Unlock Spring Boot’s Hidden Power: Master Built‑in Features for Faster Development

Introduction

Spring Boot ships with a wealth of built‑in utilities that act like sharp tools, allowing developers to achieve common requirements with minimal configuration or code, thereby increasing productivity across the entire project lifecycle.

1. Full‑Chain Request Tracing: CommonsRequestLoggingFilter

This filter can log detailed request information, supporting multi‑dimensional data collection such as query strings ( includeQueryString), request bodies ( includePayload), headers ( includeHeaders) and client IP. The log format is flexible via setAfterMessagePrefix. Enable it by defining a bean and setting the logging level to DEBUG in application.properties.

@Configuration
public class RequestLoggingConfig {
    @Bean
    public CommonsRequestLoggingFilter logFilter() {
        CommonsRequestLoggingFilter filter = new CommonsRequestLoggingFilter();
        filter.setIncludeQueryString(true);
        filter.setIncludePayload(true);
        filter.setMaxPayloadLength(1024);
        filter.setAfterMessagePrefix("[REQUEST DATA] ");
        return filter;
    }
}

Sample log output:

[REQUEST DATA] POST /api/user, client=192.168.1.1, headers=[Content-Type:application/json], payload={"username":"test","email":"[email protected]"}

2. Flexible Request/Response Handling: Content Caching Wrappers

Native HttpServletRequest and HttpServletResponse streams can be read only once. Spring provides ContentCachingRequestWrapper and ContentCachingResponseWrapper to cache the data, enabling multiple reads and post‑processing such as logging or signature addition.

Request Wrapper Example

@Component
public class RequestLogFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        ContentCachingRequestWrapper wrappedRequest = new ContentCachingRequestWrapper(request);
        byte[] requestBody = wrappedRequest.getContentAsByteArray();
        log.debug("Received request body: {}", new String(requestBody));
        chain.doFilter(wrappedRequest, response);
    }
}

Response Wrapper Example

@Component
public class ResponseSignFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        ContentCachingResponseWrapper wrappedResponse = new ContentCachingResponseWrapper(response);
        chain.doFilter(request, wrappedResponse);
        byte[] responseBody = wrappedResponse.getContentAsByteArray();
        String signature = generateSignature(responseBody);
        wrappedResponse.setHeader("X-Response-Signature", signature);
        wrappedResponse.copyBodyToResponse();
    }
    private String generateSignature(byte[] body) {
        return Base64.getEncoder().encodeToString(body);
    }
}

3. Single‑Execution Guarantee: OncePerRequestFilter

In forward or include scenarios, regular filters may execute multiple times. Extending OncePerRequestFilter ensures the filter runs only once per request, simplifying logging, security checks, and performance monitoring.

Core Advantages

Avoid Duplicate Processing: shouldNotFilter automatically skips repeated executions.

Simplify Development: Override only doFilterInternal without manual state handling.

Applicable Scenarios: Logging, JWT validation, performance metrics, etc.

4. AOP Development Helpers

AopContext: Access the current proxy via AopContext.currentProxy() to ensure annotations like @Transactional work when a method calls another method within the same class.

AopUtils: Determine proxy type (JDK dynamic or CGLIB) with AopUtils.isJdkDynamicProxy and AopUtils.isCglibProxy.

ReflectionUtils: Simplify reflective access to private fields and methods.

5. Dependency Management Magic: Starter Auto‑Configuration

Spring Boot starters provide “one‑stop” dependency bundles. Adding spring-boot-starter-web automatically brings in Tomcat, Spring MVC, Jackson, etc. Version alignment is handled by spring-boot-dependencies.

Custom starters can be created by adding spring.factories under src/main/resources/META-INF and using conditional annotations such as @ConditionalOnClass and @ConditionalOnMissingBean.

6. Configuration Simplification: @ConfigurationProperties and Placeholders

Bind external configuration to POJOs with @ConfigurationProperties, avoiding hard‑coded values. Use ${} placeholders and @Value for dynamic injection.

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String env;
    private DatabaseConfig database;
    // getters and setters
    public static class DatabaseConfig {
        private String url;
        private String username;
        // ...
    }
}

app:
  env: production
  database:
    url: jdbc:mysql://localhost:3306/test
    username: root

7. Asynchronous and Scheduled Tasks

Use @Async (enabled by @EnableAsync) to run methods in separate threads, optionally specifying a custom executor. Use @Scheduled for cron‑based or fixed‑delay jobs.

@Service
public class AsyncService {
    @Async("customExecutor")
    public CompletableFuture<Void> processAsyncTask(String taskId) {
        // time‑consuming logic
        return CompletableFuture.completedFuture(null);
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean("customExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(20);
        executor.initialize();
        return executor;
    }
}

@Service
public class ScheduledService {
    @Scheduled(cron = "0 0 1 * * ?")
    public void dailyCleanup() {
        // cleanup logic
    }

    @Scheduled(fixedDelay = 5000)
    public void periodicSync() {
        // sync logic
    }
}

8. Monitoring and Diagnostics: Spring Boot Actuator

Actuator provides production‑ready endpoints for health checks, metrics, and more. Custom metrics can be added via MeterRegistry.

@Autowired
private MeterRegistry meterRegistry;

public void recordOrder(String status) {
    meterRegistry.counter("order.processed", "status", status).increment();
}

9. Expression Power: Spring Expression Language (SpEL)

SpEL enables dynamic evaluation in configuration, annotations, and code. Examples include bean property values, conditional configuration, and security expressions.

<bean id="userService" class="com.example.UserService">
    <property name="defaultTimeout" value="#{T(java.lang.Integer).parseInt('1000')}"/>
</bean>

@ConditionalOnExpression("${app.env} == 'prod' && @environment.getProperty('server.port') == 8080")
public class ProdConfig { }

@PreAuthorize("hasRole('ADMIN') or @accessService.hasPermission(#userId)")
public void deleteUser(Long userId) { /* ... */ }

Conclusion

Spring Boot’s built‑in features span the entire development‑to‑operations lifecycle. Properly combining these tools reduces boilerplate code, enhances maintainability, and strengthens system robustness.