What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Symfony2 Essentials

Chapter 1. The Symfony Framework – Installation and Configuration

The Symfony framework is currently one of the most popular PHP frameworks existing within the PHP developer's environment. Version 2, which was released a few years ago, has been a great improvement, and in my opinion was one of the key elements for making the PHP ecosystem suitable for larger enterprise projects. The framework version 2.0 not only required the modern PHP version (minimal version required for Symfony is PHP 5.3.8), but also uses state-of-the-art technology — namespaces and anonymous functions. Authors also put a lot of efforts to provide long term support and to minimize changes, which break the compatibility between versions. Also, Symfony forced developers to use a few useful design concepts. The key one, introduced in Symfony, was DependencyInjection.

Note

In most cases, the book will refer to the framework as Symfony2. If you want to look over the Internet or Google about this framework, apart from using Symfony keyword you may also try to use the Symfony2 keyword This was the way recommended some time ago by one of the creators to make searching or referencing to the specific framework version easier in future.

Installing Symfony2 using an installer

To install Symfony2 through an installer, go to the Symfony website at http://symfony.com/download, and install the Symfony2 installer by issuing the following commands:

$ sudo curl -LsS http://symfony.com/installer -o /usr/local/bin/symfony
$ sudo chmod +x /usr/local/bin/symfony

After this, you can install Symfony by just typing the following command:

$ symfony new <new_project_folder>

To install the Symfony2 framework for a to-do application, execute the following command:

$ symfony new todoapp

This command installs the latest Symfony2 stable version on the newly created todoapp folder, creates the Symfony2 application, and prepares some basic structure for you to work with.

After the app creation, you can verify that your local PHP is properly configured for Symfony2 by typing the following command:

$ php app/check.php

If everything goes fine, the script should complete with the following message:

[OK]
Your system is ready to run Symfony projects

Symfony2 is equipped with a standalone server. It makes development easier. If you want to run this, type the following command:

$ php app/console server:run

If everything went alright, you will see a message that your server is working on the IP 127.0.0.1 and port 8000. If there is an error, make sure you are not running anything else that is listening on port 8000. It is also possible to run the server on a different port or IP, if you have such a requirement, by adding the address and port as a parameter, that is:

$ php app/console server:run 127.0.0.1:8080

If everything works, you can now type the following:

http://127.0.0.1:8000/

Now, you will visit Symfony's welcome page.

This page presents you with a nice welcome information and useful documentation link.

Tip

Downloading the example code

You can download the example code files for all Packt books you have purchased from your account at http://www.packtpub.com. If you have purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files directly e-mailed to you.

The Symfony2 directory structure

Let's dive in to the initial directory structure within the typical Symfony application. Here it is:

app
bin
src
vendor
web

While Symfony2 is very flexible in terms of directory structure, it is recommended to keep the basic structure mentioned earlier.

The following table describes their purpose:

Directory	Used for
`app`	This holds information about general configuration, routing, security configuration, database parameters, and many others. It is also the recommended place for putting new view files. This directory is a starting point.
`bin`	It holds some helper executables. It is not really important during the development process, and rarely modified.
`src`	This directory holds the project PHP code (usually your bundles).
`vendor`	These are third-party libraries used within the project. Usually, this directory contains all the open source third-party bundles, libraries, and other resources. It's worth to mention that it's recommended to keep the files within this directory outside the versioning system. It means that you should not modify them under any circumstances. Fortunately, there are ways to modify the code, if it suits your needs more. This will be demonstrated when we implement user management within our to-do application.
`web`	This is the directory that is accessible through the web server. It holds the main entry point to the application (usually the `app.php` and `app_dev.php` files), CSS files, JavaScript files, and all the files that need to be available through the web server (user uploadable files).

So, in most cases, you will be usually modifying and creating the PHP files within the src/ directory, the view and configuration files within the app/ directory, and the JS/CSS files within the web/ directory.

The main directory also holds a few files as follows:

.gitignore
README.md
composer.json
composer.lock

The .gitignore file's purpose is to provide some preconfigured settings for the Git repository, while the composer.json and composer.lock files are the files used by the composer dependency manager.

What is a bundle?

Within the Symfony2 application, you will be using the "bundle" term quite often. Bundle is something similar to plugins. So it can literally hold any code controllers, views, models, and services. A bundle can integrate other non-Symfony2 libraries and hold some JavaScript/CSS code as well. We can say that almost everything is a bundle in Symfony2; even some of the core framework features together form a bundle. A bundle usually implements a single feature or functionality. The code you are writing when you write a Symfony2 application is also a bundle.

There are two types of bundles. The first kind of bundle is the one you write within the application, which is project-specific and not reusable. For this purpose, there is a special bundle called AppBundle created for you when you install the Symfony2 project.

Also, there are reusable bundles that are shared across the various projects either written by you, your team, or provided by a third-party vendors. Your own bundles are usually stored within the src/ directory, while the third-party bundles sit within the vendor/ directory.

The vendor directory is used to store third-party libraries and is managed by the composer. As such, it should never be modified by you.

There are many reusable open source bundles, which help you to implement various features within the application. You can find many of them to help you with User Management, writing RESTful APIs, making better documentation, connecting to Facebook and AWS, and even generating a whole admin panel. There are tons of bundles, and everyday brings new ones.

Note

If you want to explore open source bundles, and want to look around what's available, I recommend you to start with the http://knpbundles.com/ website.

The bundle name is correlated with the PHP namespace. As such, it needs to follow some technical rules, and it needs to end with the Bundle suffix. A few examples of correct names are AppBundle and AcmeDemoBundle, CompanyBlogBundle or CompanySocialForumBundle, and so on.

Composer

Symfony2 is built based on components, and it would be very difficult to manage the dependencies between them and the framework without a dependency manager. To make installing and managing these components easier, Symfony2 uses a manager called composer.

You can get it from the https://getcomposer.org/ website. The composer makes it easy to install and check all dependencies, download them, and integrate them to your work. If you want to find additional packages that can be installed with the composer, you should visit https://packagist.org/. This site is the main composer repository, and contains information about most of the packages that are installable with the composer.

To install the composer, go to https://getcomposer.org/download/ and see the download instruction. The download instruction should be similar to the following:

$ curl -sS https://getcomposer.org/installer | php

If the download was successful, you should see the composer.phar file in your directory. Move this to the project location in the same place where you have the composer.json and composer.lock files. You can also install it globally, if you prefer to, with these two commands:

$ curl -sS https://getcomposer.org/installer | php
$ sudo mv composer.phar /usr/local/bin/composer

You will usually need to use only three composer commands: require, install, and update.

The require command is executed when you need to add a new dependency. The install command is used to install the package. The update command is used when you need to fetch the latest version of your dependencies as specified within the JSON file.

The difference between install and update is subtle, but very important. If you are executing the update command, your composer.lock file gets updated with the version of the code you just fetched and downloaded. The install command uses the information stored in the composer.lock file and the fetch version stored in this file.

When to use install? For example, if you deploy the code to the server, you should use install rather than update, as it will deploy the version of the code stored in composer.lock, rather than download the latest version (which may be untested by you). Also, if you work in a team and you just got an update through Git, you should use install to fetch the vendor code updated by other developers.

You should use the update command if you want to check whether there is an updated version of the package you have installed, that is, whether a new minor version of Symfony2 will be released, then the update command will fetch everything.

As an example, let's install one extra package for user management called FOSUserBundle (FOS is a shortcut of Friends of Symfony). We will only install it here; we will not configure it. We will configure it in the chapter focused on security and user management.

To install FOSUserBundle, we need to know the correct package name and version. The easiest way is to look in the packagist site at https://packagist.org/ and search for the package there. If you type fosuserbundle, the search should return a package called friendsofsymfony/user-bundle as one of the top results. The download counts visible on the right-hand side might be also helpful in determining how popular the bundle is.

If you click on this, you will end up on the page with the detailed information about that bundle, such as homepage, versions, and requirements of the package.

Type the following command:

$ php composer.phar require friendsofsymfony/user-bundle ^1.3
Using version ^1.3 for friendsofsymfony/user-bundle
./composer.json has been updated
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Installing friendsofsymfony/user-bundle (v1.3.6)
    Loading from cache

friendsofsymfony/user-bundle suggests installing willdurand/propel-typehintable-behavior (Needed when using the propel implementation)
Writing lock file
Generating autoload files
...

Which version of the package you choose is up to you. If you are interested in package versioning standards, see the composer website at https://getcomposer.org/doc/01-basic-usage.md#package-versions to get more information on it.

The composer holds all the configurable information about dependencies and where to install them in a special JSON file called composer.json. Let's take a look at this:

{
"name": "wbancer/todoapp",
"license": "proprietary",
"type": "project",
"autoload": {
  "psr-0": {
    "": "src/",
    "SymfonyStandard": "app/SymfonyStandard/"
  }
},
"require": {
  "php": ">=5.3.9",
  "symfony/symfony": "2.7.*",
  "doctrine/orm": "~2.2,>=2.2.3,<2.5",
  // [...]
  "incenteev/composer-parameter-handler": "~2.0",
  "friendsofsymfony/user-bundle": "^1.3"
},
"require-dev": {
  "sensio/generator-bundle": "~2.3"
},
"scripts": {
  "post-root-package-install": [
  "SymfonyStandard\\Composer::hookRootPackageInstall"
  ],
  "post-install-cmd": [
  // post installation steps
  ],
  "post-update-cmd": [
  // post update steps
  ]
},
"config": {
  "bin-dir": "bin"
},
"extra": {
  // [...]
}
}

The most important section is the one with the require key. It holds all the information about the packages we want to use within the project. The key scripts contain a set of instructions to run post-install and post-update. The extra key in this case contains some settings specific to the Symfony2 framework. Note that one of the values in here points out to the parameter.yml file. This file is the main file holding the custom machine-specific parameters. The meaning of the other keys is rather obvious.

If you look into the vendor/ directory, you will notice that our package has been installed in the vendor/friendsofsymfony/user-bundle directory.

The configuration files

Each application has a need to hold some global and machine-specific parameters and configurations. Symfony2 holds configuration within the app/config directory and it is split into a few files as follows:

config.yml
config_dev.yml
config_prod.yml
config_test.yml
parameters.yml
parameters.yml.dist
routing.yml
routing_dev.yml
security.yml
services.yml

All the files except the parameters.yml* files contain global configuration, while the parameters.yml file holds machine-specific information such as database host, database name, user, password, and SMTP configuration.

The default configuration file generated by the new Symfony command will be similar to the following one.

This file is auto-generated during the composer install:

parameters:
    database_driver: pdo_mysql
    database_host: 127.0.0.1
    database_port: null
    database_name: symfony
    database_user: root
    database_password: null
    mailer_transport: smtp
    mailer_host: 127.0.0.1
    mailer_user: null
    mailer_password: null
    secret: 93b0eebeffd9e229701f74597e10f8ecf4d94d7f

As you can see, it mostly holds the parameters related to database, SMTP, locale settings, and secret key that are used internally by Symfony2. Here, you can add your custom parameters using the same syntax. It is a good practice to keep machine-specific data such as passwords, tokens, api-keys, and access keys within this file only. Putting passwords in the general config.yml file is considered as a security risk bug.

The global configuration file (config.yml) is split into a few other files called routing*.yml that contain information about routing on the development and production configuration. The file called as security.yml holds information related to authentication and securing the application access. Note that some files contains information for development, production, or test mode. You can define your mode when you run Symfony through the command-line console and when you run it through the web server. In most cases, while developing you will be using the dev mode.

The Symfony2 console

To finish this chapter, let's take a look at the Symfony console script. We used it before to fire up the development server, but it offers more. Execute the following:

$ php app/console

You will see a list of supported commands. Each command has a short description. Each of the standard commands come with help, so I will not be describing each of them here, but it is worth to mention a few commonly used ones:

Command	Description
`app/console: cache:clear`	Symfonys in production uses a lot of caching. Therefore, if you need to change values within a template (Twig) or within configuration files while in production mode, you will need to clear the cache. Cache is also one of the reasons why it's worth to work in the development mode.
`app/console container:debug`	Displays all configured public services
`app/console router:debug`	Displays all routing configuration along with method, scheme, host, and path.
`app/console security:check`	Checks your composer and packages version against known security vulnerabilities. You should run this command regularly.

You can, of course, write your own Symfony2 commands and we will do this within the forthcoming chapters.

Description

Symfony is a free and open source PHP MVC web application development framework, which helps you create and maintain web applications and replace recurrent coding tasks. It integrates with an independent library, PHPUnit, to give you a rich testing framework. It is one of the best and most popular frameworks available on the market. Popular projects such as Drupal, Laravel, and phpBB also use Symfony. Its well-organized structure, clean code, and good programming practices make web development a breeze. Symfony2 Essentials will guide you through the process of creating a sample web application with Symfony2. You will create a To-Do application, using a few of the most commonly used Symfony2 components, and discover how to perform these development tasks efficiently. This book introduces you to the Symfony framework with a quick installation guide and a brief explanation of its key features including the MVC architecture, twig templating, dependency injection, and more. You will learn to manage dependencies, create controllers, views, and API calls, and secure your application. Next, you will go through the steps that are common for most web applications, which include writing CRUD and AJAX, handling forms, validation, translations, and the command-line interface, and e-mail sending features. The book ends with best practices, debugging, profiling, and deployment procedures. By the end of this book, you will have learned how to combine a Symfony2 framework with other open source code to speed up the development process.

What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Frequently bought together

zł133.99

zł177.99

Extending Symfony2 Web Application Framework

zł157.99

Total zł 469.97

Filter reviews by

All

Amazon verified reviews

Madchu Oct 08, 2017

It took me two attempts to get through this, but that was mainly because I've been trying to learn everything and Symfony, at first glance, was a little daunting. The author covers things well, though, so I'm glad I gave this a second go. it complements well with an online course on Symfony from KNP University which is the best I've found so far on the subject.

Amazon Verified review

AlberT Nov 08, 2016

Un libro che scorre facilmente, affronta più o meno tutti gli aspetti del ciclo di vita di una applicazione symfony ..Nulla di particolarmente illuminante, ma sicuramente una buona infarinatura generale.

D. Cullen Feb 21, 2017

Mistakes in the examples make it tricky for someone completely new to symfony, but otherwise ok.

Spurgeon Jun 07, 2016

Good book for experienced PHP developers to acquaint themselves with Symfony. Considering that Symfony 3 is out some time back, this might be slightly outdated. Nevertheless, the foundations / fundamentals hold good.

Amazon Customer Feb 15, 2016

very basic book, you could find better guides on the web.

Symfony2 Essentials:

What do you get with Print?

Symfony2 Essentials

Chapter 1. The Symfony Framework – Installation and Configuration

Note

Key reasons to choose Symfony2

The history of Symfony

Note

Installation

Note

Installing Symfony2 using an installer

Tip

The Symfony2 directory structure

What is a bundle?

Note

Composer

The configuration files

The Symfony2 console

Summary

Page 1 of 9

Description

Who is this book for?

Product Details

What do you get with Print?

Product Details

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs

Symfony2 Essentials:

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Description

Who is this book for?

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs