设计模式系统回顾（7）代理模式

一个对象为另一个对象提供一种代理，从而通过代理对象来控制非代理对象的访问，代理对象在客户端和目标对象之间起到中介作用

1.静态代理

public interface Travel {
    void buyTrainticket();//买火车票
}

public class TravelPerson implements Travel {
    @Override
    public void buyTrainticket() {//这个方法是真正实现买火车票的逻辑
        System.out.println("深圳到广州");
        System.out.println("早上9:00出发");
    }
}

public class TravelAgency implements Travel {
    private TravelPerson travelPerson;//被代理对象

    public TravelAgency(TravelPerson travelPerson) {
        this.travelPerson = travelPerson;
    }

    @Override
    public void buyTrainticket(){
        before();
        this.travelPerson.buyTrainticket();//调用被代理对象的原方法
        after();

    }

    private void before() {
        System.out.println("付定金");
    }

    private void after() {
        System.out.println("付尾款");
    }
}

public class TestStaticProxy {
    public static void main(String[] args) {
        TravelAgency travelAgency = new TravelAgency(new TravelPerson());
        travelAgency.buyTrainticket();
    }
}

局限性：
修改方法需要代理对象也修改
代理对象需要显示声明被代理对象，后边修改代理对象，则需要修改源代码

2.动态代理

利用jdk内置的动态代理实现：
1.定义的代理对象必须要实现 java.lang.reflect.InvocationHandler 接口。
2.被代理对象必须要显式的实现至少一个接口。

public interface Travel {
    void buyTrainticket();//买火车票
}

public final class JdkTravelPerson implements Travel{
    @Override
    public void buyTrainticket() {
        System.out.println("广州到深圳");
        System.out.println("早上9:00出发");
    }
}

public class JdkTravelAgency implements InvocationHandler {
    private Object target;//被代理对象，即示例中的 JdkTravelPerson

    public Object getInstance(Object target){//动态获取代理对象
        this.target = target;//target 就是被代理对象
        Class<?> clazz = target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);//创建代理对象
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object obj = method.invoke(this.target,args);//调用代理对象方法
        after();
        return obj;
    }

    private void before() {
        System.out.println("付定金");
    }

    private void after() {
        System.out.println("付尾款");
    }
}

public class TestJdkProxy {
    public static void main(String[] args){
        Travel travel = (Travel) new JdkTravelAgency().getInstance(new JdkTravelPerson());
        travel.buyTrainticket();
    }
}

3.CGLIB 动态代理

CGLIB 是通过继承被代理对象来实现
CGLIB 要求代理对象必须要实现 MethodInterceptor 接口，并重写其唯一的方法 intercept。

public class CglibTravelPerson{
    public void buyTrainticket() {
        System.out.println("cglib:广州到深圳");
        System.out.println("cglib:早上9:00出发");
    }
}

public class CglibTravelAgency implements MethodInterceptor {

    public Object getInstance(Class<?> clazz){
        Enhancer enhancer = new Enhancer();//相当于 JDK 动态代理中的 Proxy 类
        enhancer.setSuperclass(clazz);//设置为即将生成的代理类的父类
        enhancer.setCallback(this);//设置回调对象
        return enhancer.create();//相当于JDK动态代理的 Proxy.newProxyInstance 方法，生成新的字节码文件，并加载到 JVM 中
    }


    /**
     *
     * @param o - CBLIG 生成的代理对象
     * @param method - 被代理对象中被拦截的方法
     * @param objects - 方法中的参数
     * @param methodProxy - 代理对象中对应的方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o,objects);
        after();
        return obj;
    }

    private void before() {
        System.out.println("付定金");
    }

    private void after() {
        System.out.println("付尾款");
    }
}

public class TestCglibProxy {
    public static void main(String[] args){
        CglibTravelPerson cglibTravelPerson = (CglibTravelPerson) new CglibTravelAgency().getInstance(CglibTravelPerson.class);
        cglibTravelPerson.buyTrainticket();
    }
}

和jdk动态代理对比
JDK的动态代理只能针对实现了接口的类生成代理。而cglib的动态代理是针对类实现代理

代理模式优点：
1.分离代理对象和被调用对象，降低耦合，拓展型好
2.增强被代理对象的功能
缺点
1.类数量增加
2.性能影响