Spring-依赖来源

依赖来源

1 Spring BeanDefinition（xml,注解，BeanDefinitionBuilder, 还有API实现的单例对象）
2 Spring 内建BeanDefinition

3 内建单例对象

依赖注入和依赖查找的区别

Context.refresh() 的时候会调用这个方法：prepareBeanFactory(beanFactory)注入下面这几个对象：

我们可以看到在依赖查找的时候用到了：

public class DependencySourceDemo {
    //  字段注入注入postProcessProperties 方法执行 早于setter注入 也早于 @PostConstruct
    @Autowired
    BeanFactory beanFactory;

    @Autowired
    ResourceLoader resourceLoader;

    @Autowired
    ApplicationContext applicationContext;
    @Autowired
    ApplicationEventPublisher publisher;

    @PostConstruct
    public void init() {
        System.out.println(beanFactory == applicationContext);
        System.out.println(beanFactory == applicationContext.getAutowireCapableBeanFactory());
        System.out.println(resourceLoader == applicationContext);
        System.out.println(publisher == applicationContext);
    }

    @PostConstruct
    public void initLookUp() {
        getBean(BeanFactory.class);
        getBean(ApplicationEventPublisher.class);
        getBean(ApplicationContext.class);
        getBean(ResourceLoader.class);
    }
    public <T> T getBean(Class<T> type) {
        try {
            beanFactory.getBean(type);
        } catch (NoSuchBeanDefinitionException e) {
            System.err.println("无法在当前容器总找到" + type + "类型的bean");
        }
        return null;
    }

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(DependencySourceDemo.class);
        context.refresh();
    }
}

运行结果：

所以说依赖注入会比依赖查找多这样几个对象。

依赖来源及依赖使用场景

比较这几种来源的使用场景：
单体对象也就是内建的单例对象

1 Spirng BeanDefinition 通过 DefaultListableBeanFactory#registerBeanDefinition进行注册
这个方法后面会有这样一段代码，前者是存储了beanName和beanDefinition 后者是为了保证顺序，因为后者是一个ArrayList

2 单体对象
由SingletonBeanRegistry#registerSingleton
限制是没有生命周期管理的，也无法实现延迟初始化。

为什么ConcurrentHashMap还有加锁呢？
因为我们查找了以后如果没有还需要往里面放，所以也存在线程安全问题。
我们看到这里还有一把锁，是因为这个方法可能会被单独使用，但是其实这里锁的是同一个对象，如果是同一个线程内没有额外加锁。

同样这里也使用了LinkedHashSet保证了有序：

非容器托管的对象

DefaultListableBeanFactory#registerResolvableDependency
限制：
没有生命周期
无法实现延迟初始化
无法通过依赖查找

public class ResolvableDependencySourceDemo {
@Autowired
String value;
public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(ResolvableDependencySourceDemo.class);
    context.addBeanFactoryPostProcessor(beanFactory -> {
        beanFactory.registerResolvableDependency(String.class, "demo");
    });
    context.refresh();
    ResolvableDependencySourceDemo bean = context.getBean(ResolvableDependencySourceDemo.class);
    System.out.println(bean.value);
}
}

这里为什么要这样写呢？通过回调函数，因为我们依赖注入的时候如果容器启没有refresh beanFactory.registerResolvableDependency(String.class, “demo”);这个时候注册会报错，如果启动了，我们可不可以把这个注册写到refresh之后呢？不可以因为这个时候上面的@Autowired 注入的时候找不到这个bean也会报错，所以通过回调函数的方式来处理，当Factory创建好以后进行注册。

外部化配置作为依赖

没有生命周期
无法实现延迟初始化
无法通过依赖查找

@Configuration
@PropertySource(value = "meta-info/demo.properties", encoding = "GBK")
public class ExtDependencyDemo {
    @Value("${usr.name}")
    private String name;

    @Value("${usr.pass}")
    private String pass;
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(ExtDependencyDemo.class);
        context.refresh();
        ExtDependencyDemo bean = context.getBean(ExtDependencyDemo.class);
        System.out.println(bean.pass);
        System.out.println(bean.name);
    }
}

参考资料：小马哥核心编程思想