Spring-Aop编程(三)-AspectJ

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量74 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/longlyseul/p/10023395.html
版权

AspectJ

1. 介绍

AspectJ是一个基于Java语言的AOP框架，Spring2.0以后新增了对AspectJ切点表达式支持，@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面，它是一种新版本Spring框架，建议使用AspectJ方式来开发AOP。主要用途：自定义开发

2.切入点表达式

　　为了能够灵活定义切入点位置，Spring AOP提供了多种切入点指示符。

execution———用来匹配执行方法的连接点

　　语法结构：   execution(   方法修饰符  方法返回值  方法所属类 匹配方法名 (  方法中的形参表 )  方法申明抛出的异常  )

　　其中红色字体的部分时不能省略的，各部分都支持通配符 “*” 来匹配全部。

　　比较特殊的为形参表部分，其支持两种通配符

  • 　　"*"：代表一个任意类型的参数；
  • 　　“..”：代表零个或多个任意类型的参数。

　　例如：

　　　　（）匹配一个无参方法

　　　　（..）匹配一个可接受任意数量参数和类型的方法

　　　　（*）匹配一个接受一个任意类型参数的方法

　　　　（*，Integer）匹配一个接受两个参数的方法，第一个可以为任意类型，第二个必须为Integer。

　　下面举一些execution的使用实例：

分类示例描述
通过方法签名定义切入点execution(public * * (..))匹配所有目标类的public方法，第一个*为返回类型，第二个*为方法名
execution(* save* (..))匹配所有目标类以save开头的方法，第一个*代表返回类型
execution(**product(*,String))匹配目标类所有以product结尾的方法，并且其方法的参数表第一个参数可为任意类型，第二个参数必须为String
通过类定义切入点execution(* aop_part.Demo1.service.*(..))匹配service接口及其实现子类中的所有方法
通过包定义切入点execution(* aop_part.*(..))匹配aop_part包下的所有类的所有方法，但不包括子包
execution(* aop_part..*(..))匹配aop_part包下的所有类的所有方法，包括子包。（当".."出现再类名中时，后面必须跟“*”,表示包、子孙包下的所有类）
execution(* aop_part..*.*service.find*(..))匹配aop_part包及其子包下的所有后缀名为service的类中，所有方法名必须以find为前缀的方法
通过方法形参定义切入点execution(*foo(String,int))匹配所有方法名为foo，且有两个参数，其中，第一个的类型为String，第二个的类型为int
execution(* foo(String,..))匹配所有方法名为foo，且至少含有一个参数，并且第一个参数为String的方法（后面可以有任意个类型不限的形参）

within————通过类匹配模式申明切入点（只能通过类型匹配连接点）

　　　　例如：within(aop_part..*)             表示匹配包aop_part以及子包的所有方法

　　　　由于execution可以匹配包、类、方法，而within只能匹配包、类，因此execution完全可以代替within的功能。

this————限定AOP代理必须时指定类型的实例，用于匹配该对象的所有连接点

　　　　例如：this(aop_part.service.GodService)        表示匹配了GodService接口的代理对象的所有连接点

target————通过判断目标类的类型确定判断的是否匹配

　　　　this通过判断代理类的类型来决定是否和切入点匹配，两者限定的对象都是指定类型的实例。

　　　　例如: target(aop_part.service.GodService)      表示匹配实现了GodService接口的目标对象的所有连接点

args————用于对连接点的参数类型进行限制，要求参数类型时指定类型的实例

　　　　例如：args(aop_part.service)                     表示匹配时，出入的参数类型时service的方法

　　　　其与execution(**(aop_part.service))的区别为，execution针对的时方法签名，而args针对的是运行时的实际参数类型。

　　　　args既匹配buyGoods(service newService)，也匹配buyGoods(Buyservice newService)   <Buyservice为service的子类>

　　　　execution只匹配buyGoods(service newService)

组合切入点

　　　　支持 &&、 || 、！

　　　　与其他语言所代表的意思相同

　　　　例：args(aop_part.service)  &&execution(**(aop_part.service))

3.AspectJ 通知类型

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

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

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

before:前置通知(应用：各种校验)在方法执行前执行，如果通知抛出异常，阻止方法运行

afterReturning:后置通知(应用：常规数据处理)方法正常返回后执行，如果方法中抛出异常，通知无法执行必须在方法执行后才执行，所以可以获得方法的返回值。

around:环绕通知(应用：十分强大，可以做任何事情)方法执行前后分别执行，可以阻止方法的执行必须手动执行目标方法

afterThrowing:抛出异常通知(应用：包装异常信息)方法抛出异常后执行，如果方法没有抛出异常，无法执行

after:最终通知(应用：清理现场) 方法执行完毕后执行，无论方法中是否出现异常

Spring Aop实例:

方式一 :注解配置 

UserService.java

package com.zk.b_annotation;

public interface UserService {
	
	public void addUser();
	public String updateUser();
	public void deleteUser();

}

UserServiceImpl.java

package com.zk.b_annotation;

import org.springframework.stereotype.Service;

@Service("userServiceId")
public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		System.out.println("d_aspect.b_anno addUser");
	}

	@Override
	public String updateUser() {
		System.out.println("d_aspect.b_anno updateUser");
		int i = 1/ 0;
		return "阳志就是";
	}

	@Override
	public void deleteUser() {
		
		System.out.println("d_aspect.b_anno deleteUser");
	}
}

　　

切面

MyAspect.java

package com.zk.b_annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 切面类，含有多个通知
 */
@Component
@Aspect
public class MyAspect {
	
	//前置通知
//	@Before("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
        @Before("myPointCut()")
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知" + joinPoint.getSignature().getName());
	}
	
	//声明公共切入点
	@Pointcut("execution(* com.zk.b_annotation.UserServiceImpl.*(..))")
	private void myPointCut(){
	}
	
//	@AfterReturning(value="myPointCut()" ,returning="ret")        
        @AfterReturning("myPointCut()")
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知" + joinPoint.getSignature().getName() + " , -->" + ret);
	}
	
//	@Around(value = "myPointCut()")
        @Around("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")
        @AfterThrowing("myPointCut()")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知" + e.getMessage());
	}
	
	@After("myPointCut()")
	public void myAfter(JoinPoint joinPoint){
		System.out.println("后置通知");
	}

}

　　

beans.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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.zk.b_annotation"></context:component-scan>
	
	<!-- 2.确定 aop注解生效 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

　　

TestAspectAnno.java

package com.zk.b_annotation;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAspectAnno {
	
	@Test
	public void demo01(){
		String xmlPath = "com/zk/b_annotation/beans.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		
		//获得目标bean
		UserService userService = (UserService) applicationContext.getBean("userServiceId");
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}

}

　　

运行效果图:

方式二:xml配置 

UserService.java

package com.itheima.d_aspect.a_xml;

public interface UserService {
	
	public void addUser();
	public String updateUser();
	public void deleteUser();

}

　

UserServiceImpl.java

package com.itheima.d_aspect.a_xml;

public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		System.out.println("d_aspect.a_xml addUser");
	}

	@Override
	public String updateUser() {
		System.out.println("d_aspect.a_xml updateUser");
		int i = 1/ 0;
		return "阳志就是屌";
	}

	@Override
	public void deleteUser() {
		
		System.out.println("d_aspect.a_xml deleteUser");
	}

}

　　

MyAspect.java

package com.itheima.d_aspect.a_xml;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 切面类，含有多个通知
 */
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("最终通知");
	}

}

　　

TestAspectXml.java

package com.itheima.d_aspect.a_xml;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAspectXml {
	
	@Test
	public void demo01(){
		String xmlPath = "com/itheima/d_aspect/a_xml/beans.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		
		//获得目标类
		UserService userService = (UserService) applicationContext.getBean("userServiceId");
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}

}

　　

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">
	<!-- 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>
</beans>

　　

运行效果:

 

 

 

转载于:https://www.cnblogs.com/longlyseul/p/10023395.html

datai3890
关注
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1114
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
spring-aop-jar
12-14
总结起来，"spring-aop-jar"涉及了Spring框架中的面向切面编程模块，包括Spring AOP和AspectJ的集成。通过理解和熟练使用这些组件，开发者可以有效地解耦关注点，提高代码的可维护性和可扩展性。在实际项目中，结合...
错误: 找不到或无法加载主类 com.test.TestIOC
米二DeFans
09-02 5564
报这个错的原因主要是类没有编译成功 这里，我说下我报这个错的原因，大家可以参考 大家可以看下项目的classpath(类输出路径)在testSpring/bin 然后我这个目录确实是没有文件，大家看下面的图 最后我找到了我报这个错误的原因 原来是我加了spring的.libd和一个.txt文件导致不能构建了，这里，我们选中.libd,.txt文件，remove掉就好了 ...
Spring --- AOP 操作 - AspectJ注解
yuanchenglong的博客
08-03 574
其实，面向切面编程，简单地理解就是为了降低代码耦合度，减少重复代码量，增加系统灵活性而采用的一种编程规范。
Spring——AOP面向切面编程&SpringAOP与AspectJ比较
娜娜米的博客
07-09 975
​最近跟着源码研究了下Spring使用三级缓存处理循环依赖的原理，里面涉及到Spring AOP的概念；本篇介绍AOP相关的知识点，AOP下的概念名词比较多，尽量使用通俗的概念来逐个解释，内容包括：对AOP（面向切面编程）的理解、AOP下的名词概念、Spring AOP与AspectJ的比较等；这部分知识对于学习Spring框架或者面试，都非常重要，需要掌握； ​...
Spring之Spring AOP与AspectJ
fishyu
10-16 656
在日常开发中，我们经常用到切面，比如在springboot搭建的服务里，经常使用日志切面来记录客户端的访问日志。 我用一个小的demo演示 项目结构如下 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi...
Spring-AOP 使用@AspectJ
热门推荐
小工匠
08-24 1万+
概述 准备工作 实例 通过编码的方式使用AspectJ切面 通过配置的方式使用AspectJ切面 自动生成代理的方式 基于Schema的aop命名空间配置的方式概述我们之前一个系列的文章，分别使用Pointcut和Advice接口描述切点和增强，并用Advisor整合二者描述切面，@AspectJ则采用注解来描述切点、增强，二者只是表述方式不同，描述内容的本质是完全相同的。 准备工作 在使用@Asp
Spring-AOP面相切面编程示例（有详细注释）
m0_61160520的博客
03-19 908
Spring IOC面向切面编程获取通知细节信息，切点表达式语法，重用(提取)切点表达式，环绕通知，切面优先级设置。
三、Spring-AOP
D_A_I_H_A_O的博客
04-29 1054
AOP AOP：Aspect Oriented Programming 面向切面编程 AOP最早是AOP联盟组织提出的，指定的一套规范。 AOP通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类，而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。 AOP框架是Spring的一个重要组成部分。但是Spring IOC容器并不依赖于AOP，这意味着你有权利选择是否使用AOP，AOP做为Spring IOC容器的一个补
Spring AOP以及AspectJ
啦啦啦小骑士的博客
01-11 470
一、
原生AspectJ用法分析以及Spring-AOP原理分析
【欢迎关注公众号：冬瓜白】
03-17 1727
前言 前两天看了一些关于spring aop以及AspectJ的文章，但是总是感觉非常的乱，有的说spring aop跟aspectj相互独立，有的说spring aop依赖于aspectj，有的甚至直接把两者混为一谈。很多专门讲Aspectj的文章也只是搬运了AspectJ的语法，就那么一两点东西，讲来讲去也没有什么新意。甚至很多甚至都是面向IDE编程(教你怎么安装插件，点击菜单)，对AspectJ的使用方式和工作原理都不去分析，离开了IDE的支持甚至连编译都不会了。我认为咱们这些码农平时习惯用IDE并
spring-aop-aspectj-case
08-06
标题“spring-aop-aspectj-case”涉及到的是Spring框架中的AOP（面向切面编程）与AspectJ的集成使用案例。在Spring框架中，AOP用于处理系统中的横切关注点，如日志、事务管理等，而AspectJ则是一个强大的、独立的...
spring-aop-training-with-aspectj
05-25
本教程将深入探讨如何在Spring中结合AspectJ进行AOP编程。 首先，让我们了解核心概念： 1. **切面（Aspect）**：切面是关注点的模块化，比如日志、事务管理等。在@AspectJ中，切面由一个包含通知（advisors）和...
spring-aop-aspectj(Schema)-case
08-06
标题 "spring-aop-aspectj(Schema)-case" 指涉的是Spring AOP（面向切面编程）中使用AspectJ的Schema配置方式的一个案例。Spring AOP是Spring框架的一部分，它允许我们在不修改源代码的情况下，通过"切面"来实现对...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 136
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 814
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 873
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 252
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 412
函数式接口与回调函数
spring-boot-starter-aop
03-16
这是一个Spring Boot应用程序，可以帮助您实现面向方面编程（AOP）。spring-boot-starter-aop是一个Spring Boot starter，它提供了对面向切面编程（AOP）的支持。AOP是一种编程范式，它允许开发人员将横切关注点（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值