Learn how to package a Spring Boot application into a Docker image using three Maven plugins—spring-boot-maven-plugin's build-image, Google's jib-maven-plugin, and the dockerfile-maven-plugin—complete with setup steps, command examples, and tips for container testing.
This article explains the inner workings of Spring Boot’s @SpringBootApplication annotation, the loading of auto‑configuration classes from META‑INF/spring.factories, the refresh of the application context, the creation of the embedded Tomcat server, and demonstrates how to create a custom starter with configuration properties.
The article walks through creating a test management platform using Spring Boot, mockJS, and custom MyBatis TypeHandlers to store public data as JSON arrays, detailing the data model, handler implementations, and full mapper XML configuration for CRUD operations.
This article explains how to integrate the Quartz scheduler into a Spring Boot application to create, update, delete, pause, and resume dynamic scheduled jobs without restarting the service, covering Quartz fundamentals, storage options, configuration steps, job implementation, and deployment considerations.
Spring Boot’s 2.3.0 release marked a major shift from Maven to Gradle, driven by the need to reduce build times, leverage incremental and parallel builds, and improve CI efficiency, resulting in average build times dropping from over an hour to just over nine minutes.
This guide walks through installing the RabbitMQ delayed‑message‑exchange plugin, configuring it in a Spring Boot application, and building Java components to send and receive delayed order‑cancellation messages, comparing the plugin approach with dead‑letter queues and providing complete code snippets and deployment steps.
Spring Boot parses @SpringBootApplication by combining @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan, then processes @Import, @Conditional, and bean post‑processors, uses SpringFactoriesLoader for auto‑configuration, and follows an eight‑step configuration‑class parsing flow to register beans during startup.
This article demonstrates how to set up a Redis cluster, connect it with Spring Boot 2.3 using Lettuce, simulate a node failure, and configure Spring Boot's adaptive topology refresh to achieve automatic failover without application downtime.
This article explains how to integrate RocketMQ with Spring Boot to implement peak‑shaving, detailing core components, consumer pull parameters, one‑way sending, batch consumption configuration, and practical performance testing with code examples and deployment tips.
This article provides a comprehensive tutorial on how to integrate Dataway—a DataQL‑based API configuration tool—into a Spring Boot project, covering dependency setup, configuration properties, datasource wiring, Hasor module creation, enabling Hasor, and using the Dataway UI to create and publish APIs without writing any Java code.
This article explains how to enable and use Spring Boot's graceful shutdown feature in version 2.3, including configuration of the embedded web server and Actuator, and also provides a custom solution for older Spring Boot releases to achieve smooth termination of ongoing requests.
This article explains why graceful shutdown is essential for Spring Boot and Spring Cloud applications, outlines key precautions, shows how Spring Boot 2.3 adds built‑in support, and provides configuration steps, code examples, and container‑specific behaviors to ensure clean service termination.
Through a 30‑minute Apache JMeter load test on the Spring Boot Petclinic sample, we captured heap dumps and used HeapHero to reveal that 65% of memory is wasted due to string duplication, inefficient collections, and poor initialization, offering concrete code‑level recommendations to improve memory efficiency.
After moving a project to Spring Boot, the system reported unusually high swap usage despite a 4 GB heap, prompting a detailed investigation using JVM native‑memory tracking, pmap, gperftools, strace, and GDB, which ultimately identified Spring Boot’s JAR scanning and glibc memory arenas as the root causes and led to a configuration fix and an upgrade to resolve the off‑heap memory leak.
This article explains how MyBatis-Plus adds data-security protection to Spring Boot applications by encrypting datasource and property file values, details the custom EnvironmentPostProcessor implementation, loading mechanisms, and offers extension ideas and alternatives such as jasypt-spring-boot-starter.
This article explains the purpose, differences, default settings, and practical verification of MyBatis first‑level and second‑level caches in Spring Boot, showing how cache scope, transaction boundaries, and mapper configuration affect cache behavior and performance.
This article explains how Spring Boot 2.3 implements graceful shutdown, showing configuration properties, code examples, container-specific behaviors, and how to trigger shutdown via the actuator endpoint, while also noting differences among Tomcat, Reactor Netty, and Undertow.
This tutorial walks through building a Spring Boot application that uses Alibaba's Dubbo framework, covering the RPC workflow, project structure, Maven dependencies, Spring Boot and XML configurations, service interface definition, provider and consumer implementations, and a RESTful endpoint for testing.
This article details a lightweight transactional message solution for microservices that stores pending messages in a local MySQL table, defers RabbitMQ publishing until after transaction commit, and includes compensation logic with exponential back‑off to ensure reliable asynchronous communication.
This article explains how RocketMQ’s decoupling, asynchronous and peak‑shaving features can be applied in a Spring Boot project to buffer massive like‑click traffic, reduce database pressure, and dynamically tune consumer pull parameters for optimal throughput.
This article provides a step‑by‑step guide to using Google's open‑source gRPC framework in Java, covering Protocol Buffers service definitions, Maven configuration, Spring Boot server implementation, client creation, and unit testing to demonstrate cross‑language RPC communication.
This article demonstrates how to integrate Redisson with Spring Boot to create Redis‑based distributed locks, covering Maven dependencies, YAML configuration, a Redisson configuration class, utility methods for locking and unlocking, and a sample controller that simulates concurrent access to verify lock behavior.
This article explains why traditional @ControllerAdvice fails in Spring Cloud Gateway, introduces the built‑in ExceptionHandlingWebHandler and DefaultErrorWebExceptionHandler, and shows how to override them with a custom GlobalExceptionConfiguration for robust reactive error handling.
This guide explains how to reduce Docker image size by separating Spring Boot application classes from third‑party libraries into distinct layers, using the Maven plugin and layertools, resulting in rebuilds that change only a few kilobytes instead of megabytes.
This article explains common API security mechanisms such as token, timestamp, signature, and anti‑replay techniques, demonstrates how to prevent duplicate submissions, and provides complete Java Spring Boot code examples including interceptors, Redis configuration, and utility classes for secure API design.
Spring Boot 2.3 introduces major core component upgrades—including Spring Data Neumann, Spring HATEOAS 1.1, and Spring Security 5.3—adds Java 14 compatibility while retaining Java 8/11 support, enhances Docker integration with Cloud Native Buildpacks and layered jars, and provides graceful shutdown and health‑probe features for improved application reliability.
This article lists the Maven dependencies for Spring Boot Admin 2.2.3 and outlines the upgrade changes, including Spring Boot 2.2.7, Spring Cloud Hoxton.SR4, Portuguese language support, customizable pages, language set extensions, InstanceEvents deserialization improvements, and fixes for custom CSS/JS loading issues.
Discover Mica, a lightweight Java microservice core built on Spring Boot and Spring Cloud, its dependencies, versioning scheme, ip2region integration, configuration tips, and usage examples, providing a streamlined foundation for cloud-native applications.
This tutorial walks through integrating Dataway into a Spring Boot project, covering dependency setup, Dataway configuration, database table creation, data source integration, Hasor module registration, enabling Hasor, running the application, accessing the UI, and creating APIs using SQL or DataQL, all without writing custom code.
This tutorial walks through installing the EasyCode and Lombok plugins, creating a MySQL table, configuring IDEA database connections, generating entity, DAO, service, controller, and mapper code for a Spring Boot project, and setting up the required Maven dependencies and application.yml configuration.
Version 2.x of the open‑source Mica framework, built on Java 8 and Spring Boot/Cloud, introduces a streamlined core, reduced dependencies, enhanced HTTP, captcha, Redis rate‑limiting, job starter, and numerous utility upgrades, while outlining upcoming module releases and providing documentation links.
This article explores various strategies for controlling execution timing in Java backend services, comparing Thread.sleep, Timer, and Redis-based expiration techniques, and provides practical code examples and configuration steps for integrating Redis with Spring Boot to achieve reliable delayed processing.
Spring Boot provides a set of conditional annotations such as @ConditionalOnBean, @ConditionalOnClass, and @ConditionalOnMissingBean that evaluate classpath presence, bean existence, and other criteria at runtime, allowing auto‑configuration classes to be registered only when their required conditions are satisfied, with detailed implementation details and activation mechanisms explained.
This guide explains how to embed Dataway—a DataQL‑based API configuration tool—into a Spring Boot project by adding Hasor dependencies, configuring Dataway properties, setting up a MySQL datasource, wiring Hasor modules, enabling Hasor annotations, and finally creating and publishing a simple API without writing any Java controller code.
This article explains what Spring Boot application starters are, describes how they simplify adding modules like Tomcat and Redis through Maven dependencies, and provides a detailed list of all 44 available starters with their primary functions for backend Java development.
This article explains how to implement automatic idempotency for Spring Boot APIs using Redis, a custom @AutoIdempotent annotation, token generation and verification, and an interceptor, providing step‑by‑step code examples and a testing workflow to prevent duplicate operations.
This article details a step‑by‑step investigation of excessive native memory usage in a Spring Boot service, explaining how JVM tools, system tracers, and custom allocators revealed that the default MCC package scanner and Inflater implementation caused a hidden memory leak that was fixed by configuring scan paths and upgrading Spring Boot.
Chinese developers can dramatically improve Maven dependency resolution and Spring Boot project setup speed by configuring Alibaba’s domestic Maven mirror and using the Alibaba-hosted Spring Initializr, which offers faster, stable access to libraries and a convenient UI for generating starter projects.
The article presents a comprehensive overview of the Home (ZhiJia) distributed task scheduling system, detailing its background, advantages, technology stack, architecture, core concepts, module responsibilities, IDE integration, and future improvement plans for big‑data processing workflows.
This article explains the distinctions between Spring and Spring Boot, covering their core concepts, Maven dependencies, MVC and template engine configurations, security setup, bootstrapping mechanisms, packaging options, and deployment strategies, with detailed code examples throughout.
This guide explains why Spring Boot JARs become bulky when packaged with many dependencies, and provides a step‑by‑step method—including Maven commands and configuration changes—to strip out unnecessary lib files, dramatically reducing the final artifact size for smoother production deployments.
This article shares practical techniques for handling date and time in Spring Boot projects, including the pitfalls of using SimpleDateFormat, the benefits of @JsonFormat, and two approaches to global configuration that streamline formatting for both java.util.Date and java.time types.
This article explains how Spring Boot’s spring-boot-maven-plugin packages an application into an executable JAR, details the internal jar layout, the role of the MANIFEST.MF and JarLauncher, and walks through the custom class‑loading mechanism that launches the Spring application.
This article provides a comprehensive overview of Spring Cloud, covering why it should be learned, its core concepts, design goals, advantages and disadvantages, version compatibility with Spring Boot, major sub‑projects, configuration management, service discovery, load balancing, circuit breaking, Feign, and practical code examples for microservice development.
This article provides an extensive Spring Boot tutorial covering its core concepts, annotations, configuration methods, security mechanisms, monitoring tools, third‑party integrations, deployment options, and common interview questions, offering Java developers a complete reference for building and maintaining modern backend applications.
This article explains Spring Boot’s conditional annotations, such as @ConditionalOnClass and @ConditionalOnBean, detailing their definitions, underlying Condition interfaces, evaluation process, and activation mechanism, with code examples and diagrams illustrating how beans are conditionally loaded at runtime.
This article demonstrates step‑by‑step how to construct a clean and standardized backend API in Spring Boot by introducing required dependencies, using Validator for request parameter checks, applying global exception handling, defining custom exceptions, and implementing a unified response format for both success and error cases.
This article explains how to implement automatic API idempotency in Spring Boot using Redis for token storage, custom annotations, and interceptor configuration, covering token generation, validation, Redis service utilities, and testing with Postman to prevent duplicate operations and ensure data consistency.
The mica-auto component of the Mica Spring Cloud framework provides a set of tools that automatically generate essential Spring Boot starter files such as spring.factories, spring‑devtools.properties, and Java SPI configurations, simplifying multi‑module backend projects and supporting annotations like @AutoService for seamless integration.
This guide walks through adding MyBatis-Plus to a Spring Boot project, covering Maven dependencies, datasource configuration, mapper scanning, pagination plugin setup, entity and mapper definitions, and a unit test that demonstrates pagination and the rich CRUD methods provided by BaseMapper.
This guide shows Java developers how to accelerate dependency fetching by configuring Alibaba's Maven mirror and how to speed up Spring Boot project creation using the domestic Spring Initializr hosted at start.aliyun.com, complete with step‑by‑step instructions and code snippets.
This article explains how Spring Boot's spring-boot-maven-plugin creates an executable JAR, details its internal structure, the role of JarLauncher and the Spring Boot Loader, and shows how the custom LaunchedURLClassLoader loads classes from embedded dependencies.
This guide shows how to integrate the MyBatis Generator Maven plugin into a Spring Boot project, configure generatorConfig.xml, run the plugin to auto‑create entity, mapper, and XML files from database tables, and use the generated code in a service layer.
This article investigates why @Configuration classes imported via @Import in a Spring Boot Dubbo starter fail to inject @Value properties and execute @PostConstruct, tracing the issue to early bean creation by a FactoryBean and offering practical work‑arounds.
This article compiles sixteen practical Spring Boot best‑practice recommendations—ranging from custom BOM management and auto‑configuration to test slicing and externalized configuration—drawn from years of professional experience and expert insights, to help developers build cleaner, more maintainable micro‑service applications.
This tutorial walks you through integrating MyBatis XML configuration into a Spring Boot 2.x project, covering Maven dependencies, application properties, mapper XML files, entity and mapper definitions, service implementation, and unit testing with full code examples.
This tutorial walks through what Spring Boot Actuator is, how to quickly create a demo project, configure endpoint exposure, explore essential endpoints such as health, metrics, loggers, and shutdown, and secure them with Spring Security, providing code snippets and configuration examples.
This tutorial walks through Micrometer's metric types, how to register them with MeterRegistry, apply tags and naming conventions, and integrate the framework into Spring Boot applications with Actuator, Prometheus scraping, and Grafana visualization for comprehensive backend monitoring.
This article compares Spring and Spring Boot, explains their core concepts, walks through MVC, template engine, and security configurations, shows Maven and Gradle dependency setups, and details how to package and deploy applications with code examples.
This guide presents three concrete methods—property‑based toggling, profile‑driven configuration, and conditional resource handling—to safely prevent Swagger2 from being exposed in production environments of Spring Boot applications, helping you keep API documentation internal while maintaining flexibility across dev and test stages.
This article provides a detailed overview of common Spring Boot, Spring MVC, and JPA annotations—including their purposes, usage patterns, and code examples—helping developers understand how to configure, map, and manage beans, controllers, and persistence in Java backend applications.
This article details a step‑by‑step investigation of unusually high native memory consumption in a Spring Boot service, covering JVM configuration, system‑level diagnostics with jcmd, pmap, gperftools, strace, GDB, and jstack, and explains how the MCC component’s default package scanning caused the leak and how configuring scan paths or upgrading Spring Boot resolved the issue.
This guide introduces EasyExcel, a Java library for memory‑efficient Excel read/write, shows how to add the Spring Boot starter dependency, and demonstrates basic, custom, multi‑sheet, password‑protected, and template‑based export techniques using the @ResponseExcel annotation.
This article provides a comprehensive overview of Spring Boot, Spring MVC, and JPA annotations, explaining their purposes, usage, and interactions, and includes practical code examples for each annotation to help developers quickly apply them in real projects.
A Spring Boot project migrated to the MDP framework exhibited excessive native memory usage, leading to swap errors; the article details step‑by‑step investigation using JVM tools, system utilities, and custom allocators to pinpoint and resolve the hidden native memory leak caused by unchecked JAR scanning and glibc memory pools.
This guide introduces Pig4Cloud’s custom Spring Initializr, explains why it outperforms start.spring.io and start.aliyun.com, details usage steps, highlights enhancements such as .gitignore, .editorconfig, yml defaults, Maven test inclusion, and provides Docker deployment instructions for rapid backend project setup.
This article explains how Alibaba built start.aliyun.com on top of Spring Initializr, adding component demos, configuration, version management, and custom extensions to streamline Spring Boot project generation for Java developers.
This article explains how to configure Spring Boot interceptors using both URL‑pattern matching and custom annotations, provides the necessary Java code for the interceptors and constant definitions, and shows how to register them in a @Configuration class for comprehensive request handling.
This article explains how Alibaba’s start.aliyun.com extends Spring Initializr to provide ready‑to‑use demos, configuration samples and multi‑component integration, covering background, core features, basic usage, YAML configuration, dependency management, version ranges, BOM handling, caching, demo code generation and the underlying startup and generation phases of the framework.
This tutorial shows how to integrate Spring Security into a Spring Boot project that already uses Swagger2, configuring dependencies, application properties, Swagger and security classes so that the generated API documentation is protected by a login page without affecting other business endpoints.
This article explains how Alibaba’s start.aliyun.com extends Spring Initializr to provide ready‑made demos, configuration samples, and component integration for Spring Boot, covering background, basic usage, configuration of dependencies, version ranges, BOM management, caching, and advanced customization, with full code examples and diagrams.
Learn step‑by‑step how to set up multiple MySQL data sources in Spring Boot 2.2.2, configure corresponding JdbcTemplate beans, define entity and service layers, and run unit tests, with full Maven dependencies, property settings, Java configuration, and SQL DDL examples.
Learn how to resolve performance bottlenecks in a Spring‑based mall project by caching user and permission data in Redis, adding cache logic with RedisTemplate, and using AOP to gracefully handle Redis failures, ensuring stable authentication even when the cache is unavailable.
When deploying a Spring Boot application on CentOS, MySQL connections may throw CommunicationsException or SSLHandshakeException due to JDK mismatches, socket path errors, SSL settings, timeout defaults, or configuration issues, and this guide explains each cause and provides concrete fixes.
This comprehensive guide covers essential Spring Boot concepts—including its definition, advantages, auto‑configuration, DevTools hot‑reloading, starter projects, embedded servers, Actuator monitoring, YAML configuration, MyBatis integration, WAR packaging, and common pitfalls—providing concise answers to 40+ interview‑style questions for backend developers.
This article explains how to define a unified JSON response format for Spring Boot APIs, implement a Result class with chainable methods, set up global exception handling using @ControllerAdvice, and configure Logback for comprehensive log collection across different environments.
This article explains the concept of multi‑tenancy, compares three data‑isolation strategies, and demonstrates how to configure MyBatis‑Plus, Spring Boot, and H2 to achieve transparent tenant filtering and automatic tenant‑ID handling using a custom SQL parser and context component.
A Spring Boot channel service suffered an unexplained ~100 ms delay per request, which was traced through network checks, curl timings, and deep Arthas analysis to reveal a Tomcat‑embed bug caused by repeated loading of Swagger static resources, ultimately fixed by upgrading Tomcat.
This article introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering a ready‑to‑use project structure, unified response handling, exception processing, code generation tools, and simple signature authentication to accelerate backend development.
This tutorial guides you through creating a basic Spring Boot calculator app, adding JUnit 4 tests, then fully migrating the project to JUnit 5 by updating dependencies, rewriting test annotations, and leveraging new JUnit 5 features such as @ExtendWith and @DisplayName.
This tutorial walks through designing and implementing a Spring Boot‑based SaaS platform that supports multiple tenants by dynamically switching databases or schemas, covering architecture overview, tenant identification, data‑source routing, Maven setup, entity and repository definitions, interceptor configuration, and a simple login test.
This article explains what Swagger is, why it benefits backend and frontend teams, and provides a step‑by‑step guide to integrate Swagger 2.7.0 into a Spring Boot project, including dependencies, configuration, annotations, controller examples, testing tips, and deployment considerations.
This guide shows how to add Spring Boot DevTools, configure Maven and IntelliJ IDEA, and use both manual and automatic hot‑deployment techniques—including registry tweaks and template cache settings—to achieve instant code changes without restarting the application.
This article walks through the complete source‑code analysis of Spring Cloud Ribbon, covering dependency setup, RestTemplate integration, interceptor creation, load‑balancer execution flow, ILoadBalancer retrieval, server list management, ping strategies, and eager‑loading configuration to reveal how client‑side load balancing is implemented in Spring Cloud.
Learn how to ensure API idempotency in Spring Boot applications by leveraging Redis for token management, creating a custom @AutoIdempotent annotation, configuring interceptors, and handling token creation and validation to prevent duplicate submissions and maintain data integrity.
This tutorial explains how to integrate MyBatis into a Spring Boot project, covering the framework's basics, Maven dependencies, annotation‑based CRUD operations, XML‑based mappings, entity definitions, controller implementations, Swagger testing, and Druid monitoring, with complete code examples and download links.
Learn how to replace verbose JDBC code with Spring’s JdbcTemplate by first understanding JDBC basics, then adding the necessary Maven dependencies, configuring a connection pool, defining entity and repository classes, and writing unit tests, all illustrated with complete Java examples.
This tutorial explains how to integrate JDBC into a Spring Boot project, covering Maven dependencies, MySQL driver setup, application.yml datasource configuration, Spring Boot's auto‑configuration mechanism, JdbcTemplate usage, Swagger documentation, CRUD endpoint implementation, and solutions to typical connection errors.
This article explains what Druid is, how to add the Druid dependency, configure it in Spring Boot's application.yml, set up monitoring with a custom DruidConfig class, and resolve common errors such as property binding failures and login issues.
This article provides a comprehensive overview of Spring Boot, Spring MVC, and JPA annotations, explaining their purposes, usage patterns, and example code snippets, while also covering global exception handling with @ControllerAdvice and @ExceptionHandler for robust backend development.
This article explains how to efficiently build, push, and pull Docker images for Spring Boot applications by leveraging Docker's layered cache, separating dependency JARs from the application JAR, and measuring the performance improvements in a Kubernetes micro‑service environment.
This guide explains how to integrate JDBC into a Spring Boot project, covering Maven dependencies, datasource configuration, Spring Boot's auto‑configuration mechanism, JdbcTemplate usage, Swagger setup for API testing, CRUD examples on a MySQL department table, and solutions to typical connection errors.
This article explains how to implement asynchronous request handling and asynchronous method invocation in Spring Boot, covering servlet‑based async, Callable, WebAsyncTask, DeferredResult, @Async usage, common pitfalls, proxy solutions, and the differences between async requests and async calls.
This guide walks through integrating MyBatis into a Spring Boot project, covering dependency setup, MySQL configuration, entity and mapper creation, CRUD annotations, and unit testing to verify database operations, including transaction management and result mapping.
This article demonstrates how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, using AOP to switch between master and slave databases, and integrating the routing data source with MyBatis for transparent database operations.
The 2020 JRebel Java technology report reveals that Java 8 dominates usage, Tomcat remains the leading application server, Spring Boot is the preferred framework, IntelliJ IDEA tops IDE preferences, PostgreSQL and Oracle lead databases, Gradle slightly outpaces Maven, Docker is the most common container tool, and microservices continue to shape technology choices.
This tutorial walks you through installing the EasyCode IntelliJ plugin, setting up a MySQL database, configuring a Spring Boot project, adding necessary Maven dependencies and YAML settings, and using EasyCode to automatically generate entity, DAO, service, controller, and mapper code without manual coding.
This guide explains how to install Redis, configure it within a Spring Boot application, define custom Redis helper interfaces and implementations, and demonstrates testing and practical usage of caching annotations for efficient data retrieval.
This tutorial demonstrates how to add Baidu's ECharts JavaScript visualization library to a Spring Boot backend, covering project setup, Maven dependencies, controller creation, Thymeleaf template configuration, and rendering a line chart in the browser.
This article presents ten commonly asked Spring Boot interview questions covering its core advantages, auto‑configuration, embedded servers, distributed transactions, security integrations, REST vs RPC choices, stateless service design, caching annotations, CORS setup, JPA vs Hibernate differences, and the relationship among Spring, Spring Boot, and Spring Cloud.
