黑马程序员_代理

------- android培训、java培训、期待与您交流！ --------------

一、代理的概念与作用

生活中的代理

武汉人从武汉的代理商手中买联想电脑和直接跑到北京来找联想总部买电脑，最终的主体业务目标基本一样，都解决了核心问题，但是，从代理商那里比直接跑到北京总部买的总成本要低。

程序中的代理

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

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

代理架构图

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

二、AOP

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：

                                  安全         事务          日志

StudentService -------|------------|------------|------------

CourseService -------|------------|------------|------------

MiscService      -------|------------|------------|-------------

用具体的程序代码描述交叉业务：

method1        method2        method3

{                       {                       {

-------------------------------------------------- 切面

    ……                ……                ……

-------------------------------------------------- 切面

}                        }                       }

交叉业务的的编程问题即为面向方面的编程（Aspect oriented program ，简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

-------------------------------------------------- 切面

fun1                 fun2                fun3

{                       {                       {

   ……                ……                ……

}                        }                       }

-------------------------------------------------- 切面

使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

三、动态代理技术

要为系统中的各种接口的类增加代理代理功能，将是需要太多的代理类，全部采用静态代理方式，写成千上万个代理类，将是一件非常麻烦的事情。

JVM 可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

JVM 生成的动态类必须实现一个或多个接口，所以，JVM 生成的动态类只能用作具有相同接口的目标类的代理。

CGLIB 库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能的代码：

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

4.在处理目标方法异常的catch块中

四、分析JVM动态生成的类
分析过程：

1.创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass()方法的各个参数

2.编码列出动态类中得所有构造方法和参数签名

3.编码列出动态类中得所有方法和参数签名

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;

public class ProxyTest {
	public static void main(String[] args) {
		Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		System.out.println(clazzProxy.getName());
		System.out.println("----------Constructors List----------");
		Constructor[] constructors = clazzProxy.getConstructors();
		for(Constructor constructor : constructors) {
			String name = constructor.getName();
			StringBuilder sb = new StringBuilder(name);
			sb.append('(');
			Class[] types = constructor.getParameterTypes();
			for(Class type : types) {
				sb.append(type.getName() + ", ");
			}
			if(types.length != 0)
				sb.deleteCharAt(sb.lastIndexOf(","));
			sb.append(')');
			System.out.println(sb);
		}
		System.out.println("----------Methods List----------");
		Method[] methods = clazzProxy.getMethods();
		for(Method method : methods) {
			String name = method.getName();
			StringBuilder sb = new StringBuilder(name);
			sb.append('(');
			Class[] types = method.getParameterTypes();
			for(Class type : types) {
				sb.append(type.getName() + ", ");
			}
			if(types.length != 0)
				sb.deleteCharAt(sb.lastIndexOf(","));
			sb.append(')');
			System.out.println(sb);
		}
	}
}

创建动态类的实例对象：

1.用反射获得构造方法

2.编写一个最简单的InvocationHandler类

3.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传出去

4.打印创建的对象返回null，有两种可能：

对象为null 和 对象的toString方法返回值为null，经验证是第2种。和getClass方法，演示调用其他有返回值的方法报告了异常

5.将创建动态类的实例对象的代理修改成匿名内部类的形式编写，习惯使用匿名内部类

6.用Proxy.newInstance方法直接一步就创建出代理对象。

		//方法一：不使用匿名内部类
		Constructor constructor1 = clazzProxy.getConstructor(InvocationHandler.class);
		class MyInvocationHandler1 implements InvocationHandler {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {		
				return null;
			}		
		}
		Collection collectionProxy1 = (Collection)constructor1.newInstance(new MyInvocationHandler1());
		System.out.println(collectionProxy1);
		
		//方法二：使用匿名内部类
		Constructor constructor2 = clazzProxy.getConstructor(InvocationHandler.class);
		Collection collectionProxy2 = (Collection)constructor2.newInstance(new InvocationHandler(){
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				return null;
			}	
		});
		System.out.println(collectionProxy2);
		
		//方法三：用Proxy.newInstance方法直接一步就创建出代理对象
		Collection collectionProxy3 = (Collection)Proxy.newProxyInstance(
				Collection.class.getClassLoader(), 
				new Class[]{Collection.class}, 
				new InvocationHandler(){
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						return null;
					}	
				}
		);
		System.out.println(collectionProxy3);

总结思考：让JVM创建动态类，需要给它提供哪些信息？

三个方面：

1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知。

2.产生的类字节码必须有一个关联的类加载器对象。

3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHander对象的invoke方法中加一点代码，就可以看到这些代码，就可以看到这些代码被调用运行了。