How Spring Boot Works Internally

Overview

Spring Boot looks at
1. Frameworks available on the run time CLASSPATH(build path)
  - (eg : web MVC , Spring Data JPA : ORM --default provider Hibernate, Jackson , DBCP : Hikari)
2. Existing configuration for the application(from application.properties or application.yaml file)
Based on these, Spring Boot provides default configuration needed to configure the application with these frameworks. This is called Auto Configuration.

Spring Boot Starters

It uses Spring Boot Starters :
- Starters are a set of convenient dependency descriptors that you can include in your application's pom.xml
  - Keeps track of required dependencies
  - Manages compatible versions.
eg : Suppose you want to develop a web application | RESTful web service
- W/o Spring boot , we would need to identify the frameworks we want to use, which versions of frameworks to use and how to connect them together.
- BUT all web application have similar needs.
  - These include Spring MVC, Jackson Databind (for data binding) - serialization n de-serialization , Hibernate-Validator (for server side validation using Java Validation API) and Log4j (for logging). Earlier while creating any web app, we had to choose the compatible versions of all these frameworks.
- With Spring boot : You just add Spring Boot Starter Web.
- Dependency for Spring Boot Starter Web
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```
- Just by adding above starter , it will add lot of dependency JARs under maven dependencies
Another eg : If you want to use Spring and JPA for database access, just include the spring-boot-starter-data-jpa dependency in your project, and you are good to go.

Important Component of a Spring Boot Application

Starting Point

Below is the starting point of a Spring Boot Application

@SpringBootApplication
public class DemoApplication {

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

}

About : org.springframework.boot.SpringApplication
- It's a Class used to bootstrap and launch a Spring application from a Java main method.
- By default it will perform the following steps to bootstrap the application
  1. It launches an embedded Tomcat container.
  2. Creates an ApplicationContext instance (sub i/f : WebApplicationContext --> implementation class --> AnnotationConfigWebApplicationContext : representing SC suitable in spring boot managed web scenario) --meaning launches SC from within Spring boot app.
  3. Configures Spring MVC components
    - DispatcherServlet, HandlerMapping , ViewResolver(only in case of MVC controller)
  4. Configures Hikari supplied DBCP
    - configures auto Tx support...
  5. SC manages life cycle of spring beans
    - eg - RestController , Service , Repository(DAO) ...

Important Annotation: @SpringBootApplication

@SpringBootApplication - This is where all the spring boot magic happens.
It consists of following 3 annotations.

1. @SpringBootConfiguration

(equivalent to @Configuration | bean config xml file)
It tells spring boot that this class is a configuration class which can have several bean definitions. We can define various spring beans here and those beans will be available at run time.
- (using @Bean method level annotation)
- eg : ModelMapper, PasswordEncoder.AuthenticationManager...

2. @EnableAutoConfiguration

It tells spring boot to automatically configure the spring application based on the dependencies available on the classpath.