黑马程序员--Java基础加强（7）-----代理和AOP（面向方面编程）

代理和AOP（面向方面编程）

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

1、什么是代理和AOP（面向方面编程）。

（1）代理，用来为多个具有相同接口的目标类的各个方法增加一些系统功能。代理具有与目标类相同的接口，且代理的每个方法调用目标类的相同方法，同时加上一些系统功能的代码。

      代理方法中可以在如下四个位置加上系统功能代码：在调用目标方法之前；在调用目标方法之后；在调用目标方法前后；在处理目标方法异常的catch块中。

 （2）AOP：Aspect oriented program 面向方面的编程。安全，事务，日志等功能要贯穿到好多个对象模块中，所以，他们就是交叉业务。交叉业务的编程问题，即为面向方面的编程。AOP的目标就是要使交叉业务模块化。

      代理是实现AOP功能的核心和关键技术。

2、动态代理方式及创建动态代理类。

     静态代理方式太麻烦，我们可以采用动态代理方式生成代理类。

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

     通常使用Proxy类中的getProxyClass（ClassLoader loader,Class<?>…interface）方法创建动态代理类。第一个参数表示默认的类加载器，第二个参数表示该代理类实现了哪个接口，接口可以有多个。一般实现哪个接口，第一个参数就使用哪个接口的类加载器。

3、创建动态代理类的实例对象及使用原理。

      通过反射可以获取动态代理类的构造函数及其参数，可知，动态代理类只有一个带有参数的构造函数，参数类型为InvocationHandler类型。所以不能使用动态代理类的class文件直接调用newInstatnce()创建实例对象，需要先将那个带参数的构造函数获取得，再用该构造函数newInstance()创建实例对象。

    这样比较麻烦，Proxy类还提供了一个方法，可以一步到位：newProxyInstance(ClassLoader loader,Class<?>[] interface,InvocationHandler h)。

示例代码：

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;

import org.omg.CORBA.Current;

public class MyProxy {
	public static void main(String[] args) throws Exception {
		final ArrayList<String> target = new ArrayList<String>();//局部内部类只能访问final修饰的局部变量
		Collection proxy1 = (Collection)Proxy.newProxyInstance(Collection.class.getClassLoader(), new Class[]{Collection.class}, new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				long startTime = System.currentTimeMillis();//系统代码，记录程序开始时间
				Object resVal = method.invoke(target, args);//这里调用目标类ArrayList对象target的add方法，
				long endTime = System.currentTimeMillis();//系统代码，记录程序开始时间
				System.out.println(endTime-startTime);//打印目标运行方法的时间
				return resVal;//将目标操作的运行结果返回
			}
		});
		proxy1.add("aaaa");
		proxy1.add("bbbb");
		proxy1.add("cccc");
		System.out.println(proxy1.size());
	}
}   

运行原理：生成的动态代理类，构造函数含有一个InvocationHandler对象，比如说是handler，这个对象很有用。

   每当动态代理类调用目标的方法时，首先会返回调用handler对象的方法invoke，然后将运算结果返回给动态代理类调用的该方法。Invoke的三个参数分别表示：操作目标（示例代码中为target），代理类调用的方法名称（这里为add方法），该方法的参数（这里三次分别为“aaaa”“bbbb”“cccc”）。你可以在invoke方法中、调用目标方法的前后，添加系统功能代码，也可以将代码抽离，形成单独的方法，便于灵活复用。

      调用目标中的方法一般都会先交给handler对象的invoke方法处理，但是注意：从Object继承过来的方法，只有hashCode，equals，toString三个方法会交给handler处理，其他的不交给handler处理。

4、创建类似Spring和可配置AOP框架

（1）思路：有工厂BeanFactory，可以通过其方法getBean("XXX");/获得配置文件中与“xxx”对应的javaBean对象。配置文件如：xxx = java.util.ArrayList; 但有一个条件是，如果xxx对应的不是ProxyFactoryBean则直接返回该类的实例对象，如果是ProxyFactoryBean则返回他的动态代理类的实例对象。

（2）步骤：BeanFactory：

  --- 构造函数，从流中获取配置文件信息，初始化。

    --- -getBean方法：如果是ProxyFactory类就创建动态代理类，如果不是ProxyFactory类就直接返回其实例对象。ProxyFactory：写出生成动态代理类的重构方法类似上一节。注意，过程中还要传递代理类生成时需要的参数：advice和target。

最后写测试类测试BeanTest类。

   *代码示例：

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class BeanFactory {
	private static Properties prop = new Properties();
	public BeanFactory(InputStream fis) {
		try {
			prop.load(fis);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	
	public  Object getBean(String name){
		String className = prop.getProperty(name);
		Object bean = null;
		try {
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		if(bean instanceof ProxyFactory){
			Object proxy = null;
			ProxyFactory pfBean = (ProxyFactory)bean;
			try {
				MyAdvice advice = (MyAdvice) Class.forName(prop.getProperty(name+".advice")).newInstance();
				Object target =  Class.forName(prop.getProperty(name+".target")).newInstance();
				pfBean.setAdvice(advice);
				pfBean.setTarget(target);
				proxy = pfBean.getProxy();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
			
		}
		return bean;
	}
}

ProxyFactory代码：

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

public class ProxyFactory {
	private Object target;
	private MyAdvice advice;
	
	public Object getTarget() {
		return target;
	}

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

	public Object getAdvice() {
		return advice;
	}

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

	public Object getProxy(){
		Object proxy = Proxy.newProxyInstance(Collection.class.getClassLoader(), new Class[]{Collection.class}, new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				advice.getStartTime();
				Object resVal = method.invoke(target, args);//这里调用目标类ArrayList对象target的add方法，
				advice.getEndTime();
				return resVal;//将目标操作的运行结果返回
			}
		});
		return proxy;
	}
}

MyAdvice代码：

public class MyAdvice {
	public long getStartTime(){
		return System.currentTimeMillis();
	}
	
	public long getEndTime(){
		return System.currentTimeMillis();
	}
}

BeanTest代码：

import java.io.InputStream;

public class BeanTest {

	public static void main(String[] args){
		InputStream ips = BeanTest.class.getResourceAsStream("config.properties");//这里配置文件是相对路径
		Object bean = new BeanFactory(ips).getBean("xxx1");
		System.out.println(bean.getClass().getName());
		Object bean1 = new BeanFactory(ips).getBean("xxx2");
		System.out.println(bean1.getClass().getName());
	}
}

配置文件config.properties代码;

xxx1=java.util.ArrayList
xxx2=cn.heima.proxy.ProxyFactory
xxx2.advice=cn.heima.proxy.MyAdvice
xxx2.target=java.util.ArrayList