【SpringCloud】（一文通）优雅实现远程调用-OpenFeign

2024-08-27 01:12
文章标签 java 实现 优雅 spring 调用 springcloud 远程 openfeign 一文

本文主要是介绍【SpringCloud】（一文通）优雅实现远程调用-OpenFeign，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目 录

  • 一. RestTemplate存在问题
  • 二. OpenFeign介绍
  • 三. 快速上手
    • 3.1 引入依赖
    • 3.2 添加注解
    • 3.3 编写 OpenFeign 的客户端
    • 3.4 远程调用
    • 3.5 测试
  • 四. OpenFeign 参数传递
    • 4.1 传递单个参数
    • 4.2 传递多个参数
    • 4.3 传递对象
    • 4.4 传递JSON
  • 五. 最佳实践
    • 5.1 Feign 继承方式
      • 5.1.1 创建⼀个Module
      • 5.1.2 引入依赖
      • 5.1.3 编写接口
      • 5.1.4 打Jar包
      • 5.1.5 服务提供方
      • 5.1.6 服务消费方
      • 5.1.7 测试
    • 5.2 Feign 抽取方式
      • 5.2.1 创建⼀个module
      • 5.2.2 引入依赖
      • 5.2.3 编写API
      • 5.2.4 打Jar包
      • 5.2.5 服务消费方使用 product-api
      • 5.2.6 测试
  • 六. 服务部署

一. RestTemplate存在问题

观察远程调用的代码

public OrderInfo selectOrderById(Integer orderId) {OrderInfo orderInfo = orderMapper.selectOrderById(orderId);String url = "http://product-service/product/"+ orderInfo.getProductId();ProductInfo productInfo = restTemplate.getForObject(url, ProductInfo.class);orderInfo.setProductInfo(productInfo);return orderInfo;
}

虽说 RestTemplate 对HTTP封装后, 已经比直接使用 HTTPClient 简单方便很多, 但是还存在⼀些问题.

  1. 需要拼接URL, 灵活性高, 但是封装臃肿, URL复杂时, 容易出错.
  2. 代码可读性差, 风格不统⼀.

微服务之间的通信方式, 通常有两种: RPC 和 HTTP.

在 SpringCloud 中, 默认是使用 HTTP 来进行微服务的通信, 最常用的实现形式有两种：

  • RestTemplate
  • OpenFeign

二. OpenFeign介绍

OpenFeign 是⼀个声明式的 Web Service 客户端. 它让微服务之间的调用变得更简单, 类似 controller 调用service, 只需要创建⼀个接口，然后添加注解即可使用 OpenFeign.

OpenFeign 的前身

Feign 是 Netflix 公司开源的⼀个组件.
• 2013年6月, Netflix 发布 Feign的第⼀个版本 1.0.0
• 2016年7月, Netflix 发布 Feign的最后⼀个版本 8.18.0
2016年，Netflix 将 Feign 捐献给社区
• 2016年7月 OpenFeign 的首个版本 9.0.0 发布，之后⼀直持续发布到现在

可以简单理解为 Netflix Feign 是OpenFeign 的祖先, 或者说 OpenFeign 是Netflix Feign 的升级版.OpenFeign 是 Feign 的⼀个更强大更灵活的实现

Spring Cloud Feign

Spring Cloud Feign 是 Spring 对 Feign 的封装, 将 Feign 项目集成到 Spring Cloud 生态系统中.

受 Feign 更名影响，Spring Cloud Feign 也有两个 starter

  • spring-cloud-starter-feign
  • spring-cloud-starter-openfeign

由于 Feign 的停更维护, 对应的, 我们使用的依赖是 spring-cloud-starter-openfeign

OpenFeign 官方文档：点击跳转
Spring Cloud Feign文档：点击跳转

三. 快速上手

3.1 引入依赖

<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

3.2 添加注解

在 order-service 的启动类添加注解 @EnableFeignClients , 开启 OpenFeign 的功能.

@EnableFeignClients
@SpringBootApplication
public class OrderServiceApplication {public static void main(String[] args) {SpringApplication.run(OrderServiceApplication.class, args);}
}

3.3 编写 OpenFeign 的客户端

基于 SpringMVC 的注解来声明远程调用的信息

import com.bite.order.model.ProductInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;@FeignClient(value = "product-service", path = "/product")
public interface ProductApi {@RequestMapping("/{productId}")ProductInfo getProductById(@PathVariable("productId") Integer productId);
}

@FeignClient 注解作用在接口上, 参数说明:

  • name/value：指定 FeignClient 的名称, 也就是微服务的名称, 用于服务发现, Feign 底层会使用
    Spring Cloud LoadBalance 进行负载均衡. 也可以使用 url 属性指定⼀个具体的 url.

  • path: 定义当前FeignClient的统⼀前缀.

3.4 远程调用

修改远程调用的方法

@Autowired
private ProductApi productApi;
/**
* Feign实现远程调⽤
* @param orderId
*/
public OrderInfo selectOrderById(Integer orderId) {OrderInfo orderInfo = orderMapper.selectOrderById(orderId);ProductInfo productInfo = productApi.getProductById(orderInfo.getProductId());orderInfo.setProductInfo(productInfo);return orderInfo;
}

代码对比:

在这里插入图片描述

3.5 测试

启动服务, 访问接口, 测试远程调用: http://127.0.0.1:8080/order/1

在这里插入图片描述

可以看出来, 使用 Feign 也可以实现远程调用.

Feign 简化了与 HTTP 服务交互的过程, 把 REST 客户端的定义转换为Java接口, 并通过注解的方式来声明请求参数,请求方式等信息, 使远程调用更加方便和间接.

四. OpenFeign 参数传递

通过观察, 我们也可以发现, Feign 的客户端和服务提供者的接口声明非常相似
上面例子中, 演示了 Feign 从 URL 中获取参数, 接下来演示下 Feign 参数传递的其他方式

4.1 传递单个参数

服务提供方 product-service

@RequestMapping("/product")
@RestController
public class ProductController {@RequestMapping("/p1")public String p1(Integer id){return "p1接收到参数:"+id;}
}

Feign 客户端

@FeignClient(value = "product-service", path = "/product")
public interface ProductApi {@RequestMapping("/p1")String p1(@RequestParam("id") Integer id);
}

注意: @RequestParam 做参数绑定, 不能省略

服务消费方 order-service

@RequestMapping("/feign")
@RestController
public class TestFeignController {@Autowiredprivate ProductApi productApi;@RequestMapping("/o1")public String o1(Integer id){return productApi.p1(id);}
}

测试远程调用：http://127.0.0.1:8080/feign/o1?id=5

在这里插入图片描述

4.2 传递多个参数

使用多个 @RequestParam 进行参数绑定即可

服务提供方 product-service

@RequestMapping("/p2")
public String p2(Integer id,String name){return "p2接收到参数,id:"+id +",name:"+name;
}

Feign 客户端

@RequestMapping("/p2")
String p2(@RequestParam("id")Integer id,@RequestParam("name")String name);

服务消费方 order-service

@RequestMapping("/o2")
public String o2(@RequestParam("id")Integerid,@RequestParam("name")String name){return productApi.p2(id,name);
}

测试远程调用：http://127.0.0.1:8080/feign/o2?id=5&name=zhangsan

在这里插入图片描述

4.3 传递对象

服务提供方 product-service

@RequestMapping("/p3")
public String p3(ProductInfo productInfo){return "接收到对象, productInfo:"+productInfo;
}

Feign 客户端

@RequestMapping("/p3")
String p3(@SpringQueryMap ProductInfo productInfo);

服务消费方 order-service

@RequestMapping("/o3")
public String o3(ProductInfo productInfo){return productApi.p3(productInfo);
}

测试远程调用：http://127.0.0.1:8080/feign/o3?id=5&productName=zhangsan

在这里插入图片描述

4.4 传递JSON

服务提供方 product-service

@RequestMapping("/p4")
public String p4(@RequestBody ProductInfo productInfo){return "接收到对象, productInfo:"+productInfo;
}

Feign 客户端

@RequestMapping("/p4")
String p4(@RequestBody ProductInfo productInfo);

服务消费方 order-service

@RequestMapping("/o4")
public String o4(@RequestBody ProductInfo productInfo){System.out.println(productInfo.toString());return productApi.p4(productInfo);
}

测试远程调用：http://127.0.0.1:8080/feign/o4

在这里插入图片描述

五. 最佳实践

最佳实践, 其实也就是经过历史的迭代, 在项目中的实践过程中, 总结出来的最好的使用方式.

通过观察, 我们也能看出来, Feign 的客户端与服务提供者的 controller 代码非常相似

Feign 客户端

@FeignClient(value = "product-service", path = "/product")
public interface ProductApi {@RequestMapping("/{productId}")ProductInfo getProductById(@PathVariable("productId") Integer productId);
}

服务提供方 Controller

@RequestMapping("/product")
@RestController
public class ProductController {@RequestMapping("/{productId}")public ProductInfo getProductById(@PathVariable("productId") Integer productId){//...}
}

有没有⼀种方法可以简化这种写法呢?

5.1 Feign 继承方式

Feign 支持继承的方式, 我们可以把⼀些常见的操作封装到接口里.

我们可以定义好⼀个接口, 服务提供方实现这个接口, 服务消费方编写Feign 接口的时候, 直接继承这个接口

具体参考: Spring Cloud OpenFeign Features :: Spring Cloud Openfeign

5.1.1 创建⼀个Module

接口可以放在⼀个公共的 Jar 包里, 供服务提供方和服务消费方使用

在这里插入图片描述

5.1.2 引入依赖

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId></dependency>
</dependencies>

5.1.3 编写接口

复制 ProductApi, ProductInfo 到 product-api 模块中

import com.bite.model.ProductInfo;
import org.springframework.cloud.openfeign.SpringQueryMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;public interface ProductInterface {@RequestMapping("/{productId}")ProductInfo getProductById(@PathVariable("productId") Integer productId);@RequestMapping("/p1")String p1(@RequestParam("id") Integer id);@RequestMapping("/p2")String p2(@RequestParam("id")Integer id,@RequestParam("name")String name);@RequestMapping("/p3")String p3(@SpringQueryMap ProductInfo productInfo);@RequestMapping("/p4")String p4(@RequestBody ProductInfo productInfo);
}

目录结构如下：

在这里插入图片描述

5.1.4 打Jar包

通过 Maven 打包

在这里插入图片描述

观察 Maven 本地仓库, Jar 包是否打成功

[INFO] Installing D:\Git\spring-cloud\spring-cloud-feign2\productapi\target\product-api-1.0-SNAPSHOT.jar to 
D:\Maven\.m2\repository\org\example\product-api\1.0-SNAPSHOT\product-api-1.0-
SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.796 s
[INFO] Finished at: 2024-01-03T19:31:35+08:00
[INFO] ------------------------------------------------------------------------

在这里插入图片描述

5.1.5 服务提供方

服务提供方实现接口 ProductInterface

@RequestMapping("/product")
@RestController
public class ProductController implements ProductInterface {@Autowiredprivate ProductService productService;@RequestMapping("/{productId}")public ProductInfo getProductById(@PathVariable("productId") Integer productId){System.out.println("收到请求,Id:"+productId);return productService.selectProductById(productId);}@RequestMapping("/p1")public String p1(Integer id){return "p1接收到参数:"+id;}@RequestMapping("/p2")public String p2(Integer id,String name){return "p2接收到参数,id:"+id +",name:"+name;}@RequestMapping("/p3")public String p3(ProductInfo productInfo){return "接收到对象, productInfo:"+productInfo;}@RequestMapping("/p4")public String p4(@RequestBody ProductInfo productInfo){return "接收到对象, productInfo:"+productInfo;}}

5.1.6 服务消费方

服务消费方继承 ProductInterface

import com.bite.api.ProductInterface;
import org.springframework.cloud.openfeign.FeignClient;@FeignClient(value = "product-service", path = "/product")
public interface ProductApi extends ProductInterface {//...
}

5.1.7 测试

试远程调用：http://127.0.0.1:8080/order/1

在这里插入图片描述

5.2 Feign 抽取方式

官方推荐 Feign 的使用方式为继承的方式, 但是企业开发中, 更多是把Feign接口抽取为⼀个独立的模块(做法和继承相似, 但理念不同).

操作⽅法:

将 Feign 的 Client 抽取为⼀个独立的模块, 并把涉及到的实体类等都放在这个模块中, 打成⼀个Jar. 服务消费⽅只需要依赖该Jar包即可. 这种方式在企业中比较常见, Jar 包通常由服务提供方来实现

5.2.1 创建⼀个module

在这里插入图片描述

5.2.2 引入依赖

<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

5.2.3 编写API

复制 ProductApi, ProductInfo 到 product-api 模块中

在这里插入图片描述

5.2.4 打Jar包

通过Maven打包

在这里插入图片描述

观察 Maven 本地仓库, Jar 包是否打成功

[INFO] Installing D:\Git\spring-cloud\spring-cloud-feign\productapi\target\product-api-1.0-SNAPSHOT.jar to 
D:\Maven\.m2\repository\org\example\product-api\1.0-SNAPSHOT\product-api-1.0-
SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.441 s
[INFO] Finished at: 2024-01-03T17:55:14+08:00
[INFO] ------------------------------------------------------------------------

在这里插入图片描述

5.2.5 服务消费方使用 product-api

  1. 删除 ProductApi, ProductInfo

  2. 引入依赖

<dependency><groupId>org.example</groupId><artifactId>product-api</artifactId><version>1.0-SNAPSHOT</version>
</dependency>

修改项目中 ProductApi, ProductInfo 的路径为 product-api 中的路径

  1. 指定扫描类: ProductApi

在启动类添加扫描路径

@EnableFeignClients(basePackages = {"com.bite.api"})

完整代码如下:

@EnableFeignClients(basePackages = {"com.bite.api"})
@SpringBootApplication
public class OrderServiceApplication {public static void main(String[] args) {SpringApplication.run(OrderServiceApplication.class, args);}
}

也可以指定需要加载的 Feign 客户端

@EnableFeignClients(clients = {ProductApi.class})

5.2.6 测试

测试远程调用：http://127.0.0.1:8080/order/1

在这里插入图片描述

六. 服务部署

  1. 修改数据库, Nacos等相关配置

  2. 对两个服务进行打包

Maven打包默认是从远程仓库下载的, product-api 这个包在本地, 有以下解决方案:

  • 上传到 Maven 中央仓库(参考: 如何发布 Jar 包到 Maven 中央仓库, 比较麻烦)[不推荐]
  • 搭建 Maven 私服, 上传 Jar 包到私服[企业推荐]
  • 从本地读取 Jar 包[个人学习阶段推荐]

前两种方法比较复杂, 咱们使用第三种方式

修改 pom 文件

<dependency><groupId>org.example</groupId><artifactId>product-api</artifactId><version>1.0-SNAPSHOT</version><!-- scope 为system. 此时必须提供systemPath即本地依赖路径. 表⽰maven不会去中央仓库查找依赖 不推荐使⽤--><scope>system</scope><systemPath>D:/Maven/.m2/repository/org/example/product-api/1.0-SNAPSHOT/product-api-1.0-SNAPSHOT.jar</systemPath>
</dependency>//....
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><includeSystemScope>true</includeSystemScope></configuration></plugin></plugins>
</build>

把D:/Maven/.m2/repository 改为本地仓库的路径

  1. 上传 jar 到Linux服务器
  2. 启动 Nacos

启动前最好把 data 数据删除掉.

  1. 启动服务
#后台启动order-service, 并设置输出⽇志到logs/order.log
nohup java -jar order-service.jar >logs/order.log &#后台启动product-service, 并设置输出⽇志到logs/order.log
nohup java -jar product-service.jar >logs/product-9090.log &#启动实例, 指定端⼝号为9091
nohup java -jar product-service.jar --server.port=9091 >logs/product-9091.log &

观察 Nacos 控制台

在这里插入图片描述

  1. 测试

访问接口: http://110.41.51.65:8080/order/1

观察远程调用的结果:

在这里插入图片描述

这篇关于【SpringCloud】（一文通）优雅实现远程调用-OpenFeign的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1110213。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

利用康拓展开将一个排列映射成一个自然数，然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2