在看到Spring当中是支持数组/集合/Map去进行注入的，但是我们如果自己要去使用，应该怎么做呢？以前自己确实没做过，这里记录一下。

1. 如何使用反射去进行数组字段的注入？

比如我们定义了如下这样一个字段

    private User[] users;

我们用反射如何去进行实现对这个字段去进行赋值？首先我们可以通过Class.getField去获取到这个users字段。

Field field = App.class.getField("users");

接着呢，我们的想法是什么？反射创建对象对吧！

我们使用如下的代码可以获取到字段的类型(User[])

Class<?> fieldType = field.getType();

那么我们如何去创建一个User[]类型的对象？因为这是个数组类型，我们自然可以拿到它的元素类型，使用如下的代码

Class<?> componentType = fieldType.getComponentType();

这个componentType就可以拿到User的类型Class。接着怎么做？我们如何创建一个数组对象？可以使用JDK提供的Array类给我们提供的相关方法：

Object userArray = Array.newInstance(componentType, 10);

使用上面的代码，userArray就是一个长度为10的User[]，那么我们如何对这个数组当中的元素去进行赋值？当然也是使用Array类为我们提供的相关方法。

            for (int i = 0; i < 10; i++) {
                Object user = componentType.getDeclaredConstructor().newInstance();
                Array.set(userArray, i, user);
            }

使用Array.set方法就可以很方便地为数组当中的元素进行赋值了！所以使用反射对User[]类型的字段去进行赋值的完整的代码如下

        Field field = App.class.getField("users");
        Class<?> fieldType = field.getType();

        if (fieldType.isArray()) {
            Class<?> componentType = fieldType.getComponentType();
            Object userArray = Array.newInstance(componentType, 10);
            for (int i = 0; i < 10; i++) {
                Object user = componentType.getDeclaredConstructor().newInstance();
                Array.set(userArray, i, user);
            }
            field.setAccessible(true);
            field.set(new App(), userArray);
        }

2. 如何使用反射去对集合的字段去进行注入？

比如我们定义了如下的字段

    public List<User> users;

我们当然也可以使用反射拿到这个字段，以及拿到这个字段类型

Field field = App.class.getField("users");
Class<?> fieldType = field.getType();

但是问题来了，Java当中对于泛型的实现是使用的类型擦除，也就是所你List<User>，这样一个集合，在底层仍然是使用的List<Object>去进行实现的，对于泛型的检查都是在javac对Java代码在编译层面去进行检查的。

这说明了什么呢？说明了我们通过fieldType是拿不到我们定义的泛型信息的，因为类型被抹除成为Object类型了。我们有什么办法获取到泛型信息吗？既然通过fieldType获取不到，那么我们使用Filed去进行获取嘛，在HotSpot VM当中，Field是有记录泛型的类型的！那么我们如何去进行获取？我们可以使用它的getGenericType方法去进行获取。

Type genericType = field.getGenericType();

对于字段当中的泛型，实际上Type是一个ParameterizedType类型，我们可以将其进行强转试试！

        if (genericType instanceof ParameterizedType) {
            ParameterizedType type = (ParameterizedType) genericType;
            Type[] actualTypeArguments = type.getActualTypeArguments();
        }

我们发现强转之后，它就为我们提供了getActualTypeArguments方法，翻译过来叫做获取真正的泛型参数，这里的Type[]其实就是我们Field的真正的泛型类型数组，为什么是个数组？别忘了还有Map<K,V>这种。

我们这里既然是个Collection，那么肯定只有一个泛型，我们直接获取它的0号元素即可。

Type typeArgument = actualTypeArguments[0];

实际上我们这里拿到的Type就是一个真正的Class对象，我们直接强转为Class！接着就可以使用泛型的具体类型去创建对象了

Class typeArgument = (Class) actualTypeArguments[0];
Object o = typeArgument.getDeclaredConstructor().newInstance();

现在有个问题就是，我们不知道提供的集合是什么类型，比如List/Collection/Set，还是ArrayList/LinkedList等？这里貌似我们就没办法，只能做一层尽可能的枚举，毕竟用户还可以自定义Collection等！

       Collection collection;
        if (field.getType() == List.class || field.getType() == Collection.class) {
            collection = new ArrayList();
        } else if (field.getType() == Set.class) {
            collection = new HashSet();
        } else {
            collection = (Collection) field.getType().getDeclaredConstructor().newInstance();
        }

既然得到了Collection对象，也得到了泛型的User对象了，差的自然就是往Collection当中放元素了，这部分代码暂时忽略掉，您完全可以自己实现！

对于Map类型中的泛型，以及方法参数中的泛型，其实完全类似的，和上述原理类似，这里就不再进行赘述。

3.下面是一个我写的比较详细的注入案例

主要功能就是实现类似Spring当中的@Autowired/@Inject/@Resource去进行注入的情况

/**
 * @author wanna
 * @version v1.0
 */
public class InjectMetadataUtils {

    private final ConfigurableListableBeanFactory beanFactory;

    public InjectMetadataUtils(ConfigurableListableBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    // 处理字段注入的情况
    public Object handleFieldInject(Field field, boolean required) {
        Value value = AnnotatedElementUtils.getMergedAnnotation(field, Value.class);
        Qualifier qualifier = AnnotatedElementUtils.getMergedAnnotation(field, Qualifier.class);
        // 1.如果是一个@Value注解的话，那么，直接解析占位符就行了...
        if (!Objects.isNull(value)) {
            return handleValueInject(value.value());
        }
        // 2.如果不是一个@Value注解，那么就是一个@Inject注解或者@Autowired注解...只需要解析@Qualifier注解就行了
        Object[] injectBean = new Object[1];

        // --2.1如果这个参数的类型是Map/Collection/Array，那么，需要去进行处理
        if (ClassUtils.isAssignableFrom(Collection.class, field.getType())
                || ClassUtils.isAssignableFrom(Map.class, field.getType()) ||
                field.getType().isArray()) {
            injectBean[0] = handleMultiBeans(field.getType(), field.getGenericType());

            // --2.2如果有Qualifier注解的话，那么按name去进行注入...
        } else if (!Objects.isNull(qualifier)) {
            injectBean[0] = beanFactory.getBean(qualifier.value(), field.getType());
            // --2.3 如果没有Qualifier注解，那么type类型去进行注入
        } else {
            injectBean[0] = beanFactory.getBean(field.getType());
        }
        int checkedIndex = checkRequired(injectBean);
        // 如果没有找到合适的Bean，那么抛出异常...
        if (required && checkedIndex != -1) {
            throw new IllegalStateException("在处理字段" + field + "时遇到了没有容器中没有的Bean，字段类型为" + field.getType());
        }
        return injectBean[0];
    }

    // 处理方法去进行注入的情况，需要对每个参数都去进行注入...
    public Object handleMethodParametersInject(Method method, boolean required) {
        Type[] types = method.getGenericParameterTypes();
        Parameter[] parameters = method.getParameters();
        Class<?>[] parameterTypes = method.getParameterTypes();
        // 要进行注入的参数列表...
        Object[] params = new Object[parameters.length];
        // 获取方法上的@Qualifier注解...
        Qualifier methodQualifier = AnnotatedElementUtils.getMergedAnnotation(method, Qualifier.class);
        // 获取方法上的@Value注解...
        Value methodValue = AnnotatedElementUtils.getMergedAnnotation(method, Value.class);
        // 1.如果方法上有@Qualifier注解，那么优先去进行处理
        if (!Objects.isNull(methodQualifier)) {
            if (parameterTypes.length != 1) {
                throw new NoSupportException("@Qualifier注解不支持标注在参数数量不是1个的方法上");
            }
            // 如果@Qualifier注解标注在只有一个参数的方法上，那么...按照名字去解析
            params[0] = beanFactory.getBean(methodQualifier.name(), parameterTypes[0]);

            // 2.如果方法上有@Value注解，那么也优先去进行处理
        } else if (!Objects.isNull(methodValue)) {
            if (parameterTypes.length != 1) {
                throw new NoSupportException("@Value注解不支持标注在参数数量不是1个的方法上");
            }
            // 如果@Value注解标注在只有一个参数的方法上，那么...直接进行解析占位符
            params[0] = handleValueInject(methodValue.value());
            // 3.如果方法上没标注@Value/@Qualifier注解，那么...遍历所有的参数去进行注入
        } else {
            for (int i = 0; i < parameterTypes.length; i++) {
                handleMethodParameter(params, i, parameterTypes, parameters, types);
            }
        }
        // 如果required=true，就得去检查是否每个属性都存在，如果其中一个不存在(返回值不为-1)，那么都会抛出异常...
        int checkedIndex = checkRequired(params);
        if (required && checkedIndex != -1) {
            throw new IllegalStateException("在处理方法" + method + "时遇到了没有容器中没有的Bean，参数类型为" + parameters[checkedIndex]);
        }
        return params;
    }

    private void handleMethodParameter(Object[] params, int i, Class<?>[] parameterTypes, Parameter[] parameters, Type[] types) {
        // 获取参数类型、泛型类型以及Parameter...
        Class<?> parameterType = parameterTypes[i];
        Type type = types[i];
        Parameter parameter = parameters[i];

        // 获取参数上的@Value注解信息
        Value value = AnnotatedElementUtils.getMergedAnnotation(parameter, Value.class);

        // 如果这个参数的类型是Map/Collection/Array，那么，需要去进行处理
        if (ClassUtils.isAssignableFrom(Collection.class, parameterType)
                || ClassUtils.isAssignableFrom(Map.class, parameterType) ||
                parameterType.isArray()) {
            params[i] = handleMultiBeans(parameterType, type);

            // 如果这个参数类型不是Map/Collection/Array类型的话，那么直接解析placeholder/getBean即可
            // 处理方法参数上是@Value注解的话，那么...
        } else if (!Objects.isNull(value)) {
            params[i] = handleValueInject(value.value());
        } else {
            // 如果方法上具体某个参数上标注了Qualifier注解的话...那么需要按照名字去进行注入
            Qualifier qualifier = AnnotatedElementUtils.getMergedAnnotation(parameter, Qualifier.class);
            // 判断是根据name去注入还是根据type去进行注入
            if (Objects.isNull(qualifier)) {
                params[i] = beanFactory.getBean(parameterType);
            } else {
                params[i] = beanFactory.getBean(qualifier.name(), parameterType);
            }
        }
    }

    // 处理要注入多个Bean的情况，支持Array/Collection/Map三种方式，其它的不支持
    public Object handleMultiBeans(Class<?> type, Type genericType) {
        // 如果类型是个数组，那么从容器当中注入全部该类型的元素列表
        if (type.isArray()) {
            return handleArrayBean(type, genericType);
            // 如果类型是个集合类型的话，也是从容器中注入全部该类型的元素列表
        } else if (ClassUtils.isAssignableFrom(Collection.class, type)) {
            return handleCollectionBean(type, genericType);
            //如果类型是个Map类型，key是它的beanName，value是Bean
        } else if (ClassUtils.isAssignableFrom(Map.class, type)) {
            return handleMapBean(type, genericType);
        }
        return null;
    }

    // 处理要注入一个Array的情况，注入某种类型的全部Bean的数组
    private Object handleArrayBean(Class<?> type, Type genericType) {
        Class<?> componentType = type.getComponentType();  // 这个api是获取数组的元素类型
        List<?> beansForType = beanFactory.getBeansForType(componentType);
        // 使用Array类去创建一个目标类型的数组对象
        Object targetArray = Array.newInstance(componentType, beansForType.size());
        for (int i = 0; i < beansForType.size(); i++) {
            Array.set(targetArray, i, beansForType.get(i));
        }
        return targetArray;
    }

    // 处理要注入一个Collection的情况...注入某种类型的全部Bean的Collection
    @SuppressWarnings({"unchecked", "rawtypes"})
    private Object handleCollectionBean(Class<?> type, Type genericType) {
        Collection collection;
        if (type == Collection.class || type == List.class) {
            collection = new ArrayList();
        } else if (type == Set.class) {
            collection = new HashSet();
        } else {
            collection = (Collection) ClassUtils.newInstance(type);
        }
        AssertUtils.notNull(collection, "进行注入的Collection必须提供无参数构造器");
        // 如果提供了泛型参数，那么...按照泛型参数去进行注入
        if (genericType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments();
            Class targetType = (Class) actualTypeArguments[0];
            List<?> beanNamesForType = beanFactory.getBeansForType(targetType);
            collection.addAll(beanNamesForType);

            // 如果没有泛型参数，那么暂时不支持
        } else {

        }
        return collection;
    }

    // 处理需要注入一个Map的情况，Key是beanName，value是beanName对应的Bean
    @SuppressWarnings({"unchecked", "rawtypes"})
    private Object handleMapBean(Class<?> type, Type genericType) {
        Map map;
        if (type == Map.class) {
            map = new HashMap();
        } else {
            map = (Map) ClassUtils.newInstance(type);
        }
        AssertUtils.notNull(map, "Map必须提供无参数构造器");
        if (genericType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments();
            Class keyType = (Class) actualTypeArguments[0];
            AssertUtils.assertTrue(ClassUtils.isAssignableFrom(CharSequence.class, keyType),
                    "要进行注入Map的Key必须是字符串(CharSequence)类型的");
            Class valueType = (Class) actualTypeArguments[1];
            // 拿到容器中所有该类型的Bean，加入到map当中去...
            for (String name : beanFactory.getBeanNamesForType(valueType)) {
                Object injectBean = beanFactory.getBean(name);
                map.put(name, injectBean);
            }

            // 如果Map没有泛型参数，那么...暂时不支持...
        } else {

        }
        return map;
    }

    // 对候选的参数去进行非空的检查，如果有一个为空，那么就会return 非空的参数所在的索引，如果全部都非空，那么return -1
    private int checkRequired(Object[] params) {
        for (int i = 0; i < params.length; i++) {
            // 如果是字符串的话，并且为空串的话...那么
            if (params[i] instanceof CharSequence && StringUtils.isNullOrEmpty(params[i].toString())) {
                return i;
            }
            if (Objects.isNull(params[i])) {
                return i;
            }
        }
        return -1;
    }

    // 处理@Value去进行注入的情况
    private Object handleValueInject(String valueValue) {
        AssertUtils.assertTrue(!StringUtils.isNullOrEmpty(valueValue), "@Value注解不能不配置value属性");
        // 如果必要的话，那么使用嵌入式的值解析器去解析占位符
        return beanFactory.hasEmbeddedValueResolver() ? beanFactory.resolveEmbeddedValue(valueValue) : valueValue;
    }
}