Spring：AOP - 版本历史

Eijux：/* Spring：AOP */

2022-11-05T04:07:49Z

Spring：AOP

←上一版本		2022年11月5日 (六) 12:07的版本
第121行：		第121行：
	=== 相关术语 ===		=== 相关术语 ===
	* Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。【可以被切入的方法】		* Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。【可以被切入的方法】
	** ~~在spring 中,这些点指的是~~'''方法'''~~,因为spring~~ 只支持方法类型的连接点；		** 在 Spring 中，这些点指的是'''方法'''，因为，Spring 只支持方法类型的连接点；
	* '''Pointcut'''（切入点）：所谓切入点是指我们要对哪些Joinpoint 进行拦截的定义；【用来切入的方法】		* '''Pointcut'''（切入点）：所谓切入点是指我们要对哪些Joinpoint 进行拦截的定义；【用来切入的方法】
	* '''Advice'''（通知/增强）：所谓通知是指拦截到Joinpoint 之后所要做的事情就是通知；【切面处理】		* '''Advice'''（通知/增强）：所谓通知是指拦截到Joinpoint 之后所要做的事情就是通知；【切面处理】
第129行：		第129行：
	*# “最终通知”：无论程序是否正常执行,最终通知的代码会得到执行；		*# “最终通知”：无论程序是否正常执行,最终通知的代码会得到执行；
	*# “环绕通知”：；		*# “环绕通知”：；
	* Introduction（引介）：引介是一种特殊的通知在不修改类代码的前提下, ~~Introduction可以在运行期为类动态地添加一些方法或Field；~~		* Introduction（引介）：引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field；
	* '''Target'''（目标对象）：代理的目标对象；		* '''Target'''（目标对象）：代理的目标对象；
	* '''Weaving'''（织入）：是指把增强应用到目标对象来创建新的代理对象的过程；【应用增强生成代理对象】		* '''Weaving'''（织入）：是指把增强应用到目标对象来创建新的代理对象的过程；【应用增强生成代理对象】
	** spring采用“动态代理织入”，而AspectJ采用“编译期织入”和“类装载期织入”；【？】		** spring采用“动态代理织入”，而AspectJ采用“编译期织入”和“类装载期织入”；【？】
	* '''Proxy'''~~（代理）：一个类被AOP~~ 织入增强后，就产生一个结果代理类；		* '''Proxy'''（代理）：一个类被 AOP 织入增强后，就产生一个结果代理类；
	* '''Aspect'''（切面）： ~~是切入点和通知（引介）的结合；~~		* '''Aspect'''（切面）：是 Pointcut（切入点）和 Advice（增强）/Introduction（引介）的结合；

	=== jar包 ===		=== jar包 ===
	# spring ~~的传统AOP~~ 的开发的包：		spring 的传统 AOP 的开发的包：
	#* “spring-aop-4.2.4.RELEASE.jar”		“spring-aop-4.2.4.RELEASE.jar”
	#* “com.springsource.org.aopalliance-1.0.0.jar”		“com.springsource.org.aopalliance-1.0.0.jar”
	* aspectJ 的开发包:
	#* “com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar”		aspectJ 的开发包:
	#* “spring-aspects-4.2.4.RELEASE.jar”		“com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar”
			“spring-aspects-4.2.4.RELEASE.jar”

	=== 配置文件 ===		=== 配置文件 ===
	~~需要在“applicationContext~~.~~xml”中引入AOP相关约束：~~		需要在“'''applicationContext.xml'''”中引入 AOP 相关约束：
	<syntaxhighlight lang="properties">		: <syntaxhighlight lang="properties">
	<beans xmlns="http://www.springframework.org/schema/beans"		<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
第158行：		第159行：

	=== 切入点表达式 ===		=== 切入点表达式 ===
	'''execution([方法访问修饰符] ~~<big>~~<方法返回类型> <包名.类名.方法名>(<方法的参数>)~~</big>~~ [异常])'''		注意：<span style="color: green; font-size: 150%">Spring 中，'''切入点是“方法”，而非“类”'''</span>
	* “<>”：必须项；
	* “[]”：可选项；
	* “*”：匹配所有；		'''execution([方法访问修饰符] <方法返回类型> <包名.类名.方法名>(<方法的参数>) [异常])'''
	* “(..)”：任何参数；

			定义切点：
	~~通过方法签名定义切点：~~		# 通过'''方法签名'''：
	# execution(public * *(..))~~：匹配所有目标类的public方法；~~		#: 示例：
	# execution(* *To(..))：匹配目标类所有以To为后缀的方法；		#: execution(public * *(..))：匹配所有目标类的 public方法；
			#: execution(* *To(..))：匹配目标类所有以To为后缀的方法；
	~~通过类定义切点：~~		# 通过'''类'''：
	# execution(* com.baobaotao.Waiter.*(..))：匹配Waiter接口的所有方法；		#: 示例：
	# execution(* com.baobaotao.Waiter+.*(..))：匹配Waiter接口及其所有实现类的方法；		#: execution(* com.baobaotao.Waiter.*(..))：匹配Waiter接口的所有方法；
			#: execution(* com.baobaotao.Waiter+.*(..))：匹配Waiter接口及其所有实现类的方法；
	~~通过类包定义切点：~~		# 通过'''类包'''：
	* “.”：表示包下的所有类；		#* “.”：表示包下的所有类；
	* “..”：表示包、子孙包下的所有类；		#* “..”：表示包、子孙包下的所有类；
	# execution(* com.baobaotao.*(..))：匹配com.baobaotao包下所有类的所有方法；		#: 示例：
	# execution(* com.baobaotao..*(..))：匹配com.baobaotao包、子孙包下所有类的所有方法；		#: execution(* com.baobaotao.*(..))：匹配com.baobaotao包下所有类的所有方法；
	# execution(* com...*Dao.find(..))：匹配：前缀为com的任何包下，后缀为Dao的任何类中，以find为前缀的方法；		#: execution(* com.baobaotao..*(..))：匹配com.baobaotao包、子孙包下所有类的所有方法；
			#: execution(* com...*Dao.find(..))：匹配：前缀为com的任何包下，后缀为Dao的任何类中，以find为前缀的方法；
	~~通过方法入参定义切点：~~		# 通过'''方法入参'''：
	* “”：表示任意类型的参数；		#* “”：表示任意类型的参数；
	* “..”：表示任意类型、任意个数的参数；		#* “..”：表示任意类型、任意个数的参数；
	* 如果参数类型是“java.lang”包下的类，可以直接使用类名；否则必须使用全限定类名；		#* 如果参数类型是“java.lang”包下的类，可以直接使用类名；否则必须使用全限定类名；
	# execution(* joke(String,int)))~~：匹配第一参数是String，第二个参数是int 的joke~~()方法；		#: 示例：
	# execution(* joke(String,*)))：		#: execution(* joke(String,int)))：匹配第一参数是 String，第二个参数是 int 的 joke()方法；
	# execution(* joke(String,..)))：		#: execution(* joke(String,*)))：
	# execution(* joke(Object+)))：匹配参数是“Object”或“Object”子类 ~~的joke~~()方法；		#: execution(* joke(String,..)))：
			#: execution(* joke(Object+)))：匹配参数是“Object”或“Object”子类的 joke()方法；

	== 基于AspectJ：XML ==		== 基于AspectJ：XML ==

Eijux：/* 基于AspectJ：注解 */

2020-11-02T01:35:05Z

基于AspectJ：注解

@@ 第284行： / 第284行： @@
+	}
+}
 </syntaxhighlight>

Eijux：/* 基于AspectJ：XML */

2020-10-29T21:25:55Z

基于AspectJ：XML

←上一版本		2020年10月30日 (五) 05:25的版本
第216行：		第216行：
	<aop:pointcut expression="execution(* cn.itcast.aop.Book.*(..))" id="pointcut1"/>		<aop:pointcut expression="execution(* cn.itcast.aop.Book.*(..))" id="pointcut1"/>

	<!-- 2.2 ~~配置切面：把增强用到方法上面~~ -->		<!-- 2.2 配置切面 -->
	<aop:aspect ref="myBook">		<aop:aspect ref="myBook">
	<!-- ~~配置增强类型（method：增强类里面使用哪个方法作为前置）~~-->		<!-- 配置增强（“method”：增强；“pointcut-ref”：切入点）-->
	<aop:before method="before1" pointcut-ref="pointcut1"/>		<aop:before method="before1" pointcut-ref="pointcut1"/>

Eijux：/* 基于AspectJ：注解 */

2020-10-29T21:23:24Z

基于AspectJ：注解

←上一版本		2020年10月30日 (五) 05:23的版本
第259行：		第259行：

	== 基于AspectJ：注解 ==		== 基于AspectJ：注解 ==
			步骤：
			# 创建对象；
			# 开启aop操作（“applicationContext.xml”中）；
			#: <syntaxhighlight lang="properties" highlight="6">
			<!-- 1 配置对象 -->
			<bean id="book" class="cn.itcast.aop.Book"></bean>
			<bean id="myBook" class="cn.itcast.aop.MyBook"></bean>

			<!-- 2 开启aop操作 -->
			<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
			</syntaxhighlight>
			# 在增强类中使用注解；
			## “'''@Aspect'''”：注解增强类；
			## “'''@Before'''”、“'''@After'''”、“'''@Around'''”、“@AfterReturning”、“@AfterThrowing”：注解增强；
			##* 需要配置“'''切入点表达式'''”（value属性中）；
			#: <syntaxhighlight lang="java" highlight="1,5">
			@Aspect
			public class MyBook {

			//在方法上面使用注解完成增强配置
			@Before(value="execution(* cn.itcast.aop.Book.*(..))")
			public void before1() {
			System.out.println("before..............");
			}
			}
			</syntaxhighlight>

Eijux：/* 基于AspectJ：XML */

2020-10-29T21:10:05Z

基于AspectJ：XML

←上一版本		2020年10月30日 (五) 05:10的版本
第190行：		第190行：

	== 基于AspectJ：XML ==		== 基于AspectJ：XML ==
			步骤：
			# 配置Bean对象；
			# 配置aop操作：
			## 配置切入点；
			## 配置切面；（AspectJ）
			#


			xml配置示例：
			<syntaxhighlight lang="properties" highlight="15,18,22">
			<?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="book" class="cn.itcast.aop.Book"></bean>
			<bean id="myBook" class="cn.itcast.aop.MyBook"></bean>

			<!-- 2 配置aop操作 -->
			<aop:config>
			<!-- 2.1 配置切入点 -->
			<aop:pointcut expression="execution(* cn.itcast.aop.Book.*(..))" id="pointcut1"/>

			<!-- 2.2 配置切面：把增强用到方法上面 -->
			<aop:aspect ref="myBook">
			<!-- 配置增强类型（method：增强类里面使用哪个方法作为前置）-->
			<aop:before method="before1" pointcut-ref="pointcut1"/>

			<aop:after-returning method="after1" pointcut-ref="pointcut1"/>

			<aop:around method="around1" pointcut-ref="pointcut1"/>
			</aop:aspect>
			</aop:config>
			</beans>
			</syntaxhighlight>
			# 切入点“execution(* cn.itcast.aop.Book.*(..))”匹配到“book”类中的所有方法；（切入点是方法，而非类）
			# 增强类“myBook”的“before1”、“after1”、“around1”分别被织入到切入点的前、后、环绕；

			增强类示例：
			<syntaxhighlight lang="java">
			public class MyBook {

			public void before1() {
			System.out.println("前置增强......");
			}

			public void after1() {
			System.out.println("后置增强......");
			}

			//环绕通知
			public void around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
			//方法之前
			System.out.println("方法之前.....");

			//执行被增强的方法
			proceedingJoinPoint.proceed();

			//方法之后
			System.out.println("方法之后.....");
			}
			}
			</syntaxhighlight>
			# “环绕通知”中，调用执行切入点；（切入点是方法，而非类）

	== 基于AspectJ：注解 ==		== 基于AspectJ：注解 ==

Eijux：/* 切入点表达式 */

2020-10-29T18:00:57Z

切入点表达式

@@ 第158行： / 第158行： @@
 === 切入点表达式 ===
 == 基于AspectJ：XML ==
 == 基于AspectJ：注解 ==

Eijux：/* 关于AspectJ */

2020-10-29T17:30:41Z

关于AspectJ

←上一版本		2020年10月30日 (五) 01:30的版本
第82行：		第82行：
	* AspectJ不是spring一部分，和spring一起使用进行aop操作（Spring2.0以后新增了对AspectJ支持）；		* AspectJ不是spring一部分，和spring一起使用进行aop操作（Spring2.0以后新增了对AspectJ支持）；

	=== ~~AspectJ 与 Spring AOP~~ ===		=== 关于织入 ===
	AOP编程，存在三种织入方式：		AOP编程，存在三种织入方式：
	# 编译期织入（Compile-time weaving）：（编译期、编译后）在Java编译期，采用特殊的'''编译器'''，将切面织入到Java类中；		# 编译期织入（Compile-time weaving）：（编译期、编译后）在Java编译期，采用特殊的'''编译器'''，将切面织入到Java类中；
第90行：		第90行：
	# 运行期织入：采用'''CGLib工具'''或'''JDK动态代理'''进行切面的织入；		# 运行期织入：采用'''CGLib工具'''或'''JDK动态代理'''进行切面的织入；

			=== AspectJ 与 Spring AOP ===
	Spring AOP 和 AspectJ 之间的关键区别：		Spring AOP 和 AspectJ 之间的关键区别：
	{\| class="wikitable"		{\| class="wikitable"
第116行：		第116行：
	*:“@Before”、“@After”等是Aspect的Annotation；		*:“@Before”、“@After”等是Aspect的Annotation；
	* AspectJ在实际运行之前就完成了织入，所以其生成的类没有额外运行时开销。		* AspectJ在实际运行之前就完成了织入，所以其生成的类没有额外运行时开销。

			== Spring：AOP ==

	=== 相关术语 ===		=== 相关术语 ===
第154行：		第156行：
	</beans>		</beans>
	</syntaxhighlight>		</syntaxhighlight>

			=== 切入点表达式 ===

	== 基于AspectJ：XML ==		== 基于AspectJ：XML ==

	== 基于AspectJ：注解 ==		== 基于AspectJ：注解 ==

Eijux：/* 基于AspectJ：XML配置 */

2020-10-29T17:26:36Z

基于AspectJ：XML配置

←上一版本		2020年10月30日 (五) 01:26的版本
第155行：		第155行：
	</syntaxhighlight>		</syntaxhighlight>

	== ~~基于AspectJ：XML配置~~ ==		== 基于AspectJ：XML ==

	== 基于AspectJ：注解 ==		== 基于AspectJ：注解 ==

Eijux：/* 基于AspectJ的AOP：注解 */

2020-10-29T17:26:18Z

基于AspectJ的AOP：注解

←上一版本		2020年10月30日 (五) 01:26的版本
第157行：		第157行：
	== 基于AspectJ：XML配置 ==		== 基于AspectJ：XML配置 ==

	== ~~基于AspectJ的AOP：注解~~ ==		== 基于AspectJ：注解 ==

Eijux：/* 基于AspectJ的AOP：XML */

2020-10-29T17:26:03Z

基于AspectJ的AOP：XML

←上一版本		2020年10月30日 (五) 01:26的版本
第155行：		第155行：
	</syntaxhighlight>		</syntaxhighlight>

	== ~~基于AspectJ的AOP：XML~~ ==		== 基于AspectJ：XML配置 ==


	== 基于AspectJ的AOP：注解 ==		== 基于AspectJ的AOP：注解 ==

Spring：AOP - 版本历史

Eijux：​/* Spring：AOP */

Eijux：​/* 基于AspectJ：注解 */

Eijux：​/* 基于AspectJ：XML */

Eijux：​/* 基于AspectJ：注解 */

Eijux：​/* 基于AspectJ：XML */

Eijux：​/* 切入点表达式 */

Eijux：​/* 关于AspectJ */

Eijux：​/* 基于AspectJ：XML配置 */

Eijux：​/* 基于AspectJ的AOP：注解 */

Eijux：​/* 基于AspectJ的AOP：XML */

Eijux：/* Spring：AOP */

Eijux：/* 基于AspectJ：注解 */

Eijux：/* 基于AspectJ：XML */

Eijux：/* 基于AspectJ：注解 */

Eijux：/* 基于AspectJ：XML */

Eijux：/* 切入点表达式 */

Eijux：/* 关于AspectJ */

Eijux：/* 基于AspectJ：XML配置 */

Eijux：/* 基于AspectJ的AOP：注解 */

Eijux：/* 基于AspectJ的AOP：XML */