Aufgrund der umständlichen Abhängigkeitskonfiguration ist die Konfiguration von Spring für Unternehmensanwendungen zu einer sehr mühsamen und fehleranfälligen Aufgabe geworden. Dies gilt insbesondere für Anwendungen, die auch mehrere Bibliotheken von Drittanbietern verwenden.
Jedes Mal, wenn Sie eine andere Spring-basierte Enterprise-Java-Anwendung erstellen, müssen Sie dieselben Routineschritte wiederholen, um sie zu konfigurieren:
- Importieren Sie je nach Art der zu erstellenden Anwendung (Spring MVC, Spring JDBC, Spring ORM usw.) die erforderlichen Spring-Module
- Importieren einer Webcontainerbibliothek (für Webanwendungen)
- Importieren Sie die erforderlichen Bibliotheken von Drittanbietern (z. B. Hibernate, Jackson), während Sie nach Versionen suchen sollten, die mit der angegebenen Version von Spring kompatibel sind
- Konfigurieren Sie DAO-Komponenten wie Datenquellen, Transaktionsverwaltung usw.
- Konfigurieren Sie Web-Layer-Komponenten, z. B.: Ressourcenmanager, Ansichtsauflöser
- Definieren Sie eine Klasse, die alle erforderlichen Konfigurationen lädt.
1. Einführung in Spring Boot
Die Autoren von Spring haben beschlossen, Entwicklern einige Dienstprogramme zur Verfügung zu stellen, die den Konfigurationsprozess automatisieren und den Prozess der Erstellung und Bereitstellung von Spring-Anwendungen beschleunigen, die gemeinsam als Spring Boot bezeichnet werden
Spring Boot ist ein nützliches Projekt, dessen Ziel es ist, die Erstellung von Anwendungen auf Basis von Spring zu vereinfachen. Sie können damit auf einfachste Weise eine Webanwendung erstellen, wobei Entwickler nur minimalen Aufwand für die Konfiguration und das Schreiben von Code benötigen.
2. Merkmale von Spring Boot
Spring Boot bietet eine hervorragende Funktionalität, die wichtigsten Funktionen sind jedoch: Abhängigkeitsverwaltung, automatische Konfiguration und integrierte Servlet-Container
2.1. Einfaches Abhängigkeitsmanagement
Um den Abhängigkeitsverwaltungsprozess zu beschleunigen, packt Spring Boot implizit die erforderlichen Abhängigkeiten von Drittanbietern für jeden Typ einer Spring-basierten Anwendung und stellt sie dem Entwickler über die sogenannten Starter- Pakete (Spring-Boot-Starter-Web, Spring-Boot-Starter-Daten-JPA usw.) zur Verfügung. .d.)
Starterpakete sind eine Reihe praktischer Abhängigkeitsbeschreibungen, die Sie in Ihre Anwendung aufnehmen können. Dies bietet eine universelle Lösung für alle Spring-bezogenen Technologien, die es dem Programmierer erspart, unnötig nach Codebeispielen zu suchen und die erforderlichen Abhängigkeitsdeskriptoren daraus zu laden (ein Beispiel für solche Deskriptoren und Starterpakete wird unten gezeigt).
Wenn Sie beispielsweise Spring Data JPA für den Zugriff auf die Datenbank verwenden möchten, fügen Sie einfach die Spring-Boot-Starter-Data-JPA- Abhängigkeit in Ihr Projekt ein, und schon sind Sie fertig (Sie müssen nicht nach kompatiblen Datenbanktreibern und Hibernate-Bibliotheken suchen).
Wenn Sie eine Spring-Webanwendung erstellen möchten, fügen Sie einfach die Spring-Boot-Starter-Web- Abhängigkeit hinzu, die alle für die Entwicklung von Spring-MVC-Anwendungen erforderlichen Bibliotheken wie Spring-Webmvc , Jackson-JSON , Validation-API und Tomcat in das Projekt einbezieht
Mit anderen Worten, Spring Boot sammelt alle gängigen Abhängigkeiten und definiert sie an einem Ort, sodass Entwickler sie einfach verwenden können, anstatt das Rad jedes Mal neu zu erfinden, wenn sie eine neue Anwendung erstellen
Daher enthält die Datei pom.xml bei Verwendung von Spring Boot viel weniger Zeilen als bei Verwendung in Spring-Anwendungen
In der Dokumentation finden Sie alle Spring Boot-Starterpakete.
2.2. Automatische Konfiguration
Die zweite hervorragende Spring Boot- Funktion ist die automatische Anwendungskonfiguration
Nach Auswahl des entsprechenden Starterpakets versucht Spring Boot , die Spring-Anwendung basierend auf den von Ihnen hinzugefügten JAR- Abhängigkeiten automatisch zu konfigurieren
Wenn Sie beispielsweise Spring-Boot-Starter-Web hinzufügen, konfiguriert Spring Boot automatisch registrierte Beans wie DispatcherServlet , ResourceHandlers , MessageSource
Wenn Sie Spring-Boot-Starter-JDBC verwenden , registriert Spring Boot automatisch die DataSource- , EntityManagerFactory- und TransactionManager-Beans und liest die Informationen für die Verbindung zur Datenbank aus der Datei application.properties
Wenn Sie die Datenbank nicht verwenden und im manuellen Modus keine detaillierten Informationen zur Verbindung bereitstellen, konfiguriert Spring Boot die Datenbank automatisch im Speicher, ohne dass Sie zusätzliche Konfigurationen vornehmen müssen (wenn Sie über H2- oder HSQL-Bibliotheken verfügen).
Die automatische Konfiguration kann jederzeit mit den Benutzereinstellungen vollständig neu definiert werden
2.3. Native Unterstützung für Anwendungsserver - Servlet-Container
Jede Spring Boot-Webanwendung enthält einen eingebetteten Webserver. Sehen Sie sich die Liste der Servlet-Container an, die standardmäßig unterstützt werden.
Entwickler müssen sich nicht mehr um die Konfiguration des Servlet-Containers und die Bereitstellung der Anwendung darauf kümmern. Jetzt kann die Anwendung von selbst als ausführbare JAR-Datei mit dem integrierten Server gestartet werden
Wenn Sie einen separaten HTTP-Server verwenden müssen, schließen Sie einfach die Standardabhängigkeiten dafür aus. Spring Boot bietet separate Starterpakete für verschiedene HTTP-Server
Das Erstellen eigenständiger Webanwendungen mit eingebetteten Servern ist nicht nur praktisch für die Entwicklung, sondern auch eine akzeptable Lösung für Anwendungen auf Unternehmensebene und wird in der Welt der Mikrodienste immer nützlicher. Die Möglichkeit, einen gesamten Dienst (z. B. die Benutzerauthentifizierung) schnell in ein eigenständiges und vollständig bereitstellbares Artefakt zu packen, das auch eine API bereitstellt, erleichtert die Installation und Bereitstellung von Anwendungen erheblich
3. Spring Boot-Installationsanforderungen
Zum Konfigurieren und Ausführen von Spring Boot-Anwendungen ist Folgendes erforderlich:
4. Erstellen einer Spring Boot-Anwendung
Lassen Sie uns nun eine sehr einfache REST-API zum Akzeptieren von Zahlungen mit den Funktionen von Spring Boot üben und implementieren
4.1. Erstellen eines Webprojekts mit Maven
Erstellen Sie ein Maven-Projekt in der von Ihnen verwendeten IDE und nennen Sie es SpringBootRestService
Stellen Sie sicher, dass Sie die Java 8+ -Version verwenden, da Spring Boot mit früheren Versionen nicht funktioniert
4.2. Pom.xml Konfiguration
Der zweite Schritt besteht darin, Spring Boot in der Datei pom.xml zu konfigurieren
Alle Spring Boot-Anwendungen werden über Spring-Boot-Starter-Parent konfiguriert. Fügen Sie Starter-Parent wie folgt hinzu, bevor Sie die Abhängigkeiten weiter definieren:
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> </parent>
Weil Da wir eine REST-API erstellen, muss Spring-Boot-Starter-Web als Abhängigkeit verwendet werden, die implizit alle anderen Abhängigkeiten definiert, z. B. Spring-Core , Spring-Web , Spring-Webmvc , Servlet-API und die Jackson-Databind- Bibliothek Fügen Sie einfach Folgendes zu pom.xml hinzu:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
Jetzt werden die folgenden JAR-Bibliotheken automatisch in Ihr Projekt importiert:
Der nächste Schritt ist das Hinzufügen des Spring Boot Plugins:
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
Der letzte Schritt besteht darin, Maven dazu zu bringen, während der Montage eine ausführbare JAR-Datei zu generieren:
<packaging>jar</packaging>
Unten finden Sie die vollständige Datei pom.xml:
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>springboot.topjava.ru</groupId> <artifactId>SpringBootRestService</artifactId> <version>1.0</version> <packaging>jar</packaging> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
Wie Sie sehen, können wir mit einer Abhängigkeit eine voll funktionsfähige Webanwendung erstellen
4.3. REST-Ressourcen erstellen
Jetzt erstellen wir einen Zahlungscontroller zusammen mit POJO-Klassen für Anfragen und Antworten
Schreiben wir die Klasse der Zahlungsanforderung:
package springboot.topjava.ru; public class PaymentRequest { private int userId; private String itemId; private double discount; public String getItemId() { return itemId; } public void setItemId(String itemId) { this.itemId = itemId; } public double getDiscount() { return discount; } public void setDiscount(double discount) { this.discount = discount; } public int getUserId() { return userId; } public void setUserId(int userId) { this.userId = userId; } }
Und auch eine Klasse, die die von unserem Service zurückgegebene grundlegende Antwort verarbeitet:
package springboot.topjava.ru; public class BaseResponse { private final String status; private final Integer code; public BaseResponse(String status, Integer code) { this.status = status; this.code = code; } public String getStatus() { return status; } public Integer getCode() { return code; } }
Erstellen Sie nun einen Controller:
package springboot.topjava.ru; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/payment") public class PaymentController { private final String sharedKey = "SHARED_KEY"; private static final String SUCCESS_STATUS = "success"; private static final String ERROR_STATUS = "error"; private static final int CODE_SUCCESS = 100; private static final int AUTH_FAILURE = 102; @GetMapping public BaseResponse showStatus() { return new BaseResponse(SUCCESS_STATUS, 1); } @PostMapping("/pay") public BaseResponse pay(@RequestParam(value = "key") String key, @RequestBody PaymentRequest request) { final BaseResponse response; if (sharedKey.equalsIgnoreCase(key)) { int userId = request.getUserId(); String itemId = request.getItemId(); double discount = request.getDiscount();
4.4. Erstellen der Hauptanwendungsklasse
Dieser letzte Schritt besteht darin, eine Konfigurationsklasse zu erstellen und die Anwendung zu starten. Spring Boot unterstützt die neue Annotation @SpringBootApplication , die der Verwendung von @Configuration , @EnableAutoConfiguration und @ComponentScan mit ihren Standardattributen entspricht
Sie müssen also nur eine mit @SpringBootApplication kommentierte Klasse erstellen , und Spring Boot aktiviert die automatische Konfiguration und scannt Ihre Ressourcen im aktuellen Paket:
package springboot.topjava.ru; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }
5. Bereitstellen der Spring Boot-Anwendung
Nutzen wir jetzt die dritte großartige Funktion von Spring Boot - einen eingebetteten Server. Wir müssen lediglich eine ausführbare JAR-Datei mit Maven erstellen und wie eine normale eigenständige Anwendung ausführen:
- Rufen Sie den Befehlszeilenmodus (Befehl cmd) auf, wechseln Sie in den Ordner mit pom.xml und geben Sie den Befehl mvn clean package ein
- Maven generiert eine ausführbare JAR-Datei mit dem Namen SpringBootRestService-1.0.jar
- Wechseln Sie zum CD- Zielordner
- Führen Sie dann die JAR-Datei aus: java -jar SpringBootRestService-1.0.jar
- Gehen Sie zum Browser unter http: // localhost: 8080 / payment
Unsere REST-API wird ausgeführt und ist bereit, Anforderungen über Port 8080 zu bedienen (standardmäßig).
In diesem Artikel haben wir uns die Funktionen von Spring Boot angesehen und ein voll funktionsfähiges Beispiel mit dem eingebetteten Server erstellt.
Quelle:
https://dzone.com/articles/introducing-spring-boot
- Spring-Boot-Starter-Parent hat die Version von 1.5.8.RELEASE auf 2.1.1.RELEASE geändert und dementsprechend wurde die Liste der Bibliotheken, die Maven aufruft, aktualisiert
- Spring-Repository-Deklarationen entfernt, Abhängigkeiten werden aus dem zentralen Repository abgerufen
- In der BaseResponse-Klasse wurden Felder endgültig festgelegt, ein Konstruktor hinzugefügt und Setter entfernt
- Im PaymentController haben wir die Methode showStatus () mit @GetMapping eingeführt, um die Anwendung im Browser zu testen
- @RequestMapping in Methoden wurde durch @ GetMapping / @ PostMapping ersetzt
- Es wurden auch Änderungen vorgenommen, um die Anwendung über die Befehlszeile bereitzustellen
UPDATE:
Wie Lure_of_Chaos feststellte, kann jetzt alles automatisch über SPRING INITIALIZR erledigt werden. Und ohne Ihre Lieblings-JetBrains IntelliJ IDEA zu verlassen .