public class HotClassLoader extends ClassLoader {
    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
            InputStream is = this.getClass().getResourceAsStream(fileName);
            byte[] b = new byte[is.available()];
            is.read(b);
            return defineClass(name, b, 0, b.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name);
        }
    }
}


public static void test() throws Exception {
	loadHelloWorld();
	Thread.sleep(10000);
	System.out.println("============= new =============");
	loadHelloWorld();
}

public static void loadHelloWorld() throws Exception {
	HotClassLoader myLoader = new HotClassLoader();
	Class<?> clazz = myLoader.findClass("com.hot.Hello");
	Object obj = clazz.newInstance();
	Method method = clazz.getMethod("say");
	method.invoke(obj);
	System.out.println(obj.getClass());
	System.out.println(obj.getClass().getClassLoader());
}

for (int i = 0; i < 5; i++) {
	URL classUrl = new URL("file:E:\\workspace\\test\\target\\classes\\");
	URLClassLoader loader = new URLClassLoader(new URL[]{classUrl});
	Class<?> clazz = loader.loadClass("com.hot.Hello");
	Object obj = clazz.newInstance();
	clazz.getMethod("say").invoke(obj);
	System.out.println(obj.getClass().getClassLoader());

	loader.close();
	Thread.sleep(1000 * 5);
}

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();
				// 都没找到，使用findClass方法
				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;
	}
}

public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
	int var3 = var1.lastIndexOf(46);
	if (var3 != -1) {
		SecurityManager var4 = System.getSecurityManager();
		if (var4 != null) {
			var4.checkPackageAccess(var1.substring(0, var3));
		}
	}

	if (this.ucp.knownToNotExist(var1)) {
		Class var5 = this.findLoadedClass(var1);
		if (var5 != null) {
			if (var2) {
				this.resolveClass(var5);
			}

			return var5;
		} else {
			throw new ClassNotFoundException(var1);
		}
	} else {
		return super.loadClass(var1, var2);
	}
}

public static void rootLoader(String args[]) {
	String conf = System.getProperty("groovy.starter.conf",null);
	final LoaderConfiguration lc = new LoaderConfiguration();
	// ...
	while (args.length-argsOffset>0 && !(hadMain && hadConf && hadCP)) {
		// ...
		} else if (args[argsOffset].equals("--main")) {
			if (hadMain) break;
			if (args.length==argsOffset+1) {
				exit("main parameter needs argument");
			}
			lc.setMainClass(args[argsOffset+1]);
			argsOffset+=2;
			hadMain=true;
		} else if (args[argsOffset].equals("--conf")) {
			if (hadConf) break;
			if (args.length==argsOffset+1) {
				exit("conf parameter needs argument");
			}
			conf=args[argsOffset+1];
			argsOffset+=2;
			hadConf=true;
		} // ...
	}
	// this allows to override the commandline conf
	String confOverride = System.getProperty("groovy.starter.conf.override",null);
	if (confOverride!=null) conf = confOverride;
	// ...
	// load configuration file
	// 解析$GROOVY_HOME/conf/groovy-starter.conf文件，里面加载了一些jar包
	lc.configure(new FileInputStream(conf));
	// ...
	// create loader and execute main class，创建的就是RootLoader
	ClassLoader loader = AccessController.doPrivileged(new PrivilegedAction<RootLoader>() {
		public RootLoader run() {
			// 负责加载Groovy及其依赖的第三方库中的类，以及管理classPathUrls(对Java原有的ClassLoader是不可见)
			return new RootLoader(lc);
		}
	});
	// ...
	Class c = loader.loadClass(lc.getMainClass());
    m = c.getMethod("main", new Class[]{String[].class});
	m.invoke(null, new Object[]{newArgs});
	// ...
}

// 省略异常处理
private boolean run() {
	if (processSockets) {
		processSockets();
	} else if (processFiles) {
		processFiles();
	} else {
		processOnce();
	}
	return true;
}

public GroovyShell(ClassLoader parent, Binding binding, final CompilerConfiguration config) {
	// ...
	final ClassLoader parentLoader = (parent!=null)?parent:GroovyShell.class.getClassLoader();
	this.loader = AccessController.doPrivileged(new PrivilegedAction<GroovyClassLoader>() {
		public GroovyClassLoader run() {
			return new GroovyClassLoader(parentLoader,config);
		}
	});
	// ...
}

protected synchronized Class loadClass(final String name, boolean resolve) throws ClassNotFoundException {
	Class c = this.findLoadedClass(name);
	if (c != null) return c;
	// customClasses定义了一些必须由Java原有ClassLoader载入的类  
	c = customClasses.get(name);
	if (c != null) return c;

	try {
		// 先尝试加载这个类  
		c = oldFindClass(name);
	} catch (ClassNotFoundException cnfe) {
		// IGNORE
	}
	// 加载不到则回到原有的双亲委派模型  
	if (c == null) c = super.loadClass(name, resolve);

	if (resolve) resolveClass(c);

	return c;
}

private Class doParseClass(GroovyCodeSource codeSource) {
	// 简单校验一些参数是否为null
	validate(codeSource);
	Class answer;  // Was neither already loaded nor compiling, so compile and add to cache.
	// 创建CompilationUnit，构造方法中会初始化1个加载类的加载器(this)和1个AST transformations的加载器(null)
	CompilationUnit unit = createCompilationUnit(config, codeSource.getCodeSource());
	if (recompile!=null && recompile || recompile==null && config.getRecompileGroovySource()) {
		unit.addFirstPhaseOperation(TimestampAdder.INSTANCE, CompilePhase.CLASS_GENERATION.getPhaseNumber());
	}
	SourceUnit su = null;
	File file = codeSource.getFile();
	if (file != null) {
		su = unit.addSource(file);
	} else {
		URL url = codeSource.getURL();
		if (url != null) {
			su = unit.addSource(url);
		} else {
			su = unit.addSource(codeSource.getName(), codeSource.getScriptText());
		}
	}
	
	// 这里创建了InnerLoader 
	ClassCollector collector = createCollector(unit, su);
	unit.setClassgenCallback(collector);
	int goalPhase = Phases.CLASS_GENERATION;
	if (config != null && config.getTargetDirectory() != null) goalPhase = Phases.OUTPUT;
	// 编译groovy源代码  
	unit.compile(goalPhase);

	answer = collector.generatedClass;
	// 查找源文件中的Main Class 
	String mainClass = su.getAST().getMainClassName();
	for (Object o : collector.getLoadedClasses()) {
		Class clazz = (Class) o;
		String clazzName = clazz.getName();
		definePackageInternal(clazzName);
		setClassCacheEntry(clazz);
		if (clazzName.equals(mainClass)) answer = clazz;
	}
	return answer;
}

public Class loadClass(final String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve)
		throws ClassNotFoundException, CompilationFailedException {
	// look into cache
	Class cls = getClassCacheEntry(name);

	// enable recompilation?
	boolean recompile = isRecompilable(cls);
	if (!recompile) return cls;

	// try parent loader
	ClassNotFoundException last = null;
	try {
		// 委托父类加载
		Class parentClassLoaderClass = super.loadClass(name, resolve);
		// always return if the parent loader was successful
		if (cls != parentClassLoaderClass) return parentClassLoaderClass;
	} catch (ClassNotFoundException cnfe) {
		last = cnfe;
	} catch (NoClassDefFoundError ncdfe) {
		if (ncdfe.getMessage().indexOf("wrong name") > 0) {
			last = new ClassNotFoundException(name);
		} else {
			throw ncdfe;
		}
	}

	// check security manager
	SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
		String className = name.replace('/', '.');
		int i = className.lastIndexOf('.');
		// no checks on the sun.reflect classes for reflection speed-up
		// in particular ConstructorAccessorImpl, MethodAccessorImpl, FieldAccessorImpl and SerializationConstructorAccessorImpl
		// which are generated at runtime by the JDK
		if (i != -1 && !className.startsWith("sun.reflect.")) {
			sm.checkPackageAccess(className.substring(0, i));
		}
	}

	// prefer class if no recompilation
	if (cls != null && preferClassOverScript) return cls;

	// at this point the loading from a parent loader failed
	// and we want to recompile if needed.
	if (lookupScriptFiles) {
		// try groovy file
		try {
			// check if recompilation already happened.
			final Class classCacheEntry = getClassCacheEntry(name);
			if (classCacheEntry != cls) return classCacheEntry;
			URL source = resourceLoader.loadGroovySource(name);
			// if recompilation fails, we want cls==null
			Class oldClass = cls;
			cls = null;
			cls = recompile(source, name, oldClass);
		} catch (IOException ioe) {
			last = new ClassNotFoundException("IOException while opening groovy source: " + name, ioe);
		} finally {
			if (cls == null) {
				removeClassCacheEntry(name);
			} else {
				setClassCacheEntry(cls);
			}
		}
	}

	if (cls == null) {
		// no class found, there should have been an exception before now
		if (last == null) throw new AssertionError(true);
		throw last;
	}
	return cls;
}

protected ClassCollector createCollector(CompilationUnit unit, SourceUnit su) {
	InnerLoader loader = AccessController.doPrivileged(new PrivilegedAction<InnerLoader>() {
		public InnerLoader run() {
			// 每次编译groovy源代码都会创建一个新的InnerLoader
			return new InnerLoader(GroovyClassLoader.this);
		}
	});
	return new ClassCollector(loader, unit, su);
}


// 在编译的过程中，将编译出来的字节码，通过InnerLoader进行加载
public static class ClassCollector extends CompilationUnit.ClassgenCallback {
	// ...
	protected Class createClass(byte[] code, ClassNode classNode) {
		BytecodeProcessor bytecodePostprocessor = unit.getConfiguration().getBytecodePostprocessor();
		byte[] fcode = code;
		if (bytecodePostprocessor!=null) {
			fcode = bytecodePostprocessor.processBytecode(classNode.getName(), fcode);
		}
		GroovyClassLoader cl = getDefiningClassLoader();
		Class theClass = cl.defineClass(classNode.getName(), fcode, 0, fcode.length, unit.getAST().getCodeSource());
		this.loadedClasses.add(theClass);

		if (generatedClass == null) {
			ModuleNode mn = classNode.getModule();
			SourceUnit msu = null;
			if (mn != null) msu = mn.getContext();
			ClassNode main = null;
			if (mn != null) main = (ClassNode) mn.getClasses().get(0);
			if (msu == su && main == classNode) generatedClass = theClass;
		}

		return theClass;
	}
	// ...
}

// CompilationUnit
// throughPhase：Phases.CLASS_GENERATION 7，即从步骤1做到步骤7
// 		INITIALIZATION        = 1;   // Opening of files and such
// 		PARSING               = 2;   // Lexing, parsing, and AST building
// 		CONVERSION            = 3;   // CST to AST conversion
// 		SEMANTIC_ANALYSIS     = 4;   // AST semantic analysis and elucidation
// 		CANONICALIZATION      = 5;   // AST completion
// 		INSTRUCTION_SELECTION = 6;   // Class generation, phase 1
// 		CLASS_GENERATION      = 7;   // Class generation, phase 2
// 		OUTPUT                = 8;   // Output of class to disk
// 		FINALIZATION          = 9;   // Cleanup
//		ALL                   = 9;   // Synonym for full compilation
public void compile(int throughPhase) throws CompilationFailedException {
	// 保证不处理旧代码
	gotoPhase(Phases.INITIALIZATION);
	throughPhase = Math.min(throughPhase, Phases.ALL);

    while (throughPhase >= phase && phase <= Phases.ALL) {
		// 步骤4
		if (phase == Phases.SEMANTIC_ANALYSIS) {
			doPhaseOperation(resolve);
			if (dequeued()) continue;
		}
		// ---> 最后的步骤7有2个操作：CompilationUnit和ASTTransformationVisitor
		processPhaseOperations(phase);
		// Grab processing may have brought in new AST transforms into various phases, process them as well
		processNewPhaseOperations(phase);
		// ...
	}
	// ...
}
	
	
// body：CompilationUnit
// 在AST抽象语法树上循环操作所有主要的ClassNodes
public void applyToPrimaryClassNodes(PrimaryClassNodeOperation body) throws CompilationFailedException {
	for (ClassNode classNode : getPrimaryClassNodes(body.needSortedInput())) {
		SourceUnit context = null;
		context = classNode.getModule().getContext();
		if (context == null || context.phase < phase || (context.phase == phase && !context.phaseComplete)) {
			int offset = 1;
			for (Iterator<InnerClassNode> iterator = classNode.getInnerClasses(); iterator.hasNext(); ) {
				iterator.next();
				offset++;
			}
			// 
			body.call(context, new GeneratorContext(this.ast, offset), classNode);
		}
	}
}

private PrimaryClassNodeOperation classgen = new PrimaryClassNodeOperation() {
	// ...
	public void call(SourceUnit source, GeneratorContext context, ClassNode classNode) throws CompilationFailedException {
		// ...
		// Run the Verifier on the outer class
		verifier.visitClass(classNode);
		// ...
		// Prep the generator machinery
		// 返回一个groovyjarjarasm.asm.ClassWriter
		ClassVisitor visitor = createClassVisitor();
		// ...
		AsmClassGenerator generator = new AsmClassGenerator(source, context, visitor, sourceName);
		// Run the generation and create the class (if required)
		// 
		generator.visitClass(classNode);
		byte[] bytes = ((ClassWriter) visitor).toByteArray();
		generatedClasses.add(new GroovyClass(classNode.getName(), bytes));
		// Handle any callback that's been set
		if (CompilationUnit.this.classgenCallback != null) {
			classgenCallback.call(visitor, classNode);
		}
		// Recurse for inner classes
		LinkedList innerClasses = generator.getInnerClasses();
		while (!innerClasses.isEmpty()) {
			classgen.call(source, context, (ClassNode) innerClasses.removeFirst());
		}
	}
}		

public class ASMGettingStarted {
    /**
     * 动态创建一个类，有一个无参数的构造函数
     */
    static ClassWriter createClassWriter(String className) {
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        //声明一个类，使用JDK1.8版本，public的类，父类是java.lang.Object，没有实现任何接口
        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", null);

        //初始化一个无参的构造函数
        MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
        constructor.visitVarInsn(Opcodes.ALOAD, 0);
        //执行父类的init初始化
        constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
        //从当前方法返回void
        constructor.visitInsn(Opcodes.RETURN);
        constructor.visitMaxs(1, 1);
        constructor.visitEnd();
        return cw;
    }

    /**
     * 创建一个run方法，里面只有一个输出
     * public void run()
     * {
     * System.out.println(message);
     * }
     *
     * @return
     * @throws Exception
     */
    static byte[] createVoidMethod(String className, String message) throws Exception {
        //注意，这里需要把classname里面的.改成/，如com.asm.Test改成com/asm/Test
        ClassWriter cw = createClassWriter(className.replace('.', '/'));

        //创建run方法
        //()V表示函数，无参数，无返回值
        MethodVisitor runMethod = cw.visitMethod(Opcodes.ACC_PUBLIC, "run", "()V", null, null);
        //先获取一个java.io.PrintStream对象
        runMethod.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        //将int, float或String型常量值从常量池中推送至栈顶  (此处将message字符串从常量池中推送至栈顶[输出的内容])
        runMethod.visitLdcInsn(message);
        //执行println方法（执行的是参数为字符串，无返回值的println函数）
        runMethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        runMethod.visitInsn(Opcodes.RETURN);
        runMethod.visitMaxs(1, 1);
        runMethod.visitEnd();

        return cw.toByteArray();
    }

    public static void main(String[] args) throws Exception {
        String className = "com.testAsm.MyAsmTest";
        byte[] classData = createVoidMethod(className, "hello ASM");
        Class<?> clazz = new GeneratorClassLoader().defineClassForName(className, classData);
//        clazz.getMethods()[0].invoke(clazz.newInstance());
        Object obj = clazz.newInstance();
        clazz.getMethod("run").invoke(obj);
        System.out.println(obj.getClass().getName());
    }

    private static class GeneratorClassLoader extends ClassLoader {

        public Class defineClassForName(String className, byte[] classFile) throws ClassFormatError {
            return defineClass(className, classFile, 0, classFile.length);
        }
    }
}

public static void main(String[] args) throws IOException {
	ClassWriter cw = new ClassWriter(0);

	//通过visit方法确定类的头部信息
	cw.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT + Opcodes.ACC_INTERFACE,
			"com/testAsm/MyAsmInterface", null, "java/lang/Object", new String[]{"com/testAsm/a/HelloAsm"});

	//定义类的属性
	cw.visitField(Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_STATIC,
			"LESS", "I", null, new Integer(-1)).visitEnd();
	cw.visitField(Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_STATIC,
			"EQUAL", "I", null, new Integer(0)).visitEnd();
	cw.visitField(Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_STATIC,
			"GREATER", "I", null, new Integer(1)).visitEnd();

	//定义类的方法
	cw.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT, "myMethod",
			"(Ljava/lang/Object;)I", null, null).visitEnd();
	cw.visitEnd(); //使cw类已经完成

	//将cw转换成字节数组写到文件里面去
	byte[] data = cw.toByteArray();
	File file = new File("E:\\workspace\\test\\target\\classes\\com\\testAsm\\a\\MyAsmInterface.class");
	FileOutputStream fout = new FileOutputStream(file);
	fout.write(data);
	fout.close();
}

package com.testAsm;

import com.testAsm.a.HelloAsm;

public abstract interface MyAsmInterface
  extends HelloAsm
{
  public static final int LESS = -1;
  public static final int EQUAL = 0;
  public static final int GREATER = 1;
  
  public abstract int myMethod(Object paramObject);
}