2.2.2 泛型依赖注入

阅读本篇需要读者首先对Spring注解配置Bean部分的内容有粗浅的了解
Spring注解配置Bean的两种主要方式

Spring4开始可以为子类注入子类对应的泛型类型成员变量的引用

在此通过一个实例来说明如何通过Spring的注解实现

1. 主程序依赖于抽象类型
2. 向子类所对应的泛型类类型成员变量中注入其他对象的引用（此处为向UserService的成员变量中注入对UserRepository类型的对象的引用）

为了便于读者理解，先说点题外话，讨厌咬文嚼字的朋友可以选择跳过，这里我所理解的依赖和注入，二者是分开的。依赖一方面只的是类型与类型之间的依赖关系，另一方面是指最后主程序与主程序main方法中所使用的类之间的依赖关系。很明显，前者主要是抽象类AbstractService 对 AbstractRepository的依赖关系，不过这个关系进而被子类继承成为UserService对UserRepository的依赖关系，为什么说这个依赖关系被继承了呢？
很明显，main()方法中本来只对UserService类的方法进行了调用，但却间接地调用了UserRepository的方法并得到了其方法的输出结果，显然调用前者方法的同时也调用了后者的方法，这表明UserService类对UserRepository类是有依赖关系的，而这依赖关系在这两个类自己的代码中没有体现，很显然是从父类型那继承得到的
而主程序这边很明显，并没有直接使用UserService类和UserRepository类的相关方法，而仅仅得到了AbstractService的对象也只调用了AbstractService的方法。所以我们的主程序是依赖于抽象类型的
另一点注入，指的就是资源的注入。我们是不可能直接创建两个抽象类型的对象的。
而我们的子类UserService中所使用的父类的成员变量repository它是AbstractRepository类型兼容的，但是很明显它肯定不仅仅是AbstractRepository这个抽象类型。那它有时何时被创建何时又到我们所得到的这个UserService类的实例对象中来的呢。答案就是我们Spring4开始才有的泛型依赖注入
后面配合代码详细介绍这个泛型依赖注入的过程

一.抽象类型

• 抽象类型1：AbstractService

package thread.conor.spring.generic;
import org.springframework.beans.factory.annotation.Autowired;
public abstract class AbstractService <T>{
    @Autowired
    protected AbstractRepository<T> repository;
    public abstract void add(T t);
}

• 抽象类型2：AbstractRepository

package thread.conor.spring.generic;
public abstract class AbstractRepository <T>{
    public abstract void act(T t);
}

注意：

1. 由于AbstractService 中需要有一个repository成员变量来实现对另一个泛型类AbstractRepository的依赖关系，所以不能使用接口代替抽象类
2. 上面两个抽象类都没有使用与特定组件相关的注解（如@Component）也就意味着无法被Spring容器通过<context:component-scan>标签扫描到
3. @Autowired注解标识了repository成员变量依据类型AbstractRepository的自动装配

二. 实体类型

1. UserService

package thread.conor.spring.generic;
import org.springframework.stereotype.Service;
import thread.conor.spring.domain.User;
@Service
public class UserService extends AbstractService<User>{
    @Override
    public void add(User user) {
        System.out.println("user " +user.getName() + " is in service");
        repository.act(user);
    }
}

2. Repository

package thread.conor.spring.generic;

import org.springframework.stereotype.Repository;

import thread.conor.spring.domain.User;

@Repository
public class UserRepository extends AbstractRepository<User>{

    @Override
    public void act(User user) {
        System.out.println(user.getName()+" is added into repository");
    }
}

3. user

package thread.conor.spring.domain;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class User {
    private String name = "conor";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

注意：

1. 上述实体类都有与组件相关的注解（@Repository,@Service,@Component），都会被Spring容器扫描到

三. 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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    <context:component-scan base-package="thread.conor.spring.generic,thread.conor.spring.domain"></context:component-scan>

</beans>

<context:component-scan base-package="thread.conor.spring.generic,thread.conor.spring.domain"></context:component-scan>此句即为配置需要扫描的包，其他外面的只是框子（套路）

四. Main主程序

package thread.conor.spring.generic;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-generic.xml");
        AbstractService service = (AbstractService) ctx.getBean("userService");
        service.add(ctx.getBean("user"));
    }
}

注意：

1. 这里main方法只使用了抽象类型AbstractService，即除了IOC容器外只有对抽象类型AbstractService的依赖（对于AbstractRepository的依赖也是通过这层依赖进行传递的）

五. 运行结果

user conor is in service
conor is added into repository

1. 第一句表明主程序虽然只对抽象类型AbstractService有依赖关系，却调用了其子类的方法。
2. 第二句说明在调用UserService的方法add(User user)时也通过其中的repository.act(user);这句话调用到了UserRepository的对象的方法act(User user)。这里repository是从UserService父类型AbstractService继承而来的成员变量，但是这个成员变量的引用指向的却是UserRepository类的一个对象，当然这个对象是关于AbstractRepository类兼容的，这里这个repository成员变量就是通过AbstractService抽象类中对repository成员变量标识的@Autowired注解来将 标识了@Repository注解的UserRepository类 的对象依据类型自动装配到UserService的成员变量repository之中的
   这里UserService类的repository成员变量是从父类型继承而来的。

六. 此程序实例的依赖，继承关系如下图所示：