SpringBoot實現用戶統一管理與單點登陸

前言

最近在開發產品的過程中，需要將業務功能拆分成獨立子系統，既可以單獨使用也可以集成部署，這里就需要對框架進行擴展，支持用戶統一管理與單點登陸。我們的基礎框架使用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/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";
        }
   }
  })
}

存儲控制

前端必須使用cookie存儲配置項與憑據才能實現跨域共享，注意憑據可以不設置時間在session內有效即可，業務系統sso配置及其他配置一定要設置有效期，因為業務系統配置在登錄頁獲取存儲，不設置有效期，重定向到sso登錄頁會認定當前session結束清除cookie數據

操作控制

業務系統在開啟sso登陸的狀態下，前端需要控制業務系統組織架構只能查看，避免誤操作導致數據的一致性問題