`

Spring AOP 的实现原理(2)

阅读更多

接上一篇Spring AOP 的实现原理(1):

 

 

 

上面类中出现的Logger类和Level枚举还是和上一上例子的实现是一样的.这里就不贴出代码了.

让我们写一个Test类去测试一下.代码如下:
Test.java

 1 package  sinosoft.dj.aop.proxyaop;
 2
 3 public   class  Test  {
 4      public   static   void  main(String[] args)  {
 5         IHello hello  =  (IHello) new  DynaProxyHello().bind( new  Hello());
 6         hello.sayGoogBye( " Double J " );
 7         hello.sayHello( " Double J " );
 8         
 9     }

10 }

11


运行输出的结果如下:

Tue Mar  04   21 : 24 : 03  CST  2008  sayGoogBye Method end  .
Double J GoodBye!
2008 - 3 - 4   21 : 24 : 03  sayGoogBye Method Start!
Tue Mar 
04   21 : 24 : 03  CST  2008  sayHello Method end  .
Hello Double J
2008 - 3 - 4   21 : 24 : 03  sayHello Method Start!


由于线程的关系,第二个方法的开始出现在第一个方法的结束之前.这不是我们所关注的!
从上面的例子我们看出.只要你是采用面向接口编程,那么,你的任何对象的方法执行之前要加上记录日志的操作都是可以的.他(DynaPoxyHello) 自动去代理执行被代理对象(Hello)中的每一个方法,一个java.lang.reflect.InvocationHandler接口就把我们的代 理对象和被代理对象解藕了.但是,我们又发现还有一个问题,这个DynaPoxyHello对象只能跟我们去在方法前后加上日志记录的操作.我们能不能把 DynaPoxyHello对象和日志操作对象(Logger)解藕呢?
结果是肯定的.让我们来分析一下我们的需求.
我们要在被代理对象的方法前面或者后面去加上日志操作代码(或者是其它操作的代码),
那么,我们可以抽象出一个接口,这个接口里就只有两个方法,一个是在被代理对象要执行方法之前执行的方法,我们取名为start,第二个方法就是在被代理对象执行方法之后执行的方法,我们取名为end .接口定义如下 :

 1 package  sinosoft.dj.aop.proxyaop;
 2
 3 import  java.lang.reflect.Method;
 4
 5 public   interface  IOperation  {
 6      /** */ /**
 7      * 方法执行之前的操作
 8      *  @param  method
 9       */

10      void  start(Method method);
11      /** */ /**
12      * 方法执行之后的操作
13      *  @param  method
14       */

15      void  end(Method method);
16 }

17


我们去写一个实现上面接口的类.我们把作他真正的操作者,如下面是日志操作者的一个类:
LoggerOperation.java

package  sinosoft.dj.aop.proxyaop;

import  java.lang.reflect.Method;

public   class  LoggerOperation  implements  IOperation  {

    
public   void  end(Method method)  {
        Logger.logging(Level.DEBUGE, method.getName() 
+   "  Method end  . " );
    }


    
public   void  start(Method method)  {
        Logger.logging(Level.INFO, method.getName() 
+   "  Method Start! " );
    }


}


然后我们要改一下代理对象DynaProxyHello中的代码.如下:

 1 package  sinosoft.dj.aop.proxyaop;
 2
 3 import  java.lang.reflect.InvocationHandler;
 4 import  java.lang.reflect.Method;
 5 import  java.lang.reflect.Proxy;
 6
 7 public   class  DynaProxyHello  implements  InvocationHandler  {
 8      /** */ /**
 9      * 操作者
10       */

11      private  Object proxy;
12      /** */ /**
13      * 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
14       */

15      private  Object delegate;
16
17      /** */ /**
18      * 动态生成方法被处理过后的对象 (写法固定)
19      * 
20      *  @param  delegate
21      *  @param  proxy
22      *  @return
23       */

24      public  Object bind(Object delegate,Object proxy)  {
25         
26          this .proxy  =  proxy;
27          this .delegate  =  delegate;
28          return  Proxy.newProxyInstance(
29                  this .delegate.getClass().getClassLoader(),  this .delegate
30                         .getClass().getInterfaces(),  this );
31     }

32      /** */ /**
33      * 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
34      * 此方法是动态的,不是手动调用的
35       */

36      public  Object invoke(Object proxy, Method method, Object[] args)
37              throws  Throwable  {
38         Object result  =   null ;
39          try   {
40              // 反射得到操作者的实例
41             Class clazz  =   this .proxy.getClass();
42              // 反射得到操作者的Start方法
43             Method start  =  clazz.getDeclaredMethod( " start " ,
44                      new  Class[]  { Method. class  } );
45              // 反射执行start方法
46             start.invoke( this .proxy,  new  Object[]  { method } );
47              // 执行要处理对象的原本方法
48             result  =  method.invoke( this .delegate, args);
49 //             反射得到操作者的end方法
50             Method end  =  clazz.getDeclaredMethod( " end " ,
51                      new  Class[]  { Method. class  } );
52 //             反射执行end方法
53             end.invoke( this .proxy,  new  Object[]  { method } );
54
55         }
  catch  (Exception e)  {
56             e.printStackTrace();
57         }

58          return  result;
59     }

60
61 }

62


然后我们把Test.java中的代码改一下.测试一下:

package  sinosoft.dj.aop.proxyaop;

public   class  Test  {
    
public   static   void  main(String[] args)  {
        IHello hello 
=  (IHello) new  DynaProxyHello().bind( new  Hello(), new  LoggerOperation());
        hello.sayGoogBye(
" Double J " );
        hello.sayHello(
" Double J " );
        
    }

}

结果还是一样的吧.

如果你想在每个方法之前加上日志记录,而不在方法后加上日志记录.你就把LoggerOperation类改成如下:

 1 package  sinosoft.dj.aop.proxyaop;
 2
 3 import  java.lang.reflect.Method;
 4
 5 public   class  LoggerOperation  implements  IOperation  {
 6
 7      public   void  end(Method method)  {
 8          // Logger.logging(Level.DEBUGE, method.getName() + " Method end  .");
 9     }

10
11      public   void  start(Method method)  {
12         Logger.logging(Level.INFO, method.getName()  +   "  Method Start! " );
13     }

14
15 }

16


运行一下.你就会发现,每个方法之后没有记录日志了. 这样,我们就把代理者和操作者解藕了!

下面留一个问题给大家,如果我们不想让所有方法都被日志记录,我们应该怎么去解藕呢.?
我的想法是在代理对象的public Object invoke(Object proxy, Method method, Object[] args)方法里面加上个if(),对传进来的method的名字进行判断,判断的条件存在XML里面.这样我们就可以配置文件时行解藕了.如果有兴趣的 朋友可以把操作者,被代理者,都通过配置文件进行配置 ,那么就可以写一个简单的SpringAOP框架了.

分享到:
评论

相关推荐

    spring aop实现原理

    NULL 博文链接:https://zhang-yingjie-qq-com.iteye.com/blog/319927

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    Spring框架中的AOP模块使用了动态代理来实现AOP概念。Spring AOP允许开发者定义切面,并在这些切面中指定拦截的方法。Spring AOP支持不同的代理策略,包括JDK动态代理和CGLIB代理。如果被代理的类没有实现接口,...

    Spring AOP实现机制

    **Spring AOP 实现机制详解** Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许程序员在不修改源代码的情况下,通过“切面”来插入额外的业务逻辑,如日志、事务管理等。AOP的引入极大地提高了代码的...

    Spring框架系列(9) - Spring AOP实现原理详解之AOP切面的实现.doc

    Spring AOP 实现原理详解之 AOP 切面的实现 Spring AOP 是基于 IOC 的 Bean 加载来实现的,本文主要介绍 Spring AOP 原理解析的切面实现过程。AOP 切面的实现是将切面类的所有切面方法根据使用的注解生成对应 ...

    Spring AOP面向方面编程原理:AOP概念

    ### Spring AOP面向方面编程原理:AOP概念详解 #### 一、引言 随着软件系统的日益复杂,传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战,面向方面编程...

    反射实现 AOP 动态代理模式(Spring AOP 的实现 原理) - Java 例子 -

    本文将深入探讨Spring AOP的实现原理,以及如何使用反射来实现动态代理模式。 首先,我们需要了解AOP的基本概念。AOP的核心思想是切面,它包含两个主要部分:切点(Pointcut)和通知(Advice)。切点定义了在程序...

    JDK动态代理 spring aop 的原理

    总的来说,JDK动态代理是Spring AOP实现的基础,它允许我们在运行时动态创建代理对象,实现对方法调用的拦截和增强。Spring AOP则在此基础上提供了更高级的抽象,让我们可以方便地定义和管理切面,从而实现更灵活的...

    spring aop 自定义注解保存操作日志到mysql数据库 源码

    2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 (需要知道原理的请看spring aop源码,此处不做赘述) 3、可在现有源码上快速进行功能扩展 4、spring boot,mybatis,druid,spring aop的使用

    简单spring aop 例子

    本示例将简要介绍如何在Spring应用中实现AOP,通过实际的代码示例帮助理解其工作原理。 首先,我们要理解AOP的核心概念。AOP是一种编程范式,它允许开发者定义“切面”(Aspects),这些切面封装了特定的关注点,如...

    spring ioc和aop原理流程图(详细)

    6. **代理(Proxy)**:Spring AOP通过动态代理实现切面的织入。对于接口,使用JDK动态代理;对于非接口类,使用CGLIB动态代理。 Spring的IOC和AOP机制使得开发者能够更专注于业务逻辑,而不是繁琐的依赖管理和横切...

    SpringAop学习笔记以及实现Demo

    4. **事务管理Demo**:结合Spring的事务管理特性,展示了如何使用AOP实现数据库操作的事务控制。 通过这些示例,你可以深入理解Spring AOP的工作原理,掌握其配置和使用方式,从而在实际项目中灵活地应用切面编程,...

    Spring Aop的底层实现技术 --- Jdk动态代理原理

    Spring AOP 的底层实现技术 --- Jdk 动态代理原理 JDK 动态代理是 Spring AOP 的底层实现技术,允许开发者在运行期创建接口的代理实例。在 JDK 1.3 以后,JDK 动态代理技术提供了实现 AOP 的绝好底层技术。JDK 动态...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序.pdf

    在深入理解 Spring AOP 的源码时,需要熟悉 Spring IoC 的工作原理,以及 AOP 相关的概念,如切点表达式、通知类型等。了解这些基础知识可以帮助我们更好地掌握 Spring AOP 的实现细节。在分析源码时,可以参考作者...

    Java动态代理(Spring Aop原理)

    在Spring框架中,AOP(面向切面编程)就是基于Java动态代理来完成的,用于实现横切关注点,如日志、事务管理等。这篇博客的文章链接虽然没有给出具体内容,但我们可以根据Java动态代理和Spring AOP的基本概念来深入...

    Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现.doc

    Spring AOP,全称Aspect Oriented Programming,即面向切面编程,是Spring框架的一个重要特性,用于实现横切关注点的模块化。AOP通过在运行时动态地将代码编织到一起,使得我们可以在不修改原有业务代码的情况下,对...

    Spring aop 性能监控器

    本篇文章将深入探讨如何使用Spring AOP实现性能监控器,并通过源码分析来理解其工作原理。 首先,我们要了解AOP的核心概念——切面(Aspect)、通知(Advice)、连接点(Join Point)、切入点(Pointcut)和织入...

    Spring AOP的底层实现技术

    可以帮助我们更好地理解其工作原理,例如,可以查看`org.springframework.aop.framework.ProxyFactoryBean`、`org.springframework.aop.aspectj.autoproxy.AspectJProxyFactoryBean`、`org.springframework.aop....

    spring aop 学习笔记

    - **事务管理**:通过AOP实现声明式事务管理,简化事务控制代码。 - **性能监控**:在关键方法前、后插入性能计时通知,便于性能分析。 - **权限校验**:在方法执行前进行用户权限验证,确保安全。 5. **源码...

    深入浅析Spring 的aop实现原理

    AOP(Aspect-Oriented Programming,面向方面编程)是一种编程范式,旨在提供更好的模块化和组织代码的方式,...通过理解Spring AOP的实现原理,开发者可以更好地设计和优化应用程序,提升系统架构的灵活性和可扩展性。

    springboot+aspect实现springaop拦截指定方法.zip

    综上所述,SpringBoot结合AspectJ实现SpringAOP拦截指定方法,主要涉及到Spring AOP的原理、切点和通知的定义、自定义注解的使用,以及如何在SpringBoot项目中整合AspectJ进行更复杂的切面编程。通过这些知识点,...

Global site tag (gtag.js) - Google Analytics