Java Instrumentation.getAllLoadedClasses方法代码示例

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包/类
public static List<String> loadedClasses() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    List<String> rtn = new ArrayList<>();
    Instrumentation inst = instrumentation();
    Class[] classes = inst.getAllLoadedClasses();

    for(Class c:classes){
        rtn.add(c.getName());
    }
    return rtn;
}
 

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public static void agentmain(String arg,Instrumentation inst) throws AttachNotSupportedException, IOException
{
	MyAgent.inst=inst;
	System.out.println("agent代理程序类[MyAgent]被执行!");
	System.out.println("当前代理程序类使用加载器:"+Thread.currentThread().getContextClassLoader().toString());
	num.incrementAndGet();
	System.out.println(num.longValue());
	System.out.println(arg);
	Class<?>[] classes = inst.getAllLoadedClasses();
       for(Class<?> cls :classes)
       {
           System.out.println(cls.getName());
       }
}
 

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

import java.lang.instrument.Instrumentation; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    Instrumentation inst = Agent.inst;
    if (inst == null)
        throw new RuntimeException("Agent not loaded");

    // check boot class path has been extended
    Class<?> helper = Class.forName("AgentHelper");
    if (helper.getClassLoader() != null)
        throw new RuntimeException("AgentHelper not loaded by boot loader");

    // check Instrumentation object can be used
    Class<?>[] classes = inst.getAllLoadedClasses();
    System.out.println(classes.length + " classes loaded");
}