BestHub
Sign in
Tagged articles

Spring

1874 articles · Page 18 of 19
Programmer DD
Programmer DD
Nov 22, 2019 · Backend Development

Mastering Spring: A Comprehensive Guide to Java’s Leading Backend Framework

An in‑depth overview of the Spring ecosystem explains its core container, modules such as AOP, MVC, Data, Security, Boot and Cloud, detailing how IoC and dependency injection simplify Java enterprise development, and guides readers through configuration, architecture, and the advantages of using Spring for modern backend applications.

AOPBackend DevelopmentDependency Injection
0 likes · 19 min read
Mastering Spring: A Comprehensive Guide to Java’s Leading Backend Framework
Architect's Tech Stack
Architect's Tech Stack
Nov 21, 2019 · Backend Development

Comprehensive Guide to Spring‑Kafka: Integration, Configuration, and Advanced Features

This article provides a thorough tutorial on using Spring‑Kafka, covering basic Maven setup, producer and consumer code, embedded Kafka for testing, programmatic topic creation, synchronous and asynchronous message sending, transaction handling, request‑reply patterns, advanced @KafkaListener options, manual acknowledgments, lifecycle control, message forwarding with @SendTo, and retry with dead‑letter queues.

@TransactionalKafkaMicroservices
0 likes · 16 min read
Comprehensive Guide to Spring‑Kafka: Integration, Configuration, and Advanced Features
Programmer DD
Programmer DD
Nov 21, 2019 · Backend Development

Mastering High‑Performance Excel Export in Java: A Complete Guide

This article explains how to build a reusable Java utility for exporting massive Excel reports, covering customizable headers, field formatting, multithreaded data retrieval, asynchronous processing, and provides full source code with detailed analysis and usage instructions.

ExcelExportJava
0 likes · 17 min read
Mastering High‑Performance Excel Export in Java: A Complete Guide
Architects Research Society
Architects Research Society
Nov 16, 2019 · Backend Development

Practical Guide to Domain‑Driven Design: Modeling, Architecture, and Implementation

This article presents a comprehensive, practice‑oriented overview of Domain‑Driven Design, covering its conceptual foundations, project‑level management, architectural layering, design patterns, implementation techniques with Java/Spring, testing, continuous integration, and deployment strategies for enterprise applications.

Domain-Driven DesignJavaSpring
0 likes · 39 min read
Practical Guide to Domain‑Driven Design: Modeling, Architecture, and Implementation
21CTO
21CTO
Nov 7, 2019 · Backend Development

Key Takeaways from Meituan’s Java Interview: Backend Questions & Learning Roadmap

This article compiles detailed notes from three rounds of Meituan’s Java interviews, covering SOA, micro‑services, load balancing, concurrency, JVM internals, Spring, database optimization, and algorithm challenges, while also outlining a learning roadmap for seasoned Java developers.

JavaSpringinterview
0 likes · 8 min read
Key Takeaways from Meituan’s Java Interview: Backend Questions & Learning Roadmap
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 30, 2019 · Backend Development

Eliminating Complex if‑else Logic with Strategy and Factory Patterns in a Spring‑Based Java Application

This article explains how excessive if‑else statements in business code hurt readability and maintainability, and demonstrates how to replace them with the Strategy and Factory design patterns integrated with Spring, using a food‑delivery discount example and complete Java code snippets.

BackendDesign PatternsFactory Pattern
0 likes · 12 min read
Eliminating Complex if‑else Logic with Strategy and Factory Patterns in a Spring‑Based Java Application
macrozheng
macrozheng
Oct 29, 2019 · Backend Development

Eliminate Complex if‑else with Strategy & Factory Patterns in Spring

This article explains how to replace tangled if‑else logic in business code with the Strategy and Factory design patterns, integrates them into a Spring application, and demonstrates the resulting improvements in readability, maintainability, and extensibility for discount calculations.

Factory PatternJavaSpring
0 likes · 13 min read
Eliminate Complex if‑else with Strategy & Factory Patterns in Spring
Programmer DD
Programmer DD
Oct 11, 2019 · Backend Development

Mastering Graceful Shutdown in Dubbo: From 2.5.x to 2.7.x

This article explores Dubbo's graceful shutdown mechanisms across versions 2.5.x, 2.6.x, and 2.7.x, detailing the underlying shutdown hooks, registry and protocol cleanup, Spring integration challenges, and best‑practice configurations to ensure in‑flight requests complete without service disruption.

DubboGraceful ShutdownJava
0 likes · 19 min read
Mastering Graceful Shutdown in Dubbo: From 2.5.x to 2.7.x
Selected Java Interview Questions
Selected Java Interview Questions
Sep 29, 2019 · Backend Development

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

Spring, Spring MVC, Spring Boot, and Spring Cloud are Java frameworks that respectively provide core IoC/AOP functionality, web MVC capabilities, convention‑over‑configuration rapid development, and comprehensive microservice governance, together forming a layered ecosystem for building clean, manageable, and scalable backend applications.

BackendJavaSpring
0 likes · 4 min read
Overview of Spring, Spring MVC, Spring Boot, and Spring Cloud
Java Backend Technology
Java Backend Technology
Sep 25, 2019 · Backend Development

Avoid These 10 Common Mistakes in Java Backend Development

This article outlines ten frequent errors that Java backend developers make—from over‑focusing on low‑level details and leaking internal structures to neglecting proper testing—and offers practical guidelines and examples to write cleaner, more maintainable Spring‑based services.

BackendJavaSpring
0 likes · 14 min read
Avoid These 10 Common Mistakes in Java Backend Development
Java Backend Technology
Java Backend Technology
Sep 9, 2019 · Backend Development

Mastering TCC Distributed Transactions: Key Design Principles and Pitfalls

This article explores the complexities of building a generic TCC distributed transaction framework, emphasizing the need for RM-local transaction integration, Spring TransactionManager takeover, fault‑recovery mechanisms, idempotency guarantees, and proper handling of Try/Confirm/Cancel phases to ensure global consistency.

SpringTCCfault-recovery
0 likes · 18 min read
Mastering TCC Distributed Transactions: Key Design Principles and Pitfalls
Java Captain
Java Captain
Aug 24, 2019 · Backend Development

Comprehensive Guide to Spring MVC, Spring Bean, and Spring Boot Annotations

This article provides a detailed overview of the most commonly used Spring MVC request‑mapping annotations, Spring Bean stereotypes, dependency‑injection and scope annotations, container configuration annotations such as @Autowired and @Primary, and essential Spring Boot annotations, illustrating each with clear code examples and diagrams.

JavaSpringSpring Boot
0 likes · 18 min read
Comprehensive Guide to Spring MVC, Spring Bean, and Spring Boot Annotations
macrozheng
macrozheng
Aug 23, 2019 · Backend Development

Why Your Java Controllers Misuse Service Layers—and How to Fix It

This article examines common misuse of base Controller and Service classes in Java Spring projects, explains why they violate the Liskov Substitution Principle, and provides practical steps to split, refactor, and properly structure code across the three‑tier architecture.

ArchitectureBackendJava
0 likes · 22 min read
Why Your Java Controllers Misuse Service Layers—and How to Fix It
Java Backend Technology
Java Backend Technology
Aug 18, 2019 · Backend Development

Mastering Spring Annotations: From @Controller to @CacheEvict

This article provides a comprehensive guide to essential Spring annotations—including @Controller, @RestController, @Service, @Autowired, @RequestMapping, @ModelAttribute, @Cacheable, @CacheEvict, @Resource, @PostConstruct, @PreDestroy, @Repository, @Component, @Scope, @SessionAttributes, @Required and @Qualifier—explaining their purposes, usage patterns, and practical examples with accompanying diagrams.

Dependency InjectionJavaSpring
0 likes · 9 min read
Mastering Spring Annotations: From @Controller to @CacheEvict
Qunar Tech Salon
Qunar Tech Salon
Aug 12, 2019 · Backend Development

QMQ: Design, Usage, and Implementation of Qunar's Distributed Message Queue

This article introduces QMQ, Qunar's internal distributed message queue, covering its background, design motivations, core concepts, code examples for producing and consuming both real‑time and delayed messages, transactional messaging support, and the overall architecture of its metaserver, broker, and delay components.

JavaQMQSpring
0 likes · 18 min read
QMQ: Design, Usage, and Implementation of Qunar's Distributed Message Queue
Java Captain
Java Captain
Aug 11, 2019 · Backend Development

Top Java GitHub Projects in July

This article presents a curated list of the most popular Java open‑source projects on GitHub for July, highlighting eleven repositories—most of them Spring‑based—along with their star counts, brief descriptions, and links for developers seeking valuable resources.

GitHubJavaMicroservices
0 likes · 5 min read
Top Java GitHub Projects in July
Java Backend Technology
Java Backend Technology
Aug 11, 2019 · Backend Development

Why Your Java Controllers and Services Are Misdesigned—and How to Fix Them

This article examines common misuse of base Controller and Service classes in Java micro‑service projects, critiques embedding business logic in Controllers, exposing persistence models to APIs, and offers concrete refactoring steps, project structuring patterns, and best‑practice guidelines to restore a clean three‑layer architecture.

BackendJavaMicroservices
0 likes · 22 min read
Why Your Java Controllers and Services Are Misdesigned—and How to Fix Them
Java Backend Technology
Java Backend Technology
Aug 9, 2019 · Backend Development

10 Common Mistakes in Java Backend Development and How to Avoid Them

This article outlines ten frequent errors that Java backend developers make—from over‑focusing on low‑level details and leaking internal structures to neglecting separation of concerns, proper exception handling, multithreading, validation, XML configuration, profile management, dependency injection, and testing—offering practical guidance to prevent each pitfall.

JavaSpringbest practices
0 likes · 14 min read
10 Common Mistakes in Java Backend Development and How to Avoid Them
Programmer DD
Programmer DD
Jul 31, 2019 · Backend Development

Blocking vs Non‑Blocking in Spring: RestTemplate vs WebClient Explained

This article compares Spring's traditional RestTemplate blocking client with the newer reactive WebClient non‑blocking client, explaining their underlying mechanisms, performance differences under concurrency, and provides complete code examples for both approaches, helping developers choose the appropriate tool for efficient HTTP calls.

HTTPJavaRestTemplate
0 likes · 8 min read
Blocking vs Non‑Blocking in Spring: RestTemplate vs WebClient Explained
Java Captain
Java Captain
Jul 26, 2019 · Fundamentals

Java Fundamentals: Spring Lifecycle, TCP Handshake, Thread Pool, JVM Memory, JMM, Spring MVC, JDBC, Spring Cloud, and Dubbo Overview

This article provides a comprehensive overview of core Java concepts and related technologies, covering Spring's lifecycle, TCP three-way handshake and four-way termination, thread pool execution flow, JVM memory structure and Java Memory Model, as well as Spring MVC, JDBC, Spring Cloud components, and Dubbo service framework.

JVMJavaSpring
0 likes · 11 min read
Java Fundamentals: Spring Lifecycle, TCP Handshake, Thread Pool, JVM Memory, JMM, Spring MVC, JDBC, Spring Cloud, and Dubbo Overview
Programmer DD
Programmer DD
Jul 24, 2019 · Backend Development

Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master

This comprehensive guide explores the fundamentals of the Spring framework—including its core modules, dependency injection, IoC, bean scopes, configuration styles, annotation-driven setup, event handling, and common design patterns—providing Java developers with practical examples and code snippets to master Spring's capabilities.

Bean LifecycleConfigurationDependency Injection
0 likes · 25 min read
Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master
Programmer DD
Programmer DD
Jul 21, 2019 · Backend Development

Understanding Spring, Spring MVC, and Spring Boot: Core Problems Solved and Best Use Cases

This article provides a comprehensive overview of the Spring framework, Spring MVC, and Spring Boot, explaining how dependency injection reduces boilerplate and enables loose coupling, illustrating code examples with and without DI, and describing Spring Boot’s auto‑configuration, starter projects and typical starter options for building modern Java backend applications.

Backend DevelopmentDependency InjectionJava
0 likes · 12 min read
Understanding Spring, Spring MVC, and Spring Boot: Core Problems Solved and Best Use Cases
Programmer DD
Programmer DD
Jul 20, 2019 · Backend Development

Unlocking Spring Bean Lifecycle: Mastering Aware Interfaces

This article completes the Spring Bean lifecycle overview by illuminating the remaining phases, explains how various XxxxAware interfaces are invoked during bean initialization, demonstrates common pitfalls with constructor injection, and provides code examples for implementing and using Aware interfaces such as BeanNameAware and BeanFactoryAware.

Aware InterfaceBackend DevelopmentBean Lifecycle
0 likes · 7 min read
Unlocking Spring Bean Lifecycle: Mastering Aware Interfaces
Programmer DD
Programmer DD
Jul 16, 2019 · Information Security

How to Prevent XSS and SQL Injection in Spring: A Practical Guide

This article explains the dangers of XSS and SQL injection attacks, demonstrates realistic attack scenarios, and provides a comprehensive backend solution using Spring AOP, HttpMessageConverter, custom Servlet Filters, request wrappers, and ESAPI to sanitize inputs and protect web applications.

ESAPISQL injectionSpring
0 likes · 17 min read
How to Prevent XSS and SQL Injection in Spring: A Practical Guide
Java Captain
Java Captain
Jul 14, 2019 · Backend Development

Backend Architecture, Distributed Locks, and Session Management in Java

This article explains a Java backend architecture with front‑end/back‑end separation, deployment diagrams, the concepts of thread, process and distributed locks, implementations using database optimistic locking, Redis and Zookeeper, session handling in distributed systems, and various related code examples and best‑practice notes.

Backend DevelopmentJavaRedis
0 likes · 12 min read
Backend Architecture, Distributed Locks, and Session Management in Java
Programmer DD
Programmer DD
Jul 11, 2019 · Backend Development

Escaping Callback Hell: From Blocking Calls to Reactive Streams in Kotlin

This article explains the code types involved in synchronous remote calls, demonstrates how blocking IO leads to callback hell, and shows how to simplify the programming model using Java CompletableFuture, AsyncHttpClient, and Project Reactor’s reactive streams to efficiently retrieve city data.

AsyncHttpClientCompletableFutureKotlin
0 likes · 9 min read
Escaping Callback Hell: From Blocking Calls to Reactive Streams in Kotlin
Java Captain
Java Captain
Jul 8, 2019 · Backend Development

Understanding Spring Bean Definition Registration Mechanisms

This article explains how Spring registers bean definitions through various mechanisms such as BeanDefinitionRegistryPostProcessor, BeanFactoryPostProcessor, annotations, XML, @Import, ImportSelector and ImportBeanDefinitionRegistrar, using analogies and code examples to illustrate the process.

BeanDefinitionDependencyInjectionJava
0 likes · 13 min read
Understanding Spring Bean Definition Registration Mechanisms
Java Captain
Java Captain
Jul 5, 2019 · Backend Development

Understanding Spring BeanDefinition: Core Concepts, Interfaces, and Practical Examples

This article explains the fundamental role of Spring's BeanDefinition as the core data structure that records all bean metadata, compares it to real‑world analogies, lists the key BeanDefinition interface methods, demonstrates registration via annotations and @Bean methods, and shows how to inspect bean definitions at runtime.

BeanDefinitionDependencyInjectionJava
0 likes · 11 min read
Understanding Spring BeanDefinition: Core Concepts, Interfaces, and Practical Examples
Programmer DD
Programmer DD
Jul 2, 2019 · Backend Development

BeanFactory vs ApplicationContext in Spring: When to Use Which?

This article compares Spring's BeanFactory and ApplicationContext, explaining their roles in retrieving beans, detailing lazy versus eager loading, providing Java and XML code examples, and offering guidance on when to choose each interface for efficient backend development.

ApplicationContextBackend DevelopmentBeanFactory
0 likes · 7 min read
BeanFactory vs ApplicationContext in Spring: When to Use Which?
macrozheng
macrozheng
Jun 27, 2019 · Backend Development

How to Implement Unified Logging with AOP in a Spring MVC Project

This tutorial explains the fundamentals of Aspect Oriented Programming (AOP) and demonstrates how to create a logging aspect in a Spring MVC application, covering AOP terminology, Spring annotations, pointcut expressions, a WebLog DTO, the WebLogAspect implementation, and how to test the logging output via Swagger UI.

AOPJavaSpring
0 likes · 10 min read
How to Implement Unified Logging with AOP in a Spring MVC Project
Java Captain
Java Captain
Jun 18, 2019 · Backend Development

Top Java Open‑Source Projects on GitHub (May)

This article presents a curated list of the most popular Java open‑source projects on GitHub for May, highlighting each repository's purpose, star count, and key features ranging from algorithm visualizations and interview prep notes to full‑stack e‑commerce platforms and core Spring frameworks.

FrameworksGitHubJava
0 likes · 6 min read
Top Java Open‑Source Projects on GitHub (May)
Java Captain
Java Captain
May 29, 2019 · Backend Development

Common Design Patterns Used in the Spring Framework

This article reviews the most frequently applied design patterns in Spring—including IoC/DI, Factory, Singleton, Proxy (AOP), Template Method, Observer, Adapter, and Decorator—explaining their purpose, how Spring implements them, and providing concise code examples for each.

AOPDependency InjectionDesign Patterns
0 likes · 17 min read
Common Design Patterns Used in the Spring Framework
Programmer DD
Programmer DD
May 28, 2019 · Backend Development

Mastering the Strategy Pattern in Spring: Real-World Java Examples

This article explains how to apply the Strategy pattern within a Spring project, covering background, learning objectives, step‑by‑step code examples for query services A, B, and C, the three‑part invocation process, and both list‑based and map‑based configurations.

Backend DevelopmentDesign PatternsJava
0 likes · 3 min read
Mastering the Strategy Pattern in Spring: Real-World Java Examples
Youzan Coder
Youzan Coder
May 17, 2019 · Backend Development

How Youzan’s Unit Test Architecture Solves Common Testing Pain Points

This article explains Youzan’s layered unit‑testing framework for microservice applications, outlines typical pain points such as massive test‑case rewrites, unstable test data, and missing result verification, and demonstrates how tools like DbUnit, H2, springockito, spring‑test and PowerMock are combined to provide data preparation, mock injection, automatic cleanup, and declarative result checks.

DbUnitJavaMockito
0 likes · 13 min read
How Youzan’s Unit Test Architecture Solves Common Testing Pain Points
Java Captain
Java Captain
Apr 6, 2019 · Backend Development

Understanding Spring Transaction Management and AOP Mechanism

This article explains how Spring enables transaction management through @EnableTransactionManagement, details the internal configuration selectors, bean registrations, AOP pointcuts, and the TransactionInterceptor implementation, illustrating the flow of transaction attribute detection, method interception, and exception‑based commit or rollback.

AOPBackend DevelopmentDeclarative Transactions
0 likes · 9 min read
Understanding Spring Transaction Management and AOP Mechanism
Programmer DD
Programmer DD
Apr 2, 2019 · Backend Development

From Freshman to Senior Engineer: A Developer’s Journey Through Java, Spring, and Big Data

This article chronicles a Chinese computer science graduate’s step‑by‑step evolution from learning basic C and Java in university to building campus apps, winning software contests, mastering Spring, Hadoop, Elasticsearch, and Neo4j, and ultimately landing offers from top tech firms, illustrating the challenges and perseverance required for a successful software engineering career.

CareerJavaSpring
0 likes · 13 min read
From Freshman to Senior Engineer: A Developer’s Journey Through Java, Spring, and Big Data
360 Tech Engineering
360 Tech Engineering
Mar 28, 2019 · Backend Development

Implementing Java Scheduled Tasks with Spring and Cron Expressions

This article explains how to implement scheduled tasks in Java, compares built‑in JDK timers, Quartz, and Spring's task scheduler, and provides detailed steps for using Spring XML configuration, annotations, and dynamic code addition together with a guide to writing cron expressions.

BackendCronJava
0 likes · 4 min read
Implementing Java Scheduled Tasks with Spring and Cron Expressions
JD Tech
JD Tech
Mar 22, 2019 · Backend Development

EasyRPC Framework Overview: Architecture, Server Publishing, and Client Invocation

This article introduces the EasyRPC framework, explaining its RPC fundamentals, the use of Netty for communication, Spring for configuration, dynamic proxy for transparent calls, Protostuff for message serialization, and details both server-side service publishing and client-side invocation with reconnection handling.

NettyProtostuffRPC
0 likes · 3 min read
EasyRPC Framework Overview: Architecture, Server Publishing, and Client Invocation
Java Architecture Diary
Java Architecture Diary
Mar 22, 2019 · Backend Development

Boost Java Performance with Cglib BeanCopier: Fast Bean Copy Techniques

This article introduces the high‑performance Cglib BeanCopier used in the Mica microservice framework, compares its speed with other bean‑copy tools, demonstrates usage with Spring and Lombok, explains the underlying ASM bytecode generation, and discusses current limitations such as lack of chainable beans and primitive‑wrapper handling.

BeanCopierJavaPerformance
0 likes · 7 min read
Boost Java Performance with Cglib BeanCopier: Fast Bean Copy Techniques
Java Captain
Java Captain
Mar 14, 2019 · Backend Development

Why Combining synchronized with @Transactional Causes Thread‑Safety Issues in Spring and How to Resolve Them

The article explains why using the synchronized keyword together with Spring's @Transactional annotation can lead to lost updates when many threads increment a database field, analyzes the underlying transaction‑proxy interaction, and presents a refactored solution that moves the lock to a separate service to ensure correct results.

JavaSpringconcurrency
0 likes · 7 min read
Why Combining synchronized with @Transactional Causes Thread‑Safety Issues in Spring and How to Resolve Them
Java Captain
Java Captain
Mar 11, 2019 · Backend Development

Comprehensive Java Interview Question List (208 Questions)

This article presents a curated collection of over 200 Java interview questions covering fundamentals, collections, concurrency, reflection, web technologies, Spring ecosystem, databases, messaging, and JVM internals, aimed at developers preparing for junior to senior-level interviews and seeking to identify and fill knowledge gaps.

JVMJavaSpring
0 likes · 12 min read
Comprehensive Java Interview Question List (208 Questions)
Java Captain
Java Captain
Mar 6, 2019 · Backend Development

Understanding Spring Transaction Proxies: JDK Dynamic Proxy and CGLIB

This article explains how Spring implements declarative transaction management using proxies, compares JDK dynamic proxies and CGLIB, demonstrates their behavior with code examples, and clarifies which method modifiers support transactional annotations in Spring applications.

Backend DevelopmentCGLIBJDK Dynamic Proxy
0 likes · 13 min read
Understanding Spring Transaction Proxies: JDK Dynamic Proxy and CGLIB
Java Captain
Java Captain
Feb 26, 2019 · Backend Development

How to Write Better Java Code: Refactoring, DTO Conversion, Lombok, and Design Practices

This article discusses practical Java programming techniques, including proper DTO conversion, use of BeanUtils, Lombok annotations, builder patterns, static constructors, validation with JSR‑303, and design considerations such as refactoring, strategy versus state patterns, to help developers write cleaner, more maintainable backend code.

DTODesign PatternsJava
0 likes · 27 min read
How to Write Better Java Code: Refactoring, DTO Conversion, Lombok, and Design Practices
Senior Brother's Insights
Senior Brother's Insights
Feb 25, 2019 · Backend Development

Master Spring @Configuration and @Bean: From Java Classes to Fully Configured Beans

Spring’s shift from XML to annotation‑based configuration is explained, covering @Configuration and @Bean requirements, example Java classes, equivalent XML, annotation definitions, bean scopes, component scanning, unit‑testing, and practical tips for wiring beans without field injection, providing a complete guide for modern Spring development.

@BeanDependency InjectionJava
0 likes · 8 min read
Master Spring @Configuration and @Bean: From Java Classes to Fully Configured Beans
JD Tech
JD Tech
Feb 22, 2019 · Databases

Issues When Using Transactions with Database Read/Write Splitting

This article examines the challenges of using transactions with database read/write splitting, including potential master‑slave switching errors, connection‑pool deadlocks caused by isolation levels and propagation, and presents Spring‑based dynamic data source and transaction management solutions.

Dynamic Data SourceIsolation LevelRead-Write Splitting
0 likes · 6 min read
Issues When Using Transactions with Database Read/Write Splitting
Java Backend Technology
Java Backend Technology
Feb 17, 2019 · Backend Development

9 Essential Spring Design Patterns Every Java Developer Should Master

This article explores nine commonly used Spring design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method—explaining their concepts, showing XML or Java code examples, and illustrating how Spring implements each pattern in real applications.

Backend DevelopmentDependency InjectionDesign Patterns
0 likes · 9 min read
9 Essential Spring Design Patterns Every Java Developer Should Master
Java Captain
Java Captain
Feb 10, 2019 · Backend Development

Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method

This article explains how Spring implements nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—through configuration examples and Java code, illustrating their roles in building flexible, maintainable backend applications.

AdapterBackend DevelopmentDesign Patterns
0 likes · 9 min read
Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method
Programmer DD
Programmer DD
Jan 16, 2019 · Backend Development

How We Overhauled Our API: A Practical Guide to Backend‑First Development and RESTful Design

This article shares a step‑by‑step experience of redesigning a project’s API by adopting front‑back separation, establishing unified interface conventions, standardizing database IDs, request/response formats, and implementing RESTful methods with Java Spring controllers, while also addressing tooling, documentation, and static resource strategies to dramatically reduce communication overhead and accelerate delivery.

Backend DevelopmentJavaRESTful
0 likes · 13 min read
How We Overhauled Our API: A Practical Guide to Backend‑First Development and RESTful Design
Senior Brother's Insights
Senior Brother's Insights
Jan 3, 2019 · Backend Development

Mastering Spring Framework: Core Concepts, Modules, and Practical Guides

This comprehensive guide walks Java developers through Spring Framework’s essential features—including its modular architecture, dependency injection mechanisms, bean lifecycle, annotation‑based configuration, data‑access support, AOP concepts, and MVC workflow—providing clear explanations, code examples, and visual diagrams to deepen understanding.

AOPBackendDependency Injection
0 likes · 26 min read
Mastering Spring Framework: Core Concepts, Modules, and Practical Guides
Senior Brother's Insights
Senior Brother's Insights
Jan 2, 2019 · Backend Development

9 Essential Spring Design Patterns Explained with Code Samples

This article walks through nine commonly used design patterns in Spring, such as Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method, providing clear explanations, XML configurations, and Java code examples to illustrate each pattern in practice.

AdapterDesign PatternsJava
0 likes · 9 min read
9 Essential Spring Design Patterns Explained with Code Samples
Senior Brother's Insights
Senior Brother's Insights
Dec 31, 2018 · Backend Development

Why Field Injection Is the Least Recommended in Spring: A Deep Dive

This article examines Spring's three annotation-based dependency injection styles—field, constructor, and setter—showing why the widely used field injection is actually the least advisable, and explains the advantages of constructor injection introduced in Spring 4.x with concrete code examples and best‑practice guidelines.

Constructor InjectionDependency InjectionField Injection
0 likes · 5 min read
Why Field Injection Is the Least Recommended in Spring: A Deep Dive
Senior Brother's Insights
Senior Brother's Insights
Dec 30, 2018 · Backend Development

From Spring Framework to Spring Boot: A Complete Historical Timeline

This article chronicles the evolution of the Spring ecosystem—from its origins as a lightweight dependency‑injection framework, through rapid version growth and corporate changes, to the emergence of Spring Boot and Spring IO, highlighting key releases, architectural shifts, and the impact on Java backend development.

Backend DevelopmentDependency InjectionFramework History
0 likes · 11 min read
From Spring Framework to Spring Boot: A Complete Historical Timeline
Programmer DD
Programmer DD
Dec 13, 2018 · Backend Development

How Does Spring Cloud Stream’s Built‑In Retry Handle Message Failures?

This article explains Spring Cloud Stream’s default retry mechanism, demonstrates a complete example of producing and consuming messages with intentional failures, shows how to configure retry attempts, and discusses what happens when retries succeed or ultimately fail, providing practical guidance for reliable message processing.

RetrySpringmessage-consumption
0 likes · 10 min read
How Does Spring Cloud Stream’s Built‑In Retry Handle Message Failures?
Java Captain
Java Captain
Dec 12, 2018 · Backend Development

Design and Implementation of the Service Layer for a High‑Concurrency Seckill Application Using Java Spring

This article explains the purpose of the Service layer in a Java SSM‑based high‑concurrency seckill project, walks through interface design, DTO/VO/PO concepts, provides full Service implementation with transaction management, custom exceptions, enumeration for status codes, Spring XML configuration, and unit testing examples.

Backend DevelopmentJavaService Layer
0 likes · 15 min read
Design and Implementation of the Service Layer for a High‑Concurrency Seckill Application Using Java Spring
Java Captain
Java Captain
Dec 12, 2018 · Backend Development

Integrating Redis with Java for a Seckill Application and Optimizing with MySQL Stored Procedures

This guide walks through downloading and installing Redis, adding Java dependencies, creating a Redis DAO with Protostuff serialization, configuring Spring beans, caching seckill data, implementing a MySQL stored procedure for atomic execution, mapping it with MyBatis, updating service and controller layers, and testing the entire workflow.

JavaMySQLPerformance Optimization
0 likes · 8 min read
Integrating Redis with Java for a Seckill Application and Optimizing with MySQL Stored Procedures
Programmer DD
Programmer DD
Dec 3, 2018 · Backend Development

Master Spring Core Annotations: @Autowired, @Bean, @Qualifier, @Value and More

This article provides a comprehensive guide to Spring's core annotations—including @Autowired, @Bean, @Qualifier, @Required, @Value, @DependsOn, @Lazy, @Lookup, @Primary, @Scope, @Profile, @Import, @ImportResource, @PropertySource and @PropertySources—explaining their purpose, usage patterns, and code examples for constructor, setter, and field injection in Java applications.

@BeanSpringdependency-injection
0 likes · 10 min read
Master Spring Core Annotations: @Autowired, @Bean, @Qualifier, @Value and More
Java Captain
Java Captain
Dec 3, 2018 · Backend Development

Common Spring Framework Annotations and Their Usage

This article explains the purpose and usage of frequently used Spring annotations such as @Controller, @RestController, @Service, @Autowired, @RequestMapping, @RequestParam, @ModelAttribute, @Cacheable, @CacheEvict, @Resource, @PostConstruct, @PreDestroy, @Repository, @Component, @Scope, @SessionAttributes, and @Qualifier, providing code examples and practical notes for Java backend development.

Dependency InjectionJavaSpring
0 likes · 12 min read
Common Spring Framework Annotations and Their Usage
Java Captain
Java Captain
Nov 26, 2018 · Backend Development

Design and Implementation of a Reusable Java Backend Framework (lyyzoo)

This article details the design of a reusable Java backend framework called lyyzoo, covering coding standards, Maven module hierarchy, dependency management, core utility classes, and Spring configuration for web, JPA, and transaction support, providing a comprehensive guide for building enterprise applications.

HibernateJavaMaven
0 likes · 25 min read
Design and Implementation of a Reusable Java Backend Framework (lyyzoo)
Java Captain
Java Captain
Nov 26, 2018 · Backend Development

Design and Implementation of a Gas Purchase‑Sale‑Stock System Using Maven, Spring, and ExtJS

This article walks through the complete backend development of a gas purchase‑sale‑stock management system, covering entity and database design, Maven multi‑module project setup, Spring and web.xml configuration, environment‑specific property handling with a portable‑config Maven plugin, and a sample login controller implementation using Java, Spring MVC, and ExtJS.

ExtJSJavaMaven
0 likes · 21 min read
Design and Implementation of a Gas Purchase‑Sale‑Stock System Using Maven, Spring, and ExtJS
Java Captain
Java Captain
Nov 26, 2018 · Backend Development

Step‑by‑Step Guide to Building an Inventory Management System with Spring, Hibernate, and ExtJS

This article provides a comprehensive, step‑by‑step tutorial on designing and implementing a Java‑based inventory management system, covering requirement analysis, architecture, module design, development environment setup, and deployment using Spring, Spring MVC, Hibernate, ExtJS, Maven, and Tomcat.

Backend DevelopmentExtJSHibernate
0 likes · 9 min read
Step‑by‑Step Guide to Building an Inventory Management System with Spring, Hibernate, and ExtJS
Java Captain
Java Captain
Nov 21, 2018 · Backend Development

Comprehensive Overview of Our Company’s Technology Stack, Server Environment, and Team Management Practices

This article presents a detailed case study of a mid‑size development team’s front‑end and back‑end technology stack, server environment, project workflow, and management practices, aiming to share practical solutions and lessons learned for building and maintaining enterprise‑grade Java applications.

JavaMavenSpring
0 likes · 21 min read
Comprehensive Overview of Our Company’s Technology Stack, Server Environment, and Team Management Practices
Java Captain
Java Captain
Nov 19, 2018 · Backend Development

Implementing a Red Packet System with Redis, Lua Scripts, and Spring Async

This article explains how to build a high‑performance red‑packet (hong‑bao) service by configuring a RedisTemplate in Spring, writing an atomic Lua script for stock management, persisting results to a MySQL database via JDBC batch processing, and using @Async to off‑load long‑running tasks, complete with code examples and deployment steps.

@AsyncJavaLua
0 likes · 17 min read
Implementing a Red Packet System with Redis, Lua Scripts, and Spring Async
Java Captain
Java Captain
Nov 16, 2018 · Backend Development

Spring, Spring MVC, and MyBatis Interview Questions and Answers

This article compiles common interview questions and concise answers about Spring, Spring MVC, and MyBatis, covering core concepts such as IoC, AOP, transaction management, controller behavior, annotation usage, design patterns, MyBatis configuration, mapping techniques, pagination, and integration with Ajax.

Backend DevelopmentJavaMyBatis
0 likes · 10 min read
Spring, Spring MVC, and MyBatis Interview Questions and Answers
Java Captain
Java Captain
Nov 5, 2018 · Backend Development

Implementing a High‑Concurrency Red Packet System with Java, MySQL, MyBatis, and Spring

This article demonstrates how to build a high‑concurrency red‑packet (抢红包) system using Java backend technologies—including MySQL table design, POJOs, MyBatis DAOs, Spring services with transaction management, and a web layer, and discusses performance testing, data consistency issues, and solutions such as pessimistic and optimistic locking.

JavaMyBatisMySQL
0 likes · 22 min read
Implementing a High‑Concurrency Red Packet System with Java, MySQL, MyBatis, and Spring
Java Captain
Java Captain
Oct 15, 2018 · Backend Development

Implementing AOP in Java Controllers: Guidelines and Code Example

This article explains how to use Aspect‑Oriented Programming (AOP) in Java backend controllers by defining a unified ResultBean response format, outlining controller coding conventions, and providing complete Java and XML examples for logging, exception handling, and AOP configuration.

AOPBackend DevelopmentController
0 likes · 5 min read
Implementing AOP in Java Controllers: Guidelines and Code Example
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Oct 9, 2018 · Backend Development

Quartz Scheduler: Architecture, Core Components, Cluster Deployment, and Monitoring

This article provides a comprehensive overview of the Quartz Java scheduling framework, detailing its architecture, core components such as Scheduler, Job, Trigger and JobDetail, typical use cases, Spring‑based cluster deployment configurations, monitoring techniques, and the underlying database‑lock synchronization mechanism.

ClusterJavaJob
0 likes · 10 min read
Quartz Scheduler: Architecture, Core Components, Cluster Deployment, and Monitoring
Java Captain
Java Captain
Oct 7, 2018 · Backend Development

A Comprehensive Overview of Spring Framework Concepts and Practices

This article provides a systematic summary of Spring's core concepts—including IoC, AOP, bean configuration via XML and annotations, dependency injection mechanisms, transaction management, and web integration—offering Java developers a clear guide to effectively using the framework in real-world projects.

AOPBean ConfigurationDependency Injection
0 likes · 9 min read
A Comprehensive Overview of Spring Framework Concepts and Practices
Xianyu Technology
Xianyu Technology
Sep 27, 2018 · Backend Development

SWAK: A Swiss‑Army‑Knife‑Style Multi‑Implementation Framework for Xianyu Backend

SWAK is a lightweight, Spring-compatible framework that treats product type, category, and region tags as rules, registers multiple implementations during startup, and at runtime selects the appropriate one via priority and reduction, eliminating tangled if-else code, improving reuse, onboarding, and performance for Xianyu’s backend.

ArchitectureJavaSpring
0 likes · 10 min read
SWAK: A Swiss‑Army‑Knife‑Style Multi‑Implementation Framework for Xianyu Backend
Java Captain
Java Captain
Sep 19, 2018 · Backend Development

Refactoring Poor Spring MVC Code: Lessons on Clean Backend Development

The article critiques badly written Spring controller and service code, explains how poor coding habits cause maintenance headaches, and demonstrates a cleaner, AOP‑based approach that reduces boilerplate and improves code quality for backend Java applications.

AOPBackendJava
0 likes · 6 min read
Refactoring Poor Spring MVC Code: Lessons on Clean Backend Development