BestHub
Sign in
Tagged articles
492 articles
Page 2 of 5
Java Backend Technology
Java Backend Technology
Dec 26, 2024 · Backend Development

Unlock Cleaner Java Code: Master Lombok’s @Delegate, @Cleanup, @Builder & More

Explore how Lombok’s powerful annotations—@onX, @Delegate, @Cleanup, @Singular, and @Builder—can dramatically simplify Java code, enable seamless Spring dependency injection, manage resources automatically, and streamline object construction, while highlighting best practices and potential pitfalls for maintainable backend development.

Code GenerationLombokannotations
0 likes · 8 min read
Unlock Cleaner Java Code: Master Lombok’s @Delegate, @Cleanup, @Builder & More
Top Architect
Top Architect
Dec 22, 2024 · Backend Development

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

The article examines whether a Service layer in a Spring‑based backend should be defined by interfaces, debunks common arguments for using interfaces, proposes a top‑down coding workflow, explores project structures for single and multiple implementations, and concludes that interfaces are only worthwhile when multiple implementations are required, while also containing promotional material for unrelated services.

Backend ArchitectureInterfacesService Layer
0 likes · 11 min read
Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects
Architecture Digest
Architecture Digest
Dec 19, 2024 · Backend Development

Comprehensive Overview of Spring Bean Lifecycle Extension Points

This article explains the Spring container's refresh process, details every extensible hook in a bean's lifecycle—from ApplicationContextInitializer to DisposableBean—provides usage scenarios, and includes complete Java code snippets illustrating how to implement each extension point for custom middleware and application development.

Extension PointsJavaSpring Boot
0 likes · 18 min read
Comprehensive Overview of Spring Bean Lifecycle Extension Points
Open Source Tech Hub
Open Source Tech Hub
Dec 15, 2024 · Backend Development

Mastering PHP IoC: Build a Singleton Container from Scratch

This tutorial explains how to create a lightweight Inversion of Control (IoC) container in PHP, covering the singleton pattern, binding services, PSR‑11 compliance, retrieving and injecting dependencies, and implementing class and method resolvers with practical code examples.

ContainerIoCPHP
0 likes · 16 min read
Mastering PHP IoC: Build a Singleton Container from Scratch
Sohu Tech Products
Sohu Tech Products
Dec 11, 2024 · Mobile Development

Understanding the Repository Pattern in Flutter

The Repository pattern in Flutter abstracts data access behind a type‑safe interface, isolating domain models from API, database, or device details, enabling easy swapping of implementations, simplifying testing with mocks, and promoting clean architecture by keeping UI code separate from business and networking logic.

DARTFlutterRepository Pattern
0 likes · 15 min read
Understanding the Repository Pattern in Flutter
Architecture Digest
Architecture Digest
Nov 29, 2024 · Backend Development

Dynamic Service Provider Switching with Spring Smart DI

This article explains how to implement runtime switching of multiple service providers in a Spring‑based backend by configuring the active implementation in a central store and using the spring‑smart‑di library's AutowiredProxySPI to inject the appropriate bean automatically.

Dynamic ConfigurationJavadependency-injection
0 likes · 7 min read
Dynamic Service Provider Switching with Spring Smart DI
Architecture Digest
Architecture Digest
Nov 5, 2024 · Backend Development

Spring Annotation-Based Development and MyBatis Integration Tutorial

This article explains how Spring 3.0's pure annotation mode simplifies bean configuration, demonstrates using @Component, @Scope, @Autowired, @Qualifier, @Value, and @PropertySource for dependency injection and property loading, and shows step‑by‑step integration of MyBatis with Spring, including required dependencies and configuration classes.

BackendConfigurationJava
0 likes · 8 min read
Spring Annotation-Based Development and MyBatis Integration Tutorial
Java Architect Essentials
Java Architect Essentials
Oct 25, 2024 · Backend Development

Using Lombok Annotations @RequiredArgsConstructor, @Delegate, @Cleanup, @Singular and @Builder in Spring Applications

This article demonstrates how Lombok annotations such as @RequiredArgsConstructor, @Delegate, @Cleanup, @Singular, and @Builder can be combined with Spring components to reduce boilerplate, automatically inject dependencies, manage resources, and build immutable objects, providing practical code examples and usage guidelines.

Code GenerationJavaLombok
0 likes · 7 min read
Using Lombok Annotations @RequiredArgsConstructor, @Delegate, @Cleanup, @Singular and @Builder in Spring Applications
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 8, 2024 · Frontend Development

Understanding Inversion of Control (IoC) and Dependency Injection in Front‑End Development

This article explains the Inversion of Control (IoC) principle, why it matters for growing front‑end applications, and demonstrates how to refactor a simple App component using dependency injection and a module registration system, turning the App into a container that manages its dependencies rather than directly instantiating them.

IoCJavaScriptdependency-injection
0 likes · 7 min read
Understanding Inversion of Control (IoC) and Dependency Injection in Front‑End Development
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 23, 2024 · Backend Development

Mastering Spring Bean Lifecycle: 8 Essential Stages Explained

This article walks through the eight critical phases of a Spring bean's lifecycle—from instantiation and property population to initialization, post‑processor hooks, usage, and destruction—detailing how Spring creates, configures, enhances, and finally disposes of beans, with code snippets and diagrams for clarity.

Backend DevelopmentJavabean-lifecycle
0 likes · 5 min read
Mastering Spring Bean Lifecycle: 8 Essential Stages Explained
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 16, 2024 · Backend Development

Mastering Spring’s IOC Container: Concepts, Types, and Startup Steps

This article explains the Inversion of Control principle, defines what an IOC container is, compares Spring’s BeanFactory and ApplicationContext, and walks through the three-stage startup process—including loading configurations, registering bean definitions, and instantiating beans with automatic dependency injection.

Backend DevelopmentIoCJava
0 likes · 5 min read
Mastering Spring’s IOC Container: Concepts, Types, and Startup Steps
Architect
Architect
Sep 4, 2024 · Backend Development

Unlocking Spring Bean Lifecycle: 17 Extension Points Every Developer Should Master

This article systematically catalogs every Spring and Spring Boot extension interface—from ApplicationContextInitializer to DisposableBean—illustrates their invocation order with a diagram, explains practical use‑cases, and provides concrete code samples for each hook, enabling developers to tap into the bean lifecycle for custom initialization, monitoring, and cleanup.

BackendExtension PointsJava
0 likes · 20 min read
Unlocking Spring Bean Lifecycle: 17 Extension Points Every Developer Should Master
Architect
Architect
Sep 3, 2024 · Frontend Development

Designing a Reusable, Flexible, and Stable Detail Page Framework

This article analyzes the challenges of maintaining high‑traffic detail pages across multiple business teams and proposes a three‑layer, dependency‑injection‑enabled framework that ensures reusability, flexibility, and stability while supporting fast onboarding and robust quality assurance.

dependency-injectionfrontendmodularization
0 likes · 10 min read
Designing a Reusable, Flexible, and Stable Detail Page Framework
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Aug 30, 2024 · Backend Development

Master the 9 Essential SpringBoot Annotations for Backend Development

This article provides a concise yet comprehensive guide to the most common SpringBoot annotations—including @SpringBootApplication, @EnableAutoConfiguration, @ComponentScan, @Service, @Repository, @Component, @RestController, @Bean, @ResponseBody, and @Autowired—explaining their purpose, composition, and practical code examples for building robust Java backend applications.

Backend DevelopmentJavaSpringBoot
0 likes · 6 min read
Master the 9 Essential SpringBoot Annotations for Backend Development
Architect's Guide
Architect's Guide
Aug 19, 2024 · Fundamentals

Applying the Strategy Pattern with Simple Factory in a Java Backend Service

This article explains how to use the Strategy pattern combined with a simple factory in a Spring‑based Java backend, showing interface definition, multiple arithmetic strategy implementations, a factory that registers them in a map, a service that selects a strategy at runtime, and a REST controller for testing.

BackendFactoryJava
0 likes · 6 min read
Applying the Strategy Pattern with Simple Factory in a Java Backend Service
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 19, 2024 · Backend Development

Why Field Injection in Spring Is Risky and How Constructor Injection Solves It

The article explains how field injection in Spring can cause null‑pointer exceptions, break immutability, violate design principles, and hide circular dependencies, and demonstrates that using constructor injection (with optional @Lazy) provides safer, more maintainable dependency management.

Constructor InjectionField Injectioncircular-dependency
0 likes · 7 min read
Why Field Injection in Spring Is Risky and How Constructor Injection Solves It
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Aug 16, 2024 · Backend Development

Understanding IOC vs Dependency Injection in Spring: Key Differences Explained

This article clarifies how Inversion of Control (IoC) serves as a design pattern that hands control to an external container, while Dependency Injection (DI) is a concrete IoC implementation that automatically supplies required objects, detailing their definitions, purposes, implementations, and typical usage scenarios.

Backend DevelopmentInversion of ControlJava
0 likes · 4 min read
Understanding IOC vs Dependency Injection in Spring: Key Differences Explained
php Courses
php Courses
Aug 15, 2024 · Backend Development

Applying the Interface Programming Principle in Laravel: From SMS to Email Notifications

This article explains the interface‑programming principle, demonstrates its benefits with SMS and email notification services in Laravel, shows how to refactor code using an INotification interface, and configures the service container to switch implementations seamlessly, illustrating a flexible, maintainable backend design.

PHPService Containerbackend-development
0 likes · 8 min read
Applying the Interface Programming Principle in Laravel: From SMS to Email Notifications
Top Architect
Top Architect
Aug 12, 2024 · Backend Development

Why Field Injection Is Discouraged in Spring and Preferred Alternatives

The article explains that Spring no longer recommends @Autowired field injection, describes constructor‑based, setter‑based, and field‑based dependency injection types, illustrates each with code examples, and outlines the drawbacks of field injection such as immutability issues, SRP violations, and tight coupling to the container.

Backend DevelopmentConstructor InjectionField Injection
0 likes · 11 min read
Why Field Injection Is Discouraged in Spring and Preferred Alternatives
Java Tech Enthusiast
Java Tech Enthusiast
Aug 5, 2024 · Backend Development

Implementing SPI-like Extensions in Spring Boot

Spring Boot can emulate SPI plug‑in extensions by using native Java ServiceLoader, conditional bean registration with @ConditionalOnClass/@ConditionalOnProperty, custom FactoryBean implementations, or programmatic BeanDefinitionRegistryPostProcessor registration, each enabling dynamic service loading based on configuration or runtime conditions.

FactoryBeanJavaSPI
0 likes · 7 min read
Implementing SPI-like Extensions in Spring Boot
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 4, 2024 · Backend Development

Enable Spring Dependency Injection for New Objects with @Configurable

This guide explains how to use Spring's @Configurable annotation and the AnnotationBeanConfigurerAspect to inject dependencies into objects created with new, covering environment setup, Maven configuration, AspectJ weaving, and advanced options like autowiring, constructor injection, and dependency checks.

Backend DevelopmentConfigurableaspectj
0 likes · 8 min read
Enable Spring Dependency Injection for New Objects with @Configurable
Selected Java Interview Questions
Selected Java Interview Questions
Aug 1, 2024 · Backend Development

Spring Annotation-Based Development and MyBatis Integration Guide

This article explains how Spring 3.0's pure annotation development simplifies bean configuration, demonstrates defining beans with @Component, managing bean scopes, performing various injection techniques, reading properties files, and integrating MyBatis, providing complete code examples and best‑practice tips for backend Java developers.

BackendJavaMyBatis
0 likes · 11 min read
Spring Annotation-Based Development and MyBatis Integration Guide
FunTester
FunTester
Aug 1, 2024 · Backend Development

Mastering Advanced fx Features: Invoke, Supply, Populate, and More

This article dives deep into Uber's fx dependency‑injection framework for Go, explaining advanced constructs such as fx.Invoke, fx.Supply, fx.Populate, fx.Annotated, fx.In, fx.Out, fx.Module, fx.WithLogger and fx.As, and provides complete code examples that illustrate how to manage lifecycles, inject static values, differentiate multiple implementations, and customize logging in production‑grade applications.

Backend DevelopmentGoUber fx
0 likes · 13 min read
Mastering Advanced fx Features: Invoke, Supply, Populate, and More
Java Backend Technology
Java Backend Technology
Jul 30, 2024 · Backend Development

Spring Annotation Development: From Bean Definition to MyBatis Integration

This article explains how Spring’s pure annotation development replaces XML bean definitions, covers component scanning, bean scopes, derived annotations, various injection methods, property file loading, and demonstrates seamless Spring‑MyBatis integration, showing step‑by‑step code examples that simplify backend configuration.

JavaMyBatisannotation
0 likes · 9 min read
Spring Annotation Development: From Bean Definition to MyBatis Integration
FunTester
FunTester
Jul 29, 2024 · Backend Development

Mastering Dependency Injection in Go with Uber’s Fx Framework

This article explains the core concepts of dependency injection, introduces Uber’s Fx framework for Go, and provides step‑by‑step code examples that demonstrate how to register providers, manage application lifecycles, and use hooks for start‑up and shutdown logic.

Backend DevelopmentGodependency-injection
0 likes · 12 min read
Mastering Dependency Injection in Go with Uber’s Fx Framework
DaTaobao Tech
DaTaobao Tech
Jul 22, 2024 · Backend Development

Spring Bean Injection Issues and Dependency Injection Priorities

In a project with two applications, a Tair bean defined via JavaConfig works in one app but fails in the other because Spring’s injection rules prioritize type over name, causing ambiguity; using explicit bean naming with XML, adding @Qualifier, or switching to @Resource resolves the issue.

Bean ConfigurationJavaannotations
0 likes · 12 min read
Spring Bean Injection Issues and Dependency Injection Priorities
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jul 18, 2024 · Mobile Development

Comprehensive Guide to GetX in Flutter: State Management, Routing, Dependency Injection, and Practical Project Implementation

This article provides an in‑depth tutorial on using the GetX library for Flutter, covering its state‑management, routing, dependency‑injection features, code generation tricks, common pitfalls, and a step‑by‑step rewrite of a WanAndroid project with practical examples.

GetXMobile DevelopmentState Management
0 likes · 40 min read
Comprehensive Guide to GetX in Flutter: State Management, Routing, Dependency Injection, and Practical Project Implementation
Bilibili Tech
Bilibili Tech
Jul 12, 2024 · Frontend Development

Design and Implementation of a Unified Multi‑Business Detail Page Framework

The project consolidates three separate detail‑page implementations into a single, reusable framework that separates business, component, and framework layers, employs dependency‑injection and scoped lifecycles to support diverse scenarios while ensuring stability through comprehensive logging, monitoring, and staged gray‑release testing.

Scope Managementarchitecturecode-reuse
0 likes · 11 min read
Design and Implementation of a Unified Multi‑Business Detail Page Framework
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 10, 2024 · Backend Development

Master Spring’s FactoryBean: From Basics to Advanced Use Cases

This article explains Spring's FactoryBean interface, detailing its three core methods, and provides step‑by‑step examples—including a simple bean, prototype scope, proxy creation, accessing the original FactoryBean, and using ServiceFactoryBean for SPI—illustrating how to customize bean instantiation in Spring 6.

FactoryBeanSPIdependency-injection
0 likes · 7 min read
Master Spring’s FactoryBean: From Basics to Advanced Use Cases
IT Architects Alliance
IT Architects Alliance
Jul 2, 2024 · Backend Development

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

This article examines whether defining separate interfaces for Service and DAO layers is necessary in Spring projects, debunks common justifications, proposes a bottom‑up development workflow, and outlines project structures for single and multiple implementations, highlighting both benefits and drawbacks.

Backend ArchitectureInterface DesignService Layer
0 likes · 8 min read
Do You Really Need Interfaces for Service and DAO Layers in Spring?
21CTO
21CTO
Jul 2, 2024 · Backend Development

FastAPI vs Flask: Why FastAPI Outperforms Flask for Modern APIs

This article compares FastAPI and Flask, highlighting FastAPI's speed, developer experience, and standards support, while providing practical migration guidance, code examples, configuration tips, async handling, dependency injection, testing, deployment, and documentation differences for Python web developers.

ASGIFastAPIFlask
0 likes · 25 min read
FastAPI vs Flask: Why FastAPI Outperforms Flask for Modern APIs
Architect
Architect
Jun 28, 2024 · Backend Development

Do Service and DAO Layers Really Need Interfaces? A Practical Spring Analysis

This article examines whether defining interfaces for Service and DAO layers is necessary in Spring projects, debunks common arguments for interfaces, proposes a top‑down coding workflow, and outlines strategies for handling multiple implementations without adding unnecessary abstraction.

Backend DevelopmentInterfaceService Layer
0 likes · 9 min read
Do Service and DAO Layers Really Need Interfaces? A Practical Spring Analysis
Code Ape Tech Column
Code Ape Tech Column
Jun 24, 2024 · Backend Development

Applying the Service Locator Pattern in Spring to Decouple File Parsers

The article explains how to replace tightly‑coupled if‑else or switch statements for selecting CSV, JSON, or XML parsers with a Service Locator Pattern in Spring, showing step‑by‑step code examples, configuration, and the resulting adherence to the open‑closed principle.

Factory BeanJavaService Locator
0 likes · 8 min read
Applying the Service Locator Pattern in Spring to Decouple File Parsers
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 19, 2024 · Backend Development

Mastering Spring Boot Annotations: A Comprehensive Guide for Backend Developers

This article provides a thorough overview of Spring Boot's core, web, configuration, dependency injection, AOP, testing, security, transaction, scheduling, event, exception handling, property binding, and conditional annotations, complete with practical code examples for Java backend development.

Backend DevelopmentSpring Bootannotations
0 likes · 12 min read
Mastering Spring Boot Annotations: A Comprehensive Guide for Backend Developers
Go Programming World
Go Programming World
Jun 13, 2024 · Backend Development

Using Wire for Dependency Injection in Go Web Applications: A Practical Guide

This article demonstrates how to apply Google’s Wire tool in a production‑grade Go web service, covering project layout, a four‑layer architecture, code generation for constructors, comparisons with dig and inject, and practical CLI usage to streamline dependency injection and improve development efficiency.

BackendGoWeb Development
0 likes · 23 min read
Using Wire for Dependency Injection in Go Web Applications: A Practical Guide
Java Tech Enthusiast
Java Tech Enthusiast
Jun 12, 2024 · Backend Development

Understanding Dependency Injection Types in Spring: Constructor, Setter, and Field Injection

The article explains Spring’s three dependency‑injection styles—constructor, setter, and field—showing how constructor injection (often with @Autowired or implicit) enables immutable, required dependencies, setter injection handles optional ones, and field injection, though concise, is discouraged due to immutability, testability, and coupling drawbacks.

Constructor InjectionField InjectionSetter Injection
0 likes · 7 min read
Understanding Dependency Injection Types in Spring: Constructor, Setter, and Field Injection
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 3, 2024 · Backend Development

Why Static Field Injection Fails in Spring 6 and How to Do It Correctly

This article examines why Spring 6 does not support injecting static fields or methods with @Resource, @Autowired, or @Inject, demonstrates the resulting errors, and presents proper ways to inject static dependencies using instance‑method or constructor injection, backed by source‑code analysis of the relevant bean post‑processors.

Backend DevelopmentStatic Fieldsdependency-injection
0 likes · 9 min read
Why Static Field Injection Fails in Spring 6 and How to Do It Correctly
Ops Development & AI Practice
Ops Development & AI Practice
Jun 1, 2024 · Backend Development

Mastering Dependency Injection in Go with Google Wire

This article introduces Google Wire, a static‑analysis‑based dependency injection tool for Go, covering its key features, installation steps, core usage patterns—including defining dependencies, creating providers, generating code, and best practices such as modular management, interface abstraction, and testing with mock implementations.

Code GenerationGoGoogle Wire
0 likes · 8 min read
Mastering Dependency Injection in Go with Google Wire
Ops Development & AI Practice
Ops Development & AI Practice
Jun 1, 2024 · Backend Development

How to Build a Name Injection Registry in Go for Flexible Plugins

This guide walks through creating a name‑based injection system in Go by defining a processor interface, implementing concrete processors, building a registration map with init functions, and demonstrating usage in a main program, while also covering best practices such as global variable handling, initialization order, and error checking.

GoPlugin SystemRegistry
0 likes · 5 min read
How to Build a Name Injection Registry in Go for Flexible Plugins
Ops Development & AI Practice
Ops Development & AI Practice
May 27, 2024 · Backend Development

Decoupling Gin Handlers with Dependency Injection in Go

This article explains how to apply Dependency Injection in the Go Gin framework to separate routing logic from business services, reducing code coupling, improving testability, and enhancing reusability through concrete interface definitions, a simple DI container, and practical code examples.

BackendDesign PatternsGin
0 likes · 6 min read
Decoupling Gin Handlers with Dependency Injection in Go
php Courses
php Courses
May 27, 2024 · Backend Development

Using PHP Traits in Symfony for Reusable and Modular Code

This guide explains how to use PHP Traits within the Symfony framework to encapsulate reusable functionality, demonstrating the creation of a LoggerTrait, its integration into a UserService, and the injection of that service into a controller for clean, modular, and DRY code.

Backend DevelopmentPHPSymfony
0 likes · 5 min read
Using PHP Traits in Symfony for Reusable and Modular Code
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 25, 2024 · Backend Development

Understanding Spring's IoC Container: BeanFactory, ListableBeanFactory, HierarchicalBeanFactory, and AutowireCapableBeanFactory

This article explains the core Spring IoC concepts by analyzing the top‑level BeanFactory interface and its three important sub‑interfaces—HierarchicalBeanFactory, ListableBeanFactory, and AutowireCapableBeanFactory—illustrating their responsibilities, inheritance relationships, and practical usage with code examples.

Backend DevelopmentBeanFactoryIoC
0 likes · 8 min read
Understanding Spring's IoC Container: BeanFactory, ListableBeanFactory, HierarchicalBeanFactory, and AutowireCapableBeanFactory
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 23, 2024 · Backend Development

Spring Prototype Bean Injection: ServiceLocator vs ObjectFactoryCreating

This article explains how to define and inject prototype-scoped beans in Spring using @Scope, ServiceLocatorFactoryBean, and ObjectFactoryCreatingFactoryBean, demonstrates configuration via annotations and XML, shows code examples, compares the two FactoryBean approaches, and includes tips for bean name mapping and custom exceptions.

Bean ScopeObjectFactoryCreatingFactoryBeanServiceLocatorFactoryBean
0 likes · 9 min read
Spring Prototype Bean Injection: ServiceLocator vs ObjectFactoryCreating
Go Development Architecture Practice
Go Development Architecture Practice
May 9, 2024 · Backend Development

How to Organize a Scalable Go Project: Best Practices and Patterns

This guide outlines a comprehensive Go project layout—including cmd, pkg, internal, test, configs, and docs directories—alongside modular design principles, middleware usage, dependency injection, error handling, logging, database access layers, testing strategies, performance tuning, and documentation practices to improve code readability, maintainability, and scalability.

GoProject Structuredependency-injection
0 likes · 26 min read
How to Organize a Scalable Go Project: Best Practices and Patterns
macrozheng
macrozheng
May 8, 2024 · Backend Development

Mastering Spring’s @Autowired: Advanced Usage, Qualifiers, and Common Pitfalls

This article explores the default behavior of Spring's @Autowired annotation, how to resolve bean name conflicts, use @Qualifier and @Primary, apply @Autowired on constructors, methods, parameters, and collections, and troubleshoot common issues such as missing annotations, filter injection, component scanning, and circular dependencies.

AutowiredBackendJava
0 likes · 15 min read
Mastering Spring’s @Autowired: Advanced Usage, Qualifiers, and Common Pitfalls
Code Ape Tech Column
Code Ape Tech Column
Apr 29, 2024 · Backend Development

Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With

This article explains several powerful Lombok annotations—including @onX, @Delegate, @Cleanup, @Builder with @Singular, and @With—showing how they simplify Spring‑based Java code through automatic constructor generation, method delegation, resource management, and fluent builders, while also warning against overuse.

Code GenerationJavaLombok
0 likes · 7 min read
Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With
Code Ape Tech Column
Code Ape Tech Column
Apr 27, 2024 · 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, discusses the three traditional reasons for using interfaces, explains why they often do not hold up, and proposes practical structuring alternatives for single‑ and multi‑implementation scenarios.

InterfaceJavaService Layer
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 23, 2024 · Backend Development

Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies

This article explains the distinct roles of Spring's @Configuration and @Component annotations, demonstrates their behavior through code examples, compares bean initialization and proxy generation, and reveals how Spring's ConfigurationClassPostProcessor and related enhancers ensure singleton beans across method calls.

ComponentConfigurationJava
0 likes · 9 min read
Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies
Architect's Tech Stack
Architect's Tech Stack
Apr 16, 2024 · Backend Development

Should the Service Layer Use Interfaces? A Critical Discussion

This article examines whether a Service layer in Java Spring projects truly requires interfaces, debunking common arguments, exploring development workflows without interfaces, discussing project structuring for single and multiple implementations, and concluding when interfaces are beneficial or unnecessary.

InterfaceJavaService Layer
0 likes · 7 min read
Should the Service Layer Use Interfaces? A Critical Discussion
MoonWebTeam
MoonWebTeam
Apr 16, 2024 · Frontend Development

Mastering Dependency Injection in Frontend: Boost Maintainability and Testability

This article explains the concept of Dependency Injection for frontend projects, compares it with Inversion of Control, showcases practical code examples, discusses popular DI libraries and frameworks, and details implementation techniques such as decorators, reflection, singleton handling, and circular dependency resolution to improve maintainability and testability.

Design PatternsIoCSoftware Architecture
0 likes · 26 min read
Mastering Dependency Injection in Frontend: Boost Maintainability and Testability
Java Tech Enthusiast
Java Tech Enthusiast
Apr 9, 2024 · Backend Development

Understanding Spring DI: @Autowired vs @Resource and Field Injection Pitfalls

Spring supports constructor, setter, and field injection, but field injection is discouraged; @Autowired (Spring‑specific, by‑type) and @Resource (standard, by‑name) differ in defaults and IDE warnings, so prefer constructor injection for required beans, setter injection for optional ones, and only use @Resource for unavoidable field injection to lessen container coupling.

AutowiredJavadependency-injection
0 likes · 5 min read
Understanding Spring DI: @Autowired vs @Resource and Field Injection Pitfalls
Open Source Tech Hub
Open Source Tech Hub
Feb 29, 2024 · Backend Development

Mastering PHP-DI: A Step‑by‑Step Guide to Dependency Injection in Webman

This tutorial explains what a Dependency Injection (DI) container is, shows how to install php-di, demonstrates basic usage including container creation, automatic wiring, constructor and annotation injection, and provides custom injection techniques for the Webman framework with concrete code examples.

Backend DevelopmentPHPWebman
0 likes · 9 min read
Mastering PHP-DI: A Step‑by‑Step Guide to Dependency Injection in Webman
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 23, 2024 · Backend Development

Master Spring Boot 2.7: Bean Lifecycle, DI, AOP, Caching & More

This guide walks through essential Spring Boot 2.7.16 features—including bean lifecycle annotations, dependency injection methods, Java‑based configuration, conditional beans, event listeners, AOP, scheduled tasks, data access with Spring Data JPA, caching, exception handling, security, SpEL, configuration management, performance monitoring, and micro‑service components—providing concise code examples for each.

JavaMicroservicesSpring Boot
0 likes · 10 min read
Master Spring Boot 2.7: Bean Lifecycle, DI, AOP, Caching & More
Java Tech Enthusiast
Java Tech Enthusiast
Feb 7, 2024 · Backend Development

How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation

This article provides a comprehensive analysis of Spring's @Autowired annotation, covering its usage, the bean lifecycle stages where it operates, the core classes and methods that implement it, and a comparison with other injection annotations such as @Resource, all illustrated with runnable code examples.

Annotation ProcessingAutowiredJava
0 likes · 27 min read
How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation
Architect
Architect
Feb 5, 2024 · Backend Development

Applying the Strategy Pattern with Simple Factory in a Spring Boot Application

This article demonstrates how to apply the Strategy pattern combined with a simple factory in a Spring Boot application, showing interface definition, multiple arithmetic strategy implementations, a factory that registers beans, a service invoking strategies via a map, and a REST controller for testing, highlighting extensibility.

BackendFactoryJava
0 likes · 8 min read
Applying the Strategy Pattern with Simple Factory in a Spring Boot Application
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 30, 2024 · Backend Development

Master Spring Boot Bean Lifecycle: Init, Destroy, Scopes & Advanced Tricks

This article explains how to control Spring bean initialization and destruction using interfaces and annotations, inject prototype beans into singleton controllers, implement various BeanPostProcessor extensions, dynamically register beans, use @Import, Runner interfaces, global exception handling, custom type conversion, BeanFactoryAware, web interceptors, and default AOP proxy creation.

Backend DevelopmentJavaSpring Boot
0 likes · 9 min read
Master Spring Boot Bean Lifecycle: Init, Destroy, Scopes & Advanced Tricks
Tencent Cloud Developer
Tencent Cloud Developer
Jan 25, 2024 · Backend Development

How to Write Testable Business Code in Go: A Practical Guide

The guide shows that by consciously designing Go data structures and function interfaces—using pure functions, parameter injection, interface abstractions, struct‑based objects, or function‑variable patterns—and avoiding init(), developers can expose and control all dependencies, making business code inherently testable and achieving high unit‑test coverage.

Backend DevelopmentGoMocking
0 likes · 17 min read
How to Write Testable Business Code in Go: A Practical Guide
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 24, 2024 · Mobile Development

Unlock Peak Kotlin Performance with Advanced Refactoring Techniques

This article guides developers through a series of Kotlin refactoring steps—replacing when statements with HashMap, introducing payload mechanisms, infix functions, inline registration, and delegated properties—to dramatically improve event‑handling performance, readability, and maintainability while adhering to the single‑responsibility principle.

HashMapInfix FunctionsKotlin
0 likes · 16 min read
Unlock Peak Kotlin Performance with Advanced Refactoring Techniques
Baidu Geek Talk
Baidu Geek Talk
Jan 8, 2024 · Backend Development

Exgraph: A Graph Execution Engine for Task Orchestration

Exgraph, Baidu Search’s graph execution engine, uses a human‑readable description language and a robust execution core with dependency injection, object pooling, and interruption handling to orchestrate complex, parallel or conditional tasks, improving code readability and unifying diverse execution scenarios in search architecture.

DAGGo developmentObject Pooling
0 likes · 10 min read
Exgraph: A Graph Execution Engine for Task Orchestration
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 27, 2023 · Backend Development

How @Nullable Prevents Spring Bean Injection Failures

Learn how to use Spring's @Nullable annotation (or its Java equivalents) to safely handle missing beans during dependency injection, avoiding startup errors, with code examples, underlying mechanism details, and comparisons to other approaches like required=false, Optional, and ObjectFactory.

@NullableBackend DevelopmentJava
0 likes · 6 min read
How @Nullable Prevents Spring Bean Injection Failures
政采云技术
政采云技术
Dec 5, 2023 · Fundamentals

Java SPI vs Dubbo SPI: Service Provider Interface Mechanisms Compared

This article explains Java's Service Provider Interface (SPI) mechanism and compares it with Dubbo's enhanced SPI implementation, highlighting how Dubbo addresses the limitations of native Java SPI through configuration format changes and lazy loading.

Dubbo SPIFramework ExtensionJava SPI
0 likes · 19 min read
Java SPI vs Dubbo SPI: Service Provider Interface Mechanisms Compared
Architect's Tech Stack
Architect's Tech Stack
Dec 2, 2023 · Backend Development

Drawbacks of the Spring Framework: Performance, Configuration Complexity, Learning Curve, and More

This article examines several drawbacks of the Spring framework—including performance overhead from reflection and proxies, complex configuration, steep learning curve, over‑reliance on the Spring ecosystem, hidden “magic” features, version compatibility challenges, and misuse of dependency injection—illustrated with Java code examples.

ConfigurationJavadependency-injection
0 likes · 8 min read
Drawbacks of the Spring Framework: Performance, Configuration Complexity, Learning Curve, and More
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 2, 2023 · Backend Development

Mastering Spring’s @Import: Three Powerful Ways to Load Configurations

This guide explains Spring’s @Import annotation, covering three import strategies—direct class array, ImportSelector, and ImportBeanDefinitionRegistrar—through detailed code examples, usage scenarios, and important version notes, helping developers improve configuration management, code maintainability, and readability in backend Java applications.

Backend DevelopmentConfigurationImport Annotation
0 likes · 6 min read
Mastering Spring’s @Import: Three Powerful Ways to Load Configurations
Sohu Tech Products
Sohu Tech Products
Nov 22, 2023 · Fundamentals

Mastering the Chain of Responsibility: From SOLID Principles to Spring Integration

This article explains the seven SOLID design principles, introduces the Chain of Responsibility pattern, demonstrates its application to a video‑review workflow with step‑by‑step Java code, and shows how to evolve the implementation from a basic chain to a Spring‑managed, fully open‑closed solution.

Chain of ResponsibilityDesign PatternsJava
0 likes · 13 min read
Mastering the Chain of Responsibility: From SOLID Principles to Spring Integration
php Courses
php Courses
Nov 17, 2023 · Fundamentals

Using the Strategy Pattern in PHP to Send Notifications

An overview of the Strategy design pattern demonstrates how to encapsulate notification-sending algorithms in independent PHP classes, allowing runtime selection among email, SMS, or FCM implementations without modifying client code, and highlights benefits such as flexibility, reusability, and testability.

Design PatternsNotificationPHP
0 likes · 5 min read
Using the Strategy Pattern in PHP to Send Notifications
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 7, 2023 · Mobile Development

Comprehensive Guide to Building Modern Android Apps in 2023

This article provides a detailed overview of the latest 2023 trends, tools, libraries, architectural patterns, and best practices for developing modern Android applications, covering everything from Kotlin and Jetpack Compose to Clean Architecture, modularization, performance optimization, and Google Play features.

AndroidClean ArchitectureJetpack Compose
0 likes · 16 min read
Comprehensive Guide to Building Modern Android Apps in 2023
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 3, 2023 · Mobile Development

Comprehensive Guide to Using Hilt for Dependency Injection in Android

This article explains the fundamentals of dependency injection, introduces Hilt and its basic setup for Android, demonstrates advanced features such as qualifiers, scopes, assisted injection, custom entry points, and analyzes Hilt's underlying principles, helping developers decide whether to adopt DI frameworks in Android projects.

AndroidAssisted InjectionDI Framework
0 likes · 21 min read
Comprehensive Guide to Using Hilt for Dependency Injection in Android
php Courses
php Courses
Oct 23, 2023 · Backend Development

Implementing a Service Layer in PHP: Benefits, Steps, and Example Code

This article explains the purpose and advantages of a service layer between presentation and domain layers, outlines step‑by‑step how to create one in PHP—including directory setup, class and interface definitions, dependency injection—and provides sample code for user management services and controller integration.

Backend DevelopmentPHPService Layer
0 likes · 4 min read
Implementing a Service Layer in PHP: Benefits, Steps, and Example Code
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 21, 2023 · Backend Development

Mastering Spring’s ObjectProvider: Flexible Dependency Injection Techniques

Spring’s ObjectProvider interface enhances dependency injection by allowing optional, lazy, and multiple bean retrieval, offering methods like getIfAvailable, orderedStream, and stream, with code examples demonstrating on-demand injection, fetching all implementations, and the underlying mechanism via DependencyObjectProvider in the DefaultListableBeanFactory.

Javadependency-injectionobjectprovider
0 likes · 8 min read
Mastering Spring’s ObjectProvider: Flexible Dependency Injection Techniques