Symfony 2 and Doctrine 2

While continuing to learn Symfony 2, I decided to describe the use of the framework in conjunction with Doctrine 2, since this is one of the most frequently asked questions. And it is worth noting Doctrine 2 also underwent major changes in comparison with the 1.x branch. By itself, the Doctrine project is so large that a description of it will probably draw on a small but interesting book. Therefore, I will only very briefly describe an example of using Doctrine 2 in Symfony 2, which allows you to figure out how to run this bundle and do it on the example of a very small and simple application.

About Doctrine 2

For a start, a brief introduction on Doctrine 2. The project is now divided into three packages:

Common
DBAL
ORM

Common - contains common components that are used in other packages.

DBAL is a database access abstraction layer.

ORM - Object Relational Mapping Tools

Doctrine 2 does not have the usual classes * Table and * Record, which were before. This also means that now the model classes do not need to inherit the * Record classes, and the table classes inherit the * Table classes from the Doctrine package. Instead, two new concepts of “Entity” and “EntityManager” are introduced. “Entity” is, roughly speaking, a model object, and “EntityManager” is a class that allows you to manage objects “Entity”, respectively. Interestingly, “Entity” can be any PHP class and should not inherit any classes from the Doctrine package.

In Doctrine 1, the models were described in the Yaml file, but now you can use Yaml, XML or Docblock Annotations for this. In one form or another, Docblock annotations probably had to be used by everyone, for example, to describe methods under a PHPDocumentor. So now you can also describe the metadata of persistent objects.

Example:

Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }
Copy Source | Copy HTML <?php /** * @Entity * @Table(name="my_model") */ class MyModel { /** * @Id @Column(name="id", type="integer") * @GeneratedValue(strategy="AUTO") */ private $id ; /** * @Column(name="title", type="string", length=255) */ private $title ; }

')

And of course you can read about all this and many other things on the Doctrine website.

We take off

I decided to consider using Doctrine 2 using a very small and very simple application. This will be the Readlater service, which allows you to save links in order to postpone reading something until later. That is, all its functionality is reduced to three simple actions:

display a list of links
add link
delete link

But I immediately ran into a small problem - and Doctrine 2 and Symfony 2 are now being actively developed and there is no question of any stability. Moreover, everything changes very often and what works today may not take off tomorrow. Often these are various little things, like transferring code to another directory. Therefore, for this application I decided to freeze the versions of the libraries used. For this, I took:

symfony-sandbox : a sandbox based on it, everything was built
symfony : a symfony fork from Jonathan Wage of the developer Doctrine
doctrine migrations : migrations
doctrine : trunk doctrine

Having collected it all together, I froze all versions on April 18, 2010 in the form in which they were and laid out with my application on github . So if you're interested, go for it.

Flew

So, the first is briefly about the structure. Approximately this type of directory:

readlater : - application directory
src
- Application : - ReadlaterBundle “bundle” will lie here and in general we will code there too.
- Bundle : - in this case it's empty
- vendor : - here is the framework and all libraries

Let's start with configs. In readlater / config / config.yml add:

Copy Source | Copy HTML
kernel. config : ~
web . web : ~
web . templating : ~
doctrine. dbal :
default_connection : default
connections :
default :
driver : PDOMySql
dbname : sfbox2
user : root
password : 123
host : localhost
event_manager_class : Doctrine \ Common \ EventManager
configuration_class : Doctrine \ DBAL \ Configuration
doctrine. orm :
default_entity_manager : default
cache_driver : array
entity_managers :
default :
connection : default

I described the connection to the doctrine.dbal database and the settings for the Doctrine \ ORM doctrine.orm package

I will not describe here the creation of the application kernel, since it is almost the same as what goes into symfony-sandbox.

Therefore, I will go to ReadlaterBundle , which I will put in src / Application . The structure of the bundle is:

Controller : - here are the controllers
Entities : - here are those Entity, classes of models
Resources
- config : - here are the settings
- views : - here are the templates

In the Entities directory, I will create a single Link class, because I don’t need more. Doctrine 2 by default offers to create Entity in the Entities directory of the bundle, that is, each bundle can have its own set of model classes. By configuring, you can ask Doctrine to look for classes in a directory other than Entities, but I will not do this.

So here’s the Link class code:

Copy Source | Copy HTML
<? php
namespace Application \ ReadlaterBundle \ Entities;
use Doctrine \ ORM \ EntityRepository;
/ ** * @Entity * @Table (name = "readlater_link") * /
class Link
{
/ ** * @Id @Column (name = "id", type = "integer") * @GeneratedValue (strategy = "AUTO") * /
private $ id ;
/ ** * @Column (name = "url", type = "string", length = 255) * /
private $ url ;
/ ** * @Column (name = "created_at", type = "datetime") * /
private $ createdAt ;
/ ** * constructor * /
public function __construct ()
{
$ this -> createdAt = new \ DateTime ();
}
/ ** * to string * /
public function __toString ()
{
return $ this -> getUrl ();
}
}

I defined three fields for a class:

$ id - identifier
$ url - URL links
$ createdAt - date added

And also added two methods that are already clear. As you can see from the example, I used Docblock to describe the model.

Now I executed several commands:

readlater/console doctrine:database:create
    

      
      
      
    

  readlater/console doctrine:generate:entities
    

      
      
      
    

  readlater/console doctrine:schema:create

The first team will create a database, the second will generate methods for our class and do some work, and the third will create a table in the database.

It will look something like this:

Now, if we look at our Link class , we will see that it has changed a little, and now it looks like this:

Copy Source | Copy HTML
<? php
namespace Application \ ReadlaterBundle \ Entities;
use Doctrine \ ORM \ EntityRepository;
/ ** * @Entity * @Table (name = "readlater_link") * /
class Link
{
/ ** * @Id @Column (name = "id", type = "integer") * @GeneratedValue (strategy = "AUTO") * /
private $ id ;
/ ** * @Column (name = "url", type = "string", length = 255) * /
private $ url ;
/ ** * @Column (name = "created_at", type = "datetime") * /
private $ createdAt ;
/ ** * constructor * /
public function __construct ()
{
$ this -> createdAt = new \ DateTime ();
}
/ ** * to string * /
public function __toString ()
{
return $ this -> getUrl ();
}
/ ** * Get id * * @return integer $ id * /
public function getId ()
{
return $ this -> id;
}
/ ** * Set url * * @param string $ url * /
public function setUrl ( $ url )
{
$ this -> url = $ url ;
}
/ ** * Get url * * @return string $ url * /
public function getUrl ()
{
return $ this -> url;
}
/ ** * Set createdAt * * @param datetime $ createdAt * /
public function setCreatedAt ( $ createdAt )
{
$ this -> createdAt = $ createdAt ;
}
/ ** * Get createdAt * * @return datetime $ createdAt * /
public function getCreatedAt ()
{
return $ this -> createdAt;
}
}

It introduced methods for accessing class properties.

Well now add routing rules to routing.yml

Copy Source | Copy HTML
link_list :
pattern : /
defaults : { _bundle : ReadlaterBundle, _controller : Readlater, _action : index }
add_link :
pattern : / add
defaults : { _bundle : ReadlaterBundle, _controller : Readlater, _action : add }
read_link :
pattern : / read /: id
defaults : { _bundle : ReadlaterBundle, _controller : Readlater, _action : read }

From the code I think everything is clear, there are 3 rules, listing, adding and deleting.

Now, finally, the controller, where you can and see how to work with objects running Doctrine. Immediately quote the entire code:

Copy Source | Copy HTML
<? php
namespace Application \ ReadlaterBundle \ Controller;
use Symfony \ Framework \ WebBundle \ Controller,
Application \ ReadlaterBundle \ Entities \ Link,
Doctrine \ ORM \ QueryBuilder;
class ReadlaterController extends Controller
{
public function indexAction ()
{
$ em = $ this -> container-> getDoctrine_ORM_EntityManagerService ();
$ links = $ em -> getRepository ( 'Application \ ReadlaterBundle \ Entities \ Link' ) -> findAll ();
return $ this -> render ( 'ReadlaterBundle: Readlater: index' , array ( 'links' => $ links ));
}
public function addAction ()
{
$ request = $ this -> getRequest ();
$ url = $ request -> request-> get ( 'link' );
$ link = new Link ();
$ link -> setUrl ( $ url );
$ em = $ this -> container-> getDoctrine_ORM_EntityManagerService ();
$ em -> persist ( $ link );
$ em -> flush ();
return $ this -> redirect ( $ this -> generateUrl ( 'link_list' ));
}
public function readAction ( $ id )
{
$ em = $ this -> container-> getDoctrine_ORM_EntityManagerService ();
$ link = $ em -> find ( 'Application \\ ReadlaterBundle \\ Entities \\ Link' , $ id );
$ em -> remove ( $ link );
$ em -> flush ();
return $ this -> redirect ( $ this -> generateUrl ( 'link_list' ));
}
}

A few words about the code.

$em = $this->container->getDoctrine_ORM_EntityManagerService(); so using the DI Container we access the EntityManager

$em->getRepository() - so we get a repository of objects of a certain type, that is, some kind of * Table from Doctrine 1.x.

$em->persist($link); - so we save the object

$em->flush() so we complete the transaction, that is, we actually send the data to the database.

$em->remove($link) - well, and so remove the object.

By the way, if I inherited my controller from Symfony \ Framework \ DoctrineBundle \ Controller \ DoctrineController , then the methods would be available:

getDatabaseConnection - returns a database connection object
getEntityManager - and I wouldn’t have to get it from DI Container
createQueryBuilder
createQuery

That's all about the code, the rest I think is obvious.

But perhaps the question arose if now there are no classes of tables, then where to create methods for extracting model objects. For example, in this case, it would be good for the findAll method to get a list of objects sorted by adding date in descending order. To do this, you must create your own class storage repository for objects of a particular type.

To do this, open our class Link and add to the end of the file:

Copy Source | Copy HTML
/ ** * LinkRepository * /
class LinkRepository extends EntityRepository
{
public function findAll ()
{
return $ this -> _ em-> createQuery ( 'SELECT l FROM Application \\ ReadlaterBundle \\ Entities \\ Link l ORDER BY l.createdAt DESC' ) -> getResult ();
}
}

this will be the repository.

Now let's say which repository to use for the Link class, for this we will slightly change Docblock and the Link class

Copy Source | Copy HTML
/ ** * @Entity (repositoryClass = "Application \ ReadlaterBundle \ Entities \ LinkRepository") * @Table (name = "readlater_link") * /
class Link
{
// ...
}

That's all. Now the list of links will be sorted in the right order and it will look something like this:

I did not give the template code, but all this can be viewed in the source code on github

as well as related links:

Source: https://habr.com/ru/post/91565/

All Articles

Symfony 2 and Doctrine 2

About Doctrine 2

We take off

Flew

More articles: