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

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

//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-------");
	}		
}

//client
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，代理的是类，不须要业务类继承接口，通过派生的子类来实现代理。通过在执行时，动态改动字节码达到改动类的目的。