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

手写nacos基本原理实现

2023-07-28 117
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 之前一直在用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基本原理
创业之路＆下一个五年
目录
相关文章
小小工匠
|
监控 关系型数据库 MySQL
Nacos架构与原理 - 健康检查机制
Nacos架构与原理 - 健康检查机制
小小工匠
299 0
小小工匠
|
存储 运维 持续交付
Nacos架构与原理 - 寻址机制
Nacos架构与原理 - 寻址机制
小小工匠
127 0
javaedge
|
存储 运维 Dubbo
Nacos 注册中心的设计原理：让你的应用轻松实现高效注册与发现！
Nacos 注册中心的设计原理：让你的应用轻松实现高效注册与发现！
javaedge
183 0
技术自由圈/原疯狂创客圈
|
2月前
|
负载均衡 算法 Java
蚂蚁面试：Nacos、Sentinel了解吗？Springcloud 核心底层原理，你知道多少？
40岁老架构师尼恩分享了关于SpringCloud核心组件的底层原理，特别是针对蚂蚁集团面试中常见的面试题进行了详细解析。内容涵盖了Nacos注册中心的AP/CP模式、Distro和Raft分布式协议、Sentinel的高可用组件、负载均衡组件的实现原理等。尼恩强调了系统化学习的重要性，推荐了《尼恩Java面试宝典PDF》等资料，帮助读者更好地准备面试，提高技术实力，最终实现“offer自由”。更多技术资料和指导，可关注公众号【技术自由圈】获取。
技术自由圈/原疯狂创客圈
82 0
蚂蚁面试：Nacos、Sentinel了解吗？Springcloud 核心底层原理，你知道多少？
土木林森
|
4月前
|
安全 Nacos 数据安全/隐私保护
【技术干货】破解Nacos安全隐患：连接用户名与密码明文传输！掌握HTTPS、JWT与OAuth2.0加密秘籍，打造坚不可摧的微服务注册与配置中心！从原理到实践，全方位解析如何构建安全防护体系，让您从此告别数据泄露风险！
【8月更文挑战第15天】Nacos是一款广受好评的微服务注册与配置中心，但其连接用户名和密码的明文传输成为安全隐患。本文探讨加密策略提升安全性。首先介绍明文传输风险，随后对比三种加密方案：HTTPS简化数据保护；JWT令牌减少凭证传输，适配分布式环境；OAuth2.0增强安全，支持多授权模式。每种方案各有千秋，开发者需根据具体需求选择最佳实践，确保服务安全稳定运行。
土木林森
406 0
洛神灬殇
|
7月前
|
关系型数据库 MySQL Nacos
【深入浅出Nacos原理及调优】「实战开发专题」采用Docker容器进行部署和搭建Nacos服务以及“坑点”
【深入浅出Nacos原理及调优】「实战开发专题」采用Docker容器进行部署和搭建Nacos服务以及“坑点”
洛神灬殇
316 1
小小工匠
|
自然语言处理 负载均衡 算法
Nacos架构与原理 - 通信通道
Nacos架构与原理 - 通信通道
小小工匠
128 1
小小工匠
|
存储 开发框架 Java
Nacos架构与原理 - Nacos-Sync
Nacos架构与原理 - Nacos-Sync
小小工匠
214 0
小小工匠
|
Kubernetes Cloud Native Nacos
Nacos架构与原理 -服务网格生态
Nacos架构与原理 -服务网格生态
小小工匠
184 0
小小工匠
|
存储 运维 网络协议
Nacos架构与原理 - 注册中心服务数据模型(2.x版本)
Nacos架构与原理 - 注册中心服务数据模型(2.x版本)
小小工匠
150 0

热门文章

最新文章

  • 1
    使用KMS为MSE-Nacos敏感配置加密的最佳实践
  • 2
    免费下载！阿里Nacos开源必备书籍《Nacos架构&原理》
  • 3
    如何基于Nacos实现分布式配置中心？ | 带你读《Spring Cloud Alibaba（2019）》之七
  • 4
    修改nacos数据库，并制作镜像
  • 5
    nacos进阶二--使用源码启动项目
  • 6
    Nacos 服务源码包安装 & Docker 安装
  • 7
    微服务：注册中心ZooKeeper、Eureka、Consul 、Nacos对比
  • 8
    微服务架构 | 3.2 Alibaba Nacos 注册中心
  • 9
    Spring Cloud Gateway + Nacos 实现服务上下线无缝切换
  • 10
    Nacos系列-Nacos服务注册与发现
  • 1
    如何使用公网地址远程访问内网Nacos UI界面查看注册服务
    429
  • 2
    最详细的Mac下安装nacos教程来了
    1089
  • 3
    nacos 单节点Caused by: com.alibaba.nacos.api.exception.NacosException: failed to req API:/nacos/v1/ns/s
    438
  • 4
    nacos 配置页面的模糊查询
    154
  • 5
    Nacos 1.4.1核心功能组件及使用入门
    231
  • 6
    Serverless 应用引擎产品使用之Nacos 在集中发版时遇到老年代暂满，并且频繁进行 Full GC，但是 GC 后内存没有降下来如何解决
    163
  • 7
    Spring Cloud Nacos：概念与实战应用
    94
  • 8
    Serverless 应用引擎操作报错合集之Nacos中nacos启动正常，访问白页，启动日志显示正常如何解决
    224
  • 9
    【微服务】生产部署nacos集群（三个节点）
    209
  • 10
    docker部署nacos集群
    112

    • 相关课程

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

    • 相关电子书

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

    • 相关实验场景

    更多
  • 基于MSE-Nacos实现服务的动态发现和配置动态管理
  • 快速上手使用Dubbo进行远程调用
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • Rocketmq-spring入门与实践
    • 下一篇
    fs.oss.accessKeyId和fs.oss.accessKeySecret。