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

参考博客：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); } }

运行结果：