Spring框架学习（9）AOP技术理解与使用

内容源自：AOP技术理解与使用

一、什么是AOP?

aop技术是面向切面编程思想，作为OOP（面向对象编程）的延续思想添加到企业开发中，用于弥补OOP开发过程中的缺陷而提出的编程思想。

AOP底层也是面向对象；只不过面向的不是普通的Object对象，而是特殊的AOP对象。AOP的关注点是组成系统的非核心通用服务模块（比如登录检查等），相对于普通对象，aop不需要通过继承、方法调用的方式来提供功能，只需要在xml文件中以引用的方式，将非核心服务功能引用给需要改功能的核心业务逻辑对象或方法中。最终实现对象的解耦。spring 中ioc技术实现了核心业务逻辑对象之间的解耦（如LoginAction与DaoImpl）, aop技术实现的是核心业务逻辑对象与非核心通用服务之间的解耦（如LoginAction与LoginCheckInterceptor）.

二、AOP相对于OOP有什么好处？

OOP的问题不存在于开发阶段，在开发阶段和首次测试阶段中，使用OOP是效率最高也是最简单的一种方式。OOP问题体现在软件开发完毕之后的二次测试阶段，软件修改完毕之后，需要对软件中修改的方法进行重新测试，之后才可以上线运行。这时测试的对象是当前修改的方法 以及 和该方法具有级联/依赖关系的所有的其他方法。这样做显然了延长二次测试周期。 而使用aop在二次测试时，因为他是配置在xml文件中的，所以并不需要测试相关的所有类。

三、spring中如何使用aop?

我们使用一个例子来介绍下如何在spring中使用aop, 
这里我们提供一个类StuAction，为这个类中的核心业务逻辑方法(addStu、delStu)添加登录检查的功能。

public class StuAction {
    public String addStu(){
        System.out.println("处理客户端提交的addStu.action请求");
        //int i = 1/0;
        return "success";
    }
    public String delStu(){
        System.out.println("处理客户端提交的selStu.action请求");
        return "success";
    }
}

spring中的AOP技术提供了四种基本类型的通知:

  • before通知 ~ 核心方法执行之前的通知 MethodBeforeAdvice
  • after通知 ~ 核心方法执行之后的通知 AfterReturningAdvice
  • around通知 ~ 核心方法执行时的通知before+after filter、interceptor都是一种around通知 MethodInterceptor
  • throws通知 ~ 核心方法执行出现异常之后执行的通知 ThrowsAdvice

这四种通知我们都来测试下： 
注意：在测试athrows通知时把StuAction中的int i = 1/0;取消注释，我们创建一个异常来进行测试。 
另外，after通知主要用来核心方法调用结束后输出日志，所以这里用到了log4j 。

// 定义一个实现MethodBeforeAdvice的通知类 - before通知
public class LoginCheckAdvice implements MethodBeforeAdvice {
    // 该方法会在核心方法执行之前自动执行
    @Override
    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("判断当前是否存在登录用户");
            // 根据判断的结果决定是否执行后续的核心方法
    }
}

// after通知
public class LoggerAdvice implements AfterReturningAdvice{
    private static Logger logger =
        Logger.getLogger(LoggerAdvice.class);
    // 该方法会在核心方法执行完毕之后自动执行
    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("核心方法执行完毕之后进行日志记录");

        // 记录一条日志信息
        logger.error("这是一条error级别的日志信息");
        logger.warn("这是一条warn级别的日志信息");
        logger.info("这是一条info级别的日志信息");
        logger.debug("这是一条debug级别的日志信息");
    }
}

// around通知
public class AroundAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        //struts2 interceptor ActionInvocation调度者
        System.out.println("around通知-核心方法执行之前");
        Object result = invocation.proceed();
            // 将请求的执行权限转交给核心业务逻辑方法 addStu/selStu
            // result - 核心方法的执行结果 addStu()/selStu()
        System.out.println("result--"+result); // success
        System.out.println("around通知-核心方法执行之后");
        return result;
    }
}

// throws通知
public class ExceptionAdvice implements ThrowsAdvice {
    //该方法会在核心方法执行出现异常之后自动执行
    public void afterThrowing(Method method, Object[] args,
            Object target, Exception ex){
        System.out.println("核心方法执行出现异常了...异常信息"+ex.getMessage());
    }
}

log4j.properties

log4j.rootLogger=info,etoak1,etoak2
log4j.appender.etoak1=org.apache.log4j.ConsoleAppender
log4j.appender.etoak1.layout=org.apache.log4j.TTCCLayout

log4j.appender.etoak2=org.apache.log4j.FileAppender
log4j.appender.etoak2.file=C://log4j.html
log4j.appender.etoak2.layout=org.apache.log4j.HTMLLayout

好了，准备工作完毕，那我们如何在spring容器中配置aop呢？ 
重点的来了！ 
在applicationContext.xml中配置aop: 
首先导入spring 中aop下所有包，log4j 包

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!--
        引入aop命名空间、schame文件
        需求 : 使用spring提供的AOP技术为
        添加登录检查的辅助功能
        1 将登录检查的功能封装成一种spring中的AOP组件
            AOP组件[struts2拦截器 filter过滤器 spring通知]
        2 将通知类、核心业务逻辑对象[具有依赖关系的两个对象]
        配置在ioc容器中
     -->
    <bean id="action" class="com.etoak.action.StuAction"/>

    <bean id="lc" class="com.etoak.util.LoginCheckAdvice"/>
    <bean id="logger" class="com.etoak.util.LoggerAdvice"/>
    <bean id="around" class="com.etoak.util.AroundAdvice"/>
    <bean id="exce" class="com.etoak.util.ExceptionAdvice"></bean>
    <!--
        3 使用AOP方式将通知类引用给业务逻辑对象
        aop:config ： 配置一个aop组件[通知类的使用方式]
        3.1 描述需要将这个通知类提供的功能引用给谁
            aop:pointcut  配置切入点
                切入点 : 用于描述通知执行的地点[在哪执行]
                    地址 : 在哪个/哪些方法周围执行
                切入点指向的是需要添加登录检查功能的一组方法
            expression属性(表达式):通知执行一个表达式，将表达式的执行结果作为切入点
                表达式的执行结果指向的也是一组方法
        execution(* com.etoak.action.*.*(..))
            execution(1 2) 执行()中表达式的内容
            1 用于限定方法的返回值 *
            2 用于限定方法的位置、名字
                com.etoak.action.*.*(..)
        3.2 组装通知类+切入点 形成一个AOP组件[切面]
     -->
    <aop:config>
        <aop:pointcut expression="execution(* com.etoak.action.Stu*.add*(..)) || execution(* com.etoak.action.*.del*(..))" id="pc"/>
        <aop:advisor advice-ref="lc" pointcut-ref="pc"/><!-- 将id="lc"这个通知类提供的功能引用给   id="pc"这个切入点指向的那组方法. -->
        <aop:advisor advice-ref="logger" pointcut-ref="pc"/>
        <aop:advisor advice-ref="around" pointcut-ref="pc"/>
        <aop:advisor advice-ref="exce" pointcut-ref="pc"/>
    </aop:config>
</beans>

使用test类测试一下：

public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        StuAction la = (StuAction)ac.getBean("action");
        la.addStu();
        la.delStu();
    }
}

结果如下： 

原文地址：https://www.cnblogs.com/xym4869/p/8975902.html

时间： 2024-08-11 08:34:05

Spring框架学习（9）AOP技术理解与使用的相关文章

Spring框架学习06——AOP底层实现原理

在Java中有多种动态代理技术,如JDK.CGLIB.Javassist.ASM,其中最常用的动态代理技术是JDK和CGLIB. 1.JDK的动态代理 JDK动态代理是java.lang.reflect.*包提供的方法,必须要借助一个接口才能产生代理对象,对于使用业务接口的类,Spring默认使用JDK动态代理实现AOP.代码示例如下:创建dao包,并创建StuDao接口和StuDaoImpl实现类,StuDao接口 public interface StuDao { public void a

Spring框架学习05——AOP相关术语详解

1.Spring AOP 的基本概述 AOP(Aspect Oriented Programing)面向切面编程,AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码(性能监视.事务管理.安全检查.缓存).Spring AOP使用纯Java实现,不需要专门的编译过程和类加载器,在运行期通过代理方式向目标类织入增强代码. 2.AOP的相关术语 在Spring AOP 框架中涉及以下常用术语: 连接点(Joinpoint):是指程序运行中的一些时间点,即那些被拦截到的点,例如方法的调用或异常的抛

spring框架学习(三)——AOP( 面向切面编程)

AOP 即 Aspect Oriented Program 面向切面编程 首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能. 所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务 所谓的周边功能,比如性能统计,日志,事务管理等等 周边功能在Spring的面向切面编程AOP思想里,即被定义为切面 在面向切面编程AOP的思想里面,核心业务功能和切面功能分别独立进行开发 然后把切面功能和核心业务功能 "编织" 在一起,这就叫AOP 原理图 1. 功能分两大类,辅助功能和

spring框架学习（六）AOP

spring框架学习(六)AOP AOP(Aspect-OrientedProgramming)面向方面编程,与OOP完全不同,使用AOP编程系统被分为方面或关注点,而不是OOP中的对象. AOP的引入 在OOP面向对象的使用中,无可避免的会出现代码重复,而且使用面向对象的编程方式,这种重复无法避免,比如用户权限判断中,根据相应的权限执行相应的方法:在servlet中设置编码格式时,同样相同的代码出现很多次,而且还根业务无关,很容易忘记写,结果运行的时候就出现乱码拉.这种重复代码不仅使编码麻烦,

Spring框架学习总结（上）

目录 1.Spring的概述 2.Spring的入门(IOC) 3.Spring的工厂类 4.Spring的配置 5.Spring的属性注入 6.Spring的分模块开发的配置 @ 1.Spring的概述 在学习SSM框架中,我建议初学者最好先学Spring框架,其次mybatis接着springMVC,先学mybatis当然也是可以的,今天我们就以绝对优雅的姿态闯进Spring世界,系好安全带,准备好了吗,出发了哦!!!咳咳....平时开发接触最多的估计就是IOC容器,它可以装载bean(所谓

Spring框架学习1

AnonymouL 兴之所至,心之所安;尽其在我,顺其自然 新随笔 管理 Spring框架学习(一) 阅读目录 一. spring概述 核心容器: Spring 上下文: Spring AOP: Spring DAO: Spring ORM: Spring Web 模块: Spring MVC 框架: 二.实例化spring容器 三.利用Spring容器创建javaBean对象 1,用构造器实例化 2,使用静态工厂方法实例化 3,实例工厂实例化 四,容器的IOC应用 4.1)Set注入 4.2)

Spring框架学习之IOC(一)

Spring框架学习之IOC 先前粗浅地学过Spring框架,但当时忙于考试及后期实习未将其记录,于是趁着最近还有几天的空闲时间,将其稍微整理一下,以备后期查看. Spring相关知识 spring是J2EE应用程序框架,是轻量级的IoC和AOP的容器框架,主要是针对javaBean的生命周期进行管理的轻量级容器.可单独使用,通常也与其他框架整合使用,例如SSH.SSM. IOC:控制反转 控制权由对象本身转向容器:由容器根据配置文件去创建实例并创建各个实例之间的依赖关系.等同于DI依赖注入 A

spring框架学习（一）

转自:http://blog.csdn.net/lishuangzhe7047/article/details/20740209 —————————————————————————————————————————————————— 1,什么是spring框架 spring是J2EE应用程序框架,是轻量级的IoC和AOP的容器框架,主要是针对javaBean的生命周期进行管理的轻量级容器,可以单独使用,也可以和Struts框架,ibatis框架等组合使用. 2,架构概述 1)IoC(Inversi

spring框架学习（二）依赖注入

转自:http://blog.csdn.net/lishuangzhe7047/article/details/20740835 ———————————————————————————————————————————— spring框架为我们提供了三种注入方式,分别是set注入,构造方法注入,接口注入.接口注入不作要求,下面介绍前两种方式. 1,set注入 采用属性的set方法进行初始化,就成为set注入. 1)给普通字符类型赋值. [java] view plaincopyprint? pub