static方法能被AOP动态代理吗？

首先在回答题目之前，应该先明确一个问题，static是什么意思，是静态的意思，静态的能被动态的代理么？从字面上来讲就不太可能。那么事实是什么呢，事实就是static不能被动态代理。

动态代理的方式有两种，一种是jdk自带的动态代理，只能代理接口类；另一种是cglib提供的增强代理，需要额外引入cglib的依赖，接口和类都可以代理。

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.1</version>
</dependency>

为什么static方法不能被动态代理呢？因为不管是jdk的动态代理还是cglib的动态代理，都是要通过代理的方式获取到代理的具体对象，而static是不属于对象的，是属于类。所以静态方法是不能被重写的，正因为不能被重写，所以动态代理也不成立。因为不管是jdk和cglib动态代理，都是需要实现或者重写方法的。

下面我们用代码来看下重写static方法的效果以及两种动态代理的情况。

1、子类“重写”static方法

可以“重写”，但是不具有多态性。

public class ParentStatic {

    public static void main(String[] args) {
        ParentStatic p = new ParentStatic();
        p.test();

        ParentStatic c = new Child();
        c.test();

        Child cc = new Child();
        cc.test();
    }

    public static void test(){
        System.out.println("test");
    }
}

class Child extends ParentStatic{
    public static void test(){
        System.out.println("Child test");
    }
}

输出结果是：

test
test
Child test

我们可以看到，虽然引用调用了静态方法，但是调用的并不是引用指向的对象的方法，而是调用的引用类型对应的类里面的静态方法。

我们用两种代理方式分别做下测试：

1、使用jdk动态代理

/**
 * jdk动态代理测试static
 */
public class JdkProxyTest implements MyTest {

    public JdkProxyTest(){}

    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        MyTest test = new JdkProxyTest();//真实对象
        Class[] interfaces = {MyTest.class};
        //生成代理对象
        MyTest o1 = (MyTest) Proxy.newProxyInstance(JdkProxyTest.class.getClassLoader(), interfaces, new MyInvocationHandler(test));
//        o1.test(); //编译直接不通过
        o1.go();
    }

    public static void test(){
        System.out.println("test");
    }
    public void go(){
        System.out.println("go");
    }
}

interface MyTest{
    static void test(){};
    void go();
}

class MyInvocationHandler implements InvocationHandler{

    private Object realObj;

    public MyInvocationHandler(Object realObj) {
        this.realObj = realObj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("hello");
        Object invokeObj = method.invoke(realObj, args);
        System.out.println("bye");
        return invokeObj;
    }
}

我们用代理引用，直接调用静态方法，直接就编译报错。

2、使用cglib

/**
 * cglib增强代理测试static
 */
public class EnhanceTest implements Callback, MethodInterceptor {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(EnhanceTest.class);
        enhancer.setCallback(new EnhanceTest());
        EnhanceTest my = (EnhanceTest) enhancer.create();
        my.test();
        System.out.println("--------------------");
        my.go();
    }

    public static void test(){
        System.out.println("test");
    }
    public void go(){
        System.out.println("go");
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy proxy) throws Throwable {
        System.out.println("hello");
        proxy.invokeSuper(o, objects);
        System.out.println("bye");
        return null;
    }
}

输出结果：

test
--------------------
hello
go
bye

可以看到增强对象对应的引用，调用静态方法时，并没有走代理方法。

至此，总结一下：

static方法不能被重写，即便写法上是重写，但是并不具备重写的含义。

static方法是属于类的，不属于任何对象，即便具体对象所声明的引用对象调用了static方法，实际执行的也是引用对象类型对应的类里的方法。

static不能被动态代理，因为不能被重写且不属于对象。