`

开源框架spring详解-----AOP的深刻理解

 
阅读更多
开源框架spring详解-----AOP的深刻理解

AOP的理解

         1、AOP的概述
                   AOP是一种不同于OOP(面向对象编程)的编程模式,它不是OOP的替代,而是对OOP的一种有益补充。
         2、spring AOP的原理
         3、spring AOP的实现
                   在spring2.5中,常用的AOP实现方式有两种。第一种是基于xml配置文件方式的实现,第二种是基于注解方式的实现。
                   接下来,以具体的是理智讲解这两种方式的使用。
 
Java代码  
package com.zxf.service;  
  
/** 
 * 业务逻辑接口 
 * @author z_xiaofei168 
 */  
public interface AccountService {  
    public void save(String loginname, String password);  
}  
  
它的实现类  
  
package com.zxf.service;  
import com.zxf.dao.AccountDao;  
  
/** 
 * AccountService的实现类 
 * @author z_xiaofei168 
 */  
public class AccountServiceImpl implements AccountService {  
    private  AccountDao accountDao;  
      
    public AccountServiceImpl() {}  
      
    /** 带参数的构造方法 */  
    public AccountServiceImpl(AccountDao accountDao){  
        this.accountDao = accountDao;  
    }  
      
    public void save(String loginname, String password) {  
        accountDao.save(loginname, password);  
        throw new RuntimeException("故意抛出一个异常。。。。");  
    }  
      
    /** set方法 */  
    public void setAccountDao(AccountDao accountDao) {  
        this.accountDao = accountDao;  
    }  
}  
   
     对于业务系统来说,AccountServiceImpl类就是目标实现类,它的业务方法,如save()方法的前后或代码会出现异常的地方都是AOP的连接点。
 
下面是日志服务类的代码:
 
 
Java代码  
package com.zxf.aspect;  
  
import org.aspectj.lang.JoinPoint;  
import org.aspectj.lang.ProceedingJoinPoint;  
  
/** 
 * 日志切面类 
 * @author z_xiaofei168 
 */  
public class LogAspect {  
  
    //任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型   
    public void before(JoinPoint call) {  
        //获取目标对象对应的类名  
        String className = call.getTarget().getClass().getName();  
        //获取目标对象上正在执行的方法名  
        String methodName = call.getSignature().getName();  
          
        System.out.println("前置通知:" + className + "类的" + methodName + "方法开始了");  
    }  
      
    public void afterReturn() {  
        System.out.println("后置通知:方法正常结束了");  
    }  
      
    public void after(){  
        System.out.println("最终通知:不管方法有没有正常执行完成,一定会返回的");  
    }  
      
    public void afterThrowing() {  
        System.out.println("异常抛出后通知:方法执行时出异常了");  
    }  
      
    //用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型  
    public Object doAround(ProceedingJoinPoint call) throws Throwable {  
        Object result = null;  
        this.before(call);//相当于前置通知  
        try {  
            result = call.proceed();  
            this.afterReturn(); //相当于后置通知  
        } catch (Throwable e) {  
  
            this.afterThrowing();  //相当于异常抛出后通知  
            throw e;  
        }finally{  
            this.after();  //相当于最终通知  
        }  
          
        return result;  
    }  
}  
 
     这个类属于业务服务类,如果用AOP的术语来说,它就是一个切面类,它定义了许多通知。Before()、afterReturn()、after()和afterThrowing()这些方法都是通知。
 
<1>.基于xml配置文件的AOP实现
 
         这种方式在实现AOP时,有4个步骤。
 
Xml代码  
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>  
  
    <bean id="accountDaoImpl" class="com.zxf.dao.AccountDaoImpl"/>  
      
    <bean id="accountService" class="com.zxf.service.AccountServiceImpl">  
        <property name=" accountDaoImpl " ref=" accountDaoImpl "/>  
    </bean>  
  
    <!-- 日志切面类 -->  
    <bean id="logAspectBean" class="com.zxf.aspect.LogAspect"/>  
      
    <!-- 第1步: AOP的配置 -->  
    <aop:config>  
        <!-- 第2步:配置一个切面 -->  
        <aop:aspect id="logAspect" ref="logAspectBean">  
            <!-- 第3步:定义切入点,指定切入点表达式 -->  
            <aop:pointcut id="allMethod"   
                expression="execution(* com.zxf.service.*.*(..))"/>  
                  
            <!-- 第4步:应用前置通知 -->  
            <aop:before method="before" pointcut-ref="allMethod" />  
            <!-- 第4步:应用后置通知 -->  
            <aop:after-returning method="afterReturn" pointcut-ref="allMethod"/>  
            <!-- 第4步:应用最终通知 -->  
            <aop:after method="after" pointcut-ref="allMethod"/>  
            <!-- 第4步:应用抛出异常后通知 -->  
            <aop:after-throwing method="afterThrowing" pointcut-ref="allMethod"/>  
              
            <!-- 第4步:应用环绕通知 -->  
            <!--  
            <aop:around method="doAround" pointcut-ref="allMethod" /> 
             -->  
        </aop:aspect>  
    </aop:config>  
</beans>  
 
 
    上述配置针对切入点应用了前置、后置、最终,以及抛出异常后通知。这样在测试执行AccountServiceImpl类的save()方法时,控制台会有如下结果输出。
 
前置通知:com.zxf.service.AccountServiceImpl类的save方法开始了。
针对MySQL的AccountDao实现中的save()方法。
后置通知:方法正常结束了。
最终通知:不管方法有没有正常执行完成,一定会返回的。
   <2>基于注解的AOP的实现
 
    首先创建一个用来作为切面的类LogAnnotationAspect,同时把这个类配置在spring的配置文件中。
        在spring2.0以后引入了JDK5.0的注解Annotation的支持,提供了对AspectJ基于注解的切面的支持,从而 更进一步地简化AOP的配置。具体的步骤有两步。
 
Spring的配置文件是如下的配置:
 
 
Xml代码  
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>  
  
    <bean id="accountDao" class="com.zxf.dao.AccountDaoImpl"/>  
    <bean id="accountService" class="com.zxf.service.AccountServiceImpl">  
        <property name="accountDao" ref="accountDao"/>  
    </bean>  
    <!-- 把切面类交由Spring容器来管理 -->  
    <bean id="logAspectBean" class="com.zxf.aspect.LogAnnotationAspect"/>  
    <!-- 启用spring对AspectJ注解的支持 -->  
    <aop:aspectj-autoproxy/>  
</beans>  
 
这是那个切面的类LogAnnotationAspect
Java代码  
package com.zxf.aspect;  
  
import org.aspectj.lang.JoinPoint;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.After;  
import org.aspectj.lang.annotation.AfterReturning;  
import org.aspectj.lang.annotation.AfterThrowing;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Before;  
import org.aspectj.lang.annotation.Pointcut;  
  
/** 
 * 日志切面类 
 */  
@Aspect  //定义切面类  
public class LogAnnotationAspect {  
    @SuppressWarnings("unused")  
    //定义切入点  
    @Pointcut("execution(* com.zxf.service.*.*(..))")  
    private void allMethod(){}  
      
    //针对指定的切入点表达式选择的切入点应用前置通知  
    @Before("execution(* com. zxf.service.*.*(..))")  
    public void before(JoinPoint call) {  
          
        String className = call.getTarget().getClass().getName();  
        String methodName = call.getSignature().getName();  
          
        System.out.println("【注解-前置通知】:" + className + "类的"   
                + methodName + "方法开始了");  
    }  
    //访问命名切入点来应用后置通知  
    @AfterReturning("allMethod()")  
    public void afterReturn() {  
        System.out.println("【注解-后置通知】:方法正常结束了");  
    }  
      
    //应用最终通知  
    @After("allMethod()")  
    public void after(){  
        System.out.println("【注解-最终通知】:不管方法有没有正常执行完成,"   
                + "一定会返回的");  
    }  
      
    //应用异常抛出后通知  
    @AfterThrowing("allMethod()")  
    public void afterThrowing() {  
        System.out.println("【注解-异常抛出后通知】:方法执行时出异常了");  
    }  
      
    //应用周围通知  
    //@Around("allMethod()")  
    public Object doAround(ProceedingJoinPoint call) throws Throwable{  
        Object result = null;  
        this.before(call);//相当于前置通知  
        try {  
            result = call.proceed();  
            this.afterReturn(); //相当于后置通知  
        } catch (Throwable e) {  
            this.afterThrowing();  //相当于异常抛出后通知  
            throw e;  
        }finally{  
            this.after();  //相当于最终通知  
        }  
          
        return result;  
    }  
}  

 

分享到:
评论

相关推荐

    spring-aop-4.0.1.RELEASE.zip

    在"spring-aop-4.0.1.RELEASE.zip"中,可能包含了相关的配置和示例代码,帮助开发者更好地理解和使用AspectJ与Spring的集成。 总的来说,Spring框架的AOP模块为开发者提供了灵活、强大的工具,以实现横切关注点的...

    spring框架:spring-framework-4.3.9.RELEASE-dist

    Spring框架是Java开发领域中的核心组件之一,以其强大的依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)功能,极大地简化了企业级应用的开发。本文将深入探讨Spring ...

    官方完整包 spring-framework-5.3.7.RELEASE-dist.zip

    Spring Framework 是一个开源的应用程序框架,它主要针对Java平台,为构建企业级应用提供了全面的解决方案。5.3.7.RELEASE是Spring Framework的一个稳定版本,包含了一系列的增强功能和性能优化。本压缩包“spring-...

    spring2.5 -3.0 hibernate3.3 jar包说明

    Spring是一个开源的应用框架,它提供了一个全面的编程模型,旨在简化Java应用程序的开发过程。Spring的核心功能包括依赖注入(Dependency Injection, DI)、面向切面编程(Aspect Oriented Programming, AOP)、事务...

    spring-framework-3.0.RELEASE

    Spring框架作为Java领域中最受欢迎的轻量级开源框架之一,其3.0版本的发布标志着一个重要的里程碑。本文将深入探讨Spring框架3.0的核心特性、主要改进以及如何使用其中的jar包。 一、Spring框架概述 Spring框架以...

    Spring4Ioc-Aop

    Spring是一个开源框架,旨在简化企业级应用开发。通过Spring框架,普通的JavaBean能够实现以往只有通过EJB才能完成的功能。Spring的核心特性包括轻量级、依赖注入(DI/IOC)、面向切面编程(AOP)等,这使得它成为...

    spring-framework-4.0.0.RELEASE官方完整包

    Spring Framework是一款开源的应用框架,主要目标是简化Java EE应用程序的开发。它提供了AOP(面向切面编程)、IOC(控制反转)和DI(依赖注入)等关键特性,极大地提高了代码的可测试性和模块化程度。Spring 4.0.0....

    spring4-hibernate4-struts2整合

    **Spring4** 是一个开源的轻量级Java开发框架,旨在简化企业级应用的开发过程。它提供了强大的IoC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)功能,支持多种模块化设计...

    spring jar 包详解

    Spring 是一个开源的 Java 开发框架,主要用于简化企业级应用的开发工作。它通过提供一系列的基础框架,使得开发者能够更容易地处理复杂的业务逻辑,并且提高了代码的可维护性和可测试性。Spring 提供了多种不同的 ...

    java-spring教程-全面理解

    - **定义**: Spring是一个开源框架,旨在简化企业级应用的开发。 - **功能定位**: 既可以被视为一个容器(负责管理对象的生命周期),也可以被视为一个框架(提供基础设施支持)。 - **特点**: 轻量级、非侵入式。 -...

    spring-tx-4.2.4.RELEASE.zip

    《Spring 框架详解:以 Spring TX 4.2.4.RELEASE 为例》 在软件开发领域,Spring 框架无疑是 Java 平台上最受欢迎的开源项目之一。其强大的功能、灵活的设计以及丰富的生态使得它成为企业级应用开发的首选。本文将...

    spring-mybatis-spring-3.0.1.zip

    Spring框架提供了依赖注入(DI)和面向切面编程(AOP)等特性,使得代码更加松耦合,易于测试和维护。而MyBatis则专注于SQL的编写和执行,避免了传统的JDBC中的大量模板代码,提高了开发效率。两者的整合,可以让...

    Spring - 3 AOP

    Spring 是一款轻量级的开源框架,主要用于简化企业级应用的开发工作。它提供了丰富的功能集,包括依赖注入(Dependency Injection, DI)、面向切面编程(Aspect-Oriented Programming, AOP)、数据访问/集成(Data ...

    spring-framework-3.0.5.RELEASE-dependencies3

    在Java开发领域,Spring框架无疑是最具影响力和广泛使用的开源框架之一。本文将深入探讨Spring Framework 3.0.5.RELEASE版本中的核心依赖,以及这些依赖在实际应用中的作用。由于文件大小限制,该版本的依赖被分成了...

    spring-framework-2.5.5-with-dependencies.zip

    《Spring框架2.5.5依赖包详解及应用探索》 Spring Framework作为Java开发领域中的一个里程碑,一直以来都是企业级应用开发的首选框架。本文将深入探讨Spring 2.5.5版本及其依赖包,旨在为开发者提供全面的了解和...

    Spring-framework-4.3

    《Spring框架4.3详解——基于Javadoc-API的官方文档》 Spring框架是Java开发中的一个核心组件,尤其在企业级应用中广泛使用。本文将深入探讨Spring框架4.3版本,结合其提供的Javadoc-API文档,帮助开发者更好地理解...

    spring-mybatis-spring-2.0.3.zip

    Spring是一个开源的企业级应用框架,它提供了全面的编程和配置模型,包括依赖注入(DI)、面向切面编程(AOP)以及丰富的MVC支持。而MyBatis则是一个轻量级的ORM框架,它简化了SQL操作,允许开发者直接编写SQL语句,...

    spring-xx.zip

    Spring框架作为Java领域最广泛应用的轻量级开源框架,以其模块化、松耦合的设计理念,为开发者提供了强大的企业级应用开发能力。本压缩包"spring-xx.zip"包含了Spring框架的核心组件,包括spring-jdbc、spring-aop、...

    spring jar 包

    Spring框架作为Java领域最广泛使用的轻量级开源框架,以其模块化、松耦合的设计理念赢得了广大开发者的青睐。在提供的压缩包中,包含了Spring框架4.3.9版本的核心组件,以及一个依赖库——Apache Commons Logging ...

Global site tag (gtag.js) - Google Analytics