代理模式

代理模式

代理的意义

• 在原功能上增加新的功能，为了保证代码的稳定和安全不能直接对原代码进行更改，那怎么办呢？这个时候代理就出现了，代理就是对原功能的代理，并且增强其功能，通过代理对象访问目标对象。比如一辆车会跑，这个时候还需要记录跑的里程，为了不影响跑的功能，只需给车新增一个代理，就可以实现不影响原功能的基础上记录里程。

代理模式的实现方式

静态代理

1. 静态代理是开始就确定了要代理的对象，编译时生成的代理类，代理类和被代理类需要实现相同的接口

2. 示例

   • 一个carService接口拥有run功能，现在需要记录跑的里程，新增代理类carServiceProxy代理car并实现记录里程功能

     // CarService接口
     public interface CarService {
         void run();
     }
     
     // 火车实现跑的功能
     public class TrainService implements CarService{
         @Override
         public void run() {
             System.out.println("train is running");
         }
     }
     
     // 代理火车 实现记录里程功能
     public class TrainServiceProxy implements CarService {
         private CarService carService;
     
         public TrainServiceProxy(TrainService trainService) {
             this.carService = trainService;
         }
     
         @Override
         public void run() {
             System.out.println("start record mile");
             carService.run();
             System.out.println("stop record mile");
         }
     }
     
     // 输出
     start record mile
     train is running
     stop record mile
     

   • 静态类有个局限性，就是对每一个代理对象都要新增一个代理类，比如火车记录里程需要一个代理类，汽车也需要一个，这就意味着需要许多的代理类，这就造成了大量的重复工作，动态代理可以解决这个问题。

动态代理

• 动态代理是在运行时生成的代理类，是用来代理 需要实现同一功能的对象，比如记录日志功能
• 动态代理又分为jdk动态代理, cglib动态代理

jdk动态代理

1. 需要实现InvocationHandler接口

2. 示例

   // 动态代理类
   public class LogProxyService implements InvocationHandler {
       // 目标对象
       private Object target;
   
       public Object newInstanceProxy(Object target) {
           this.target = target;
   
           Class<?> targetClass = target.getClass();
           // 返回代理对象
           return Proxy.newProxyInstance(targetClass.getClassLoader(), targetClass.getInterfaces(), this);
       }
   
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           System.out.println("start record log");
           Object invoke = method.invoke(target, args);
           System.out.println("stop record log");
   
           return invoke;
       }
   }
   
   public class ProxyExerService {
       public static void main(String[] args) {
           CarService carService = new TrainService();
           LogProxyService logProxyService = new LogProxyService();
           CarService targetProxy = (CarService)logProxyService.newInstanceProxy(carService);
           targetProxy.run();
       }
   }
   

cglib动态代理

1. 静态代理和jdk动态代理有一个限制就是要求目标对象必须要实现接口，所以单独的对象没有实现接口就不能用jdk动态代理了，这个时候可以使用Cglib动态代理。

2. Cglib代理也叫做子类代理，在内存中构造一个目标类的子类从而实现对目标类功能的扩展

3. 代理类不能是final类型，final类型的类不能被继承

4. 示例：

   public class CglilbProxyService implements MethodInterceptor {
       // 目标对象
       private Object target;
   
       public CglilbProxyService(Object target) {
           this.target = target;
       }
   
       // 创建代理对象
       public Object newProxyInstance() {
           // 工具类
           Enhancer enhancer = new Enhancer();
           // 设置父类
           enhancer.setSuperclass(target.getClass());
           // 设置回调函数
           enhancer.setCallback(this);
           // 创建子类(代理对象)
           return enhancer.create();
       }
   
       @Override
       public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
           System.out.println("start cglib proxy");
           // 执行目标对象的方法
           Object result = method.invoke(target, args);
           System.out.println("end cglib proxy");
           return result;
       }
   }
   
   // 测试类
   public class ProxyExerService {
       public static void main(String[] args) {
           TrainServiceCglib carService = new TrainServiceCglib();
           TrainServiceCglib trainServiceProxy1 = (TrainServiceCglib) new CglilbProxyService(carService).newProxyInstance();
           trainServiceProxy1.run();
       }
   
   }