openfeign实现服务间的调用

最新推荐文章于 2024-05-20 20:22:32 发布
最新推荐文章于 2024-05-20 20:22:32 发布
阅读量610 收藏 1
点赞数 1
分类专栏： 项目实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuerchong/article/details/119052304
版权

openfeign实现前台服务调用文章服务实现查看文章列表及读取文章功能

源码地址
https://gitee.com/liuerchong/news-artical

首先搭建文章服务

用https://blog.csdn.net/liuerchong/article/details/119035213文章中的代码生成器生成代码，复制到article文章服务路径下，源码如下：
代码格式自行格式化
pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>news-artical</artifactId>
        <groupId>com.liu.news</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ap-article</artifactId>

    <dependencies>

        <dependency>
            <groupId>com.liu.news</groupId>
            <artifactId>artical-common-db</artifactId>
        </dependency>
        <dependency>
            <groupId>com.liu.news</groupId>
            <artifactId>artical-common-public</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-loadbalancer -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>

    </dependencies>

</project>

controller

package com.liu.news.artical.controller.article;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.liu.news.artical.entity.article.ApArticle;
import com.liu.news.artical.services.article.service.IApArticleService;
import com.liu.news.common.result.R;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * @Package: com.liu.news.artical.entity.article.ApArticle
 * @Description: <文章信息表，存储已发布的文章前端控制器>
 * @Author: Liuerchong
 * @CreateDate: 2021-07-23
 * @UpdateUser: Liuerchong
 * @UpdateDate: 2021-07-23
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@RestController
@Api(tags = "ApArticle-相关接口")
@RequestMapping(value = "ApArticle")
public class ApArticleController {

private static final Logger logger = LoggerFactory.getLogger(ApArticleController.class);

@Autowired
private IApArticleService iApArticleService;

@GetMapping("{id}")
@ApiOperation(value = "文章信息表，存储已发布的文章获取某一实体")
public R getIApArticleServiceDetails(@PathVariable Integer id) {
        return R.ok(iApArticleService.getById(id));
        }


/**
  * 列表查询（非分页）
  *
  * @return
  */
@RequestMapping("/list")
@SentinelResource(value = "articleList")
public R list() {
    ApArticle model = new  ApArticle();
        List<ApArticle> list =  iApArticleService.list();
        // todo 再包装一层
        return  R.ok(list);
        }


/**
* 列表查询（分页）
*
* @return
*/
    @RequestMapping("/pageList")
    public Object pageList(Integer pageNum, Integer pageSize) {

        ApArticle model = new  ApArticle();
        IPage<ApArticle> page = iApArticleService.pageList(model,pageNum,pageSize);
        // todo 再包装一层
            return R.ok(page);
    }

@PostMapping
@ApiOperation(value = "文章信息表，存储已发布的文章新增数据")
public R saveIApArticleService(@RequestBody ApArticle dto) {
        return R.ok(iApArticleService.save(dto));
        }

@PutMapping("{id}")
@ApiOperation(value = "文章信息表，存储已发布的文章修改数据")
public R modifyIApArticleService(@RequestBody ApArticle dto, @PathVariable Integer id) {
        dto.setId(id);
        return R.ok(iApArticleService.updateById(dto)) ;
        }

@DeleteMapping("batch")
@ApiOperation(value = "文章信息表，存储已发布的文章批量删除数据")
public R batchRemoveIApArticleService(@RequestParam(value = "ids") List<Integer> ids) {
        return R.ok(iApArticleService.removeByIds(ids)) ;
        }

@DeleteMapping("{id}")
@ApiOperation(value = "文章信息表，存储已发布的文章删除数据")
public R removeIApArticleService(@PathVariable Integer id) {
        return R.ok(iApArticleService.removeById(id)) ;
        }
        }

service

package com.liu.news.artical.services.article.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.liu.news.artical.entity.article.ApArticle;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;

/**
 * @Package: com.liu.news.artical.services.article.service
 * @Description: <文章信息表，存储已发布的文章服务类>
 * @Author: Liuerchong
 * @CreateDate: 2021-07-23
 * @UpdateUser: Liuerchong
 * @UpdateDate: 2021-07-23
 * @UpdateRemark: <>
 * @Version: 1.0
 */
public interface IApArticleService extends IService<ApArticle> {

        /**
       * 查询
       *
       * @param model
       * @return
       */
        List<ApArticle> list(ApArticle model);

        /**
        * 分页查询
        *
        * @param model
        * @param pageNum  第几页
        * @param pageSize 每页数量
        * @return
        */
        IPage<ApArticle> pageList(ApArticle model, Integer pageNum, Integer pageSize);

        }

package com.liu.news.artical.services.article.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.liu.news.artical.entity.article.ApArticle;
import com.liu.news.artical.mapper.article.ApArticleMapper;
import com.liu.news.artical.services.article.service.IApArticleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

import java.util.List;

/**

  • @Package: com.liu.news.artical.services.article.service.impl

  • @Description: <文章信息表，存储已发布的文章服务实现类>

  • @Author: Liuerchong

  • @CreateDate: 2021-07-23

  • @UpdateUser: Liuerchong

  • @UpdateDate: 2021-07-23

  • @UpdateRemark: <>

  • @Version: 1.0
    */
    @Service
    public class ApArticleServiceImpl extends ServiceImpl<ApArticleMapper, ApArticle> implements IApArticleService {

         @Override
     public List< ApArticle> list(ApArticle model) {
     QueryWrapper< ApArticle> wrapper = new QueryWrapper();
     return super.list(wrapper);
     }

     @Override
     public IPage< ApArticle> pageList(ApArticle model, Integer pageNum, Integer pageSize) {

     QueryWrapper< ApArticle> wrapper = new QueryWrapper(model);
     return this.page(new Page<>(pageNum, pageSize), wrapper);
     }
 }

mapper

package com.liu.news.artical.mapper.article;

import com.liu.news.artical.entity.article.ApArticle;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
 * @Package: com.liu.news.artical.mapper.article
 * @Description: <文章信息表，存储已发布的文章Mapper接口>
 * @Author: Liuerchong
 * @CreateDate: 2021-07-23
 * @UpdateUser: Liuerchong
 * @UpdateDate: 2021-07-23
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Mapper
public interface ApArticleMapper extends BaseMapper<ApArticle> {

}

实体层

package com.liu.news.artical.entity.article;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;

import java.time.LocalDateTime;

import com.baomidou.mybatisplus.annotation.TableField;

import java.io.Serializable;

import lombok.Data;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Package: com.liu.news.artical.entity.article
 * @Description: <文章信息表，存储已发布的文章实体>
 * @Author: Liuerchong
 * @CreateDate: 2021-07-23
 * @UpdateUser: Liuerchong
 * @UpdateDate: 2021-07-23
 * @UpdateRemark: <>
 * @Version: 1.0
 */
@Data
@ApiModel(value = "ApArticle实体")
public class ApArticle implements Serializable {
    /**
     * 序列化时候使用
     */
    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "", notes = "")
    private Integer id;

    @ApiModelProperty(value = "标题", notes = "")
    private String title;

    @ApiModelProperty(value = "文章作者的ID", notes = "")
    private Integer authorId;

    @ApiModelProperty(value = "作者昵称", notes = "")
    private String authorName;

    @ApiModelProperty(value = "文章所属频道ID", notes = "")
    private Integer channelId;

    @ApiModelProperty(value = "频道名称", notes = "")
    private String channelName;

    @ApiModelProperty(value = "文章布局", notes = "0 无图文章     1 单图文章            2 多图文章")
    private Integer layout;

    @ApiModelProperty(value = "文章标记",
            notes = "0 普通文章   1 热点文章    2 置顶文章    3 精品文章      4 大V 文章")
    private Integer flag;

    @ApiModelProperty(value = "文章图片", notes = "多张逗号分隔")
    private String images;

    @ApiModelProperty(value = "文章标签最多3个", notes = "逗号分隔")
    private String labels;

    @ApiModelProperty(value = "点赞数量", notes = "")
    private Integer likes;

    @ApiModelProperty(value = "收藏数量", notes = "")
    private Integer collection;

    @ApiModelProperty(value = "评论数量", notes = "")
    private Integer comment;

    @ApiModelProperty(value = "阅读数量", notes = "")
    private Integer views;

    @ApiModelProperty(value = "省市", notes = "")
    private Integer provinceId;

    @ApiModelProperty(value = "市区", notes = "")
    private Integer cityId;

    @ApiModelProperty(value = "区县", notes = "")
    private Integer countyId;

    @ApiModelProperty(value = "创建时间", notes = "")
    private LocalDateTime createdTime;

    @ApiModelProperty(value = "发布时间", notes = "")
    private LocalDateTime publishTime;

    @ApiModelProperty(value = "同步状态", notes = "")
    private Boolean syncStatus;

    @ApiModelProperty(value = "来源", notes = "")
    private Integer origin;

}

启动类

package com.liu.news.artical;

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

/**
 * @author lx
 * @version 1.0
 * @description: TODO
 * @date 2021/7/23 13:33
 */
@SpringBootApplication
@EnableDiscoveryClient
public class ApArticleApplication {

    public static void main(String[] args) throws InterruptedException{

        SpringApplication.run(ApArticleApplication.class, args);

    }
}

配置文件

server:
  port: 9070
spring:
  profiles:
    active: dev
  application:
    name: ap-artical
  main:
    allow-bean-definition-overriding: true
  cloud:
    nacos:
      discovery:
        username: nacos
        password: nacos
        server-addr: 172.17.169.81:8848
        namespace: b561281a-fb95-411e-b75b-cf36bfc90854
        group: ATICAL_CLNEWS_DEV_GROUP
      config:
        server-addr: ${spring.cloud.nacos.discovery.server-addr}
        file-extension: yml
        namespace: ${spring.cloud.nacos.discovery.namespace}
        group: ${spring.cloud.nacos.discovery.group}
        shared-configs[0]:
          data-id: user-prompt-info.yml # 配置文件名-Data Id
          group: ${spring.cloud.nacos.discovery.group}   # 默认为DEFAULT_GROUP
          refresh: true   # 是否动态刷新，默认为false
    sentinel:
      transport:
        port: 8719 # spring.cloud.sentinel.transport.port 端口配置会在应用对应的机器上启动一个 Http Server，该 Server 会与 Sentinel 控制台做交互。比如 Sentinel 控制台添加了1个限流规则，会把规则数据 push 给这个 Http Server 接收，Http Server 再将规则注册到 Sentinel 中
        dashboard: 127.0.0.1:5003
      eager: true

spring:

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver #数据库驱动包
    url: jdbc:mysql://localhost:3307/artical?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true
    username: root
    password: root
mybatis-plus:
  global-config:
    db-config:
      field-strategy: not_empty
      #驼峰下划线转换
      column-underline: true
      #逻辑删除配置
      logic-delete-value: 0
      logic-not-delete-value: 1
      db-type: mysql
    refresh: false
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false

启动服务，进行访问
在这里插入图片描述

搭建前台服务

新建模块 article-reception
pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>news-artical</artifactId>
        <groupId>com.liu.news</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>article-reception</artifactId>

    <dependencies>

        <dependency>
            <groupId>com.liu.news</groupId>
            <artifactId>artical-common-utils</artifactId>
        </dependency>
        <dependency>
            <groupId>com.liu.news</groupId>
            <artifactId>artical-common-public</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-loadbalancer -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
    </dependencies>

</project>

配置文件
bootstrap.yml

server:
  port: 8060
spring:
  profiles:
    active: dev
  application:
    name: article-reception
  main:
    allow-bean-definition-overriding: true
  cloud:
    nacos:
      discovery:
        username: nacos
        password: nacos
        server-addr: 172.17.169.81:8848
        namespace: b561281a-fb95-411e-b75b-cf36bfc90854
        group: ATICAL_CLNEWS_DEV_GROUP
      config:
        server-addr: ${spring.cloud.nacos.discovery.server-addr}
        file-extension: yml
        namespace: ${spring.cloud.nacos.discovery.namespace}
        group: ${spring.cloud.nacos.discovery.group}

application.yml

feign:
  lient:
    config:
      default:
        connectTimeout: 50000
  client:
    config:
      default:
        readTimeout: 190000

  okhttp:
    enabled: true
  httpclient:
    enabled: false
    max-connections: 1000
    max-connections-per-route: 100
    connection-timeout: 190000
    connection-timer-repeat: 190000

server:
  undertow:
    max-http-post-size: 0
    # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程,数量和CPU 内核数目一样即可
    io-threads: 4
    # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载  io-threads*8
    worker-threads: 32
    # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
    # 每块buffer的空间大小,越小的空间被利用越充分
    buffer-size: 1024
    # 每个区分配的buffer数量 , 所以pool的大小是buffer-size * buffers-per-region
    #   buffers-per-region: 1024 # 这个参数不需要写了
    # 是否分配的直接内存
    direct-buffers: true

management:
  endpoints:
    web:
      exposure:
        include: "*"

启动类

package com.liu.news.article.reception;

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

/**
 * @author lx
 * @version 1.0
 * @description: TODO
 * @date 2021/7/19 14:34
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ArticleReceptionApplication {

    public static void main(String[] args) {

        SpringApplication.run(ArticleReceptionApplication.class, args);
    }


}

controller

package com.liu.news.article.reception.controller;

import com.liu.news.article.reception.service.ArticleReceptionFeignService;
import com.liu.news.result.R;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author lx
 * @version 1.0
 * @description: TODO
 * @date 2021/7/27 9:33
 */
@RestController
public class ArticleReceptionController {


    @Resource
    private ArticleReceptionFeignService articleReceptionFeignService;

    @GetMapping(value = "/articleReception/articleList", produces = MediaType.APPLICATION_JSON_VALUE)
    public String getPaymentById(){

        return articleReceptionFeignService.list();
    }

}


package com.liu.news.article.reception.service;

import com.liu.news.result.R;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;

@Component
@FeignClient(name = "ap-artical"  )
public interface ArticleReceptionFeignService {

   @GetMapping(value = "/ApArticle/list")
    public String  list();
}

启动服务

在这里插入图片描述

liu1002880404
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用 OpenFeign 实现跨服务的调用
weixin_40364776的博客
01-15 3823
OpenFeign 实战笔记整理
使用OpenFeign实现微服务间的接口调用
原名：@程序员大禹
03-08 2997
一、微服务架构如下： 模块名 用途 实例名 springCloud_nacos 服务注册中心 springcloud-nacos springCloud_serviceA 微服务模块A springcloud-serviceA springCloud_serviceB 微服务模块B springcloud-serviceB 二、openFeign实现微服务间接口调用（serviceA 调用 serviceB 接口） 1、在父pom.xml中
OpenFeign微服务调用组件使用
最新发布
w2144217940的博客
05-20 575
Feign是Netflix开发的声明式、模版化的HTTP客户端。Feign可以做到使用 HTTP 请求远程服务时就像调用本地方法一样的体验，开发者完全感知不到这是远程方法，更感知不到这是个 HTTP 请求，开发者无需关注与远程的交互细节，更无需关注分布式环境开发。
简单使用openfeign实现服务间的调用
taolin0的博客
01-09 1294
简单使用openfeign实现服务间的调用
SpringCloud系列（五）| 集成OpenFeign实现服务间调用
lsqingfeng的博客
12-14 497
在SpringCloud体系中，集成OpenFeign实现各个服务之间的相互调用。
服务间调用方式 OpenFeign 的介绍和使用
yy139926的博客
02-17 1391
Feign 停更了，OpenFeign 是在 Feign 基础上开发出来的。
Springcloud基于OpenFeign实现服务调用代码实例
08-24
我们需要定义一个接口来调用服务，这个接口需要使用@FeignClient 注解： ```java @FeignClient("productservices") public interface ProductClient { @RequestMapping("/product/findAll") public Map findAll()...
SpringCloud-OpenFeign服务接口调用及代码
06-01
1. 调用服务：在需要调用远程服务的地方，注入刚刚定义的Feign客户端接口，然后直接调用其方法即可，就像调用本地方法一样。 ```java @Service public class ServiceConsumer { @Autowired private ...
6.OpenFeign服务消费者
01-01
OpenFeign是Spring Cloud生态中的一个关键组件，它作为一个声明式的Web服务客户端，极大地简化了服务之间的调用。...在实际开发中，使用OpenFeign可以提高代码的可读性和可维护性，降低了服务间通信的复杂度。
SpringCloud实现服务间通信
01-22
- orderserver可能是一个订单服务，它需要调用goodsserver的商品服务来获取商品信息，可以使用RestTemplate或OpenFeign实现这一通信。 总的来说，选择RestTemplate还是OpenFeign主要取决于需求。如果希望代码简洁，...
Spring Cloud OpenFeign 远程调用
11-25
Spring Cloud OpenFeign 可以做到 让我们在使用 HTTP 请求远程服务时，就像调用本地方法一样。OpenFeign 和 Dubbo一样是一个RPC远程调用框架，目的是使的我们调用接口和调用本地方法一样简单，开发者无需关心和远程...
spring boot整合openfeign实现两个微服务之间的调用。
2301_78646673的博客
11-22 1305
（在FeignCLient接口中要注意路径的问题，因为）@FeignClient接口不允许使用@RequestMapper注解，而我们在controller接口中，一般会默认使用@RequestMapper注解，来指定操作的数据表，所以在FeignCLient接口中，要注意将路径补充完整。在这个接口上方添加@feignClient注解，表示这个接口是一个OpenFeign用户端接口，并在这个注解中写上你要调用的服务模块的微服务名称（这个名称要与注册到nacos中的微服务名称保持一致）。
SpringCloud微服务（八）——OpenFeign服务调用
qq_43409401的博客
11-23 3333
Feign是一个声明式的Web Service客户端。它的出现使开发Web Service客户端变得很简单。
spring-cloud 使用openfeign实现微服务之间的调用——注意事项
weixin_63497297的博客
09-20 161
spring-cloud 使用openfeign实现微服务之间的调用——注意事项
（Java企业 / 公司项目）微服务OpenFeign怎么实现服务间调用？（含面试题）
全栈技术分享，项目分享，资料分享
12-26 1494
Feign: 远程调用组件使用步骤，理解上面的图 后台系统中, 微服务和微服务之间的调用可以通过Feign组件来完成. Feign组件集成了Ribbon负载均衡策略(默认开启的, 使用轮询机制),Hystrix熔断器 (默认关闭的, 需要通过配置文件进行设置开启) 被调用的微服务需要提供一个接口, 加上@FeignClient("url")注解 调用方需要在启动类上加上@EnableFeignClients, 开启Feign组件功能。
微服务：OpenFeign的服务调用
Java技术攻略的博客
03-23 1035
OpenFeign 全称 Spring Cloud OpenFeign，它是 Spring 官方推出的一种声明式服务调用与负载均衡组件，它的出现就是为了替代进入停更维护状态的 Feign。Spring Cloud openfeign对Feign进行了增强，使其支持Spring MVC注解，另外还整合了Ribbon和Nacos，从而使得Feign的使用更加方便。Feign使用http远程调用方法就好像调用本地的方法，感觉不到是远程方法。
【SpringCloud OpenFeign】OpenFeign服务接口调用
HR的博客
08-13 367
代码】【SpringCloud OpenFeign】OpenFeign服务接口调用。
简单使用feign实现服务间调用
weixin_43778043的博客
09-13 1724
Feign简单实现
SpringCloud服务间通信feign/openfeign远程调用在微服务结构中如何使用
qq_45776953的博客
05-19 205
spring cloud微服务实现服务间通信或者服务间调用openfeign快速上手使用案例
openfeign服务的远程调用
04-10
OpenFeign是一个基于Java的声明式HTTP客户端，它简化了编写服务间远程调用的代码。通过使用注解和接口定义，开发人员可以轻松地定义和使用远程服务接口。 在使用OpenFeign进行远程调用时，需要进行以下几个步骤： ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值