Java 静态代理 与 动态代理

静态代理

1、创建接口

public interface MyInterface {

    void print01();
    void print02();
    void print03();

}

2、创建实现类

public class RealMyInterface implements MyInterface{

    @Override
    public void print01() {
        System.out.println("打印方法01");
    }

    @Override
    public void print02() {
        System.out.println("打印方法02");
    }

    @Override
    public void print03() {
        System.out.println("打印方法03");
    }


}

3、创建代理类

import java.util.Date;

public class ProxyDemo implements MyInterface{
    private MyInterface myInterface;

    public ProxyDemo(MyInterface myInterface) {
        this.myInterface = myInterface;
    }

    @Override
    public void print01() {
        System.out.println("执行时间" + new Date().toLocaleString());
        myInterface.print01();
        System.out.println("结束时间" + new Date().toLocaleString());
    }

    @Override
    public void print02() {
        System.out.println("执行时间" + new Date().toLocaleString());
        myInterface.print02();
        System.out.println("结束时间" + new Date().toLocaleString());
    }

    @Override
    public void print03() {
        System.out.println("结束时间" + new Date().toLocaleString());
        myInterface.print03();
        System.out.println("结束时间" + new Date().toLocaleString());
    }

}

4、创建测试类

public class MainDemo {
    public static void main(String[] args) {
        ProxyDemo proxyDemo = new ProxyDemo(new RealMyInterface());
        proxyDemo.print01();
        proxyDemo.print02();
        proxyDemo.print03();

    }
}

结果：

 通过静态代理，达到了功能增强的目的，而且没有侵入原代码，这是静态代理的一个优点。

但是静态代理也有缺点：

1、 当需要代理多个类的时候，由于代理对象要实现与目标对象一致的接口，有两种方式：

• 只维护一个代理类，由这个代理类实现多个接口，但是这样就导致代理类过于庞大
• 新建多个代理类，每个目标对象对应一个代理类，但是这样会产生过多的代理类

2、 当接口需要增加、删除、修改方法的时候，目标对象与代理类都要同时修改，不易维护。

为了解决这些缺点就要用到动态代理

动态代理

需要用到java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler 

代理类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Date;

//要实现动态代理必须要实现InvocationHandler接口
public class DynamicProxy implements InvocationHandler {
    private Object object ;

    //构造器
    public DynamicProxy(Object object){
        this.object = object;//初始化接口
    }

    public Object getProxy(){
        Object o = Proxy.newProxyInstance(
                object.getClass().getClassLoader(),//系统类加载器
                object.getClass().getInterfaces(),//真正实现类的接口列表
                this //InvocationHandler接口的实现类对象
        );
        return o;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("执行开始时间:" + new Date().toLocaleString());

        Object value = method.invoke(object, args);

        System.out.println("执行结束时间:" + new Date().toLocaleString());
        return value;
    }
}

测试类：

public class MyTest {
    public static void main(String[] args) {

        DynamicProxy dp = new DynamicProxy(new RealMyInterface());//动态代理类对象

        Object o = dp.getProxy();

        MyInterface real = (MyInterface)o ;
        real.print01();
        real.print02();
        real.print03();
    }
}

首先通过 newProxyInstance 方法获取实现类的代理，实现类代理的是接口，之后就可以通过这个实现类的代理调用接口的方法

对实现类的方法调用都会调用中间类 (实现了 invocationHandle 的类) 的 invoke 方法，invoke中传的应该是接口中的方法，在 invoke 方法中我们调用实现类的对应方法，然后加上自己的处理逻辑。