能否不修改类与客户端代码修改静态方法执行逻辑？

能实现这个需求，下面提供两种可靠的方案，解决你提到的类加载委托机制问题：

方案一：基于Java Agent（推荐，无需处理类加载器委托） #

Java Agent可以在类加载阶段修改目标类的字节码，完全绕过类加载器的双亲委派机制，直接替换Foo类的printSomething方法逻辑。

实现步骤： #

1. 编写Agent类，借助ByteBuddy修改目标方法：

import net.bytebuddy.agent.builder.AgentBuilder;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;

import java.lang.instrument.Instrumentation;

public class FooAgent {
    public static void premain(String args, Instrumentation inst) {
        new AgentBuilder.Default()
                // 匹配目标类Foo
                .type(ElementMatchers.named("Foo"))
                .transform((builder, typeDesc, classLoader, module) ->
                        builder.method(
                                        // 匹配printSomething静态方法
                                        ElementMatchers.named("printSomething")
                                        .and(ElementMatchers.isStatic()))
                                // 替换方法实现为拦截器逻辑
                                .intercept(MethodDelegation.to(FooInterceptor.class)))
                .installOn(inst);
    }

    // 定义方法拦截器，输出目标内容
    public static class FooInterceptor {
        public static void printSomething() {
            System.out.println("bar");
        }
    }
}

2. 打包Agent为jar包，在MANIFEST.MF中添加配置：

Premain-Class: FooAgent
Can-Redefine-Classes: true

3. 启动Main类时指定Agent：

java -javaagent:foo-agent.jar Main

运行后，Main调用Foo.printSomething()会输出bar，完全不需要修改原Main和Foo的代码。

方案二：自定义类加载器（解决委托机制限制） #

如果坚持用自定义类加载器，需要规避双亲委派的默认逻辑：默认情况下自定义加载器会先委托父加载器加载类，若父加载器（如AppClassLoader）能找到原Foo类，就会加载原版本。因此需要确保父加载器无法找到原Foo类，或让自定义加载器打破双亲委派。

实现步骤： #

1. 编写自定义类加载器，重写findClass方法生成修改后的Foo类：

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;

import java.io.IOException;

public class CustomFooClassLoader extends ClassLoader {
    // 将父加载器设为ExtClassLoader，避免委托给能加载原Foo的AppClassLoader
    public CustomFooClassLoader() {
        super(ClassLoader.getSystemClassLoader().getParent());
    }

    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        if ("Foo".equals(className)) {
            try {
                // 用ByteBuddy生成修改后的Foo类字节码
                byte[] modifiedBytecode = new ByteBuddy()
                        .subclass(Object.class)
                        .name("Foo")
                        .defineMethod(
                                "printSomething",
                                void.class,
                                java.lang.reflect.Modifier.PUBLIC | java.lang.reflect.Modifier.STATIC)
                        .intercept(MethodDelegation.to(FooInterceptor.class))
                        .make()
                        .getBytes();
                return defineClass(className, modifiedBytecode, 0, modifiedBytecode.length);
            } catch (IOException e) {
                throw new ClassNotFoundException("Failed to generate modified Foo class", e);
            }
        }
        // 其他类委托父加载器加载
        return super.findClass(className);
    }

    public static class FooInterceptor {
        public static void printSomething() {
            System.out.println("bar");
        }
    }
}

2. 启动时指定系统类加载器为自定义加载器：

# 确保原Foo类不在当前classpath中，避免被AppClassLoader加载
java -Djava.system.class.loader=CustomFooClassLoader Main

关键说明： #

• 自定义加载器的父加载器设为ExtClassLoader，这样父加载器无法找到原Foo类，会由自定义加载器生成修改后的版本。
• 必须移除classpath中原Foo类的字节码，否则AppClassLoader会加载原类，导致自定义加载器的逻辑失效。

内容的提问来源于stack exchange，提问作者Sergey Zolotarev