BestHub
Sign in
Tagged articles
5000 articles
Page 50 of 50
Ops Development Stories
Ops Development Stories
Nov 9, 2023 · Operations

How to Pinpoint Java Out‑Of‑Memory Errors Using jmap and VisualVM

This guide explains why frequent garbage collection and heap memory overflow occur in Java applications, demonstrates how to reproduce the issue with a sample program, and walks through various techniques—including jmap histograms, heap dumps, VisualVM analysis, and remote JMX monitoring—to diagnose and resolve out‑of‑memory errors.

Garbage CollectionHeap DumpJava
0 likes · 9 min read
How to Pinpoint Java Out‑Of‑Memory Errors Using jmap and VisualVM
Selected Java Interview Questions
Selected Java Interview Questions
Nov 8, 2023 · Fundamentals

Most Popular Java Features Added Since Java 8 (Up to Java 20)

This article reviews the most widely adopted Java language enhancements introduced after Java 8, covering features such as local variable type inference, switch expressions, text blocks, records, pattern matching for instanceof, sealed classes, and improved NullPointerException messages, helping developers decide which upgrades to adopt.

JavaJava 8backend
0 likes · 6 min read
Most Popular Java Features Added Since Java 8 (Up to Java 20)
Architecture Digest
Architecture Digest
Nov 8, 2023 · Backend Development

Comparing Spring Boot and Quarkus: Performance, Native Images, and Migration Guide

This article compares the Spring Boot and Quarkus Java frameworks by examining their architectures, running reactive test applications, measuring startup time, memory usage, CPU consumption and response latency for both JVM and native builds, and provides practical guidance for migrating Spring developers to Quarkus.

JavaKubernetesNative Images
0 likes · 16 min read
Comparing Spring Boot and Quarkus: Performance, Native Images, and Migration Guide
Java High-Performance Architecture
Java High-Performance Architecture
Nov 8, 2023 · Backend Development

Build a Java SpringBoot Electronic Signature & Seal System: Full Source Code & Deployment Guide

This article walks through the design and implementation of a Java SpringBoot‑based electronic signature and seal system, covering the underlying concepts of digital signatures, the complete project structure, key controller and service code, utility classes, deployment steps, and a step‑by‑step functional demo with screenshots.

DocumentWorkflowElectronicSignatureJava
0 likes · 15 min read
Build a Java SpringBoot Electronic Signature & Seal System: Full Source Code & Deployment Guide
Architect's Guide
Architect's Guide
Nov 8, 2023 · Backend Development

Introduction to TLog: Enterprise‑Level Microservice Log Tracing and Integration Guide

This article introduces TLog, a zero‑intrusion Java logging library that adds globally unique trace IDs, SpanId and upstream/downstream tags to microservice logs, outlines its key features, multiple integration modes, configuration examples for Log4j and async logging, and shows how to use it with Spring Boot, Spring Native and task frameworks like XXL‑JOB.

JavaSpringBootTLog
0 likes · 8 min read
Introduction to TLog: Enterprise‑Level Microservice Log Tracing and Integration Guide
JD Retail Technology
JD Retail Technology
Nov 7, 2023 · Backend Development

Practical Cases of Using ChatGPT for Backend Development Tasks

This document presents a series of real‑world examples showing how ChatGPT can assist cloud‑trading developers with backend tasks such as resource scheduling, regex interpretation, CSV generation, JavaBean‑to‑JSON conversion, Spring IoC learning, JSON formatting, Java 8 stream processing, and CI pipeline error analysis.

CSVChatGPTJava
0 likes · 5 min read
Practical Cases of Using ChatGPT for Backend Development Tasks
Selected Java Interview Questions
Selected Java Interview Questions
Nov 7, 2023 · Backend Development

Implementing Distributed Locks with Redis: Principles, Challenges, and Optimizations

This article explains why traditional local locks fail in distributed systems, surveys common distributed‑lock approaches, and provides a step‑by‑step guide to building a robust Redis‑based lock in Java—including expiration handling, UUID safety, Lua‑script atomicity, re‑entrancy, automatic renewal, and the RedLock algorithm—while comparing its performance against plain local locks.

JavaLuaRedis
0 likes · 17 min read
Implementing Distributed Locks with Redis: Principles, Challenges, and Optimizations
Su San Talks Tech
Su San Talks Tech
Nov 7, 2023 · Backend Development

Why Adding Thread Pools in Business Logic Often Hurts Performance

Although many developers avoid using thread pools in business code, this article explains how thread pools already exist in web containers and RPC frameworks, why inserting custom pools can backfire, and when proper tuning or message queues are the better solution for improving throughput.

DubboJavabackend
0 likes · 10 min read
Why Adding Thread Pools in Business Logic Often Hurts Performance
IT Services Circle
IT Services Circle
Nov 7, 2023 · Backend Development

Understanding ThreadLocal Memory Leaks and How to Prevent Them

This article explains the internal structure of ThreadLocal, identifies scenarios where ThreadLocal can cause memory leaks—especially in thread‑pool environments—analyzes the root causes, and provides practical techniques such as using remove() and expungeStaleEntry() to avoid these leaks.

Garbage CollectionJavaMemory Leak
0 likes · 11 min read
Understanding ThreadLocal Memory Leaks and How to Prevent Them
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 7, 2023 · Backend Development

Essential Java Libraries Every Senior Developer Should Know

This article presents a curated list of essential Java libraries—including JUnit, Mockito, Jackson, Gson, SLF4J, Log4j2, Apache Commons, Guava, JAXB, Xerces, Apache POI, JavaAssist, Cglib, Eclipse Collections, Trove, Jsoup, Apache MINA, Netty, Lombok, and Testcontainers—explaining their purposes and why senior developers should master them.

Backend DevelopmentJavalibraries
0 likes · 9 min read
Essential Java Libraries Every Senior Developer Should Know
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 7, 2023 · Backend Development

Master Spring Validation in Spring Boot 2.6: From Basics to Custom Annotations

This guide explains Spring Validation in Spring Boot 2.6, covering its lightweight features, configuration of Bean Validation providers, injection of validators, practical examples, custom annotation creation, method‑level validation, and additional configuration options with clear code samples.

Backend DevelopmentBean ValidationCustom Annotations
0 likes · 8 min read
Master Spring Validation in Spring Boot 2.6: From Basics to Custom Annotations
Architect
Architect
Nov 6, 2023 · Backend Development

Unveiling MyBatis: A Deep Dive into Its Architecture and Execution Flow

This article provides a comprehensive, step‑by‑step analysis of MyBatis’s overall architecture, covering its core features, three‑layer design, configuration parsing, proxy generation, SQL execution process, and the underlying components that enable seamless Java‑to‑SQL mapping.

Backend DevelopmentJavaMyBatis
0 likes · 11 min read
Unveiling MyBatis: A Deep Dive into Its Architecture and Execution Flow
macrozheng
macrozheng
Nov 6, 2023 · Backend Development

Mastering MyBatis PageHelper: Avoid Common Pagination Pitfalls

This article explains the core principles and multiple usage patterns of MyBatis PageHelper for pagination, demonstrates code examples, details its internal ThreadLocal and interceptor mechanisms, and highlights common pitfalls with safe versus unsafe practices to ensure reliable data retrieval.

JavaMyBatispagehelper
0 likes · 9 min read
Mastering MyBatis PageHelper: Avoid Common Pagination Pitfalls
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 6, 2023 · Fundamentals

Fundamental OOP Concepts and Design Patterns in Java

This article explains core object‑oriented concepts such as encapsulation, abstraction, inheritance and polymorphism, then details common design principles and a wide range of design patterns—including factory, builder, bridge, singleton, strategy, adapter, and proxy—illustrated with complete Java code examples and usage guidelines.

AdapterDesign PatternsFactory
0 likes · 23 min read
Fundamental OOP Concepts and Design Patterns in Java
Java Architect Essentials
Java Architect Essentials
Nov 5, 2023 · Fundamentals

19 Real‑World Bad Code Snippets Every Developer Should Avoid

This article curates 19 genuinely terrible code fragments collected from various developers, illustrating common pitfalls such as magic numbers, poorly named variables, misuse of booleans, and overly complex switch statements, and encourages readers to reflect on and learn from these mistakes.

Javabad codecode smells
0 likes · 8 min read
19 Real‑World Bad Code Snippets Every Developer Should Avoid
FunTester
FunTester
Nov 5, 2023 · Backend Development

Why java.util.UUID.randomUUID Can Block Threads and How to Fix It

The article explains how java.util.UUID.randomUUID relies on OS entropy, can block threads when entropy is low, shows a real‑world thread‑dump example, and provides three remedies: upgrading the JDK, installing haveged, or switching to /dev/urandom.

BlockingJDKJava
0 likes · 5 min read
Why java.util.UUID.randomUUID Can Block Threads and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
Nov 5, 2023 · Backend Development

Design and Implementation of a High‑Performance Distributed Reconciliation System for Large‑Scale Payment Orders

This article presents a comprehensive design of a distributed reconciliation system that handles tens of millions of daily payment orders by using a six‑module architecture, Kafka for decoupled state transitions, Hive for large‑scale data processing, and Java‑based plug‑in patterns to achieve six‑nine accuracy and significant operational cost savings.

Big DataDistributed SystemsHive
0 likes · 15 min read
Design and Implementation of a High‑Performance Distributed Reconciliation System for Large‑Scale Payment Orders
Su San Talks Tech
Su San Talks Tech
Nov 5, 2023 · Backend Development

Master Parameter & Business Rule Validation in SpringBoot Using Custom Bean Validation

Learn how to implement both simple parameter checks and complex business rule validations in SpringBoot by leveraging Bean Validation, creating custom annotations like @UniqueUser and @NotConflictUser, and integrating them seamlessly into controllers to ensure data integrity and reduce boilerplate logic.

Backend DevelopmentBean ValidationBusiness Rule Validation
0 likes · 9 min read
Master Parameter & Business Rule Validation in SpringBoot Using Custom Bean Validation
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 5, 2023 · Backend Development

How to Fully Customize Spring MVC Core Components for Flexible Web Apps

This guide walks through creating custom Spring MVC core components—including DispatcherServlet, HandlerMapping, HandlerAdapter, and ViewResolver—using annotations and Java code to gain full control over request handling, parameter resolution, and response rendering in backend development.

Backend DevelopmentCustom HandlerMappingHandlerAdapter
0 likes · 10 min read
How to Fully Customize Spring MVC Core Components for Flexible Web Apps
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 4, 2023 · Fundamentals

Understanding the Composite Reuse Principle (CRP): Concepts, Benefits, UML, and Implementation Examples

This article provides a comprehensive explanation of the Composite Reuse Principle (CRP), covering its definition, background, advantages over inheritance, UML representation, practical Java code examples, and guidelines for choosing between composition and inheritance in object‑oriented design.

Code ReuseComposite Reuse PrincipleComposition over Inheritance
0 likes · 11 min read
Understanding the Composite Reuse Principle (CRP): Concepts, Benefits, UML, and Implementation Examples
Su San Talks Tech
Su San Talks Tech
Nov 4, 2023 · Fundamentals

Unlock Java’s Secrets: How Bytecode Powers Cross‑Platform Execution

This article introduces Java’s bytecode fundamentals, explaining how the JVM translates compiled class files into platform‑independent instructions, the role of dynamic linking, stack frames, operand stacks, and common bytecode mnemonics, while providing code examples and visual diagrams to deepen understanding.

JVMJavadynamic linking
0 likes · 17 min read
Unlock Java’s Secrets: How Bytecode Powers Cross‑Platform Execution
Architect's Guide
Architect's Guide
Nov 4, 2023 · Backend Development

Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping

This article explains how to reduce repetitive Java backend code by extracting common logic into abstract classes, applying the Template Method and Factory patterns, using custom annotations with reflection for API serialization, and leveraging bean‑mapping utilities to copy properties between DTOs and DOs.

Code RefactoringDesign PatternsJava
0 likes · 21 min read
Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 4, 2023 · Backend Development

Essential Java Libraries Every Advanced Developer Should Know

This guide presents a curated list of essential Java libraries—including testing, JSON, logging, utility, XML, Excel, bytecode, collections, HTML parsing, encryption, embedded databases, serialization, networking, Lombok, and Testcontainers—that can dramatically improve productivity and code quality for backend development.

Backend DevelopmentJSONJava
0 likes · 8 min read
Essential Java Libraries Every Advanced Developer Should Know
Programmer DD
Programmer DD
Nov 3, 2023 · Backend Development

Why Java Remains Dominant: Insights from the 2023 State of Java Survey

The 2023 State of Java report, based on a survey of over 2,000 Java professionals, reveals that Java adoption stays strong with most companies using LTS versions, migrating to the cloud, confronting rising costs and security challenges, while Oracle's market share declines in favor of OpenJDK alternatives.

JavaOpenJDKOracle
0 likes · 5 min read
Why Java Remains Dominant: Insights from the 2023 State of Java Survey
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 3, 2023 · Backend Development

Unlock Massive Concurrency in Java with Virtual Threads and Structured Concurrency

This article introduces Java virtual threads, compares them with traditional platform threads, demonstrates multiple creation and execution patterns, showcases performance benefits through code examples, and explains structured concurrency as a preview feature for building high‑throughput, scalable backend applications.

JavaSpring BootThread Pools
0 likes · 15 min read
Unlock Massive Concurrency in Java with Virtual Threads and Structured Concurrency
DaTaobao Tech
DaTaobao Tech
Nov 3, 2023 · Fundamentals

Mastering the Strategy Pattern: From Simple IF‑ELSE to Scalable Design

This article explains why hard‑coded if‑else logic hinders extensibility, introduces the Strategy pattern, shows its structure and Java implementation for data synchronization, then enhances the design with a Factory to decouple object creation, concluding with best‑practice recommendations.

Design PatternsFactory PatternJava
0 likes · 8 min read
Mastering the Strategy Pattern: From Simple IF‑ELSE to Scalable Design
Architect's Guide
Architect's Guide
Nov 3, 2023 · Databases

Performance Evaluation of Inserting Hundreds of Millions of Records into MySQL Using Java, MyBatis, and JDBC

This article experimentally compares three Java‑based insertion strategies—MyBatis without transaction, plain JDBC with and without transaction, and JDBC batch processing—with and without transactions, measuring how they affect the time required to insert tens of millions of rows into MySQL.

Batch ProcessingDatabase OptimizationJDBC
0 likes · 13 min read
Performance Evaluation of Inserting Hundreds of Millions of Records into MySQL Using Java, MyBatis, and JDBC
Code Ape Tech Column
Code Ape Tech Column
Nov 3, 2023 · Backend Development

Diagnosing Excessive Native Memory Usage in a Spring Boot Application Using JVM Native Memory Tracking and System Tools

After migrating a project to the MDP framework based on Spring Boot, the author observed swap overuse and physical memory far exceeding the 4 GB heap; using JVM native memory tracking, gperftools, strace, pmap, and a custom allocator, they traced a native‑memory leak to Spring Boot’s ZipInflaterInputStream during JAR scanning and resolved it by limiting scan paths.

JVMJavaMemory Leak
0 likes · 12 min read
Diagnosing Excessive Native Memory Usage in a Spring Boot Application Using JVM Native Memory Tracking and System Tools
Architect
Architect
Nov 2, 2023 · Backend Development

Understanding RocketMQ Consumer Scaling and MessageQueue Allocation Strategies

This article explains when adding consumers to a RocketMQ topic improves message consumption, the reasons for consumer pull delays, and details six MessageQueue allocation strategies—including average, round‑robin, custom, machine‑room, nearby, and consistent‑hash—accompanied by code examples.

JavaMessageQueueRocketMQ
0 likes · 11 min read
Understanding RocketMQ Consumer Scaling and MessageQueue Allocation Strategies
Top Architect
Top Architect
Nov 2, 2023 · Big Data

Understanding Distributed Systems and Kafka: Concepts, Architecture, and Ensuring Ordered Message Consumption

This article introduces the fundamentals of distributed systems, provides an overview of Apache Kafka’s architecture and core components, explains how Kafka ensures message ordering within partitions, and outlines Java‑based strategies to guarantee ordered consumption, including single‑partition consumption, partition assignment, and key‑based partitioning.

Big DataJavaKafka
0 likes · 10 min read
Understanding Distributed Systems and Kafka: Concepts, Architecture, and Ensuring Ordered Message Consumption
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 2, 2023 · Databases

Strategies for Efficiently Importing One Billion Records into MySQL

This article analyzes the constraints of loading one billion 1 KB log records from distributed storage into MySQL, evaluates single‑table limits, proposes batch‑insert, sharding, storage‑engine, file‑reading, and distributed‑task coordination techniques to achieve high‑speed, ordered, and reliable data ingestion.

Batch InsertJavaPerformance
0 likes · 18 min read
Strategies for Efficiently Importing One Billion Records into MySQL
TAL Education Technology
TAL Education Technology
Nov 2, 2023 · Backend Development

Java CompletableFuture: Creation, Asynchronous Callbacks, Composition, and Thread‑Pool Configuration

This article explains Java's CompletableFuture utility introduced in Java 8, covering its creation methods, asynchronous callback functions, exception handling, task composition, combination operators, underlying implementation details, and best practices for configuring thread pools to achieve efficient concurrent execution.

AsyncCompletableFutureJava
0 likes · 32 min read
Java CompletableFuture: Creation, Asynchronous Callbacks, Composition, and Thread‑Pool Configuration
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 2, 2023 · Fundamentals

Understanding the Proxy Design Pattern with Java Examples

This article explains the Proxy design pattern, illustrates its core participants with clear Chinese idiom analogies, and provides a complete static‑proxy implementation in Java—including interface, real subject, proxy class, and client code—while also noting the distinction between static and dynamic proxies.

Design PatternsJavaProxy Pattern
0 likes · 6 min read
Understanding the Proxy Design Pattern with Java Examples
macrozheng
macrozheng
Nov 2, 2023 · Fundamentals

When to Use List.of vs Arrays.asList in Java: Immutable vs Mutable Lists Explained

This article compares Java's List.of() and Arrays.asList() methods, detailing their immutable versus mutable characteristics, handling of nulls, size constraints, and underlying array behavior, and provides practical code examples and guidance on choosing the appropriate method for different programming scenarios.

Arrays.asListCollectionsImmutable List
0 likes · 7 min read
When to Use List.of vs Arrays.asList in Java: Immutable vs Mutable Lists Explained
政采云技术
政采云技术
Nov 2, 2023 · Information Security

Design and Implementation of a Multi‑System Data Permission Control System

This article describes a unified, configurable data‑permission framework built on RBAC, detailing its architecture, rule definition, integration workflow, Java SDK implementation, and practical examples to achieve flexible, low‑coupling access control across multiple backend systems.

Access ControlData PermissionJava
0 likes · 11 min read
Design and Implementation of a Multi‑System Data Permission Control System
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 2, 2023 · Backend Development

Rethinking Global Exception Handling in SpringBoot Applications

This article examines the pitfalls of using SpringBoot's @ControllerAdvice and @ExceptionHandler for global exception handling, illustrates common issues across controller, service, and data layers, and proposes more precise logging and debugging strategies to improve error traceability and maintainability.

DebuggingJavaSpringBoot
0 likes · 7 min read
Rethinking Global Exception Handling in SpringBoot Applications
Java Architect Essentials
Java Architect Essentials
Nov 1, 2023 · Backend Development

Understanding Java 8 Optional API: Methods, Usage, and Practical Examples

This article explains how Java 8's Optional class helps avoid NullPointerException by providing a fluent API—including ofNullable, empty, orElse, map, flatMap, filter, and other methods—along with concrete code examples that demonstrate refactoring traditional null‑check logic into concise, functional style.

Code RefactoringFunctional ProgrammingJava
0 likes · 10 min read
Understanding Java 8 Optional API: Methods, Usage, and Practical Examples
Architect
Architect
Nov 1, 2023 · Backend Development

Mastering Distributed Locks with Redis: From Basics to Advanced Solutions

This article examines why local locks fail in distributed micro‑service environments, introduces Redis‑based distributed locking, walks through five incremental lock designs—from a simple SETNX implementation to a Lua‑script atomic solution—highlighting each scheme's trade‑offs, code examples, and practical pitfalls.

JavaLuaMicroservices
0 likes · 18 min read
Mastering Distributed Locks with Redis: From Basics to Advanced Solutions
DaTaobao Tech
DaTaobao Tech
Nov 1, 2023 · Fundamentals

Understanding the Chain of Responsibility Design Pattern

The Chain of Responsibility pattern links a series of handler objects so that a request can be passed along until one processes it, decoupling sender and receiver, supporting dynamic composition, runtime flexibility, and the Open/Closed principle, as illustrated by a Java leave‑approval workflow.

Chain of ResponsibilityCode ExampleJava
0 likes · 12 min read
Understanding the Chain of Responsibility Design Pattern
Java Architecture Diary
Java Architecture Diary
Nov 1, 2023 · Backend Development

Boost Your IoT Apps with mica-mqtt: A Low‑Latency Java AIO MQTT Engine

The article introduces mica-mqtt, a Java AIO‑based open‑source MQTT component offering simple, low‑latency, high‑performance IoT messaging, outlines its extensive feature set, typical use cases, recent updates, and provides detailed configuration examples for custom business thread pools and Spring Boot integration.

AIOIoTJava
0 likes · 6 min read
Boost Your IoT Apps with mica-mqtt: A Low‑Latency Java AIO MQTT Engine
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 1, 2023 · Backend Development

Mastering Spring Event Mechanism: Custom Events, Listeners, Async & Ordering

This article introduces Spring's event mechanism, covering the creation of custom ApplicationEvent classes, implementing listeners via ApplicationListener and @EventListener annotations, publishing events, using @Async for asynchronous handling, configuring custom event multicaster, and controlling listener execution order with @Order, complete with code examples.

AsynchronousEventJava
0 likes · 9 min read
Mastering Spring Event Mechanism: Custom Events, Listeners, Async & Ordering
Java Architect Essentials
Java Architect Essentials
Oct 31, 2023 · Information Security

Understanding Traditional Session Mechanisms, Cluster Session Challenges, and SSO Solutions with CAS and OAuth2

The article explains why multiple independent systems hurt user experience, reviews traditional session and cookie based authentication, discusses session sharing problems in clustered environments, and presents centralized Redis storage and CAS‑based single sign‑on solutions with code examples and a comparison to OAuth2.

CASJavaOAuth2
0 likes · 16 min read
Understanding Traditional Session Mechanisms, Cluster Session Challenges, and SSO Solutions with CAS and OAuth2
JD Cloud Developers
JD Cloud Developers
Oct 31, 2023 · Backend Development

How SpringBoot Auto‑Configuration Works and Build Your Own Logging Starter

This article explains SpringBoot’s auto‑configuration mechanism, walks through the DispatcherServlet example, and demonstrates how to build a custom logging starter—including annotation, properties class, AOP aspect, auto‑configuration class, Maven packaging, and usage—showcasing the efficiency and reusability benefits for backend developers.

Backend DevelopmentCustom StarterJava
0 likes · 9 min read
How SpringBoot Auto‑Configuration Works and Build Your Own Logging Starter
Architecture Digest
Architecture Digest
Oct 31, 2023 · Backend Development

Performance Troubleshooting and Optimization of a ToB System: From Low Throughput to Improved CPU Utilization

This article documents a step‑by‑step investigation of a Java Spring backend that initially achieved only 50 requests per second under load, detailing how slow SQL, excessive logging, thread‑pool misconfiguration, bean‑creation overhead and CPU‑bound operations were identified and mitigated to roughly double the throughput while reducing response latency.

JavaOptimizationProfiling
0 likes · 14 min read
Performance Troubleshooting and Optimization of a ToB System: From Low Throughput to Improved CPU Utilization
Java High-Performance Architecture
Java High-Performance Architecture
Oct 31, 2023 · Backend Development

Master Redisson Distributed Locks in Java: Features, Code & Spring Boot

This article introduces Redisson, a Java framework built on Redis for distributed systems, detailing its extensive features such as distributed objects, locks, rate limiters, and task scheduling, and provides step‑by‑step guidance on integrating Redisson’s distributed lock into Spring Boot applications with code examples.

JavaRedisRedisson
0 likes · 11 min read
Master Redisson Distributed Locks in Java: Features, Code & Spring Boot
政采云技术
政采云技术
Oct 31, 2023 · Fundamentals

Understanding Java Threads, Thread Models, and Scheduling

This article explains what threads are, how Java maps its threads to operating‑system thread models (1:1, N:1, N:M), the differences between kernel and user threads, thread scheduling, context switching, priority handling, and includes sample Java code to compare serial and multithreaded execution.

JavaThreadsconcurrency
0 likes · 19 min read
Understanding Java Threads, Thread Models, and Scheduling
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 31, 2023 · Backend Development

Mastering Custom Formatter SPI in Spring Boot 2.6.12

This guide explains how to use Spring's Formatter SPI and AnnotationFormatterFactory to create, register, and test custom type converters and annotation‑based formatters in a Spring Boot 2.6.12 application, complete with code samples and endpoint demonstrations.

AnnotationFormatterFactoryFormatter SPIJava
0 likes · 8 min read
Mastering Custom Formatter SPI in Spring Boot 2.6.12
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 30, 2023 · Databases

Easy-Es Tutorial: Simplify Elasticsearch Operations with a Java ORM Framework

This article introduces Easy-Es, a Java ORM framework built on Elasticsearch's RestHighLevelClient that simplifies query construction and CRUD operations, provides step‑by‑step setup including Maven dependencies, configuration, entity and mapper definitions, controller examples, and advanced features such as condition builders, index management, logging, and aggregation queries.

CRUDEasy-EsElasticsearch
0 likes · 8 min read
Easy-Es Tutorial: Simplify Elasticsearch Operations with a Java ORM Framework
Su San Talks Tech
Su San Talks Tech
Oct 30, 2023 · Backend Development

Boost Backend Performance with HashMap, LinkedHashMap, TreeMap & ByteBuffer

This article explores four powerful yet understated caching techniques—HashMap with read‑write locks, LinkedHashMap‑based LRU caches, TreeMap for consistent hashing, and ByteBuffer pooling—detailing their implementations in middleware such as RocketMQ, MyBatis, and Cobar to enhance backend performance.

Backend DevelopmentByteBufferConcurrentHashMap
0 likes · 10 min read
Boost Backend Performance with HashMap, LinkedHashMap, TreeMap & ByteBuffer
Java Architect Essentials
Java Architect Essentials
Oct 27, 2023 · Backend Development

Design and Implementation of Delayed Task Solutions for Payment Systems

This article compares delayed and scheduled tasks, analyzes several implementation approaches—including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET and key‑space notifications, and RabbitMQ delayed queues—provides code examples, and discusses the advantages and drawbacks of each method for handling order timeout scenarios in payment systems.

JavaQuartzRedis
0 likes · 17 min read
Design and Implementation of Delayed Task Solutions for Payment Systems
JD Tech
JD Tech
Oct 27, 2023 · Backend Development

Design and Implementation of JD's Unified Header/Footer Management System

The article describes the design background, overall architecture, management backend, and header/footer client implementations (Nginx and Java) of JD's unified header/footer management system, explaining how it enables rapid, centralized updates of site-wide header and footer content across hundreds of services.

Javabackendfooter
0 likes · 14 min read
Design and Implementation of JD's Unified Header/Footer Management System
Selected Java Interview Questions
Selected Java Interview Questions
Oct 27, 2023 · Backend Development

Diagnosing and Optimizing Throughput and CPU Usage in a Java Spring Backend Service

The article details a step‑by‑step investigation of a Java Spring backend that initially achieved only 50 req/s under load, identifies bottlenecks such as slow SQL, excessive logging, thread‑pool misconfiguration and costly Spring bean creation, and demonstrates how targeted optimizations roughly doubled throughput while reducing response times.

CPUJavaOptimization
0 likes · 14 min read
Diagnosing and Optimizing Throughput and CPU Usage in a Java Spring Backend Service
Architecture Digest
Architecture Digest
Oct 27, 2023 · Backend Development

10 Essential Java Stream API Tips and Best Practices

This article presents ten practical tips for using the Java Stream API effectively, covering primitive streams for performance, avoiding nested streams, careful use of parallel streams, lazy evaluation, side‑effect avoidance, immutability, proper ordering of filter and map, method references, distinct, and sorted operations, each illustrated with concise code examples.

Best PracticesFunctional ProgrammingJava
0 likes · 7 min read
10 Essential Java Stream API Tips and Best Practices
Java Backend Technology
Java Backend Technology
Oct 27, 2023 · Backend Development

How I Reduced Helios API Latency from Seconds to Milliseconds with Arthas

This article details a step‑by‑step performance tuning of the Helios scoring API, showing how profiling with Arthas revealed costly date formatting and list operations, and how successive code refactors—changing data structures, eliminating redundant object creation, and optimizing loops—cut the response time from several seconds to just a few dozen milliseconds.

ArthasBackend DevelopmentJava
0 likes · 29 min read
How I Reduced Helios API Latency from Seconds to Milliseconds with Arthas
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 27, 2023 · Backend Development

Applying the Chain of Responsibility Pattern in Spring MVC Interceptors

This article explains how the Chain of Responsibility design pattern is implemented within Spring MVC interceptors, detailing the request flow, interceptor lifecycle methods, and practical differences from the classic GoF definition, while also exploring other typical use cases of the pattern.

Backend DevelopmentChain of ResponsibilityInterceptor
0 likes · 10 min read
Applying the Chain of Responsibility Pattern in Spring MVC Interceptors
Selected Java Interview Questions
Selected Java Interview Questions
Oct 26, 2023 · Backend Development

Apache ShenYu: Reactive Java API Gateway Overview and Quick Start Guide

Apache ShenYu is a high‑performance, reactive Java API gateway offering dynamic traffic control, hot‑plug plugins, multi‑protocol support, observability, and easy deployment, with detailed module descriptions, quick Docker‑based startup commands, selector and rule routing concepts, and data synchronization mechanisms.

Apache ShenYuDockerJava
0 likes · 6 min read
Apache ShenYu: Reactive Java API Gateway Overview and Quick Start Guide
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 26, 2023 · Backend Development

Using Java Lambda Expressions to Simplify Collection Operations

This article explains how Java lambda expressions and the Stream API can replace verbose loops, comparators, and aggregation code with concise, readable functional constructs, covering traversal, sorting, aggregation, optional handling, thread creation, mapping, grouping, and parallel processing of collections.

CollectionsFunctional ProgrammingJava
0 likes · 10 min read
Using Java Lambda Expressions to Simplify Collection Operations
Code Ape Tech Column
Code Ape Tech Column
Oct 26, 2023 · Information Security

OpenAPI Security Practices: AppId/AppSecret, Signature Generation, and Implementation Guide

This article explains how to use OpenAPI standards to secure API interfaces by introducing AppId/AppSecret mechanisms, RSA‑based signatures, timestamp and nonce anti‑replay measures, and provides complete Java code examples for client‑side signing and server‑side verification along with common protection techniques such as rate limiting and data validation.

AppIdAppSecretJava
0 likes · 28 min read
OpenAPI Security Practices: AppId/AppSecret, Signature Generation, and Implementation Guide
FunTester
FunTester
Oct 26, 2023 · Fundamentals

Mastering Java Locks: Reentrant, Synchronized, ReadWrite, and Spin Locks Explained

This article provides a comprehensive guide to Java locking mechanisms, covering ReentrantLock, synchronized, ReadWriteLock, and spin locks, with detailed code examples, performance considerations, common use cases, and best practices to ensure thread safety, avoid deadlocks, and optimize concurrency in multithreaded applications.

JavaLocksReadWriteLock
0 likes · 17 min read
Mastering Java Locks: Reentrant, Synchronized, ReadWrite, and Spin Locks Explained
Java Architect Essentials
Java Architect Essentials
Oct 25, 2023 · Fundamentals

Comprehensive Guide to Using Debug in IntelliJ IDEA

This article provides a detailed tutorial on leveraging IntelliJ IDEA's Debug mode, covering UI components, basic shortcuts, variable inspection, expression evaluation, smart step‑into, breakpoint conditions, multithreaded debugging, frame dropping, interrupting execution, and JRebel activation for efficient Java development.

IDEIntelliJ IDEAJava
0 likes · 17 min read
Comprehensive Guide to Using Debug in IntelliJ IDEA
Sohu Tech Products
Sohu Tech Products
Oct 25, 2023 · Backend Development

Deep Analysis of Netty FastThreadLocal: From Production Issue to Source Code Implementation

The article traces a production bug where unreleased JDK ThreadLocal data corrupted user info, then compares JDK ThreadLocal with Netty’s FastThreadLocal, detailing their source‑code implementations, performance trade‑offs (O(n) vs O(1) access), memory‑leak risks, and recommends explicit remove() calls to avoid leaks.

Backend DevelopmentFastThreadLocalJava
0 likes · 15 min read
Deep Analysis of Netty FastThreadLocal: From Production Issue to Source Code Implementation
vivo Internet Technology
vivo Internet Technology
Oct 25, 2023 · Backend Development

Optimizing Dubbo Routing and Load Balancing at Scale: Vivo's Practice

Vivo tackled high CPU overhead in large‑scale Dubbo deployments by disabling unused routers, caching routing results with BitMap intersections and epoch validation, optimizing weight calculations, and adding a grouping router, which together delivered over 100 % TPS gains for 20 k+ providers and cut CPU usage by roughly 27 %.

Backend ArchitectureCache OptimizationDubbo
0 likes · 18 min read
Optimizing Dubbo Routing and Load Balancing at Scale: Vivo's Practice
Programmer DD
Programmer DD
Oct 25, 2023 · Backend Development

Why G1 Garbage Collector Beats CMS in Java 7+

The G1 Garbage Collector, introduced in Java 7 update 4, replaces CMS by using a region‑based design that minimizes pause times and improves throughput, and a detailed video with diagrams and code examples is provided to deepen understanding of its operation.

Backend DevelopmentGarbage CollectionJVM
0 likes · 2 min read
Why G1 Garbage Collector Beats CMS in Java 7+
JD Cloud Developers
JD Cloud Developers
Oct 25, 2023 · Backend Development

Master Kafka: Core Concepts, Architecture, and Practical Tips

This article explains Kafka's fundamentals, including topics, partitions, brokers, replication, producer‑consumer workflow, consumer groups, offset management, and common exception handling, while providing code examples and diagrams to help developers understand and effectively use this distributed messaging system.

Distributed SystemsJavaKafka
0 likes · 21 min read
Master Kafka: Core Concepts, Architecture, and Practical Tips
Architecture Digest
Architecture Digest
Oct 25, 2023 · Information Security

RBAC Permission Analysis and Spring Security Implementation Guide (including JWT and JSON Login)

This article explains the fundamentals of Role‑Based Access Control (RBAC), its model variants, permission concepts, and user‑group usage, then demonstrates practical Spring Security setups ranging from simple in‑memory authentication to JWT integration, JSON‑based login, password encryption, and database‑backed authentication with full code examples.

Access ControlAuthorizationJava
0 likes · 18 min read
RBAC Permission Analysis and Spring Security Implementation Guide (including JWT and JSON Login)