Static proxy uses AspectJ. I specifically tried it with AspectJ, but it cannot be achieved by simple AspectJ. However, it can be implemented using asm. It can be implemented by modifying the class bytecode during runtime, but it is very troublesome. If you have no special needs, just write it normally. I will post a piece of asm later on how to change it

Anyway, I will post the implementation of asm below

public class TargetObject {

    public static void businessLogic() {
        System.out.println("static目标对象/真实对象中的      业务逻辑处理");
    }
}

public class ProxyUtil {

    public void businessLogic() {}

    public static void before() {  
        System.out.println("目标对象/真实对象      方法调用之前...");
    }  

    public static void after() {
        System.out.println("目标对象/真实对象      方法调用之后...");
    }
}

public class Test extends ClassLoader implements Opcodes{
    public static void main(String[] args) throws Exception {
        ClassReader cr = new ClassReader("TargetObject"); 
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); 
        ClassVisitor classAdapter = new TargetObjectAdapter(Opcodes.ASM4,cw);
        cr.accept(classAdapter, ClassReader.SKIP_DEBUG); 
        byte[] data = cw.toByteArray(); 
        Test loader = new Test();
        Class<?> appClass=loader.defineClass(null, data, 0,data.length);
        appClass.getMethods()[0].invoke(appClass.newInstance(), new Object[]{});
    }
}

public class TargetObjectAdapter extends ClassVisitor {

    private MethodVisitor mv;

    public TargetObjectAdapter(int api, ClassVisitor cw) {
        super(api, cw);
    }

    public MethodVisitor visitMethod(int access, String name, String desc, String signature,
            String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
        if (name.equals("businessLogic")) {
            return new MethodVisitor(this.api, mv) {
                public void visitCode() {
                    super.visitCode();
//                    this.visitMethodInsn(Opcodes.INVOKESTATIC, "ProxyUtil", "before", "()V");
                    mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                    mv.visitLdcInsn("before");
                    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
                }

                public void visitInsn(int opcode) {
                    if (opcode == Opcodes.RETURN) {
                        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                        mv.visitLdcInsn("after");
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
//                        this.visitMethodInsn(Opcodes.INVOKESTATIC, "ProxyUtil", "after", "()V");
                    }
                    super.visitInsn(opcode);
                }
            };
        }
        return mv;
    }
}

Why cglib cannot intercept static methods is because of the way Cglib is implemented: the generated proxy class inherits from the proxy class/target class. When requested, it executes its own woven enhancements and then executes the target method, so it is created using inheritance. The proxy class cannot proxy any final methods and classes, as well as static methods.