BestHub
Sign in
Tagged articles
5000 articles
Page 40 of 50
Top Architect
Top Architect
May 6, 2024 · Operations

Graceful Service Shutdown and Deployment Strategies for Java Applications

This article explains how to achieve graceful service startup and shutdown in Java projects, covering monolithic and microservice architectures, Spring and SpringBoot mechanisms, service registration with Eureka and Nacos, Kubernetes probes, thread‑pool and MQ graceful termination, and provides practical code examples for each scenario.

Graceful ShutdownKubernetesMicroservices
0 likes · 27 min read
Graceful Service Shutdown and Deployment Strategies for Java Applications
JD Tech
JD Tech
May 6, 2024 · Fundamentals

Static and Runtime Code Scanning to Detect Unused Java Methods

This article presents a design and implementation of both static AST‑based scanning and runtime JaCoCo coverage analysis to automatically detect unused (zombie) Java methods, describing the workflow, required dependencies, code snippets, and how to visualize active versus dead code in the IDE.

ASTDead CodeJaCoCo
0 likes · 8 min read
Static and Runtime Code Scanning to Detect Unused Java Methods
Java Tech Enthusiast
Java Tech Enthusiast
May 6, 2024 · Backend Development

Design Patterns in MyBatis Source Code

MyBatis, a widely used Java ORM, embeds around ten classic design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template Method, Strategy, and Iterator—to modularize object creation, structure, and behavior, thereby simplifying complex data access and caching mechanisms within its architecture.

Design PatternsMyBatisORM
0 likes · 8 min read
Design Patterns in MyBatis Source Code
FunTester
FunTester
May 6, 2024 · Backend Development

Building a Multi‑Priority Thread Pool with Java's PriorityBlockingQueue

This article explains how to solve Java thread‑pool priority problems by leveraging java.util.concurrent.PriorityBlockingQueue, details its thread‑safe and unbounded features, and provides a complete multi‑priority thread‑pool implementation with sample code and a test demonstrating correct task ordering.

Priority SchedulingPriorityBlockingQueueThreadPool
0 likes · 6 min read
Building a Multi‑Priority Thread Pool with Java's PriorityBlockingQueue
Su San Talks Tech
Su San Talks Tech
May 5, 2024 · Backend Development

Fixing MyBatis‑Plus Migration Errors: Why LocalDateTime Conversion Fails and How to Resolve It

This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, explains the “Conversion not supported for type java.time.LocalDateTime” error caused by MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, and shows how upgrading the driver resolves the issue while offering debugging tips.

MyBatisORMdebugging
0 likes · 16 min read
Fixing MyBatis‑Plus Migration Errors: Why LocalDateTime Conversion Fails and How to Resolve It
Java Captain
Java Captain
May 4, 2024 · Backend Development

Implementing a FIFO Export Queue for Large Data Exports in Java

This article explains how to design and implement a fixed‑size FIFO export queue in a Java Spring application to control concurrent MySQL data exports, detailing the related entities, code implementation with EasyExcel, a test controller, and observed results.

BackendExport Queueconcurrency
0 likes · 10 min read
Implementing a FIFO Export Queue for Large Data Exports in Java
Code Ape Tech Column
Code Ape Tech Column
May 4, 2024 · Backend Development

Understanding PageHelper Pagination Issues and ThreadLocal Management in MyBatis

This article analyzes common anomalies caused by the PageHelper pagination plugin in a Java backend project—such as duplicate user registration, limited query results, and password‑reset errors—traces them to ThreadLocal misuse, explains the internal workflow of startPage, getLocalPage, and clearPage, and offers practical recommendations to avoid these pitfalls.

BackendMyBatisThreadLocal
0 likes · 11 min read
Understanding PageHelper Pagination Issues and ThreadLocal Management in MyBatis
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 4, 2024 · Backend Development

Refactoring Cloud Disk Upload Logic with Domain-Driven Design: Models, Factories, and Repositories

The article examines the difficulties of applying Domain-Driven Design to a cloud‑disk file‑upload scenario, demonstrates how to simplify the code by extracting business models, introducing factories and repositories, and explains how these patterns clarify the separation between business and technical concerns.

Domain-Driven DesignFactory PatternRepository Pattern
0 likes · 20 min read
Refactoring Cloud Disk Upload Logic with Domain-Driven Design: Models, Factories, and Repositories
Java Tech Enthusiast
Java Tech Enthusiast
May 2, 2024 · Backend Development

Why Not to Use Spring BeanUtils for Object Copying and How MapperStruct Improves Performance

Spring’s BeanUtils.copyProperties is error‑prone and slow due to type mismatches, primitive‑wrapper issues, null overwrites and reflection, whereas MapStruct generates compile‑time, type‑safe mapper code that avoids these pitfalls, delivers far better performance, and integrates easily with Maven and Lombok.

BeanUtilsObject MappingReflection
0 likes · 6 min read
Why Not to Use Spring BeanUtils for Object Copying and How MapperStruct Improves Performance
Java Tech Enthusiast
Java Tech Enthusiast
May 2, 2024 · Backend Development

Why IDEA Warns on @Autowired but Not on @Resource: A Spring DI Overview

IDEA flags @Autowired field injection but not @Resource because Spring advises against field injection—seeing it as tightly coupled and hard to test—while @Resource is a standard JSR‑250 annotation, so the IDE applies the warning only to the Spring‑specific @Autowired usage.

AutowiredIDEAdependency-injection
0 likes · 5 min read
Why IDEA Warns on @Autowired but Not on @Resource: A Spring DI Overview
Java Tech Enthusiast
Java Tech Enthusiast
May 1, 2024 · Fundamentals

Pitfalls of Arrays.asList in Java

Java's Arrays.asList method has three major pitfalls: it cannot directly convert primitive arrays like int[] because of autoboxing limits, it returns a fixed-size list that throws UnsupportedOperationException on modification, and the list shares its backing array so changes to the original array are reflected in the list; using Arrays.stream for boxing or wrapping the result in a new ArrayList avoids these issues.

Arrays.asListCode ExamplesCollections
0 likes · 4 min read
Pitfalls of Arrays.asList in Java
Java Tech Enthusiast
Java Tech Enthusiast
May 1, 2024 · Fundamentals

Zigzag Conversion Algorithm (LeetCode 6)

The Zigzag Conversion algorithm rearranges an input string into a Z‑shaped pattern across a specified number of rows, tracks the current row while toggling direction at the top and bottom, stores characters per row, and finally concatenates the rows to produce the transformed string, with reference implementations in C++, Java, and Python.

LeetCodePythonString
0 likes · 9 min read
Zigzag Conversion Algorithm (LeetCode 6)
Architect's Guide
Architect's Guide
May 1, 2024 · Fundamentals

Effect of Placing try‑catch Inside vs Outside a for Loop in Java

This article explains the behavioral and performance differences of positioning a try‑catch block either outside or inside a Java for‑loop, illustrating each case with code examples, execution results, memory analysis, and practical recommendations for handling exceptions during batch processing.

/loopException Handlingjava
0 likes · 5 min read
Effect of Placing try‑catch Inside vs Outside a for Loop in Java
Architect
Architect
Apr 30, 2024 · Backend Development

Using CompletableFuture for Asynchronous Programming in Java: Examples and Best Practices

This article explains why asynchronous programming improves performance, compares serial and parallel implementations of a login flow, and demonstrates how to use Java's CompletableFuture API—including supplyAsync, runAsync, callbacks, composition, and error handling—to write efficient backend code.

AsynchronousBackendCompletableFuture
0 likes · 22 min read
Using CompletableFuture for Asynchronous Programming in Java: Examples and Best Practices
JD Cloud Developers
JD Cloud Developers
Apr 30, 2024 · Artificial Intelligence

Build a Handwritten Digit Recognizer in Java with TensorFlow

This article walks through the complete process of creating, training, evaluating, saving, and loading a MNIST handwritten digit recognition model using TensorFlow in Java, comparing it with the equivalent Python implementation and covering required knowledge, environment setup, and code details.

Deep LearningMNISTTensorFlow
0 likes · 34 min read
Build a Handwritten Digit Recognizer in Java with TensorFlow
macrozheng
macrozheng
Apr 30, 2024 · Operations

How to Automate Java SpringBoot Deployment with Jenkins and Docker Swarm

This guide walks you through setting up Jenkins to pull code from GitLab, build a SpringBoot 3 Java project with Maven, back up and copy JAR files to a remote server, and perform rolling updates of Docker Swarm services, all with step‑by‑step instructions and code snippets.

DeploymentDocker SwarmJenkins
0 likes · 10 min read
How to Automate Java SpringBoot Deployment with Jenkins and Docker Swarm
Su San Talks Tech
Su San Talks Tech
Apr 30, 2024 · Backend Development

Mastering Context Propagation in Thread Pools with TransmittableThreadLocal

This article explains why standard ThreadLocal mechanisms fail with thread pools, introduces the design of a custom solution using YesThreadLocal and YesRunnable, and then details how Alibaba's TransmittableThreadLocal (TTL) implements context capture, replay, and restoration for seamless asynchronous execution.

ContextPropagationThreadLocalThreadPool
0 likes · 12 min read
Mastering Context Propagation in Thread Pools with TransmittableThreadLocal
Software Development Quality
Software Development Quality
Apr 30, 2024 · Backend Development

How to Thoroughly Test Dubbo Services: A Step‑by‑Step Guide

This guide walks you through preparing a Dubbo test environment, creating mock providers, writing JUnit 5 test cases, configuring consumers, sending requests, validating responses, handling errors, and optionally adding performance testing, monitoring, and CI automation to ensure robust backend services.

DubboMicroservicesjava
0 likes · 5 min read
How to Thoroughly Test Dubbo Services: A Step‑by‑Step Guide
DeWu Technology
DeWu Technology
Apr 29, 2024 · Backend Development

Handling Non-Standard Collection Types in Dubbo RPC with Protostuff Serialization

When Dubbo RPC uses Protostuff serialization, DTO fields declared with ambiguous types that contain non‑standard collections such as subList results can trigger ClassNotFound or null errors during deserialization, so converting these to regular JDK collections (or switching to a more tolerant format like Hessian2/JSON) restores stability.

BackendDubboNon-standard collections
0 likes · 8 min read
Handling Non-Standard Collection Types in Dubbo RPC with Protostuff Serialization
Architecture Digest
Architecture Digest
Apr 29, 2024 · Backend Development

Implementing a FIFO Export Queue in Spring Boot for Large Data Exports

This article explains how to design and implement a fixed-size FIFO export queue in a Spring Boot backend, using synchronized methods, EasyExcel for large data exports, and a test controller to simulate concurrent export requests, while discussing performance considerations and future enhancements.

BackendExport QueueSpring Boot
0 likes · 10 min read
Implementing a FIFO Export Queue in Spring Boot for Large Data Exports
Selected Java Interview Questions
Selected Java Interview Questions
Apr 29, 2024 · Backend Development

Why Spring BeanUtils.copyProperties Is Discouraged and MapStruct Is Preferred for Java Object Mapping

The article explains the limitations of Spring's BeanUtils.copyProperties—such as type mismatches, null overwriting, and reflection overhead—and demonstrates how MapStruct provides a faster, compile‑time generated alternative for copying properties between Java objects, with usage examples and Maven setup.

BeanUtilsObject Mappingjava
0 likes · 6 min read
Why Spring BeanUtils.copyProperties Is Discouraged and MapStruct Is Preferred for Java Object Mapping
DaTaobao Tech
DaTaobao Tech
Apr 29, 2024 · Backend Development

Refactoring Cache Logic with Spring Cache Annotations

The article explains how moving cache operations out of business code and into Spring Cache annotations—@Cacheable, @CachePut, and @CacheEvict—creates a clean, loosely‑coupled design, simplifies maintenance, and enables custom extensions such as breakdown protection and multi‑level caching for high‑concurrency applications.

aopjavaspring
0 likes · 6 min read
Refactoring Cache Logic with Spring Cache Annotations
macrozheng
macrozheng
Apr 29, 2024 · Backend Development

Boost Java Development with MyBatisX: Full Guide to Code Generation and JPA Features

This article introduces MyBatisX, an IDEA plugin that streamlines MyBatis development with navigation, GUI‑based code generation, customizable templates, JPA‑style method hints, and icon settings, providing step‑by‑step instructions and visual examples to enhance backend productivity.

IDEA PluginMyBatisXbackend-development
0 likes · 8 min read
Boost Java Development with MyBatisX: Full Guide to Code Generation and JPA Features
Code Ape Tech Column
Code Ape Tech Column
Apr 29, 2024 · Backend Development

Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With

This article explains several powerful Lombok annotations—including @onX, @Delegate, @Cleanup, @Builder with @Singular, and @With—showing how they simplify Spring‑based Java code through automatic constructor generation, method delegation, resource management, and fluent builders, while also warning against overuse.

Lombokannotationscode-generation
0 likes · 7 min read
Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With
Architect
Architect
Apr 28, 2024 · Backend Development

Understanding Spring's Circular Dependency Resolution with a Three‑Level Cache

This article explains how Spring solves circular dependencies by using a three‑level cache system, walks through the underlying source‑code execution flow, clarifies the purpose of each cache level, and discusses why the design is essential for AOP‑enabled beans.

BeanFactoryThree-level Cacheaop
0 likes · 12 min read
Understanding Spring's Circular Dependency Resolution with a Three‑Level Cache
Architecture Digest
Architecture Digest
Apr 28, 2024 · Backend Development

Understanding FastJSON Serialization: Why isChinaName() Is Invoked and How to Control Serialized Methods

This article analyzes a FastJSON serialization issue where a getter method is unexpectedly called, explains the underlying ASM‑generated serializer mechanism, details which methods FastJSON invokes during serialization, and proposes using @JSONField(serialize = false) to explicitly exclude methods from the serialization process.

ASMJSONFieldbackend-development
0 likes · 8 min read
Understanding FastJSON Serialization: Why isChinaName() Is Invoked and How to Control Serialized Methods
macrozheng
macrozheng
Apr 28, 2024 · Backend Development

How to Seamlessly Replace MyBatis with MyBatis-Plus and Fix LocalDateTime Errors

This article walks through migrating an existing MySQL‑based Java project from MyBatis 3.5.x to MyBatis‑Plus 3.1.1, diagnosing the LocalDateTime conversion exception, upgrading mysql‑connector‑java, handling subsequent null‑pointer issues, and learning from a related file‑validation bug to emphasize thorough testing during component upgrades.

Connector-JavaLocalDateTimeORM
0 likes · 9 min read
How to Seamlessly Replace MyBatis with MyBatis-Plus and Fix LocalDateTime Errors
Architect's Guide
Architect's Guide
Apr 28, 2024 · Backend Development

Kafka Consumer Usage Example and Deep Dive into Offset Management, Rebalance, and Thread Safety

This article presents a Java Kafka consumer example, explains offset semantics (at‑most‑once, at‑least‑once, exactly‑once), details consumer rebalance mechanisms, partition assignment strategies, thread‑safety considerations, and showcases core poll, heartbeat, and auto‑commit implementations with accompanying code snippets.

ConsumerKafkaOffset Management
0 likes · 14 min read
Kafka Consumer Usage Example and Deep Dive into Offset Management, Rebalance, and Thread Safety
Code Ape Tech Column
Code Ape Tech Column
Apr 27, 2024 · Backend Development

Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects

This article examines whether every Service and DAO class in a Spring‑based backend should implement an interface, discusses the three traditional reasons for using interfaces, explains why they often do not hold up, and proposes practical structuring alternatives for single‑ and multi‑implementation scenarios.

InterfaceService Layerdao
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects
Su San Talks Tech
Su San Talks Tech
Apr 27, 2024 · Cloud Native

Master OpenFeign: From Basics to Advanced Configurations in Spring Cloud

This comprehensive tutorial walks you through OpenFeign—its relationship to Feign, environment setup, service provider and consumer creation, various parameter passing methods, timeout handling, logging, HTTP client replacement, GZIP compression, and Sentinel-based circuit breaking—providing practical code examples and configuration snippets for Spring Cloud microservices.

Circuit BreakingMicroservicesOpenFeign
0 likes · 19 min read
Master OpenFeign: From Basics to Advanced Configurations in Spring Cloud
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Apr 27, 2024 · Backend Development

Enabling Multiple @RequestBody Parameters in Spring MVC by Caching the Request Body

This article explains why Spring MVC cannot parse multiple @RequestBody annotations on a single handler method, analyzes the internal I/O stream closure that causes the failure, and provides a practical solution using a request‑body caching wrapper and a servlet filter to allow repeated reads of the request payload.

@RequestBodyBackendHTTP
0 likes · 9 min read
Enabling Multiple @RequestBody Parameters in Spring MVC by Caching the Request Body
Top Architect
Top Architect
Apr 26, 2024 · Backend Development

Netty TCP Client Demo: Architecture Overview, Code Walkthrough, and Testing

This article presents a complete Netty TCP client demo for an IoT project, explaining the project background, architecture, modules, business flow, and detailed Java code—including a local queue, thread pool, client initialization, handler logic, and test controllers—along with deployment notes and source links.

NettySpring BootTCP
0 likes · 22 min read
Netty TCP Client Demo: Architecture Overview, Code Walkthrough, and Testing
Top Architect
Top Architect
Apr 26, 2024 · Backend Development

Comprehensive Guide to Java 8 Stream API with Practical Examples

This article provides an in-depth tutorial on Java 8 Stream API, covering stream creation, intermediate and terminal operations, filtering, mapping, reduction, collection, sorting, grouping, and practical code examples, helping developers master functional programming with streams in Java.

Code ExamplesStream APIfunctional programming
0 likes · 24 min read
Comprehensive Guide to Java 8 Stream API with Practical Examples
Java High-Performance Architecture
Java High-Performance Architecture
Apr 26, 2024 · Backend Development

Mastering Spring Transaction Hooks: Safely Sync Kafka Messages After Commit

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register callbacks that asynchronously send Kafka messages only after a transaction successfully commits, illustrated with a payment‑system case study and complete code examples.

Spring BootTransactionSynchronizationManagerbackend-development
0 likes · 9 min read
Mastering Spring Transaction Hooks: Safely Sync Kafka Messages After Commit
Top Architecture Tech Stack
Top Architecture Tech Stack
Apr 26, 2024 · Backend Development

Visualizing and Optimizing Java Inheritance Diagrams in IntelliJ IDEA

This guide explains how to use IntelliJ IDEA’s diagram feature to view, clean up, and explore inheritance and interface relationships of Java classes such as Servlets, including removing unwanted nodes, inspecting members, adjusting visibility, zooming, adding classes, and jumping to source code.

Inheritance DiagramIntelliJ IDEAServlet
0 likes · 6 min read
Visualizing and Optimizing Java Inheritance Diagrams in IntelliJ IDEA
Code Ape Tech Column
Code Ape Tech Column
Apr 26, 2024 · Backend Development

JDFrame/SDFrame: A JVM‑Level DataFrame‑Like Stream API for Java

This article introduces JDFrame/SDFrame, a Java library that provides a DataFrame‑style, semantic API for stream processing, covering quick start, dependency setup, comprehensive examples of filtering, aggregation, grouping, sorting, joining, and utility functions, along with code snippets and usage guidance.

BackendJDFrameSDFrame
0 likes · 16 min read
JDFrame/SDFrame: A JVM‑Level DataFrame‑Like Stream API for Java
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 26, 2024 · Backend Development

Mastering RSocket with Spring Boot 2.7: Protocol Basics, Interaction Patterns, and Real‑World Code

This article introduces the RSocket binary protocol, explains its four interaction models, highlights key features such as back‑pressure and lease, and provides step‑by‑step Spring Boot 2.7 examples for Request‑Response, Request‑Stream, Channel, and Fire‑and‑Forget communication.

MicroservicesSpring Bootjava
0 likes · 11 min read
Mastering RSocket with Spring Boot 2.7: Protocol Basics, Interaction Patterns, and Real‑World Code
FunTester
FunTester
Apr 26, 2024 · Fundamentals

Mastering Java 14 Records: Compact Constructors, Limitations, and Practical Examples

This article explains Java 14’s preview feature records, showing how they replace verbose classes with concise data carriers, detailing automatically generated members, compact constructors for validation, inherent limitations, and new reflection methods, all illustrated with clear code examples.

CompactConstructorJDK14dataclass
0 likes · 5 min read
Mastering Java 14 Records: Compact Constructors, Limitations, and Practical Examples
Architect
Architect
Apr 25, 2024 · Backend Development

Design and Implementation of an Elasticsearch Data Synchronization Service (ECP)

This article describes the challenges of synchronizing billions of order records to Elasticsearch and presents the design, architecture, and key technical details of a generic data‑sync service (ECP) that supports multiple data sources, dynamic rate limiting, retry strategies, SPI‑based extensibility, environment isolation, health‑check, fault recovery, smooth migration, and elegant logging.

Dynamic Rate LimitingElasticsearchbackend-development
0 likes · 22 min read
Design and Implementation of an Elasticsearch Data Synchronization Service (ECP)
Kuaishou Tech
Kuaishou Tech
Apr 25, 2024 · Backend Development

Engineering Architecture Governance: Jar Package Management, IDEA Performance, and Maven Dependency Optimization at Kuaishou

This article details Kuaishou's engineering architecture governance process, covering project background, IDEA performance bottlenecks, cloud‑based IDE solutions, MavenHelper and custom Maven plugins for dependency analysis, handling NoClassDefFoundError issues, and static‑dynamic class dependency detection to improve backend build efficiency.

IDEAarchitecture governancedependency management
0 likes · 13 min read
Engineering Architecture Governance: Jar Package Management, IDEA Performance, and Maven Dependency Optimization at Kuaishou
macrozheng
macrozheng
Apr 25, 2024 · Backend Development

How to Upgrade the Mall Project to Spring Boot 3 & JDK 17 – Complete Guide

This article walks through upgrading the open‑source Mall e‑commerce system to Spring Boot 3 and JDK 17, covering dependency version updates, migration from SpringFox to SpringDoc, new Spring Data Elasticsearch usage, revised Spring Security configuration, Docker deployment tips, and essential code changes.

ElasticsearchSpringDocbackend-development
0 likes · 19 min read
How to Upgrade the Mall Project to Spring Boot 3 & JDK 17 – Complete Guide
Cognitive Technology Team
Cognitive Technology Team
Apr 25, 2024 · Backend Development

Alibaba Java Interview: Does annotating the same Spring Boot service method with @Transactional and @Async cause transaction failure?

In Spring Boot, using @Transactional and @Async on the same service method does not invalidate the transaction, but the asynchronous execution runs in a separate thread with its own transaction, isolated from the original thread's transaction due to AOP interceptor ordering.

AsyncSpring Bootaop
0 likes · 1 min read
Alibaba Java Interview: Does annotating the same Spring Boot service method with @Transactional and @Async cause transaction failure?
JD Tech
JD Tech
Apr 25, 2024 · Backend Development

Comprehensive API Performance Optimization: Diagnosis, Problem Localization, and Solutions with Pfinder and JSF Asynchronous Calls

This article details a comprehensive API performance optimization journey, covering current diagnostics with Pfinder and UMP, pinpointing bottlenecks such as excessive RPC loops and large data sets, and presenting solutions like Set-based deduplication, JSF asynchronous calls, and code refactoring that reduce latency from seconds to milliseconds.

APIAsynchronousJSF
0 likes · 7 min read
Comprehensive API Performance Optimization: Diagnosis, Problem Localization, and Solutions with Pfinder and JSF Asynchronous Calls
IT Services Circle
IT Services Circle
Apr 25, 2024 · Backend Development

How Redisson Implements Distributed Locks Using Redis

This article explains how Redisson leverages Redis to implement distributed locks, detailing the underlying Lua scripts, lock acquisition and release processes, the watch‑dog mechanism for automatic lease renewal, and provides Java code examples for integrating and testing the lock functionality.

DistributedLockLuaWatchdog
0 likes · 19 min read
How Redisson Implements Distributed Locks Using Redis
vivo Internet Technology
vivo Internet Technology
Apr 24, 2024 · Big Data

Analysis and Resolution of a FileSystem‑Induced Memory Leak Causing OOM in Production

The article details how repeatedly calling FileSystem.get(uri, conf, user) created distinct UserGroupInformation objects, inflating the static FileSystem cache and causing a heap‑memory leak that triggered an Out‑Of‑Memory error, and explains that using the two‑argument get method or explicitly closing instances resolves the issue.

HadoopOutOfMemoryPerformance debugging
0 likes · 13 min read
Analysis and Resolution of a FileSystem‑Induced Memory Leak Causing OOM in Production
The Dominant Programmer
The Dominant Programmer
Apr 24, 2024 · Backend Development

How to Build a JSON DSL in Spring Boot with Jayway JsonPath

This tutorial demonstrates adding JsonPath to a Spring Boot project, using DSL‑style expressions to extract authors, titles, counts and filtered data from a sample JSON payload, and shows how to drive the extraction dynamically via configurable mappings with fastjson and hutool.

DSLJsonPathSpring Boot
0 likes · 7 min read
How to Build a JSON DSL in Spring Boot with Jayway JsonPath
Top Architect
Top Architect
Apr 24, 2024 · Backend Development

Improving Spring Boot Code Quality with Java Reflection

This article demonstrates how to use Java reflection in Spring Boot projects to automatically enforce naming conventions and coding standards, thereby enhancing code quality, maintainability, and scalability while providing practical demo steps and code examples.

ReflectionSpring Bootbackend-development
0 likes · 11 min read
Improving Spring Boot Code Quality with Java Reflection
Architect's Journey
Architect's Journey
Apr 24, 2024 · Databases

A Graceful Approach to Multi‑Table Queries: Embrace Aggregation, Avoid Stitching

The article compares redundant and normalized storage, explains their trade‑offs, and introduces an in‑memory aggregation technique implemented via a repository "fill" method in Java, showing how to replace costly SQL joins with flexible, code‑driven data merging while preserving consistency and performance.

Database designDenormalizationIn-Memory Join
0 likes · 11 min read
A Graceful Approach to Multi‑Table Queries: Embrace Aggregation, Avoid Stitching
Su San Talks Tech
Su San Talks Tech
Apr 24, 2024 · Backend Development

Master Spring’s Core Features: Resource Management, Environment, Type Conversion and More

This article provides a comprehensive guide to Spring’s essential infrastructure, covering Java and Spring resource management, environment property handling, type conversion APIs, data binding mechanisms, generic type inspection with ResolvableType, internationalization support, the BeanFactory and ApplicationContext architecture, and the built‑in event system, all illustrated with code examples and diagrams.

EnvironmentResource Managementapplicationcontext
0 likes · 39 min read
Master Spring’s Core Features: Resource Management, Environment, Type Conversion and More
Architect
Architect
Apr 23, 2024 · Backend Development

Cross-Thread Log Sampling for High-Throughput Java Services

This article examines the performance impact of excessive logging in high-throughput Java services and presents three practical approaches—ThreadLocal-style wrappers, explicit flag propagation, and a decoupled component with an extensible API—to achieve cross-thread request-level log sampling while preserving traceability.

AsynchronousBackendThreadLocal
0 likes · 9 min read
Cross-Thread Log Sampling for High-Throughput Java Services
The Dominant Programmer
The Dominant Programmer
Apr 23, 2024 · Fundamentals

How to Write, Convert, and Read WKB Data with JTS in Java

This article explains the WKB binary format, its storage advantages in MySQL and PostgreSQL, and provides step‑by‑step Java code using JTS's GeometryFactory, WKBWriter, and WKBReader to write a Point to WKB, convert it to a hex string, and read it back into a geometry object.

GeometryJTSSpatial Data
0 likes · 3 min read
How to Write, Convert, and Read WKB Data with JTS in Java
The Dominant Programmer
The Dominant Programmer
Apr 23, 2024 · Backend Development

Implementing Asynchronous Multithreaded Tasks in SpringBoot with Singleton and ScheduledExecutorService

This article walks through how to use the Singleton pattern together with SpringBoot's ScheduledExecutorService to build a reusable asynchronous task manager, recreate Ruoyi's login‑log recording logic, and verify the non‑blocking behavior with a concrete test case.

AsyncManagerAsyncTaskFactoryScheduledExecutorService
0 likes · 7 min read
Implementing Asynchronous Multithreaded Tasks in SpringBoot with Singleton and ScheduledExecutorService
Architecture Digest
Architecture Digest
Apr 23, 2024 · Backend Development

14 Practical Code Optimization Tips for Java Backend Development

This article presents fourteen actionable Java backend code‑optimization techniques—including configuration‑file management, Lombok’s @RequiredArgsConstructor, modularization, exception handling, database query reduction, null‑avoidance, strategic use of design patterns, IDE shortcuts, and efficient collection handling—to help developers write cleaner, more maintainable, and higher‑performance code.

BackendCode OptimizationLombok
0 likes · 7 min read
14 Practical Code Optimization Tips for Java Backend Development
IT Services Circle
IT Services Circle
Apr 23, 2024 · Fundamentals

30+ IntelliJ IDEA Debugging Tips and Tricks to Boost Your Efficiency

This article presents a comprehensive collection of over thirty IntelliJ IDEA debugging features, shortcuts, and advanced techniques—including breakpoint types, conditional breakpoints, remote debugging, and code evaluation—to help Java developers dramatically improve their debugging workflow and productivity.

IDE TipsIntelliJ IDEAbreakpoint
0 likes · 15 min read
30+ IntelliJ IDEA Debugging Tips and Tricks to Boost Your Efficiency
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 23, 2024 · Backend Development

Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies

This article explains the distinct roles of Spring's @Configuration and @Component annotations, demonstrates their behavior through code examples, compares bean initialization and proxy generation, and reveals how Spring's ConfigurationClassPostProcessor and related enhancers ensure singleton beans across method calls.

ComponentConfigurationannotations
0 likes · 9 min read
Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies
Architecture Digest
Architecture Digest
Apr 22, 2024 · Backend Development

Migrating from MyBatis to MyBatis-Plus: Resolving LocalDateTime Conversion Errors and Lessons Learned

This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, demonstrates the LocalDateTime conversion error caused by MySQL‑connector‑java version incompatibility, shows how upgrading the driver resolves the issue, and shares a cautionary tale about unintended bugs after component upgrades.

LocalDateTimeMyBatisMyBatis-Plus
0 likes · 15 min read
Migrating from MyBatis to MyBatis-Plus: Resolving LocalDateTime Conversion Errors and Lessons Learned
Su San Talks Tech
Su San Talks Tech
Apr 22, 2024 · Fundamentals

Why Java’s Object Graph Traversal Pauses: Tri‑Color Marking & STW Solutions

This article explains the two‑phase reachability analysis in Java garbage collection, detailing why the object‑graph traversal stage incurs stop‑the‑world pauses, how the tri‑color marking model reveals issues like floating garbage and object disappearance, and describes incremental update and snapshot‑at‑the‑beginning techniques that avoid STW.

Garbage CollectionSATBSTW
0 likes · 14 min read
Why Java’s Object Graph Traversal Pauses: Tri‑Color Marking & STW Solutions
Java Tech Enthusiast
Java Tech Enthusiast
Apr 21, 2024 · Fundamentals

Decoding Binary UTF-8 Signage in a Public Restroom Using Java

The article explains how a binary message on a multilingual public‑restroom sign was decoded by identifying UTF‑8 byte patterns, extracting the first 24 bits to reveal the Chinese character “向”, and providing a Java program that parses the entire bit string into readable Chinese text.

UTF-8Unicodebinary encoding
0 likes · 4 min read
Decoding Binary UTF-8 Signage in a Public Restroom Using Java
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 19, 2024 · Backend Development

SpringBoot Extension Interfaces: BeanPostProcessor, BeanFactoryPostProcessor

This article introduces the key SpringBoot extension interfaces—including BeanPostProcessor, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, SmartInstantiationAwareBeanPostProcessor, SmartInitializingSingleton, ApplicationContextInitializer, EnvironmentPostProcessor, and the *Runner interfaces—explaining their purposes, usage patterns, and providing concrete code examples to help developers customize and extend SpringBoot applications effectively.

BeanPostProcessorExtension InterfacesSpringBoot
0 likes · 10 min read
SpringBoot Extension Interfaces: BeanPostProcessor, BeanFactoryPostProcessor
21CTO
21CTO
Apr 18, 2024 · Information Security

Why 90% of Java Services Harbor Critical Vulnerabilities – Datadog 2024 Report

Datadog’s 2024 DevSecOps report reveals that 90% of Java services contain at least one severe vulnerability—far higher than other languages—largely due to indirect dependencies, and stresses the need for comprehensive dependency scanning, prioritized remediation, and robust alert triage to manage the flood of low‑impact automated attacks.

Dependency ScanningDevSecOpsInformation Security
0 likes · 5 min read
Why 90% of Java Services Harbor Critical Vulnerabilities – Datadog 2024 Report
Java Interview Crash Guide
Java Interview Crash Guide
Apr 18, 2024 · Backend Development

14 Practical Java Code‑Optimization Tips for Cleaner, More Maintainable Code

This article presents fourteen actionable Java coding‑style and architecture tips—ranging from using configuration properties and Lombok constructors to modularizing methods, throwing exceptions, reducing DB calls, avoiding null returns, and leveraging IDE suggestions—to help developers write cleaner, more robust backend code.

Code OptimizationDesign PatternsIDEA
0 likes · 9 min read
14 Practical Java Code‑Optimization Tips for Cleaner, More Maintainable Code
Code Ape Tech Column
Code Ape Tech Column
Apr 18, 2024 · Backend Development

Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously after transaction commit, illustrated with a payment‑system logging scenario and complete Java code examples.

AsynchronousBackendKafka
0 likes · 10 min read
Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing
Sohu Tech Products
Sohu Tech Products
Apr 17, 2024 · Operations

Developing an OpenTelemetry Extension for Pulsar Java Client Metrics

The article walks through building a custom OpenTelemetry Java‑agent extension for Pulsar client metrics—migrating from SkyWalking, setting up a Gradle project, using ByteBuddy to instrument methods with advice, registering gauge metrics, packaging the jar, handling common class‑loader pitfalls, and configuring deployment via the OpenTelemetry operator.

ExtensionInstrumentationJavaAgent
0 likes · 14 min read
Developing an OpenTelemetry Extension for Pulsar Java Client Metrics
Architect's Tech Stack
Architect's Tech Stack
Apr 16, 2024 · Backend Development

Should the Service Layer Use Interfaces? A Critical Discussion

This article examines whether a Service layer in Java Spring projects truly requires interfaces, debunking common arguments, exploring development workflows without interfaces, discussing project structuring for single and multiple implementations, and concluding when interfaces are beneficial or unnecessary.

InterfaceService Layerarchitecture
0 likes · 7 min read
Should the Service Layer Use Interfaces? A Critical Discussion
macrozheng
macrozheng
Apr 16, 2024 · Backend Development

Boost Java Backend Development with DDD, CQRS, and Automated Maven Archetype Generation

This article explains how to lower the learning curve of DDD and CQRS by using structured, standardized, and templated approaches, introduces a Maven archetype for rapid project scaffolding, and demonstrates an IntelliJ IDEA plugin that auto‑generates boilerplate code for aggregate roots, commands, queries, and related components.

CQRSDDDSpringBoot
0 likes · 16 min read
Boost Java Backend Development with DDD, CQRS, and Automated Maven Archetype Generation
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 16, 2024 · Backend Development

Speed Up Spring Startup with Parallel Bean Initialization

This article introduces Spring 6.2’s Parallel Bean Initialization feature, explains its benefits for reducing startup time, provides step‑by‑step code examples for configuring background bean initialization and a bootstrap executor, compares traditional and concurrent initialization timings, and details the underlying implementation in the Spring container.

Parallel Bean Initializationbackend-developmentconcurrency
0 likes · 7 min read
Speed Up Spring Startup with Parallel Bean Initialization
Top Architect
Top Architect
Apr 15, 2024 · Backend Development

Implementing Data Masking in SQL, Java, and MyBatis‑Mate Sensitive Jackson

This article demonstrates how to mask sensitive data such as phone numbers, ID cards, and personal information using SQL string functions, a Java library (sensitive‑plus), and the MyBatis‑Mate Sensitive Jackson plugin, providing complete code examples, configuration files, and test results for backend developers.

MyBatisbackend-developmentdata masking
0 likes · 11 min read
Implementing Data Masking in SQL, Java, and MyBatis‑Mate Sensitive Jackson
JD Tech
JD Tech
Apr 15, 2024 · Backend Development

How Java Thread Pools Handle Exceptions: execute vs submit

This article investigates how Java's java.util.concurrent.ExecutorService thread pools react to exceptions when tasks are submitted via execute versus submit, providing source‑code experiments, observed outcomes, and a detailed analysis of the underlying JDK implementation.

ExecutorServiceThreadPoolconcurrency
0 likes · 8 min read
How Java Thread Pools Handle Exceptions: execute vs submit
FunTester
FunTester
Apr 15, 2024 · Fundamentals

Using JMH to Benchmark GUID Generation Strategies in Java

This article introduces JMH, explains its key features, and presents microbenchmark results comparing thread‑exclusive, thread‑shared, Snowflake, UUID, and Snowflake‑algorithm GUID generation methods under various thread counts, accompanied by the full Java test code.

BenchmarkingGUIDJMH
0 likes · 8 min read
Using JMH to Benchmark GUID Generation Strategies in Java
Architect
Architect
Apr 14, 2024 · Backend Development

How to Dynamically Load and Unload Java Governance Tasks with Custom ClassLoaders and XXL‑Job

This article explains how to design a plug‑in architecture for a data‑governance service that can start, stop, add, or upgrade individual tasks at runtime without restarting the whole service, using a custom URLClassLoader, Spring bean registration, XXL‑Job integration, dynamic configuration updates, and a clean unload process.

Dynamic LoadingMicroservicesNacos
0 likes · 26 min read
How to Dynamically Load and Unload Java Governance Tasks with Custom ClassLoaders and XXL‑Job
Architecture Digest
Architecture Digest
Apr 14, 2024 · Backend Development

Optimizing Nested Loops in Java: From O(N²) to O(N) Using HashMap

This article demonstrates how to replace a costly double‑for‑loop that matches two large lists of users with a HashMap lookup, showing performance measurements, the effect of adding a break statement, and detailed Java code examples for backend developers.

HashMapalgorithmbackend-development
0 likes · 7 min read
Optimizing Nested Loops in Java: From O(N²) to O(N) Using HashMap
IT Services Circle
IT Services Circle
Apr 13, 2024 · Fundamentals

Java Interview Questions: Collections, HashMap, Concurrency, JVM Memory, GC, References, and Redis

This article compiles a set of Java interview questions covering the differences between ArrayList and LinkedList, the internal workings and resizing of HashMap, concurrency primitives like synchronized and ReentrantLock, JVM memory layout, garbage‑collection algorithms, reference types, and Redis persistence and distributed‑lock mechanisms.

HashMapJVMconcurrency
0 likes · 21 min read
Java Interview Questions: Collections, HashMap, Concurrency, JVM Memory, GC, References, and Redis
Code Ape Tech Column
Code Ape Tech Column
Apr 13, 2024 · Backend Development

Integrating MybatisX Plugin with Spring Boot for Rapid MyBatis Development

This tutorial walks through setting up a simple Spring Boot project, adding MyBatis‑Plus dependencies, configuring MybatisX in IntelliJ IDEA, generating entity, mapper, service, and controller code, and handling common connection issues, providing a complete end‑to‑end example of rapid MyBatis development.

IDEA PluginMyBatisXSpring Boot
0 likes · 6 min read
Integrating MybatisX Plugin with Spring Boot for Rapid MyBatis Development
The Dominant Programmer
The Dominant Programmer
Apr 13, 2024 · Backend Development

Integrating LiteFlow with Spring Boot for Decoupled, Dynamic, Scalable Business Logic

This guide shows how to integrate the lightweight LiteFlow rule engine into a Spring Boot application, split complex business logic into reusable components, configure rule files, and use various component types—including switch, condition, and parameterized components—to achieve dynamic orchestration, hot‑reloading, and high scalability.

Component OrchestrationDynamic WorkflowLiteFlow
0 likes · 13 min read
Integrating LiteFlow with Spring Boot for Decoupled, Dynamic, Scalable Business Logic