Discussion :

[Ben90]

Bonjour,


Ayant l'habitude de développer en Symfony 2 puis 3, je suis en train de m'initier à Symfony 4.
Le changement entre les deux est assez frappant et limite déstabilisant dans certains cas.

Sur les précédentes versions de Symfony, j'avais l'habitude de créer des services liés à chaque entités que j'appelais [Nom entité]Manager (ex: UserManager). Ces classes me permettent de manipuler mes entités rapidement.
Par exemple pour récupérer une entité et la sauvegarder, au lieu de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
$entityManager = $this->getDoctrine()->getManager();
 
$product = $this->getDoctrine()
        ->getRepository(Product::class)
        ->find($id);
 
$product->setName('Test');
 
$entityManager->persist($product);
$entityManager->flush();

Il me suffisait de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
$productManager = $this->container->get('app.product_manager');
 
$product = $productManager->getOneById($id);
$product->setName('Test');
 
$productManager->save($product);

L'utilité n'est peut-être pas directement visible comme ça mais je trouve que ça rend le code plus propre et plus compréhensible, surtout sur de gros controllers.

En général, un de mes managers ressemble à ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
<?php
 
namespace AppBundle\Manager;
 
use AppBundle\Entity\User;
use Doctrine\ORM\EntityManager;
use AppBundle\Manager\BaseManager;
 
use Symfony\Component\DependencyInjection\ContainerInterface as Container;
 
class UserManager extends BaseManager
{
    public function __construct(EntityManager $em, Container $container)
    {
        $this->em = $em;
        $this->container = $container;
        $this->repository = 'AppBundle:User';
    }
 
    public function getOneByUsername($username) {
        return $this->getRepository()
            ->findOneByUsername($username);
    }
 
    public function getByJob($job) {
        return $this->getRepository()
            ->findByJob($job);
    }
 
    public function getActiveByRole($role) {
        return $this->getRepository()
            ->findBy(['isActive' => true, 'role' => $role], ['lastName' => 'ASC']);
    }
}

Tous mes managers étant étendus du BaseManager qui contient des fonctions de... base (getOneById($id), getByFieldLike($field, $term), save($entity), delete($entity), etc).

Ces managers ne sont pas enregistrés dans le fichier services.yml mais un nouveau fichier qui s'appelle managers.yml (qui fonctionne de la même manière). La récupération de celui-ci étant ajoutée dans le fichier DependencyInjection/AppExtension.php.
Ceci est fait pour les différencier des services qui eux servent à faire des actions hors entité (Par exemple: $calendarService->isHoliday($date) pour savoir si c'est un jour férié).

J'ai toujours fait comme ça et j'ai l'impression que ce n'est plus du tout possible dans Symfony 4, en tout cas pas dans cette forme, je me trompe ?

Surtout j'ai vu aussi que les services se récupèrent autrement, à savoir dans les arguments de l'action du controller (ex: public function list(LoggerInterface $logger)), ce qui est surement plus facile dans la plupart des cas, mais dans d'autres cas nécessitant pas mal de services, ça peut devenir compliqué... (selon mon utilisation toujours).

Je prends comme exemple une application de planning que j'ai du développer (en Symfony 3.4) pour une entreprise, voici une le début d'une des actions d'un des controllers:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
     * @Route("planning/{year}/{week}/{day}", options={"expose"=true})
     */
    public function planningAction(Request $request, $year = null, $week = null, $day = null)
    {
        //Récupération des managers et services
        $availabilityManager = $this->container->get('app.availability_manager');
        $planningManager    = $this->container->get('app.planning_manager');
        $calendarService      = $this->container->get('app.calendar_service');
        $positionManager     = $this->container->get('app.position_manager');
        $absenceManager     = $this->container->get('app.absence_manager');
        $roomManager         = $this->container->get('app.room_manager');
        $userManager          = $this->container->get('app.user_manager');
 
        [...]
    }

Perso, j'ai un peu de mal à voir comment faire rentrer proprement tout ça dans les arguments... Après, peut-être allez vous me dire que ce que je faisait jusque la est inutile et que je devrais me contenter tout simplement de ce que proposer Symfony ?

Merci d'avance de vos réponses.

[insaneness]

Bonjour,
Pour la manipulation des entités, je passe par les repository auxquels j'ajoute une fonction "save".
Le code est de ce type :

Code php :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public function save(Entity $entity)
    {
        $this->_em->persist($entity);
        $this->_em->flush();
    }

Pour la seconde question, avec l'autowire de symfony tu peux appeller directement les services dont ton controlleur aura besoin ex :

Code php :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
/**
     * @Route("planning/{year}/{week}/{day}", options={"expose"=true})
     */
    public function planningAction(Request $request, CalendarService $calendarService, $year = null, $week = null, $day = null)
    {
.....
}

Apres si il y a beaucoup d'arguments et que c'est trop "sale" pour toi, tu peux créer des handler spécifiques que tu loaderas de la même façon dans ton controlleur. Ces handler auront en arguments les différents services requis.
Ca permet d'avoir un code de controlleur plus clair et moins dense.