motan源码分析二：使用spi机制进行类加载

在motan的源码中使用了很多的spi机制进行对象的创建，下面我们来具体分析一下它的实现方法。

1.在实际的jar包的\META-INF\services目录中引入相关的文件，例如下图中，我解压了core的jar文件后，获得到的相应文件列表：

2.以第一节中的ConfigHandler为例来分析，打开上图中的com.weibo.api.motan.config.handler.ConfigHandler文件，文件内容标识着ConfigHandler接口的实现类为：com.weibo.api.motan.config.handler.SimpleConfigHandler

#

#  Copyright 2009-2016 Weibo, Inc.

#

#    Licensed under the Apache License, Version 2.0 (the "License");

#    you may not use this file except in compliance with the License.

#    You may obtain a copy of the License at

#

#        http://www.apache.org/licenses/LICENSE-2.0

#

#    Unless required by applicable law or agreed to in writing, software

#    distributed under the License is distributed on an "AS IS" BASIS,

#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

#    See the License for the specific language governing permissions and

#    limitations under the License.

#

com.weibo.api.motan.config.handler.SimpleConfigHandler

3.在第一节中，创建ConfigHandler对象的代码是这样的：

        ConfigHandler configHandler = ExtensionLoader.getExtensionLoader(ConfigHandler.class).getExtension(MotanConstants.DEFAULT_VALUE);

4.开始进入到实际的加载代码核心部分，首先来看一下类加载器的具体实现：

    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {

        checkInterfaceType(type);//基础性检查

        ExtensionLoader<T> loader = (ExtensionLoader<T>) extensionLoaders.get(type);//之前是否已经加载过此加载器

        if (loader == null) {

            loader = initExtensionLoader(type);//第一次加载

        }

        return loader;

    }

    private static <T> void checkInterfaceType(Class<T> clz) {

        if (clz == null) {

            failThrows(clz, "Error extension type is null");

        }

        if (!clz.isInterface()) {

            failThrows(clz, "Error extension type is not interface");

        }

        if (!isSpiType(clz)) {

            failThrows(clz, "Error extension type without @Spi annotation");

        }

    }

    public static synchronized <T> ExtensionLoader<T> initExtensionLoader(Class<T> type) {

        ExtensionLoader<T> loader = (ExtensionLoader<T>) extensionLoaders.get(type);

        if (loader == null) {

            loader = new ExtensionLoader<T>(type);//新创建一个加载器

            extensionLoaders.putIfAbsent(type, loader);

            loader = (ExtensionLoader<T>) extensionLoaders.get(type);

        }

        return loader;

    }

5.下面我们将进入到加载器的内部，分析具体的实现：

    private ExtensionLoader(Class<T> type) {

        this(type, Thread.currentThread().getContextClassLoader());//使用当前线程的类加载器做为加载器，type为ConfigHandler接口

    }

    public T getExtension(String name) {

        checkInit();//检查是否初始化

        if (name == null) {

            return null;

        }

        try {

            Spi spi = type.getAnnotation(Spi.class);

            if (spi.scope() == Scope.SINGLETON) {

                return getSingletonInstance(name);//返回唯一的对象

            } else {

                Class<T> clz = extensionClasses.get(name);

                if (clz == null) {

                    return null;

                }

                return clz.newInstance();//重新创建对象

            }

        } catch (Exception e) {

            failThrows(type, "Error when getExtension " + name, e);

        }

        return null;

    }

    private synchronized void loadExtensionClasses() {

        if (init) {

            return;

        }

        extensionClasses = loadExtensionClasses(PREFIX);//加载相关的类

        singletonInstances = new ConcurrentHashMap<String, T>();

        init = true;

    }

    private ConcurrentMap<String, Class<T>> loadExtensionClasses(String prefix) {

        String fullName = prefix + type.getName();//全名为:jar包名+\META-INF\services\com.weibo.api.motan.config.handler.ConfigHandler文件里的类

        List<String> classNames = new ArrayList<String>();

        try {

            Enumeration<URL> urls;

            if (classLoader == null) {

                urls = ClassLoader.getSystemResources(fullName);

            } else {

                urls = classLoader.getResources(fullName);

            }

            if (urls == null || !urls.hasMoreElements()) {

                return new ConcurrentHashMap<String, Class<T>>();

            }

            System.out.println("fullname:"+fullName);

            while (urls.hasMoreElements()) {

                URL url = urls.nextElement();

                System.out.println("url:"+url.getFile());

                parseUrl(type, url, classNames);

            }

        } catch (Exception e) {

            throw new MotanFrameworkException(

                    "ExtensionLoader loadExtensionClasses error, prefix: " + prefix + " type: " + type.getClass(), e);

        }

        for(String classN : classNames){

            System.out.println("class:"+classN);

        }

        return loadClass(classNames);

    }

6.在parseUrl方法中进行文件的内容读取，并在loadClass中完成类的加载

    private void parseUrl(Class<T> type, URL url, List<String> classNames) throws ServiceConfigurationError {

        InputStream inputStream = null;

        BufferedReader reader = null;

        try {

            inputStream = url.openStream();

            reader = new BufferedReader(new InputStreamReader(inputStream, MotanConstants.DEFAULT_CHARACTER));

            String line = null;

            int indexNumber = 0;

            while ((line = reader.readLine()) != null) {

                indexNumber++;

                parseLine(type, url, line, indexNumber, classNames);//读取到类的名称：com.weibo.api.motan.config.handler.SimpleConfigHandler

            }

        } catch (Exception x) {

            failLog(type, "Error reading spi configuration file", x);

        } finally {

            try {

                if (reader != null) {

                    reader.close();

                }

                if (inputStream != null) {

                    inputStream.close();

                }

            } catch (IOException y) {

                failLog(type, "Error closing spi configuration file", y);

            }

        }

    }

    private ConcurrentMap<String, Class<T>> loadClass(List<String> classNames) {

        ConcurrentMap<String, Class<T>> map = new ConcurrentHashMap<String, Class<T>>();

        for (String className : classNames) {

            try {

                Class<T> clz;

                if (classLoader == null) {

                    clz = (Class<T>) Class.forName(className);//装载类：com.weibo.api.motan.config.handler.SimpleConfigHandler

                } else {

                    clz = (Class<T>) Class.forName(className, true, classLoader);

                }

                checkExtensionType(clz);

                String spiName = getSpiName(clz);

                if (map.containsKey(spiName)) {

                    failThrows(clz, ":Error spiName already exist " + spiName);

                } else {

                    map.put(spiName, clz);

                }

            } catch (Exception e) {

                failLog(type, "Error load spi class", e);

            }

        }

        return map;

    }

motan类加载的知识点总结：

1.使用jdk的spi规范，在\META-INF\services中添加实际的使用类描述，从而实现类与类之间的完全解耦；

2.类加载器使用的是当前线程的类加载器；

3.motan的类加载器可以支持单例和多例两种模式；

4.motan中大量使用了spi的类加载方式。

巴特西

motan源码分析二：使用spi机制进行类加载

最新文章

热门文章