[PHP] 基于SPI的增强式插件框架设计

本文的技术，从双亲委派模型到自定义类加载器，再到基于自定义类加载器实现的类交换，基于Java SPI实现的类交换，最后到基于Java SPI+ Java Agent + Javassist实现的插件框架及框架支持远程插件化，来一步一步的向读者展示所涉及的知识点。

   

• 进入App ClassLoader中，先检查缓存中是否存在，如果存在，则直接返回   
  
• 步骤2中的缓存中不存在，则被代理到父加载器，即Extension ClassLoader   
  
• 检查Extension ClassLoader缓存中是否存在   
  
• 步骤4中的缓存中不存在，则被代理到父加载器，即Bootstrap ClassLoader   
  
• 检查Bootstrap ClassLoader缓存中是否存在   
  
• 步骤6中的缓存中不存在，则从Bootstrap ClassLoader的类搜索路径下的文件中寻找，一般为rt.jar等，如果找不到，则抛出ClassNotFound Exception   
  
• Extension ClassLoader会捕捉ClassNotFound错误，然后从Extension ClassLoader的类搜索路径下的文件中寻找，一般为环境变量$JRE_HOME/lib/ext路径下，如果也找不到，则抛出ClassNotFound Exception   
  
• App ClassLoader会捕捉ClassNotFound错误，然后从App ClassLoader的类搜索路径下的文件中寻找，一般为环境变量$CLASSPATH路径下，如果找到，则将其读入字节数组，如果也找不到，则抛出ClassNotFound Exception。如果找到，则App ClassLoader调用defineClass()方法。   
  

public class CustomClassLoader extends ClassLoader {


  //需要该类加载器直接加载的类文件的基目录
  private String baseDir;
  public CustomClassLoader(String baseDir, String[] classes) throws IOException {
    super();
    this.baseDir = baseDir;
    loadClassByMe(classes);
  }
  private void loadClassByMe(String[] classes) throws IOException {
    for (int i = 0; i < classes.length; i++) {
      findClass(classes[i]);
    }
  }
  /**
   * 重写findclass方法
   *
   * 在ClassLoader中，loadClass方法先从缓存中找，缓存中没有，会代理给父类查找，如果父类中也找不到，就会调用此用户实现的findClass方法
   *
   * @param name
   * @return
   */
  @Override
  protected Class findClass(String name) {
    Class clazz = null;
    StringBuffer stringBuffer = new StringBuffer(baseDir);
    String className = name.replace('.', File.separatorChar) + ".class";
    stringBuffer.append(File.separator + className);
    File classF = new File(stringBuffer.toString());
    try {
      clazz = instantiateClass(name, new FileInputStream(classF), classF.length());
    } catch (IOException e) {
      e.printStackTrace();
    }
    return clazz;
  }
  private Class instantiateClass(String name, InputStream fin, long len) throws IOException {
    byte[] raw = new byte[(int) len];
    fin.read(raw);
    fin.close();
    return defineClass(name, raw, 0, raw.length);
  }
}

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
{
  synchronized (getClassLoadingLock(name)) {
    // First, check if the class has already been loaded
    Class<?> c = findLoadedClass(name);
    if (c == null) {
      long t0 = System.nanoTime();
      try {
        if (parent != null) {
          c = parent.loadClass(name, false);
        } else {
          c = findBootstrapClassOrNull(name);
        }
      } catch (ClassNotFoundException e) {
        // ClassNotFoundException thrown if class not found
        // from the non-null parent class loader
      }
      if (c == null) {
        // If still not found, then invoke findClass in order
        // to find the class.
        long t1 = System.nanoTime();
        c = findClass(name);
        // this is the defining class loader; record the stats
        sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
        sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
        sun.misc.PerfCounter.getFindClasses().increment();
      }
    }
    if (resolve) {
      resolveClass(c);
    }
    return c;
  }
}

clazz = instantiateClass(name, new FileInputStream(classF), classF.length());
//省略部分逻辑
return defineClass(name, raw, 0, raw.length);

package com.tw.client;
public class Foo {
  public Foo() {
  }
  public void sayHello() {
    System.out.println("hello world22222! (version 11)");
  }
}

public static void main(String[] args) throws Exception {
    while (true) {
      run();
      Thread.sleep(1000);
    }
  }
  /**
   * ClassLoader用来加载class类文件的,实现类的热替换
   * 注意，需要在swap目录下，一层层建立目录com/tw/client/，然后将Foo.class放进去
   * @throws Exception
   */
  public static void run() throws Exception {
    CustomClassLoader customClassLoader = new CustomClassLoader("swap", new String[]{"com.tw.client.Foo"});
    Class clazz = customClassLoader.loadClass("com.tw.client.Foo");
    Object foo = clazz.newInstance();
    Method method = foo.getClass().getMethod("sayHello", new Class[]{});
    method.invoke(foo, new Object[]{});
  }

hello world22222! (version 11)
hello world22222! (version 11)
hello world22222! (version 11)
hello world22222! (version 11)
hello world22222! (version 11)
hello world2222! (version 2)
hello world2222! (version 2)
hello world2222! (version 2)
hello world2222! (version 2)

Foo foo2 = (Foo) clazz.newInstance();
foo2.sayHello();

java.lang.ClassCastException: com.tw.client.Foo cannot be cast to com.tw.client.Foo

IFoo foo2 = (IFoo) clazz.newInstance();
foo2.sayHello();

//设置操作
Thread t = Thread.currentThread();
t.setContextClassLoader(loader);
//获取操作
Thread t = Thread.currentThread();
ClassLoader loader = t.getContextClassLoader();
Class<?> cl = loader.loadClass(className);

public interface HelloService {
  void sayHello(String name);
}
public class HelloServiceProvider implements HelloService {
  @Override
  public void sayHello(String name) {
    System.out.println("Hello " + name);
  }
}
public class NameServiceProvider implements HelloService{
  @Override
  public void sayHello(String name) {
    System.out.println("Hi, your name is " + name);
  }
}

com.tinywhale.deploy.spi.HelloServiceProvider
com.tinywhale.deploy.spi.NameServiceProvider

public static void main(String...args) throws Exception {
    while(true) {
      run();
      Thread.sleep(1000);
    }
  }
  private static void run(){
    ServiceLoader<HelloService> serviceLoader = ServiceLoader.load(HelloService.class);
    for (HelloService helloWorldService : serviceLoader) {
      helloWorldService.sayHello("myname");
    }
  }

Hello myname
Hi, your name is myname
Hello myname
Hi, your name is myname
Hello myname
Hi, your name is myname
Hello myname
Hello myname
Hello myname
Hello myname

public class BizClassLoader extends URLClassLoader {
  public BizClassLoader(URL[] urls) {
    super(urls);
  }
}

<plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-shade-plugin</artifactId>
     <version>2.4.3</version>
     <configuration>
       <!-- 自动将所有不使用的类排除-->
       <minimizeJar>true</minimizeJar>
     </configuration>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>shade</goal>
         </goals>
         <configuration>
           <shadedArtifactAttached>true</shadedArtifactAttached>
           <shadedClassifierName>biz</shadedClassifierName>
         </configuration>
       </execution>
     </executions>
   </plugin>

public static void main(String... args) throws Exception {
     while (true) {
       loadJarFile();
       Thread.sleep(1000);
     }
   }
   /**
  * URLClassLoader 用来加载Jar文件, 直接放在swap目录下即可
  *
  * 动态改变jar中类，可以实现热加载
  *
  * @throws Exception
  */
   public static void loadJarFile() throws Exception {
     File moduleFile = new File("swap\\tinywhale-client-0.0.1-SNAPSHOT-biz.jar");
     URL moduleURL = moduleFile.toURI().toURL();
     URL[] urls = new URL[] { moduleURL };
     BizClassLoader bizClassLoader = new BizClassLoader(urls);
     Class clazz = bizClassLoader.loadClass("com.tw.client.Bar");
     Object foo = clazz.newInstance();
     Method method = foo.getClass().getMethod("sayBar", new Class[]{});
     method.invoke(foo, new Object[]{});
     bizClassLoader.close();
   }

I am bar, Foo's sister, can you catch me ?????????????
I am bar, Foo's sister, can you catch me ?????????????
I am bar, Foo's sister, can you catch me ！！！！
I am bar, Foo's sister, can you catch me ！！！！
I am bar, Foo's sister, can you catch me ！！！！
I am bar, Foo's sister, can you catch me ！！！！

bizClassLoader.close();

/**
 * main方法执行之前执行，manifest需要配置属性Premain-Class，参数配置方式载入
 */
public static void premain(String agentArgs, Instrumentation inst);
/**
 * 程序启动后执行，manifest需要配置属性Agent-Class，Attach附加方式载入
 */
public static void agentmain(String agentArgs, Instrumentation inst);

Premain-class        : main方法执行前执行的agent类.
Agent-class          : 程序启动后执行的agent类.
Can-Redefine-Classes     : agent是否具有redifine类能力的开关，true表示可以，false表示不可以.
Can-Retransform-Classes    : agent是否具有retransform类能力的开关，true表示可以，false表示不可以.
Can-Set-Native-Method-Prefix : agent是否具有生成本地方法前缀能力的开关，trie表示可以，false表示不可以.
Boot-Class-Path        : 此路径会被加入到BootstrapClassLoader的搜索路径.

<plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-shade-plugin</artifactId>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>shade</goal>
         </goals>
       </execution>
     </executions>
   </plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
      <archive>
        <manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
      </archive>
    </configuration>
  </plugin>

//main执行前调用
public class AgentPre {
  public static void premain(String agentArgs, Instrumentation inst) {
    System.out.println("execute premain method");
  }
}
//main主方法入口
public class App {
  public static void main(String... args) throws Exception {
    System.out.println("execute main method ");
  }
}
//main执行后调用
public class AgentMain {
  public static void agentmain(String agentArgs, Instrumentation inst) {
    System.out.println("execute agentmain method");
  }
}

Manifest-Version: 1.0
Premain-Class: com.tinywhale.deploy.javaAgent.AgentPre
Agent-Class: com.tinywhale.deploy.javaAgent.AgentMain

-javaagent:D:\app\tinywhale\tinywhale-deploy\target\tinywhale-deploy-1.0-SNAPSHOT-biz.jar

execute premain method
execute main method

public class App {
  public static void main(String... args) throws Exception {
    System.out.println("execute main method ");
    attach();
  }
  private static void attach() {
    File agentFile = Paths.get("D:\\app\\tinywhale\\tinywhale-deploy\\target\\tinywhale-deploy-1.0-SNAPSHOT.jar").toFile();
    try {
      String name = ManagementFactory.getRuntimeMXBean().getName();
      String pid = name.split("@")[0];
      VirtualMachine jvm = VirtualMachine.attach(pid);
      jvm.loadAgent(agentFile.getAbsolutePath());
    } catch (Exception e) {
      System.out.println(e);
    }
  }
}

execute premain method
execute main method
execute agentmain method

public interface IPluginExecuteStrategy {
  /**
   * 执行方法
   * @param agentArgs
   * @param inst
   */
  void execute(String agentArgs, Instrumentation inst);
}

public class PluginPreMainExecutor implements IPluginExecuteStrategy{


  /**
   * 扫描加载的plugin，识别出@PreMainCondition并加载执行
   */
  @Override
  public void execute(String agentArgs, Instrumentation inst) {
    //获取前置执行集合
    List<String> pluginNames = AgentPluginAnnotationHelper.annoProcess(PreMainCondition.class);
    ServiceLoader<IPluginService> pluginServiceLoader = ServiceLoader.load(IPluginService.class);
    //只执行带有PreMainCondition的插件
    for (IPluginService pluginService : pluginServiceLoader) {
      if (pluginNames.contains(pluginService.getPluginName())) {
        pluginService.pluginLoad(agentArgs, inst);
      }
    }
  }
}

public class PluginAgentMainExecutor implements IPluginExecuteStrategy {


  /**
   * 扫描加载的plugin，识别出@AgentMainCondition并加载执行
   */
  @Override
  public void execute(String agentArgs, Instrumentation inst) {
    //获取后置执行集合
    List<String> pluginNames = AgentPluginAnnotationHelper.annoProcess(AgentMainCondition.class);
    ServiceLoader<IPluginService> pluginServiceLoader = ServiceLoader.load(IPluginService.class);
    for (IPluginService pluginService : pluginServiceLoader) {
      //只执行带有AgentMainCondition的插件
      if (pluginNames.contains(pluginService.getPluginName())) {
        pluginService.pluginLoad(agentArgs, inst);
      }
    }
  }
}

public class AgentPluginContextFactory {
  /**
   * 创建agent pre执行上下文
   * @return
   */
  public static PluginExecutorContext makeAgentPreExecuteContext() {
    IPluginExecuteStrategy strategy = new PluginPreMainExecutor();
    PluginExecutorContext context = new PluginExecutorContext(strategy);
    return context;
  }


  /**
   * 创建agent main执行上下文
   * @return
   */
  public static PluginExecutorContext makeAgentMainExecuteContext() {
    IPluginExecuteStrategy strategy = new PluginAgentMainExecutor();
    PluginExecutorContext context = new PluginExecutorContext(strategy);
    return context;
  }

}

public class AgentPluginPreWrapper {
  public static void premain(String agentArgs, Instrumentation inst) {
    AgentPluginContextFactory.makeAgentPreExecuteContext().execute(agentArgs, inst);
  }

}


public class AgentPluginMainWrapper {
  public static void agentmain(String agentArgs, Instrumentation inst) {
    AgentPluginContextFactory.makeAgentMainExecuteContext().execute(agentArgs, inst);
  }
}

Manifest-Version: 1.0
Premain-Class: org.tiny.upgrade.core.AgentPluginPreWrapper
Agent-Class: org.tiny.upgrade.core.AgentPluginMainWrapper
Permissions: all-permissions
Can-Retransform-Classes: true
Can-Redefine-Classes: true

@AgentMainCondition
@Slf4j
public class CodePadPluginServiceProvider implements IPluginService {

  @Override
  public String getPluginName() {
    return "增强插件";
  }

  @Override
  public void pluginLoad(String agentArgs, Instrumentation inst) {
    //获取已加载的所有类
    Class<?>[] classes = inst.getAllLoadedClasses();
    if (classes == null || classes.length == 0) {
      return;
    }
    //需要将业务类进行retransform一下，这样可以避免在transform执行的时候，找不到此类的情况
    for (Class<?> clazz : classes) {
      if (clazz.getName().contains(entity.getClassName())) {
        try {
          inst.retransformClasses(clazz);
        } catch (UnmodifiableClassException e) {
          log.error("retransform class fail:" + clazz.getName(), e);
        }
      }
    }
    //进行增强操作
    inst.addTransformer(new ByteCodeBizInvoker(), true);
  }

  @Override
  public void pluginUnload() {

  }
}

@Slf4j
public class ByteCodeBizInvoker implements ClassFileTransformer {
  /**
   * 在此处加载tprd-ut并利用类加载器加载
   *
   * @param loader
   * @param className
   * @param classBeingRedefined
   * @param protectionDomain
   * @param classfileBuffer
   * @return
   * @throws IllegalClassFormatException
   */
  @Override
  public byte[] transform(ClassLoader loader
              , String className
              , Class<?> classBeingRedefined
              , ProtectionDomain protectionDomain
              , byte[] classfileBuffer) throws IllegalClassFormatException {
    //java自带的方法不进行处理
    if (loader == null) {
      return null;
    }
    //增强spring5的componetscan，将org.tiny路径塞入
    if (className.contains("ComponentScanBeanDefinitionParser")) {
      try {
        System.out.println("增强spring");
        ClassPool classPool = new ClassPool(true);
        classPool.appendClassPath(ByteCodeBizInvoker.class.getName());

        CtClass ctClass = classPool.get(className.replace("/", "."));
        ClassFile classFile = ctClass.getClassFile();
        MethodInfo methodInfo = classFile.getMethod("parse");
        CtMethod ctMethod = ctClass.getDeclaredMethod("parse");
        addComponentScanPackage(methodInfo, ctMethod);
        return ctClass.toBytecode();
      } catch (Exception e) {
        log.error("handle spring 5 ComponentScanBeanDefinitionParser error", e);
      }
    }
  }
  /**
   * 遍历method，直至找到ReportTracer标记类
   *
   * @param ctMethod
   */
  private void addComponentScanPackage(MethodInfo methodInfo, CtMethod ctMethod) throws CannotCompileException {
    final boolean[] success = {false};
    CodeAttribute ca = methodInfo.getCodeAttribute();
    CodeIterator codeIterator = ca.iterator();
    //行遍历方法体
    while (codeIterator.hasNext()) {
      ExprEditor exprEditor = new ExprEditor() {
        public void edit(MethodCall m) throws CannotCompileException {
          String methodCallName = m.getMethodName();
          if (methodCallName.equals("getAttribute")) {
            //将org.tiny追加进去
            m.replace("{ $_ = $proceed($$); $_ = $_ +  ",org.tiny.upgrade";  }");
            success[0] = true;
          }
        }
      };
      ctMethod.instrument(exprEditor);
      if (success[0]) {
        break;
      }
    }
  }
}

public class TinyPluginClassLoader extends URLClassLoader {
  /**
   * 带参构造
   * @param urls
   */
  public TinyPluginClassLoader(URL[] urls, ClassLoader parent) {
    super(urls, parent);
  }
  /**
   * 添加URL路径
   * @param url
   */
  public void addURL(URL url) {
    super.addURL(url);
  }
}

URL url = new URL("jar:file:/D:/project/tiny-plugin-hello/target/tiny-plugin-hello-1.0-SNAPSHOT.jar!/")

URL url = new URL("jar:http://111.111.111.111/tiny-plugin-hello-1.0-SNAPSHOT.jar!/")

/**
   * 从jar文件中提取出对应的插件类
   *
   * @param pluginClass
   * @param jarFile
   * @return
   */
  public static Set<Class> loadPluginFromJarFile(Class pluginClass, JarFile jarFile, TinyPluginClassLoader tinyPluginClassLoader) {
    Set<Class> pluginClasses = new HashSet<Class>();
    Enumeration<JarEntry> jars = jarFile.entries();
    while (jars.hasMoreElements()) {
      JarEntry jarEntry = jars.nextElement();
      String jarEntryName = jarEntry.getName();
      if (jarEntryName.charAt(0) == '/') {
        jarEntryName = jarEntryName.substring(1);
      }
      if (jarEntry.isDirectory() || !jarEntryName.endsWith(".class")) {
        continue;
      }
      String className = jarEntryName.substring(0, jarEntryName.length() - 6);
      try {
        Class clazz = tinyPluginClassLoader.loadClass(className.replace("/", "."));
        if (clazz != null && !clazz.isInterface() && pluginClass.isAssignableFrom(clazz)) {
          pluginClasses.add(clazz);
        }
      } catch (ClassNotFoundException e) {
        log.error("PluginUtil.loadPluginFromJarFile fail",e);
      }
    }
    return pluginClasses;
  }

/**
   * 加载插件
   *
   * @return
   */
  @Override
  public Set<Class> loadPlugins(URL jarURL) {
    try {
      JarFile jarFile = ((JarURLConnection) jarURL.openConnection()).getJarFile();
      getTinyPluginClassLoader().addURL(jarURL);
      return PluginUtil.loadPluginFromJarFile(IPluginService.class, jarFile, getTinyPluginClassLoader());
    } catch (IOException e) {
      log.error("LoadPluginViaJarStrategy.loadPlugins fail", e);
      return null;
    }
  }

/**
   * 执行插件
   */
  public void processPlugins(URL... urls) {
    if (urls == null || urls.length == 0) {
      log.error("jar url path empty");
      return;
    }
    for (URL url : urls) {
      pluginLoadFactory.loadJarPlugins(url);
    }
    ServiceLoader<IPluginService> serviceLoader = ServiceLoader.load(IPluginService.class, pluginLoadFactory.getPluginLoader());
    for (IPluginService pluginService : serviceLoader) {
      pluginService.Process();
    }
  }