前言

这是我在这个网站整理的笔记,有错误的地方请指出，关注我，接下来还会持续更新。 作者：神的孩子都在歌唱

一. SpEL中使用自定义Bean

通过编程授权方法

首先，声明一个 Bean，如下所示：

@Service("authz")
public class PermissionService {
      /**
     * 验证用户是否具备某权限
     *
     * @param permission 权限字符串
     * @return 用户是否具备某权限
     */
    public boolean hasPerm(String permission) {
        // 逻辑处理
    }
    
}

然后，在注解中以如下方式引用该 Bean：

@Controller
public class MyController {
    @PreAuthorize("@authz.hasPerm('com:user:ip')")
    @GetMapping("/endpoint")
    public String endpoint() {
        // ...
    }
}

Spring Security 将在每次方法调用时调用该Bean上的给定方法。

这样做的好处是所有的授权逻辑都在一个单独的类中，可以独立进行单元测试并验证其正确性。

二. 通过类继承自定义权限表达式

1. 第一种的缺点：

   (1) 使用第一种方式idea会有告警，使得项目很难看

   

   (2) 这种自定义方式太自由了，没有在 Spring Security 架构内完成这件事。所以，我们要在不使用第三方对象的情况下，来自定义一个权限判断的表达式。

我们在 @PreAuthorize 注解中使用的不用加对象名就能调用的授权字段和方法，如 hasAuthority、hasPermission、hasRole、hasAnyRole 等， Spring Security 将所有授权字段和方法封装在一组根（root）对象中。最通用的根对象称为 SecurityExpressionRoot，它构成了 MethodSecurityExpressionRoot 的基础。当准备评估授权表达式时，Spring Security 会将该根对象提供给 MethodSecurityEvaluationContext。

2.1 自定义 ExpressionRoot

首先我们自定义一个类继承自 SecurityExpressionRoot 并实现 MethodSecurityExpressionOperations 接口（本来直接继承自 MethodSecurityExpressionRoot 即可，但是因为这个类不是 public 的，没法继承，所以我们就实现 MethodSecurityExpressionOperations 接口即可）：

/**
 * 自定义权限实现
 *
 * @author chenyunzhi
 */
public class PermissionSecurityExpressionRoot extends SecurityExpressionRoot implements MethodSecurityExpressionOperations {

    private Object filterObject;

    private Object returnObject;

    private Object target;


    /**
     * 所有权限标识
     */
    private static final String ALL_PERMISSION = "*:*:*";

    private static final String PERMISSION_DELIMETER = ",";

    /**
     * Creates a new instance
     *
     * @param authentication the {@link Authentication} to use. Cannot be null.
     */
    public PermissionSecurityExpressionRoot(Authentication authentication) {
        super(authentication);
    }

    /**
     * 验证用户是否具备某权限
     *
     * @param permission 权限字符串
     * @return 用户是否具备某权限
     */
    public boolean hasPerm(String permission) {
        if (StringUtils.isEmpty(permission)) {
            return false;
        }
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getPermissions())) {
            return false;
        }
        return hasPermissions(loginUser.getPermissions(), permission);
    }

    /**
     * 验证用户是否具有以下任意一个权限
     *
     * @param permissions 以 PERMISSION_NAMES_DELIMETER 为分隔符的权限列表
     * @return 用户是否具有以下任意一个权限
     */
    public boolean hasAnyPerm(String permissions) {
        if (StringUtils.isEmpty(permissions)) {
            return false;
        }
//        LoginUser loginUser = SecurityUtils.getLoginUser();
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getPermissions())) {
            return false;
        }
        Set<String> authorities = loginUser.getPermissions();
        for (String permission : permissions.split(PERMISSION_DELIMETER))
        {
            if (permission != null && hasPermissions(authorities, permission))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断是否包含权限
     *
     * @param permissions 权限列表
     * @param permission  权限字符串
     * @return 用户是否具备某权限
     */
    private boolean hasPermissions(Set<String> permissions, String permission) {
        return permissions.contains(ALL_PERMISSION) || permissions.contains(StringUtils.trim(permission));
    }

    @Override
    public void setFilterObject(Object filterObject) {
        this.filterObject = filterObject;
    }

    @Override
    public Object getFilterObject() {
        return this.filterObject;
    }

    @Override
    public void setReturnObject(Object returnObject) {
        this.returnObject = returnObject;
    }

    @Override
    public Object getReturnObject() {
        return this.returnObject;
    }

    @Override
    public Object getThis() {
        return this.target;
    }
}

Spring Security 中，MethodSecurityExpressionRoot 的配置是通过 DefaultMethodSecurityExpressionHandler 来完成的，现在我们自定义了 PermissionSecurityExpressionRoot， 所以，再来一个PermissionSecurityExpressionHandler类继承DefaultMethodSecurityExpressionHandler，如下：

/**
 * @author chenyunzhi
 * @description: 定义handler配置 PermissionSecurityExpressionRoot
 */
@Component
public class PermissionSecurityExpressionHandler extends DefaultMethodSecurityExpressionHandler {
    @Override
    protected MethodSecurityExpressionOperations createSecurityExpressionRoot(Authentication authentication, MethodInvocation invocation) {
        PermissionSecurityExpressionRoot root = new PermissionSecurityExpressionRoot(authentication);
        root.setTrustResolver(getTrustResolver());
        root.setPermissionEvaluator(getPermissionEvaluator());
        root.setRoleHierarchy(getRoleHierarchy());
        return root;
    }
}

然后就可以通过以下注解使用了

@PreAuthorize("hasPerm('com:user:add')")

三. 参考文章

如何在 Spring Security 中自定义权限表达式

security中文文档

作者：神的孩子都在歌唱
本人博客：https://blog.csdn.net/weixin_46654114
转载说明：务必注明来源，附带本人博客连接。