所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。

     系统中经常有这种需求：在某些操作前需要进行验证操作，比如：在添加/删除操作时，先进性用户信息验证，确认该用户是否拥有这些操作的权限。代码如下：

//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接口服务；

通过代理类来进行添加/删除操作，这样就可以确保目标函数不被改变，可维护性增强，但是没有解决根本问题，因为这样一来把问题转移给了代理类，上述讲到的问题依然存在。如何解决？

2，动态代理：

将共有验证checkSecurity()拿出来，放在单独类中；

代理类——运行时创建，可以为各个接口服务；

动态代理考虑的问题：把遍布在系统里的独立服务（具有横切性的服务）拿出来放在一个地方，运行时自动放入；考虑的是横向问题；

代码：

//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("张三", "123");//调用ddUser()方法
	}


}

3，总结

    静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。 
     静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道。 
     动态代理是实现JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。 
    还有一种动态代理CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到修改类的目的。

静态代理和动态代理