Learn step‑by‑step how to integrate Spring AI Alibaba into a Spring Boot backend, configure API keys, add necessary dependencies, create a CORS‑enabled chat controller, and then develop a matching React frontend that streams AI responses, enabling a complete Java‑to‑React AI chat application.
This article demonstrates how to handle Java Long precision loss in Spring Boot 3 front‑end displays, configures Jackson to serialize Long as String, uses @JsonValue for single‑property serialization, and creates custom annotations with a SensitiveSerializer for data masking, complete with code examples and screenshots.
This article explains how to use Filebeat as a lightweight log shipper together with Graylog for centralized log aggregation, storage, and analysis, covering installation, configuration files, Docker deployment, Spring Boot integration, and query techniques for efficient operations monitoring.
Learn how to replace manual jar uploads and java -jar commands by configuring IntelliJ IDEA and Docker for one‑click remote deployment of Spring Boot applications, covering prerequisite setup, Docker daemon basics, Dockerfile creation, and step‑by‑step configuration to streamline and automate the deployment process.
This article explains various Spring Boot approaches for formatting dates in API responses, covering frontend JavaScript utilities, Java SimpleDateFormat and DateTimeFormatter, global Jackson settings, annotation‑based formatting, custom converters, ControllerAdvice initBinder, and timestamp output methods.
This article examines common pitfalls in Spring Boot controller implementations, demonstrates how to refactor messy controllers into clean, maintainable code using @Valid for input validation and a centralized exception handler, and highlights best‑practice guidelines for backend development.
WeBlog is a Spring Boot and Vue 3.2 based full‑stack blog that combines a MySQL‑backed backend with JWT authentication, MinIO storage, and a hand‑crafted Element Plus admin UI, offering markdown publishing, analytics dashboards, and open‑source repository links for developers to explore.
This guide explains Apache Tika's document parsing capabilities, shows how to download and run the Tika app, demonstrates extracting text and metadata from a PDF, and provides step‑by‑step instructions for integrating Tika into a Spring Boot project with full code examples.
This article walks through the complete process of implementing WeChat QR code login using a Java Spring Boot backend, covering prerequisite configuration, Maven dependencies, configuration classes, QR code generation, callback handling, session storage in Redis, and frontend integration.
This article demonstrates several techniques—including @Bean methods, @Component inheritance, BeanFactoryPostProcessor, and custom FactoryBean implementations—to instantiate multiple beans of the same class in a Spring Boot 3 application, comparing their advantages and limitations.
This article explains how to achieve lossless releases for Spring Boot microservices by deregistering old instances, handling shutdown hooks, configuring graceful shutdown in Spring Boot 2.3+, and integrating custom interceptors for various containers and registration centers.
This article examines the challenges of sprawling order‑processing code in logistics systems and presents a strategic component‑based approach using the open‑source LiteFlow framework, detailing its architecture, execution rules, example XML flow, Java implementations, and key advantages for scalable backend development.
This article introduces Apache Tika for document parsing, outlines its key advantages, and provides step‑by‑step Spring Boot 3 examples—including facade parsing, text, PDF, auto‑detect, HTML conversion, custom configuration, and file‑upload integration—complete with code snippets and output screenshots.
This article walks through setting up a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common pitfalls, and provides essential scaffold code such as global exception handling, logging, CORS configuration, Swagger setup, and response wrappers.
This article walks through Spring Boot 3's powerful extension points—including AutoConfigurationImportFilter, ApplicationContextFactory, SpringApplicationRunListener, and ApplicationContextInitializer—showing how to implement, register, and test custom behavior with complete code examples and configuration steps.
This guide walks through installing the kkfileviewer container, building its Docker image, running it, and then integrating MinIO storage into a Spring Boot project with full configuration, utility classes, and REST endpoints for file upload and preview.
This tutorial explains how to design a MySQL table for hot‑search records, generate Java entity and mapper classes using MyBatis Generator, create unique IDs for each entry, and implement scheduled Java crawlers for Douyin and Baidu hot‑search data that persist the results via Spring‑Boot services.
This article explores the Java Optional class with practical examples, showing how to avoid NullPointerException, simplify exception handling, provide default values, chain operations, and improve code readability in Spring Boot 3 projects.
This article explains how to secure Spring Boot deployment packages by using Maven plugins for code obfuscation and encryption, configuring classfinal‑maven‑plugin to encrypt class files, configuration files, and libraries, and demonstrates password‑less and password‑protected startup as well as machine‑bound execution to prevent reverse engineering.
This article demonstrates how to enable and use Spring Boot 3's @Async annotation together with Java's CompletableFuture to create custom thread pools, run multiple asynchronous REST calls concurrently, aggregate their results, and handle exceptions, providing a complete backend solution for high‑performance APIs.
This article explains how to use Prometheus together with Spring Boot Actuator and Micrometer to collect, expose, and visualize application metrics, including step‑by‑step dependency configuration, YAML settings, Docker deployment of Prometheus and Grafana, and adding custom metrics for comprehensive monitoring.
This article explains what Java virtual threads are, how they differ from regular OS threads, demonstrates configuring Spring Boot to use them, and presents performance benchmarks showing virtual threads dramatically outperform traditional threads in both async service calls and simple HTTP requests.
This article explains how to use Filebeat as a lightweight log shipper together with Graylog, Elasticsearch, and MongoDB to collect, process, and visualize logs from multiple environments, including detailed configuration examples, deployment scripts, and integration with Docker and Spring Boot.
This article walks through the challenges of setting up a Java development environment, demonstrates how to create a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, showcases essential Maven configurations and code snippets for global exception handling, logging, CORS, Swagger, and recommends useful in‑memory tools such as embedded Redis, DB, Kafka, Hutool, MyBatis‑Plus, MapStruct, and Redisson.
This article demonstrates how to implement fine‑grained permission checks in Spring Boot 3 without using Spring Security, by creating custom HandlerInterceptors, JWT utilities, DAO and service layers, and integrating SpEL expressions for dynamic authorization, complete with code snippets and test results.
This guide walks you through setting up Ollama for local large‑model serving, creating a Spring Boot project with Spring AI support, writing a unit test to query the model, and explains how to add the necessary dependencies for AI integration in existing Java applications.
This article explains how to integrate Spring Boot with Java Deeplearning4j to create a traffic sign recognition system, covering CNN fundamentals, dataset organization, Maven dependencies, data loading, model construction, training, prediction, and unit testing, complete with code examples.
This article explains why stale JavaScript can break functionality, outlines the risks of caching such as outdated bugs, security flaws, and debugging difficulties, and provides practical Java‑side solutions—including versioned URLs, cache‑control headers, static‑resource policies, and ETag/Last‑Modified handling—to ensure browsers always load the latest scripts.
This article demonstrates how to dynamically load Spring Boot configuration from a database and refresh specific beans at runtime using Spring Cloud's ContextRefresher, enabling configuration changes without restarting the application.
Learn how to efficiently convert internal entities to external DTOs in Spring Boot 3 using ModelMapper, covering library comparisons, Maven setup, configuration, entity and DTO definitions, service, facade, controller implementation, and advanced features like custom mappings, property skipping, value conversion, and conditional mapping.
This guide demonstrates how to use Spring State Machine to elegantly manage order status changes by defining states, events, configuring transitions, and implementing listeners, providing Maven dependencies and Java code examples for building extensible, event‑driven workflows in backend applications.
This article demonstrates two practical methods for restricting request IPs—configuring allow/deny rules in Nginx and building a Spring Boot whitelist check using a custom HandlerInterceptor, complete with database schema, service logic, and MVC configuration.
This article walks through creating a Spring Boot project, handling IDE setup, managing Spring Cloud and Kafka version compatibility, using Maven for dependency management, and provides essential scaffold code such as global exception handling, logging aspects, CORS configuration, and Swagger integration.
The article details how a Java SDK for a CIM instant‑messaging system was redesigned using Java 8+ features and the Builder pattern, introduced a lightweight proxy resembling RPC frameworks with dynamic‑URL support, and added comprehensive integration tests that verify automatic client reconnection and reliable message delivery across clustered servers.
This article presents ten practical techniques—including built‑in annotations, custom constraints, server‑side checks, internationalized messages, validation groups, cross‑field rules, exception handling, testing, and client‑side considerations—to help developers implement robust validation in Spring Boot applications.
This article provides a comprehensive guide to using Alibaba's JetCache in Java Spring Boot projects, covering dependency setup, configuration of local and remote caches, annotation‑based caching, API usage, testing procedures, and troubleshooting common integration errors.
This article provides a comprehensive, step‑by‑step guide to using Spring Boot 3's @ComponentScan annotation, covering basic usage, package filtering, include/exclude filters, lazy initialization, custom name generators, scoped proxies, and custom scope resolvers, complete with runnable code samples and output screenshots.
This article walks through the design and implementation of symmetric request/response encryption for a Spring Boot API, covering requirement analysis, data models, custom ControllerAdvice for decryption and encryption, serialization challenges with FastJson and Jackson, and final configuration to keep encrypted payloads consistent across Android, iOS, and H5 clients.
This article explains how to use Spring Boot's built‑in request logging, request/response wrappers, OncePerRequestFilter, and AOP utility classes such as AopContext, AopUtils, and ReflectionUtils, providing configuration snippets and practical code examples for backend developers.
This article explains what Tomcat is, its core functions, how to set up a simple servlet manually, and why Spring Boot hides Tomcat by default while still allowing you to switch to alternatives like Jetty or Undertow.
This article introduces Alibaba's JetCache Java caching framework, explains how to integrate it with Spring Boot and Redis, provides detailed configuration and code examples for local, remote, and multi‑level caches, and covers testing procedures and common error resolutions.
This article introduces four Java HTTP client libraries—Java HttpClient, Apache HttpComponents, OkHttp, and Spring WebClient—explains their key features, provides async GET and sync POST code examples for each, and offers guidance on selecting the right client for Spring Boot and plain Java projects.
Bean Searcher is an open‑source, Apache‑2.0 licensed ORM search engine that outperforms MyBatis by up to 100×, offering one‑line multi‑table joins, pagination, dynamic sorting, field aggregation, and extensive extensibility, with simple Spring Boot integration and customizable components for rapid backend development.
This comprehensive tutorial explains how to design and implement RESTful APIs with Spring Boot 3.2.5, covering all major HTTP methods (GET, HEAD, POST, PUT, DELETE, PATCH), best‑practice endpoint design, response handling, status‑code usage, pagination, filtering, versioning, caching, and security considerations.
This article explains how to create a consistent JSON API response format—including custom status codes, message fields, and a Result wrapper—by using a @ResponseResult annotation, an interceptor, and ResponseBodyAdvice in Spring Boot, while also offering tips for optimization and error handling.
The article explains why UUIDv4 primary keys hurt performance and storage, then demonstrates how to replace them in a Spring Boot 3.3 application with a custom Snowflake‑based 64‑bit ID generator, providing full Maven setup, configuration, entity, service, REST controller, and Thymeleaf UI example.
This tutorial demonstrates how to use the mybatis-plus-join (MPJ) library to perform left and right join queries in a Spring Boot project without writing XML, covering dependency setup, mapper changes, query construction, pagination, and practical code examples.
This article walks through creating a Spring Boot 3 application from scratch, demonstrating how to customize the ApplicationContext, embed a Tomcat server, define a custom SpringApplication class, configure web components, and test REST endpoints, providing complete code snippets and explanations for each step.
This guide walks through installing kkfileviewer in a Docker container, building and running the image, then shows how to add MinIO support to a Spring Boot project with Maven dependencies, configuration classes, utility methods, and REST endpoints for file upload and preview.
This article explores Spring Boot's asynchronous task and request mechanisms, detailing how @EnableAsync, @Async, @EnableScheduling, and @Async annotations configure thread pools, examines the underlying source code, and demonstrates custom configurations for executors and schedulers to control concurrency.
This article provides a comprehensive analysis of how Spring Boot integrates Log4j2 (and Logback), detailing the internal logging architecture, configuration options, initialization flow, logger groups, and how to perform hot updates of logger levels via the LoggersEndpoint or custom APIs.
This tutorial walks through six practical techniques—@Qualifier, @Primary, @Profile, collection injection, @Priority, and custom @Conditional—to control which implementation of a Spring Boot interface is autowired, complete with code examples and usage tips.
This article explains how to configure a Spring Boot scheduled task to execute just once, covering three approaches—specifying a start time with TaskScheduler, using @Scheduled with an initial delay, and creating a custom PeriodicTrigger—complete with runnable code examples.
This article explains how Spring Boot can handle HTTP requests asynchronously using Callable, WebAsyncTask, and DeferredResult, detailing the underlying servlet workflow, thread‑pool configuration, and when asynchronous processing truly improves throughput versus CPU‑bound workloads.
This article introduces the Forest Java HTTP client, explains its architecture and dynamic‑proxy mechanism, and provides step‑by‑step Spring Boot examples—including dependency setup, configuration, declarative interfaces, request annotations, parameter handling, and programmatic usage—so developers can quickly adopt declarative HTTP calls in their backend services.
This article explores four common batch‑update techniques in MyBatis, compares their performance, shows how to configure Druid and Spring Boot to allow multi‑statement execution, and provides practical code examples and configuration tips for reliable large‑scale data updates.
This article introduces RabbitMQ, explains its core features and messaging model, discusses why to use it for asynchronous, decoupled, and throttled processing, and provides step‑by‑step installation instructions for macOS, Windows, and CentOS along with Java code examples for configuring and using delayed messages via the rabbitmq_delayed_message_exchange plugin.
By implementing a plug‑in architecture that uses a custom URLClassLoader to load and unload JAR‑packaged governance tasks at runtime, the Spring Boot application can dynamically register Spring beans and XXL‑Job handlers, remove them cleanly, update configuration via YAML or Nacos, and package the solution with Maven Shade without restarting services.
Learn how to enable and test Java 21 virtual threads in Spring Boot 3.2.5, compare their throughput against platform threads with JMeter, and explore performance limits through sample code and benchmarks, revealing when virtual threads excel and their constraints for CPU‑bound tasks.
This article explains how Spring Boot integrates Log4j2, details the internal logging initialization process, describes logger and LoggerConfig relationships, and demonstrates how to hot‑update logger levels using LoggersEndpoint or custom endpoints without restarting the application.
The article explains how exposed API endpoints can be intercepted and altered, and presents practical security measures—including HTTPS, encrypted parameters, timestamp‑based signatures, and a Spring Boot filter implementation—to detect and block tampering and replay attacks in a Java backend.
This article explains how to design a two‑level leave‑approval process using the Activiti BPMN engine, covering diagram creation, Spring‑Boot configuration, deployment, task handling, exclusive gateways, database tables, API overview, and practical tips for extending the workflow.
This guide explains how to use Maven plugins such as spring-boot-maven-plugin, maven-dependency-plugin, and maven-jar-plugin to package a Spring Boot application into an executable JAR with external lib dependencies, and shows how to deploy the resulting artifacts in a Docker container using a custom Dockerfile.
This article introduces Spring Boot's new RestClient, compares it with RestTemplate and WebClient, and provides detailed code examples for creating clients, performing GET/POST/PUT/DELETE requests, handling errors, customizing interceptors, and enabling load‑balanced service discovery.
Learn how to protect personal data in Spring Boot 3.2.5 applications by customizing Logback's PatternLayout and appender to mask fields such as name, phone, password, and email, with step‑by‑step code examples, configuration snippets, and handling of object logging.
This article demonstrates how to build a flexible API rate‑limiting solution in Spring Boot by combining a HandlerInterceptor, Redis counters, and custom annotations with reflection, covering configuration, code examples, mapping rules, time‑window nuances, path‑parameter handling, and real‑IP considerations.
This article explains how to integrate Spring Boot with WebSocket to create a lightweight instant‑messaging system, covering dependency setup, configuration classes, core server code, front‑end integration, essential IM modules, common deployment challenges, and provides complete example code and demos.
This guide walks you through the pain points of environment setup, shows step‑by‑step creation of a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot and Kafka, and provides ready‑to‑use Maven configurations, global exception handling, logging, CORS, Swagger, and a curated list of useful development tools.
This tutorial walks through creating a Maven‑based Spring Boot backend project with multiple modules, configuring pom.xml files, application properties, and logging, then adds a scheduled Douyin hot‑search crawler using OkHttp, demonstrating full end‑to‑end setup for a web service.
This article provides a comprehensive analysis of how Spring Boot 2.7.2 works with Log4j2 2.17.2, covering Log4j2's core components, Spring Boot's logging configuration options, the internal startup sequence, the LoggersEndpoint for runtime level changes, and custom hot‑update techniques, all illustrated with code snippets and diagrams.
This article explains why API versioning is essential for Spring Boot REST services and compares three common approaches—URI versioning, request‑header versioning, and media‑type versioning—while offering guidance on selecting a method and handling API deprecation.
This article walks through practical ways to perform batch updates in MyBatis, compares foreach, case‑when, and INSERT…ON DUPLICATE KEY techniques, explains common Druid WallFilter restrictions, and shows how to enable multi‑statement execution via JDBC and Spring configuration.
This guide explains why structured logging is essential for observability, shows how Spring Boot 3.4 adds out‑of‑the‑box support for Elastic Common Schema and Logstash formats, and provides step‑by‑step configurations and code examples for console output, file logging, custom fields, and custom formatters.
This article examines common pitfalls in Spring Boot controller implementations, demonstrates how excessive if‑else checks and business logic in controllers degrade code quality, and provides clean, refactored examples using @Valid validation, concise error handling, and a global exception handler to achieve more maintainable backend services.
This article explains why a plain Dockerfile for a Spring Boot fat JAR is inefficient, introduces Spring Boot's layered JAR format, and provides a multi‑stage Dockerfile that leverages layer caching to speed up builds and reduce runtime overhead.
This article provides a step‑by‑step tutorial on Apollo’s concepts, features, model, namespace handling, client design, high‑availability considerations, project creation, configuration management, Spring Boot client implementation, testing across environments, clusters and namespaces, and deployment on Kubernetes with Docker.
This article reviews several ways to integrate WebSocket with Spring Boot, focusing on the three mainstream approaches—Javax, WebMVC, and WebFlux—by providing server and client configurations, code examples, and practical tips such as handling ping/pong, handshake interceptors, and reactive streams.
This guide explains why pre‑loading initial data is essential for Spring Boot applications and demonstrates four practical methods—CommandLineRunner/ApplicationRunner, bean initialization with @PostConstruct, SQL script execution, and @Sql annotation for tests—complete with code snippets and configuration details.
This article demonstrates multiple methods to add text or image watermarks to PDF documents in a Spring Boot application, covering Java libraries such as Apache PDFBox, iText, Ghostscript command line, Free Spire.PDF, and Aspose.PDF, with code examples and usage instructions.
This article explains how Spring Boot 3.2.5 implements the RFC 7807 Problem Details specification, covering the core abstractions, code examples for creating ProblemDetail and ErrorResponse objects, and practical patterns for global exception handling in Spring MVC applications.
This article explains how Spring Boot’s @Transactional annotation works, introduces programmatic transaction management, and demonstrates how to create custom transaction hook functions with TransactionSynchronizationManager and TransactionSynchronization to execute custom logic at each transaction phase, improving robustness and maintainability.
This tutorial explains how to integrate Jasypt into Spring Boot 3.2.5, configure encryption keys, encrypt sensitive properties, use the ENC() syntax, and retrieve decrypted values at runtime, providing a complete solution for protecting configuration data.
This guide explains how to use LangChain4j Spring Boot starters to configure OpenAI models, create declarative AI services with @AiService, and run practical examples such as a customer‑support agent and a simple HelloWorld program, covering required dependencies, properties, and code snippets.
This article provides a comprehensive introduction to Spring Cloud OpenFeign, comparing it with Feign and HttpExchange, and walks through practical setup, client declaration, custom configuration, interceptors, error handling, timeout and logging settings with full code examples for Spring Boot 3.2.5.
This article explains the essential duties of a Spring MVC Controller, identifies common pitfalls such as duplicated validation and inconsistent responses, and demonstrates how to introduce a unified result wrapper, ResponseBodyAdvice, proper message‑converter ordering, JSR‑303 validation, custom validators, and global exception handling to produce concise, maintainable backend code.
This article explains why validating file types is essential for security and demonstrates six Java-based techniques—including Java 7 API, URLConnection, MimeTypesFileTypeMap, jMimeMagic, Apache Tika, and Spring's MediaTypeFactory—to reliably determine a file's MIME type under various conditions.
Learn step‑by‑step how to create a custom Spring Boot starter, configure its properties, define services and controllers, register it via spring.factories, and then integrate the starter into other projects with Maven dependencies and configuration files.
This article explains why Spring Cloud Gateway can return duplicate Access-Control-Allow-Origin and Vary headers, analyzes the request processing flow, and provides two solutions—using the built‑in DedupeResponseHeader filter with retention strategies or implementing a custom CorsResponseHeaderFilter—to eliminate the CORS error caused by multiple header values.
This article explains how to implement invisible token refresh for authentication servers using Spring Boot gateway filters, JWT handling, Axios interceptors, and a client‑side timer, compares client‑ and server‑side approaches, and provides complete code examples and practical recommendations.
This article provides a comprehensive guide to using Spring Boot’s @RequestMapping annotation, covering path definitions, HTTP methods, headers, produces/consumes, path variables, parameters, fallback handling, and advanced options, with practical curl commands and code snippets for each scenario.
This article explains how to implement asynchronous request handling in Spring Boot using four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—detailing their mechanisms, code examples, thread pool configuration, and when to apply asynchronous processing to improve throughput.
This article explains why centralized log collection is essential for multi‑environment services, introduces Graylog as a lightweight alternative to ELK, details Filebeat's role and workflow, provides configuration examples, shows how to deploy both Filebeat and Graylog via Docker or packages, and demonstrates integration with Spring Boot and log search techniques.
Spring Boot 3.4 adds built‑in support for structured logging with ready‑made JSON formats such as Elastic Common Schema, lets you configure console or file outputs, enrich logs via MDC or the fluent API, and enables custom formatters—including a JsonWriter‑based example—for fully tailored, machine‑readable log entries.
This article walks you through designing, deploying, and managing a multi‑level approval workflow using the Activiti engine, covering BPMN diagram creation, Spring Boot integration, database schema, API usage, code examples, and best practices for extending processes without additional code.
This article walks through using JetCache with Spring Boot 3.2.5, covering its features, Maven dependency setup, YAML configuration, annotation-based caching, programmatic cache creation, statistics monitoring, and deprecated APIs, all illustrated with code snippets and screenshots.
This article explains how to protect Spring Boot web applications from Cross‑Site Scripting (XSS) attacks by introducing two main defense mechanisms—custom @XSS annotations and servlet filters—complete with implementation details, code examples, configuration steps, and testing results.
This article explains several strategies for dynamically updating Spring Boot application properties—such as using prototype‑scoped beans, @RefreshScope with Spring Cloud, external configuration files, and custom PropertySource updates—so that changes take effect without restarting the service.
This guide walks through creating a Spring Boot 3.3.3 microservice permission framework with OAuth2, covering technology stack, core features, project structure, step‑by‑step service startup, token acquisition, API calls, and provides the complete source repository for hands‑on experimentation.
This guide explains how to protect a Spring Boot release package from source leakage by comparing code obfuscation and encryption, detailing the configuration of the classfinal‑maven‑plugin, launch commands with and without passwords, and binding the encrypted jar to a specific machine.
This tutorial provides a step‑by‑step guide to set up a complete Jenkins‑Docker‑Spring Boot pipeline on CentOS 7, covering Docker installation, Jenkins deployment, required plugins, Maven configuration, job creation, testing, and running the packaged application with Docker.
