This article explains how Spring's @Conditional annotation and its 13 specialized @ConditionalOnXxx variants let you load beans only when specific runtime conditions are met, covering usage on classes and methods, combination logic, and how to create custom conditional annotations.
This article presents a Java MongoDB utility comprising a static helper class and a MongoObject wrapper, explains methods for server and credential handling, client creation, collection access, and demonstrates usage with a sample main program and its output.
This article presents the ten most frequently asked Spring Boot interview questions, covering annotations, package exclusion, auto‑configuration control, Actuator features, initializer usage, embedded Tomcat customization, and how to disable the default web server, providing concise answers and code examples for each.
This tutorial walks through preparing the environment, configuring Docker remote access, creating a Spring Boot project with Maven, writing Dockerfile and related configuration files, building the image, and running the container, demonstrating how to deploy a Java web application to Docker using IntelliJ IDEA.
This article explains how to diagnose and manually re‑execute a Spring @Scheduled task that fails to send notifications by using Arthas to obtain the ApplicationContext, invoke the bean method, and reveals that a missing timeout in Hutool caused the original hang.
This article presents a comprehensive collection of Spring Boot best practices—ranging from custom BOM management, automatic configuration, project initialization with Spring Initializr, clean controller and service design, externalized configuration, logging, testing strategies, and more—to help developers build robust, maintainable Java microservices efficiently.
Learn how to implement a smooth, graceful shutdown for Spring Boot applications that use an embedded Tomcat server by customizing the Tomcat connector, enabling the Actuator shutdown endpoint, and automating the process with scripts, ensuring in‑flight requests complete before the service stops.
This article walks through rebuilding an asynchronous MySQL logging service using Spring Boot and MyBatis, providing full source code for the application entry point, DAO, service, controller, MyBatis mapper, and configuration, and shows the resulting database entries.
This article examines the evolution of Java microservices at Huajiao, compares existing PHP and Java solutions, justifies the adoption of Spring Boot 2 with MyBatis and Undertow, outlines incremental improvements such as CI/CD migration and service mesh adoption, and presents a roadmap for future microservice components.
This article examines the challenges of a PHP‑based microservice stack, compares open‑source Java solutions, explains the rationale for adopting Spring Boot 2 with MyBatis and Undertow, and outlines a roadmap toward CI/CD automation, service discovery, and Service Mesh adoption.
This article provides a comprehensive overview of the Spring framework, Spring MVC, and Spring Boot, explaining how dependency injection reduces boilerplate and enables loose coupling, illustrating code examples with and without DI, and describing Spring Boot’s auto‑configuration, starter projects and typical starter options for building modern Java backend applications.
This article presents a complete Spring Boot project template for an e‑commerce order service, covering README composition, one‑click local build scripts, business‑oriented package layout, automated test classification, logging, exception handling, background tasks with distributed locks, static analysis, health checks, Swagger API documentation, database migration, multi‑environment configuration, CORS setup, and a curated list of useful third‑party libraries.
This article explains the concept of microservices, contrasts them with SOA, outlines their architectural advantages, and describes how Spring Boot and Spring Cloud work together to implement microservice solutions, detailing core components and request flow within a cloud‑native backend system.
The author recounts how, after his company closed, he built a lightweight Spring Boot‑Vue blog project, iterated it into a more complex human‑resource management system, documented each feature, released it on GitHub, and eventually saw it climb the GitHub Trending list, sharing lessons learned and advice for newcomers.
This guide explains how developers can commit code, update the Maven pom, use Jenkins to read the pom, upload artifacts to Nexus, and retrieve the latest package URL, illustrating a complete CI/CD workflow for a Spring Boot application.
This article demonstrates how to build a distributed rate‑limiting component named shield‑ratelimiter using Redis’s INCR and TTL features, Spring‑Boot‑starter integration, Lua scripting for atomic operations, custom annotations, and AspectJ, providing a robust, configurable solution for limiting API calls in Java backend services.
This tutorial explains how to use Spring Boot's ApplicationContextRunner to simplify testing of auto‑configuration classes, covering class, bean, and property conditions with concrete code examples and assertions for both present and missing scenarios.
This tutorial explains how to customize Spring Boot's embedded Tomcat server by adjusting ports, addresses, error handling, connection limits, SSL settings, and access log options through application.properties, providing clear code examples for each configuration.
This article presents fifteen common Spring Boot interview questions covering its definition, features, starters, configuration files, CORS handling, security choices, session sharing, hot deployment, scheduling, API documentation, data access, XML usage, executable JAR differences, and property file distinctions, providing concise explanations and practical references for Java developers.
An encrypted Spring @Component class causes a startup failure because Spring reads class files as raw byte arrays using ASM before loading them, and the encrypted bytecode violates JVM specifications, leading to an ArrayIndexOutOfBoundsException; the article explains this scanning mechanism and the hidden cause.
This article explains MyBatis interceptors, showing how to intercept SQL execution, parameter setting, and result processing, and provides step‑by‑step code for custom encryption/decryption annotations, a parameter interceptor, a result‑set interceptor, and the supporting IEncryptDecrypt interface.
This tutorial demonstrates how to integrate an AOP logging module into a Spring Boot project by adding required dependencies, creating a custom aspect that extends LBaseWebLogAspect, defining a pointcut, and exposing a sample REST endpoint that returns user data while logging detailed request information.
This article chronicles a step‑by‑step performance overhaul of a 20‑million‑record migration project, detailing four architectural revisions—from a single‑threaded procedural script to a fully decoupled, multithreaded, interface‑driven solution—that reduced processing time from two months to just four hours while ensuring data consistency, recoverability, and scalability.
This article explains why session sharing is required in distributed Java back‑ends, demonstrates how Spring Session automatically synchronizes HttpSession data to Redis, and shows step‑by‑step how to configure Spring Boot, Redis, and Nginx to achieve transparent session sharing across multiple service instances.
This article explains how to use Spring Session together with Redis to achieve transparent HTTP session sharing across multiple Spring Boot instances in a clustered environment, including project setup, Redis configuration, sample controller code, Nginx load‑balancing, and deployment steps.
This article explains how to configure and tune Spring Boot's embedded Tomcat, adjust JVM parameters, enable remote debugging, and connect monitoring tools such as JConsole and JVisualVM, providing practical steps and code examples for improved performance and easier troubleshooting in production environments.
This article walks through a series of practical experiments—ranging from baseline Flux tests to lazy initialization, JVM options, dependency exclusions, and AppCDS—to dramatically reduce Spring Boot application startup time, ultimately achieving sub‑second launch speeds.
This article explains the mica-auto library, which uses Java annotation processing to automatically generate Spring Boot starter configurations, streamline component registration, and simplify multi‑module Spring Cloud projects, while providing Maven and Gradle integration details and recent change logs.
This tutorial walks through installing RabbitMQ, configuring it in a Spring Boot project, defining message models and enums, implementing delayed messaging to automatically cancel unpaid orders, and provides complete Java code, configuration files, testing steps, and useful resources for building a robust backend order system.
This tutorial walks through integrating MongoDB into a Spring Boot mall project, covering installation, configuration, Spring Data MongoDB usage, defining document and repository classes, implementing service and controller layers, and testing CRUD operations for product browsing records.
This tutorial walks you through installing Graylog with Docker‑Compose, configuring it for Spring Boot, and routing Logback and Log4j2 logs to Graylog, while also comparing Graylog to the ELK stack and providing source links for the full projects.
This guide walks through installing Elasticsearch and Kibana, configuring a Chinese analyzer, defining Spring Data Elasticsearch annotations, creating repository and service layers, building a REST controller, and testing product search functionality within a Spring Boot mall application.
A curated list of 13 high‑quality Spring Boot open‑source projects—including e‑commerce platforms, microservice frameworks, payment systems, and ERP solutions—each with brief descriptions, key features, and demo links to help Java developers find valuable codebases for learning and real‑world use.
This article explains what Spring Cloud is, its advantages for distributed microservices, the meaning of service registration and discovery, the purpose of load balancing, how Hystrix provides fault tolerance and circuit breaking, the role of Netflix Feign, and the function of Spring Cloud Bus for configuration refresh across instances.
This tutorial walks through building a Spring Boot backend with user registration, login, JWT token generation, Swagger UI configuration, and method-level permission annotations, providing complete code examples and step‑by‑step instructions for secure authentication and authorization.
This guide walks you through installing Redis, adding Maven dependencies, configuring Spring Boot, creating a Redis service interface and implementation, and building controller endpoints to generate and verify SMS verification codes, complete with code examples and deployment instructions.
This tutorial walks through integrating Swagger‑UI into the mall‑tiny Spring Boot project, covering Maven dependencies, Java configuration, adding Swagger annotations to controllers, customizing MyBatis Generator to emit @ApiModelProperty, regenerating model code, and finally viewing and testing the generated API docs via the Swagger‑UI interface.
This article provides a comprehensive tutorial on Spring Boot, covering its purpose, key advantages, project setup with Maven, essential configuration files, integration of JdbcTemplate, JPA, MyBatis, JSP, AOP, and task scheduling, all illustrated with complete Java code snippets.
The Mall project is a comprehensive e‑commerce solution featuring a front‑end storefront and back‑office management, implemented with Spring Boot, MyBatis, and a suite of modern technologies such as Redis, Elasticsearch, RabbitMQ, Docker, and more, offering modules for products, orders, marketing, and analytics.
This article compiles essential Spring Boot best practices—from custom BOMs and auto‑configuration to logging, testing, and exception handling—offering developers actionable guidance to streamline microservice development, improve code quality, and maintain scalable, maintainable Java applications.
MyBatis 3.5 now supports Java's Optional in mapper methods, allowing developers to replace verbose null‑checking code with concise, expressive calls, while noting that MyBatis Generator and some third‑party mappers have not yet adopted this feature.
This article examines the limitations of Spring Cloud Config—especially Git‑based permission control and coarse granularity—explains why a database‑backed configuration center is preferable, and details a custom long‑polling refresh mechanism built with Spring's DeferredResult and asynchronous servlets.
Spring Boot imposes no strict project layout, but adopting a recommended package structure—placing the main application class in a root package and organizing domain, service, and web layers under it—prevents configuration pitfalls and ensures automatic component scanning, while alternative scanning methods like @ComponentScan and @Bean can handle non‑standard layouts.
This tutorial walks you through setting up a Spring Boot 2.1.3 project using Maven, covering environment prerequisites, two creation methods (Spring Initializr and IntelliJ IDEA plugin), project structure, configuration, essential dependencies, a HelloWorld REST controller, unit testing, and important deployment tips.
This article explains what Spring Boot and Spring Cloud are, why they are used, their configuration file types, hot‑deployment methods with code examples, the differences between JPA and Hibernate, and the main components of Spring Cloud such as Eureka, Ribbon, Hystrix, Zuul and Config.
This tutorial walks you through creating a Spring Boot project with Spring Initializr, explains its lightweight advantages, shows how to set up the project structure, configure Maven dependencies, implement a simple HTTP endpoint, and write unit tests, all using Java and Maven.
This article explains Spring's annotation‑based caching, analyzes why the default cache key collides in multi‑tenant scenarios, shows how to embed tenant identifiers into keys, and provides a custom CacheManager implementation that parses TTL from the cache name and applies it to Redis entries.
Mica is a Java‑8 based microservice framework that evolved from lutool, offering servlet and reactive WebFlux support, auto‑configuration via Spring Boot and Spring Cloud without third‑party dependencies, modular components, LGPL‑v3 licensing, and detailed update notes for developers.
The article describes the motivation, analysis, architecture, performance optimizations, development challenges, and future plans of JD Finance’s LEGO backend platform, which uses Spring Boot, SpEL, Redis, and reactive programming to enable dynamic, high‑performance page configuration for a high‑traffic mobile app.
The article explains mica-auto, a core component of the Mica Spring Cloud microservice framework that automatically generates essential Spring Boot starter configurations, outlines its usage scenarios, features, integration methods for Maven and Gradle, licensing, and provides visual guides for developers.
This open‑source project offers a Spring Cloud Finchley‑based RBAC permission system using Spring Security OAuth2, a data‑driven Element‑ui front‑end that works without Vue experience, and full container support (Docker, Kubernetes, Rancher2) plus production‑ready lambda, Stream API and WebFlux examples, with detailed dependency listings and contribution guidelines.
This guide explains how to create clear, hierarchical service names for microservices, defines environment partitions, shows how to use the Mica launcher with Spring Boot, and demonstrates custom configuration, plugin extension, and code examples for streamlined backend development.
This guide explains how Mica-Log4j2 provides environment‑specific log configurations, high‑throughput asynchronous logging via Disruptor, replaces System.out/err in non‑dev modes, and shows Maven/Gradle dependencies, system settings, custom log levels, file structures, and open‑source resources for Spring Boot applications.
This guide explains the purpose of the mica-boot-test component, shows how to add its Maven or Gradle dependency, and provides two example test classes demonstrating the use of @MicaBootTest with either @RunWith(MicaSpringRunner.class) or inheritance from MicaBaseTest.
The article explains the purpose, usage scenarios, features, dependency setup, build process, and licensing of mica-auto, a component that generates essential Spring Boot starter configurations for the Mica microservice framework, helping avoid package inconsistencies and streamline development.
This article presents the design, architecture, and technology choices of a Sonar monitoring system for Spring Boot microservices, covering time‑series database selection, deployment topology, client collection strategies, and future plans for advanced analytics and AI‑driven alerting.
This article explains how to select the appropriate Spring Cloud Alibaba version by clarifying its relationship with Spring Boot and Spring Cloud, provides a Maven BOM snippet, a compatibility matrix, and points to a comprehensive tutorial series for building micro‑service applications.
Dubbo Admin 0.1, a freshly refactored standalone project, replaces the old Webx backend with Spring Boot, adopts Vue and Vuetify for the UI, integrates Swagger, and introduces updated configuration, tag routing, application‑level service governance, and metadata‑driven testing to fully support Dubbo 2.7 features.
Spring’s shift from XML to annotation‑based configuration is explained, covering @Configuration and @Bean requirements, example Java classes, equivalent XML, annotation definitions, bean scopes, component scanning, unit‑testing, and practical tips for wiring beans without field injection, providing a complete guide for modern Spring development.
This article introduces Spring Boot, explains its advantages over traditional Spring projects, describes JavaConfig, shows how to use DevTools for automatic reloads, outlines Actuator monitoring, and provides practical guidance on security, YAML configuration, ActiveMQ integration, and pagination with Spring Data JPA.
This article presents a curated list of the most popular Java open‑source projects on GitHub for January, summarizing each repository’s purpose, key features, and star count to help developers discover valuable resources for learning, building, and advancing Java applications.
This guide walks through integrating Codecentric's Chaos Monkey into a Spring Boot microservice ecosystem, covering dependency setup, configuration, actuator endpoints, Dockerized MySQL, performance testing with Gatling, and timeout tuning for Feign and Ribbon clients to simulate real‑world failures.
This article explains how to configure Spring Boot Actuator to export metrics to InfluxDB and Prometheus, covering Docker setup, Micrometer dependencies, application properties, sample controller code, test data generation, and visualisation with Grafana.
Groovy, a dynamic JVM language praised for its concise syntax and powerful features like closures, has re‑entered the TIOBE Top 20 thanks to its role in Jenkins and Gradle, offering Java developers a compelling boost to Spring Boot productivity.
This article dissects how a simple Spring Boot Hello World application launches, walks through the runtime call stacks, explains the FatJar packaging and custom ClassLoader, and reveals how @RestController classes are automatically registered with the embedded Tomcat server.
This tutorial walks you through using Nacos as a centralized configuration center in a Spring Cloud application, covering the benefits of Nacos config management, creating configuration entries, setting up a Spring Boot project with the required dependencies, implementing a refreshable controller, and verifying dynamic updates at runtime.
This article lists and briefly describes the eleven most popular Java‑related GitHub repositories in December, covering learning guides, e‑commerce platforms, advanced Java topics, performance monitoring, high‑concurrency demos, diagnostic tools, Spring Boot, tutorials, messaging middleware, community software, and the Dubbo RPC framework.
This tutorial walks you through installing Nacos, configuring Spring Cloud Alibaba for service registration and discovery, building provider and consumer Spring Boot applications, and testing load‑balanced calls, offering a complete hands‑on guide to cloud‑native microservice integration.
This guide explains how to build a Spring Boot starter that automatically counts and logs the number of entries for each entity at application startup, covering starter concepts, Maven setup, code implementation, auto‑configuration, and integration into a main project.
This article explains why migrating a Spring Boot app from Java 8 to Java 11 is necessary, compares OpenJDK and commercial licenses, outlines Spring's Java‑11 support, and provides detailed migration steps, dependency updates, and Maven/Gradle configuration changes.
This article explores the inner workings of Spring Boot by dissecting a simple Hello World application, analyzing its startup sequence, class loading via FatJar, the custom JarLauncher, and automatic registration of RestControllers, while highlighting performance considerations and the complexity of its annotation-driven configuration.
After moving to Spring Boot, the application consumed up to 7 GB of native memory because Meituan’s MCC package scanner invoked Spring’s ZipInflaterInputStream, which allocated large off‑heap buffers during JAR decompression that were only freed by the JVM finalizer and retained by glibc’s 64 MB arenas; restricting the scan scope or upgrading to Spring Boot 2.0.5 eliminated the excess usage.
This article provides a comprehensive analysis of Spring AOP's core proxy mechanisms, detailing the roles of advisor, advice, and pointcut classes, the annotation‑driven configuration process, and how Spring Boot automatically creates proxies using JDK or CGLIB based on configuration flags.
This article provides a comprehensive analysis of Spring AOP, covering its core classes, multiple proxy mechanisms, annotation‑based configuration in Spring Boot, the differences between Spring Boot 1.x and 2.x AOP settings, and detailed source‑code snippets that illustrate how advisors, pointcuts, and advices are created and applied.
This article chronicles the evolution of the Spring ecosystem—from its origins as a lightweight dependency‑injection framework, through rapid version growth and corporate changes, to the emergence of Spring Boot and Spring IO, highlighting key releases, architectural shifts, and the impact on Java backend development.
This comprehensive guide explains how to design and implement functional tests for a Spring Boot microservice using Docker containers, REST‑Assured, WireMock, and Testcontainers, covering architecture, code examples, test configuration, and best practices for maintainable black‑box testing.
This tutorial walks through the design and implementation of a distributed configuration center using Spring Boot, demonstrating how to define configuration entities, apply the observer pattern for dynamic updates, and integrate a thread‑pooled scheduler to keep configuration in sync without restarting services.
This tutorial walks through persisting Domain‑Driven Design aggregates by first explaining aggregates and aggregate roots, then showing Java class examples, followed by practical JPA/Hibernate integration challenges and a complete MongoDB document‑store solution, highlighting trade‑offs and best practices.
The article surveys thirty‑nine essential open‑source tools for constructing microservices—from API management, messaging, and monitoring to Kubernetes orchestration, programming languages, frameworks, and serverless platforms—highlighting how each solution supports communication, scalability, and rapid development across enterprise, government, education, and charitable applications.
This article explains how Spring Boot, Spring, and Spring MVC relate to each other, describes Spring MVC's core concepts, and details Spring Boot's auto‑configuration, static resource handling, error handling, CORS support, and related code examples for building Java backend applications.
This article walks through the Spring MVC internals, explaining how the @ResponseBody annotation triggers JSON serialization by tracing the DispatcherServlet, HandlerAdapters, and ReturnValueHandlers, and includes runnable Spring Boot test code to illustrate the processing flow.
This article provides a step‑by‑step guide to creating a Spring Boot application, generating a project template, adding a MyBatis‑based persistence layer, implementing service and controller layers, configuring the database, and running the application to expose REST endpoints.
Learn how to quickly wrap XML requests into objects and return XML responses in Spring Boot by leveraging the HttpMessageConverter mechanism, adding the Jackson XML message converter, defining POJOs with Jackson annotations, and creating controller endpoints that consume and produce XML.
This article explains the principles of cross-origin restrictions, analyzes various client‑side and server‑side solutions such as disabling browser security, using script tags, JSONP, and especially CORS with Spring Boot filters, annotations, and proxy configurations, providing complete code examples and practical deployment tips.
This article explains the difference between kill -9 and kill -15 signals, how Spring Boot processes the TERM signal, and provides practical code examples for implementing graceful shutdown, including shutdown hooks, DisposableBean, and proper thread‑pool termination strategies.
This tutorial explains how to build a WeChat QR‑code login system using Spring‑Boot, Thymeleaf, HttpClient and JSON, covering preparation steps, project configuration, OAuth2 flow, code examples for generating QR pages, handling callbacks, and customizing the login experience.
This article provides a comprehensive, question‑driven guide to Spring Boot, covering its differences from Spring and Spring MVC, auto‑configuration, starter projects, embedded servers, Maven plugins, DevTools, static resources, Spring Data, REST support, request mapping nuances, and profile‑based configuration for building production‑ready Java backend applications.
This article presents sixteen practical Spring Boot best‑practice recommendations—ranging from custom BOM dependency management and starter usage to clean controller design, service layering, externalized configuration, testing strategies, and logging—to help developers build maintainable, production‑grade Java micro‑services.
This article provides a comprehensive overview of Spring Cloud, explaining why it’s favored for microservice development, detailing its key features and toolset, and examining essential components such as Eureka, Hystrix, Config, Zuul, and Ribbon with practical insights.
This article compares two common Spring Cloud Config storage strategies—sharing a single Git repository with per‑project directories versus using a separate Git repository per project—detailing configuration properties, directory mapping, and the pros and cons of each approach.
This guide explains what CORS is, why browsers enforce same‑origin policies, and provides both frontend and backend strategies—including JSONP, proxy servers, Chrome flags, and several Spring Boot configurations such as filters, @CrossOrigin, custom CorsFilter, and WebMvcConfigurer—to resolve cross‑origin issues.
Spring Boot, introduced in 2013 to simplify Spring development, provides out‑of‑the‑box starter dependencies, reduces configuration and deployment complexity, and enables rapid creation of microservice‑ready Java applications, making it essential knowledge for modern backend developers.
This tutorial walks through creating a Spring Cloud Config Server that stores configuration data in a MySQL database, covering project setup, Maven dependencies, database schema creation with Flyway, Java bootstrap code, application properties configuration, and verification using curl commands to retrieve configuration values.
This article explains how to identify, design, and implement Java microservices—from domain‑driven modeling and service boundaries to RESTful API creation, documentation, proper HTTP verbs, and versioning strategies—using examples like an online retail store and the Game On! text adventure.
This guide shows how to change a Spring Boot project’s packaging to WAR, remove the embedded Tomcat, add the servlet‑api dependency, create a servlet initializer, build the WAR with Maven, and deploy it to an external Tomcat server for verification.
This article traces Spring's evolution, explains why Spring Boot was created to simplify configuration and deployment, outlines its core features, testing support, convention‑over‑configuration philosophy, and its relationship with Spring Cloud, providing a comprehensive guide for backend developers.
This article explains Spring Boot's core features, the role of @Conditional in automatic configuration, demonstrates custom condition classes and annotations, and walks through the source code of Spring Boot's auto‑configuration infrastructure, including @SpringBootApplication, EnableAutoConfigurationImportSelector, and class‑path condition evaluation.
This guide explains how to implement global rate limiting for high‑traffic Spring Boot applications by using Redis caches and MySQL storage, covering request interception, Redis key structures for limits and counters, and dynamic configuration for adding, updating, or deleting limits.
This article explores the origins of Spring Boot, its evolution from the Spring framework, key features, advantages for developers, and its relationship with Spring Cloud, illustrating how it simplifies Java backend development and addresses configuration complexity.
This article provides a detailed tutorial for creating a Spring Boot project with MyBatis, including environment setup, Maven dependencies, configuration files, database creation, MyBatis generator usage, and sample controller, service, and mapper code, enabling pagination with PageHelper and testing via HTTP requests.
