Java Instrumentation.retransformClasses方法代码示例

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
/**
 * 初始化类字节码的转换器
 *
 * @param inst 用于管理字节码转换器
 */
private static void initTransformer(Instrumentation inst) throws UnmodifiableClassException {
    LinkedList<Class> retransformClasses = new LinkedList<Class>();
    CustomClassTransformer customClassTransformer = new CustomClassTransformer();
    inst.addTransformer(customClassTransformer, true);
    Class[] loadedClasses = inst.getAllLoadedClasses();
    for (Class clazz : loadedClasses) {
        for (final AbstractClassHook hook : customClassTransformer.getHooks()) {
            if (hook.isClassMatched(clazz.getName().replace(".", "/"))) {
                if (inst.isModifiableClass(clazz) && !clazz.getName().startsWith("java.lang.invoke.LambdaForm")) {
                    retransformClasses.add(clazz);
                }
            }
        }
    }
    // hook已经加载的类
    Class[] classes = new Class[retransformClasses.size()];
    retransformClasses.toArray(classes);
    if (classes.length > 0) {
        inst.retransformClasses(classes);
    }
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public static void premain(String args, Instrumentation instrumentation) {
    if (!instrumentation.isRetransformClassesSupported()) {
        System.out.println("Class retransformation is not supported.");
        return;
    }
    System.out.println("Calling lambda to ensure that lambda forms were created");

    Agent.lambda.run();

    System.out.println("Registering class file transformer");

    instrumentation.addTransformer(new Agent());

    for (Class c : instrumentation.getAllLoadedClasses()) {
        if (c.getName().contains("LambdaForm") &&
            instrumentation.isModifiableClass(c)) {
            System.out.format("We've found a modifiable lambda form: %s%n", c.getName());
            try {
                instrumentation.retransformClasses(c);
            } catch (UnmodifiableClassException e) {
                throw new AssertionError("Modification of modifiable class " +
                                         "caused UnmodifiableClassException", e);
            }
        }
    }
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
private static void reloadClass(Class seleClass) throws Exception {
    if (!isLoaded) {
        startUp();
    }
    Instrumentation inst = instrumentation();

    inst.retransformClasses(seleClass);
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public synchronized static void removeMetricsClass(String name) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, UnmodifiableClassException {
    Class seleClass = Class.forName(name.replace('/', '.'));
    needRecoverClasses.put(name, needMetricsClasses.remove(name));
    Instrumentation inst = instrumentation();
    inst.retransformClasses(seleClass);
    MetricsCollector.getCollector().removeClassMetrics(name);
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public synchronized static Map<String, Object> removeDebugClassByTraceId(String traceId,boolean isForce) throws NotFoundException {
    String className = null;
    logger.debug("ready remove "+traceId);
    Map<String, Object> rtn = DebugTool.removeTraceInfo(traceId);

    for (Map.Entry<String, DebugInfo> entry : debugClassInfos.entrySet()) {
        if (traceId.equals(entry.getValue().getTraceId())) {
            className = entry.getKey();
            break;
        }
    }
    if (className == null) {
        throw  new NotFoundException("no debug class found by traceid "+traceId);
    }

    if(rtn != null || isForce) {
        try {

            Class seleClass = Class.forName(className.replace('/', '.'));
            debugClassInfos.remove(className);
            needRecoverClasses.put(className, needDebugClasses.remove(className));
            Instrumentation inst = instrumentation();
            inst.retransformClasses(seleClass);
        } catch (Throwable e) {
            logger.error("recover debug class failed!", e);
        }
    }
    return rtn;

}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
@Override
public void rewriteIfPossible(Class<?> declaringClass) throws IllegalStateException {
  Instrumentation instrumentation = checkInstrumentation();
  
  /*
  byte[] bytecode;
  ClassLoader loader = declaringClass.getClassLoader();
  try(InputStream input = loader.getResourceAsStream(declaringClass.getName().replace('.', '/') + ".class")) {
    if (input == null) {
      throw new IllegalStateException("no input");
    }

    Function<String, Optional<InputStream>> classFileFinder = internalName -> Optional.ofNullable(loader.getResourceAsStream(internalName + ".class"));
    bytecode = Rewriter.rewrite(input, classFileFinder);
  } catch (IOException e) {
    throw new IllegalStateException(e);
  }
  
  try {
    instrumentation.redefineClasses(new ClassDefinition(declaringClass, bytecode));
  } catch (ClassNotFoundException | UnmodifiableClassException e) {
    throw new IllegalStateException(e);
  }*/
  
  try {
    instrumentation.retransformClasses(declaringClass);
  } catch (UnmodifiableClassException e) {
    throw new IllegalStateException(e);
  }
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public static void agentmain(@SuppressWarnings("unused") String args, Instrumentation inst) throws Exception {
    if (inst.isRedefineClassesSupported() && inst.isRetransformClassesSupported()) {
        inst.addTransformer(new Redefiner(), true);
        Class<?>[] allClasses = inst.getAllLoadedClasses();
        for (int i = 0; i < allClasses.length; i++) {
            Class<?> c = allClasses[i];
            if (c == Intrinsic.class) {
                inst.retransformClasses(new Class<?>[]{c});
            }
        }
    }
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public static void premain(String agentArgs, Instrumentation inst) throws Exception {
    LoggingTransformer t = new LoggingTransformer();
    inst.addTransformer(t, true);
    {
        Class demoClass = Class.forName("RedefineLeak$Tester");

        for (int i = 0; i < 10000; i++) {
           inst.retransformClasses(demoClass);
        }
    }
    System.gc();
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public static void redefine(String agentArgs, Instrumentation instrumentation, Class to_redefine) {

        try {
            instrumentation.retransformClasses(to_redefine);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public static void agentmain(@SuppressWarnings("unused") String args, Instrumentation inst) throws Exception {
    if (inst.isRedefineClassesSupported() && inst.isRetransformClassesSupported()) {
        inst.addTransformer(new FooTransformer(), true);
        Class<?>[] allClasses = inst.getAllLoadedClasses();
        for (int i = 0; i < allClasses.length; i++) {
            Class<?> c = allClasses[i];
            if (c == Foo.class) {
                inst.retransformClasses(new Class<?>[]{c});
            }
        }
    }
}