Spring BootAUTENTIA.COM
Jorge Pacheco Mengual@tanoka12Madrid 13 Noviembre de 2014
QUE ES ???
● Es un nuevo módulo de la plataforma Spring cuyo objetivo es simplificar la creación de aplicaciones y servicios listos para ejecutarse.
Objetivos
● Ofrecer una forma muy sencilla de arrancar desarrollos Spring.
● Disponer de funcionalidad out-of-the-box en función de la naturaleza del proyecto (web, jpa, jms, nosql, etc ..)
● Dotar a las aplicaciones de herramientas que permitan su monitorización y auditoría.
¿¿ Cómo ??● Simplificar la configuración de maven/gradle (Starter)
● Configurar automáticamente Spring siempre que sea posible. (CoC)
● Ofrece una serie de características no funcionales comunes a los proyectos (por ejemplo, servidores embebidos, seguridad, métricas, configuración externalizada)
● Sin generar código ni configuración XML.
Al lio … configurar Maven<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.2.0.BUILD-SNAPSHOT</version> </parent>…<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency>…..<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
Al lio … Clase Application@RestController
@EnableAutoConfiguration
@ComponentScan
public class Application {
@Autowired
private MyService service;
@RequestMapping("/hello")
String home() {
return service.message();
}
public static void main(String[] args) throws Exception {
SpringApplication.run(Application.class, args);
}
}
Al lio .. ejecutar
● mvn spring-boot:run
● mvn clean package → genera un jar ejecutable
● jar java -jar target/ejemplo1.jar
Como usar Spring Boot● Spring Boot se puede usar tanto con Maven como
con Gradle (Nos centraremos en maven)
● Se puede heredar de spring-boot-starter-parent que nos proporciona las siguientes características○ Java 1.6 .○ UTF-8 source encoding.○ Dependency Management section○ Sensible resource filtering.○ Incluye plugins básicos (exec plugin, surefire, Git
commit ID, shade).● spring-boot-maven-plugin para añadir el
empaquetado en un jar ejecutable
Como usar Spring Boot .. Starters● Agrupaciones de dependencias clasificadas por tipos
que evita tener que configurarlas manualmente.
Funcionalidad
spring-boot-starter-data-jpa
spring-boot-starter-web
spring-boot-starter-data-mongodb
spring-boot-starter-security
spring-boot-starter-security
sspring-boot-starter-thymeleaf
sspring-boot-starter-test
Como usar Spring Boot .. Starters
Metricas
Caracteristicas
spring-boot-starter-actuator
spring-boot-starter-remote-shell
spring-boot-starter-jetty
spring-boot-starter-tomcat
spring-boot-starter-log4j
spring-boot-starter-logging
Configuración@Configuration@EnableAutoConfiguration@ComponentScanpublic class Application { public static void main(String[] args) {
SpringApplication.run(Application.class, args); }}
● Favorece la configuración basada en Java● @Configuration Anotación de Spring para marcar esta
clase como clase de configuración. ● @ComponentScan Para que Spring “escanee” en esta
clase y a partir del paquete de esta clase para buscar otros componentes springs
Autoconfiguración@Configuration@EnableAutoConfiguration@ComponentScanpublic class Application { public static void main(String[] args) {
SpringApplication.run(Application.class, args); }}
● @EnableAutoConfiguration - Boot intenta configurar automáticamente la aplicación basándose en las dependencias que se han añadido
● No invasivo - En cualquier momento podemos añadir configuración manual para sustituir partes específicas de la configuración automática.
Autoconfiguración
@Configuration@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})public class Application { public static void main(String[] args) {
SpringApplication.run(Application.class, args); }}
● Se puede desactivar partes de la autoconfiguración
● Si al ejecutar ponemos --debug se podrá ver un informe de la auto-configuración
SpringApplication
public static void main(String[] args) { SpringApplication.run(MySpringConfiguration.class, args);
}
● SpringApplication clase encargada de arrancar una aplicación Spring.
● Crea el applicationContext adecuado ○ AnnotationConfigApplicationContext ○ AnnotationConfigEmbeddedWebApplicationContext
● Se le pueden añadir ApplicationEvents and listeners
Ejecución ..
● Desde un IDE como un aplicación java normal
● Desde un jar (Si hemos usado el plugin de empaquetado de Spring-Boot)
java -jar target/myproject-0.0.1-SNAPSHOT.jar
● Maven
mvn spring-boot:run
Externalizar la configuración● Archivos de propiedades.
○ application.properties
● Archivos YAML.
○ application.yml
● Variables de entorno.
● Argumentos de línea de comandos.
○ java -jar app.jar --name="Spring"
@Component public class MyBean { @Value("${name}") private String name;
}
Externalizar la configuración● Los bean anotados @ConfigurationProperties se
configurarán automáticamente con las propiedades de configuración
● Se le pueden añadir validaciones JSR-303
@Component@ConfigurationProperties(prefix="connection")
public class ConnectionSettings {
@NotNull
private String username;
private InetAddress remoteAddress;
}
# application.yml
connection:
username: admin
remoteAddress: 192.168.1.1
# application.properties
connection.username=admin
connection.remoteAddress=192.168.1.1
Profiles ● Spring permite la activación de perfiles a través de la
anotación @Profile@Configuration@Profile("production")public class ProductionConfiguration {
// ...
}
● El profile activo lo podriamos indicar desde la propiedad spring.profiles.active○ application.properties → spring.profiles.active=produccion
○ linea de comando → --spring.profiles.active=produccion
○ programaticamente → SpringApplication.setAdditionalProfiles(...)
● Tendremos ficheros de propiedades en función del profile activo application-{profile}.properties
Logging● Spring Boot usa internamente Commons Logging
● Por defecto el Log va por pantalla y con nivel ERROR, WARN and INFO
● Para definir un fichero de log se añade el parámetro logging.file o logging.path
Logging
● Se puede definir el nivel de log añadiendo al application.properties
logging.level.org.springframework.web= DEBUG
logging.level.org.hibernate= ERROR
● Se puede personalizar el sistema de trazas añadiendo las dependencias necesarias y el fichero de configuración apropiado al classpath.○ Logback → logback.xml
○ Log4j → log4j.properties or log4j.xml
○ JDK (Java Util Logging) → logging.properties
Desarrollo de Aplicaciones Web● Spring Boot, permite arrancar de manera fácil y
rápida aplicaciones web● Ofrece la posibilidad de crear un servidor embebido
como Tomcat y Jetty● Añade toda la configuración necesaria para trabajar
con Spring MVC.○ Inclusión ContentNegotiatingViewResolver
○ Soporte para recursos estáticos
○ Soporte para HttpMessageConverters
○ Inclusión de MessageCodeResolver
○ Registro automático de Converters, GenericConverter, Formatter
● Bastaría con añadir spring-boot-starter-web
Desarrollo de Aplicaciones Web● Si se quiere tener el control completo de Spring MVC
se añade un bean @Configuration con @EnableWebMvc
@EnableWebMvc
@Configuration
public class AppConfig {
@Bean
public InternalResourceViewResolver getInternalResourceViewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/pages/");
resolver.setSuffix(".jsp");
return resolver;
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/css/**").addResourceLocations("/css/");
registry.addResourceHandler("/js/**").addResourceLocations("/js/");
}
}
Desarrollo de Aplicaciones Web● Si se quiere mantener la configuración de Spring MVC
Boot y añadir configuración adicional (interceptors, formatters, view controllers etc. ) basta con extender el bean de configuración de WebMvcConfigurerAdapter, pero sin @EnableWebMvc
@Configuration
public class AppConfig extends WebMvcConfigurerAdapter {
@Bean public HttpMessageConverters customConverters() { HttpMessageConverter<?> additional = ... HttpMessageConverter<?> another = ... return new HttpMessageConverters(additional, another); }
}
Desarrollo de Aplicaciones Web● Contenido estático
○ Por defecto se encontrara en /static (o /public o /resources o /META-INF/resources)
● Proporciona auto-configuración para los motores de plantillas más comunes (añadiendo el starter adecuado)○ FreeMarker○ Groovy○ ThymeLeaf○ Velocity
● Los template los buscará por defecto en /main/resources/templates
Servidores embebidos● Spring Boot ofrece soporte para contenedores
embebidos (Tomcat o Jetty) escuchando 8080● Customizar el Servidor embebido
○ Definiendo en el application.properties
. server.port
. server.address
. server.sessionTimeout
. server.contextPath
○ O de manera programática
@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
container.setPort(9000);
}
}
WAR● Cambiar el <packaging>war</packaging> ● SpringBootServletInicializer que se apoya en la
especificación Servlet 3.0 para sustituir el contenido del web.xml de manera programática.
@Configuration@EnableAutoConfiguration@ComponentScanpublic class Application extends SpringBootServletInitializer {
@Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return application.sources(Application.class); }}
Seguridad● Sí Spring Security esta en el classpath la aplicación
web contendrá autenticación básica.○ AutenticationManager en memoria con un usuario 'user' y una
password aleatoria que saldrá en el log de la aplicación
○ Se protegerán todas las URL ignorando los path de recursos estáticos (/css/**, /js/**, /images/** and **/favicon.ico).
○ Incluye una serie de características de Spring Security por defecto (HSTS, XSS, CSRF,..)
● Se puede usar una configuración propia de seguridad añadiendo @EnableWebSecurity
● O añadir algún comportamiento usando un bean que extienda WebSecurityConfigurerAdapter
BBDD Relacionales● Spring Boot nos permite levantar un servidor de
BBDD embebido H2, HSQL o Derby con solo con añadir su dependencia.
● Esta BBDD se podrá crear y cargar si añadimos al classpath los ficheros schema.sql, data.sql
● Creará automáticamente un Datasource.
● Este DataSource se puede configurar a traves del application.properties
spring.datasource.url=jdbc:mysql://localhost/testspring.datasource.username=dbuserspring.datasource.password=dbpassspring.datasource.driver-class-name=com.mysql.jdbc.Driver
● O por JNDI:spring.datasource.jndi-name=java:jboss/datasources/customers
JDBC● Solo necesitaríamos incluir el starter spring-boot-
starter-jdbc● Configura automáticamente un JdbcTemplate
@Component
public class MyBean {
private final JdbcTemplate jdbcTemplate;
@Autowired
public MyBean(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
}
Spring Data JPA● Solo necesitaríamos incluir el starter spring-boot-
data-jpa● Escanearía todos los paquetes por debajo de la clase
principal de configuración buscando las Entity Classes y los Repositorios de Spring Data
@Entitypublic class City implements Serializable {
@Id @GeneratedValue private Long id;
@Column(nullable = false) private String name;
public interface CityRepository extends Repository<City, Long> {
Page<City> findAll(Pageable pageable); City findByNameAndCountryAllIgnoringCase(String name, String country);}
Test● spring-boot-starter-test, incluye las dependencias
○ Spring Test○ JUnit○ Hamcrest○ Mockito
● @SpringApplicationConfiguration alternativa a @ContextConfiguration, para conseguir las características de Spring Boot
@RunWith(SpringJUnit4ClassRunner.class)@SpringApplicationConfiguration(classes = SampleDataJpaApplication.class)public class CityRepositoryIntegrationTests {
@Autowired CityRepository repository;
}
Integration Test● @IntegrationTest
○ Levanta la aplicación escuchando en sus puertos por defecto.
○ Se puede configurar para que sean puertos que no estén ocupados
@RunWith(SpringJUnit4ClassRunner.class)@SpringApplicationConfiguration(classes = MyApplication.class)@WebAppConfiguration@IntegrationTest({"server.port=0", "management.port=0"})public class SomeIntegrationTests {
// ...
}
● TestRestTemplate subclase de RestTemplate
Actuator .. la Joya de la corona
● Spring Boot añade una serie de características adicionales que permiten monitorizar, auditar y administrar las aplicaciones.
● Simplemente añadiendo un starter spring-boot-starter-actuator
● Añade a nuestro proyecto una serie de endpoints para consultar estas características.
● Estos endpoints se pueden securizar.
Actuator … EndPoints● /health mostrará el estado de salud de la aplicación.
● /info mostrará información del proyecto
● /dump mostrará un dump de todos los threads.
● /beans mostrará todos los beans del ApplicationContext
● /autoconfig Muestra todas las auto-configuraciones disponibles
● /beans Lista de los beans manejados por Spring
● /configprops Lista de los @ConfigurationProperties
● /env Lista las propiedades registradas Spring’s.
● /metrics Muestra información de las métricas del proyecto
● /mappings Lista de los @RequestMapping path
● /shutdown Permite realizar un shutdown de la aplicación
● /trace Información de traza , por defecto las últimas peticiones HTTP
EndPoints… Personalización● Estos endpoint se pueden personalizar desde el
application.propertiesendpoints.beans.id=springbeans
endpoints.beans.sensitive=false
endpoints.shutdown.enabled=true
● Securizarlossecurity.user.name=adminsecurity.user.password=secret
● Añadir un Context-Path comúnmanagement.context-path=/managemanagement.port=8081
EndPoints … health● /health → Por defecto muestra OK si la aplicación
está levantada.● Se puede personalizar para comprobar si la BBDD
esta levantada (DataSourceHealthIndicator) o si los servicios rest están activos.
@Componentpublic class MyHealth implements HealthIndicator {
@Override public Health health() { // perform some specific health check return ... }
}
EndPoints … info● /info → Muestra información relativa al proyecto● Se puede personalizar esta información, añadiendo
datos al application.properties con el prefijo info.*info.app.name=AutentiaBootApplicationinfo.app.description=Aplicación de Ejemplo de Actuatorinfo.app.version=1.0.0
● Maven “project properties” via placeholdersinfo.build.artifact=${project.artifactId}
info.build.name=${project.name}
info.build.description=${project.description}
info.build.version=${project.version}
● Se puede añadir información git.branch and git.
commit (añadiendo git-commit-id-plugin)
EndPoints .. Métricas● /metrics → Devuelve información sobre el consumo
de memoria, heap, cargador de clases, número de peticiones, threads, etc ..
● Métricas de Datasource○ Máximo número de conexiones (datasource.xxx.max).○ Mínimo número de conexiones (datasource.xxx.min).○ Número de conexiones activas (datasource.xxx.active)○ Uso del pool de conexiones (datasource.xxx.usage).
● Crear tus propias métricas inyectando CounterService o GaugeService
● Se pueden añadir las métricas Coda Hale Metrics incluyendo su librería entre las dependencias del proyecto.
Métricas … CounterService
@Servicepublic class MyService {
private final CounterService counterService;
@Autowired public MyService(CounterService counterService) { this.counterService = counterService; }
public void exampleMethod() { this.counterService.increment("services.system.myservice.invoked"); }
}
Métricas… GaugeService
@RestController@RequestMapping("/user")public class UserController {
@Autowired private UserRepository repository;
@Autowired private GaugeService gaugeService;
@RequestMapping public User get(Long id) { Long start = new Date().getTime(); User user = repository.findOne(id); gaugeService.submit(‘time.get.user’, new Date().getTime() - start); return user; }
}
Métricas .. trazas● /trace → Registra las últimas peticiones HTTP.● Se pueden customizar para añadir nuestras trazas
inyectando TraceRepository en los Spring Beans{
"timestamp": 1394343677415, "info": { "method": "GET", "path": "/trace", "headers": { "request": { "Accept": "text/html,application/xhtml+xml,application/xml", "Connection": "keep-alive", "Accept-Encoding": "gzip, deflate", "User-Agent": "Mozilla/5.0 Gecko/Firefox", "Accept-Language": "en-US,en;q=0.5", "Cookie": "_ga=GA1.1.827067509.1390890128; ..." "Authorization": "Basic ...", "Host": "localhost:8080" }, "response": { "Strict-Transport-Security": "max-age=31536000”,
"X-Application-Context": "application:8080", "Content-Type": "application/json;charset=UTF-8", "status": "200" } } }}
Actuator .. Remote Shell● Acceso vía Remote Shell.● Añadiendo spring-boot-starter-remote-shell● Conectar a la Shell
○ Escuchando por defecto en el puerto 200
○ Se crea un usuario ‘user’
○ Password aleatoria (se muestra en consola)$ ssh -p 2000 user@localhost
user@localhost's password:
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.2.0.BUILD-SNAPSHOT) on myhost
● Comandos: metrics, beans, autoconfig ...
Actuator .. Remote Shell● Podemos sobreescribir el usuario y password de
acceso.shell.auth.simple.user.name=usershell.auth.simple.user.password=password
● Si disponemos de Spring Security podemos hacer que este sea el encargado de gestionar el acceso.
Otras carácteristicas ….● JMS
● NoSQL
○ MongoDB
○ Redis
○ ElasticSearch
○ Solr
● Spring Batch
● Spring Integration
● Spring Cloud
● Spring Boot CLI
Beneficios de Spring Boot● Simplifica la gestión de dependencias.
● Reduce la configuración (CoC).
● Facilita y acelera el desarrollo de aplicaciones Spring.
● Genera aplicaciones listas para ser ejecutadas.
● Monitorizar, auditar y administrar las aplicaciones.
PetClinic con Spring Boot
Pom.xml Configuration Properties
PetClinic377 lines
77 imported artifact
9 XML files
350 lines
2 files
17 lines
Spring Boot117 lines
79 imported artifacts
6 JavaConfig
130 lines
1 file
10 lines
EjemplosLos ejemplos mostrados en esta charla se encuentran:
https://github.com/jorgepacheco/charla_spring_boot
Y para concluir
PREGUNTAS
¿?