[Spring de l'entrée au didacticiel de combat réel] Chapitre 1 Présentation du printemps

1. Aperçu du printemps

1.1 Qu'est-ce que le printemps

    Spring est un framework open source léger Java EE actuellement courant et l'un des frameworks les plus performants du monde Java. Spring a été proposé et fondé par le "père de Spring" Rod Johnson. Son objectif est de simplifier la difficulté de développement et le cycle de développement des applications d'entreprise Java.
    
    Depuis la sortie officielle de Spring 1.0 en avril 2004, Spring est entré dans la cinquième version majeure, ce que nous appelons souvent Spring 5.
    
    Spring a été favorisé depuis sa création et a été considéré comme le premier choix des développeurs pour le développement d'applications d'entreprise Java. Aujourd'hui, Spring est devenu synonyme de Java EE et de la norme de facto pour la création d'applications Java EE.
    
    Spring Framework ne se limite pas au développement côté serveur. Toute application Java peut bénéficier de Spring en termes de simplicité, de testabilité et de couplage lâche. Le framework Spring est également une plateforme de super glue, en plus de fournir ses propres fonctions, il offre également la possibilité de coller d'autres technologies et frameworks.
    
    Spring est un framework de conteneur léger Inversion of Control (IOC) et Aspect Oriented (AOP).

Décrivez précisément Spring :

    Léger : Spring est léger en termes de taille et de frais généraux. Le framework Spring complet peut être distribué dans un fichier JAR d'une taille légèrement supérieure à 1 Mo. Et la surcharge de traitement requise par Spring est négligeable. De plus, Spring est non intrusif : généralement, les objets d'une application Spring ne dépendent pas de classes spécifiques à Spring. Le Servlet que nous avons appris précédemment est intrusif, car une classe Java doit implémenter ou hériter de l'API Servlet si elle veut devenir un Servlet, mais Spring ne le fait pas.
    
    Idée centrale :
        Inversion de contrôle : IOC (inversion de contrôle).
        Injection de dépendance : DI (injection de dépendance).
        Programmation orientée aspect : AOP (programmation orientée aspect).
    
    Conteneur : Spring contient et gère la configuration et le cycle de vie des objets de l'application, dans le sens où il s'agit d'un conteneur, vous pouvez configurer la façon dont chacun de vos beans est créé - sur la base d'un prototype configurable (prototype), votre bean peut créer un distinct instance ou en créer une nouvelle chaque fois que vous en avez besoin - et comment ils sont liés les uns aux autres.
    
    Framework : Spring peut configurer et combiner des composants simples dans des applications complexes. Dans Spring, les objets d'application sont composés de manière déclarative, généralement dans un fichier XML. Spring fournit également de nombreuses fonctions de base (gestion des transactions, intégration du framework de persistance, etc.), vous laissant le développement de la logique applicative.
    
    Guichet unique : sur la base d'IOC et d'AOP, il peut intégrer des frameworks open source de diverses applications d'entreprise et d'excellentes bibliothèques de classes tierces (par exemple : travail collaboratif entre les frameworks Struts2 et Hibernate), Spring est un pont ou une gestion dans le programme Ou, l'ensemble de l'application repose sur Spring pour s'exécuter. En fait, Spring lui-même fournit également SpringMVC pour la couche de présentation et SpringJDBC pour la couche de persistance.

1.1.1 La naissance et le développement du printemps

    Les premiers J2EE (plate-forme Java EE) préconisaient la méthode de développement avec EJB comme noyau, mais cette méthode de développement présente divers inconvénients dans le processus de développement réel, tels qu'une utilisation complexe, un code gonflé, un code intrusif fort, un long cycle de développement et un portage difficile. Grosse attente.

    Dans son best-seller "Expert One-on-One J2EE Design and Development" édité en 2002, Rod Johnson a analysé et nié les différentes structures gonflées d'EJB une par une, et les a remplacées de manière plus concise.

    Dans ce livre, Rod Johnson montre, à travers une annexe de 30 000 lignes, comment construire une application Java évolutive de haute qualité sans utiliser d'EJB. Dans cette annexe, Rod Johnson a écrit des dizaines de milliers de lignes de code d'infrastructure, y compris de nombreuses interfaces et classes Java réutilisables telles que ApplicationContext, BeanFactory, etc. Le package racine de ces classes est nommé com.interface21, ce qui signifie : C'est une référence pour le 21e siècle.

    Ce livre a eu un impact considérable. Plus tard, Rod Johnson a ouvert le code de com.interface21 et a nommé ce nouveau framework "Spring", ce qui signifie : le printemps est comme un rayon de brise printanière, balayant l'hiver froid de l'environnement traditionnel. J2EE.

    En février 2003, la version 0.9 de Spring a été publiée, qui a adopté le protocole open source Apache 2.0 ; en avril 2004, la version 1.0 de Spring a été officiellement publiée. Jusqu'à présent, Spring est entré dans la cinquième version majeure, ce que nous appelons souvent Spring 5.

1.1.2 Sens étroit et sens large du printemps

    Dans différents contextes, Spring représente différentes significations. Ensuite, nous présenterons Spring du point de vue du "sens large" et du "sens étroit".
    
    Site officiel : https://spring.io/

Spring au sens large : pile technologique Spring

    Spring au sens large fait référence à la pile technologique Spring avec Spring Framework comme noyau.

    Après plus de dix ans de développement, Spring n'est plus un pur framework d'application, mais s'est progressivement développé en une technologie mature composée de plusieurs sous-projets différents (modules), tels que Spring Framework, Spring MVC, SpringBoot, Spring Cloud, Spring Data, Spring Security, etc., parmi lesquels Spring Framework est la base d'autres sous-projets.

    Ces sous-projets couvrent tout, du développement d'applications au niveau de l'entreprise au cloud computing, et peuvent aider les développeurs à résoudre divers problèmes pratiques qui surviennent au cours du processus de développement de logiciels, offrant aux développeurs une meilleure expérience de développement.

nom du projet	décrire
Données de printemps	Le module d'accès aux données fourni par Spring offre un bon support pour JDBC et ORM. Grâce à elle, les développeurs peuvent utiliser une manière relativement uniforme d'accéder aux données situées dans différents types de bases de données.
Lot de printemps	Un cadre léger pour les tâches quotidiennes de traitement par lots dans les systèmes d'entreprise, qui peut aider les développeurs à développer facilement des applications de traitement par lots robustes et efficaces.
Sécurité du printemps	Anciennement connu sous le nom d'Acegi, c'est l'un des sous-modules les plus matures de Spring. Il s'agit d'un cadre d'authentification et de contrôle d'accès personnalisable.
Mobile de printemps	Il s'agit d'une extension de Spring MVC pour simplifier le développement d'applications Web mobiles.
Botte de printemps	Il s'agit d'un nouveau framework fourni par l'équipe Spring. Il fournit des configurations prêtes à l'emploi pour Spring et des bibliothèques tierces, ce qui peut simplifier le processus de construction et de développement d'applications Spring.
Nuage de printemps	Un framework de microservice basé sur Spring Boot. Il ne s'agit pas d'une certaine technologie, mais d'un ensemble ordonné d'une série de solutions ou de frameworks de microservices. Il intègre des frameworks de microservices matures et éprouvés sur le marché, et les reconditionne à travers l'idée de Spring Boot, protégeant et ajustant les principes complexes de configuration et de mise en œuvre, et fournit enfin aux développeurs un ensemble de simples, faciles à comprendre et faciles. -to-deploy Et un kit de développement de système distribué facile à entretenir.

Ressort étroit : cadre de ressort

    Spring au sens étroit fait spécifiquement référence au Spring Framework, que nous appelons généralement le Spring Framework.

    Le framework Spring est une solution légère à plusieurs niveaux pour les applications Java orientées aspect. Il s'agit du cœur et de la base de la pile technologique Spring et a été créé pour résoudre la complexité du développement d'applications au niveau de l'entreprise.

    Spring a deux parties principales : IoC et AOP.

cœur	décrire
CIO	L'abréviation d'Inverse of Control, traduite par "inversion de contrôle", fait référence à la remise du processus de création d'objets à Spring pour la gestion.
AOP	L'abréviation de Aspect Oriented Programming, traduit par "programmation orientée aspect". AOP est utilisé pour encapsuler le comportement public de plusieurs classes, et encapsuler la logique qui n'a rien à voir avec le métier mais qui est communément appelée par les modules métier, afin de réduire la duplication de code dans le système et de réduire le couplage entre les modules. En outre, AOP résout également certains problèmes au niveau du système, tels que les journaux, les transactions, les autorisations, etc.

    Spring est une technologie de programmation basée sur les bean qui change profondément le monde du développement Java. Spring utilise des Java Beans simples et basiques pour compléter le travail que seul EJB pouvait faire auparavant, rendant de nombreux codes complexes élégants et concis, évitant le mode de développement gonflé et inefficace des EJB, et facilitant grandement la maintenance et la mise à niveau ultérieures des projets et des extensions.

    Dans le développement réel, les applications côté serveur adoptent généralement une architecture à trois niveaux, qui sont la couche de présentation (web), la couche de logique métier (service) et la couche de persistance (dao).

    Spring s'engage à résoudre chaque couche d'application Java EE et fournit un support technique pour chaque couche.
    Dans la couche de présentation, il fournit l'intégration de Spring MVC, Struts2 et d'autres frameworks ;
    dans la couche de logique métier, il fournit les fonctions de gestion des transactions et d'enregistrement des journaux ;
    dans la couche de persistance, des technologies telles que MyBatis, Hibernate et JdbcTemplate peuvent également être intégré pour accéder à la base de données.

    Cela reflète pleinement le fait que Spring est une solution complète, et Spring ne fera jamais de choses répétitives pour les domaines qui ont déjà de meilleures solutions.

    Du point de vue de la conception, le framework Spring donne aux programmeurs Java un degré de liberté plus élevé et fournit de bonnes solutions aux problèmes courants de l'industrie. Par conséquent, il est largement bien accueilli dans la communauté open source et est considéré comme un projet Java par la plupart des entreprises. Le cadre de développement privilégié.

1.1.3 Fonctionnalités du framework Spring

    Le framework Spring a les caractéristiques suivantes.

    Découplage pratique et développement simplifié : Spring est une grande usine, qui peut confier la création de tous les objets et la maintenance des dépendances à la direction de Spring.

    Intégration pratique de divers excellents frameworks : Spring n'exclut pas divers excellents frameworks open source et fournit un support direct pour divers excellents frameworks (tels que Struts2, Hibernate, MyBatis, etc.).

    Réduire la difficulté d'utilisation de l'API Java EE : Spring fournit des packages pour certaines API (JDBC, JavaMail, appels distants, etc.) très difficiles à utiliser dans le développement Java EE, ce qui réduit considérablement la difficulté d'utilisation de ces API.

    Test de programme pratique : Spring prend en charge JUnit4, et les programmes Spring peuvent être facilement testés via des annotations.

    Prise en charge de la programmation AOP : Spring fournit une programmation orientée aspect, qui peut facilement implémenter des fonctions telles que l'interception des autorisations et la surveillance du fonctionnement des programmes.

    Prise en charge des transactions déclaratives : la gestion des transactions ne peut être effectuée que par configuration, sans programmation manuelle.

1.2 Architecture du ressort

    Le framework Spring est une architecture en couches. Chaque module peut exister indépendamment ou être implémenté conjointement avec d'autres modules. Son architecture est illustrée dans la figure suivante :

     Spring Core : le module Core est la bibliothèque de classes principale de Spring. Toutes les fonctions de Spring dépendent de cette bibliothèque de classes. Core implémente principalement les fonctions IOC, et toutes les fonctions de Sprign sont réalisées à l'aide d'IOC.
    
    Spring AOP : le module AOP est la bibliothèque AOP de Spring, qui prend en charge la programmation orientée aspect pour les objets gérés par le conteneur Spring.
    
    Spring DAO : Spring prend en charge JDBC, encapsule JDBC, permet à JDBC d'utiliser les ressources Spring et fournit une gestion des transactions basée sur le module AOP.
    
    Spring ORM : le module ORM de Spring fournit une gestion et un support auxiliaire pour les frameworks ORM couramment utilisés. Spring prend en charge les frameworks couramment utilisés tels que Hibernate, ibtas et jdo. Spring lui-même n'implémente pas ORM, mais encapsule uniquement les frameworks ORM courants et les gère.
    
    Spring Context : le module Context fournit une méthode d'accès au bean de style framework, et d'autres programmes peuvent accéder aux ressources Bean de Spring via le contexte. Ajout de la prise en charge de l'internationalisation, de la propagation des événements et de la validation, ainsi que de la prise en charge de nombreux services d'entreprise et de l'intégration du framework de modèles.
    
    Spring Web : Le module WEB est construit sur le module Context, fournissant un contexte adapté aux applications Web. De plus, l'intégration de Spring et d'autres frameworks Web (tels que Struts1, Struts2, JSF) est également fournie.
    
    Spring Web MVC : le module WEB MVC fournit à Spring un ensemble d'implémentations MVC légères. Il s'agit d'une application Web complète qui prend en charge un grand nombre de technologies d'affichage, telles que JSP, Velocity et POI.

1.3 Comprendre l'inversion de contrôle et l'injection de dépendance

    IoC est l'abréviation d'inversion de contrôle, traduit par "inversion de contrôle". Ce n'est pas une technologie, mais une idée de conception. C'est une règle de programmation orientée objet importante qui peut nous guider sur la façon de concevoir un programme faiblement couplé et meilleur.

    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 un objet Java géré par le conteneur IoC un Spring Bean, qui ne peut être distingué d'un objet Java créé à l'aide du mot-clé new.

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

1.3.1 Compréhension populaire

Classe d'adresse :

public class Address {
    
    /**
     * 在Address类中使用到了String类与Integer类
     * 可以理解为，Address类依赖了String,Integer
     */
    private String city; //城市
    private String street; //街道
    private Integer no; //门牌号

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public Integer getNo() {
        return no;
    }

    public void setNo(Integer no) {
        this.no = no;
    }
}

Classe personne :

public class Person {
    /**
     * Person类依赖了String, Integer, Address类
     */
    private String name;
    private Integer age;
    private Address address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public void show(){
        System.out.println("hello");
    }
}

test:

public class SpringTest {
    @Test
    public void testNewObject() {
        //传统创建对象的方式：由代码编写者创建对象，对象的生命周期由程序员决定
        //根据对象定义位置的不同，对象的生命周期也不相同
        System.out.println("address对象的生命周期开始");
        if (true) {
            Address address = new Address();

            //使用对象
            address.setCity("郑州市");
            address.setStreet("迎春路");
            System.out.println(address.getCity());

            //如果把创建Address对象的代码放在if语句块中,那么if执行结束,我们可以认为对象生命周期就结束了
        }

        //System.out.println(address); //定义在if中,在if外无法使用address

        //如果Address对象放在test1()中,那么方法执行结束,我们可以认为对象生命周期就结束了
        System.out.println("address对象的生命周期结束");
    }

    @Test
    public void testIOC() {
        /*
         * 控制反转：IOC
         * 将创建对象的权力转交给Spring，由Spring来负责对象的创建、销毁和管理
         * 程序员无需创建对象，只需要从Spring容器中获取对象和使用对象即可
         */
    }

    @Test
    public void testDI() {
        Address address = new Address();

        /*
         * 首先我们理解什么是依赖：
         *  在Address类中使用到了String类与Integer类
         *  可以理解为，Address类依赖了String,Integer
         */
        //那么为依赖类型的属性赋值，就叫做依赖注入
        address.setCity("郑州市");
        address.setStreet("迎春路");
        address.setNo(18);

        Person p = new Person();
        //注入字面值
        p.setName(new String("张三"));
        p.setAge(new Integer(20));
        //注入其他的对象
        p.setAddress(address);
    }
}

1.3.2 Inversion de contrôle

    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 ce dernier objet dans son code via new Object() avant de réaliser la propriété ou la méthode de transfert. Pour la commodité de la compréhension et de la description, nous pouvons désigner le premier comme "l'appelant" et le second comme "l'appelé". En d'autres termes, l'appelant détient le contrôle sur la création de l'objet appelé.

    Mais dans l'application Spring, le contrôle de la création d'objets Java est entre les mains du conteneur IOC, et les étapes générales sont les suivantes.
        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 <bean> dans les fichiers de configuration XML, l'utilisation d'annotations @Component sur les classes Java, etc.
        
        2. Au démarrage de Spring, le conteneur IoC créera et gérera automatiquement ces objets en fonction de 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 certain bean, nous pouvons l'obtenir directement à partir du conteneur IOC (par exemple, via la méthode getBean() de ApplicationContext), sans le créer manuellement via du code (par exemple, la méthode de new Object( )).

    Le plus grand changement apporté par IoC n'est pas au niveau du code, mais un changement de "transposition maître-esclave" au niveau idéologique. À l'origine, l'appelant est la partie active et il prendra l'initiative de créer la ressource qu'il souhaite utiliser ; mais dans l'application Spring, le conteneur IOC détient l'initiative et l'appelant devient la partie passive, attendant passivement l'IOC. container Crée les objets (Bean) dont il a besoin.

    Ce processus a une inversion de contrôle au niveau de la responsabilité, et la création d'objets initialement mis en œuvre par l'appelant via le code est inversée vers le conteneur IOC pour obtenir de l'aide. Par conséquent, nous appelons ce processus "l'inversion de contrôle" de Spring.

1.3.3 Injection de dépendance

    Après avoir compris IoC, nous devons également comprendre un autre concept très important : l'injection de dépendances.

    L'injection de dépendance (DI en abrégé) a été proposée par Martin Fowler en 2004 lors de l'explication de "l'inversion du contrôle". Martin Fowler pense que le terme "inversion de contrôle" est très obscur et qu'il est impossible pour les gens de comprendre directement "où est l'inversion", il suggère donc d'utiliser "l'injection de dépendance" au lieu de "l'inversion de contrôle".

    En orienté objet, il existe une relation appelée "dépendance" entre les objets. En termes simples, une relation de dépendance est qu'un objet doit utiliser un autre objet, c'est-à-dire qu'il y a un attribut dans l'objet et que l'attribut est un objet d'une autre classe.

Par exemple, il existe une classe Java nommée B dont le code est le suivant :

public class B {
    String bid;
    A a;
}

    On peut voir à partir du code qu'il existe un attribut d'objet a de type A dans B, à ce moment on peut dire que l'objet de B dépend de l'objet a. Et l'injection de dépendance est basée sur cette "relation de dépendance".

    Nous savons que l'idée centrale de l'inversion de contrôle est que Spring est responsable de la création d'objets. Pendant le processus de création d'objet, Spring injectera automatiquement l'objet dont il dépend dans l'objet actuel en fonction de la relation de dépendance, appelée "injection de dépendance".

1.3.4 Fonctionnement des IOC

    Dans le processus de développement de logiciels Java, il existe plus ou moins certaines relations de couplage entre les objets du système, entre les modules et entre les systèmes logiciels et les systèmes matériels.

    Si le couplage d'un système est trop élevé, cela entraînera des problèmes difficiles à maintenir, mais le code sans couplage du tout ne peut pratiquement pas effectuer de travail, car presque toutes les fonctions nécessitent la coopération et l'interdépendance entre les codes pour se terminer. Ainsi, lorsque nous concevons des programmes, l'idée que nous défendons est généralement de minimiser le degré de couplage sans affecter les fonctions du système.

    La couche inférieure d'IoC réduit au minimum le degré de couplage du code grâce au mode usine, au mécanisme de réflexion Java, à l'analyse syntaxique XML et à d'autres technologies.Les principales étapes sont les suivantes.
        1. Dans le fichier de configuration (tel que Bean.xml), configurez chaque objet et les dépendances entre eux ;
        
        2. Nous pouvons considérer le conteneur IoC comme une usine, et le produit de cette usine est Spring Bean ;
        
        3. Lorsque le conteneur démarre Ces fichiers de configuration seront chargés et analysés pour obtenir les informations de base des objets et de leurs dépendances ;
        
        4. IoC utilise le mécanisme de réflexion de Java pour générer les objets correspondants (c'est-à-dire les Spring Beans) en fonction des noms de classe, et convertit cet objet en fonction des dépendances Injecté dans les objets qui en dépendent.

    É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 et ne sont pas étroitement couplées dans le code, même si l'objet change, nous n'avons qu'à le modifier dans le fichier de configuration au lieu de modifier le code Java, qui est le principe du découplage Spring IoC.

1.4 Créer un environnement de développement Spring

1.4.1 Créer un projet Java

    Dans le module de base de Spring, il n'y a pas de contenu Web et il n'est pas nécessaire de créer un projet JavaWEB, juste un projet Java.

1.4.2 Importer le package core jar

Paquets de base du framework Spring :

nom	effet
printemps-core-xxxx.jar	Contient les classes d'outils de base du framework Spring, et les autres composants Spring doivent utiliser les classes de ce package, qui est le noyau de base des autres composants.
printemps-haricots-xxxx.jar	Utilisé par toutes les applications, il contient toutes les classes liées à l'accès aux fichiers de configuration, à la création et à la gestion des beans et à l'exécution d'opérations d'inversion de contrôle (IoC) ou d'injection de dépendance (DI).
ressort-contexte-xxxx.jar	Spring fournit des services étendus basés sur les fonctions IoC de base et prend également en charge de nombreux services de niveau entreprise, tels que les services de messagerie, la planification des tâches, l'emplacement JNDI, l'intégration EJB, l'accès à distance, la mise en cache et l'encapsulation de divers cadres de couche de vue.
printemps-expression-xxxx.jar	Définit le langage d'expression de Spring. Il convient de noter que lors du développement avec Spring, en plus du package JAR fourni avec Spring, un package JAR tiers commons.logging est requis pour traiter les informations de journal.

Méthode 1 : Importer le package jar

 Méthode 2 : configuration de la dépendance Maven

<dependencies>
    <!-- spring核心包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springbeans包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springcontext包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- spring表达式包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

1.4.3 Écrire des beans

HelloWorld.java

public class HelloWorld {
    
    public String show() {
        return "Hello Spring";
    }
}

1.4.4 Écrire des fichiers de configuration Spring

    applicationContext.xml est le nom par défaut et sa fonction est de configurer les objets Bean qui doivent être gérés par Spring dans le conteneur SpringIOC.
    
    La gestion de la configuration de Spring peut être configurée à l'aide de XML, et il existe un concept d'espace de noms dans XML. En fait, c'est un peu similaire à la signification des balises. Après avoir donné un espace de noms, les balises dans le contexte de cet espace de noms peuvent être utilisées dans ce fichier XML.
    
    1. beans : le nœud racine du fichier xml.
    
    2. xmlns : est l'abréviation de XML NameSpace, car les noms de balises des fichiers XML sont tous personnalisés, les balises écrites par soi-même et définies par d'autres sont susceptibles d'être nommées à plusieurs reprises, mais les fonctions sont différentes, donc un espace de noms doit être ajouté Pour distinguer ce fichier xml des autres fichiers xml, similaire au package en java.
    
    3. xmlns:xsi : signifie que le fichier xml est conforme à la spécification xml, et le nom complet de xsi : l'instance de schéma xml fait référence à la spécification que les éléments définis dans le fichier de ressources de schéma utilisé dans l'application spécifique doivent respecter. Autrement dit, à quelles normes les éléments définis dans le fichier http://www.w3.org/2001/XMLSchema-instance sont-ils conformes.
    
    4. xsi:schemaLocation : fait référence aux normes auxquelles les éléments xml de ce document sont conformes. Ces normes sont toutes formulées par le gouvernement. Vous pouvez accéder au site Web que vous avez écrit pour voir les changements de version. L'URL du xsd peut également vous aider à déterminer si le code que vous utilisez est légal.

<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring配置文件xml，采用schema约束规范（一个xml文件可以采用多个文件的规范） -->
<!--
	xmlns：扩展当前xml的规范
	xsi:schemaLocation：规范文件，成对出现
-->
<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">
    
    <!-- 配置bean：将Java中类的对象托管给springIOC容器 -->
    <bean id="helloworld" class="com.newcapec.bean.HelloWorld"></bean>
</beans>

La différence entre Schema et DTD :

    Le schéma est la définition et la description de la structure du document XML, et sa fonction principale est de contraindre le document XML et de vérifier la validité du document XML. Le rôle de la DTD est de définir les blocs de construction juridiques de XML, qui utilisent une série d'éléments juridiques pour définir la structure du document. Les différences entre eux sont les suivantes :

    1. Schema lui-même est également un document XML. La définition DTD n'a rien à voir avec XML. Schema présente de nombreux avantages en termes de compréhension et d'application pratique.

    2. La structure du document DTD est "plate". Si vous définissez un document XML complexe, il est difficile de saisir la relation d'imbrication entre chaque élément ; le document Schema a une structure forte et la relation d'imbrication entre chaque élément est très intuitif.

    3. DTD peut uniquement spécifier que l'élément contient du texte et ne peut pas définir le type spécifique de texte de l'élément, tel que le type de caractère, le type entier, le type de date, le type personnalisé, etc. Les schémas sont plus solides que les DTD à cet égard.

    4. Le schéma prend en charge la description de l'ordre des nœuds d'éléments. La DTD ne fournit pas de description des situations désordonnées. Pour définir des situations désordonnées, toutes les situations doivent être classées de manière exhaustive. Schema peut utiliser xs:all pour représenter des situations non ordonnées.

    5. Prise en charge des espaces de noms. DTD ne peut pas tirer parti des espaces de noms XML et Schema satisfait très bien les espaces de noms. De plus, Schema propose également d'inclure et d'importer deux méthodes de référencement des espaces de noms.

    6. XML Schema ne peut pas définir des entités comme DTD, et est plus compliqué que DTD, mais Xml Schema est maintenant la norme de l'organisation w3c, et il remplace progressivement DTD.

Avantages du schéma :

    1. Lorsque les utilisateurs XML utilisent XML Schema, ils n'ont pas besoin de réapprendre à comprendre XML Schema, ce qui fait gagner du temps ;
    
    2. Étant donné que XML Schema lui-même est également une sorte de XML, de nombreux outils d'édition XML, kits de développement d'API et analyse de syntaxe XML Les filtres peuvent être appliqués directement au schéma XML sans modification.
    
    3. En tant qu'application de XML, XML Schema hérite naturellement de l'autodescription et de l'extensibilité de XML, ce qui rend XML Schema plus lisible et flexible.
    
    4. Étant donné que le format est exactement le même que XML, XML Schema peut non seulement être traité comme XML, mais également être stocké de la même manière que le document XML qu'il décrit, ce qui est pratique pour la gestion.
    
    5. La cohérence entre le schéma XML et le format XML facilite l'échange de schémas entre les systèmes d'application qui utilisent XML comme échange de données.
    
    6. XML a des exigences de légalité très élevées. La description de XML dans XML DTD est souvent utilisée comme base pour vérifier la légalité de XML. Cependant, la légalité de XML DTD elle-même manque d'un bon mécanisme de vérification et doit être gérée de manière indépendante. XML Schema est différent, il a le même mécanisme de vérification de la légalité que XML.

1.4.5 Tests

@Test
public void testSpringIOC() {
    //1、创建IOC容器ApplicationContext
    //ClassPathXmlApplicationContext是ApplicationContext接口的实现类，该对象通过加载类路径下面的spring配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

    //2、从容器中获取bean对象
    /**
         * Object getBean(String name)
         * 参数name: 获取对象的名称，对象的唯一标识符，bean标签的id属性值
         * 返回值Object: 对象
         */
    Object obj = ac.getBean("helloworld");
    System.out.println(obj instanceof HelloWorld);
    HelloWorld helloWorld = (HelloWorld) obj;
    String str = helloWorld.show();
    System.out.println("方法的返回值为：" + str);

    Object obj1 = ac.getBean("helloworld");

    System.out.println(obj == obj1);
}

Il y a deux choses à noter à propos du code ci-dessus :

• La classe ClassPathXmlApplicationContext est utilisée lors de la création de l'objet ApplicationContext. Cette classe est utilisée pour charger le fichier de configuration Spring, créer et initialiser tous les objets (Bean).

• La méthode ApplicationContext.getBean() est utilisée pour obtenir le Bean, et le type de valeur de retour de cette méthode est Object, qui est converti en un objet d'instance de HelloWorld via une conversion de type obligatoire, et la méthode show() qu'elle contient est appelée.