This tutorial walks through setting up Spring Cloud microservices using Spring Boot, configuring Eureka for service registration, implementing Ribbon and Feign for client-side load balancing, and configuring high‑availability Eureka clusters, complete with Maven pom.xml, application.yml, and Java code examples.
This article provides a step‑by‑step technical analysis of Spring Boot's startup process, breaking down the creation of SpringApplication, the configuration of application type, initializers, listeners, and the eight phases executed by the run() method, complete with code snippets and diagrams.
MyBatis-Plus (MP) is a non‑intrusive MyBatis enhancement tool that offers a rich set of CRUD features, multi‑database support, code generation, and plugins, and this article explains its key capabilities, architecture diagram, and provides a step‑by‑step quick‑start example with Maven dependencies and sample query code.
Spring Boot 2.4 introduces automatic removal of empty starter dependencies when building executable JARs, reducing size by eliminating unnecessary starter JARs; this guide demonstrates the effect, explains what empty starters are, and shows how to customize JARs for automatic slimming using manifest entries.
This article walks you through setting up Jenkins to clone a Spring Boot project from Gitee, configure JDK, Git, and Maven tools, create a freestyle job with parameterized builds, write shell scripts for stopping and starting the application, and troubleshoot common issues for a fully automated CI/CD pipeline.
This article compares Maven Docker plugins (spotify, fabric8) and Jib, highlights their drawbacks for Spring Boot projects, and shows how Spring Boot 2.4's built‑in docker support simplifies image building and publishing via the spring‑boot‑maven‑plugin.
This tutorial walks through adding Dataway to a Spring Boot project by importing Hasor and Dataway dependencies, configuring Maven, setting Dataway and datasource properties, creating a Hasor module to inject the Spring DataSource, enabling Hasor annotations, launching the application, and finally using the Dataway UI to define and publish SQL or DataQL‑based APIs.
Learn how Spring Boot 2.4 replaces the old CronSequenceGenerator with CronExpression, enabling advanced scheduling features such as built-in macros, last-day-of-month, weekday, and week-of-month semantics, with practical code examples and a reference table of common macros.
This tutorial explains the core concepts of Spring AOP, shows how to integrate AOP in Spring Boot to create custom annotations and interceptors, and provides practical solutions for the common self‑invocation issue that causes AOP advice to be ignored.
Spring Boot 2.4.0 GA, released on November 12, 2020, introduces twelve major updates—including version naming changes, improved configuration handling, new Kubernetes import support, enhanced startup diagnostics, Docker/Buildpack integration, Java 15 compatibility, upgraded dependencies, refined embedded‑DB detection, Logback property revisions, HTTP trace tweaks, Undertow forwarding behavior, and Elasticsearch client adjustments—providing developers with clearer migration paths and richer functionality.
This tutorial walks through preparing the environment, configuring Docker remote access, creating a Spring Boot project in IntelliJ IDEA, setting up Maven and Docker files, building the image, and running the container, demonstrating a complete end‑to‑end Java microservice deployment with Docker.
Spring Boot 2.4.0 has been officially released with full Java 15 support, layered JARs, Docker/Buildpack image building, JUnit 5 adoption, enhanced configuration handling, new startup endpoints, and numerous core dependency upgrades, marking a major step toward cloud‑native applications.
This article explains how to set up separate configuration files for development, testing, and production environments in Spring Boot, how to activate the desired profile via properties or command line, and how to use Maven profiles and resource filtering to package the application accordingly.
This tutorial walks you through preparing the environment, installing Jenkins via Docker, configuring initial settings, integrating JDK, Maven, and Git, adding SSH servers and credentials, creating Maven jobs, and automating builds for Spring Boot applications on both GitHub and GitLab, including multi‑module project handling.
This tutorial explains why a unified JSON format is needed in a Spring Boot project, defines a standard {code, message, data} schema, shows how to create a Result enum and generic wrapper class, and demonstrates global handling with @ResponseResultBody, ResponseBodyAdvice, and @ExceptionHandler for clean, consistent API responses.
This article provides a comprehensive guide on using Swagger for REST API documentation in Spring Boot projects, covering Swagger fundamentals, Springfox introduction, the features of Springfox 3.0.0, compatibility requirements, Maven integration, configuration classes, common annotations, and a complete example with code snippets.
This article introduces Spring Boot as a lightweight Java framework, explains Spring Cloud's microservice components such as Eureka, Zuul, Ribbon, Feign, Hystrix, and Turbine, outlines Spring Cloud Alibaba's features, and describes Nacos as a combined service registry and configuration center for cloud‑native applications.
This article provides a comprehensive guide to configuring Logback in Spring Boot, covering Maven dependencies, SLF4J usage, step‑by‑step XML setup, application.yml integration, controller logging code, Lombok shortcuts, appender types, logger definitions, log levels, rolling policies, filters, and best practices for backend development.
This tutorial walks through creating a Spring Cloud microservices architecture using Spring Boot, Eureka service registry, Ribbon load balancing, and Feign clients, covering project initialization in IntelliJ IDEA, Maven configuration, YAML setup, service implementation, high‑availability Eureka server clustering, and testing the end‑to‑end workflow.
This article walks through the complete process of integrating Swagger 3.0 into a Spring Boot 2.3.5 application, covering dependency setup, the role of springfox‑boot‑starter, custom OpenAPI configuration, API grouping, security schemes, and global request parameters with concrete code examples.
This article walks you through creating a custom Spring Boot starter for SMS services, covering naming conventions, Maven dependencies, configuration properties, auto‑configuration, sender implementations, activation methods, packaging, and usage with practical code examples and diagrams.
This article provides a detailed, hands‑on tutorial for installing the required tools, configuring Nacos and MySQL, cloning the RuoYi-Cloud source, initializing databases, and launching both backend and frontend services so you can run the full microservice system on a local machine.
This guide walks through cloning the RuoYi‑Process repository, configuring the database and application settings, building the project with Spring Boot, and launching the workflow system at http://localhost:8888.
This article explains how to install and configure JRebel for both local and remote hot deployment in Spring Boot projects, compares it with Spring DevTools, provides step‑by‑step setup instructions, and addresses multi‑module deployment pitfalls.
This tutorial walks through creating a Spring Boot service, adding local configuration, moving the configuration to Nacos, integrating Nacos into the service, and enabling dynamic refresh so changes take effect without restarting the application.
This tutorial walks you through creating two Spring Boot microservices, adding Nacos dependencies, configuring discovery, implementing a simple /hello endpoint, and invoking it from a consumer service using RestTemplate and LoadBalancerClient, all with complete code examples.
This tutorial explains Spring Boot's three core annotations—@Configuration, @ComponentScan, and @EnableAutoConfiguration—by showing how Java Config replaces XML, demonstrating bean creation, lifecycle management, component scanning, and auto‑configuration with practical code examples for a Spring application.
This article demonstrates how to implement a dynamic, non‑blocking Quartz scheduler in a Spring Boot application, allowing tasks to be added, paused, resumed, deleted, or triggered instantly without restarting the service, and provides complete code examples and configuration steps.
This article demonstrates how to use Spring Boot AOP to automatically record operation and exception logs by defining log tables, adding the AOP starter dependency, creating a custom @OperLog annotation, implementing an aspect that captures request details and errors, and applying the annotation to controller methods, providing a clean, reusable logging solution for Java backend applications.
The October 2020 Spring Data Ockham (2020.0.0) release introduces a new version‑naming scheme, updates to Spring Data Neo4j, JDBC, R2DBC, Redis, adds RxJava 3 and De‑lombok support, and outlines compatibility notes for Spring Boot 2.4 and Neo4j users.
Spring Framework 5.3 GA, released on October 27, brings JDK 8+ support, new R2DBC capabilities, performance tweaks, enhanced MockMvc and WebFlux features, and is the recommended long‑term upgrade for both 5.x and 4.x users with maintenance through 2024.
Spring Boot 2.3.5, 2.2.11, and 2.1.18 have been released on Maven Central, each bringing dozens of bug fixes, documentation improvements, and dependency upgrades, while the 2.1.x line has reached end‑of‑life and users are urged to migrate to newer versions.
This article provides a step‑by‑step guide to implementing login authentication in Spring Boot, covering both session‑based and JWT‑based approaches, including code for controllers, filters, interceptors, context utilities, and best‑practice considerations for secure and scalable backend development.
This article explains the concept of API idempotency, presents common solutions such as unique indexes, token mechanisms, and distributed locks, and provides a complete Spring Boot implementation using Redis to generate, store, and validate tokens via custom annotations, interceptors, and service classes, including testing and performance verification.
This article explains what remote debugging is, why it is useful, introduces the JPDA architecture, details the JDWP command‑line options such as transport, server, suspend, address, and shows step‑by‑step how to start a Spring Boot service in remote‑debug mode and attach IntelliJ IDEA for debugging.
This article demonstrates how to implement read/write splitting in a Spring Boot application by configuring multiple data sources, using AbstractRoutingDataSource for dynamic routing, and applying AOP and custom annotations to direct read operations to slave databases and write operations to the master, with full Maven and MyBatis setup.
This guide shows how to replace the old springfox-swagger jars with the new Springfox 3.0.0 starter, configure Swagger UI in a Spring Boot project, compare version differences, and integrate Swagger with Spring Security for protected API endpoints.
When starting a Spring Boot application, WARN messages about missing JAR files appear because Tomcat incorrectly scans Manifest Class-Path entries, and the article explains the root cause, debugging steps, and multiple ways to resolve the issue.
This article walks through the fundamentals of JSR‑303 Bean Validation in Spring Boot, explains how to add the starter dependency, lists built‑in constraint annotations, demonstrates simple, group and nested validation, shows how to capture validation errors, and guides you through creating custom constraint annotations and validators with full code examples.
This article explains the fundamental differences between Spring and Spring Boot, covering their core concepts, configuration methods, MVC setup, template engine integration, security configuration, bootstrapping mechanisms, and packaging/deployment options, with detailed code examples for each aspect.
This article explains the concept of idempotency, common causes of duplicate submissions, and presents several practical solutions—including PRG, token validation, local locks using ConcurrentHashMap, and distributed locks with Redis—accompanied by Spring Boot AOP annotations and full code examples.
This guide explains how to use Redis key expiration notifications in a Spring Boot application to automatically close unpaid orders by storing an order‑ID key with a TTL, configuring Redis to emit expiration events, and implementing a listener that updates order status when the key expires.
This article demonstrates how to combine Spring Boot and Netty, define a .proto file, generate Java classes with protoc, configure Maven dependencies, and implement both server and client handlers to exchange binary Protobuf messages with heartbeat and reconnection logic.
This tutorial explains how to configure Spring Boot with a single Druid data source, extend it to multiple dynamic data sources using AbstractRoutingDataSource, and seamlessly integrate MyBatis, including custom annotations, AOP switching, thread‑local isolation, and transaction management for robust multi‑database applications.
This article explains what Druid Monitor and Druid Admin are, why cluster‑level monitoring is needed in microservice architectures, and provides a complete Spring Cloud starter implementation with configuration examples, code snippets, and usage limitations.
This article explains how to choose and integrate Java logging frameworks, use SLF4J with Logback, understand Spring Boot's default logging setup, customize log output, and switch between implementations such as Log4j2, providing practical code snippets and configuration examples.
This guide walks you through every configurable element of IntelliJ IDEA's Project Structure—Modules, SDKs, language level, compiler output, libraries, facets, and artifacts—so you can fine‑tune Spring Boot projects, avoid common pitfalls, and streamline multi‑module development.
SOFABoot, an open‑source framework from Ant Financial built on Spring Boot, enhances microservice development by adding readiness checks, class isolation via SOFAArk, log space isolation, unified middleware integration, and modular development support, helping prevent class conflicts and simplify large‑scale service deployments.
This guide demonstrates how to integrate Spring Boot 2.0.5 with Elasticsearch 5.6.11 by installing Elasticsearch and Kibana, adding the required Maven dependencies, configuring the client via application.yml or Java code, defining @Document‑annotated entities, implementing repository, service and controller layers for CRUD and full‑text search, handling Netty conflicts at startup, and verifying the setup with health, list and search endpoints.
This article explains six key patterns for customizing Spring Boot auto‑configuration, covering how to locate auto‑configuration classes, the role of @Conditionalxxx, @EnableConfigurationProperties, @Import, @AutoConfigurexxx annotations, and the significance of internal static configuration classes, with concrete code examples.
This article creates three MySQL tables with auto‑increment, UUID, and Snowflake‑generated random keys, runs identical insert workloads using Spring Boot and JdbcTemplate, measures performance, compares index structures, discusses the pros and cons of each key type, and concludes with best‑practice recommendations.
This comprehensive Spring Security guide explains core concepts of authentication and access control, details the AuthenticationManager and ProviderManager interfaces, shows how to customize authentication managers, configure authorization with AccessDecisionManager, secure web requests with filter chains, and apply method-level security, including asynchronous contexts.
This article explains the evolution, usage, and customization of Spring Boot's @Conditional annotation, detailing its underlying Condition interface, execution phases, ordering mechanisms, and providing practical code examples for environment-specific bean registration in Spring applications.
This guide shows how to quickly reformat code without opening settings, generate UML class diagrams, view and test Spring Boot endpoint mappings, navigate debugging execution points, and rename methods using IntelliJ IDEA Ultimate shortcuts, enhancing productivity for Java developers.
This article provides a step‑by‑step tutorial on using Sharding-JDBC with Spring Boot to implement horizontal database and table sharding across multiple MySQL instances, including project setup, Maven dependencies, entity and controller code, sharding configuration, and testing via Postman.
This tutorial explains how to install Docker on CentOS, pull a Java base image, create and configure a Spring Boot project, write a Dockerfile, build the image with Maven, run the container with port mapping, and access both console and Log4j2 file logs.
This comprehensive guide explains what Redis is, its data structures and features, demonstrates how to use Redis as a cache in Spring Boot applications, discusses cache eviction policies, persistence mechanisms, replication, Sentinel high‑availability, and performance characteristics while also covering common interview questions such as cache snowball, penetration and breakdown.
This article explains the motivations for adopting Spring Cloud, defines its components and design goals, compares it with Spring Boot and other frameworks, outlines its main sub‑projects, versioning scheme, and provides practical guidance on configuration, service discovery, load balancing, fault tolerance, and gateway development for cloud‑native microservices.
This article explains how to replace repetitive try‑catch‑finally blocks with a unified global exception handling mechanism in Spring Boot, covering its evolution since Spring 3.x, classification of exceptions, the exact matching order, and a complete code example for developers.
This article introduces a full‑stack online exam system built with Spring Boot and Vue, detailing its role‑based features, front‑back separation architecture, and step‑by‑step instructions for cloning, configuring, and deploying both the backend and frontend components.
This article explains how to extend Spring MVC in Spring Boot by implementing WebMvcConfigurer, how the default auto‑configuration works, and why using @EnableWebMvc fully takes over MVC configuration, while also providing code examples and resource links for deeper learning.
This article explains the role of Servlet Filters in Spring Boot, details their execution chain, shows how to implement custom filters, and provides step‑by‑step configurations using FilterRegistrationBean and @WebFilter, including a practical CORS filter example.
This article provides a comprehensive overview of essential Spring Boot and Spring MVC annotations—including @SpringBootApplication, @RestController, @RequestMapping, @Autowired, and JPA annotations—explaining their purposes, usage examples, and how they simplify configuration, component scanning, request handling, and database mapping in Java backend development.
This article explains how to create, configure, and apply custom Spring MVC interceptors in Spring Boot, including a practical example that uses Redis to block repeated requests within a short time window, with full code demonstrations.
This article demonstrates how to implement a dynamic, non‑blocking Quartz scheduling solution in a Spring Boot application, covering Maven dependencies, database schema, initialization steps, custom job factory, listener, and common Scheduler API operations such as pause, resume, delete, and trigger.
This tutorial demonstrates how to integrate both Hibernate and MyBatis ORM frameworks within a single Spring Boot application, covering environment setup, project configuration, entity and repository definitions, service and controller implementation, and testing to verify concurrent operation.
This article provides a comprehensive step‑by‑step guide on selecting technologies, configuring Gradle, integrating Spring Boot 2.1.5 with MyBatisPlus, setting up FastJSON, Hutool, Undertow, and other tools, and includes complete source code for entity, mapper, service, controller, and utility classes to build a clean Java backend application.
This tutorial walks you through creating a Spring Boot web project, adding the starter dependency, implementing a REST endpoint, customizing Tomcat port and context path, and configuring Jackson for JSON output such as date formatting and global ObjectMapper settings.
This article explains the concept of API idempotency, reviews common solutions, and provides a complete Spring Boot implementation using a Redis‑based token mechanism, custom @ApiIdempotent annotation, interceptor, and supporting services, along with testing and important concurrency considerations.
Hmily 2.1.1 introduces a completely refactored architecture, new modules, expanded RPC support, configurable storage options, and detailed upgrade guides, enabling developers to build high‑availability, high‑performance distributed transactions with minimal code changes across Spring Boot, Dubbo, and Spring Cloud ecosystems.
This article explains how to seamlessly replace Spring Boot's default Logback logging framework with alternatives like Log4j2 by leveraging the SLF4J facade, covering version requirements, dependency management, configuration files, and detailed XML examples for various log levels.
This article demonstrates how to integrate Redisson with Spring Boot to create Redis‑based distributed locks, provides Maven dependency configuration, shows a Spring @Configuration class for Redisson, offers a utility wrapper for lock operations, and includes a REST controller with a concurrent test to illustrate correct locking behavior versus no‑lock scenarios.
This article explains how to configure logging in Spring Boot, covering supported versions, log levels, available logging frameworks, default Logback setup, code usage with Lombok, customizing log levels, directing output to files, formatting patterns, and detailed Logback XML configuration.
This article introduces Alibaba Sentinel, explains its key features for traffic control and circuit breaking, and provides step‑by‑step instructions with code samples to set up the Sentinel dashboard, integrate it into a Spring Boot microservice, configure rate‑limiting rules, and verify the protection in action.
This article explains why a multi‑level cache combining JVM‑level Caffeine and distributed Redis is essential for modern Spring Boot applications, outlines design challenges, provides step‑by‑step integration instructions, and demonstrates performance gains with benchmark results and core implementation code.
This tutorial explains how Spring Boot returns JSON using the default Jackson library, compares it with Alibaba's FastJson, demonstrates handling of null values, and shows how to encapsulate responses in a unified structure with status codes and messages for backend development.
This article explains Spring Boot's two configuration file formats—properties and YAML—detailing their syntax, how to map them to Java classes, and the various annotations (@ConfigurationProperties, @Value, @PropertySource) for retrieving configuration values, including custom file handling.
The article shares the author's personal experience of reading source code—starting with Java collections, moving to Spring and MyBatis, diving deep into Spring Boot and Quartz integration, and offering practical tips such as using official guides, books, blogs, design‑pattern knowledge, and IDE breakpoint debugging to master backend frameworks.
This article explains the concepts of multi‑tenant architecture, compares three data isolation strategies, and provides a complete Spring Boot example that uses MyBatis‑Plus to automatically inject a tenant identifier into SQL queries, including configuration, entity definitions, and unit tests.
This guide walks through the fundamentals of Spring Boot, explaining its purpose, showing how to create a project with Spring Initializr, writing a Hello World REST controller, understanding starter dependencies, configuring properties, exploring the main application class annotations, and adding a simple unit test.
This tutorial walks you through preparing the environment, configuring Docker remote access, setting up a Spring Boot project in IDEA, creating Dockerfiles and Maven settings, building the image, running the container, and verifying the deployment via browser and logs.
Spring Boot’s latest multi‑version release, now available via repo.spring.io and Maven Central, delivers critical bug fixes and a security patch for CVE‑2020‑5421, with detailed version‑specific changes for 2.3.4, 2.2.10, and 2.1.17, including the number of fixes and upgrade notes.
This article walks through building a two‑level caching system in Java, starting with a generic cache interface, implementing a local Guava cache, then adding a Redis distributed cache, and finally combining them with versioned keys to achieve timely expiration and seamless cache switching.
This article introduces PowerJob, a next‑generation distributed scheduling and computation framework, explains why a central scheduler is needed in microservice architectures, and provides detailed installation, configuration, and code examples for setting up the server, worker, and tasks using Docker, MySQL, MongoDB, and Spring Boot.
This tutorial walks through installing Docker, configuring remote access, creating a Spring Boot project, writing the necessary Dockerfile and Maven settings, building the image, and running the container, demonstrating how IDEA, Spring Boot, and Docker combine to simplify Java web deployment.
This guide explains why Spring Boot JARs become oversized when packed with many dependencies, demonstrates how to extract and reuse the lib folder, modify Maven settings to exclude embedded libraries, and run a much smaller JAR together with the external libs for efficient deployment.
This article introduces the open‑source Spring framework for Java, explains the core concepts of Inversion of Control (IOC) and Aspect‑Oriented Programming (AOP), and walks through creating a Spring Boot web project with MVC layers, annotations, and a runnable example.
This article walks through creating, configuring, testing, and deploying a Spring Boot application on Alibaba Cloud's Development Platform, covering both online and local development modes, CI/CD pipelines, environment management, and practical tips for smoother serverless workflows.
This article explains the concept of API idempotency, outlines common solutions, and provides a complete Spring Boot implementation using Redis and a token mechanism, including custom annotation, interceptor, utility classes, and testing procedures to ensure safe, single‑execution requests.
This article explains how Spring Boot uses the Maven plugin to create an executable fat JAR, details the internal archive layout, the repackage process, the custom class loader and URL handling, and compares JarLauncher with WarLauncher for both JAR and WAR deployments.
This article demonstrates how to design a non‑intrusive, unified JSON response structure for Spring Boot applications, defines a standard Result wrapper and status enum, shows static factory methods, and explains global handling via @ResponseResultBody, @RestControllerAdvice, and centralized exception processing.
This article explains how to implement seamless JWT token refresh in a Spring Boot OAuth2 application by embedding refresh information into the access token, customizing token services, defining a token refresh executor, and handling the refreshed token on the front‑end with an Axios interceptor.
Spring Boot loads configuration files in a defined order, giving higher priority to application.properties over application.yaml, and searches locations such as file:./config/, file:./, classpath:/config/, and classpath:/, with merging behavior that interviewers often test.
This article walks through integrating Spring Boot with Netty and using Google Protobuf for binary data exchange, covering Protobuf basics, Maven setup, code generation, server and client implementations, heartbeat handling, reconnection logic, and testing results, all with complete Java examples.
This tutorial walks you through downloading RuoYi-Vue 3.1, creating a MySQL database, importing required SQL files, configuring Redis and application settings, and then launching the Spring Boot back‑end and Vue front‑end so you can access the admin console at http://localhost:81/.
This article provides a detailed overview of common Spring Boot, Spring MVC, and JPA annotations—including @SpringBootApplication, @RestController, @RequestMapping, and JPA mapping annotations—explaining their purposes, usage patterns, and example code snippets for building Java backend applications.
This article explains how to design and build a simple two‑level caching solution in Java, covering generic cache interfaces, local caching with Guava, distributed caching with Redis, configuration details, version‑controlled cache keys, and practical usage within a Spring Boot application.
This article introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering ready‑made project structure, unified response handling, exception processing, code generation utilities, signature authentication, and integration guides to accelerate backend development.
This article explains the fundamentals of message queues, why they are needed for decoupling, asynchronous processing and throttling, introduces JMS concepts, details ActiveMQ storage options and protocols, and provides practical Java and Spring Boot code examples for producers, consumers, and advanced features such as transactions, persistence, and delayed delivery.
This article demonstrates how to build a robust email‑sending service using Spring Boot and RabbitMQ, covering message confirmation, consumer idempotency, retry mechanisms, configuration details, and complete source code examples for producers, consumers, and scheduled re‑delivery tasks.
