BestHub
Sign in
Tagged articles

spring

1810 articles · Page 13 of 19
Programmer DD
Programmer DD
Jan 12, 2022 · Backend Development

Mastering Spring’s HttpMessageConverter: Elegant Request/Response Handling

This article explains how Spring's HttpMessageConverter abstracts HTTP message conversion, shows how to read request bodies via HttpInputMessage and ServletServerHttpRequest, demonstrates a practical filter using FormHttpMessageConverter, and illustrates writing JSON responses with MappingJackson2HttpMessageConverter, all with concise code examples.

BackendHttpMessageConverterJava
0 likes · 6 min read
Mastering Spring’s HttpMessageConverter: Elegant Request/Response Handling
IT Architects Alliance
IT Architects Alliance
Jan 10, 2022 · Backend Development

How RPC Works: Build a Simple RPC Framework with Spring, Netty, and Zookeeper

This article explains the fundamentals of Remote Procedure Call (RPC), detailing the end‑to‑end workflow—from interface definition and dynamic proxy generation on the client, through service registration in ZooKeeper, to server‑side handling with Spring and Netty—accompanied by complete Java code snippets and configuration examples.

JavaNettyRPC
0 likes · 17 min read
How RPC Works: Build a Simple RPC Framework with Spring, Netty, and Zookeeper
Top Architect
Top Architect
Jan 8, 2022 · Backend Development

Comprehensive Guide to Spring MVC and Spring Boot Annotations

This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean and dependency‑injection annotations, and essential Spring Boot configuration annotations, illustrating their usage with code examples and explaining how they work together to build robust backend applications.

Backend DevelopmentSpring Bootannotations
0 likes · 13 min read
Comprehensive Guide to Spring MVC and Spring Boot Annotations
Architect's Journey
Architect's Journey
Jan 5, 2022 · Backend Development

Why @Transactional Can Trigger Production Outages: Lessons from a Long‑Transaction Failure

The author recounts a real‑world incident where a Spring @Transactional annotation caused database connection exhaustion, deadlocks, and a production outage, explains how long‑running transactions arise from holding a single connection during costly operations, and offers practical ways to avoid them by splitting methods or using programmatic transactions.

@TransactionalDatabase DeadlockJava
0 likes · 10 min read
Why @Transactional Can Trigger Production Outages: Lessons from a Long‑Transaction Failure
Top Architect
Top Architect
Jan 2, 2022 · Backend Development

Debugging Redis Connection Pool Blocking Issues in a Spring Backend Application

The article details a step‑by‑step investigation of a Spring‑based backend where API requests hung due to Redis connection pool misconfiguration, showing how thread dumps, jstack, and Arthas were used to pinpoint blocking in Jedis pool acquisition, and provides corrected configuration and proper connection handling recommendations.

Connection PoolJedisRedis
0 likes · 9 min read
Debugging Redis Connection Pool Blocking Issues in a Spring Backend Application
Top Architect
Top Architect
Dec 28, 2021 · Backend Development

Using @PathVariable for RESTful API Parameters in Spring MVC

This article explains how to use the @PathVariable annotation in Spring MVC to handle required and optional parameters in RESTful URLs, illustrates the syntax with image-based examples, discusses the complexity of multiple parameters, and advises using POST for more intricate cases, while also offering promotional links and giveaways.

API designJavaPathVariable
0 likes · 4 min read
Using @PathVariable for RESTful API Parameters in Spring MVC
Top Architect
Top Architect
Dec 23, 2021 · Backend Development

Implementing Custom Logging with Spring AOP and Annotations

This article explains how to create a custom logging solution in Spring by defining annotation-based AOP aspects, configuring pointcuts, handling various advice types, and persisting log details such as user, operation, parameters, and results into a database using Java code examples.

AOPAspectJJava
0 likes · 14 min read
Implementing Custom Logging with Spring AOP and Annotations
Architect's Tech Stack
Architect's Tech Stack
Dec 21, 2021 · Backend Development

Using @Async Annotation in Spring: Application Scenarios, Built‑in Thread Pools, and Custom Thread‑Pool Configuration

This article explains the @Async annotation in Spring, how it enables asynchronous method execution, compares the built‑in executors, shows how to configure custom thread pools via AsyncConfigurer or AsyncConfigurerSupport, and provides code examples for void, Future and CompletableFuture based async methods.

Javaasyncconcurrency
0 likes · 12 min read
Using @Async Annotation in Spring: Application Scenarios, Built‑in Thread Pools, and Custom Thread‑Pool Configuration
Java Interview Crash Guide
Java Interview Crash Guide
Dec 21, 2021 · Backend Development

How to Implement Custom Logging with Spring AOP and Annotations

This guide explains how to create a custom Spring AOP logging solution by defining a @SystemCrmlog annotation, extracting its parameters via pointcuts, and persisting detailed log entries—including user, method, parameters, and execution results—to a database using aspect advice methods.

AOPJavaLogging
0 likes · 15 min read
How to Implement Custom Logging with Spring AOP and Annotations
Su San Talks Tech
Su San Talks Tech
Dec 15, 2021 · Backend Development

Top 18 Spring Interview Questions and Answers You Must Know

Explore a comprehensive list of 18 essential Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy types, bean lifecycle, circular dependency resolution, transaction management, and Spring Boot auto‑configuration, complete with concise explanations and illustrative diagrams to help you ace your interview.

AOPBackendIOC
0 likes · 17 min read
Top 18 Spring Interview Questions and Answers You Must Know
macrozheng
macrozheng
Dec 13, 2021 · Backend Development

Master Spring Validation: From Simple Use to Advanced Techniques and Internals

This guide thoroughly explores Spring Validation, covering basic and advanced usage such as requestBody and requestParam checks, grouping, nested and collection validation, custom constraints, programmatic validation, fail-fast configuration, and the underlying implementation mechanisms within Spring MVC and Hibernate Validator.

Hibernate ValidatorJavaSpring Boot
0 likes · 17 min read
Master Spring Validation: From Simple Use to Advanced Techniques and Internals
Top Architect
Top Architect
Dec 11, 2021 · Backend Development

Proxy vs. Decorator Patterns and DIY Spring AOP Implementation in Java

This article explains the proxy and decorator design patterns using a coffee analogy, provides complete Java code examples for static and dynamic proxies, discusses their differences, and shows how to implement a Spring‑like AOP mechanism with JDK InvocationHandler and cglib, while also warning about their limitations.

AOPCGLIBDecorator
0 likes · 11 min read
Proxy vs. Decorator Patterns and DIY Spring AOP Implementation in Java
Architect's Tech Stack
Architect's Tech Stack
Dec 10, 2021 · Backend Development

2021 JVM Ecosystem Report Highlights Java Version Adoption, IDE Preferences, Build Tools, and Framework Dominance

The 2021 JVM Ecosystem Report, based on responses from over 2,000 Java developers, reveals a shift from Java 8 to Java 11, widespread use of AdoptOpenJDK and Oracle builds, dominant IDEs like IntelliJ IDEA, Maven as the primary build system, and Spring as the leading framework in the Java ecosystem.

Build ToolsIDEJava
0 likes · 4 min read
2021 JVM Ecosystem Report Highlights Java Version Adoption, IDE Preferences, Build Tools, and Framework Dominance
Top Architect
Top Architect
Dec 8, 2021 · Backend Development

Do You Need Interfaces in the Service Layer? A Top Architect’s Perspective

The article examines whether the Service layer in a Spring‑based Java project truly requires interfaces, debunks common justifications, proposes practical development workflows, and outlines project structures for both single and multiple implementations, concluding with recommendations on when to use interfaces.

Dependency InjectionJavaservice-layer
0 likes · 8 min read
Do You Need Interfaces in the Service Layer? A Top Architect’s Perspective
Selected Java Interview Questions
Selected Java Interview Questions
Dec 4, 2021 · Backend Development

Common Scenarios Where Spring @Transactional Does Not Take Effect

This article explains eight typical situations—such as using non‑transactional storage engines, missing Spring bean registration, non‑public methods, self‑invocation, absent transaction manager, incorrect propagation settings, swallowed exceptions, and wrong exception types—that cause the @Transactional annotation in Spring to appear ineffective, and provides practical solutions for each.

@TransactionalBackendDatabase
0 likes · 7 min read
Common Scenarios Where Spring @Transactional Does Not Take Effect
Programmer DD
Programmer DD
Dec 2, 2021 · Backend Development

Explore IntelliJ IDEA 2021.3: Remote Development, Smart Refactoring, and New Spring Support

IntelliJ IDEA 2021.3 introduces a beta remote development mode, enhanced IDE repair tools, convenient font scaling, streamlined Markdown table creation, advanced unsafe string checks, improved refactoring shortcuts, and multiple Spring framework enhancements, all illustrated with screenshots and GIFs for developers.

IDE FeaturesIntelliJ IDEAJava
0 likes · 6 min read
Explore IntelliJ IDEA 2021.3: Remote Development, Smart Refactoring, and New Spring Support
Java Architect Essentials
Java Architect Essentials
Nov 30, 2021 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains Spring's three‑level cache mechanism for breaking circular dependencies in singleton beans, demonstrates a simplified implementation with Java code, draws an analogy to the classic Two‑Sum algorithm, and highlights the core idea behind dependency injection.

Two Sumcircular dependencydependency-injection
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 29, 2021 · Backend Development

Master Spring’s ObjectFactory & FactoryBean: Real-World Usage

This article explains the differences between Spring’s ObjectFactory and FactoryBean interfaces, demonstrates how they are used internally for bean creation, dependency injection, and servlet API injection, and shows how to customize ObjectFactory behavior to resolve bean conflicts and inject specific implementations.

Backend DevelopmentDependency InjectionJava
0 likes · 9 min read
Master Spring’s ObjectFactory & FactoryBean: Real-World Usage
Architect
Architect
Nov 29, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

This article explains why Spring's @Transactional annotation can silently fail in many typical situations—such as incorrect method visibility, final methods, self‑invocation, unmanaged beans, multithreading, non‑transactional tables, missing configuration, wrong propagation or rollback settings, nested transaction behavior, and oversized transaction scopes—and provides practical solutions to ensure reliable transaction management.

AOPTransaction Managementexception-handling
0 likes · 16 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
macrozheng
macrozheng
Nov 29, 2021 · Backend Development

Why Constructor Injection Outperforms Field and Setter Injection in Spring

This article explains Spring's three dependency injection methods—field, constructor, and setter—examines why IntelliJ IDEA warns against field injection, and compares them across reliability, maintainability, testability, flexibility, cycle detection, and performance, concluding that constructor injection is generally the preferred approach.

Constructor InjectionDependency InjectionField Injection
0 likes · 7 min read
Why Constructor Injection Outperforms Field and Setter Injection in Spring
Senior Brother's Insights
Senior Brother's Insights
Nov 28, 2021 · Backend Development

Why @Transactional Fails with parallelStream and How to Fix It

An Excel import that partially succeeds reveals a hidden bug where Spring’s @Transactional annotation doesn’t roll back when using Java 8’s parallelStream, and the article explains the underlying thread‑local transaction mechanics, demonstrates the issue with code, and offers practical solutions and best‑practice guidelines.

JavaTransactionbug
0 likes · 8 min read
Why @Transactional Fails with parallelStream and How to Fix It
Code Ape Tech Column
Code Ape Tech Column
Nov 27, 2021 · Backend Development

A Comprehensive Guide to 10 Practical Scheduling Solutions for Java and Linux

This article reviews ten widely used scheduling methods—from Linux crontab and Java Thread/Timer to Spring Task, Spring Quartz, and distributed frameworks like XXL‑Job and Elastic‑Job—explaining their configuration, code examples, and advantages and disadvantages for various backend scenarios.

Distributed TasksJavaScheduling
0 likes · 22 min read
A Comprehensive Guide to 10 Practical Scheduling Solutions for Java and Linux
Architects Research Society
Architects Research Society
Nov 25, 2021 · Backend Development

Practical Implementation of Domain‑Driven Design with a Loan Processing Sample Application

This article provides a comprehensive, practical guide to applying Domain‑Driven Design (DDD) in enterprise Java projects, covering architectural principles, project management steps, design patterns, code generation, testing, deployment, and a detailed loan‑processing example that demonstrates how to model, implement, and evolve a rich domain model using Spring, DI, AOP, and related technologies.

DDDDomain-Driven DesignJava
0 likes · 39 min read
Practical Implementation of Domain‑Driven Design with a Loan Processing Sample Application
Architecture Digest
Architecture Digest
Nov 25, 2021 · Backend Development

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

This article details a two‑week effort to diagnose and resolve high CPU usage, server load, Hystrix circuit‑breaker inefficiencies, and Spring data‑binding exceptions in a Java backend service, resulting in doubled QPS capacity, stable circuit breaking under heavy traffic, and significant performance gains.

BackendHystrixJava
0 likes · 16 min read
Performance Optimization of a Java Backend Service: Reducing CPU Load, Improving Hystrix Circuit Breaking, and Fixing Spring Data Binding Issues
macrozheng
macrozheng
Nov 25, 2021 · Backend Development

Why @Transactional Can Crash Production and How to Prevent Long Transactions

This article recounts a production incident caused by using Spring's @Transactional annotation, explains how long-running transactions exhaust database connections, and provides practical strategies—including method splitting, programmatic transactions, and proper AOP proxy usage—to prevent such failures in backend Java applications.

JavaLong TransactionTransactional
0 likes · 10 min read
Why @Transactional Can Crash Production and How to Prevent Long Transactions
Selected Java Interview Questions
Selected Java Interview Questions
Nov 20, 2021 · Backend Development

Design Pattern Summary in the Spring Framework

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

BeanFactoryDesign PatternsFactory Method
0 likes · 13 min read
Design Pattern Summary in the Spring Framework
Programmer DD
Programmer DD
Nov 16, 2021 · Backend Development

Why @Transactional Might Fail in Spring and How to Fix It

This article explains common reasons why Spring's @Transactional annotation can become ineffective—such as self‑invocation, non‑public methods, multiple data sources, incorrect rollback settings, and unsupported database engines—and provides concrete code examples and solutions to ensure proper transaction management.

@TransactionalAOPBackend
0 likes · 7 min read
Why @Transactional Might Fail in Spring and How to Fix It
Top Architect
Top Architect
Nov 14, 2021 · Backend Development

Implementing a Request Logging Aspect with Spring AOP

This article demonstrates how to create a Spring AOP request‑logging aspect that captures request details, parameters, results, execution time, and error information, and discusses enhancements for high‑concurrency environments by aggregating log data into a single JSON object.

AOPAspectJJava
0 likes · 12 min read
Implementing a Request Logging Aspect with Spring AOP
Top Architect
Top Architect
Nov 13, 2021 · Backend Development

Parameter Validation in the Controller Layer Using Hibernate Validator

This article explains how to cleanly perform parameter validation in Java backend applications by placing business‑independent checks in the Controller layer with Hibernate Validator and optional custom annotations, while business‑related checks belong to the Service layer.

ControllerHibernate ValidatorJava
0 likes · 6 min read
Parameter Validation in the Controller Layer Using Hibernate Validator
Code Ape Tech Column
Code Ape Tech Column
Nov 13, 2021 · Backend Development

Spring Framework Interview Questions and Answers Overview

This article compiles a comprehensive set of Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy mechanisms, bean lifecycle, circular dependency resolution, transaction isolation and propagation, as well as Spring Boot auto‑configuration principles, providing concise explanations for each topic.

AOPDependency InjectionDesign Patterns
0 likes · 16 min read
Spring Framework Interview Questions and Answers Overview
Programmer DD
Programmer DD
Nov 12, 2021 · Information Security

Master Spring Authorization Server: Build a Production-Ready OAuth2 Flow

This guide walks you through replacing Spring Security OAuth2.0 with the production-ready Spring Authorization Server, showing how to add OAuth2 client, resource server, and authorization server dependencies, and demonstrating a complete authorization‑code flow demo with detailed request/response examples and configuration snippets.

Javaauthorization-serveroauth2
0 likes · 7 min read
Master Spring Authorization Server: Build a Production-Ready OAuth2 Flow
21CTO
21CTO
Nov 9, 2021 · Backend Development

Mastering Elegant Operation Log Design with AOP and SpEL in Java

This article explains how to implement clean, decoupled operation logs in Java applications using AOP, SpEL, custom annotations, and dynamic templates, covering use cases, implementation methods, code examples, parsing logic, context handling, and integration with Spring Boot.

AOPJavaLogging
0 likes · 27 min read
Mastering Elegant Operation Log Design with AOP and SpEL in Java
dbaplus Community
dbaplus Community
Nov 8, 2021 · Backend Development

How to Elegantly Implement Decoupled Operation Logging with AOP in Spring

This article explains the difference between system and operation logs, presents common log formats, and provides step‑by‑step implementations—including Canal binlog listening, log‑file recording, LogUtil helpers, and a full AOP‑based @LogRecord solution—while detailing template parsing, context handling, custom functions, and persistence in a Spring Boot environment.

AOPCanalJava
0 likes · 27 min read
How to Elegantly Implement Decoupled Operation Logging with AOP in Spring
Selected Java Interview Questions
Selected Java Interview Questions
Nov 7, 2021 · Backend Development

Do Service and DAO Layers Need Interfaces? When to Omit Them in Spring Projects

This article examines whether Service and DAO layers in Java Spring applications must always have interfaces, explains why dependency‑injection frameworks make interfaces optional, discusses development workflows, multiple‑implementation scenarios, project structuring options, and outlines the trade‑offs of using or not using interfaces.

Backend DevelopmentDependency InjectionJava
0 likes · 9 min read
Do Service and DAO Layers Need Interfaces? When to Omit Them in Spring Projects
Architecture Digest
Architecture Digest
Nov 5, 2021 · Backend Development

Parameter Validation in Spring: Controller vs Service Layer, Hibernate Validator, and Commons‑Lang3

This article explains how to place parameter validation in the appropriate Spring layer, demonstrates using Hibernate Validator and commons‑lang3 for concise validation annotations, provides code examples for entity definitions and controller methods, and mentions creating custom validation annotations when needed.

Backend DevelopmentCommons Lang3Controller
0 likes · 6 min read
Parameter Validation in Spring: Controller vs Service Layer, Hibernate Validator, and Commons‑Lang3
Programmer DD
Programmer DD
Nov 5, 2021 · Backend Development

Constructor Injection vs Field Injection: Which Spring Dependency Method Is Best?

This article explains Spring’s three dependency injection methods—Field, Constructor, and Setter—detailing their implementations, advantages, and drawbacks, and shows why IDEs warn against field injection, recommending constructor injection as the preferred approach for.

Constructor InjectionDependency InjectionField Injection
0 likes · 7 min read
Constructor Injection vs Field Injection: Which Spring Dependency Method Is Best?
macrozheng
macrozheng
Nov 1, 2021 · Backend Development

Design Patterns in Java: Strategy, Chain, Template, Observer & Singleton

This article explores six classic design patterns—Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—detailing their real‑world business scenarios, core principles, Java implementations with Spring integration, and how they improve code maintainability, extensibility, and adherence to SOLID principles.

JavaSOLIDSoftware Architecture
0 likes · 27 min read
Design Patterns in Java: Strategy, Chain, Template, Observer & Singleton
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 1, 2021 · Backend Development

2021 Comprehensive Java Learning Roadmap: From Fundamentals to a Competitive Offer

This guide presents a detailed 2021 Java learning roadmap covering programming fundamentals, JVM internals, concurrency, data structures, algorithms, databases, development tools, backend frameworks, DevOps practices, and interview preparation, with curated resources and a practical study schedule to help learners secure a strong job offer.

Backend DevelopmentJavaalgorithms
0 likes · 8 min read
2021 Comprehensive Java Learning Roadmap: From Fundamentals to a Competitive Offer
Java Interview Crash Guide
Java Interview Crash Guide
Nov 1, 2021 · Backend Development

How We Doubled Service QPS and Fixed Hystrix Bottlenecks in Two Weeks

In this article we detail a two‑week sprint that identified and eliminated multiple Java backend performance bottlenecks, optimized CPU usage with jtop, re‑engineered Hystrix circuit‑breaker settings, reduced logging overhead, and fixed Spring data‑binding issues, ultimately doubling QPS and stabilizing service recovery.

HystrixJavaOptimization
0 likes · 16 min read
How We Doubled Service QPS and Fixed Hystrix Bottlenecks in Two Weeks
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 31, 2021 · Backend Development

Comprehensive Guide to Using Spring RestTemplate for HTTP Requests

This article provides a detailed tutorial on Spring's RestTemplate class, covering its overview, setup, and extensive examples of GET, POST, file download, header handling, dynamic URL parameters, and integration with HttpClient and OkHttp, along with complete code snippets and best‑practice recommendations for backend Java development.

APIBackendHTTP
0 likes · 25 min read
Comprehensive Guide to Using Spring RestTemplate for HTTP Requests
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 31, 2021 · Backend Development

Spring Bean Injection Methods: Property, Setter, and Constructor Injection

This article explains Spring's three bean injection approaches—property, setter, and constructor injection—detailing their syntax, advantages, and drawbacks, referencing official Spring documentation to show the evolution from setter to constructor injection and advising developers on best practices.

BackendConstructor InjectionDependency Injection
0 likes · 7 min read
Spring Bean Injection Methods: Property, Setter, and Constructor Injection
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 30, 2021 · Backend Development

Spring Transaction Management: Concepts, Configuration, and Best Practices

This article explains the fundamentals of database transactions, the ACID properties, and how Spring provides both declarative and programmatic transaction support through three core interfaces, detailed configuration examples in XML and Java, and a deep dive into transaction attributes such as isolation, propagation, rollback rules, read‑only mode, and timeout.

BackendJavaProgrammatic
0 likes · 31 min read
Spring Transaction Management: Concepts, Configuration, and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Oct 29, 2021 · Backend Development

Differences Between @Autowired, @Resource, and @Inject and Why Field Injection Is Not Recommended in Spring

This article explains the distinctions among Spring's @Autowired, @Resource, and @Inject annotations, describes the IDE warning "Field injection is not recommended", compares field, setter, and constructor injection methods, and provides best‑practice recommendations with code examples.

AutowiredDependency InjectionInject
0 likes · 14 min read
Differences Between @Autowired, @Resource, and @Inject and Why Field Injection Is Not Recommended in Spring
Architect's Tech Stack
Architect's Tech Stack
Oct 29, 2021 · Backend Development

Spring nohttp Project: Blocking HTTP URLs and Enhancing Security

The article introduces Spring’s open‑source nohttp project, which scans, replaces, and blocks HTTP URLs to prevent man‑in‑the‑middle attacks, outlines its modules and usage with an XML configuration example, and also advertises a free Alibaba Cloud server giveaway and a large interview‑question PDF collection.

Backend DevelopmentJavaXML
0 likes · 4 min read
Spring nohttp Project: Blocking HTTP URLs and Enhancing Security
Architect's Tech Stack
Architect's Tech Stack
Oct 28, 2021 · Backend Development

Commonly Used Spring Annotations – Core, MVC/REST, Boot, Stereotype, Transaction, Scheduling and Testing

This article provides a comprehensive overview of the most frequently used Spring annotations, covering core dependency‑injection annotations, MVC/REST mapping, Spring Boot configuration, stereotype components, transaction management, task scheduling, asynchronous execution, and testing support, with clear code examples for each.

BootDependencyInjectionJava
0 likes · 11 min read
Commonly Used Spring Annotations – Core, MVC/REST, Boot, Stereotype, Transaction, Scheduling and Testing
macrozheng
macrozheng
Oct 27, 2021 · Backend Development

Unlock the Full Power of Spring’s @Value: Tips, Tricks, and Common Pitfalls

This article provides a comprehensive guide to Spring’s @Value annotation, covering basic usage, property naming, handling Unicode and encoding issues, default values, static fields, arrays, collections, EL expressions, bean injection, and the differences between ${} and #{} syntax, with practical code examples and solutions to common problems.

@ValueEL ExpressionsJava
0 likes · 20 min read
Unlock the Full Power of Spring’s @Value: Tips, Tricks, and Common Pitfalls
Top Architect
Top Architect
Oct 22, 2021 · Backend Development

Understanding AOP: AspectJ, Spring AOP, and CGLIB – A Practical Guide

This article explains the fundamentals of Aspect‑Oriented Programming, introduces AspectJ as a standalone AOP solution, demonstrates how to implement a HelloWorld example with compile‑time weaving, compares it with Spring AOP’s runtime proxies, and shows how CGLIB can be used for proxy generation.

AOPAspectJJava
0 likes · 9 min read
Understanding AOP: AspectJ, Spring AOP, and CGLIB – A Practical Guide
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 22, 2021 · Backend Development

Unlock Spring BeanPostProcessor & BeanFactoryPostProcessor for Backend Customization

This article explains how to extend the Spring IoC container using custom BeanPostProcessor, BeanFactoryPostProcessor, and FactoryBean implementations, covering registration methods, ordering, interaction with AOP proxies, and practical code examples for tracing bean creation and externalizing configuration properties.

Backend DevelopmentBeanPostProcessorDependency Injection
0 likes · 13 min read
Unlock Spring BeanPostProcessor & BeanFactoryPostProcessor for Backend Customization
Java Interview Crash Guide
Java Interview Crash Guide
Oct 20, 2021 · Backend Development

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

This article explains how Spring’s core container uses classic design patterns—Simple Factory via BeanFactory, Factory Method with FactoryBean, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—illustrated with code snippets and diagrams to show their implementation and purpose within the framework.

BeanFactoryFactory MethodSingleton
0 likes · 15 min read
How Spring Implements Classic Design Patterns: From Simple Factory to Template Method
Java Architect Essentials
Java Architect Essentials
Oct 15, 2021 · Backend Development

Master Spring MVC & Bean Annotations: A Complete Guide

This article provides a comprehensive overview of Spring MVC request‑mapping annotations, core Spring Bean annotations, dependency‑injection and scope configurations, container setup annotations, and essential Spring Boot annotations, each illustrated with clear code examples and usage tips.

Dependency InjectionJava backendSpring Boot
0 likes · 16 min read
Master Spring MVC & Bean Annotations: A Complete Guide
Selected Java Interview Questions
Selected Java Interview Questions
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.

BackendJavaMyBatis
0 likes · 7 min read
Implementing MyBatis Streaming Queries with Cursor and Keeping Database Connections Open
Java Backend Technology
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.

ControllerJavaspring
0 likes · 16 min read
14 Must-Know Spring MVC Controller Tips for Better Backend Development
Su San Talks Tech
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.

@ValueDependency InjectionEL expression
0 likes · 19 min read
Unlock the Full Power of Spring’s @Value: Tips, Tricks, and Hidden Features
Code Ape Tech Column
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.

@TransactionalAOPBackend
0 likes · 19 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
Top Architect
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.

AOPAspectJCGLIB
0 likes · 4 min read
Understanding Spring AOP Proxy Creation and Common Pitfalls
Selected Java Interview Questions
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.

Dependency InjectionSpring BootWeb MVC
0 likes · 16 min read
Overview of Spring Web MVC and Spring Bean Annotations
Architecture Digest
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.

Backend DevelopmentDependency InjectionFactory Method
0 likes · 13 min read
Understanding Simple Factory, Factory Method, Singleton, Adapter, Decorator, Observer, Strategy, and Template Method Patterns in Spring
High Availability Architecture
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.

AOPBackendJava
0 likes · 25 min read
Elegant Design and Implementation of Operation Logging Using AOP and Dynamic Templates
Programmer DD
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.

JavaKubernetesMicroservices
0 likes · 9 min read
What Makes Spring the Dominant Backend Framework in 2021? Survey Insights
Java Interview Crash Guide
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.

JavaMySQLRedis
0 likes · 18 min read
What I Learned from 20 Java Interviews: High‑Frequency Questions and Real Experiences
JavaEdge
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.

AOPCGLIBDependency Injection
0 likes · 5 min read
Why Spring AOP Doesn’t Apply to ‘this’ Calls and How to Fix It
Spring Full-Stack Practical Cases
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
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.

JavaSpring Bootannotations
0 likes · 13 min read
Overview of Spring Web MVC, Bean, and Boot Annotations
Java Backend Technology
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.

AnnotationBeanImport
0 likes · 18 min read
Mastering Spring Bean Definitions: XML, Annotations, JavaConfig & Import Techniques
Architect's Tech Stack
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.

Javaannotationsspring
0 likes · 12 min read
Commonly Used Spring Framework Annotations Overview
Su San Talks Tech
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.

@TransactionalAOPBackend
0 likes · 19 min read
Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them
Programmer DD
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
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.

JavaRedisdelay queue
0 likes · 14 min read
Implementation of a Redis-Based Delay Queue in Java
Top Architect
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.

Backend DevelopmentEL ExpressionsJava
0 likes · 9 min read
Injecting List, Array, Set, and Map Values in Spring Using @Value and EL Expressions
Architecture Digest
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.

BackendDependency InjectionIOC
0 likes · 9 min read
Injecting Beans with Annotations in Spring
Programmer DD
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 SecurityJava
0 likes · 8 min read
Seamless Data Encryption with ShardingSphere: A Spring Guide
Top Architect
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.

Javaasyncconcurrency
0 likes · 9 min read
Understanding Spring @Async and Custom Thread Pools
Top Architect
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 DesignElasticsearchJava
0 likes · 8 min read
Comprehensive Domain Interface Design and Implementation in Java Backend Systems
Java Backend Technology
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.

Dependency InjectionDesign PatternsJava
0 likes · 14 min read
Eliminate if‑else with Annotation‑Driven Strategy Pattern in Spring Boot
Programmer DD
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.

Dependency InjectionJavaReflection
0 likes · 17 min read
How Does Spring’s @Autowired Work Under the Hood? A Deep Dive
Architecture Digest
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.

BackendDTOJava
0 likes · 15 min read
Comprehensive Guide to Spring Validation: Best Practices, Scenarios, and Advanced Features
Spring Full-Stack Practical Cases
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.

AutowiredBackend DevelopmentCode examples
0 likes · 7 min read
Mastering Spring @Autowired: 9 Powerful Injection Techniques