【Apollo】【二】发布配置的过程-Portal 发布配置

1  前言

上节我们看了下我们服务启动的时候，首次去加载配置的过程，那么这节来开始看看当我们在 Apollo上配置变更的时候，我们的服务又是如何一步一步的热更新掉的呢，也就是实时更新。

2  配置发布过程

我们先了解下，当我们发布一个配置时，Apollo是如何运转的：

上图简要描述了配置发布的大致过程：

1. 用户在 Portal 操作配置发布
2. Portal 调用 Admin Service 的接口操作发布
3. Admin Service 发布配置后，发送 ReleaseMessage （注意这里不是说像MQ似的发消息，而是数据库间隔轮询的）给各个Config Service
4. Config Service 收到 ReleaseMessage 后，通知对应的客户端

3  Portal 发布配置

知道了配置的一个变更过程，这节我们先来看看Portal 发布配置：

3.1  相关实体

3.1.1  Release

com.ctrip.framework.apollo.biz.entity.Release ，继承 BaseEntity 抽象类，Release 实体。代码如下：

@Entity
@Table(name = "Release")
@SQLDelete(sql = "Update Release set isDeleted = 1 where id = ?") // 标记删除
@Where(clause = "isDeleted = 0")
public class Release extends BaseEntity {

    /**
     * Release Key
     *
     * 【TODO 6006】用途？
     */
    @Column(name = "ReleaseKey", nullable = false)
    private String releaseKey;
    /**
     * 标题
     */
    @Column(name = "Name", nullable = false)
    private String name;
    /**
     * 备注
     */
    @Column(name = "Comment", nullable = false)
    private String comment;
    /**
     * App 编号  就是我们的服务名称 比如stock-center库存服务   order-center订单服务
     */
    @Column(name = "AppId", nullable = false)
    private String appId;
    /**
     * Cluster 名字  集群
     */
    @Column(name = "ClusterName", nullable = false)
    private String clusterName;
    /**
     * Namespace 名字  就是配置比如 application  application-datasource application-mybatis等
     */
    @Column(name = "NamespaceName", nullable = false)
    private String namespaceName;
    /**
     * 配置 Map 字符串，使用 JSON 格式化成字符串  发布时的完整配置 Map 字符串
     */
    @Column(name = "Configurations", nullable = false)
    @Lob
    private String configurations;
    /**
     * 是否被回滚（放弃）
     */
    @Column(name = "IsAbandoned", columnDefinition = "Bit default '0'")
    private boolean isAbandoned;
}

3.1.2  ReleaseHistory

com.ctrip.framework.apollo.biz.entity.ReleaseHistory ，继承 BaseEntity 抽象类，ReleaseHistory 实体，记录每次 Release 相关的操作日志。代码如下：

@Entity
@Table(name = "ReleaseHistory")
@SQLDelete(sql = "Update ReleaseHistory set isDeleted = 1 where id = ?") // 标记删除
@Where(clause = "isDeleted = 0")
public class ReleaseHistory extends BaseEntity {

    /**
     * App 编号
     */
    @Column(name = "AppId", nullable = false)
    private String appId;
    /**
     * Cluster 名字
     */
    @Column(name = "ClusterName", nullable = false)
    private String clusterName;
    /**
     * Namespace 名字
     */
    @Column(name = "NamespaceName", nullable = false)
    private String namespaceName;
    /**
     * Branch 名
     *
     * 主干，使用 Cluster 名字
     * 分支，使用子 Cluster 名字
     */
    @Column(name = "BranchName", nullable = false)
    private String branchName;
    /**
     * Release 编号
     */
    @Column(name = "ReleaseId")
    private long releaseId;
    /**
     * 上一次 Release 编号
     */
    @Column(name = "PreviousReleaseId")
    private long previousReleaseId;
    /**
     * 操作类型 {@link com.ctrip.framework.apollo.common.constants.ReleaseOperation}
     */
    @Column(name = "Operation")
    private int operation;
    /**
     * 操作 Context
     */
    @Column(name = "OperationContext", nullable = false)
    private String operationContext;
    
}

• appId + clusterName + namespaceName 字段，指向对应的 Namespace 记录。

• branchName 字段，Branch 名字。

  • 主干，使用 Cluster 名字。
  • 分支，使用子 Cluster 名字。

• releaseId 字段，Release 编号。

• previousReleaseId 字段，上一次 Release 编号。

• operation 类型，操作类型。在 com.ctrip.framework.apollo.common.constants.ReleaseOperation 类中，枚举了所有发布相关的操作类型。代码如下：

public interface ReleaseOperation {

    int NORMAL_RELEASE = 0; // 主干发布
    int ROLLBACK = 1; // 回滚
    int GRAY_RELEASE = 2; // 灰度发布
    int APPLY_GRAY_RULES = 3; //
    int GRAY_RELEASE_MERGE_TO_MASTER = 4;
    int MASTER_NORMAL_RELEASE_MERGE_TO_GRAY = 5;
    int MATER_ROLLBACK_MERGE_TO_GRAY = 6;
    int ABANDON_GRAY_RELEASE = 7;
    int GRAY_RELEASE_DELETED_AFTER_MERGE = 8;

}

3.1.3  ReleaseHistory

com.ctrip.framework.apollo.biz.entity.ReleaseMessage ，不继承 BaseEntity 抽象类，ReleaseMessage 实体。代码如下：

@Entity
@Table(name = "ReleaseMessage")
public class ReleaseMessage {

    /**
     * 编号
     */
    @Id
    @GeneratedValue
    @Column(name = "Id")
    private long id;
    /**
     * 消息内容，通过 {@link com.ctrip.framework.apollo.biz.utils.ReleaseMessageKeyGenerator#generate(String, String, String)} 方法生成。
     */
    @Column(name = "Message", nullable = false)
    private String message;
    /**
     * 最后更新时间
     */
    @Column(name = "DataChange_LastTime")
    private Date dataChangeLastModifiedTime;
 
    @PrePersist
    protected void prePersist() {
        if (this.dataChangeLastModifiedTime == null) {
            dataChangeLastModifiedTime = new Date();
        }
    }   
}

3.2  发布-Portal门户

3.2.1 ReleaseController

在 apollo-portal 项目中，com.ctrip.framework.apollo.portal.controller.ReleaseController ，提供 Release 的 API 。在【发布】的界面中，点击【 发布 】按钮，调用发布配置的 API 。

#createRelease(appId, env, clusterName, namespaceName, NamespaceReleaseModel) 方法，发布配置。代码如下：

@Autowired
private ReleaseService releaseService;
@Autowired
private ApplicationEventPublisher publisher;
@Autowired
private PortalConfig portalConfig;

@PreAuthorize(value = "@permissionValidator.hasReleaseNamespacePermission(#appId, #namespaceName)")
@RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/releases", method = RequestMethod.POST)
public ReleaseDTO createRelease(@PathVariable String appId,
                                @PathVariable String env, @PathVariable String clusterName,
                                @PathVariable String namespaceName, @RequestBody NamespaceReleaseModel model) {
    // 校验 NamespaceReleaseModel 非空
    checkModel(Objects.nonNull(model));
    // 设置 PathVariable 变量到 NamespaceReleaseModel 中
    model.setAppId(appId);
    model.setEnv(env);
    model.setClusterName(clusterName);
    model.setNamespaceName(namespaceName);
    // 若是紧急发布，但是当前环境未允许该操作，抛出 BadRequestException 异常
    if (model.isEmergencyPublish() && !portalConfig.isEmergencyPublishAllowed(Env.valueOf(env))) {
        throw new BadRequestException(String.format("Env: %s is not supported emergency publish now", env));
    }
    // 发布配置
    ReleaseDTO createdRelease = releaseService.publish(model);

    // 创建 ConfigPublishEvent 对象
    ConfigPublishEvent event = ConfigPublishEvent.instance();
    event.withAppId(appId)
            .withCluster(clusterName)
            .withNamespace(namespaceName)
            .withReleaseId(createdRelease.getId())
            .setNormalPublishEvent(true)
            .setEnv(Env.valueOf(env));
    // 发布 ConfigPublishEvent 事件
    publisher.publishEvent(event);

    return createdRelease;
}

• POST /apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/releases 接口，Request Body 传递 JSON 对象。

• @PreAuthorize(...) 注解，调用 PermissionValidator#hasReleaseNamespacePermissio(appId, namespaceName) 方法，校验是否有发布配置的权限。后续文章，详细分享。

• com.ctrip.framework.apollo.portal.entity.model.NamespaceReleaseModel ，Namespace 配置发布 Model 。代码如下：

public class NamespaceReleaseModel implements Verifiable {

    /**
     * App 编号
     */
    private String appId;
    /**
     * Env 名字
     */
    private String env;
    /**
     * Cluster 名字
     */
    private String clusterName;
    /**
     * Namespace 名字
     */
    private String namespaceName;
    /**
     * 发布标题
     */
    private String releaseTitle;
    /**
     * 发布描述
     */
    private String releaseComment;
    /**
     * 发布人
     */
    private String releasedBy;
    /**
     * 是否紧急发布
     */
    private boolean isEmergencyPublish;

    @Override
    public boolean isInvalid() {
        return StringUtils.isContainEmpty(appId, env, clusterName, namespaceName, releaseTitle); // 校验非空
    }
    
}

• 第 14 行：校验 NamespaceReleaseModel 非空。

• 第 15 至 19 行：设置 PathVariable 变量到 NamespaceReleaseModel 中。

• 第 20 至 23 行：校验若是紧急发布，但是当前环境未允许该操作，抛出 BadRequestException 异常。

  • 紧急发布功能，可通过设置 PortalDB 的 ServerConfig 的"emergencyPublish.supported.envs" 配置开启对应的 Env 们。例如，emergencyPublish.supported.envs = dev 。

• 第 25 行：调用 ReleaseService#publish(NamespaceReleaseModel) 方法，调用 Admin Service API ，发布配置。

• 第 27 至 36 行：创建 ConfigPublishEvent 对象，并调用 ApplicationEventPublisher#publishEvent(event) 方法，发布 ConfigPublishEvent 事件。这部分，我们在后续文章分享。

• 第 38 行：返回 ReleaseDTO 对象。

3.2.2 ReleaseService

在 apollo-portal 项目中，com.ctrip.framework.apollo.portal.service.ReleaseService ，提供 Release 的 Service 逻辑。

#publish(NamespaceReleaseModel) 方法，调用 Admin Service API ，发布配置。代码如下：

@Autowired
private UserInfoHolder userInfoHolder;
@Autowired
private AdminServiceAPI.ReleaseAPI releaseAPI;

public ReleaseDTO publish(NamespaceReleaseModel model) {
    Env env = model.getEnv();
    boolean isEmergencyPublish = model.isEmergencyPublish();
    String appId = model.getAppId();
    String clusterName = model.getClusterName();
    String namespaceName = model.getNamespaceName();
    String releaseBy = StringUtils.isEmpty(model.getReleasedBy()) ? userInfoHolder.getUser().getUserId() : model.getReleasedBy();

    // 调用 Admin Service API ，发布 Namespace 的配置。
    ReleaseDTO releaseDTO = releaseAPI.createRelease(appId, env, clusterName, namespaceName,
            model.getReleaseTitle(), model.getReleaseComment(),
            releaseBy, isEmergencyPublish);
    // 【TODO 6001】Tracer 日志
    Tracer.logEvent(TracerEventType.RELEASE_NAMESPACE, String.format("%s+%s+%s+%s", appId, env, clusterName, namespaceName));
    return releaseDTO;
}

• 第14 至 17 行：调用 ReleaseAPI#createRelease(appId, env, clusterName, namespaceName, releaseTitle, releaseComment, releaseBy, isEmergencyPublish) 方法，调用 Admin Service API ，发布配置。
• 第 19 行：【TODO 6001】Tracer 日志

3.2.3 ReleaseAPI

com.ctrip.framework.apollo.portal.api.ReleaseAPI ，实现 API 抽象类，封装对 Admin Service 的 Release 模块的 API 调用。代码如下：

3.3 发布-Admin Service

3.3.1 ReleaseController

在 apollo-adminservice 项目中， com.ctrip.framework.apollo.adminservice.controller.ReleaseController ，提供 Release 的 API 。

#publish(appId, env, clusterName, namespaceName, releaseTitle, releaseComment, releaseBy, isEmergencyPublish) 方法，发布 Namespace 的配置。代码如下：

@Autowired
private ReleaseService releaseService;
@Autowired
private NamespaceService namespaceService;
@Autowired
private MessageSender messageSender;

@Transactional
@RequestMapping(path = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/releases", method = RequestMethod.POST)
public ReleaseDTO publish(@PathVariable("appId") String appId,
                          @PathVariable("clusterName") String clusterName,
                          @PathVariable("namespaceName") String namespaceName,
                          @RequestParam("name") String releaseName,
                          @RequestParam(name = "comment", required = false) String releaseComment,
                          @RequestParam("operator") String operator,
                          @RequestParam(name = "isEmergencyPublish", defaultValue = "false") boolean isEmergencyPublish) {
    // 校验对应的 Namespace 对象是否存在。若不存在，抛出 NotFoundException 异常
    Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName);
    if (namespace == null) {
        throw new NotFoundException(String.format("Could not find namespace for %s %s %s", appId, clusterName, namespaceName));
    }
    // 发布 Namespace 的配置
    Release release = releaseService.publish(namespace, releaseName, releaseComment, operator, isEmergencyPublish);

    // send release message
    // 获得 Cluster 名
    Namespace parentNamespace = namespaceService.findParentNamespace(namespace);
    String messageCluster;
    if (parentNamespace != null) { // 灰度发布
        messageCluster = parentNamespace.getClusterName();
    } else {
        messageCluster = clusterName; // 使用请求的 ClusterName
    }
    // 发送 Release 消息
    messageSender.sendMessage(ReleaseMessageKeyGenerator.generate(appId, messageCluster, namespaceName), Topics.APOLLO_RELEASE_TOPIC);

    // 将 Release 转换成 ReleaseDTO 对象
    return BeanUtils.transfrom(ReleaseDTO.class, release);
}

• POST /apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/releases 接口，Request Body 传递 JSON 对象。
• 第 17 至 21 行：校验对应的 Namespace 对象是否存在。若不存在，抛出 NotFoundException 异常。
• 第 23 行：调用 ReleaseService#publish(namespace, releaseName, releaseComment, operator, isEmergencyPublish) 方法，发布 Namespace 的配置，返回 Release 对象。
• 第 26 至 33 行：获得发布消息的 Cluster 名字。

  • 第 27 行：调用 NamespaceService#findParentNamespace(namespace) 方法，获得父 Namespace 对象。代码如下：

    @Autowired
    private ClusterService clusterService;
    @Autowired
    private ClusterService clusterService;
        
    public Namespace findParentNamespace(Namespace namespace) {
        String appId = namespace.getAppId();
        String namespaceName = namespace.getNamespaceName();
        // 获得 Cluster
        Cluster cluster = clusterService.findOne(appId, namespace.getClusterName());
        // 若为子 Cluster
        if (cluster != null && cluster.getParentClusterId() > 0) {
            // 获得父 Cluster
            Cluster parentCluster = clusterService.findOne(cluster.getParentClusterId());
            // 获得父 Namespace
            return findOne(appId, parentCluster.getName(), namespaceName);
        }
        return null;
    }
    
    public Namespace findOne(String appId, String clusterName, String namespaceName) {
        return namespaceRepository.findByAppIdAndClusterNameAndNamespaceName(appId, clusterName, namespaceName);
    }

• 第 29 至 30 行：若有父 Namespace 对象，说明是子 Namespace ( 灰度发布 )，则使用父 Namespace 的 Cluster 名字。因为，客户端即使在灰度发布的情况下，也是使用 父 Namespace 的 Cluster 名字。也就说，灰度发布，对客户端是透明无感知的。

• 第 32 行：使用请求的 Cluster 名字。

3.3.2 ReleaseService

在 apollo-biz 项目中，com.ctrip.framework.apollo.biz.service.ReleaseService ，提供 Release 的 Service 逻辑给 Admin Service 和 Config Service 。

3.3.2.1 publish

#publish(namespace, releaseName, releaseComment, operator, isEmergencyPublish) 方法，发布 Namespace 的配置。代码如下：

private Gson gson = new Gson();

@Autowired
private ReleaseRepository releaseRepository;
@Autowired
private ItemService itemService;
@Autowired
private AuditService auditService;
@Autowired
private NamespaceLockService namespaceLockService;
@Autowired
private NamespaceService namespaceService;
@Autowired
private ReleaseHistoryService releaseHistoryService;

@Transactional
public Release publish(Namespace namespace, String releaseName, String releaseComment, String operator, boolean isEmergencyPublish) {
    // 校验锁定
    checkLock(namespace, isEmergencyPublish, operator);
    // 获得 Namespace 的普通配置 Map
    Map<String, String> operateNamespaceItems = getNamespaceItems(namespace);
    // 获得父 Namespace
    Namespace parentNamespace = namespaceService.findParentNamespace(namespace);
    // 若有父 Namespace ，则是子 Namespace ，进行灰度发布
    // branch release
    if (parentNamespace != null) {
        return publishBranchNamespace(parentNamespace, namespace, operateNamespaceItems, releaseName, releaseComment, operator, isEmergencyPublish);
    }
    // 获得子 Namespace 对象
    Namespace childNamespace = namespaceService.findChildNamespace(namespace);
    // 获得上一次，并且有效的 Release 对象
    Release previousRelease = null;
    if (childNamespace != null) {
        previousRelease = findLatestActiveRelease(namespace);
    }
    // 创建操作 Context
    // master release
    Map<String, Object> operationContext = Maps.newHashMap();
    operationContext.put(ReleaseOperationContext.IS_EMERGENCY_PUBLISH, isEmergencyPublish);
    // 主干发布
    Release release = masterRelease(namespace, releaseName, releaseComment, operateNamespaceItems, operator, ReleaseOperation.NORMAL_RELEASE, operationContext); // 是否紧急发布。
    // 若有子 Namespace 时，自动将主干合并到子 Namespace ，并进行一次子 Namespace 的发布
    // merge to branch and auto release
    if (childNamespace != null) {
        mergeFromMasterAndPublishBranch(namespace, childNamespace, operateNamespaceItems,
                releaseName, releaseComment, operator, previousRelease,
                release, isEmergencyPublish);
    }
    return release;
}

• 第 19 行：调用 #checkLock(namespace, isEmergencyPublish, operator) 方法，校验 NamespaceLock 锁定。代码如下：

  private void checkLock(Namespace namespace, boolean isEmergencyPublish, String operator) {
      if (!isEmergencyPublish) { // 非紧急发布
          // 获得 NamespaceLock 对象
          NamespaceLock lock = namespaceLockService.findLock(namespace.getId());
          // 校验锁定人是否是当前管理员。若是，抛出 BadRequestException 异常
          if (lock != null && lock.getDataChangeCreatedBy().equals(operator)) {
              throw new BadRequestException("Config can not be published by yourself.");
          }
      }
  }

• 第 21 行：调用 #getNamespaceItems(namespace) 方法，获得 Namespace 的普通配置 Map 。代码如下：

  private Map<String, String> getNamespaceItems(Namespace namespace) {
      // 读取 Namespace 的 Item 集合
      List<Item> items = itemService.findItemsWithoutOrdered(namespace.getId());
      // 生成普通配置 Map 。过滤掉注释和空行的配置项
      Map<String, String> configurations = new HashMap<String, String>();
      for (Item item : items) {
          if (StringUtils.isEmpty(item.getKey())) {
              continue;
          }
          configurations.put(item.getKey(), item.getValue());
      }
      return configurations;
  }

• 第 23 行：调用 #findParentNamespace(namespace) 方法，获得父 Namespace 对象。

• 第 26 至 28 行：若有父 Namespace 对象，灰度发布 。

• 第 30 行：调用 NamespaceService#findChildNamespace(namespace) 方法，获得子 Namespace 对象 。

• 第 31 至 35 行：调用 #findLatestActiveRelease(Namespace) 方法，获得上一次，并且有效的 Release 对象。代码如下：

  public Release findLatestActiveRelease(Namespace namespace) {
      return findLatestActiveRelease(namespace.getAppId(), namespace.getClusterName(), namespace.getNamespaceName());
  }
  
  public Release findLatestActiveRelease(String appId, String clusterName, String namespaceName) {
      return releaseRepository.findFirstByAppIdAndClusterNameAndNamespaceNameAndIsAbandonedFalseOrderByIdDesc(appId,
              clusterName, namespaceName); // IsAbandoned = False && Id DESC
  }

• 第 36 至 39 行：创建操作 Context 。

• 第 41 行：调用 #masterRelease(namespace, releaseName, releaseComment, operateNamespaceItems, operator, releaseOperation, operationContext) 方法，主干发布配置。🙂 创建的 Namespace ，默认就是主干，而灰度发布使用的是分支。

• 第 42 至 48 行：调用 #mergeFromMasterAndPublishBranch(...) 方法，若有子 Namespace 时，自动将主干合并到子 Namespace ，并进行一次子 Namespace 的发布。

• 第 49 行：返回 Release 对象 。

3.3.2.2 masterRelease

#masterRelease(namespace, releaseName, releaseComment, operateNamespaceItems, operator, releaseOperation, operationContext) 方法，主干发布配置。代码如下：

private Release masterRelease(Namespace namespace, String releaseName, String releaseComment,
                              Map<String, String> configurations, String operator,
                              int releaseOperation, Map<String, Object> operationContext) {
    // 获得最后有效的 Release 对象
    Release lastActiveRelease = findLatestActiveRelease(namespace);
    long previousReleaseId = lastActiveRelease == null ? 0 : lastActiveRelease.getId();
    // 创建 Release 对象，并保存
    Release release = createRelease(namespace, releaseName, releaseComment, configurations, operator);

    // 创建 ReleaseHistory 对象，并保存
    releaseHistoryService.createReleaseHistory(namespace.getAppId(), namespace.getClusterName(),
            namespace.getNamespaceName(), namespace.getClusterName(),
            release.getId(), previousReleaseId, releaseOperation,
            operationContext, operator);
    return release;
}

• 第 5 行：调用 #findLatestActiveRelease(namespace) 方法，获得最后、有效的 Release 对象。代码如下：

  public Release findLatestActiveRelease(Namespace namespace) {
      return findLatestActiveRelease(namespace.getAppId(), namespace.getClusterName(), namespace.getNamespaceName());
  }
  
  public Release findLatestActiveRelease(String appId, String clusterName, String namespaceName) {
      return releaseRepository.findFirstByAppIdAndClusterNameAndNamespaceNameAndIsAbandonedFalseOrderByIdDesc(appId,
              clusterName, namespaceName); // IsAbandoned = False && Id DESC
  }

• 第 8 行：调用 #createRelease(namespace, releaseName, releaseComment, configurations, operator) 方法，创建 Release 对象，并保存。

• 第10 至 14 行：调用 ReleaseHistoryService#createReleaseHistory(appId, clusterName, namespaceName, branchName, releaseId, previousReleaseId, operation, operationContext, operator) 方法，创建 ReleaseHistory 对象，并保存。

3.3.2.3 createRelease

#createRelease(namespace, releaseName, releaseComment, configurations, operator) 方法，创建 Release 对象，并保存。代码如下：

private Release createRelease(Namespace namespace, String name, String comment,
                              Map<String, String> configurations, String operator) {
    // 创建 Release 对象
    Release release = new Release();
    release.setReleaseKey(ReleaseKeyGenerator.generateReleaseKey(namespace)); //【TODO 6006】Release Key 用途？
    release.setDataChangeCreatedTime(new Date());
    release.setDataChangeCreatedBy(operator);
    release.setDataChangeLastModifiedBy(operator);
    release.setName(name);
    release.setComment(comment);
    release.setAppId(namespace.getAppId());
    release.setClusterName(namespace.getClusterName());
    release.setNamespaceName(namespace.getNamespaceName());
    release.setConfigurations(gson.toJson(configurations)); // 使用 Gson ，将配置 Map 格式化成字符串。
    // 保存 Release 对象
    release = releaseRepository.save(release);
    // 释放 NamespaceLock
    namespaceLockService.unlock(namespace.getId());
    // 记录 Audit 到数据库中
    auditService.audit(Release.class.getSimpleName(), release.getId(), Audit.OP.INSERT, release.getDataChangeCreatedBy());
    return release;
}

• 第 4 至 14 行：创建 Release 对象，并设置对应的属性。
  • 第 5 行：【TODO 6006】Release Key 用途？
  • 第 14 行：调用 Gson#toJson(src) 方法，将配置 Map 格式化成字符串。
• 第 16 行：调用 ReleaseRepository#save(Release) 方法，保存 Release 对象。
• 第 18 行：调用 NamespaceLockService#unlock(namespaceId) 方法，释放 NamespaceLock 。
• 第 20 行：记录 Audit 到数据库中。

3.3.3 ReleaseRepository

com.ctrip.framework.apollo.biz.repository.ReleaseRepository ，继承 org.springframework.data.repository.PagingAndSortingRepository 接口，提供 Release 的数据访问 给 Admin Service 和 Config Service 。代码如下：

public interface ReleaseRepository extends PagingAndSortingRepository<Release, Long> {

  Release findFirstByAppIdAndClusterNameAndNamespaceNameAndIsAbandonedFalseOrderByIdDesc(@Param("appId") String appId, @Param("clusterName") String clusterName, @Param("namespaceName") String namespaceName);

  Release findByIdAndIsAbandonedFalse(long id);

  List<Release> findByAppIdAndClusterNameAndNamespaceNameOrderByIdDesc(String appId, String clusterName, String namespaceName, Pageable page);

  List<Release> findByAppIdAndClusterNameAndNamespaceNameAndIsAbandonedFalseOrderByIdDesc(String appId, String clusterName, String namespaceName, Pageable page);

  List<Release> findByReleaseKeyIn(Set<String> releaseKey);

  List<Release> findByIdIn(Set<Long> releaseIds);

  @Modifying
  @Query("update Release set isdeleted=1,DataChange_LastModifiedBy = ?4 where appId=?1 and clusterName=?2 and namespaceName = ?3")
  int batchDelete(String appId, String clusterName, String namespaceName, String operator);

  // For release history conversion program, need to delete after conversion it done
  List<Release> findByAppIdAndClusterNameAndNamespaceNameOrderByIdAsc(String appId, String clusterName, String namespaceName);

}

3.3.4 ReleaseHistoryService

在 apollo-biz 项目中，com.ctrip.framework.apollo.biz.service.ReleaseHistoryService ，提供 ReleaseHistory 的 Service 逻辑给 Admin Service 和 Config Service 。

#createReleaseHistory(appId, clusterName, namespaceName, branchName, releaseId, previousReleaseId, operation, operationContext, operator) 方法，创建 ReleaseHistory 对象，并保存。代码如下：

private Gson gson = new Gson();

@Autowired
private ReleaseHistoryRepository releaseHistoryRepository;
@Autowired
private AuditService auditService;

@Transactional
public ReleaseHistory createReleaseHistory(String appId, String clusterName, String namespaceName, String branchName,
                                           long releaseId, long previousReleaseId, int operation,
                                           Map<String, Object> operationContext, String operator) {
    // 创建 ReleaseHistory 对象
    ReleaseHistory releaseHistory = new ReleaseHistory();
    releaseHistory.setAppId(appId);
    releaseHistory.setClusterName(clusterName);
    releaseHistory.setNamespaceName(namespaceName);
    releaseHistory.setBranchName(branchName);
    releaseHistory.setReleaseId(releaseId); // Release 编号
    releaseHistory.setPreviousReleaseId(previousReleaseId); // 上一个 Release 编号
    releaseHistory.setOperation(operation);
    if (operationContext == null) {
        releaseHistory.setOperationContext("{}"); //default empty object
    } else {
        releaseHistory.setOperationContext(gson.toJson(operationContext));
    }
    releaseHistory.setDataChangeCreatedTime(new Date());
    releaseHistory.setDataChangeCreatedBy(operator);
    releaseHistory.setDataChangeLastModifiedBy(operator);
    // 保存 ReleaseHistory 对象
    releaseHistoryRepository.save(releaseHistory);
    // 记录 Audit 到数据库中
    auditService.audit(ReleaseHistory.class.getSimpleName(), releaseHistory.getId(), Audit.OP.INSERT, releaseHistory.getDataChangeCreatedBy());
    return releaseHistory;
}

• 第 12 至 28 行：创建 ReleaseHistory 对象，并设置对应的属性。
• 第 30 行：调用 ReleaseHistoryRepository#save(ReleaseHistory) 方法，保存 ReleaseHistory 对象。
• 第 32 行：记录 Audit 到数据库中。

3.3.5 ReleaseHistoryRepository

com.ctrip.framework.apollo.biz.repository.ReleaseHistoryRepository ，继承 org.springframework.data.repository.PagingAndSortingRepository 接口，提供 ReleaseHistory 的数据访问 给 Admin Service 和 Config Service 。代码如下：

public interface ReleaseHistoryRepository extends PagingAndSortingRepository<ReleaseHistory, Long> {

    Page<ReleaseHistory> findByAppIdAndClusterNameAndNamespaceNameOrderByIdDesc(String appId, String
            clusterName, String namespaceName, Pageable pageable);

    Page<ReleaseHistory> findByReleaseIdAndOperationOrderByIdDesc(long releaseId, int operation, Pageable pageable);

    Page<ReleaseHistory> findByPreviousReleaseIdAndOperationOrderByIdDesc(long previousReleaseId, int operation, Pageable pageable);

    @Modifying
    @Query("update ReleaseHistory set isdeleted=1,DataChange_LastModifiedBy = ?4 where appId=?1 and clusterName=?2 and namespaceName = ?3")
    int batchDelete(String appId, String clusterName, String namespaceName, String operator);

}

4  小结

好啦，这节我们简单了解了配置的变更过程以及涉及到的组件，并从源码了解了Portal 和AdminService的发布过程，这节我们看了Admin Service 往数据库里放入了 release 以及 releaseHistory 记录，放releaseMessage 的我们下节看哈，有理解不对的地方欢迎指正哈。