精华内容
下载资源
问答
  • SpringCloud入门(三)之基于Feign的服务间接口调用什么是Feign基于Feign的服务间接口调用实战创建两个微服务服务提供者引入spring-boot-starter-web依赖创建controller类提供接口配置端口号为8081服务消费者引入...

    什么是Feign

    Feign是一个声明式WebService客户端。
    在SpringCloud用于实现微服务之间的互相调用。
    服务消费者无需知道服务提供者的ip和端口,只需要 指定服务名,即可通过注册中心调用到目标服务。

    下面我们来实战下如何实现服务间的接口调用

    基于Feign的服务间接口调用实战

    完整参考代码github

    1. 已有基于Eureka注册中心的两个服务;
    2. 引入Eureka依赖;
    3. 使用注解@EnableEurekaClient声明作为Euraka客户端;
    4. 配置服务名和注册中心地址。

    ps:如果不配置服务名,则在注册中心显示的服务名为unknown;如果不配置注册中心地址,则无法注册成功,程序启动会报错。

    创建两个微服务

    创建两个基于Eureka注册中心的微服务,其中一个作为服务消费者,一个作为服务提供者。
    如何创建微服务可以参考:

    服务提供者

    把AuthenticationService作为服务提供者,并提供一个http请求接口:GET http://ip:port/user

    引入spring-boot-starter-web依赖

    在pom文件加入以下依赖引入,版本为2.1.0.RELEASE

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    

    创建controller类提供接口

    package com.markey.test.authenticationservice.contorller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class LoginController {
    
        @GetMapping("/user")
        public String getUser() {
            return "小明";
        }
    }
    

    配置端口号为8081

    #配置端口号,默认为8080,已被我的注册中心使用
    server.port=8081
    #配置服务名,不配置的话,注册中心显示为UnKnown
    spring.application.name=AuthenticationService
    #配置注册中心地址,不配置的话,程序启动会失败
    eureka.client.service-url.defaultZone=http://localhost:8080/eureka/
    

    服务消费者

    把CustomService作为服务消费者,并对外提供一个接口http请求:GET http://ip:port/hello

    引入openfeign依赖

    在pom文件加入以下依赖引入,版本为2.1.0.M2

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

    ps:这里没有指定版本,是因为使用spring-cloud-dependencies,版本号Greenwich.M3,读者如果没有引用spring-cloud-dependencies的话,可以自行给openfeign依赖加上版本号2.1.0.M2

    引入服务提供者的接口

    创建一个接口,接口的方法定义即为服务提供者提供的接口,这里是:GET http://ip:port/user

    package com.markey.test.customservice.api;
    
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.stereotype.Service;
    import org.springframework.web.bind.annotation.GetMapping;
    
    @FeignClient(value = "AuthenticationService")
    @Service
    public interface AuthenticationServiceApi {
    
        @GetMapping("/user")
        String getUser();
    }
    

    引入spring-boot-starter-web依赖

    在pom文件加入以下依赖引入,版本为2.1.0.RELEASE

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    

    创建controller类提供接口

    将上一步声明的接口作为一个bean注入;
    在方法中调用AuthenticationService提供的接口,就像调用普通bean的方法一样。

    package com.markey.test.customservice.controller;
    
    import com.markey.test.customservice.api.AuthenticationServiceApi;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class RootController {
    
        @Autowired
        AuthenticationServiceApi authenticationServiceApi;
    
        @GetMapping("/hello")
        public String hello() {
            //调用服务提供者的接口
            return "hello, " + authenticationServiceApi.getUser();
        }
    }
    

    配置端口号为8082

    #配置端口号,默认为8080,已被我的注册中心使用
    server.port=8082
    #配置服务名,不配置的话,注册中心显示为UnKnown
    spring.application.name=CustomService
    #配置注册中心地址,不配置的话,程序启动会失败
    eureka.client.service-url.defaultZone=http://localhost:8080/eureka/
    

    测试

    1. 启动服务注册中心;
    2. 启动AuthenticationService服务和CustomService服务
    3. 通过浏览器访问/hello接口

    访问/hello接口,CustomService会调用AuthenticationService,AuthenticationService给CustomService返回“小明”,CustomService再给浏览器返回“hello,小明”
    在这里插入图片描述

    展开全文
  • spring cloud框架中各个服务进行服务间调用时需要用到feign模块,但是由于feign的懒加载,往往会出现服务启动后第一次调用异常后续正常或者是持续调用异常等不稳定现象,此处针对该问题对使用feign的服务添加配置...

    feign服务间接口调用时,有时候首次调用出现问题,后续正常,有时始终不正常,总之feign由于懒加载导致存在不稳定性因素。但是feign作为spring cloud一大组件,确实简化开发,此处给出配置信息,对feign组件的不稳定性加以处理。

    spring.cloud.loadbalancer.retry.enabled=true
    hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=10000
    
    ribbon.ConnectTimeout=250
    ribbon.ReadTimeout=1000
    ribbon.OkToRetryOnAllOperations=true
    ribbon.MaxAutoRetriesNextServer=2
    ribbon.maxAutoRetries=1
    

    各参数含义:
    spring.cloud.loadbalancer.retry.enabled:该参数用来开启重试机制,它默认是关闭的。
    hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds:断路器的超时时间需要大于Ribbon的超时时间,不然不会触发重试。
    ribbon.ConnectTimeout:请求连接超时时间。
    ribbon.ReadTimeout:请求处理的超时时间
    ribbon.OkToRetryOnAllOperations:对所有操作请求都进行重试。
    ribbon.MaxAutoRetriesNextServer:切换实例的重试次数。
    ribbon.maxAutoRetries:对当前实例的重试次数。

    根据以上配置,当访问到故障请求的时候,它会再尝试访问一次当前实例(次数由maxAutoRetries配置),如果不行,就换一个实例进行访问,如果还是不行,再换一个实例访问(更换次数由MaxAutoRetriesNextServer配置),如果依然不行,返回失败。

    参考链接:https://www.jianshu.com/p/f86af82fa782

    展开全文
  • 1.feign的远程调用(http接口调用) 2.RestTemplate 下面参考别的博客我自己的项目来介绍这两种方式~ 1.feign实现springboot/springcloud的远程HTTP调用 参考博文:springboot feign使用 1.1 pom文件中添加相关...

    springboot项目间的远程调用,springboot本身封装了两种方法HTTP调用方式:
    1.feign的远程调用(http接口调用)
    2.RestTemplate
    下面参考别的博客我自己的项目来介绍这两种方式~


    1.feign实现springboot/springcloud间的远程HTTP调用

    参考博文:第一篇缺少调用方法。第二篇相对详细
    1.springboot feign使用
    2.Spring Boot 中使用Feign作为HTTP客户端调用远程HTTP服务


    Spring Cloud的Feign支持的一个中心概念就是命名客户端.Feign客户端使用@FeignClient注册组合成组件,按需调用远程服务器. Spring Cloud使用FeignClientsConfiguration创建一个新的集合作为每个命名客户端的ApplicationContext(应用上下文), 包含feign.Decoder,feign.Encoder和feign.Contract.

    你可以使用 Jersey 和 CXF 这些来写一个 Rest 或 SOAP 服务的java客服端。你也可以直接使用 Apache HttpClient 来实现。但是 Feign 的目的是尽量的减少资源和代码来实现和 HTTP API 的连接。通过自定义的编码解码器以及错误处理,你可以编写任何基于文本的 HTTP API。

    Feign 通过注解注入一个模板化请求进行工作。只需在发送之前关闭它,参数就可以被直接的运用到模板中。然而这也限制了 Feign,只支持文本形式的API,它在响应请求等方面极大的简化了系统。同时,它也是十分容易进行单元测试的。

    Spring Cloud应用在启动时,Feign会扫描标有@FeignClient注解的接口,生成代理,并注册到Spring容器中。生成代理时Feign会为每个接口方法创建一个RequetTemplate对象,该对象封装了HTTP请求需要的全部信息,请求参数名、请求方法等信息都是在这个过程中确定的,Feign的模板化就体现在这里。

    写了两个springboot项目,一个叫center-erp作为接口提供方(server),一个叫mt-task作为接口调用方(client)。

    • 1.1 首先是服务方center-erp,正常的写一个接受别的项目feign调用的公共controller层接口。
    import com.alibaba.fastjson.JSONObject;
    import lombok.Builder;
    import lombok.Data;
    import lombok.experimental.Accessors;
    
    @Data
    @Builder
    @Accessors(chain = true)//bean链式操作
    public class RequestJson {
    	//接口名称
        private String serverName;
        
    	//方法名称
        private String functionName;
        
        //请求参数,具体参数请查看对应接口
        private JSONObject jsonObject;
        
    }
    
    import com.base.entity.RequestJson;
    import com.taobao.txc.common.TxcContext;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    @RestController
    @RequestMapping("/center/erp")
    public class BaseController {
        private final static Logger LOGGER = LoggerFactory.getLogger(BaseController.class);
    
        @PostMapping("/requestDistribute")
        public ResponseJson requestDistribute(@RequestBody RequestJson requestJson) {
            try {
                LOGGER.info("***************************center-erp:requestJson={}", requestJson.toString());
                Object obj = SpringBeanUtil.getBean(requestJson.getServerName());
                if (null == obj) {
                    LOGGER.error("center-erp:请求接口不存在");
                    return ResponseUtil.getResponseMsg(RESPONSE_CODE_ERROR, "请求接口不存在");
                }
                JSONObject jsonObject = requestJson.getJsonObject();
               // String xid = jsonObject.getString("xid");
               // if (StringUtil.isNotEmpty(xid)) {
               //     LOGGER.info("事务xid={}", xid);
               //     TxcContext.bind(xid, null);
               // }
                Method method = obj.getClass().getDeclaredMethod(requestJson.getFunctionName(), new Class[]{JSONObject.class});
                ResponseJson responseJson = (ResponseJson) method.invoke(obj, requestJson.getJsonObject());
                LOGGER.info("*************************center-erp:responseJson={}", responseJson.toString());
                //if (StringUtil.isNotEmpty(xid)) {
                //    TxcContext.unbind();
                //}
                return responseJson;
            } catch (Exception e) {
                LOGGER.error("center-erp:请求执行异常=", e);
                return ResponseUtil.getResponseCode(RESPONSE_CODE_ERROR);
            }
        }
    }
    
    
    • 1.2 服务端封好,下面是客户端mt-task的实现

    mt-task为接口调用方,需要用到feign,因此pom中需引入相关feign包。
    之前是spring-cloud-starter-feign这个包名,但是现在你去maven看会发现,这个已经不推荐使用了,现在推荐用spring-cloud-starter-openfeign这个。

    <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    
    • 1.3 写一个service类.下面写了两个,一个是举例,一个是实例

    @FeignClient(name = “demo3”),name是你要调的那个服务的名字。fallback,这个属性是当你需要调的那个服务(本例里面的demo3)出问题了,就会走你fallback指定的实现类。
    举例:

    @FeignClient(name = "demo3",fallback = HelloServiceImpl.class)
    public interface HelloService {
         @RequestMapping(value = "/demo3/ans",method = RequestMethod.GET)
         String todo();
    }
    

    实例:
    在这里插入图片描述

    import com.alibaba.fastjson.JSONObject;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    /**
     * @author zhanglifeng
     */
    @FeignClient(value = "center-erp", fallback = CenterErpHystrix.class)
    public interface CenterErpClient {
        @RequestMapping(value = "/center/erp/requestDistribute", method = RequestMethod.POST)
        JSONObject requestDistribute(@RequestBody(required = false) JSONObject jsonObject);
    }
    
    import com.alibaba.fastjson.JSONObject;
    import org.springframework.stereotype.Component;
    
    /**
     * @author zhanglifeng
     */
    @Component
    public class CenterErpHystrix implements CenterErpClient {
        @Override
        public JSONObject requestDistribute(JSONObject jsonObject) {
            throw new RuntimeException("center_erp 服务异常!");
        }
    }
    

    封装调用center-erp的公共基础方法
    在这里插入图片描述

        @Override
        public JSONObject callCenterErp(ErpCenterMethod serverEnum, JSONObject jsonObject) {
            String serviceName = serverEnum.getServiceName();
            String functionName = serverEnum.getFunctionName();
            try {
                JSONObject json = new JSONObject();
                json.put("serverName", serviceName);
                json.put("functionName", functionName);
                json.put("jsonObject", jsonObject);
                long start = System.currentTimeMillis();
                jsonObject = centerErpClient.requestDistribute(json);
                long end = System.currentTimeMillis();
                LOGGER.info("调用center-erp:接口={},方法={},耗时={}", serviceName, functionName, String.valueOf(end - start));
            } catch (Exception e) {
                LOGGER.error("调用center-erp:接口={}方法={},异常={}", serviceName, functionName, e);
            }
            return jsonObject;
        }
    

    在mt-task的具体项目的地方调用center-erp项目的一个方法。

    
        @Override
        public JSONObject sendOrderToCqErp(String orderId, String orderType) throws Exception {
            JSONObject paramJson = new JSONObject();
            paramJson.put("orderId", orderId);
            paramJson.put("orderType", orderType);
            return callCenterErp(CQ_ERP_ORDER_SEND, paramJson);
        }
    

    上面便是feign调用的实例


    2.restTemplate实现springboot/springcloud间的远程HTTP调用

    • 2.1 RestTemplate介绍

    RestTemplate是spring框架中自带的rest客户端工具类,具有丰富的API,并且在spring cloud中,标记@LoadBalanced注解,可以实现客户端负载均衡的rest调用.
    由于RestTemplate为spring框架中自带的工具类。故不用专门在pom中引入依赖。我这里以项目中的实例来做demo 讲解。如下图大致知道是上面这个springboot项目调用下面用户中这个springboot项目。
    在这里插入图片描述
    2.2 首先是下面用户中心这个springboot项目的接口(提供方的接口层)

    /**
     * [用户操作接口]
     * @author zhanglifeng
     * @date 2019-03-20
     */
    @RestController
    @RequestMapping("/user")
    @Slf4j
    public class UserController {
        
        /**
         * [批量注册学生信息]
         * @param params
         * @return
         */
    
        @RequestMapping(value = "/batchSign",method = {RequestMethod.POST})
        public Result  batchSign(@RequestBody String params){
            log.info("UserController.addClassUser " + JSON.toJSONString(params));
            Map<String, Object> map = ParamUtil.parseParams(Map.class, params);
            Object paramsTemp = map.get("params");
            List<UserInfo> students = JSON.parseArray(JSON.toJSONString(paramsTemp), UserInfo.class);
            、、、、、
        }
    
    }
    

    2.3 接口调用方的代码。这里已经实例化注入了RestTemplate;,具体实现看2.4配置。

    /**
     * @Author: zhanglf
     * @Date: 2019/3/28 15:28
     * @Description: *
     */
    @RestController
    @RequestMapping("/classroom")
    @Slf4j
    public class ClassUserController {
    
        /**
         * 实例化RestTemplate
         */
        @Autowired
        private RestTemplate restTemplate;
    
     /**[批量导入学生信息]
         * @author zhanglf
         * @date 2019-04-18
         * @param params
         * @return
         */
        @RequestMapping(value = "/batchExportClassUser")
        public Result batchSignAndExportClassUser(@RequestBody String params) {
            log.info("ClassUserController.addClassUser " + JSON.toJSONString(params));
            Map<String, Object> map = ParamUtil.parseAndRequire(Map.class, params);
    		、、、、、、
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
            HttpEntity<String> entity = new HttpEntity<String>(JSON.toJSONString(map), headers);
            Result result = restTemplate.exchange(uri, HttpMethod.POST, entity, Result.class).getBody();
            
            log.info("调用接口回参strBody:{}",result);
            if(result.getCode()!=CodeMsg.SUCCESS.getCode()){
                log.info("调用批量注册异常:"+result.getMsg());
                throw new BizException(CodeMsg.CALL_API_FAILED.fillArgs("调用批量注册异常!"));
            }
    		、、、、、、
    
        }
    

    2.4 利用spring管理RestTemplate的实例。而不是通过new出一个RestTemplate对象来用。

    package com.zhanglf.catalog.config;
    
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.config.Registry;
    import org.apache.http.config.RegistryBuilder;
    import org.apache.http.conn.socket.ConnectionSocketFactory;
    import org.apache.http.conn.socket.PlainConnectionSocketFactory;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.client.ClientHttpRequestFactory;
    import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * @author zhanglf
     * @Description 自定义RestTemplate实例
     * @date 2019/4/17 11:40
     */
    @Configuration
    public class RestTemplateConfig {
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate(httpRequestFactory());
        }
    
        public ClientHttpRequestFactory httpRequestFactory() {
            return new HttpComponentsClientHttpRequestFactory(httpClient());
        }
    
        public HttpClient httpClient() {
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", SSLConnectionSocketFactory.getSocketFactory())
                    .build();
            PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry);
            //设置整个连接池最大连接数 根据自己的场景决定
            connectionManager.setMaxTotal(100);
            //路由是对maxTotal的细分
            connectionManager.setDefaultMaxPerRoute(100);
            RequestConfig requestConfig = RequestConfig.custom()
                    //服务器返回数据(response)的时间,超过该时间抛出read timeout
                    .setSocketTimeout(10000)
                    //连接上服务器(握手成功)的时间,超出该时间抛出connect timeout
                    .setConnectTimeout(5000)
                    //从连接池中获取连接的超时时间,超过该时间未拿到可用连接,
                    // 会抛出org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool
                    .setConnectionRequestTimeout(1000)
                    .build();
            return HttpClientBuilder.create()
                    .setDefaultRequestConfig(requestConfig)
                    .setConnectionManager(connectionManager)
                    .build();
        }
    }
    
    

    通过以上即可实现springboot服务远程接口调用。下面针对调用的代码部分具体说明:
    在这里插入图片描述
    下面这两张图分别是接口地址的值声明赋值和yml文件中的配置
    import org.springframework.beans.factory.annotation.Value;
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 服务接口调用:OpenFeign

    万次阅读 多人点赞 2021-01-30 19:53:45
    OpenFeign入门案例2.1、项目准备2.2、创建工程2.3、导入依赖2.4、编写配置2.5、主启动类2.6、编写实体2.7、编写接口2.8、调用接口2.9、最终测试第三章 OpenFeign超时控制3.1、超时控制介绍3.2、设置超时时间第四章 ...


    配套资料,免费下载
    链接:https://pan.baidu.com/s/1la_3-HW-UvliDRJzfBcP_w
    提取码:lxfx
    复制这段内容后打开百度网盘手机App,操作更方便哦

    第一章 OpenFeign介绍

    1.1、什么是OpenFeign

    OpenFeign为微服务架构下服务之间的调用提供了解决方案,OpenFeign是一种声明式、模板化的HTTP客户端。在Spring Cloud中使用OpenFeign,可以做到使用HTTP请求访问远程服务,就像调用本地方法一样的,开发者完全感知不到这是在调用远程方法,更感知不到在访问HTTP请求。

    1.2、为啥用OpenFeign

    OpenFeign可以用来简化HTTP的调用。

    1.3、Fegin与OpenFeign

    第二章 OpenFeign入门案例

    2.1、项目准备

    我们接下来的所有操作均是在Ribbon最后完成的工程上进行操作,相关代码请到配套资料中寻找。

    2.2、创建工程

    spring-cloud-study创建一个子项目名字叫:service-consumer9002

    2.3、导入依赖

    pom.xml

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <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.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>
    

    2.4、编写配置

    application.yaml

    server:
      port: 9002
    
    spring:
      application:
        name: service-consumer9002
    
    eureka:
      client:
        #是否将自己注册到注册中心,默认为 true
        register-with-eureka: false
        #表示 Eureka Client 间隔多久去服务器拉取注册信息,默认为 30 秒
        registry-fetch-interval-seconds: 10
        #设置服务注册中心地址
        service-url:
          defaultZone: http://root:123456@eureka-server7001.com:7001/eureka/,http://root:123456@eureka-server7002.com:7002/eureka/
    

    2.5、主启动类

    com.caochenlei.ServiceConsumer9002Application

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

    2.6、编写实体

    com.caochenlei.pojo.Product

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Product implements Serializable {
        private Integer pid;
        private String name;
        private Double price;
        private Integer count;
    }
    

    2.7、编写接口

    com.caochenlei.service.ProductFeignService

    @Component
    @FeignClient("SERVICE-PROVIDER")
    public interface ProductFeignService {
        /**
         * 编写技巧,直接把服务提供者那一端的控制器方法的两行拷贝过来,最后加一个分号就可以了,别的什么也不用动
         */
        @RequestMapping("/provider/product/findAll")
        public List<Product> findAll();
    
        @RequestMapping("/provider/product/findByPid")
        public String findByPid(@RequestParam("pid") Integer pid);
    }
    

    2.8、调用接口

    com.caochenlei.controller.ProductController

    @RestController
    public class ProductController {
        @Autowired
        private ProductFeignService productFeignService;
    
        @RequestMapping("/consumer/product/findAll")
        public List<Product> findAll() {
            return productFeignService.findAll();
        }
    
        @RequestMapping("/consumer/product/findByPid")
        public String findByPid(@RequestParam("pid") Integer pid) {
            return productFeignService.findByPid(pid);
        }
    }
    

    2.9、最终测试

    (1)依次启动以下注册中心:

    1. eureka-server7001
    2. eureka-server7002

    (2)依次启动以下服务提供者:

    1. service-provider8001
    2. service-provider8002

    (3)依次启动以下服务消费者:

    1. service-consumer9002

    (4)打开浏览器输入地址:http://localhost:9002/consumer/product/findAll

    (5)打开浏览器输入地址:http://localhost:9002/consumer/product/findByPid?pid=1

    第三章 OpenFeign超时控制

    3.1、超时控制介绍

    默认Feign客户端只等待一秒钟,如果服务端处理需要超过1秒钟,导致Feign客户端不想等待了,直接返回报错。

    为了避免这样的情况,有时候我们需要设置Feign客户端的超时控制。

    3.2、设置超时时间

    打开application.yaml,添加如下配置:

    ribbon:
      ReadTimeout:  5000
      ConnectTimeout: 5000
    

    第四章 OpenFeign日志打印

    4.1、日志打印介绍

    Feign提供了日志打印功能,我们可以通过配置来调整日志级别,从而了解Feign中Http请求的细节。

    简单来说,就是对Feign接口的调用情况进行监控和输出。

    4.2、日志打印级别

    • NONE:默认的,不显示任何日志。
    • BASIC:仅记录请求方法、URL、响应状态码及执行时间。
    • HEADERS:除了BASIC中定义的信息之外,还有请求和响应的头信息。
    • FULL:除了HEADERS中定义的信息之外,还有请求和响应的正文及元数据。

    4.3、开启日志打印

    4.3.1、编写配置对象

    com.caochenlei.config.FeignConfig

    @Configuration
    public class FeignConfig {
        @Bean
        Logger.Level feignLoggerLevel() {
            return Logger.Level.FULL;
        }
    }
    

    4.3.2、编写配置属性

    application.yaml

    logging:
      level:
        com.caochenlei.service: debug
    

    4.4、测试日志打印

    重启service-consumer9002,然后使用浏览器访问地址:http://localhost:9002/consumer/product/findByPid?pid=1

    展开全文
  • 六、服务接口调用OpenFeign

    万次阅读 2020-04-16 14:35:06
    服务接口调用框架openFeign的使用
  • 使用FeignClient实现微服务间接口调用

    千次阅读 2019-08-20 14:23:19
    首先,根据要调用服务接口: import com.sample.pass.distrition.model.ResultBody; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; ...
  • 1.场景还原 在多模块开发的...实现方案这里以笔者项目的订单模块远程调用状态机模块接口为例,仅供参考①订单模块的pom依赖&lt;dependency&gt; &lt;groupId&gt;io.github.openfeign&lt;/gro...
  • 天地图API及服务接口调用418错误

    万次阅读 热门讨论 2019-01-21 14:01:20
    天地图API及服务接口调用418错误 几个月前写的天地图API调用,今天发布一下竟然返回“418,抱歉,您的请求被拦截,因为您的请求疑似攻击行为!”,以为是ip被黑名单了,换了ip也不行,去官网才发现自2019年1月1日起...
  • 本地系统服务采用Binder进程通信库,Framework系统服务利用AIDL最简单(当然也可以自己写),但是他们都是基于Binder框架实现,所以他们的接口是可以相互调用的,这里分两种情况:C/C++层调用Framework层服务、java...
  • Java调用第三方接口示范

    万次阅读 多人点赞 2018-10-08 15:03:53
    在项目开发中经常会遇到调用第三方接口的情况,比如说调用第三方的天气预报接口。 使用流程 【1】准备工作:在项目的工具包下导入HttpClientUtil这个工具类,或者也可以使用Spring框架的restTemplate来调用,上面...
  • 解决springboot服务间Feign调用超时问题概述 起因 在完成项目功能需求的开发,经过自己测试以及通过测试组测试通过后,昨晚正式部署到线上环境进行正式运行前的最后一次的测试。但是在测试中,由A服务调用B服务接口...
  • 模块接口间三中调用方式

    千次阅读 2016-07-27 14:06:40
    异步消息的传递-回调机制 软件模块之间总是存在着一定的接口,从调用方式上...异步调用是一种类似消息或事件的机制,不过它的调用方向刚好相反,接口服务在收到某种讯息或发生某种事件时,会主动通知客户方(即调用
  • 接口调用超时

    万次阅读 2018-10-25 15:04:34
    假设A系统有个方法methodA,会调用B系统的methodB这个http接口,如果mehodA不追求超快的响应速度,那么你在调用methodB这个http接口时,可以增长超时时间,例如10秒超时。因为经常在某些时刻,由于网络原因或者系统...
  • 调用金蝶EAS系统提供的标准WebService接口或者二次开发提供的接口之前,都需要先调用登录接口。 下载登录接口对应的wsdl文件,生成客户端代码之后,调用实例如下(包路径根据实际情况修改): package ...
  • Webservice接口调用

    万次阅读 2019-03-09 16:07:58
    web service分两大类架构一种是基于soap协议的(wsdl结尾的接口),另外一种就是基于restful思想的,由于...1.先来看soap风格的webservice接口调用的步骤。 直接点击SOAP按钮–图里画出来了,弹出new soap proje...
  • WebService接口调用

    千次阅读 2017-11-02 10:40:01
    最近项目中有朋友咨询我webService接口的调用,在这里...一、webService接口调用工具类 public class WebService { private WebService() { throw new IllegalAccessError("CallWebServiceInterface class"); }
  • 假定系统管理微服务的实例名称为system, 在系统管理中查询码表 :/...在自己的微服务中调用系统管理的查询码表接口写法如下: DataDictionaryService @AuthorizedFeignClient(name ="system",fallback = Data...
  • 接口调用异常

    千次阅读 2019-01-21 11:17:05
    对于部分请求参数存在特殊字符的情况:  需要对参数进行UrlEncode处理。
  • 在eclipse中WebService服务接口调用方法

    千次阅读 2018-03-12 23:08:16
    第一步:下载apache-cxf压缩包,解压后生成一个文件,记住文件路径第二步:进入http://www.webxml.com.cn/zh_cn/index.aspx网站查找自己需要的服务,打开服务找到帮助文档,选择以wsdl结尾的地址复制到浏览器(以...
  • 如何跨服务调用后端接口
  • 不同springCloud项目互相调用接口

    万次阅读 2018-09-05 11:18:44
    有A,B两个springCloud项目,B项目的提供restful接口供A项目调用,B项目不在A的注册中心,其实跟普通的http接口调用方法一样 代码 A项目 1.调用接口类 public static String defaultConnection(String method, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,617,828
精华内容 1,047,131
关键字:

不同服务间的接口调用