Einführung in die vereinfachte Verwendung des Spring-Frameworks

Dieser Artikel bietet Ihnen eine Einführung in die vereinfachte Verwendung des Spring-Frameworks. Freunde in Not können darauf zurückgreifen.

Als Spring-Framework besteht seine Hauptfunktion darin, eine Reihe von Klassen zu verwalten, die die App (Anwendung) zum Funktionieren bringen. Diese Klassen, die den Grundstein und das Rückgrat der gesamten App bilden, werden Beans genannt.

Um Beans zu verwalten, also eine Reihe von Klassen, die Geschäftsfunktionen ausführen, können Sie sie nicht direkt neu erstellen, was an einer einheitlichen Planung mangelt. Daher verwendet Spring XML-Konfigurationsdateien als Medium und IoC (Inversion of Control) als Tool, um diese Beans zur einheitlichen Verwaltung in den Spring-Container zu übertragen.

Auf dieser Grundlage sind mindestens zwei Teile erforderlich, um eine Bohne in den Container zu werfen:

Die Definition der Klasse, die der Bohne entspricht

Indirekt gesteuerte .xml Konfigurationsdatei

Der Grund, warum zwei Teile benötigt werden, ist leicht zu verstehen. Erstens müssen Sie eine Definition der Bean selbst haben. Als nächstes müssen Sie dem Spring-Container mitteilen, wie er die Bean akzeptieren soll. Dies wird durch die .xml-Datei erklärt.

Zum Beispiel heißt die Bean, die wir verwalten möchten, HelloWorld, dann sind ihre zwei Teile: 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>

und 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);    
    } 
}

Mit diesen beiden Teilen kann der Spring-Container die Bean namens HelloWorld korrekt empfangen.

Wenn Sie diese Bean verwenden möchten, können Sie die HelloWorld-Bean natürlich nicht direkt berühren. Stattdessen müssen Sie die Bean über den Spring-Container abrufen, der ihren Agenten verwaltet, und diese Bean dann zum Servieren verwenden selbst.

Zum Beispiel muss die Klasse mit dem Namen MainApp.java jetzt den Dienst der HelloWorld-Bean verwenden. Wir können dies tun:

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();    
    }
}

Hier gibt es zwei Teile:

Rufen Sie zunächst den Spring-Container entsprechend dem Speicherort der Konfigurations-XML-Datei ab, der hier als Kontext angesehen werden kann. Er kann als der bekannteste Sprecher unter mehreren Spring-Containern verstanden werden.

Nachdem Sie diesen Sprecher haben, können Sie den Sprecher natürlich nach den erforderlichen Beans HelloWorld fragen, sodass Sie die erforderlichen Beans über die Methode context.getBean() erhalten können.

Nachdem Sie die Bohne erhalten haben, können Sie sie direkt verwenden.

Es ist ersichtlich, dass der Ausgangspunkt des Spring-Frameworks intuitiv ist. Es soll als Proxy für eine Reihe von Funktionsklassen (Beans) fungieren und diese Beans zur Verwaltung in ihren eigenen Containern vereinen. Jede andere Klasse, die die Bean verwenden muss, muss sie über ihren Agenten erhalten.

Eine diskussionswürdige Frage ist, dass das Obige recht intuitiv und leicht zu verstehen ist, aber warum gibt es in der allgemeinen Java-Webentwicklung nicht viele Erklärungen zu ApplicationContext?

Der Grund dafür ist, dass in der normalen J2EE-Entwicklung die Deklaration von Spring Context nicht direkt im Benutzercode erfolgt, sondern in web.xml konfiguriert wird:

<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>

Hier mit Hilfe von ContextLoaderListener registriert ApplicationContext in unserer Web-App.

Eine weitere wichtigere Überlegung ist:

Es sollte keine direkte Verwendung von ApplicationContext in Ihrem Code geben, sondern die gleiche Verwendung von Konfigurationsdateien und IoC zur Verwendung von Context.

Das obige ist der detaillierte Inhalt vonEinführung in die vereinfachte Verwendung des Spring-Frameworks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!