org.apache.dubbo.rpc.RpcException: No provider available from registry localhost:9090 for service xxxx on consumer 192.168.20.92.1 use dubbo version 2.7.8, please check status of providers(disabled, not registered or in blacklist).at org.apache.dubbo.registry.integration.RegistryDirectory.doList(RegistryDirectory.java:599)  at org.apache.dubbo.rpc.cluster.directory.AbstractDirectory.list(AbstractDirectory.java:74)  at org.apache.dubbo.rpc.cluster.support.AbstractClusterInvoker.list(AbstractClusterInvoker.java:292)  at org.apache.dubbo.rpc.cluster.support.AbstractClusterInvoker.invoke(AbstractClusterInvoker.java:257)  at org.apache.dubbo.rpc.cluster.interceptor.ClusterInterceptor.intercept(ClusterInterceptor.java:47)  at org.apache.dubbo.rpc.cluster.support.wrapper.AbstractCluster$InterceptorInvokerNode.invoke(AbstractCluster.java:92)  at org.apache.dubbo.rpc.cluster.support.wrapper.MockClusterInvoker.invoke(MockClusterInvoker.java:88)  at org.apache.dubbo.rpc.proxy.InvokerInvocationHandler.invoke(InvokerInvocationHandler.java:74)

public ConfigurableApplicationContext run(String... args) {    StopWatch stopWatch = new StopWatch();    stopWatch.start();    ConfigurableApplicationContext context = null;    configureHeadlessProperty();    SpringApplicationRunListeners listeners = getRunListeners(args);    listeners.starting();    try {      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);      ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);      configureIgnoreBeanInfo(environment);      Banner printedBanner = printBanner(environment);      context = createApplicationContext();      prepareContext(context, environment, listeners, applicationArguments, printedBanner);      refreshContext(context);//这里就是总入口      afterRefresh(context, applicationArguments);      stopWatch.stop();      if (this.logStartupInfo) {        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);      }      listeners.started(context);      callRunners(context, applicationArguments);    }    catch (Throwable ex) {      handleRunFailure(context, ex, listeners);      throw new IllegalStateException(ex);    }
    try {      listeners.running(context);    }    catch (Throwable ex) {      handleRunFailure(context, ex, null);      throw new IllegalStateException(ex);    }    return context;  }

  public void start() {    if (!isEnabled()) {      if (logger.isDebugEnabled()) {        logger.debug("Discovery Lifecycle disabled. Not starting");      }      return;    }
    // only initialize if nonSecurePort is greater than 0 and it isn't already running    // because of containerPortInitializer below    if (!this.running.get()) {      this.context.publishEvent(          new InstancePreRegisteredEvent(this, getRegistration()));      register();//这里是注册的上层接口定义      if (shouldRegisterManagement()) {        registerManagement();      }      this.context.publishEvent(          new InstanceRegisteredEvent<>(this, getConfiguration()));      this.running.compareAndSet(false, true);    }
  }

public void register(Registration registration) {        if (StringUtils.isEmpty(registration.getServiceId())) {            log.warn("No service to register for nacos client...");        } else {            NamingService namingService = this.namingService();            String serviceId = registration.getServiceId();            String group = this.nacosDiscoveryProperties.getGroup();            Instance instance = this.getNacosInstanceFromRegistration(registration);
            try {                namingService.registerInstance(serviceId, group, instance);                log.info("nacos registry, {} {} {}:{} register finished", new Object[]{group, serviceId, instance.getIp(), instance.getPort()});            } catch (Exception var7) {                if (this.nacosDiscoveryProperties.isFailFast()) {                    log.error("nacos registry, {} register failed...{},", new Object[]{serviceId, registration.toString(), var7});                    ReflectionUtils.rethrowRuntimeException(var7);                } else {                    log.warn("Failfast is false. {} register failed...{},", new Object[]{serviceId, registration.toString(), var7});                }            }
        }    }

public DubboBootstrap start() {        if (started.compareAndSet(false, true)) {            ready.set(false);            initialize();            if (logger.isInfoEnabled()) {                logger.info(NAME + " is starting...");            }            // 1. export Dubbo Services //暴露dubbo服务            exportServices();
            // Not only provider register            if (!isOnlyRegisterProvider() || hasExportedServices()) {                // 2. export MetadataService //暴露dubbo服务元数据服务                exportMetadataService();                //3. Register the local ServiceInstance if required                registerServiceInstance(); //注册dubbo服务实例            }
            referServices();            if (asyncExportingFutures.size() > 0) {                new Thread(() -> {                    try {                        this.awaitFinish();                    } catch (Exception e) {                        logger.warn(NAME + " exportAsync occurred an exception.");                    }                    ready.set(true);                    if (logger.isInfoEnabled()) {                        logger.info(NAME + " is ready.");                    }                }).start();            } else {                ready.set(true);                if (logger.isInfoEnabled()) {                    logger.info(NAME + " is ready.");                }            }            if (logger.isInfoEnabled()) {                logger.info(NAME + " has started.");            }        }        return this;    }

package com.alibaba.cloud.dubbo.autoconfigure;.........import static com.alibaba.cloud.dubbo.autoconfigure.DubboServiceRegistrationAutoConfiguration.CONSUL_AUTO_SERVICE_AUTO_CONFIGURATION_CLASS_NAME;import static com.alibaba.cloud.dubbo.autoconfigure.DubboServiceRegistrationAutoConfiguration.EUREKA_CLIENT_AUTO_CONFIGURATION_CLASS_NAME;import static com.alibaba.cloud.dubbo.registry.SpringCloudRegistryFactory.ADDRESS;import static com.alibaba.cloud.dubbo.registry.SpringCloudRegistryFactory.PROTOCOL;import static org.springframework.util.ObjectUtils.isEmpty;
/** * Dubbo Service Registration Auto-{@link Configuration}. * * @author Mercy * @author theonefx */@Configuration(proxyBeanMethods = false)@Import({ DubboServiceRegistrationEventPublishingAspect.class,    DubboBootstrapStartCommandLineRunner.class })@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled",    matchIfMissing = true)@AutoConfigureAfter(name = { EUREKA_CLIENT_AUTO_CONFIGURATION_CLASS_NAME,    CONSUL_AUTO_SERVICE_AUTO_CONFIGURATION_CLASS_NAME,    "org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration" },    value = { DubboMetadataAutoConfiguration.class })public class DubboServiceRegistrationAutoConfiguration {
    /**   * EurekaClientAutoConfiguration.   */  public static final String EUREKA_CLIENT_AUTO_CONFIGURATION_CLASS_NAME = "org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration";
  /**   * ConsulAutoServiceRegistrationAutoConfiguration.   */  public static final String CONSUL_AUTO_SERVICE_AUTO_CONFIGURATION_CLASS_NAME = "org.springframework.cloud.consul.serviceregistry.ConsulAutoServiceRegistrationAutoConfiguration";
  /**   * ConsulAutoRegistration.   */  public static final String CONSUL_AUTO_SERVICE_AUTO_REGISTRATION_CLASS_NAME = "org.springframework.cloud.consul.serviceregistry.ConsulAutoRegistration";
  /**   * ZookeeperAutoServiceRegistrationAutoConfiguration.   */  public static final String ZOOKEEPER_AUTO_SERVICE_AUTO_CONFIGURATION_CLASS_NAME = "org.springframework.cloud.zookeeper.serviceregistry.ZookeeperAutoServiceRegistrationAutoConfiguration";
  private static final Logger logger = LoggerFactory      .getLogger(DubboServiceRegistrationAutoConfiguration.class);
  @Autowired  private DubboServiceMetadataRepository dubboServiceMetadataRepository;
  @Bean  @Conditional({ MissingSpringCloudRegistryConfigPropertyCondition.class })  public RegistryConfig defaultSpringCloudRegistryConfig() {    return new RegistryConfig(ADDRESS, PROTOCOL);  }
  private Map, Set> registrations = new ConcurrentHashMap<>();
  @EventListener(DubboBootstrapStartedEvent.class)  public void onDubboBootstrapStarted(DubboBootstrapStartedEvent event) {    if (!event.getSource().isReady()) {      return;    }    registrations.forEach(        (registry, registrations) -> registrations.forEach(registration -> {          attachDubboMetadataServiceMetadata(registration);          registry.register(registration);        }));  }
  @EventListener(ServiceInstancePreRegisteredEvent.class)  public void onServiceInstancePreRegistered(ServiceInstancePreRegisteredEvent event) {    Registration registration = event.getSource();    if (!DubboBootstrap.getInstance().isReady()        || !DubboBootstrap.getInstance().isStarted()) {      ServiceRegistry registry = event.getRegistry();      synchronized (registry) {        registrations.putIfAbsent(registry, new HashSet<>());        registrations.get(registry).add(registration);      }    }    else {      attachDubboMetadataServiceMetadata(registration);    }
  }
  @EventListener(ServiceInstancePreDeregisteredEvent.class)  public void onServiceInstancePreDeregistered(      ServiceInstancePreDeregisteredEvent event) {    ServiceRegistry registry = event.getRegistry();    registrations.remove(registry);  }
  private void attachDubboMetadataServiceMetadata(Registration registration) {    if (registration == null) {      return;    }    synchronized (registration) {      Map metadata = registration.getMetadata();      attachDubboMetadataServiceMetadata(metadata);    }  }
  private void attachDubboMetadataServiceMetadata(Map metadata) {    Map serviceMetadata = dubboServiceMetadataRepository        .getDubboMetadataServiceMetadata();    if (!isEmpty(serviceMetadata)) {      metadata.putAll(serviceMetadata);    }  }    ......................................
}

@Componentpublic class DubboBootstrapStartCommandLineRunner    implements CommandLineRunner, ApplicationEventPublisherAware {
  private ApplicationEventPublisher applicationEventPublisher;
  @Override  public void setApplicationEventPublisher(      ApplicationEventPublisher applicationEventPublisher) {    this.applicationEventPublisher = applicationEventPublisher;  }
  @Override  public void run(String... args) {    applicationEventPublisher.publishEvent(        new DubboBootstrapStartedEvent(DubboBootstrapWrapper.getInstance()));  }
}

@EventListener(DubboBootstrapStartedEvent.class)public void onDubboBootstrapStarted(DubboBootstrapStartedEvent event) {    if (!event.getSource().isReady()) {      return;    }    registrations.forEach(        (registry, registrations) -> registrations.forEach(registration -> {          attachDubboMetadataServiceMetadata(registration);          registry.register(registration);        }));}

@Aspectpublic class DubboServiceRegistrationEventPublishingAspect    implements ApplicationEventPublisherAware {
  /**   * The pointcut expression for {@link ServiceRegistry#register(Registration)}.   */  public static final String REGISTER_POINTCUT_EXPRESSION = "execution(* org.springframework.cloud.client.serviceregistry.ServiceRegistry.register(*)) && target(registry) && args(registration)";
  /**   * The pointcut expression for {@link ServiceRegistry#deregister(Registration)}.   */  public static final String DEREGISTER_POINTCUT_EXPRESSION = "execution(* org.springframework.cloud.client.serviceregistry.ServiceRegistry.deregister(*)) && target(registry) && args(registration)";
  private ApplicationEventPublisher applicationEventPublisher;
    //服务预注册事件的发布  @Before(value = REGISTER_POINTCUT_EXPRESSION, argNames = "registry, registration")  public void beforeRegister(ServiceRegistry registry, Registration registration) {    applicationEventPublisher.publishEvent(        new ServiceInstancePreRegisteredEvent(registry, registration));  }
    //服务注销事件的发布  @Before(value = DEREGISTER_POINTCUT_EXPRESSION, argNames = "registry, registration")  public void beforeDeregister(ServiceRegistry registry, Registration registration) {    applicationEventPublisher.publishEvent(        new ServiceInstancePreDeregisteredEvent(registry, registration));  }        //服务册事件完成后的事件发布  @After(value = REGISTER_POINTCUT_EXPRESSION, argNames = "registry, registration")  public void afterRegister(ServiceRegistry registry, Registration registration) {    applicationEventPublisher        .publishEvent(new ServiceInstanceRegisteredEvent(registration));  }
  @Override  public void setApplicationEventPublisher(      ApplicationEventPublisher applicationEventPublisher) {    this.applicationEventPublisher = applicationEventPublisher;  }
}

package com.alibaba.cloud.dubbo.registry;@Aspectpublic class DubboServiceRegistrationEventPublishingAspect        implements ApplicationEventPublisherAware {
    /**     * The pointcut expression for {@link ServiceRegistry#register(Registration)}.     */    public static final String REGISTER_POINTCUT_EXPRESSION = "execution(* org.springframework.cloud.client.serviceregistry.ServiceRegistry.register(*)) && target(registry) && args(registration)";
    /**     * The pointcut expression for {@link ServiceRegistry#deregister(Registration)}.     */    public static final String DEREGISTER_POINTCUT_EXPRESSION = "execution(* org.springframework.cloud.client.serviceregistry.ServiceRegistry.deregister(*)) && target(registry) && args(registration)";
    private ApplicationEventPublisher applicationEventPublisher;
    private static DubboBootstrap dubboBootstrap;//这里是新增的代码
    static {        //这里是新增的代码        dubboBootstrap = DubboBootstrap.getInstance();    }
    @Before(value = REGISTER_POINTCUT_EXPRESSION, argNames = "registry, registration")    public void beforeRegister(ServiceRegistry registry, Registration registration) {        dubboBootstrap.start();//这里是新增的代码        applicationEventPublisher.publishEvent(                new ServiceInstancePreRegisteredEvent(registry, registration));    }
    @Before(value = DEREGISTER_POINTCUT_EXPRESSION, argNames = "registry, registration")    public void beforeDeregister(ServiceRegistry registry, Registration registration) {        dubboBootstrap.stop();//这里是新增的代码        applicationEventPublisher.publishEvent(                new ServiceInstancePreDeregisteredEvent(registry, registration));    }
    @After(value = REGISTER_POINTCUT_EXPRESSION, argNames = "registry, registration")    public void afterRegister(ServiceRegistry registry, Registration registration) {        applicationEventPublisher                .publishEvent(new ServiceInstanceRegisteredEvent(registration));    }
    @Override    public void setApplicationEventPublisher(            ApplicationEventPublisher applicationEventPublisher) {        this.applicationEventPublisher = applicationEventPublisher;    }
}

public class DubboBootstrapApplicationListener extends OneTimeExecutionApplicationContextEventListener        implements Ordered {
    /**     * The bean name of {@link DubboBootstrapApplicationListener}     *     * @since 2.7.6     */    public static final String BEAN_NAME = "dubboBootstrapApplicationListener";
    private final DubboBootstrap dubboBootstrap;
    public DubboBootstrapApplicationListener() {        this.dubboBootstrap = DubboBootstrap.getInstance();    }
    @Override    public void onApplicationContextEvent(ApplicationContextEvent event) {        if (event instanceof ContextRefreshedEvent) {            //onContextRefreshedEvent((ContextRefreshedEvent) event); 注释这一行，这个逻辑已经放到上面的DubboServiceRegistrationEventPublishingAspect里面来触发了        } else if (event instanceof ContextClosedEvent) {            onContextClosedEvent((ContextClosedEvent) event);        }    }
    private void onContextRefreshedEvent(ContextRefreshedEvent event) {        dubboBootstrap.start();    }
    private void onContextClosedEvent(ContextClosedEvent event) {        dubboBootstrap.stop();    }
    @Override    public int getOrder() {        return LOWEST_PRECEDENCE;    }}

public class DubboBootstrapApplicationListener extends OneTimeExecutionApplicationContextEventListener        implements Ordered {
    /**     * The bean name of {@link DubboBootstrapApplicationListener}     *     * @since 2.7.6     */    public static final String BEAN_NAME = "dubboBootstrapApplicationListener";
    private final DubboBootstrap dubboBootstrap;
    public DubboBootstrapApplicationListener() {        this.dubboBootstrap = DubboBootstrap.getInstance();    }

    /*@Override    public void onApplicationContextEvent(ApplicationContextEvent event) {        if (event instanceof ContextRefreshedEvent) {            onContextRefreshedEvent((ContextRefreshedEvent) event);        } else if (event instanceof ContextClosedEvent) {            onContextClosedEvent((ContextClosedEvent) event);        }    }*/
    @Override    public void onApplicationContextEvent(ApplicationEvent event) {        if (event instanceof InstancePreRegisteredEvent) {            onContextRefreshedEvent((InstancePreRegisteredEvent) event);        } else if (event instanceof ContextClosedEvent) {            onContextClosedEvent((ContextClosedEvent) event);        }    }
    /*private void onContextRefreshedEvent(ContextRefreshedEvent event) {        dubboBootstrap.start();    }*/
    private void onContextRefreshedEvent(InstancePreRegisteredEvent event) {        dubboBootstrap.start();    }
    /*private void onContextClosedEvent(ContextClosedEvent event) {        dubboBootstrap.stop();    }*/
    private void onContextClosedEvent(ContextClosedEvent event) {        dubboBootstrap.stop();    }
    @Override    public int getOrder() {        return LOWEST_PRECEDENCE;    }}

public class DubboLifecycleComponentApplicationListener extends OneTimeExecutionApplicationContextEventListener {
    /**     * The bean name of {@link DubboLifecycleComponentApplicationListener}     *     * @since 2.7.6     */    public static final String BEAN_NAME = "dubboLifecycleComponentApplicationListener";
    private List lifecycleComponents = emptyList();
   /* @Override    protected void onApplicationContextEvent(ApplicationContextEvent event) {        if (event instanceof ContextRefreshedEvent) {            onContextRefreshedEvent((ContextRefreshedEvent) event);        } else if (event instanceof ContextClosedEvent) {            onContextClosedEvent((ContextClosedEvent) event);        }    }*/

    @Override    protected void onApplicationContextEvent(ApplicationEvent event) {        if (event instanceof InstancePreRegisteredEvent) {            onContextRefreshedEvent((InstancePreRegisteredEvent) event);        } else if (event instanceof ContextClosedEvent) {            onContextClosedEvent((ContextClosedEvent) event);        }    }
  /*  protected void onContextRefreshedEvent(ContextRefreshedEvent event) {        initLifecycleComponents(event);        startLifecycleComponents();    }*/
    protected void onContextRefreshedEvent(InstancePreRegisteredEvent event) {        initLifecycleComponents(event);        startLifecycleComponents();    }
    protected void onContextClosedEvent(ContextClosedEvent event) {        destroyLifecycleComponents();    }
    /*private void initLifecycleComponents(ContextRefreshedEvent event) {        ApplicationContext context = event.getApplicationContext();        ClassLoader classLoader = context.getClassLoader();        lifecycleComponents = new LinkedList<>();        // load the Beans of Lifecycle from ApplicationContext        loadLifecycleComponents(lifecycleComponents, context);    }*/
    private void initLifecycleComponents(InstancePreRegisteredEvent event) {        ApplicationContext context = SpringUtils.getApplicationContext();        ClassLoader classLoader = context.getClassLoader();        lifecycleComponents = new LinkedList<>();        // load the Beans of Lifecycle from ApplicationContext        loadLifecycleComponents(lifecycleComponents, context);    }
    private void loadLifecycleComponents(List lifecycleComponents, ApplicationContext context) {        lifecycleComponents.addAll(beansOfTypeIncludingAncestors(context, Lifecycle.class).values());    }
    private void startLifecycleComponents() {        lifecycleComponents.forEach(Lifecycle::start);    }
    private void destroyLifecycleComponents() {        lifecycleComponents.forEach(Lifecycle::destroy);    }}

abstract class OneTimeExecutionApplicationContextEventListener implements ApplicationListener, ApplicationContextAware {
    private ApplicationContext applicationContext;
   /* public final void onApplicationEvent(ApplicationEvent event) {        if (isOriginalEventSource(event) && event instanceof ApplicationContextEvent) {            onApplicationContextEvent((ApplicationContextEvent) event);        }    }*/
    public final void onApplicationEvent(ApplicationEvent event) {        if (isOriginalEventSource(event) && event instanceof InstancePreRegisteredEvent) {            onApplicationContextEvent((ApplicationContextEvent) event);        }    }

    /**     * The subclass overrides this method to handle {@link ApplicationContextEvent}     *     * @param event {@link ApplicationContextEvent}     */    //protected abstract void onApplicationContextEvent(ApplicationContextEvent event);    protected abstract void onApplicationContextEvent(ApplicationEvent event);
    /**     * Is original {@link ApplicationContext} as the event source     *     * @param event {@link ApplicationEvent}     * @return     */    /*private boolean isOriginalEventSource(ApplicationEvent event) {        return (applicationContext == null) // Current ApplicationListener is not a Spring Bean, just was added                // into Spring's ConfigurableApplicationContext                || Objects.equals(applicationContext, event.getSource());    }*/        private boolean isOriginalEventSource(ApplicationEvent event) {        return (applicationContext == null) // Current ApplicationListener is not a Spring Bean, just was added                // into Spring's ConfigurableApplicationContext                || Objects.equals(applicationContext, event.getSource());    }
    @Override    public final void setApplicationContext(ApplicationContext applicationContext) throws BeansException {        this.applicationContext = applicationContext;    }
    public ApplicationContext getApplicationContext() {        return applicationContext;    }}

@EventListener(ServiceInstancePreRegisteredEvent.class)  public void onServiceInstancePreRegistered(ServiceInstancePreRegisteredEvent event) {    Registration registration = event.getSource();    if (!DubboBootstrap.getInstance().isReady()        || !DubboBootstrap.getInstance().isStarted()) {      ServiceRegistry registry = event.getRegistry();      synchronized (registry) {        registrations.putIfAbsent(registry, new HashSet<>());        registrations.get(registry).add(registration);      }    }    else {      attachDubboMetadataServiceMetadata(registration);    }
  }

@EventListener(DubboBootstrapStartedEvent.class)  public void onDubboBootstrapStarted(DubboBootstrapStartedEvent event) {    if (!event.getSource().isReady()) {      return;    }    registrations.forEach(        (registry, registrations) -> registrations.forEach(registration -> {          attachDubboMetadataServiceMetadata(registration);          registry.register(registration);        }));  }

import com.alibaba.cloud.nacos.registry.NacosRegistration;import com.alibaba.cloud.nacos.registry.NacosServiceRegistry;import com.alibaba.nacos.api.exception.NacosException;import com.alibaba.nacos.common.lifecycle.Closeable;import com.alibaba.nacos.common.utils.ThreadUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.boot.ApplicationArguments;import org.springframework.boot.ApplicationRunner;import org.springframework.stereotype.Component; import javax.annotation.PostConstruct;import javax.annotation.Resource;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.ScheduledThreadPoolExecutor;import java.util.concurrent.ThreadFactory;import java.util.concurrent.TimeUnit; @Componentpublic class NacosServiceInstanceUpAndDownOperator implements ApplicationRunner, Closeable {    protected Logger logger = LoggerFactory.getLogger(this.getClass());    /**     * nacos服务实例上线     */    private static final String OPERATOR_UP = "UP";    /**     * nacos服务实例下线     */    private static final String OPERATOR_DOWN = "DOWN";     @Resource    NacosServiceRegistry nacosServiceRegistry;     @Resource    NacosRegistration nacosRegistration;     private ScheduledExecutorService executorService;      @PostConstruct    public void init() {        int poolSize = 1;        this.executorService = new ScheduledThreadPoolExecutor(poolSize, new ThreadFactory() {            @Override            public Thread newThread(Runnable r) {                Thread thread = new Thread(r);                thread.setDaemon(true);                thread.setName("NacosServiceInstanceUpAndDownOperator");                return thread;            }        });    }      @Override    public void run(ApplicationArguments args) throws Exception {        long delayDown = 5000L;  //下线任务延迟        long delayUp = 10000L;   // 上线任务延迟        this.executorService.schedule(new InstanceDownAndUpTask(nacosServiceRegistry, nacosRegistration, OPERATOR_DOWN), delayDown, TimeUnit.MILLISECONDS);        this.executorService.schedule(new InstanceDownAndUpTask(nacosServiceRegistry, nacosRegistration, OPERATOR_UP), delayUp, TimeUnit.MILLISECONDS);    }     @Override    public void shutdown() throws NacosException {        ThreadUtils.shutdownThreadPool(executorService, logger);    }     /**     * 服务实例上下线任务     */    class InstanceDownAndUpTask implements Runnable {        private NacosServiceRegistry nacosServiceRegistry;        private NacosRegistration nacosRegistration;        //更新服务实例的状态 ：UP 、DOWN        private String nacosServiceInstanceOperator;         InstanceDownAndUpTask(NacosServiceRegistry nacosServiceRegistry, NacosRegistration nacosRegistration, String nacosServiceInstanceOperator) {            this.nacosServiceRegistry = nacosServiceRegistry;            this.nacosRegistration = nacosRegistration;            this.nacosServiceInstanceOperator = nacosServiceInstanceOperator;        }         @Override        public void run() {            logger.info("===更新nacos服务实例的状态to：{}===start=", nacosServiceInstanceOperator);            this.nacosServiceRegistry.setStatus(nacosRegistration, nacosServiceInstanceOperator);            logger.info("===更新nacos服务实例的状态to：{}===end=", nacosServiceInstanceOperator);             //上线后，关闭线程池            if (NacosServiceInstanceUpAndDownOperator.OPERATOR_UP.equals(nacosServiceInstanceOperator)) {                ThreadUtils.shutdownThreadPool(NacosServiceInstanceUpAndDownOperator.this.executorService, NacosServiceInstanceUpAndDownOperator.this.logger);            }        }    }}

import com.alibaba.cloud.nacos.NacosDiscoveryProperties;import com.alibaba.cloud.nacos.NacosServiceManager;import com.alibaba.cloud.nacos.registry.NacosRegistration;import com.alibaba.cloud.nacos.registry.NacosServiceRegistry;import com.alibaba.nacos.api.naming.pojo.Instance;import com.alibaba.nacos.common.lifecycle.Closeable;import com.alibaba.nacos.common.utils.ThreadUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.boot.ApplicationArguments;import org.springframework.boot.ApplicationRunner;import org.springframework.cloud.client.serviceregistry.Registration;import org.springframework.stereotype.Component; import javax.annotation.PostConstruct;import javax.annotation.Resource;import java.util.Properties;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.ScheduledThreadPoolExecutor;import java.util.concurrent.TimeUnit; @Componentpublic class NacosUpDown implements ApplicationRunner, Closeable {    private static final Logger logger = LoggerFactory.getLogger(NacosUpDown.class);    /**     * nacos服务实例上线     */    private static final String OPERATOR_UP = "UP";    /**     * nacos服务实例下线     */    private static final String OPERATOR_DOWN = "DOWN";     @Resource    NacosServiceRegistry nacosServiceRegistry;     @Resource    NacosRegistration nacosRegistration;     @Resource    private NacosServiceManager nacosServiceManager;    @Resource    private NacosDiscoveryProperties nacosDiscoveryProperties;     private ScheduledExecutorService executorService;      @PostConstruct    public void init() {        int poolSize = 1;        this.executorService = new ScheduledThreadPoolExecutor(poolSize, r -> {            Thread thread = new Thread(r);            thread.setDaemon(true);            thread.setName("NacosUpAndDown");            return thread;        });    }      @Override    public void run(ApplicationArguments args){        //下线任务延迟        long delayDown = 15000L;        // 上线任务延迟        long delayUp = 21000L;        this.executorService.schedule(new InstanceDownAndUpTask(nacosServiceRegistry, nacosRegistration, OPERATOR_DOWN), delayDown, TimeUnit.MILLISECONDS);        this.executorService.schedule(new InstanceDownAndUpTask(nacosServiceRegistry, nacosRegistration, OPERATOR_UP), delayUp, TimeUnit.MILLISECONDS);    }     @Override    public void shutdown() {        ThreadUtils.shutdownThreadPool(executorService, logger);    }     /**     * 服务实例上下线任务     */    class InstanceDownAndUpTask implements Runnable {        private final NacosServiceRegistry nacosServiceRegistry;        private final NacosRegistration nacosRegistration;        //更新服务实例的状态 ：UP 、DOWN        private final String nacosServiceInstanceOperator;         InstanceDownAndUpTask(NacosServiceRegistry nacosServiceRegistry, NacosRegistration nacosRegistration, String nacosServiceInstanceOperator) {            this.nacosServiceRegistry = nacosServiceRegistry;            this.nacosRegistration = nacosRegistration;            this.nacosServiceInstanceOperator = nacosServiceInstanceOperator;        }         @Override        public void run() {            logger.info("===更新nacos服务实例的状态to：{}===start=", nacosServiceInstanceOperator);            setStatus(nacosRegistration, nacosServiceInstanceOperator);            logger.info("===更新nacos服务实例的状态to：{}===end=", nacosServiceInstanceOperator);             //上线后，关闭线程池            if (NacosUpDown.OPERATOR_UP.equals(nacosServiceInstanceOperator)) {                ThreadUtils.shutdownThreadPool(NacosUpDown.this.executorService, logger);            }        }    }      public void setStatus(Registration registration, String status) {        if (!status.equalsIgnoreCase(OPERATOR_UP) && !status.equalsIgnoreCase(OPERATOR_DOWN)) {        } else {            String serviceId = registration.getServiceId();            Instance instance = this.getNacosInstanceFromRegistration(registration);            if (status.equalsIgnoreCase(OPERATOR_DOWN)) {                instance.setEnabled(false);            } else {                instance.setEnabled(true);            }             try {                Properties nacosProperties = this.nacosDiscoveryProperties.getNacosProperties();                this.nacosServiceManager.getNamingMaintainService(nacosProperties).updateInstance(serviceId,nacosProperties.getProperty("group"), instance);            } catch (Exception var6) {                throw new RuntimeException("update nacos instance status fail", var6);            }        }    }    private Instance getNacosInstanceFromRegistration(Registration registration) {        Instance instance = new Instance();        instance.setIp(registration.getHost());        instance.setPort(registration.getPort());        instance.setWeight(this.nacosDiscoveryProperties.getWeight());        instance.setClusterName(this.nacosDiscoveryProperties.getClusterName());        instance.setEnabled(this.nacosDiscoveryProperties.isInstanceEnabled());        instance.setMetadata(registration.getMetadata());        instance.setEphemeral(this.nacosDiscoveryProperties.isEphemeral());        return instance;    }}

server:  address: 192.168.20.2 # 本机ip  port: 8081dubbo:  provider:    host: 192.168.20.2spring:  cloud:    nacos:      config:        server-addr: ${nacos.addr}        group: ${nacos.group}        namespace: ${nacos.ns}        file-extension: yaml      discovery:        server-addr: ${nacos.addr}        namespace: ${nacos.ns}        ip: 192.168.20.2 # 服务提供者注册指定ip注册
nacos:  addr: xxxx:8848  group: xxxxx  ns: xxxxx

server:  port: 12188dubbo:  provider:    filter: -validation  consumer:    check: false  cloud:    subscribed-services: ''  scan:    base-packages: com.dy.member.service.dubbo  protocol:    name: dubbo    port: -1 # 这里设置为-1就会导致每次服务提供者重启后，服务提供者的服务端口会变，这里在本地两个服务相互调用的时候需要注意  registry:    address: spring-cloud://localhost # nacos://xxxx:8848 这种方式是直接注册到nacos上不注册到本地的目录中，每次都去nacos上拉取最新的，就不至于会等实例变更通知后，客户端没有及时去拉取nacos上的服务实例信息缓存到本地，在从本地调用  application:    version: 1.0.0

@RestController@RequestMapping("xxx")@Slf4jpublic class xxxxController {
    @DubboReference(version = "${dubbo.application.version}",url = "dubbo://192.168.20.2:20880")    UserClient userClient; //这里是服务提供这的dubbo服务，需要设置url为本地注册到nacos的服务的url信息，该信息可以从nacos的服务那里查看，如果测试环境，不配置这个url，可以将测试环境上的其它这个服务提供者注册上去的服务下线，只保留你自己本地启动注册上去的服务，这种就可以不用加这个url了，因为nacos上只有你的你本地的服务，就可以直接调用到这个服务的，若果加了这个url，需要去nacos上查看服务提供者本地注册上去的dubbo服务的地址和端口        @PostMapping("getUserInfo")    public RestResponse getUserInfo() {        Long uid = customThreadLocal.getCustomInfo().getMemberId();        MemberVOV2 memberVOV2 = userClient.queryMemberByUid(uid);    }}