SpringCloud-服务调用-OpenFeign

1. OpenFeign和Feign的区别

2019 年 Netflix 公司宣布 Feign 组件正式进入停更维护状态，于是 Spring 官方便推出了一个名为 OpenFeign 的组件作为 Feign 的替代方案。OpenFeign 全称 Spring Cloud OpenFeign，它是 Spring 官方推出的一种声明式服务调用与负载均衡组件，它的出现就是为了替代进入停更维护状态的 Feign。OpenFeign 是 Spring Cloud 对 Feign 的二次封装，它具有 Feign 的所有功能，并在 Feign 的基础上增加了对 Spring MVC 注解的支持，例如 @RequestMapping、@GetMapping 和 @PostMapping 等。

1.1 OpenFeign常用注解

@FeignClient 该注解用于通知 OpenFeign 组件对 @RequestMapping 注解下的接口进行解析，并通过动态代理的方式产生实现类，实现负载均衡和服务调用。
@EnableFeignClients 该注解用于开启 OpenFeign 功能，当 Spring Cloud 应用启动时，OpenFeign 会扫描标有 @FeignClient 注解的接口，生成代理并注册到 Spring 容器中。

1.2 Feign与OpenFeign的对比

相同点：

1. Feign 和 OpenFeign 都是 Spring Cloud 下的远程调用和负载均衡组件。
2. Feign 和 OpenFeign 作用一样，都可以实现服务的远程调用和负载均衡。
3. Feign 和 OpenFeign 都对 Ribbon 进行了集成，都利用 Ribbon 维护了可用服务清单，并通过 Ribbon 实现了客户端的负载均衡。
4. Feign 和 OpenFeign 都是在服务消费者（客户端）定义服务绑定接口并通过注解的方式进行配置，以实现远程服务的调用。

不同点：
5. Feign 和 OpenFeign 的依赖项不同，Feign 的依赖为 spring-cloud-starter-feign，而 OpenFeign 的依赖为 spring-cloud-starter-openfeign。
6. Feign 和 OpenFeign 支持的注解不同，Feign 支持 Feign 注解和 JAX-RS 注解，但不支持 Spring MVC 注解；OpenFeign 除了支持 Feign 注解和 JAX-RS 注解外，还支持 Spring MVC 注解。

2. 应用实战

我们这里用的是OpenFeign
user-service向order-service发起远程调用

2.1 user-service代码

1. 配置文件application.yml：

server:
    port: 8081
spring:
    application:
        name: user-service
eureka:
    client:
        service-url:
            defaultZone: http://localhost:8761/eureka
# feign只是帮你封装了远程调用的功能  底层还是ribbon 所以我们需要去修改ribbon的时间
ribbon:
    ReadTimeout: 3000 # 调用超时, 给3s超时时间
    ConnectTimeout: 3000 # 连接服务的超时时间
logging:
    level:
        com.powernode.feign.UserOrderFeign: debug  # 我需要答应这个接口下面的日志

2. 启动类加@EnableFeignClients

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.xinliushijian.feign"}) // 开启feign的客户端功能 才可以帮助我们发起调用
public class UserServiceApplication {

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

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    /**
     * 打印fein日志信息 级别
     * @return
     */
    @Bean
    public Logger.Level level(){
        return Logger.Level.FULL;
    }
}

3. controller

@RestController
public class UserController {

    /**
     * 接口是不能做事情的
     * 如果想做事 必须要有对象
     * 那么这个接口肯定是被创建出代理对象的
     * 动态代理 jdk(java interface 接口 $Proxy )  cglib(subClass 子类)
     * jdk动态代理 只要是代理对象调用的方法必须走 java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
     */
    @Autowired
    public UserOrderFeign userOrderFeign;

    /**
     * 总结
     * 浏览器(前端)-------> user-service(/userDoOrder)-----RPC(feign)--->order-service(/doOrder)
     * feign的默认等待时间时1s
     * 超过1s就在直接报错超时
     *
     * @return
     */
    @GetMapping("userDoOrder")
    public String userDoOrder() {
        System.out.println("有用户进来了");
        // 这里需要发起远程调用
        String s = userOrderFeign.doOrder();
        return s;
    }
}

4. 专门搞一个接口记录order-service的接口加@FeignClient(value = “order-service”)

/**
 * @FeignClient(value = "order-service")
 * value 就是提供者的应用名称
 */
@FeignClient(value = "order-service")
public interface UserOrderFeign {

    /**
     * 你需要调用哪个controller  就写它的方法签名
     * 方法签名(方法的整体，包含注解，就是包含一个方法的所有的属性)
     *
     * @return
     */
    @GetMapping("doOrder")
    String doOrder();
}

2.2 order-service代码

1. 配置文件application.yml：

server:
    port: 8080
spring:
    application:
        name: order-service
eureka:
    client:
        service-url:
            defaultZone: http://localhost:8761/eureka

2. 启动类

@SpringBootApplication
@EnableEurekaClient
public class OrderServiceApplication {

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

3. controller

@RestController
public class OrderController {
    @GetMapping("doOrder")
    public String doOrder(){
        try {
            // 模拟操作数据库等 耗时2s
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "心流时间 努力 奋斗+1";
    }
}

2.3 api工具向user-service发送请求,user-service再向order-service发起服务调用

3. 原理分析(手写feign)

3.1 为什么明明是对接口的调用，为什么现在直接调用方法即可实现呢？

那么肯定这个方法有代理，代理中实现了接口的调用。
按住alt建，鼠标左机，可以看到user-service中这个类会生成jdk动态代理类，对接口调用的实现就在代理类中。

jdk动态代理 只要是代理对象调用的方法必须走 java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])，所以我们获取代理类重写invoke方法即可改变调用的实现，就可以做到调用方法完成调用接口的功能

@RestController
public class UserController {
    public static void main(String[] args) {
        UserOrderFeign o = (UserOrderFeign)Proxy.newProxyInstance(UserController.class.getClassLoader(), new Class[]{UserOrderFeign.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        return "心流时间，通过代理重写o.doOrder()的实现";
                    }
                });
        // 走到这里就会走invoke方法，代理重写了逻辑
        String strResult = o.doOrder();
        System.out.println(strResult);
    }
}

3.2 手写feign

代码：

@SpringBootTest
class ApplicationTests {
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 手写feign的核心步骤
     */
    @Test
    void contextLoads() {
        UserOrderFeign o = (UserOrderFeign) Proxy.newProxyInstance(UserController.class.getClassLoader(), new Class[]{UserOrderFeign.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 能去拿到对方的ip和port 并且拿到这个方法上面的注解里面的值 那么就完事了
                GetMapping annotation = method.getAnnotation(GetMapping.class);
                String[] paths = annotation.value();
                String path = paths[0];
                Class<?> aClass = method.getDeclaringClass();
                FeignClient annotation1 = aClass.getAnnotation(FeignClient.class);
                String applicationName = annotation1.value();
                String url = "http://" + applicationName + "/" + path;
                String forObject = restTemplate.getForObject(url, String.class);
                return forObject;
            }
        });
        String s = o.doOrder();
        System.out.println(s);
    }
}

4. 总结

4.1 OpenFeign 用过吗？它是如何运作的？

在主启动类上加上@EnableFeignClients 注解后，启动会进行包扫描，把所有加了
@FeignClient(value=”xxx-service”)注解的接口进行创建代理对象通过代理对象，使用
ribbon 做了负载均衡和远程调用

4.2 如何创建的代理对象？

当 项 目 在 启 动 时 ， 先 扫 描 ， 然 后 拿 到 标 记 了 @FeignClient 注 解 的 接 口 信 息 ， 由
ReflectiveFeign 类的 newInstance 方法创建了代理对象 JDK 代理

4.3 OpenFeign 到底是用什么做的远程调用？

使用的是 HttpURLConnection （java.net）

4.4 OpenFeign 怎么和 ribbon 整合的？

在代理对象执行调用的时候