Spring Boot - Kurzanleitung

Spring Boot ist ein Open Source Java-basiertes Framework, mit dem ein Mikrodienst erstellt wird. Es wurde vom Pivotal Team entwickelt und wird verwendet, um eigenständige und serienreife Federanwendungen zu erstellen. Dieses Kapitel gibt Ihnen eine Einführung in Spring Boot und macht Sie mit den grundlegenden Konzepten vertraut.

Was ist Micro Service?

Micro Service ist eine Architektur, mit der Entwickler Services unabhängig voneinander entwickeln und bereitstellen können. Jeder ausgeführte Dienst verfügt über einen eigenen Prozess. Dadurch wird das einfache Modell zur Unterstützung von Geschäftsanwendungen erreicht.

Vorteile

Micro Services bietet seinen Entwicklern folgende Vorteile:

• Einfache Bereitstellung
• Einfache Skalierbarkeit
• Kompatibel mit Containern
• Minimale Konfiguration
• Geringere Produktionszeit

Was ist Spring Boot?

Spring Boot bietet Java-Entwicklern eine gute Plattform, um eine eigenständige und produktionsfähige Spring-Anwendung zu entwickeln, die Sie können just run. Sie können mit minimalen Konfigurationen beginnen, ohne dass ein komplettes Spring-Konfigurationssetup erforderlich ist.

Vorteile

Spring Boot bietet seinen Entwicklern die folgenden Vorteile:

• Einfach zu verstehen und Federanwendungen zu entwickeln
• Steigert die Produktivität
• Reduziert die Entwicklungszeit

Tore

Spring Boot wurde mit folgenden Zielen entwickelt:

• So vermeiden Sie komplexe XML-Konfigurationen im Frühjahr
• Einfachere Entwicklung einer produktionsfertigen Federanwendung
• So reduzieren Sie die Entwicklungszeit und führen die Anwendung unabhängig aus
• Bieten Sie einen einfacheren Einstieg in die Anwendung

Warum Spring Boot?

Sie können Spring Boot aufgrund der hier angegebenen Funktionen und Vorteile wählen -

• Es bietet eine flexible Möglichkeit, Java Beans, XML-Konfigurationen und Datenbanktransaktionen zu konfigurieren.

• Es bietet eine leistungsstarke Stapelverarbeitung und verwaltet REST-Endpunkte.

• In Spring Boot wird alles automatisch konfiguriert. Es sind keine manuellen Konfigurationen erforderlich.

• Es bietet eine annotationsbasierte Federanwendung

• Erleichtert das Abhängigkeitsmanagement

• Es enthält eingebetteten Servlet-Container

Wie funktioniert es?

Spring Boot konfiguriert Ihre Anwendung automatisch basierend auf den Abhängigkeiten, die Sie mithilfe von zum Projekt hinzugefügt haben @EnableAutoConfigurationAnmerkung. Wenn sich beispielsweise die MySQL-Datenbank in Ihrem Klassenpfad befindet, Sie jedoch keine Datenbankverbindung konfiguriert haben, konfiguriert Spring Boot eine speicherinterne Datenbank automatisch.

Der Einstiegspunkt der Spring Boot-Anwendung ist die Klasse, die sie enthält @SpringBootApplication Anmerkung und die Hauptmethode.

Spring Boot scannt automatisch alle im Projekt enthaltenen Komponenten mithilfe von @ComponentScan Anmerkung.

Spring Boot Starter

Die Handhabung des Abhängigkeitsmanagements ist eine schwierige Aufgabe für große Projekte. Spring Boot behebt dieses Problem, indem Entwickler eine Reihe von Abhängigkeiten bereitstellen.

Wenn Sie beispielsweise Spring und JPA für den Datenbankzugriff verwenden möchten, ist dies ausreichend, wenn Sie einschließen spring-boot-starter-data-jpa Abhängigkeit in Ihrem Projekt.

Beachten Sie, dass alle Spring Boot-Starter dem gleichen Namensmuster folgen spring-boot-starter- *, wobei * angibt, dass es sich um einen Anwendungstyp handelt.

Beispiele

Schauen Sie sich zum besseren Verständnis die folgenden Spring Boot-Starter an, die unten erläutert werden:

Spring Boot Starter Actuator dependencywird verwendet, um Ihre Anwendung zu überwachen und zu verwalten. Sein Code ist unten gezeigt -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Spring Boot Starter Security dependencywird für Spring Security verwendet. Sein Code ist unten gezeigt -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Spring Boot Starter web dependencywird verwendet, um Rest-Endpunkte zu schreiben. Sein Code ist unten gezeigt -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Spring Boot Starter Thyme Leaf dependencywird zum Erstellen einer Webanwendung verwendet. Sein Code ist unten gezeigt -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Spring Boot Starter Test dependencywird zum Schreiben von Testfällen verwendet. Sein Code ist unten gezeigt -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
</dependency>

Automatische Konfiguration

Die automatische Spring Boot-Konfiguration konfiguriert Ihre Spring-Anwendung automatisch basierend auf den JAR-Abhängigkeiten, die Sie im Projekt hinzugefügt haben. Wenn sich beispielsweise die MySQL-Datenbank in Ihrem Klassenpfad befindet, Sie jedoch keine Datenbankverbindung konfiguriert haben, konfiguriert Spring Boot automatisch eine speicherinterne Datenbank.

Zu diesem Zweck müssen Sie hinzufügen @EnableAutoConfiguration Anmerkung oder @SpringBootApplicationAnmerkung zu Ihrer Hauptklassendatei. Anschließend wird Ihre Spring Boot-Anwendung automatisch konfiguriert.

Beachten Sie zum besseren Verständnis den folgenden Code:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

@EnableAutoConfiguration
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Spring Boot-Anwendung

Der Einstiegspunkt der Spring Boot-Anwendung ist die Klasse, die sie enthält @SpringBootApplicationAnmerkung. Diese Klasse sollte die Hauptmethode zum Ausführen der Spring Boot-Anwendung haben.@SpringBootApplication Die Annotation umfasst die automatische Konfiguration, den Komponentenscan und die Spring Boot-Konfiguration.

Wenn Sie hinzugefügt haben @SpringBootApplication Anmerkung zur Klasse, Sie müssen die nicht hinzufügen @EnableAutoConfiguration, @ComponentScan und @SpringBootConfigurationAnmerkung. Das@SpringBootApplication Annotation enthält alle anderen Annotationen.

Beachten Sie zum besseren Verständnis den folgenden Code:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Komponentenscan

Die Spring Boot-Anwendung überprüft alle Beans und Paketdeklarationen, wenn die Anwendung initialisiert wird. Sie müssen das hinzufügen@ComponentScan Anmerkung für Ihre Klassendatei zum Scannen Ihrer in Ihrem Projekt hinzugefügten Komponenten.

Beachten Sie zum besseren Verständnis den folgenden Code:

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

In diesem Kapitel erfahren Sie, wie Sie mit Maven und Gradle eine Spring Boot-Anwendung erstellen.

Voraussetzungen

Ihr System muss die folgenden Mindestanforderungen erfüllen, um eine Spring Boot-Anwendung zu erstellen:

• Java 7
• Maven 3.2
• Gradle 2.5

Spring Boot CLI

Die Spring Boot CLI ist ein Befehlszeilentool, mit dem wir die Groovy-Skripte ausführen können. Dies ist der einfachste Weg, eine Spring Boot-Anwendung mithilfe der Spring Boot-Befehlszeilenschnittstelle zu erstellen. Sie können die Anwendung in der Eingabeaufforderung selbst erstellen, ausführen und testen.

In diesem Abschnitt werden die Schritte zur manuellen Installation der Spring Boot CLI erläutert. Für weitere Hilfe können Sie den folgenden Link verwenden:https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot

Sie können die Spring CLI-Distribution auch aus dem Spring Software-Repository herunterladen unter: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation

Für die manuelle Installation müssen Sie die folgenden zwei Ordner verwenden:

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz

Entpacken Sie nach dem Download die Archivdatei und befolgen Sie die Schritte in der Datei install.txt. Nicht, dass keine Umgebungseinrichtung erforderlich wäre.

Wechseln Sie unter Windows zur Spring Boot-CLI bin Verzeichnis in der Eingabeaufforderung und führen Sie den Befehl aus spring –-versionum sicherzustellen, dass die Feder-CLI korrekt installiert ist. Nach dem Ausführen des Befehls sehen Sie die Spring-CLI-Version wie unten gezeigt -

Führen Sie Hello World mit Groovy aus

Erstellen Sie eine einfache Groovy-Datei, die das Rest Endpoint-Skript enthält, und führen Sie die Groovy-Datei mit der Spring Boot-CLI aus. Beachten Sie dazu den hier gezeigten Code -

@Controller
class Example {
   @RequestMapping("/")
   @ResponseBody
   public String hello() {
      "Hello Spring Boot"
   }
}

Speichern Sie nun die groovige Datei mit dem Namen hello.groovy. Beachten Sie, dass wir in diesem Beispiel die groovige Datei in der Spring Boot-CLI gespeichert habenbinVerzeichnis. Führen Sie nun die Anwendung mit dem Befehl ausspring run hello.groovy wie im folgenden Screenshot gezeigt -

Sobald Sie die groovige Datei ausgeführt haben, werden die erforderlichen Abhängigkeiten automatisch heruntergeladen und die Anwendung im Tomcat 8080-Port gestartet, wie im folgenden Screenshot gezeigt.

Gehen Sie nach dem Start von Tomcat zum Webbrowser und klicken Sie auf die URL http://localhost:8080/ und Sie können die Ausgabe wie gezeigt sehen.

In diesem Kapitel wird erläutert, wie Sie ein Bootstrapping für eine Spring Boot-Anwendung durchführen.

Federinitialisierer

Eine Möglichkeit zum Bootstrapping einer Spring Boot-Anwendung ist die Verwendung von Spring Initializer. Dazu müssen Sie die Spring Initializer-Webseite www.start.spring.io besuchen und Ihre Build- , Spring Boot-Version und Plattform auswählen. Außerdem müssen Sie eine Gruppe, ein Artefakt und die erforderlichen Abhängigkeiten angeben, um die Anwendung auszuführen.

Beachten Sie den folgenden Screenshot, der ein Beispiel zeigt, in dem wir das hinzugefügt haben spring-boot-starter-web Abhängigkeit zum Schreiben von REST-Endpunkten.

Nachdem Sie die Gruppe, das Artefakt, die Abhängigkeiten, das Build-Projekt, die Plattform und die Version angegeben haben, klicken Sie auf Generate ProjectTaste. Die Zip-Datei wird heruntergeladen und die Dateien werden extrahiert.

In diesem Abschnitt werden die Beispiele anhand von Maven und Gradle erläutert.

Maven

Entpacken Sie die Datei, nachdem Sie das Projekt heruntergeladen haben. Nun, deinpom.xml Datei sieht aus wie unten gezeigt -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle

Sobald Sie das Projekt heruntergeladen haben, entpacken Sie die Datei. Nun deinbuild.gradle Datei sieht aus wie unten gezeigt -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Klassenpfadabhängigkeiten

Spring Boot bietet eine Reihe von Startersum die Gläser in unseren Klassenpfad aufzunehmen. Zum Schreiben eines Rest-Endpunkts müssen wir beispielsweise den hinzufügenspring-boot-starter-webAbhängigkeit in unserem Klassenpfad. Beachten Sie die unten gezeigten Codes zum besseren Verständnis -

Maven-Abhängigkeit

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Gradle-Abhängigkeit

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Hauptmethode

Die Hauptmethode sollte das Schreiben der Spring Boot Application-Klasse sein. Diese Klasse sollte mit Anmerkungen versehen sein@SpringBootApplication. Dies ist der Einstiegspunkt der zu startenden Spring Boot-Anwendung. Die Hauptklassendatei finden Sie untersrc/java/main Verzeichnisse mit dem Standardpaket.

In diesem Beispiel befindet sich die Hauptklassendatei unter src/java/main Verzeichnisse mit dem Standardpaket com.tutorialspoint.demo. Beachten Sie den hier gezeigten Code zum besseren Verständnis -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Schreiben Sie einen Ruheendpunkt

Führen Sie die folgenden Schritte aus, um einen einfachen Hello World Rest-Endpunkt in die Hauptklassendatei der Spring Boot-Anwendung selbst zu schreiben.

• Fügen Sie zunächst die hinzu @RestController Anmerkung oben in der Klasse.

• Schreiben Sie nun eine Anforderungs-URI-Methode mit @RequestMapping Anmerkung.

• Dann sollte die Request URI-Methode die zurückgeben Hello World Zeichenfolge.

Jetzt sieht Ihre Hauptklassendatei der Spring Boot-Anwendung wie im folgenden Code gezeigt aus -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

Erstellen Sie eine ausführbare JAR

Lassen Sie uns eine ausführbare JAR-Datei erstellen, um die Spring Boot-Anwendung auszuführen, indem Sie die Befehle Maven und Gradle in der Eingabeaufforderung verwenden (siehe unten).

Verwenden Sie den Maven-Befehl mvn clean install wie unten gezeigt -

Nach dem Ausführen des Befehls sehen Sie die BUILD SUCCESS Meldung an der Eingabeaufforderung wie unten gezeigt -

Verwenden Sie den Befehl Gradle gradle clean build wie unten gezeigt -

Nach dem Ausführen des Befehls sehen Sie die BUILD SUCCESSFUL Meldung in der Eingabeaufforderung wie unten gezeigt -

Führen Sie Hello World mit Java aus

Nachdem Sie eine ausführbare JAR-Datei erstellt haben, finden Sie diese in den folgenden Verzeichnissen.

Für Maven finden Sie die JAR-Datei im Zielverzeichnis wie unten gezeigt -

Für Gradle finden Sie die JAR-Datei unter build/libs Verzeichnis wie unten gezeigt -

Führen Sie nun die JAR-Datei mit dem Befehl aus java –jar <JARFILE>. Beachten Sie, dass im obigen Beispiel die JAR-Datei benannt istdemo-0.0.1-SNAPSHOT.jar

Sobald Sie die JAR-Datei ausgeführt haben, können Sie die Ausgabe im Konsolenfenster wie unten gezeigt sehen.

Schauen Sie sich die Konsole an, Tomcat wurde auf Port 8080 (http) gestartet. Gehen Sie jetzt zum Webbrowser und klicken Sie auf die URLhttp://localhost:8080/ und Sie können die Ausgabe wie unten gezeigt sehen -

Mithilfe der Spring Boot-Anwendung können wir eine War-Datei erstellen, die auf dem Webserver bereitgestellt werden soll. In diesem Kapitel erfahren Sie, wie Sie eine WAR-Datei erstellen und die Spring Boot-Anwendung auf dem Tomcat-Webserver bereitstellen.

Spring Boot Servlet Initializer

Die traditionelle Art der Bereitstellung besteht darin, die Spring Boot-Anwendung zu erstellen @SpringBootApplication Klasse erweitern die SpringBootServletInitializerKlasse. Mit der Spring Boot Servlet Initializer-Klassendatei können Sie die Anwendung beim Start mithilfe des Servlet-Containers konfigurieren.

Der Code für die Spring Boot Application-Klassendatei für die Bereitstellung von JAR-Dateien ist unten angegeben:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Wir müssen die Klasse erweitern SpringBootServletInitializerzur Unterstützung der Bereitstellung von WAR-Dateien. Der Code der Spring Boot Application-Klassendatei ist unten angegeben -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Hauptklasse einstellen

In Spring Boot müssen wir die Hauptklasse erwähnen, die in der Build-Datei beginnen soll. Zu diesem Zweck können Sie die folgenden Codeteile verwenden:

Fügen Sie für Maven die Startklasse hinzu pom.xml Eigenschaften wie unten gezeigt -

<start-class>com.tutorialspoint.demo.DemoApplication</start-class>

Fügen Sie für Gradle den Hauptklassennamen in build.gradle wie unten gezeigt hinzu -

mainClassName="com.tutorialspoint.demo.DemoApplication"

Aktualisieren Sie die Verpackungs-JAR in WAR

Wir müssen die Verpackungs-JAR mit den folgenden Codeteilen in WAR aktualisieren:

Fügen Sie für Maven die Verpackung als WAR in hinzu pom.xml wie unten gezeigt -

<packaging>war</packaging>

Fügen Sie für Gradle das Anwendungs-Plugin und das War-Plugin hinzu build.gradle wie unten gezeigt -

apply plugin: ‘war’
apply plugin: ‘application’

Schreiben wir nun einen einfachen Rest-Endpunkt, um die Zeichenfolge "Hello World from Tomcat" zurückzugeben. Um einen Rest-Endpunkt zu schreiben, müssen wir die Spring Boot-Webstarter-Abhängigkeit in unsere Build-Datei einfügen.

Fügen Sie für Maven die Spring Boot-Starterabhängigkeit in pom.xml hinzu, indem Sie den folgenden Code verwenden:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Fügen Sie für Gradle die Spring Boot-Starterabhängigkeit in hinzu build.gradle Verwenden Sie den Code wie unten gezeigt -

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Schreiben Sie nun einen einfachen Rest Endpoint in die Spring Boot Application-Klassendatei mit dem folgenden Code:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

Packen Sie Ihre Anwendung

Erstellen Sie jetzt eine WAR-Datei für die Bereitstellung auf dem Tomcat-Server, indem Sie die Befehle Maven und Gradle zum Packen Ihrer Anwendung verwenden (siehe unten).

Verwenden Sie für Maven den Befehl mvn packagezum Verpacken Ihrer Anwendung. Dann wird die WAR-Datei erstellt und Sie finden sie im Zielverzeichnis, wie in den folgenden Screenshots gezeigt -

Verwenden Sie für Gradle den Befehl gradle clean buildzum Verpacken Ihrer Anwendung. Dann wird Ihre WAR-Datei erstellt und Sie finden sie unterbuild/libsVerzeichnis. Beachten Sie die hier gezeigten Screenshots zum besseren Verständnis -

In Tomcat bereitstellen

Führen Sie nun den Tomcat-Server aus und stellen Sie die WAR-Datei unter dem bereit webappsVerzeichnis. Beachten Sie die hier gezeigten Screenshots zum besseren Verständnis -

Klicken Sie nach erfolgreicher Bereitstellung auf die URL in Ihrem Webbrowser http://localhost:8080/demo-0.0.1-SNAPSHOT/ und beachten Sie, dass die Ausgabe wie im folgenden Screenshot dargestellt aussieht -

Der vollständige Code für diesen Zweck ist unten angegeben.

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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <start-class>com.tutorialspoint.demo.DemoApplication</start-class>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'
apply plugin: 'application'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
mainClassName = "com.tutorialspoint.demo.DemoApplication"

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Der Code für die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

In Spring Boot ist die Auswahl eines Build-Systems eine wichtige Aufgabe. Wir empfehlen Maven oder Gradle, da sie das Abhängigkeitsmanagement gut unterstützen. Spring unterstützt andere Build-Systeme nicht gut.

Abhängigkeitsmanagement

Das Spring Boot-Team bietet eine Liste von Abhängigkeiten, um die Spring Boot-Version für jede Version zu unterstützen. Sie müssen keine Version für Abhängigkeiten in der Build-Konfigurationsdatei angeben. Spring Boot konfiguriert die Abhängigkeitsversion automatisch basierend auf der Version. Denken Sie daran, dass beim Upgrade der Spring Boot-Version auch Abhängigkeiten automatisch aktualisiert werden.

Note- Wenn Sie die Version für die Abhängigkeit angeben möchten, können Sie sie in Ihrer Konfigurationsdatei angeben. Das Spring Boot-Team empfiehlt jedoch dringend, die Version für die Abhängigkeit nicht anzugeben.

Maven-Abhängigkeit

Für die Maven-Konfiguration sollten wir das übergeordnete Spring Boot Starter-Projekt erben, um die Spring Boot Starters-Abhängigkeiten zu verwalten. Dafür können wir einfach das Starter-Elternteil in unserem erbenpom.xml Datei wie unten gezeigt.

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>1.5.8.RELEASE</version>
</parent>

Wir sollten die Versionsnummer für die Abhängigkeit von Spring Boot Parent Starter angeben. Für andere Starterabhängigkeiten müssen wir dann nicht die Spring Boot-Versionsnummer angeben. Beachten Sie den unten angegebenen Code -

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Gradle-Abhängigkeit

Wir können die Spring Boot Starters-Abhängigkeiten direkt in importieren build.gradleDatei. Wir brauchen keinen Spring Boot-Start. Übergeordnete Abhängigkeit wie Maven für Gradle. Beachten Sie den unten angegebenen Code -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

Ebenso müssen wir in Gradle nicht die Spring Boot-Versionsnummer für Abhängigkeiten angeben. Spring Boot konfiguriert die Abhängigkeit automatisch basierend auf der Version.

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Spring Boot verfügt über kein Code-Layout, mit dem gearbeitet werden kann. Es gibt jedoch einige Best Practices, die uns helfen werden. In diesem Kapitel wird ausführlich darauf eingegangen.

Standardpaket

Eine Klasse ohne Paketdeklaration wird als default package. Beachten Sie, dass eine Standardpaketdeklaration im Allgemeinen nicht empfohlen wird. Spring Boot verursacht Probleme wie Fehlfunktionen der automatischen Konfiguration oder des Komponentenscans, wenn Sie das Standardpaket verwenden.

Note- Die von Java empfohlene Namenskonvention für die Paketdeklaration ist der umgekehrte Domänenname. Zum Beispiel -com.tutorialspoint.myproject

Typisches Layout

Das typische Layout der Spring Boot-Anwendung ist in der folgenden Abbildung dargestellt:

Die Datei Application.java sollte die Hauptmethode zusammen mit @SpringBootApplication deklarieren. Beachten Sie zum besseren Verständnis den unten angegebenen Code -

package com.tutorialspoint.myproject;

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

In Spring Boot können wir Spring Framework verwenden, um unsere Beans und ihre Abhängigkeitsinjektion zu definieren. Das@ComponentScan Annotation wird verwendet, um Bohnen und die entsprechenden injizierten zu finden @Autowired Anmerkung.

Wenn Sie dem typischen Spring Boot-Layout gefolgt sind, müssen Sie keine Argumente für angeben @ComponentScanAnmerkung. Alle Komponentenklassendateien werden automatisch bei Spring Beans registriert.

Das folgende Beispiel enthält eine Vorstellung davon, wie das Rest Template-Objekt automatisch verkabelt und eine Bean für dasselbe Objekt erstellt wird.

@Bean
public RestTemplate getRestTemplate() {
   return new RestTemplate();
}

Der folgende Code zeigt den Code für das automatisch verkabelte Rest Template-Objekt und das Bean-Erstellungsobjekt in der Hauptklassendatei der Spring Boot-Anwendung.

package com.tutorialspoint.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
@Autowired
   RestTemplate restTemplate;
   
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();   
   }
}

Mit den Schnittstellen Application Runner und Command Line Runner können Sie den Code ausführen, nachdem die Spring Boot-Anwendung gestartet wurde. Sie können diese Schnittstellen verwenden, um Aktionen unmittelbar nach dem Start der Anwendung auszuführen. In diesem Kapitel wird ausführlich darauf eingegangen.

Application Runner

Application Runner ist eine Schnittstelle, über die der Code nach dem Start der Spring Boot-Anwendung ausgeführt wird. Das folgende Beispiel zeigt, wie die Application Runner-Schnittstelle in der Hauptklassendatei implementiert wird.

package com.tutorialspoint.demo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements ApplicationRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      System.out.println("Hello World from Application Runner");
   }
}

Nun, wenn Sie das Konsolenfenster unten beobachten Hello World from Application Runnerwird die println-Anweisung ausgeführt, nachdem der Tomcat gestartet wurde. Ist der folgende Screenshot relevant?

Befehlszeilen-Runner

Command Line Runner ist eine Schnittstelle. Es wird verwendet, um den Code nach dem Start der Spring Boot-Anwendung auszuführen. Das folgende Beispiel zeigt, wie die Command Line Runner-Schnittstelle in der Hauptklassendatei implementiert wird.

package com.tutorialspoint.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(String... arg0) throws Exception {
      System.out.println("Hello world from Command Line Runner");
   }
}

Schauen Sie sich das Konsolenfenster unten an. Die println-Anweisung "Hallo Welt vom Befehlszeilen-Runner" wird ausgeführt, nachdem der Tomcat gestartet wurde.

Die Anwendungseigenschaften unterstützen uns bei der Arbeit in verschiedenen Umgebungen. In diesem Kapitel erfahren Sie, wie Sie die Eigenschaften einer Spring Boot-Anwendung konfigurieren und angeben.

Befehlszeileneigenschaften

Die Spring Boot-Anwendung konvertiert die Befehlszeileneigenschaften in die Eigenschaften der Spring Boot-Umgebung. Befehlszeileneigenschaften haben Vorrang vor den anderen Eigenschaftsquellen. Standardmäßig verwendet Spring Boot die 8080-Portnummer, um den Tomcat zu starten. Lassen Sie uns lernen, wie Sie die Portnummer mithilfe der Befehlszeileneigenschaften ändern.

Step 1 - Nachdem Sie eine ausführbare JAR-Datei erstellt haben, führen Sie sie mit dem Befehl aus java –jar <JARFILE>.

Step 2 - Verwenden Sie den im folgenden Screenshot angegebenen Befehl, um die Portnummer für die Spring Boot-Anwendung mithilfe der Befehlszeileneigenschaften zu ändern.

Note Mit dem Trennzeichen können Sie mehr als eine Anwendungseigenschaft bereitstellen.

Eigenschaftendatei

Eigenschaftendateien werden verwendet, um 'N' Anzahl von Eigenschaften in einer einzelnen Datei zu behalten, um die Anwendung in einer anderen Umgebung auszuführen. In Spring Boot werden die Eigenschaften in der gespeichertapplication.properties Datei unter dem Klassenpfad.

Die Datei application.properties befindet sich in der src/main/resourcesVerzeichnis. Der Code für das Beispielapplication.properties Datei ist unten angegeben -

server.port = 9090
spring.application.name = demoservice

Beachten Sie, dass in dem oben gezeigten Code der Demoservice der Spring Boot-Anwendung auf dem Port 9090 gestartet wird.

YAML-Datei

Spring Boot unterstützt YAML-basierte Eigenschaftenkonfigurationen zum Ausführen der Anwendung. Anstatt vonapplication.properties, wir können benutzen application.ymlDatei. Diese YAML-Datei sollte auch im Klassenpfad aufbewahrt werden. Die Probeapplication.yml Datei ist unten angegeben -

spring:
   application:
      name: demoservice
   server:
port: 9090

Externalisierte Eigenschaften

Anstatt die Eigenschaftendatei unter Klassenpfad zu belassen, können wir die Eigenschaften an einem anderen Speicherort oder Pfad aufbewahren. Während der Ausführung der JAR-Datei können wir den Pfad der Eigenschaftendatei angeben. Mit dem folgenden Befehl können Sie den Speicherort der Eigenschaftendatei angeben, während Sie die JAR ausführen.

-Dspring.config.location = C:\application.properties

Verwendung von @Value Annotation

Die Annotation @Value wird zum Lesen des Umgebungs- oder Anwendungseigenschaftswerts in Java-Code verwendet. Die Syntax zum Lesen des Eigenschaftswerts ist unten dargestellt:

@Value("${property_key_name}")

Schauen Sie sich das folgende Beispiel an, das die Syntax zum Lesen der zeigt spring.application.name Eigenschaftswert in der Java-Variablen mithilfe der Annotation @Value.

@Value("${spring.application.name}")

Beachten Sie zum besseren Verständnis den unten angegebenen Code -

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   @Value("${spring.application.name}")
   private String name;
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String name() {
      return name;
   }
}

Note - Wenn die Eigenschaft beim Ausführen der Anwendung nicht gefunden wird, löst Spring Boot die Ausnahme für unzulässige Argumente aus Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}".

Um das Platzhalterproblem zu beheben, können Sie den Standardwert für die Eigenschaft mithilfe der unten angegebenen Syntax festlegen.

@Value("${property_key_name:default_value}")

@Value("${spring.application.name:demoservice}")

Aktives Spring Boot-Profil

Spring Boot unterstützt verschiedene Eigenschaften basierend auf dem aktiven Spring-Profil. Beispielsweise können wir zwei separate Dateien für Entwicklung und Produktion aufbewahren, um die Spring Boot-Anwendung auszuführen.

Aktives Federprofil in application.properties

Lassen Sie uns verstehen, wie Spring ein aktives Profil in application.properties hat. Standardmäßig Anwendung. Eigenschaften werden verwendet, um die Spring Boot-Anwendung auszuführen. Wenn Sie profilbasierte Eigenschaften verwenden möchten, können wir für jedes Profil eine separate Eigenschaftendatei erstellen, wie unten gezeigt.

application.properties

server.port = 8080
spring.application.name = demoservice

application-dev.properties

server.port = 9090
spring.application.name = demoservice

application-prod.properties

server.port = 4431
spring.application.name = demoservice

Während der Ausführung der JAR-Datei müssen wir das aktive Spring-Profil basierend auf jeder Eigenschaftendatei angeben. Standardmäßig verwendet die Spring Boot-Anwendung die Datei application.properties. Der Befehl zum Einstellen des aktiven Federprofils ist unten dargestellt:

Sie können den Namen des aktiven Profils im Konsolenprotokoll sehen, wie unten gezeigt -

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: dev

Jetzt hat Tomcat auf dem Port 9090 (http) wie unten gezeigt gestartet -

2017-11-26 08:13:20.185  INFO 14028 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

Sie können das aktive Produktionsprofil wie unten gezeigt einstellen -

Sie können den Namen des aktiven Profils im Konsolenprotokoll sehen, wie unten gezeigt -

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: prod

Jetzt startete Tomcat auf dem Port 4431 (http) wie unten gezeigt -

2017-11-26 08:13:20.185  INFO 14028 --- [          
   main] s.b.c.e.t.TomcatEmbeddedServletContainer :
   Tomcat started on port(s): 4431 (http)

Federaktives Profil für application.yml

Lassen Sie uns verstehen, wie Sie das aktive Spring-Profil für application.yml beibehalten. Wir können die aktiven Profileigenschaften von Spring in der Single behaltenapplication.ymlDatei. Sie müssen keine separate Datei wie application.properties verwenden.

Das Folgende ist ein Beispielcode, um die aktiven Spring-Profile in der Datei application.yml zu behalten. Beachten Sie, dass das Trennzeichen (---) verwendet wird, um jedes Profil in der Datei application.yml zu trennen.

spring:
   application:
      name: demoservice
server:
   port: 8080

---
spring:
   profiles: dev
   application:
      name: demoservice
server:
   port: 9090

---
spring: 
   profiles: prod
   application:
      name: demoservice
server: 
   port: 4431

Der Befehl zum Festlegen des aktiven Entwicklungsprofils ist unten angegeben:

Sie können den Namen des aktiven Profils im Konsolenprotokoll sehen, wie unten gezeigt -

2017-11-26 08:41:37.202  INFO 14104 --- [           
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: dev

Jetzt startete Tomcat auf dem Port 9090 (http) wie unten gezeigt -

2017-11-26 08:41:46.650  INFO 14104 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

Der Befehl zum Festlegen des aktiven Produktionsprofils ist unten angegeben:

Sie können den Namen des aktiven Profils im Konsolenprotokoll sehen, wie unten gezeigt -

2017-11-26 08:43:10.743  INFO 13400 --- [    
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: prod

Dadurch wird Tomcat auf dem Port 4431 (http) wie unten gezeigt gestartet:

2017-11-26 08:43:14.473  INFO 13400 --- [     
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 4431 (http)

Spring Boot verwendet die Apache Commons-Protokollierung für die gesamte interne Protokollierung. Die Standardkonfigurationen von Spring Boot bieten Unterstützung für die Verwendung von Java Util Logging, Log4j2 und Logback. Mit diesen können wir die Konsolenprotokollierung sowie die Dateiprotokollierung konfigurieren.

Wenn Sie Spring Boot Starters verwenden, bietet Logback eine gute Unterstützung für die Protokollierung. Außerdem bietet Logback eine gute Unterstützung für Common Logging, Util Logging, Log4J und SLF4J.

Protokollformat

Das Standardformat für das Spring Boot-Protokoll ist in der folgenden Abbildung dargestellt.

das gibt Ihnen die folgenden Informationen -

• Date und Time das gibt das Datum und die Uhrzeit des Protokolls an

• Log level zeigt INFO, ERROR oder WARN

• Process ID

• Das --- was ein Trennzeichen ist

• Thread name ist in eckigen Klammern eingeschlossen []

• Logger Name das zeigt den Namen der Quellklasse

• Die Protokollnachricht

Konsolenprotokollausgabe

Die Standardprotokollnachrichten werden im Konsolenfenster gedruckt. Standardmäßig werden die Protokollmeldungen „INFO“, „ERROR“ und „WARN“ in der Protokolldatei gedruckt.

Wenn Sie das Protokoll auf Debug-Ebene aktivieren müssen, fügen Sie beim Starten Ihrer Anwendung das Debug-Flag mit dem folgenden Befehl hinzu:

java –jar demo.jar --debug

Sie können den Debug-Modus auch wie hier gezeigt zu Ihrer Datei application.properties hinzufügen.

debug = true

Dateiprotokollausgabe

Standardmäßig werden alle Protokolle im Konsolenfenster und nicht in den Dateien gedruckt. Wenn Sie die Protokolle in einer Datei drucken möchten, müssen Sie die Eigenschaft festlegenlogging.file oder logging.path in der Datei application.properties.

Sie können den Protokolldateipfad mithilfe der unten gezeigten Eigenschaft angeben. Beachten Sie, dass der Name der Protokolldatei spring.log lautet.

logging.path = /var/tmp/

Sie können den Namen der eigenen Protokolldatei mit der unten gezeigten Eigenschaft angeben -

logging.file = /var/tmp/mylog.log

Note - Dateien werden nach Erreichen der Größe von 10 MB automatisch gedreht.

Protokollebenen

Spring Boot unterstützt alle Logger-Ebenen wie "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF". Sie können den Root-Logger in der Datei application.properties wie folgt definieren:

logging.level.root = WARN

Note- Logback unterstützt kein FATAL-Level-Log. Es wird dem Protokoll der Ebene „ERROR“ zugeordnet.

Logback konfigurieren

Logback unterstützt die XML-basierte Konfiguration für Spring Boot Log-Konfigurationen. Details zur Protokollierungskonfiguration werden in konfiguriertlogback.xmlDatei. Die Datei logback.xml sollte unter dem Klassenpfad platziert werden.

Sie können das ROOT-Level-Protokoll in der Datei Logback.xml mit dem unten angegebenen Code konfigurieren.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <root level = "INFO">
   </root>
</configuration>

Sie können den Konsolen-Appender in der unten angegebenen Datei Logback.xml konfigurieren.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender"></appender>
   <root level = "INFO">
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

Sie können den Dateianhang in der Datei Logback.xml mit dem unten angegebenen Code konfigurieren. Beachten Sie, dass Sie den Protokolldateipfad im Dateianhang angeben müssen.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
   </appender>   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
   </root>
</configuration>

Sie können das Protokollmuster in definieren logback.xmlDatei mit dem unten angegebenen Code. Sie können die unterstützten Protokollmuster auch in der Konsole oder im Dateiprotokoll-Appender mithilfe des folgenden Codes definieren:

<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>

Der Code für die vollständige Datei logback.xml ist unten angegeben. Sie müssen dies in den Klassenpfad einfügen.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender">
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

Der folgende Code zeigt, wie der slf4j-Logger in die Spring Boot-Hauptklassendatei eingefügt wird.

package com.tutorialspoint.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
   
   public static void main(String[] args) {
      logger.info("this is a info message");
      logger.warn("this is a warn message");
      logger.error("this is a error message");
      SpringApplication.run(DemoApplication.class, args);
   }
}

Die Ausgabe, die Sie im Konsolenfenster sehen können, wird hier angezeigt -

Die Ausgabe, die Sie in der Protokolldatei sehen können, wird hier angezeigt -

Spring Boot bietet eine sehr gute Unterstützung beim Erstellen von RESTful Web Services für Unternehmensanwendungen. In diesem Kapitel wird das Erstellen von RESTful-Webdiensten mithilfe von Spring Boot ausführlich erläutert.

Note - Zum Erstellen eines RESTful Web Services müssen wir die Spring Boot Starter-Webabhängigkeit zur Build-Konfigurationsdatei hinzufügen.

Wenn Sie ein Maven-Benutzer sind, verwenden Sie den folgenden Code, um die folgende Abhängigkeit in Ihre hinzuzufügen pom.xml Datei -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>    
</dependency>

Wenn Sie ein Gradle-Benutzer sind, verwenden Sie den folgenden Code, um die folgende Abhängigkeit in Ihre hinzuzufügen build.gradle Datei.

compile('org.springframework.boot:spring-boot-starter-web')

Der Code für die vollständige Build-Konfigurationsdatei Maven build – pom.xml ist unten angegeben -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für die vollständige Build-Konfigurationsdatei Gradle Build – build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Bevor Sie mit dem Erstellen eines RESTful-Webdienstes fortfahren, sollten Sie die folgenden Anmerkungen kennen:

Rest Controller

Die Annotation @RestController wird verwendet, um die RESTful-Webdienste zu definieren. Es dient JSON, XML und benutzerdefinierten Antworten. Die Syntax ist unten dargestellt -

@RestController
public class ProductServiceController { 
}

Mapping anfordern

Die Annotation @RequestMapping wird verwendet, um den Anforderungs-URI für den Zugriff auf die REST-Endpunkte zu definieren. Wir können die Request-Methode definieren, um Objekte zu konsumieren und zu produzieren. Die Standardanforderungsmethode ist GET.

@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }

Text anfordern

Die Annotation @RequestBody wird verwendet, um den Inhaltstyp des Anforderungshauptteils zu definieren.

public ResponseEntity<Object> createProduct(@RequestBody Product product) {
}

Pfadvariable

Die Annotation @PathVariable wird verwendet, um den benutzerdefinierten oder dynamischen Anforderungs-URI zu definieren. Die Pfadvariable im Anforderungs-URI wird wie unten gezeigt als geschweifte Klammern {} definiert.

public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {
}

Parameter anfordern

Die Annotation @RequestParam wird verwendet, um die Anforderungsparameter von der Anforderungs-URL zu lesen. Standardmäßig ist dies ein erforderlicher Parameter. Wir können auch den Standardwert für Anforderungsparameter festlegen, wie hier gezeigt -

public ResponseEntity<Object> getProduct(
   @RequestParam(value = "name", required = false, defaultValue = "honey") String name) {
}

GET API

Die Standard-HTTP-Anforderungsmethode ist GET. Diese Methode erfordert keinen Anforderungshauptteil. Sie können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Der Beispielcode zum Definieren der HTTP-GET-Anforderungsmethode ist unten dargestellt. In diesem Beispiel haben wir HashMap zum Speichern des Produkts verwendet. Beachten Sie, dass wir eine POJO-Klasse als zu speicherndes Produkt verwendet haben.

Hier ist der Anforderungs-URI /productsund es wird die Liste der Produkte aus dem HashMap-Repository zurückgegeben. Die Controller-Klassendatei enthält die GET-Methode REST Endpoint.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

POST-API

Die HTTP-POST-Anforderung wird zum Erstellen einer Ressource verwendet. Diese Methode enthält den Anforderungshauptteil. Wir können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Das folgende Beispiel zeigt den Beispielcode zum Definieren der HTTP-POST-Anforderungsmethode. In diesem Beispiel haben wir HashMap zum Speichern des Produkts verwendet, wobei das Produkt eine POJO-Klasse ist.

Hier ist der Anforderungs-URI /productsNach dem Speichern des Produkts im HashMap-Repository wird der String zurückgegeben.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

PUT API

Die HTTP-PUT-Anforderung wird zum Aktualisieren der vorhandenen Ressource verwendet. Diese Methode enthält einen Anforderungshauptteil. Wir können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Das folgende Beispiel zeigt, wie die HTTP-PUT-Anforderungsmethode definiert wird. In diesem Beispiel haben wir HashMap verwendet, um das vorhandene Produkt zu aktualisieren, wobei das Produkt eine POJO-Klasse ist.

Hier ist der Anforderungs-URI /products/{id}Dadurch wird der String nach dem Produkt in ein HashMap-Repository zurückgegeben. Beachten Sie, dass wir die Pfadvariable verwendet haben{id} Hiermit wird die Produkt-ID definiert, die aktualisiert werden muss.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }   
}

API LÖSCHEN

Die HTTP-Löschanforderung wird verwendet, um die vorhandene Ressource zu löschen. Diese Methode enthält keinen Anforderungshauptteil. Wir können Anforderungsparameter und Pfadvariablen senden, um die benutzerdefinierte oder dynamische URL zu definieren.

Das folgende Beispiel zeigt, wie die Anforderungsmethode HTTP DELETE definiert wird. In diesem Beispiel haben wir HashMap verwendet, um das vorhandene Produkt zu entfernen, bei dem es sich um eine POJO-Klasse handelt.

Die Anforderungs-URI lautet /products/{id}Nach dem Löschen des Produkts aus dem HashMap-Repository wird der String zurückgegeben. Wir haben die Pfadvariable verwendet{id} Hiermit wird die Produkt-ID definiert, die gelöscht werden muss.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
}

In diesem Abschnitt finden Sie den vollständigen Satz des Quellcodes. Beachten Sie die folgenden Codes für ihre jeweiligen Funktionen -

The Spring Boot main application class – DemoApplication.java

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

The POJO class – Product.java

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

The Rest Controller class – ProductServiceController.java

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
   
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring-Boot-Anwendung ausführen, indem Sie die folgenden Maven- oder Gradle-Befehle wie folgt verwenden:

Verwenden Sie für Maven den unten gezeigten Befehl -

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den unten gezeigten Befehl -

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Sie können die JAR-Datei mit dem unten gezeigten Befehl ausführen -

java –jar <JARFILE>

Dadurch wird die Anwendung auf dem Tomcat-Port 8080 wie unten gezeigt gestartet.

Klicken Sie nun auf die unten in der POSTMAN-Anwendung angegebene URL und sehen Sie sich die Ausgabe an.

Die GET API-URL lautet: http://localhost:8080/products

Die POST-API-URL lautet: http://localhost:8080/products

Die PUT-API-URL lautet: http://localhost:8080/products/3

Die API der DELETE-API lautet: http://localhost:8080/products/3

Der Umgang mit Ausnahmen und Fehlern in APIs und das Senden der richtigen Antwort an den Client ist gut für Unternehmensanwendungen. In diesem Kapitel erfahren Sie, wie Sie mit Ausnahmen in Spring Boot umgehen.

Bevor Sie mit der Ausnahmebehandlung fortfahren, sollten Sie sich mit den folgenden Anmerkungen vertraut machen.

Controller-Beratung

Das @ControllerAdvice ist eine Anmerkung, um die Ausnahmen global zu behandeln.

Ausnahmehandler

Der @ExceptionHandler ist eine Anmerkung, mit der die spezifischen Ausnahmen behandelt und die benutzerdefinierten Antworten an den Client gesendet werden.

Mit dem folgenden Code können Sie die Klasse @ControllerAdvice erstellen, um die Ausnahmen global zu behandeln.

package com.tutorialspoint.demo.exception;

import org.springframework.web.bind.annotation.ControllerAdvice;

@ControllerAdvice
   public class ProductExceptionController {
}

Definieren Sie eine Klasse, die die RuntimeException-Klasse erweitert.

package com.tutorialspoint.demo.exception;

public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

Sie können die @ ExcceptionHandler-Methode definieren, um die Ausnahmen wie gezeigt zu behandeln. Diese Methode sollte zum Schreiben der Controller Advice-Klassendatei verwendet werden.

@ExceptionHandler(value = ProductNotfoundException.class)

public ResponseEntity<Object> exception(ProductNotfoundException exception) {
}

Verwenden Sie nun den unten angegebenen Code, um die Ausnahme von der API auszulösen.

@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct() { 
   throw new ProductNotfoundException();
}

Der vollständige Code zur Behandlung der Ausnahme ist unten angegeben. In diesem Beispiel haben wir die PUT-API verwendet, um das Produkt zu aktualisieren. Wenn das Produkt während der Aktualisierung nicht gefunden wird, wird die Antwortfehlermeldung als "Produkt nicht gefunden" zurückgegeben. Notiere dass derProductNotFoundException Ausnahmeklasse sollte die erweitern RuntimeException.

package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

Die Controller Advice-Klasse zur globalen Behandlung der Ausnahme ist unten angegeben. In dieser Klassendatei können beliebige Exception-Handler-Methoden definiert werden.

package com.tutorialspoint.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ProductExceptionController {
   @ExceptionHandler(value = ProductNotfoundException.class)
   public ResponseEntity<Object> exception(ProductNotfoundException exception) {
      return new ResponseEntity<>("Product not found", HttpStatus.NOT_FOUND);
   }
}

Die Product Service API-Controller-Datei wird unten angegeben, um das Produkt zu aktualisieren. Wenn das Produkt nicht gefunden wird, wirft es dasProductNotFoundException Klasse.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      if(!productRepo.containsKey(id))throw new ProductNotfoundException();
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successfully", HttpStatus.OK);
   }
}

Der Code für die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Der Code für POJO class für Produkt ist unten angegeben -

package com.tutorialspoint.demo.model;
public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

Der Code für Maven build – pom.xml wird unten gezeigt -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für Gradle Build – build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den Befehlen Maven oder Gradle ausführen.

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Sie können die JAR-Datei mit dem folgenden Befehl ausführen:

java –jar <JARFILE>

Dadurch wird die Anwendung auf dem Tomcat-Port 8080 wie unten gezeigt gestartet.

Klicken Sie nun auf die unten stehende URL in der POSTMAN-Anwendung und Sie können die Ausgabe wie unten gezeigt sehen -

URL aktualisieren: http: // localhost: 8080 / products / 3

Sie können den Interceptor in Spring Boot verwenden, um Vorgänge in den folgenden Situationen auszuführen:

• Vor dem Senden der Anfrage an die Steuerung

• Vor dem Senden der Antwort an den Client

Sie können beispielsweise einen Interceptor verwenden, um den Anforderungsheader hinzuzufügen, bevor Sie die Anforderung an den Controller senden, und den Antwortheader hinzufügen, bevor Sie die Antwort an den Client senden.

Um mit Interceptor arbeiten zu können, müssen Sie erstellen @Component Klasse, die es unterstützt und es sollte die implementieren HandlerInterceptor Schnittstelle.

Im Folgenden sind die drei Methoden aufgeführt, die Sie bei der Arbeit an Interceptors kennen sollten:

• preHandle()Methode - Hiermit werden Vorgänge ausgeführt, bevor die Anforderung an die Steuerung gesendet wird. Diese Methode sollte true zurückgeben, um die Antwort an den Client zurückzugeben.

• postHandle() Methode - Hiermit werden Vorgänge ausgeführt, bevor die Antwort an den Client gesendet wird.

• afterCompletion() Methode - Dies wird verwendet, um Vorgänge nach Abschluss der Anforderung und Antwort auszuführen.

Beachten Sie zum besseren Verständnis den folgenden Code:

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      return true;
   }
   @Override
   public void postHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler, 
      ModelAndView modelAndView) throws Exception {}
   
   @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
      Object handler, Exception exception) throws Exception {}
}

Sie müssen diesen Interceptor bei registrieren InterceptorRegistry durch die Nutzung WebMvcConfigurerAdapter wie unten gezeigt -

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

In dem unten angegebenen Beispiel werden wir die GET-Produkt-API aufrufen, die die Ausgabe wie unter - liefert.

Der Code für die Interceptor-Klasse ProductServiceInterceptor.java ist unten angegeben -

package com.tutorialspoint.demo.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle
      (HttpServletRequest request, HttpServletResponse response, Object handler) 
      throws Exception {
      
      System.out.println("Pre Handle method is Calling");
      return true;
   }
   @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, 
      Object handler, ModelAndView modelAndView) throws Exception {
      
      System.out.println("Post Handle method is Calling");
   }
   @Override
   public void afterCompletion
      (HttpServletRequest request, HttpServletResponse response, Object 
      handler, Exception exception) throws Exception {
      
      System.out.println("Request and Response is completed");
   }
}

Der Code für die Klassendatei der Anwendungskonfiguration zum Registrieren des Interceptors in der Interceptor-Registrierung - ProductServiceInterceptorAppConfig.java ist unten angegeben.

package com.tutorialspoint.demo.interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

Der Code für die Controller-Klassendatei ProductServiceController.java ist unten angegeben -

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();   
   static {      
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);      
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

Der Code für die POJO-Klasse für Product.java ist unten angegeben -

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

Der Code für die Hauptklasse der Spring Boot-Anwendungsklasse DemoApplication.java ist unten angegeben -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);   
   }
}

Der Code für Maven Build - pom.xml wird hier gezeigt -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für Gradle Build build.gradle wird hier gezeigt -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Sie können die JAR-Datei mit dem folgenden Befehl ausführen:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 wie unten gezeigt gestartet.

Klicken Sie nun in der POSTMAN-Anwendung auf die folgende URL und Sie können die Ausgabe wie unter - sehen.

GET API: http://localhost:8080/products

Im Konsolenfenster sehen Sie die im Interceptor hinzugefügten System.out.println-Anweisungen, wie im folgenden Screenshot gezeigt -

Ein Filter ist ein Objekt, mit dem die HTTP-Anforderungen und -Antworten Ihrer Anwendung abgefangen werden. Mit dem Filter können wir zwei Operationen an zwei Instanzen ausführen -

• Vor dem Senden der Anfrage an die Steuerung
• Vor dem Senden einer Antwort an den Client.

Der folgende Code zeigt den Beispielcode für eine Servlet Filter-Implementierungsklasse mit @ Component-Annotation.

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter
      (ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {}

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

Das folgende Beispiel zeigt den Code zum Lesen des Remote-Hosts und der Remote-Adresse aus dem ServletRequest-Objekt, bevor die Anforderung an die Steuerung gesendet wird.

In der Methode doFilter () haben wir die Anweisungen System.out.println hinzugefügt, um den Remote-Host und die Remote-Adresse zu drucken.

package com.tutorialspoint.demo;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.stereotype.Component;

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {
      
      System.out.println("Remote Host:"+request.getRemoteHost());
      System.out.println("Remote Address:"+request.getRemoteAddr());
      filterchain.doFilter(request, response);
   }

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

In der Spring Boot-Hauptanwendungsklassendatei haben wir den einfachen REST-Endpunkt hinzugefügt, der die Zeichenfolge "Hello World" zurückgibt.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

Der Code für Maven Build - pom.xml ist unten angegeben -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für Gradle Build - build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten gezeigten Befehlen Maven oder Gradle ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach BUILD SUCCESS finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach BUILD SUCCESSFUL finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus

java –jar <JARFILE>

Sie können sehen, dass die Anwendung auf dem Tomcat-Port 8080 gestartet wurde.

Nun drücke die URL http://localhost:8080/und sehen Sie die Ausgabe Hello World. Es sollte wie unten gezeigt aussehen -

Anschließend können Sie den Remote-Host und die Remote-Adresse wie unten gezeigt im Konsolenprotokoll anzeigen.

Mit Spring Boot können Sie dieselbe Anwendung mehrmals an einer anderen Portnummer ausführen. In diesem Kapitel erfahren Sie mehr darüber. Beachten Sie, dass die Standardportnummer 8080.

Benutzerdefinierter Port

In dem application.properties Datei können wir eine benutzerdefinierte Portnummer für die Eigenschaft server.port festlegen

server.port = 9090

In dem application.yml Datei finden Sie wie folgt -

server: 
   port: 9090

Zufälliger Port

In dem application.properties Datei können wir zufällige Portnummer für die Eigenschaft server.port festlegen

server.port = 0

In dem application.yml Datei finden Sie wie folgt -

server: 
   port: 0

Note - Wenn die server.port Die Zahl ist 0, während die Spring Boot-Anwendung gestartet wird. Tomcat verwendet die zufällige Portnummer.

Die Restvorlage wird zum Erstellen von Anwendungen verwendet, die RESTful Web Services verwenden. Du kannst den ... benutzenexchange()Methode zum Konsumieren der Webdienste für alle HTTP-Methoden. Der folgende Code zeigt, wie Sie Bean for Rest Template erstellen, um das Rest Template-Objekt automatisch zu verkabeln.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();
   }
}

BEKOMMEN

Consuming the GET API by using RestTemplate - exchange() method

Nehmen Sie diese URL an http://localhost:8080/products Gibt den folgenden JSON zurück und wir werden diese API-Antwort mithilfe der Restvorlage mit dem folgenden Code verwenden:

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

Sie müssen die angegebenen Punkte befolgen, um die API zu verwenden -

• Das Rest Template-Objekt wurde automatisch verdrahtet.
• Verwenden Sie HttpHeaders, um die Anforderungsheader festzulegen.
• Verwenden Sie HttpEntity, um das Anforderungsobjekt zu verpacken.
• Geben Sie den URL-, HttpMethod- und Return-Typ für die Exchange () -Methode an.

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity <String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange("
         http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
}

POST

Consuming POST API by using RestTemplate - exchange() method

Nehmen Sie diese URL an http://localhost:8080/products Gibt die unten gezeigte Antwort zurück. Wir werden diese API-Antwort mithilfe der Restvorlage verwenden.

Der unten angegebene Code ist der Anfragetext -

{
   "id":"3",
   "name":"Ginger"
}

Der unten angegebene Code ist der Antworttext -

Product is created successfully

Sie müssen die unten angegebenen Punkte befolgen, um die API zu verwenden -

• Das Rest Template-Objekt wurde automatisch verdrahtet.

• Verwenden Sie die HttpHeaders, um die Anforderungsheader festzulegen.

• Verwenden Sie die HttpEntity, um das Anforderungsobjekt zu verpacken. Hier verpacken wir das Product-Objekt, um es an den Anforderungshauptteil zu senden.

• Geben Sie den URL-, HttpMethod- und Return-Typ für die exchange () -Methode an.

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
}

STELLEN

Consuming PUT API by using RestTemplate - exchange() method

Nehmen Sie diese URL an http://localhost:8080/products/3 Gibt die folgende Antwort zurück und wir werden diese API-Antwort mithilfe der Restvorlage verwenden.

Der unten angegebene Code lautet Anforderungshauptteil -

{
   "name":"Indian Ginger"
}

Der unten angegebene Code ist der Antworttext -

Product is updated successfully

Sie müssen die unten angegebenen Punkte befolgen, um die API zu verwenden -

• Das Rest Template-Objekt wurde automatisch verdrahtet.

• Verwenden Sie HttpHeaders, um die Anforderungsheader festzulegen.

• Verwenden Sie HttpEntity, um das Anforderungsobjekt zu verpacken. Hier verpacken wir das Product-Objekt, um es an den Anforderungshauptteil zu senden.

• Geben Sie den URL-, HttpMethod- und Return-Typ für die exchange () -Methode an.

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
}

LÖSCHEN

Consuming DELETE API by using RestTemplate - exchange() method

Nehmen Sie diese URL an http://localhost:8080/products/3 Gibt die unten angegebene Antwort zurück und wir werden diese API-Antwort mithilfe der Restvorlage verwenden.

Diese unten gezeigte Codezeile ist der Antworttext -

Product is deleted successfully

Sie müssen die unten gezeigten Punkte befolgen, um die API zu verwenden -

• Das Rest Template-Objekt wurde automatisch verdrahtet.

• Verwenden Sie HttpHeaders, um die Anforderungsheader festzulegen.

• Verwenden Sie HttpEntity, um das Anforderungsobjekt zu verpacken.

• Geben Sie den URL-, HttpMethod- und Return-Typ für die exchange () -Methode an.

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

Die vollständige Rest Template Controller-Klassendatei finden Sie unten -

package com.tutorialspoint.demo.controller;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

Der Code für die Spring Boot-Anwendungsklasse - DemoApplication.java ist unten angegeben:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Der Code für Maven build - pom.xml ist unten angegeben -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für Gradle Build - build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 gestartet.

Klicken Sie nun in der POSTMAN-Anwendung auf die folgenden URLs, und Sie können die Ausgabe sehen.

GET Produkte von Rest Template - http://localhost:8080/template/products

Produkte erstellen POST - http://localhost:8080/template/products

Produkt-PUT aktualisieren - http://localhost:8080/template/products/3

Produkt löschen - http://localhost:8080/template/products/3

In diesem Kapitel erfahren Sie, wie Sie die Datei mithilfe des Webdienstes hochladen und herunterladen.

Datei-Upload

Zum Hochladen einer Datei können Sie verwenden MultipartFileAls Anforderungsparameter sollte diese API den Wert für mehrteilige Formulardaten verwenden. Beachten Sie den unten angegebenen Code -

@RequestMapping(value = "/upload", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)

public String fileUpload(@RequestParam("file") MultipartFile file) {
   return null;
}

Der vollständige Code dafür ist unten angegeben -

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {
   @RequestMapping(value = "/upload", method = RequestMethod.POST, 
      consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
   
   public String fileUpload(@RequestParam("file") MultipartFile file) throws IOException {
      File convertFile = new File("/var/tmp/"+file.getOriginalFilename());
      convertFile.createNewFile();
      FileOutputStream fout = new FileOutputStream(convertFile);
      fout.write(file.getBytes());
      fout.close();
      return "File is upload successfully";
   }
}

Datei download

Zum Herunterladen von Dateien sollten Sie InputStreamResource zum Herunterladen einer Datei verwenden. Wir müssen den HttpHeader einstellenContent-Disposition in Antwort und müssen den Antwortmedientyp der Anwendung angeben.

Note - Im folgenden Beispiel sollte die Datei unter dem angegebenen Pfad verfügbar sein, unter dem die Anwendung ausgeführt wird.

@RequestMapping(value = "/download", method = RequestMethod.GET) 
public ResponseEntity<Object> downloadFile() throws IOException  {
   String filename = "/var/tmp/mysql.png";
   File file = new File(filename);
   InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
   HttpHeaders headers = new HttpHeaders();
      
   headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
   headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
   headers.add("Pragma", "no-cache");
   headers.add("Expires", "0");
      
   ResponseEntity<Object> 
   responseEntity = ResponseEntity.ok().headers(headers).contentLength(file.length()).contentType(
      MediaType.parseMediaType("application/txt")).body(resource);
      
   return responseEntity;
}

Der vollständige Code dafür ist unten angegeben -

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FileDownloadController {
   @RequestMapping(value = "/download", method = RequestMethod.GET) 
   public ResponseEntity<Object> downloadFile() throws IOException  {
      String filename = "/var/tmp/mysql.png";
      File file = new File(filename);
      InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
      HttpHeaders headers = new HttpHeaders();
      
      headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
      headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
      headers.add("Pragma", "no-cache");
      headers.add("Expires", "0");
      
      ResponseEntity<Object> 
      responseEntity = ResponseEntity.ok().headers(headers).contentLength(
         file.length()).contentType(MediaType.parseMediaType("application/txt")).body(resource);
      
      return responseEntity;
   }
}

Die Hauptanwendung für Spring Boot ist unten angegeben -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Der Code für Maven build - pom.xml ist unten angegeben -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für Gradle Build - build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Jetzt können Sie eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten angegebenen Maven- oder Gradle-Befehlen ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den unten gezeigten Befehl verwenden -

sgradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Dadurch wird die Anwendung auf dem Tomcat-Port 8080 wie unten gezeigt gestartet.

Klicken Sie nun in der POSTMAN-Anwendung auf die folgenden URLs und Sie können die Ausgabe wie unten gezeigt sehen -

Datei hochladen - http://localhost:8080/upload

Datei herunterladen - http://localhost:8080/upload

Servicekomponenten sind die Klassendateien, die die @ Service-Annotation enthalten. Diese Klassendateien werden verwendet, um Geschäftslogik in einer anderen Schicht zu schreiben, die von der @ RestController-Klassendatei getrennt ist. Die Logik zum Erstellen einer Servicekomponenten-Klassendatei wird hier gezeigt -

public interface ProductService {
}

Die Klasse, die die Schnittstelle mit @ Service-Annotation implementiert, ist wie folgt:

@Service
public class ProductServiceImpl implements ProductService {
}

Beachten Sie, dass wir in diesem Tutorial verwenden Product Service API(s)zum Speichern, Abrufen, Aktualisieren und Löschen der Produkte. Wir haben die Geschäftslogik in die @ RestController-Klassendatei selbst geschrieben. Jetzt verschieben wir den Geschäftslogikcode vom Controller zur Servicekomponente.

Sie können eine Schnittstelle erstellen, die Methoden zum Hinzufügen, Bearbeiten, Abrufen und Löschen enthält, indem Sie den folgenden Code verwenden:

package com.tutorialspoint.demo.service;

import java.util.Collection;
import com.tutorialspoint.demo.model.Product;

public interface ProductService {
   public abstract void createProduct(Product product);
   public abstract void updateProduct(String id, Product product);
   public abstract void deleteProduct(String id);
   public abstract Collection<Product> getProducts();
}

Mit dem folgenden Code können Sie eine Klasse erstellen, die die ProductService-Schnittstelle mit @ Service-Annotation implementiert, und die Geschäftslogik schreiben, um das Produkt zu speichern, abzurufen, zu löschen und zu aktualisieren.

package com.tutorialspoint.demo.service;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.tutorialspoint.demo.model.Product;

@Service
public class ProductServiceImpl implements ProductService {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);

      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @Override
   public void createProduct(Product product) {
      productRepo.put(product.getId(), product);
   }
   @Override
   public void updateProduct(String id, Product product) {
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
   }
   @Override
   public void deleteProduct(String id) {
      productRepo.remove(id);

   }
   @Override
   public Collection<Product> getProducts() {
      return productRepo.values();
   }
}

Der Code hier zeigt die Rest Controller-Klassendatei, hier haben wir die ProductService-Schnittstelle @Autowired und die Methoden aufgerufen.

package com.tutorialspoint.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;
import com.tutorialspoint.demo.service.ProductService;

@RestController
public class ProductServiceController {
   @Autowired
   ProductService productService;

   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productService.getProducts(), HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> 
      updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      
      productService.updateProduct(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) {
      productService.deleteProduct(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productService.createProduct(product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

Der Code für die POJO-Klasse - Product.java wird hier angezeigt -

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

Eine Hauptanwendung für Spring Boot finden Sie unten -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Der Code für Maven build - pom.xml wird unten angezeigt -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>

</project>

Der Code für Gradle Build - build.gradle wird unten angezeigt -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten angegebenen Maven- oder Gradle-Befehlen ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 gestartet (siehe Abbildung unten).

Klicken Sie nun in der POSTMAN-Anwendung auf die folgenden URLs und Sie können die Ausgabe wie unten gezeigt sehen -

GET API URL ist - http://localhost:8080/products

Die POST-API-URL lautet - http://localhost:8080/products

PUT API URL ist - http://localhost:8080/products/3

DELETE API URL ist - http://localhost:8080/products/3

Thymeleaf ist eine Java-basierte Bibliothek, mit der eine Webanwendung erstellt wird. Es bietet eine gute Unterstützung für das Bereitstellen von XHTML / HTML5 in Webanwendungen. In diesem Kapitel erfahren Sie mehr über Thymeleaf.

Thymeleaf Vorlagen

Thymeleaf konvertiert Ihre Dateien in wohlgeformte XML-Dateien. Es enthält 6 Arten von Vorlagen wie unten angegeben -

• XML
• Gültiges XML
• XHTML
• Gültiges XHTML
• HTML5
• Legacy HTML5

Alle Vorlagen mit Ausnahme von Legacy HTML5 beziehen sich auf wohlgeformte gültige XML-Dateien. Mit Legacy HTML5 können wir die HTML5-Tags auf Webseiten einschließlich nicht geschlossener Tags rendern.

Internetanwendung

Sie können Thymeleaf-Vorlagen verwenden, um eine Webanwendung in Spring Boot zu erstellen. Sie müssen die folgenden Schritte ausführen, um eine Webanwendung in Spring Boot mithilfe von Thymeleaf zu erstellen.

Verwenden Sie den folgenden Code, um eine @ Controller-Klassendatei zu erstellen und den Anforderungs-URI in eine HTML-Datei umzuleiten.

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WebController {
   @RequestMapping(value = "/index")
   public String index() {
      return "index";
   }
}

Im obigen Beispiel lautet der Anforderungs-URI /indexund das Steuerelement wird in die Datei index.html umgeleitet. Beachten Sie, dass die Datei index.html im Vorlagenverzeichnis und alle JS- und CSS-Dateien im Klassenpfad im statischen Verzeichnis abgelegt werden sollten. Im gezeigten Beispiel haben wir eine CSS-Datei verwendet, um die Farbe des Textes zu ändern.

Sie können den folgenden Code verwenden und eine CSS-Datei in einem separaten Ordner erstellen css und benennen Sie die Datei als styles.css -

h4 {
   color: red;
}

Der Code für die Datei index.html ist unten angegeben -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <link href = "css/styles.css" rel = "stylesheet"/>
      <title>Spring Boot Application</title>
   </head>
   <body>
      <h4>Welcome to Thymeleaf Spring Boot web application</h4>
   </body>
</html>

Der Projektexplorer wird im folgenden Screenshot gezeigt -

Jetzt müssen wir die Spring Boot Starter Thymeleaf-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Gradle-Benutzer können der build.gradle-Datei die folgende Abhängigkeit hinzufügen:

compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

Der Code für die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Der Code für Maven - pom.xml ist unten angegeben -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für Gradle - build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring-Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem hier angegebenen Befehl aus -

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 wie unten gezeigt gestartet.

Drücken Sie nun die URL in Ihrem Webbrowser und Sie können die Ausgabe wie gezeigt sehen -

http://localhost:8080/index

In diesem Kapitel wird ausführlich erläutert, wie Sie RESTful Web Services mithilfe von jQuery AJAX verwenden.

Erstellen Sie eine einfache Spring Boot-Webanwendung und schreiben Sie eine Controller-Klassendatei, die zum Umleiten in die HTML-Datei verwendet wird, um die RESTful-Webdienste zu nutzen.

Wir müssen den Spring Boot-Starter Thymeleaf und die Web-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Fügen Sie für Maven-Benutzer die folgenden Abhängigkeiten in Ihre pom.xml-Datei ein.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Fügen Sie für Gradle-Benutzer die folgenden Abhängigkeiten zu Ihrer build.gradle-Datei hinzu:

compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
compile(‘org.springframework.boot:spring-boot-starter-web’)

Der Code für die @ Controller-Klassendatei ist unten angegeben -

@Controller
public class ViewController {
}

Sie können die Anforderungs-URI-Methoden definieren, um in die HTML-Datei umzuleiten, wie unten gezeigt -

@RequestMapping(“/view-products”)
public String viewProducts() {
   return “view-products”;
}
@RequestMapping(“/add-products”)
public String addProducts() {
   return “add-products”;
}

Diese API http://localhost:9090/products sollte den folgenden JSON als Antwort wie unten gezeigt zurückgeben -

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

Erstellen Sie nun eine Datei view-products.html im Vorlagenverzeichnis im Klassenpfad.

In der HTML-Datei haben wir die jQuery-Bibliothek hinzugefügt und den Code geschrieben, um den RESTful-Webdienst beim Laden der Seite zu verwenden.

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

<script>
$(document).ready(function(){
   $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
         $("#productsJson").append(value.id+" "+value.name+" ");
      }); 
   });
});
</script>

Die POST-Methode und diese URL http://localhost:9090/products sollte den folgenden Anforderungs- und Antworttext enthalten.

Der Code für den Anfragetext ist unten angegeben -

{
   "id":"3",
   "name":"Ginger"
}

Der Code für den Antworttext ist unten angegeben -

Product is created successfully

Erstellen Sie nun die Datei add-products.html im Vorlagenverzeichnis im Klassenpfad.

In der HTML-Datei haben wir die jQuery-Bibliothek hinzugefügt und den Code geschrieben, der das Formular beim Klicken auf die Schaltfläche an den RESTful-Webdienst sendet.

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
   $(document).ready(function() {
      $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
            type : "POST",
            url : "http://localhost:9090/products",
            headers : {
               "Content-Type" : "application/json"
            },
            data : requestJSON,
            success : function(data) {
               alert(data);
            },
            error : function(data) {
            }
         });
      });
   });
</script>

Der vollständige Code ist unten angegeben.

Maven - pom.xml Datei

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Der Code für Gradle - build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = ‘1.5.8.RELEASE’
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: ‘java’
apply plugin: ‘eclipse’
apply plugin: ‘org.springframework.boot’

group = ‘com.tutorialspoint’
version = ‘0.0.1-SNAPSHOT’
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile(‘org.springframework.boot:spring-boot-starter-web’)
   compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
   testCompile(‘org.springframework.boot:spring-boot-starter-test’)
}

Die unten angegebene Controller-Klassendatei - ViewController.java ist unten angegeben -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping(“/view-products”)
   public String viewProducts() {
      return “view-products”;
   }
   @RequestMapping(“/add-products”)
   public String addProducts() {
      return “add-products”;   
   }   
}

Die Datei view-products.html ist unten angegeben -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>View Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function(){
            $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
                  $("#productsJson").append(value.id+" "+value.name+" ");
               }); 
            });
         });
      </script>
   </head>
   
   <body>
      <div id = "productsJson"> </div>
   </body>
</html>

Die Datei add-products.html ist unten angegeben -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <title>Add Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function() {
            $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
                  type : "POST",
                  url : "http://localhost:9090/products",
                  headers : {
                     "Content-Type" : "application/json"
                  },
                  data : requestJSON,
                  success : function(data) {
                     alert(data);
                  },
                  error : function(data) {
                  }
               });
            });
         });
      </script>
   </head>
   
   <body>
      <button>Click here to submit the form</button>
   </body>
</html>

Die Hauptklassendatei der Spring Boot-Anwendung ist unten angegeben:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Jetzt können Sie eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 gestartet.

Drücken Sie nun die URL in Ihrem Webbrowser und Sie können die Ausgabe wie gezeigt sehen -

http: // localhost: 8080 / view-products

http: // localhost: 8080 / add-products

Klicken Sie nun auf die Schaltfläche Click here to submit the form und Sie können das Ergebnis wie gezeigt sehen -

Klicken Sie nun auf die URL zum Anzeigen von Produkten und sehen Sie sich das erstellte Produkt an.

http://localhost:8080/view-products

Angular JS

Um die APIs mithilfe von Angular JS zu verwenden, können Sie die folgenden Beispiele verwenden:

Verwenden Sie den folgenden Code, um den Angular JS Controller für die Verwendung der GET-API zu erstellen. http://localhost:9090/products - -

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.get('http://localhost:9090/products'). then(function(response) { $scope.products = response.data;
   });
});

Verwenden Sie den folgenden Code, um den Angular JS Controller für die Verwendung der POST-API zu erstellen. http://localhost:9090/products - -

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.post('http://localhost:9090/products',data).
   then(function(response) {
      console.log("Product created successfully");
   });
});

Note - Die Post-Methodendaten repräsentieren den Anforderungshauptteil im JSON-Format zum Erstellen eines Produkts.

Cross-Origin Resource Sharing (CORS) ist ein Sicherheitskonzept, mit dem die in Webbrowsern implementierten Ressourcen eingeschränkt werden können. Es verhindert, dass der JavaScript-Code die Anforderungen gegen unterschiedliche Herkunft erzeugt oder verbraucht.

Beispielsweise wird Ihre Webanwendung auf dem 8080-Port ausgeführt, und mithilfe von JavaScript versuchen Sie, RESTful-Webdienste über den 9090-Port zu nutzen. In solchen Situationen tritt in Ihren Webbrowsern das Sicherheitsproblem Cross-Origin Resource Sharing auf.

Um dieses Problem zu lösen, sind zwei Anforderungen erforderlich:

• RESTful-Webdienste sollten die Cross-Origin Resource Sharing unterstützen.

• Die RESTful-Webdienstanwendung sollte den Zugriff auf die APIs über den 8080-Port ermöglichen.

In diesem Kapitel erfahren Sie ausführlich, wie Sie Cross-Origin-Anforderungen für eine RESTful-Webdienstanwendung aktivieren.

Aktivieren Sie CORS in der Controller-Methode

Wir müssen die Ursprünge für den RESTful-Webdienst mithilfe von festlegen @CrossOriginAnmerkung für die Controller-Methode. Diese @ CrossOrigin-Annotation unterstützt eine bestimmte REST-API und nicht für die gesamte Anwendung.

@RequestMapping(value = "/products")
@CrossOrigin(origins = "http://localhost:8080")

public ResponseEntity<Object> getProduct() {
   return null;
}

Globale CORS-Konfiguration

Wir müssen die angezeigte @ Bean-Konfiguration definieren, um die CORS-Konfigurationsunterstützung global auf Ihre Spring Boot-Anwendung festzulegen.

@Bean
public WebMvcConfigurer corsConfigurer() {
   return new WebMvcConfigurerAdapter() {
      @Override
      public void addCorsMappings(CorsRegistry registry) {
         registry.addMapping("/products").allowedOrigins("http://localhost:9000");
      }    
   };
}

Im Folgenden wird beschrieben, wie Sie die CORS-Konfiguration global in der Spring Boot-Hauptanwendung festlegen können.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public WebMvcConfigurer corsConfigurer() {
      return new WebMvcConfigurerAdapter() {
         @Override
         public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/products").allowedOrigins("http://localhost:8080");
         }
      };
   }
}

Jetzt können Sie eine Spring Boot-Webanwendung erstellen, die auf dem 8080-Port ausgeführt wird, und Ihre RESTful-Webdienstanwendung, die auf dem 9090-Port ausgeführt werden kann. Weitere Informationen zur Implementierung von RESTful Web Service finden Sie im Kapitel mit dem TitelConsuming RESTful Web Services dieses Tutorials.

Die Internationalisierung ist ein Prozess, mit dem Ihre Anwendung an verschiedene Sprachen und Regionen angepasst werden kann, ohne dass technische Änderungen am Quellcode vorgenommen werden müssen. Mit anderen Worten, Internationalisierung ist eine Bereitschaft zur Lokalisierung.

In diesem Kapitel erfahren Sie ausführlich, wie Sie die Internationalisierung in Spring Boot implementieren.

Abhängigkeiten

Wir benötigen die Abhängigkeiten Spring Boot Starter Web und Spring Boot Starter Thymeleaf, um eine Webanwendung in Spring Boot zu entwickeln.

Maven

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Gradle

compile('org.springframework.boot:spring-boot-starter-web')
compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

LocaleResolver

Wir müssen das Standardgebietsschema Ihrer Anwendung bestimmen. Wir müssen die LocaleResolver-Bean in unserer Spring Boot-Anwendung hinzufügen.

@Bean
public LocaleResolver localeResolver() {
   SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
   sessionLocaleResolver.setDefaultLocale(Locale.US);
   return sessionLocaleResolver;
}

LocaleChangeInterceptor

LocaleChangeInterceptor wird verwendet, um das neue Gebietsschema basierend auf dem Wert des Sprachparameters zu ändern, der einer Anforderung hinzugefügt wurde.

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
   LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
   localeChangeInterceptor.setParamName("language");
   return localeChangeInterceptor;
}

Um diesen Effekt zu erzielen, müssen wir den LocaleChangeInterceptor zum Registrierungs-Interceptor der Anwendung hinzufügen. Die Konfigurationsklasse sollte die WebMvcConfigurerAdapter-Klasse erweitern und die Methode addInterceptors () überschreiben.

@Override
public void addInterceptors(InterceptorRegistry registry) {
   registry.addInterceptor(localeChangeInterceptor());
}

Nachrichtenquellen

Die Spring Boot-Anwendung übernimmt standardmäßig die Nachrichtenquellen src/main/resourcesOrdner unter dem Klassenpfad. Der Standardname für das Gebietsschema der Nachrichtendatei sollte lautenmessage.properties und Dateien für jedes Gebietsschema sollten den Namen haben messages_XX.properties. Das "XX" steht für den Gebietsschema-Code.

Alle Nachrichteneigenschaften sollten als Schlüsselpaarwerte verwendet werden. Wenn im Gebietsschema keine Eigenschaften gefunden werden, verwendet die Anwendung die Standardeigenschaft aus der Datei messages.properties.

Die Standardnachrichten.Eigenschaften sind wie folgt:

welcome.text=Hi Welcome to Everyone

Die französische Sprache messages_fr.properties wird wie folgt angezeigt:

welcome.text=Salut Bienvenue à tous

Note - Die Nachrichtenquelldatei sollte im Dateiformat „UTF-8“ gespeichert werden.

HTML-Datei

Verwenden Sie in der HTML-Datei die Syntax #{key} um die Nachrichten aus der Eigenschaftendatei anzuzeigen.

<h1 th:text = "#{welcome.text}"></h1>

Der vollständige Code ist unten angegeben

Maven - 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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Gradle - build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Die Controller-Klassendatei ist unten angegeben -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping("/locale")
   public String locale() {
      return "locale";
   }
}

Konfigurationsklasse zur Unterstützung der Internationalisierung

package com.tutorialspoint.demo;

import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

@Configuration
public class Internationalization extends WebMvcConfigurerAdapter {
   @Bean
   public LocaleResolver localeResolver() {
      SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
      sessionLocaleResolver.setDefaultLocale(Locale.US);
      return sessionLocaleResolver;
   }
   @Bean
   public LocaleChangeInterceptor localeChangeInterceptor() {
      LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
      localeChangeInterceptor.setParamName("language");
      return localeChangeInterceptor;
   }
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(localeChangeInterceptor());
   }
}

Die Nachrichtenquellen - messages.properties sind wie gezeigt -

welcome.text = Hi Welcome to Everyone

Die Nachrichtenquellen - message_fr.properties sind wie gezeigt -

welcome.text = Salut Bienvenue à tous

Die HTML-Datei locale.html sollte wie gezeigt unter dem Vorlagenverzeichnis im Klassenpfad abgelegt werden.

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>Internationalization</title>
   </head>
   <body>
      <h1 th:text = "#{welcome.text}"></h1>
   </body>
</html>

Sie können eine ausführbare JAR-Datei erstellen und die Spring-Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Sie werden feststellen, dass die Anwendung auf dem Tomcat-Port 8080 gestartet wurde.

Nun drücke die URL http://localhost:8080/locale in Ihrem Webbrowser und Sie können die folgende Ausgabe sehen -

Die URL http://localhost:8080/locale?language=fr gibt Ihnen die Ausgabe wie gezeigt -

Bei der Planung werden die Aufgaben für den bestimmten Zeitraum ausgeführt. Spring Boot bietet eine gute Unterstützung für das Schreiben eines Schedulers für die Spring-Anwendungen.

Java Cron Ausdruck

Java Cron-Ausdrücke werden verwendet, um die Instanzen von CronTrigger, einer Unterklasse von org.quartz.Trigger, zu konfigurieren. Weitere Informationen zum Java-Cron-Ausdruck finden Sie unter diesem Link -

https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm

Die Annotation @EnableScheduling wird verwendet, um den Scheduler für Ihre Anwendung zu aktivieren. Diese Anmerkung sollte zur Hauptdatei der Spring Boot-Anwendungsklasse hinzugefügt werden.

@SpringBootApplication
@EnableScheduling

public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Die Annotation @Scheduled wird verwendet, um den Scheduler für einen bestimmten Zeitraum auszulösen.

@Scheduled(cron = "0 * 9 * * ?")
public void cronJobSch() throws Exception {
}

Das Folgende ist ein Beispielcode, der zeigt, wie die Aufgabe jede Minute ausgeführt wird, beginnend um 9:00 Uhr und endend jeden Tag um 9:59 Uhr

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(cron = "0 * 9 * * ?")
   public void cronJobSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Java cron job expression:: " + strDate);
   }
}

Der folgende Screenshot zeigt, wie die Anwendung um 09:03:23 Uhr gestartet wurde und für jede Minute ab diesem Zeitpunkt die Cron Job Scheduler-Aufgabe ausgeführt wurde.

Fester Zinssatz

Der Festpreisplaner wird verwendet, um die Aufgaben zu einem bestimmten Zeitpunkt auszuführen. Es wartet nicht auf den Abschluss der vorherigen Aufgabe. Die Werte sollten in Millisekunden angegeben werden. Der Beispielcode wird hier angezeigt -

@Scheduled(fixedRate = 1000)
public void fixedRateSch() { 
}

Ein Beispielcode zum Ausführen einer Aufgabe in jeder Sekunde ab dem Start der Anwendung wird hier angezeigt -

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedRate = 1000)
   public void fixedRateSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Rate scheduler:: " + strDate);
   }
}

Beachten Sie den folgenden Screenshot, der die Anwendung zeigt, die um 09:12:00 Uhr gestartet wurde und danach jede zweite Scheduler-Aufgabe mit fester Rate ausgeführt wurde.

Feste Verzögerung

Der Scheduler mit fester Verzögerung wird verwendet, um die Aufgaben zu einem bestimmten Zeitpunkt auszuführen. Es sollte auf den Abschluss der vorherigen Aufgabe warten. Die Werte sollten in Millisekunden angegeben werden. Ein Beispielcode wird hier angezeigt -

@Scheduled(fixedDelay = 1000, initialDelay = 1000)
public void fixedDelaySch() {
}

Hier ist die initialDelay die Zeit, nach der die Task das erste Mal nach dem anfänglichen Verzögerungswert ausgeführt wird.

Ein Beispiel zum Ausführen der Aufgabe für jede Sekunde nach Abschluss von 3 Sekunden nach dem Start der Anwendung ist unten dargestellt:

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedDelay = 1000, initialDelay = 3000)
   public void fixedDelaySch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Delay scheduler:: " + strDate);
   }
}

Beachten Sie den folgenden Screenshot, der die Anwendung zeigt, die um 09:18:39 gestartet wurde, und alle 3 Sekunden wurde die Scheduler-Task mit fester Verzögerung jede Sekunde ausgeführt.

Standardmäßig verwendet die Spring Boot-Anwendung beim Start der Anwendung den HTTP 8080-Port.

Sie müssen die folgenden Schritte ausführen, um das HTTPS und den Port 443 in der Spring Boot-Anwendung zu konfigurieren.

• Erhalten Sie das SSL-Zertifikat - Erstellen Sie ein selbstsigniertes Zertifikat oder beziehen Sie eines von einer Zertifizierungsstelle

• Aktivieren Sie HTTPS und 443 Port

Selbstsigniertes Zertifikat

Um ein selbstsigniertes Zertifikat zu erstellen, wird die Java-Laufzeitumgebung mit dem Schlüssel-Tool des Zertifikatsverwaltungsdienstprogramms geliefert. Mit diesem Dienstprogramm wird ein selbstsigniertes Zertifikat erstellt. Es wird in dem hier angegebenen Code angezeigt -

keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650
Enter keystore password:
   Re-enter new password:
   What is your first and last name?
   [Unknown]:
   What is the name of your organizational unit?
   [Unknown]:
   What is the name of your organization?
   [Unknown]:
   What is the name of your City or Locality?
   [Unknown]:
   What is the name of your State or Province?
   [Unknown]:
   What is the two-letter country code for this unit?
   [Unknown]:
   Is CN = Unknown, OU=Unknown, O = Unknown, L = Unknown, ST = Unknown, C = Unknown correct?
   [no]: yes

Dieser Code generiert eine PKCS12-Keystore-Datei mit dem Namen keystore.p12 und der Name des Zertifikatsalias lautet tomcat.

Konfigurieren Sie HTTPS

Wir müssen den Server-Port als 443, Schlüsselspeicher-Dateipfad, Schlüsselspeicher-Kennwort, Schlüsselspeicher-Typ und Schlüssel-Alias-Namen in der Datei application.properties angeben. Beachten Sie den hier angegebenen Code -

server.port: 443
server.ssl.key-store: keystore.p12
server.ssl.key-store-password: springboot
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcat

Sie können den folgenden Code verwenden, wenn Sie YAML-Eigenschaften verwenden. Verwenden Sie dazu application.yml -

server:
   port: 443
   ssl:
      key-store: keystore.p12
      key-store-password: springboot
      keyStoreType: PKCS12
      keyAlias: tomcat

Sie können eine ausführbare JAR-Datei erstellen und die Spring-Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den Befehl verwenden

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 443 mit https wie gezeigt gestartet -

Eureka Server ist eine Anwendung, die Informationen zu allen Client-Service-Anwendungen enthält. Jeder Micro-Dienst wird beim Eureka-Server registriert, und der Eureka-Server kennt alle Clientanwendungen, die an jedem Port und jeder IP-Adresse ausgeführt werden. Eureka Server wird auch als Discovery Server bezeichnet.

In diesem Kapitel erfahren Sie ausführlich, wie Sie einen Eureka-Server erstellen.

Erstellen eines Eureka-Servers

Eureka Server wird mit dem Paket Spring Cloud geliefert. Dazu müssen wir den Eureka-Server entwickeln und auf dem Standardport 8761 ausführen.

Besuchen Sie die Homepage des Spring Initializer https://start.spring.io/und laden Sie das Spring Boot-Projekt mit Eureka-Serverabhängigkeit herunter. Es wird im Screenshot unten gezeigt -

Nach dem Herunterladen des Projekts in der Hauptklassendatei der Spring Boot-Anwendung müssen wir die Annotation @EnableEurekaServer hinzufügen. Die Annotation @EnableEurekaServer wird verwendet, damit Ihre Spring Boot-Anwendung als Eureka-Server fungiert.

Der Code für die Hauptdatei der Spring Boot-Anwendungsklasse lautet wie folgt:

package com.tutorialspoint.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaserverApplication.class, args);
   }
}

Stellen Sie sicher, dass die Spring Cloud Eureka-Serverabhängigkeit in Ihrer Build-Konfigurationsdatei hinzugefügt ist.

Der Code für die Maven-Benutzerabhängigkeit wird unten angezeigt -

<dependency>
<groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>

Der Code für die Gradle-Benutzerabhängigkeit ist unten angegeben -

compile('org.springframework.cloud:spring-cloud-starter-eureka-server')

Die vollständige Build-Konfigurationsdatei finden Sie unten -

Maven 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>com.tutorialspoint</groupId>
   <artifactId>eurekaserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>eurekaserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka-server</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-eureka-server')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Standardmäßig registriert sich der Eureka-Server bei der Ermittlung. Sie sollten die unten angegebene Konfiguration in Ihre Datei application.properties oder application.yml einfügen.

Die Datei application.properties ist unten angegeben -

eureka.client.registerWithEureka = false
eureka.client.fetchRegistry = false
server.port = 8761

Die Datei application.yml ist unten angegeben -

eureka:
   client:
      registerWithEureka: false
      fetchRegistry: false
server:
   port: 8761

Jetzt können Sie eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten gezeigten Befehlen Maven oder Gradle ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Sie können feststellen, dass die Anwendung auf dem Tomcat-Port 8761 gestartet wurde (siehe unten).

Klicken Sie jetzt auf die URL http://localhost:8761/ In Ihrem Webbrowser finden Sie den Eureka-Server, der auf dem Port 8761 ausgeführt wird (siehe unten).

In diesem Kapitel erfahren Sie ausführlich, wie Sie die Spring Boot Micro-Dienstanwendung auf dem Eureka-Server registrieren. Stellen Sie vor der Registrierung der Anwendung sicher, dass Eureka Server auf Port 8761 ausgeführt wird, oder erstellen Sie zuerst den Eureka Server und führen Sie ihn aus. Weitere Informationen zum Erstellen des Eureka-Servers finden Sie im vorherigen Kapitel.

Zunächst müssen Sie die folgenden Abhängigkeiten in unsere Build-Konfigurationsdatei einfügen, um den Microservice beim Eureka-Server zu registrieren.

Maven-Benutzer können die folgenden Abhängigkeiten hinzufügen pom.xml Datei -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>

Gradle-Benutzer können die folgenden Abhängigkeiten hinzufügen build.gradle Datei -

compile('org.springframework.cloud:spring-cloud-starter-eureka')

Jetzt müssen wir die Annotation @EnableEurekaClient in die Hauptklasse der Spring Boot-Anwendungsklasse einfügen. Mit der Annotation @EnableEurekaClient fungiert Ihre Spring Boot-Anwendung als Eureka-Client.

Die Hauptanwendung für Spring Boot ist wie folgt:

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
}

Um die Spring Boot-Anwendung in Eureka Server zu registrieren, müssen Sie die folgende Konfiguration in unsere Datei application.properties oder application.yml einfügen und die Eureka Server-URL in unserer Konfiguration angeben.

Der Code für die Datei application.yml ist unten angegeben -

eureka:
   client:
      serviceUrl:
         defaultZone: http://localhost:8761/eureka
      instance:
      preferIpAddress: true
spring:
   application:
      name: eurekaclient

Der Code für die Datei application.properties ist unten angegeben -

eureka.client.serviceUrl.defaultZone  = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient

Fügen Sie nun den Rest Endpoint hinzu, um String in der Hauptanwendung von Spring Boot und die Webabhängigkeit von Spring Boot Starter in der Build-Konfigurationsdatei zurückzugeben. Beachten Sie den unten angegebenen Code -

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
@RestController
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String home() {
      return "Eureka Client application";
   }
}

Die gesamte Konfigurationsdatei ist unten angegeben.

For Maven user - 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>com.tutorialspoint</groupId>
   <artifactId>eurekaclient</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>eurekaclient</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>   
   </build>
   
</projecta>

For Gradle user – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-starter-eureka') testCompile('org.springframework.boot:spring-boot-starter-test') compile('org.springframework.boot:spring-boot-starter-web') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 gestartet und die Eureka-Client-Anwendung ist wie unten gezeigt beim Eureka-Server registriert.

Klicken Sie in Ihrem Webbrowser auf die URL http: // localhost: 8761 / und Sie können sehen, dass die Eureka Client-Anwendung bei Eureka Server registriert ist.

Nun drücke die URL http://localhost:8080/ in Ihrem Webbrowser und sehen Sie die Rest Endpoint-Ausgabe.

Zuul Server ist eine Gateway-Anwendung, die alle Anforderungen verarbeitet und das dynamische Routing von Microservice-Anwendungen übernimmt. Der Zuul-Server wird auch als Edgeserver bezeichnet.

Zum Beispiel, /api/user wird dem Benutzerdienst zugeordnet und / api / products wird dem Produktdienst zugeordnet, und Zuul Server leitet die Anforderungen dynamisch an die jeweilige Backend-Anwendung weiter.

In diesem Kapitel erfahren Sie ausführlich, wie Sie eine Zuul Server-Anwendung in Spring Boot erstellen.

Zuul Server-Anwendung erstellen

Der Zuul-Server ist mit der Spring Cloud-Abhängigkeit gebündelt. Sie können das Spring Boot-Projekt von der Spring Initializer-Seite herunterladenhttps://start.spring.io/ und wählen Sie die Zuul Server-Abhängigkeit.

Fügen Sie die Annotation @EnableZuulProxy zu Ihrer Spring Boot-Hauptanwendung hinzu. Die Annotation @EnableZuulProxy wird verwendet, damit Ihre Spring Boot-Anwendung als Zuul-Proxyserver fungiert.

package com.tutorialspoint.zuulserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy
public class ZuulserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZuulserverApplication.class, args);
   }
}

Sie müssen die Spring Cloud Starter Zuul-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer müssen die folgende Abhängigkeit in Ihre hinzufügen pom.xml Datei -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>

Fügen Sie für Gradle-Benutzer die folgende Abhängigkeit in Ihre build.gradle-Datei ein

compile('org.springframework.cloud:spring-cloud-starter-zuul')

Fügen Sie für das Zuul-Routing die folgenden Eigenschaften in Ihre Datei application.properties oder application.yml ein.

spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111

Dies bedeutet, dass http aufruft /api/demo/Lassen Sie sich an den Produktservice weiterleiten. Zum Beispiel,/api/demo/products wird weitergeleitet an /products.

Benutzer von yaml-Dateien können die unten gezeigte Datei application.yml verwenden -

server:
   port: 8111
spring:
   application:  
      name: zuulserver
zuul:

routes:
   products:
      path: /api/demo/**
      url: http://localhost:8080/

Note - Die http://localhost:8080/ Die Anwendung sollte bereits vor dem Routing über Zuul Proxy ausgeführt werden.

Die vollständige Build-Konfigurationsdatei finden Sie unten.

Maven-Benutzer können die unten angegebene Datei pom.xml verwenden -

<?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>com.tutorialspoint</groupId>
   <artifactId>zuulserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>zuulserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-zuul</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Gradle-Benutzer können die unten angegebene Datei build.gradle verwenden -

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-zuul')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten angegebenen Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem unten gezeigten Befehl aus -

java –jar <JARFILE>

Sie finden, dass die Anwendung auf dem Tomcat-Port 8111 gestartet wurde, wie hier gezeigt.

Klicken Sie jetzt auf die URL http://localhost:8111/api/demo/products in Ihrem Webbrowser und Sie können die Ausgabe von sehen /products REST-Endpunkt wie unten gezeigt -

Spring Cloud Configuration Server ist eine zentralisierte Anwendung, die alle anwendungsbezogenen Konfigurationseigenschaften verwaltet. In diesem Kapitel erfahren Sie ausführlich, wie Sie einen Spring Cloud-Konfigurationsserver erstellen.

Erstellen eines Spring Cloud-Konfigurationsservers

Laden Sie zunächst das Spring Boot-Projekt von der Spring Initializer-Seite herunter und wählen Sie die Spring Cloud Config Server-Abhängigkeit aus. Beachten Sie den folgenden Screenshot -

Fügen Sie nun die Spring Cloud Config-Serverabhängigkeit in Ihre Build-Konfigurationsdatei ein, wie unten erläutert.

Maven-Benutzer können die folgende Abhängigkeit in die Datei pom.xml einfügen.

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Gradle-Benutzer können die folgende Abhängigkeit in Ihre build.gradle-Datei einfügen.

compile('org.springframework.cloud:spring-cloud-config-server')

Fügen Sie nun die Annotation @EnableConfigServer in Ihre Hauptdatei der Spring Boot-Anwendungsklasse ein. Mit der Annotation @EnableConfigServer fungiert Ihre Spring Boot-Anwendung als Konfigurationsserver.

Die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

package com.tutorialspoint.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigserverApplication.class, args);
   }
}

Fügen Sie nun die folgende Konfiguration zu Ihrer Eigenschaftendatei hinzu und ersetzen Sie die Datei application.properties durch die Datei bootstrap.properties. Beachten Sie den unten angegebenen Code -

server.port = 8888
spring.cloud.config.server.native.searchLocations=file:///C:/configprop/
SPRING_PROFILES_ACTIVE=native

Der Konfigurationsserver wird auf dem Tomcat-Port 8888 ausgeführt, und die Eigenschaften der Anwendungskonfiguration werden von nativen Suchpositionen geladen.

Jetzt in file:///C:/configprop/Platzieren Sie Ihre Client-Anwendung - application.properties-Datei. Der Name Ihrer Clientanwendung lautet beispielsweiseconfig-clientBenennen Sie dann Ihre Datei application.properties in um config-client.properties und platzieren Sie die Eigenschaftendatei auf dem Pfad file:///C:/configprop/.

Der Code für die Eigenschaftendatei des Konfigurationsclients ist unten angegeben:

welcome.message = Welcome to Spring cloud config server

Die vollständige Build-Konfigurationsdatei finden Sie unten -

Maven-Benutzer können verwenden pom.xml unten angegeben -

<?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>com.tutorialspoint</groupId>
   <artifactId>configserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>configserver</name>
   <description>Demo project for Spring Boot</description>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-config-server</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle-Benutzer können die unten angegebene Datei build.gradle verwenden -

<scope>import</scope>
</dependency>
</dependencies>
buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-config-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Erstellen Sie nun eine ausführbare JAR-Datei und führen Sie die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen aus:

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8888 wie hier gezeigt gestartet -

Nun drücke die URL http://localhost:8888/config-client/default/master in Ihrem Webbrowser und Sie können die Konfigurationseigenschaften Ihrer Config-Client-Anwendung wie hier gezeigt sehen.

Einige Anwendungen benötigen möglicherweise Konfigurationseigenschaften, die möglicherweise geändert werden müssen, und Entwickler müssen sie möglicherweise herunterfahren oder die Anwendung neu starten, um dies auszuführen. Dies kann jedoch zu Ausfallzeiten in der Produktion und der Notwendigkeit eines Neustarts der Anwendung führen. Mit Spring Cloud Configuration Server können Entwickler die neuen Konfigurationseigenschaften laden, ohne die Anwendung neu zu starten und ohne Ausfallzeiten.

Arbeiten mit Spring Cloud Configuration Server

Laden Sie zunächst das Spring Boot-Projekt von herunter https://start.spring.io/und wählen Sie die Spring Cloud Config Client-Abhängigkeit. Fügen Sie nun die Spring Cloud Starter Config-Abhängigkeit in Ihre Build-Konfigurationsdatei ein.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

Gradle-Benutzer können die folgende Abhängigkeit in die hinzufügen build.gradle Datei.

compile('org.springframework.cloud:spring-cloud-starter-config')

Jetzt müssen Sie die Annotation @RefreshScope zu Ihrer Hauptanwendung von Spring Boot hinzufügen. Die Annotation @RefreshScope wird verwendet, um den Wert der Konfigurationseigenschaften vom Konfigurationsserver zu laden.

package com.example.configclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;

@SpringBootApplication
@RefreshScope
public class ConfigclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
}

Fügen Sie nun die Konfigurationsserver-URL in Ihre Datei application.properties ein und geben Sie Ihren Anwendungsnamen an.

Note - http: // localhost: 8888 Konfigurationsserver sollte ausgeführt werden, bevor die Konfigurationsclientanwendung gestartet wird.

spring.application.name = config-client
spring.cloud.config.uri = http://localhost:8888

Der Code zum Schreiben eines einfachen REST-Endpunkts zum Lesen der Begrüßungsnachricht vom Konfigurationsserver ist unten angegeben:

package com.example.configclient;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RefreshScope
@RestController
public class ConfigclientApplication {
   @Value("${welcome.message}")
   String welcomeText;
   
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String welcomeText() {
      return welcomeText;
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Für Maven können Sie den unten gezeigten Befehl verwenden -

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem hier gezeigten Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 wie hier gezeigt gestartet -

Sie können das Anmeldekonsolenfenster sehen. Die config-client-Anwendung ruft die Konfiguration von der abhttps://localhost:8888

2017-12-08 12:41:57.682  INFO 1104 --- [           
   main] c.c.c.ConfigServicePropertySourceLocator : 
   Fetching config from server at: http://localhost:8888

Jetzt drücke die URL, http://localhost:8080/ Die Begrüßungsnachricht wird vom Konfigurationsserver geladen.

Ändern Sie nun den Eigenschaftswert auf dem Konfigurationsserver und klicken Sie auf die POST-URL des Aktorendpunkts http://localhost:8080/refresh und sehen Sie den neuen Konfigurationseigenschaftswert in der URL http://localhost:8080/

Spring Boot Actuator bietet gesicherte Endpunkte für die Überwachung und Verwaltung Ihrer Spring Boot-Anwendung. Standardmäßig sind alle Aktorendpunkte gesichert. In diesem Kapitel erfahren Sie ausführlich, wie Sie den Spring Boot-Aktuator für Ihre Anwendung aktivieren.

Aktivieren des Spring Boot Actuator

Um Spring Boot-Aktorendpunkte für Ihre Spring Boot-Anwendung zu aktivieren, müssen Sie die Spring Boot Starter-Aktuatorabhängigkeit in unsere Build-Konfigurationsdatei aufnehmen.

Maven-Benutzer können die folgende Abhängigkeit in Ihre pom.xml-Datei einfügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Gradle-Benutzer können die folgende Abhängigkeit in Ihre build.gradle-Datei einfügen.

compile group: 'org.springframework.boot', name: 'spring-boot-starter-actuator'

In der Datei application.properties müssen wir die Sicherheit für Aktorendpunkte deaktivieren.

management.security.enabled = false

Benutzer von YAML-Dateien können der Datei application.yml die folgende Eigenschaft hinzufügen.

management:
   security:
      enabled: false

Wenn Sie die separate Portnummer für den Zugriff auf die Spring Boot Actutator-Endpunkte verwenden möchten, fügen Sie die Verwaltungsportnummer in die Datei application.properties ein.

management.port = 9000

Benutzer von YAML-Dateien können der Datei application.yml die folgende Eigenschaft hinzufügen.

management:
   port: 9000

Jetzt können Sie eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Jetzt können Sie die JAR-Datei mit dem folgenden Befehl ausführen:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 gestartet. Beachten Sie, dass dieselbe Anwendung auf zwei verschiedenen Portnummern ausgeführt wird, wenn Sie die Verwaltungsportnummer angegeben haben.

Einige wichtige Spring Boot Actuator-Endpunkte sind unten angegeben. Sie können sie in Ihren Webbrowser eingeben und Ihr Anwendungsverhalten überwachen.

ENDPUNKTE	VERWENDUNG
/ Metriken	Anzeigen der Anwendungsmetriken wie verwendeter Speicher, speicherfreier Speicher, Threads, Klassen, Systemverfügbarkeit usw.
/ env	Anzeigen der Liste der in der Anwendung verwendeten Umgebungsvariablen.
/Bohnen	Anzeigen der Spring Beans und ihrer Typen, Bereiche und Abhängigkeiten.
/Gesundheit	Anzeigen des Anwendungszustands
/die Info	Anzeigen der Informationen zur Spring Boot-Anwendung.
/Spur	Anzeigen der Liste der Spuren Ihrer Rest-Endpunkte.

Die Überwachung Ihrer Anwendung mithilfe des Spring Boot Actuator-Endpunkts ist etwas schwierig. Denn wenn Sie nicht viele Anwendungen haben, verfügt jede Anwendung über separate Aktorendpunkte, was die Überwachung erschwert. Spring Boot Admin Server ist eine Anwendung zum Verwalten und Überwachen Ihrer Microservice-Anwendung.

Um solche Situationen zu bewältigen, bietet CodeCentric Team eine Spring Boot Admin-Benutzeroberfläche zum Verwalten und Überwachen aller Actuator-Endpunkte Ihrer Spring Boot-Anwendung an einem Ort.

Zum Erstellen eines Spring Boot Admin-Servers müssen die folgenden Abhängigkeiten in Ihre Build-Konfigurationsdatei aufgenommen werden.

Maven-Benutzer können die folgenden Abhängigkeiten in Ihre pom.xml-Datei einfügen -

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server-ui</artifactId>
   <version>1.5.5</version>
</dependency>

Gradle-Benutzer können die folgenden Abhängigkeiten in Ihre build.gradle-Datei einfügen -

compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'

Fügen Sie die Annotation @EnableAdminServer in Ihre Hauptdatei der Spring Boot-Anwendungsklasse ein. Mit der Annotation @EnableAdminServer können Sie als Admin-Server alle anderen Microservices überwachen.

package com.tutorialspoint.adminserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import de.codecentric.boot.admin.config.EnableAdminServer;

@SpringBootApplication
@EnableAdminServer
public class AdminserverApplication {   
   public static void main(String[] args) {
      SpringApplication.run(AdminserverApplication.class, args);
   }
}

Definieren Sie nun den server.port und den Anwendungsnamen in der Datei application.properties.

server.port = 9090
spring.application.name = adminserver

Verwenden Sie für YAML-Benutzer die folgenden Eigenschaften, um die Portnummer und den Anwendungsnamen in der Datei application.yml zu definieren.

server:
   port: 9090
spring:
   application:
      name: adminserver

Die Build-Konfigurationsdatei ist unten angegeben.

For Maven users – 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>com.tutorialspoint</groupId>
   <artifactId>adminserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>adminserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>

      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server</artifactId>
         <version>1.5.5</version>
      </dependency>
      
      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server-ui</artifactId>
         <version>1.5.5</version>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

For Gradle users – build.gradle file

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
repositories {   
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
   compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'   
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Verwenden Sie für Maven den hier gezeigten Befehl -

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den hier gezeigten Befehl -

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 9090 gestartet, wie hier gezeigt -

Klicken Sie nun in Ihrem Webbrowser auf die folgende URL und rufen Sie die Benutzeroberfläche des Admin-Servers auf.

http://localhost:9090/

Um Ihre Microservice-Anwendung über Spring Boot Admin Server zu überwachen und zu verwalten, sollten Sie die Spring Boot Admin-Starter-Client-Abhängigkeit hinzufügen und den Admin Server-URI in die Anwendungseigenschaftendatei aufnehmen.

Note - Zum Überwachen einer Anwendung sollten Sie die Spring Boot Actuator-Endpunkte für Ihre Microservice-Anwendung aktivieren.

Fügen Sie zunächst die folgende Spring Client Admin-Starter-Client-Abhängigkeit und Spring Boot Starter-Aktuator-Abhängigkeit in Ihre Build-Konfigurationsdatei ein.

Maven-Benutzer können der Datei pom.xml die folgenden Abhängigkeiten hinzufügen:

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-starter-client</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Gradle-Benutzer können die folgenden Abhängigkeiten zu Ihrer build.gradle-Datei hinzufügen.

compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')

Fügen Sie nun die Spring Boot Admin Server-URL zu Ihrer Anwendungseigenschaftendatei hinzu.

Fügen Sie für Benutzer von Eigenschaftendateien die folgenden Eigenschaften in die Datei application.properties ein.

spring.boot.admin.url = http://localhost:9090/

Fügen Sie für YAML-Benutzer die folgende Eigenschaft in die Datei application.yml ein.

spring:
   boot:
      admin:
         url: http://localhost:9000/

Erstellen Sie nun eine ausführbare JAR-Datei und führen Sie die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen aus.

Für Maven können Sie den Befehl wie folgt verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den Befehl wie folgt verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem angezeigten Befehl aus -

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 9090 wie gezeigt gestartet -

Klicken Sie nun in Ihrem Webbrowser auf die folgende URL und sehen Sie, dass Ihre Spring Boot-Anwendung bei Spring Boot Admin Server registriert ist.

http://localhost:9090/

Klicken Sie nun auf Details Klicken Sie auf die Schaltfläche und sehen Sie die Aktorendpunkte in der Benutzeroberfläche des Admin-Servers.

Swagger2 ist ein Open Source-Projekt, mit dem die REST-API-Dokumente für RESTful-Webdienste generiert werden. Es bietet eine Benutzeroberfläche für den Zugriff auf unsere RESTful-Webdienste über den Webbrowser.

Um die Anwendung Swagger2 in Spring Boot zu aktivieren, müssen Sie die folgenden Abhängigkeiten in unsere Build-Konfigurationsdatei einfügen.

<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger2</artifactId>
   <version>2.7.0</version>
</dependency>
<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger-ui</artifactId>
   <version>2.7.0</version>
</dependency>

Fügen Sie für Gradle-Benutzer die folgenden Abhängigkeiten in Ihre build.gradle-Datei ein.

compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'

Fügen Sie nun die Annotation @ EnableSwagger2 in Ihre Spring Boot-Hauptanwendung ein. Die Annotation @ EnableSwagger2 wird verwendet, um Swagger2 für Ihre Spring Boot-Anwendung zu aktivieren.

Der Code für die Hauptanwendung von Spring Boot wird unten angezeigt -

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
}

Erstellen Sie als Nächstes Docket Bean, um Swagger2 für Ihre Spring Boot-Anwendung zu konfigurieren. Wir müssen das Basispaket definieren, um die REST-APIs für Swagger2 zu konfigurieren.

@Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }

Fügen Sie diese Bean nun in die Hauptdatei der Spring Boot-Anwendungsklasse selbst ein, und Ihre Hauptklasse der Spring Boot-Anwendung sieht wie folgt aus:

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
   @Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }
}

Fügen Sie nun die folgende Spring Boot Starter-Webabhängigkeit in Ihre Build-Konfigurationsdatei ein, um REST-Endpunkte wie unten gezeigt zu schreiben.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgende Abhängigkeit hinzufügen:

compile('org.springframework.boot:spring-boot-starter-web')

Hier wird der Code zum Erstellen von zwei einfachen RESTful-Webdiensten GET und POST in der Rest Controller-Datei angezeigt.

package com.tutorialspoint.swaggerdemo;

import java.util.ArrayList;
import java.util.List;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SwaggerAPIController {
   @RequestMapping(value = "/products", method = RequestMethod.GET)
   public List<String> getProducts() {
      List<String> productsList = new ArrayList<>();
      productsList.add("Honey");
      productsList.add("Almond");
      return productsList;
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public String createProduct() {
      return "Product is saved successfully";
   }
}

Die vollständige Build-Konfigurationsdatei finden Sie unten -

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>swagger-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>swagger-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger2</artifactId>
         <version>2.7.0</version>
      </dependency>

      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger-ui</artifactId>
         <version>2.7.0</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
} dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
   compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den hier gezeigten Befehl verwenden -

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den hier gezeigten Befehl verwenden -

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem hier gezeigten Befehl aus -

java –jar <JARFILE>

Jetzt wird die Anwendung wie gezeigt auf dem Tomcat-Port 8080 gestartet.

Klicken Sie jetzt in Ihrem Webbrowser auf die URL und sehen Sie sich die Funktionen der Swagger-API an.

http://localhost:8080/swagger-ui.html

Docker ist ein Containerverwaltungsdienst, der das Erstellen und Bereitstellen erleichtert. Wenn Sie ein Anfänger von Docker sind, erfahren Sie mehr über diesen Link -https://www.tutorialspoint.com/docker/index.htm

In diesem Kapitel erfahren Sie, wie Sie ein Docker-Image mithilfe von Maven- und Gradle-Abhängigkeiten für Ihre Spring Boot-Anwendung erstellen.

Erstellen Sie eine Docker-Datei

Erstellen Sie zunächst eine Datei mit dem Namen Dockerfile unter den Verzeichnissen src/main/dockermit den unten gezeigten Inhalten. Beachten Sie, dass diese Datei wichtig ist, um ein Docker-Image zu erstellen.

FROM java:8
VOLUME /tmp
ADD dockerapp-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Maven

Fügen Sie für Maven das Docker Maven-Plugin zu Ihrer Build-Konfigurationsdatei hinzu pom.xml

<properties>
   <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
</properties>

<build>
   <plugins>
      <plugin>
         <groupId>com.spotify</groupId>
         <artifactId>docker-maven-plugin</artifactId>
         <version>1.0.0</version>
         
         <configuration>
            <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                  <include>${project.build.finalName}.jar</include>
               </resource>
            </resources>
         </configuration>
      </plugin>
      
      <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
   </plugins>
   
</build>

Die vollständige Datei pom.xml finden Sie unten -

<?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>com.tutorialspoint</groupId>
   <artifactId>dockerapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>dockerapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            
            <configuration>
               <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                     <include>${project.build.finalName}.jar</include>
                  </resource>
               </resources>
            </configuration>
         </plugin>
         
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Jetzt können Sie Ihre Anwendung mit dem Befehl Maven ausführen mvn package docker:build

Note - Aktivieren Sie den Expose-Daemon ein tcp://localhost:2375 ohne TLS.

Nach erfolgreichem Build können Sie die Ausgabe auf der Konsole wie unten gezeigt sehen -

Zeigen Sie nun die Docker-Images mit dem Befehl Docker-Images an und sehen Sie sich die Image-Informationen auf der Konsole an.

Gradle

Um ein Docker-Image mithilfe der Gradle-Build-Konfiguration zu erstellen, müssen Sie das hinzufügen docker Plugin und müssen eine Aufgabe schreiben buildDocker um ein Docker-Image zu erstellen.

Der Code für die Gradle Docker-Konfiguration ist unten angegeben.

buildscript {
   .....
   dependencies {
      .....
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

.....
apply plugin: 'docker'

task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

Die vollständige Datei build.gradle finden Sie unten.

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'docker'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

Erstellen Sie nun ein Docker-Image mit dem unten gezeigten Befehl -

gradle build buildDocker

Nach dem Ausführen des Befehls wird das Protokoll BUILD SUCCESSFUL im Konsolenfenster angezeigt.

Sehen Sie sich nun die Docker-Images mit dem Befehl using an docker images und sehen Sie die Informationen des Bildes auf der Konsole.

Die meisten Entwickler haben Schwierigkeiten, Protokolle zu verfolgen, wenn ein Problem aufgetreten ist. Dies kann durch Spring Cloud Sleuth und ZipKin Server für Spring Boot-Anwendung gelöst werden.

Spring Cloud Sleuth

Spring Cloud Sleuth-Protokolle werden im folgenden Format gedruckt:

[application-name,traceid,spanid,zipkin-export]

Wo,

• Anwendungsname = Name der Anwendung

• Trace-ID = Jede Anforderungs- und Antwort-Trace-ID ist dieselbe, wenn derselbe Dienst oder ein Dienst zu einem anderen Dienst aufgerufen wird.

• Spanid = Span-ID wird zusammen mit der Trace-ID gedruckt. Die Bereichs-ID unterscheidet sich bei jeder Anforderung und Antwort, bei der ein Dienst zu einem anderen Dienst aufgerufen wird.

• Zipkin-Export = Standardmäßig ist es falsch. Wenn dies der Fall ist, werden Protokolle auf den Zipkin-Server exportiert.

Fügen Sie nun die Spring Cloud Starter Sleuth-Abhängigkeit wie folgt in Ihre Build-Konfigurationsdatei ein:

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

Gradle-Benutzer können Ihrer build.gradle-Datei die folgende Abhängigkeit hinzufügen:

compile('org.springframework.cloud:spring-cloud-starter-sleuth')

Fügen Sie nun die Protokolle wie hier gezeigt in die Rest Controller-Klassendatei Ihrer Spring Boot-Anwendung ein.

package com.tutorialspoint.sleuthapp;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SleuthappApplication {
   private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
   public static void main(String[] args) {
      SpringApplication.run(SleuthappApplication.class, args);
   }
   @RequestMapping("/")
   public String index() {
      LOG.log(Level.INFO, "Index API is calling");
      return "Welcome Sleuth!";
   }
}

Fügen Sie nun den Anwendungsnamen wie gezeigt in die Datei application.properties ein -

spring.application.name = tracinglogs

Der vollständige Code für die Build-Konfigurationsdatei ist unten angegeben.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>sleuthapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>sleuthapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-sleuth</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-sleuth')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem hier gezeigten Befehl aus -

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 8080 gestartet.

Klicken Sie nun in Ihrem Webbrowser auf die URL und sehen Sie die Ausgabe im Konsolenprotokoll.

http://localhost:8080/

Sie können die folgenden Protokolle im Konsolenfenster sehen. Beachten Sie, dass das Protokoll im folgenden Format gedruckt wird [Anwendungsname, Trace-ID, Spanid, Zipkin-Export]

Zipkin Server

Zipkin ist eine Anwendung, die die Spring Cloud Sleuth-Protokolle Ihrer Spring Boot-Anwendung überwacht und verwaltet. Um einen Zipkin-Server zu erstellen, müssen wir die Abhängigkeiten der Zipkin-Benutzeroberfläche und des Zipkin-Servers in unsere Build-Konfigurationsdatei aufnehmen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen:

<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-autoconfigure-ui</artifactId>
</dependency>

Gradle-Benutzer können die folgende Abhängigkeit in Ihre build.gradle-Datei einfügen -

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Konfigurieren Sie nun server.port = 9411 in der Anwendungseigenschaftendatei.

Fügen Sie für Benutzer von Eigenschaftendateien die folgende Eigenschaft in die Datei application.properties ein.

server.port = 9411

Fügen Sie für YAML-Benutzer die folgende Eigenschaft in die Datei application.yml ein.

server:
   port: 9411

Fügen Sie die Annotation @EnableZipkinServer in Ihre Hauptanwendungsklasse Spring Boot ein. Die Annotation @EnableZipkinServer wird verwendet, damit Ihre Anwendung als Zipkin-Server fungiert.

package com.tutorialspoint.zipkinapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;

@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZipkinappApplication.class, args);
   }
}

Der Code für die vollständige Build-Konfigurationsdatei ist unten angegeben.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>zipkinapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>zipkinapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-server</artifactId>
      </dependency>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-autoconfigure-ui</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('io.zipkin.java:zipkin-autoconfigure-ui') compile('io.zipkin.java:zipkin-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem angezeigten Befehl aus -

java –jar <JARFILE>

Jetzt wurde die Anwendung auf dem Tomcat-Port 9411 wie unten gezeigt gestartet.

Klicken Sie nun auf die folgende URL und sehen Sie die Benutzeroberfläche des Zipkin-Servers.

http://localhost:9411/zipkin/

Fügen Sie dann die folgende Abhängigkeit in Ihre Client-Service-Anwendung ein und verweisen Sie auf die Zipkin-Server-URL, um die Microservice-Protokolle über die Zipkin-Benutzeroberfläche zu verfolgen.

Fügen Sie nun die Spring Cloud Starter Zipkin-Abhängigkeit wie gezeigt in Ihre Build-Konfigurationsdatei ein -

Maven-Benutzer können die folgende Abhängigkeit in die Datei pom.xml einfügen:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Gradle-Benutzer können die folgende Abhängigkeit in die Datei build.gradle einfügen -

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Fügen Sie nun die hinzu Always Sampler Bean in Ihrer Spring Boot-Anwendung, um die Protokolle in den Zipkin-Server zu exportieren.

@Bean
public AlwaysSampler defaultSampler() {
   return new AlwaysSampler();
}

Wenn Sie die AlwaysSampler-Bean hinzufügen, ändert sich die Exportoption für Spring Sleuth Zipkin automatisch von false in true.

Konfigurieren Sie als Nächstes Ihre Zipkin Server-Basis-URL in der Datei client service application.properties.

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

Geben Sie dann die Ablaufverfolgungs-ID ein und suchen Sie die Ablaufverfolgungen in der Zipkin-Benutzeroberfläche.

http://localhost:9411/zipkin/traces/{traceid}/

Flyway ist eine Versionskontrollanwendung, mit der Sie Ihr Datenbankschema einfach und zuverlässig für alle Ihre Instanzen entwickeln können. Um mehr über Flyway zu erfahren, können Sie den Link www.flywaydb.org verwenden

Viele Softwareprojekte verwenden relationale Datenbanken. Dies erfordert die Behandlung von Datenbankmigrationen, die häufig auch als Schemamigrationen bezeichnet werden.

In diesem Kapitel erfahren Sie ausführlich, wie Sie die Flyway-Datenbank in Ihrer Spring Boot-Anwendung konfigurieren.

Flyway-Datenbank konfigurieren

Laden Sie zunächst das Spring Boot-Projekt von der Spring Initializer-Seite www.start.spring.io herunter und wählen Sie die folgenden Abhängigkeiten aus:

• Spring Boot Starter Web
• Flyway
• MySQL
• JDBC

Maven-Benutzer können die folgenden Abhängigkeiten in die Datei pom.xml einfügen.

<dependency>
   <groupId>org.flywaydb</groupId>
   <artifactId>flyway-core</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Gradle-Benutzer können die folgenden Abhängigkeiten in die Datei build.gradle einfügen.

compile('org.flywaydb:flyway-core')
compile('org.springframework.boot:spring-boot-starter-jdbc')
compile('org.springframework.boot:spring-boot-starter-web')
compile('mysql:mysql-connector-java')

In den Anwendungseigenschaften müssen die Datenbankeigenschaften zum Erstellen einer DataSource sowie die Flyway-Eigenschaften konfiguriert werden, die in den Anwendungseigenschaften konfiguriert werden müssen.

Fügen Sie für Benutzer von Eigenschaftendateien die folgenden Eigenschaften in die Datei application.properties ein.

spring.application.name = flywayapp  

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

flyway.url = jdbc:mysql://localhost:3306/mysql
flyway.schemas = USERSERVICE
flyway.user = root
flyway.password = root

YAML-Benutzer können der Datei application.yml die folgenden Eigenschaften hinzufügen.

spring:
   application:
      name: flywayapp  
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
flyway:
   url: jdbc:mysql://localhost:3306/mysql
   schemas: USERSERVICE
   user: "root"
   password: "root"

Erstellen Sie nun eine SQL-Datei unter src/main/resources/db/migrationVerzeichnis. Nennen Sie die SQL-Datei "V1__Initial.sql".

CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');

Der Hauptcode der Spring Boot-Anwendungsklassendatei ist unten angegeben -

package com.tutorialspoint.flywayapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class FlywayappApplication {
   public static void main(String[] args) {
      SpringApplication.run(FlywayappApplication.class, args);
   }
}

Die vollständige Build-Konfigurationsdatei finden Sie unten.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>flywayapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>flywayapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.flywaydb</groupId>
         <artifactId>flyway-core</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.flywaydb:flyway-core')
   compile('org.springframework.boot:spring-boot-starter-jdbc')
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('mysql:mysql-connector-java')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten angegebenen Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den hier gezeigten Befehl verwenden -

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den hier gezeigten Befehl verwenden -

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt wurde Tomcat auf dem Port 8080 gestartet und im Konsolenfenster können Sie die hier gezeigten Flyway-Datenbankprotokolle sehen.

Sie können jetzt zur Datenbank gehen und die ausgewählten Abfragen durchführen.

Mithilfe des Spring Boot RESTful-Webdiensts können Sie eine E-Mail mit Google Mail Transport Layer Security senden. Lassen Sie uns in diesem Kapitel detailliert verstehen, wie diese Funktion verwendet wird.

Zuerst müssen wir die Spring Boot Starter Mail-Abhängigkeit in Ihre Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

Gradle-Benutzer können der build.gradle-Datei die folgende Abhängigkeit hinzufügen.

compile('org.springframework.boot:spring-boot-starter-mail')

Der Code der Hauptklasse der Spring Boot-Anwendungsklasse ist unten angegeben:

package com.tutorialspoint.emailapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class EmailappApplication {
   public static void main(String[] args) {
      SpringApplication.run(EmailappApplication.class, args);
   }
}

Sie können eine einfache Rest-API schreiben, um sie wie gezeigt in der Rest Controller-Klassendatei an E-Mail zu senden.

package com.tutorialspoint.emailapp;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmailController {
   @RequestMapping(value = "/sendemail")
   public String sendEmail() {
      return "Email sent successfully";
   }   
}

Sie können eine Methode zum Senden der E-Mail mit Anhang schreiben. Definieren Sie die Eigenschaften mail.smtp und verwenden Sie PasswordAuthentication.

private void sendmail() throws AddressException, MessagingException, IOException {
   Properties props = new Properties();
   props.put("mail.smtp.auth", "true");
   props.put("mail.smtp.starttls.enable", "true");
   props.put("mail.smtp.host", "smtp.gmail.com");
   props.put("mail.smtp.port", "587");
   
   Session session = Session.getInstance(props, new javax.mail.Authenticator() {
      protected PasswordAuthentication getPasswordAuthentication() {
         return new PasswordAuthentication("[email protected]", "<your password>");
      }
   });
   Message msg = new MimeMessage(session);
   msg.setFrom(new InternetAddress("[email protected]", false));

   msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("[email protected]"));
   msg.setSubject("Tutorials point email");
   msg.setContent("Tutorials point email", "text/html");
   msg.setSentDate(new Date());

   MimeBodyPart messageBodyPart = new MimeBodyPart();
   messageBodyPart.setContent("Tutorials point email", "text/html");

   Multipart multipart = new MimeMultipart();
   multipart.addBodyPart(messageBodyPart);
   MimeBodyPart attachPart = new MimeBodyPart();

   attachPart.attachFile("/var/tmp/image19.png");
   multipart.addBodyPart(attachPart);
   msg.setContent(multipart);
   Transport.send(msg);   
}

Rufen Sie nun die obige sendmail () -Methode über die Rest-API wie gezeigt auf -

@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
   sendmail();
   return "Email sent successfully";   
}

Note - Bitte schalten Sie ein, um weniger sichere Apps in Ihren Google Mail-Kontoeinstellungen zuzulassen, bevor Sie eine E-Mail senden.

Die vollständige Build-Konfigurationsdatei finden Sie unten.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>emailapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>emailapp</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
   <java.version>1.8</java.version>
   </properties>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-mail</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build> 
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('org.springframework.boot:spring-boot-starter-mail')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Jetzt können Sie eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten gezeigten Befehlen Maven oder Gradle ausführen.

Für Maven können Sie den Befehl wie folgt verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den Befehl wie folgt verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Sie können sehen, dass die Anwendung auf dem Tomcat-Port 8080 gestartet wurde.

Klicken Sie nun in Ihrem Webbrowser auf die folgende URL und Sie erhalten eine E-Mail.

http://localhost:8080/sendemail

Hystrix ist eine Bibliothek von Netflix. Hystrix isoliert die Zugriffspunkte zwischen den Diensten, stoppt die Kaskadierung von Fehlern und bietet die Fallback-Optionen.

Zum Beispiel , wenn Sie eine 3 rufen ^rd Party - Anwendung, dauert es mehr Zeit , um die Antwort zu senden. Zu diesem Zeitpunkt wechselt das Steuerelement zur Fallback-Methode und gibt die benutzerdefinierte Antwort an Ihre Anwendung zurück.

In diesem Kapitel erfahren Sie, wie Sie die Hystrix in einer Spring Boot-Anwendung implementieren.

Zuerst müssen wir die Spring Cloud Starter Hystrix-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>

Gradle-Benutzer können der build.gradle-Datei die folgende Abhängigkeit hinzufügen:

compile('org.springframework.cloud:spring-cloud-starter-hystrix')

Fügen Sie nun die Annotation @EnableHystrix zu Ihrer Hauptdatei der Spring Boot-Anwendungsklasse hinzu. Die Annotation @EnableHystrix wird verwendet, um die Hystrix-Funktionen in Ihrer Spring Boot-Anwendung zu aktivieren.

Der Hauptcode der Spring Boot-Anwendungsklassendatei ist unten angegeben -

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@SpringBootApplication
@EnableHystrix
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
}

Schreiben Sie nun einen einfachen Rest Controller so, dass er den String nach 3 Sekunden ab der angeforderten Zeit zurückgibt.

@RequestMapping(value = "/")
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}

Fügen Sie nun den Befehl @Hystrix und @HystrixProperty für die Rest-API hinzu und definieren Sie das Zeitlimit in Millisekunden.

@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})

Definieren Sie als Nächstes die Fallback-Methode fallback_hello (), wenn die Antwort der Anforderung lange dauert.

private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

Die vollständige Rest Controller-Klassendatei, die REST-API- und Hystrix-Eigenschaften enthält, wird hier angezeigt:

@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}
private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

In diesem Beispiel wurde die REST-API in die Hauptdatei der Spring Boot-Anwendungsklasse selbst geschrieben.

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

@SpringBootApplication
@EnableHystrix
@RestController
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
   @RequestMapping(value = "/")
   @HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
      @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
   })
   public String hello() throws InterruptedException {
      Thread.sleep(3000);
      return "Welcome Hystrix";
   }
   private String fallback_hello() {
      return "Request fails. It takes long time to response";
   }
}

Die vollständige Build-Konfigurationsdatei finden Sie unten.

Maven – pom.xml file

<?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>com.tutorialspoint</groupId>
   <artifactId>hystrixapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>hystrixapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-hystrix</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-hystrix')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Dadurch wird die Anwendung auf dem Tomcat-Port 8080 wie unten gezeigt gestartet.

Klicken Sie jetzt auf die URL http://localhost:8080/in Ihrem Webbrowser und sehen Sie die Hystrix-Antwort. Die API benötigt 3 Sekunden, um zu antworten, aber das Hystrix-Zeitlimit beträgt 1 Sekunde.

In diesem Kapitel erfahren Sie, wie Sie eine interaktive Webanwendung mithilfe von Spring Boot mit Web-Sockets erstellen.

Um eine interaktive Webanwendung in Spring Boot mit Web-Socket zu erstellen, müssen Sie die folgenden Abhängigkeiten hinzufügen.

Maven-Benutzer sollten der Datei pom.xml die folgenden Abhängigkeiten hinzufügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>webjars-locator</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>sockjs-client</artifactId>
   <version>1.0.2</version>
</dependency>

<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>stomp-websocket</artifactId>
   <version>2.3.3</version>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>bootstrap</artifactId>
   <version>3.3.7</version>        </dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>jquery</artifactId>
   <version>3.1.0</version>
</dependency>

Gradle-Benutzer können der build.gradle-Datei die folgenden Abhängigkeiten hinzufügen:

compile("org.springframework.boot:spring-boot-starter-websocket")
compile("org.webjars:webjars-locator")
compile("org.webjars:sockjs-client:1.0.2")
compile("org.webjars:stomp-websocket:2.3.3")
compile("org.webjars:bootstrap:3.3.7")
compile("org.webjars:jquery:3.1.0")

Lassen Sie uns einen Message Handling Controller erstellen, der mit STOMP Messaging arbeitet. STOMP-Nachrichten können an die @ Controller-Klassendatei weitergeleitet werden. Beispielsweise ist GreetingController so zugeordnet, dass die Nachrichten an das Ziel "/ hello" verarbeitet werden.

package com.tutorialspoint.websocketapp;

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class GreetingController {
   @MessageMapping("/hello")
   @SendTo("/topic/greetings")
   public Greeting greeting(HelloMessage message) throws Exception {
      Thread.sleep(1000); // simulated delay
      return new Greeting("Hello, " + message.getName() + "!");
   }
}

Konfigurieren Sie nun Spring für STOMP-Messaging. Schreiben Sie eine WebSocketConfig-Klassendatei, die die AbstractWebSocketMessageBrokerConfigurer-Klasse wie unten gezeigt erweitert.

package com.tutorialspoint.websocketapp;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
   @Override
   public void configureMessageBroker(MessageBrokerRegistry config) {
      config.enableSimpleBroker("/topic");
      config.setApplicationDestinationPrefixes("/app");
   }
   @Override
   public void registerStompEndpoints(StompEndpointRegistry registry) {
      registry.addEndpoint("/tutorialspoint-websocket").withSockJS();
   }
}

Die Annotation @EnableWebSocketMessageBroker wird verwendet, um den Web-Socket-Nachrichtenbroker zum Erstellen von STOMP-Endpunkten zu konfigurieren.

Sie können eine Browser-Client-Datei unter der Datei src / main / resources / static / index.html wie gezeigt erstellen.

<!DOCTYPE html>
<html>
   <head>
      <title>Hello WebSocket</title>
      <link href = "/webjars/bootstrap/css/bootstrap.min.css" rel = "stylesheet">
      <link href = "/main.css" rel = "stylesheet">
      <script src = "/webjars/jquery/jquery.min.js"></script>
      <script src = "/webjars/sockjs-client/sockjs.min.js"></script>
      <script src = "/webjars/stomp-websocket/stomp.min.js"></script>
      <script src = "/app.js"></script>
   </head>
   
   <body>
      <noscript>
         <h2 style = "color: #ff0000">
            Seems your browser doesn't support Javascript! Websocket relies on Javascript being
            enabled. Please enable Javascript and reload this page!
         </h2>
      </noscript>
      <div id = "main-content" class = "container">
         <div class = "row">
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "connect">WebSocket connection:</label>
                     <button id = "connect" class = "btn btn-default" type = "submit">Connect</button>
                     <button id = "disconnect" class = "btn btn-default" type = "submit" disabled = "disabled">Disconnect
                     </button>
                  </div>
               </form>
            </div>
            
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "name">What is your name?</label>
                     <input type = "text" id = "name" class = "form-control" placeholder = "Your name here...">
                  </div>
                  <button id = "send" class = "btn btn-default" type = "submit">Send</button>
               </form>
            </div>
         </div>
         
         <div class  =  "row">
            <div class  =  "col-md-12">
               <table id  =  "conversation" class = "table table-striped">
                  <thead>
                     <tr>
                        <th>Greetings</th>
                     </tr>
                  </thead>
                  <tbody id  =  "greetings"></tbody>
               </table>
            </div>
         </div>
      </div>
   </body>
</html>

Lassen Sie uns eine app.js-Datei erstellen, um die Nachrichten mithilfe von STOMP zu verarbeiten und zu produzieren.

var stompClient = null;

function setConnected(connected) {
   $("#connect").prop("disabled", connected);
   $("#disconnect").prop("disabled", !connected); if (connected) { $("#conversation").show();
   } else {
      $("#conversation").hide(); } $("#greetings").html("");
}

function connect() {
   var socket = new SockJS('/tutorialspoint-websocket');
   stompClient = Stomp.over(socket);
   stompClient.connect({}, function (frame) {
      setConnected(true);
      console.log('Connected: ' + frame);
      stompClient.subscribe('/topic/greetings', function (greeting) {
         showGreeting(JSON.parse(greeting.body).content);
      });
   });
}
function disconnect() {
   if (stompClient !== null) {
      stompClient.disconnect();
   }
   setConnected(false);
   console.log("Disconnected");
}
function sendName() {
   stompClient.send("/app/hello", {}, JSON.stringify({'name': $("#name").val()})); } function showGreeting(message) { $("#greetings").append("<tr><td>" + message + "</td></tr>");
}
$(function () { $( "form" ).on('submit', function (e) {e.preventDefault();});
   $( "#connect" ).click(function() { connect(); }); $( "#disconnect" ).click(function() { disconnect(); });
   $( "#send" ).click(function() { sendName(); });
});

Der Code für die Hauptanwendung von Spring Boot wird unten angezeigt.

package com.tutorialspoint.websocketapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WebsocketappApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsocketappApplication.class, args);
   }  
}

Die vollständige Build-Konfigurationsdatei finden Sie unten.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>websocketapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websocketapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
   </parent>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-websocket</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>webjars-locator</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>sockjs-client</artifactId>
         <version>1.0.2</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>stomp-websocket</artifactId>
         <version>2.3.3</version>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>bootstrap</artifactId>
         <version>3.3.7</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>jquery</artifactId>
         <version>3.1.0</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <properties>
      <java.version>1.8</java.version>
   </properties>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.9.RELEASE")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

jar {
   baseName = 'websocketapp'
   version =  '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile("org.springframework.boot:spring-boot-starter-websocket")
   compile("org.webjars:webjars-locator")
   compile("org.webjars:sockjs-client:1.0.2")
   compile("org.webjars:stomp-websocket:2.3.3")
   compile("org.webjars:bootstrap:3.3.7")
   compile("org.webjars:jquery:3.1.0")

   testCompile("org.springframework.boot:spring-boot-starter-test")
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung ausführen, indem Sie die folgenden Befehle verwenden: Maven oder Gradle -

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den Befehl wie folgt verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem hier angegebenen Befehl aus -

java –jar <JARFILE>

Jetzt wurde die Anwendung wie gezeigt auf dem Tomcat-Port 8080 gestartet.

Klicken Sie jetzt auf die URL http://localhost:8080/ in Ihrem Webbrowser und verbinden Sie den Web-Socket und senden Sie die Begrüßung und empfangen Sie die Nachricht.

Der Batch-Service ist ein Prozess zum Ausführen mehrerer Befehle in einer einzelnen Aufgabe. In diesem Kapitel erfahren Sie, wie Sie einen Batch-Service in einer Spring Boot-Anwendung erstellen.

Betrachten wir ein Beispiel, in dem wir den Inhalt der CSV-Datei in HSQLDB speichern.

Um ein Batch-Service-Programm zu erstellen, müssen wir die Spring Boot Starter Batch-Abhängigkeit und die HSQLDB-Abhängigkeit in unsere Build-Konfigurationsdatei aufnehmen.

Maven-Benutzer können die folgenden Abhängigkeiten in die Datei pom.xml einfügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
   <groupId>org.hsqldb</groupId>
   <artifactId>hsqldb</artifactId>
</dependency>

Gradle-Benutzer können die folgenden Abhängigkeiten in die Datei build.gradle einfügen.

compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")

Fügen Sie nun die einfache CSV-Datendatei unter Klassenpfadressourcen - src / main / resources hinzu und benennen Sie die Datei wie gezeigt als file.csv -

William,John
Mike, Sebastian
Lawarance, Lime

Schreiben Sie als Nächstes ein SQL-Skript für HSQLDB - unter dem Ressourcenverzeichnis classpath - request_fail_hystrix_timeout

DROP TABLE USERS IF EXISTS;
CREATE TABLE USERS  (
   user_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
   first_name VARCHAR(20),
   last_name VARCHAR(20)
);

Erstellen Sie eine POJO-Klasse für das USERS-Modell wie gezeigt -

package com.tutorialspoint.batchservicedemo;
public class User {
   private String lastName;
   private String firstName;

   public User() {
   }
   public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   public String getFirstName() {
      return firstName;
   }
   public String getLastName() {
      return lastName;
   }
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }

   @Override
   public String toString() {
      return "firstName: " + firstName + ", lastName: " + lastName;
   }   
}

Erstellen Sie nun einen Zwischenprozessor, um die Vorgänge nach dem Lesen der Daten aus der CSV-Datei und vor dem Schreiben der Daten in SQL auszuführen.

package com.tutorialspoint.batchservicedemo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;

public class UserItemProcessor implements ItemProcessor<User, User> {
   private static final Logger log = LoggerFactory.getLogger(UserItemProcessor.class);

   @Override
   public User process(final User user) throws Exception {
      final String firstName = user.getFirstName().toUpperCase();
      final String lastName = user.getLastName().toUpperCase();
      final User transformedPerson = new User(firstName, lastName);

      log.info("Converting (" + user + ") into (" + transformedPerson + ")");
      return transformedPerson;
   }
}

Lassen Sie uns eine Stapelkonfigurationsdatei erstellen, um die Daten aus CSV zu lesen und wie unten gezeigt in die SQL-Datei zu schreiben. Wir müssen die Annotation @EnableBatchProcessing in die Konfigurationsklassendatei einfügen. Die Annotation @EnableBatchProcessing wird verwendet, um die Stapeloperationen für Ihre Spring Boot-Anwendung zu aktivieren.

package com.tutorialspoint.batchservicedemo;

import javax.sql.DataSource;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
   @Autowired
   public JobBuilderFactory jobBuilderFactory;

   @Autowired
   public StepBuilderFactory stepBuilderFactory;

   @Autowired
   public DataSource dataSource;

   @Bean
   public FlatFileItemReader<User> reader() {
      FlatFileItemReader<User> reader = new FlatFileItemReader<User>();
      reader.setResource(new ClassPathResource("file.csv"));
      reader.setLineMapper(new DefaultLineMapper<User>() {
         {
            setLineTokenizer(new DelimitedLineTokenizer() {
               {
                  setNames(new String[] { "firstName", "lastName" });
               }
            });
            setFieldSetMapper(new BeanWrapperFieldSetMapper<User>() {
               {
                  setTargetType(User.class);
               }
            });
         }
      });
      return reader;
   }
   @Bean
   public UserItemProcessor processor() {
      return new UserItemProcessor();
   }
   @Bean
   public JdbcBatchItemWriter<User> writer() {
      JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<User>();
      writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<User>());
      writer.setSql("INSERT INTO USERS (first_name, last_name) VALUES (:firstName, :lastName)");
      writer.setDataSource(dataSource);
      return writer;
   }
   @Bean
   public Job importUserJob(JobCompletionNotificationListener listener) {
      return jobBuilderFactory.get("importUserJob").incrementer(
         new RunIdIncrementer()).listener(listener).flow(step1()).end().build();
   }
   @Bean
   public Step step1() {
      return stepBuilderFactory.get("step1").<User, User>chunk(10).reader(reader()).processor(processor()).writer(writer()).build();
   }
}

Das reader() Die Methode wird verwendet, um die Daten aus der CSV-Datei zu lesen, und die writer () -Methode wird verwendet, um Daten in SQL zu schreiben.

Als Nächstes müssen wir eine Listener-Klasse für Benachrichtigungen zum Abschluss von Jobs schreiben, die zum Benachrichtigen nach Abschluss von Jobs verwendet wird.

package com.tutorialspoint.batchservicedemo;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;

@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {
   private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
   private final JdbcTemplate jdbcTemplate;

   @Autowired
   public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
      this.jdbcTemplate = jdbcTemplate;
   }
   @Override
   public void afterJob(JobExecution jobExecution) {
      if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
         log.info("!!! JOB FINISHED !! It's time to verify the results!!");

         List<User> results = jdbcTemplate.query(
            "SELECT first_name, last_name FROM USERS", new RowMapper<User>() {
            
            @Override
            public User mapRow(ResultSet rs, int row) throws SQLException {
               return new User(rs.getString(1), rs.getString(2));
            }
         });

         for (User person : results) {
            log.info("Found <" + person + "> in the database.");
         }
      }
   }
}

Erstellen Sie nun eine ausführbare JAR-Datei und führen Sie die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen aus.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den Befehl wie folgt verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem hier angegebenen Befehl aus -

java –jar <JARFILE>

Sie können die Ausgabe im Konsolenfenster wie gezeigt sehen -

Apache Kafka ist ein Open Source-Projekt, mit dem Nachrichten basierend auf dem fehlertoleranten Nachrichtensystem veröffentlicht und abonniert werden. Es ist schnell, skalierbar und vom Design her verteilt. Wenn Sie ein Anfänger von Kafka sind oder ein besseres Verständnis dafür erlangen möchten, lesen Sie bitte diesen Link - www.tutorialspoint.com/apache_kafka/

In diesem Kapitel erfahren Sie, wie Sie die Apache Kafka in Spring Boot-Anwendung implementieren.

Zuerst müssen wir die Spring Kafka-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>org.springframework.kafka</groupId>
   <artifactId>spring-kafka</artifactId>
   <version>2.1.0.RELEASE</version>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgende Abhängigkeit hinzufügen.

compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'

Nachrichten erstellen

Um Nachrichten in Apache Kafka zu erstellen, müssen Sie die Konfigurationsklasse für die Producer-Konfiguration wie folgt definieren:

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

@Configuration
public class KafkaProducerConfig {
   @Bean
   public ProducerFactory<String, String> producerFactory() {
      Map<String, Object> configProps = new HashMap<>();
      configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
      configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      return new DefaultKafkaProducerFactory<>(configProps);
   }
   @Bean
   public KafkaTemplate<String, String> kafkaTemplate() {
      return new KafkaTemplate<>(producerFactory());
   }
}

Um eine Nachricht zu veröffentlichen, verdrahten Sie das Kafka-Vorlagenobjekt automatisch und erstellen Sie die Nachricht wie gezeigt.

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
 
public void sendMessage(String msg) {
   kafkaTemplate.send(topicName, msg);
}

Eine Nachricht konsumieren

Um Nachrichten zu konsumieren, müssen wir eine Consumer-Konfigurationsklassendatei wie unten gezeigt schreiben.

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

@EnableKafka
@Configuration
public class KafkaConsumerConfig {
   @Bean
   public ConsumerFactory<String, String> consumerFactory() {
      Map<String, Object> props = new HashMap<>();
      props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:2181");
      props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id");
      props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      return new DefaultKafkaConsumerFactory<>(props);
   }
   @Bean
   public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
      ConcurrentKafkaListenerContainerFactory<String, String> 
      factory = new ConcurrentKafkaListenerContainerFactory<>();
      factory.setConsumerFactory(consumerFactory());
      return factory;
   }
}

Schreiben Sie als Nächstes einen Listener, um die Nachrichten abzuhören.

@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
   System.out.println("Received Messasge in group - group-id: " + message);
}

Rufen Sie die sendMessage () -Methode aus der ApplicationRunner-Klassenlaufmethode aus der Hauptklasse der Spring Boot-Anwendungsklasse auf und verwenden Sie die Nachricht aus derselben Klassendatei.

Der Hauptcode der Spring Boot-Anwendungsklassendatei ist unten angegeben:

package com.tutorialspoint.kafkademo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;

@SpringBootApplication
public class KafkaDemoApplication implements ApplicationRunner {
   @Autowired
   private KafkaTemplate<String, String> kafkaTemplate;

   public void sendMessage(String msg) {
      kafkaTemplate.send("tutorialspoint", msg);
   }
   public static void main(String[] args) {
      SpringApplication.run(KafkaDemoApplication.class, args);
   }
   @KafkaListener(topics = "tutorialspoint", groupId = "group-id")
   public void listen(String message) {
      System.out.println("Received Messasge in group - group-id: " + message);
   }
   @Override
   public void run(ApplicationArguments args) throws Exception {
      sendMessage("Hi Welcome to Spring For Apache Kafka");
   }
}

Der Code für die vollständige Build-Konfigurationsdatei ist unten angegeben.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>kafka-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>kafka-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.kafka</groupId>
         <artifactId>spring-kafka</artifactId>
         <version>2.1.0.RELEASE</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Erstellen Sie nun eine ausführbare JAR-Datei und führen Sie die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen aus.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem hier angegebenen Befehl aus -

java –jar <JARFILE>

Sie können die Ausgabe im Konsolenfenster sehen.

Twilio ist eine 3 ^rd Party - Anwendung verwendet , SMS zu senden und Sprachanrufe aus unserer Anwendung zu machen. Es ermöglicht uns, die SMS zu senden und Sprachanrufe programmgesteuert zu tätigen.

In diesem Kapitel erfahren Sie, wie Sie das Senden und Tätigen von SMS mithilfe von Spring Boot mit Twilio implementieren.

Note- Wir haben das Trail-Konto in Twilio verwendet, um die SMS zu senden und Sprachanrufe zu tätigen. Weitere Informationen zu Twilio finden Sie unter www.twilio.com .

Zuerst müssen wir die Twilio-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>com.twilio.sdk</groupId>
   <artifactId>twilio</artifactId>
   <version>7.16.1</version>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgende Abhängigkeit hinzufügen.

compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"

Initialisieren Sie nun das Twilio-Konto mit ACCOUNT_SID und AUTH_ID im statischen Block wie gezeigt -

static {
   Twilio.init(ACCOUNT_SID, AUTH_ID);
}

SMS senden

Um die SMS zu senden, müssen wir der Message.create () -Methode eine From-Number und eine To-Number geben. Der Inhalt des Nachrichtentexts muss auch für die Methode Message.creator () wie gezeigt bereitgestellt werden -

Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
   "Message from Spring Boot Application").create();

Die Hauptdatei der Spring Boot-Anwendungsklasse ist unten dargestellt.

package com.tutorialspoint.smsdemo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Message;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<your-account-sid>";
   private final static String AUTH_ID = "<your-auth-id>";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
         "Message from Spring Boot Application").create();
   }
}

Der vollständige Code zum Erstellen der Konfigurationsdatei ist unten angegeben.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring-Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem folgenden Befehl aus:

java –jar <JARFILE>

Jetzt erhalten Sie die SMS an Ihre "to-number".

Nachricht empfangen an "to-number".

Sent from your Twilio trail account
- Message from Spring Boot Application

Note- In diesem Beispiel haben wir das Trail-Konto verwendet. Sie sollten daher die Nummern überprüfen, bevor Sie die SMS senden.

Sprachanrufe

Um mit Twilio Sprachanrufe zu tätigen, müssen wir die Call.creator () -Methode aufrufen. Für diese Methode müssen wir eine To-Number-, From-Number- und Voice-Note bereitstellen, wie hier gezeigt.

Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
   new URI("http://demo.twilio.com/docs/voice.xml")).create();

Der Code für die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben.

package com.tutorialspoint.smsdemo; 

import java.net.URI;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Call;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<ACCOUNT-SID>";
   private final static String AUTH_ID = "AUTH-ID";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
         new URI("http://demo.twilio.com/docs/voice.xml")).create();
   }
}

Der Code für die vollständige Build-Konfigurationsdatei ist unten angegeben -

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Verwenden Sie für Maven den folgenden Befehl:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Verwenden Sie für Gradle den folgenden Befehl:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem hier angegebenen Befehl aus:

java –jar <JARFILE>

Jetzt erhalten Sie von Twilio einen Anruf an Ihre "to-number".

Drücken Sie eine beliebige Taste, nachdem Sie an dem Anruf teilgenommen haben. Sie hören die Sprachnotiz von https://demo.twilio.com/docs/voice.xml

Note- In diesem Beispiel haben wir das Trail-Konto verwendet. Sie sollten daher die Nummern überprüfen, bevor Sie Anrufe tätigen.

Unit Testing ist einer der Tests, die von den Entwicklern durchgeführt werden, um sicherzustellen, dass die Funktionen einzelner Einheiten oder Komponenten einwandfrei funktionieren.

In diesem Tutorial erfahren Sie, wie Sie mit Mockito und Web Controller einen Unit-Testfall schreiben.

Mockito

Um Mockito Mocks in Spring Beans zu injizieren, müssen wir die Mockito-Core-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>org.mockito</groupId>
   <artifactId>mockito-core</artifactId>
   <version>2.13.0</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgende Abhängigkeit hinzufügen.

compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')

Hier wird der Code zum Schreiben einer Service-Klasse angegeben, die eine Methode enthält, die den String-Wert zurückgibt.

package com.tutorialspoint.mockitodemo;

import org.springframework.stereotype.Service;

@Service
public class ProductService {
   public String getProductName() {
      return "Honey";
   } 
}

Fügen Sie nun die ProductService-Klasse wie gezeigt in eine andere Service-Klassendatei ein.

package com.tutorialspoint.mockitodemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
   @Autowired
   ProductService productService;

   public OrderService(ProductService productService) {
      this.productService = productService;
   }
   public String getProductName() {
      return productService.getProductName();
   }
}

Die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

package com.tutorialspoint.mockitodemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MockitoDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(MockitoDemoApplication.class, args);
   }
}

Konfigurieren Sie dann den Anwendungskontext für die Tests. Die Annotation @Profile ("Test") wird verwendet, um die Klasse zu konfigurieren, wenn die Testfälle ausgeführt werden.

package com.tutorialspoint.mockitodemo;

import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;

@Profile("test")
@Configuration
public class ProductServiceTestConfiguration {
   @Bean
   @Primary
   public ProductService productService() {
      return Mockito.mock(ProductService.class);
   }
}

Jetzt können Sie einen Unit-Test-Fall für den Bestellservice unter dem schreiben src/test/resources Paket.

package com.tutorialspoint.mockitodemo;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@SpringBootTest
@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
public class MockitoDemoApplicationTests {
   @Autowired
   private OrderService orderService;
   
   @Autowired
   private ProductService productService;

   @Test
   public void whenUserIdIsProvided_thenRetrievedNameIsCorrect() {
      Mockito.when(productService.getProductName()).thenReturn("Mock Product Name");
      String testName = orderService.getProductName();
      Assert.assertEquals("Mock Product Name", testName);
   }
}

Der vollständige Code für die Build-Konfigurationsdatei ist unten angegeben.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>mockito-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>mockito-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.mockito</groupId>
         <artifactId>mockito-core</artifactId>
         <version>2.13.0</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle1-Befehlen ausführen.

Für Maven können Sie den Befehl wie folgt verwenden:

mvn clean install

Sie können die Testergebnisse im Konsolenfenster sehen.

Für Gradle können Sie den Befehl wie folgt verwenden:

gradle clean build

Sie können die restlichen Ergebnisse im Konsolenfenster sehen.

Spring Boot bietet eine einfache Möglichkeit, eine Unit Test for Rest Controller-Datei zu schreiben. Mit Hilfe von SpringJUnit4ClassRunner und MockMvc können wir einen Webanwendungskontext erstellen, um die Unit Test for Rest Controller-Datei zu schreiben.

Unit Tests sollten unter dem geschrieben werden src/test/java Verzeichnis- und Klassenpfadressourcen zum Schreiben eines Tests sollten unter dem platziert werden src/test/resources Verzeichnis.

Zum Schreiben eines Komponententests müssen Sie die Spring Boot Starter Test-Abhängigkeit wie unten gezeigt in Ihre Build-Konfigurationsdatei einfügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Gradle-Benutzer können der build.gradle-Datei die folgende Abhängigkeit hinzufügen.

testCompile('org.springframework.boot:spring-boot-starter-test')

Bevor wir einen Testfall schreiben, sollten wir zuerst RESTful-Webdienste erstellen. Weitere Informationen zum Erstellen von RESTful-Webdiensten finden Sie in dem entsprechenden Kapitel in diesem Lernprogramm.

Schreiben eines Unit-Tests für den REST-Controller

In diesem Abschnitt erfahren Sie, wie Sie einen Komponententest für den REST-Controller schreiben.

Zuerst müssen wir eine abstrakte Klassendatei erstellen, die zum Erstellen des Webanwendungskontexts mithilfe von MockMvc verwendet wird, und die Methoden mapToJson () und mapFromJson () definieren, um das Java-Objekt in eine JSON-Zeichenfolge und die JSON-Zeichenfolge in ein Java-Objekt zu konvertieren.

package com.tutorialspoint.demo;

import java.io.IOException;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = DemoApplication.class)
@WebAppConfiguration
public abstract class AbstractTest {
   protected MockMvc mvc;
   @Autowired
   WebApplicationContext webApplicationContext;

   protected void setUp() {
      mvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
   }
   protected String mapToJson(Object obj) throws JsonProcessingException {
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.writeValueAsString(obj);
   }
   protected <T> T mapFromJson(String json, Class<T> clazz)
      throws JsonParseException, JsonMappingException, IOException {
      
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.readValue(json, clazz);
   }
}

Schreiben Sie als Nächstes eine Klassendatei, die die AbstractTest-Klasse erweitert, und schreiben Sie einen Unit-Test für jede Methode wie GET, POST, PUT und DELETE.

Der Code für den GET API-Testfall ist unten angegeben. Diese API dient zum Anzeigen der Produktliste.

@Test
public void getProductsList() throws Exception {
   String uri = "/products";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
      .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   Product[] productlist = super.mapFromJson(content, Product[].class);
   assertTrue(productlist.length > 0);
}

Der Code für den POST-API-Testfall ist unten angegeben. Diese API dient zum Erstellen eines Produkts.

@Test
public void createProduct() throws Exception {
   String uri = "/products";
   Product product = new Product();
   product.setId("3");
   product.setName("Ginger");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(201, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is created successfully");
}

Der Code für den PUT-API-Testfall ist unten angegeben. Diese API dient zum Aktualisieren des vorhandenen Produkts.

@Test
public void updateProduct() throws Exception {
   String uri = "/products/2";
   Product product = new Product();
   product.setName("Lemon");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is updated successsfully");
}

Der Code für den API-Testfall "Löschen" ist unten angegeben. Diese API löscht das vorhandene Produkt.

@Test
public void deleteProduct() throws Exception {
   String uri = "/products/2";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is deleted successsfully");
}

Die vollständige Controller-Testklassendatei finden Sie unten -

package com.tutorialspoint.demo;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.Before;
import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import com.tutorialspoint.demo.model.Product;

public class ProductServiceControllerTest extends AbstractTest {
   @Override
   @Before
   public void setUp() {
      super.setUp();
   }
   @Test
   public void getProductsList() throws Exception {
      String uri = "/products";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
         .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      Product[] productlist = super.mapFromJson(content, Product[].class);
      assertTrue(productlist.length > 0);
   }
   @Test
   public void createProduct() throws Exception {
      String uri = "/products";
      Product product = new Product();
      product.setId("3");
      product.setName("Ginger");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(201, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is created successfully");
   }
   @Test
   public void updateProduct() throws Exception {
      String uri = "/products/2";
      Product product = new Product();
      product.setName("Lemon");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is updated successsfully");
   }
   @Test
   public void deleteProduct() throws Exception {
      String uri = "/products/2";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is deleted successsfully");
   }
}

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den unten angegebenen Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Jetzt können Sie die Testergebnisse im Konsolenfenster sehen.

Für Gradle können Sie den folgenden Befehl verwenden:

gradle clean build

Sie können die restlichen Ergebnisse im Konsolenfenster sehen, wie unten gezeigt.

Spring Boot bietet eine sehr gute Unterstützung beim Erstellen einer DataSource für die Datenbank. Wir müssen keinen zusätzlichen Code schreiben, um eine DataSource in Spring Boot zu erstellen. Das Hinzufügen der Abhängigkeiten und das Ausführen der Konfigurationsdetails reicht aus, um eine DataSource zu erstellen und die Datenbank zu verbinden.

In diesem Kapitel verwenden wir die Spring Boot JDBC-Treiberverbindung, um die Datenbank zu verbinden.

Zuerst müssen wir die Spring Boot Starter JDBC-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können der Datei pom.xml die folgenden Abhängigkeiten hinzufügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgenden Abhängigkeiten hinzufügen.

compile('org.springframework.boot:spring-boot-starter-jdbc')

Stellen Sie eine Verbindung zur H2-Datenbank her

Um die H2-Datenbank zu verbinden, müssen wir die H2-Datenbankabhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Fügen Sie für Maven-Benutzer die folgende Abhängigkeit in Ihre pom.xml-Datei ein.

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

Fügen Sie für Gradle-Benutzer die folgende Abhängigkeit in Ihre build.gradle-Datei ein.

compile('com.h2database:h2')

Wir müssen die Datei schema.sql und die Datei data.sql im Verzeichnis classpath src / main / resources erstellen, um die H2-Datenbank zu verbinden.

Die Datei schema.sql ist unten angegeben.

CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));

Die Datei data.sql ist unten angegeben.

INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');

Verbinden Sie MySQL

Um die MySQL-Datenbank zu verbinden, müssen wir die MySQL-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Fügen Sie für Maven-Benutzer die folgende Abhängigkeit in Ihre pom.xml-Datei ein.

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

Fügen Sie für Gradle-Benutzer die folgende Abhängigkeit in Ihre build.gradle-Datei ein.

compile('mysql:mysql-connector-java')

Erstellen Sie nun wie gezeigt eine Datenbank und Tabellen in MySQL.

Fügen Sie für Benutzer von Eigenschaftendateien die folgenden Eigenschaften in die Datei application.properties ein.

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

Fügen Sie für YAML-Benutzer die folgenden Eigenschaften in die Datei application.yml ein.

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      username: "root"
      password: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000

Verbinden Sie Redis

Redis ist eine Open-Source-Datenbank, in der die speicherinterne Datenstruktur gespeichert wird. Um die Redis-Datenbank in der Spring Boot-Anwendung zu verbinden, müssen wir die Redis-Abhängigkeit in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer sollten der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

Gradle-Benutzer sollten der build.gradle-Datei die folgende Abhängigkeit hinzufügen.

compile('org.springframework.boot:spring-boot-starter-data-redis')

Für die Redis-Verbindung müssen wir RedisTemplate verwenden. Für RedisTemplate müssen wir die JedisConnectionFactory-Details bereitstellen.

@Bean
JedisConnectionFactory jedisConnectionFactory() {
   JedisConnectionFactory jedisConFactory = new JedisConnectionFactory();
   jedisConFactory.setHostName("localhost");
   jedisConFactory.setPort(6000);
   jedisConFactory.setUsePool(true);
   return jedisConFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(jedisConnectionFactory());
   template.setKeySerializer(new StringRedisSerializer());
   template.setHashKeySerializer(new StringRedisSerializer());
   template.setHashValueSerializer(new StringRedisSerializer());
   template.setValueSerializer(new StringRedisSerializer());
   return template;
}

Verdrahten Sie nun automatisch die RedisTemplate-Klasse und greifen Sie auf die Daten aus der Redis-Datenbank zu.

@Autowired

RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);

JDBCTemplate

Um mithilfe von JdbcTemplate in der Spring Boot-Anwendung auf die relationale Datenbank zuzugreifen, müssen Sie die Spring Boot Starter JDBC-Abhängigkeit in unsere Build-Konfigurationsdatei aufnehmen.

Wenn Sie dann die JdbcTemplate-Klasse @Autowired haben, verbindet Spring Boot automatisch die Datenbank und legt die Datenquelle für das JdbcTemplate-Objekt fest.

@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");

Die Annotation @Repository sollte der Klassendatei hinzugefügt werden. Die Annotation @Repository wird verwendet, um ein Datenbank-Repository für Ihre Spring Boot-Anwendung zu erstellen.

@Repository
public class ProductServiceDAO {
}

Mehrere DataSource

Wir können 'n' Anzahl Datenquellen in einer einzigen Spring Boot-Anwendung behalten. Das hier gegebene Beispiel zeigt, wie Sie mehr als eine Datenquelle in der Spring Boot-Anwendung erstellen. Fügen Sie nun die beiden Datenquellen-Konfigurationsdetails in die Anwendungseigenschaftendatei ein.

Fügen Sie für Benutzer von Eigenschaftendateien die folgenden Eigenschaften zu Ihrer Datei application.properties hinzu.

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.dbProductService.username = root
spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

spring.dbUserService.driverClassName = com.mysql.jdbc.Driver
spring.dbUserService.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect = true
spring.dbUserService.username = root
spring.dbUserService.password = root
spring.dbUserService.testOnBorrow = true
spring.dbUserService.testWhileIdle = true
spring.dbUserService.timeBetweenEvictionRunsMillis = 60000
spring.dbUserService.minEvictableIdleTimeMillis = 30000
spring.dbUserService.validationQuery = SELECT 1
spring.dbUserService.max-active = 15
spring.dbUserService.max-idle = 10
spring.dbUserService.max-wait = 8000

Yaml-Benutzer sollten die folgenden Eigenschaften in Ihre application.yml-Datei einfügen.

spring:
   dbProductService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
   dbUserService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1    
      max-active: 15
      max-idle: 10
      max-wait: 8000

Erstellen Sie jetzt eine Konfigurationsklasse, um eine DataSource und eine JdbcTemplate für mehrere Datenquellen zu erstellen.

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
public class DatabaseConfig {
   @Bean(name = "dbProductService")
   @ConfigurationProperties(prefix = "spring.dbProductService")
   @Primary
   public DataSource createProductServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "dbUserService")
   @ConfigurationProperties(prefix = "spring.dbUserService")
   public DataSource createUserServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "jdbcProductService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_ProductService(@Qualifier("dbProductService") DataSource productServiceDS) {
      return new JdbcTemplate(productServiceDS);
   }
   @Bean(name = "jdbcUserService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_UserService(@Qualifier("dbUserService") DataSource userServiceDS) {
      return new JdbcTemplate(userServiceDS);
   }
}

Verdrahten Sie dann das JDBCTemplate-Objekt mithilfe der Annotation @Qualifier automatisch.

@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;

@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;

Wenn dem Klassenpfad eine Spring Boot-Sicherheitsabhängigkeit hinzugefügt wird, erfordert die Spring Boot-Anwendung automatisch die Basisauthentifizierung für alle HTTP-Endpunkte. Die Endpunkte "/" und "/ home" erfordern keine Authentifizierung. Alle anderen Endpunkte erfordern eine Authentifizierung.

Um Ihrer Spring Boot-Anwendung eine Spring Boot-Sicherheit hinzuzufügen, müssen Sie die Spring Boot Starter-Sicherheitsabhängigkeit in unsere Build-Konfigurationsdatei aufnehmen.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgende Abhängigkeit hinzufügen.

compile("org.springframework.boot:spring-boot-starter-security")

Sichern einer Webanwendung

Erstellen Sie zunächst eine unsichere Webanwendung mithilfe von Thymeleaf-Vorlagen.

Erstellen Sie dann eine home.html-Datei unter src/main/resources/templates Verzeichnis.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example</title>
   </head>
   <body>
      <h1>Welcome!</h1>
      <p>Click <a th:href = "@{/hello}">here</a> to see a greeting.</p>
   </body>
   
</html>

Die einfache Ansicht /hello in der HTML-Datei mithilfe von Thymeleaf-Vorlagen definiert.

Erstellen Sie jetzt eine hello.html unter src/main/resources/templates Verzeichnis.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1>Hello world!</h1>
   </body>
   
</html>

Jetzt müssen wir den Spring MVC - View Controller für Privat- und Hallo-Ansichten einrichten.

Erstellen Sie dazu eine MVC-Konfigurationsdatei, die WebMvcConfigurerAdapter erweitert.

package com.tutorialspoint.websecuritydemo;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter {
   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
      registry.addViewController("/home").setViewName("home");
      registry.addViewController("/").setViewName("home");
      registry.addViewController("/hello").setViewName("hello");
      registry.addViewController("/login").setViewName("login");
   }
}

Fügen Sie nun die Sicherheitsabhängigkeit von Spring Boot Starter zu Ihrer Build-Konfigurationsdatei hinzu.

Maven-Benutzer können der Datei pom.xml die folgende Abhängigkeit hinzufügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgende Abhängigkeit hinzufügen.

compile("org.springframework.boot:spring-boot-starter-security")

Erstellen Sie jetzt eine Web Security-Konfigurationsdatei, mit der Sie Ihre Anwendung für den Zugriff auf die HTTP-Endpunkte mithilfe der Basisauthentifizierung sichern.

package com.tutorialspoint.websecuritydemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .authorizeRequests()
            .antMatchers("/", "/home").permitAll()
            .anyRequest().authenticated()
            .and()
         .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
   }
   @Autowired
   public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
      auth
         .inMemoryAuthentication()
         .withUser("user").password("password").roles("USER");
   }
}

Erstellen Sie nun eine login.html-Datei unter src/main/resources Verzeichnis, damit der Benutzer über den Anmeldebildschirm auf den HTTP-Endpunkt zugreifen kann.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org"
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example </title>
   </head>
   <body>
      <div th:if = "${param.error}">
         Invalid username and password.
      </div>
      <div th:if = "${param.logout}">
         You have been logged out.
      </div>
      
      <form th:action = "@{/login}" method = "post">
         <div>
            <label> User Name : <input type = "text" name = "username"/> </label>
         </div>
         <div>
            <label> Password: <input type = "password" name = "password"/> </label>
         </div>
         <div>
            <input type = "submit" value = "Sign In"/>
         </div>
      </form>
      
   </body>
</html>

Aktualisieren Sie abschließend die Datei hello.html, damit sich der Benutzer von der Anwendung abmelden und den aktuellen Benutzernamen wie unten gezeigt anzeigen kann.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1 th:inline = "text">Hello [[${#httpServletRequest.remoteUser}]]!</h1>
      <form th:action = "@{/logout}" method = "post">
         <input type = "submit" value = "Sign Out"/>
      </form>
   </body>
   
</html>

Der Code für die Hauptanwendung von Spring Boot ist unten angegeben -

package com.tutorialspoint.websecuritydemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WebsecurityDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsecurityDemoApplication.class, args);
   }
}

Der vollständige Code für die Build-Konfigurationsdatei ist unten angegeben.

Maven – 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>com.tutorialspoint</groupId>
   <artifactId>websecurity-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurity-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-thymeleaf')
   compile('org.springframework.boot:spring-boot-starter-web')
   
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
}

Erstellen Sie nun eine ausführbare JAR-Datei und führen Sie die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen aus.

Maven-Benutzer können den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Gradle-Benutzer können den Befehl wie folgt verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem unten gezeigten Befehl aus -

java –jar <JARFILE>

Klicken Sie auf die URL http://localhost:8080/in Ihrem Webbrowser. Sie können die Ausgabe wie gezeigt sehen.

In diesem Kapitel erfahren Sie mehr über Spring Boot Security-Mechanismen und OAuth2 mit JWT.

Autorisierungsserver

Authorization Server ist eine herausragende Architekturkomponente für die Web-API-Sicherheit. Der Autorisierungsserver fungiert als zentraler Autorisierungspunkt, über den Ihre Apps und HTTP-Endpunkte die Funktionen Ihrer Anwendung identifizieren können.

Ressourcenserver

Resource Server ist eine Anwendung, die den Clients das Zugriffstoken für den Zugriff auf die HTTP-Endpunkte des Resource Servers bereitstellt. Es handelt sich um eine Sammlung von Bibliotheken, die HTTP-Endpunkte, statische Ressourcen und dynamische Webseiten enthält.

OAuth2

OAuth2 ist ein Autorisierungsframework, mit dem die Anwendung Web Security vom Client aus auf die Ressourcen zugreifen kann. Um eine OAuth2-Anwendung zu erstellen, müssen wir uns auf den Grant-Typ (Autorisierungscode), die Client-ID und das Client-Geheimnis konzentrieren.

JWT-Token

JWT-Token ist ein JSON-Web-Token, mit dem die zwischen zwei Parteien gesicherten Ansprüche dargestellt werden. Weitere Informationen zum JWT-Token finden Sie unter www.jwt.io/ .

Jetzt erstellen wir eine OAuth2-Anwendung, die die Verwendung von Authorization Server, Resource Server, mithilfe eines JWT-Tokens ermöglicht.

Mit den folgenden Schritten können Sie die Spring Boot Security mit JWT-Token implementieren, indem Sie auf die Datenbank zugreifen.

Zunächst müssen wir die folgenden Abhängigkeiten in unsere Build-Konfigurationsdatei einfügen.

Maven-Benutzer können die folgenden Abhängigkeiten zu Ihrer pom.xml-Datei hinzufügen.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security.oauth</groupId>
   <artifactId>spring-security-oauth2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-jwt</artifactId>
</dependency>

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-test</artifactId>
   <scope>test</scope>
</dependency>

Gradle-Benutzer können der Datei build.gradle die folgenden Abhängigkeiten hinzufügen.

compile('org.springframework.boot:spring-boot-starter-security')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
testCompile('org.springframework.security:spring-security-test')

compile("org.springframework.security.oauth:spring-security-oauth2")
compile('org.springframework.security:spring-security-jwt')
compile("org.springframework.boot:spring-boot-starter-jdbc")
compile("com.h2database:h2:1.4.191")

wo,

• Spring Boot Starter Security - Implementiert die Federsicherheit

• Spring Security OAuth2 - Implementiert die OAUTH2-Struktur, um den Autorisierungsserver und den Ressourcenserver zu aktivieren.

• Spring Security JWT - Generiert das JWT-Token für die Websicherheit

• Spring Boot Starter JDBC - Greift auf die Datenbank zu, um sicherzustellen, dass der Benutzer verfügbar ist oder nicht.

• Spring Boot Starter Web - Schreibt HTTP-Endpunkte.

• H2 Database - Speichert die Benutzerinformationen zur Authentifizierung und Autorisierung.

Die vollständige Build-Konfigurationsdatei finden Sie unten.

<?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>com.tutorialspoint</groupId>
   <artifactId>websecurityapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurityapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security.oauth</groupId>
         <artifactId>spring-security-oauth2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-jwt</artifactId>
      </dependency>
      
      <dependency>
         <groupId>com.h2database</groupId>
         <artifactId>h2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
   compile("org.springframework.security.oauth:spring-security-oauth2")
   compile('org.springframework.security:spring-security-jwt')
   compile("org.springframework.boot:spring-boot-starter-jdbc")
   compile("com.h2database:h2:1.4.191")  
}

Fügen Sie nun in der Spring Boot-Hauptanwendung die Annotation @EnableAuthorizationServer und @EnableResourceServer hinzu, um als Auth-Server und Resource Server in derselben Anwendung zu fungieren.

Sie können auch den folgenden Code verwenden, um einen einfachen HTTP-Endpunkt für den Zugriff auf die API mit Spring Security mithilfe von JWT-Token zu schreiben.

package com.tutorialspoint.websecurityapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableAuthorizationServer
@EnableResourceServer
@RestController
public class WebsecurityappApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsecurityappApplication.class, args);
   }
   @RequestMapping(value = "/products")
   public String getProductName() {
      return "Honey";   
   }
}

Verwenden Sie den folgenden Code, um die POJO-Klasse zum Speichern der Benutzerinformationen zur Authentifizierung zu definieren.

package com.tutorialspoint.websecurityapp;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;

public class UserEntity {
   private String username;
   private String password;
   private Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
   
   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public Collection<GrantedAuthority> getGrantedAuthoritiesList() {
      return grantedAuthoritiesList;
   }
   public void setGrantedAuthoritiesList(Collection<GrantedAuthority> grantedAuthoritiesList) {
      this.grantedAuthoritiesList = grantedAuthoritiesList;
   }
   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }
}

Verwenden Sie nun den folgenden Code und definieren Sie die CustomUser-Klasse, die die org.springframework.security.core.userdetails.User-Klasse für die Spring Boot-Authentifizierung erweitert.

package com.tutorialspoint.websecurityapp;

import org.springframework.security.core.userdetails.User;

public class CustomUser extends User {
   private static final long serialVersionUID = 1L;
   public CustomUser(UserEntity user) {
      super(user.getUsername(), user.getPassword(), user.getGrantedAuthoritiesList());
   }
}

Sie können die Klasse @Repository erstellen, um die Benutzerinformationen aus der Datenbank zu lesen, an den benutzerdefinierten Benutzerdienst zu senden und die erteilte Berechtigung "ROLE_SYSTEMADMIN" hinzuzufügen.

package com.tutorialspoint.websecurityapp;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Repository;

@Repository
public class OAuthDao {
   @Autowired
   private JdbcTemplate jdbcTemplate;

   public UserEntity getUserDetails(String username) {
      Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
      String userSQLQuery = "SELECT * FROM USERS WHERE USERNAME=?";
      List<UserEntity> list = jdbcTemplate.query(userSQLQuery, new String[] { username },
         (ResultSet rs, int rowNum) -> {
         
         UserEntity user = new UserEntity();
         user.setUsername(username);
         user.setPassword(rs.getString("PASSWORD"));
         return user;
      });
      if (list.size() > 0) {
         GrantedAuthority grantedAuthority = new SimpleGrantedAuthority("ROLE_SYSTEMADMIN");
         grantedAuthoritiesList.add(grantedAuthority);
         list.get(0).setGrantedAuthoritiesList(grantedAuthoritiesList);
         return list.get(0);
      }
      return null;
   }
}

Sie können eine Serviceklasse für benutzerdefinierte Benutzerdetails erstellen, die die Datei org.springframework.security.core.userdetails.UserDetailsService erweitert, um die DAO-Repository-Klasse wie gezeigt aufzurufen.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class CustomDetailsService implements UserDetailsService {
   @Autowired
   OAuthDao oauthDao;

   @Override
   public CustomUser loadUserByUsername(final String username) throws UsernameNotFoundException {
      UserEntity userEntity = null;
      try {
         userEntity = oauthDao.getUserDetails(username);
         CustomUser customUser = new CustomUser(userEntity);
         return customUser;
      } catch (Exception e) {
         e.printStackTrace();
         throw new UsernameNotFoundException("User " + username + " was not found in the database");
      }
   }
}

Erstellen Sie als Nächstes eine @ configure-Klasse, um die Web-Sicherheit zu aktivieren, definieren Sie den Kennwortcodierer (BCryptPasswordEncoder) und definieren Sie die AuthenticationManager-Bean. Die Sicherheitskonfigurationsklasse sollte die WebSecurityConfigurerAdapter-Klasse erweitern.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Autowired
   private CustomDetailsService customDetailsService;

   @Bean
   public PasswordEncoder encoder() {
      return new BCryptPasswordEncoder();
   }
   @Override
   @Autowired
   protected void configure(AuthenticationManagerBuilder auth) throws Exception {
      auth.userDetailsService(customDetailsService).passwordEncoder(encoder());
   }
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http.authorizeRequests().anyRequest().authenticated().and().sessionManagement()
         .sessionCreationPolicy(SessionCreationPolicy.NEVER);
   }
   @Override
   public void configure(WebSecurity web) throws Exception {
      web.ignoring();
   }
   @Override
   @Bean
   public AuthenticationManager authenticationManagerBean() throws Exception {
      return super.authenticationManagerBean();
   }
}

Definieren Sie nun die OAuth2-Konfigurationsklasse, um die Client-ID, das Client-Geheimnis, den JwtAccessTokenConverter, den privaten Schlüssel und den öffentlichen Schlüssel für den Token-Signierer-Schlüssel und den Überprüfungsschlüssel hinzuzufügen, und konfigurieren Sie den ClientDetailsServiceConfigurer für die Token-Gültigkeit mit Gültigkeitsbereichen.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

@Configuration
public class OAuth2Config extends AuthorizationServerConfigurerAdapter {
   private String clientid = "tutorialspoint";
   private String clientSecret = "my-secret-key";
   private String privateKey = "private key";
   private String publicKey = "public key";

   @Autowired
   @Qualifier("authenticationManagerBean")
   private AuthenticationManager authenticationManager;
   
   @Bean
   public JwtAccessTokenConverter tokenEnhancer() {
      JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
      converter.setSigningKey(privateKey);
      converter.setVerifierKey(publicKey);
      return converter;
   }
   @Bean
   public JwtTokenStore tokenStore() {
      return new JwtTokenStore(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
      endpoints.authenticationManager(authenticationManager).tokenStore(tokenStore())
      .accessTokenConverter(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
      security.tokenKeyAccess("permitAll()").checkTokenAccess("isAuthenticated()");
   }
   @Override
   public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
      clients.inMemory().withClient(clientid).secret(clientSecret).scopes("read", "write")
         .authorizedGrantTypes("password", "refresh_token").accessTokenValiditySeconds(20000)
         .refreshTokenValiditySeconds(20000);

   }
}

Erstellen Sie jetzt mit openssl einen privaten und einen öffentlichen Schlüssel.

Sie können die folgenden Befehle zum Generieren eines privaten Schlüssels verwenden.

openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem

Sie können Für die Generierung öffentlicher Schlüssel die folgenden Befehle verwenden.

openssl rsa -in jwt.pem -pubout

Fügen Sie für die Version von Spring Boot, die älter als Version 1.5 ist, die folgende Eigenschaft in Ihre Datei application.properties ein, um die Reihenfolge der OAuth2-Ressourcenfilter zu definieren.

security.oauth2.resource.filter-order=3

Benutzer von YAML-Dateien können die folgende Eigenschaft in die YAML-Datei einfügen.

security:
   oauth2:
      resource:
         filter-order: 3

Erstellen Sie nun die Dateien schema.sql und data.sql unter den Klassenpfadressourcen src/main/resources/directory um die Anwendung mit der H2-Datenbank zu verbinden.

Die Datei schema.sql sieht wie folgt aus:

CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));

Die Datei data.sql ist wie gezeigt -

INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES (
   1, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG'); INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES ( 2, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG');

Note - Das Passwort sollte im Format Bcrypt Encoder in der Datenbanktabelle gespeichert sein.

Sie können eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen.

Für Maven können Sie den folgenden Befehl verwenden:

mvn clean install

Nach "BUILD SUCCESS" finden Sie die JAR-Datei im Zielverzeichnis.

Für Gradle können Sie den Befehl wie folgt verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie nun die JAR-Datei mit dem hier gezeigten Befehl aus -

java –jar <JARFILE>

Die Anwendung wird auf dem Tomcat-Port 8080 gestartet.

Klicken Sie nun über POSTMAN auf die URL der POST-Methode, um das OAUTH2-Token zu erhalten.

http://localhost:8080/oauth/token

Fügen Sie nun die Anforderungsheader wie folgt hinzu:

• Authorization - Grundlegende Authentifizierung mit Ihrer Client-ID und Ihrem Client-Geheimnis.

• Content Type - application / x-www-form-urlencoded

Fügen Sie nun die Anforderungsparameter wie folgt hinzu:

• grant_type = Passwort
• Benutzername = Ihr Benutzername
• Passwort = Ihr Passwort

Drücken Sie jetzt die API und erhalten Sie das access_token wie gezeigt -

Klicken Sie nun wie gezeigt auf die Resource Server-API mit dem Bearer-Zugriffstoken im Anforderungsheader.

Dann können Sie die Ausgabe wie unten gezeigt sehen -

Google Cloud Platform bietet Cloud-Computing-Dienste, mit denen die Spring Boot-Anwendung in der Cloud-Umgebung ausgeführt wird. In diesem Kapitel erfahren Sie, wie Sie die Spring Boot-Anwendung in der GCP App Engine-Plattform bereitstellen.

Laden Sie zunächst die Gradle Build Spring Boot-Anwendung von der Spring Initializer-Seite www.start.spring.io herunter . Beachten Sie den folgenden Screenshot.

Fügen Sie nun in der Datei build.gradle das Google Cloud-Appengine-Plugin und die Appengine-Klassenpfadabhängigkeit hinzu.

Der Code für die Datei build.gradle ist unten angegeben -

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath 'com.google.cloud.tools:appengine-gradle-plugin:1.3.3'
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'com.google.cloud.tools.appengine'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Schreiben Sie nun einen einfachen HTTP-Endpunkt und er gibt den String-Erfolg wie gezeigt zurück -

package com.tutorialspoint.appenginedemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class AppengineDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(AppengineDemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String success() {
      return "APP Engine deployment success";
   }
}

Fügen Sie als Nächstes die Datei app.yml wie gezeigt im Verzeichnis src / main / appengine hinzu.

runtime: java
env: flex

handlers:
- url: /.*
   script: this field is required, but ignored

Gehen Sie jetzt zur Google Cloud-Konsole und klicken Sie oben auf der Seite auf die Google Cloud-Shell aktivieren.

Verschieben Sie nun Ihre Quelldateien und Gradle-Dateien mithilfe der Google Cloud Shell in das Ausgangsverzeichnis Ihres Google Cloud-Computers.

Führen Sie nun den Befehl gradle appengineDeploy aus, und Ihre Anwendung wird in der Google Cloud-Appengine bereitgestellt.

Note - GCP sollte für die Abrechnung aktiviert sein. Bevor Sie Ihre Anwendung in Appengine bereitstellen, sollten Sie eine Appengine-Plattform in GCP erstellen.

Die Bereitstellung Ihrer Anwendung auf der GCP-Appengine-Plattform dauert einige Minuten.

Nach erfolgreicher Erstellung wird die Service-URL im Konsolenfenster angezeigt.

Klicken Sie nun auf die Service-URL und sehen Sie die Ausgabe.

Google Cloud SQL

Um Google Cloud SQL mit Ihrer Spring Boot-Anwendung zu verbinden, sollten Sie der Datei application.properties die folgenden Eigenschaften hinzufügen.

JDBC-URL-Format

jdbc:mysql://google/<DATABASE-NAME>?cloudSqlInstance = <GOOGLE_CLOUD_SQL_INSTANCE_NAME> &socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = <USERNAME>&password = <PASSWORD>

Note - Die Spring Boot-Anwendung und Google Cloud SQL sollten sich im selben GCP-Projekt befinden.

Die Datei application.properties ist unten angegeben.

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance = springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = root&password = rootspring.dbProductService.username = root

spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

Benutzer von YAML-Dateien können die folgenden Eigenschaften zu Ihrer application.yml-Datei hinzufügen.

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance=springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=root&password=root"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      validationQuery: SELECT 1
      
      max-active: 15
      max-idle: 10
      max-wait: 8000

In diesem Kapitel erfahren Sie, wie Sie die Google OAuth2-Anmeldung mithilfe der Spring Boot-Anwendung mit Gradle-Build hinzufügen.

Fügen Sie zunächst die Spring Boot OAuth2-Sicherheitsabhängigkeit in Ihre Build-Konfigurationsdatei ein, und Ihre Build-Konfigurationsdatei wird unten angegeben.

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint.projects'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile('org.springframework.security.oauth:spring-security-oauth2')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Fügen Sie nun den HTTP-Endpunkt hinzu, um das Benutzerprinzipal von Google zu lesen, nachdem Sie sich über Spring Boot in der Hauptdatei der Spring Boot-Anwendungsklasse wie unten angegeben authentifiziert haben.

package com.tutorialspoint.projects.googleservice;

import java.security.Principal;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class GoogleserviceApplication {
   public static void main(String[] args) {
      SpringApplication.run(GoogleserviceApplication.class, args);
   }
   @RequestMapping(value = "/user")
   public Principal user(Principal principal) {
      return principal;
   }
}

Schreiben Sie nun eine Konfigurationsdatei, um OAuth2SSO für die Websicherheit zu aktivieren, und entfernen Sie die Authentifizierung für die Datei index.html wie gezeigt -

package com.tutorialspoint.projects.googleservice;

import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableOAuth2Sso
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .csrf()
         .disable()
         .antMatcher("/**")
         .authorizeRequests()
         .antMatchers("/", "/index.html")
         .permitAll()
         .anyRequest()
         .authenticated();
   }
}

Fügen Sie als Nächstes die Datei index.html unter statischen Ressourcen hinzu und fügen Sie den Link hinzu, der zum HTTP-Endpunkt des Benutzers umgeleitet werden soll, um den Google-Benutzerprinzipal wie unten gezeigt zu lesen.

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1">
      <title>Insert title here</title>
   </head>
   <body>
      <a href = "user">Click here to Google Login</a>
   </body>
</html>

Note - In der Google Cloud-Konsole - Aktivieren Sie die APIs für Google Mail-Dienste, Analytics-Dienste und Google+ Dienste.

Gehen Sie dann zum Abschnitt Anmeldeinformationen, erstellen Sie Anmeldeinformationen und wählen Sie OAuth-Client-ID.

Geben Sie als Nächstes einen Produktnamen im OAuth2-Zustimmungsbildschirm ein.

Wählen Sie als Nächstes den Anwendungstyp als "Webanwendung" aus, geben Sie die autorisierten JavaScript-Ursprünge und die autorisierten Umleitungs-URIs an.

Jetzt werden Ihre OAuth2-Client-ID und Ihr Client-Geheimnis erstellt.

Fügen Sie als Nächstes die Client-ID und das Client-Geheimnis in Ihre Anwendungseigenschaftendatei ein.

security.oauth2.client.clientId = <CLIENT_ID>
security.oauth2.client.clientSecret = <CLIENT_SECRET>
security.oauth2.client.accessTokenUri  =  https://www.googleapis.com/oauth2/v3/token
security.oauth2.client.userAuthorizationUri  =  https://accounts.google.com/o/oauth2/auth
security.oauth2.client.tokenName = oauth_token
security.oauth2.client.authenticationScheme = query
security.oauth2.client.clientAuthenticationScheme = form
security.oauth2.client.scope = profile email

security.oauth2.resource.userInfoUri  =  https://www.googleapis.com/userinfo/v2/me
security.oauth2.resource.preferTokenInfo = false

Jetzt können Sie eine ausführbare JAR-Datei erstellen und die Spring Boot-Anwendung mit dem folgenden Gradle-Befehl ausführen.

Für Gradle können Sie den Befehl wie folgt verwenden:

gradle clean build

Nach "BUILD SUCCESSFUL" finden Sie die JAR-Datei im Verzeichnis build / libs.

Führen Sie die JAR-Datei mit dem Befehl java –jar <JARFILE> aus, und die Anwendung wird auf dem Tomcat-Port 8080 gestartet.

Nun drücke die URL http://localhost:8080/ und klicken Sie auf den Link Google Login.

Es wird zum Google-Anmeldebildschirm weitergeleitet und bietet Google Mail-Anmeldedaten.

Bei erfolgreicher Anmeldung erhalten wir das Hauptobjekt des Google Mail-Nutzers.