Discussion :

[footsteps]

Bonjour.
Question simple:le code ci dessous est dans un controller .Peut on isoler les traitements des objets dans une couche séparée?.En somme ,le but est d'adapter l'architecture d'un projet java ee spring(entites/Interfacedao/daoimpl/Interfacemetier/metierimpl/controller).Donc d'utiliser un objet metier dans le controller et appeler les méthodes déjà implémentéesMerci.

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("/addN/{$note}/{$nom}")
     * @Template()
     */
    public function addNoteAction($note,$nom){
        $em = $this->getDoctrine()->getEntityManager();
        $note =new Note();
        $note->setNote($note);
        $c = new Candidat();
        $c->setNom($nom);
        $note->setCandidat($c);
        $em->persist($note);
        $em->flush();
        return array("note"=>$note);
    }

[gototog]

Je connais pas trop l'architecture spring

Il te suffit d'utiliser des services et d'injecter ce que tu veux.

controller

Code :

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

1
2
3
4
5
6
public function addNoteAction($note,$nom){
 
        $note = $this->get('note_saver')->addNoteForName($note, $nom);
 
        return array("note"=>$note);
    }

Service qui modifie/créer des notes NoteSaver (par exemple hin)

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
/**
 * @Service("note_saver")
 */
class NoteSaver {
 
    private $em;
 
    /**
     * @InjectParams({"em"    = @Inject("doctrine.orm.entity_manager")})
     */
    public function __construct(EntityManager $entityManager)
    {
        $this->em= $entityManager;
    }
 
    public function addNoteForName($note, $name) {
        $note =new Note();
        $note->setNote($note); //c'est bizar comme nommage mais bon
        $c = new Candidat();
        $c->setNom($nom);
        $note->setCandidat($c);
        $this->em->persist($note);
        $this->em->flush();
 
        return $note
 
    }

Ca c'est le découpage de base, si tu veux faire une architecture avec plus de couches, il suffit de définir tes couches et de les utiliser proprement.

Dans ma boite on a mit en place 5 couches : La vue, Le controlleur, une couche transactionnelle, une couche contenant le code métier, une couche de repository.
On s'est interdit de manipuler des objets doctrines dans le controlleur et la vue, donc on utilise des objets métiers (de simples classes php) qu'on hydrate avant de passer aux vues
On utilise donc des services qui ne servent qu'a transformer un ensemble d'objets doctrine en un objet métier. Dans le code que je t'ai mis en exemple, ce service ne serait appelé qu'après le flush, et retournerai au controlleur l'objet métier

[footsteps]

Je te remercie.
En fait,on passe par symfony2 car le client veut du php.On sait faire que du jee donc ça chauffe.
C'est un framework intéressant qui se rapproche du java web.
Donc si je te suis bien,on peut découper comme on veut à condition de passer par la structure service de symfony.Je vais regarder un peu.Reste l'injection de dépendances entres couches (facile avec spring ou ejb), essentielle!,je vais z'yeuter aussi.Je me permettrai de reposter si je coince.Cdlt.

[footsteps]

Pour avancer,je me demande si on peut regrouper tous les services dans une interface et l'implémenter.Indispensable pour les mises à jour.
Plutôt que de créer autant de class que de traitements...