// 判断当前类加载器是否是自定义的WClassLoader
if (!Attach.class.getClassLoader().toString().startsWith(WClassLoader.class.getName())) {
    // 如果不是的话，则检查jdk版本是否是1.8
    String jdkVersion = System.getProperty("java.version");
    if (jdkVersion.startsWith("1.")) {
        if (jdkVersion.startsWith("1.8")) {
            try {
                // 如果是1.8则用自定义的类加载器加载当前类
                // 这个类加载器中会指定当前jar包路径 + tools.jar路径
                // parent指向AppClassLoader的parent，即ext classloader
                // 这样与原来的loader对齐
                WClassLoader customClassLoader = new WClassLoader(
                        new URL[]{toolsJarUrl(), currentUrl()},
                        ClassLoader.getSystemClassLoader().getParent()
                );
                // 重新用WClassLoader加载当前类
                Class<?> mainClass = Class.forName("w.Attach", true, customClassLoader);
                Method mainMethod = mainClass.getMethod("main", String[].class);
                // 并运行main方法，此时会重新进入到这段代码，但是第一行的判断
                // 就是由WClassLoader加载的，会跳过这段
                mainMethod.invoke(null, (Object) args);
                return;
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(-1);
            }
        } else {
            Global.error(jdkVersion + " is not supported");
            return;
        }
    }
}
// 这里可以使用tools中的类了
List<VirtualMachineDescriptor> jps = VirtualMachine.list();
Copy

if (javaVersion.startsWith("1.8")) {
    // urlClassLoader来加载tools.jar
    URLClassLoader urlClassLoader = new URLClassLoader(
        new URL[]{toolsJarURL()}
    );
}
List<VirtualMachineDescriptor> jps = VirtualMachine.list();
Copy

class ExecClassLoader extends ClassLoader {
    public ExecClassLoader(ClassLoader parent) {
        super(parent);
    }
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (!name.equals(EXEC_CLASS)) {
            return super.loadClass(name);
        }
        try {
            byte[] bytes = WCompiler.compileWholeClass("package w; public class Exec { public void exec() {} }");
            return defineClass(EXEC_CLASS, bytes, 0, bytes.length);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
Copy

Class<?> c = new ExecClassLoader(springClassLoader()).loadClass("w.Exec");
Object inst = c.newInstance();
inst.getClass().getDeclaredMethod("exec").invoke(inst);
Copy

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-shade-plugin</artifactId>
	<version>3.5.0</version>
	<configuration>
		<relocations>
			<relocation>
				<pattern>com.fasterxml.jackson</pattern>
				<shadedPattern>wshade.com.fasterxml.jackson</shadedPattern>
			</relocation>
		</relocations>
	</configuration>
	<executions>
		<execution>
			<phase>package</phase>
			<goals>
				<goal>shade</goal>
			</goals>
		</execution>
	</executions>
</plugin>
Copy

GroovyScriptEngineImpl engine = 
    new GroovyScriptEngineImpl(new GroovyClassLoader(springClassLoader()));
Copy

class WGroovyClassLoader extends URLClassLoader {
    public WGroovyClassLoader(ClassLoader parent) throws Exception {
        super(new URL[] { currentUrl() }, parent);
    }
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (name.startsWith("org.apache.groovy") || name.startsWith("org.codehaus.groovy") || name.startsWith("groovy") || name.startsWith("w.core.GroovyBundle")) {
            Class<?> c = findLoadedClass(name);
            if (c != null) return c;
            return findClass(name);
        }
        return super.loadClass(name);
    }
}
Copy

{
    static WGroovyClassLoader cl;
    static GroovyScriptEngineImpl engine;
    static {
        if (GroovyBundle.class.getClassLoader().toString().startsWith(WGroovyClassLoader.class.getName())) {
            try {
                engine = new GroovyScriptEngineImpl(new GroovyClassLoader());
                Global.info("Groovy Engine Initialization finished");
                if (SpringUtils.isSpring()) {
                    engine.put("ctx", SpringUtils.getSpringBootApplicationContext());
                }
            } catch (Exception e) {
                Global.error("Could not load Groovy Engine", e);
            }
        } else {
            try {
                cl = new WGroovyClassLoader(Global.getClassLoader());
            } catch (Exception e) {
                Global.error("Could not init Groovy Classloader", e);
            }
        }
    }
    public static Object eval(String script) throws Exception {
        if (cl != null) {
            Thread.currentThread().setContextClassLoader(cl);
            Class<?> bundle = cl.loadClass(GroovyBundle.class.getName());
            return bundle.getDeclaredMethod("eval", String.class).invoke(null, script);
        }
        return engine.eval(script);
    }
}
Copy

class WGroovyClassLoader extends URLClassLoader {
    private final ClassLoader delegate;
    public WGroovyClassLoader(ClassLoader delegate) throws Exception {
        super(new URL[] { currentUrl() }, ClassLoader.getSystemClassLoader().getParent());
        this.delegate = delegate;
    }
    @Override
    public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        if (name.startsWith("w.") && !name.equals(GroovyBundle.class.getName())) {
            return delegate.loadClass(name);
        }
        try {
            Class<?> c = findLoadedClass(name);
            if (c != null) return c;
            c = findClass(name);
            return c;
        } catch (ClassNotFoundException e) {
            return delegate.loadClass(name);
        }
    }
}
Copy

public static class WGroovyClassLoader extends URLClassLoader {
    private final ClassLoader delegate;
    public WGroovyClassLoader(ClassLoader parent, ClassLoader delegate) throws Exception {
        super(new URL[] { currentUrl() }, parent);
        this.delegate = Global.getClassLoader();
    }
    @Override
    public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // For entrypoint class, must load it by self
        if (name.equals(GroovyBundle.class.getName())) {
            Class<?> c = findLoadedClass(name);
            if (c != null) return c;
            return findClass(name);
        }
        try {
            // For groovy, need to load it by parent(jarInJarClassLoader)
            return getParent().loadClass(name);
        } catch (ClassNotFoundException e) {
            // Else load it by delegate(Global.getClassLoader())
            return delegate.loadClass(name);
        }
    }
}
Copy

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-dependency-plugin</artifactId>
	<version>3.3.0</version>
	<executions>
		<execution>
			<id>copy-dependencies</id>
			<phase>prepare-package</phase>
			<goals>
				<goal>copy-dependencies</goal>
			</goals>
			<configuration>
				<outputDirectory>${project.build.directory}/classes/W-INF/lib</outputDirectory>
				<includeGroupIds>org.apache.groovy</includeGroupIds>
				<overWriteReleases>false</overWriteReleases>
				<overWriteSnapshots>false</overWriteSnapshots>
				<overWriteIfNewer>true</overWriteIfNewer>
			</configuration>
		</execution>
	</executions>
</plugin>
<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-shade-plugin</artifactId>
	<version>3.5.0</version>
	<configuration>
		<artifactSet>
			<excludes>
				<exclude>org.apache.groovy:*</exclude>
			</excludes>
	    </artifactSet>
	</configuration>
	<!-- 省略 其他配置 -->
</plugin>
Copy