IoC is a design principle where the control of object creation and management is transferred from the application code to an external container (Spring Container).

DI is the implementation of IoC where dependencies are injected into objects rather than objects creating their dependencies.

// 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
    }
}

Spring supports three types of DI:

1. Constructor Injection: Dependencies injected through constructor
2. Setter Injection: Dependencies injected through setter methods
3. Field Injection: Dependencies injected directly into fields using @Autowired

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

// Setter Injection
@Service
public class UserService {
    private UserRepository userRepository;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

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

These are stereotype annotations for different layers:

• @Component: Generic stereotype for any Spring-managed component
• @Service: Indicates service layer components (business logic)
• @Repository: Indicates data access layer components (DAO)
• @Controller: Indicates presentation layer components (MVC controllers)

All are essentially @Component with semantic meaning. @Repository provides additional exception translation.

Spring supports three configuration approaches:

1. XML-based configuration: Traditional XML files
2. Annotation-based configuration: Using annotations like @Component, @Autowired
3. Java-based configuration: Using @Configuration classes

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

@Autowired enables automatic dependency injection. Spring automatically injects matching beans by type. It can be used on:

• Constructors
• Setter methods
• Fields
• Method parameters

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

Spring Boot is an opinionated framework that simplifies Spring application development by providing:

• Auto-configuration: Automatically configures Spring applications
• Starter dependencies: Pre-configured dependency sets
• Embedded servers: Tomcat, Jetty, Undertow embedded
• Production-ready features: Metrics, health checks, externalized configuration
• No XML configuration: Convention over configuration
• Standalone applications: JAR files with embedded servers

Starters are pre-configured dependency descriptors that include all necessary dependencies for specific functionality:

• spring-boot-starter-web: Web applications (Spring MVC, Tomcat)
• spring-boot-starter-data-jpa: JPA with Hibernate
• spring-boot-starter-security: Spring Security
• spring-boot-starter-test: Testing (JUnit, Mockito, TestNG)