Spring学习----AspectJ

最新推荐文章于 2024-04-18 04:01:53 发布
最新推荐文章于 2024-04-18 04:01:53 发布
阅读量333 收藏
点赞数
分类专栏： java WebFrame learning 文章标签： AspectJ spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21467113/article/details/91421402
版权
learning 同时被 3 个专栏收录
90 篇文章 2 订阅
订阅专栏
java
73 篇文章 0 订阅
订阅专栏
WebFrame
52 篇文章 0 订阅
订阅专栏

AspectJ介绍

           AspectJ是一个基于Java语言的AOP框架

           Spring2.0以后新增了对AspectJ切点表达式支持

           @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面。新版本Spring框架，建议使用AspectJ方式来开发AOP

           主要用途：自定义开发

            需导入的jar包：4个

  •        aop联盟规范
  •        spring aop 实现
  •        aspect 规范
  •        spring aspect 实现

切入点表达式【掌握】

                       1.execution()  用于描述方法 【掌握】

       语法：execution(修饰符  返回值  包.类.方法名(参数) throws异常)

              修饰符，一般省略
                     public            公共方法
                     *                   任意

              返回值，不能省略
                     void               返回没有值
                     String            返回值字符串
                     *                  任意
 
             包，[省略]
                     com.itheima.crm                 固定包
                     com.itheima.crm.*.service   crm包下面子包任意 （例如：com.itheima.crm.staff.service）
                     com.itheima.crm..               crm包下面的所有子包（含自己）
                     com.itheima.crm.*.service.. crm包下面任意子包，固定目录service，service目录任意包

              类，[省略]
                     UserServiceImpl                       指定类
                     *Impl                                 以Impl结尾
                     User*                                 以User开头
                     *                                        任意

              方法名，不能省略
                     addUser                              固定方法
                     add*                                   以add开头
                     *Do                                    以Do结尾
                     *                                        任意

              (参数)
                     ()                                        无参
                     (int)                                    一个整型
                     (int ,int)                              两个
                     (..)                                      参数任意
              throws ,可省略，一般不写。

综合1
       execution(* com.itheima.crm.*.service..*.*(..))
综合2
       <aop:pointcut expression="execution(* com.itheima.*WithCommit.*(..)) ||
                          execution(* com.itheima.*Service.*(..))" id="myPointCut"/>

 

                             2.within:匹配包或子包中的方法(了解)

                 within(com.itheima.aop..*)

                            3.this:匹配实现接口的代理对象中的方法(了解)

                 this(com.itheima.aop.user.UserDAO)

                           4.target:匹配实现接口的目标对象中的方法(了解)

                target(com.itheima.aop.user.UserDAO)

                           5.args:匹配参数格式符合标准的方法(了解)

                  args(int,int)

                           6.bean(id)  对指定的bean所有的方法(了解)

                bean('userServiceId')

 

AspectJ 通知类型

aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。

aspectj 通知类型，只定义类型名称。已经方法格式。

个数：6种，知道5种，掌握1中。

  •        before:前置通知(应用：各种校验)
                  在方法执行前执行，如果通知抛出异常，阻止方法运行
  •        afterReturning:后置通知(应用：常规数据处理)
                  方法正常返回后执行，如果方法中抛出异常，通知无法执行
                  必须在方法执行后才执行，所以可以获得方法的返回值。
  •        around:环绕通知(应用：十分强大，可以做任何事情)
                  方法执行前后分别执行，可以阻止方法的执行
                  必须手动执行目标方法
  •        afterThrowing:抛出异常通知(应用：包装异常信息)
                  方法抛出异常后执行，如果方法没有抛出异常，无法执行
  •        after:最终通知(应用：清理现场)
                  方法执行完毕后执行，无论方法中是否出现异常

环绕通知模拟：

环绕

try{
     //前置：before
    //手动执行目标方法
    //后置：afterRetruning
} catch(){
    //抛出异常 afterThrowing
} finally{
    //最终 after
}

 

基于xml

1.目标类：接口 + 实现

2.切面类：编写多个通知，采用aspectj 通知名称任意（方法名任意）

3.aop编程，将通知应用到目标类

4.测试

示例：切面类

/**
 * 切面类，含有多个通知
 */
public class MyAspect {
	
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}
	
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}
	
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}
	
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}
	
	public void myAfter(JoinPoint joinPoint){
		System.out.println("最终通知");
	}

}

            spring配置

<!-- 1 创建目标类 -->
	<bean id="userServiceId" class="com.itheima.d_aspect.a_xml.UserServiceImpl"></bean>
	<!-- 2 创建切面类（通知） -->
	<bean id="myAspectId" class="com.itheima.d_aspect.a_xml.MyAspect"></bean>
	<!-- 3 aop编程 
		<aop:aspect> 将切面类 声明“切面”，从而获得通知（方法）
			ref 切面类引用
		<aop:pointcut> 声明一个切入点，所有的通知都可以使用。
			expression 切入点表达式
			id 名称，用于其它通知引用
	-->
	<aop:config>
		<aop:aspect ref="myAspectId">
			<aop:pointcut expression="execution(* com.itheima.d_aspect.a_xml.UserServiceImpl.*(..))" id="myPointCut"/>
			
			<!-- 3.1 前置通知 
				<aop:before method="" pointcut="" pointcut-ref=""/>
					method : 通知，及方法名
					pointcut :切入点表达式，此表达式只能当前通知使用。
					pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
				通知方法格式：public void myBefore(JoinPoint joinPoint){
					参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等
				例如：
			<aop:before method="myBefore" pointcut-ref="myPointCut"/>
			-->
			
			<!-- 3.2后置通知  ,目标方法后执行，获得返回值
				<aop:after-returning method="" pointcut-ref="" returning=""/>
					returning 通知方法第二个参数的名称
				通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){
					参数1：连接点描述
					参数2：类型Object，参数名 returning="ret" 配置的
				例如：
			<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
			-->
			
			<!-- 3.3 环绕通知 
				<aop:around method="" pointcut-ref=""/>
				通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
					返回值类型：Object
					方法名：任意
					参数：org.aspectj.lang.ProceedingJoinPoint
					抛出异常
				执行目标方法：Object obj = joinPoint.proceed();
				例如：
			<aop:around method="myAround" pointcut-ref="myPointCut"/>
			-->
			<!-- 3.4 抛出异常
				<aop:after-throwing method="" pointcut-ref="" throwing=""/>
					throwing ：通知方法的第二个参数名称
				通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
					参数1：连接点描述对象
					参数2：获得异常信息，类型Throwable ，参数名由throwing="e" 配置
				例如：
			<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
			-->
			<!-- 3.5 最终通知 -->			
			<aop:after method="myAfter" pointcut-ref="myPointCut"/>
			
			
			
		</aop:aspect>
	</aop:config>

基于注解

       1.替换bean

<!-- 1 创建目标类 -->
	<bean id="userServiceId" class="com.itheima.d_aspect.b_anno.UserServiceImpl"></bean>
	<!-- 2 创建切面类（通知） -->
	<bean id="myAspectId" class="com.itheima.d_aspect.b_anno.MyAspect"></bean>

            注意：扫描

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       					   http://www.springframework.org/schema/beans/spring-beans.xsd
       					   http://www.springframework.org/schema/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context 
       					   http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 1.扫描 注解类 -->
	<context:component-scan base-package="com.itheima.d_aspect.b_anno"></context:component-scan>

        2.替换aop

             ① 必须进行aspectj 自动代理

<!-- 2.确定 aop注解生效 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

           ②声明切面

 <aop:aspect ref="myAspectId">

            ③替换前置通知

<aop:before method="myBefore" pointcut="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))"/>
	//切入点当前有效
	@Before("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}

        ④替换 公共切入点

<aop:pointcut expression="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" id="myPointCut"/>
//声明公共切入点
	@Pointcut("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
	private void myPointCut(){
	}

         ⑤替换后置

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
	@AfterReturning(value="myPointCut()" ,returning="ret")
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}

          ⑥替换环绕

<aop:around method="myAround" pointcut-ref="myPointCut"/>
@Around(value = "myPointCut()")
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}

           ⑦替换抛出异常

<aop:after-throwing method="myAfterThrowing" pointcut="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" throwing="e"/>
@AfterThrowing(value="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}

示例：切面类

/**
 * 切面类，含有多个通知
 */
@Component
@Aspect
public class MyAspect {
	
	//切入点当前有效
//	@Before("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}
	
	//声明公共切入点
	@Pointcut("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
	private void myPointCut(){
	}
	
//	@AfterReturning(value="myPointCut()" ,returning="ret")
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}
	
//	@Around(value = "myPointCut()")
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}
	
//	@AfterThrowing(value="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}
	
	@After("myPointCut()")
	public void myAfter(JoinPoint joinPoint){
		System.out.println("最终通知");
	}

}

             spring配置

<!-- 1.扫描 注解类 -->
	<context:component-scan base-package="com.itheima.d_aspect.b_anno"></context:component-scan>
	
	<!-- 2.确定 aop注解生效 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

           3.aop注解总结

@Aspect  声明切面，修饰切面类，从而获得 通知。

通知

  •        @Before 前置
  •        @AfterReturning 后置
  •        @Around 环绕
  •        @AfterThrowing 抛出异常
  •        @After 最终

切入点

       @PointCut ，修饰方法 private void xxx(){}  之后通过“方法名”获得切入点引用

 

 

 

 

 

 

 

 

 

 

 

 

 

没有刺的仙人掌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AspectJ 使用及原理
依生依世
08-01 5086
AspectJ 使用及原理一.简介二.原理三.使用(一)基本概念1.连接点(JoinPoint)2.切点(PointCut)3.插入逻辑(Advice)4.切面(Aspect)(二)类型匹配表达式1.注解2.修饰符3.返回值4.类5.方法名6.方法参数7.组合使用(三)切入点组合表达式1.call/execution2.this3.target4.within5.args6.注解支持7.组合使用8...
Spring AOP与AspectJ的对比及应用
woaimx_1314的博客
05-23 931
AOP，即面向切面编程是很常用的技术，特别是在Java Web开发中。而最流行的AOP框架分别是Spring AOP和AspectJ。AOP场景应用特别多，还是需要掌握的。代码请看GitHub:标签:Java。
面试官：Spring AOP、AspectJ、CGLIB 都是什么鬼？它们有什么关系？
最新发布
ling_y_u_n的博客
04-18 1962
与 AspectJ 相对的还有另外一种 AOP 框架，它不需要在编译时对目标类进行增强，而是运行时生成目标类的代理类，该代理类要么与目标类实现相同的接口，要么是目标类的子类——总之，代理类的实例可作为目标类的实例来使用。当启动了 @AspectJ 支持后，在 Spring 容器中配置一个带 @Aspect 注释的 Bean，Spring 将会自动识别该 Bean，并将该 Bean 作为方面 Bean 处理。但是与AspectJ的最大区别在于—Spring AOP的运行时增强，而AspectJ是编译时增强。
Spring AOP讲解（Pointcut、Before、Around、AfterReturning、After）
qq_28834355的博客
08-24 4935
AOP依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> @Pointcut 定义切入点，有以下2种方式： 方式一：设置为注解@LogFilter1标记的方法，有标记的方法触发该AOP，没有标记就没有。 @Aspect @C
Spring AOP 与 AspectJ
大鹏的博客
06-22 1126
目前注解成了应用 Spring 的首选方式。在 Spring AOP 中，Spring 又使用了 AspectJ 的注解，既然 Spring 单独提出一个 AOP 模块，那它为什么自己不提供一套注解？Spring AOP 和 AspectJ 又有何不同？本篇将尝试对这两者的区别与联系进行解释说明。
JAVA开发（AOP之ProceedingJoinPoint）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
01-12 6027
我们在开发过程中经常使用到自定义注解来实现在一些类或者方法执行过程中切面，统一实现某些业务操作。例如自定义注解
Spring aop 之 静态代理 动态代理 Aspectj aop-config 等实现方式
09-01
主要对Spring AOP的相关概念和简单的静态代理、动态代理以及常见的几种AOP配置方式做总结学习。主要包括：1. AOP的常见概念 2. 静态代理 3. jdk动态代理 4. Aspectj and Aspectjweaver 5. **aop-config** 6. CGLIB ...
spring-framework-2.5.1
06-16
- **ASPECTJ集成**：Spring 2.5.1引入了对AspectJ更深入的集成，增强了AOP功能。 3. **与其他技术的整合**： - **Hibernate**：Spring 2.5.1支持与Hibernate的无缝集成，提供声明式事务管理，使得事务处理更为...
spring-aop-annotation-log-all
07-28
这里zip压缩包囊括了学习Spring过程中用到的所有的jar包； 有： commons-logging-1.2.jar spring-beans-4.0.4.RELEASE.jar spring-context-4.0.4.RELEASE.jar spring-core-4.0.4.RELEASE.jar spring-expression-...
jar包---Spring Aop AspectJ新增包.rar
07-16
包含学习Spring AOP以及学习Spring Aspect J需要新增的jar包，需要的朋友可以下载哦！
Spring2.5-中文参考手册
10-14
通过阅读这份《Spring2.5-中文参考手册》，开发者可以深入理解Spring的核心机制，学习如何有效地利用其特性构建健壮、可维护的企业级应用。无论是初学者还是经验丰富的开发者，都能从中受益匪浅。
Java Spring 框架：（八）AspectJ
地球村
06-28 246
AspectJ 我们目前使用AOP的不足？ 我们目前使用的schema Baes 实现的方式，发现了每一个通知都需要实现对应的接口，每一个接口中就是一个方法，这样的书写方式比较的麻烦的，我们想所有的方法都在一个类中书写就比较方便了 Aspect J方式实现： Aspect J方式实现 我们发现 Aspect J的方式虽然可以把所有的通知都结合到一起，书写方便，但是获得切点中的参数和切点所在的类的时候比较的繁琐 两种方式的使用场景： schema base ：如果我们需要使用切点中的参数或者切点所在的
（Spring笔记）Spring的AspectJ基本概念
张松的博客
06-17 234
Spring的AspectJ基本概念
AspectJ 在 Spring 中的使用
weixin_34354173的博客
05-31 148
这是一篇纯实例的博客，网络上关于AspectJ的实例博客非常少，很多的博客都是在讲解AOP思想的一些概念以及从AspectJ语言本身出发去讲解AspectJ，但小编觉得作为急需在项目中使用，换句话说对于初学者来说，没有必要从AspectJ语言本身去深入了解它，如果对AOP思想不明白的，请参考我的博客一起来谈谈 Spring AOP！ 本文将从AspectJ在Spring中的应用入手讲解。 首先明白...
Spring使用AspectJ进行AOP开发（基于注解）
洛卡JAVA架构师每日分享Java架构师知识
05-18 625
在 Spring 中，虽然我们可以使用 XML 配置文件可以实现 AOP 开发，但如果所有的配置都集中在 XML 配置文件中，就势必会造成 XML 配置文件过于臃肿，从而给维护和升级带来一定困难。 为此，AspectJ 框架为 AOP 开发提供了一套 @AspectJ 注解。它允许我们直接在 Java 类中通过注解的方式对切面（Aspect）、切入点（Pointcut）和增强（Advice）进行定义，Spring 框架可以根据这些注解生成 AOP 代理。 关于注解的介绍如表 1 所示。 启用 @Aspec
Spring系列教程——13AspectJ讲解
qq_44932835的博客
07-27 2452
Spring系列教程——13AspectJ讲解
Spring入门第八讲——Spring的JDBC模板
李阿昀的博客
04-09 6162
Spring使用AspectJ进行AOP的开发：注解方式之前我已讲过Spring使用AspectJ通过配置文件的方式来进行AOP的开发，现在就来讲怎样使用注解方式进行AOP的开发。 创建一个Web项目， 引入相关的jar包。所要导入的jar包如下： 引入Spring的配置文件。主要引入AOP的约束：<?xml version="1.0" encoding="UTF-8"?> <beans xmlns
SpringAOP超详细教学
TheSevenSky
03-10 7947
SpringAOP 前言 我的这篇AOP博客有大量的图片和例子教会怎么使用AOP 配置那里如果没有学习Maven的话也别急 就是使用maven下载了jar包而已了 你完全可以自己手动导入 如果你有一些代码比如说 事务 或者 日志等操作 需要大量嵌入你的代码前后的话 那么无疑AOP是最好用的 AOP运行流程 : 首先调用前置通知(你可以认为最一开始初始的东西)-&amp;gt;你的逻辑代码(这里先不说环...
Spring AspectJ 框架配置详情
zgl1243094406的博客
07-13 1757
Aspect J 是一个基于Java语言的AOP框架使用Aspect J需要导入Spring AOP 和 Aspect J的相关jar包工程结构：相关类：StudentServiceI.javapackage com.baidu.beans2; public interface StudentServiceI { void delete(); String add(); }Stud...
Spring学习笔记-cqupt
03-19
Spring提供了ProxyFactoryBean和AspectJ等机制来实现AOP。我学会了如何配置切面和通知，将日志、事务等公共功能模块与具体的业务逻辑解耦。 此外，Spring还提供了面向Web开发的模块，例如Spring MVC。Spring MVC是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值