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

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

什么是代理模式？

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

为什么要使用代理模式？

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

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

代理模式的两种分类

静态代理

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

优点： 简单易懂

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

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

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

public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;

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

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

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

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

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

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy(userService);
        User user = new User("John");
        proxy.addUser(user);
        proxy.deleteUser(1);
    }
}

动态代理

动态代理是一种在运行时动态生成代理类的代理模式。它可以在不修改原始类的情况下，为原始类提供额外的功能或控制访问。在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("Adding user...");
    }

    @Override
    public void deleteUser() {
        System.out.println("Deleting user with ID...");
    }
}

创建一个实现 InvocationHandler 接口的代理处理器类 LogInvocationHandler，它负责在方法执行前后添加日志记录的功能。

public class LogInvocationHandler implements InvocationHandler {
    private Object target;

    public LogInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After " + method.getName());
        return result;
    }
}

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

public class Main {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        LogInvocationHandler handler = new LogInvocationHandler(userService);

        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                handler
        );

        proxy.addUser();
        proxy.deleteUser();
    }
}

CGLIB动态代理

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

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

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

public class UserService {
    public void addUser() {
        System.out.println("Adding user...");
    }

    public void deleteUser() {
        System.out.println("Deleting user with ID... ");
    }
}

一个代理类 LogProxy，它继承了被代理类 UserService。

public class LogProxy extends UserService implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After " + method.getName());
        return result;
    }
}

最后，我们可以使用 Enhancer 类来创建代理对象。

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new LogProxy());

        UserService proxy = (UserService) enhancer.create();
        
        proxy.addUser();
        proxy.deleteUser();
    }
}

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

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

总结

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

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