Spring Boot - Guía rápida

Spring Boot es un marco de código abierto basado en Java que se utiliza para crear un microservicio. Está desarrollado por Pivotal Team y se utiliza para construir aplicaciones de resortes independientes y listas para producción. Este capítulo le dará una introducción a Spring Boot y lo familiarizará con sus conceptos básicos.

¿Qué es Micro Service?

Micro Service es una arquitectura que permite a los desarrolladores desarrollar e implementar servicios de forma independiente. Cada servicio en ejecución tiene su propio proceso y esto logra el modelo liviano para admitir aplicaciones comerciales.

Ventajas

Los microservicios ofrecen las siguientes ventajas a sus desarrolladores:

• Despliegue sencillo
• Escalabilidad simple
• Compatible con contenedores
• Configuración mínima
• Menor tiempo de producción

¿Qué es Spring Boot?

Spring Boot proporciona una buena plataforma para que los desarrolladores de Java desarrollen una aplicación de primavera independiente y de grado de producción que puede just run. Puede comenzar con configuraciones mínimas sin la necesidad de una configuración completa de Spring.

Ventajas

Spring Boot ofrece las siguientes ventajas a sus desarrolladores:

• Aplicaciones de muelles fáciles de entender y desarrollar
• Aumenta la productividad
• Reduce el tiempo de desarrollo

Metas

Spring Boot está diseñado con los siguientes objetivos:

• Para evitar una configuración XML compleja en Spring
• Desarrollar aplicaciones Spring listas para producción de una manera más fácil
• Para reducir el tiempo de desarrollo y ejecutar la aplicación de forma independiente
• Ofrezca una forma más sencilla de comenzar con la aplicación

¿Por qué Spring Boot?

Puede elegir Spring Boot debido a las características y beneficios que ofrece como se indica aquí:

• Proporciona una forma flexible de configurar Java Beans, configuraciones XML y transacciones de bases de datos.

• Proporciona un potente procesamiento por lotes y gestiona los puntos finales REST.

• En Spring Boot, todo se configura automáticamente; no se necesitan configuraciones manuales.

• Ofrece una aplicación de resorte basada en anotaciones.

• Facilita la gestión de la dependencia

• Incluye contenedor de servlet integrado

¿Como funciona?

Spring Boot configura automáticamente su aplicación en función de las dependencias que ha agregado al proyecto utilizando @EnableAutoConfigurationanotación. Por ejemplo, si la base de datos MySQL está en su classpath, pero no ha configurado ninguna conexión de base de datos, Spring Boot configura automáticamente una base de datos en memoria.

El punto de entrada de la aplicación Spring Boot es la clase que contiene @SpringBootApplication anotación y el método principal.

Spring Boot escanea automáticamente todos los componentes incluidos en el proyecto usando @ComponentScan anotación.

Arrancadores Spring Boot

Manejar la gestión de la dependencia es una tarea difícil para los grandes proyectos. Spring Boot resuelve este problema proporcionando un conjunto de dependencias para la conveniencia de los desarrolladores.

Por ejemplo, si desea utilizar Spring y JPA para el acceso a la base de datos, es suficiente si incluye spring-boot-starter-data-jpa dependencia en su proyecto.

Tenga en cuenta que todos los arrancadores Spring Boot siguen el mismo patrón de nomenclatura spring-boot-starter- *, donde * indica que es un tipo de aplicación.

Ejemplos

Mire los siguientes arrancadores de Spring Boot que se explican a continuación para una mejor comprensión:

Spring Boot Starter Actuator dependencyse utiliza para monitorear y administrar su aplicación. Su código se muestra a continuación:

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

Spring Boot Starter Security dependencyse utiliza para Spring Security. Su código se muestra a continuación:

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

Spring Boot Starter web dependencyse utiliza para escribir un Rest Endpoints. Su código se muestra a continuación:

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

Spring Boot Starter Thyme Leaf dependencyse utiliza para crear una aplicación web. Su código se muestra a continuación:

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

Spring Boot Starter Test dependencyse utiliza para escribir casos de prueba. Su código se muestra a continuación:

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

Configuración automática

Spring Boot Auto Configuration configura automáticamente su aplicación Spring en función de las dependencias JAR que agregó en el proyecto. Por ejemplo, si la base de datos MySQL está en su ruta de clases, pero no ha configurado ninguna conexión de base de datos, Spring Boot configura automáticamente una base de datos en memoria.

Para este propósito, debe agregar @EnableAutoConfiguration anotación o @SpringBootApplicationanotación a su archivo de clase principal. Luego, su aplicación Spring Boot se configurará automáticamente.

Observe el siguiente código para una mejor comprensión:

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

Aplicación Spring Boot

El punto de entrada de la aplicación Spring Boot es la clase que contiene @SpringBootApplicationanotación. Esta clase debe tener el método principal para ejecutar la aplicación Spring Boot.@SpringBootApplication La anotación incluye la configuración automática, la exploración de componentes y la configuración de arranque con resorte.

Si agregaste @SpringBootApplication anotación a la clase, no es necesario agregar la @EnableAutoConfiguration, @ComponentScan y @SpringBootConfigurationanotación. los@SpringBootApplication la anotación incluye todas las demás anotaciones.

Observe el siguiente código para una mejor comprensión:

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

Escaneo de componentes

La aplicación Spring Boot analiza todos los beans y las declaraciones de paquetes cuando la aplicación se inicializa. Necesitas agregar el@ComponentScan anotación para su archivo de clase para escanear sus componentes agregados en su proyecto.

Observe el siguiente código para una mejor comprensión:

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

Este capítulo le enseñará cómo crear una aplicación Spring Boot usando Maven y Gradle.

Prerrequisitos

Su sistema debe tener los siguientes requisitos mínimos para crear una aplicación Spring Boot:

• Java 7
• Maven 3.2
• Gradle 2.5

Spring Boot CLI

Spring Boot CLI es una herramienta de línea de comandos y nos permite ejecutar los scripts Groovy. Esta es la forma más sencilla de crear una aplicación Spring Boot mediante la interfaz de línea de comandos de Spring Boot. Puede crear, ejecutar y probar la aplicación en el símbolo del sistema.

Esta sección le explica los pasos involucrados en la instalación manual de Spring Boot CLI. Para obtener más ayuda, puede utilizar el siguiente enlace:https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot

También puede descargar la distribución de Spring CLI desde el repositorio de Spring Software en: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation

Para la instalación manual, debe utilizar las dos carpetas siguientes:

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

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

Después de la descarga, descomprima el archivo comprimido y siga los pasos dados en el archivo install.txt. No es que no requiera ninguna configuración de entorno.

En Windows, vaya a la CLI de Spring Boot bin directorio en el símbolo del sistema y ejecute el comando spring –-versionpara asegurarse de que Spring CLI esté instalado correctamente. Después de ejecutar el comando, puede ver la versión de CLI de primavera como se muestra a continuación:

Ejecute Hello World con Groovy

Cree un archivo maravilloso simple que contenga el script Rest Endpoint y ejecute el archivo maravilloso con Spring Boot CLI. Observe el código que se muestra aquí para este propósito:

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

Ahora, guarde el archivo maravilloso con el nombre hello.groovy. Tenga en cuenta que en este ejemplo, guardamos el archivo maravilloso dentro de la CLI de Spring Bootbindirectorio. Ahora ejecute la aplicación usando el comandospring run hello.groovy como se muestra en la captura de pantalla que se muestra a continuación:

Una vez que ejecute el archivo maravilloso, las dependencias requeridas se descargarán automáticamente e iniciará la aplicación en el puerto Tomcat 8080 como se muestra en la captura de pantalla que se muestra a continuación:

Una vez que se inicie Tomcat, vaya al navegador web y presione la URL http://localhost:8080/ y puede ver la salida como se muestra.

Este capítulo le explicará cómo realizar bootstrapping en una aplicación Spring Boot.

Spring Initializer

Una de las formas de iniciar una aplicación Spring Boot es utilizando Spring Initializer. Para hacer esto, tendrá que visitar la página web de Spring Initializer www.start.spring.io y elegir su Build, Spring Boot Version y plataforma. Además, debe proporcionar un grupo, un artefacto y las dependencias necesarias para ejecutar la aplicación.

Observe la siguiente captura de pantalla que muestra un ejemplo donde agregamos el spring-boot-starter-web dependencia para escribir puntos finales REST.

Una vez que haya proporcionado el grupo, el artefacto, las dependencias, el proyecto de compilación, la plataforma y la versión, haga clic en Generate Projectbotón. El archivo zip se descargará y se extraerán los archivos.

En esta sección, se explican los ejemplos mediante el uso de Maven y Gradle.

Maven

Después de descargar el proyecto, descomprima el archivo. Ahora tupom.xml archivo se ve como se muestra a continuación -

<?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 vez que descargue el proyecto, descomprima el archivo. Ahora tubuild.gradle archivo se ve como se muestra a continuación -

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

Dependencias de la ruta de clases

Spring Boot proporciona una serie de Starterspara agregar los tarros en nuestra ruta de clases. Por ejemplo, para escribir un punto final de descanso, necesitamos agregar elspring-boot-starter-webdependencia en nuestra ruta de clases. Observe los códigos que se muestran a continuación para una mejor comprensión:

Dependencia de Maven

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

Dependencia de Gradle

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

Método principal

El método principal debería ser escribir la clase de aplicación Spring Boot. Esta clase debe estar anotada con@SpringBootApplication. Este es el punto de entrada de la aplicación Spring Boot para comenzar. Puede encontrar el archivo de clase principal ensrc/java/main directorios con el paquete predeterminado.

En este ejemplo, el archivo de clase principal se encuentra en el src/java/main directorios con el paquete predeterminado com.tutorialspoint.demo. Observe el código que se muestra aquí para una mejor comprensión:

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

Escribir un punto final de descanso

Para escribir un punto final de descanso Hello World simple en el archivo de clase principal de la aplicación Spring Boot, siga los pasos que se muestran a continuación:

• En primer lugar, agregue el @RestController anotación en la parte superior de la clase.

• Ahora, escriba un método Request URI con @RequestMapping anotación.

• Luego, el método Request URI debería devolver el Hello World cuerda.

Ahora, su archivo de clase principal de la aplicación Spring Boot se verá como se muestra en el código que se proporciona a continuación:

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

Crear un archivo JAR ejecutable

Creemos un archivo JAR ejecutable para ejecutar la aplicación Spring Boot utilizando los comandos Maven y Gradle en el símbolo del sistema como se muestra a continuación:

Utilice el comando de Maven mvn clean install como se muestra a continuación:

Después de ejecutar el comando, puede ver el BUILD SUCCESS mensaje en el símbolo del sistema como se muestra a continuación -

Usa el comando de Gradle gradle clean build como se muestra a continuación -

Después de ejecutar el comando, puede ver el BUILD SUCCESSFUL mensaje en el símbolo del sistema como se muestra a continuación:

Ejecuta Hello World con Java

Una vez que haya creado un archivo JAR ejecutable, puede encontrarlo en los siguientes directorios.

Para Maven, puede encontrar el archivo JAR en el directorio de destino como se muestra a continuación:

Para Gradle, puede encontrar el archivo JAR en el build/libs directorio como se muestra a continuación -

Ahora, ejecute el archivo JAR usando el comando java –jar <JARFILE>. Observe que en el ejemplo anterior, el archivo JAR se llamademo-0.0.1-SNAPSHOT.jar

Una vez que ejecute el archivo jar, puede ver el resultado en la ventana de la consola como se muestra a continuación:

Ahora, mire la consola, Tomcat comenzó en el puerto 8080 (http). Ahora, vaya al navegador web y presione la URLhttp://localhost:8080/ y puede ver el resultado como se muestra a continuación:

Al usar la aplicación Spring Boot, podemos crear un archivo war para implementar en el servidor web. En este capítulo, aprenderá a crear un archivo WAR e implementar la aplicación Spring Boot en el servidor web Tomcat.

Inicializador Spring Boot Servlet

La forma tradicional de implementación es hacer que la aplicación Spring Boot @SpringBootApplication clase extender el SpringBootServletInitializerclase. El archivo de clase Spring Boot Servlet Initializer le permite configurar la aplicación cuando se inicia mediante Servlet Container.

El código para el archivo de clase de la aplicación Spring Boot para la implementación del archivo JAR se proporciona a continuación:

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

Necesitamos extender la clase SpringBootServletInitializerpara admitir la implementación de archivos WAR. El código del archivo de clase de la aplicación Spring Boot se proporciona a continuación:

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

Configuración de la clase principal

En Spring Boot, debemos mencionar la clase principal que debería comenzar en el archivo de compilación. Para este propósito, puede utilizar los siguientes fragmentos de código:

Para Maven, agregue la clase de inicio en pom.xml propiedades como se muestra a continuación -

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

Para Gradle, agregue el nombre de la clase principal en build.gradle como se muestra a continuación:

mainClassName="com.tutorialspoint.demo.DemoApplication"

Actualizar el paquete JAR en WAR

Tenemos que actualizar el paquete JAR en WAR usando los siguientes fragmentos de código:

Para Maven, agregue el empaque como WAR en pom.xml como se muestra a continuación -

<packaging>war</packaging>

Para Gradle, agregue el complemento de aplicación y el complemento de guerra en el build.gradle como se muestra a continuación -

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

Ahora, vamos a escribir un punto final de descanso simple para devolver la cadena "Hola mundo desde Tomcat". Para escribir un punto final de descanso, debemos agregar la dependencia del iniciador web Spring Boot en nuestro archivo de compilación.

Para Maven, agregue la dependencia de inicio Spring Boot en pom.xml usando el código que se muestra a continuación:

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

Para Gradle, agregue la dependencia de inicio Spring Boot en build.gradle usando el código como se muestra a continuación -

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

Ahora, escriba un punto final de descanso simple en el archivo de clase de la aplicación Spring Boot usando el código como se muestra a continuación:

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

Empaquetado de su aplicación

Ahora, cree un archivo WAR para implementarlo en el servidor Tomcat utilizando los comandos Maven y Gradle para empaquetar su aplicación como se indica a continuación:

Para Maven, use el comando mvn packagepara empaquetar su aplicación. Luego, se creará el archivo WAR y puede encontrarlo en el directorio de destino como se muestra en las capturas de pantalla que se muestran a continuación:

Para Gradle, usa el comando gradle clean buildpara empaquetar su aplicación. Luego, se creará su archivo WAR y podrá encontrarlo enbuild/libsdirectorio. Observe las capturas de pantalla que se proporcionan aquí para una mejor comprensión:

Implementar en Tomcat

Ahora, ejecute el servidor Tomcat e implemente el archivo WAR en el webappsdirectorio. Observe las capturas de pantalla que se muestran aquí para una mejor comprensión:

Después de una implementación exitosa, presione la URL en su navegador web http://localhost:8080/demo-0.0.1-SNAPSHOT/ y observe que la salida se verá como se muestra en la captura de pantalla que se muestra a continuación:

El código completo para este propósito se proporciona a continuación.

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

El código para el archivo de clase de la aplicación Spring Boot principal se proporciona a continuación:

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

En Spring Boot, elegir un sistema de compilación es una tarea importante. Recomendamos Maven o Gradle, ya que brindan un buen soporte para la gestión de dependencias. Spring no es compatible con otros sistemas de construcción.

Gestión de dependencias

El equipo de Spring Boot proporciona una lista de dependencias para admitir la versión de Spring Boot para cada versión. No es necesario que proporcione una versión para las dependencias en el archivo de configuración de compilación. Spring Boot configura automáticamente la versión de las dependencias según la versión. Recuerde que cuando actualice la versión Spring Boot, las dependencias también se actualizarán automáticamente.

Note- Si desea especificar la versión para la dependencia, puede especificarla en su archivo de configuración. Sin embargo, el equipo de Spring Boot recomienda encarecidamente que no es necesario especificar la versión para la dependencia.

Dependencia de Maven

Para la configuración de Maven, debemos heredar el proyecto principal Spring Boot Starter para administrar las dependencias de Spring Boot Starters. Para esto, simplemente podemos heredar el padre inicial en nuestropom.xml archivo como se muestra a continuación.

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

Debemos especificar el número de versión para la dependencia de Spring Boot Parent Starter. Luego, para otras dependencias de inicio, no necesitamos especificar el número de versión de Spring Boot. Observe el código que se proporciona a continuación:

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

Dependencia de Gradle

Podemos importar las dependencias de Spring Boot Starters directamente a build.gradlearchivo. No necesitamos Spring Boot start Dependencia de padres como Maven para Gradle. Observe el código que se proporciona a continuación:

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

De manera similar, en Gradle, no necesitamos especificar el número de versión de Spring Boot para las dependencias. Spring Boot configura automáticamente la dependencia según la versión.

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

Spring Boot no tiene ningún diseño de código con el que trabajar. Sin embargo, existen algunas mejores prácticas que nos ayudarán. Este capítulo habla de ellos en detalle.

Paquete predeterminado

Una clase que no tiene ninguna declaración de paquete se considera un default package. Tenga en cuenta que, en general, no se recomienda una declaración de paquete predeterminada. Spring Boot causará problemas como el mal funcionamiento de la configuración automática o el escaneo de componentes, cuando usa el paquete predeterminado.

Note- La convención de nomenclatura recomendada por Java para la declaración de paquetes es el nombre de dominio invertido. Por ejemplocom.tutorialspoint.myproject

Disposición típica

El diseño típico de la aplicación Spring Boot se muestra en la imagen que se muestra a continuación:

El archivo Application.java debe declarar el método principal junto con @SpringBootApplication. Observe el código que se proporciona a continuación para una mejor comprensión:

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

En Spring Boot, podemos usar Spring Framework para definir nuestros beans y su inyección de dependencia. los@ComponentScan La anotación se usa para encontrar frijoles y el correspondiente inyectado con @Autowired anotación.

Si siguió el diseño típico de Spring Boot, no es necesario especificar ningún argumento para @ComponentScananotación. Todos los archivos de clases de componentes se registran automáticamente con Spring Beans.

El siguiente ejemplo proporciona una idea sobre el cableado automático del objeto Rest Template y la creación de un Bean para el mismo:

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

El siguiente código muestra el código para el objeto de plantilla de descanso cableado automáticamente y el objeto de creación de Bean en el archivo de clase principal de la aplicación 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();   
   }
}

Las interfaces Application Runner y Command Line Runner le permiten ejecutar el código después de que se inicia la aplicación Spring Boot. Puede utilizar estas interfaces para realizar cualquier acción inmediatamente después de que se haya iniciado la aplicación. Este capítulo habla de ellos en detalle.

Ejecutor de la aplicación

Application Runner es una interfaz utilizada para ejecutar el código después de que se inició la aplicación Spring Boot. El ejemplo que se muestra a continuación muestra cómo implementar la interfaz de Application Runner en el archivo de clase principal.

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

Ahora, si observa la ventana de la consola a continuación Hello World from Application Runner, la instrucción println se ejecuta después de que se inicie Tomcat. ¿Es relevante la siguiente captura de pantalla?

Ejecutor de línea de comandos

Command Line Runner es una interfaz. Se utiliza para ejecutar el código después de que se inició la aplicación Spring Boot. El ejemplo que se muestra a continuación muestra cómo implementar la interfaz Command Line Runner en el archivo de clase principal.

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

Mire la ventana de la consola debajo de “Hola mundo desde Command Line Runner”, la declaración println se ejecuta después de que se inició Tomcat.

Las propiedades de la aplicación nos apoyan para trabajar en diferentes entornos. En este capítulo, aprenderá a configurar y especificar las propiedades de una aplicación Spring Boot.

Propiedades de la línea de comandos

La aplicación Spring Boot convierte las propiedades de la línea de comandos en propiedades del entorno Spring Boot. Las propiedades de la línea de comandos tienen prioridad sobre las otras fuentes de propiedades. De forma predeterminada, Spring Boot usa el número de puerto 8080 para iniciar Tomcat. Aprendamos cómo cambiar el número de puerto usando las propiedades de la línea de comandos.

Step 1 - Después de crear un archivo JAR ejecutable, ejecútelo usando el comando java –jar <JARFILE>.

Step 2 - Use el comando dado en la captura de pantalla que se muestra a continuación para cambiar el número de puerto para la aplicación Spring Boot usando las propiedades de la línea de comando.

Note - Puede proporcionar más de una propiedad de aplicación utilizando el delimitador -.

Archivo de propiedades

Los archivos de propiedades se utilizan para mantener un número 'N' de propiedades en un solo archivo para ejecutar la aplicación en un entorno diferente. En Spring Boot, las propiedades se mantienen en elapplication.properties archivo bajo la ruta de clase.

El archivo application.properties se encuentra en el src/main/resourcesdirectorio. El código de muestraapplication.properties archivo se da a continuación -

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

Tenga en cuenta que en el código que se muestra arriba, el servicio de demostración de la aplicación Spring Boot comienza en el puerto 9090.

Archivo YAML

Spring Boot admite configuraciones de propiedades basadas en YAML para ejecutar la aplicación. En vez deapplication.properties, nosotros podemos usar application.ymlarchivo. Este archivo YAML también debe mantenerse dentro de la ruta de clases. La muestraapplication.yml archivo se da a continuación -

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

Propiedades externalizadas

En lugar de mantener el archivo de propiedades en classpath, podemos mantener las propiedades en una ubicación o ruta diferente. Mientras ejecutamos el archivo JAR, podemos especificar la ruta del archivo de propiedades. Puede usar el siguiente comando para especificar la ubicación del archivo de propiedades mientras ejecuta el JAR:

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

Uso de la anotación @Value

La anotación @Value se utiliza para leer el valor de propiedad del entorno o de la aplicación en el código Java. La sintaxis para leer el valor de la propiedad se muestra a continuación:

@Value("${property_key_name}")

Mire el siguiente ejemplo que muestra la sintaxis para leer el spring.application.name valor de propiedad en la variable Java mediante la anotación @Value.

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

Observe el código que se proporciona a continuación para una mejor comprensión:

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 - Si no se encuentra la propiedad mientras se ejecuta la aplicación, Spring Boot lanza la excepción de argumento ilegal como Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}".

Para resolver el problema del marcador de posición, podemos establecer el valor predeterminado para la propiedad utilizando la sintaxis thr que se indica a continuación:

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

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

Perfil activo de Spring Boot

Spring Boot admite diferentes propiedades basadas en el perfil activo de Spring. Por ejemplo, podemos mantener dos archivos separados para desarrollo y producción para ejecutar la aplicación Spring Boot.

Perfil activo de primavera en application.properties

Entendamos cómo tener el perfil activo de Spring en application.properties. Por defecto, application. Las propiedades se utilizarán para ejecutar la aplicación Spring Boot. Si desea utilizar propiedades basadas en perfiles, podemos mantener un archivo de propiedades separado para cada perfil como se muestra a continuación:

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

Mientras ejecutamos el archivo JAR, debemos especificar el perfil activo de Spring en función de cada archivo de propiedades. De forma predeterminada, la aplicación Spring Boot usa el archivo application.properties. El comando para configurar el perfil activo del resorte se muestra a continuación:

Puede ver el nombre del perfil activo en el registro de la consola como se muestra a continuación:

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

Ahora, Tomcat se ha iniciado en el puerto 9090 (http) como se muestra a continuación:

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

Puede configurar el perfil activo de producción como se muestra a continuación:

Puede ver el nombre del perfil activo en el registro de la consola como se muestra a continuación:

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

Ahora, Tomcat comenzó en el puerto 4431 (http) como se muestra a continuación:

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

Perfil activo de primavera para application.yml

Entendamos cómo mantener el perfil activo de Spring para application.yml. Podemos mantener las propiedades del perfil activo de Spring en el únicoapplication.ymlarchivo. No es necesario utilizar un archivo separado como application.properties.

El siguiente es un código de ejemplo para mantener los perfiles activos de Spring en el archivo application.yml. Tenga en cuenta que el delimitador (---) se utiliza para separar cada perfil en el archivo 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

Para ordenar para configurar el perfil activo de desarrollo se da a continuación:

Puede ver el nombre del perfil activo en el registro de la consola como se muestra a continuación:

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

Ahora, Tomcat se inició en el puerto 9090 (http) como se muestra a continuación:

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

El comando para configurar el perfil activo de producción se da a continuación:

Puede ver el nombre del perfil activo en el registro de la consola como se muestra a continuación:

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

Esto iniciará Tomcat en el puerto 4431 (http) como se muestra a continuación:

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 utiliza el registro de Apache Commons para todos los registros internos. Las configuraciones predeterminadas de Spring Boot brindan soporte para el uso de Java Util Logging, Log4j2 y Logback. Con estos, podemos configurar el registro de la consola así como el registro de archivos.

Si está utilizando Spring Boot Starters, Logback proporcionará un buen soporte para el registro. Además, Logback también proporciona un buen soporte para Common Logging, Util Logging, Log4J y SLF4J.

Formato de registro

El formato predeterminado de Spring Boot Log se muestra en la captura de pantalla que se muestra a continuación.

que le brinda la siguiente información:

• Date y Time que da la fecha y hora del registro

• Log level muestra INFO, ERROR o WARN

• Process ID

• El --- que es un separador

• Thread name está entre corchetes []

• Logger Name que muestra el nombre de la clase de origen

• El mensaje de registro

Salida de registro de la consola

Los mensajes de registro predeterminados se imprimirán en la ventana de la consola. De forma predeterminada, los mensajes de registro “INFO”, “ERROR” y “WARN” se imprimirán en el archivo de registro.

Si tiene que habilitar el registro de nivel de depuración, agregue la marca de depuración al iniciar su aplicación usando el comando que se muestra a continuación:

java –jar demo.jar --debug

También puede agregar el modo de depuración a su archivo application.properties como se muestra aquí -

debug = true

Salida de registro de archivo

De forma predeterminada, todos los registros se imprimirán en la ventana de la consola y no en los archivos. Si desea imprimir los registros en un archivo, debe establecer la propiedadlogging.file o logging.path en el archivo application.properties.

Puede especificar la ruta del archivo de registro utilizando la propiedad que se muestra a continuación. Tenga en cuenta que el nombre del archivo de registro es spring.log.

logging.path = /var/tmp/

Puede especificar el nombre del archivo de registro propio utilizando la propiedad que se muestra a continuación:

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

Note - los archivos rotarán automáticamente después de alcanzar el tamaño de 10 MB.

Niveles de registro

Spring Boot admite todos los niveles de registrador, como "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF". Puede definir el registrador raíz en el archivo application.properties como se muestra a continuación:

logging.level.root = WARN

Note- Logback no es compatible con el registro de nivel "FATAL". Se asigna al registro de nivel "ERROR".

Configurar Logback

Logback admite la configuración basada en XML para manejar configuraciones de Spring Boot Log. Los detalles de configuración de registro se configuran enlogback.xmlarchivo. El archivo logback.xml debe colocarse bajo classpath.

Puede configurar el registro de nivel ROOT en el archivo Logback.xml usando el código que se proporciona a continuación:

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

Puede configurar el appender de la consola en el archivo Logback.xml que se muestra a continuación.

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

Puede configurar el appender del archivo en el archivo Logback.xml usando el código que se proporciona a continuación. Tenga en cuenta que debe especificar la ruta del archivo de registro dentro del appender del archivo.

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

Puede definir el patrón de registro en logback.xmlarchivo utilizando el código que se proporciona a continuación. También puede definir el conjunto de patrones de registro admitidos dentro de la consola o el appender de registro de archivos utilizando el código que se proporciona a continuación:

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

El código para el archivo logback.xml completo se proporciona a continuación. Tienes que colocar esto en la ruta de clases.

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

El código que se proporciona a continuación muestra cómo agregar el registrador slf4j en el archivo de clase principal de 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);
   }
}

El resultado que puede ver en la ventana de la consola se muestra aquí:

La salida que puede ver en el archivo de registro se muestra aquí:

Spring Boot proporciona un muy buen soporte para crear servicios web RESTful para aplicaciones empresariales. Este capítulo explicará en detalle cómo crear servicios web RESTful usando Spring Boot.

Note - Para crear un servicio web RESTful, necesitamos agregar la dependencia web Spring Boot Starter en el archivo de configuración de la compilación.

Si es un usuario de Maven, use el siguiente código para agregar la siguiente dependencia en su pom.xml archivo -

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

Si es un usuario de Gradle, use el siguiente código para agregar la siguiente dependencia en su build.gradle archivo.

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

El código para el archivo de configuración de compilación completo Maven build – pom.xml se da a continuación -

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

El código para el archivo de configuración de compilación completo Gradle Build – build.gradle se da a continuación -

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

Antes de proceder a crear un servicio web RESTful, se sugiere que tenga conocimiento de las siguientes anotaciones:

Controlador de descanso

La anotación @RestController se utiliza para definir los servicios web RESTful. Sirve JSON, XML y respuesta personalizada. Su sintaxis se muestra a continuación:

@RestController
public class ProductServiceController { 
}

Solicitar mapeo

La anotación @RequestMapping se utiliza para definir el URI de solicitud para acceder a los puntos finales REST. Podemos definir el método de solicitud para consumir y producir objetos. El método de solicitud predeterminado es GET.

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

Cuerpo de solicitud

La anotación @RequestBody se utiliza para definir el tipo de contenido del cuerpo de la solicitud.

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

Variable de ruta

La anotación @PathVariable se utiliza para definir el URI de solicitud dinámico o personalizado. La variable de ruta en el URI de solicitud se define como llaves {} como se muestra a continuación:

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

Solicitar parámetro

La anotación @RequestParam se usa para leer los parámetros de solicitud de la URL de solicitud. De forma predeterminada, es un parámetro obligatorio. También podemos establecer el valor predeterminado para los parámetros de solicitud como se muestra aquí:

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

OBTENER API

El método de solicitud HTTP predeterminado es GET. Este método no requiere ningún cuerpo de solicitud. Puede enviar parámetros de solicitud y variables de ruta para definir la URL dinámica o personalizada.

El código de muestra para definir el método de solicitud HTTP GET se muestra a continuación. En este ejemplo, usamos HashMap para almacenar el Producto. Tenga en cuenta que usamos una clase POJO como el producto que se almacenará.

Aquí, el URI de solicitud es /productsy devolverá la lista de productos del repositorio HashMap. El archivo de clase del controlador se proporciona a continuación que contiene el método 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);
   }
}

API POST

La solicitud HTTP POST se utiliza para crear un recurso. Este método contiene el cuerpo de la solicitud. Podemos enviar parámetros de solicitud y variables de ruta para definir la URL personalizada o dinámica.

El siguiente ejemplo muestra el código de muestra para definir el método de solicitud HTTP POST. En este ejemplo, usamos HashMap para almacenar el Producto, donde el producto es una clase POJO.

Aquí, el URI de solicitud es /products, y devolverá la cadena después de almacenar el producto en el repositorio 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 solicitud HTTP PUT se utiliza para actualizar el recurso existente. Este método contiene un cuerpo de solicitud. Podemos enviar parámetros de solicitud y variables de ruta para definir la URL personalizada o dinámica.

El ejemplo que se muestra a continuación muestra cómo definir el método de solicitud HTTP PUT. En este ejemplo, usamos HashMap para actualizar el Producto existente, donde el producto es una clase POJO.

Aquí el URI de solicitud es /products/{id}que devolverá el String después del producto a un repositorio HashMap. Tenga en cuenta que usamos la variable Path{id} que define el ID de productos que necesita actualizarse.

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

ELIMINAR API

La solicitud HTTP Delete se utiliza para eliminar el recurso existente. Este método no contiene ningún cuerpo de solicitud. Podemos enviar parámetros de solicitud y variables de ruta para definir la URL personalizada o dinámica.

El ejemplo que se muestra a continuación muestra cómo definir el método de solicitud HTTP DELETE. En este ejemplo, usamos HashMap para eliminar el producto existente, que es una clase POJO.

El URI de solicitud es /products/{id}y devolverá la cadena después de eliminar el producto del repositorio HashMap. Usamos la variable Path{id} que define el ID de productos que debe eliminarse.

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

Esta sección le brinda el conjunto completo de código fuente. Observe los siguientes códigos para sus respectivas funcionalidades:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación de arranque de primavera utilizando los siguientes comandos de Maven o Gradle como se muestra:

Para Maven, use el comando que se muestra a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando que se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Puede ejecutar el archivo JAR utilizando el comando que se muestra a continuación:

java –jar <JARFILE>

Esto iniciará la aplicación en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora presione la URL que se muestra a continuación en la aplicación POSTMAN y vea el resultado.

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

La URL de la API POST es: http://localhost:8080/products

La URL de la API PUT es: http://localhost:8080/products/3

DELETE API URL es: http://localhost:8080/products/3

Manejar excepciones y errores en las API y enviar la respuesta adecuada al cliente es bueno para las aplicaciones empresariales. En este capítulo, aprenderemos cómo manejar excepciones en Spring Boot.

Antes de continuar con el manejo de excepciones, comprendamos las siguientes anotaciones.

Asesoramiento del controlador

@ControllerAdvice es una anotación, para manejar las excepciones globalmente.

Controlador de excepciones

@ExceptionHandler es una anotación que se usa para manejar las excepciones específicas y enviar las respuestas personalizadas al cliente.

Puede usar el siguiente código para crear la clase @ControllerAdvice para manejar las excepciones globalmente:

package com.tutorialspoint.demo.exception;

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

@ControllerAdvice
   public class ProductExceptionController {
}

Defina una clase que amplíe la clase RuntimeException.

package com.tutorialspoint.demo.exception;

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

Puede definir el método @ExceptionHandler para manejar las excepciones como se muestra. Este método se debe utilizar para escribir el archivo de clase de avisos del controlador.

@ExceptionHandler(value = ProductNotfoundException.class)

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

Ahora, use el código que se proporciona a continuación para lanzar la excepción de la API.

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

El código completo para manejar la excepción se proporciona a continuación. En este ejemplo, usamos la API PUT para actualizar el producto. Aquí, mientras actualiza el producto, si el producto no se encuentra, devuelva el mensaje de error de respuesta como "Producto no encontrado". Tenga en cuenta que elProductNotFoundException la clase de excepción debe extender el RuntimeException.

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

La clase Controller Advice para manejar la excepción globalmente se proporciona a continuación. Podemos definir cualquier método de controlador de excepciones en este archivo de clase.

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

El archivo del controlador de API de servicio de producto se proporciona a continuación para actualizar el producto. Si no se encuentra el Producto, arroja elProductNotFoundException clase.

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

El código para el archivo de clase de la aplicación Spring Boot principal se proporciona a continuación:

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

El código para POJO class para el producto se indica a continuación:

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

El código para Maven build – pom.xml se muestra a continuación -

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

El código para Gradle Build – build.gradle se da a continuación -

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los comandos de Maven o Gradle:

Para Maven, puede usar el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el siguiente comando:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Puede ejecutar el archivo JAR utilizando el siguiente comando:

java –jar <JARFILE>

Esto iniciará la aplicación en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora presione la siguiente URL en la aplicación POSTMAN y podrá ver el resultado como se muestra a continuación:

URL de actualización: http: // localhost: 8080 / products / 3

Puede usar el Interceptor en Spring Boot para realizar operaciones en las siguientes situaciones:

• Antes de enviar la solicitud al controlador

• Antes de enviar la respuesta al cliente

Por ejemplo, puede usar un interceptor para agregar el encabezado de la solicitud antes de enviar la solicitud al controlador y agregar el encabezado de respuesta antes de enviar la respuesta al cliente.

Para trabajar con interceptor, necesita crear @Component clase que lo admite y debe implementar el HandlerInterceptor interfaz.

Los siguientes son los tres métodos que debe conocer mientras trabaja con interceptores:

• preHandle()método: se utiliza para realizar operaciones antes de enviar la solicitud al controlador. Este método debe devolver verdadero para devolver la respuesta al cliente.

• postHandle() método: se utiliza para realizar operaciones antes de enviar la respuesta al cliente.

• afterCompletion() método: se utiliza para realizar operaciones después de completar la solicitud y la respuesta.

Observe el siguiente código para una mejor comprensión:

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

Deberá registrar este Interceptor con InterceptorRegistry mediante el uso WebMvcConfigurerAdapter como se muestra a continuación -

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

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

En el ejemplo que se muestra a continuación, vamos a acceder a la API de productos GET que da el resultado como se indica en -

El código para la clase de Interceptor ProductServiceInterceptor.java se proporciona a continuación:

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

El código para el archivo de clase de configuración de la aplicación para registrar el Interceptor en el Registro de Interceptor - ProductServiceInterceptorAppConfig.java se proporciona a continuación:

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

El código para el archivo de clase de controlador ProductServiceController.java se proporciona a continuación:

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

El código de la clase POJO para Product.java se proporciona a continuación:

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

El código para el archivo de clase de la aplicación Spring Boot principal DemoApplication.java se da a continuación -

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

El código para la compilación de Maven - pom.xml se muestra aquí -

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

El código para Gradle Build build.gradle se muestra aquí -

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle.

Para Maven, use el comando como se muestra a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Puede ejecutar el archivo JAR utilizando el siguiente comando:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora presione la siguiente URL en la aplicación POSTMAN y podrá ver el resultado como se muestra en -

OBTENER API: http://localhost:8080/products

En la ventana de la consola, puede ver las declaraciones System.out.println agregadas en el Interceptor como se muestra en la captura de pantalla que se muestra a continuación:

Un filtro es un objeto que se utiliza para interceptar las solicitudes y respuestas HTTP de su aplicación. Al usar el filtro, podemos realizar dos operaciones en dos instancias:

• Antes de enviar la solicitud al controlador
• Antes de enviar una respuesta al cliente.

El siguiente código muestra el código de muestra para una clase de implementación de filtro de servlet con la anotación @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 {}
}

El siguiente ejemplo muestra el código para leer el host remoto y la dirección remota del objeto ServletRequest antes de enviar la solicitud al controlador.

En el método doFilter (), hemos agregado las declaraciones System.out.println para imprimir el host remoto y la dirección remota.

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

En el archivo de clase de la aplicación principal de Spring Boot, hemos agregado el punto final REST simple que devuelve la cadena "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";
   }
}

El código para la compilación de Maven - pom.xml se da a continuación -

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

El código para Gradle Build - build.gradle se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los comandos de Maven o Gradle que se muestran a continuación:

Para Maven, use el comando como se muestra a continuación:

mvn clean install

Después de BUILD SUCCESS, puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se muestra a continuación:

gradle clean build

Después de BUILD SUCCESSFUL, puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el siguiente comando

java –jar <JARFILE>

Puede ver que la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora presiona la URL http://localhost:8080/y vea la salida Hello World. Debería verse como se muestra a continuación:

Luego, puede ver el host remoto y la dirección remota en el registro de la consola como se muestra a continuación:

Spring Boot le permite ejecutar la misma aplicación más de una vez en un número de puerto diferente. En este capítulo, aprenderá sobre esto en detalle. Tenga en cuenta que el número de puerto predeterminado 8080.

Puerto personalizado

En el application.properties archivo, podemos establecer un número de puerto personalizado para la propiedad server.port

server.port = 9090

En el application.yml archivo, puede encontrar lo siguiente:

server: 
   port: 9090

Puerto aleatorio

En el application.properties archivo, podemos establecer un número de puerto aleatorio para la propiedad server.port

server.port = 0

En el application.yml archivo, puede encontrar lo siguiente:

server: 
   port: 0

Note - Si el server.port número es 0 al iniciar la aplicación Spring Boot, Tomcat usa el número de puerto aleatorio.

Rest Template se utiliza para crear aplicaciones que consumen RESTful Web Services. Puedes usar elexchange()método para consumir los servicios web para todos los métodos HTTP. El código que se proporciona a continuación muestra cómo crear Bean for Rest Template para cablear automáticamente el objeto 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();
   }
}

OBTENER

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

Asume esta URL http://localhost:8080/products devuelve el siguiente JSON y vamos a consumir esta respuesta de API usando Rest Template usando el siguiente código:

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

Tendrá que seguir los puntos dados para consumir la API -

• Conectó automáticamente el objeto de plantilla de descanso.
• Utilice HttpHeaders para configurar los encabezados de solicitud.
• Utilice HttpEntity para envolver el objeto de solicitud.
• Proporcione la URL, HttpMethod y el tipo de retorno para el método 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();
   }
}

ENVIAR

Consuming POST API by using RestTemplate - exchange() method

Asume esta URL http://localhost:8080/products devuelve la respuesta que se muestra a continuación, vamos a consumir esta respuesta de API utilizando la plantilla de descanso.

El código que se proporciona a continuación es el cuerpo de la solicitud:

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

El código que se proporciona a continuación es el cuerpo de la respuesta:

Product is created successfully

Deberá seguir los puntos que se indican a continuación para consumir la API:

• Conectó automáticamente el objeto de plantilla de descanso.

• Utilice HttpHeaders para establecer los encabezados de solicitud.

• Utilice HttpEntity para envolver el objeto de solicitud. Aquí, envolvemos el objeto Producto para enviarlo al cuerpo de la solicitud.

• Proporcione la URL, HttpMethod y el tipo de retorno para el método 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();
   }
}

PONER

Consuming PUT API by using RestTemplate - exchange() method

Asume esta URL http://localhost:8080/products/3 devuelve la respuesta a continuación y vamos a consumir esta respuesta de API usando Rest Template.

El código que se proporciona a continuación es el cuerpo de la solicitud:

{
   "name":"Indian Ginger"
}

El código que se proporciona a continuación es el cuerpo de la respuesta:

Product is updated successfully

Deberá seguir los puntos que se indican a continuación para consumir la API:

• Conectó automáticamente el objeto de plantilla de descanso.

• Utilice HttpHeaders para configurar los encabezados de solicitud.

• Utilice HttpEntity para envolver el objeto de solicitud. Aquí, envolvemos el objeto Producto para enviarlo al cuerpo de la solicitud.

• Proporcione la URL, HttpMethod y el tipo de retorno para el método 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();
   }
}

ELIMINAR

Consuming DELETE API by using RestTemplate - exchange() method

Asume esta URL http://localhost:8080/products/3 devuelve la respuesta que se proporciona a continuación y vamos a consumir esta respuesta de API utilizando Rest Template.

Esta línea de código que se muestra a continuación es el cuerpo de la respuesta:

Product is deleted successfully

Deberá seguir los puntos que se muestran a continuación para consumir la API:

• Conectó automáticamente el objeto de plantilla de descanso.

• Utilice HttpHeaders para configurar los encabezados de solicitud.

• Utilice HttpEntity para envolver el objeto de solicitud.

• Proporcione la URL, HttpMethod y el tipo de retorno para el método 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();
   }
}

El archivo completo de clase de controlador de plantilla de descanso se proporciona a continuación:

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

El código para la clase de aplicación Spring Boot - DemoApplication.java se proporciona a continuación:

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

El código para la compilación de Maven - pom.xml se da a continuación -

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

El código para Gradle Build - build.gradle se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle:

Para Maven, puede usar el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el siguiente comando:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora presione la siguiente URL en la aplicación POSTMAN y podrá ver el resultado.

OBTENER productos por plantilla de descanso - http://localhost:8080/template/products

Crear productos POST - http://localhost:8080/template/products

Actualizar producto PUT - http://localhost:8080/template/products/3

Eliminar producto - http://localhost:8080/template/products/3

En este capítulo, aprenderá a cargar y descargar el archivo mediante el servicio web.

Subir archivo

Para cargar un archivo, puede usar MultipartFilecomo parámetro de solicitud y esta API debe consumir un valor de datos de formulario de varias partes. Observe el código que se proporciona a continuación:

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

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

El código completo para el mismo se da a continuación:

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

Descarga de archivos

Para la descarga de archivos, debe usar InputStreamResource para descargar un archivo. Necesitamos configurar el HttpHeaderContent-Disposition en Respuesta y es necesario especificar el Tipo de medio de respuesta de la aplicación.

Note - En el siguiente ejemplo, el archivo debe estar disponible en la ruta especificada donde se ejecuta la aplicación.

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

El código completo para el mismo se da a continuación:

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

La aplicación principal de Spring Boot se muestra a continuación:

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

El código para la compilación de Maven - pom.xml se da a continuación -

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

El código para Gradle Build - build.gradle se proporciona a continuación:

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

Ahora puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se indican a continuación:

Para Maven, use el comando que se proporciona a continuación:

mvn clean install

Después de “BUILD SUCCESS”, puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se muestra a continuación:

sgradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el siguiente comando:

java –jar <JARFILE>

Esto iniciará la aplicación en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora presione la siguiente URL en la aplicación POSTMAN y podrá ver el resultado como se muestra a continuación:

Carga de archivo - http://localhost:8080/upload

Descarga de archivos - http://localhost:8080/upload

Los componentes de servicio son el archivo de clase que contiene la anotación @Service. Estos archivos de clase se utilizan para escribir lógica empresarial en una capa diferente, separada del archivo de clase @RestController. La lógica para crear un archivo de clase de componente de servicio se muestra aquí:

public interface ProductService {
}

La clase que implementa la interfaz con la anotación @Service es la que se muestra:

@Service
public class ProductServiceImpl implements ProductService {
}

Observe que en este tutorial estamos usando Product Service API(s)para almacenar, recuperar, actualizar y eliminar los productos. Escribimos la lógica empresarial en el propio archivo de clase @RestController. Ahora, vamos a mover el código de lógica empresarial del controlador al componente de servicio.

Puede crear una interfaz que contenga métodos para agregar, editar, obtener y eliminar utilizando el código que se muestra a continuación:

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

El siguiente código le permitirá crear una clase que implemente la interfaz ProductService con la anotación @Service y escribir la lógica comercial para almacenar, recuperar, eliminar y actualizar el producto.

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

El código aquí muestra el archivo de clase Rest Controller, aquí @Autowired la interfaz ProductService y llamamos a los métodos.

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

El código para la clase POJO - Product.java se muestra aquí -

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

A continuación se proporciona una aplicación principal de 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);
   }
}

El código para la compilación de Maven - pom.xml se muestra a continuación -

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

El código para Gradle Build - build.gradle se muestra a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se indican a continuación:

Para Maven, use el comando como se muestra a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando como se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando que se indica a continuación:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat como se muestra en la imagen que se muestra a continuación:

Ahora presione la siguiente URL en la aplicación POSTMAN y podrá ver el resultado como se muestra a continuación:

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

La URL de la API POST es: http://localhost:8080/products

La URL de la API PUT es - http://localhost:8080/products/3

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

Thymeleaf es una biblioteca basada en Java que se utiliza para crear una aplicación web. Proporciona un buen soporte para servir un XHTML / HTML5 en aplicaciones web. En este capítulo, aprenderá en detalle sobre Thymeleaf.

Plantillas de Thymeleaf

Thymeleaf convierte sus archivos en archivos XML bien formados. Contiene 6 tipos de plantillas como se indica a continuación:

• XML
• XML válido
• XHTML
• XHTML válido
• HTML5
• HTML5 heredado

Todas las plantillas, excepto Legacy HTML5, se refieren a archivos XML válidos bien formados. El HTML5 heredado nos permite representar las etiquetas HTML5 en una página web, incluidas las etiquetas no cerradas.

Aplicación web

Puede utilizar las plantillas de Thymeleaf para crear una aplicación web en Spring Boot. Deberá seguir los pasos a continuación para crear una aplicación web en Spring Boot utilizando Thymeleaf.

Use el siguiente código para crear un archivo de clase @Controller para redirigir el URI de solicitud a un archivo 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";
   }
}

En el ejemplo anterior, el URI de solicitud es /indexy el control se redirige al archivo index.html. Tenga en cuenta que el archivo index.html debe colocarse en el directorio de plantillas y todos los archivos JS y CSS deben colocarse en el directorio estático en classpath. En el ejemplo que se muestra, usamos un archivo CSS para cambiar el color del texto.

Puede usar el siguiente código y crear un archivo CSS en una carpeta separada css y nombre el archivo como styles.css -

h4 {
   color: red;
}

El código para el archivo index.html se proporciona a continuación:

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

El explorador del proyecto se muestra en la captura de pantalla que se muestra a continuación:

Ahora, necesitamos agregar la dependencia Spring Boot Starter Thymeleaf en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml:

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle:

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

El código para el archivo de clase de la aplicación Spring Boot principal se proporciona a continuación:

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

El código para Maven - pom.xml se da a continuación -

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

El código para Gradle - build.gradle se da a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle:

Para Maven, use el comando como se muestra a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando que se proporciona aquí:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora presione la URL en su navegador web y podrá ver el resultado como se muestra:

http://localhost:8080/index

Este capítulo discutirá en detalle sobre el consumo de servicios web RESTful mediante el uso de jQuery AJAX.

Cree una aplicación web Spring Boot simple y escriba archivos de clase de controlador que se utilizan para redireccionar al archivo HTML para consumir los servicios web RESTful.

Necesitamos agregar el iniciador de Spring Boot Thymeleaf y la dependencia Web en nuestro archivo de configuración de compilación.

Para los usuarios de Maven, agregue las siguientes dependencias en su archivo 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>

Para los usuarios de Gradle, agregue las siguientes dependencias en su archivo build.gradle:

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

El código para el archivo de clase @Controller se proporciona a continuación:

@Controller
public class ViewController {
}

Puede definir los métodos de solicitud URI para redireccionar al archivo HTML como se muestra a continuación:

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

Esta API http://localhost:9090/products debe devolver el JSON a continuación en respuesta como se muestra a continuación:

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

Ahora, cree un archivo view-products.html en el directorio de plantillas en la ruta de clases.

En el archivo HTML, agregamos la biblioteca jQuery y escribimos el código para consumir el servicio web RESTful al cargar la página.

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

El método POST y esta URL http://localhost:9090/products debe contener el cuerpo de solicitud y el cuerpo de respuesta a continuación.

El código para el cuerpo de la solicitud se proporciona a continuación:

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

El código para el cuerpo de respuesta se proporciona a continuación:

Product is created successfully

Ahora, cree el archivo add-products.html en el directorio de plantillas en la ruta de clases.

En el archivo HTML, agregamos la biblioteca jQuery y escribimos el código que envía el formulario al servicio web RESTful al hacer clic en el botón.

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

El código completo se proporciona a continuación.

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

El código para Gradle - build.gradle se da a continuación:

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

El archivo de clase del controlador que se muestra a continuación: ViewController.java se muestra a continuación:

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

El archivo view-products.html se muestra a continuación:

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

El archivo add-products.html se muestra a continuación:

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

El archivo de clase principal de la aplicación Spring Boot se muestra a continuación:

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

Ahora, puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle.

Para Maven, use el comando como se indica a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se indica a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el siguiente comando:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora presione la URL en su navegador web y podrá ver el resultado como se muestra:

http: // localhost: 8080 / view-products

http: // localhost: 8080 / add-products

Ahora, haga clic en el botón Click here to submit the form y puede ver el resultado como se muestra:

Ahora, presione la URL de ver productos y vea el producto creado.

http://localhost:8080/view-products

JS angular

Para consumir las API usando Angular JS, puede usar los ejemplos que se dan a continuación:

Use el siguiente código para crear el controlador Angular JS para consumir la 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;
   });
});

Use el siguiente código para crear el controlador Angular JS para consumir la 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 - Los datos del método de publicación representan el cuerpo de la solicitud en formato JSON para crear un producto.

Cross-Origin Resource Sharing (CORS) es un concepto de seguridad que permite restringir los recursos implementados en los navegadores web. Evita que el código JavaScript produzca o consuma las solicitudes contra un origen diferente.

Por ejemplo, su aplicación web se ejecuta en el puerto 8080 y, al usar JavaScript, está intentando consumir servicios web RESTful desde el puerto 9090. En tales situaciones, enfrentará el problema de seguridad de Intercambio de recursos entre orígenes en sus navegadores web.

Se necesitan dos requisitos para manejar este problema:

• Los servicios web RESTful deben admitir el intercambio de recursos entre orígenes.

• La aplicación de servicio web RESTful debe permitir el acceso a las API desde el puerto 8080.

En este capítulo, aprenderemos en detalle sobre cómo habilitar solicitudes de origen cruzado para una aplicación de servicio web RESTful.

Habilitar CORS en el método del controlador

Necesitamos establecer los orígenes del servicio web RESTful usando @CrossOriginanotación para el método del controlador. Esta anotación @CrossOrigin admite una API REST específica, y no para toda la aplicación.

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

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

Configuración CORS global

Necesitamos definir la configuración de @Bean mostrada para establecer el soporte de configuración CORS globalmente para su aplicación Spring Boot.

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

A continuación, se muestra el código para establecer la configuración CORS globalmente en la aplicación principal Spring Boot.

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

Ahora, puede crear una aplicación web Spring Boot que se ejecute en el puerto 8080 y su aplicación de servicio web RESTful que se pueda ejecutar en el puerto 9090. Para obtener más detalles sobre la implementación del servicio web RESTful, puede consultar el capítulo tituladoConsuming RESTful Web Services de este tutorial.

La internacionalización es un proceso que hace que su aplicación se adapte a diferentes idiomas y regiones sin cambios de ingeniería en el código fuente. En sus palabras, la internacionalización es una preparación para la localización.

En este capítulo, aprenderemos en detalle cómo implementar la internacionalización en Spring Boot.

Dependencias

Necesitamos la dependencia Spring Boot Starter Web y Spring Boot Starter Thymeleaf para desarrollar una aplicación web en Spring Boot.

Maven

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

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

Gradle

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

LocaleResolver

Necesitamos determinar la configuración regional predeterminada de su aplicación. Necesitamos agregar el bean LocaleResolver en nuestra aplicación Spring Boot.

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

LocaleChangeInterceptor

LocaleChangeInterceptor se utiliza para cambiar la nueva configuración regional en función del valor del parámetro de idioma agregado a una solicitud.

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

Para tener este efecto, debemos agregar LocaleChangeInterceptor en el interceptor de registro de la aplicación. La clase de configuración debe extender la clase WebMvcConfigurerAdapter y anular el método addInterceptors ().

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

Fuentes de mensajes

La aplicación Spring Boot de forma predeterminada toma las fuentes de mensajes de src/main/resourcescarpeta debajo de la ruta de clase. El nombre del archivo de mensaje de configuración regional predeterminado debe sermessage.properties y los archivos para cada configuración regional deben denominarse como messages_XX.properties. El "XX" representa el código local.

Todas las propiedades del mensaje deben usarse como valores de pares de claves. Si no se encuentran propiedades en el entorno local, la aplicación utiliza la propiedad predeterminada del archivo messages.properties.

Los messages.properties predeterminados serán los siguientes:

welcome.text=Hi Welcome to Everyone

El idioma francés messages_fr.properties será como se muestra:

welcome.text=Salut Bienvenue à tous

Note - El archivo de origen de los mensajes debe guardarse como formato de archivo "UTF-8".

Archivo HTML

En el archivo HTML, use la sintaxis #{key} para mostrar los mensajes del archivo de propiedades.

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

El código completo se da a continuación.

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

El archivo principal de clase de la aplicación Spring Boot se muestra a continuación:

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

El archivo de clase del controlador se proporciona a continuación:

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

Clase de configuración para apoyar la internacionalización

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

Las fuentes de mensajes - messages.properties es como se muestra -

welcome.text = Hi Welcome to Everyone

Las fuentes de mensajes - message_fr.properties es como se muestra -

welcome.text = Salut Bienvenue à tous

El archivo HTML locale.html debe colocarse en el directorio de plantillas en la ruta de clase como se muestra:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring boot mediante los siguientes comandos de Maven o Gradle:

Para Maven, use el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el siguiente comando:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando como se muestra:

java –jar <JARFILE>

Verá que la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora presiona la URL http://localhost:8080/locale en su navegador web y puede ver el siguiente resultado:

La URL http://localhost:8080/locale?language=fr le dará la salida como se muestra -

La programación es un proceso de ejecución de tareas para un período de tiempo específico. Spring Boot proporciona un buen soporte para escribir un programador en las aplicaciones Spring.

Expresión Java Cron

Las expresiones Java Cron se utilizan para configurar las instancias de CronTrigger, una subclase de org.quartz.Trigger. Para obtener más información sobre la expresión cron de Java, puede consultar este enlace:

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

La anotación @EnableScheduling se usa para habilitar el programador para su aplicación. Esta anotación debe agregarse al archivo de clase de la aplicación Spring Boot principal.

@SpringBootApplication
@EnableScheduling

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

La anotación @Scheduled se utiliza para activar el programador durante un período de tiempo específico.

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

El siguiente es un código de muestra que muestra cómo ejecutar la tarea cada minuto comenzando a las 9:00 a.m. y terminando a las 9:59 a.m., todos los días

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

La siguiente captura de pantalla muestra cómo se inició la aplicación a las 09:03:23 y cada minuto desde ese momento se ejecutó la tarea del programador de trabajos cron.

Tipo de interés fijo

El programador de tasa fija se utiliza para ejecutar las tareas en el momento específico. No espera a que se complete la tarea anterior. Los valores deben estar en milisegundos. El código de muestra se muestra aquí:

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

Aquí se muestra un código de muestra para ejecutar una tarea cada segundo desde el inicio de la aplicación:

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

Observe la siguiente captura de pantalla que muestra la aplicación que se inició a las 09:12:00 y luego se ejecutó cada segundo tarea del programador de tasa fija.

Retraso fijo

El programador de retardo fijo se utiliza para ejecutar las tareas en un momento específico. Debe esperar a que se complete la tarea anterior. Los valores deben estar en milisegundos. Aquí se muestra un código de muestra:

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

Aquí, initialDelay es el tiempo después del cual la tarea se ejecutará por primera vez después del valor de retraso inicial.

A continuación, se muestra un ejemplo para ejecutar la tarea cada segundo después de que se hayan completado 3 segundos desde el inicio de la aplicación:

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

Observe la siguiente captura de pantalla que muestra la aplicación que se inició a las 09:18:39 y después de cada 3 segundos, la tarea del programador de retraso fijo se ha ejecutado en cada segundo.

De forma predeterminada, la aplicación Spring Boot usa el puerto HTTP 8080 cuando se inicia la aplicación.

Debe seguir los pasos que se indican a continuación para configurar HTTPS y el puerto 443 en la aplicación Spring Boot:

• Obtenga el certificado SSL: cree un certificado autofirmado u obtenga uno de una autoridad certificadora

• Habilitar HTTPS y puerto 443

Certificado autofirmado

Para crear un certificado autofirmado, el entorno Java Run Time viene con una herramienta clave de utilidad de gestión de certificados. Esta herramienta de utilidad se utiliza para crear un certificado autofirmado. Se muestra en el código dado aquí:

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

Este código generará un archivo de almacén de claves PKCS12 denominado keystore.p12 y el nombre de alias del certificado es tomcat.

Configurar HTTPS

Necesitamos proporcionar el puerto del servidor como 443, la ruta del archivo del almacén de claves, la contraseña del almacén de claves, el tipo de almacén de claves y el nombre de alias de clave en el archivo application.properties. Observe el código dado aquí -

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

Puede usar el siguiente código si está usando las propiedades de YAML, use a continuación application.yml -

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle.

Para Maven, puede usar el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puedes usar el comando

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el siguiente comando:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 443 de Tomcat con https como se muestra:

Eureka Server es una aplicación que contiene la información sobre todas las aplicaciones de servicio al cliente. Cada servicio Micro se registrará en el servidor Eureka y el servidor Eureka conoce todas las aplicaciones cliente que se ejecutan en cada puerto y dirección IP. Eureka Server también se conoce como Discovery Server.

En este capítulo, aprenderemos en detalle sobre cómo construir un servidor Eureka.

Construyendo un servidor Eureka

Eureka Server viene con el paquete de Spring Cloud. Para ello, necesitamos desarrollar el servidor Eureka y ejecutarlo en el puerto predeterminado 8761.

Visite la página de inicio de Spring Initializer https://start.spring.io/y descargue el proyecto Spring Boot con dependencia del servidor Eureka. Se muestra en la captura de pantalla a continuación:

Después de descargar el proyecto en el archivo de clase principal de la aplicación Spring Boot, necesitamos agregar la anotación @EnableEurekaServer. La anotación @EnableEurekaServer se utiliza para hacer que su aplicación Spring Boot actúe como un servidor Eureka.

El código para el archivo de clase de la aplicación Spring Boot principal es el que se muestra a continuación:

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

Asegúrese de que la dependencia del servidor Spring Cloud Eureka esté agregada en su archivo de configuración de compilación.

El código para la dependencia del usuario de Maven se muestra a continuación:

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

El código para la dependencia del usuario de Gradle se proporciona a continuación:

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

El archivo de configuración de compilación completo se proporciona a continuación:

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

De forma predeterminada, Eureka Server se registra en el descubrimiento. Debe agregar la configuración dada a continuación en su archivo application.properties o en el archivo application.yml.

El archivo application.properties se proporciona a continuación:

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

El archivo application.yml se proporciona a continuación:

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

Ahora, puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se muestran a continuación:

Para Maven, use el comando como se muestra a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el siguiente comando:

java –jar <JARFILE>

Puede encontrar que la aplicación se ha iniciado en el puerto 8761 de Tomcat como se muestra a continuación:

Ahora, presiona la URL http://localhost:8761/ en su navegador web y puede encontrar el servidor Eureka ejecutándose en el puerto 8761 como se muestra a continuación:

En este capítulo, aprenderá en detalle sobre cómo registrar la aplicación de servicio Spring Boot Micro en el servidor Eureka. Antes de registrar la aplicación, asegúrese de que Eureka Server se esté ejecutando en el puerto 8761 o primero compile el Eureka Server y ejecútelo. Para obtener más información sobre la creación del servidor Eureka, puede consultar el capítulo anterior.

Primero, debe agregar las siguientes dependencias en nuestro archivo de configuración de compilación para registrar el microservicio con el servidor Eureka.

Los usuarios de Maven pueden agregar las siguientes dependencias en el pom.xml archivo -

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

Los usuarios de Gradle pueden agregar las siguientes dependencias en el build.gradle archivo -

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

Ahora, necesitamos agregar la anotación @EnableEurekaClient en el archivo de clase de la aplicación Spring Boot principal. La anotación @EnableEurekaClient hace que su aplicación Spring Boot actúe como un cliente de Eureka.

La aplicación principal de Spring Boot es la siguiente:

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

Para registrar la aplicación Spring Boot en Eureka Server, debemos agregar la siguiente configuración en nuestro archivo application.properties o application.yml y especificar la URL del servidor Eureka en nuestra configuración.

El código para el archivo application.yml se proporciona a continuación:

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

El código para el archivo application.properties se proporciona a continuación:

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

Ahora, agregue Rest Endpoint para devolver String en la aplicación principal Spring Boot y la dependencia web Spring Boot Starter en el archivo de configuración de compilación. Observe el código que se proporciona a continuación:

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

El archivo de configuración completo se proporciona a continuación.

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle:

Para Maven, puede usar el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el siguiente comando:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando como se muestra:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat y la aplicación del cliente Eureka está registrada con el servidor Eureka como se muestra a continuación:

Pulse la URL http: // localhost: 8761 / en su navegador web y podrá ver que la aplicación Eureka Client está registrada con Eureka Server.

Ahora presiona la URL http://localhost:8080/ en su navegador web y vea el resultado de Rest Endpoint.

Zuul Server es una aplicación de puerta de enlace que maneja todas las solicitudes y realiza el enrutamiento dinámico de las aplicaciones de microservicio. El servidor Zuul también se conoce como servidor perimetral.

Por ejemplo, /api/user se asigna al servicio del usuario y / api / products se asigna al servicio del producto y Zuul Server enruta dinámicamente las solicitudes a la aplicación de backend correspondiente.

En este capítulo, veremos en detalle cómo crear la aplicación Zuul Server en Spring Boot.

Creación de la aplicación de servidor Zuul

El servidor Zuul está incluido con la dependencia de Spring Cloud. Puede descargar el proyecto Spring Boot desde la página Spring Initializerhttps://start.spring.io/ y elija la dependencia del servidor Zuul.

Agregue la anotación @EnableZuulProxy en su aplicación principal Spring Boot. La anotación @EnableZuulProxy se utiliza para hacer que su aplicación Spring Boot actúe como un servidor proxy Zuul.

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

Tendrá que agregar la dependencia Spring Cloud Starter Zuul en nuestro archivo de configuración de compilación.

Los usuarios de Maven deberán agregar la siguiente dependencia en su pom.xml archivo -

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

Para los usuarios de Gradle, agregue la siguiente dependencia en su archivo build.gradle

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

Para el enrutamiento de Zuul, agregue las siguientes propiedades en su archivo application.properties o en el archivo application.yml.

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

Esto significa que http llama a /api/demo/ser reenviado al servicio de productos. Por ejemplo,/api/demo/products se reenvía a /products.

Los usuarios del archivo yaml pueden usar el archivo application.yml que se muestra a continuación:

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

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

Note - el http://localhost:8080/ La aplicación ya debería estar ejecutándose antes de enrutar a través de Zuul Proxy.

El archivo de configuración de compilación completo se proporciona a continuación.

Los usuarios de Maven pueden usar el archivo pom.xml que se muestra a continuación:

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

Los usuarios de Gradle pueden usar el archivo build.gradle que se muestra a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se indican a continuación:

Para Maven, puede usar el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se proporciona a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra a continuación:

java –jar <JARFILE>

Puede encontrar que la aplicación se ha iniciado en el puerto 8111 de Tomcat como se muestra aquí.

Ahora, presiona la URL http://localhost:8111/api/demo/products en su navegador web y puede ver la salida de /products REST Endpoint como se muestra a continuación -

Spring Cloud Configuration Server es una aplicación centralizada que administra todas las propiedades de configuración relacionadas con la aplicación. En este capítulo, aprenderá en detalle cómo crear el servidor Spring Cloud Configuration.

Creación del servidor de configuración de Spring Cloud

Primero, descargue el proyecto Spring Boot de la página Spring Initializer y elija la dependencia Spring Cloud Config Server. Observe la captura de pantalla que se muestra a continuación:

Ahora, agregue la dependencia del servidor Spring Cloud Config en su archivo de configuración de compilación como se explica a continuación:

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml.

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en su archivo build.gradle.

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

Ahora, agregue la anotación @EnableConfigServer en su archivo principal de clase de la aplicación Spring Boot. La anotación @EnableConfigServer hace que su aplicación Spring Boot actúe como un servidor de configuración.

El archivo principal de clase de la aplicación Spring Boot se muestra a continuación:

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

Ahora, agregue la siguiente configuración a su archivo de propiedades y reemplace el archivo application.properties en el archivo bootstrap.properties. Observe el código que se proporciona a continuación:

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

Configuration Server se ejecuta en el puerto 8888 de Tomcat y las propiedades de configuración de la aplicación se cargan desde ubicaciones de búsqueda nativas.

Ahora en file:///C:/configprop/, coloque su aplicación cliente - archivo application.properties. Por ejemplo, el nombre de su aplicación cliente esconfig-client, luego cambie el nombre de su archivo application.properties como config-client.properties y coloque el archivo de propiedades en la ruta file:///C:/configprop/.

El código para el archivo de propiedades del cliente de configuración se proporciona a continuación:

welcome.message = Welcome to Spring cloud config server

El archivo de configuración de compilación completo se proporciona a continuación:

Los usuarios de Maven pueden usar pom.xml dado a continuación -

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

Los usuarios de Gradle pueden usar el archivo build.gradle que se muestra a continuación:

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

Ahora, cree un archivo JAR ejecutable y ejecute la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle:

Para Maven, use el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando que se proporciona a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el siguiente comando:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8888 de Tomcat como se muestra aquí:

Ahora presiona la URL http://localhost:8888/config-client/default/master en su navegador web y puede ver las propiedades de configuración de la aplicación config-client como se muestra aquí.

Algunas aplicaciones pueden necesitar propiedades de configuración que pueden necesitar un cambio y los desarrolladores pueden necesitar quitarlas o reiniciar la aplicación para realizar esto. Sin embargo, esto podría provocar un tiempo de inactividad en la producción y la necesidad de reiniciar la aplicación. Spring Cloud Configuration Server permite a los desarrolladores cargar las nuevas propiedades de configuración sin reiniciar la aplicación y sin tiempo de inactividad.

Trabajando con Spring Cloud Configuration Server

Primero, descargue el proyecto Spring Boot de https://start.spring.io/y elija la dependencia del cliente Spring Cloud Config. Ahora, agregue la dependencia de Spring Cloud Starter Config en su archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml.

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en el build.gradle archivo.

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

Ahora, debe agregar la anotación @RefreshScope a su aplicación principal Spring Boot. La anotación @RefreshScope se utiliza para cargar el valor de las propiedades de configuración desde el servidor de configuración.

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

Ahora, agregue la URL del servidor de configuración en su archivo application.properties y proporcione el nombre de su aplicación.

Note - http: // localhost: 8888 config server debe ejecutarse antes de iniciar la aplicación de cliente de configuración.

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

El código para escribir un punto final REST simple para leer el mensaje de bienvenida del servidor de configuración se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle:

Para Maven, puede usar el comando que se muestra a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se muestra a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra aquí:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat como se muestra aquí:

Puede ver la ventana de inicio de sesión de la consola; La aplicación config-client está obteniendo la configuración delhttps://localhost:8888

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

Ahora presiona la URL, http://localhost:8080/ El mensaje de bienvenida se carga desde el servidor de configuración.

Ahora, vaya y cambie el valor de la propiedad en el servidor de configuración y presione la URL POST del punto final del actuador http://localhost:8080/refresh y ver el nuevo valor de propiedad de configuración en la URL http://localhost:8080/

Spring Boot Actuator proporciona puntos finales seguros para monitorear y administrar su aplicación Spring Boot. De forma predeterminada, todos los puntos finales del actuador están protegidos. En este capítulo, aprenderá en detalle cómo habilitar el actuador Spring Boot en su aplicación.

Habilitación del actuador de arranque por resorte

Para habilitar los puntos finales del actuador Spring Boot en su aplicación Spring Boot, necesitamos agregar la dependencia del actuador Spring Boot Starter en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en su archivo pom.xml.

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en su archivo build.gradle.

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

En el archivo application.properties, necesitamos deshabilitar la seguridad para los puntos finales del actuador.

management.security.enabled = false

Los usuarios del archivo YAML pueden agregar la siguiente propiedad en su archivo application.yml.

management:
   security:
      enabled: false

Si desea utilizar el número de puerto separado para acceder a los puntos finales del actuador de arranque de Spring, agregue el número de puerto de administración en el archivo application.properties.

management.port = 9000

Los usuarios del archivo YAML pueden agregar la siguiente propiedad en su archivo application.yml.

management:
   port: 9000

Ahora, puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle.

Para Maven, puede usar el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el siguiente comando:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, puede ejecutar el archivo JAR usando el siguiente comando:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat. Tenga en cuenta que si especificó el número de puerto de administración, la misma aplicación se está ejecutando en dos números de puerto diferentes.

A continuación se indican algunos puntos finales importantes del actuador Spring Boot. Puede ingresarlos en su navegador web y monitorear el comportamiento de su aplicación.

FINALES	USO
/métrica	Para ver las métricas de la aplicación, como la memoria utilizada, la memoria libre, los subprocesos, las clases, el tiempo de actividad del sistema, etc.
/ env	Para ver la lista de variables de entorno utilizadas en la aplicación.
/frijoles	Para ver los beans de Spring y sus tipos, ámbitos y dependencia.
/salud	Para ver el estado de la aplicación
/ info	Para ver la información sobre la aplicación Spring Boot.
/rastro	Para ver la lista de rastros de sus puntos finales de descanso.

Monitorear su aplicación usando Spring Boot Actuator Endpoint es un poco difícil. Porque, si tiene 'n' aplicaciones, cada aplicación tiene puntos finales de actuador separados, lo que dificulta la supervisión. Spring Boot Admin Server es una aplicación que se utiliza para administrar y monitorear su aplicación de microservicio.

Para manejar tales situaciones, CodeCentric Team proporciona una interfaz de usuario de administrador de Spring Boot para administrar y monitorear todos los puntos finales del actuador de la aplicación Spring Boot en un solo lugar.

Para construir un servidor de administración de Spring Boot, necesitamos agregar las siguientes dependencias en su archivo de configuración de compilación.

Los usuarios de Maven pueden agregar las siguientes dependencias en su archivo 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>

Los usuarios de Gradle pueden agregar las siguientes dependencias en su archivo 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'

Agregue la anotación @EnableAdminServer en su archivo principal de clase de la aplicación Spring Boot. La anotación @EnableAdminServer se usa para convertirlo en servidor de administración para monitorear todos los demás microservicios.

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

Ahora, defina el server.port y el nombre de la aplicación en el archivo application.properties que se muestra:

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

Para los usuarios de YAML, use las siguientes propiedades para definir el número de puerto y el nombre de la aplicación en el archivo application.yml.

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

El archivo de configuración de compilación se proporciona a continuación.

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle:

Para Maven, use el comando que se muestra aquí:

mvn clean install

Después de “BUILD SUCCESS”, puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando que se muestra aquí:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se indica a continuación:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 9090 de Tomcat como se muestra aquí:

Ahora presione la siguiente URL desde su navegador web y vea la interfaz de usuario del servidor de administración.

http://localhost:9090/

Para monitorear y administrar su aplicación de microservicio a través de Spring Boot Admin Server, debe agregar la dependencia del cliente de inicio Spring Boot Admin y señalar el URI del servidor de administración en el archivo de propiedades de la aplicación.

Note - Para monitorear una aplicación, debe habilitar Spring Boot Actuator Endpoints para su aplicación de microservicio.

Primero, agregue la siguiente dependencia del cliente de arranque Spring Boot Admin y la dependencia del actuador de arranque Spring Boot en su archivo de configuración de compilación.

Los usuarios de Maven pueden agregar las siguientes dependencias en su archivo 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>

Los usuarios de Gradle pueden agregar las siguientes dependencias en su archivo build.gradle.

compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')

Ahora, agregue la URL del servidor de administración de Spring Boot en el archivo de propiedades de su aplicación.

Para los usuarios del archivo de propiedades, agregue las siguientes propiedades en el archivo application.properties.

spring.boot.admin.url = http://localhost:9090/

Para los usuarios de YAML, agregue la siguiente propiedad en el archivo application.yml.

spring:
   boot:
      admin:
         url: http://localhost:9000/

Ahora, cree un archivo JAR ejecutable y ejecute la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle.

Para Maven, puede usar el comando como se muestra:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 9090 de Tomcat como se muestra:

Ahora presione la siguiente URL desde su navegador web y vea que su aplicación Spring Boot está registrada con Spring Boot Admin Server.

http://localhost:9090/

Ahora, haga clic en el Details y ver los puntos finales del actuador en la interfaz de usuario del servidor de administración.

Swagger2 es un proyecto de código abierto que se utiliza para generar los documentos de la API REST para los servicios web RESTful. Proporciona una interfaz de usuario para acceder a nuestros servicios web RESTful a través del navegador web.

Para habilitar la aplicación Swagger2 en Spring Boot, debe agregar las siguientes dependencias en nuestro archivo de configuraciones de compilación.

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

Para los usuarios de Gradle, agregue las siguientes dependencias en su archivo 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'

Ahora, agregue la anotación @ EnableSwagger2 en su aplicación principal Spring Boot. La anotación @ EnableSwagger2 se usa para habilitar Swagger2 para su aplicación Spring Boot.

El código para la aplicación principal Spring Boot se muestra a continuación:

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

A continuación, cree Docket Bean para configurar Swagger2 para su aplicación Spring Boot. Necesitamos definir el paquete base para configurar API (s) REST para Swagger2.

@Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }

Ahora, agregue este bean en el archivo de clase principal de la aplicación Spring Boot y su clase principal de la aplicación Spring Boot se verá como se muestra a continuación:

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

Ahora, agregue la siguiente dependencia de Spring Boot Starter Web en su archivo de configuración de compilación para escribir un REST Endpoints como se muestra a continuación:

Los usuarios de Maven pueden agregar la siguiente dependencia en su archivo pom.xml:

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle:

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

Ahora, el código para construir dos servicios web RESTful simples GET y POST en el archivo Rest Controller se muestra aquí:

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

El archivo de configuración de compilación completo se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle.

Para Maven, puede usar el comando que se muestra aquí:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando como se muestra aquí:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra aquí:

java –jar <JARFILE>

Ahora, la aplicación se iniciará en el puerto 8080 de Tomcat como se muestra:

Ahora, presione la URL en su navegador web y vea las funcionalidades de la API Swagger.

http://localhost:8080/swagger-ui.html

Docker es un servicio de administración de contenedores que facilita la construcción y la implementación. Si es un principiante en Docker, puede obtener más información en este enlace:https://www.tutorialspoint.com/docker/index.htm

En este capítulo, veremos Cómo crear una imagen de Docker usando dependencias de Maven y Gradle para su aplicación Spring Boot.

Crear Dockerfile

Primero, crea un archivo con el nombre Dockerfile debajo de los directorios src/main/dockercon el contenido que se muestra a continuación. Tenga en cuenta que este archivo es importante para crear una imagen de Docker.

FROM java:8
VOLUME /tmp
ADD dockerapp-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Maven

Para Maven, agregue el complemento Docker Maven en su archivo de configuración de compilación 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>

El archivo completo pom.xml se proporciona a continuación:

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

Ahora, puede ejecutar su aplicación usando el comando Maven mvn package docker:build

Note - Habilite el demonio Expose en tcp://localhost:2375 sin TLS.

Después del éxito de la compilación, puede ver el resultado en la consola como se muestra a continuación:

Ahora, vea las imágenes de Docker por el comando usando imágenes de Docker y vea la información de la imagen en la consola.

Gradle

Para construir una imagen de Docker usando la configuración de compilación de Gradle, necesitamos agregar el docker complemento y necesidad de escribir una tarea buildDocker para crear una imagen de Docker.

El código para la configuración de Gradle Docker se proporciona a continuación.

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

El archivo build.gradle completo se proporciona a continuación.

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

Ahora, cree una imagen de Docker usando el comando que se muestra a continuación:

gradle build buildDocker

Después de ejecutar el comando, puede ver el registro BUILD SUCCESSFUL en la ventana de la consola.

Ahora, vea las imágenes de Docker por el comando usando docker images y vea la información de la imagen en la consola.

La mayoría de los desarrolladores enfrentan dificultades para rastrear registros si ocurre algún problema. Esto puede ser resuelto por Spring Cloud Sleuth y el servidor ZipKin para la aplicación Spring Boot.

Spring Cloud Sleuth

Los registros de Spring Cloud Sleuth se imprimen en el siguiente formato:

[application-name,traceid,spanid,zipkin-export]

Dónde,

• Application-name = Nombre de la aplicación

• Traceid = cada traceid de solicitud y respuesta es el mismo cuando se llama al mismo servicio o un servicio a otro servicio.

• Spanid = Span Id se imprime junto con Trace Id. Span Id es diferente en cada solicitud y respuesta que llama de un servicio a otro servicio.

• Zipkin-export = Por defecto es falso. Si es cierto, los registros se exportarán al servidor Zipkin.

Ahora, agregue la dependencia Spring Cloud Starter Sleuth en su archivo de configuración de compilación de la siguiente manera:

Los usuarios de Maven pueden agregar la siguiente dependencia en su archivo pom.xml:

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en su archivo build.gradle:

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

Ahora, agregue los registros en el archivo de clase de controlador de descanso de la aplicación Spring Boot como se muestra aquí -

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

Ahora, agregue el nombre de la aplicación en el archivo application.properties como se muestra:

spring.application.name = tracinglogs

El código completo para el archivo de configuración de compilación se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle.

Para Maven, puede usar el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el siguiente comando:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra aquí:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora, presione la URL en su navegador web y vea el resultado en el registro de la consola.

http://localhost:8080/

Puede ver los siguientes registros en la ventana de la consola. Observe que el registro está impreso en el siguiente formato [nombre de la aplicación, traceid, spanid, zipkin-export]

Servidor Zipkin

Zipkin es una aplicación que monitorea y administra los registros de Spring Cloud Sleuth de su aplicación Spring Boot. Para construir un servidor Zipkin, necesitamos agregar la interfaz de usuario de Zipkin y las dependencias del servidor Zipkin en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en su archivo 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>

Los usuarios de Gradle pueden agregar la siguiente dependencia en su archivo build.gradle:

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Ahora, configure server.port = 9411 en el archivo de propiedades de la aplicación.

Para los usuarios del archivo de propiedades, agregue la siguiente propiedad en el archivo application.properties.

server.port = 9411

Para los usuarios de YAML, agregue la siguiente propiedad en el archivo application.yml.

server:
   port: 9411

Agregue la anotación @EnableZipkinServer en la clase principal de su aplicación Spring Boot fie. La anotación @EnableZipkinServer se utiliza para permitir que su aplicación actúe como un servidor 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);
   }
}

El código para el archivo de configuración de compilación completo se proporciona a continuación.

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle:

Para Maven, use el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando que se proporciona a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando que se muestra:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 9411 de Tomcat como se muestra a continuación:

Ahora, presione la siguiente URL y vea la interfaz de usuario del servidor Zipkin.

http://localhost:9411/zipkin/

Luego, agregue la siguiente dependencia en su aplicación de servicio al cliente y señale la URL del servidor Zipkin para rastrear los registros de microservicio a través de la interfaz de usuario de Zipkin.

Ahora, agregue la dependencia de Spring Cloud Starter Zipkin en su archivo de configuración de compilación como se muestra:

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle:

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Ahora, agregue el Always Sampler Bean en su aplicación Spring Boot para exportar los registros al servidor Zipkin.

@Bean
public AlwaysSampler defaultSampler() {
   return new AlwaysSampler();
}

Si agrega el Bean AlwaysSampler, automáticamente la opción de exportación Zipkin de Spring Sleuth cambiará de falso a verdadero.

A continuación, configure la URL base de su servidor Zipkin en el archivo application.properties de servicio del cliente.

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

Luego, proporcione la identificación de seguimiento y busque los rastros en la interfaz de usuario de Zipkin.

http://localhost:9411/zipkin/traces/{traceid}/

Flyway es una aplicación de control de versiones para hacer evolucionar su esquema de base de datos de manera fácil y confiable en todas sus instancias. Para obtener más información sobre Flyway, puede utilizar el enlace: www.flywaydb.org

Muchos proyectos de software utilizan bases de datos relacionales. Esto requiere el manejo de migraciones de bases de datos, también llamadas migraciones de esquemas.

En este capítulo, aprenderá en detalle cómo configurar la base de datos de Flyway en su aplicación Spring Boot.

Configuración de la base de datos de Flyway

Primero, descargue el proyecto Spring Boot de la página de Spring Initializer www.start.spring.io y elija las siguientes dependencias:

• Spring Boot Starter Web
• Flyway
• MySQL
• JDBC

Los usuarios de Maven pueden agregar las siguientes dependencias en el archivo 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>

Los usuarios de Gradle pueden agregar las siguientes dependencias en el archivo 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')

En las propiedades de la aplicación, necesitamos configurar las propiedades de la base de datos para crear un DataSource y también las propiedades de la vía aérea que necesitamos configurar en las propiedades de la aplicación.

Para los usuarios del archivo de propiedades, agregue las siguientes propiedades en el archivo 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

Los usuarios de YAML pueden agregar las siguientes propiedades en el archivo 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"

Ahora, cree un archivo SQL bajo el src/main/resources/db/migrationdirectorio. Nombra el archivo SQL como "V1__Initial.sql"

CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');

El código principal del archivo de clase de la aplicación Spring Boot se proporciona a continuación:

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

El archivo de configuración de compilación completo se proporciona a continuación.

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se indican a continuación:

Para Maven, puede usar el comando que se muestra aquí:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se muestra aquí:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el siguiente comando:

java –jar <JARFILE>

Ahora, Tomcat se inició en el puerto 8080 y en la ventana de la consola puede ver los registros de la base de datos de flyway como se muestra aquí.

Ahora puede ir a la base de datos y hacer las consultas de selección.

Al utilizar el servicio web RESTful de Spring Boot, puede enviar un correo electrónico con Gmail Transport Layer Security. En este capítulo, comprendamos en detalle cómo utilizar esta función.

Primero, necesitamos agregar la dependencia Spring Boot Starter Mail en su archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml.

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en su archivo build.gradle.

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

El código del archivo de clase de la aplicación Spring Boot principal se proporciona a continuación:

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

Puede escribir una API Rest simple para enviar por correo electrónico en el archivo de clase Rest Controller como se muestra.

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

Puede escribir un método para enviar el correo electrónico con un archivo adjunto. Defina las propiedades mail.smtp y utilice 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);   
}

Ahora, llame al método sendmail () anterior desde la API Rest como se muestra:

@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
   sendmail();
   return "Email sent successfully";   
}

Note - Active permitir aplicaciones menos seguras en la configuración de su cuenta de Gmail antes de enviar un correo electrónico.

El archivo de configuración de compilación completo se proporciona a continuación.

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

Ahora, puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se muestran a continuación:

Para Maven, puede usar el comando como se muestra:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se indica a continuación:

java –jar <JARFILE>

Puede ver que la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora presione la siguiente URL desde su navegador web y recibirá un correo electrónico.

http://localhost:8080/sendemail

Hystrix es una biblioteca de Netflix. Hystrix aísla los puntos de acceso entre los servicios, detiene las fallas en cascada entre ellos y proporciona las opciones de reserva.

Por ejemplo, cuando se está llamando a un 3 ^rd de aplicaciones de terceros, se necesita más tiempo para enviar la respuesta. Entonces, en ese momento, el control va al método de reserva y devuelve la respuesta personalizada a su aplicación.

En este capítulo, verá Cómo implementar Hystrix en una aplicación Spring Boot.

Primero, necesitamos agregar la dependencia Spring Cloud Starter Hystrix en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml:

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle:

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

Ahora, agregue la anotación @EnableHystrix en su archivo principal de clase de la aplicación Spring Boot. La anotación @EnableHystrix se usa para habilitar las funcionalidades de Hystrix en su aplicación Spring Boot.

El código principal del archivo de clase de la aplicación Spring Boot se proporciona a continuación:

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

Ahora escriba un controlador de descanso simple de modo que devuelva la cadena después de 3 segundos desde el tiempo solicitado.

@RequestMapping(value = "/")
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}

Ahora, agregue el comando @Hystrix y @HystrixProperty para la API Rest y defina el tiempo de espera en milisegundos.

@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})

A continuación, defina el método de reserva fallback_hello () si la solicitud tarda mucho en responder.

private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

Aquí se muestra el archivo completo de la clase Rest Controller que contiene la API REST y las propiedades de Hystrix:

@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}
private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

En este ejemplo, la API REST está escrita en el propio archivo de clase de la aplicación Spring Boot.

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

@SpringBootApplication
@EnableHystrix
@RestController
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
   @RequestMapping(value = "/")
   @HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
      @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
   })
   public String hello() throws InterruptedException {
      Thread.sleep(3000);
      return "Welcome Hystrix";
   }
   private String fallback_hello() {
      return "Request fails. It takes long time to response";
   }
}

El archivo de configuración de compilación completo se proporciona a continuación.

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle:

Para Maven, use el comando como se muestra:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se indica a continuación:

java –jar <JARFILE>

Esto iniciará la aplicación en el puerto 8080 de Tomcat como se muestra a continuación:

Ahora, presiona la URL http://localhost:8080/desde su navegador web y vea la respuesta de Hystrix. La API tarda 3 segundos en responder, pero el tiempo de espera de Hystrix es de 1 segundo.

En este capítulo, entendamos cómo construir una aplicación web interactiva usando Spring Boot con sockets web.

Para crear una aplicación web interactiva en Spring Boot con Web socket, debe agregar las siguientes dependencias.

Los usuarios de Maven deben agregar las siguientes dependencias en el archivo 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>

Los usuarios de Gradle pueden agregar las siguientes dependencias en su archivo 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")

Creemos un controlador de manejo de mensajes para trabajar con la mensajería STOMP. Los mensajes STOMP se pueden enrutar al archivo de clase @Controller. Por ejemplo, GreetingController está asignado para manejar los mensajes al destino "/ hola".

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

Ahora, configure Spring para la mensajería STOMP. Escriba un archivo de clase WebSocketConfig que amplíe la clase AbstractWebSocketMessageBrokerConfigurer como se muestra a continuación.

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

La anotación @EnableWebSocketMessageBroker se utiliza para configurar el intermediario de mensajes de socket web para crear puntos finales STOMP.

Puede crear un archivo de cliente del navegador en src / main / resources / static / index.html como se muestra:

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

Creemos un archivo app.js para consumir y producir los mensajes usando 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(); });
});

El código de la aplicación principal Spring Boot se muestra a continuación.

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

El archivo de configuración de compilación completo se proporciona a continuación.

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle como se muestra a continuación:

Para Maven, puede usar el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando que se proporciona aquí:

java –jar <JARFILE>

Ahora, la aplicación se ha iniciado en el puerto 8080 de Tomcat como se muestra.

Ahora, presiona la URL http://localhost:8080/ en su navegador web y conecte el enchufe web y envíe el saludo y reciba el mensaje.

Batch Service es un proceso para ejecutar más de un comando en una sola tarea. En este capítulo, aprenderá a crear un servicio por lotes en una aplicación Spring Boot.

Consideremos un ejemplo en el que vamos a guardar el contenido del archivo CSV en HSQLDB.

Para crear un programa de servicio por lotes, debemos agregar la dependencia de Spring Boot Starter Batch y la dependencia de HSQLDB en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar las siguientes dependencias en el archivo pom.xml.

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

Los usuarios de Gradle pueden agregar las siguientes dependencias en el archivo build.gradle.

compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")

Ahora, agregue el archivo de datos CSV simple debajo de classpath resources - src / main / resources y nombre el archivo como file.csv como se muestra -

William,John
Mike, Sebastian
Lawarance, Lime

A continuación, escriba un script SQL para HSQLDB, bajo el directorio de recursos classpath, request_fail_hystrix_timeout

DROP TABLE USERS IF EXISTS;
CREATE TABLE USERS  (
   user_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
   first_name VARCHAR(20),
   last_name VARCHAR(20)
);

Cree una clase POJO para el modelo USERS como se muestra:

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

Ahora, cree un procesador intermedio para realizar las operaciones después de leer los datos del archivo CSV y antes de escribir los datos en 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;
   }
}

Creemos un archivo de configuración por lotes, para leer los datos de CSV y escribir en el archivo SQL como se muestra a continuación. Necesitamos agregar la anotación @EnableBatchProcessing en el archivo de clase de configuración. La anotación @EnableBatchProcessing se usa para habilitar las operaciones por lotes para su aplicación 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();
   }
}

los reader() El método se usa para leer los datos del archivo CSV y el método writer () se usa para escribir datos en el SQL.

A continuación, tendremos que escribir una clase de escucha de notificación de finalización del trabajo, que se utiliza para notificar después de la finalización del trabajo.

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

Ahora, cree un archivo JAR ejecutable y ejecute la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle.

Para Maven, use el comando como se muestra:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando que se proporciona aquí:

java –jar <JARFILE>

Puede ver la salida en la ventana de la consola como se muestra:

Apache Kafka es un proyecto de código abierto que se utiliza para publicar y suscribir mensajes basados ​​en el sistema de mensajería tolerante a fallas. Es rápido, escalable y distribuido por diseño. Si es un principiante en Kafka o desea comprenderlo mejor, consulte este enlace: www.tutorialspoint.com/apache_kafka/

En este capítulo, veremos cómo implementar la aplicación Apache Kafka en Spring Boot.

Primero, necesitamos agregar la dependencia Spring Kafka en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml.

<dependency>
   <groupId>org.springframework.kafka</groupId>
   <artifactId>spring-kafka</artifactId>
   <version>2.1.0.RELEASE</version>
</dependency>

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle.

compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'

Producir mensajes

Para producir mensajes en Apache Kafka, necesitamos definir la clase de configuración para la configuración de Producer como se muestra:

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

Para publicar un mensaje, cablee automáticamente el objeto Plantilla de Kafka y genere el mensaje como se muestra.

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
 
public void sendMessage(String msg) {
   kafkaTemplate.send(topicName, msg);
}

Consumir un mensaje

Para consumir mensajes, necesitamos escribir un archivo de clase de configuración de consumidor como se muestra a continuación.

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

A continuación, escriba un Oyente para escuchar los mensajes.

@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
   System.out.println("Received Messasge in group - group-id: " + message);
}

Llamemos al método sendMessage () del método de ejecución de la clase ApplicationRunner desde el archivo de clase de la aplicación Spring Boot principal y consumamos el mensaje del mismo archivo de clase.

Su código de archivo de clase de la aplicación Spring Boot principal se proporciona a continuación:

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

El código para el archivo de configuración de compilación completo se proporciona a continuación.

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

Ahora, cree un archivo JAR ejecutable y ejecute la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle como se muestra:

Para Maven, use el comando como se muestra:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando que se proporciona aquí:

java –jar <JARFILE>

Puede ver el resultado en la ventana de la consola.

Twilio es un 3 ^rd de aplicaciones de terceros utilizado para enviar SMS y hacer llamadas de voz desde nuestra aplicación. Nos permite enviar SMS y realizar llamadas de voz mediante programación.

En este capítulo, aprenderá cómo implementar el envío de SMS y hacer llamadas de voz usando Spring Boot con Twilio.

Note- Usamos la cuenta Trail en Twilio para enviar los SMS y hacer llamadas de voz. Puede obtener más información sobre Twilio en www.twilio.com .

Primero, necesitamos agregar la dependencia Twilio en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml.

<dependency>
   <groupId>com.twilio.sdk</groupId>
   <artifactId>twilio</artifactId>
   <version>7.16.1</version>
</dependency>

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle.

compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"

Ahora, inicialice la cuenta Twilio con ACCOUNT_SID y AUTH_ID en un bloque estático como se muestra:

static {
   Twilio.init(ACCOUNT_SID, AUTH_ID);
}

Envío de SMS

Para enviar el SMS, debemos proporcionar un número de remitente y un número de destino al método Message.create (). El contenido del cuerpo del mensaje también debemos proporcionar el método Message.creator () como se muestra:

Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
   "Message from Spring Boot Application").create();

El archivo principal de clase de la aplicación Spring Boot se ve a continuación.

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

El código completo para construir el archivo de configuración se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle:

Para Maven, use el comando como se muestra:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando que se indica a continuación:

java –jar <JARFILE>

Ahora, recibirá el SMS a su "número de destino".

Mensaje recibido para "to-number".

Sent from your Twilio trail account
- Message from Spring Boot Application

Note- En este ejemplo, usamos la cuenta Trail. Por lo tanto, debe verificar los números antes de enviar el SMS.

Llamadas de voz

Para hacer llamadas de voz usando Twilio, necesitamos llamar al método Call.creator (). Para este método, necesitamos proporcionar un número para, un número de remitente y una nota de voz como se muestra aquí.

Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
   new URI("http://demo.twilio.com/docs/voice.xml")).create();

El código para el archivo de clase de la aplicación Spring Boot principal se proporciona a continuación.

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

El código para el archivo de configuración de compilación completo se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle.

Para Maven, use el comando como se muestra:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando dado aquí:

java –jar <JARFILE>

Ahora, recibirá una llamada a su "número de destino" de Twilio.

Presione cualquier tecla después de atender la llamada, escuchará la nota de voz de https://demo.twilio.com/docs/voice.xml

Note- En este ejemplo, usamos la cuenta Trail. Por lo tanto, debe verificar los números antes de realizar llamadas.

La prueba unitaria es una de las pruebas realizadas por los desarrolladores para asegurarse de que las funcionalidades de las unidades o componentes individuales funcionen correctamente.

En este tutorial, veremos cómo escribir un caso de prueba unitario usando Mockito y Web Controller.

Mockito

Para inyectar Mockito Mocks en Spring Beans, necesitamos agregar la dependencia Mockito-core en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en su archivo 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>

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle.

compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')

Aquí se proporciona el código para escribir una clase de servicio que contiene un método que devuelve el valor de cadena.

package com.tutorialspoint.mockitodemo;

import org.springframework.stereotype.Service;

@Service
public class ProductService {
   public String getProductName() {
      return "Honey";
   } 
}

Ahora, inyecte la clase ProductService en otro archivo de clase de servicio como se muestra.

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

El archivo principal de clase de la aplicación Spring Boot se muestra a continuación:

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

Luego, configure el contexto de la aplicación para las pruebas. La anotación @Profile ("prueba") se utiliza para configurar la clase cuando se ejecutan los casos de prueba.

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

Ahora, puede escribir un caso de prueba unitaria para el servicio de pedidos en el src/test/resources paquete.

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

El código completo para el archivo de configuración de compilación se proporciona a continuación.

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle1.

Para Maven, puede usar el comando como se muestra:

mvn clean install

Puede ver los resultados de la prueba en la ventana de la consola.

Para Gradle, puede usar el comando como se muestra:

gradle clean build

Puede ver el resto de resultados en la ventana de la consola.

Spring Boot proporciona una manera fácil de escribir un archivo Unit Test for Rest Controller. Con la ayuda de SpringJUnit4ClassRunner y MockMvc, podemos crear un contexto de aplicación web para escribir el archivo Unit Test for Rest Controller.

Las pruebas unitarias deben escribirse bajo el src/test/java Los recursos de directorio y ruta de clases para escribir una prueba deben colocarse bajo el src/test/resources directorio.

Para escribir una prueba unitaria, necesitamos agregar la dependencia Spring Boot Starter Test en su archivo de configuración de compilación como se muestra a continuación.

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en su archivo build.gradle.

testCompile('org.springframework.boot:spring-boot-starter-test')

Antes de escribir un caso de prueba, primero debemos crear servicios web RESTful. Para obtener más información sobre la creación de servicios web RESTful, consulte el capítulo sobre los mismos que se proporciona en este tutorial.

Escribir una prueba unitaria para el controlador REST

En esta sección, veamos cómo escribir una prueba unitaria para el controlador REST.

Primero, necesitamos crear un archivo de clase abstracto utilizado para crear el contexto de la aplicación web usando MockMvc y definir los métodos mapToJson () y mapFromJson () para convertir el objeto Java en una cadena JSON y convertir la cadena JSON en un objeto 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);
   }
}

A continuación, escriba un archivo de clase que amplíe la clase AbstractTest y escriba una prueba unitaria para cada método, como GET, POST, PUT y DELETE.

El código para el caso de prueba GET API se proporciona a continuación. Esta API es para ver la lista de productos.

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

El código para el caso de prueba de la API POST se proporciona a continuación. Esta API es para crear un producto.

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

El código para el caso de prueba PUT API se proporciona a continuación. Esta API es para actualizar el producto existente.

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

El código para el caso de prueba Eliminar API se proporciona a continuación. Esta API eliminará el producto existente.

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

El archivo completo de la clase de prueba del controlador se proporciona a continuación:

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

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se indican a continuación:

Para Maven, puede usar el comando que se proporciona a continuación:

mvn clean install

Ahora, puede ver los resultados de la prueba en la ventana de la consola.

Para Gradle, puede usar el comando como se muestra a continuación:

gradle clean build

Puede ver el resto de resultados en la ventana de la consola como se muestra a continuación.

Spring Boot proporciona un muy buen soporte para crear una fuente de datos para la base de datos. No necesitamos escribir ningún código adicional para crear un DataSource en Spring Boot. Solo agregar las dependencias y hacer los detalles de configuración es suficiente para crear una fuente de datos y conectar la base de datos.

En este capítulo, usaremos la conexión del controlador Spring Boot JDBC para conectar la base de datos.

Primero, debemos agregar la dependencia JDBC de Spring Boot Starter en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar las siguientes dependencias en el archivo pom.xml.

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

Los usuarios de Gradle pueden agregar las siguientes dependencias en el archivo build.gradle.

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

Conectarse a la base de datos H2

Para conectar la base de datos H2, necesitamos agregar la dependencia de la base de datos H2 en nuestro archivo de configuración de compilación.

Para los usuarios de Maven, agregue la siguiente dependencia en su archivo pom.xml.

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

Para los usuarios de Gradle, agregue la siguiente dependencia en su archivo build.gradle.

compile('com.h2database:h2')

Necesitamos crear el archivo schema.sql y el archivo data.sql en el directorio classpath src / main / resources para conectar la base de datos H2.

El archivo schema.sql se muestra a continuación.

CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));

El archivo data.sql se muestra a continuación.

INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');

Conectar MySQL

Para conectar la base de datos MySQL, necesitamos agregar la dependencia MySQL en nuestro archivo de configuración de compilación.

Para los usuarios de Maven, agregue la siguiente dependencia en su archivo pom.xml.

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

Para los usuarios de Gradle, agregue la siguiente dependencia en su archivo build.gradle.

compile('mysql:mysql-connector-java')

Ahora, cree una base de datos y tablas en MySQL como se muestra:

Para los usuarios del archivo de propiedades, agregue las siguientes propiedades en el archivo 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

Para los usuarios de YAML, agregue las siguientes propiedades en el archivo 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

Conectar Redis

Redis es una base de datos de código abierto que se utiliza para almacenar la estructura de datos en memoria. Para conectar la base de datos de Redis en la aplicación Spring Boot, necesitamos agregar la dependencia de Redis en nuestro archivo de configuración de compilación.

Los usuarios de Maven deben agregar la siguiente dependencia en su archivo pom.xml.

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

Los usuarios de Gradle deben agregar la siguiente dependencia en su archivo build.gradle.

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

Para la conexión de Redis, necesitamos usar RedisTemplate. Para RedisTemplate, debemos proporcionar los detalles de 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;
}

Ahora conecte automáticamente la clase RedisTemplate y acceda a los datos de la base de datos de Redis.

@Autowired

RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);

JDBCTemplate

Para acceder a la base de datos relacional usando JdbcTemplate en la aplicación Spring Boot, necesitamos agregar la dependencia Spring Boot Starter JDBC en nuestro archivo de configuración de compilación.

Luego, si @Autowired la clase JdbcTemplate, Spring Boot conecta automáticamente la base de datos y establece la fuente de datos para el objeto JdbcTemplate.

@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");

La anotación @Repository debe agregarse al archivo de clase. La anotación @Repository se utiliza para crear un repositorio de base de datos para su aplicación Spring Boot.

@Repository
public class ProductServiceDAO {
}

Fuente de datos múltiple

Podemos mantener 'n' números de fuentes de datos en una sola aplicación Spring Boot. El ejemplo que se da aquí muestra cómo crear más de 1 fuente de datos en la aplicación Spring Boot. Ahora, agregue los dos detalles de configuración de la fuente de datos en el archivo de propiedades de la aplicación.

Para los usuarios del archivo de propiedades, agregue las siguientes propiedades en su archivo 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

Los usuarios de Yaml deben agregar las siguientes propiedades en su archivo 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

Ahora, cree una clase de configuración para crear un DataSource y JdbcTemplate para múltiples fuentes de datos.

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

Luego, cablee automáticamente el objeto JDBCTemplate usando la anotación @Qualifier.

@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;

@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;

Si se agrega una dependencia de Spring Boot Security en la ruta de clase, la aplicación Spring Boot requiere automáticamente la autenticación básica para todos los puntos finales HTTP. El Endpoint “/” y “/ home” no requiere autenticación. Todos los demás puntos finales requieren autenticación.

Para agregar Spring Boot Security a su aplicación Spring Boot, necesitamos agregar la dependencia Spring Boot Starter Security en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en el archivo pom.xml.

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Asegurar una aplicación web

Primero, cree una aplicación web insegura utilizando plantillas de Thymeleaf.

Luego, cree un archivo home.html en src/main/resources/templates directorio.

<!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 simple /hello definido en el archivo HTML mediante el uso de plantillas Thymeleaf.

Ahora, cree un hello.html en src/main/resources/templates directorio.

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

Ahora, necesitamos configurar el controlador Spring MVC - View para las vistas de inicio y hola.

Para ello, cree un archivo de configuración MVC que amplíe 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");
   }
}

Ahora, agregue la dependencia de seguridad Spring Boot Starter a su archivo de configuración de compilación.

Los usuarios de Maven pueden agregar la siguiente dependencia en su archivo pom.xml.

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

Los usuarios de Gradle pueden agregar la siguiente dependencia en el archivo build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Ahora, cree un archivo de configuración de seguridad web, que se utiliza para proteger su aplicación para acceder a los puntos finales HTTP mediante la autenticación básica.

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

Ahora, cree un archivo login.html bajo el src/main/resources directorio para permitir que el usuario acceda al punto final HTTP a través de la pantalla de inicio de sesión.

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

Finalmente, actualice el archivo hello.html, para permitir que el usuario cierre sesión en la aplicación y muestre el nombre de usuario actual como se muestra a continuación.

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

El código para la aplicación principal Spring Boot se proporciona a continuación:

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

El código completo para el archivo de configuración de compilación se proporciona a continuación.

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

Ahora, cree un archivo JAR ejecutable y ejecute la aplicación Spring Boot utilizando los siguientes comandos de Maven o Gradle.

Los usuarios de Maven pueden usar el comando como se indica a continuación:

mvn clean install

Después de “BUILD SUCCESS”, puede encontrar el archivo JAR en el directorio de destino.

Los usuarios de Gradle pueden usar el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra a continuación:

java –jar <JARFILE>

Pulsa la URL http://localhost:8080/en su navegador web. Puede ver la salida como se muestra.

En este capítulo, aprenderá en detalle sobre los mecanismos de Spring Boot Security y OAuth2 con JWT.

Servidor de autorización

Authorization Server es un componente arquitectónico supremo para Web API Security. El servidor de autorización actúa como un punto de autorización de centralización que permite que sus aplicaciones y puntos finales HTTP identifiquen las características de su aplicación.

Servidor de recursos

Resource Server es una aplicación que proporciona el token de acceso a los clientes para acceder a los puntos finales HTTP del servidor de recursos. Es una colección de bibliotecas que contiene los puntos finales HTTP, recursos estáticos y páginas web dinámicas.

OAuth2

OAuth2 es un marco de autorización que permite que la aplicación Web Security acceda a los recursos del cliente. Para crear una aplicación OAuth2, debemos centrarnos en el tipo de concesión (código de autorización), la identificación del cliente y el secreto del cliente.

Token JWT

JWT Token es un JSON Web Token, que se utiliza para representar los reclamos asegurados entre dos partes. Puede obtener más información sobre el token JWT en www.jwt.io/ .

Ahora, vamos a construir una aplicación OAuth2 que habilita el uso de Authorization Server, Resource Server con la ayuda de un JWT Token.

Puede utilizar los siguientes pasos para implementar Spring Boot Security con el token JWT accediendo a la base de datos.

Primero, necesitamos agregar las siguientes dependencias en nuestro archivo de configuración de compilación.

Los usuarios de Maven pueden agregar las siguientes dependencias en su archivo 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>

Los usuarios de Gradle pueden agregar las siguientes dependencias en el archivo 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")

dónde,

• Spring Boot Starter Security - Implementa Spring Security

• Spring Security OAuth2 - Implementa la estructura OAUTH2 para habilitar el servidor de autorización y el servidor de recursos.

• Spring Security JWT - Genera el token JWT para seguridad web

• Spring Boot Starter JDBC - Accede a la base de datos para asegurar que el usuario esté disponible o no.

• Spring Boot Starter Web - Escribe extremos HTTP.

• H2 Database - Almacena la información del usuario para autenticación y autorización.

El archivo de configuración de compilación completo se proporciona a continuación.

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

Ahora, en la aplicación Spring Boot principal, agregue la anotación @EnableAuthorizationServer y @EnableResourceServer para actuar como un servidor de autenticación y un servidor de recursos en la misma aplicación.

Además, puede usar el siguiente código para escribir un punto final HTTP simple para acceder a la API con Spring Security usando JWT Token.

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

Utilice el siguiente código para definir la clase POJO para almacenar la información del usuario para la autenticación.

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

Ahora, use el siguiente código y defina la clase CustomUser que extiende la clase org.springframework.security.core.userdetails.User para la autenticación 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());
   }
}

Puede crear la clase @Repository para leer la información del usuario de la base de datos y enviarla al servicio de usuario personalizado y también agregar la autoridad otorgada “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;
   }
}

Puede crear una clase de servicio de detalles de usuario personalizado que amplíe org.springframework.security.core.userdetails.UserDetailsService para llamar a la clase de repositorio DAO como se muestra.

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

A continuación, cree una clase @configuration para habilitar la seguridad web, definiendo el codificador de contraseña (BCryptPasswordEncoder) y definiendo el bean AuthenticationManager. La clase de configuración de seguridad debe extender la clase 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();
   }
}

Ahora, defina la clase de configuración OAuth2 para agregar el ID de cliente, el secreto del cliente, defina el JwtAccessTokenConverter, la clave privada y la clave pública para la clave del firmante del token y la clave del verificador, y configure ClientDetailsServiceConfigurer para la validez del token con alcances.

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

   }
}

Ahora, cree una clave privada y una clave pública utilizando openssl.

Puede utilizar los siguientes comandos para generar una clave privada.

openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem

Puede utilizar Para la generación de claves públicas, utilice los siguientes comandos.

openssl rsa -in jwt.pem -pubout

Para la versión de Spring Boot posterior a la 1.5, agregue la propiedad a continuación en su archivo application.properties para definir el orden del filtro de recursos OAuth2.

security.oauth2.resource.filter-order=3

Los usuarios del archivo YAML pueden agregar la siguiente propiedad en el archivo YAML.

security:
   oauth2:
      resource:
         filter-order: 3

Ahora, cree el archivo schema.sql y data.sql en los recursos de classpath src/main/resources/directory para conectar la aplicación a la base de datos H2.

El archivo schema.sql es como se muestra:

CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));

El archivo data.sql es como se muestra:

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 contraseña debe almacenarse en el formato de Bcrypt Encoder en la tabla de la base de datos.

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante los siguientes comandos de Maven o Gradle.

Para Maven, puede usar el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra aquí:

java –jar <JARFILE>

La aplicación se inicia en el puerto 8080 de Tomcat.

Ahora presione la URL del método POST a través de POSTMAN para obtener el token OAUTH2.

http://localhost:8080/oauth/token

Ahora, agregue los encabezados de solicitud de la siguiente manera:

• Authorization - Autenticación básica con su identificación de cliente y secreto de cliente.

• Content Type - aplicación / x-www-form-urlencoded

Ahora, agregue los parámetros de solicitud de la siguiente manera:

• grant_type = contraseña
• username = tu nombre de usuario
• contraseña = su contraseña

Ahora, presione la API y obtenga el access_token como se muestra:

Ahora, presione la API del servidor de recursos con el token de acceso al portador en el encabezado de solicitud como se muestra.

Entonces puede ver la salida como se muestra a continuación:

Google Cloud Platform proporciona servicios de computación en la nube que ejecutan la aplicación Spring Boot en el entorno de la nube. En este capítulo, veremos cómo implementar la aplicación Spring Boot en la plataforma del motor de aplicaciones GCP.

Primero, descargue la aplicación Spring Boot de la compilación Gradle desde la página de Spring Initializer www.start.spring.io . Observe la siguiente captura de pantalla.

Ahora, en el archivo build.gradle, agregue el complemento appengine de Google Cloud y la dependencia de classpath de appengine.

El código para el archivo build.gradle se proporciona a continuación:

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

Ahora, escriba un punto final HTTP simple y devuelve el éxito de la cadena como se muestra:

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

A continuación, agregue el archivo app.yml en el directorio src / main / appengine como se muestra:

runtime: java
env: flex

handlers:
- url: /.*
   script: this field is required, but ignored

Ahora, vaya a la consola de Google Cloud y haga clic en Activar el shell de la nube de Google en la parte superior de la página.

Ahora, mueva sus archivos de origen y el archivo Gradle al directorio de inicio de su máquina en la nube de Google utilizando el shell de Google Cloud.

Ahora, ejecute el comando gradle appengineDeploy y desplegará su aplicación en Google Cloud appengine.

Note - GCP debe tener la facturación habilitada y antes de implementar su aplicación en appengine, debe crear la plataforma de appengine en GCP.

La implementación de su aplicación en la plataforma appengine de GCP llevará unos minutos.

Después de una compilación exitosa, puede ver la URL del servicio en la ventana de la consola.

Ahora, presione la URL del servicio y vea el resultado.

Google Cloud SQL

Para conectar Google Cloud SQL a su aplicación Spring Boot, debe agregar las siguientes propiedades en su archivo application.properties.

Formato de 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 - La aplicación Spring Boot y Google Cloud SQL deben estar en el mismo proyecto de GCP.

El archivo application.properties se muestra a continuación.

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

Los usuarios del archivo YAML pueden agregar las siguientes propiedades a su archivo 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

En este capítulo, veremos cómo agregar el inicio de sesión de Google OAuth2 mediante la aplicación Spring Boot con la compilación de Gradle.

Primero, agregue la dependencia de seguridad Spring Boot OAuth2 en su archivo de configuración de compilación y su archivo de configuración de compilación se muestra a continuación.

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

Ahora, agregue el extremo HTTP para leer el User Principal de Google después de autenticarse a través de Spring Boot en el archivo de clase de la aplicación Spring Boot principal como se indica a continuación:

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

Ahora, escriba un archivo de configuración para habilitar OAuth2SSO para la seguridad web y elimine la autenticación para el archivo index.html como se muestra:

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

A continuación, agregue el archivo index.html en recursos estáticos y agregue el enlace para redirigir al extremo HTTP del usuario para leer el Principal del usuario de Google como se muestra a continuación:

<!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 - En la consola de Google Cloud: habilite los servicios de Gmail, los servicios de análisis y las API de servicios de Google+.

Luego, vaya a la sección Credenciales y cree una credencial y elija OAuth Client ID.

A continuación, proporcione un Nombre de producto en la pantalla de consentimiento de OAuth2.

A continuación, elija el Tipo de aplicación como "Aplicación web", proporcione los orígenes de JavaScript autorizados y los URI de redireccionamiento autorizados.

Ahora, se crea su ID de cliente de OAuth2 y su secreto de cliente.

A continuación, agregue el ID de cliente y el secreto de cliente en el archivo de propiedades de su aplicación.

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

Ahora, puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot mediante el siguiente comando de Gradle.

Para Gradle, puede usar el comando como se muestra:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ejecute el archivo JAR utilizando el comando java –jar <JARFILE> y la aplicación se inicia en el puerto Tomcat 8080.

Ahora presiona la URL http://localhost:8080/ y haga clic en el enlace de inicio de sesión de Google.

Redirigirá a la pantalla de inicio de sesión de Google y proporcionará los detalles de inicio de sesión de Gmail.

Si el inicio de sesión es exitoso, recibiremos el objeto Principal del usuario de Gmail.