Spring-cloud （七）自定义HystrixCommand

前提

1、在继续学习Hystrix之前，向关注本人博客的各位致歉

由于之前的项目起名以及服务之间的名称不是很规范，所以我修改了这些名称方便后来的代码管理，这些代码可以在本人github中找到，这里贴出该项目地址https://github.com/HellxZ/SpringCloudLearn.git

2、如果不想使用最新的代码，也可以修改本来的代码，比较麻烦，再次致歉。

3、本文假设读者已经有了注册中心、服务提供者，本次修改处为上一文项目修改而得

本文内容

1、自定义HystrixCommand（非注解）

2、同步调用和异步调用的区别

3、通过注解实现异步调用

4、observe和toObserve方法简介

5、结语

自定义HystrixCommand

自定义HystrixCommand需要继承HystrixCommand类，想让这个自定义的熔断执行，需要使用这个熔断器的对象去执行（同步方法为execute，异步为queue），会自动调用自定义对象的run方法，你们的请求就放在run方法中。解释好了，看代码：

1、本地启动

自定义HystrixCommand：

package com.cnblogs.hellxz.hystrix;

import com.cnblogs.hellxz.entity.User;
import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandProperties;
import org.springframework.web.client.RestTemplate;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * @Author : Hellxz
 * @Description:
 * @Date : 2018/4/25 09:47
 */
public class UserCommand extends HystrixCommand<User> {

    private RestTemplate restTemplate;

    private Long id;

    public UserCommand(Setter setter, RestTemplate restTemplate, Long id){
        super(setter);
        this.restTemplate = restTemplate;
        this.id = id;
    }

    /**
     * 注意本地main方法启动，url请用http://localhost:8080/user
     * 通过controller请求启动需要改为服务调用地址：http://eureka-service/user
     */
    @Override
    protected User run() {
        //本地请求
//        return restTemplate.getForObject("http://localhost:8080/user", User.class);
        //连注册中心请求
        return restTemplate.getForObject("http://eureka-service/user", User.class);
    }

    /**
     * 此方法为《spirngcloud微服务实战》中的学习部分，仅用于在此项目启动的之后调用本地服务,但是不能没有走注册中心。
     * 书中为我们留下了这个坑，详情请直接翻阅151页。
     * 问题解决请参考：https://blog.csdn.net/lvyuan1234/article/details/76550706
     * 本人在书中基础上已经完成调用注册中心服务的功能，见RibbonService类中具体实现
     */
    public static void main(String[] args) {
        //同步请求
        User userSync=new UserCommand(com.netflix.hystrix.HystrixCommand.Setter.withGroupKey(
                HystrixCommandGroupKey.Factory.asKey("")).andCommandPropertiesDefaults(
                HystrixCommandProperties.Setter().withExecutionTimeoutInMilliseconds(5000)),
                new RestTemplate(),0L).execute();
        System.out.println("------------------This is sync request's response:"+userSync);
        //异步请求
        Future<User> userFuture = new UserCommand(com.netflix.hystrix.HystrixCommand.Setter.withGroupKey(
                HystrixCommandGroupKey.Factory.asKey("")).andCommandPropertiesDefaults(
                HystrixCommandProperties.Setter().withExecutionTimeoutInMilliseconds(5000)),
                new RestTemplate(),0L).queue();

        User userAsync = null;

        try {
            userAsync = userFuture.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("------------------This is async request's response:"+userAsync);
    }
}

上述代码中的main方法的作用？

在这个方法中没有用到spring容器，仅仅是把服务提供者当做一个普通的springboot项目，但是要只启动服务提供者，会因为没有注册中心报错。所以这回我们仅仅使用main方法调用一下服务提供者的接口。这里将//本地请求下方的代码打开，注掉//连注册中心请求下方的代码，启动main方法，输出如下：

16:10:24.252 [hystrix--1] DEBUG org.springframework.web.client.RestTemplate - Created GET request for "http://localhost:8080/user"
16:10:24.327 [hystrix--1] DEBUG org.springframework.web.client.RestTemplate - Setting request Accept header to [application/json, application/*+json]
16:10:24.374 [hystrix--1] DEBUG org.springframework.web.client.RestTemplate - GET request for "http://localhost:8080/user" resulted in 200 (null)
16:10:24.376 [hystrix--1] DEBUG org.springframework.web.client.RestTemplate - Reading [class com.cnblogs.hellxz.entity.User] as "application/json;charset=UTF-8" using [org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@4abb52c0]
------------------This is sync request's response:user:{name: hellxz, sex: male, phone: 123456789 }
16:10:24.506 [hystrix--2] DEBUG org.springframework.web.client.RestTemplate - Created GET request for "http://localhost:8080/user"
16:10:24.507 [hystrix--2] DEBUG org.springframework.web.client.RestTemplate - Setting request Accept header to [application/json, application/*+json]
16:10:24.516 [hystrix--2] DEBUG org.springframework.web.client.RestTemplate - GET request for "http://localhost:8080/user" resulted in 200 (null)
16:10:24.516 [hystrix--2] DEBUG org.springframework.web.client.RestTemplate - Reading [class com.cnblogs.hellxz.entity.User] as "application/json;charset=UTF-8" using [org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@7a61c025]
------------------This is async request's response:user:{name: hellxz, sex: male, phone: 123456789 }

Process finished with exit code 0

2、使用容器请求调用

这里将//本地请求下方的代码注掉， //连注册中心请求下方的代码

新增service包，创建RibbonService，这里把之后的代码一并粘过来了

package com.cnblogs.hellxz.servcie;

import com.cnblogs.hellxz.entity.User;
import com.cnblogs.hellxz.hystrix.UserCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.command.AsyncResult;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * @Author : Hellxz
 * @Description: Ribbon服务层
 * @Date : 2018/4/26 10:08
 */
@Service
public class RibbonService {

    private static final Logger logger = Logger.getLogger(RibbonService.class);
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 使用Hystrix注解，声明回调类，此方法为同步请求，如果不指定回调方法会使用默认
     */
    @HystrixCommand(fallbackMethod = "hystrixFallback")
    public String helloService(){
        long start = System.currentTimeMillis();
        //设置随机3秒内延迟，hystrix默认延迟2秒未返回则熔断，调用回调方法
        int sleepMillis = new Random().nextInt(3000);
        logger.info("----sleep-time:"+sleepMillis);

        try {
            Thread.sleep(sleepMillis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //调用服务提供者接口，正常则返回hello字符串
        String body = restTemplate.getForEntity("http://eureka-service/hello", String.class).getBody();
        long end = System.currentTimeMillis();
        logger.info("----spend-time:"+(end-start));
        return body;
    }

    /**
     * 调用服务失败处理方法：返回类型为字符串
     * @return “error"
     */
    public String hystrixFallback(){
        return "error";
    }

    /**
     * 使用自定义HystrixCommand同步方法调用接口
     */
    public User useSyncRequestGetUser(){
        //这里使用Spring注入的RestTemplate, Spring注入的对象都是静态的
        User userSync = new UserCommand(com.netflix.hystrix.HystrixCommand.Setter.withGroupKey(
                HystrixCommandGroupKey.Factory.asKey("")).andCommandPropertiesDefaults(
                        HystrixCommandProperties.Setter().withExecutionTimeoutInMilliseconds(5000)),
                restTemplate ,0L).execute();

        return userSync;
    }

    /**
     * 使用自定义HystrixCommand异步方法调用接口
     */
    public User useAsyncRequestGetUser(){

        Future<User> userFuture = new UserCommand(com.netflix.hystrix.HystrixCommand.Setter.withGroupKey(
                HystrixCommandGroupKey.Factory.asKey("")).andCommandPropertiesDefaults(
                        HystrixCommandProperties.Setter().withExecutionTimeoutInMilliseconds(5000)),
                restTemplate,0L).queue();

        User userAsync = null;

        try {
            //获取Future内部包含的对象
            userAsync = userFuture.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        return userAsync;
    }
}

这里RestTemplete对象是spring注入的，所以我们将此时可以写RibbonController了

package com.cnblogs.hellxz.controller;

import com.cnblogs.hellxz.entity.User;
import com.cnblogs.hellxz.servcie.RibbonService;
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.RestController;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * @Author : Hellxz
 * @Description: Ribbon消费者controller
 * @Date : 2018/4/20 10:07
 */
@RestController
@RequestMapping("hystrix")
public class RibbonController {

    @Autowired
    RibbonService service;

    @GetMapping("/invoke")
    public String helloHystrix(){
        //调用服务层方法
        return service.helloService();
    }

    /**
     * 发送同步请求，使用继承方式实现自定义Hystrix
     */
    @GetMapping("/sync")
    public User sendSyncRequestGetUser(){
        return service.useSyncRequestGetUser();
    }

    /**
     * 发送异步请求，使用继承方式实现自定义Hystrix
     */
    @GetMapping("/async")
    public User sendAsyncRequestGetUser(){
        return service.useAsyncRequestGetUser();
    }

}

启动这个项目（此项目为上一篇文中项目修改而来，详情见github），分别访问这下边两个接口，实测可以，这里就不贴了。

同步调用和异步调用的区别

上面说了那么多关于同步异步的说法，小伙伴们可别晕哦，本人理论不是很好，这里说说我的理解

我的理解:

同步调用：获取到结果直接返回并立即显示结果

异步调用：获取到结果，延迟直到调用，结果才显示

以本文举例，大家也可以试下异步的延迟加载，RibbonServcice中有这样一个方法useAsyncRequestGetUser这个方法中先接收到Future对象，其中的get方法不仅是返回User对象，还是调用这个异步的获取结果，查看这个get方法的源码，的确说是必要时加载

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     */
    V get() throws InterruptedException, ExecutionException;

本想设计个实验的，想到些却没成功，这个方法还有一个设置延迟时间的重载方法，有兴趣的可以留言交流一下

通过注解实现异步调用

扩充RibbonService，这里自定义了回调方法

    /**
     * 使用注解实现异步请求调用
     *
     * 注意：此处AsyncResult为netfix实现，spring也做了实现，注意导包。
     */
    @HystrixCommand(fallbackMethod = "fallbackForUserTypeReturnMethod")
    public Future<User> asyncRequest(){
        return new AsyncResult<User>(){
            public User invoke(){
                return restTemplate.getForObject("http://eureka-service/user", User.class);
            }
        };
    }

    /**
     * 调用服务失败处理方法：返回类型为User
     */
    public User fallbackForUserTypeReturnMethod(){
        return null;
    }

扩充RibbonController，调用上边的方法

    /**
     * 使用注解发送异步请求
     */
    @GetMapping("/annotationasync")
    public User sendAsyncRequestByAnnotation(){
        Future<User> userFuture = service.asyncRequest();
        try {
            return userFuture.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        return null;
    }

observe和toObserve方法简介

除了同步异步调用，还可以通过自定义HystrixCommand对象的observe方法和toObserve方法进行响应式编程，这两个方法都返回了一个Obserable对象

• observe命令在调用的时候会立即返回一个Observable对象。
• toObservable则不会立即返回一个Observable，订阅者调用数据的时候才会执行。

引用《springcloud 微服务》书中对这两个方法的解释：

observe()和toObservable虽然都返回了Observable，但是它们略有不同，前者返回的是一个Hot Observable,该命令会在observe()调用的时候立即执行，当Observable每次被订阅的时候会重放它的行为；而后者返回的是一个Cold Observable，toObservable执行之后，命令不会被立即执行，只有当所有订阅者都订阅它才会执行。

        //observe和toObservable方法
        UserCommand userCommand = new UserCommand(HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("")), new RestTemplate(),1L);
        Observable<User> observe = userCommand.observe();
        System.out.println("------------------This is observe's response:"+observe);
        Observable<User> userObservable = userCommand.toObservable();
        System.out.println("------------------This is toObserve's response:"+userObservable);

也可以使用注解的形式进行响应式编程

    /**
     * 注解实现Observable响应式开发
     */
    @HystrixCommand
    public Observable<User> observeByAnnotation() {
        return Observable.create(new Observable.OnSubscribe<User>() {
            @Override
            public void call(Subscriber<? super User> subscriber) {
                if (!subscriber.isUnsubscribed()) {
                    User user = restTemplate.getForObject("http://eureka-service/user", User.class);
                    subscriber.onNext(user);
                    subscriber.onCompleted();
                }
            }
        });
    }

注解中也可以添加参数来确定是通过observe()还是toObserable()

@HystrixCommand(observableExecutionMode = ObservableExecutionMode.EAGER)表示使用observe模式来执行
@HystrixCommand(observableExecutionMode = ObservableExecutionMode.LAZY)表示使用toObservable模式来执行

注意：测试的时候，区分本地启动与容器启动，报错找不到那个主机url就请修改UserCommand的run()注释行

结语

自定义Hystrix请求就先记这些了，还是注解方便些。

本文引用：

《springcloud 微服务实战》翟永超 著

通过继承HystrixCommand来创建请求命令遇到的问题