The article shows how to efficiently load 300,000 MySQL rows in Java by comparing MyBatis and plain-JDBC batch inserts, demonstrating that batching 1,000‑5,000 records per transaction with proper transaction control, connection pooling, and MySQL tuning reduces insertion time from hours to seconds.
This article introduces Spring Data JPA's Query by Example (QBE) feature, explains its benefits and limitations, and provides step‑by‑step code examples—including entity definition, repository setup, and various query scenarios—illustrated with SQL output and screenshots.
This article provides a comprehensive guide on using Jenkins Pipeline to automate the deployment of Java backend projects, covering pipeline concepts, parameterized builds, code checkout, Maven compilation, JAR packaging, remote uploading, backup, update, and service restart procedures.
This article describes the challenges and technical solutions for synchronizing billions of order records from a relational database to Elasticsearch, including multi‑source data reading, dynamic rate limiting, retry strategies, SPI‑based service integration, environment isolation, health‑checking, smooth migration, and structured logging, all implemented in a backend service called ECP.
This article introduces WeBlog, a Spring Boot + Vue 3.2 based front‑and‑back end blog, details its core features, module structure, technology stack, provides repository links and demo credentials, and showcases screenshots of the admin dashboard and user interface.
This article explains how to build a Maven‑based tool that scans a Java codebase, removes trivial getter and setter methods, adds Lombok’s @Data annotation, and rewrites the source files using JavaParser, complete with implementation steps, code examples, and usage instructions.
This article explains how to use Jenkins Pipeline to automate the deployment of a Java backend project, covering pipeline basics, parameterized builds, GitLab branch checkout, Maven compilation, JAR packaging, remote file transfer, backup, update, and service restart with Docker Swarm.
This article presents Liteflow, a lightweight yet powerful Java rule engine that supports XML/JSON/YAML rule files, multiple storage backends, and hot‑deployment, and demonstrates its components, configuration, and a real‑world e‑commerce workflow example with code snippets.
Graceful Response is a Spring Boot library that provides unified response wrapping, global exception handling, custom error codes, validation support, and configurable response styles, enabling developers to write cleaner controller code, reduce boilerplate, and improve API consistency.
This article explains how to create custom predicate and gateway filter factories in Spring Cloud Gateway, covering the underlying concepts, implementation steps, example code, and YAML configuration to tailor routing conditions and request handling for specific business needs.
This article explains the Fork/Join model and Java's ForkJoinPool, covering the divide‑and‑conquer algorithm, custom RecursiveTask implementation, core pool design, task submission methods, work‑stealing mechanics, commonPool pitfalls, and performance testing with code examples and practical guidelines.
A legacy Java project using MySQL, MyBatis 3.5.0, and an old mysql‑connector‑java version encounters a Conversion not supported for java.time.LocalDateTime error after switching to MyBatis‑Plus, and the article walks through root‑cause analysis, version upgrades, and practical fixes.
This article walks through the evolution of system architecture from monolithic to microservices, explains Spring Cloud Alibaba components, introduces Nacos for service registration and discovery, provides step‑by‑step installation and integration instructions, and includes code snippets for a Spring Boot project.
The article examines which Java backend technologies are considered obsolete—such as JSP, Struts, Hibernate, and others—by applying criteria like practical usage, depth of understanding, and interview relevance, and advises learners on what to drop, prioritize, or master for modern development.
This guide demonstrates how to use Spring's @Resource annotation to inject collections such as Map, List, and array, as well as single beans, and explains resolution strategies like @Priority, @Primary, BeanFactory, ApplicationContext, @Qualifier, and custom qualifiers.
This article introduces the open‑source Java library Disruptor, explains its core concepts such as RingBuffer, Sequence, and WaitStrategy, and provides a step‑by‑step demo with Maven dependency, event model, factory, handler, and a Spring‑Boot test illustrating high‑throughput producer‑consumer messaging.
This article provides an in‑depth overview of WebSocket, covering its definition, advantages and disadvantages, protocol details, connection lifecycle, message format, JavaScript and Java APIs, Spring Boot integration, performance considerations, and future development directions.
This article explains how Java's System.gc triggers full or concurrent garbage collection in NIO scenarios, detailing the JVM's handling of out‑of‑memory errors during memory‑mapped file operations and direct buffer allocations, and examines the behavior across various garbage collectors such as Serial, Parallel, G1, ZGC, and Shenandoah.
This article explains how to implement IP‑location lookup by recommending the free ip2region offline library, provides Maven dependency details, shows step‑by‑step Java code for loading the XDB file, querying an IP address, interpreting the result format, and highlights its high accuracy and cross‑region support.
This article introduces Alibaba's Druid JDBC connection pool, walks through a basic Java usage example, details essential configuration parameters, and demonstrates a multithreaded concurrency test to evaluate performance and stability in MySQL environments.
This article explains how to use Java Flight Recorder (JFR) and JProfiler for low‑overhead, production‑grade performance analysis, covering JFR advantages, process discovery, file generation commands, JProfiler features, memory and CPU profiling techniques, and includes practical code examples.
This guide explains how to define Spring AOP aspects with @Aspect, configure ProxyFactoryBean for fine‑grained proxy control, and create proxies programmatically using ProxyFactory, providing complete code examples and configuration details for Spring 6.1.2.
This article explains the main lock mechanisms used in concurrent and distributed Java applications—including pessimistic, optimistic, distributed, reentrant, spin, shared, read/write, fair, non‑fair, interruptible, segment, and lock‑upgrade techniques—along with their characteristics, usage scenarios, and sample SQL or Java code snippets.
The article guides beginners through command‑line Java execution, showing how JDK 8 requires explicit compilation and class‑path, JDK 11 introduces single‑source file launching without compilation, and JDK 22 extends this to multi‑file programs, allowing direct execution of several source files with a simple java command.
This article explains how configuration management evolves from simple local files in monolithic applications to centralized, dynamic configuration centers like Nacos for microservices, covering code examples, registration, deregistration, viewing, change subscription, and guidance on choosing a service registry.
This guide walks through reading local or network images in Java, creating a Graphics2D canvas, and applying either a red semi‑transparent text watermark or a scaled image watermark at pixel‑specified coordinates before saving the result as a PNG file.
This article explains how to replace the default embedded Tomcat container in Spring Boot with Undertow, compares their performance and memory usage through load tests, and demonstrates why Undertow is a better choice for high‑concurrency Java web applications.
A real‑world bug caused by incorrect year‑week calculation is explained, then the ISO‑8601 week‑based year definition and Java's LocalDate/WeekFields APIs are introduced to reliably compute the correct year and week for any date.
This article explains how to dynamically manage multiple data sources and ensure transaction consistency across a master and several application databases in Spring by extending AbstractRoutingDataSource, using configuration‑file and database‑table solutions, and implementing a custom multi‑database transaction manager.
This article examines the detailed steps and performance impact of creating a MySQL connection from a Java web application, measures the latency of the handshake and authentication using Wireshark, and demonstrates why connection pooling is essential for high‑traffic services.
This article explains how to handle log files that are too large to fit into memory by reading them line‑by‑line with Java streams, using a Counter class and BitSet to track service usage and efficiently generate a top‑10 report.
This article introduces Spring's BeanWrapper, explains how to set and retrieve simple and nested properties, demonstrates indexed and key‑based access, covers automatic and custom type conversion using PropertyEditorSupport and Converter, and clarifies conversion priority and registration details for backend developers.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, uncovers the root cause of a LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL connector, demonstrates version upgrades and code fixes, and shares a related production bug and its remediation.
This article investigates the time overhead of establishing MySQL database connections in Java web applications, detailing the TCP handshake, authentication steps, and measured latency using Wireshark, and demonstrates why connection pooling is essential to avoid hundreds of milliseconds per request.
The article analyzes high coupling problems caused by multiple controller calls and third‑party integrations in a Java settlement backend, and proposes a dedicated TPS microservice with unified Feign interfaces, enum‑based routing, and factory patterns to decouple frontend and backend logic while providing implementation examples and diagrams.
This article examines the internal read/write mechanisms of Java's FileChannel and MappedByteBuffer on Linux kernel 5.4, compares their performance through detailed source analysis and benchmarks, and explains why MappedByteBuffer often outperforms FileChannel for small I/O but can be overtaken for larger transfers due to page‑fault and dirty‑page handling.
This article introduces a Java library that simplifies file download in Spring applications by using a @Download annotation, supporting various source types, reactive and servlet environments, concurrent loading, compression, and customizable handlers, and details its architecture, code examples, and practical considerations.
This article explains how to achieve zero‑downtime releases for Java applications by using JVM shutdown hooks, Spring context events, and service‑registry tricks for both monolithic and microservice architectures, with concrete code samples, configuration details, and Kubernetes probes to ensure seamless online upgrades.
This article details a step‑by‑step investigation of a container whose memory usage spiked to 99% due to large objects being allocated to the old generation under G1GC, explains the root cause, demonstrates reproducible tests with JVM flags and monitoring tools, and provides practical mitigation strategies.
The article explains that Java database connection pools rely on blocking I/O and JDBC design rather than IO multiplexing, detailing the technical, architectural, and ecosystem reasons why multiplexed DB access is uncommon despite its potential performance benefits.
This article walks through Spring 6.1.2’s bean creation lifecycle, from the refresh entry point to property population, initialization, and disposable bean registration, illustrating each step with concise code examples and detailed explanations.
Although IO multiplexing can boost performance, most Java applications continue to use connection pools like c3p0 or Tomcat because JDBC is blocking, DB protocols require multiple sessions, and integrating NIO drivers into existing web containers adds significant complexity and ecosystem constraints.
The article describes a production OOM incident caused by downloading a 2.4 GB file, walks through GC log and heap‑dump analysis using MAT, identifies the problematic use of FileUtils.readFileToByteArray, and presents streaming and external storage solutions to prevent memory exhaustion.
This guide demonstrates how to use Spring's UriComponentsBuilder and related classes—UriBuilderFactory, ServletUriComponentsBuilder, and MvcUriComponentsBuilder—to construct, encode, and link URIs in various scenarios, providing clear code examples for each step, including handling templates, query parameters, and servlet contexts.
A tech roundup reveals Sam Altman's candid take on OpenAI’s branding, China’s sweeping ban on foreign CPUs, Apple’s AI partnership talks for iOS 18, and Oracle’s Java 22 release, highlighting how policy, funding, and new tools are reshaping the AI landscape.
This article analyses the challenges of protecting intellectual property in B2B Java applications, reviews existing obfuscation and encryption tools, and proposes a lightweight Maven‑based encryption plus javaagent decryption scheme that secures both proprietary code and third‑party dependencies while keeping performance impact below five percent.
This article explains common causes of extreme CPU usage in MySQL and Java applications, provides step‑by‑step troubleshooting methods using Linux tools and SQL commands, and presents real‑world case studies with concrete optimizations such as indexing, caching, and thread‑handling adjustments.
Java 8’s Stream API introduces a declarative, lazy-processing model for collections, and this article details multiple ways to create streams—including from collections, arrays, static factory methods, files, generators, and iterators—providing code examples and explanations to help developers harness its expressive and efficient data‑handling capabilities.
ThreadLocal in Java provides thread‑local variables by maintaining a per‑thread map, enabling data isolation, simplifying inter‑thread data transfer, and storing context information, while requiring careful handling to avoid memory leaks, thread‑pool contamination, and overuse.
This article provides a comprehensive guide to Java SE exception handling, covering the concepts and classifications of checked and unchecked exceptions, the try‑catch‑finally structure, custom exception creation, exception chaining, and best‑practice recommendations for writing robust, maintainable Java code.
This article explains how to integrate Apache Kafka into a Spring Boot project, covering dependency setup, producer and consumer configuration, code examples, and optimization tips to build a high‑throughput, reliable message processing system.
This article explains why Java's String class is immutable, detailing the benefits such as thread safety, cached hash codes, and string pooling, and describes the internal mechanisms—including a private final char array, creation of new objects on concatenation, and the intern method—that enforce this immutability.
This article recounts the end‑to‑end design, bottleneck analysis, and iterative performance tuning—including MySQL, Redis, RocketMQ, compression, sharding, and connection‑pool adjustments—that enabled a volunteer registration platform to meet demanding high‑concurrency and data‑accuracy requirements under limited resources.
This article explains how to build a high‑performance, dynamically configurable rate‑limiting utility for Java applications using Caffeine cache with a 1‑second refresh interval, covering data structures, limit‑checking logic, dynamic configuration, and sample code with test results.
This article explains how to diagnose and resolve severe CPU usage spikes—up to 900%—in MySQL and Java processes, detailing step‑by‑step identification, common causes such as missing indexes or excessive garbage collection, and practical remediation techniques including query optimization, indexing, caching, and thread analysis.
This article compiles a comprehensive Java backend interview guide covering Redis fundamentals, thread creation methods, thread‑pool pitfalls, Spring ecosystem relationships, IoC/AOP principles, shallow vs deep copying, collection cloning, differences between interfaces and abstract classes, and string handling classes, providing concise explanations and code examples for each topic.
This article examines JD's practical implementation of middle‑platform (中台) evolution, detailing the design rationale, the Matrix support framework, hot‑deployment mechanisms, class‑loader isolation, and business‑identity principles to illustrate how the architecture improves delivery speed and modularity.
This article introduces Bloom filters, explains their probabilistic principles, advantages and drawbacks, details how to add and query elements, derives false‑positive formulas, provides Guava, Redisson, Redis‑module, and custom bitmap implementations with code samples, and showcases real‑world business scenarios and performance benefits.
The article explains JVM runtime memory regions, heap allocation and generational layout, object reference types, major garbage‑collection algorithms and collectors, class‑loading phases, and provides practical tuning commands and case studies for optimizing GC pauses, preventing memory leaks, and diagnosing performance bottlenecks.
This article explains the Fork/Join model and Java's ForkJoinPool, covering divide‑and‑conquer theory, custom RecursiveTask examples, pool construction options, task submission methods, work‑stealing mechanics, commonPool pitfalls, and performance testing results to help developers decide when to use it.
This article explains how to improve large‑file upload experiences by using instant transfer (MD5‑based deduplication), chunked upload, and resumable upload techniques, and provides complete Java backend implementations with Redis coordination and code examples using RandomAccessFile and MappedByteBuffer.
This tutorial introduces the EasyCode IntelliJ IDEA plugin, explains how to install it, connect a database, configure generation settings, and automatically produce Java CRUD components such as entities, DAOs, services, and controllers, concluding with integration steps in a Spring Boot application.
The article details the short‑term support JDK 22 release, highlighting twelve JEP‑driven enhancements—including G1 region‑fixed GC, constructor‑pre‑super statements, foreign function & memory API, unnamed variables, class‑file API, multi‑file source launch, string templates, vector API, stream collectors, structured concurrency, implicit classes, and scoped values—while also noting Oracle’s six‑month support, community contributions, and migration considerations.
A production incident where a poorly implemented lazy‑loading mechanism for KMSClient caused repeated initialization, blocking threads, exhausting the shared thread pool, and triggering RejectedExecutionException alerts, was investigated step‑by‑step, leading to a concrete code fix, improved monitoring, and better thread‑pool isolation.
A Java backend debugging story explains how using BeanUtils.copyProperties led to a ClassCastException when a HashMap was cast to a custom class, details the investigation steps, shows the problematic code, and presents a manual assignment solution plus recommendations for safer mapping tools.
Oracle warns Java developers that upgrading Apple Silicon macOS Sonoma to version 14.4 can crash JetBrains IDEs by sending a SIGKILL signal, and advises postponing the update until a fix is available, highlighting the impact on multiple JDK versions.
This tutorial explains RBAC concepts and model classifications, demonstrates permission and user‑group management, and provides step‑by‑step guidance for implementing Spring Security with in‑memory authentication, JWT integration, JSON login, password encryption, and database authentication using Java code examples.
This article explains how using a Java thread pool for multithreaded pagination can dramatically speed up large‑scale data queries, outlines thread‑pool concepts and benefits, details ThreadPoolExecutor parameters and work‑queue options, and reviews common rejection policies and built‑in pool factories.
This article explains the principles of Single Sign‑On (SSO) and OAuth2.0, compares their workflows, describes the main steps of each protocol, outlines the four OAuth2.0 grant types, and clarifies the distinctions between SSO, OAuth2.0, JWT, and Java security frameworks.
The article explains Java 22’s new Stream Gather API, which extends the traditional Stream model with custom Gatherers that can emit zero‑to‑many elements, enabling stateful, parallel operations such as a concurrency‑controlled mapConcurrent operator built on virtual threads, and compares it to Reactor‑core and Pekko‑Stream.
The article details a real‑world debugging case where a Java service threw a ClassCastException due to BeanUtils.copyProperties performing a shallow copy, explains the investigation steps, shows the problematic code, and presents a manual‑assignment solution along with reflections on safer alternatives.
Java 22 introduces twelve enhancements—including seven preview features and one incubator feature—that span language syntax, APIs, performance, and tooling, with detailed explanations of each JEP and the practical value they bring to developers.
This article explains how Spring Boot's @Conditional annotations—covering class, bean, property, resource, web application, and SpEL expression conditions—can be used to conditionally load configuration and beans, with examples and guidance on custom conditions.
This article compares Java and Go generics, explaining their syntax, type constraints, union types, variance, and practical code examples, while highlighting key differences such as explicit constraints in Go, Java’s type hierarchy, and the impact on type switches and type safety.
This guide walks you through creating a Spring Boot project, integrating the Druid connection‑pool, configuring its WebStatFilter and StatViewServlet for full SQL monitoring, testing the setup, and removing the built‑in advertisement via a custom filter.
This article provides an in‑depth tutorial on Alibaba Sentinel, covering its core concepts, installation of the dashboard, integration with Spring Cloud microservices, detailed configuration of flow control, degrade rules, hot‑parameter limiting, system adaptive protection, custom block handlers, persistence with Nacos, and cluster flow control for high‑availability services.
This article explains six typical OutOfMemoryError situations in Java—heap, native thread, stack overflow, direct buffer, GC overhead, and Metaspace—provides code examples that trigger each issue, shows the resulting exception messages, and offers practical tips such as using thread pools, limiting recursion depth, adjusting GC settings, and configuring Metaspace to avoid these memory problems.
This article explains why a Java page took five seconds to load, identifies three bottlenecks involving large BLOB fields and file I/O, and walks through four optimization steps—including lazy loading, buffered streams, memory‑mapped files, and sendFile zero‑copy—that reduce the load time to under one second.
This article explains Spring Web MVC.fn's functional programming model, covering HandlerFunction, immutable request/response contracts, parameter validation, routing predicates, nested routes, filters, and provides complete code examples for building functional endpoints in Spring Boot 2.7.
This article demonstrates how to quickly locate and resolve frequent full GC and CPU spikes in Java backend services by combining Arthas‑integrated async‑profiler flame graphs with VisualVM, GCEasy analysis, and practical step‑by‑step deployment procedures.
This article demonstrates various methods for inserting 300,000 rows into a MySQL database using Java, including direct batch insertion with MyBatis, row‑by‑row insertion, and optimized batch strategies for both MyBatis and JDBC, along with performance results and practical tips.
This article introduces Spring 6's new HTTP Interface feature, walks through building a Spring Boot project with a User entity, a REST controller, an HTTP Interface definition, and a test using WebClient, while explaining related annotations and the need for Spring Reactive Web dependencies.
If you’ve received the macOS 14.4 upgrade prompt, Java developers should postpone the update because the new OS sends an uncatchable SIGKILL signal on protected‑memory writes, causing immediate termination of Java processes on Apple Silicon machines.
This tutorial explains how to let users upload PDF, Word, or TXT files, install the Elasticsearch Ingest Attachment Processor Plugin, create an ingest pipeline and index mapping, convert files to Base64, and perform fuzzy searches with highlighted results using Spring Boot and Java code examples.
This article explains what Java annotations are, their underlying nature as interfaces extending Annotation, the various meta‑annotations such as @Retention and @Target, how retention policies affect availability, and demonstrates how to parse SOURCE‑retention annotations using a custom AbstractProcessor with complete code examples.
This article explores six typical OutOfMemoryError situations in Java—including heap, stack, direct memory, GC overhead, and metaspace issues—explains their root causes, provides reproducible code examples, and offers practical tips to avoid or mitigate each problem.
This article explains how to replace a simple Map‑based rate limiter with a Caffeine cache‑backed solution that supports dynamic TPS configuration, outlines the data structures, limit‑checking logic, and provides full Java/Groovy code examples along with a test script and its output.
This tutorial explains how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including removing irrelevant nodes, inspecting class members, adding other classes, and jumping to source code.
This article explains the Java volatile keyword, covering its underlying principles, effects on visibility and instruction reordering, appropriate usage scenarios, limitations, and provides a practical code example demonstrating how volatile ensures thread visibility and prevents dead loops in multithreaded programs.
Typical reasons for Java backend services hitting 100 % CPU include fetching massive data sets, misusing Kafka auto‑acknowledge, infinite loops or recursion, thread‑pool overload causing context‑switch thrashing, bulk file synchronization, lock‑order deadlocks, poorly designed regular expressions, and intensive real‑time calculations under high concurrency.
This article walks you through creating a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration classes, registration via spring.factories (or the new imports file), and comprehensive unit testing strategies to ensure reliable conditional behavior.
The article surveys frequent Java development mistakes—such as NullPointerExceptions, unsafe object equality, improper null handling, manual mapping errors, thread‑safety and thread‑pool misuse, swallowed exceptions, Spring bean initialization problems, memory leaks, performance traps, and transaction misconfigurations—while offering practical fixes like annotations, Optional, MapStruct, concurrent utilities, immutable wrappers, bounded executors, unified logging, and proper AOP usage.
This tutorial demonstrates how to build a custom dynamic data source solution in Spring Boot by combining ThreadLocal and AbstractRoutingDataSource, covering the implementation of context holders, routing logic, configuration, testing, annotation‑driven switching, and runtime addition of new data sources.
Learn how to integrate Nacos as a dynamic configuration center to modify Java thread pool sizes at runtime, covering dependency setup, initial Nacos configuration, custom listener implementation, thread pool usage, testing, and the benefits of adaptive scaling for production systems.
This article explains MyBatis dynamic SQL, its purpose, and how to use various tags such as if, where, trim, choose, foreach, include, sql, resultMap, association, and collection, providing detailed code examples and best‑practice guidelines for building flexible and secure SQL statements in Java applications.
This article demonstrates how to use Spring Framework 6's new HTTP Interface feature by creating a simple Spring Boot application, defining a User entity and controller, implementing an HTTP Interface with @GetExchange, and testing the service via a WebClient proxy, while covering required dependencies and key annotations.
Upgrading from JDK 8 to JDK 19 brings significant performance, security, and modularity improvements, but requires careful compatibility testing, performance evaluation, and security checks, while offering new features such as Text Blocks, Virtual Threads, Record Patterns, and enhanced APIs, positioning Java for future cloud, big data, and AI workloads.
This article provides a comprehensive analysis of the Spring framework, covering its core concepts, main components such as IoC container, AOP, data access and web support, its modular and declarative features, and the author’s personal learning experiences and best‑practice insights.
This article explains Java's reflection mechanism, detailing its core concepts, how it works at runtime, common application scenarios such as framework design, plugin systems, and dynamic proxies, and highlights important performance, security, and maintainability considerations.
This article explains Java generics, covering their basic concepts, type‑erasure implementation, common use cases such as collections, generic methods and classes, and the resulting improvements in type safety, readability, and code reusability.
