设计模式——代理模式

知识点：静态代理和动态代理

参考博客：https://www.cnblogs.com/daniels/p/8242592.html

                  https://blog.csdn.net/familyshizhouna/article/details/78905997

一：什么是代理模式

代理模式是给某个对象提供一个代理对象，由代理对象调用原对象的方法，类似我们生活中的中介，经纪人的角色，本人不直接去做，找一个人代替我们去做一些事情。

二：使用代理模式的好处

a.中介隔离作用：当我们不想直接调用一个对象时，代理对象可以起一个中介隔离的作用，被代理对象和代理对象都实现相同的接口

b.遵循开闭原则：我们可以通过代理类，在被代理类功能前后，加入一些公共服务，比如缓存，日志等，而不用修改原被代理类

三：代理模式的分类

 按创建代理的时间分类可以分为：静态代理和动态代理

   静态代理是代码创建后编译，运行之前，代理类的.class文件就已经创建了；

  动态代理：是在程序运行时，通过反射机制动态创建代理对象的（另一篇博客简略地介绍Java中的反射：https://www.cnblogs.com/shuaifing/p/10863645.html）

（1）静态代理

//代理模式（静态代理）
//测试类
public class StaticProxy {
    public static void main(String[] args) {
        Object obj=new ProxyObject();
        obj.action();
    }
}
//公共接口
interface Object{
    void action();
}
//代理类
class ProxyObject implements  Object{
    Object obj;
    public ProxyObject(){
        System.out.println("代理类构造方法创建被代理类");
        obj=new ObjectImp();
    }
    @Override
    public void action() {
        System.out.println("代理类执行被代理类中的方法");
       obj.action();
    }
}
//被代理类
class ObjectImp implements  Object{
    @Override
    public void action() {
        System.out.println("被代理类输出的内容！");
    }
}
运行结果：

（2）动态代理

当有多个类要代理的话，手动创建多个代理对象比较麻烦，代码冗余，动态产生代理对象的话，代码更加灵活，方便

//动态代理，反射是动态语言的关键
//测试类
public class DynamicProxy {
    public static void main(String[] args) {
        //1.被代理类的对象
        RealSubject realSubject=new RealSubject();
        //2.创建一个实现InvocationHandler接口类的对象
        MyInvocationHandler handler=new MyInvocationHandler();
        //3.调用blind()方法，动态返回一个实现了跟被代理类所实现接口的代理对象
        Object obj=handler.blind(realSubject);
        Subject subject=(Subject) obj;//subject是代理类对象
        subject.action();//代理类对象调用action(),会转到对InvocationHandler接口实现类的invoke()方法调用
     

        //增加另一个 ObjectImp的被代理对象，返回相应的代理对象
        ObjectImp objIml=new ObjectImp();
        com.kdgc.interfacetest.Object proxyObject= (com.kdgc.interfacetest.Object)handler.blind(objIml);
        proxyObject.action();
    }
}
//公共接口
interface Subject{
    void action();
}
//被代理类
class RealSubject implements Subject{
    @Override
    public void action() {
        System.out.println("被代理类要执行的方法！");
    }
}
class MyInvocationHandler implements InvocationHandler{
    Object obj;//实现了接口的被代理对象的声明

    //1.给被代理对象实例化 2.返回一个代理类的对象
    public Object blind(Object obj){
        this.obj=obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }
    //当通过代理类的对象发起对被重写方法的调用时，会转化为对下面的invoke方法的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object val=method.invoke(obj,args);
        return val;
    }
}

运行结果：

 (3)补充：动态代理与AOP

在固定的代码的位置，动态地调用不同对象的方法

   //测试类

public class AOPTest {
    public static void main(String[] args) {
        Man man = new Man();
        Person person = (Person) MyProxy.getProxyInstance(man);
        person.drink();
        person.eat();
    }
}
//公共接口
interface Person{
    void eat();
    void drink();
}
//被代理类
class Man implements Person{
    @Override
    public void eat() {
        System.out.println("吃东西！");
    }
    @Override
    public void drink() {
        System.out.println("喝水！");
    }
}
//固定的方法
class ChangelessMethodUtil{
   public void method1(){
       System.out.println("===========方法1==========");
   }
   public void method2(){
       System.out.println("============方法2===========");
   }
}
class MyInvocationHanlder implements InvocationHandler{
    Object obj;//代理类的声明
    public void setObject(Object obj){
        this.obj=obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        ChangelessMethodUtil changelessMethodUtil=new ChangelessMethodUtil();
        changelessMethodUtil.method1();

         method.invoke(obj,args);

         changelessMethodUtil.method2();
         return null;
    }
}
class MyProxy{
    //动态创建一个代理类的对象
    public static Object getProxyInstance(Object obj){
        MyInvocationHanlder hanlder=new MyInvocationHanlder();
        hanlder.setObject(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),hanlder);
    }
}

运行结果：