Spring_Spring与AOP_AspectJ基于注解的AOP实现

一、AspectJ、Spring与AOP的关系

AspectJ是一个面向切面的框架,它扩展了Java语言。AspectJ定义了AOP语法,所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。(百度百科)

Spring又将AspectJ的对于AOP的实现引入到自己的框架中。

在Spring中使用AOP开发时,一般使用AspectJ的实现方式。

二、AspectJ的通知类型

  1. 前置通知
  2. 后置通知
  3. 环绕通知
  4. 异常通知
  5. 最终通知

三、AspectJ的切入点表达式


表达式中加【】的部分表示可省略部分 ,个部分用空格分开。在其中可以使用以下符号:

execution(* * ..service.*.*(..))

指定所有包下的service子包下所有类(接口)中所有方法为切入点

execution(* *..ISomeService.*(..))

指定所有包下的ISomeService接口中所有方法为切入点

三、AspectJ的开发环境


导入2个Jar包

spring-framework-3.0.2.RELEASE-dependencies\org.aspectj\com.springsource.org.aspectj.weaver\1.6.8.RELEASE

四、AspectJ基于注解的AOP实现

1、前置通知

1 //主业务接口
2 public interface ISomeService {
3   //目标方法
4     void doFirst();
5     String doSecond();
6     void doThird();
7
8 }

ISomeService

 1 public class SomeServiceImpl implements ISomeService {
 2
 3     @Override
 4     public void doFirst() {
 5         // TODO Auto-generated method stub
 6         System.out.println("执行doFirst()方法");
 7     }
 8
 9     @Override
10     public String doSecond() {
11         // TODO Auto-generated method stub
12         System.out.println("执行doSecond()方法");
13         return "abcde";
14     }
15
16     @Override
17     public void doThird() {
18         // TODO Auto-generated method stub
19         System.out.println("执行doThird()方法");
20     }
21
22 }

SomeServiceImpl

 1 import org.aspectj.lang.JoinPoint;
 2 import org.aspectj.lang.annotation.Aspect;
 3 import org.aspectj.lang.annotation.Before;
 4
 5 @Aspect  //表示当前类为切面
 6 public class MyAspect {
 7    @Before("execution(* *..ISomeService.doFirst(..))")
 8    public void  before(){
 9        System.out.println("执行前置通知方法");
10    }
11
12    @Before("execution(* *..ISomeService.doFirst(..))")
13    public void  before(JoinPoint jp){
14        System.out.println("执行前置通知方法 jp="+jp);
15    }
16
17 }

MyAspect

 1 import org.junit.Test;
 2 import org.springframework.context.ApplicationContext;
 3 import org.springframework.context.support.ClassPathXmlApplicationContext;
 4
 5 public class MyTest {
 6
 7     @Test
 8     public void test01() {
 9         //创建容器对象
10         String resource = "com/bjpowernode/annotation/applicationContext.xml";
11         ApplicationContext ac=new ClassPathXmlApplicationContext(resource);
12
13         ISomeService service=(ISomeService) ac.getBean("someService");
14         service.doFirst();
15         System.out.println("--------------------");
16         service.doSecond();
17         System.out.println("--------------------");
18         service.doThird();
19     }
20
21 }

MyTest

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
 5         http://www.springframework.org/schema/beans
 6         http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://www.springframework.org/schema/aop
 8         http://www.springframework.org/schema/aop/spring-aop.xsd">
 9     <!-- 注册切面 -->
10     <bean id="myAspect" class="com.bjpowernode.annotation.MyAspect"></bean>
11
12      <!-- 注册目标对象 -->
13      <bean id="someService" class="com.bjpowernode.annotation.SomeServiceImpl"></bean>
14
15      <!--   注册AspectJ的自动代理 -->
16      <aop:aspectj-autoproxy/>
17 </beans>

ApplicationContext

输出:

执行前置通知方法
执行前置通知方法 jp=execution(void com.bjpowernode.annotation.ISomeService.doFirst())
执行doFirst()方法
--------------------
执行doSecond()方法
--------------------
执行doThird()方法

output

2.后置通知

 1   @AfterReturning("execution(* *..ISomeService.doSecond(..))")
 2    public void myAfterReturning(){
 3        System.out.println("执行后置通知方法");
 4
 5    }
 6
 7    @AfterReturning(value="execution(* *..ISomeService.doSecond(..))",returning="result")
 8    public void myAfterReturning(Object result){
 9        System.out.println("执行后置通知方法 result="+result);
10
11    }

MyAspect

3、环绕通知

1    @Around("execution(* *..ISomeService.doSecond(..))")
2    public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
3        System.out.println("执行环绕通知方法,目标方法执行之前");
4        //执行目标方法
5        Object result = pjp.proceed();
6        System.out.println("执行环绕通知方法,目标方法执行之后");
7     return result;
8
9    }

MyAspect

输出:

1 执行环绕通知方法,目标方法执行之前
2 执行doSecond()方法
3 执行环绕通知方法,目标方法执行之后

output

4、异常通知

1  @AfterThrowing("execution(* *..ISomeService.doThird(..))")
2    public void myAfterThrowing(){
3       System.out.println("执行异常通知方法");
4    }

MyAspect

1   @AfterThrowing(value="execution(* *..ISomeService.doThird(..))",throwing="ex")
2    public void myAfterThrowing(Exception ex){
3       System.out.println("执行异常通知方法ex="+ex.getMessage());
4    }

MyAspect

1 执行异常通知方法ex=/ by zero

output

5、最终通知

1  @After("execution(* *..ISomeService.doThird(..))")
2    public void myAfter(){
3       System.out.println("执行最终通知方法");
4    }

五、定义切入点

定义了一个切入点,叫doThirdPointcut()

1  @After("doThirdPointcut()")
2    public void myAfter(){
3       System.out.println("执行最终通知方法");
4    }
5    //定义了一个切入点,叫doThirdPointcut()
6    @Pointcut("execution(* *..ISomeService.doThird(..))")
7    public void doThirdPointcut(){}
8 }

原文地址:https://www.cnblogs.com/hoje/p/8471275.html

时间: 2024-10-11 16:51:03

Spring_Spring与AOP_AspectJ基于注解的AOP实现的相关文章

SPRING学习(十九)--基于注解的AOP切面编程

上篇中介绍了基于XML配置的AOP切面编程,除了XML配置AOP切面编程外,还可以通过注解方式实现AOP切面编程,本篇通过一个小例子来介绍基于注解的AOP编程. 1.在spring中使用AOP变成,不止要导入spring-aop.jar,还需要导入spring-aspects.jar.aspectjweaver.jar和aopalliance.jar,但是aspectjweaver.jar被spring-aspects.jar依赖,aopalliance.jar被spring-aop.jar依赖

Spring基础知识之基于注解的AOP

背景概念: 1)横切关注点:散布在应用中多处的功能称为横切关注点 2)通知(Advice):切面完成的工作.通知定了了切面是什么及何时调用. 5中可以应用的通知: 前置通知(Before):在目标方法被调用前调用通知功能. 后置通知(After):在目标方法完成后调用通知,此时不会关系方法输出什么. 返回通知(After-returning):在目标方法成功执行后调用通知. 异常通知(After-throwing):在目标方法抛出异常后调用通知. 环绕通知(Around):通知包裹了被通知的方法

AspectJ框架基于注解的AOP实现

AspectJ的AOP实现:有两种方式,一种是基于XML配置文件,一种是基于注解的,由于注解更为常用,这里 这里只针对注解来学习. -------------------------------------------------------------------------------------- 1 package com.sjl.aspectj.annotation; 2 3 import org.aspectj.lang.JoinPoint; 4 import org.aspectj

阶段3 2.Spring_08.面向切面编程 AOP_9 spring基于注解的AOP配置

复制依赖和改jar包方式 src下的都复制过来. 复制到新项目里了 bean.xml里面复制上面一行代码到下面.把aop改成context. 配置spring容器创建时要扫描的包 Service的配置这里就可以删除了 配置注解 使用@Service注解 开始AOP配置 把通知类交给Spring来管理 在Logger上加注解.之类注意,@Service和@Repository都不合适.因为logger属于三层 所以这里用@Component这个注解来配置 写完上面的@Component的注解后.b

Spring AspectJ基于注解的AOP实现

对于AOP这种编程思想,很多框架都进行了实现.Spring就是其中之一,可以完成面向切面编程.然而,AspectJ也实现了AOP的功能,且实现方式更为简捷,使用更加方便,而且还支持注解式开发.所以,Spring又将AspectJ对于AOP的实现也引入到了自己的框架中.     在Spring中使用AOP开发时,一般使用AspectJ的实现方式. Spring的经典AOP配置方案  01.使用的是Aspectj第三方框架,实现了AOP思想  02.注解配置的AOP  03.纯POJO <aop:c

Spring_Spring与IoC_基于注解的DI

一.基本注解的使用 (1)导入AOP的Jar包 (2) 与set()无关 二.组件扫描器的base-package 三.@Component相关注解 四.@Scope 五.域属性的注入 (1)byType (2)byName方式 byName方式的注解式注入,要求@Autowired和@Qualifier联合使用 六.域属性注解@Resource 七.Bean的生命始末 八.JavaConfig . 九.使用Spring的JUnit4测试 导入Jar包 十.XML的优先级别高于注解 原文地址:h

spring相关—AOP编程—数学计算器情景示例讲解(包含注解配置AOP与XML配置AOP)

1.数学计算器 ①数学计算器接口[MathCalculator]            public void add(int i,int j);     public int sub(int i,int j);     public int multi(int i,int j);     public void divide(int i,int j);    ②提供简单实现:加减乘除运算[EasyImpl]    ③在简单实现的基础上让每一个计算方法都能够打印日志[LoginImpl]    

Spring注解(AOP)

底层动态代理 程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式 导入aop的相关模块 <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId

基于注解的Spring AOP示例

基于注解的Spring AOP示例 目录 在XML配置文件中开启 @AspectJ 支持 声明切面及切入点 声明通知 测试 结语 在XML配置文件中开启 @AspectJ 支持 要使用Spring的AOP,首先要在 applicationContext.xml 配置文件中添加如下内容: <!-- 启动@Aspectj --> <aop:aspectj-autoproxy/> 声明切面及切入点 在Spring中, 切面 就是使用 @Aspect 注解的类.而 切入点 则由两部分组成: