Java动态代理实现(简单AOP实现)

  本文介绍了简单Aop实现的方法,意在抛砖引玉。  

首先是简单的Aspect接口 
Java代码   收藏代码
  1. package org.aspect;  
  2.   
  3. /** 
  4.  * 切面接口 
  5.  */  
  6. public interface Aspect {  
  7.       
  8.     /** 
  9.      * 事先执行 
  10.      */  
  11.     public void doBefore();  
  12.       
  13.     /** 
  14.      * 事后执行 
  15.      */  
  16.     public void doAfter();  
  17. }  


然后是代理工厂 
Java代码   收藏代码
  1. package org.aspect;  
  2.   
  3. import java.lang.reflect.Proxy;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7. /** 
  8.  * 代理工厂类 
  9.  */  
  10. public class DynamicProxyFactory {  
  11.       
  12.     /** 
  13.      * 私有构造方法 
  14.      */  
  15.     private DynamicProxyFactory() {}  
  16.       
  17.     /** 
  18.      * 工厂方法 
  19.      *  
  20.      * @param instance 代理目标类实例对象 
  21.      * @param aspect 切面对象 
  22.      */  
  23.     public static Object newInstance(Object instance, Aspect aspect) {  
  24.           
  25.         List<Aspect> aspectList = new ArrayList<Aspect>();  
  26.         aspectList.add(aspect);  
  27.           
  28.         return newInstance(instance, aspectList);  
  29.     }  
  30.       
  31.     /** 
  32.      * 工厂方法 
  33.      *  
  34.      * @param instance 代理目标类实例对象 
  35.      * @param aspectList 切面集合 
  36.      */  
  37.     public static Object newInstance(Object instance, List<Aspect> aspectList) {  
  38.         SimpleInvocationHandler hander = new SimpleInvocationHandler();  
  39.         hander.setAspectList(aspectList);  
  40.         hander.setSource(instance);  
  41.         return Proxy.newProxyInstance(instance.getClass().getClassLoader(),   
  42.                                       instance.getClass().getInterfaces(),   
  43.                                       hander);  
  44.     }  
  45. }  


最后是代理执行类 
Java代码   收藏代码
  1. package org.aspect;  
  2.   
  3. import java.lang.reflect.InvocationHandler;  
  4. import java.lang.reflect.Method;  
  5. import java.util.List;  
  6.   
  7. /** 
  8.  * 代理委托接口实现 
  9.  */  
  10. public class SimpleInvocationHandler implements InvocationHandler {  
  11.   
  12.       
  13.     private Object source = null;  
  14.       
  15.     private List<Aspect> aspectList = null;  
  16.       
  17.       
  18.     public Object getSource() {  
  19.         return source;  
  20.     }  
  21.   
  22.   
  23.     public void setSource(Object source) {  
  24.         this.source = source;  
  25.     }  
  26.   
  27.   
  28.     public List<Aspect> getAspectList() {  
  29.         return aspectList;  
  30.     }  
  31.   
  32.   
  33.     public void setAspectList(List<Aspect> aspectList) {  
  34.         this.aspectList = aspectList;  
  35.     }  
  36.   
  37.     /** 
  38.      * 委托方法 
  39.      *  
  40.      * @param proxy 代理对象 
  41.      * @param method 代理方法 
  42.      * @param args 方法参数 
  43.      */  
  44.     public Object invoke(Object proxy, Method method, Object[] args)  
  45.             throws Throwable {  
  46.           
  47.         for (Aspect aspect : aspectList) {  
  48.             aspect.doBefore();  
  49.         }  
  50.           
  51.         Object retObj = method.invoke(getSource(), args);  
  52.           
  53.         for (int index = aspectList.size() - 1; index >= 0; index--) {  
  54.             aspectList.get(index).doAfter();  
  55.         }  
  56.           
  57.         return retObj;  
  58.     }  
  59.       
  60. }  


测试代码 

Java代码   收藏代码
  1. public interface Student {  
  2.     public void sayHello();  
  3. }  
  4.   
  5. import org.aspect.Aspect;  
  6.   
  7. public class StudentAspectOne implements Aspect {  
  8.   
  9.     @Override  
  10.     public void doAfter() {  
  11.         System.out.println("do After One");  
  12.           
  13.     }  
  14.   
  15.     @Override  
  16.     public void doBefore() {  
  17.         System.out.println("do Before One");  
  18.           
  19.     }  
  20.   
  21. }  
  22.   
  23. import org.aspect.Aspect;  
  24.   
  25.   
  26. public class StudentAspectTwo implements Aspect{  
  27.     @Override  
  28.     public void doAfter() {  
  29.         System.out.println("do After Two");  
  30.           
  31.     }  
  32.   
  33.     @Override  
  34.     public void doBefore() {  
  35.         System.out.println("do Before Two");  
  36.           
  37.     }  
  38. }  
  39.   
  40. public class StudentImpl implements Student {  
  41.   
  42.     @Override  
  43.     public void sayHello() {  
  44.         System.out.println("Student");  
  45.     }  
  46.   
  47. }  
  48.   
  49. import java.util.ArrayList;  
  50. import java.util.List;  
  51.   
  52. import org.aspect.Aspect;  
  53. import org.aspect.DynamicProxyFactory;  
  54.   
  55. public class Test {  
  56.   
  57.     public static void main(String[] args) {  
  58.           
  59.         List<Aspect> aspectList = new ArrayList<Aspect>();  
  60.           
  61.         aspectList.add(new StudentAspectOne());  
  62.         aspectList.add(new StudentAspectTwo());  
  63.         Student s = (Student)DynamicProxyFactory.newInstance(new StudentImpl(), aspectList);  
  64.         s.sayHello();  
  65.     }  
  66.   
  67. }  


执行Test,控制台返回 

do Before One 
do Before Two 
Student 
do After Two 
do After One 
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值