This article explains why asynchronous execution is needed in Spring Boot, demonstrates how to enable @Async, shows step‑by‑step code for configuration, method annotation, and controller usage, and details how to create and manage custom thread pools for optimal performance and fault tolerance.
This tutorial walks through setting up a Spring Boot and MyBatis multi‑module project in IntelliJ IDEA, covering environment preparation, directory layout, parent and child module creation, Maven dependency configuration, bean scanning, MyBatis integration, and verification of the running application.
This article presents a complete Java backend project for community‑based COVID‑19 management, detailing its architecture, modules such as login, daily epidemic tracking, prevention management, system administration and user management, and provides extensive SpringBoot service‑layer code examples with RBAC permission control.
Learn how to set up the enterprise‑grade Torna API documentation platform, integrate it with Swagger, and run it on Windows, Linux, or Docker, covering project structure, installation steps, configuration, and advanced features like permission control, mock data, and interface testing.
This guide walks through integrating Hikvision cameras into a SpringBoot‑Vue application, covering SDK download, backend‑frontend code generation, Vue table multi‑selection limited to four cameras, IE‑mode detection, plugin installation, camera login, real‑time playback, and clean shutdown.
This article demonstrates how APIJSON dramatically reduces boilerplate for typical CRUD operations by using a single generic endpoint for all request types, showing concrete SpringBoot examples, request/response JSON structures, permission configuration, and advanced query capabilities, all with minimal code.
This article provides an in‑depth overview of Logback, covering its core modules, component relationships, configuration files, code examples for console, file, and rolling appenders, as well as practical integration tips for Spring Boot and servlet containers.
This article presents a full‑stack Java SpringBoot project that manages community users and tracks epidemic data, employing RBAC for role‑based permissions, MySQL for storage, and various Spring modules such as SpringMVC, AOP, interceptors, and global exception handling.
This guide walks through creating a SpringBoot and MyBatis multi‑module project in IntelliJ IDEA, covering environment setup, parent and child module creation, dependency configuration, bean scanning, MyBatis integration, and troubleshooting common startup errors, culminating in a runnable demo endpoint.
This tutorial shows how to replace Swagger with smart-doc, a zero‑annotation API documentation tool for SpringBoot that generates HTML docs and Postman collections, covering Maven plugin setup, configuration files, custom tags, error‑code mapping, request‑header definitions, and step‑by‑step usage examples.
This article explains why traditional SpringBoot CRUD endpoints require dozens of lines of code and how APIJSON lets you perform all create, read, update, delete, and statistical operations on any table with only a few lines of configuration and a single generic interface.
This article explains the principles of Single Sign-On using OAuth2.0, illustrates the flow with a real‑world analogy, details HTTP redirection, compares grant types, and provides a complete Spring Boot implementation of an authorization server, client application, and role‑based access control for microservices.
This article provides a step‑by‑step guide on optimizing SpringBoot projects by modifying configuration files and tuning JVM parameters, covering both IDE‑based VM options and command‑line scripts, with detailed explanations of each setting and practical examples.
This article provides a comprehensive walkthrough of SpringBoot’s auto‑configuration mechanism, covering common annotations, configuration property binding, import strategies, conditional beans, the application startup flow, and the role of META‑INF/spring.factories in loading auto‑configuration classes.
This article provides a comprehensive guide on integrating Alibaba's EasyExcel library into Java projects, covering environment setup, reading Excel files with and without sheet specifications for datasets smaller or larger than 1000 rows, exporting data with simple and model‑mapped approaches, handling multiple sheets, and includes full source code examples and a test suite.
This article demonstrates a real-time device monitoring solution that uses a WebSocket connection to push abnormal equipment alerts from a mobile client to a Vue-based monitoring page, with a SpringBoot backend handling the WebSocket server and broadcast logic.
This guide walks through setting up a complete log‑collection and visualization pipeline—including SpringBoot log4j2 configuration, Kafka broker creation, Filebeat forwarding, Logstash processing, and Kibana dashboard setup—so you can capture, ship, and analyze application logs in real time.
This article introduces a WeChat mini‑program that uses uni‑app for the front end and SpringBoot for the back end to provide text, voice, and image‑based garbage classification, and walks through the required setup, dependencies, and deployment steps.
This guide explains how to add a custom banner.txt file to a SpringBoot project and shows several free online tools for generating ASCII art from text or images, including step‑by‑step instructions and example results that appear when the application starts.
This guide walks you through setting up a complete log‑collection and visualization pipeline—preparing servers, configuring a SpringBoot application with Log4j2, routing logs to Kafka, harvesting them with Filebeat, processing with Logstash, and finally visualizing in Elasticsearch and Kibana.
This article walks through integrating Swagger into a SpringBoot project, covering dependency setup, configuration, handling common issues like ResponseBodyAdvice conflicts, enhancing UI with Knife4j, and leveraging Swagger’s grouping feature for parameter validation, providing complete code snippets and troubleshooting tips for seamless API documentation.
This article walks through the challenges of sharing HTTP session data between micro‑services in a distributed SpringBoot architecture, demonstrates a Redis‑based manual solution, introduces Spring Session for transparent session clustering, and resolves OpenFeign cookie loss with a request interceptor.
This article surveys the most commonly used Java libraries and tools—from Netty and SpringBoot to JUnit, JMH, OkHttp, HikariCP, Caffeine, Hazelcast, logging frameworks, Jackson, Jolokia, Hibernate Validator, and FreeMarker—highlighting their roles, advantages, and integration tips for modern enterprise development.
This article introduces smart-doc as a zero‑annotation alternative to Swagger, compares their features, and provides step‑by‑step instructions—including Maven setup, configuration files, debugging, response‑body advice, custom headers, parameter grouping, and IDE integration—to generate rich API documentation for SpringBoot projects.
This article introduces the EasyExcel library for Java, demonstrating how to quickly set up Excel import and export with Maven dependencies, entity annotations, custom converters, listeners for validation, and controller code for both reading and writing data, along with common API usage and examples.
This article explains how to set up Spring Boot and RabbitMQ message confirmation, covering environment preparation, publisher and consumer callback implementations, acknowledgment methods, testing procedures, and practical pitfalls such as missed acknowledgments, infinite redelivery loops, and duplicate consumption.
This article presents a comprehensive overview of how a team applied Domain-Driven Design to migrate a car‑purchase invoice repository, detailing DDD fundamentals, strategic and tactical design phases, module architecture, coding standards, and lessons learned from the implementation.
This guide walks through setting up a complete log‑collection and visualization pipeline—preparing servers, configuring a SpringBoot project with Log4j2, deploying Kafka, installing Filebeat, creating Logstash pipelines, and visualizing logs in Elasticsearch and Kibana—so you can monitor application logs in real time.
This article introduces Sa-Token, a lightweight Java permission authentication framework, showcases its simple API with code examples, lists its extensive features such as login, SSO, OAuth2.0 and distributed sessions, and provides Maven dependency, configuration, and quick‑start demo for SpringBoot projects.
This guide walks through deploying a SpringBoot‑Vue split‑stack project with Docker by creating separate containers for Redis and MySQL, building custom Docker images for the backend JAR and the Nginx‑served frontend, configuring host networking, and exposing the necessary ports for verification.
This article introduces a front‑back separated HR management system built with SpringBoot and Vue, detailing its technology stack—including Redis and RabbitMQ—and provides a quick deployment guide with code snippets, enabling developers to set up and extend the project efficiently.
This article explains how to build a free Java-based online preview service for Word, Excel, and PowerPoint files by installing Apache OpenOffice, adding JODConverter dependencies, creating a conversion utility class, and exposing the functionality through SpringBoot service and controller layers.
This tutorial walks through the end‑to‑end setup of a logging pipeline that starts with a SpringBoot application using Log4j2, forwards logs to Kafka, collects them with Filebeat, processes them via Logstash, and finally visualizes them in Elasticsearch and Kibana, covering server preparation, configuration files, and essential code snippets.
This article explains how to implement graceful shutdown and startup for microservices using JVM shutdown hooks, Spring Boot's built‑in mechanisms, Docker stop signals, and external containers like Jetty, providing code examples and best‑practice recommendations for ensuring services deregister, reject traffic, and start only after health checks succeed.
This article introduces the most frequently used Spring framework annotations—including core, MVC/REST, Spring Boot, stereotype, transaction, scheduling, and testing annotations—explaining their purposes, usage locations, and providing Java code examples to illustrate how they configure beans, handle requests, and manage application behavior.
This article presents a curated list of the eleven most popular Java open‑source projects on GitHub in August, including brief descriptions, star counts, and links, covering frameworks, messaging systems, data processing engines, and development tools for Java developers.
This article explains how a naïve SpringBoot SecKill implementation can cause overselling, then introduces Redis commands (SETNX, EXPIRE, GETSET) and a custom RedisLock component to achieve safe distributed locking, avoid deadlocks, and ensure accurate inventory updates during high‑concurrency flash‑sale events.
This article explains how SpringBoot injects HttpServletRequest into controllers using a JDK dynamic proxy and ThreadLocal storage, tracing the request object from the ObjectFactoryDelegatingInvocationHandler through RequestObjectFactory, RequestContextHolder, and the FrameworkServlet's processRequest lifecycle.
The article evaluates three data‑insertion techniques—repeated single inserts, XML‑based SQL concatenation, and batch processing—within a SpringBoot application using SQL Server, presenting code examples, test results, and recommendations on when to use each method.
This tutorial walks through preparing servers, configuring a SpringBoot project with Log4j2, setting up Kafka, Filebeat, and Logstash to collect and parse logs, and finally visualizing them in Elasticsearch and Kibana, providing a full end‑to‑end logging solution.
JApiDocs is a zero‑annotation, out‑of‑the‑box tool that parses SpringBoot controller code and JavaDoc comments to automatically generate HTML API documentation, offering quick setup, client model export, and various features that simplify backend documentation workflows.
This guide introduces the sa‑plus framework—a SpringBoot‑based rapid‑development scaffold with an integrated code generator that can automatically produce backend, frontend, and API documentation code from database tables, and walks through its architecture, technology stack, module structure, quick start steps, and code‑generation features.
This article explains how to discover the built‑in Tomcat dependency in a SpringBoot project, add the appropriate Maven dependency, create a servlet, configure an embedded Tomcat programmatically with Java, and run the application without any external web.xml or server installation.
This article introduces a SpringBoot-based service that leverages OpenOffice to upload, convert (DOC/DOCX/XLS/PPT to PDF or HTML), and preview files directly in the browser, detailing built‑in features, configuration settings, and sample controller code for seamless integration.
RabbitMQ is an open‑source AMQP broker that enables asynchronous, reliable messaging through exchanges, queues, and bindings, and can be quickly deployed with Docker; SpringBoot integration uses the amqp starter, configuration properties, AmqpAdmin for programmatic setup, RabbitTemplate for sending, and @RabbitListener for consuming messages, even converting JSON payloads to POJOs.
This article explains how Spring Boot's spring-boot-maven-plugin creates an executable JAR, details the internal JAR layout, the role of the JarLauncher and custom class loader, and walks through the launch process and related source code.
This article introduces the open‑source WeChat mini‑program mall (Java version), detailing its technical stack, development plan, project structure, core features such as member and order management, SMS service integration, and step‑by‑step installation and deployment instructions for both backend and frontend components.
This guide walks you through integrating the lightweight Sa-Token framework into a SpringBoot project, covering dependency setup, configuration, login, role and permission checks, as well as global exception handling, with complete code examples and practical screenshots.
This article evaluates three ways to insert records into a SQL Server database—repeated single inserts, XML‑concatenated SQL, and batch processing—under SpringBoot, presents performance tests, and recommends the most suitable approach based on data volume and code simplicity.
This tutorial explains why a consistent response wrapper is needed in SpringBoot, shows how to define a standard JSON format with status, message and data fields, and demonstrates using ResponseBodyAdvice and a global exception handler to automatically wrap successful and error results.
This guide walks you through installing kkFileView on Windows and Linux, integrating it with MinIO for online file preview, configuring Docker containers, and customizing settings such as watermarks, providing step‑by‑step instructions and code snippets for a seamless preview service.
This article provides a comprehensive tutorial on preparing the development environment, configuring backend and frontend components, and launching a Jeecg‑boot powered logistics warehouse management system built with SpringBoot, Vue, MySQL, Redis, and related tools.
This article demonstrates how to implement global exception handling in a SpringBoot project, covering environment setup, Maven dependencies, custom error interfaces, enums, exception classes, response wrappers, and controller advice, along with testing via Postman to verify handling of custom, null pointer, and generic exceptions.
This tutorial walks through installing Keycloak via Docker, exploring its admin console, configuring realms, users, and clients, and demonstrates both authorization code and password grant flows before integrating Keycloak with a SpringBoot application to protect APIs using OAuth2.
This article explains how to configure Spring Boot scheduled tasks, compare serial and parallel execution using @Async, create custom and global thread pools, and handle asynchronous exceptions, providing complete code examples and practical observations.
Learn how to create a custom SpringBoot annotation that supports ${…} placeholder expressions by adding AspectJ dependencies, defining the annotation, implementing an AOP aspect that resolves placeholders via EnvironmentAware, storing the result in a ThreadLocal, and using it in a service and controller.
This article explains how to secure a SpringBoot web application by creating a login interceptor with the HandlerInterceptor interface, registering it via WebMvcConfigurer, managing user sessions, and demonstrates the complete code and verification steps to ensure authenticated access.
This article explains the principles of Single Sign‑On using OAuth2.0, illustrates the flow with a real‑world analogy, and provides a complete SpringBoot implementation for both the authorization server and client, including role‑based permission control and microservice integration.
This article explains how SpringBoot launches an embedded Tomcat server by walking through the main method, the SpringApplication.run workflow, context creation and refresh, and the internal Tomcat components such as Connector, Engine, Host, Context, and Wrapper, illustrated with code snippets and diagrams.
This article provides a step‑by‑step tutorial on building a DevOps pipeline that integrates Docker, Jenkins, GitLab, Maven, and SpringBoot, covering environment setup on CentOS, Maven pom configuration, Dockerfile creation, shell scripting for image building, multi‑machine deployment, and practical Jenkins job configuration.
This article explains the inner workings of Spring Cloud's RefreshScope, detailing its source code, registration process, refresh endpoint activation, event-driven refresh mechanism, and how beans annotated with @RefreshScope or @ConfigurationProperties are dynamically reloaded without restarting the application.
This article demonstrates how to create a custom @AccessLimit annotation in Spring Boot, implement a rate‑limiting interceptor using Redis, register the interceptor, and apply the annotation to controller methods to restrict request frequency, with full Java code examples.
This article introduces Spring Cache as a framework‑agnostic caching abstraction that eliminates manual cache code, explains its core concepts, annotations, configuration options, and demonstrates practical usage with Redis and custom key, condition, and eviction strategies in Spring Boot applications.
This article introduces Caffeine Cache, explains its W‑TinyLFU eviction algorithm, compares it with Guava, and provides detailed usage examples—including manual, synchronous, and asynchronous loading, eviction policies, Spring Boot integration, annotations, and configuration snippets—for building high‑performance backend caches.
This guide demonstrates how to add a custom AOP‑based caching layer to a SpringBoot application, using Redis to store frequently queried MySQL table data, defining @AopCacheEnable and @AopCacheEvict annotations, implementing an aspect, handling key generation, expiration, and cache eviction on CRUD operations.
This article explores the quirks and advanced features of YAML configuration in SpringBoot, covering string handling, numbers, dictionaries, objects, lists, special data types, and complex key syntax, while providing practical code examples and debugging tips to help Java developers avoid common pitfalls.
This article walks through designing and implementing a Java-based stock trading monitoring system, covering strategy overview, architecture with SpringBoot, data collection, notification services, code structure, deployment steps, and sample outputs, enabling readers to build low‑frequency grid and intraday T‑strategies themselves.
The article analyzes a Spring Boot transaction issue where a @Transactional method called from another non‑transactional method fails to roll back, explains the underlying propagation and proxy mechanisms, and presents two practical solutions—including using the bean’s proxy via AopContext with exposeProxy enabled—to ensure proper rollback.
This article outlines the design, deployment architecture, technology stack, and core features of a lightweight, open‑source file storage system built with modern front‑end and micro‑service back‑end technologies, offering file management, sharing, and distributed storage capabilities.
This article provides a step‑by‑step guide to integrating GitHub and QQ third‑party OAuth2 login in a Spring Boot backend, covering app registration, required URLs, state handling to prevent CSRF, and complete Java code for authorization, token exchange, and user info retrieval.
This article provides a concise reference of common SpringBoot and Spring Cloud annotations, JPA entity mappings, global exception handling techniques, and related code examples, helping Java backend developers quickly understand and apply these components in their projects.
The article shares a developer's post‑interview reflections covering self‑introduction, Spring ecosystem usage, Nacos vs Eureka service discovery, SpringBoot startup mechanics, design patterns, Linux commands, Redis operations, Excel POI handling, SQL optimization techniques, and other practical interview questions.
This article explains Spring's Lifecycle and SmartLifecycle interfaces, shows how to implement custom beans that react to container start and stop events, provides complete code examples, and demonstrates the automatic startup and ordered shutdown behavior of SmartLifecycle in a Spring Boot application.
This article walks through the design of a flash‑sale system, starting with a simple SpringBoot‑MyBatis implementation, then addressing overselling with pessimistic and optimistic locks, applying rate‑limiting algorithms, time‑window controls, interface hiding, frequency limits, and a suite of production‑grade optimizations such as CDN, Nginx load balancing, Redis caching, message queues, and short‑URL handling.
This guide walks through creating a SpringBoot multi‑module project integrated with MyBatis and Shiro, covering Maven module setup, dependency versions, bean scanning nuances, unit‑test annotations, custom Realm configuration, common pitfalls, and provides a demo repository for reference.
This tutorial explains how to replace traditional REST APIs with GraphQL by building a Spring Boot application, defining Java entities, writing GraphQL schema, implementing query resolvers, configuring the endpoint, and testing queries using tools like Altair.
This guide introduces Erupt, a low‑code full‑stack Java framework that lets you create enterprise‑level backend management systems without writing any front‑end code, covering installation, SpringBoot integration, CRUD generation, extended modules like scheduling, code generation, monitoring, NoSQL support, and online API development.
This article presents a complete logistics management system case study, covering business requirements, technology stack selection, front‑end and back‑end architecture, core modules such as bill management, receipt handling, vehicle dispatch, and includes full Java code snippets for key operations.
This article explains how to set up SpringBoot 1.5.17 with Maven, define custom error interfaces, enums, and exception classes, implement a global @ControllerAdvice handler, and verify the behavior through Postman tests for various CRUD endpoints, demonstrating unified error responses.
This article introduces the open‑source Java‑based WeChat mini‑program mall, detailing its development plan, technology stack, project structure, core features, installation steps, configuration requirements, and visual page previews for developers interested in building or customizing the solution.
This article explains what CORS is, shows the typical browser error caused by missing CORS headers, and provides step‑by‑step SpringBoot configuration and filter code to enable cross‑origin requests and control filter execution order for reliable backend support.
This article explains three typical situations in which Spring's @Transactional annotation becomes ineffective—non‑public methods, internal self‑calls, and caught exceptions—illustrates each case with runnable code examples, and dives into the underlying AOP and transaction‑management source code to show why the proxy logic is bypassed.
This article demonstrates how to configure Spring Boot @Scheduled tasks for both serial and parallel execution, introduces @Async for asynchronous processing, shows how to define custom local and global thread pools, and explains exception handling for asynchronous tasks, providing complete code examples.
The article analyzes three typical situations—non‑public methods, internal self‑calls, and caught exceptions—that cause Spring's @Transactional annotation to be ineffective, explains the underlying proxy and AOP mechanisms, and provides Java code samples and test cases to illustrate each case.
This article demonstrates how to set up global exception handling in a SpringBoot application by preparing the development environment, adding Maven dependencies, defining a base error interface, custom enums, exception classes, a unified response body, and a controller advice that captures business, null‑pointer, and generic exceptions, followed by testing the implementation with Postman.
This article demonstrates how to automatically encrypt sensitive fields such as ID numbers and phone numbers before storing them in a database and decrypt them after retrieval by using Spring Boot, MyBatis plugins, and custom annotations, eliminating manual encryption logic in business code.
This article introduces the Gradle Docker plugin, shows how to configure it for a SpringBoot project, demonstrates building and pushing Docker images directly from Gradle, and compares the build speed with Maven, highlighting the simplicity and speed gains.
The article dissects Spring Boot’s @SpringBootApplication annotation, revealing it as a composite of seven meta‑annotations—including @SpringBootConfiguration, @EnableAutoConfiguration and @ComponentScan—and explains the underlying registrar, import selector, metadata loading, and exclusion mechanisms that together drive Spring Boot’s automatic configuration process.
This article presents nine practical MyBatis techniques—including pagination, preset column selection, one‑to‑many and one‑to‑one associations, foreach‑in queries, dynamic where clauses, choose/otherwise logic, hidden _parameter usage, and dynamic set updates—illustrated with SpringBoot and MySQL code examples.
This tutorial explains how to set up a Spring Boot project with Elasticsearch 6.2.1, configure RestHighLevelClient and RestClient beans, define ES host settings, and perform index creation, deletion, pagination, various query types, sorting, and highlighting through the Java API.
This article explains the principle of reliable message eventual consistency using Spring Boot 2.3.9 and RocketMQ 4.8.0, detailing the transaction flow, broker handling of commit/rollback, project structure, code implementation for producers and consumers, and testing procedures.
This article provides a step‑by‑step tutorial on using MyBatis‑Plus with Spring Boot, covering database creation, table definition, Maven dependencies, entity and mapper setup, CRUD operations, automatic field filling, optimistic locking, pagination, logical deletion, performance monitoring, query wrappers, and code generation, all illustrated with complete code examples.
This tutorial walks you through creating a Spring Boot project, adding Elasticsearch 6.2.1 dependencies, configuring a RestHighLevelClient bean, setting up host properties, and performing core index operations, pagination, various query types, sorting, filtering, and highlighting using both DSL JSON and Java APIs.
This article introduces JetCache, a Java caching library that offers powerful annotations, two‑level (local and remote) caching, TTL support, and easy configuration, and demonstrates its quick start, usage in Spring Boot, unit testing, and cache statistics.
This article walks through building a WebSSH solution from scratch using Spring Boot for the backend, WebSocket for real‑time communication, JSch for SSH handling, and xterm.js on the frontend to render a terminal‑like interface, complete with code examples and deployment tips.
This article describes how the architecture team packages a unified log4j2.xml into a common JAR, uses sys system variables for customizable parameters, and maps SpringBoot application.yml settings to those variables via a custom EnvironmentPostProcessor, enabling developers to configure logging with minimal effort.
This guide demonstrates how to integrate ZXing into a SpringBoot backend to generate QR code images, expose them via a REST endpoint, and display the QR codes in a Vue front‑end dialog by fetching the image as a blob and rendering it with Element UI components.
This article explains how to add a custom banner.txt to a SpringBoot project, lists several online ASCII‑art generators for banner creation, and provides step‑by‑step instructions for installing and configuring the JetBrains agent.jar to activate IntelliJ IDEA licenses.
JApiDocs is a plug‑and‑play SpringBoot tool that automatically generates HTML API documentation and client models without extra annotations, offering quick setup, code‑as‑doc, multi‑platform support, and customizable features to streamline backend development workflows.
This article explains how to integrate RabbitMQ into a Spring Boot application, covering dependency setup, connection configuration, message production and consumption, handling complex JSON messages, and ensuring both sending and receiving reliability through publisher confirms, return callbacks, and consumer acknowledgements.
