Learn how to protect personal data in Spring Boot 3.2.5 applications by customizing Logback's PatternLayout and appender to mask fields such as name, phone, password, and email, with step‑by‑step code examples, configuration snippets, and handling of object logging.
This article demonstrates how to build a flexible API rate‑limiting solution in Spring Boot by combining a HandlerInterceptor, Redis counters, and custom annotations with reflection, covering configuration, code examples, mapping rules, time‑window nuances, path‑parameter handling, and real‑IP considerations.
This article explains how to integrate Spring Boot with WebSocket to create a lightweight instant‑messaging system, covering dependency setup, configuration classes, core server code, front‑end integration, essential IM modules, common deployment challenges, and provides complete example code and demos.
This guide walks you through the pain points of environment setup, shows step‑by‑step creation of a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot and Kafka, and provides ready‑to‑use Maven configurations, global exception handling, logging, CORS, Swagger, and a curated list of useful development tools.
This tutorial walks through creating a Maven‑based Spring Boot backend project with multiple modules, configuring pom.xml files, application properties, and logging, then adds a scheduled Douyin hot‑search crawler using OkHttp, demonstrating full end‑to‑end setup for a web service.
This article provides a comprehensive analysis of how Spring Boot 2.7.2 works with Log4j2 2.17.2, covering Log4j2's core components, Spring Boot's logging configuration options, the internal startup sequence, the LoggersEndpoint for runtime level changes, and custom hot‑update techniques, all illustrated with code snippets and diagrams.
This article explains why API versioning is essential for Spring Boot REST services and compares three common approaches—URI versioning, request‑header versioning, and media‑type versioning—while offering guidance on selecting a method and handling API deprecation.
This article walks through practical ways to perform batch updates in MyBatis, compares foreach, case‑when, and INSERT…ON DUPLICATE KEY techniques, explains common Druid WallFilter restrictions, and shows how to enable multi‑statement execution via JDBC and Spring configuration.
This guide explains why structured logging is essential for observability, shows how Spring Boot 3.4 adds out‑of‑the‑box support for Elastic Common Schema and Logstash formats, and provides step‑by‑step configurations and code examples for console output, file logging, custom fields, and custom formatters.
This article examines common pitfalls in Spring Boot controller implementations, demonstrates how excessive if‑else checks and business logic in controllers degrade code quality, and provides clean, refactored examples using @Valid validation, concise error handling, and a global exception handler to achieve more maintainable backend services.
This article explains why a plain Dockerfile for a Spring Boot fat JAR is inefficient, introduces Spring Boot's layered JAR format, and provides a multi‑stage Dockerfile that leverages layer caching to speed up builds and reduce runtime overhead.
This article provides a step‑by‑step tutorial on Apollo’s concepts, features, model, namespace handling, client design, high‑availability considerations, project creation, configuration management, Spring Boot client implementation, testing across environments, clusters and namespaces, and deployment on Kubernetes with Docker.
This article reviews several ways to integrate WebSocket with Spring Boot, focusing on the three mainstream approaches—Javax, WebMVC, and WebFlux—by providing server and client configurations, code examples, and practical tips such as handling ping/pong, handshake interceptors, and reactive streams.
This guide explains why pre‑loading initial data is essential for Spring Boot applications and demonstrates four practical methods—CommandLineRunner/ApplicationRunner, bean initialization with @PostConstruct, SQL script execution, and @Sql annotation for tests—complete with code snippets and configuration details.
This article demonstrates multiple methods to add text or image watermarks to PDF documents in a Spring Boot application, covering Java libraries such as Apache PDFBox, iText, Ghostscript command line, Free Spire.PDF, and Aspose.PDF, with code examples and usage instructions.
This article explains how Spring Boot 3.2.5 implements the RFC 7807 Problem Details specification, covering the core abstractions, code examples for creating ProblemDetail and ErrorResponse objects, and practical patterns for global exception handling in Spring MVC applications.
This article explains how Spring Boot’s @Transactional annotation works, introduces programmatic transaction management, and demonstrates how to create custom transaction hook functions with TransactionSynchronizationManager and TransactionSynchronization to execute custom logic at each transaction phase, improving robustness and maintainability.
This tutorial explains how to integrate Jasypt into Spring Boot 3.2.5, configure encryption keys, encrypt sensitive properties, use the ENC() syntax, and retrieve decrypted values at runtime, providing a complete solution for protecting configuration data.
This guide explains how to use LangChain4j Spring Boot starters to configure OpenAI models, create declarative AI services with @AiService, and run practical examples such as a customer‑support agent and a simple HelloWorld program, covering required dependencies, properties, and code snippets.
This article provides a comprehensive introduction to Spring Cloud OpenFeign, comparing it with Feign and HttpExchange, and walks through practical setup, client declaration, custom configuration, interceptors, error handling, timeout and logging settings with full code examples for Spring Boot 3.2.5.
This article explains the essential duties of a Spring MVC Controller, identifies common pitfalls such as duplicated validation and inconsistent responses, and demonstrates how to introduce a unified result wrapper, ResponseBodyAdvice, proper message‑converter ordering, JSR‑303 validation, custom validators, and global exception handling to produce concise, maintainable backend code.
This article explains why validating file types is essential for security and demonstrates six Java-based techniques—including Java 7 API, URLConnection, MimeTypesFileTypeMap, jMimeMagic, Apache Tika, and Spring's MediaTypeFactory—to reliably determine a file's MIME type under various conditions.
Learn step‑by‑step how to create a custom Spring Boot starter, configure its properties, define services and controllers, register it via spring.factories, and then integrate the starter into other projects with Maven dependencies and configuration files.
This article explains why Spring Cloud Gateway can return duplicate Access-Control-Allow-Origin and Vary headers, analyzes the request processing flow, and provides two solutions—using the built‑in DedupeResponseHeader filter with retention strategies or implementing a custom CorsResponseHeaderFilter—to eliminate the CORS error caused by multiple header values.
This article explains how to implement invisible token refresh for authentication servers using Spring Boot gateway filters, JWT handling, Axios interceptors, and a client‑side timer, compares client‑ and server‑side approaches, and provides complete code examples and practical recommendations.
This article provides a comprehensive guide to using Spring Boot’s @RequestMapping annotation, covering path definitions, HTTP methods, headers, produces/consumes, path variables, parameters, fallback handling, and advanced options, with practical curl commands and code snippets for each scenario.
This article explains how to implement asynchronous request handling in Spring Boot using four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—detailing their mechanisms, code examples, thread pool configuration, and when to apply asynchronous processing to improve throughput.
This article explains why centralized log collection is essential for multi‑environment services, introduces Graylog as a lightweight alternative to ELK, details Filebeat's role and workflow, provides configuration examples, shows how to deploy both Filebeat and Graylog via Docker or packages, and demonstrates integration with Spring Boot and log search techniques.
Spring Boot 3.4 adds built‑in support for structured logging with ready‑made JSON formats such as Elastic Common Schema, lets you configure console or file outputs, enrich logs via MDC or the fluent API, and enables custom formatters—including a JsonWriter‑based example—for fully tailored, machine‑readable log entries.
This article walks you through designing, deploying, and managing a multi‑level approval workflow using the Activiti engine, covering BPMN diagram creation, Spring Boot integration, database schema, API usage, code examples, and best practices for extending processes without additional code.
This article walks through using JetCache with Spring Boot 3.2.5, covering its features, Maven dependency setup, YAML configuration, annotation-based caching, programmatic cache creation, statistics monitoring, and deprecated APIs, all illustrated with code snippets and screenshots.
This article explains how to protect Spring Boot web applications from Cross‑Site Scripting (XSS) attacks by introducing two main defense mechanisms—custom @XSS annotations and servlet filters—complete with implementation details, code examples, configuration steps, and testing results.
This article explains several strategies for dynamically updating Spring Boot application properties—such as using prototype‑scoped beans, @RefreshScope with Spring Cloud, external configuration files, and custom PropertySource updates—so that changes take effect without restarting the service.
This guide walks through creating a Spring Boot 3.3.3 microservice permission framework with OAuth2, covering technology stack, core features, project structure, step‑by‑step service startup, token acquisition, API calls, and provides the complete source repository for hands‑on experimentation.
This guide explains how to protect a Spring Boot release package from source leakage by comparing code obfuscation and encryption, detailing the configuration of the classfinal‑maven‑plugin, launch commands with and without passwords, and binding the encrypted jar to a specific machine.
This tutorial provides a step‑by‑step guide to set up a complete Jenkins‑Docker‑Spring Boot pipeline on CentOS 7, covering Docker installation, Jenkins deployment, required plugins, Maven configuration, job creation, testing, and running the packaged application with Docker.
This guide explains how to enable and use Spring Boot's @Async and @Scheduled annotations, configure various TaskExecutor and TaskScheduler implementations, leverage new Spring 6.1 pause/resume and virtual‑thread features, and apply graceful shutdown for both asynchronous and scheduled jobs.
This article introduces ShardingJDBC, a Java middleware that simplifies sharding, read/write separation, and distributed transactions, and provides a step‑by‑step Spring Boot example with configuration, code snippets, and verification of its core features.
This guide explains how to automatically inject userId and orderId into log statements in a Spring Boot microservice by configuring Log4j2 patterns, using MDC to store context variables, and creating a custom @UserLog annotation with an AOP aspect that populates the MDC before method execution.
This article walks through the challenges of setting up a Java backend environment, demonstrates how to create a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, and provides reusable code snippets for exception handling, logging, CORS, Swagger, and response wrapping, along with recommended tools.
This tutorial explains how to implement IP‑and‑URL rate limiting in a Spring Boot application by creating a custom HandlerInterceptor that tracks request counts in Redis, uses a distributed lock to enforce limits, and registers the interceptor to protect services from malicious or excessive traffic.
This article explains how Spring Boot supports asynchronous request processing using Servlet 3.0 features and four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—provides code examples, thread‑pool configuration, and guidance on when to apply async handling to improve throughput.
This article explains the most commonly used Spring Boot annotations—including @SpringBootApplication, @RestController, @RequestMapping, @Autowired, @Value, @Component, @Service, @Repository, and @Configuration—providing clear descriptions and practical code examples for each.
This tutorial explains how to perform partial updates of RESTful resources using the HTTP PATCH method and JSON Patch format in Spring Boot 3.2.5, covering all RFC‑6902 operations with code examples and a complete working controller implementation.
This article explains the Spring Boot startup mechanism, covering the @SpringBootApplication entry annotation, its constituent annotations, the role of SpringApplication.run, and the step‑by‑step initialization flow that powers Java backend applications.
This article provides a step‑by‑step guide to creating a Spring Boot starter for enterprise‑grade object storage services, explaining OSS concepts, Amazon S3 basics, project setup, Maven dependencies, configuration classes, template interfaces, implementation details, auto‑configuration, packaging, and testing.
This guide explains how to integrate the mybatis-plus-generator-ui library into a Spring Boot project, configure database connections, launch the web UI, and use its customizable templates and naming converters to generate Entity, Mapper, Service, and Controller classes for multiple databases with a single click.
Learn how to seamlessly integrate the open‑source p6spy tool into a Spring Boot 3.2.5 application to automatically log SQL statements, measure execution times, customize logging formats, and fine‑tune database performance using both MyBatis and JPA examples.
This article introduces the open‑source XXL-Job distributed task scheduling framework, explains its architecture and communication design, and provides a step‑by‑step hands‑on tutorial covering server deployment, executor configuration, task development (annotation, API, sharding), execution, and log inspection, with code examples and screenshots.
Apache Tomcat is the underlying servlet container and web server that Spring Boot automatically embeds via the spring‑boot‑starter‑web dependency, but junior developers often miss its core roles—managing servlet lifecycles, serving static resources, and compiling JSPs—so learning Tomcat (or swapping it for Jetty by adjusting Maven exclusions) clarifies what Spring Boot abstracts and enables flexible container choices.
This guide explains how to set up a Spring Boot project, add the Tess4J dependency, configure language data, implement an OCR service and REST controller, and test both local file uploads and remote image URLs for text recognition.
Learn how to integrate the open‑source DynamicTp framework into Spring Boot 2.7, configure its core parameters, enable real‑time monitoring, alerts, and Nacos‑based dynamic adjustments, while exploring code examples, dependency setup, and practical usage for robust thread‑pool management.
This article provides an in‑depth overview of the WebSocket protocol, covering its fundamentals, advantages, lifecycle, message formats, Java API usage, Spring Boot integration, performance considerations, and future development directions, complete with practical code examples for both server and client sides.
This article explains how Spring Boot automatically configures a ThreadPoolTaskExecutor for @Async and @Scheduled, shows the default parameters introduced in version 2.1, demonstrates how to inspect and customize them, compares the default executor with SimpleAsyncTaskExecutor, and provides code examples for using @Async, injecting the executor, and defining a custom thread pool to avoid resource‑exhaustion issues.
This article explains how to standardize API responses in Spring Boot by defining a JSON result format, using custom annotations, interceptors, and ResponseBodyAdvice to automatically wrap controller return values, while also discussing status code design, message handling, and code simplification techniques.
This article explains how to implement unified data desensitization in Java Spring Boot applications by creating custom annotations, enums, serializers, and utility methods that automatically mask personal information during JSON serialization, complete with code examples and test results.
This article systematically catalogs every Spring and Spring Boot extension interface—from ApplicationContextInitializer to DisposableBean—illustrates their invocation order with a diagram, explains practical use‑cases, and provides concrete code samples for each hook, enabling developers to tap into the bean lifecycle for custom initialization, monitoring, and cleanup.
This guide explains how to integrate the Logbook library into Spring Boot applications to capture detailed HTTP request and response logs, covering dependency setup, configuration options, output formats, Logback file logging, custom sinks, and RestTemplate interception for comprehensive monitoring and debugging.
This article explains the concept, advantages, design considerations, and step‑by‑step implementation of a multi‑tenant architecture using Spring Boot and Spring Cloud, covering tenant isolation, database strategies, dynamic routing, security configuration, deployment scenarios, and provides complete code examples for building SaaS‑ready applications.
This article explains how to design a multi‑level workflow approval system using the Activiti engine, covering process diagram creation, deployment, task handling, variable management, exclusive gateways, and complete project configuration with Spring Boot and an H2 database.
This article explains how to dynamically load JAR files in a Spring Boot application, covering core concepts, benefits, usage of SpringBootClassLoader, creation of JARs, and alternative third‑party OSGi‑resource‑locator approaches with full code examples.
The article explains how to protect Spring Boot applications from XSS attacks by using custom annotations such as @XSS with an XssValidator and by implementing a request‑filter chain—including XssFilter and XssWrapper—to sanitize input, demonstrating through tests that both approaches reliably secure user data.
Learn how to create and register custom type converters for Spring Boot @ConfigurationProperties, enabling seamless binding of complex objects from property files using @ConfigurationPropertiesBinding and BeanFactoryPostProcessor techniques, including code examples, configuration snippets, and two registration approaches for practical implementation.
This article details a step‑by‑step investigation of a Spring Boot application that consumed far more physical memory than its 4 GB heap limit, revealing a native‑memory leak caused by MCC's package‑scanning using Reflections and the Spring Boot ZipInflaterInputStream, and explains how configuration changes and newer Spring Boot versions resolve the issue.
This article compiles practical advice for Java developers feeling out‑of‑practice, covering migration to JDK 21, Spring Boot 3.2 observability, new language features, community resources, and strategies to boost confidence and stay current with the evolving Java ecosystem.
This article walks through a Java Spring‑Boot implementation of a contract‑signing workflow, explains the original chain‑of‑responsibility design, shows its limitations, and demonstrates how to replace manual bean wiring with a strategy‑based annotation and enum configuration for flexible node management.
This article builds a simple Spring Boot Greetings API, configures Maven profiles for Tomcat, Jetty, and Undertow, creates Docker images for each, runs load‑testing benchmarks across multiple concurrency levels, and analyzes startup time, CPU, memory, and response performance to determine the optimal embedded server.
This article explains the JSONP technique, demonstrates how to implement it in Spring Boot with a simple REST endpoint, custom JSONP wrapper, ResponseBodyAdvice, and a customized HttpMessageConverter, and shows how to test the solution using HTML script tags.
This article explains how to use the Activiti workflow engine to design a multi‑level leave‑approval process, covering BPMN diagram creation, Spring Boot configuration, deployment, Java code for starting instances, task handling, database schema, API overview, and tips for extending the workflow without additional code.
Learn how to simplify repetitive error-handling code in Spring Boot by creating a custom @ErrorHandler annotation that leverages Spring AOP to automatically log exceptions, with step-by-step instructions, required dependencies, annotation definition, aspect implementation, and usage examples.
This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts OSS object‑storage services via the Amazon S3 protocol, covering project setup, Maven dependencies, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing.
This tutorial explains how to implement API rate limiting in Spring Boot using the Bucket4j library, covering token‑bucket theory, Maven dependencies, Redis configuration, YAML rules, annotation‑based limits, custom responses, and conditional bypasses with complete code examples.
This article explains how to use SLF4J as a facade for Logback or Log4j2, shows Maven dependencies, demonstrates logback.xml and logback‑spring.xml configurations, covers Spring Boot's default logging setup, custom log levels, profile‑based settings, and how to switch to Log4j2 for higher performance.
Graceful Response is a Spring Boot component that offers one‑stop unified response packaging, global exception handling, and custom error code support, enabling developers to simplify controller code, reduce boilerplate, and improve readability and efficiency.
This article explores eight practical strategies for injecting prototype‑scoped beans into singleton‑scoped beans in Spring Boot, detailing each method's implementation, advantages, and drawbacks, and provides code examples to help developers choose the most suitable approach.
This article provides a comprehensive guide on integrating Spring Boot with the open‑source distributed scheduler XXL‑Job, covering installation, configuration of the admin console and executor, code examples, parameter details, comparison with other schedulers, and best practices for reliable task management.
Lock4j is a Java distributed lock library supporting Spring AOP, RedisTemplate, Redisson, and Zookeeper, offering simple usage, configurable properties, annotation-driven locking, custom executors, key generators, and failure strategies, with detailed setup, code examples, and advanced customization instructions.
This guide walks through eight Spring Boot property injection techniques—including @Value placeholders, SpEL expressions, @ConfigurationProperties, custom @PropertySource, YAML factories, Environment access, custom annotations, programmatic loading, and command‑line arguments—showing code examples and expected outputs for each method.
This article explains how to integrate JSON Schema validation into a Spring Boot application, covering dependency setup, schema definition, bean configuration, service implementation, controller exposure, and testing with curl to ensure JSON payloads conform to the defined rules.
This article explains why API debounce is essential, identifies the types of endpoints that need it, and provides two distributed solutions—shared Redis cache and Redisson lock—along with complete Java code examples and deployment tips for preventing duplicate submissions in a Spring Boot backend.
The article explains Java's virtual threads introduced in Java 19, compares them with traditional threads, and demonstrates how to configure Spring Boot to use virtual threads, including code samples and performance benchmarks that show dramatic latency reductions in both async services and HTTP requests.
This guide walks you through why Java remains vital, explains what Spring Boot is, outlines its core features, and provides a detailed learning roadmap covering Java fundamentals, Spring core concepts, web development, AOP, microservices, databases, security, DevOps tools, and deployment strategies for building robust enterprise applications.
The article compares messy Spring MVC controllers packed with try‑catch, field checks, and business logic to concise, well‑structured versions that use @Valid, service delegation, and global exception handling, and provides a step‑by‑step refactoring guide.
This tutorial explores Jackson's rich annotation set in Spring Boot 3.2.5, demonstrating how to serialize and deserialize JSON with built‑in annotations like @JsonAnyGetter, @JsonGetter, @JsonPropertyOrder, and @JsonIgnore, how to create custom annotations, and how to disable annotation processing for fine‑grained control.
This article explains the four common Redis cache pitfalls—cache penetration, avalanche, breakdown, and data inconsistency—demonstrates how they can crash high‑traffic systems, and provides practical Java/Spring Boot solutions such as empty‑object caching, Bloom filters, distributed locks, and delayed double‑delete strategies.
This article introduces the high‑performance Caffeine caching library for Spring Boot 3.2, explains its core features, demonstrates detailed performance benchmarks, and provides practical code examples covering synchronous and asynchronous operations, eviction policies, removal listeners, refresh mechanisms, and statistics collection.
Learn how to elegantly process Java 8 date parameters, register custom converters, conditionally enable controllers, apply unified API prefixes, perform service‑layer validation, and control asynchronous request timeouts in Spring Boot 3.2.5 using annotations, configuration files, and programmatic WebMvcConfigurer techniques.
This guide explains why upgrading from Spring Boot 1.5 to 2.1 is essential for MongoDB transaction management, outlines version requirements, highlights key feature changes, and provides step‑by‑step instructions with code examples to enable reliable transactional operations in a Spring‑based backend.
This guide demonstrates how to integrate the open‑source kkFileView library into a Spring Boot 3.2.5 project to provide online preview for dozens of file formats—including Office documents, PDFs, images, 3D models, and media—by configuring a local resource handler, running the kkFileView server, and using base64‑encoded URLs.
This article explains a bug in Spring 6.1.11 where adding a servlet path prefix causes functional routing to throw an UnsupportedOperationException, demonstrates the issue with code and screenshots, and provides work‑arounds and the permanent fix introduced in Spring 6.1.12.
This guide shows how to implement end‑to‑end trace ID propagation across Spring Cloud gateways, downstream services, and asynchronous threads using a custom GlobalTraceFilter, a patched LogbackMDCAdapter with Alibaba TransmittableThreadLocal, and minimal configuration, avoiding heavyweight tracing libraries.
This article examines common pitfalls in Spring Boot controller design, showcases messy examples, then demonstrates cleaner implementations using @Valid for parameter validation, streamlined exception handling, and best‑practice refactoring to produce more maintainable backend code.
In Spring Boot you can customize JSON request and response handling by annotating fields with @JsonSerialize/@JsonDeserialize, registering a global ObjectMapper module, adding a PropertyEditor via @ControllerAdvice, creating a custom HttpMessageConverter, or using AOP interception, selecting the approach that matches your project’s complexity.
This article explains how the LiteFlow rule engine enables Java developers to define, configure, and execute complex serial and parallel business workflows using XML/JSON/YAML rule files, various node components, data contexts, and runtime parameters, with hot‑deployment and integration examples for Spring Boot projects.
This article demonstrates how to transform overly complex Spring Boot controllers—filled with try‑catch blocks, validation logic, and business code—into elegant, concise implementations by applying @Valid, separating concerns, and using global exception handling, illustrated with side‑by‑side code comparisons and practical tips for cleaner backend development.
This article explains how to implement asynchronous request handling in Spring Boot using four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—detailing their execution flow, configuration of thread pools, and scenarios where async processing improves throughput.
This article documents a production incident where multiple Spring Boot services each consumed around 12 GB of memory, explains how to diagnose the issue using jps and jmap, details default JVM heap size calculations, and provides recommendations for configuring JVM parameters to prevent excessive memory usage.
The article demonstrates how to mask sensitive Java backend data by using Hutool's DesensitizedUtil for common types and a custom @Desensitization annotation with a DesensitizationTypeEnum‑driven Jackson serializer (or Fastjson ValueFilter) to apply flexible masking rules during JSON serialization.
This tutorial shows how to instrument Spring Boot APIs using Actuator, a custom @Monitor annotation with AOP, and Prometheus to collect and visualize method execution times, providing a complete end‑to‑end monitoring solution.
Spring AI has added full support for OpenAI's structured output feature, enabling developers to define JSON schemas for AI responses, with example code showing how to configure prompts, response formats, and BeanOutputConverter for seamless JSON-to-Java bean conversion, plus Spring Boot starter configuration.
