[Java知识库] Springcloud项目接入nacos

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Springcloud项目接入nacos -> 正文阅读

[Java知识库]Springcloud项目接入nacos

一、控制中心

下载
https://github.com/alibaba/nacos/releases/download/2.0.4/nacos-server-2.0.4.zip
2. 配置
conf/application.properties

### 默认路径，别动:
server.servlet.contextPath=/nacos
### 端口，看你高兴:
server.port=8848


### Count of DB:
db.num=1

### 数据库
db.url.0=jdbc:mysql://202.173.9.28:3306/nacos2?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=abcd1234
db.pool.config.connectionTimeout=30000
db.pool.config.validationTimeout=10000
db.pool.config.maximumPoolSize=20
db.pool.config.minimumIdle=2


###开启登录认证，默认密码nacos/nacos,登录进去自己改
nacos.core.auth.enabled=true

conf/cluster.conf

#集群配置 你想搞几个搞几个
202.173.14.69:8848
202.173.14.94:8848
202.173.9.40:8848

启动

bin/startup.sh

访问: http://202.173.9.40:8848/nacos/

在这里插入图片描述

二、服务端

  <properties>
          <spring-cloud.version>2020.0.0</spring-cloud.version>
          <spring-cloud-alibaba.version>2.2.5.RELEASE</spring-cloud-alibaba.version>
   </properties>
  
  <dependencies>
      <dependency>
              <groupId>com.alibaba.cloud</groupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
              <exclusions>
                  <exclusion>
                      <artifactId>spring-cloud-starter-netflix-archaius</artifactId>
                      <groupId>org.springframework.cloud</groupId>
                  </exclusion>
              </exclusions>
          </dependency>
          <dependency>
              <groupId>com.alibaba.cloud</groupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
       </dependency>
  </dependencies>
  
  <dependencyManagement>
          <dependencies>
              <dependency>
                  <groupId>org.springframework.cloud</groupId>
                  <artifactId>spring-cloud-dependencies</artifactId>
                  <version>${spring-cloud.version}</version>
                  <type>pom</type>
                  <scope>import</scope>
              </dependency>
              <dependency>
                  <groupId>com.alibaba.cloud</groupId>
                  <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                  <version>${spring-cloud-alibaba.version}</version>
                  <type>pom</type>
                  <scope>import</scope>
              </dependency>
          </dependencies>
   </dependencyManagement>配置

  server:
    port: 15060
    application:
  #服务名
      name: knet-cloud-domain   
    cloud:
      nacos:
        username: nacos
        password: abcd1234
        discovery:
          server-addr: 202.173.14.69:8848,202.173.9.40:8848,202.173.14.94:8848

配置

jar启动方式直接增加注解

 @SpringBootApplication
 @EnableDiscoveryClient
 public class KnetBusinessTaskApplication{}

tomcat需要配置类，否则找不到端口

  package cn.knet.wz.conf;
 import com.alibaba.cloud.nacos.registry.NacosAutoServiceRegistration;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.stereotype.Component;

 import javax.management.MBeanServer;
 import javax.management.ObjectName;
 import javax.management.Query;
 import java.lang.management.ManagementFactory;
 import java.util.Set;

@Component
 @Slf4j
 public class NacosConfig implements ApplicationRunner {  
    @Autowired(required = false)
   private NacosAutoServiceRegistration registration;

   @Value("${server.port}")
   Integer port;

   @Override
   public void run(ApplicationArguments args) {
       if (registration != null && port != null) {
           Integer tomcatPort = port;
           try {
               tomcatPort = new Integer(getTomcatPort());
           } catch (Exception e) {
               //e.printStackTrace();
               log.info("运行在非WAR环境");
           }

           registration.setPort(tomcatPort);
           registration.start();
       }
   }

   public String getTomcatPort() throws Exception {
       MBeanServer beanServer = ManagementFactory.getPlatformMBeanServer();
       Set<ObjectName> objectNames = beanServer.queryNames(new ObjectName("*:type=Connector,*"), Query.match(Query.attr("protocol"), Query.value("HTTP/1.1")));
       String port = objectNames.iterator().next().getKeyProperty("port");
       return port;
   }
 }

启动

服务器启动后，控制台打印

2022-03-31 15:15:57.135 INFO 8464 --- [ main] c.a.c.n.registry.NacosServiceRegistry : nacos registry, DEFAULT_GROUP knet-domain-boss 192.168.90.21:10710 register finished

服务注册成功。

在nacos的服务管理-服务列表中显示该服务

三、客户端

重复服务端1-3的步骤
配置

启动类

@SpringBootApplication
@EnableDiscoveryClient
public class KnetDomainBossApplication {

    public static void main(String[] args) {
        SpringApplication.run(KnetDomainBossApplication.class, args);
    }
}

  RestTemplateConfig配置

package cn.knet.boss;

import cn.knet.domain.filter.LoggingClientHttpRequestInterceptor;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpRequest;
import org.apache.http.client.methods.HttpRequestWrapper;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.BufferingClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

@Slf4j
@Configuration
public class RestTemplateConfig {

    private static final int HTTP_CLIENT_RETRY_COUNT = 0;

    private static final int MAXIMUM_TOTAL_CONNECTION = 10;

    private static final int MAXIMUM_CONNECTION_PER_ROUTE = 5;

    private static final int CONNECTION_VALIDATE_AFTER_INACTIVITY_MS = 10 * 1000;

    /**
     * @param connectionTimeoutMs milliseconds/毫秒
     * @param readTimeoutMs       milliseconds/毫秒
     * @return
     */
    public static RestTemplate createRestTemplate(int connectionTimeoutMs, int readTimeoutMs, ObjectMapper objectMapper) {

        HttpClientBuilder clientBuilder = HttpClients.custom();

        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();

        // 整个连接池最大连接数
        connectionManager.setMaxTotal(MAXIMUM_TOTAL_CONNECTION);
        // 设置每个路由的最大并发连接数,默认为2.
        connectionManager.setDefaultMaxPerRoute(MAXIMUM_CONNECTION_PER_ROUTE);
        // 官方推荐使用检查永久链接的可用性,而不推荐每次请求的时候才去检查 (milliseconds 毫秒)
        connectionManager.setValidateAfterInactivity(CONNECTION_VALIDATE_AFTER_INACTIVITY_MS);

        clientBuilder.setConnectionManager(connectionManager);
        //设置重连操作次数，这里设置了3次
        clientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(HTTP_CLIENT_RETRY_COUNT, true, new ArrayList<>()) {
            @Override
            public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
                HttpRequestWrapper httpRequestWrapper = (HttpRequestWrapper) context.getAttribute("http.request");
                HttpRequest original = httpRequestWrapper.getOriginal();
                log.info("Retry request, execution count:{}, exception:{}, request URL:{}", executionCount, exception.getMessage(), original);
                return super.retryRequest(exception, executionCount, context);
            }
        });
//
//        //使用httpClient创建一个ClientHttpRequestFactory的实现
        HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory(clientBuilder.build());
        httpRequestFactory.setConnectTimeout(connectionTimeoutMs);
        httpRequestFactory.setConnectionRequestTimeout(readTimeoutMs);
        httpRequestFactory.setReadTimeout(readTimeoutMs);

        RestTemplate restTemplate = new RestTemplate(httpRequestFactory);
        // 添加自定义拦截器
        List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>();
        interceptors.add(new LoggingClientHttpRequestInterceptor());
        restTemplate.setInterceptors(interceptors);
        //提供对传出/传入流的缓冲,可以让响应body多次读取(如果不配置,拦截器读取了Response流,再响应数据时会返回body=null)
        restTemplate.setRequestFactory(new BufferingClientHttpRequestFactory(httpRequestFactory));



        //防止响应中文乱码
        restTemplate.getMessageConverters().stream().filter(StringHttpMessageConverter.class::isInstance).map(StringHttpMessageConverter.class::cast).forEach(a -> {
            a.setWriteAcceptCharset(false);
            a.setDefaultCharset(StandardCharsets.UTF_8);
        });

        return restTemplate;
    }

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = RestTemplateConfig.createRestTemplate(120000, 120000, new ObjectMapper());
        //配置自定义的interceptor拦截器
        //使用restTemplate远程调用防止400和401导致报错而获取不到正确反馈信息
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {
            @Override
            public void handleError(ClientHttpResponse response) throws IOException {
                if (response.getRawStatusCode() != 400 && response.getRawStatusCode() != 401) {
                    super.handleError(response);
                }
            }
        });
        return restTemplate;
    }
}

主要是对RestTemplate进行配置和增加日志监控，也可以简化为在启动类中增加：

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

日志监控拦截器：

package cn.knet.domain.filter;

import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;

@Slf4j
public class LoggingClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {
    int i = 0;

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {


        long l = System.currentTimeMillis();
        ClientHttpResponse response = execution.execute(request, body);
        long time = System.currentTimeMillis() - l;

        try {
            String className = Thread.currentThread().getStackTrace()[9].getClassName();//调用的类名
            String methodName = Thread.currentThread().getStackTrace()[9].getMethodName();//调用的方法名
            int lineNumber = Thread.currentThread().getStackTrace()[9].getLineNumber();
            String bodystr = new String(body, StandardCharsets.UTF_8);
            StringBuilder inputStringBuilder = new StringBuilder();
            try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody(), StandardCharsets.UTF_8))) {
                String line = bufferedReader.readLine();
                while (line != null) {
                    inputStringBuilder.append(line);
                    inputStringBuilder.append('\n');
                    line = bufferedReader.readLine();
                }
            }

            String logstr = "\n\n===========================请求开始：================================================" +
                    "\n= Service      : {}" +
                    "\n= URI          : {}" +
                    "\n= Request body : {}" +
                    "\n= Method       : {}" +
                    "\n= Status code  : {}" +
                    "\n= Times        : {}" +
                    "\n= Response body: {}" +
                    "===========================请求结束：================================================\n\n";
            log.info(logstr, className + "." + methodName + ":" + lineNumber, request.getURI(), getJsonStrByQueryUrl(bodystr),
                    request.getMethod(), response.getStatusCode(), time, inputStringBuilder.toString());
        } catch (Exception e) {
            log.info("请求参数处理异常：" + e.getMessage() + ",URI:" + request.getURI());

        }
        return response;
    }


    public String getJsonStrByQueryUrl(String paramStr) {
        String[] params = paramStr.split("&");
        JSONObject obj = new JSONObject();
        for (int i = 0; i < params.length; i++) {
            String[] param = params[i].split("=");
            if (param.length >= 2) {
                String key = param[0];
                String value = param[1];
                for (int j = 2; j < param.length; j++) {
                    value += "=" + param[j];
                }
                try {
                    obj.put(key, URLDecoder.decode(value,"UTF-8"));
                } catch (JSONException | UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }
        }
        return obj.toString();
    }
}

访问服务端

   @Autowired
   private RestTemplate restTemplate;
 

   MultiValueMap<String, Object> parm = new LinkedMultiValueMap<>();
     parm.add("from","sender05@knetreg.cn");
     parm.add("to", mail);
     parm.add("subject", ".网址-商标通知");
   parm.add("ftl", "tmch.ftl");
     parm.add("jsonMap", map);
     Map<String, Object> result = restTemplate.postForObject("http://knet-cloud-mail/mail/send/ftlMap", parm, Map.class);

请求地址为：http://服务名/接口地址

临时实例与持久化实例

# false为永久实例，true表示临时实例
spring.cloud.nacos.discovery.ephemeral=false

临时实例向Nacos注册，Nacos不会对其进行持久化存储，只能通过心跳方式保活。默认模式是：客户端心跳上报Nacos实例健康状态，默认间隔5秒，Nacos在15秒内未收到该实例的心跳，则会设置为不健康状态，超过30秒则将实例删除。
持久化实例向Nacos注册，Nacos会对其进行持久化处理。当该实例不存在时，Nacos只会将其健康状态设置为不健康，但并不会对将其从服务端删除。
另外，可以使用实例的ephemeral来判断健康检查模式，ephemeral为true对应的是client模式（客户端心跳），为false对应的是server模式（服务端检查）。

临时实例的问题

一旦服务端出现超过30秒的异常会被删除，就算服务端恢复正常也不能使用，需重启服务端才能恢复，建议正式环境使用持久化实例，开发者使用临时实例。