跳至主要內容

负载均衡：OpenFeign

添码座原创大约 4 分钟微服务Java微服务JavaSpring Cloud OpenFeign

OpenFeign能做什么

OpenFeign本来是Spring Cloud中用于服务间实现RPC（但实际上是HTTP）调用的组件，但因为扩展了Netflix Ribbon的功能，从而有了负载均衡的特性。

OpenFeign的服务调用和负载均衡
OpenFeign的服务调用和负载均衡

集成&开发

使用OpenFeign需要引入的依赖。

<!-- OpenFeign -->
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-openfeign</artifactId>
	<version>3.1.3</version>
	<exclusions>
		<exclusion>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-netflix-ribbon</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-loadbalancer</artifactId>
	<version>3.1.3</version>
</dependency>

有两个Maven子模块项目funcun-payment-center和funcun-order-center，它们都既是服务提供者，也是服务调用者。


Payment

PaymentFeignService

package com.funcun.order.center.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

/**
 * 调用funcun-order-center提供的服务
 *
 */
@FeignClient(name = "funcun-payment-center")
public interface PaymentFeignService {
    /**
     * GET参数方式
     *
     */
    @GetMapping("/ping1")
    public String ping1(@RequestParam("id") String id);

    /**
     * 路径参数方式
     *
     */
    @GetMapping("/ping2/{id}")
    public String ping2(@PathVariable("id") String id);

    /**
     * RequestMapping
     *
     */
    @RequestMapping("/ping3")
    public String ping3();

    @GetMapping("/ping4")
    public String ping4();

    @GetMapping("/ping5")
    public String ping5(@RequestParam("name") String name);

    /**
     * POST参数方式
     *
     */
    @PostMapping("/ping6")
    public String ping6(@RequestBody String username);
}

PaymentController

package com.funcun.payment.center.controller;

import com.funcun.payment.center.service.OrderFeignService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;

/**
 * 支付接口
 *
 */
@RestController
public class PaymentController {
    @Resource
    private OrderFeignService orderFeignService;

    /**
     * 在列表中给openfeign传参需要通过@RequestParam
     *
     */
    @GetMapping("/pong1")
    public String pong1(String id) {
        return "consumer-payment 通过 openfeign 调用 order-provider 的接口 /pong1，结果是：" + orderFeignService.pong1(id);
    }

    /**
     * 在路径中给openfeign传参需要通过@PathVariable
     *
     */
    @GetMapping("/pong2/{id}")
    public String pong2(@PathVariable("id")String id) {
        return "consumer-payment 通过 openfeign 调用 order-provider 的接口 /pong2/{id}，结果是：" + orderFeignService.pong2(id);
    }

    /**
     * 使用@RequestMapping默认就是GET方法
     *
     */
    @RequestMapping("/pong3")
    public String pong3() {
        return "consumer-payment 通过 openfeign 调用 order-provider 的接口 /pong3，结果是：" + orderFeignService.pong3();
    }

    /**
     * 明确指定使用@GetMapping
     *
     */
    @GetMapping("/pong4")
    public String pong4() {
        return "consumer-payment 通过 openfeign 调用 order-provider 的接口 /pong4，结果是：" + orderFeignService.pong4();
    }

    @GetMapping("/pong5")
    public String pong5(String name) {
        return "consumer-payment 通过 openfeign 调用 order-provider 的接口 /pong5，结果是：" + orderFeignService.pong5(name);
    }

    @PostMapping("/pong6")
    public String pong6(String username) {
        return "consumer-payment 通过 openfeign 调用 order-provider 的接口 /pong6，结果是：" + orderFeignService.pong6(username);
    }
}

然后在服务启动类中加入@EnableFeignClients注解。

package com.funcun.payment.center;

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

/**
 * 支付中心应用启动类
 *
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class PaymentCenterApplication {
    public static void main(String[] args) {
        SpringApplication.run(PaymentCenterApplication.class, args);
    }
}

Order

OrderFeignService

package com.funcun.payment.center.service;

import com.funcun.payment.center.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

/**
 * 调用funcun-payment-center提供的服务
 *
 */
@FeignClient(name = "funcun-order-center")
public interface OrderFeignService {
    /**
     * GET参数方式
     *
     */
    @GetMapping("/pong1")
    public String pong1(@RequestParam("id") String id);

    /**
     * 路径参数方式
     *
     */
    @GetMapping("/pong2/{id}")
    public String pong2(@PathVariable("id") String id);

    /**
     * RequestMapping
     *
     */
    @RequestMapping("/pong3")
    public String pong3();

    @GetMapping("/pong4")
    public String pong4();

    @GetMapping("/pong5")
    public String pong5(@RequestParam("name") String name);

    /**
     * POST参数方式
     *
     */
    @PostMapping("/pong6")
    public String pong6(@RequestBody String username);
}

OrderController

package com.funcun.order.center.controller;

import com.funcun.order.center.service.PaymentFeignService;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;

/**
 * 订单接口
 *
 */
@RestController
// 在控制器类加入@RefreshScope注解使当前类下的配置支持Nacos的动态刷新功能
@RefreshScope
public class OrderController {
    @Resource
    private PaymentFeignService paymentFeignService;

    @GetMapping("/ping1")
    public String ping1(String id) {
        return "consumer-order 通过 openfeign 调用 payment-provider 的接口 /ping1，结果是：" + paymentFeignService.ping1(id);
    }

    @GetMapping("/ping2/{id}")
    public String ping2(@PathVariable("id")String id) {
        return "consumer-order 通过 openfeign 调用 payment-provider 的接口 /ping2/{id}，结果是：" + paymentFeignService.ping2(id);
    }

    @RequestMapping("/ping3")
    public String ping3() {
        return "consumer-order 通过 openfeign 调用 payment-provider 的接口 /ping3，结果是：" + paymentFeignService.ping3();
    }

    @GetMapping("/ping4")
    public String ping4() {
        return "consumer-order 通过 openfeign 调用 payment-provider 的接口 /ping4，结果是：" + paymentFeignService.ping4();
    }

    @GetMapping("/ping5")
    public String ping5(String name) {
        return "consumer-order 通过 openfeign 调用 payment-provider 的接口 /ping5，结果是：" + paymentFeignService.ping5(name);
    }

    @PostMapping("/ping6")
    public String ping6(String username) {
        return "consumer-order 通过 openfeign 调用 payment-provider 的接口 /ping6，结果是：" + paymentFeignService.ping6(username);
    }
}

它也需要在服务启动类中加入@EnableFeignClients注解。

package com.funcun.order.center;

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

/**
 * 订单中心应用启动类
 *
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class OrderCenterApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderCenterApplication.class, args);
    }
}

之后就可以启动两个服务，通过接口实现互相调用了。

如果需要的话可以启动多个Payment或Order服务，看看负载均衡的效果，只需要稍微改造一下输出，能区分出是哪个子服务发出的调用就行。



感谢支持

更多内容，请移步《超级个体》。