Java代理模式的深入了解

一、静态代理模式

1.1、 代理模式的定义：

由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

比如在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。

静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。

代码实例：实现增删改查操作，通过代理

接口：

package com.proxyPattern.staticProxy2;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.staticProxy2
* @className UserService
* @date 2021/12/27 17:54
* @Description 服务接口
*/
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}

真实类（这里是服务类）

package com.proxyPattern.staticProxy2;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.staticProxy2
* @className UserServiceImp
* @date 2021/12/27 17:55
* @Description 服务实现类
*/
public class UserServiceImp implements UserService{
   @Override
   public void add() {
       System.out.println("添加了一条数据");
   }
   @Override
   public void delete() {
       System.out.println("删除了一条数据");
   }
   @Override
   public void update() {
       System.out.println("修改了一条数据");
   }
   @Override
   public void query() {
       System.out.println("查询了一条数据");
   }
}

代理类

package com.proxyPattern.staticProxy2;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.staticProxy2
* @className UserServiceProxy
* @date 2021/12/27 17:56
* @Description 服务代理类
*/
public class UserServiceProxy implements UserService {
   private UserServiceImp userServiceImp;
   public UserServiceProxy() {
   }
   public void setUserServiceImp(UserServiceImp userServiceImp) {
       this.userServiceImp = userServiceImp;
   }
   @Override
   public void add() {
       getLog("add");
       userServiceImp.add();
   }
   @Override
   public void delete() {
       getLog("delete");
       userServiceImp.delete();
   }
   @Override
   public void update() {
       getLog("update");
       userServiceImp.update();
   }
   @Override
   public void query() {
       getLog("add");
       userServiceImp.query();
   }
   public void getLog(String message) {
       System.out.println("日志：" + message + "语句执行了");
   }
}

客户端测试类

package com.proxyPattern.staticProxy2;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.staticProxy2
* @className Customer
* @date 2021/12/27 18:00
* @Description 客户终端测试类
*/
public class Customer {
   public static void main(String[] args) {
       UserServiceImp userServiceImp = new UserServiceImp();
       UserServiceProxy p = new UserServiceProxy();
       p.setUserServiceImp(userServiceImp);
       p.add();
       p.update();
       p.delete();
       p.query();
   }
}
/**
* 执行结果：
* 日志：add语句执行了
* 添加了一条数据
* 日志：update语句执行了
* 修改了一条数据
* 日志：delete语句执行了
* 删除了一条数据
* 日志：add语句执行了
* 查询了一条数据
*/

        上述代码看到我们并没有使用userServiceImp去执行方法，而是使用了一个代理类去执行，这就是代理模式，类似于你租房并没有找房东租房，而是找的一个中间代理人中介来完成租房这个动作。

1.2、代理模式的优缺点

那么代理模式有哪些优点呢？

1、可以使得我们的真实角色更加纯粹 ，不再去关注一些公共的事情 
2、公共的业务由代理来完成 . 实现了业务的分工 
3、公共业务发生扩展时变得更加集中和方便 

缺点

1、代理模式会造成系统设计中类的数量增加

2、在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；

3、增加了系统的复杂度；

 如何解决这些问题呢？就靠下面的 * 模式来解决

二、 * 模式

动态，是指在程序运行时，运用反射机制动态创建而成

没错，动态的代理模式使用的是反射，而且要自己写一个 * 类去动态的获取一个代理类

代码实例：案例同上，只不过采用的是 * 模式

服务实现类（真实类）

package com.proxyPattern.staticProxy2;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.staticProxy2
* @className Customer
* @date 2021/12/27 18:00
* @Description 客户终端测试类
*/
public class Customer {
   public static void main(String[] args) {
       UserServiceImp userServiceImp = new UserServiceImp();
       UserServiceProxy p = new UserServiceProxy();
       p.setUserServiceImp(userServiceImp);
       p.add();
       p.update();
       p.delete();
       p.query();
   }
}
/**
* 执行结果：
* 日志：add语句执行了
* 添加了一条数据
* 日志：update语句执行了
* 修改了一条数据
* 日志：delete语句执行了
* 删除了一条数据
* 日志：add语句执行了
* 查询了一条数据
*/

接口：

package com.proxyPattern. autoProxy;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.staticProxy2
* @className UserService
* @date 2021/12/27 17:54
* @Description 服务接口
*/
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}

* 类，这个几乎可以做一个工具类使用，因为格式固定        

package com.proxyPattern.autoProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.autoProxy
* @className ProxyInvocationHandler
* @date 2021/12/27 19:33
* @Description * 类
*/
public class ProxyInvocationHandler implements InvocationHandler {
   //被代理的接口
   private Object target;
   public void setTarget(Object target) {
       this.target = target;
   }
   /**
    * @Date  2021/12/27 19:36
    * @Param
    * @Return Object
    * @MetodName getProxy
    * @Author wang
    * @Description 生成得到代理类
    */
   public Object getProxy() {
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
   }
   /**
    * @Date  2021/12/27 19:34
    * @Param
    * @param proxy
    * @param method
    * @param args
    * @Return Object
    * @MetodName invoke
    * @Author wang
    * @Description 处理代理实例，并返回结果
    */
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       log(method.getName());
       Object result = method.invoke(target, args);
       return result;
   }
   public void log(String message) {
       System.out.println("日志：" + message + "语句执行了" );
   }
}

客户端测试类：

package com.proxyPattern.autoProxy;
/**
* @author wang
* @version 1.0
* @packageName com.proxyPattern.staticProxy2
* @className Customer
* @date 2021/12/27 18:00
* @Description 客户终端测试类
*/
public class Customer {
   public static void main(String[] args) {
      //真实角色
       UserService userService = new UserServiceImp();
       //代理角色
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       //动态设置代理的对象
       pih.setTarget(userService);
       //动态生成代理类
       UserService proxy = (UserService) pih.getProxy();
       proxy.query();
       proxy.update();
   }
}
/**
* 日志：query语句执行了
* 查询了一条数据
* 日志：update语句执行了
* 修改了一条数据
*/

可以看到我们这里可以更方便的去获取代理类了，只需要将动态设置代理类那里的对象改一下，就可以去代理别的类。

来源：https://blog.csdn.net/ww166955/article/details/122179161