Spring Boot

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.2.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

@RestController
@RequestMapping("/api/v1/orders") // URI Versioning
public class OrderV1Controller {}

@RestController
@RequestMapping("/api/v2/orders") // URI Versioning
public class OrderV2Controller {}

<!-- Spring Session Redis Starter -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

# application.properties
spring.flyway.baseline-on-migrate=true
spring.flyway.baseline-version=1

@SneakyThrows // Avoids declaring 'throws IOException' on method signature
public String readFile(String path) {
    return Files.readString(Path.of(path));
}

<!-- logback-spring.xml -->
<conversionRule conversionWord="maskedMsg" 
                converterClass="com.example.logging.MaskingPatternConverter" />
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %maskedMsg%n</pattern>
    </encoder>
</appender>

// Compensating transaction triggered if payment fails:
public void compensateOrder(Long orderId) {
    orderRepository.updateStatus(orderId, OrderStatus.CANCELLED);
    inventoryService.releaseStock(orderId);
}

@RestController
@RefreshScope // Reloads property dynamically on /actuator/refresh
public class FeatureFlagController {
    @Value("${feature.new-ui:false}")
    private boolean newUiEnabled;
}

@Transactional("primaryTransactionManager")
public void savePrimary(Order order) { primaryRepo.save(order); }

@Transactional("secondaryTransactionManager")
public void saveAudit(AuditLog log) { auditRepo.save(log); }

<!-- Spring Boot Admin Client -->
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>3.2.0</version>
</dependency>

# application-dev.properties
spring.main.lazy-initialization=true

@Component
@Order(1)
public class DatabaseSeeder implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) {
        if (args.containsOption("seed")) {
            System.out.println("Seeding initial admin user data...");
        }
    }
}

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .headers(headers -> headers
            .contentSecurityPolicy(csp -> csp.policyDirectives("default-src 'self'"))
            .frameOptions(HeadersConfigurer.FrameOptionsConfig::deny)
        )
        .build();
}

public class UserDTO {
    @JsonProperty("full_name")
    private String fullName;

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    private String password; // Never serialized in responses

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String middleName;
}

Bandwidth limit = Bandwidth.classic(10, Refill.greedy(10, Duration.ofMinutes(1)));
Bucket bucket = Bucket.builder().addLimit(limit).build();

if (bucket.tryConsume(1)) {
    // Allow request to proceed
} else {
    res.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
}

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

@Bean(name = "taskExecutor")
public Executor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(100);
    executor.setThreadNamePrefix("AsyncWorker-");
    executor.initialize();
    return executor;
}

@Component
public class IdempotencyInterceptor implements HandlerInterceptor {
    @Autowired private StringRedisTemplate redisTemplate;
    @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) {
        String key = req.getHeader("Idempotency-Key");
        if (key != null) {
            Boolean isNew = redisTemplate.opsForValue().setIfAbsent("idemp:" + key, "PENDING", Duration.ofMinutes(5));
            if (Boolean.FALSE.equals(isNew)) throw new DuplicateRequestException("Duplicate request");
        }
        return true;
    }
}

@Bean
public RedisCacheConfiguration cacheConfiguration() {
    return RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(10))
        .disableCachingNullValues()
        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
}

// DTO Record Projection:
public record UserSummaryDTO(Long id, String username, String email) {}

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT new com.example.dto.UserSummaryDTO(u.id, u.username, u.email) FROM User u")
    List<UserSummaryDTO> findAllSummaries();
}

# Recommended production setting:
spring.jpa.open-in-view=false

public interface AccountRepository extends JpaRepository<Account, Long> {
    // Pessimistic row-level lock (SELECT FOR UPDATE):
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT a FROM Account a WHERE a.id = :id")
    Optional<Account> findByIdForUpdate(@Param("id") Long id);
}

@Transactional
public void createUser(User user) {
    userRepository.save(user); // SQL statement deferred until transaction commit
    userRepository.saveAndFlush(user); // Flushes SQL INSERT immediately to DB
}

@Service
public class PaymentService {
    private final Counter orderCounter;
    public PaymentService(MeterRegistry registry) {
        this.orderCounter = registry.counter("orders.completed.total", "type", "credit_card");
    }
    public void processPayment() {
        // Business logic
        orderCounter.increment();
    }
}

@Component
public class PaymentGatewayHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        boolean reachable = checkGatewayConnection();
        if (reachable) {
            return Health.up().withDetail("latency", "25ms").build();
        }
        return Health.down().withDetail("error", "Timeout connecting to gateway").build();
    }
}

@Service
public class OrderEventService {
    @Autowired private KafkaTemplate<String, OrderEvent> kafkaTemplate;

    public void sendOrder(OrderEvent event) {
        kafkaTemplate.send("orders-topic", event.orderId(), event);
    }

    @KafkaListener(topics = "orders-topic", groupId = "billing-group")
    public void consumeOrder(OrderEvent event) {
        System.out.println("Processing billing for order: " + event.orderId());
    }
}

@Service
public class InventoryService {
    @CircuitBreaker(name = "inventoryService", fallbackMethod = "fallbackStock")
    public int checkStock(String productId) {
        return remoteWarehouseClient.getStock(productId); // Remote network call
    }
    public int fallbackStock(String productId, Throwable t) {
        return 0; // Safe default response during service outages
    }
}

@Bean
public SecurityFilterChain filterChain(HttpSecurity http, JwtAuthFilter jwtFilter) throws Exception {
    return http
        .csrf(AbstractHttpConfigurer::disable)
        .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
        .authorizeHttpRequests(a -> a
            .requestMatchers("/api/auth/**").permitAll()
            .anyRequest().authenticated())
        .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
        .build();
}

@Configuration
public class WebCorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins("https://app.example.com")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*")
                .allowCredentials(true);
    }
}

// Modern RestClient (Spring Boot 3.2+):
RestClient restClient = RestClient.create();
User user = restClient.get()
    .uri("https://api.example.com/users/{id}", 1)
    .accept(MediaType.APPLICATION_JSON)
    .retrieve()
    .body(User.class);