BestHub
Sign in
Tagged articles

Java

5000 articles · Page 37 of 50
Architecture Digest
Architecture Digest
Dec 4, 2024 · Fundamentals

Avoid the Hidden Pitfall of Arrays.asList(): Fixed‑Length List and UnsupportedOperationException

This article explains why using Java's Arrays.asList to convert an array into a List can cause UnsupportedOperationException when modifying the list, illustrates the underlying implementation details, and provides a safe solution using java.util.ArrayList to prevent serious runtime failures.

Arrays.asListJavaUnsupportedOperationException
0 likes · 9 min read
Avoid the Hidden Pitfall of Arrays.asList(): Fixed‑Length List and UnsupportedOperationException
Top Architect
Top Architect
Dec 4, 2024 · Fundamentals

Comprehensive Guide to IntelliJ IDEA Debugging Features

This article provides a detailed walkthrough of IntelliJ IDEA's debugging capabilities, covering preparation, main interface components, step controls, variable inspection, conditional breakpoints, expression evaluation, frame dropping, force return, multithreaded and stream debugging, as well as remote debugging techniques, supplemented by a Java code example.

DebuggingDevelopment ToolsIDE
0 likes · 18 min read
Comprehensive Guide to IntelliJ IDEA Debugging Features
FunTester
FunTester
Dec 4, 2024 · Backend Development

Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools

This article explains why the standard Executors factory methods may be insufficient, details each ThreadPoolExecutor constructor parameter, demonstrates how to configure a custom pool for performance testing, and walks through multiple code examples that illustrate thread creation, queue behavior, and rejection policies.

ConcurrencyJavaJava concurrency
0 likes · 14 min read
Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools
Architect
Architect
Dec 3, 2024 · Information Security

How to Secure Third‑Party APIs with AK/SK, Signatures, and Token Strategies

This guide presents a comprehensive design for securing third‑party API calls, covering Access Key/Secret Key generation, permission granularity, timestamp and nonce based replay protection, signature creation and verification, token handling, TLS encryption, rate limiting, logging, and practical Java code examples.

API securityAccess KeyJava
0 likes · 28 min read
How to Secure Third‑Party APIs with AK/SK, Signatures, and Token Strategies
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 3, 2024 · Fundamentals

Unraveling Java’s ClassLoader: From Parent Delegation to Custom Loading

This article explores Java's class loading mechanism in depth, covering when and how classes are loaded, the parent‑delegation model, the internal role of ClassFileParser and InstanceKlass, parallel loading nuances, and practical ways to break or extend the delegation chain with custom class loaders.

ClassLoaderCustomClassLoaderInstanceKlass
0 likes · 17 min read
Unraveling Java’s ClassLoader: From Parent Delegation to Custom Loading
Java Tech Enthusiast
Java Tech Enthusiast
Dec 3, 2024 · Backend Development

Spring Boot 3.4 Upgrade Guide: Major Changes and Features

Spring Boot 3.4 adds automatic multi‑client RestClient configuration, Bean‑Validation‑based property checks, default graceful shutdown, ECS/GELF/Logstash structured logging, enhanced observability with application grouping and OTLP tracing, upgraded core and third‑party dependencies, AssertJ‑enabled MockMvc testing, and replaces old management endpoint settings with access‑based properties.

ConfigurationJavaLogging
0 likes · 6 min read
Spring Boot 3.4 Upgrade Guide: Major Changes and Features
JD Cloud Developers
JD Cloud Developers
Dec 3, 2024 · Backend Development

How to Slash SpringBoot Startup Time by 60%: Proven Optimization Techniques

This article details a comprehensive set of optimizations that reduced a SpringBoot application's startup time from 400‑500 seconds to about 130‑150 seconds, covering Actuator monitoring, Tomcat TLD scan disabling, HBase asynchronous warm‑up, custom BeanPostProcessor timing, JSF consumer proxy refactoring, Tomcat version impacts, and hardware upgrades.

Backend DevelopmentBeanPostProcessorJava
0 likes · 22 min read
How to Slash SpringBoot Startup Time by 60%: Proven Optimization Techniques
JD Tech Talk
JD Tech Talk
Dec 3, 2024 · Backend Development

Optimizing SpringBoot Application Startup Time: Diagnosis, BeanPostProcessor Tweaks, and Asynchronous JSF Consumer Initialization

This article documents the systematic analysis and multi‑step optimization of a SpringBoot application's slow startup, covering profiling with Actuator, Tomcat TLD scan disabling, HBase async warm‑up, custom BeanPostProcessor timing, and asynchronous JSF consumer initialization to cut launch time by over 60 percent.

BeanPostProcessorJavaPerformance
0 likes · 21 min read
Optimizing SpringBoot Application Startup Time: Diagnosis, BeanPostProcessor Tweaks, and Asynchronous JSF Consumer Initialization
macrozheng
macrozheng
Dec 3, 2024 · Backend Development

Master Spring Boot 3.4: Key Changes, New Features, and Migration Guide

This comprehensive guide explores Spring Boot 3.4’s performance boosts, enhanced observability, and developer experience improvements, detailing major changes such as RestClient/RestTemplate auto‑configuration, bean validation updates, graceful shutdown, structured logging formats, observability enhancements, dependency upgrades, testing enhancements, and deprecated feature handling, with practical code snippets.

Backend DevelopmentConfigurationJava
0 likes · 9 min read
Master Spring Boot 3.4: Key Changes, New Features, and Migration Guide
Java Architect Essentials
Java Architect Essentials
Dec 2, 2024 · Backend Development

Dynamic Loading of JAR Files in Spring Boot Applications

This article provides a comprehensive guide on dynamically loading JAR packages in Spring Boot, covering core concepts, benefits, and step‑by‑step implementations using SpringBootClassLoader and third‑party OSGi libraries, complete with practical code examples.

Backend DevelopmentClassLoaderDynamic JAR Loading
0 likes · 8 min read
Dynamic Loading of JAR Files in Spring Boot Applications
Architect
Architect
Dec 2, 2024 · Backend Development

Mastering Java Agents: Premain vs Attach for Bytecode Manipulation

This article explains how Java agents work, compares premain and attach agents, shows how to implement entry points, use Instrumentation and Javassist to transform bytecode, provides complete code samples, packaging instructions, and demonstrates the runtime output with diagrams.

AgentAttachBytecode
0 likes · 17 min read
Mastering Java Agents: Premain vs Attach for Bytecode Manipulation
Zhuanzhuan Tech
Zhuanzhuan Tech
Dec 2, 2024 · Fundamentals

Understanding Fair and Unfair Locks in Java's ReentrantLock

This article explains the concepts, creation methods, usage examples, and internal implementation details of fair and unfair locks in Java's ReentrantLock, comparing their performance characteristics and providing guidance on when to choose each type in multithreaded applications.

ConcurrencyFairLockJava
0 likes · 23 min read
Understanding Fair and Unfair Locks in Java's ReentrantLock
Code Ape Tech Column
Code Ape Tech Column
Dec 2, 2024 · Backend Development

Creating an Enterprise‑Grade OSS Object Storage Spring Boot Starter Based on Amazon S3

This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts object storage services (OSS) via the Amazon S3 protocol, covering dependency selection, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing for cloud‑native backend applications.

Amazon S3JavaOSS
0 likes · 15 min read
Creating an Enterprise‑Grade OSS Object Storage Spring Boot Starter Based on Amazon S3
Architect's Guide
Architect's Guide
Dec 2, 2024 · Backend Development

Implementing QR‑Code Login with WebSocket in Spring Boot

This article explains how to design a QR‑code login flow, create the necessary database table, define the required APIs, and integrate front‑end JavaScript with a Spring Boot back‑end using WebSocket to notify the client of successful authentication.

JavaQR Code LoginSpring Boot
0 likes · 13 min read
Implementing QR‑Code Login with WebSocket in Spring Boot
FunTester
FunTester
Dec 2, 2024 · Fundamentals

Mastering Java Thread Pools: Fixed vs. Cached Executors Explained

This article explains Java thread pools, their performance benefits, and how to create and use FixedThreadPool and CachedThreadPool via the Executors utility, providing code examples, execution results, and guidance on selecting the appropriate pool for different concurrency scenarios.

CachedThreadPoolConcurrencyFixedThreadPool
0 likes · 12 min read
Mastering Java Thread Pools: Fixed vs. Cached Executors Explained
Top Architect
Top Architect
Dec 1, 2024 · Backend Development

Diagnosing Slow Asynchronous Log Printing in Java: From Mapping Overhead to Disruptor and JNI Analysis

This article investigates why a large number of quality‑check mappings cause severe latency in a Java service, traces the slowdown to excessive asynchronous log printing, explains the Disruptor‑based async logger internals, evaluates stack‑trace location handling and JNI overhead, and proposes practical configuration and code‑level fixes.

DisruptorJNIJava
0 likes · 20 min read
Diagnosing Slow Asynchronous Log Printing in Java: From Mapping Overhead to Disruptor and JNI Analysis
Java Tech Enthusiast
Java Tech Enthusiast
Dec 1, 2024 · Fundamentals

LeetCode 34: Binary Search Range

LeetCode 34 asks for the first and last indices of a target in a non‑decreasing integer array, returning [-1,-1] when absent, and can be solved in O(log n) time by applying two binary‑search passes—one locating the leftmost occurrence and the other the rightmost—illustrated with Java, C++, and Python implementations.

C++JavaLeetCode
0 likes · 8 min read
LeetCode 34: Binary Search Range
Su San Talks Tech
Su San Talks Tech
Dec 1, 2024 · Backend Development

Master Elegant Parameter Validation in Spring Boot with Hibernate Validator

This article explains why manual if‑statement checks are problematic, introduces Spring Boot's built‑in validation using Hibernate Validator annotations, shows how to handle errors globally, and covers advanced techniques such as group validation and custom constraint annotations for clean, maintainable backend code.

Hibernate ValidatorJavaSpring Boot
0 likes · 12 min read
Master Elegant Parameter Validation in Spring Boot with Hibernate Validator
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 1, 2024 · Backend Development

Optimizing Million-Row Excel Export with EasyExcel: Design, Implementation, and Performance Tuning

This article presents a comprehensive guide to efficiently exporting millions of rows to Excel using EasyExcel, covering performance bottlenecks, resource consumption, asynchronous processing, thread‑pool design, batch querying, streaming writes, and practical code examples to achieve fast, memory‑friendly report generation.

EasyExcelExcel exportJava
0 likes · 35 min read
Optimizing Million-Row Excel Export with EasyExcel: Design, Implementation, and Performance Tuning
Code Ape Tech Column
Code Ape Tech Column
Nov 30, 2024 · Cloud Native

Implementing Distributed Authentication in Spring Cloud Alibaba Using Custom Annotations

This article demonstrates how to move authentication from the gateway to downstream microservices in a Spring Cloud Alibaba setup by disabling the gateway’s ReactiveAuthorizationManager, defining three custom security annotations, creating an AOP aspect to enforce them, and showing practical usage examples with role‑based access control and Feign calls.

AOPAuthenticationJava
0 likes · 9 min read
Implementing Distributed Authentication in Spring Cloud Alibaba Using Custom Annotations
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 30, 2024 · Backend Development

Understanding Nacos Service Registration and Discovery in Spring Cloud Microservices

This article explains the fundamentals and implementation of a Nacos service registry in a Spring Cloud microservice architecture, covering registration concepts, building a standalone Nacos server, creating provider and consumer services, and deep-diving into the underlying registration code and HTTP interactions.

DiscoveryJavaNacos
0 likes · 15 min read
Understanding Nacos Service Registration and Discovery in Spring Cloud Microservices
Zhuanzhuan Tech
Zhuanzhuan Tech
Nov 29, 2024 · Operations

Why Use Prometheus and How It Guarantees Business System Stability

This article explains the motivations for adopting Prometheus, introduces its core components and metric types, and demonstrates how comprehensive monitoring of business‑critical data, failure events, QPS, latency, and underlying resources can improve system stability and accelerate fault response.

Javaprometheussystem stability
0 likes · 13 min read
Why Use Prometheus and How It Guarantees Business System Stability
Top Architect
Top Architect
Nov 29, 2024 · Backend Development

Diagnosing High Memory Usage in Spring Boot Applications and Tuning JVM Parameters

This article details a real‑world case where Spring Boot microservices on a 64 GB server consumed excessive memory, explains how to diagnose the issue using jps and jmap, discusses default JVM heap settings, and provides practical recommendations for tuning JVM parameters to prevent similar problems.

BackendDevelopmentJVMJava
0 likes · 8 min read
Diagnosing High Memory Usage in Spring Boot Applications and Tuning JVM Parameters
Selected Java Interview Questions
Selected Java Interview Questions
Nov 29, 2024 · Databases

12 MyBatis‑Plus Optimization Tips for Efficient Database Operations

This article presents twelve practical MyBatis‑Plus optimization techniques—including avoiding isNull checks, specifying select fields, batch operations, using EXISTS, safe ordering, type‑safe Lambda queries, handling nulls, performance tracking, enum mapping, logical deletion, optimistic locking, and increment/decrement methods—to improve code readability, maintainability, and database query performance.

JavaMybatisPlusORM
0 likes · 14 min read
12 MyBatis‑Plus Optimization Tips for Efficient Database Operations
Architecture Digest
Architecture Digest
Nov 29, 2024 · Backend Development

Dynamic Service Provider Switching with Spring Smart DI

This article explains how to implement runtime switching of multiple service providers in a Spring‑based backend by configuring the active implementation in a central store and using the spring‑smart‑di library's AutowiredProxySPI to inject the appropriate bean automatically.

Dynamic ConfigurationJavaSpring
0 likes · 7 min read
Dynamic Service Provider Switching with Spring Smart DI
Java Backend Technology
Java Backend Technology
Nov 29, 2024 · Backend Development

Why Does submit() Hide Exceptions in Java Thread Pools? Uncover the Truth

This article explains why tasks submitted with submit() in a Java thread pool silently swallow exceptions, contrasts it with execute(), and presents three practical solutions—including try‑catch, a default UncaughtExceptionHandler, and overriding afterExecute—to reliably capture and handle those errors.

Javaexception handlingexecutorservice
0 likes · 14 min read
Why Does submit() Hide Exceptions in Java Thread Pools? Uncover the Truth
JD Retail Technology
JD Retail Technology
Nov 29, 2024 · Fundamentals

Java Code Style Guidelines: Importance, Standards, and Tool Integration

This article explains why Java code style standards are essential for team collaboration, reviews major guidelines such as Google Java Style and Alibaba's p3c, and provides step‑by‑step instructions for configuring IntelliJ IDEA, Checkstyle, and Maven to enforce consistent, readable, and maintainable Java code.

Code styleIntelliJ IDEAJava
0 likes · 13 min read
Java Code Style Guidelines: Importance, Standards, and Tool Integration
JD Tech
JD Tech
Nov 28, 2024 · Fundamentals

Comprehensive Guide to Unit Testing Strategies and Tools for Java Projects

This article presents a detailed, step‑by‑step guide on improving unit test coverage in large Java codebases, covering strategies such as mocking, divide‑and‑conquer, tool‑assisted test generation, reflection‑based coverage, Maven configuration, and practical tips for handling static methods, final classes, and test data replay.

JUnitJavaMockito
0 likes · 27 min read
Comprehensive Guide to Unit Testing Strategies and Tools for Java Projects
IT Services Circle
IT Services Circle
Nov 28, 2024 · Backend Development

When to Quit Your Job and What a 2‑Year Java Developer Should Know

The article offers practical advice on deciding whether to resign without a new job, emphasizing health, financial stability, and mindset, and then outlines the essential technical knowledge and interview expectations for Java developers with around two years of experience.

Javacareer advicejob resignation
0 likes · 14 min read
When to Quit Your Job and What a 2‑Year Java Developer Should Know
Top Architect
Top Architect
Nov 28, 2024 · Backend Development

Comprehensive Maven Tutorial: Basic Configuration, Dependency Management, Module Setup, Plugin Usage, and Build Settings

This article provides a thorough step‑by‑step guide to using Maven for Java backend projects, covering repository configuration, basic POM structure, dependency inclusion and exclusion, module management, unified dependency handling, essential plugins such as jar, assembly and shade, and detailed build settings with code examples.

Backend DevelopmentBuild ToolsDependency Management
0 likes · 24 min read
Comprehensive Maven Tutorial: Basic Configuration, Dependency Management, Module Setup, Plugin Usage, and Build Settings
Top Architect
Top Architect
Nov 28, 2024 · Backend Development

A Comprehensive Guide to Java Enums: Basics, Advanced Usage, and Design Patterns

This article explains Java enums introduced in Java 5, shows how to define simple and complex enum types, demonstrates their use in comparisons, switch statements, collections like EnumSet and EnumMap, and illustrates applying enums to design patterns such as Singleton and Strategy, while providing practical code examples and JSON serialization techniques.

CollectionsDesign PatternsEnum
0 likes · 16 min read
A Comprehensive Guide to Java Enums: Basics, Advanced Usage, and Design Patterns
Selected Java Interview Questions
Selected Java Interview Questions
Nov 28, 2024 · Backend Development

Key Considerations and Best Practices for Using Spring Event in Backend Systems

This article explains critical pitfalls and best‑practice guidelines for employing Spring Event in Java backend applications, covering graceful shutdown requirements, event loss during startup, suitable business scenarios, reliability enhancements, retry mechanisms, idempotency, and the relationship between Spring Event and message queues.

JavaRetrySpring
0 likes · 12 min read
Key Considerations and Best Practices for Using Spring Event in Backend Systems
Architecture Digest
Architecture Digest
Nov 28, 2024 · Backend Development

Automatic Insertion of UserId and OrderId into Logs Using Spring AOP and MDC

This article explains how to automatically embed userId and orderId into log statements by defining log placeholders, storing these values in MDC via ThreadLocal, and using a custom @UserLog annotation together with Spring AOP to inject the data before method execution, complete with configuration and test examples.

AOPAnnotationJava
0 likes · 8 min read
Automatic Insertion of UserId and OrderId into Logs Using Spring AOP and MDC
Java Architect Essentials
Java Architect Essentials
Nov 28, 2024 · Backend Development

Comprehensive Guide to Maven: Basic Configuration, Dependency Management, Module Management, and Plugin Usage

This article provides a detailed tutorial on Maven, covering its basic configuration, repository setup, dependency management (including scopes, exclusions, and version variables), multi‑module organization, unified dependency management, and common build plugins such as jar, assembly, and shade, with complete code examples and explanations.

Build ToolsDependency ManagementJava
0 likes · 22 min read
Comprehensive Guide to Maven: Basic Configuration, Dependency Management, Module Management, and Plugin Usage
Su San Talks Tech
Su San Talks Tech
Nov 28, 2024 · Backend Development

Unified Asynchronous Notification Verification Using Custom Spring MVC Argument Resolvers

The article explains how to encapsulate asynchronous notification signature verification in Spring MVC by creating a custom annotation and argument resolver, discusses why aspects and @RequestBody are unsuitable, and presents an alternative unified notification handling design using a service interface and dynamic implementation loading.

AnnotationJavacustom argument resolver
0 likes · 9 min read
Unified Asynchronous Notification Verification Using Custom Spring MVC Argument Resolvers
FunTester
FunTester
Nov 28, 2024 · Backend Development

Java Multithreading Implementations

This article explains three common ways to create multithreaded Java programs—extending Thread, implementing Runnable, and using Lambda expressions—providing step‑by‑step instructions, code samples, console output, and a summary of each method’s advantages and appropriate use cases.

JavaLambdaRunnable
0 likes · 6 min read
Java Multithreading Implementations
vivo Internet Technology
vivo Internet Technology
Nov 27, 2024 · Backend Development

Implementation Principles of Distributed Locks with Redis and Zookeeper

Distributed locks synchronize multiple services across nodes, and can be implemented using Redis’s fast, AP‑oriented SET‑NX with automatic TTL renewal or Zookeeper’s CP‑oriented ephemeral sequential nodes, each offering distinct trade‑offs in performance, consistency, and suitability for various workload requirements.

CAP theoremJavaRedis
0 likes · 24 min read
Implementation Principles of Distributed Locks with Redis and Zookeeper
Top Architect
Top Architect
Nov 27, 2024 · Information Security

Understanding RBAC and Implementing Spring Security with JWT in Java

This article explains the concepts and models of Role‑Based Access Control (RBAC), demonstrates how to configure RBAC permissions in Spring Security, and provides step‑by‑step Java code for integrating JWT authentication, password encryption, and custom login filters for secure backend development.

Backend DevelopmentJWTJava
0 likes · 18 min read
Understanding RBAC and Implementing Spring Security with JWT in Java
Selected Java Interview Questions
Selected Java Interview Questions
Nov 27, 2024 · Backend Development

Designing a Flexible Permission Control System with Java Annotations and Spring AOP

This article explains how to build a scalable, maintainable permission control framework in Java by defining custom annotations, designing relational database tables, and using Spring AOP to intercept method calls for organization‑level, personal, limit, and special‑role checks, while providing implementation details and best‑practice recommendations.

AOPAccess ControlJava
0 likes · 21 min read
Designing a Flexible Permission Control System with Java Annotations and Spring AOP
macrozheng
macrozheng
Nov 27, 2024 · Backend Development

How a Tiny HashMap Bug Triggered a Massive Memory Leak in a High‑Traffic Microservice

A senior architect introduced a high‑concurrency monitoring feature that used a ConcurrentHashMap without proper equals/hashCode implementations, leading to duplicate keys, race conditions, and severe memory leaks, which were later resolved by correcting the key class and applying atomic map operations.

ConcurrentHashMapJavaMemoryLeak
0 likes · 8 min read
How a Tiny HashMap Bug Triggered a Massive Memory Leak in a High‑Traffic Microservice
Architect's Tech Stack
Architect's Tech Stack
Nov 27, 2024 · Backend Development

Refactoring Spring Boot Controllers: From Messy Code to Clean, Validated, and Exception‑Handled Design

This article examines common problems in Spring Boot controller implementations—excessive try‑catch blocks, inline validation, and business logic leakage—and demonstrates how to refactor them using @Valid, assertion utilities, and a global exception handler to achieve concise, maintainable backend code.

ControllerExceptionHandlingJava
0 likes · 9 min read
Refactoring Spring Boot Controllers: From Messy Code to Clean, Validated, and Exception‑Handled Design
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 27, 2024 · Backend Development

Understanding Java ThreadPoolExecutor Rejection Policies and Their Use Cases

Java's ThreadPoolExecutor provides four built‑in RejectedExecutionHandler strategies—AbortPolicy, CallerRunsPolicy, DiscardPolicy, and DiscardOldestPolicy—each suited to different overload scenarios, and this article explains their behavior, trigger conditions, and practical application guidelines for robust backend concurrency management.

ConcurrencyJavaPerformance
0 likes · 10 min read
Understanding Java ThreadPoolExecutor Rejection Policies and Their Use Cases
JD Retail Technology
JD Retail Technology
Nov 27, 2024 · Backend Development

Optimizing SpringBoot Application Startup Time: Diagnosis and Solutions

This article documents the diagnosis of slow SpringBoot startup in a large‑scale advertising platform and presents a series of optimizations—including actuator monitoring, Tomcat TLD scan disabling, HBase async warm‑up, custom BeanPostProcessor timing, asynchronous JSF consumer refer, Tomcat version tuning, and hardware migration—that together reduce launch time by about 60%.

BeanPostProcessorJavaPerformance
0 likes · 20 min read
Optimizing SpringBoot Application Startup Time: Diagnosis and Solutions
Java Architect Essentials
Java Architect Essentials
Nov 27, 2024 · Backend Development

New Features of Cool Request Plugin: Trace, MyBatis Tracking, Custom Timing Colors, and Scripting

The article introduces the latest Cool Request IDEA plugin update, detailing its Trace capability for method execution timing, selective MyBatis function monitoring, customizable slow‑method highlighting, and scripting support for headers and JSON parsing, all illustrated with Java code examples.

Cool RequestIDEA PluginJava
0 likes · 5 min read
New Features of Cool Request Plugin: Trace, MyBatis Tracking, Custom Timing Colors, and Scripting
Programmer XiaoFu
Programmer XiaoFu
Nov 27, 2024 · Databases

Why Does MySQL CPU Spike to 900%? Diagnosis and Fixes

The article explains how to troubleshoot extreme CPU usage in MySQL and Java processes, detailing step‑by‑step diagnostics with top, show processlist, jstack, and practical fixes such as adding missing indexes, disabling slow logs, using caches, and correcting busy‑loop code to bring CPU consumption back to normal levels.

CPUIndexingJava
0 likes · 11 min read
Why Does MySQL CPU Spike to 900%? Diagnosis and Fixes
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 26, 2024 · Backend Development

Understanding CountDownLatch and CompletableFuture in Java Concurrency

This article explains the purpose, typical usage scenarios, and provides concrete code demonstrations of Java's CountDownLatch and CompletableFuture, comparing their synchronization versus asynchronous capabilities and guiding developers on selecting the appropriate tool for effective multithreaded programming.

CompletableFutureConcurrencyCountDownLatch
0 likes · 6 min read
Understanding CountDownLatch and CompletableFuture in Java Concurrency
FunTester
FunTester
Nov 26, 2024 · Backend Development

Understanding Java's ScheduledThreadPoolExecutor: Concepts, Configuration, Core Methods, and Best Practices

This article provides a comprehensive overview of Java's ScheduledThreadPoolExecutor, covering its fundamental concepts, inheritance, key features, construction options, core scheduling methods, configuration recommendations, common pitfalls, and practical code examples for reliable task scheduling in backend applications.

Backend DevelopmentJavaScheduledThreadPoolExecutor
0 likes · 9 min read
Understanding Java's ScheduledThreadPoolExecutor: Concepts, Configuration, Core Methods, and Best Practices
Top Architect
Top Architect
Nov 25, 2024 · Backend Development

UniHttp – A Declarative HTTP Interface Integration Framework for Java Backend Projects

This article introduces UniHttp, a declarative HTTP client framework that simplifies third‑party API integration in Java backend applications by replacing manual HttpClient/OkHttp code with annotated interfaces, provides quick‑start instructions, detailed annotation usage, lifecycle hooks, custom channel integration examples, and configuration tips.

Declarative APIJavaSpring Boot
0 likes · 24 min read
UniHttp – A Declarative HTTP Interface Integration Framework for Java Backend Projects
Top Architect
Top Architect
Nov 25, 2024 · Backend Development

Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit

This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously only after a transaction successfully commits, ensuring data consistency without impacting the main business flow.

JavaKafkaSpring
0 likes · 12 min read
Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit
Ubiquitous Tech
Ubiquitous Tech
Nov 25, 2024 · Backend Development

Understanding EasyRules: Core Execution Flow and Design of the Java Rule Engine

This article provides a detailed walkthrough of EasyRules' source code, covering its modular project structure, the Facts container, Rule definition, registration via dynamic proxies, the two engine implementations, and the step‑by‑step fire process that drives rule evaluation and execution.

Backend DevelopmentDynamic ProxyEasyRules
0 likes · 20 min read
Understanding EasyRules: Core Execution Flow and Design of the Java Rule Engine
FunTester
FunTester
Nov 25, 2024 · Fundamentals

Understanding Concurrency and Parallelism in Java Multithreading

This article introduces the basics of Java multithreading concurrency, explains the difference between concurrency and parallelism with a supermarket analogy, and details thread pool creation, usage, and customization through analysis of ThreadPoolExecutor source code.

JavaParallelismThreadPoolExecutor
0 likes · 9 min read
Understanding Concurrency and Parallelism in Java Multithreading
Architecture & Thinking
Architecture & Thinking
Nov 25, 2024 · Backend Development

Mastering RocketMQ: Core Concepts, Comparison, and Java Implementation

This comprehensive guide introduces RocketMQ's architecture, compares it with RabbitMQ and Kafka, outlines typical use cases, explains key concepts such as producers, brokers, consumers, topics, tags, and offsets, and provides complete Java code examples for building producers and consumers.

Backend DevelopmentJavaMessage Queue
0 likes · 14 min read
Mastering RocketMQ: Core Concepts, Comparison, and Java Implementation
ITPUB
ITPUB
Nov 24, 2024 · Backend Development

Master Java Logging: Frameworks, Best Practices, and Real‑World Tips

This guide explains why logging is essential for Java applications, compares popular logging frameworks such as Logback, Log4j2, and SLF4J, shows how to integrate them with Spring Boot, and provides concrete best‑practice recommendations for levels, formatting, async handling, rotation, and security.

JavaLoggingSpring Boot
0 likes · 17 min read
Master Java Logging: Frameworks, Best Practices, and Real‑World Tips
Ubiquitous Tech
Ubiquitous Tech
Nov 23, 2024 · Fundamentals

Rule Engine Basics: Getting Started with the Open‑Source EasyRule

The article walks through the problems of hard‑coded if‑else logic, introduces rule engines as a flexible solution, explains EasyRule’s concepts, advantages, and classifications, and provides step‑by‑step Java examples using annotations, fluent API, MVEL, and YAML configurations.

AnnotationEasyRuleFluent API
0 likes · 20 min read
Rule Engine Basics: Getting Started with the Open‑Source EasyRule
Top Architect
Top Architect
Nov 23, 2024 · Backend Development

Integrating Spring Boot with XXL-Job for Distributed Task Scheduling

This article explains how to integrate Spring Boot with the open‑source XXL‑Job distributed task scheduler, covering XXL‑Job fundamentals, configuration of the admin console and executor, Maven dependencies, property settings, code examples, @XxlJob annotation parameters, best practices, and includes additional promotional material.

Backend DevelopmentJavaSpring Boot
0 likes · 16 min read
Integrating Spring Boot with XXL-Job for Distributed Task Scheduling
Top Architect
Top Architect
Nov 23, 2024 · Backend Development

RBAC Permission Analysis and Spring Security Tutorial with JWT Integration

This comprehensive tutorial explains RBAC concepts and models, demonstrates basic Spring Security setup, shows how to integrate JWT for stateless authentication, covers JSON‑based login, password encryption with BCrypt, and database‑backed authentication, providing full code examples for each step.

JWTJavaRBAC
0 likes · 16 min read
RBAC Permission Analysis and Spring Security Tutorial with JWT Integration
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 23, 2024 · Big Data

Implementing a Basic Hadoop MapReduce Word Count with Extensible Design and Performance Tuning

This article explains Hadoop’s core concepts using a library analogy, details HDFS storage and MapReduce processing, provides complete Java implementations for a word‑count job with support for text, CSV, and JSON inputs, and discusses extensibility and performance optimizations such as combiners and custom partitioners.

Big DataHadoopJava
0 likes · 20 min read
Implementing a Basic Hadoop MapReduce Word Count with Extensible Design and Performance Tuning
Architect
Architect
Nov 22, 2024 · Backend Development

Why Is Async Log4j2 Logging So Slow? A Deep Dive into Disruptor and JNI Overheads

The article investigates a severe performance bottleneck in a Java service caused by massive async Log4j2 logging, analyzes the Disruptor‑based async logger, explores JNI stack‑trace overhead, reproduces the issue with benchmarks, and provides practical recommendations to eliminate the slowdown.

DisruptorJNIJava
0 likes · 18 min read
Why Is Async Log4j2 Logging So Slow? A Deep Dive into Disruptor and JNI Overheads
ITPUB
ITPUB
Nov 22, 2024 · Backend Development

Master Java Collection Conversions with 10 Stream Utility Methods

This article presents a set of ten Java Stream‑based utility methods that simplify converting between Collection, List, Set, and Map types, showing practical examples, test cases, and reusable implementations for common data‑mapping scenarios.

CollectionConversionJava
0 likes · 11 min read
Master Java Collection Conversions with 10 Stream Utility Methods
JD Cloud Developers
JD Cloud Developers
Nov 22, 2024 · Frontend Development

How Playwright Transforms Car‑Insurance UI Testing: From Recording to Automated Reporting

This article explains how Playwright can automate the UI testing of a car‑insurance H5 application, covering background challenges, tool installation, recording test cases, API response verification, building a full automated testing pipeline, and a demo that reduces manual effort while improving reliability.

Car InsuranceJavaPlaywright
0 likes · 10 min read
How Playwright Transforms Car‑Insurance UI Testing: From Recording to Automated Reporting
Top Architect
Top Architect
Nov 22, 2024 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

This article walks through a systematic approach to sizing and configuring JVM parameters—including heap size, young generation, GC algorithm selection, and advanced options—for a high‑traffic login service that processes one million requests per day on a server with 8 GB of memory, while explaining the underlying performance‑analysis methodology.

Garbage CollectionJVMJava
0 likes · 27 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Architecture Digest
Architecture Digest
Nov 22, 2024 · Backend Development

Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts

This article demonstrates how to implement a login attempt limiting mechanism using Spring Boot, Redis, and Lua scripts, explaining the problem of repeated password failures, the design of IP-based rate limiting, and providing complete front‑end and back‑end code examples with configuration details.

JavaLogin Rate LimitingLua
0 likes · 17 min read
Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts
macrozheng
macrozheng
Nov 22, 2024 · Backend Development

How to Quickly Master a Spring Cloud Microservices Project with Mall‑Swarm

This guide walks you through the entire Mall‑Swarm microservices e‑commerce project—covering setup, core Spring Cloud components, scaffolding, Kubernetes deployment, and extending functionality—so newcomers can confidently tackle a real‑world microservice system.

Backend DevelopmentJavaKubernetes
0 likes · 11 min read
How to Quickly Master a Spring Cloud Microservices Project with Mall‑Swarm
AsiaInfo Technology: New Tech Exploration
AsiaInfo Technology: New Tech Exploration
Nov 22, 2024 · Operations

How Inferred Spans Boost Distributed Tracing Accuracy and Coverage

The article examines the implementation of inferred spans as an advanced observability technique that enriches traditional distributed tracing by automatically generating additional spans, improving coverage, pinpointing latency sources, and offering performance‑optimisation insights while discussing practical integration, algorithmic details, and associated trade‑offs.

Javaasync-profilerdistributed tracing
0 likes · 9 min read
How Inferred Spans Boost Distributed Tracing Accuracy and Coverage
Programmer XiaoFu
Programmer XiaoFu
Nov 22, 2024 · Backend Development

15 Must-Know SpringBoot Startup Extension Points – Which Have You Used?

This article enumerates fifteen common SpringBoot startup extension points, explains their positions in the bean lifecycle, illustrates each with concrete code snippets and usage scenarios, and provides a visual call‑order diagram to help developers harness these hooks for custom initialization and middleware development.

BeanLifecycleExtensionPointsJava
0 likes · 18 min read
15 Must-Know SpringBoot Startup Extension Points – Which Have You Used?
FunTester
FunTester
Nov 22, 2024 · Operations

Why Java Is the Ultimate Backbone for Performance Testing

The author recounts a four‑year journey from UI automation to Java‑based performance testing, illustrating how mastering Java’s concurrency utilities and Groovy scripting can replace traditional tools like JMeter, enabling flexible, high‑throughput test scenarios and deeper control over test case design.

ConcurrencyGroovyJMeter
0 likes · 8 min read
Why Java Is the Ultimate Backbone for Performance Testing
Top Architect
Top Architect
Nov 21, 2024 · Backend Development

Best Practices and Common Pitfalls of Using Thread Pools in Java

This article summarizes how to correctly declare, monitor, configure, and name Java thread pools, explains common mistakes such as unbounded queues and ThreadLocal contamination, and introduces dynamic tuning techniques and open‑source solutions for robust backend concurrency management.

ConcurrencyJavaSpringBoot
0 likes · 18 min read
Best Practices and Common Pitfalls of Using Thread Pools in Java
Zhuanzhuan Tech
Zhuanzhuan Tech
Nov 20, 2024 · Backend Development

Design and Implementation of a High‑Performance Message Notification System

This article presents a comprehensive design of a high‑performance, fault‑tolerant message notification system, covering service partitioning, system architecture, idempotent processing, dynamic error detection, thread‑pool management, retry mechanisms, and stability measures such as traffic‑spike handling, resource isolation, third‑party protection, monitoring, and active‑active deployment.

JavaMessage Notificationbackend architecture
0 likes · 16 min read
Design and Implementation of a High‑Performance Message Notification System
Top Architect
Top Architect
Nov 20, 2024 · Big Data

Understanding Distributed Systems and Kafka: Architecture, Message Ordering, and Java Consumer Practices

This article explains the fundamentals of distributed systems, introduces Apache Kafka's architecture and components, discusses how Kafka ensures ordered message consumption, and provides Java consumer configuration tips to maintain message order, offering practical guidance for backend developers working with streaming data.

Big DataJavaKafka
0 likes · 11 min read
Understanding Distributed Systems and Kafka: Architecture, Message Ordering, and Java Consumer Practices
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 20, 2024 · Backend Development

Overview of Spring Framework Utility Classes

This article provides a comprehensive overview of Spring's built‑in utility classes—including assertion, string, collection, object, file/resource, web, reflection, AOP, path‑matching, and ID generation helpers—illustrating their usage with code examples and highlighting how they improve development efficiency and code quality.

Backend DevelopmentJavaSpring
0 likes · 12 min read
Overview of Spring Framework Utility Classes
Java Architect Essentials
Java Architect Essentials
Nov 20, 2024 · Backend Development

Common Java Backend Pitfalls and Practical Solutions

The article shares a Java backend developer’s recent challenges—including duplicated configuration files, hard‑coded parameters, mixed logging practices, unchecked Maven dependencies, and production database inconsistencies—and offers practical solutions such as consolidating Spring configuration, standardizing logging, enforcing code reviews, and proper Maven pom handling.

ConfigurationJavaLogging
0 likes · 6 min read
Common Java Backend Pitfalls and Practical Solutions
Architect
Architect
Nov 19, 2024 · Backend Development

Java Agent and Instrumentation: Non‑Intrusive Method Timing, Attach API, and Arthas Trace

This article demonstrates how to replace invasive manual timing code with Java Agent‑based instrumentation, covering the use of java.lang.instrument, premain and agentmain methods, dynamic class retransformation via the Attach API, and practical examples including method‑level timing, runtime class modification, and integration with Arthas for tracing.

BytecodeInstrumentationJava
0 likes · 20 min read
Java Agent and Instrumentation: Non‑Intrusive Method Timing, Attach API, and Arthas Trace
Code Ape Tech Column
Code Ape Tech Column
Nov 19, 2024 · Backend Development

Encapsulating EasyExcel for Simplified Import/Export in Spring Boot Applications

This article demonstrates how to wrap the EasyExcel library in a Spring Boot + MyBatis‑Plus project, providing a unified component that simplifies Excel import and export through concise annotations, reusable service methods, and customizable converters while addressing common pitfalls such as date handling and template support.

EasyExcelExcelImportExportJava
0 likes · 15 min read
Encapsulating EasyExcel for Simplified Import/Export in Spring Boot Applications
JD Cloud Developers
JD Cloud Developers
Nov 19, 2024 · Fundamentals

When to Choose Coroutines Over Threads: A Deep Dive into Java/Kotlin Concurrency

This article compares coroutines and threads for high‑concurrency and I/O‑intensive workloads versus CPU‑bound tasks, discusses Kotlin coroutine adoption, presents multithreading fundamentals, highlights performance pitfalls like System.currentTimeMillis, and offers code examples and optimization strategies for backend developers.

CoroutinesJavaKotlin
0 likes · 8 min read
When to Choose Coroutines Over Threads: A Deep Dive into Java/Kotlin Concurrency
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 19, 2024 · Backend Development

Understanding Java ThreadPool Rejection Policies and Their Use Cases

This article explains the conditions that trigger Java thread‑pool rejection policies, describes the four built‑in policies (AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy), provides detailed code examples for each, and discusses suitable application scenarios for backend developers.

Backend DevelopmentConcurrencyJava
0 likes · 13 min read
Understanding Java ThreadPool Rejection Policies and Their Use Cases
FunTester
FunTester
Nov 19, 2024 · Backend Development

Unlock Dynamic Scripting in Java with GroovyShell: Real‑World Examples

This article introduces GroovyShell, a powerful Groovy tool for runtime script execution, and provides five practical code examples—including basic usage, variable passing, multi‑line scripts, external script loading, and context control—followed by key application scenarios such as rule engines, dynamic configuration, rapid debugging, and data processing.

Backend DevelopmentDynamic ScriptingGroovy
0 likes · 7 min read
Unlock Dynamic Scripting in Java with GroovyShell: Real‑World Examples
Top Architect
Top Architect
Nov 18, 2024 · Backend Development

Comprehensive Guide to Spring Framework Utility Classes and Their Usage

This article presents a detailed overview of Spring's utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—provides code examples for each, and also contains promotional information about ChatGPT services and a developer community.

AOPJavaSpring
0 likes · 18 min read
Comprehensive Guide to Spring Framework Utility Classes and Their Usage
Code Ape Tech Column
Code Ape Tech Column
Nov 18, 2024 · Backend Development

How to Slim Down SpringBoot Jar Packages for Faster Deployment

This guide explains how to analyze the structure of a SpringBoot jar, separate your own classes from third‑party dependencies, reconfigure Maven packaging to produce a much smaller zip‑layout jar, and deploy it efficiently by uploading only the necessary libraries.

Jar SlimmingJavaMaven
0 likes · 6 min read
How to Slim Down SpringBoot Jar Packages for Faster Deployment
macrozheng
macrozheng
Nov 18, 2024 · Backend Development

How to Turn Java Swing Apps into Standalone Executables: A Practical Guide

This article explores Java Swing packaging challenges, compares five distribution methods—including GraalVM, JLink, and Exe4J—highlights their pros and cons, and demonstrates a custom WinForm tool that bundles a Swing program with a minimal JRE into a double‑clickable executable.

GraalVMJLinkJava
0 likes · 8 min read
How to Turn Java Swing Apps into Standalone Executables: A Practical Guide
Shepherd Advanced Notes
Shepherd Advanced Notes
Nov 18, 2024 · Fundamentals

Why Java’s Ternary Operator Can Throw NPE: Autoboxing Pitfalls Explained

The article explains how Java’s ternary operator can cause NullPointerException when type inference leads to automatic unboxing of a null wrapper, demonstrates this with concrete code examples, decompiled bytecode, and offers strategies such as using consistent types or replacing the ternary with if‑else.

AutoboxingJavaNullPointerException
0 likes · 11 min read
Why Java’s Ternary Operator Can Throw NPE: Autoboxing Pitfalls Explained
Top Architect
Top Architect
Nov 17, 2024 · Backend Development

Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Best Practices

This article records and reviews a production incident where multiple Spring Boot services consumed excessive memory, explains how default JVM settings caused each instance to allocate up to 12 GB of heap, and provides step‑by‑step diagnostics, configuration guidelines, and optimization recommendations for backend developers.

JVMJavaMemoryOptimization
0 likes · 8 min read
Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Nov 17, 2024 · Backend Development

Understanding Java Object Allocation: Stack Allocation, TLAB, and Performance Impact

This article examines a Java micro‑benchmark that measures object creation time, explains why printing objects dramatically slows execution, and details JVM allocation strategies such as stack allocation, escape analysis, scalar replacement, and Thread‑Local Allocation Buffers (TLAB) with relevant parameters.

JVMJavaObject Allocation
0 likes · 6 min read
Understanding Java Object Allocation: Stack Allocation, TLAB, and Performance Impact
ITPUB
ITPUB
Nov 17, 2024 · Backend Development

Why Spring Event Can Lose Messages During Startup and How to Avoid It

A deep dive into Spring Event's delayed listener registration reveals how messages can be lost during the brief window between Kafka consumer initialization and EventListener setup, explaining the root cause, illustrating the startup order, and recommending safer alternatives for reliable message handling.

EventJavaMessage Loss
0 likes · 8 min read
Why Spring Event Can Lose Messages During Startup and How to Avoid It