JVM自定义类加载器在代码扩展性的实践

  

• 通过一个类的全限定名来获取定义此类的二进制字节流。
    
  
• 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
    
  
• 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
  
  

  

• protected Class loadClass(String name, boolean resolve)：name为类名，resove如果为true，在加载时解析该类。
    
  
• protected Class findClass(String name) ：根据指定类名来查找类。
  
  

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

  

• 判断此类是否已经加载；
    
  
• 如果父加载器不为null，则使用父加载器进行加载；反之，使用根加载器进行加载；
    
  
• 如果前面都没加载成功，则使用findClass方法进行加载。
  
  

public class DynamicClassLoader extends ClassLoader {
 
  private static final String CLASS_EXTENSION = "class";
 
  @Override
  public Class<?> findClass(String encryptClassInfo) {
    EncryptClassInfo info = JSON.parseObject(encryptClassInfo, EncryptClassInfo.class);
    String filePath = info.getAbsoluteFilePath();
    String systemPath = System.getProperty("java.io.tmpdir");
    String normalizeFileName = FilenameUtils.normalize(filePath, true);
    if (StringUtils.isEmpty(normalizeFileName) || !normalizeFileName.startsWith(systemPath)
        ||getApkFileExtension(normalizeFileName) == null
        || !CLASS_EXTENSION.equals(getApkFileExtension(normalizeFileName))) {
      return null;
    }
 
    String className = info.getEncryptClassName();
    byte[] classBytes = null;
    File customEncryptFile = new File(filePath);
    try {
      Path path = Paths.get(customEncryptFile.toURI());
      classBytes = Files.readAllBytes(path);
    } catch (IOException e) {
      log.info("加密错误", e);
    }
    if (classBytes != null) {
      return defineClass(className, classBytes, 0, classBytes.length);
    }
    return null;
  }
 
  private static String getApkFileExtension(String fileName) {
    int index = fileName.lastIndexOf(".");
    if (index != -1) {
      return fileName.substring(index + 1);
    }
    return null;
  }
}

public String encrypt(String rawString) {
    String keyString = "R.string.0x7f050001";
    byte[] enByte = encryptField(keyString, rawString.getBytes());
    return Base64.encode(enByte);
  }

public class EncryptStringHandler {
 
  private static final Map<String, Class<?>> classMameMap = new HashMap<>();
 
  @Autowired
  private VivofsFileHelper vivofsFileHelper;
 
  @Autowired
  private DynamicClassLoader dynamicClassLoader;
 
  public String encryptString(String fileId, String encryptClassName, String fileContent) {
    try {
      Class<?> clazz = obtainEncryptClass(fileId, encryptClassName);
      Object obj = clazz.newInstance();
      Method method = clazz.getMethod("encrypt", String.class);
      String encryptStr = (String) method.invoke(obj, fileContent);
      log.info("原字符串为:{},加密后的字符串为:{}", fileContent, encryptStr);
      return encryptStr;
    } catch (Exception e) {
      log.error("自定义加载器加载加密类异常", e);
      return null;
    }
  }
 
  private Class<?> obtainEncryptClass(String fileId, String encryptClassName) {
    Class<?> clazz = classMameMap.get(encryptClassName);
    if (clazz != null) {
      return clazz;
    }
 
    String absoluteFilePath = null;
    try {
      String domain = VivoConfigManager.getString("vivofs.host");
      String fullPath = domain + "/" + fileId;
      File classFile = vivofsFileHelper.downloadFileByUrl(fullPath);
      absoluteFilePath = classFile.getAbsolutePath();
      EncryptClassInfo encryptClassInfo = new EncryptClassInfo(encryptClassName, absoluteFilePath);
      String info = JSON.toJSONString(encryptClassInfo);
      clazz = dynamicClassLoader.findClass(info);
      //设置缓存
      Assert.notNull(clazz, "自定义类加载器加载加密类异常");
      classMameMap.put(encryptClassName, clazz);
      return clazz;
    } finally {
      if (absoluteFilePath != null) {
        FileUtils.deleteQuietly(new File(absoluteFilePath));
      }
    }
  }
}

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

  

• 部署在同一个服务器上的两个web应用程序所使用的Java类库可以实现相互隔离；
    
  
• 部署在同一个服务器上的两个web应用程序所使用的Java类库可以实现共享；
    
  
• 服务器需要尽可能保证自身安全，服务器所使用的类库应该与应用程序的类库相互独立；
    
  
• 支持JSP应用的Web服务器，大对数需要支持HotSwap功能。
  
  

@Slf4j
@Component
public class Test implements ApplicationListener<ContextRefreshedEvent> {
 
  @Override
  public void onApplicationEvent(ContextRefreshedEvent event) {
    log.info("classLoader DynamicClassLoader:" + DynamicClassLoader.class.getClassLoader().toString());
  }
}

public DynamicClassLoader() {
    super(DynamicClassLoader.class.getClassLoader());
}

public String encrypt(String rawString) {
    log.info("classLoader Base64:{}", Base64.class.getClassLoader().toString());
    String keyString = "R.string.0x7f050001";
    byte[] enByte = encryptField(keyString, rawString.getBytes());
    return Base64.encode(enByte);
  }

public String encrypt(String rawString) {
    System.out.println("类加载器详情...");
    System.out.println("classLoader EncryptStrategyHandler:" + EncryptStrategyHandlerH.class.getClassLoader().toString());
    System.out.println("classLoader EncryptStrategyHandler:" + EncryptStrategyHandlerH.class.getClassLoader().getParent().toString());
    String classPath = System.getProperty("java.class.path");
    System.out.println("classPath:" + classPath);
    System.out.println("classLoader Base64:" + Base64.class.getClassLoader().toString());
    String keyString = "R.string.0x7f050001";
    byte[] enByte = encryptField(keyString, rawString.getBytes());
    return Base64.encode(enByte);
  }

作者：vivo互联网服务器团队-Wang Fei