代理模式

• 需求：现在有一个前人写好的计算接口及其实现类，里面有add，sub，mul，div方法。现在想要在其中添加日志的方法，其如：传入的值是a和b，计算结果是a+b

interface IMath {
    int add(int a,int b);
    int sub(int a,int b);
    int mul(int a,int b);
    int div(int a,int b);
}

class Math implements IMath {
    @Override
    public int add(int a,int b) {
        return a+b;
    }

    @Override
    public int sub(int a,int b) {
        return a-b;
    }

    @Override
    public int mul(int a,int b) {
        return a*b;
    }

    @Override
    public int div(int a,int b) {
        return a/b;
    }
}

1、静态代理

class Proxy implements IMath{
    private IMath iMath;

    public Proxy(IMath iMath) {
        this.iMath = iMath;
    }

    @Override
    public int add(int a, int b) {
        System.out.println("传入的参数是："+a+"和"+b);
        int c = iMath.add(a,b);
        System.out.println("结果是："+c);
        return c;
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("传入的参数是："+a+"和"+b);
        int c = iMath.sub(a,b);
        System.out.println("结果是："+c);
        return c;
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("传入的参数是："+a+"和"+b);
        int c = iMath.mul(a,b);
        System.out.println("结果是："+c);
        return c;
    }

    @Override
    public int div(int a, int b) {
        System.out.println("传入的参数是："+a+"和"+b);
        int c = iMath.div(a,b);
        System.out.println("结果是："+c);
        return c;
    }
}

优点： 符合开闭原则
缺点： 如果有一百个方法则需要添加一百个，工作量太大

2、JDK动态代理

依赖于接口，对接口进行代理生成实现类。

class IMathProxy {

    public static IMath proxy(IMath iMath){
        return (IMath) Proxy.newProxyInstance(AppTest.class.getClassLoader(), new Class[]{IMath.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("传入的参数是："+ Arrays.toString(args));
                        Object o = method.invoke(iMath, args);
                        System.out.println("结果是："+ o);
                        return o;
                    }
                });
    }
}

public class AppTest {

    public static void main(String[] args) {
        IMath proxy = IMathProxy.proxy(new Math());
        int add = proxy.add(1, 3);
        System.out.println(add);

        int sub = proxy.sub(1, 3);
        System.out.println(sub);

        int mul = proxy.mul(1, 3);
        System.out.println(mul);

        int div = proxy.div(1, 3);
        System.out.println(div);
    }
}

优点： 需要依赖于接口，但是大量减少代码量

3、cglib代理

cglib代理无需依赖于接口，可以直接对类进行代理
使用cglib代理需要导入三个包。

class ProxyFactory implements MethodInterceptor{

    //维护一个目标对象
    private Object target;

    //传入一个被代理的对象
    public ProxyFactory(Object targer){
        this.target = targer;
    }

    //返回一个代理对象，他是target的代理对象（此方法原模原样写就对了）
    public Object getProxyInstance(){
        //1、创建一个工具类
        Enhance enhance = new Enhance();
        //2、设置父类
        enhance.setSuperClass(target.getClass());
        //3、设置回调函数
        enhance.setCallBack(this);
        //4、创建子类对象，及代理对象
        return enhance.create();
    }

    //重写intercept方法
    @Override
    public Object intercept(Object arg0,Method method,Object[] objects,MethodProxy arg3)throws Throwable{
        System.out.println("cglib代理模式开始");
        System.out.println("传入的参数是："+ Arrays.toString(objects));
        Object returnVal = method.invoke(target,objects);
        System.out.println("结果是："+ returnVal);
        return returnVal;
    }
}

public class AppTest {

    public static void main(String[] args) {
        //创建目标对象
        Math targer = new Math();
        //获取代理对象，并将目标对象传入
        Math proxyInstance = (Math)new ProxyFactory(targer).getProxyInstance();
        //执行代理对象的方法，触发intercept方法，从而实现对目标对象的调用
        int add = proxyInstance.add(1, 2);
        System.out.println(add);
    }
}