黑马程序员_代理

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

从生活中的例子引入代理：武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？

答：批发进货的成本和运输费的优势，比你自己直接到北京总部买的总成本要低吧。

l程序中的代理

要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？

编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下页的原理图）

如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

还有一个十分典型的例子：大家玩游戏，如果想要玩国外的服务器，或者是浏览国外的网站，由于国内的ip受限等原因，大家只能通过在网络上寻找代理服务器来实现与国外的玩家互动。

代理类的优点：如果采用工厂模式和配置文件的方式进行管理如果想要日志功能时，就配置代理类，否则配置目标类，增强了系统功能，方便切换。

代码示例：

package cn.itcast.test3;
import java.lang.reflect.*;
import java.util.*;
public class ProxyTest {
	public static void main(String[] args) throws Exception{
//创建动态代理类的三种方式
		//方式一：通过接口的子类创建对象
		Collection proxy1 = (Collection)
				constructor.newInstance(new MyInvocationHandler());
		System.out.println(proxy1);//null
		System.out.println(proxy1.toString());//null
		proxy1.clear();//无异常
		//proxy1.size();//异常		
		//方式二：匿名内部类
		Collection proxy2 = (Collection)
				constructor.newInstance(new InvocationHandler(){
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						// TODO Auto-generated method stub
						return null;
					}
				});
		
		//方式三：
		//通过代理类的newProxyInstance方法直接创建对象
		Collection proxy3 = (Collection)Proxy.newProxyInstance(
			//定义代理类的类加载器
			Collection.class.getClassLoader(),
			//代理类要实现的接口列表
			new Class[]{Collection.class},
			//指派方法调用的调用处理程序
			new InvocationHandler() {
				//创建集合，制定一个目标
				ArrayList target = new ArrayList();
				public Object invoke(Object proxy, Method method, Object[] args)
						throws Throwable {
					//测试程序运行时间
					long beginTime = System.currentTimeMillis();
					//调用目标方法，将其从return抽出来，加入代理所需的代码
					Object retVal = method.invoke(target, args);
					long endTime = System.currentTimeMillis();
					//测试
					System.out.println(method.getName() + 
							" run time of " + 
							(endTime - beginTime));
					return retVal;
				}
			}
			);
		//通过代理类调用目标方法，每调用一个目标的方法就会执行代理类的方法
		//当调用一次add方法时，就会找一次InvocationHandler这个参数的invoke方法
		proxy3.add("sdfd");
		proxy3.add("shrt");
		proxy3.add("rtbv");
		System.out.println(proxy3.size());
		System.out.println(proxy3.getClass().getName());
	}
}

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
                              安全       事务         日志
StudentService  ------|----------|------------|-------------
CourseService   ------|----------|------------|-------------
MiscService       ------|----------|------------|-------------
用具体的程序代码描述交叉业务：
method1         method2          method3
{                      {                       { 
------------------------------------------------------切面
....            ....              ......
------------------------------------------------------切面
}                       }                       }
交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：
------------------------------------------------------切面
func1         func2            func3
{             {                { 
....            ....              ......
}             }                }
------------------------------------------------------切面
使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术

要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1.在调用目标方法之前
2.在调用目标方法之后
3.在调用目标方法前后
4.在处理目标方法异常的catch块中

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
 编码列出动态类中的所有构造方法和参数签名
 编码列出动态类中的所有方法和参数签名
 创建动态类的实例对象
 用反射获得构造方法
 编写一个最简单的InvocationHandler类
 调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
 打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有
 返回值的方法报告了异常。
将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
产生的类字节码必须有个一个关联的类加载器对象；
生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。用Proxy.newInstance方法直接一步就创建出代理对象。
代码示例：

package cn.itcast.test3;
import java.lang.reflect.*;
import java.util.*;
public class ProxyTest {
	public static void main(String[] args) throws Exception{
//创建动态代理类的三种方式
		//方式一：通过接口的子类创建对象
		Collection proxy1 = (Collection)
				constructor.newInstance(new MyInvocationHandler());
		System.out.println(proxy1);//null
		System.out.println(proxy1.toString());//null
		proxy1.clear();//无异常
		//proxy1.size();//异常		
		//方式二：匿名内部类
		Collection proxy2 = (Collection)
				constructor.newInstance(new InvocationHandler(){
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						// TODO Auto-generated method stub
						return null;
					}
				});
		
		//方式三：
		//通过代理类的newProxyInstance方法直接创建对象
		Collection proxy3 = (Collection)Proxy.newProxyInstance(
			//定义代理类的类加载器
			Collection.class.getClassLoader(),
			//代理类要实现的接口列表
			new Class[]{Collection.class},
			//指派方法调用的调用处理程序
			new InvocationHandler() {
				//创建集合，制定一个目标
				ArrayList target = new ArrayList();
				public Object invoke(Object proxy, Method method, Object[] args)
						throws Throwable {
					//测试程序运行时间
					long beginTime = System.currentTimeMillis();
					//调用目标方法，将其从return抽出来，加入代理所需的代码
					Object retVal = method.invoke(target, args);
					long endTime = System.currentTimeMillis();
					//测试
					System.out.println(method.getName() + 
							" run time of " + 
							(endTime - beginTime));
					return retVal;
				}
			}
			);
		//通过代理类调用目标方法，每调用一个目标的方法就会执行代理类的方法
		//当调用一次add方法时，就会找一次InvocationHandler这个参数的invoke方法
		proxy3.add("sdfd");
		proxy3.add("shrt");
		proxy3.add("rtbv");
		System.out.println(proxy3.size());
		System.out.println(proxy3.getClass().getName());
	}
}

动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？
说明如下：

Client程序调用objProxy.add(“abc”)方法时，涉及三要素：objProxy对象、add方法、“abc”参数

ClassProxy$ {

  add(Object object) {

return handler.invoke(Object proxy, Method method, Object[] args);

  }

}

怎样将目标传进去：直接在InvocationHandler实现类中创建目标类的实例对象，可看运行效果和加入日志代码，但是毫无意义。为InvocationHandler实现类注入目标的实例对象，不能采用匿名内部类的形式了。让匿名内部类的InvocationHandler实现类访问外面的方法中的目标类实例对象的final类型的引用变量。

动态代理的工作原理：Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个方法)。

将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接受目标，同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

在这里将InvocationHandler加入到Proxy的构造方法中，因此，在创建出来的对象，就会存有构造方法中InvocationHandler的一些功能和信息，因为我们把想要运行的代码封装在InvocationHandler对象，把它传入到构造函数中，那么就实现了代理对象每次调用目标方法（因为实现了同一接口）时，都会调用我们加入到InvocationHandler对象中的代码。这就保证了每次调用代理时，可以在目标上加入我们自己加入的功能。

把系统功能代理模块化，即切面代码也改为通过参数形式提供，怎么把要执行的系统功能代码以参数的形式提供：

把要执行的代码装到一个对象的某个方法中，然后把此对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外接提供的代码。

为bind方法增加一个Advice参数。

代码示例：

package cn.itcast.test3;
import java.lang.reflect.*;
import java.util.*;
public class MyProxy {
	public static void main(String[] args)throws Exception {
		//创建目标对象，并进行操作测试
		final ArrayList target = new ArrayList();
		Collection proxy = (Collection)getProxy(target,new MyAdvice());
		proxy.add("sdf");
		proxy.add("wgcd");
		proxy.add("hgwe");
		System.out.println(proxy.size());
		
	}
	//作为一个通用的方法，就使用Object
	//传入一个目标，并传入一个接口，此接口作为通信的契约，才能调用额外的方法
	private static Object getProxy(final Object target,final Advice advice) {
		Object proxy = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				//这里的接口要和target实现相同的接口
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						//通过契约，使用其方法--before和after方法
						advice.beforeMethod(method);
						Object value = method.invoke(target, args);
						advice.afterMethod(method);
						return value;
					}
				}
				);
		return proxy;
	}
}
//创建实现Advice接口的子类
package cn.itcast.test3;
import java.lang.reflect.Method;
//实现Advice接口中方法的具体内容
public class MyAdvice implements Advice {

	long beginTime = 0;
	public void beforeMethod(Method method) {
		// TODO Auto-generated method stub
		System.out.println("从这里开始");
		beginTime = System.currentTimeMillis(); 
	}
	public void afterMethod(Method method) {
		// TODO Auto-generated method stub
		long endTime = System.currentTimeMillis();
		System.out.println("从这里结束");
		System.out.println(method.getName() + " run time of " + (endTime-beginTime));
	}
}
//创建接口Advice
import java.lang.reflect.Method;
public interface Advice {
	void beforeMethod(Method method);
	void afterMethod(Method method);
}

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------