[JAVA] Essayez d'utiliser un conteneur DI avec Laravel et Spring Boot

introduction

Ceci est un article de Your Meister Advent Calendar 2019 Day 13. (Ce sera un article qui sort ce que vous avez appris depuis que vous êtes devenu membre de la société.)

Contexte de cette époque

Après être devenu membre de la société, j'ai appris le concept de DI (injection de dépendance). Il y a eu de nombreuses occasions où j'ai utilisé le framework lors du développement de services WEB, mais je me souviens que le concept de DI n'apparaissait pas dans le Cake PHP que j'utilisais principalement. (Je suis désolé si j'ai une mauvaise mémoire.)

DI utilise une instance pré-enregistrée en utilisant ce qu'on appelle un conteneur DI ou un conteneur de service (appelé conteneur DI dans Spring Boot et un conteneur de service dans Laravel) au lieu de créer une instance avec new et de l'utiliser. Faire.

Cette fois, j'aimerais écrire un article sur le thème de l'utilisation des conteneurs DI dans Spring Boot, que j'utilise pour les entreprises, et de l'utilisation des conteneurs de services dans Laravel, que j'ai récemment appris par moi-même.

Pour Spring Boot

Utiliser l'injection de constructeur

J'écrirai en utilisant le code que j'ai écrit dans l'article le 7ème jour de Your Meister Advent Calendar 2019. Essayez de changer de base de données dynamiquement avec Spring Boot https://github.com/Masaki-Ogawa/datasourceDemo

1. PersonRepository.java

PersonRepository.java

package com.example.dataSourceDemo.domain.repositories;

import com.example.dataSourceDemo.domain.models.Person;
import org.springframework.data.jpa.repository.JpaRepository;

@Repository
public interface PersonRepository extends JpaRepository<Person, Integer> {

}

Classe de référentiel qui hérite de JpaRepository

2. PersonServiceImpl.java

PersonServiceImpl.java

package com.example.dataSourceDemo.domain.services;

import com.example.dataSourceDemo.annotations.DataSource;
import com.example.dataSourceDemo.annotations.DataSource.DataSourceType;
import com.example.dataSourceDemo.domain.models.Person;
import com.example.dataSourceDemo.domain.repositories.PersonRepository;
import java.util.List;
import org.springframework.stereotype.Service;

@Service
public class PersonServiceImpl implements PersonService {

  private final PersonRepository personRepository;

  public PersonServiceImpl(
      PersonRepository personRepository) {
    this.personRepository = personRepository;
  }

  /**
   *Méthode pour obtenir l'enregistrement de la table Person à partir de DB de stg
   * @enregistrement dans la table des personnes de retour
   */
  @Override
  public List<Person> findAllPersonInStg() {
    return personRepository.findAll();
  }

  /**
   *Méthode pour obtenir l'enregistrement de la table Person à partir de DB de stg
   * @enregistrement dans la table des personnes de retour
   */
  @DataSource(value = DataSourceType.PROD)
  @Override
  public List<Person> findAllPersonInProd() {
    return personRepository.findAll();
  }
}

Je fais de la DI ici.

En particulier,

private final PersonRepository personRepository;

  public PersonServiceImpl(
      PersonRepository personRepository) {
    this.personRepository = personRepository;
  }

L'injection DI par constructeur est effectuée dans la partie de. Il est enregistré dans le conteneur DI en utilisant les annotations «@ Service» et «@ Repository». Pour l'utiliser, créez une instance à l'aide de l'injection de constructeur, etc. comme décrit ci-dessus.

référence Spring Framework Summary-About DI

DI à Laravel

Utilisez un fournisseur de services

Créez un fournisseur de services pour enregistrer le service créé en tant que conteneur de services. Cette fois, j'ai créé une classe de service appelée DemoService.

AppServiceProvider.php

class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        $this->app->bind('App\Services\DemoService');
    }

    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        //
    }
}

Enregistrez le service comme ci-dessus.

DemoService.php

class DemoService {
    public function show() {
        echo "Montre quelque chose";
    }
}

La classe de service convient cette fois, mais seule la méthode qui produit certains caractères est implémentée.

DemoController.php

class MessageController extends Controller
{
    protected $demoService;

    public function __construct(DemoService $demoService)
    {
        $this->demoService = $demoService;
    }

    public function index(Request $request) {

        return $this->demoService->show();
    }
}

De cette façon, nous utilisons également l'injection de constructeur pour faire DI.

À la fin

Personnellement, je pense que Spring Boot, qui peut être enregistré dans le conteneur DI avec des annotations telles que @ Service et @ Controller, est plus facile à utiliser. Après tout, en utilisant Java et Spring Boot, il existe de nombreuses situations dans lesquelles la puissance des annotations est remarquée.

Aussi, comme je l'ai écrit dans le Calendrier de l'Avent le 7ème jour, chaque cadre a ses avantages et ses inconvénients, et l'expérience de toucher de nombreux cadres est que lorsque je fais quelque chose dans le futur, "Quel genre de chose dois-je adopter?" Si oui, est-ce le meilleur pour le produit? "

À l'avenir, j'aimerais continuer à aborder à la fois les entreprises et les non-entreprises.