Spring Boot - Guida rapida
Spring Boot è un framework basato su Java open source utilizzato per creare un micro servizio. È sviluppato da Pivotal Team e viene utilizzato per creare applicazioni per molle indipendenti e pronte per la produzione. Questo capitolo ti fornirà un'introduzione a Spring Boot e ti familiarizzerà con i suoi concetti di base.
Cos'è Micro Service?
Micro Service è un'architettura che consente agli sviluppatori di sviluppare e distribuire servizi in modo indipendente. Ogni servizio in esecuzione ha il proprio processo e questo raggiunge il modello leggero per supportare le applicazioni aziendali.
Vantaggi
Micro services offre i seguenti vantaggi ai suoi sviluppatori:
- Facile implementazione
- Scalabilità semplice
- Compatibile con i contenitori
- Configurazione minima
- Tempi di produzione ridotti
Cos'è Spring Boot?
Spring Boot fornisce una buona piattaforma per gli sviluppatori Java per sviluppare un'applicazione spring autonoma e di livello di produzione che puoi just run. Puoi iniziare con configurazioni minime senza la necessità di un'intera configurazione di Spring.
Vantaggi
Spring Boot offre i seguenti vantaggi ai suoi sviluppatori:
- Facile da capire e sviluppare applicazioni a molla
- Aumenta la produttività
- Riduce i tempi di sviluppo
Obiettivi
Spring Boot è progettato con i seguenti obiettivi:
- Per evitare complesse configurazioni XML in primavera
- Sviluppare applicazioni Spring pronte per la produzione in modo più semplice
- Per ridurre i tempi di sviluppo ed eseguire l'applicazione in modo indipendente
- Offri un modo più semplice per iniziare con l'applicazione
Perché Spring Boot?
Puoi scegliere Spring Boot per le caratteristiche e i vantaggi che offre come indicato qui -
Fornisce un modo flessibile per configurare Java Beans, configurazioni XML e transazioni di database.
Fornisce una potente elaborazione batch e gestisce gli endpoint REST.
In Spring Boot, tutto è configurato automaticamente; non sono necessarie configurazioni manuali.
Offre un'applicazione a molla basata su annotazioni
Facilita la gestione delle dipendenze
Include il contenitore servlet incorporato
Come funziona?
Spring Boot configura automaticamente l'applicazione in base alle dipendenze aggiunte al progetto utilizzando @EnableAutoConfigurationannotazione. Ad esempio, se il database MySQL si trova nel percorso classi, ma non è stata configurata alcuna connessione al database, Spring Boot configura automaticamente un database in memoria.
Il punto di ingresso dell'applicazione di avvio primaverile è la classe contiene @SpringBootApplication annotazione e metodo principale.
Spring Boot analizza automaticamente tutti i componenti inclusi nel progetto utilizzando @ComponentScan annotazione.
Avviatori Spring Boot
Gestire la gestione delle dipendenze è un compito difficile per i grandi progetti. Spring Boot risolve questo problema fornendo una serie di dipendenze per comodità degli sviluppatori.
Ad esempio, se si desidera utilizzare Spring e JPA per l'accesso al database, è sufficiente includere spring-boot-starter-data-jpa dipendenza nel tuo progetto.
Notare che tutti gli avviatori Spring Boot seguono lo stesso schema di denominazione spring-boot-starter- *, dove * indica che si tratta di un tipo di applicazione.
Esempi
Guarda i seguenti avviatori Spring Boot spiegati di seguito per una migliore comprensione:
Spring Boot Starter Actuator dependencyviene utilizzato per monitorare e gestire la tua applicazione. Il suo codice è mostrato di seguito -
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
Spring Boot Starter Security dependencyviene utilizzato per Spring Security. Il suo codice è mostrato di seguito -
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
Spring Boot Starter web dependencyviene utilizzato per scrivere un Rest Endpoint. Il suo codice è mostrato di seguito -
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Spring Boot Starter Thyme Leaf dependencyviene utilizzato per creare un'applicazione web. Il suo codice è mostrato di seguito -
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
Spring Boot Starter Test dependencyviene utilizzato per scrivere casi di test. Il suo codice è mostrato di seguito -
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
Configurazione automatica
Spring Boot Auto Configuration configura automaticamente l'applicazione Spring in base alle dipendenze JAR aggiunte nel progetto. Ad esempio, se il database MySQL si trova nel percorso della classe, ma non è stata configurata alcuna connessione al database, Spring Boot configura automaticamente un database in memoria.
A tale scopo, è necessario aggiungere @EnableAutoConfiguration annotazione o @SpringBootApplicationannotazione al file della classe principale. Quindi, l'applicazione Spring Boot verrà configurata automaticamente.
Osservare il seguente codice per una migliore comprensione:
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);
}
}
Applicazione Spring Boot
Il punto di ingresso dell'applicazione Spring Boot è che la classe contiene @SpringBootApplicationannotazione. Questa classe dovrebbe avere il metodo principale per eseguire l'applicazione Spring Boot.@SpringBootApplication l'annotazione include la configurazione automatica, la scansione dei componenti e la configurazione Spring Boot.
Se hai aggiunto @SpringBootApplication annotazione alla classe, non è necessario aggiungere il file @EnableAutoConfiguration, @ComponentScan e @SpringBootConfigurationannotazione. Il@SpringBootApplication l'annotazione include tutte le altre annotazioni.
Osservare il seguente codice per una migliore comprensione:
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);
}
}
Scansione dei componenti
L'applicazione Spring Boot analizza tutti i bean e le dichiarazioni dei pacchetti quando l'applicazione viene inizializzata. Devi aggiungere il file@ComponentScan annotazione per il file di classe per scansionare i componenti aggiunti al progetto.
Osservare il seguente codice per una migliore comprensione:
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);
}
}
Questo capitolo ti insegnerà come creare un'applicazione Spring Boot utilizzando Maven e Gradle.
Prerequisiti
Il tuo sistema deve avere i seguenti requisiti minimi per creare un'applicazione Spring Boot:
- Java 7
- Maven 3.2
- Gradle 2.5
CLI di Spring Boot
Spring Boot CLI è uno strumento a riga di comando e ci consente di eseguire gli script Groovy. Questo è il modo più semplice per creare un'applicazione Spring Boot utilizzando l'interfaccia della riga di comando di Spring Boot. È possibile creare, eseguire e testare l'applicazione nel prompt dei comandi stesso.
Questa sezione spiega i passaggi coinvolti nell'installazione manuale della CLI di Spring Boot. Per ulteriore assistenza, puoi utilizzare il seguente collegamento:https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot
È inoltre possibile scaricare la distribuzione della CLI di Spring dal repository di Spring Software all'indirizzo: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation
Per l'installazione manuale, è necessario utilizzare le seguenti due cartelle:
spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip
spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz
Dopo il download, decomprimere il file di archivio e seguire i passaggi indicati nel file install.txt. Non che non richieda alcuna configurazione dell'ambiente.
In Windows, vai alla CLI di Spring Boot bin directory nel prompt dei comandi ed eseguire il comando spring –-versionper assicurarsi che Spring CLI sia installato correttamente. Dopo aver eseguito il comando, è possibile visualizzare la versione della CLI di primavera come mostrato di seguito:
Esegui Hello World con Groovy
Crea un semplice file groovy che contiene lo script Rest Endpoint ed esegui il file groovy con la CLI di avvio a molla. Rispettare il codice mostrato qui per questo scopo -
@Controller
class Example {
@RequestMapping("/")
@ResponseBody
public String hello() {
"Hello Spring Boot"
}
}
Ora salva il file groovy con il nome hello.groovy. Nota che in questo esempio, abbiamo salvato il file groovy all'interno della CLI di Spring Bootbindirectory. Ora esegui l'applicazione utilizzando il comandospring run hello.groovy come mostrato nello screenshot riportato di seguito -
Una volta eseguito il file groovy, le dipendenze richieste verranno scaricate automaticamente e verrà avviata l'applicazione nella porta Tomcat 8080 come mostrato nello screenshot riportato di seguito -
Una volta avviato Tomcat, vai al browser web e premi l'URL http://localhost:8080/ e puoi vedere l'output come mostrato.
Questo capitolo spiegherà come eseguire il bootstrap su un'applicazione Spring Boot.
Inizializzatore di primavera
Uno dei modi per avviare un'applicazione Spring Boot è usare Spring Initializer. Per fare ciò, dovrai visitare la pagina web di Spring Initializer www.start.spring.io e scegliere la build, la versione di Spring Boot e la piattaforma. Inoltre, è necessario fornire un gruppo, un artefatto e le dipendenze richieste per eseguire l'applicazione.
Osserva lo screenshot seguente che mostra un esempio in cui abbiamo aggiunto il file spring-boot-starter-web dipendenza per scrivere endpoint REST.
Dopo aver fornito gruppo, artefatto, dipendenze, progetto di compilazione, piattaforma e versione, fare clic su Generate Projectpulsante. Il file zip verrà scaricato e i file verranno estratti.
Questa sezione spiega gli esempi utilizzando sia Maven che Gradle.
Esperto di
Dopo aver scaricato il progetto, decomprimere il file. Adesso tuopom.xml il file appare come mostrato di seguito -
<?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
Una volta scaricato il progetto, decomprimere il file. Adesso tuobuild.gradle il file appare come mostrato di seguito -
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')
}
Dipendenze del percorso di classe
Spring Boot fornisce una serie di Startersper aggiungere i vasi nel nostro percorso di classe. Ad esempio, per scrivere un Rest Endpoint, dobbiamo aggiungere il filespring-boot-starter-webdipendenza nel nostro percorso di classe. Rispettare i codici riportati di seguito per una migliore comprensione:
Dipendenza da Maven
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
Gradle dipendenza
dependencies {
compile('org.springframework.boot:spring-boot-starter-web')
}
Metodo principale
Il metodo principale dovrebbe essere scrivere la classe Spring Boot Application. Questa classe dovrebbe essere annotata con@SpringBootApplication. Questo è il punto di ingresso dell'applicazione Spring Boot da avviare. Puoi trovare il file della classe principale sottosrc/java/main directory con il pacchetto predefinito.
In questo esempio, il file di classe principale si trova in src/java/main directory con il pacchetto predefinito com.tutorialspoint.demo. Osservare il codice mostrato qui per una migliore comprensione -
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);
}
}
Scrivi un endpoint di riposo
Per scrivere un semplice Hello World Rest Endpoint nel file di classe principale dell'applicazione Spring Boot stesso, seguire i passaggi mostrati di seguito:
In primo luogo, aggiungi il file @RestController annotazione in cima alla classe.
Ora scrivi un metodo URI di richiesta con @RequestMapping annotazione.
Quindi, il metodo URI della richiesta dovrebbe restituire il file Hello World corda.
Ora, il file di classe dell'applicazione Spring Boot principale apparirà come mostrato nel codice riportato di seguito:
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";
}
}
Crea un JAR eseguibile
Creiamo un file JAR eseguibile per eseguire l'applicazione Spring Boot utilizzando i comandi Maven e Gradle nel prompt dei comandi come mostrato di seguito:
Utilizzare il comando Maven mvn clean install come mostrato di seguito -
Dopo aver eseguito il comando, puoi vedere il file BUILD SUCCESS messaggio al prompt dei comandi come mostrato di seguito -
Usa il comando Gradle gradle clean build come mostrato di seguito -
Dopo aver eseguito il comando, puoi vedere il file BUILD SUCCESSFUL messaggio nel prompt dei comandi come mostrato di seguito -
Esegui Hello World con Java
Dopo aver creato un file JAR eseguibile, puoi trovarlo nelle seguenti directory.
Per Maven, puoi trovare il file JAR nella directory di destinazione come mostrato di seguito -
Per Gradle, puoi trovare il file JAR sotto build/libs directory come mostrato di seguito -
Ora, esegui il file JAR usando il comando java –jar <JARFILE>. Si noti che nell'esempio precedente, il file JAR è denominatodemo-0.0.1-SNAPSHOT.jar
Una volta eseguito il file jar, puoi vedere l'output nella finestra della console come mostrato di seguito:
Ora, guarda la console, Tomcat è stato avviato sulla porta 8080 (http). Ora vai al browser web e premi l'URLhttp://localhost:8080/ e puoi vedere l'output come mostrato di seguito -
Utilizzando l'applicazione Spring Boot, possiamo creare un file war da distribuire nel server web. In questo capitolo imparerai come creare un file WAR e distribuire l'applicazione Spring Boot nel server Web Tomcat.
Inizializzatore servlet Spring Boot
Il modo tradizionale di distribuzione è creare l'applicazione Spring Boot @SpringBootApplication classe estendere la SpringBootServletInitializerclasse. Il file di classe Spring Boot Servlet Initializer consente di configurare l'applicazione quando viene avviata utilizzando Servlet Container.
Di seguito è riportato il codice per il file di classe dell'applicazione Spring Boot per la distribuzione del file JAR:
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);
}
}
Dobbiamo estendere la classe SpringBootServletInitializerper supportare la distribuzione di file WAR. Il codice del file di classe dell'applicazione Spring Boot è fornito di seguito:
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);
}
}
Impostazione della classe principale
In Spring Boot, dobbiamo menzionare la classe principale che dovrebbe iniziare nel file di build. A tale scopo, puoi utilizzare le seguenti parti di codice:
Per Maven, aggiungi la classe iniziale in pom.xml proprietà come mostrato di seguito -
<start-class>com.tutorialspoint.demo.DemoApplication</start-class>
Per Gradle, aggiungi il nome della classe principale in build.gradle come mostrato di seguito -
mainClassName="com.tutorialspoint.demo.DemoApplication"
Aggiorna la confezione di JAR in WAR
Dobbiamo aggiornare il JAR di imballaggio in WAR utilizzando le seguenti parti di codice:
Per Maven, aggiungi la confezione come WAR in pom.xml come mostrato di seguito -
<packaging>war</packaging>
Per Gradle, aggiungi il plugin dell'applicazione e il plugin war nel file build.gradle come mostrato di seguito -
apply plugin: ‘war’
apply plugin: ‘application’
Ora, scriviamo un semplice Rest Endpoint per restituire la stringa "Hello World from Tomcat". Per scrivere un Rest Endpoint, dobbiamo aggiungere la dipendenza di Web Starter Spring Boot nel nostro file di build.
Per Maven, aggiungi la dipendenza di avvio di Spring Boot in pom.xml utilizzando il codice come mostrato di seguito -
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Per Gradle, aggiungi la dipendenza di avvio di Spring Boot in build.gradle utilizzando il codice come mostrato di seguito -
dependencies {
compile('org.springframework.boot:spring-boot-starter-web')
}
Ora, scrivi un semplice Rest Endpoint nel file di classe Spring Boot Application usando il codice come mostrato di seguito -
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";
}
}
Creazione del pacchetto dell'applicazione
Ora, crea un file WAR da distribuire nel server Tomcat utilizzando i comandi Maven e Gradle per impacchettare l'applicazione come indicato di seguito:
Per Maven, usa il comando mvn packageper confezionare la tua applicazione. Quindi, verrà creato il file WAR e puoi trovarlo nella directory di destinazione come mostrato negli screenshot riportati di seguito -
Per Gradle, usa il comando gradle clean buildper confezionare la tua applicazione. Quindi, il tuo file WAR verrà creato e puoi trovarlo sottobuild/libsdirectory. Osserva gli screenshot qui forniti per una migliore comprensione -
Distribuisci in Tomcat
Ora, esegui il server Tomcat e distribuisci il file WAR in webappsdirectory. Osserva gli screenshot mostrati qui per una migliore comprensione -
Dopo la corretta distribuzione, premi l'URL nel tuo browser web http://localhost:8080/demo-0.0.1-SNAPSHOT/ e osserva che l'output apparirà come mostrato nella schermata riportata di seguito -
Il codice completo per questo scopo è fornito di seguito.
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')
}
Di seguito è riportato il codice per il file di classe dell'applicazione Spring Boot principale:
package com.tutorialspoint.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class DemoApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(DemoApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@RequestMapping(value = "/")
public String hello() {
return "Hello World from Tomcat";
}
}
In Spring Boot, la scelta di un sistema di compilazione è un'attività importante. Consigliamo Maven o Gradle in quanto forniscono un buon supporto per la gestione delle dipendenze. Spring non supporta bene altri sistemi di compilazione.
Gestione delle dipendenze
Il team di Spring Boot fornisce un elenco di dipendenze per supportare la versione di Spring Boot per ogni suo rilascio. Non è necessario fornire una versione per le dipendenze nel file di configurazione della build. Spring Boot configura automaticamente la versione delle dipendenze in base al rilascio. Ricorda che quando aggiorni la versione Spring Boot, anche le dipendenze verranno aggiornate automaticamente.
Note- Se si desidera specificare la versione per la dipendenza, è possibile specificarla nel file di configurazione. Tuttavia, il team di Spring Boot consiglia vivamente che non è necessario specificare la versione per la dipendenza.
Dipendenza da Maven
Per la configurazione di Maven, dovremmo ereditare il progetto padre Spring Boot Starter per gestire le dipendenze Spring Boot Starters. Per questo, semplicemente possiamo ereditare il genitore iniziale nel nostro filepom.xml file come mostrato di seguito.
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.8.RELEASE</version>
</parent>
Dobbiamo specificare il numero di versione per la dipendenza Spring Boot Parent Starter. Quindi, per altre dipendenze di avvio, non è necessario specificare il numero di versione di Spring Boot. Rispettare il codice riportato di seguito -
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
Gradle Dependency
Possiamo importare le dipendenze di Spring Boot Starters direttamente in build.gradlefile. Non abbiamo bisogno di Spring Boot per avviare la dipendenza dei genitori come Maven per Gradle. Rispettare il codice riportato di seguito -
buildscript {
ext {
springBootVersion = '1.5.8.RELEASE'
}
repositories {
mavenCentral()
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
}
}
Allo stesso modo, in Gradle, non è necessario specificare il numero di versione di Spring Boot per le dipendenze. Spring Boot configura automaticamente la dipendenza in base alla versione.
dependencies {
compile('org.springframework.boot:spring-boot-starter-web')
}
Spring Boot non ha alcun layout di codice con cui lavorare. Tuttavia, ci sono alcune best practice che ci aiuteranno. Questo capitolo ne parla in dettaglio.
Pacchetto predefinito
Una classe che non ha alcuna dichiarazione di pacchetto è considerata come un file default package. Notare che generalmente una dichiarazione di pacchetto predefinita non è consigliata. Spring Boot causerà problemi come il malfunzionamento della configurazione automatica o della scansione dei componenti, quando si utilizza il pacchetto predefinito.
Note- La convenzione di denominazione consigliata da Java per la dichiarazione del pacchetto è il nome di dominio invertito. Ad esempio:com.tutorialspoint.myproject
Layout tipico
Il layout tipico dell'applicazione Spring Boot è mostrato nell'immagine riportata di seguito:
Il file Application.java dovrebbe dichiarare il metodo principale insieme a @SpringBootApplication. Osservare il codice fornito di seguito per una migliore comprensione -
package com.tutorialspoint.myproject;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}
In Spring Boot, possiamo usare Spring Framework per definire i nostri bean e la loro iniezione di dipendenza. Il@ComponentScan l'annotazione viene utilizzata per trovare i bean e il corrispondente iniettato con @Autowired annotazione.
Se hai seguito il layout tipico di Spring Boot, non è necessario specificare alcun argomento per @ComponentScanannotazione. Tutti i file di classe dei componenti vengono registrati automaticamente con Spring Beans.
L'esempio seguente fornisce un'idea sul cablaggio automatico dell'oggetto Rest Template e sulla creazione di un Bean per lo stesso -
@Bean
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
Il codice seguente mostra il codice per l'oggetto Rest Template cablato automaticamente e l'oggetto di creazione Bean nel file di classe principale dell'applicazione Spring Boot -
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();
}
}
Le interfacce Application Runner e Command Line Runner consentono di eseguire il codice dopo l'avvio dell'applicazione Spring Boot. È possibile utilizzare queste interfacce per eseguire qualsiasi azione subito dopo l'avvio dell'applicazione. Questo capitolo ne parla in dettaglio.
Application Runner
Application Runner è un'interfaccia utilizzata per eseguire il codice dopo l'avvio dell'applicazione Spring Boot. L'esempio fornito di seguito mostra come implementare l'interfaccia Application Runner sul file di classe principale.
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");
}
}
Ora, se osservi la finestra della console di seguito Hello World from Application Runner, l'istruzione println viene eseguita dopo l'avvio di Tomcat. Il seguente screenshot è pertinente?
Command Line Runner
Command Line Runner è un'interfaccia. Viene utilizzato per eseguire il codice dopo l'avvio dell'applicazione Spring Boot. L'esempio riportato di seguito mostra come implementare l'interfaccia Runner della riga di comando sul file di classe principale.
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");
}
}
Guarda la finestra della console sotto "Hello world from Command Line Runner" L'istruzione println viene eseguita dopo l'avvio di Tomcat.
Le proprietà dell'applicazione ci aiutano a lavorare in ambienti diversi. In questo capitolo imparerai come configurare e specificare le proprietà di un'applicazione Spring Boot.
Proprietà della riga di comando
L'applicazione Spring Boot converte le proprietà della riga di comando nelle proprietà dell'ambiente Spring Boot. Le proprietà della riga di comando hanno la precedenza sulle altre origini di proprietà. Per impostazione predefinita, Spring Boot utilizza il numero di porta 8080 per avviare Tomcat. Impariamo come modificare il numero di porta utilizzando le proprietà della riga di comando.
Step 1 - Dopo aver creato un file JAR eseguibile, eseguirlo utilizzando il comando java –jar <JARFILE>.
Step 2 - Utilizzare il comando fornito nella schermata riportata di seguito per modificare il numero di porta per l'applicazione Spring Boot utilizzando le proprietà della riga di comando.
Note - È possibile fornire più di una proprietà dell'applicazione utilizzando il delimitatore -.
File delle proprietà
I file delle proprietà vengono utilizzati per mantenere il numero "N" di proprietà in un singolo file per eseguire l'applicazione in un ambiente diverso. In Spring Boot, le proprietà vengono mantenute inapplication.properties file sotto il classpath.
Il file application.properties si trova in src/main/resourcesdirectory. Il codice per l'esempioapplication.properties file è dato di seguito -
server.port = 9090
spring.application.name = demoservice
Notare che nel codice mostrato sopra il servizio demo dell'applicazione Spring Boot si avvia sulla porta 9090.
File YAML
Spring Boot supporta configurazioni di proprietà basate su YAML per eseguire l'applicazione. Invece diapplication.properties, possiamo usare application.ymlfile. Anche questo file YAML dovrebbe essere mantenuto all'interno del classpath. Il campioneapplication.yml file è dato di seguito -
spring:
application:
name: demoservice
server:
port: 9090
Proprietà esternalizzate
Invece di mantenere il file delle proprietà sotto classpath, possiamo mantenere le proprietà in una posizione o un percorso diversi. Durante l'esecuzione del file JAR, possiamo specificare il percorso del file delle proprietà. È possibile utilizzare il seguente comando per specificare la posizione del file delle proprietà durante l'esecuzione del JAR:
-Dspring.config.location = C:\application.properties
Uso dell'annotazione @Value
L'annotazione @Value viene utilizzata per leggere il valore della proprietà dell'ambiente o dell'applicazione nel codice Java. La sintassi per leggere il valore della proprietà è mostrata di seguito:
@Value("${property_key_name}")
Guarda il seguente esempio che mostra la sintassi per leggere il file spring.application.name valore della proprietà nella variabile Java utilizzando l'annotazione @Value.
@Value("${spring.application.name}")
Osservare il codice fornito di seguito per una migliore comprensione -
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 - Se la proprietà non viene trovata durante l'esecuzione dell'applicazione, Spring Boot genera l'eccezione Argomento Illegal come Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}".
Per risolvere il problema del segnaposto, possiamo impostare il valore predefinito per la proprietà utilizzando la sintassi indicata di seguito:
@Value("${property_key_name:default_value}")
@Value("${spring.application.name:demoservice}")
Profilo attivo Spring Boot
Spring Boot supporta proprietà diverse in base al profilo attivo Spring. Ad esempio, possiamo mantenere due file separati per lo sviluppo e la produzione per eseguire l'applicazione Spring Boot.
Profilo attivo della molla in application.properties
Cerchiamo di capire come avere il profilo Spring attivo in application.properties. Per impostazione predefinita, application. verranno utilizzate per eseguire l'applicazione Spring Boot. Se desideri utilizzare proprietà basate sul profilo, possiamo mantenere un file delle proprietà separato per ciascun profilo come mostrato di seguito:
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
Durante l'esecuzione del file JAR, è necessario specificare il profilo attivo della molla in base a ciascun file delle proprietà. Per impostazione predefinita, l'applicazione Spring Boot utilizza il file application.properties. Di seguito viene mostrato il comando per impostare il profilo attivo della molla:
È possibile visualizzare il nome del profilo attivo nel registro della console come mostrato di seguito:
2017-11-26 08:13:16.322 INFO 14028 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: dev
Ora, Tomcat è stato avviato sulla porta 9090 (http) come mostrato di seguito -
2017-11-26 08:13:20.185 INFO 14028 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer :
Tomcat started on port(s): 9090 (http)
È possibile impostare il profilo attivo di produzione come mostrato di seguito:
È possibile visualizzare il nome del profilo attivo nel registro della console come mostrato di seguito:
2017-11-26 08:13:16.322 INFO 14028 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: prod
Ora, Tomcat è stato avviato sulla porta 4431 (http) come mostrato di seguito -
2017-11-26 08:13:20.185 INFO 14028 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer :
Tomcat started on port(s): 4431 (http)
Profilo attivo a molla per application.yml
Cerchiamo di capire come mantenere attivo il profilo Spring per application.yml. Possiamo mantenere le proprietà del profilo attivo Spring nel singoloapplication.ymlfile. Non è necessario utilizzare il file separato come application.properties.
Quello che segue è un codice di esempio per mantenere i profili attivi Spring nel file application.yml. Notare che il delimitatore (---) viene utilizzato per separare ogni profilo nel file 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
Di seguito viene fornito il comando per impostare il profilo attivo di sviluppo:
È possibile visualizzare il nome del profilo attivo nel registro della console come mostrato di seguito:
2017-11-26 08:41:37.202 INFO 14104 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: dev
Ora Tomcat è stato avviato sulla porta 9090 (http) come mostrato di seguito -
2017-11-26 08:41:46.650 INFO 14104 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer :
Tomcat started on port(s): 9090 (http)
Di seguito il comando per impostare il profilo attivo di Produzione:
È possibile visualizzare il nome del profilo attivo nel registro della console come mostrato di seguito:
2017-11-26 08:43:10.743 INFO 13400 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: prod
Questo avvierà Tomcat sulla porta 4431 (http) come mostrato di seguito:
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 utilizza la registrazione di Apache Commons per tutte le registrazioni interne. Le configurazioni predefinite di Spring Boot forniscono un supporto per l'uso di Java Util Logging, Log4j2 e Logback. Usandoli, possiamo configurare la registrazione della console così come la registrazione dei file.
Se utilizzi Spring Boot Starter, Logback fornirà un buon supporto per la registrazione. Inoltre, Logback fornisce anche un buon supporto per Common Logging, Util Logging, Log4J e SLF4J.
Formato registro
Il formato predefinito del registro Spring Boot è mostrato nella schermata riportata di seguito.
che ti fornisce le seguenti informazioni:
Date e Time che fornisce la data e l'ora del registro
Log level mostra INFO, ERRORE o AVVISO
Process ID
Il --- che è un separatore
Thread name è racchiuso tra parentesi quadre []
Logger Name che mostra il nome della classe di origine
Il messaggio di registro
Output del registro della console
I messaggi di registro predefiniti verranno stampati nella finestra della console. Per impostazione predefinita, i messaggi di registro "INFO", "ERROR" e "WARN" verranno stampati nel file di registro.
Se devi abilitare il log del livello di debug, aggiungi il flag di debug all'avvio dell'applicazione utilizzando il comando mostrato di seguito -
java –jar demo.jar --debug
Puoi anche aggiungere la modalità di debug al tuo file application.properties come mostrato qui -
debug = true
Output registro file
Per impostazione predefinita, tutti i registri verranno stampati nella finestra della console e non nei file. Se vuoi stampare i log in un file, devi impostare la proprietàlogging.file o logging.path nel file application.properties.
È possibile specificare il percorso del file di registro utilizzando la proprietà mostrata di seguito. Notare che il nome del file di registro è spring.log.
logging.path = /var/tmp/
È possibile specificare il nome del file di registro utilizzando la proprietà mostrata di seguito:
logging.file = /var/tmp/mylog.log
Note - i file ruoteranno automaticamente dopo aver raggiunto la dimensione di 10 MB.
Livelli di registro
Spring Boot supporta tutti i livelli di logger come "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF". È possibile definire il logger root nel file application.properties come mostrato di seguito:
logging.level.root = WARN
Note- Il logback non supporta il log di livello "FATAL". È mappato al registro di livello "ERRORE".
Configura Logback
Logback supporta la configurazione basata su XML per gestire le configurazioni Spring Boot Log. I dettagli di configurazione della registrazione sono configurati inlogback.xmlfile. Il file logback.xml dovrebbe essere posizionato sotto il classpath.
È possibile configurare il registro di livello ROOT nel file Logback.xml utilizzando il codice fornito di seguito:
<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
<root level = "INFO">
</root>
</configuration>
È possibile configurare l'appender della console nel file Logback.xml indicato di seguito.
<?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>
È possibile configurare il file appender nel file Logback.xml utilizzando il codice fornito di seguito. Tieni presente che devi specificare il percorso del file di registro all'interno dell'appender del file.
<?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>
È possibile definire il modello di log in logback.xmlfile utilizzando il codice fornito di seguito. È inoltre possibile definire il set di modelli di registro supportati all'interno della console o dell'appender del registro file utilizzando il codice fornito di seguito:
<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
Di seguito viene fornito il codice per il file logback.xml completo. Devi inserirlo nel percorso di classe.
<?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>
Il codice riportato di seguito mostra come aggiungere il logger slf4j nel file di classe principale di 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);
}
}
L'output che puoi vedere nella finestra della console è mostrato qui -
L'output che puoi vedere nel file di registro è mostrato qui -
Spring Boot fornisce un ottimo supporto per la creazione di servizi Web RESTful per applicazioni aziendali. Questo capitolo spiegherà in dettaglio come creare servizi Web RESTful utilizzando Spring Boot.
Note - Per creare un servizio Web RESTful, è necessario aggiungere la dipendenza Web Spring Boot Starter nel file di configurazione della build.
Se sei un utente Maven, utilizza il codice seguente per aggiungere la seguente dipendenza nel tuo file pom.xml file -
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Se sei un utente Gradle, utilizza il codice seguente per aggiungere la dipendenza sottostante nel tuo file build.gradle file.
compile('org.springframework.boot:spring-boot-starter-web')
Il codice per il file di configurazione della build completo Maven build – pom.xml è dato di seguito -
<?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>
Il codice per il file di configurazione della build completo Gradle Build – build.gradle è dato di seguito -
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')
}
Prima di procedere alla creazione di un servizio web RESTful, si consiglia di conoscere le seguenti annotazioni:
Rest Controller
L'annotazione @RestController viene utilizzata per definire i servizi Web RESTful. Serve JSON, XML e risposta personalizzata. La sua sintassi è mostrata di seguito:
@RestController
public class ProductServiceController {
}
Richiedi mappatura
L'annotazione @RequestMapping viene utilizzata per definire l'URI della richiesta per accedere agli endpoint REST. Possiamo definire il metodo Request per consumare e produrre oggetti. Il metodo di richiesta predefinito è GET.
@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }
Corpo della richiesta
L'annotazione @RequestBody viene utilizzata per definire il tipo di contenuto del corpo della richiesta.
public ResponseEntity<Object> createProduct(@RequestBody Product product) {
}
Variabile di percorso
L'annotazione @PathVariable viene utilizzata per definire l'URI della richiesta personalizzato o dinamico. La variabile Path nell'URI della richiesta è definita come parentesi graffe {} come mostrato di seguito -
public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {
}
Richiedi parametro
L'annotazione @RequestParam viene utilizzata per leggere i parametri della richiesta dall'URL della richiesta. Per impostazione predefinita, è un parametro obbligatorio. Possiamo anche impostare il valore predefinito per i parametri di richiesta come mostrato qui -
public ResponseEntity<Object> getProduct(
@RequestParam(value = "name", required = false, defaultValue = "honey") String name) {
}
OTTIENI API
Il metodo di richiesta HTTP predefinito è GET. Questo metodo non richiede alcun corpo di richiesta. È possibile inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.
Il codice di esempio per definire il metodo di richiesta HTTP GET è mostrato di seguito. In questo esempio, abbiamo utilizzato HashMap per memorizzare il prodotto. Notare che abbiamo utilizzato una classe POJO come prodotto da memorizzare.
Qui, l'URI della richiesta è /productse restituirà l'elenco dei prodotti dal repository HashMap. Di seguito viene fornito il file della classe controller che contiene il metodo 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
La richiesta HTTP POST viene utilizzata per creare una risorsa. Questo metodo contiene il corpo della richiesta. Possiamo inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.
L'esempio seguente mostra il codice di esempio per definire il metodo di richiesta HTTP POST. In questo esempio, abbiamo utilizzato HashMap per memorizzare il prodotto, dove il prodotto è una classe POJO.
Qui, l'URI della richiesta è /productse restituirà la stringa dopo aver archiviato il prodotto nel repository 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
La richiesta HTTP PUT viene utilizzata per aggiornare la risorsa esistente. Questo metodo contiene un corpo della richiesta. Possiamo inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.
L'esempio riportato di seguito mostra come definire il metodo di richiesta HTTP PUT. In questo esempio, abbiamo utilizzato HashMap per aggiornare il prodotto esistente, dove il prodotto è una classe POJO.
Qui l'URI della richiesta è /products/{id}che restituirà la stringa dopo il prodotto in un repository HashMap. Nota che abbiamo usato la variabile Path{id} che definisce l'ID dei prodotti che deve essere aggiornato.
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);
}
}
DELETE API
La richiesta HTTP Delete viene utilizzata per eliminare la risorsa esistente. Questo metodo non contiene alcun corpo della richiesta. Possiamo inviare parametri di richiesta e variabili di percorso per definire l'URL personalizzato o dinamico.
L'esempio riportato di seguito mostra come definire il metodo di richiesta HTTP DELETE. In questo esempio, abbiamo utilizzato HashMap per rimuovere il prodotto esistente, che è una classe POJO.
L'URI della richiesta è /products/{id}e restituirà la stringa dopo aver eliminato il prodotto dal repository HashMap. Abbiamo usato la variabile Path{id} che definisce l'ID dei prodotti che deve essere eliminato.
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);
}
}
Questa sezione fornisce il set completo di codice sorgente. Rispettare i seguenti codici per le rispettive funzionalità:
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);
}
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione di avvio a molla utilizzando i seguenti comandi Maven o Gradle come mostrato:
Per Maven, usa il comando mostrato di seguito -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, utilizzare il comando mostrato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
È possibile eseguire il file JAR utilizzando il comando mostrato di seguito:
java –jar <JARFILE>
Questo avvierà l'applicazione sulla porta Tomcat 8080 come mostrato di seguito -
Ora premi l'URL mostrato di seguito nell'applicazione POSTMAN e guarda l'output.
L'URL dell'API GET è: http://localhost:8080/products
L'URL dell'API POST è: http://localhost:8080/products
L'URL dell'API PUT è: http://localhost:8080/products/3
L'URL dell'API DELETE è: http://localhost:8080/products/3
La gestione delle eccezioni e degli errori nelle API e l'invio della risposta corretta al client è utile per le applicazioni aziendali. In questo capitolo impareremo come gestire le eccezioni in Spring Boot.
Prima di procedere con la gestione delle eccezioni, acquisiamo una comprensione delle seguenti annotazioni.
Consiglio del controllore
@ControllerAdvice è un'annotazione, per gestire le eccezioni a livello globale.
Gestore delle eccezioni
@ExceptionHandler è un'annotazione utilizzata per gestire le eccezioni specifiche e inviare le risposte personalizzate al client.
È possibile utilizzare il codice seguente per creare la classe @ControllerAdvice per gestire le eccezioni a livello globale:
package com.tutorialspoint.demo.exception;
import org.springframework.web.bind.annotation.ControllerAdvice;
@ControllerAdvice
public class ProductExceptionController {
}
Definisci una classe che estende la classe RuntimeException.
package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
private static final long serialVersionUID = 1L;
}
È possibile definire il metodo @ExceptionHandler per gestire le eccezioni come mostrato. Questo metodo dovrebbe essere utilizzato per scrivere il file di classe Controller Advice.
@ExceptionHandler(value = ProductNotfoundException.class)
public ResponseEntity<Object> exception(ProductNotfoundException exception) {
}
Ora, usa il codice fornito di seguito per lanciare l'eccezione dall'API.
@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct() {
throw new ProductNotfoundException();
}
Di seguito viene fornito il codice completo per gestire l'eccezione. In questo esempio, abbiamo utilizzato l'API PUT per aggiornare il prodotto. Qui, durante l'aggiornamento del prodotto, se il prodotto non viene trovato, restituire il messaggio di errore di risposta come "Prodotto non trovato". Nota che il fileProductNotFoundException la classe di eccezione dovrebbe estendere la RuntimeException.
package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
private static final long serialVersionUID = 1L;
}
Di seguito viene fornita la classe Controller Advice per gestire l'eccezione a livello globale. Possiamo definire qualsiasi metodo di gestione delle eccezioni in questo file di classe.
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);
}
}
Di seguito viene fornito il file del controller API del servizio prodotto per aggiornare il prodotto. Se il prodotto non viene trovato, lancia il fileProductNotFoundException classe.
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);
}
}
Di seguito è riportato il codice per il file di classe dell'applicazione Spring Boot principale:
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);
}
}
Il codice per POJO class per il prodotto è dato di seguito -
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;
}
}
Il codice per Maven build – pom.xml è mostrato di seguito -
<?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>
Il codice per Gradle Build – build.gradle è dato di seguito -
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle -
Per Maven, puoi usare il seguente comando:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il seguente comando:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
È possibile eseguire il file JAR utilizzando il seguente comando:
java –jar <JARFILE>
Questo avvierà l'applicazione sulla porta Tomcat 8080 come mostrato di seguito -
Ora premi l'URL sottostante nell'applicazione POSTMAN e puoi vedere l'output come mostrato di seguito -
URL di aggiornamento: http: // localhost: 8080 / products / 3
È possibile utilizzare Interceptor in Spring Boot per eseguire operazioni nelle seguenti situazioni:
Prima di inviare la richiesta al titolare
Prima di inviare la risposta al cliente
Ad esempio, è possibile utilizzare un intercettore per aggiungere l'intestazione della richiesta prima di inviare la richiesta al controller e aggiungere l'intestazione della risposta prima di inviare la risposta al client.
Per lavorare con l'interceptor, devi creare @Component classe che lo supporta e dovrebbe implementare il HandlerInterceptor interfaccia.
I seguenti sono i tre metodi che dovresti conoscere mentre lavori su Interceptor:
preHandle()metodo - Viene utilizzato per eseguire operazioni prima di inviare la richiesta al controller. Questo metodo dovrebbe restituire true per restituire la risposta al client.
postHandle() metodo: viene utilizzato per eseguire operazioni prima di inviare la risposta al client.
afterCompletion() metodo: viene utilizzato per eseguire operazioni dopo aver completato la richiesta e la risposta.
Osservare il seguente codice per una migliore comprensione:
@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 {}
}
Dovrai registrare questo Interceptor con InterceptorRegistry usando WebMvcConfigurerAdapter come mostrato di seguito -
@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
@Autowired
ProductServiceInterceptor productServiceInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(productServiceInterceptor);
}
}
Nell'esempio riportato di seguito, faremo clic sull'API dei prodotti GET che fornisce l'output come indicato in -
Il codice per la classe Interceptor ProductServiceInterceptor.java è fornito di seguito:
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");
}
}
Di seguito è riportato il codice per il file di classe Configurazione dell'applicazione per registrare l'Interceptor in Interceptor Registry - ProductServiceInterceptorAppConfig.java -
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);
}
}
Il codice per il file di classe Controller ProductServiceController.java è fornito di seguito:
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);
}
}
Il codice per la classe POJO per Product.java è fornito di seguito:
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;
}
}
Il codice per il file di classe dell'applicazione Spring Boot principale DemoApplication.java è dato di seguito -
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);
}
}
Il codice per la build di Maven - pom.xml è mostrato qui -
<?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>
Il codice per Gradle Build build.gradle è mostrato qui -
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, utilizzare il comando come mostrato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, utilizzare il comando come mostrato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
È possibile eseguire il file JAR utilizzando il seguente comando:
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 8080 come mostrato di seguito -
Ora premi l'URL sottostante nell'applicazione POSTMAN e puoi vedere l'output come mostrato sotto -
OTTIENI API: http://localhost:8080/products
Nella finestra della console, puoi vedere le istruzioni System.out.println aggiunte in Interceptor come mostrato nella schermata riportata di seguito:
Un filtro è un oggetto utilizzato per intercettare le richieste e le risposte HTTP dell'applicazione. Usando il filtro, possiamo eseguire due operazioni in due istanze:
- Prima di inviare la richiesta al titolare
- Prima di inviare una risposta al cliente.
Il codice seguente mostra il codice di esempio per una classe di implementazione del filtro servlet con l'annotazione @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 {}
}
L'esempio seguente mostra il codice per leggere l'host remoto e l'indirizzo remoto dall'oggetto ServletRequest prima di inviare la richiesta al controller.
Nel metodo doFilter (), abbiamo aggiunto le istruzioni System.out.println per stampare l'host remoto e l'indirizzo remoto.
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 {}
}
Nel file della classe dell'applicazione principale Spring Boot, abbiamo aggiunto il semplice endpoint REST che restituisce la stringa "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";
}
}
Il codice per la build di Maven - pom.xml è dato di seguito -
<?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>
Il codice per Gradle Build - build.gradle è fornito di seguito -
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle mostrati di seguito:
Per Maven, utilizzare il comando come mostrato di seguito:
mvn clean install
Dopo BUILD SUCCESS, è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, utilizzare il comando come mostrato di seguito:
gradle clean build
Dopo BUILD SUCCESSFUL, puoi trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR utilizzando il seguente comando
java –jar <JARFILE>
Puoi vedere che l'applicazione è stata avviata sulla porta Tomcat 8080.
Ora premi l'URL http://localhost:8080/e guarda l'output Hello World. Dovrebbe apparire come mostrato di seguito -
Quindi, puoi vedere l'host remoto e l'indirizzo remoto nel registro della console come mostrato di seguito:
Spring Boot consente di eseguire la stessa applicazione più di una volta su un numero di porta diverso. In questo capitolo, imparerai questo in dettaglio. Notare che il numero di porta predefinito 8080.
Porta personalizzata
Nel application.properties file, possiamo impostare il numero di porta personalizzato per la proprietà server.port
server.port = 9090
Nel application.yml file, puoi trovare quanto segue:
server:
port: 9090
Porta casuale
Nel application.properties file, possiamo impostare un numero di porta casuale per la proprietà server.port
server.port = 0
Nel application.yml file, puoi trovare quanto segue:
server:
port: 0
Note - Se il file server.port numero è 0 all'avvio dell'applicazione Spring Boot, Tomcat utilizza il numero di porta casuale.
Rest Template viene utilizzato per creare applicazioni che utilizzano servizi Web RESTful. Puoi usare il fileexchange()metodo per utilizzare i servizi Web per tutti i metodi HTTP. Il codice riportato di seguito mostra come creare Bean for Rest Template per il cablaggio automatico dell'oggetto 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();
}
}
OTTENERE
Consuming the GET API by using RestTemplate - exchange() method
Assumi questo URL http://localhost:8080/products restituisce il seguente JSON e utilizzeremo questa risposta API utilizzando Rest Template utilizzando il codice seguente:
[
{
"id": "1",
"name": "Honey"
},
{
"id": "2",
"name": "Almond"
}
]
Dovrai seguire i punti indicati per utilizzare l'API -
- Autowired l'oggetto Rest Template.
- Usa HttpHeaders per impostare le intestazioni della richiesta.
- Usa HttpEntity per racchiudere l'oggetto richiesta.
- Fornisci l'URL, HttpMethod e il tipo di ritorno per il metodo 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();
}
}
INVIARE
Consuming POST API by using RestTemplate - exchange() method
Assumi questo URL http://localhost:8080/products restituisce la risposta mostrata di seguito, utilizzeremo questa risposta API utilizzando il modello di riposo.
Il codice fornito di seguito è il corpo della richiesta -
{
"id":"3",
"name":"Ginger"
}
Il codice fornito di seguito è il corpo della risposta -
Product is created successfully
Dovrai seguire i punti indicati di seguito per utilizzare l'API -
Autowired l'oggetto Rest Template.
Usa HttpHeaders per impostare le intestazioni della richiesta.
Usa HttpEntity per racchiudere l'oggetto richiesta. Qui, avvolgiamo l'oggetto Product per inviarlo al corpo della richiesta.
Fornisci l'URL, HttpMethod e il tipo di ritorno per il metodo 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();
}
}
METTERE
Consuming PUT API by using RestTemplate - exchange() method
Assumi questo URL http://localhost:8080/products/3 restituisce la risposta seguente e utilizzeremo questa risposta API utilizzando Rest Template.
Il codice riportato di seguito è il corpo della richiesta -
{
"name":"Indian Ginger"
}
Il codice fornito di seguito è il corpo della risposta -
Product is updated successfully
Dovrai seguire i punti indicati di seguito per utilizzare l'API -
Autowired l'oggetto Rest Template.
Usa HttpHeaders per impostare le intestazioni della richiesta.
Usa HttpEntity per racchiudere l'oggetto richiesta. Qui, avvolgiamo l'oggetto Product per inviarlo al corpo della richiesta.
Fornisci l'URL, HttpMethod e il tipo di ritorno per il metodo 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();
}
}
ELIMINA
Consuming DELETE API by using RestTemplate - exchange() method
Assumi questo URL http://localhost:8080/products/3 restituisce la risposta fornita di seguito e utilizzeremo questa risposta API utilizzando Rest Template.
Questa riga di codice mostrata di seguito è il corpo della risposta:
Product is deleted successfully
Dovrai seguire i punti mostrati di seguito per utilizzare l'API -
Autowired l'oggetto Rest Template.
Usa HttpHeaders per impostare le intestazioni della richiesta.
Usa HttpEntity per racchiudere l'oggetto richiesta.
Fornisci l'URL, HttpMethod e il tipo di ritorno per il metodo 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();
}
}
Di seguito viene fornito il file completo della classe Rest Template Controller:
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();
}
}
Il codice per Spring Boot Application Class - DemoApplication.java è fornito di seguito -
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);
}
}
Il codice per la build di Maven - pom.xml è fornito di seguito -
<?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>
Il codice per Gradle Build - build.gradle è fornito di seguito -
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, puoi usare il comando indicato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il comando mostrato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il seguente comando:
java –jar <JARFILE>
Ora l'applicazione è stata avviata sulla porta Tomcat 8080.
Ora premi l'URL sottostante nell'applicazione POSTMAN e puoi vedere l'output.
OTTIENI Prodotti per modello di riposo - http://localhost:8080/template/products
Crea prodotti POST - http://localhost:8080/template/products
Aggiorna prodotto PUT - http://localhost:8080/template/products/3
Elimina prodotto - http://localhost:8080/template/products/3
In questo capitolo imparerai come caricare e scaricare il file utilizzando il servizio web.
Upload di file
Per caricare un file, puoi usare MultipartFilecome parametro di richiesta e questa API dovrebbe utilizzare il valore dei dati del modulo multiparte. Rispettare il codice riportato di seguito -
@RequestMapping(value = "/upload", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public String fileUpload(@RequestParam("file") MultipartFile file) {
return null;
}
Il codice completo per lo stesso è dato di seguito -
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";
}
}
Download file
Per il download di file, è necessario utilizzare InputStreamResource per scaricare un file. Dobbiamo impostare HttpHeaderContent-Disposition in risposta ed è necessario specificare il tipo di supporto di risposta dell'applicazione.
Note - Nel seguente esempio, il file dovrebbe essere disponibile nel percorso specificato in cui è in esecuzione l'applicazione.
@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;
}
Il codice completo per lo stesso è dato di seguito -
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;
}
}
Di seguito viene fornita l'applicazione principale 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);
}
}
Il codice per la build di Maven - pom.xml è fornito di seguito -
<?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>
Il codice per Gradle Build - build.gradle è fornito di seguito -
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')
}
Ora puoi creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle indicati di seguito:
Per Maven, utilizzare il comando fornito di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il comando mostrato di seguito:
sgradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il seguente comando:
java –jar <JARFILE>
Questo avvierà l'applicazione sulla porta Tomcat 8080 come mostrato di seguito -
Ora premi gli URL seguenti nell'applicazione POSTMAN e puoi vedere l'output come mostrato di seguito -
Caricamento file - http://localhost:8080/upload
Download di file - http://localhost:8080/upload
I componenti del servizio sono il file di classe che contiene l'annotazione @Service. Questi file di classe vengono utilizzati per scrivere la logica aziendale in un livello diverso, separato dal file di classe @RestController. La logica per la creazione di un file di classe del componente del servizio è mostrata qui:
public interface ProductService {
}
La classe che implementa l'interfaccia con l'annotazione @Service è come mostrato -
@Service
public class ProductServiceImpl implements ProductService {
}
Osserva che in questo tutorial stiamo usando Product Service API(s)memorizzare, recuperare, aggiornare ed eliminare i prodotti. Abbiamo scritto la logica aziendale nel file di classe @RestController stesso. Ora sposteremo il codice della logica di business dal controller al componente di servizio.
È possibile creare un'interfaccia che contenga metodi di aggiunta, modifica, recupero ed eliminazione utilizzando il codice come mostrato di seguito:
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();
}
Il codice seguente ti consentirà di creare una classe che implementa l'interfaccia ProductService con l'annotazione @Service e scrivere la logica di business per archiviare, recuperare, eliminare e aggiornare il prodotto.
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();
}
}
Il codice qui mostra il file di classe Rest Controller, qui abbiamo @Autowired l'interfaccia ProductService e chiamato i metodi.
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);
}
}
Il codice per la classe POJO - Product.java è mostrato qui -
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;
}
}
Di seguito viene fornita un'applicazione principale 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);
}
}
Il codice per la build di Maven - pom.xml è mostrato di seguito -
<?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>
Il codice per Gradle Build - build.gradle è mostrato di seguito -
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle indicati di seguito:
Per Maven, utilizzare il comando come mostrato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il comando come mostrato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il comando indicato di seguito:
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 8080 come mostrato nell'immagine sotto riportata -
Ora premi gli URL seguenti nell'applicazione POSTMAN e puoi vedere l'output come mostrato di seguito -
GET API URL è - http://localhost:8080/products
L'URL dell'API POST è - http://localhost:8080/products
L'URL dell'API PUT è - http://localhost:8080/products/3
L'URL dell'API DELETE è - http://localhost:8080/products/3
Thymeleaf è una libreria basata su Java utilizzata per creare un'applicazione web. Fornisce un buon supporto per servire un XHTML / HTML5 nelle applicazioni web. In questo capitolo imparerai in dettaglio su Thymeleaf.
Modelli di foglia di timone
Thymeleaf converte i tuoi file in file XML ben formati. Contiene 6 tipi di modelli come indicato di seguito:
- XML
- XML valido
- XHTML
- XHTML valido
- HTML5
- HTML5 precedente
Tutti i modelli, ad eccezione di Legacy HTML5, fanno riferimento a file XML validi ben formati. La versione precedente di HTML5 ci consente di visualizzare i tag HTML5 nella pagina web, inclusi i tag non chiusi.
Applicazione web
È possibile utilizzare modelli Thymeleaf per creare un'applicazione Web in Spring Boot. Dovrai seguire i passaggi seguenti per creare un'applicazione web in Spring Boot utilizzando Thymeleaf.
Utilizzare il codice seguente per creare un file di classe @Controller per reindirizzare l'URI della richiesta al file 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";
}
}
Nell'esempio precedente, l'URI della richiesta è /indexe il controllo viene reindirizzato al file index.html. Notare che il file index.html deve essere posizionato nella directory dei modelli e tutti i file JS e CSS devono essere posizionati nella directory statica in classpath. Nell'esempio mostrato, abbiamo utilizzato il file CSS per cambiare il colore del testo.
È possibile utilizzare il codice seguente e creare un file CSS in una cartella separata css e denomina il file come styles.css -
h4 {
color: red;
}
Il codice per il file index.html è fornito di seguito:
<!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>
L'esploratore del progetto è mostrato nella schermata riportata di seguito:
Ora, dobbiamo aggiungere la dipendenza Spring Boot Starter Thymeleaf nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle:
compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
Di seguito è riportato il codice per il file di classe dell'applicazione Spring Boot principale:
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);
}
}
Il codice per Maven - pom.xml è fornito di seguito -
<?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>
Il codice per Gradle - build.gradle è fornito di seguito -
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione di avvio primaverile utilizzando i seguenti comandi Maven o Gradle:
Per Maven, utilizzare il comando come mostrato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, utilizzare il comando come mostrato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il comando fornito qui -
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 8080 come mostrato di seguito -
Ora premi l'URL nel tuo browser web e puoi vedere l'output come mostrato -
http://localhost:8080/index
Questo capitolo discuterà in dettaglio sull'utilizzo di servizi Web RESTful utilizzando jQuery AJAX.
Creare una semplice applicazione Web Spring Boot e scrivere un file di classe controller che viene utilizzato per reindirizzare nel file HTML per consumare i servizi Web RESTful.
Dobbiamo aggiungere lo starter Spring Boot Thymeleaf e la dipendenza Web nel nostro file di configurazione della build.
Per gli utenti Maven, aggiungi le seguenti dipendenze nel tuo file 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>
Per gli utenti Gradle, aggiungi le seguenti dipendenze nel tuo file build.gradle -
compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
compile(‘org.springframework.boot:spring-boot-starter-web’)
Il codice per il file di classe @Controller è fornito di seguito:
@Controller
public class ViewController {
}
È possibile definire i metodi dell'URI della richiesta per reindirizzare nel file HTML come mostrato di seguito:
@RequestMapping(“/view-products”)
public String viewProducts() {
return “view-products”;
}
@RequestMapping(“/add-products”)
public String addProducts() {
return “add-products”;
}
Questa API http://localhost:9090/products dovrebbe restituire il seguente JSON in risposta come mostrato di seguito -
[
{
"id": "1",
"name": "Honey"
},
{
"id": "2",
"name": "Almond"
}
]
Ora, crea un file view-products.html nella directory templates nel classpath.
Nel file HTML, abbiamo aggiunto la libreria jQuery e scritto il codice per utilizzare il servizio web RESTful al caricamento della pagina.
<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>
Il metodo POST e questo URL http://localhost:9090/products dovrebbe contenere il corpo della richiesta e il corpo della risposta di seguito.
Il codice per il corpo della richiesta è riportato di seguito:
{
"id":"3",
"name":"Ginger"
}
Il codice per il corpo della risposta è fornito di seguito:
Product is created successfully
Ora, crea il file add-products.html nella directory dei modelli nel classpath.
Nel file HTML, abbiamo aggiunto la libreria jQuery e scritto il codice che invia il modulo al servizio web RESTful facendo clic sul pulsante.
<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>
Di seguito viene fornito il codice completo.
Maven: file 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>
Il codice per Gradle - build.gradle è fornito di seguito -
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’)
}
Il file di classe del controller fornito di seguito - ViewController.java è fornito di seguito -
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”;
}
}
Il file view-products.html è fornito di seguito:
<!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>
Di seguito viene fornito il file add-products.html:
<!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>
Di seguito è riportato il file di classe dell'applicazione Spring Boot principale:
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);
}
}
Ora puoi creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, utilizzare il comando come indicato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, utilizzare il comando come indicato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il seguente comando:
java –jar <JARFILE>
Ora l'applicazione è stata avviata sulla porta Tomcat 8080.
Ora premi l'URL nel tuo browser web e puoi vedere l'output come mostrato -
http: // localhost: 8080 / view-products
http: // localhost: 8080 / add-products
Ora fai clic sul pulsante Click here to submit the form e puoi vedere il risultato come mostrato -
Ora, premi l'URL di visualizzazione dei prodotti e guarda il prodotto creato.
http://localhost:8080/view-products
JS angolare
Per utilizzare le API utilizzando Angular JS, puoi utilizzare gli esempi forniti di seguito:
Utilizzare il codice seguente per creare il controller JS angolare per utilizzare l'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;
});
});
Utilizzare il codice seguente per creare il controller JS angolare per utilizzare l'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 - I dati del metodo Post rappresentano il corpo della richiesta in formato JSON per creare un prodotto.
Cross-Origin Resource Sharing (CORS) è un concetto di sicurezza che consente di limitare le risorse implementate nei browser web. Impedisce al codice JavaScript di produrre o consumare le richieste su origini diverse.
Ad esempio, la tua applicazione web è in esecuzione sulla porta 8080 e usando JavaScript stai tentando di consumare servizi web RESTful dalla porta 9090. In tali situazioni, dovrai affrontare il problema di sicurezza della condivisione delle risorse tra le origini sui tuoi browser web.
Sono necessari due requisiti per gestire questo problema:
I servizi Web RESTful dovrebbero supportare la condivisione delle risorse tra le origini.
L'applicazione del servizio Web RESTful dovrebbe consentire l'accesso alle API dalla porta 8080.
In questo capitolo apprenderemo in dettaglio come abilitare le richieste cross-origin per un'applicazione del servizio Web RESTful.
Abilita CORS nel metodo controller
È necessario impostare le origini per il servizio Web RESTful utilizzando @CrossOriginannotazione per il metodo controller. Questa annotazione @CrossOrigin supporta API REST specifiche e non per l'intera applicazione.
@RequestMapping(value = "/products")
@CrossOrigin(origins = "http://localhost:8080")
public ResponseEntity<Object> getProduct() {
return null;
}
Configurazione CORS globale
Dobbiamo definire la configurazione @Bean mostrata per impostare il supporto della configurazione CORS a livello globale per la tua applicazione Spring Boot.
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/products").allowedOrigins("http://localhost:9000");
}
};
}
Di seguito viene fornito il codice per impostare la configurazione CORS a livello globale nell'applicazione Spring Boot principale.
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");
}
};
}
}
Ora puoi creare un'applicazione Web Spring Boot che viene eseguita sulla porta 8080 e l'applicazione del servizio Web RESTful che può essere eseguita sulla porta 9090. Per ulteriori dettagli sull'implementazione del servizio Web RESTful, fare riferimento al capitolo intitolatoConsuming RESTful Web Services di questo tutorial.
L'internazionalizzazione è un processo che rende la tua applicazione adattabile a diverse lingue e regioni senza modifiche ingegneristiche sul codice sorgente. In entrambe le parole, l'internazionalizzazione è una prontezza di localizzazione.
In questo capitolo impareremo in dettaglio come implementare l'internazionalizzazione in Spring Boot.
Dipendenze
Abbiamo bisogno della dipendenza Spring Boot Starter Web e Spring Boot Starter Thymeleaf per sviluppare un'applicazione web in Spring Boot.
Esperto di
<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
Dobbiamo determinare le impostazioni internazionali predefinite della tua applicazione. Dobbiamo aggiungere il bean LocaleResolver nella nostra applicazione Spring Boot.
@Bean
public LocaleResolver localeResolver() {
SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
sessionLocaleResolver.setDefaultLocale(Locale.US);
return sessionLocaleResolver;
}
LocaleChangeInterceptor
LocaleChangeInterceptor è utilizzato per modificare le nuove impostazioni internazionali in base al valore del parametro della lingua aggiunto a una richiesta.
@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
localeChangeInterceptor.setParamName("language");
return localeChangeInterceptor;
}
Per ottenere questo effetto, è necessario aggiungere LocaleChangeInterceptor nell'interceptor del registro dell'applicazione. La classe di configurazione dovrebbe estendere la classe WebMvcConfigurerAdapter e sovrascrivere il metodo addInterceptors ().
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(localeChangeInterceptor());
}
Fonti dei messaggi
L'applicazione Spring Boot per impostazione predefinita prende le origini dei messaggi da src/main/resourcescartella sotto il classpath. Il nome del file dei messaggi delle impostazioni internazionali predefinito dovrebbe esseremessage.properties e i file per ogni locale dovrebbero essere denominati come messages_XX.properties. Il "XX" rappresenta il codice locale.
Tutte le proprietà del messaggio devono essere utilizzate come valori della coppia di chiavi. Se nessuna proprietà viene trovata nelle impostazioni locali, l'applicazione utilizza la proprietà predefinita dal file messages.properties.
Il valore predefinito messages.properties sarà come mostrato:
welcome.text=Hi Welcome to Everyone
La lingua francese messages_fr.properties sarà come mostrato -
welcome.text=Salut Bienvenue à tous
Note - Il file sorgente dei messaggi deve essere salvato come formato di file "UTF-8".
File HTML
Nel file HTML, usa la sintassi #{key} per visualizzare i messaggi dal file delle proprietà.
<h1 th:text = "#{welcome.text}"></h1>
Di seguito viene fornito il codice completo
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')
}
Di seguito viene fornito il file di classe dell'applicazione Spring Boot principale:
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);
}
}
Il file di classe del controller è fornito di seguito:
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";
}
}
Classe di configurazione per supportare l'internazionalizzazione
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());
}
}
Le origini dei messaggi - messages.properties sono come mostrato -
welcome.text = Hi Welcome to Everyone
Le origini dei messaggi - message_fr.properties sono come mostrato -
welcome.text = Salut Bienvenue à tous
Il file HTML locale.html dovrebbe essere posizionato nella directory dei modelli sul classpath come mostrato -
<!DOCTYPE html>
<html>
<head>
<meta charset = "ISO-8859-1"/>
<title>Internationalization</title>
</head>
<body>
<h1 th:text = "#{welcome.text}"></h1>
</body>
</html>
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, usa il seguente comando:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, usa il seguente comando:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando come mostrato -
java –jar <JARFILE>
Scoprirai che l'applicazione è stata avviata sulla porta Tomcat 8080.
Ora premi l'URL http://localhost:8080/locale nel tuo browser web e puoi vedere il seguente output:
L'URL http://localhost:8080/locale?language=fr ti darà l'output come mostrato -
La pianificazione è un processo di esecuzione delle attività per il periodo di tempo specifico. Spring Boot fornisce un buon supporto per scrivere uno scheduler sulle applicazioni Spring.
Espressione Java Cron
Le espressioni Java Cron vengono utilizzate per configurare le istanze di CronTrigger, una sottoclasse di org.quartz.Trigger. Per ulteriori informazioni sull'espressione cron di Java, fare riferimento a questo collegamento:
https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm
L'annotazione @EnableScheduling viene utilizzata per abilitare lo scheduler per la tua applicazione. Questa annotazione dovrebbe essere aggiunta al file di classe dell'applicazione Spring Boot principale.
@SpringBootApplication
@EnableScheduling
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
L'annotazione @Scheduled viene utilizzata per attivare lo scheduler per un periodo di tempo specifico.
@Scheduled(cron = "0 * 9 * * ?")
public void cronJobSch() throws Exception {
}
Di seguito è riportato un codice di esempio che mostra come eseguire l'attività ogni minuto a partire dalle 9:00 e termina alle 9:59, ogni giorno
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);
}
}
Lo screenshot seguente mostra come l'applicazione è stata avviata alle 09:03:23 e per ogni minuto da quel momento è stata eseguita l'attività di cron job scheduler.
Tasso fisso
Lo scheduler a tasso fisso viene utilizzato per eseguire le attività in un momento specifico. Non attende il completamento dell'attività precedente. I valori dovrebbero essere in millisecondi. Il codice di esempio è mostrato qui -
@Scheduled(fixedRate = 1000)
public void fixedRateSch() {
}
Un codice di esempio per eseguire un'attività ogni secondo dall'avvio dell'applicazione è mostrato qui -
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);
}
}
Osservare la seguente schermata che mostra l'applicazione che è stata avviata alle 09:12:00 e successivamente è stata eseguita ogni seconda attività di pianificazione a tasso fisso.
Ritardo fisso
Lo scheduler con ritardo fisso viene utilizzato per eseguire le attività in un momento specifico. Dovrebbe attendere il completamento dell'attività precedente. I valori dovrebbero essere in millisecondi. Un codice di esempio è mostrato qui -
@Scheduled(fixedDelay = 1000, initialDelay = 1000)
public void fixedDelaySch() {
}
In questo caso, initialDelay è il tempo dopo il quale l'attività verrà eseguita la prima volta dopo il valore di ritardo iniziale.
Di seguito è riportato un esempio per eseguire l'attività per ogni secondo dopo che sono stati completati 3 secondi dall'avvio dell'applicazione:
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);
}
}
Osservare la seguente schermata che mostra l'applicazione che è stata avviata alle 09:18:39 e dopo ogni 3 secondi, l'attività di pianificazione del ritardo fisso è stata eseguita ogni secondo.
Per impostazione predefinita, l'applicazione Spring Boot utilizza la porta HTTP 8080 all'avvio dell'applicazione.
È necessario seguire i passaggi indicati di seguito per configurare HTTPS e la porta 443 nell'applicazione Spring Boot -
Ottieni il certificato SSL: crea un certificato autofirmato o richiedine uno da un'autorità di certificazione
Abilita HTTPS e la porta 443
Certificato autofirmato
Per creare un certificato autofirmato, l'ambiente Java Run Time viene fornito in bundle con lo strumento chiave dell'utilità di gestione dei certificati. Questo strumento di utilità viene utilizzato per creare un certificato autofirmato. È mostrato nel codice qui fornito -
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
Questo codice genererà un file di archivio chiavi PKCS12 denominato keystore.p12 e il nome alias del certificato è tomcat.
Configura HTTPS
Dobbiamo fornire la porta del server come 443, percorso file archivio chiavi, password archivio chiavi, tipo archivio chiavi e nome alias chiave nel file application.properties. Rispettare il codice qui fornito -
server.port: 443
server.ssl.key-store: keystore.p12
server.ssl.key-store-password: springboot
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcat
Puoi usare il seguente codice se stai usando le proprietà YAML usa sotto application.yml -
server:
port: 443
ssl:
key-store: keystore.p12
key-store-password: springboot
keyStoreType: PKCS12
keyAlias: tomcat
È possibile creare un file JAR eseguibile ed eseguire l'applicazione di avvio primaverile utilizzando i seguenti comandi Maven o Gradle.
Per Maven, puoi usare il seguente comando:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il seguente comando:
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 443 con https come mostrato -
Eureka Server è un'applicazione che contiene le informazioni su tutte le applicazioni del servizio client. Ogni servizio Micro si registrerà nel server Eureka e il server Eureka conosce tutte le applicazioni client in esecuzione su ciascuna porta e indirizzo IP. Eureka Server è anche noto come Discovery Server.
In questo capitolo impareremo in dettaglio come costruire un server Eureka.
Costruire un server Eureka
Eureka Server viene fornito con il pacchetto di Spring Cloud. Per questo, dobbiamo sviluppare il server Eureka ed eseguirlo sulla porta predefinita 8761.
Visita la home page di Spring Initializer https://start.spring.io/e scarica il progetto Spring Boot con la dipendenza dal server Eureka. È mostrato nello screenshot qui sotto -
Dopo aver scaricato il progetto nel file di classe principale dell'applicazione Spring Boot, è necessario aggiungere l'annotazione @EnableEurekaServer. L'annotazione @EnableEurekaServer viene utilizzata per fare in modo che l'applicazione Spring Boot agisca come un server Eureka.
Il codice per il file di classe dell'applicazione Spring Boot principale è come mostrato di seguito:
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);
}
}
Assicurati che la dipendenza dal server Spring cloud Eureka sia aggiunta nel file di configurazione della build.
Il codice per la dipendenza dell'utente Maven è mostrato di seguito:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>
Il codice per la dipendenza dell'utente Gradle è fornito di seguito:
compile('org.springframework.cloud:spring-cloud-starter-eureka-server')
Di seguito viene fornito il file di configurazione della build completo:
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}"
}
}
Per impostazione predefinita, il server Eureka si registra nella discovery. È necessario aggiungere la configurazione indicata di seguito nel file application.properties o application.yml.
Il file application.properties è fornito di seguito:
eureka.client.registerWithEureka = false
eureka.client.fetchRegistry = false
server.port = 8761
Il file application.yml è fornito di seguito:
eureka:
client:
registerWithEureka: false
fetchRegistry: false
server:
port: 8761
Ora puoi creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle mostrati di seguito:
Per Maven, utilizzare il comando come mostrato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il comando mostrato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il seguente comando:
java –jar <JARFILE>
È possibile scoprire che l'applicazione è stata avviata sulla porta Tomcat 8761 come mostrato di seguito:
Ora, premi l'URL http://localhost:8761/ nel tuo browser web e puoi trovare il server Eureka in esecuzione sulla porta 8761 come mostrato di seguito -
In questo capitolo imparerai in dettaglio come registrare l'applicazione del servizio Spring Boot Micro nel server Eureka. Prima di registrare l'applicazione, assicurati che Eureka Server sia in esecuzione sulla porta 8761 o prima compila l'Eureka Server ed eseguilo. Per ulteriori informazioni sulla creazione del server Eureka, fare riferimento al capitolo precedente.
Innanzitutto, è necessario aggiungere le seguenti dipendenze nel nostro file di configurazione della build per registrare il microservizio con il server Eureka.
Gli utenti Maven possono aggiungere le seguenti dipendenze nel file pom.xml file -
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file build.gradle file -
compile('org.springframework.cloud:spring-cloud-starter-eureka')
Ora, dobbiamo aggiungere l'annotazione @EnableEurekaClient nel file di classe dell'applicazione Spring Boot principale. L'annotazione @EnableEurekaClient fa sì che l'applicazione Spring Boot agisca come un client Eureka.
La principale applicazione Spring Boot è la seguente:
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);
}
}
Per registrare l'applicazione Spring Boot in Eureka Server, dobbiamo aggiungere la seguente configurazione nel nostro file application.properties o application.yml e specificare l'URL del server Eureka nella nostra configurazione.
Il codice per il file application.yml è fornito di seguito:
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka
instance:
preferIpAddress: true
spring:
application:
name: eurekaclient
Il codice per il file application.properties è fornito di seguito:
eureka.client.serviceUrl.defaultZone = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient
Ora aggiungi Rest Endpoint per restituire String nell'applicazione Spring Boot principale e la dipendenza Web Spring Boot Starter nel file di configurazione della build. Rispettare il codice riportato di seguito -
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";
}
}
Di seguito viene fornito l'intero file di configurazione.
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}"
}
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, puoi usare il seguente comando:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il seguente comando:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando come mostrato -
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 8080 e l'applicazione Eureka Client è registrata con il server Eureka come mostrato di seguito:
Premi l'URL http: // localhost: 8761 / nel tuo browser web e puoi vedere che l'applicazione Eureka Client è registrata con Eureka Server.
Ora premi l'URL http://localhost:8080/ nel browser Web e visualizzare l'output di Rest Endpoint.
Zuul Server è un'applicazione gateway che gestisce tutte le richieste e fa il routing dinamico delle applicazioni di microservizi. Lo Zuul Server è anche conosciuto come Edge Server.
Per esempio, /api/user è mappato al servizio utente e / api / products è mappato al servizio del prodotto e Zuul Server instrada dinamicamente le richieste alla rispettiva applicazione di backend.
In questo capitolo vedremo in dettaglio come creare l'applicazione Zuul Server in Spring Boot.
Creazione dell'applicazione Zuul Server
Il server Zuul è fornito in bundle con la dipendenza Spring Cloud. È possibile scaricare il progetto Spring Boot dalla pagina Spring Initializerhttps://start.spring.io/ e scegli la dipendenza Zuul Server.
Aggiungi l'annotazione @EnableZuulProxy sull'applicazione Spring Boot principale. L'annotazione @EnableZuulProxy viene utilizzata per fare in modo che l'applicazione Spring Boot funga da server 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);
}
}
Dovrai aggiungere la dipendenza Spring Cloud Starter Zuul nel nostro file di configurazione della build.
Gli utenti Maven dovranno aggiungere la seguente dipendenza nel file pom.xml file -
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>
Per gli utenti Gradle, aggiungi la seguente dipendenza nel tuo file build.gradle
compile('org.springframework.cloud:spring-cloud-starter-zuul')
Per il routing Zuul, aggiungi le seguenti proprietà nel tuo file application.properties o application.yml.
spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111
Ciò significa che http chiama a /api/demo/essere inoltrati al servizio prodotti. Per esempio,/api/demo/products viene inoltrato a /products.
Gli utenti del file yaml possono utilizzare il file application.yml mostrato di seguito -
server:
port: 8111
spring:
application:
name: zuulserver
zuul:
routes:
products:
path: /api/demo/**
url: http://localhost:8080/
Note - Il http://localhost:8080/ l'applicazione dovrebbe essere già in esecuzione prima del routing tramite Zuul Proxy.
Di seguito viene fornito il file di configurazione completo della build.
Gli utenti di Maven possono utilizzare il file pom.xml indicato di seguito -
<?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>
Gli utenti Gradle possono utilizzare il file build.gradle fornito di seguito -
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}"
}
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle indicati di seguito:
Per Maven, puoi usare il comando indicato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il comando indicato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR utilizzando il comando mostrato di seguito:
java –jar <JARFILE>
È possibile scoprire che l'applicazione è stata avviata sulla porta Tomcat 8111 come mostrato qui.
Ora, premi l'URL http://localhost:8111/api/demo/products nel tuo browser web e puoi vedere l'output di /products Endpoint REST come mostrato di seguito -
Spring Cloud Configuration Server è un'applicazione centralizzata che gestisce tutte le proprietà di configurazione relative all'applicazione. In questo capitolo imparerai in dettaglio come creare il server Spring Cloud Configuration.
Creazione di Spring Cloud Configuration Server
Innanzitutto, scarica il progetto Spring Boot dalla pagina Spring Initializer e scegli la dipendenza Spring Cloud Config Server. Osserva lo screenshot riportato di seguito -
Ora aggiungi la dipendenza del server Spring Cloud Config nel file di configurazione della build come spiegato di seguito:
Gli utenti di Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile('org.springframework.cloud:spring-cloud-config-server')
Ora aggiungi l'annotazione @EnableConfigServer nel file di classe dell'applicazione Spring Boot principale. L'annotazione @EnableConfigServer fa sì che l'applicazione Spring Boot funga da server di configurazione.
Di seguito viene fornito il file di classe dell'applicazione Spring Boot principale:
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);
}
}
Ora aggiungi la configurazione seguente al tuo file delle proprietà e sostituisci il file application.properties nel file bootstrap.properties. Rispettare il codice riportato di seguito -
server.port = 8888
spring.cloud.config.server.native.searchLocations=file:///C:/configprop/
SPRING_PROFILES_ACTIVE=native
Il server di configurazione viene eseguito sulla porta Tomcat 8888 e le proprietà di configurazione dell'applicazione vengono caricate dalle posizioni di ricerca native.
Ora in file:///C:/configprop/, posizionare l'applicazione client - file application.properties. Ad esempio, il nome dell'applicazione client èconfig-client, quindi rinomina il tuo file application.properties come config-client.properties e posiziona il file delle proprietà nel percorso file:///C:/configprop/.
Il codice per il file delle proprietà del client di configurazione è fornito di seguito:
welcome.message = Welcome to Spring cloud config server
Di seguito viene fornito il file di configurazione della build completo:
Gli utenti di Maven possono utilizzare pom.xml dato di seguito -
<?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>
Gli utenti Gradle possono utilizzare il file build.gradle fornito di seguito -
<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}"
}
}
Ora, crea un file JAR eseguibile ed esegui l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, utilizzare il comando fornito di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, utilizzare il comando fornito di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il seguente comando:
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 8888 come mostrato qui -
Ora premi l'URL http://localhost:8888/config-client/default/master sul tuo browser web e puoi vedere le proprietà di configurazione dell'applicazione config-client come mostrato qui.
Alcune applicazioni potrebbero richiedere proprietà di configurazione che potrebbero richiedere una modifica e gli sviluppatori potrebbero dover rimuoverle o riavviare l'applicazione per eseguire questa operazione. Tuttavia, ciò potrebbe comportare tempi di inattività nella produzione e la necessità di riavviare l'applicazione. Spring Cloud Configuration Server consente agli sviluppatori di caricare le nuove proprietà di configurazione senza riavviare l'applicazione e senza tempi di inattività.
Lavorare con Spring Cloud Configuration Server
Innanzitutto, scarica il progetto Spring Boot da https://start.spring.io/e scegli la dipendenza Spring Cloud Config Client. Ora aggiungi la dipendenza Spring Cloud Starter Config nel file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle file.
compile('org.springframework.cloud:spring-cloud-starter-config')
Ora devi aggiungere l'annotazione @RefreshScope alla tua applicazione Spring Boot principale. L'annotazione @RefreshScope viene utilizzata per caricare il valore delle proprietà di configurazione dal server 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);
}
}
Ora aggiungi l'URL del server di configurazione nel file application.properties e fornisci il nome dell'applicazione.
Note - http: // localhost: 8888 config server deve essere eseguito prima di avviare l'applicazione config client.
spring.application.name = config-client
spring.cloud.config.uri = http://localhost:8888
Di seguito viene fornito il codice per scrivere un semplice endpoint REST per leggere il messaggio di benvenuto dal server di configurazione:
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;
}
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, puoi utilizzare il comando mostrato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il comando mostrato di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando mostrato qui:
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 8080 come mostrato qui -
È possibile visualizzare la finestra di accesso della console; l'applicazione config-client sta recuperando la configurazione dal filehttps://localhost:8888
2017-12-08 12:41:57.682 INFO 1104 --- [
main] c.c.c.ConfigServicePropertySourceLocator :
Fetching config from server at: http://localhost:8888
Ora premi l'URL, http://localhost:8080/ messaggio di benvenuto viene caricato dal server di configurazione.
Ora vai e modifica il valore della proprietà sul server di configurazione e premi l'URL POST dell'endpoint dell'attuatore http://localhost:8080/refresh e vedere il nuovo valore della proprietà di configurazione nell'URL http://localhost:8080/
Spring Boot Actuator fornisce endpoint protetti per il monitoraggio e la gestione dell'applicazione Spring Boot. Per impostazione predefinita, tutti i punti finali dell'attuatore sono protetti. In questo capitolo, imparerai in dettaglio come abilitare l'attuatore Spring Boot nella tua applicazione.
Abilitazione dell'attuatore Spring Boot
Per abilitare gli endpoint dell'attuatore Spring Boot nell'applicazione Spring Boot, è necessario aggiungere la dipendenza dell'attuatore Spring Boot Starter nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile group: 'org.springframework.boot', name: 'spring-boot-starter-actuator'
Nel file application.properties, dobbiamo disabilitare la sicurezza per gli endpoint dell'attuatore.
management.security.enabled = false
Gli utenti del file YAML possono aggiungere la seguente proprietà nel file application.yml.
management:
security:
enabled: false
Se si desidera utilizzare il numero di porta separato per accedere agli endpoint dell'attuatore di Spring Boot, aggiungere il numero della porta di gestione nel file application.properties.
management.port = 9000
Gli utenti del file YAML possono aggiungere la seguente proprietà nel file application.yml.
management:
port: 9000
Ora puoi creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, puoi usare il seguente comando:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il seguente comando:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora puoi eseguire il file JAR utilizzando il seguente comando:
java –jar <JARFILE>
Ora l'applicazione è stata avviata sulla porta Tomcat 8080. Notare che se è stato specificato il numero della porta di gestione, la stessa applicazione verrà eseguita su due diversi numeri di porta.
Di seguito sono riportati alcuni importanti endpoint di Spring Boot Actuator. Puoi inserirli nel tuo browser web e monitorare il comportamento dell'applicazione.
ENDPOINT | UTILIZZO |
---|---|
/metrica | Per visualizzare le metriche dell'applicazione come memoria utilizzata, memoria libera, thread, classi, tempo di attività del sistema ecc. |
/ env | Per visualizzare l'elenco delle variabili d'ambiente utilizzate nell'applicazione. |
/fagioli | Per visualizzare i bean Spring e i relativi tipi, ambiti e dipendenze. |
/Salute | Per visualizzare lo stato di salute dell'applicazione |
/Informazioni | Per visualizzare le informazioni sull'applicazione Spring Boot. |
/traccia | Per visualizzare l'elenco delle tracce dei tuoi endpoint di riposo. |
Il monitoraggio dell'applicazione utilizzando Spring Boot Actuator Endpoint è leggermente difficile. Perché, se si dispone di un numero 'n' di applicazioni, ogni applicazione ha endpoint attuatori separati, rendendo così difficile il monitoraggio. Spring Boot Admin Server è un'applicazione utilizzata per gestire e monitorare la tua applicazione Microservice.
Per gestire tali situazioni, CodeCentric Team fornisce un'interfaccia utente di amministrazione Spring Boot per gestire e monitorare tutti gli endpoint dell'attuatore dell'applicazione Spring Boot in un'unica posizione.
Per creare un server di amministrazione Spring Boot, dobbiamo aggiungere le seguenti dipendenze nel file di configurazione della build.
Gli utenti Maven possono aggiungere le seguenti dipendenze nel file 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>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file 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'
Aggiungi l'annotazione @EnableAdminServer nel file di classe dell'applicazione Spring Boot principale. L'annotazione @EnableAdminServer viene utilizzata per rendere il tuo server di amministrazione per monitorare tutti gli altri microservizi.
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);
}
}
Ora, definire il server.port e il nome dell'applicazione nel file application.properties mostrato -
server.port = 9090
spring.application.name = adminserver
Per gli utenti YAML, utilizzare le seguenti proprietà per definire il numero di porta e il nome dell'applicazione nel file application.yml.
server:
port: 9090
spring:
application:
name: adminserver
Di seguito viene fornito il file di configurazione della build.
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, usa il comando mostrato qui -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, usa il comando mostrato qui -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR utilizzando il comando indicato di seguito:
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 9090 come mostrato qui -
Ora premi l'URL sottostante dal tuo browser web e vedi l'interfaccia utente del server di amministrazione.
http://localhost:9090/
Per monitorare e gestire l'applicazione del microservizio tramite Spring Boot Admin Server, è necessario aggiungere la dipendenza del client di avviamento dell'amministratore Spring Boot e indicare l'URI del server Admin nel file delle proprietà dell'applicazione.
Note - Per monitorare un'applicazione, è necessario abilitare gli endpoint di Spring Boot Actuator per la propria applicazione Microservice.
Innanzitutto, aggiungi la seguente dipendenza del client di avviamento dell'amministratore di Spring Boot e la dipendenza dell'attuatore di avviamento di Spring Boot nel file di configurazione della build.
Gli utenti Maven possono aggiungere le seguenti dipendenze nel file 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>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file build.gradle.
compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')
Ora aggiungi l'URL del server di amministrazione Spring Boot nel file delle proprietà dell'applicazione.
Per gli utenti del file delle proprietà, aggiungere le seguenti proprietà nel file application.properties.
spring.boot.admin.url = http://localhost:9090/
Per gli utenti YAML, aggiungi la seguente proprietà nel file application.yml.
spring:
boot:
admin:
url: http://localhost:9000/
Ora, crea un file JAR eseguibile ed esegui l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, puoi usare il comando come mostrato -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando mostrato -
java –jar <JARFILE>
Ora, l'applicazione è stata avviata sulla porta Tomcat 9090 come mostrato -
Ora premi il seguente URL dal tuo browser web e vedi che la tua applicazione Spring Boot è registrata con Spring Boot Admin Server.
http://localhost:9090/
Ora, fai clic su Details e vedere gli endpoint dell'attuatore nell'interfaccia utente di Admin Server.
Swagger2 è un progetto open source utilizzato per generare i documenti API REST per i servizi Web RESTful. Fornisce un'interfaccia utente per accedere ai nostri servizi web RESTful tramite il browser web.
Per abilitare Swagger2 nell'applicazione Spring Boot, è necessario aggiungere le seguenti dipendenze nel nostro file di configurazione della build.
<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>
Per gli utenti Gradle, aggiungi le seguenti dipendenze nel tuo file 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'
Ora aggiungi l'annotazione @ EnableSwagger2 nella tua applicazione Spring Boot principale. L'annotazione @ EnableSwagger2 viene utilizzata per abilitare Swagger2 per la tua applicazione Spring Boot.
Il codice per l'applicazione Spring Boot principale è mostrato di seguito:
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);
}
}
Quindi, crea Docket Bean per configurare Swagger2 per la tua applicazione Spring Boot. Dobbiamo definire il pacchetto di base per configurare le API REST per Swagger2.
@Bean
public Docket productApi() {
return new Docket(DocumentationType.SWAGGER_2).select()
.apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
}
Ora, aggiungi questo bean nel file della classe dell'applicazione Spring Boot principale e la tua classe dell'applicazione Spring Boot principale apparirà come mostrato di seguito:
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();
}
}
Ora, aggiungi la seguente dipendenza Web Spring Boot Starter nel file di configurazione della build per scrivere un endpoint REST come mostrato di seguito -
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle:
compile('org.springframework.boot:spring-boot-starter-web')
Ora, il codice per creare due semplici servizi Web RESTful GET e POST nel file Rest Controller è mostrato qui -
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";
}
}
Di seguito viene fornito il file di configurazione della build completo:
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'
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, puoi usare il comando mostrato qui -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando come mostrato qui -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando mostrato qui -
java –jar <JARFILE>
Ora, l'applicazione verrà avviata sulla porta Tomcat 8080 come mostrato -
Ora, premi l'URL nel tuo browser web e guarda le funzionalità dell'API Swagger.
http://localhost:8080/swagger-ui.html
Docker è un servizio di gestione dei contenitori che semplifica la creazione e la distribuzione. Se sei un principiante di Docker, puoi saperne di più in dettaglio a questo link -https://www.tutorialspoint.com/docker/index.htm
In questo capitolo vedremo come creare un'immagine Docker utilizzando le dipendenze Maven e Gradle per la tua applicazione Spring Boot.
Crea Dockerfile
Innanzitutto, crea un file con il nome Dockerfile sotto le directory src/main/dockercon il contenuto mostrato di seguito. Tieni presente che questo file è importante per creare un'immagine 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"]
Esperto di
Per Maven, aggiungi il plug-in Docker Maven nel file di configurazione della build 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>
Il file pom.xml completo è fornito di seguito:
<?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>
Ora puoi eseguire la tua applicazione utilizzando il comando Maven mvn package docker:build
Note - Abilita il demone Expose tcp://localhost:2375 senza TLS.
Dopo il successo della compilazione, puoi vedere l'output sulla console come mostrato di seguito:
Ora, guarda le immagini Docker dal comando usando immagini Docker e vedi le informazioni sull'immagine sulla console.
Gradle
Per creare un'immagine Docker utilizzando la configurazione di build Gradle, è necessario aggiungere il file docker plugin e devi scrivere un'attività buildDocker per creare un'immagine Docker.
Il codice per la configurazione di Gradle Docker è fornito di seguito.
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
}
}
}
Di seguito viene fornito il file build.gradle completo.
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
}
}
}
Ora, crea un'immagine Docker utilizzando il comando mostrato di seguito:
gradle build buildDocker
Dopo aver eseguito il comando, è possibile visualizzare il registro BUILD SUCCESSFUL nella finestra della console.
Ora, guarda le immagini Docker dal comando usando docker images e vedere le informazioni dell'immagine sulla console.
La maggior parte degli sviluppatori incontra difficoltà nel rintracciare i log in caso di problemi. Questo può essere risolto da Spring Cloud Sleuth e dal server ZipKin per l'applicazione Spring Boot.
Spring Cloud Sleuth
I registri Spring cloud Sleuth vengono stampati nel seguente formato:
[application-name,traceid,spanid,zipkin-export]
Dove,
Nome-applicazione = nome dell'applicazione
Traceid = ogni richiesta e risposta traceid è la stessa quando si chiama lo stesso servizio o un servizio a un altro servizio.
Spanid = Span Id viene stampato insieme all'ID traccia. Lo span Id è diverso da ogni richiesta e risposta che chiama un servizio a un altro servizio.
Zipkin-export = Per impostazione predefinita è falso. Se è vero, i registri verranno esportati sul server Zipkin.
Ora aggiungi la dipendenza Spring Cloud Starter Sleuth nel file di configurazione della build come segue:
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle:
compile('org.springframework.cloud:spring-cloud-starter-sleuth')
Ora aggiungi i log nel file di classe Rest Controller dell'applicazione Spring Boot come mostrato qui -
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!";
}
}
Ora aggiungi il nome dell'applicazione nel file application.properties come mostrato -
spring.application.name = tracinglogs
Di seguito viene fornito il codice completo per il file di configurazione della build:
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}"
}
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, puoi usare il seguente comando:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi utilizzare il seguente comando:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando mostrato qui -
java –jar <JARFILE>
Ora l'applicazione è stata avviata sulla porta Tomcat 8080.
Ora, premi l'URL nel tuo browser web e guarda l'output nel log della console.
http://localhost:8080/
È possibile visualizzare i seguenti registri nella finestra della console. Osserva che il registro viene stampato nel seguente formato [nome-applicazione, traceid, spanid, zipkin-export]
Zipkin Server
Zipkin è un'applicazione che monitora e gestisce i log Spring Cloud Sleuth della tua applicazione Spring Boot. Per creare un server Zipkin, dobbiamo aggiungere l'interfaccia utente Zipkin e le dipendenze del server Zipkin nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file 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>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle -
compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')
Ora, configura server.port = 9411 nel file delle proprietà dell'applicazione.
Per gli utenti del file delle proprietà, aggiungere la proprietà seguente nel file application.properties.
server.port = 9411
Per gli utenti YAML, aggiungi la seguente proprietà nel file application.yml.
server:
port: 9411
Aggiungi l'annotazione @EnableZipkinServer nel file della classe dell'applicazione Spring Boot principale. L'annotazione @EnableZipkinServer viene utilizzata per abilitare la tua applicazione a fungere da server 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);
}
}
Di seguito viene fornito il codice per il file di configurazione della build completo.
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}"
}
}
Puoi creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, utilizzare il comando fornito di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, utilizzare il comando fornito di seguito:
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il comando mostrato -
java –jar <JARFILE>
Ora l'applicazione è stata avviata sulla porta Tomcat 9411 come mostrato di seguito:
Ora, premi l'URL sottostante e vedi l'interfaccia utente del server Zipkin.
http://localhost:9411/zipkin/
Quindi, aggiungi la seguente dipendenza nell'applicazione del servizio client e indica l'URL del server Zipkin per tracciare i log del microservizio tramite l'interfaccia utente di Zipkin.
Ora aggiungi la dipendenza Spring Cloud Starter Zipkin nel file di configurazione della build come mostrato -
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle -
compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')
Ora aggiungi il file Always Sampler Bean nell'applicazione Spring Boot per esportare i log nel server Zipkin.
@Bean
public AlwaysSampler defaultSampler() {
return new AlwaysSampler();
}
Se aggiungi AlwaysSampler Bean, automaticamente l'opzione Spring Sleuth Zipkin Export cambierà da falso a vero.
Quindi, configura l'URL di base del tuo server Zipkin nel file application.properties del servizio client.
spring.zipkin.baseUrl = http://localhost:9411/zipkin/
Quindi, fornire l'ID traccia e trovare le tracce nell'interfaccia utente di Zipkin.
http://localhost:9411/zipkin/traces/{traceid}/
Flyway è un'applicazione di controllo della versione per far evolvere lo schema del database in modo semplice e affidabile in tutte le istanze. Per saperne di più su Flyway, puoi utilizzare il link - www.flywaydb.org
Molti progetti software utilizzano database relazionali. Ciò richiede la gestione delle migrazioni del database, spesso chiamate anche migrazioni dello schema.
In questo capitolo imparerai in dettaglio come configurare il database Flyway nella tua applicazione Spring Boot.
Configurazione del database Flyway
Innanzitutto, scarica il progetto Spring Boot dalla pagina Spring Initializer www.start.spring.io e scegli le seguenti dipendenze:
- Spring Boot Starter Web
- Flyway
- MySQL
- JDBC
Gli utenti Maven possono aggiungere le seguenti dipendenze nel file 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>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file 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')
Nelle proprietà dell'applicazione, dobbiamo configurare le proprietà del database per la creazione di un DataSource e anche le proprietà flyway che dobbiamo configurare nelle proprietà dell'applicazione.
Per gli utenti del file delle proprietà, aggiungere le seguenti proprietà nel file 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
Gli utenti YAML possono aggiungere le seguenti proprietà nel file 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"
Ora, crea un file SQL sotto src/main/resources/db/migrationdirectory. Assegna al file SQL il nome "V1__Initial.sql"
CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');
Di seguito è riportato il codice del file di classe dell'applicazione Spring Boot principale:
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);
}
}
Di seguito viene fornito il file di configurazione completo della build.
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle indicati di seguito:
Per Maven, puoi usare il comando mostrato qui -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando mostrato qui -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il seguente comando:
java –jar <JARFILE>
Ora, Tomcat è stato avviato sulla porta 8080 e nella finestra della console puoi vedere i log del database flyway come mostrato qui.
Ora puoi andare al database ed eseguire le query di selezione.
Utilizzando il servizio web RESTful Spring Boot, puoi inviare un'e-mail con Gmail Transport Layer Security. In questo capitolo, vediamo in dettaglio come utilizzare questa funzione.
Innanzitutto, dobbiamo aggiungere la dipendenza Spring Boot Starter Mail nel file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile('org.springframework.boot:spring-boot-starter-mail')
Di seguito è riportato il codice del file di classe dell'applicazione Spring Boot principale:
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);
}
}
È possibile scrivere una semplice API Rest da inviare all'e-mail nel file di classe Rest Controller come mostrato.
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";
}
}
Puoi scrivere un metodo per inviare l'email con Allegato. Definire le proprietà mail.smtp e utilizzare 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);
}
Ora, chiama il metodo sendmail () sopra dall'API Rest come mostrato -
@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
sendmail();
return "Email sent successfully";
}
Note - Attiva l'opzione Consenti app meno sicure nelle impostazioni del tuo account Gmail prima di inviare un'e-mail.
Di seguito viene fornito il file di configurazione completo della build.
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')
}
Ora puoi creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle mostrati di seguito:
Per Maven, puoi usare il comando come mostrato -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR utilizzando il comando indicato di seguito:
java –jar <JARFILE>
Puoi vedere che l'applicazione è stata avviata sulla porta Tomcat 8080.
Ora premi il seguente URL dal tuo browser web e riceverai un'e-mail.
http://localhost:8080/sendemail
Hystrix è una libreria di Netflix. Hystrix isola i punti di accesso tra i servizi, arresta i guasti a cascata tra di essi e fornisce le opzioni di fallback.
Ad esempio, quando si chiama un 3 ° applicazione partito, ci vuole più tempo per inviare la risposta. Quindi, in quel momento, il controllo passa al metodo di fallback e restituisce la risposta personalizzata all'applicazione.
In questo capitolo vedrai come implementare Hystrix in un'applicazione Spring Boot.
Innanzitutto, dobbiamo aggiungere la dipendenza Spring Cloud Starter Hystrix nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle:
compile('org.springframework.cloud:spring-cloud-starter-hystrix')
Ora aggiungi l'annotazione @EnableHystrix nel file di classe dell'applicazione Spring Boot principale. L'annotazione @EnableHystrix viene utilizzata per abilitare le funzionalità Hystrix nella tua applicazione Spring Boot.
Di seguito è riportato il codice del file di classe dell'applicazione Spring Boot principale:
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);
}
}
Ora scrivi un semplice Rest Controller in modo che restituisca la stringa dopo 3 secondi dal tempo richiesto.
@RequestMapping(value = "/")
public String hello() throws InterruptedException {
Thread.sleep(3000);
return "Welcome Hystrix";
}
Ora aggiungi il comando @Hystrix e @HystrixProperty per l'API Rest e definisci il timeout in millisecondi.
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
Successivamente, definisci il metodo fallback fallback_hello () se la richiesta impiega molto tempo per rispondere.
private String fallback_hello() {
return "Request fails. It takes long time to response";
}
Il file completo della classe Rest Controller che contiene l'API REST e le proprietà Hystrix è mostrato qui -
@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
Thread.sleep(3000);
return "Welcome Hystrix";
}
private String fallback_hello() {
return "Request fails. It takes long time to response";
}
In questo esempio, l'API REST scritta nel file di classe dell'applicazione Spring Boot principale stesso.
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";
}
}
Di seguito viene fornito il file di configurazione completo della build.
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}"
}
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle:
Per Maven, usa il comando come mostrato -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, usa il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR utilizzando il comando indicato di seguito:
java –jar <JARFILE>
Questo avvierà l'applicazione sulla porta Tomcat 8080 come mostrato di seguito -
Ora, premi l'URL http://localhost:8080/dal tuo browser web e guarda la risposta di Hystrix. L'API impiega 3 secondi per rispondere, ma il timeout di Hystrix è di 1 secondo.
In questo capitolo, vediamo come costruire un'applicazione web interattiva usando Spring Boot con i socket web.
Per creare un'applicazione Web interattiva in Spring Boot con Web socket, è necessario aggiungere le seguenti dipendenze.
Gli utenti Maven dovrebbero aggiungere le seguenti dipendenze nel file 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>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file 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")
Creiamo un controller di gestione dei messaggi per lavorare con la messaggistica STOMP. I messaggi STOMP possono essere instradati al file di classe @Controller. Ad esempio, GreetingController è mappato per gestire i messaggi nella destinazione "/ 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() + "!");
}
}
Ora configura Spring per la messaggistica STOMP. Scrivi un file di classe WebSocketConfig che estenda la classe AbstractWebSocketMessageBrokerConfigurer come mostrato di seguito.
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();
}
}
L'annotazione @EnableWebSocketMessageBroker viene utilizzata per configurare il broker di messaggi socket Web per creare endpoint STOMP.
È possibile creare un file client del browser sotto src / main / resources / static / index.html come mostrato -
<!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>
Creiamo un file app.js per consumare e produrre i messaggi utilizzando 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(); });
});
Il codice per l'applicazione Spring Boot principale è mostrato di seguito.
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);
}
}
Di seguito viene fornito il file di configurazione completo della build.
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")
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle come mostrato di seguito:
Per Maven, puoi usare il comando indicato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il comando fornito qui -
java –jar <JARFILE>
Ora l'applicazione è stata avviata sulla porta Tomcat 8080 come mostrato.
Ora, premi l'URL http://localhost:8080/ nel browser Web e collegare la presa Web, inviare il saluto e ricevere il messaggio.
Batch Service è un processo per eseguire più di un comando in una singola attività. In questo capitolo imparerai come creare un servizio batch in un'applicazione Spring Boot.
Consideriamo un esempio in cui salveremo il contenuto del file CSV in HSQLDB.
Per creare un programma Batch Service, è necessario aggiungere la dipendenza Spring Boot Starter Batch e la dipendenza HSQLDB nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere le seguenti dipendenze nel file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file build.gradle.
compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")
Ora aggiungi il semplice file di dati CSV sotto classpath resources - src / main / resources e assegna al file il nome file.csv come mostrato -
William,John
Mike, Sebastian
Lawarance, Lime
Quindi, scrivi uno script SQL per HSQLDB - nella directory delle risorse del percorso di classe - 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)
);
Crea una classe POJO per il modello USERS come mostrato -
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;
}
}
Ora, crea un processore intermedio per eseguire le operazioni dopo la lettura dei dati dal file CSV e prima di scrivere i dati in 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;
}
}
Creiamo un file di configurazione Batch, per leggere i dati da CSV e scrivere nel file SQL come mostrato di seguito. Dobbiamo aggiungere l'annotazione @EnableBatchProcessing nel file della classe di configurazione. L'annotazione @EnableBatchProcessing viene utilizzata per abilitare le operazioni batch per l'applicazione 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();
}
}
Il reader() viene utilizzato per leggere i dati dal file CSV e il metodo writer () viene utilizzato per scrivere i dati nell'SQL.
Successivamente, dovremo scrivere una classe Listener di notifica del completamento del lavoro, utilizzata per notificare dopo il completamento del lavoro.
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.");
}
}
}
}
Ora, crea un file JAR eseguibile ed esegui l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, usa il comando come mostrato -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il comando fornito qui -
java –jar <JARFILE>
Puoi vedere l'output nella finestra della console come mostrato -
Apache Kafka è un progetto open source utilizzato per pubblicare e sottoscrivere i messaggi in base al sistema di messaggistica a tolleranza di errore. È veloce, scalabile e distribuito in base alla progettazione. Se sei un principiante di Kafka, o vuoi approfondirlo, fai riferimento a questo link - www.tutorialspoint.com/apache_kafka/
In questo capitolo, vedremo come implementare Apache Kafka nell'applicazione Spring Boot.
Innanzitutto, dobbiamo aggiungere la dipendenza Spring Kafka nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
<version>2.1.0.RELEASE</version>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'
Produzione di messaggi
Per produrre messaggi in Apache Kafka, dobbiamo definire la classe di configurazione per la configurazione del produttore come mostrato -
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());
}
}
Per pubblicare un messaggio, cablare automaticamente l'oggetto Modello Kafka e produrre il messaggio come mostrato.
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
public void sendMessage(String msg) {
kafkaTemplate.send(topicName, msg);
}
Consumare un messaggio
Per consumare messaggi, dobbiamo scrivere un file di classe di configurazione Consumer come mostrato di seguito.
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;
}
}
Quindi, scrivi un ascoltatore per ascoltare i messaggi.
@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
System.out.println("Received Messasge in group - group-id: " + message);
}
Chiamiamo il metodo sendMessage () dal metodo di esecuzione della classe ApplicationRunner dal file di classe dell'applicazione Spring Boot principale e utilizziamo il messaggio dallo stesso file di classe.
Il codice del file della classe dell'applicazione Spring Boot principale è riportato di seguito:
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");
}
}
Di seguito viene fornito il codice per il file di configurazione della build completo.
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')
}
Ora, crea un file JAR eseguibile ed esegui l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle come mostrato:
Per Maven, usa il comando come mostrato -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, usa il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il comando fornito qui -
java –jar <JARFILE>
Puoi vedere l'output nella finestra della console.
Twilio è un 3 ° un'applicazione di terze parti utilizzato per inviare SMS ed effettuare chiamate vocali dalla nostra applicazione. Ci consente di inviare SMS ed effettuare chiamate vocali in modo programmatico.
In questo capitolo imparerai come implementare l'invio di SMS e le chiamate vocali utilizzando Spring Boot con Twilio.
Note- Abbiamo utilizzato l'account Trail in Twilio per inviare SMS ed effettuare chiamate vocali. Puoi saperne di più su Twilio su www.twilio.com .
Innanzitutto, dobbiamo aggiungere la dipendenza Twilio nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>com.twilio.sdk</groupId>
<artifactId>twilio</artifactId>
<version>7.16.1</version>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"
Ora inizializza l'account Twilio con ACCOUNT_SID e AUTH_ID nel blocco statico come mostrato -
static {
Twilio.init(ACCOUNT_SID, AUTH_ID);
}
Invio di SMS
Per inviare l'SMS, dobbiamo fornire un numero da e un numero al metodo Message.create (). Anche il contenuto del corpo del messaggio dobbiamo fornire il metodo Message.creator () come mostrato -
Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
"Message from Spring Boot Application").create();
Il file di classe dell'applicazione Spring Boot principale appare di seguito.
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();
}
}
Il codice completo per creare il file di configurazione è fornito di seguito:
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.+"
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione di avvio primaverile utilizzando i seguenti comandi Maven o Gradle:
Per Maven, usa il comando come mostrato -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, usa il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Esegui il file JAR utilizzando il comando come indicato di seguito:
java –jar <JARFILE>
Ora riceverai l'SMS al tuo "numero a".
Messaggio ricevuto a "al numero".
Sent from your Twilio trail account
- Message from Spring Boot Application
Note- In questo esempio, abbiamo utilizzato l'account Trail. Quindi, dovresti verificare i numeri prima di inviare l'SMS.
Chiamate vocali
Per effettuare chiamate vocali utilizzando Twilio, dobbiamo chiamare il metodo Call.creator (). Per questo metodo, dobbiamo fornire un numero a, un numero di partenza e una nota vocale come mostrato qui.
Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
new URI("http://demo.twilio.com/docs/voice.xml")).create();
Di seguito viene fornito il codice per il file di classe dell'applicazione Spring Boot principale.
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();
}
}
Di seguito viene fornito il codice per il file di configurazione della build completo:
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.+"
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, usa il comando come mostrato -
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, usa il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando fornito qui -
java –jar <JARFILE>
Ora riceverai una chiamata al tuo "numero" da Twilio.
Premere un tasto qualsiasi dopo aver partecipato alla chiamata, si ascolterà la nota vocale https://demo.twilio.com/docs/voice.xml
Note- In questo esempio, abbiamo utilizzato l'account Trail. Quindi, dovresti verificare i numeri prima di effettuare chiamate.
Lo unit test è uno dei test eseguiti dagli sviluppatori per assicurarsi che le funzionalità delle singole unità o dei componenti funzionino correttamente.
In questo tutorial vedremo come scrivere uno unit test case utilizzando Mockito e Web Controller.
Mockito
Per iniettare Mockito Mocks in Spring Beans, dobbiamo aggiungere la dipendenza Mockito-core nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file 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>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')
Il codice per scrivere una classe Service che contiene un metodo che restituisce il valore String viene fornito qui.
package com.tutorialspoint.mockitodemo;
import org.springframework.stereotype.Service;
@Service
public class ProductService {
public String getProductName() {
return "Honey";
}
}
Ora, inserisci la classe ProductService in un altro file di classe Service come mostrato.
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();
}
}
Di seguito viene fornito il file di classe dell'applicazione Spring Boot principale:
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);
}
}
Quindi, configurare il contesto dell'applicazione per i test. L'annotazione @Profile ("test") viene utilizzata per configurare la classe quando i casi di test sono in esecuzione.
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);
}
}
Ora puoi scrivere un caso di test unitario per Order Service sotto src/test/resources pacchetto.
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);
}
}
Di seguito viene fornito il codice completo per il file di configurazione della build.
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')
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle1.
Per Maven, puoi usare il comando come mostrato -
mvn clean install
Puoi vedere i risultati del test nella finestra della console.
Per Gradle, puoi usare il comando come mostrato -
gradle clean build
Puoi vedere il resto dei risultati nella finestra della console.
Spring Boot fornisce un modo semplice per scrivere un file Unit Test for Rest Controller. Con l'aiuto di SpringJUnit4ClassRunner e MockMvc, possiamo creare un contesto di applicazione web per scrivere il file Unit Test for Rest Controller.
I test unitari devono essere scritti sotto src/test/java le risorse di directory e classpath per scrivere un test dovrebbero essere collocate sotto src/test/resources directory.
Per la scrittura di un test unitario, è necessario aggiungere la dipendenza Spring Boot Starter Test nel file di configurazione della build come mostrato di seguito.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
testCompile('org.springframework.boot:spring-boot-starter-test')
Prima di scrivere un test case, dobbiamo prima creare servizi web RESTful. Per ulteriori informazioni sulla creazione di servizi Web RESTful, fare riferimento al capitolo sugli stessi fornito in questo tutorial.
Scrittura di uno unit test per il controller REST
In questa sezione, vediamo come scrivere uno Unit Test per il controller REST.
Innanzitutto, è necessario creare un file di classe Abstract utilizzato per creare il contesto dell'applicazione Web utilizzando MockMvc e definire i metodi mapToJson () e mapFromJson () per convertire l'oggetto Java in stringa JSON e convertire la stringa JSON in oggetto 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);
}
}
Quindi, scrivi un file di classe che estenda la classe AbstractTest e scrivi uno Unit Test per ogni metodo come GET, POST, PUT e DELETE.
Il codice per il test case GET API è fornito di seguito. Questa API serve per visualizzare l'elenco dei prodotti.
@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);
}
Di seguito viene fornito il codice per il test case POST API. Questa API serve per creare un prodotto.
@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");
}
Il codice per il test case PUT API è fornito di seguito. Questa API serve per aggiornare il prodotto esistente.
@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");
}
Il codice per il test case di eliminazione API è fornito di seguito. Questa API eliminerà il prodotto esistente.
@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");
}
Il file completo della classe Controller Test è fornito di seguito:
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");
}
}
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i comandi Maven o Gradle indicati di seguito:
Per Maven, puoi usare il comando indicato di seguito:
mvn clean install
Ora puoi vedere i risultati del test nella finestra della console.
Per Gradle, puoi utilizzare il comando come mostrato di seguito:
gradle clean build
Puoi vedere il resto dei risultati nella finestra della console come mostrato di seguito.
Spring Boot fornisce un ottimo supporto per creare un'origine dati per database. Non è necessario scrivere codice aggiuntivo per creare un DataSource in Spring Boot. Basta aggiungere le dipendenze e fare i dettagli di configurazione per creare un DataSource e connettere il Database.
In questo capitolo, utilizzeremo la connessione del driver JDBC Spring Boot per connettere il database.
Innanzitutto, dobbiamo aggiungere la dipendenza JDBC di Spring Boot Starter nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere le seguenti dipendenze nel file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file build.gradle.
compile('org.springframework.boot:spring-boot-starter-jdbc')
Connettiti al database H2
Per connettere il database H2, dobbiamo aggiungere la dipendenza del database H2 nel nostro file di configurazione della build.
Per gli utenti Maven, aggiungi la seguente dipendenza nel tuo file pom.xml.
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
Per gli utenti Gradle, aggiungi la seguente dipendenza nel tuo file build.gradle.
compile('com.h2database:h2')
Dobbiamo creare il file schema.sql e il file data.sql nella directory classpath src / main / resources per connettere il database H2.
Il file schema.sql è fornito di seguito.
CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));
Il file data.sql è fornito di seguito.
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');
Connetti MySQL
Per connettere il database MySQL, dobbiamo aggiungere la dipendenza MySQL nel nostro file di configurazione della build.
Per gli utenti Maven, aggiungi la seguente dipendenza nel tuo file pom.xml.
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
Per gli utenti Gradle, aggiungi la seguente dipendenza nel tuo file build.gradle.
compile('mysql:mysql-connector-java')
Ora, crea database e tabelle in MySQL come mostrato -
Per gli utenti del file delle proprietà, aggiungere le seguenti proprietà nel file 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
Per gli utenti YAML, aggiungi le seguenti proprietà nel file 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
Connetti Redis
Redis è un database open source utilizzato per archiviare la struttura dei dati in memoria. Per connettere il database Redis nell'applicazione Spring Boot, dobbiamo aggiungere la dipendenza Redis nel nostro file di configurazione della build.
Gli utenti Maven dovrebbero aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
Gli utenti Gradle dovrebbero aggiungere la seguente dipendenza nel file build.gradle.
compile('org.springframework.boot:spring-boot-starter-data-redis')
Per la connessione Redis, dobbiamo usare RedisTemplate. Per RedisTemplate dobbiamo fornire i dettagli di 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;
}
Ora collega automaticamente la classe RedisTemplate e accedi ai dati dal database Redis.
@Autowired
RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);
JDBCTemplate
Per accedere al database relazionale utilizzando JdbcTemplate nell'applicazione Spring Boot, è necessario aggiungere la dipendenza JDBC Spring Boot Starter nel file di configurazione della build.
Quindi, se hai @Autowired la classe JdbcTemplate, Spring Boot connette automaticamente il database e imposta l'origine dati per l'oggetto JdbcTemplate.
@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");
L'annotazione @Repository dovrebbe essere aggiunta al file di classe. L'annotazione @Repository viene utilizzata per creare un repository di database per l'applicazione Spring Boot.
@Repository
public class ProductServiceDAO {
}
Più DataSource
Possiamo mantenere un numero 'n' di origini dati in una singola applicazione Spring Boot. L'esempio fornito qui mostra come creare più di 1 origine dati nell'applicazione Spring Boot. Ora aggiungi i due dettagli di configurazione dell'origine dati nel file delle proprietà dell'applicazione.
Per gli utenti del file delle proprietà, aggiungere le seguenti proprietà nel file 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
Gli utenti Yaml dovrebbero aggiungere le seguenti proprietà nel file 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
Ora, crea una classe di configurazione per creare un DataSource e un JdbcTemplate per più origini dati.
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);
}
}
Quindi, cablare automaticamente l'oggetto JDBCTemplate utilizzando l'annotazione @Qualifier.
@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;
@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;
Se una dipendenza Spring Boot Security viene aggiunta al classpath, l'applicazione Spring Boot richiede automaticamente l'autenticazione di base per tutti gli endpoint HTTP. L'endpoint "/" e "/ home" non richiede alcuna autenticazione. Tutti gli altri endpoint richiedono l'autenticazione.
Per aggiungere una Spring Boot Security alla tua applicazione Spring Boot, dobbiamo aggiungere la dipendenza Spring Boot Starter Security nel nostro file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile("org.springframework.boot:spring-boot-starter-security")
Protezione di un'applicazione Web
Innanzitutto, crea un'applicazione web non sicura utilizzando i modelli Thymeleaf.
Quindi, crea un file home.html sotto src/main/resources/templates directory.
<!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>
La vista semplice /hello definito nel file HTML utilizzando i modelli Thymeleaf.
Ora, crea un hello.html sotto src/main/resources/templates directory.
<!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>
Ora, dobbiamo configurare Spring MVC - View controller per le visualizzazioni home e hello.
A tale scopo, creare un file di configurazione MVC che estenda 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");
}
}
Ora aggiungi la dipendenza di sicurezza Spring Boot Starter al file di configurazione della build.
Gli utenti Maven possono aggiungere la seguente dipendenza nel file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
Gli utenti Gradle possono aggiungere la seguente dipendenza nel file build.gradle.
compile("org.springframework.boot:spring-boot-starter-security")
Ora, crea un file di configurazione della sicurezza Web, che viene utilizzato per proteggere la tua applicazione per accedere agli endpoint HTTP utilizzando l'autenticazione di base.
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");
}
}
Ora crea un file login.html sotto src/main/resources directory per consentire all'utente di accedere all'endpoint HTTP tramite la schermata di accesso.
<!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>
Infine, aggiorna il file hello.html - per consentire all'utente di disconnettersi dall'applicazione e visualizzare il nome utente corrente come mostrato di seguito -
<!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>
Di seguito viene fornito il codice per l'applicazione Spring Boot principale:
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);
}
}
Di seguito viene fornito il codice completo per il file di configurazione della build.
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')
}
Ora, crea un file JAR eseguibile ed esegui l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Gli utenti di Maven possono utilizzare il comando come indicato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Gli utenti Gradle possono utilizzare il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR utilizzando il comando mostrato di seguito:
java –jar <JARFILE>
Premi l'URL http://localhost:8080/nel tuo browser web. Puoi vedere l'output come mostrato.
In questo capitolo imparerai in dettaglio i meccanismi di Spring Boot Security e OAuth2 con JWT.
Server di autorizzazione
Authorization Server è un componente architettonico supremo per Web API Security. Il server di autorizzazione funge da punto di autorizzazione di centralizzazione che consente alle app e agli endpoint HTTP di identificare le funzionalità della tua applicazione.
Resource Server
Resource Server è un'applicazione che fornisce il token di accesso ai client per accedere agli endpoint HTTP di Resource Server. È una raccolta di librerie che contiene gli endpoint HTTP, le risorse statiche e le pagine Web dinamiche.
OAuth2
OAuth2 è un framework di autorizzazione che consente all'applicazione Web Security di accedere alle risorse dal client. Per creare un'applicazione OAuth2, dobbiamo concentrarci sul tipo di concessione (codice di autorizzazione), sull'ID client e sul segreto del client.
Token JWT
Il token JWT è un token Web JSON, utilizzato per rappresentare le rivendicazioni protette tra due parti. Puoi saperne di più sul token JWT su www.jwt.io/ .
Ora, costruiremo un'applicazione OAuth2 che abiliti l'uso di Authorization Server, Resource Server con l'aiuto di un token JWT.
È possibile utilizzare i seguenti passaggi per implementare Spring Boot Security con token JWT accedendo al database.
Innanzitutto, dobbiamo aggiungere le seguenti dipendenze nel nostro file di configurazione della build.
Gli utenti di Maven possono aggiungere le seguenti dipendenze nel file 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>
Gli utenti Gradle possono aggiungere le seguenti dipendenze nel file 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")
dove,
Spring Boot Starter Security - Implementa la Spring Security
Spring Security OAuth2 - Implementa la struttura OAUTH2 per abilitare il server di autorizzazione e il server di risorse.
Spring Security JWT - Genera il token JWT per la sicurezza Web
Spring Boot Starter JDBC - Accede al database per assicurarsi che l'utente sia disponibile o meno.
Spring Boot Starter Web - Scrive endpoint HTTP.
H2 Database - Memorizza le informazioni dell'utente per l'autenticazione e l'autorizzazione.
Di seguito viene fornito il file di configurazione completo della build.
<?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")
}
Ora, nell'applicazione Spring Boot principale, aggiungi l'annotazione @EnableAuthorizationServer e @EnableResourceServer per agire come server di autenticazione e server di risorse nella stessa applicazione.
Inoltre, puoi utilizzare il codice seguente per scrivere un semplice endpoint HTTP per accedere all'API con Spring Security utilizzando il token 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";
}
}
Utilizzare il codice seguente per definire la classe POJO per memorizzare le informazioni sull'utente per l'autenticazione.
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;
}
}
Utilizzare ora il codice seguente e definire la classe CustomUser che estende la classe org.springframework.security.core.userdetails.User per l'autenticazione 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());
}
}
È possibile creare la classe @Repository per leggere le informazioni sull'utente dal database e inviarle al servizio utente personalizzato e aggiungere anche l'autorizzazione concessa "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;
}
}
È possibile creare una classe del servizio dettagli utente personalizzato che estende org.springframework.security.core.userdetails.UserDetailsService per chiamare la classe del repository DAO come mostrato.
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");
}
}
}
Quindi, creare una classe @configuration per abilitare Web Security, definendo il codificatore di password (BCryptPasswordEncoder) e definendo il bean AuthenticationManager. La classe di configurazione Security dovrebbe estendere la classe 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();
}
}
Ora, definire la classe di configurazione OAuth2 per aggiungere l'ID client, il segreto client, definire il JwtAccessTokenConverter, la chiave privata e la chiave pubblica per la chiave del firmatario del token e della chiave del verificatore e configurare ClientDetailsServiceConfigurer per la validità del token con gli ambiti.
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);
}
}
Ora, crea una chiave privata e una chiave pubblica utilizzando openssl.
È possibile utilizzare i seguenti comandi per generare la chiave privata.
openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem
È possibile utilizzare Per la generazione della chiave pubblica utilizzare i comandi seguenti.
openssl rsa -in jwt.pem -pubout
Per la versione di Spring Boot successiva alla 1.5, aggiungi la proprietà seguente nel tuo file application.properties per definire l'ordine del filtro delle risorse OAuth2.
security.oauth2.resource.filter-order=3
Gli utenti del file YAML possono aggiungere la seguente proprietà nel file YAML.
security:
oauth2:
resource:
filter-order: 3
Ora, crea il file schema.sql e data.sql nelle risorse del percorso di classe src/main/resources/directory per connettere l'applicazione al database H2.
Il file schema.sql è come mostrato -
CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));
Il file data.sql è come mostrato -
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 - La password deve essere memorizzata nel formato di Bcrypt Encoder nella tabella del database.
È possibile creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando i seguenti comandi Maven o Gradle.
Per Maven, puoi usare il comando indicato di seguito:
mvn clean install
Dopo "BUILD SUCCESS", è possibile trovare il file JAR nella directory di destinazione.
Per Gradle, puoi usare il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Ora, esegui il file JAR usando il comando mostrato qui -
java –jar <JARFILE>
L'applicazione viene avviata sulla porta Tomcat 8080.
Ora premi l'URL del metodo POST tramite POSTMAN per ottenere il token OAUTH2.
http://localhost:8080/oauth/token
Ora aggiungi le intestazioni della richiesta come segue:
Authorization - Autenticazione di base con il tuo ID cliente e segreto cliente.
Content Type - application / x-www-form-urlencoded
Ora aggiungi i parametri di richiesta come segue:
- grant_type = password
- username = il tuo nome utente
- password = la tua password
Ora premi l'API e ottieni access_token come mostrato -
Ora, premi l'API del server delle risorse con il token di accesso al portatore nell'intestazione della richiesta come mostrato.
Quindi puoi vedere l'output come mostrato di seguito -
Google Cloud Platform fornisce servizi di cloud computing che eseguono l'applicazione Spring Boot nell'ambiente cloud. In questo capitolo vedremo come distribuire l'applicazione Spring Boot nella piattaforma del motore di app GCP.
Innanzitutto, scarica l'applicazione Gradle build Spring Boot dalla pagina Spring Initializer www.start.spring.io . Osserva il seguente screenshot.
Ora, nel file build.gradle, aggiungi il plug-in appengine di Google Cloud e la dipendenza del percorso di classe appengine.
Il codice per il file build.gradle è fornito di seguito:
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')
}
Ora scrivi un semplice endpoint HTTP e restituisce il successo della stringa come mostrato -
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";
}
}
Quindi, aggiungi il file app.yml nella directory src / main / appengine come mostrato -
runtime: java
env: flex
handlers:
- url: /.*
script: this field is required, but ignored
Ora vai alla console di Google Cloud e fai clic su Attiva Google Cloud Shell nella parte superiore della pagina.
Ora sposta i tuoi file sorgente e il file Gradle nella home directory della tua macchina cloud Google utilizzando Google Cloud Shell.
Ora, esegui il comando gradle appengineDeploy e distribuirà la tua applicazione nell'appengine di Google Cloud.
Note - GCP deve essere abilitato per la fatturazione e prima di distribuire la tua applicazione in appengine, devi creare la piattaforma appengine in GCP.
Ci vorranno alcuni minuti per distribuire la tua applicazione nella piattaforma GCP appengine.
Una volta completata la compilazione, puoi vedere l'URL del servizio nella finestra della console.
Ora, premi l'URL del servizio e guarda l'output.
Google Cloud SQL
Per connettere Google Cloud SQL alla tua applicazione Spring Boot, devi aggiungere le seguenti proprietà nel tuo file application.properties.
Formato 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 - L'applicazione Spring Boot e Google Cloud SQL dovrebbero trovarsi nello stesso progetto GCP.
Il file application.properties è fornito di seguito.
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
Gli utenti del file YAML possono aggiungere le seguenti proprietà al file 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
In questo capitolo vedremo come aggiungere l'accesso a Google OAuth2 utilizzando l'applicazione Spring Boot con Gradle build.
Innanzitutto, aggiungi la dipendenza di sicurezza Spring Boot OAuth2 nel file di configurazione della build e il file di configurazione della build viene fornito di seguito.
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')
}
Ora aggiungi l'endpoint HTTP per leggere l'entità utente da Google dopo l'autenticazione tramite Spring Boot nel file di classe dell'applicazione Spring Boot principale come indicato di seguito:
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;
}
}
Ora scrivi un file di configurazione per abilitare OAuth2SSO per la sicurezza web e rimuovi l'autenticazione per il file index.html come mostrato -
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();
}
}
Successivamente, aggiungi il file index.html in risorse statiche e aggiungi il link per reindirizzare nell'endpoint HTTP dell'utente per leggere il Principal utente di Google come mostrato di seguito:
<!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 - Nella console di Google Cloud: abilitare i servizi Gmail, i servizi di analisi e le API dei servizi Google+.
Quindi, vai alla sezione Credenziali e crea le credenziali e scegli OAuth Client ID.
Successivamente, fornisci un nome prodotto nella schermata di consenso OAuth2.
Quindi, scegli il tipo di applicazione come "applicazione Web", fornisci le origini JavaScript autorizzate e gli URI di reindirizzamento autorizzati.
Ora, l'ID client OAuth2 e il segreto client sono stati creati.
Successivamente, aggiungi l'ID client e il segreto client nel file delle proprietà dell'applicazione.
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
Ora puoi creare un file JAR eseguibile ed eseguire l'applicazione Spring Boot utilizzando il seguente comando Gradle.
Per Gradle, puoi usare il comando come mostrato -
gradle clean build
Dopo "BUILD SUCCESSFUL", è possibile trovare il file JAR nella directory build / libs.
Eseguire il file JAR utilizzando il comando java –jar <JARFILE> e l'applicazione viene avviata sulla porta Tomcat 8080.
Ora premi l'URL http://localhost:8080/ e fare clic sul collegamento di accesso a Google.
Reindirizzerà alla schermata di accesso di Google e fornirà i dettagli di accesso a Gmail.
Se il login ha esito positivo, riceveremo l'oggetto Principal dell'utente Gmail.