聊聊spring cloud的ConsulServiceRegistry

public interface ServiceRegistry<R extends Registration> {
​
    /**
     * Registers the registration. A registration typically has information about an
     * instance, such as its hostname and port.
     * @param registration registration meta data
     */
    void register(R registration);
​
    /**
     * Deregisters the registration.
     * @param registration registration meta data
     */
    void deregister(R registration);
​
    /**
     * Closes the ServiceRegistry. This is a lifecycle method.
     */
    void close();
​
    /**
     * Sets the status of the registration. The status values are determined by the
     * individual implementations.
     * @param registration The registration to update.
     * @param status The status to set.
     * @see org.springframework.cloud.client.serviceregistry.endpoint.ServiceRegistryEndpoint
     */
    void setStatus(R registration, String status);
​
    /**
     * Gets the status of a particular registration.
     * @param registration The registration to query.
     * @param <T> The type of the status.
     * @return The status of the registration.
     * @see org.springframework.cloud.client.serviceregistry.endpoint.ServiceRegistryEndpoint
     */
    <T> T getStatus(R registration);
​
}

public class ConsulServiceRegistry implements ServiceRegistry<ConsulRegistration> {
​
    private static Log log = LogFactory.getLog(ConsulServiceRegistry.class);
​
    private final ConsulClient client;
​
    private final ConsulDiscoveryProperties properties;
​
    private final TtlScheduler ttlScheduler;
​
    private final HeartbeatProperties heartbeatProperties;
​
    public ConsulServiceRegistry(ConsulClient client,
            ConsulDiscoveryProperties properties, TtlScheduler ttlScheduler,
            HeartbeatProperties heartbeatProperties) {
        this.client = client;
        this.properties = properties;
        this.ttlScheduler = ttlScheduler;
        this.heartbeatProperties = heartbeatProperties;
    }
​
    @Override
    public void register(ConsulRegistration reg) {
        log.info("Registering service with consul: " + reg.getService());
        try {
            this.client.agentServiceRegister(reg.getService(),
                    this.properties.getAclToken());
            NewService service = reg.getService();
            if (this.heartbeatProperties.isEnabled() && this.ttlScheduler != null
                    && service.getCheck() != null
                    && service.getCheck().getTtl() != null) {
                this.ttlScheduler.add(reg.getInstanceId());
            }
        }
        catch (ConsulException e) {
            if (this.properties.isFailFast()) {
                log.error("Error registering service with consul: " + reg.getService(),
                        e);
                ReflectionUtils.rethrowRuntimeException(e);
            }
            log.warn("Failfast is false. Error registering service with consul: "
                    + reg.getService(), e);
        }
    }
​
    @Override
    public void deregister(ConsulRegistration reg) {
        if (this.ttlScheduler != null) {
            this.ttlScheduler.remove(reg.getInstanceId());
        }
        if (log.isInfoEnabled()) {
            log.info("Deregistering service with consul: " + reg.getInstanceId());
        }
        this.client.agentServiceDeregister(reg.getInstanceId(),
                this.properties.getAclToken());
    }
​
    @Override
    public void close() {
​
    }
​
    @Override
    public void setStatus(ConsulRegistration registration, String status) {
        if (status.equalsIgnoreCase(OUT_OF_SERVICE.getCode())) {
            this.client.agentServiceSetMaintenance(registration.getInstanceId(), true);
        }
        else if (status.equalsIgnoreCase(UP.getCode())) {
            this.client.agentServiceSetMaintenance(registration.getInstanceId(), false);
        }
        else {
            throw new IllegalArgumentException("Unknown status: " + status);
        }
​
    }
​
    @Override
    public Object getStatus(ConsulRegistration registration) {
        String serviceId = registration.getServiceId();
        Response<List<Check>> response = this.client.getHealthChecksForService(serviceId,
                QueryParams.DEFAULT);
        List<Check> checks = response.getValue();
​
        for (Check check : checks) {
            if (check.getServiceId().equals(registration.getInstanceId())) {
                if (check.getName().equalsIgnoreCase("Service Maintenance Mode")) {
                    return OUT_OF_SERVICE.getCode();
                }
            }
        }
​
        return UP.getCode();
    }
​
}

public class ConsulRegistration implements Registration {
​
    private final NewService service;
​
    private ConsulDiscoveryProperties properties;
​
    public ConsulRegistration(NewService service, ConsulDiscoveryProperties properties) {
        this.service = service;
        this.properties = properties;
    }
​
    public NewService getService() {
        return this.service;
    }
​
    protected ConsulDiscoveryProperties getProperties() {
        return this.properties;
    }
​
    public String getInstanceId() {
        return getService().getId();
    }
​
    public String getServiceId() {
        return getService().getName();
    }
​
    @Override
    public String getHost() {
        return getService().getAddress();
    }
​
    @Override
    public int getPort() {
        return getService().getPort();
    }
​
    @Override
    public boolean isSecure() {
        return this.properties.getScheme().equalsIgnoreCase("https");
    }
​
    @Override
    public URI getUri() {
        return DefaultServiceInstance.getUri(this);
    }
​
    @Override
    public Map<String, String> getMetadata() {
        return ConsulServerUtils.getMetadata(getService().getTags());
    }
​
}

@Configuration
@ConditionalOnConsulEnabled
@ConditionalOnProperty(value = "spring.cloud.service-registry.enabled", matchIfMissing = true)
@AutoConfigureBefore(ServiceRegistryAutoConfiguration.class)
public class ConsulServiceRegistryAutoConfiguration {
​
    @Autowired(required = false)
    private TtlScheduler ttlScheduler;
​
    @Bean
    @ConditionalOnMissingBean
    public ConsulServiceRegistry consulServiceRegistry(ConsulClient consulClient,
            ConsulDiscoveryProperties properties,
            HeartbeatProperties heartbeatProperties) {
        return new ConsulServiceRegistry(consulClient, properties, this.ttlScheduler,
                heartbeatProperties);
    }
​
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty("spring.cloud.consul.discovery.heartbeat.enabled")
    public TtlScheduler ttlScheduler(ConsulClient consulClient,
            HeartbeatProperties heartbeatProperties) {
        return new TtlScheduler(heartbeatProperties, consulClient);
    }
​
    @Bean
    @ConditionalOnMissingBean
    public HeartbeatProperties heartbeatProperties() {
        return new HeartbeatProperties();
    }
​
    @Bean
    @ConditionalOnMissingBean
    public ConsulDiscoveryProperties consulDiscoveryProperties(InetUtils inetUtils) {
        return new ConsulDiscoveryProperties(inetUtils);
    }
​
}