待写...



### 1、认识 solon-security-auth 插件

[solon-security-auth](/article/109) 的定位是，只做认证控制。侧重对验证结果的适配，及在此基础上的统一控制和应用。功能会少，但适配起来不会晕。同时支持规则控制和注解控制两种方案，各有优缺点，也可组合使用：

* 规则控制，适合在一个地方进行整体的宏观控制
* 注解控制，方便在细节处精准把握

### 2、开始适配，完成3步动作即可

* 第1步，构建一个认证适配器（可以和其它异常处理合并一个过滤器）

```java
@Configuration
public class Config {
    @Bean(index = 0) //如果与别的过滤器冲突，可以按需调整顺序位
    public AuthAdapter init() {
        //
        // 构建适配器
        //
        return new AuthAdapter()
                .loginUrl("/login") //设定登录地址，未登录时自动跳转（如果不设定，则输出401错误）
                .addRule(r -> r.include("**").verifyIp().failure((c, t) -> c.output("你的IP不在白名单"))) //添加规则
                .addRule(b -> b.exclude("/login**").exclude("/run/**").verifyPath()) //添加规则
                .processor(new AuthProcessorImpl()) //设定认证处理器
                .failure((ctx, rst) -> { 
                    ctx.render(rst); //设定默认的验证失败处理；也可通过过滤器捕捉异常的方式处理
                });
    }
}

//规则配置说明
//1.include(path) 规则包函的路径范围，可多个
//2.exclude(path) 规则排除的路径池围，可多个
//3.failure(..)   规则失则后的处理
//4.verifyIp()... 规则要做的验证方案（可多个不同的验证方案）

```

* 第2步，认证异常处理（通过过滤器捕捉异常）

```java
//可以和其它异常处理合并一个过滤器
@Component
public class DemoFilter implements Filter {
    @Override
    public void doFilter(Context ctx, FilterChain chain) throws Throwable {
        try {
            chain.doFilter(ctx);
        } catch (AuthException e) {
            AuthStatus status = e.getStatus();
            ctx.render(Result.failure(status.code, status.message));
        }
    }
}
```




* 第3步，实现一个认证处理器 

先了解一下 AuthProcessor 的接口，它对接的是一系列的验证动作结果。可能用户得自己也得多干点活，但很直观。

```java
//认证处理器
public class AuthProcessorImpl implements AuthProcessor {

    @Override
    public boolean verifyIp(String ip) {
        //验证IP，是否有权访问
    }

    @Override
    public boolean verifyLogined() {
        //验证登录状态，用户是否已登录
    }

    @Override
    public boolean verifyPath(String path, String method) {
        //验证路径，用户可访问
    }

    @Override
    public boolean verifyPermissions(String[] permissions, Logical logical) {
        //验证特定权限，用户是否有权限（verifyLogined 为 true，才会触发）
    }

    @Override
    public boolean verifyRoles(String[] roles, Logical logical) {
        //验证特定角色，用户是否有角色（verifyLogined 为 true，才会触发）
    }
}
```

现在做一次适配实战，用的是一份生产环境的代码：

```java
public class GritAuthProcessor implements AuthProcessor {
    /**
     * 获取主体Id
     * */
    protected long getSubjectId() {
        return SessionBase.global().getSubjectId();
    }

    /**
     * 获取主体显示名
     */
    protected String getSubjectDisplayName() {
        return SessionBase.global().getDisplayName();
    }

    @Override
    public boolean verifyIp(String ip) {
        //安装模式，则忽略
        if (Solon.cfg().isSetupMode()) {
            return true;
        }

        long subjectId = getSubjectId();

        if (subjectId > 0) {
            String subjectDisplayName = getSubjectDisplayName();
            Context ctx = Context.current();

            if (ctx != null) {
                //old
                ctx.attrSet("user_puid", String.valueOf(subjectId));
                ctx.attrSet("user_name", subjectDisplayName);
                //new
                ctx.attrSet("user_id", String.valueOf(subjectId));
                ctx.attrSet("user_display_name", subjectDisplayName);
            }
        }

        //非白名单模式，则忽略
        if (Solon.cfg().isWhiteMode() == false) {
            return true;
        }

        return CloudClient.list().inListOfClientAndServerIp(ip);
    }

    @Override
    public boolean verifyLogined() {
        //安装模式，则忽略
        if (Solon.cfg().isSetupMode()) {
            return true;
        }

        return getSubjectId() > 0;
    }

    @Override
    public boolean verifyPath(String path, String method) {
        //安装模式，则忽略
        if (Solon.cfg().isSetupMode()) {
            return true;
        }

        try {
            if (GritClient.global().resource().hasResourceByUri(path) == false) {
                return true;
            } else {
                return GritClient.global().auth().hasUri(getSubjectId(), path);
            }
        } catch (SQLException e) {
            throw new GritException(e);
        }
    }

    @Override
    public boolean verifyPermissions(String[] permissions, Logical logical) {
        long subjectId = getSubjectId();

        try {
            if (logical == Logical.AND) {
                boolean isOk = true;

                for (String p : permissions) {
                    isOk = isOk && GritClient.global().auth().hasPermission(subjectId, p);
                }

                return isOk;
            } else {
                for (String p : permissions) {
                    if (GritClient.global().auth().hasPermission(subjectId, p)) {
                        return true;
                    }
                }
                return false;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public boolean verifyRoles(String[] roles, Logical logical) {
        long subjectId = getSubjectId();

        try {
            if (logical == Logical.AND) {
                boolean isOk = true;

                for (String r : roles) {
                    isOk = isOk && GritClient.global().auth().hasRole(subjectId, r);
                }

                return isOk;
            } else {
                for (String r : roles) {
                    if (GritClient.global().auth().hasRole(subjectId, r)) {
                        return true;
                    }
                }
                return false;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
```


### 3、三种应用方式（一般组合使用）


刚才我们算是适配好了，现在就应用的活了。


* 第1种，在 AuthAdapter 直接配置所有规则，或部分规则（也可以不配）

```java
//参考上面的适配器 addRule(...)
```

配置的好处是，不需要侵入业务代码；同时在统一的地方，宏观可见；但容易忽略掉细节。

* 第2种，基于注解做一部份（一般特定权限 或 特定角色时用）

```java
@Mapping("/demo/agroup")
@Controller
public class AgroupController {
    @Mapping("")
    public void home() {
        //agroup 首页
    }
    
    @AuthPermissions("agroup:edit") //需要特定权限
    @Mapping("edit/{id}")
    public void edit(int id) {
        //编辑显示页，需要编辑权限
    }

    @AuthRoles("admin")  //需要特定角色
    @Mapping("edit/{id}/ajax/save")
    public void save(int id) {
        //编辑处理接口，需要管理员权限
    }
}
```

* 第3种，应用于后端模板（支持所有已适配的模板）

关于模板标鉴控制权限的示例，可参考[https://gitee.com/opensolon/solon-examples/tree/main/3.Solon-Web/demo3031-auth](https://gitee.com/opensolon/solon-examples/tree/main/3.Solon-Web/demo3031-auth)

```xml
<@authPermissions name="user:del">
我有user:del权限
</@authPermissions>

<@authRoles name="admin">
我有admin角色
</@authRoles>
```

注解的好处是，微观可见，在一个方法上就可以看到它需要什么权限或角色，不容易忽略。

* 组合使用方式

一般，用`配置规则`，控制所有需要登录的地址；用`注解`，控制特定的权限或角色。