@HystrixCommand(fallbackMethod = "back")public String getHello(String id){return template.getForObject("http://helloclient/hello", String.class);}public String back(String id , Throwable e){if (e instanceof NullPointerException){return "client 2 has some error! NullPointerException";}else{return "client 2 has some error! Exception";}}

/*** Every {@link HystrixCommand} requests asks this if it is allowed to proceed or not.  It is idempotent and does* not modify any internal state, and takes into account the half-open logic which allows some requests through* after the circuit has been opened* * @return boolean whether a request should be permitted*/boolean allowRequest();/*** Whether the circuit is currently open (tripped).* * @return boolean state of circuit breaker*/boolean isOpen();/*** Invoked on successful executions from {@link HystrixCommand} as part of feedback mechanism when in a half-open state.*/void markSuccess();/*** Invoked on unsuccessful executions from {@link HystrixCommand} as part of feedback mechanism when in a half-open state.*/void markNonSuccess();/*** Invoked at start of command execution to attempt an execution.  This is non-idempotent - it may modify internal* state.*/boolean attemptExecution();

 @Overridepublic boolean isOpen() {//判断熔断器是否被强制打开，如果强制打开，返回true，表示熔断器已打开。circuitBreaker.forceOpen这个配置指定if (properties.circuitBreakerForceOpen().get()) {return true;}//判断熔断器是否被强制关闭。circuitBreaker.forceClosedif (properties.circuitBreakerForceClosed().get()) {return false;}//判断上一次断路器打开的时间是否大于零，访问成功，该值为-1，访问失败，该值为访问失败时的系统时间。根据是否大于零，判断熔断器是否打开。return circuitOpened.get() >= 0;}

@Overridepublic boolean attemptExecution() {//判断熔断器是否被强制打开，如果强制打开，返回false后，直接执行fallbackif (properties.circuitBreakerForceOpen().get()) {return false;}//判断熔断器是否被强制关闭if (properties.circuitBreakerForceClosed().get()) {return true;}//如果circuitOpened为-1，返回true，正常执行if (circuitOpened.get() == -1) {return true;} else {//如果circuitOpened不为-1，则表示断路器打开了，此时，服务会从circuitOpened起，休眠5秒（circuitBreaker.sleepWindowInMilliseconds配置，              //默认5000），直接返回false，执行fallback。若休眠时间超过5秒，并且当前熔断状态为打开状态，则会将熔断状态置为半开状态。如它的注释，只有第一个              //请求满足第一次为打开，之后的请求都为半开状态，返回false。if (isAfterSleepWindow()) {if (status.compareAndSet(Status.OPEN, Status.HALF_OPEN)) {//only the first request after sleep window should executereturn true;} else {return false;}} else {return false;}}}

 @Overridepublic void markSuccess() {//如果当前状态为半开，则将state设置成closed，关闭熔断器。如果之前由于断路器打开时，之后的请求，Hystrix会放开一个请求去尝试是否服务正常，并将断路器置为半开，           //如果正常，则将断路器关闭，并重置断路器。if (status.compareAndSet(Status.HALF_OPEN, Status.CLOSED)) {//This thread wins the race to close the circuit - it resets the stream to start it over from 0
                metrics.resetStream();Subscription previousSubscription = activeSubscription.get();if (previousSubscription != null) {previousSubscription.unsubscribe();}Subscription newSubscription = subscribeToStream();activeSubscription.set(newSubscription);circuitOpened.set(-1L);}}

 @Overridepublic void markNonSuccess() {//如果当前为半开状态，且请求失败，则重新打开断路器，将最近一次访问失败的时间置为当前时间。if (status.compareAndSet(Status.HALF_OPEN, Status.OPEN)) {//This thread wins the race to re-open the circuit - it resets the start time for the sleep window
                circuitOpened.set(System.currentTimeMillis());}}

 private Subscription subscribeToStream() {/** This stream will recalculate the OPEN/CLOSED status on every onNext from the health stream*/return metrics.getHealthCountsStream().observe().subscribe(new Subscriber<HealthCounts>() {@Overridepublic void onCompleted() {}@Overridepublic void onError(Throwable e) {}@Overridepublic void onNext(HealthCounts hc) {// check if we are past the statisticalWindowVolumeThreshold//检查时间窗内的请求总数小于配置文件中的数量（采用的是buckets，感兴趣的自己研究下）。默认时间窗为10S（metrics.rollingStats.timeInMilliseconds,metrics.rollingStats.numBuckets），默认请求总数为20(circuitBreaker.requestVolumeThreshold)。if (hc.getTotalRequests() < properties.circuitBreakerRequestVolumeThreshold().get()) {// we are not past the minimum volume threshold for the stat window,// so no change to circuit status.// if it was CLOSED, it stays CLOSED// if it was half-open, we need to wait for a successful command execution// if it was open, we need to wait for sleep window to elapse} else {//时间窗内，统计的错误（失败）请求比例是否小于配置比例，默认配置是50%，通过circuitBreaker.errorThresholdPercentage=50指定。if (hc.getErrorPercentage() < properties.circuitBreakerErrorThresholdPercentage().get()) {//we are not past the minimum error threshold for the stat window,// so no change to circuit status.// if it was CLOSED, it stays CLOSED// if it was half-open, we need to wait for a successful command execution// if it was open, we need to wait for sleep window to elapse} else {// our failure rate is too high, we need to set the state to OPEN//如果时间窗内请求数大于定义数，且失败比例大于定义比例，并且当前熔断器关闭的情况下，将熔断器置为打开，并将circuitOpened置为当前时间。if (status.compareAndSet(Status.CLOSED, Status.OPEN)) {circuitOpened.set(System.currentTimeMillis());}}}}});}

package com.example.demo;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;@EnableCircuitBreaker
@SpringBootApplication
@EnableEurekaClient
@ServletComponentScan
public class ConsumerApplication {@Bean@LoadBalancedRestTemplate template(){return new RestTemplate();}public static void main(String[] args) {SpringApplication.run(ConsumerApplication.class, args);}
}

package com.example.demo;import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;@WebFilter(filterName = "HystrixRequestContextServletFilter",urlPatterns = "/*",asyncSupported = true)
public class HystrixRequestContextServletFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {HystrixRequestContext context = HystrixRequestContext.initializeContext();try{chain.doFilter(request,response);}finally {context.shutdown();}}@Overridepublic void destroy() {}
}

package com.example.demo;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
public class ConsumerContorller {@AutowiredHystrixServer server;//注意，在这个controller中调用具有缓存功能的方法才会具备缓存效果。@RequestMapping("/hello")public String sayHello(){System.out.println("请求了一次hello2");server.getHello2("1","ibethfy");System.out.println("请求了二次hello2，不会打印hello2 initinized");server.getHello2("1","ibethfy");System.out.println("请求了三次hello2，清空缓存，会打印hello2 initinized");server.updateHello2("1","ibethfy");server.getHello2("1","ibethfy");System.out.println("请求了四次hello2，入参不同，会打印hello2 initinized");server.getHello2("1","ibethfy1");return server.getHello2("1","ibethfy1");}
}

package com.example.demo;import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import com.netflix.hystrix.contrib.javanica.cache.annotation.CacheKey;
import com.netflix.hystrix.contrib.javanica.cache.annotation.CacheRemove;
import com.netflix.hystrix.contrib.javanica.cache.annotation.CacheResult;
import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;@Service
public class HystrixServer {@AutowiredRestTemplate template;//通过指定生成缓存key的方法生成key，commandKey指定一个HystrixCommand的key，表示注解@HystrixCommand的方法的key。groupKey表示一个类型分组的key。threadPoolKey指定线程池的key。//fallbackMethod指定降级方法，commandProperties指定该HystrixCommand方法的参数，是个数组类型，里面的值是@HystrixProperty，多个用逗号隔开。@CacheResult(cacheKeyMethod = "generateCacheKey")@HystrixCommand(commandKey = "getHello1",groupKey = "getHello",threadPoolKey = "getHelloThreadPool",fallbackMethod = "back",commandProperties = {@HystrixProperty(name="execution.isolation.thread.timeoutinMilliseconds", value = "5000")})public String getHello1(){System.out.println("hello1 initinized");return template.getForObject("http://helloclient/hello", String.class);}private String generateCacheKey(){return "myHelloKey";}//若不指定cache的key，默认使用方法的所有参数作为key
    @CacheResult@HystrixCommand(commandKey = "getHello2",groupKey = "getHello",threadPoolKey = "getHelloThreadPool")public String getHello2(String id,String name){System.out.println("hello2 initinized");return template.getForObject("http://helloclient/hello", String.class);}//使用@CacheRemove在数据更新时，移除对应key的缓存，需要指定commandKey，@HystrixCommand里面的参数可以指定亦可以不用@CacheRemove(commandKey = "getHello2")@HystrixCommand(commandKey = "getHello2",groupKey = "getHello",threadPoolKey = "getHelloThreadPool")public void updateHello2(String id,String name){System.out.println("hello2 id = "+ id + ", name = "+ name + " removed");}//使用@CacheKey指定参数作为key
    @CacheResult@HystrixCommand(commandKey = "getHello3",groupKey = "getHello",threadPoolKey = "getHelloThreadPool")public String getHello3(@CacheKey("id") String id, String name){System.out.println("请求了一次hello3");return "hello3 " + id + name;}public String back(Throwable e){if (e instanceof NullPointerException){return "client 2 has some error! NullPointerException";}else{return "client 2 has some error! Exception";}}}