1: private static final String SERVICES_DIRECTORY = "META-INF/services/";
  2: 
  3: private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
  4: 
  5: private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
  6: 
  7: private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
  8: 
  9: // ============================== 静态属性 ==============================
 10: 
 11: /**
 12:  * 拓展加载器集合
 13:  *
 14:  * key：拓展接口
 15:  */
 16: private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
 17: /**
 18:  * 拓展实现类集合
 19:  *
 20:  * key：拓展实现类
 21:  * value：拓展对象。
 22:  *
 23:  * 例如，key 为 Class<AccessLogFilter>
 24:  *  value 为 AccessLogFilter 对象
 25:  */
 26: private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
 27: 
 28: // ============================== 对象属性 ==============================
 29: 
 30: /**
 31:  * 拓展接口。
 32:  * 例如，Protocol
 33:  */
 34: private final Class<?> type;
 35: /**
 36:  * 对象工厂
 37:  *
 38:  * 用于调用 {@link #injectExtension(Object)} 方法，向拓展对象注入依赖属性。
 39:  *
 40:  * 例如，StubProxyFactoryWrapper 中有 `Protocol protocol` 属性。
 41:  */
 42: private final ExtensionFactory objectFactory;
 43: /**
 44:  * 缓存的拓展名与拓展类的映射。
 45:  *
 46:  * 和 {@link #cachedClasses} 的 KV 对调。
 47:  *
 48:  * 通过 {@link #loadExtensionClasses} 加载
 49:  */
 50: private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
 51: /**
 52:  * 缓存的拓展实现类集合。
 53:  *
 54:  * 不包含如下两种类型：
 55:  *  1. 自适应拓展实现类。例如 AdaptiveExtensionFactory
 56:  *  2. 带唯一参数为拓展接口的构造方法的实现类，或者说拓展 Wrapper 实现类。例如，ProtocolFilterWrapper 。
 57:  *   拓展 Wrapper 实现类，会添加到 {@link #cachedWrapperClasses} 中
 58:  *
 59:  * 通过 {@link #loadExtensionClasses} 加载
 60:  */
 61: private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
 62: 
 63: /**
 64:  * 拓展名与 @Activate 的映射
 65:  *
 66:  * 例如，AccessLogFilter。
 67:  *
 68:  * 用于 {@link #getActivateExtension(URL, String)}
 69:  */
 70: private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
 71: /**
 72:  * 缓存的拓展对象集合
 73:  *
 74:  * key：拓展名
 75:  * value：拓展对象
 76:  *
 77:  * 例如，Protocol 拓展
 78:  *      key：dubbo value：DubboProtocol
 79:  *      key：injvm value：InjvmProtocol
 80:  *
 81:  * 通过 {@link #loadExtensionClasses} 加载
 82:  */
 83: private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
 84: /**
 85:  * 缓存的自适应( Adaptive )拓展对象
 86:  */
 87: private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
 88: /**
 89:  * 缓存的自适应拓展对象的类
 90:  *
 91:  * {@link #getAdaptiveExtensionClass()}
 92:  */
 93: private volatile Class<?> cachedAdaptiveClass = null;
 94: /**
 95:  * 缓存的默认拓展名
 96:  *
 97:  * 通过 {@link SPI} 注解获得
 98:  */
 99: private String cachedDefaultName;
100: /**
101:  * 创建 {@link #cachedAdaptiveInstance} 时发生的异常。
102:  *
103:  * 发生异常后，不再创建，参见 {@link #createAdaptiveExtension()}
104:  */
105: private volatile Throwable createAdaptiveInstanceError;
106: 
107: /**
108:  * 拓展 Wrapper 实现类集合
109:  *
110:  * 带唯一参数为拓展接口的构造方法的实现类
111:  *
112:  * 通过 {@link #loadExtensionClasses} 加载
113:  */
114: private Set<Class<?>> cachedWrapperClasses;
115: 
116: /**
117:  * 拓展名 与 加载对应拓展类发生的异常 的 映射
118:  *
119:  * key：拓展名
120:  * value：异常
121:  *
122:  * 在 {@link #loadFile(Map, String)} 时，记录
123:  */
124: private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();

private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();

private volatile Class<?> cachedAdaptiveClass = null;

private Set<Class<?>> cachedWrapperClasses;

  1: /**
  2:  * 获得拓展实现类数组
  3:  *
  4:  * @return 拓展实现类数组
  5:  */
  6: private Map<String, Class<?>> getExtensionClasses() {
  7:     // 从缓存中，获得拓展实现类数组
  8:     Map<String, Class<?>> classes = cachedClasses.get();
  9:     if (classes == null) {
 10:         synchronized (cachedClasses) {
 11:             classes = cachedClasses.get();
 12:             if (classes == null) {
 13:                 // 从配置文件中，加载拓展实现类数组
 14:                 classes = loadExtensionClasses();
 15:                 // 设置到缓存中
 16:                 cachedClasses.set(classes);
 17:             }
 18:         }
 19:     }
 20:     return classes;
 21: }

 1: /**
 2:  * 加载拓展实现类数组
 3:  *
 4:  * 无需声明 synchronized ，因为唯一调用该方法的 {@link #getExtensionClasses()} 已经声明。
 5:  * // synchronized in getExtensionClasses
 6:  *
 7:  * @return 拓展实现类数组
 8:  */
 9: private Map<String, Class<?>> loadExtensionClasses() {
10:     // 通过 @SPI 注解，获得默认的拓展实现类名
11:     final SPI defaultAnnotation = type.getAnnotation(SPI.class);
12:     if (defaultAnnotation != null) {
13:         String value = defaultAnnotation.value();
14:         if ((value = value.trim()).length() > 0) {
15:             String[] names = NAME_SEPARATOR.split(value);
16:             if (names.length > 1) {
17:                 throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
18:                         + ": " + Arrays.toString(names));
19:             }
20:             if (names.length == 1) cachedDefaultName = names[0];
21:         }
22:     }
23: 
24:     // 从配置文件中，加载拓展实现类数组
25:     Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
26:     loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
27:     loadFile(extensionClasses, DUBBO_DIRECTORY);
28:     loadFile(extensionClasses, SERVICES_DIRECTORY);
29:     return extensionClasses;
30: }

/**
 * 缓存的自适应拓展对象的类
 *
 * {@link #getAdaptiveExtensionClass()}
 */
private volatile Class<?> cachedAdaptiveClass = null;

/**
 * 拓展 Wrapper 实现类集合
 *
 * 带唯一参数为拓展接口的构造方法的实现类
 *
 * 通过 {@link #loadExtensionClasses} 加载
 */
private Set<Class<?>> cachedWrapperClasses;

/**
 * 拓展名与 @Activate 的映射
 *
 * 例如，AccessLogFilter。
 *
 * 用于 {@link #getActivateExtension(URL, String)}
 */
private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();

/**
 * 缓存的拓展名与拓展类的映射。
 *
 * 和 {@link #cachedClasses} 的 KV 对调。
 *
 * 通过 {@link #loadExtensionClasses} 加载
 */
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();

/**
 * 拓展名 与 加载对应拓展类发生的异常 的 映射
 *
 * key：拓展名
 * value：异常
 *
 * 在 {@link #loadFile(Map, String)} 时，记录
 */
private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();

  1: /**
  2:  * 从一个配置文件中，加载拓展实现类数组。
  3:  *
  4:  * @param extensionClasses 拓展类名数组
  5:  * @param dir 文件名
  6:  */
  7: private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
  8:     // 完整的文件名
  9:     String fileName = dir + type.getName();
 10:     try {
 11:         Enumeration<java.net.URL> urls;
 12:         // 获得文件名对应的所有文件数组
 13:         ClassLoader classLoader = findClassLoader();
 14:         if (classLoader != null) {
 15:             urls = classLoader.getResources(fileName);
 16:         } else {
 17:             urls = ClassLoader.getSystemResources(fileName);
 18:         }
 19:         // 遍历文件数组
 20:         if (urls != null) {
 21:             while (urls.hasMoreElements()) {
 22:                 java.net.URL url = urls.nextElement();
 23:                 try {
 24:                     BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
 25:                     try {
 26:                         String line;
 27:                         while ((line = reader.readLine()) != null) {
 28:                             // 跳过当前被注释掉的情况，例如 #spring=xxxxxxxxx
 29:                             final int ci = line.indexOf('#');
 30:                             if (ci >= 0) line = line.substring(0, ci);
 31:                             line = line.trim();
 32:                             if (line.length() > 0) {
 33:                                 try {
 34:                                     // 拆分，key=value 的配置格式
 35:                                     String name = null;
 36:                                     int i = line.indexOf('=');
 37:                                     if (i > 0) {
 38:                                         name = line.substring(0, i).trim();
 39:                                         line = line.substring(i + 1).trim();
 40:                                     }
 41:                                     if (line.length() > 0) {
 42:                                         // 判断拓展实现，是否实现拓展接口
 43:                                         Class<?> clazz = Class.forName(line, true, classLoader);
 44:                                         if (!type.isAssignableFrom(clazz)) {
 45:                                             throw new IllegalStateException("Error when load extension class(interface: " +
 46:                                                     type + ", class line: " + clazz.getName() + "), class "
 47:                                                     + clazz.getName() + "is not subtype of interface.");
 48:                                         }
 49:                                         // 缓存自适应拓展对象的类到 `cachedAdaptiveClass`
 50:                                         if (clazz.isAnnotationPresent(Adaptive.class)) {
 51:                                             if (cachedAdaptiveClass == null) {
 52:                                                 cachedAdaptiveClass = clazz;
 53:                                             } else if (!cachedAdaptiveClass.equals(clazz)) {
 54:                                                 throw new IllegalStateException("More than 1 adaptive class found: "
 55:                                                         + cachedAdaptiveClass.getClass().getName()
 56:                                                         + ", " + clazz.getClass().getName());
 57:                                             }
 58:                                         } else {
 59:                                             // 缓存拓展 Wrapper 实现类到 `cachedWrapperClasses`
 60:                                             try {
 61:                                                 clazz.getConstructor(type);
 62:                                                 Set<Class<?>> wrappers = cachedWrapperClasses;
 63:                                                 if (wrappers == null) {
 64:                                                     cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
 65:                                                     wrappers = cachedWrapperClasses;
 66:                                                 }
 67:                                                 wrappers.add(clazz);
 68:                                             // 缓存拓展实现类到 `extensionClasses`
 69:                                             } catch (NoSuchMethodException e) {
 70:                                                 clazz.getConstructor();
 71:                                                 // 未配置拓展名，自动生成。例如，DemoFilter 为 demo 。主要用于兼容 Java SPI 的配置。
 72:                                                 if (name == null || name.length() == 0) {
 73:                                                     name = findAnnotationName(clazz);
 74:                                                     if (name == null || name.length() == 0) {
 75:                                                         if (clazz.getSimpleName().length() > type.getSimpleName().length()
 76:                                                                 && clazz.getSimpleName().endsWith(type.getSimpleName())) {
 77:                                                             name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
 78:                                                         } else {
 79:                                                             throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
 80:                                                         }
 81:                                                     }
 82:                                                 }
 83:                                                 // 获得拓展名，可以是数组，有多个拓展名。
 84:                                                 String[] names = NAME_SEPARATOR.split(name);
 85:                                                 if (names != null && names.length > 0) {
 86:                                                     // 缓存 @Activate 到 `cachedActivates` 。
 87:                                                     Activate activate = clazz.getAnnotation(Activate.class);
 88:                                                     if (activate != null) {
 89:                                                         cachedActivates.put(names[0], activate);
 90:                                                     }
 91:                                                     for (String n : names) {
 92:                                                         // 缓存到 `cachedNames`
 93:                                                         if (!cachedNames.containsKey(clazz)) {
 94:                                                             cachedNames.put(clazz, n);
 95:                                                         }
 96:                                                         // 缓存拓展实现类到 `extensionClasses`
 97:                                                         Class<?> c = extensionClasses.get(n);
 98:                                                         if (c == null) {
 99:                                                             extensionClasses.put(n, clazz);
100:                                                         } else if (c != clazz) {
101:                                                             throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
102:                                                         }
103:                                                     }
104:                                                 }
105:                                             }
106:                                         }
107:                                     }
108:                                 } catch (Throwable t) {
109:                                     // 发生异常，记录到异常集合
110:                                     IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
111:                                     exceptions.put(line, e);
112:                                 }
113:                             }
114:                         } // end of while read lines
115:                     } finally {
116:                         reader.close();
117:                     }
118:                 } catch (Throwable t) {
119:                     logger.error("Exception when load extension class(interface: " +
120:                             type + ", class file: " + url + ") in " + url, t);
121:                 }
122:             } // end of while urls
123:         }
124:     } catch (Throwable t) {
125:         logger.error("Exception when load extension class(interface: " +
126:                 type + ", description file: " + fileName + ").", t);
127:     }
128: }

ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(name)

/**
 * 拓展加载器集合
 *
 * key：拓展接口
 */
 // 【静态属性】
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>(); 

  1: /**
  2:  * 根据拓展点的接口，获得拓展加载器
  3:  *
  4:  * @param type 接口
  5:  * @param <T> 泛型
  6:  * @return 加载器
  7:  */
  8: @SuppressWarnings("unchecked")
  9: public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
 10:     if (type == null)
 11:         throw new IllegalArgumentException("Extension type == null");
 12:     // 必须是接口
 13:     if (!type.isInterface()) {
 14:         throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
 15:     }
 16:     // 必须包含 @SPI 注解
 17:     if (!withExtensionAnnotation(type)) {
 18:         throw new IllegalArgumentException("Extension type(" + type +
 19:                 ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
 20:     }
 21: 
 22:     // 获得接口对应的拓展点加载器
 23:     ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
 24:     if (loader == null) {
 25:         EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
 26:         loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
 27:     }
 28: }

/**
 * 拓展接口。
 * 例如，Protocol
 */
private final Class<?> type;
/**
 * 对象工厂
 *
 * 用于调用 {@link #injectExtension(Object)} 方法，向拓展对象注入依赖属性。
 *
 * 例如，StubProxyFactoryWrapper 中有 `Protocol protocol` 属性。
 */
private final ExtensionFactory objectFactory;

  1: private ExtensionLoader(Class<?> type) {
  2:     this.type = type;
  3:     objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
  4: }

ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(name)

/**
 * 缓存的拓展对象集合
 *
 * key：拓展名
 * value：拓展对象
 *
 * 例如，Protocol 拓展
 *          key：dubbo value：DubboProtocol
 *          key：injvm value：InjvmProtocol
 *
 * 通过 {@link #loadExtensionClasses} 加载
 */
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();

  1: /**
  2:  * Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
  3:  * will be thrown.
  4:  */
  5: /**
  6:  * 返回指定名字的扩展对象。如果指定名字的扩展不存在，则抛异常 {@link IllegalStateException}.
  7:  *
  8:  * @param name 拓展名
  9:  * @return 拓展对象
 10:  */
 11: @SuppressWarnings("unchecked")
 12: public T getExtension(String name) {
 13:     if (name == null || name.length() == 0)
 14:         throw new IllegalArgumentException("Extension name == null");
 15:     // 查找 默认的 拓展对象
 16:     if ("true".equals(name)) {
 17:         return getDefaultExtension();
 18:     }
 19:     // 从 缓存中 获得对应的拓展对象
 20:     Holder<Object> holder = cachedInstances.get(name);
 21:     if (holder == null) {
 22:         cachedInstances.putIfAbsent(name, new Holder<Object>());
 23:         holder = cachedInstances.get(name);
 24:     }
 25:     Object instance = holder.get();
 26:     if (instance == null) {
 27:         synchronized (holder) {
 28:             instance = holder.get();
 29:             // 从 缓存中 未获取到，进行创建缓存对象。
 30:             if (instance == null) {
 31:                 instance = createExtension(name);
 32:                 // 设置创建对象到缓存中
 33:                 holder.set(instance);
 34:             }
 35:         }
 36:     }
 37:     return (T) instance;
 38: }

/**
 * 拓展实现类集合
 *
 * key：拓展实现类
 * value：拓展对象。
 *
 * 例如，key 为 Class<AccessLogFilter>
 *      value 为 AccessLogFilter 对象
 */
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
    
  1: /**
  2:  * 创建拓展名的拓展对象，并缓存。
  3:  *
  4:  * @param name 拓展名
  5:  * @return 拓展对象
  6:  */
  7: @SuppressWarnings("unchecked")
  8: private T createExtension(String name) {
  9:     // 获得拓展名对应的拓展实现类
 10:     Class<?> clazz = getExtensionClasses().get(name);
 11:     if (clazz == null) {
 12:         throw findException(name); // 抛出异常
 13:     }
 14:     try {
 15:         // 从缓存中，获得拓展对象。
 16:         T instance = (T) EXTENSION_INSTANCES.get(clazz);
 17:         if (instance == null) {
 18:             // 当缓存不存在时，创建拓展对象，并添加到缓存中。
 19:             EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
 20:             instance = (T) EXTENSION_INSTANCES.get(clazz);
 21:         }
 22:         // 注入依赖的属性
 23:         injectExtension(instance);
 24:         // 创建 Wrapper 拓展对象
 25:         Set<Class<?>> wrapperClasses = cachedWrapperClasses;
 26:         if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
 27:             for (Class<?> wrapperClass : wrapperClasses) {
 28:                 instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
 29:             }
 30:         }
 31:         return instance;
 32:     } catch (Throwable t) {
 33:         throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
 34:                 type + ")  could not be instantiated: " + t.getMessage(), t);
 35:     }
 36: }

 1: /**
 2:  * 注入依赖的属性
 3:  *
 4:  * @param instance 拓展对象
 5:  * @return 拓展对象
 6:  */
 7: private T injectExtension(T instance) {
 8:     try {
 9:         if (objectFactory != null) {
10:             for (Method method : instance.getClass().getMethods()) {
11:                 if (method.getName().startsWith("set")
12:                         && method.getParameterTypes().length == 1
13:                         && Modifier.isPublic(method.getModifiers())) { // setting && public 方法
14:                     // 获得属性的类型
15:                     Class<?> pt = method.getParameterTypes()[0];
16:                     try {
17:                         // 获得属性
18:                         String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
19:                         // 获得属性值
20:                         Object object = objectFactory.getExtension(pt, property);
21:                         // 设置属性值
22:                         if (object != null) {
23:                             method.invoke(instance, object);
24:                         }
25:                     } catch (Exception e) {
26:                         logger.error("fail to inject via method " + method.getName()
27:                                 + " of interface " + type.getName() + ": " + e.getMessage(), e);
28:                     }
29:                 }
30:             }
31:         }
32:     } catch (Exception e) {
33:         logger.error(e.getMessage(), e);
34:     }
35:     return instance;
36: }

ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension()

/**
 * 缓存的自适应( Adaptive )拓展对象
 */
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();

/**
 * 创建 {@link #cachedAdaptiveInstance} 时发生的异常。
 *
 * 发生异常后，不再创建，参见 {@link #createAdaptiveExtension()}
 */
private volatile Throwable createAdaptiveInstanceError;

  1: /**
  2:  * 获得自适应拓展对象
  3:  *
  4:  * @return 拓展对象
  5:  */
  6: @SuppressWarnings("unchecked")
  7: public T getAdaptiveExtension() {
  8:     // 从缓存中，获得自适应拓展对象
  9:     Object instance = cachedAdaptiveInstance.get();
 10:     if (instance == null) {
 11:         // 若之前未创建报错，
 12:         if (createAdaptiveInstanceError == null) {
 13:             synchronized (cachedAdaptiveInstance) {
 14:                 instance = cachedAdaptiveInstance.get();
 15:                 if (instance == null) {
 16:                     try {
 17:                         // 创建自适应拓展对象
 18:                         instance = createAdaptiveExtension();
 19:                         // 设置到缓存
 20:                         cachedAdaptiveInstance.set(instance);
 21:                     } catch (Throwable t) {
 22:                         // 记录异常
 23:                         createAdaptiveInstanceError = t;
 24:                         throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
 25:                     }
 26:                 }
 27:             }
 28:         // 若之前创建报错，则抛出异常 IllegalStateException
 29:         } else {
 30:             throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
 31:         }
 32:     }
 33:     return (T) instance;
 34: }

/**
 * 创建自适应拓展对象
 *
 * @return 拓展对象
 */
@SuppressWarnings("unchecked")
private T createAdaptiveExtension() {
    try {
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
    }
}

 1: /**
 2:  * @return 自适应拓展类
 3:  */
 4: private Class<?> getAdaptiveExtensionClass() {
 5:     getExtensionClasses();
 6:     if (cachedAdaptiveClass != null) {
 7:         return cachedAdaptiveClass;
 8:     }
 9:     return cachedAdaptiveClass = createAdaptiveExtensionClass();
10: }

 1: /**
 2:  * 自动生成自适应拓展的代码实现，并编译后返回该类。
 3:  *
 4:  * @return 类
 5:  */
 6: private Class<?> createAdaptiveExtensionClass() {
 7:     // 自动生成自适应拓展的代码实现的字符串
 8:     String code = createAdaptiveExtensionClassCode();
 9:     // 编译代码，并返回该类
10:     ClassLoader classLoader = findClassLoader();
11:     com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
12:     return compiler.compile(code, classLoader);
13: }

List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);

 1: /**
 2:  * This is equivalent to {@code getActivateExtension(url, url.getParameter(key).split(","), null)}
 3:  *
 4:  * 获得符合自动激活条件的拓展对象数组
 5:  *
 6:  * @param url   url
 7:  * @param key   url parameter key which used to get extension point names
 8:  *              Dubbo URL 参数名
 9:  * @param group group
10:  *              过滤分组名
11:  * @return extension list which are activated.
12:  * @see #getActivateExtension(com.alibaba.dubbo.common.URL, String[], String)
13:  */
14: public List<T> getActivateExtension(URL url, String key, String group) {
15:     // 从 Dubbo URL 获得参数值
16:     String value = url.getParameter(key);
17:     // 获得符合自动激活条件的拓展对象数组
18:     return getActivateExtension(url, value == null || value.length() == 0 ? null : Constants.COMMA_SPLIT_PATTERN.split(value), group);
19: }
20: 
21: /**
22:  * Get activate extensions.
23:  *
24:  * 获得符合自动激活条件的拓展对象数组
25:  *
26:  * @param url    url
27:  * @param values extension point names
28:  * @param group  group
29:  * @return extension list which are activated
30:  * @see com.alibaba.dubbo.common.extension.Activate
31:  */
32: public List<T> getActivateExtension(URL url, String[] values, String group) {
33:     List<T> exts = new ArrayList<T>();
34:     List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
35:     // 处理自动激活的拓展对象们
36:     // 判断不存在配置 `"-name"` 。例如，<dubbo:service filter="-default" /> ，代表移除所有默认过滤器。
37:     if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
38:         // 获得拓展实现类数组
39:         getExtensionClasses();
40:         // 循环
41:         for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
42:             String name = entry.getKey();
43:             Activate activate = entry.getValue();
44:             if (isMatchGroup(group, activate.group())) { // 匹配分组
45:                 // 获得拓展对象
46:                 T ext = getExtension(name);
47:                 if (!names.contains(name) // 不包含在自定义配置里。如果包含，会在下面的代码处理。
48:                         && !names.contains(Constants.REMOVE_VALUE_PREFIX + name) // 判断是否配置移除。例如 <dubbo:service filter="-monitor" />，则 MonitorFilter 会被移除
49:                         && isActive(activate, url)) { // 判断是否激活
50:                     exts.add(ext);
51:                 }
52:             }
53:         }
54:         // 排序
55:         Collections.sort(exts, ActivateComparator.COMPARATOR);
56:     }
57:     // 处理自定义配置的拓展对象们。例如在 <dubbo:service filter="demo" /> ，代表需要加入 DemoFilter （这个是笔者自定义的）。
58:     List<T> usrs = new ArrayList<T>();
59:     for (int i = 0; i < names.size(); i++) {
60:         String name = names.get(i);
61:         if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX) && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) { // 判断非移除的
62:             // 将配置的自定义在自动激活的拓展对象们前面。例如，<dubbo:service filter="demo,default,demo2" /> ，则 DemoFilter 就会放在默认的过滤器前面。
63:             if (Constants.DEFAULT_KEY.equals(name)) {
64:                 if (!usrs.isEmpty()) {
65:                     exts.addAll(0, usrs);
66:                     usrs.clear();
67:                 }
68:             } else {
69:                 // 获得拓展对象
70:                 T ext = getExtension(name);
71:                 usrs.add(ext);
72:             }
73:         }
74:     }
75:     // 添加到结果集
76:     if (!usrs.isEmpty()) {
77:         exts.addAll(usrs);
78:     }
79:     return exts;
80: }

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface SPI {

    /**
     * default extension name
     */
    String value() default "";

}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {

    /**
     * Decide which target extension to be injected. The name of the target extension is decided by the parameter passed
     * in the URL, and the parameter names are given by this method.
     * <p>
     * If the specified parameters are not found from {@link URL}, then the default extension will be used for
     * dependency injection (specified in its interface's {@link SPI}).
     * <p>
     * For examples, given <code>String[] {"key1", "key2"}</code>:
     * <ol>
     * <li>find parameter 'key1' in URL, use its value as the extension's name</li>
     * <li>try 'key2' for extension's name if 'key1' is not found (or its value is empty) in URL</li>
     * <li>use default extension if 'key2' doesn't appear either</li>
     * <li>otherwise, throw {@link IllegalStateException}</li>
     * </ol>
     * If default extension's name is not give on interface's {@link SPI}, then a name is generated from interface's
     * class name with the rule: divide classname from capital char into several parts, and separate the parts with
     * dot '.', for example: for {@code com.alibaba.dubbo.xxx.YyyInvokerWrapper}, its default name is
     * <code>String[] {"yyy.invoker.wrapper"}</code>. This name will be used to search for parameter from URL.
     *
     * @return parameter key names in URL
     */
    /**
     * 从 {@link URL }的 Key 名，对应的 Value 作为要 Adapt 成的 Extension 名。
     * <p>
     * 如果 {@link URL} 这些 Key 都没有 Value ，使用 缺省的扩展（在接口的{@link SPI}中设定的值）。<br>
     * 比如，<code>String[] {"key1", "key2"}</code>，表示
     * <ol>
     *      <li>先在URL上找key1的Value作为要Adapt成的Extension名；
     *      <li>key1没有Value，则使用key2的Value作为要Adapt成的Extension名。
     *      <li>key2没有Value，使用缺省的扩展。
     *      <li>如果没有设定缺省扩展，则方法调用会抛出{@link IllegalStateException}。
     * </ol>
     * <p>
     * 如果不设置则缺省使用Extension接口类名的点分隔小写字串。<br>
     * 即对于Extension接口 {@code com.alibaba.dubbo.xxx.YyyInvokerWrapper} 的缺省值为 <code>String[] {"yyy.invoker.wrapper"}</code>
     *
     * @see SPI#value()
     */
    String[] value() default {};

}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Activate {
    /**
     * Activate the current extension when one of the groups matches. The group passed into
     * {@link ExtensionLoader#getActivateExtension(URL, String, String)} will be used for matching.
     *
     * @return group names to match
     * @see ExtensionLoader#getActivateExtension(URL, String, String)
     */
    /**
     * Group过滤条件。
     * <br />
     * 包含{@link ExtensionLoader#getActivateExtension}的group参数给的值，则返回扩展。
     * <br />
     * 如没有Group设置，则不过滤。
     */
    String[] group() default {};

    /**
     * Activate the current extension when the specified keys appear in the URL's parameters.
     * <p>
     * For example, given <code>@Activate("cache, validation")</code>, the current extension will be return only when
     * there's either <code>cache</code> or <code>validation</code> key appeared in the URL's parameters.
     * </p>
     *
     * @return URL parameter keys
     * @see ExtensionLoader#getActivateExtension(URL, String)
     * @see ExtensionLoader#getActivateExtension(URL, String, String)
     */
    /**
     * Key过滤条件。包含{@link ExtensionLoader#getActivateExtension}的URL的参数Key中有，则返回扩展。
     * <p/>
     * 示例：<br/>
     * 注解的值 <code>@Activate("cache,validatioin")</code>，
     * 则{@link ExtensionLoader#getActivateExtension}的URL的参数有<code>cache</code>Key，或是<code>validatioin</code>则返回扩展。
     * <br/>
     * 如没有设置，则不过滤。
     */
    String[] value() default {};

    /**
     * Relative ordering info, optional
     *
     * @return extension list which should be put before the current one
     */
    /**
     * 排序信息，可以不提供。
     */
    String[] before() default {};

    /**
     * Relative ordering info, optional
     *
     * @return extension list which should be put after the current one
     */
    /**
     * 排序信息，可以不提供。
     */
    String[] after() default {};

    /**
     * Absolute ordering info, optional
     *
     * @return absolute ordering info
     */
    /**
     * 排序信息，可以不提供。
     */
    int order() default 0;
}

/**
 * ExtensionFactory
 *
 * 拓展工厂接口
 */
@SPI
public interface ExtensionFactory {

    /**
     * Get extension.
     *
     * 获得拓展对象
     *
     * @param type object type. 拓展接口
     * @param name object name. 拓展名
     * @return object instance. 拓展对象
     */
    <T> T getExtension(Class<T> type, String name);

}

 1: @Adaptive
 2: public class AdaptiveExtensionFactory implements ExtensionFactory {
 3: 
 4:     /**
 5:      * ExtensionFactory 拓展对象集合
 6:      */
 7:     private final List<ExtensionFactory> factories;
 8: 
 9:     public AdaptiveExtensionFactory() {
10:         // 使用 ExtensionLoader 加载拓展对象实现类。
11:         ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
12:         List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
13:         for (String name : loader.getSupportedExtensions()) {
14:             list.add(loader.getExtension(name));
15:         }
16:         factories = Collections.unmodifiableList(list);
17:     }
18: 
19:     public <T> T getExtension(Class<T> type, String name) {
20:         // 遍历工厂数组，直到获得到属性
21:         for (ExtensionFactory factory : factories) {
22:             T extension = factory.getExtension(type, name);
23:             if (extension != null) {
24:                 return extension;
25:             }
26:         }
27:         return null;
28:     }
29: 
30: }

public class SpiExtensionFactory implements ExtensionFactory {

    /**
     * 获得拓展对象
     *
     * @param type object type. 拓展接口
     * @param name object name. 拓展名
     * @param <T> 泛型
     * @return 拓展对象
     */
    public <T> T getExtension(Class<T> type, String name) {
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) { // 校验是 @SPI
            // 加载拓展接口对应的 ExtensionLoader 对象
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
            // 加载拓展对象
            if (!loader.getSupportedExtensions().isEmpty()) {
                return loader.getAdaptiveExtension();
            }
        }
        return null;
    }

}

public class SpringExtensionFactory implements ExtensionFactory {

    /**
     * Spring Context 集合
     */
    private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();

    public static void addApplicationContext(ApplicationContext context) {
        contexts.add(context);
    }

    public static void removeApplicationContext(ApplicationContext context) {
        contexts.remove(context);
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T getExtension(Class<T> type, String name) {
        for (ApplicationContext context : contexts) {
            if (context.containsBean(name)) {
                // 获得属性
                Object bean = context.getBean(name);
                // 判断类型
                if (type.isInstance(bean)) {
                    return (T) bean;
                }
            }
        }
        return null;
    }

}

public class DemoFilter implements Filter {

    private DemoDAO demoDAO;

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return invoker.invoke(invocation);
    }

    public DemoFilter setDemoDAO(DemoDAO demoDAO) {
        this.demoDAO = demoDAO;
        return this;
    }
}