1.首先看一下效果



2.默认的效果



3.修改注解不换行





4.修改全局变量和局部变量竖向对其

个人觉得修改后代码更容易阅读，代码风格可设置很多，可以根据自己的习惯自行设置 。

 

注意 ：设置完成后注解部分的格式直接按代码格式化快捷键无效，需重新插入代码

python的函数以及装饰器的使用，全局变量以及局部变量的访问
装饰器的使用，基于嵌套函数
全局以及局部变量的关键字的使用

装饰器的使用，基于嵌套函数
1.类似于spring的Aop切面编程

2.返回的值为函数

3.在需要的进行切面的方法上面加上函数的注解

代码如下
#装饰器以及嵌套函数
def user_log(level):
    def domain(func):
        def doreal(*args,**kwargs):
            print("方法执行之前我做的操作")
            func(*args,**kwargs)
            print('方法执行之后的操作')
        return doreal
    return domain

@user_log(level='123')
def kkk(name):
    print('我的名字是：{name}'.format(name=name))

kkk('kkk')


全局以及局部变量的关键字的使用
#全局变量以及局部变量的访问
gol='12344'
def func1():
    uni='5677'
    #声明要调用全局变量
    global gol
    print('打印全局变量:{gol}'.format(gol=gol))
    #声明调用函数内部的变量
    def fun2():
        nonlocal uni
        print('打印局部（函数内变量）：{uni}'.format(uni=uni))

    fun2()

func1()

1.hystrix的局部降级逻辑的处理方式

服务降级

前面两篇文章中，fallbackMethod所描述的函数实际上就是一个备胎，用来实现服务的降级处理，在注解中我们可以通过fallbackMethod属性来指定降级处理的方法名称，在自定义Hystrix请求命令时我们可以通过重写getFallback函数来处理服务降级之后的逻辑。使用注解来定义服务降级逻辑时，服务降级函数和@HystrixCommand注解要处于同一个类中，同时，服务降级函数在执行过程中也有可能发生异常，所以也可以给服务降级函数添加‘备胎’

异常处理

我们在调用服务提供者时有可能会抛异常，默认情况下方法抛了异常会自动进行服务降级，交给服务降级中的方法去处理，在自定义Hystrix请求命令的方式下，我们可以在getFallback方法中调用getExecutionException方法来获取抛出的异常
2.全局降级处理方式

　Springcloud开发微服务时，基于Feign来做声明式服务接口，当启用Hystrix服务熔断降级时，项目微服务众多，
每个Feign服务接口都得写一些重复性的服务降级处理代码，势必显得枯燥无味：
当服务较多时写这样重复的统一熔断降级处理显得十分枯燥无味！
前提场景是你的服务接口具有统一的报文格式，例如我的是Result或者PageResult，这样才有统一全局处理的可能，否则每个服务的fallback你是省不了的
本文将采用Cglib动态代理来统一处理这些fallback，说来容易做起来却十分棘手，完成这一功能，费了相当大的力气：
3.什么是熔断? 熔断有哪几种状态  断路器的工作原理

熔断手段：

隔离、限流、降级
隔离

GroupKey

CommandKey

ThreadPoolKey
限流

ExecutionIsolationStrategy设置策略

THREAD 线程池

SEMAPHORE 信号量（*）
降级

重写HystrixCommand父类 getFallback（）
原理图
是否缓存
是否用断路器
断路器恢复机制

在发生熔断后默认5秒后将状态改为半熔断（限定每次只能1个请求过来）

如果请求响应成功则结束熔断，如果失败则重新熔断
原理：命令模式    切面
Hystrix会将每一个依赖服务的调用成功，失败，拒绝，超时，等事件，都会发送给circuit breaker断路器。短路器就会对调用成功/失败/拒绝/超时等事件的次数进行统计。短路器会根据这些统计次数来决定，是否要进行短路，如果打开了短路器，那么在一段时间内就会直接短路，然后如果在之后第一次检查发现调用成功了，就关闭断路器
代码使用
一般用在拦截器中
4.如何开启熔断?

feign中开启熔断的书写步骤

/**   1、在pom.xml中引入依赖    2、在application.yaml中开启hystrix
 3、在方法上配置熔断类     4、书写接口的实现类

**/
//1、在pom.xml中引入依赖
<?xml version="1.0" encoding="UTF-8"?>




cloud-demo

com.hope.demo

1.0.0-SNAPSHOT



4.0.0
<artifactId>consumer-demo</artifactId>

<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>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
</dependencies>


//2、在application.yaml中开启hystrix
server:
  port: 8083
spring:
  application:
    name: consumer-service
eureka:
  client:
    service-url:
       defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka
    registry-fetch-interval-seconds: 30
  instance:
    prefer-ip-address: true
    ip-address: 127.0.0.1
user-service:
    ribbon:
      NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
hystrix:
     command:
         default:
             execution:
                isolation:
                   thread:
                      timeoutInMilliseconds: 6000
ribbon:
     ReadTimeout: 6000
     ConnectTimeout: 6000
feign:
     hystrix:
        enabled: true
//3、在方法上配置熔断类

package com.hope.Consumer.client;
import com.hope.Consumer.pojo.User;

import org.springframework.cloud.openfeign.FeignClient;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;
@FeignClient(value = “user-service”,fallback =  UserClientFallback.class )

public interface UserClient {

@GetMapping(“user/{id}”)

User queryById(@PathVariable(“id”) Long id);

}
//4、书写接口的实现类
package com.hope.Consumer.client;
import com.hope.Consumer.pojo.User;

import org.springframework.stereotype.Component;
@Component

public class UserClientFallback implements UserClient {

@Override

public User queryById(Long id) {

User user = new User();

user.setName(“未知用户”);

return user;

}

}
5.什么是网关? gateway 的核心概念

核心概念：
Route(路由)：路由是构建网关的基本模块，它由ID、目标URI，一系列的断言和过滤器组成，如果断言为true则匹配该路由
Predicate(断言)：参考的是Java8的java.util.function.Predicate

开发人员可以匹配HTTP请求中的所有内容(例如请求头或请求参数)，如果请求与断言相匹配则进行路由
Filter(过滤)：指的是Spring框架中GatewayFilyter的实例，使用过滤器，可以在请求被路由前或者之后进行修改
匹配方式就叫断言，实现这个匹配方式就叫filter，对外表现出来就是路由的功能。
6.如何简单使用gateway

目录
注解：
注解使用

注解：
* 概念：说明程序的。给计算机看的
* 注释：用文字描述程序的。给程序员看的

* 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
* 概念描述：
	* JDK1.5之后的新特性
	* 说明程序的
	* 使用注解：@注解名称
	

* 作用分类：
	①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
	②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
	③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】


* JDK中预定义的一些注解
	* @Override	：检测被该注解标注的方法是否是继承自父类(接口)的
	* @Deprecated：该注解标注的内容，表示已过时
	* @SuppressWarnings：压制警告
		* 一般传递参数all  @SuppressWarnings("all")

* 自定义注解
	* 格式：
		元注解
		public @interface 注解名称{
			属性列表;
		}

	* 本质：注解本质上就是一个接口，该接口默认继承Annotation接口
		* public interface MyAnno extends java.lang.annotation.Annotation {}

	* 属性：接口中的抽象方法
		* 要求：
			1. 属性的返回值类型有下列取值
				* 基本数据类型
				* String
				* 枚举
				* 注解
				* 以上类型的数组

			2. 定义了属性，在使用时需要给属性赋值
				1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
				2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
				3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
	
	* 元注解：用于描述注解的注解
		* @Target：描述注解能够作用的位置
			* ElementType取值：
				* TYPE：可以作用于类上
				* METHOD：可以作用于方法上
				* FIELD：可以作用于成员变量上
		* @Retention：描述注解被保留的阶段
			* @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
		* @Documented：描述注解是否被抽取到api文档中
		* @Inherited：描述注解是否被子类继承


* 在程序使用(解析)注解：获取注解中定义的属性值
	1. 获取注解定义的位置的对象  （Class，Method,Field）
	2. 获取指定的注解
		* getAnnotation(Class)
	3. 调用注解中的抽象方法获取配置的属性值

* 案例：简单的测试框架
* 小结：
	1. 以后大多数时候，我们会使用注解，而不是自定义注解
	2. 注解给谁用？
		1. 编译器
		2. 给解析程序用
	3. 注解不是程序的一部分，可以理解为注解就是一个标签

注解使用
现在有一个自定义类 要求检测其中方法是不是有错
public class Calculator {

    //加法
    @Check
    public void add(){
        String str = null;
        str.toString();
        System.out.println("1 + 0 =" + (1 + 0));
    }
    //减法
    @Check
    public void sub(){
        System.out.println("1 - 0 =" + (1 - 0));
    }
    //乘法
    @Check
    public void mul(){
        System.out.println("1 * 0 =" + (1 * 0));
    }
    //除法
    @Check
    public void div(){
        System.out.println("1 / 0 =" + (1 / 0));
    }

    public void show(){
        System.out.println("永无bug...");
    }

}

自定义注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}


编写测试类:
public class TestCheck {


    public static void main(String[] args) throws IOException {
        //1.创建计算器对象
        Calculator c = new Calculator();
        //2.获取字节码文件对象
        Class cls = c.getClass();
        //3.获取所有方法
        Method[] methods = cls.getMethods();

        int number = 0;//出现异常的次数
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));


        for (Method method : methods) {
            //4.判断方法上是否有Check注解
            if(method.isAnnotationPresent(Check.class)){
                //5.有，执行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕获异常

                    //记录到文件中
                    number ++;

                    bw.write(method.getName()+ " 方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称:" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因:"+e.getCause().getMessage());
                    bw.newLine();
                    bw.write("--------------------------");
                    bw.newLine();

                }
            }
        }

        bw.write("本次测试一共出现 "+number+" 次异常");

        bw.flush();
        bw.close();



    }

}

推荐视频