微服务之间相互调用

最新推荐文章于 2024-09-06 22:10:13 发布
最新推荐文章于 2024-09-06 22:10:13 发布
阅读量883 收藏 22
点赞数 14
分类专栏： # 微服务与分布式 文章标签： 微服务 架构 云原生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45049746/article/details/141905303
版权

使用RESTful API进行微服务调用

服务A（调用方）

  1. 创建Spring Boot项目：
    使用Spring Initializr创建一个新的Spring Boot项目，并添加以下依赖：

    • Spring Web: 用于构建Web应用和RESTful API。
    • Spring Boot DevTools: 提供开发时的热加载功能。
    • Lombok (可选): 简化Java对象的开发。
    • Spring Cloud OpenFeign: 用于简化HTTP客户端调用。

  2. 配置文件application.properties：
    配置服务器端口。

    server.port=8080

  3. 定义Feign客户端：
    Feign是一个声明式HTTP客户端，可以简化RESTful服务的调用。这里定义了一个接口ServiceBClient，用于调用服务B的API。

    import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

// 定义Feign客户端，用于调用服务B的API
@FeignClient(name = "service-b", url = "http://localhost:8081")
public interface ServiceBClient {
    // 声明一个GET请求方法，映射到服务B的API
    @GetMapping("/api/data/{id}")
    String getDataById(@PathVariable("id") String id);
}

  4. 创建控制器：
    这个控制器包含一个RESTful端点，用于接收来自客户端的请求，并通过ServiceBClient调用服务B的API。

    import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceAController {

    @Autowired
    private ServiceBClient serviceBClient;  // 注入Feign客户端

    // 定义一个GET请求方法，调用服务B的API并返回结果
    @GetMapping("/service-a/data/{id}")
    public String getDataFromServiceB(@PathVariable String id) {
        return serviceBClient.getDataById(id);
    }
}

  5. 启动类：
    启动Spring Boot应用并启用Feign客户端。

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients  // 启用Feign客户端
public class ServiceAApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceAApplication.class, args);  // 启动应用
    }
}

服务B（被调用方）

  1. 创建Spring Boot项目：
    使用Spring Initializr创建一个新的Spring Boot项目，并添加以下依赖：

    • Spring Web: 用于构建Web应用和RESTful API。
    • Spring Boot DevTools: 提供开发时的热加载功能。
    • Lombok (可选): 简化Java对象的开发。

  2. 配置文件application.properties：
    配置服务器端口。

    server.port=8081

  3. 创建控制器：
    这个控制器包含一个RESTful端点，用于接收来自服务A的请求，并返回相应的数据。

    import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceBController {

    // 定义一个GET请求方法，返回ID对应的数据
    @GetMapping("/api/data/{id}")
    public String getData(@PathVariable String id) {
        return "Data from Service B with ID: " + id;
    }
}

  4. 启动类：
    启动Spring Boot应用。

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ServiceBApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceBApplication.class, args);  // 启动应用
    }
}

使用gRPC进行微服务调用

服务A（调用方）

  1. 创建Spring Boot项目：
    使用Spring Initializr创建一个新的Spring Boot项目，并添加以下依赖：

    • Spring Boot DevTools: 提供开发时的热加载功能。
    • Spring Boot Starter: 提供Spring Boot核心依赖。
    • gRPC Starter: 提供gRPC支持。

  2. 生成gRPC代码：
    定义.proto文件并使用protoc编译生成Java代码。

    syntax = "proto3";

package com.example.grpc;

// 定义gRPC服务
service DataService {
    // 定义一个RPC方法
    rpc GetData (DataRequest) returns (DataResponse);
}

// 定义请求消息
message DataRequest {
    string id = 1;
}

// 定义响应消息
message DataResponse {
    string data = 1;
}

  3. 创建gRPC客户端：
    这个服务类包含一个gRPC客户端，用于连接到服务B并调用其方法。

    import com.example.grpc.DataServiceGrpc;
import com.example.grpc.DataRequest;
import com.example.grpc.DataResponse;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import org.springframework.stereotype.Service;

@Service
public class GrpcClientService {

    private final DataServiceGrpc.DataServiceBlockingStub stub;

    public GrpcClientService() {
        // 创建一个gRPC通道，连接到服务B
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 9090)
            .usePlaintext()
            .build();
        // 创建一个阻塞式的gRPC客户端
        stub = DataServiceGrpc.newBlockingStub(channel);
    }

    // 调用服务B的gRPC方法
    public String getData(String id) {
        DataRequest request = DataRequest.newBuilder().setId(id).build();
        DataResponse response = stub.getData(request);
        return response.getData();
    }
}

  4. 创建控制器：
    这个控制器包含一个RESTful端点，用于接收来自客户端的请求，并通过GrpcClientService调用服务B的gRPC服务。

    import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceAController {

    @Autowired
    private GrpcClientService grpcClientService;  // 注入gRPC客户端服务

    // 定义一个GET请求方法，调用服务B的gRPC方法并返回结果
    @GetMapping("/service-a/data/{id}")
    public String getDataFromServiceB(@PathVariable String id) {
        return grpcClientService.getData(id);
    }
}

  5. 启动类：
    启动Spring Boot应用。

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ServiceAApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceAApplication.class, args);  // 启动应用
    }
}

服务B（被调用方）

  1. 创建Spring Boot项目：
    使用Spring Initializr创建一个新的Spring Boot项目，并添加以下依赖：

    • Spring Boot DevTools: 提供开发时的热加载功能。
    • Spring Boot Starter: 提供Spring Boot核心依赖。
    • gRPC Starter: 提供gRPC支持。

  2. 生成gRPC代码：
    定义.proto文件并使用protoc编译生成Java代码（同上）。

  3. 实现gRPC服务：
    这个服务类实现了gRPC服务，处理来自服务A的请求并返回响应数据。

    import com.example.grpc.DataServiceGrpc;
import com.example.grpc.DataRequest;
import com.example.grpc.DataResponse;
import io.grpc.stub.StreamObserver;
import net.devh.boot.grpc.server.service.GrpcService;

@GrpcService
public class GrpcDataService extends DataServiceGrpc.DataServiceImplBase {

    // 实现gRPC服务的方法
    @Override
    public void getData(DataRequest request, StreamObserver<DataResponse> responseObserver) {
        String id = request.getId();
        DataResponse response = DataResponse.newBuilder()
            .setData("Data from Service B with ID: " + id)
            .build();
        // 返回响应数据
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

  4. 启动类：
    启动Spring Boot应用。

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ServiceBApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceBApplication.class, args);  // 启动应用
    }
}

优点和适用场景：

  • RESTful API：

    • 易于理解和使用。
    • 广泛支持各种客户端和工具。
    • 适合简单的请求/响应模式。

  • gRPC：

    • 高性能、低延迟。
    • 支持多种语言。
    • 适合需要高效通信的场景，尤其是需要双向流和复杂数据交换的场景。
懒人w
关注
  • 14
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
微服务之间相互调用的三种最常见方式（含源码）
m0_67391683的博客
07-30 1236
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。通过上面的方式我们解决了微服务之间的相互调用，但是存在硬编码的问题，如果服务提供者的地址发生变化，就需要手工修改代码；Feign是SpringCloud提供的一个声明式的伪Http客户端，它使得调用远程服务就像调用本地服务一样简单，只需要创建一个接口并添加一个注解即可。这个时候就会需要服务治理，服务治理是微服务架构最核心的问题，用于实现各个微服务的自动化注册与发现。3.在对应的微服务上添加。...
微服务之间最佳调用方式到底是什么？有没有上限？
2301_76437916的博客
02-09 179
这是一种具有颠覆性质的的设计，它把系统中所有的数据都以事件（Event）的方式记录下来，它的持久存储叫Event Store， 一般是建立在数据库或消息队列（例如Kafka）基础之上，并提供了对事件进行操作的接口，例如事件的读写和查询。直到十年之后，微服务出来之后，人们发现它其实内部就是微服务，而且微服务的设计需要用它的思想来指导，于是就又重新焕发了青春，而且这次更猛，已经到了每个谈论微服务的人都不得不谈论DDD的地步。有一点需要明确的是微服务的流行不是因为技术上的创新，而是为了满足管理上的需要。
微服务之间的调用
游手好闲
05-17 9070
服务注册与发现：Nacos 可以让服务实例将自己注册到 Nacos 中心，其他服务可以通过 Nacos 中心来发现这些服务实例。在微服务架构中，服务的数量很多，服务之间的依赖关系很复杂，因此需要一个集中化的服务注册与发现平台来管理这些服务。在调用微服务时，可以通过 Nacos 提供的服务注册与发现机制，从 Nacos 中心获取需要调用的微服务的地址信息，然后使用该地址信息进行调用。服务管理：Nacos 可以提供服务的健康检查、流量管理、服务降级、服务熔断等功能，帮助开发者更好地管理和监控服务。
【软件架构】微服务架构java多模块项目，微服务之间相互调用方法
weixin_46453070的博客
03-26 3122
在Java多模块项目中实现微服务架构时，微服务之间的相互调用通常可以通过以下几种方式实现：这些方式可以根据具体项目需求和技术选型来选择。在Java多模块项目中，可以将不同的微服务模块实现为独立的模块，每个模块负责实现一个特定的业务功能，通过以上方式来实现微服务之间的相互调用。下面是对上述六种调用方式的适用场景的简要总结：Feign：HTTP/RESTful API调用：RPC（远程过程调用）调用：消息队列：服务代理：事件驱动：根据具体的业务需求、性能要求、开发团队技术栈等因素，可以选择合适的调用方式来进行微
微服务之间的互相调用
窗外有风景，笔下有前途，低头是题海，抬头是未来
07-13 2752
微服务之间的互相调用
微服务之间互相调用出现的错误
qq_41536556的博客
01-04 531
微服务之间互相调用出现的错误
spring cloud eureka微服务之间的调用详解
08-27
微服务之间的调用是指微服务之间相互调用以实现业务逻辑的调用。 Spring Cloud Eureka 提供了多种方式来实现微服务之间的调用，包括： * 使用 RestTemplate 进行 HTTP 调用 * 使用 Feign 进行声明式调用 使用 ...
Spring Cloud多个微服务之间调用代码实例
08-25
Spring Cloud 多个微服务之间调用代码实例 Spring Cloud 是一个基于 Java 的微服务架构开发框架，它提供了许多优秀的功能来帮助开发者快速构建微服务架构。微服务之间的调用是 Spring Cloud 中一个非常重要的概念，...
微服务保护
2301_80339238的博客
09-03 1187
前面我们已经学习了远程调用、服务治理、请求路由、身份认证、配置管理这些与微服务密不可分的知识，但是既然我们拆分了许多服务的模块，那对于某些模块可能发生的问题，我们要做准备一些兜底的方案，又或者是做好健壮性的处理，这就是对于真个微服务的保护。另外之前单体项目时，无论业务多么复杂，操纵多少张表，最终都能够去满足事务的ACID的特性。但是拆分成很多服务以后，由于服务之间相互独立，各自操作数据库，这就破坏了ACID的特性，这就属于分布式事务的问题，我们下次再说，这次我们主要讲微服务保护。
什么是微服务
QQ1817117243的博客
09-03 470
微服务是一种现代软件架构风格，通过将应用程序拆分为小的、独立的服务，能够提高灵活性、可维护性和可扩展性。尽管微服务架构带来了许多优点，但也伴随着一定的复杂性和挑战，因此在设计和实施微服务架构时需要谨慎考虑。
如何通过Spring Cloud Consul增强微服务安全性和可靠性
2401_85639015的博客
09-02 1095
Spring Cloud Consul 是基于 HashiCorp Consul 的一套分布式系统解决方案，它主要提供了服务发现、配置管理、健康检查等功能。在微服务架构中，服务的动态注册与发现是确保服务互联互通的核心，而 Consul 正好提供了这一能力。同时，Consul 还集成了服务的健康检查功能，通过监控服务的状态来确保服务的高可用性。此外，Spring Cloud Consul 还通过其配置中心功能，提供了动态的配置管理和分布式系统的状态管理，这些都为微服务架构的健壮性提供了强有力的支持。
【脚手架 第一篇章】介绍一下若依微服务版框架
最新发布
Tsing
09-06 537
是基于和的分布式微服务架构平台，专为构建大型分布式系统提供完整的解决方案。它集成了众多微服务特性，如服务发现、配置管理、负载均衡等，适合需要高可扩展性和高可用性的企业级应用。
微服务CI/CD实践（六）Jenkins & Docker 自动化构建部署Java微服务
lbmydream的博客
09-06 794
pipeline {agent anystages {stage('获取代码') {steps {checkout([]]])stage('替换') {steps {stage('打包') {steps {steps {$(dockerpipeline {agent anystage('获取代码') {steps {
微服务日常总结
m0_59239420的博客
09-03 429
微服务日常总结
微服务--Nacos
weixin_51933701的博客
09-02 821
Nacos（Naming and Configuration Service）是阿里巴巴开源的一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它致力于帮助开发者快速实现动态服务发现、服务配置、服务元数据及流量管理。Nacos支持几乎所有主流类型的服务的发现、配置和管理，包括Kubernetes Service、gRPC & Dubbo RPC Service、Spring Cloud RESTful Service等。
微服务配置管理
2301_80339238的博客
09-03 1082
在前面我们已经学习了远程调用，Nacos注册中心，OpenFeign以及网关这些微服务组件。但是我们现在又会面临新的问题，就是微服务、注册中心、网关之中存在许多重复配置，维护成本比较高，另外就是业务配置经常变动，每次修改都要重启服务非常麻烦，网关路由配置写死，如果变更要重启网关。那么现在我们就可以用到配置管理服务。配置管理服务一方面读取配置，另一方面当配置发生改变时，它也可以去推送配置变更。
使用 Nacos 来管理微服务
懒人w的博客
09-06 442
Nacos 是阿里巴巴开源的一个易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它旨在帮助开发者更轻松地构建、部署微服务架构，并且支持动态配置服务、服务发现以及服务间的健康检查等功能。
LIN协议栈 AUTOSAR架构下 状态管理
汽车电子从业者，电子爱好者。
09-04 876
LIN State Manager 通过对这些状态的管理和转换，实现了对 LIN 总线通信状态的精确控制，以满足汽车电子系统中不同场景的需求。
springclou微服务之间的调用可以用kafka吗
05-09
是的，Spring Cloud 微服务之间的调用可以使用 Kafka。可以使用 Kafka 作为消息代理，微服务之间相互发送消息，从而实现服务之间的通信。 使用 Kafka 的好处是可以实现异步通信，提高系统的可用性和容错性。此外，Kafka 还支持分布式部署和高可用性，可以满足高并发和大规模的系统需求。 在 Spring Cloud 中，可以使用 Spring Cloud Stream 来与 Kafka 进行集成。Spring Cloud Stream 提供了一种简单的方式来定义和使用消息通道，使得在微服务之间进行消息传递更加容易。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

懒人w

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值