精华内容
下载资源
问答
  • 在springcloud版本 Hoxton.SR1中 微服务的名称并非为application.yml或者appklication.properties 总配置文件对应的spring.application.name对应的属性 ,而是他的大写 比如 微服务名称为abc 实际应该为ABC...

    报错信息大致出现此类Load balancer does not have available server for client

    可能性1:

    feignclient 

     使用注解

    @FeignClient("XXX")

    注入时候  微服务名称错误  没有找到对应的服务 也就是没有找到名称为xxx的服务器

    正确的名字应该为application.yml或者appklication.properties 总配置文件对应的spring.application.name对应的属性

    可能性2:

    由于版本问题  

    在springcloud版本

    Hoxton.SR1中  微服务的名称并非为application.yml或者appklication.properties 总配置文件对应的spring.application.name对应的属性 ,而是他的大写

    比如   微服务名称为abc  实际应该为ABC

    展开全文
  • Feign

    2020-09-29 16:19:44
    加入Feign 调用 转发head信息 Ribbon转发 Spring Cloud之Ribbon转发请求头(header参数) Feign转发 Feign传递请求头信息(Finchley版本

    加入Feign

    调用

    转发head信息

    注意

    • Feign返回对象不能为接口对象
    @FeignClient(value = "hqrfid-core",path = "taizBang")
    public interface FeignCoreTaizService{
    
        @PostMapping("list")
        public Ret<Page<TaizBang>> list(PageRequest pageRequest);
    	//返回对象不能为口对象
    }
    
    • 服务之间传递head参数
    @EnableFeignClients和Feign的过滤器 RequestInterceptor
    @Bean
    public RequestInterceptor requestInterceptor(){
    	return new FeignBasicAuthRequestInterceptor();
    }
    都是只需在调用者上加,不需要再被调用者上加
    
    展开全文
  • feign

    2018-11-14 17:46:20
    Feign包含了Ribbon和Hystrix,这个在实战中才慢慢体会到它的意义,所谓的包含并不是Feign的jar包包含有Ribbon和Hystrix的jar包这种物理上的包含,而是Feign的功能包含了其他两者的功能这种逻辑上的包含。简言之:...

    https://blog.csdn.net/yejingtao703/article/details/77748190

     

    Feign包含了Ribbon和Hystrix,这个在实战中才慢慢体会到它的意义,所谓的包含并不是Feign的jar包包含有Ribbon和Hystrix的jar包这种物理上的包含,而是Feign的功能包含了其他两者的功能这种逻辑上的包含。简言之:Feign能干Ribbon和Hystrix的事情,但是要用Ribbon和Hystrix自带的注解必须要引入相应的jar包才可以。

        

    案例一:

    Eureka注册中心:https://github.com/yejingtao/forblog/tree/master/demo-eureka-register

    服务提供方:https://github.com/yejingtao/forblog/tree/master/demo-feign-freeservice

    服务调用方:https://github.com/yejingtao/forblog/tree/master/demo-feign-freeconsumer


    服务提供方就是个简单的EurekaClient端+web应用,提供以下方法

        @RestController
    @RequestMapping("/feign-service")
    public class HelloServiceContorller {
        
        private Logger logger = LoggerFactory.getLogger(this.getClass());
        
        private void sleep(String methodName) {
            int sleepMinTime = new Random().nextInt(3000);
            logger.info("helloService "+methodName+" sleepMinTime: "+sleepMinTime);
            try {
                Thread.sleep(sleepMinTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        @RequestMapping(value="/serviceGet",method=RequestMethod.GET)
        public String helloService(@RequestParam String name) {
            sleep("get");
            return "HelloServiceImpl name :"+name;
        }
        
        @RequestMapping(value="/serviceHead", method=RequestMethod.HEAD)
        public String helloService(@RequestHeader String name,
                @RequestHeader String password) {
            sleep("header");
            return "helloServiceHead name :"+name +" password:"+password;
        }
        
        @RequestMapping(value="/servicePost", method=RequestMethod.POST)
        public String helloService(@RequestBody UserDemo userDemo) {
            sleep("post");
            return userDemo.toString();
        }
    }

    需要注意的以下注解不可以省略。

    @RequestParam:Annotation which indicates that amethod parameter should be bound to a web request parameter

    @RequestBody:Annotation indicating a methodparameter should be bound to the body of the web request.

    @RequestHeader:Annotation which indicates that amethod parameter should be bound to a web request header.

    如果缺少了以上注解,服务运行起来以后虽然不会报错,但是获取不到入参。

    服务调用方项目:

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

    这里只依赖了Feign,没有依赖Ribbon和Hystrix。

    application.yml:

        server:
          port: 9051
         
        spring:
          application:
            name: demo-feign-freeconsumer
            
        eureka:
          client:
            serviceUrl:
              defaultZone: http://peer1:1111/eureka/,http://peer2:1112/eureka/
        feign:
          hystrix:
            enabled: true
         
        #Ribbon 超时时间设置
        #ribbon:
        #  ConnectTimeout: 500
        #  ReadTimeout:  3000

    hystrix这个配置坑了我好久我用的Spring Cloud是Dalston版本SR1,比网上其他材料的版本要新,因为在新版本中Feign对Hystrix的支持默认是关闭的,所以要通过配置手动打开feign.hystrix.enabled=true,这样服务降级等功能才有效果。

    Application启动程序

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

    注意这里还有个坑,我这里用的是@SpringBootApplication+@EnableEurekaClient,而不是用的@SpringCloudApplication,因为后者包含了@EnableCircuitBreaker,而@EnableCircuitBreaker又是属于Hystrix包里的内容,我的pom里并没有引入Hystrix。所以这一点Spring Cloud做的还是有不足的地方,直接用@SpringCloudApplication编译不会报错,但是启动不了。当然这里的主角还是@EnableFeignClients这个注解。
    核心客户端代码

        @FeignClient(name="demo-feign-freeservice",fallback=DemoFeignFallback.class)
        public interface DemoFeignService{
            
         
            @RequestMapping(value="/feign-service/serviceGet",method=RequestMethod.GET)
            String helloService(@RequestParam("name") String name);
            
            @RequestMapping(value="/feign-service/serviceHead", method=RequestMethod.HEAD)
            String helloService(@RequestHeader("name") String name,
                    @RequestHeader("password") String password);
            
            @RequestMapping(value="/feign-service/servicePost", method=RequestMethod.POST)
            String helloService(@RequestBody UserDemo userDemo);
         
        }

    @FeignClient注解定义了该接口是一个Feign客户端,name指定了注册到Eureka上的服务名,fallback是服务降级后的接口实现类。
    @RequestMapping里指定了请求的相对url和http请求方式,与服务端一一对应。入参里的@RequestParam、@RequestBody、@RequestHeader注解比起服务端多了value属性,这里不能省略,需要显式的告知Feign客户端参数要如何对应。
    降级服务代码:

        @Component
        public class DemoFeignFallback implements DemoFeignService{
            @Override
            public String helloService(String name) {
                return "get error";
            }
         
            @Override
            public String helloService(String name,String password) {
                return "head error";
            }
            
            @Override
            public String helloService(UserDemo userDemo) {
                return "post error";
            }
        }

    发现这里的入参里我故意去掉了@RequestParam、@RequestBody、@RequestHeader注解,因为这几个注解本质上的意义就在于Feign在做微服务调用的时候对http传递参数用的,但服务降级根本不会做http请求了,所以此处可以省略。
    Controller代码:

        @RestController
        public class DemoFeignController {
            
            @Autowired
            private DemoFeignService demoFeignService;
            
            @RequestMapping(value="/test", method=RequestMethod.GET)
            public String demoServiceTest() {
                StringBuffer sb = new StringBuffer();
                sb.append(demoFeignService.helloService("yuanyuan"));
                sb.append("\n");
                sb.append(demoFeignService.helloService("yjt","xixihaha"));
                sb.append("\n");
                sb.append(demoFeignService.helloService(new UserDemo("yejingtao","123456")));
                return sb.toString();
                
            }
        }

    我们来看效果:

    我们服务都没超时,3个方法全部正常,但是head请求没有拿到返回值,这个是因为head方式http请求的特性决定的,head不返回response的body体,一般用来做连通性测试来用。

    再看一组:
    运气不好head和post请求方法处理时间超过了2000ms,服务降级,实现被fallback处理类取代。

     

    在案例一中我们总有种感觉,服务提供方和服务调用方存在重复的代码,是否可以进行优化?请看案例二。

    案例二:

    Eureka注册中心:https://github.com/yejingtao/forblog/tree/master/demo-eureka-register

    接口API:https://github.com/yejingtao/forblog/tree/master/demo-feign-serviceapi

    服务提供方:https://github.com/yejingtao/forblog/tree/master/demo-feign-serviceimpl

    服务调用方:https://github.com/yejingtao/forblog/tree/master/demo-feign-apiconsumer

    案例二最大的变动是将服务能力单独写到一个API的project中,调用方和提供方pom都依赖这个API。


    API:

        public interface HelloService {
            
            @RequestMapping(value="/feign-service/serviceGet",method=RequestMethod.GET)
            String helloService(@RequestParam("name") String name);
            
            @RequestMapping(value="/feign-service/serviceHead", method=RequestMethod.HEAD)
            String helloService(@RequestHeader("name") String name,
                    @RequestHeader("password") String password);
            
            @RequestMapping(value="/feign-service/servicePost", method=RequestMethod.POST)
            String helloService(@RequestBody UserDemo userDemo);
            
        }


    服务提供方:

        @RestController
        public class HelloServiceContorller implements HelloService{
            
            private Logger logger = LoggerFactory.getLogger(this.getClass());
            
            private void sleep(String methodName) {
                int sleepMinTime = new Random().nextInt(3000);
                logger.info("helloService "+methodName+" sleepMinTime: "+sleepMinTime);
                try {
                    Thread.sleep(sleepMinTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            @Override
            public String helloService(@RequestParam("name") String name) {
                sleep("get");
                return "HelloServiceImpl name :"+name;
            }
            
            @Override
            public String helloService(@RequestHeader("name") String name,
                    @RequestHeader("password") String password) {
                sleep("header");
                return "helloServiceHead name :"+name +" password:"+password;
            }
            
            @Override
            public String helloService(@RequestBody UserDemo userDemo) {
                sleep("post");
                return userDemo.toString();
            }
            
            
        }


    服务调用方:

        @FeignClient(name="demo-feign-serviceimpl", fallback=FeignServiceFallback.class)
        public interface FeignService extends HelloService{
         
        }

    其它代码基本不变,效果也一样。


    两种风格各有优缺点:freestyle的更自由,服务端新增方法不会影响客户端代码,缺点是服务能力不同步服务能力的变动会引起异常;API格式服务端客户端服务能力同步,但是接口的变动需要修改两边的代码,需要构建的时候就要考虑清楚。
    ---------------------
    作者:牛麦康纳
    来源:CSDN
    原文:https://blog.csdn.net/yejingtao703/article/details/77748190
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • Feign 的使用

    千次阅读 2018-03-20 17:06:33
    Feign 是 Netflix 开发的声明式、模板化的 HTTP 客户端,它可以帮助...使用的 Feign 版本为 1.4.3 服务端指 Eureka Server 所在微服务,客户端指提供数据的微服务,消费端指获取数据的微服务 1、Eureka 整合 Feig...

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

    前言

    • 本文中涉及到的 Spring Cloud 内容,可以查看我的相关博客

    • 使用的 Feign 版本为 1.4.3

    • 服务端指 Eureka Server 所在微服务,客户端指提供数据的微服务,消费端指获取数据的微服务

    1、Eureka 整合 Feign

    添加 Feign 依赖

    compile('org.springframework.cloud:spring-cloud-starter-feign')

    创建 Feign 接口,添加 @FeignClient 注解

    //name是客户端的虚拟主机名
    @FeignClient(name = "microservice-provider-user")
    @Service
    public interface UserFeignClient {
    
        //这里写客户端的访问路径
        @GetMapping("/{id}")
        User findById(@PathVariable("id") Long id);
    }

    其中的 microservice-provider-user 是任意一个客户端的虚拟主机名,用于创建 Ribbon 负载均衡器

    下面修改 Controller 代码

    @RestController
    public class BaseController {
    //    @Autowired
    //    private RestTemplate restTemplate;
    
        @Autowired
        private UserFeignClient userFeignClient;
    
        //之前我们是使用 RestTemplate 调用,需要拼接字符串
    //    @GetMapping("/user/{id}")
    //    public User findById(@PathVariable Long id){
    //        return this.restTemplate.getForObject("http://microservice-provider-user/"+id,User.class);
    //    }
    
    
        //相比于 RestTemplate ,Feign 明显地更加简洁
        @GetMapping("/user/{id}")
        public User findById_feign(@PathVariable Long id){
            return this.userFeignClient.findById(id);
        }
    }

    启动类上添加注解

    @EnableFeignClients

    这样我们就可以使用 Feign 来调用微服务的 API ,取代使用拼接方式访问的 RestTemplate

    2、自定义 Feign 配置

    创建 Feign 配置类

    
    /**
     * !!不能在主应用程序的上下文的@Component中,即不能在启动类所在包中
     */
    @Configuration
    public class FeignConfiguration {
    
        /** 
         * 将契约改为feign原生的默认契约,这样可以使用feign自带的注解。
         * !!修改为默认契约后,启动应用时下面接口会报错,所以建议不要使用
         */
        @Bean
        public Contract feignContract(){
            return new Contract.Default();
        }
    }

    修改 Feign 接口如下

    //使用 configuration 属性指定配置类
    @FeignClient(name = "microservice-provider-user",configuration = FeignConfiguration.class)
    @Service
    public interface UserFeignClient {
    
        /**
         * 经过测试,如果启用上面的默认契约,这里在启动应用时会报错
         * 下面两种方式都是可以的,RequestLine 是 Feign 的自带注解
         */
    //    @RequestLine("GET/{id}")
    //    User findById(@Param("id") Long id);
    
        @GetMapping("{id}")
        User findById(@PathVariable("id") Long id);
    }

    类似地可以自定义 Feign 的编码器、解码器等(这些未实验)。例如调用需要 HTTP Basic 认证的接口,配置类 FeignConfiguration 中加入:

    //过滤器 Http Basic 认证
    @Bean
    public BasicAuthorizationInterceptor basicAuthorizationInterceptor(){
        return new BasicAuthorizationInterceptor("user","password");
    }

    3、自建 Feign

    在某些场景下,自定义的 Feign 满足不了需求,此时可用 Feign Builder API 手动创建 Feign

    首先,在 客户端 微服务上建立 Spring Security 配置

    导入 Spring Security 依赖

    compile( 'org.springframework.boot:spring-boot-starter-security')

    创建配置类(可以全部copy)

    @Configuration
    @EnableWebSecurity
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
    
    
        @Override
        protected void configure(HttpSecurity http) throws Exception{
            //所有的请求,都需要经过HTTP basic认证
            http.authorizeRequests().anyRequest().authenticated().and().httpBasic();
        }
    
        @Bean
        public PasswordEncoder passwordEncoder(){
            //明文编码器。这是一个不做任何操作的密码编码器,是Spring提供给我们做明文测试的
            return NoOpPasswordEncoder.getInstance();
        }
    
        //在下面
        @Autowired
        private CustomUserDetailsService userDetailService;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception{
            auth.userDetailsService(this.userDetailService).passwordEncoder(this.passwordEncoder());
        }
    
        @Component
        class CustomUserDetailsService implements UserDetailsService{
            /**
             * 模拟两个账户
             * ① 账号 user,密码123,角色是user-role
             * ② 账号 admin,密码123,角色是admin-role
             */
            @Override
            public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
                if("user".equals(username)) {
                    return new SecurityUser("user", "123", "user-role");
                }
                else if("admin".equals(username)) {
                    return new SecurityUser("admin", "123", "admin-role");
                }
                else
                    return null;
            }
        }
        class SecurityUser implements UserDetails {
            private static final long serialVersionUID = 1L;
    
            public SecurityUser(String username, String password, String role) {
                super();
                this.username = username;
                this.password = password;
                this.role = role;
            }
    
            public SecurityUser() {
            }
    
            private Long id;
            private String username;
            private String password;
            private String role;
    
            @Override
            public Collection<? extends GrantedAuthority> getAuthorities() {
                Collection<GrantedAuthority> authorities = new ArrayList<>();
                SimpleGrantedAuthority authority = new SimpleGrantedAuthority(this.role);
                authorities.add(authority);
                return authorities;
            }
            //关键点:以下四个方法返回值返回true
            @Override
            public boolean isAccountNonExpired() {return true;}
    
            @Override
            public boolean isAccountNonLocked() {return true;}
    
            @Override
            public boolean isCredentialsNonExpired() {return true;}
    
            @Override
            public boolean isEnabled() { return true;}
    
            @Override
            public String getPassword() {
                return this.password;
            }
    
            @Override
            public String getUsername() {
                return this.username;
            }
        }
    }

    修改 Controller,打印当前登录的用户信息

    @GetMapping("{id}")
    public User findById(@PathVariable long id){
        Object principal= SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    
        if(principal instanceof UserDetails){
            UserDetails user=(UserDetails) principal;
            Collection<? extends GrantedAuthority> collection=user.getAuthorities();
            //打印当前用户信息
            for(GrantedAuthority c:collection){
                BaseController.LOGGER.info("用户:{},角色:{}",user.getUsername(),c.getAuthority());
            }
        }
    
        //这里从数据库获取 User,我用的是 MyBatis
        return userMapper.findById(id);
    }

    启动服务端和客户端测试,会弹出登录对话框

    分别使用 user / 123 和 admin / 123 登录,会输出类似以下的日志:

    2018-03-19 15:53:43.605  INFO 4404 --- [nio-8001-exec-3] c.i.port.controller.BaseController       : 用户:user,角色:user-role
    2018-03-19 15:53:43.605  INFO 4404 --- [nio-8001-exec-3] c.i.port.controller.BaseController       : 用户:admin,角色:admin-role

    用户信息是保存在了 Session 中,所以注销用户的方法就是重启浏览器

    现在修改消费端微服务
    • 去掉 Feign 接口 UserFeignClient 上的 @FeignClient 注解

    • 去掉启动类上的 @EnableFeignClients 注解

    修改 Controller 如下:

    @Import(FeignClientsConfiguration.class)
    @RestController
    public class BaseController {
    
        private UserFeignClient userFeignClient;
    
        private UserFeignClient adminFeignClient;
    
        @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
        @Autowired
        public BaseController(Decoder decoder, Encoder encoder, Client client, Contract contract){
            this.userFeignClient= Feign.builder().client(client).encoder(encoder).decoder(decoder).contract(contract)
                    .requestInterceptor(new BasicAuthRequestInterceptor("user","123"))
                    .target(UserFeignClient.class,"http://microservice-provider-user/");
            this.adminFeignClient= Feign.builder().client(client).encoder(encoder).decoder(decoder).contract(contract)
                    .requestInterceptor(new BasicAuthRequestInterceptor("admin","123"))
                    .target(UserFeignClient.class,"http://microservice-provider-user/");        
        }
    
        @GetMapping("/user-user/{id}")
        public User findById_user(@PathVariable Long id){
            return this.userFeignClient.findById(id);
        }
    
        @GetMapping("/user-admin/{id}")
        public User findById_admin(@PathVariable Long id){
            return this.userFeignClient.findById(id);
        }
    }

    其中,@Import 导入的是 Spring Cloud 为 Feign 默认提供的配置类。两个方法各司其职,分别登录 user 和 admin,使用同一个接口 UserFeignClient

    启动服务端、客户端、消费端(端口号8010),访问http://localhost:8010/user-user/1http://localhost:8010/user-admin/1,可以看到客户端微服务打印登录信息

    3、Feign 的其他支持

    对继承的支持

    使用继承,可以将一些公共操作分组到一些父接口中,从而简化 Feign 的开发

    创建基础接口 : UserService.java

    public interface UserService{
        @RequestMapping(method = RequestMethod.GET,value = "/user/{id}")
        User getUser(@PathVariable("id") long id);
    }

    服务提供者 Controller : UserResource.java

    @RestController
    public class UserResource implements UserService{
        //...
    }

    服务消费者 : UserClient.java

    @FeignClient("user")
    public interface UserClient extends UserService{
    }
    对压缩的支持

    一些场景下,可能需要对请求后响应进行压缩,此时可使用以下的属性启用 Feign 的压缩功能

    feign.compression.request.enabled=true
    feign.compression.response.enabled=true

    更详细的配置

    feign.compression.request.enabled=true
    feign.compression.request.mime-types=text/xml,application/xml,application/json
    feign.compression.request.min-request-size=2048

    其中
    - feign.compression.request.mime-types 用于支持的媒体类型列表,默认是 text/xml、application/xml 以及 application/json
    - feign.compression.request.min-request-size 用于设置请求的最小阈值,默认是2048

    4、Feign 的日志

    把项目回归到 第2条( 自定义 Feign 配置 ) 的状态:( 如果你拒绝,可以直接跳到下面黑体字 )
    - 加上启动类注解
    - 加上 Feign 接口的注解
    - UserFeignClient 使用 @Autowire 自动导入

    配置类 FeignConfiguration 中加入:

    @Bean
    public Logger.Level feignLoggerLevel(){
        //设置为输出详细信息
        return Logger.Level.FULL;
    }

    application.xml 中添加如下:

    logging:
      level:
        # 将Feign接口的日志级别设置为DEBUG
        cn.itscloudy.consumer.feign.UserFeignClient: DEBUG

    其中 cn.itscloudy.consumer.feign.UserFeignClient 是你 Feign 接口的路径

    然后启动服务端、客户端以及消费端,测试可以发现 Feign 请求的各种细节非常详细地记录了下来
    DEBUG LOGGER
    把上面方法返回值设为 Logger.Level.BASIC,再次测试,控制台只打印了请求方法、请求的 URL 等

    如果,项目是自建 Feign 的状态,即第3条的状态,需要以下步骤

    首先,自建 MyLogger 类继承 feing.Logger.ErrorLogger (因为经过测试,只有 ErrorLogger 才能输出信息)

    public class MyLogger extends feign.Logger.ErrorLogger{
        @Override
        protected void log(String configKey, String format, Object... args) {
            //所有关键信息都在 args 里了,可以自己输出看下,然后自定义格式输出所需信息
            for(Object o:args){
                System.out.println(o.toString());
            }
    //        super.log(configKey,format,args);
        }
    }

    构建 UserFeignClinet 时加上 .logger 指定 Logger ,加上 .logLevel 指定输出级别。

    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Autowired
    public BaseController(Decoder decoder, Encoder encoder, Client client, Contract contract){
        this.userFeignClient= Feign.builder().client(client).encoder(encoder).decoder(decoder).contract(contract)
                .logger(new MyLogger())
                .logLevel(feign.Logger.Level.FULL)
                .requestInterceptor(new BasicAuthRequestInterceptor("user","123"))
                .target(UserFeignClient.class,"http://microservice-provider-user/");
    }

    这里的 Logger 使用 MyLogger,当然也可以直接使用 ErrorLogger ,但是输出格式是全红
    全红输出
    然后,application.yml 也还需要有所添加,添加内容上面有叙述,不再赘述。
    ( 如果针对这一点有更好解决方法,欢迎告知 )

    5、构造 Feign 多参数请求

    GET

    @FeignClient(name = "microservice-provider-user")
    @Service
    public interface UserFeignClient {
        //方法一
    //    @GetMapping("/")
    //    User findUser(@RequestParam("id") Long id),@RequestParam("username") username);
    
        //方法二
        @GetMapping("/")
        User findUser(@RequestParm Map<String,Object> map);
    }

    使用方法二调用,可使用以下类似方法

    public User getUser(int id,String username){
        HashMap<String,Object> map=new HashMap<>();
        map.put("id",id);
        map.put("username",username);
        return this.userFeignClient.findUser(map);
    }

    POST

    @FeignClient(name = "microservice-provider-user")
    @Service
    public interface UserFeignClient {
        //使用@RequestBody注解
        @PostMapping("/")
        User findUser(@RequestBody User user);
    }

    后记

    以上代码大部分经过了我的测试

    引用的内容源自《Spring Cloud与Docker微服务架构实战》周立/著

    展开全文
  • 上一篇文章,讲述了如何通过RestTemplate+Ribbon去消费服务,这篇文章主要讲述如何通过Feign去消费服务。 一、Feign简介 Feign是一个声明式的伪Http客户端,它使得写Http客户端变得更简单。使...
  • Springboot中Feign client调用时版本问题

    千次阅读 2019-04-14 21:45:56
    gsdic-api, twpre-api是公共的服务,对外提供Restful的API,通过feign client去调用。 大的背景就是,jpmc-adapter现在需要调用另外两个公共的服务。 Springboot版本: jpmc-adapter 1.5.9 ...
  • 所以现在直接从Feign开始学习。当然由于没有用之前的那套代码,所以代码在这里 下面就开始Feign的学习 POM引入 &lt;dependency&gt; &lt;groupId&gt;org.springframework.cloud&lt;/groupId&...
  • Feign深入学习(一)

    2020-05-03 08:43:43
    Feign版本https://github.com/Netflix/feign不再维护,修改为https://github.com/OpenFeign/feign。 Maven <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-c...
  • 使用的是springboot的最新版本2.4.3和springcloud的最新版本2020.0.1,对应的feign版本不包含hystrix依赖 解决 更换springboot和springclould版本 <?xml version="1.0" encoding="UTF-8"?> <project xmlns=...
  • SpringCloud组件之Feign(Hoxton版本)

    千次阅读 2020-06-30 09:44:42
    1.Feign简介 Feign是一个声明式的伪Http客户端,它使得写Http客户端变得更简单。使用Feign,只需要创建一个接口并注解。它具有可插拔的注解特性,可使用Feign 注解和JAX-RS注解。Feign支持可插拔的编码器和解码器。...
  • nacos feign注意事项

    2020-09-27 15:22:54
    nacos 下载nacos最新版本 1.3.2,运行环境位windo10 单机版。需要更改startup.cmd文件下 set MODE="standalone" 如果需要讲将nacos的数据库文件导入到...feign 版本依赖 <dependency> <groupId>o
  • Feign 简介 Feign是一个声明式的Web客户端,它使得写Web客户端变得更简单。使用Feign,只需要创建一个接口并注解。 Feign默认集成了Ribbon,并和Eureka结合,默认实现了负载均衡的效果。 feign 配置 1.客户端...
  • 前言: Feign在Ribbon的基础上进行了升级,采用接口+注解的方式更为简单和接近我们...Feign版本:1.4.7.RELEASE 项目结构: baseservice   #基础服务,存放所有服务的Feign接口,也作为其他服务模块的依赖包
  • 网上很多配置感觉有点乱,版本没有具体说明,我这里是针对我自己使用的Finchley版本进行的配置。 Feign Retry 设置 feign.retryer的超时设置优先级>ribbon超时间设置,而且ribbon的超时时间设置必须要小于...
  • spring cloud的Hoxton.SR1版本feign的优雅降级的实现源码下载前言feign的优雅降级的实现注册中心账户微服务订单微服务验证feign的降级 源码下载 大家可以直接微信扫描上面的二维码关注我的公众号,然后回复hoxton...
  • 公司项目升级springboot由1.5.1升级到2.1.2.RELEASE,cloud版本也升级到G版本。突然发现文件上传失效。。。之前解决掉的问题又再次出现 问题收集如下: 1.Feign library does not support Multipart requests 2. The...
  • swagger2与feign版本冲突: 2.0的openfeingn使用的swagger版本应为2.5以上。
  • SpringBoot 关于Feign的超时时间配置

    千次阅读 2020-07-30 20:09:56
    无独有偶,我今天也遇到了一个关于 feign 超时时间配置的问题。 今天项目现场提过来一个问题 “公司发过来的封装好的 springboot ...公司 feign 版本 spring-cloud-starter-openfeign 2.2.3.RELEASE 基于 @FeignClien
  • 使用Feign,只需要创建一个接口并注解。它具有可插拔的注解特性,可使用Feign 注解和JAX-RS注解。Feign支持可插拔的编码器和解码器。Feign默认集成了Ribbon,并和Eureka结合,默认实现了负载均衡的效果。 简而言之:...
  • 走进Spring Cloud之五 eureka Feign(服务调用者)(Greenwich版本Feignservice-consumermoudlepom.xmlapplication.ymlConsumerExampleApplication.javaFeignExampleService.java启动工程 Feign Feign是一个声明式...
  • 主要是feign版本和swagger版本冲突,本项目spring cloud 版本为 Finchley.M8 swagger冲突版本 &lt;!-- swagger2 --&gt; &lt;dependency&gt; &lt;groupId&gt;io....
  • 简介 Feign是Java里的一个声明式的http api请求库,可以...基于这些优点,我也为.Net封装了一个类似的类库:Beinet.Feign,下面简单介绍一下使用方法。 注1:该库基于Framework4.0开发(可以支持WinXP系统),并依...
  • springboot feign 拦截器 RequestInterceptor,拦截feign请求拦截feign的请求 spring boot 版本 2.2.2.RELEASE spring cloud版本 Hoxton.SR1 拦截feign的请求 package cn.zhangfusheng.base.feign.interceptor; ...
  • 这篇文章主要讲述通过feign去消费服务。Feign是一个声明式的web服务客户端,它使得写web服务变得更简单。使用Feign,只需要创建一个接口并注解。它具有可插拔的注解特性,包括Feign 注解和JAX-RS注解。Feign同时支持...
  • Spring Cloud Feign是一套基于Netflix Feign实现的声明式服务调用客户端。它使得编写Web服务客户端变得更加简单。我们只需要通过创建接口并用注解来配置它既可完成对Web服务接口的绑定。它具备可插拔的注解支持,...
  • SpringCloud学习之路(四) 服务消费者Feign (Finchley版本) 一、Feign简介 Feign是Netflix开发的声明式、模板化的HTTP客户端, Feign可以帮助我们更快捷、优雅地调用HTTP API。 在Spring Cloud中,使用Feign非常...
  • SpringCloud Finchley.SR1版本feign 上使用 hystrix 一.Feign client 中加入hystrix的 fallaback。 @FeignClient(value = “usercenter-client”,fallback = UserCenteriServiceHystric.class) public interface ...
  • sentinal 对feign的支持需要设置feign.sentinel.enabled=true,这个要求可以从代码SentinelFeignAutoConfiguration看到 @Configuration @ConditionalOnClass({ SphU.class, Feign.class }) public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,416
精华内容 6,166
关键字:

feign版本