Spring Cloud(三)声明式服务调用Feign

Spring Cloud的另一种服务消费者Feign。

Feign简介

Feign是一个声明式的伪Http客户端，它使得写Http客户端变得更简单。使用Feign，只需要创建一个接口并注解。它具有可插拔的注解特性，可使用Feign 注解和JAX-RS（JAX-RS是JAVA EE6 引入的一个新技术。提供了一些注解将一个资源类，一个POJO Java类，封装为Web资源。如：@GET，@PUT，@POST，@DELETE，标注方法是HTTP请求的类型。）注解。Feign支持可插拔的编码器和解码器。Feign默认集成了Ribbon，并和Eureka结合，默认实现了负载均衡的效果。

概念性的东西讲起来比较枯燥，还是动手操作吧！

为了能够更加清晰的展现Feign对服务的调用，这里会新建一个管理员服务，用户服务还是用的上一篇博文的。不明白的朋友，可以看上一篇博文。

服务消费者Feign

假设业务场景：管理员需要查询用户的信息，所以需要调用用户服务。

管理员服务

新建一个管理员服务，命名为：admin-service。至于创建子模块的过程，这里就省略了。
pom文件中导入相应的约束：

pom.xml

<?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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.root.project</groupId>
    <artifactId>admin-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>admin-service</name>
    <packaging>jar</packaging>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>com.root.project</groupId>
        <artifactId>springcloud-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <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>
        <!-- feign的依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

接下来需要对启动类进行修改，加上@EnableFeignClients注解，表明开启Feign功能。

AdminServiceApplication

package com.root.project.adminservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
@EnableEurekaClient
public class AdminServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(AdminServiceApplication.class, args);
    }

}

然后同样需要在配置文件中进行配置，指明注册中心。

application.yml

spring:
  application:
    name: admin-service


server:
  port: 9100


#指定注册中心
eureka:
  client:
    service-url:
      defaultzone: http://localhost:8761/eureka/

基本上配置相关的操作就完成了，因为Feign采用接口的方式进行服务的调用，所以，先定义一个接口。

UserClient

package com.root.project.adminservice.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * @ClassName: UserClient
 * @Author: 清风一阵吹我心
 * @Description: TODO  加入注解，指定需要调用的服务名称
 * @Date: 2019/1/27 15:13
 * @Version 1.0
 **/
@FeignClient(name = "user-service")
public interface UserClient {

    /**
     * 调用用户接口，查询用户信息，让其返回字符串
     * @param userId
     * @return
     */
    @GetMapping("/api/v1.0/user/{userId}")
    String findUserById(@PathVariable("userId")Long userId);
}

因为用户服务的这个接口，返回的是一个用户对象。但是在管理员服务中，没有用户的实体类，所以，就用String类型来接收返回值，然后使用Json工具类对其进行解析。
@FeignClient这个注解，指定了需要调用哪个服务。
注意：服务名称一定要写正确。
@GetMapping注解，就和控制层发起Get请求一样。这里需要指明用户服务提供接口的地址。一定要和那边的URL一样。包括其中的参数。然后，在服务层调用接口中的方法。

AdminService

package com.root.project.adminservice.service;

import com.root.project.adminservice.pojo.Admin;

/**
 * @ClassName: AdminService
 * @Author: 清风一阵吹我心
 * @Description: TODO
 * @Date: 2019/1/27 15:20
 * @Version 1.0
 **/
public interface AdminService {

    /**
     * 查询用户
     * @param uId
     */
    Admin save(Long uId);
}

创建接口的实现类

AdminServiceImpl

package com.root.project.adminservice.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.common.util.JsonUtil;
import com.root.project.adminservice.pojo.Admin;
import com.root.project.adminservice.service.AdminService;
import com.root.project.adminservice.service.UserClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @ClassName: AdminServiceImpl
 * @Author: 清风一阵吹我心
 * @Description: TODO
 * @Date: 2019/1/27 15:20
 * @Version 1.0
 **/
@Service
public class AdminServiceImpl implements AdminService {

    private static final Logger LOGGER = LoggerFactory.getLogger(AdminServiceImpl.class);

    @Autowired
    private UserClient userClient;

    @Override
    public Admin save(Long uId) {
        String user = userClient.findUserById(uId);
        JSONObject object = JsonUtil.jsonToObject(user);
        LOGGER.info("object:{}", object);
        Admin admin = new Admin();
        admin.setAdminName("清风一阵吹我心");
        admin.setAdminPwd("111111");
        admin.setObject(object.get("data"));
        return admin;
    }
}

把UserClient接口进行注入，调用接口中的方法，即可拿到需要的值。这里我抽取了一个解析Json的工具类，其中只有一个方法，就是将Json字符串转换为对象。因为，返回的是一个统一的ResultBean，所以，这里用了admin.setObject()来接收解析后返回的值，里面直接是一个用户对象。

JsonUtil

package com.common.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

/**
 * @ClassName: JsonUtil
 * @Author: 清风一阵吹我心
 * @Description: TODO
 * @Date: 2019/1/27 15:32
 * @Version 1.0
 **/
public class JsonUtil {

    /**
     * 将json字符串转换成对象
     * @param str
     * @return
     */
    public static JSONObject jsonToObject(String str){
        return JSON.parseObject(str);
    }
}

这里使用了阿里的fastjson，需要导入相关的约束，如有需要，将下面的约束复制到父工程中的pom文件中即可。

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>

最后，编写一个测试接口，来测试结果。

AdminController

package com.root.project.adminservice.controller;

import com.common.bean.Result;
import com.common.util.ResultBean;
import com.root.project.adminservice.service.AdminService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName: AdminController
 * @Author: 清风一阵吹我心
 * @Description: TODO
 * @Date: 2019/1/27 15:39
 * @Version 1.0
 **/
@RestController
@RequestMapping("/api/v1.0")
public class AdminController {

    @Autowired
    private AdminService adminService;

    @GetMapping(value = "/admin")
    public Result save(@RequestParam("userId") Long userId) {
        return ResultBean.success("查询成功", adminService.save(userId));
    }
}

这里写的简单，直接返回对象，逻辑那些都是根据自己的需求定义的。
接下来就可以启动服务看结果了。启动注册中心：eureka-server、用户服务：user-service、管理员服务：admin-service

访问地址：http://localhost:9100/api/v1.0/admin?userId=1

结果如上图，证明Feign成功调用了用户服务，然后扩展一些知识。
开篇说了Feign默认集成Ribbon，所以，使用的也是Ribbon的负载均衡策略。这里我就不测试了，感兴趣的朋友可以多启动几个用户服务，自行测试。上一篇博文中讲了如何修改负载均衡策略，这里同样给出修改所需的配置：

#自定义负载均衡策略
user-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

在理想的环境下，你调用任何服务，都能得到相应的响应。但是，打破这个环境，现在服务超时，就会抛出异常。那么该怎么解决这个问题呢？官网同样给我们提供了解决办法。同样是修改配置文件。

#设置调用超时时间
feign:
  client:
    config:
      default:
        connectTimeout: 2000
        readTimeout: 2000

这里可以设置超时时间，只要在范围内响应，都是服务正常。

在2秒之内给客户响应，被用户认为是“非常有吸引力”的用户体验。所以，服务响应应该控制在2秒内。大家可以自定义场景来测试超时现象。这里就给大家讲一下Feign的基础用法。至于深层次的东西，还是建议大家去看官方文档。

你说自己很弱，是啊，你很弱！你那么弱，为何不去变强试试？所以，我要变强，我要努力！