This tutorial walks you through the complete setup of an ELK (Elasticsearch, Logstash, Kibana) real‑time log analysis platform on Ubuntu, covering component installation, configuration for Spring Boot and Nginx logs, Grok parsing, and background service management with Supervisor.
This article explains how to use Spring Boot Actuator to expose Tomcat performance metrics, retrieve health and metric endpoints via HTTP, configure custom endpoints, and optionally log or export the data to Prometheus for continuous monitoring and analysis.
This article introduces a Spring Boot starter that enhances native @Scheduled tasks with dynamic management capabilities, explains how to integrate the dependency, and details the underlying implementation using post‑processors, application runners, custom managers, and CGLIB‑based proxy chains to modify scheduling parameters at runtime.
This guide explains why manual configuration changes across development, test, and production environments are error‑prone and shows step‑by‑step how Spring Boot’s profile‑specific property files, code snippets, and activation methods let you configure and switch environments quickly and reliably.
Spring Cloud Function abstracts infrastructure to let developers write business logic as reusable functions, deployable as web endpoints, stream processors, or serverless tasks across providers, with examples showing HTTP, RabbitMQ/Kafka integration, code snippets, and endpoint mappings for various function types.
This article explains the difference between synchronous and asynchronous method calls in Spring Boot, demonstrates how to convert blocking tasks into @Async‑enabled concurrent executions, and shows how to use Future for callback handling to measure total execution time.
This guide walks you through applying for a free SSL certificate, exporting it as a PFX file, and configuring Spring Boot to serve HTTPS on port 443, including code snippets and common pitfalls to avoid.
The Spring Cloud Alibaba 2021.0.1.0 release, built on Spring Boot 2.6.3 and Spring Cloud 2021.0.1, introduces upgraded Nacos client, RocketMQ 4.9.2 with batch and async support, Sentinel 1.8.3 enhancements for FeignClient, Spring Config import support, and a clarified version‑numbering scheme aligning with Spring Cloud.
Spring Security's WebSecurityConfigurerAdapter is deprecated in version 5.7, and this article explains the migration path by comparing the old and new ways to configure HttpSecurity, WebSecurity, and AuthenticationManager with practical code examples.
This article explains two high‑severity Spring Cloud Gateway vulnerabilities (CVE‑2022‑22946 and CVE‑2022‑22947), outlines the affected versions, describes how attackers can exploit exposed Actuator endpoints, and provides concrete mitigation steps such as upgrading to safe releases or disabling the gateway actuator.
This article explains why Spring Cloud Gateway may emit duplicate Access-Control-Allow-Origin and Vary headers during CORS handling, analyzes the internal processing flow, and provides two practical solutions—using DedupeResponseHeader configuration or a custom GlobalFilter—to eliminate the duplication.
This article explains how to replace inefficient traditional delay mechanisms with RabbitMQ's delayed‑queue plugin, showing step‑by‑step configuration, producer and consumer code in Spring Boot, and demonstrates successful delayed message delivery using real‑world examples such as auto‑confirm orders and ticket reservations.
RedisOM, the official Redis ORM for Java, lets Spring Boot developers replace RedisTemplate with object‑oriented data handling and built‑in full‑text search, covering JDK 11 setup, Maven dependencies, configuration, entity annotations, repository interfaces, and REST controller examples for managing product data.
This article explains why traditional delayed‑message solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, and demonstrates how to use RabbitMQ's delayed‑queue plugin with Spring Boot to configure exchanges, send delayed messages, and consume them reliably.
This article explains why Spring Boot creates only one UserManager bean when both @Configuration + @Bean and @Component definitions exist, how the bean definition overriding mechanism works across different Spring versions, and how to control it with the allowBeanDefinitionOverriding setting.
This article explains why traditional delay solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, then demonstrates step‑by‑step how to configure RabbitMQ’s delayed‑queue plugin, create exchanges, queues, and bindings in Spring Boot, and send and consume delayed messages with code examples.
This article explains two critical Spring Cloud Gateway vulnerabilities (CVE-2022-22946 and CVE-2022-22947), detailing their causes, affected versions, potential impact, and recommended remediation steps such as upgrading to safe releases or disabling the vulnerable actuator endpoint.
This article introduces the fully open‑source HC Community IoT platform built with Vue + ElementUI on the front end and Spring Boot on the back end, and provides step‑by‑step deployment instructions, code snippets, screenshots, and the source‑code repository link.
This article provides a comprehensive guide on integrating Apache Shiro into a Spring Boot application, covering core components, Maven configuration, bean definitions, security manager setup, custom realms, filter chain configuration, and the complete login authentication flow with code examples.
This article explains why using scheduled tasks for closing timed‑out orders is problematic, demonstrates how to use RabbitMQ dead‑letter queues and the x‑delay‑message plugin to achieve accurate order timeout handling, and provides complete Spring Boot configuration and code examples with testing and limitations.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable with exe4j, bundling a local JRE, and then creating a user‑friendly installer using Inno Setup, providing step‑by‑step screenshots and configuration details to avoid common pitfalls.
This article explains the fundamentals of Alibaba Druid as a Java database connection pool, shows how to add Maven dependencies, configure properties and filters in Spring Boot, set up monitoring pages, remove built‑in ads, and retrieve runtime statistics via DruidStatManagerFacade.
This guide explains why Apache-related logs appear in the console when integrating Tinylog with Spring Boot and shows how to hide them by setting the appropriate logging level for the offending package, such as disabling org.apache.catalina logs.
This tutorial explains how to deploy MinIO with Docker on Linux/macOS and Windows, configure a Spring Boot backend with MinIO client libraries, create reusable Java components for signed policies and file uploads, and build a Vue/Element‑UI frontend that demonstrates three upload methods, all with complete code examples.
The article introduces Spring Cloud 2021.0.1, providing the updated Maven dependency snippet, a detailed list of module version upgrades, compatibility tables with Spring Boot, and highlights new features in Spring Cloud Gateway, OpenFeign, and Sleuth, while also offering PDF resources for deeper learning.
The article explains why killing a Spring Boot process with SIGKILL is unsafe and presents five practical ways—using Actuator, closing the application context, writing a PID file, invoking SpringApplication.exit, and creating a custom shutdown controller—to achieve a graceful shutdown while ensuring @PreDestroy methods run and resources are released.
This guide explains how to create a Spring Boot Admin server, configure a Spring Boot client to register with it, enable Actuator for extended metrics, and view real‑time logs, providing a comprehensive monitoring solution for Java backend services.
This guide walks you through packaging a Spring Boot application into a Docker image with Jib, installing the Spring Boot Operator on a Kubernetes cluster, deploying a demo app, customizing deployments, handling graceful shutdown, and using node affinity for advanced scheduling.
This article explains step‑by‑step how Spring Boot’s RabbitAutoConfiguration sets up connection factories, RabbitTemplate, listener containers, and lifecycle management to enable @RabbitListener‑driven message processing, complete with code examples and the underlying bean registration flow.
This article provides a detailed tutorial on Druid, the Alibaba‑developed Java database connection pool, covering its core concepts, Maven dependencies, extensive Spring Boot configuration options, filter setup, monitoring UI, SQL and slow‑query logging, ad removal techniques, and programmatic access to monitoring data.
This article details the research background, environment preparation, and three Redis‑based message‑queue implementations—using List structures, Pub/Sub, and Stream APIs—along with code examples, design considerations, testing strategies, and deployment tips for building a lightweight messaging component in Java Spring Boot.
This article provides a step‑by‑step tutorial for installing, configuring, and running a JVM monitoring solution that integrates with Spring Boot, covering repository cloning, server configuration, Maven installation, application property setup, and accessing the monitor server UI.
This article shares a collection of practical Java/Spring coding habits—including using @ConfigurationProperties for YAML configs, Lombok's @RequiredArgsConstructor, modular method design, avoiding null returns, leveraging HashSet for fast lookups, fine‑grained locking, structured cache naming, @Cacheable with TTL, and asynchronous task handling—to help developers write cleaner, more maintainable, and higher‑performance backend code.
The article compares popular Java microservice frameworks, highlighting Spring Boot's ease of use but high memory consumption, Vert.x's lightweight performance, and the characteristics of SparkJava, Micronaut, Javalin, and Quarkus, while also noting required infrastructure components for Spring Cloud.
This tutorial explains the advantages of WebSocket over HTTP and provides a step‑by‑step guide, including Maven dependency, Spring Boot configuration, a ServerEndpoint class, a simple HTML/JavaScript front‑end, and a controller method, to build a real‑time chat system with online/offline notifications and private or broadcast messaging.
This article introduces mybatis-mate, an official MyBatis‑Plus extension that provides enterprise‑grade features such as sharding, multi‑datasource support, data auditing, field encryption, sensitive‑data masking, automatic DDL maintenance, dynamic datasource switching, distributed transaction logging, and fine‑grained data permission control, with detailed usage examples and configuration snippets for Spring Boot projects.
This article provides an in-depth comparison of Nacos with other configuration and registration centers, explains its architecture and design principles, and offers detailed step-by-step instructions for deploying Nacos in standalone and cluster modes, integrating it with Spring Boot for both configuration and service discovery, including code snippets and operational tips.
This tutorial shows how to add the tinylog logging framework to a Spring Boot application by excluding the default logger, adding tinylog dependencies, configuring tinylog.properties, and verifying the setup with a simple Lombok‑based logging example.
This article explains how to secure API communication with tokens, timestamps, cryptographic signatures, duplicate‑submission prevention, and practical Spring Boot code examples, offering a comprehensive guide for protecting data exchange between services.
This article explains four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—to perform generic authentication with code examples and a final comparison of their execution order.
This tutorial explains how to embed Dataway—a zero‑code API configuration UI built on DataQL—into a Spring Boot application by adding Hasor dependencies, configuring properties, setting up required database tables, wiring the data source into Hasor, enabling Hasor annotations, and finally creating and publishing APIs through the Dataway UI.
This guide introduces kkFileView, an open‑source Spring Boot solution for online preview of office, PDF, CAD, multimedia and text files, outlines its key features, provides documentation links, shows preview examples, and explains how to set up and run the service.
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 leveraging MyBatis plugins, custom annotations, and Spring Boot components, providing a clean, reusable solution for backend applications.
This article explains why Swagger can become cumbersome as API counts grow, introduces Knife4j as a powerful Swagger enhancement, and provides step‑by‑step instructions with code examples to integrate Knife4j into a Spring Boot project, highlighting its key features such as JSON folding, search, and global parameters.
This article presents a detailed overview of a custom Java RPC framework, covering its core concepts, architecture, communication flow, message protocol, load balancing, serialization, handling of TCP packet fragmentation, and practical implementation using Spring Boot, Netty, and Zookeeper, along with deployment instructions.
kkFileView is a free, Apache‑licensed Spring Boot project that enables online preview of numerous file types—including office documents, PDFs, CAD files, images, archives, and multimedia—offering RESTful APIs, easy deployment, and extensible interfaces for developers seeking a versatile document viewer.
This article demonstrates five practical techniques for reading YAML configuration files in Spring Boot—including Environment, YamlPropertiesFactoryBean, custom listeners, SnakeYml, and Jackson—providing code examples, usage details, and tips for handling defaults and profile activation.
This article explains how Spring Boot's spring-boot-maven-plugin creates an executable JAR, describes the internal structure and Manifest, details the role of JarLauncher and the custom LaunchedURLClassLoader, and provides concrete code examples for class loading and execution.
This tutorial explains how to install Docker, configure remote access, create a Spring Boot project in IntelliJ IDEA, add Dockerfile and Maven settings, build a Docker image, run the container, and verify the application through a browser and log inspection.
An in‑depth guide shows how running 100 concurrent MyBatis queries triggers a ClassCastException, explains the underlying cache placeholder issue, and demonstrates how Spring Boot’s SqlSessionTemplate and transaction management guarantee thread‑safe SqlSession usage through ThreadLocal binding.
The article outlines the major updates in Spring Boot 3.0.0 M1, including the jump to Java 17, migration from Java EE to Jakarta EE, removed legacy support, upgraded Spring and third‑party dependencies, and the roadmap for upcoming milestone releases.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable using exe4j, configuring the bundled JRE, and then creating a full installer with Inno Setup, enabling non‑technical users to install and run the application without a separate JDK.
Learn step‑by‑step how to convert a functional Spring Boot JAR into a Windows executable using exe4j, embed the required JRE, and package everything into an installer with Inno Setup, enabling users without Java installed to run your application effortlessly.
This article provides a step‑by‑step guide on deploying Flowable‑UI, designing BPMN diagrams, configuring a Spring Boot backend, managing Flowable database tables, and using Flowable engine APIs to implement a complete leave‑approval workflow with code examples.
This article compares popular Java microservice frameworks—including Spring Boot, Spring Cloud, Vert.x, SparkJava, Micronaut, Javalin, and Quarkus—by examining their setup complexity, resource consumption, performance in stress tests, and suitability for small‑to‑medium projects.
The article reviews the latest Spring Native 0.11.2 and Spring Authorization Server 0.2.2 releases, detailing new features, compatibility changes, bug fixes, and dependency upgrades that impact cloud‑native Java applications and backend security.
This article examines Spring Boot 3’s migration to Java 17, the adoption of Spring 6, updated Maven and Gradle versions, the move to Jakarta EE 9, removal of legacy components, and practical advice on when and how to upgrade your backend applications.
This guide walks you through downloading XXL-Job, setting up its database, configuring Spring Boot profiles, customizing log paths, deploying the admin console, writing a sample executor with @XxlJob, and managing tasks through the web UI, all with concrete commands and code snippets.
The article explains how Spring Boot 3 drops Java 8, embraces Java 17 and Spring 6, outlines the major framework changes, removed components, and offers practical advice on when and why developers should consider upgrading.
This guide explains why Spring Boot applications suffer 30‑second cold‑start delays on serverless platforms, breaks down each startup phase, and provides three practical optimization techniques—reserved instances, lazy initialization with JVM tweaks, and proper instance‑concurrency sizing—to dramatically improve response times.
This article, part of a series analyzing Serverless platforms for Spring Boot, explains how to diagnose and reduce cold‑start latency, covering tracing, reserved instances, lazy initialization, JVM options, and instance concurrency tuning, using the high‑traffic Mall demo application as a concrete example.
The article reviews VS Code’s 2021 updates, outlines its 2022 roadmap centered on six key areas—including extensive Spring Boot enhancements—and speculates that these improvements aim to keep VS Code competitive against JetBrains’ upcoming Fleet IDE for Java developers.
This tutorial walks through creating a Spring Boot lottery application that caches activity, prize, and record data in Redis, covering project setup, Maven dependencies, YML configuration, MyBatis‑Plus code generation, Redis key management, lottery API, event‑driven data loading, stock handling, and asynchronous record saving.
This article presents a step‑by‑step guide to building a Spring Boot lottery application that leverages MyBatis‑Plus and Redis for caching activity, prize, and record data, covering project setup, dependencies, configuration, code generation, Redis integration, lottery logic, and stock management.
This article compares the Java Redis clients Jedis, Redisson, and Lettuce, explains their distinct features and thread‑safety models, and provides detailed Spring Boot configuration and code examples for using RedisTemplate, RedissonClient, and annotation‑based caching to implement distributed locks, hash operations, and cache management.
Spring Boot 3.0.0 M1, released on January 20 2022, upgrades the Java baseline to Java 17, migrates all Java EE APIs to Jakarta EE, drops support for several components, updates numerous Spring and third‑party dependencies, and outlines the upcoming release schedule.
An in‑depth comparison of Maven, Gradle, and the Maven Daemon (mvnd) examines their features, configuration differences, and real‑world build performance on Spring Boot projects, revealing that Gradle delivers the fastest packaging times while offering simpler, more readable build scripts.
This article explains how to handle a PC‑triggered device upgrade record by using Quartz for timed execution and Spring Batch for bulk processing, detailing Maven dependencies, YAML configuration, service and batch classes, custom reader/writer logic, a processor that calls an upgrade‑dispatch API, and the overall challenges encountered.
This guide walks you through designing a simple front‑back separation microservice architecture, implementing it with Java Spring Boot, deploying multiple instances with Eureka, adding Prometheus‑Grafana monitoring, logging, tracing, flow control, and finally installing Kubernetes using K8seasy and verifying high‑availability across the cluster.
This guide walks through analyzing and optimizing cold‑start latency for a Spring Boot e‑commerce app on Alibaba Cloud Function Compute,{} covering tracing, reserved instances, lazy initialization, JVM tuning, and instance concurrency settings to improve performance.
This article explains how to monitor, collect, and analyze real‑time logs, use multi‑dimensional metrics, perform local debugging, and enable cloud‑edge debugging for Spring Boot applications running on a Serverless platform, providing step‑by‑step commands and visual guides.
This article investigates MySQL's recommendation to avoid UUIDs as primary keys by benchmarking auto‑increment, UUID, and random snowflake IDs using Spring Boot and JdbcTemplate, analyzing insert speed, InnoDB index behavior, and the trade‑offs of each key strategy.
This guide walks through using Serverless Devs to collect real‑time logs, query metrics, perform local debugging, and enable cloud‑edge debugging for a Spring Boot e‑commerce application running on Alibaba Cloud Function Compute, with step‑by‑step commands and screenshots.
This article explains how to use Spring Batch together with Quartz to periodically process device upgrade records, covering Maven dependencies, configuration files, service implementation, batch job and step definitions, a custom processor for HTTP dispatch, entity mapping, and job retry scheduling for failed updates.
This guide walks you through installing Spring Boot Admin, configuring a monitoring server, adding the client starter to a Spring Boot application, enabling Actuator for expanded metrics, and using SBA to view health, JVM, logs, and real‑time performance data across single or clustered services.
This article explains the principles and workflow of Single Sign-On (SSO) using OAuth2.0, illustrates the process with a real‑life scenario, compares multi‑point and single‑point login, and provides a complete Spring Boot example for building an authorization server, client, and role‑based access control in micro‑service architectures.
This article explains four distinct approaches to register Spring Boot event listeners, shows how to create custom events and listeners, provides complete code examples for each method, and demonstrates their execution order through a test run.
This guide explains how to use Alibaba Cloud's Application High Availability Service (AHAS) with Sentinel to implement fine‑grained traffic control, hotspot detection, concurrency limits, circuit breaking, and fallback handling for Java and Go web applications, illustrated with a Spring Boot example.
This article explains why multiple Spring Boot timers can conflict due to single‑threaded execution, demonstrates the problem with example outputs, and shows how to configure a thread pool and use @Async annotations to run timers concurrently, preventing bottlenecks and avalanche effects.
This article demonstrates how to use Redis key‑expiration notifications together with Spring Boot to automatically close orders that remain unpaid after a configurable timeout, eliminating inefficient polling and providing a clean backend solution for order lifecycle management.
This guide introduces MongoDB fundamentals and demonstrates how to integrate it with Spring WebFlux to create a fully reactive CRUD service, covering dependencies, configuration, entity definitions, repository interfaces, service logic, and controller endpoints.
This article explains what MDC is, its API, advantages, common issues like traceId loss in child threads and HTTP calls, and provides practical solutions using custom thread‑pool wrappers and HTTP interceptors to ensure reliable logging in Spring Boot applications.
This article provides a step‑by‑step guide for integrating email functionality into a Spring Boot application, covering SMTP/IMAP/POP3 basics, configuring JavaMailSenderImpl, sending simple and MIME messages with attachments, and includes full source code examples and troubleshooting tips.
This article explains the concepts, architecture, communication flow, and implementation details of a custom RPC framework built with Spring Boot, Netty, and Zookeeper, covering service registration, load balancing, custom message protocols, serialization, TCP handling, and deployment steps.
magic-api is a Java‑based rapid API development framework that lets developers create HTTP interfaces through a UI without writing Controllers, Services, DAOs, or XML, offering extensive database support, dynamic scripting, Swagger generation, and easy Spring Boot integration.
This guide walks through setting up Spring Security for WebFlux, covering Maven dependencies, reactive security beans, password encoding, filter chain rules, functional routing, and method‑level authorization with complete code examples for a Spring Boot 2.5.8 project.
mica‑mqtt, built on t‑io, offers a simple, low‑latency, high‑performance open‑source MQTT component that integrates easily into existing services, supports multiple protocols and deployment scenarios, and includes Spring Boot starter, GraalVM compilation, and Redis‑based clustering for robust IoT solutions.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean and dependency‑injection annotations, and essential Spring Boot configuration annotations, illustrating their usage with code examples and explaining how they work together to build robust backend applications.
This article explains how to protect a Spring Boot API from traffic spikes by applying common rate‑limiting algorithms, configuring Redis for distributed throttling, writing Lua scripts for atomic counters, and integrating a custom @Limit annotation with AOP to enforce limits across a cluster.
This article explains how to use Maven profiles and the maven‑assembly‑plugin to create environment‑specific zip packages for a Spring Boot application and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and managing the deployed JAR on Linux.
This article provides a comprehensive overview of Seata, covering its origins, supported transaction modes, installation steps, database initialization, detailed configuration for registry and Apollo, client setup, transaction lifecycle components, and scheduled tasks that manage global and branch transaction states.
This article demystifies Single Sign-On using OAuth2.0 by illustrating the authentication and authorization flow through a real‑world analogy, explaining HTTP redirects, detailing the four grant types, and providing a complete Spring Boot implementation with role‑based access control for both client and server sides in microservice architectures.
This tutorial explains how to deploy a Spring Boot‑based monitoring solution that tracks multiple remote JVMs, covering repository cloning, configuration of server and client properties, Maven installation of the starter jar, and running the monitor‑server with example code snippets and screenshots.
This guide explains the technical stack, deployment steps, and core features of the open‑source wx‑manage system for managing multiple WeChat public accounts, including backend setup, database initialization, and frontend launch.
This guide demonstrates how to configure and execute ServiceTask nodes in Activiti 7.1 within a Spring Boot 2.3.12 application, covering service class implementation, three configuration methods (direct class, delegate expression, Spring bean method), BPMN XML definition, and a REST endpoint to start the process.
This article explains why Spring Boot's default scheduled tasks run on a single thread and demonstrates three practical ways to configure multithreaded scheduling using SchedulingConfigurer, application properties, and the @Async annotation with a custom thread pool.
This tutorial explains how to achieve automatic API idempotency in Spring Boot by leveraging Redis for token storage, creating a custom @AutoIdempotent annotation, configuring an interceptor to validate tokens, and providing complete code examples and test cases to prevent duplicate operations.
This step‑by‑step guide shows how to prepare a VM, clone the open‑source Mall project, build Docker images for its dependencies, push them to Alibaba Cloud Container Registry, configure Serverless Devs, and finally deploy both the backend and Vue‑based frontend to Alibaba Cloud Function Compute, including log inspection and verification.
This article explains the concept of Spring Boot starters, how they replace cumbersome Spring MVC setup with automatic dependency import and configuration, details the inner workings of Spring Boot's auto‑configuration mechanism, and guides you through creating custom starters and publishing them as reusable modules.
Learn how to replace Spring Boot 2.x's default Logback logging with the high‑performance Log4j2 by adding the starter dependency, configuring the logging file, and setting up a basic log4j2.xml, including code snippets and troubleshooting tips for a smooth migration.
