Le cœur de spring est une inversion légère du cadre de contrôle (IOC) et de programmation orientée aspect (AOP)!
L'inversion de contrôle consiste à réduire le couplage entre les codes, le moyen le plus courant est l' injection de dépendances
Qu'est-ce que l'injection de dépendance?
Voyons d'abord ce qu'est la dépendance. Dans la vie, s'appuyer sur les autres ou sur d'autres choses sans pouvoir être indépendant ou indépendant s'appelle la dépendance.
Alors, quelle est la dépendance dans l'application? La dépendance fait référence à la relation entre deux instances. Une instance est indépendante, l'autre est dépendante (dépendante) et dépend d'une autre instance. Par exemple, l'objet ordinateur, qui contient l'objet hôte et l'objet d'affichage. S'il n'y a pas d'objet hôte ou d'objet d'affichage, l'objet ordinateur est incomplet et ne peut pas être utilisé normalement. Nous disons que l'objet ordinateur dépend de l'objet hôte et de l'objet d'affichage.
Alors, qu'est-ce que l'injection? Les objets ordinateur sont indissociables de l'objet hôte et de l'objet d'affichage. Lorsque le programme est en cours d'exécution, nous devons fournir à l'objet ordinateur l'objet hôte et l'objet d'affichage dont il a besoin, et fournir l'objet hôte et l'objet d'affichage à l'objet ordinateur comme une "injection". Le processus est appelé injection. En d'autres termes, si un objet a besoin d'un autre objet pour être utilisé normalement, nous lui fournissons l'objet dont il a besoin lorsque le programme est en cours d'exécution.
Nous savons que Spring gérera presque tous les objets Bean et qu'il peut y avoir des dépendances entre les objets. Pendant l'exécution du programme, Spring assemble tous les objets dont nous avons besoin. Il s'agit de l'injection de dépendances de Spring. Dans la conception Java traditionnelle, lorsqu'un appelant d'une instance Java crée une instance Java appelée, la classe Java appelée doit apparaître dans le code de l'appelant et un couplage lâche ne peut pas être obtenu entre les deux. En termes simples, le modèle d'usine a amélioré cela afin que l'appelant n'ait pas besoin de se soucier du processus d'implémentation spécifique de l'appelé, et puisse l'utiliser tant qu'il obtient une instance qui répond à un certain standard (interface). Le code d'appel est orienté vers la programmation d'interface, qui prend en charge le découplage de l'appelant et de l'appelé, de sorte que le modèle d'usine peut être largement utilisé. Mais dans le modèle d'usine, l'appelant doit localiser l'usine par lui-même et être couplé à l'usine spécifique, de sorte que le découplage de l'appelant et de l'appelé n'est réalisé que dans une certaine mesure. L'émergence de Spring élimine le besoin pour les appelants de localiser l'usine par eux-mêmes. Lorsque le programme s'exécute sur l'appelé, le système fournira automatiquement l'instance de l'appelé. En fait, l'appelant et l'appelé sont gérés par Spring et la dépendance entre les deux est fournie par Spring.
En termes simples: l'objet de classe B est utilisé dans la classe A. Dans des circonstances normales, un nouvel objet B de la classe A doit être utilisé. L'injection de dépendance ne nécessite que de définir un objet B privé dans la classe A.
L'injection de dépendances, un aspect de la COI, est un concept courant, et il a de nombreuses explications. Le concept est que vous n'avez pas besoin de créer un objet, mais seulement de décrire comment il est créé. Vous n'assemblez pas vos composants et services directement dans le code, mais vous devez décrire quels composants ont besoin de quels services dans le fichier de configuration, puis un conteneur (conteneur IOC) est responsable de leur assemblage.
Cas complet d'injection de dépendance
- Comment développer une imprimante?
Peut être configuré de manière flexible pour utiliser des cartouches d'encre couleur ou des cartouches d'encre noire
Peut configurer de manière flexible la taille de la page imprimée (A4, B5)
La réalisation de la fonction imprimante dépend de la cartouche d'encre et du papier - Étape
1. Définissez les normes d'interface pour les cartouches d'encre et le papier
2. Utilisez les normes d'interface pour développer l'imprimante
3. Assemblez l'imprimante
4. Exécutez l'imprimante
1. Définissez la norme d'interface de la cartouche d'encre et du papier
//定义墨盒接口
public interface InkBox {
//提供获取颜色的方法
String getColor();
}
============== 为了阅读方便放在了一起 标准做法应该要分开写 ==============
//定义纸张大小接口
public interface PaperSize {
//提供获取纸张大小的方法
String getPaper();
}
2. La classe d'implémentation de l'interface
//A4纸张
public class A4Paper implements PaperSize {
public String getPaper() {
return "A4";
}
}
//B5纸张
public class B5Paper implements PaperSize {
public String getPaper() {
return "B5";
}
}
//黑色墨盒
public class BlackInkBox implements InkBox {
public String getColor() {
return "黑色墨盒";
}
}
//彩色墨盒
public class ColourInkBox implements InkBox {
public String getColor() {
return "彩色墨盒";
}
}
3. Classe d'imprimante (la classe est définie ici, si vous souhaitez assembler différentes imprimantes, vous devez utiliser l'interface, et différentes classes d'imprimantes implémentent une méthode d'imprimante commune)
Injection de méthode Setter: L'injection de méthode Setter signifie qu'après que le conteneur instancie le bean en appelant le constructeur sans paramètre ou la méthode de fabrique statique sans paramètre, la méthode setter du bean est appelée, qui réalise l'injection de dépendance basée sur le setter.
public class Printer {
private InkBox inkBox;
private PaperSize paperSize;
//通过set注入必须要提供无参构造
public Printer() {
}
//提供setter方法对应xml文件中标签<property name="paperSize" ref="a4Paper"/>
public void setInkBox(InkBox inkBox) {
this.inkBox = inkBox;
}
//提供setter方法对应xml文件中标签<property name="inkBox" ref="colourInkBox"/>
public void setPaperSize(PaperSize paperSize) {
this.paperSize = paperSize;
}
//组装打印机的方法
public void print(){
System.out.println("使用"+inkBox.getColor()+"打印出了"+paperSize.getPaper()+"大小的纸张");
}
}
4. Configurez le fichier applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 创建A4Paper的对象 -->
<bean id="a4Paper" class="com.li.bean.Impl.A4Paper"/>
<!-- 创建ColourInkBox的对象 -->
<bean id="colourInkBox" class="com.li.bean.Impl.ColourInkBox"/>
<!-- 创建Printer对象 Printer中用到了PaperSize InkBox 两个接口的引用 所以需要接口的实现类-->
<bean id="printer" class="com.li.bean.Printer">
<property name="paperSize" ref="a4Paper"/>
<property name="inkBox" ref="colourInkBox"/>
</bean>
<bean id="b5Paper" class="com.li.bean.Impl.B5Paper"/>
<bean id="blackInkBox" class="com.li.bean.Impl.BlackInkBox"/>
<bean id="printer2" class="com.li.bean.Printer">
<property name="paperSize" ref="b5Paper"/>
<property name="inkBox" ref="blackInkBox"/>
</bean>
</beans>
5. Test
public class TestPrinter {
/**
* 一般情况下:new 对象
*/
@Test
public void printerOut() {
A4Paper a4Paper = new A4Paper();
ColourInkBox colourInkBox = new ColourInkBox();
Printer printer = new Printer();
printer.setPaperSize(a4Paper);
printer.setInkBox(colourInkBox);
printer.print();
//使用黑色墨盒打印出了A4大小的纸张
}
/**
* 创建对象由配置文件管理
*/
@Test
public void printerOut2(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Printer printer = context.getBean("printer", Printer.class);
printer.print();
//使用彩色墨盒打印出了A4大小的纸张
}
@Test
public void printerOut3() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Printer printer = context.getBean("printer2", Printer.class);
printer.print();
//使用黑色墨盒打印出了B5大小的纸张
}
}
Résumé: Spring IOC est responsable de la création d'objets, de la gestion des objets (via l'injection de dépendances (DI), de l'assemblage d'objets, de la configuration des objets et de la gestion de l'ensemble du cycle de vie de ces objets).