Presentación de Spring Boot en Autentia, 13 Noviembre 2014

1. Spring Boot
AUTENTIA.COM
Jorge Pacheco Mengual
@tanoka12
Madrid 13 Noviembre de 2014

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

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

4. ¿¿ 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.

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

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

7. Al lio .. ejecutar
● mvn spring-boot:run
● mvn clean package → genera un jar ejecutable
● jar java -jar target/ejemplo1.jar

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

9. Como usar Spring Boot .. Starters
● Agrupaciones de dependencias clasificadas por tipos
que evita tener que configurarlas manualmente.
Funcionalidad
spring-boot-starter-web
spring-boot-starter-data-jpa
spring-boot-starter-data-mongodb
spring-boot-starter-security
spring-boot-starter-security
sspring-boot-starter-thymeleaf
sspring-boot-starter-test

10. Como usar Spring Boot .. Starters
Caracteristicas
Metricas
spring-boot-starter-jetty
spring-boot-starter-tomcat
spring-boot-starter-logging
spring-boot-starter-log4j
spring-boot-starter-actuator
spring-boot-starter-remote-shell

11. Configuración
@Configuration
@EnableAutoConfiguration
@ComponentScan
public 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

12. Autoconfiguración
@Configuration
@EnableAutoConfiguration
@ComponentScan
public 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.

13. Autoconfiguración
● Se puede desactivar partes de la autoconfiguración
● Si al ejecutar ponemos --debug se podrá ver un informe de la auto-configuración
@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

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

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

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

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

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

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

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

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

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

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

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

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

26. 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
@ComponentScan
public class Application extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Application.class);
}
}

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

28. 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/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
● O por JNDI:
spring.datasource.jndi-name=java:jboss/datasources/customers

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

30. 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
@Entity
public 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);
}

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

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

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

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

35. EndPoints… Personalización
● Estos endpoint se pueden personalizar desde el
application.properties
endpoints.beans.id=springbeans
endpoints.beans.sensitive=false
endpoints.shutdown.enabled=true
● Securizarlos
security.user.name=admin
security.user.password=secret
● Añadir un Context-Path común
management.context-path=/manage
management.port=8081

36. 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.
@Component
public class MyHealth implements HealthIndicator {
@Override
public Health health() {
// perform some specific health check
return ...
}
}

37. 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=AutentiaBootApplication
info.app.description=Aplicación de Ejemplo de Actuator
info.app.version=1.0.0
● Maven “project properties” via placeholders
info.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)

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

39. Métricas … CounterService
@Service
public class MyService {
private final CounterService counterService;
@Autowired
public MyService(CounterService counterService) {
this.counterService = counterService;
}
public void exampleMethod() {
this.counterService.increment("services.system.myservice.invoked");
}
}

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

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

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

43. Actuator .. Remote Shell
● Podemos sobreescribir el usuario y password de
acceso.
shell.auth.simple.user.name=user
shell.auth.simple.user.password=password
● Si disponemos de Spring Security podemos hacer
que este sea el encargado de gestionar el acceso.

44. Otras carácteristicas ….
● JMS
● NoSQL
○ MongoDB
○ Redis
○ ElasticSearch
○ Solr
● Spring Batch
● Spring Integration
● Spring Cloud
● Spring Boot CLI

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

46. PetClinic con Spring Boot
Pom.xml Configuration Properties
PetClinic
377 lines
77 imported
artifact
9 XML files
350 lines
2 files
17 lines
Spring Boot
117 lines
79 imported
artifacts
6 JavaConfig
130 lines
1 file
10 lines

47. Ejemplos
Los ejemplos mostrados en esta charla se
encuentran:
https://github.com/jorgepacheco/charla_spring_boot

48. Y para concluir
PREGUNTAS
¿?