首先介绍一下。什么是代理：

代理模式，是经常使用的设计模式。

特征是。代理类与托付类有同样的接口，代理类主要负责为托付类预处理消息、过滤消息、把消息转发给托付类。以及事后处理消息。

代理类和托付类，存在着关联关系。代理类的对象本身并不真正实现服务，知识通过调用托付类的对象的相关方法。

代理类能够分为两种：静态代理和动态代理。

静态代理：

代理类是由程序猿创建，或由工具生成的代码 编译成的。

在程序执行前，代理类的 *.class文件已经存在了。直接就能够执行 。

动态代理：

动态代理的代理类。

没有直接由源码生成。动态代理类的对象是在程序执行时由JAVA反射机制动态生成。不须要手工编写源码。从而提高了软件的可扩展性。JAVA反射机制能够生成随意类型的动态代理类。

静态代理的实现：

接口：

package test.static.pattern;

public interface UserManager {

	public void addUser(String userId,String userName);

	public void delUser(String userId);

	public String findUser(String userId);

	public void modifyUser(String userId,String userNameString);

}

实现类：

package test.static.pattern;

public class UserManagerImpl implements UserManager {

	@Override

	public void addUser(String userId, String userName) {

		System.out.println("UserManagerImpl.addUser()  userId-->>" + userId);

	}

	@Override

	public void delUser(String userId) {

		System.out.println("UserManagerImpl.delUser() userId-->>" + userId);

	}

	@Override

	public String findUser(String userId) {

		System.out.println("UserManagerImpl.findUser() userId-->>" + userId);

		return null;

	}

	@Override

	public void modifyUser(String userId, String userNameString) {

		System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);

	}

}

静态代理类：（仅仅持有对象的引用）

package test.static.pattern;

public class UserManagerImplProxy implements UserManager {

	private UserManager userManager;

	public UserManagerImplProxy	(UserManager userManager){

		this.userManager=userManager;

	}

	@Override

	public void addUser(String userId, String userName) {

		userManager.addUser(userId, userName);

	}

	@Override

	public void delUser(String userId) {

		userManager.delUser(userId);

	}

	@Override

	public String findUser(String userId) {

		return userManager.findUser(userId);

	}

	@Override

	public void modifyUser(String userId, String userNameString) {

		userManager.modifyUser(userId, userNameString);

	}

}

client：

package test.static.pattern;

public class Client {

	/**

	 * @param args

	 */

	public static void main(String[] args) {

		//正常思路：client直接实例化出 子类的对象

		UserManager userManager=new UserManagerImpl();

		//静态代理：client实例化代理。通过代理取 子类的引用

		UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());

		userManager.addUser("0001", "张三");

	}

}

运行结果：

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast">

静态代理，由于代理类持有对象的引用，所以能够对其进行控制。

现象1：对于各个功能模块来说，都要建立相应的代理类。造成大量的代理类

现象2：可是假设对各个实现同样的控制，则须要反复写大量的代码。

为了避免反复代码出现多次，我们接着看什么是动态代理。

动态代理的实现：

接口：

package test.dynamic.pattern;

public interface UserManager {

	public void addUser(String userId,String userName);

	public void delUser(String userId);

	public String findUser(String userId);

	public void modifyUser(String userId,String userNameString);

}

实现类：

package test.dynamic.pattern;

public class UserManagerImpl implements UserManager {

	@Override

	public void addUser(String userId, String userName) {

		System.out.println("UserManagerImpl.addUser()  userId-->>" + userId);

	}

	@Override

	public void delUser(String userId) {

		System.out.println("UserManagerImpl.delUser() userId-->>" + userId);

	}

	@Override

	public String findUser(String userId) {

		System.out.println("UserManagerImpl.findUser() userId-->>" + userId);

		return null;

	}

	@Override

	public void modifyUser(String userId, String userNameString) {

		System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);

	}

}

动态代理生成类：

package test.dynamic.pattern;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import org.omg.CORBA.SystemException;

import org.omg.CORBA.portable.InputStream;

import org.omg.CORBA.portable.InvokeHandler;

import org.omg.CORBA.portable.OutputStream;

import org.omg.CORBA.portable.ResponseHandler;

public class LogHandler implements InvocationHandler {

	/**

	 * 调用引用对象类的方法抽象

	 */

	@Override

	public Object invoke(Object proxy, Method method, Object[] args)

			throws Throwable {

		Object ret=null;

		try {

			//调用目标方法

			ret=method.invoke(targetObject, args);

		} catch (Exception e) {

			throw e;

		}

		return ret;

	}

	//目标实现的引用

	private Object targetObject;

	/**

	 * 代理类生成方法

	 * @param targetObject

	 * @return

	 */

	public Object newProxyInstance(Object targetObject){

		this.targetObject=targetObject;

		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);

	}

}

client：

package test.dynamic.pattern;

public class Client {

	/**

	 * @param args

	 */

	public static void main(String[] args) {

		//动态代理

		LogHandler logHandler=new LogHandler();

		UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());

		//userManager.addUser("0001", "张三");

		userManager.delUser("111");

	}

}

运行结果：

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast">

动态代理类，在程序中没有体现。

仅仅有在程序执行的时候採用创建对应的代理类。这样就能够少些大量的代理类。

对于现象2。同样控制代码是怎样降低的。请看下一篇博客。