7 Essential Spring Boot Concepts Every Senior Developer Should Master

Environment: Spring Boot 3.5.0

1. Resilient Service Capability

Junior developers catch exceptions; senior developers design fault‑tolerance. In microservices, distributed failures are inevitable, so a multi‑layer defense is required.

Dependency for Resilience4j:

<dependency>
  <groupId>io.github.resilience4j</groupId>
  <artifactId>resilience4j-spring-boot3</artifactId>
  <version>2.3.0</version>
</dependency>

Service implementation with annotations:

@Service
public class PaymentService {
  private final PaymentClientAcl paymentClientAcl;

  @CircuitBreaker(name = "paymentAPI", fallbackMethod = "paymentFallback")
  @Retry(name = "paymentAPI")
  @Bulkhead(name = "paymentAPI", type = Bulkhead.Type.THREADPOOL)
  public PaymentResponse processPayment(PaymentRequest request) {
    return paymentClientAcl.payment(request);
  }

  private PaymentResponse paymentFallback(PaymentRequest request, Exception ex) {
    return PaymentResponse.builder()
        .status("PENDING")
        .message("Payment queued for retry")
        .build();
  }
}

Configuration:

resilience4j:
  circuitbreaker:
    instances:
      paymentAPI:
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10s
  retry:
    instances:
      paymentAPI:
        maxAttempts: 3
        waitDuration: 500ms
  bulkhead:
    instances:
      paymentAPI:
        maxConcurrentCalls: 10

Result: graceful degradation instead of cascade failures.

2. Service Monitoring

Spring Boot Actuator provides out‑of‑the‑box health endpoints for observability.

Custom database health indicator:

@Component
public class DatabaseHealthIndicator implements HealthIndicator {
  private final DataSource dataSource;

  public DatabaseHealthIndicator(DataSource dataSource) {
    this.dataSource = dataSource;
  }

  @Override
  public Health health() {
    long startTime = System.currentTimeMillis();
    try (Connection connection = dataSource.getConnection()) {
      boolean valid = connection.isValid(2); // 2‑second timeout
      long responseTime = System.currentTimeMillis() - startTime;
      if (valid) {
        DatabaseMetaData metaData = connection.getMetaData();
        String dbType = metaData.getDatabaseProductName();
        return Health.up()
            .withDetail("database", dbType)
            .withDetail("responseTimeMs", responseTime)
            .build();
      } else {
        return Health.down().withDetail("reason", "Connection is not valid").build();
      }
    } catch (SQLException e) {
      return Health.down().withDetail("error", e.getMessage()).withException(e).build();
    }
  }
}

Business‑level metric example:

@Service
public class OrderService {
  private final MeterRegistry meterRegistry;
  private final Counter orderCounter;

  public OrderService(MeterRegistry meterRegistry) {
    this.meterRegistry = meterRegistry;
    this.orderCounter = Counter.builder("orders.statistics")
        .description("订单统计")
        .tag("type", "premium")
        .register(meterRegistry);
  }

  public void recordOrder(Order order) {
    orderCounter.increment();
    meterRegistry.timer("order.processing.time")
        .record(() -> processOrder(order));
  }

  public void processOrder(Order order) {
    try {
      TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
    } catch (InterruptedException e) {}
  }
}

3. Distributed Transactions

ACID transactions cannot span services. The Saga pattern provides eventual consistency via compensating actions.

Simple Saga workflow example:

public void createOrder(OrderRequest request) {
  Order order = new Order(request);
  order.setStatus(OrderStatus.PENDING);
  orderRepository.save(order); // step 1

  SagaState saga = new SagaState(order.getId(), SagaStep.START);
  sagaRepository.save(saga); // persist state

  try {
    // Step 2: Reserve payment (independent transaction)
    paymentService.reserve(order.getAmount());
    saga.setStep(SagaStep.PAYMENT_RESERVED);
    sagaRepository.save(saga);

    // Step 3: Allocate inventory (independent transaction)
    inventoryService.allocate(order.getItems());
    saga.setStep(SagaStep.INVENTORY_ALLOCATED);
    sagaRepository.save(saga);

    order.setStatus(OrderStatus.CONFIRMED);
    orderRepository.save(order);
  } catch (Exception e) {
    compensate(saga, order);
    throw e;
  }
}

private void compensate(SagaState saga, Order order) {
  if (saga.getStep() == SagaStep.INVENTORY_ALLOCATED) {
    try { inventoryService.deallocate(order.getItems()); } catch (Exception ex) { /* log & retry */ }
  }
  if (saga.getStep().compareTo(SagaStep.PAYMENT_RESERVED) >= 0) {
    try { paymentService.release(order.getId()); } catch (Exception ex) { /* log & retry */ }
  }
  order.setStatus(OrderStatus.CANCELLED);
  orderRepository.save(order);
}

4. Caching Techniques

Illustrates @Cacheable, @CachePut, @CacheEvict, and @Caching for fine‑grained cache control.

@Service
public class ProductService {

  @Cacheable(value = "products", key = "#id", unless = "#result == null")
  public Product getProduct(Long id) {
    return productRepository.findById(id)
        .orElseThrow(() -> new ProductNotFoundException(id));
  }

  @CachePut(value = "products", key = "#product.id")
  public Product updateProduct(Product product) {
    return productRepository.save(product);
  }

  @CacheEvict(value = "products", key = "#id")
  public void deleteProduct(Long id) {
    productRepository.deleteById(id);
  }

  @Caching(evict = {
    @CacheEvict(value = "products", allEntries = true),
    @CacheEvict(value = "productsByCategory", allEntries = true)
  })
  public void clearAllCaches() {
    // triggered on bulk updates
  }
}

5. Asynchronous Processing

Blocking calls reduce throughput; @Async with a custom executor improves concurrency.

@Service
public class NotificationService {

  @Async("taskExecutor")
  public CompletableFuture<Void> sendEmail(String recipient, String message) {
    return CompletableFuture.runAsync(() -> {
      emailClient.send(recipient, message);
    });
  }

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

6. API Gateway

Programmatic route configuration with Spring Cloud Gateway, adding circuit‑breaker and rate‑limiter filters.

@Configuration
public class GatewayConfig {

  @Bean
  public RouteLocator customRoutes(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("orders", r -> r.path("/api/orders/**")
            .filters(f -> f.circuitBreaker(c -> c.setName("ordersCircuitBreaker"))
                .retry(3))
            .uri("lb://order-service"))
        .route("payments", r -> r.path("/api/payments/**")
            .filters(f -> f.requestRateLimiter(config -> config.setRateLimiter(redisRateLimiter())))
            .uri("lb://PAYMENT-SERVICE"))
        .build();
  }
}

7. Security Authentication

OAuth2, JWT, and RBAC configuration using Spring Security.

@Configuration
@EnableWebSecurity
public class SecurityConfig {

  @Bean
  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .csrf().disable()
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/api/public/**").permitAll()
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated())
        .oauth2ResourceServer(oauth2 -> oauth2.jwt())
        .build();
  }
}

The article concludes with a reminder that the full content is available in the accompanying PDF collection and encourages readers to like, share, and subscribe.