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

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

代理类的作用与原理

1、生活中的代理：就是常说的代理商，从厂商将商品卖给消费者，消费者不用很麻烦的到厂商在购买了。

2、程序中的代理：要为已经存在的多个具有相同接口的目标类的各个方法增加一些系统功能，如异常处理、日志、计算方法的运行时间、事物管理等等。

3、简单示例：编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码，如：

目标类：                             代理类：

class X{                               Xproxy{

   void sayHello(){                        void sayHello(){

syso:Hello;                            startTime

}                                           X. sayHello();

}                                       endTime;}}

一般用接口来引用其子类，如：Collection coll = new ArrayList();

4、代理类的有点：

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

5、获取代理类的构造方法和方法代码

import java.lang.reflect.*;
import java.util.*;
public class ProxyTest {
	public static void main(String[] args) throws Exception{
		//获取代理类Proxy的Class对象，传入的是类加载器和相应的字节码对象
		Class clazzProxy1 = Proxy.getProxyClass(
				Collection.class.getClassLoader(), Collection.class);
		System.out.println(clazzProxy1.getName());//$Proxy0
		System.out.println("---begin constructor list------");
		//获取代理类的构造方法，可能含有多个，得到数组
		Constructor[] constructors = clazzProxy1.getConstructors();
		//遍历数组，获取每个构造方法
		for(Constructor constructor : constructors){
			//先得到构造方法的名字，并装入字符串容器中
			String name = constructor.getName();
			StringBuilder sBul = new StringBuilder(name);
			sBul.append('(');
			//获取构造方法中的参数类型，并遍历
			Class[] clazzParams = constructor.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBul.append(clazzParam.getName()).append(',');
			}
			//将最后一个逗号去除
			if(clazzParams != null && clazzParams.length!=0)
				sBul.deleteCharAt(sBul.length()-1);
			sBul.append(')');
			System.out.println(sBul.toString());
		}
		
		System.out.println("---begin method list------");
		//获取代理类的方法，存入数组
		Method[] methods = clazzProxy1.getMethods();
		//遍历数组，获取每个方法
		for(Method method : methods){
			//先得到方法的名字，并装入字符串容器中
			String name = method.getName();
			StringBuilder sBul = new StringBuilder(name);
			sBul.append('(');
			//获取方法中的参数类型，并遍历
			Class[] clazzParams = method.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBul.append(clazzParam.getName()).append(',');
			}
			//将最后一个逗号去除
			if(clazzParams!=null && clazzParams.length!=0)
				sBul.deleteCharAt(sBul.length()-1);
			sBul.append(')');
			System.out.println(sBul.toString());
		}
}

AOP

简述：AOP（Aspect Oriented Program）即面向方面的编程。

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
                              安全       事务         日志
StudentService  ------|----------|------------|-------------
CourseService  ------|----------|------------|-------------
MiscService       ------|----------|------------|-------------

用具体的程序代码描述交叉业务：
method1         method2          method3
{                      {                       { 
------------------------------------------------------切面
....            ....              ......
------------------------------------------------------切面
}                       }                       }

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

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

 

动态代理技术

一、概述：

1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，这时就不能采用静态代理方式，需用动态代理技术。

2、动态代理类：JVM可在运行时，动态生成类的字节码，这种动态（不是代理，只是拿出来作为代理类）生成的类往往被用作代理类，即动态代理类。

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

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

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

1）在调用目标方法之前

2）在调用目标方法之后

3）在调用目标方法前后

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

二、分析JVM动态生成的类

1、创建动态类的实例对象：

1）用反射获得构造方法

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

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

示例：

第一、打印创建的对象和调用对象的无返回值的方法和getClass方法，演示调用其他没有返回值的方法报告的异常

第二、将创建的动态类的实例对象的代理改写成为匿名内部类的形式编写。

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());
	}
}

让jvm创建动态类及其实例对象，需要给它提供哪些信息：

• 生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
• 产生的类字节码必须有个一个关联的类加载器对象；
• 生成的代理类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个 InvocationHandler 对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的 InvocationHandler 对象的 invoke 方法中加一点代码，就可以看到这些代码被调用运行了。

 

三、问题：

1、在上面的方式一的代码中，调用无返回值的方法返回的是null，而调用有返回值方法的时候会报NullPointException异常的原因：

在proxy1.size()方法中，size()会调用Object invoke()方法，而对其覆写时的返回值是null，而size()本身会返回int类型，两者返回的类型不相等，所以就会报错。

而对于proxy3.size()不报错，是因为size()返回值与代理对象中handler参数返回值是一致的，当前目标返回什么，代理就返回什么，所以不会报错。

注意：目标返回值和代理返回值必须是同一类型。

2、为何动态类的实例对象的getClass()方法返回了正确结果，而没调用invoke方法：

因为代理类从Object上继承了许多方法，其中只对三个方法（hansCode、equals和toString）进行开发，委托给handler去自行处理，对于它身上其他方法不会交给代理类去实现，所以对于getClass()方法，还是会有Object本身实现的。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。

四、总结分析动态代理类的统计原理和结构：
动态代理的工作原理图

1、怎样将目标传进去：

1）直接在InvocationHandler实现类中创建目标类的实例对象，可看运行效果和加入日志代码，但是毫无意义。

2）为InvocationHandler实现类注入目标的实例对象，不能采用匿名内部类的形式了。

3）让匿名内的InvocationHandler实现类访问外面的方法中的目标类实例对象的final类型的引用变量。

2、动态代理的工作原理：

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

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

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

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

2）为方法增加一个Advice参数。

代码示例：

//创建接口Advice
import java.lang.reflect.Method;
/*接口中需要实现四个方法
 * 调用目标方法之前
 * 调用目标方法之后
 * 调用目标方法前后
 * 在处理目标方法异常的catch块中
 */
//这里只列出两个作为示例
public interface Advice {
	void beforeMethod(Method method);
	void afterMethod(Method method);
}

//创建实现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));
	}
}

//封装getProxy方法
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;
	}
}

实现类似 spring 的可配置的 AOP 框架

需求：要求在不修改 Client 代码的情况下，可以修改我们创建的对象的类型，并且配置是否创建目标功能的代理类对象，那么我们可以选用   配置文件 + 工厂模式  的方法。我们的需求在配置文件中配置好以后，使用工厂类对象读取配置文件获得我们要创建的对象的类的名字的字符串，使用该字符串来在工厂中使用反射来创建我们我们需要的实例。

现在我们的配置选项可以设置为我们要创建的对象要么是一般目标类对象，要么是目标代理类对象，创建目标代理类对象的话，还需要指定 目标类 和 Advice 接口的实现类。

配置文件格式可以为：

#xxxClassName=java.util.ArrayList
xxxClassName=cn.itcast.proxy.aopframework.ProxyFactoryBean
xxxClassName.target=java.util.ArrayList
xxxClassName.advice=java.util.ArrayList

其中 xxxClassName 可以是 Collection 这种我们 Client  程序中需要的对象的类型的名字

config.properties 文件：

Collection=java.util.ArrayList
#Collection=cn.itcast.proxy.aopframework.ProxyFactoryBean
Collection.target=java.util.ArrayList
Collection.advice=cn.itcast.proxy.MyAdvice

定义一个bean工厂接口

定义一个bean工厂接口，专门负责生产指定的 javabean 的对象

package cn.itcast.proxy.aopframework;

public interface BeanFactory {
	Object getBean(String className) throws Exception;
}

定义一个 ConfigurableBeanFactory 类

定义一个 ConfigurableBeanFactory 类实现 bean 工厂，它是根据配置文件产生 bean 类

package cn.itcast.proxy.aopframework;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ConfigurableBeanFactory implements BeanFactory {

	private Properties properties;

	public ConfigurableBeanFactory(InputStream propertiesInputStream) {
		// TODO Auto-generated constructor stub
		properties = new Properties();
		try {
			properties.load(propertiesInputStream);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public Object getBean(String className) throws Exception {
		// 根据传入的类名去配置文件中拿到实际配置的类名
		String configClassName = properties.getProperty(className);
		Object beanObject = Class.forName(configClassName).newInstance();
		// 如果配置的对象是 代理工厂类对象，那么要返回就得是下面配置的目标和Advice组合形成的代理的对象
		if (beanObject instanceof ProxyFactoryBean) {
			ProxyFactoryBean proxyFactoryBeanObject = (ProxyFactoryBean) beanObject;
			String target = properties.getProperty(className + ".target");
			String advice = properties.getProperty(className + ".advice");
			proxyFactoryBeanObject.setTarget(target);
			proxyFactoryBeanObject.setAdvice(advice);

			beanObject = proxyFactoryBeanObject.getBean(target);
		}

		return beanObject;
	}

	public static void main(String[] args) throws Exception {
		InputStream propertiesInputStream = ConfigurableBeanFactory.class
				.getResourceAsStream("config.properties");
		BeanFactory beanFactory = new ConfigurableBeanFactory(
				propertiesInputStream);
		
		System.out.println(beanFactory.getBean("Collection").getClass().getName());
	}
}

定义一个 ProxyFactoryBean 类

定义一个 ProxyFactoryBean 类它是一个产生 代理类对象的工厂，它本身就是 javabean ，而且实现了 BeanFactory 接口。

package cn.itcast.proxy.aopframework;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import cn.itcast.proxy.Advice;
public class ProxyFactoryBean implements BeanFactory{
	private String target;
	private String advice;

	public ProxyFactoryBean() {
		super();
	}

	public String getTarget() {
		return target;
	}

	public void setTarget(String target) {
		this.target = target;
	}

	public String getAdvice() {
		return advice;
	}

	public void setAdvice(String advice) {
		this.advice = advice;
	}

	@Override
	public Object getBean(String className) throws Exception {
		// TODO Auto-generated method stub
		Object target = Class.forName(this.target).newInstance();
		Advice advice = (Advice)Class.forName(this.advice).newInstance();
		return createDynamicProxyInstance(target, advice);
	}
	
	private static Object createDynamicProxyInstance(final Object target, final Advice advice) {
		Object proxyObject = Proxy.newProxyInstance(target.getClass()
				.getClassLoader(), target.getClass().getInterfaces(),
				new InvocationHandler() {

					@Override
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						// TODO Auto-generated method stub
						
						// 1.在 target 功能之前添加代理的额外功能
						advice.beforeMethod(method);
						// 2.调用 target 功能
						Object returnValue = method.invoke(target, args);
						// 3.在 target 功能之后添加代理的额外功能
						advice.afterMethod(method);
						
						return returnValue;
					}
				});
		return proxyObject;
	}
}