代理模式：控制访问的设计模式

代理模式：控制访问的设计模式

什么是代理模式？

代理模式是一种常见的设计模式，它允许通过代理对象来控制对真实对象的访问。代理模式的主要目的是在不改变原始对象的情况下，提供额外的功能或控制访问。

为什么要使用代理模式？

代理模式有以下几个主要的应用场景：

• 访问控制：代理模式可以限制对真实对象的直接访问，只有通过代理对象才能访问真实对象。这样可以实现对真实对象的访问控制，例如权限验证、身份验证等。
• 增加额外功能：代理模式可以在不修改真实对象的情况下，为其增加额外的功能。代理对象可以在调用真实对象的方法前后执行一些额外的操作，例如日志记录、性能监控、缓存等。
• 远程访问：代理模式可以实现远程访问，即通过代理对象访问位于不同地址空间的真实对象。这对于分布式系统或跨网络的应用程序非常有用。

代理模式的两种分类

静态代理

静态代理是在编译时就已经确定代理对象和真实对象的关系。代理对象和真实对象实现相同的接口或继承相同的父类，代理对象持有真实对象的引用，并在调用真实对象的方法前后执行一些额外的操作。

优点： 简单易懂

缺点： 需要为每个真实对象编写一个代理类，当真实对象较多时，会导致代码冗余

案例： 一个简单的日志记录功能

假设我们有一个 UserService 接口和一个实现类 UserServiceImpl，它提供了用户管理的一些基本操作方法，如添加用户、删除用户等。现在我们需要在每个方法执行前后记录日志，例如：在方法执行前，打印 “Before” 的日志；在方法执行后，打印 “After” 的日志。

// UserService 接口
public interface UserService {
    void addUser();
    void deleteUser();
}

// 实现类 UserServiceImpl
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户...");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户...");
    }
}

// 静态代理类
public class UserServiceProxy implements UserService {
    private UserService userService;

    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void addUser() {
        System.out.println("Before...");
        userService.addUser();
        System.out.println("After...");
    }

    @Override
    public void deleteUser() {
        System.out.println("Before...");
        userService.deleteUser();
        System.out.println("After...");
    }

    // 其他方法同样的方式实现
}

接下来，我们可以使用代理类来代替真实对象进行操作。

public class Client {
    public static void main(String[] args) {
        // 静态代理
        UserServiceProxy proxy = new UserServiceProxy(new UserServiceImpl());
        proxy.addUser();
        System.out.println("------------------");
        proxy.deleteUser();
    }
}

结果：

动态代理

动态代理是一种在运行时动态生成代理类的代理模式。它可以在不修改原始类的情况下，为原始类提供额外的功能或控制访问。在Java中，有两种常见的动态代理方式：JDK动态代理和CGLIB动态代理

JDK动态代理

JDK动态代理是通过Java的反射机制实现的。它要求被代理的类必须实现一个接口。JDK动态代理提供了一个Proxy类和一个InvocationHandler接口，通过这两个类可以动态生成代理类。

案例： 简单的日志记录功能

定义一个接口 UserService，它提供了用户管理的一些基本操作方法。

public interface UserService {
    void addUser();
    void deleteUser();
}

真实的用户服务类UserServiceImpl，它实现了 UserService 接口。

public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户...");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户...");
    }
}

通过Proxy类，创建代理对象UserServiceProxy对目标对象的方法进行拦截和增强

public class UserServiceProxy {
    private Object target;

    public UserServiceProxy(Object target) {
        this.target = target;
    }
	 /**
     * target：目标对象，即要被代理的对象。
     * getProxyInstance()：该方法返回一个代理对象，该代理对象实现了目标对象所实现的接口，并在方法调用前后执行额外的逻辑。
     * Proxy.newProxyInstance()：这是Java提供的创建代理对象的方法。它接受三个参数：类加载器、目标对象实现的接口数组和一个InvocationHandler对象。
     * InvocationHandler：这是一个接口，用于定义代理对象的方法调用处理逻辑。在invoke()方法中，我们可以在目标方法调用前后执行额外的逻辑。
     */
    public  Object getProxyInstance(){

        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println(gdk代理模式---开始);
                        Object invoke = method.invoke(target, args);
                        System.out.println(gdk代理模式---结束);
                        return invoke;
                    }
                });
    }
}

最后，我们可以使用 Proxy 类的 newProxyInstance 方法来创建代理对象。

public class Client {
    public static void main(String[] args) {
        // JDK动态代理
        UserService proxy = (UserService) new UserServiceProxy(new UserServiceImpl()).getProxyInstance();
        proxy.addUser();
        System.out.println("-----------------");
        proxy.deleteUser();
    }
}

CGLIB动态代理

CGLIB动态代理是通过继承被代理类来实现的，它不要求被代理的类实现接口。CGLIB动态代理使用了字节码生成库来生成代理类。

案例：简单的日志记录功能

定义一个类 UserService，它提供了用户管理的一些基本操作方法。

public interface UserService {
    void addUser();
    void deleteUser();
    // 带返回结果
    int getUserCount();
}

真实的用户服务类UserServiceImpl，它实现了 UserService 接口。

public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户...");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户...");
    }
 	// 带返回结果
    @Override
    public int getUserCount() {
        System.out.println("查询用户数量...");
        return 66;
    }
}

一个代理类 UserServiceProxy ，它实现了MethodInterceptor 接口。

public class UserServiceProxy implements MethodInterceptor {
    // 维护一个目标对象
    private Object target;

    // 构造器，传入一个被代理的对象
    public UserServiceProxy(Object target) {
        this.target = target;
    }

    // 返回一个代理对象，target的代理对象
    public Object getProxyInstance() {
        // 1. 创建一个工具类
        Enhancer enhancer = new Enhancer();
        // 2. 设置父类
        enhancer.setSuperclass(target.getClass());
        // 3. 设置回调函数
        enhancer.setCallback(this);
        // 4. 创建子类对象，即代理对象
        return enhancer.create();
    }
    // 重写 intercept 方法，会调用目标对象的方法
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib代理模式---开始");
        Object returnVal = method.invoke(target, objects);
        System.out.println("cglib代理模式---结束");
        return returnVal;
    }
}

最后，我们可以使用UserServiceProxy的getProxyInstance方法创建代理对象实例，调用方法。

public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserServiceImpl();
        // 获取代理对象，并将目标对象传递到代理对象
        UserService proxyInstance = (UserService) new UserServiceProxy(userService).getProxyInstance();
        // 执行代理对象的方法，触发intecept方法，从而实现目标对象的调用
        proxyInstance.addUser();
        System.out.println("-------------");
        int userCount = proxyInstance.getUserCount();
        System.out.println(userCount);
    }

jdk动态代理和cglib动态代理的区别

1. 实现方式：jdk动态代理是通过反射实现的，而cglib动态代理是通过继承目标类来实现的。
2. 目标类限制：jdk动态代理要求目标类必须要实现接口，而cglib动态代理则没有这个限制。
3. 性能：jdk动态代理相对于cglib动态代理来说，因为实现方式不同，生成的代理类的效率会低一些。
4. 对象类型：jdk动态代理只能代理实现了接口的类，cglib通过继承实现，不能代理 final 类。
5. 依赖库：jdk动态代理是Java自带的库，不需要额外的依赖，而cglib动态代理需要依赖cglib库。

总结

代理模式是一种非常有用的设计模式，它可以实现访问控制、增加额外功能和远程访问。静态代理在编译时确定代理对象和真实对象的关系，而动态代理在运行时动态生成代理对象。动态代理又分为jdk动态代理和cglib动态代理，分别基于接口和类来实现代理功能。根据具体的需求和场景，选择适合的代理模式可以提高代码的可维护性和灵活性。
区别：

• 与适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。
• 与装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

---

学习更多设计模式