90 lines
3.5 KiB
Markdown
90 lines
3.5 KiB
Markdown
## 获取类实例
|
|
|
|
```java
|
|
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
|
|
return getSpringFactoriesInstances(type, new Class<?>[] {});
|
|
}
|
|
|
|
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
|
|
Class<?>[] parameterTypes, Object... args) {
|
|
ClassLoader classLoader = getClassLoader();
|
|
// Use names and ensure unique to protect against duplicates
|
|
Set<String> names = new LinkedHashSet<>(
|
|
SpringFactoriesLoader.loadFactoryNames(type, classLoader));
|
|
List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
|
|
classLoader, args, names);
|
|
AnnotationAwareOrderComparator.sort(instances);
|
|
return instances;
|
|
}
|
|
```
|
|
|
|
## spring工厂中加载类名
|
|
|
|
```java
|
|
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
|
|
String factoryTypeName = factoryType.getName();
|
|
return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
|
|
}
|
|
```
|
|
|
|
```java
|
|
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
|
|
MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
|
|
if (result != null) {
|
|
return result;
|
|
} else {
|
|
try {
|
|
Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
|
|
MultiValueMap<String, String> result = new LinkedMultiValueMap();
|
|
|
|
while(urls.hasMoreElements()) {
|
|
URL url = (URL)urls.nextElement();
|
|
UrlResource resource = new UrlResource(url);
|
|
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
|
|
Iterator var6 = properties.entrySet().iterator();
|
|
|
|
while(var6.hasNext()) {
|
|
Map.Entry<?, ?> entry = (Map.Entry)var6.next();
|
|
String factoryTypeName = ((String)entry.getKey()).trim();
|
|
String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
|
|
int var10 = var9.length;
|
|
|
|
for(int var11 = 0; var11 < var10; ++var11) {
|
|
String factoryImplementationName = var9[var11];
|
|
result.add(factoryTypeName, factoryImplementationName.trim());
|
|
}
|
|
}
|
|
}
|
|
|
|
cache.put(classLoader, result);
|
|
return result;
|
|
} catch (IOException var13) {
|
|
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
|
|
```java
|
|
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
|
|
ClassLoader classLoader, Object[] args, Set<String> names) {
|
|
List<T> instances = new ArrayList<>(names.size());
|
|
for (String name : names) {
|
|
try {
|
|
Class<?> instanceClass = ClassUtils.forName(name, classLoader);
|
|
Assert.isAssignable(type, instanceClass);
|
|
Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
|
|
T instance = (T) BeanUtils.instantiateClass(constructor, args);
|
|
instances.add(instance);
|
|
}
|
|
catch (Throwable ex) {
|
|
throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
|
|
}
|
|
}
|
|
return instances;
|
|
}
|
|
```
|
|
|