Dubbo流程及源码分析（一）

        扑街前言：之前的文章说明了zookeeper的使用及源码，那么本次我们继续了解和zookeeper的黄金搭档dubbo的相关内容，当然dubbo也是典型的rpc框架，所以我们从客户端和服务端逐个分析，后续还有一系列文章，慢慢来。

---

SPI机制

        在分析dubbo 的源码之前，首先要分析一下dubbo 的SPI机制。dubbo 整体的设计上就是一个微内核架构，微内核架构就是只要写好主流程，同时提供一套插件查找机制。在主流程的每一个流程点上根据配置查找对应的插件来完成具体的工作，这样在每一个流程点上都可以自定制，为开发者提供了很大的便利。（在dubbo 中插件也叫做扩展点）

        dubbo 中的插件查找机制就是SPI 机制，至于为什么叫做SPI，是因为在Java中也有一套SPI机制（全称是：Service Provider Interface），服务发现机制，dubbo 本身也就是对于这套机制进行了扩展。那么我们首先可以从Java的SPI 入手。

        对Java SPI机制可以由下面一段代码进行分析。下面先写了一个接口，然后是这个接口的两个实现类，最后的就是一个JavaSpi的测试类，很简单的一段逻辑，在测试类中首先构建了一个ServiceLoader 对象，然后获取对象中的迭代器，最后判断迭代器中是否有值，有的话就用刚刚创建的接口接受，然后调用对应的方法。这里其实就可以推测iterator.next() 代码中返回的就是接口的实例，也就是上面创建的两个实现类。至于如何做到的，接着看。

public interface Robot {
    void sayHello();
}

public class Bumblebee implements Robot{
    @Override
    public void sayHello() {
        System.out.println("Hello, I am Bumblebee.");
    }
}

public class OptimusPrime implements Robot{
    @Override
    public void sayHello() {
        System.out.println("Hello, I am Optimus Prime.");
    }
}

public class JavaSpiTest {

    @Test
    public void testSayHello() {
        //创建一个 ServiceLoader对象，
        ServiceLoader serviceLoader = ServiceLoader.load(Robot.class);
        //serviceLoader.forEach(Robot::sayHello);


        //获取服务下的所有实例信息集合
        Iterator iterator = serviceLoader.iterator();

        /**
         * 循环创建所有服务实例并执行对应方法
         */
        while (iterator.hasNext()) {
            /**
             * 获取一个服务实例
             */
            Robot robot = iterator.next();
            //调用实例方法
            robot.sayHello();
        }
        // serviceLoader.forEach(Robot::sayHello);
    }
}

        首先需要知道的是ServiceLoader 对象是什么，它的位置是在Java.util 包下，实现了Iterable 迭代器接口，具体中文意思翻译过来就是：服务加载程序，其实这里我们可以都不用关心，只需要知道这个是有由Java提供可以构建服务加载的一个对象就行了，具体的还是要看下获取到迭代器之后的hasNext 方法和next 方法，下面上代码。需要注意的是上面获取的迭代器是LazyIterator 对象，那么hasNext 方法和next 方法的代码也是在LazyIterator 对象中。

        从下面的代码中可以看到，在hasNext 方法真正调用返回的是hasNextService 方法，而hasNextService 方法的代码中可以看到fullName 变量的值为：META-INF/services/接口路径，然后用这个变量值去获取配置文件信息，最后赋值给nextName。后面next 方法其实也就是调用的nextService 方法中，会使用到nextName 这个变量获取具体的实例对象并返回。

        那么也就是说只要在META-INF/services/ 这个路径下，编写一个以接口路径为名称的文件，然后在文件中写入对应的实现类路径，就能去加载。所以上面的测试类想要成功就还需要一个名称为：com.spi.jdk.Robot 的文件，其中的应该写入对应两个实现类的路径。

private static final String PREFIX = "META-INF/services/";

Class service;
ClassLoader loader;
Enumeration configs = null;
Iterator pending = null;
String nextName = null;

public boolean hasNext() {
	if (acc == null) {
		return hasNextService();
	} else {
		PrivilegedAction action = new PrivilegedAction() {
			public Boolean run() { return hasNextService(); }
		};
		return AccessController.doPrivileged(action, acc);
	}
}

private boolean hasNextService() {
	if (nextName != null) {
		return true;
	}
	if (configs == null) {
		try {
			String fullName = PREFIX + service.getName();
			if (loader == null)
				configs = ClassLoader.getSystemResources(fullName);
			else
				configs = loader.getResources(fullName);
		} catch (IOException x) {
			fail(service, "Error locating configuration files", x);
		}
	}
	while ((pending == null) || !pending.hasNext()) {
		if (!configs.hasMoreElements()) {
			return false;
		}
		pending = parse(service, configs.nextElement());
	}
	nextName = pending.next();
	return true;
}

public S next() {
	if (acc == null) {
		return nextService();
	} else {
		PrivilegedAction action = new PrivilegedAction() {
			public S run() { return nextService(); }
		};
		return AccessController.doPrivileged(action, acc);
	}
}

private S nextService() {
	if (!hasNextService())
		throw new NoSuchElementException();
	String cn = nextName;
	nextName = null;
	Class c = null;
	try {
		c = Class.forName(cn, false, loader);
	} catch (ClassNotFoundException x) {
		fail(service,
			 "Provider " + cn + " not found");
	}
	if (!service.isAssignableFrom(c)) {
		fail(service,
			 "Provider " + cn  + " not a subtype");
	}
	try {
		S p = service.cast(c.newInstance());
		providers.put(cn, p);
		return p;
	} catch (Throwable x) {
		fail(service,
			 "Provider " + cn + " could not be instantiated",
			 x);
	}
	throw new Error();          // This cannot happen
}

---

        Java SPI 实际上是“基于接口的编程＋策略模式＋配置文件”组合实现的动态加载机制。那么Java的SPI 就先说到这里，下面我们看下dubbo的SPI 是怎么实现的。

        从上面的Java SPI 机制我们不难看出，其最大的弊端就是不能按需获取实现，如果获取想要的实现类只能全部迭代一遍然后判断，那么dubbo之前也说了它的SPI 是基础Java的SPI 实现的，那么dubbo 这种微内核设计肯定不能是跟Java 的SPI一样迭代获取不同的实现，所以dubbo的SPI 的写法加入了键值对的形式，通过键找不同的实现。下面看下dubbo具体是如何实现的。

ExtensionLoader

        上述也说了dubbo并未使用Java SPI，而是实现了一套功能更强的SPI 机制。dubbo SPI 的相关逻辑被封装到了ExtensionLoader 类中，通过ExtensionLoader 可以加载指定的实现类。下面用一段测试类代码一点点引出ExtensionLoader 类的具体逻辑。

public class DubboSpiTest {

    //测试dubbo spi机制
    @Test
    public  void sayHello() throws Exception {
        //1、获得接口的ExtentionLoader
        ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
        
        //2、根据指定的名字获(key)取对应的实例
        Robot robot = extensionLoader.getExtension("optimusPrime");
        robot.sayHello();
        
        Robot optimusPrime = extensionLoader.getExtension("optimusPrime");
        optimusPrime.sayHello();
        
        Robot robot2 = extensionLoader.getDefaultExtension();
        robot2.sayHello();
    }
}

        上面我们首先看到就是ExtensionLoader 类的获取，通过ExtensionLoader 对象的getExtensionLoader 方法获取到了一个ExtensionLoader 对象，而入参就是接口类。下面上代码，看下具体有哪些内容。

        进入getExtensionLoader 方法，首先判断的就是入参对象不能为空、必须是接口、这个接口必须要被SPI.class 注解修饰，然后就是在EXTENSION_LOADERS 集合中获取当前入参接口对应的ExtensionLoader 对象，如果存在直接返回，反之就会创建一个属于入参接口的ExtensionLoader 对象，并存入EXTENSION_LOADERS 集合中，然后再返回。这里创建的内容就结束了。

        需要注意的是EXTENSION_LOADERS 集合就是ConcurrentMap 对象，而ConcurrentMap 对象父类对象就是Map 对象，而且EXTENSION_LOADERS 集合声明的静态常量，这里dubbo其实就是将这个集合用于做全局缓存，map集合的key是入参接口对象，value就是专属ExtensionLoader 对象。

private static final ConcurrentMap, ExtensionLoader> EXTENSION_LOADERS = new ConcurrentHashMap<>();

private static  boolean withExtensionAnnotation(Class type) {
    return type.isAnnotationPresent(SPI.class);
}

public static  ExtensionLoader getExtensionLoader(Class type) {
	/**
	 * 校验
	 * 1、不为空
	 * 2、是接口
	 * 3、接口上需要有@SPI注解
	 */
	if (type == null) {
		throw new IllegalArgumentException("Extension type == null");
	}
	if (!type.isInterface()) {
		throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
	}
	if (!withExtensionAnnotation(type)) {
		throw new IllegalArgumentException("Extension type (" + type +
				") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
	}
	/**
	 * 先从EXTENSION_LOADERS(已加载的ExtensionLoader) 中获取
	 * 每个接口type都对应一个 ExtensionLoader,该接口下会对应多个扩展点
	 */
	ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
	if (loader == null) {
		EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type)); // 每个接口type都对应一个 ExtensionLoader
		loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
	}
	return loader;
}

        当获取到接口对应的ExtensionLoader 对象之后，就到了getExtension 获取实现类的地方，这里的入参就是上面所说的dubbo SPI 中实现的键值对的键，至于值就是具体实现类。上代码详细看。

        代码一眼看去也很简单，第一步判断入参不能为空、不能是字符true，第二步用getOrCreateHolder 方法获取Holder 对象，如果存在返回，反之调用createExtension 方法创建实例再返回，这里需要注意的就是Holder 对象，这个对象本身就只有一个value属性，但是这个value 属性被volatile 关键值修饰，而且这个下面这段代码的写法就是为了实现单例模式，也就是入参对应的Holder 对象一定是唯一的。（volatile 关键的用法和单例模式的实现，这里就不再赘述了） 

        再分析一下getOrCreateHolder 方法和createExtension 方法，getOrCreateHolder 方法十分简单（这就是好的代码，耦合低，可读性高），这个方法目的就是为了在cachedInstances 集合中根据入参获取实例对象，如果集合中没存数据，就创建一个Holder 对象并存入集合。注意：这里的集合和上面的集合不一样，上面的是全局静态常量集合，这里是私有的常量集合。也就是说这个集合只有在当前类中能使用，而上面的整个项目都能使用。

// 缓存 所有实例key及对应的Holder
private final ConcurrentMap> cachedInstances = new ConcurrentHashMap<>();

/**
 * Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
 * will be thrown.
 */
@SuppressWarnings("unchecked")
public T getExtension(String name) {
	if (StringUtils.isEmpty(name)) {
		throw new IllegalArgumentException("Extension name == null");
	}
	if ("true".equals(name)) {
		return getDefaultExtension();
	}
	/**
	 * name为 META-INF/dubbo下配置文件中配置的key
	 *
	 * 1、获取key对应Extension实例的holder (双重锁校验)--->getOrCreateHolder内部通过cachedInstances缓存所有实例key及对应的Holder
	 * 2、创建key对应的Extension实例并存入holder
	 * 3、返回对应的Extension实例
	 */
	final Holder