黑马程序员---Java基础加强---代理

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

代理

一、代理

代理类的生成是通过反射来进行的，同时代理对象的操作也是通过反射。
代理的概念
要为已经存在的目标类的各个方法，增加一些新的功能，如：异常处理、日志、计算方法的运行时间、事务管理、等等，这些方法本身不能动，那么可以通过代理来实现功能的增加，即写一个代理类，与此目标类实现相同的接口（为了具有 相同的方法），然后再方法里增加新功能，并调用目标类中的相同的方法，这样代理类中的这个方法就是增加了新功能的方法。
例如：
class X
{
  void sayHello()
  {
    System.out.println("hello world");
  }
}
为了给此类中的方法sayHello增加一些功能，则利用代理，以后就不要再调用目标类的此方法了，而是直接使用代理类中的此方法。如下
class XProxy
{
  void sayHello()
{
  //增加新的功能
  starttime
  X.sayHello();//调用目标类的相同的方法。
  endtime
  }
}
即为：
第一、要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？

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

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

二、AOP（面向方面）

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

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

2.代理类的生成原理

第一：当类实现了接口

JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

第二：类没有实现任何接口

CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下

四个位置加上系统功能代码：

  1.在调用目标方法之前
  2.在调用目标方法之后
  3.在调用目标方法前后
  4.在处理目标方法异常的catch块中

2.创建动态类及查看其方法列表信息

程序：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class ProxyTest 
{
	public static void main(String[] args) 
	{
	// TODO Auto-generated method stub
	System.out.println("----------第一步：生产动态类----------------");
	//调用生成动态类Proxy.getProxyClass(类加载器，实现的接口)，
	//通常类加载器是与实现的接口的类加载器是一样的。
	Class clazzProxy=Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
	System.out.println(clazzProxy.getName());
	System.out.println("----------第二步：查看此类中的构造方法----------------");
	//得到构造方法
	Constructor[] constructors=clazzProxy.getConstructors();
	//循环得到所有的构造方法
	//打印的构造函数形式为：构造函数名（参数类型，参数类型）
	//即$Proxy0()和$Proxy0(int,String)这种
	for (Constructor constructor : constructors) 
	{
		String sc=constructor.getName();//com.sun.proxy.$Proxy0
		String sc1=sc.substring(sc.lastIndexOf('.')+1);//$Proxy0
		StringBuilder sb=new StringBuilder();
		//将获得的构造函数名加入到容器中。
		sb.append(sc1);
		sb.append('(');
		//获取此构造函数中的参数类型
		Class[] clazzParams=constructor.getParameterTypes();
		if (clazzParams!=null&&clazzParams.length!=0)
		{
			for (Class clazzParam : clazzParams)
			{
				String cp=clazzParam.getName();
				String cp1=cp.substring(cp.lastIndexOf('.')+1);
				sb.append(cp1+",");	
			}
			sb.deleteCharAt(sb.length()-1);//去掉最后的那个,
			sb.append(')');
		}
		System.out.println(sb);	
	}
	System.out.println("----------第三步：查看此类中的所有方法----------------");
	Method[] methods=clazzProxy.getMethods();
	//循环得到所有的方法
	//打印的函数形式为：函数名（参数类型，参数类型）
	for (Method method : methods) 
	{
		String sc=method.getName();//com.sun.proxy.$Proxy0
		String sc1=sc.substring(sc.lastIndexOf('.')+1);//$Proxy0
		StringBuilder sb=new StringBuilder();
		//将获得的构造函数名加入到容器中。
		sb.append(sc1);
		sb.append('(');
		//获取此构造函数中的参数类型
		Class[] clazzParams=method.getParameterTypes();
		if (clazzParams!=null&&clazzParams.length!=0) 
		{
			for (Class clazzParam : clazzParams) 
			{
			String cp=clazzParam.getName();
			//将前面的前缀去掉，只打印最后的类型
			String cp1=cp.substring(cp.lastIndexOf('.')+1);
			sb.append(cp+",");	
			}
			sb.deleteCharAt(sb.length()-1);//去掉最后的那个,
			sb.append(')');
		}
		else
			sb.append(')');
		System.out.println(sb);	
	}
	System.out.println("----------第四步：创建动态类对象---------------");
	//第一种方法来创建动态代理类对象
		//得到对应的构造函数
		Constructor constructor=clazzProxy.getConstructor(InvocationHandler.class);
		//由于InvocationHandler是一个接口，所以需要有一个类实现它才能创建它的对象
		class MyInvocationHandler implements InvocationHandler{
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				// TODO Auto-generated method stub
				return null;
			}	
		}
		//创建对象
		Collection proxy=(Collection)constructor.newInstance(new MyInvocationHandler());
		System.out.println(proxy);
	//第二种方法来创建动态代理类对象
		//或者用匿名内部类的形式
		Constructor constructor=clazzProxy.getConstructor(InvocationHandler.class);
		Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){

			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				return null;
			}
			
		});
	//第三种方法来创建动态代理类对象
		//通过方法newProxyInstance(接口类的类加载器在,实现的接口的字节码,传入InvocationHandler对象)
		//来直接一步创建出动态代理类
		Object proxy3 = Proxy.newProxyInstance(
				Collection.class.getClassLoader(),
				new Class[]{Collection.class},
				new InvocationHandler(){
				//复写InvocationHandler中的invoke方法，
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						long beginTime = System.currentTimeMillis();
						Object retVal = method.invoke(target, args);
						long endTime = System.currentTimeMillis();
						System.out.println(method.getName() + " running time of " + (endTime - beginTime));
						return retVal;				
					}
				}
				);
	}	
}

3.分析动态代理类对象操作方法的原理以及InvocationHandler对象的运行原理

动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个接受InvocationHandler参数的构造方法

（1）此构造方法为$Proxy0(InvocationHandler handler)
{
     this.handler=handler;
}
（2）对于调用方法size()时其size()方法的内部为
int size()
{
    return handler.invoke(this,this.getClass().getMethod("size"),null);
}
void clear()
{
     handler.invoke(this,this.getClass().getMethod("clear"),null);
}
（3）所以每次代理调用方法时都会调用一次InvocationHandler中的invoke方法，在此invoke的代码里来添加想要添加的内容，并调用目标的相同的方法。从而实现添加功能即代理的功能。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
public class ProxyTest 
{
	public static void main(String[] args) throws Exception
	{
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
		//传入一个目标类对象
		final ArrayList target = new ArrayList();	
		//通过方法newProxyInstance(接口类的类加载器在,实现的接口的字节码,传入InvocationHandler对象)
		//来直接一步创建出动态代理类
		Collection proxy3 = (Collection)Proxy.newProxyInstance(
				Collection.class.getClassLoader(),
				new Class[]{Collection.class},
				new InvocationHandler(){
				//复写InvocationHandler中的invoke方法，此方法中传入的参数为：代理类对象proxy，
				//调用代理类的method方法，以及此方法中需要传入的参数args
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable 
					{
						//加入其他的功能
						long beginTime = System.currentTimeMillis();
						//调用目标的method方法，此方法作用于目标target对象上，参数为args
						Object retVal = method.invoke(target, args);
						long endTime = System.currentTimeMillis();
						System.out.println(method.getName() + " running time of " + (endTime - beginTime));
						return retVal;				
					}
				}
				);
				proxy3.add("zxx");//每写一次add方法就会调用一次invoke方法，此时invoke方法中的参数
				proxy3.add("lhm");//分别对应proxy3,add方法和"zxx"
				proxy3.add("bxd");
				System.out.println(proxy3.size());//结果为3.
	}
}

4.总结分析动态代理类的设计原理与结构
即：客户端调用代理->代理的构造方法传递一个handler对象->客户端调用代理的方法->代理将客户端的调用请求发

给handler对象->handler对象通过调用invoke又把请求发给目标类中的对应的方法。

也就是：客户端调用代理类的方法，代理类再调用目标类的对应的方法。