前言

最近在开发产品的过程中，须要将业务性能拆分成独立子系统，既能够独自应用也能够集成部署，这里就须要对框架进行扩大，反对用户对立治理与单点登陆。咱们的根底框架应用redis实现token认证，所以只须要所有子系统共享redis数据就能够实现单点登陆，次要的难点是sso对立用户治理，咱们这里抉择的是通过监听sso平台组织架构的变动散发同步到各个子系统，这样子系统只依赖sso的登陆/登出/校验凭据三个接口，组织架构查问还是应用具体业务零碎数据。

方案设计

后端设计

后端设计如下图所示，次要蕴含利用/服务注册，组织架构同步，日志治理三大块

前端设计

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

计划实现

后端实现

注：表构造展现省略主键，增加工夫等通用字段

表结构设计

SSO_Application 利用信息

序号	列名	数据类型	长度	列阐明
1	AppName	varchar	100	利用名称
2	AppTag	varchar	100	利用标识
3	AppStatus	int	11	利用状态
4	SortNum	int	11	排序
5	AppAPIUrl	varchar	200	利用接口地址
6	AppType	int	11	利用类型
7	Remark	varchar	500	备注
8	AppWebsiteMainPageUrl	varchar	500	利用网站主页地址
9	AppManageMainPageUrl	varchar	500	利用治理主页地址

SSO_ApplicationPermission 利用权限信息

序号	列名	数据类型	长度	列阐明
1	AppGuid	varchar	50	利用Guid
2	PermissionType	int	11	权限类型
3	PermissionGuid	varchar	50	权限关联业务Guid

SSO_ApplicationService 应用服务

序号	列名	数据类型	长度	列阐明
1	ServiceName	varchar	100	服务名称
2	ServiceType	int	11	服务类别
3	ServiceRoute	varchar	200	服务路由
4	ServiceStatus	int	11	服务状态
5	AppGuid	varchar	50	利用Guid
6	Remark	varchar	500	备注

SSO_SyncDataSQL 同步数据SQL语句

序号	列名	数据类型	长度	列阐明
1	TableName	varchar	300	数据表
2	SyncStatus	int	11	同步状态
3	CommandType	varchar	50	操作类型
4	CommandText	varchar	1000	操作语句

SSO_SyncDataTask 同步数据工作

序号	列名	数据类型	长度	小数位	列阐明
1	TaskName	varchar	500		工作名称
2	TaskStatus	int	11		工作状态
3	FinishDate	varchar	100		实现工夫
4	TaskContent	varchar	500		工作内容
5	TaskFinishPeroid	decimal	18	2	工作实现时常
6	TaskSQLJson	ntext	0		工作SQL语句Json
7	StartDate	varchar	11		开始工夫

SSO_SyncDataTaskItem 同步数据工作子表

序号	列名	数据类型	长度	小数位	列阐明
1	TaskID	varchar	50		工作ID
2	TaskItemStatus	int	11		工作状态
3	FinishDate	varchar	100		实现工夫
4	AppGuid	varchar	50		利用Guid
5	TaskItemFinishPeroid	decimal	18	2	工作实现时长
6	StartDate	varchar	11		开始工夫
7	AppName	varchar	300		利用名称
8	ExecuteInfo	ntext	0		执行信息

SSO_SyncDataLog 同步数据日志

序号	列名	数据类型	长度	小数位	列阐明
1	SyncType	int	11		同步类型
2	SyncContent	varchar	500		同步内容
3	StartDate	varchar	100		开始工夫
4	FinishDate	varchar	100		完结工夫
5	FinishPeroid	decimal	18	2	同步时长

相干配置

配置次要是用于业务零碎灵便切换是否集成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登陆的状态下，前端须要管制业务零碎组织架构只能查看，防止误操作导致数据的一致性问题