Skip to content
Tagged articles

Java

500 articles · Page 3 of 5
Java Tech Workshop
Java Tech Workshop
Sep 9, 2026 · Fundamentals

Why Your Custom java.lang.String Can Never Replace the JDK's String

This article explains why a custom java.lang.String class cannot replace the JDK's String, detailing the parent delegation class loading model, Bootstrap ClassLoader's role, core class protection mechanisms, Java 9+ module system restrictions, and why attempts to bypass these (custom class loaders, -Xbootclasspath, --patch-module, Java Agents) fail or are unsafe.

Bootstrap ClassLoaderClass LoadingCore Class Protection
0 likes · 23 min read
Why Your Custom java.lang.String Can Never Replace the JDK's String
samdeepthink
samdeepthink
Sep 9, 2026 · Backend Development

Separation of Concerns: Decoupling SDK Details from Business Logic

The article illustrates Separation of Concerns beyond AOP by refactoring a reconciliation service that mixes WeChat Pay and Alipay SDK calls with business logic, introducing a wrapper layer with custom types to isolate SDK-specific parsing from core matching rules, enabling independent evolution of each concern.

JavaReconciliation ServiceSDK Integration
0 likes · 7 min read
Separation of Concerns: Decoupling SDK Details from Business Logic
SpringMeng
SpringMeng
Sep 9, 2026 · Backend Development

Spring Boot + Tess4j: Build OCR REST API Step by Step

This tutorial demonstrates how to integrate Tess4j with Spring Boot to create an OCR REST API, covering dependency setup, Tesseract engine initialization with language data configuration, image preprocessing tips, and a working controller example, plus a comparison of popular OCR engines and alternatives for improved Chinese text recognition.

Chinese text recognitionJavaOCR
0 likes · 9 min read
Spring Boot + Tess4j: Build OCR REST API Step by Step
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 9, 2026 · Backend Development

Refactoring 7 Duplicate Notification Services Using Template Method Pattern in Spring Boot

The article demonstrates how to correctly apply the DRY principle by refactoring seven duplicated notification service classes in Spring Boot 3.5.0 using the template method pattern and a NotificationMessage value object, consolidating 40 lines of repeated validation, logging, and error handling into a single abstract base class.

DRY principleJavaNotification Service
0 likes · 12 min read
Refactoring 7 Duplicate Notification Services Using Template Method Pattern in Spring Boot
macrozheng
macrozheng
Sep 8, 2026 · Backend Development

Why Hutool 5 Dominates Java Projects: One Library Replaces Dozens of Custom Utils

This article analyzes why Hutool 5 has become the standard Java utility library, detailing its modular design, code reduction benefits, performance improvements over JDK, and comparison with Guava and Apache Commons, while providing practical migration examples for strings, dates, files, HTTP, JSON, and AI integration.

AI IntegrationBackend DevelopmentHutool
0 likes · 23 min read
Why Hutool 5 Dominates Java Projects: One Library Replaces Dozens of Custom Utils
Architect Chen
Architect Chen
Sep 8, 2026 · Fundamentals

Java Decorator Pattern: Complete Guide with Pros, Cons & Code Examples

This article provides a comprehensive explanation of the Java Decorator pattern, covering its definition, purpose, advantages, disadvantages, and a complete implementation example with four key roles and runnable code demonstrating dynamic behavior extension.

Code ExamplesDecorator PatternJava
0 likes · 5 min read
Java Decorator Pattern: Complete Guide with Pros, Cons & Code Examples
liandk
liandk
Sep 7, 2026 · Backend Development

Why Your Troubleshooting Is Slow: The 4-Step Framework Senior Java Developers Use

This article contrasts junior developers' trial-and-error debugging with senior engineers' structured four-step method — confirm symptoms, layer-by-layer isolation, evidence-based root-cause analysis, and closed-loop remediation — to cut production incident resolution from hours to minutes.

JVMJavaPerformance Tuning
0 likes · 8 min read
Why Your Troubleshooting Is Slow: The 4-Step Framework Senior Java Developers Use
Java Tech Enthusiast
Java Tech Enthusiast
Sep 7, 2026 · Backend Development

Java Virtual Threads: Why Production Adoption Lagged Behind the Hype

The article analyzes why Java virtual threads, despite promising million-concurrency with minimal code changes, see little production adoption due to pinning with synchronized, ThreadLocal memory pressure, incomplete framework support, and CPU-bound workload mismatch, while showing benchmarks where they excel in I/O-heavy services but migration costs deter legacy systems.

ConcurrencyJDK 21Java
0 likes · 12 min read
Java Virtual Threads: Why Production Adoption Lagged Behind the Hype
macrozheng
macrozheng
Sep 7, 2026 · Backend Development

Java Virtual Threads: Why the 'Million Concurrency' Promise Failed in Production

This article analyzes why Java virtual threads, despite promising million-concurrency with minimal overhead, see little production adoption due to pinning with synchronized blocks, ThreadLocal memory explosions, incomplete framework support, and unsuitability for CPU-bound workloads, while showing benchmarks where they excel in I/O-heavy scenarios.

ConcurrencyJDK 21Java
0 likes · 12 min read
Java Virtual Threads: Why the 'Million Concurrency' Promise Failed in Production
Java Tech Workshop
Java Tech Workshop
Sep 7, 2026 · Backend Development

From Java Code to CPU Instructions: A Method Call's Complete Journey

This article traces a Java method call through five stages: compilation to bytecode, class loading with vtable resolution, interpretation via stack frames, JIT compilation with optimizations like inlining and escape analysis, and final execution as machine code on CPU pipelines.

BytecodeCPU pipelineClass Loading
0 likes · 30 min read
From Java Code to CPU Instructions: A Method Call's Complete Journey
LuTiao Programming
LuTiao Programming
Sep 6, 2026 · Artificial Intelligence

Spring AI 2.0 Tool Search: Stop Flooding LLMs with Dozens of Tools

The author migrates a Spring AI Agent with 30+ business tools to Spring AI 2.0's Tool Search, which uses Lucene indexing to let the model search for relevant tools before calling them, reducing context overload and improving selection accuracy, while sharing best practices for tool descriptions and safe write-operation handling.

AI AgentJavaLucene
0 likes · 15 min read
Spring AI 2.0 Tool Search: Stop Flooding LLMs with Dozens of Tools
Coder Trainee
Coder Trainee
Sep 4, 2026 · Backend Development

ComfyUI Java Integration: 3 Open-Source Solutions from Lightweight SDK to Full-Stack Product

This article reviews three open-source Java solutions for integrating ComfyUI AI image generation: a lightweight SDK (ComfyUiApiJava), an API aggregation layer (comfy-flow-api) with Spring Boot 3, and a full-stack enterprise platform (comfyui-openrouter-ai) with user management, credits, and WebSocket progress, helping developers choose by complexity and needs.

AI image generationBackend IntegrationComfyUI
0 likes · 9 min read
ComfyUI Java Integration: 3 Open-Source Solutions from Lightweight SDK to Full-Stack Product
Java Architect Handbook
Java Architect Handbook
Sep 4, 2026 · Backend Development

Dynamic Service Provider Switching with Spring-Smart-DI's @AutowiredProxySPI

This tutorial demonstrates how to use Spring-Smart-DI's @AutowiredProxySPI annotation to dynamically switch between multiple service implementations (e.g., SMS providers) at runtime by changing configuration values, without application restarts, using proxy-based injection that resolves the active implementation on each call.

@AutowiredBackend DevelopmentDependency Injection
0 likes · 8 min read
Dynamic Service Provider Switching with Spring-Smart-DI's @AutowiredProxySPI
ITPUB
ITPUB
Sep 3, 2026 · Backend Development

Master Java Callbacks & Functional Programming: Write Elegant, Structured Code Beyond CRUD

This article explains Java callback mechanisms — synchronous and asynchronous — through interfaces, anonymous classes, lambdas, and CompletableFuture, demonstrates their use in Spring's BeanFactory and a payment integration, and shows how functional interfaces enable flexible data transformation for multi-bank integration.

CallbackCompletableFutureJava
0 likes · 15 min read
Master Java Callbacks & Functional Programming: Write Elegant, Structured Code Beyond CRUD
java1234
java1234
Sep 3, 2026 · Backend Development

MyBatis-Plus 3.5.15: Spring Boot 4.0 & Jackson 3.0 Support Explained

This article details MyBatis-Plus 3.5.15's new support for Spring Boot 4.0 and Jackson 3.0, providing step-by-step migration guidance including starter dependency changes, JSON field handling with Jackson3TypeHandler, and common upgrade pitfalls like starter mismatches and factoryBeanObjectType errors.

Database MigrationJackson 3.0Java
0 likes · 13 min read
MyBatis-Plus 3.5.15: Spring Boot 4.0 & Jackson 3.0 Support Explained
Java Tech Workshop
Java Tech Workshop
Sep 3, 2026 · Backend Development

Why Adding a Method Breaks Java Deserialization: The Implicit serialVersionUID Trap

This article explains how Java's implicit serialVersionUID causes deserialization failures when class structure changes, details how the JVM calculates it, shows source-level version checking in ObjectStreamClass, lists compatible and incompatible changes, and covers custom serialization mechanisms like transient, writeObject/readObject, and Externalizable.

InvalidClassExceptionJVMJava
0 likes · 20 min read
Why Adding a Method Breaks Java Deserialization: The Implicit serialVersionUID Trap
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 2, 2026 · Backend Development

Java Thread Pool Deep Dive: 7 Core Parameters, 4 Rejection Policies & Tuning Formulas

This comprehensive guide covers Java thread pool internals including seven core parameters with bank analogies, task execution flow, four rejection strategies with production pitfalls, CPU/IO-bound thread sizing formulas, common Executors pitfalls, state transitions, and graceful shutdown patterns with code examples.

ConcurrencyExecutorServiceInterview Preparation
0 likes · 41 min read
Java Thread Pool Deep Dive: 7 Core Parameters, 4 Rejection Policies & Tuning Formulas
Programmer1970
Programmer1970
Sep 2, 2026 · Backend Development

One TINYINT Field, Four Notification Switches: Bitmask Pattern in Practice

This article demonstrates how to store four independent notification channel switches (SMS, email, in-app, WeChat) in a single MySQL TINYINT column using bitwise operations, covering schema design, SQL queries, Java enum and utility classes, service and controller layers, MyBatis mapper, extensibility to N channels, and key considerations like indexing, concurrency, and readability.

JavaMyBatisMySQL
0 likes · 14 min read
One TINYINT Field, Four Notification Switches: Bitmask Pattern in Practice
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 2, 2026 · Backend Development

How to Build a Scalable Notification Service with Spring Boot

The article explains why notification services are hard—slow delivery, unreliable third‑party providers, and status tracking—and shows how to solve these issues by fully decoupling the API from workers using a message queue, with detailed Spring Boot code examples and scaling strategies.

JavaNotification ServiceRabbitMQ
0 likes · 10 min read
How to Build a Scalable Notification Service with Spring Boot
LuTiao Programming
LuTiao Programming
Sep 1, 2026 · Backend Development

Why I Dropped @FeignClient After Years of Use: Spring Boot’s Built‑In HTTP Service Client

The author refactors an old Spring Cloud project by removing Feign, replacing @FeignClient with Spring Boot 4.x’s native @HttpExchange and @ImportHttpServices, and demonstrates that Spring’s built‑in HTTP Service Client provides the same declarative convenience with less boilerplate, while still supporting custom configuration, error handling, and reactive use cases.

Declarative HTTPFeignHTTP Service Client
0 likes · 14 min read
Why I Dropped @FeignClient After Years of Use: Spring Boot’s Built‑In HTTP Service Client
samdeepthink
samdeepthink
Sep 1, 2026 · Fundamentals

Why Java Static Blocks Aren’t Executed First

The article explains that Java static blocks are not always the first code to run during class loading because static field initializers and static blocks are executed in the order they appear in the source, and a static field can trigger instance initialization.

Class LoadingJavaJava fundamentals
0 likes · 6 min read
Why Java Static Blocks Aren’t Executed First
macrozheng
macrozheng
Sep 1, 2026 · Information Security

Why Sa-Token Is Winning Over Developers: A Java Authentication Efficiency Revolution

Sa-Token has rapidly become the go‑to Java permission framework because it abstracts and automates common security concerns, offers a lightweight Core‑Plugin‑Adapter architecture, supports plug‑in storage like Redis, and lets developers implement login, logout and permission checks with a single line of code, dramatically reducing development time compared with Spring Security.

AuthorizationJavaPermission Framework
0 likes · 16 min read
Why Sa-Token Is Winning Over Developers: A Java Authentication Efficiency Revolution
AliExpress Tech
AliExpress Tech
Sep 1, 2026 · Backend Development

Designing an AI-Powered, Zero-Impact Checker Attack‑Defense System for AliExpress

The article details how the massive 700‑plus error‑code validation system in AliExpress’s marketing pipeline is protected by an AI‑driven, multi‑phase attack‑defence pipeline that leverages Saiga Mock for non‑destructive testing, MQ‑driven orchestration, and plug‑in sub‑engines to achieve rapid, risk‑free verification.

AICheckerJava
0 likes · 28 min read
Designing an AI-Powered, Zero-Impact Checker Attack‑Defense System for AliExpress
LuTiao Programming
LuTiao Programming
Aug 31, 2026 · Backend Development

Why Disabled Buttons Still Produce Duplicate Orders – Rebuilding Idempotency in Spring Boot

The article examines a common duplicate‑order bug caused by client retries after network timeouts, explains why @Transactional alone cannot guarantee idempotency, critiques simple Redis SETNX solutions, and presents a robust Spring Boot design that stores idempotency records together with order data in a single MySQL transaction, uses request fingerprints, unique keys, and owner tokens to safely replay or reject retries while handling concurrency and cleanup.

@TransactionalAPI DesignConcurrency
0 likes · 19 min read
Why Disabled Buttons Still Produce Duplicate Orders – Rebuilding Idempotency in Spring Boot
Java Architect Handbook
Java Architect Handbook
Aug 31, 2026 · Backend Development

Say Goodbye to If‑Else Nightmares with Flow Orchestration

The article explains how excessive if‑else logic in Java back‑ends harms code isolation and scalability, and demonstrates a practical workflow‑orchestration solution using a FlowChain engine, complete with configuration, node definitions, execution flow, and source code examples from the open‑source MemberClub project.

BackendFlow OrchestrationJava
0 likes · 8 min read
Say Goodbye to If‑Else Nightmares with Flow Orchestration
samdeepthink
samdeepthink
Aug 31, 2026 · Fundamentals

Why Java Arrays Have No Constructors and How the JVM Instantiates Them

The article explains that Java arrays, unlike regular objects, lack constructors because the JVM creates them directly via special bytecode instructions, automatically zero‑initialising elements and exposing length as a field, which trades flexibility for simplicity and performance.

BytecodeJVMJava
0 likes · 6 min read
Why Java Arrays Have No Constructors and How the JVM Instantiates Them
Java Tech Workshop
Java Tech Workshop
Aug 31, 2026 · Backend Development

Add a Dependency and It Just Works: One‑Line Spring Boot Starter Auto‑Configuration

This article explains why adding a Spring Boot starter dependency instantly creates the required beans without XML or manual configuration, walks through the auto‑configuration mechanism—including @EnableAutoConfiguration, AutoConfigurationImportSelector, and conditional annotations—and shows step‑by‑step how to build a custom starter from scratch with Maven, configuration properties, an aspect, and registration files.

Auto-ConfigurationConditional AnnotationsJava
0 likes · 21 min read
Add a Dependency and It Just Works: One‑Line Spring Boot Starter Auto‑Configuration
Java Architecture Diary
Java Architecture Diary
Aug 31, 2026 · Backend Development

Spring 7's Native Retry & Concurrency Limit: When They're Enough (and When They're Not)

Spring Framework 7 introduces @Retryable and @ConcurrencyLimit annotations for method-level retry and concurrency control, enabling developers to handle transient failures and limit parallel executions without third-party libraries, though they operate per-JVM and lack distributed coordination.

@RetryableConcurrencyLimitFault Tolerance
0 likes · 9 min read
Spring 7's Native Retry & Concurrency Limit: When They're Enough (and When They're Not)
LuTiao Programming
LuTiao Programming
Aug 30, 2026 · Databases

I Finally Deleted the Java Code That Reads the Whole Redis Object to Update One Field

The article explains how the old pattern of GET‑ing an entire JSON string from Redis, deserializing it in Java, modifying a single field and writing it back is inefficient and error‑prone, and shows how Spring Data Redis 4.2’s RedisJsonTemplate lets you update or read individual JSON paths directly, reducing code, network traffic and race‑condition risks.

CacheJSONJava
0 likes · 15 min read
I Finally Deleted the Java Code That Reads the Whole Redis Object to Update One Field
samdeepthink
samdeepthink
Aug 30, 2026 · Fundamentals

Understanding the Open‑Closed Principle Through Spring’s Extension Hooks

The article explains the Open‑Closed Principle, shows how Spring leaves empty hook methods like onRefresh() for extensions, demonstrates the concept with a Java demo, compares inheritance‑based and interface‑based extension approaches, and discusses trade‑offs and practical guidelines for designing extension points.

Extension HooksJavaOpen/Closed Principle
0 likes · 10 min read
Understanding the Open‑Closed Principle Through Spring’s Extension Hooks
CodeSmart Hoops
CodeSmart Hoops
Aug 30, 2026 · Backend Development

Classic gRPC Interview Questions with Answers – Must‑Save for Your Prep

This article presents eight self‑test gRPC interview questions covering performance, contract, cross‑language support, streaming, HTTP/2 fundamentals, Protobuf field tags, call patterns, retryable status codes, load‑balancing policies, interceptor usage, and Spring Boot 3 integration, each accompanied by concise reference answers.

HTTP/2JavaProtobuf
0 likes · 23 min read
Classic gRPC Interview Questions with Answers – Must‑Save for Your Prep
Coder Trainee
Coder Trainee
Aug 29, 2026 · Backend Development

When @Transactional Goes Wrong: Misusing Transaction Propagation Leads to Deadlocks

A real‑world case shows that using @Transactional with the default REQUIRED propagation caused a long‑running transaction, frequent deadlocks, data inconsistency and higher timeout rates, and the article walks through the root cause, investigation steps, and practical fixes such as REQUIRES_NEW, self‑proxy calls, and async eventual consistency.

@TransactionalBackendDeadlock
0 likes · 9 min read
When @Transactional Goes Wrong: Misusing Transaction Propagation Leads to Deadlocks
The Dominant Programmer
The Dominant Programmer
Aug 29, 2026 · Artificial Intelligence

Harness Engineering with Spring AI Alibaba: Theory, Architecture, and Full Implementation Guide

This comprehensive guide walks through Harness Engineering concepts, the seven‑layer architecture, environment setup, full Spring Boot codebase, agent configuration, best‑practice recommendations, testing procedures, common issues, and advanced directions for building controllable AI agents with Spring AI Alibaba.

AI agentsJavaSpring AI
0 likes · 34 min read
Harness Engineering with Spring AI Alibaba: Theory, Architecture, and Full Implementation Guide
samdeepthink
samdeepthink
Aug 29, 2026 · Fundamentals

Why a Contract‑Compliant List Still Breaks Liskov Substitution in Java

The article demonstrates that although List.of, Arrays.asList, and unmodifiableList implement the List interface, they violate the Liskov Substitution Principle because their optional add/remove operations throw UnsupportedOperationException, revealing a hidden contract mismatch between interface documentation and runtime behavior.

Design PrinciplesImmutable CollectionsJava
0 likes · 13 min read
Why a Contract‑Compliant List Still Breaks Liskov Substitution in Java
Coder Trainee
Coder Trainee
Aug 28, 2026 · Backend Development

I Almost Got Fired Using Parallel Stream in Production

A production outage caused by Java 8 parallel streams exposed the dangers of the default commonPool, unlimited task queuing, and long‑running API calls, leading to 100% CPU, 30+ GC events per hour, and a near‑service collapse, which was resolved by custom thread pools, timeouts, and CompletableFuture alternatives.

CompletableFutureForkJoinPoolJava
0 likes · 7 min read
I Almost Got Fired Using Parallel Stream in Production
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 28, 2026 · Backend Development

Fuzzy Query on Encrypted Phone Numbers: 5 Solutions & Production Java Implementation

This article compares five technical approaches for fuzzy querying encrypted phone numbers, detailing the industry-standard prefix/suffix hash indexing and 3-gram fragment indexing with complete Java implementations using AES-256-GCM and HMAC-SHA256, covering database schema, security hardening, production challenges, and interview strategies.

3-gramAES-256-GCMHMAC-SHA256
0 likes · 28 min read
Fuzzy Query on Encrypted Phone Numbers: 5 Solutions & Production Java Implementation
ITPUB
ITPUB
Aug 28, 2026 · Backend Development

Why Java’s Optional Is Still Ignored After 10 Years – The Real Bottlenecks

The article dissects why Java 8’s Optional, despite being a dedicated null‑pointer remedy, remains unpopular, examines common misconceptions, misuse pitfalls, unsuitable scenarios, and finally presents three concrete situations where Optional truly shines, backed by code examples and practical guidance.

Best PracticesJavaNullPointerException
0 likes · 10 min read
Why Java’s Optional Is Still Ignored After 10 Years – The Real Bottlenecks
Code Ape Tech Column
Code Ape Tech Column
Aug 28, 2026 · Databases

Redis Transforms into AI Data Infrastructure: Vector Search, Vector Sets, Semantic Cache & Agent Memory

This article details Redis's evolution into a comprehensive AI data infrastructure, covering its four core capabilities—vector search with hybrid queries, native Vector Sets data type, LangCache semantic caching for 70% LLM cost reduction, and Redis Iris context engine for AI agent memory—with technical implementations, performance benchmarks, and use-case recommendations.

AI agent memoryHNSWJava
0 likes · 16 min read
Redis Transforms into AI Data Infrastructure: Vector Search, Vector Sets, Semantic Cache & Agent Memory
samdeepthink
samdeepthink
Aug 28, 2026 · Fundamentals

How Java’s LocalDate Embodies the Single Responsibility Principle

The article explains how JDK 17’s java.time.LocalDate follows the Single Responsibility Principle by separating date data from formatting, contrasts this design with the older mutable java.util.Date, and shows how to spot classes that take on too many responsibilities.

API DesignDateTimeFormatterImmutable Objects
0 likes · 6 min read
How Java’s LocalDate Embodies the Single Responsibility Principle
dbaplus Community
dbaplus Community
Aug 27, 2026 · Backend Development

How MQ Message Reordering Triggered a Major Business Outage

A late‑night logistics alert revealed that out‑of‑order RocketMQ events caused order and shipment statuses to diverge, prompting a root‑cause analysis that uncovered a gift‑giving feature’s simultaneous event publishing and led to two mitigation strategies: delayed sending and ordered messages.

BackendJavaRocketMQ
0 likes · 8 min read
How MQ Message Reordering Triggered a Major Business Outage
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 27, 2026 · Backend Development

10GB File Upload: Chunked Concurrency, Resumable & Instant Upload with MinIO + Redis

This article presents a complete solution for uploading 10GB files, covering frontend chunking with WebWorker MD5, concurrent upload control, backend MinIO multipart upload with Redis state tracking, resumable upload, instant upload via hash deduplication, Java NIO zero-copy merging, and interview-focused Q&A with code examples.

JavaMinIONIO zero-copy
0 likes · 31 min read
10GB File Upload: Chunked Concurrency, Resumable & Instant Upload with MinIO + Redis
CodeSmart Hoops
CodeSmart Hoops
Aug 27, 2026 · Backend Development

Deep Dive into gRPC: Load Balancing, Service Discovery, and Pitfall Guide

This article provides a comprehensive analysis of gRPC, covering core concepts, HTTP/2 and Protobuf fundamentals, four call patterns, interceptors, error handling, load‑balancing strategies, service discovery mechanisms, circuit‑breaking and rate‑limiting, security layers, and a complete Spring Boot 3 + JDK 21 runnable example with a detailed best‑practice checklist.

Circuit BreakingHTTP/2Java
0 likes · 33 min read
Deep Dive into gRPC: Load Balancing, Service Discovery, and Pitfall Guide
Su San Talks Tech
Su San Talks Tech
Aug 27, 2026 · Artificial Intelligence

How Redis Becomes the Real‑Time Data Backbone for AI

Redis has evolved from a pure cache middleware into a full‑stack AI data infrastructure, offering vector search, native vector sets, semantic caching, and an AI Agent context engine, with sub‑millisecond latency, high throughput, and detailed performance benchmarks that illustrate its strengths and trade‑offs.

AIJavaRedis
0 likes · 15 min read
How Redis Becomes the Real‑Time Data Backbone for AI
Senior Tony
Senior Tony
Aug 26, 2026 · Industry Insights

What Is a Forward Deployed Engineer (FDE) and Why Big Tech Is Hiring Them

This article explains the Forward Deployed Engineer (FDE) role, tracing its origins from Palantir to its current critical function in deploying AI models into real enterprise systems, detailing the workflow, required skills, and why FDEs command high salaries in the AI deployment era.

AI deploymentAgentEnterprise AI
0 likes · 9 min read
What Is a Forward Deployed Engineer (FDE) and Why Big Tech Is Hiring Them
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 25, 2026 · Backend Development

Java Thread Safety: 5 Core Approaches Compared with Code Examples & Interview Insights

This comprehensive guide covers five categories of Java thread safety solutions — from stateless objects and immutable classes to volatile, locks, and thread confinement — with performance comparisons, code examples for DCL, CAS, ReentrantLock, and ThreadLocal, plus analysis of deadlock, ABA problem, and memory leaks for backend interview preparation.

Atomic OperationsConcurrencyInterview Preparation
0 likes · 23 min read
Java Thread Safety: 5 Core Approaches Compared with Code Examples & Interview Insights
Architect Chen
Architect Chen
Aug 25, 2026 · Fundamentals

Java Thread States Explained: 6 States with Visual Diagrams

This article provides a comprehensive explanation of Java's six thread states—New, Runnable, Blocked, Waiting, Timed Waiting, and Terminated—with visual diagrams illustrating each state's transitions and typical triggers such as lock acquisition, wait/notify, and timeout mechanisms.

ConcurrencyJavaJava Interview
0 likes · 3 min read
Java Thread States Explained: 6 States with Visual Diagrams
IoT Full-Stack Technology
IoT Full-Stack Technology
Aug 25, 2026 · Fundamentals

Elegant Ways to Eliminate Null‑Related Bugs in Java

The article explains how null values cause NullPointerException, unpredictable behavior, and resource leaks in Java, and presents twelve practical techniques—including Optional, annotations, null‑safe APIs, custom helpers, exception handling, the Null Object pattern, third‑party libraries, documentation, code reviews, testing, static analysis, and IDE support—to prevent and resolve these issues.

AnnotationsBest PracticesJava
0 likes · 5 min read
Elegant Ways to Eliminate Null‑Related Bugs in Java
Java Backend Technology
Java Backend Technology
Aug 25, 2026 · Backend Development

Are Java Virtual Threads Losing Their Momentum?

The article examines why the early hype around Java virtual threads has faded, detailing technical pitfalls such as pinning and ThreadLocal memory bloat, incomplete ecosystem support, and misuse in CPU‑bound workloads, while also presenting benchmark data that shows they still excel in I/O‑heavy scenarios.

ConcurrencyJDKJava
0 likes · 10 min read
Are Java Virtual Threads Losing Their Momentum?
Coder Trainee
Coder Trainee
Aug 24, 2026 · Backend Development

How a Silent Infinite Loop Drained Our Database Connection Pool

The article walks through a real incident where a scheduled batch job contained an infinite while‑true loop, causing all 500 HikariCP connections to be held, slowing the application dramatically; it details the investigation steps, root‑cause analysis, and both emergency and long‑term fixes, plus a checklist to avoid similar bugs.

Connection PoolHikariCPJava
0 likes · 7 min read
How a Silent Infinite Loop Drained Our Database Connection Pool
CTO Full-Stack Academy
CTO Full-Stack Academy
Aug 24, 2026 · Backend Development

Hot Swap vs Hot Deployment in Java: How They Work and When to Use Them

The article explains the background of long Java restart times, defines hot swap and hot deployment, details their implementation mechanisms, compares their granularity, speed, limitations, and impact, lists common tools, and highlights frequent misconceptions and pitfalls for developers.

Hot DeploymentHot SwapJRebel
0 likes · 9 min read
Hot Swap vs Hot Deployment in Java: How They Work and When to Use Them
Code Archaeology
Code Archaeology
Aug 24, 2026 · Backend Development

Why Spring Changed HttpMethod from Enum to Class: Fixing an Open Set Mismatch

Spring changed HttpMethod from enum to class in Spring 6.0 because HTTP methods form an open, extensible set per RFC 7231, making enum's closed nature a poor fit that forced workarounds like dual getters and null-returning resolve methods until a major version break allowed the fix.

API DesignEnum vs ClassHTTP Methods
0 likes · 7 min read
Why Spring Changed HttpMethod from Enum to Class: Fixing an Open Set Mismatch
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 23, 2026 · Fundamentals

Java Interview Mastery: Core Concepts, JDK 8-21 Evolution & Modern Features

This comprehensive guide covers Java interview essentials including JDK/JRE/JVM differences, JDK 8-21 version evolution with key features like Records, Sealed Classes, Pattern Matching, Virtual Threads, and core topics such as String immutability, equals/hashCode contract, OOP principles, exception handling, reflection, serialization, and IO models.

JDKJavaRecords
0 likes · 58 min read
Java Interview Mastery: Core Concepts, JDK 8-21 Evolution & Modern Features
Yumin Fish Harvest
Yumin Fish Harvest
Aug 23, 2026 · Backend Development

How to Deploy TSID for Distributed ID Generation: From Local Setup to Multi‑Cluster Kubernetes

This article walks through using the TSID library to generate 64‑bit numeric and 13‑character string IDs, shows a quick‑start Maven example, integrates the creator into Spring Boot as a singleton bean, explains node and nodeCount configuration, and details deployment strategies for fixed servers, a single Kubernetes cluster, and multiple clusters.

JavaSpring BootTSID
0 likes · 16 min read
How to Deploy TSID for Distributed ID Generation: From Local Setup to Multi‑Cluster Kubernetes
LuTiao Programming
LuTiao Programming
Aug 22, 2026 · Backend Development

Why Spring Boot 4.1.1 Makes Controllers and JSON Unnecessary for Internal Microservice Calls

Spring Boot 4.1.1 now offers native gRPC support, letting Java microservices replace the usual REST controllers, DTOs, Feign clients and JSON payloads with a single .proto definition, generated code, and built‑in security, health, observability and testing features, while highlighting best practices and pitfalls.

JavaProtocol BuffersSpring Boot
0 likes · 12 min read
Why Spring Boot 4.1.1 Makes Controllers and JSON Unnecessary for Internal Microservice Calls
Three Knives
Three Knives
Aug 22, 2026 · Cloud Native

Eliminating Startup Decisions: How Feat Moves Runtime Choices to Compile Time for Faster Cold Starts

The article explains how the Feat framework reduces Java cold‑start latency by shifting configuration and environment decisions from runtime to compile time, using a three‑layer config model, externalized placeholders, and compile‑time code generation to eliminate on‑the‑fly processing.

Cloud NativeCold StartCompile-time Configuration
0 likes · 7 min read
Eliminating Startup Decisions: How Feat Moves Runtime Choices to Compile Time for Faster Cold Starts
Architect's Guide
Architect's Guide
Aug 22, 2026 · Information Security

Comprehensive Guide: Implementing RBAC with Spring Security and JWT

This article walks through the fundamentals of Role‑Based Access Control (RBAC), explains the RBAC0‑RBAC3 model hierarchy, demonstrates how to configure Spring Security for in‑memory and database authentication, integrates JWT for stateless token handling, and shows how to enable JSON‑based login and BCrypt password encryption with concrete code examples.

JavaRBACSpring Boot
0 likes · 16 min read
Comprehensive Guide: Implementing RBAC with Spring Security and JWT
Dabaoshi
Dabaoshi
Aug 21, 2026 · Backend Development

Concurrency Series Finale: Virtual Threads and Structured Concurrency

The article explains why platform threads are costly, how JDK 21 virtual threads eliminate that cost, and provides practical guidance on creating, using, and debugging virtual threads, including pinning pitfalls, rules against pooling, structured concurrency, ScopedValue, and a detailed model‑selection comparison.

ConcurrencyJDK 21Java
0 likes · 34 min read
Concurrency Series Finale: Virtual Threads and Structured Concurrency
Java Architecture Diary
Java Architecture Diary
Aug 21, 2026 · Artificial Intelligence

LangChain4j 1.19 Switches to Stateless Streamable HTTP and Adds Hybrid Milvus Search

LangChain4j 1.19 drops SSE support in favor of a stateless Streamable HTTP protocol, introduces a Milvus‑v2 module that combines dense vector similarity with BM25 keyword matching for hybrid retrieval, and bundles dozens of bug fixes and new integrations across agents, HTTP clients, vector stores, and document parsers.

JavaLLMLangChain4j
0 likes · 9 min read
LangChain4j 1.19 Switches to Stateless Streamable HTTP and Adds Hybrid Milvus Search
The Dominant Programmer
The Dominant Programmer
Aug 20, 2026 · Artificial Intelligence

Deep Dive into Context Engineering with Spring AI Alibaba

This article explains how Spring AI Alibaba’s Agent framework uses Hooks and Interceptors to dynamically control model, tool, and lifecycle contexts, demonstrating the concepts through a complete e‑commerce smart‑customer‑service demo with role‑based tool selection, dynamic prompts, and context compression.

AI AgentContext EngineeringInterceptor
0 likes · 21 min read
Deep Dive into Context Engineering with Spring AI Alibaba
Dabaoshi
Dabaoshi
Aug 20, 2026 · Backend Development

Mastering Asynchronous Orchestration in Java: From Future Limits to CompletableFuture and Fork/Join

The article explains how to replace blocking Future with CompletableFuture for efficient asynchronous orchestration, covering task chaining, parallel execution, exception handling, and Fork/Join, and demonstrates a complete seckill order pipeline that reduces latency by parallelizing independent steps.

CompletableFutureConcurrencyForkJoin
0 likes · 19 min read
Mastering Asynchronous Orchestration in Java: From Future Limits to CompletableFuture and Fork/Join
Tech Musings
Tech Musings
Aug 20, 2026 · Fundamentals

Four JMH Cases Reveal How Java JIT Optimizes at the Assembly Level

The article walks through four carefully designed JMH benchmarks—method inlining, SIMD vectorization, lock elimination, and a Netty AsciiString regression—to show how JVM JIT optimizations appear in assembly, explain the performance impact (up to 1500×), and demonstrate how to diagnose and fix real‑world issues using assembly analysis.

JITJMHJava
0 likes · 19 min read
Four JMH Cases Reveal How Java JIT Optimizes at the Assembly Level
The Dominant Programmer
The Dominant Programmer
Aug 19, 2026 · Artificial Intelligence

Persisting Spring AI Alibaba Memory to Redis: A Hands‑On Guide

This guide walks through configuring Spring AI Alibaba 1.1.2.0 to persist an agent's short‑term memory in Redis, covering environment setup, core concepts like Checkpointer and StateSerializer, step‑by‑step Maven project creation, code snippets, common pitfalls, and verification of multi‑turn conversation state across sessions.

AgentJavaRedis
0 likes · 17 min read
Persisting Spring AI Alibaba Memory to Redis: A Hands‑On Guide
MeowKitty Programming
MeowKitty Programming
Aug 19, 2026 · Backend Development

DeepSeek Is Raising Prices: Java Developers Must Recalculate AI Costs

The article analyzes DeepSeek's upcoming price hike, explains why Java projects can no longer treat large‑model calls as cheap infrastructure, outlines three common pitfalls, and provides concrete engineering steps—cost tracking, model routing, budgeting, and testing—to keep AI services affordable and reliable.

AI pricingDeepSeekJava
0 likes · 7 min read
DeepSeek Is Raising Prices: Java Developers Must Recalculate AI Costs
Java Architect Handbook
Java Architect Handbook
Aug 19, 2026 · Backend Development

How Enums Can Streamline Spring Boot Configuration Management

This article demonstrates how to use Java enums together with Spring Boot's @ConfigurationProperties to replace hard‑coded strings in application.yml, improving readability, reducing maintenance effort, and enabling flexible configuration of user types displayed via a Thymeleaf front‑end.

ConfigurationPropertiesJavaSpring Boot
0 likes · 14 min read
How Enums Can Streamline Spring Boot Configuration Management
Architect's Guide
Architect's Guide
Aug 19, 2026 · Backend Development

How to Implement Redis Cache Preheating in Spring

This article explains the concept of cache preheating, provides an abstract cache class, a Spring context utility, and a CommandLineRunner implementation that automatically loads hot data into Redis at startup, demonstrating the approach with a news‑cache example and related controller code.

AbstractCacheCache PreheatingCommandLineRunner
0 likes · 5 min read
How to Implement Redis Cache Preheating in Spring
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 19, 2026 · Backend Development

PDFBox: A Powerful Open‑Source Java Library for PDF Manipulation

This article introduces Apache PDFBox, an open‑source Java library for creating, modifying, and extracting content from PDFs, and provides step‑by‑step Spring Boot 3.5 examples covering text extraction, region extraction, metadata handling, image insertion, form creation, JavaScript actions, and bookmark generation.

JavaPDF manipulationPDF processing
0 likes · 17 min read
PDFBox: A Powerful Open‑Source Java Library for PDF Manipulation
MeowKitty Programming
MeowKitty Programming
Aug 18, 2026 · Backend Development

When AI Writes Whole Projects, What Jobs Remain for Java Backend Developers?

After an AI mistakenly removed three reflection‑based Spring beans from a 5,000‑line service, the author reflects on how AI‑driven code generation is reshaping Java backend roles—from writing code to focusing on architecture, requirements, and AI‑orchestrated testing—highlighting recent survey data and upcoming Spring AI 2.0 features.

AI code generationBackend DevelopmentJava
0 likes · 5 min read
When AI Writes Whole Projects, What Jobs Remain for Java Backend Developers?
The Dominant Programmer
The Dominant Programmer
Aug 18, 2026 · Artificial Intelligence

Comprehensive Guide to Spring AI Alibaba Tools: From Basics to Advanced

This article presents a complete, runnable Spring AI Alibaba Tools example (v1.1.2.0) that explains core concepts, three creation methods, registration techniques, advanced features such as JSON schema generation and custom result conversion, environment setup, testing commands, and common troubleshooting tips.

AI AgentAlibabaJSON Schema
0 likes · 32 min read
Comprehensive Guide to Spring AI Alibaba Tools: From Basics to Advanced
Dabaoshi
Dabaoshi
Aug 18, 2026 · Backend Development

ConcurrentHashMap Deep Dive: Understanding Java’s Core Concurrent Container

This article explains why HashMap isn’t thread‑safe, how Hashtable’s single lock hurts performance, and walks through the evolution from JDK 1.7 segment locks to JDK 1.8’s CAS‑plus‑synchronized bucket locking, including lock‑free size counting and a comparison with CopyOnWriteArrayList for read‑heavy scenarios.

ConcurrencyConcurrentHashMapCopyOnWriteArrayList
0 likes · 17 min read
ConcurrentHashMap Deep Dive: Understanding Java’s Core Concurrent Container
Dabaoshi
Dabaoshi
Aug 18, 2026 · Backend Development

Thread Pool Mechanics and Tuning: Avoid new Thread() in Production

This article explains why creating raw threads in production is costly, breaks down the seven ThreadPoolExecutor parameters, shows the exact execution flow of a submitted task, compares queue choices and Executors factories, and provides practical tuning, rejection‑policy and graceful‑shutdown guidance.

ConcurrencyExecutorServiceJava
0 likes · 16 min read
Thread Pool Mechanics and Tuning: Avoid new Thread() in Production
Niu Liu
Niu Liu
Aug 18, 2026 · Industry Insights

Go vs Java and the Mystery of China’s Missing Programming Language: What’s the Real Technical Gap?

The article compares Go and Java across history, concurrency, performance, ecosystem and developer experience, examines why Japan, not China, has produced influential languages, notes emerging Chinese language projects, and offers concrete paths for engineers to deepen their low‑level technical understanding.

Asia Tech CultureConcurrencyGo
0 likes · 16 min read
Go vs Java and the Mystery of China’s Missing Programming Language: What’s the Real Technical Gap?
Yumin Fish Harvest
Yumin Fish Harvest
Aug 18, 2026 · Backend Development

Distributed Snowflake ID Generation in Java: Hutool and MyBatis-Plus Demo

This article walks through the Snowflake algorithm for distributed ID generation, detailing its timestamp, workerId and sequence fields, handling clock rollback and sequence overflow, and provides a complete Java implementation with integration examples for Hutool and MyBatis‑Plus, including configuration and test code.

HutoolJavaMyBatis Plus
0 likes · 28 min read
Distributed Snowflake ID Generation in Java: Hutool and MyBatis-Plus Demo
Architect's Guide
Architect's Guide
Aug 18, 2026 · Backend Development

Boost CRUD Development Speed 100× with This Open‑Source Code Generator

Manually creating entity classes, CRUD interfaces and SQL for dozens of tables can consume dozens of hours, so the author built an open‑source tool that automatically generates the full backend stack—from table definition to Java models, MyBatis mappers, services and controllers—dramatically accelerating development.

BackendCRUDJava
0 likes · 17 min read
Boost CRUD Development Speed 100× with This Open‑Source Code Generator
Coder Trainee
Coder Trainee
Aug 17, 2026 · Operations

Uncovering the Truth Behind Connection Reset: A Network Timeout Investigation

This article explains the differences among Connection reset, Read timed out, and Connect timed out, outlines typical causes for each, provides step‑by‑step Linux command checks, Java Spring Boot configuration examples, a real‑world case study, and a quick‑reference cheat sheet for troubleshooting network timeouts.

JavaLinuxNetwork
0 likes · 8 min read
Uncovering the Truth Behind Connection Reset: A Network Timeout Investigation
Dabaoshi
Dabaoshi
Aug 17, 2026 · Fundamentals

Concurrency 07: Understanding Deadlocks and Thread‑Safety Strategies

This article explains how deadlocks arise from four necessary conditions, shows how to detect them with jstack, outlines practical ways to prevent deadlock, distinguishes livelock and starvation, and presents three prioritized approaches—immutability, thread confinement, and synchronization—to achieve thread safety in Java.

ConcurrencyDeadlockImmutable
0 likes · 16 min read
Concurrency 07: Understanding Deadlocks and Thread‑Safety Strategies
Yumin Fish Harvest
Yumin Fish Harvest
Aug 17, 2026 · Backend Development

How to Implement Distributed ID Generation with Segment Mode? A Double‑Buffer Issuer in Practice

The article analyses lock contention caused by per‑request ID generation, derives a segment‑based solution that batches IDs using a configurable step, defines a left‑closed/right‑open interval schema in MySQL, and builds a double‑buffer Java issuer with asynchronous pre‑loading, thorough concurrency handling, testing, and configuration guidelines.

ConcurrencyJavaMySQL
0 likes · 21 min read
How to Implement Distributed ID Generation with Segment Mode? A Double‑Buffer Issuer in Practice
Java Architecture Diary
Java Architecture Diary
Aug 17, 2026 · Artificial Intelligence

Pure Java OCR with mica-ppocr: How It Parses Documents and Invoices

This article details the pure‑Java mica‑ppocr library built on Java 17 and ONNX Runtime, covering its rapid version evolution, core engine upgrades, structured parsing of six document types, Spring Boot and Solon integration, performance optimizations, and architectural refactors, providing a comprehensive technical overview for developers.

JavaOCRONNX Runtime
0 likes · 12 min read
Pure Java OCR with mica-ppocr: How It Parses Documents and Invoices
Ray's Galactic Tech
Ray's Galactic Tech
Aug 16, 2026 · Backend Development

Ditch Seata: Build a Production‑Ready SAGA Orchestrator with a 500‑Line Java State Machine

This article shows how to replace heavyweight distributed‑transaction frameworks such as Seata with a lightweight, production‑grade SAGA orchestrator built from a Java state machine, MySQL persistence and Spring Boot, covering architecture, state‑machine design, database schema, core orchestration logic, recovery, exception handling and practical deployment tips.

JavaSagaSpring Boot
0 likes · 46 min read
Ditch Seata: Build a Production‑Ready SAGA Orchestrator with a 500‑Line Java State Machine
Dabaoshi
Dabaoshi
Aug 16, 2026 · Backend Development

AQS Deep Dive: How Java’s AbstractQueuedSynchronizer Powers Concurrency

This article dissects Java’s AbstractQueuedSynchronizer (AQS), explaining its three core components—volatile state, CAS, and a FIFO wait queue—how exclusive and shared modes operate, the step‑by‑step lock acquisition flow, ReentrantLock implementation details, fairness trade‑offs, and the underlying template‑method design pattern.

AQSConcurrencyJava
0 likes · 15 min read
AQS Deep Dive: How Java’s AbstractQueuedSynchronizer Powers Concurrency
Dabaoshi
Dabaoshi
Aug 16, 2026 · Fundamentals

CAS and Java Atomic Classes Explained: Mechanics, Pitfalls, and LongAdder

This article demystifies Java's Compare‑And‑Swap (CAS) instruction, shows how atomic classes like AtomicInteger achieve lock‑free increments, discusses CAS's three main drawbacks, surveys the entire java.util.concurrent.atomic family, and explains how LongAdder improves high‑contention counting.

Atomic ClassesCASConcurrency
0 likes · 15 min read
CAS and Java Atomic Classes Explained: Mechanics, Pitfalls, and LongAdder
CTO Full-Stack Academy
CTO Full-Stack Academy
Aug 16, 2026 · Fundamentals

Mastering Maven: A Complete Guide to Java Build Management

This article explains Maven's role as a Java project manager, covering its core concepts, lifecycle, repositories, plugins, scopes, inheritance, practical setup steps, common use cases, advantages, drawbacks, real‑world project examples, and typical pitfalls.

JavaMavenbuild automation
0 likes · 17 min read
Mastering Maven: A Complete Guide to Java Build Management