spring cloud学习（四） 负载均衡Ribbon

最新推荐文章于 2024-06-27 17:16:38 发布
最新推荐文章于 2024-06-27 17:16:38 发布
阅读量151 收藏 1
点赞数
分类专栏： # spring cloud # spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34484062/article/details/105919545
版权

       在之前的一片文章中已经大致介绍了负载均衡Ribbon中用到的RestTemplate，下面是实现Ribbon的简单例子。首先还是需要建立四个项目。一个Eureka服务端，一个Ribbon服务端，向外提供出接口。两个业务处理项目，供Ribbon服务端调用。

Eureka服务端这里就不再展示

Ribbon服务端

项目结构如下：

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhong.demo</groupId>
        <artifactId>ribbondemo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <groupId>com.zhong.demo.loadbalanceservice</groupId>
    <artifactId>loadbalance-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>order-service1</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <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>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

 LoadbalanceServiceApplication.java的内容如下：

@SpringBootApplication
@EnableDiscoveryClient
public class LoadbalanceServiceApplication {

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

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

}

这里的@Bean可以把RestTemplate注入到每一个service里面。

LoadbalanceController.java是共外界调用的接口。实现调用内部的其他服务接口。

@RestController
@RequestMapping("/balance")
public class LoadbalanceController {

    @Autowired
    RestTemplate restTemplate;

    /**
     * get请求 传入参数, 返回string
     * @param service
     * @param param
     * @return
     */
    @RequestMapping(value = "/{service}/get1",method = RequestMethod.GET)
    public Object get1(@PathVariable(value = "service") String service, @RequestParam("param") String param){
        //解析{service-name}/hello 的路径调用不同的地址
        return restTemplate.getForEntity("http://"+ service +"/"+ service +"/get1?param="+param, String.class);
    }

    /**
     * 获取返回结果， Entity
     * @param service
     * @return
     */
    @RequestMapping(value = "/{service}/get2",method = RequestMethod.GET)
    public Object get2(@PathVariable(value = "service") String service){
        //解析{service-name}/hello 的路径调用不同的地址
        ResponseEntity<ReturnBean> responseEntity =  restTemplate.getForEntity("http://"+ service +"/"+ service +"/get2", ReturnBean.class);
        return responseEntity;
    }

    /**
     * 获取返回结果， object
     * @param service
     * @return
     */
    @RequestMapping(value = "/{service}/get3",method = RequestMethod.GET)
    public Object getParamR(@PathVariable(value = "service") String service, @RequestParam("param") String param){
        //解析{service-name}/hello 的路径调用不同的地址
        ReturnBean returnBean = restTemplate.getForObject("http://"+ service +"/"+ service +"/get3?param=" +param, ReturnBean.class);
        return returnBean;
    }

    /**
     * 获取返回结果， object
     * @param service
     * @return
     */
    @RequestMapping(value = "/{service}/get4",method = RequestMethod.GET)
    public Object get3(@PathVariable(value = "service") String service, @RequestParam("url") String url,@RequestParam("param") String param){
        //解析{service-name}/hello 的路径调用不同的地址
        ((DefaultUriTemplateHandler)restTemplate.getUriTemplateHandler()).setStrictEncoding(true);
        ReturnBean returnBean = restTemplate.getForObject("http://"+ service +"/"+ service +"/get4/{param}?param={param}", ReturnBean.class, url, param);
        return returnBean;
    }

    /**
     * 带 请求头 和 请求体 的post请求
     *
     * @param service 服务名称
     * @return
     */
    @RequestMapping(value = "/{service}/postForEntity",method = RequestMethod.POST)
    public Object helloTest(@PathVariable(value = "service") String service, @RequestBody QueryBean queryBean){
        HttpHeaders headers =  new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("name","test");
        HttpEntity entity = new HttpEntity(queryBean, headers);
        ResponseEntity<ReturnBean> responseEntity
                = restTemplate.postForEntity("http://"+ service +"/"+ service +"/postForEntity", entity , ReturnBean.class);
        return responseEntity;
    }

    /**
     * 带url参数的post请求
     *
     * @param service 服务名称
     * @return
     */
    @RequestMapping(value = "/{service}/postForEntity1",method = RequestMethod.POST)
    public Object postForEntity1(@PathVariable(value = "service") String service, @RequestBody QueryBean queryBean){
        HttpHeaders headers =  new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("name","test");
        HttpEntity entity = new HttpEntity(queryBean, headers);
        ResponseEntity<ReturnBean> responseEntity
                = restTemplate.postForEntity("http://"+ service +"/"+ service +"/postForEntity1?param={param}", entity , ReturnBean.class,"带参数");
        return responseEntity;
    }

    /**
     * 带url参数的post请求
     *
     * @param service 服务名称
     * @return
     */
    @RequestMapping(value = "/{service}/postForObject",method = RequestMethod.POST)
    public Object postForObject(@PathVariable(value = "service") String service, @RequestParam("url") String url, @RequestBody QueryBean queryBean){
        HttpHeaders headers =  new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("name","test");
        HttpEntity entity = new HttpEntity(queryBean, headers);
        ReturnBean returnBean = restTemplate.postForObject
                ("http://"+ service +"/"+ service +"/postForObject/{param}?param={param}",entity, ReturnBean.class, url, service);
        return returnBean;
    }

    /**
     * 带url参数的post请求
     *
     * @param service 服务名称
     * @return
     */
    @RequestMapping(value = "/{service}/postForObject2",method = RequestMethod.POST)
    public Object postForObject2(@PathVariable(value = "service") String service, @RequestBody QueryBean queryBean){
        HttpHeaders headers =  new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("name","test");
        HttpEntity entity = new HttpEntity(queryBean, headers);
        Map<String, String> map = new HashMap<>();
        map.put("product","111111");
        ((DefaultUriTemplateHandler)restTemplate.getUriTemplateHandler()).setParsePath(true);
        ReturnBean returnBean
                = restTemplate.postForObject("http://"+ service +"/"+ service +"/postForObject2",entity, ReturnBean.class, map);
        return returnBean;
    }

}

这样我们就建立了一个简单的Ribbon服务。

业务处理服务

再建立两个接口一模一样的业务处理服务。注册到eureka上的服务名称是一致的。都是Order-service

接口如下:

@RestController
public class WebController {
    /**
     * get请求 传入参数
     * @param param
     * @return
     */
    @RequestMapping(value = "/get1",method = RequestMethod.GET)
    public Object get1(@RequestParam("param") String param){
        //解析{service-name}/hello 的路径调用不同的地址
        return "order-service-1 收到参数param：" + param;
    }

    /**
     * 获取返回结果
     * @return
     */
    @RequestMapping(value = "/get2",method = RequestMethod.GET)
    public Object get2(){
        //解析{service-name}/hello 的路径调用不同的地址
        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：");
        returnBean.setDate(new Date());
        return returnBean;
    }

    @RequestMapping(value = "/get3",method = RequestMethod.GET)
    public Object getParamR(@RequestParam("param") String param){
        //解析{service-name}/hello 的路径调用不同的地址
        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：" + param);
        returnBean.setDate(new Date());
        return returnBean;
    }
    @RequestMapping(value = "/get4",method = RequestMethod.GET)
    public Object get4(HttpServletRequest request){
        //解析{service-name}/hello 的路径调用不同的地址
        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：" + request.getParameterMap());
        returnBean.setDate(new Date());
        return returnBean;
    }

    @RequestMapping(value = "/get4/url",method = RequestMethod.GET)
    public Object get4Url(HttpServletRequest request){
        //解析{service-name}/hello 的路径调用不同的地址
        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：" + request.getParameterMap().toString());
        returnBean.setDate(new Date());
        return returnBean;
    }

    /**
     * 带 请求头 和 请求体 的post请求
     *
     * @return
     */
    @RequestMapping(value = "/postForEntity",method = RequestMethod.POST)
    public Object helloTest(@RequestBody QueryBean queryBean, HttpServletRequest httpServletRequest){
        String value = httpServletRequest.getHeader("name");

        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：" + JSONObject.toJSONString(queryBean) + "，请求头：name=" + value);
        returnBean.setDate(new Date());
        return returnBean;
    }

    /**
     * 带url参数的post请求
     *
     * @return
     */
    @RequestMapping(value = "/postForEntity1",method = RequestMethod.POST)
    public Object postForEntity1(@RequestBody QueryBean queryBean, @RequestParam("param") String param){
        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：" + JSONObject.toJSONString(queryBean) + "，请求参数：name=" + param);
        returnBean.setDate(new Date());
        return returnBean;
    }

    /**
     * 带url参数的post请求
     *
     * @return
     */
    @RequestMapping(value = "/postForObject/url",method = RequestMethod.POST)
    public Object postForObject(@RequestBody QueryBean queryBean, @RequestParam("param") String param){
        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：" + JSONObject.toJSONString(queryBean) + "，url参数：param=" + param);
        returnBean.setDate(new Date());
        return returnBean;
    }

    /**
     * 带url参数的post请求
     *
     * @return
     */
    @RequestMapping(value = "/postForObject2",method = RequestMethod.POST)
    public Object postForObject2(@RequestBody QueryBean queryBean, @RequestParam("param") String param){
        ReturnBean returnBean = new ReturnBean();
        returnBean.setName("order-service-1");
        returnBean.setLocation("收到参数param：" + JSONObject.toJSONString(queryBean) + "，url参数：param=" + param);
        returnBean.setDate(new Date());
        return returnBean;
    }

}

然后启动四个服务：在eureka页面可以看到，三个服务都已近注册到eureka上了。

现在使用postman调用ribbon的接口。

第一次调用：

的如此调用：

可以看到，我们前后两次请求处理的服务不是同一个。

例子中的整个项目已经放到以下地址，有兴趣的人可以看一下。

https://download.csdn.net/download/qq_34484062/12387780

 

飘零未归人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用spring restTemplate的坑
lunhuasxk的专栏
03-04 313
文章目录广告项目需求方案问题测试结果 广告项目 需求 广告点击事件转发 方案 接受请求，将结果发送kafka缓存 @GetMapping("/test") public String test(HttpServletRequest request) { final String queryString = request.getQueryString(); log.info("{}",queryString); return queryString; } 将结果转发给
spring cloud学习（四） 负载均衡Ribbon-RestTemplate
毅香雪海的博客
05-02 205
负载均衡主要是提供客户端的软件的负载均衡的算法，将Netflix的中间层服务连在一起，并提供超市连接，重试。Ribbon的服务链表有两种方式，一种是自己维护列表。这种方式，ribbon可以自动剔除实例。但增加新实例时，需要手工调用接口实现。第二种可以通过Eureka获取服务信息。 负载均衡主要是在实现服务调用的时候使用算法来决定当前过来的接口应该转接到多个服务中的哪个服...
request和response的setCharacterEncoding()方法
qq_38409944的博客
08-01 3万+
转载自： https://blog.csdn.net/kong_lev/article/details/73071198 1、pageEncoding=”UTF-8”的作用是设置JSP编译成Servlet时使用的编码。 2、contentType=”text/html;charset=UTF-8”的作用是指定服务器响应给浏览器的编码。 　 JSP要经过两次的“编码”，第一阶段会用pa...
三、Spring4的新功能和增强
等风的帆
04-06 700
移除不推荐的包和方法所有可选的第三方依赖都已经升级到了最低2010/2011(例如Spring4 通常只支持 2010 年的最新或者现在的最新发布版本):尤其是 Hibernate 3.6+、EhCache 2.1+、Quartz 1.8+、Groovy 1.8+、Joda-Time 2.0+。但是有一个例外，Spring4依赖最近的Hibernate Validator 4.3+，现在对Jacks
【Spring源码分析】38-RestTemplate详解
通往神秘的道路的专栏
03-06 8071
同步客户端执行HTTP请求，在底层HTTP客户端库（如JDK HttpURLConnection，Apache HttpComponents等）上公开简单的模板方法API。RestTemplate除了支持频率较低的情况的通用交换和执行方法之外，还通过HTTP方法提供常见方案的模板。注意：从5.0开始，非阻塞，反应式org.springframework.web.reactive.client.We...
SpringCloud之负载均衡Ribbon
weixin_46171048的博客
04-25 1167
利用Ribbon实现负载均衡效果
Spring Cloud Alibaba之负载均衡组件Ribbon
最新发布
ysy1119的博客
06-27 1442
简单来说，Ribbon是一个客户端负载均衡器，提供多种负载均衡策略，以便在客户端选择最佳的服务实例。同时也是Spring Cloud Alibaba 体系中负责负载均衡的组件，是一组类库的集合。Ribbon在客户端进行负载均衡，而不是依赖服务器端的负载均衡器。与Eureka等服务发现组件集成，通过服务名称来调用不同的服务实例。可以保留服务结点访问的相关统计信息，这样可以避免向高延迟或低高故障的节点发送请求。允许用户定制负载均衡策略，如随机策略、轮询策略等。
SpringCloud客户端的负载均衡Ribbon的实现
08-27
SpringCloud客户端的负载均衡Ribbon的实现 微服务架构中，单个微服务有多个实例是不可避免的，这就需要对客户端的请求进行负载均衡，以便将请求分摊到多个微服务的实例上。Ribbon是一个由Netflix发布的负载均衡器，...
spring cloud 之 客户端负载均衡Ribbon深入理解
08-30
【Spring Cloud Ribbon 深入理解：客户端负载均衡】 负载均衡是现代分布式系统中的关键组件，用于提升系统可用性和性能。在Spring Cloud框架中，Ribbon是一个轻量级的客户端负载均衡器，它实现了客户端的负载均衡...
Spring Cloud Ribbon负载均衡器处理方法
08-27
Spring Cloud Ribbon负载均衡器处理方法 Spring Cloud Ribbon负载均衡器处理方法是指在Spring Cloud中使用Ribbon实现负载均衡的处理方法。该方法主要介绍了如何获取服务实例，获取以后做了哪些处理，处理后又是如何...
SpringCloud之Ribbon负载均衡的入门操作
01-27
在Spring Cloud生态系统中，Ribbon是一个重要的组件，它作为客户端的负载均衡器，主要用于服务消费者端，以便在多个服务提供者之间智能地分配请求。在使用Ribbon之前，我们需要理解为何需要它。当我们把服务提供者...
73-Spring Cloud客户端负载均衡Ribbon笔记1
08-08
Spring Cloud中的Ribbon是实现客户端负载均衡的关键组件。在传统的服务端负载均衡中，像Nginx这样的代理服务器会接收请求并根据预设的算法（如轮询、权重轮询、随机等）转发到后端服务。而在客户端负载均衡模式下，...
@RequestParam @RequestBody @PathVariable 等参数绑定注解详解
热门推荐
行者无疆
09-21 22万+
引言： 接上一篇文章，对@RequestMapping进行地址映射讲解之后，该篇主要讲解request 数据到handler method 参数数据的绑定所用到的注解和什么情形下使用； 简介： handler method 参数绑定常用的注解,我们根据他们处理的Request的不同内容部分分为四类：（主要讲解常用类型） A、处理requet uri 部分（这里指uri templa
@Bean的使用
毅香雪海的博客
09-24 2万+
@Bean是一个方法级别上的注解，主要用在@Configuration注解的类里，也可以用在@Component注解的类里。目的是创建一个类。当spring需要创建指定的一个类时会调用这个注解（@Bean）的方法。 一个对象 @Data @AllArgsConstructor @NoArgsConstructor public class Info { String name; ...
springboot中META-INF/spring.factories解析加载类
毅香雪海的博客
04-27 1万+
org.springframework.boot.autoconfigure.EnableAutoConfiguration org.springframework.cloud.bootstrap.BootstrapConfiguration
SpringContextUtils.getBean() 和 @Component共同存在的导致问题。
毅香雪海的博客
10-29 1万+
在项目中我们会多类的创建都会交给spring来完成。我们使用是都只要从容器中获取就可以了。 在某些情况下我们在自己建的类中会需要用到spring容器中的类，这样我们会写一个方法来获取，这个方法在这里就不做介绍了。有兴趣的可以看 https://blog.csdn.net/qq_34484062/article/details/101282262 我在项目中遇到过着样的情况，在@Compo...
SpringBoot 从容器中获取对象
毅香雪海的博客
09-24 8343
有时候在项目中，我们会自己创建一些类，类中需要使用到容器中的一些类。方法是新建类并实现ApplicationContextAware 接口，在类中建立静态对象 ApplicationContext 对象，这个对象就如同xml配置中的 applicationContext.xml，容器中类都可以获取到。例如@Service、 @Component 标注的类都能获取到。 /** * 功能描述：Sp...
新建springboot聚合项目，一启动完就停止结束了
毅香雪海的博客
08-30 6683
背景 最近一直再做springboot项目的开发。但是一直弄的是代码逻辑。所以想试一下从无到有的建立一个springboot聚合测试项目。好吧，果然很多事还是不能拍拍脑袋就可以了。 这里就不讲所有的过程，其实是还没有完全实验成功< 难过脸 >。但是问题还是要记录一下的。 首先 我在建立如图所示的聚合项目后。 使用start下面的StartApplication启动之后 import ...
springboot无法注入@Repository注解的JpaRepository类
毅香雪海的博客
06-01 5124
最近在创建一个多module的springnoot项目时，发现项目启动一直扫描不到@Repository注释的类。 报错如下： Description: Field helloService in com.example.demo.service.TestService required a bean of type 'com.example.test.modules1.service.repository.HelloRepository' that could not be found. Ac
springcloud负载均衡ribbon
06-28
Spring Cloud负载均衡Ribbon是一种客户端负载均衡工具，它可以将请求分发到多个服务提供者实例中，从而提高系统的可用性和性能。Ribbon可以根据不同的负载均衡策略来选择服务提供者，例如轮询、随机、加权轮询等。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值