业务工具类

工具类列表

名称	作用
DictCache	数据字典缓存类
ConfigCache	系统配置
ResourceCache	资源管理
RoleCache	角色管理
ScopeDataCache	数据权限管理
TenantUtil	租户上下文
ThreadLocalParamUtil	用户上下文
InterfacesCache	第三方接口配置缓存类
InterfaceUtil	第三方接口调用

数据字典-DictCache

getDictValue

/**
 *@Description: 获取字典项名称
 * @param code: 字典编码
 * @param key: 字典项编码
 * @return: java.lang.String 具体字典项名称例如："男"
 **/
public String getDictValue(String code ,String key);

getDictKey

/**
 *@Description: 通过字典项的名称找字典项的key
 * @param code: 字典编码
 * @param name: 字典项名称
 * @return: java.lang.String 具体字典项值例如："1" 
 **/
public String getDictKey(String code,String name);

getOptionsByCode

    /**
 *@Description: 根据字典查询字典项内容
 * @param code: 编码
 * @return: java.util.Map<java.lang.String,java.lang.String> 
 **/
public Map<String, String> getOptionsByCode(String code);

返回值格式参考返回值-map对象

getOptionsListByCode

/**
*@Description: 根据字典查询字典项内容
* @param code: 编码
* @return: cn.hutool.json.JSONArray
 **/
public JSONArray getOptionsListByCode(String code);

返回值格式参考返回值-list对象

查询字典返回map对象

{
 "1": "男",
 "2": "女",
 "3": "其他"
}

查询字典返回list对象

[{
 "label": "男",
 "value": "1"
},
 "label": "女",
 "value": "2"
}]

系统配置-ConfigCache

getValueByCode

/**
*@Description: 根据配置编码查询配置值
* @param code: 编码
* @return: java.lang.String 具体系统项值 例如:"true"
 **/
public String getValueByCode(String code);

getValueById

/**
*@Description: 根据配置id查询配置值
* @param id: 主键id
* @return: java.lang.String 具体系统项值 例如:"true"
 **/
public String getValueById(String id);

资源管理-ResourceCache

getResourceByCode

/**
* 根据资源编码查询资源对象
* @param code 资源编码
* @return Resource 资源实体对象(Resource)
*/
public Resource getResourceByCode(String code);

getResourceById

/**
 * 根据资源主键id查询资源对象
 * @param id 资源id
 * @return Resource 资源实体对象(Resource)
 */
public Resource getResourceById(String id);

角色管理-RoleCache

getRoleByCode

/**
 * 根据角色编码查询角色对象
 * @param code 编码
 * @return 角色实体对象(Role)
 */
public Role getRoleByCode(String code);

getRoleById

/**
 * 根据角色主键id查询角色对象
 * @param roleId id
 * @return 角色实体对象(Role)
 */
public Role getRoleById(String roleId);

数据权限管理-ScopeDataCache

getScopeDataByCode

/**
 * 根据数据权限编码查询数据权限对象
 * @param code 编码
 * @return 数据权限实体对象(ScopeData)
 */
public ScopeData getScopeDataByCode(String code);

getScopeDataById

/**
 * 根据数据权限主键id查询数据权限对象
 * @param id 主键id
 * @return 数据权限实体对象(ScopeData)
 */
public ScopeData getScopeDataById(String id);

listScopeDataIdByRoleId

/**
 * 根据角色id获取数据权限id集合
 * @param roleId 角色id
 * @return List<String> roleId(角色id)
 */
public List<String> listScopeDataIdByRoleId(String roleId) 

租户上下文-TenantUtil

获取当前登录用户租户id可以通过如下方式。

isEnableTenant

/**
 * 判断是否启用多租户
 **/
public static boolean isEnableTenant() 

getTenantId

/**
 * 获取当前租户Id
 **/
public static String getTenantId();

用户上下文-ThreadLocalParamUtil

获取当前登录用户信息可以通过如下方式。

获取当前登录用户

/**
 * 获取用户登录名
 **/
public static String getAccountCode();


/**
 * 获取账号id
 * @return
 */
public static String getAccountId();


/**
 * 获取岗位id 多个以逗号分开 不支持简版
 * @return
 */
public static String getPostId();

/**
 * 获取岗位code 多个以逗号分开 不支持简版
 * @return
 */
public static String getPostCode();


/**
 * 获取当前登录用户
 **/
public static BaseUser getLoginUser()

/**
 * 获取登录用户的租户Id
 **/
public static String getTenantId()


/**
 * 获取岗位编码 不支持简版
 * @return
 */
public static String getPostCode()

/**
 * 获取业务单元ID 不支持简版
 * @return
 */
public static String getBuId() 

/**
 * 获取业务单元编码 不支持简版
 * @return
 */
public static String getBuCode() 

/**
 * 获取部门ID 
 * @return
 */
public static String getDeptId()

/**
 * 获取所有部门ID
 * @return
 */
public static String getAllDeptId() 
/**
 * 获取部门编码
 * @return
 */
public static String getDeptCode() 

/**
 * 获取所有部门编码
 * @return
 */
public static String getAllDeptCode() 

/**
 * 获取机构ID
 * @return
 */
public static String getOrgId() 

/**
 * 获取所有机构ID
 * @return
 */
public static String getAllOrgId() 

/**
 * 获取机构编码
 * @return
 */
public static String getOrgCode() 

/**
 * 获取所有机构编码
 * @return
 */
public static String getAllOrgCode() 

/**
 *  获取人员唯一标识
 * @Description
 * @return String
 */
public static String getPaPersonId()

判断是否为超管

/**
 * 是否为管理员用户
 *
 * @return boolean
 */
public static boolean isAdmin() ;

/**
 * 是否为管理员用户
 *
 * @return boolean
 */
public static boolean isAdmin(String loginName)

取当前登录用户的角色

BaseUser user = SecurityUtils.getLoginUser();
String postId = user.getPostId();
// 精简版、专业版获取方式
List<HosPermRole> roles = hosPostRoleService.getActivedRoleMsgByPostId(AccountUtil.getPostId());
// 简版获取方式
List<HosPermRole> hosPermRoleList = AccountRoleCache.me().getRoleByAccountId(AccountUtil.getAccountId());

第三方接口配置缓存-InterfacesCache

getByCode

/**
 * 获取接口配置对象
 * @param code 接口编码
 * @return Interfaces 接口配置对象
 **/
public Interfaces getByCode(String code);

/**
 * 接口配置对象类
 **/
public class Interfaces extends BaseEntity {

    @ApiModelProperty(value = "接口编码")
    private String code;

    @ApiModelProperty(value = "接口名称")
    private String name;

    @ApiModelProperty(value = "接口来源，所属分类。取字典编码")
    private String category;

    @ApiModelProperty(value = "接口类型。restful、soap")
    private String type;

    @ApiModelProperty(value = "接口方式。post、get")
    private String way;

    @ApiModelProperty(value = "协议。http、https")
    private String protocol;

    @ApiModelProperty(value = "api前缀。例如 192.168.100.3:8081")
    private String prefix;

    @ApiModelProperty(value = "接口地址")
    private String url;

    @ApiModelProperty(value = "方法名。接口类型为soap时，需要设置方法名")
    private String methodName;

    @ApiModelProperty(value = "命名空间")
    private String nameSpace;

    @ApiModelProperty(value = "SOAP标头参数结构")
    private String soapHeader;

    @ApiModelProperty(value = "结果数据节点")
    private String returnNode;

    @ApiModelProperty(value = "query参数")
    private String queryParams;

    @ApiModelProperty(value = "请求头参数")
    private String headerParams;

    @ApiModelProperty(value = "请求体body参数")
    private String bodyParams;

    @ApiModelProperty(value = "form-url参数")
    private String urlParams;

    @ApiModelProperty(value = "返回参数")
    private String returnParams;

    @ApiModelProperty(value = "假数据")
    private String fakeData;

    @ApiModelProperty(value = "超时响应时长。单位：秒")
    private Integer timeouts;

    @ApiModelProperty(value = "是否启用")
    private Boolean actived;

    @ApiModelProperty(value = "创建人主键" )
    private String createBy;

    @ApiModelProperty(value = "更新人主键")
    private String updateBy;

    @ApiModelProperty(value = "是否已删除")
    private Integer isDeleted;

}

第三方接口调用工具类-InterfaceUtil

提供第三方接口调用工具类，需结合第三方接口配置使用，详情参考第三方接口配置。

restful类接口调用

/**
 * rest执行方法
 * @param interfaceCode 接口编码
 * @param params param参数    自定或解析接口配置中的params结构来设定数据
 * @param body body参数   自定或解析接口配置中的body结构来设定数据
 * @param headers header参数   自定或解析接口配置中的header结构来设定数据
 * @return 接口返回值
 */
public static String executeRest(String interfaceCode, Map<String, ?> params, String body, Map<String, ?> headers);

/**
 * rest get方式params参数请求
 * @param interfaceCode 接口编码
 * @param params param参数
 * @return 接口返回值
 */
public static String executeRestByParams(String interfaceCode, Map<String, ?> params);

/**
 * rest 带header的get方式params参数请求
 * @param interfaceCode 接口编码
 * @param params param参数
 * @param headers header参数
 * @return 接口返回值
 */
public static String executeRestByParams(String interfaceCode, Map<String, ?> params, Map<String, ?> headers);

/**
 * rest post方式json字符串body参数请求
 * @param interfaceCode 接口编码
 * @param body body参数
 * @return 接口返回值
 */
public static String executeRestByBody(String interfaceCode, String body);

/**
 * rest 带header的post方式json字符串body参数请求
 * @param interfaceCode 接口编码
 * @param body body参数
 * @param headers header参数
 * @return 接口返回值
 */
public static String executeRestByBody(String interfaceCode, String body,  Map<String, ?> headers);

soap类接口调用

/**
 * soap方式调用。自拼接入参调用。
 * @param interfaceCode 接口编码
 * @param xmlSoapHeaderStr 手动拼接SOAPheader参数
 * @param xmlBodyStr 手动拼接body参数
 * @return soap接口返回值
 */
public static String executeSoap(String interfaceCode, String xmlSoapHeaderStr, String xmlBodyStr, Map<String, ?> headers);

/**
 * soap方式调用。自拼接入参调用。
 * @param interfaceCode 接口编码
 * @param xmlSoapHeaderStr 手动拼接SOAPheader参数
 * @param xmlBodyStr 手动拼接body参数
 * @return soap接口返回值转json字符串。不能转则为原值返回。
 */
public static String executeSoapReturnJson(String interfaceCode, String xmlSoapHeaderStr, String xmlBodyStr, Map<String, ?> headers);

/**
 * @param interfaceCode 接口编码
 * @param soapXml 完整入参
 * @return soap接口返回值
 */
public static String executeSoap(String interfaceCode, String soapXml, Map<String, ?> headers);

/**
 * @param interfaceCode 接口编码
 * @param soapXml 完整入参
 * @return soap接口返回值转json字符串。不能转则为原值返回。
 */
public static String executeSoapReturnJson(String interfaceCode, String soapXml, Map<String, ?> headers);

/**
 * 参数包装
 * @param xmlHeaderStr   header参数
 * @param xmlBodyStr    请求参数
 * @param method     方法名
 * @param namespace     命名空间
 * @return 返回值
 */
public static String splicingMessage(String xmlHeaderStr, String xmlBodyStr, String method, String namespace);

/**
* @param res 结果string
* @return 将soap返回结果转换为json字符串，如果数据不能转换则返回原值
*/
public static String xml2JsonStr(String res);
  

提示

接口配置提供接口的基本信息，如编码、地址、方法、应用系统等。同时提供出入参的配置，包含参数结构及各参数的信息。 如无需使用，请忽略以下提示信息。反之在使用时，每一类的参数信息均为json数组格式，开发人员可按其信息进行解析使用。结合以上接口调用工具类使用即可。

以下为参数结构信息的介绍：

Interfaces接口配置对象中用到的参数字段如下
    请求头参数（headerParams）、请求体参数（bodyParams）、params参数（queryParams）、form-url参数（urlParams）、返回参数（returnParams）
结构示例及说明：
    示例
        [{"paramKey":"root","name":"root","type":"","paramType":"Object","paramValue":"","id":1,"children":[]}]
    参数说明：
        paramKey：字段key（当key为root、type为空时表示该参数结构存在上下级关系，且root节点为参数结构的根节点，无需关注，解析使用其子节点即可。）
        name：字段名称。
        type：字段值类型。内置：fixed（固定值）、dynamic（动态值）、custom（自定义）
        paramType：参数值类型（String、Object、Int、Array等）除Array和Object之外类型的节点下无子节点。
        paramValue：值。当type为dynamic时，可根据value值获取相应的动态参数值。可详见【动态参数管理】的使用介绍。
        id：节点id。无实际意义。
        children：子级节点。为空数组时表示已无子节点。

调用示例

调用方式主要分为restful和soap（针对于webservice）。以下为用户登录安全组soap接口调用示例

基础配置

入参配置（可比对webservice的xml结构对比）

请求参数中
请求头: 即header配置。soap接口一般还需要配置SOAPAction（操作方法地址，可见截图）。
SOAP标头: 即报文内请求头。如果接口需要做调用身份校验的须在此配置用户名和密码（可见截图示例）。
请求体: 即请求入参结构。配置后可解析使用。

// 根据接口编码获取接口配置
HosSysInterfaces inObj = interfacesService.getByCode(code);
// 请求体是单独的表，需要转换为主表的json格式
getParams(interfaces);
// 取请求体入参配置
String bodyData = inObj.getBodyParams();
JSONArray bodyArr = new JSONArray(bodyData);

// 取请求头入参配置
String headData = inObj.getHeaderParams();
JSONArray heArr = new JSONArray(headData);

// soapHeader
String soapHeadStr = "";
String soapHeadData = inObj.getSoapHeader();
JSONArray soaHeArr = new JSONArray(soapHeadData);

// 请求头参数解析处理
Map<String, String> headers = this.getHeadersData(heArr);

// SOAP标头参数解析处理
soapHeadStr = this.recursionHeaderXml(soaHeArr);

// 请求体参数解析处理
String bodyStr = this.recursionBodyXml(bodyArr);

// 调用接口，返回xml。 如需直接返回xml转json可调用executeSoapReturnJson方法，详见工具类方法说明
String interData = InterfaceUtil.executeSoap(code, soapHeadStr, bodyStr, headers);

/**
 * 获取新的param数据
 *
 * @param interfaceObj
 */
public void getParams(Object interfaceObj) {
    String code = (String) ReflectUtil.getFieldValue(interfaceObj, "code");
    if (!CommonUtils.isEmpty(code)) {
        String queryParams = paramService.getParamsStr(code, ApiParamType.QUERY.getCode());
        ReflectUtil.setFieldValue(interfaceObj, "queryParams", queryParams);
        String headerParams = paramService.getParamsStr(code, ApiParamType.HEADER.getCode());
        ReflectUtil.setFieldValue(interfaceObj, "headerParams", headerParams);
        String bodyParams = paramService.getParamsStr(code, ApiParamType.BODY.getCode());
        ReflectUtil.setFieldValue(interfaceObj, "bodyParams", bodyParams);
        String urlParams = paramService.getParamsStr(code, ApiParamType.URL.getCode());
        ReflectUtil.setFieldValue(interfaceObj, "urlParams", urlParams);
        String returnParams = resultService.getParamsStr(code);
        ReflectUtil.setFieldValue(interfaceObj, "returnParams", returnParams);
    }
}

// 请求头header参数解析赋值
public Map<String, String> getHeadersData(JSONArray heArr) {
    Map<String, String> headers = new HashMap<>();
    for (Object pObj : heArr) {
        JSONObject parObj = new JSONObject(pObj);
        if (CommonUtils.isNotNull(parObj)) {
            if (CommonUtils.isNotNull(parObj.getStr("paramKey")) && CommonUtils.isNotEmpty(parObj.getStr("paramKey"))) {
                String value = parObj.getStr("paramValue");
                //动态参数取值
                if (CommonUtils.equals(parObj.getStr("type"), "dynamic") && CommonUtils.isNotEmpty(value)) {
                    value = dynamicParamsUtil.getValueByCode(value);
                }
                headers.put(parObj.getStr("paramKey"), value);
            }
        }
    }
    return headers;
}
// soap标头参数解析赋值
public String recursionHeaderXml(JSONArray ja) {
    StringBuilder ret = new StringBuilder();
    for (int i = 0; i < ja.size(); ++i) {
        JSONObject jo = ja.getJSONObject(i);
        String key = jo.getStr("paramKey");
        String type = jo.getStr("type");
        String value = jo.getStr("paramValue");
        String id = jo.getStr("id");
        JSONArray children = jo.getJSONArray("children");
        if (!CommonUtils.equals("root", key) && StringUtil.isNotBlank(type)) {
            ret.append("<").append(key);
            // 安全校验节点拼接
            if (CommonUtils.equals("Security", key)) {
                ret.append(" xmlns=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"");
            }
            ret.append(">");
        }
        if (CommonUtils.isNotEmpty(children)) {
            // 子级数据递归解析
            ret.append(recursionHeaderXml(children));
        } else if (!CommonUtils.equals("fixed", type) && !CommonUtils.equals("custom", type)) {
            if (CommonUtils.equals("dynamic", type)) {
                // 如果用到了动态参数 可使用动态参数工具类dynamicParamsUtil获取当前人的相关信息值
                String dynamicValue = dynamicParamsUtil.getValueByCode(value);
                ret.append(dynamicValue);
            }
        } else {
            // 固定值处理
            ret.append(value);
            // 自定业务处理
            ...
        }
        if (!CommonUtils.equals("root", key) && StringUtil.isNotBlank(type)) {
            ret.append("</").append(key).append(">\n");
        }
    }
    return ret.toString();
}
// 请求体参数解析赋值
public String recursionBodyXml(JSONArray ja) {
    StringBuilder ret = new StringBuilder();
    for (int i = 0; i < ja.size(); ++i) {
        JSONObject jo = ja.getJSONObject(i);
        String key = jo.getStr("paramKey");
        String type = jo.getStr("type");
        String value = jo.getStr("paramValue");
        String id = jo.getStr("id");
        JSONArray children = jo.getJSONArray("children");
        if (CommonUtils.isNotEmpty(children)) {
            if (!CommonUtils.equals("root", key) && StringUtil.isNotBlank(type)) {
                ret.append("<").append(key).append(">");
            }
            ret.append(recursionBodyXml(children));
            if (!CommonUtils.equals("root", key) && StringUtil.isNotBlank(type)) {
                ret.append("</").append(key).append(">\n");
            }
        } else {
            String newValue = value;
            if (!CommonUtils.equals("fixed", type) && !CommonUtils.equals("custom", type)) {
                if (CommonUtils.equals("dynamic", type)) {
                    newValue = dynamicParamsUtil.getValueByCode(value);
                }
            }
            // 自定业务处理，入参值传递示例
            ...
        }
    }
    return ret.toString();
}