SpringBoot+拦截器+自定义异常+自定义注解+全局异常处理简单实现接口权限管理

SpringBoot+拦截器+自定义异常+自定义注解+全局异常处理简单实现接口权限管理

https://mp.weixin.qq.com/s/9C5gH28MQECT8n3NBbLdCQ

我觉得一个拦截器加上其他的一些处理就能满足项目的需求，我又何必去多用一个框架呢，

我将权限管理分为三块：

1. 资源权限：将url当做资源，可以给每个账号动态划分Url权限，访问不同的URl；
2. 操作权限：将所有URL分为增、删、改、查4种操作权限，给用户分配对应的操作权限，如某个用户只有查操作权限那么他就无法做其他的操作；
3. 角色权限：系统有多个角色，每个角色的权限都不同，如一个管理后台有着账号管理模块、商品模块等，为超级管理员的角色就可以看到所有模块并操作，而为售后的角色就只能看到商品模块，即使他知道账号管理模块下的URL也无权限操作。然后为用户设置角色就有对应的权限；

资源权限

1.静态资源准备

这里方便演示就不直接操作数据库了，对应的权限建表关系也很简单，这里直接建立静态的用户对应的URL关系。

public class Constant {
    /**
     * 权限管理
     */
    public static Map<Integer,String[]> permission=new HashMap<>();
    static {
        //用户1所拥有的URL权限
        String[] frist={"/url1","/url2","/url3","/url4","/url5","/url6","/url7"};
        
        //用户2所拥有的URL权限
        String[] second={"/url1","/url2","/url3","/url4","/url5"};
        
        //用户3所拥有的URL权限
        String[] third={"/url1","/url2","/url3"};
        
        permission.put(1,frist);
        permission.put(2,second);
        permission.put(3,third);

    }
}

2.自定义一个异常，便于拦截抛出

public class APIException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    
    //异常的消息
    private String msg;
    
    //构造赋值
    public APIException(String msg) {
        super(msg);
        this.msg = msg;
    }

}

3.全局异常处理

便于异常后返回统一规范的结果,正常应该是正常返回自定义Vo，但这里目标是为了演示结果，再加上各位应该都有自己的Vo类，所以这里就不用了

@RestControllerAdvice
public class WebExceptionControl {
    
    @ExceptionHandler(APIException.class)
    public String APIExceptionHandler(APIException e) {
        return e.getMessage();
    }
}

4.controller层

很简单创建对应的URL就好

@RestController
public class TestController {

    @RequestMapping(value = "/url1")
    public String url1() {
        return "恭喜你，你有此权限";
    }


    @RequestMapping(value = "/url7")
    public String url7() {
        return "恭喜你，你有此权限";
    }
}

5.拦截器创建

一般是要先验证token，后根据token取到用户对应信息，这里没有登录所以就直接在token里传对应用户的key值了

/**
 * 权限管理URL拦截器  。 类上 不能public
 */
public class URLInterceptor implements HandlerInterceptor {

    // 预处理回调方法，在接口调用之前使用  true代表放行  false代表不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        //强转了个 寂寞
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        //获取 token
        String token = httpServletRequest.getHeader("token");
        //获取 请求的 uri
        String requestURL = httpServletRequest.getRequestURI();
        
        //1.根据token判断用户是否登录
        if (token==null){   //正常情况下这里还需判断与redis中的token是否匹配
            // 如果没有token或者token不匹配, 直接抛出异常  提示未登录
            throw  new APIException("当前用户未登录");
        }
        
        //2.登录成功后 根据用户token中的信息获取到用户对应的URL权限集合。 1 2 3 获取所有权限
        String[] strings = Constant.permission.get(Integer.valueOf(token));
        
        boolean hasPermission = false;
        //3.再根据用户对应的URL集合去与当前请求的URL对比  有匹配的则放行  反之则抛出异常
        for (int i =0;i<strings.length;i++) { //遍历
            if (strings[i].equals(requestURL)){//如果相同 requestURL
                //权限 可行
                hasPermission = true;
                break;
            }
        }
        if (hasPermission){
            return true;
        }else {
            throw  new APIException("当前用户没有访问路径" + requestURL + "的权限");
        }
    }
}

6.将拦截器注入应用

@Configuration
public class WebMvcConfg implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //权限拦截器
        registry.addInterceptor(urlInterceptor()).addPathPatterns("/**");
    }
    @Bean
    public URLInterceptor urlInterceptor(){
        return new URLInterceptor();
    }
}

7.验证查看结果

分别在token中传入用户1-3的key，访问不同url就可以看到效果，如下

把token换成1 显示：

恭喜你，你有此权限

操作权限

1.和上面一样使用静态资源

public class Constant {
    /**
     * 权限管理
     */
    public static Map<Integer,String[]> permission=new HashMap<>();
    static {
        String[] frist={"insert","delete","select","update"};//用户1所拥有的操作权限
        String[] second={"insert","select","update"};//用户2所拥有的URL权限
        String[] third={"select"};//用户3所拥有的URL权限
        permission.put(1,frist);
        permission.put(2,second);
        permission.put(3,third);

    }
}

2.自定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UrlAnnotation {
    /**
     * 操作类型(type):添加,删除,修改,插入
     * 
     */
    String type();
}

3.controller层

打上自定义的注解，代表对应方法是什么操作

4.修改一下之前的拦截器

添加对注解上面的操作类型的获取，并用type类型去对比判断

		//强转
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        //获取方法
        Method method = handlerMethod.getMethod();
        //获得action注解
        UrlAnnotation urlAnnotation = method.getAnnotation(UrlAnnotation.class);
        //如果 获取的为 null
        if (null == urlAnnotation) {
            throw new APIException("当前用户没有访问路径" + requestURL + "的权限");
        }
		//@UrlAnnotation(type = "select") 获取到 type
        String type = urlAnnotation.type();


        //2.登录成功后 根据用户token中的信息获取到用户对应的URL权限集合。 1 2 3 获取所有权限
        String[] strings2 = Constant.permissionCRUD.get(Integer.valueOf(token));

        boolean hasPermission2 = false;

        //如果数组里，有 action 上的 权限，则可以访问
        for (int i = 0; i < strings2.length; i++) { 
            if (strings2[i].equals(type)) {
                //权限 可行
                hasPermission2 = true;
                break;
            }
        }

5.验证结果

其他都不变

http://localhost:8080/url1 。token=2，2用户，有查询的权限。接口1是查询

恭喜你，你有此权限

角色权限

这里其实和上面的操作大同小异，我这里简单演示一下，以两个模块为例

1.静态对应关系

public class Constant {
    /**
     * 权限管理
     */
    public static Map<Integer,String[]> permission=new HashMap<>();
    static {
        String[] frist={"test","test1"};//用户1所拥有的模块权限  这里的test是模块URL入口  例如：test模块下所有URL都是/test/**
        
        String[] second={"test"};//用户2所拥有的模块权限
        
        permission.put(1,frist); //这里的1其实是用户对应ID为1的角色
        
        permission.put(2,second);//这个2同理

    }

2.修改controller

模拟两个模块

3.修改一下拦截器

        String[] split = requestURL.split("/");

        //截取第一个。第0个位 "" ，1为 test，2为url1
        if (split[1] == null) {
            throw new APIException("url format error");
        }
        String[] strings3 = Constant.permissionResource.get(Integer.valueOf(token));

        boolean hasResource = false;

        for (int i = 0; i < strings3.length; i++) {
            if (strings3[i].equals(split[1])) {
                hasResource = true;
                break;
            }
        }

4.结果测试

http://localhost:8080/test/url1

token = 2，2用户有 test权限，出现：恭喜你，你有此权限

总结

其实用自定义的拦截器去做权限，不管是什么类型其实都大同小异，根据需求灵活的去处理才是最重要的，上面的静态权限变通一下，建立角色表、用户表、路径表以及对应关系，就很容易做出URL的动态权限配置了，灵活运用自定义注解搭配可以做到更细致。