Spring Boot

Auto-Configuration Implementation Detail:

@Configuration
@ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {
    
    @Bean
    @ConditionalOnProperty(name = "spring.datasource.jndi-name")
    public DataSource dataSource(DataSourceProperties properties) {
        return createDataSource(properties);
    }
    
    // Additional configuration methods...
}
        

Property Resolution Order (Partial List):

1. Devtools global settings (~/.spring-boot-devtools.properties)
2. @TestPropertySource annotations
3. Command line arguments
4. SPRING_APPLICATION_JSON properties
5. ServletConfig init parameters
6. ServletContext init parameters
7. JNDI attributes from java:comp/env
8. Java System properties (System.getProperties())
9. OS environment variables
10. Profile-specific application properties
11. Application properties (application.properties/yml)
12. @PropertySource annotations
13. Default properties (SpringApplication.setDefaultProperties)
        

Conditional Configuration Example:

@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public DataSourceInitializer dataSourceInitializer(DataSourceProperties properties,
            ApplicationContext applicationContext) {
        return new DataSourceInitializer(properties, applicationContext);
    }

    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource dataSource(DataSourceProperties properties) {
        // Default implementation that will be used if no DataSource bean is defined
        return properties.initializeDataSourceBuilder().build();
    }
}
        

This pattern allows Spring Boot to provide a default DataSource implementation, but gives developers the ability to override it simply by defining their own DataSource bean.

Relaxed Binding Example:

All of these property specifications map to the same property:

# Different formats - all bind to the property "spring.jpa.databasePlatform"
spring.jpa.database-platform=MYSQL
spring.jpa.databasePlatform=MYSQL
spring.JPA.database_platform=MYSQL
SPRING_JPA_DATABASE_PLATFORM=MYSQL
        

RESTful API Example:

curl https://start.spring.io/starter.zip -d dependencies=web,data-jpa \
-d type=maven-project -d bootVersion=3.2.0 \
-d groupId=com.example -d artifactId=demo \
-d name=demo -d packageName=com.example.demo \
-d javaVersion=17 -o demo.zip
        

Maven pom.xml (Key Elements):

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Other dependencies -->
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
        

Equivalent Configuration:

@Configuration
@EnableAutoConfiguration
@ComponentScan(basePackages = "com.example.myapp")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
        

This is functionally equivalent to using @SpringBootApplication.

Auto-Configuration Order and Exclusions:

@SpringBootApplication(
    scanBasePackages = {"com.example.service", "com.example.web"},
    exclude = {DataSourceAutoConfiguration.class},
    excludeName = {"org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration"}
)
public class ApplicationWithCustomization {
    // ...
}
        

Property Resolution Example:

# application.properties in jar
app.name=BaseApp
app.description=The baseline application

# application-dev.properties in jar
app.name=DevApp

# Command line when starting application
java -jar app.jar --app.name=CommandLineApp
        

In this example, app.name resolves to "CommandLineApp" due to precedence order.

@RequestMapping(
    path = "/api/resources",              // URL path
    method = RequestMethod.GET,           // HTTP method
    params = "version=1",                 // Required request parameters
    headers = "Content-Type=text/plain",  // Required headers
    consumes = "application/json",        // Consumable media types
    produces = "application/json"         // Producible media types
)
        

Comprehensive Controller Example:

@RestController
@RequestMapping(path = "/api/products", produces = MediaType.APPLICATION_JSON_VALUE)
public class ProductController {

    private final ProductService productService;

    @Autowired
    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    // The full path will be /api/products
    // Inherits produces = "application/json" from class-level annotation
    @GetMapping
    public ResponseEntity<List<Product>> getAllProducts(
            @RequestParam(required = false) String category,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        
        List<Product> products = productService.findProducts(category, page, size);
        return ResponseEntity.ok(products);
    }

    // Path: /api/products/{id}
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(
            @PathVariable("id") Long productId,
            @RequestHeader(value = "X-API-VERSION", required = false) String apiVersion) {
        
        Product product = productService.findById(productId)
            .orElseThrow(() -> new ResourceNotFoundException("Product not found"));
            
        return ResponseEntity.ok(product);
    }

    // Path: /api/products
    // Consumes only application/json
    @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Product> createProduct(
            @Valid @RequestBody ProductDto productDto) {
        
        Product created = productService.create(productDto);
        URI location = ServletUriComponentsBuilder
            .fromCurrentRequest()
            .path("/{id}")
            .buildAndExpand(created.getId())
            .toUri();
            
        return ResponseEntity.created(location).body(created);
    }
}
        

DevTools Configuration Properties:

# Disable DevTools restart capability
spring.devtools.restart.enabled=false

# Exclude specific paths from triggering restarts
spring.devtools.restart.exclude=static/**,public/**

# Configure additional paths to watch for changes
spring.devtools.restart.additional-paths=scripts/**

# Configure LiveReload server port
spring.devtools.livereload.port=35730
        

Remote DevTools Configuration:

// In main application
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        System.setProperty("spring.devtools.restart.enabled", "true");
        System.setProperty("spring.devtools.remote.secret", "my-secret");
        SpringApplication.run(MyApplication.class, args);
    }
}
        

Maven Configuration with Property Filtering:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

<!-- Ensure DevTools resources are included in the final artifact -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludeDevtools>false</excludeDevtools>
            </configuration>
        </plugin>
    </plugins>
</build>
        

# Enable/disable automatic restart
spring.devtools.restart.enabled=true

# Fine-tune the triggering of restarts
spring.devtools.restart.poll-interval=1000
spring.devtools.restart.quiet-period=400

# Exclude paths from triggering restart
spring.devtools.restart.exclude=static/**,public/**,WEB-INF/**

# Include additional paths to trigger restart
spring.devtools.restart.additional-paths=scripts/

# Disable specific file patterns from triggering restart
spring.devtools.restart.additional-exclude=*.log,*.tmp

# Enable/disable LiveReload
spring.devtools.livereload.enabled=true

# Configure LiveReload server port
spring.devtools.livereload.port=35729

# Trigger file to force restart (create this file to trigger restart)
spring.devtools.restart.trigger-file=.reloadtrigger
        

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Programmatically control restart behavior
        System.setProperty("spring.devtools.restart.enabled", "true");
        
        // Set the trigger file programmatically
        System.setProperty("spring.devtools.restart.trigger-file", 
                           "/path/to/custom/trigger/file");
                           
        SpringApplication.run(Application.class, args);
    }
}
        

@Component
public class CustomRestartListener implements ApplicationListener<ApplicationReadyEvent> {
    
    private final RestartScopeInitializer initializer;
    
    @Autowired
    public CustomRestartListener(RestartScopeInitializer initializer) {
        this.initializer = initializer;
    }
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        // Custom initialization after restart
        System.out.println("Application restarted at: " + new Date());
        
        // Execute custom logic after restart
        reinitializeCaches();
    }
    
    private void reinitializeCaches() {
        // Custom business logic to warm up caches after restart
    }
}
        

# Remote DevTools properties (in application.properties of remote app)
spring.devtools.remote.secret=mysecret
spring.devtools.remote.debug.enabled=true
spring.devtools.remote.restart.enabled=true
        

Technical Implementation:

A typical Spring Boot starter consists of two components:

1. The starter module (e.g., spring-boot-starter-web): 
   - Contains primarily dependency declarations
   - May include property defaults
   
2. The autoconfigure module (e.g., spring-boot-autoconfigure): 
   - Contains @Configuration classes
   - Uses @ConditionalOn* annotations to apply configuration conditionally
   - Registers through META-INF/spring.factories
        

Auto-configuration example for the starter-web (simplified):

@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class })
@AutoConfigureAfter(WebMvcAutoConfiguration.class)
public class ErrorMvcAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean(value = ErrorAttributes.class)
    public DefaultErrorAttributes errorAttributes() {
        return new DefaultErrorAttributes();
    }
    
    // Additional bean definitions...
}
        

Technical Implementation - Default vs. Customized Configuration:

// Example: Customizing embedded server port with spring-boot-starter-web
// Default auto-configuration value is 8080

// Option 1: application.properties
server.port=9000

// Option 2: Programmatic configuration
@Bean
public WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> webServerFactoryCustomizer() {
    return factory -> factory.setPort(9000);
}

// Option 3: Completely replacing the auto-configuration
@Configuration
@ConditionalOnWebApplication
public class CustomWebServerConfiguration {
    @Bean
    public ServletWebServerFactory servletWebServerFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        factory.setPort(9000);
        factory.addConnectorCustomizers(connector -> {
            Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
            protocol.setMaxThreads(200);
            protocol.setConnectionTimeout(20000);
        });
        return factory;
    }
}
        

Maven Configuration:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- Choose the appropriate JDBC driver -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- Optional for connection pooling configuration -->
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
    </dependency>
</dependencies>
        

application.yml Example:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: dbuser
    password: dbpass
    driver-class-name: org.postgresql.Driver
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5
      idle-timeout: 30000
      connection-timeout: 30000
      max-lifetime: 1800000
  
  jpa:
    hibernate:
      ddl-auto: validate  # Use validate in production
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        format_sql: true
        jdbc:
          batch_size: 30
        order_inserts: true
        order_updates: true
        query:
          in_clause_parameter_padding: true
    show-sql: false
        

Custom JPA Configuration:

@Configuration
public class JpaConfig {

    @Bean
    public JpaVendorAdapter jpaVendorAdapter() {
        HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
        adapter.setDatabase(Database.POSTGRESQL);
        adapter.setShowSql(false);
        adapter.setGenerateDdl(false);
        adapter.setDatabasePlatform("org.hibernate.dialect.PostgreSQLDialect");
        return adapter;
    }
    
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            DataSource dataSource, 
            JpaVendorAdapter jpaVendorAdapter,
            HibernateProperties hibernateProperties) {
        
        LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
        emf.setDataSource(dataSource);
        emf.setJpaVendorAdapter(jpaVendorAdapter);
        emf.setPackagesToScan("com.example.domain");
        
        Properties jpaProperties = new Properties();
        jpaProperties.putAll(hibernateProperties.determineHibernateProperties(
            new HashMap<>(), new HibernateSettings()));
        // Add custom properties
        jpaProperties.put("hibernate.physical_naming_strategy", 
            "com.example.config.CustomPhysicalNamingStrategy");
            
        emf.setJpaProperties(jpaProperties);
        return emf;
    }
    
    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager txManager = new JpaTransactionManager();
        txManager.setEntityManagerFactory(emf);
        return txManager;
    }
}
        

Entity Class:

@Entity
@Table(name = "products", 
       indexes = {@Index(name = "idx_product_name", columnList = "name")})
public class Product implements Serializable {
    
    private static final long serialVersionUID = 1L;
    
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "product_seq")
    @SequenceGenerator(name = "product_seq", sequenceName = "product_sequence", allocationSize = 50)
    private Long id;
    
    @Column(name = "name", nullable = false, length = 100)
    private String name;
    
    @Column(name = "price", precision = 10, scale = 2)
    private BigDecimal price;
    
    @Version
    private Integer version;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "category_id", foreignKey = @ForeignKey(name = "fk_product_category"))
    private Category category;
    
    @CreatedDate
    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;
    
    // Getters, setters, equals, hashCode implementations
}
        

Advanced Repository:

public interface ProductRepository extends JpaRepository<Product, Long>, 
                                            JpaSpecificationExecutor<Product> {
    
    @Query("SELECT p FROM Product p JOIN FETCH p.category WHERE p.price > :minPrice")
    List<Product> findExpensiveProductsWithCategory(@Param("minPrice") BigDecimal minPrice);
    
    // Projection interface for selected fields
    interface ProductSummary {
        Long getId();
        String getName();
        BigDecimal getPrice();
        
        @Value("#{target.name + ' - $' + target.price}")
        String getDisplayName();
    }
    
    // Using the projection
    List<ProductSummary> findByCategory_NameOrderByPrice(String categoryName, Pageable pageable);
    
    // Async query execution
    @Async
    CompletableFuture<List<Product>> findByNameContaining(String nameFragment);
    
    // Native query with pagination
    @Query(value = "SELECT * FROM products p WHERE p.price BETWEEN :min AND :max",
           countQuery = "SELECT COUNT(*) FROM products p WHERE p.price BETWEEN :min AND :max",
           nativeQuery = true)
    Page<Product> findProductsInPriceRange(@Param("min") BigDecimal min, 
                                        @Param("max") BigDecimal max,
                                        Pageable pageable);
}
        

Service with Transaction Management:

@Service
@Transactional(readOnly = true)  // Default to read-only transactions
public class ProductService {
    
    private final ProductRepository productRepository;
    private final CategoryRepository categoryRepository;
    
    @Autowired
    public ProductService(ProductRepository productRepository, CategoryRepository categoryRepository) {
        this.productRepository = productRepository;
        this.categoryRepository = categoryRepository;
    }
    
    public List<Product> findAllProducts() {
        return productRepository.findAll();
    }
    
    @Transactional  // Override to use read-write transaction
    public Product createProduct(Product product) {
        if (product.getCategory() != null && product.getCategory().getId() != null) {
            // Attach existing category from DB to avoid persistence errors
            Category category = categoryRepository.findById(product.getCategory().getId())
                .orElseThrow(() -> new EntityNotFoundException("Category not found"));
            product.setCategory(category);
        }
        return productRepository.save(product);
    }
    
    @Transactional(timeout = 5)  // Custom timeout in seconds
    public void updatePrices(BigDecimal percentage) {
        productRepository.findAll().forEach(product -> {
            BigDecimal newPrice = product.getPrice()
                .multiply(BigDecimal.ONE.add(percentage.divide(new BigDecimal(100))));
            product.setPrice(newPrice);
            productRepository.save(product);
        });
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW, 
                   rollbackFor = {ConstraintViolationException.class})
    public void deleteProductsInCategory(Long categoryId) {
        productRepository.deleteAllByCategoryId(categoryId);
    }
}
        

Second-level Cache Configuration:

spring:
  jpa:
    properties:
      hibernate:
        cache:
          use_second_level_cache: true
          use_query_cache: true
          region.factory_class: org.hibernate.cache.jcache.JCacheRegionFactory
        javax.cache:
          provider: org.ehcache.jsr107.EhcacheCachingProvider
        

Repository Test:

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@TestPropertySource(properties = {
    "spring.jpa.hibernate.ddl-auto=validate",
    "spring.flyway.enabled=true"
})
class ProductRepositoryTest {

    @Autowired
    private ProductRepository productRepository;
    
    @Autowired
    private EntityManager entityManager;
    
    @Test
    void testFindByNameContaining() {
        // Given
        Product product1 = new Product();
        product1.setName("iPhone 13");
        product1.setPrice(new BigDecimal("999.99"));
        entityManager.persist(product1);
        
        Product product2 = new Product();
        product2.setName("Samsung Galaxy");
        product2.setPrice(new BigDecimal("899.99"));
        entityManager.persist(product2);
        
        entityManager.flush();
        
        // When
        List<Product> foundProducts = productRepository.findByNameContaining("iPhone");
        
        // Then
        assertThat(foundProducts).hasSize(1);
        assertThat(foundProducts.get(0).getName()).isEqualTo("iPhone 13");
    }
}
        

Flyway Configuration:

spring:
  jpa:
    hibernate:
      ddl-auto: validate  # Only validate the schema, don't modify it
  
  flyway:
    enabled: true
    locations: classpath:db/migration
    baseline-on-migrate: true
        

Migration SQL Example (V1__create_schema.sql):

CREATE SEQUENCE IF NOT EXISTS product_sequence START WITH 1 INCREMENT BY 50;

CREATE TABLE IF NOT EXISTS categories (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    created_at TIMESTAMP NOT NULL,
    updated_at TIMESTAMP
);

CREATE TABLE IF NOT EXISTS products (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    price DECIMAL(10,2),
    version INTEGER NOT NULL DEFAULT 0,
    category_id BIGINT,
    created_at TIMESTAMP NOT NULL,
    updated_at TIMESTAMP,
    CONSTRAINT fk_product_category FOREIGN KEY (category_id) REFERENCES categories(id)
);

CREATE INDEX idx_product_name ON products(name);
CREATE INDEX idx_product_category ON products(category_id);
        

┌─────────────────────────┐       ┌──────────────────────┐
│ Repository Interface    │       │ Query Lookup Strategy │
│ (Developer-defined)     │◄──────┤ - CREATE              │
└───────────┬─────────────┘       │ - USE_DECLARED_QUERY  │
            │                     │ - CREATE_IF_NOT_FOUND │
            │                     └──────────────────────┘
            ▼                                 ▲
┌───────────────────────────┐                │
│ JpaRepositoryFactoryBean  │                │
└───────────┬───────────────┘                │
            │                                 │
            ▼                                 │
┌───────────────────────────┐                │
│ Repository Implementation │────────────────┘
│ (Runtime Proxy)           │
└───────────┬───────────────┘
            │
            ▼
┌───────────────────────────┐
│ SimpleJpaRepository       │
│ (Default Implementation)  │
└───────────────────────────┘
        

Repository (marker interface)
    ↑
CrudRepository
    ↑
PagingAndSortingRepository
    ↑
JpaRepository

Method Name Query Creation:

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    // Subject + Predicate pattern
    List<Employee> findByDepartmentNameAndSalaryGreaterThan(String deptName, BigDecimal minSalary);
    
    // Parsed as: FROM Employee e WHERE e.department.name = ?1 AND e.salary > ?2
}
        

Named Queries:

@Entity
@NamedQueries({
    @NamedQuery(
        name = "Employee.findByDepartmentWithBonus",
        query = "SELECT e FROM Employee e WHERE e.department.name = :deptName " +
               "AND e.salary + e.bonus > :threshold"
    )
})
public class Employee { /* ... */ }

// In repository interface
List<Employee> findByDepartmentWithBonus(@Param("deptName") String deptName, 
                                       @Param("threshold") BigDecimal threshold);
        

Query Annotation with Native SQL:

@Query(value = "SELECT e.* FROM employees e " +
               "JOIN departments d ON e.department_id = d.id " +
               "WHERE d.name = ?1 AND " +
               "EXTRACT(YEAR FROM AGE(CURRENT_DATE, e.birth_date)) > ?2",
       nativeQuery = true)
List<Employee> findSeniorEmployeesInDepartment(String departmentName, int minAge);
        

Dynamic Queries with Specifications:

public interface EmployeeRepository extends JpaRepository<Employee, Long>, 
                                        JpaSpecificationExecutor<Employee> { }

// In service class
public List<Employee> findEmployeesByFilters(String namePattern, 
                                           String departmentName, 
                                           BigDecimal minSalary) {
    return employeeRepository.findAll(Specification
        .where(nameContains(namePattern))
        .and(inDepartment(departmentName))
        .and(salaryAtLeast(minSalary)));
}

// Specification methods
private Specification<Employee> nameContains(String pattern) {
    return (root, query, cb) -> 
        pattern == null ? cb.conjunction() : 
                        cb.like(root.get("name"), "%" + pattern + "%");
}

private Specification<Employee> inDepartment(String departmentName) {
    return (root, query, cb) -> 
        departmentName == null ? cb.conjunction() : 
                              cb.equal(root.get("department").get("name"), departmentName);
}

private Specification<Employee> salaryAtLeast(BigDecimal minSalary) {
    return (root, query, cb) -> 
        minSalary == null ? cb.conjunction() : 
                          cb.greaterThanOrEqualTo(root.get("salary"), minSalary);
}
        

1. Entity Graphs for Fetching Strategies:

@Entity
@NamedEntityGraph(
    name = "Employee.withDepartmentAndProjects",
    attributeNodes = {
        @NamedAttributeNode("department"),
        @NamedAttributeNode("projects")
    }
)
public class Employee { /* ... */ }

// In repository
@EntityGraph(value = "Employee.withDepartmentAndProjects")
List<Employee> findByDepartmentName(String deptName);

// Dynamic entity graph
@EntityGraph(attributePaths = {"department", "projects"})
Employee findById(Long id);
        

2. Query Projection for DTO Mapping:

public interface EmployeeProjection {
    Long getId();
    String getName();
    String getDepartmentName();
    
    // Computed attribute using SpEL
    @Value("#{target.department.name + ' - ' + target.position}")
    String getDisplayTitle();
}

// In repository
@Query("SELECT e FROM Employee e JOIN FETCH e.department WHERE e.salary > :minSalary")
List<EmployeeProjection> findEmployeeProjectionsBySalaryGreaterThan(@Param("minSalary") BigDecimal minSalary);
        

3. Customizing Repository Implementation:

// Custom fragment interface
public interface EmployeeRepositoryCustom {
    List<Employee> findBySalaryRange(BigDecimal min, BigDecimal max, int limit);
    void updateEmployeeStatuses(List<Long> ids, EmployeeStatus status);
}

// Implementation
public class EmployeeRepositoryImpl implements EmployeeRepositoryCustom {
    @PersistenceContext
    private EntityManager entityManager;
    
    @Override
    public List<Employee> findBySalaryRange(BigDecimal min, BigDecimal max, int limit) {
        return entityManager.createQuery(
                "SELECT e FROM Employee e WHERE e.salary BETWEEN :min AND :max", 
                Employee.class)
            .setParameter("min", min)
            .setParameter("max", max)
            .setMaxResults(limit)
            .getResultList();
    }
    
    @Override
    @Transactional
    public void updateEmployeeStatuses(List<Long> ids, EmployeeStatus status) {
        entityManager.createQuery(
                "UPDATE Employee e SET e.status = :status WHERE e.id IN :ids")
            .setParameter("status", status)
            .setParameter("ids", ids)
            .executeUpdate();
    }
}

// Combined repository interface
public interface EmployeeRepository extends JpaRepository<Employee, Long>, 
                                         EmployeeRepositoryCustom {
    // Standard and custom methods are now available
}
        

Automatic Auditing:

@Configuration
@EnableJpaAuditing
public class AuditConfig {
    @Bean
    public AuditorAware<String> auditorProvider() {
        return () -> Optional.ofNullable(SecurityContextHolder.getContext())
            .map(SecurityContext::getAuthentication)
            .filter(Authentication::isAuthenticated)
            .map(Authentication::getName);
    }
}

@Entity
@EntityListeners(AuditingEntityListener.class)
public class Employee {
    // Other fields...
    
    @CreatedDate
    @Column(nullable = false, updatable = false)
    private Instant createdDate;
    
    @LastModifiedDate
    @Column(nullable = false)
    private Instant lastModifiedDate;
    
    @CreatedBy
    @Column(nullable = false, updatable = false)
    private String createdBy;
    
    @LastModifiedBy
    @Column(nullable = false)
    private String lastModifiedBy;
}
        

Authentication Flow:

1. Client sends Base64-encoded credentials in the Authorization header
2. BasicAuthenticationFilter extracts and validates credentials
3. Authentication object is stored in SecurityContextHolder
4. SecurityContext is cleared after request completes (in STATELESS mode)

Security Filter Chain

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()))
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasAuthority("ADMIN")
                .requestMatchers(HttpMethod.GET, "/api/user/**").hasAnyAuthority("USER", "ADMIN")
                .requestMatchers(HttpMethod.POST, "/api/user/**").hasAuthority("ADMIN")
                .anyRequest().authenticated()
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)
                .invalidSessionUrl("/invalid-session")
                .maximumSessions(1)
                .maxSessionsPreventsLogin(false)
            )
            .exceptionHandling(exceptions -> exceptions
                .accessDeniedHandler(customAccessDeniedHandler())
                .authenticationEntryPoint(customAuthEntryPoint())
            )
            .formLogin(form -> form
                .loginPage("/login")
                .loginProcessingUrl("/perform-login")
                .defaultSuccessUrl("/dashboard")
                .failureUrl("/login?error=true")
                .successHandler(customAuthSuccessHandler())
                .failureHandler(customAuthFailureHandler())
            )
            .logout(logout -> logout
                .logoutUrl("/perform-logout")
                .logoutSuccessUrl("/login?logout=true")
                .deleteCookies("JSESSIONID")
                .clearAuthentication(true)
                .invalidateHttpSession(true)
            )
            .rememberMe(remember -> remember
                .tokenRepository(persistentTokenRepository())
                .tokenValiditySeconds(86400)
            );
        
        return http.build();
    }
}
        

@Entity
public class Product {
    @Id @GeneratedValue
    private Long id;
    
    @NotBlank(message = "{product.name.required}")
    @Size(min = 2, max = 100, message = "{product.name.size}")
    private String name;
    
    @Min(value = 0, message = "{product.price.positive}")
    @Digits(integer = 6, fraction = 2, message = "{product.price.digits}")
    private BigDecimal price;
    
    @NotNull
    @Valid  // For cascade validation
    private ProductCategory category;
    
    // Custom validation
    @ProductSKUConstraint(message = "{product.sku.invalid}")
    private String sku;
    
    // getters and setters
}
        

// Define validation groups
public interface OnCreate {}
public interface OnUpdate {}

public class User {
    @Null(groups = OnCreate.class)
    @NotNull(groups = OnUpdate.class)
    private Long id;
    
    @NotBlank(groups = {OnCreate.class, OnUpdate.class})
    private String name;
    
    // Other fields
}

@PostMapping("/users")
public ResponseEntity<?> createUser(@Validated(OnCreate.class) @RequestBody User user,
                                   BindingResult result) {
    // Implementation
}

@PutMapping("/users/{id}")
public ResponseEntity<?> updateUser(@Validated(OnUpdate.class) @RequestBody User user,
                                   BindingResult result) {
    // Implementation
}
        

@Service
public class ProductService {
    @Autowired
    private Validator validator;
    
    public void processProduct(Product product) {
        Set<ConstraintViolation<Product>> violations = validator.validate(product);
        
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
        
        // Continue with business logic
    }
    
    // Or more granular validation
    public void checkProductPrice(Product product) {
        validator.validateProperty(product, "price");
    }
}
        

A. Custom Constraint Annotation:

// Step 1: Define annotation
@Documented
@Constraint(validatedBy = ProductSKUValidator.class)
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ProductSKUConstraint {
    String message() default "Invalid SKU format";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

// Step 2: Implement validator
public class ProductSKUValidator implements ConstraintValidator<ProductSKUConstraint, String> {
    @Override
    public void initialize(ProductSKUConstraint constraintAnnotation) {
        // Initialization logic if needed
    }

    @Override
    public boolean isValid(String sku, ConstraintValidatorContext context) {
        if (sku == null) {
            return true; // Use @NotNull for null validation
        }
        // Custom validation logic
        return sku.matches("^[A-Z]{2}-\\d{4}-[A-Z]{2}$");
    }
}
        

B. Spring Validator Interface:

@Component
public class ProductValidator implements Validator {
    @Override
    public boolean supports(Class<?> clazz) {
        return Product.class.isAssignableFrom(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        Product product = (Product) target;
        
        // Custom complex validation logic
        if (product.getPrice().compareTo(BigDecimal.ZERO) > 0 && 
            product.getDiscountPercent() > 80) {
            errors.rejectValue("discountPercent", "discount.too.high", 
                              "Discount cannot exceed 80% for non-zero price");
        }
        
        // Cross-field validation
        if (product.getEndDate() != null && 
            product.getStartDate().isAfter(product.getEndDate())) {
            errors.rejectValue("endDate", "dates.invalid", 
                              "End date must be after start date");
        }
    }
}

// Using in controller
@Controller
public class ProductController {
    @Autowired
    private ProductValidator productValidator;
    
    @InitBinder
    protected void initBinder(WebDataBinder binder) {
        binder.addValidators(productValidator);
    }
    
    @PostMapping("/products")
    public String addProduct(@ModelAttribute @Validated Product product, 
                             BindingResult result) {
        // Validation handled by framework via @InitBinder
        if (result.hasErrors()) {
            return "product-form";
        }
        // Process valid product
        return "redirect:/products";
    }
}
        

@RestControllerAdvice
public class ValidationExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ValidationErrorResponse> handleValidationExceptions(
            MethodArgumentNotValidException ex) {
        ValidationErrorResponse errors = new ValidationErrorResponse();
        
        ex.getBindingResult().getAllErrors().forEach(error -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.addError(fieldName, errorMessage);
        });
        
        return ResponseEntity.badRequest().body(errors);
    }
    
    @ExceptionHandler(ConstraintViolationException.class)
    public ResponseEntity<ValidationErrorResponse> handleConstraintViolation(
            ConstraintViolationException ex) {
        ValidationErrorResponse errors = new ValidationErrorResponse();
        
        ex.getConstraintViolations().forEach(violation -> {
            String fieldName = violation.getPropertyPath().toString();
            String errorMessage = violation.getMessage();
            errors.addError(fieldName, errorMessage);
        });
        
        return ResponseEntity.badRequest().body(errors);
    }
}

// Well-structured error response
public class ValidationErrorResponse {
    private final Map<String, List<String>> errors = new HashMap<>();
    
    public void addError(String field, String message) {
        errors.computeIfAbsent(field, k -> new ArrayList<>()).add(message);
    }
    
    public Map<String, List<String>> getErrors() {
        return errors;
    }
}
        

Key Components:

• Constraint annotations: Metadata describing validation rules
• ConstraintValidator: Implementations that perform actual validation logic
• ValidatorFactory: Creates Validator instances
• Validator: Main API for performing validation
• ConstraintViolation: Represents a validation failure

@NotNull
@Size(min = 2, max = 30)
@Pattern(regexp = "^[a-zA-Z0-9]+$")
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = {})
public @interface Username {
    String message() default "Invalid username";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

// Usage
public class User {
    @Username
    private String username;
    // other fields
}
        

@PasswordMatches(message = "Password confirmation doesn't match password")
public class RegistrationForm {
    private String password;
    private String confirmPassword;
    // Other fields and methods
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = PasswordMatchesValidator.class)
public @interface PasswordMatches {
    String message() default "Passwords don't match";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class PasswordMatchesValidator implements 
        ConstraintValidator<PasswordMatches, RegistrationForm> {
    
    @Override
    public boolean isValid(RegistrationForm form, ConstraintValidatorContext context) {
        boolean isValid = form.getPassword().equals(form.getConfirmPassword());
        
        if (!isValid) {
            // Customize violation with specific field
            context.disableDefaultConstraintViolation();
            context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate())
                   .addPropertyNode("confirmPassword")
                   .addConstraintViolation();
        }
        
        return isValid;
    }
}
        

// Define validation groups
public interface CreateValidationGroup {}
public interface UpdateValidationGroup {}

public class Product {
    @Null(groups = CreateValidationGroup.class, 
         message = "ID must be null for new products")
    @NotNull(groups = UpdateValidationGroup.class, 
            message = "ID is required for updates")
    private Long id;
    
    @NotBlank(groups = {CreateValidationGroup.class, UpdateValidationGroup.class},
             message = "Name is required")
    private String name;
    
    @PositiveOrZero(groups = {CreateValidationGroup.class, UpdateValidationGroup.class},
                   message = "Price must be non-negative")
    private BigDecimal price;
    
    // Other fields and methods
}

// Controller usage
@RestController
@RequestMapping("/products")
public class ProductController {
    
    @PostMapping
    public ResponseEntity<?> createProduct(
            @Validated(CreateValidationGroup.class) @RequestBody Product product,
            BindingResult result) {
        // Implementation
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<?> updateProduct(
            @PathVariable Long id,
            @Validated(UpdateValidationGroup.class) @RequestBody Product product,
            BindingResult result) {
        // Implementation
    }
}
        

public interface BasicChecks {}
public interface AdvancedChecks {}

@GroupSequence({BasicChecks.class, AdvancedChecks.class, CompleteValidation.class})
public interface CompleteValidation {}

public class Order {
    @NotNull(groups = BasicChecks.class)
    @Valid
    private Customer customer;
    
    @NotEmpty(groups = BasicChecks.class)
    private List<OrderItem> items;
    
    @AssertTrue(groups = AdvancedChecks.class, 
               message = "Order total must match sum of items")
    public boolean isTotalValid() {
        // Validation logic
    }
}
        

# ValidationMessages.properties
user.email.invalid=The email '${validatedValue}' is not valid
user.age.range=Age must be between {min} and {max} (was: ${validatedValue})
        

@Email(message = "{user.email.invalid}")
private String email;

@Min(value = 18, message = "{user.age.range}", payload = {Priority.High.class})
@Max(value = 150, message = "{user.age.range}")
private int age;
        

@Service
@Validated
public class UserService {
    
    public User createUser(
            @NotBlank String username,
            @Email String email,
            @Size(min = 8) String password) {
        // Implementation
    }
    
    @NotNull
    public User findUser(@Min(1) Long id) {
        // Implementation
    }
    
    // Cross-parameter constraint
    @ConsistentDateParameters
    public List<Transaction> getTransactions(Date startDate, Date endDate) {
        // Implementation
    }
    
    // Return value validation
    @Size(min = 1)
    public List<User> findAllActiveUsers() {
        // Implementation
    }
}
        

Controller Layer:

// Web MVC Form Validation
@Controller
public class RegistrationController {
    
    @GetMapping("/register")
    public String showForm(Model model) {
        model.addAttribute("user", new User());
        return "registration";
    }
    
    @PostMapping("/register")
    public String processForm(@Valid @ModelAttribute("user") User user,
                             BindingResult result) {
        if (result.hasErrors()) {
            return "registration";
        }
        // Process registration
        return "redirect:/success";
    }
}

// REST API Validation
@RestController
public class UserApiController {
    
    @PostMapping("/api/users")
    public ResponseEntity<?> createUser(@Valid @RequestBody User user,
                                       BindingResult result) {
        if (result.hasErrors()) {
            // Transform errors into API response
            return ResponseEntity.badRequest()
                   .body(result.getAllErrors().stream()
                         .map(e -> e.getDefaultMessage())
                         .collect(Collectors.toList()));
        }
        // Process user
        return ResponseEntity.ok(userService.save(user));
    }
}
        

Service Layer:

@Service
@Validated
public class ProductServiceImpl implements ProductService {
    
    @Override
    public Product createProduct(@Valid Product product) {
        // The @Valid cascades validation to the product object
        return productRepository.save(product);
    }
    
    @Override
    public List<Product> findByPriceRange(
            @DecimalMin("0.0") BigDecimal min,
            @DecimalMin("0.0") @DecimalMax("100000.0") BigDecimal max) {
        // Parameters are validated
        return productRepository.findByPriceBetween(min, max);
    }
}
        

Repository Layer:

@Repository
@Validated
public interface UserRepository extends JpaRepository<User, Long> {
    
    // Parameter validation in repository methods
    User findByUsername(@NotBlank String username);
    
    // Validate query parameters
    @Query("select u from User u where u.age between :minAge and :maxAge")
    List<User> findByAgeRange(
        @Min(0) @Param("minAge") int minAge, 
        @Max(150) @Param("maxAge") int maxAge);
}
        

Programmatic Validation:

@Service
public class ValidationService {
    
    @Autowired
    private jakarta.validation.Validator validator;
    
    public <T> void validate(T object, Class<?>... groups) {
        Set<ConstraintViolation<T>> violations = validator.validate(object, groups);
        
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
    }
    
    public <T> void validateProperty(T object, String propertyName, Class<?>... groups) {
        Set<ConstraintViolation<T>> violations = 
            validator.validateProperty(object, propertyName, groups);
        
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
    }
    
    public <T> void validateValue(Class<T> beanType, String propertyName, 
                                Object value, Class<?>... groups) {
        Set<ConstraintViolation<T>> violations = 
            validator.validateValue(beanType, propertyName, value, groups);
        
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
    }
}
        

Dynamic Validation with SpEL:

@ScriptAssert(lang = "javascript", 
             script = "_this.startDate.before(_this.endDate)", 
             message = "End date must be after start date")
public class DateRange {
    private Date startDate;
    private Date endDate;
    // Getters and setters
}
        

Conditional Validation:

public class ConditionalValidator implements ConstraintValidator<ValidateIf, Object> {
    
    private String condition;
    private String field;
    private Class<? extends Annotation> constraint;
    
    @Override
    public void initialize(ValidateIf constraintAnnotation) {
        this.condition = constraintAnnotation.condition();
        this.field = constraintAnnotation.field();
        this.constraint = constraintAnnotation.constraint();
    }
    
    @Override
    public boolean isValid(Object object, ConstraintValidatorContext context) {
        // Evaluate condition using SpEL
        ExpressionParser parser = new SpelExpressionParser();
        Expression exp = parser.parseExpression(condition);
        boolean shouldValidate = (Boolean) exp.getValue(object);
        
        if (!shouldValidate) {
            return true; // Skip validation
        }
        
        // Get field value and apply constraint
        // This would require reflection or other mechanisms
        // ...
        
        return false; // Invalid
    }
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = ConditionalValidator.class)
public @interface ValidateIf {
    String message() default "Conditional validation failed";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    
    String condition();
    String field();
    Class<? extends Annotation> constraint();
}
        

Comprehensive Implementation:

// 1. Custom exception types
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String resourceId) {
        super("Resource not found with id: " + resourceId);
    }
}

public class ValidationException extends RuntimeException {
    private final Map<String, String> errors;
    
    public ValidationException(Map<String, String> errors) {
        super("Validation failed");
        this.errors = errors;
    }
    
    public Map<String, String> getErrors() {
        return errors;
    }
}

// 2. Error response model
@Data
@Builder
public class ErrorResponse {
    private LocalDateTime timestamp;
    private int status;
    private String error;
    private String message;
    private String path;
    private Map<String, String> validationErrors;
    
    public static ErrorResponse of(HttpStatus status, String message, String path) {
        return ErrorResponse.builder()
                .timestamp(LocalDateTime.now())
                .status(status.value())
                .error(status.getReasonPhrase())
                .message(message)
                .path(path)
                .build();
    }
}

// 3. Global exception handler
@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
    
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleResourceNotFoundException(
            ResourceNotFoundException ex, 
            WebRequest request) {
        
        ErrorResponse errorResponse = ErrorResponse.of(
                HttpStatus.NOT_FOUND, 
                ex.getMessage(), 
                ((ServletWebRequest) request).getRequest().getRequestURI()
        );
        
        return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
    }
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(
            ValidationException ex, 
            WebRequest request) {
        
        ErrorResponse errorResponse = ErrorResponse.of(
                HttpStatus.BAD_REQUEST,
                "Validation failed",
                ((ServletWebRequest) request).getRequest().getRequestURI()
        );
        errorResponse.setValidationErrors(ex.getErrors());
        
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }
    
    @Override
    protected ResponseEntity<Object> handleMethodArgumentNotValid(
            MethodArgumentNotValidException ex,
            HttpHeaders headers, 
            HttpStatusCode status, 
            WebRequest request) {
        
        Map<String, String> errors = ex.getBindingResult()
                .getFieldErrors()
                .stream()
                .collect(Collectors.toMap(
                        FieldError::getField,
                        FieldError::getDefaultMessage,
                        (existing, replacement) -> existing + "; " + replacement
                ));
        
        ErrorResponse errorResponse = ErrorResponse.of(
                HttpStatus.BAD_REQUEST,
                "Validation failed",
                ((ServletWebRequest) request).getRequest().getRequestURI()
        );
        errorResponse.setValidationErrors(errors);
        
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(
            Exception ex, 
            WebRequest request) {
        
        ErrorResponse errorResponse = ErrorResponse.of(
                HttpStatus.INTERNAL_SERVER_ERROR,
                "An unexpected error occurred",
                ((ServletWebRequest) request).getRequest().getRequestURI()
        );
        
        // Log the full exception details here but return a generic message
        log.error("Unhandled exception", ex);
        
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}
        

@ControllerAdvice Filtering Options:

// Applies to all controllers
@ControllerAdvice
public class GlobalControllerAdvice { /* ... */ }

// Applies to specific packages
@ControllerAdvice("org.example.controllers")
public class PackageSpecificAdvice { /* ... */ }

// Applies to specific controller classes
@ControllerAdvice(assignableTypes = {UserController.class, ProductController.class})
public class SpecificControllersAdvice { /* ... */ }

// Applies to controllers with specific annotations
@ControllerAdvice(annotations = RestController.class)
public class RestControllerAdvice { /* ... */ }
        

Advanced @ExceptionHandler Implementation:

@RestControllerAdvice
public class ComprehensiveExceptionHandler extends ResponseEntityExceptionHandler {

    // Handle custom business exception
    @ExceptionHandler(BusinessRuleViolationException.class)
    public ResponseEntity<ProblemDetail> handleBusinessRuleViolation(
            BusinessRuleViolationException ex, 
            WebRequest request) {
        
        ProblemDetail problemDetail = ProblemDetail.forStatusAndDetail(
                HttpStatus.CONFLICT, 
                ex.getMessage());
        
        problemDetail.setTitle("Business Rule Violation");
        problemDetail.setProperty("timestamp", Instant.now());
        problemDetail.setProperty("errorCode", ex.getErrorCode());
        
        return ResponseEntity.status(HttpStatus.CONFLICT)
                .contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .body(problemDetail);
    }
    
    // Handle multiple related exceptions with one handler
    @ExceptionHandler({
        ResourceNotFoundException.class,
        EntityNotFoundException.class
    })
    public ResponseEntity<ProblemDetail> handleNotFoundExceptions(
            Exception ex, 
            WebRequest request) {
        
        ProblemDetail problemDetail = ProblemDetail.forStatus(HttpStatus.NOT_FOUND);
        problemDetail.setTitle("Resource Not Found");
        problemDetail.setDetail(ex.getMessage());
        problemDetail.setProperty("timestamp", Instant.now());
        
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .body(problemDetail);
    }
    
    // Customize handling of Spring's built-in exceptions by overriding methods from ResponseEntityExceptionHandler
    @Override
    protected ResponseEntity<Object> handleMethodArgumentNotValid(
            MethodArgumentNotValidException ex, 
            HttpHeaders headers,
            HttpStatusCode status, 
            WebRequest request) {
        
        Map<String, List<String>> validationErrors = ex.getBindingResult()
                .getFieldErrors()
                .stream()
                .collect(Collectors.groupingBy(
                        FieldError::getField,
                        Collectors.mapping(FieldError::getDefaultMessage, Collectors.toList())
                ));
        
        ProblemDetail problemDetail = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        problemDetail.setTitle("Validation Failed");
        problemDetail.setDetail("The request contains invalid parameters");
        problemDetail.setProperty("timestamp", Instant.now());
        problemDetail.setProperty("validationErrors", validationErrors);
        
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                .contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .body(problemDetail);
    }
}
        

Modern Unit Test With JUnit 5:

@ExtendWith(MockitoExtension.class)
class ProductServiceTest {
    
    @Mock
    private ProductRepository productRepository;
    
    @Mock
    private PricingService pricingService;
    
    @InjectMocks
    private ProductService productService;
    
    @Test
    void shouldApplyDiscountToEligibleProducts() {
        // Arrange
        Product product = new Product(1L, "Laptop", 1000.0);
        when(productRepository.findById(1L)).thenReturn(Optional.of(product));
        when(pricingService.calculateDiscount(product)).thenReturn(100.0);
        
        // Act
        ProductDTO result = productService.getProductWithDiscount(1L);
        
        // Assert
        assertEquals(900.0, result.getFinalPrice());
        verify(pricingService).calculateDiscount(product);
        verify(productRepository).findById(1L);
    }
    
    @Test
    void shouldThrowExceptionWhenProductNotFound() {
        // Arrange
        when(productRepository.findById(anyLong())).thenReturn(Optional.empty());
        
        // Act & Assert
        assertThrows(ProductNotFoundException.class, 
                     () -> productService.getProductWithDiscount(1L));
    }
}
        

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@TestPropertySource(properties = {
    "spring.datasource.url=jdbc:h2:mem:testdb",
    "spring.jpa.hibernate.ddl-auto=create-drop"
})
class OrderServiceIntegrationTest {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void shouldCreateOrderAndUpdateInventory() {
        // Arrange
        OrderRequest request = new OrderRequest(List.of(
            new OrderItemRequest(1L, 2)
        ));
        
        // Act
        ResponseEntity<OrderResponse> response = restTemplate.postForEntity(
            "/api/orders", request, OrderResponse.class);
        
        // Assert
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        
        OrderResponse orderResponse = response.getBody();
        assertNotNull(orderResponse);
        assertNotNull(orderResponse.getOrderId());
        
        // Verify the order was persisted
        Optional<Order> savedOrder = orderRepository.findById(orderResponse.getOrderId());
        assertTrue(savedOrder.isPresent());
        assertEquals(2, savedOrder.get().getItems().size());
    }
}
        

@WebMvcTest(ProductController.class)
class ProductControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private ProductService productService;
    
    @Test
    void shouldReturnProductWhenProductExists() throws Exception {
        // Arrange
        ProductDTO product = new ProductDTO(1L, "Laptop", 999.99, 899.99);
        when(productService.getProductWithDiscount(1L)).thenReturn(product);
        
        // Act & Assert
        mockMvc.perform(get("/api/products/1")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.name").value("Laptop"))
                .andExpect(jsonPath("$.finalPrice").value(899.99));
        
        verify(productService).getProductWithDiscount(1L);
    }
    
    @Test
    void shouldReturn404WhenProductNotFound() throws Exception {
        // Arrange
        when(productService.getProductWithDiscount(anyLong()))
            .thenThrow(new ProductNotFoundException("Product not found"));
        
        // Act & Assert
        mockMvc.perform(get("/api/products/999")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value("Product not found"));
    }
}
        

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@TestPropertySource(properties = {
    "spring.jpa.hibernate.ddl-auto=create-drop",
    "spring.datasource.url=jdbc:tc:postgresql:13:///testdb"
})
class ProductRepositoryTest {
    
    @Autowired
    private ProductRepository productRepository;
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Test
    void shouldFindProductsByCategory() {
        // Arrange
        Category electronics = new Category("Electronics");
        entityManager.persist(electronics);
        
        Product laptop = new Product("Laptop", 1000.0, electronics);
        Product phone = new Product("Phone", 500.0, electronics);
        entityManager.persist(laptop);
        entityManager.persist(phone);
        
        Category furniture = new Category("Furniture");
        entityManager.persist(furniture);
        
        Product chair = new Product("Chair", 100.0, furniture);
        entityManager.persist(chair);
        
        entityManager.flush();
        
        // Act
        List<Product> electronicsProducts = productRepository.findByCategory(electronics);
        
        // Assert
        assertEquals(2, electronicsProducts.size());
        assertTrue(electronicsProducts.stream()
            .map(Product::getName)
            .collect(Collectors.toList())
            .containsAll(Arrays.asList("Laptop", "Phone")));
    }
}
        

@SpringBootTest
@Testcontainers
class UserServiceWithPostgresTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");
    
    @DynamicPropertySource
    static void postgresProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }
    
    @Autowired
    private UserService userService;
    
    @Test
    void shouldPersistUserInRealDatabase() {
        // Test with real PostgreSQL instance
    }
}
        

public class UserTestFactory {
    public static User createValidUser() {
        return User.builder()
            .id(1L)
            .username("testuser")
            .email("test@example.com")
            .password("password")
            .roles(Set.of(Role.USER))
            .build();
    }
    
    public static List<User> createUsersList(int count) {
        return IntStream.range(0, count)
            .mapToObj(i -> User.builder()
                .id((long) i)
                .username("user" + i)
                .email("user" + i + "@example.com")
                .password("password")
                .roles(Set.of(Role.USER))
                .build())
            .collect(Collectors.toList());
    }
}
        

Advanced @SpringBootTest Configuration:

@SpringBootTest(
    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
    properties = {
        "spring.datasource.url=jdbc:h2:mem:testdb",
        "spring.jpa.hibernate.ddl-auto=create-drop",
        "spring.security.user.name=testuser",
        "spring.security.user.password=password"
    },
    classes = {
        TestConfig.class,
        SecurityConfig.class,
        PersistenceConfig.class
    }
)
@ActiveProfiles("test")
class ComplexIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;
    
    @Autowired
    private UserRepository userRepository;
    
    @MockBean
    private ExternalPaymentService paymentService;
    
    @Test
    void shouldProcessOrderEndToEnd() {
        // Mock external service
        when(paymentService.processPayment(any(PaymentRequest.class)))
            .thenReturn(new PaymentResponse("TX123", PaymentStatus.APPROVED));
        
        // Create test data
        User testUser = new User("customer1", "password", "customer@example.com");
        userRepository.save(testUser);
        
        // Prepare authentication
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Basic " + 
            Base64.getEncoder().encodeToString("testuser:password".getBytes()));
        
        // Create request
        OrderRequest orderRequest = new OrderRequest(
            List.of(new OrderItem("product1", 2), new OrderItem("product2", 1)),
            new Address("123 Test St", "Test City", "12345")
        );
        
        // Execute test
        ResponseEntity response = restTemplate.exchange(
            "/api/orders",
            HttpMethod.POST,
            new HttpEntity<>(orderRequest, headers),
            OrderResponse.class
        );
        
        // Verify response
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        assertNotNull(response.getBody().getOrderId());
        assertEquals("TX123", response.getBody().getTransactionId());
        
        // Verify database state
        Order savedOrder = orderRepository.findById(response.getBody().getOrderId()).orElse(null);
        assertNotNull(savedOrder);
        assertEquals(OrderStatus.CONFIRMED, savedOrder.getStatus());
    }
}
        

Advanced MockMvc Configuration and Usage:

@WebMvcTest(ProductController.class)
class ProductControllerTest {

    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private ProductService productService;
    
    @MockBean
    private SecurityService securityService;
    
    @Test
    void shouldReturnProductsWithPagination() throws Exception {
        // Setup mock service
        List<ProductDTO> products = IntStream.range(0, 20)
            .mapToObj(i -> new ProductDTO(
                (long) i, 
                "Product " + i, 
                BigDecimal.valueOf(10 + i), 
                "Description " + i))
            .collect(Collectors.toList());
        
        Page<ProductDTO> productPage = new PageImpl<>(
            products.subList(5, 15), 
            PageRequest.of(1, 10, Sort.by("price").descending()), 
            products.size()
        );
        
        when(productService.getProducts(any(Pageable.class))).thenReturn(productPage);
        when(securityService.isAuthenticated()).thenReturn(true);
        
        // Execute test with complex request
        mockMvc.perform(get("/api/products")
                .param("page", "1")
                .param("size", "10")
                .param("sort", "price,desc")
                .header("X-API-KEY", "test-api-key")
                .accept(MediaType.APPLICATION_JSON))
                
                // Verify response details
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.content", hasSize(10)))
                .andExpect(jsonPath("$.number").value(1))
                .andExpect(jsonPath("$.size").value(10))
                .andExpect(jsonPath("$.totalElements").value(20))
                .andExpect(jsonPath("$.totalPages").value(2))
                .andExpect(jsonPath("$.content[0].name").value("Product 14"))
                
                // Log request/response for debugging
                .andDo(print())
                
                // Extract and further verify response
                .andDo(result -> {
                    String content = result.getResponse().getContentAsString();
                    assertThat(content).contains("Product");
                    
                    // Parse the response and do additional assertions
                    ObjectMapper mapper = new ObjectMapper();
                    JsonNode rootNode = mapper.readTree(content);
                    JsonNode contentNode = rootNode.get("content");
                    
                    // Verify sorting order
                    double previousPrice = Double.MAX_VALUE;
                    for (JsonNode product : contentNode) {
                        double currentPrice = product.get("price").asDouble();
                        assertTrue(currentPrice <= previousPrice, 
                            "Products not properly sorted by price descending");
                        previousPrice = currentPrice;
                    }
                });
        
        // Verify service interactions
        verify(productService).getProducts(any(Pageable.class));
        verify(securityService).isAuthenticated();
    }
    
    @Test
    void shouldHandleValidationErrors() throws Exception {
        // Test handling of validation errors
        mockMvc.perform(post("/api/products")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"name\":\"\", \"price\":-10}")
                .with(csrf()))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.errors", hasSize(greaterThan(0))))
                .andExpect(jsonPath("$.errors[*].field", hasItems("name", "price")));
    }
    
    @Test
    void shouldHandleSecurityConstraints() throws Exception {
        // Test security constraints
        when(securityService.isAuthenticated()).thenReturn(false);
        
        mockMvc.perform(get("/api/products/admin")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isUnauthorized());
    }
}
        

@SpringBootTest
@AutoConfigureMockMvc
class IntegratedControllerTest {

    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Autowired
    private OrderRepository orderRepository;
    
    @MockBean
    private PaymentGateway paymentGateway;
    
    @BeforeEach
    void setup() {
        // Initialize test data in the database
        orderRepository.deleteAll();
    }
    
    @Test
    void shouldCreateOrderWithFullApplicationContext() throws Exception {
        // Mock external service
        when(paymentGateway.processPayment(any())).thenReturn(
            new PaymentResult("TXN123", true));
        
        // Create test request
        OrderCreateRequest request = new OrderCreateRequest(
            "Customer 1",
            Arrays.asList(
                new OrderItemRequest("Product 1", 2, BigDecimal.valueOf(10.99)),
                new OrderItemRequest("Product 2", 1, BigDecimal.valueOf(24.99))
            ),
            "VISA",
            "4111111111111111"
        );
        
        // Execute request
        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request))
                .with(jwt()))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.orderId").exists())
                .andExpect(jsonPath("$.status").value("CONFIRMED"))
                .andExpect(jsonPath("$.totalAmount").value(46.97))
                .andExpect(jsonPath("$.paymentDetails.transactionId").value("TXN123"));
        
        // Verify database state after the request
        List<Order> orders = orderRepository.findAll();
        assertEquals(1, orders.size());
        
        Order savedOrder = orders.get(0);
        assertEquals(2, savedOrder.getItems().size());
        assertEquals(OrderStatus.CONFIRMED, savedOrder.getStatus());
        assertEquals(BigDecimal.valueOf(46.97), savedOrder.getTotalAmount());
        
        // Verify external service interactions
        verify(paymentGateway).processPayment(any());
    }
}
        

1. Health Indicators

Health endpoints aggregate status from multiple health indicators:

@Component
public class CustomHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        // Logic to determine health
        boolean isHealthy = checkSystemHealth();
        
        if (isHealthy) {
            return Health.up()
                .withDetail("customService", "running")
                .withDetail("metricValue", 42)
                .build();
        }
        return Health.down()
            .withDetail("customService", "not available")
            .withDetail("error", "connection refused")
            .build();
    }
}
        

2. Custom Metrics Integration

Actuator integrates with Micrometer for metrics collection and reporting:

@RestController
public class ExampleController {
    private final Counter requestCounter;
    private final Timer requestLatencyTimer;
    
    public ExampleController(MeterRegistry registry) {
        this.requestCounter = registry.counter("api.requests");
        this.requestLatencyTimer = registry.timer("api.request.latency");
    }
    
    @GetMapping("/api/example")
    public ResponseEntity<String> handleRequest() {
        requestCounter.increment();
        return requestLatencyTimer.record(() -> {
            // Method logic here
            return ResponseEntity.ok("Success");
        });
    }
}
        

Basic Configuration

Configure endpoints through properties:

# Expose specific endpoints
management.endpoints.web.exposure.include=health,info,metrics,prometheus,loggers

# Exclude specific endpoints
management.endpoints.web.exposure.exclude=shutdown,env

# Enable/disable specific endpoints
management.endpoint.health.enabled=true
management.endpoint.shutdown.enabled=false

# Configure base path (default is /actuator)
management.endpoints.web.base-path=/management

# Dedicated management port
management.server.port=8081
management.server.address=127.0.0.1
        

Customizing Existing Endpoints

@Component
public class CustomHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        boolean databaseConnectionValid = checkDatabaseConnection();
        Map<String, Object> details = new HashMap<>();
        details.put("database.connection.valid", databaseConnectionValid);
        details.put("cache.size", getCacheSize());
        
        if (databaseConnectionValid) {
            return Health.up().withDetails(details).build();
        }
        return Health.down().withDetails(details).build();
    }
}
        

Creating Custom Endpoints

@Component
@Endpoint(id = "applicationData")
public class ApplicationDataEndpoint {
    
    private final DataService dataService;
    
    public ApplicationDataEndpoint(DataService dataService) {
        this.dataService = dataService;
    }
    
    @ReadOperation
    public Map<String, Object> getData() {
        return Map.of(
            "records", dataService.getRecordCount(),
            "active", dataService.getActiveRecordCount(),
            "lastUpdated", dataService.getLastUpdateTime()
        );
    }
    
    @WriteOperation
    public Map<String, String> purgeData(@Selector String dataType) {
        dataService.purgeData(dataType);
        return Map.of("status", "Data purged successfully");
    }
}
        

Role-Based Access Control with Spring Security

@Configuration
public class ActuatorSecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.requestMatcher(EndpointRequest.toAnyEndpoint())
            .authorizeRequests()
            .requestMatchers(EndpointRequest.to("health", "info")).permitAll()
            .requestMatchers(EndpointRequest.to("metrics")).hasRole("MONITORING")
            .requestMatchers(EndpointRequest.to("loggers")).hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .httpBasic();
    }
}
        

Fine-grained Health Indicator Exposure

# Expose health details only to authenticated users
management.endpoint.health.show-details=when-authorized

# Control specific health indicators visibility
management.health.db.enabled=true
management.health.diskspace.enabled=true

# Group health indicators
management.endpoint.health.group.readiness.include=db,diskspace
management.endpoint.health.group.liveness.include=ping
        

Prometheus Integration

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
        

Prometheus configuration (prometheus.yml):

scrape_configs:
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:8080']
        

Custom Metrics with Micrometer

@Service
public class OrderService {
    private final Counter orderCounter;
    private final DistributionSummary orderSizeSummary;
    private final Timer processingTimer;
    
    public OrderService(MeterRegistry registry) {
        this.orderCounter = registry.counter("orders.created");
        this.orderSizeSummary = registry.summary("orders.size");
        this.processingTimer = registry.timer("orders.processing.time");
    }
    
    public Order processOrder(Order order) {
        return processingTimer.record(() -> {
            // Processing logic
            orderCounter.increment();
            orderSizeSummary.record(order.getItems().size());
            return saveOrder(order);
        });
    }
}
        

Using WebClient to Interact with Remote Actuator

@Service
public class SystemMonitorService {
    private final WebClient webClient;
    
    public SystemMonitorService() {
        this.webClient = WebClient.builder()
            .baseUrl("http://remote-service:8080/actuator")
            .defaultHeaders(headers -> {
                headers.setBasicAuth("admin", "password");
                headers.setContentType(MediaType.APPLICATION_JSON);
            })
            .build();
    }
    
    public Mono<Map> getHealthStatus() {
        return webClient.get()
            .uri("/health")
            .retrieve()
            .bodyToMono(Map.class);
    }
    
    public Mono<Void> updateLogLevel(String loggerName, String level) {
        return webClient.post()
            .uri("/loggers/{name}", loggerName)
            .bodyValue(Map.of("configuredLevel", level))
            .retrieve()
            .bodyToMono(Void.class);
    }
}
        

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-boot-app
spec:
  template:
    spec:
      containers:
      - name: app
        image: spring-boot-app:latest
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 5
        

With corresponding application configuration:

management.endpoint.health.probes.enabled=true
management.health.livenessstate.enabled=true
management.health.readinessstate.enabled=true