代理模式（常用）

代理模式（代理设计模式）

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

在软件设计中，使用代理模式的例子也很多，例如，要访问的远程对象比较大（如视频或大图像等），其下载要花很多时间。还有因为安全原因需要屏蔽客户端直接访问真实对象，如某单位的内部数据库等。

代理模式的定义与特点

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

代理模式的优点是：

• 可以控制对象的访问和权限。
• 可以为对象提供额外的功能，例如缓存和延迟加载。
• 可以降低系统的耦合度，使得修改和扩展更加容易。

代理模式的缺点有：

• 代理模式会造成系统设计中类的数量增加
• 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
• 增加了系统的复杂度；

因为存在这些缺点，所以动态代理模式就产生了，用来更好的实现代理模式！

代理模式的结构与实现

代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面是其基本结构和实现方法。

代理模式的主要角色如下：

图1 代理模式的结构图

代理模式的分类

在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。

• 静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
• 动态：在程序运行时运用反射机制动态创建而成，是根据代理的对象，动态创建代理类和代理对象。

静态代理模式

静态代理是最基本的代理模式，它需要手动编写代理类。在 Java 中，可以通过实现或继承相同的接口或父类，使得代理对象拥有与实际对象相同的方法和属性。代理对象在调用实际对象的方法时，可以在方法前或方法后添加一些额外的操作，以实现特定的功能。

用一个简单的实例代码，更好理解！

//创建一个用户接口，并且定义一个方法用来保存用户
public interface User {
    void saveUser();
}

//创建真正实现操作的实现类！用来实现save方法。
public class UserBoss implements User{
    @Override
    public void saveUser() {
        System.out.println(" ---- 保存用户 ---- ");
    }
}
//创建代理用户类，内部存在真正用户对象，来实现代理的方法-》saveUser
public class UserProxy {
    private User user;
    
    public UserProxy(User user){
        this.user = user;
    }

    public void saveUser() {
        System.out.println(" ---- 代理保存开始 ---- ");
        user.saveUser();
        System.out.println(" ---- 代理保存结束 ----");
    }
}
//测试一下
public class SaveUser {
    public static void main(String[] args) {
        User user = new UserBoss();
        UserProxy userProxy = new UserProxy(user);
        userProxy.saveUser();

    }
}

静态代理，如果还不理解，这个案例可以看下，必定懂！
网址：https://zhuanlan.zhihu.com/p/93908252

动态代理模式

最常见的动态代理：

• JDK动态代理：基于接口的动态代理技术
• CGLIB动态代理：基于父类的动态代理技术

JDK动态代理

JDK动态代理主要是基于反射，使用反射解析目标对象的属性、方法等,根据解析的内容生成proxy.class，简单就是在运行时生成一个代理对象，并将所有方法调用转发给我们指定的处理器。

注意: JDK动态代理的调用处理程序必须事先继承 InvocationHandler 接口，使用 Proxy 类中的 newProxyInstance 方法动态的创建代理类。

针对上面的例子，修改一下代码

//创建一个用户接口，并且定义一个方法用来保存用户
public interface User {
    void saveUser();
}

//创建真正实现操作的实现类！用来实现save方法。
public class UserBoss implements User{
    @Override
    public void saveUser() {
        System.out.println(" ---- 保存用户 ---- ");
    }
}

public class UserHandler implements InvocationHandler {
    private User user;
    
    public UserHandler(User user){
        this.user = user;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置增强代码...");
        Object invoke = method.invoke(user, args);
        System.out.println("后置增强代码...");
        return invoke;
    }
}
//test
public static void jdkProxy(){
  User user = new UserBoss();
  InvocationHandler handler = new UserHandler(user);
  
  User proxy = (User)Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(),handler);
  
  proxy.saveUser();
}

CGLIB 动态代理

基于目标对象创建子类的方式实现的，它可以在运行时动态修改目标对象的字节码，从而达到代理的目的，可以代理没有任何接口的类（ JDK动态代理必须要接口）。

相比于静态代理和 JDK 动态代理，CGLIB的性能更优秀，因为其直接操作字节码，避免了反射机制的调用，使得代理方法的调用速度更快。但是，CGLIB也有缺点，就是在创建代理类时需要消耗更多的时间和内存。

1. 使用CGLIB动态代理，首先需要导入相关的Jar包.
2. 创建一个没有实现任何接口的类

public class UserService {
   public void saveUser(){
       System.out.println("---- 保存用户 ----");
   }
}

3. 使用 CGLIB 动态代理来生成代理对象

//增强类
public class UserServiceInterceptor implements MethodInterceptor {
//intercept的参数：第一个是代理对象，第二个是目标方法，第三个是目标方法参数，第四个是代理对象生成的代理方法。
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("执行方法前");
        //result->CGLIB动态代理类实例！
        //proxy->生成的代理类对方法的引用
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("执行方法后");
        return result;
    }
}

4. 测试一下下

public class Main {
	public static void main(String[] args) {
 
 	 Enhancer enhancer = new Enhancer();//创建增强器
 	 enhancer.setSuperclass(UserService.class);//设置代理类的父类
  	 enhancer.setCallback(new UserServiceInterceptor());//设置回调，将增强类引入到生成的代理类中
  	 UserService userService = (UserService)enhancer.create();//创建代理对象
     // 通过代理对象调用目标方法
 	 userService.saveUser();
	}
}

比较常用的就是这两种动态模式，根据代码或许能够能更好的理解！