微服务---5.微服务场景模拟

最新推荐文章于 2021-06-04 19:32:42 发布
最新推荐文章于 2021-06-04 19:32:42 发布
阅读量359 收藏
点赞数
分类专栏： 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lucasmaluping/article/details/103597469
版权

5.创建工程

1、项目整体架构：

在这里插入图片描述
common:
在这里插入图片描述
service
在这里插入图片描述
consumer:
在这里插入图片描述
eureka:
在这里插入图片描述

2.代码：

service代码

UserController ：

package com.lucas.service.web;


import com.lucas.service.service.CountryService;
import com.zpark.model.Country;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Author Lucas
 * @Date 2019/12/17 14:13
 * @Version 1.0
 */
@RestController
@RequestMapping("/")
public class UserController {
    @Autowired
    CountryService countryService;



//    @RequestMapping("/{id}")
//    public User selectUser(@PathVariable("id") Long id) {
//        return userService.queryById(id);
//    }

    @RequestMapping(value = {"findall"})
    public String findAll() {
        List<Country> countries = countryService.queryAll();
        StringBuilder sb = new StringBuilder();
        for (Country country: countries) {
            sb.append(country.toString());
        }
        return sb.toString();
    }
}

CountryService

package com.lucas.service.service;


import com.zpark.model.Country;

import java.util.List;

/**
 * @Author Lucas
 * @Date 2019/12/17 14:12
 * @Version 1.0
 */
public interface CountryService {
    public List<Country> queryAll();
}

CountryServiceImpl

package com.lucas.service.service;

import com.lucas.service.mapper.CountryMapper;

import com.zpark.model.Country;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author Lucas
 * @Date 2019/12/17 14:16
 * @Version 1.0
 */
@Service
public class CountryServiceImpl implements CountryService {
    @Autowired
    private CountryMapper countryMapper;

    @Override
    public List<Country> queryAll() {
        return countryMapper.selectAll();
    }
}

CountryMapper

package com.lucas.service.mapper;


import com.zpark.model.Country;
import tk.mybatis.mapper.common.Mapper;

/**
 * @Author Lucas
 * @Date 2019/12/17 14:12
 * @Version 1.0
 */

public interface CountryMapper extends Mapper<Country> {
}

service的配置文件
application.yml

server:
  port: 8081
  servlet:
    context-path: /
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/frame?characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: lucas
    driver-class-name: com.mysql.cj.jdbc.Driver
  thymeleaf:
    cache: false
  application:
    name: user-service

mybatis:
  type-aliases-package: com.zpark.model
  configuration:
    map-underscore-to-camel-case: true
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10086/eureka,http://localhost:10087/eureka
  instance:
    prefer-ip-address: true
    ip-address: 127.0.0.1

service的porm：

<?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/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>com.lucas</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-service</artifactId>
    <!--添加依赖-->
    <dependencies> <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency> <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency> <!--mapper启动器 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <dependency>
            <artifactId>user-common</artifactId>
            <groupId>com.lucas</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- Eureka客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.1.2.RELEASE</version><!--服务器有可不写-->
        </dependency>
    </dependencies>

</project>

Consumer代码：

ConsumerController

package com.lucas.consumer.controller;

import com.zpark.model.Country;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * @Author Lucas
 * @Date 2019/12/18 11:04
 * @Version 1.0
 */
@RestController
@RequestMapping("/")
public class ConsumerController {
    private String SERVICEURL = "http://localhost:8081/findall";
    @Autowired
    RestTemplate template;

    @Autowired
    DiscoveryClient discoveryClient;

    @RequestMapping("findall")
    public String findAll() {
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        ServiceInstance instance = instances.get(0);
        String host = instance.getHost();
        int port = instance.getPort();
//        return template.getForObject(SERVICEURL, String.class);
        String urlByEureka = "http://" + host + ":" + port + "/findall";
        return template.getForObject(urlByEureka, String.class);
    }
}

ConsumerController3

package com.lucas.consumer.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * @Author Lucas
 * @Date 2019/12/18 17:53
 * @Version 1.0
 */
@RestController
@RequestMapping("/")
public class ConsumerController3 {
    @Autowired
    RestTemplate restTemplate;

    @Autowired
    LoadBalancerClient loadBalancerClient;

    @RequestMapping("findall2")
    public String findAll() {
        ServiceInstance instance = loadBalancerClient.choose("user-service");
        String host = instance.getHost();
        int port = instance.getPort();
//        return template.getForObject(SERVICEURL, String.class);
        String urlByEureka = "http://" + host + ":" + port + "/findall";
        return restTemplate.getForObject(urlByEureka, String.class);
    }

    @RequestMapping("findall3")
    public String findAll2() {
        return restTemplate.getForObject("http://user-service/findall",String.class);
    }

    @RequestMapping("findall4")
    public String findAll3() {
        ResponseEntity<String> forEntity = restTemplate.getForEntity("http://user-service/findall", String.class);
        HttpStatus statusCode = forEntity.getStatusCode();
        int statusCodeValue = forEntity.getStatusCodeValue();
        HttpHeaders headers = forEntity.getHeaders();
        String body = forEntity.getBody();
        StringBuilder result = new StringBuilder();
        result.append("responseEntity.getBody()：").append(body).append("<hr>")
                .append("responseEntity.getStatusCode()：").append(statusCode).append("<hr>")
                .append("responseEntity.getStatusCodeValue()：").append(statusCodeValue).append("<hr>")
                .append("responseEntity.getHeaders()：").append(headers).append("<hr>");
        return result.toString();
    }

}

启动类：ConsumerApplication

package com.lucas.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * @Author Lucas
 * @Date 2019/12/18 10:39
 * @Version 1.0
 */
@SpringBootApplication
@EnableDiscoveryClient
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

配置文件：yml

server:
  port: 8083
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/frame?characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: lucas
    driver-class-name: com.mysql.cj.jdbc.Driver
  thymeleaf:
    cache: false
  application:
    name: user-consumer
  cloud:
    loadbalancer:
      retry:
        enabled: true # 开启Spring Cloud的重试功能
  user-service:
    ribbon:
      ConnectTimeout: 250 # Ribbon的连接超时时间
      ReadTimeout: 1000 # Ribbon的数据读取超时时间
      OkToRetryOnAllOperations: true # 是否对所有操作都进行重试
      MaxAutoRetriesNextServer: 1 # 切换实例的重试次数
      MaxAutoRetries: 1 # 对当前实例的重试次数

mybatis:
  type-aliases-package: com.zpark.model
  configuration:
    map-underscore-to-camel-case: true

eureka:
  client:
    service-url:
      defaultZone: http://localhost:10086/eureka,http://localhost:10087/eureka
  instance:
    prefer-ip-address: true
    ip-address: 127.0.0.1

porm：

<?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/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>com.lucas</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-consumer</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <artifactId>user-common</artifactId>
            <groupId>com.lucas</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- Eureka客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.1.2.RELEASE</version><!--版本报错加-->
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>2.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>

</project>

Eureka代码：

启动类：EurekaServerApplication

package com.lucas.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * @Author Lucas
 * @Date 2019/12/18 14:14
 * @Version 1.0
 */
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

yml:

server:
  port: 10086

eureka:
  client:
    service-url:
      defaultZone: http://localhost:10086/eureka
  instance:
    prefer-ip-address: true
    ip-address: 127.0.0.1
spring:
  application:
    name: eureka-server

common代码：

Country

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2017 abel533@gmail.com
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

package com.zpark.model;

import org.apache.ibatis.type.JdbcType;
import tk.mybatis.mapper.annotation.ColumnType;

import javax.persistence.Id;
import java.io.Serializable;

/**
 * Description: Country
 * Author: liuzh
 * Update: liuzh(2014-06-06 13:38)
 */
public class Country implements Serializable {
    private static final long serialVersionUID = 6569081236403751407L;
    @Id
    @ColumnType(jdbcType = JdbcType.BIGINT)
    private Long   id;
    private String countryname;
    private String countrycode;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getCountryname() {
        return countryname;
    }

    public void setCountryname(String countryname) {
        this.countryname = countryname;
    }

    public String getCountrycode() {
        return countrycode;
    }

    public void setCountrycode(String countrycode) {

        this.countrycode = countrycode;
    }

    @Override
    public String toString() {
        return "Country{" +
                "id=" + id +
                ", countryname='" + countryname + '\'' +
                ", countrycode='" + countrycode + '\'' +
                '}';
    }
}

整个项目porm：

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lucas</groupId>
    <artifactId>cloud-demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>user-service</module>
        <module>user-consumer</module>
        <module>user-common</module>
        <module>eureka-server</module>
    </modules>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath></relativePath>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
        <mapper.starter.version>2.0.3</mapper.starter.version>
        <mysql.version>8.0.15</mysql.version>
    </properties>
    <dependencyManagement>
        <dependencies> <!-- 引入sprngcloud的pom -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency> <!-- 通用mapper启动器 -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency> <!-- mysql驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies> <!--lombok-->
        <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>
lucasmaluping
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微服务实战（二十一） 从一个秒杀场景的小demo开始
看山不是山
09-20 694
介绍 之前的章节主要是把微服务架构的概念，常用组件逐个实际测验。 接下来就是开始真正项目实战，整体计划是这样的： 1、使用微服务架构实现一个秒杀下单的应用 2、集成注册中心、链路追踪、限流断路、聚合API文档等组件，整合到统一的界面，实现单点登录 3、模拟压力测试，针对互联网高并发场景进行实际测验和性能优化 4、容器化部署，在服务器上进行真实部署（规模在10台以上），实践CI / CD 以及真实高并发 目前DEMO是利用碎片时间开发，等到完整后再开放源码 应用截图 业务部分拆分为4个.
微服务--1.微服务场景模拟遇到的问题
Hi_this_is_ID的博客
12-26 400
错误1： I/O error on GET request for “http://user-service/hi”: user-service; nested exception is java.net.UnknownHostException: user-service 解决错误1的方法： 添加依赖： <dependency> <groupId&gt...
认识微服务-微服务场景模拟
shenzhen_zsw的专栏
06-10 337
认识微服务-微服务场景模拟5.微服务场景模拟5.1.服务提供者5.1.1.Spring脚手架创建工程5.1.2.编写代码5.1.3.启动并测试：5.2.服务调用者5.2.1.创建工程5.2.2.编写代码5.2.3.启动测试：5.3.有没有问题？ 5.微服务场景模拟 首先，我们需要模拟一个服务调用的场景。方便后面学习微服务架构 5.1.服务提供者 我们新建一个项目，对外提供查询用户的服务。 5.1....
微服务场景模拟
Honmaple的博客
04-01 228
1.微服务场景模拟首先，我们需要模拟一个服务调用的场景，搭建两个工程：itcast-service-provider（服务提供方）和itcast-service-consumer（服务调用方）。方便后面学习微服务架构 服务提供方：使用mybatis操作数据库，实现对数据的增删改查；并对外提供rest接口服务。 服务消费方：使用restTemplate远程调用服务提供方的rest接口服务，获取数据。...
springcloud微服务场景模拟
W_litttle的博客
01-03 279
创建父工程pom pom.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLo...
高可用短信微服务-sms.zip
最新发布
01-30
- **集成测试**：通过模拟不同场景的测试用例，确保服务的正确性和可靠性。 4. **最佳实践**： - **API设计**：遵循RESTful原则，提供清晰的接口定义，支持HTTP和HTTPS协议。 - **异常处理**：良好的错误处理...
spring-framework-reference-4.3.19.pdf
09-18
- **微服务架构**：Spring Boot简化了基于Spring的微服务应用的开发过程。 **4. 依赖管理和命名约定** - **Spring依赖**：了解Spring框架与其他库之间的依赖关系非常重要。 - **Maven依赖管理**：使用Maven来管理...
PyPI 官网下载 | cdktf-cdktf-provider-null-0.4.101.tar.gz
01-26
这在编写模板或测试场景时非常有用，可以用来占位或者模拟某些条件，而不真正影响生产环境。 关于【标签】，"zookeeper"是一个分布式协调服务，广泛用于管理分布式应用，如服务发现、配置管理和集群同步。"分布式...
PyPI 官网下载 | dbnd-test-scenarios-0.25.13.tar.gz
01-27
4. **测试数据**：为了进行测试，通常会包含一些示例数据集，用于模拟实际工作流。 5. **测试脚本**：用以验证dbnd任务正确性的单元测试或集成测试。 在标签中提到的“zookeeper”，是一个分布式协调服务，常用于...
SpringCloud-day01-微服务场景模拟
雁迟的博客
06-04 271
一、微服务场景模拟 首先，我们需要模拟一个服务调用的场景，搭建两个工程：springcloud-provider（服务提供方）和ispringcloud-consumer（服务调用方）。方便后面学习微服务架构 服务提供方：使用mybatis操作数据库，实现对数据的增删改查；并对外提供rest接口服务。 服务消费方：使用restTemplate远程调用服务提供方的rest接口服务，获取数据。 1.1、创建项目springcloud-provider（服务提供方） pom 导入依赖
模拟微服务业务场景
L-李俊漩的博客
06-29 375
一、创建步骤 模拟开发过程中的服务间关系。抽象出来，开发中的微服务之间的关系是生产者和消费者关系。 总目标：模拟一个最简单的服务调用场景，场景中保护微服务提供者(Producer)和微服务调用者(Consumer)，方便后面使用微服务架构 注意：每个微服务为一个独立的SpringBoot工程。 （1）创建一个新的Maven父工程 （2）添加起步依赖坐标 <!--创建SpringBoot...
【亲测】微服务场景模拟(案例)
Armymans的博客
11-30 6459
一.微服务场景模拟 首先，我们需要模拟一个服务调用的场景。方便后面学习微服务架构 1.1.服务提供者 我们新建一个项目，对外提供查询用户的服务。 创建数据库 CREATE TABLE `tb_user` ( `id` int(11) NOT NULL, `user_name` varchar(50) DEFAULT NULL, `password` varchar(50) DEFAUL...
微服务---6.Eureka注册中心
lucasmaluping的专栏
12-18 2640
6.4.Eureka详解 6.4.1.基础架构 Eureka架构中的三个核心角色： 服务注册中心 Eureka的服务端应用，提供服务注册和发现功能，就是刚刚我们建立的eureka-server 服务提供者 提供服务的应用，可以是SpringBoot应用，也可以是其它任意技术实现，只要对外提供的是Rest风格服务即 可。本例中就是我们实现的user-service 服务消费者 消费应用从注册中心获...
Spring REST Template
lucasmaluping的专栏
12-16 602
简介 我们之前都使用过HttpClient来发送HTTP请求，但我们很多时间都需要将HttpClient请求或者响应的数据转换为Java对象，HttpClient需要我们自己手动来解析。我们今天要介绍的Spring REST Template比HttpClient用起来更加方便简洁。 思路： 一、后台主要提供RESTFUL Service服务 二、门户，也就是前端系统，用来处理浏览器提交的请求，接...
微服务---2.远程调用方式
lucasmaluping的专栏
12-13 450
2.远程调用方式 无论是微服务还是SOA，都面临着服务间的远程调用。 那么服务间的远程调用方式有哪些呢？ 常见的远程调用方式有以下几种： RPC：Remote Produce Call远程过程调用，类似的还有RMI。自定义数据格式，基于原生TCP通信，速度快， 效率高。早期的webservice，现在热门的dubbo，都是RPC的典型 Http：http其实是一种网络传输协议，基于TCP，规定了...
微服务---7.负载均衡Ribbon
lucasmaluping的专栏
12-19 298
实际环境中，我们往往会开启很多个user-service的集群。此时我们获取的服务列表中就会有多个，到底该访问 哪个呢？ 一般这种情况下我们就需要编写负载均衡算法，在多个实例列表中进行选择。 不过Eureka中已经帮我们集成了负载均衡组件：Ribbon，简单修改代码即可使用。 什么是Ribbon： 接下来，我们就来使用Ribbon实现负载均衡。 7.1.启动...
Spring RestTemplate中几种常见的请求方式
lucasmaluping的专栏
12-19 280
GET请求 在RestTemplate中，发送一个GET请求，我们可以通过如下两种方式： 第一种：getForEntity getForEntity方法的返回值是一个ResponseEntity，ResponseEntity是Spring对HTTP请求响应的封装，包括了几个重要的元素，如响应码、contentType、contentLength、响应消息体等。比如下面一个例子： @RequestM...
微服务架构下的Sentinel：服务容错与雪崩防护
章节首先通过模拟高并发场景，如修改Tomcat并发数、使用JMeter进行压力测试，展示了在面对大量请求时，服务间的瓶颈可能会引发问题。当order方法处理能力不足时，会对message方法造成负载过大，从而显现服务雪崩的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值