This article walks through the anatomy of a Java Virtual Machine crash, explains how to read the generated hs_err_pid log and core dump, and provides practical debugging steps—including code examples, signal analysis, register context, and GDB commands—to pinpoint and resolve the root cause.
This article investigates a production issue on Java 21 where virtual threads cause Tomcat to stop processing requests, closeWait sockets to accumulate, and locks to deadlock, detailing the diagnostics, thread‑dump analysis, lock inspection, and the eventual conclusions about virtual‑thread behavior.
This article walks through creating a WebSSH solution using SpringBoot, WebSocket, the Java jsch library, and the xterm.js front‑end, covering technology choices, core backend logic, demo screenshots, command examples, and future extension ideas.
This article presents fourteen practical Java Spring development best‑practice tips—including using @ConfigurationProperties, Lombok's @RequiredArgsConstructor, modularizing code, throwing exceptions instead of returning error codes, minimizing unnecessary database calls, avoiding null returns, reducing if‑else chains, and leveraging IDE features—to help developers write cleaner, more maintainable backend code.
This article introduces the open‑source Spring AI Alibaba framework, explains its background, core features such as chat model abstraction, prompt templates, structured output, function calling, RAG and chat memory, and walks through a complete smart‑ticket‑assistant example with code snippets and deployment guidance.
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 explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously send Kafka messages only after a transaction successfully commits, providing a practical example and detailed code snippets for building a reusable Spring Boot starter library.
This article introduces UniHttp, a declarative Java HTTP client framework that lets developers define third‑party HTTP APIs as annotated interfaces, provides quick‑start instructions, detailed annotation usage, lifecycle hooks, custom client configuration, and an enterprise integration example with full code snippets.
This article demonstrates how to build a hot‑pluggable AOP solution in Spring by dynamically adding and removing Advice, Advisor, and related components through custom endpoints, event listeners, and Spring’s bean factory APIs, enabling users to control logging at runtime.
An in‑depth guide reveals thirteen common pitfalls that cause Spring’s @Transactional annotation to malfunction—ranging from unnecessary usage and proxy limitations to propagation misconfigurations and exception handling—plus practical demos and solutions to ensure reliable transaction rollbacks in Java backend development.
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 explains what Java virtual threads are, compares them with ordinary platform threads, shows how to enable them in SpringBoot, and presents performance benchmarks that reveal virtual threads can be up to two hundred times faster for I/O‑bound workloads.
This guide introduces Caffeine, a high‑performance Java caching library, explains its core features, configuration options, loading strategies—including manual, automatic, asynchronous, and async loading caches—eviction policies, removal listeners, and statistics collection, providing code examples for each use case.
Learn how to leverage the Arthas flamegraph tool to profile Java applications, interpret CPU usage visualizations, and apply practical optimization techniques illustrated through real-world case studies that reduced CPU consumption by up to 6% and improved system stability during high‑traffic events.
This article explains how to handle time‑consuming Spring endpoints by using asynchronous streaming tools—ResponseBodyEmitter, SseEmitter, and StreamingResponseBody—detailing their use cases, code examples, and how they improve system responsiveness without blocking servlet threads.
This guide walks non‑specialist GIS developers through front‑end mapping with Vue, OpenLayers and Leaflet, back‑end processing with Java, GeoTools and PostGIS, and practical solutions for common GIS toolchain challenges.
This article explains how APIJSON can replace dozens of traditional SpringBoot controller methods with a single configurable endpoint, demonstrating concise request formats, permission annotations, and example code for creating, reading, updating, deleting, and aggregating data in a Java backend.
This guide explains what unit testing is, its benefits, the AIR principles of good tests, step‑by‑step Java test creation with JUnit and Mockito, and how the AI tool Tongyi Lingma can quickly generate reliable unit tests.
This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool, demonstrates how to implement divide‑and‑conquer tasks with RecursiveTask, analyzes the pool’s design, task submission methods, work‑stealing mechanism, common pool pitfalls, and presents performance evaluation results.
This article, written by a senior architect, reviews Spring’s built‑in utility classes—including assertions, object and collection helpers, file/IO operations, and reflection/AOP tools—providing code snippets and usage notes to help developers replace redundant custom utilities and improve backend Java code quality.
This article explains why Java's BigDecimal maintains exact precision by examining its class fields, demonstrating a test example, and walking through the internal add method logic that scales numbers to long integers before performing arithmetic, ensuring loss‑free results.
This article provides an in‑depth tutorial on Apollo, Ctrip's open‑source distributed configuration center, covering its concepts, features, architecture, four management dimensions, client design, Maven integration, SpringBoot implementation, testing procedures, and deployment on Kubernetes with Docker.
This article introduces the JXLS library for Java, explains how to add Maven dependencies, provides backend utility and controller code for exporting Excel files, and details common XLS expressions such as jx:area, jx:each, jx:mergeCells, and dynamic column handling to simplify complex Excel report generation.
Spring AI Alibaba is an open‑source Java framework that integrates Alibaba Cloud's large‑model services with Spring AI, offering high‑level abstractions for chat models, prompts, function calling, RAG, and conversation memory, and includes a complete ticket‑assistant example with code snippets.
This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously publish payment‑log messages to Kafka without affecting the main business flow, complete with practical code snippets and pitfalls to avoid.
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 provides a comprehensive overview of mainstream distributed transaction solutions, explains the CAP theorem and consistency models, compares various approaches such as 2PC, 3PC, TCC, Saga, and demonstrates how to configure and use Seata's AT mode in a micro‑service environment.
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.
The article analyzes why C++‑focused graduates receive few backend interview opportunities at major internet firms, highlights the mismatch between C++ skill sets and common backend components, and offers practical advice on switching languages or augmenting projects to better align with industry demands.
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.
Seata 2.1.0, the first Apache-incubated release, renames the package to org.apache.seata, adds RocketMQ transaction support, Raft metadata sync, decouples Saga from Spring, provides extensive compatibility across JDKs, Spring versions and OSes, and includes detailed deployment, upgrade, security and testing improvements.
The article advises Java backend developers to drop learning outdated technologies such as JSP, Struts, Hibernate, and certain legacy tools, emphasizing the importance of mastering core concepts like Servlets while focusing on modern frameworks like Spring MVC and lightweight ORMs like MyBatis.
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 explains why, in containerized Java applications, the JVM flag -XX:+ExitOnOutOfMemoryError is generally preferred over -XX:+HeapDumpOnOutOfMemoryError, detailing the trade‑offs, operational benefits, and how Kubernetes probes and monitoring can ensure fast failure, rapid recovery, and user‑transparent service continuity.
This article walks through a systematic investigation of a slow‑starting Dubbo service built on Spring 3.2, using JProfile to pinpoint costly class‑loading checks, disabling unnecessary annotation processing, and resolving thread‑waiting issues caused by RabbitMQ and other components, ultimately reducing deployment time by about 40%.
This article walks through creating a Spring Boot project, handling version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common Maven configurations, provides global exception handling and logging aspects, and lists useful backend tools such as embedded Redis, MyBatis‑Plus, and Redisson.
The article introduces Fluent Mybatis, a compile‑time code‑generating ORM that merges Mybatis‑Plus, Dynamic SQL and JPA features, eliminates XML mappers, offers a fluent, type‑safe Java API, and demonstrates through concise examples how it reduces boilerplate compared with native Mybatis and Mybatis‑Plus.
The article explains how to simplify Spring MVC controller code by introducing a unified response wrapper, handling String return types with ResponseBodyAdvice, adjusting HttpMessageConverter order, applying JSR‑303 validation for @RequestParam, @PathVariable and @RequestBody, creating custom validation annotations, and implementing global exception handling for consistent API responses.
This article guides readers through the concepts of large language models, embeddings, vector databases, and Retrieval‑Augmented Generation, then demonstrates step‑by‑step how to set up Ollama, install a local Chroma vector store, configure Maven dependencies, and write Java code using LangChain4J to build and test a functional AI Q&A application.
This article explains Java's built‑in Service Provider Interface (SPI) mechanism, demonstrates how to implement and test SPI with sample code, analyzes its internal workings and limitations, and then shows how Spring extends SPI using spring.factories with comparable examples and source‑code insights.
This article explains why the == operator yields false when comparing two Integer objects with the value 1000 but true for the value 100, covering Java's reference comparison, the IntegerCache mechanism, its performance rationale, and a reflective hack that can even make 2+2 equal 5.
Oracle’s release of Java 23 introduces a suite of preview JEPs—including primitive pattern matching, module import declarations, flexible constructors, and new library APIs—while also previewing performance, tooling, and management enhancements, and it hints at upcoming features slated for Java 24.
This article explains why the author created the EasyQuery ORM for Java, demonstrates a wide range of query patterns—including single‑record, pagination, joins, subqueries, streaming, custom VO mapping, dynamic conditions, grouping, native SQL, function columns, and high‑performance encryption—while providing complete code snippets and links to documentation and source repositories.
The article explains why forcibly stopping a Java thread is unsafe, outlines common scenarios requiring thread exit, compares graceful and forced termination methods, and provides practical techniques such as flag checks and Thread.interrupt() with recommended interrupt‑handling strategies.
This article dissects the exact moment a Spring @Transactional method commits relative to a surrounding lock, explains why committing after unlock can cause overselling, and provides source‑level debugging techniques to verify transaction start, commit, and rollback behavior in MySQL under high concurrency.
This article provides a concise, hands‑on overview of Java’s most useful language enhancements from Java 9 through Java 17—including private interface methods, Optional API upgrades, Stream API additions, var type inference, the new HTTP client, switch expressions, text blocks, records, instanceof pattern matching, and sealed classes—complete with clear code examples for each feature.
This article examines whether the @Service annotation can replace @Controller in Spring Boot by presenting a functional example, explaining the component‑scanning and request‑mapping mechanisms that allow a @Service‑annotated class to handle HTTP requests just like a controller.
This article explains why overusing null‑check statements in Java leads to verbose code, distinguishes cases where null is a valid response versus an error, and offers practical techniques such as assertions, throwing exceptions, returning empty collections, and applying the Null Object pattern to write cleaner backend code.
This guide explains Java's try-with-resources statement introduced in JDK 7, showing how it automatically closes AutoCloseable resources, eliminates boilerplate finally blocks, manages closure order and suppressed exceptions, avoids common decorator pitfalls, and provides best‑practice examples for robust production code.
This article details the discovery, analysis, and fix of a severe thread‑leak issue in a Java Spring MVC service caused by unsafe use of a shared CloseableHttpAsyncClient, showing how multithreaded testing reproduced the problem and how refactoring the client to a local variable eliminated the runaway thread growth.
The article first shares a frustrated JD interview experience regarding a 'personality' assessment, then introduces LeetCode problem 814 – Binary Tree Pruning – detailing the problem statement, examples, and providing concise post‑order traversal solutions in Java, C++, and Python.
This article explains the TCC (Try‑Confirm‑Cancel) distributed transaction model, its three phases, three practical variants, and provides a complete Seata‑based Java implementation with code samples, exception handling strategies, and deployment tips for backend services.
This article explains defensive programming as a proactive coding paradigm that anticipates and mitigates errors through input validation, error handling, assertions, and continuous testing, and demonstrates its application with detailed Java examples covering pagination, loop safety, exception management, and boundary checks.
This article analyzes Java performance bottlenecks and demonstrates how to use CompletableFuture for parallelism, fine‑tune ThreadPoolExecutor parameters, minimize transaction scope, apply cache‑line padding, object pooling, lock‑granularity techniques, copy‑on‑write collections, and reduce network payloads to achieve lower latency and higher throughput.
This article explains how to launch Java processes from the command line, explores JVM -X and -XX tuning parameters, details garbage‑collection algorithms, describes reference strengths, and clarifies object reachability to help developers optimize Java application performance.
This article introduces RediSearch, compares its memory usage and query performance with Elasticsearch on modest hardware, shows installation steps, demonstrates core index commands and Java integration, and concludes with practical advice on using RediSearch as a lightweight full‑text search engine.
This article explains how to use the iTextPdf library in Java to design a PDF template, fill fixed fields, dynamically generate product tables, and merge the two parts into a single invoice PDF, including Maven dependencies and sample code.
JEP 453 integrates StructuredTaskScope into Java 21, offering a preview API that replaces Future with Subtask, enabling lightweight virtual‑thread based concurrent tasks, such as fetching data from multiple servers and automatically cancelling slower calls, while simplifying error handling and improving observability.
This article explains seven practical methods for loading property files in Spring Boot, covering default locations, external files, classpath resources, profile‑specific files, custom @PropertySource usage, and overriding via environment variables or JVM system properties.
Domain‑Driven Design (DDD) structures software around a rich domain model—entities, value objects, aggregates, and services—organized into UI, application, domain, and infrastructure layers, employing patterns such as aggregate roots, domain events, and event‑driven microservices to improve maintainability, scalability, and collaboration between developers and domain experts.
This article shares a ByteDance interview experience and provides detailed technical explanations on Java thread pools, Redis internals, message queue usage, computer networking processes, HTTP/HTTPS differences, and a sample algorithm problem, offering valuable insights for backend developers.
This article explains how Nacos’s ConfigService initiates a long‑polling task on the client side, how the client periodically checks for configuration changes, and how the Nacos server processes long‑polling requests, detailing the relevant classes, methods, and code flow.
The article explains that storing IPv4 addresses as a 32‑bit UNSIGNED INT in MySQL saves storage and index space, enables faster range queries, outlines conversion functions like INET_ATON/INET_NTOA, discusses drawbacks such as readability, and provides Java utilities for IP‑long transformations.
This article explains how to implement runtime switching of multiple service providers, such as SMS vendors, in a Spring-based backend using the spring‑smart‑di library, @EnvironmentProxySPI, and @AutowiredProxySPI annotations, with configuration stored in Nacos, databases, or environment variables.
This guide provides step‑by‑step instructions for installing the Allure test reporting tool on Windows, macOS, and Linux, covering Java setup, environment variables, verification commands, important considerations, and how to generate and view test reports.
This guide introduces Google’s Guava library for Java, covering Maven integration, data validation with Preconditions, immutable collections, factory methods, counting collections, multimap usage, advanced string joining and splitting, and simple caching, showing how each feature can make code cleaner, safer, and more efficient.
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.
This guide walks engineers through every stage of technical interview preparation—from researching job requirements and mastering core backend concepts to systematic coding practice, project presentation, soft‑skill polishing, resume crafting, submission strategies, mock interviews, and maintaining a positive mindset for success.
This article examines the limitations of using JPA for complex queries in SpringBoot projects and demonstrates how MyBatis‑Flex can simplify conditional queries, partial field selection, Kotlin integration, and code generation through clear code examples and practical guidance.
This article examines the concept of weak pointers and weak references in Go, Rust, Java, and C#, comparing their implementations, explaining their memory‑management semantics, presenting concrete code examples, and discussing the upcoming Go weak‑pointer proposal and practical scenarios such as caching and event handling.
The article describes a year‑long development experience where a senior architect designs, plans, and implements a sharding solution for loan and repayment tables using ShardingSphere, Spring Boot 3, MySQL, and custom synchronization code to migrate billions of rows while ensuring data consistency and operational continuity.
This article explains the concept of gray (canary) release, details the core components and version configuration, and provides a complete Spring Cloud implementation—including custom request holders, gateway filters, Ribbon load‑balancer extensions, Feign interceptors, and deployment instructions—for smoothly rolling out new service versions.
This article outlines the twelve new JEPs introduced in JDK 23, highlighting language previews, API enhancements, and performance boosts, while also reviewing the BenQ RD280U monitor’s larger screen, programming mode, Moonhalo backlight, eye‑care technologies, and software integration that together can significantly improve developer productivity.
JDK 24, slated for a March 2025 release as a non‑LTS version, introduces JNI usage warnings, a G1 garbage‑collector post‑barrier extension, a finalized Class File API, and several potential enhancements, while offering six months of premium support following the recent JDK 23 launch.
Learn how the Interface Segregation Principle (ISP) of SOLID design encourages splitting large interfaces into focused, minimal ones, reducing unnecessary method implementations, improving maintainability, and enhancing modularity across backend Java code, frontend React components, and state‑management modules, while also noting its trade‑offs.
This article explains what syntactic sugar is, outlines its benefits such as readability, reduced boilerplate, and lower error rates, and then showcases ten concrete Java syntactic‑sugar features—including autoboxing, enhanced for‑loops, generics, varargs, try‑with‑resources, lambdas, method references, string concatenation, switch expressions, and type inference—complete with code examples.
JD’s hot‑key detection framework instantly identifies bursty hot requests, pushes the hot keys to a clustered memory layer, and broadcasts them to all JVMs, enabling client‑side caching, user blocking, and circuit breaking, while handling up to 370 000 detections and 800 000 pushes per second and reducing backend query load by over 50 % in large‑scale events.
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 article details a real-world performance optimization of a high‑concurrency Java backend interface, reducing response time from 30 seconds to under 0.8 seconds through SQL analysis, array aggregation, moving logic to PostgreSQL, and introducing Caffeine caching, with code examples and lessons learned.
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.
JD’s Hotkey framework provides millisecond‑level detection and cluster‑wide push of hot data, users, and interfaces, dramatically reducing backend query load, improving performance, and supporting scenarios such as local caching and rate limiting, with proven scalability demonstrated in large‑scale e‑commerce promotions.
This article clarifies the purpose of Java classes ending with “O”—BO, DTO, VO, PO—explains their proper usage in a typical front‑end/back‑end workflow, and compares mapping solutions like Spring BeanUtils and MapStruct with code examples.
This guide explains why MySQL or Java processes can consume 700‑900% CPU in production, walks through step‑by‑step diagnosis using Linux tools, and provides concrete remediation techniques such as indexing, caching, thread analysis, and code adjustments to restore normal performance.
This article explains the concepts, characteristics, and ideal scenarios for unbounded and bounded queues in Java, provides step‑by‑step Maven setup and complete code examples for asynchronous task scheduling, event‑driven processing, and API rate‑limiting, and highlights practical considerations such as resource management and performance.
This guide introduces Java performance analysis fundamentals, covering profiling tools, key metrics such as CPU, memory, thread behavior, and practical methods to detect and resolve common issues like memory leaks, GC pauses, high CPU usage, I/O bottlenecks, and inefficient collection usage.
This article explains the theoretical and practical limits of Java String length, covering compile‑time restrictions, UTF‑8 encoding effects, constant‑pool constraints, runtime constructor limits, memory consumption, and JDK 9 optimizations, with illustrative code examples.
This article explains how to design and implement a fixed-size FIFO export queue in a Java backend using Spring components and EasyExcel, covering business requirements, class definitions, code examples, testing results, and considerations for further enhancements such as Redis queues and high‑concurrency scenarios.
This article walks through building a local AI question‑answer system using Java, Ollama, LangChain4J, embeddings, and a Chroma vector database, covering LLM fundamentals, embedding techniques, RAG architecture, setup steps, Maven dependencies, and sample code to retrieve and answer queries.
This guide walks you through installing Appium Desktop, configuring and launching the server, creating a simple Java test for the Android calculator app, exploring multiple element‑locating strategies (ID, class name, XPath, Accessibility ID, UIAutomator), and using the desktop tool’s element inspector and recording features to generate test scripts.
This article provides a detailed tutorial on using Maven for Java projects, covering basic repository setup, dependency declaration, scope options, indirect dependencies, exclusions, variable properties, multi‑module configuration, dependencyManagement, and essential plugins such as jar, assembly, and shade, with practical code examples and best‑practice recommendations.
This article critiques overly complex Spring Boot controllers filled with try-catch and validation logic, demonstrates a cleaner implementation using @Valid annotations and reduced code, provides global exception handling examples, and concludes with advice on maintaining concise controller methods while also promoting related community resources.
The article explains how adding a new reducePrincipal field to the RepayPlan class caused existing interfaces to miscalculate remaining principal, and demonstrates fixing the low‑cohesion bug by centralizing the updated calculation in a RepaymentCalculator utility so future changes occur in one place.
The article explains how to store and deduplicate billions of identifiers efficiently by using a bitmap backed by Redis and extending it with a Bloom filter implementation in Java, highlighting memory calculations, practical commands, and code examples.
This article explains the difference between static and dynamic proxies in Java, walks through JDK dynamic‑proxy implementation steps, analyzes the underlying Proxy class generation process, and compares performance and usage with static proxies and CGLIB.
This article explores the CQRS (Command Query Responsibility Segregation) pattern, detailing its core concepts, implementation approaches—including logical, storage, and asynchronous separation—its benefits and challenges, and practical best‑practice guidelines for applying CQRS in modern high‑performance, scalable systems.
This article provides an in‑depth introduction to Java's BigDecimal class, covering its purpose for high‑precision arithmetic, frequently used constructors, essential arithmetic and conversion methods, comparison techniques, number‑formatting examples, common exceptions during division, and a utility class that encapsulates typical operations.
This article demonstrates how to secure API interfaces by implementing symmetric encryption and decryption for both GET and POST requests in a Spring MVC application, using ControllerAdvice to intercept and process request and response bodies, handling key management, signature verification, and serialization issues across H5, Android, and iOS clients.
