Spring IoC [Inversion de contrôle] DI [Injection de dépendance]

---

IoC est l'abréviation d'inversion de contrôle, traduite par "inversion de contrôle", ce n'est pas une technologie, mais une idée de conception, est un principe de programmation orienté objet important, peut nous guider sur la façon de concevoir un meilleur programme faiblement couplé

Spring gère l'instanciation et l'initialisation de tous les objets Java via le conteneur IoC et contrôle les dépendances entre les objets. Nous appelons les objets Java IoC 容器gérés par Spring Bean, Spring Beans pas différents des objets Java créés avec le nouveau mot-clé.

Le conteneur IoC est l'un des composants de base les plus importants du framework Spring, qui parcourt tout le processus de Spring, de sa naissance à sa croissance.

Inversion de contrôle (IoC)

Dans les applications Java traditionnelles, si une classe souhaite appeler une propriété ou une méthode dans une autre classe, elle crée généralement d'abord ce dernier objet dans son code au moyen de new Object(), puis la propriété ou la méthode peut être appelée. . C'est-à-dire, la méthode de développement traditionnelle, le contrôle de la création d'objet est remis au programmeur

Dans les applications Spring, le contrôle de la création d'objets Java est donné au conteneur, qui est控制反转

1. Les développeurs définissent les objets Java via des fichiers de configuration XML, des annotations, des classes de configuration Java, etc., comme l'utilisation de balises dans les fichiers de configuration XML, l'utilisation d'annotations @Component sur les classes Java, etc.
2. Lorsque Spring démarre, le conteneur IoC crée et gère automatiquement ces objets conformément à la définition de l'objet. Ces objets créés et gérés par le conteneur IoC sont appelés Spring Beans.
3. Lorsque nous voulons utiliser un Bean, nous pouvons l'obtenir directement depuis le conteneur IoC (par exemple, via la méthode getBean() de ApplicationContext), au lieu de créer newmanuellement un objet

Le plus grand changement apporté par IoC n'est pas au niveau du code, mais au niveau idéologique. Dans les applications Spring, le conteneur IoC détient l'initiative et l'appelant devient la partie passive, attendant passivement que le conteneur IoC crée les objets (Beans) dont il a besoin.

Dans ce processus, l'inversion de contrôle se produit, et la création de l'objet qui a été initialement implémentée par l'appelant via le code est inversée dans le conteneur IoC pour aider à le réaliser. Par conséquent, nous appelons ce processus "l'inversion de contrôle" de Spring.

Injection de dépendance (DI)

Au fil du temps, les concepteurs ont découvert qu'IoC avait de nombreux frameworks, donc Spring hésite à s'arrêter là.Sur la base d'Ioc, le concept d'injection de dépendances est introduit.

Dependency Injection (Denpendency Injection, en abrégé DI), en orienté objet, il existe une relation appelée "dépendance" entre les objets et les objets. En termes simples, une relation de dépendance est qu'un objet doit utiliser un autre objet, c'est-à-dire qu'il existe un attribut dans l'objet, qui est un objet d'une autre classe.

Principe IoC et découplage

Dans le processus de développement logiciel, il existe plus ou moins certaines relations de couplage entre divers objets du système, entre divers modules, entre le système logiciel et le système matériel.

Si le couplage d'un système est trop élevé, cela entraînera des problèmes difficiles à maintenir, mais presque aucun travail ne peut être effectué par code sans couplage du tout, car presque toutes les fonctions nécessitent une coopération mutuelle et une interdépendance entre les codes pour être complétées. Ainsi, lorsque nous concevons le programme, l'idée que nous défendons est généralement de minimiser le degré de couplage sans affecter le fonctionnement du système.

La couche inférieure d'IoC réduit au minimum le couplage du code grâce à des technologies telles que le mode usine, le mécanisme de réflexion de Java et l'analyse XML.

Étant donné que les informations de base de l'objet et les dépendances entre les objets sont définies dans le fichier de configuration, elles ne sont pas étroitement couplées dans le code, donc même si l'objet change, nous n'avons qu'à le modifier dans le fichier de configuration, sans avoir besoin pour modifier le code Java, qui est le principe du découplage de l'implémentation Spring IoC.

Deux implémentations de conteneurs IoC

L'idée d'IoC est implémentée sur la base du conteneur IoC.La couche inférieure du conteneur IoC est en fait une usine de haricots. Le framework Spring nous fournit deux types différents de conteneurs IoC, ils sont BeanFactoryetApplicationContext

Fabrique de haricots

BeanFactory est l'implémentation de base du conteneur IoC et le conteneur IoC le plus simple fourni par Spring. Il fournit les fonctions les plus élémentaires du conteneur IoC et est défini par l' org.springframework.beans.factory.BeanFactoryinterface .

BeanFactory adopte 懒加载（lazy-load）机制, le conteneur ne créera pas l'objet Java immédiatement lors du chargement du fichier de configuration, uniquement lorsque le programme obtient (utilise) cette paire d'objets.

ApplicationContextApplicationContext

ApplicationContext est une sous-interface de l'interface BeanFactory et est une extension de BeanFactory. ApplicationContext ajoute de nombreuses fonctions au niveau de l'entreprise sur la base de BeanFactory, telles que l'AOP (Aspect Oriented Programming), l'internationalisation, la prise en charge des transactions, etc. L'interface ApplicationContext a deux classes d'implémentation couramment utilisées, ClassPathXmlApplicationContext, qui charge le fichier de configuration XML spécifié dans le chemin de classe ClassPath et termine l'instanciation de ApplicationContext. FileSystemXmlApplicationContext, charge le fichier de configuration XML spécifié dans le chemin du système de fichiers spécifié et termine l'instanciation de ApplicationContext

public class TestSpring {
    
    
    public static void main(String[] args) {
    
    
        //启动工厂
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //获取工厂中创建好的对象，参数：获取工厂中指定对应的唯一标识
        UserDAO userDAO = (UserDAO) context.getBean("userDAO");
        userDAO.save("Hello Spring ClassPathXmlApplicationContext");
        BeanFactory context1 = new ClassPathXmlApplicationContext("spring.xml");
        //FileSystemXmlApplicationContext fileSystemXmlApplicationContext = new FileSystemXmlApplicationContext("D://xxx");
        //UserDAO userDAO2 = fileSystemXmlApplicationContext.getBean("userDAO", userDAO.getClass());
        UserDAO userDAO1 = (UserDAO) context1.getBean("userDAO");
        userDAO1.save("hello spring beanFactory");
    }
}

résultat

userDAO save name = Hello Spring ClassPathXmlApplicationContext
userDAO save name = hello spring beanFactory