Configuration Center Principle of Nacos How does Nacos or Config implement configuration hot refresh? And make a wheel out of it?

Key PRINCIPLES of Nacos:

• 1. Use Spring Cloud native annotations on beans that need a hot refresh@RefreshScope
• 2. Called when the configuration is updatedcontextRefresher.refresh()

The code is as follows:

@RestController
@RequestMapping("/config")
@RefreshScope / / the key
public class ConfigController {
    @Value("${laker.name}") // Attributes to be refreshed
    private String lakerName;
    @RequestMapping("/get")
    public String get(a) {
        returnlakerName; }... }Copy the code

Trigger contextrefresher.refresh when there is a configuration update

RefreshScope Refresh process

The entrance ContextRefresher. Refresh

public synchronized Set<String> refresh(a) {① Map<String, Object> extractthis.context.getEnvironment().getPropertySources()); (2) updateEnvironment (); Set<String> keys = changes(before, ③extract(this.context.getEnvironment().getPropertySources())).keySet(); 5.this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys)); 6.this.scope.refreshAll();
}
Copy the code

① Extract all parameter variables other than standard parameters (SYSTEM,JNDI,SERVLET)

(2) Re-load the Environment parameters into a new Spring Context container, and then close the new container (important: you can debug it and restart the SpringApplication).

(3) Mention the updated parameters (excluding standard parameters)

④ Compare the change items

Release environment change events

(6) The RefreshScope regenerates the Bean with the new environment parameters. The process of regenerating is simple. Clear the RefreshScope cache and destroy the Bean, and the next time a new instance is fetched from the BeanFactory.

Here we can simulate building a thermal regenerative wheel;

The code and configuration are as follows:

• The project relies on spring-Cloud-Context

  <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-context</artifactId>
  </dependency>
  Copy the code

• Configuration bean

  @Component
  @RefreshScope
  public class User {
      @Value("${laker.name}")
      privateString name; . }Copy the code

• Refresh interfaces and view interfaces

  @RestController
  @RequestMapping("/config")
  public class ConfigController {
      @Autowired
      User user;
      @Autowired
      ContextRefresher contextRefresher;
      @RequestMapping("/get")
      public String get(a) {
          return user.getName();
      }
      @RequestMapping("/refresh")
      public String[] refresh() {
          Set<String> keys = contextRefresher.refresh();
          return keys.toArray(new String[keys.size()]);
      }
  Copy the code

• application.yml

  laker:
    name: laker
  Copy the code

The operation process is as follows:

1. Browser browser http://localhost:8080/config/get – result: laker

2. Change the contents of application.yml to:

   laker:
     name: lakerupdate
   Copy the code

3. Browser http://localhost:8080/config/refresh – browser results: laker. Name

4. Browser browser http://localhost:8080/config/get – result: lakerupdate (not restart, realized the configuration updates)

The implementation is as follows:

1. The client sends an Http request to the Config Servicenotifications/v2The interface, that isNotificationControllerV2, seeRemoteConfigLongPollService
2. NotificationControllerV2 does not return the result immediately, but suspends the request via Spring DeferredResult
3. If no configuration of interest to the client is published within 60 seconds, Http status code 304 is returned to the client
4. NotificationControllerV2 calls the setResult method of DeferredResult if a configuration is published that the client is interested in, passing in namespace information with the configuration change, and the request is returned immediately. The client requests the Config Service to obtain the latest configuration of the namespace after obtaining the newly configured namespace.

Interpretation:

• The keyword DeferredResult uses this feature to implement long polling

• When a timeout is returned, the status Code returned is Http Code 304

  The requested page has not been modified since the last request. When the server returns this response, it does not return the web page content, thus saving bandwidth and overhead.

Here we will use Spring Boot to simulate how to implement long polling service push through Spring Boot DeferredResult.

The code is as follows for your reference only:

/** * Echo Config Service notification client long polling implementation principle */
@RestController
@RequestMapping("/config")
public class LakerConfigController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    // A key can hold multiple values
    private Multimap<String, DeferredResult<String>> watchRequests = Multimaps.synchronizedSetMultimap(HashMultimap.create());
    /** * simulate long polling */
    @RequestMapping(value = "/get/{dataId}")
    public DeferredResult<String> watch(@PathVariable("dataId") String dataId) {
        logger.info("Request received");
        ResponseEntity<String>
                NOT_MODIFIED_RESPONSE = new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
        The 304 status code is returned to tell the client that the configuration file of the current namespace is not updated
        DeferredResult<String> deferredResult = new DeferredResult<>(30 * 1000L, NOT_MODIFIED_RESPONSE);
        // When deferredResult completes (whether timed out, abnormal, or normal), remove the corresponding Watch key from watchRequests
        deferredResult.onCompletion(() -> {
            logger.info("remove key:" + dataId);
            watchRequests.remove(dataId, deferredResult);
        });
        deferredResult.onTimeout(() -> {
            logger.info("onTimeout()");
        });
        watchRequests.put(dataId, deferredResult);
        logger.info("Servlet thread released");
        return deferredResult;
    }
    /** * simulate publish configuration */
    @RequestMapping(value = "/update/{dataId}")
    public Object publishConfig(@PathVariable("dataId") String dataId) {
        if (watchRequests.containsKey(dataId)) {
            Collection<DeferredResult<String>> deferredResults = watchRequests.get(dataId);
            Long time = System.currentTimeMillis();
            // Inform all watch of the configuration change result of namespace change
            for (DeferredResult<String> deferredResult : deferredResults) {
                //deferredResult Once the setResult() method is executed, deferredResult is finished and the result is immediately returned to the client
                deferredResult.setResult(dataId + " changed:"+ time); }}return "success"; }}Copy the code

The operation process is as follows:

For the sake of simplicity I use the browser simulation, the actual use of Java Http Client, such as: OKHTTP, Apache Http Client, etc

Normal process:

• client1The browserhttp://localhost:8080/config/get/laker, blocking in ing
• client2The browserhttp://localhost:8080/config/update/lakerTo return tosuccess
• client1The browserhttp://localhost:8080/config/get/lakerTo return tolaker changed:1611022736865

Timeout process:

• client1The browserhttp://localhost:8080/config/get/laker, blocking in ing
• After the 30 s
• client1Browser, backhttp code 304

Contents of this series

• An overview of the Spring Cloud microservices series of articles, which will be updated in real time

🍎QQ group [837324215] 🍎 pay attention to my public number [Java Factory interview officer], learn together 🍎🍎🍎