代理设计模式

代理模式分为两种：

　　　　1、静态代理

　　　　2、动态代理

                    1）jdk实现的动态代理

　　　　　  2）cglib实现的动态代理

代理模式的核心组件：代理对象，目标对象

静态代理：

       优点：扩展以及重用目标对象的功能！

       缺点：代理对象和目标对象的关系，编译前已经确定，如果代理模式中的接口功能出变动，代理对象和目标对象都需要进行维护

关系图：

静态代理模式的实现步骤：

 1、创建接口

 2、创建代理类并实现 第一步创建的接口

     2.1）通过构造函数传入的接口对象，调用目标对象方法接建立代理对象和目标对象的关系

 3、创建目标类并实现 第一步创建的接口

---

创建接口：

public interface ProxyInterface {
    //找工作
    String lookForJob();
}

创建代理类并实现接口：

public class ProxyObject implements ProxyInterface {

    private ProxyInterface  proxyInterface;

    public ProxyObject(ProxyInterface proxyInterface) {
        this.proxyInterface = proxyInterface;
    }

    @Override
    public String lookForJob() {
        //如果返回的是1，则表示通过智联没有找到工作，返回2则表示找到工作
        String s = proxyInterface.lookForJob();
        //如果通过智联没有找到工作，则使用boss继续找工作
        if (s.equals("1")) {
            System.out.println("通过boss找工作");
            return "2";
        }
        return s;
    }
}

创建目标类并实现接口：

public class TargetObject implements ProxyInterface{
    @Override
    public String lookForJob() {
        System.out.println("通过智联找工作");
        return "1";
    }
}

客户端调用：

public class ProxyTest {

    public static void proxyClient(ProxyInterface proxyInterface){
        proxyInterface.lookForJob();
    }

    public static void main(String[] args) {
        proxyClient(new ProxyObject(new TargetObject()));
    }
}

---

_{动态代理：}

   优点：扩展，复用

   缺点：复杂不易理解，代码重复，（jdk动态代理必须实现接口）

jdk动态代理核心组件：Proxy类，invocationhandler接口

动态代理实现步骤：

 1、创建接口

 2、创建目标类并实现接口

 3、创建代理类，并实现invocationhandler接口

创建接口：

public interface DynamicInterface {

    String lookForJob();
}

创建目标类并实现接口：

public class DynamicTargetObject implements DynamicInterface {
    @Override
    public String lookForJob() {
        System.out.println("智联找工作");
        return "1";
    }
}

创建代理类，并实现invocationhandler接口：

public class DynamicProxyObject implements InvocationHandler {

    private Object object;

    public DynamicProxyObject(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(object,args);
    }
}

调用：

public class DynamicProxyTest {

    public static void dynamicProxyClient(DynamicInterface dynamicInterface){
        //如果返回的是1，则表示通过智联没有找到工作，返回2则表示找到工作
        String s = dynamicInterface.lookForJob();
        //如果通过智联没有找到工作，则使用boss继续找工作
        if (s.equals("1")) {
            System.out.println("通过boss找工作");
        }
    }

    public static void main(String[] args) {
        DynamicTargetObject dynamicTargetObject = new DynamicTargetObject();
        Object o = Proxy.newProxyInstance(dynamicTargetObject.getClass().getClassLoader(),
                dynamicTargetObject.getClass().getInterfaces(),
                new DynamicProxyObject(dynamicTargetObject));
        dynamicProxyClient((DynamicInterface) o);
    }
}