AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

手写nacos基本原理实现

2023-07-28 98
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 之前一直在用nacos，对于nacos的原理只是停留在理论的层面上；最近想要再精进一步，于是有了想要自己实现一下nacos的大致原理。

一、背景介绍


之前一直在用nacos，对于nacos的原理只是停留在理论的层面上；最近想要再精进一步，于是有了想要自己实现一下nacos的大致原理。


当然对于安全、健壮性等方面的考虑并没有涉及那么多，只是通过简易的代码实现了配置管理和注册管理的逻辑功能。


二、思路&方案


635402cbca024031a05e49404686c77d.png

7ebdec7d2eef4898958a1f52a0d9be14.png

0cdaf309289445b992d2ada38bfc936b.png

b3bfc85bbd9d42a195598c1f2d14efcd.png


三、过程


service代码


POM


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <parent>
        <artifactId>NacosTest</artifactId>
        <groupId>com.mark</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>Service</artifactId>
    <name>Service</name>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        开始-Http请求引入的包依赖，没有明确那些有用那些没有用-->
        <!-- 解决编译时，报程序包javax.servlet不存在的错误 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!-- 只在编译和测试的时候用 -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.11</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>


配置文件


server:
  port: 8080
spring:
  mvc:
    static-path-pattern: /static/** #static为存放css,js的文件夹


具体类


package com.tfjy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Service {
    public static void main(String[] args) {
        SpringApplication.run(Service.class,args);
    }
}



package com.tfjy.util;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
public class httpClient {
    public static void main(String[] args)throws Exception {
    }
    public static String doGet1(String httpurl) {
        try {
            //创建连接
            URL url = new URL(httpurl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("Accept", "application/json");
            if (conn.getResponseCode() != 200) {
                throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
            }
            //从输入流中读取数据
            InputStream inputStream = conn.getInputStream();
            Scanner scanner = new Scanner(inputStream);
            StringBuffer buffer = new StringBuffer();
            while (scanner.hasNextLine()) {
                buffer.append(scanner.nextLine());
            }
            scanner.close();
            String result = buffer.toString();
            conn.disconnect();
            return result;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }
    public static String doGet(String httpurl) {
        HttpURLConnection connection = null;
        InputStream is = null;
        BufferedReader br = null;
        String result = null;// 返回结果字符串
        try {
            // 创建远程url连接对象
            URL url = new URL(httpurl);
            // 通过远程url连接对象打开一个连接，强转成httpURLConnection类
            connection = (HttpURLConnection) url.openConnection();
            // 设置连接方式：get
            connection.setRequestMethod("GET");
            // 设置连接主机服务器的超时时间：15000毫秒
            connection.setConnectTimeout(15000);
            // 设置读取远程返回的数据时间：60000毫秒
            connection.setReadTimeout(60000);
            connection.setRequestProperty("Accept", "application/json");
            // 发送请求
            connection.connect();
            // 通过connection连接，获取输入流
            if (connection.getResponseCode() == 200) {
                is = connection.getInputStream();
                // 封装输入流is，并指定字符集
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                // 存放数据
                StringBuffer sbf = new StringBuffer();
                String temp = null;
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            connection.disconnect();// 关闭远程连接
        }
        return result;
    }
    public static String doPost(String httpUrl, String param) {
        HttpURLConnection connection = null;
        InputStream is = null;
        OutputStream os = null;
        BufferedReader br = null;
        String result = null;
        try {
            URL url = new URL(httpUrl);
            // 通过远程url连接对象打开连接
            connection = (HttpURLConnection) url.openConnection();
            // 设置连接请求方式
            connection.setRequestMethod("POST");
            // 设置连接主机服务器超时时间：15000毫秒
            connection.setConnectTimeout(15000);
            // 设置读取主机服务器返回数据超时时间：60000毫秒
            connection.setReadTimeout(60000);
            // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
            connection.setDoOutput(true);
            // 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
            connection.setDoInput(true);
            // 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            // 通过连接对象获取一个输出流
            os = connection.getOutputStream();
            // 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
            os.write(param.getBytes());
            // 通过连接对象获取一个输入流，向远程读取
            if (connection.getResponseCode() == 200) {
                is = connection.getInputStream();
                // 对输入流对象进行包装:charset根据工作项目组的要求来设置
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                StringBuffer sbf = new StringBuffer();
                String temp = null;
                // 循环遍历一行一行读取数据
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 断开与远程地址url的连接
            connection.disconnect();
        }
        return result;
    }
}



package com.tfjy.controller;
import com.tfjy.util.httpClient;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
import java.util.Map;
@Controller
public class ServiceController {
    Map<String, Map<String,Object>> mapMapConfig = new HashMap<>();
    Map<String, Map<String,Object>> mapMapRegistion = new HashMap<>();
    @PostMapping("/saveService")
    @ResponseBody
    public String saveService(@RequestBody Map<String,Object> map){
        if("config".equalsIgnoreCase(String.valueOf(map.get("serviceType")))){
            mapMapConfig.put(String.valueOf(map.get("serviceKey")),(Map)map.get("serviceValue"));
            if(mapMapRegistion.containsKey(String.valueOf(map.get("serviceKey")))) {
                Map<String,Object> objectMap = mapMapRegistion.get(String.valueOf(map.get("serviceKey")));
                String ip = String.valueOf(objectMap.get(String.valueOf(map.get("serviceKey"))));
                //请求对应的服务进行通知
                String param = "{}";
                httpClient.doPost("http://"+ip+"/getConfigMessage", param);
            }
        }else  if("Registion".equalsIgnoreCase(String.valueOf(map.get("serviceType")))){
            mapMapRegistion.put(String.valueOf(map.get("serviceKey")),(Map)map.get("serviceValue"));
            //循环请求所有服务进行通知
            for (Map.Entry entry:mapMapRegistion.entrySet()) {
                Map value = (Map)entry.getValue();
                String ip = String.valueOf(value.get(String.valueOf(entry.getKey())));
                //请求对应的服务进行通知
                String param = "{}";
                httpClient.doPost("http://"+ip+"/getRegistionMessage", param);
            }
        }
        System.out.println(map);
        return " save 成功！";
    }
    @PostMapping("/getService")
    @ResponseBody
    public Object getService(@RequestBody Map<String,Object> map){
        if("config".equalsIgnoreCase(String.valueOf(map.get("serviceType")))){
            return mapMapConfig.get(String.valueOf(map.get("serviceKey")));
        }else  if("Registion".equalsIgnoreCase(String.valueOf(map.get("serviceType")))){
            return mapMapRegistion;
        }
        return "false";
    }
}


apiSDK代码


POM


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <parent>
        <artifactId>NacosTest</artifactId>
        <groupId>com.mark</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>apiSDK</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        开始-Http请求引入的包依赖，没有明确那些有用那些没有用-->
        <!-- 解决编译时，报程序包javax.servlet不存在的错误 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!-- 只在编译和测试的时候用 -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.11</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
    </dependencies>
    <distributionManagement>
        <!--Release类型的托管资源库-->
        <repository>
            <!--id对应nexus仓库的id-->
            <id>test-hosted</id>
            <!--自定义名称-->
            <name>Releases</name>
            <!--仓库对应的URL地址-->
            <url>http://xxx:8089/repository/test-hosted/</url>
        </repository>
        <!--Snapshot类型的托管资源库-->
        <snapshotRepository>
            <!--id对应nexus仓库的id-->
            <id>test-snapshot-hosted</id>
            <!--自定义名称-->
            <name>Snapshot</name>
            <!--仓库对应的URL地址-->
            <url>http://xxx:8089/repository/test-snapshot-hosted/</url>
        </snapshotRepository>
    </distributionManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>


配置文件


server:
  port: 8081
spring:
  mvc:
    static-path-pattern: /static/** #static为存放css,js的文件夹


具体类


package com.tfjy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class apiSDK {
    public static void main(String[] args) {
        SpringApplication.run(apiSDK.class,args);
    }
}



package com.tfjy.util;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import java.net.InetAddress;
import java.net.UnknownHostException;
@Component
public class StartInit3 implements ApplicationRunner {
    @Value("${server.port}")
    String port ;
    @Value("${server.name}")
    String name ;
    @Value("${server.nacosUrl}")
    String nacosUrl ;
    @Override
    public void run(ApplicationArguments args) {
        String ipAddress = null;
        try {
            ipAddress = InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        }
        System.out.println(ipAddress.hashCode());
        String param = "{\n" +
                "    \"serviceKey\":\""+name+"\",\n" +
                "    \"serviceType\":\"Registion\",\n" +
                "    \"serviceValue\":{\n" +
                "        \""+name+"\":\""+ipAddress+":"+port+"\"\n" +
                "    }\n" +
                "}";
        String result = httpClient.doPost(nacosUrl+"/saveService", param);
        System.out.println("服务XXX启动成功，已经进行nacos注册"+result);
    }
}



package com.tfjy.controller;
import com.alibaba.fastjson.JSONObject;
import com.tfjy.util.httpClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
import java.util.Map;
@Controller
public class ServiceController {
    @Value("${server.nacosUrl}")
    String nacosUrl ;
    @Value("${server.name}")
    String name ;
    Map<String,Object> mapMapConfig = new HashMap<>();
    Map<String, Object> mapMapRegistion = new HashMap<>();
    @PostMapping("/getRegistionMessage")
    @ResponseBody
    public String getRegistionMessage(@RequestBody Map<String,Object> map){
        //请求注册发现的全部信息
        String param = "{\n" +
                "    \"serviceKey\":\""+name+"\",\n" +
                "    \"serviceType\":\"Registion\"\n" +
                "}";
        String result = httpClient.doPost(nacosUrl+"/getService", param);
        Map<String,Object> resultMap = JSONObject.parseObject(result);
        for (Map.Entry entry:resultMap.entrySet()) {
            Map<String,Object> value = (Map<String,Object>)entry.getValue();
            mapMapRegistion.putAll(value);
        }
        return " save 成功！";
    }
    @PostMapping("/getConfigMessage")
    @ResponseBody
    public Object getConfigMessage(@RequestBody Map<String,Object> map){
        //请求单独的配置信息
        String param = "{\n" +
                "    \"serviceKey\":\""+name+"\",\n" +
                "    \"serviceType\":\"config\"\n" +
                "}";
        String result = httpClient.doPost(nacosUrl+"/getService", param);
        Map resultMap = JSONObject.parseObject(result);
        mapMapConfig.putAll(resultMap);
        return "true";
    }
}


A服务代码


POM


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <parent>
        <artifactId>NacosTest</artifactId>
        <groupId>com.mark</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>A</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        开始-Http请求引入的包依赖，没有明确那些有用那些没有用-->
        <!-- 解决编译时，报程序包javax.servlet不存在的错误 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!-- 只在编译和测试的时候用 -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.11</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <dependency>
            <groupId>com.mark</groupId>
            <artifactId>apiSDK</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>


配置文件


server:
  port: 8091
  name: A
  nacosUrl: http://localhost:8080
spring:
  mvc:
    static-path-pattern: /static/** #static为存放css,js的文件夹


具体类


package com.tfjy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class A {
    public static void main(String[] args) {
        SpringApplication.run(A.class,args);
    }
}



package com.tfjy.controller;
import com.tfjy.util.httpClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.Map;
@Controller
public class AController {
    @Autowired
    ServiceController serviceController;
    @PostMapping("/sendToBMessage")
    @ResponseBody
    public String sendToBMessage(@RequestBody Map<String,Object> map){
        //请求注册发现的全部信息
        String param = "{\n" +
                "    \"serviceKey\":\"我是A\",\n" +
                "    \"serviceType\":\"Registion\"\n" +
                "}";
        String ip = String.valueOf(serviceController.mapMapRegistion.get("B"));
        String result = httpClient.doPost("http://"+ip+"/getConfigB", param);
        System.out.println("A服务调用B服务结果："+result);
        return " save 成功！";
    }
}


B服务代码


POM


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <parent>
        <artifactId>NacosTest</artifactId>
        <groupId>com.mark</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>B</artifactId>
    <name>B</name>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        开始-Http请求引入的包依赖，没有明确那些有用那些没有用-->
        <!-- 解决编译时，报程序包javax.servlet不存在的错误 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!-- 只在编译和测试的时候用 -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.11</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <dependency>
            <groupId>com.mark</groupId>
            <artifactId>apiSDK</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>


配置文件


server:
  port: 8092
  name: B
  nacosUrl: http://localhost:8080
spring:
  mvc:
    static-path-pattern: /static/** #static为存放css,js的文件夹


具体类


package com.tfjy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class B {
    public static void main(String[] args) {
        SpringApplication.run(B.class,args);
    }
}



package com.tfjy.controller;
import com.alibaba.fastjson.JSONObject;
import com.tfjy.util.httpClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
import java.util.Map;
@Controller
public class BController {
    @Autowired
    ServiceController serviceController;
    @PostMapping("/getConfigB")
    @ResponseBody
    public String getConfigB(@RequestBody Map<String,Object> map){
        System.out.println("调用B 服务 getConfigB 方法的入参为："+map);
        System.out.println("B服务的配置文件为："+serviceController.mapMapConfig);
        return " save 成功！";
    }
}


四、总结


1.有了实践层面的理解；对于理论的理解更深入了一层

2.实现过程中又进一步体会了sdk封装的精妙，让集成sdk的服务复用性得到了充足的发挥

3.通过SDK缓存机制，将集权制的好管理带来的耦合性强的弊端做了规避

4.小例子中的心跳，数据传递的安全性，代码的健壮性，CAP的考虑没有列入其中；后续再进行迭代研究


五、升华


对于底层内容的学习和理解，让我再看框架的时候，显得那么的通透。

文章标签：
开发工具
Nacos
安全
缓存
关键词：
nacos原理
nacos基本原理
创业之路＆下一个五年
目录
相关文章
小小工匠
|
10月前
|
监控 关系型数据库 MySQL
Nacos架构与原理 - 健康检查机制
Nacos架构与原理 - 健康检查机制
小小工匠
242 0
小小工匠
|
10月前
|
存储 运维 持续交付
Nacos架构与原理 - 寻址机制
Nacos架构与原理 - 寻址机制
小小工匠
87 0
javaedge
|
10月前
|
存储 运维 Dubbo
Nacos 注册中心的设计原理：让你的应用轻松实现高效注册与发现！
Nacos 注册中心的设计原理：让你的应用轻松实现高效注册与发现！
javaedge
143 0
李木子2024
|
4天前
|
安全 Nacos 数据安全/隐私保护
【技术干货】破解Nacos安全隐患：连接用户名与密码明文传输！掌握HTTPS、JWT与OAuth2.0加密秘籍，打造坚不可摧的微服务注册与配置中心！从原理到实践，全方位解析如何构建安全防护体系，让您从此告别数据泄露风险！
【8月更文挑战第15天】Nacos是一款广受好评的微服务注册与配置中心，但其连接用户名和密码的明文传输成为安全隐患。本文探讨加密策略提升安全性。首先介绍明文传输风险，随后对比三种加密方案：HTTPS简化数据保护；JWT令牌减少凭证传输，适配分布式环境；OAuth2.0增强安全，支持多授权模式。每种方案各有千秋，开发者需根据具体需求选择最佳实践，确保服务安全稳定运行。
李木子2024
16 0
洛神灬殇
|
3月前
|
关系型数据库 MySQL Nacos
【深入浅出Nacos原理及调优】「实战开发专题」采用Docker容器进行部署和搭建Nacos服务以及“坑点”
【深入浅出Nacos原理及调优】「实战开发专题」采用Docker容器进行部署和搭建Nacos服务以及“坑点”
洛神灬殇
219 1
小小工匠
|
10月前
|
自然语言处理 负载均衡 算法
Nacos架构与原理 - 通信通道
Nacos架构与原理 - 通信通道
小小工匠
105 1
小小工匠
|
10月前
|
存储 开发框架 Java
Nacos架构与原理 - Nacos-Sync
Nacos架构与原理 - Nacos-Sync
小小工匠
163 0
小小工匠
|
10月前
|
Kubernetes Cloud Native Nacos
Nacos架构与原理 -服务网格生态
Nacos架构与原理 -服务网格生态
小小工匠
129 0
小小工匠
|
10月前
|
存储 运维 网络协议
Nacos架构与原理 - 注册中心服务数据模型(2.x版本)
Nacos架构与原理 - 注册中心服务数据模型(2.x版本)
小小工匠
93 0
小小工匠
|
10月前
|
存储 负载均衡 容灾
Nacos架构与原理 - 注册中心的设计原理
Nacos架构与原理 - 注册中心的设计原理
小小工匠
149 0

热门文章

最新文章

  • 1
    阿里云服务器公网IP怎样绑定域名？
  • 2
    SpringCloud Alibaba 2021版 nacos 配置中心教程
  • 3
    Docker容器内不能联网的6种解决方案
  • 4
    阿里云容器服务Ingress设置原IP透传
  • 5
    深度学习模型训练痛点及解决方法
  • 6
    SAE急速部署
  • 7
    阿里HotFix2.0升级详解——技术运营小二畅谈热修复领域那些事
  • 8
    在SQL Server中创建用户角色及授权(使用SQL语句)
  • 9
    SpringCloud Alibaba - Nacos 作为配置中心 & 读取Yaml配置信息
  • 10
    阿里巴巴NACOS（6）- 在k8s上部署Nacos
  • 1
    最详细的Mac下安装nacos教程来了
    602
  • 2
    nacos 配置页面的模糊查询
    83
  • 3
    Serverless 应用引擎产品使用之Nacos 在集中发版时遇到老年代暂满，并且频繁进行 Full GC，但是 GC 后内存没有降下来如何解决
    116
  • 4
    Serverless 应用引擎操作报错合集之Nacos中nacos启动正常，访问白页，启动日志显示正常如何解决
    131
  • 5
    【微服务】生产部署nacos集群（三个节点）
    93
  • 6
    微服务学习 | Springboot整合Dubbo+Nacos实现RPC调用
    575
  • 7
    Sentinel如何持久化数据到Nacos？
    87
  • 8
    Nacos 配置中心(2023旧笔记)
    43
  • 9
    Nacos 注册中心(2023旧笔记)
    37
  • 10
    云效产品使用常见问题之把云效上的配置发到Nacos上面去如何解决
    54

    • 相关课程

    更多
  • Nacos 服务网格生态
  • Spring Cloud Alibaba Nacos 详解（上）
  • Spring Cloud Alibaba Nacos 详解（下）
  • 微服务实战-服务注册中心 - Nacos
  • 微服务实战-服务注册与发现 - Nacos Discovery
  • Nacos发展历程以及最佳实践

    • 相关电子书

    更多
  • Nacos架构&原理
  • workshop专场-微服务专场-开发者动手实践营-微服务-使用Nacos进行服务的动态发现和流量调度
  • Nacos 启航，发布第一个版本, 云原生时代助力用户微服务平台建设

    • 相关实验场景

    更多
  • 基于MSE-Nacos实现服务的动态发现和配置动态管理
  • 快速上手使用Dubbo进行远程调用
    • 下一篇
    通义千问API入门教程