Spring Framework 5.0 Einführung Tutorial

1. Warum Frühling lernen?

Mit kontinuierlichem Kontakt und Verständnis von Java EE werden Sie feststellen, dass der Frühling in verschiedenen Unternehmen und Projekten eine immer wichtigere Rolle spielt. Das Mastering Frühling ist zu einer der Muss-Learn-Fähigkeiten in unserer IT-Branche geworden.

1. Spring Framework ist ein Open-Source-Java/Java ee-Full-Stack-Anwendungs-Framework, das unter der Apache-Lizenz veröffentlicht wurde und auch eine portierte Version auf der .NET-Plattform verfügt.
2. Das Framework basiert auf dem Code des Buchentwurfs und der Entwicklung und Entwicklung von Java EE (ISBN 0-7645-4385-7) und wurde ursprünglich unter anderem von Rod Johnson und Juergen Hoeller entwickelt.
3. Spring Framework bietet eine einfache Entwicklungsmethode, mit der eine große Anzahl von Eigenschaftsdateien vermieden und Klassen helfen können, die dazu führen können, dass der zugrunde liegende Code kompliziert und unordentlich wird.

Spring Framework Die aktuelle neueste Version ist Spring Framework 5. Wenn Sie die offizielle Website öffnen, sollten Sie in der Lage sein, die Werbebilder der offiziellen Website zu sehen.

Hier gibt es eine verwandte Nachrichten, an denen Sie interessiert sind. Klicken Sie hier, um die ursprüngliche englische Version anzuzeigen. Klicken Sie hier, um die chinesische Version anzuzeigen.

Laut den offiziellen Website -Nachrichten und den Informationen, die ich kenne, wird die offizielle Website von Spring weiterhin Spring MVC unterstützen, da sie viele Verbesserungen enthält.

Aber ich denke, der zukünftige Trend wird Spring Boot+ Springweb Flux+ Spring Cloud sein.

Was ist der Unterschied zwischen Spring MVC und Frühlings -Webfluss?

Die offizielle Website gibt dieses Vergleichsbild:

Unten übersetzt:

1. Spring MVC basiert auf der Servlet-API und verwendet ein Web-Framework, das die Synchron-Blockierungs-E/A-Architektur und ein einsthreades Anforderungs-Threadmodell synchronisiert
2. Spring WebFlux ist ein nicht blockierendes Web-Framework, das aus dieser Gruppe erstellt wurde und Multi-Kern-, Prozessoren der nächsten Generation und eine große Anzahl von gleichzeitigen Verbindungen nutzt.

Zusammenfassen:

1. Spring MVC ist ein Web -Framework für synchrones Blockierungs -E/A, das auf der Servlet -API basiert.
2. Spring WebFlux ist ein ausgezeichnetes nicht blockierendes Web-Framework und kann eine große Anzahl von gleichzeitigen Verbindungen besser verarbeiten.

Nachdem ich das gesehen habe, glaube ich, dass Sie zu diesem Zeitpunkt klug sind, sollten Sie wissen, warum ich das schon einmal gesagt habe.

2. Einführung in die offizielle Spring -Website

Frühling offizielle Website: https://spring.io/ Spring

Dokumentation: https://spring.io/guides

Spring IDE: https://spring.io/tools/sts

Springprojekt: https://spring.io/projects

Project Quick Generator: https://start.spring.io/

Ich glaube, viele Menschen kennen die oben genannten Links, aber tatsächlich wissen wir oft nicht, welchen Link zu verwenden ist.

Frühling offizielle Website: Befolgen

Frühlingsdokumentation: Was möchten Sie tun? Welche Art von Projekt möchten Sie entwickeln? Verwandte Einführungen und Dokumentationen finden Sie hier schnell.

Spring IDE: Wenn Sie die Eclipse -Version verwenden möchten, empfehle ich die Verwendung der offiziellen Website STS, da sie die freundlichste und unterstützendste Version von Spring sein sollte. Wenn die Bedingungen in Ordnung sind, empfehle ich Ihnen natürlich immer noch dringend, Intellij -Idee zu verwenden.

Spring Project: Dies wird nach Projektmodulen unterteilt, z. B. von der Konfiguration über Sicherheit, Webanwendungen bis hin zu Big Data, und Sie können lernen, welche Sie gemäß der Klassifizierung lernen möchten.

Projektgenerator: Dies ist ein sehr bequemes Tool, das von der offiziellen Website von Spring bereitgestellt wird. Welche Abhängigkeiten sind erforderlich und welche Version ist erforderlich? Sie können es hier konfigurieren und dann herunterladen.

3. Spring -Framework

Spring Framework Core unterstützt Abhängigkeitsinjektion, Transaktionsmanagement, Webanwendungen, Datenzugriff, Messaging, Tests und mehr

Tipps: Hier ist die Übersetzung https://projekts.spring.io/spring-framework/

3.1 Einführung

Das Spring Framework bietet ein umfassendes Programmier- und Konfigurationsmodell für moderne Java -basierte Unternehmensanwendungen - auf jeder Art von Bereitstellungsplattform.

Ein Schlüsselelement von Spring ist Infrastrukturunterstützung auf Anwendungsebene: Spring konzentriert sich auf die „Pipeline“ von Unternehmensanwendungen, damit sich die Teams auf die Geschäftslogik auf Anwendungsebene konzentrieren können, ohne unnötige Verbindungen mit bestimmten Bereitstellungsumgebungen herzustellen.

3.2 Funktionsfunktionen

1. Kerntechnologien: Abhängigkeitsinjektion, Ereignisse, Ressourcen, i18n, Überprüfung, Datenbindung, Typumwandlung, Spel, AOP.
2. Test: Mock -Objekte, TestContext -Framework, Spring MVC -Test, WebTestClient.
3. Datenzugriff: Transaktionen, DAO -Support, JDBC, Orm, Marshalling XML.
4. Spring MVC und Spring WebFlux Web Frameworks
5. Integration: Remoteverarbeitung, JMS, JCA, JMX, E -Mail, Aufgaben, Planung, Cache.
6. Sprache: Kotlin, grooviger, dynamischer Sprache.

Tipps: Hier ist ein Screenshot aus dem offiziellen Website -Dokument. Ich glaube, es wird Ihnen helfen, besser zu verstehen.

3.3 Mindestanforderungen

1. JDK 8+ für Spring Framework 5.x
2. JDK 6+ für Spring Framework 4.x
3. JDK 5+ für Spring Framework 3.x

Tipps: Ihr Computer empfiehlt jetzt die Verwendung von JDK1.8+

3.4 Schneller Start

Die empfohlene Möglichkeit, mit Spring -Framework in Ihrem Projekt zu beginnen, besteht darin, ein Abhängigkeitsmanagementsystem zu verwenden. Das folgende Code -Snippet kann kopiert und in Ihren Build eingefügt werden.

Benötigen Sie Hilfe? Sehen Sie sich unseren Anleitungen zum Bauen mit Maven und Gradle an.

Tatsächlich ist es nicht nur die offizielle Spring -Website. Die meisten unserer großen Unternehmen sollten heute außerdem empfehlen, Maven und Gradle zu verwenden, um Projekt -JAR -Paketabhängigkeiten zu verwalten.

Wenn Sie Maven verwenden:

 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId> spring-context</artifactId> <version>5.1.0.BUILD-SNAPSHOT</version> </dependency></dependencies><repositories> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <URL> https://repo.spring.io/libs-snapshot </url> <snapshots> <enable> true </enabled> </snapshots> </repository> </repository>

Wenn Sie Gradle verwenden

 Abhängigkeiten {Compile 'org.springframework: Spring-Context: 5.1.0.build-Snapshot'} Repositories {maven {url 'https://repo.spring.io/libs-snapshot'}}}}}

Tipps: Eigentlich denke ich, dass Gradle ein fortgeschritteneres Tool zur Abhängigkeit von Versionen als Maven sein sollte. Es scheint jedoch, dass große Unternehmen Gradle nicht oft verwenden. Vielleicht liegt es daran, dass die Unterstützung von Eclipse für Gradle nicht so perfekt ist wie die Intellij -Idee.

Das Feder -Framework enthält viele verschiedene Module. Hier zeigen wir den Frühlingskontext, der Kernfunktionen bietet. Weitere Optionen finden Sie in der rechten Seite Erste Schritte.

Sobald Sie Ihren Build mit der Abhängigkeit von der Spring-Kontext eingerichtet haben, können Sie Folgendes ausführen:

Nachdem Sie hier angekommen sind, ist die offizielle Website nicht detailliert. Fügen Sie sie also hinzu.

Methode 1: Verwenden Sie das STS-Tool, um dieses Projekt mit einem Feder-Kontext-Kontext zu erstellen

Vorbereitung:

1. JDK 1.8
2. STS IDE

Tipps: Beim Herunterladen gibt es eine Fallstrick. Wenn Ihr JDK 64-Bit ist und die STS, die standardmäßig direkt heruntergeladen werden, 32-Bit ist, tritt dieser Fehler auf.

Daher müssen Sie beim Herunterladen die JDK -Matching -Version herunterladen. Bewegung: https://spring.io/tools/sts/all

Nachdem der hier abgeschlossene Download abgeschlossen ist, werden wir mit der rechten Maustaste auf den leeren Bereich unserer IDE -> neu -> Andere ...

Geben Sie die Maven -Suche ein, wählen Sie das Maven -Projekt aus und erstellen Sie ein Maven -Projekt

Wählen Sie den Standardarbeitsbereich aus

Wählen Sie den Standardtyp aus

Geben Sie die grundlegenden Projektinformationen ein und klicken Sie auf Fertig stellen, um sie zu vervollständigen

Dann sollten wir in der Lage sein, die Projektstruktur wie diese zu sehen

Zuerst modifizieren Sie pom.xml

 <project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.xingyun</groupId> <artifactId>spring-context-sample</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <Name> Spring-Context-Sample </name> <URL> http://maven.apache.org </url> <properties> <projekt.build.sourceencoding> utf-8 </project.build.SourceCoding> </properties> <deponcies> </gruppy> </gruppy> </gruppy> <artifactId> junit </artifactId> <version> 3.8.1 </Version> <Schops> test </scope> </abhängig> <depeopecy> <gruppe> org.springFramework </Groupid> <ArtifactId> Spring-Context </artifactID> <version> 5.1.0.Build-Snapshot </artifactID> 5.1.0.build-Snapshots </artifactID> 5.1.0.build-Snapshots </artifactID> 5.1.0.build-snapshot </artifactId> </ca. <repositories> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/libs-snapshot</url> <snapshots> <enabled>true</enabled> </snapshots> </repository> </repository> </repository> </repository> </repository> </project>

Eine Datei erstellen

Hallo/messageservice.java

 paket com.xingyun.spring_context_sample.hello; public interface messageVice {String getMessage ();};

Hallo/MessagePrinter.java

 paket com.xingyun.spring_context_sample.hello; import org.springframework.bean.factory.annotation.autowired; @Autowired public messagePrinter (MessageService -Dienst) {this.service = service; } public void printMessage () {System.out.println (this.service.getMessage ()); }}

Tipps: Achten Sie auf diese Annotation und vergessen Sie nicht

App.java

 Paket com.xingyun.spring_context_sample; import org.springframework.context.applicationContext; import org.springframework.context.annotation.annotation.annotationConfigapplicationContext; org.springFramework.context.annotation.comPonentscan; org.springFramework.context.annotation.Configuration; com.xingyun.spring_context_Sample.hello.messagePrinter; {@Bean MessageService MockMessageService () {return New MessageService () {public String getMessage () {return "Hallo Welt!"; }}; } public static void main (String [] args) {applicationContext context = new AnnotationConFigApplicationContext (app.class); MessagePrinter drucker = context.getBean (messagePrinter.class); printMessage (); }}

Tipps: Beachten Sie, dass die Klasse zwei Anmerkungen und eine Annotation auf der Methode enthält. Vergessen Sie nicht. Sie können den Namen der Klasse in die Bewerbung auf der offiziellen Website ändern oder den Standard -App -Namen beibehalten.

Die Projektstruktur sollte nach erfolgreicher Schöpfung so sein

Natürlich fühlen Sie sich möglicherweise unwohl, wenn Sie sich die Struktur dieses Projekts ansehen, damit Sie es auch ändern können.

Die Projektstruktur wird Folgendes:

App.main () Hauptmethode ausführen

Project Source Code Download: https://github.com/geekxingyun/javaee-framework-probe/tree/master/spring-context-sample

Anhang: Core -JAR -Paketabhängigkeiten

Tipps: Wenn Sie keine Java-Webanwendung schreiben, benötigen Sie das Spring-Web-Modul nicht.

Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.