Explication détaillée du printemps (super complète)

Language 2023-08-19 01:34:42 views: null

Table des matières:

1. Printemps

​ Spring fait partie des frameworks SSM (Spring, SpringMVC, Mybatis). Le soi-disant cadre est une conception qui extrait fortement le code réutilisable et est très polyvalente ;

1. Vue d'ensemble

(1) Spring est un framework open source ;

(2) Spring est né pour simplifier le développement au niveau de l'entreprise. En utilisant Spring, JavaBean peut rendre le code très élégant et concis ;

(3) Spring est un cadre de conteneur IoC (DI) et AOP ;

(4) Excellentes caractéristiques du printemps

​ Non intrusif : les objets dans les applications développées sur la base de Spring peuvent ne pas dépendre des API Spring

​ Injection de dépendance : DI (Dependency Injection), l'implémentation la plus classique de l'Inversion de Contrôle (IoC) ;

​ Programmation Orientée Aspect : AOP (Programmation Orientée Aspect)

Conteneur : Spring est un conteneur car il contient et gère le cycle de vie des objets applicatifs

(5) Composantisation : Spring réalise la combinaison de configurations de composants simples dans une application complexe. Dans Spring, des annotations XML et Java peuvent être utilisées pour combiner ces objets ;

(6) Guichet unique : sur la base d'IoC et d'AOP, des frameworks open source et d'excellentes bibliothèques de classes tierces de diverses applications d'entreprise peuvent être intégrés (en fait, Spring lui-même fournit également Spring MVC pour la couche de présentation et Spring JDBC pour couche de persistance);

(7) Module ressort

[Le transfert d'image du lien externe a échoué, le site source peut avoir un mécanisme anti-leeching, il est recommandé d'enregistrer l'image et de la télécharger directement (img-TE3J19zB-1682512561625) (C:\Users\admin\Desktop\ssm\spring component image.png)]

expliquer:

Chaque boîte verte représente un module fonctionnel ; la boîte noire dans la boîte verte représente les emballages de pots nécessaires pour utiliser ce module fonctionnel.

2. Pourquoi utiliser Spring

(1) 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 gestion de Spring.

(2) Intégration pratique de divers excellents cadres

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

(3) 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'application de ces API.

(4) Test de programme pratique

Spring prend en charge JUnit4, ce qui facilite le test des programmes Spring via des annotations.

(5) 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.

(6) Prise en charge des transactions déclaratives

La gestion des transactions ne peut être complétée que par configuration, sans programmation manuelle ;

En tant que programmeur Java, le degré de compréhension et de maîtrise de Spring est essentiellement l'incarnation de la capacité de programmation.

3. Première expérience printanière

  1. Créer un projet Maven

    Cochez Construire par archétype, sélectionnez maven-archetype-quickstart

  2. importer des dépendances

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
  1. Créer une interface et une classe d'implémentation
public interface UserDao {
    
    
    void queryAll();
}

public class UserDaoImpl implements UserDao {
    
    
    public UserDaoImpl(){
    
    
        System.out.println("UserDaoImpl对象创建了");
    }

    @Override
    public void queryAll() {
    
    
        System.out.println("查询了所有用户信息");
    }
}
  1. Créer un fichier de configuration Spring

​ Créez spring-config.xml dans le répertoire des ressources du projet. Dans l'idée, vous pouvez utiliser le menu Nouveau -> Fichier de configuration XML -> Spring Config directement dans le répertoire des ressources à créer.

<?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">
    <!--
        bean标签进行描述
        id指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
        class指定创建对象的类的全类名
    -->
    <bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl"/>
</beans>
  1. test
public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        userDaoImpl.selectAll();
    }
}

Deux, IoC

1. Conception

​IoC (Inversion de Contrôle) est l'Inversion de Contrôle. Avant d'utiliser Spring, nous utilisions presque toujours la nouvelle méthode pour obtenir des objets, mais après avoir utilisé Spring, nous n'utilisons plus la nouvelle méthode pour créer des objets, mais laissons Spring les créer pour nous. Le transfert de contrôle est appelé inversion de contrôle.

2. Conteneur IoC

  • Le conteneur IoC est le cœur de Spring et peut également être appelé le conteneur Spring. Spring utilise le conteneur IoC pour gérer l'instanciation et l'initialisation des objets, ainsi que le cycle de vie complet des objets, de la création à la destruction.

  • Les objets utilisés dans Spring sont tous gérés par le conteneur IoC, et nous n'avons pas besoin d'utiliser manuellement le nouvel opérateur pour créer des objets. Les objets gérés par le conteneur IoC sont appelés Spring Beans, et les Spring Beans sont des objets Java, qui ne sont pas différents des objets créés avec l'opérateur new.

  • Spring obtient quels objets doivent être instanciés en lisant des informations dans des annotations XML ou Java.

  • Spring fournit 2 types différents de conteneurs IoC, les conteneurs BeanFactory et ApplicationContext.

2.1 Bean Factory

Le conteneur BeanFactory, l'interface de niveau le plus bas de Spring, fournit les fonctions de conteneur les plus simples et ne fournit que les fonctions d'instanciation d'objets et de prise d'objets ; BeanFactory n'instanciera pas de beans au démarrage. Bean sera uniquement instancié ;

BeanFactory ac = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

2.2 ApplicationContext

Le contexte d'application, qui hérite de l'interface BeanFactory, est un conteneur plus avancé de Spring et fournit des fonctions plus utiles ; ApplicationContext ajoute de nombreuses fonctions au niveau de l'entreprise sur la base de BeanFactory, telles que l'AOP, l'internationalisation, le support des transactions, etc. ; ApplicationContext instancie tous les haricots quand il commence. Il peut également configurer lazy-init=true pour que Bean retarde l'instanciation de Bean ; l'interface ApplicationContext a deux classes d'implémentation couramment utilisées :

2.2.1 ClassPathXmlApplicationContext

Cette classe recherche le fichier de configuration XML spécifié à partir du chemin de classe ClassPath et termine l'instanciation de ApplicationContext, comme suit :

ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");

2.2.2 FileSystemXmlApplicationContext

Cette classe recherche le fichier de configuration XML spécifié à partir du chemin du système de fichiers spécifié et termine l'instanciation de ApplicationContext, comme suit :

ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\workspace\\spring_demo\\src\\main\\resources\\spring-config.xml");

3. Création du haricot de printemps

Les objets gérés par le conteneur Spring IoC sont appelés beans, et les beans sont créés sur la base des informations du fichier de configuration Spring. En général, nous gérons les beans dans les fichiers de configuration Spring.

Dans le fichier de configuration de Spring, il est enveloppé par un ensemble d' <beans></beans>étiquettes, dans lequel <bean></bean>les étiquettes sont utilisées pour gérer chaque objet.

1. Aucune création de construction de paramètres

​ Pour créer un bean de cette manière, vous devez avoir une structure sans paramètre, sinon une erreur sera signalée dans le fichier de configuration de Spring

<?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">
    <!--
        bean标签进行描述
        id指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
        class指定创建对象的类的全类名
    -->
    <bean id="userDaoImpl" class="com.hqyj.dao.impl.UserDaoImpl" lazy-init="true"/>
</beans>

1.1 Attributs de la balise bean

Nom d'attribut décrire
identifiant L'identifiant unique du bean, ainsi que la configuration et la gestion du bean par le conteneur Spring sont effectués via cette propriété. La valeur de id doit commencer par une lettre et des symboles tels que des lettres, des chiffres et des traits de soulignement peuvent être utilisés.
nom Plusieurs noms peuvent être spécifiés pour le Bean dans l'attribut name, et chaque nom est séparé par une virgule ou un point-virgule. Le conteneur Spring peut configurer et gérer le bean dans le conteneur via l'attribut name.
classe Cet attribut spécifie la classe d'implémentation spécifique du bean, qui doit être un nom de classe complet, c'est-à-dire le nom complet de la classe.
portée Il est utilisé pour définir la portée de l'instance de Bean, et la valeur de l'attribut peut être singleton (singleton), prototype (prototype), request, session et global Session. Sa valeur par défaut est singleton
constructeur-arg L'élément enfant de l'élément, qui peut être instancié en transmettant les paramètres de construction de cet élément. L'attribut index de cet élément spécifie le numéro de série du paramètre de construction (à partir de 0), et l'attribut type spécifie le type du paramètre de construction
propriété Le sous-élément de l'élément est utilisé pour appeler la méthode setter dans l'instance Bean pour attribuer des valeurs de propriété, complétant ainsi l'injection de dépendance. L'attribut name de cet élément est utilisé pour spécifier le nom de la propriété correspondante dans l'instance du Bean
réf Les sous-éléments d'éléments tels que et , l'attribut bean dans cet élément est utilisé pour spécifier une référence à une instance Bean
valeur Les éléments enfants d'éléments tels que et sont utilisés pour spécifier directement une valeur constante
liste Injection de dépendances pour encapsuler les types de liste ou de tableau
ensemble Injection de dépendances pour encapsuler les types Set
carte Injection de dépendances pour encapsuler les types Map
entrée 元素的子元素，用于设置一个键值对。其 key 属性指定字符串类型的键值，ref 或 value 子元素指定其值
méthode init Cette méthode est appelée lorsque le conteneur charge le bean, similaire à la méthode init() dans Servlet
méthode de destruction Cette méthode est appelée lorsque le conteneur supprime le bean, similaire à la méthode destroy() du servlet. Cette méthode n'est valide que lorsque scope=singleton
lazy-init Chargement différé, si la valeur est true, le conteneur créera une instance de Bean à la première requête ; si la valeur est false, le conteneur créera une instance de Bean au démarrage. Cette méthode n'est valide que lorsque scope=singleton

2. Création du mode usine dynamique

  1. Créer une usine UserDaoFactory
public class UserDaoFactory {
    
    
    public UserDao getUserDao(){
    
    
        return new UserDaoImpl();
    }
}
  1. Fichier de configuration de printemps
<!-- 通过普通工厂创建bean-->
<!-- 第一步，将工厂类本身加入ioc容器-->
<bean id="userDaoFactory" class="com.hqyj.cl.dao.impl.UserDaoFactory"/>
<!-- 第二步，配置bean 
    factory-bean指定由ioc容器创建的工厂bean
    factory-method指定的该工程的工厂方法 -->
<bean id="userDaoImpl" factory-bean="userDaoFactory" factory-method="getUserDao"/>

3. Création du mode usine statique

  1. Créer une usine UserDaoFactory
public class UserDaoFactory {
    
    
    public static UserDao getUserDao02(){
    
    
        return new UserDaoImpl();
    }
}
  1. Fichier de configuration de printemps
<!-- 第二步，配置bean 
	id指定创建出来的对象在核心容器中的名字(name)，用作唯一标识
	class指定创建对象的类的全类名
    factory-method指定的该工程的静态工厂方法 -->
<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoFactory" factory-method="getUserDao02"/>

Quatrièmement, la portée de Spring Bean

Portée Description
singleton (Par défaut) Étend une seule définition de bean par conteneur Spring IoC à une seule instance d'objet.
prototype Étend une définition de bean unique à n'importe quel nombre d'instances d'objet.
demande Étend une définition de bean unique à la durée de vie d'une seule requête HTTP. Autrement dit, chaque requête HTTP a une instance de bean créée derrière une seule définition de bean. Uniquement disponible dans un Spring ApplicationContext compatible réseau.
session Portez une définition de bean unique à la durée de vie d'une session HTTP. Valide uniquement dans le contexte d'un Spring ApplicationContext compatible réseau.
application 8 Limitez la portée d'une définition de bean unique au cycle de vie du ServletContext. Valide uniquement dans le contexte d'un Spring ApplicationContext compatible réseau.
WebSocket Portez une définition de bean unique à la durée de vie d'un WebSocket. Valide uniquement dans le contexte d'un Spring ApplicationContext compatible réseau.

4.1 Exemple de code

4.1.1 singleton

  1. Fichier de configuration de printemps
<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="singleton"/>
  1. classe d'essai
public class UserDaoTest {
    
    
    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        UserDao userDaoImpl1 = ac.getBean("userDaoImpl", UserDao.class);
        System.out.println(userDaoImpl==userDaoImpl1);
    }
}

La sortie du résultat est vraie. L'instruction de sortie de construction sans argument écrite dans la classe UserDaoImpl ne sera sortie qu'une seule fois, indiquant que l'objet n'est créé qu'une seule fois.

4.1.2 prototype

  1. Fichier de configuration de printemps
<bean id="userDaoImpl" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="prototype"/>
  1. classe d'essai
public class UserDaoTest {
    
    
    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        UserDao userDaoImpl = ac.getBean("userDaoImpl", UserDao.class);
        UserDao userDaoImpl1 = ac.getBean("userDaoImpl", UserDao.class);
        System.out.println(userDaoImpl==userDaoImpl1);
    }
}

La sortie du résultat est fausse. L'instruction de sortie de construction sans argument écrite dans la classe UserDaoImpl sera sortie deux fois, indiquant que l'objet a été créé deux fois.

Cinq, le cycle de vie de Spring Bean

  • Dans une application Java traditionnelle, le cycle de vie d'un bean est très simple. Le bean est instancié à l'aide du mot-clé new, et lorsque le bean n'est pas nécessaire, Java effectue automatiquement le ramasse-miettes.

  • Le cycle de vie de Bean in Spring est plus compliqué, ce qui peut être exprimé comme suit : Définition du bean -> Initialisation du bean -> Utilisation du bean -> Destruction du bean.

  • Spring choisit la méthode de gestion en fonction de la portée du bean. Pour les beans avec une portée singleton, Spring peut savoir exactement quand le bean est créé, quand il est initialisé et quand il est détruit ; pour les beans avec une portée prototype, Spring n'est responsable que de la création, lorsque le conteneur crée une instance du bean After Ainsi, l'instance Bean est transmise à la gestion du code client et le conteneur Spring ne suivra plus son cycle de vie.

  • Lors de la configuration d'un bean en XML, vous pouvez utiliser l'attribut init-method et l'attribut destroy-method dans la balise Bean pour définir respectivement la méthode de rappel d'initialisation et la méthode de rappel de destruction du bean.

5.1 Exemple de code

  1. utilisateurDao
public class UserDaoImpl implements UserDao {
    
    

    public UserDaoImpl(){
    
    
        System.out.println("UserDaoImpl对象创建了");
    }

    @Override
    public void selectAll() {
    
    
        System.out.println("执行了selectAll方法");
    }

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

    public void destroy(){
    
    
        System.out.println("destroy");
    }
}
  1. Fichier de configuration de printemps
<bean id="userDaoImpl1" class="com.hqyj.cl.dao.impl.UserDaoImpl" scope="prototype"
      init-method="init" destroy-method="destroy"/>
  1. classe d'essai
public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        ac.registerShutdownHook();
    }
}

Dans le mode singleton des applications non Web, chargez manuellement le conteneur Spring IoC, utilisez l'interface AbstractApplicationContext pour hériter de l'interface ApplicationContext, et la méthode registerShutdownHook/close peut fermer manuellement le conteneur et laisser la méthode destroy exécuter la méthode correspondante.

六、MAR

​ DI (Dependency Injection), c'est-à-dire "injection de dépendance": la dépendance entre les composants est déterminée par le conteneur au moment de l'exécution, c'est-à-dire que le conteneur injecte dynamiquement une certaine dépendance dans le composant. Le but de l'injection de dépendances n'est pas d'apporter plus de fonctions au système logiciel, mais d'augmenter la fréquence de réutilisation des composants et de construire une plate-forme flexible et évolutive pour le système. Grâce au mécanisme d'injection de dépendances, nous n'avons qu'à spécifier les ressources requises par la cible sans aucun code via une configuration simple, et compléter notre propre logique métier, sans nous soucier de l'origine des ressources spécifiques et de qui les implémente.

Il existe deux implémentations principales de l'injection de dépendances, à savoir l'injection de setter et l'injection de constructeur.

6.1 Injection de l'incubateur

​ Fait référence au conteneur IoC utilisant la méthode setter pour injecter l'instance dépendante. L'injection de dépendance basée sur le setter peut être réalisée en appelant la méthode setter du bean après avoir instancié le bean en appelant le constructeur sans argument ou la méthode de fabrique statique sans argument.

Dans le processus d'instanciation de Bean dans Spring, le constructeur par défaut est d'abord appelé pour instancier l'objet Bean, puis la méthode setXxx() est appelée via le mécanisme de réflexion de Java pour injecter des propriétés. Par conséquent, l'injection de setter nécessite que la classe correspondante du Bean réponde aux deux exigences suivantes :

  • Un constructeur sans argument par défaut doit être fourni ;

  • Des méthodes setter correspondantes doivent être fournies pour les propriétés qui doivent être injectées.

    Lorsque vous utilisez l'injection de setter, dans le fichier de configuration Spring, vous devez utiliser <bean>les éléments enfants de l'élément <property>pour injecter des valeurs pour chaque attribut ; utilisez l'injection de construction

, dans le fichier de configuration, utilisez principalement <constructor-arg>la balise pour définir les paramètres de la méthode de construction, et utilisez son attribut value (ou sous-élément) pour définir la valeur du paramètre.

6.1.1 Exemple de codes

La balise<property> contient des attributs tels que name, ref et value. name est utilisé pour spécifier le nom du paramètre ; l'attribut value est utilisé pour injecter la valeur du type de données de base et du type de chaîne ; l'attribut ref est utilisé pour injecter le bean défini

  1. Créer un utilisateur de classe Java
public class User {
    
    
    private int id;
    private String username;
    private String password;

    public User() {
    
    
    }

    public User(int id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
  1. Fichier de configuration de printemps
<?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">
    <bean id="user" class="com.hqyj.cl.pojo.User">
        <property name="id" value="1"/>
        <property name="username" value="chenlei"/>
        <property name="password" value="111"/>
    </bean>
</beans>
  1. classe d'essai
public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = ac.getBean("user", User.class);
        System.out.println(user);
    }
}

6.2 Constructeur

​ Fait référence au conteneur IoC utilisant le constructeur pour injecter l'instance dépendante. L'injection de dépendances peut être implémentée en appelant un constructeur avec des paramètres, chaque paramètre représentant une dépendance.

Il existe trois manières d'injecter des instances dépendantes à l'aide de constructeurs : via l'injection d'indices, via l'injection d'attributs et via l'injection de noms de paramètres.

6.2.1 Définir une classe d'utilisateurs

public class User {
    
    
    private int id;
    private String username;
    private String password;

    public User() {
    
    
    }

    public User(int id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    @Override
    public String toString() {
    
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

6.2.2 Injection par indice

​ Lorsque le constructeur a plusieurs paramètres, vous pouvez utiliser l'attribut index pour spécifier la position des paramètres. La valeur de l'attribut index commence à 0. Si vous ne spécifiez pas l'index, la séquence d'étiquettes est utilisée par défaut.

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg index="0" value="1"/>
    <constructor-arg index="1" value="chenchen"/>
    <constructor-arg index="2" value="23"/>
</bean>

6.2.3 Injection via les propriétés

​ L'attribut name est injecté en spécifiant le nom du paramètre dans la méthode de construction, c'est le plus couramment utilisé et doit être maîtrisé

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg type="int" value="2"/>
    <constructor-arg type="java.lang.String" value="chenchen"/>
    <constructor-arg type="java.lang.String" value="123"/>
</bean>

6.2.4 Injection par nom de paramètre

<bean id="user" class="com.hqyj.cl.pojo.User">
    <constructor-arg name="id" value="3"/>
    <constructor-arg name="username" value="chenchen"/>
    <constructor-arg name="password" value="123"/>
</bean>

6.3 Comparaison de l'injection du setter et de l'injection du constructeur

Injection de constructeur :

Avantages : tous les paramètres du constructeur doivent être spécifiés au moment de la création avant que le bean puisse être créé, ce qui garantit qu'après la création de l'objet, les variables membres doivent avoir des valeurs.

Inconvénient : tous les paramètres doivent être spécifiés, sinon l'objet ne peut pas être créé. Utilisez cette méthode pour modifier le processus de création de l'objet.

injection de poseur :

Avantages : Lors de la création d'un objet, il n'est pas nécessaire de spécifier des paramètres et la création d'objets ne sera pas restreinte.
Inconvénient : lorsqu'un objet possède plusieurs propriétés qui peuvent être injectées, il n'y a aucune garantie que toutes ou certaines propriétés seront injectées.
La méthode d'injection du setter est plus flexible et plus pratique à utiliser.

6.4 objet d'injection de setter

Il existe plusieurs cas : type commun, collection List, collection Map, type String, type référence d'objet, collection Set, tableau, Properties, type null

  1. Classe étudiante
public class Student {
    
    
    private String name;
    private Counselor counselor;
    private String[] courses;
    private List<String> books;
    private Map<String, String> idCard;
    private Set<String> studentNumber;
    private String wifeName;
    private Properties properties;

    public Student() {
    
    
    }

    public Student(String name, Counselor counselor, String[] courses, List<String> books, Map<String, String> idCard, Set<String> studentNumber, String wifeName, Properties properties) {
    
    
        this.name = name;
        this.counselor = counselor;
        this.courses = courses;
        this.books = books;
        this.idCard = idCard;
        this.studentNumber = studentNumber;
        this.wifeName = wifeName;
        this.properties = properties;
    }

    public String getName() {
    
    
        return name;
    }

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

    public Counselor getCounselor() {
    
    
        return counselor;
    }

    public void setCounselor(Counselor counselor) {
    
    
        this.counselor = counselor;
    }

    public String[] getCourses() {
    
    
        return courses;
    }

    public void setCourses(String[] courses) {
    
    
        this.courses = courses;
    }

    public List<String> getBooks() {
    
    
        return books;
    }

    public void setBooks(List<String> books) {
    
    
        this.books = books;
    }

    public Map<String, String> getIdCard() {
    
    
        return idCard;
    }

    public void setIdCard(Map<String, String> idCard) {
    
    
        this.idCard = idCard;
    }

    public Set<String> getStudentNumber() {
    
    
        return studentNumber;
    }

    public void setStudentNumber(Set<String> studentNumber) {
    
    
        this.studentNumber = studentNumber;
    }

    public String getWifeName() {
    
    
        return wifeName;
    }

    public void setWifeName(String wifeName) {
    
    
        this.wifeName = wifeName;
    }

    public Properties getProperties() {
    
    
        return properties;
    }

    public void setProperties(Properties properties) {
    
    
        this.properties = properties;
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "name='" + name + '\'' +
                ", counselor=" + counselor +
                ", courses=" + Arrays.toString(courses) +
                ", books=" + books +
                ", idCard=" + idCard +
                ", studentNumber=" + studentNumber +
                ", wifeName='" + wifeName + '\'' +
                ", properties=" + properties +
                '}';
    }
}
  1. Classe de conseiller
public class Counselor {
    
    
    private String name;

    public Counselor() {
    
    
    }

    public Counselor(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

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

    @Override
    public String toString() {
    
    
        return "Counselor{" +
                "name='" + name + '\'' +
                '}';
    }
}
  1. Fichier de configuration de printemps
<!--引用注入-->
<bean id="counselor" class="com.hqyj.cl.pojo.Counselor">
    <property name="name" value="张老师"/>
</bean>
<!--注入学生类-->
<bean id="student" class="com.hqyj.cl.pojo.Student">
    <!--普通值注入-->
    <property name="name" value="chenchen"/>
    <!--引用注入-->
    <property name="counselor" ref="counselor"/>
    <!--数组注入-->
    <property name="courses">
        <array>
            <value>计算机组成原理</value>
            <value>计算机网络</value>
            <value>数据结构</value>
        </array>
    </property>
    <!--List集合注入-->
    <property name="books">
        <list>
            <value>Java入门到放弃</value>
            <value>Python大数据挖掘与分析</value>
        </list>
    </property>
    <!--Map集合注入-->
    <property name="idCard">
        <map>
            <entry key="idCard" value="29121821212"/>
            <entry key="phone" value="123121212121"/>
        </map>
    </property>
    <!--Set集合注入-->
    <property name="studentNumber">
        <set>
            <value>20200301123</value>
        </set>
    </property>
    <!--null注入-->
    <property name="wifeName">
        <null/>
    </property>
    <!--Properties注入-->
    <property name="properties">
        <props>
            <prop key="username">chenchen</prop>
            <prop key="password">112112</prop>
        </props>
    </property>
</bean>
  1. classe d'essai
public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        Student student = ac.getBean("student", Student.class);
        System.out.println(student);
    }
}

7. Configuration basée sur les annotations

Dans Spring, bien que les fichiers de configuration XML puissent être utilisés pour implémenter l'assemblage de Bean, si le nombre de beans dans l'application est important, les fichiers de configuration XML seront trop gonflés, ce qui apportera certaines difficultés à la maintenance et aux mises à jour.

Java a fourni la fonction Annotation depuis JDK 5.0, et Spring 2.5 a également fourni une prise en charge complète de la technologie Annotation.Nous pouvons utiliser des annotations pour configurer l'injection de dépendances.

Spring n'utilise pas d'annotations pour assembler les beans par défaut, vous devez donc ajouter des balises dans le fichier de configuration <context:annotation-config/>pour activer la prise en charge des annotations ;

​:<context:annotation-config/> Cela ne peut fonctionner que sur des grains qui ont déjà été enregistrés. Il n'effectue aucune opération sur les haricots qui ne sont pas enregistrés dans le conteneur de printemps

​:<context:component-scan/> En plus de <context:annotation-config/la fonction >, il a également la fonction d'enregistrer automatiquement des objets avec des annotations telles que @component, @service, @Repositoryetc. dans le conteneur de printemps

​ Annotations d'analyse du package de configuration :

​ <context:component-scan base-package="com.hqyj"/>

1. Créer des annotations liées au haricot

1.1 @Composant

Cette annotation peut être utilisée pour décrire le Bean in Spring, mais il s'agit d'un concept généralisé qui ne représente qu'un composant (Bean) et peut être utilisé à n'importe quel niveau. Lors de son utilisation, il vous suffit de marquer l'annotation sur la classe correspondante.

1.2 @Référentiel

Il est utilisé pour identifier la classe de la couche d'accès aux données (couche DAO) en tant que bean dans Spring, et sa fonction est la même que celle de @Component.

1.3 @Service

​ Agit généralement sur la couche métier (couche service) et est utilisé pour identifier la classe de la couche métier en tant que bean dans Spring, et sa fonction est la même que @Component.

1.4 @Contrôleur

Agit généralement sur la couche de contrôle (comme Action de Struts2, Controller de SpringMVC), et est utilisé pour identifier la classe de la couche de contrôle en tant que bean dans Spring, et sa fonction est la même que @Component.

2. Annotations relatives au cycle de vie du Bean

2.1 @Portée

L'annotation sur le nom de la classe est utilisée pour spécifier la portée du bean, ce qui équivaut à utiliser l'attribut scope lors de la configuration du bean dans le fichier xml. Valeurs communes singleton, prototype

2.2 @AprèsConstruction

​ Remarque sur la méthode, spécifiez la méthode de rappel lors de la création du bean. <bean>Cela équivaut à la fonction d'utilisation de l'attribut init-method dans la balise du fichier de configuration xml .

2.3 @PreDestroy

​ Note sur la méthode, spécifiant la méthode de rappel lorsque le bean est détruit. <bean>Cela équivaut à la fonction d'utilisation de l'attribut destroy-method dans la balise du fichier de configuration xml .

2.4 @Configuration

Implémentation complète des annotations, @Configuration est similaire à la balise beans du fichier de configuration xml @bean est similaire à la balise bean

import com.hqyj.pojo.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBean {  //方法返回值就是定义bean的类型 方法名就是id
    @Bean
    public Dog dog(){
        return new Dog("哈士奇","黑白色");
    }
}

public static void main(String[] args) {
    //通过注解Component
    ApplicationContext ac = new AnnotationConfigApplicationContext(MyBean.class);
    Dog dog = ac.getBean("dog", Dog.class);
    System.out.println(dog);
}

3. Annotations liées à l'injection de dépendances

3.1 @Autowired

Câblage automatique :

L'assemblage automatique signifie que le conteneur Spring peut assembler automatiquement (autowire) la relation entre les beans coopérants sans utiliser <constructor-arg>de tags et injecter un bean dans la propriété d'autres beans.<property>

Le câblage automatique permet l'injection de dépendances avec moins de code. Cependant, les types de données simples tels que int, boolean et String ne peuvent pas être automatiquement assemblés. Par rapport à l'assemblage explicite, l'assemblage automatique n'est pas contrôlé par le programmeur.

L'annotation @Autowired peut être appliquée aux variables d'attribut de Bean, aux méthodes de définition d'attribut, aux méthodes et constructeurs non définissables, etc., et coopérer avec le processeur d'annotation correspondant pour terminer la configuration automatique de Bean. Par défaut, il est assemblé selon le type de Bean. L'assemblage automatique ne nécessite pas la méthode de réglage correspondante.

Il y a aussi un attribut autowired dans la balise bean du fichier de configuration

​ byType : Assurez-vous que l'identifiant du bean est unique et que le type du bean est également unique

​ byName : Assurez-vous que l'id du bean est unique et que l'id du bean est le nom de la méthode set correspondant à ce type de propriété

Classe d'utilisateurs

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    @Autowired
    private Address address;
}

Classe d'adresse

@Component
public class Address {
    @Value("chengdu")
    private String addr;

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                '}';
    }
}

Fichier de configuration bean.xml

<bean id="User" class="com.hqyj.pojo.User">
</bean>
<bean id="address" class="com.hqyj.pojo.Address">
</bean>

classe d'essai

public class UserTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        User user = ac.getBean("User", User.class);
        System.out.println(user);
    }
}

3.2 @Ressource

La fonction est la même qu'Autowired, la différence est que @Autowired est assemblé selon le type de Bean par défaut, tandis que @Resource est assemblé selon le nom de l'instance Bean par défaut.

​ Il existe deux attributs importants dans @Resource : le nom et le type.

Spring résout l'attribut name en nom d'instance du Bean et l'attribut type en type d'instance du Bean. Si l'attribut name est spécifié, il sera assemblé par nom d'instance ; si l'attribut type est spécifié, il sera assemblé par type de bean. Si aucun n'est spécifié, assemblez d'abord selon le nom de l'instance de Bean, puis assemblez selon le type de Bean s'ils ne correspondent pas ; s'ils ne correspondent pas, NoSuchBeanDefinitionException sera levée.

Classe d'utilisateurs

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    /*@Autowired
    @Qualifier("address1")*/
    @Resource(name = "address1")  //相当于@Autowired+@Qualifier
    private Address address;
}

3.3 @Qualificatif

​ Utilisé conjointement avec l'annotation @Autowired, l'assembly par défaut par type de Bean sera modifié pour être assemblé par le nom d'instance du Bean, et le nom d'instance du Bean est spécifié par le paramètre de l'annotation @Qualifier. (vous pouvez spécifier le haricot injecté)

Classe d'adresse (supprimer l'annotation @Component)

public class Address {
    private String addr;

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                '}';
    }
}

fichier de configuration

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User">
</bean>
<bean id="address" class="com.hqyj.pojo.Address">
    <property name="addr" value="chengdu"></property>
</bean>
<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>

Classe d'utilisateurs

@Data   //提供了getter  setter方法
@AllArgsConstructor   //提供了有参构造方法
@NoArgsConstructor   //提供了无参构造方法
@Component
public class User {
    @Value("zhangsan")
    private String username;
    @Value("111")
    private String password;
    @Autowired
    @Qualifier("address1")  //指定要注入的bean
    private Address address;
}

classe d'essai

public class UserTest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        User user = ac.getBean("User", User.class);
        System.out.println(user); //拿到haerbin
    }
}

Notes complémentaires:

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User" autowire="byType">
</bean>
<bean id="address" class="com.hqyj.pojo.Address" >
    <property name="addr" value="chengdu"></property>
</bean>
<!--<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>-->

Vous pouvez supprimer l'annotation @autowire dans l'utilisateur et l'ajouter dans le fichier de configuration, et vous pouvez injecter byType, mais le bean injecté doit être unique.

<context:component-scan base-package="com.hqyj.pojo"/>
<bean id="User" class="com.hqyj.pojo.User" autowire="byName">
</bean>
<bean id="address" class="com.hqyj.pojo.Address" >
    <property name="addr" value="chengdu"></property>
</bean>
<bean id="address1" class="com.hqyj.pojo.Address">
    <property name="addr" value="haerbin"></property>
</bean>

autowire="byName" consiste à obtenir la valeur correspondante en fonction du nom du paramètre des méthodes get et set dans le pojo (vous pouvez écrire manuellement les tests des méthodes getter et setter de la classe User)

Pour injecter le bean correspondant, il faut modifier le nom de méthode de la méthode set, par exemple :

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

3.4 @Valeur

​ @Autowired injecte un autre bean, tandis que l'annotation @Value injecte la valeur. Cette annotation est moins utilisée en raison de problèmes de codage en dur causés par l'injection de valeurs constantes dans le code source java.

4. Exemple de code

  1. UserService
public interface UserService {
    
    
    void selectAll();
}
  1. UserServiceImpl
@Service
public class UserServiceImpl implements UserService {
    
    

    @Autowired
    private UserDao userDao;

    // 注入值
    @Value("张三")
    private String username;

    @Override
    public void selectAll() {
    
    
        System.out.println(username);
        userDao.selectAll();
    }
}
  1. Fichier de configuration de printemps
<context:component-scan base-package="com.hqyj.cl" />
<bean id="man" class="com.hqyj.cl.pojo.Man" />
<bean id="student" class="com.hqyj.cl.pojo.Student">
    <property name="name" value="student1"/>
</bean>
<bean id="student1" class="com.hqyj.cl.pojo.Student">
    <property name="name" value="student1"/>
</bean>
<bean id="counselor" class="com.hqyj.cl.pojo.Counselor">
    <property name="name" value="张老师" />
</bean>
  1. classe homme
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class Man {
    
    

    @Value("张三")
    private String name;

/*    @Autowired
    @Qualifier("student1")*/
    @Resource(type = Student.class)
    private Student student;

    @Autowired
    private Counselor counselor;
}
  1. classe d'essai
public class UserDaoTest {
    
    

    @Test
    public void selectAll() {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        Man man = ac.getBean("man", Man.class);
        System.out.println(man);
    }
}

Je suppose que tu aimes

Origine blog.csdn.net/ailaohuyou211/article/details/130394148
conseillé
Classement
du quotidien
Plus
2024-08-26(0)
2024-08-25(0)
2024-08-24(0)
2024-08-23(0)
2024-08-22(0)
2024-08-21(0)
2024-08-20(0)
2024-08-19(0)
2024-08-18(0)
2024-08-17(0)

Code World

© 2018 codetd.com