Spring框架-AOP

1.什么是AOP？

面向切面编程，可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

通过不修改源代码方式，在主干功能里面添加新功能

2.底层原理

底层使用动态代理：

有接口的情况，使用 JDK 动态代理：创建接口的实现类的代理对象，通过代理对象实现方法的增强
// 存在的接口
public interface UserDao {public void login();
}
// 接口的实现类
public class UserDaoImpl implements UserDao {// 原始方法@Overridepublic void login() {System.out.println("实现登录功能");System.out.println("对代码增强");}
}
没有接口的情况，使用 cglib 动态代理：创建当前类的子类的代理对象，通过代理对象实现方法的增强
// 当前的类
public class Emp {public void add(){System.out.println("原始功能的实现");}
}
// 当前类的子类
public class EmpMen extends Emp{// 原始方法@Overridepublic void add() {super.add();System.out.println("对功能的增强");}
}

2.1 JDK 动态代理

使用 Proxy 类里面的方法创建代理对象：调用 newProxyInstance 方法，方法中的参数如下：
- 类加载器
- 增强方法所在的类实现的接口，支持多个接口
- 实现接口 InvocationHandler，创建代理对象，写增强的部分

编写 JDK 动态代理代码：

创建接口，定义方法：

public interface UserDao {public int add(int a,int b);public String update(String id);
}

创建接口实现类，实现方法：

public class UserDaoImpl implements UserDao {@Overridepublic int add(int a, int b) {return a+b;}@Overridepublic String update(String id) {return id;}
}

使用 Proxy 类创建接口代理对象：

public class JDKProxy {public static void main(String[] args) {//创建接口实现类代理对象Class[] interfaces = {UserDao.class};// 创建接口的实现类UserDaoImpl userDao = new UserDaoImpl();UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));int result = dao.add(1, 2);  // 调用哪个方法就对哪个方法实现增强System.out.println("result:"+result);}
}
// 创建代理对象
class UserDaoProxy implements InvocationHandler {// 创建的是谁的代理对象就把谁传递过来(通过有参数构造传递）private Object obj;public UserDaoProxy(Object obj) {this.obj = obj;}// 增强的代码@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//执行原始方法代码之前增强的功能System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args));//被增强的方法执行Object res = method.invoke(obj, args);//执行完原始方法代码之后增强的功能System.out.println("方法之后执行...."+obj);return res;}
}
// 输出：
// 方法之前执行....add :传递的参数...[1, 2]
// 方法之后执行....com.psj.AOP.UserDaoImpl@153f5a29
// result:3

3.AOP术语

连接点：类中哪些方法可以被增强，这些方法被称为连接点

切入点：实际被真正增强的方法

通知(增强)：实际增强方法中的逻辑部分(即新加入的代码)。通知有多个类型(假设切入点为add方法)：
前置通知：在add方法执行前执行的代码

后置通知：在add方法执行后执行的代码，有异常就不会执行

环绕通知：在add方法执行前以及执行后执行的代码

异常通知：当执行add方法出现异常时会执行的代码

最终通知：类似于try-catch-finally中的finally代码块。如果add方法出现异常，则后置通知就不会执行，但是最终通知还是会执行(但是并不意味着最终通知是最后执行的，没有异常时后置通知是最后执行的。和try-catch-finally一样先执行完finally代码块再执行try中的return语句)

切面：把通知应用到切入点的过程，是一个动作

4.AOP 操作

4.1 准备工作

引入AOP的依赖：在Spring中有多种方式实现AOP的操作，但是一般使用AspectJ。它不是Spring 组成部分，是一个独立于Spring的AOP 框架，一般把AspectJ和Spirng框架一起使用

切入点表达式：知道对哪个类里面的哪个方法进行增强
语法：execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

举例：
对 com.psj.dao.BookDao 类里面的 add 进行增强：execution(* com.psj.dao.BookDao.add(..))。其中*表示任意的权限修饰符，返回类型可以省略，..表示add方法的参数

对 com.psj.dao.BookDao 类里面的所有的方法进行增强：execution(* com.atguigu.dao.BookDao.* (..))。其中第二个*表示对BookDao下的所有方法增强

对 com.psj.dao 包里面所有类，类里面所有方法进行增强：execution(* com.atguigu.dao.*.*(..))

需要导入的包：
spring-aspects-xxx.jar

com.springsource.net.sf.cglib-xxx.jar

com.springsource.org.aopalliance-xxx.jar

com.springsource.org.aspectj.weaver-xxx.jar

4.2 AspectJ 注解

创建被增强的类：

public class User {public void add() {System.out.println("add.......");}
}

创建增强类：在增强类里面创建方法，让不同方法代表不同通知类型

public class UserProxy {public void before() {//前置通知System.out.println("before......");}
}

进行通知的配置(采用注解方式)：

开启注解扫描：

# 要加上名称空间
<context:component-scan base-package="com.psj"></context:component-scan>

使用注解创建 User 和 UserProxy 对象，并在增强类UserProxy 上面添加注解 @Aspect：：

@Component
public class User {public void add() {System.out.println("add.......");}
}
@Component
@Aspect // 表示生成代理对象
public class UserProxy {public void before() {//前置通知System.out.println("before......");}
}

在 spring 配置文件中开启生成代理对象：

<!-- 开启 Aspect 生成代理对象，其实就是看创建的对象上是否有@AspectJ，有的话就创建代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

配置不同类型的通知：在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

@Component
@Aspect // 表示生成代理对象
public class UserProxy {//前置通知//@Before 注解表示作为前置通知@Before(value = "execution(* com.psj.AOP.User.add(..))")public void before() {System.out.println("before.........");}//后置通知（返回通知，执行完return语句后执行）@AfterReturning(value = "execution(* com.psj.AOP.User.add(..))")public void afterReturning() {System.out.println("afterReturning.........");}//最终通知@After(value = "execution(* com.psj.AOP.User.add(..))")public void after() {System.out.println("after.........");}//异常通知@AfterThrowing(value = "execution(* com.psj.AOP.User.add(..))")public void afterThrowing() {System.out.println("afterThrowing.........");}//环绕通知@Around(value = "execution(* com.psj.AOP.User.add(..))")public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("环绕之前.........");//执行被增强的方法，即add方法proceedingJoinPoint.proceed();System.out.println("环绕之后.........");}
}
// 测试：
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
user.add();
// 输出：
// 当add方法正常执行时
环绕之前.........
before.........
add.......
环绕之后.........
after.........
afterReturning.........
// 当add方法出现异常时
环绕之前.........
before.........
after.........
afterThrowing.........

tips:

后置通知在出现异常时不会执行时因为像try-catch-finally代码块中，出现异常后不会再执行try中的下面的代码(即执行不到add方法的return语句，也就不会执行到后置通知)
在上述通知中切入点都是一样的，所以会出现重复的切入点声明代码，可以将相同的切入点抽取出来：

@Pointcut(value = "execution(* com.psj.AOP.User.add(..))")
public void pointDemo(){}
@Before(value = "pointDemo()")
public void before() {System.out.println("before.........");
}

假设有多个增强类对add方法做增强，可以设置优先级决定先执行哪个增强类的增强代码(所有增强类的增强代码都会执行，只不过决定哪个先执行)：

@Component
@Aspect
@Order(1)  // 值越小，优先级越高
public class UserProxy2 {@Pointcut(value = "execution(* com.psj.AOP.User.add(..))")public void pointDemo(){}@Before(value = "pointDemo()")public void before() {System.out.println("another before.........");}
}

如果采取完全注解方式，需要将bean.xml中的配置信息改为在config类上加注解：

@Configuration
@ComponentScan(basePackages = {"com.psj"})  // 替代开启注解扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)  // 替代开启Aspect生成代理对象
public class configAop {
}

4.3 AspectJ 配置文件

创建增强类和被增强类以及被增强的方法
在 spring 配置文件中创建两个类对象：

<bean id="user" class="com.psj.AOP.User"></bean>
<bean id="userProxy" class="com.psj.AOP.UserProxy"></bean>

在 spring 配置文件中配置切入点：

<!--配置 aop 增强-->
<aop:config><!--切入点--><aop:pointcut id="p" expression="execution(* com.psj.AOP.User.add(..))"/><!--配置切面--><aop:aspect ref="userProxy"><!--增强作用在具体的方法上--><aop:before method="before" pointcut-ref="p"/></aop:aspect>
</aop:config>

Spring框架-AOP相关推荐

spring框架 AOP核心详解
AOP称为面向切面编程,在程序开发中主要用来解决一些系统层面上的问题,比如日志,事务,权限等待,Struts2的拦截器设计就是基于AOP的思想,是个比较经典的例子. 一 AOP的基本概念 (1)Asp ...
Spring框架AOP源码剖析
今天我要和大家分享的是 AOP(Aspect-Oriented Programming)这个东西的源码剖析,作为多年的开发者,想必大家在面试的时候都被问过,你知道Spring框架AOP的底层实现机制吗 ...
Spring框架 AOP面向切面编程（转）
一.前言在以前的项目中,很少去关注spring aop的具体实现与理论,只是简单了解了一下什么是aop具体怎么用,看到了一篇博文写得还不错,就转载来学习一下,博文地址:http://www.cnbl ...
Spring框架----AOP的概念及术语
1.什么是AOP AOP:全称是 Aspect Oriented Programming 即:面向切面编程简单的说它就是把我们程序重复的代码抽取出来,在需要执行的时候,使用动态代理的技术,在不修改源 ...
Spring框架——AOP入门笔记以及个人总结
注:作者本人也是初学者,所以本文有些总结性见解可能存在问题,但是多数问题都是在上网查询过资料后总结的,如果有逻辑或者原理上的错误,或者见解不同,欢迎在评论区讨论!!! 目录 Spring的AOP 1. ...
spring框架AOP的理解，程序高类聚的体现
本文主要介绍AOP思想,而不是Spring,Spring在本文只做为理解AOP的工具和例子,所以也不打算介绍Spring的Aspect.Join point.Advice.AOP proxy等概念,那 ...
08 Spring框架 AOP （一）
首先我们先来介绍一下AOP: AOP(Aspect Orient Programming),面向切面编程,是面向对象编程OOP的一种补充. 面向对象编程是从静态角度考虑程序的结构,面向切面编程是从动态 ...
Spring框架AOP原理及实现
1.AOP思想 1.1 什么是AOP Aspect oritention programming(面向切面编程),把一个个的横切关注点(这些零散存在于业务方法中的功能代码,我们称之为横切面关注点)放到 ...
Spring 框架 AOP 的总结
一:帝国之军-AOP 1:案例分析 ![事务案例](https://img-blog.csdn.net/2018040518063398?watermark/2/text/aHR0cHM6Ly9ibG ...

Spring框架-AOP

1.什么是AOP？

2.底层原理

2.1 JDK 动态代理

3.AOP术语

4.AOP 操作

4.1 准备工作

4.2 AspectJ 注解

4.3 AspectJ 配置文件

Spring框架-AOP相关推荐

最新文章

热门文章