BestHub
Sign in
Tagged articles
5000 articles
Page 42 of 50
JD Retail Technology
JD Retail Technology
Mar 22, 2024 · Backend Development

Analysis of JD's Middle‑Platform Evolution and the Underlying Matrix Technical Framework

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.

Hot DeploymentPaaSclassloader
0 likes · 32 min read
Analysis of JD's Middle‑Platform Evolution and the Underlying Matrix Technical Framework
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 22, 2024 · Backend Development

Comprehensive Guide to Bloom Filters: Principles, Implementations, and Business Applications

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.

Guavabloom-filterjava
0 likes · 28 min read
Comprehensive Guide to Bloom Filters: Principles, Implementations, and Business Applications
DaTaobao Tech
DaTaobao Tech
Mar 22, 2024 · Backend Development

Understanding JVM Memory, GC, and Performance Tuning

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.

GarbageCollectionJVMMemoryManagement
0 likes · 33 min read
Understanding JVM Memory, GC, and Performance Tuning
Architect's Guide
Architect's Guide
Mar 22, 2024 · Backend Development

Understanding ForkJoinPool: Principles, Implementation, and Performance Evaluation in Java

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.

DivideAndConquerForkJoinPoolParallelism
0 likes · 22 min read
Understanding ForkJoinPool: Principles, Implementation, and Performance Evaluation in Java
Java Architect Essentials
Java Architect Essentials
Mar 21, 2024 · Backend Development

Implementing Fast File Upload: Instant Transfer, Chunked Upload, and Resume Support in Java

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.

Backendchunked uploadfile upload
0 likes · 14 min read
Implementing Fast File Upload: Instant Transfer, Chunked Upload, and Resume Support in Java
Architecture Digest
Architecture Digest
Mar 21, 2024 · Fundamentals

Overview of New Features and Enhancements in JDK 22

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.

JDK 22JEPjava
0 likes · 9 min read
Overview of New Features and Enhancements in JDK 22
Huolala Tech
Huolala Tech
Mar 21, 2024 · Backend Development

How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It

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.

KMS clientbackend debuggingconcurrency
0 likes · 16 min read
How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It
JD Cloud Developers
JD Cloud Developers
Mar 21, 2024 · Backend Development

Why BeanUtils.copyProperties Causes ClassCastException and How to Fix It

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.

BeanUtilsClassCastExceptionCopyProperties
0 likes · 4 min read
Why BeanUtils.copyProperties Causes ClassCastException and How to Fix It
21CTO
21CTO
Mar 20, 2024 · Backend Development

Why Oracle Urges Java Developers to Skip macOS Sonoma 14.4 Update

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.

Apple SiliconIDEJetBrains
0 likes · 5 min read
Why Oracle Urges Java Developers to Skip macOS Sonoma 14.4 Update
Architect
Architect
Mar 20, 2024 · Information Security

RBAC Permission Analysis and Spring Security JWT Integration Tutorial

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.

JWTPassword EncryptionRBAC
0 likes · 18 min read
RBAC Permission Analysis and Spring Security JWT Integration Tutorial
JD Retail Technology
JD Retail Technology
Mar 20, 2024 · Backend Development

Multithreaded Pagination Query with Java ThreadPoolExecutor: Principles, Parameters, and Usage

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.

BackendThreadPooljava
0 likes · 6 min read
Multithreaded Pagination Query with Java ThreadPoolExecutor: Principles, Parameters, and Usage
DaTaobao Tech
DaTaobao Tech
Mar 20, 2024 · Backend Development

Understanding Java Stream Gather API and the mapConcurrent Operator

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.

Gather APIStream APIVirtual Threads
0 likes · 14 min read
Understanding Java Stream Gather API and the mapConcurrent Operator
FunTester
FunTester
Mar 20, 2024 · Fundamentals

Java vs Go Generics: Syntax, Constraints, and Practical Differences

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.

ComparisonGenericsGo
0 likes · 10 min read
Java vs Go Generics: Syntax, Constraints, and Practical Differences
Code Ape Tech Column
Code Ape Tech Column
Mar 19, 2024 · Backend Development

Comprehensive Guide to Alibaba Sentinel: Installation, Configuration, Flow Control, Degrade Rules, Hot Parameter Limiting, System Adaptive Limits, Persistence, Cluster Flow Control, and Integration

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.

CircuitBreakerFlowControlMicroservices
0 likes · 36 min read
Comprehensive Guide to Alibaba Sentinel: Installation, Configuration, Flow Control, Degrade Rules, Hot Parameter Limiting, System Adaptive Limits, Persistence, Cluster Flow Control, and Integration
Java Backend Technology
Java Backend Technology
Mar 19, 2024 · Backend Development

6 Common Java OOM Scenarios and How to Prevent Them

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.

HeapJVMMetaspace
0 likes · 9 min read
6 Common Java OOM Scenarios and How to Prevent Them
Su San Talks Tech
Su San Talks Tech
Mar 19, 2024 · Backend Development

Cut Page Load Time from 5 s to <1 s: Java IO, NIO, mmap & Zero‑Copy Tricks

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.

IO performancebuffered streamsjava
0 likes · 17 min read
Cut Page Load Time from 5 s to <1 s: Java IO, NIO, mmap & Zero‑Copy Tricks
Architecture Digest
Architecture Digest
Mar 18, 2024 · Backend Development

Creating a Simple HTTP Service with Spring 6 HTTP Interface

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.

BackendHTTP InterfaceSpring Boot
0 likes · 6 min read
Creating a Simple HTTP Service with Spring 6 HTTP Interface
Code Ape Tech Column
Code Ape Tech Column
Mar 18, 2024 · Backend Development

Implementing File Upload and Text Extraction with Elasticsearch Ingest Attachment Plugin in Spring Boot

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.

ElasticsearchIngest AttachmentSpring Boot
0 likes · 21 min read
Implementing File Upload and Text Extraction with Elasticsearch Ingest Attachment Plugin in Spring Boot
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 18, 2024 · Fundamentals

Understanding Java Annotations: Definition, Essence, Details, and Parsing SOURCE‑Retention Annotations

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.

Annotation ProcessingBackendMeta-annotations
0 likes · 12 min read
Understanding Java Annotations: Definition, Essence, Details, and Parsing SOURCE‑Retention Annotations
Su San Talks Tech
Su San Talks Tech
Mar 18, 2024 · Backend Development

6 Common Java OOM Scenarios and How to Prevent Them

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.

JVMMemory ManagementOutOfMemoryError
0 likes · 8 min read
6 Common Java OOM Scenarios and How to Prevent Them
FunTester
FunTester
Mar 18, 2024 · Backend Development

Implementing Dynamic Rate Limiting with Caffeine Cache in Java

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.

BackendCaffeine Cachejava
0 likes · 6 min read
Implementing Dynamic Rate Limiting with Caffeine Cache in Java
IT Services Circle
IT Services Circle
Mar 17, 2024 · Backend Development

Understanding the volatile Keyword in Java Concurrency

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.

CASatomicjava
0 likes · 6 min read
Understanding the volatile Keyword in Java Concurrency
Java Tech Enthusiast
Java Tech Enthusiast
Mar 16, 2024 · Backend Development

Common Causes of 100% CPU Usage in Java Backend Services

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.

CPUKafkajava
0 likes · 8 min read
Common Causes of 100% CPU Usage in Java Backend Services
Programmer DD
Programmer DD
Mar 16, 2024 · Backend Development

How to Build Your Own Spring Boot Starter: Step‑by‑Step Guide

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.

Spring BootStarterauto-configuration
0 likes · 7 min read
How to Build Your Own Spring Boot Starter: Step‑by‑Step Guide
DaTaobao Tech
DaTaobao Tech
Mar 15, 2024 · Backend Development

Common Java Development Pitfalls and Solutions

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.

best practicesbugjava
0 likes · 18 min read
Common Java Development Pitfalls and Solutions
Architect's Guide
Architect's Guide
Mar 15, 2024 · Backend Development

Implementing Dynamic Data Source Switching in Spring Boot with ThreadLocal and AbstractRoutingDataSource

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.

DynamicDataSourceSpringBootThreadLocal
0 likes · 16 min read
Implementing Dynamic Data Source Switching in Spring Boot with ThreadLocal and AbstractRoutingDataSource
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 15, 2024 · Backend Development

How to Dynamically Adjust Thread Pool Size with Nacos in Java

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.

Dynamic ConfigurationNacosbackend-development
0 likes · 7 min read
How to Dynamically Adjust Thread Pool Size with Nacos in Java
Java Architect Essentials
Java Architect Essentials
Mar 14, 2024 · Backend Development

Understanding MyBatis Dynamic SQL and Tag Usage

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.

Dynamic SQLMyBatisORM
0 likes · 15 min read
Understanding MyBatis Dynamic SQL and Tag Usage
Architect's Tech Stack
Architect's Tech Stack
Mar 14, 2024 · Backend Development

Spring 6 HTTP Interface Demo: Defining and Invoking HTTP Services with Java Interfaces

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.

HTTP Interfacebackend-developmentjava
0 likes · 7 min read
Spring 6 HTTP Interface Demo: Defining and Invoking HTTP Services with Java Interfaces
Java Captain
Java Captain
Mar 14, 2024 · Fundamentals

Why and How to Upgrade from JDK 8 to JDK 19: Benefits, Considerations, and New Features

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.

JDKNewFeaturesjava
0 likes · 6 min read
Why and How to Upgrade from JDK 8 to JDK 19: Benefits, Considerations, and New Features
Java Captain
Java Captain
Mar 14, 2024 · Backend Development

Comprehensive Guide to MyBatis Dynamic SQL and XML Mapping Tags

This article explains MyBatis dynamic SQL concepts, details the nine dynamic tags (if, where, set, choose, trim, foreach, sql, include, association), provides complete XML mapper examples with code snippets, and demonstrates one‑to‑many, many‑to‑one, and many‑to‑many association queries for Java backend development.

Dynamic SQLMyBatisORM
0 likes · 16 min read
Comprehensive Guide to MyBatis Dynamic SQL and XML Mapping Tags
JD Tech
JD Tech
Mar 14, 2024 · Databases

JD ElasticSearch Supports ZSTD Compression: Implementation, Performance Evaluation, and Usage Guide

This article explains how JD ElasticSearch has integrated the high‑performance ZSTD compression algorithm, details the motivations behind its adoption, presents benchmark results comparing it with LZ4 and best_compression, and provides step‑by‑step instructions and code snippets for configuring and using the new jd_zstd codec in Elasticsearch.

Elasticsearchcompressionjava
0 likes · 14 min read
JD ElasticSearch Supports ZSTD Compression: Implementation, Performance Evaluation, and Usage Guide
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 13, 2024 · Backend Development

Remote Hot Deployment (Mark42/Jarvis): Design, Implementation, and Practice

This article introduces the design and implementation of a remote hot‑deployment component (Mark42/Jarvis) built on Java Agent and an IDEA plugin, analyzes the challenges of dynamic compilation in Spring‑Boot fat‑jar environments, presents solution choices, and shares practical experiences and future directions.

Dynamic CompilationHot DeploymentJava Agent
0 likes · 16 min read
Remote Hot Deployment (Mark42/Jarvis): Design, Implementation, and Practice
Top Architect
Top Architect
Mar 13, 2024 · Backend Development

Integrating Tess4J OCR into a Spring Boot Backend Service

This tutorial walks through setting up a Spring Boot backend, adding the Tess4J OCR library, creating a service and REST controller to recognize text from both local files and remote image URLs, and provides testing steps and deployment tips.

OCRREST APISpring Boot
0 likes · 8 min read
Integrating Tess4J OCR into a Spring Boot Backend Service
Architecture Digest
Architecture Digest
Mar 13, 2024 · Backend Development

Using LMAX Disruptor as a High‑Performance In‑Memory Message Queue in Java

This article introduces the LMAX Disruptor library, explains its core concepts such as RingBuffer, Sequencer and WaitStrategy, and provides a step‑by‑step Java demo—including Maven dependency, model, event factory, handler, manager, service and test code—to build a fast, lock‑free producer‑consumer queue.

DisruptorMessage Queuebackend-development
0 likes · 10 min read
Using LMAX Disruptor as a High‑Performance In‑Memory Message Queue in Java
Su San Talks Tech
Su San Talks Tech
Mar 13, 2024 · Backend Development

Boost Java Productivity: 10 Must‑Have IntelliJ Plugins

Discover ten IntelliJ plugins—including POJO‑to‑JSON, Cool Request, CamelCase, any‑rule, Grep Console, GenerateO2O, Smart Input, Squaretest, TONGYI Lingma, and Auto‑Filling Java Call Arguments—that streamline Java development, automate repetitive tasks, and enhance code quality for backend engineers.

IDE pluginsIntelliJjava
0 likes · 7 min read
Boost Java Productivity: 10 Must‑Have IntelliJ Plugins
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 13, 2024 · Backend Development

Mastering Spring Boot Event Handling and Asynchronous Processing

Learn how Spring Boot 2.7.16 leverages ApplicationEvent and ApplicationListener for synchronous event handling, then explore two asynchronous approaches—using @Async with @EventListener and custom thread pools with a bespoke ApplicationEventMulticaster—complete with code examples and configuration details.

ApplicationListenerAsynchronousSpring Boot
0 likes · 5 min read
Mastering Spring Boot Event Handling and Asynchronous Processing
IT Services Circle
IT Services Circle
Mar 12, 2024 · Fundamentals

LRU Cache Design and Java Implementation with O(1) Operations

This article explains the LeetCode LRU Cache problem, detailing the required class interface, operational constraints, and provides a thorough Java solution using a HashMap combined with a doubly linked list to achieve O(1) time complexity for get and put operations.

Data StructuresDoubly Linked ListHashMap
0 likes · 10 min read
LRU Cache Design and Java Implementation with O(1) Operations
Su San Talks Tech
Su San Talks Tech
Mar 12, 2024 · Backend Development

Why Is RocketMQ So Fast? 10 Core Techniques Explained

This article explores the ten key architectural and implementation techniques—such as batch messaging, compression, Netty networking, zero‑copy I/O, sequential writes, efficient storage structures, asynchronous processing, batch handling, lock optimizations, and thread‑pool isolation—that together make RocketMQ a high‑performance message middleware.

NettyRocketMQZero Copy
0 likes · 21 min read
Why Is RocketMQ So Fast? 10 Core Techniques Explained
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 12, 2024 · Backend Development

Master Spring’s Essential Utility Classes: From Resources to AOP

This article provides a comprehensive guide to Spring 5.3.30 utility classes, covering resource handling, object and array utilities, number conversion, stream operations, system property resolution, collection helpers, AOP proxy tools, BeanFactory shortcuts, annotation processing, bean manipulation, validation, XML/HTML parsing, web utilities, and URI handling, all illustrated with clear code examples.

Code ExamplesUtility Classesbackend-development
0 likes · 9 min read
Master Spring’s Essential Utility Classes: From Resources to AOP
Java Architect Essentials
Java Architect Essentials
Mar 11, 2024 · Backend Development

Designing a Bounded FIFO Export Queue for Large MySQL Data Exports in Java Spring

To prevent performance degradation during large MySQL data exports, this article presents a Java Spring implementation of a bounded FIFO export queue, detailing the ExportQueue class, abstract export handling with EasyExcel, concrete service and controller code, and test results demonstrating queue limits and concurrency considerations.

ExportQueueconcurrency
0 likes · 11 min read
Designing a Bounded FIFO Export Queue for Large MySQL Data Exports in Java Spring
Java Tech Enthusiast
Java Tech Enthusiast
Mar 11, 2024 · Backend Development

How to Prevent Cache Penetration, Breakdown, and Avalanche in Redis

The article explains the concepts of cache penetration, cache breakdown, and cache avalanche, illustrates why they cause massive database load, and provides practical mitigation techniques such as parameter validation, storing null placeholders, Bloom filters, rate limiting, hot‑key pre‑warming, distributed locking, and cache pre‑warming strategies, with Java code examples.

Cachebloom-filtercache-avalanche
0 likes · 10 min read
How to Prevent Cache Penetration, Breakdown, and Avalanche in Redis
Java High-Performance Architecture
Java High-Performance Architecture
Mar 11, 2024 · Backend Development

Build a Spring Boot App that Calls OpenAI’s ChatGPT API

This tutorial walks through creating a Spring Boot application that integrates the OpenAI ChatGPT API, covering prompt concepts, API endpoint details, required request parameters, project setup, necessary dependencies, DTO definitions, RestTemplate configuration, and a REST controller to generate AI‑driven responses.

ChatGPTOpenAI APISpring Boot
0 likes · 10 min read
Build a Spring Boot App that Calls OpenAI’s ChatGPT API
Su San Talks Tech
Su San Talks Tech
Mar 11, 2024 · Backend Development

Boost Java Development Efficiency with Hutool: Essential Utilities Explained

This article introduces the Hutool Java utility library, detailing its design principles and core features such as Convert, DateUtil, StrUtil, ReflectUtil, IdUtil, RandomUtil, BeanUtil, and JSONUtil, with code examples showing how each utility simplifies common development tasks and improves productivity.

Code ExamplesUtility Librarybackend-development
0 likes · 14 min read
Boost Java Development Efficiency with Hutool: Essential Utilities Explained
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 11, 2024 · Backend Development

Mastering @ResponseStatus in Spring Boot: Real‑World Examples & Custom Error Handling

This tutorial explains how Spring Boot's @ResponseStatus annotation works, demonstrates practical ways to throw ResponseStatusException, create custom exception classes, annotate controller methods, and replace the default error view with a custom JSON response, complete with code samples and diagrams.

@ResponseStatusError HandlingSpring Boot
0 likes · 6 min read
Mastering @ResponseStatus in Spring Boot: Real‑World Examples & Custom Error Handling
Java Tech Enthusiast
Java Tech Enthusiast
Mar 10, 2024 · Backend Development

Comprehensive Guide to Spring Validation in Spring Boot

This guide explains how to configure and use Spring Validation (JSR‑303) in Spring Boot, covering dependency setup, @Valid vs @Validated, request body and parameter validation, group, nested and collection checks, custom constraints, programmatic validation, fail‑fast mode, and underlying implementation details.

APIHibernateValidatorjava
0 likes · 16 min read
Comprehensive Guide to Spring Validation in Spring Boot
IT Services Circle
IT Services Circle
Mar 9, 2024 · Backend Development

Common Java Date Handling Pitfalls: Leap Year, Formatting, Timezone, and Thread Safety

This article explains several Java date‑time pitfalls—including leap‑year calculations, differences between YYYY/yyyy and HH/hh patterns, SimpleDateFormat initialization, Calendar hour fields, integer overflow in date arithmetic, thread‑unsafe usage of SimpleDateFormat, and daylight‑saving‑time handling—providing code examples and best‑practice recommendations.

BackendDateFormattingLeapYear
0 likes · 10 min read
Common Java Date Handling Pitfalls: Leap Year, Formatting, Timezone, and Thread Safety
IT Services Circle
IT Services Circle
Mar 9, 2024 · Backend Development

Java Backend Interview Guide: Networks, Data Structures, MySQL Logs, Elasticsearch, Kafka, Microservices, and Spring Essentials

This article compiles a comprehensive Java backend interview guide covering network protocols, HTTP characteristics, core data structures and algorithms, MySQL logging mechanisms, Elasticsearch full‑text search, Kafka reliability and deduplication, common micro‑service components, load‑balancing algorithms, and essential Spring concepts such as IoC, AOP, transactions, and MVC workflow.

BackendElasticsearchKafka
0 likes · 22 min read
Java Backend Interview Guide: Networks, Data Structures, MySQL Logs, Elasticsearch, Kafka, Microservices, and Spring Essentials
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 9, 2024 · Backend Development

Implementing Internal Network Penetration (Port Forwarding) with Java AIO Asynchronous Sockets

This article explains the principle of internal network penetration, describes how to build a Java AIO‑based client‑service tunnel with separate modules for registration and data exchange, and provides complete source code and testing steps for remote access to locally deployed services.

AIOasynchronous-iobackend-development
0 likes · 11 min read
Implementing Internal Network Penetration (Port Forwarding) with Java AIO Asynchronous Sockets
Code Ape Tech Column
Code Ape Tech Column
Mar 8, 2024 · Backend Development

Implementing Environment Isolation in MyBatis with a Custom Interceptor and Annotation

This article describes how to achieve data environment isolation in a Java application by creating a custom MyBatis interceptor and annotation, allowing automatic SQL modification to handle env fields, reducing code changes, improving safety, and supporting flexible deployment across pre‑release, gray, and production environments.

InterceptorMyBatisannotation
0 likes · 11 min read
Implementing Environment Isolation in MyBatis with a Custom Interceptor and Annotation
Java Architect Essentials
Java Architect Essentials
Mar 7, 2024 · Backend Development

Various Implementation Strategies for Delayed Tasks in Java: Quartz, DelayQueue, HashedWheelTimer, Redis, and RabbitMQ

This article explains the concept of delayed tasks, distinguishes them from scheduled tasks, and presents six practical Java implementations—including Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, Redis key‑space notifications, and RabbitMQ delayed queues—along with their advantages and drawbacks.

QuartzRabbitMQScheduling
0 likes · 14 min read
Various Implementation Strategies for Delayed Tasks in Java: Quartz, DelayQueue, HashedWheelTimer, Redis, and RabbitMQ
Selected Java Interview Questions
Selected Java Interview Questions
Mar 7, 2024 · Backend Development

Evolving an Order Processing System with Design Patterns: From Chain of Responsibility to Distributed Asynchronous Flow

This article walks through a real‑world order‑processing case, demonstrating how successive design‑pattern refinements—starting with the Chain of Responsibility, then adding Factory, Proxy, Template Method, Observer and distributed messaging—enable multi‑tenant, asynchronous, and scalable backend workflows.

Chain of ResponsibilityDesign PatternsFactory Pattern
0 likes · 15 min read
Evolving an Order Processing System with Design Patterns: From Chain of Responsibility to Distributed Asynchronous Flow
Java Captain
Java Captain
Mar 7, 2024 · Information Security

Requirements Analysis and Technical Implementation of Java Image Captcha

This article analyzes the security, usability, performance, and scalability requirements of Java image captchas and proposes a technical solution covering generation, verification, and optimization to build a safe, efficient, and user‑friendly validation mechanism.

CaptchaScalabilityUsability
0 likes · 5 min read
Requirements Analysis and Technical Implementation of Java Image Captcha
Java Captain
Java Captain
Mar 7, 2024 · Backend Development

Applying Java Annotations in Concurrent Programming

This article explores how Java's annotation mechanism, introduced in JDK 5.0, can be leveraged to address concurrency challenges by providing thread-safety, locking, timeout, and asynchronous execution annotations, and discusses their integration with AOP for enhanced thread management and performance.

Timeoutannotationsaop
0 likes · 5 min read
Applying Java Annotations in Concurrent Programming
Java Captain
Java Captain
Mar 7, 2024 · Backend Development

Replacing MyBatis with MyBatis-Plus: Troubleshooting LocalDateTime Conversion Issues and Version Compatibility

This article details the migration from MyBatis to MyBatis-Plus in a Java project, explains the LocalDateTime conversion exception caused by MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, and outlines the step‑by‑step fixes including driver upgrades and lessons learned from a separate file‑generation bug.

LocalDateTimeVersion Compatibilitybackend-development
0 likes · 14 min read
Replacing MyBatis with MyBatis-Plus: Troubleshooting LocalDateTime Conversion Issues and Version Compatibility
Java Captain
Java Captain
Mar 7, 2024 · Fundamentals

Understanding Java's String Class: Immutability, Methods, and Best Practices

This article reflects on the author's journey with Java, explaining the immutable nature of the String class, its rich set of methods—including substring, indexOf, replace, and regex support—while also discussing its limitations and alternatives like StringBuilder.

RegularExpressionsStringfundamentals
0 likes · 5 min read
Understanding Java's String Class: Immutability, Methods, and Best Practices
Java Captain
Java Captain
Mar 7, 2024 · Backend Development

How Spring Scans and Registers Custom Annotations

This article explains how the Spring framework discovers and registers custom annotations by using @ComponentScan, ClassPathScanningCandidateComponentProvider, and TypeFilter mechanisms, guiding developers to configure package scanning, apply meta‑annotations, and optionally implement custom filters for flexible bean management.

Custom AnnotationsTypeFilterbackend-development
0 likes · 5 min read
How Spring Scans and Registers Custom Annotations
Top Architect
Top Architect
Mar 6, 2024 · Backend Development

Integrating Tess4J OCR into a Spring Boot Backend Service

This guide demonstrates how to integrate Tess4J OCR into a Spring Boot application, covering environment setup, Maven dependencies, adding language data, creating an OCR service class, building REST endpoints for local and remote image processing, and testing the solution.

OCRSpring Bootjava
0 likes · 8 min read
Integrating Tess4J OCR into a Spring Boot Backend Service
JD Tech
JD Tech
Mar 6, 2024 · Backend Development

Fixing Incorrect Total Count in PageHelper Pagination Using PageInfo

This article analyzes why the total record count returned by PageHelper mismatches the actual number of rows, examines the underlying PageInfo and PageSerializable source code, and provides a concrete solution that avoids type conversion and directly constructs PageInfo from the mapper result to ensure accurate pagination.

BackendMyBatisPageInfo
0 likes · 7 min read
Fixing Incorrect Total Count in PageHelper Pagination Using PageInfo
Selected Java Interview Questions
Selected Java Interview Questions
Mar 6, 2024 · Backend Development

Encapsulating EasyExcel for Simplified Import/Export in Spring Boot Applications

This article demonstrates how to wrap EasyExcel within a Spring Boot + MyBatis‑Plus project to provide clean, reusable import and export APIs, covering environment setup, annotation usage, controller implementation, core service design, common pitfalls, and solutions for date and template handling.

BackendCodeExampleExcelImportExport
0 likes · 19 min read
Encapsulating EasyExcel for Simplified Import/Export in Spring Boot Applications
Su San Talks Tech
Su San Talks Tech
Mar 6, 2024 · Backend Development

Mastering Java Design Patterns: From High Cohesion to Low Coupling in Spring

This article explains the core concepts of high cohesion and low coupling, introduces common Java design patterns, demonstrates how Spring applies these patterns such as Singleton, Factory, Proxy, Observer, Chain of Responsibility, and Template Method, and provides practical code examples for real‑world scenarios.

Design PatternsHigh CohesionLow Coupling
0 likes · 19 min read
Mastering Java Design Patterns: From High Cohesion to Low Coupling in Spring
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 6, 2024 · Backend Development

Mastering Java 8 CompletableFuture: Async Patterns and Best Practices

This article introduces Java 8's CompletableFuture class, compares it with Future, demonstrates basic Future usage, then explores advanced asynchronous patterns—including CompletionService, chaining, exception handling, combining tasks, and various utility methods—providing code examples and execution results to illustrate each concept.

CompletableFutureExecutorServiceFuture
0 likes · 15 min read
Mastering Java 8 CompletableFuture: Async Patterns and Best Practices
FunTester
FunTester
Mar 5, 2024 · Backend Development

Building a Lightweight Java Object Pool Without Commons‑Pool2

This article walks through the design and implementation of a simple, thread‑safe object pool in Java using a LinkedBlockingQueue, explains the underlying concepts such as factory pattern and queue trimming, and provides a complete code example with a test script and output analysis.

Backendconcurrencydesign pattern
0 likes · 7 min read
Building a Lightweight Java Object Pool Without Commons‑Pool2
Top Architect
Top Architect
Mar 5, 2024 · Backend Development

Patent for a SpringBoot‑Based Web System Backend Implementation Method

The article announces a Chinese patent (CN112905176B) for a SpringBoot‑based backend implementation method, outlines its technical steps and benefits, briefly introduces SpringBoot, and also includes promotional material for a ChatGPT‑focused community offering resources and exclusive offers.

SpringBootWeb Developmentjava
0 likes · 5 min read
Patent for a SpringBoot‑Based Web System Backend Implementation Method
Su San Talks Tech
Su San Talks Tech
Mar 5, 2024 · Backend Development

Cracking the One Billion Row Challenge: Java Performance Secrets Unveiled

This article walks through the One Billion Row Challenge, explaining the problem, baseline solution, and a series of progressive Java optimizations—from parallel streams and better JVMs to custom hash tables, Unsafe, SWAR, and statistical tuning—that shrink execution time from minutes to under two seconds.

Custom Hash TableMemorySegmentOne Billion Row Challenge
0 likes · 20 min read
Cracking the One Billion Row Challenge: Java Performance Secrets Unveiled
Linux Code Review Hub
Linux Code Review Hub
Mar 5, 2024 · Operations

Why Did Opening a Log with Vim Kill the Java Process?

A port alarm revealed a missing Java process, which was later traced to an OOM kill triggered by vim loading a 37 GB nginx log into an 8 GB container, illustrating how editor behavior and Linux's OOM killer can unexpectedly terminate critical services.

ContainerLinuxNginx
0 likes · 7 min read
Why Did Opening a Log with Vim Kill the Java Process?
Selected Java Interview Questions
Selected Java Interview Questions
Mar 4, 2024 · Backend Development

Spring Cloud Gateway: A Step‑by‑Step Guide to Building a Scalable Microservice Gateway

This article introduces Spring Cloud Gateway as a powerful tool for building scalable microservice gateways, explains its reactive architecture and advantages, and provides a step‑by‑step tutorial—including Maven dependency, route configuration, custom filter code, and deployment instructions—plus suggestions for advanced features.

BackendMicroservicesSpring Cloud Gateway
0 likes · 8 min read
Spring Cloud Gateway: A Step‑by‑Step Guide to Building a Scalable Microservice Gateway
Java Backend Technology
Java Backend Technology
Mar 4, 2024 · Backend Development

How to Achieve Seamless Data Isolation in SpringBoot with MyBatis Interceptors

This article walks through the challenges of sharing a single database across pre‑release, gray, and online environments, explains how to add an env field for isolation, and shows a custom MyBatis interceptor and annotation‑driven AOP solution that rewrites SQL to automatically handle environment filtering and insertion while keeping business code untouched.

Custom AnnotationData IsolationInterceptor
0 likes · 9 min read
How to Achieve Seamless Data Isolation in SpringBoot with MyBatis Interceptors
FunTester
FunTester
Mar 4, 2024 · Backend Development

How to Build a Simple Java Rate Limiter from Scratch

This article explains the concept and benefits of rate limiting, reviews popular Java libraries, and walks through a custom implementation using maps, locks, and atomic counters, complete with full source code and a test script demonstrating a 2‑requests‑per‑2‑seconds policy.

Token Bucketbackend-developmentconcurrency
0 likes · 9 min read
How to Build a Simple Java Rate Limiter from Scratch
FunTester
FunTester
Mar 4, 2024 · Backend Development

Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger

This article explains the purpose and benefits of rate limiting, reviews popular Java rate‑limiting libraries, and provides a step‑by‑step guide with complete source code for building a simple, thread‑safe custom rate limiter using maps, ReentrantLock, and AtomicInteger.

Token Bucketconcurrencyjava
0 likes · 9 min read
Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger
Java Captain
Java Captain
Mar 3, 2024 · Backend Development

Introduction to LiteFlow Rule Engine and Its Usage in Java Spring Boot

This article introduces the lightweight yet powerful LiteFlow rule engine, explains its architecture, component types, EL rule files, data context handling, configuration, and demonstrates a practical e‑commerce workflow with hot‑deployment capabilities.

LiteFlowSpring Bootjava
0 likes · 9 min read
Introduction to LiteFlow Rule Engine and Its Usage in Java Spring Boot