Tagged articles

1744 articles

Page 13 of 18

Oct 12, 2021 · Backend Development

Implementing MyBatis Streaming Queries with Cursor and Keeping Database Connections Open

The article explains the concept of streaming queries in MyBatis, introduces the Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three practical solutions—SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open during iteration.

BackendCursorMyBatis

0 likes · 7 min read

Implementing MyBatis Streaming Queries with Cursor and Keeping Database Connections Open

Java Backend Technology

Oct 12, 2021 · Backend Development

14 Must-Know Spring MVC Controller Tips for Better Backend Development

This article walks through fourteen practical techniques for building Spring MVC controllers, covering annotation‑based definitions, interface implementation, extending abstract classes, URL mapping, request method handling, parameter binding, model handling, redirects, form validation, file uploads, autowiring services, and best practices such as single‑responsibility and domain‑specific controller design.

ControllerSpring MVCjava

0 likes · 16 min read

14 Must-Know Spring MVC Controller Tips for Better Backend Development

Su San Talks Tech

Oct 11, 2021 · Backend Development

Unlock the Full Power of Spring’s @Value: Tips, Tricks, and Hidden Features

This comprehensive guide explores Spring's @Value annotation, covering basic usage, property name handling, encoding issues, default values, static fields, various data types, collection injection, EL expressions, bean injection, and the differences between ${} and #{} to help Java developers master configuration injection.

@ValueConfigurationEL expression

0 likes · 19 min read

Unlock the Full Power of Spring’s @Value: Tips, Tricks, and Hidden Features

Code Ape Tech Column

Oct 9, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

This article explains why Spring @Transactional may become ineffective or fail to roll back in various situations—such as wrong method visibility, final modifiers, internal calls, missing Spring bean registration, multithreading, unsupported table engines, misconfigured propagation, swallowed exceptions, and improper rollback settings—while also offering practical solutions and best‑practice recommendations.

Backendaopjava

0 likes · 19 min read

Common Scenarios Where Spring Transactions Fail and How to Fix Them

ITFLY8 Architecture Home

Oct 8, 2021 · Backend Development

Why Interface‑Based Domain Models Boost Flexibility in Java Back‑End Design

This article explains how designing domain objects, services, and repositories as interfaces in Java enables seamless switching between different persistence technologies and deployment models, improving modularity, testability, and adaptability for micro‑service architectures.

DDDInterfaceRepository

0 likes · 10 min read

Why Interface‑Based Domain Models Boost Flexibility in Java Back‑End Design

Top Architect

Oct 6, 2021 · Backend Development

Understanding Spring AOP Proxy Creation and Common Pitfalls

This article explains how Spring AOP weaves aspect code using dynamic proxies, why internal calls via this bypass proxy logic, and how to correctly configure and obtain proxied beans using JDK/CGLIB proxies, @EnableAspectJAutoProxy, @Autowired injection, and AopContext.

Proxyaopaspectj

0 likes · 4 min read

Understanding Spring AOP Proxy Creation and Common Pitfalls

Selected Java Interview Questions

Oct 5, 2021 · Backend Development

Overview of Spring Web MVC and Spring Bean Annotations

This article provides a comprehensive guide to Spring Web MVC and Spring Bean annotations, detailing usage, attributes, and examples of @RequestMapping, @GetMapping, @PostMapping, @ControllerAdvice, @Autowired, @Scope, and various Spring Boot conditional annotations, helping developers understand and apply them effectively.

Spring BootWeb MVCannotations

0 likes · 16 min read

Overview of Spring Web MVC and Spring Bean Annotations

Architecture Digest

Oct 5, 2021 · Backend Development

Understanding Simple Factory, Factory Method, Singleton, Adapter, Decorator, Observer, Strategy, and Template Method Patterns in Spring

This article explains how Spring implements classic design patterns—including Simple Factory via BeanFactory, Factory Method with FactoryBean, Singleton with double‑checked locking, Adapter through HandlerAdapter, Decorator via Wrapper classes, Observer in its event model, Strategy via the Resource interface, and Template Method in JdbcTemplate—providing clear examples and code snippets for each.

Factory MethodSingletonbackend-development

0 likes · 13 min read

Understanding Simple Factory, Factory Method, Singleton, Adapter, Decorator, Observer, Strategy, and Template Method Patterns in Spring

Java Interview Crash Guide

Sep 30, 2021 · Backend Development

How Spring Boot Auto‑Configuration Works: A Deep Dive into the Mechanics

This article explains how Spring Boot’s auto‑configuration mechanism operates, covering configuration files, key annotations like @EnableAutoConfiguration, the role of spring.factories, conditional annotations, and how properties are bound to beans to become effective at runtime.

Spring Bootannotationsauto-configuration

0 likes · 9 min read

How Spring Boot Auto‑Configuration Works: A Deep Dive into the Mechanics

High Availability Architecture

Sep 28, 2021 · Backend Development

Elegant Design and Implementation of Operation Logging Using AOP and Dynamic Templates

This article explains the differences between system and operation logs, explores various implementation methods such as Canal, file logging, LogUtil, and method annotations, and demonstrates how to achieve clean, dynamic, and decoupled operation logging in Java Spring applications using AOP, SpEL, custom functions, and a well‑structured logging context.

BackendSpELaop

0 likes · 25 min read

Elegant Design and Implementation of Operation Logging Using AOP and Dynamic Templates

Programmer DD

Sep 28, 2021 · Backend Development

What Makes Spring the Dominant Backend Framework in 2021? Survey Insights

A 2021 survey reveals that Spring remains the leading Java backend platform, with 75% of developers using core modules, over 80% adopting modern architectures, and growing interest in Kotlin, Spring Native, and Kubernetes integration, highlighting its extensive ecosystem and productivity benefits.

KubernetesMicroservicesSpring Native

0 likes · 9 min read

What Makes Spring the Dominant Backend Framework in 2021? Survey Insights

Java Interview Crash Guide

Sep 28, 2021 · Backend Development

What I Learned from 20 Java Interviews: High‑Frequency Questions and Real Experiences

The author, a senior Java developer with ten years of experience, documents a ten‑day interview marathon across 20 companies, summarizing interview processes, outcomes, and the most frequently asked technical questions on Java fundamentals, Spring, MySQL, Redis, MQ, and micro‑service architecture to help fellow developers prepare effectively.

interviewjavamysql

0 likes · 18 min read

What I Learned from 20 Java Interviews: High‑Frequency Questions and Real Experiences

JavaEdge

Sep 25, 2021 · Backend Development

Why Spring AOP Doesn’t Apply to ‘this’ Calls and How to Fix It

This article explains why Spring AOP proxies are not applied when a bean invokes its own methods via the this reference, compares JDK and CGLIB proxy mechanisms, and shows how to enable proxy exposure or use AopContext to achieve the desired AOP behavior.

JDKProxyaop

0 likes · 5 min read

Why Spring AOP Doesn’t Apply to ‘this’ Calls and How to Fix It

Spring Full-Stack Practical Cases

Sep 23, 2021 · Backend Development

Unlock Spring’s Aware Interfaces: Access ApplicationContext, Environment, and BeanFactory

This tutorial explains how implementing Spring’s *Aware interfaces lets beans obtain ApplicationContext, Environment, and BeanFactory objects, walks through the underlying processing mechanism, and provides concrete code examples with the relevant Spring classes and lifecycle hooks.

Aware InterfaceBeanPostProcessordependency-injection

0 likes · 3 min read

Unlock Spring’s Aware Interfaces: Access ApplicationContext, Environment, and BeanFactory

Code Ape Tech Column

Sep 21, 2021 · Backend Development

Overview of Spring Web MVC, Bean, and Boot Annotations

This article provides a comprehensive guide to Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot conditional and configuration annotations, illustrating each with code examples and usage notes for Java backend development.

Spring BootSpring MVCannotations

0 likes · 13 min read

Overview of Spring Web MVC, Bean, and Boot Annotations

Meituan Technology Team

Sep 16, 2021 · Backend Development

Elegant Operation Log Recording in Backend Systems Using AOP and Annotations

The article demonstrates how to implement elegant, business‑logic‑independent operation logging in Java back‑ends by using AOP‑driven annotations, SpEL dynamic templates, custom parse functions, thread‑local context, and a Spring Boot starter, offering flexible persistence and automatic operator retrieval.

BackendOperation Logannotation

0 likes · 27 min read

Elegant Operation Log Recording in Backend Systems Using AOP and Annotations

Java Backend Technology

Sep 12, 2021 · Backend Development

Mastering Spring Bean Definitions: XML, Annotations, JavaConfig & Import Techniques

This comprehensive guide explores every way to define Spring beans—from classic XML configurations and constructor or setter injection to modern @Component annotations, JavaConfig @Bean methods, and advanced @Import, ImportSelector, and post‑processor techniques—empowering developers to choose the most suitable approach for any project.

ImportJavaConfigPostProcessor

0 likes · 18 min read

Mastering Spring Bean Definitions: XML, Annotations, JavaConfig & Import Techniques

Architect's Tech Stack

Sep 11, 2021 · Backend Development

Commonly Used Spring Framework Annotations Overview

This article introduces the most frequently used Spring framework annotations—including core, MVC/REST, Spring Boot, stereotype, transaction, scheduling, and testing annotations—explaining their purposes, usage locations, and providing Java code examples to illustrate how they configure beans, handle requests, and manage application behavior.

SpringBootannotationsjava

0 likes · 12 min read

Commonly Used Spring Framework Annotations Overview

Selected Java Interview Questions

Sep 8, 2021 · Backend Development

Understanding Circular Dependency Issues in Spring IoC and Their Resolution

This article provides a comprehensive overview of Spring IoC circular dependency problems, explains the three types of circular dependencies, demonstrates them with Java and XML code, and details how Spring resolves singleton setter‑based cycles using its three‑level cache mechanism.

IoCbackend-developmentcircular-dependency

0 likes · 7 min read

Understanding Circular Dependency Issues in Spring IoC and Their Resolution

Su San Talks Tech

Sep 4, 2021 · Backend Development

Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them

This article explores why Spring transactions may fail, covering seven common pitfalls such as incorrect method visibility, final methods, internal calls, missing Spring management, multithreading, unsupported table engines, and misconfigured propagation, and provides practical solutions to ensure reliable transaction handling.

Backendaopspring

0 likes · 19 min read

Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them

Programmer DD

Sep 2, 2021 · Backend Development

Unlocking Spring: 9 Essential Design Patterns Every Backend Developer Should Know

This article explains how Spring implements nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation mechanisms, core principles, key Spring interfaces, and code examples for each pattern.

backend-developmentdependency-injectionjava

0 likes · 16 min read

Unlocking Spring: 9 Essential Design Patterns Every Backend Developer Should Know

Top Architect

Aug 29, 2021 · Backend Development

Implementation of a Redis-Based Delay Queue in Java

This article explains the design and step‑by‑step implementation of a Redis delay queue using Java and Spring, covering the workflow, core components, task states, public APIs, container classes, timer handling, and testing procedures with complete code examples.

delay queuejavaredis

0 likes · 14 min read

Implementation of a Redis-Based Delay Queue in Java

Top Architect

Aug 27, 2021 · Backend Development

Injecting List, Array, Set, and Map Values in Spring Using @Value and EL Expressions

This article explains how to configure and inject List, Map, Set, and array values in Spring applications using @Value annotations, EL expression split functions, default values, and custom parsing methods, providing practical code examples and discussing the advantages and limitations of each approach.

EL ExpressionsValue Annotationbackend-development

0 likes · 9 min read

Injecting List, Array, Set, and Map Values in Spring Using @Value and EL Expressions

Architecture Digest

Aug 26, 2021 · Backend Development

Injecting Beans with Annotations in Spring

This article explains how to use Spring annotations such as @Component, @Configuration, @Bean, @Autowired, and @Qualifier to inject beans via XML replacement, constructor injection, setter injection, property injection, List and Map injection, providing code examples and detailed explanations for each method.

BackendIoCannotations

0 likes · 9 min read

Injecting Beans with Annotations in Spring

Programmer DD

Aug 24, 2021 · Databases

Seamless Data Encryption with ShardingSphere: A Spring Guide

This article explains why encrypting sensitive customer data in databases is essential, outlines common pain points, and demonstrates how Apache ShardingSphere’s data‑desensitization module can be quickly configured in Spring (XML and Boot) to provide transparent AES encryption and decryption without altering business code.

AESDatabase SecurityShardingSphere

0 likes · 8 min read

Seamless Data Encryption with ShardingSphere: A Spring Guide

Top Architect

Aug 19, 2021 · Backend Development

Understanding Spring @Async and Custom Thread Pools

This article explains how Spring's @Async annotation enables asynchronous method execution, compares synchronous and asynchronous flows, reviews the built‑in executors, highlights the drawbacks of the default SimpleAsyncTaskExecutor, and demonstrates how to configure a custom thread pool using AsyncConfigurer or TaskExecutor beans.

AsyncThreadPoolconcurrency

0 likes · 9 min read

Understanding Spring @Async and Custom Thread Pools

Top Architect

Aug 19, 2021 · Backend Development

Comprehensive Domain Interface Design and Implementation in Java Backend Systems

This article explores comprehensive domain interface design in Java backend development, showing how to model domain objects as interfaces, implement repositories for JPA, MyBatis, and Elasticsearch, handle associations with JPA annotations, and apply these patterns in the open‑source Mallfoundry e‑commerce platform.

Domain-Driven DesignElasticsearchInterface Design

0 likes · 8 min read

Comprehensive Domain Interface Design and Implementation in Java Backend Systems

Java Backend Technology

Aug 19, 2021 · Backend Development

Eliminate if‑else with Annotation‑Driven Strategy Pattern in Spring Boot

This article explains how to replace bulky if‑else statements with a clean, annotation‑based Strategy pattern in a Spring Boot application, covering interface definition, custom annotations, dynamic proxy handling, map injection, and the crucial hashCode/equals overrides for reliable handler lookup.

Design PatternsStrategy Patterndependency-injection

0 likes · 14 min read

Eliminate if‑else with Annotation‑Driven Strategy Pattern in Spring Boot

FunTester

Aug 19, 2021 · Backend Development

Why Does My Java Filter Log Requests Twice? The Hidden Implicit Registration Explained

During development of the DCS_FunTester framework a custom servlet filter logged each HTTP request twice because Spring automatically registered an implicit filter with a lowercase bean name, and overriding the filterName resolved the duplicate logging issue.

Servlet FilterWebFilterduplicate logging

0 likes · 7 min read

Why Does My Java Filter Log Requests Twice? The Hidden Implicit Registration Explained

Top Architect

Aug 18, 2021 · Backend Development

Understanding Spring BeanUtils.copyProperties: Shallow Copy, Use Cases, and Code Examples

This article explains how Spring's BeanUtils.copyProperties performs a shallow copy, outlines scenarios where it is appropriate, compares it with manual setters, and provides Java code examples illustrating its behavior with parent‑child classes and common pitfalls.

BeanUtilsCodeExampleShallowCopy

0 likes · 5 min read

Understanding Spring BeanUtils.copyProperties: Shallow Copy, Use Cases, and Code Examples

Programmer DD

Aug 18, 2021 · Information Security

Spring Authorization Server Goes GA: What This Means for OAuth 2.1 and OpenID Connect

On August 17, Spring announced that Spring Authorization Server has left experimental status and entered the Spring Project family with a production‑ready 0.2.0 release, supporting most of OAuth 2.1 and adding OpenID Connect 1.0 support, and provided a new GitHub repository for developers.

Authorization ServerOAuth 2.1java

0 likes · 3 min read

Spring Authorization Server Goes GA: What This Means for OAuth 2.1 and OpenID Connect

Programmer DD

Aug 18, 2021 · Backend Development

How Does Spring’s @Autowired Work Under the Hood? A Deep Dive

This article explores the various ways to use Spring’s @Autowired annotation—including constructor, setter, field, and collection injection—examines its purpose, and provides a detailed analysis of its implementation in the Spring framework by dissecting the source code and related reflection mechanisms.

Reflectionannotationsdependency-injection

0 likes · 17 min read

How Does Spring’s @Autowired Work Under the Hood? A Deep Dive

Architecture Digest

Aug 17, 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, requestBody and requestParam validation, group and nested validation, collection handling, custom constraints, programmatic validation, fail‑fast mode, and the underlying implementation details within Spring MVC and Hibernate Validator.

BackendHibernateannotations

0 likes · 15 min read

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

Spring Full-Stack Practical Cases

Aug 17, 2021 · Backend Development

Mastering Spring @Autowired: 9 Powerful Injection Techniques

This article explains how Spring's @Autowired annotation works across constructors, methods, fields, arrays, collections, maps, optional dependencies, and special beans, providing practical code examples and important notes on required flags, ordering, and usage restrictions.

AutowiredCode ExamplesSpring Framework

0 likes · 7 min read

Mastering Spring @Autowired: 9 Powerful Injection Techniques

Spring Full-Stack Practical Cases

Aug 16, 2021 · Backend Development

Mastering Spring AOP Pointcuts: Static, Dynamic, and Custom Implementations

This article explains Spring's pointcut implementations, covering static and dynamic pointcuts, regular‑expression based pointcuts, the RegexpMethodPointcutAdvisor, control‑flow pointcuts, and how to create custom pointcuts by subclassing Spring’s abstract pointcut classes, with full XML and Java code examples.

Pointcutaopbackend-development

0 likes · 9 min read

Mastering Spring AOP Pointcuts: Static, Dynamic, and Custom Implementations

Top Architect

Aug 13, 2021 · Backend Development

Understanding Stateful vs. Stateless Beans, Singleton vs. Prototype Scope, and Thread Safety in Spring

This article explains the differences between stateful and stateless Spring beans, the impact of singleton and prototype scopes on thread safety, and demonstrates how ThreadLocal can be used to safely share resources in multithreaded backend applications, complete with code examples.

Bean ScopeThreadLocaljava

0 likes · 13 min read

Understanding Stateful vs. Stateless Beans, Singleton vs. Prototype Scope, and Thread Safety in Spring

Code Ape Tech Column

Aug 9, 2021 · Backend Development

Why Your Custom AOP Annotation Fails in Spring Boot and How to Fix It

This article explains why a custom AOP annotation like @MyMonitor may not trigger advice in Spring Boot, analyzes the proxy‑based limitation of Spring AOP, and provides practical solutions such as self‑injection or AspectJ mode to ensure the advice executes correctly.

Custom AnnotationProxySpring Boot

0 likes · 8 min read

Why Your Custom AOP Annotation Fails in Spring Boot and How to Fix It

Code Ape Tech Column

Aug 8, 2021 · Backend Development

Master Spring @Async: Custom Thread Pools and Real-World Usage

This guide explains how Spring's @Async annotation works, compares built-in executors, shows how to configure custom thread pools via AsyncConfigurer or AsyncConfigurerSupport, and demonstrates various async method signatures including void, Future and CompletableFuture with practical code examples.

AsyncBackendThreadPool

0 likes · 9 min read

Master Spring @Async: Custom Thread Pools and Real-World Usage

Java Backend Technology

Aug 8, 2021 · Backend Development

When to Use @Autowired, @Resource, or @Inject? A Deep Dive into Spring DI

This article explains the differences between Spring's @Autowired, @Resource, and @Inject annotations, compares field, setter, and constructor injection, shows how Spring resolves bean candidates, and outlines the framework's recommendations for choosing the appropriate injection style.

AutowiredInjectdependency-injection

0 likes · 13 min read

When to Use @Autowired, @Resource, or @Inject? A Deep Dive into Spring DI

Xianyu Technology

Aug 5, 2021 · Backend Development

Applying SWAK Framework in Xianyu Search: Architecture and Implementation

The article explains how Xianyu’s search service refactors tightly‑coupled, if‑else‑heavy code by applying the lightweight SWAK framework—defining @SwakInterface and @SwakTag annotations, registering proxy beans, using AOP and CGLIB proxies to route business logic via request‑derived tag groups, achieving clean, modular routing.

BackendDynamicProxySWAK

0 likes · 13 min read

Applying SWAK Framework in Xianyu Search: Architecture and Implementation

Java Interview Crash Guide

Aug 5, 2021 · Backend Development

Mastering Java ThreadPoolExecutor: 4 Rejection Policies Explained & When to Use Them

Java's ThreadPoolExecutor offers four rejection policies—AbortPolicy, DiscardPolicy, DiscardOldestPolicy, and CallerRunsPolicy—each handling task overflow differently; this article explains their behavior, default setting, code examples, and how to configure them via Spring's ThreadPoolTaskExecutor for various business scenarios.

RejectionPolicyThreadPoolExecutorconcurrency

0 likes · 9 min read

Mastering Java ThreadPoolExecutor: 4 Rejection Policies Explained & When to Use Them

Java High-Performance Architecture

Aug 4, 2021 · Backend Development

Top 10 Common Spring Framework Mistakes and How to Fix Them

This article outlines the ten most frequent errors developers make when using the Spring framework—ranging from over‑focusing on low‑level details to neglecting proper testing—and provides concrete best‑practice solutions with code examples to improve code quality, maintainability, and reliability.

backend-developmentjavaspring

0 likes · 17 min read

Top 10 Common Spring Framework Mistakes and How to Fix Them

Java Backend Technology

Aug 3, 2021 · Backend Development

Why Java 11 Dominates Production: Insights from the 2021 JVM Ecosystem Report

According to Snyk’s 2021 JVM Ecosystem Report, Java 11 now powers 61.5% of production environments, while Java 8 usage declines, and the Java community overwhelmingly favors Spring, IntelliJ IDEA, Maven, and a growing mix of IDEs and languages like Kotlin.

IDEJVMVersion Adoption

0 likes · 5 min read

Why Java 11 Dominates Production: Insights from the 2021 JVM Ecosystem Report

Top Architect

Jul 31, 2021 · Backend Development

Understanding Spring Bean Instantiation Process

This article explains how Spring's IoC container creates and manages beans, covering the container startup phase, bean definition loading, BeanFactoryPostProcessor and BeanPostProcessor extensions, object creation strategies, property injection, Aware interfaces, and bean lifecycle callbacks.

IoCbeandependency-injection

0 likes · 14 min read

Understanding Spring Bean Instantiation Process

Selected Java Interview Questions

Jul 30, 2021 · Backend Development

Comprehensive Collection of Java Backend Interview Questions and Topics

This page aggregates over 300 curated interview question articles covering Java backend development topics such as Spring, MySQL, Redis, concurrency, data structures, and system design, organized by issue numbers to help candidates prepare effectively for technical interviews.

Backendinterviewjava

0 likes · 19 min read

Comprehensive Collection of Java Backend Interview Questions and Topics

Selected Java Interview Questions

Jul 29, 2021 · Backend Development

Java 11 Migration Guide: Release Cycle, LTS, Tool Updates, JPMS Migration, and Compatibility Issues

This guide explains the Java 11 migration process, covering the new JDK release schedule, LTS support, OpenJDK and Amazon Corretto adoption, required tool upgrades, JPMS module changes, class‑loader differences, obsolete JVM options, and common framework compatibility problems.

JDK11JPMSModules

0 likes · 15 min read

Java 11 Migration Guide: Release Cycle, LTS, Tool Updates, JPMS Migration, and Compatibility Issues

Architect's Tech Stack

Jul 29, 2021 · Databases

Quick Start Guide to Data Encryption (Masking) with Apache ShardingSphere in Spring and Spring Boot

This article explains how to use Apache ShardingSphere's encryption module to transparently store and query sensitive customer data such as ID numbers and bank cards by configuring encryption rules in Spring or Spring Boot, eliminating manual SQL encryption and simplifying compliance for legacy systems.

Database SecuritySQL MaskingShardingSphere

0 likes · 9 min read

Quick Start Guide to Data Encryption (Masking) with Apache ShardingSphere in Spring and Spring Boot

Programmer DD

Jul 29, 2021 · Databases

Secure Sensitive Data in ShardingSphere: Quick Start Guide for Spring

This tutorial explains why encrypting sensitive fields like ID numbers and bank cards is required, outlines common pain points, and shows how to configure ShardingSphere's data‑desensitization module using Spring namespace or Spring Boot with full code examples and configuration files.

Database SecurityShardingSpheredata encryption

0 likes · 8 min read

Secure Sensitive Data in ShardingSphere: Quick Start Guide for Spring

Fulu Network R&D Team

Jul 27, 2021 · Databases

Understanding Flyway: Database Migration Tool Overview and Spring Integration

Flyway is an open‑source database migration tool that version‑controls SQL scripts, supports many databases, and integrates with Maven and Spring to automate schema changes across environments, offering commands such as migrate, clean, info, validate, baseline, undo and repair, with detailed configuration examples.

Flywaydatabase migrationmaven

0 likes · 9 min read

Understanding Flyway: Database Migration Tool Overview and Spring Integration

Java Interview Crash Guide

Jul 27, 2021 · Backend Development

Mastering Spring AOP: From Basics to Advanced Real‑World Examples

This article introduces Aspect‑Oriented Programming in Spring, explains core concepts such as pointcut, advice, aspect, join point and weaving, and provides step‑by‑step code examples—including a simple @GetMapping logger, a custom permission annotation with multiple aspects, and detailed usage of @Pointcut, @Around, @Before, @After, @AfterReturning and @AfterThrowing annotations—illustrated with diagrams and runnable snippets.

Aspect Oriented Programmingannotationsaop

0 likes · 19 min read

Mastering Spring AOP: From Basics to Advanced Real‑World Examples

Selected Java Interview Questions

Jul 26, 2021 · Fundamentals

Understanding Java Reflection: Advantages, Disadvantages, and Practical Use Cases

This article explains Java's reflection mechanism, discusses its strengths and weaknesses, and demonstrates common scenarios such as JDBC connection setup and Spring framework bean loading with clear code examples, helping developers decide when to apply reflection in backend development.

BackendJDBCReflection

0 likes · 9 min read

Understanding Java Reflection: Advantages, Disadvantages, and Practical Use Cases

Top Architect

Jul 26, 2021 · Backend Development

Performance Optimization of Java Backend Services: Reducing CPU Load, Improving Hystrix Circuit Breaking, and Fixing Spring Data Binding Issues

This article describes how a Java backend service suffered high CPU usage and load, how the team diagnosed the problems with jtop and thread stacks, optimized JSON/Bean processing, re‑engineered Hystrix circuit‑breaker settings, reduced logging overhead, and fixed Spring data‑binding exceptions to double the QPS and achieve stable recovery after traffic spikes.

HystrixJVMcircuit breaker

0 likes · 15 min read

Performance Optimization of Java Backend Services: Reducing CPU Load, Improving Hystrix Circuit Breaking, and Fixing Spring Data Binding Issues

Selected Java Interview Questions

Jul 23, 2021 · Backend Development

Global Exception Handling in Spring MVC Using @ControllerAdvice and @ExceptionHandler

This article explains why global exception handling is needed in Spring MVC, outlines its application scenarios, compares AOP with the simpler @ControllerAdvice/@ExceptionHandler approach, and provides detailed code examples for custom response objects, validation handling, and transaction rollback strategies to improve code cleanliness and maintainability.

BackendControllerAdviceException Handling

0 likes · 11 min read

Global Exception Handling in Spring MVC Using @ControllerAdvice and @ExceptionHandler

Top Architect

Jul 23, 2021 · Backend Development

Design Patterns in the Spring Framework: A Comprehensive Overview

This article provides a detailed overview of how the Spring framework implements classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—illustrated with code snippets and explanations of their roles in Spring's dependency injection and bean lifecycle management.

Design PatternsSingletondependency-injection

0 likes · 14 min read

Design Patterns in the Spring Framework: A Comprehensive Overview

Spring Full-Stack Practical Cases

Jul 21, 2021 · Backend Development

Mastering Spring @Autowired: 9 Powerful Injection Techniques

This guide explains how Spring's @Autowired annotation works across constructors, methods, fields, arrays, collections, maps, optional dependencies, and built‑in Spring components, providing code examples and tips for handling required and optional beans in a Spring 5.2.15 environment.

Autowiredbackend-developmentdependency-injection

0 likes · 7 min read

Selected Java Interview Questions

Jul 21, 2021 · Backend Development

Using Spring BeanUtils for Object Property Copying and List Conversion

This article demonstrates how to use Spring's BeanUtils.copyProperties method to copy properties between objects and provides a generic utility to convert a list of source objects into a list of target objects, illustrated with Java code examples for User and Employee classes.

BackendBeanUtilsObject Mapping

0 likes · 5 min read

Using Spring BeanUtils for Object Property Copying and List Conversion

Top Architect

Jul 21, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics

This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP and dynamic proxies create transactional proxies, the role of BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle, accompanied by code examples and diagrams for deeper insight.

aopbackend-developmentjava

0 likes · 10 min read

Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics

Top Architect

Jul 21, 2021 · Databases

How to Perform Streaming Queries with MyBatis Cursor and Keep the Database Connection Open

This article explains the concept of streaming queries, introduces MyBatis' Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or the @Transactional annotation—to keep the database connection alive during iteration.

CursorMyBatisStreaming Query

0 likes · 7 min read

How to Perform Streaming Queries with MyBatis Cursor and Keep the Database Connection Open

Java Captain

Jul 21, 2021 · Backend Development

Integrating Alipay’s New Transfer API (alipay.fund.trans.uni.transfer) in a Java Spring Application

This guide explains how to integrate Alipay’s new secure transfer API (alipay.fund.trans.uni.transfer) into a Java Spring application, covering SDK upgrade, certificate placement, configuration files, Maven dependency, bean injection, and utility classes with full code examples for payment and transfer operations.

AlipayBackendapi-integration

0 likes · 11 min read

Integrating Alipay’s New Transfer API (alipay.fund.trans.uni.transfer) in a Java Spring Application

Code Ape Tech Column

Jul 21, 2021 · Backend Development

Understanding Spring @Transactional Annotation: Implementation Principles and Source Code Analysis

This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP creates proxy objects, the role of BeanPostProcessor, advisors, interceptors, and the TransactionInterceptor, and walks through key source code snippets that manage transaction boundaries.

Backendaopjava

0 likes · 9 min read

Understanding Spring @Transactional Annotation: Implementation Principles and Source Code Analysis

Java Backend Technology

Jul 20, 2021 · Backend Development

How to Implement Efficient MyBatis Streaming Queries in Spring

Streaming queries return an iterator instead of a full result set, reducing memory usage, but require keeping the database connection open; this guide explains MyBatis’s Cursor interface, its methods, and three practical ways—using SqlSessionFactory, TransactionTemplate, or @Transactional—to safely perform MyBatis streaming queries in Spring.

CursorMyBatisStreaming Query

0 likes · 7 min read

How to Implement Efficient MyBatis Streaming Queries in Spring

Programmer DD

Jul 20, 2021 · Backend Development

Understanding @Autowired, @Resource, and @Inject: When and How to Use Spring DI Annotations

This article explains the differences between Spring's @Autowired, @Resource, and @Inject annotations, describes the injection order and rules, shows code examples for each approach, and discusses why constructor‑based injection is recommended over field injection for cleaner, more maintainable applications.

AutowiredConstructor InjectionField Injection

0 likes · 13 min read

Understanding @Autowired, @Resource, and @Inject: When and How to Use Spring DI Annotations

Code Ape Tech Column

Jul 19, 2021 · Databases

Secure Your Data with ShardingSphere: Quick Start Guide for Spring Encryption

This article explains why sensitive customer data must be encrypted at rest, outlines the drawbacks of manual SQL encryption and retrofitting existing systems, and provides step‑by‑step Spring and Spring Boot configurations using ShardingSphere's encryption module with full code examples.

Database SecurityShardingSpheredata encryption

0 likes · 9 min read

Secure Your Data with ShardingSphere: Quick Start Guide for Spring Encryption

Top Architect

Jul 18, 2021 · Backend Development

Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics

This article explains the @Autowired annotation in Spring, covering its various usage forms such as constructor, setter, method, field, and collection injection, and delves into the underlying implementation details within Spring's AutowiredAnnotationBeanPostProcessor, including metadata handling, reflection-based injection, and common pitfalls.

Autowiredannotationsbackend-development

0 likes · 19 min read

Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics

Java Interview Crash Guide

Jul 15, 2021 · Backend Development

What I Learned From Four Rounds of Alibaba Cainiao Java Interviews

A detailed recount of four interview rounds for a Java backend position at Alibaba Cainiao, covering the breadth of topics from JVM and garbage collection to Spring, MySQL indexing, Kafka, and project design, plus personal reflections and next‑step plans.

JVMinterviewjava

0 likes · 9 min read

What I Learned From Four Rounds of Alibaba Cainiao Java Interviews

Java Backend Technology

Jul 15, 2021 · Fundamentals

Unlocking Java’s SPI: How JDK, Dubbo, and Spring Extend Your Applications

This article explains the Service Provider Interface (SPI) concept, demonstrates its use in plain JDK, Dubbo, and Spring frameworks with code examples, compares their strengths and limitations, and shows how SPI enhances extensibility and modularity in Java applications.

DubboJDKSPI

0 likes · 14 min read

Unlocking Java’s SPI: How JDK, Dubbo, and Spring Extend Your Applications

Spring Full-Stack Practical Cases

Jul 14, 2021 · Backend Development

Understanding Spring Cloud RefreshScope: How Dynamic Configuration Refresh Works

This article explains the inner workings of Spring Cloud's RefreshScope, detailing its source code, registration process, refresh endpoint activation, event-driven refresh mechanism, and how beans annotated with @RefreshScope or @ConfigurationProperties are dynamically reloaded without restarting the application.

@RefreshScopeConfigurationSpringBoot

0 likes · 11 min read

Understanding Spring Cloud RefreshScope: How Dynamic Configuration Refresh Works

Top Architect

Jul 11, 2021 · Backend Development

Implementing Request Logging with Spring AOP: A Practical Guide

This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures request parameters, response data, execution time, and error information, 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: A Practical Guide

Programmer DD

Jul 11, 2021 · Databases

Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close

This article demystifies MyBatis transaction handling by explaining the true JDBC methods—setAutoCommit, commit, rollback—and clarifying common misconceptions about create, begin, close, and suspend, while exploring MyBatis’s Transaction, TransactionFactory, and practical code examples that illustrate how commits, rollbacks, and connection closing behave in various scenarios.

JDBCMyBatisdatabase

0 likes · 10 min read

Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close

Full-Stack Internet Architecture

Jul 9, 2021 · Backend Development

Why IDEA Shows Errors for @Autowired Mapper Beans and How to Fix Them

This article explains why IntelliJ IDEA reports errors when injecting MyBatis @Mapper beans with @Autowired despite successful execution, and provides four practical solutions—including disabling inspections, adding Spring stereotypes, allowing null injection, and using @Resource—to eliminate the warnings.

AutowiredIDEAMyBatis

0 likes · 4 min read

Why IDEA Shows Errors for @Autowired Mapper Beans and How to Fix Them

Programmer DD

Jul 9, 2021 · Backend Development

Why Catching an Exception Doesn't Prevent Spring Transaction Rollback

This article explains why a caught javax.validation.ConstraintViolationException in a Spring @Transactional method does not stop the transaction from rolling back, and shows how to debug the flow with logs and breakpoints to understand the underlying commit process.

Exception Handlingdebuggingjava

0 likes · 4 min read

Why Catching an Exception Doesn't Prevent Spring Transaction Rollback

Code Ape Tech Column

Jul 9, 2021 · Backend Development

How to Keep MyBatis Streaming Queries Alive: Three Practical Solutions

This article explains the concept of MyBatis streaming queries, why keeping the database connection open is essential, and provides three concrete approaches—using SqlSessionFactory, TransactionTemplate, or @Transactional—to ensure cursors remain usable without premature closure.

CursorMyBatisStreaming Query

0 likes · 7 min read

How to Keep MyBatis Streaming Queries Alive: Three Practical Solutions

Programmer DD

Jul 5, 2021 · Backend Development

What the 2021 JVM Ecosystem Survey Reveals About Java, OpenJDK, and Tooling Trends

The 2021 JVM ecosystem report, based on responses from over 2,000 Java developers worldwide, shows OpenJDK now dominates with 77% market share, Java 11 surpasses Java 8 in production, Kotlin gains traction, IntelliJ IDEA leads IDE usage, and Maven remains the top build tool.

IDEJVMKotlin

0 likes · 7 min read

What the 2021 JVM Ecosystem Survey Reveals About Java, OpenJDK, and Tooling Trends

Full-Stack Internet Architecture

Jul 4, 2021 · Backend Development

Using Spring's StopWatch to Measure Code Execution Time

This article explains how to use Spring's built‑in StopWatch utility to record the start and end times of multiple code sections, generate a clear performance summary, and compares it with similar tools from Apache Commons and Guava.

BackendProfilingStopwatch

0 likes · 5 min read

Using Spring's StopWatch to Measure Code Execution Time

Full-Stack Internet Architecture

Jul 3, 2021 · Backend Development

Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster

The article explains how to abstract remote data location logic using an RPC framework built on Spring and Dubbo, demonstrates proxy injection and service registration, and shows how similar principles are applied to Redis Cluster to reduce request redirection and improve scalability.

Distributed Systemsbackend-developmentjava

0 likes · 12 min read

Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster

Code Ape Tech Column

Jul 2, 2021 · Backend Development

Mastering Java Object Copying: Apache vs Spring BeanUtils Compared

This article explains the difference between shallow and deep copying in Java, demonstrates how Apache Commons BeanUtils and Spring Framework BeanUtils perform property copying with code examples, highlights performance concerns, and recommends more efficient alternatives for backend development.

ApacheBackendBeanUtils

0 likes · 8 min read

Mastering Java Object Copying: Apache vs Spring BeanUtils Compared

Spring Full-Stack Practical Cases

Jul 1, 2021 · Backend Development

Mastering Spring @Scope: Custom Scopes, Prototypes, and Injection Techniques

This guide explains how Spring's @Scope annotation determines bean lifecycles, shows the underlying source code handling singleton and prototype scopes, demonstrates creating and registering a custom scope, and provides practical examples of using custom and prototype-scoped beans with proper proxy configuration in Spring Boot.

Custom Scopedependency-injectionprototype

0 likes · 7 min read

Mastering Spring @Scope: Custom Scopes, Prototypes, and Injection Techniques

Wukong Talks Architecture

Jun 29, 2021 · Backend Development

Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware

This article introduces Spring Cache as a framework‑agnostic caching abstraction that eliminates manual cache code, explains its core concepts, annotations, configuration options, and demonstrates practical usage with Redis and custom key, condition, and eviction strategies in Spring Boot applications.

BackendCacheEhcache

0 likes · 15 min read

Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware

Programmer DD

Jun 29, 2021 · Backend Development

Will These Spring @Transactional Methods Roll Back? Explore Four Scenarios

This article examines four Spring Boot @Transactional test cases using a MySQL InnoDB database to determine whether each method rolls back or commits when exceptions are thrown or caught, providing code examples and inviting readers to vote on the outcomes.

Spring Bootjpamysql

0 likes · 4 min read

Will These Spring @Transactional Methods Roll Back? Explore Four Scenarios

Code Ape Tech Column

Jun 28, 2021 · Backend Development

Understanding and Implementing Spring's @Autowired Annotation

This article explains the various ways to use Spring's @Autowired annotation, examines its underlying implementation via reflection, and provides detailed code examples illustrating field, constructor, setter, and collection injection, while also discussing annotation lifecycle and best practices.

AutowiredBackendReflection

0 likes · 17 min read

Understanding and Implementing Spring's @Autowired Annotation

Top Architect

Jun 27, 2021 · Backend Development

Understanding and Implementing Spring's @Autowired Annotation

This article explains the various ways to use Spring's @Autowired annotation, explores its underlying implementation using reflection, analyzes the core processing classes in the Spring framework, and answers common questions about its lifecycle, bean relationships, and why static injection is discouraged.

AutowiredReflectionSpring Boot

0 likes · 17 min read

Spring Full-Stack Practical Cases

Jun 27, 2021 · Backend Development

How Spring Builds AOP Proxies: Advisor Discovery and Custom Proxy Creation

This article explains how Spring 5.3.3 creates AOP proxy objects using Advisors, details the internal methods for locating and applying both bean-defined and @Aspect advisors, and demonstrates how to implement a custom Advisor to intercept methods annotated with @DS, including common pitfalls and solutions.

AdvisorCustomAdvisorProxy

0 likes · 8 min read

How Spring Builds AOP Proxies: Advisor Discovery and Custom Proxy Creation

Selected Java Interview Questions

Jun 26, 2021 · Backend Development

Understanding Spring Autowired: Preventing NullPointerException Compared to Manual Instantiation

The article explains how Spring's automatic dependency injection initializes beans to avoid NullPointerExceptions, contrasting it with manual object creation using new, and provides example code demonstrating proper @Autowired usage versus manual instantiation.

AutowiredBackenddependency-injection

0 likes · 4 min read

Understanding Spring Autowired: Preventing NullPointerException Compared to Manual Instantiation

Alibaba Cloud Developer

Jun 25, 2021 · Cloud Native

Is Spring Still the Best Cloud‑Native Platform? 5 Key Reasons Explained

Spring remains a leading cloud‑native platform because of rapid JDK evolution, a thriving JVM language ecosystem, mature Spring Boot and Spring Cloud for service‑oriented architectures, and Spring Reactive’s support for event‑driven designs, all of which address cost, performance, and modern development needs.

Cloud Nativejavareactive

0 likes · 19 min read

Is Spring Still the Best Cloud‑Native Platform? 5 Key Reasons Explained

Spring Full-Stack Practical Cases

Jun 25, 2021 · Backend Development

How Spring AOP Creates Proxies: Inside AnnotationAwareAspectJAutoProxyCreator

This article walks through Spring’s AOP proxy creation process, detailing how enabling @EnableAspectJAutoProxy registers AnnotationAwareAspectJAutoProxyCreator, how it decides whether to wrap a bean, and the internal methods—wrapIfNecessary, isInfrastructureClass, shouldSkip, and advisor discovery—that together generate the dynamic proxies used at runtime.

Proxyaopaspectj

0 likes · 15 min read

How Spring AOP Creates Proxies: Inside AnnotationAwareAspectJAutoProxyCreator

Programmer DD

Jun 25, 2021 · Backend Development

How Spring Solves Circular Dependencies: Inside the Three‑Level Cache

This article explains why Spring’s default singleton beans can handle circular references, describes the three‑level cache mechanism that makes it possible, shows prototype limitations, provides a minimal implementation example, and even relates the solution to the classic two‑sum algorithm.

Three-level CacheTwo Sumcircular-dependency

0 likes · 9 min read

How Spring Solves Circular Dependencies: Inside the Three‑Level Cache

Alibaba Cloud Developer

Jun 23, 2021 · Cloud Native

Is Spring Still the Best Cloud‑Native Platform? 5 Key Reasons Explained

This article examines why Spring remains a top cloud‑native platform by exploring Java and JDK evolution, the competitive JVM language ecosystem, the maturity of Spring Boot and Spring Cloud for service‑oriented architectures, and Spring Reactive’s support for event‑driven designs.

Cloud NativeJVMjava

0 likes · 19 min read

Tencent Cloud Developer

Jun 23, 2021 · Backend Development

Understanding Java Web Backend: Servlets, JSP, Tomcat, Listeners, Filters, Spring, Spring Boot, and Spring Cloud

Understanding Java web backend requires grasping how Tomcat parses HTTP requests, dispatches them through servlets, JSPs, listeners and filters, and then leverages Spring’s IoC, AOP, MVC, Boot’s auto‑configuration, and Cloud’s micro‑service tools to build robust, industrial‑grade applications.

BackendServletSpring Boot

0 likes · 24 min read

Understanding Java Web Backend: Servlets, JSP, Tomcat, Listeners, Filters, Spring, Spring Boot, and Spring Cloud

Architect's Tech Stack

Jun 22, 2021 · Backend Development

Injecting Lists, Arrays, Sets, and Maps in Spring Using @Value and EL

This article explains how to store and inject collection types such as List, Map, Set, and arrays from Spring configuration files using @Value, @ConfigurationProperties, and Spring Expression Language, while handling missing keys and reducing code‑configuration coupling.

ConfigurationELannotation

0 likes · 7 min read

Injecting Lists, Arrays, Sets, and Maps in Spring Using @Value and EL

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.

MyBatisVuebackend-development

0 likes · 6 min read

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

Top Architect

Jun 20, 2021 · Backend Development

Implementing IP‑Based City Detection and Visit Counting in a Spring Backend

This article explains how to obtain a user's city from their IP address in a Java Spring backend, using the QQWry IP database, custom utility classes, and a login interceptor to count visits per city, with complete code examples and deployment considerations.

Interceptorgeolocationip

0 likes · 6 min read

Implementing IP‑Based City Detection and Visit Counting in a Spring Backend

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 ControlIoCdependency-injection

0 likes · 9 min read

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

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.

Configurationannotationsbean

0 likes · 10 min read

Spring Annotation-Based Bean Registration Guide

Top Architect

Jun 17, 2021 · Big Data

Step‑by‑Step Guide to Installing and Configuring the ELK Stack (Elasticsearch, Logstash, Kibana) on macOS and Linux

This article explains why the ELK stack is useful for large‑scale log collection and analysis, then provides detailed installation, configuration, and integration steps for Elasticsearch, Logstash, and Kibana on both macOS and Linux, including common pitfalls and memory‑tuning tips.

ELKKibanaLinux

0 likes · 14 min read

Step‑by‑Step Guide to Installing and Configuring the ELK Stack (Elasticsearch, Logstash, Kibana) on macOS and Linux

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.

Request Loggingaopaspectj

0 likes · 12 min read

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

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.

FrameworkIoCaop

0 likes · 45 min read

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

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.

Aspect Oriented ProgrammingDesign PatternsProxy

0 likes · 16 min read

Implementing AOP in a Custom Spring‑like Framework

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.

Microservicesenterprise architecturejava

0 likes · 16 min read

Zheng: A Comprehensive J2EE Enterprise Development Framework and Architecture Guide

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.

Connection PoolJedisdebugging

0 likes · 9 min read

Why My Spring API Stalled: Debugging Redis Connection Pool Blocking

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.

AdviceAspect Oriented ProgrammingDynamic Proxy

0 likes · 20 min read

Introduction to AOP (Aspect Oriented Programming) in Java