feign_feignclient - CSDN
feign 订阅
feign英语单词,主要用作为动词,用作动词译为“装作;假装,伪装;捏造(借口、理由等);创造或虚构,假装;装作;作假;佯作” 展开全文
feign英语单词,主要用作为动词,用作动词译为“装作;假装,伪装;捏造(借口、理由等);创造或虚构,假装;装作;作假;佯作”
信息
英式读音
feɪn
美式读音
fen
词    性
动词
外文名
feign
feign单词释义
... 同本义〖blackmail;cheat;swindle〗假装;冒充〖feign;pretend〗 用语言试探,诱使对方露真情〖soundout〗 ... [1] 
收起全文
精华内容
参与话题
  • Feign详解与实例

    千次阅读 2019-06-11 11:54:51
    基本介绍 Feign是一种负载均衡的HTTP客户端,...Feign集成了Ribbon。Ribbon+eureka是面向微服务编程,而Feign是面向接口编程。 Fegin是一个声明似的web服务客户端,它使得编写web服务客户端变得更加容易。使用Feg...

    基本介绍

            Feign是一种负载均衡的HTTP客户端, 使用Feign调用API就像调用本地方法一样,从避免了调用目标微服务时,需要不断的解析/封装json 数据的繁琐。Feign集成了Ribbon。Ribbon+eureka是面向微服务编程,而Feign是面向接口编程。

            Fegin是一个声明似的web服务客户端,它使得编写web服务客户端变得更加容易。使用Fegin创建一个接口并对它进行注解。它具有可插拔的注解支持包括Feign注解与JAX-RS注解,Feign还支持可插拔的编码器与解码器,Spring Cloud 增加了对 Spring MVC的注解,Spring Web 默认使用了HttpMessageConverters, Spring Cloud 集成 Ribbon 和 Eureka 提供的负载均衡的HTTP客户端 Feign。

    Feign能干什么

           Feign旨在使编写Java Http客户端变得更容易。在使用Ribbon+RestTemplate时,利用RestTemplate对http请求的封装处理,形成了一套模版化的调用方法。但是在实际开发中,由于对服务依赖的调用可能不止一处,往往一个接口会被多处调用,所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以,Feign在此基础上做了进一步封装,由他来帮助我们定义和实现依赖服务接口的定义。在Feign的实现下,我们只需创建一个接口并使用注解的方式来配置它(以前是Dao接口上面标注Mapper注解,现在是一个微服务接口上面标注一个Feign注解即可),即可完成对服务提供方的接口绑定,简化了使用Spring cloud Ribbon时,自动封装服务调用客户端的开发量。

           Feign集成了Ribbon。利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息,并且通过轮询实现了客户端的负载均衡。而与Ribbon不同的是,通过feign只需要定义服务绑定接口且以声明式的方法,优雅而简单的实现了服务调用。

    SpringCloud之Feign入门实例

    1、添加依赖以及主程序

       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-feign</artifactId>
       </dependency>
    @SpringBootApplication
    @EnableEurekaClient
    @EnableFeignClients(basePackages= {"com.atguigu.springcloud"})
    @ComponentScan("com.atguigu.springcloud")
    public class DeptConsumer80_Feign_App{
    
    	public static void main(String[] args){
    		SpringApplication.run(DeptConsumer80_Feign_App.class, args);
    	}
    }

     2、接口+注解(一般在公共接口中定义,方面其他微服务调用)

    @FeignClient(value = "MICROSERVICECLOUD-DEPT")  //该接口对应于应用id为MICROSERVICECLOUD-DEPT的微服务
    public interface DeptClientService
    {
      @RequestMapping(value = "/dept/get/{id}",method = RequestMethod.GET)
      public Dept get(@PathVariable("id") long id);
    
    
      @RequestMapping(value = "/dept/list",method = RequestMethod.GET)
      public List<Dept> list();
    
    
      @RequestMapping(value = "/dept/add",method = RequestMethod.POST)
      public boolean add(Dept dept);
    }

    应用id为MICROSERVICECLOUD-DEPT的微服务就实现该接口功能。

    3、Web层服务调用

    以前使用Ribbon+Eureka时:

    @RestController
    public class DeptController_Consumer{
    	private static final String REST_URL_PREFIX = "http://MICROSERVICECLOUD-DEPT";
    
    	@Autowired
    	private RestTemplate restTemplate;
    
    	@RequestMapping(value = "/consumer/dept/add")
    	public boolean add(Dept dept){
    		return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    	}
    
    	@RequestMapping(value = "/consumer/dept/get/{id}")
    	public Dept get(@PathVariable("id") Long id){
    		return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    	}
    
    	@SuppressWarnings("unchecked")
    	@RequestMapping(value = "/consumer/dept/list")
    	public List<Dept> list(){
    		return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    	}
    }
    

    现在使用Feign,面向接口编程:

    @RestController
    public class DeptController_Consumer{
    
    	@Autowired
    	private DeptClientService service;
    
    	@RequestMapping(value = "/consumer/dept/get/{id}")
    	public Dept get(@PathVariable("id") Long id){
    		return this.service.get(id);
    	}
    
    	@RequestMapping(value = "/consumer/dept/list")
    	public List<Dept> list(){
    		return this.service.list();
    	}
    
    	@RequestMapping(value = "/consumer/dept/add")
    	public Object add(Dept dept){
    		return this.service.add(dept);
    	}
    }

    Ribbon和Feign都是用于调用其他服务的,不过方式不同

    目前,在Spring cloud 中服务之间通过restful方式调用有两种方式 
        - restTemplate+Ribbon 
        - feign

    • 1.启动类使用的注解不同,Ribbon用的是@RibbonClient,Feign用的是@EnableFeignClients。
    • 2.服务的指定位置不同,Ribbon是在@RibbonClient注解上声明,Feign则是在定义抽象方法的接口中使用@FeignClient声明。
    • 3.调用方式不同,Ribbon需要自己构建http请求,模拟http请求然后使用RestTemplate发送给其他服务,步骤相当繁琐。Feign则是在Ribbon的基础上进行了一次改进,采用接口的方式,将需要调用的其他服务的方法定义成抽象方法即可,不需要自己构建http请求。不过要注意的是抽象方法的注解、方法签名要和提供服务的方法完全一致。

     

    Feign的自带断路器

    @FeignClient(value = "YunCai-SearchServer", fallback=ServiceHystrix.class)
    public interface SchedualServiceHi {
     
    	@RequestMapping(value = "/luke/itemsearch",method = RequestMethod.GET)
    	ResponseMap sayHiFromClientOne(@RequestParam(value = "start") Integer start,
        		@RequestParam(value = "rows") Integer rows,
        		@RequestParam(value = "tenantId") Integer tenantId,
        		@RequestParam(value = "status") Integer status,
        		@RequestParam(value = "key") String key);
    }
    @Component
    public class ServiceHystrix implements SchedualServiceHi {
     
    	@Override
    	public ResponseMap sayHiFromClientOne(Integer start, Integer rows, Integer tenantId, Integer status, String key) {
    		SearchResult result = new SearchResult(0, new ArrayList<>(Arrays.asList(1L,2L,3L)));
    		return new ResponseMap(false, "111", 506, result);
    	}
    }

     

    展开全文
  • Feign可以把Rest的请求进行隐藏,伪装成类似SpringMVC的Controller一样。你不用再自己拼接url,拼接参数等等操作,一切都交给Feign去做。 项目主页:https://github.com/OpenFeign/feign 2.2.快速入门 2.2.1.导入...

    有道词典的英文解释:

    在这里插入图片描述

    为什么叫伪装?

    Feign可以把Rest的请求进行隐藏,伪装成类似SpringMVC的Controller一样。你不用再自己拼接url,拼接参数等等操作,一切都交给Feign去做。

    项目主页:https://github.com/OpenFeign/feign

    在这里插入图片描述

    2.2.快速入门

    2.2.1.导入依赖

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

    2.2.2.Feign的客户端

    @FeignClient("user-service")
    public interface UserFeignClient {
    
        @GetMapping("/user/{id}")
        User queryUserById(@PathVariable("id") Long id);
    }
    
    • 首先这是一个接口,Feign会通过动态代理,帮我们生成实现类。
    • @FeignClient,声明这是一个Feign客户端,类似@Mapper注解。同时通过value属性指定服务名称
    • 接口中的定义方法,完全采用SpringMVC的注解,Feign会根据注解帮我们生成URL,并访问获取结果

    改造原来的调用逻辑,修改UserDao:

     @Autowired
        private UserFeighClient userFeighClient;
    
    
        @HystrixCommand(fallbackMethod = "queryUserByIdFallback")
        public User queryUserById(Long id){
            long begin = System.currentTimeMillis();
    
            User user = this.userFeighClient.queryById(id);
    
            long end = System.currentTimeMillis();
            System.out.println("用时:"+(begin-end));
    
            return user;
        }
    

    2.2.3.开启Feign功能

    我们在启动类上,添加注解,开启Feign功能

    @SpringBootApplication
    @EnableDiscoveryClient
    @EnableHystrix
    @EnableFeignClients // 开启Feign功能
    public class UserConsumerDemoApplication {
        public static void main(String[] args) {
            SpringApplication.run(UserConsumerDemoApplication.class, args);
        }
    }
    
    • 你会发现RestTemplate的注册被我删除了。Feign中已经自动集成了Ribbon负载均衡,因此我们不需要自己定义RestTemplate了

    2.2.4.启动测试:

    访问接口:

    在这里插入图片描述

    正常获取到了结果。

    2.3.负载均衡

    Feign中本身已经集成了Ribbon依赖和自动配置:

    在这里插入图片描述

    因此我们不需要额外引入依赖,也不需要再注册RestTemplate对象。

    另外,我们可以像上节课中讲的那样去配置Ribbon,可以通过ribbon.xx来进行全局配置。也可以通过服务名.ribbon.xx来对指定服务配置:

    全局配置:对所有服务都生效

    ribbon:
      ConnectTimeout: 250 # 连接超时时间(ms)
      ReadTimeout: 1000 # 通信超时时间(ms)
      OkToRetryOnAllOperations: true # 是否对所有操作重试
      MaxAutoRetriesNextServer: 1 # 同一服务不同实例的重试次数
      MaxAutoRetries: 1 # 同一实例的重试次数
    

    局部配置:只对当前服务生效

    user-service:
      ribbon:
        ConnectTimeout: 250 # 连接超时时间(ms)
        ReadTimeout: 1000 # 通信超时时间(ms)
        OkToRetryOnAllOperations: true # 是否对所有操作重试
        MaxAutoRetriesNextServer: 1 # 同一服务不同实例的重试次数
        MaxAutoRetries: 1 # 同一实例的重试次数
    

    2.4.Hystix支持

    Feign默认也有对Hystix的集成:

    在这里插入图片描述

    只不过,默认情况下是关闭的。我们需要通过下面的参数来开启:

    feign:
      hystrix:
        enabled: true # 开启Feign的熔断功能
    

    但是,Feign中的Fallback配置不像Ribbon中那样简单了。

    1)首先,我们要定义一个类,实现刚才编写的UserFeignClient,作为fallback的处理类

    @Component
    public class UserFeignClientFallback implements UserFeignClient {
        @Override
        public User queryUserById(Long id) {
            User user = new User();
            user.setId(id);
            user.setName("用户查询出现异常!");
            return user;
        }
    }
    
    

    2)然后在UserFeignClient中,指定刚才编写的实现类

    @FeignClient(value = "user-service", fallback = UserFeignClientFallback.class)
    public interface UserFeignClient {
    
        @GetMapping("/user/{id}")
        User queryUserById(@PathVariable("id") Long id);
    }
    
    

    3)重启测试:

    我们关闭user-service服务,然后在页面访问:

    在这里插入图片描述

    展开全文
  • Feign简介与简单应用

    万次阅读 热门讨论 2018-08-13 18:57:01
    一 点睛 Feign是Netflix开发的声明式、模板化的HTTP客户端, Feign可以帮助我们更快捷、优雅地调用HTTP API。 在Spring Cloud中,使用Feign非常简单...Spring Cloud对Feign进行了增强,使Feign支持了Sprin...

    一 点睛

    Feign是Netflix开发的声明式、模板化的HTTP客户端, Feign可以帮助我们更快捷、优雅地调用HTTP API。

    在Spring Cloud中,使用Feign非常简单——创建一个接口,并在接口上添加一些注解,代码就完成了。Feign支持多种注解,例如Feign自带的注解或者JAX-RS注解等。

    Spring Cloud对Feign进行了增强,使Feign支持了Spring MVC注解,并整合了Ribbon和Eureka,从而让Feign的使用更加方便。

    Spring Cloud Feign是基于Netflix feign实现,整合了Spring Cloud Ribbon和Spring Cloud Hystrix,除了提供这两者的强大功能外,还提供了一种声明式的Web服务客户端定义的方式。

    Spring Cloud Feign帮助我们定义和实现依赖服务接口的定义。在Spring Cloud feign的实现下,只需要创建一个接口并用注解方式配置它,即可完成服务提供方的接口绑定,简化了在使用Spring Cloud Ribbon时自行封装服务调用客户端的开发量。

    Spring Cloud Feign具备可插拔的注解支持,支持Feign注解、JAX-RS注解和Spring MVC的注解。

     

    二 创建项目microservice-consumer-movie-feign

    三 添加Feign依赖

    <?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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.itmuch.cloud</groupId>
      <artifactId>microservice-consumer-movie-feign</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
      <!-- 引入spring boot的依赖 -->
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.3.RELEASE</version>
      </parent>
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
      </properties>
      <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!--添加feign依赖-->
        <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
      </dependencies>
      <!-- 引入spring cloud的依赖 -->
      <dependencyManagement>
        <dependencies>
          <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Camden.SR4</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
        </dependencies>
      </dependencyManagement>
      <!-- 添加spring-boot的maven插件 -->
      <build>
        <plugins>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
        </plugins>
      </build>
    </project>

    四 创建一个Feign接口,并添加@FeignClient注解

    package com.itmuch.cloud.study.user.feign;
    
    import org.springframework.cloud.netflix.feign.FeignClient;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    import com.itmuch.cloud.study.user.entity.User;
    
    @FeignClient(name = "microservice-provider-user")
    public interface UserFeignClient {
      @RequestMapping(value = "/{id}", method = RequestMethod.GET)
      public User findById(@PathVariable("id") Long id);
    }

    五 修改Controller代码,让其调用Feign接口

    package com.itmuch.cloud.study.user.controller;
    
    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;
    
    import com.itmuch.cloud.study.user.entity.User;
    import com.itmuch.cloud.study.user.feign.UserFeignClient;
    
    @RestController
    public class MovieController {
      @Autowired
      private UserFeignClient userFeignClient;
    
      @GetMapping("/user/{id}")
      public User findById(@PathVariable Long id) {
        return this.userFeignClient.findById(id);
      }
    }

    六 修改启动类,为其添加@EnableFeignClients注解

    package com.itmuch.cloud.study;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.feign.EnableFeignClients;
    
    @EnableDiscoveryClient
    @SpringBootApplication
    @EnableFeignClients
    public class ConsumerMovieApplication {
      public static void main(String[] args) {
        SpringApplication.run(ConsumerMovieApplication.class, args);
      }
    }

    七 测试

    1 启动eureka

    2 启动2个user实例

    3 启动feign

    4 多次访问http://localhost:8010/user/1

    发现两个微服务实例都会打印如下日志:

    Hibernate: select user0_.id as id1_0_0_, user0_.age as age2_0_0_, user0_.balance as balance3_0_0_, user0_.name as name4_0_0_, user0_.username as username5_0_0_ from user user0_ where user0_.id=?

     

    展开全文
  • Feign 基本使用

    万次阅读 多人点赞 2018-10-24 15:07:32
    文章目录Feign 概述什么是 FeignFeign 入门案例引入依赖Feign 接口编写Controller结果Feign 工作原理@FeignClient 注解   在开发 Spring Cloud 微服务的时候,我们知道,服务之间都是以 HTTP 接口的形式对外提供...

      在开发 Spring Cloud 微服务的时候,我们知道,服务之间都是以 HTTP 接口的形式对外提供服务的,因此消费者在进行调用的时候,底层就是通过 HTTP Client 的这种方式进行访问。当然我们可以使用JDK原生的 URLConnection、Apache 的 HTTP Client、Netty 异步 Http Client,Spring 的 RestTemplate 去实现服务间的调用。但是最方便、最优雅的方式是通过 Spring Cloud Open Feign 进行服务间的调用 Spring Cloud 对 Feign 进行了增强,使 Feign 支持 Spring Mvc 的注解,并整合了 Ribbon 等,从而让 Feign 的使用更加方便。

    Feign 概述

    什么是 Feign

      Feign 是一个声明式的 Web Service 客户端。它的出现使开发 Web Service 客户端变得很简单。使用 Feign 只需要创建一个接口加上对应的注解,比如:@FeignClient 注解。 Feign 有可插拔的注解,包括 Feign 注解和 AX-RS 注解。Feign 也支持编码器和解码器,Spring Cloud Open Feign 对 Feign 进行增强支持 Spring Mvc 注解,可以像 Spring Web 一样使用 HttpMessageConverters 等。

      Feign 是一种声明式、模板化的 HTTP 客户端。在 Spring Cloud 中使用 Feign,可以做到使用 HTTP 请求访问远程服务,就像调用本地方法一样的,开发者完全感知不到这是在调用远程方法,更感知不到在访问 HTTP 请求。接下来介绍一下 Feign 的特性,具体如下:

    • 可插拔的注解支持,包括 Feign 注解和AX-RS注解。
    • 支持可插拔的 HTTP 编码器和解码器。
    • 支持 Hystrix 和它的 Fallback。
    • 支持 Ribbon 的负载均衡。
    • 支持 HTTP 请求和响应的压缩。Feign 是一个声明式的 WebService 客户端,它的目的就是让 Web Service 调用更加简单。它整合了 Ribbon 和 Hystrix,从而不需要开发者针对 Feign 对其进行整合。Feign 还提供了 HTTP 请求的模板,通过编写简单的接口和注解,就可以定义好 HTTP 请求的参数、格式、地址等信息。Feign 会完全代理 HTTP 的请求,在使用过程中我们只需要依赖注入 Bean,然后调用对应的方法传递参数即可。

    Feign 入门案例

      此处以调用 Github API 查询服务为例。

    引入依赖

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

      启动类加入如下注解:

    /** 开启 Feign 扫描支持 */
    @EnableFeignClients 
    

    Feign 接口编写

    /**
     * @Author:大漠知秋
     * @Description:使用 Feign 访问 Github 查询 API
     * @CreateDate:2:36 PM 2018/10/24
     */
    @FeignClient(name = "github-client", url = "https://api.github.com")
    public interface GitHubFeign {
    
        @RequestMapping(
                value = "/search/repositories",
                method = RequestMethod.GET,
                produces = MediaType.APPLICATION_JSON_UTF8_VALUE
        )
        String searchRepo(@RequestParam("q") String q);
    
    }
    

    Controller

    /**
     * @Author:大漠知秋
     * @Description:使用 Feign 访问 Github 查询 API
     * @CreateDate:2:42 PM 2018/10/24
     */
    @RestController
    @RequestMapping(
            value = "/github",
            produces = MediaType.APPLICATION_JSON_UTF8_VALUE
    )
    public class GitHubController {
    
        @Resource
        private GitHubFeign gitHubFeign;
    
        @RequestMapping(
                value = "/search/repositories",
                method = RequestMethod.GET
        )
        String searchRepo(@RequestParam("q") String q) {
            return gitHubFeign.searchRepo(q);
        }
    
    }
    

    结果

    结果

    源码:https://github.com/SlowSlicing/demo-spring-cloud-finchley/tree/Feign基本使用

    Feign 工作原理

    • 在开发微服务应用时,我们会在主程序入口添加 @EnableFeignClients 注解开启对 Feign Client 扫描加载处理。根据 Feign Client 的开发规范,定义接口并加 @FeignClients 注解。
    • 当程序启动时,会进行包扫描,扫描所有 @FeignClients 的注解的类,并将这些信息注入 Spring IOC 容器中。当定义的 Feign 接口中的方法被调用时,通过JDK的代理的方式,来生成具体的 RequestTemplate。当生成代理时,Feign 会为每个接口方法创建一个 RequetTemplate 对象,该对象封装了 HTTP 请求需要的全部信息,如请求参数名、请求方法等信息都是在这个过程中确定的。
    • 然后由 RequestTemplate 生成 Request,然后把 Request 交给 Client 去处理,这里指的 Client 可以是 JDK 原生的 URLConnection、Apache 的 Http Client 也可以是 Okhttp。最后 Client 被封装到 LoadBalanceclient 类,这个类结合 Ribbon 负载均衡发起服务之间的调用。

    @FeignClient 注解

    • name:指定 Feign Client 的名称,如果项目使用了 Ribbon,name 属性会作为微服务的名称,用于服务发现。
    • url:url 一般用于调试,可以手动指定 @FeignClient 调用的地址。
    • decode404:当发生404错误时,如果该字段为 true,会调用 decoder 进行解码,否则抛出 FeignException。
    • configuration:Feign 配置类,可以自定义 Feign 的 Encoder、Decoder、LogLevel、Contract。
    • fallback:定义容错的处理类,当调用远程接口失败或超时时,会调用对应接口的容错逻辑,fallback 指定的类必须实现 @FeignClient 标记的接口。
    • fallbackFactory:工厂类,用于生成 fallback 类示例,通过这个属性我们可以实现每个接口通用的容错逻辑,减少重复的代码。
    • path:定义当前 FeignClient 的统一前缀。
    展开全文
  • 这篇文章主要讲述通过feign去消费服务。Feign是一个声明式的web服务客户端,它使得写web服务变得更简单。使用Feign,只需要创建一个接口并注解。它具有可插拔的注解特性,包括Feign 注解和JAX-RS注解。Feign同时支持...
  • Feign-简单使用

    千次阅读 2019-03-21 22:18:40
    Feign 是一个声明式的伪RPC的REST客户端,它用了基于接口的注解方式,很方便的客户端配置。Spring Cloud 给 Feign 添加了支持Spring MVC注解,并整合Ribbon及Eureka进行支持负载均衡。 Feign的使用很简单,有以下...
  • FeignClient源码深度解析

    万次阅读 多人点赞 2019-02-27 21:14:03
    springCloud feign主要对netflix feign进行了增强和包装,本篇从源码角度带你过一遍装配流程,揭开feign底层的神秘面纱。 主要包括feign整合ribbon,hystrix,sleuth,以及生成的代理类最终注入到spring容器的过程。...
  • Feign

    2019-06-13 14:56:27
    https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-feign.html ...7.Declarative REST Client: Feign Feignis a declarative web service client. It makes writing web service clients eas...
  • Spring Cloud-Feign设计原理

    万次阅读 多人点赞 2019-06-07 22:53:18
    什么是FeignFeign 是一个http请求调用的轻量级框架,可以以Java接口注解的方式调用Http请求,而不用像Java中通过封装HTTP请求报文的方式直接调用。Feign通过处理注解,将请求模板化,当实际调用的时候,传入参数...
  • feign.FeignException: status 401 reading XXXXX

    万次阅读 2018-07-20 20:17:32
    权限下无法调用feign 报错信息为  401 , {"error":"unauthorized","error_description":"Full authentication is required to access this resource"} 解决办法可以在...
  • 前些天玩SpringCloud做了个小demo做到使用feign 做一个服务消费者时 出现这个错误:解决办法:
  • 问题:项目部署到线上环境之后,有一天突然报错:Feign status 400 reading XXXX content: 原因:get请求参数太长,内嵌tomcat对参数的默认限制是8K 解决:在Feign接口提供端的微服务中修改tomcat对参数的默认值,...
  • 404,那么还是路径的问题! 服务提供者 接口中心: 消费端: 报错是因为接口中心的/consumer路径没加上去,加上去就OK了
  • feign.FeignException: status 500 reading… 也不是第一次碰到这个bug,出现的频率也不小,从异常给予的提示来看 status 500其实什么提示也没有. 从解决的结果来看,这个bug容易出现的地方分别为: 1.远程调用的时候...
  • 此贴未必对所有出现这种错的都有效果,只是记录了我在开发中遇到了这样的...feign.FeignException: status 404 reading NotOperationFeignClient#findByCityName(String); content: {"timestamp":149036...
  • 在请求某个接口时, 在接口异常的情况下,一次正常返回异常信息,紧接着请求就会报feign.FeignException: status 400 reading xxx 异常 解决方法: Feign 请求服务,在Controller 之上的 xxxMapping 的注解,如果...
  • Ribbon和Feign的区别

    万次阅读 2018-07-23 09:43:13
    Ribbon和Feign都是用于调用其他服务的,不过方式不同。 1.启动类使用的注解不同,Ribbon用的是@RibbonClient,Feign用的是@EnableFeignClients。 2.服务的指定位置不同,Ribbon是在@RibbonClient注解上声明,Feign...
  • 使用Feign服务进行模块调用时报错 我是Client模块jar包安装到本地,另一项目调用 具体内容如下 Client 调用 爆红没事,是IDEA的检测导致,不影响正常使用 解决方案 将配置文件(yml或properties)的 ...
  • ribbon和feign的区别

    万次阅读 2018-10-11 17:42:39
    pring cloud的Netflix中提供了两个组件实现软负载均衡调用:ribbon和feign。 Ribbon  是一个基于 HTTP 和 TCP 客户端的负载均衡器  它可以在客户端配置 ribbonServerList(服务端列表),然后轮询请求以实现均衡...
  • feign.RetryableException: Read timed out

    万次阅读 2018-03-12 16:42:16
    两个微服务之间通过feign调用时,后台抛出异常: feign.RetryableException: Read timed out executing POST 解决方法: 在你的yml文件中添加 ribbon: ReadTimeout: 60000 ConnectTimeout: 60000 如图: ...
1 2 3 4 5 ... 20
收藏数 32,895
精华内容 13,158
关键字:

feign