dubbo的IOC机制

转自：https://blog.csdn.net/qq_25235807

当@Adaptive注解没有注解在扩展点实现类上，而是在扩展点实现类的方法上的时候则会生成一个<扩展点接口名>$Adpative的代理类。

 private Class<?> createAdaptiveExtensionClass() {
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
return compiler.compile(code, classLoader);
    }

• 1

• createAdaptiveExtensionClassCode()会生成一个模板代码

public class <扩展点接口名>$Adpative implements <扩展点接口> {
public <有@Adaptive注解的接口方法>(<方法参数>) {
if(是否有URL类型方法参数?) 使用该URL参数
else if(是否有方法类型上有URL属性) 使用该URL属性
        # <else 在加载扩展点生成自适应扩展点类时抛异常，即加载扩展点失败！>
if(获取的URL == null) {
throw new IllegalArgumentException("url == null");
        }
          根据@Adaptive注解上声明的Key的顺序，从URL获致Value，作为实际扩展点名。
          如URL没有Value，则使用缺省扩展点实现。如没有扩展点， throw new IllegalStateException("Fail to get extension");
          在扩展点实现调用该方法，并返回结果。
    }
public <有@Adaptive注解的接口方法>(<方法参数>) {
throw new UnsupportedOperationException("is not adaptive method!");
    }
}

• 1

package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
public void destroy() {
throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }
public int getDefaultPort() {
throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }
public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {
if (arg0 == null) {
throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
        }
if (arg0.getUrl() == null) {
throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
        }
        com.alibaba.dubbo.common.URL url = arg0.getUrl();
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
if (extName == null) {
throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        }
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
return extension.export(arg0);
    }
public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {
if (arg1 == null) {
throw new IllegalArgumentException("url == null");
        }
        com.alibaba.dubbo.common.URL url = arg1;
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
if (extName == null) {
throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        }
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
return extension.refer(arg0, arg1);
    }
}

• 1

然后会接着通过getExtension(name)获得指定名称的扩展点的实例。

• getExtension(name)

/**
     * 返回指定名字的扩展。如果指定名字的扩展不存在，则抛异常 {@link IllegalStateException}.
     *
     * @param name
     * @return
     */
    @SuppressWarnings("unchecked")
public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) {
return getDefaultExtension();
        }
        Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {
            cachedInstances.putIfAbsent(name, new Holder<Object>());
            holder = cachedInstances.get(name);
        }
        Object instance = holder.get();
if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
if (instance == null) {
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
return (T) instance;
    }

• 1

这里巧妙的使用了缓存，单例，和高并发。接下来我会单独分析dubbo的spi中是如何解决高并发处理的。

• createExtension()

private T createExtension(String name) {
        Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {
throw findException(name);
        }
try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
                EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            injectExtension(instance);
//对于有包装类的将包装类进行循环注入
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && wrapperClasses.size() > 0) {
for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
return instance;
        } catch (Throwable t) {
throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                    type + ")  could not be instantiated: " + t.getMessage(), t);
        }
    }

• 1

在创建扩展点实例的时候，同样是使用getExtensionClasses()获取他的class对象，在这里有一个非常重要的方法就是injectExtension().这个方法是dubbo进行IOC和AOP的地方。

    private T injectExtension(T instance) {
try {
if (objectFactory != null) {
for (Method method : instance.getClass().getMethods()) {
if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) {
                        Class<?> pt = method.getParameterTypes()[0];
try {
                            String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                            Object object = objectFactory.getExtension(pt, property);
if (object != null) {
                                method.invoke(instance, object);
                            }
                        } catch (Exception e) {
                            logger.error("fail to inject via method " + method.getName()
                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
return instance;
    }

• 1

上次我们说到了objectFactory是dubbo用于IOC和AOP的工厂，而他真正产生作用的地方就是injectExtension(T)，我们可以注意到objectFactory实际上就是ExtensionFactory的自适应扩展点。在这里我们要首先介绍一下ExtensionFactory的三个实现类。

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
private final List<ExtensionFactory> factories;
public AdaptiveExtensionFactory() {
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
for (String name : loader.getSupportedExtensions()) {
list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }
public <T> T getExtension(Class<T> type, String name) {
for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
if (extension != null) {
return extension;
            }
        }
return null;
    }
}

• 1

这是一个典型的适配器模式。通过适配器获得另外的两个ExtensionFactory实现类。

public class SpiExtensionFactory implements ExtensionFactory {
public <T> T getExtension(Class<T> type, String name) {
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
if (loader.getSupportedExtensions().size() > 0) {
return loader.getAdaptiveExtension();
            }
        }
return null;
    }
}

• 1

SpiExtensionFactory负责加载扩展点的自适应扩展点对象。

public class SpringExtensionFactory implements ExtensionFactory {
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);
    }
@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;
    }
}

• 1

通过spring容器加载扩展点实例。

• 总结以上代码
  通过以上代码分析可以看出来，dubbo的ExtensionFactory维护了两套bean的管理容器SpringExtensionFactory和SpiExtensionFactory，通过适配器模式使用AdaptiveExtensionFactoy来统一管理这两种容器。而objectFactoty实际上就是
  AdaptiveExtensionFactoy适配工厂类。所以在dubbo一个内部的bean的注入一定是通过SpiExtensionFactory实现的。而类似于服务的发布则交由spring统一管理.