How Do Applications Work?

You are currently reading the basic document of the Nette documentation. You will learn all the principle of web applications. Nice from A to Z, from the moment of birth until the last breath of the PHP script. After reading you will know:

how it all works
what is Bootstrap, Presenter and DI container
what the directory structure looks like

Directory Structure

Open a skeleton example of a web application called WebProject and you can watch the files being written about.

The directory structure looks something like this:

web-project/
├── app/                      ← directory with application
│   ├── Core/                 ← basic necessary classes
│   │   └── RouterFactory.php ← configuration of URL addresses
│   ├── Presentation/         ← presenters, templates & co.
│   │   ├── @layout.latte     ← template of shared layout
│   │   └── Home/             ← Home presenter directory
│   │       ├── HomePresenter.php ← Home presenter class
│   │       └── default.latte ← template for action default
│   └── Bootstrap.php         ← booting class Bootstrap
├── bin/                      ← scripts for the command line
├── config/                   ← configuration files
│   ├── common.neon
│   └── services.neon
├── log/                      ← error logs
├── temp/                     ← temporary files, cache, …
├── vendor/                   ← libraries installed by Composer
│   ├── ...
│   └── autoload.php          ← autoloading of libs installed by Composer
├── www/                      ← public directory, document root of project
│   ├── .htaccess             ← mod_rewrite rules etc
│   └── index.php             ← initial file that launches the application
└── .htaccess                 ← prohibits access to all directories except www

You can modify the directory structure however you like, rename or move folders – it's completely flexible. Nette also features smart autodetection and automatically recognizes the application location including its URL base.

For slightly larger applications, we can organize presenter and template folders into subdirectories and group classes into namespaces, which we call modules.

The www/ directory is the public directory or document-root of the project. You can rename it without having to set anything else on the application side. You just need to configure the hosting so that the document-root goes to this directory.

You can also download the WebProject directly, including Nette, using Composer:

composer create-project nette/web-project

On Linux or macOS, set the write permissions for directories log/ and temp/.

The WebProject application is ready to run, there is no need to configure anything else at all and you can view it directly in the browser by accessing the folder www/.

HTTP Request

It all begins when a user opens the page in a browser and browser knocks on the server with an HTTP request. The request goes to a PHP file located in the public directory www/, which is index.php. Let's suppose that this is a request to https://example.com/product/123. Thanks to the appropriate server settings, this URL is also mapped to the index.php file and will be executed.

Its task is:

initialize the environment
get the factory
launch the Nette application that handles the request

What kind of factory? We do not produce tractors, but websites! Hold on, it'll be explained right away.

By “environment initialization” we mean, for example, activating Tracy, which is a fantastic tool for logging and error visualization. On production servers it logs errors, while on development it displays them directly. Therefore, initialization includes determining whether the website runs in production or development mode. For this, Nette uses smart autodetection: if you run the site on localhost, it operates in development mode. No configuration is needed and the application is ready for both development and production deployment. These steps are performed and detailed in the Bootstrap class chapter.

The third point (yes, we skipped the second, but we will return to it) is to start the application. The handling of HTTP requests in Nette is done by the class Nette\Application\Application (hereinafter referred to as the Application), so when we say “run an application”, we mean to call a method with the name run() on an object of this class.

Nette is a mentor who guides you to write clean applications by proven methodologies. And the most proven is called dependency injection, abbreviated DI. At the moment we don't want to burden you with explaining DI, since there is a separate chapter, the important thing here is that the key objects will usually be created by a factory for objects called DI container (abbreviated DIC). Yes, this is the factory that was mentioned a while ago. And it also creates the Application object for us, so we need a container first. We get it using the Configurator class and let it produce Application object, call the method run() and this starts Nette application. This is exactly what happens in the index.php file.

Nette Application

The Application class has a single task: to respond to an HTTP request.

Applications written in Nette are divided into many so-called presenters (in other frameworks you may come across the term controller, which is the same), which are classes representing a specific website page: eg homepage; product in e-shop; sign-in form; sitemap feed, etc. The application can have from one to thousands of presenters.

The application starts by asking the so-called router to decide which of the presenters to pass the current request for processing. The router decides whose responsibility it is. It looks at the input URL https://example.com/product/123 and, based on how it is set up, decides that this is a job, for example, for presenter Product, who wants to show a product with id: 123 as an action. It is a good habit to write a pairs of presenter + action separated by a colon as Product:show.

So the router transformed the URL into a pair Presenter:action + parameters, in our case Product:show + id: 123. You can see how a router looks like in file app/Core/RouterFactory.php and we will describe it in detail in chapter Routing.

Let's move on. The application already knows the name of the presenter and can continue. By creating an object ProductPresenter, which is the code of presenter Product. More precisely, it asks the DI container for creating the presenter, because producting objects is its job.

The presenter might look like this:

class ProductPresenter extends Nette\Application\UI\Presenter
{
	public function __construct(
		private ProductRepository $repository,
	) {
	}

	public function renderShow(int $id): void
	{
		// we obtain data from the model and pass it to the template
		$this->template->product = $this->repository->getProduct($id);
	}
}

The request is handled by the presenter. And the task is clear: do action show with id: 123. Which in the language of presenters means that the method renderShow() is called and in the parameter $id it gets 123.

A presenter can handle multiple actions, ie have multiple methods render<Action>(). But we recommend designing presenters with one or as few actions as possible.

So, the method renderShow(123) was called, whose code is fictional example, but you can see on it how the data is passed to the template, ie by writing to $this->template.

Subsequently, the presenter returns the answer. This can be an HTML page, an image, an XML document, sending a file from disk, JSON or redirecting to another page. Importantly, if we do not explicitly say how to respond (which is the case of ProductPresenter), the answer will be to render the template with an HTML page. Why? Well, because in 99% of cases we want to draw a template, so the presenter takes this behavior as the default and wants to make our work easier. That's Nette's point.

We don't even need to specify which template to render; the framework will deduce the path itself. In the case of the show action, it simply tries to load the show.latte template in the directory with the ProductPresenter class. It also attempts to find the layout in the @layout.latte file (more about template searching).

Subsequently, the templates are rendered. This completes the task of the presenter and the entire application, and the work is done. If the template did not exist, a 404 error page would be returned. You can read more about presenters on the page Presenters.

Just to be sure, let's try to recap the whole process with a slightly different URL:

the URL will be https://example.com
we boot the application, create a container and run Application::run()
the router decodes the URL as a pair Home:default
an HomePresenter object is created
method renderDefault() is called (if exists)
a template default.latte with a layout @layout.latte is rendered

You may have come across a lot of new concepts now, but we believe they make sense. Creating applications in Nette is a breeze.

Templates

When it comes to the templates, Nette uses the Latte template system. That's why the files with templates ends with .latte. Latte is used because it is the most secure template system for PHP, and at the same time the most intuitive system. You don't have to learn much new, you just need to know PHP and a few Latte tags. You will find out everything in the documentation.

In template we create a links to other presenters & actions as follows:

<a n:href="Product:show $productId">product detail</a>

Simply write the familiar Presenter:action pair instead of the real URL and include any parameters. The trick is n:href, which says that this attribute will be processed by Nette. And it will generate:

<a href="/product/456">product detail</a>

The previously mentioned router is in charge of generating the URL. In fact, routers in Nette are unique in that they can perform not only transformations from a URL to a pair of presenter:action, but also vice versa generate a URL from the name of the presenter + action + parameters. Thanks to this, in Nette you can completely change the form of the URL in the whole finished application without changing a single character in the template or presenter just by modifying the router. And thanks to this, the so-called canonization works, which is another unique feature of Nette, which improves SEO (optimization of searchability on the internet) by automatically preventing the existence of duplicate content at different URLs. Many programmers find this amazing.

Interactive Components

We have one more thing to tell you about presenters: they have a built-in component system. Older of you may remember something similar from Delphi or ASP.NET Web Forms. React or Vue.js is built on something remotely similar. In the world of PHP frameworks, this is a completely unique feature.

Components are separate reusable units that we place into pages (ie presenters). They can be forms, datagrids, menus, polls, in fact anything that makes sense to use repeatedly. We can create our own components or use some of the huge range of opensource components.

Components fundamentally change the approach to application development. They will open up new possibilities for composing pages from pre-defined units. And they have something in common with Hollywood.

DI Container and Configuration

DI container (factory for objects) is the heart of the whole application.

Don't worry, it's not a magical black box, as it might seem from the previous words. Actually, it's one pretty boring PHP class generated by Nette and stored in a cache directory. It has a lot of methods named as createServiceAbcd() and each of them creates and returns an object. Yes, there is also a method createServiceApplication() that will produce Nette\Application\Application, which we needed in the file index.php to run the application. And there are methods for producing individual presenters. And so on.

The objects that the DI container creates are called services for some reason.

What is really special about this class is that it is not programmed by you, but by the framework. It actually generates the PHP code and saves it to disk. You just give instructions on what objects the container should be able to produce and how exactly. And these instructions are written in configuration files in the NEON format and therefore have the extension .neon.

The configuration files are used purely to instruct the DI container. So, for example, if I specify the expiration: 14 days option in the session section, the DI container when creating the Nette\Http\Session object representing the session will call its method setExpiration('14 days'), and thus configuration becomes a reality.

There is a whole chapter ready for you, describing what can be configured and how to define your own services.

Once you get into the creation of services, you will come across the word autowiring. This is a gadget that will make your life incredibly easier. It can automatically pass objects where you need them (in the constructors of your classes, for example) without having to do anything. You will find that the DI container in Nette is a small miracle.

What Next?

We went through the basic principles of applications in Nette. So far, very superficially, but you will soon delve into the depths and eventually create wonderful web applications. Where to continue? Have you tried the tutorial Create Your First Application?

In addition to the above, Nette has a whole arsenal of useful classes, database layer, etc. Try purposely just click through documentation. Or visit blog. You will discover a lot of interesting things.

Let the framework bring you a lot of joy 💙