Services: Naming and Configuration

Service autowiring is a feature provided by Symfony's Service Container to manage services with minimal configuration. It reads the type-hints on your constructor (or other methods) and automatically passes the correct services to each method. It can also add service tags to the services needing them, such as Twig extensions, event subscribers, etc.

The blog application needs a utility that can transform a post title (e.g. "Hello World") into a slug (e.g. "hello-world") to include it as part of the post URL. Let's create a new Slugger class inside src/Utils/:

1
2
3
4
5
6
7
8
9
10

// src/Utils/Slugger.php
namespace App\Utils;

class Slugger
{
    public function slugify(string $value): string
    {
        // ...
    }
}

If you're using the default services.yaml configuration, this class is auto-registered as a service whose ID is App\Utils\Slugger (or simply Slugger::class if the class is already imported in your code).

Now you can use the custom slugger in any other service or controller class, such as the AdminController:

1
2
3
4
5
6
7
8
9
10
11
12
13

use App\Utils\Slugger;

public function create(Request $request, Slugger $slugger)
{
    // ...

    if ($form->isSubmitted() && $form->isValid()) {
        $slug = $slugger->slugify($post->getTitle());
        $post->setSlug($slug);

        // ...
    }
}

Services can also be public or private. If you use the default services.yaml configuration, all services are private by default.

Service Format: YAML

If you use the default services.yaml configuration, most services will be configured automatically. However, in some edge cases you'll need to configure services (or parts of them) manually.

This is controversial, and in our experience, YAML and XML usage is evenly distributed among developers, with a slight preference towards YAML. Both formats have the same performance, so this is ultimately a matter of personal taste.

We recommend YAML because it's friendly to newcomers and concise. You can of course use whatever format you like.

Using a Persistence Layer

Symfony is an HTTP framework that only cares about generating an HTTP response for each HTTP request. That's why Symfony doesn't provide a way to talk to a persistence layer (e.g. database, external API). You can choose whatever library or strategy you want for this.

In practice, many Symfony applications rely on the independent Doctrine project to define their model using entities and repositories. Just like with business logic, we recommend storing Doctrine entities in the src/Entity/ directory.

The three entities defined by our sample blog application are a good example:

1
2
3
4
5
6
7

symfony-project/
├─ ...
└─ src/
   └─ Entity/
      ├─ Comment.php
      ├─ Post.php
      └─ User.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;

/**
 * @ORM\Entity
 */
class Post
{
    const NUMBER_OF_ITEMS = 10;

    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="string")
     */
    private $title;

    /**
     * @ORM\Column(type="string")
     */
    private $slug;

    /**
     * @ORM\Column(type="text")
     */
    private $content;

    /**
     * @ORM\Column(type="string")
     */
    private $authorEmail;

    /**
     * @ORM\Column(type="datetime")
     */
    private $publishedAt;

    /**
     * @ORM\OneToMany(
     *      targetEntity="Comment",
     *      mappedBy="post",
     *      orphanRemoval=true
     * )
     * @ORM\OrderBy({"publishedAt"="ASC"})
     */
    private $comments;

    public function __construct()
    {
        $this->publishedAt = new \DateTime();
        $this->comments = new ArrayCollection();
    }

    // getters and setters ...
}

1

$ composer require "doctrine/doctrine-fixtures-bundle"

1
2
3
4
5
6

// config/bundles.php

return [
    // ...
    Doctrine\Bundle\FixturesBundle\DoctrineFixturesBundle::class => ['dev' => true, 'test' => true],
];

1
2
3
4
5

$ php bin/console doctrine:fixtures:load

Careful, database will be purged. Do you want to continue Y/N ? Y
  > purging database
  > loading App\DataFixtures\ORM\LoadFixtures

Coding Standards

The Symfony source code follows the PSR-1 and PSR-2 coding standards that were defined by the PHP community. You can learn more about the Symfony Coding standards and even use the PHP-CS-Fixer, which is a command-line utility that can fix the coding standards of an entire codebase in a matter of seconds.

Next: Controllers