基于RPC远程调用的电影售票系统.zip

package com.lnsf.rpc.extension; import lombok.extern.slf4j.Slf4j; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.URL; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * refer to dubbo spi: https://dubbo.apache.org/zh/docs/v2.7/dev/source/dubbo-spi/ * 实现思想：首先通过 ExtensionLoader 的 getExtensionLoader 方法获取一个 ExtensionLoader 实例， * 然后再通过 ExtensionLoader 的 getExtension 方法获取拓展类对象。这其中，getExtensionLoader * 方法用于从缓存中获取与拓展类对应的 ExtensionLoader，若缓存未命中，则创建一个新的实例。 */ @Slf4j public final class ExtensionLoader<T> { /** * 配置文件路径 */ private static final String SERVICE_DIRECTORY = "META-INF/extensions/"; private static final Map<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>(); private static final Map<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<>(); private final Class<?> type; private final Map<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>(); private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>(); private ExtensionLoader(Class<?> type) { this.type = type; } public static <S> ExtensionLoader<S> getExtensionLoader(Class<S> type) { if (type == null) { throw new IllegalArgumentException("扩展类型不能为空"); } if (!type.isInterface()) { throw new IllegalArgumentException("扩展类型只能为接口类型"); } if (type.getAnnotation(SPI.class) == null) { throw new IllegalArgumentException("扩展类型必须要有@SPI注解"); } // 从缓存中直接读取，null->创建 ExtensionLoader<S> extensionLoader = (ExtensionLoader<S>) EXTENSION_LOADERS.get(type); if (extensionLoader == null) { EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<S>(type)); extensionLoader = (ExtensionLoader<S>) EXTENSION_LOADERS.get(type); } return extensionLoader; } /** * 首先检查缓存，缓存未命中则创建拓展对象 * @param name * @return */ public T getExtension(String name) { if (name == null || name.length() == 0) { throw new IllegalArgumentException("Extension name == null"); } // Holder，顾名思义，用于持有目标对象 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 中 holder.set(instance); } } } return (T) instance; } /** * 1、通过 getExtensionClasses 获取所有的拓展类 * 2、通过反射创建拓展对象 * 第一个步骤是加载拓展类的关键 * @param name * @return */ private T createExtension(String name) { // 从配置文件中加载所有的拓展类，可得到“配置项名称”到“配置类”的映射关系表 Class<?> clazz = getExtensionClasses().get(name); if (clazz == null) { throw new RuntimeException("没有该扩展类型" + name); } T instance = (T) EXTENSION_INSTANCES.get(clazz); if (instance == null) { try { // 通过反射创建实例 EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance()); instance = (T) EXTENSION_INSTANCES.get(clazz); } catch (Exception e) { log.error(e.getMessage()); } } return instance; } /** * 通过名称获取拓展类之前，首先需要根据配置文件解析出拓展项名称到拓展类的映射关系表（Map<名称, 拓展类>）， * 之后再根据拓展项名称从映射关系表中取出相应的拓展类即可 * @return */ private Map<String, Class<?>> getExtensionClasses() { // 从缓存中获取已加载的拓展类 Map<String, Class<?>> classes = cachedClasses.get(); // 双重检查 if (classes == null) { //同步锁，保证每次只有一个对象操作资源 synchronized (cachedClasses) { classes = cachedClasses.get(); if (classes == null) { classes = new HashMap<>(); // 加载拓展类 loadDirectory(classes); cachedClasses.set(classes); } } } return classes; } /** * loadDirectory 方法先通过 classLoader 获取所有资源链接， * 然后再通过 loadResource 方法加载资源 * @param extensionClasses */ private void loadDirectory(Map<String, Class<?>> extensionClasses) { // fileName = 文件夹路径 + type 全限定名 String fileName = ExtensionLoader.SERVICE_DIRECTORY + type.getName(); try { Enumeration<URL> urls; ClassLoader classLoader = ExtensionLoader.class.getClassLoader(); //加载本地扩展类 urls = classLoader.getResources(fileName); //全局加载同名文件 //urls = ClassLoader.getSystemResources(fileName); if (urls != null) { while (urls.hasMoreElements()) { URL resourceUrl = urls.nextElement(); //加载资源 loadResource(extensionClasses, classLoader, resourceUrl); } } } catch (IOException e) { log.error(e.getMessage()); } } private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, URL resourceUrl) { try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceUrl.openStream(), "UTF-8"))) { String line; // 按行读取配置内容 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; String clazzName = null; final int ei = line.indexOf('='); if (ei > 0) { name = line.substring(0, ei).trim(); clazzName = line.substring(ei + 1).trim(); } if (name.length() > 0 && clazzName.length() > 0) { // 加载类，并通过 loadClass 方法对类进行缓存 Class<?> clazz = classLoader.loadClass(clazzName); extensionClasses.put(name, clazz); } } catch (ClassNotFoundException e) { log.error(e.getMessage()); } } } } catch (IOException e) { log.error(e.getMessage()); } } }