BestHub
Sign in
Tagged articles

spring

1855 articles · Page 15 of 19
Programmer DD
Programmer DD
Jun 22, 2021 · Backend Development

Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue

This article presents a full‑stack Java mall project with distribution features, detailing its object‑oriented advantages, comprehensive backend and frontend technology stack, project structure, implemented modules such as member management, product editing, promotion, order and system management, deployment environment, and provides source code and documentation for developers.

E‑commerceJavaMyBatis
0 likes · 6 min read
Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue
Top Architect
Top Architect
Jun 20, 2021 · Backend Development

Understanding Spring IoC (Inversion of Control) and Dependency Injection (DI)

This article explains the concepts of Inversion of Control (IoC) and Dependency Injection (DI) in the Spring framework, describing how containers manage object creation, reduce coupling, improve testability, and embody the Hollywood principle for more flexible Java backend development.

Inversion of ControlIoCJava
0 likes · 9 min read
Understanding Spring IoC (Inversion of Control) and Dependency Injection (DI)
Java Tech Enthusiast
Java Tech Enthusiast
Jun 18, 2021 · Backend Development

Spring Annotation-Based Bean Registration Guide

The guide explains how Spring’s annotation-driven configuration—using @Configuration and @Bean to define beans, @ComponentScan for automatic detection, and additional annotations such as @Scope, @Lazy, @Conditional, @Import and FactoryBean—replaces verbose XML, streamlining bean registration and lifecycle management.

BeanConfigurationJava
0 likes · 10 min read
Spring Annotation-Based Bean Registration Guide
Top Architect
Top Architect
Jun 16, 2021 · Backend Development

Implementing Request Logging with Spring AOP: Aspect Code and Best Practices

This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures IP, URL, HTTP method, parameters, results, execution time, and error details, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.

AOPAspectJJava
0 likes · 12 min read
Implementing Request Logging with Spring AOP: Aspect Code and Best Practices
Programmer DD
Programmer DD
Jun 14, 2021 · Backend Development

Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained

This comprehensive guide explores the Spring framework’s fundamentals, including its lightweight architecture, core IoC container, dependency injection mechanisms, bean scopes and lifecycle, annotation‑based configuration, data‑access support, and aspect‑oriented programming features, providing developers with a solid foundation for building robust Java applications.

AOPBean LifecycleIoC
0 likes · 45 min read
Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained
Top Architect
Top Architect
Jun 13, 2021 · Backend Development

Implementing AOP in a Custom Spring‑like Framework

This article explains the principles and step‑by‑step implementation of Aspect‑Oriented Programming (AOP) in a lightweight Spring‑style container, covering core concepts, advice and pointcut design, weaving mechanisms, proxy creation, observer integration, and practical code examples.

AOPDesign PatternsJava
0 likes · 16 min read
Implementing AOP in a Custom Spring‑like Framework
Top Architect
Top Architect
Jun 12, 2021 · Backend Development

Zheng: A Comprehensive J2EE Enterprise Development Framework and Architecture Guide

The article presents Zheng, a full‑stack J2EE enterprise solution that integrates Spring, MyBatis, Dubbo, and a rich set of micro‑service modules, detailing its architecture, technology stack, environment setup, deployment procedures, and coding conventions for building scalable backend systems.

Javaenterprise architecturemicroservices
0 likes · 16 min read
Zheng: A Comprehensive J2EE Enterprise Development Framework and Architecture Guide
Java Backend Technology
Java Backend Technology
Jun 12, 2021 · Databases

Why My Spring API Stalled: Debugging Redis Connection Pool Blocking

A Spring‑based service repeatedly hung because Redis connections were never returned to the pool, leading to thread starvation; the article walks through the investigation using top, jstack, Arthas, and code analysis, then shows the proper way to use RedisCallback and release connections to prevent the deadlock.

DebuggingJavaPerformance
0 likes · 9 min read
Why My Spring API Stalled: Debugging Redis Connection Pool Blocking
Java Tech Enthusiast
Java Tech Enthusiast
Jun 8, 2021 · Backend Development

Introduction to AOP (Aspect Oriented Programming) in Java

This article introduces Aspect‑Oriented Programming in Java, explaining how AOP separates cross‑cutting concerns like logging using join points, pointcuts, advice, and aspects, and demonstrates dynamic proxies, various advice types, XML configuration, and aspect ordering within Spring AOP.

AOPAdviceAspectJ
0 likes · 20 min read
Introduction to AOP (Aspect Oriented Programming) in Java
Java Interview Crash Guide
Java Interview Crash Guide
Jun 8, 2021 · Backend Development

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

After a week of intermittent API hangs in an internal sandbox, we traced the issue to Redis connection pool blocking caused by missing max‑wait configuration, leading to threads waiting indefinitely; by adjusting Jedis pool settings, using proper connection release, and avoiding unsupported commands, the deadlock was resolved.

DebuggingJavaRedis
0 likes · 9 min read
Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking
Programmer DD
Programmer DD
Jun 8, 2021 · Backend Development

Mastering Request Logging with Spring AOP: A Complete Guide

Learn how to implement a robust request logging aspect in Spring using AOP annotations, covering pointcut definition, before/around/after advice, handling high concurrency, serializing logs, capturing errors, and adding traceId support for better traceability in backend services.

AOPJavaRequest Logging
0 likes · 14 min read
Mastering Request Logging with Spring AOP: A Complete Guide
Code Ape Tech Column
Code Ape Tech Column
Jun 8, 2021 · Backend Development

Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It

The article analyzes a Spring Boot transaction issue where a @Transactional method called from another non‑transactional method fails to roll back, explains the underlying propagation and proxy mechanisms, and presents two practical solutions—including using the bean’s proxy via AopContext with exposeProxy enabled—to ensure proper rollback.

AOPSpringBootTransactional
0 likes · 8 min read
Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It
Programmer DD
Programmer DD
Jun 6, 2021 · Backend Development

Fastest Java Bean Mapper? BeanUtils, Dozer, Orika, BeanCopier Compared

This article compares the usage, performance, and internal implementation of popular Java bean‑mapping tools—Spring BeanUtils, Apache BeanUtils, CGLIB BeanCopier, Dozer, and Orika—providing benchmark results, code examples, and detailed analysis to help developers choose the most efficient solution for their layered architectures.

DozerJavaOrika
0 likes · 33 min read
Fastest Java Bean Mapper? BeanUtils, Dozer, Orika, BeanCopier Compared
Programmer DD
Programmer DD
Jun 5, 2021 · Backend Development

When Does @Transactional Roll Back? Mastering Spring Transaction Exceptions

This article explains Alibaba’s Java guidelines for using @Transactional, categorizes checked and unchecked exceptions, shows how Spring’s default rollback behavior works, and provides practical examples of configuring rollback rules, avoiding common pitfalls, and best practices for applying @Transactional in backend Java applications.

JavaTransactionalbackend development
0 likes · 5 min read
When Does @Transactional Roll Back? Mastering Spring Transaction Exceptions
Java Tech Enthusiast
Java Tech Enthusiast
Jun 3, 2021 · Backend Development

Master Spring IoC: From Bean Creation to Dependency Injection

This tutorial explains the concept of Inversion of Control in Spring, demonstrates how to configure beans with XML, compares BeanFactory and ApplicationContext, explores bean scopes and lifecycle, and provides detailed examples of constructor, static‑factory, instance‑factory, and collection injection techniques.

BeanIoCJava
0 likes · 19 min read
Master Spring IoC: From Bean Creation to Dependency Injection
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Jun 2, 2021 · Backend Development

How to Build a User‑Customizable Scheduled Task System with Java’s ScheduledExecutor

This article explains how to design and implement a user‑customizable scheduled‑task component in Java, addressing the limitations of open‑source frameworks by separating task creation, loading, scheduling, and execution, and provides practical code examples for robust backend task management.

JavaScheduledExecutorconcurrency
0 likes · 11 min read
How to Build a User‑Customizable Scheduled Task System with Java’s ScheduledExecutor
Java Interview Crash Guide
Java Interview Crash Guide
Jun 1, 2021 · Backend Development

How Does Spring’s @Transactional Work? A Deep Dive into AOP and Transaction Management

This article explains the purpose and inner workings of Spring’s @Transactional annotation, detailing how AOP creates proxies, defines pointcuts, and orchestrates transaction management through BeanPostProcessors, advisors, interceptors, and the TransactionInterceptor, illustrated with source code snippets and diagrams.

AOPAnnotationJava
0 likes · 10 min read
How Does Spring’s @Transactional Work? A Deep Dive into AOP and Transaction Management
Selected Java Interview Questions
Selected Java Interview Questions
May 31, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: AOP‑Based Implementation and Transaction Management Flow

This article explains the purpose of Spring's @Transactional annotation, how it leverages AOP and dynamic proxies to manage transactions, and walks through the core source‑code components—including BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle—illustrated with concrete code examples.

AOPDynamic ProxyJava
0 likes · 9 min read
Understanding Spring's @Transactional Annotation: AOP‑Based Implementation and Transaction Management Flow
Top Architect
Top Architect
May 31, 2021 · Backend Development

Do Service and DAO Layers Need Interfaces? A Practical Discussion for Java Backend Projects

This article examines whether Service and DAO layers in Java backend projects require interfaces, arguing that with dependency‑injection frameworks like Spring the interfaces are often unnecessary, while outlining development workflows, project structures, and scenarios where interfaces remain useful.

JavaService Layerbackend architecture
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? A Practical Discussion for Java Backend Projects
Programmer DD
Programmer DD
May 30, 2021 · Backend Development

When to Prefer Spring BeanUtils Over Apache BeanUtils for Object Copying

This article explains the difference between shallow and deep copying in Java, compares Apache BeanUtils and Spring BeanUtils with code examples, highlights performance and safety concerns, and recommends using Spring BeanUtils or alternative libraries for efficient property transfer between objects.

ApacheBeanUtilsDeepCopy
0 likes · 10 min read
When to Prefer Spring BeanUtils Over Apache BeanUtils for Object Copying
Top Architect
Top Architect
May 28, 2021 · Backend Development

Injecting Specific Service Implementations in Spring with @Autowired, @Qualifier, and @Resource

This article explains three methods to inject a specific service implementation into a Spring controller—using @Autowired with @Qualifier, using @Resource with type, and using named @Service beans combined with @Resource(name), including code examples and differences between @Autowired and @Resource.

Javaannotationsdependency injection
0 likes · 4 min read
Injecting Specific Service Implementations in Spring with @Autowired, @Qualifier, and @Resource
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2021 · Backend Development

Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications

This article explains the Template Method design pattern, illustrating its algorithm skeleton and step customization with Java code examples, and demonstrates real‑world applications in Spring, MyBatis, and other backend frameworks, highlighting advantages, drawbacks, and practical implementation details.

Design PatternJavaMyBatis
0 likes · 12 min read
Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications
macrozheng
macrozheng
May 20, 2021 · Backend Development

10 Powerful Java Scheduling Techniques for Every Scenario

This article walks through ten practical scheduling solutions—from Linux crontab and JDK utilities to Spring Task, Spring Quartz, and distributed frameworks like XXL‑Job and Elastic‑Job—explaining their usage, configuration, code examples, and pros and cons so developers can pick the right tool for any business need.

Crondistributedscheduling
0 likes · 24 min read
10 Powerful Java Scheduling Techniques for Every Scenario
Top Architect
Top Architect
May 19, 2021 · Databases

MyBatis Streaming Query: Cursor Interface and Practical Implementations

This article explains MyBatis streaming queries using the Cursor interface, demonstrates how to define a Mapper that returns a Cursor, shows common pitfalls with closed connections, and provides three solutions—manual SqlSession handling, TransactionTemplate, and @Transactional—to keep the database connection open while iterating results.

DatabaseJavaMyBatis
0 likes · 7 min read
MyBatis Streaming Query: Cursor Interface and Practical Implementations
Programmer DD
Programmer DD
May 19, 2021 · Backend Development

Can You Build a Mini Spring Framework from Scratch? A Step‑by‑Step Guide

This article explains Spring's core concepts such as IOC, DI, and AOP, demonstrates building a simple Hello World with SpringBoot, then shows how to recreate the same functionality using raw Servlets and a handcrafted mini‑Spring framework with full code examples.

Inversion of ControlJavaMini Framework
0 likes · 20 min read
Can You Build a Mini Spring Framework from Scratch? A Step‑by‑Step Guide
Top Architect
Top Architect
May 17, 2021 · Backend Development

Common Spring Transaction Failure Scenarios and Their Solutions

This article explains typical situations where Spring @Transactional annotations fail—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, caught exceptions without rethrow, incorrect propagation settings, and unsupported MyISAM storage—and provides concrete code examples and fixes to ensure proper transaction behavior.

AOPJavaexception handling
0 likes · 10 min read
Common Spring Transaction Failure Scenarios and Their Solutions
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 13, 2021 · Backend Development

Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts

This article provides a comprehensive overview of the Spring framework, covering its core modules, version compatibility, core concepts such as IoC and AOP, proxy implementations, bean factories, lifecycle management, transaction handling, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.

AOPIoCJava
0 likes · 34 min read
Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts
Top Architect
Top Architect
May 11, 2021 · Backend Development

Implementing CORS Cross‑Origin Requests in Java Backend (Spring MVC)

This article explains why browsers enforce same‑origin restrictions, defines cross‑origin requests, lists the limitations of non‑same‑origin interactions, and presents five practical Java backend solutions—including a global CorsFilter bean, WebMvcConfigurer override, @CrossOrigin annotation, manual response headers, and a custom filter—complete with code examples.

CORSCross-OriginJava
0 likes · 7 min read
Implementing CORS Cross‑Origin Requests in Java Backend (Spring MVC)
Top Architect
Top Architect
May 10, 2021 · Backend Development

Understanding Java SPI, Dubbo SPI, and Spring SPI Mechanisms

This article explains the Service Provider Interface (SPI) concept, demonstrates how Java's built‑in SPI, Dubbo's enhanced SPI, and Spring's SPI work with code examples, compares their strengths and limitations, and discusses classpath ordering and extension loading issues.

DubboExtensionJava
0 likes · 13 min read
Understanding Java SPI, Dubbo SPI, and Spring SPI Mechanisms
Programmer DD
Programmer DD
May 10, 2021 · Backend Development

Doubling QPS and Fixing Hystrix Bottlenecks in a Java Service

This article describes how a Java backend service suffering from high CPU load and unstable Hystrix circuit breaking was diagnosed and optimized—using jtop for JVM profiling, refactoring JSON/Bean handling, switching Hystrix isolation modes, improving logging, and tweaking circuit‑breaker settings—to double its QPS capacity and achieve rapid recovery after traffic spikes.

HystrixJVMJava
0 likes · 15 min read
Doubling QPS and Fixing Hystrix Bottlenecks in a Java Service
Code Ape Tech Column
Code Ape Tech Column
May 10, 2021 · Backend Development

Mastering CORS in Spring: 5 Ways to Enable Cross‑Origin Requests

This article explains why browsers enforce the same‑origin policy, defines cross‑origin requests, outlines the restrictions of non‑same‑origin interactions, and presents five practical methods—including a global CorsFilter, WebMvcConfigurer, @CrossOrigin annotation, manual header setting, and a custom filter—to implement CORS in Java Spring backends.

CORSCross-OriginJava
0 likes · 8 min read
Mastering CORS in Spring: 5 Ways to Enable Cross‑Origin Requests
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 8, 2021 · Backend Development

Graceful Shutdown of RocketMQ Consumer in Spring Applications

The article recounts a production incident caused by an ungraceful RocketMQ consumer shutdown, analyzes the root cause involving Spring's bean destruction order and ShutdownHook behavior, and presents two solutions—using the official Spring‑Boot starter with SmartLifecycle or handling ContextClosedEvent—to achieve orderly termination.

RocketMQShutdownHookSmartLifecycle
0 likes · 5 min read
Graceful Shutdown of RocketMQ Consumer in Spring Applications
Top Architect
Top Architect
May 7, 2021 · Backend Development

Common Spring Transaction Failure Scenarios and Their Solutions

This article explains typical reasons why @Transactional may not work in Spring applications—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, swallowed exceptions, wrong propagation settings, and unsupported MySQL storage engines—and provides concrete code examples and fixes for each case.

AOPJavaMySQL
0 likes · 11 min read
Common Spring Transaction Failure Scenarios and Their Solutions
Code Ape Tech Column
Code Ape Tech Column
May 6, 2021 · Backend Development

Why PageHelper Pagination Breaks with List Operations and How to Fix It

This article explains why PageHelper pagination yields incorrect totals when list operations are performed before or after pagination, analyzes the underlying cause that startPage only affects subsequent SQL, and provides a step‑by‑step solution that processes the list after pagination and returns a correctly populated PageInfo object.

JavaMyBatisPagination
0 likes · 6 min read
Why PageHelper Pagination Breaks with List Operations and How to Fix It
Wukong Talks Architecture
Wukong Talks Architecture
Apr 29, 2021 · Backend Development

Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions

This article explains why local in‑memory locks fail in distributed environments, introduces the concept of distributed locks, and walks through five progressive Redis‑based lock implementations—bronze, silver, gold, platinum, and diamond—detailing their principles, code examples, advantages, and shortcomings.

JavaRedisbackend
0 likes · 16 min read
Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions
Java Interview Crash Guide
Java Interview Crash Guide
Apr 28, 2021 · Backend Development

Inside Spring: How Beans Are Instantiated Step by Step

This article explains the two‑phase lifecycle of Spring beans, covering container startup tasks, metadata loading, bean definition registration, and the detailed instantiation process including object creation strategies, BeanWrapper, property injection, Aware interfaces, post‑processors, and custom init/destroy logic.

BeanIoCJava
0 likes · 16 min read
Inside Spring: How Beans Are Instantiated Step by Step
Selected Java Interview Questions
Selected Java Interview Questions
Apr 27, 2021 · Backend Development

Understanding the Spring Bean Instantiation Process

This article explains how the Spring IoC container prepares and creates Bean instances, detailing the two main phases—container startup and Bean instantiation—along with the roles of BeanDefinition, BeanFactoryPostProcessor, BeanWrapper, Aware interfaces, BeanPostProcessor, and custom initialization and destruction logic.

BeanIoCJava
0 likes · 16 min read
Understanding the Spring Bean Instantiation Process
Programmer DD
Programmer DD
Apr 25, 2021 · Backend Development

Why Spring Dominates Java Development: Insights from the 2020 State of Spring Report

The 2020 State of Spring report reveals that the majority of Java developers favor Spring/Spring Boot, spending more time on unit testing, achieving higher code quality, and appreciating benefits such as easier web/API setup and robust testing support, with user adoption rising from 60% to 86%.

Framework SurveyJavabackend development
0 likes · 6 min read
Why Spring Dominates Java Development: Insights from the 2020 State of Spring Report
Top Architect
Top Architect
Apr 20, 2021 · Backend Development

Why @Transactional May Not Work: Common Failure Scenarios and Source‑Code Analysis

This article explains three typical situations in which Spring's @Transactional annotation becomes ineffective—non‑public methods, internal self‑calls, and caught exceptions—illustrates each case with runnable code examples, and dives into the underlying AOP and transaction‑management source code to show why the proxy logic is bypassed.

AOPJavaSpringBoot
0 likes · 12 min read
Why @Transactional May Not Work: Common Failure Scenarios and Source‑Code Analysis
Programmer DD
Programmer DD
Apr 16, 2021 · Backend Development

Demystifying Spring IoC and Dependency Injection: A Clear Guide for Beginners

This article explains the core concepts of Spring's Inversion of Control (IoC) and Dependency Injection (DI), illustrating how a container takes over object creation and wiring, why this reversal improves modularity and testability, and how the two ideas are essentially two views of the same design principle.

Design PatternsIoCJava
0 likes · 10 min read
Demystifying Spring IoC and Dependency Injection: A Clear Guide for Beginners
Architecture Digest
Architecture Digest
Apr 15, 2021 · Backend Development

Integrating Alipay’s New Transfer Interface with Java Spring Boot

This guide explains how to replace the legacy Alipay transfer API with the new alipay.fund.trans.uni.transfer interface by upgrading the SDK, configuring certificates, adding Maven dependencies, and implementing Spring components and utility classes for secure backend payment processing.

AlipayIntegrationJava
0 likes · 8 min read
Integrating Alipay’s New Transfer Interface with Java Spring Boot
Su San Talks Tech
Su San Talks Tech
Apr 10, 2021 · Backend Development

Mastering Java Scheduling: 10 Essential Timers and Distributed Task Solutions

Explore ten practical Java scheduling options—from Linux crontab and JDK Thread/Timer to Spring Task, Quartz, and distributed frameworks like XXL‑Job, Elastic‑Job, Saturn and TBSchedule—detailing setup, code examples, advantages, drawbacks, and best‑fit scenarios for reliable task automation.

CronQuartzdistributed
0 likes · 22 min read
Mastering Java Scheduling: 10 Essential Timers and Distributed Task Solutions
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 9, 2021 · Backend Development

Understanding Spring: Core Concepts, IoC, DI, AOP, and Annotations Explained

This article provides a comprehensive overview of the Spring framework, covering its lightweight architecture, core principles such as Inversion of Control and Dependency Injection, AOP mechanisms, design goals, module structure, common design patterns, bean lifecycle, circular dependency handling, and the most frequently used Spring annotations with code examples.

AOPIoCJava
0 likes · 41 min read
Understanding Spring: Core Concepts, IoC, DI, AOP, and Annotations Explained
Selected Java Interview Questions
Selected Java Interview Questions
Apr 8, 2021 · Backend Development

Common Scenarios Where Spring @Transactional Fails and How to Fix Them

This article outlines common situations that cause Spring @Transactional to fail—such as non‑public methods, internal method calls, unmanaged beans, non‑runtime exceptions, silent catches, incorrect propagation settings, and unsupported MySQL storage engines—and provides practical solutions to ensure transaction reliability.

AOPExceptionJava
0 likes · 10 min read
Common Scenarios Where Spring @Transactional Fails and How to Fix Them
Java Interview Crash Guide
Java Interview Crash Guide
Apr 8, 2021 · Backend Development

Why Does @Transactional Fail? Common Pitfalls and Fixes

This article explains the main reasons why Spring's @Transactional annotation may become ineffective—including non‑public method modifiers, internal method calls, and swallowed exceptions—provides code examples, test cases, and a deep dive into the underlying proxy and AOP mechanisms.

AOPJavaTransactional
0 likes · 13 min read
Why Does @Transactional Fail? Common Pitfalls and Fixes
New Oriental Technology
New Oriental Technology
Mar 29, 2021 · Backend Development

Sentinel Flow Control Component: Quick Start, Rules, Annotations, and Internal Mechanisms

This article introduces Alibaba Sentinel, an open‑source flow‑control framework for distributed services, covering Maven integration, dashboard setup, configuration of flow, degrade and hotspot rules, the @SentinelResource annotation, XCloud Sentinel starter usage, and a deep dive into its slot‑chain architecture and sliding‑window algorithm.

Flow ControlHotSpotSentinel
0 likes · 12 min read
Sentinel Flow Control Component: Quick Start, Rules, Annotations, and Internal Mechanisms
ITPUB
ITPUB
Mar 25, 2021 · Backend Development

Why a TCC Framework Must Own the Spring TransactionManager

This article examines the challenges of building a generic TCC distributed‑transaction framework on Spring, explaining why every TCC service must participate in RM‑local transactions, why the framework should intercept the Spring TransactionManager, how to handle fault recovery, idempotency of Confirm/Cancel, and the pitfalls of relying on Cancel for rollback, concluding with practical recommendations.

Distributed TransactionsTCCTransactionManager
0 likes · 18 min read
Why a TCC Framework Must Own the Spring TransactionManager
Top Architect
Top Architect
Mar 22, 2021 · Backend Development

Fundamentals of Spring Transaction Management

This article explains the core principles of Spring transaction management, covering basic JDBC transaction steps, declarative @Transactional usage, AOP proxy mechanisms (JDK dynamic proxy and CGLIB), transaction propagation attributes, isolation levels, nested transactions, and Spring Boot support, with practical code examples.

AOPJavabackend
0 likes · 14 min read
Fundamentals of Spring Transaction Management
Alibaba Cloud Native
Alibaba Cloud Native
Mar 18, 2021 · Backend Development

5 Ways to Integrate Apache RocketMQ into the Spring Ecosystem

This article outlines five Spring-based approaches for using Apache RocketMQ—including Spring Messaging, Spring Cloud Stream, Spring Cloud Bus, Spring Cloud Data Flow, and Spring Cloud Function—detailing each project's features, typical use cases, and how they fit into modern Java microservice architectures.

JavaRocketMQSpring Boot
0 likes · 11 min read
5 Ways to Integrate Apache RocketMQ into the Spring Ecosystem
Amap Tech
Amap Tech
Mar 12, 2021 · Backend Development

PowerMock and Mockito: Comprehensive Guide to Java Unit Testing and Mocking Techniques

This comprehensive guide walks Java developers through setting up PowerMock and Mockito, demonstrates creating and spying on mocks, stubbing methods, using parameter matchers, verifying interactions—including static and private members—and explains essential annotations and best‑practice principles for robust, maintainable unit tests.

JavaMockingMockito
0 likes · 24 min read
PowerMock and Mockito: Comprehensive Guide to Java Unit Testing and Mocking Techniques
ZhiKe AI
ZhiKe AI
Mar 11, 2021 · Backend Development

Mastering Spring Expression Language (SpEL): Syntax, Features, and Usage

This article provides a comprehensive overview of Spring Expression Language (SpEL), detailing its supported expression types, case‑insensitive keywords, step‑by‑step usage flow, core interfaces, and concrete code examples for literals, arithmetic, relational, logical, ternary, Elvis, variable handling, and property navigation.

EvaluationContextExpression LanguageJava
0 likes · 11 min read
Mastering Spring Expression Language (SpEL): Syntax, Features, and Usage
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 10, 2021 · Backend Development

Master PowerMock: Advanced Java Unit Testing Techniques

This article explains how to simplify complex Java code by using PowerMock and Mockito for unit testing, covering environment setup, mock, spy, when, parameter matchers, verification, static method mocking, private field and method handling, and essential annotations with practical code examples.

JavaMockitoPowerMock
0 likes · 26 min read
Master PowerMock: Advanced Java Unit Testing Techniques
Architect's Tech Stack
Architect's Tech Stack
Mar 6, 2021 · Information Security

Spring nohttp Project: Scanning and Blocking Insecure HTTP URLs

The Spring nohttp project is an open‑source tool that scans and replaces insecure http:// URLs with HTTPS, preventing man‑in‑the‑middle attacks, updating Maven and documentation links, offering multiple modules and a command‑line interface, and providing example XML configuration for secure classpath resolution.

HTTPSMavenSecurity
0 likes · 4 min read
Spring nohttp Project: Scanning and Blocking Insecure HTTP URLs
Xianyu Technology
Xianyu Technology
Mar 4, 2021 · Frontend Development

Solving CORS Issues When Integrating React Frontend with Java Backend

Integrating a React front‑end with a Java back‑end required fixing HTTPS‑to‑HTTP CORS errors by serving the React index.html from the backend, switching @RestController to @Controller for sub‑path routing, adding Thymeleaf, using a Chrome redirect plugin and crossorigin tags, and disabling lazy‑loaded asset URLs during local development, highlighting that true front‑end/back‑end separation remains elusive.

CORSJavaReAct
0 likes · 5 min read
Solving CORS Issues When Integrating React Frontend with Java Backend
Java Architect Essentials
Java Architect Essentials
Mar 3, 2021 · Information Security

Seven Open‑Source OAuth and SSO Projects for Developers

This article introduces seven open‑source OAuth/SSO solutions—including oauth2‑shiro, tkey, MaxKey, spring‑lhbauth, oauth2, oauthserver, and JustAuth—detailing their features, supported protocols, and repository links to help developers implement secure authentication and token management in web and mobile applications.

AuthenticationOAuthSSO
0 likes · 5 min read
Seven Open‑Source OAuth and SSO Projects for Developers
Top Architect
Top Architect
Mar 3, 2021 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains Spring's approach to resolving circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype bean limitations, provides a simplified implementation example, and draws an analogy to the classic two‑sum algorithm to illustrate the core concept.

Circular DependencyDesign PatternsJava
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
macrozheng
macrozheng
Mar 1, 2021 · Information Security

Build an OAuth2 Authorization Server with Spring Authorization Server 0.1.0

This guide walks you through setting up Spring Authorization Server 0.1.0 on Spring Boot 2.4.2, covering Maven dependencies, bean configurations, token customization, and testing with curl commands for authorization code flow, token issuance, refresh, and revocation.

Securityauthorization-serverspring
0 likes · 7 min read
Build an OAuth2 Authorization Server with Spring Authorization Server 0.1.0
Selected Java Interview Questions
Selected Java Interview Questions
Feb 26, 2021 · Backend Development

Understanding IoC: Inversion of Control, Dependency Injection, and Their Benefits

The article explains the core concept of Inversion of Control (IoC), how a third‑party container manages resources to reduce coupling, illustrates the idea with everyday examples, and clarifies the related terms dependency injection and control inversion, especially in the context of Spring.

Inversion of ControlIoCbackend development
0 likes · 10 min read
Understanding IoC: Inversion of Control, Dependency Injection, and Their Benefits
Programmer DD
Programmer DD
Feb 24, 2021 · Backend Development

Why Field Injection in Spring Is Discouraged and What to Use Instead

The article explains Spring's warning about field injection, compares constructor, setter, and field injection methods with code examples, outlines the drawbacks of field injection such as final‑field incompatibility, hidden dependencies, and tight IOC coupling, and recommends using constructor injection for required beans and setter injection for optional ones.

Constructor InjectionField InjectionJava
0 likes · 6 min read
Why Field Injection in Spring Is Discouraged and What to Use Instead
Java Captain
Java Captain
Feb 20, 2021 · Backend Development

Spring Framework Design Patterns: Summary and Implementation Details

This article provides a comprehensive overview of the design patterns used in the Spring framework—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—explaining their implementation, underlying principles, and practical significance with code examples.

BeanFactoryDesign PatternsFactory Method
0 likes · 15 min read
Spring Framework Design Patterns: Summary and Implementation Details
Architect's Tech Stack
Architect's Tech Stack
Feb 18, 2021 · Backend Development

Summary of Design Patterns Used in the Spring Framework

This article provides a comprehensive overview of how Spring implements classic design patterns such as Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, and Template Method, explaining their implementation details, underlying principles, and practical code examples within the Spring container.

Design Patternsdependency injectionfactory
0 likes · 15 min read
Summary of Design Patterns Used in the Spring Framework
Java Captain
Java Captain
Feb 13, 2021 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains how Spring resolves circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype beans, provides a minimal reflective implementation, and draws an analogy to the classic two‑sum algorithm to illustrate the core principle.

Circular DependencyDesign PatternsJava
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
Architect
Architect
Feb 5, 2021 · Backend Development

Spring Container Startup Listeners and Initialization Techniques

This article explains various ways to execute custom logic during Spring container startup, covering bean constructors, @PostConstruct, InitializingBean, ApplicationListener events, @EventListener, constructor injection, CommandLineRunner, and SmartLifecycle, with code examples and usage guidelines.

Bean InitializationCommandLineRunnerJava
0 likes · 10 min read
Spring Container Startup Listeners and Initialization Techniques
Bitu Technology
Bitu Technology
Feb 2, 2021 · Backend Development

Recap of the Online Scala Meetup: Reactive Ad Platform, Functional Programming, Scala 3 Typeclasses, and Spring‑Akka Microservices

The 2021 Online Scala Meetup organized by Tubi featured four technical talks covering a fully reactive ad‑serving platform built with Scala and Akka‑Streams, a pragmatic take on functional programming, Scala 3 typeclass implementation, and a Spring‑Akka microservice integration, followed by summaries and recruitment information.

AkkaFunctional ProgrammingReactive Programming
0 likes · 4 min read
Recap of the Online Scala Meetup: Reactive Ad Platform, Functional Programming, Scala 3 Typeclasses, and Spring‑Akka Microservices
Programmer DD
Programmer DD
Feb 1, 2021 · Backend Development

Unlock Spring’s Power: 9 Essential Design Patterns Every Backend Engineer Should Master

This article explores nine key Spring framework design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation, underlying principles, and practical code examples, while highlighting how they enable loose coupling and extensibility in backend development.

Design PatternsJavabackend development
0 likes · 15 min read
Unlock Spring’s Power: 9 Essential Design Patterns Every Backend Engineer Should Master
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 30, 2021 · Backend Development

How Spring Implements 9 Classic Design Patterns – From Simple Factory to Template Method

This article explains how the Spring framework embodies nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Strategy, Observer, and Template Method—detailing their implementation principles, core code snippets, and the benefits they bring to dependency injection and bean lifecycle management.

Javaspring
0 likes · 15 min read
How Spring Implements 9 Classic Design Patterns – From Simple Factory to Template Method
vivo Internet Technology
vivo Internet Technology
Jan 27, 2021 · Backend Development

Caffeine Cache: Principles, High‑Performance Read/Write, and Practical Usage in Java

Caffeine is a high‑performance Java 8 local‑cache library that replaces Guava by using the W‑TinyLFU algorithm with three‑queue LRU structures and lock‑free read/write buffers, offering extensive configuration, dynamic runtime adjustments, and safe back‑source loading with distributed locks to prevent cache‑stampede.

CacheCaffeineJava
0 likes · 13 min read
Caffeine Cache: Principles, High‑Performance Read/Write, and Practical Usage in Java
Top Architect
Top Architect
Jan 27, 2021 · Databases

MyBatis Streaming Query (Cursor) – Keeping the Database Connection Open

This article explains what a streaming query is, introduces MyBatis's Cursor interface and its methods, demonstrates common pitfalls such as the cursor being closed prematurely, and provides three practical solutions using SqlSessionFactory, TransactionTemplate, and @Transactional to keep the database connection alive during streaming reads.

Database ConnectionJavaMyBatis
0 likes · 7 min read
MyBatis Streaming Query (Cursor) – Keeping the Database Connection Open
Architecture Digest
Architecture Digest
Jan 26, 2021 · Information Security

API Request Signature Implementation and Best Practices

This article explains how to protect front‑back separated APIs using a request signature scheme, detailing the required parameters, signature generation algorithm, Java filter implementation, anti‑leech timing checks, nonce usage, and duplicate‑submission prevention with Redis.

API securityJavaSignature
0 likes · 6 min read
API Request Signature Implementation and Best Practices
Architecture Digest
Architecture Digest
Jan 19, 2021 · Backend Development

Comprehensive Guide to Spring Validation: Best Practices, Scenarios, and Advanced Features

This article provides an in‑depth tutorial on Spring Validation, covering basic usage, dependency configuration, requestBody and requestParam validation, unified exception handling, group and nested validation, collection checks, custom constraints, programmatic validation, fail‑fast mode, and the differences between @Valid and @Validated.

DTOHibernate ValidatorJava
0 likes · 16 min read
Comprehensive Guide to Spring Validation: Best Practices, Scenarios, and Advanced Features
Top Architect
Top Architect
Jan 17, 2021 · Backend Development

Object Copying in Java: Comparing Apache BeanUtils and Spring BeanUtils

This article explains the concepts of shallow and deep copying in Java, demonstrates how to use Apache BeanUtils and Spring BeanUtils for property copying between objects, compares their implementations and performance, and recommends alternative tools for efficient object mapping.

ApacheBeanUtilsDeepCopy
0 likes · 9 min read
Object Copying in Java: Comparing Apache BeanUtils and Spring BeanUtils
Top Architect
Top Architect
Jan 16, 2021 · Backend Development

Designing a Unified API Response Structure with @ResponseResult in Spring Backend

This article explains how to design a unified API response format in a Spring backend by defining a JSON result structure, using standardized status codes, creating a @ResponseResult annotation, and implementing interceptors and ResponseBodyAdvice to automatically wrap controller outputs for cleaner, more maintainable code.

APIAnnotationJava
0 likes · 8 min read
Designing a Unified API Response Structure with @ResponseResult in Spring Backend
Top Architect
Top Architect
Jan 14, 2021 · Backend Development

Understanding Spring Transaction Management: Mechanisms, Common Pitfalls, and Best Practices

This article explains how Spring transaction management works, details its declarative and programmatic integration methods, examines core implementation classes and AOP proxies, and highlights frequent pitfalls such as ineffective transactions, rollback failures, and timeout issues, providing code examples and solutions for Java backend developers.

AOPJavaTransaction Management
0 likes · 21 min read
Understanding Spring Transaction Management: Mechanisms, Common Pitfalls, and Best Practices