java代理课程测试 spring AOP代理简单测试

jjava加强课程测试代码 反射、 代理 、泛型、beanUtils等 项目源码下载：http://download.csdn.net/detail/liangrui1988/6568169

热身运动代码。。。。。。。。。

package com.proxyTest;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest {

	public static void main(String[] args) throws Exception{

		//获取代理字节码
		Class clazzProxy=Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);

		System.out.println(clazzProxy.getName());
		System.out.println("-----------Proxy构造方法列表------------");
		Constructor[] constructor=clazzProxy.getConstructors();

		for(Constructor con:constructor){
			//get名称
			String conName=con.getName();

			//接接参数
			StringBuilder sb=new StringBuilder(conName);//单线程 快
			sb.append('(');
			//get 获得参数类型的字节码
			Class[] paraClass=con.getParameterTypes();
			for(Class c:paraClass){
				//获取参数
java加强课程测试代码 反射、 代理 、泛型、beanUtils等				sb.append(c.getName()).append(',');
			}

			if(paraClass!=null&¶Class.length!=0)
			sb.deleteCharAt(sb.length()-1);

			sb.append(')');

			System.out.println(sb.toString());
		}

System.out.println("\n================Proxy方法列表=============================");

		Method[] methods=clazzProxy.getMethods();

		for(Method me:methods){
			//get名称
		String conName=me.getName();

		//接接参数
		StringBuilder sb=new StringBuilder(conName);//单线程 快
		sb.append('(');
		//get 获得参数类型的字节码
		Class[] paraClass=me.getParameterTypes();
		for(Class c:paraClass){
			//获取参数
			sb.append(c.getName()).append(',');
		}

		if(paraClass!=null&¶Class.length!=0)
		sb.deleteCharAt(sb.length()-1);

		sb.append(')');

			System.out.println(sb.toString());
		}

System.out.println("\n================Proxy创建实例=============================");
       //获取指定的构造方法
      Constructor conIns=clazzProxy.getConstructor(InvocationHandler.class);

      //创建一个connection类做参数
      class myConn1 implements InvocationHandler{

		@Override
		public Object invoke(Object proxy, Method method, Object[] args)
				throws Throwable {
			// TODO Auto-generated method stub
			return null;
		}

      }

      //创建实例
     Collection proxy1 =(Collection) conIns.newInstance(new myConn1());
      System.out.println(proxy1);

     // proxy1.size();

       //创建实例 方式2===================================
     @SuppressWarnings("unchecked")
	Collection<String> proxy2 =(Collection<String>) conIns.newInstance(new InvocationHandler(){
    	  //内部类
		@Override
		public Object invoke(Object proxy, Method method, Object[] args)
				throws Throwable {
			return null;
		}
      } );

      //创建实例  方式3===================================
     Collection proxy3=(Collection) Proxy.newProxyInstance(
    		 //类加载器
    		 Collection.class.getClassLoader(),
    		 // 参数数内型
    		 new Class[]{Collection.class},
    		 //参数值
    		 new InvocationHandler(){
    			 /**
    			  * proxy 代理的对象
    			  * method 代理对象的那个方法
    			  * args 方法中传入的参数
    			  */
    			 ArrayList target=new ArrayList();
				@Override
				public Object invoke(Object proxy, Method method, Object[] args)
						throws Throwable {
			       Long startTime=	System.currentTimeMillis();
					//方法调用 参数 目标对象和参数
					Object obj=method.invoke(target, args);
				    Long endTime=	System.currentTimeMillis();
				  System.out.println(method.getName()+"runTime of 用时:"+(endTime=startTime));  

				  //死循环
				//  return  method.invoke(proxy,args);

				  //返回对象
				  return obj;
				}}
    		  );

     proxy3.add("aaaa");
     proxy3.add("bbbb");
     proxy3.add("ccccc");
   // System.out.println(proxy3.size());

	}

}

进一步加强代码

package com.proxyTest;

import java.lang.reflect.Method;
/**
 * 通知接口
 * @author liangrui
 *
 */
public interface Advice {

	public void beforeMethod(Method m);//开始方法
	public void afterMethod(Method m);//结束方法
	//异常方法，前后方法 省略

}

package com.proxyTest;

import java.lang.reflect.Method;
/**
 * 实现自已的处理功能对象
 * @author liangrui
 *
 */
public class Myadvice implements Advice {
	  Long startTime=null;
	@Override
	public void beforeMethod(Method m) {
		System.out.println("欢迎来到代理处理对象 开始方法");
		  startTime=	System.currentTimeMillis();

	}

	@Override
	public void afterMethod(Method m) {
		System.out.println("欢迎来到代理处理对象  执行之后处理的方法");
		 Long endTime=	System.currentTimeMillis();
		System.out.println(m.getName()+"runTime of 用时:"+(endTime=startTime));
	}

}

package com.proxyTest;

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 ProxyTests {

	public static void main(String[] args) {

		ArrayList target=new ArrayList();//代理目标对象
		//获取代理 对象
		Collection coll=(Collection) getProxy(target,new Myadvice());

		/**
		 * 每次在执行自已方法的同时
		 * 都会执行自定义对象(MyAdivce)功能来进行处理
		 */

		coll.add("开始工作");
		System.out.println("\n---------------处理一个OK--------------------");
		coll.add("开始工作3");
		System.out.println("\n---------------处理一个OK--------------------");
		coll.add("开始工作2");
		System.out.println("\n---------------处理一个OK--------------------");
	System.out.println(coll.size());

	}

	/**
	 * 代理处理方法 返回处理后的对象
	 * @param target 目标对象
	 * @param advice 通告
	 * @return
	 */
	public static Object getProxy(final Object target,final Advice advice){
		Object proxyObj=Proxy.newProxyInstance(
				target.getClass().getClassLoader()//类加载器
				, target.getClass().getInterfaces()//参数类型
				,new InvocationHandler() {//调用方法进行处理
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {

						//代理功能处理 把方法交给它进行处理
						advice.beforeMethod(method);
						//处理自已的方法
						Object returnObj=method.invoke(target, args);
						advice.afterMethod(method);
						//返回处理后的对象
						return returnObj;
					}
				});

		return proxyObj;
	}

}

//spring AOP 简单的实现例子

package com.AopFramework;

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

import com.proxyTest.Advice;

public class FactoryBean {

	Properties pro=new Properties();

	public FactoryBean(InputStream is){
		try {
			pro.load(is);//加载数据流得到配制信息
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	//通过Key获取对象
	public Object getBean(String name){
		//通过Key获取类路径
		String classPath=pro.getProperty(name);
		Object bean=null;
		try {
			//获取类的字节码
			Class clazz=Class.forName(classPath);
			//得到对象实例
			bean=clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}

		//如果是代理对象则返回代理对象
		if(bean instanceof ProxyFactoryBean){
		//强转为代理对象
		ProxyFactoryBean proxyFactoryBean=(ProxyFactoryBean)bean;

		Object ProxyBean = null;
		try {
			//获取功能对象
			Advice advice=(Advice) Class.forName(pro.getProperty(name+".advice")).newInstance();
			//目标对象
			Object target=         Class.forName(pro.getProperty(name+".target")).newInstance();
			proxyFactoryBean.setAdvice(advice);//为代理对象加入 功能对象
			proxyFactoryBean.setTarget(target);//加入目标对象
			//get代理对象
			ProxyBean = proxyFactoryBean.getProxy();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//返回代理对象
		return ProxyBean;
		}

		//返回没有代理过的对象
		return bean;

	}
}

package com.AopFramework;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Properties;

import com.proxyTest.Advice;

public class ProxyFactoryBean {

	private Advice advice;//代理通告对象
	private Object target;//代理目标对象

	/**
	 * 代理处理方法 返回处理后的对象
	 * @param target 目标对象
	 * @param advice 通告
	 * @return
	 */
	public Object getProxy() {
		Object proxyObj=Proxy.newProxyInstance(
				target.getClass().getClassLoader()//类加载器
				, target.getClass().getInterfaces()//参数类型
				,new InvocationHandler() {//调用方法进行处理
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {

						//代理功能处理 把方法交给它进行处理
						advice.beforeMethod(method);
						//处理自已的方法
						Object returnObj=method.invoke(target, args);
						advice.afterMethod(method);
						//返回处理后的对象
						return returnObj;
					}
				});

		return proxyObj;
	}

	//=======================================
	public Advice getAdvice() {
		return advice;
	}
	public void setAdvice(Advice advice) {
		this.advice = advice;
	}

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

}

config.properties 配置文件

#target
#xxx=java.util.ArrayList
#proxy
xxx=com.AopFramework.ProxyFactoryBean

#target object
xxx.target=java.util.ArrayList
#advice object
xxx.advice=com.proxyTest.Myadvice

package com.AopFramework;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;

import com.proxyTest.Myadvice;

public class AopFrameworkTest {
	public static void main(String[] args) {
		//加载配制文件
		InputStream is=AopFrameworkTest.class.getResourceAsStream("config.properties");

		//创建工厂实例 ---》获得bean
		Object obj=new FactoryBean(is).getBean("xxx");
		//根据你入的名称和配制       打印获得的对象名称
		System.out.println(obj.getClass().getName());

		//打印测试
		Collection coll=(Collection) obj;

		/**
		 * 每次在执行自已方法的同时
		 * 都会执行自定义对象(MyAdivce)功能来进行处理
		 */

		coll.add("开始工作");
		System.out.println("\n---------------处理一个OK--------------------");
		coll.add("开始工作2");
		System.out.println("\n---------------处理一个OK--------------------");
	    System.out.println(coll.size());
	}

}