接口和方法信息注册

VO和接口信息

@Data
@Schema(description = "接口和方法 ReqVO")
public class InterfaceMethodSaveReqVO {
    @Schema(description = "服务URL")
    private String serverUrl;
    @Schema(description = "安全key")
    private String safeKey;
    @Schema(description = "安全密钥")
    private String safeSecret;
    @Schema(description = "接口名称")
    private String interfaceName;
    @Schema(description = "接口方法信息")
    private List<MethodSaveDomain> methods;
}

@Data
@Schema(description = "接口方法信息")
public class MethodSaveDomain {
    @Schema(description = "方法名称")
    private String methodName;
    @Schema(description = "参数类型")
    private String parameterType;
    @Schema(description = "方法路径")
    private String url;
    @Schema(description = "是否需要认证")
    private Integer isAuth;
    @Schema(description = "是否是http请求")
    private Integer isHttp;
    @Schema(description = "http请求类型")
    private String httpType;
}

接口和方法注册

@Override
@Transactional(rollbackFor = Exception.class)
public String create(InterfaceMethodSaveReqVO reqVO) {
    log.info("开始创建接口及其方法，请求参数: {}", reqVO);

    String safeKey = reqVO.getSafeKey();
    String safeSecret = reqVO.getSafeSecret();
    String serverId = gatewayServerMapper.getIdBySafeKey(safeKey);
    if (serverId == null) {
        log.error("创建接口失败，服务不存在，safeKey: {}", safeKey);
        throw new RuntimeException("该服务不存在");
    }

    GatewayServerDO serverDO = gatewayServerMapper.selectById(serverId);
    if (serverDO.getStatus().equals(StatusEnum.DISABLE.getValue())) {
        log.error("创建接口失败，服务已下线，serverId: {}", serverId);
        throw new RuntimeException("该服务已下线");
    }
    if (!serverDO.getSafeSecret().equals(safeSecret)) {
        log.error("创建接口失败，安全密钥错误，serverId: {}", serverId);
        throw new RuntimeException("安全密钥错误");
    }

    GatewayInterfaceDO selectedOne = gatewayInterfaceMapper.selectOne(new LambdaQueryWrapper<GatewayInterfaceDO>()
            .eq(GatewayInterfaceDO::getInterfaceName, reqVO.getInterfaceName())
            .last("limit 1"));

    GatewayInterfaceDO interfaceDO = new GatewayInterfaceDO();
    interfaceDO.setId(selectedOne == null ? uniqueIdUtil.nextId() : selectedOne.getId());
    interfaceDO.setServerId(serverId);
    interfaceDO.setInterfaceName(reqVO.getInterfaceName());

    if (selectedOne == null) {
        log.debug("新增接口信息，interfaceName: {}", reqVO.getInterfaceName());
        gatewayInterfaceMapper.insert(interfaceDO);
    } else {
        log.debug("更新接口信息，interfaceId: {}", interfaceDO.getId());
        gatewayInterfaceMapper.updateById(interfaceDO);
    }
  
    // 处理方法信息
    for (MethodSaveDomain method : reqVO.getMethods()) {
        GatewayMethodDO methodDO = new GatewayMethodDO();
        GatewayMethodDO gatewayMethodDO = gatewayMethodMapper.selectOne(new LambdaQueryWrapper<GatewayMethodDO>()
                .eq(GatewayMethodDO::getMethodName, method.getMethodName())
                .eq(GatewayMethodDO::getInterfaceId, interfaceDO.getId())
                .eq(GatewayMethodDO::getParameterType, method.getParameterType())
                .last("limit 1"));

        methodDO.setInterfaceId(interfaceDO.getId());
        methodDO.setMethodName(method.getMethodName());
        methodDO.setParameterType(method.getParameterType());
        methodDO.setUrl(method.getUrl());
        methodDO.setIsAuth(method.getIsAuth());
        methodDO.setIsHttp(method.getIsHttp());
        methodDO.setHttpType(method.getHttpType());

        try {
            if (gatewayMethodDO == null) {
                methodDO.setId(uniqueIdUtil.nextId());
                log.debug("新增方法信息，methodName: {}, interfaceId: {}", method.getMethodName(), interfaceDO.getId());
                gatewayMethodMapper.insert(methodDO);
            } else {
                methodDO.setId(gatewayMethodDO.getId());
                log.debug("更新方法信息，methodId: {}", methodDO.getId());
                gatewayMethodMapper.updateById(methodDO);
            }
        } catch (Exception e) {
            log.error("方法参数为空，interfaceId: {}, method: {}", interfaceDO.getId(), method);
            throw new RuntimeException("方法部分参数为空");
        }
    }

    // 异步注册服务和方法
    executor.submit(() -> {
        log.info("开始异步注册服务和方法，serverId: {}, interfaceId: {}", serverId, interfaceDO.getId());
        registerMethod(serverDO.getServerName(), interfaceDO.getInterfaceName(), reqVO.getMethods());
        registerService(reqVO, serverId);
    });

    log.info("成功创建接口及其方法，interfaceId: {}", interfaceDO.getId());
    return interfaceDO.getId();
}

信息注册和接口保存

    /**
     * 注册方法到Redis缓存
     *
     * @param serverName    服务名称
     * @param interfaceName 接口名称
     * @param methods       方法列表
     */
    private void registerMethod(String serverName, String interfaceName, List<MethodSaveDomain> methods) {
        log.debug("开始注册方法到Redis，serverName: {}, interfaceName: {}", serverName, interfaceName);
        for (MethodSaveDomain method : methods) {
            Map<String, Object> params = new HashMap<>();
            params.put("interfaceName", interfaceName);
            params.put("methodName", method.getMethodName());
            params.put("parameterType", method.getParameterType());
            params.put("isAuth", method.getIsAuth());
            params.put("isHttp", method.getIsHttp());
            params.put("httpType", method.getHttpType());

            String redisKey = "URL:" + serverName + ":" + method.getUrl();
            redisTemplate.opsForHash().putAll(redisKey, params);
            log.debug("成功注册方法到Redis，key: {}", redisKey);
        }
    }

    /**
     * 注册服务到Redis缓存
     *
     * @param reqVO    接口方法保存请求VO
     * @param serverId 服务ID
     */
    private void registerService(InterfaceMethodSaveReqVO reqVO, String serverId) {
        log.debug("开始注册服务到Redis，serverId: {}", serverId);
        String serverUrl = reqVO.getServerUrl();
        GatewayServerDetailDO detailDO = gatewayServerDetailMapper.selectOne(new LambdaQueryWrapper<GatewayServerDetailDO>()
                .eq(GatewayServerDetailDO::getServerAddress, serverUrl)
                .last("limit 1"));

        if (detailDO == null) {
            log.debug("新增服务详情，serverUrl: {}", serverUrl);
            detailDO = new GatewayServerDetailDO();
            detailDO.setId(uniqueIdUtil.nextId());
            detailDO.setStatus(StatusEnum.ENABLE.getValue());
            detailDO.setServerAddress(serverUrl);
            detailDO.setServerId(serverId);
            gatewayServerDetailMapper.insert(detailDO);
        } else {
            log.debug("更新服务详情，detailId: {}", detailDO.getId());
            detailDO.setStatus(StatusEnum.ENABLE.getValue());
            detailDO.setServerId(serverId);
            gatewayServerDetailMapper.updateById(detailDO);
        }

        redisPubUtil.ServerFlush();
        redisPubUtil.heartBeat();
        log.debug("成功注册服务到Redis并发送心跳，serverId: {}", serverId);
    }