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

JavaKafkaTransactionSynchronizationManager
0 likes · 12 min read
Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit
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.

JavaThreadPoolExecutormultithreading
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 DevelopmentDistributed SystemsJava
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.

Best PracticesJavaLogging
0 likes · 17 min read
Master Java Logging: Frameworks, Best Practices, and Real‑World Tips
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 DevelopmentDistributed SystemsJava
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
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.

Best PracticesConcurrencyJava
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.

Backend ArchitectureDistributed SystemsJava
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 DataDistributed SystemsJava
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 Framework
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.

Best PracticesJavaLogging
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.

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

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

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

ExecutableJLinkJava
0 likes · 8 min read
How to Turn Java Swing Apps into Standalone Executables: A Practical Guide
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
JD Tech
JD Tech
Nov 15, 2024 · Backend Development

Best Practices for Writing High‑Quality Java Methods

This article discusses how to write clean, maintainable Java methods by covering proper method signatures, limiting parameters, avoiding varargs misuse, validating inputs, minimizing side effects, handling exceptions correctly, writing concise method bodies, and providing effective logging and documentation practices.

Best PracticesException HandlingJava
0 likes · 21 min read
Best Practices for Writing High‑Quality Java Methods
Architect
Architect
Nov 14, 2024 · Backend Development

How to Set JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server

This article explains, step by step, how to estimate capacity, choose the appropriate garbage collector, size the young and old generations, configure stack memory, adjust object aging thresholds, and fine‑tune CMS or G1 settings so that a Java service handling one million daily logins can run reliably on an 8 GB node.

BackendGarbage CollectionJVM
0 likes · 24 min read
How to Set JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
ITPUB
ITPUB
Nov 14, 2024 · Operations

How to Tame 900% CPU Spikes in MySQL and Java Processes

This guide explains why MySQL and Java processes can suddenly consume 900% CPU, walks through systematic diagnosis using Linux tools, and provides concrete remediation steps such as indexing, caching, thread analysis, and code adjustments to bring CPU usage back to normal levels.

CPUJavaLinux
0 likes · 12 min read
How to Tame 900% CPU Spikes in MySQL and Java Processes
Java Tech Enthusiast
Java Tech Enthusiast
Nov 14, 2024 · Databases

Activiti Workflow Engine Database Design

Activiti is a BPMN workflow engine that provides components such as Process, Repository, Runtime, Task, and History services, stores definitions, runtime data, and history in a relational database schema, and is used by deploying BPMN diagrams, starting instances, and managing tasks via its Java API.

ActivitiBPMNDatabase Design
0 likes · 21 min read
Activiti Workflow Engine Database Design
Selected Java Interview Questions
Selected Java Interview Questions
Nov 14, 2024 · Backend Development

AviatorScript: High‑Performance JVM‑Based Expression Engine and Scripting Language – Features and Usage Guide

This article introduces AviatorScript, a lightweight high‑performance expression engine and scripting language for the JVM (including Android), outlines its core features, demonstrates basic expression evaluation, variable handling, built‑in and custom functions, and shows how to run full scripts with code examples.

AviatorBackendExpression Engine
0 likes · 8 min read
AviatorScript: High‑Performance JVM‑Based Expression Engine and Scripting Language – Features and Usage Guide
Architecture Digest
Architecture Digest
Nov 14, 2024 · Backend Development

30 Essential IntelliJ IDEA Plugins for Java Developers

This article presents a curated list of thirty free IntelliJ IDEA plugins, ranging from code assistance and formatting to UI enhancements and productivity tools, each accompanied by brief usage instructions and screenshots to help Java developers streamline their development workflow.

IDE pluginsIntelliJJava
0 likes · 6 min read
30 Essential IntelliJ IDEA Plugins for Java Developers
Code Ape Tech Column
Code Ape Tech Column
Nov 14, 2024 · Backend Development

Integrating Flowable Workflow Engine with Spring Boot: A Step‑by‑Step Guide

This article introduces the evolution of Java‑based workflow engines, compares Activiti, Flowable and Camunda, explains core BPMN concepts, and provides a detailed Spring Boot integration tutorial—including Maven dependencies, BPMN diagram creation, service task implementation, REST endpoint for diagram viewing, unit tests, and common troubleshooting tips.

BPMNFlowableJava
0 likes · 20 min read
Integrating Flowable Workflow Engine with Spring Boot: A Step‑by‑Step Guide
macrozheng
macrozheng
Nov 14, 2024 · Backend Development

Master Java’s New Map Methods: getOrDefault, forEach, merge & More

Learn how Java 8 introduced powerful Map methods such as getOrDefault, forEach, merge, putIfAbsent, compute, computeIfAbsent, computeIfPresent, and replace, with clear code examples that show how they simplify common tasks like default value handling, iteration, merging entries, and conditional updates.

Backend DevelopmentCode TutorialJDK8
0 likes · 10 min read
Master Java’s New Map Methods: getOrDefault, forEach, merge & More
Java Architecture Stack
Java Architecture Stack
Nov 14, 2024 · Backend Development

How Read‑Write Lock Separation Supercharges E‑Commerce Inventory

This article explains the read‑write lock separation design pattern, its principles, suitable scenarios such as high‑concurrency inventory queries, and provides a complete Java implementation with ReentrantReadWriteLock, including code samples, testing, performance benefits, and a discussion of its advantages and limitations.

BackendInventoryManagementJava
0 likes · 9 min read
How Read‑Write Lock Separation Supercharges E‑Commerce Inventory
Architect's Guide
Architect's Guide
Nov 14, 2024 · Backend Development

Implementing the Chain of Responsibility Pattern for Product Validation in Java

This article explains the Chain of Responsibility design pattern, demonstrates its application in a product creation workflow with concrete Java code, shows how to configure and assemble handlers dynamically using Spring, and discusses the pattern's advantages, drawbacks, and testing scenarios.

BackendChain of ResponsibilityHandler
0 likes · 20 min read
Implementing the Chain of Responsibility Pattern for Product Validation in Java
Java Interview Crash Guide
Java Interview Crash Guide
Nov 14, 2024 · Fundamentals

Master IntelliJ IDEA Debugging: From Basics to Advanced Techniques

This guide walks you through every essential feature of IntelliJ IDEA's Debug tool—pre‑setup, main UI, service and debug buttons, watches, variable inspection, conditional breakpoints, expression evaluation, frame rollback, force return, multithreaded, Stream and remote debugging—empowering you to troubleshoot Java code efficiently.

IDEIntelliJ IDEAJava
0 likes · 16 min read
Master IntelliJ IDEA Debugging: From Basics to Advanced Techniques
Architect
Architect
Nov 13, 2024 · Backend Development

UniHttp – Declarative HTTP Client Framework for Java Enterprise Projects

UniHttp is a declarative HTTP interface integration framework that simplifies third‑party API calls in Java projects by generating proxy beans, supporting rich annotations for request parameters, lifecycle hooks, custom processors, and seamless Spring integration, thereby improving code cohesion and maintainability.

APIDeclarativeFramework
0 likes · 21 min read
UniHttp – Declarative HTTP Client Framework for Java Enterprise Projects
Architecture Digest
Architecture Digest
Nov 13, 2024 · Backend Development

Unified Exception Handling in Spring Boot Using @ControllerAdvice, Assert, and Enum-based Error Codes

This article explains how to replace repetitive try‑catch blocks in Java backend development with a unified exception handling approach using Spring's @ControllerAdvice, custom Assert utilities, and enum‑based error codes, providing cleaner code, consistent error responses, and easy internationalization.

AssertBackendEnum
0 likes · 20 min read
Unified Exception Handling in Spring Boot Using @ControllerAdvice, Assert, and Enum-based Error Codes
Top Architect
Top Architect
Nov 13, 2024 · Fundamentals

Comprehensive Guide to IntelliJ IDEA Debugging Features

This article provides a step‑by‑step tutorial on using IntelliJ IDEA's Debug tool, covering preparation, main interface elements, each debugging button, variable inspection and modification, conditional breakpoints, expression evaluation, rollback, force return, multi‑thread, Stream and remote debugging, with code examples and screenshots.

DebuggingDevelopmentIDE
0 likes · 20 min read
Comprehensive Guide to IntelliJ IDEA Debugging Features
JD Cloud Developers
JD Cloud Developers
Nov 13, 2024 · Backend Development

Mastering Sentinel: Deep Dive into Java Flow Control and Cloud‑Native Governance

Sentinel, an open‑source flow‑control component born from Alibaba’s ecosystem, offers out‑of‑the‑box circuit‑breaking, rate‑limiting, and real‑time monitoring for Java microservices, with extensive rule types, dashboard visualization, datasource integrations, and adaptable architecture that supports multiple protocols, making it a versatile solution for cloud‑native traffic governance.

Circuit BreakingFlow ControlJava
0 likes · 19 min read
Mastering Sentinel: Deep Dive into Java Flow Control and Cloud‑Native Governance
Architect's Guide
Architect's Guide
Nov 13, 2024 · Backend Development

Designing a Modular Spring Boot Backend Project: Principles, Module Structure, and Maven Configuration

This article presents a comprehensive guide to building a Spring Boot backend system by outlining essential design principles, detailing a multi‑module architecture with clear responsibilities, and providing complete Maven POM configurations for each module to enable scalable and maintainable development.

Backend ArchitectureJavaMaven
0 likes · 14 min read
Designing a Modular Spring Boot Backend Project: Principles, Module Structure, and Maven Configuration
Java Tech Enthusiast
Java Tech Enthusiast
Nov 12, 2024 · Backend Development

Boost Spring Boot API Testing with the Free Open‑Source Cool Request Plugin

The article introduces Cool Request, a free open‑source IntelliJ IDEA plugin that streamlines Spring Boot backend API testing by providing in‑IDE request execution, method timing statistics, interceptor bypass, job triggering, Java pre/post scripts, response preview, and export to third‑party tools, complete with usage examples and code snippets.

API testingBackend DevelopmentCool Request
0 likes · 8 min read
Boost Spring Boot API Testing with the Free Open‑Source Cool Request Plugin
macrozheng
macrozheng
Nov 12, 2024 · Backend Development

Boost Kafka Throughput in Spring Boot: Batch Consumption Guide

This article demonstrates how to integrate Kafka with Spring Boot, add necessary dependencies and configuration, implement both single‑message and batch consumers, and tune batch settings to dramatically improve processing speed for millions of records in a microservice environment.

BackendBatchProcessingJava
0 likes · 12 min read
Boost Kafka Throughput in Spring Boot: Batch Consumption Guide
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 12, 2024 · Backend Development

Unlock Rapid API Development with Magic‑API: A Spring Boot 3 Practical Guide

This article introduces the Magic‑API framework for Java, explains its extensive features, walks through environment setup, dependency configuration, and demonstrates real‑world use cases such as data source management, pagination, SQL, MyBatis, HTTP calls, Redis integration, and inline Java execution within a Spring Boot 3 project.

API developmentBackendJava
0 likes · 6 min read
Unlock Rapid API Development with Magic‑API: A Spring Boot 3 Practical Guide
DeWu Technology
DeWu Technology
Nov 11, 2024 · Backend Development

Precise Testing Platform: Architecture, Recommendation Engine, and Graph Database Implementation

The Precise Testing Platform combines a recommendation engine—featuring a link analyzer, diff analyzer, and knowledge base—to automatically construct detailed method‑call graphs from source code, extract HTTP and Dubbo APIs, handle reflections and inheritance, and store billions of nodes in Nebula Graph, thereby eliminating blind, missed, and redundant tests while boosting coverage and reducing testing costs.

ASTBackend DevelopmentGraph Database
0 likes · 54 min read
Precise Testing Platform: Architecture, Recommendation Engine, and Graph Database Implementation
Top Architect
Top Architect
Nov 11, 2024 · Backend Development

Integrating Flowable Workflow Engine with Spring Boot: A Step‑by‑Step Guide

This article explains how to use the Flowable BPMN engine in a Spring Boot project, covering workflow basics, related BPMN concepts, Maven dependencies, diagram creation, service‑task implementation, REST API for diagram viewing, unit testing, and common pitfalls such as font configuration and process definition updates.

BPMNFlowableJava
0 likes · 21 min read
Integrating Flowable Workflow Engine with Spring Boot: A Step‑by‑Step Guide
Selected Java Interview Questions
Selected Java Interview Questions
Nov 11, 2024 · Backend Development

Understanding the Difference Between execute() and submit() in Java ThreadPoolExecutor

This article explains how Java's ThreadPoolExecutor handles tasks submitted via execute() and submit(), why execute() prints exceptions directly while submit() defers them until Future.get() is called, and provides detailed source‑code analysis and examples to illustrate the underlying mechanisms.

FutureTaskJavaThreadPoolExecutor
0 likes · 14 min read
Understanding the Difference Between execute() and submit() in Java ThreadPoolExecutor
Java Tech Enthusiast
Java Tech Enthusiast
Nov 11, 2024 · Backend Development

LiteFlow: A Java Flow Orchestration Framework Overview

LiteFlow is a lightweight Java flow‑orchestration framework that lets developers break complex business processes into independent Spring‑Boot node components, configure them via XML, and execute them with FlowExecutor, supporting conditional switches and loops while focusing on simple workflow modeling rather than role‑task management.

JavaLiteFlowSpringBoot
0 likes · 8 min read
LiteFlow: A Java Flow Orchestration Framework Overview
Architecture Digest
Architecture Digest
Nov 11, 2024 · Backend Development

Fluent Mybatis Tutorial: Introduction, Features, Comparison with MyBatis/MyBatis Plus, and Practical CRUD Implementation

This article introduces the Fluent Mybatis ORM framework, explains its design advantages, demonstrates how to implement a complex student‑score aggregation query using Fluent Mybatis, native MyBatis and MyBatis‑Plus, and provides end‑to‑end code examples for entity generation, configuration, and CRUD testing.

Fluent MyBatisJavaMyBatis
0 likes · 16 min read
Fluent Mybatis Tutorial: Introduction, Features, Comparison with MyBatis/MyBatis Plus, and Practical CRUD Implementation
Architect
Architect
Nov 10, 2024 · Backend Development

How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks

This article explains why API debouncing is crucial for backend Java services, outlines which endpoints need protection, describes how to identify duplicate requests, and provides step‑by‑step implementations using Redis shared‑cache and Redisson distributed locks with concrete code examples and test results.

BackendDebounceJava
0 likes · 14 min read
How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks
Top Architect
Top Architect
Nov 10, 2024 · Backend Development

Understanding Dependency Injection Types in Spring: Constructor, Setter, and Field Injection

This article explains Spring's three dependency injection methods—constructor‑based, setter‑based, and field‑based—illustrates each with code examples, discusses why field injection is discouraged, and recommends using constructor injection for required dependencies and setter injection for optional ones.

Constructor InjectionJavaspring
0 likes · 11 min read
Understanding Dependency Injection Types in Spring: Constructor, Setter, and Field Injection
dbaplus Community
dbaplus Community
Nov 10, 2024 · Cloud Native

Which JDK Performs Best on Kubernetes? A Detailed Comparison

This article benchmarks several popular JDK distributions on Kubernetes using a Spring Boot 3 application, measuring image size, startup time, memory consumption, and throughput with k6, and concludes that performance differences are minimal after repeated testing.

DockerJDKJava
0 likes · 11 min read
Which JDK Performs Best on Kubernetes? A Detailed Comparison
JavaEdge
JavaEdge
Nov 9, 2024 · Artificial Intelligence

Build an AI‑Powered Airline Ticket Agent with Spring AI Alibaba

This tutorial walks through creating an intelligent airline‑ticket customer‑service agent using Spring AI Alibaba, covering requirements, architecture, RAG integration, function calling, chat memory, core capabilities, code implementation with ChatClient, and a sample running result.

AI AgentAlibabaChat Memory
0 likes · 9 min read
Build an AI‑Powered Airline Ticket Agent with Spring AI Alibaba
Java Tech Enthusiast
Java Tech Enthusiast
Nov 9, 2024 · Databases

Java Connection Pool Optimization with HikariCP

The article examines Java connection pool technologies, comparing Commons Pool 2 with HikariCP and showing through JMH benchmarks that HikariCP delivers up to five‑times higher throughput, while detailing lifecycle management, configuration, eviction strategies, sizing best practices, and real‑world uses such as database, HTTP, and RPC connections.

Connection PoolDatabaseHikariCP
0 likes · 12 min read
Java Connection Pool Optimization with HikariCP
Java Architect Essentials
Java Architect Essentials
Nov 8, 2024 · Backend Development

The Hidden Risks of Using Lombok in Java Projects

This article examines how Lombok reduces boilerplate in Java code, demonstrates the transformation of a typical JavaBean before and after Lombok, and critically discusses five major drawbacks—including JDK compatibility, forced dependency, reduced readability, increased coupling, and technical debt—guiding developers to weigh its benefits against long‑term maintenance costs.

BoilerplateJavaLombok
0 likes · 10 min read
The Hidden Risks of Using Lombok in Java Projects
Java Tech Enthusiast
Java Tech Enthusiast
Nov 8, 2024 · Backend Development

Deploy kkfileviewer Container and Integrate MinIO with Spring Boot

This guide walks through building and running the kkfileviewer Docker container, then shows how to add MinIO to a Spring Boot application with configuration, a client bean, utility methods, and REST endpoints for uploading files and retrieving presigned preview URLs to display in the kkfileviewer UI.

DockerJavaMinio
0 likes · 7 min read
Deploy kkfileviewer Container and Integrate MinIO with Spring Boot
Code Ape Tech Column
Code Ape Tech Column
Nov 8, 2024 · Backend Development

Implementing a Dynamic Thread Pool with Nacos in Spring Boot

This article explains how to externalize and dynamically adjust a Spring Boot thread pool's core and maximum sizes using Nacos as a configuration center, allowing runtime changes without service restarts and demonstrating the setup, code, and testing procedures.

Dynamic ConfigurationJavaNacos
0 likes · 9 min read
Implementing a Dynamic Thread Pool with Nacos in Spring Boot
Java Architect Essentials
Java Architect Essentials
Nov 7, 2024 · Backend Development

Building a Netty + WebSocket Message Push Server in Java

This tutorial explains how to use Netty to create a Java backend server with WebSocket support, covering server initialization, channel configuration, pipeline setup, custom handlers, and message‑push services, and includes complete code examples for each component.

JavaNettyServer
0 likes · 10 min read
Building a Netty + WebSocket Message Push Server in Java
macrozheng
macrozheng
Nov 7, 2024 · Backend Development

Automate CRUD Code Generation for Spring Boot: Build 20+ Tables in Hours

This article introduces a Spring Boot code‑generation tool that automatically creates database tables, entity classes, DAO interfaces, service layers and controllers, turning weeks of manual CRUD development for dozens of tables into a matter of minutes, and explains its design, templates, dynamic parameters and usage.

CRUDJavaSpring Boot
0 likes · 18 min read
Automate CRUD Code Generation for Spring Boot: Build 20+ Tables in Hours
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 7, 2024 · Backend Development

Date Formatting Techniques in Spring Boot Applications

This article explains why consistent date formatting is crucial in Spring Boot APIs, outlines common scenarios such as front‑end data exchange, database storage and logging, and presents multiple server‑side and client‑side solutions—including SimpleDateFormat, DateTimeFormatter, global Jackson settings, annotations, custom converters, and timestamp output—complete with code examples.

Backend DevelopmentDate FormattingDateTimeFormatter
0 likes · 12 min read
Date Formatting Techniques in Spring Boot Applications
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 7, 2024 · Backend Development

Integrating XXL‑Job for Scheduled Hot‑Search Crawlers in a Java Backend

This tutorial explains how to replace the basic @Scheduled annotation with the flexible XXL‑Job distributed scheduler, covering repository download, admin deployment, database initialization, Spring‑Boot executor configuration, job registration for Douyin and Bilibili hot‑search crawling, and a Vue front‑end component for displaying ranked results with real‑time update timestamps.

Backend DevelopmentJavaScheduled Tasks
0 likes · 14 min read
Integrating XXL‑Job for Scheduled Hot‑Search Crawlers in a Java Backend
Su San Talks Tech
Su San Talks Tech
Nov 7, 2024 · Backend Development

Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems

This article explains how to analyze per‑second object memory usage in a 100k TPS e‑commerce order flow, choose an appropriate garbage collector, set heap and young‑generation sizes, and apply common JVM tuning parameters to reduce Full GC pauses and improve latency and throughput.

Garbage CollectionJVMJava
0 likes · 6 min read
Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems
Bin's Tech Cabin
Bin's Tech Cabin
Nov 7, 2024 · Backend Development

How Netty Detects Memory Leaks: Deep Dive into LeakAwareBuffer and ResourceLeakDetector

This article provides a comprehensive analysis of Netty's memory‑leak detection mechanism, covering the design principles, leak‑aware buffers, reference handling, sampling strategies, detection levels, and the internal models that enable accurate identification of unreleased native memory in both pooled and unpooled ByteBuf allocations.

JavaNettyResourceLeakDetector
0 likes · 44 min read
How Netty Detects Memory Leaks: Deep Dive into LeakAwareBuffer and ResourceLeakDetector