BestHub
Sign in
Tagged articles
5000 articles
Page 44 of 50
Java High-Performance Architecture
Java High-Performance Architecture
Feb 25, 2024 · Backend Development

Mastering Spring’s @ConfigurationProperties and @PropertySources for Clean Config Management

This article explains how Spring's @ConfigurationProperties and @PropertySources annotations work, compares their purposes, and provides step‑by‑step examples for binding external configuration to Java beans and loading multiple property files in a Spring Boot application.

ConfigurationPropertiesJavaPropertySources
0 likes · 11 min read
Mastering Spring’s @ConfigurationProperties and @PropertySources for Clean Config Management
Selected Java Interview Questions
Selected Java Interview Questions
Feb 25, 2024 · Information Security

Custom Authorization Annotations in Spring Security: Design, Implementation, and Usage

This article explores how to create and use custom authorization annotations in Spring Security to achieve more flexible, expressive, and maintainable permission checks, covering the basics of Spring Security, advantages of custom annotations, step‑by‑step implementation, and additional use‑case scenarios.

Backend SecurityCustom AnnotationJava
0 likes · 9 min read
Custom Authorization Annotations in Spring Security: Design, Implementation, and Usage
Architect's Guide
Architect's Guide
Feb 25, 2024 · Backend Development

Understanding AOP in Spring Boot with Practical Code Examples

This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes its core concepts such as pointcuts, advice, aspects, join points and weaving, and provides multiple Spring Boot examples—including simple @GetMapping logging, custom permission annotations, and the use of various AOP annotations—complete with full source code snippets.

AOPAspect Oriented ProgrammingBackend Development
0 likes · 18 min read
Understanding AOP in Spring Boot with Practical Code Examples
Architect
Architect
Feb 24, 2024 · Backend Development

Implementing a Dynamic Thread Pool with Nacos in Spring Cloud

This article demonstrates how to build a dynamically configurable thread pool in a Spring Cloud backend by using Nacos as a configuration center, covering dependency setup, YAML files, Java implementation, controller exposure, testing steps, and practical tips for runtime adjustments.

BackendDynamic ConfigurationJava
0 likes · 9 min read
Implementing a Dynamic Thread Pool with Nacos in Spring Cloud
Java High-Performance Architecture
Java High-Performance Architecture
Feb 24, 2024 · Backend Development

Unlock MyBatis Performance: Master First‑Level and Second‑Level Caches in SpringBoot

This article explains how MyBatis implements first‑level (session) and second‑level (namespace) caches, details their activation conditions, common pitfalls—especially when integrated with SpringBoot—and provides step‑by‑step configuration, code examples, and best‑practice recommendations to ensure cache effectiveness while avoiding hidden hazards.

CacheJavaMyBatis
0 likes · 11 min read
Unlock MyBatis Performance: Master First‑Level and Second‑Level Caches in SpringBoot
Java Architect Essentials
Java Architect Essentials
Feb 23, 2024 · Backend Development

Optimizing Apache HttpClient for High-Concurrency Scenarios

This article explains how to improve a high‑traffic Java service by reusing a singleton HttpClient, enabling keep‑alive, configuring a pooling connection manager, and adding an idle‑connection monitor, which reduces average request latency from 250 ms to about 80 ms.

BackendConnectionPoolingHttpClient
0 likes · 11 min read
Optimizing Apache HttpClient for High-Concurrency Scenarios
Architect
Architect
Feb 23, 2024 · Backend Development

Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest

This article explains the seven Spring transaction propagation levels, shows how nested @Transactional methods interact under each level, and provides concrete code‑level examples that illustrate when transactions are merged, suspended, started anew, or rolled back, helping developers choose the right strategy for reliable enterprise applications.

JavaSpring Frameworkpropagation
0 likes · 14 min read
Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest
Selected Java Interview Questions
Selected Java Interview Questions
Feb 23, 2024 · Backend Development

Designing an Order Number Generation System in Spring Boot

This article presents several approaches for generating unique, scalable order numbers in Spring Boot, including UUIDs, database sequences or auto‑increment IDs, timestamp‑based strings with random components, and distributed Snowflake IDs, each accompanied by Java code examples and discussion of their advantages and drawbacks.

JavaSpring Bootorder ID
0 likes · 10 min read
Designing an Order Number Generation System in Spring Boot
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 23, 2024 · Backend Development

Master Spring Boot 2.7: Bean Lifecycle, DI, AOP, Caching & More

This guide walks through essential Spring Boot 2.7.16 features—including bean lifecycle annotations, dependency injection methods, Java‑based configuration, conditional beans, event listeners, AOP, scheduled tasks, data access with Spring Data JPA, caching, exception handling, security, SpEL, configuration management, performance monitoring, and micro‑service components—providing concise code examples for each.

AOPCachingJava
0 likes · 10 min read
Master Spring Boot 2.7: Bean Lifecycle, DI, AOP, Caching & More
Java Tech Enthusiast
Java Tech Enthusiast
Feb 22, 2024 · Backend Development

Common Pitfalls of Arrays.asList in Java

When converting arrays to lists in Java, Arrays.asList cannot handle primitive arrays (treating them as a single element), returns a fixed‑size view that disallows add or remove operations, and shares its backing array so modifications affect both structures, so developers should use boxed streams or copy into a new ArrayList.

Arrays.asListJavaList
0 likes · 4 min read
Common Pitfalls of Arrays.asList in Java
macrozheng
macrozheng
Feb 22, 2024 · Backend Development

How Many Requests Can a Default SpringBoot App Handle? Inside Tomcat & Undertow Thread Pools

This article walks through an interview question about the maximum concurrent requests a default SpringBoot application can process, builds a minimal demo, examines Tomcat and Undertow thread‑pool configurations, and shows how container defaults and parameters like core size, max size, and queue length determine the real limit.

JavaPerformanceSpringBoot
0 likes · 19 min read
How Many Requests Can a Default SpringBoot App Handle? Inside Tomcat & Undertow Thread Pools
macrozheng
macrozheng
Feb 22, 2024 · Backend Development

Why Using isSuccess Can Break JSON Serialization in Java

This article explains how different Java JSON libraries handle boolean getter naming, shows code examples of serialization results with fastjson, Gson, and Jackson, and recommends using a plain "success" field with an isSuccess() getter to avoid runtime bugs.

FastJSONGsonJackson
0 likes · 7 min read
Why Using isSuccess Can Break JSON Serialization in Java
Code Ape Tech Column
Code Ape Tech Column
Feb 22, 2024 · Backend Development

Upgrading a Campus Blog Project to JDK 17 and Spring Boot 3: Process, Pitfalls, and Solutions

This article documents the step‑by‑step migration of a Java campus‑blog project from JDK 8 + Spring Boot 2.6 to JDK 17 and Spring Boot 3.2, explaining why the upgrade is worthwhile, detailing code and configuration changes, and sharing solutions to the numerous compatibility issues encountered.

ElasticsearchJavaSpringBoot3
0 likes · 18 min read
Upgrading a Campus Blog Project to JDK 17 and Spring Boot 3: Process, Pitfalls, and Solutions
Architecture Digest
Architecture Digest
Feb 21, 2024 · Backend Development

Java 8 Stream API Tutorial with PO Example and Common Operations

This article introduces Java 8's Stream API, explains its pipeline concept similar to SQL and Linux pipes, and demonstrates common operations such as filter, map, sorted, forEach, collect, statistics and parallelStream using a UserPo class with complete runnable code examples.

BackendData ProcessingFunctional Programming
0 likes · 9 min read
Java 8 Stream API Tutorial with PO Example and Common Operations
DaTaobao Tech
DaTaobao Tech
Feb 21, 2024 · Artificial Intelligence

An Overview of LangChain: Core Concepts and Practical Implementations

The article introduces LangChain as a framework that unifies LLM providers through model I/O, connects external data via retrievers, composes workflows with chains, maintains context with memory, and enables tool use through agents, and demonstrates Java examples for TongYi embeddings, a ChatGLM‑6B RetrievalQA chain, and discusses agent registration and micro‑service‑based agent factories.

EmbeddingJavaLLM
0 likes · 9 min read
An Overview of LangChain: Core Concepts and Practical Implementations
转转QA
转转QA
Feb 21, 2024 · Backend Development

Design and Evaluation of a JSON Similarity Algorithm for Reducing Diff Noise in Traffic Replay

This article presents a systematic approach to distinguish effective from ineffective diff failures in traffic replay by designing a JSON similarity model based on value, key, and structural comparisons, implementing the algorithm in Java, and demonstrating its superior accuracy over traditional system diff through extensive experiments.

Backend testingDiff Noise ReductionJSON
0 likes · 19 min read
Design and Evaluation of a JSON Similarity Algorithm for Reducing Diff Noise in Traffic Replay
Architect's Guide
Architect's Guide
Feb 21, 2024 · Backend Development

Design and Implementation of a Java Rule Engine with Short‑Circuit Evaluation

This article explains a real‑world scenario of extending trial‑user eligibility rules, introduces a refactored Java rule‑engine architecture that separates data, abstract rule templates, concrete rule implementations, and a service supporting AND/OR short‑circuit logic, and evaluates its advantages and drawbacks.

Backend DevelopmentCode RefactoringDesign Patterns
0 likes · 8 min read
Design and Implementation of a Java Rule Engine with Short‑Circuit Evaluation
Java Architect Essentials
Java Architect Essentials
Feb 20, 2024 · Backend Development

Why Did Our API Hang? Uncovering Redis Connection Pool Blocking in Spring Boot

A week‑long API freeze in a sandbox environment was traced to Redis connection pool misconfiguration, where threads waited indefinitely for a Jedis resource, leading to Tomcat request threads blocking and 500 errors, and the issue was resolved by adjusting pool settings and using proper connection release patterns.

BackendConnection PoolDebugging
0 likes · 9 min read
Why Did Our API Hang? Uncovering Redis Connection Pool Blocking in Spring Boot
Architect
Architect
Feb 20, 2024 · Backend Development

Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java

This article demonstrates how to prevent API abuse in a Java Spring application by using a custom HandlerInterceptor combined with Redis to track request counts per IP and URI, covering basic implementation, configuration, custom annotations, reflection for flexible limits, and discusses potential pitfalls and improvements.

InterceptorJavaReflection
0 likes · 19 min read
Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java
The Dominant Programmer
The Dominant Programmer
Feb 20, 2024 · Backend Development

Implementing Retry Logic for Third‑Party APIs with Spring Retry in Spring Boot

This guide shows how to add a retry mechanism to Spring Boot applications using Spring Retry, covering dependency setup, enabling @EnableRetry, defining @Retryable with custom back‑off settings, handling failures with @Recover, writing unit tests, and observing behavior with different retry counts and exception filters.

@EnableRetryJavaRetryable
0 likes · 6 min read
Implementing Retry Logic for Third‑Party APIs with Spring Retry in Spring Boot
The Dominant Programmer
The Dominant Programmer
Feb 20, 2024 · Backend Development

Integrating Elasticsearch with Spring Boot for Full CRUD Operations

This guide walks through integrating Spring Data Elasticsearch into a Spring Boot application, covering entity mapping annotations, repository creation, service layer implementation, and unit tests to perform create, read, update, delete, and fuzzy search operations on Elasticsearch indices.

CRUDElasticsearchJava
0 likes · 8 min read
Integrating Elasticsearch with Spring Boot for Full CRUD Operations
Top Architect
Top Architect
Feb 20, 2024 · Backend Development

JVM Garbage Collection Tuning Experience: Reducing FullGC Frequency and Solving Memory Leaks

Over a month of systematic JVM tuning, the author reduced FullGC frequency from 40 times per day to once every ten days, halved YoungGC time, identified and fixed a memory leak caused by anonymous inner‑class listeners, and documented the step‑by‑step optimization process with configuration changes and performance results.

Garbage CollectionJVMJava
0 likes · 12 min read
JVM Garbage Collection Tuning Experience: Reducing FullGC Frequency and Solving Memory Leaks
IT Services Circle
IT Services Circle
Feb 20, 2024 · Fundamentals

LeetCode 392: Determine if a String is a Subsequence Using the Two‑Pointer Technique

This article humorously references recent layoff memes before presenting a detailed tutorial on solving LeetCode problem 392—checking whether string s is a subsequence of t—using a two‑pointer algorithm, complete with step‑by‑step explanation, complexity analysis, visual illustrations, and reference implementations in C++, Java, and Python.

C++JavaLeetCode
0 likes · 8 min read
LeetCode 392: Determine if a String is a Subsequence Using the Two‑Pointer Technique
Programmer DD
Programmer DD
Feb 20, 2024 · Backend Development

Quick Start: Integrate Camunda Workflow Engine with Spring Boot

Learn how to set up and integrate the Camunda BPMN 2.0 workflow engine into a Spring Boot application, covering project initialization, Maven dependencies, configuration files, creating a simple user task process, and testing the workflow via Camunda’s web interface.

BPMNCamundaJava
0 likes · 10 min read
Quick Start: Integrate Camunda Workflow Engine with Spring Boot
Code Ape Tech Column
Code Ape Tech Column
Feb 20, 2024 · Backend Development

Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and its divide‑and‑conquer algorithm, demonstrates custom RecursiveTask implementations with full source code, analyzes ForkJoinPool construction, task submission, work‑stealing, monitoring APIs, commonPool pitfalls, and performance evaluation, providing practical guidance for Java developers.

ConcurrencyForkJoinPoolJava
0 likes · 24 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java
FunTester
FunTester
Feb 20, 2024 · Backend Development

Deadlock, Livelock, and Thread Starvation in Java Concurrency

This article explains Java concurrency issues such as deadlock, livelock, and thread starvation, demonstrates deadlock examples, discusses prevention techniques like timeouts and lock ordering, and provides an overview of the java.util.concurrent package including executors, locks, semaphores, latches, barriers, and concurrent collections.

ConcurrencyJavaThread Starvation
0 likes · 33 min read
Deadlock, Livelock, and Thread Starvation in Java Concurrency
Architect
Architect
Feb 19, 2024 · Information Security

Mastering Single Sign-On: From Session Basics to CAS Implementation

This article walks through the fundamentals of HTTP session handling, the challenges of session sharing in clustered environments, and presents a step‑by‑step design of a Single Sign‑On solution using CAS, including concrete code examples, Redis‑based session storage, and a comparison with OAuth2.

AuthenticationCASJava
0 likes · 17 min read
Mastering Single Sign-On: From Session Basics to CAS Implementation
IT Services Circle
IT Services Circle
Feb 19, 2024 · Backend Development

Common Pitfalls When Converting Arrays to Lists with Arrays.asList in Java

This article explains three common pitfalls of using Java's Arrays.asList—its incompatibility with primitive arrays, the immutability of the returned list, and the shared backing array that causes side‑effects—along with practical solutions such as using wrapper types, Streams, or creating a new ArrayList.

Arrays.asListBackend DevelopmentJava
0 likes · 5 min read
Common Pitfalls When Converting Arrays to Lists with Arrays.asList in Java
Selected Java Interview Questions
Selected Java Interview Questions
Feb 19, 2024 · Backend Development

Eight Ways to Implement Asynchronous Programming in Java

This article introduces eight common Java asynchronous implementation techniques—including raw threads, thread pools, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava ListenableFuture—explains their use cases, advantages, and limitations, and provides concrete code examples for each method.

AsynchronousBackendCompletableFuture
0 likes · 11 min read
Eight Ways to Implement Asynchronous Programming in Java
The Dominant Programmer
The Dominant Programmer
Feb 19, 2024 · Backend Development

How to Use SpringBoot and Modbus4j for Modbus TCP Data Reading

This article walks through setting up a SpringBoot project with the Modbus4j library to communicate with Modbus TCP devices, covering repository configuration, Maven dependencies, utility class implementation, single and batch reads, scheduled tasks, and troubleshooting common function‑code errors.

Industrial IoTJavaModbus TCP
0 likes · 11 min read
How to Use SpringBoot and Modbus4j for Modbus TCP Data Reading
Programmer DD
Programmer DD
Feb 19, 2024 · Backend Development

How to Build a Full‑Text Search API with Spring Boot and PostgreSQL

This guide explains how to implement a searchable user‑story interface using PostgreSQL tables with btree and gin indexes, Java record models, Spring Boot data access, and REST controllers to support range and full‑text queries efficiently.

Full-Text SearchJavaPostgreSQL
0 likes · 9 min read
How to Build a Full‑Text Search API with Spring Boot and PostgreSQL
Programmer DD
Programmer DD
Feb 19, 2024 · Backend Development

Boost Your Spring Boot Apps with Generative AI Using Spring AI

This tutorial walks you through adding OpenAI's generative capabilities to a Spring Boot application with Spring AI, covering project setup, API key configuration, controller creation, simple and advanced prompt usage, and how to test the resulting AI-powered endpoints.

Backend DevelopmentGenerative AIJava
0 likes · 5 min read
Boost Your Spring Boot Apps with Generative AI Using Spring AI
High Availability Architecture
High Availability Architecture
Feb 19, 2024 · Backend Development

Understanding Spring Transaction Propagation Mechanisms

This article explains Spring's seven transaction propagation behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how nested transactional methods interact, when new transactions are created or suspended, and how exceptions influence commit and rollback across different propagation settings.

Javapropagationspring
0 likes · 10 min read
Understanding Spring Transaction Propagation Mechanisms
Architect
Architect
Feb 18, 2024 · Backend Development

How Redisson Implements Distributed Locks: Deep Dive into Mechanisms and Pitfalls

This article explains why distributed locks are needed, outlines Redisson's lock properties, walks through its Lua‑based acquisition, renewal, and release processes, examines master‑slave pitfalls, compares RedLock with Zookeeper, and provides practical code examples for Java developers.

ConcurrencyJavaLock Mechanism
0 likes · 14 min read
How Redisson Implements Distributed Locks: Deep Dive into Mechanisms and Pitfalls
Python Programming Learning Circle
Python Programming Learning Circle
Feb 18, 2024 · Fundamentals

Hello World Examples in 12 Popular Programming Languages

This article showcases the correct "Hello World" syntax for twelve widely used programming languages, providing clear code snippets and brief explanations to help beginners understand the fundamental first program across Java, C, Python, C++, C#, Visual Basic .NET, JavaScript, PHP, Objective‑C, SQL, Ruby, and MATLAB.

C++Hello WorldJava
0 likes · 4 min read
Hello World Examples in 12 Popular Programming Languages
Programmer DD
Programmer DD
Feb 18, 2024 · Backend Development

How SpringBoot Enables a Dynamic Backend Implementation – A Patent Insight

Industrial and Commercial Bank of China received patent CN112905176B for a SpringBoot‑based web system backend method that extracts operation data, maps business IDs to configuration, builds conditional expressions, and processes data, thereby reducing development changes, cutting costs, and enhancing system stability.

JavaSpringBootbusiness logic
0 likes · 3 min read
How SpringBoot Enables a Dynamic Backend Implementation – A Patent Insight
Su San Talks Tech
Su San Talks Tech
Feb 18, 2024 · Backend Development

Mastering CompletableFuture: From Basics to RocketMQ Integration

This article explains Java's CompletableFuture, its advantages over the traditional Future API, demonstrates common methods with code examples, and shows how RocketMQ leverages CompletableFuture to coordinate asynchronous disk flush and replica synchronization tasks.

CompletableFutureConcurrencyFuture
0 likes · 15 min read
Mastering CompletableFuture: From Basics to RocketMQ Integration
FunTester
FunTester
Feb 18, 2024 · Backend Development

Mastering Java Concurrency: Threads, Synchronization, and Immutable Design

This article provides a step‑by‑step guide to Java concurrency, covering core concepts such as threads, runnables, thread lifecycle, synchronization primitives, wait/notify patterns, volatile variables, ThreadLocal storage, and how to design immutable objects for thread‑safety, all illustrated with concrete code examples and detailed explanations.

ConcurrencyImmutableJava
0 likes · 17 min read
Mastering Java Concurrency: Threads, Synchronization, and Immutable Design
Programmer DD
Programmer DD
Feb 17, 2024 · Backend Development

What’s New in IntelliJ IDEA 2024.1 EAP? Top Features for Spring, HTTP, and GitHub Actions

The IntelliJ IDEA 2024.1 EAP 5 release brings powerful enhancements for Spring and other Java frameworks, richer HTTP client capabilities, improved GitHub Actions support, and various productivity tweaks such as JSON schema handling and automatic header completion, all aimed at boosting backend developers' efficiency.

Backend DevelopmentGitHub ActionsHTTP client
0 likes · 6 min read
What’s New in IntelliJ IDEA 2024.1 EAP? Top Features for Spring, HTTP, and GitHub Actions
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 17, 2024 · Backend Development

Mastering @InitBinder in Spring Boot 3: Custom Data Binding Techniques

This article explains how to use Spring Boot's @InitBinder annotation in @Controller and @ControllerAdvice classes to customize WebDataBinder for parameter binding, type conversion, and formatting, and provides five practical examples demonstrating custom editors, converters, global binders, and field restrictions.

Custom ConverterInitBinderJava
0 likes · 6 min read
Mastering @InitBinder in Spring Boot 3: Custom Data Binding Techniques
Java Captain
Java Captain
Feb 16, 2024 · Backend Development

Differences Between Spring and Spring Boot: A Comprehensive Comparison

Spring Boot, an evolution of the Spring framework, simplifies project setup, offers built-in web servers, provides production-ready features, and enhances development efficiency, distinguishing it from traditional Spring which requires extensive XML configuration and external servlet containers, making Boot the preferred choice for modern Java backend development.

Backend DevelopmentJavaSpring Boot
0 likes · 4 min read
Differences Between Spring and Spring Boot: A Comprehensive Comparison
Architect
Architect
Feb 15, 2024 · Backend Development

Mastering State Patterns with Spring State Machine: From Theory to Order Workflow

This article explains the classic State design pattern, demonstrates a traffic‑light example, compares Spring State Machine with COLA, and walks through building a complete order‑status workflow in Spring Boot using enums, configuration, listeners, services, and a test controller, while highlighting trade‑offs and alternatives.

BackendJavaOrder Workflow
0 likes · 14 min read
Mastering State Patterns with Spring State Machine: From Theory to Order Workflow
Su San Talks Tech
Su San Talks Tech
Feb 15, 2024 · Backend Development

How to Ensure Transaction Rollback in Spring Multithreaded Operations

This article explains why the @Transactional annotation fails in Spring when using multithreading, demonstrates a failing example, and provides a solution using manual SqlSession management to guarantee that all database changes are rolled back if any thread encounters an exception.

JavaMyBatismultithreading
0 likes · 10 min read
How to Ensure Transaction Rollback in Spring Multithreaded Operations
Architect
Architect
Feb 14, 2024 · Backend Development

Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP

This article explains the fundamentals of finite state machines, demonstrates how to model order states using Spring Statemachine, shows persistence options with in‑memory and Redis stores, and provides advanced techniques such as exception handling, extended state tracking, and AOP‑based result logging for reliable state transitions.

AOPJavaOrder Management
0 likes · 23 min read
Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP
Java Tech Enthusiast
Java Tech Enthusiast
Feb 14, 2024 · Backend Development

Generic Excel Export for Arbitrary Java Objects via Reflection

The article shows how to generically export any Java object's data to an Excel‑compatible CSV file by using reflection to convert objects into maps, building headers (optionally via a @JcExcelName annotation) and writing the result with a reusable utility class and Maven‑managed Apache POI, FastJSON, and Commons‑IO dependencies, illustrated through SpringBoot controller and main‑method examples.

CSVJavaReflection
0 likes · 10 min read
Generic Excel Export for Arbitrary Java Objects via Reflection
Java Tech Enthusiast
Java Tech Enthusiast
Feb 14, 2024 · Backend Development

Understanding Xxl-Job: Architecture and Implementation of a Lightweight Distributed Task Scheduler

The article explains Xxl‑Job’s lightweight distributed scheduling architecture—detailing its Scheduling Center, Executor, and Task components, demo installation steps, Maven configuration, executor bean setup, job‑handler types, scheduling logic, thread‑pool and routing strategies, blocking policies, result callbacks, and overall HTTP‑based communication flow.

Distributed SchedulingJavaarchitecture
0 likes · 19 min read
Understanding Xxl-Job: Architecture and Implementation of a Lightweight Distributed Task Scheduler
Architect
Architect
Feb 13, 2024 · Information Security

Implementing API Key Authentication in Spring Security for REST APIs

This tutorial explains how to secure a Spring Boot REST API using API key authentication, covering the addition of Maven dependencies, creating a custom filter, extending AbstractAuthenticationToken, configuring the security filter chain, and testing the protected endpoint with curl commands.

API keyJavaREST API
0 likes · 8 min read
Implementing API Key Authentication in Spring Security for REST APIs
Su San Talks Tech
Su San Talks Tech
Feb 13, 2024 · Backend Development

How to Ensure Transaction Consistency When Async Threads Fail in Spring

This article explains how to guarantee transactional integrity when importing a 100,000‑row Excel file with asynchronous threads in Spring, covering double‑async optimization, Future and CompletableFuture handling, @Transactional pitfalls, manual transaction control, and a complete solution for cross‑thread transaction management.

AsyncCompletableFutureExcel Import
0 likes · 18 min read
How to Ensure Transaction Consistency When Async Threads Fail in Spring
MaGe Linux Operations
MaGe Linux Operations
Feb 12, 2024 · Information Security

How XML External Entity (XXE) Attacks Exploit DTDs and How to Defend Them

This article explains fundamental XML concepts, DTD and entity definitions, demonstrates common XXE attack scenarios such as file reading, internal network probing, DoS and XInclude exploitation with Java code examples, and provides practical security hardening techniques including disabling XInclude, DTD parsing, and external entity resolution.

DTDEntity ExpansionJava
0 likes · 15 min read
How XML External Entity (XXE) Attacks Exploit DTDs and How to Defend Them
Java Tech Enthusiast
Java Tech Enthusiast
Feb 12, 2024 · Backend Development

Dynamic Loading and Unloading of Java Governance Tasks with Custom ClassLoader and XXL‑Job Integration

The solution introduces a plug‑in architecture that uses a custom URLClassLoader to load governance task JARs at runtime, registers their Spring beans and @XxlJob handlers with XXL‑Job, and provides unload logic to deregister jobs, destroy beans, and update configuration via YAML or Nacos without restarting the service.

Dynamic LoadingJavaMaven
0 likes · 21 min read
Dynamic Loading and Unloading of Java Governance Tasks with Custom ClassLoader and XXL‑Job Integration
Architect's Guide
Architect's Guide
Feb 12, 2024 · Backend Development

Automating CRUD Operations with MyBatisPlus in Spring Boot

This article demonstrates how to automate CRUD operations in a Spring Boot application by leveraging MyBatisPlus, creating utility methods, a generic BaseController, pagination configuration, and extending it in concrete controllers, providing reusable code for rapid backend development.

JavaMyBatisPlusRESTful API
0 likes · 9 min read
Automating CRUD Operations with MyBatisPlus in Spring Boot
Su San Talks Tech
Su San Talks Tech
Feb 12, 2024 · Backend Development

How to Warm Up Your Cache for High‑Concurrency Systems

Cache warming, a technique used in high‑concurrency systems to preload frequently accessed data before traffic spikes, improves hit rates, reduces latency, prevents cache breakdowns, and eases backend load, with methods ranging from startup loading and scheduled jobs to Spring Boot listeners, Redis tools, and Caffeine loaders.

Backend PerformanceCaffeineJava
0 likes · 10 min read
How to Warm Up Your Cache for High‑Concurrency Systems
Code Ape Tech Column
Code Ape Tech Column
Feb 11, 2024 · Backend Development

Comparison of Java Distributed Scheduling Frameworks: Elastic-Job vs X-Job and Other Options

This article examines why scheduled tasks are needed, outlines common Java scheduling frameworks for both single‑machine and distributed environments, and provides a detailed side‑by‑side comparison of Elastic‑Job, X‑Job, Quartz and other solutions, highlighting their architectures, clustering, sharding, monitoring, scaling and failure‑handling strategies.

BackendDistributed SchedulingElastic-Job
0 likes · 13 min read
Comparison of Java Distributed Scheduling Frameworks: Elastic-Job vs X-Job and Other Options
Su San Talks Tech
Su San Talks Tech
Feb 11, 2024 · Backend Development

How to Retrieve Async Return Values with Java FutureTask?

This article explains how to obtain return values from asynchronous Java methods using FutureTask, covering its AQS foundation, execution flow, get() behavior, and provides concrete source code examples for practical implementation.

AQSAsyncConcurrency
0 likes · 13 min read
How to Retrieve Async Return Values with Java FutureTask?
Java Tech Enthusiast
Java Tech Enthusiast
Feb 9, 2024 · Backend Development

Understanding PageHelper Issues and ThreadLocal in MyBatis Pagination

Unexpected duplicate registrations, truncated query results, and password‑reset SQL errors in a Java backend were traced to PageHelper’s ThreadLocal pagination state persisting across requests when startPage() is called without immediate query execution, so developers should ensure immediate execution or manually clear the ThreadLocal to prevent stale LIMIT clauses.

JavaMyBatisThreadLocal
0 likes · 12 min read
Understanding PageHelper Issues and ThreadLocal in MyBatis Pagination
Architect's Guide
Architect's Guide
Feb 9, 2024 · Backend Development

How to Capture Exceptions from Java ThreadPool Tasks: submit vs execute and Three Solutions

This article explains why exceptions from tasks submitted to a Java ThreadPool using submit are not printed, how execute shows them, and presents three practical approaches—try‑catch within the task, a custom Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably obtain and handle those exceptions.

ConcurrencyExecutorServiceFuture
0 likes · 14 min read
How to Capture Exceptions from Java ThreadPool Tasks: submit vs execute and Three Solutions
Architect
Architect
Feb 7, 2024 · Backend Development

How to Secure Spring MVC APIs with Request/Response Encryption Using ControllerAdvice

This article walks through a real‑world scenario of adding symmetric encryption to Spring MVC endpoints for Android, iOS and H5 clients, detailing the requirements, code implementation of request and response interceptors, serialization pitfalls with enums and LocalDateTime, and the final solution using Jackson's ObjectMapper to keep encrypted and non‑encrypted responses consistent.

API SecurityControllerAdviceFastJSON
0 likes · 17 min read
How to Secure Spring MVC APIs with Request/Response Encryption Using ControllerAdvice
Java Tech Enthusiast
Java Tech Enthusiast
Feb 7, 2024 · Backend Development

How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation

This article provides a comprehensive analysis of Spring's @Autowired annotation, covering its usage, the bean lifecycle stages where it operates, the core classes and methods that implement it, and a comparison with other injection annotations such as @Resource, all illustrated with runnable code examples.

Annotation ProcessingAutowiredJava
0 likes · 27 min read
How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation
macrozheng
macrozheng
Feb 7, 2024 · Backend Development

Master Spring’s Essential Utility Classes: Assert, StringUtils, BeanUtils & More

This comprehensive guide walks you through the most useful Spring framework utility classes—including Assert, StringUtils, CollectionUtils, ObjectUtils, ClassUtils, BeanUtils, ReflectionUtils, Base64Utils, SerializationUtils, HttpStatus, and HtmlUtils—showing practical code examples and explaining when and how to use each to streamline Java backend development.

JavaSpring FrameworkUtility Classes
0 likes · 15 min read
Master Spring’s Essential Utility Classes: Assert, StringUtils, BeanUtils & More
AI Illustrated Series
AI Illustrated Series
Feb 7, 2024 · Databases

Why Store IPv4 Addresses as UNSIGNED INT in MySQL? Space, Speed, and Queries Explained

Storing IPv4 addresses as a 32‑bit UNSIGNED INT instead of VARCHAR saves storage space, reduces index size, enables faster range queries, and leverages MySQL’s built‑in INET_ATON/INET_NTOA functions, while the trade‑offs include reduced readability and the need for conversion code, as demonstrated with benchmarks and Java examples.

INET_ATONIP address storageJava
0 likes · 5 min read
Why Store IPv4 Addresses as UNSIGNED INT in MySQL? Space, Speed, and Queries Explained
Code Ape Tech Column
Code Ape Tech Column
Feb 7, 2024 · Backend Development

Dynamic Loading and Unloading of Data Governance Tasks in Java with Custom ClassLoader and XXL‑Job Integration

This article explains how to implement dynamic loading, upgrading, and unloading of data‑governance tasks in a Java Spring application using a custom URLClassLoader, integrate the tasks with the XXL‑Job scheduler, manage Spring bean registration, and persist configuration changes via local YAML or Nacos.

Backend DevelopmentDynamic Class LoadingJava
0 likes · 17 min read
Dynamic Loading and Unloading of Data Governance Tasks in Java with Custom ClassLoader and XXL‑Job Integration
Top Architect
Top Architect
Feb 6, 2024 · Backend Development

2023 State of the Java Ecosystem Report Highlights: Java 17 Adoption, JDK Vendor Shifts, and Containerization Trends

New Relic’s 2023 State of the Java Ecosystem report reveals a 430% surge in Java 17 adoption, declining use of older LTS releases, Amazon Corretto overtaking Oracle as the leading JDK provider, and a dominant shift toward containerized Java workloads, while the article also promotes a ChatGPT community and related services.

ContainerizationEcosystemJDK
0 likes · 7 min read
2023 State of the Java Ecosystem Report Highlights: Java 17 Adoption, JDK Vendor Shifts, and Containerization Trends
macrozheng
macrozheng
Feb 6, 2024 · Backend Development

Mastering LiteFlow: Build Elegant Java Workflow Engines for Complex Business Logic

This article introduces LiteFlow, a lightweight Java workflow engine, explains its core features, demonstrates rule syntax for serial, parallel, switch, and conditional orchestration, and provides step‑by‑step integration examples—including Maven dependencies, configuration, component implementation, and controller usage—to simplify complex business processes.

Backend DevelopmentJavaLiteFlow
0 likes · 13 min read
Mastering LiteFlow: Build Elegant Java Workflow Engines for Complex Business Logic
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Feb 6, 2024 · Fundamentals

How to Merge Two Sorted Arrays In‑Place Without Extra Space

This article walks through the classic interview problem of merging two non‑decreasing integer arrays directly into the first array, compares a naïve extra‑array solution with an optimal in‑place two‑pointer algorithm, and provides full Java implementations.

Javaarray mergingin-place algorithm
0 likes · 7 min read
How to Merge Two Sorted Arrays In‑Place Without Extra Space
Code Ape Tech Column
Code Ape Tech Column
Feb 6, 2024 · Backend Development

Comprehensive Guide to Spring Validation: Best Practices and Implementation Principles

This article provides an in‑depth tutorial on Spring Validation, covering simple usage, requestBody and requestParam/PathVariable validation, unified exception handling, advanced techniques such as group, nested, collection and custom validation, programmatic validation, fail‑fast mode, and the underlying implementation mechanisms within Spring MVC and Hibernate Validator.

BackendHibernate ValidatorJava
0 likes · 17 min read
Comprehensive Guide to Spring Validation: Best Practices and Implementation Principles
Su San Talks Tech
Su San Talks Tech
Feb 6, 2024 · Backend Development

Top 10 Online Development Tools to Boost Your Coding Efficiency

This article introduces ten powerful online utilities—including a Java Spring Initializr, code generators, JSON formatters, cron expression builders, regex testers, nginx formatters, and visual data tools—that streamline backend and frontend development workflows and dramatically improve productivity.

BackendJavadevelopment tools
0 likes · 7 min read
Top 10 Online Development Tools to Boost Your Coding Efficiency