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

原创 于 2013-11-17 23:48:04 发布 · 1.3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍Java代理模式的应用，包括反射创建代理对象、自定义代理处理流程，并通过Spring AOP实现简单示例。深入剖析了代理模式在实际项目中的具体实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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

}


评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值