AOP___基于aspectJ方式实现

最新推荐文章于 2022-07-02 20:22:20 发布
最新推荐文章于 2022-07-02 20:22:20 发布
阅读量300 收藏
点赞数
分类专栏： SpringFramework
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37432174/article/details/90577662
版权

AspectJ实现了AOP功能，使用方便，支持注解。Spring中也有AspectJ的方式实现AOP。在Spring中使用AOP开发时，一般使用AspectJ的实现方式

AspectJ的切点表达式：
execution(A, B, C, D, E);

[权限修饰符 可选]
A：方法返回类型
B：包名
C：类名
D：方法名
E：参数名
[异常类型 可选]

包名，类名，方法名要用.隔开，靠近()的方法名
execution(* com.target.ServiceImpl.*(…))

*：0至多个
… ：用于参数，表示多个；用于包名后，表示这个包以及它的子包们
+：用于类，表示这个类以及它的子类们；用于接口，表示这个接口以及接口的实现类们

Eg:
execution(public * (. .))
指定切入点为：任意公共方法。
execution( set (. .))
指定切入点为：任何一个以“set”开始的方法。
execution( com.xyz.service..(. .))
指定切入点为：定义在service包里的任意类的任意方法。
execution(* com.xyz.service. ..(. .))
指定切入点为：定义在service包或者子包里的任意类的任意方法。“…”出现在类名中时，
后面必须跟“”，表示包、子包下的所有类。
execution( .service..(. .))
指定只有一级包下的serivce子包下所有类(接口)中的所有方法为切入点
execution( . .service..*(. .))
指定所有包下的serivce子包下所有类(接口)中的所有方法为切入点

1、注解的形式
通知类：必须加上@Aspect
这里的 returning="msg"必须和方法里面的参数同名，因为它就是目标类（切点）所返回（return）的值，throwing="ex"是目标类（切点所抛的异常）

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.springframework.stereotype.Component;

@Component
@Aspect
public class MethodAdvice {
	@Before("execution(* com.service.*.*(..))")
	public void methodBefor() {
		// TODO Auto-generated method stub
		System.out.println("前置通知");
	}
	
	@AfterReturning(value="execution(* com.service.*.*(..))",returning="msg")
	public void methodAfterReturn(String msg) {
		// TODO Auto-generated method stub
		System.out.println("后置通知："+msg);
	}
	
	@Around(value="execution(* com.service.*.*(..))")
	public Object methodAround(ProceedingJoinPoint pjp) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("方法前...");
		Object proceed = pjp.proceed();
		System.out.println("方法后..."+proceed);
		return proceed;
	}
	
	@AfterThrowing(value="execution(* com.service.*.*(..))",throwing="ex")
	public void methodThrow(Exception ex) {
		// TODO Auto-generated method stub
		System.out.println("出现异常："+ex.getMessage());
	}
	
	@After("execution(* com.service.*.*(..))")
	public void after() {
		// TODO Auto-generated method stub
		System.out.println("最终通知...");
	}
}

目标类：（切点）

@Service
public class ServiceImpl implements IService{

	@Override
	public String say() {
		// TODO Auto-generated method stub
		return "SAY";
	}

	@Override
	public String sleep() {
		// TODO Auto-generated method stub
		return "SLEEP";
	}

}

applicationContext.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"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	
	<!-- 开启扫描 -->
	<context:component-scan base-package="com.advice,com.service"/>
	
 	<!-- 开启AOP注解 -->
	<aop:aspectj-autoproxy/>
		
</beans>

测试：

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.service.IService;

public class Test {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext applicationContext = 
				new ClassPathXmlApplicationContext("applicationContext.xml");

		IService bean = (IService) applicationContext.getBean("serviceImpl");
		System.out.println(bean.say());
		System.out.println(bean.sleep());
		
	}
}

2、xml配置的形式：
通知类：


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.springframework.stereotype.Component;

@Component
//@Aspect
public class MethodAdvice {
//	@Before("execution(* com.service.*.*(..))")
	public void methodBefor() {
		// TODO Auto-generated method stub
		System.out.println("前置通知");
	}
	
	/**
	 *这里的 returning="msg"必须和方法里面的参数同名，因为它就是目标类（切点）所返回（return）的值
	 * @param msg
	 */
//	@AfterReturning(value="execution(* com.service.*.*(..))",returning="msg")
	public void methodAfterReturn(String msg) {
		// TODO Auto-generated method stub
		System.out.println("后置通知："+msg);
	}
	
//	@Around(value="execution(* com.service.*.*(..))")
	public Object methodAround(ProceedingJoinPoint pjp) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("方法前...");
		Object proceed = pjp.proceed();
		System.out.println("方法后..."+proceed);
		return proceed;
	}
	
//	@AfterThrowing(value="execution(* com.service.*.*(..))",throwing="ex")
	public void methodThrow(Exception ex) {
		// TODO Auto-generated method stub
		System.out.println("出现异常："+ex.getMessage());
	}
	
//	@After("execution(* com.service.*.*(..))")
	public void after() {
		// TODO Auto-generated method stub
		System.out.println("最终通知...");
	}
}

目标类（切点）

@Service
public class ServiceImpl implements IService{

	@Override
	public String say() {
		// TODO Auto-generated method stub
		return "SAY";
	}

	@Override
	public String sleep() {
		// TODO Auto-generated method stub
		return "SLEEP";
	}

}

ApplicationContext.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"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	
	<!-- 开启扫描 -->
	<context:component-scan base-package="com.service,com.advice"/>
	
 	
	<aop:config>
	<!-- 切面 -->
		<aop:aspect ref="methodAdvice">
		<!-- 切点 -->
			<aop:pointcut expression="execution(* com.service.ServiceImpl.*(..))" id="myPointcut"/>
			<!-- 前置通知 -->
			<aop:before method="methodBefor" pointcut-ref="myPointcut"/>
			<!-- 后置通知 -->
			<aop:after-returning method="methodAfterReturn" pointcut-ref="myPointcut" returning="msg"/>
			<!-- 异常通知 -->
			<aop:after-throwing method="methodThrow" pointcut-ref="myPointcut" throwing="ex"/>
			<!-- 环绕通知 -->
			<aop:around method="methodAround" pointcut-ref="myPointcut"/>
			<!-- 最终通知 -->
			<aop:after method="after" pointcut-ref="myPointcut"/>
		</aop:aspect>
	</aop:config>
</beans>

测试：


public class Test {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext applicationContext = 
				new ClassPathXmlApplicationContext("applicationContext.xml");

		IService bean = (IService) applicationContext.getBean("serviceImpl");
		System.out.println(bean.say());
		System.out.println(bean.sleep());
		
	}
}
偷偷学习被我发现
关注
专栏目录
Spring 使用AspectJ 实现 AOP（基于xml文件、基于注解）
04-18
本教程将探讨如何在Spring中结合AspectJ实现AOP，包括基于XML配置和基于注解的方式。 **一、AOP基本概念** AOP的核心概念有切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）和引入...
aop.zip_884AOP_java aop原理_javaaop原理
09-21
Spring AOP提供了两种主要的实现方式：代理模式和AspectJ字节码增强。代理模式包括JDK动态代理和CGLIB代理。JDK动态代理适用于实现了接口的类，而CGLIB代理则可以在没有接口的情况下工作，通过字节码技术创建被代理...
基于@AspectJ注解的AOP实现
06-27 482
【例子】用户登录添加日志功能一、项目结构二、创建相关类User类package com.aop; public class User { private String userName; public User(){} public User(String userName) { super(); this.userName = userName; } public Strin...
Spring Aop（二）——基于Aspectj注解的Spring Aop简单实现
weixin_34077371的博客
09-27 203
2 基于Aspectj注解的Spring Aop简单实现 Spring Aop是基于Aop框架Aspectj实现的，它不是完完全全的对Aspectj框架进行扩展和改造，而是利用Aspectj里面的一些功能来实现自己的Aop框架，其中就包括对Aspectj提供的注解的解析。之前已经提过Spring Aop和Aspectj实现的Aop之间的差别，这...
基于AspectJ实现AOP操作
MrYushiwen的博客
12-26 951
前言：AspectJ 不是 Spring框架的组成部分，是独立的AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用进行 AOP 操作 一.AOP相关术语 比如某个类中有如下4个方法： Class A{ add(); delete(); update(); select(); } 1.连接点(JoinPoint) 类A中的4个方法都可能被增强，这4个方法成为连接点 2.切入点(PointCut) 如果我实际只增强 add()和update()方法，则add()和update()称为
使用aspectj实现AOP
gitcat的博客
02-18 616
aspectj是java语言的一个AOP实现，aspectj不一定要在spring中使用，单独也可以用，本文通过一个简单的例子来说明如果通过独立使用aspectj来实现aop，本文不会介绍aop的相关概念，只给出一个简单的例子。 1. 下载安装aspectj https://www.eclipse.org/aspectj/downloads.php 通过上面的网站下载aspectj的jar包，我下...
AspectJ对AOP的实现
职业炮灰的博客
05-06 4456
AspectJ对AOP的实现一、概述       对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可以完成面向切面编程。然而，AspectJ 也实现了 AOP 的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以，Spring 又将 AspectJ 的对于 AOP 的实现也引入到了自己的框架中。二、AspectJ的通知类型AspectJ中常用的通知类...
spring_AOP.rar_876.aop_java aop_spring_aop
09-14
3. AspectJ集成：Spring还支持完全基于AspectJ的AOP，提供了更强大的表达式语言和更灵活的切面定义。 在给定的压缩包文件中，我们可以看到以下几个子文件： 1. Spring_AOP_DynProxy：这可能包含有关Spring动态代理...
spring_aop_xml.rar_java aop_xml aop
09-20
在Spring框架中，AOP主要通过两种方式实现：一种是基于代理的，另一种是基于 AspectJ 的编译时或加载时织入。在XML配置中，我们通常使用基于代理的方式，这涉及到两种类型的代理：JDK动态代理和CGLIB代理。JDK代理...
spring-aop.rar_aop1270_spring_spring aop
09-23
3. `AspectJAutoProxyCreator`：基于AspectJ的自动代理创建器，根据配置的切面信息生成代理对象。 四、应用实践 在实际开发中，Spring AOP广泛应用于日志记录、事务管理、性能监控等方面。例如，可以通过声明式...
Spring框架笔记3 ---- AspectJ 对 AOP 的实现
GGood_Name的博客
07-02 224
a. AspectJ 中常用的通知有四种类型： b. AspectJ 的切入点表达式 c. 实现的步骤:
spring基于AspectJ实现AOP入门demo
hills的专栏
07-09 522
Spring基于AspectJ的简单AOP demo 1 demo的工程 1.1pom.xml引入spring和AspectJ的必要框架 　 <dependencies> <dependency> <groupId>org....
基于AspectJ实现Spring的AOP操作
Hiyiin的博客
05-17 206
什么是AspectJ AspectJ不是SPring的组成部分，是一个独立AOP框架，一般把AspectJ和Spring框架一起使用，进而进行AOP操作。 基于AspectJ实现AOP操作 基于XML配置文件实现 基于注解方式实现(方便，常用) 切入点表达式 切入点表达式作用：知道对哪个类里面的哪个方法进行增强。 语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称] [参数列表]) 举例1：对dao.BookDao类中的add方法进行增强 execution(
基于AspectJ的Spring-AOP
RailgunSmash的博客
06-28 125
什么是AOP： AOP是面向切面编程，是一种新的方法论，是对传统面向对象编程的补充。 AOP的主要变成对象是切面，而切面模块化横切还煮点。 在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类，这样一来横切关注点就被模块化到特殊的对象（切面）里 一些AOP相关的概念： 切面(Aspect)：横切关注点(跨越应用程序多个模块的功能...
基于AspectJ的注解AOP开发
。
07-30 285
AspectJ简介 环境搭建 使用AspectJ之前需要在pom.xml中引入Spring AOP和AspectJ的相关jar包  &lt;dependency&gt;       &lt;groupId&gt;aopalliance&lt;/groupId&gt;       &lt;artifactId&gt;aopalliance&lt;/artifactId&gt;      ...
基于@AspectJ的AOP的使用
zero的博客
10-03 281
基于@AspectJ的AOP的使用
基于AspectJ的注解和通知类型:
缥缈
02-14 552
第一步:引入相应jar包. * aspectj依赖aop环境. * spring-aspects-3.2.0.RELEASE.jar * com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar 第二步:编写被增强的类:InfoDao 第三步:使用AspectJ注解形式: @Aspect public class MyAspect ...
使用AspectJ实现AOP的两种方式
weixin_42453837的博客
01-06 3044
一、基于XML的声明式AspectJ 基于XML声明式AspectJ是指通过XML文件来定义切面、切入点及通知，所有的切面切入点通知都必须是定义在aop:config元素内。 1.配置切面 在Spring的哦欸之文件中，配置切面使用的是aop:aspect元素，该元素会将一个定义好事务Spring Bean转换成切面Bean，所以要在配置文件中先定义一个普通的Spring Bean。aop:asp...
AspectJ AOP是基于编译器的AOP实现方式
最新发布
05-17
是的，AspectJ AOP是基于编译器的AOP实现方式。它使用Java编译器和AspectJ编译器来将切面织入到Java字节码中，从而实现AOP的功能。相比于其他AOP实现方式，AspectJ AOP具有更高的性能和更广泛的应用场景，因为它可以在编译期就将切面织入到字节码中，避免了运行时的性能损失和一些限制。同时，AspectJ AOP也提供了丰富的语法和API，可以支持复杂的切面和各种AOP需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偷偷学习被我发现

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值