关于Feign的超时记录：

在Spring Cloud微服务架构中，大部分公司都是利用Open Feign进行服务间的调用，而比较简单的业务使用默认配置是不会有多大问题的，但是如果是业务比较复杂，服务要进行比较繁杂的业务计算，那后台很有可能会出现Read Timeout这个异常。

1、关于hystrix的熔断超时

如果Feign开启了熔断，必须要重新设置熔断超时的时间，因为默认的熔断超时时间太短了，只有1秒，这容易导致业务服务的调用还没完成然后超时就被熔断了。

如何配置熔断超时：

1. #Feign如何开启熔断

2. feign.hystrix.enabled=true

3.  

4. #是否开始超时熔断，如果为false，则熔断机制只在服务不可用时开启（spring-cloud-starter-openfeign中的HystrixCommandProperties默认为true）

5. hystrix.command.default.execution.timeout.enabled=true

6.  

7. #设置超时熔断时间（spring-cloud-starter-openfeign中的HystrixCommandProperties默认为1000毫秒）

8. hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=6000

注意：关于hystrix在application.properties配置是没提示的，但是HystrixCommandProperties是会获取的。

1. // 构造函数

2. protected HystrixCommandProperties(HystrixCommandKey key, HystrixCommandProperties.Setter builder, String propertyPrefix) {

3.  

4. // .... 省略很多其他配置

5.  

6. // propertyPrefix：hystrix，key：default

7. this.executionTimeoutInMilliseconds = getProperty(propertyPrefix, key, "execution.isolation.thread.timeoutInMilliseconds", builder.getExecutionIsolationThreadTimeoutInMilliseconds(), default_executionTimeoutInMilliseconds);

8. }

9.  

10. // 具体获取属性的方法

11. private static HystrixProperty<String> getProperty(String propertyPrefix, HystrixCommandKey key, String instanceProperty, String builderOverrideValue, String defaultValue) {

12. return HystrixPropertiesChainedProperty.forString().add(propertyPrefix + ".command." + key.name() + "." + instanceProperty, builderOverrideValue).add(propertyPrefix + ".command.default." + instanceProperty, defaultValue).build();

13. }

2、Feign局部设置超时间

 spring-cloud-dependencies Dalston版本之后，默认Feign对Hystrix的支持默认是关闭的，需要手动开启。

feign.hystrix.enabled=true

开启hystrix，可以选择关闭熔断或超时。
2.1关闭熔断：

1. # 全局关闭熔断：

2. hystrix.command.default.circuitBreaker.enabled: false

3. # 局部关闭熔断：

4. hystrix.command.<HystrixCommandKey>.circuitBreaker.enabled: false

2.2设置超时：

1. # 全局设置超时：

2. hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds: 1000

3. # 局部设置超时：

4. hystrix.command.<HystrixCommandKey>.execution.isolation.thread.timeoutInMilliseconds: 1000

2.3设置局部方法超时成功案例:

需要对下图两个方法局部设置超时时间为10秒,

 方法一、配置如下:

1. # 禁用Hystrix超时

2. hystrix.threadpool.default.coreSize = 10

3. hystrix.command.default.fallback.enabled = true

4. hystrix.command.default.execution.timeout.enabled= true

5. hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds = 3000

6. hystrix.command.MemberStaffFeign#getExcelDataByDoctor(String,Integer,Integer).execution.isolation.thread.timeoutInMilliseconds=10000

7. hystrix.command.MemberStaffFeign#getExcelDataByTeam(String,Integer,Integer).execution.isolation.thread.timeoutInMilliseconds=10000

8.  

@SpringBootApplication启动类中添加@EnableCircuitBreaker注解

1. @EnableFeignClients

2. @EnableEurekaClient

3. @EnableDiscoveryClient

4. @EnableApolloConfig

5. @EnableCircuitBreaker

6. @SpringBootApplication

7. public class BusinessSystemApplication {

8. public static void main(String[] args) {

9. ConfigurableApplicationContext app = new SpringApplicationBuilder(BusinessSystemApplication.class).run(args);

10. System.out.println(app.getEnvironment().getProperty("spring.application.name") + "服务启动完毕...");

11. }

12. }

2.4关闭超时

1. # 全局关闭：

2. hystrix.command.default.execution.timeout.enabled: false

3. # 局部关闭：

4. hystrix.command.<HystrixCommandKey>.execution.timeout.enabled: false

3、关于Ribbon超时。

Feign调用默认是使用Ribbon进行负载均衡的，所以我们还需要了解关于Ribbon的超时。

①、Feign的调用链路

看一下Feign的请求是否有使用Ribbon的超时时间，而且是如何读取Ribbon的超时时间的？

(1)、org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient#execute

(2)、com.netflix.client.AbstractLoadBalancerAwareClient#executeWithLoadBalancer(S, com.netflix.client.config.IClientConfig)

(3)、org.springframework.cloud.openfeign.ribbon.CachingSpringLoadBalancerFactory#create

1. ​创建Client，这里会判断对应ClientName的链接Client是否创建过，如果创建过复用之前的Client；

2. 如果不存在则创建一个并且放入cache缓存。

1. public FeignLoadBalancer create(String clientName) {

2. FeignLoadBalancer client = this.cache.get(clientName);

3. if(client != null) {

4. return client;

5. }

6. IClientConfig config = this.factory.getClientConfig(clientName);

7. ILoadBalancer lb = this.factory.getLoadBalancer(clientName);

8. ServerIntrospector serverIntrospector = this.factory.getInstance(clientName, ServerIntrospector.class);

9. // 判断是否有重试

10. client = loadBalancedRetryFactory != null ? new RetryableFeignLoadBalancer(lb, config, serverIntrospector,

11. loadBalancedRetryFactory) : new FeignLoadBalancer(lb, config, serverIntrospector);

12. this.cache.put(clientName, client);

13. return client;

14. }

(4)、com.netflix.client.AbstractLoadBalancerAwareClient#executeWithLoadBalancer(S, com.netflix.client.config.IClientConfig)

    ​负载均衡器抽象类

(5)、org.springframework.cloud.openfeign.ribbon.FeignLoadBalancer#execute

1. ​ Feign的负载均衡器实现类。到这里我们可以看到，连接超时和读超时的配置都在这里：

2. 如果application.properties配置文件中的超时时间不为空，则使用配置的超时时间。

3. 如果为空则使用默认值，而从FeignLoadBalancer的构造函数可以看到，默认值也是取的RibbonProperties的默认超时时间。

1. public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)

2. throws IOException {

3. Request.Options options;

4. // 设置超时时间。，如果orride的配置为空，则用默认值

5. if (configOverride != null) {

6. RibbonProperties override = RibbonProperties.from(configOverride);

7. options = new Request.Options(

8. override.connectTimeout(this.connectTimeout),

9. override.readTimeout(this.readTimeout));

10. }

11. else {

12. options = new Request.Options(this.connectTimeout, this.readTimeout);

13. }

14. // 发起请求

15. Response response = request.client().execute(request.toRequest(), options);

16. return new RibbonResponse(request.getUri(), response);

17. }

18.  

19. // 构造函数

20. public FeignLoadBalancer(ILoadBalancer lb, IClientConfig clientConfig, ServerIntrospector serverIntrospector) {

21. super(lb, clientConfig);

22. this.setRetryHandler(RetryHandler.DEFAULT);

23. this.clientConfig = clientConfig;

24. this.ribbon = RibbonProperties.from(clientConfig);

25. RibbonProperties ribbon = this.ribbon;

26. this.connectTimeout = ribbon.getConnectTimeout();

27. this.readTimeout = ribbon.getReadTimeout();

28. this.serverIntrospector = serverIntrospector;

29. }

②、Ribbon的默认超时时间

在RibbonClientConfiguration中：

1. public static final int DEFAULT_CONNECT_TIMEOUT = 1000;

2. public static final int DEFAULT_READ_TIMEOUT = 1000;

③、如何自定义Ribbon超时时间

首先，RibbonProperties的超时时间的读取的源码如下：

1. public Integer getConnectTimeout() {

2. return (Integer)this.get(CommonClientConfigKey.ConnectTimeout);

3. }

4.  

5. public Integer getReadTimeout() {

6. return (Integer)this.get(CommonClientConfigKey.ReadTimeout);

7. }

然后，可以在CommonClientConfigKey中可以看到两个超时时间的名称：

1. // ConnectTimeout:

2. public static final IClientConfigKey<Integer> ConnectTimeout = new CommonClientConfigKey<Integer>("ConnectTimeout") {};

3.  

4. // ReadTimeout:

5. public static final IClientConfigKey<Integer> ReadTimeout = new CommonClientConfigKey<Integer>("ReadTimeout") {};

然后，在IClientConfig的默认实现类：DefaultClientConfigImpl中，可以发现Ribbon配置的前缀

public static final String DEFAULT_PROPERTY_NAME_SPACE = "ribbon";

所以，最后Ribbon该这么配置超时时间：

1. ribbon.ConnectTimeout=5000

2. ribbon.ReadTimeout=5000

总结

1.如何配置好Hystrix和Ribbon的超时时间呢？

其实是有套路的,因为Feign的请求：其实是Hystrix+Ribbon。Hystrix在最外层，然后再到Ribbon，最后里面的是http请求。所以说。Hystrix的熔断时间必须大于Ribbon的 ( ConnectTimeout + ReadTimeout )。而如果Ribbon开启了重试机制，还需要乘以对应的重试次数，保证在Ribbon里的请求还没结束时，Hystrix的熔断时间不会超时。

1 变量

1.1 概念

可以改变的数，称为变量。在Java语言中，所有的变量在使用前必须声明。
一般通过“变量类型 变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;
变量的使用原则：就近原则,即尽量控制变量的使用范围到最小

1.2 局部变量

位置:定义在方法里或者方法的声明上
注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
生命周期:随着方法的调用而存在,方法运行完毕就释放了

1.3 成员变量

位置:定义在类里方法外
注意:不用初始化,也会自动被初始化成默认值
生命周期:整个类中,类消失了,成员变量才会释放

1.4 练习：变量的默认值测试

创建包: cn.tedu.basic
创建类: TestVariable1.java

package cn.tedu.design;
/*本类用于测试各种类型变量的默认值*/
public class TestVariable1 {
        static String name;
        static byte b;//整数类型默认值都是0
        static short c;
        static int d;
        static long e;
        static float f;//小数类型的默认值是0.0
        static double g;
        static char j;//char类型的默认值是\u0000
        static boolean h;//boolean类型的默认值是false

        public static void main(String[] args) {
            System.out.println(name);//null,引用类型的默认值
            System.out.println(b);
            System.out.println(c);
            System.out.println(d);
            System.out.println(e);
            System.out.println(f);
            System.out.println(g);
            System.out.println(h);
            System.out.println(j);
            System.out.println(h);
        }
    }

1.5 练习：局部变量与成员变量测试

创建包: cn.tedu.basic
创建类: TestVariable2.java

package cn.tedu.oop;
/**本类用于测试变量的使用*/
public class TestVariable2 {
    //2.定义成员变量:
    //1)位置:类里方法外
    //2)无需手动初始化,会自动赋予对应类型的默认值
    //3)作用域:在整个类中生效,类消失,变量才会消失
    static int count;
   
    //3.变量有一个使用的原则:就近原则
    static int sum = 200;
    public static void main(String[] args) {
        //1.定义局部变量:
        //1)位置:在方法里/局部代码块里
        //2)必须手动初始化
        //3)作用域:在方法/局部代码块中,对应的代码执行完局部变量就被释放
        int sum = 100;//定义在方法中的局部变量sum
        System.out.println(sum);//变量的就近原则:使用的都是自己附近的变量,100
        System.out.println(count);
       
        for (int i = 0; i < 10; i++) {//局部变量i只能在循环中使用
            System.out.println(i);
        }
        //System.out.println(i);//报错:无法引用变量i:i cannot be resolved to a variable
    }
}

2 方法

2.1 概述

被命名的代码块,方法可以含参数可以不含参数,可以提高代码的复用性。

2.2 方法定义的格式

2.3 方法调用顺序图

顺序执行代码,调用指定方法,执行完毕,返回调用位置

2.4 练习:测试方法的调用顺序/参数/返回值

创建包:cn.tedu.method
创建类:TestMethod .java

package cn.tedu.method;
/**本类用于测试方法*/
public class TestMethod {
	//1.创建程序的入口函数main()
	public static void main(String[] args) {
		System.out.println(1);
		/**2.我们通过方法名+参数列表的方式来调用方法的功能*/
		method1();//调用method1()
		System.out.println(2);
		method2(3);//调用method2()
		int result = method3(1,2);//调用method3()
		System.out.println(result);
	}

	/**3.如果方法想要返回值,必须修改返回值类型
	 * 并且return对应类型的结果
	 * 如果方法的返回值类型是void,不允许有返回值
	 * */
	/*本方法用来测试方法的返回值类型*/
	public static int method3(int i, int j) {
		/**4.通过return关键字将方法结果返回到调用位置*/
		return i+j;
	}

	/**1.方法的修饰符 方法的返回值类型 方法名(方法参数){方法体}*/
	/*method1()想测试方法的调用顺序*/
	public static void method1() {
		System.out.println(5);
		System.out.println(6);
		System.out.println(7);
	}
	
	/*本方法用来测试方法的参数,参数的位置在小括号里*/
	public static void method2(int a) {
		System.out.println("海绵宝宝今年:"+ a +"岁啦~");
	}	
}

2.5 方法的重载

方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.

2.6 练习：测试方法的重载

创建包: cn.tedu.method
创建类: TestMethodOverload.java

package cn.tedu.method;
/**本类用于测试方法的重载*/
public class TestMethodOverload {
	public static void main(String[] args) {
		/**1.我们根据方法名+参数列表确定具体调用哪个方法*/
		/**2.方法的重载:
		 * 在同一个类中,存在方法名相同,但参数列表不同的方法
		 * 如果在同类中,同名方法的参数个数不同,一定构成重载
		 * 如果在同类中,同名方法的参数个数相同,
		 * 需要查看对应位置上参数的类型,而不是参数名,与参数名无关
		 * (int a,String b)与(int b,String a)--不构成重载
		 * (int a,String b)与(String a,int b)--构成重载
		 * */
		//2.调用method()
		method();
		//4.调用method(int)
		method(666);
		//6.调用method(int,String)
		method(888,"泡泡");
	}

	//1.创建一个无参的method()
	public static void method() {
		System.out.println("哈哈哈哈我没参数");
	}
	//3.创建一个method(int n)
	public static void method(int n) {
		System.out.println("哈哈哈哈我的参数是:"+n);
	}
	//5.创建一个method(int n,String s)
	public static void method(int a,String b) {
		System.out.println(b+"今晚要干他"+a+"碗大米饭");
	}
	public static void method(String a,int b) {
		System.out.println(b+"今晚要干他"+a+"碗大米饭");
	}
}

3 拓展 成员变量与局部变量的区别

我们都知道java的内部类
局部内部类如果要去访问局部变量，那么局部变量必须声明为final类型。
具体可以看下java内部类介绍
也就是

public class demo {
    public static void main(String[] args) {
        doSomething();
    }

    private static void doSomething() {
        final String str1 = "Hello";
         String str2 = "World!";
        // 创建一个方法里的局部内部类
         class Test {
            public void out() {
                System.out.println(str1);
                 System.out.println(str2);
            }
        }
        Test test = new Test();
        test.out();

    }
}

这个方法在运行到 System.out.println(str2); 时候会报错
由于str2没有声明为final，编译抛出异常：Cannot refer to the non-final local variable str2 defined in an enclosing scope

但是现在运行的时候却发现成功了

感到十分的奇怪 于是查了下资料
得知 JDK1.8之后匿名内部类访问方法中的局部变量不用加final修饰

具体可以文档参考https://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html#accessing-members-of-an-enclosing-class