Introduction à l'utilisation simplifiée du framework Spring

Cet article vous apporte une introduction à l'utilisation simplifiée du framework Spring. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

En tant que framework Spring, sa fonction principale est de gérer un ensemble de classes qui font fonctionner l'application (application). Ces classes, qui sont la pierre angulaire et l'épine dorsale de l'ensemble de l'application, sont appelées beans.

Pour gérer des beans, c'est-à-dire un ensemble de classes qui exécutent des fonctions métier, vous ne pouvez pas les créer directement, ce qui manque d'une planification unifiée. Par conséquent, Spring utilise les fichiers de configuration .xml comme support et IoC (Inversion of Control) comme outil pour transférer ces beans vers le conteneur Spring pour une gestion unifiée.

Sur cette base, pour jeter un bean dans le conteneur, au moins deux parties sont nécessaires :

La définition de la classe correspondant au bean

.xml contrôlé indirectement fichier de configuration

La raison pour laquelle deux parties sont nécessaires est facile à comprendre. Tout d'abord, vous devez avoir une définition du bean lui-même. Ensuite, vous devez indiquer au conteneur Spring comment accepter le bean. Ceci est expliqué par le fichier .xml.

Par exemple, le bean que nous voulons gérer s'appelle HelloWorld, alors ses deux parties sont : applicationContext-src.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-3.0.xsd">
    
    <bean id="helloWorld" class="com.terence.HelloWorld">        
        <property name="message" value="Hello Terence&#39;s World!" />
    </bean>  

</beans>

et HelloWorld.java :

public class HelloWorld {
    private String message;     
    
    public void setMessage(String message) {       
        this.message  = message;    
    }     
    
    public void getMessage() {       
        System.out.println("Your Message : " + message);    
    } 
}

Avec ces deux parties, le conteneur Spring peut recevoir correctement le bean nommé HelloWorld.

Maintenant, si vous souhaitez utiliser ce bean, bien sûr, vous ne pouvez pas toucher directement le bean HelloWorld. Au lieu de cela, vous devez faire passer le bean via le conteneur Spring qui gère son agent, puis utiliser ce bean pour le servir. toi-même.

Par exemple, la classe nommée MainApp.java doit maintenant utiliser le service du bean HelloWorld. Nous pouvons faire ceci :

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {    
    
    @SuppressWarnings("resource")
    public static void main(String[] args) {       
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-src.xml");        
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");        
        obj.getMessage();    
    }
}

Il y a deux parties ici :

<.>Tout d'abord, récupérez le conteneur Spring en fonction de l'emplacement du fichier de configuration .xml, qui est le contexte ici. Il peut être compris comme le porte-parole le plus célèbre parmi plusieurs conteneurs Spring.

Après avoir ce porte-parole, vous pouvez naturellement demander au porte-parole les beans requis HelloWorld, afin que vous puissiez obtenir les beans requis via la méthode context.getBean().

Après avoir obtenu le grain, vous pouvez l'utiliser directement.

On voit que le point de départ du framework Spring est intuitif. Il s'agit d'agir comme un proxy pour un ensemble de classes fonctionnelles (beans), et d'unifier ces beans dans leurs propres conteneurs pour la gestion. Toute autre classe qui a besoin d'utiliser le bean doit l'obtenir via son agent.

Une question qui mérite d'être discutée est que ce qui précède est assez intuitif et facile à comprendre, mais pourquoi n'y a-t-il pas beaucoup de déclarations sur ApplicationContext dans le développement Web Java en général ?

La raison est que dans le développement J2EE habituel, la déclaration du Spring Context ne se fait pas directement dans le code utilisateur, mais est configurée dans web.xml :

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml</param-value>
</context-param>

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Ici, l'ApplicationContext est enregistré dans notre application Web à l'aide de ContextLoaderListener.

Une autre considération plus importante est :

Il ne devrait pas y avoir d'utilisation directe d'ApplicationContext dans votre code, mais la même utilisation des fichiers de configuration et d'IoC pour utiliser Context.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!