服务中心相互注册RestTemplate自动录找nacos 服务实例

最新推荐文章于 2024-07-14 18:41:59 发布
最新推荐文章于 2024-07-14 18:41:59 发布
阅读量146 收藏
点赞数 1
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/codeSmart/article/details/139345750
版权

RestTemplateConfig 配置信息

@Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplateBuilder().build();
        restTemplate.setRequestFactory(clientHttpRequestFactory());
        return restTemplate;
    }
  
    @Bean
    public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() {
        try {
            HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
            SSLContext sslContext = new SSLContextBuilder()
                    .loadTrustMaterial(null, (TrustStrategy) (arg0, arg1) -> true).build();
            httpClientBuilder.setSSLContext(sslContext);
            HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE;
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext,
                    hostnameVerifier);
            // 注册http和https请求
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", sslConnectionSocketFactory).build();
            // 开始设置连接池
            PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(
                    socketFactoryRegistry);
            // 最大连接数500
            poolingHttpClientConnectionManager.setMaxTotal(500);
            // 同路由并发数100
            poolingHttpClientConnectionManager.setDefaultMaxPerRoute(100);
            // 重试次数
            httpClientBuilder.setConnectionManager(poolingHttpClientConnectionManager);
            httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(3, true));
            // httpClient连接配置
            CloseableHttpClient httpClient = httpClientBuilder.build();
            HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(
                    httpClient);
            // 连接超时
            clientHttpRequestFactory.setConnectTimeout(20000);
            // 数据读取超时时间
            clientHttpRequestFactory.setReadTimeout(30000);
            // 连接不够用的等待时间
            clientHttpRequestFactory.setConnectionRequestTimeout(20000);
            
            return clientHttpRequestFactory;
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException e) {
            log.error("初始化HTTP连接池出错", e);
        }
        return null;
    }

服务中心相互注册

  private static final String APPLICATION = "xxx";
    @Autowired
    private NacosDiscoveryProperties nacosDiscoveryProperties;

    @Autowired
    private NacosRegistration registration;

    @Value("${register.server.urls:-}")
    private String serverUrls;

    @Value("${register.server.name:-}")
    private String serverName;
    
    @EventListener
    public void event(InstanceRegisteredEvent event) throws Exception {
        if(serverUrls.equals("-")){
            //不需要注册第二个注册中心
            return;
        }
        try {
            for (String serverUrl : serverUrls.split(",")) {
                nacosDiscoveryProperties.setServerAddr(serverUrl);
                String group = nacosDiscoveryProperties.getGroup();
                Instance instance = getNacosInstanceFromRegistration(registration);
                NamingService namingService = NamingFactory.createNamingService(nacosDiscoveryProperties.getNacosProperties());
                namingService.registerInstance(serverName, group, instance);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        
    }

    //@EventListener
    public void event(ApplicationReadyEvent event) throws Exception {
        if("-".equals(serverUrls)){
            //不获取总中心的dcim服务列表
            return;
        }
        nacosDiscoveryProperties.setServerAddr(serverName);
        String group = nacosDiscoveryProperties.getGroup();
        NamingService namingService = NamingFactory.createNamingService(nacosDiscoveryProperties.getNacosProperties());
        List<Instance> dcimInstances = namingService.getAllInstances(APPLICATION, group);
        LoadBalancerUtil.updateInstances(dcimInstances);
        namingService.subscribe(APPLICATION, updateEvent -> {
            if (updateEvent instanceof NamingEvent) {
                LoadBalancerUtil.updateInstances(((NamingEvent) updateEvent).getInstances());
            }
        });
    }


    private Instance getNacosInstanceFromRegistration(Registration registration) {
        Instance instance = new Instance();
        instance.setIp(registration.getHost());
        instance.setPort(registration.getPort());
        instance.setWeight(nacosDiscoveryProperties.getWeight());
        instance.setClusterName(nacosDiscoveryProperties.getClusterName());
        instance.setEnabled(nacosDiscoveryProperties.isInstanceEnabled());
        instance.setMetadata(registration.getMetadata());
        instance.setEphemeral(nacosDiscoveryProperties.isEphemeral());
        return instance;
    }

RestTemplate工具类

 public static String put(RestTemplate restTemplate, Object entity, String url){
        return put(restTemplate,entity,url,String.class);
    }

    public static  <T>T put(RestTemplate restTemplate,Object entity,String url, Class<T> cls){
        logParams(RequestMethod.PUT,url,entity);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        HttpEntity<Object> request = new HttpEntity<>(entity,headers);
        ResponseEntity<T> exchange = restTemplate.exchange(url, HttpMethod.PUT, request, cls);
        T result = exchange.getBody();
        log.info("put result:{}",result);
        return result;
    }

    public static String post(RestTemplate restTemplate,Object entity,String url){
        return post(restTemplate,url,entity,String.class);
    }

    /**
     * 得到 参数的字符串
     * @param entity
     * @return
     */
    private static String getStringParams(Object entity){
        if(entity instanceof String){
            return entity.toString();
        }
        return JSONUtil.toJsonStr(entity);
    }

    private static void logParams(RequestMethod method, String url, Object entity){
        String params=getStringParams(entity);
        log.info("{} url:{}  params:{}",method,url,params);
    }

    /**
     * json请求,可以指定header
     */
    public static <T>T post(RestTemplate restTemplate, String url, Object entity, Map<String,String> headerMap, Class<T> cls){
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        if(!CollectionUtils.isEmpty(headerMap)){
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                headers.set(entry.getKey(),entry.getValue());
            }
        }

        HttpEntity<Object> request = new HttpEntity<>(entity,headers);
        return executePost(restTemplate,url,request,cls);

    }
    /**
     * json请求
     */
    public static <T>T post(RestTemplate restTemplate,String url, Object entity, Class<T> cls){
        return post(restTemplate,url,entity,null,cls);
    }

    /**
     * 表单请求
     */
    public static <T>T formPost(RestTemplate restTemplate,String url, Map<String, String> params, Map<String,String> headerMap, Class<T> cls){
        HttpHeaders headers = new HttpHeaders();
        if(!CollectionUtils.isEmpty(headerMap)){
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                headers.set(entry.getKey(),entry.getValue());
            }
        }
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        HttpEntity<Object> request = new HttpEntity<>(params,headers);
        return executePost(restTemplate,url,request,cls);
    }

    /**
     * post 请求
     */
    private static <T>T executePost(RestTemplate restTemplate,String url, HttpEntity<Object> request, Class<T> cls){
        logParams(RequestMethod.POST,url,request);
        ResponseEntity<T> exchange = restTemplate.exchange(url, HttpMethod.POST, request, cls);
        T body = exchange.getBody();
        log.info("post result:{}", body);
        return body;
    }

    public static <T>T upload(RestTemplate restTemplate, String url, Map<String, String> updateMap, Map<String,String> headerMap , Class<T> returnClass, Resource resource) {
        MultiValueMap<String, Object> parts = new LinkedMultiValueMap<>();
        HttpHeaders headers = new HttpHeaders();

        if(!CollectionUtils.isEmpty(headerMap)){
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                headers.set(entry.getKey(),entry.getValue());
            }
        }


        parts.add("file",resource);
        for (Map.Entry<String, String> entry : updateMap.entrySet()) {
            Object value = entry.getValue();
            String key = entry.getKey();
            log.info("--->upload param key:{},val:{}",key,value);
            parts.add(key,value);
        }

        HttpEntity<Object> httpEntity = new HttpEntity<>(parts, headers);

        ResponseEntity<T> exchange = restTemplate.exchange(url, HttpMethod.POST, httpEntity, returnClass);

        T body = exchange.getBody();
        return body;
    }

    private static <T>T executeGet(RestTemplate restTemplate,String url, HttpEntity<Object> request, Class<T> cls){
        logParams(RequestMethod.GET,url,request);
        ResponseEntity<T> exchange = restTemplate.exchange(url, HttpMethod.GET, request, cls);
        T body = exchange.getBody();
        log.info("get result:{}", body);
        return body;
    }

    public static  String get(RestTemplate restTemplate,String url){
        return get(restTemplate,url,null,String.class);
    }
    public static  <T>T get(RestTemplate restTemplate,String url, Map<String,String> params,Map<String,String> headerMap, Class<T> cls){
        String reqUrl = buildUrl(url,params);
        HttpHeaders headers = new HttpHeaders();
        if(headerMap != null){
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                headers.set(entry.getKey(),entry.getValue());
            }
        }
        HttpEntity<Object> request = new HttpEntity<>(headers);
        return executeGet(restTemplate,reqUrl,request,cls);
    }
    /**
     * get 请求
     */
    public static  <T>T get(RestTemplate restTemplate,String url, Map<String,String> params, Class<T> cls){
        String reqUrl = buildUrl(url,params);
        log.info("get url:{}",reqUrl);
        T result = restTemplate.getForObject(reqUrl, cls);
        log.info("get result:{}", getStringParams(result));
        return result;
    }

    /**
     * 设置的url
     */
    private static String buildUrl(String url, Map<String,String> params){
        StringBuilder urlBuiler=new StringBuilder(url);
        if(!url.contains("?")){
            urlBuiler.append("?");
        }
        if(!CollectionUtils.isEmpty(params)){
            for (Map.Entry<String, String> entry : params.entrySet()) {
                urlBuiler.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
            }
        }
        return urlBuiler.toString();
    }
狂野弘仁
关注
Nacos注册中心实现-服务注册
菜鸟传说的博客
12-01 662
Nacos注册中心实现-服务注册 父级导入SpringCloudAlibaba版本控制依赖<dependencyManagement> <dependencies> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-alibaba-dependencies</
nacos注册中心实现-服务发现使用RestTemplate
菜鸟传说的博客
12-01 3185
Nacos注册中心实现-服务发现-RestTemplate 服务发现可以用RestTemplate实现，也可以使用OpenFeign实现 consumer_service导入依赖<!--alibaba的 Nacos依赖--> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discove
【仅是入门用】spring cloud 集成Nacos，采用RestTemplate（HttpClient）实现服务的直接调用
小哇
01-28 2446
首先搭建好Nacos服务端，可参考如下博文https://blog.csdn.net/qq_41712271/article/details/113270225 此功能模块是在以下项目的基础上实现，可参考博文https://blog.csdn.net/qq_41712271/article/details/113249044 Nacos客户端配置 (其他所有的子项目) ，这里只设置了订单服务，视频服务依此步骤进行 这里试验 订单服务 调用 视频服务 1 订单服务 添加maven依赖 <!--添加.
RestTemplate Nacos OpenFeign
最新发布
2302_80490510的博客
07-14 1190
Spring给我们提供了一个RestTemplate的API，可以方便的实现Http请求的发送。同步客户端执行HTTP请求，在底层HTTP客户端库(如JDK HttpURLConnection、Apache HttpComponents等)上公开一个简单的模板方法API。RestTemplate通过HTTP方法为常见场景提供了模板，此外还提供了支持不太常见情况的通用交换和执行方法。RestTemplate通常用作共享组件。然而，它的配置不支持并发修改，因此它的配置通常是在启动时准备的。
SpringCloud入门（微服务调用 RestTemplate）——微服务调用的方式 & RestTemplate的使用 & 使用nacos的服务名初步（Ribbon负载均衡）
Arya的博客，专注后端领域
08-28 4141
1.微服务调用的几种方式，异步消息传递，http调用，服务网关调用，服务发现调用nacos； 2.spring提供的restTemplate，发送HTTP请求的客户端工具类； 3.nacos使用服务名报错，需要加Ribbon负载均衡；
Nacos由浅入深（一）
astra_zhao的专栏
10-18 824
Nacos 的关键特性包括: 服务发现和服务健康监测 Nacos 支持基于 DNS 和基于 RPC 的服务发现。服务提供者使用原生SDK、OpenAPI、或一个独立的Agent TODO注册 Service 后，服务消费者可以使用DNS TODO或HTTP&API查找和发现服务。 Nacos 提供对服务的实时的健康检查，阻止向不健康的主机或服务实例发送请求。Nacos 支...
nacos-RestTemplate
qq_40067747的博客
07-31 273
Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts、Mybatis、Hessian、Quartz）等的直接支持。可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。「最主要的还是减少了大量的XML配置，总的来说就是一句话，用SpringBoot框架开发项目，可以轻松地创建独立的，基于生产级别的基于Spring的应用程序」6.绝对没有代码生成，不需要 XML 配置。
SpringCloud Alibaba Nacos：注册中心提供者和消费者之间的调用之RestTemplate + Ribbon
weixin_41899827的博客
07-24 1000
前面我们已经将客户端作为提供者和消费者注册到注册中心，下面我们进行调用。 我们采用RestTemplate方式调用。 1.首先我们在提供者端建立一个Controller package com.nacos.nacostest; import com.sun.org.apache.xml.internal.utils.URI; import org.springframework.beans.factory.annotation.Value; import org.springframework.c
SpringCloudAlibaba，Nacos注册中心，服务区域配置
10-19
5. **使用配置中心**：除了服务注册与发现，Nacos还提供配置中心的功能。服务实例可以通过@RefreshScope注解实现配置的动态刷新。在Nacos控制台，可以实时修改配置，服务实例会自动感知变化并更新。 6. **多环境...
本地服务注册不上nacos_一篇文章带你学会注册Nacos 配置中心和服务
weixin_39608394的博客
12-31 1784
Nacos配置中心在项目中使用Nacos做配置中心还是比较简单的，我们先创建SpringBoot项目，然后引入nacos-config的jar包，具体如下：com.alibaba.cloudspring-cloud-starter-alibaba-nacos-config如果你不想使用SpringBoot默认的nacos-config版本，也可以指定版本号。首先，我们进入到nacos的管理后台，第...
Nacos服务注册与发现——服务发现
weixin_51966377的博客
06-17 4682
Nacos服务注册与发现——服务发现
Nacos注册中心和服务方式
qq_66924116的博客
11-27 769
通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址 （ip，端口）等硬编码到了代码中，这种做法存在许多问题：一旦服务提供者地址变化，就需要手工修改代码一旦是多个服务提供者，无法实现负载均衡功能一旦服务变得越来越多，人工维护调用关系困难为解决以上麻烦：就需要通过注册中心动态的实现服务治理。常见的注册中心。
Nacos服务注册成功,RestTemplate调用服务提供者时空指针异常（已解决）
总结分享
07-05 872
报错解决 ERROR 6596 --- [io-20087-exec-3] o.a.c.c.C.[.[.[/].[dispatcherServlet] : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.NullPointerException]
关于Nacos使用RestTemplate多模块间调用错误或失败的问题
水到渠成
03-24 852
最开始怀疑是Nacos的选主问题，于是追了半天源码，后来发现是RestTemplate初始化时没有配置负载均衡@LoadBalanced，导致nacos底层不能正常解析服务名。在使用RestTemplate进行跨服务调用时，返回UnknownHostException:未知主机。适用于SpringBoot3 + Nacos2.1.X版本。
【nacos】RestTemplate
m0_56762697的博客
01-23 2258
远程调用的一种方式 RestTemplate package com.jt.controller; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.beans.factory.annotation.Value; import org.springfra
Nacos注册中心-RestTemplate
qq_43185617的博客
12-12 1738
Nacos注册中心-RestTemplate 文章目录Nacos注册中心-RestTemplate前言1 项目结构2 模块搭建2.1 创建父工程2.2 创建基础模块2.3 创建用户微服务2.4 创建商品微服务2.5 创建订单微服务3 Nacos Discovery--服务治理3.1 搭建Nacos环境3.2 将商品微服务注册到nacos3.3 将订单微服务注册到nacos3.4 基于Ribbon实现负载均衡Ribbon支持的负载均衡策略3.5 基于Feign实现服务调用和负载 前言 本文主要介绍了创建父子
SpringCloud-Nacos-服务注册中心-服务发现HelloWorld(服务之间数据的调用RestTemplate)
baidu_38287567的博客
11-03 2524
SpringCloud-Nacos-服务注册中心-服务发现(服务之间数据的调用) 一、Nacos注册中心的安装 # 一、从Github上克隆项目 git clone https://github.com/nacos-group/nacos-docker.git # 进入该目录 cd nacos-docker # 单机模式Mysql启动(带数据库) docker-compose -f example...
SpringCloud入门（微服务调用 RestTemplate）——微服务调用的方式 &amp； RestTemplate的使用 &amp； 使用nacos的服务名初步（Ribbon负载均衡(1)
2401_84002294的博客
05-12 1026
本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取[外链图片转存中…(img-Tfx0n25K-1715469595449)][外链图片转存中…(img-dYBy42TF-1715469595450)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。
请写出使用RestTemplate通过nacos服务发现，基于注册中心完成远程调用的流程
06-01
好的，下面是使用RestTemplate通过nacos服务发现，基于注册中心完成远程调用的流程： 1. 在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency> ``` 2. 在启动类上添加@EnableDiscoveryClient注解，启用服务发现功能。 3. 创建RestTemplate实例，并使用@LoadBalanced注解，开启负载均衡功能。 ``` @Bean @LoadBalanced public RestTemplate restTemplate() { return new RestTemplate(); } ``` 4. 使用RestTemplate进行远程调用，使用服务名替代具体的IP地址和端口号。 ``` String result = restTemplate.getForObject("http://service-provider/hello", String.class); ``` 其中，"service-provider"是服务提供者在nacos注册中心注册的名称，"/hello"是服务提供者的接口地址。 5. 完成远程调用，获取结果并进行处理。 以上就是使用RestTemplate通过nacos服务发现，基于注册中心完成远程调用的流程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值