Spring框架学习之AOP

最新推荐文章于 2022-03-17 20:10:19 发布

苏福唉

最新推荐文章于 2022-03-17 20:10:19 发布

阅读量621

点赞数 2

分类专栏： Spring学习 Java后端开发文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_52951579/article/details/122022724

版权

Java后端开发同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

Spring学习

5 篇文章 0 订阅

订阅专栏

AOP操作（基于AspectJ注解，常用）

AOP操作（基于AspectJ配置文件，了解）

什么是AOP

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

下面用登录案例来解释以下

上图为一个简单的登录实现流程，如果我们现在要在此基础上添加一个权限判断的功能：

原始方式：

修改源代码来进行实现，比如：

if 管理员

else if 普通用户

AOP：通过AOP我们可以不通过修改源代码的方式来添加新的功能，比如在该例子中就可以增加一个权限判断模块，通过配置文件或者其他方式来将其添加进登录流程中，这样我们就实现了添加权限判断的功能，如果以后我们不想要该功能了，直接将对应模块配置去掉就行，而不用去修改源代码，这样就可以实现降耦合。

AOP的底层原理

AOP底层使用了动态代理，有两种情况的动态代理

第一种有接口情况，使用JDK动态代理（创建接口实现类代理对象，增强类方法）

总结：使用Proxy类的newProxyInstance方法创建代理对象

该方法有三个参数：

第一个参数：类加载器

第二个参数：增强方法所在类实现的接口，支持多个接口

第三个参数：实现接口InvocationHandler，创建代理对象，写增强的方法（可写成匿名内部类，也可写成单独的一个类）

比如现在有一个UserDao接口

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

有一个实现类

public class UserDaoImp implements UserDao{
    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了...");
        return a + b;
    }
    @Override
    public String update(String id) {
        System.out.println("update方法执行了...");
        return id;
    }
}

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

public class JDKPeoxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDao userDao = new UserDaoImp();
        UserDao o = (UserDao) Proxy.newProxyInstance(JDKPeoxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add = o.add(1, 2);
        System.out.println("结果：" + add);
        String name = o.update("xxzz");
        System.out.println("id：" + name);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
    //把被代理对象传递进来
    //有参数构造进行传递
    private Object object;
    public UserDaoProxy(Object obj){
        this.object = obj;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("在方法之前执行....." + method.getName() + ":传递的参数..." + Arrays.toString(args));
        //被增强的方法
        Object invoke = method.invoke(object, args);
        //方法之后
        System.out.println("在方法之后执行....." + object);
        return invoke;
    }
}

第二种没有接口情况，使用CGLIB动态代理（创建子类的代理对象，来对方法进行增强）

现在有一个User类

public class User {
    public int add(int a,int b){
        System.out.println("add方法被执行了...");
        return a + b;
    }
}

现在我们想增强User类中的add方法

原始方式：可以创建User类的子类，通过子类来增强方法。

CGLIB动态代理：创建当前类子类的代理对象，通过该代理对象来对方法进行增强

AOP的相关术语

class User{
	add();
	update();
	select();
	delete();
}

1. 连接点：类里面哪些方法可以被增强，这些方法被称为连接点（User的add、update、select、 delete等个4方法）

2. 切入点：实际真正被增强的方法（在User中如果我只增强的add方法，其他没有增强，那么就只有add方法可以称为切入点）

3. 通知（增强）：

①：实际增强的逻辑部分被称为通知（增强），（在之前的登录功能里，我们增加的权限判断模块就可以称为通知）

②：通知有多种类型，假如我们现在想增强add方法

前置通知：在add方法之前其会执行

后置通知：在add方法之后其会执行

环绕通知：在add方法之前和之后都会执行

异常通知：当add方法出现异常其会执行

最终通知：类似于finally，有无异常都会执行

4. 切面（是一个动作术语）：把通知应用到切入点的过程（把权限判断加到登录方法的过程）

AOP操作前的准备工作

1. Spring框架一般基于 AspectJ 实现AOP操作

AspectJ：不是Spring的组成部分，独立AOP框架，一般把 AspectJ 和 Spring 框架一起使用来实现 AOP操作

2. 基于AspectJ 实现AOP操作

①：基于xml配置文件实现

②：基于注解方式实现（一般使用）

3. 在项目工程里面引入AOP相关依赖（前面IOC部分引入的依赖也要引入）

前两个jar包在spring官方jar包里面，后两个jar包可在下面链接下载

链接：https://pan.baidu.com/s/1YdsINOvIVQ8Ki47Kd7ZpNA
提取码：0js8

对应maven

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.9.RELEASE</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>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.2.9.RELEASE</version>
    </dependency>

4. 切入点表达式

①：切入点表达式作用：知道对哪个类里面的哪个方法进行增强

②：语法结构：

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

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

execution(* Test.BookDao.add(..)) 注：* 表示任意权限修饰符，参数列表用 .. 代替

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

execution(* Test.BookDao.*(..))

举例3：对Test包下的所有类，类里面的所有方法进行增强

execution(* Test.*.*(..))

AOP操作（基于AspectJ注解，常用）

1. 创建被增强类，在类里面定义方法

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

2. 创建增强类（编写增强逻辑）

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

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

3. 进行通知的配置

①：在spring配置文件中，开启注解扫描

首先要引入 context 和 aop 名称空间

xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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 base-package="Test2"></context:component-scan>

②：使用注解创建 User 和 UserProxy 对象

在两个类上添加 @Component

③：在增强类上面添加注解 @Aspect

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

<!--开启Aspect生成代理对象-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4. 配置不同类型的通知

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

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

5. 测试

public class TestAop {
    @Test
    public void test1(){
        ApplicationContext context = new FileSystemXmlApplicationContext("G:\\SpringStudy\\Spring-AOP\\src\\bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
}

6. 其他几种通知

//前置通知
    @Before(value = "execution(* Test2.User.add(..))") //Before注解表示前置通知
    public void before(){
        System.out.println("before......");
    }
    //最终通知（在返回值之前执行）
    @After(value = "execution(* Test2.User.add(..))")
    public void after(){
        System.out.println("after......");
    }
    //后置通知（在返回值之后执行）
    @AfterReturning(value = "execution(* Test2.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning......");
    }
    //异常通知
    @AfterThrowing(value = "execution(* Test2.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing......");
    }
    //环绕通知
    @Around(value = "execution(* Test2.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around之前......");
        proceedingJoinPoint.proceed();
        System.out.println("around之后......");
    }

没有异常

出现异常（在add方法前添加了除0操作）

由此可见 after 不论是否出现异常都会执行，可叫做最终通知

afterReturning 出现异常就不会执行，可叫做后置通知

其他问题：

①：相同切入点抽取，用 Pointcut 进行抽取，可以简化操作

@Pointcut(value = "execution(* Test2.User.add(..))")
    public void pointDemo(){}
    //前置通知
    @Before(value = "pointDemo()") //Before注解表示前置通知
    public void before(){
        System.out.println("before......");
    }

②：有多个增强类对同一个方法进行增强，设置增强类的优先级

新添加一个PersonProxy作为增强类

@Component
@Aspect //生成代理对象
public class PersonProxy {
    @Before(value = "execution(* Test2.User.add(..))") //Before注解表示前置通知
    public void before(){
        System.out.println("Person Before......");
    }
}

设置两个增强类的优先级，可以在增强类上面添加注解 @Order(数字类型的值)，值越小优先级越高

我们将 PersonProxy 设置为1，UserProxy 设置为3

将UserProxy设置为1，PersonProxy设置为3

完全使用注解开发

创建配置类，不需要xml配置文件

@Configuration
@ComponentScan(basePackages = "Test2") //组件扫描
@EnableAspectJAutoProxy //替代开启Aspect生成代理对象
public class ConfigAop {
}

AOP操作（基于AspectJ配置文件，了解）

1. 创建两个类，增强类和被增强类，以及他们的方法

//被增强类
public class Book {
    public void buy(){
        System.out.println("buy......");
    }
}

//增强类
public class BookProxy {
    public void before(){
        System.out.println("before......");
    }
}

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

<!--创建两个类的对象-->
    <bean id="book" class="Test3.Book"></bean>
    <bean id="bookProxy" class="Test3.BookProxy"></bean>

3. 在 spring 配置文件中配置切入点，需要开启aop名称空间

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

4. 测试

@Test
    public void test(){
        ApplicationContext context = new FileSystemXmlApplicationContext("G:\\SpringStudy\\Spring-AOP\\src\\bean2.xml");
        Book book = context.getBean("book", Book.class);
        book.buy();
    }

这里仅用了前置通知作为示范，其他通知同理。用配置文件操作AOP仅作了解即可。

至此，AOP学习结束。

苏福唉

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring框架学习之AOP

目录什么是AOPAOP的底层原理AOP的相关术语AOP操作前的准备工作AOP操作（基于AspectJ注解，常用）AOP操作（基于AspectJ配置文件，了解）什么是AOP面向切面编程(方面)，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑的各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率下面用登录案例来解释以下上图为一个简单的登录实现流程，如果我们现在要在此基础上添加一个权限判断的功能：原始方式：修改源代码来进行实现，比如：i
复制链接

扫一扫

专栏目录