Spring的AspectJ的AOP，基于注解(9.1)重点掌握

什么是AspectJ

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。
AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
新版本Spring框架，建议使用AspectJ方式来开发AOP

  • AspectJ表达式:

    • 语法:execution(表达式)
      execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
    • execution(“ cn.itcast.spring3.demo1.dao.(..)”) ---只检索当前包
    • execution(“ cn.itcast.spring3.demo1.dao..(..)”) ---检索包及当前包的子包.
    • execution( cn.itcast.dao.GenericDAO+.(..)) ---检索GenericDAO及子类
  • AspectJ增强:
        @Before 前置通知，相当于BeforeAdvice
        @AfterReturning 后置通知，相当于AfterReturningAdvice
        @Around 环绕通知，相当于MethodInterceptor
        @AfterThrowing抛出通知，相当于ThrowAdvice
        @After 最终final通知，不管是否异常，该通知都会执行
        @DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

基于注解

  • 第一步:引入相应jar包.

    • aspectj依赖aop环境.
    • spring-aspects-3.2.0.RELEASE.jar
    • com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
  • 第二步:编写被增强的类:
    • UserDao
package cn.spring3.demo1;
/**
 * @author NOP
 * 被代理的对象
 */
public class UserDao {
    public void add() {
        // TODO Auto-generated method stub
        System.out.println("添加客户");
    }
    public void delete() {
        // TODO Auto-generated method stub
        System.out.println("删除客户");
        int i=1/0;
    }
    public String find() {
        // TODO Auto-generated method stub
        System.out.println("查询客户");
        return "fanhuizhi";
    }
    public void update() {
        // TODO Auto-generated method stub
        System.out.println("修改客户");
    }
}
  • 第三步:使用AspectJ注解形式:
package cn.spring3.demo1;
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.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
 * @author NOP 切面类：就是切点与增强结合
 * 前置增强
 */
@Aspect
public class MyAspect {
    @Before(value = "execution(* cn.spring3.demo1.UserDao.add(..))")//这里写表达式，写哪些类需要添加
    public void before(JoinPoint joinpoint) {
        System.out.println("前置增强..."+joinpoint);
    }

    @AfterReturning(value = "execution(* cn.spring3.demo1.UserDao.find(..))",returning="returnVal")//这里写表达式，写哪些类需要添加
    public void afterReturning(Object returnVal){
        System.out.println("后置增强..."+"方法的返回值"+returnVal);
    }

    @Around(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕前增强...");
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("环绕后增强...");
        return obj;
    }

    @AfterThrowing(value = "execution(* cn.spring3.demo1.UserDao.delete(..))",throwing="ex")//这里写表达式，写哪些类需要添加
    public void afterThrowing(Throwable ex) throws Throwable{
        System.out.println("不跑了出异常了..."+ex.getMessage());
    }

    //@After(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
    @After("MyAspect.MyPointCut()")//类名.方法名
    public void after(){
        System.out.println("最终通知");//不管有没有异常都会通知
    }

    //仅是为了定义一个通用的表达式
    @Pointcut(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")
    private void MyPointCut(){
    }
}
  • 第四步:创建applicationContext.xml
 xmlns:aop="http://www.springframework.org/schema/aop"

* 引入aop的约束:
*<!-- 自动生成代理  底层就是AnnotationAwareAspectJautoProxyCreator -->
    <aop:aspectj-autoproxy/>

    <bean id="userDao" class="cn.spring3.demo1.UserDao"/>

    <bean id="MyAspect" class="cn.spring3.demo1.MyAspect"/>
  • 第五步，编写测试类
package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author NOP
 * 自动方式代理没有切点切面的增强
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;

    @Test
    public void demo1(){
        System.out.println("-----------------");
        userDao.add();
        System.out.println("-----------------");
        userDao.find();
        System.out.println("-----------------");
        userDao.delete();
        System.out.println("-----------------");
        userDao.update();
        System.out.println("-----------------");
    }
}
测试结果：
-----------------
前置增强...execution(void cn.spring3.demo1.UserDao.add())
添加客户
-----------------
查询客户
后置增强...方法的返回值fanhuizhi
-----------------
环绕前增强...
删除客户
最终通知
不跑了出异常了.../ by zero
  • AspectJ的通知类型:

    • @Before 前置通知，相当于BeforeAdvice

      • 就在方法之前执行.没有办法阻止目标方法执行的.
    • @AfterReturning 后置通知，相当于AfterReturningAdvice
      • 后置通知,获得方法返回值.
    • @Around 环绕通知，相当于MethodInterceptor
      • 在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.
    • @AfterThrowing抛出通知，相当于ThrowAdvice
    • @After 最终final通知，不管是否异常，该通知都会执行
    • @DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)
  • 切点的定义:
    • @Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")
      private void myPointcut(){}

面试:

  • Advisor和Aspect的区别?

    • Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.
    • Aspect:可以支持多个切点和多个通知的组合

基于XML

  • 第一步:编写被增强的类:

    • ProductDao
package cn.spring3.demo2;

public class ProductDao {

    public void add() {
        // TODO Auto-generated method stub
        System.out.println("添加商品");
    }

    public void delete() {
        // TODO Auto-generated method stub
        System.out.println("删除商品");

    }

    public void find() {
        // TODO Auto-generated method stub
        System.out.println("查询商品");
        int i = 1 / 0;
    }

    public String update() {
        // TODO Auto-generated method stub
        System.out.println("修改商品");
        return "woshitest";
    }

}
  • 第二步:定义切面
package cn.spring3.demo2;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * @author NOP
 * 切面类
 */
public class MyAspectXML {
    /*
     *
     */
    public void before(){
        System.out.println("前置增强");
    }

    public void afterReturning(Object returnVal){
        System.out.println("后置增强"+returnVal);
    }

    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕前增强");
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("环绕后增强");
        return obj;
    }

    public void afterThrowing(Throwable ex){
        System.out.println("不跑了出异常了..."+ex.getMessage());
    }

    public void after(){
        System.out.println("最终通知");//不管有没有异常都会通知
    }
}
  • 第三步:配置applicationContext.xml
<!-- 定义被增强的类 -->
    <bean id="productDao" class="cn.spring3.demo2.ProductDao"/>

    <!-- 定义切面 -->
    <bean id="myAspectXML" class="cn.spring3.demo2.MyAspectXML"/>

    <!-- 定义aop配置 -->
    <aop:config>
        <!-- 定义切点： -->
        <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

        <!-- 定义切点： -->
        <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.update(..))" id="mypointcutar"/>

        <!-- 定义切点： -->
        <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.delete(..))" id="mypointcutaar"/>

        <!-- 定义切点： -->
        <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.find(..))" id="mypointcutaat"/>

        <aop:aspect ref="myAspectXML">
            <!-- 前置通知-->
            <aop:before method="before" pointcut-ref="mypointcut"/> 

            <!-- 后置通知 -->
            <aop:after-returning method="afterReturning" pointcut-ref="mypointcutar" returning="returnVal"/>

            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="mypointcutaar"/>

            <!-- 异常通知 -->
            <aop:after-throwing method="afterThrowing" throwing="ex" pointcut-ref="mypointcutaat"/>

            <!-- 最终通知//不管有没有异常都会通知 -->
            <aop:after method="after"  pointcut-ref="mypointcutaat"/>
        </aop:aspect>
    </aop:config>
  • 第四步:编写测试类
package cn.spring3.demo2;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest2 {
    @Autowired
    @Qualifier("productDao")
    private ProductDao productDao;

    @Test
    public void demo1(){
        System.out.println("-----------------");
        productDao.add();
        System.out.println("-----------------");
        productDao.find();
        System.out.println("-----------------");
        productDao.delete();
        System.out.println("-----------------");
        productDao.update();
        System.out.println("-----------------");
    }
}

测试结果：
-----------------
前置增强
添加商品
-----------------
查询商品
不跑了出异常了.../ by zero
最终通知

原文地址：http://blog.51cto.com/4534309/2112449

时间： 2024-10-07 01:16:50

Spring的AspectJ的AOP，基于注解(9.1)重点掌握的相关文章

Spring AOP基于注解的“零配置”方式

Spring AOP基于注解的“零配置”方式: Spring的beans.xml中 <!-- 指定自动搜索Bean组件.自动搜索切面类 --> <context:component-scan base-package="org.crazyit.app.service,org.crazyit.app.aspect"> <context:include-filter type="annotation" expression="or

（转）Spring使用AspectJ进行AOP的开发：注解方式

http://blog.csdn.net/yerenyuan_pku/article/details/69790950 Spring使用AspectJ进行AOP的开发:注解方式 之前我已讲过Spring使用AspectJ通过配置文件的方式来进行AOP的开发,现在就来讲怎样使用注解方式进行AOP的开发. 创建一个Web项目, 引入相关的jar包.所要导入的jar包如下:  引入Spring的配置文件.主要引入AOP的约束: <?xml version="1.0" encoding=

Spring IoC 源码分析 (基于注解) 之 包扫描

在上篇文章Spring IoC 源码分析 (基于注解) 一我们分析到,我们通过AnnotationConfigApplicationContext类传入一个包路径启动Spring之后,会首先初始化包扫描的过滤规则.那我们今天就来看下包扫描的具体过程. 还是先看下面的代码: AnnotationConfigApplicationContext类 //该构造函数会自动扫描以给定的包及其子包下的所有类,并自动识别所有的Spring Bean,将其注册到容器中 public AnnotationConf

spring学习1：1.基于注解的bean

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org

Spring使用AspectJ开发AOP：基于Annotation

基于 Annotation 的声明式 在 Spring 中,尽管使用 XML 配置文件可以实现 AOP 开发,但是如果所有的相关的配置都集中在配置文件中,势必会导致 XML 配置文件过于臃肿,从而给维护和升级带来一定的困难. 为此,AspectJ 框架为 AOP 开发提供了另一种开发方式——基于 Annotation 的声明式.AspectJ 允许使用注解定义切面.切入点和增强处理,而 Spring 框架则可以识别并根据这些注解生成 AOP 代理. 关于 Annotation 注解的介绍如表 1

Spring AOP基于注解的“零配置”方式实现

为了在Spring中启动@AspectJ支持,需要在类加载路径下新增两个AspectJ库:aspectjweaver.jar和aspectjrt.jar.除此之外,Spring AOP还需要依赖一个aopalliance.jar包 定义一个类似ServiceAspect.java这样的切面bean: 1 package com.hyq.aop; 2 3 import org.apache.commons.logging.Log; 4 import org.apache.commons.loggi

Spring AOP基于注解的“零配置”方式---org.springframework.beans.factory.BeanNotOfRequiredTypeException

具体异常信息如下: 1 Exception in thread "main" org.springframework.beans.factory.BeanNotOfRequiredTypeException: Bean named 'hello' must be of type [com.hyq.chapter08_04_3.HelloImpl], but was actually of type [com.sun.proxy.$Proxy13] 2 at org.springfram

Spring Security 4 Hello World 基于注解 和 XML 例子（带源码）

下一篇: Spring Security 4 自定义登录表单 注解和XML例子 原文:http://websystique.com/spring-security/spring-security-4-hello-world-annotation-xml-example/ [已翻译文章,点击分类里面的spring security 4进行查看] [翻译by 明明如月 QQ 605283073] 本教程演示Spring MVC web项目中Spring Security 4的用法.通过url对访问进

Spring+SpringMVC+Mybatis 利用AOP自定义注解实现可配置日志快照记录

目的: 需要对一些事物的操作进行日志记录,如果在service内进行记录,大量的代码重复,并且维护比较麻烦.所以采用AOP的方式对service进行拦截.使用自定义注解的目的则是判断是否需要记录日志和传递额外的信息. 方式 本次解决方案十分感谢博主-跳刀的兔子的博文 本文绝大部分参考与本文,略有不同,所以做一些整理,博主的文章更详细一些. 1.首先新建自定义注解 @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @