Spring实现泛型注入的示例详解

更新时间：2022年07月08日 08:18:25 作者：默念x

Spring 4.0版本中更新了很多新功能，其中比较重要的一个就是对带泛型的Bean进行依赖注入的支持。本文将通过实例详细讲讲Spring如何实现泛型注入，需要的可以参考一下

1.Spring泛型注入

创建一个抽象泛型类BaseDao，有参数化类型T

public abstract class BaseDao<T> {
    
  public abstract void eat();
}

每种动物有不同的行为，猫、狗

public class Cat {

}

public class Dog {

}

分别继承BaseDao实现不同的行为

@Repository
public class CatDao extends BaseDao<Cat> {

  @Override
  public void eat() {
    System.out.println("cat eat....");
  }
}

@Repository
public class DogDao extends BaseDao<Dog> {

  @Override
  public void eat() {
    System.out.println("dog eat....");
  }
}

接着创建一个抽象业务类，也有参数化类型T。

注意:此处不能使用@Resource注入，会找到多个BaseDao类型的bean，无法确认注入哪一个bean会报错

需要使用@Autowired注入，它有根据泛型参数匹配的逻辑，会一个个去匹配

public abstract class BaseService<T> {

  @Autowired
  private BaseDao<T> baseDao;


  protected void eat() {
    baseDao.eat();
  }
}

子类继承BaseService指定参数化类型实现注入相应的BaseDao

@Service
public class CatService extends BaseService<Cat> {


}

@Service
public class DogService extends BaseService<Dog> {

}

代码目录

测试

@Configuration
@ComponentScan(value = "com.monian.test.generic")
public class GenericConfig {

}

public class GenericTests {

  public static void main(String[] args) {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
    applicationContext.register(GenericConfig.class);
    applicationContext.refresh();

    DogService dogService = applicationContext.getBean(DogService.class);
    CatService catService = applicationContext.getBean(CatService.class);
    dogService.eat();
    catService.eat();
  }

}

结果输出，成功注入相应的BaseDao

2. 关于java泛型有四种Type

GenericArrayType泛型数组类型

public class GenericArrayTypeTest {


  public static class TestClass<S> {

    // 泛型数组
    private List<String>[] lists;

    // 泛型数组
    private S[] ss;

    private String[] s;
  }

  public static void main(String[] args) {

    Class cl = TestClass.class;
    for (Field field : cl.getDeclaredFields()) {
      System.out.println("filed's name:" + field.getName());

      Type genericType = field.getGenericType();
      System.out.println("Is it genericArrayType:" + (genericType instanceof GenericArrayType));

      if (genericType instanceof GenericArrayType) {
        GenericArrayType genericArrayType = (GenericArrayType) genericType;
        System.out.println(genericArrayType.getTypeName());
        Type genericComponentType = genericArrayType.getGenericComponentType();
        System.out.println(genericComponentType);
      }
      System.out.println();
    }
  }
}

result:

filed's name:lists
Is it genericArrayType:true
java.util.List<java.lang.String>[]
java.util.List<java.lang.String>

filed's name:ss
Is it genericArrayType:true
S[]
S

filed's name:s
Is it genericArrayType:false

ParameterizedType参数化类型

public class ParameterizedTypeTest {

  public static abstract class Test<T> {

    public abstract void test(T t);

  }

  public static class TestClass<T extends Number> extends Test<Integer> {

    private List<T> tList;

    private List<? extends Number> list;

    private Map<String, Integer> map;

    @Override
    public void test(Integer o) {

    }
  }


  public static void main(String[] args) {
    TestClass<Integer> tt = new TestClass<>();
    Class cl = tt.getClass();

    Type genericSuperclass = cl.getGenericSuperclass();
    assert genericSuperclass instanceof ParameterizedType;
    ParameterizedType parameterizedType1 = (ParameterizedType) genericSuperclass;
    System.out.println(parameterizedType1.getActualTypeArguments()[0]);

    for (Field field : cl.getDeclaredFields()) {
      System.out.println("field's name:" + field.getName());
      Type genericType = field.getGenericType();
      System.out.println("Is it ParameterizedType:" + (genericType instanceof ParameterizedType));

      if (genericType instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) genericType;
        for (Type type : parameterizedType.getActualTypeArguments()) {
          System.out.println("actualType:" + type);
          System.out.println(type.getTypeName());
        }
      }
      System.out.println();
    }
  }

}

result：

class java.lang.Integer
field's name:tList
Is it ParameterizedType:true
actualType:T
T

field's name:list
Is it ParameterizedType:true
actualType:? extends java.lang.Number
? extends java.lang.Number

field's name:map
Is it ParameterizedType:true
actualType:class java.lang.String
java.lang.String
actualType:class java.lang.Integer
java.lang.Integer

TypeVariable 类型变量

public class TypeVariableTest {

  public static class TestClass<S extends Number, T> {

    private Map<S, T> map;
  }


  public static void main(String[] args) throws Exception {

    Class cl = TestClass.class;
    Field field = cl.getDeclaredField("map");
    Type genericType = field.getGenericType();
    ParameterizedType parameterizedType = (ParameterizedType) genericType;
    for (Type type : parameterizedType.getActualTypeArguments()) {
      TypeVariable typeVariable = (TypeVariable) type;
      // 类型变量名
      System.out.println(typeVariable.getName());
      // 变量上边界
      Type[] bounds = typeVariable.getBounds();
      System.out.println(Arrays.toString(bounds));
    }
  }
}

result:

S
[class java.lang.Number]
T
[class java.lang.Object]

WildcardType 通配符类型

public class WildcardTypeTest {

  public static class TestClass {

    private List<? extends Number> lists;

    private Set<?> sets;

    private Map<? extends Number, ? super String> map;
  }

  public static void main(String[] args) {
    Class cl = TestClass.class;

    for (Field field : cl.getDeclaredFields()) {
      System.out.println("filed's name:" + field.getName());
      Type genericType = field.getGenericType();
      ParameterizedType parameterizedType = (ParameterizedType) genericType;
      for (Type type : parameterizedType.getActualTypeArguments()) {
        // 通配符类型
        WildcardType wildcardType = (WildcardType) type;
        System.out.println(wildcardType.getTypeName());
        // 上边界
        System.out.println("上边界" + Arrays.toString(wildcardType.getUpperBounds()));
        // 下边界
        System.out.println("下边界" + Arrays.toString(wildcardType.getLowerBounds()));
      }
      System.out.println();
    }
  }
}

result:

filed's name:lists
? extends java.lang.Number
上边界[class java.lang.Number]
下边界[]

filed's name:sets
?
上边界[class java.lang.Object]
下边界[]

filed's name:map
? extends java.lang.Number
上边界[class java.lang.Number]
下边界[]
? super java.lang.String
上边界[class java.lang.Object]
下边界[class java.lang.String]

注:spring对泛型的解析主要是在ResolvableType类，掌握上述的基本知识后可以去阅读下相关源码

到此这篇关于Spring实现泛型注入的示例详解的文章就介绍到这了,更多相关Spring泛型注入内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

SpringBoot实现连接nacos并支持多环境部署
这篇文章主要介绍了SpringBoot实现连接nacos并支持多环境部署方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-06-06
如何通过Java监听MySQL数据的变化
对于二次开发来说，很大一部分就找找文件和找数据库的变化情况,下面这篇文章主要给大家介绍了关于如何通过Java监听MySQL数据的变化的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
2023-03-03
详解Java8中CompletableFuture类的使用
Java 8中引入了CompletableFuture类，它是一种方便的异步编程工具，可以处理各种异步操作，本文将详细介绍CompletableFuture的使用方式，希望对大家有所帮助
2023-04-04
用java实现在txt文本中写数据和读数据的方法
今天小编就为大家分享一篇用java实现在txt文本中写数据和读数据的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2018-07-07
SpringSecurity Web权限方案实现全过程
Spring Security是一个功能强大且高度可定制的身份验证和授权框架,专门用于保护Java应用程序的Web集成,下面这篇文章主要给大家介绍了关于SpringSecurity Web权限方案实现的相关资料,需要的朋友可以参考下
2024-01-01
Java中JVM常用参数配置教程(提供配置示例)
这篇文章主要给大家介绍了关于Java中JVM常用参数配置的相关资料, jvm的参数有很多,必须知道参数分类并且记住面试常见的几个参数,文中通过代码介绍的非常详细,需要的朋友可以参考下
2024-06-06
详解java中BigDecimal精度问题
这篇文章主要介绍了java BigDecimal精度问题，对精确计算感兴趣的同学，可以参考下
2021-05-05
浅谈利用Session防止表单重复提交
这篇文章主要介绍了浅谈利用Session防止表单重复提交，简单介绍表单重复提交的情况，分析，以及解决方法代码示例，具有一定借鉴价值，需要的朋友可以了解下。
2017-12-12
SpringBoot集成JPA持久层框架,简化数据库操作
JPA(Java Persistence API)意即Java持久化API，是Sun官方在JDK5.0后提出的Java持久化规范。主要是为了简化持久层开发以及整合ORM技术，结束Hibernate、TopLink、JDO等ORM框架各自为营的局面。JPA是在吸收现有ORM框架的基础上发展而来，易于使用，伸缩性强。
2021-06-06
maven多模块项目依赖管理与依赖继承详解
这篇文章主要介绍了maven多模块项目依赖管理与依赖继承详解，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-12-12