理解

控制反转（Inversion of Control，IoC）：一个设计原则，指的是将对象的创建和管理的控制权从对象本身转移到外部系统
依赖注入（Dependency Injection，DI）：一种设计模式，允许在运行时将依赖项（如数据库连接）注入到需要它们的组件中

FastAPI

定义依赖项：get_query_param 和 common_parameters 是两个函数，分别定义了不同的依赖项。它们可以有默认参数和返回值
使用Depends：在路径操作函数中，通过 Depends 将依赖注入。FastAPI会自动调用这些依赖项，并将返回值传递给路径操作函数
自动管理：FastAPI会自动管理依赖项的生命周期和实例化，这就是控制反转的体现。你不需要手动创建或管理这些依赖项

from fastapi import Depends, FastAPI

app = FastAPI()

# 定义一个依赖项
def get_query_param(q: str = None):
    return q


# 使用依赖项的路径操作
@app.get("/items/")
async def read_items(q: str = Depends(get_query_param)):
    return {"query_param": q}


# 另一个依赖项示例
def common_parameters(q: str = None, skip: int = 0, limit: int = 10):
    return {"q": q, "skip": skip, "limit": limit}


@app.get("/users/")
async def read_users(commons: dict = Depends(common_parameters)):
    return commons

依赖注入单例

from typing import Optional

from fastapi import Depends, FastAPI

app = FastAPI()

# 单例依赖的示例
class MySingleton:
    _instance: Optional["MySingleton"] = None


def __new__(cls, *args, **kwargs):
    if cls._instance is None:
        cls._instance = super().__new__(cls)
    return cls._instance


def common_operation(self):
    return "This is a common operation"


# 依赖项工厂
def get_singleton() -> MySingleton:
    return MySingleton()


@app.get("/singleton/")
async def use_singleton(singleton=Depends(get_singleton)):
    response = singleton.common_operation()
    return response


# 运行服务器
if name == "main":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=8000)

Spring

控制反转（IoC）

在Java中，IoC意味着将对象的创建和管理的责任从代码中移除，转交给外部容器（如Spring容器）
这样，代码的耦合度降低，增强了模块间的独立性和可替换性

依赖注入（DI）：

DI是IoC的一种实现方式，它允许对象通过构造器参数、工厂方法的参数或对象的属性来接收它们的依赖对象
Spring支持几种类型的依赖注入：构造器注入、设置器注入和字段注入

定义组件：

MessageService和MessagePrinter都使用@Component注解，这告诉Spring这些类需要被管理

依赖注入：

MessagePrinter通过其构造函数使用@Autowired注解来注入MessageService
这表示当Spring创建MessagePrinter的实例时，它会自动注入一个MessageService的实例

配置和运行：

Application类使用@Configuration和@ComponentScan注解来配置Spring
ComponentScan指定Spring在哪些包中查找带有@Component注解的类
main方法初始化Spring应用上下文，并获取MessagePrinter的bean，然后调用printMessage方法

通过这种方式，Spring框架管理了对象的生命周期和依赖关系，开发者可以专注于业务逻辑的实现，提高了代码的可维护性和可测试性

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Component
public class MessageService {
    public String getMessage() {
        return "Hello, World!";
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessagePrinter {
    private final MessageService service;

    @Autowired
    public MessagePrinter(MessageService service) {
        this.service = service;
    }

    public void printMessage() {
        System.out.println(service.getMessage());
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "your.package.name")
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
        MessagePrinter printer = context.getBean(MessagePrinter.class);
        printer.printMessage();
    }
}

目录CONTENT

控制反转（IoC）、依赖注入（DI）

理解

FastAPI

Spring

评论区