Spring-AOP

最新推荐文章于 2024-09-29 20:00:00 发布

UndefinedException

最新推荐文章于 2024-09-29 20:00:00 发布

阅读量89

点赞数

分类专栏： Spring5 文章标签： spring 后端

本文链接：https://blog.csdn.net/weixin_62427168/article/details/125815521

版权

Spring5 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、什么是 AOP

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

（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

二、AOP的实现原理

AOP 底层使用动态代理。

动态代理就是在程序运行期间创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间，对象中方法的动态拦截，在拦截方法的前后执行功能操作。

代理对象并不是事先在Java代码中定义好的。而是在运行期间，根据我们在动态代理对象中的“指示”，动态生成的。

有两种实现方式：

1.有接口情况，使用 JDK 动态代理

- 创建接口实现类代理对象，增强类的方法

2.没有接口情况，使用 CGLIB 动态代理

- 创建子类的代理对象，增强类的方法

举例：AOP（JDK 动态代理）

//（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）创建代理对象代码
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;
 }
}

//（4）使用 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);
 }
}

三、AOP术语

1、连接点 类里面哪些方法可以被增强

2、切入点 实际被增强的方法

3、通知（增强） 实现增强的逻辑部分

前置通知-被增强方法前执行

后置通知-被增强方法后执行，发生异常时不执行

环绕通知-被增强方法前后执行

异常通知-被增强方法抛异常时执行

最终通知-被增强方法后执行，无论是否发生异常都会执行

通知执行顺序：

1.前置通知

2.环绕通知的调用目标方法之前的代码

3.目标方法

4.(异常通知)环绕通知的调用目标方法之后的代码

5.后置通知

6.最终通知

4、切面把通知应用到切入点的过程（增强逻辑应用到原有方法的过程）

四、AOP操作

Spring 框架一般都是基于 AspectJ 实现 AOP 操作，AspectJ 不是 Spring 组成部分，而是独立的 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作。

maven依赖：

 <!--AspectJ 开始-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.10</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.9.5</version>
        </dependency>

        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.0</version>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!--AspectJ 结束-->

4.1 切入点表达式

作用：知道对哪个类里面的哪个方法进行增强

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

举例 1：对 com.dao.BookDao 类里面的 add 进行增强
execution(* com.dao.BookDao.add(..))

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

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

4.2 AOP操作-注解方式

1、创建类，在类里面定义方法
public class User {
     public void add() {
     System.out.println("add.......");
 }
}

2、创建增强类（编写增强逻辑）
//在增强类里面，创建方法，让不同方法代表不同通知类型
//增强的类
public class UserProxy {
 public void before() {//前置通知
     System.out.println("before......");
 }
    ... ...
}

3、进行通知的配置
（1）在 spring 配置文件中，开启注解扫描、生成代理对象
<?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:context="http://www.springframework.org/schema/context" 
         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/context 
         http://www.springframework.org/schema/context/spring-context.xsd 
         http://www.springframework.org/schema/aop 
         http://www.springframework.org/schema/aop/spring-aop.xsd">
 <!-- 开启注解扫描 -->
 <context:component-scan basepackage="com.spring5.aopanno"></context:component-scan>
 <!-- 开启 Aspect 生成代理对象-->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

（2）使用注解创建 User 和 UserProxy 对象，
在增强类上面添加注解 @Aspect，并配置不同类型的通知

//被增强类
@component
public class User（
     ... ...
}

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

}

补充：

1.相同切入点的抽取：

//相同切入点抽取
@Pointcut(value = "execution(* com.spring5.aopanno.User.add(..))")
public void pointdemo() {
}

//前置通知
//@Before 注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
     System.out.println("before.........");
}

2. 有多个增强类多同一个方法进行增强，设置增强类优先级

-在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(1)
public class xxxProxy

3.完全使用注解开发

@Configuration
@ComponentScan(basePackages = {"com.spring5"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

4.3 AOP操作-XML配置文件方式

1、创建两个类，增强类和被增强类，创建方法（略）

2.在 spring 配置文件中创建两个类对象

<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

3.在 spring 配置文件中配置切入点

<!--配置 aop 增强-->
<aop:config>
     <!--切入点-->
     <aop:pointcut id="pc" expression="execution(*com.spring5.aopxml.Book.buy(..))"/>
     <!--配置切面-->
     <aop:aspect ref="bookProxy">
     <!--增强作用在具体的方法上-->
     <aop:before method="before" pointcut-ref="pc"/>
     </aop:aspect>
</aop:config>