初学Spring——Spring内核之AOP（面向切面编程）

最新推荐文章于 2022-07-13 10:20:37 发布
最新推荐文章于 2022-07-13 10:20:37 发布
阅读量458 收藏
点赞数
分类专栏： # spring 文章标签： spring java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongzi_yu/article/details/104579970
版权

文章目录


AOP的全称是：Aspect Oriented Programming，也就是面向切面的编程（也叫面向方面的编程）。它是面向对象编程的（OOP）一种补充。OOP采取的是纵向的代码机制，所以只能实现父子关系的代码重用；而AOP是横向的代码机制，采取的是切入的方式执行代码。AOP是对OOP的一种补充，但并不是OOP的替代品。

怎么理解AOP呢？

在这里插入图片描述
这些执行的通用的内容可以是记录日志、开启事务。

JDK实现代理

jdk代理必须要实现InvocationHandler接口
package com.dz.aop_jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 代理类：LogHandler；实现InvocationHandler接口
 *
 */
public class LogHandler implements InvocationHandler {

	private Object targetObject; // 目标对象，或者是被代理类

	/**
	 * 生成被代理类的对象
	 * 
	 * @param targetObject
	 * @return
	 */
	public Object creatProxy(Object targetObject) {
		this.targetObject = targetObject;
		/*
		 * 创建一个被代理类 （参数 详情） -获取被代理类的类加载器 -获取被代理类的接口 -使用当前的代理类this来执行被代理的类
		 */
		return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),
				this.targetObject.getClass().getInterfaces(), this);
	}

	/**
	 * 代理类执行的方法
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object result =null;
		try {
			//伪代码，这就是在执行方法之前横向切入的执行内容
			System.out.println("准备~~开始记录日志...");
			result = method.invoke(this.targetObject, args);//执行被代理类的方法
			//伪代码：这是在方法执行之后横向切入的内容
			System.out.println("日志记录完毕...");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
}
创建被代理类UserDao.java

被代理的类必须要提供接口

package com.dz.aop_jdk;

public interface UserDao {	
	// 假装添加一个用户
	void addUser();
}

实现接口

package com.dz.aop_jdk;

public class UserDaoImpl implements UserDao{

	@Override
	public void addUser() {
		//伪代码
		System.out.println("执行一个添加用户的操作...");
	}
}
测试代理类
package com.dz.aop_jdk;

public class TestProxy {

	public static void main(String[] args) {
		UserDao userDao = new UserDaoImpl();
		
		LogHandler log=new LogHandler();
		//根据被代理的对象，生成代理的对象--根据指定的接口返回对象
		UserDao proxyUser = (UserDao) log.creatProxy(userDao);
		//让代理对象来执行方法
		proxyUser.addUser(); 
	}
}
jdk实现代理结果

在这里插入图片描述

SpringAOP的实现

流行的AOP框架目前有两个：SpringAOP和AspectJ。后来，从Spring2.0开始SpringAOP引入了对AspectJ的支持。并且SpringAOP建议使用AspectJ开发AOP。
开始AOP的配置之前，先来认识一下AOP中的一些术语：

  1. Aspect：切面。代理类就是切面。
  2. JoinPoint：连接点。方法的调用。
  3. PointCut：切入点。切面与程序流程的交叉点（比如执行到某一个类或者方法开始切入，这个切入的点就叫切入点）。
  4. Advince：通知。切入点处要执行的代码，可以理解为切面类中的方法。
  5. Target Object：目标对象。指被通知的对象，也就是被代理的对象。
  6. Proxy：代理。被动态创建的对象。
  7. Weaving：织入。将切面的代码插入到目标对象上。

通知又分为几个类型，下面在代码里面可以看到通知的类型。（也就是这个通知在方法的什么位置执行）。

xml配置方式实现SpringAOP

定义一个切面

package com.dz.aop_spring;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 
 * 配置一个切面类
 */
public class AspectXML {

	public void beforeAdvice() {
		System.out.println("前置通知..执行的方法，比如说：开启事务？？？");
	}

	public void afterAdvice() {
		System.out.println("最终通知..执行的方法，比如说：关闭事务？？");
	}

	public void afterReturnAdvice() {
		System.out.println("后置通知");
	}

	public void afterThrowingAdvice() {
		System.out.println("异常通知");
	}

	public Object aroundAdvice(ProceedingJoinPoint pjp) {
		
		Object object = null;
		try {
			System.out.println("环绕通知开始...");
			object = pjp.proceed();// 执行切点，切中的方法
			System.out.println("环绕通知结束...");
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return object;
	}
}

定义切点切入的类

package com.dz.aop_spring;

public interface UserService {
	
	public void insertUser();

}


package com.dz.aop_spring;

public class UserServiceImpl implements UserService {
	
	//假装插入一条数据
	@Override
	public void insertUser() {
		System.out.println("执行一个插入用户的操作");
	}

}

配置切面

<?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-4.0.xsd 
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd ">

	<bean id="userService" class="com.dz.aop_spring.UserServiceImpl"></bean>
	<!--配置切面 -->
	<bean id="aspectXmL" class="com.dz.aop_spring.AspectXML"></bean>
	<!-- 配置切面 -->
	<aop:config>
		<aop:aspect id="myAspect" ref="aspectXmL">
			<!-- 配置切入点 ：根据表达式找切入点，满足切入点执行通知-->
			<aop:pointcut
				expression="execution(* com.dz.aop_spring.*.*(..))" id="myCut" />
			<!-- 根据切入点，执行一些类型的通知方法 -->
			<aop:before method="beforeAdvice" pointcut-ref="myCut" />
			<aop:after method="afterAdvice"  pointcut-ref="myCut"/>
			<aop:after-returning method="afterReturnAdvice" pointcut-ref="myCut" />
			<aop:after-throwing method="afterThrowingAdvice" pointcut-ref="myCut" />
			<aop:around method="aroundAdvice"  pointcut-ref="myCut"/>
		</aop:aspect>
	</aop:config>

</beans>

测试类

package com.dz.aop_spring;

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

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		//满足切入点的类，和类下面所有的方法
		UserService userService = ac.getBean("userService", UserService.class);
		userService.insertUser();
	}
}

结果
在这里插入图片描述
异常通知在方法出现异常的时候才会执行。

注解配置SpringAOP

注解配置AOP也是要声明切面的！！！

package com.dz.aop_anno;

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

/**
 * 
 * 配置一个切面类
 */
@Aspect // 注解声明切面
//@Component  //注解声明需要一个扫描
public class AspectAnno {
	// 定义切入点：任何返回类型，aop_anno包下的任何类下的任何方法包括任意参数都满足切入点
	@Pointcut("execution(* com.dz.aop_anno.*.*(..))")
	public void pointCut() {
	}

	//这里也可以直接将表达式放进去
	@Before(value = "execution(* com.dz.aop_anno.*.*(..))")
	//@Before("pointCut()") // 根据切点切入通知
	public void beforeAdvice() {
		System.out.println("注解：前置通知..执行的方法，比如说：开启事务？？？");
	}

	@After("pointCut()")
	public void afterAdvice() {
		System.out.println("最终通知..执行的方法，比如说：关闭事务？？");
	}

	@AfterReturning("pointCut()")
	public void afterReturnAdvice() {
		System.out.println("后置通知");
	}

	@AfterThrowing("pointCut()")
	public void afterThrowingAdvice() {
		System.out.println("异常通知");
	}

	@Around("pointCut()")
	public Object aroundAdvice(ProceedingJoinPoint pjp) {

		Object object = null;
		try {
			System.out.println("环绕通知开始...");
			object = pjp.proceed();// 执行切点，切中的方法
			System.out.println("环绕通知结束...");
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return object;
	}
}

定义一个UserService.java接口

package com.dz.aop_anno;

public interface UserService {
	
	public void updatetUser();

}

并实现它

package com.dz.aop_anno;

public class UserServiceImpl implements UserService {
	
	//假装修改一条数据
	@Override
	public void updatetUser() {
		System.out.println("执行一个修改用户的操作");
	}

}

配置文件开启注解

<?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-4.0.xsd 
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/context ">

	<!-- 这里没有使用扫描，而是直接装配的bean -->
	<bean id="userService" class="com.dz.aop_anno.UserServiceImpl"></bean>
	<bean id="aspectAnno" class="com.dz.aop_anno.AspectAnno"></bean>
	
	<!--启动注解配置切入方式  -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

测试注解配置的AOP

package com.dz.aop_anno;

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


public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService userService = (UserService) ac.getBean("userService");
		userService.updatetUser();
	}
}

结果
注解配置结果

咦？？？仔细对比了两张结果图发现不一样？

总结

  • 两张结果图可以看出：

基于XML与注解的方式执行的结果是相同的，只是目标方法前后的通知顺序发生了改变。

  • 需要注意的是：

如果同一个连接点有多个通知执行，那么前置通知与环绕通知的执行顺序未知，后置通知与环绕通知的执行顺序未知。

  • xml配置与注解配置的相同之处

无论使用的哪种方法的配置，都需要定义：切面、切点、通知。（除非有人帮你定义好了，你只需要引用。比如：事务管理。）

附上我的目录结构
在这里插入图片描述
依赖

在这里插入图片描述

Spring入门
行者无疆的博客
03-19 1925
1 Spring 简介 1.1 Spring 概述 官网定义： Spring 框架为任何类型的部署平台上的基于 Java 的现代企业应用程序提供了全面的编程和配置模型。 Spring 的一个关键元素是在应用程序级别的基础架构支持：Spring 专注于企业应用程序的 “管道”，以便团队可以专注于应用程序级别的业务逻辑，而不必与特定的部署环境建立不必要的联系。 慕课解释： 简单来说：Spring 是一个免费开源框架，为了简化企业级项目开发，提供全面的开发部署解决方案。 1.2 Spring 的体系结构 结构图
零基础开始Spring（一）--------适合java小白的Spring基础
qq_42357261的博客
10-18 886
Spring从绫开始（一）--------Spring基础（这将是你所看到最详细的文章） SpringSpring从绫开始（一）--------Spring基础（这将是你所看到最详细的文章）1.什么是Spring1.1为什么要学习Spring1.2Spring可以用来干嘛2. Spring搭建基础2.1 MySQL数据库2.2 IDE工具 1.什么是Spring 如果你去买一本Spring的书或者去看其他人的博客，他会告诉你Spring是**分层的**Java SE/EE应用的**一站式轻量级**开源框架
【第六章】 AOP 之 6.7 通知顺序 ——跟我学spring3
luckykapok918的专栏
01-08 417
如果我们有多个通知想要在同一连接点执行，那执行顺序如何确定呢？Spring AOP使用AspectJ的优先级规则来确定通知执行顺序。总共有两种情况：同一切面中通知执行顺序、不同切面中的通知执行顺序。        首先让我们看下   1） 同一切面中通知执行顺序：如图6-6所示。   图6-6 同一切面中的通知执行顺序 而如果在同一切面中定义两个相同类型通知（如
SpringAOP复习
此心安处
09-25 3680
作业1 一.单选题 1、以下不属于ProxyFactoryBean类中的常用可配置属性的是（）。 A、target B、proxyInterfaces C、targetClass D、interceptorNames 答案：C 2、以下哪种类型不是Spring中的通知类型（）。 A、异常通知 B、前置通知 C、后置通知 D、最终通知 答案：D 答案解析： 3关于AspectJ注解的介绍，说法错误的是（）。 A、@Aspect用于定义一个切面 B、@Pointcut用于定义切入点表达式 C、@Before用于
代理模式和切面简介
专注编程和人工智能！
07-10 831
代理设计模式： java里常用的设计模式 特点： 1.具体类和代理类有相同的接口或者共同的父类 2.代理类为具体类负责消息的处理，并将消息转发给具体类 3.代理类本身并不是真正的实现者，而是通过调研具体类的方法来实现的 2.按照代理类创建的时机，分两类： 1.静态代理： 是有我们程序员或者是特定的工具生成的 ...
SpringAop入门
熊二吃屁的博客
09-10 221
Aop面向切面编程，在方法执行的前中后等加入指定的操作。底层动态代理 代码 MyCalculator方法类 public class MyCalculator { public int div(int i,int j){ return i/j; } } 切面类AspectJ @Aspect public class AspectJTest { // 切入点表达式 @Pointcut("execution(public int com.spirng.aop.My
代理模式和切面切点
New__Dream的博客
10-21 557
代理模式 一.静态代理 代理模式需要创建一个代理对象，一个目标对象，通过代理对象调用目标对象，实现我们需要实现的功能，代码如下： public interface Ticket { void buyTicket(); } /** * 12306 直接购买 */ public class By12306TicketImpl implements Ticket{ @Override public void buyTicket() { System.ou
spring_MVC中文教程pdf
06-03
Spring框架以轻量级控制反转（IoC）和面向切面编程（AOP）为内核，提供了展现层Spring MVC和持久层Spring JDBC等多种技术的整合方案。 2. Spring的设计思想： Spring框架的设计思想来自于Rod Johnson的实用主义设计...
深入理解Spring核心原理：JSP科研管理系统教程
- AOP（面向切面编程）：AOP允许开发者将横切关注点（例如日志、事务管理等）从业务逻辑代码中分离出来，通过预编译方式和运行期动态代理实现程序的统一维护。 - Bean生命周期：Spring容器管理Bean的整个生命周期，...
Spring与LOG4J日志记录教程适合初学者
Spring是一个开源的轻量级Java平台，它以控制反转（IoC）和面向切面编程（AOP）为内核，提供了声明式事务管理、远程访问、数据访问及Web MVC框架等多层次的服务。Spring的核心特性之一是通过依赖注入来降低组件之间...
Spring学习(二)---代理模式/AOP面向切面编程
DOGIOOH的博客
08-24 421
Spring学习(二)—代理模式/AOP面向切面编程 01 代理模式 在学习AOP之前，我们需要先学习代理模式，因为AOP的底层机制就是基于动态代理实现的。 什么是代理模式？代理模式是7种结构设计模式之一，其目的是提供一个代理对象，以控制客户对某个被代理的真实对象(委托类)的直接访问。 通常，代理类负责为被代理的真实对象预处理消息，过滤消息并转发消息，以及消息被真实对象执行后的后续处理。但是核心...
动态代理与AOP切面
qq_44189274的博客
07-13 576
思考: 随着业务的不断扩展: (1)日志功能。如果日志代码修改: 以AAA开始 感觉:如果有1w方法都需要添加日志，修改1W方法的代码 (2)校验功能:若1w方法需要校验，修改1w方法的源代码。 解决方案: (1)抽取方法。缺点还需要再1w方法的地方调用。 (2)动态代理: 实现方式有两种: [1]JDK原生动态代理----缺点:必须基于接口完成 [2]cglib动态代理 (3)AOP面向切面编程：AOP的底层实现就是基于动态代理。 准备：引入依赖: 一、动态代理 1.JDK原生动态代理 创建业
Spring选择判断习题练习
m0_56691541的博客
03-31 3060
1、 下列有关AOP专业术语中，用于表示切面与程序流程的交叉点的是（）。 3分 A、Joinpoint B、Pointcut C、Aspect D、Advice 2、 以下有关CGLIB代理相关说法正确的是（）。 3分 A、CGLIB代理的使用非常简单，但它还有一定的局限性——使用动态代理的对象必须实现一个或多个接口 B、如果要对没有实现接口的类进行代理，那么可以使用JDK代理 C、CGLIB是一个高性能开源的代码生成包，在使用时需要另外导入CGLIB所需要的包 D、Spring中的AOP代理，可以是JDK
下面关于数据库中多表之间关联关系说法错误的是（）
夜半少年的博客
12-14 3170
下面关于数据库中多表之间关联关系说法错误的是（B） A.一对一关联关系可以在任意一方引入对方主键作为外键。B.一对多关联关系在“一”的一方，添加“多”的一方的主键作为外键。 C.多对多关联关系会产生中间关系表，引入两张表的主键作为外键。 D.多对多关联关系的两个表的主键成可以为联合主键或使用新的字段作为主键。 ...
AOP术语
03-24 1415
====关注点(Concern)====关注点就是我们要考察或解决的问题。如订单的处理，用户的验证、用户日志记录等都属于关注点。 关注点中的核心关注点(Core Concerns)，是指系统中的核心功能，即真正的商业逻辑。如在一个电子商务系统中，订单处理、客户管理、库存及物流管理都是属于系统中的核心关注点。 还有一种关注点叫横切关注点 (Crosscutting Conc
spring15----AOP之通知顺序
weixin_30622181的博客
12-31 135
如果我们有多个通知想要在同一连接点执行，那执行顺序如何确定呢？Spring AOP使用AspectJ的优先级规则来确定通知执行顺序。总共有两种情况：同一切面中通知执行顺序、不同切面中的通知执行顺序。 首先让我们看下 1）同一切面中通知执行顺序：如图所示 图 同一切面中的通知执行顺序...
JAVA EE企业级应用开发教程3-4章
weixin_46066900的博客
06-29 2029
第三章 1、下列有关AOP专业术语中,用于表示切面与程序流程的交叉点的是()。 A、 Joinpoint B、 Pointcut C、 Aspect D、 Advice 参考答案: B 2、以下有关CGLIB代理相关说法正确的是()。 A、 CGLIB代理的使用非常简单，但它还有一定的局限性–使用动态代理的对象必须实现-个或多个接口 B、 如果要对没有实现接口的类进行代理，那么可以使用JDK代理 C、 CGLIB是- 个高性能开源的代码生成包，在使用时需要另外导入CGLIB所需要的包 D、 Spring中的
小白式讲解AOP（面向切面编程）
刘富国的博客
09-18 3551
一、 基础部分原理讲解： AOP 即 Aspect Oriental Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务 所谓的周边功能，比如性能统计，日志，事务管理等等 周边功能在Spring的面向切面编程AOP思想里，即被定义为切面 在面向切面编程AOP的思想里面，核心
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小白说(๑• . •๑)

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

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

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

打赏作者

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

抵扣说明：

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

余额充值