低版本skywalking与LinkAgent不兼容怎么办？记一次详细的解决过程

public static void premain(String agentArgument, Instrumentation instrumentation) throws Exception

public static void agentmain(String agentArgument, Instrumentation instrumentation) throws Exception

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) throws InterruptedException, UnmodifiableClassException {
        SpringApplication.run(DemoApplication.class, args);
        test();
    }

    public static void test() throws InterruptedException, UnmodifiableClassException {
        Instrumentation instrumentation = ByteBuddyAgent.install();

        System.err.println("before =============");
        printAllTestControllerClasses(instrumentation);

        reTransform(instrumentation);
        reTransform(instrumentation);
        reTransform(instrumentation);

        System.err.println("after =============");
        printAllTestControllerClasses(instrumentation);
    }

    public static void reTransform(Instrumentation instrumentation) throws UnmodifiableClassException {
        ClassFileTransformer transformer = new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
                return null;
            }
        };
        try {
            instrumentation.addTransformer(transformer, true);
            try {
                instrumentation.retransformClasses(TestController.class);
            } catch (Throwable e) {
                e.printStackTrace();
            }

        } finally {
            instrumentation.removeTransformer(transformer);
        }

    }

    public static void printAllTestControllerClasses(Instrumentation instrumentation) {
        Class<?>[] classes = instrumentation.getAllLoadedClasses();
        for (Class<?> clazz : classes) {
            if (clazz.getName().startsWith(TestController.class.getName())) {
                System.out.println(clazz.getName());
            }
        }
    }

-Dskywalking.agent.is_cache_enhanced_class=true 
-Dskywalking.agent.class_cache_mode=MEMORY

public byte[] transform(ClassLoader classLoader,
                        String internalTypeName,
                        Class<?> classBeingRedefined,
                        ProtectionDomain protectionDomain,
                        byte[] binaryRepresentation) {
    // ... 忽略实现
}

    public static void premain(final String agentArgs, final Instrumentation instrumentation) throws Exception {
        System.err.println("====== skywalking-byte-buddy-agent ======");
        // 预处理启动参数
        AgentConfig.instance().initConfig();

        if (AgentConfig.enable) {
            System.err.println("=== begin start skywalking-byte-buddy-agent ===");
            System.out.println("=== cacheMode is " + AgentConfig.cacheMode + " ===");
            AgentBuilder.Transformer transformer = (builder, typeDescription, classLoader, javaModule) -> builder
                    // 拦截transform方法
                    .method(ElementMatchers.hasMethodName("transform")
                                    .and(ElementMatchers.takesArguments(5))
                    )
                    // 委托
                    .intercept(MethodDelegation.to(CacheInterceptor.class));

            new AgentBuilder
                    .Default()
                    // 指定需要拦截的类
                    .type(ElementMatchers.named("org.apache.skywalking.apm.dependencies.net.bytebuddy.agent.builder.AgentBuilder$Default$ExecutingTransformer"))
                    .transform(transformer)
                    .installOn(instrumentation);

            System.err.println("=== end start skywalking-byte-buddy-agent ===");
        } else {
            System.err.println("=== enable is false, not start skywalking-byte-buddy-agent ===");
        }
    }

/**
 * @Description 缓存拦截器
 * @Author ocean_wll
 * @Date 2021/8/5 11:53 上午
 */
public class CacheInterceptor {

    @RuntimeType
    public static Object intercept(@Origin Method method, @AllArguments Object[] args,
                                   @SuperCall Callable<?> callable) {
        Object returnObj = null;

        try {
            // 校验参数
            if (checkArgs(args)) {
                ClassLoader classLoader = (ClassLoader) args[0];
                String className = (String) args[1];

                // 获取缓存中的value
                byte[] bytes = Cache.getClassCache(classLoader, className);
                if (bytes != null) {
                    return bytes;
                }
                // 调用原有方法
                returnObj = callable.call();
                if (returnObj != null) {
                    // 如果缓存中没有，并且原方法执行结果不为null，则放入缓存中
                    Cache.putClassCache(classLoader, className, (byte[]) returnObj);
                }
            } else {
                // 会出现classloader为null的情况，但还是需要去执行transform
                returnObj = callable.call();
            }
            return returnObj;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return returnObj;
    }

    /**
     * 因为拦截的方法是五个参数，jvm中类的唯一性是根据classloader和className来确定的，所以进行增强前对方法参数进行一次校验避免方法增强错误
     * <p>
     * 需要增强的方法
     * public byte[] transform(ClassLoader classLoader,
     * String internalTypeName,
     * Class<?> classBeingRedefined,
     * ProtectionDomain protectionDomain,
     * byte[] binaryRepresentation) {
     * if (circularityLock.acquire()) {
     * try {
     * return AccessController.doPrivileged(new AgentBuilder.Default.ExecutingTransformer.LegacyVmDispatcher(classLoader,
     * internalTypeName,
     * classBeingRedefined,
     * protectionDomain,
     * binaryRepresentation), accessControlContext);
     * } finally {
     * circularityLock.release();
     * }
     * } else {
     * return NO_TRANSFORMATION;
     * }
     * }
     *
     * @param args 方法入参
     * @return true校验通过，false校验失败
     */
private static boolean checkArgs(Object[] args) {
        // 先校验参数个数
        if (args.length == 5) {
            // 校验第一个参数，第一个参数类型是classLoader
            boolean arg0IsTrue = args[0] != null && args[0] instanceof ClassLoader;
            // 校验第二个参数，第二个参数表示的是类名，类型为String
            boolean agr1IsTrue = args[1] != null && args[1] instanceof String;
            return arg0IsTrue && agr1IsTrue;
        }
        return false;
    }
}

/**
 * @Description cacheResolver接口
 * @Author ocean_wll
 * @Date 2021/8/5 4:02 下午
 */
public interface ClassCacheResolver {

    /**
     * 获取class缓存
     *
     * @param loader    ClassLoader
     * @param className 类名
     * @return byte数组
     */
byte[] getClassCache(ClassLoader loader, String className);

    /**
     * 存放class缓存
     *
     * @param loader          ClassLoader
     * @param className       类名
     * @param classfileBuffer 字节码数据
     */
void putClassCache(ClassLoader loader, String className, byte[] classfileBuffer);
}

/**
 * @Description 内存缓存解析器
 * @Author ocean_wll
 * @Date 2021/8/5 4:03 下午
 */
public class MemoryCacheResolver implements ClassCacheResolver {

    /**
     * key为 classloader+className，value为 字节码
     */
private final Map<String, byte[]> classCacheMap = new ConcurrentHashMap<>();

    @Override
    public byte[] getClassCache(ClassLoader loader, String className) {
        String cacheKey = getCacheKey(loader, className);
        return classCacheMap.get(cacheKey);
    }

    @Override
    public void putClassCache(ClassLoader loader, String className, byte[] classfileBuffer) {
        String cacheKey = getCacheKey(loader, className);
        classCacheMap.put(cacheKey, classfileBuffer);
    }


    /**
     * 获取缓存key ClassLoaderHash(loader) + "@" + className
     *
     * @param loader    ClassLoader
     * @param className 类名
     * @return 缓存key
     */
private String getCacheKey(ClassLoader loader, String className) {
        return Cache.getClassLoaderHash(loader) + "@" + className;
    }
}