This document provides an introduction to Spring Boot, including its objectives, key principles, and features. It discusses how Spring Boot enables building standalone, production-grade Spring applications with minimal configuration. It demonstrates creating a "Hello World" REST app with one Java class. It also covers auto-configuration, application configuration, testing, supported technologies, case studies, and other features like production readiness and remote shell access.

1. Introduction to
Spring Boot
October 4, 2016
Purbarun Chakrabarti

2. Objectives
Make you want to use Spring Boot
Demystify how self-configuration works
Show Spring Boot in action
Share a return of migration experience to Spring Boot

3. Summary
The principles of Spring Boot
The traditional Hello World
Application configuration
Simplified tests
Demo: development of a Hello World application
Case studies: migration of the Spring Petclinic application
Overview of other features

4. Strong ideas
Accelerate the development of Spring applications
Convention over Configuration
No code generated
Easy deployment
Ready for production

5. Hello World
REST Application = 1 Java Class +1 pom.xml/build.gradle
@SpringBootApplication
@RestController
public class HelloWorld {
public static void main(String[] args) {
SpringApplication.run(HelloWorld.class, args);
}
@RequestMapping("/")
public String hello() {
return "Hello World!";
}
}

6. Technologies supported
Core : Spring Security, JTA, Spring Cache, Spring Session
Web : Spring MVC, Websocket, Jersey, Mobile, HATEOS
Template engines : Freemaker, Thymeleaf, Groovy, Mustache
Database
RDBMS : Spring Data JPA, JDBC, JOOQ
NoSQL : Redis, MongoDB, Elasticsearch, Cassandra
Spring Cloud Suite: Eureka, Hystrix, Turbine, AWS, OAuth2
I/O : Spring Batch and Integration, JavaMail, Camel, JMS, AMQP
Social : Facebook, Linkedin, Twitter

7. Auto-configuration (1/2)
The @SpringBootApplication annotation triggers the automatic
configuration of the Spring infrastructure
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
When the application starts, Spring Boot :
Scans all classes of @Configuration
Application-specific configuration classes
Spring Boot Classes Suffixed by AutoConfiguration
Use the JARs present in the classpath to make decisions

8. Auto-configuration (2/2)
Based on conditional activations
@Conditional, @ConditionalOnProperty, @ConditionalOnClass,
@ConditionalOnMissingClass ,@ConditionalOnMissingBean ,
@ConditionalOnWebApplication, @ConditionalOnNotWebApplication,
@ConditionalOnExpression
Possibility to create your own self-configuring library

9. Spring JDBC auto-configuration
@Configuration
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnSingleCandidate(DataSource.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class JdbcTemplateAutoConfiguration {
private final DataSource dataSource;
public JdbcTemplateAutoConfiguration(DataSource dataSource) {
this.dataSource = dataSource;
}
@Bean
@Primary
@ConditionalOnMissingBean(JdbcOperations.class)
public JdbcTemplate jdbcTemplate() {
return new JdbcTemplate(this.dataSource);
}
@Bean
@Primary
@ConditionalOnMissingBean(NamedParameterJdbcOperations.class)
public NamedParameterJdbcTemplate namedParameterJdbcTemplate() {
return new NamedParameterJdbcTemplate(this.dataSource);
}
}

10. Auto-configuration of the DataSource
Complexity of DataSourceAutoConfiguration
DataSource recovery by JNDI
Choice of connection pool : Tomcat, HikariCP
, Commons DBCP 1 or 2
Setting up the connection to the database
Configurationapplication.properties
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
Embedded database by JAR analysis in the classpath
XA Support
Pool exposure via JMX

11. Application Configuration
Centralized in
 application.properties
 or application.yml
Completion in the IDE
Expandable and TypeSafe configuration
 @ConfigurationProperties
Possibility of configuration specific to a deployment environment
 java -jar myapp,jar --spring.profiles.active=production
 Change application-production.properties

12. Self-configured tests
The spring-boot-starter-test starter pulls test frameworks :
JUnit, Spring Test, AssertJ, Mockito, JsonPath, JSONassert et Hamcrest.
Functionality of «slicing test»
Allows to segment tests : presentation layer, REST controllers, DAO …
Spring Boot is responsible for creating a dedicated application context
Annotations game : @WebMvcTest, @JsonTest, @DataJpaTest, @RestClientTest
Possibility to create your own slice (ex: @DataJdbcTest)
Automatic creation of mocks with @MockBean
For integration testing, @SpringBootTest allows you to start a servlet
container

13. @RunWith(SpringRunner.class)
@WebMvcTest(OwnerController.class)
public class OwnerControllerTests {
@Autowired
private MockMvc mockMvc;
@MockBean
private ClinicService clinicService;
@Test
public void testDisplayOwner() throws Exception {
Owner george = new Owner(1, "George", "Franklin");
given(this.clinicService.findOwnerById(1)).willReturn(george);
mockMvc.perform(get("/owners/{ownerId}", 1))
.andExpect(status().isOk())
.andExpect(model().attribute("owner", hasProperty("lastName", is("Franklin"))))
.andExpect(model().attribute("owner", hasProperty("firstName", is("George"))))
.andExpect(view().name("owners/ownerDetails"));
}
}
Unit test example
Initialization of a web application
context scanning Spring MVC beans
and configuration of MockMvc
Mockito simulacrum recorded in the
Spring application context and made
available by auto-wiring
Alias for SpringJUnit4ClassRunner

14. Live coding
Using Spring Initializr from IntelliJ : WEB, JPA, thymeleaf
Using the H2 database
Creation of a service REST HelloWorld
Logger configuration
Tomcat to Jetty migration
Actuator demo
Banner customization
Running a self-executing JAR
Port change by configuration, parameter and Spring profile

15. Case studies: Spring Petclinic migration

16. And many other features
Customizing the Startup Banner
Ready for Production
Initializing databases
Exécution de jobs Spring Batch
Shell remote (CRaSH)
Spring Boot CLI
Use Jetty or Undertow instead of Tomcat
Live Reload & Hot swapping
Installation as a Linux or Windows service

17. Conclusion
Allows you to quickly set up an application Java based on Spring
Drastically reduces the Spring configuration
Can replace a Business base
Say goodbye to the good old big application servers
Make JAR not WAR

18. Resources
Spring Boot Reference Manual(Pivotal)
Bootiful Microservice (Josh Long)
Custom test slice with Spring Boot 1.4 (S. Nicoll)
Spring Guides (Pivotal)