前言

最近在开发产品的过程中，须要将业务性能拆分成独立子系统，既能够独自应用也能够集成部署，这里就须要对框架进行扩大，反对用户对立治理与单点登陆。咱们的根底框架应用 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/

组织架构 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) {}}

框架内置同步接口

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

减少就是将传递过去的 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;
    }

同步工作

同步工作采纳的是 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;
    }

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

http://localhost:8061/smartau…

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";}
   }
  })
}

存储管制

前端必须应用 cookie 存储配置项与凭据能力实现跨域共享，留神凭据能够不设置工夫在 session 内无效即可，业务零碎 sso 配置及其他配置肯定要设置有效期，因为业务系统配置在登录页获取存储，不设置有效期，重定向到 sso 登录页会认定以后 session 完结革除 cookie 数据

操作控制

业务零碎在开启 sso 登陆的状态下，前端须要管制业务零碎组织架构只能查看，防止误操作导致数据的一致性问题