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

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

public class Cat {

}

public class Dog {

}

@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....");
  }
}

public abstract class BaseService<T> {

  @Autowired
  private BaseDao<T> baseDao;


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

@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();
  }

}

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();
    }
  }
}

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();
    }
  }

}

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));
    }
  }
}

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();
    }
  }
}