SpringCloud Eureka的相关配置

小灰灰 2022-10-07 13:59 11阅读 0赞

eureka的属性配置主要有eureka.server、eureka.instance、以及eureka.client。分别对应EurekaServerConfigBean、EurekaInstanceConfigBean以及EurekaClientConfigBean三个配置类。

## 【1】 eureka server的属性配置 ##

/**
    * Eureka server configuration properties prefix.
    */
    public static final String PREFIX = "eureka.server";
    
    private static final int MINUTES = 60 * 1000;
    
    @Autowired(required = false)
    PropertyResolver propertyResolver;
    
    private String aWSAccessId;
    
    private String aWSSecretKey;
    
    private int eIPBindRebindRetries = 3;
    
    private int eIPBindingRetryIntervalMs = 5 * MINUTES;
    
    private int eIPBindingRetryIntervalMsWhenUnbound = 1 * MINUTES;
    
    private boolean enableSelfPreservation = true;
    
    private double renewalPercentThreshold = 0.85;
    
    private int renewalThresholdUpdateIntervalMs = 15 * MINUTES;
    
    private int peerEurekaNodesUpdateIntervalMs = 10 * MINUTES;
    
    private int numberOfReplicationRetries = 5;
    
    private int peerEurekaStatusRefreshTimeIntervalMs = 30 * 1000;
    
    private int waitTimeInMsWhenSyncEmpty = 5 * MINUTES;
    
    private int peerNodeConnectTimeoutMs = 200;
    
    private int peerNodeReadTimeoutMs = 200;
    
    private int peerNodeTotalConnections = 1000;
    
    private int peerNodeTotalConnectionsPerHost = 500;
    
    private int peerNodeConnectionIdleTimeoutSeconds = 30;
    
    private long retentionTimeInMSInDeltaQueue = 3 * MINUTES;
    
    private long deltaRetentionTimerIntervalInMs = 30 * 1000;
    
    private long evictionIntervalTimerInMs = 60 * 1000;
    
    private int aSGQueryTimeoutMs = 300;
    
    private long aSGUpdateIntervalMs = 5 * MINUTES;
    
    private long aSGCacheExpiryTimeoutMs = 10 * MINUTES; // defaults to longer than the
    
    // asg update interval
    
    private long responseCacheAutoExpirationInSeconds = 180;
    
    private long responseCacheUpdateIntervalMs = 30 * 1000;
    
    private boolean useReadOnlyResponseCache = true;
    
    private boolean disableDelta;
    
    private long maxIdleThreadInMinutesAgeForStatusReplication = 10;
    
    private int minThreadsForStatusReplication = 1;
    
    private int maxThreadsForStatusReplication = 1;
    
    private int maxElementsInStatusReplicationPool = 10000;
    
    private boolean syncWhenTimestampDiffers = true;
    
    private int registrySyncRetries = 0;
    
    private long registrySyncRetryWaitMs = 30 * 1000;
    
    private int maxElementsInPeerReplicationPool = 10000;
    
    private long maxIdleThreadAgeInMinutesForPeerReplication = 15;
    
    private int minThreadsForPeerReplication = 5;
    
    private int maxThreadsForPeerReplication = 20;
    
    private int maxTimeForReplication = 30000;
    
    private boolean primeAwsReplicaConnections = true;
    
    private boolean disableDeltaForRemoteRegions;
    
    private int remoteRegionConnectTimeoutMs = 1000;
    
    private int remoteRegionReadTimeoutMs = 1000;
    
    private int remoteRegionTotalConnections = 1000;
    
    private int remoteRegionTotalConnectionsPerHost = 500;
    
    private int remoteRegionConnectionIdleTimeoutSeconds = 30;
    
    private boolean gZipContentFromRemoteRegion = true;
    
    private Map<String, String> remoteRegionUrlsWithName = new HashMap<>();
    
    private String[] remoteRegionUrls;
    
    private Map<String, Set<String>> remoteRegionAppWhitelist = new HashMap<>();
    
    private int remoteRegionRegistryFetchInterval = 30;
    
    private int remoteRegionFetchThreadPoolSize = 20;
    
    private String remoteRegionTrustStore = "";
    
    private String remoteRegionTrustStorePassword = "changeit";
    
    private boolean disableTransparentFallbackToOtherRegion;
    
    private boolean batchReplication;
    
    private boolean rateLimiterEnabled = false;
    
    private boolean rateLimiterThrottleStandardClients = false;
    
    private Set<String> rateLimiterPrivilegedClients = Collections.emptySet();
    
    private int rateLimiterBurstSize = 10;
    
    private int rateLimiterRegistryFetchAverageRate = 500;
    
    private int rateLimiterFullFetchAverageRate = 100;
    
    private boolean logIdentityHeaders = true;
    
    private String listAutoScalingGroupsRoleName = "ListAutoScalingGroups";
    
    private boolean enableReplicatedRequestCompression = false;
    
    private String jsonCodecName;
    
    private String xmlCodecName;
    
    private int route53BindRebindRetries = 3;
    
    private int route53BindingRetryIntervalMs = 5 * MINUTES;
    
    private long route53DomainTTL = 30;
    
    private AwsBindingStrategy bindingStrategy = AwsBindingStrategy.EIP;
    
    private int minAvailableInstancesForPeerReplication = -1;
    
    private int initialCapacityOfResponseCache = 1000;
    
    private int expectedClientRenewalIntervalSeconds = 30;
    
    private boolean useAwsAsgApi = true;
    
    private String myUrl;

## 【2】 eureka.instance的属性配置 ##

private static final String UNKNOWN = "unknown";
    
    	private HostInfo hostInfo;
    
    	private InetUtils inetUtils;
    
    	/**
    	 * Default prefix for actuator endpoints.
    	 */
    	private String actuatorPrefix = "/actuator";
    
    	/**
    	 * Get the name of the application to be registered with eureka.
    	 */
    	private String appname = UNKNOWN;
    
    	/**
    	 * Get the name of the application group to be registered with eureka.
    	 */
    	private String appGroupName;
    
    	/**
    	 * Indicates whether the instance should be enabled for taking traffic as soon as it
    	 * is registered with eureka. Sometimes the application might need to do some
    	 * pre-processing before it is ready to take traffic.
    	 */
    	private boolean instanceEnabledOnit;
    
    	/**
    	 * Get the non-secure port on which the instance should receive traffic.
    	 */
    	private int nonSecurePort = 80;
    
    	/**
    	 * Get the Secure port on which the instance should receive traffic.
    	 */
    	private int securePort = 443;
    
    	/**
    	 * Indicates whether the non-secure port should be enabled for traffic or not.
    	 */
    	private boolean nonSecurePortEnabled = true;
    
    	/**
    	 * Indicates whether the secure port should be enabled for traffic or not.
    	 */
    	private boolean securePortEnabled;
    
    	/**
    	 * Indicates how often (in seconds) the eureka client needs to send heartbeats to
    	 * eureka server to indicate that it is still alive. If the heartbeats are not
    	 * received for the period specified in leaseExpirationDurationInSeconds, eureka
    	 * server will remove the instance from its view, there by disallowing traffic to this
    	 * instance.
    	 *
    	 * Note that the instance could still not take traffic if it implements
    	 * HealthCheckCallback and then decides to make itself unavailable.
    	 */
    	private int leaseRenewalIntervalInSeconds = 30;
    
    	/**
    	 * Indicates the time in seconds that the eureka server waits since it received the
    	 * last heartbeat before it can remove this instance from its view and there by
    	 * disallowing traffic to this instance.
    	 *
    	 * Setting this value too long could mean that the traffic could be routed to the
    	 * instance even though the instance is not alive. Setting this value too small could
    	 * mean, the instance may be taken out of traffic because of temporary network
    	 * glitches.This value to be set to atleast higher than the value specified in
    	 * leaseRenewalIntervalInSeconds.
    	 */
    	private int leaseExpirationDurationInSeconds = 90;
    
    	/**
    	 * Gets the virtual host name defined for this instance.
    	 *
    	 * This is typically the way other instance would find this instance by using the
    	 * virtual host name.Think of this as similar to the fully qualified domain name, that
    	 * the users of your services will need to find this instance.
    	 */
    	private String virtualHostName = UNKNOWN;
    
    	/**
    	 * Get the unique Id (within the scope of the appName) of this instance to be
    	 * registered with eureka.
    	 */
    	private String instanceId;
    
    	/**
    	 * Gets the secure virtual host name defined for this instance.
    	 *
    	 * This is typically the way other instance would find this instance by using the
    	 * secure virtual host name.Think of this as similar to the fully qualified domain
    	 * name, that the users of your services will need to find this instance.
    	 */
    	private String secureVirtualHostName = UNKNOWN;
    
    	/**
    	 * Gets the AWS autoscaling group name associated with this instance. This information
    	 * is specifically used in an AWS environment to automatically put an instance out of
    	 * service after the instance is launched and it has been disabled for traffic..
    	 */
    	private String aSGName;
    
    	/**
    	 * Gets the metadata name/value pairs associated with this instance. This information
    	 * is sent to eureka server and can be used by other instances.
    	 */
    	private Map<String, String> metadataMap = new HashMap<>();
    
    	/**
    	 * Returns the data center this instance is deployed. This information is used to get
    	 * some AWS specific instance information if the instance is deployed in AWS.
    	 */
    	private DataCenterInfo dataCenterInfo = new MyDataCenterInfo(
    			DataCenterInfo.Name.MyOwn);
    
    	/**
    	 * Get the IPAdress of the instance. This information is for academic purposes only as
    	 * the communication from other instances primarily happen using the information
    	 * supplied in { @link #getHostName(boolean)}.
    	 */
    	private String ipAddress;
    
    	/**
    	 * Gets the relative status page URL path for this instance. The status page URL is
    	 * then constructed out of the hostName and the type of communication - secure or
    	 * unsecure as specified in securePort and nonSecurePort.
    	 *
    	 * It is normally used for informational purposes for other services to find about the
    	 * status of this instance. Users can provide a simple HTML indicating what is the
    	 * current status of the instance.
    	 */
    	private String statusPageUrlPath = actuatorPrefix + "/info";
    
    	/**
    	 * Gets the absolute status page URL path for this instance. The users can provide the
    	 * statusPageUrlPath if the status page resides in the same instance talking to
    	 * eureka, else in the cases where the instance is a proxy for some other server,
    	 * users can provide the full URL. If the full URL is provided it takes precedence.
    	 *
    	 * It is normally used for informational purposes for other services to find about the
    	 * status of this instance. Users can provide a simple HTML indicating what is the
    	 * current status of the instance.
    	 */
    	private String statusPageUrl;
    
    	/**
    	 * Gets the relative home page URL Path for this instance. The home page URL is then
    	 * constructed out of the hostName and the type of communication - secure or unsecure.
    	 *
    	 * It is normally used for informational purposes for other services to use it as a
    	 * landing page.
    	 */
    	private String homePageUrlPath = "/";
    
    	/**
    	 * Gets the absolute home page URL for this instance. The users can provide the
    	 * homePageUrlPath if the home page resides in the same instance talking to eureka,
    	 * else in the cases where the instance is a proxy for some other server, users can
    	 * provide the full URL. If the full URL is provided it takes precedence.
    	 *
    	 * It is normally used for informational purposes for other services to use it as a
    	 * landing page. The full URL should follow the format http://${ eureka.hostname}:7001/
    	 * where the value ${ eureka.hostname} is replaced at runtime.
    	 */
    	private String homePageUrl;
    
    	/**
    	 * Gets the relative health check URL path for this instance. The health check page
    	 * URL is then constructed out of the hostname and the type of communication - secure
    	 * or unsecure as specified in securePort and nonSecurePort.
    	 *
    	 * It is normally used for making educated decisions based on the health of the
    	 * instance - for example, it can be used to determine whether to proceed deployments
    	 * to an entire farm or stop the deployments without causing further damage.
    	 */
    	private String healthCheckUrlPath = actuatorPrefix + "/health";
    
    	/**
    	 * Gets the absolute health check page URL for this instance. The users can provide
    	 * the healthCheckUrlPath if the health check page resides in the same instance
    	 * talking to eureka, else in the cases where the instance is a proxy for some other
    	 * server, users can provide the full URL. If the full URL is provided it takes
    	 * precedence.
    	 *
    	 * <p>
    	 * It is normally used for making educated decisions based on the health of the
    	 * instance - for example, it can be used to determine whether to proceed deployments
    	 * to an entire farm or stop the deployments without causing further damage. The full
    	 * URL should follow the format http://${ eureka.hostname}:7001/ where the value
    	 * ${ eureka.hostname} is replaced at runtime.
    	 */
    	private String healthCheckUrl;
    
    	/**
    	 * Gets the absolute secure health check page URL for this instance. The users can
    	 * provide the secureHealthCheckUrl if the health check page resides in the same
    	 * instance talking to eureka, else in the cases where the instance is a proxy for
    	 * some other server, users can provide the full URL. If the full URL is provided it
    	 * takes precedence.
    	 *
    	 * <p>
    	 * It is normally used for making educated decisions based on the health of the
    	 * instance - for example, it can be used to determine whether to proceed deployments
    	 * to an entire farm or stop the deployments without causing further damage. The full
    	 * URL should follow the format http://${ eureka.hostname}:7001/ where the value
    	 * ${ eureka.hostname} is replaced at runtime.
    	 */
    	private String secureHealthCheckUrl;
    
    	/**
    	 * Get the namespace used to find properties. Ignored in Spring Cloud.
    	 */
    	private String namespace = "eureka";
    
    	/**
    	 * The hostname if it can be determined at configuration time (otherwise it will be
    	 * guessed from OS primitives).
    	 */
    	private String hostname;
    
    	/**
    	 * Flag to say that, when guessing a hostname, the IP address of the server should be
    	 * used in prference to the hostname reported by the OS.
    	 */
    	private boolean preferIpAddress = false;
    
    	/**
    	 * Initial status to register with remote Eureka server.
    	 */
    	private InstanceStatus initialStatus = InstanceStatus.UP;
    
    	private String[] defaultAddressResolutionOrder = new String[0];
    
    	private Environment environment;

## 【3】 eureka.client的属性配置 ##

/**
    * Default prefix for Eureka client config properties.
    */
    public static final String PREFIX = "eureka.client";
    
    /**
    * Default Eureka URL.
    */
    public static final String DEFAULT_URL = "http://localhost:8761" + DEFAULT_PREFIX
    + "/";
    
    /**
    * Default availability zone if none is resolved based on region.
    */
    public static final String DEFAULT_ZONE = "defaultZone";
    
    private static final int MINUTES = 60;
    
    @Autowired(required = false)
    PropertyResolver propertyResolver;
    
    /**
    * Flag to indicate that the Eureka client is enabled.
    */
    private boolean enabled = true;
    
    @NestedConfigurationProperty
    private EurekaTransportConfig transport = new CloudEurekaTransportConfig();
    
    /**
    * Indicates how often(in seconds) to fetch the registry information from the eureka
    * server.
    */
    private int registryFetchIntervalSeconds = 30;
    
    /**
    * Indicates how often(in seconds) to replicate instance changes to be replicated to
    * the eureka server.
    */
    private int instanceInfoReplicationIntervalSeconds = 30;
    
    /**
    * Indicates how long initially (in seconds) to replicate instance info to the eureka
    * server.
    */
    private int initialInstanceInfoReplicationIntervalSeconds = 40;
    
    /**
    * Indicates how often(in seconds) to poll for changes to eureka server information.
    * Eureka servers could be added or removed and this setting controls how soon the
    * eureka clients should know about it.
    */
    private int eurekaServiceUrlPollIntervalSeconds = 5 * MINUTES;
    
    /**
    * Gets the proxy port to eureka server if any.
    */
    private String proxyPort;
    
    /**
    * Gets the proxy host to eureka server if any.
    */
    private String proxyHost;
    
    /**
    * Gets the proxy user name if any.
    */
    private String proxyUserName;
    
    /**
    * Gets the proxy password if any.
    */
    private String proxyPassword;
    
    /**
    * Indicates how long to wait (in seconds) before a read from eureka server needs to
    * timeout.
    */
    private int eurekaServerReadTimeoutSeconds = 8;
    
    /**
    * Indicates how long to wait (in seconds) before a connection to eureka server needs
    * to timeout. Note that the connections in the client are pooled by
    * org.apache.http.client.HttpClient and this setting affects the actual connection
    * creation and also the wait time to get the connection from the pool.
    */
    private int eurekaServerConnectTimeoutSeconds = 5;
    
    /**
    * Gets the name of the implementation which implements BackupRegistry to fetch the
    * registry information as a fall back option for only the first time when the eureka
    * client starts.
    *
    * This may be needed for applications which needs additional resiliency for registry
    * information without which it cannot operate.
    */
    private String backupRegistryImpl;
    
    /**
    * Gets the total number of connections that is allowed from eureka client to all
    * eureka servers.
    */
    private int eurekaServerTotalConnections = 200;
    
    /**
    * Gets the total number of connections that is allowed from eureka client to a eureka
    * server host.
    */
    private int eurekaServerTotalConnectionsPerHost = 50;
    
    /**
    * Gets the URL context to be used to construct the service url to contact eureka
    * server when the list of eureka servers come from the DNS. This information is not
    * required if the contract returns the service urls from eurekaServerServiceUrls.
    *
    * The DNS mechanism is used when useDnsForFetchingServiceUrls is set to true and the
    * eureka client expects the DNS to configured a certain way so that it can fetch
    * changing eureka servers dynamically. The changes are effective at runtime.
    */
    private String eurekaServerURLContext;
    
    /**
    * Gets the port to be used to construct the service url to contact eureka server when
    * the list of eureka servers come from the DNS.This information is not required if
    * the contract returns the service urls eurekaServerServiceUrls(String).
    *
    * The DNS mechanism is used when useDnsForFetchingServiceUrls is set to true and the
    * eureka client expects the DNS to configured a certain way so that it can fetch
    * changing eureka servers dynamically.
    *
    * The changes are effective at runtime.
    */
    private String eurekaServerPort;
    
    /**
    * Gets the DNS name to be queried to get the list of eureka servers.This information
    * is not required if the contract returns the service urls by implementing
    * serviceUrls.
    *
    * The DNS mechanism is used when useDnsForFetchingServiceUrls is set to true and the
    * eureka client expects the DNS to configured a certain way so that it can fetch
    * changing eureka servers dynamically.
    *
    * The changes are effective at runtime.
    */
    private String eurekaServerDNSName;
    
    /**
    * Gets the region (used in AWS datacenters) where this instance resides.
    */
    private String region = "us-east-1";
    
    /**
    * Indicates how much time (in seconds) that the HTTP connections to eureka server can
    * stay idle before it can be closed.
    *
    * In the AWS environment, it is recommended that the values is 30 seconds or less,
    * since the firewall cleans up the connection information after a few mins leaving
    * the connection hanging in limbo.
    */
    private int eurekaConnectionIdleTimeoutSeconds = 30;
    
    /**
    * Indicates whether the client is only interested in the registry information for a
    * single VIP.
    */
    private String registryRefreshSingleVipAddress;
    
    /**
    * The thread pool size for the heartbeatExecutor to initialise with.
    */
    private int heartbeatExecutorThreadPoolSize = 2;
    
    /**
    * Heartbeat executor exponential back off related property. It is a maximum
    * multiplier value for retry delay, in case where a sequence of timeouts occurred.
    */
    private int heartbeatExecutorExponentialBackOffBound = 10;
    
    /**
    * The thread pool size for the cacheRefreshExecutor to initialise with.
    */
    private int cacheRefreshExecutorThreadPoolSize = 2;
    
    /**
    * Cache refresh executor exponential back off related property. It is a maximum
    * multiplier value for retry delay, in case where a sequence of timeouts occurred.
    */
    private int cacheRefreshExecutorExponentialBackOffBound = 10;
    
    /**
    * Map of availability zone to list of fully qualified URLs to communicate with eureka
    * server. Each value can be a single URL or a comma separated list of alternative
    * locations.
    *
    * Typically the eureka server URLs carry protocol,host,port,context and version
    * information if any. Example:
    * https://ec2-256-156-243-129.compute-1.amazonaws.com:7001/eureka/
    *
    * The changes are effective at runtime at the next service url refresh cycle as
    * specified by eurekaServiceUrlPollIntervalSeconds.
    */
    private Map<String, String> serviceUrl = new HashMap<>();
    
    { 
    this.serviceUrl.put(DEFAULT_ZONE, DEFAULT_URL);
    }
    
    /**
    * Indicates whether the content fetched from eureka server has to be compressed
    * whenever it is supported by the server. The registry information from the eureka
    * server is compressed for optimum network traffic.
    */
    private boolean gZipContent = true;
    
    /**
    * Indicates whether the eureka client should use the DNS mechanism to fetch a list of
    * eureka servers to talk to. When the DNS name is updated to have additional servers,
    * that information is used immediately after the eureka client polls for that
    * information as specified in eurekaServiceUrlPollIntervalSeconds.
    *
    * Alternatively, the service urls can be returned serviceUrls, but the users should
    * implement their own mechanism to return the updated list in case of changes.
    *
    * The changes are effective at runtime.
    */
    private boolean useDnsForFetchingServiceUrls = false;
    
    /**
    * Indicates whether or not this instance should register its information with eureka
    * server for discovery by others.
    *
    * In some cases, you do not want your instances to be discovered whereas you just
    * want do discover other instances.
    */
    private boolean registerWithEureka = true;
    
    /**
    * Indicates whether or not this instance should try to use the eureka server in the
    * same zone for latency and/or other reason.
    *
    * Ideally eureka clients are configured to talk to servers in the same zone
    *
    * The changes are effective at runtime at the next registry fetch cycle as specified
    * by registryFetchIntervalSeconds
    */
    private boolean preferSameZoneEureka = true;
    
    /**
    * Indicates whether to log differences between the eureka server and the eureka
    * client in terms of registry information.
    *
    * Eureka client tries to retrieve only delta changes from eureka server to minimize
    * network traffic. After receiving the deltas, eureka client reconciles the
    * information from the server to verify it has not missed out some information.
    * Reconciliation failures could happen when the client has had network issues
    * communicating to server.If the reconciliation fails, eureka client gets the full
    * registry information.
    *
    * While getting the full registry information, the eureka client can log the
    * differences between the client and the server and this setting controls that.
    *
    * The changes are effective at runtime at the next registry fetch cycle as specified
    * by registryFetchIntervalSecondsr
    */
    private boolean logDeltaDiff;
    
    /**
    * Indicates whether the eureka client should disable fetching of delta and should
    * rather resort to getting the full registry information.
    *
    * Note that the delta fetches can reduce the traffic tremendously, because the rate
    * of change with the eureka server is normally much lower than the rate of fetches.
    *
    * The changes are effective at runtime at the next registry fetch cycle as specified
    * by registryFetchIntervalSeconds
    */
    private boolean disableDelta;
    
    /**
    * Comma separated list of regions for which the eureka registry information will be
    * fetched. It is mandatory to define the availability zones for each of these regions
    * as returned by availabilityZones. Failing to do so, will result in failure of
    * discovery client startup.
    *
    */
    private String fetchRemoteRegionsRegistry;
    
    /**
    * Gets the list of availability zones (used in AWS data centers) for the region in
    * which this instance resides.
    *
    * The changes are effective at runtime at the next registry fetch cycle as specified
    * by registryFetchIntervalSeconds.
    */
    private Map<String, String> availabilityZones = new HashMap<>();
    
    /**
    * Indicates whether to get the applications after filtering the applications for
    * instances with only InstanceStatus UP states.
    */
    private boolean filterOnlyUpInstances = true;
    
    /**
    * Indicates whether this client should fetch eureka registry information from eureka
    * server.
    */
    private boolean fetchRegistry = true;
    
    /**
    * Get a replacement string for Dollar sign <code>$</code> during
    * serializing/deserializing information in eureka server.
    */
    private String dollarReplacement = "_-";
    
    /**
    * Get a replacement string for underscore sign <code>_</code> during serializing/
    * deserializing information in eureka server.
    */
    private String escapeCharReplacement = "__";
    
    /**
    * Indicates whether server can redirect a client request to a backup server/cluster.
    * If set to false, the server will handle the request directly, If set to true, it
    * may send HTTP redirect to the client, with a new server location.
    */
    private boolean allowRedirects = false;
    
    /**
    * If set to true, local status updates via ApplicationInfoManager will trigger
    * on-demand (but rate limited) register/updates to remote eureka servers.
    */
    private boolean onDemandUpdateStatusChange = true;
    
    /**
    * This is a transient config and once the latest codecs are stable, can be removed
    * (as there will only be one).
    */
    private String encoderName;
    
    /**
    * This is a transient config and once the latest codecs are stable, can be removed
    * (as there will only be one).
    */
    private String decoderName;
    
    /**
    * EurekaAccept name for client data accept.
    */
    private String clientDataAccept = EurekaAccept.full.name();
    
    /**
    * Indicates whether the client should explicitly unregister itself from the remote
    * server on client shutdown.
    */
    private boolean shouldUnregisterOnShutdown = true;
    
    /**
    * Indicates whether the client should enforce registration during initialization.
    * Defaults to false.
    */
    private boolean shouldEnforceRegistrationAtInit = false;
    
    /**
    * Order of the discovery client used by `CompositeDiscoveryClient` for sorting
    * available clients.
    */
    private int order = 0;

## 【4】项目参考配置实例(不断完善) ##

#关闭自我保护
    eureka.server.enable-self-preservation=false
    
    eureka.server.eviction-interval-timer-in-ms=6000
    
    #服务过期时间配置,超过这个时间没有接收到心跳EurekaServer就会将这个实例剔除  默认90S
    eureka.instance.lease-expiration-duration-in-seconds=30
    
    #发送心跳的间隔时间，默认30S
    eureka.instance.lease-renewal-interval-in-seconds=10
    
    #是否作为客户端注册到eureka server被其他服务实例发现 默认true
    eureka.client.register-with-eureka=false
    
    #是否从eureka server获取注册信息  默认值true
    eureka.client.fetch-registry=false
    
    #连接到eureka server的超时时间 默认5S
    eureka.client.eureka-server-connect-timeout-seconds=20
    
    #等待eureka server返回结果的超时时间 默认8S
    eureka.client.eureka-server-read-timeout-seconds=20
    
    #到eureka server的连接最大空闲时间 默认30S
    eureka.client.eureka-connection-idle-timeout-seconds=30
    
    #多久从eureka获取注册信息 默认30S
    eureka.client.registry-fetch-interval-seconds=20
    
    eureka.client.service-url.defaultZone=http://localhost:${ server.port}/eureka