feign简单使用

JAVA 项目中接口调用

1）Httpclient

HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 Http 协议的客户端编程工具包，并且它支持 HTTP 协议最新版本和建议。

HttpClient 相比传统 JDK 自带的 URLConnection，提升了易用性和灵活性，使客户端发送 HTTP 请求变得容易，提高了开发的效率。

2）Okhttp

一个处理网络请求的开源项目，是安卓端最火的轻量级框架，由 Square 公司贡献，用于替代 HttpUrlConnection 和 Apache HttpClient。OkHttp 拥有简洁的 API、高效的性能，并支持多种协议（HTTP/2 和 SPDY）。

3）HttpURLConnection

HttpURLConnection 是 Java 的标准类，它继承自 URLConnection，可用于向指定网站发送 GET 请求、POST 请求。HttpURLConnection 使用比较复杂，不像 HttpClient 那样容易使用。

4）RestTemplate

RestTemplate 是 Spring 提供的用于访问 Rest 服务的客户端，RestTemplate 提供了多种便捷访问远程 HTTP 服务的方法，能够大大提高客户端的编写效率。

上面介绍的是最常见的几种调用接口的方法，我们下面要介绍的方法比上面的更简单、方便，它就是 Feign。

Feign 是一个声明式的 REST 客户端，它能让 REST 调用更加简单。Feign 供了 HTTP 请求的模板，通过编写简单的接口和插入注解，就可以定义好 HTTP 请求的参数、格式、地址等信息。

而 Feign 则会完全代理 HTTP 请求，我们只需要像调用方法一样调用它就可以完成服务请求及相关处理。

Spring Cloud 对 Feign 进行了封装，使其支持 SpringMVC 标准注解和 HttpMessageConverters。Feign 可以与 Eureka 和 Ribbon 组合使用以支持负载均衡。

在Spring Cloud中集成Feign

在 Spring Cloud 中集成 Feign 的步骤相当简单，首先还是加入 Feign 的依赖，代码如下所示。

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

 

在启动类上加 @EnableFeignClients 注解，如果你的 Feign 接口定义跟你的启动类不在同一个包名下，还需要制定扫描的包名 @EnableFeignClients（basePackages=“com.fangjia.api.client”），代码如下所示

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages = "com.fangjia.api.client")
public class FshSubstitutionServiceApplication {
public static void main(String[] args) {
SpringApplication.run(FshSubstitutionServiceApplication.class, args);
}
}

 

使用Feign调用接口

定义一个 Feign 的客户端，以接口形式存在，代码如下所示。

@FeignClient(value = "eureka-client-user-service")
public interface UserRemoteClient {
@GetMapping("/user/hello")
String hello();
}

 

首先我们来看接口上加的 @FeignClient 注解。这个注解标识当前是一个 Feign 的客户端，value 属性是对应的服务名称，也就是你需要调用哪个服务中的接口。

定义方法时直接复制接口的定义即可，当然还有另一种做法，就是将接口单独抽出来定义，然后在 Controller 中实现接口。

在调用的客户端中也实现了接口，从而达到接口共用的目的。我这里的做法是不共用的，即单独创建一个 API Client 的公共项目，基于约定的模式，每写一个接口就要对应写一个调用的 Client，后面打成公共的 jar，这样无论是哪个项目需要调用接口，只要引入公共的接口 SDK jar 即可，不用重新定义一遍了。

定义之后可以直接通过注入 UserRemoteClient 来调用，这对于开发人员来说就像调用本地方法一样。

接下来采用 Feign 来调用 /user/hello 接口，代码如下所示。

@Autowired
private UserRemoteClient userRemoteClient;
@GetMapping("/callHello")
public String callHello() {
//return restTemplate.getForObject("http://localhost:8083/house/hello",String.class);
//String result = restTemplate.getForObject("http://eureka-client-user-service/user/hello",String.class);
String result = userRemoteClient.hello();
System.out.println("调用结果：" + result);
return result;
}

 

通过跟注释掉的代码相比可以发现，我们的调用方式变得越来越简单了，从最开始的指定地址，到后面通过 Eureka 中的服务名称来调用，再到现在直接通过定义接口来调用。

简单案例：

首先定义一个公共的api，避免写swagger接口文档

1.定义接口：（用途是我将该接口打包，然后分发服务提供方和服务调用方，这样如果我在这里写的接口在服务方和调用方就可以实现，然后就不用写文档，你也可以知道每个接口的用途（如果你在定义接口时写了），只是每次需要打包，就比较麻烦，且服服务端和调用方试用版的版本要一致）

public interface UserHandler {

    User getUser();

    Map testMap();

    String putUser(User user);

}

2.install 该接口所在项目

api所在的项目mavenx项目标识

    <groupId>paic.common</groupId>
    <artifactId>user_api</artifactId>
    <version>1.0-SNAPSHOT</version>

3.在服务方和接口调用方引用该jar包

       <dependency>
            <groupId>paic.common</groupId>
            <artifactId>user_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

服务方 pom：

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>paic.provider</groupId>
    <artifactId>user_provider</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>paic.common</groupId>
            <artifactId>user_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

服务方可以实现这些接口：

@RestController
public class ProviderUserConreoller implements UserHandler {
    private AtomicInteger integer=new AtomicInteger();

    @RequestMapping("/getUser")
    @Override
    public User getUser() {
        integer.incrementAndGet();
        System.out.println("第："+integer.get()+" 次调用。。。");
        User user=new User();
        user.setAge(integer.get());
        user.setName("baier");
        user.setSchool("黄埔二中");
        try {
            System.out.println("进入睡眠");
            Thread.sleep(4000);
            System.out.println("睡眠结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return user;
    }
    @RequestMapping("/testMap")
    @Override
    public Map testMap() {
        return Collections.singletonMap("one","hahaha");
    }

    @RequestMapping("/putUser")
    @Override
    public String putUser(@RequestBody  User user) {
        System.out.println(user.getAge());
        System.out.println(user.getName());
        System.out.println(user.getSchool());
        return user.toString();
    }
}

服务调用方pom：

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>paic.common</groupId>
    <artifactId>user_api</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

调用方继承api信息（继承是因为可以自己定义一部分其他的接口，而不是全部都是公共接口中的东西，其实服务端也可以这样做）

@FeignClient(name = "user-provider")
public interface UserApi extends UserHandler {
    @RequestMapping("/getUser")
    User getUser();
    @RequestMapping("/testMap")
    Map testMap();
    @RequestMapping("/putUser")
    String putUser(User var1);
}

调用方调用：

@RestController
public class UserConsumer  {
    @Autowired
    private UserApi api;

    @GetMapping("/getUser")
    public User getUser() {
        System.out.println("getUser-------------");
        return api.getUser();
    }

    @GetMapping("/testMap")
    public Map testMap() {
        System.out.println("testMap-------------");
        return api.testMap();
    }

    @PostMapping("/putUser")
    public String putUser(@RequestBody User var1) {
        System.out.println("putUser-------------");
        return api.putUser(var1);
    }
}

使用postman调用：

 

 调用通过

 当有两个服务提供方的时候，会自定做负载均衡，这样如果光是查询的话没有问题，如果中间做其他操作就会有问题，比如中间向数据库中插入一条数据，就会插入两次

 比如启动两个项目，其中一个项目睡眠一段时间，会发现程序会掉用另一个服务中的东西，如下：

第一个服务睡眠

  try {
            System.out.println("进入睡眠");
            Thread.sleep(4000);
            System.out.println("睡眠结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

调用一次，发现两个服务都输出了东西

第一个：

 

 第二个没有睡眠：

 

 其实就是第一次访问到了第一台机器，但是由于业务调用时间太长（睡眠了），然后会去尝试调用其他的服务器（之前的调用还在继续），这样如果第二台调用成功了，就会返回快速返回结果，但事实上两个服务器上都执行了

 可以通过配置参数来处理尝试次数这些，如下：

#连接超时时间(ms)
#ribbon.ConnectTimeout=1000
#业务逻辑超时时间(ms)，如果超过会新启一个请求去调用，有可能继续打到该台机器上
#ribbon.ReadTimeout=2000
#同一台实例最大重试次数,不包括首次调用
#ribbon.MaxAutoRetries=3
#重试负载均衡其他的实例最大重试次数,不包括首次调用
#ribbon.MaxAutoRetriesNextServer=3
#是否所有操作都重试
#ribbon.OkToRetryOnAllOperations=false