代理

定义：给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用

整个设计模式，我们需要对拓展开放，对修改关闭

目的：

• 通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性
• 通过代理对象对原有的业务增强

真实对象：代理对象所代表的真实对象，最终被引用的对象

抽象对象：声明了真实对象和代理对象的公共接口

代理对象：包含真实对象从而操作真实主题对象，相当于访问与真实对象直接的中介

静态代理

整体结构

//接口
public interface MTFactory {
    void saleMT(String s);
}
//实现类
public class AFactory implements MTFactory {
    @Override
    public void saleMT(String s) {
        System.out.println("AFactory 方法正在执行--"+s);
    }
}
//静态代理实现
//扩展能力差
//可维护性差
public class StaticProxy implements MTFactory, WTFactory {
    //包含真实对象
    public MTFactory factory;
    public WTFactory wtFactory;
    public StaticProxy(MTFactory factory) {
        this.factory=factory;
    }
    public StaticProxy(WTFactory wtFactory) {
        this.wtFactory=wtFactory;
    }
    @Override
    public void saleMT(String s) {
        dosomeBefore();//前置增强
        factory.saleMT(s);
        dosomeEnd();//后置增强
    }
    private void dosomeEnd() {
        System.out.println("前置增强正在执行");
    }
    private void dosomeBefore() {
        System.out.println("后置增强在执行");
    }
    @Override
    public void saleWT(int l) {
        dosomeBefore(); 
        wtFactory.saleWT(2);
        dosomeEnd();
    }
}
//CLient
public class Client {
    public static void main(String[] args) {
        MTFactory mtFactory=new AFactory();
        ShiXian shiXian = new ShiXian(mtFactory);
        shiXian.saleMT("D");
    }
}

静态代理的时候，每当我们需要多一个需求的时候，就需要多一个接口，一个实现方法，然后具体引用这个方法的时候还需要更改。不便于拓展。

动态代理

动态代理核心：Proxy，InvocationHandler

Proxy：proxy provides static methods for creating dynamic proxy classes and instance,and it is also the superclass of all dynamic proxy classes created by those method.

通过

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

动态生成代理对象

InvocationHandler：{@code InvocationHandler} is the interface implemented by the invocation handler of a proxy instance.

 public interface InvocationHandler {
     public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

public class Dynamic implements InvocationHandler {
    //绑定委托对象，并返回代理类
    private Object factory;
    public Object getFactory() {
        return factory;
    }
    public void setFactory(Object factory) {
        this.factory = factory;
    }
    //通过Proxy获取动态代理的对象,实现该类的所有接口并取得代理类
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        dosomeBefore();
        //围绕这个方法就是AOP
        Object invoke = method.invoke(factory,args);
        dosomeEnd();
        //调用代理对象
        return invoke;
    }
    private void dosomeEnd() {
        System.out.println("前置增强正在执行");
    }
    private void dosomeBefore() {
        System.out.println("后置增强在执行");
    }
}
执行
    public class Client {
    public static void main(String[] args) {
        //静态代理
/*        MTFactory mtFactory=new AFactory();
        StaticProxy shiXian = new StaticProxy(mtFactory);
        shiXian.saleMT("D");
        System.out.println("====================================");*/
        //动态代理
        MTFactory mtFactory=new AFactory();
        Dynamic dynamic =new Dynamic();
        dynamic.setFactory(mtFactory);
        MTFactory proxyInstance = (MTFactory) dynamic.getProxyInstance();
        proxyInstance.saleMT("D");
        System.out.println("============================");
    }
}