AOP到底是啥

前言

回忆起来，第一次听到这三字母是博主在上大二的时候，那时候看的一脸懵逼，现在马上研二了才想起来回顾下。

只记得当时面向对象编程还没整明白，这一下子又来个面向切面编程，这直接给整懵了。。。。

面向对象相信大家都很了解了，那咱们接下来看看什么是面向切面编程。

面向切面编程到底是啥意思

咱不整哪些官方话术了，整点通俗的。

想象以下这样的一个场景，你接手了一个人员管理系统，这个项目并没有做任何的权限管理，并且大部分功能已经完成，这时候甲方突然来了个新需求，我现在希望你加上对人员管理的权限，即部门经理只能管理其部门的人员，不能管理其他部门的人员。

这时候，你可能想到要不加个安全框架，但很快你就放弃了，因为这种需要给权限的接口实在是太多了，总不能一个个根据用户权限限制管理权限这么去改吧。

这时候aop的作用就出现了

那可以怎么做呢？

我们通常会将包含接口的Controller都放在一个package中，这时候我们就在想，我们可不可以在职工id传递给接口之前对传递的职工id操作一下呢？

即前端传递过来之后，我们在对这些id再进行一次审核，将没有权限管理的职工id删掉可以不？

很幸运，可以

我们可以认为客户端到调用接口这之间存在一个面，在这个面上我们可以处理将要传递给接口的id参数进行处理，将那些没有权限操作的id直接删除。这个面就可以认为是切面，面向切面编程就是这样。

这里只是一个例子，切面不仅存在这种情况中，对象和对象之间，方法和方法之间等等之间都可以认为是一个切面。

那么要怎么实现面向切面编程呢？

这里我们用注解的方式实现

首先就是我们怎么监视这个面呢？
先看下接口

package com.xiaow.springsecuriydemo.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xiaow.springsecuriydemo.entity.Person;
import com.xiaow.springsecuriydemo.service.PersonService;
import com.xiaow.springsecuriydemo.vo.Result;
import io.jsonwebtoken.lang.Collections;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import java.util.Collection;
import java.util.List;

/**
 * 

 * 前端控制器
 * 
 *
 * @author xiaow
 * @since 2023-09-01
 */
@RestController
@RequestMapping("/person")
public class PersonController {
    @Autowired
    PersonService personService;

    @GetMapping("getPersons")
    public Result getPersons(int adminid, int[] personids) {
        LambdaQueryWrapper<Person> personLambdaQueryWrapper = new LambdaQueryWrapper<>();
        List list1 = Collections.arrayToList(personids);
        personLambdaQueryWrapper.in(Person::getId, list1);
        List<Person> list = personService.list(personLambdaQueryWrapper);
        return Result.succ(list);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

这里的mplus操作，就交给大家去写了。

来了解下怎么写Aspect

@Before(value = "execution(* com.xiaow.springsecuriydemo.controller.*.*(..))")
1

Before也就是在接口执行前，我们对其进行操作，com.xiaow.springsecuriydemo.controller就是我们存放controller的包，后面的第一个*代表任意一个Controller，第二个*（） 就是任意的方法

其意义就是在com.xiaow.springsecuriydemo.controller下的所有接口执行前，做一步处理，那么处理什么呢？

当然是处理传递的员工id，就是把那些无权限处理的id替代掉，这里我们使用-1来代替，因为id为-1不会指向任何员工信息。

看下完整的代码

package com.xiaow.springsecuriydemo.aop.advice;

import com.xiaow.springsecuriydemo.aop.annotation.ArgsAnnotation;
import com.xiaow.springsecuriydemo.aop.annotation.ArraysAnnotation;
import com.xiaow.springsecuriydemo.entity.Admin;
import com.xiaow.springsecuriydemo.entity.Person;
import com.xiaow.springsecuriydemo.service.AdminService;
import com.xiaow.springsecuriydemo.service.PersonService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;

@Aspect
@Component
public class PersonAdvice {
    @Autowired
    AdminService adminService;
    @Autowired
    PersonService personService;

    //  在进入接口之前执行
    @Before(value = "execution(* com.xiaow.springsecuriydemo.controller.*.*(..))")
    public void before(JoinPoint joinPoint) throws IllegalAccessException, NoSuchFieldException {
        final Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        // 获取参数的名字
        final String[] names = methodSignature.getParameterNames();
        // 获取参数的值
        final Object[] args = joinPoint.getArgs();
        int admin_index = -1;
        int personid_index = -1;
        // 获取到adminid和personids的下标位置
        for (int i = 0; i < names.length; i++) {
            if (names[i].equals("adminid")) {
                admin_index = i;
            }
            if (names[i].equals("personids")) {
                personid_index = i;
            }
        }

        Integer adminid = (Integer) args[admin_index];
        int [] personid = (int[]) args[personid_index];
        Admin byId = adminService.getById(adminid);
        if (byId != null) {
            Integer deptid = byId.getDeptid();
            List<Person> byDeptIdAndPersonids = personService.getByDeptIdAndPersonids(deptid, personid);
            int[] personids = (int[]) args[personid_index];
            for (Integer i = 0; i < personids.length; i++) {
                boolean flag = false;
                for (Person byDeptIdAndPersonid : byDeptIdAndPersonids) {
                    if (personids[i] == byDeptIdAndPersonid.getId())
                        flag = true;
                }
//              若不在有权限的id中，则直接设置为-1
                if (!flag)
                    Array.setInt(personid, i, -1);
            }

        }


    }

    // 在接口执行完毕后执行
    @After(value = "execution(* com.xiaow.springsecuriydemo.controller.*.*(..))")
    public void after() {
        System.out.println("after");
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

成果

就这样我们在不修改原有的接口的情况下，实现了权限控制，如下图