package cn.itcast.day3;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{//getProxyClass()接收两个参数：加载器，实现的接口。Class clazzProxy1=Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);System.out.println(clazzProxy1.getName());//该类有什么构造方法System.out.println("----------begin constructor list");/*希望打印出的构造方法如下格式：* $Proxy()* $Proxy(InvocationHandldr,int)*/Constructor[] constructors=clazzProxy1.getConstructors();for(Constructor  constructor:constructors){String name=constructor.getName();StringBuilder sBuilder=new StringBuilder(name);sBuilder.append('(');Class[] clazzParams=constructor.getParameterTypes();//获得参数类型,返回的是Class类型的数组for(Class clazzParam:clazzParams){sBuilder.append(clazzParam.getName()).append(',');}//如果得到的参数类型不为空，去掉最后一个逗号if(clazzParams!=null && clazzParams.length!=0)sBuilder.deleteCharAt(sBuilder.length()-1);sBuilder.append(')');System.out.println(sBuilder.toString());}System.out.println("----------begin methods list");/*希望打印出的构造方法如下格式：* $Proxy()* $Proxy(InvocationHandldr,int)* */Method[] methods=clazzProxy1.getMethods();for(Method  method:methods){String name=method.getName();StringBuilder sBuilder=new StringBuilder(name);sBuilder.append('(');Class[] clazzParams=method.getParameterTypes();//获得参数类型,返回的是Class类型的数组for(Class clazzParam:clazzParams){sBuilder.append(clazzParam.getName()).append(',');}//如果得到的参数类型不为空，去掉最后一个逗号if(clazzParams!=null && clazzParams.length!=0)sBuilder.deleteCharAt(sBuilder.length()-1);sBuilder.append(')');System.out.println(sBuilder.toString());}//由刚才的构造方法列表得：动态类只有一个有一个参数的构造方法：com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler)//创建动态类 的实例对象及调用其方法。System.out.println("----------begin create instance list");//clazzProxy1.newInstance();因为动态类没有无参数的构造方法，所有这样new对象错误。//所以先得到构造方法Constructor constructor=clazzProxy1.getConstructor(InvocationHandler.class);//由得到的构造方法创建动态类的实例对象时需要指定一个InvocationHandler类型的对象，//但通过API查  询，InvocationHandler为一个接口，不能创建对象，所以要通过子类实现该接口，然后创建对象。class MyInvocationHandler1 implements InvocationHandler{@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {// TODO Auto-generated method stubreturn null;}}//创建代理对象方式1Collection proxy1=(Collection)constructor.newInstance(new MyInvocationHandler1());System.out.println(proxy1);//此处打印为null，原因可能有2个：1。该对象真的为null，但是这样会返回空指针异常//2.proxy1.toString()返回是null，显然是这种情况。//创建代理对象方式2/*对于上述通过实现接口来new对象，我们可以通过构造匿名内部类的方式，更简单*/Collection proxy2=(Collection)constructor.newInstance(new InvocationHandler(){@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {// TODO Auto-generated method stubreturn null;}});//创建代理对象方式3,不需要先创建代理类再创建对象，采用直接调用Proxy.newProxyInstance方式创建对象。Collection proxy3=(Collection)Proxy.newProxyInstance(Collection.class.getClassLoader(), new Class[]{Collection.class},new InvocationHandler(){ArrayList target=new ArrayList();//此处的ArrayList起到了目标的作用，//暂时替代Collection对象。然后将运算后的结果返回给Collection对象，这样就相当于Collection对象自己调用一样。//代理对象，方法，传递的参数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;}});proxy3.add("zxx");//调用代理内部的invoke方法，并把proxy对象，add方法，"zxx"参数传递进去，代理内部执行完毕后再返回值。proxy3.add("lhm");System.out.println(proxy3.size());//注意：对于代理身上的方法，只有hashCode(),equals(),toString()三个方法交给InvocationHandldr去做。//而其他方法的实现，代理会自己实现。/*编写可生成代理和插入通告的通用方法。* 由上段代码我们可知：在代理类中新建对象的Invocation内部，代码是硬写上去的，不利于以后的修改。* 我们可以采用在其内部接收一个对象的方式来进行构造，而这个对象是由外部一个类传过来的，这个类中任意定义需要的代码，框架思想。* */final ArrayList target=new ArrayList();//注意：在内部类的方法中要访问局部变量，必须加finalCollection proxy4=(Collection)getProxy(target,new MyAdvice());//要想得到此方法，可以将上段产生代理对象的方法，Refactor-Extract method抽取方法得到。proxy4.add("ljx");//proxy4.add("xyk");//System.out.println(proxy4.size());}private static Object getProxy(final Object target,final Advice advice) {Object proxy4=Proxy.newProxyInstance(target.getClass().getClassLoader(), /*new Class[]{Collection.class},*/target.getClass().getInterfaces(),new InvocationHandler(){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 target;*/advice.beforeMethod(method);Object retVal=method.invoke(target, args);advice.afeterMethod(method);return target;}});return proxy4;}}

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

一、工厂类BeanFactory：

1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。

2、getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则返回该类示例对象的getProxy方法返回的对象。

3、BeanFactory的构造方法接收代表配置文件的输入流对象的配置文件格式如下：

#xxx=java.util.ArrayList

xxx=cn.itcast.test3.aopframework.ProxyFactoryBean

xxx.advice=cn.itcast.test3.MyAdvice

xxx.target=java.util. ArrayList

注意：其中的#代表注释当前行。

4、ProxyFactoryBean充当封装成动态的工厂，需为工厂提供的配置参数信息包括：

目标（target）

通告（advice）

5、BeanFactory和ProxyFactoryBean：

1）BeanFactory是一个纯粹的bean工程，就是创建bean即相应的对象的工厂。

2）ProxyfactoryBean是BeanFactory中的一个特殊的Bean，是创建代理的工厂。

二、实现类似spring的可配置的AOP框架的思路：

1、创建BeanFactory类：

1）构造方法：接受一个配置文件，通过Properties对象加载InputStream流对象获得。

2）创建getBean(String name)方法，接收Bean的名字，从上面加载后的对象获得。

3）通过其字节码对象创建实例对象bean。

4）判断bean是否是特殊的Bean即ProxyFactoryBean，如果是，就要创建代理类，并设置目标和通告，分别得到各自的实例对象，并返回代理类实例对象。如果不是在返回普通类的实例对象。

2、创建ProxyFactoryBean(接口)，此处用类做测试，其中有一个getProxy方法，用于获得代理类对象。

3、对配置文件进行配置，如上面配置一样。

4、作一个测试类：AopFrameworkTest进行测试。

主要程序：

//创建BeanFactory类
package cn.itcast.test3.aopframework;
import java.io.*;
import java.util.Properties;
import cn.itcast.test3.Advice;
public class BeanFactory {Properties prop = new Properties();//创建对象时需要传入一个配置文件中的数据，所以需要在构造方法中接受一个参数public BeanFactory(InputStream ips) {try {//将配置文件加载进来prop.load(ips);} catch (IOException e) {e.printStackTrace();}}//创建getBean方法，通过配置文件中的名字获取bean对象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();} //判断bean是特殊的bean即ProxyFactoryBean还是普通的beanif(bean instanceof ProxyFactoryBean){Object proxy = null;try {//是ProxyFactoryBean的话，强转，并获取目标和通告ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;//获取advice和targetAdvice advice = (Advice)Class.forName(prop.getProperty(name + ".advice")).newInstance();Object target = Class.forName(prop.getProperty(name + ".target")).newInstance();//设置目标和通告proxyFactoryBean.setAdvice(advice);proxyFactoryBean.setTarget(target);//通过类ProxyFactoryBean（开发中是作为接口存在）中获得proxy对象proxy = proxyFactoryBean.getProxy();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();} //是ProxyFactoryBean的话，返回proxy对象return proxy;}//否则返回普通bean对象return bean;}
}//创建ProxyFactoryBean类
package cn.itcast.test3.aopframework;
import java.lang.reflect.*;
import cn.itcast.test3.Advice;
public class ProxyFactoryBean {private Object target;private Advice advice;public Object getTarget() {return target;}public void setTarget(Object target) {this.target = target;}public Advice getAdvice() {return advice;}public void setAdvice(Advice advice) {this.advice = advice;}public Object getProxy() {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;}
}
//创建测试类AopFrameworkTest
package cn.itcast.test3.aopframework;
import java.io.InputStream;
public class AopFramewrorkTest {public static void main(String[] args)throws Exception {//读取配置文件的数据InputStream ips = AopFramewrorkTest.class.getResourceAsStream("config.property");//获取bean对象Object bean = new BeanFactory(ips).getBean("xxx");System.out.println(bean.getClass().getName());}