欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Spring AspectJ AOP框架注解原理解析

程序员文章站 2022-06-23 14:32:33
什么是aspectjaspectj是一个面向切面的框架,它扩展了java语言。aspectj定义了aop语法所以它有一个专门的编译器用来生成遵守java字节编码规范的class文件。aspectj是一...

什么是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.springjunit4cla***unner;

/**
 * @author nop
 * 自动方式代理没有切点切面的增强
 */
@runwith(springjunit4cla***unner.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.springjunit4cla***unner;

@runwith(springjunit4cla***unner.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
最终通知

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。