Spring依赖注入与第三方Bean管理基础详解

Spring依赖注入与第三方Bean管理基础详解

Spring是一个企业级应用开发框架，它能够帮助开发者做到松耦合、便于测试和灵活性高的设计。其中的依赖注入和第三方Bean管理是Spring最为重要的两个特性之一，也是开发者需要掌握的基础知识。

什么是依赖注入？

依赖注入（DI，Dependency Injection）是指Spring容器将一个Bean的依赖注入到另一个Bean中。在Spring中，Bean之间的依赖关系都是通过依赖注入来实现的。依赖注入有三种方式：构造注入、Setter注入和接口注入。

以构造注入为例，假设有两个类Dog和Person，Person类中有一个Dog类型的成员变量，通过构造注入可以实现将Dog注入到Person中，代码如下：

public class Dog {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    // setter and getter method
}

public class Person {
    private Dog dog;

    public Person(Dog dog) {
        this.dog = dog;
    }

    // setter and getter method
}

什么是第三方Bean管理？

第三方Bean管理是指Spring容器管理非Spring的Bean。在实际项目中，我们通常会使用一些非Spring的Bean来处理一些业务逻辑，如果想让Spring容器能够管理这些Bean，则需要向Spring容器注册这些Bean。

在注册Bean之前，需要先定义一个BeanFactoryPostProcessor的实现类，用于修改Bean的定义。例如，我们写一个BeanFactoryPostProcessor的实现类，将所有名字以"myBean_"开头的Bean的scope改为singleton，如下：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            if (beanName.startsWith("myBean_")) {
                BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
                bd.setScope("singleton");
            }
        }
    }
}

然后在Spring的配置文件中，向容器中注册这个BeanFactoryPostProcessor的实现类，如下：

<bean class="com.example.MyBeanFactoryPostProcessor"/>

最后，我们可以在其他类中注入这些非Spring的Bean，如下：

@Component
public class UserServiceImpl {
    @Autowired
    @Qualifier("myBean_userDAO")
    private UserDAO userDAO;

    // method
}

示例1：Spring依赖注入

以构造注入为例，假设现在有一个Teacher类和一个Student类，每个Teacher对象可以关联多个Student对象，在Teacher类中添加一个List类型的成员变量，在创建Teacher对象时通过构造注入将Student注入到Teacher中，代码如下：

public class Teacher {
    private List<Student> students;

    public Teacher(List<Student> students) {
        this.students = students;
    }

    // setter and getter method
}

public class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    // setter and getter method
}

在Spring的配置文件中，可以使用如下代码定义Teacher和Student的Bean：

<bean id="student1" class="com.example.Student">
    <constructor-arg value="张三"/>
</bean>

<bean id="student2" class="com.example.Student">
    <constructor-arg value="李四"/>
</bean>

<bean id="teacher" class="com.example.Teacher">
    <constructor-arg>
        <list>
            <ref bean="student1"/>
            <ref bean="student2"/>
        </list>
    </constructor-arg>
</bean>

这样，Spring容器会自动将创建的Student对象注入到Teacher对象中，我们就可以在Teacher类中使用students来完成业务逻辑操作。

示例2：第三方Bean管理

假设我们现在需要使用一个非Spring的Bean——RedisTemplate，来操作Redis缓存。首先需要在Spring的配置文件中引入Redis的依赖，如下：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.3.6.RELEASE</version>
</dependency>

然后需要向Spring容器中注册RedisTemplate的实例，如下：

<bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    <property name="hostName" value="localhost"/>
    <property name="port" value="6379"/>
</bean>

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <property name="connectionFactory" ref="redisConnectionFactory"/>
    <property name="keySerializer" ref="stringRedisSerializer"/>
    <property name="valueSerializer" ref="stringRedisSerializer"/>
</bean>

<util:constant id="stringRedisSerializer" static-field="org.springframework.data.redis.serializer.RedisSerializer.string"/>

注入RedisTemplate的方式和注入Spring的Bean一样，我们只需要在代码中使用@Autowired和@Qualifier注解即可，如下：

@Component
public class UserServiceImpl {
    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate<String, String> redisTemplate;

    // method
}

这样，我们就可以在Spring容器管理的Bean中，使用RedisTemplate来操作Redis缓存了。