Spring：AOP面向切面的编程方式

最新推荐文章于 2024-04-13 15:33:11 发布
最新推荐文章于 2024-04-13 15:33:11 发布
阅读量437 收藏
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzc70919700/article/details/79981120
版权

    在Spring中面向切面编程有两种方式，分别是通过注解的方式和通过xml的方式，以下案例是在Spring3.x版本进行讲解。

一、execution函数

1.1、语法

    execution(<访问修饰符>?<方法的返回值类型><方法名>(<参数列表>)<异常>)

1.2、规则

规则表达式示例
匹配所有类的public方法execution(public **(..)) 
匹配指定包下所有类的方法（不包含子包）execution(* 包名.*(..))execution(* test.aop.t1.*(..))
匹配指定包下所有类的方法（包含子包）execution(* 包名.**(..))execution(* test.aop.t1..*(..))
匹配指定类下的所有方法execution(* 包名.类名.*(..))execution(* test.aop.t1.UserDao.*(..))
匹配指定类下的指定方法execution(* 包名.类名.方法名(..))execution(* test.aop.t1.UserDao.add(..))
匹配实现指定接口的所有类的方法execution(* 包名.接口名+*(..))execution(* test.aop.t1.UserDao+*(..))
匹配所有名称以save开头的方法execution(* save*(..)) 
二、使用注解的方式实现AOP

2.1、导入Spring的类库


2.2、创建业务功能类UserDao

package test.aop.t1;

public class UserDao {

	public void add() {
		System.out.println("添加用户");
	}
	
	public int update() {
		System.out.println("修改用户");
		return 1;
	}
	
	public void find() {
		System.out.println("查询用户");
//		System.out.println(10/0); //制造异常
	}
}

2.3、创建切面类

package test.aop.t1;

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 thinkpad
 *
 */
@Aspect
public class MyAspect {

	/**
	 * 前置通知
	 */
	@Before(value = "execution(* test.aop.t1.UserDao.add(..))")
	public void before() {
		System.out.println("前置增强...");
	}
	
	/**
	 * 后置通知，可以获得方法的返回值
	 */
	@AfterReturning(returning = "returnVal", value = "execution(* test.aop.t1.UserDao.update(..))")
	public  void afterReturning(Object returnVal){
		System.out.println("后置增强...方法的返回值" + returnVal);
	}
	
	/**
	 * 环绕通知，可以阻止目标方法执行
	 * @return 
	 * @throws Throwable 
	 */
	@Around(value = "MyAspect.myPointcut()")
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("环绕前增强...");
		Object obj = joinPoint.proceed(); //代表目标方法执行
		System.out.println("环绕后增强...");
		return obj;
	}
	
	/**
	 * 抛出异常通知
	 */
	@AfterThrowing(throwing="e", value = "MyAspect.myPointcut()")
	public void afterThrowing(Throwable e){
		System.out.println("不好了，出异常了....，异常信息："+e.getMessage());
	}
	
	/**
	 * 最终通知，不管是否异常，该通知都会执行
	 */
	@After(value = "MyAspect.myPointcut()")
	public void after(){
		System.out.println("总会执行");
	}
	
	/**
	 * 定义切点，目的是定义通用的execution表达式
	 */
	@Pointcut(value = "execution(* test.aop.t1.UserDao.find(..))")
	private void myPointcut() {
		
	}
}

2.4、配置切面

在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"
       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">

	<!-- 自动生成代理 -->
	<aop:aspectj-autoproxy/>
	
	<bean id="myAspect" class="test.aop.t1.MyAspect"/>

	<bean id="userDao" class="test.aop.t1.UserDao"/>
	
</beans>

2.5、测试

package test.aop.t1;

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

public class JTest {

	@Test
	public void test() {
		ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao dao = (UserDao) cxt.getBean("userDao");
//		dao.add();
//		dao.update();
		dao.find();
	}
}

2.6、运行结果


三、使用XML的方式实现AOP

3.1、Spring类库


3.2、创建业务功能类UserDao

package test.aop;

public class UserDao {

	public void add() {
		System.out.println("添加用户");
	}
	
	public int update() {
		System.out.println("修改用户");
		return 1;
	}
	
	public void find() {
		System.out.println("查询用户");
//		System.out.println(10/0); //制造异常
	}
}

3.3、创建切面类

package test.aop;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 切面类：就是切点与增强的结合
 * 
 * @author thinkpad
 *
 */
public class MyAspect {

	/**
	 * 前置通知
	 */
	public void before() {
		System.out.println("前置增强...");
	}
	
	/**
	 * 后置通知，可以获得方法的返回值
	 */
	public  void afterReturning(Object returnVal){
		System.out.println("后置增强...方法的返回值" + returnVal);
	}
	
	/**
	 * 环绕通知，可以阻止目标方法执行
	 * @return 
	 * @throws Throwable 
	 */
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("环绕前增强...");
		Object obj = joinPoint.proceed(); //代表目标方法执行
		System.out.println("环绕后增强...");
		return obj;
	}
	
	/**
	 * 抛出异常通知
	 */
	public void afterThrowing(Throwable e){
		System.out.println("不好了，出异常了....，异常信息："+e.getMessage());
	}
	
	/**
	 * 最终通知，不管是否异常，该通知都会执行
	 */
	public void after(){
		System.out.println("总会执行");
	}
	
}

3.4、在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"
       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">

	<bean id="userDao" class="test.aop.UserDao"/>

	<bean id="myAspect" class="test.aop.MyAspect"/>
	
	<aop:config>
		<!-- 定义切点 -->
		<aop:pointcut expression="execution(* test.aop.UserDao.add(..))" id="addPointcut"/>
		<aop:pointcut expression="execution(* test.aop.UserDao.update(..))" id="updatePointcut"/>
		<aop:pointcut expression="execution(* test.aop.UserDao.find(..))" id="findPointcut"/>
		<!-- 定义切面 -->
		<aop:aspect ref="myAspect">
			<aop:before method="before" pointcut-ref="addPointcut"/>
			<aop:after-returning method="afterReturning" returning="returnVal" pointcut-ref="updatePointcut"/>
			<aop:around method="around" pointcut-ref="findPointcut"/>
			<aop:after-throwing method="afterThrowing" throwing="e" pointcut-ref="findPointcut"/>
			<aop:after method="after" pointcut-ref="findPointcut"/>
		</aop:aspect>
	</aop:config>
	
</beans>

3.5、测试

package test.aop;

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

public class JTest {

	@Test
	public void test() {
		ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao dao = (UserDao) cxt.getBean("userDao");
//		dao.add();
//		dao.update();
		dao.find();
	}
}

3.6、运行结果


四、源代码

Spring通过注解实现AOP

Spring通过XML实现AOP


Java秦老师
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP
qq_45943290的博客
09-28 443
一、OOP和AOP OOP是一种面向对象的程序设计。“对象”在显式支持面向对象的语言中，一般指类在内存中装载的实例，具有相关的成员变量和成员函数（也称为方法）。我们通过抽象的方式把对象的共同特性总结出来构造类（共同模型），主要关系对象包含哪些属性及行为，但是不关心具体的细节，从而达到软件工程的要求：重用性、灵活性和扩展性。 AOP（面向切面编程）可以说是OOP的补充和完善。OOP通过引用封装、继承和多态性等概念来建立一种对象的层次结构，用于模拟公共行为的一种集合，但在需要为分散的对象引入公共行为时就显得无能
Spring的AOP面向切面编程
hanziang1996的博客
01-11 589
一、AOP的概述 AOP是基于反射与动态代理的实现，java有反射的中间层，让AOP的实现更加简单，而C++想实现相比会较为困难。 AOP为：(aspect oriented programming)，面向切面编程。是对OOP的补充，弥补OOP的不足。 作用：在不修改源码的前提下，给项目增加新的公共功能，如：权限，日志，事务（数据库中同时成功或同时失败的操作的集合）。 二、AOP的组成
SpringBoot中使用Aspect实现切面，超详细
热门推荐
DDDYSz的博客
03-09 2万+
Spring中的切面Aspect，这是Spring的一大优势。面向切面编程往往让我们的开发更加低耦合，也大大减少了代码量，同时呢让我们更专注于业务模块的开发，把那些与业务无关的东西提取出去，便于后期的维护和迭代。 相关的学习教程是看的动力节点的视频，然后整理了这篇博客作为笔记，方便以后复习时候看看，也分享给有需要的小伙伴。 视频资源：https://www.bilibili.com/video/BV1XQ4y1m7ex 相关概念 1. 切面（Aspect）： 首先要理解‘切’字，需要把对象想象成一
Java实例类中的切面_Spring进行面向切面编程的一个简单例子
weixin_39980353的博客
02-24 621
一、eclipse新建java项目取名SpringTest二、导入sping包到构建路径还需要aspectjweaver.jar三、创建java类(当然先要创建各种包)IHelloService.javapackagecom.zjptcc.wxw.spring.hello;publicinterfaceIHelloService{publicvoidsayHello();public...
spring中AOP切面的两种实现方式
weixin_45401493的博客
11-16 1770
AOP切面编程两种实现方式公共jar包2.方式一：配置bean切入2.1创建日志切面类2.2 配置日志切面类方式二 注解模式实现1.开启注解扫描2. 只配置日志切面类 两种实现方式 公共jar包 <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance --> <dependency> <gro...
Spring的aop在类中切入到另一个类中的方法
weixin_42325823的博客
03-12 1529
SPRING-AOP面向切面编程
FBDriftz的博客
06-25 165
     面向切面编程即抽取程序的公共方法放在一个类里面(这个类被称为通知)，然后在需要该方法的时候通过AOP将这个公共方法插入进来，既可以节省代码量，又不需要修改源码。        此处以插入log日志为例子演示AOP的插入配置和过程一、JAR包                    spring的四大核心包加aop和aspects包 另外需要2个日志包 1个aop 1个aspect。 一共1...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
16.2 Spring框架-AOP面向切面编程
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
Java Spring AOP 面向切面编程的4种实现
07-16
Spring AOP (面向切面编程框架): Spring框架内建了支持动态代理的功能，使用@AspectJ注解可以轻松地创建AOP代理。Spring AOP既支持JDK动态代理也支持CGLIB，会根据目标类是否实现了接口选择合适的底层技术。 Guice ...
Spring AOP 切入任意自定义方法的技巧 （不用 AspectJ)
Miozus Blog
02-10 1408
网上一大堆 Spring AOP 切面打日志的方法，笔者使用注解切入，不再赘述。 笔者在抽离 “同步更新缓存” 的切面时，遇到各种困难，最终实践找到一个比较简单的方法，来实现任意自定义方法的切入。 首先，AOP 的底层原理是动态代理，也就是 Spring 托管的 Bean 容器。至少具备以下条件： 它是个 Bean (创建Bean的六种方式)，一般 Bean 都是 public 修饰的（动态代理会忽视 private) 的方法。 那么，怎么达成条件呢？ 一、将它升级为新 Bean Service 接口
SpringAop实现切面
qq_39727896的博客
12-15 309
首先自定义注解@Login，后面在需要用到切面的方法上加上这个注解即可使用其功能。 package com.example.config; import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface L...
JavaEE简单示例——SpringAOP面向切面编程
hssjsh的博客
03-20 746
JavaEE简单示例——SpringAOP面向切面编程
Spring AOP——Spring 中面向切面编程
没有伞的孩子必须努力奔跑！—小林
03-23 237
一、AOP——另一种编程思想 1.1 什么是 AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 从《Spring实战（第4版）》图书中扒了一张图： 从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。 1.2 为什么需要 AOP 想象下面的场景，开发中在多个模块间有
详解Spring的AOP切面编程
2401_83412172的博客
04-13 802
千千万万要记得：多刷题！！多刷题！！之前算法是我的硬伤，后面硬啃了好长一段时间才补回来，算法才是程序员的灵魂！！！！篇幅有限，以下只能截图分享部分的资源！！（1）多线程（这里以多线程为代表，其实整理了一本JAVA核心架构笔记集）（2）刷的算法题（还有左神的算法笔记）（3）面经+真题解析+对应的相关笔记（很全面）（4）视频学习（部分）ps：当你觉得学不进或者累了的时候，视频是个不错的选择在这里，最后只一句话：祝大家offer拿到手软！！
Spring AOP(面向切面编程)
Fong灵
11-03 507
Spring AOP(面向切面编程)
基于微信小程序的付费自习室管理系统.zip
最新发布
08-19
基于微信小程序的付费自习室管理系统.zip
Spring AOP：面向切面编程详解与实战
CH03-AOP面向切面编程 本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值