1、优雅启动

1.1、说明

优雅启动的目的是为了保证在应用完全启动成功之后再接收到外部请求，否则在应用未完全准备好之前接收请求，则无法正常处理请求，会报错。

1.2、使用场景

在分布式应用中，经常会根据实际需要对应用服务集群进行扩容和缩容，而进行扩容时，即新启动加入集群的应用，应该在应用彻底启动完成后才能接收请求。

1.3、实现方案

消费方服务是从注册中心获取到提供方服务的信息，从而向提供方发起的请求。所以只需要保证在提供方应用未彻底启动之前，消费方不会从注册中心获取到提供方的信息，就不会向未启动成功的提供方发出请求了。
在应用启动完成之前，不要向Nacos-Server注册自身的信息，在应用启动完成之后，再向Nacos-Server注册。
Nacos-Client实现了SpringCloud提供的注册中心的接口，从而实现了在Springboot启动时自动注册。具体注册逻辑，可以参考此文：https://www.yuque.com/davi/pwc2vg/hdwoti
Nacos-Client在Springboot启动时自动向Server端注册时，是通过这个类：com.alibaba.cloud.nacos.registry.NacosServiceRegistry中的register方法来注册的。所以我们可以通过自定义实现一个CustomNacosServiceRegistry继承NacosServiceRegistry并且替换它，重写register方法，即可实现不自动注册。
通过自定义的CustomNacosServiceRegistry来组织它自动注册之后，还需要在应用启动完成之后再手动将应用注册到Nacos-Server。我们可以通过启动一个轮询线程NacosRegisterTask，这个轮询线程将会在应用启动期间不停的轮询应用的状态，如果应用的状态处于启动完成、可注册，那么该线程就会把应用注册到Nacos-Server。

  1. import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
  2. import com.alibaba.cloud.nacos.registry.NacosServiceRegistry;
  3. import com.alibaba.nacos.api.naming.NamingService;
  4. import com.alibaba.nacos.api.naming.pojo.Instance;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  9. import org.springframework.cloud.client.serviceregistry.Registration;
  12. public class CustomNacosServiceRegistry extends NacosServiceRegistry {
  13.     private static final Logger log = LoggerFactory.getLogger(CustomNacosServiceRegistry.class);
  15.     private final NacosDiscoveryProperties nacosDiscoveryProperties;
  17.     private final NamingService namingService;
  19.     public CustomNacosServiceRegistry(NacosDiscoveryProperties nacosDiscoveryProperties) {
  20.         super(nacosDiscoveryProperties);
  21.         this.nacosDiscoveryProperties = nacosDiscoveryProperties;
  22.         this.namingService = nacosDiscoveryProperties.namingServiceInstance();
  23.     }
  26.     @Override
  27.     public void register(Registration registration) {
  29.         if (StringUtils.isEmpty(registration.getServiceId())) {
  30.             log.warn("No service to register for nacos client...");
  31.             return;
  32.         }
  34.         String serviceId = registration.getServiceId();
  36.         Instance instance = getNacosInstanceFromRegistration(registration);
  37.         //将实例的健康状态设置为false，注册到nacos的实例就不会接受请求
  38.         instance.setEnabled(false);
  39.         try {
  40.             namingService.registerInstance(serviceId, instance);
  41.             log.warn("The system is not ready now, relegate to register thread to do register on nacos. ");
  43.             //创建轮训任务
  44.             new NacosRegisterTask(instance, namingService, serviceId).start();
  45.         } catch (Exception e) {
  46.             log.error("nacos registry, {} register failed...{},", serviceId,
  47.                     registration.toString(), e);
  48.         }
  49.     }
  51.     private Instance getNacosInstanceFromRegistration(Registration registration) {
  52.         Instance instance = new Instance();
  53.         instance.setIp(registration.getHost());
  54.         instance.setPort(registration.getPort());
  55.         instance.setWeight(nacosDiscoveryProperties.getWeight());
  56.         instance.setClusterName(nacosDiscoveryProperties.getClusterName());
  57.         instance.setMetadata(registration.getMetadata());
  58.         return instance;
  59.     }
  60. }

如何用自定义的CustomNacosServiceRegistry替换原本的NacosServiceRegistry呢？原本的NacosServiceRegistry是会注册到Spring容器中的，那么我们可以将自定义的CustomNacosServiceRegistry也注册到容器中，并且设置优先级高于原本的NacosServiceRegistry，这样Springboot启动时获取注册中心实现的Bean时就会优先获取到我们自定义的CustomNacosServiceRegistry。

  2. import cn.sunline.adp.boot.cedar.handler.CustomNacosServiceRegistry;
  3. import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
  4. import com.alibaba.cloud.nacos.registry.NacosServiceRegistry;
  5. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.context.annotation.Primary;
  10. @ConditionalOnProperty(name="spring.cloud.nacos.discovery.enabled",havingValue ="true",matchIfMissing=false)
  11. @Configuration
  12. public class NacosRegistryConfig {
  13.     //设置一个标识位，标识应用当前的状态是否可以注册
  14.     private boolean isRegistryNow=false;
  17.     public boolean isRegistryNow() {
  18.         return isRegistryNow;
  19.     }
  21.     //在应用启动完成之后，通过该set方法将标识位置为true
  22.     public void setRegistryNow(boolean isRegistryNow) {
  23.         this.isRegistryNow = isRegistryNow;
  24.     }    
  26.     @Bean("NacosServiceRegistry") //指定BeanName，防止与原本的NacosServiceRegistry冲突
  27.     @Primary //通过该注解可以设置Bean的优先级
  28.     public NacosServiceRegistry nacosServiceRegistry(NacosDiscoveryProperties nacosDiscoveryProperties) {
  29.         return new CustomNacosServiceRegistry(nacosDiscoveryProperties);
  30.     }
  31. }
  1. package cn.sunline.adp.boot.cedar.handler;
  3. import cn.sunline.adp.boot.configuration.NacosRegistryConfig;
  4. import cn.sunline.adp.cedar.base.logging.SysLog;
  5. import cn.sunline.adp.cedar.base.logging.SysLogUtil;
  6. import cn.sunline.adp.core.GlobalContext;
  7. import cn.sunline.adp.core.util.SpringUtils;
  8. import com.alibaba.nacos.api.exception.NacosException;
  9. import com.alibaba.nacos.api.naming.NamingService;
  10. import com.alibaba.nacos.api.naming.pojo.Instance;
  12. import org.slf4j.Logger;
  13. import org.slf4j.LoggerFactory;
  15. public class NacosRegisterTask {
  16.     private static final Logger log = LoggerFactory.getLogger(NacosRegisterTask.class);
  18.     private Instance instance;
  19.     private final NamingService namingService;
  20.     private String serviceId;
  21.     public NacosOnline(Instance instance, NamingService namingService, String serviceId) {
  22.         this.instance=instance;
  23.         this.namingService=namingService;
  24.         this.serviceId=serviceId;
  25.     }
  27.     public  void  start() {
  28.         //启动轮训线程
  29.         new NacosRegistryThread().start();
  30.     }
  32.     class NacosRegistryThread extends Thread{
  33.         //从Spring容器中获取设置的应用状态标识位
  34.         NacosRegistryConfig nacosConfig= SpringUtils.getBean(NacosRegistryConfig.class);
  36.         @Override
  37.         public void run() {
  38.             try {
  39.                 //如果应用当前的状态是false，则自旋1秒
  40.                 while(!nacosConfig.isRegistryNow()){
  41.                     TimeUnit.SECOND.sleep(1);
  42.                 }
  43.                 //将实例的健康状态设置为true
  44.                 instance.setEnabled(true);
  45.                 namingService.registerInstance(serviceId, instance);
  46.                 log.info("The system is ready now, register to nacos success.");
  47.             } catch (NacosException e) {
  48.                 e.printStackTrace();
  49.             } catch (InterruptedException e) {
  50.                 e.printStackTrace();
  51.             }
  52.             String status=nacosConfig.isRegistryNow()==true?" online":" offline";
  53.             log.info("nacos registry, {} {}:{} register "+status+" finished", serviceId,
  54.                     instance.getIp(), instance.getPort());
  56.         }
  58. }

注意：一定要在系统启动完成之后，将系统状态标识位置为true，否则轮训线程会一直轮训，且不会注册到Nacos-server

2、优雅停机

2.1、说明

优雅停机的目的是为了在应用停机下线时，也应该保证该应用中所有的服务请求都正确执行完毕。

2.2、使用场景

在分布式应用中，经常会根据实际需要对应用服务集群进行扩容和缩容，而进行缩容时，即准备要停机下线的应用，也应该保证该应用中所有的服务请求都正确执行完毕。

2.3、实现方案

首先要明确一个前提，在Linux系统中，关闭一个JVM进程，通常是通过kill命令，而kill命令常用的有kill -9和kill -15。kill -9和kill -15这两种命令的区别，这里就不在赘述，如果使用kill -9命令来停机，那就不用考虑什么优雅停机了，所以我们在生产环境中是禁止使用kill -9命令停机的。而使用kill -15命令时，JVM就不会马上关闭，而是先做一些准备工作，并且提供了一个钩子函数：Runtime.getRuntime().addShutdownHook(this.shutdownHook)来给用户做一些关闭前的准备工作。
Spring就是通过这个钩子函数来接收关闭容器的信号的。Spring在启动过程中，在刷新容器refreshContext时，向JVM注册了这个钩子。

当应用准备停机下线时，该应用中很有可能还有正在处理中的服务，必须要保证这些正在处理中的服务能够正常处理完成之后，应用才停机。并且，当应用准备下线停机时，就不要再从外部接收新的请求了，所以需要应用主动的从Nacos中下线，这样就不会有新的请求发进来了。
总的来说，优雅停机就是两个步骤。第一步：主动从注册中心下线。第二步：将应用中正在处理的服务执行完毕再停机即可。
Spring容器在准备关闭之前，会发布一个事件：ContextClosedEvent。我们可以通过监听这个事件来知道什么时候要关闭应用了。
第一步：主动从注册中心下线。Nacos实现了SpringCloud提供的统一服务注册的接口：org.springframework.cloud.client.serviceregistry.ServiceRegistry。我们可以通过从Spring容器中获取该ServiceRegistry的Bean，且调用其deregister方法即可实现主动下线。而Nacos在消费方还有一个本地缓存的机制，消费方从Nacos中获取到服务信息之后，会在本地保存一个缓存，并定期刷新该缓存，当我们的提供方服务主动从nacos下线之后，还需要等待一段时间，直到所有消费方都刷新本地缓存。
第二步：等待应用中正在处理的服务执行完毕。这个步骤需要考虑到具体的web容器了，SpringBoot内置了几种常用的，比如Tomcat、Jetty、Undertown。这几种不通的web容器，具体停机的实现方式不同。这里仅给出这三种常用容器的停机策略，看代码。

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.context.event.ContextClosedEvent;
  3. import org.springframework.context.event.SmartApplicationListener;
  4. import org.springframework.core.Ordered;
  5. import org.apache.catalina.connector.Connector;
  6. import org.apache.catalina.startup.Tomcat;
  7. import org.springframework.beans.factory.NoSuchBeanDefinitionException;
  8. import org.springframework.boot.web.context.ConfigurableWebServerApplicationContext;
  9. import org.springframework.boot.web.context.WebServerInitializedEvent;
  10. import org.springframework.boot.web.embedded.jetty.JettyWebServer;
  11. import org.springframework.boot.web.embedded.tomcat.TomcatWebServer;
  12. import org.springframework.boot.web.embedded.undertow.UndertowServletWebServer;
  13. import org.springframework.boot.web.server.WebServer;
  14. import org.springframework.cloud.client.serviceregistry.AbstractAutoServiceRegistration;
  15. import org.springframework.cloud.client.serviceregistry.Registration;
  16. import org.springframework.cloud.client.serviceregistry.ServiceRegistry;
  17. import org.springframework.cloud.netflix.eureka.serviceregistry.EurekaAutoServiceRegistration;
  18. import org.springframework.context.ApplicationContext;
  19. import org.springframework.context.ApplicationEvent;
  20. import org.springframework.util.ReflectionUtils;
  22. import io.micrometer.core.instrument.MeterRegistry;
  23. import io.micrometer.core.instrument.binder.jvm.ExecutorServiceMetrics;
  24. import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
  25. import io.undertow.Undertow;
  26. import io.undertow.server.ConnectorStatistics;
  28. import java.lang.reflect.Field;
  29. import java.util.List;
  30. import java.util.concurrent.Executor;
  31. import java.util.concurrent.ExecutorService;
  32. import java.util.concurrent.ThreadPoolExecutor;
  33. import java.util.concurrent.TimeUnit;
  34. import java.util.concurrent.atomic.AtomicInteger;
  36. import org.slf4j.Logger;
  37. import org.slf4j.LoggerFactory;
  39. /**
  40.  * 自定义监听器控制服务注册
  41.  * 
  42.  *
  43.  */
  44. public class GracefulRegistryInstanceListener implements SmartApplicationListener {
  46.     private static final Logger log = LoggerFactory.getLogger(GracefulRegistryInstanceListener.class);
  49.     @Override
  50.     public boolean supportsSourceType(Class<?> sourceType) {
  51.         return true;
  52.     }
  54.     @Override
  55.     public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
  56.         return WebServerInitializedEvent.class.isAssignableFrom(eventType)
  57.                 || ContextClosedEvent.class.isAssignableFrom(eventType);
  58.     }
  60.     private WebServerInitializedEvent event;
  62.     private final int waitTime = 30;
  64.     private ApplicationContext context;
  66.     private WebServer webServer;
  68.     @Override
  69.     public void onApplicationEvent(ApplicationEvent event) {
  70.         //在Springboot启动时获取到当前使用的web容器
  71.         if (event instanceof WebServerInitializedEvent) {
  72.             onWebServerInitializedEvent((WebServerInitializedEvent) event);
  73.         } else if(event instanceof ContextClosedEvent){
  74.             //监听容器关闭时发布的ContextClosedEvent事件
  75.             onContextClosedEvent((ContextClosedEvent) event);
  76.         }
  77.     }
  79.     @Override
  80.     public int getOrder() {
  81.         return Ordered.HIGHEST_PRECEDENCE;
  82.     }
  84.     private void onWebServerInitializedEvent(WebServerInitializedEvent event) {
  85.         ApplicationContext context = event.getApplicationContext();
  86.         if (context instanceof ConfigurableWebServerApplicationContext) {
  87.             this.context = context;
  88.             this.event = (WebServerInitializedEvent) event;
  89.             this.webServer = ((WebServerInitializedEvent) event).getWebServer();
  90.         }
  91.     }
  95.     private void onContextClosedEvent(ContextClosedEvent event) {
  96.         if(webServer == null) {
  97.             return;
  98.         }
  99.         //第一步：服务主动下线
  100.         ServiceRegistry serviceRegistry=context.getBean(ServiceRegistry.class);
  101.         serviceRegistry.deregister(context.getBean(Registration.class));
  102.         //休眠1min，等待消费方刷新本地缓存
  103.         try{
  104.             TimeUnit.SECOND.sleep(60);
  105.         }cache(Exception e){
  107.         }
  109.         //第二步：等待容器中正在处理的服务执行完毕，再关闭容器
  110.         if (webServer instanceof TomcatWebServer) {
  111.             TomcatWebServer tomcatWebServer = (TomcatWebServer) webServer;
  112.             Tomcat tomcat = tomcatWebServer.getTomcat();
  113.             Connector connector = tomcat.getConnector();
  114.             connector.pause();
  115.             Executor executor = connector.getProtocolHandler().getExecutor();
  116.             if (executor instanceof ThreadPoolExecutor) {
  117.                 try {
  118.                     ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
  119.                     threadPoolExecutor.shutdown();
  120.                     if (!threadPoolExecutor.awaitTermination(waitTime, TimeUnit.SECONDS)) {
  121.                         LOGGER.info(
  122.                                 "Tomcat thread pool did not shut down gracefully within {} seconds. Proceeding with forceful shutdown.",
  123.                                 waitTime);
  124.                     }
  125.                 } catch (InterruptedException ex) {
  126.                     Thread.currentThread().interrupt();
  127.                 }
  128.             }
  129.         } else if (webServer instanceof JettyWebServer) {
  130.             webServer.stop();
  131.         } else if (webServer instanceof UndertowServletWebServer) {
  132.             UndertowShutdownWrapper gracefulShutdownWrapper = SpringUtils.getBean(UndertowShutdownWrapper.class);
  133.             gracefulShutdownWrapper.getGracefulShutdownHandler().shutdown();
  134.             UndertowServletWebServer undertowWebserver = (UndertowServletWebServer) webServer;
  135.             try {
  136.                 Field field = undertowWebserver.getClass().getDeclaredField("undertow");
  137.                 field.setAccessible(true);
  138.                 Undertow undertow = (Undertow) field.get(undertowWebserver);
  139.                 List<Undertow.ListenerInfo> listenerInfo = undertow.getListenerInfo();
  140.                 Undertow.ListenerInfo listener = listenerInfo.get(0);
  141.                 ConnectorStatistics connectorStatistics = listener.getConnectorStatistics();
  142.                 long beginTime = System.currentTimeMillis();
  143.                 while (connectorStatistics.getActiveConnections() > 0) {
  144.                     long nowTime = System.currentTimeMillis();
  145.                     if ((nowTime - beginTime) > 30 * 1000) {
  146.                         break;
  147.                     }
  148.                     Thread.sleep(50);
  149.                 }
  150.             } catch (Exception e) {
  151.                 // TODO: handle exception
  153.             }
  154.         }
  155.     }
  156. }