This article describes how a hidden 100 ms latency in a Spring Boot channel service was traced with Arthas, revealing a Tomcat‑embed bug caused by repeated loading of Swagger UI resources, and explains how upgrading Tomcat or Spring Boot eliminates the delay.
This guide shows how to use Zookeeper 3.6.2 with Spring Boot 2.2.10 to create sequential nodes, implement a distributed ID service in Java, and test concurrent ID generation across 100 threads.
This guide walks you through IntelliJ IDEA 2021’s revamped Profiler, the new microservice call‑graph analysis for Spring Boot, Micronaut and Quarkus, the Docker‑based run configurations, and the built‑in JSONPath expression debugger, showing how to leverage each feature to improve development efficiency.
This tutorial explains how to integrate Redisson into a Spring Boot application to implement robust distributed locks, covering Redisson's architecture, configuration, code examples, lock types, watchdog mechanism, and practical testing procedures for reentrant, read‑write, and semaphore locks.
This guide walks through adding Spring Boot Actuator to a project, configuring default and custom endpoints, securing shutdown operations, and demonstrates practical code snippets and curl commands for monitoring and managing a Spring Boot application.
This guide explains Spring Boot's two programmatic transaction approaches—TransactionTemplate/TransactionalOperator and direct TransactionManager—provides detailed code examples for using TransactionTemplate with return values, rollbacks, property configuration, demonstrates PlatformTransactionManager usage, and shows how to listen to transaction events with @TransactionalEventListener.
After upgrading IntelliJ IDEA, Lombok annotations may stop working and cause compilation errors, but updating Lombok to version 1.18.14 or later and adjusting IDE settings can restore functionality for Java and Spring Boot projects.
This guide demonstrates how to use Zookeeper with Spring Boot to enable data sharing among multiple JVM processes in a distributed system, covering Maven dependencies, configuration files, and Java code for connection, node watching, and data change handling.
This tutorial explains how to set up a single‑node Elasticsearch instance with Docker, integrate it into a Spring Boot application using Spring Data Elasticsearch Repositories, configure the necessary dependencies and settings, and perform basic CRUD operations and visualization with Kibana.
This article explains how to overcome Spring Boot's static @Scheduled limitation by customizing the task scheduler, creating wrapper classes and a registrar to dynamically add, remove, start, and stop cron‑based jobs, with full code examples and a database‑driven design.
This guide explains three ways to register Servlets in Spring Boot 2.3.9—including @ServletComponentScan with @WebServlet, ServletRegistrationBean, and dynamic registration via ServletContextInitializer—while detailing the underlying scanning mechanism, BeanFactory post‑processor workflow, and how Tomcat ultimately registers the servlet.
This article explains how to shrink large Spring Boot fat JAR files by separating dependencies into a lib directory and creating small business JARs, covering three optimization levels—including standard dependency separation, merging modules into a shared lib, and handling system‑scope third‑party SDKs—complete with Maven configurations and code examples.
Spring GraphQL 1.0 introduces seamless integration of GraphQL Java with Spring, offering HTTP and WebSocket handlers, security annotations, exception resolvers, testing utilities, metrics, Querydsl support, and a schema‑first approach, while outlining the roadmap and resources for developers.
This article explains how the BizLog component records who performed which action at what time in Spring Boot applications, covering Maven setup, annotation usage, custom operators, detail fields, category segregation, SpEL expressions, custom parse functions, and extension points for persistence and operator retrieval.
This article provides a comprehensive guide on integrating the Alibaba Druid JDBC connection pool into a Spring Boot application, covering its components, powerful monitoring features, password encryption, SQL parsing, Maven and YAML configuration, filter setup, and how to access the Druid monitoring console.
This article introduces Spring Cache as a unified caching solution that abstracts away the specifics of Redis, Ehcache, and other providers, explains its core concepts, annotations, configuration, and demonstrates practical usage with code examples to eliminate manual cache handling.
This article explains the concept, characteristics, and multiple implementation approaches of distributed locks, focusing on Redis‑based locks and the Redlock algorithm, and provides complete Java code examples using Spring Boot and Redisson for acquiring and releasing locks safely.
This guide walks through setting up a Spring Boot 2.1.4 application with JDK 1.8, Oracle, and HikariCP to use separate master and slave data sources, covering Maven dependencies, YAML configuration, custom property classes, JPA EntityManager factories, MyBatis SqlSession factories, mapper scanning, and sample entity definitions.
This article provides a comprehensive tutorial on the fundamentals of microservices, explains how to set up a Spring Cloud project with Maven and IntelliJ IDEA, configures Eureka registration and discovery, demonstrates service provider and consumer implementations using Spring Boot, and shows how to achieve high‑availability Eureka clusters with load‑balanced calls via Ribbon and Feign.
This article explains how to replace direct OkHttp or RestTemplate usage in Spring Boot projects with the retrofit‑spring‑boot‑starter, covering dependency setup, annotation configuration, interface definition, injection, custom interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors.
This article presents a collection of Spring Boot security vulnerabilities, detailing information leakage and remote code execution cases, with step‑by‑step exploitation guides and underlying principles, intended for security research and authorized testing only.
This article explains how to use Spring Boot to quickly integrate ShardingSphere for database sharding, covering the background of massive data storage challenges, the advantages of ShardingSphere, step‑by‑step project setup, configuration of data sources and sharding strategies, and a complete test example.
This article explains the behavior of Spring Boot’s @Configuration and @Import annotations, the reasons a custom PointcutAdvisor may not be applied when using JDK proxies, and provides two solutions—adding the @DS annotation to interface methods or forcing CGLIB proxying with proxyTargetClass=true—to ensure the advice executes correctly.
This article examines four Spring Boot @Transactional test cases using a MySQL InnoDB database to determine whether each method rolls back or commits when exceptions are thrown or caught, providing code examples and inviting readers to vote on the outcomes.
This article introduces a Spring Boot component that automatically records who performed which operation at what time, explains its Maven dependency, configuration, usage of @EnableLogRecord and @LogRecordAnnotation with SpEL expressions, custom operators, detail fields, log categories, and extensibility through custom parse functions and service implementations.
This article explains what Spring Boot Actuator is, how to quickly add and configure it, details the available endpoints, illustrates common security pitfalls such as exposing sensitive configuration, and provides practical recommendations to safely use Actuator in production environments.
This article explains the various ways to use Spring's @Autowired annotation, explores its underlying implementation using reflection, analyzes the core processing classes in the Spring framework, and answers common questions about its lifecycle, bean relationships, and why static injection is discouraged.
This article provides a comprehensive guide to using Apache RocketMQ with Spring Boot, covering core components, basic concepts, key features, step‑by‑step configuration, producer and consumer code examples, advanced message types, transaction handling, and common interview questions for distributed messaging systems.
After launching a Spring Boot 2.3.9 application, you can execute custom tasks using ApplicationRunner or CommandLineRunner, access startup arguments, generate random configuration values, disable command-line properties, understand configuration file loading order, and correctly use @EnableConfigurationProperties for bean binding.
This article introduces the open‑source Seata distributed transaction solution, explains its AT, TCC, SAGA and XA modes, describes the TC‑TM‑RM components and workflow, and provides a step‑by‑step Spring Boot demo with Docker, Maven dependencies, configuration, and code examples for a multi‑service purchase scenario.
This guide walks through configuring ShardingSphere with Oracle in a Spring Boot‑MyBatis‑JPA project, shows custom sharding algorithms, entity/DAO/service code, and details the step‑by‑step debugging that uncovered schema handling bugs and version‑specific quirks, ending with a working solution.
Understanding Java web backend requires grasping how Tomcat parses HTTP requests, dispatches them through servlets, JSPs, listeners and filters, and then leverages Spring’s IoC, AOP, MVC, Boot’s auto‑configuration, and Cloud’s micro‑service tools to build robust, industrial‑grade applications.
This tutorial explains how to integrate Ehcache into a Spring Boot application, covering Maven dependencies, YAML and XML configuration, enabling caching with @EnableCaching, using cache annotations, and manually operating caches via CacheManager, complete with code examples.
A week‑long API freeze in a sandbox environment was traced to Redis connection pool deadlocks caused by missing pool configuration and improper connection handling, and the article walks through the diagnosis with top, jstack, Arthas, and the code changes needed to fix it.
This tutorial walks through creating a Spring Boot project, configuring Maven dependencies, setting up application.yml and properties, defining POJOs, MyBatis mapper XML, service and controller layers, and building simple Thymeleaf login and registration pages, with full code snippets for each step.
This article introduces mica, a micro‑service component suite that simplifies JFinal ActiveRecord usage within Spring Boot projects, outlines its version matrix, highlights recent updates, and details key modules such as mica‑activerecord and mica‑logging for Loki support.
This article explains how to configure Spring Boot to handle default and custom exceptions globally, covering logging of error mappings, adding Fastjson and Freemarker dependencies, configuring properties, defining error entity and custom exception classes, creating an error template, implementing a @ControllerAdvice handler, and testing with sample controllers and JSON responses.
This tutorial explains the Redis publish/subscribe pattern, contrasts it with the observer pattern, and provides a complete Spring Boot example—including configuration, publisher and subscriber code, and verification steps—to help developers quickly implement real‑time messaging with Redis.
This tutorial explains why centralizing user data with LDAP simplifies multi‑system authentication, introduces LDAP fundamentals, and provides a complete Spring Boot example—including Maven dependencies, embedded LDIF setup, entity mapping, repository usage, and test cases—to help developers quickly connect to both embedded and external LDAP servers.
Spring Boot Actuator provides extensive monitoring and management features via HTTP and JMX; this guide shows how to enable it, lists each endpoint such as /auditevents, /beans, /caches, /conditions, /env, /health, and demonstrates configuration, custom endpoints, and code examples for full utilization.
This guide walks through setting up Prometheus and Grafana to monitor a Spring Boot 2.3.11 application, covering environment preparation, Maven dependencies, Spring configuration, custom metrics, Prometheus server setup, and visualizing data in Grafana.
This article explains how Spring Boot's @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration classes are discovered from META‑INF/spring.factories, and how the framework creates and refreshes the application context, including the embedded Tomcat web server, with illustrative code snippets.
This article introduces Apache Pulsar, outlines its key features and advantages over other messaging systems, and provides step‑by‑step Spring Boot integration code examples including dependencies, configuration, producer and consumer implementations for both normal and delayed messages.
This article introduces the need for dynamic configuration in Spring Boot microservices, compares popular open‑source configuration centers such as Apollo, Nacos, Spring Cloud Config, Disconf, and Diamond, and provides detailed features, a comparison table, and code examples for integrating Apollo.
This tutorial explains how to configure Spring Boot to automatically convert XML payloads into Java objects using message converters, define XML‑Java mappings with Jackson annotations, and create controller endpoints that both consume and produce XML, complete with code examples and Maven setup.
This article explains how to add a generic app‑key whitelist authentication feature to a Spring Boot web framework using four different mechanisms—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.
This tutorial explains how to protect a Spring Boot web application by integrating Spring Security and JSON Web Tokens (JWT), covering project setup, dependency configuration, custom authentication components, security filters, token generation, role‑based access control, and testing with curl commands.
This tutorial explains what Redisson is, how it extends Redis with powerful distributed data structures and lock mechanisms, and provides step‑by‑step Spring Boot integration, code examples, and detailed testing of re‑entrant, read‑write, and semaphore locks.
Learn how to capture and stream real‑time database changes using Debezium’s distributed CDC framework, configure MySQL binlog, integrate the embedded engine with Spring Boot, and process change events with sample code and Docker setup for robust data pipelines.
This article explains how to add a generic appkey whitelist authentication feature to a Spring Boot web framework using four approaches—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.
Spring Native beta introduces Maven and Gradle plugins that let Spring applications be compiled into GraalVM native images, delivering near‑instant startup, reduced memory usage, and container‑ready executables while outlining supported features, AOT transformation, and practical use cases for cloud‑native deployments.
This guide demonstrates how to build a Spring Boot 2.0 backend that accepts multiple image files, returns upload success, and displays real‑time previews on the frontend using HTML, JavaScript, and Spring MVC multipart handling, along with configuration and error handling tips.
This article introduces Alibaba's open‑source Nacos service for dynamic configuration and service discovery, explains its core features and the performance benefits of Nacos 2.x with gRPC, and provides step‑by‑step Spring Boot integration code, configuration examples, and a live demonstration using the Nacos web console.
This article explains how to shrink large Spring Boot fat JARs by extracting common dependencies into a shared lib directory and building lightweight business JARs, offering step‑by‑step Maven configurations for four optimization levels that dramatically reduce deployment size and improve update speed for both monolithic and microservice projects.
This step‑by‑step guide shows how to package a functional Spring Boot JAR into a Windows executable using exe4j, embed a local JRE, and create an all‑in‑one installer with Inno Setup so even users without Java knowledge can install and run the application.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable using exe4j, configuring a bundled JRE, and creating a single‑click installer with Inno Setup, providing step‑by‑step screenshots and command‑line details to avoid common pitfalls.
This article provides a step‑by‑step tutorial on installing Apache Pulsar with Docker, managing it via Pulsar Manager, and integrating it into a Spring Boot application using the Pulsar Java Spring Boot starter, complete with code examples and UI screenshots.
This article walks through setting up Spring Boot 2.3.11 with MyBatis 3.5.6, covering Maven dependencies, pagination and MyBatis configurations, mapper scanning, CRUD mapper definitions, dynamic SQL providers, and comprehensive unit tests, all illustrated with code snippets and diagrams.
This article explains why Spring Boot developers should return a ResponseEntity instead of a plain business object, covering its structure, custom status codes, headers, body handling, and a practical example of serving file downloads with proper content disposition.
This article explains how to break down large Spring Boot fat JARs by extracting dependencies into a shared lib directory and packaging only the business code, reducing single‑service JARs to a few hundred kilobytes and cutting total deployment size from gigabytes to a few hundred megabytes.
This article provides a detailed overview of the most commonly used Spring Boot, Spring MVC, and JPA annotations, explains their purposes, shows how they interact, and includes practical code examples for building robust Java backend applications.
This guide walks through preparing a runnable Spring Boot JAR, converting it to an EXE with exe4j (including VM options and bundled JRE), and then creating a self‑contained installer using Inno Setup so the application can run on computers without a pre‑installed JDK.
When a Java application throws IllegalArgumentException: Request header is too large, the issue stems from oversized HTTP headers, and you can resolve it by increasing the server's max‑http‑header‑size setting in Spring Boot or by moving large data from headers to the request body.
This tutorial demonstrates how to create JavaBeans, DAO interfaces, and implementations, use JDK dynamic proxies to expose proxy classes, troubleshoot method‑level proxy failures, and apply Spring AOP with ProxyFactory or @Aspect, while also covering transaction pitfalls and best‑practice configurations.
This article provides a detailed tutorial on using MyBatis-Plus with Spring Boot, covering installation, quick start, CRUD operations, annotation usage, condition builders, pagination, AR mode, primary key strategies, configuration options, code generation, logical deletion, auto-filling, optimistic locking, performance analysis, multi‑tenant support, dynamic table names, and best‑practice summaries.
This article explains how to protect data exchange with third‑party systems by using access tokens, timestamps, cryptographic signatures, and duplicate‑submission safeguards, providing detailed Java/Spring Boot examples and code snippets for implementing secure API authentication and request validation.
This article provides a detailed tutorial on using MyBatis‑Plus with Spring Boot, covering quick setup, entity and mapper definitions, CRUD operations, condition wrappers (including lambda and chain wrappers), pagination, ActiveRecord mode, primary‑key strategies, configuration options, code generation, and advanced features such as logical deletion, auto‑fill, optimistic locking, performance analysis, multi‑tenant and dynamic table name handling.
This guide walks you through installing Kafka on CentOS, configuring Zookeeper, using command‑line tools, setting up the Kafka‑Eagle visual interface, and integrating Kafka with a Spring Boot application, providing code snippets and step‑by‑step instructions for a quick start.
This tutorial walks through preparing a Spring Boot JAR, converting it to an executable with exe4j, embedding a local JRE, and finally creating a user‑friendly installer using Inno Setup, enabling distribution to computers without a pre‑installed JDK.
This article explains three ways to conditionally register a Spring Boot bean—using @ConditionalOnExpression, AllNestedConditions, and AnyNestedCondition—so that the bean is created only when specified configuration properties or other beans meet the required criteria.
This article curates thirteen high‑quality Spring Boot open‑source projects—ranging from e‑commerce platforms and microservice frameworks to payment systems and HR tools—providing star counts, repository links, brief feature overviews, and demo screenshots to help Java developers choose valuable reference implementations.
This article provides a step‑by‑step tutorial on five different ways to implement Java job scheduling—including raw threads, TimerTask, thread pools, Quartz framework, and Spring @Scheduled—followed by detailed instructions for setting up the xxl‑job admin console, configuring a Spring Boot project, and deploying sample job handlers.
This comprehensive tutorial demonstrates how to integrate MyBatis-Plus with Spring Boot, covering basic setup, entity and mapper creation, CRUD operations, condition wrappers, pagination, logical deletion, automatic field filling, optimistic locking, and advanced features such as multi‑tenant and dynamic table name handling, complete with code examples.
This article introduces the BizLog SDK for Spring Boot, explains how to add the Maven dependency, enable the @EnableLogRecord switch, use @LogRecordAnnotation for various logging scenarios, customize operators, details, categories, and parse functions, and shows how to extend the framework with custom services and implementations.
This article explains how to use Maven profiles to manage multiple Spring Boot environments, configure the maven‑assembly‑plugin to create a zip release containing the jar, configuration files and a custom shell script, and then deploy and control the application on Linux using the provided shenniu_publish.sh tool.
This guide explains how to configure a Spring Boot application with MySQL and SQL Server data sources, use Nginx to expose capture‑server images as URLs, and implement Vue components for on‑demand photo preview of traffic‑violation records.
This article explains how to implement read‑write separation in Spring Boot by extending AbstractRoutingDataSource, using ThreadLocal for key storage, and creating AOP aspects that prioritize datasource switching over transaction management.
The article explains the dangers of using kill -9 to terminate Java processes, illustrates how it can cause data loss in database operations, and provides several practical approaches—including SIGTERM, ConfigurableApplicationContext.close(), Spring Boot Actuator, and a custom Tomcat shutdown hook—to gracefully stop Spring Boot services while preserving data integrity.
Spring Boot 2.5 introduces major enhancements such as Java 16 support, Gradle 7 and Jetty 10 compatibility, HTTP/2 over TCP, a revamped datasource initialization mechanism, environment‑variable prefixes, Docker build improvements, layered WARs, actuator endpoint changes, extensive dependency upgrades, and several deprecations, while urging careful migration.
This article explains several Spring Boot techniques for initializing resources at application startup, including CommandLineRunner, ApplicationRunner, @Order, @PostConstruct, InitializingBean, and ApplicationListener, and provides code examples and usage guidelines for each method.
magic-api is a Java-based rapid API development framework that eliminates the need for traditional Controllers, Services, DAOs, and XML files by providing a UI for defining endpoints, supporting Spring Boot integration, CRUD operations, validation, transactions, result mapping, and Swagger integration, with detailed configuration examples.
This article explains why using the forceful kill -9 command to terminate Spring Boot services can cause data inconsistency and errors, and demonstrates three safer shutdown methods—using kill -15, invoking ConfigurableApplicationContext.close(), and leveraging Spring Boot Actuator—complete with code examples and configuration steps.
This guide walks through installing Elasticsearch, Kibana, and Filebeat, configuring Filebeat to ship Spring Boot logs to Elasticsearch, and verifying the logs via Kibana, including a sample Spring Boot controller that generates both normal and error log entries.
This article walks through Spring Boot 2.5.0's redesigned DataSource script initialization, clarifies deprecated properties, introduces the new SqlInitializationProperties class, and provides a complete example with Maven dependencies, configuration settings, SQL scripts, and best‑practice recommendations for automated database setup.
This article walks through building a real‑time push system with Spring Boot by integrating WebSocket and MQTT, covering the protocol basics, Maven setup, configuration classes, server implementation, controller endpoints, front‑end testing page, common pitfalls, and deployment tips.
This article explains how Spring Boot versions up to 2.3.0.RELEASE normalize URLs containing the %2e sequence, causing servlet path handling that can be exploited to bypass authentication, and shows why the behavior changes in later releases.
This tutorial walks through setting up Spring Boot 2.3.8 with Spring Cloud Hoxton, adding OpenFeign dependencies, configuring service URLs, customizing Feign client defaults, enabling logging, setting request timeouts, and integrating Hystrix circuit breaker with fallbacks and factories.
This tutorial walks through setting up iText dependencies, creating a Word‑based PDF template, configuring Adobe Acrobat form fields, and implementing a Spring Boot utility class and endpoint to generate and download customized PDF documents with embedded images.
Spring Boot 2.5.0 introduces Java 16, Gradle 7, Jetty 10 support, enhanced Docker image building, dark‑mode docs, numerous configuration improvements, updated dependency versions, and several deprecations, providing developers with a richer, more modern backend framework.
This article explains how to integrate Redisson into a Spring Boot application to implement various Redis‑based distributed synchronization primitives—including re‑entrant locks, read‑write locks, and semaphores—while covering configuration, code examples, the watchdog mechanism, and practical testing procedures.
Spring Boot 2.5.0 (alongside 2.4.6 and 2.3.11) introduces Java 16 support, Gradle 7 compatibility, enhanced Docker image building, a new datasource loading mechanism, dark‑mode documentation, and several important configuration and security changes for backend developers.
This article compiles essential Spring Boot interview questions, covering its definition, benefits, core configuration files, starter modules, auto‑configuration, embedded containers, actuator monitoring, security concerns, exception handling, differences from Spring MVC, and integration with tools like ELK and Docker.
This article provides a complete tutorial for building a food‑delivery system with a mobile app, backend management, and API, detailing the technology stack, module structure, database setup, code snippets, and step‑by‑step instructions to launch both the admin and mobile front‑ends.
This article explains what ThreadLocal is, demonstrates how it works with and without it, analyses its source code, discusses potential memory‑leak issues, and provides best‑practice guidelines and a Spring‑Boot example for safe usage in multithreaded Java applications.
This article examines the architecture and features of Spring Cloud Config and Ctrip Apollo configuration centers, compares their strengths and weaknesses, and provides practical guidance for migrating from Spring Cloud Config to Apollo in microservice environments.
This guide walks through configuring Spring Boot 2.3.10 with OAuth2 client support, detailing required dependencies, application and security settings, common session‑related errors, step‑by‑step debugging of OAuth2LoginAuthenticationFilter and OAuth2AuthorizationRequestRedirectFilter, and the final solution of aligning hostnames to preserve cookies.
This article demonstrates how to configure and use Spring Boot's ThreadPoolTaskExecutor for asynchronous processing, shows custom thread‑pool monitoring, and provides complete code snippets and log examples to help improve batch‑insert performance in Java backend applications.
This guide demonstrates how to integrate Spring Boot with the Activiti workflow engine, covering common operations such as querying owner tasks, retrieving assigned tasks, suspending, activating, and deleting process instances, complete with controller examples and sample API calls.
This guide explains how to configure and use Activiti's TaskRuntimeEventListeners and ProcessRuntimeEventListeners in a Spring Boot application, covering TaskAssignedEvent, TaskCompletedEvent, and ProcessCompletedEvent with code examples, testing steps, and important authentication settings.
This tutorial demonstrates how to extend a Spring Boot application with Activiti to query historic process data, configure a diagram generator bean, compute highlighted flows, expose a REST endpoint for real-time process diagram rendering, and verify the workflow through a series of API calls and screenshots.
