本文主要是介绍Spring AOP知识点复习，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

AOP概念

面向切面编程。利用AOP可以对业务逻辑重要部分进行隔离，降低各部分逻辑之间的耦合度。

AOP底层原理

1. 底层使用动态代理

有接口情况：
使用JDK动态代理创建接口代理对象

没有接口情况：
使用CGLIB动态代理创建当前类子类代理对象

jdk动态代理实现

（1）调用 newProxyInstance 方法
方法有三个参数：

• 第一参数，类加载器
• 第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
• 第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

//（1）创建接口，定义方法
public interface UserDao {
 public int add(int a,int b);
 public String update(String id);
}

//（2）创建接口实现类，实现方法
public class UserDaoImpl implements UserDao {
 @Override
 public int add(int a, int b) {
 return a+b;
 }
 @Override
 public String update(String id) {
 return id;
 } }
 
 
//（3）使用 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 {
 //1 把创建的是谁的代理对象，把谁传递过来
 //有参数构造传递
 private Object obj;
 public UserDaoProxy(Object obj) {
 this.obj = obj;
 }
 //增强的逻辑
 @Override
 public 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;
 }

AOP部分术语

连接点

类中可以被增强的方法，称为连接点

切入点

真正被增加的方法，称为切入点

通知（增强）

实际增加的部分被称为通知（增强）
有多种类型

• 前置通知：前
• 后置通知：后
• 环绕通知：前后
• 异常通知：异常时
• 最终通知：类似finally

切面

把通知应用到切入点过程叫切面

操作

spring中基于AspectJ实现AOP操作

AspectJ不是Spring的组成部分，是独立的AOP框架，一般把AspecJ和Spreing框架一起使用，进行AOP操作。

• 基于xml配置
• 基于注解（一般使用这个）

切入点表达式

语法结构： execution([权限修饰符] [返回类型] [类全路径] 方法名称 )

举例 1：对 com.test.dao.BookDao 类里面的 add 进行增强

execution(* com.test.dao.BookDao.add(..))

举例 2：对 com.test.dao.BookDao 类里面的所有的方法进行增强

execution(* com.test.dao.BookDao.* (..))

举例 3：对 com.test.dao 包里面所有类，类里面所有方法进行增强

execution(* com.test.dao.. (..))

基于注解实现

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
 //前置通知
 //@Before 注解表示作为前置通知
 @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
 public void before() {
 System.out.println("before.........");
 }
 //后置通知（返回通知）
 @AfterReturning(value = "execution(* 
com.atguigu.spring5.aopanno.User.add(..))")
 public void afterReturning() {
 System.out.println("afterReturning.........");
 }
 //最终通知
 @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
 public void after() {
 System.out.println("after.........");
 }
 //异常通知
 @AfterThrowing(value = "execution(* 
com.atguigu.spring5.aopanno.User.add(..))")
 public void afterThrowing() {
 System.out.println("afterThrowing.........");
 }
 //环绕通知
 @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
 public void around(ProceedingJoinPoint proceedingJoinPoint) throws 
Throwable {
 System.out.println("环绕之前.........");
 //被增强的方法执行
 proceedingJoinPoint.proceed();
 System.out.println("环绕之后.........");
 } }

相同切入点抽取出来

//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
//前置通知
//@Before 注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
 System.out.println("before.........");
}

在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy

这篇关于Spring AOP知识点复习的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！