Injection de dépendance du constructeur au printemps

Injection de dépendance de constructeur au printemps

1. introduction

L'un des principes de développement les plus importants de la conception de logiciels modernes est sans douteDependency Injection (DI), qui découle tout naturellement d'un autre principe d'une importance cruciale:Modularity.

Cet article explore un type spécifique de technique DI appeléConstructor-Based Dependency Injection dans Spring - ce qui signifie simplement que les composants requis sont passés dans une classe au moment de l'instanciation.

Pour commencer, nous devons importer la dépendancespring-context dans nospom.xml:


    org.springframework
    spring-context
    5.1.4.RELEASE

Ensuite, nous devons configurer un fichierConfiguration. Ce fichier peut être un POJO ou, si vous préférez, un fichier XML.

Lectures complémentaires:

Introduction à l'inversion du contrôle et injection de dépendance avec ressort

Une introduction rapide aux concepts d'inversion de contrôle et d'injection de dépendance, suivie d'une démonstration simple à l'aide du framework Spring

Questions d'entretiens chez Top Spring Framework

Une brève discussion sur les questions courantes concernant le cadre de travail qui pourraient être soulevées lors d’un entretien d’emploi.

Câblage au printemps: @Autowired, @Resource et @Inject

Cet article comparera et opposera l'utilisation des annotations liées à l'injection de dépendance, à savoir les annotations @Resource, @Inject et @Autowired.

2. Configuration basée sur les annotations

Le fichier de configuration Java ressemble beaucoup à un objet Java ordinaire avec quelques annotations supplémentaires:

@Configuration
@ComponentScan("com.example.constructordi")
public class Config {

    @Bean
    public Engine engine() {
        return new Engine("v8", 5);
    }

    @Bean
    public Transmission transmission() {
        return new Transmission("sliding");
    }
}

Ici, nous utilisons des annotations pour informer Spring runtime que cette classe est un fournisseur de définitions de bean (annotation@Bean) et qu'une analyse de contexte pour des beans supplémentaires doit être effectuée dans le packagecom.example.spring. Ensuite, nous définissons une classeCar:

@Component
public class Car {

    @Autowired
    public Car(Engine engine, Transmission transmission) {
        this.engine = engine;
        this.transmission = transmission;
    }
}

Spring rencontrera notre classeCar lors d'une analyse de package et initialisera son instance en appelant le constructeur annoté@Autowired.

Les instances deEngine and Transmission seront obtenues en appelant les méthodes annotées@Bean de la classeConfig. Enfin, nous devons amorcer unApplicationContext en utilisant notre configuration POJO:

ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
Car car = context.getBean(Car.class);

3. Injection de constructeur implicite

Depuis Spring 4.3, les classes avec un seul constructeur peuvent omettre l'annotation@Autowired. Un bon petit peu de commodité et l'enlèvement de la passe-partout!

En plus de cela, à partir de 4.3 également, l'injection basée sur les constructeurs peut être exploitée dans les classes annotées@Configuration. Et oui, si une telle classe n'a qu'un seul constructeur, l'annotation@Autowired peut également être omise.

4. Configuration basée sur XML

Un autre moyen de configurer l'exécution de Spring avec une injection de dépendance basée sur un constructeur consiste à utiliser un fichier de configuration xml:

Notez queconstructor-arg peut accepter une valeur littérale ou une référence à un autre bean et qu'unindex ettype explicite optionnel peut être fourni. Les attributsType etindex peuvent être utilisés pour résoudre une ambiguïté (par exemple si un constructeur prend plusieurs arguments du même type).

L'attributname peut également être utilisé pour la correspondance de variables xml à java, mais votre codemust sera compilé avec l'indicateur de débogage activé.

Un contexte d'application Spring, dans ce cas, doit être amorcé à l'aide deClassPathXmlApplicationContext:

ApplicationContext context = new ClassPathXmlApplicationContext("example.xml");
Car car = context.getBean(Car.class);

5. Conclusion

Ce tutoriel rapide a présenté les bases de deux manières distinctes d'utiliserConstructor-Based Dependency Injection à l'aide du framework Spring.

Lesfull implementation de ce tutoriel peuvent être trouvésover on Github.

TOC