所谓的代理设计就是指由1个代理主题来操作真实主题，真实主题履行具体的业务操作，而代理主题负责其他相干业务的处理。
系统中常常有这类需求：在某些操作前需要进行验证操作，比如：在添加/删除操作时，先进性用户信息验证，确认该用户是不是具有这些操作的权限。代码以下：
//UserManager接口：
public interface UserManager {
public void addUser(String username, String password);
public void delUser(int userId);
}
//UserManagerImpl类，实现UserManager 接口：
public class UserManagerImpl implements UserManager {
public void addUser(String username, String password) {
checkSecurity();
System.out.println("---------UserManagerImpl.add()--------");
}
public void delUser(int userId) {
checkSecurity();
System.out.println("---------UserManagerImpl.delUser()--------");
}
private void checkSecurity() {
System.out.println("-------checkSecurity-------");
}
}
在添加/删除方法中，加入验证函数checkSecurity()，那末问题来了，如果上百个函数中都需要加验证函数checkSecurity()，那末就要写上百个checkSecurity()函数，如果哪天需求变化了，不需要进行用户验证了，那末就需要在上百个函数中删除checkSecurity()，保护性极差。如何解决此问题？
1，静态代理
添加代理类
public class UserManagerImpl implements UserManager {
public void addUser(String username, String password) {
//checkSecurity();
System.out.println("---------UserManagerImpl.add()--------");
}
public void delUser(int userId) {
//checkSecurity();
System.out.println("---------UserManagerImpl.delUser()--------");
}
// private void checkSecurity() {
// System.out.println("-------checkSecurity-------");
// }
}
//UserManagerImplProxy代理类：（注：该代理类只能为UserManager接口服务）
public class UserManagerImplProxy implements UserManager {
private UserManager userManager;
public UserManagerImplProxy(UserManager userManager) {
this.userManager = userManager;
}
public void addUser(String username, String password) {
checkSecurity();
userManager.addUser(username, password);
}
public void delUser(int userId) {
checkSecurity();
userManager.delUser(userId);
}
private void checkSecurity() {
System.out.println("-------checkSecurity-------");
}
}
静态代理：
代理类――编译时创建，UserManagerImplProxy只能为UserManager接口服务；
通过代理类来进行添加/删除操作，这样就能够确保目标函数不被改变，可保护性增强，但是没有解决根本问题，由于这样1来把问题转移给了代理类，上述讲到的问题仍然存在。如何解决？
2，动态代理：
将共有验证checkSecurity()拿出来，放在单独类中；
代理类――运行时创建，可以为各个接口服务；
动态代理斟酌的问题：把遍及在系统里的独立服务（具有横切性的服务）拿出来放在1个地方，运行时自动放入；斟酌的是横向问题；
代码：
//UserManager接口
public interface UserManager {
public void addUser(String username, String password);
public void delUser(int userId);
}
//UserManagerImpl类 实现UserManager接口
public class UserManagerImpl implements UserManager {
public void addUser(String username, String password) {
//checkSecurity();
System.out.println("---------UserManagerImpl.add()--------");
}
public void delUser(int userId) {
//checkSecurity();
System.out.println("---------UserManagerImpl.delUser()--------");
}
// private void checkSecurity() {
// System.out.println("-------checkSecurity-------");
// }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//需要实现接口InvocationHandler
public class SecurityHandler implements InvocationHandler {
private Object targetObject;//目标类，根据目标创建代理类
//创建代理类
public Object createProxyInstance(Object targetObject) {
this.targetObject = targetObject;
//根据目标生成代理
//参数：第1个参数：代理类 装载代理类；第2个参数：目标接口；第3个参数：
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(),
this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
checkSecurity();
//调用目标方法
Object ret = method.invoke(targetObject, args);
return ret;
}
private void checkSecurity() {
System.out.println("-------checkSecurity-------");
}
}
//客户端
public class Client {
public static void main(String[] args) {
SecurityHandler hander = new SecurityHandler();
//生成代理
UserManager userManager = (UserManager)hander.createProxyInstance(new UserManagerImpl());
userManager.addUser("张3", "123");//调用ddUser()方法
}
}
3，总结
静态代理通常只代理1个类，动态代理是代理1个接口下的多个实现类。
静态代理事前知道要代理的是甚么，而动态代理不知道要代理甚么东西，只有在运行时才知道。
动态代理是实现JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。
还有1种动态代理CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码到达修改类的目的。