single: Create your First Page in Symfony
Creating a new page - whether it's an HTML page or a JSON endpoint - is a simple two-step process:
- Create a route: A route is the URL (e.g.
/about) to your page and points to a controller; - Create a controller: A controller is the PHP function you write that builds the page. You take the incoming request information and use it to create a Symfony
Responseobject, which can hold HTML content, a JSON string or even a binary file like an image or PDF.
Do you prefer video tutorials? Check out the Joyful Development with Symfony screencast series from KnpUniversity.
Symfony embraces the HTTP Request-Response lifecycle. To find out more, see /introduction/http_fundamentals.
single: Page creation; Example
Tip
Before continuing, make sure you've read the Setup </setup> article and can access your new Symfony app in the browser.
Suppose you want to create a page - /lucky/number - that generates a lucky (well, random) number and prints it. To do that, create a "Controller class" and a "controller" method inside of it that will be executed when someone goes to /lucky/number:
// src/AppBundle/Controller/LuckyController.php
namespace AppBundle\Controller;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
class LuckyController
{
/**
* @Route("/lucky/number")
*/
public function numberAction()
{
$number = mt_rand(0, 100);
return new Response(
'<html><body>Lucky number: '.$number.'</body></html>'
);
}
}Before diving into this, test it out! If you are using PHP's internal web server go to:
Tip
If you're using the built-in PHP web-server, you can omit the app_dev.php part of the URL.
If you see a lucky number being printed back to you, congratulations! But before you run off to play the lottery, check out how this works. Remember the two steps to creating a page?
- Create a route: The
@RouteabovenumberAction()is the route: it defines the URL pattern for this page. You'll learn more aboutrouting </routing>in its own section, including how to make variable URLs; - Create a controller: The method below the route -
numberAction()- is called the controller. This is a function where you build the page and ultimately return aResponseobject. You'll learn more aboutcontrollers </controller>in their own section, including how to return JSON responses.
If your page is working, then you should also see a bar along the bottom of your browser. This is called the Web Debug Toolbar: and it's your debugging best friend. You'll learn more about all the information it holds along the way, but feel free to experiment: hover over and click the different icons to get information about routing, performance, logging and more.
If you're returning HTML from your controller, you'll probably want to render a template. Fortunately, Symfony comes with Twig: a templating language that's easy, powerful and actually quite fun.
First, make sure that LuckyController extends Symfony's base Symfony\\Bundle\\FrameworkBundle\\Controller\\Controller class:
// src/AppBundle/Controller/LuckyController.php
// ...
// --> add this new use statement
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class LuckyController extends Controller
{
// ...
}Now, use the handy render() function to render a template. Pass it our number variable so we can render that:
// src/AppBundle/Controller/LuckyController.php
// ...
class LuckyController extends Controller
{
/**
* @Route("/lucky/number")
*/
public function numberAction()
{
$number = mt_rand(0, 100);
return $this->render('lucky/number.html.twig', array(
'number' => $number,
));
}
}Finally, template files should live in the app/Resources/views directory. Create a new app/Resources/views/lucky directory with a new number.html.twig file inside:
{# app/Resources/views/lucky/number.html.twig #}
<h1>Your lucky number is {{ number }}</h1>The {{ number }} syntax is used to print variables in Twig. Refresh your browser to get your new lucky number!
In the /templating article, you'll learn all about Twig: how to loop, render other templates and leverage its powerful layout inheritance system.
Great news! You've already worked inside the two most important directories in your project:
app/Contains things like configuration and templates. Basically, anything that is not PHP code goes here.
src/Your PHP code lives here.
99% of the time, you'll be working in src/ (PHP files) or app/ (everything else). As you keep reading, you'll learn what can be done inside each of these.
So what about the other directories in the project?
bin/The famous
bin/consolefile lives here (and other, less important executable files).tests/The automated tests (e.g. Unit tests) for your application live here.
var/This is where automatically-created files are stored, like cache files (
var/cache/), logs (var/logs/) and sessions (var/sessions/).vendor/Third-party (i.e. "vendor") libraries live here! These are downloaded via the Composer package manager.
web/This is the document root for your project: put any publicly accessible files here (e.g. CSS, JS and images).
Your Symfony application comes pre-installed with a collection of bundles, like FrameworkBundle and TwigBundle. Bundles are similar to the idea of a plugin, but with one important difference: all functionality in a Symfony application comes from a bundle.
Bundles are registered in your app/AppKernel.php file (a rare PHP file in the app/ directory) and each gives you more tools, sometimes called services:
class AppKernel extends Kernel
{
public function registerBundles()
{
$bundles = array(
new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
new Symfony\Bundle\TwigBundle\TwigBundle(),
// ...
);
// ...
return $bundles;
}
// ...
}For example, TwigBundle is responsible for adding the Twig tool to your app!
Eventually, you'll download and add more third-party bundles to your app in order to get even more tools. Imagine a bundle that helps you create paginated lists. That exists!
You can control how your bundles behave via the app/config/config.yml file. That file - and other details like environments & parameters - are discussed in the /configuration article.
Congrats! You're already starting to master Symfony and learn a whole new way of building beautiful, functional, fast and maintainable apps.
Ok, time to finish mastering the fundamentals by reading these articles:
/routing/controller/templating
Then, learn about other important topics like the service container </service_container>, the form system </forms>, using Doctrine </doctrine> (if you need to query a database) and more!
Have fun!
routing
introduction/*