代理模式

定义

代理模式，为其他对象提供一种代理以控制对这个对象的访问

具体实现

代理模式的具体实现描述可以分为以下几个步骤：

创建抽象对象接口（Subject Interface）：
- 定义抽象对象接口，包含原始对象和代理对象共同实现的方法。

/*** 抽象对象接口**/
public interface UserManager {public void addUser(String userId, String userName);public void delUser(String userId);public void modifyUser(String userId, String userName);public String findUser(String userId);
}

2. 创建原始对象（Real Object）：

实现抽象对象接口的具体类，即原始对象。

public class UserManagerImpl implements UserManager {public void addUser(String userId, String userName) {try {System.out.println("UserManagerImpl.addUser() userId-->>" + userId);}catch(Exception e) {e.printStackTrace();throw new RuntimeException();}	}public void delUser(String userId) {System.out.println("UserManagerImpl.delUser() userId-->>" + userId);}public String findUser(String userId) {System.out.println("UserManagerImpl.findUser() userId-->>" + userId);return "张三";}public void modifyUser(String userId, String userName) {System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);}}

3. 创建代理对象（Proxy Object）：

实现抽象对象接口的具体类，即代理对象。
在代理对象中持有一个对原始对象的引用。

/*** 代理类**/
public class UserManagerImplProxy implements UserManager {private UserManager userManager;public UserManagerImplProxy(UserManager userManager) {this.userManager = userManager;}public void addUser(String userId, String userName) {try {System.out.println("start-->>addUser() userId--代理类-->>" + userId);userManager.addUser(userId, userName);System.out.println("success--代理类-->>addUser()");}catch(Exception e) {e.printStackTrace();System.out.println("error--代理类-->>addUser()");}	}public void delUser(String userId) {}public String findUser(String userId) {return null;}public void modifyUser(String userId, String userName) {}}

在代理对象中添加额外逻辑：
- 在代理对象的方法中，可以在调用原始对象之前或之后执行一些额外的逻辑。
- 这些额外逻辑可以是权限验证、日志记录、缓存操作等。
在客户端中使用代理对象：
- 在客户端代码中，通过代理对象来访问原始对象的方法。
- 客户端不直接访问原始对象，而是通过代理对象进行间接访问。

public class Client {/*** @param args*/public static void main(String[] args) {//创建代理对象，同时将被代理的对象通过构造函数传入到代理对象中UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());//调用代理对象的方法userManager.addUser("0001", "张三");}}

分析优缺点

上面写的代码都是静态代理模式的，所以这里罗列优缺点的基础也是基于静态代理的：
优点：

额外功能：静态代理可以在代理对象中添加额外的功能，而无需修改真实对象的代码。这使得我们可以在不影响真实对象的情况下，对其进行功能扩展，例如添加日志记录、性能监控等。
控制访问：静态代理可以在代理对象中控制对真实对象的访问。代理对象可以验证参数、权限等，并决定是否允许客户端访问真实对象。
解耦合：静态代理可以将真实对象与客户端代码解耦合。客户端只需要通过代理对象与真实对象进行交互，而无需关注真实对象的具体实现。

缺点：

代码重复：静态代理需要手动创建代理对象，并在代理对象中实现与真实对象相同的接口。这可能导致代理对象和真实对象之间的代码重复，增加了维护的工作量。
增加类的数量：静态代理需要为每个真实对象创建一个代理对象，这可能导致类的数量增加。如果需要代理多个真实对象，就需要为每个真实对象创建一个代理对象，这可能导致类的爆炸增长。
编译时确定：静态代理在编译时就确定了代理对象和真实对象的关系，无法动态改变。如果需要在运行时动态决定代理对象的行为，静态代理就无法满足需求。

优化使用动态代理解决

优化

使用动态代理来优化上述的静态代理代码，可以解决静态代理中的一些不足之处，如代码重复和类数量增加。下面是使用动态代理进行优化的示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class DynamicProxyDemo {public static void main(String[] args) {UserManager userManager = new UserManagerImpl();UserManager proxy = (UserManager) getProxyInstance(userManager);proxy.addUser("0001", "张三");}public static Object getProxyInstance(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new DynamicProxyHandler(target));}
}class DynamicProxyHandler implements InvocationHandler {private Object target;public DynamicProxyHandler(Object target) {this.target = target;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object result;try {System.out.println("start-->>" + method.getName() + "() userId--代理类-->>" + args[0]);result = method.invoke(target, args);System.out.println("success--代理类-->>" + method.getName() + "()");} catch (Exception e) {e.printStackTrace();System.out.println("error--代理类-->>" + method.getName() + "()");throw new RuntimeException();}return result;}
}

通过使用动态代理，我们可以避免手动创建代理对象和实现代理接口的繁琐工作。在上述代码中，我们创建了一个DynamicProxyHandler类实现了InvocationHandler接口，它负责处理代理对象的方法调用。在getProxyInstance方法中，我们使用Proxy.newProxyInstance动态生成代理对象，并将DynamicProxyHandler作为参数传入。最后，我们可以直接调用代理对象的方法，实现对真实对象的代理。

使用动态代理优化静态代理的不足之处包括：