Spring 使用 setter 方法实现依赖注入的三种方式

本文讨论最简单的 Spring setter 方法实现依赖注入的方法。
我们主要讨论手动模式的 setter 方法实现依赖注入，主要有三种模式。

• xml 资源配置元信息
• Java 注解配置元信息
• API 配置元信息

首先上代码结构图：

在这里插入图片描述

我们定义 model 类 Employee，两个最简单属性：String name 和 Long id。
Boss 类继承 Employee 类，并且添加属性 String title。两个类都加上 getter/ setter 方法和 toString() 方法。

我们首先定义基本的 dependency-injection-context.xml 文件，来定义 Employee 和 Boss 的 Spring bean。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--实时查找 bean 的方式-->
    <bean id="emp" class="container.overview.domain.Employee">
        <property name="id" value="1"></property>
        <property name="name" value="小明"></property>
    </bean>

    <bean id="boss" class="container.overview.domain.Boss" parent="emp" primary="true">
        <property name="title" value="CTO"></property>
    </bean>
</beans>

然后我们定义一个 UserHolder 类来放置 Employee 类。

public class UserHolder {

    private Employee employee;

    public UserHolder(Employee employee) {
        this.employee = employee;
    }

    /*public UserHolder() {

    }*/

    public Employee getEmployee() {
        return employee;
    }

    public void setEmployee(Employee employee) {
        this.employee = employee;
    }

    @Override
    public String toString() {
        return "UserHolder{" +
                "employee=" + employee +
                '}';
    }
}

xml 资源配置元信息

相关 xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:/META-INF/dependency-injection-context.xml"/>

    <bean class="ioc.dependency.injection.UserHolder">
        <property name="employee" ref="boss"/>
    </bean>

</beans>

我们第一个最简单的方式就是使用 xml 来实现依赖注入。如上面的 xml 文件所示，我们的 UserHolder 类的 <property name="employee" ref="boss"/> 。

Java 代码：

public class XmlDependencyInjectionDemo {

    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); // 这个类可以实现层次性、集合类型、单一类型的
        // 查找。
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        String resourcePath = "classpath:/META-INF/dependency-setter-injection.xml";
        // 加载 xml 资源，解析并且生成 BeanDefinition
        xmlBeanDefinitionReader.loadBeanDefinitions(resourcePath);
        UserHolder userHolder = beanFactory.getBean(UserHolder.class);
        System.out.println(userHolder);
    }
}

Java 注解配置元信息

public class AnnotationDependencyInjectionDemo {
    public static void main(String[] args) {
        // 创建 beanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 注册配置类来取代我们的 xml 文件。
        applicationContext.register(AnnotationDependencyInjectionDemo.class);
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);
        String resourceLocation = "META-INF/dependency-injection-context.xml";
        // 加载 xml 资源，解析并且生产 beanDefinition
        xmlBeanDefinitionReader.loadBeanDefinitions(resourceLocation);
        applicationContext.refresh();
        UserHolder holder = applicationContext.getBean(UserHolder.class);
        System.out.println(holder);
        applicationContext.close();
    }

    @Bean
    public UserHolder userHolder(Employee employee) {
        return new UserHolder(employee);
    }
}

将当前类作为配置类，然后使用 @Bean 注解注入 Spring bean。

API 配置元信息

public class APIDependencyInjectionDemo {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 生成并且注册 UserHolder 的 beanDefinition
        BeanDefinition beanDefinition = createDefinition();
        applicationContext.registerBeanDefinition("userHolder",beanDefinition);
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(applicationContext);
        String resourceLocation = "META-INF/dependency-injection-context.xml";
        xmlBeanDefinitionReader.loadBeanDefinitions(resourceLocation);
        // 启动应用上下文
        applicationContext.refresh();
        UserHolder userHolder = applicationContext.getBean(UserHolder.class);
        System.out.println(userHolder);
        applicationContext.close();
    }

    private static BeanDefinition createDefinition() {
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(UserHolder.class);
        beanDefinitionBuilder.addPropertyReference("employee","boss");
        return beanDefinitionBuilder.getBeanDefinition();

    }
}

使用相关的 API 来实现 setter 注入依赖。

---

完整代码放在我的 github 上。戳此可以查看

本文参考资料：小马哥讲Spring核心编程思想
自动注入可以参考我的另一篇文章 自动注入 autowire 中 byName 和 byType 的区别