Spring初识（三）（AOP）

最新推荐文章于 2023-06-06 12:24:48 发布

宇智波波奶茶

最新推荐文章于 2023-06-06 12:24:48 发布

阅读量103

点赞数 1

分类专栏： spring Java 文章标签： spring java

本文链接：https://blog.csdn.net/layonly/article/details/120772993

版权

Java 同时被 2 个专栏收录

52 篇文章 3 订阅

订阅专栏

spring

4 篇文章 1 订阅

订阅专栏

Spring中的AOP

1.AOP简介

什么是AOP

AOP Aspect Oriented Programing 面向切面编程

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存） SpringAOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码

2.AOP底层原理

AOP底层原理：就是代理机制动态代理：特点：字节码随用随创建，随用随加载作用：不修改源码的基础上对方法增强分类：基于接口的动态代理基于子类的动态代理

Spring的AOP代理: JDK动态代理:被代理对象必须要实现接口,才能产生代理对象.如果没有接口将不能使用动态代理技术。 CGLib动态代理:第三方代理技术,cglib代理.可以对任何类生成代理.代理的原理是对目标对象进行继承代理. 如果目标对象被final修饰.那么该类无法被cglib代理.

结论:Spring框架,如果类实现了接口,就使用JDK的动态代理生成代理对象,如果这个类没有实现任何接口,使用CGLIB生成代理对象

3.AOP的术语

AOP的术语:

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.

Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Target(目标对象):代理的目标对象

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程,spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面): 是切入点和通知（引介）的结合

4.AOP案例

4.1在pom.xml添加aop依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.4</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
</dependencies>

4.2创建通知类

前置通知(before)：目标方法运行之前调用

后置通知(after-returning)：在目标方法运行之后调用 (如果出现异常不会调用)

环绕通知(around)：在目标方法之前和之后都调用(ProceedingJoinPoint对象 -->> 调用proceed方法)

异常拦截通知(after-throwing)：如果出现异常,就会调用

最终通知(after)：在目标方法运行之后调用 (无论是否出现异常都会调用)

4.3 创建目标接口目标类和通知类

package com.coffee.service;

public interface Service {

   public void add();

   public void delete();
}

package com.coffee.service.impl;

import com.coffee.service.Service;

public class ServiceImpl implements Service {
    @Override
    public void add() {
        System.out.println("我是add方法");
    }

    @Override
    public void delete() {
        System.out.println("我是delete方法");
    }
}

package com.coffee.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAdvice {

    public void before(){
        System.out.println("前置通知，目标对象调用方法前执行");
    }

    public void after(){
        System.out.println("后置通知（最终通知），目标对象调用方法后执行，无论是否发生异常都执行");
    }

    public void after_returning(){
        System.out.println("后置通知，目标对象调用方法后执行，发生异常不执行");
    }

    public void after_throwing(){
        System.out.println("异常通知，发生异常执行");
    }

    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知，目标对象调用方法之前");
        joinPoint.proceed();
        System.out.println("环绕通知，目标对象调用方法之后");
    }
}

4.3创建applicationContext.xml，添加aop约束

<?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"> <!-- bean definitions here -->
<!--        配置通知对象-->
        <bean id="myAdvice" class="com.coffee.advice.MyAdvice"></bean>
<!--        配置目标对象-->
        <bean id="service" class="com.coffee.service.impl.ServiceImpl"></bean>

            <aop:config>
    <!--            切入点，对那些方法进行拦截-->
                <aop:pointcut id="pc" expression="execution(* com.coffee.service.Service.*(..))"/>
    <!--                切面，要增强什么方法-->
                <aop:aspect ref="myAdvice">
    <!--                前置通知，目标对象调用方法前执行-->
                    <aop:before method="before" pointcut-ref="pc"></aop:before>
    <!--                后置通知（最终通知），目标对象调用方法后执行，无论是否发生异常都执行-->
                    <aop:after method="after" pointcut-ref="pc"></aop:after>
    <!--                后置通知，目标对象调用方法后执行，发生异常不执行-->
                    <aop:after-returning method="after_returning" pointcut-ref="pc"></aop:after-returning>
                    <!--异常通知，抛出异常的时候执行-->
                    <aop:after-throwing method="after_throwing" pointcut-ref="pc"></aop:after-throwing>
    <!--                环绕通知，目标对象调用方法之前和之后-->
                    <aop:around method="around" pointcut-ref="pc"></aop:around>

                </aop:aspect>

            </aop:config>

</beans>

5.Spring中的注解配置AOP（了解会用）

AOP注解方式下配置applicationContext.xml

<?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"> <!-- bean definitions here -->
<!--        配置通知对象-->
        <bean id="myAdvice" class="com.coffee.advice.MyAdvice"></bean>
<!--        配置目标对象-->
        <bean id="service" class="com.coffee.service.impl.ServiceImpl"></bean>
<!--        开启使用注解完成织入-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

通知对象：

package com.coffee.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAdvice {
    @Pointcut(value = "execution(* com.coffee.service.impl.ServiceImpl.add())")
    public void pc(){}

    @Before(value = "pc()")
    public void before(){
        System.out.println("前置通知，目标对象调用方法前执行");
    }
    @After(value = "pc()")
    public void after(){
        System.out.println("后置通知（最终通知），目标对象调用方法后执行，无论是否发生异常都执行");
    }
    @AfterReturning(value = "pc()")
    public void after_returning(){
        System.out.println("后置通知，目标对象调用方法后执行，发生异常不执行");
    }
    @AfterThrowing(value = "pc()")
    public void after_throwing(){
        System.out.println("异常通知，发生异常执行");
    }
    @Around(value = "pc()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知，目标对象调用方法之前");
        joinPoint.proceed();
        System.out.println("环绕通知，目标对象调用方法之后");
    }
}

测试类为：

import com.coffee.service.Service;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//        动态代理这里用的是JDK代理 返回的是个接口对象
        Service service =(Service) applicationContext.getBean("service");
        service.add();
        service.delete();
    }
}

结果如下