Spring Boot - Szybki przewodnik

Spring Boot to platforma open source oparta na języku Java służąca do tworzenia mikroserwisów. Jest rozwijany przez Pivotal Team i służy do tworzenia samodzielnych i gotowych do produkcji aplikacji sprężynowych. W tym rozdziale znajdziesz wprowadzenie do Spring Boot i zapoznasz się z podstawowymi koncepcjami.

Co to jest usługa Micro?

Micro Service to architektura, która umożliwia programistom niezależne opracowywanie i wdrażanie usług. Każda uruchomiona usługa ma swój własny proces, dzięki czemu uzyskuje się lekki model do obsługi aplikacji biznesowych.

Zalety

Micro Services oferuje swoim programistom następujące korzyści -

• Łatwe wdrożenie
• Prosta skalowalność
• Kompatybilny z pojemnikami
• Minimalna konfiguracja
• Krótszy czas produkcji

Co to jest Spring Boot?

Spring Boot stanowi dobrą platformę dla programistów Java do tworzenia samodzielnych i produkcyjnych aplikacji wiosennych, które możesz just run. Możesz rozpocząć od minimalnych konfiguracji bez konieczności wykonywania całej konfiguracji Spring.

Zalety

Spring Boot oferuje swoim programistom następujące korzyści -

• Łatwe do zrozumienia i rozwijania aplikacji sprężynowych
• Zwiększa produktywność
• Skraca czas rozwoju

Cele

Spring Boot ma następujące cele -

• Aby uniknąć skomplikowanej konfiguracji XML w Spring
• Aby w łatwiejszy sposób opracować gotowe do produkcji aplikacje Spring
• Aby skrócić czas programowania i uruchomić aplikację niezależnie
• Oferuj łatwiejszy sposób rozpoczęcia korzystania z aplikacji

Dlaczego Spring Boot?

Możesz wybrać Spring Boot ze względu na funkcje i zalety, które oferuje, jak podano tutaj -

• Zapewnia elastyczny sposób konfigurowania Java Beans, konfiguracji XML i transakcji w bazie danych.

• Zapewnia wydajne przetwarzanie wsadowe i zarządza punktami końcowymi REST.

• W Spring Boot wszystko jest automatycznie konfigurowane; nie są potrzebne żadne konfiguracje ręczne.

• Oferuje aplikację sprężynową opartą na adnotacjach

• Ułatwia zarządzanie zależnościami

• Zawiera wbudowany kontener serwletów

Jak to działa?

Spring Boot automatycznie konfiguruje aplikację na podstawie zależności, które zostały dodane do projektu przy użyciu @EnableAutoConfigurationadnotacja. Na przykład, jeśli baza danych MySQL znajduje się w ścieżce klasy, ale nie skonfigurowałeś żadnego połączenia z bazą danych, Spring Boot automatycznie konfiguruje bazę danych w pamięci.

Punktem wejścia aplikacji rozruchu sprężynowego jest klasa zawiera @SpringBootApplication adnotacja i główna metoda.

Spring Boot automatycznie skanuje wszystkie komponenty zawarte w projekcie przy użyciu @ComponentScan adnotacja.

Spring Boot Starters

Zarządzanie zależnościami to trudne zadanie w przypadku dużych projektów. Spring Boot rozwiązuje ten problem, udostępniając zestaw zależności dla wygody programistów.

Na przykład, jeśli chcesz używać Spring i JPA do dostępu do bazy danych, wystarczy, że włączysz spring-boot-starter-data-jpa zależność w projekcie.

Zauważ, że wszystkie startery Spring Boot mają ten sam wzorzec nazewnictwa spring-boot-starter- *, gdzie * oznacza, że ​​jest to typ aplikacji.

Przykłady

Spójrz na poniższe startery Spring Boot wyjaśnione poniżej, aby lepiej zrozumieć -

Spring Boot Starter Actuator dependencysłuży do monitorowania aplikacji i zarządzania nią. Jego kod pokazano poniżej -

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

Spring Boot Starter Security dependencyjest używany dla Spring Security. Jego kod pokazano poniżej -

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

Spring Boot Starter web dependencysłuży do pisania Rest Endpoints. Jego kod pokazano poniżej -

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

Spring Boot Starter Thyme Leaf dependencysłuży do tworzenia aplikacji internetowych. Jego kod pokazano poniżej -

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

Spring Boot Starter Test dependencysłuży do pisania przypadków testowych. Jego kod pokazano poniżej -

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

Konfiguracja automatyczna

Spring Boot Auto Configuration automatycznie konfiguruje Twoją aplikację Spring na podstawie zależności JAR dodanych w projekcie. Na przykład, jeśli baza danych MySQL znajduje się na ścieżce klasy, ale nie skonfigurowałeś żadnego połączenia z bazą danych, Spring Boot automatycznie konfiguruje bazę danych w pamięci.

W tym celu musisz dodać @EnableAutoConfiguration adnotacja lub @SpringBootApplicationadnotacja do głównego pliku klasy. Następnie Twoja aplikacja Spring Boot zostanie automatycznie skonfigurowana.

Obserwuj następujący kod, aby lepiej zrozumieć -

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

Aplikacja Spring Boot

Punktem wejścia aplikacji Spring Boot jest klasa zawiera @SpringBootApplicationadnotacja. Ta klasa powinna mieć główną metodę uruchamiania aplikacji Spring Boot.@SpringBootApplication adnotacja obejmuje automatyczną konfigurację, skanowanie składników i konfigurację rozruchu sprężynowego.

Jeśli dodałeś @SpringBootApplication adnotacji do zajęć, nie musisz dodawać pliku @EnableAutoConfiguration, @ComponentScan i @SpringBootConfigurationadnotacja. Plik@SpringBootApplication adnotacja obejmuje wszystkie inne adnotacje.

Obserwuj następujący kod, aby lepiej zrozumieć -

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

Skanowanie składników

Aplikacja Spring Boot skanuje wszystkie komponenty bean i deklaracje pakietów podczas inicjowania aplikacji. Musisz dodać@ComponentScan adnotacja do pliku klasy, aby przeskanować komponenty dodane w projekcie.

Obserwuj następujący kod, aby lepiej zrozumieć -

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

W tym rozdziale nauczysz się, jak stworzyć aplikację Spring Boot przy użyciu Maven i Gradle.

Wymagania wstępne

Twój system musi spełniać następujące minimalne wymagania, aby utworzyć aplikację Spring Boot:

• Java 7
• Maven 3.2
• Gradle 2.5

Spring Boot CLI

Spring Boot CLI to narzędzie wiersza poleceń, które pozwala nam uruchamiać skrypty Groovy. Jest to najłatwiejszy sposób na stworzenie aplikacji Spring Boot przy użyciu interfejsu wiersza poleceń Spring Boot. Możesz tworzyć, uruchamiać i testować aplikację w samym wierszu poleceń.

W tej sekcji opisano czynności związane z ręczną instalacją interfejsu wiersza polecenia Spring Boot. Aby uzyskać dalszą pomoc, możesz skorzystać z następującego łącza:https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot

Możesz również pobrać dystrybucję Spring CLI z repozytorium oprogramowania Spring pod adresem: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation

W przypadku instalacji ręcznej musisz użyć następujących dwóch folderów -

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

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

Po pobraniu rozpakuj plik archiwum i postępuj zgodnie z instrukcjami podanymi w pliku install.txt. Nie to, że nie wymaga żadnej konfiguracji środowiska.

W systemie Windows przejdź do interfejsu wiersza polecenia Spring Boot bin katalogu w wierszu polecenia i uruchom polecenie spring –-versionaby upewnić się, że sprężynowy interfejs CLI jest prawidłowo zainstalowany. Po wykonaniu polecenia możesz zobaczyć sprężynową wersję CLI, jak pokazano poniżej -

Uruchom Hello World z Groovym

Utwórz prosty plik groovy, który zawiera skrypt Rest Endpoint i uruchom plik groovy za pomocą Spring Boot CLI. W tym celu należy przestrzegać przedstawionego tutaj kodu -

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

Teraz zapisz groovy plik pod nazwą hello.groovy. Zwróć uwagę, że w tym przykładzie zapisaliśmy groovy plik w interfejsie wiersza polecenia Spring Bootbininformator. Teraz uruchom aplikację za pomocą poleceniaspring run hello.groovy jak pokazano na zrzucie ekranu podanym poniżej -

Po uruchomieniu pliku groovy wymagane zależności zostaną pobrane automatycznie i uruchomi aplikację na porcie Tomcat 8080, jak pokazano na zrzucie ekranu podanym poniżej -

Po uruchomieniu Tomcat przejdź do przeglądarki internetowej i naciśnij adres URL http://localhost:8080/ i możesz zobaczyć dane wyjściowe, jak pokazano.

W tym rozdziale wyjaśniono, jak wykonać ładowanie w aplikacji Spring Boot.

Spring Initializer

Jednym ze sposobów bootstrapowania aplikacji Spring Boot jest użycie Spring Initializer. Aby to zrobić, musisz odwiedzić stronę internetową Spring Initializer www.start.spring.io i wybrać kompilację, wersję Spring Boot i platformę. Ponadto musisz podać grupę, artefakt i wymagane zależności, aby uruchomić aplikację.

Przyjrzyj się poniższemu zrzutowi ekranu, który przedstawia przykład, w którym dodaliśmy spring-boot-starter-web zależność do zapisywania punktów końcowych REST.

Po podaniu grupy, artefaktu, zależności, projektu kompilacji, platformy i wersji kliknij Generate Projectprzycisk. Plik zip zostanie pobrany, a pliki zostaną wyodrębnione.

W tej sekcji wyjaśniono przykłady przy użyciu zarówno Mavena, jak i Gradle.

Maven

Po pobraniu projektu rozpakuj plik. Teraz twójpom.xml plik wygląda jak poniżej -

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

Po pobraniu projektu rozpakuj plik. Teraz twójbuild.gradle plik wygląda jak poniżej -

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

Zależności ścieżek klas

Spring Boot zapewnia szereg plików Startersaby dodać słoiki do naszej ścieżki klasowej. Na przykład, aby napisać Rest Endpoint, musimy dodaćspring-boot-starter-webzależność na naszej ścieżce klasowej. Przestrzegaj poniższych kodów, aby lepiej zrozumieć -

Zależność Mavena

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

Zależność Gradle

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

Główna metoda

Główną metodą powinno być napisanie klasy Spring Boot Application. Ta klasa powinna być opatrzona adnotacją@SpringBootApplication. To jest punkt wejścia do uruchomienia aplikacji rozruchu sprężynowego. Główny plik klas można znaleźć podsrc/java/main katalogi z pakietem domyślnym.

W tym przykładzie główny plik klasy znajduje się w src/java/main katalogi z pakietem domyślnym com.tutorialspoint.demo. Zapoznaj się z kodem pokazanym tutaj, aby lepiej zrozumieć -

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

Napisz punkt końcowy odpoczynku

Aby napisać prosty punkt końcowy Hello World Rest w głównym pliku klasy aplikacji Spring Boot Application, wykonaj kroki pokazane poniżej -

• Najpierw dodaj rozszerzenie @RestController adnotacja na górze zajęć.

• Teraz napisz metodę identyfikatora URI żądania z @RequestMapping adnotacja.

• Następnie metoda identyfikatora URI żądania powinna zwrócić plik Hello World strunowy.

Teraz twój główny plik klasy Spring Boot Application będzie wyglądał tak, jak pokazano w kodzie podanym poniżej -

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

Utwórz wykonywalny plik JAR

Utwórzmy wykonywalny plik JAR, aby uruchomić aplikację Spring Boot, używając poleceń Maven i Gradle w wierszu poleceń, jak pokazano poniżej -

Użyj polecenia Maven mvn clean install, jak pokazano poniżej -

Po wykonaniu polecenia możesz zobaczyć plik BUILD SUCCESS komunikat w wierszu polecenia, jak pokazano poniżej -

Użyj polecenia Gradle gradle clean build jak pokazano poniżej -

Po wykonaniu polecenia możesz zobaczyć plik BUILD SUCCESSFUL komunikat w wierszu polecenia, jak pokazano poniżej -

Uruchom Hello World z Javą

Po utworzeniu wykonywalnego pliku JAR można go znaleźć w następujących katalogach.

W przypadku Mavena plik JAR można znaleźć w katalogu docelowym, jak pokazano poniżej -

W przypadku Gradle plik JAR można znaleźć pod rozszerzeniem build/libs katalog, jak pokazano poniżej -

Teraz uruchom plik JAR za pomocą polecenia java –jar <JARFILE>. Zauważ, że w powyższym przykładzie plik JAR ma nazwędemo-0.0.1-SNAPSHOT.jar

Po uruchomieniu pliku jar możesz zobaczyć dane wyjściowe w oknie konsoli, jak pokazano poniżej -

Teraz spójrz na konsolę, Tomcat rozpoczął pracę na porcie 8080 (http). Teraz przejdź do przeglądarki internetowej i naciśnij adres URLhttp://localhost:8080/ i możesz zobaczyć dane wyjściowe, jak pokazano poniżej -

Korzystając z aplikacji Spring Boot, możemy stworzyć plik wojenny do wdrożenia na serwerze WWW. W tym rozdziale dowiesz się, jak utworzyć plik WAR i wdrożyć aplikację Spring Boot na serwerze WWW Tomcat.

Spring Boot Servlet Initializer

Tradycyjnym sposobem wdrażania jest tworzenie aplikacji Spring Boot @SpringBootApplication rozszerz klasę SpringBootServletInitializerklasa. Plik klasy Spring Boot Servlet Initializer umożliwia skonfigurowanie aplikacji podczas jej uruchamiania przy użyciu kontenera serwletów.

Kod dla pliku klasy aplikacji Spring Boot dla wdrożenia pliku JAR jest podany poniżej -

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

Musimy rozszerzyć klasę SpringBootServletInitializerdo obsługi wdrażania pliku WAR. Kod pliku klasy Spring Boot Application podano poniżej -

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

Ustawianie klasy głównej

W Spring Boot musimy wspomnieć o głównej klasie, która powinna rozpocząć się w pliku kompilacji. W tym celu możesz użyć następujących fragmentów kodu -

W przypadku Mavena dodaj klasę początkową w pom.xml właściwości, jak pokazano poniżej -

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

W przypadku Gradle dodaj nazwę klasy głównej do pliku build.gradle, jak pokazano poniżej -

mainClassName="com.tutorialspoint.demo.DemoApplication"

Zaktualizuj pakiet JAR do WAR

Musimy zaktualizować JAR opakowania do WAR, używając następujących fragmentów kodu -

W przypadku Mavena dodaj opakowanie jako WAR in pom.xml jak pokazano poniżej -

<packaging>war</packaging>

W przypadku Gradle dodaj wtyczkę aplikacji i wtyczkę wojny do pliku build.gradle jak pokazano poniżej -

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

Teraz napiszmy prosty punkt końcowy odpoczynku, aby zwrócić ciąg „Hello World from Tomcat”. Aby napisać punkt końcowy Rest, musimy dodać zależność startera sieci Web Spring Boot do naszego pliku kompilacji.

W przypadku Maven dodaj zależność startera Spring Boot w pom.xml, używając kodu, jak pokazano poniżej -

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

W przypadku Gradle Dodaj zależność startera Spring Boot w build.gradle używając kodu, jak pokazano poniżej -

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

Teraz napisz prosty punkt końcowy Rest w pliku klasy Spring Boot Application, używając kodu, jak pokazano poniżej -

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

Pakowanie aplikacji

Teraz utwórz plik WAR do wdrożenia na serwerze Tomcat, używając poleceń Maven i Gradle do pakowania aplikacji, jak podano poniżej -

W przypadku Mavena użyj polecenia mvn packagedo pakowania aplikacji. Następnie plik WAR zostanie utworzony i można go znaleźć w katalogu docelowym, jak pokazano na zrzutach ekranu podanych poniżej -

W przypadku Gradle użyj polecenia gradle clean builddo pakowania aplikacji. Następnie twój plik WAR zostanie utworzony i możesz go znaleźć podbuild/libsinformator. Obserwuj zrzuty ekranu podane tutaj, aby lepiej zrozumieć -

Wdróż w Tomcat

Teraz uruchom serwer Tomcat i wdróż plik WAR w webappsinformator. Obserwuj zrzuty ekranu pokazane tutaj, aby lepiej zrozumieć -

Po pomyślnym wdrożeniu kliknij adres URL w przeglądarce internetowej http://localhost:8080/demo-0.0.1-SNAPSHOT/ i zwróć uwagę, że wynik będzie wyglądał tak, jak pokazano na zrzucie ekranu podanym poniżej -

Pełny kod do tego celu znajduje się poniżej.

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

Kod głównego pliku klasy aplikacji Spring Boot jest podany poniżej -

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

W Spring Boot wybór systemu kompilacji jest ważnym zadaniem. Zalecamy Maven lub Gradle, ponieważ zapewniają dobre wsparcie w zarządzaniu zależnościami. Spring nie obsługuje dobrze innych systemów kompilacji.

Zarządzanie zależnościami

Zespół Spring Boot udostępnia listę zależności obsługujących wersję Spring Boot dla każdego wydania. Nie musisz podawać wersji dla zależności w pliku konfiguracji kompilacji. Spring Boot automatycznie konfiguruje wersję zależności na podstawie wydania. Pamiętaj, że kiedy aktualizujesz wersję Spring Boot, zależności również aktualizują się automatycznie.

Note- Jeśli chcesz określić wersję dla zależności, możesz określić ją w swoim pliku konfiguracyjnym. Jednak zespół Spring Boot zdecydowanie zaleca, aby nie trzeba określać wersji dla zależności.

Zależność Mavena

W przypadku konfiguracji Maven powinniśmy odziedziczyć projekt nadrzędny Spring Boot Starter, aby zarządzać zależnościami Spring Boot Starters. W tym celu po prostu możemy odziedziczyć rodzica starter w naszympom.xml plik, jak pokazano poniżej.

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

Powinniśmy określić numer wersji dla zależności Spring Boot Parent Starter. Wtedy dla innych zależności startera nie musimy określać numeru wersji Spring Boot. Przestrzegaj kodu podanego poniżej -

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

Zależność Gradle

Możemy importować zależności Spring Boot Starters bezpośrednio do build.gradleplik. Nie potrzebujemy zależności rodzica startu Spring Boot jak Maven dla Gradle. Przestrzegaj kodu podanego poniżej -

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

Podobnie w Gradle nie musimy określać numeru wersji Spring Boot dla zależności. Spring Boot automatycznie konfiguruje zależność na podstawie wersji.

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

Spring Boot nie ma żadnego układu kodu do pracy. Jest jednak kilka sprawdzonych metod, które mogą nam pomóc. W tym rozdziale omówiono je szczegółowo.

Pakiet domyślny

Klasa, która nie ma żadnej deklaracji pakietu, jest traktowana jako default package. Zauważ, że generalnie domyślna deklaracja pakietu nie jest zalecana. Spring Boot spowoduje problemy, takie jak nieprawidłowe działanie automatycznej konfiguracji lub skanowania składników, gdy użyjesz domyślnego pakietu.

Note- Zalecaną konwencją nazewnictwa Javy dla deklaracji pakietu jest odwrócona nazwa domeny. Na przykład -com.tutorialspoint.myproject

Typowy układ

Typowy układ aplikacji Spring Boot pokazano na poniższym obrazku -

Plik Application.java powinien zadeklarować główną metodę wraz z @SpringBootApplication. Przestrzegaj kodu podanego poniżej, aby lepiej zrozumieć -

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

W Spring Boot możemy użyć Spring Framework do zdefiniowania naszych ziaren i iniekcji ich zależności. Plik@ComponentScan adnotacja służy do wyszukiwania ziaren i odpowiadających im wstrzyknięć @Autowired adnotacja.

Jeśli zastosowałeś typowy układ Spring Boot, nie musisz określać żadnych argumentów dla @ComponentScanadnotacja. Wszystkie pliki klas komponentów są automatycznie rejestrowane w Spring Beans.

Poniższy przykład przedstawia pomysł na automatyczne podłączanie obiektu Rest Template i tworzenie Bean dla tego samego -

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

Poniższy kod przedstawia kod dla obiektu szablonu Rest z automatycznym okablowaniem i obiektu tworzenia fasoli w głównym pliku klasy aplikacji Spring Boot Application -

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

Interfejsy Application Runner i Command Line Runner umożliwiają wykonanie kodu po uruchomieniu aplikacji Spring Boot. Za pomocą tych interfejsów można wykonywać dowolne czynności natychmiast po uruchomieniu aplikacji. W tym rozdziale omówiono je szczegółowo.

Application Runner

Application Runner to interfejs używany do wykonywania kodu po uruchomieniu aplikacji Spring Boot. Poniższy przykład pokazuje, jak zaimplementować interfejs Application Runner w głównym pliku klasy.

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

Teraz, jeśli obserwujesz okno konsoli poniżej Hello World from Application Runner, instrukcja println jest wykonywana po uruchomieniu Tomcata. Czy poniższy zrzut ekranu jest odpowiedni?

Linia poleceń Runner

Command Line Runner to interfejs. Służy do wykonywania kodu po uruchomieniu aplikacji Spring Boot. Poniższy przykład pokazuje, jak zaimplementować interfejs Command Line Runner w głównym pliku klasy.

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

Spójrz na okno konsoli poniżej „Hello world from Command Line Runner” Instrukcja println jest wykonywana po uruchomieniu Tomcata.

Właściwości aplikacji pomagają nam pracować w różnych środowiskach. W tym rozdziale dowiesz się, jak skonfigurować i określić właściwości aplikacji Spring Boot.

Właściwości wiersza poleceń

Aplikacja Spring Boot konwertuje właściwości wiersza poleceń na właściwości Spring Boot Environment. Właściwości wiersza polecenia mają pierwszeństwo przed innymi źródłami właściwości. Domyślnie Spring Boot używa numeru portu 8080 do uruchomienia serwera Tomcat. Nauczmy się, jak zmienić numer portu, korzystając z właściwości wiersza poleceń.

Step 1 - Po utworzeniu wykonywalnego pliku JAR uruchom go za pomocą polecenia java –jar <JARFILE>.

Step 2 - Użyj polecenia podanego na zrzucie ekranu podanym poniżej, aby zmienić numer portu dla aplikacji Spring Boot za pomocą właściwości wiersza poleceń.

Note - Możesz podać więcej niż jedną właściwości aplikacji, używając separatora -.

Plik właściwości

Pliki właściwości służą do zachowania liczby „N” właściwości w jednym pliku w celu uruchomienia aplikacji w innym środowisku. W Spring Boot właściwości są przechowywane wapplication.properties plik w ścieżce klas.

Plik application.properties znajduje się w katalogu src/main/resourcesinformator. Kod przykładowyapplication.properties plik jest podany poniżej -

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

Zauważ, że w kodzie pokazanym powyżej usługa demo aplikacji Spring Boot uruchamia się na porcie 9090.

Plik YAML

Spring Boot obsługuje konfiguracje właściwości oparte na YAML do uruchamiania aplikacji. Zamiastapplication.properties, możemy użyć application.ymlplik. Ten plik YAML również powinien być przechowywany w ścieżce klas. Próbkaapplication.yml plik jest podany poniżej -

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

Właściwości eksternalizowane

Zamiast trzymać plik właściwości w ścieżce klas, możemy przechowywać właściwości w innej lokalizacji lub ścieżce. Podczas uruchamiania pliku JAR możemy określić ścieżkę do pliku właściwości. Możesz użyć następującego polecenia, aby określić lokalizację pliku właściwości podczas uruchamiania pliku JAR -

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

Korzystanie z adnotacji @Value

Adnotacja @Value służy do odczytywania wartości właściwości środowiska lub aplikacji w kodzie Java. Składnia służąca do odczytywania wartości właściwości jest pokazana poniżej -

@Value("${property_key_name}")

Spójrz na poniższy przykład, który przedstawia składnię odczytu spring.application.name wartość właściwości w zmiennej Java przy użyciu adnotacji @Value.

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

Przestrzegaj kodu podanego poniżej, aby lepiej zrozumieć -

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 - Jeśli właściwość nie zostanie znaleziona podczas uruchamiania aplikacji, Spring Boot zgłasza wyjątek Illegal Argument as Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}".

Aby rozwiązać problem z symbolem zastępczym, możemy ustawić domyślną wartość właściwości za pomocą składni thr podanej poniżej -

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

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

Profil aktywny podczas rozruchu sprężynowego

Spring Boot obsługuje różne właściwości w oparciu o aktywny profil Spring. Na przykład, możemy zachować dwa oddzielne pliki na potrzeby programowania i produkcji, aby uruchomić aplikację Spring Boot.

Sprężynowy profil aktywny w application.properties

Pozwól nam zrozumieć, jak mieć aktywny profil Spring w application.properties. Domyślnie application. właściwości zostaną użyte do uruchomienia aplikacji Spring Boot. Jeśli chcesz korzystać z właściwości opartych na profilu, możemy zachować osobny plik właściwości dla każdego profilu, jak pokazano poniżej -

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

Podczas uruchamiania pliku JAR musimy określić aktywny profil sprężyny na podstawie każdego pliku właściwości. Domyślnie aplikacja Spring Boot korzysta z pliku application.properties. Polecenie ustawienia aktywnego profilu sprężyny pokazano poniżej -

Możesz zobaczyć nazwę aktywnego profilu w dzienniku konsoli, jak pokazano poniżej -

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

Teraz Tomcat uruchomił się na porcie 9090 (http), jak pokazano poniżej -

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

Możesz ustawić aktywny profil produkcyjny, jak pokazano poniżej -

Możesz zobaczyć nazwę aktywnego profilu w dzienniku konsoli, jak pokazano poniżej -

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

Teraz Tomcat wystartował na porcie 4431 (http), jak pokazano poniżej -

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

Profil sprężynujący do application.yml

Pozwól nam zrozumieć, jak zachować aktywny profil Spring dla application.yml. Możemy zachować właściwości aktywnego profilu Spring w pojedynczymapplication.ymlplik. Nie ma potrzeby używania oddzielnego pliku, takiego jak application.properties.

Poniżej znajduje się przykładowy kod, który utrzymuje aktywne profile Spring w pliku application.yml. Zauważ, że separator (---) jest używany do oddzielania każdego profilu w pliku application.yml.

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

Polecenie do ustawienia aktywnego profilu rozwoju jest podane poniżej -

Możesz zobaczyć nazwę aktywnego profilu w dzienniku konsoli, jak pokazano poniżej -

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

Teraz Tomcat wystartował na porcie 9090 (http), jak pokazano poniżej -

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

Polecenie do ustawienia aktywnego profilu produkcji podano poniżej -

Możesz zobaczyć nazwę aktywnego profilu w dzienniku konsoli, jak pokazano poniżej -

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

Spowoduje to uruchomienie Tomcata na porcie 4431 (http), jak pokazano poniżej:

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 używa rejestrowania Apache Commons do wszystkich wewnętrznych rejestrów. Domyślne konfiguracje Spring Boot zapewniają obsługę funkcji Java Util Logging, Log4j2 i Logback. Korzystając z nich, możemy skonfigurować rejestrowanie konsoli, a także rejestrowanie plików.

Jeśli używasz Spring Boot Starters, Logback zapewni dobrą obsługę logowania. Poza tym Logback zapewnia również dobre wsparcie dla Common Logging, Util Logging, Log4J i SLF4J.

Format dziennika

Domyślny format Spring Boot Log pokazano na zrzucie ekranu podanym poniżej.

który zawiera następujące informacje -

• Date i Time który podaje datę i godzinę dziennika

• Log level wyświetla INFO, ERROR lub WARN

• Process ID

• --- który jest separatorem

• Thread name jest ujęta w nawiasy kwadratowe []

• Logger Name który pokazuje nazwę klasy źródłowej

• Komunikat dziennika

Wyjście dziennika konsoli

Domyślne komunikaty dziennika zostaną wydrukowane w oknie konsoli. Domyślnie komunikaty dziennika „INFO”, „ERROR” i „WARN” są drukowane w pliku dziennika.

Jeśli musisz włączyć dziennik poziomu debugowania, dodaj flagę debugowania podczas uruchamiania aplikacji za pomocą polecenia pokazanego poniżej -

java –jar demo.jar --debug

Możesz również dodać tryb debugowania do pliku application.properties, jak pokazano tutaj -

debug = true

Plik wyjściowy dziennika

Domyślnie wszystkie dzienniki będą drukowane w oknie konsoli, a nie w plikach. Jeśli chcesz wydrukować dzienniki w pliku, musisz ustawić właściwośćlogging.file lub logging.path w pliku application.properties.

Możesz określić ścieżkę do pliku dziennika, korzystając z właściwości pokazanej poniżej. Zwróć uwagę, że nazwa pliku dziennika to spring.log.

logging.path = /var/tmp/

Możesz określić własną nazwę pliku dziennika, korzystając z właściwości pokazanej poniżej -

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

Note - pliki będą się obracać automatycznie po osiągnięciu rozmiaru 10 MB.

Log Levels

Spring Boot obsługuje wszystkie poziomy rejestratorów, takie jak „TRACE”, „DEBUG”, „INFO”, „WARN”, „ERROR”, „FATAL”, „OFF”. Możesz zdefiniować główny rejestrator w pliku application.properties, jak pokazano poniżej -

logging.level.root = WARN

Note- Logback nie obsługuje dziennika poziomu „FATAL”. Jest odwzorowany na dzienniku poziomu „ERROR”.

Skonfiguruj wylogowanie

Logback obsługuje konfigurację opartą na XML do obsługi konfiguracji Spring Boot Log. Szczegóły konfiguracji logowania są konfigurowane wlogback.xmlplik. Plik logback.xml należy umieścić pod ścieżką klas.

Możesz skonfigurować poziom logowania na poziomie ROOT w pliku Logback.xml za pomocą kodu podanego poniżej -

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

Możesz skonfigurować appender konsoli w pliku Logback.xml podanym poniżej.

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

Możesz skonfigurować program dołączający plik w pliku Logback.xml, używając kodu podanego poniżej. Zauważ, że musisz określić ścieżkę do pliku dziennika w programie dołączającym plik.

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

Możesz zdefiniować wzorzec logowania w logback.xmlplik przy użyciu kodu podanego poniżej. Możesz również zdefiniować zestaw obsługiwanych wzorców dziennika wewnątrz konsoli lub programu dołączającego dziennik plików, używając kodu podanego poniżej -

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

Kod pełnego pliku logback.xml znajduje się poniżej. Musisz to umieścić w ścieżce klasowej.

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

Poniższy kod pokazuje, jak dodać rejestrator slf4j w głównym pliku klasy Spring Boot.

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

Dane wyjściowe, które możesz zobaczyć w oknie konsoli, są pokazane tutaj -

Dane wyjściowe, które można zobaczyć w pliku dziennika, są pokazane tutaj -

Spring Boot zapewnia bardzo dobrą obsługę tworzenia RESTful Web Services dla aplikacji korporacyjnych. W tym rozdziale wyjaśniono szczegółowo tworzenie usług internetowych zgodnych z REST przy użyciu Spring Boot.

Note - Aby zbudować RESTful Web Services, musimy dodać zależność Spring Boot Starter Web do pliku konfiguracyjnego kompilacji.

Jeśli jesteś użytkownikiem Maven, użyj poniższego kodu, aby dodać poniższą zależność w pliku pom.xml plik -

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

Jeśli jesteś użytkownikiem Gradle, użyj poniższego kodu, aby dodać poniższą zależność w pliku build.gradle plik.

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

Kod pełnego pliku konfiguracji kompilacji Maven build – pom.xml podano poniżej -

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

Kod pełnego pliku konfiguracji kompilacji Gradle Build – build.gradle podano poniżej -

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

Przed przystąpieniem do tworzenia usługi internetowej zgodnej ze standardem REST zaleca się zapoznanie się z następującymi adnotacjami -

Rest Controller

Adnotacja @RestController służy do definiowania usług internetowych RESTful. Obsługuje JSON, XML i niestandardową odpowiedź. Jego składnię przedstawiono poniżej -

@RestController
public class ProductServiceController { 
}

Poproś o mapowanie

Adnotacja @RequestMapping służy do definiowania identyfikatora URI żądania w celu uzyskania dostępu do punktów końcowych REST. Możemy zdefiniować metodę Request, aby konsumować i produkować obiekt. Domyślną metodą żądania jest GET.

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

Treść żądania

Adnotacja @RequestBody służy do definiowania typu treści żądania.

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

Zmienna ścieżki

Adnotacja @PathVariable służy do definiowania niestandardowego lub dynamicznego identyfikatora URI żądania. Zmienna Path w identyfikatorze URI żądania jest zdefiniowana jako nawiasy klamrowe {}, jak pokazano poniżej -

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

Poproś o parametr

Adnotacja @RequestParam służy do odczytywania parametrów żądania z adresu URL żądania. Domyślnie jest to parametr wymagany. Możemy również ustawić wartość domyślną parametrów żądania, jak pokazano tutaj -

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

POBIERZ API

Domyślną metodą żądania HTTP jest GET. Ta metoda nie wymaga żadnej treści żądania. Możesz wysłać parametry żądania i zmienne ścieżki, aby zdefiniować niestandardowy lub dynamiczny adres URL.

Przykładowy kod definiujący metodę żądania HTTP GET przedstawiono poniżej. W tym przykładzie użyliśmy HashMap do przechowywania produktu. Zauważ, że użyliśmy klasy POJO jako produktu do przechowywania.

Tutaj identyfikator URI żądania to /productsi zwróci listę produktów z repozytorium HashMap. Plik klasy kontrolera jest podany poniżej, który zawiera metodę GET 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

Żądanie HTTP POST służy do tworzenia zasobu. Ta metoda zawiera treść żądania. Możemy wysłać parametry żądania i zmienne ścieżki, aby zdefiniować niestandardowy lub dynamiczny adres URL.

Poniższy przykład przedstawia przykładowy kod definiujący metodę żądania HTTP POST. W tym przykładzie użyliśmy HashMap do przechowywania produktu, gdzie produkt jest klasą POJO.

Tutaj identyfikator URI żądania to /products, i zwróci String po zapisaniu produktu w repozytorium HashMap.

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

Żądanie HTTP PUT służy do aktualizacji istniejącego zasobu. Ta metoda zawiera treść żądania. Możemy wysłać parametry żądania i zmienne ścieżki, aby zdefiniować niestandardowy lub dynamiczny adres URL.

Poniższy przykład pokazuje, jak zdefiniować metodę żądania HTTP PUT. W tym przykładzie użyliśmy HashMap do zaktualizowania istniejącego produktu, w którym produkt jest klasą POJO.

Tutaj jest identyfikator URI żądania /products/{id}co zwróci ciąg znaków po produkcie do repozytorium HashMap. Zauważ, że użyliśmy zmiennej Path{id} który określa identyfikator produktu, który należy zaktualizować.

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

USUŃ API

Żądanie HTTP Delete służy do usunięcia istniejącego zasobu. Ta metoda nie zawiera treści żądania. Możemy wysłać parametry żądania i zmienne ścieżki, aby zdefiniować niestandardowy lub dynamiczny adres URL.

Poniższy przykład pokazuje, jak zdefiniować metodę żądania HTTP DELETE. W tym przykładzie użyliśmy HashMap do usunięcia istniejącego produktu, którym jest klasa POJO.

Identyfikator URI żądania to /products/{id}i zwróci String po usunięciu produktu z repozytorium HashMap. Użyliśmy zmiennej Path{id} który określa identyfikator produktu, który należy usunąć.

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

Ta sekcja zawiera pełny zestaw kodu źródłowego. Przestrzegaj następujących kodów dotyczących ich funkcji -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację rozruchu sprężynowego za pomocą poniższych poleceń Maven lub Gradle, jak pokazano -

W przypadku Mavena użyj polecenia pokazanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia pokazanego poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Możesz uruchomić plik JAR za pomocą polecenia pokazanego poniżej -

java –jar <JARFILE>

Spowoduje to uruchomienie aplikacji na porcie Tomcat 8080, jak pokazano poniżej -

Teraz naciśnij adres URL pokazany poniżej w aplikacji POSTMAN i zobacz dane wyjściowe.

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

URL interfejsu POST API to: http://localhost:8080/products

URL PUT API to: http://localhost:8080/products/3

URL USUŃ API to: http://localhost:8080/products/3

Obsługa wyjątków i błędów w interfejsach API oraz wysyłanie właściwej odpowiedzi do klienta jest dobre dla aplikacji korporacyjnych. W tym rozdziale dowiemy się, jak obsługiwać wyjątki w Spring Boot.

Zanim przejdziemy do obsługi wyjątków, zapoznajmy się z następującymi adnotacjami.

Porady dotyczące kontrolera

@ControllerAdvice to adnotacja do obsługi wyjątków globalnie.

Obsługa wyjątków

@ExceptionHandler to adnotacja używana do obsługi określonych wyjątków i wysyłania niestandardowych odpowiedzi do klienta.

Możesz użyć następującego kodu, aby utworzyć klasę @ControllerAdvice do obsługi wyjątków globalnie -

package com.tutorialspoint.demo.exception;

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

@ControllerAdvice
   public class ProductExceptionController {
}

Zdefiniuj klasę, która rozszerza klasę RuntimeException.

package com.tutorialspoint.demo.exception;

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

Możesz zdefiniować metodę @ExceptionHandler do obsługi wyjątków, jak pokazano. Ta metoda powinna być używana do pisania pliku klasy Controller Advice.

@ExceptionHandler(value = ProductNotfoundException.class)

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

Teraz użyj kodu podanego poniżej, aby zgłosić wyjątek z interfejsu API.

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

Pełny kod do obsługi wyjątku znajduje się poniżej. W tym przykładzie użyliśmy PUT API do aktualizacji produktu. Tutaj, podczas aktualizacji produktu, jeśli produkt nie zostanie znaleziony, zwróć komunikat o błędzie odpowiedzi jako „Nie znaleziono produktu”. Zwróć uwagę, żeProductNotFoundException klasa wyjątku powinna rozszerzać RuntimeException.

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

Klasa Controller Advice do globalnej obsługi wyjątku jest podana poniżej. W tym pliku klasy możemy zdefiniować dowolne metody obsługi wyjątków.

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

Plik kontrolera Product Service API jest podany poniżej w celu aktualizacji Produktu. Jeśli produkt nie zostanie znaleziony, wyrzuca plikProductNotFoundException klasa.

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

Kod głównego pliku klasy aplikacji Spring Boot jest podany poniżej -

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

Kod dla POJO class dla produktu podano poniżej -

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

Kod dla Maven build – pom.xml pokazano poniżej -

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

Kod dla Gradle Build – build.gradle podano poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle -

W przypadku Mavena możesz użyć następującego polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć następującego polecenia -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Możesz uruchomić plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Spowoduje to uruchomienie aplikacji na porcie Tomcat 8080, jak pokazano poniżej -

Teraz naciśnij poniższy adres URL w aplikacji POSTMAN i możesz zobaczyć dane wyjściowe, jak pokazano poniżej -

Zaktualizuj adres URL: http: // localhost: 8080 / products / 3

Możesz użyć Interceptora w Spring Boot do wykonywania operacji w następujących sytuacjach:

• Przed wysłaniem żądania do administratora

• Przed wysłaniem odpowiedzi do klienta

Na przykład można użyć przechwytywacza, aby dodać nagłówek żądania przed wysłaniem żądania do kontrolera i dodać nagłówek odpowiedzi przed wysłaniem odpowiedzi do klienta.

Aby pracować z przechwytywaczem, musisz stworzyć @Component obsługującą ją i powinien implementować HandlerInterceptor berło.

Oto trzy metody, o których powinieneś wiedzieć podczas pracy nad przechwytywaczami:

• preHandle()metoda - służy do wykonywania operacji przed wysłaniem żądania do kontrolera. Ta metoda powinna zwrócić wartość true, aby zwrócić odpowiedź do klienta.

• postHandle() metoda - służy do wykonywania operacji przed wysłaniem odpowiedzi do klienta.

• afterCompletion() metoda - służy do wykonywania operacji po zakończeniu żądania i odpowiedzi.

Obserwuj następujący kod, aby lepiej zrozumieć -

@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 {}
}

Będziesz musiał zarejestrować ten Interceptor w InterceptorRegistry używając WebMvcConfigurerAdapter jak pokazano poniżej -

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

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

W przykładzie podanym poniżej trafimy do API produktów GET, które daje dane wyjściowe podane w -

Kod klasy Interceptor ProductServiceInterceptor.java podano poniżej -

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

Kod dla pliku klasy konfiguracji aplikacji służący do rejestracji modułu przechwytującego w rejestrze modułu przechwytującego - ProductServiceInterceptorAppConfig.java jest podany poniżej -

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

Kod dla pliku klasy kontrolera ProductServiceController.java podano poniżej -

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

Kod klasy POJO dla Product.java podano poniżej -

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

Kod głównego pliku klasy aplikacji Spring Boot DemoApplication.java podano poniżej -

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

Kod kompilacji Maven - pom.xml jest pokazany tutaj -

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

Kod dla Gradle Build build.gradle jest pokazany tutaj -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poniższych poleceń Maven lub Gradle.

W przypadku Mavena użyj polecenia, jak pokazano poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia, jak pokazano poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Możesz uruchomić plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080, jak pokazano poniżej -

Teraz naciśnij poniższy adres URL w aplikacji POSTMAN i możesz zobaczyć dane wyjściowe, jak pokazano w -

POBIERZ API: http://localhost:8080/products

W oknie konsoli możesz zobaczyć instrukcje System.out.println dodane do przechwytywacza, jak pokazano na zrzucie ekranu podanym poniżej -

Filtr to obiekt używany do przechwytywania żądań HTTP i odpowiedzi aplikacji. Korzystając z filtru, możemy wykonać dwie operacje w dwóch instancjach -

• Przed wysłaniem żądania do administratora
• Przed wysłaniem odpowiedzi do klienta.

Poniższy kod przedstawia przykładowy kod klasy implementacji Servlet Filter z adnotacją @Component.

@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 {}
}

Poniższy przykład przedstawia kod służący do odczytu zdalnego hosta i zdalnego adresu z obiektu ServletRequest przed wysłaniem żądania do kontrolera.

W metodzie doFilter () dodaliśmy instrukcje System.out.println do drukowania zdalnego hosta i adresu zdalnego.

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

W głównym pliku klasy aplikacji Spring Boot dodaliśmy prosty punkt końcowy REST, który zwraca ciąg „Hello World”.

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

Kod kompilacji Maven - pom.xml podano poniżej -

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

Kod dla Gradle Build - build.gradle jest podany poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle pokazanych poniżej -

W przypadku Mavena użyj polecenia, jak pokazano poniżej -

mvn clean install

Po BUDOWIE SUKCESU można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia, jak pokazano poniżej -

gradle clean build

Po zakończeniu kompilacji plik JAR można znaleźć w katalogu build / libs.

Teraz uruchom plik JAR za pomocą następującego polecenia

java –jar <JARFILE>

Możesz zobaczyć, że aplikacja została uruchomiona na porcie Tomcat 8080.

Teraz kliknij adres URL http://localhost:8080/i zobacz dane wyjściowe Hello World. Powinien wyglądać tak, jak pokazano poniżej -

Następnie możesz zobaczyć zdalny host i zdalny adres w dzienniku konsoli, jak pokazano poniżej -

Spring Boot umożliwia uruchomienie tej samej aplikacji więcej niż raz na innym porcie. W tym rozdziale dowiesz się o tym szczegółowo. Zwróć uwagę, że domyślny numer portu 8080.

Port niestandardowy

w application.properties możemy ustawić niestandardowy numer portu dla właściwości server.port

server.port = 9090

w application.yml plik, można znaleźć w następujący sposób -

server: 
   port: 9090

Losowy port

w application.properties możemy ustawić losowy numer portu dla właściwości server.port

server.port = 0

w application.yml plik, można znaleźć w następujący sposób -

server: 
   port: 0

Note - Jeśli server.port number to 0 podczas uruchamiania aplikacji Spring Boot, Tomcat używa losowego numeru portu.

Szablon REST służy do tworzenia aplikacji korzystających z usług WWW zgodnych z REST. Możesz użyćexchange()metoda korzystania z usług sieci Web dla wszystkich metod HTTP. Kod podany poniżej pokazuje, jak utworzyć szablon Bean for Rest, aby automatycznie połączyć obiekt Rest Template.

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

DOSTAĆ

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

Przyjmij ten adres URL http://localhost:8080/products zwraca następujący kod JSON i zamierzamy korzystać z tej odpowiedzi interfejsu API przy użyciu szablonu Rest przy użyciu następującego kodu -

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

Będziesz musiał postępować zgodnie z podanymi punktami, aby korzystać z API -

• Autowired the Rest Template Object.
• Użyj HttpHeaders, aby ustawić nagłówki żądań.
• Użyj HttpEntity, aby zawinąć obiekt żądania.
• Podaj adres URL, HttpMethod i typ zwrotu dla metody Exchange ().

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

POCZTA

Consuming POST API by using RestTemplate - exchange() method

Przyjmij ten adres URL http://localhost:8080/products zwraca odpowiedź pokazaną poniżej, będziemy używać tej odpowiedzi API przy użyciu szablonu Rest.

Kod podany poniżej to treść żądania -

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

Kod podany poniżej to treść odpowiedzi -

Product is created successfully

Będziesz musiał postępować zgodnie z poniższymi punktami, aby korzystać z API -

• Autowired the Rest Template Object.

• Użyj HttpHeaders, aby ustawić nagłówki żądań.

• Użyj HttpEntity, aby zawinąć obiekt żądania. Tutaj zawijamy obiekt Product, aby wysłać go do treści żądania.

• Podaj adres URL, HttpMethod i typ zwrotu dla metody exchange ().

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

POŁOŻYĆ

Consuming PUT API by using RestTemplate - exchange() method

Przyjmij ten adres URL http://localhost:8080/products/3 zwraca poniższą odpowiedź i będziemy korzystać z tej odpowiedzi API przy użyciu szablonu Rest.

Kod podany poniżej to treść żądania -

{
   "name":"Indian Ginger"
}

Kod podany poniżej to treść odpowiedzi -

Product is updated successfully

Będziesz musiał postępować zgodnie z poniższymi punktami, aby korzystać z API -

• Autowired the Rest Template Object.

• Użyj HttpHeaders, aby ustawić nagłówki żądań.

• Użyj HttpEntity, aby zawinąć obiekt żądania. Tutaj zawijamy obiekt Product, aby wysłać go do treści żądania.

• Podaj adres URL, HttpMethod i typ zwrotu dla metody exchange ().

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

USUNĄĆ

Consuming DELETE API by using RestTemplate - exchange() method

Przyjmij ten adres URL http://localhost:8080/products/3 zwraca odpowiedź podaną poniżej i będziemy korzystać z tej odpowiedzi API przy użyciu szablonu Rest.

Ten wiersz kodu pokazany poniżej to treść odpowiedzi -

Product is deleted successfully

Aby korzystać z interfejsu API, musisz postępować zgodnie z poniższymi punktami -

• Autowired the Rest Template Object.

• Użyj HttpHeaders, aby ustawić nagłówki żądań.

• Użyj HttpEntity, aby zawinąć obiekt żądania.

• Podaj adres URL, HttpMethod i typ zwrotu dla metody exchange ().

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

Pełny plik klasy Rest Template Controller znajduje się poniżej -

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

Kod dla Spring Boot Application Class - DemoApplication.java jest podany poniżej -

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

Kod kompilacji Maven - pom.xml jest podany poniżej -

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

Kod dla Gradle Build - build.gradle jest podany poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena możesz użyć polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia pokazanego poniżej -

gradle clean build

Po komunikacie „BUILD SUCCESSFUL” można znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080.

Teraz naciśnij poniższe adresy URL w aplikacji POSTMAN i zobaczysz wynik.

Pobierz produkty według szablonu odpoczynku - http://localhost:8080/template/products

Utwórz produkty POST - http://localhost:8080/template/products

Zaktualizuj PUT produktu - http://localhost:8080/template/products/3

Usuń produkt - http://localhost:8080/template/products/3

W tym rozdziale dowiesz się, jak załadować i pobrać plik za pomocą usługi sieciowej.

Udostępnianie pliku

Aby przesłać plik, możesz użyć MultipartFilejako parametr żądania, a ten interfejs API powinien wykorzystywać wartość danych formularza wieloczęściowego. Przestrzegaj kodu podanego poniżej -

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

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

Pełny kod tego samego znajduje się poniżej -

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

Pobieranie pliku

Aby pobrać plik, należy użyć InputStreamResource do pobrania pliku. Musimy ustawić HttpHeaderContent-Disposition w odpowiedzi i należy określić typ nośnika odpowiedzi aplikacji.

Note - W poniższym przykładzie plik powinien być dostępny w określonej ścieżce, w której działa aplikacja.

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

Pełny kod tego samego znajduje się poniżej -

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

Główna aplikacja Spring Boot jest podana poniżej -

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

Kod kompilacji Maven - pom.xml jest podany poniżej -

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

Kod dla Gradle Build - build.gradle jest podany poniżej -

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

Teraz możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle podanych poniżej -

W przypadku Mavena użyj polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia pokazanego poniżej -

sgradle clean build

Po komunikacie „BUILD SUCCESSFUL” można znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Spowoduje to uruchomienie aplikacji na porcie Tomcat 8080, jak pokazano poniżej -

Teraz naciśnij poniższe adresy URL w aplikacji POSTMAN i zobaczysz dane wyjściowe, jak pokazano poniżej -

Przesyłanie pliku - http://localhost:8080/upload

Pobieranie pliku - http://localhost:8080/upload

Składniki usługi to plik klasy zawierający adnotację @Service. Te pliki klas są używane do zapisywania logiki biznesowej w innej warstwie, oddzielonej od pliku klasy @RestController. Logika tworzenia pliku klasy komponentu usługi jest pokazana tutaj -

public interface ProductService {
}

Klasa implementująca interfejs z adnotacją @Service jest taka, jak pokazano -

@Service
public class ProductServiceImpl implements ProductService {
}

Zauważ, że w tym samouczku używamy Product Service API(s)do przechowywania, pobierania, aktualizowania i usuwania produktów. Logikę biznesową napisaliśmy w samym pliku klasy @RestController. Teraz zamierzamy przenieść kod logiki biznesowej ze sterownika do komponentu usługi.

Możesz utworzyć interfejs, który zawiera dodawanie, edytowanie, pobieranie i usuwanie metod za pomocą kodu, jak pokazano poniżej -

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

Poniższy kod umożliwia utworzenie klasy, która implementuje interfejs ProductService z adnotacją @Service i zapisuje logikę biznesową do przechowywania, pobierania, usuwania i aktualizowania produktu.

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

Kod tutaj pokazuje plik klasy Rest Controller, tutaj @Autowired interfejs ProductService i wywołaliśmy metody.

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

Kod klasy POJO - Product.java jest pokazany tutaj -

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

Poniżej przedstawiono główną aplikację Spring Boot -

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

Kod kompilacji Mavena - pom.xml pokazano poniżej -

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

Kod dla Gradle Build - build.gradle pokazano poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle podanych poniżej -

W przypadku Mavena użyj polecenia, jak pokazano poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia, jak pokazano poniżej -

gradle clean build

Po komunikacie „BUILD SUCCESSFUL” można znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR za pomocą polecenia podanego poniżej -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080, jak pokazano na poniższym obrazku -

Teraz naciśnij poniższe adresy URL w aplikacji POSTMAN i zobaczysz dane wyjściowe, jak pokazano poniżej -

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

URL interfejsu POST API to - http://localhost:8080/products

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

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

Thymeleaf to oparta na Javie biblioteka używana do tworzenia aplikacji internetowych. Zapewnia dobre wsparcie dla obsługi XHTML / HTML5 w aplikacjach internetowych. W tym rozdziale dowiesz się szczegółowo o grasicy.

Szablony tymianek

Thymeleaf konwertuje twoje pliki do dobrze sformatowanych plików XML. Zawiera 6 rodzajów szablonów, jak podano poniżej -

• XML
• Prawidłowy plik XML
• XHTML
• Prawidłowy XHTML
• HTML5
• Starsza wersja HTML5

Wszystkie szablony, z wyjątkiem starszej wersji HTML5, odwołują się do poprawnie sformułowanych, prawidłowych plików XML. Starsza wersja HTML5 umożliwia nam renderowanie tagów HTML5 na stronie internetowej, w tym tagów niezamkniętych.

Aplikacja internetowa

Możesz użyć szablonów Thymeleaf do stworzenia aplikacji internetowej w Spring Boot. Będziesz musiał wykonać poniższe kroki, aby utworzyć aplikację internetową w Spring Boot za pomocą Thymeleaf.

Użyj poniższego kodu, aby utworzyć plik klasy @Controller w celu przekierowania identyfikatora URI żądania do pliku HTML -

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

W powyższym przykładzie identyfikator URI żądania to /index, a formant jest przekierowywany do pliku index.html. Zauważ, że plik index.html powinien być umieszczony w katalogu szablonów, a wszystkie pliki JS i CSS w katalogu statycznym w ścieżce klas. W pokazanym przykładzie użyliśmy pliku CSS do zmiany koloru tekstu.

Możesz użyć następującego kodu i utworzyć plik CSS w oddzielnym folderze css i nazwij plik style.css -

h4 {
   color: red;
}

Kod pliku index.html jest podany poniżej -

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

Eksplorator projektu pokazano na zrzucie ekranu podanym poniżej -

Teraz musimy dodać zależność Spring Boot Starter Thymeleaf w naszym pliku konfiguracyjnym kompilacji.

Użytkownicy Maven mogą dodać następującą zależność do pliku pom.xml -

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle -

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

Kod głównego pliku klasy aplikacji Spring Boot jest podany poniżej -

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

Kod dla Maven - pom.xml podano poniżej -

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

Kod dla Gradle - build.gradle jest podany poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację rozruchu sprężynowego za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena użyj polecenia, jak pokazano poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia, jak pokazano poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR, używając polecenia podanego tutaj -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080, jak pokazano poniżej -

Teraz naciśnij adres URL w przeglądarce internetowej i zobaczysz dane wyjściowe, jak pokazano -

http://localhost:8080/index

W tym rozdziale omówiono szczegółowo korzystanie z usług WWW zgodnych ze specyfikacją REST przy użyciu jQuery AJAX.

Utwórz prostą aplikację internetową Spring Boot i napisz pliki klasy kontrolera, które są używane do przekierowań do pliku HTML w celu wykorzystania usług sieciowych RESTful.

Musimy dodać starter Spring Boot Thymeleaf i zależność sieciową w naszym pliku konfiguracyjnym kompilacji.

W przypadku użytkowników Maven dodaj poniższe zależności w pliku pom.xml.

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

W przypadku użytkowników Gradle dodaj poniższe zależności do pliku build.gradle -

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

Kod pliku klasy @Controller jest podany poniżej -

@Controller
public class ViewController {
}

Możesz zdefiniować metody identyfikatora URI żądania, aby przekierować do pliku HTML, jak pokazano poniżej -

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

Ten interfejs API http://localhost:9090/products powinien zwrócić poniższy kod JSON w odpowiedzi, jak pokazano poniżej -

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

Teraz utwórz plik view-products.html w katalogu szablonów w ścieżce klas.

W pliku HTML dodaliśmy bibliotekę jQuery i napisaliśmy kod, który zużywa usługę sieciową RESTful podczas ładowania strony.

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

Metoda POST i ten adres URL http://localhost:9090/products powinien zawierać poniższą treść żądania i odpowiedzi.

Kod treści żądania jest podany poniżej -

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

Kod treści odpowiedzi podano poniżej -

Product is created successfully

Teraz utwórz plik add-products.html w katalogu szablonów w ścieżce klas.

W pliku HTML dodaliśmy bibliotekę jQuery i napisaliśmy kod, który przesyła formularz do serwisu internetowego RESTful po kliknięciu przycisku.

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

Pełny kod podano poniżej.

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

Kod dla Gradle - build.gradle jest podany poniżej -

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

Plik klasy kontrolera podany poniżej - ViewController.java jest podany poniżej -

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

Plik view-products.html znajduje się poniżej -

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

Plik add-products.html znajduje się poniżej -

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

Główny plik klasy aplikacji Spring Boot Application znajduje się poniżej -

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

Teraz możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena użyj polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia podanego poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080.

Teraz naciśnij adres URL w przeglądarce internetowej i zobaczysz dane wyjściowe, jak pokazano -

http: // localhost: 8080 / view-products

http: // localhost: 8080 / add-products

Teraz kliknij przycisk Click here to submit the form i możesz zobaczyć wynik, jak pokazano -

Teraz kliknij URL widoku produktów i zobacz utworzony produkt.

http://localhost:8080/view-products

Angular JS

Aby korzystać z interfejsów API przy użyciu Angular JS, możesz użyć poniższych przykładów -

Użyj poniższego kodu, aby utworzyć kontroler Angular JS do korzystania z interfejsu API GET - 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;
   });
});

Użyj poniższego kodu, aby utworzyć kontroler Angular JS do korzystania z interfejsu API POST - 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 - Dane metody Post reprezentują treść żądania w formacie JSON w celu utworzenia produktu.

Współdzielenie zasobów między źródłami (CORS) to koncepcja bezpieczeństwa, która pozwala na ograniczenie zasobów zaimplementowanych w przeglądarkach internetowych. Zapobiega generowaniu lub wykorzystywaniu żądań przez kod JavaScript z innego źródła.

Na przykład Twoja aplikacja internetowa działa na porcie 8080 i używając JavaScript próbujesz korzystać z usług sieciowych RESTful z portu 9090. W takich sytuacjach napotkasz problem bezpieczeństwa współdzielenia zasobów między źródłami w swoich przeglądarkach internetowych.

Do rozwiązania tego problemu potrzebne są dwa wymagania -

• Usługi sieciowe RESTful powinny obsługiwać współdzielenie zasobów między źródłami.

• Aplikacja usługi WWW zgodna ze standardem REST powinna umożliwiać dostęp do interfejsów API z portu 8080.

W tym rozdziale dowiemy się szczegółowo, jak włączyć żądania cross-Origin dla aplikacji usługi sieci Web zgodnej z REST.

Włącz CORS w metodzie kontrolera

Musimy ustawić źródła usługi sieci Web RESTful przy użyciu @CrossOriginadnotacja dotycząca metody kontrolera. Ta adnotacja @CrossOrigin obsługuje określony interfejs API REST, a nie całą aplikację.

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

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

Globalna konfiguracja CORS

Musimy zdefiniować pokazaną konfigurację @Bean, aby ustawić obsługę konfiguracji CORS globalnie dla Twojej aplikacji Spring Boot.

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

Kod umożliwiający globalne ustawienie konfiguracji CORS w głównej aplikacji Spring Boot jest podany poniżej.

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

Teraz możesz utworzyć aplikację internetową Spring Boot działającą na porcie 8080 oraz aplikację internetową RESTful, która może działać na porcie 9090. Więcej informacji na temat implementacji usługi WWW zgodnej ze standardem REST można znaleźć w rozdziale zatytułowanymConsuming RESTful Web Services tego samouczka.

Umiędzynarodowienie to proces, który umożliwia dostosowanie aplikacji do różnych języków i regionów bez wprowadzania zmian inżynieryjnych w kodzie źródłowym. Krótko mówiąc, umiędzynarodowienie to gotowość do lokalizacji.

W tym rozdziale dowiemy się szczegółowo, jak wdrożyć internacjonalizację w Spring Boot.

Zależności

Potrzebujemy zależności Spring Boot Starter Web i Spring Boot Starter Thymeleaf, aby opracować aplikację internetową w Spring Boot.

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

Musimy określić domyślne ustawienia regionalne Twojej aplikacji. Musimy dodać komponent bean LocaleResolver w naszej aplikacji Spring Boot.

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

LocaleChangeInterceptor

LocaleChangeInterceptor służy do zmiany nowego ustawienia Locale na podstawie wartości parametru języka dodanego do żądania.

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

Aby uzyskać ten efekt, musimy dodać LocaleChangeInterceptor do przechwytywacza rejestru aplikacji. Klasa konfiguracji powinna rozszerzać klasę WebMvcConfigurerAdapter i przesłonić metodę addInterceptors ().

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

Źródła wiadomości

Aplikacja Spring Boot domyślnie pobiera źródła komunikatów z src/main/resourcesfolder w ścieżce klas. Domyślną nazwą pliku komunikatów lokalnych powinno byćmessage.properties a pliki dla każdego ustawienia narodowego powinny mieć nazwę messages_XX.properties. „XX” reprezentuje kod ustawień regionalnych.

Wszystkie właściwości wiadomości powinny być używane jako wartości par kluczy. Jeśli w ustawieniach regionalnych nie zostaną znalezione żadne właściwości, aplikacja użyje domyślnej właściwości z pliku messages.properties.

Domyślne messages.properties będą wyglądać tak, jak pokazano -

welcome.text=Hi Welcome to Everyone

Francuski komunikat messages_fr.properties będzie taki, jak pokazano -

welcome.text=Salut Bienvenue à tous

Note - Plik źródłowy wiadomości powinien być zapisany w formacie „UTF-8”.

Plik HTML

W pliku HTML użyj składni #{key} aby wyświetlić komunikaty z pliku właściwości.

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

Pełny kod podano poniżej

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

Główny plik klasy aplikacji Spring Boot znajduje się poniżej -

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

Plik klasy kontrolera jest podany poniżej -

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

Klasa konfiguracji do obsługi internacjonalizacji

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

Źródła wiadomości - messages.properties są jak pokazano -

welcome.text = Hi Welcome to Everyone

Źródła wiadomości - message_fr.properties są takie, jak pokazano -

welcome.text = Salut Bienvenue à tous

Plik HTML locale.html należy umieścić w katalogu szablonów w ścieżce klas, jak pokazano -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację rozruchową Spring za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena użyj następującego polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj następującego polecenia -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą polecenia, jak pokazano -

java –jar <JARFILE>

Przekonasz się, że aplikacja została uruchomiona na porcie Tomcat 8080.

Teraz kliknij adres URL http://localhost:8080/locale w przeglądarce internetowej i możesz zobaczyć następujące dane wyjściowe -

URL http://localhost:8080/locale?language=fr da ci wynik, jak pokazano -

Planowanie to proces wykonywania zadań w określonym przedziale czasu. Spring Boot zapewnia dobre wsparcie dla pisania harmonogramu w aplikacjach Spring.

Wyrażenie Java Cron

Wyrażenia Java Cron służą do konfigurowania instancji CronTrigger, podklasy org.quartz.Trigger. Aby uzyskać więcej informacji na temat wyrażenia cron w języku Java, możesz skorzystać z tego linku -

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

Adnotacja @EnableScheduling służy do włączania harmonogramu dla Twojej aplikacji. Ta adnotacja powinna zostać dodana do głównego pliku klasy aplikacji Spring Boot.

@SpringBootApplication
@EnableScheduling

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

Adnotacja @Scheduled jest używana do wyzwalania harmonogramu na określony czas.

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

Poniżej znajduje się przykładowy kod, który pokazuje, jak wykonywać zadanie co minutę, zaczynając o 9:00 i kończąc o 9:59, każdego dnia

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

Poniższy zrzut ekranu pokazuje, jak aplikacja została uruchomiona o godzinie 09:03:23 i co minutę od tego czasu zostało wykonane zadanie harmonogramu zadań cron.

Stała stawka

Harmonogram stałej stawki służy do wykonywania zadań w określonym czasie. Nie czeka na zakończenie poprzedniego zadania. Wartości powinny być w milisekundach. Przykładowy kod jest pokazany tutaj -

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

Przykładowy kod do wykonywania zadania co sekundę od uruchomienia aplikacji jest pokazany tutaj -

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

Zwróć uwagę na poniższy zrzut ekranu, który przedstawia aplikację, która została uruchomiona o godzinie 09:12:00, a następnie zostało wykonane co drugie zadanie harmonogramu o stałej szybkości.

Naprawiono opóźnienie

Harmonogram stałego opóźnienia służy do wykonywania zadań w określonym czasie. Powinien zaczekać na zakończenie poprzedniego zadania. Wartości powinny być w milisekundach. Przykładowy kod jest pokazany tutaj -

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

Tutaj initialDelay jest czasem, po którym zadanie zostanie wykonane po raz pierwszy po początkowej wartości opóźnienia.

Przykład wykonania zadania co sekundę po 3 sekundach od uruchomienia aplikacji jest pokazany poniżej -

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

Zwróć uwagę na poniższy zrzut ekranu, który pokazuje aplikację, która została uruchomiona o godzinie 09:18:39 i co 3 sekundy, zadanie harmonogramu stałego opóźnienia było wykonywane co sekundę.

Domyślnie aplikacja Spring Boot używa portu HTTP 8080 podczas uruchamiania aplikacji.

Musisz wykonać kroki podane poniżej, aby skonfigurować HTTPS i port 443 w aplikacji Spring Boot -

• Uzyskaj certyfikat SSL - utwórz certyfikat z podpisem własnym lub uzyskaj go od urzędu certyfikacji

• Włącz port HTTPS i 443

Certyfikat z podpisem własnym

Aby utworzyć certyfikat z podpisem własnym, środowisko Java Run Time jest dostarczane z narzędziem klucza do zarządzania certyfikatami. To narzędzie służy do tworzenia certyfikatu z podpisem własnym. Jest to pokazane w kodzie podanym tutaj -

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

Ten kod wygeneruje plik kluczy PKCS12 o nazwie keystore.p12, a nazwa aliasu certyfikatu to tomcat.

Skonfiguruj HTTPS

Musimy podać port serwera jako 443, ścieżkę do pliku kluczy, hasło do magazynu kluczy, typ magazynu kluczy i nazwę aliasu klucza w pliku application.properties. Przestrzegaj kodu podanego tutaj -

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

Możesz użyć następującego kodu, jeśli używasz właściwości YAML, użyj poniżej application.yml -

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

Można utworzyć wykonywalny plik JAR i uruchomić aplikację rozruchu sprężynowego za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena możesz użyć następującego polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 443 z https, jak pokazano -

Serwer Eureka to aplikacja przechowująca informacje o wszystkich aplikacjach obsługujących klienta. Każda usługa Micro zarejestruje się na serwerze Eureka, a serwer Eureka zna wszystkie aplikacje klienckie działające na każdym porcie i adresie IP. Serwer Eureka jest również znany jako Discovery Server.

W tym rozdziale dowiemy się szczegółowo, jak zbudować serwer Eureka.

Budowanie serwera Eureka

Serwer Eureka jest dostarczany z pakietem Spring Cloud. W tym celu musimy opracować serwer Eureka i uruchomić go na domyślnym porcie 8761.

Odwiedź stronę główną Spring Initializer https://start.spring.io/i pobierz projekt Spring Boot z zależnością od serwera Eureka. Jest to pokazane na poniższym zrzucie ekranu -

Po pobraniu projektu w głównym pliku klasy Spring Boot Application, musimy dodać adnotację @EnableEurekaServer. Adnotacja @EnableEurekaServer służy do tego, aby aplikacja Spring Boot działała jak serwer Eureka.

Kod głównego pliku klasy aplikacji Spring Boot jest pokazany poniżej -

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

Upewnij się, że zależność serwera Eureka w chmurze Spring jest dodana do pliku konfiguracji kompilacji.

Kod zależności użytkownika Maven pokazano poniżej -

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

Kod zależności użytkownika Gradle jest podany poniżej -

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

Pełny plik konfiguracyjny kompilacji znajduje się poniżej -

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

Domyślnie serwer Eureka rejestruje się w procesie wykrywania. Poniższą konfigurację należy dodać do pliku application.properties lub application.yml.

Plik application.properties znajduje się poniżej -

eureka.client.registerWithEureka = false
eureka.client.fetchRegistry = false
server.port = 8761

Plik application.yml znajduje się poniżej -

eureka:
   client:
      registerWithEureka: false
      fetchRegistry: false
server:
   port: 8761

Teraz możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle pokazanych poniżej -

W przypadku Mavena użyj polecenia, jak pokazano poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia pokazanego poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Możesz stwierdzić, że aplikacja została uruchomiona na porcie Tomcat 8761, jak pokazano poniżej -

Teraz kliknij adres URL http://localhost:8761/ w przeglądarce internetowej i możesz znaleźć serwer Eureka działający na porcie 8761, jak pokazano poniżej -

W tym rozdziale dowiesz się szczegółowo, jak zarejestrować aplikację usługi Spring Boot Micro na serwerze Eureka. Przed zarejestrowaniem aplikacji upewnij się, że serwer Eureka działa na porcie 8761 lub najpierw zbuduj serwer Eureka i uruchom go. Więcej informacji na temat budowy serwera Eureka można znaleźć w poprzednim rozdziale.

Najpierw musisz dodać następujące zależności w naszym pliku konfiguracji kompilacji, aby zarejestrować mikrousługę na serwerze Eureka.

Użytkownicy Maven mogą dodać następujące zależności do pom.xml plik -

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

Użytkownicy Gradle mogą dodawać następujące zależności do build.gradle plik -

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

Teraz musimy dodać adnotację @EnableEurekaClient w głównym pliku klasy aplikacji Spring Boot. Adnotacja @EnableEurekaClient sprawia, że ​​aplikacja Spring Boot działa jako klient Eureka.

Główna aplikacja Spring Boot jest taka, jak podano poniżej -

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

Aby zarejestrować aplikację Spring Boot na serwerze Eureka, musimy dodać następującą konfigurację do naszego pliku application.properties lub application.yml i określić adres URL serwera Eureka w naszej konfiguracji.

Kod pliku application.yml znajduje się poniżej -

eureka:
   client:
      serviceUrl:
         defaultZone: http://localhost:8761/eureka
      instance:
      preferIpAddress: true
spring:
   application:
      name: eurekaclient

Kod pliku application.properties jest podany poniżej -

eureka.client.serviceUrl.defaultZone  = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient

Teraz dodaj punkt końcowy Rest, aby zwrócić ciąg w głównej aplikacji Spring Boot oraz zależność sieciową Spring Boot Starter w pliku konfiguracji kompilacji. Przestrzegaj kodu podanego poniżej -

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

Cały plik konfiguracyjny znajduje się poniżej.

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena możesz użyć następującego polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć następującego polecenia -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą polecenia, jak pokazano -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080 i aplikacja klienta Eureka jest zarejestrowana na serwerze Eureka, jak pokazano poniżej -

Wybierz adres URL http: // localhost: 8761 / w przeglądarce internetowej, a zobaczysz, że aplikacja klienta Eureka jest zarejestrowana na serwerze Eureka.

Teraz kliknij adres URL http://localhost:8080/ w przeglądarce internetowej i zobacz dane wyjściowe Rest Endpoint.

Zuul Server to aplikacja bramy, która obsługuje wszystkie żądania i wykonuje dynamiczny routing aplikacji mikrousług. Serwer Zuul jest również znany jako serwer brzegowy.

Na przykład, /api/user jest mapowany na usługę użytkownika, a / api / products jest mapowany na usługę produktu, a Zuul Server dynamicznie kieruje żądania do odpowiedniej aplikacji wewnętrznej bazy danych.

W tym rozdziale zobaczymy szczegółowo, jak stworzyć aplikację Zuul Server w Spring Boot.

Tworzenie aplikacji serwera Zuul

Serwer Zuul jest powiązany z zależnością Spring Cloud. Projekt Spring Boot można pobrać ze strony Spring Initializerhttps://start.spring.io/ i wybierz zależność Zuul Server.

Dodaj adnotację @EnableZuulProxy do swojej głównej aplikacji Spring Boot. Adnotacja @EnableZuulProxy służy do tego, aby aplikacja Spring Boot działała jako serwer Zuul Proxy.

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

Będziesz musiał dodać zależność Spring Cloud Starter Zuul w naszym pliku konfiguracji kompilacji.

Użytkownicy Maven będą musieli dodać następującą zależność do pliku pom.xml plik -

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

W przypadku użytkowników Gradle dodaj poniższą zależność w pliku build.gradle

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

W przypadku routingu Zuul dodaj poniższe właściwości w pliku application.properties lub application.yml.

spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111

Oznacza to, że http wywołuje /api/demo/zostać przekierowanym do serwisu produktów. Na przykład,/api/demo/products jest przekazywany do /products.

Użytkownicy pliku yaml mogą korzystać z pliku application.yml pokazanego poniżej -

server:
   port: 8111
spring:
   application:  
      name: zuulserver
zuul:

routes:
   products:
      path: /api/demo/**
      url: http://localhost:8080/

Note - The http://localhost:8080/ aplikacja powinna już działać przed routingiem przez Zuul Proxy.

Pełny plik konfiguracyjny kompilacji znajduje się poniżej.

Użytkownicy Mavena mogą skorzystać z podanego poniżej pliku 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>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>

Użytkownicy Gradle mogą skorzystać z pliku build.gradle podanego poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle podanych poniżej -

W przypadku Mavena możesz użyć polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia podanego poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą polecenia pokazanego poniżej -

java –jar <JARFILE>

Możesz znaleźć aplikację, która została uruchomiona na porcie Tomcat 8111, jak pokazano tutaj.

Teraz kliknij adres URL http://localhost:8111/api/demo/products w przeglądarce internetowej i możesz zobaczyć wynik /products Punkt końcowy REST, jak pokazano poniżej -

Spring Cloud Configuration Server to scentralizowana aplikacja, która zarządza wszystkimi właściwościami konfiguracyjnymi aplikacji. W tym rozdziale dowiesz się szczegółowo, jak stworzyć serwer Spring Cloud Configuration.

Tworzenie serwera konfiguracji Spring Cloud

Najpierw pobierz projekt Spring Boot ze strony Spring Initializer i wybierz zależność Spring Cloud Config Server. Obserwuj zrzut ekranu podany poniżej -

Teraz dodaj zależność serwera Spring Cloud Config do pliku konfiguracji kompilacji, jak wyjaśniono poniżej -

Użytkownicy Maven mogą dodać poniższą zależność do pliku pom.xml.

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

Użytkownicy Gradle mogą dodać poniższą zależność w pliku build.gradle.

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

Teraz dodaj adnotację @EnableConfigServer w głównym pliku klasy aplikacji Spring Boot. Adnotacja @EnableConfigServer sprawia, że ​​aplikacja Spring Boot działa jako serwer konfiguracji.

Główny plik klasy aplikacji Spring Boot znajduje się poniżej -

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

Teraz dodaj poniższą konfigurację do pliku właściwości i zamień plik application.properties na plik bootstrap.properties. Przestrzegaj kodu podanego poniżej -

server.port = 8888
spring.cloud.config.server.native.searchLocations=file:///C:/configprop/
SPRING_PROFILES_ACTIVE=native

Serwer konfiguracji działa na porcie 8888 serwera Tomcat, a właściwości konfiguracyjne aplikacji są ładowane z natywnych lokalizacji wyszukiwania.

Teraz w file:///C:/configprop/umieść aplikację kliencką - plik application.properties. Na przykład nazwa aplikacji klienckiej toconfig-client, a następnie zmień nazwę pliku application.properties na config-client.properties i umieść plik właściwości w ścieżce file:///C:/configprop/.

Kod pliku właściwości config-client jest podany poniżej -

welcome.message = Welcome to Spring cloud config server

Pełny plik konfiguracyjny kompilacji znajduje się poniżej -

Użytkownicy Mavena mogą używać pom.xml podane poniżej -

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

Użytkownicy Gradle mogą skorzystać z pliku build.gradle podanego poniżej -

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

Teraz utwórz wykonywalny plik JAR i uruchom aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena użyj polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia podanego poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8888, jak pokazano tutaj -

Teraz kliknij adres URL http://localhost:8888/config-client/default/master w przeglądarce internetowej i możesz zobaczyć właściwości konfiguracyjne aplikacji config-client, jak pokazano tutaj.

Niektóre aplikacje mogą wymagać właściwości konfiguracyjnych, które mogą wymagać zmiany, a programiści mogą być zmuszeni do ich wyłączenia lub ponownego uruchomienia aplikacji, aby to wykonać. Może to jednak prowadzić do przestojów w produkcji i konieczności ponownego uruchomienia aplikacji. Spring Cloud Configuration Server umożliwia programistom ładowanie nowych właściwości konfiguracyjnych bez ponownego uruchamiania aplikacji i bez przestojów.

Praca z serwerem konfiguracji Spring Cloud

Najpierw pobierz projekt Spring Boot z https://start.spring.io/i wybierz zależność Spring Cloud Config Client. Teraz dodaj zależność Spring Cloud Starter Config do pliku konfiguracji kompilacji.

Użytkownicy Maven mogą dodać następującą zależność do pliku pom.xml.

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

Użytkownicy Gradle mogą dodać następującą zależność do build.gradle plik.

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

Teraz musisz dodać adnotację @RefreshScope do swojej głównej aplikacji Spring Boot. Adnotacja @RefreshScope służy do ładowania wartości właściwości konfiguracyjnych z serwera Config.

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

Teraz dodaj adres URL serwera konfiguracji do pliku application.properties i podaj nazwę aplikacji.

Note - http: // localhost: serwer konfiguracyjny 8888 należy uruchomić przed uruchomieniem aplikacji klienta konfiguracji.

spring.application.name = config-client
spring.cloud.config.uri = http://localhost:8888

Kod do napisania prostego punktu końcowego REST w celu odczytania wiadomości powitalnej z serwera konfiguracji jest podany poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena możesz użyć polecenia pokazanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia pokazanego poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR, używając polecenia pokazanego tutaj:

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080, jak pokazano tutaj -

Możesz zobaczyć okno logowania w konsoli; config-client aplikacja pobiera konfigurację zhttps://localhost:8888

2017-12-08 12:41:57.682  INFO 1104 --- [           
   main] c.c.c.ConfigServicePropertySourceLocator : 
   Fetching config from server at: http://localhost:8888

Teraz kliknij adres URL, http://localhost:8080/ wiadomość powitalna jest ładowana z serwera konfiguracji.

Teraz przejdź i zmień wartość właściwości na serwerze konfiguracji i naciśnij adres URL POST punktu końcowego elementu wykonawczego http://localhost:8080/refresh i zobacz nową wartość właściwości konfiguracji w adresie URL http://localhost:8080/

Spring Boot Actuator zapewnia zabezpieczone punkty końcowe do monitorowania i zarządzania aplikacją Spring Boot. Domyślnie wszystkie punkty końcowe siłownika są zabezpieczone. W tym rozdziale dowiesz się szczegółowo, jak włączyć siłownik Spring Boot w swojej aplikacji.

Włączanie siłownika rozruchu sprężynowego

Aby włączyć punkty końcowe siłownika Spring Boot do aplikacji Spring Boot, musimy dodać zależność siłownika Spring Boot Starter w naszym pliku konfiguracyjnym kompilacji.

Użytkownicy Maven mogą dodać poniższą zależność w pliku pom.xml.

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

Użytkownicy Gradle mogą dodać poniższą zależność w pliku build.gradle.

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

W pliku application.properties musimy wyłączyć zabezpieczenia dla punktów końcowych elementu wykonawczego.

management.security.enabled = false

Użytkownicy pliku YAML mogą dodać następującą właściwość w pliku application.yml.

management:
   security:
      enabled: false

Jeśli chcesz używać oddzielnego numeru portu do uzyskiwania dostępu do punktów końcowych aktora rozruchowego Spring, dodaj numer portu zarządzania w pliku application.properties.

management.port = 9000

Użytkownicy pliku YAML mogą dodać następującą właściwość w pliku application.yml.

management:
   port: 9000

Teraz możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena możesz użyć następującego polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć następującego polecenia -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz możesz uruchomić plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080. Zwróć uwagę, że jeśli określono numer portu zarządzania, to ta sama aplikacja działa na dwóch różnych numerach portów.

Poniżej przedstawiono kilka ważnych punktów końcowych siłownika rozruchu sprężynowego. Możesz je wprowadzić w swojej przeglądarce internetowej i monitorować zachowanie aplikacji.

PUNKTY KOŃCOWE	STOSOWANIE
/metryka	Aby wyświetlić metryki aplikacji, takie jak wykorzystana pamięć, ilość wolnej pamięci, wątki, klasy, czas pracy systemu itp.
/ env	Aby wyświetlić listę zmiennych środowiskowych używanych w aplikacji.
/fasolki	Aby wyświetlić fasolę wiosenną i jej rodzaje, zakresy i zależności.
/zdrowie	Aby wyświetlić stan aplikacji
/ info	Aby wyświetlić informacje o aplikacji Spring Boot.
/ślad	Aby wyświetlić listę śladów punktów końcowych odpoczynku.

Monitorowanie aplikacji za pomocą Spring Boot Actuator Endpoint jest nieco trudne. Ponieważ jeśli masz „n” aplikacji, każda aplikacja ma oddzielne punkty końcowe siłownika, co utrudnia monitorowanie. Spring Boot Admin Server to aplikacja służąca do zarządzania i monitorowania aplikacji Microservice.

Aby poradzić sobie z takimi sytuacjami, zespół CodeCentric zapewnia interfejs administratora Spring Boot do zarządzania i monitorowania wszystkich punktów końcowych elementu wykonawczego aplikacji Spring Boot w jednym miejscu.

Aby zbudować Spring Boot Admin Server, musimy dodać poniższe zależności w pliku konfiguracji kompilacji.

Użytkownicy Maven mogą dodać poniższe zależności w pliku pom.xml -

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

Użytkownicy Gradle mogą dodać poniższe zależności w pliku build.gradle -

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'

Dodaj adnotację @EnableAdminServer w głównym pliku klasy aplikacji Spring Boot. Adnotacja @EnableAdminServer służy do ustawiania serwera administracyjnego w celu monitorowania wszystkich innych mikrousług.

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

Teraz zdefiniuj server.port i nazwę aplikacji w pliku application.properties a pokazany -

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

W przypadku użytkowników YAML użyj następujących właściwości, aby zdefiniować numer portu i nazwę aplikacji w pliku application.yml.

server:
   port: 9090
spring:
   application:
      name: adminserver

Plik konfiguracyjny kompilacji jest podany poniżej.

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena użyj polecenia pokazanego tutaj -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia pokazanego tutaj -

gradle clean build

Po komunikacie „BUILD SUCCESSFUL” można znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR, używając polecenia podanego poniżej -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 9090, jak pokazano tutaj -

Teraz kliknij poniższy adres URL w przeglądarce internetowej i zobacz interfejs użytkownika serwera administracyjnego.

http://localhost:9090/

Aby monitorować aplikację mikrousług i zarządzać nią za pośrednictwem Spring Boot Admin Server, należy dodać zależność klienta startowego Spring Boot Admin i wskazać identyfikator URI serwera administracyjnego w pliku właściwości aplikacji.

Note - Aby monitorować aplikację, należy włączyć punkty końcowe siłownika rozruchu sprężynowego dla aplikacji Microservice.

Najpierw dodaj następującą zależność klienta startowego Spring Boot Admin i zależność startera Spring Boot w pliku konfiguracyjnym kompilacji.

Użytkownicy Maven mogą dodawać następujące zależności w pliku pom.xml -

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

Użytkownicy Gradle mogą dodawać następujące zależności w pliku build.gradle.

compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')

Teraz dodaj adres URL serwera administracyjnego Spring Boot do pliku właściwości aplikacji.

W przypadku użytkowników plików właściwości dodaj następujące właściwości w pliku application.properties.

spring.boot.admin.url = http://localhost:9090/

W przypadku użytkowników YAML dodaj następującą właściwość w pliku application.yml.

spring:
   boot:
      admin:
         url: http://localhost:9000/

Teraz utwórz wykonywalny plik JAR i uruchom aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena możesz użyć polecenia, jak pokazano -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą pokazanego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 9090, jak pokazano -

Teraz kliknij następujący adres URL w przeglądarce internetowej i zobacz, że Twoja aplikacja Spring Boot jest zarejestrowana na serwerze Spring Boot Admin Server.

http://localhost:9090/

Teraz kliknij Details i zobacz punkty końcowe elementu wykonawczego w interfejsie użytkownika serwera administracyjnego.

Swagger2 to projekt open source używany do generowania dokumentów REST API dla usług internetowych RESTful. Zapewnia interfejs użytkownika umożliwiający dostęp do naszych usług sieciowych RESTful za pośrednictwem przeglądarki internetowej.

Aby włączyć Swagger2 w aplikacji Spring Boot, musisz dodać następujące zależności w naszym pliku konfiguracji kompilacji.

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

W przypadku użytkowników Gradle dodaj następujące zależności w pliku build.gradle.

compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'

Teraz dodaj adnotację @ EnableSwagger2 w swojej głównej aplikacji Spring Boot. Adnotacja @ EnableSwagger2 służy do włączania Swagger2 dla Twojej aplikacji Spring Boot.

Poniżej przedstawiono kod głównej aplikacji Spring Boot -

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

Następnie utwórz Docket Bean, aby skonfigurować Swagger2 dla swojej aplikacji Spring Boot. Musimy zdefiniować pakiet podstawowy, aby skonfigurować API REST dla Swagger2.

@Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }

Teraz dodaj ten bean do samego głównego pliku klasy aplikacji Spring Boot, a Twoja główna klasa aplikacji Spring Boot będzie wyglądać jak pokazano poniżej -

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

Teraz dodaj poniższą zależność sieci Web Spring Boot Starter w pliku konfiguracyjnym kompilacji, aby zapisać punkty końcowe REST, jak pokazano poniżej -

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml -

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle -

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

Teraz kod do zbudowania dwóch prostych usług internetowych RESTful GET i POST w pliku Rest Controller jest pokazany tutaj -

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

Pełny plik konfiguracyjny kompilacji znajduje się poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena możesz użyć pokazanego tutaj polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia, jak pokazano tutaj -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR, używając polecenia pokazanego tutaj -

java –jar <JARFILE>

Teraz aplikacja uruchomi się na porcie Tomcat 8080, jak pokazano -

Teraz kliknij adres URL w przeglądarce internetowej i zobacz funkcje Swagger API.

http://localhost:8080/swagger-ui.html

Docker to usługa zarządzania kontenerami, która ułatwia tworzenie i wdrażanie. Jeśli jesteś początkującym użytkownikiem Dockera, możesz dowiedzieć się o szczegółach pod tym linkiem -https://www.tutorialspoint.com/docker/index.htm

W tym rozdziale zobaczymy, jak utworzyć obraz Dockera przy użyciu zależności Maven i Gradle dla aplikacji Spring Boot.

Utwórz plik Dockerfile

Najpierw utwórz plik o nazwie Dockerfile w katalogach src/main/dockerz zawartością pokazaną poniżej. Zauważ, że ten plik jest ważny do tworzenia obrazu Docker.

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

W przypadku Mavena dodaj wtyczkę Docker Maven do pliku konfiguracji kompilacji 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>

Pełny plik pom.xml znajduje się poniżej -

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

Teraz możesz uruchomić swoją aplikację za pomocą polecenia Maven mvn package docker:build

Note - Włącz demona Expose tcp://localhost:2375 bez TLS.

Po pomyślnym zakończeniu kompilacji możesz zobaczyć dane wyjściowe na konsoli, jak pokazano poniżej -

Teraz zobacz obrazy platformy Docker za pomocą polecenia przy użyciu obrazów platformy Docker i zobacz informacje o obrazie na konsoli.

Gradle

Aby zbudować obraz platformy Docker przy użyciu konfiguracji kompilacji Gradle, musimy dodać docker wtyczkę i musisz napisać zadanie buildDocker aby utworzyć obraz platformy Docker.

Kod konfiguracji Gradle Docker jest podany poniżej.

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

Pełny plik build.gradle znajduje się poniżej.

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

Teraz utwórz obraz Dockera za pomocą polecenia pokazanego poniżej -

gradle build buildDocker

Po wykonaniu polecenia w oknie konsoli można zobaczyć dziennik BUDOWA SUKCESU.

Teraz zobacz obrazy platformy Docker za pomocą polecenia przy użyciu docker images i zobacz informacje o obrazie na konsoli.

Większość programistów napotyka trudności w śledzeniu dzienników, jeśli wystąpi jakikolwiek problem. Można to rozwiązać za pomocą Spring Cloud Sleuth i serwera ZipKin dla aplikacji Spring Boot.

Wiosenny tropiciel chmur

Dzienniki Spring Cloud Sleuth są drukowane w następującym formacie -

[application-name,traceid,spanid,zipkin-export]

Gdzie,

• Application-name = nazwa aplikacji

• Traceid = każde żądanie i identyfikator traceid są takie same podczas wywoływania tej samej usługi lub jednej usługi do innej usługi.

• Spanid = Span Id jest drukowany wraz z identyfikatorem śledzenia. Identyfikator zakresu jest inny dla każdego żądania i odpowiedzi wzywającej jedną usługę do innej usługi.

• Zipkin-export = Domyślnie jest to fałsz. Jeśli to prawda, dzienniki zostaną wyeksportowane na serwer Zipkin.

Teraz dodaj zależność Spring Cloud Starter Sleuth do pliku konfiguracji kompilacji w następujący sposób -

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml -

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle -

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

Teraz dodaj dzienniki do pliku klasy Rest Controller aplikacji Spring Boot, jak pokazano tutaj -

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!";
   }
}

Teraz dodaj nazwę aplikacji w pliku application.properties, jak pokazano -

spring.application.name = tracinglogs

Pełny kod pliku konfiguracyjnego kompilacji znajduje się poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena możesz użyć następującego polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć następującego polecenia -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR, używając polecenia pokazanego tutaj -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080.

Teraz naciśnij adres URL w przeglądarce internetowej i zobacz dane wyjściowe w dzienniku konsoli.

http://localhost:8080/

W oknie konsoli możesz zobaczyć następujące dzienniki. Zwróć uwagę, że dziennik jest drukowany w następującym formacie [nazwa aplikacji, identyfikator śledzenia, spanid, eksport zipkin]

Serwer Zipkin

Zipkin to aplikacja, która monitoruje i zarządza dziennikami Spring Cloud Sleuth Twojej aplikacji Spring Boot. Aby zbudować serwer Zipkin, musimy dodać Zipkin UI i Zipkin Server zależności w naszym pliku konfiguracji kompilacji.

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml -

<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-autoconfigure-ui</artifactId>
</dependency>

Użytkownicy Gradle mogą dodać poniższą zależność do pliku build.gradle -

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Teraz skonfiguruj server.port = 9411 w pliku właściwości aplikacji.

W przypadku użytkowników plików właściwości dodaj poniższą właściwość w pliku application.properties.

server.port = 9411

Dla użytkowników YAML dodaj poniższą właściwość w pliku application.yml.

server:
   port: 9411

Dodaj adnotację @EnableZipkinServer w swojej głównej klasie aplikacji Spring Boot fie. Adnotacja @EnableZipkinServer służy do umożliwienia aplikacji działania jako serwera Zipkin.

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

Kod pełnego pliku konfiguracyjnego kompilacji znajduje się poniżej.

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poniższych poleceń Maven lub Gradle -

W przypadku Mavena użyj polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia podanego poniżej -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR za pomocą pokazanego polecenia -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 9411, jak pokazano poniżej -

Teraz kliknij poniższy adres URL i zobacz interfejs użytkownika serwera Zipkin.

http://localhost:9411/zipkin/

Następnie dodaj następującą zależność w aplikacji usługi klienckiej i wskaż adres URL serwera Zipkin, aby śledzić dzienniki mikrousług za pośrednictwem interfejsu użytkownika Zipkin.

Teraz dodaj zależność Spring Cloud Starter Zipkin w pliku konfiguracyjnym kompilacji, jak pokazano -

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Użytkownicy Gradle mogą dodać poniższą zależność w pliku build.gradle -

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Teraz dodaj Always Sampler Bean w aplikacji Spring Boot, aby wyeksportować dzienniki do serwera Zipkin.

@Bean
public AlwaysSampler defaultSampler() {
   return new AlwaysSampler();
}

Jeśli dodasz fasolkę AlwaysSampler, automatycznie opcja Spring Sleuth Zipkin Export zmieni się z false na true.

Następnie skonfiguruj podstawowy adres URL serwera Zipkin w pliku application.properties usługi klienta.

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

Następnie podaj identyfikator śledzenia i znajdź ślady w interfejsie użytkownika Zipkin.

http://localhost:9411/zipkin/traces/{traceid}/

Flyway to aplikacja do kontroli wersji umożliwiająca łatwe i niezawodne rozwijanie schematu bazy danych we wszystkich instancjach. Aby dowiedzieć się więcej o Flyway, możesz skorzystać z linku - www.flywaydb.org

Wiele projektów oprogramowania korzysta z relacyjnych baz danych. Wymaga to obsługi migracji baz danych, często nazywanych również migracjami schematów.

W tym rozdziale dowiesz się szczegółowo, jak skonfigurować bazę danych Flyway w swojej aplikacji Spring Boot.

Konfigurowanie bazy danych Flyway

Najpierw pobierz projekt Spring Boot ze strony Spring Initializer www.start.spring.io i wybierz następujące zależności -

• Strona startowa Spring Boot Starter
• Flyway
• MySQL
• JDBC

Użytkownicy Mavena mogą dodać następujące zależności w pliku pom.xml.

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

Użytkownicy Gradle mogą dodawać następujące zależności w pliku build.gradle.

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

We właściwościach aplikacji musimy skonfigurować właściwości bazy danych do tworzenia źródła danych, a także właściwości flyway, które musimy skonfigurować we właściwościach aplikacji.

W przypadku użytkowników plików właściwości dodaj poniższe właściwości w pliku application.properties.

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

Użytkownicy YAML mogą dodawać następujące właściwości w pliku application.yml.

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"

Teraz utwórz plik SQL pod rozszerzeniem src/main/resources/db/migrationinformator. Nazwij plik SQL jako „V1__Initial.sql”

CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');

Główny kod pliku klasy aplikacji Spring Boot jest podany poniżej -

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

Pełny plik konfiguracyjny kompilacji znajduje się poniżej.

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle podanych poniżej -

W przypadku Mavena możesz użyć pokazanego tutaj polecenia -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć pokazanego tutaj polecenia -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą następującego polecenia -

java –jar <JARFILE>

Teraz Tomcat wystartował na porcie 8080 iw oknie konsoli możesz zobaczyć dzienniki bazy danych flyway, jak pokazano tutaj.

Możesz teraz przejść do bazy danych i wykonać zapytania wybierające.

Korzystając z usługi internetowej Spring Boot RESTful, możesz wysyłać e-maile za pomocą Gmail Transport Layer Security. W tym rozdziale wyjaśnimy szczegółowo, jak korzystać z tej funkcji.

Najpierw musimy dodać zależność Spring Boot Starter Mail do pliku konfiguracyjnego kompilacji.

Użytkownicy Maven mogą dodać następującą zależność do pliku pom.xml.

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle.

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

Kod głównego pliku klasy aplikacji Spring Boot jest podany poniżej -

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

Możesz napisać proste API Rest do wysłania na e-mail w pliku klasy Rest Controller, jak pokazano.

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

Możesz napisać metodę wysyłania wiadomości e-mail z załącznikiem. Zdefiniuj właściwości mail.smtp i użyj hasła 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);   
}

Teraz wywołaj powyższą metodę sendmail () z Rest API, jak pokazano -

@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
   sendmail();
   return "Email sent successfully";   
}

Note - Włącz opcję Zezwalaj na mniej bezpieczne aplikacje w ustawieniach konta Gmail przed wysłaniem wiadomości e-mail.

Pełny plik konfiguracyjny kompilacji znajduje się poniżej.

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

Teraz możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle pokazanych poniżej -

W przypadku Mavena możesz użyć polecenia, jak pokazano -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR, używając polecenia podanego poniżej -

java –jar <JARFILE>

Możesz zobaczyć, że aplikacja została uruchomiona na porcie Tomcat 8080.

Teraz kliknij następujący adres URL w przeglądarce internetowej, a otrzymasz wiadomość e-mail.

http://localhost:8080/sendemail

Hystrix to biblioteka Netflix. Hystrix izoluje punkty dostępu między usługami, zatrzymuje kaskadowe awarie w nich i zapewnia opcje awaryjne.

Na przykład, gdy dzwonisz do 3 ^rd aplikacji innej, to zajmuje więcej czasu, aby wysłać odpowiedź. W tym momencie formant przechodzi do metody rezerwowej i zwraca niestandardową odpowiedź do aplikacji.

W tym rozdziale zobaczysz, jak zaimplementować Hystrix w aplikacji Spring Boot.

Najpierw musimy dodać zależność Spring Cloud Starter Hystrix do naszego pliku konfiguracji kompilacji.

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml -

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle -

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

Teraz dodaj adnotację @EnableHystrix do głównego pliku klasy aplikacji Spring Boot. Adnotacja @EnableHystrix służy do włączania funkcji Hystrix w Twojej aplikacji Spring Boot.

Główny kod pliku klasy aplikacji Spring Boot jest podany poniżej -

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

Teraz napisz prosty kontroler REST tak, aby zwracał Ciąg po 3 sekundach od żądanego czasu.

@RequestMapping(value = "/")
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}

Teraz dodaj polecenie @Hystrix i @HystrixProperty dla interfejsu API Rest i zdefiniuj limit czasu w milisekundach.

@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})

Następnie zdefiniuj metodę rezerwową fallback_hello (), jeśli odpowiedź na żądanie zajmuje dużo czasu.

private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

Pełny plik klasy Rest Controller, który zawiera właściwości REST API i Hystrix -

@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";
}

W tym przykładzie API REST napisane w głównym pliku klasy aplikacji Spring Boot.

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

Pełny plik konfiguracyjny kompilacji znajduje się poniżej.

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena użyj polecenia, jak pokazano -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR, używając polecenia podanego poniżej -

java –jar <JARFILE>

Spowoduje to uruchomienie aplikacji na porcie Tomcat 8080, jak pokazano poniżej -

Teraz kliknij adres URL http://localhost:8080/z przeglądarki internetowej i zobacz odpowiedź Hystrix. Odpowiedź API zajmuje 3 sekundy, ale limit czasu Hystrix wynosi 1 sekundę.

W tym rozdziale wyjaśnimy, jak zbudować interaktywną aplikację internetową przy użyciu Spring Boot z gniazdami internetowymi.

Aby zbudować interaktywną aplikację internetową w Spring Boot z gniazdem internetowym, musisz dodać następujące zależności.

Użytkownicy Mavena powinni dodać następujące zależności w pliku pom.xml.

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

Użytkownicy Gradle mogą dodawać następujące zależności w pliku build.gradle -

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

Stwórzmy kontroler obsługi wiadomości do pracy z przesyłaniem komunikatów STOMP. Komunikaty STOMP mogą być kierowane do pliku klasy @Controller. Na przykład GreetingController jest mapowany do obsługi komunikatów do miejsca docelowego „/ hello”.

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

Teraz skonfiguruj Spring do obsługi wiadomości STOMP. Napisz plik klasy WebSocketConfig, który rozszerza klasę AbstractWebSocketMessageBrokerConfigurer, jak pokazano poniżej.

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

Adnotacja @EnableWebSocketMessageBroker służy do konfigurowania brokera komunikatów gniazda sieci Web w celu tworzenia punktów końcowych STOMP.

Możesz utworzyć plik klienta przeglądarki w katalogu src / main / resources / static / index.html, jak pokazano -

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

Stwórzmy plik app.js, aby konsumować i generować komunikaty przy użyciu STOMP.

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

Poniżej przedstawiono kod głównej aplikacji Spring Boot.

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

Pełny plik konfiguracyjny kompilacji znajduje się poniżej.

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle, jak pokazano poniżej -

W przypadku Mavena możesz użyć polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR, używając polecenia podanego tutaj -

java –jar <JARFILE>

Teraz aplikacja została uruchomiona na porcie Tomcat 8080, jak pokazano.

Teraz kliknij adres URL http://localhost:8080/ w przeglądarce internetowej i podłącz do gniazdka sieciowego, wyślij powitanie i odbierz wiadomość.

Usługa wsadowa to proces wykonywania więcej niż jednego polecenia w jednym zadaniu. W tym rozdziale dowiesz się, jak utworzyć usługę wsadową w aplikacji Spring Boot.

Rozważmy przykład, w którym zamierzamy zapisać zawartość pliku CSV w HSQLDB.

Aby utworzyć program Batch Service, musimy dodać zależność Spring Boot Starter Batch i HSQLDB do naszego pliku konfiguracji kompilacji.

Użytkownicy Mavena mogą dodać następujące zależności w pliku pom.xml.

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

Użytkownicy Gradle mogą dodawać następujące zależności w pliku build.gradle.

compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")

Teraz dodaj prosty plik danych CSV w zasobach ścieżki klas - src / main / resources i nazwij plik jako file.csv, jak pokazano -

William,John
Mike, Sebastian
Lawarance, Lime

Następnie napisz skrypt SQL dla HSQLDB - w katalogu zasobów ścieżki klas - 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)
);

Utwórz klasę POJO dla modelu USERS, jak pokazano -

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

Teraz utwórz procesor pośredni, który będzie wykonywał operacje po odczytaniu danych z pliku CSV i przed zapisaniem danych do SQL.

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

Utwórzmy plik konfiguracyjny wsadowy, aby odczytać dane z CSV i zapisać do pliku SQL, jak pokazano poniżej. Musimy dodać adnotację @EnableBatchProcessing w pliku klasy konfiguracyjnej. Adnotacja @EnableBatchProcessing służy do włączania operacji wsadowych dla aplikacji Spring Boot.

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

Plik reader() metoda służy do odczytu danych z pliku CSV, a metoda writer () służy do zapisywania danych w SQL.

Następnie będziemy musieli napisać klasę odbiornika powiadomień o zakończeniu pracy - używaną do powiadamiania po zakończeniu zadania.

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

Teraz utwórz wykonywalny plik JAR i uruchom aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena użyj polecenia, jak pokazano -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR, używając polecenia podanego tutaj -

java –jar <JARFILE>

Możesz zobaczyć dane wyjściowe w oknie konsoli, jak pokazano -

Apache Kafka to projekt typu open source używany do publikowania i subskrybowania wiadomości w oparciu o odporny na błędy system przesyłania wiadomości. Jest szybki, skalowalny i dystrybuowany zgodnie z projektem. Jeśli jesteś początkującym użytkownikiem Kafki lub chcesz lepiej go zrozumieć, skorzystaj z tego linku - www.tutorialspoint.com/apache_kafka/

W tym rozdziale zobaczymy, jak zaimplementować Apache Kafka w aplikacji Spring Boot.

Najpierw musimy dodać zależność Spring Kafka w naszym pliku konfiguracyjnym kompilacji.

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml.

<dependency>
   <groupId>org.springframework.kafka</groupId>
   <artifactId>spring-kafka</artifactId>
   <version>2.1.0.RELEASE</version>
</dependency>

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle.

compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'

Tworzenie wiadomości

Aby wygenerować komunikaty w Apache Kafka, musimy zdefiniować klasę Configuration dla konfiguracji producenta, jak pokazano -

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

Aby opublikować wiadomość, automatycznie połącz obiekt szablonu Kafka i utwórz wiadomość, jak pokazano.

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
 
public void sendMessage(String msg) {
   kafkaTemplate.send(topicName, msg);
}

Konsumowanie wiadomości

Aby korzystać z wiadomości, musimy napisać plik klasy konfiguracyjnej konsumenta, jak pokazano poniżej.

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

Następnie napisz Listenera, który będzie słuchał wiadomości.

@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
   System.out.println("Received Messasge in group - group-id: " + message);
}

Wywołajmy metodę sendMessage () z metody uruchamiania klasy ApplicationRunner z głównego pliku klasy aplikacji Spring Boot i wykorzystajmy komunikat z tego samego pliku klasy.

Twój główny kod pliku klasy aplikacji Spring Boot jest podany poniżej -

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

Kod pełnego pliku konfiguracyjnego kompilacji znajduje się poniżej.

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

Teraz utwórz wykonywalny plik JAR i uruchom aplikację Spring Boot za pomocą poniższych poleceń Maven lub Gradle, jak pokazano -

W przypadku Mavena użyj polecenia, jak pokazano -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR, używając polecenia podanego tutaj -

java –jar <JARFILE>

Możesz zobaczyć dane wyjściowe w oknie konsoli.

Twilio jest 3 ^rd aplikacja partia używany do wysyłania wiadomości SMS i wykonywanie połączeń głosowych z naszej aplikacji. Umożliwia nam programowe wysyłanie SMS-ów i wykonywanie połączeń głosowych.

W tym rozdziale dowiesz się, jak zaimplementować wysyłanie wiadomości SMS i wykonywanie połączeń głosowych przy użyciu funkcji Spring Boot z Twilio.

Note- Użyliśmy konta Trail w Twilio do wysyłania wiadomości SMS i wykonywania połączeń głosowych. Możesz dowiedzieć się więcej o Twilio pod adresem www.twilio.com .

Najpierw musimy dodać zależność Twilio w naszym pliku konfiguracji kompilacji.

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml.

<dependency>
   <groupId>com.twilio.sdk</groupId>
   <artifactId>twilio</artifactId>
   <version>7.16.1</version>
</dependency>

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle.

compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"

Teraz zainicjuj konto Twilio z ACCOUNT_SID i AUTH_ID w statycznym bloku, jak pokazano -

static {
   Twilio.init(ACCOUNT_SID, AUTH_ID);
}

Wysyłanie wiadomości SMS

Aby wysłać SMS-a, musimy podać od-numer i numer do metody Message.create (). Treść wiadomości również musimy podać dla metody Message.creator (), jak pokazano -

Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
   "Message from Spring Boot Application").create();

Główny plik klasy aplikacji Spring Boot wygląda poniżej.

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

Pełny kod do zbudowania pliku konfiguracyjnego jest podany poniżej -

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.+"   
}

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację rozruchu sprężynowego za pomocą następujących poleceń Maven lub Gradle -

W przypadku Mavena użyj polecenia, jak pokazano -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR za pomocą polecenia podanego poniżej -

java –jar <JARFILE>

Teraz otrzymasz SMS na swój „numer pod numer”.

Otrzymano wiadomość na numer „na numer”.

Sent from your Twilio trail account
- Message from Spring Boot Application

Note- W tym przykładzie użyliśmy konta Trail. Dlatego przed wysłaniem wiadomości SMS należy zweryfikować numery.

Połączenia głosowe

Aby wykonywać połączenia głosowe za pomocą Twilio, musimy wywołać metodę Call.creator (). W przypadku tej metody musimy podać numer do, numer nadawcy i notatkę głosową, jak pokazano tutaj.

Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
   new URI("http://demo.twilio.com/docs/voice.xml")).create();

Poniżej znajduje się kod głównego pliku klasy aplikacji Spring Boot.

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

Kod pełnego pliku konfiguracji kompilacji znajduje się poniżej -

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.+"   
}

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena użyj polecenia, jak pokazano -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle użyj polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą polecenia podanego tutaj -

java –jar <JARFILE>

Teraz otrzymasz połączenie z numerem „na numer” od Twilio.

Naciśnij dowolny klawisz po odebraniu połączenia, usłyszysz notatkę głosową od https://demo.twilio.com/docs/voice.xml

Note- W tym przykładzie użyliśmy konta Trail. Dlatego przed wykonaniem połączeń należy zweryfikować numery.

Testowanie jednostkowe to jedno z testów wykonywanych przez programistów w celu upewnienia się, że funkcje poszczególnych jednostek lub komponentów działają poprawnie.

W tym samouczku zobaczymy, jak napisać przypadek testowy przy użyciu Mockito i kontrolera internetowego.

Mockito

Aby wprowadzić Mockito Mocks do Spring Beans, musimy dodać zależność Mockito-core do naszego pliku konfiguracyjnego kompilacji.

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml.

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle.

compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')

Kod do napisania klasy Service, która zawiera metodę zwracającą wartość String, jest podany tutaj.

package com.tutorialspoint.mockitodemo;

import org.springframework.stereotype.Service;

@Service
public class ProductService {
   public String getProductName() {
      return "Honey";
   } 
}

Teraz wstrzyknij klasę ProductService do innego pliku klasy Service, jak pokazano.

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

Główny plik klasy aplikacji Spring Boot znajduje się poniżej -

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

Następnie skonfiguruj kontekst aplikacji dla testów. Adnotacja @Profile („test”) służy do konfigurowania klasy, gdy przypadki testowe są uruchomione.

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

Teraz możesz napisać przypadek testu jednostkowego dla usługi zamówienia w ramach src/test/resources pakiet.

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

Pełny kod pliku konfiguracyjnego kompilacji znajduje się poniżej.

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle1.

W przypadku Mavena możesz użyć polecenia, jak pokazano -

mvn clean install

Możesz zobaczyć wyniki testu w oknie konsoli.

W przypadku Gradle możesz użyć polecenia, jak pokazano -

gradle clean build

Pozostałe wyniki możesz zobaczyć w oknie konsoli.

Spring Boot zapewnia łatwy sposób na napisanie testu jednostkowego dla pliku kontrolera odpoczynku. Z pomocą SpringJUnit4ClassRunner i MockMvc możemy stworzyć kontekst aplikacji internetowej do zapisu pliku Unit Test for Rest Controller.

Testy jednostkowe powinny być napisane pod src/test/java Zasoby katalogu i ścieżki klas do napisania testu powinny być umieszczone w katalogu src/test/resources informator.

Aby napisać test jednostkowy, musimy dodać zależność Spring Boot Starter Test w pliku konfiguracyjnym kompilacji, jak pokazano poniżej.

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle.

testCompile('org.springframework.boot:spring-boot-starter-test')

Przed napisaniem przypadku testowego powinniśmy najpierw zbudować usługi sieciowe RESTful. Więcej informacji na temat tworzenia usług internetowych zgodnych ze standardem REST można znaleźć w rozdziale poświęconym temu samemu podanemu w tym samouczku.

Pisanie testu jednostkowego dla kontrolera REST

W tej sekcji zobaczmy, jak napisać test jednostkowy dla kontrolera REST.

Najpierw musimy utworzyć plik klasy abstrakcyjnej używany do tworzenia kontekstu aplikacji internetowej za pomocą MockMvc i zdefiniować metody mapToJson () i mapFromJson (), aby przekonwertować obiekt Java na ciąg JSON i przekonwertować ciąg JSON na obiekt Java.

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

Następnie napisz plik klasy, który rozszerza klasę AbstractTest i napisz Test jednostkowy dla każdej metody, takiej jak GET, POST, PUT i DELETE.

Kod przypadku testowego GET API znajduje się poniżej. Ten interfejs API służy do przeglądania listy produktów.

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

Kod przypadku testowego POST API jest podany poniżej. To API służy do tworzenia produktu.

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

Kod przypadku testowego PUT API znajduje się poniżej. Ten interfejs API służy do aktualizacji istniejącego produktu.

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

Kod dla Usuń przypadek testowy API znajduje się poniżej. Ten interfejs API usunie istniejący 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");
}

Pełny plik klasy testu kontrolera znajduje się poniżej -

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

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą poleceń Maven lub Gradle podanych poniżej -

W przypadku Mavena możesz użyć polecenia podanego poniżej -

mvn clean install

Teraz możesz zobaczyć wyniki testu w oknie konsoli.

W przypadku Gradle możesz użyć polecenia, jak pokazano poniżej -

gradle clean build

Możesz zobaczyć pozostałe wyniki w oknie konsoli, jak pokazano poniżej.

Spring Boot zapewnia bardzo dobrą obsługę tworzenia źródła danych dla bazy danych. Nie musimy pisać żadnego dodatkowego kodu, aby utworzyć źródło danych w Spring Boot. Wystarczy dodać zależności i wykonać szczegóły konfiguracji, aby utworzyć źródło danych i połączyć się z bazą danych.

W tym rozdziale użyjemy połączenia sterownika Spring Boot JDBC do połączenia z bazą danych.

Najpierw musimy dodać zależność Spring Boot Starter JDBC w naszym pliku konfiguracyjnym kompilacji.

Użytkownicy Maven mogą dodać następujące zależności w pliku pom.xml.

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

Użytkownicy Gradle mogą dodać następujące zależności w pliku build.gradle.

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

Połącz się z bazą danych H2

Aby podłączyć bazę danych H2, musimy dodać zależność bazy danych H2 w naszym pliku konfiguracyjnym kompilacji.

W przypadku użytkowników Maven dodaj poniższą zależność w pliku pom.xml.

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

W przypadku użytkowników Gradle dodaj poniższą zależność w pliku build.gradle.

compile('com.h2database:h2')

Musimy utworzyć plik schema.sql i plik data.sql w katalogu classpath src / main / resources, aby połączyć bazę danych H2.

Plik schema.sql jest podany poniżej.

CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));

Plik data.sql znajduje się poniżej.

INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');

Połącz MySQL

Aby połączyć bazę danych MySQL, musimy dodać zależność MySQL do naszego pliku konfiguracji kompilacji.

W przypadku użytkowników Maven dodaj następującą zależność w pliku pom.xml.

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

W przypadku użytkowników Gradle dodaj następującą zależność w pliku build.gradle.

compile('mysql:mysql-connector-java')

Teraz utwórz bazę danych i tabele w MySQL, jak pokazano -

W przypadku użytkowników plików właściwości dodaj następujące właściwości w pliku application.properties.

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

W przypadku użytkowników YAML dodaj następujące właściwości w pliku application.yml.

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

Połącz Redis

Redis to baza danych typu open source używana do przechowywania struktury danych w pamięci. Aby połączyć bazę danych Redis w aplikacji Spring Boot, musimy dodać zależność Redis w naszym pliku konfiguracyjnym kompilacji.

Użytkownicy Mavena powinni dodać następującą zależność w pliku pom.xml.

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

Użytkownicy Gradle powinni dodać następującą zależność w pliku build.gradle.

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

W przypadku połączenia Redis musimy użyć RedisTemplate. W przypadku RedisTemplate musimy podać szczegóły JedisConnectionFactory.

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

Teraz automatycznie połącz klasę RedisTemplate i uzyskaj dostęp do danych z bazy danych Redis.

@Autowired

RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);

JDBCTemplate

Aby uzyskać dostęp do relacyjnej bazy danych za pomocą JdbcTemplate w aplikacji Spring Boot, musimy dodać zależność Spring Boot Starter JDBC w naszym pliku konfiguracyjnym kompilacji.

Następnie, jeśli @Autowired klasę JdbcTemplate, Spring Boot automatycznie łączy bazę danych i ustawia źródło danych dla obiektu JdbcTemplate.

@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");

Adnotację @Repository należy dodać do pliku klasy. Adnotacja @Repository służy do tworzenia repozytorium bazy danych dla aplikacji Spring Boot.

@Repository
public class ProductServiceDAO {
}

Wiele źródeł danych

Możemy przechowywać „n” źródeł danych w jednej aplikacji Spring Boot. Podany tutaj przykład pokazuje, jak utworzyć więcej niż jedno źródło danych w aplikacji Spring Boot. Teraz dodaj dwa szczegóły konfiguracji źródła danych w pliku właściwości aplikacji.

W przypadku użytkowników plików właściwości dodaj następujące właściwości do pliku application.properties.

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

Użytkownicy Yaml powinni dodać następujące właściwości w pliku application.yml.

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

Teraz utwórz klasę Configuration, aby utworzyć DataSource i JdbcTemplate dla wielu źródeł danych.

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

Następnie automatycznie połącz obiekt JDBCTemplate przy użyciu adnotacji @Qualifier.

@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;

@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;

Jeśli w ścieżce klasy zostanie dodana zależność Spring Boot Security, aplikacja Spring Boot automatycznie wymaga uwierzytelnienia podstawowego dla wszystkich punktów końcowych HTTP. Punkty końcowe „/” i „/ home” nie wymagają żadnego uwierzytelnienia. Wszystkie inne punkty końcowe wymagają uwierzytelnienia.

Aby dodać Spring Boot Security do Twojej aplikacji Spring Boot, musimy dodać zależność Spring Boot Starter Security w naszym pliku konfiguracyjnym kompilacji.

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml.

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Zabezpieczanie aplikacji internetowej

Najpierw utwórz niezabezpieczoną aplikację internetową przy użyciu szablonów Thymeleaf.

Następnie utwórz plik home.html pod src/main/resources/templates informator.

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

Prosty widok /hello zdefiniowane w pliku HTML przy użyciu szablonów Thymeleaf.

Teraz utwórz hello.html pod src/main/resources/templates informator.

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

Teraz musimy skonfigurować kontroler Spring MVC - View dla widoków Home i Hello.

W tym celu utwórz plik konfiguracyjny MVC, który rozszerza WebMvcConfigurerAdapter.

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

Teraz dodaj zależność zabezpieczeń Spring Boot Starter do pliku konfiguracji kompilacji.

Użytkownicy Maven mogą dodać następującą zależność w pliku pom.xml.

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

Użytkownicy Gradle mogą dodać następującą zależność w pliku build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Teraz utwórz plik konfiguracyjny zabezpieczeń sieci Web, który jest używany do zabezpieczania aplikacji w celu uzyskania dostępu do punktów końcowych HTTP przy użyciu podstawowego uwierzytelniania.

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

Teraz utwórz plik login.html pod rozszerzeniem src/main/resources katalogu, aby umożliwić użytkownikowi dostęp do punktu końcowego HTTP za pośrednictwem ekranu logowania.

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

Na koniec zaktualizuj plik hello.html - aby umożliwić użytkownikowi wylogowanie się z aplikacji i wyświetlenie bieżącej nazwy użytkownika, jak pokazano poniżej -

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

Kod dla głównej aplikacji Spring Boot jest podany poniżej -

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

Pełny kod pliku konfiguracyjnego kompilacji znajduje się poniżej.

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

Teraz utwórz wykonywalny plik JAR i uruchom aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

Użytkownicy Mavena mogą użyć polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

Użytkownicy Gradle mogą użyć polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR za pomocą polecenia pokazanego poniżej -

java –jar <JARFILE>

Uderz w adres URL http://localhost:8080/w Twojej przeglądarce internetowej. Możesz zobaczyć dane wyjściowe, jak pokazano.

W tym rozdziale poznasz szczegółowo mechanizmy Spring Boot Security i OAuth2 z JWT.

Serwer autoryzacji

Serwer autoryzacji jest najwyższym komponentem architektonicznym dla bezpieczeństwa Web API. Serwer autoryzacji działa jako centralny punkt autoryzacji, który umożliwia aplikacjom i punktom końcowym HTTP identyfikowanie funkcji aplikacji.

Serwer zasobów

Serwer zasobów to aplikacja, która zapewnia token dostępu klientom w celu uzyskania dostępu do punktów końcowych HTTP serwera zasobów. Jest to zbiór bibliotek, który zawiera punkty końcowe HTTP, zasoby statyczne i dynamiczne strony internetowe.

OAuth2

OAuth2 to struktura autoryzacji, która umożliwia zabezpieczeniom sieci Web aplikacji dostęp do zasobów klienta. Aby zbudować aplikację OAuth2, musimy skupić się na typie przyznania (kod autoryzacji), identyfikatorze klienta i tajnym kluczu klienta.

JWT Token

JWT Token to JSON Web Token, używany do reprezentowania roszczeń zabezpieczonych między dwiema stronami. Możesz dowiedzieć się więcej o tokenie JWT na www.jwt.io/ .

Teraz zamierzamy zbudować aplikację OAuth2, która umożliwia korzystanie z serwera autoryzacji, serwera zasobów za pomocą tokena JWT.

Możesz wykonać następujące kroki, aby zaimplementować Spring Boot Security z tokenem JWT, uzyskując dostęp do bazy danych.

Najpierw musimy dodać następujące zależności w naszym pliku konfiguracyjnym kompilacji.

Użytkownicy Maven mogą dodawać następujące zależności w pliku pom.xml.

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

Użytkownicy Gradle mogą dodać następujące zależności w pliku build.gradle.

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

gdzie,

• Spring Boot Starter Security - Implementuje Spring Security

• Spring Security OAuth2 - Implementuje strukturę OAUTH2, aby włączyć serwer autoryzacji i serwer zasobów.

• Spring Security JWT - Generuje token JWT dla bezpieczeństwa WWW

• Spring Boot Starter JDBC - Uzyskuje dostęp do bazy danych, aby upewnić się, że użytkownik jest dostępny, czy nie.

• Spring Boot Starter Web - Zapisuje punkty końcowe HTTP.

• H2 Database - Przechowuje informacje o użytkowniku do uwierzytelnienia i autoryzacji.

Pełny plik konfiguracyjny kompilacji znajduje się poniżej.

<?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")  
}

Teraz w głównej aplikacji Spring Boot dodaj adnotację @EnableAuthorizationServer i @EnableResourceServer, aby działały jako serwer uwierzytelniania i serwer zasobów w tej samej aplikacji.

Możesz również użyć poniższego kodu, aby napisać prosty punkt końcowy HTTP, aby uzyskać dostęp do interfejsu API z Spring Security za pomocą tokenu JWT.

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

Użyj poniższego kodu, aby zdefiniować klasę POJO do przechowywania informacji o użytkowniku na potrzeby uwierzytelniania.

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

Teraz użyj następującego kodu i zdefiniuj klasę CustomUser, która rozszerza klasę org.springframework.security.core.userdetails.User na potrzeby uwierzytelniania Spring Boot.

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

Można utworzyć klasę @Repository, aby odczytać informacje o użytkowniku z bazy danych i wysłać je do usługi użytkownika niestandardowego, a także dodać przyznane uprawnienie „ROLE_SYSTEMADMIN”.

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

Możesz utworzyć klasę usługi szczegółów użytkownika niestandardowego, która rozszerza klasę org.springframework.security.core.userdetails.UserDetailsService, aby wywołać klasę repozytorium DAO, jak pokazano.

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

Następnie utwórz klasę @configuration, aby włączyć zabezpieczenia sieci Web, zdefiniuj koder hasła (BCryptPasswordEncoder) i zdefiniuj komponent bean AuthenticationManager. Klasa konfiguracji zabezpieczeń powinna rozszerzać klasę WebSecurityConfigurerAdapter.

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

Teraz zdefiniuj klasę konfiguracji OAuth2, aby dodać identyfikator klienta, klucz tajny klienta, zdefiniuj JwtAccessTokenConverter, klucz prywatny i klucz publiczny dla klucza podpisującego tokenu i klucza weryfikatora, a następnie skonfiguruj ClientDetailsServiceConfigurer pod kątem ważności tokenu z zakresami.

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

   }
}

Teraz utwórz klucz prywatny i klucz publiczny za pomocą openssl.

Możesz użyć następujących poleceń do wygenerowania klucza prywatnego.

openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem

Możesz użyć Do generowania klucza publicznego użyj poniższych poleceń.

openssl rsa -in jwt.pem -pubout

W przypadku wersji Spring Boot późniejszej niż 1.5 dodaj poniższą właściwość w pliku application.properties, aby zdefiniować kolejność filtrów zasobów OAuth2.

security.oauth2.resource.filter-order=3

Użytkownicy plików YAML mogą dodać poniższą właściwość w pliku YAML.

security:
   oauth2:
      resource:
         filter-order: 3

Teraz utwórz plik schema.sql i data.sql w zasobach classpath src/main/resources/directory aby połączyć aplikację z bazą danych H2.

Plik schema.sql jest taki, jak pokazano -

CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));

Plik data.sql jest taki, jak pokazano -

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 - Hasło powinno być przechowywane w tabeli bazy danych w formacie Bcrypt Encoder.

Możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następujących poleceń Maven lub Gradle.

W przypadku Mavena możesz użyć polecenia podanego poniżej -

mvn clean install

Po „BUILD SUCCESS” można znaleźć plik JAR w katalogu docelowym.

W przypadku Gradle możesz użyć polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Teraz uruchom plik JAR, używając polecenia pokazanego tutaj -

java –jar <JARFILE>

Aplikacja jest uruchamiana na porcie Tomcat 8080.

Teraz naciśnij adres URL metody POST za pośrednictwem POSTMAN, aby uzyskać token OAUTH2.

http://localhost:8080/oauth/token

Teraz dodaj nagłówki żądań w następujący sposób -

• Authorization - Uwierzytelnianie podstawowe za pomocą identyfikatora klienta i tajnego klucza klienta.

• Content Type - application / x-www-form-urlencoded

Teraz dodaj parametry żądania w następujący sposób -

• grant_type = hasło
• nazwa użytkownika = twoja nazwa użytkownika
• hasło = twoje hasło

Teraz naciśnij API i uzyskaj access_token, jak pokazano -

Teraz naciśnij interfejs API serwera zasobów z tokenem dostępu okaziciela w nagłówku żądania, jak pokazano.

Następnie możesz zobaczyć dane wyjściowe, jak pokazano poniżej -

Google Cloud Platform zapewnia usługi przetwarzania w chmurze, które uruchamiają aplikację Spring Boot w środowisku chmury. W tym rozdziale zobaczymy, jak wdrożyć aplikację Spring Boot na platformie silnika aplikacji GCP.

Najpierw pobierz aplikację Gradle Build Spring Boot ze strony Spring Initializer www.start.spring.io . Obserwuj poniższy zrzut ekranu.

Teraz w pliku build.gradle dodaj wtyczkę Google Cloud appengine i zależność appengine classpath.

Kod dla pliku build.gradle jest podany poniżej -

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

Teraz napisz prosty punkt końcowy HTTP i zwróci sukces ciągu, jak pokazano -

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

Następnie dodaj plik app.yml do katalogu src / main / appengine, jak pokazano -

runtime: java
env: flex

handlers:
- url: /.*
   script: this field is required, but ignored

Teraz przejdź do konsoli Google Cloud i kliknij Aktywuj powłokę chmury Google u góry strony.

Teraz przenieś swoje pliki źródłowe i plik Gradle do katalogu domowego komputera w chmurze Google za pomocą powłoki Google Cloud Shell.

Teraz wykonaj polecenie gradle appengineDeploy, a aplikacja zostanie wdrożona w Google Cloud appengine.

Note - GCP powinno mieć włączone rozliczenia i przed wdrożeniem aplikacji w appengine należy utworzyć platformę appengine w GCP.

Wdrożenie aplikacji na platformie GCP appengine zajmie kilka minut.

Po udanej kompilacji możesz zobaczyć adres URL usługi w oknie konsoli.

Teraz naciśnij adres URL usługi i zobacz dane wyjściowe.

Google Cloud SQL

Aby połączyć Google Cloud SQL z aplikacją Spring Boot, dodaj następujące właściwości do pliku application.properties.

Format adresu URL JDBC

jdbc:mysql://google/<DATABASE-NAME>?cloudSqlInstance = <GOOGLE_CLOUD_SQL_INSTANCE_NAME> &socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = <USERNAME>&password = <PASSWORD>

Note - Aplikacja Spring Boot i Google Cloud SQL powinny znajdować się w tym samym projekcie GCP.

Plik application.properties znajduje się poniżej.

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

Użytkownicy pliku YAML mogą dodawać poniższe właściwości do pliku application.yml.

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

W tym rozdziale zobaczymy, jak dodać logowanie Google OAuth2 przy użyciu aplikacji Spring Boot z kompilacją Gradle.

Najpierw dodaj zależność zabezpieczeń Spring Boot OAuth2 do pliku konfiguracji kompilacji, a plik konfiguracji kompilacji znajduje się poniżej.

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

Teraz dodaj punkt końcowy HTTP, aby odczytać nazwę użytkownika z Google po uwierzytelnieniu przez Spring Boot w głównym pliku klasy aplikacji Spring Boot, jak podano poniżej -

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

Teraz napisz plik konfiguracyjny, aby włączyć OAuth2SSO dla bezpieczeństwa sieci i usuń uwierzytelnianie dla pliku index.html, jak pokazano -

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

Następnie dodaj plik index.html pod statycznymi zasobami i dodaj link do przekierowania do punktu końcowego HTTP użytkownika, aby odczytać dane główne użytkownika Google, jak pokazano poniżej -

<!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 - W konsoli Google Cloud - Włącz usługi Gmail, usługi Analytics i interfejsy API usług Google+.

Następnie przejdź do sekcji Poświadczenia, utwórz dane logowania i wybierz Identyfikator klienta OAuth.

Następnie podaj nazwę produktu na ekranie akceptacji OAuth2.

Następnie wybierz typ aplikacji jako „aplikacja internetowa”, podaj źródła autoryzowanego kodu JavaScript i identyfikatory URI autoryzowanego przekierowania.

Teraz tworzony jest identyfikator klienta OAuth2 i klucz tajny klienta.

Następnie dodaj identyfikator klienta i klucz tajny klienta w pliku właściwości aplikacji.

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

Teraz możesz utworzyć wykonywalny plik JAR i uruchomić aplikację Spring Boot za pomocą następującego polecenia Gradle.

W przypadku Gradle możesz użyć polecenia, jak pokazano -

gradle clean build

Po „BUILD SUCCESSFUL” możesz znaleźć plik JAR w katalogu build / libs.

Uruchom plik JAR za pomocą komendy java –jar <JARFILE> i aplikacja zostanie uruchomiona na porcie Tomcat 8080.

Teraz kliknij adres URL http://localhost:8080/ i kliknij link Google Login.

Przekieruje do ekranu logowania Google i poda dane logowania do Gmaila.

Jeśli logowanie się powiedzie, otrzymamy główny obiekt użytkownika Gmaila.