BestHub
Sign in
Tagged articles
5000 articles
Page 41 of 50
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.

Backend DevelopmentInheritance DiagramIntelliJ IDEA
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.

BackendJDFrameJava
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.

JavaSpring Bootmicroservices
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.

CompactConstructorJDK14Java
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.

Backend DevelopmentDynamic Rate LimitingElasticsearch
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.

IDEAJavaMaven
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.

Backend DevelopmentElasticsearchJava
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.

AOPAsyncConcurrency
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.

ConcurrencyDistributedLockJava
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.

HadoopJavaMemory Leak
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.

DSLFastJSONHutool
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.

Backend DevelopmentJavaReflection
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.

EnvironmentJavaType Conversion
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.

AsynchronousBackendJava
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.

GeometryJTSJava
0 likes · 3 min read
How to Write, Convert, and Read WKB Data with JTS in Java
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 OptimizationJava
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.

DebuggingIDE TipsIntelliJ IDEA
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.

ComponentJavaannotations
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.

DatabaseJavaLocalDateTime
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 CollectionJavaSATB
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.

JavaUTF-8Unicode
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.

Backend DevelopmentBeanPostProcessorExtension Interfaces
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.

Best PracticesCode OptimizationDesign Patterns
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.

AsynchronousBackendJava
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.

ExtensionInstrumentationJava
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.

InterfaceJavaService Layer
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.

Backend DevelopmentCQRSDDD
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.

Backend DevelopmentConcurrencyJava
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.

Backend DevelopmentJavaMyBatis
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.

ConcurrencyExecutorServiceJava
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 LoadingJavaNacos
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.

Backend DevelopmentHashMapJava
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.

ConcurrencyHashMapInterview
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 PluginJavaMyBatis-Plus
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 OrchestrationJavaLiteFlow
0 likes · 13 min read
Integrating LiteFlow with Spring Boot for Decoupled, Dynamic, Scalable Business Logic
DaTaobao Tech
DaTaobao Tech
Apr 12, 2024 · Backend Development

HSF (High‑speed Service Framework) Overview and Usage Guide

HSF (High‑speed Service Framework) is Alibaba’s high‑performance SOA solution that decouples monolithic applications via non‑blocking RPC, offering service discovery, dynamic routing, grouping, and both synchronous and asynchronous calls, configurable serialization, timeout, and thread pools, and employing patterns such as proxy, chain‑of‑responsibility, observer and decorator.

Design PatternsHSFJava
0 likes · 22 min read
HSF (High‑speed Service Framework) Overview and Usage Guide
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 12, 2024 · Backend Development

Master Spring Boot Externalized Config: Locations, Overrides & Advanced Options

This guide explains how Spring Boot 3.1.10 discovers and loads external configuration files from classpath and filesystem locations, how to customize file names and paths with spring.config.name, spring.config.location, and spring.config.additional-location, and demonstrates merging, profile-specific files, optional prefixes, wildcards, imports, and handling missing resources.

Backend DevelopmentExternalized ConfigurationJava
0 likes · 11 min read
Master Spring Boot Externalized Config: Locations, Overrides & Advanced Options
Eric Tech Circle
Eric Tech Circle
Apr 11, 2024 · Artificial Intelligence

Build a Generative AI RAG App with Spring AI in Minutes

This guide walks you through setting up Spring AI, configuring model providers and vector stores, initializing a Spring Boot project, adding OpenAI credentials, and running a complete RAG (Retrieval‑Augmented Generation) demo with code snippets and sample API calls.

JavaOpenAIRAG
0 likes · 15 min read
Build a Generative AI RAG App with Spring AI in Minutes
Architecture Digest
Architecture Digest
Apr 11, 2024 · Backend Development

Cool Request: A Free Open‑Source IDEA Plugin for Simplifying SpringBoot Backend API Testing

This article introduces Cool Request, a free open‑source IntelliJ IDEA plugin that automatically extracts SpringBoot controllers, simplifies HTTP request debugging, supports multiple request bodies, pre‑ and post‑scripts, reflection calls, cURL import, Apifox export, global API search, and even provides a static resource server.

API testingCool RequestHTTP request
0 likes · 7 min read
Cool Request: A Free Open‑Source IDEA Plugin for Simplifying SpringBoot Backend API Testing
High Availability Architecture
High Availability Architecture
Apr 11, 2024 · Backend Development

Understanding Netty's Core Architecture, I/O Models, Memory Management, and High‑Performance Components

This article provides a comprehensive overview of Netty's core layers, protocol support, transport services, logical architecture, various I/O models, packet framing techniques, custom protocol design, write‑and‑flush behavior, off‑heap memory management, and high‑performance data structures such as FastThreadLocal and HashedTimerWheel.

IO ModelJavaNetty
0 likes · 26 min read
Understanding Netty's Core Architecture, I/O Models, Memory Management, and High‑Performance Components
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Apr 11, 2024 · Backend Development

Why OpenFeign Misinterprets Dates and How to Fix It

When converting Date parameters in OpenFeign calls, the client serializes them to strings using the local CST timezone, causing a 14‑hour discrepancy that can be resolved by using timestamps, @DateTimeFormat, or custom formatters on both client and server sides.

FeignClientJavaOpenFeign
0 likes · 10 min read
Why OpenFeign Misinterprets Dates and How to Fix It
Java Architect Essentials
Java Architect Essentials
Apr 10, 2024 · Information Security

Implementing JWT‑Based Authentication and RBAC with Spring Security in a Spring Boot Application

This article demonstrates how to integrate JWT token authentication and role‑based access control (RBAC) into a Spring Boot backend using Spring Security, covering model classification, dependency setup, user details implementation, token utilities, filters, configuration, and login handling with code examples.

Backend DevelopmentJavaRBAC
0 likes · 15 min read
Implementing JWT‑Based Authentication and RBAC with Spring Security in a Spring Boot Application
Sohu Tech Products
Sohu Tech Products
Apr 10, 2024 · Big Data

Bloom Filter: Principles, False Positive Rate, and Implementations with Guava and Redis

Bloom filters are space‑efficient probabilistic structures that answer “definitely not” or “maybe” membership queries, with a controllable false‑positive rate derived from bit array size, element count, and hash functions, and can be implemented via Guava’s Java library, Redisson’s Redis wrapper, native Redis modules, or custom bitmap code, dramatically reducing memory usage and latency in large‑scale systems such as URL deduplication or user‑product checks.

Big DataGuavaJava
0 likes · 21 min read
Bloom Filter: Principles, False Positive Rate, and Implementations with Guava and Redis
vivo Internet Technology
vivo Internet Technology
Apr 10, 2024 · Databases

Analysis of Redis Pipeline Support in Spring Boot with Lettuce and Redisson Clients

The article examines how Spring Boot’s Lettuce and Redisson clients implement Redis pipelining, explains the batch‑request principle, benchmarks 100 000 set inserts showing pipeline speeds of 0.5–1.4 seconds versus 162 seconds for single commands, demonstrates Spring Data Redis callback usage, warns of high‑cost command pitfalls, and details Redisson’s RBatch internals, concluding that pipelining dramatically boosts throughput when command costs are modest.

JavaLettuceRedis
0 likes · 27 min read
Analysis of Redis Pipeline Support in Spring Boot with Lettuce and Redisson Clients
Code Ape Tech Column
Code Ape Tech Column
Apr 10, 2024 · Backend Development

Understanding and Comparing Java, Spring, and Dubbo SPI Mechanisms

This article explains the concept of Service Provider Interface (SPI), demonstrates how Java's ServiceLoader, Spring's SpringFactoriesLoader, and Dubbo's ExtensionLoader implement SPI, compares their configurations and capabilities, and discusses advanced features such as adaptive extensions, IOC/AOP integration, wrappers, and auto‑activation.

Backend DevelopmentDubboExtensionLoader
0 likes · 15 min read
Understanding and Comparing Java, Spring, and Dubbo SPI Mechanisms
FunTester
FunTester
Apr 10, 2024 · Backend Development

Why Caffeine’s Default Scheduler Skips Expired Eviction and How to Enable It

This article explains why Caffeine’s default scheduler (disabledScheduler) does not trigger RemovalListener on expired entries, details the three cache cleanup strategies, compares the four built‑in schedulers, and shows how to configure a functional scheduler with code examples.

CacheCaffeineJava
0 likes · 9 min read
Why Caffeine’s Default Scheduler Skips Expired Eviction and How to Enable It
Java Architect Essentials
Java Architect Essentials
Apr 9, 2024 · Backend Development

Implementing Data Isolation in Java Applications Using MyBatis Interceptor and Custom Annotations

This article describes a Java data isolation solution that adds an 'env' field to tables, uses a MyBatis interceptor to rewrite SQL for environment‑aware queries, and introduces custom annotations with AOP to selectively skip environment checks, detailing implementation, challenges, and best practices.

AOPBackendCustom Annotation
0 likes · 13 min read
Implementing Data Isolation in Java Applications Using MyBatis Interceptor and Custom Annotations
dbaplus Community
dbaplus Community
Apr 9, 2024 · Backend Development

Building a Scalable Order‑to‑Elasticsearch Sync Service (ECP)

This article explains the challenges of synchronizing billions of order records to Elasticsearch, outlines the design of the ECP service that automates heterogeneous data integration, and details its implementation including multi‑source reading, SQL parsing, dynamic rate limiting, retry mechanisms, SPI‑based extensibility, environment isolation, health‑check, smooth migration, and logging.

ElasticsearchJavaSPI
0 likes · 19 min read
Building a Scalable Order‑to‑Elasticsearch Sync Service (ECP)
JavaEdge
JavaEdge
Apr 9, 2024 · Fundamentals

What’s New in IntelliJ IDEA 2024.1? Full‑Line Completion, Java 22 Support and More

IntelliJ IDEA 2024.1 introduces full‑line code completion powered by a local deep‑learning model, Java 22 language support, a revamped terminal, sticky lines in the editor, enhanced Maven handling, improved debugging, richer Spring assistance, advanced HTTP client features, and new database tools, all aimed at boosting developer productivity and safety.

DebuggingIDE FeaturesIntelliJ IDEA
0 likes · 15 min read
What’s New in IntelliJ IDEA 2024.1? Full‑Line Completion, Java 22 Support and More
IT Services Circle
IT Services Circle
Apr 9, 2024 · Backend Development

ByteDance Backend Interview Experience: Key Topics and Knowledge Points

This article shares a detailed ByteDance backend interview experience covering three rounds, summarizing essential topics such as Java HashMap internals, Spring circular dependencies, MySQL indexing, OS process/thread concepts, networking protocols, TLS handshake, HTTP/2 features, and common design patterns, providing concise explanations and practical tips.

BackendDesign PatternsInterview
0 likes · 25 min read
ByteDance Backend Interview Experience: Key Topics and Knowledge Points
Selected Java Interview Questions
Selected Java Interview Questions
Apr 9, 2024 · Backend Development

Applying the Chain of Responsibility Pattern for Multi‑Level Product Validation and Workflow in Java

This article explains the Chain of Responsibility design pattern, demonstrates its use for multi‑step product validation and a reimbursement workflow in Java with Spring, provides UML diagrams, configuration handling, concrete handler implementations, client execution code, and discusses the pattern’s advantages and drawbacks.

BackendChain of ResponsibilityJava
0 likes · 18 min read
Applying the Chain of Responsibility Pattern for Multi‑Level Product Validation and Workflow in Java
Java Tech Enthusiast
Java Tech Enthusiast
Apr 9, 2024 · Backend Development

Understanding Spring DI: @Autowired vs @Resource and Field Injection Pitfalls

Spring supports constructor, setter, and field injection, but field injection is discouraged; @Autowired (Spring‑specific, by‑type) and @Resource (standard, by‑name) differ in defaults and IDE warnings, so prefer constructor injection for required beans, setter injection for optional ones, and only use @Resource for unavoidable field injection to lessen container coupling.

AutowiredJavadependency-injection
0 likes · 5 min read
Understanding Spring DI: @Autowired vs @Resource and Field Injection Pitfalls
Programmer DD
Programmer DD
Apr 9, 2024 · Backend Development

What’s New in Java 22? Explore 12 Key Features and Their Benefits

Java 22 introduces twelve enhancements—including seven preview and one incubator features—spanning language syntax, APIs, performance, and tooling, with detailed explanations of each JEP’s purpose, value, and impact on developer productivity and code readability.

Backend DevelopmentJDK 22JEP
0 likes · 15 min read
What’s New in Java 22? Explore 12 Key Features and Their Benefits
Architect
Architect
Apr 8, 2024 · Backend Development

Mastering Batch Processing: Boost API Performance and Cut Overhead

This guide explains why batch processing is essential for API tuning and provides step‑by‑step techniques—including bulk database operations, request merging, pagination, parallel execution, caching, and monitoring—backed by concrete Java code samples and SQL queries to help engineers dramatically improve throughput and latency.

API optimizationBatch processingCaching
0 likes · 33 min read
Mastering Batch Processing: Boost API Performance and Cut Overhead
DeWu Technology
DeWu Technology
Apr 8, 2024 · Operations

Analyzing and Optimizing ZooKeeper WatchManager Memory Usage

By replacing ZooKeeper’s default WatchManager hash‑set tables with concurrent maps and bitmap‑based structures, the authors cut watch‑related heap usage from several gigabytes to under 12 MB, lowered lock contention, and achieved 5‑6× latency gains, delivering up to 91 % memory reduction and ten‑fold SLA improvement in production clusters.

JavaMemory OptimizationWatchManager
0 likes · 13 min read
Analyzing and Optimizing ZooKeeper WatchManager Memory Usage
Java Tech Enthusiast
Java Tech Enthusiast
Apr 8, 2024 · Industry Insights

What’s New in IntelliJ IDEA 2024.1? A Deep Dive into the Latest Features

IntelliJ IDEA 2024.1 introduces full line code completion, enhanced Java 22 support, a revamped terminal with visual enhancements, sticky lines in the editor, improved indexing for Java and Kotlin, scalable UI, language injection in string templates, upgraded logging workflow, and a redesigned Conflicts Detected dialog.

2024.1Developer ToolsIDE
0 likes · 6 min read
What’s New in IntelliJ IDEA 2024.1? A Deep Dive into the Latest Features
Architecture Digest
Architecture Digest
Apr 8, 2024 · Backend Development

Design and Implementation of a Flexible Java Download Library for Spring MVC/WebFlux

This article introduces a Java library that simplifies file and resource download handling in Spring MVC and WebFlux by using annotations, reactive programming, customizable handlers, source factories, concurrent loading, compression, response writing, and event‑driven logging to support a wide range of download scenarios.

BackendDownloadFile Compression
0 likes · 15 min read
Design and Implementation of a Flexible Java Download Library for Spring MVC/WebFlux
Java High-Performance Architecture
Java High-Performance Architecture
Apr 8, 2024 · Backend Development

Dynamic Multi-DataSource Switching & Transaction Management in Spring

This article explores solutions for managing multiple data sources in a Spring application, covering dynamic routing with AbstractRoutingDataSource, configuration‑file and database‑table approaches, AOP‑based source switching, and custom multi‑transaction handling to ensure consistency across heterogeneous databases.

JavaMulti-Database Transactionabstractroutingdatasource
0 likes · 15 min read
Dynamic Multi-DataSource Switching & Transaction Management in Spring
Architect's Guide
Architect's Guide
Apr 8, 2024 · Backend Development

Why HikariCP Is So Fast: A Deep Dive into Its Implementation

This article examines why HikariCP, the default Spring Boot 2.0 connection pool, achieves high performance by exploring its design concepts such as dual HikariPool instances, FastList, custom ConcurrentBag, thread‑local caching, and bytecode optimization, and includes sample Maven configuration and Java code.

ConcurrencyConnection PoolHikariCP
0 likes · 14 min read
Why HikariCP Is So Fast: A Deep Dive into Its Implementation
Code Ape Tech Column
Code Ape Tech Column
Apr 7, 2024 · Backend Development

WebSocket Load‑Balancing Concept for Microservice Architectures

This article explains the challenges of using WebSocket in a microservice environment, introduces a load‑balancing library that forwards messages between service instances, shows how to enable it with Spring annotations, and details the underlying connection, subscription, and selector mechanisms for reliable message routing.

JavaMessage Routingload balancing
0 likes · 12 min read
WebSocket Load‑Balancing Concept for Microservice Architectures
FunTester
FunTester
Apr 7, 2024 · Backend Development

Generating Globally Unique Identifiers (GUID) for Performance Testing: UUID, Distributed Services, Snowflake Algorithm, and Thread‑Local Techniques

This article explains why globally unique identifiers are needed in performance testing, compares several common solutions such as Java UUID, Redis/Zookeeper distributed ID generators, the Snowflake algorithm, and thread‑local or shared counters, and provides complete Java code examples for each approach.

Distributed SystemsGUIDJava
0 likes · 13 min read
Generating Globally Unique Identifiers (GUID) for Performance Testing: UUID, Distributed Services, Snowflake Algorithm, and Thread‑Local Techniques
MaGe Linux Operations
MaGe Linux Operations
Apr 6, 2024 · Backend Development

Boost Tomcat Performance: Essential JVM and Connector Tuning Tips

This guide explains why Tomcat’s default settings are unsuitable for production, then walks through JVM memory tuning, thread‑pool adjustments, connector optimizations, and security hardening to dramatically improve stability and throughput on various server configurations.

JVM tuningJavaTomcat
0 likes · 12 min read
Boost Tomcat Performance: Essential JVM and Connector Tuning Tips