很多bean注入为啥是这样ApplicationContextUtil.getBean(MigrateService.class);而不是 @Autowired MigrateService migrateService

这是因为在某些情况下，使用 @Autowired 注解可能会出现一些问题，例如在非 Spring 管理的类中使用 @Autowired 注解时，会导致注入失败。而使用 ApplicationContextUtil.getBean() 方法可以确保获取到正确的 Bean 实例。此外，使用 ApplicationContextUtil.getBean() 方法还可以在任何地方获取到 Bean 实例，而不仅仅局限于 Spring 管理的类中。

相关问题

beanFactory.getBean(clz) 和 @Autowired

beanFactory.getBean(clz) 是在 Spring 框架中通过 BeanFactory 获取指定类型的 Bean 实例。它需要传入一个 Class 对象作为参数，返回与该类型匹配的 Bean 实例。

@Autowired 是 Spring 框架中的一个注解，用于自动装配 Bean。它可以用在字段、构造函数、Setter 方法上，通过类型匹配来自动注入相应的 Bean 实例。

两者的区别在于，beanFactory.getBean(clz) 是手动通过代码获取 Bean 实例，而 @Autowired 是通过自动装配的方式将 Bean 注入到对应的字段、构造函数或方法中。使用 @Autowired 注解可以减少手动获取 Bean 的代码，提高代码的可读性和可维护性。

1. *由容器创建和管理* *bean**，**bean* *应当为容器内单实例* * 注册 bean 方法为 register 2. *根据类型* *getBean* 3. *bean* *有基本依赖注入功能，根据**类型**进行依赖注入* 完成后应该能实现如下功能 ```java static class A { @Autowired // 自定义 private B b; public void foo() { System.out.println("A foo()"); b.bar(); } } static class B { public void bar() { System.out.println("B bar()"); } } public static void main(String[] args) { BeanFactory container = new Container(); container.register(A.class); // 注册 A container.register(B.class); // 注册 B A a = container.getBean(A.class); // 获取 A 实例 container.autowired(a); // 依赖注入 a.foo(); // 不应该出现空指针，即 B 注入成功 } ```

您可以使用以下代码来实现所需的功能：

import java.util.HashMap;
import java.util.Map;

class Container implements BeanFactory {
    private Map<Class<?>, Object> beanMap = new HashMap<>();

    @Override
    public void register(Class<?> clazz) {
        try {
            Object bean = clazz.getDeclaredConstructor().newInstance();
            beanMap.put(clazz, bean);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public <T> T getBean(Class<T> clazz) {
        return clazz.cast(beanMap.get(clazz));
    }

    @Override
    public void autowired(Object bean) {
        try {
            for (var field : bean.getClass().getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    Class<?> fieldType = field.getType();
                    Object dependency = beanMap.get(fieldType);
                    field.set(bean, dependency);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

interface BeanFactory {
    void register(Class<?> clazz);
    <T> T getBean(Class<T> clazz);
    void autowired(Object bean);
}

@interface Autowired {
}

static class A {
    @Autowired
    private B b;

    public void foo() {
        System.out.println("A foo()");
        b.bar();
    }
}

static class B {
    public void bar() {
        System.out.println("B bar()");
    }
}

public static void main(String[] args) {
    BeanFactory container = new Container();
    container.register(A.class);
    container.register(B.class);

    A a = container.getBean(A.class);
    container.autowired(a);
    a.foo();
}

运行以上代码，输出应为：

A foo()
B bar()