Oracle’s March 2025 release of JDK 24 and GraalVM 24 introduces a new Class‑File API and Premain support for Java agents, allowing static compilation of agents, improving observability, reducing native image size, and delivering measurable startup‑time and memory‑usage gains.
This article introduces the Liteflow rule engine, detailing its architecture, component types, Maven and YAML configuration, example XML rule definitions, and a real‑world e‑commerce workflow, while also promoting related AI tools and services.
This article demonstrates how to create and fill PDF templates using a PDF editor and Java iText library, covering importing Word documents, inserting text, option, and image fields (including signatures and stamps), and provides complete code examples for generating customized PDFs.
This article explains how to build a Spring Boot service that uses OpenCV for image preprocessing and Tesseract OCR to extract ID numbers and business license information from photos, providing step‑by‑step guidance, required dependencies, and complete Java code examples.
This article explains how Spring AI's tool‑calling feature extends large language models by integrating custom Java tools for information retrieval and operations, and provides step‑by‑step Spring Boot 3 examples—including date‑time and weather tools—complete with configuration, code snippets, and execution results.
This article compares Spring Boot and Quarkus by outlining their architectures, running a reactive‑API benchmark with JMeter and VisualVM, presenting startup, build‑time, memory, CPU and response‑time results for JVM and native images, and offering a step‑by‑step guide for migrating Spring developers to Quarkus with code examples.
This article investigates MySQL's recommendation to avoid UUIDs and non‑sequential keys by benchmarking insert performance of auto‑increment, UUID, and random (snowflake) primary keys, analyzing their index structures, drawbacks, and concluding that sequential auto‑increment keys provide the best overall efficiency.
This article explains what a Java thread dump is, describes multiple ways to generate it—including JDK command‑line tools like jstack and jcmd, OS signals such as kill ‑3, and programmatic access via ThreadMXBean—provides syntax, options, examples, and recommendations for choosing the appropriate method.
This article explains how Spring Boot replaces extensive XML configuration with annotation‑driven setup, detailing the purpose and usage of core annotations such as @SpringBootApplication and @EnableAutoConfiguration, as well as conditional annotations like @ConditionalOnClass, @ConditionalOnBean, @ConditionalOnProperty, @Profile, and provides best‑practice recommendations.
An in‑depth analysis reveals how misuse of InheritableThreadLocal with shared thread pools can sporadically produce NullPointerExceptions, detailing the root cause, code examples, debugging steps, and best‑practice recommendations to avoid thread‑local contamination in Java backend services.
This article presents a comprehensive design scheme for third‑party APIs, covering permission segmentation, AK/SK generation, signature workflow and rules, secure API endpoint design, anti‑replay mechanisms, token handling, TLS encryption, database schema, and implementation examples in Java.
This article explains the fundamentals of OAuth2.0, outlines its roles and grant types, and provides a step‑by‑step Spring Boot implementation—including authorization server, security configuration, resource server, and a test controller—followed by detailed testing procedures and results.
This guide walks you through setting up Cursor, an AI‑enhanced VS Code‑based editor, on macOS and configuring full development environments for Python, JavaScript/TypeScript, Swift, and Java, including essential tools, virtual environments, plugins, and VS Code settings to boost productivity.
This article introduces the YAVI library, a type‑safe Java validation framework, and walks through its core features, custom constraints, nested and collection validation, conditional and group validation, fail‑fast mode, parameter validation with comprehensive code examples and output screenshots.
This guide shows how to use the Fabric8 Kubernetes Java client to load, create, apply, list, watch, and delete core Kubernetes objects such as EndpointSlice, PersistentVolumeClaim, PersistentVolume, NetworkPolicy, PodDisruptionBudget, and various RBAC resources, with complete code examples for each operation.
This article explains the Model Context Protocol (MCP) for seamless LLM integration, describes its background, presents a sequence diagram of its architecture, and provides step‑by‑step Java SpringBoot code for SSE streaming, HTTP POST handling, and annotation‑based tool registration.
This article introduces a unified log recording solution for Java backend services, covering the background need, expected UI effects, database schema, core principles, detailed annotation and service implementations, and multiple usage scenarios including simple log objects, inheritance, and nested objects.
The article explains why data masking is essential for protecting sensitive information, then details three implementation methods—SQL, Java (with open‑source plugins), and the MyBatis‑Mate‑Sensitive‑Jackson ORM extension—comparing their principles, code examples, advantages, limitations, performance, suitable scenarios, and cost considerations.
This article introduces Java regular expressions, covering basic syntax, character classes, logical operators, predefined tokens, quantifiers, practical code examples, common applications such as data validation, and performance optimization tips for effective string processing in Java.
This article compares Spring Boot and Quarkus by describing their architectures, presenting a reactive test application that uses PostgreSQL, detailing a JMeter performance test plan, and analyzing results such as startup time, build size, CPU, memory, and response latency to help developers decide when to migrate from Spring Boot to Quarkus.
This article explains LeetCode problem 1186, which asks for the maximum sum of a contiguous subarray after optionally deleting one element, and presents a dynamic‑programming solution with recurrence formulas, base cases, and full Java and C++ implementations.
This tutorial demonstrates how to configure IntelliJ IDEA for remote one‑click deployment of a SpringBoot application with Docker, covering environment setup, SSH and Docker daemon configuration, Dockerfile creation, Maven build steps, firewall adjustments, and troubleshooting common deployment issues.
This article demonstrates how to use the Adapter pattern to abstract multiple OSS providers such as MinIO and Aliyun in a Spring microservice, configure the concrete adapters via Nacos dynamic configuration, and expose a unified upload API through a service and controller layer, complete with deployment and testing steps.
This article explains the low‑level implementation of Java's synchronized keyword, covering monitorenter/monitorexit bytecode, object header structures, Mark Word layouts, and the evolution from heavyweight locks to biased and lightweight locks with lock‑upgrade mechanisms.
This guide demonstrates how to use the Fabric8 Java client to create, retrieve, update, list, watch, and delete common Kubernetes resources such as Job, CronJob, Namespace, ServiceAccount, Ingress, StatefulSet, and DaemonSet, providing code snippets for each operation.
This article introduces a free Spring Boot 3 ebook with 110 practical cases and explains the configuration file loading order, then demonstrates how to use @Value, @ConfigurationProperties, @PropertySource, EnvironmentPostProcessor and other techniques with clear code examples.
This article introduces a free collection of programmer books and provides a detailed comparison of several Java microservice frameworks—including Spring Cloud, Vert.x, SparkJava, Micronaut, Javalin, and Quarkus—covering their resource consumption, startup times, memory usage, and suitability for lightweight or heavy‑weight applications.
This article explains the JVM's tiered compilation mechanism, detailing the client (C1) and server (C2) JIT compilers, the five compilation levels, code cache organization, relevant JVM flags, and demonstrates method compilation lifecycle through illustrative Java code examples and log analysis.
This article explains the inner workings of Caffeine's cache, covering the getIfPresent method, the design of ReadBuffer and StripedBuffer, eviction policies, the maintenance cycle, and the climb algorithm that dynamically adjusts window and protected partitions for optimal performance.
This article explains the inner workings of Caffeine's getIfPresent method, the design of its MPSC ReadBuffer and WriteBuffer, the maintenance cycle, eviction strategies, and the TinyLFU algorithm, providing Java code examples and diagrams to illustrate how caching decisions are made in high‑concurrency environments.
This article explains the fundamentals of ASM’s tree API for Java bytecode manipulation, illustrates the structure of class files, fields, methods, and signatures, and provides a practical example of inserting code to rename anonymous Thread instances during the Transform phase.
The article explains how modern multi‑core CPUs use time slices, hyper‑threading, and various types of context switches to manage multithreaded workloads, discusses the performance costs of switching, and offers practical optimization strategies such as lock‑free programming, appropriate thread counts, and coroutine usage.
This tutorial introduces the fundamentals of LangChain, explains large language models, prompt engineering, word embeddings, and demonstrates how to use the Java implementation LangChain4j with Maven dependencies, model I/O, memory, retrieval, chains, and agents to build sophisticated LLM‑driven applications.
The article introduces Spring AI Alibaba OpenManus, a Java‑based multi‑agent framework that showcases complex task execution through browser automation, travel itinerary generation, and document translation, while detailing its architecture, current limitations, and future development roadmap.
This article explains how to implement unified global exception handling in SpringBoot by using @ControllerAdvice with @ExceptionHandler, defining a base error interface, custom enums, exception classes, and a standardized response wrapper, while also providing test code examples and best‑practice recommendations.
This article explains why using Arrays.asList to convert an array into a List can produce an immutable, fixed‑size list that throws UnsupportedOperationException on add or remove operations, illustrates the issue with real‑world incident details, analyzes the internal implementation, and provides a safe replacement using java.util.ArrayList.
This article demonstrates how to leverage Spring Boot 3's data binding capabilities by converting primitive types to objects, creating custom converters, handling hierarchical object binding, and implementing custom argument resolvers, complete with code examples and execution results.
Java 24 arrived in March 2025 with a slew of preview features and performance tweaks, yet most production teams should ignore it and wait for the September Java 25 LTS release, which stabilizes these innovations for enterprise use.
This article explains the classic MVC three‑tier architecture, identifies its drawbacks such as bloated service code and long‑running transactions, and proposes adding a Manager layer to separate generic business processing, improve code maintainability, and enhance performance in Java backend systems.
The article introduces DeepSeek4j 1.4, a Java‑centric framework that overcomes Spring AI’s limitations by preserving DeepSeek’s chain‑of‑thought, supporting streaming output, and offering a simple Spring Boot starter with reactive, configurable, and ready‑to‑use APIs for AI developers.
This article explains how the Java Memory Model defines the interaction between threads, thread stacks, and the heap, illustrates these concepts with diagrams and example code, and discusses how modern hardware memory architecture, caches, and CPU registers affect visibility and race conditions in concurrent Java programs.
This guide details a secure third‑party API design, covering API key generation, request signing with timestamps and nonces, permission division, CRUD endpoint definitions, unified response structures, and best‑practice security measures such as HTTPS, IP whitelisting, rate limiting, logging, and idempotency handling.
This article walks through the design and implementation of a Spring‑based download library that lets developers download files, HTTP resources, or arbitrary objects with a single @Download annotation, covering the problem setup, reactive architecture, source abstraction, concurrency handling, compression, response writing, and the lessons learned.
This article describes a lightweight, non‑intrusive MyBatis plugin that adds identifiable coloring comments to SQL statements—embedding statementId, pFinderId, and optional custom data—to simplify SQL source tracing, improve slow‑SQL analysis, and support SELECT, INSERT, UPDATE, DELETE operations with minimal performance overhead.
This article demonstrates how to wrap EasyExcel in a SpringBoot‑MyBatis‑Plus project, providing clear steps, code examples, and solutions to common issues such as date conversion and POI version compatibility, enabling developers to import and export Excel data with minimal effort.
This article explains how to replace Spring Boot's default embedded Tomcat with the Undertow container, details the configuration steps, and presents benchmark results showing Undertow's superior throughput and lower memory usage under high‑concurrency workloads, making it a better choice for performance‑critical applications.
This article explains how to efficiently handle massive Excel import and export tasks in Java by using EasyExcel, Java 8 functional programming, reflection, generics, thread‑pool batching, and custom ReadListener implementations, while also providing Maven dependencies and reusable export utilities.
This article explains how Spring Framework's ResponseBodyEmitter enables real‑time, chunked HTTP responses for use cases such as log streaming, progress updates, chat, and AI output, detailing its advantages over SSE, usage scenarios, core methods, a complete controller example, and best‑practice considerations.
This article announces the updated Spring Boot 3 case‑study e‑book with 108 examples and then dives into Java 24’s latest preview features—enhanced pattern matching, flexible constructors, module import, single‑file source, custom stream collectors, Vector API, scoped values, and structured concurrency—complete with code snippets and links.
Learn five Java file copy techniques—from basic streams to NIO Files.copy, FileChannel, and RandomAccessFile—detailing their implementations, performance differences, and ideal use cases for small, large, and massive files, helping you choose the most efficient method for your project.
This article explains how to use SpringBoot, AOP, and a custom @DataSource annotation to dynamically switch between MySQL master and slave databases, automatically falling back to the master when a slave fails, thereby achieving high availability for backend services.
This tutorial explains how to exchange the values of two Java variables without using a temporary variable, covering three techniques—arithmetic addition/subtraction, multiplication/division, and bitwise XOR—along with complete code examples, step‑by‑step explanations, output results, and discussion of each method’s advantages, limitations, and appropriate use cases.
This article explains multiple ways to load JSON configuration into Spring Boot 3 applications, covering command‑line arguments, @PropertySource with custom factories, ApplicationContextInitializer, nested JSON handling, and direct @Bean approaches, complete with code examples and troubleshooting tips.
This article explains how to build a Spring‑based download library that uses annotations to simplify downloading files, HTTP resources, or custom objects, supports both WebMvc and WebFlux, handles concurrency, compression, and event‑driven logging, and provides a modular architecture for extensibility.
Design patterns provide reusable solutions for common Java development challenges; this article explains their core concepts, categorizes creational, structural, and behavioral patterns, links them to SOLID principles, offers real‑world application scenarios, best‑practice guidelines, common pitfalls, and concrete code examples across e‑commerce, logging, and game development.
This article introduces nine different approaches to achieve asynchronous programming in Java, including using Thread and Runnable, Executors thread pools, custom thread pools, Future and Callable, CompletableFuture, ForkJoinPool, Spring @Async, message queues, and Hutool's ThreadUtil, with code examples and usage tips.
The article introduces Spring AI as an emerging tool for Java developers, explains its background, goals, and core components such as data processing, model training, deployment and monitoring, showcases application scenarios like NLP, image processing, recommendation systems and predictive analytics, and also includes promotional offers for AI resources and community groups.
The article outlines nine practical approaches for asynchronous programming in Java—including low‑level Thread/Runnable, managed Executors and custom thread pools, Future/Callable, CompletableFuture, ForkJoinPool, Spring’s @Async annotation, message‑queue integration, and the Hutool ThreadUtil utility—offering a comprehensive toolbox for scalable, non‑blocking execution.
This article introduces Spring AI, a Spring ecosystem module that simplifies building, training, and deploying AI applications for Java developers, covering its background, goals, core components such as data processing, model training, deployment, practical code examples, use cases, advantages, challenges, and future outlook.
This article presents nine practical techniques—including the Strategy pattern, lambda maps, Optional chaining, ternary operators, enums, early returns, condition merging, and rule engines—to replace cumbersome if‑else chains in Java, offering cleaner, more maintainable and performant code for Spring Boot developers.
This article explains the Facade design pattern, illustrating its purpose of simplifying complex systems with a real‑world TV remote analogy, detailing its benefits, UML structure, and a comprehensive Spring Boot example that integrates flight, hotel, and package services through a BookingFacade to streamline travel booking logic.
This guide demonstrates how to use the Fabric8 Kubernetes Java client to load, create, retrieve, update, scale, watch, and delete ReplicationController, ConfigMap, and Secret resources, providing complete code examples and step‑by‑step commands for managing these objects across namespaces in a Kubernetes cluster.
This article explains why Java performance matters, outlines fundamental principles, and provides concrete code, memory, concurrency, I/O, and database optimization techniques, along with profiling tools, common pitfalls, real‑world case studies, and emerging trends to help developers build faster, more stable applications.
This article explains how to merge multiple user‑detail requests into a single database query using a blocking queue, scheduled thread pool, and CompletableFuture in Spring Boot, providing code examples, a high‑concurrency test, and discussion of trade‑offs such as added latency and timeout handling.
This guide explains how to use JSR‑303 and Hibernate Validator in Java Spring Boot to perform comprehensive parameter validation, covering basic annotations, global exception handling, group validation, nested object checks, fast‑fail configuration, and custom validation rules, with practical code examples and testing procedures.
The article explains how high coupling caused by multiple front‑end controllers and repetitive back‑end push‑service code can be eliminated by introducing a dedicated TPS microservice that encapsulates third‑party integrations and exposes a unified Feign interface for all business systems.
After being laid off, the author interviewed only four companies, detailing each interview’s technical questions—from Spring Cloud and MySQL to concurrency and design patterns—and reflecting on the interviewers’ professionalism, the relevance of his skill set, and the importance of matching resumes to job requirements.
This article introduces Spring AI, explains its background, goals, core components such as data processing, model training, deployment and monitoring, showcases practical use cases like NLP, image processing and recommendation systems, and discusses its advantages, challenges, and future outlook for Java developers.
This article provides a step‑by‑step guide to creating a Jenkins CI/CD pipeline for Java applications, covering environment setup, required plugins, project structure, CI stages such as code checkout, dependency installation, testing, SonarQube scanning, Docker image building and pushing, as well as CD stages including Helm chart creation, deployment, health checks, rollback, and maintenance‑window management.
This article introduces a Spring Boot 3 case collection and provides a comprehensive guide to Java enums, covering their definition, type safety, custom values, interface implementation, abstract methods, generics, pattern matching, functional programming, collection usage, and sealed‑class integration with clear code examples.
This article explains the Model Context Protocol (MCP) introduced by Gitee, shows how Java developers can integrate it using LangChain4j, compares stdio and SSE transport modes, provides full code samples, installation steps, and demonstrates a practical AI‑powered repository assistant.
The Word Break problem (LeetCode 139) asks whether a given string can be segmented into a sequence of dictionary words, and can be solved efficiently with dynamic programming by tracking reachable prefixes in a boolean array, as demonstrated by concise Java and C++ implementations.
This article provides an in‑depth overview of Apache Zookeeper, covering its core concepts, common application scenarios such as pub/sub, configuration management and naming services, detailed architecture including znodes and node types, the watch mechanism, ZAB consensus protocol, and practical usage examples with Maven dependencies, Java client code, and command‑line operations.
This article walks through the One Billion Row Challenge, explaining the problem, baseline Java solution, and a series of deep performance optimizations—from parallel streams and custom hash tables to unsafe memory access and SIMD techniques—that shrink execution time from minutes to under two seconds.
Pointer collision is an efficient memory allocation technique that can trigger severe concurrency problems in multithreaded Java environments, and this article explains the underlying causes, illustrates conflict scenarios, and presents common remedies such as CAS (Compare‑And‑Swap) and TLAB (Thread‑Local Allocation Buffer) with sample code.
This article explains how to refactor the Spring MVC Controller layer by unifying response structures, using ResponseBodyAdvice for automatic wrapping, handling parameter validation with JSR‑303, and implementing custom exceptions with centralized exception handling to simplify and standardize API responses.
Explore a rich Spring Boot 3 case collection while learning step‑by‑step how to use REST‑assured for API testing, covering dependency setup, GET/POST/PUT/DELETE requests, authentication, XML validation, file upload/download, and advanced features, with full code examples and a promise of ongoing updates.
This article demonstrates how to initialize a Kubernetes Java client, configure it with default or custom kubeconfig, and provides comprehensive DSL examples for managing Pods, Services, Deployments, ReplicaSets, including creation, listing, updating, watching, port forwarding, and cleanup, with full code snippets throughout.
Oracle’s Java 24 release introduces AI‑focused enhancements such as the Vector API, new post‑quantum cryptography support with ML‑KEM and ML‑DSA, language improvements like pattern‑matching for primitives, and beginner‑friendly features, positioning Java for modern development and long‑term support.
Oracle officially released Java 24, introducing over twenty new JEPs that enhance language patterns, modular imports, AI and quantum‑resistant security, streamlined tooling, and runtime performance, while also offering a free programmer book giveaway for interested developers.
This article explains common encryption and signing algorithms—including AES, SM4, RSA2, and SM2—covers key representations in hex and Base64, details digital certificate structures, CSR application, TLS usage scenarios, OpenSSL commands for PEM conversion, and provides Java and JavaScript code examples for secure communication.
This article explains the Retrieval‑Augmented Generation (RAG) paradigm, walks through its four core steps, and provides a detailed Spring AI implementation—including configuration, vector storage, REST controller, multi‑query expansion, query rewriting, document joining, and error handling—plus best‑practice recommendations for production deployments.
The article reviews key Java backend interview topics—including thread‑safe collections, JVM memory layout and heap tuning, Full GC troubleshooting, Java 8 features, optimistic locking, stock‑over‑sell handling with Redis, MySQL scaling, cache‑consistency patterns, anti‑bot safeguards, and Bloom filters—while noting JD’s recent 30% salary hike for algorithm engineers.
This article explains how to generate a unique traceId at request entry and propagate it through Rest, MQ, and RPC modules using Log4j2, MDC, and custom converters, enabling clear, linked log output across the entire request chain.
This article explains the differences between ExecutorService and CompletionService, demonstrates how to replace a simple Future‑based approach with CompletionService for faster result retrieval, analyzes the underlying source code, and outlines typical use‑cases such as load‑balancing and early‑return patterns in concurrent Java applications.
This article provides a detailed walkthrough of Spring and Spring Boot's core concepts, explains the bean container refresh process, and enumerates all major extension interfaces—including ApplicationContextInitializer, BeanDefinitionRegistryPostProcessor, BeanFactoryPostProcessor, InstantiationAwareBeanPostProcessor, SmartInstantiationAwareBeanPostProcessor, various *Aware interfaces, @PostConstruct, InitializingBean, FactoryBean, SmartInitializingSingleton, CommandLineRunner, DisposableBean, and ApplicationListener—accompanied by code samples and usage scenarios.
An in‑depth look at how the JVM stores object references, comparing handle‑based access with direct pointer access, highlighting their performance trade‑offs, memory overhead, and impact on garbage collection to help developers choose the most suitable approach for their applications.
This article introduces a continuously updated Spring Boot 3 case collection and provides a step‑by‑step tutorial on implementing Server‑Sent Events using both the native EventSource API and the fetch‑event‑source library, covering backend controller code, frontend Vue integration, and practical code examples.
This article provides a comprehensive guide to speeding up Spring Boot application startup by explaining configuration principles, code‑level interventions, lazy loading, dependency reduction, auto‑configuration exclusion, logging adjustments, compile‑time optimizations, and caching strategies, all illustrated with practical Java examples.
This article explains OpenSSL’s origins, its role in encryption on CentOS, common use cases such as web servers and database security, provides step‑by‑step installation and upgrade commands, and demonstrates how to generate RSA, SM2, AES, and SM4 keys via the OpenSSL command line and Java alternatives.
This article explains how Java's foreach loop is implemented using iterators, demonstrates the bytecode differences between array and collection traversal, analyzes why modifying a HashMap during foreach can trigger ConcurrentModificationException, and shows the correct way to safely modify collections with an iterator.
This article explains how to refactor the Spring MVC Controller layer by standardizing response structures, implementing unified response wrapping via ResponseBodyAdvice, handling String conversion issues, applying JSR‑303 parameter validation, creating custom validation rules, and defining custom exceptions with centralized exception handling to simplify controller code.
The article recounts a puzzling case where a minimal Java program using ConcurrentLinkedQueue runs fine normally but throws a NullPointerException when debugged in IntelliJ IDEA, explains the underlying cause involving the IDE's automatic toString invocation, and shows how to disable the offending settings.
This article explains how SpringBoot integrates MyBatis by using @MapperScan and @Import annotations to scan mapper interfaces, generate and modify BeanDefinitions, create proxy beans, and execute SQL statements, while also promoting AI tools, DeepSeek resources, and related services for developers.
This article explains the motivation behind Netty's FastThreadLocal, details its internal design using an indexed array to avoid hash collisions, analyzes the core source code of InternalThreadLocalMap, FastThreadLocalThread, and FastThreadLocal, and discusses performance implications and reclamation strategies.
The article compares Java and Go across syntax, variable declaration, object‑oriented features, error handling, concurrency models, garbage collection, resource usage, and ecosystem maturity, concluding that Go offers simpler code, lightweight concurrency and lower overhead, while Java provides a richer library ecosystem and more mature tooling, making the choice dependent on project requirements.
Amid the AI wave, Java backend developers focused solely on CRUD face replacement by automation, but by deepening business expertise, enhancing soft skills, gaining project experience, and expanding into AI and new technologies, they can transform their roles and stay valuable in the evolving software industry.
This article explains how to use spring-smart-di to dynamically switch between multiple service providers in a Spring application, reducing manual configuration, improving fault tolerance, and enabling runtime updates without restarting the service.
This article explains how to dynamically switch between multiple service providers in a Spring backend by configuring identifiers, using spring-smart-di's AutowiredProxySPI and related annotations, and provides step‑by‑step code examples for seamless, runtime‑configurable dependency injection.
Web containers, such as Tomcat, keep running by continuously listening on network ports with socket servers and thread pools, handling I/O requests; this article explains the role of the main function, servlet lifecycle, Netty’s NIO framework, and why WebFlux‑based gateways outperform traditional Tomcat setups.
