Spring入门笔记（二）AOP及AspectJ

最新推荐文章于 2024-04-02 02:47:35 发布

Keozzz

最新推荐文章于 2024-04-02 02:47:35 发布

阅读量440

点赞数

分类专栏： JAVA EE 文章标签： spring aop 学习笔记

本文链接：https://blog.csdn.net/qq_32971807/article/details/52883245

版权

本文深入探讨了Spring框架中的AOP概念，包括AOP的定义、实现原理和术语。讲解了手动实现动态代理的JDK和CGLIB方式，并介绍了Spring的AOP联盟通知类型。接着详细阐述了AspectJ的介绍、切入点表达式及其应用场景，提供了基于XML和注解的AOP配置示例。

摘要由CSDN通过智能技术生成

看完上一篇博客，大致入门了Spring，对于DI（依赖注入）、IOC（控制反转）有了一定的认识。这篇博客，我们还要继续学习Spring。现在，由Spring的另一个核心 — — AOP开始学习。

1.AOP

1.1APO介绍

1.1.1什么是AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码

经典应用：事务管理、性能监视、安全检查、缓存、日志等

Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码

AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

举个例子吧，这里有一堆的service类，UserService、MenuService、CompanyService...,现在我要求你让每一个service的方法执行前开启事物，执行后关闭提交，但又不能改变原本service类的代码。没学过动态代理和AOP思想之前，我们本能的会去分别写一个类去继承UserService、MenuService、CompanyService....在这些子类的每一个方法中，写事务的开启提交。先不说这么写，作用的类其实已经不是原本的对象了。况且这么多的service类，一个一个写，代码重复率不是一点点的高。所以，我们要学习动态代理，深刻理解AOP面向切面编程。

我们可以将事务的开启提交写到一个类中，假设是A类。我们希望A类的这些代码都能作用到UserService中的那些方法上，所以我们想到了代理。代理类将得到A和UserService中的方法开始代理。后文我们用代码一步步模拟。

理解AOP，必须先理解动态代理的概念，如果对这方面感觉有些陌生的朋友，可以进入我的主页，有篇专门介绍JAVA动态代理，其中提及了AOP面向切面编程思想，但是比较浅薄，所以这篇博文将会重点介绍Sring中的AOP。

1.1.2AOP实现原理

aop底层将采用代理机制进行实现。

当有接口 + 实现类时：spring采用 jdk 的动态代理Proxy。

当只有实现类：spring 采用 cglib字节码增强。

1.1.3AOP术语（必须掌握）

1.target：目标类，需要被代理的类。例如：UserService

2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法（你可以理解为公共卫生间中的那些坑）

3.PointCut 切入点：已经被增强的连接点。例如：addUser()（你可以理解为公共卫生间中正在被使用的坑）

4.advice 通知/增强，增强的代码。例如：after、before

5.Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.

6.proxy 代理类

7.Aspect(切面): 是切入点pointcut和通知advice的结合

一个线是一个特殊的面。

一个切入点和一个通知，组成成一个特殊的面。

对于Aspect(切面)的概念，如果你理解不了，那么请听我说。A中的方法是advice，UserService中的一些方法是PointCut，advice和pointCut（这些方法）都会被weaving（织入）Proxy（代理类），我们可以看做这个时候，advice和pointCut这两个点相连，连成了一条线，当advice和pointCut越来越多，这里有越来越多的连线，便组成了一个面（其实数学的理论上，三个点就已经可以确定一个平面了，就算只有一个advice与ponitCut想连，一条直线，在数学的定义里，一个线是一个特殊的面。）就是我们的Aspect(切面)。说了这么多，对于AOP面向切面编程，是不是有了一些感受了呢？

1.2手动方式实现代理

1.2.1JDK动态代理

JDK动态代理对“装饰者”设计模式简化。使用前提：必须有接口

我们可以来模拟一下：

1.目标类：接口 + 实现类

2.切面类：用于存通知 MyAspect

3.工厂类：编写工厂生成代理

4.测试

/**
 * 目标类
 * @author Keo.Zhao
 *
 */
public interface UserService {

	public void addUser();
	public void updateUser();
	public void deleteUser();
}

/**
 * 目标类的实现类
 * @author Keo.Zhao
 *
 */
public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		System.out.println("com.spring.proxy.jdk:addUser");
		
	}

	@Override
	public void updateUser() {
		System.out.println("com.spring.proxy.jdk:updateUser");
		
	}

	@Override
	public void deleteUser() {
		System.out.println("com.spring.proxy.jdk:deleteUser");
		
	}

}

/**
 * 切面类
 * @author Keo.Zhao
 *
 */
public class MyAspect {

	public void before(){
		System.out.println("我是前方法");
	}
	
	public void after(){<span style="font-family:SimSun;">
         </span>
		System.out.println("我是后方法");
	}
}

然后是最重要的工厂类

public class MyBeanFactory {
	
	public static UserService createService(){
		//1 目标类
		final UserService userService = new UserServiceImpl();
		//2切面类
		final MyAspect myAspect = new MyAspect();
		/* 3 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
		 * 	Proxy.newProxyInstance
		 * 		参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
		 * 			一般情况：当前类.class.getClassLoader();
		 * 					目标类实例.getClass().get...
		 * 		参数2：Class[] interfaces 代理类需要实现的所有接口
		 * 			方式1：目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
		 * 			方式2：new Class[]{UserService.class}   
		 * 			例如：jdbc 驱动  --> DriverManager  获得接口 Connection
		 * 		参数3：InvocationHandler  处理类，接口，必须进行实现类，一般采用匿名内部
		 * 			提供 invoke 方法，代理类的每一个方法执行时，都将调用一次invoke
		 * 				参数31：Object proxy ：代理对象
		 * 				参数32：Method method : 代理对象当前执行的方法的描述对象（反射）
		 * 					执行方法名：method.getName()
		 * 					执行方法：method.invoke(对象，实际参数)
		 * 				参数33：Object[] args :方法实际参数
		 * 
		 */
		UserService proxService = (UserService)Proxy.newProxyInstance(
								MyBeanFactory.class.getClassLoader(), 
								userService.getClass().getInterfaces(), 
								new InvocationHandler() {
									
									@Override
									public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
										
										//前执行
										myAspect.before();
										
										//执行目标类的方法
										Object obj = method.invoke(userService, args);
										
										//后执行
										myAspect.after();
										
										return obj;
									}
								});
		
		return proxService;
	}

}

测试类

@Test
	public void testJDK() throws Exception {
		UserService userService = MyBeanFactory.createUserService();
		userService.addUser();
		userService.updateUser();
	}

1.2.2CGLIB

没有接口，只有实现类。

采用字节码增强框架 cglib，在运行时创建目标类的子类，从而对目标类进行增强。

导入jar包：

自己导包：

核心：hibernate-distribution-3.6.10.Final\lib\bytecode\cglib\cglib-2.2.jar

依赖：struts-2.3.15.3\apps\struts2-blank\WEB-INF\lib\asm-3.3.jar

spring-core..jar已经整合以上两个内容

改动较大的只有工厂类，直接看示例代码：

public class MyBeanFactory {
	
	public static UserServiceImpl createService(){
		//1 目标类
		final UserServiceImpl userService = new UserServiceImpl();
		//2切面类
		final MyAspect myAspect = new MyAspect();
		// 3.代理类 ，采用cglib，底层创建目标类的子类
		//3.1 核心类
		Enhancer enhancer = new Enhancer();
		//3.2 确定父类
		enhancer.setSuperclass(userService.getClass());
		/* 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
		 * 	intercept() 等效 jdk  invoke()
		 * 		参数1、参数2、参数3：以invoke一样
		 * 		参数4：methodProxy 方法的代理
		 * 		
		 * 
		 */
		enhancer.setCallback(new MethodInterceptor(){

			@Override
			public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				
				//前
				myAspect.before();
				
				//执行目标类的方法
				Object obj = method.invoke(