Symfony2-QuickTour, informatyka
[ Pobierz całość w formacie PDF ]
The Quick Tour
What could be better to make up your own mind than to try out Symfony yourself? Aside from
a little time, it will cost you nothing. Step by step you will explore the Symfony universe. Be
careful, Symfony can become addictive from the very first encounter!
Chapter 1
The Big Picture
Start using Symfony2 in 10 minutes! This chapter will walk you through some of the most important
concepts behind Symfony2 and explain how you can get started quickly by showing you a simple project
in action.
If you've used a web framework before, you should feel right at home with Symfony2. If not, welcome to
a whole new way of developing web applications!
Want to learn why and when you need to use a framework? Read the "
document.
Downloading Symfony2
First, check that you have installed and configured a Web server (such as Apache) with PHP 5.3.2 or
higher.
Ready? Start by downloading the "
Symfony2 Standard Edition
1
", a Symfony
that is
preconfigured for the most common use cases and also contains some code that demonstrates how to use
Symfony2 (get the archive with the
vendors
included to get started even faster).
After unpacking the archive under your web server root directory, you should have a
Symfony/
directory
that looks like this:
www/ <- your web root directory
Symfony/ <- the unpacked archive
app/
cache/
config/
logs/
Resources/
bin/
src/
Acme/
1.
PDF brought to you by Sensio Labs
The Symfony2 Quick Tour | Chapter 1: The Big Picture | 2
vendor/
symfony/
doctrine/
...
DemoBundle/
Controller/
Resources/
...
web/
app.php
...
If you downloaded the Standard Edition
without vendors
, simply run the following command to
download all of the vendor libraries:
php bin/vendors install
Checking the Configuration
Symfony2 comes with a visual server configuration tester to help avoid some headaches that come from
Web server or PHP misconfiguration. Use the following URL to see the diagnostics for your machine:
If there are any outstanding issues listed, correct them. You might also tweak your configuration by
following any given recommendations. When everything is fine, click on "
Bypass configuration and go to
the Welcome page
" to request your first "real" Symfony2 webpage:
Symfony2 should welcome and congratulate you for your hard work so far!
../_images/welcome.jpg
Understanding the Fundamentals
One of the main goals of a framework is to ensure
Separation of Concerns
2
. This keeps your code
organized and allows your application to evolve easily over time by avoiding the mixing of database calls,
HTML tags, and business logic in the same script. To achieve this goal with Symfony, you'll first need to
learn a few fundamental concepts and terms.
Want proof that using a framework is better than mixing everything in the same script? Read the
"
chapter of the book.
The distribution comes with some sample code that you can use to learn more about the main Symfony2
concepts. Go to the following URL to be greeted by Symfony2 (replace
Fabien
with your first name):
../_images/hello_fabien.png
2.
PDF brought to you by Sensio Labs
The Symfony2 Quick Tour | Chapter 1: The Big Picture | 3
What's going on here? Let's dissect the URL:
•
app_dev.php
: This is a
. It is the unique entry point of the application and it
responds to all user requests;
•
/demo/hello/Fabien
: This is the
virtual path
to the resource the user wants to access.
Your responsibility as a developer is to write the code that maps the user's
request
(
/demo/hello/Fabien
)
to the
resource
associated with it (the
Hello Fabien!
HTML page).
Routing
Symfony2 routes the request to the code that handles it by trying to match the requested URL against
some configured patterns. By default, these patterns (called routes) are defined in the
app/config/
routing.yml
configuration file. When you're in the
dev
environment
- indicated by the app_**dev**.php
front controller - the
app/config/routing_dev.yml
configuration file is also loaded. In the Standard
Edition, the routes to these "demo" pages are placed in that file:
# app/config/routing_dev.yml
_welcome:
pattern: /
defaults: { _controller: AcmeDemoBundle:Welcome:index }
_demo:
resource: "@AcmeDemoBundle/Controller/DemoController.php"
type: annotation
prefix: /demo
# ...
The first three lines (after the comment) define the code that is executed when the user requests the
"
/
" resource (i.e. the welcome page you saw earlier). When requested, the
AcmeDemoBundle:Welcome:index
controller will be executed. In the next section, you'll learn exactly what that means.
The Symfony2 Standard Edition uses
YAML
3
for its configuration files, but Symfony2 also supports
XML, PHP, and annotations natively. The different formats are compatible and may be used
interchangeably within an application. Also, the performance of your application does not depend
on the configuration format you choose as everything is cached on the very first request.
Controllers
A controller is a fancy name for a PHP function or method that handles incoming
requests
and returns
responses
(often HTML code). Instead of using the PHP global variables and functions (like
$_GET
or
header()
) to manage these HTTP messages, Symfony uses objects:
Request
4
and
Response
5
. The simplest
possible controller might create the response by hand, based on the request:
use Symfony\Component\HttpFoundation\Response;
$name = $request->query->get('name');
return new Response('Hello '.$name, 200, array('Content-Type' => 'text/plain'));
3.
PDF brought to you by Sensio Labs
The Symfony2 Quick Tour | Chapter 1: The Big Picture | 4
Symfony2 embraces the HTTP Specification, which are the rules that govern all communication on
the Web. Read the "
" chapter of the book to learn more about
this and the added power that this brings.
Symfony2 chooses the controller based on the
_controller
value from the routing configuration:
AcmeDemoBundle:Welcome:index
. This string is the controller
logical name
, and it references the
indexAction
method from the
Acme\DemoBundle\Controller\WelcomeController
class:
// src/Acme/DemoBundle/Controller/WelcomeController.php
namespace Acme\DemoBundle\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
class WelcomeController extends Controller
{
public function indexAction()
{
return $this->render('AcmeDemoBundle:Welcome:index.html.twig');
}
}
You could have used the full class and method name -
Acme\DemoBundle\Controller\WelcomeController::indexAction
- for the
_controller
value. But if
you follow some simple conventions, the logical name is shorter and allows for more flexibility.
The
WelcomeController
class extends the built-in
Controller
class, which provides useful shortcut
methods, like the
render()
6
method that loads and renders a template
(
AcmeDemoBundle:Welcome:index.html.twig
). The returned value is a Response object populated with the
rendered content. So, if the needs arise, the Response can be tweaked before it is sent to the browser:
public function indexAction()
{
$response = $this->render('AcmeDemoBundle:Welcome:index.txt.twig');
$response->headers->set('Content-Type', 'text/plain');
}
return $response;
No matter how you do it, the end goal of your controller is always to return the
Response
object that
should be delivered back to the user. This
Response
object can be populated with HTML code, represent
a client redirect, or even return the contents of a JPG image with a
Content-Type
header of
image/jpg
.
Extending the
Controller
base class is optional. As a matter of fact, a controller can be a plain PHP
function or even a PHP closure. "
" chapter of the book tells you everything about
Symfony2 controllers.
The template name,
AcmeDemoBundle:Welcome:index.html.twig
, is the template
logical name
and it
references the
Resources/views/Welcome/index.html.twig
file inside the
AcmeDemoBundle
(located at
src/
Acme/DemoBundle
). The bundles section below will explain why this is useful.
Now, take a look at the routing configuration again and find the
_demo
key:
PDF brought to you by Sensio Labs
The Symfony2 Quick Tour | Chapter 1: The Big Picture | 5
[ Pobierz całość w formacie PDF ]