代理模式

1，什么是代理模式

为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

2，代理模式所需要的角色(类和接口)

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

 

3，静态代理的实现 

抽象角色

public interface AbstractRole {
    public void rent();
}

真实角色

public class Host implements AbstractRole{
    @Override
    public void rent() {
        System.out.println("我有房屋可以出租");
    }
}

代理角色

public class Proxy implements AbstractRole{
    private Host host=new Host();
    @Override
    public void rent() {
        fee();
        host.rent();
    }
    //代理角色不仅实现了真实角色的功能还添加特有的功能
    public void fee(){
        System.out.println("通过我租房会收中介费");
    }
}

用户

public class User {
     Proxy proxy = new Proxy();
     proxy.rent();
}

通过用户我们可以看到用户不仅租到了房子还被代理(中介)狠狠的坑了一把，在不改变真实角色功能的情况下用户不仅租到了房子还付出了额外的费用，这就是代理模式把不仅可以帮我们实现真实角色的功能还能实现一些特有的功能 

但是这样实现代理模式也有一些弊端，我们每代理一个真实的角色就有去编写一个代理类

为了省去代理类的编写我们便通过动态代理的机制实现

4，动态代理

基于JDK的动态代理

这里我们通过一个类来动态的生成代理类

jdk为我们提供了一个类用和一个接口于实现动态代理

1，InvocationHandler接口

InvocationHandler是由代理实例的调用处理程序实现的接口 。每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。(这是jdk对于这个接口的描述，换句话说就是如果我们想用一个类动态的生成代理类那么这个类一定要实现InvocationHandler) 

这个接口中仅有一个方法声明

invoke(Object proxy, Method method, Object[] args)

处理代理实例上的方法调用并返回结果

这个invoke方法主要作用就是用来执行真实角色中的方法(用method通过反射来执行)并在这个方法中添加代理类特有的功能 

2，Proxy类

在Proxy类中newProxyInstance方法就是为我们生成动态代理类的

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

抽象角色

public interface Calculator {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);
}

真实角色

public class CalculatorImpl implements Calculator {

    @Override
    public int add(int i, int j) {

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        return result;
    }
}

生成代理角色的类

import java.lang.reflect.Proxy;

public class ProxyFactory {
    Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        return  Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                (proxy,method,args)->{
                    System.out.println("方法"+method.getName()+"开始执行");
                    //注意这里使用反射来完成真实角色方法的调用，所以invoke中传入真实角色
                    Object result = method.invoke(target, args);
                    System.out.println("方法"+method.getName()+"执行结束");
                    return result;
                });
    }

}

在这个类中我们可以写一些代理类特有的方法 放在invoke方法中执行

测试

public class TestCal {
    public static void main(String[] args) {
        CalculatorImpl calculator = new CalculatorImpl();
        ProxyFactory proxyFactory = new ProxyFactory(calculator);
        Calculator proxy = (Calculator)proxyFactory.getProxy();
        int add = proxy.add(1, 2);
        System.out.println(add);

    }
}