开发类Spring依赖注入框架时如何动态对List重新索引排序

你第一个Stream实现的问题在于遍历对象是服务列表，所以输出顺序和服务列表的顺序一致，不会按构造参数的顺序调整。要实现按构造参数类型排序的效果，必须以parameterTypes的遍历顺序为准，逐个匹配服务。你第二个嵌套循环的思路是正确的，只需要修复异常校验的逻辑即可正常使用。

优化后的嵌套循环实现 #

public List<Object> getObjectsFromConstructorParameterTypes(Class<?>[] parameterTypes, List<Object> objects) throws NoSuchElementException {
    List<Object> results = new ArrayList<>(parameterTypes.length);
    for (Class<?> parameterType : parameterTypes) {
        Object matchedService = null;
        for (Object object : objects) {
            if (parameterType.isAssignableFrom(object.getClass())) {
                matchedService = object;
                break;
            }
        }
        if (matchedService == null) {
            throw new NoSuchElementException(parameterType.getName() + " 类型的服务未找到，无法完成构造参数注入");
        }
        results.add(matchedService);
    }
    return results;
}

Stream实现版本 #

如果你偏好Stream的写法，可以用以下实现，逻辑和嵌套循环完全一致：

public List<Object> getObjectsFromConstructorParameterTypes(Class<?>[] parameterTypes, List<Object> objects) {
    return Arrays.stream(parameterTypes)
            .map(paramType -> objects.stream()
                    .filter(obj -> paramType.isAssignableFrom(obj.getClass()))
                    .findFirst()
                    .orElseThrow(() -> new NoSuchElementException(paramType.getName() + " 类型的服务未找到，无法完成构造参数注入"))
            )
            .collect(Collectors.toList());
}

性能优化方案（推荐） #

如果你的服务列表量级较大，建议在容器初始化阶段提前构建服务类型的映射缓存，将匹配的时间复杂度从O(m*n)降到O(m)（m为构造参数数量，n为服务总数）：

// 容器初始化阶段提前构建类型-服务映射缓存
Map<Class<?>, Object> serviceTypeMap = new HashMap<>();
for (Object service : allServices) {
    Class<?> clazz = service.getClass();
    // 遍历当前类的所有父类和实现接口，支持多态场景的匹配
    while (clazz != null) {
        serviceTypeMap.putIfAbsent(clazz, service);
        for (Class<?> inter : clazz.getInterfaces()) {
            serviceTypeMap.putIfAbsent(inter, service);
        }
        clazz = clazz.getSuperclass();
    }
}

// 匹配构造参数时直接从缓存取
public List<Object> getObjectsFromConstructorParameterTypes(Class<?>[] parameterTypes, Map<Class<?>, Object> serviceTypeMap) {
    return Arrays.stream(parameterTypes)
            .map(paramType -> {
                Object service = serviceTypeMap.get(paramType);
                if (service == null) {
                    throw new NoSuchElementException(paramType.getName() + " 类型的服务未找到");
                }
                return service;
            })
            .collect(Collectors.toList());
}

• 首先纠正认知误区：Collectors.toList() 一定会初始化新的ArrayList对象，不存在不创建新对象的情况
• 两者优劣势对比：
  • 构造参数数量少的场景下，嵌套循环的性能略优，但差距在微秒级，完全可以忽略
  • Stream的写法更简洁，属于声明式编程，逻辑分层清晰，不需要手动维护中间集合，不容易出现低级逻辑错误
  • 实际开发中选择哪种实现完全看编码规范和个人偏好，在DI框架的场景下性能差异几乎感知不到

内容的提问来源于stack exchange，提问作者Jason Rich Darmawan