实力总结四类Bean注入Spring的方式

川长思鸟来 2023-09-28 14:43 106阅读 0赞

一提到 `Spring` ，大家最先想到的是啥？是 `AOP` 和 `IOC` 的两大特性？是 `Spring` 中 `Bean` 的初始化流程？还是基于 `Spring` 的 `Spring Cloud` 全家桶呢？

今天我们就从 `Spring` 的 `IOC` 特性入手，聊一聊 `Spring` 中把 `Bean` 注入 `Spring` 容器的几种方式。

我们先来简单了解下 `IOC` 的概念： `IOC` 即 **控制反转** ，也称为 **依赖注入** ，是指将 **对象的创建** 或者 **依赖关系的引用** 从具体的对象控制转为框架或者 `IOC` 容器来完成，也就是依赖对象的获得被反转了。

可以简单理解为原来由我们来创建对象，现在由 `Spring` 来创建并控制对象。

### xml 方式 ###

依稀记得最早接触 `Spring` 的时候，用的还是 `SSH` 框架，不知道大家对这个还有印象吗？所有的 `bean` 的注入得依靠 `xml` 文件来完成。

它的注入方式分为： `set` 方法注入、构造方法注入、字段注入，而注入类型分为值类型注入（8种基本数据类型）和引用类型注入（将依赖对象注入）。

以下是 `set` 方法注入的简单样例

<bean name="teacher" class="org.springframework.demo.model.Teacher">
        <property name="name" value="阿Q"></property>
    </bean>
    复制代码

对应的实体类代码

public class Teacher {
    
    	private String name;
    
    	public void setName(String name) {
    		this.name = name;
        }
    }
    复制代码

xml方式存在的缺点如下：

1.  `xml` 文件配置起来比较麻烦，既要维护代码又要维护配置文件，开发效率低；
2.  项目中配置文件过多，维护起来比较困难；
3.  程序编译期间无法对配置项的正确性进行验证，只能在运行期发现并且出错之后不易排查；
4.  解析 `xml` 时，无论是将 `xml` 一次性装进内存，还是一行一行解析，都会占用内存资源，影响性能。

### 注解方式 ###

随着 `Spring` 的发展， `Spring 2.5` 开始出现了一系列注解，除了我们经常使用的@Controller、@Service、@Repository、@Component 之外，还有一些比较常用的方式，接下来我们简单了解下。

#### @Configuration + @Bean ####

当我们需要引入第三方的 `jar` 包时，可以用 `@Bean` 注解来标注，同时需要搭配 `@Configuration` 来使用。

*  `@Configuration` 用来声明一个配置类，可以理解为 `xml` 的 `<beans>` 标签
 *  `@Bean` 用来声明一个 `bean` ，将其加入到 `Spring` 容器中，可以理解为 `xml` 的 `<bean>` 标签

简单样例：将 RedisTemplate 注入 Spring

@Configuration
    public class RedisConfig {
        @Bean
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
            ......
            return redisTemplate;
        }
    }
    复制代码

#### @Import ####

我们在翻看 `Spring` 源码的过程中，经常会看到 `@Import` 注解，它也可以用来将第三方 `jar` 包注入 `Spring` ，但是它只可以作用在 **类** 上。

例如在注解 `EnableSpringConfigured` 上就包含了 `@Import` 注解，用于将 `SpringConfiguredConfiguration` 配置文件加载进 `Spring` 容器。

@Import(SpringConfiguredConfiguration.class)
    public @interface EnableSpringConfigured {}
    复制代码

`@Import` 的 `value` 值是一个数组，一个一个注入比较繁琐，因此我们可以搭配 `ImportSelector` 接口来使用，用法如下：

@Configuration
    @Import(MyImportSelector.class)
    public class MyConfig {}
    
    public class MyImportSelector implements ImportSelector {
    	@Override
        public String[] selectImports(AnnotationMetadata annotationMetadata) {
            return new String[]{"org.springframework.demo.model.Teacher","org.springframework.demo.model.Student"};
        }
    }
    复制代码

其中 `selectImports` 方法返回的数组就会通过 `@Import` 注解注入到 `Spring` 容器中。

无独有偶， `ImportBeanDefinitionRegistrar` 接口也为我们提供了注入 `bean` 的方法。

@Import(AspectJAutoProxyRegistrar.class)
    public @interface EnableAspectJAutoProxy {
        ......
    }
    复制代码

我们点击 `AspectJAutoProxyRegistrar` 类，发现它实现了 `ImportBeanDefinitionRegistrar` 接口，它的 `registerBeanDefinitions` 方法便是注入 `bean` 的过程，可以参考下。

如果觉得源代码比较难懂，可以看一下我们自定义的类

@Configuration
    @Import(value = {MyImportBeanDefinitionRegistrar.class})
    public class MyConfig {}
    
    public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                            BeanDefinitionRegistry registry) {
                RootBeanDefinition tDefinition = new RootBeanDefinition(Teacher.class);
                // 注册 Bean，并指定bean的名称和类型
                registry.registerBeanDefinition("teacher", tDefinition);
            }
        }
    }
    复制代码

这样我们就把 `Teacher` 类注入到 `Spring` 容器中了。

### FactoryBean ###

提到 `FactoryBean` ，就不得不与 `BeanFactory` 比较一番。

*  `BeanFactory` : 是 `Factory` ， `IOC` 容器或者对象工厂，所有的 `Bean` 都由它进行管理
 *  `FactoryBean` : 是 `Bean` ，是一个能产生或者修饰对象生成的工厂 `Bean` ，实现与工厂模式和修饰器模式类似

那么 `FactoryBean` 是如何实现 `bean` 注入的呢？

先定义实现了 `FactoryBean` 接口的类

public class TeacherFactoryBean implements FactoryBean<Teacher> {
    
    	/**
    	 * 返回此工厂管理的对象实例
    	 **/
    	@Override
    	public Teacher getObject() throws Exception {
    		return new Teacher();
    	}
    
    	/**
    	 * 返回此 FactoryBean 创建的对象的类型
    	 **/
    	@Override
    	public Class<?> getObjectType() {
    		return Teacher.class;
    	}
    
    }
    复制代码

然后通过 @Configuration + @Bean的方式将 `TeacherFactoryBean` 加入到容器中

@Configuration
    public class MyConfig {
    	@Bean
    	public TeacherFactoryBean teacherFactoryBean(){
    		return new TeacherFactoryBean();
    	}
    }
    复制代码

注意：我们没有向容器中注入 `Teacher` , 而是直接注入的 `TeacherFactoryBean` ，然后从容器中拿 `Teacher` 这个类型的 `bean` ，成功运行。

### BDRegistryPostProcessor ###

看到这个接口，不知道对于翻看过 `Spring` 源码的你来说熟不熟悉。如果不熟悉的话请往下看，要是熟悉的话就再看一遍吧:smiley:。

#### 源码 ####

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
        // 注册bean到spring容器中
    	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
    }
    
    @FunctionalInterface
    public interface BeanFactoryPostProcessor {
    	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    }
    复制代码

`BeanFactoryPostProcessor` 接口是 `BeanFactory` 的后置处理器，方法 `postProcessBeanFactory` 对 `bean` 的定义进行控制。今天我们重点来看看 `postProcessBeanDefinitionRegistry` 方法：它的参数是 `BeanDefinitionRegistry` ，顾名思义就是与 `BeanDefinition` 注册相关的。

![format_png][]

通过观察该类，我们发现它里边包含了 `registerBeanDefinition` 方法，这个不就是我们想要的吗？为了能更好的使用该接口来达到注入 `bean` 的目的，我们先来看看 `Spring` 是如何操作此接口的。

![format_png 1][]

看下 `invokeBeanFactoryPostProcessors` 方法，会发现没有实现 `PriorityOrdered` 和 `Ordered` 的 `bean` （这种跟我们自定义的实现类有关）会执行以下代码。

while (reiterate) {
        ......
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        ......
    }
    复制代码

进入该方法

private static void invokeBeanDefinitionRegistryPostProcessors(
        Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, 
        BeanDefinitionRegistry registry) {
    
        for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
    }
    复制代码

会发现实现了 `BeanDefinitionRegistryPostProcessor` 接口的 `bean` ，其 `postProcessBeanDefinitionRegistry` 方法会被调用，也就是说如果我们自定义接口实现该接口，它的 `postProcessBeanDefinitionRegistry` 方法也会被执行。

#### 实战 ####

话不多说，直接上代码。自定义接口实现类

public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    
    	/**
    	 * 初始化过程中先执行
    	 **/
    	@Override
    	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    		RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Teacher.class);
    		//Teacher 的定义注册到spring容器中
    		registry.registerBeanDefinition("teacher", rootBeanDefinition);
    	}
    
    	/**
    	 * 初始化过程中后执行
    	 **/
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {}
    }
    复制代码

启动类代码

public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        MyBeanDefinitionRegistryPostProcessor postProcessor = new MyBeanDefinitionRegistryPostProcessor();
        //将自定义实现类加入 Spring 容器
        context.addBeanFactoryPostProcessor(postProcessor);
        context.refresh();
        Teacher bean = context.getBean(Teacher.class);
        System.out.println(bean);
    }
    复制代码

启动并打印结果

org.springframework.demo.model.Teacher@2473d930
    复制代码

发现已经注入到 `Spring` 容器中了。

以上就是我们总结的几种将 `bean` 注入 `Spring` 容器的方式，赶快行动起来实战演练一下吧！

![6580880c27214a01949a4f3f0792d85f.jpeg][]

[format_png]: https://img-blog.csdnimg.cn/img_convert/afe84158e36137f70536ac8630d849be.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/922307c2e94b1457a675cfc4150d4883.webp?x-oss-process=image/format,png
[6580880c27214a01949a4f3f0792d85f.jpeg]: https://img-blog.csdnimg.cn/6580880c27214a01949a4f3f0792d85f.jpeg