The Big Picture

The Big Picture

Start using Symfony in 10 minutes! Really! That's all you need to understand the most important concepts and start building a real project!

If you've used a web framework before, you should feel right at home with Symfony. If not, welcome to a whole new way of developing web applications. Symfony embraces best practices, keeps backwards compatibility (Yes! Upgrading is always safe & easy!) and offers long-term support.

Downloading Symfony

First, make sure you've installed Composer and have PHP 7.1.3 or higher.

Ready? In a terminal, run:

1
$ composer create-project symfony/skeleton quick_tour

This creates a new quick_tour/ directory with a small, but powerful new Symfony application:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
quick_tour/
├─ .env
├─ .env.dist
├─ bin/console
├─ composer.json
├─ composer.lock
├─ config/
├─ public/index.php
├─ src/
├─ symfony.lock
├─ var/
└─ vendor/

Can we already load the project in a browser? Of course! You can setup Nginx or Apache and configure their document root to be the public/ directory. But, for development, Symfony has its own server. Install and run it with:

1
2
$ composer require server --dev
$ php bin/console server:start

Try your new app by going to http://localhost:8000 in a browser!

../_images/no_routes_page.png

Fundamentals: Route, Controller, Response

Our project only has about 15 files, but it's ready to become an sleek API, a robust web app, or a microservice. Symfony starts small, but scales with you.

But before we go too far, let's dig into the fundamentals by building our first page.

Start in config/routes.yaml: this is where we can define the URL to our new page. Uncomment the example that already lives in the file:

1
2
3
4
# config/routes.yaml
index:
    path: /
    controller: 'App\Controller\DefaultController::index'

This is called a route: it defines the URL to your page (/) and the "controller": the function that will be called whenever anyone goes to this URL. That function doesn't exist yet, so let's create it!

In src/Controller, create a new DefaultController class and an index method inside:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;

class DefaultController
{
    public function index()
    {
        return new Response('Hello!');
    }
}

That's it! Try going to the homepage: http://localhost:8000/. Symfony sees that the URL matches our route and then executes the new index() method.

A controller is just a normal function with one rule: it must return a Symfony Response object. But that response can contain anything: simple text, JSON or a full HTML page.

But the routing system is much more powerful. So let's make the route more interesting:

1
2
3
4
5
# config/routes.yaml
index:
-     path: /
+     path: /hello/{name}
    controller: 'App\Controller\DefaultController::index'

The URL to this page has changed: it is now /hello/*: the {name} acts like a wildcard that matches anything. And it gets better! Update the controller too:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;

class DefaultController
{
-     public function index()
+     public function index($name)
    {
-         return new Response('Hello!');
+         return new Response("Hello $name!");
    }
}

Try the page out by going to http://localhost:8000/hello/Symfony. You should see: Hello Symfony! The value of the {name} in the URL is available as a $name argument in your controller.

But this can be even simpler! So let's install annotations support:

1
$ composer require annotations

Now, comment-out the YAML route by adding the # character:

1
2
3
4
# config/routes.yaml
# index:
#     path: /hello/{name}
#     controller: 'App\Controller\DefaultController::index'

Instead, add the route right above the controller method:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
+ use Symfony\Component\Routing\Annotation\Route;

class DefaultController
{
+    /**
+     * @Route("/hello/{name}")
+     */
     public function index($name) {
         // ...
     }
}

This works just like before! But by using annotations, the route and controller live right next to each other. Need another page? Just add another route and method in DefaultController:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class DefaultController
{
    // ...

    /**
     * @Route("/simplicity")
     */
    public function simple()
    {
        return new Response('Simple! Easy! Great!');
    }
}

Routing can do even more, but we'll save that for another time! Right now, our app needs more features! Like a template engine, logging, debugging tools and more.

Keep reading with Flex: Compose your Application.

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.