SpringBoot实现用户统一管理与单点登陆_springmvc 和springboot两个工程统一登录

前言

最近在开发产品的过程中，需要将业务功能拆分成独立子系统，既可以单独使用也可以集成部署，这里就需要对框架进行扩展，支持用户统一管理与单点登陆。我们的基础框架使用redis实现token认证，所以只需要所有子系统共享redis数据就可以实现单点登陆，主要的难点是sso统一用户管理，我们这里选择的是通过监听sso平台组织架构的变动分发同步到各个子系统，这样子系统只依赖sso的登陆/登出/校验凭据三个接口，组织架构查询还是使用具体业务系统数据。

方案设计

后端设计

后端设计如下图所示，主要包含应用/服务注册，组织架构同步，日志管理三大块

前端设计

前端设计如下图所示，主要包括cookie跨域共享，鉴权流程

方案实现

后端实现

注：表结构展示省略主键，添加时间等通用字段

表结构设计

SSO_Application 应用信息

SSO_ApplicationPermission 应用权限信息

SSO_ApplicationService 应用服务

SSO_SyncDataSQL 同步数据SQL语句

SSO_SyncDataTask 同步数据任务

SSO_SyncDataTaskItem 同步数据任务子表

SSO_SyncDataLog 同步数据日志

相关配置

配置主要是用于业务系统灵活切换是否集成sso

sso_apptag代表sso系统唯一标识，每个业务系统的appTag是不一样的，token生成前缀也是根据appTag来的，可以从后端避免一个浏览器登陆多个系统（同一个redis库的情况下）导致用户信息覆盖的问题，当开启sso登陆后，业务系统只认证sso管理系统对应appTag（即配置中的sso_apptag）的凭据，屏蔽本身业务系统认证功能

  #sso
  #sso状态 0:关闭 1：打开
  sso_status: 0
  #sso系统标识
  sso_apptag: haopansso
  #sso统一认证地址(管理)
  sso_loginpage_manage: http://localhost:8091/haopansso/login.html
  #sso统一认证地址(网站)
  sso_loginpage_website: http://localhost:8091/haopansso/login.html
  #sso统一认证接口地址
  sso_api_url: http://localhost:8091/
1
2
3
4
5
6
7
8
9
10
11

组织架构SQL语句拦截

系统和数据库交互使用的是mybatis，所以可以通过mybaits的拦截器实现针对指定表统一拦截

Intercepts标注update标识拦截增/删/改操作

@Intercepts({@Signature(type = Executor.class,method = "update",args = {MappedStatement.class,Object.class})})
public class SSOSQLInterceptor implements Interceptor {

    private ISyncDataSQLService syncDataSQLService;

    public SSOSQLInterceptor(ISyncDataSQLService _syncDataSQLService){
        syncDataSQLService = _syncDataSQLService;
    }

    /**
     * 正则匹配 insert、delete、update操作
     */
    private static final String REGEX = ".*insert\\\\u0020.*|.*delete\\\\u0020.*|.*update\\\\u0020.*";

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        String sqlId = mappedStatement.getId();
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        Object parameter = invocation.getArgs()[1];
        BoundSql boundSql = mappedStatement.getBoundSql(parameter); // BoundSql就是封装myBatis最终产生的sql类
        String sql = boundSql.getSql();
        if(sql.toLowerCase().contains("f_tenant") || sql.toLowerCase().contains("f_dept") || sql.toLowerCase().contains("f_users")){
            // 格式化Sql语句，去除换行符，替换参数
            Configuration configuration = mappedStatement.getConfiguration(); // 获取节点的配置
            sql = getSql(configuration, boundSql, sqlId); // 获取到最终的sql语句
            //插入数据库
            String parseSQL = SQLUtils.format(sql, JdbcConstants.MYSQL);
            List<SQLStatement> sqlStatementList =  SQLUtils.parseStatements(sql, parseSQL);
            for (SQLStatement sqlStatement:sqlStatementList) {
                MySqlSchemaStatVisitor visitor = new MySqlSchemaStatVisitor();
                sqlStatement.accept(visitor);
                String tableName = visitor.getTables().keySet().toArray()[0].toString();
                boolean record = false;
                if(tableName.toLowerCase().equals("f_tenant") ){
                    record = true;
                }else if(tableName.toLowerCase().equals("f_dept")){
                    record = true;
                }else if(tableName.toLowerCase().equals("f_users")){
                    record = true;
                }
                if(record){
                    System.out.println("CommandType：[" + sqlCommandType + "]" + CommonUtil.getNewLine() +"SQL：[" + parseSQL + "]");
                    SyncDataSQLDO entity = new SyncDataSQLDO();
                    entity.setTableName(tableName);
                    entity.setCommandType(sqlCommandType.name());
                    entity.setCommandText(parseSQL);
                    syncDataSQLService.insert(entity);
                }

            }


        }
        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}
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

框架内置同步接口

为实现业务系统快速对接与对接标准化，在框架内置了增量/全量同步的两个接口

增加就是将传递过来的sql语句按顺序执行

全量就是删除本地组织架构数据，将传递的全量数据重新插入

 @ResponseBody
    @PostMapping("/syncOrganizationIncrementData")
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.READ_UNCOMMITTED)
    //组织架构增量同步
    public Object syncOrganizationIncrementData(@RequestBody List<SSO_IncrementModel> dataList) {
        Result result = Result.okResult();
        if(frameConfig.getSso_status().equals("0")){
            return Result.errorResult().setMsg("系统未开启sso，禁止同步组织架构");
        }
        StringBuilder builder = new StringBuilder();
        try {
            for (SSO_IncrementModel entity : dataList) {
                commonDTO.executeSQL(entity.getCommandText(), new HashMap<>(), false);
                builder.append("【tableName】：" + entity.getTableName() + CommonUtil.getNewLine());
                builder.append("【commandType】：" + entity.getCommandType() + CommonUtil.getNewLine());
                builder.append("【commandText】：" + entity.getCommandText() + CommonUtil.getNewLine());
            }
            builder.append("执行组织架构增量同步成功" + CommonUtil.getNewLine());
        } catch (Exception e) {
            builder.append("执行组织架构增量同步失败" + CommonUtil.getNewLine());
            builder.append("【异常信息】：" + CommonUtil.getExceptionString(e) + CommonUtil.getNewLine());
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return Result.errorResult();
        } finally {
            builder.append("=========================================================================" + CommonUtil.getNewLine());
            LogUtil.writeLog("sso/syncOrganizationIncrementData", "log", builder.toString());
        }
        return result;
    }

    @ResponseBody
    @PostMapping("/syncOrganizationTotalData")
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.READ_UNCOMMITTED)
    //组织架构全量同步
    public Object syncOrganizationTotalData(@RequestBody SSO_OrganizationTotalModel entity) {
        Result result = Result.okResult();
        StringBuilder builder = new StringBuilder();
        if(frameConfig.getSso_status().equals("0")){
            return Result.errorResult().setMsg("系统未开启sso，禁止同步组织架构");
        }
        try{
            if (entity.getTenantDOList().size() > 0) {
                String sql = "delete from f_tenant";
                commonDTO.executeSQL(sql, new HashMap<>(), false);
                for (F_TenantDO tenantDO : entity.getTenantDOList()) {
                    tenantService.insert(tenantDO);
                }
                builder.append("【同步f_tenent数量】:" + entity.getTenantDOList().size() + CommonUtil.getNewLine());
            }
            if (entity.getDeptDOList().size() > 0) {
                String sql = "delete from f_dept";
                commonDTO.executeSQL(sql, new HashMap<>(), false);
                for (F_DeptDO deptDO : entity.getDeptDOList()) {
                    deptService.insert(deptDO);
                }
                builder.append("【同步f_dept数量】:" + entity.getDeptDOList().size() + CommonUtil.getNewLine());
            }
            if (entity.getUsersDOList().size() > 0) {
                String sql = "delete from f_users";
                commonDTO.executeSQL(sql, new HashMap<>(), false);
                for (F_UsersDO usersDO : entity.getUsersDOList()) {
                    usersService.insert(usersDO);
                }
                builder.append("【同步f_users数量】:" + entity.getUsersDOList().size() + CommonUtil.getNewLine());
            }
            builder.append("执行组织架构全量同步成功" + CommonUtil.getNewLine());

        }catch (Exception e){
            builder.append("执行组织架构全量同步失败" + CommonUtil.getNewLine());
            builder.append("【异常信息】：" + CommonUtil.getExceptionString(e) + CommonUtil.getNewLine());
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return Result.errorResult();
        }finally {
            builder.append("=========================================================================" + CommonUtil.getNewLine());
            LogUtil.writeLog("sso/syncOrganizationTotalData", "log", builder.toString());
        }
        return result;
    }
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

同步任务

同步任务采用的是quartz定时任务扫描变动的sql来进行增量同步，因为可能涉及到多个平台同时同步，就需要考虑执行效率，这里使用了spring中的异步任务功能

1.启动类添加注解@EnableAsync

2.异步请求方法添加注解@Async

3.因为执行的是扫描任务，扫描所有未同步的sql语句，所以单次任务必须等待所有平台同步完成后再执行下一次扫描，异步任务需要返回CompletableFuture对象，并在所有任务执行代码后加上CompletableFuture.allOf(任务对象).join();进行统一等待

4.quartz任务需要加上@DisallowConcurrentExecution注解，保证上一个任务执行完后，再去执行下一个任务

前端实现

登陆控制

登陆页调用配置接口，获取sso配置相关信息

    @PostMapping("/getLoginPageNeedConfigParam")
    @ResponseBody
    public Object getLoginPageNeedConfigParam(@RequestBody Map<String, Object> params) {
        R result = R.ok();
        result.put("version",frameConfig.getFrameStaticFileVersion());
        result.put("systemName",systemName);
        result.put("appTag",appTag);
        result.put("sso_status",frameConfig.getSso_status());
        result.put("sso_loginpage_manage",frameConfig.getSso_loginpage_manage());
        result.put("sso_loginpage_website",frameConfig.getSso_loginpage_website());
        result.put("sso_api_url",frameConfig.getSso_api_url());
        result.put("sso_apptag",frameConfig.getSso_apptag());
        return result;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

如果开启了单点登录，则重定向到sso统一登陆页面并携带业务系统跳转标识appTag，代码中的prefix指的就是业务系统appTag，最终重定向地址示例如下：

http://localhost:8061/smartaudit-sso/login.html?appTag=smartaudit-projectmanage&authFrom=manage

authFrom参数代表是网站还是后台管理，因为登陆成功需要根据来源不同跳转不同主页

 bindFrameConfig: function() {
     var page = this;
     JsonAjax(JSON.stringify({}), configUrl, function(result, status) {
         if (result.code == 0) {
             var ssosetting = {
               appTag: result.appTag,
               sso_status: result.sso_status,            
               sso_loginpage_manage: result.sso_loginpage_manage,           
               sso_loginpage_website: result.sso_loginpage_website,
               sso_api_url: result.sso_api_url,
               sso_apptag: result.sso_apptag
        }
       $.cookie(prefix + "_sso", JSON.stringify(ssosetting),{path:"/",expires:7})
       $.cookie(prefix + "_version", result.version,{path:"/",expires:7})
       page.systemName = result.systemName;
        if (ssosetting.sso_status == "1") {
           window.location.href = ssosetting.sso_loginpage_manage + "?appTag=" + ssosetting.appTag + "&authFrom=manage";
        }
   }
  })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

存储控制

前端必须使用cookie存储配置项与凭据才能实现跨域共享，注意凭据可以不设置时间在session内有效即可，业务系统sso配置及其他配置一定要设置有效期，因为业务系统配置在登录页获取存储，不设置有效期，重定向到sso登录页会认定当前session结束清除cookie数据

操作控制

业务系统在开启sso登陆的状态下，前端需要控制业务系统组织架构只能查看，避免误操作导致数据的一致性问题