Spring Boot.

Spring is the core framework that you configure yourself, while Spring Boot configures it for you. Spring Boot is built on top of Spring and adds opinionated defaults, so a new application runs with almost no setup.

Spring Boot does not replace Spring. Its auto-configuration creates the beans you would otherwise declare by hand, based on the libraries on the classpath. Starters add a tested set of libraries with one dependency. The embedded server lets you start the app with java -jar.

Your own configuration still takes precedence. When you declare a bean yourself, Spring Boot skips its default for that bean.

The deployment row is the usual case, not a limit. A Spring Boot app can still be packaged as a WAR for an external server, by extending SpringBootServletInitializer.

Spring Boot starters are dependency descriptors that bring in everything one feature needs through a single entry in your build file. Add spring-boot-starter-data-jpa, and you get Spring Data JPA and Hibernate at versions tested together.

Commonly used starters:

• spring-boot-starter-webmvc: web apps and REST APIs with Spring MVC and Tomcat. Before Spring Boot 4 it was spring-boot-starter-web, which still works but is deprecated.
• spring-boot-starter-data-jpa: JPA with Hibernate
• spring-boot-starter-security: Spring Security
• spring-boot-starter-test: testing with JUnit and Mockito
• spring-boot-starter-actuator: monitoring and management
• spring-boot-starter-data-redis: Redis data access
• spring-boot-starter-mail: email support

You leave the versions off. Spring Boot's dependency management picks them, so upgrading Spring Boot upgrades the whole set.

@SpringBootApplication is a convenience annotation that combines three annotations. One line on the main class registers your configuration and turns on auto-configuration and component scanning.

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

It is equivalent to:

• @SpringBootConfiguration: marks the class as a source of beans. It is a specialized @Configuration that also helps tests find your configuration.
• @EnableAutoConfiguration: turns on auto-configuration, which creates beans from the libraries on the classpath.
• @ComponentScan: scans the current package and its sub-packages for components.

Scanning starts at the package of this class, so put the main class in a root package above your other classes.

All four mark a class as a Spring bean that component scanning picks up. They are stereotype annotations, and @Service, @Repository and @Controller are specializations of @Component that also name the layer the class belongs to.

• @Component is the generic stereotype for any Spring-managed class.
• @Service marks business logic in the service layer.
• @Repository marks data access. It also turns on exception translation, which converts database-specific exceptions into Spring's DataAccessException hierarchy.
• @Controller marks the presentation layer. Spring MVC treats these classes as handlers for HTTP requests.

@Service
public class UserService { }
@Repository
public class UserRepository { }
@Controller
public class UserController { }

For component scanning, the four behave the same. The specific annotation still matters, because tools and aspects can target a layer by its annotation. Spring may also give these annotations more behavior in future versions, so use the one that matches the role of the class.

You create a REST service by adding the web starter and writing a class annotated with @RestController. Each handler method maps an HTTP method and a path to Java code, and Spring converts the return value to JSON.

1. Add the web starter, spring-boot-starter-webmvc, named spring-boot-starter-web before Spring Boot 4. It brings Spring MVC, the Jackson JSON library and an embedded Tomcat web server.
2. Annotate a class with @RestController and give it a base path with @RequestMapping.
3. Map each operation with a shortcut annotation that has the HTTP method built in, such as @GetMapping or @PostMapping.
4. Read input with @PathVariable for a path segment and @RequestBody for a JSON body.

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
    // ...
}

Start the @SpringBootApplication main class, and a GET request to /api/users/1 returns that user as JSON. To choose the status code yourself, return a ResponseEntity, for example 201 Created from the POST method.

Inversion of Control (IoC) is the principle that a container, not your code, creates objects and manages them. In Spring that container is usually an ApplicationContext. Dependency Injection (DI) is how Spring puts IoC into practice. An object declares what it needs, and the container passes those dependencies in.

// Without DI - tight coupling
public class UserService {
    private UserRepository userRepository = new UserRepository(); // Tight coupling
}

// With DI - loose coupling
public class UserService {
    private UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository; // Dependency injected
    }
}

In the first class, UserService builds its own UserRepository with new, so the two are tightly coupled. You cannot swap in another implementation or a test mock without editing the class.

In the second class, the dependency arrives through the constructor. Spring chooses what to inject, and a unit test can pass a mock. That is loose coupling.

Spring supports three types of dependency injection: constructor, setter and field injection.

1. Constructor injection passes dependencies as constructor arguments.
2. Setter injection calls a setter marked with @Autowired after the object is created.
3. Field injection puts @Autowired on a field, and Spring sets it through reflection.

// Constructor Injection (Recommended)
@Service
public class UserService {
    private final UserRepository userRepository;
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

// Field Injection
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
}

Prefer constructor injection. The fields can be final, the object never exists without its dependencies, and a test can pass mocks to the constructor with no container. A class with one constructor needs no @Autowired on it.

Use setter injection for optional dependencies. Avoid field injection, because it hides what a class needs and makes it hard to test without Spring.

Spring supports three ways to configure an application: XML files, annotations on your classes, and Java configuration classes.

1. XML-based configuration declares beans and their wiring in XML files. It appears mostly in older projects.
2. Annotation-based configuration marks classes with @Component and injection points with @Autowired, and component scanning finds them.
3. Java-based configuration uses @Configuration classes whose @Bean methods create beans.

// Java-based configuration
@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }
    
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
}

Most applications mix the last two. Annotations cover your own classes, and @Bean methods cover third-party classes you cannot annotate. Spring Boot can still load an old XML file with @ImportResource.

@Autowired tells Spring to inject a dependency automatically. Spring finds the bean whose type matches the field or parameter, which is matching by type, and passes it in.

You can put it on:

• constructors
• setter methods, and other methods with any name
• fields
• method parameters

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository; // Field injection
    
    @Autowired
    public UserService(UserRepository userRepository) { // Constructor injection
        this.userRepository = userRepository;
    }
}

The example uses two places at once only to show both. In real code you pick one, usually the constructor. When a class has a single constructor, that constructor needs no @Autowired.

Every place Spring fills is required by default, so startup fails when no bean matches. Use @Autowired(required = false) or Optional for an optional dependency. When several beans match, choose one with @Qualifier or mark one bean @Primary.

Spring Boot is an opinionated framework on top of Spring that gets a production-ready application running with little setup. It follows convention over configuration, so it picks sensible defaults and you override only what you need.

Its main advantages:

• Auto-configuration creates beans from the libraries on the classpath, with no XML.
• Starter dependencies add a tested set of libraries with one dependency.
• An embedded server, Tomcat by default or Jetty, runs inside the app.
• The app ships as one executable JAR that starts with java -jar.
• Actuator adds health checks and metrics.
• Externalized configuration keeps settings in properties files and environment variables, outside the code.

The trade-off is that much happens implicitly, so you must know what to override when a default does not fit.