This comprehensive guide explains how to integrate Lua scripts with Spring Boot and Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation in Java, error handling, security considerations, and best practices for optimizing distributed applications.
This article explains Apache Tika’s core features and architecture, outlines common use‑cases, and provides a step‑by‑step Spring Boot tutorial—including Maven/Gradle setup, a service that extracts text with Tika, regex‑based sensitive‑info detection, a REST controller, optional front‑end, testing instructions, expected output, and extension ideas.
This article walks through multiple ways to configure API timeout in Spring Boot 3—including transaction timeouts, Resilience4j TimeLimiter, asynchronous request limits, RestTemplate/RestClient/WebClient HTTP client settings, and NGINX proxy timeouts—providing code samples and practical testing results.
This article explains how to achieve data isolation in a Spring Boot application by using a MyBatis interceptor that leverages JSqlParser to parse and modify SQL statements at the StatementHandler.prepare stage, covering tool introductions, dependency setup, interceptor implementation, testing examples, and the rationale behind intercepting the prepare method.
This article explains why asynchronous programming boosts Java application performance and walks through seven practical methods—Thread, FutureTask, CompletableFuture, Guava ListenableFuture, EA‑Async, Cactoos, and Jcabi‑Aspects—each illustrated with complete, runnable code examples.
This article explains how to handle image resizing, watermarking, rotation, and batch processing in Java using the Thumbnailator library, provides Maven setup, detailed code examples, and demonstrates seamless integration with Spring Boot for uploading and serving processed images.
This article explains how to integrate Lua scripts into Spring Boot applications with Redis, covering Lua fundamentals, advantages of Lua in Redis, practical use cases, step‑by‑step implementation in Spring Boot, performance optimizations, error handling, security considerations, and best practices for reliable backend development.
The article explains how to manage Maven dependencies in Java projects by using the mvn dependency:analyze command in IntelliJ IDEA to detect unused or undeclared libraries, interpret the results, clean up the pom.xml, and follow best‑practice testing to ensure project stability.
This guide walks through setting up a Spring Boot project, adding PDF.js static assets, creating a preview page, implementing a backend controller to serve PDF files, configuring MIME types, and testing the integrated PDF viewer for proper functionality.
The article presents a Spring Boot 3.4 solution that uses Redis SortedSet for fast pagination and Hash with HSCAN for multi‑condition fuzzy search, combining them via a temporary ZSet with TTL to deliver high‑performance, memory‑efficient queries on complex data sets.
This article introduces deepseek4j, a Spring‑Boot‑compatible library that fully supports DeepSeek R1’s chain‑of‑thought and billing features, offering reactive streaming, easy configuration, and a built‑in debugging page, with step‑by‑step setup and code examples to help developers quickly integrate the model.
This article explains why Spring Boot 3 uses Jackson for JSON handling, describes four effective methods—JsonNode, Map, @JsonAnySetter, and custom deserializer—to process dynamic JSON properties, and promotes a continuously updated collection of over 90 Spring Boot case studies with source code.
This article explains the Facade design pattern, its purpose of simplifying complex systems, outlines its benefits and UML structure, and demonstrates a complete Spring Boot example that encapsulates flight, hotel, and package services behind a BookingFacade for a travel‑booking application.
Explore how Spring Boot 3 leverages the @ExceptionHandler annotation to centralize error handling, customize responses based on the Accept header, configure view beans for HTML errors, and utilize new Spring 6.2 attributes, with complete code examples and testing guidance.
This article demonstrates how to achieve data isolation in a Spring Boot application by creating a MyBatis interceptor that modifies SQL statements using JSqlParser, covering tool introductions, dependency setup, interceptor implementation, testing for SELECT/INSERT/UPDATE/DELETE, and the rationale for intercepting the prepare method.
This article introduces the lightweight Sa-Token Java authentication framework, explains why it is chosen over Spring Security and Shiro, details its login and permission APIs with code examples, shows how to configure it in Spring Boot and WebFlux projects, and lists its extensive feature set for secure backend development.
This article announces a Spring Boot 3 case collection with 90 permanent examples, then walks through extending Spring Security login to include domain verification by defining a User entity, repository, custom filter, security configuration, Thymeleaf login page, controller, and test endpoint, complete with code snippets and screenshots.
This tutorial walks through installing Portainer for Docker container management, creating docker‑compose files to deploy Portainer, setting up a master‑slave‑sentinel Redis architecture, configuring a custom bridge network, and finally integrating Redis Sentinel into a Spring Boot project with Lettuce connection pooling.
The Spring Boot starter automatically registers XXL‑Job executors and job handlers at application startup by logging into the admin console, scanning beans for methods annotated with @XxlJob and @XxlRegister, and invoking the admin APIs to create missing groups and jobs, eliminating manual configuration.
This article introduces the QLExpress rule engine, outlines its key features such as thread‑safety and high‑performance execution, and provides step‑by‑step Spring Boot 3 integration examples—including dependency setup, simple expressions, function definitions, operator aliases, macro usage, and variable querying—complete with runnable code snippets and output illustrations.
This guide explains how to install Ollama, download and run the open‑source DeepSeek‑R1 language model locally, configure GPU acceleration, and integrate the model into a Spring Boot application using Spring AI to provide an API service for AI inference.
This article introduces Apache Tika, a powerful Java library for parsing many file formats, extracting text and metadata, performing OCR and language detection, and shows how to integrate it with Spring Boot to automatically detect sensitive information such as ID numbers, credit cards, and phone numbers.
Java 21’s virtual threads provide a lightweight, JVM‑managed alternative to OS threads that enables hundreds of thousands of concurrent tasks, simplifies scheduling, integrates easily into Spring Boot via a preview flag and Tomcat executor, and delivers up to five‑fold speed‑ups and lower latency in high‑load I/O‑intensive applications.
This article presents seven practical methods for recording API request logs in Spring Boot 3, including Filter, HandlerInterceptor, AOP, event listeners, Logbook, custom HandlerMethod, and RestTemplate/RestClient interceptors, complete with code samples, configuration steps, and execution screenshots.
This tutorial explains how to combine Spring Boot and Redis using Lua scripts, covering Lua fundamentals, performance advantages, practical use cases, step‑by‑step implementation in Spring Boot, error handling, security considerations, and best‑practice recommendations for backend developers.
Learn how to deploy the open‑source DeepSeek‑R1 model using Ollama on Linux or macOS, configure various model sizes, and integrate it into a Spring Boot application with Spring AI to build an API‑driven translation service, complete with code examples and testing.
This article systematically explains the importance of rate limiting in microservice systems, compares various governance frameworks such as Dubbo and Spring Cloud, introduces common algorithms like token‑bucket and leaky‑bucket, and provides detailed implementation examples using Guava, Sentinel, Redis+Lua, and a custom Spring Boot starter.
This article introduces seven core design patterns—Singleton, Factory, Builder, Strategy, Observer, Proxy, and Template—explaining their purpose, typical use cases, and providing complete Java code examples that integrate with Spring Boot 3 and Java 21, helping developers write cleaner, more maintainable software.
This article introduces the LiteFlow rule engine, explaining its architecture, supported rule file formats, component types, EL rule definitions, data context handling, configuration options, and demonstrates its application in an e‑commerce order processing scenario, highlighting hot‑deployment and performance benefits for Java backend development.
This article explains the fundamentals of transaction handling in Spring Boot, covering both programmatic approaches with PlatformTransactionManager and TransactionTemplate and declarative management using @Transactional, while detailing common pitfalls, propagation and isolation settings, and providing concrete code examples.
This article explains how to use Spring Boot's @Import annotation to modularize applications, add scanning entry points, and dynamically register beans via ImportSelector and ImportBeanDefinitionRegistrar, including code examples and configuration tips for Maven multi‑module projects.
This article announces a Spring Boot 3 practical case collection and provides a comprehensive Flyway tutorial—including installation, configuration, migration scripts, multi‑datasource usage, and visual verification—so developers can confidently manage database schema changes in Java backend projects.
This article explains the concepts, lifecycle methods, and configuration of Spring Boot's Filter, Interceptor, and AOP mechanisms, compares their execution order, and shows code examples to help developers choose the right technique for adding cross‑cutting functionality without altering core business logic.
This article deep‑dives into Spring Boot’s inner workings, explaining why dependency versions are omitted, how the spring‑boot‑starter‑parent and spring‑boot‑dependencies manage libraries, and how the composite @SpringBootApplication annotation orchestrates @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan to achieve seamless auto‑configuration and rapid application startup.
This guide demonstrates how to enable hot deployment of user‑provided Java interface implementations in a Spring Boot application, covering both annotation‑based and reflection‑based approaches, jar uploading, dynamic bean registration, class loading, and cleanup, with complete code examples.
This article walks through every extensible hook in Spring and Spring Boot—from container refresh and ApplicationContextInitializer to BeanFactoryPostProcessor, InstantiationAwareBeanPostProcessor, SmartInitializingSingleton, and more—showing when each runs, how to implement it, and practical code examples for Java developers.
This article demonstrates how to add Apache Tika dependencies to a Spring Boot project, configure tika-config.xml, create a Java configuration class, and use the injected Tika bean to detect, translate, and parse various document formats such as PDF, PPT, and XLS.
This article explains Spring Boot 3 bean destruction techniques—including DisposableBean, @PreDestroy, @Bean destroyMethod, AutoCloseable, and custom inference—provides complete code examples, and announces a continuously updated Spring Boot 3 case collection PDF for developers.
This article explains the concept of plugin mechanisms in Java and Spring Boot, covering benefits, common implementation approaches such as ServiceLoader and custom configuration, detailed code examples, and practical guidance for building extensible backend systems.
This article introduces Lua scripting in Redis, explains its fundamentals and advantages, and provides step‑by‑step instructions for integrating and executing Lua scripts within a Spring Boot application, including code examples, performance optimization, error handling, security considerations, and best practices.
This tutorial demonstrates how to build a Spring Boot application that extracts ID numbers and business license information from images by preprocessing them with OpenCV and recognizing text with Tesseract OCR, covering the full workflow from image handling to regex-based data extraction.
This guide explains how to configure Alipay sandbox credentials, expose a local Java Spring Boot service via a tunneling tool, add the Alipay SDK dependency, set up configuration files, implement payment and notification endpoints, and handle common initialization errors for seamless backend payment integration.
This article introduces LiteFlow, a lightweight Java component‑based rule engine that decouples complex business logic, explains its workbench design, demonstrates usage in both non‑Spring and SpringBoot environments with Maven setup and XML configuration, and details its core components, parsing, chain execution, and node processing.
This article explains why ConcurrentHashMap is ideal for high‑concurrency caching, outlines its key features, and provides step‑by‑step Java examples—including a basic in‑memory cache, an expiring cache, and an auto‑loading cache—plus a recommendation to use Caffeine for production workloads.
This article explains how to prepare the environment, configure GraalVM, use Maven plugins, and apply Spring Boot 3.0 AOT and RuntimeHints to compile a Spring Boot application into a fast‑starting native executable, including Docker packaging and underlying AOT principles.
This article demonstrates how to modify Spring Boot 3 log levels and refresh the application.yml configuration on the fly using Actuator endpoints and custom code, providing step‑by‑step examples, code snippets, and screenshots to help developers avoid service restarts.
This guide tackles the problem of oversized Spring Boot JARs by showing how to separate library JARs and configuration files from the main artifact, presenting three Maven‑based solutions—spring‑boot‑maven‑plugin, maven‑jar‑plugin, and maven‑assembly‑plugin—complete with configuration snippets, build commands, and deployment tips.
This article introduces the XXL‑JOB open‑source distributed scheduler, compares it with Quartz and other solutions, and provides a step‑by‑step tutorial for server deployment, executor configuration, task development, execution, logging, and the underlying Netty‑based communication design, complete with code examples.
This article explains Java 21's virtual threads, their lightweight and auto‑managed nature, demonstrates basic usage and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance tips for high‑concurrency applications.
This article introduces Spring's @Lazy annotation, explains its purpose and scenarios such as improving startup speed, breaking circular dependencies, and correctly injecting prototype beans, and provides five practical code examples while also announcing a continuously updated Spring Boot 3 case collection with a PDF ebook and source code.
This article explains how to build a multi‑level office approval workflow using the Activiti engine, covering BPMN diagram design, deployment, Java code for process creation, task handling, gateway logic, database schema, API overview, framework comparisons, and further learning directions.
This tutorial walks you through creating a Spring Boot project, defining a REST controller, running the application, testing the endpoint, expanding CRUD methods, configuring properties, and optionally adding service and repository layers, all with clear code examples.
This article explains how to integrate the networknt JSON Schema validator into a Spring Boot application to enforce structured AI output, covering dependency setup, schema definition, service implementation, custom output validator, and exception handling, ensuring reliable, correctly formatted JSON responses from AI models.
LiteFlow is a lightweight Java rule engine that lets developers orchestrate serial and parallel business workflows using XML, JSON or YAML rule files stored in back‑ends like SQL or Zookeeper, offering NodeComponent, NodeSwitchComponent and NodeIfComponent types, EL syntax, Spring Boot integration, and high‑performance execution monitoring.
This guide walks you through installing Spring Boot CLI, explains its Groovy‑based features, demonstrates creating and running a Hello World web app, shows how to use @Grab for dependencies, test with spring test, package into executable JARs, and explore init and shell commands.
This article demonstrates how to use Spring Plugin in Spring Boot 3 to create a modular, extensible payment system supporting multiple methods, covering dependency setup, interface definitions, implementations, plugin registration, metadata handling, ordering, and testing, with complete code examples and diagrams.
This article presents LiteFlow, a lightweight yet powerful rule engine built on Spring Boot, explains its architecture, component types, EL rule file syntax, data context handling, configuration options, and demonstrates a practical e‑commerce workflow example with full code snippets and deployment tips.
This article compares Server‑Sent Events, WebSocket, and traditional polling, explains why SSE can replace heavyweight WebSocket in one‑way push scenarios, provides configuration and code examples for Spring Boot, and shares practical lessons from real project experiences.
This tutorial explains how to create a traffic sign recognition application using Spring Boot and Java Deeplearning4j, covering CNN selection, dataset organization, Maven dependencies, data loading, model construction, training, prediction, unit testing, and expected results.
This article introduces the URule rule engine, explains its core concepts and library types, shows how to install and configure it within a Spring Boot project, demonstrates rule set and decision‑table creation, and provides complete Java code examples for practical usage.
This article demonstrates a practical approach to protect sensitive Spring Boot applications by encrypting the JAR with AES, storing the key in a secure vault, and using a custom ClassLoader to decrypt and load classes at runtime, while highlighting key management, performance, and additional hardening considerations.
This article introduces magic-api, a Java‑based rapid development framework that lets developers create HTTP APIs without writing traditional Controllers, Services, or DAOs, and provides a UI for designing endpoints, extensive database support, clustering, Swagger integration, and a quick‑start guide with Maven and configuration examples.
This article introduces the Liteflow rule engine, explains its architecture and supported file formats, demonstrates how to configure and use it with Spring Boot, details component types and EL rule files, and showcases a practical e‑commerce workflow example with code snippets.
This article explains the differences between replace and replaceAll, how Integer caching affects equality checks, why constructing BigDecimal with double can cause precision loss, the nuances of string concatenation, the distinction between isEmpty and isBlank, when to check for null in MyBatis mapper results, and the correct way to use indexOf in Java.
This article examines the ten most frequent errors developers make when building Spring Boot REST APIs, explains the negative impact of each mistake, and offers concrete, up‑to‑date solutions with code examples, while also highlighting a continuously updated collection of over 70 Spring Boot 3 practical case studies.
This article explains how to use Maven plugins to build a Spring Boot project into an executable JAR, separate its dependencies into a lib folder, and create a Docker image that copies those libraries, enabling clean deployment of Java backend services.
This article explains how to build a Spring Boot service that preprocesses images with OpenCV, extracts text using Tesseract OCR, and then parses identification numbers such as ID cards and business licenses via regular expressions, providing complete code examples and dependency details.
This article introduces the evolution of Java workflow engines, explains core BPMN concepts, and provides a comprehensive tutorial on integrating Flowable with Spring Boot—including Maven dependencies, database configuration, BPMN diagram creation, service task implementation, diagram viewing API, and unit testing.
This article explains OAuth2.0 fundamentals, outlines its roles and grant types, and provides step‑by‑step Spring Boot code to build an authentication server, configure security, set up a resource server, and test the full authorization flow with token handling.
Spring Boot enables modular backend development by placing each feature in its own Maven module and using @Import (or custom annotations, ImportSelector, ImportBeanDefinitionRegistrar, and @ConditionalOnProperty) to load configuration classes, scan components, and conditionally register beans while keeping the application a single monolithic program.
This article explains Spring Boot’s asynchronous processing mechanism, covering its purpose, the @Async annotation, configuration steps, custom thread pool setup, handling return values, and typical use cases, enabling developers to improve performance and responsiveness in backend applications.
This guide explains how to replace manual installation of MySQL, Redis, and Kafka with a Docker Compose configuration and Spring Boot integration, providing step‑by‑step instructions, code snippets, and tips for controlling container lifecycle during development.
This article explores eight practical use cases for message queues—including asynchronous processing, service decoupling, traffic shaping, delayed tasks, log collection, distributed transactions, remote calls, and broadcast notifications—providing code examples and architectural guidance for building robust backend systems.
This article explains how Spring AOP’s @DeclareParents introduces new interfaces to proxied beans at runtime, walks through defining interfaces, implementations, aspect configuration, testing with Spring Boot 3, and also covers perthis and pertarget aspect instantiation models for fine‑grained lifecycle control.
This article explains how to modularize a Spring Boot monolith by splitting it into Maven modules, leveraging @ComponentScan, @Import, custom annotations, ImportSelector, ImportBeanDefinitionRegistrar, and conditional loading to dynamically include or exclude functionality at runtime.
This article explains why plugin mechanisms improve modularity, extensibility, and third‑party integration, then walks through practical Java SPI implementations, custom configuration loading, and Spring Boot’s spring.factories approach, providing complete code examples and step‑by‑step guidance for building a robust plugin system.
This article introduces a Spring Boot 3 case collection and then provides a comprehensive tutorial on using Apache Commons Chain, covering its core interfaces, basic and advanced usage, resource release, catalog management, exception handling, and integration with Spring Boot.
This article explains how to integrate Spring Boot with MyBatis, configure a single Druid data source, implement a dynamic routing data source for multiple databases, and use custom annotations and AOP to switch databases at runtime, including full code examples and transaction management.
This article introduces Spring's SseEmitter for server‑sent events, outlines its key features and use cases, and provides a complete end‑to‑end example—including Vue 3 front‑end setup, JavaScript client, and Spring Boot controller code—to enable real‑time message pushing between server and browser.
This article explains how to streamline Spring Boot production releases by extracting libraries and configuration files from the main JAR, using various Maven plugins such as spring-boot-maven-plugin, maven-dependency-plugin, maven-assembly-plugin, and maven-jar-plugin to create lightweight, fast‑deployable packages.
This article examines eight common Java string concatenation techniques, benchmarks them with JMH, presents the performance results—including a clear ranking where the '+' operator outperforms others—and provides a downloadable Spring Boot 3 case collection for deeper learning.
This article guides readers through installing the Portainer Docker management UI, creating Docker‑Compose files for Portainer, deploying a Redis master‑slave cluster with Sentinel, configuring custom bridge networks, and integrating the Sentinel setup into a Spring Boot application using Lettuce and RedisTemplate.
This article introduces several Chinese open‑source AI platforms, shows how to import their Java SDKs, obtain API keys, run test demos, encapsulate a reusable AI module with Spring Boot configuration, and apply prompt‑engineering techniques to generate AI‑driven questionnaire content.
This article highlights seven often‑overlooked Spring Boot 3 details—ranging from dependency injection and controller design to configuration, constructor simplicity, environment profiles, exception handling, and response handling—providing concrete code examples and best‑practice recommendations to improve code quality and maintainability.
This article explains six typical techniques—@RequestParam, @PathVariable, @MatrixVariable, @RequestBody, @RequestHeader, and @CookieValue—for extracting request data in Spring Boot APIs, providing usage scenarios and concrete code examples for each method.
To remediate CVE‑2023‑6378 in a Spring Boot 2.7.x application, you must replace the default logging starter with a direct Logback 1.2.x dependency (e.g., 1.2.13), because Spring Boot 2.7 cannot use Logback 1.3.x due to the removed StaticLoggerBinder class; the only other option is to upgrade the whole stack to Spring Boot 3.x, Logback 1.4.x, and JDK 11.
Spring Boot 3.4 introduces extensive updates—including RestClient and RestTemplate auto‑configuration, revised HTTP client factories, refined bean validation, graceful shutdown defaults, a new Paketo tiny builder for OCI images, deprecations, and numerous configuration and observability enhancements—providing developers with a comprehensive guide to upgrade and leverage the latest features.
This guide explains how to monitor a Spring Boot application using Prometheus, configure Spring Boot Actuator, run Prometheus (including Docker deployment), set up Grafana for visualizing metrics, and create custom metrics with Micrometer, providing step‑by‑step instructions and code examples.
A Spring Boot application on CentOS 6.x hung while fetching Apollo configuration because a single /etc/hosts entry listed dozens of domain names, causing hostname resolution to fail; splitting the entry into multiple lines restored normal startup and highlighted a kernel‑specific hosts parsing bug.
This article provides a comprehensive tutorial on using the Super CSV library in Spring Boot 3, covering Maven dependencies, core APIs for reading and writing CSV files, cell processors, handling irregular data, and a complete Spring MVC controller example for CSV download, all illustrated with code snippets and screenshots.
This guide walks through building Spring Boot controller endpoints, standardizing request parameters, applying unified status codes with ResultVo, leveraging @Validated for bean validation, and using @RestControllerAdvice to globally handle exceptions and automatically wrap responses.
This article compares the performance of several Java bean‑mapping utilities—including Spring BeanUtils, Apache BeanUtils, Orika, Cglib BeanCopier, ModelMapper, MapStruct, and manual getter/setter code—by converting a sample Entity to a DTO 10,000 times and summarizing the results and best‑use recommendations.
This tutorial explains how to combine Spring Boot, MyBatis, and multiple databases using Druid connection pools, dynamic routing data sources, custom annotations, and AOP, providing complete configuration examples, code snippets, and best‑practice guidance for backend developers.
This article introduces OAuth2.0 concepts, outlines its roles and grant types, and provides a step‑by‑step Spring Boot implementation of an authorization server, resource server, and test client, followed by test results and promotional information.
This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.
The article details how a high‑traffic SaaS platform was migrated from a public‑cloud micro‑service architecture to a single on‑premise server using Tencent’s WeDa low‑code platform, describing service merging, bean and configuration refactoring, database synchronization, and automated testing that reduced over thirty services to a single process and cut hardware costs to an 8‑CPU, 16‑GB machine.
This article compares Spring Boot's declarative @Transactional annotation with programmatic transaction management using TransactionTemplate, TransactionalOperator, and TransactionManager, explains their suitable scenarios, provides code examples, and presents JMeter performance tests that show how the right choice can dramatically improve throughput.
This article provides a step‑by‑step tutorial on Apollo, an open‑source configuration center, covering its core concepts, dimensions, client design, Maven integration, Spring Boot setup, JVM parameters, testing scenarios, cluster/namespace usage, Docker image creation, and Kubernetes deployment for microservice applications.
This article provides a comprehensive overview of Spring and Spring Boot's extensible interfaces, detailing each extension point, its lifecycle stage, usage scenarios, and sample code, enabling developers to better understand and customize bean initialization within the backend framework.
This article explains how to replace Shiro with jCasbin for permission management in Spring Boot, covering Maven dependency setup, configuration files, Enforcer initialization, custom policy handling, and a simple servlet filter for runtime authorization checks.
