BestHub
Sign in
Tagged articles

Java

5000 articles · Page 33 of 50
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 7, 2024 · Backend Development

Online SQL-to-ER Diagram Tool: Features, Usage, and Implementation Details

This article introduces an online SQL-to-ER diagram tool, explains its advantages, provides step‑by‑step usage instructions, showcases example SQL and Java code for parsing and generating ER diagrams, and discusses the underlying design‑pattern architecture such as Strategy, Factory, Dependency Injection, and Singleton.

Backend DevelopmentDesign PatternsER Diagram
0 likes · 17 min read
Online SQL-to-ER Diagram Tool: Features, Usage, and Implementation Details
21CTO
21CTO
Dec 6, 2024 · Backend Development

What’s New in JDK 24? 24 Features Shaping the Future of Java

JDK 24, slated for a March 2025 release, introduces over twenty‑four enhancements—including a fourth preview of structured concurrency, quantum‑resistant cryptography, and a compact object header—while being a non‑LTS release that builds on the capabilities of JDK 23 and sets the stage for JDK 25.

Backend DevelopmentJDK 24Java
0 likes · 13 min read
What’s New in JDK 24? 24 Features Shaping the Future of Java
ITPUB
ITPUB
Dec 6, 2024 · Backend Development

Why ChatGPT Uses Server-Sent Events (SSE) and How to Implement SSE in Spring Boot

This article explains why ChatGPT adopts Server-Sent Events for streaming responses, compares SSE with WebSocket, outlines SSE's core principles and best‑practice considerations, and provides a complete Spring Boot example—including server‑side Java code and client‑side HTML—to demonstrate real‑time data push.

JavaReal‑time communicationSSE
0 likes · 14 min read
Why ChatGPT Uses Server-Sent Events (SSE) and How to Implement SSE in Spring Boot
Top Architect
Top Architect
Dec 6, 2024 · Backend Development

Java Plugin Architecture: SPI, ServiceLoader, and Spring Boot Integration

This article explains how to implement plugin mechanisms in Java using SPI and ServiceLoader, demonstrates custom configuration approaches, and shows how Spring Boot’s spring.factories can be leveraged for extensible services, providing practical code examples and step‑by‑step guidance for building modular backend applications.

JavaPluginSPI
0 likes · 23 min read
Java Plugin Architecture: SPI, ServiceLoader, and Spring Boot Integration
Java Tech Enthusiast
Java Tech Enthusiast
Dec 6, 2024 · Backend Development

Migrating MyBatis to MyBatis-Plus: Debugging LocalDateTime Conversion Issues

When migrating an old Java project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, a test failed with “Conversion not supported for type java.time.LocalDateTime” because MyBatis 3.5.1 stopped handling Java 8 time types and the existing mysql‑connector‑java 5.1.26 driver lacked support, which was resolved by upgrading the connector to version 5.1.37 or later, highlighting the need for thorough compatibility testing during framework upgrades.

JavaMyBatisMyBatis-Plus
0 likes · 7 min read
Migrating MyBatis to MyBatis-Plus: Debugging LocalDateTime Conversion Issues
Architecture Digest
Architecture Digest
Dec 6, 2024 · Backend Development

EasyExcel Wrapper for Simplified Import and Export in Spring Boot Backend

This article demonstrates how to encapsulate Alibaba's EasyExcel library within a Spring Boot backend, providing step‑by‑step environment setup, entity annotations, service interfaces, implementation details, usage examples, and solutions to common issues such as date conversion and template‑based export limitations.

EasyExcelExcelImportExportJava
0 likes · 13 min read
EasyExcel Wrapper for Simplified Import and Export in Spring Boot Backend
Selected Java Interview Questions
Selected Java Interview Questions
Dec 6, 2024 · Backend Development

Design and Implementation of a Lightweight Data Translation Framework for Java Backend Applications

This article introduces a lightweight, extensible Java framework that uses custom annotations to translate relational data, dictionaries, collections, and nested objects, detailing its background, architecture, core annotation design, usage examples, advanced features, Spring Boot integration, ORM support, and provides the open‑source repository link.

AnnotationData TranslationJava
0 likes · 17 min read
Design and Implementation of a Lightweight Data Translation Framework for Java Backend Applications
Su San Talks Tech
Su San Talks Tech
Dec 6, 2024 · Fundamentals

6 Common BigDecimal Mistakes in Java and How to Avoid Them

This article explains six typical pitfalls when using Java's BigDecimal—such as initializing with floating‑point literals, ignoring scale in division, misusing equals, misunderstanding scale, overlooking immutability, and performance costs—and provides clear code examples and best‑practice solutions to prevent precision loss and inefficiency.

ArithmeticBigDecimalJava
0 likes · 7 min read
6 Common BigDecimal Mistakes in Java and How to Avoid Them
FunTester
FunTester
Dec 5, 2024 · Backend Development

Understanding Aeron: A High‑Performance Messaging Framework and Its Advantages

Aeron is an open‑source, low‑latency, high‑throughput messaging framework that leverages zero‑copy memory, shared‑memory IPC and UDP transport to deliver microsecond‑level latency for finance, gaming, and distributed systems, offering a simple API and powerful performance features.

AeronHigh-Performance MessagingJava
0 likes · 9 min read
Understanding Aeron: A High‑Performance Messaging Framework and Its Advantages
Lobster Programming
Lobster Programming
Dec 5, 2024 · Fundamentals

How Does Java’s JVM Load Classes and Execute Code? A Deep Dive

This article explains how Java classes are loaded into the JVM, details the class loader’s parent‑delegation mechanism, and walks through the execution flow of a sample program, covering stack frames, heap allocation, dynamic linking, method area, program counter, native method stack, and garbage collection.

Garbage CollectionJVMJava
0 likes · 9 min read
How Does Java’s JVM Load Classes and Execute Code? A Deep Dive
Java Architect Essentials
Java Architect Essentials
Dec 4, 2024 · Backend Development

Spring Boot Project Initialization, Version Management, and Common Scaffold Code Guide

This article walks through initializing a Spring Boot project, handling version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common scaffolding code such as global exception handling, logging, CORS configuration, and recommends useful tools like Maven, embedded Redis, MyBatis‑Plus, and MapStruct for backend development.

Backend DevelopmentJavaKafka
0 likes · 9 min read
Spring Boot Project Initialization, Version Management, and Common Scaffold Code Guide
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.

IDEIntelliJ IDEAJava
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.

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

JavaLoggingSpring Boot
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 DevelopmentJavaMigration
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 DevelopmentDynamic JAR LoadingJava
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.

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

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

Asynchronous LoggingDisruptorJNI
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.

Binary SearchC++Java
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.

AOPJavaSpring Cloud
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.

Dependency InjectionJavaSpring
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.

ExecutorServiceJavaexception handling
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.

Best PracticesCode styleIntelliJ IDEA
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.

Career AdviceJavajob 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 ToolsJava
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.

Event-Driven ArchitectureJavaReliability
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 ToolsJavaMaven
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.

JavaLambdaMultithreading
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 theoremDistributed LockJava
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.

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

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

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

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

Distributed TracingJavaasync-profiler
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.

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.

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.

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.

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