jdk动态代理的使用

JDK动态代理 

Java为我们提供了动态代理Proxy，下面通过销售汽车的例子进行实现。

代码实现

/**
 * 抽象主体类
 */
public interface SellCar {
    void sell();
    void check();
}

/**
 * 真实主体类(目标对象)
 */
public class CarFactory implements SellCar{
    @Override
    public void sell() {
        System.out.println("进行汽车售卖");
    }

    @Override
    public void check() {
        System.out.println("进行汽车检测");
    }
}

/**
 * 代理工厂对象(创造代理类)
 */
public class ProxyFactory {
    //真实主题类
    private static CarFactory carFactory=new CarFactory();

    /*获取代理对象
    ClassLoader loader:类加载器，用于加载代理类,
    Class<?>[] interfaces：代理类实现的接口的字节码对象,
    InvocationHandler h：代理对象的调用处理程序
    */

    public static SellCar getProxyObject(){
        SellCar ProxyObject=(SellCar) Proxy.newProxyInstance(carFactory.getClass().getClassLoader(),
                carFactory.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     Object proxy:要代理的类的对象(真实主题类),
                     Method method：对接口中的方法进行封装的method对象,
                     Object[] args：接口中的方法的参数

                     返回的参数是接口中方法的返回值，若没有则为null
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("进行其他业务操作");
                        return method.invoke(carFactory,args);
                    }
                });
        return ProxyObject;
    }

}

测试：

public class Client {
    public static void main(String[] args) {
        SellCar proxyObject = ProxyFactory.getProxyObject();
        proxyObject.sell();
        System.out.println("---------");
        proxyObject.check();
    }
}

分析

我们创造了一个代理工厂类ProxyFactory，这个类不是代理类，而是创造代理类的工厂类，其提供了一个方法getProxyObject()用来获取代理类。这个方法中通过Java提供的Proxy类来创建一个代理类。

Proxy.newProxyInstance()方法可以创建一个代理类其返回值是代理类，实现了抽象主题类，其有三个参数：

ClassLoader loader:类加载器，用于加载代理类,
Class<?>[] interfaces：代理类实现的接口的字节码对象,
InvocationHandler h：代理对象的调用处理程序

前两个参数都可以通过要代理的类获得。最后一个参数是一个函数接口。在上面，我们定义了一个匿名子类对象来实现了其invoke()方法，这个方法又有三个参数和一个返回值：

Object proxy:要代理的类的对象(真实主题类),
Method method：对接口中的方法进行封装的method对象,
Object[] args：接口中的方法的参数

返回的值是接口中方法的返回值，若没有则为null

在这个方法中，我们需要进行方法的增强，通过method对象调用被代理类中的原方法。其中，method.invoke()就是调用原方法，这就是反射。其有两个参数，第一个为调用的对象，第二个为传入的参数。这里参数已经为我们提供了，为args。

执行流程

1.通过代理工厂获取代理对象

2.底层jdk会根据Proxy.newProxyInstance()传入的三个参数通过反射创建一个代理类Proxy,使其实现抽象主体类(SellCar接口)，并实现其方法。

3.通过Proxy代理类调用方法，此时会调用我们传入的InvocationHandler的实现类对象，并调用其invoke()方法。

总结

jdk动态代理是通过实现接口来实现代理的，被代理类必须要实现接口。使用动态代理能够把代理的方法都集成在一个方法invoke中，即使新增方法，也不用修改代理类，扩展性好。

在很多地方都用到了代理，比如spring的aop就是通过代理实现的。鉴权也是通过代理。