A senior Java developer at Eaton Corporation sabotaged the company's global production system with malicious code before his dismissal, causing a massive outage, data loss, and a four‑year prison sentence, highlighting the severe risk of insider threats and the need for robust access controls and monitoring.
An unexpected NullPointerException occurs when adding a simple log line to a Java DTO, revealing that FastJSON’s serialization process invokes methods like isChinaName(), getXxx(), and isXxx() via ASM-generated serializers, and the article explains the underlying mechanism, common pitfalls, and best‑practice annotations to avoid such bugs.
This article explains how the Model Context Protocol (MCP) bridges large language models and external services by converting OpenAPI specifications into callable tools, covering generation with openapi‑generator, mapping rules, three runtime modes (stdio, streamable, SSE), and implementation details in Java, Python, and Go.
During a gray‑release a single server reported that the Spring container was closed while the Netty server still accepted HTTP requests, leading to an IllegalStateException; the article analyzes the root cause in Dubbo startup, explains the event flow, and proposes a reliable fix using ApplicationReadyEvent.
By merging similar or duplicate requests upstream before sending them downstream, you can dramatically reduce downstream load and boost overall throughput; this article compares Hystrix Collapser, a custom BatchCollapser, and Guava's ConcurrentHashMultiset, detailing their implementations, configurations, and ideal use cases.
This article explains why Redisson's RMapCache.size() includes expired entries, demonstrates how to obtain the exact number of currently valid key‑value pairs using keySet().size() or readAllEntrySet().size(), and provides performance tips and a real‑world e‑commerce use case.
This guide explains how to replace Spring Boot's default Logback with Log4j2, covering Maven dependency changes, XML/YAML configuration, Java usage examples, advanced options like environment-specific files and asynchronous logging, and common troubleshooting tips.
This article explains why asynchronous execution is essential for reducing latency in Java applications and walks through eight practical implementations—including threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava—complete with code examples and usage tips.
Spring Boot AOP simplifies cross‑cutting concerns such as logging, transaction management, and monitoring by using proxy‑based aspect‑oriented programming; this guide walks through adding dependencies, core concepts, proxy mechanisms, configuration, defining aspects with various advice types, custom annotations, real‑world scenarios, best practices, and troubleshooting tips.
This guide walks you through installing RabbitMQ, configuring Spring Boot, building basic producers and consumers, exploring work, fanout, direct and topic patterns, and applying advanced features like confirmations, manual ACKs, TTL, dead‑letter, delayed and priority queues, plus clustering, monitoring and troubleshooting tips.
This article explains the differences and relationships between processes, threads, coroutines, and virtual threads, provides detailed Java code examples, compares their characteristics and performance, and offers practical guidance on choosing the right concurrency model for various scenarios.
This article combines practical advice for negotiating offers at Tonghuashun with a comprehensive Java interview cheat‑sheet covering method overloading vs overriding, final vs finally, sleep vs wait, HashMap insertion and resizing, reference types, HTTP request structure, status codes, thread‑pool parameters, and garbage‑collection algorithms.
This article explains how Java's BigDecimal class maintains exact decimal precision by scaling numbers to integers, detailing its internal fields, the add method implementation, and a concrete example that demonstrates the underlying computation steps.
Discover how treating the literal string "null" as a legitimate username can cause hidden bugs across frontend validation, backend logic, database integrity, and security, and learn practical code snippets and defensive strategies to detect and prevent these pitfalls.
This article explains the fundamental differences between processes, threads, coroutines, and virtual threads, shows how they are implemented in Java with code examples, compares their performance, and provides practical guidance on choosing the right concurrency model for various workloads.
This article introduces the Java Diff Utils library, explains its core features such as computing differences, applying patches, and generating unified diffs, and provides step‑by‑step Spring Boot 3 examples—including dependency setup, string list comparison, patch generation, application, side‑by‑side view creation, and HTML rendering—for efficient text version control.
This article explains how to simplify Spring MVC controller code by introducing a unified response format, leveraging ResponseBodyAdvice for automatic wrapping, applying JSR‑303 validation for request parameters, creating custom validators, and handling exceptions globally to keep business logic clean and maintainable.
This article explains why thread pools are essential for performance, explores the JDK ThreadPoolExecutor’s internal architecture, parameters, lifecycle states, common pitfalls, and provides practical best‑practice guidelines—including handling invokeAll timeouts, submit exceptions, rejection policies, and pool isolation techniques—to help developers use thread pools safely and efficiently.
This step‑by‑step tutorial shows Java beginners how to create a Spring Boot 3.5.5 application that generates a math‑expression image captcha, stores the answer in session or an in‑memory map, provides REST endpoints, handles CORS, and includes a complete front‑end page with refresh and validation logic.
This guide compiles high‑frequency Java interview questions—from core language concepts and collections to JVM tuning, MySQL indexing, Redis caching, Spring frameworks, micro‑services, and MQ reliability—providing a comprehensive reference for candidates targeting small‑to‑mid‑size companies.
This guide walks you through adding MQTT dependencies, configuring connection parameters, creating a unified MqttConfig class, defining a messaging gateway, implementing service and controller layers, and applying advanced production settings such as SSL/TLS, multi‑topic subscriptions, QoS choices, clustering, health checks, and performance tuning for Spring Boot applications.
This guide explains how Spring Boot 3.x uses Logback by default, shows basic property‑based setup, advanced logback‑spring.xml configurations, profile‑specific logging, SQL tracing with Hibernate, MyBatis, p6spy and datasource‑proxy, plus MDC tracing, async logging, alerting and production best practices.
This guide walks you through creating a SpringBoot parent project, adding common, business, and API‑gateway submodules, configuring dependency management, structuring the repository, isolating logs, and building or running individual modules, while highlighting common pitfalls and best‑practice layouts.
This article provides a comprehensive, step‑by‑step breakdown of Spring Boot's auto‑configuration system, covering its core SPI‑based design, execution flow, conditional annotations, the evolution from spring.factories to the new .imports file in version 3.x, practical examples, custom configuration creation, and debugging techniques.
This guide walks through two approaches for configuring multiple databases in a Spring Boot and MyBatis project—native multi‑data‑source beans and the dynamic‑datasource‑spring‑boot‑starter—covering project structure, Maven dependencies, Java configuration, mapper setup, usage examples, common pitfalls, and a concise summary of when to choose each method.
This article explains how xxl‑job uses Netty HTTP, dynamic proxies, and fully asynchronous processing to implement a high‑throughput RPC mechanism, detailing the communication layer, overall workflow, and the clever design that wraps async calls into synchronous‑looking code.
The article introduces a self‑built utility that automatically generates Java backend code—including entity classes, DAO interfaces, service implementations, and controllers—based on database table definitions, dramatically reducing the manual effort of creating dozens of tables and their associated CRUD logic.
This article explains why traditional database search struggles with large data sets, introduces Lucene as a high‑performance full‑text engine, and shows step‑by‑step how to integrate it into Spring Boot 3 using Hibernate Search, custom analyzers, entity mapping, repository extensions, and test cases.
This guide explains why adding the javacv‑platform dependency inflates a Java project's JAR to hundreds of megabytes and shows how to configure Maven to include only the needed native libraries, dramatically reducing size, build time, and deployment overhead.
This guide lists the 15 most common MyBatis pitfalls—from SQL injection and mismatched field mappings to N+1 queries and improper pagination—paired with concrete best‑practice solutions, code snippets, and configuration tips to make your persistence layer safer, more efficient, and easier to maintain.
This guide walks through adding MyBatis-Plus to a Spring Boot project, configuring basic settings, using CRUD operations, condition builders, pagination, advanced features like auto‑fill, logical delete, optimistic locking, code generation, common pitfalls, and practical recommendations for effective usage.
This tutorial walks through using Zhihu's open‑source FUST microservice framework together with DeepSeek's language model API to design, implement, and deploy a scalable, high‑performance intelligent Q&A system, covering architecture, data models, service layers, and deployment scripts.
This article examines common token‑renewal pitfalls and presents five practical solutions—including single‑token, blacklist, double‑token with triple validation, automatic renewal, and distributed‑environment techniques—while offering best‑practice guidelines to enhance security, user experience, and system scalability.
This tutorial walks you through setting up a Spring Boot project with Tess4J, adding required dependencies, configuring language data, implementing an OCR service and REST controller, and testing both local file and remote URL image recognition, all with complete code examples.
Brian Goetz, Java language architect, outlines his vision for a more growable Java by introducing the “witness” concept, discussing underlying philosophy, potential new features like numeric types, operator overloading, collection expressions, and how these ideas fit into the Valhalla project and Java’s future roadmap.
This article explains how to handle JSON objects with unknown or dynamic fields in Java using Jackson's @JsonAnySetter to collect extra properties into a Map and @JsonAnyGetter to serialize them back as regular fields, complete with practical code examples and common pitfalls.
This tutorial walks through integrating SpringDoc into a Spring Boot project, covering why it replaces SpringFox, how to configure it with minimal settings, add API annotations, set up grouped documentation, and handle static resources and Spring Security for full Swagger UI access.
This article explains how to migrate a Java application from JPA 2.x to Jakarta Persistence 3.0 by updating Maven dependencies, replacing javax.persistence imports with jakarta.persistence, adjusting XML namespace URLs, and renaming configuration properties, all illustrated with concrete code snippets.
This article explains how timeless design patterns—from Singleton to Builder—continue to enhance code reuse, maintainability, and team collaboration in cloud‑native and microservice systems, while also highlighting practical applications, performance trade‑offs, and common pitfalls.
This tutorial walks through adding the required Maven dependencies, configuring application.yml, creating SwaggerConfig, implementing sample controllers, accessing the enhanced Knife4j UI and Swagger UI, troubleshooting common issues, and comparing SpringDoc OpenAPI with Knife4j OpenAPI3 to help developers choose the right solution for Spring Boot 3.x projects.
This article provides a comprehensive comparison of JWT and Token‑Redis authentication schemes, covering their underlying principles, Java implementations, advantages and disadvantages, performance and security trade‑offs, suitable use‑cases, and practical guidance for choosing the optimal solution in modern web and mobile applications.
Tree-sitter is a high‑performance incremental parsing library that supports over 50 languages; the article explains its core features, typical use cases such as editor syntax highlighting and static analysis, and walks through a concrete multi‑language SQL extraction implementation in Java, Python, and XML.
Password reset security relies on the server storing only salted hash values, not the original passwords; this article explains why plain‑text storage is unsafe, outlines hash algorithm types, demonstrates MD5’s shortcomings, and provides Java code for generating SHA‑256 + salt hashes.
This guide outlines the mandatory code changes required when moving from JDK 8 to JDK 17—such as removed modules, internal API restrictions, and compiler flag updates—and highlights optional optimizations like var inference, collection factories, switch expressions, records, text blocks, enhanced Stream and Random APIs, with practical examples and migration steps.
This article explains Java generics, their benefits such as type safety, readability, code reuse and performance, and shows how type erasure works by demonstrating that two differently typed ArrayLists compare equal at runtime, revealing the underlying implementation details.
This article examines script injection threats in Java applications and compares static, dynamic, and interactive security testing tools—SAST, DAST, and IAST—highlighting their strengths, weaknesses, and popular options to help developers select the most suitable solution.
This article explains how using a bitmap can reduce the memory needed to store billions of integers from about 15 GB to under 500 MB, describes the bitmap concept, introduces Bloom filters, outlines their principles, advantages, common use cases, and provides Java and Redis code examples for implementation.
This article explains Java reflection—a powerful feature used by frameworks like Spring and MyBatis—covering its core concepts and demonstrating five practical ways to invoke methods, access fields, handle static and private methods, and work with superclass methods using concise code examples.
This article provides a comprehensive guide to Spring Batch, covering its purpose, supported business scenarios, core components and interfaces, Maven setup, sample job definitions, parallel execution, decision flows, nested jobs, data reading and writing, validation processing, and REST‑based job scheduling, all illustrated with complete code examples.
This article compiles essential Spring and Java utility methods—including assertion checks, object and collection handling, file I/O, resource management, and reflection/AOP tools—providing concise code examples and usage guidelines to help developers avoid redundant code and write cleaner, more reliable applications.
Explore 11 practical Spring Boot bean registration methods—from simple @Component scanning to advanced ImportSelector, FactoryBean, and runtime dynamic registration—detailing code examples, use cases, and configuration steps, enabling developers to choose the optimal approach for flexible, modular applications.
Oracle’s latest LTS release, JDK 25, introduces compact source files, streamlined module imports, enhanced constructors, memory‑efficient compact object headers, AI‑friendly features like pattern matching and the Vector API, plus performance and security improvements, while aiming to make Java more approachable for beginners.
Explore eight practical techniques for achieving asynchronous execution in Java—from low‑level threads and Futures to Spring’s @Async, ApplicationEvent, message queues, and Guava ListenableFuture—complete with code samples, performance insights, and best‑practice recommendations for building responsive backend services.
This article provides a comprehensive guide to Spring transaction management, covering both programmatic (TransactionTemplate) and declarative (@Transactional) methods, explaining their principles, code examples, and how Spring abstracts underlying JDBC steps to simplify database transaction handling for backend developers.
This article analyzes MyBatis‑Flex, highlighting its lightweight, flexible, and powerful design, compares its feature set and performance against MyBatis‑Plus and Fluent‑MyBatis, lists supported databases, and provides a step‑by‑step quick‑start tutorial with code examples.
The article explains why process orchestration is crucial for backend systems, illustrates common pitfalls of scattered if‑else logic, and demonstrates how a flow engine combined with plugin extensions—using the open‑source MemberClub project—provides clean, extensible business logic execution.
easy-jenkins is an open‑source, lightweight tool that provides one‑click deployment for Vue and JAR projects, featuring a simple UI, branch‑based configuration, local storage, and real‑time deployment logs, making small‑scale local deployments fast and easy.
This tutorial shows how to integrate HTMX into Spring Boot 3 projects to build SPA‑like pages without writing JavaScript, covering environment setup, AJAX requests, debounced search, multi‑form queries, HTML fragment rendering, and Server‑Sent Events with full code examples.
This article explains how to use Spring's BeanRegistrar to programmatically register beans with precise scope, lazy initialization, and custom providers, offering advantages over traditional annotation‑based configuration and demonstrating the approach with a complete GreetingService example.
A detailed post‑mortem explains how a sudden traffic surge, insufficient pod count, and a custom thread‑pool bottleneck caused Tomcat thread‑pool saturation, health‑check failures, and a zone‑wide outage, and offers concrete lessons on capacity planning, monitoring, and safe coding practices.
Spring Boot’s “convention over configuration” hides many default settings that can cause performance bottlenecks and runtime failures, from Tomcat and HikariCP connection limits to JPA lazy loading, timezone serialization, logging, caching, file upload limits, thread pools, and transaction timeouts, and the article shows how to tune each.
This guide explains how to implement high‑performance asynchronous APIs in Spring Web using CompletableFuture and ResponseBodyEmitter, covering controller and service code, configuration, request lifecycle, client handling, Nginx settings, and practical recommendations for choosing the right approach.
This article explains Java thread‑safety concepts, how to use and configure ThreadPoolExecutor, Redis performance tricks, Zset internal structures, memory‑eviction policies, node‑failure handling, cache‑DB consistency patterns, and MySQL transaction ACID properties with MVCC differences, providing practical code examples throughout.
This article introduces Easy-Es, an Elasticsearch ORM that mimics MyBatis‑Plus syntax, walks through its core features, integration steps, entity annotations, mapper and service implementations, and demonstrates simple, advanced, and recommendation search scenarios, highlighting the reduction in boilerplate code.
This article shares practical techniques for reducing verbose if‑else statements in Java, covering strategy‑enum patterns, ternary operators, Stream API methods, Map lookups, enums, and Optional, each illustrated with concise code examples to make conditional logic clearer and more maintainable.
This article explains how to define Jakarta Data repositories using Hibernate, covering the stateless nature of repositories, minimal and extended interfaces, custom lifecycle annotations, finder methods, and custom JDQL queries, with concrete code examples and generated SQL illustrations.
This article presents a continuously updated collection of 171 Spring Boot 3 practical cases, covering advanced topics such as global exception handling, custom interceptors, bean retrieval, configuration imports, startup runners, bean definition modification, initialization methods, custom scopes, and graceful shutdown, with full code examples and a free PDF ebook.
Learn how to seamlessly integrate MyBatis‑Plus with ShardingSphere‑JDBC for high‑performance sharding, covering core principles, step‑by‑step workflow, and detailed solutions to typical pitfalls such as SQL parsing, pagination conflicts, key generation, query routing, transaction handling, broadcast tables, injection risks, and shard algorithm design.
This article provides a comprehensive overview of the Spring framework, covering its core principles such as Inversion of Control, Dependency Injection, Aspect‑Oriented Programming, and transaction management, while illustrating each concept with diagrams and practical code examples for Java developers.
This article explains the complete Spring Bean lifecycle, breaks it down into six major phases and eleven detailed steps, describes how BeanFactory creates beans in four stages, and clearly distinguishes BeanFactoryPostProcessor from BeanPostProcessor with concrete examples and code snippets.
This article introduces the high‑performance Disruptor library, explains its core concepts such as Ring Buffer, Sequence, and Wait Strategy, and provides a step‑by‑step Java demo—including Maven setup, event model, producer, consumer, and test—showcasing how to build a lock‑free in‑memory message queue.
This article compares the token‑bucket and leaky‑bucket rate‑limiting algorithms, explaining their core principles, Java implementation details, key advantages and drawbacks, suitable application scenarios, interview‑style Q&A, and advanced hybrid strategies for building robust high‑concurrency systems.
This guide explains how to load external JAR files into the JVM, configure SpringBoot to recognize them, and choose among several class‑loading strategies—including expanding the classpath, using the loader.path parameter, or implementing a custom classloader—while providing Maven configuration examples and code snippets.
This article explains why inserting manual timing code is invasive, introduces the java.lang.instrument API, shows how to write a tiny Java Agent with premain and agentmain methods, demonstrates dynamic class redefinition via the Attach API, and explores how tools like Arthas and Bytekit leverage these mechanisms for runtime tracing and bytecode enhancement.
This article compares five major Java database access technologies—JDBC, Hibernate, Spring Data JPA, JOOQ, and MyBatis—detailing their code examples, strengths, weaknesses, and ideal use cases, while also offering a downloadable Spring Boot 3 case collection PDF for hands‑on practice.
This article explains how to use Spring's BeanRegistrar interface to programmatically register beans with precise scope, lazy initialization, and custom providers, providing code examples that demonstrate registering default and prototype beans and accessing them via a CommandLineRunner.
This article explores Java's HashMap internals, detailing its bucket array design, hash processing, collision handling, Java 8 treeification, resizing strategy, load factor and threshold calculations, performance optimization tips, common pitfalls, and when to choose alternative map implementations for high‑concurrency or ordered use cases.
This article explains the fundamental differences between Spring MVC interceptors and servlet filters, provides complete Java code examples for both, shows how to configure them in Spring and web.xml, and summarizes when to choose each approach for request handling and AOP-like functionality.
This guide explains how Java can mimic function pointers using interfaces with anonymous classes, lambda expressions, built-in functional interfaces, method references, reflection, the command pattern, and enum-based implementations, comparing their advantages, drawbacks, and ideal use cases for modern and legacy codebases.
This article examines five frequent Redis cache anti‑patterns—cache avalanche, unbounded local cache, stale data, missing invalidation, and oversized objects—explaining their pitfalls with code examples and showing concrete fixes that dramatically improve latency, throughput, and memory usage.
Learn what CORS (Cross-Origin Resource Sharing) is, why browsers block cross-origin requests, and how to configure servers—using Java, Express.js, or Spring Boot—to handle preflight checks, simple requests, and fine-grained security headers, ensuring safe and functional web applications.
This article explains how to use MinIO as an image storage service and implement a Spring Boot scheduled task that periodically deletes outdated image folders, covering dependency setup, delete utilities, performance considerations, cron expressions, thread‑pool tuning, asynchronous execution, configuration extensions, and testing strategies.
This article walks through why SpringDoc replaces SpringFox, shows step‑by‑step minimal configuration, dependency setup, controller annotations, API grouping (both programmatic and declarative), and necessary adjustments for WebMvcConfigurer and Spring Security to generate OpenAPI 3 documentation in a Spring Boot project.
The article reviews Java technologies that have become outdated—such as JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML—explaining why they no longer merit learning and recommending modern alternatives like Spring MVC, MyBatis, and a deep understanding of Servlets for today's backend development.
Recent Dimensional Research data shows that 73% of surveyed enterprises have encountered Oracle‑initiated Java license audits, prompting 15% to complete migration, 22% to start, and 25% to plan moving to OpenJDK or other open‑source JDKs, driven by cost and compliance pressures.
This article presents a comprehensive guide to generating PDF documents in Spring Boot 3 applications using iTextpdf and Thymeleaf, covering environment setup, Maven dependencies, data model, HTML template design, controller implementation, and a test case that produces a correctly rendered PDF with external CSS and images.
This article explains why tasks submitted to a Java ThreadPool via submit silently swallow exceptions while execute prints them, and demonstrates three practical ways—using Future.get(), a custom UncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process those exceptions.
This article walks through why Java 8 is being retired and highlights the most useful language features introduced from Java 8 through Java 24—including lambdas, streams, optional, records, sealed classes, virtual threads, and the new Stream Gatherers—providing code examples and practical guidance for modern Java development.
Learn how to implement graceful shutdown in Spring Boot by understanding the JVM shutdown hook, customizing cleanup logic with ContextClosedEvent listeners and @PreDestroy annotations, and configuring the spring.main.register-shutdown-hook property to ensure resources are released safely during application termination.
Learn how to replace tangled if‑else logic with four elegant solutions—Strategy pattern, Java SPI, Chain of Responsibility, and a rule engine—complete with concepts, UML diagrams, Java code examples, advantages, drawbacks, and practical usage scenarios for building maintainable, extensible backend systems.
This guide shows how to automatically inject userId and orderId into Spring Boot log messages by defining log placeholders, using ThreadLocal, creating a custom @UserLog annotation, and applying a Spring AOP aspect that populates MDC, dramatically simplifying logging in e‑commerce systems.
This article explains why null references cause NullPointerExceptions in Java and presents modern techniques—such as using Optional, fail‑fast checks, builders, records, the Null Object pattern, and utility libraries—to write safer, more expressive backend code.
This guide explains how to use Spring Boot's @RefreshScope to dynamically refresh configuration at runtime without restarting services, covering the underlying mechanism, step‑by‑step implementation, production best practices, troubleshooting tips, and advanced use cases.
This article explains MyBatis streaming queries, introduces the Cursor interface and its methods, demonstrates common pitfalls, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep database connections open while processing large result sets efficiently.
This article explains MyBatis streaming queries using the Cursor interface, demonstrates common pitfalls such as closed connections, and provides three practical solutions—including SqlSessionFactory, TransactionTemplate, and @Transactional—to reliably process large result sets with minimal memory usage.
This article explains how using the + operator for string concatenation in Java creates multiple immutable objects, why StringBuilder offers a memory‑efficient alternative, and analyzes two interview‑style code snippets with bytecode to reveal the exact number of objects each statement generates.
This article introduces a Maven aggregation plugin for IntelliJ IDEA that automates the creation of multi‑module Java projects, detailing its core features, installation methods, step‑by‑step usage, customization options, and troubleshooting tips to dramatically reduce setup time.
The article recounts a real production incident where a recent deployment triggered loss of third‑party order data, traces the root cause to an improperly configured ThreadPoolExecutor that used a local memory queue, and walks through the systematic investigation and remediation steps.
This article explains the core principles of Hessian, a Java‑optimized binary serialization protocol, covering object graph traversal, encoding formats, data‑block tags, repeated‑object reuse, small‑integer inlining, and integer compression, and shows why it offers higher efficiency and compression than text‑based alternatives.
This article shares Beike's recent campus hiring salary data and provides a comprehensive Java backend interview guide covering HTTP response codes, session vs. cookie, runtime and checked exceptions, abstract classes vs. interfaces, StringBuilder vs. String, JVM memory structure, multithreading techniques, thread‑pool parameters, the synchronized keyword, B+‑tree indexing, and essential Linux commands.
