当前位置:首页 » 《随便一记》 » 正文

dubbo源码系列2——spi源码解读(下)_xu_jiang_hua的博客

18 人参与  2022年03月03日 14:33  分类 : 《随便一记》  评论

点击全文阅读


        今天是2021年10月1号,在此祝伟大的祖国母亲生日快乐,繁荣昌盛!

        上一节对sdk spi机制从源码角度进行了分析,文末留下思考:jdk spi有什么缺点?总结如下:

  • 无法按需加载

    ServiceLoader通过LazyIterator实现延迟加载,但是加载时仍然是遍历所有的类进行实例化,无法按需加载;

  • 多线程非安全

    ServiceLoader方法都是static,在并发时可能出现意想不到的线程安全问题;

        针对以上问题,dubbo在借鉴sdk spi的基础上,通过分离配置加载和实例化实现按需加载,并且提供了ioc以及aop,进行功能增强。接下来看看dubbo如何实现相关功能?本节安排如下:

  1. demo
  2. 拓展点分析
  3. ioc
  4. aop
  5. 总结

1、demo

1.1、接口

//运动接口

package xu.jiang.hua.dubbo.api.service;
import org.apache.dubbo.common.extension.SPI;
@SPI("volleyball")
public interface Sport {
    
    public void play();
}

定义Sport接口,并且指定默认实现为volleyball.

@SPI
public interface Drink {
    void drink();
}

1.2、实现

//篮球实现

package xu.jiang.hua.dubbo.api.service.impl;
import xu.jiang.hua.dubbo.api.service.Drink;
import xu.jiang.hua.dubbo.api.service.Sport;
public class BasketBallSport implements Sport {

    private Drink drink;
    public void setDrink(Drink drink) {
        this.drink = drink;
    }

    @Override
    public void play() {

        System.out.print("运动前喝点饮料补充养分:");
        drink.drink();
        System.out.println("play basketball");
    }
}

//排球实现

package xu.jiang.hua.dubbo.api.service.impl;

import xu.jiang.hua.dubbo.api.service.Sport;

public class VolleyballSport implements Sport {
    @Override
    public void play() {
        System.out.println("play volleyballSport");
    }
}

//FootBallSport

package xu.jiang.hua.dubbo.api.service.impl;

import org.apache.dubbo.common.extension.Adaptive;
import xu.jiang.hua.dubbo.api.service.Sport;

@Adaptive
public class FootBallSport implements Sport {

    @Override
    public void play() {

        System.out.println("play football");
    }
}

并通过@Adaptive标示FootBallSport 为Sport的自适应类。

//运动切面

package xu.jiang.hua.dubbo.api.service.impl;
import xu.jiang.hua.dubbo.api.service.Sport;

public class SportWrapper1 implements Sport {

    private Sport sport;

    public SportWrapper1(Sport sport) {
        this.sport = sport;
    }
    @Override
    public void play() {
        System.out.println("运动前1");
        sport.play();
        System.out.println("运动后1");
    }
}

//饮料实现

package xu.jiang.hua.dubbo.api.service.impl;

import org.apache.dubbo.common.extension.Adaptive;
import xu.jiang.hua.dubbo.api.service.Drink;

@Adaptive
public class MineralWater implements Drink {
    @Override
    public void drink() {
        System.out.println("喝矿泉水");
    }
}

并通过@Adaptive标示MineralWater为Drink的自适应类。

1.3、配置

  • xu.jiang.hua.dubbo.api.service.Sport
    basketBall=xu.jiang.hua.dubbo.api.service.impl.BasketBallSport
    volleyball=xu.jiang.hua.dubbo.api.service.impl.VolleyballSport
    footBall=xu.jiang.hua.dubbo.api.service.impl.FootBallSport
    xu.jiang.hua.dubbo.api.service.impl.SportWrapper1

  • xu.jiang.hua.dubbo.api.service.Drink
    mineralWater=xu.jiang.hua.dubbo.api.service.impl.MineralWater

1.4、运行结果

public class MainTest {

    public static void main(String[] args) {


        System.out.println("...........getExtension............");
        Sport basketBall = ExtensionLoader.getExtensionLoader(Sport.class).getExtension("basketBall");
        basketBall.play();

        System.out.println("...........getDefaultExtension............");
        Sport defaultSport = ExtensionLoader.getExtensionLoader(Sport.class).getDefaultExtension();
        defaultSport.play();


        System.out.println("...........getAdaptiveExtension............");
        Sport adaptiveSport = ExtensionLoader.getExtensionLoader(Sport.class).getAdaptiveExtension();
        adaptiveSport.play();

    }
}

在这里插入图片描述
        从执行结果来看,basketBall这个拓展点的方法执行前后有SportWrapper1类进行拦截,同时通过dubbo spi机制注入Drink接口。
        因Sport接口上@SPI(“volleyball”)上指定了默认实现,因此getDefaultExtension返回VolleyballSport;

2、拓展点分析

        下面以上面demo为例深入源码分析内部实现逻辑。

2.1、getExtensionLoader

可以看到加载任何拓展点都需要先执行getExtensionLoader

    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        //省略非关键代码
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            //new ExtensionLoader<T>(type)
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

继续分析new ExtensionLoader(type),如下:

    private ExtensionLoader(Class<?> type) {
        this.type = type;

        /** 逻辑解读:
         *  1、传入的type为非ExtensionFactory时,则执行ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
         *  2、则再次调用new ExtensionLoader(Class<?> type),则再次执行ExtensionLoader的构造函数,此时type为ExtensionFactory,objectFactory为null;
         *  3、根据返回的ExtensionLoader,再执行方法getAdaptiveExtension;
         *  4、加载META-INF/dubbo/internal/org.apache.dubbo.common.extension.ExtensionFactory的内容,里面有SpiExtensionFactory和AdaptiveExtensionFactory,
         *     因AdaptiveExtensionFactory被@Adaptive注解标注,则getAdaptiveExtension返回AdaptiveExtensionFactory的实例对象
         *  5、接下来对AdaptiveExtensionFactory进行实例化,AdaptiveExtensionFactory属性factories仅有SpiExtensionFactory(通过cachedClasses获取)
         */
        objectFactory =
                (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

        对type为非ExtensionFactory生成的ExtensionLoader,objectFactory为SpiExtensionFactory。

2.2、getExtension

    public T getExtension(String name, boolean wrap) {
        //省略非关键代码
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();
        //双重检查
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    //创建拓展实例
                    instance = createExtension(name, wrap);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

解析来分析createExtension方法(重点

 private T createExtension(String name, boolean wrap) {
        //A、加载配置返回map,并根据name获取对应的类
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null || unacceptableExceptions.contains(name)) {
            throw findException(name);
        }
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
          //实例化
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.getDeclaredConstructor().newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            //B、ioc注入
            injectExtension(instance);

            //C、aop处理
            if (wrap) {

                List<Class<?>> wrapperClassesList = new ArrayList<>();
                //找出所有的Wrapper并排序
                if (cachedWrapperClasses != null) {
                    wrapperClassesList.addAll(cachedWrapperClasses);
                    wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                    Collections.reverse(wrapperClassesList);//倒叙List
                }

                if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                    for (Class<?> wrapperClass : wrapperClassesList) {
                        //获取wrapper注解,如果为非空,则需要判断注解的上的match和mismatch是否与当前name匹配。如果不匹配,不生成aop实例
                        Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
                        if (wrapper == null
                                || (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
                            /**
                             * wrapperClass.getConstructor(type).newInstance(instance) 实例化warpper类(aop类),将新生成的
                             * 实例赋值给instance,从而实现aop
                             *
                             * injectExtension 对warpper类实现ioc set
                             */
                            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                        }
                    }
                }
            }

            initExtension(instance);
            return instance;
        } catch (Throwable t) {
         //省略非关键代码
        }
    }

createExtension方法主要分成以下三部分:

  • getExtensionClasses加载配置文件
  • ioc处理
  • aop处理

将加载配置和实例化分开,从而实现按需实例化,避免不必要的资源浪费(相比jdk spi的改进点)。先接下来看看内部如何实现的?

2.3、getExtensionClasses

      private Map<String, Class<?>> loadExtensionClasses() {
        //A、加载当前接口的默认实现类
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();

        /**B、加载配置文件
         * 
         * 策略模式,分别加载以下路径:
         * 1、META-INF/dubbo/internal/
         * 2、META-INF/dubbo
         * 3、META-INF/Service
         */
        for (LoadingStrategy strategy : strategies) {
            loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(),
                    strategy.overridden(), strategy.excludedPackages());
            loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"),
                    strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
        }

        return extensionClasses;
    }

第一部分默认实现类的处理:

  private void cacheDefaultExtensionName() {
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }
         //通过注解获取默认值,
        String value = defaultAnnotation.value();
        if ((value = value.trim()).length() > 0) {
            String[] names = NAME_SEPARATOR.split(value);
            //默认值有且仅有一个,否则抛出异常
            if (names.length > 1) {
                throw new IllegalStateException("More than 1 default extension name on extension " + type.getName()
                        + ": " + Arrays.toString(names));
            }
            if (names.length == 1) {
                //存在cachedDefaultName中
                cachedDefaultName = names[0];
            }
        }
    }

比如Sport有默认实现volleyball,如下所示:
在这里插入图片描述
再看第二部分加载配置文件,目前支持以下三种路径:

  • META-INF/dubbo/internal/
  • META-INF/dubbo
  • META-INF/Service
    为了兼容dubbo移交给apache成为旗下的顶级项目,同时也会将type接口名中的org.apache换成com.alibaba。接下来看loadDirectory方法:
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
                               boolean extensionLoaderClassLoaderFirst, boolean overridden, String... excludedPackages) {
        String fileName = dir + type;
         //省略非关键代码
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    java.net.URL resourceURL = urls.nextElement();
                    //加载Resourece
                    loadResource(extensionClasses, classLoader, resourceURL, overridden, excludedPackages);
                }
            }
        } catch (Throwable t) {
          //省略非关键代码
        }
    }

接下来看loadResource方法

 private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
                              java.net.URL resourceURL, boolean overridden, String... excludedPackages) {
        try {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
                String line;
                String clazz = null;
                //依次读取里面的内容
                while ((line = reader.readLine()) != null) {
                    //#是注释符号,
                    final int ci = line.indexOf('#');
                    if (ci >= 0) {
                        line = line.substring(0, ci);//取注释符号前作为类名
                    }
                    line = line.trim();
                    if (line.length() > 0) {
                        try {
                            String name = null;
                            int i = line.indexOf('=');
                            if (i > 0) {
                                name = line.substring(0, i).trim();
                                clazz = line.substring(i + 1).trim();
                            } else {
                                clazz = line;//如果无=,则认为是当前接口的warpper类
                            }
                            //加载的类非空且不在排除的类集合里面,则执行loadClass
                            if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages)) {
                                loadClass(extensionClasses, resourceURL, Class.forName(clazz, true, classLoader), name, overridden);
                            }
                        } catch (Throwable t) {
                      //省略非关键代码
                        }
                    }
                }
            }
        } catch (Throwable t) {
          //省略非关键代码
        }
    }

loadResource说明:依次读取每行,过滤掉注释内容,然后判断当前行是否包含=。如果不包含,则认为该行是该接口Wrapper类(aop实现类),继续看loadClass方法:

   private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
                           boolean overridden) throws NoSuchMethodException {
            //省略关键代码
            //A、自适应类
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            cacheAdaptiveClass(clazz, overridden);//cachedAdaptiveClass
            //B、判断是否为wrapper类—判断该类是否存在一个参数为该接口的构造函数。如存在,则认为为wrapper类
        } else if (isWrapperClass(clazz)) {
            cacheWrapperClass(clazz);//cachedWrapperClasses
        } else {
         //省略关键代码
            String[] names = NAME_SEPARATOR.split(name);//一个类可以当做多个拓展点,因此进行切分
            if (ArrayUtils.isNotEmpty(names)) {
                cacheActivateClass(clazz, names[0]);//cachedActivates
                for (String n : names) {
                    cacheName(clazz, n);
                    //存入map
                    saveInExtensionClass(extensionClasses, clazz, n, overridden);
                }
            }
        }
    }

loadClass可以拆解成三部分:

  • Adaptive注解处理
    如果该类被@Adaptive注解标注,则将该类保存在以下爱属性中。
    private volatile Class<?> cachedAdaptiveClass = null;

  • Wrapper类处理

    private boolean isWrapperClass(Class<?> clazz) {
        try {
            //通过加载判断是否存在带接口的构造函数
            clazz.getConstructor(type);
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }

通过判断当前类是否存在以该接口为参数的构造函数。如果存在则认为为wrapper类,如果存在则将该列保存在private Set<Class<?>> cachedWrapperClasses;

  • 其他处理
    将name进行切分,分别存入Map<String, Class<?>> extensionClasses中,如下所示:
    private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name, boolean overridden) {
        Class<?> c = extensionClasses.get(name);
        if (c == null || overridden) {
            extensionClasses.put(name, clazz);
        } else if (c != clazz) {
            // duplicate implementation is unacceptable
            unacceptableExceptions.add(name);
            String duplicateMsg =
                    "Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName();
            logger.error(duplicateMsg);
            throw new IllegalStateException(duplicateMsg);
        }
    }

总结一下getExtensionClasses加载配置后的保存情况:

  • 接口默认实现类保存在
private String cachedDefaultName;
  • 被@Adaptive标注的实现类
 private volatile Class<?> cachedAdaptiveClass = null;
  • warpper类
private Set<Class<?>> cachedWrapperClasses;
  • 其他类
 private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();

cachedClasses则作为getExtensionClasses的结果返回。

3、ioc

        ioc处理位于createExtension方法中,回顾一下createExtension方法:

   private T createExtension(String name, boolean wrap) {
        //加载配置,并根据name返回对应的类
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null || unacceptableExceptions.contains(name)) {
            throw findException(name);
        }
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                //实例化
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.getDeclaredConstructor().newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            //ioc注入
            injectExtension(instance);

    //省略其他
    }

         通过getExtensionClasses将配置加载到map中并根据name获取对应类,然后进行实例化,实例化后执行injectExtension处理ioc。下面看看injectExtension方法:

private T injectExtension(T instance) {

        if (objectFactory == null) {
            return instance;
        }

        try {
            for (Method method : instance.getClass().getMethods()) {
                if (!isSetter(method)) {
                    continue;
                }
                /**
                 * Check {@link DisableInject} to see if we need auto injection for this property
                 */
                //set方法如果不想被ioc使用,则通过注解标示
                if (method.getAnnotation(DisableInject.class) != null) {
                    continue;
                }
                Class<?> pt = method.getParameterTypes()[0];
                if (ReflectUtils.isPrimitives(pt)) {
                    continue;
                }

                try {
                    String property = getSetterProperty(method);
                    //通过type和名字从objectFactory获取
                    Object object = objectFactory.getExtension(pt, property);
                    if (object != null) {
                        //反射调用方法
                        method.invoke(instance, object);
                    }
                } catch (Exception e) {
                  //省略非关键代码
                }

            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }

        接下来看如何通过objectFactory.getExtension(pt, property)从上下文获取实例。根据ExtensionLoader实例化分析可知,objectFactory为AdaptiveExtensionFactory,如下:
在这里插入图片描述

    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;
    }

此时facory中仅有SpiExtensionFactory,执行getExtension方法返回实例。下面看看getExtension如何执行的?

public class SpiExtensionFactory implements ExtensionFactory {

    @Override
    public <T> T getExtension(Class<T> type, String name) {
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
            /**
             * 如果type仅有一个实现类并且类上有一个@Adaptive标注,此时loader.getSupportedExtensions()
             * 返回为空,则getExtension返回null。为什么?
             */
            if (!loader.getSupportedExtensions().isEmpty()) {
                //返回自适应类
                return loader.getAdaptiveExtension();
            }
        }
        return null;
    }

}

分析getAdaptiveExtension:

    public T getAdaptiveExtension() {
        Object instance = cachedAdaptiveInstance.get();
              //省略非关键代码      
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        //创建adaptiveExtension实例
                        instance = createAdaptiveExtension();
                        cachedAdaptiveInstance.set(instance);
                    } catch (Throwable t) {
                        createAdaptiveInstanceError = t;
                        throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        }

        return (T) instance;
    }

继续分析createAdaptiveExtension:

    private T createAdaptiveExtension() {
        try {
            //获取adaptiveExtension类并实例化,然后执ioc
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
           //省略非关键代码
        }
    }

重点看getAdaptiveExtensionClass()方法

  private Class<?> getAdaptiveExtensionClass() {
        getExtensionClasses();
        //优先使用被@Adaptive标注的类
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        //如果当前接口不存在Adaptive注解标注的实现类,那么需要手动编译方法
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

可以看到ioc注入的实例获取的优先级:

  • @Adaptive标注的类
  • 动态生成自适应类(方法上必须有@Adaptive注解,否则抛异常)。运行时通过传递url指定接口的实现类,如果传递的url未匹配上且有默认实现,则使用默认实现

下面就以以上面两种情况进行演示:

3.1、@Adaptive在类上

@Adaptive
public class MineralWater implements Drink {

    @Override
    public void drink(URL url) {
        System.out.println("喝矿泉水");
    }
}

在这里插入图片描述

3.2、@Adaptive在方法上

        将MineralWater上的@Adaptive注解去掉,同时方法加上@Adaptive并设定key为drink,则运行通过url里面map参数指定具体的实现。

@SPI("mineralWater")
public interface Drink {

    @Adaptive({"drink"})
    void drink(URL url);
}

在这里插入图片描述

   private Class<?> createAdaptiveExtensionClass() {
        //生成代理类时判断方法上是否有@Adaptive注解修饰,如果没有,则抛出异常
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        ClassLoader classLoader = findClassLoader();
        org.apache.dubbo.common.compiler.Compiler compiler =
       //AdaptiveCompiler
        ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

3.3、自动生成的自适应类

package xu.jiang.hua.dubbo.api.service;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class Drink$Adaptive implements xu.jiang.hua.dubbo.api.service.Drink {

public void drink(org.apache.dubbo.common.URL arg0)  {

	if (arg0 == null) 
	
	throw new IllegalArgumentException("url == null");
	
	org.apache.dubbo.common.URL url = arg0;
	//因为接口上指定了默认实现为mineralWater,则如果取不到则使用默认的实现
	String extName = url.getParameter("drink", "mineralWater");
	
	if(extName == null) 
		throw new IllegalStateException("Failed to get extension (xu.jiang.hua.dubbo.api.service.Drink) name from url (" + url.toString() + ") use keys([drink])");
		
	xu.jiang.hua.dubbo.api.service.Drink extension = (xu.jiang.hua.dubbo.api.service.Drink)ExtensionLoader.getExtensionLoader(xu.jiang.hua.dubbo.api.service.Drink.class).getExtension(extName);
	
	extension.drink(arg0);
}
}

在这里插入图片描述
        将生成的自适应类通过反射赋给BasketBallSport实例, 运行时通过URL指定具体的实现:
URL url=URL.valueOf(“http://127.0.0.1”);
url= url.addParameter(“drink”,“mineralWater”);
drink.drink(url);

3.3、ioc总结

        通过injectExtension方法和类上的set方法实现依赖注入,获取的实例的优先级如下:

  • A、@Adaptive标记类生成的实例;
  • B、根据@Adaptive标记的方法自动编译生成自适应类,运行时如果匹配失败且有默认实现类,则使用默认类。

4、aop

aop处理同样位于createExtension方法中,回顾一下createExtension方法:

    private T createExtension(String name, boolean wrap) {
            //省略非关键代码          
            //ioc注入
            injectExtension(instance);

            //aop处理
            if (wrap) {

                List<Class<?>> wrapperClassesList = new ArrayList<>();
                //找出所有的Wrapper并排序
                if (cachedWrapperClasses != null) {
                    wrapperClassesList.addAll(cachedWrapperClasses);
                    wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                    Collections.reverse(wrapperClassesList);//倒叙List
                }

                if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                    for (Class<?> wrapperClass : wrapperClassesList) {
                        //获取wrapper注解,如果为非空,则需要判断注解的上的match和mismatch是否与当前name匹配。如果不匹配,不生成aop实例
                        Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
                        if (wrapper == null
                                || (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
                            /**
                             * wrapperClass.getConstructor(type).newInstance(instance) 实例化warpper类(aop类),将新生成的
                             * 实例赋值给instance,从而实现aop
                             *
                             * injectExtension 对warpper类实现ioc set
                             */
                            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                        }
                    }
                }
            }

            initExtension(instance);
            return instance;
        } catch (Throwable t) {
     
        }
    }

        前面getExtensionClasses方法中已经分析过warpper类会保存在

private Set<Class<?>> cachedWrapperClasses;

取出所有的cachedWrapperClasses并排序。接下来重点看
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance))

从warpper类中取出具有接口参数的构造函数,并向构造函数传入当前实例进行warpper类的实例化,然后进行ioc处理(warpper类可能也有依赖注入),然后赋值给instance(前后instance不是同一个对象),如下所示:
在这里插入图片描述
在这里插入图片描述
        可以看到instantce不是同一个对象,新生成的instance包含之前的instance。

5、总结

        每个拓展点都会通过getExtensionLoader生成ExtensionLoader实例。

  • getExtension

    getExtension通过传入的name实现按需实例化;

  • getDefaultExtension

    getDefaultExtension返回接口的默认实现, 默认实现的 类名保存在
    private String cachedDefaultName;

  • getAdaptiveExtension
    getDefaultExtension返回接口的自适应类。优先使用@Adaptive标注的类,保存在cachedAdaptiveClass。如果无@Adaptive标记的类,则根据@Adaptive标记的方法自动生成自适应类;

 private volatile Class<?> cachedAdaptiveClass = null;
  • ioc
    获取当前接口getAdaptiveExtension返回实例进行依赖注入;如果getAdaptiveExtension为空且有默认实现,则使用默认实现,否则不注入;

  • aop
    根据getExtensionClasses得到接口的warpper类集合实现链式增强并作为新实例返回。

  private Set<Class<?>> cachedWrapperClasses;

点击全文阅读


本文链接:http://m.zhangshiyu.com/post/35674.html

实例  方法  加载  
<< 上一篇 下一篇 >>

  • 评论(0)
  • 赞助本站

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

关于我们 | 我要投稿 | 免责申明

Copyright © 2020-2022 ZhangShiYu.com Rights Reserved.豫ICP备2022013469号-1