BestHub
Sign in
Tagged articles

Spring

1874 articles · Page 16 of 19
Programmer DD
Programmer DD
Feb 24, 2021 · Backend Development

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

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

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

Spring Framework Design Patterns: Summary and Implementation Details

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

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

Summary of Design Patterns Used in the Spring Framework

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

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

How Spring Solves Circular Dependencies and the Underlying Essence

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

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

Spring Container Startup Listeners and Initialization Techniques

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

API Request Signature Implementation and Best Practices

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

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

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

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

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

Object Copying in Java: Comparing Apache BeanUtils and Spring BeanUtils

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

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

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

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

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

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

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

AOPBackendJava
0 likes · 21 min read
Understanding Spring Transaction Management: Mechanisms, Common Pitfalls, and Best Practices
Top Architect
Top Architect
Jan 12, 2021 · Backend Development

Introduction to Mock Testing with Spring MVC and MockMvc

This article introduces mock testing for Spring MVC controllers, explains why mocks are useful, describes the main MockMvc components, shows required Maven dependencies, and provides complete example test cases for both view‑returning and JSON‑returning endpoints using JUnit and MockMvc.

BackendJUnitJava
0 likes · 8 min read
Introduction to Mock Testing with Spring MVC and MockMvc
Code Ape Tech Column
Code Ape Tech Column
Jan 12, 2021 · Backend Development

Master MyBatis Streaming Queries: Avoid Cursor Closure Errors with Three Simple Solutions

This article explains the concept of streaming queries in MyBatis, describes the Cursor interface and its methods, demonstrates common pitfalls that cause cursor closure errors, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep the database connection open during iteration.

BackendCursorJava
0 likes · 8 min read
Master MyBatis Streaming Queries: Avoid Cursor Closure Errors with Three Simple Solutions
Architect's Tech Stack
Architect's Tech Stack
Jan 11, 2021 · Backend Development

Commonly Used Spring Framework Annotations and Their Usage

This article introduces the most commonly used Spring framework annotations—including core, MVC/REST, Boot, stereotype, data access, scheduling, and testing annotations—explains their purposes, usage scenarios, and provides Java code examples illustrating how to apply them in typical Spring applications.

DependencyInjectionSpringSpringBoot
0 likes · 12 min read
Commonly Used Spring Framework Annotations and Their Usage
Architecture Digest
Architecture Digest
Jan 10, 2021 · Backend Development

Designing Unified API Response Wrappers with @ResponseResult in Spring

This article explains how to design a consistent JSON response structure for Spring-based micro‑service APIs, introduces a Result wrapper class, demonstrates annotation‑driven response handling, and shows controller, interceptor, and advice implementations to produce clean, maintainable backend responses.

APIJavaResponseWrapper
0 likes · 6 min read
Designing Unified API Response Wrappers with @ResponseResult in Spring
Java Captain
Java Captain
Jan 9, 2021 · Backend Development

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

This article examines whether Service and DAO layers in Java Spring projects should always have interfaces, discusses the arguments for and against using interfaces, and proposes practical structuring and dependency‑injection techniques to decide when interfaces are truly necessary.

DAODependency InjectionJava
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects
Architect's Tech Stack
Architect's Tech Stack
Jan 8, 2021 · Backend Development

Comprehensive Guide to Spring Kafka: Integration, Advanced Features, and Usage

This article provides a detailed tutorial on integrating Kafka with Spring using Spring‑Kafka, covering simple setup, embedded Kafka testing, topic creation, message sending and receiving, transaction support, listener configurations, manual acknowledgment, error handling, retry and dead‑letter queues, and related code examples.

KafkaMicroservicesSpring
0 likes · 21 min read
Comprehensive Guide to Spring Kafka: Integration, Advanced Features, and Usage
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 7, 2021 · Backend Development

Overview of Spring Core Components, IOC, AOP, and Related Technologies

This article provides a comprehensive guide to the Spring framework, covering its core modules, the concepts of Inversion of Control and Aspect‑Oriented Programming, various container implementations, proxy mechanisms, bean lifecycle, design patterns, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.

AOPBackendDependency Injection
0 likes · 31 min read
Overview of Spring Core Components, IOC, AOP, and Related Technologies
Code Ape Tech Column
Code Ape Tech Column
Jan 7, 2021 · Backend Development

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

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

BackendDependency InjectionJava
0 likes · 11 min read
How Spring Solves Circular Dependencies: Inside the Three‑Cache Mechanism
Su San Talks Tech
Su San Talks Tech
Jan 3, 2021 · Backend Development

Eliminate Long if‑else Chains in Java: Design Patterns & Spring Solutions

This article examines the drawbacks of lengthy if‑else statements in Java payment services, explains how they violate the Open/Closed and Single Responsibility principles, and presents multiple refactoring techniques—including custom annotations, dynamic bean naming, template methods, strategy‑factory, and chain‑of‑responsibility patterns—to produce cleaner, more maintainable backend code.

Springif-elsestrategy
0 likes · 17 min read
Eliminate Long if‑else Chains in Java: Design Patterns & Spring Solutions
Programmer DD
Programmer DD
Jan 3, 2021 · Backend Development

Why Spring Ecosystem Dominates Java: Surprising Top200 Rankings Unveiled

An in‑depth look at the latest Java Top‑200 project rankings reveals Spring’s ecosystem as the de‑facto standard, while contrasting tools such as Gradle versus Maven, Kafka versus Pulsar, Spring Security versus Shiro, and many others, highlighting performance, adoption and community strength across the backend landscape.

BackendFrameworksJava
0 likes · 4 min read
Why Spring Ecosystem Dominates Java: Surprising Top200 Rankings Unveiled
Java Backend Technology
Java Backend Technology
Dec 27, 2020 · Backend Development

Do You Really Need Interfaces for Service and DAO Layers in Spring?

This article examines whether Service and DAO layers in Spring projects truly require interfaces, debunks common justifications, explores alternative project structures for single and multiple implementations, and offers practical guidelines on when to use or omit interfaces.

DAODependency InjectionService Layer
0 likes · 8 min read
Do You Really Need Interfaces for Service and DAO Layers in Spring?
21CTO
21CTO
Dec 24, 2020 · Backend Development

Why Java Isn’t Dead: A Developer’s Take on Spring, Microservices, and KISS

The author reflects on returning to Java after three years, arguing that despite the rise of containers and micro‑services, Java’s performance, threading model, and mature ecosystem keep it relevant, while criticizing Spring’s complexity and advocating a simple, KISS‑driven approach.

JavaKISSMicroservices
0 likes · 8 min read
Why Java Isn’t Dead: A Developer’s Take on Spring, Microservices, and KISS
Senior Brother's Insights
Senior Brother's Insights
Dec 24, 2020 · Backend Development

Spring Filter vs Interceptor: When to Use Each in Java Web Apps

This guide explains the concepts, implementation steps, configuration examples, and key differences between Servlet Filters and Spring MVC Interceptors, helping developers choose the right tool for request preprocessing, logging, and access control in Java web applications.

Backend DevelopmentInterceptorJava
0 likes · 12 min read
Spring Filter vs Interceptor: When to Use Each in Java Web Apps
Architecture Digest
Architecture Digest
Dec 21, 2020 · Backend Development

Do You Need an Interface for the Service Layer? A Critical Examination

This article examines whether a Service layer in a Spring‑based backend project truly requires an interface, debunks common justifications, proposes practical development workflows, and outlines the advantages and drawbacks of using or omitting interfaces in various architectural scenarios.

Dependency InjectionService LayerSpring
0 likes · 8 min read
Do You Need an Interface for the Service Layer? A Critical Examination
Selected Java Interview Questions
Selected Java Interview Questions
Dec 11, 2020 · Databases

Implementing MyBatis Streaming Queries in Spring: Concepts, API, and Three Practical Solutions

This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three concrete solutions—using SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open and avoid cursor‑closed errors.

CursorJavaMyBatis
0 likes · 7 min read
Implementing MyBatis Streaming Queries in Spring: Concepts, API, and Three Practical Solutions
Top Architect
Top Architect
Dec 8, 2020 · Backend Development

Understanding Thread Safety of Spring Beans: Singleton vs Prototype Scope

This article explains why Spring beans are not inherently thread‑safe, compares the singleton and prototype scopes, shows how stateless beans can be safe, demonstrates the impact of static fields and injected beans, and provides practical code examples and recommendations for achieving thread safety in Spring applications.

@BeanJavaSpring
0 likes · 11 min read
Understanding Thread Safety of Spring Beans: Singleton vs Prototype Scope
Code Ape Tech Column
Code Ape Tech Column
Dec 7, 2020 · Backend Development

Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master

This article explores nine core design patterns implemented in Spring—simple factory, factory method, singleton, adapter, decorator, proxy, observer, strategy, and template method—detailing their implementation mechanisms, underlying principles, code examples, and practical significance for building loosely coupled, extensible Java applications.

AOPBackend DevelopmentDependency Injection
0 likes · 16 min read
Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master
Architect
Architect
Dec 6, 2020 · Backend Development

Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects

This article examines whether a Service layer in a Spring‑based application truly requires an interface, analyzes common arguments for and against using interfaces, explores project structuring options, and offers practical recommendations based on real‑world development experience.

AOPArchitectureDependency Injection
0 likes · 7 min read
Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects
Programmer DD
Programmer DD
Dec 5, 2020 · Backend Development

Mastering Spring Retry: Deep Dive into Retry and Back‑off Strategies

This article explains Spring Retry's architecture, how @EnableRetry, @Retryable, @Backoff and @Recover work together, details the available retry and back‑off policies, and walks through the core implementation using RetryTemplate and interceptors to provide flexible, AOP‑based retry handling in Java backend applications.

AOPJavaRetry
0 likes · 20 min read
Mastering Spring Retry: Deep Dive into Retry and Back‑off Strategies
Top Architect
Top Architect
Nov 30, 2020 · Backend Development

Understanding AOP in Spring: Concepts, Annotations, and Practical Examples

This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes its core concepts and terminology, and provides step‑by‑step code examples for creating pointcuts, advices, and custom annotations, while also detailing the use of common AOP annotations such as @Pointcut, @Around, @Before, @After, @AfterReturning and @AfterThrowing.

AOPJavaSpring
0 likes · 19 min read
Understanding AOP in Spring: Concepts, Annotations, and Practical Examples
Su San Talks Tech
Su San Talks Tech
Nov 30, 2020 · Backend Development

How to Tame Large Transactions in Spring: 6 Proven Strategies

This article shares practical techniques for handling large transactions in Spring-based backend systems, covering why @Transactional can cause issues, how to use programmatic transactions, move queries outside transactions, avoid remote calls, limit data volume, execute non‑transactional operations, and leverage asynchronous processing.

Declarative TransactionLarge TransactionsProgrammatic Transaction
0 likes · 10 min read
How to Tame Large Transactions in Spring: 6 Proven Strategies
Top Architect
Top Architect
Nov 25, 2020 · Databases

Understanding MyBatis Transaction Mechanisms and JDBC Transaction Behavior

This article explains the real JDBC transaction methods, clarifies common misconceptions about transaction states in MyBatis, details the MyBatis Transaction and TransactionFactory interfaces, and explores special scenarios such as auto‑commit false, missing commit or close, with concrete code examples.

JDBCJavaMyBatis
0 likes · 10 min read
Understanding MyBatis Transaction Mechanisms and JDBC Transaction Behavior
Top Architect
Top Architect
Nov 22, 2020 · Backend Development

Spring vs Spring Boot: Core Differences, Configuration, and Deployment Guide

This article compares Spring and Spring Boot, explaining their fundamental concepts, Maven dependencies, MVC and security configurations, template engine setup, startup mechanisms, and packaging options, while providing practical code examples to help Java developers choose and migrate between the two frameworks.

ConfigurationJavaMaven
0 likes · 12 min read
Spring vs Spring Boot: Core Differences, Configuration, and Deployment Guide
JavaEdge
JavaEdge
Nov 20, 2020 · Backend Development

Why Java Annotations Don't Inherit to Subclass Methods and How to Work Around It

This article explains the limits of annotation inheritance in Java, demonstrates why subclass methods cannot automatically inherit parent annotations, and shows how to use @Inherited, Spring's AnnotatedElementUtils, and find/get semantics to retrieve inherited annotations effectively.

@InheritedAnnotatedElementUtilsInheritance
0 likes · 6 min read
Why Java Annotations Don't Inherit to Subclass Methods and How to Work Around It
Java Backend Technology
Java Backend Technology
Nov 19, 2020 · Backend Development

Why Long Database Transactions Crash Services and How to Prevent Them

The article explains how long‑running database transactions can exhaust connection pools, block threads, and cause widespread service failures, then offers practical strategies—including keeping transactions short, removing RPC calls, enhancing monitoring, and reviewing code—to detect and prevent these high‑risk issues.

Backend PerformanceDatabase Connection PoolSpring
0 likes · 7 min read
Why Long Database Transactions Crash Services and How to Prevent Them
IT Xianyu
IT Xianyu
Nov 18, 2020 · Backend Development

Understanding Spring Framework: Core Concepts, Advantages, and Bean Management

This article provides a comprehensive overview of the Spring framework, explaining its IoC and AOP core, architectural layers, key advantages such as decoupling and declarative transactions, bean scopes, lifecycle settings, and practical object‑creation methods for Java backend development.

BackendBean ScopeIOC
0 likes · 7 min read
Understanding Spring Framework: Core Concepts, Advantages, and Bean Management
Programmer DD
Programmer DD
Nov 11, 2020 · Backend Development

BeanFactory vs ApplicationContext: When to Choose Each in Spring

Spring provides two IoC containers—BeanFactory and ApplicationContext—each with distinct loading strategies, features, and registration behaviors; this article demonstrates their differences through practical code examples, highlighting lazy versus eager loading, automatic post‑processor registration, and why ApplicationContext is generally preferred for enterprise applications.

ApplicationContextBeanFactoryDependency Injection
0 likes · 9 min read
BeanFactory vs ApplicationContext: When to Choose Each in Spring
Xianyu Technology
Xianyu Technology
Nov 5, 2020 · Backend Development

Accelerating Build, Deployment, and Startup for Java Backend Applications

By profiling the idle‑local Java backend, the author cut build, deployment, and startup times by over 30 seconds per cycle through asynchronous Spring bean initialization, selective dependency pruning, layered Docker image construction, and streamlined shutdown, demonstrating a comprehensive, reusable optimization strategy for faster releases.

Build OptimizationCI/CDDocker
0 likes · 13 min read
Accelerating Build, Deployment, and Startup for Java Backend Applications
Top Architect
Top Architect
Nov 3, 2020 · Backend Development

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

This article examines whether every Service and DAO class in a Spring‑based backend should implement an interface, evaluates the common arguments for using interfaces, explains why they often do not hold up, and proposes practical structuring and development approaches for projects that may or may not need multiple implementations.

DAODependency InjectionJava
0 likes · 9 min read
Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects
Java Backend Technology
Java Backend Technology
Oct 31, 2020 · Backend Development

Mastering Java Exceptions and @Transactional: When Do Transactions Roll Back?

This article explains Java exception categories, distinguishing checked from unchecked exceptions, and shows how Spring's @Transactional annotation controls transaction rollbacks, including configurations for rolling back on checked exceptions, preventing rollback on unchecked ones, and best practices for applying @Transactional in backend services.

JavaSpringexception handling
0 likes · 5 min read
Mastering Java Exceptions and @Transactional: When Do Transactions Roll Back?
Laravel Tech Community
Laravel Tech Community
Oct 28, 2020 · Backend Development

Grails 4.0.5 Release: New Features, Updates, and Improvements

Grails 4.0.5 has been released, introducing new features such as enhanced REST API configuration, plugin.groovy loading, performance optimizations, and updates to Micronaut, Spring, SpringBoot, and GORM Datastore, along with improved documentation and resolved issues.

GrailsGroovyHibernate
0 likes · 2 min read
Grails 4.0.5 Release: New Features, Updates, and Improvements
Top Architect
Top Architect
Oct 24, 2020 · Backend Development

Designing a Unified API Response Format for Java Backend Services

This article explains how to create a consistent JSON response structure for Java backend APIs, covering status‑code conventions, a Result wrapper class, static helper methods, a custom @ResponseResult annotation, response‑body advice, and tips for simplifying controller code and handling exceptions.

API DesignJavaSpring
0 likes · 7 min read
Designing a Unified API Response Format for Java Backend Services
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 20, 2020 · Backend Development

Programmatic vs Declarative Transactions in Spring: Advantages, Pitfalls, and Recommendations

This article compares Spring's programmatic and declarative transaction management, explains how each works with code examples, outlines the benefits and limitations of declarative transactions—including granularity and failure scenarios—and argues why developers should consider programmatic transactions for clearer control and fewer hidden bugs.

AOPDeclarative TransactionJava
0 likes · 8 min read
Programmatic vs Declarative Transactions in Spring: Advantages, Pitfalls, and Recommendations
Top Architect
Top Architect
Oct 18, 2020 · Backend Development

Understanding Spring @Enable Annotation Logic and the Role of ConfigurationClassPostProcessor

This article explains how Spring's @Enable annotations are driven by @Import, walks through the entry points in spring.handlers, details the processing flow of ConfigurationClassPostProcessor, distinguishes full and lightweight configuration modes, and describes the CGLIB enhancement that ensures proper @Bean method semantics.

BeanDefinitionCGLIBJava
0 likes · 10 min read
Understanding Spring @Enable Annotation Logic and the Role of ConfigurationClassPostProcessor
Top Architect
Top Architect
Oct 12, 2020 · Backend Development

Comprehensive Guide to Common Spring Framework Annotations

This article provides a comprehensive overview of the most commonly used Spring Framework annotations, including core, stereotype, Spring Boot, MVC/REST, data access, scheduling, and testing annotations, with explanations and code examples illustrating their usage in Java backend development.

DependencyInjectionJavaSpring
0 likes · 12 min read
Comprehensive Guide to Common Spring Framework Annotations
JavaEdge
JavaEdge
Oct 10, 2020 · Fundamentals

Why High‑Level Modules Should Depend on Abstractions: Mastering Dependency Inversion

This article explains the Dependency Inversion Principle, shows why traditional layered architectures suffer from maintenance and reuse problems, provides concrete Java and web examples, and demonstrates how refactoring to abstract interfaces resolves these issues for more flexible, decoupled software design.

JavaSpringabstraction
0 likes · 9 min read
Why High‑Level Modules Should Depend on Abstractions: Mastering Dependency Inversion
IT Xianyu
IT Xianyu
Oct 8, 2020 · Backend Development

Overview of Spring, Spring MVC, Spring Boot, and Spring Cloud

This article introduces Spring as a lightweight IoC and AOP container, explains Spring MVC as its web framework, describes Spring Boot's convention‑over‑configuration approach to simplify setup, and outlines how Spring Cloud builds on Spring Boot to provide micro‑service governance.

BackendJavaSpring
0 likes · 3 min read
Overview of Spring, Spring MVC, Spring Boot, and Spring Cloud
Java Captain
Java Captain
Oct 6, 2020 · Backend Development

Integrating Alipay Payment into an SSM (Spring + Spring MVC + MyBatis) Framework

This tutorial walks through the complete process of configuring a sandbox Alipay environment, setting up keys and URLs, defining the database schema, implementing DAO and service layers, and integrating Alipay payment flow into a Java SSM project with detailed code examples and screenshots.

AlipayBackend DevelopmentJava
0 likes · 11 min read
Integrating Alipay Payment into an SSM (Spring + Spring MVC + MyBatis) Framework
Top Architect
Top Architect
Oct 5, 2020 · Backend Development

Deep Dive into Spring Framework Container Startup: Constructor, BeanFactory, Reader, and Scanner Initialization

This article walks through the Spring Framework container startup process, explaining how the AnnotationConfigApplicationContext constructor prepares the environment, registers readers and scanners, initializes the BeanFactory, sets up condition evaluators and post‑processors, and outlines the default filters used for component scanning.

AnnotationConfigApplicationContextBeanFactoryDependency Injection
0 likes · 15 min read
Deep Dive into Spring Framework Container Startup: Constructor, BeanFactory, Reader, and Scanner Initialization
ITPUB
ITPUB
Sep 29, 2020 · Backend Development

Why Spring WebFlux Matters: Moving Beyond Servlet‑Based MVC

This article explains how Spring WebFlux, built on the Reactor project, provides a reactive, non‑blocking alternative to traditional Servlet‑based Spring MVC, detailing its advantages, limitations, and the considerations developers must evaluate before adopting it.

Backend DevelopmentJavaReactive Programming
0 likes · 9 min read
Why Spring WebFlux Matters: Moving Beyond Servlet‑Based MVC
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 26, 2020 · Fundamentals

Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Spring Dependency Injection

This article explains the three common factory design patterns—simple factory, factory method, and abstract factory—illustrates their Java implementations with product and factory classes, demonstrates client usage, and shows how Spring's dependency injection can replace manual factory instantiation, providing a comprehensive guide for developers.

Abstract FactoryDependency InjectionDesign Patterns
0 likes · 7 min read
Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Spring Dependency Injection
Selected Java Interview Questions
Selected Java Interview Questions
Sep 21, 2020 · Backend Development

Understanding Spring Framework Core Interfaces and Bean Lifecycle from Source Code

This article explains the core interfaces of the Spring Framework, such as BeanDefinition, BeanFactory, ApplicationContext, and BeanPostProcessor, and walks through the bean creation process—including refresh, preInstantiateSingletons, getBean, and the three‑level singleton caches—providing detailed code examples and insights into how Spring resolves circular dependencies.

Bean LifecycleDependency InjectionJava
0 likes · 28 min read
Understanding Spring Framework Core Interfaces and Bean Lifecycle from Source Code
JavaEdge
JavaEdge
Sep 19, 2020 · Backend Development

Mastering Spring Bean Definitions: Naming, Aliases, and Instantiation

Learn how Spring stores bean metadata, the structure of BeanDefinition, naming conventions, alias configuration, and various bean instantiation methods—including constructors, static and instance factory methods—while also discovering how to determine a bean's runtime type using BeanFactory.getType.

BackendBeanDefinitionDependency Injection
0 likes · 11 min read
Mastering Spring Bean Definitions: Naming, Aliases, and Instantiation
Top Architect
Top Architect
Sep 12, 2020 · Backend Development

Key Considerations for Building a Generic TCC Distributed Transaction Framework

This article explains the essential design principles of a TCC (Try‑Confirm‑Cancel) distributed transaction framework, covering the necessity of RM local transactions, integration with Spring's TransactionManager, fault‑recovery mechanisms, idempotency guarantees, and handling of parallel Try/Confirm/Cancel operations.

Distributed TransactionsSpringTCC
0 likes · 22 min read
Key Considerations for Building a Generic TCC Distributed Transaction Framework
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 9, 2020 · Fundamentals

Understanding the Template Method Design Pattern with Java Examples

This article explains the Template Method design pattern, illustrating its structure with Java code examples—including an abstract Drinks class, concrete Tea and Coffee subclasses, hook methods, and real‑world usages in JDK sorting and Spring's application context—while highlighting advantages, drawbacks, and typical scenarios.

Design PatternHook MethodJava
0 likes · 12 min read
Understanding the Template Method Design Pattern with Java Examples
Top Architect
Top Architect
Sep 6, 2020 · Backend Development

Understanding Spring @Transactional: Common Pitfalls and Proper Usage

This article explains how Spring's @Transactional annotation works, common pitfalls such as using it on private methods, and the correct ways to configure propagation, isolation, and bean injection to ensure proper transaction rollback and non‑rollback behavior.

@TransactionalAOPJava
0 likes · 8 min read
Understanding Spring @Transactional: Common Pitfalls and Proper Usage
Top Architect
Top Architect
Aug 30, 2020 · Backend Development

Using Spring Cache with Redis for Efficient Data Caching in Java Applications

This article explains how to accelerate service response by integrating Redis as a key‑value cache with Spring Cache, covering the three‑step implementation, required Maven dependencies, XML configuration, property settings, a custom Cache implementation class, and common Spring Cache annotations.

AOPJavaSpring
0 likes · 12 min read
Using Spring Cache with Redis for Efficient Data Caching in Java Applications
Programmer DD
Programmer DD
Aug 28, 2020 · Backend Development

Master Spring Validation: Best Practices and Advanced Techniques

This article provides a comprehensive guide to Spring Validation, covering basic usage, dependency setup, requestBody and requestParam validation, group and nested validation, collection checks, custom constraints, programmatic validation, fail‑fast configuration, and the underlying implementation mechanisms within Spring MVC and Hibernate Validator.

BackendHibernateSpring
0 likes · 17 min read
Master Spring Validation: Best Practices and Advanced Techniques
Su San Talks Tech
Su San Talks Tech
Aug 27, 2020 · Backend Development

Unveiling Spring Transaction Mechanics: From Annotations to Core Interceptors

This article dives deep into Spring's transaction infrastructure, explaining how @EnableTransactionManagement activates transaction support, detailing the roles of key configuration classes, core interceptors, transaction attribute resolution, propagation behaviors, and the commit‑and‑rollback processes that power reliable data operations in Spring and Spring Boot applications.

AOPBackendSpring
0 likes · 32 min read
Unveiling Spring Transaction Mechanics: From Annotations to Core Interceptors
Top Architect
Top Architect
Aug 22, 2020 · Backend Development

Comprehensive Guide to Spring Validation: Usage, Advanced Features, and Implementation Principles

This article provides a thorough tutorial on Spring Validation, covering basic usage with requestBody and requestParam, dependency setup, group, nested, collection and custom validations, programmatic validation, fail‑fast mode, differences between @Valid and @Validated, as well as the underlying implementation mechanisms in Spring MVC and method‑level AOP validation.

APIHibernate ValidatorJava
0 likes · 17 min read
Comprehensive Guide to Spring Validation: Usage, Advanced Features, and Implementation Principles