Dubbo源码 之 Activate源码分析
目录
一、简介：
二、用法
三、源码
四、小结：
一、简介：
@Activate称为自动激活扩展点注解，主要使用在有多个扩展点实现、需要同时根据不同条件被激活的场景中
二、用法
这里列举了@Activate注解不同属性的作用的几种场景，我们首先来看下使用效果。
前期准备：
新建一个接口和五个实现类
@Activate(value = {"activateKey2"}, group = {"order"})
public class ValueActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am ValueActivateImpl.");
}
}
@Activate(order = 2, group = {"order"})
public class Order2ActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am Order2ActivateImpl.");
}
}
@Activate(order = 1, group = {"order"})
public class Order1ActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am Order1ActivateImpl.");
}
}
@Activate(group = {"order"})
//@Adaptive
public class OptimusPrime implements Robot {
@Override
public void sayHello(String url) {
System.out.println("Hello, I am OptimusPrime");
}
}
@Activate(after = "valueActivateImpl",group = "order")
public class BeforeActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am BeforeActivateImpl.");
}
}测试main方法
①、@Activate#group
group表示分组如果匹配则激活，目前几个实现类都是group都是order，直接运行结果都被执行，和group匹配的都被执行。
②、@Activate#value
value表示URL有该key值，则激活,在ValueActivateImpl@Activate注解上加上value属性，和url中某个key保持一致。
在Order2ActivateImpl@Activate注解上同样加上value属性，但是和ValueActivateImpl区分开
其他的实现类group我改成其他的了，为了测试结果容易区分
value值和url中的key可以匹配上的才能被执行。
③、@Activate#before after
before表示哪些扩展点要在本扩展点之前激活，也就是当前扩展类是谁的before
after哪些扩展点要在本扩展点之后激活，也就是当前扩展类是谁的after
将代码还原原始状态，先测试执行不加before和after的
@Activate(group = "order")
public class BeforeActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am BeforeActivateImpl.");
}
}
@Activate(group = {"order"})
//@Adaptive
public class OptimusPrime implements Robot {
@Override
public void sayHello(String url) {
System.out.println("Hello, I am OptimusPrime");
}
}
@Activate(order = 1, group = {"order"})
public class Order1ActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am Order1ActivateImpl.");
}
}
@Activate(order = 2, group = {"order"})
public class Order2ActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am Order2ActivateImpl.");
}
}
@Activate(value = {"activateKey2"}, group = {"order"})
public class ValueActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am ValueActivateImpl.");
}
}
执行得到当前的一种执行时机顺序，然后我们加上before和after看是否能够根据我们的意愿进行执行
其实我就是想把BeforeActivateImpl和OptimusPrime的顺序、Order1和Order2的顺序颠倒。看下效果。符合我们的意愿。
④、@Activate#order
order表示同一组里面的排序，序号越小优先级越高
借助于上面的代码，我把order1和order2的序号改变下
@Activate(order = 2, group = {"order"})
public class Order1ActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am Order1ActivateImpl.");
}
}
@Activate(order = 1, group = {"order"})
public class Order2ActivateImpl implements Robot{
@Override
public void sayHello(String url) {
System.out.println("Hello, I am Order2ActivateImpl.");
}
}正常情况下order2应该优先于order1的执行顺序。
三、源码
现在我们从源码的角度分析@Activate的执行原理和各个属性的执行优先级顺序是怎么决定的。
从main方法作为入口我们首先看getExtensionLoader方法
这个方法总的目的就是获取ExtensionLoader，接下来 是其执行步骤：①、校验type如果为空，抛异常、type如果非接口、抛异常
、如果type没有扩展的注解修饰、抛异常。②、从缓存map中取，如果为空，生成ExtensionLoader放入map当中。③，如果缓存中能够取到，直接返回。
然后进入extExtensionLoader.getActivateExtension获取扩展的方法。
public List getActivateExtension(URL url, String[] values, String group) {
List exts = new ArrayList<>();
List names = values == null ? new ArrayList<>(0) : Arrays.asList(values);
if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
// TODO 加载配置路径下的接口的实现类。
getExtensionClasses();
for (Map.Entry entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Activate activate = entry.getValue();
if (isMatchGroup(group, activate.group())) {
T ext = getExtension(name);
if (!names.contains(name) && !names.contains(Constants.REMOVE_VALUE_PREFIX + name) && isActive(activate, url)) {
exts.add(ext);
}
}
}
// TODO 对exts这个list进行排序，排序规则是自己定义的一种优先级顺序
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
List usrs = new ArrayList<>();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX) && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
if (Constants.DEFAULT_KEY.equals(name)) {
if (usrs.size() > 0) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (usrs.size() > 0) {
exts.addAll(usrs);
}
return exts;
} exts用来存放最后返回的扩展类列表。names用来存放我们传进来的values，这里我测试的时候values是没有放值的。然后看getExtensionClasses方法，用来加载配置路径下的接口的实现类
//getExtensionClasses加载扩展点实现类
private Map> getExtensionClasses() {
Map> classes = cachedClasses.get();
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
classes = loadExtensionClasses();
cachedClasses.set(classes);
}
}
}
return classes;
} 主要流程就是从cachedClasses中取classes，DCL检查如果最终还是为空就loadExtensionClasses方法返回值，放进cachedClasses缓存中。进入到cachedClasses方法。
注释写的挺清楚的，应该不用多说。经过这两个方法的调用，主要是进行一些属性变量的额初始化赋值操作，以供使用。
然后回到getActivateExtension方法。我们看到完成了一个排序操作，Collections.sort(exts, ActivateComparator.COMPARATOR);对exts这个list进行排序，排序规则是自己定义的一种优先级顺序，重点关注下ActivateComparator.COMPARATOR，进入到ActivateComparator.COMPARATOR
很明显这是dubbo自己实现了一个比较器，进行两个对象之间的排序规则设定。在排序规则compare中我们很容易看出主要进行了@Activate注解before和after属性、order属性的元素顺序判定。
public int compare(Object o1, Object o2) {
if (o1 == null && o2 == null) {
return 0;
}
if (o1 == null) {
return -1;
}
if (o2 == null) {
return 1;
}
if (o1.equals(o2)) {
return 0;
}
Activate a1 = o1.getClass().getAnnotation(Activate.class);
Activate a2 = o2.getClass().getAnnotation(Activate.class);
if ((a1.before().length > 0 || a1.after().length > 0
|| a2.before().length > 0 || a2.after().length > 0)
&& o1.getClass().getInterfaces().length > 0
&& o1.getClass().getInterfaces()[0].isAnnotationPresent(SPI.class)) {
ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(o1.getClass().getInterfaces()[0]);
if (a1.before().length > 0 || a1.after().length > 0) {
String n2 = extensionLoader.getExtensionName(o2.getClass());
for (String before : a1.before()) {
//o1 在 o2 之前
if (before.equals(n2)) {
return -1;
}
}
for (String after : a1.after()) {
//o2 在 o1 之前
if (after.equals(n2)) {
return 1;
}
}
}
if (a2.before().length > 0 || a2.after().length > 0) {
String n1 = extensionLoader.getExtensionName(o1.getClass());
for (String before : a2.before()) {
if (before.equals(n1)) {
//o2 在 o1 之前
return 1;
}
}
for (String after : a2.after()) {
if (after.equals(n1)) {
//o1 在 o2 之前
return -1;
}
}
}
}
int n1 = a1 == null ? 0 : a1.order();
int n2 = a2 == null ? 0 : a2.order();
// 即使n1等于n2，也永远不会返回0，否则，o1和o2将像HashSet这样在集合中相互覆盖
return n1 > n2 ? 1 : -1;
}然后回到getActivateExtension方法。接下来就是对额外的额指定的names进行获取扩展类放入exts中，我这里么有放值，暂时不做研究。
四、小结：
@Activate注解各个属性声明的值是通过源码中sort方法进行排序的，排序规则是dubbo自己实现的比较规则。除了before、after、order其他的排序规则由jdk实现(默认升序)。
在value、before、after、order值都指定了的情况下首先是jdk实现(默认升序)的扩展类，然后是before、after指定的扩展类，然后是order指定的顺序。
个人才疏学浅，信手涂鸦，dubbo框架更多模块解读相关源码持续更新中......