Java静态代理和动态代理

ok，在了解了AOP的概念和简单实践了SpringAOP的实现以后。如果需要进一步深入理解，就一定要学习Java静态代理和动态代理。

SpringAOP的实现底层就是基于了Java的动态代理。

概念：

静态代理：自己定义的代理类；

动态代理：程序在运行时生成。

还是以前文提到的AOP例子为例，车子开出停车场需要在前后添加停车场的杆子升起和降下的方法。

目标：静态代理便是建一个类来代理车辆的实现，并在前后添加方法

先建车子接口Car：

public interface Car{

    void run();
}

建BMW实现Car接口：

public class BMW implements Car{

    @Override
    public void run(){
        System.out.println("宝马开出停车场");
    }

}

建Ford实现Car接口：

public class Ford implements Car{

    @Override
    public void run(){
        System.out.println("福特开出停车场");
    }

}

静态代理类：

public class ParkingProxy implements Car{

    private Car car;
    
    public ParkingProxy(Car car){
        this.car = car;
    }
    
    public void beforeRun(){
        System.out.println("停车场杆子升起");
    }
    
    public void afterRun(){
        System.out.println("停车场杆子降下");
    }

    @Override
    public void run(){
        beforeRun();
        this.car.run();
        afterRun();
    }

}

可以看到这个静态代理类通过构造方法实例Car，并在run方法中添加前后方法。这样真正执行时候只需要通过静态代理类来实例Car就可以实现切面的效果了。

执行：

public static void main(String[] args){

        Car bmw = new ParkingProxy(new BMW());
        bmw.run();
        Car ford = new ParkingProxy(new Ford());
        ford.run();
        

    }

效果：

停车场杆子升起
宝马开出停车场
停车场杆子降下
停车场杆子升起
福特开出停车场
停车场杆子降下

不错实现了。对原有的汽车实现类的结构并没有破坏，也完成了需求。

可是，问题来了，如果我的车子有许多不止方法，不止run一种，那么每次新增都需要我重新写静态代理类，添加新的方法，这样岂不是繁琐，而且不便于代码维护。

嘿嘿，来看一下动态代理类，将代理类实现InvocationHandler 接口，新建newProxy方法通过Proxy的newProxyInstance来实例化汽车接口，然后通过重写InvocationHandler 的invoke反射方法来实现方法前后加上方法。

保持汽车接口不变。

动态代理类：

public class ParkingHandler implements InvocationHandler {
    private Object targetObject;

    public Object newProxy(Object targetObject){
        this.targetObject = targetObject;
        //返回动态代理
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),targetObject.getClass().getInterfaces(),this);
    }

    public void beforeRun(){
        System.out.println("停车场杆子升起");
    }
    
    public void afterRun(){
        System.out.println("停车场杆子降下");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        beforeRun();
        Object ret = null;

        try {
            //调用目标对象的真实方法,将返回值保存在ret中
            ret = method.invoke(this.targetObject, args);
        } catch (Exception e){
            e.printStackTrace();
        }
        afterRun();
        return ret;
    }


}

执行方法：

public static void main(String[] args){
        ParkingHandler parkingHandler = new ParkingHandler();
        Car bmw = (Car) parkingHandler.newProxy(new BMW());
        bmw.run();
        Car ford = (Car) parkingHandler.newProxy(new Ford());
        ford.run();
    }

实现效果：

停车场杆子升起
宝马开出停车场
停车场杆子降下
停车场杆子升起
福特开出停车场
停车场杆子降下

ok。实现效果了。如果在接口中新增方法，停车场方法也同样会实现。如果需要对某一个特定方法进行切面，则可以通过判断invoke方法的入参method来做区分。