如何使用Spring Cloud – 简单服务流程（服务发现与API调用）

最新推荐文章于 2024-05-12 05:52:01 发布
最新推荐文章于 2024-05-12 05:52:01 发布
阅读量2.3k 收藏 1
点赞数

说起Spring Cloud那肯定要带上Spring Boot，业内人士对这两个东西必定不陌生。关于Spring Cloud的介绍，这里就不再过多的介绍。关于Spring Cloud搜索引擎搜索出来的资料并不乐观，可能向我一样的初学者，最需要的就是一份demo，先跑起来，至少做到麻雀虽小五脏俱全。

在这里还是要介绍以下Spring Cloud整个的工作流程。首先看一下Spring Cloud的工作流程，

Service Consumer -> Proxy Server -> Client(Load Balancer) -> Servie Discovery -> Target Service

这里就是要一个简单Service API调用的流程。下面看一下Spring Cloud中的组件与上面流程的对应关系。

Spring Cloud

Module

Restful API (Spring Boot)

Target Service

Eureka

Servie Discovery

Client & Load Balancer

Spring RestTemplate & Ribbon

Proxy(Edge) Server

Zuul

Service Consumer

Browser,Curl,Other Apps,etc

下面一步步介绍完成以上的简单demo

###数据结构及基础服务：

在这里使用Spring Boot快速的创建三个基础服务，并且其中三者之间存在逻辑依赖关系。

Company Service

Java

public class Company {

    private Long id;
    private String name;
    
    // Constructor、Getter、Setter 
｝

@RestController
public class CompanyService {

    @RequestMapping("/company/{id}")
    public Company getCompanyById(@PathVariable("id") Long id){
        sleep();
        return new Company(id, "Company");
    }
	
	 //利用时间等待模拟Serivce调用时长
    private void sleep() {
        Random rand = new Random();
        int time = rand.nextInt(2000);

        try {
            Thread.sleep(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
public class Company {
 
    private Long id;
    private String name;
    
    // Constructor、Getter、Setter
｝
 
@RestController
public class CompanyService {
 
    @RequestMapping("/company/{id}")
    public CompanygetCompanyById(@PathVariable("id") Long id){
        sleep();
        return new Company(id, "Company");
    }
 
 //利用时间等待模拟Serivce调用时长
    private void sleep() {
        Randomrand = new Random();
        int time = rand.nextInt(2000);
 
        try {
            Thread.sleep(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Employee Service

Java

public class Employee {

    private Long id;
    private Long companyId;
    private String name;
    
    // Constructor、Getter、Setter 
｝

@RestController
public class EmployeeService {

    @RequestMapping("/employee/{id}")
    public Employee getEmployeeById(@PathVariable("id") Long id) {

        sleep();
        return new Employee(id,1L,"张三");
    }

    @RequestMapping("/employee")
    public List<Employee> getEmployeesByCompanyId(@RequestParam("companyId") Long companyId){
        List<Employee> employees = new ArrayList<>();

        employees.add(new Employee(1L, companyId, "张三"));
        employees.add(new Employee(2L, companyId, "李四"));
        employees.add(new Employee(3L, companyId, "王五"));

        sleep();
        return employees;
    }

    private void sleep() {
        Random rand = new Random();
        int time = rand.nextInt(2000);

        try {
            Thread.sleep(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
public class Employee {
 
    private Long id;
    private Long companyId;
    private String name;
    
    // Constructor、Getter、Setter
｝
 
@RestController
public class EmployeeService {
 
    @RequestMapping("/employee/{id}")
    public EmployeegetEmployeeById(@PathVariable("id") Long id) {
 
        sleep();
        return new Employee(id,1L,"张三");
    }
 
    @RequestMapping("/employee")
    public List<Employee> getEmployeesByCompanyId(@RequestParam("companyId") Long companyId){
        List<Employee> employees = new ArrayList<>();
 
        employees.add(new Employee(1L, companyId, "张三"));
        employees.add(new Employee(2L, companyId, "李四"));
        employees.add(new Employee(3L, companyId, "王五"));
 
        sleep();
        return employees;
    }
 
    private void sleep() {
        Randomrand = new Random();
        int time = rand.nextInt(2000);
 
        try {
            Thread.sleep(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
}

Product Service

Java

public class Product {

    private Long id;
    private Long companyId;
    private String sku;
    
    // Constructor、Getter、Setter 
}

@RestController
public class ProductService {

    private static final Logger LOG = LoggerFactory.getLogger(ProductService.class);

    @RequestMapping("/product/{id}")
    public Product getProductById(@PathVariable("id") Long id) {

        sleep();
        return new Product(id, 1L, "T001");
    }


    @RequestMapping("/product")
    public List<Product> getProductsByCompanyId(@RequestParam("companyId") Long companyId) {
        List<Product> products = new ArrayList<>();

        products.add(new Product(1L, companyId, "T001"));
        products.add(new Product(2L, companyId, "T002"));
        products.add(new Product(3L, companyId, "T003"));
        return products;
    }


    private void sleep() {
        Random rand = new Random();
        int time = rand.nextInt(3000);

        try {
            Thread.sleep(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
public class Product {
 
    private Long id;
    private Long companyId;
    private String sku;
    
    // Constructor、Getter、Setter
}
 
@RestController
public class ProductService {
 
    private static final LoggerLOG = LoggerFactory.getLogger(ProductService.class);
 
    @RequestMapping("/product/{id}")
    public ProductgetProductById(@PathVariable("id") Long id) {
 
        sleep();
        return new Product(id, 1L, "T001");
    }
 
 
    @RequestMapping("/product")
    public List<Product> getProductsByCompanyId(@RequestParam("companyId") Long companyId) {
        List<Product> products = new ArrayList<>();
 
        products.add(new Product(1L, companyId, "T001"));
        products.add(new Product(2L, companyId, "T002"));
        products.add(new Product(3L, companyId, "T003"));
        return products;
    }
 
 
    private void sleep() {
        Randomrand = new Random();
        int time = rand.nextInt(3000);
 
        try {
            Thread.sleep(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这三个服务都应该是正常独立服务的。

所有的服务都需要在注册中心进行对当前服务的注册，因此要在三个服务的启动程序上加上注解 @EnableDiscoveryClient

在配置文件bootstrap.yml中加入以下配置

YAML

spring:
  application:
    name: company-service
  cloud:
    config:
      uri: ${vcap.services.${PREFIX:}configserver.credentials.uri:http://user:password@localhost:8888}
spring:
  application:
    name: company-service
  cloud:
    config:
      uri: ${vcap.services.${PREFIX:}configserver.credentials.uri:http://user:password@localhost:8888}

###服务中心

注册中心，在Demo中只用到最简单的服务发现与注册，只需要在启动程序加上注解 @EnableEurekaServer

@EnableDiscoveryClient

在application.yml中对注册服务进行配置

YAML

server:
  port: 8761
security:
  user:
    password: ${eureka.password}

eureka:
  client:
    registerWithEureka: false
    fetchRegistry: false
  server:
    waitTimeInMsWhenSyncEmpty: 0
  password: ${SECURITY_USER_PASSWORD:password}
server:
  port: 8761
security:
  user:
    password: ${eureka.password}
 
eureka:
  client:
    registerWithEureka: false
    fetchRegistry: false
  server:
    waitTimeInMsWhenSyncEmpty: 0
  password: ${SECURITY_USER_PASSWORD:password}

###远程调用Client Adapter

使用服务发现来寻找真实的服务地址，并获取API返回的数据。

在这里需要创建三个model，用来转换API结构

Java

public class CompanyAll {

    private Long id;
    private String name;
    private List<ProductDetail> productList;
    private List<EmployeeDetail> employeeList;

    public CompanyAll(Company company, List<Product> productList, List<Employee> employeeList) {
        this.id = company.getId();
        this.name = company.getName();
        if (employeeList != null) {
            this.productList = productList.stream().map(product ->
                    new ProductDetail(product.getId(), product.getSku())
            ).collect(Collectors.toList());
        }

        if (employeeList != null) {
            this.employeeList = employeeList.stream().map(employee ->
                    new EmployeeDetail(employee.getId(), employee.getName())
            ).collect(Collectors.toList());
        }

    }
    //Getter、Setter 
}

public class EmployeeDetail {
    private Long id;
    private String name;
    
   // Constructor、Getter、Setter
}

public class ProductDetail {

    private Long id;
    private String sku;
    
    // Constructor、Getter、Setter
}
public class CompanyAll {
 
    private Long id;
    private String name;
    private List<ProductDetail> productList;
    private List<EmployeeDetail> employeeList;
 
    public CompanyAll(Companycompany, List<Product> productList, List<Employee> employeeList) {
        this.id = company.getId();
        this.name = company.getName();
        if (employeeList != null) {
            this.productList = productList.stream().map(product ->
                    new ProductDetail(product.getId(), product.getSku())
            ).collect(Collectors.toList());
        }
 
        if (employeeList != null) {
            this.employeeList = employeeList.stream().map(employee ->
                    new EmployeeDetail(employee.getId(), employee.getName())
            ).collect(Collectors.toList());
        }
 
    }
    //Getter、Setter
}
 
public class EmployeeDetail {
    private Long id;
    private String name;
    
  // Constructor、Getter、Setter
}
 
public class ProductDetail {
 
    private Long id;
    private String sku;
    
    // Constructor、Getter、Setter
}

创建工具类AppUtil

在工具类中会调用到LoadBalancerClient，这个就是有Netflix Ribbon提供的Client。他会根据ServiceId（配置文件中的Service Name）向Eureka（注册服务器）获取服务地址。在这里也可以提供一个容错机制，极限情况下，全宕机时使用fallbackUri。

Java

@Component
public class AppUtil {

    @Autowired
    private LoadBalancerClient loadBalancer;

    public URI getRestUrl(String serviceId, String fallbackUri) {
        URI uri = null;
        try {
            ServiceInstance instance = loadBalancer.choose(serviceId);
            uri = instance.getUri();

        } catch (RuntimeException e) {
            uri = URI.create(fallbackUri);
        }

        return uri;
    }

    public <T> ResponseEntity<T> createOkResponse(T body) {
        return createResponse(body, HttpStatus.OK);
    }

    public <T> ResponseEntity<T> createResponse(T body, HttpStatus httpStatus) {
        return new ResponseEntity<>(body, httpStatus);
    }

    public <T> T json2Object(ResponseEntity<String> response, Class<T> clazz) {
        try {

            return (T) JSON.parseObject(response.getBody(), clazz);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

    public <T> List<T> json2Objects(ResponseEntity<String> response, Class<T> clazz) {
        try {

            return JSON.parseArray(response.getBody(), clazz);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
@Component
public class AppUtil {
 
    @Autowired
    private LoadBalancerClientloadBalancer;
 
    public URIgetRestUrl(String serviceId, String fallbackUri) {
        URIuri = null;
        try {
            ServiceInstanceinstance = loadBalancer.choose(serviceId);
            uri = instance.getUri();
 
        } catch (RuntimeException e) {
            uri = URI.create(fallbackUri);
        }
 
        return uri;
    }
 
    public <T> ResponseEntity<T> createOkResponse(T body) {
        return createResponse(body, HttpStatus.OK);
    }
 
    public <T> ResponseEntity<T> createResponse(T body, HttpStatushttpStatus) {
        return new ResponseEntity<>(body, httpStatus);
    }
 
    public <T> T json2Object(ResponseEntity<String> response, Class<T> clazz) {
        try {
 
            return (T) JSON.parseObject(response.getBody(), clazz);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
 
    }
 
    public <T> List<T> json2Objects(ResponseEntity<String> response, Class<T> clazz) {
        try {
 
            return JSON.parseArray(response.getBody(), clazz);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

当然这里还需要一个Client来对Api进行访问及Response数据处理

Java

@Component
public class RemoteServiceClient {

    @Autowired
    AppUtil appUtil;

    private RestTemplate restTemplate = new RestTemplate();

    public ResponseEntity<Company> getCompanyById(Long id) {

        URI uri = appUtil.getRestUrl("COMPANY-SERVICE", "http://localhost:57773/");
        String url = uri.toString() + "/company/" + id;

        ResponseEntity<String> resultStr = restTemplate.getForEntity(url, String.class);

        Company company = appUtil.json2Object(resultStr, Company.class);

        return appUtil.createOkResponse(company);
    }


    public ResponseEntity<List<Employee>> getEmployeesByCompanyId(Long id) {
        try {

            URI uri = appUtil.getRestUrl("EMPLOYEE-SERVICE", "http://localhost:58017");

            String url = uri.toString() + "/employee?companyId=" + id;

            ResponseEntity<String> resultStr = restTemplate.getForEntity(url, String.class);

            List<Employee> employees = appUtil.json2Objects(resultStr, Employee.class);

            return appUtil.createOkResponse(employees);
        } catch (Throwable t) {
            throw t;
        }
    }

    public ResponseEntity<List<Product>> getProductsByCompanyId(Long id) {
        try {

            URI uri = appUtil.getRestUrl("PRODUCT-SERVICE", "http://localhost:57750");

            String url = uri.toString() + "/product?companyId=" + id;

            ResponseEntity<String> resultStr = restTemplate.getForEntity(url, String.class);

            List<Product> employees = appUtil.json2Objects(resultStr, Product.class);

            return appUtil.createOkResponse(employees);
        } catch (Throwable t) {
            throw t;
        }
    }
}
@Component
public class RemoteServiceClient {
 
    @Autowired
    AppUtilappUtil;
 
    private RestTemplaterestTemplate = new RestTemplate();
 
    public ResponseEntity<Company> getCompanyById(Long id) {
 
        URIuri = appUtil.getRestUrl("COMPANY-SERVICE", "http://localhost:57773/");
        String url = uri.toString() + "/company/" + id;
 
        ResponseEntity<String> resultStr = restTemplate.getForEntity(url, String.class);
 
        Companycompany = appUtil.json2Object(resultStr, Company.class);
 
        return appUtil.createOkResponse(company);
    }
 
 
    public ResponseEntity<List<Employee>> getEmployeesByCompanyId(Long id) {
        try {
 
            URIuri = appUtil.getRestUrl("EMPLOYEE-SERVICE", "http://localhost:58017");
 
            String url = uri.toString() + "/employee?companyId=" + id;
 
            ResponseEntity<String> resultStr = restTemplate.getForEntity(url, String.class);
 
            List<Employee> employees = appUtil.json2Objects(resultStr, Employee.class);
 
            return appUtil.createOkResponse(employees);
        } catch (Throwable t) {
            throw t;
        }
    }
 
    public ResponseEntity<List<Product>> getProductsByCompanyId(Long id) {
        try {
 
            URIuri = appUtil.getRestUrl("PRODUCT-SERVICE", "http://localhost:57750");
 
            String url = uri.toString() + "/product?companyId=" + id;
 
            ResponseEntity<String> resultStr = restTemplate.getForEntity(url, String.class);
 
            List<Product> employees = appUtil.json2Objects(resultStr, Product.class);
 
            return appUtil.createOkResponse(employees);
        } catch (Throwable t) {
            throw t;
        }
    }
}

最终还是需要对外暴露一个端口来返回数据，这里也是一个Restful接口

Java

@RestController
public class RemoteAdapter {

    private static final Logger LOG = LoggerFactory.getLogger(RemoteAdapter.class);


    @Autowired
    RemoteServiceClient client;

    @Autowired
    AppUtil appUtil;

    @RequestMapping("/")
    public String welcome() {

        return "welcome to use my demo";
    }

    @RequestMapping("/company/{id}")
    public ResponseEntity<CompanyAll> getCompany(@PathVariable("id") Long id) {

        ResponseEntity<Company> companyResult = client.getCompanyById(id);

        if (!companyResult.getStatusCode().is2xxSuccessful()) {
            return appUtil.createResponse(null, companyResult.getStatusCode());
        }

        List<Product> products = null;
        try {
            ResponseEntity<List<Product>> productsResult = client.getProductsByCompanyId(id);
            if (!productsResult.getStatusCode().is2xxSuccessful()) {
                LOG.error("远程调用Product API 失败");
            } else {
                products = productsResult.getBody();
            }
        } catch (Throwable t) {
            LOG.error("远程调用Product API 异常 ", t);
            throw t;
        }

        List<Employee> employees = null;
        try {
            ResponseEntity<List<Employee>> employeeResult = null;
            employeeResult = client.getEmployeesByCompanyId(id);
            if (!employeeResult.getStatusCode().is2xxSuccessful()) {
                LOG.error("远程调用Employee API 失败");
            } else {
                employees = employeeResult.getBody();
            }

        } catch (Throwable t) {
            LOG.error("远程调用Employee API 失败");
            throw t;
        }


        return appUtil.createOkResponse(new CompanyAll(companyResult.getBody(), products, employees));
    }
}
@RestController
public class RemoteAdapter {
 
    private static final LoggerLOG = LoggerFactory.getLogger(RemoteAdapter.class);
 
 
    @Autowired
    RemoteServiceClientclient;
 
    @Autowired
    AppUtilappUtil;
 
    @RequestMapping("/")
    public String welcome() {
 
        return "welcome to use my demo";
    }
 
    @RequestMapping("/company/{id}")
    public ResponseEntity<CompanyAll> getCompany(@PathVariable("id") Long id) {
 
        ResponseEntity<Company> companyResult = client.getCompanyById(id);
 
        if (!companyResult.getStatusCode().is2xxSuccessful()) {
            return appUtil.createResponse(null, companyResult.getStatusCode());
        }
 
        List<Product> products = null;
        try {
            ResponseEntity<List<Product>> productsResult = client.getProductsByCompanyId(id);
            if (!productsResult.getStatusCode().is2xxSuccessful()) {
                LOG.error("远程调用Product API 失败");
            } else {
                products = productsResult.getBody();
            }
        } catch (Throwable t) {
            LOG.error("远程调用Product API 异常 ", t);
            throw t;
        }
 
        List<Employee> employees = null;
        try {
            ResponseEntity<List<Employee>> employeeResult = null;
            employeeResult = client.getEmployeesByCompanyId(id);
            if (!employeeResult.getStatusCode().is2xxSuccessful()) {
                LOG.error("远程调用Employee API 失败");
            } else {
                employees = employeeResult.getBody();
            }
 
        } catch (Throwable t) {
            LOG.error("远程调用Employee API 失败");
            throw t;
        }
 
 
        return appUtil.createOkResponse(new CompanyAll(companyResult.getBody(), products, employees));
    }
}

Ok，这里最后还是需要application.yml配置文件，对相关进行配置。当然bootstrap.yml的注册配置还是不能少的

YAML

server:
  port: 0

eureka:
  instance:
    leaseRenewalIntervalInSeconds: 10
    metadataMap:
      instanceId: ${vcap.application.instance_id:${spring.application.name}:${spring.application.instance_id:${random.value}}}
  client:
    registryFetchIntervalSeconds: 5
server:
  port: 0
 
eureka:
  instance:
    leaseRenewalIntervalInSeconds: 10
    metadataMap:
      instanceId: ${vcap.application.instance_id:${spring.application.name}:${spring.application.instance_id:${random.value}}}
  client:
    registryFetchIntervalSeconds: 5

###代理（边界）服务

边界服务在这里也demo中没有运用到太多的功能，这里只使用了路由转发的作用，因此也不用做过多的配置。只需要在启动程序上添加注解 @Controller @EnableZuulProxy即可

在application.yml需要对服务进行一些配置,由于在上述代码中提到了线程等待时间来模拟API调用时间，因此需要对ribbon的TimeOut时间设置到60秒。对zuul的配置最常用的是路由，对Client暴漏的服务接口进行路由转发

YAML

info:
  component: Zuul Server

endpoints:
  restart:
    enabled: true
  shutdown:
    enabled: true
  health:
    sensitive: false
hystrix:
  command:
    default:
      execution:
        timeout:
          enabled: false
ribbon:
  ReadTimeout: 60000
  ConnectTimeout: 6000

zuul:
  ignoredServices: "*"
  routes:
    service-adapter:
      path: /app/**

server:
  port: 8765

logging:
  level:
    ROOT: INFO
    org.springframework.web: INFO
info:
  component: Zuul Server
 
endpoints:
  restart:
    enabled: true
  shutdown:
    enabled: true
  health:
    sensitive: false
hystrix:
  command:
    default:
      execution:
        timeout:
          enabled: false
ribbon:
  ReadTimeout: 60000
  ConnectTimeout: 6000
 
zuul:
  ignoredServices: "*"
  routes:
    service-adapter:
      path: /app/**
 
server:
  port: 8765
 
logging:
  level:
    ROOT: INFO
    org.springframework.web: INFO

## 结果预览

来源：http://www.tuicool.com/articles/VbURJzQ

hellolio
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot启动详解
henlang的专栏
10-13 1074
springboot启动
SpringCloud——服务接口(api)
热门推荐
qq_34819372的博客
09-24 1万+
SpringCloud的服务接口基本等同于SpringBoot开发的api接口，只不过在springCloud需要将自己的服务注册到注册中心，通过网关统一访问路径 一个简单的api接口 pom.xml &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSche...
Spring Boot 常用注解大全：每个程序员必备_springboot中的常见注解
最新发布
2301_79099416的博客
05-12 620
这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你！
springcloud学习（三）eureka client定位与接口API
海洋中摇曳的扁舟
01-25 954
eureka client eureka作为注册中心，任何注册到其上面的服务，都可以被称之为client。不管是服务的提供者，还是服务的消费者。 搭建client步骤 搭建工程，比如user-service 或者payment-service。（用户服务、支付服务） 引用eureka client的包。 配置yml。 在springboot启动类增加注解 @EnableEurekaClient yml配置参考 server: port: 9002 spring: applic
《深入实践Spring Boot》阅读笔记：分布式应用开发
情情说
02-21 1492
上篇文章总结了《深入实践Spring Boot》的第一部分，这篇文章介绍第二部分：分布式应用开发，以及怎么构建一个高性能的服务平台。 主要从以下几个方面总结： Spring Boot SSO 使用分布式文件系统 云应用开发 构建高性能的服务平台 Spring Boot SSO 上篇文章提到了安全设计，使用Spring Security进行用户验证和权限验证，但一个企业级的应用系...
spring cloud 使用Zuul 实现API网关服务问题
08-27
Spring Cloud 使用 Zuul 实现 API 网关服务问题 在本文中，我们将主要介绍如何使用 Spring Cloud 的 Zuul 组件来实现 API 网关服务问题。 Zuul 是一个基于 Netflix Zuul 的 API 网关组件，它可以解决路由规则和服务...
详解Spring-Cloud2.0之Feign调用远程服务指南
08-26
"详解Spring-Cloud2.0之Feign调用远程服务指南" Feign是简化Java HTTP客户端开发的工具，灵感来自于Retrofit、JAXRS-2.0和WebSocket。Feign的初衷是降低统一绑定Denominator到HTTP API的复杂度，不区分是否为...
springcloud之自定义简易消费服务组件
08-27
本篇文章主要介绍了如何使用 Spring Cloud 实现自定义简易消费服务组件，通过 REST+Ribbon 消费服务，并且通过轮询方式来自定义了个简易消费组件。 知识点1: REST+Ribbon 实现消费服务 在微服务架构中，服务提供者...
spring cloud feign实现远程调用服务传输文件的方法
08-27
Spring Cloud Feign 是一个基于 Java 的声明式 RESTful 客户端，提供了一种简单、可靠的方式来调用远程服务。在本文中，我们将介绍如何使用 Spring Cloud Feign 实现远程调用服务传输文件的方法。 Feign 介绍 ...
SpringCloud 服务负载均衡和调用 Ribbon、OpenFeign的方法
09-07
SpringCloud 是一个全面的微服务解决方案，其中包括服务发现、服务治理、断路器、智能路由、微代理等多个组件。在SpringCloud中，服务负载均衡是一个关键特性，它可以帮助我们在调用微服务时分散请求压力，提高系统...
Spring-Cloud-Gateway-02-请求调用基本流程
Apandam的博客
10-17 2338
之后，会通过一些匹配条件，定位到真正的服务节点，并且在这个转发过程前后，进行一些细粒度的控制，其中。：GateWayFilter的实例，使用过滤器，可以在请求被路由之前或者之后对请求进行修改。：开发人员可以匹配HTTP请求中的内容（请求头和请求参数），如果请求断言匹配则进行路由。：构建网关的基础模块，由ID、目标URL、过滤器等组成。spring cloud gateway 官网的流程图。
分布式系统
皇甫嗷嗷叫
08-23 266
分布式系统是若干系统的集合 从进程角度来说，两个程序分别运行在两个主机的两个进程上，他们互相协作完成同一个功能们也可以称作为分布式系统！ 微服务架构更偏向于业务，而分布式更偏向于机器！ 分布式虽然可扩展性强，但是也带来一系列的问题： 典型的Session问题，单机环境下Session通常会存储在服务器里面，多台机器情况下，会导致用户一直重复登录，当然解决的方案也有很多：比如Red...
SpringCloud Gateway 简介、工作流程、快速入门
豆恭梓的博客
07-11 711
网关是微服务最边缘的服务，直接暴露给用户，用来做用户和微服务的桥梁没有网关：客户端直接访问我们的微服务，会需要在客户端配置很多的 ip：port，如果user-service 并发比较大，则无法完成负载均衡有网关：客户端访问网关，网关来访问微服务，（网关可以和注册中心整合，通过服务名称找到目标的 ip：prot）这样只需要使用服务名称即可访问微服务，可以实现负载均衡，可以实现token 拦截，权限验证，限流等操作你们项目里面 用的什么网关？
SpringCloud实战【九】: SpringCloud服务间调用
u010482601的专栏
10-16 1万+
1 服务间调用 微服务的特点是服务数量特别多，服务和服务之间也需要有交互，这就涉及到服务间的调用，即服务与服务之间如何通信。提到服务与服务之间的通信，最通用的莫过于HttpClient，在其它的通信架构中基本都使用HttpClient来作为底层的通讯模型。在SpringCloud中依然可以使用HttpClient进行服务与服务调用，只不过如果采用HttpClient调用的话，会有一些弊端，例如: 如果同一个服务有多个负载的话，采用HttpClient调用时，没有办法处理负载均衡的问题。还有...
SpringCloud 三种服务调用方式，你学会了吗？
知识分享官
09-04 732
搭建服务测试环境测试中，服务发现层采用Netflix的Eureka搭建。主要步骤如下：1.引入Eureka所需依赖<!--eureka服务端-->&nbsp;&nbsp;<dependency>&nbsp;&nbsp;&nbsp;&nbsp;<groupId>org.springframework.cloud</groupId>&nbsp;&nbsp;&nbsp;&nbsp;&lt
一、SpringCloud微服务整体流程介绍
oFlying1的博客
04-14 2004
一 eureka结构示意图 二微服务概括 分布式服务就是将商品管理 检索 购物车 前端 后端等分离开来的服务. 微服务是服务的最小单元. 但是多个微服务之间怎么通信的呢?有两种方式 RPC和HTTP,其中HTTP采用的是SpringCloud框架,RPC采用的是阿里的Dubbo框架. RestTemplate 如果微服务采用了http模式,我们就要对请求和响应进行处理,采用spring tem...
一文带你速通SpringCloud
m0_63161215的博客
03-08 1326
总结：不管是拦截器还是过滤器，他的基本原理都是在网络层去服务的，是要在controller之前或者说是和controller同理的一种类型，会抓取指定的请求去处理代码，他的处理和controller类似，都会去调用service层再去调用dao层，也是层层递进的，简化了service层，并给出了宏观的解决方案。调用服务也需RestTemplate提供的API。如果某个目标服务调用慢或者有大量超时，此时，熔断该服务的调用，对于后续调用请求，不在继续调用目标服务，直接返回，快速释放资源。
【熔断器Hystrix】
Java—wang的博客
07-29 328
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-ribbon</artifactId> </dependency> <!--hystrix依赖，主要是用 @HystrixComm...
SpringCloud微服务架构笔记（二）
03-18
在SpringCloud中，使用Feign非常简单，我们只需要创建一个接口，并在接口上添加一些注解即可完成代码的编写。Feign支持多种注解，包括Feign自带的注解以及JAX-RS注解等。而SpringCloud对Feign进行了增强，使得Feign...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值