This tutorial explains what Spring AI is, walks through creating a Spring Boot project with Maven, adding the necessary dependencies, writing a simple controller that forwards user messages to a local DeepSeek model, configuring the application, and testing the AI‑powered endpoint.
This article introduces the URule rule engine, explains its core concepts, shows how to install and configure it in a Spring Boot project, demonstrates library definitions, rule set creation (wizard and script modes), decision table usage, and provides real‑world scenario code examples for backend developers.
The article explains why existing Java AI frameworks struggle with DeepSeek R1’s chain‑of‑thought and streaming features, introduces DeepSeek4j 1.4 as a targeted solution, details its core capabilities, and provides a step‑by‑step guide to integrate it with Spring Boot and Project Reactor.
This article explains the default Tomcat settings in Spring Boot 2.7.10, details core parameters such as connection queue length, max connections, thread pool sizes, keep-alive and timeout options, and demonstrates how to inspect and test these configurations with code examples and command-line tools.
This article walks through creating a fully automated Spring Boot and MyBatis code generator using Freemarker templates, detailing each step from extracting table metadata to generating DAO, service, controller, and entity classes, and shows how a single-table CRUD can be produced in seconds.
This article introduces a Spring Boot 3 case collection with over 100 permanent examples and then provides a complete tutorial on implementing audit logging using Spring AOP, SpEL, asynchronous processing, custom annotations, JPA entities, and batch persistence to efficiently record operation details.
This article explains the concept and benefits of logical deletion, then demonstrates how to implement it in Spring Boot 3 using JPA annotations like @SQLDelete and @SoftDelete, and MyBatis‑Plus configuration, complete with code examples and SQL output.
This guide walks you through creating a Spring Boot project, configuring DeepSeek's large language model via SiliconFlow, setting up OpenAI‑compatible parameters, and implementing a REST controller that returns weather forecasts using the model, complete with step‑by‑step code snippets, configuration files, and deployment instructions.
This article explains how to design a modular Spring Boot backend management system called XiaoLe, covering essential design principles such as single responsibility, high cohesion, low coupling, reusability, clear interfaces, layered architecture, and testability, and provides detailed Maven module structures and POM configurations for each component.
The article introduces DeepSeek4j 1.4, a Java‑based framework that overcomes Spring AI’s limitations by fully preserving DeepSeek’s chain‑of‑thought and billing features, adding reactive streaming, providing Spring Boot starter integration, and offering quick‑start code samples and configuration guidance.
This article introduces a comprehensive Spring Boot 3 case collection and provides a detailed guide on using @ConfigurationProperties, constructor binding, @DefaultValue, and record types for type‑safe configuration, including examples of nested properties, collections, and default values, while promising ongoing updates and free source code for subscribers.
This article explains how to make custom classes visible to Spring Boot by loading external JAR files through four methods—extending the classpath, using Spring Boot's loader.path parameter, creating a custom ClassLoader, and modifying the boot classpath—while also showing how to configure scanning and packaging details.
This article investigates whether the JVM terminates when a thread encounters an OutOfMemoryError, demonstrating through Spring Boot controllers and multithreaded examples how main and child threads, daemon settings, and explicit OOM handling affect JVM shutdown behavior.
This article introduces a growing collection of over 90 Spring Boot 3 practical articles and a PDF ebook, then provides a step‑by‑step tutorial on integrating JavaMelody for monitoring, customizing metrics, and securing the monitoring UI within Spring Boot applications.
This guide showcases nine distinct Spring Boot 3 API development techniques—from classic @RestController annotations to functional RouterFunction beans and custom Actuator endpoints—providing complete code samples, configuration details, and a promise of ongoing updates with a downloadable PDF of over 90 practical cases.
This article introduces LiteFlow, a lightweight yet powerful Java rule engine, explains its architecture, component types, EL rule file syntax, configuration options, and demonstrates a real‑world e‑commerce workflow example, providing code snippets and deployment tips for backend developers.
DeepSeek4j 1.4 brings a Java‑native integration framework that fully preserves DeepSeek's chain‑of‑thought capabilities, adds reactive streaming, and offers a one‑line Spring Boot starter, enabling developers to quickly embed the model with simple configuration and rich debugging tools.
This article explores why Spring MVC automatically binds HTTP header values to controller method parameters, demonstrates the issue with a sample Spring Boot 3.4.0 project, analyzes the underlying HandlerMethodArgumentResolver and ServletModelAttributeMethodProcessor code, and provides two practical solutions to prevent unwanted header binding.
This guide explains why graceful shutdown is essential for XXL‑JOB scheduled tasks, analyzes the executor‑admin interaction chain, identifies interruption issues, and provides a three‑step solution with code examples and configuration tips for cloud‑native environments.
This guide explains how to use Spring Boot, AOP, and custom annotations to implement dynamic MySQL master‑slave data source switching, automatically falling back to the master when a slave fails, covering configuration, Maven dependencies, enum definitions, data source beans, routing logic, and usage examples.
This guide explains why DeepSeek4j is needed, its core features, and provides step‑by‑step instructions—including dependency setup, configuration, code examples, and a complete RAG pipeline using Milvus—to help developers quickly create a private AI knowledge base with Spring Boot.
This article walks through installing Ollama, downloading the DeepSeek‑r1:1.5b model, configuring Spring AI in a Spring Boot 3 project, and exposing the model via a REST endpoint with Server‑Sent Events, providing complete code snippets and step‑by‑step screenshots for a functional AI integration.
This article introduces the Java JSch library for Spring Boot 3, demonstrating how to read remote files without downloading, execute commands on a remote host, and obtain an interactive shell prompt, complete with Maven dependency setup, code examples, and execution results, while promising ongoing updates to the case collection.
This comprehensive guide covers RabbitMQ fundamentals, installation on Windows, Linux, and Docker, configuration for durability and monitoring, Java integration examples, high‑availability architectures, clustering, and practical troubleshooting tips for building reliable distributed systems.
This article introduces the Liteflow lightweight rule engine for Java, explains its architecture, configuration, component types, EL rule file syntax, data context handling, and demonstrates a practical e‑commerce workflow, highlighting hot‑deployment and performance benefits for backend development.
This article introduces ShardingSphere's three components—Sharding-JDBC, Sharding-Proxy, and the upcoming Sharding-Sidecar—explains why sharding is needed for relational databases, demonstrates horizontal data sharding concepts, and provides a complete Spring Boot example with configuration, code, and asynchronous batch insertion.
This guide walks through the prerequisites, GraalVM installation, Maven setup, and step‑by‑step packaging of a Spring Boot 3 application into a native executable using AOT compilation, runtime hints, and Docker, demonstrating dramatically faster startup times.
Learn how to efficiently handle large-scale Excel import and export in Java web applications using EasyExcel, leveraging Java 8 functional programming, reflection, thread pools, and custom ReadListener implementations to minimize memory usage, improve performance, and support flexible data mapping and dynamic schema handling.
This guide explains how to configure the Alipay sandbox, set up an Ngrok tunnel for external callbacks, add the Alipay Java SDK dependency, create Spring Boot configuration and controller classes, implement the payment flow and callback handling, and troubleshoot common initialization errors.
The article explains the Facade design pattern and demonstrates its use in a Spring Boot travel‑booking application, where a BookingFacade aggregates FlightService, HotelService, and PackageService to provide a single bookTravel method that a REST controller calls, simplifying the API and reducing coupling.
This guide walks through building a Java RAG system with DeepSeek R1, Milvus, and Spring, covering environment setup, vector model integration via OpenAI protocol, Maven dependencies, data embedding, and a chat endpoint that combines semantic retrieval with LLM generation.
This comprehensive guide walks through ShardingSphere's core sharding strategies and the twelve built‑in sharding algorithms, showing how to configure each with YAML, illustrating their behavior with code examples, and highlighting practical tips for choosing the right approach in real‑world database partitioning scenarios.
This article presents a continuously updated collection of over 90 practical Spring Boot 3 examples, covering request/response access, ThreadLocal handling, async interceptors, request metadata extraction, custom type converters, 404 error handling, and related source code to help developers build robust backend services.
This guide explains the need for JDBC connection pools, compares popular pools like HikariCP and Druid, and provides step‑by‑step configurations for both custom property files and Spring Boot auto‑configuration, helping you efficiently manage database connections in Java applications.
This article introduces a continuously updated Spring Boot 3 case collection and PDF e‑book, then dives into the @Conditional annotation, custom condition interfaces, parameterized enhancements, SpringBootCondition usage, and multi‑condition combinations, providing complete code examples and test results.
The article shows how to replace hard‑coded strings in Spring Boot configuration files with type‑safe Java enums, using @ConfigurationProperties to bind YAML values to enum fields, thereby improving readability, maintainability, and eliminating magic numbers, illustrated through a user‑role example with controller and Thymeleaf view.
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.
