Spring Cloud 微服务远程调用：OpenFeign 实战

2. 开启功能

在启动类上添加 @EnableFeignClients 注解，开启 OpenFeign 功能。

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

3. 编写 Feign 客户端

基于 Spring MVC 注解来声明远程调用的信息。这里我们定义一个 ProductApi 接口：

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

注解说明：

• value/name：指定 FeignClient 的名称，即微服务名称，用于服务发现。Feign 底层会使用 Spring Cloud LoadBalancer 进行负载均衡。也可以直接用 url 属性指定具体地址。
• path：定义当前 FeignClient 的统一前缀。

4. 执行远程调用

修改业务代码，注入刚才定义的接口即可：

@Autowired
private ProductApi productApi;

/**
 * Feign 实现远程调用
 * @param orderId
 */
public OrderInfo selectOrderById(Integer orderId) {
    OrderInfo orderInfo = orderMapper.selectOrderById(orderId);
    // 直接调用接口方法，无需关心 URL 拼接
    ProductInfo productInfo = productApi.getProductById(orderInfo.getProductId());
    orderInfo.setProductInfo(productInfo);
    return orderInfo;
}

对比 RestTemplate，代码量明显减少，逻辑也更清晰。

OpenFeign 参数传递

Feign 客户端和服务提供者的接口声明非常相似。除了路径变量，还支持多种参数传递方式。

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);
}

服务消费方 (order-service)

@RequestMapping("/feign")
@RestController
public class TestFeignController {
    @Autowired
    private ProductApi productApi;

    @RequestMapping("/o1")
    public String o1(Integer id) {
        return productApi.p1(id);
    }
}

测试访问：http://127.0.0.1:8080/feign/o1?id=5

2. 多个参数

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

服务提供方

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

Feign 客户端

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

服务消费方

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

3. 传递对象

当需要传递复杂对象时，可以使用 @SpringQueryMap 将对象属性映射为查询参数。

服务提供方

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

Feign 客户端

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

4. 传递 JSON

如果需要以 JSON 格式传输对象，使用 @RequestBody。

服务提供方

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

Feign 客户端

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

服务消费方

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

最佳实践

在实际项目中，Feign 客户端与服务提供者的 Controller 代码往往高度相似。有没有办法简化这种重复？

1. Feign 继承方式

Feign 支持继承，我们可以把一些常用操作封装到公共接口里。服务提供方实现该接口，服务消费方编写 Feign 接口时直接继承。

创建公共 Module

接口可以放在一个公共的 Jar 包里，供双方使用。

引入依赖

<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>

编写接口

将通用的 API 定义提取出来，例如 ProductInterface：

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);
}

服务提供方实现

@RequestMapping("/product")
@RestController
public class ProductController implements ProductInterface {
    @Autowired
    private ProductService productService;

    @Override
    @RequestMapping("/{productId}")
    public ProductInfo getProductById(@PathVariable("productId") Integer productId) {
        System.out.println("收到请求，Id:" + productId);
        return productService.selectProductById(productId);
    }

    // ... 其他方法实现
}

服务消费方继承

@FeignClient(value = "product-service", path = "/product")
public interface ProductApi extends ProductInterface {}

通过继承，既保证了接口规范一致，又减少了重复代码。

2. Feign 抽取方式

企业开发中，更推荐将 Feign 接口抽取为独立的模块（类似继承，但理念不同）。将 Client 抽取为独立模块，涉及到的实体类也放入其中，打成 Jar 包。服务消费方只需依赖该 Jar 包。

操作步骤

1. 创建新 Module：新建一个名为 product-api 的模块。
2. 引入依赖：仅引入 OpenFeign 相关依赖。
3. 编写 API：复制 ProductApi 和 ProductInfo 到该模块中，打包发布到本地仓库。
4. 服务消费方使用：
   • 删除本地的 ProductApi 和 ProductInfo。
   • 引入依赖：

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

   • 修改扫描路径，在启动类指定：

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

   • 或者指定具体加载的客户端：

     @EnableFeignClients(clients = {ProductApi.class})
     

总结

OpenFeign 通过声明式接口大大简化了微服务间的远程调用，相比 RestTemplate 更加优雅且易于维护。掌握其参数传递机制及接口抽取的最佳实践，能让你的微服务架构更加健壮。在实际开发中，根据团队规范选择合适的接口复用方式，能有效提升开发效率。