算法是**解决特定问题求解步骤的描述**，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。



## 1.算法

### 1.1 高斯求和

求 1+2+...99+100=?

```java
int sum = 0, n = 100;
for(int i = 1; i <= n; i++){
    sum += i;
}
System.out.println(sum);
```

高斯求和

```java
int sum = 0, n = 100;
sum = (1 + n) * n / 2;
System.out.println(sum);
```





### 1.2 算法的特性

#### 1.2.1 输入输出

- 有0个或多个输入
- 有1个或多个输出



#### 1.2.2 有穷性

**有穷性：指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可接受的时间内完成。**

*死循环不满足有穷性*



#### 1.2.2 确定性

**确定性：算法的每一步骤都具有确定的含义，不会出现二义性。**



#### 1.2.2 可行性

**可行性：算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成。**



### 1.3 算法设计的要求

#### 1.3.1 正确性

**正确性：算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性、能正确反映问题的需求、能够得到问题的正确答案。**

- 算法程序没有语法错误。
- 算法程序对于合法的输入数据能够产生满足要求的输出结果。
- 算法程序对于非法的输入数据能够得出满足规格说明的结果。
- 算法程序对于精心选择的，甚至刁难的测试数据都有满足要求的输出结果。

*第四层几乎不可达，无法去测试到所有数据，所以一般把是否满足到层次三作为一个算法是否正确的评判标准*



#### 1.3.2 可读性

**可读性：算法设计的另一目的是为了便于阅读、理解和交流。**



####  1.3.3健壮性

**健壮性：当输入数据不合法时，算法也能做出相关处理，而不是产生异常或莫名其妙的结果。**



#### 1.3.4时间效率高和存储量低

**设计算法应该尽量满足时间效率高和存储量低的需求。**





##　2. 算法的时间复杂度

在进行算法分析时，语句总的执行次数 T(n) 是关于问题规模 n 的函数，进而分析 T(n) 随 n 的变化情况并确定 T(n) 的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n) = O(f(n))。它表示随问题规模 n 的增大，算法执行时间的增长率和 f(n) 的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中 f(n) 是问题规模n的某个函数。

**分析算法的复杂度，关键就是要分析循环结构的运行情况。**



### 2.1 推导大 O 阶的方法

**步骤：**

1. 用常数1取代运行时间中的所有加法常数。
2. 在修改后的运行次数函数中，只保留最高阶项。
3. 如果最高阶项存在且不是1，则去除与这个项相乘的常数。



### 2.2 常数阶

对于分支结构而言，无论是真，还是假，执行的次数都是恒定的，不会随着 n 的变大而发生变化，所以单纯的分支结构（不包含在循环结构中），其时间复杂度也是 O(1)。

```java
int sum = 0, n = 100;
sum = (1 + n) * n / 2;  //执行1次
sum = (1 + n) * n / 2;  //执行1次
sum = (1 + n) * n / 2;  //执行1次
... // (无论多少个)
sum = (1 + n) * n / 2;  //执行1次
System.out.println(sum);
```

-> O(1)

### 2.3 线性阶

```java
int n = 100;
for(int i = 0; i < n; i++ ){
    // 执行时间复杂度 O(1)
}
```

-> O(n)



### 2.4 对数阶

```java
int count = 1;
while(count < n){
    count = count * 2;
    /* 时间复杂度为 O(1) 的程序步骤序列 */
}
```

求**时间复杂度**： 
$$
主要就是多少个 2 相乘后会大于 n，即 \\
从： 2^x = n \\
得： x = log_2n \\
所以时间复杂度为 O_{(n)} = log_2n
$$


### 2.5 平方阶

#### 2.5.1 常规

```java
for(int i = 0; i < m; i ++){
    for(int j = 0; j < n; j++){
        /* 时间复杂度为 O(1) 的程序步骤序列 */
    }
}
```

**时间复杂度：**
$$
O_{(n)} = O_{(n * m)} = O_{(n^2)}
$$


***由此总结***：**循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。**



#### 2.5.2 变形（1）

```java
for(int i = 0; i < m; i ++){
    for(int j = i; j < n; j++){ // 此处为 j = i 而非 j = 0
        /* 时间复杂度为 O(1) 的程序步骤序列 */
    }
}
```

**时间复杂度： **
$$
总执行次数为(高斯求和)： n + (n - 1) + (n -2) +...+ 1 = {(n + 1)*n\over 2} = {n^2 \over 2} + {n \over 2} \\
根据大O阶的推导方法2，只保留 {n^2 \over 2}  \\
根据大O阶的推导方法3，去除 {1 \over 2} 
所以最终得到时间复杂度为 O_{(n^2)}
$$


**其实理解大O推导不算难，难的是对数列的一些相关运算，这更多的是考察你的数学知识和能力**



### 2.6 常见的时间复杂度

| 阶          | 非正式术语 | 执行次数（举例）    |
| ----------- | ---------- | ------------------- |
| O(1)        | 常数阶     | 12                  |
| O(n)        | 线性阶     | 2n + 3              |
| O(n^2)      | 平方阶     | 3n^2 + 2n + 1       |
| O(logn)     | 对数阶     | 5log n + 20         |
| O(n long n) | nlog n 阶  | 2n + 3nlog n + 19   |
| O(n^3)      | 立方阶     | 6n^3 + 2n^2 + 3n +4 |
| O(2^n)      | 指数阶     | 2^n                 |

时间复杂度所耗费的时间从小到大依次是：
$$
O(1) < O(log_2n) < O(n) < O(nlog_2n) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
$$


### 2.7 最坏时间复杂度与平均时间复杂度

- **最坏时间复杂度：最坏情况运行时间是一种保证，那就是运行时间将不会再坏了。在应用中，这是一种最重要的需求，通常，除非特别指定，我们提到的运行时间都是最坏情况的运行**
- **平均时间复杂度：平均运行时间是所有情况中最有意义的，因为它是期望的运行时间。**

***一般在没有特殊说明的情况下，都是指最坏时间复杂度。***



## 3. 算法的空间复杂度

**算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作：S(n) = O(f(n))，其中，n 为问题的规模，f(n) 为语句关于 n 所占存储空间的函数。**

通常，我们都使用“时间复杂度”来指运行时间的需求，使用“空间复杂度”指空间需求。当不用限定词地使用“复杂度”时，**通常都是指时间复杂度**。

数据结构：算法

**程序 = 数据结构 + 算法**



## 1. 基本概念和术语

### 1.1 数据

**数据：是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识，并输入给计算机处理的符号集合。数据不仅仅包括整型、实型等数值类型，还包舌字符及声音、图像、视频等非数值类型。**

- 数据其实就是符号
  - 可以输入到计算机
  - 可以被计算机处理





### 1.2 数据元素

**数据元素：是组成数据的、有一定意义的基本单位，在计算机中通常作为整体处理。也被称为记录。**



### 1.3 数据项

**数据项：一个数据元素可以由若干个数据项组成。数据项是数据不可分割的最小单位。**

- 数据项是数据的最小单位。但真正讨论问题时，**数据元素**才是数据结构中建立数据模型的着眼点



### 1.4 数据对象

**数据对象：是性质相同的数据元素的集合，是数据的子集。**



### 1.5 数据结构

**数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。**



## 2. 逻辑结构和物理结构

### 2.1 逻辑结构

**逻辑结构：是指数据对象中数据元素之间的相互关系，主要分为四种**



#### 2.1.1 逻辑结构（1）：集合结构

**集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。**



#### 2.1.2 逻辑结构（2）：线性结构

**线性结构：线性结构中的数据元素之间是一对一的关系**



####　2.1.2 逻辑结构（3）：树形结构

树形结构：树形结构中的数据元素之间存在一种一对多的层次关系



#### 2.1.３ 逻辑结构（４）：图形结构

**图形结构：图形结构的数据元素是多对多的关系**

- 将每一个数据元素看做一个结点，用圆圈表示。
- 元素之间的逻辑关系用结点之间的连线表示，如果这个关系是有方向的，那么用带箭头的连线表示。



### 2.2 物理结构

**物理结构：是指数据的逻辑结构在计算机中的存储形式。**



#### 2.2.1 物理结构（1）：顺序存储结构

顺序存储结构：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的。



#### 2.2.2 物理结构（2）：链式存储结构

链式存储结构：是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的。





## 3. 抽象数据类型（ADT）

- **数据类型：是指一组性质相同的值的集合及定义在此集合上的一些操作的总称。**
- **抽象：是指抽取出事物具有的普遍性的本质。**

- **抽象数据类型（Abstract Data Type，ADT）：是指一个数学模型及定义在该模型上的一组操作。“抽象”的意义在于数据类型的数学抽象特性。**
- **抽象数据类型体现了程序设计中问题分解、抽象和信息隐藏的特性。**
-

数据结构：基础概念

# reference

## 1. 四种引用

### 1.1 强引用

**使用**：正常声明一个变量即为强引用

**GC**：不会被回收，引用指向 null 时中断关联，会导致 OOM



**src**

```java
    /**
     * vm 参数： -Xms20M -Xmx20M -Xmn10M -verbose:gc -XX:+PrintGCDetails
     * 强引用：
     * java.lang.OutOfMemoryError
     */
    public static void strongReference() {
        List<Object> list = new ArrayList<>();
        for (int i = 0; i < 21; i++) {
            list.add(new byte[1024 * 1024]);
        }
    }
```



**print**

```text
[GC (Allocation Failure) [PSYoungGen: 7295K->776K(9216K)] 7295K->5904K(19456K), 0.0118353 secs] [Times: user=0.05 sys=0.00, real=0.01 secs] 
[Full GC (Ergonomics) [PSYoungGen: 776K->0K(9216K)] [ParOldGen: 5128K->5785K(10240K)] 5904K->5785K(19456K), [Metaspace: 3489K->3489K(1056768K)], 0.0103363 secs] [Times: user=0.03 sys=0.00, real=0.01 secs] 
[Full GC (Ergonomics) [PSYoungGen: 7324K->3072K(9216K)] [ParOldGen: 5785K->9875K(10240K)] 13110K->12947K(19456K), [Metaspace: 3489K->3489K(1056768K)], 0.0128192 secs] [Times: user=0.03 sys=0.00, real=0.01 secs] 
[Full GC (Ergonomics) [PSYoungGen: 7481K->7168K(9216K)] [ParOldGen: 9875K->9875K(10240K)] 17357K->17044K(19456K), [Metaspace: 3489K->3489K(1056768K)], 0.0094613 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 7168K->7168K(9216K)] [ParOldGen: 9875K->9856K(10240K)] 17044K->17024K(19456K), [Metaspace: 3489K->3489K(1056768K)], 0.0101369 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
Heap
 PSYoungGen      total 9216K, used 7379K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 90% used [0x00000000ff600000,0x00000000ffd34d70,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
  to   space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
 ParOldGen       total 10240K, used 9856K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 96% used [0x00000000fec00000,0x00000000ff5a0210,0x00000000ff600000)
 Metaspace       used 3522K, capacity 4570K, committed 4864K, reserved 1056768K
  class space    used 391K, capacity 394K, committed 512K, reserved 1048576K
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at com.yui.study.reference.BaseUseReference.strongReference(BaseUseReference.java:32)
	at com.yui.study.reference.BaseUseReference.main(BaseUseReference.java:18)
```



### 1.2 软引用

**使用**：SoftReference<>

**GC**：如果内存足够，就不会被回收；如果内存不够用，会被回收。不会 OOM

**src**

```java
	/**
     * 软引用
     * 1.软引用，当GC的时候，如果GC Root可达，如果内存足够，就不会被回收；
     * 如果内存不够用，会被回收。不会 OOM
     * 2.应用于缓存。
     */
    public static void softReference() {
        List<SoftReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 21; i++) {
            SoftReference<byte[]> softReference = new SoftReference<>(new byte[1024 * 1024]);
            list.add(softReference);
            System.out.println("insert data:" + softReference.get());
        }
        // 触发 gc ，之后被回收，剩下未被回收的数据
        list.forEach(temp -> System.out.println("before gc:" + temp.get()));
        // 主动 gc 时，内存足够，数据没有变化
        System.gc();
        list.forEach(temp -> System.out.println("after gc:" + temp.get()));
    }
```

**print**

```text
insert data:[B@6d6f6e28
insert data:[B@135fbaa4
insert data:[B@45ee12a7
insert data:[B@330bedb4
insert data:[B@2503dbd3
[GC (Allocation Failure) [PSYoungGen: 7295K->696K(9216K)] 7295K->5824K(19456K), 0.0066160 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[Full GC (Ergonomics) [PSYoungGen: 696K->0K(9216K)] [ParOldGen: 5128K->5761K(10240K)] 5824K->5761K(19456K), [Metaspace: 3476K->3476K(1056768K)], 0.0198913 secs] [Times: user=0.05 sys=0.00, real=0.02 secs] 
insert data:[B@4b67cf4d
insert data:[B@7ea987ac
insert data:[B@12a3a380
insert data:[B@29453f44
insert data:[B@5cad8086
insert data:[B@6e0be858
insert data:[B@61bbe9ba
[Full GC (Ergonomics) [PSYoungGen: 7408K->3072K(9216K)] [ParOldGen: 5761K->9852K(10240K)] 13170K->12924K(19456K), [Metaspace: 3484K->3484K(1056768K)], 0.0175418 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 
insert data:[B@610455d6
insert data:[B@511d50c0
insert data:[B@60e53b93
insert data:[B@5e2de80c
[Full GC (Ergonomics) [PSYoungGen: 7543K->7192K(9216K)] [ParOldGen: 9852K->9852K(10240K)] 17396K->17044K(19456K), [Metaspace: 3490K->3490K(1056768K)], 0.0131124 secs] [Times: user=0.03 sys=0.00, real=0.01 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 7192K->0K(9216K)] [ParOldGen: 9852K->641K(10240K)] 17044K->641K(19456K), [Metaspace: 3490K->3490K(1056768K)], 0.0064228 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
insert data:[B@1d44bcfa
insert data:[B@266474c2
insert data:[B@6f94fa3e
insert data:[B@5e481248
insert data:[B@66d3c617
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:[B@1d44bcfa
before gc:[B@266474c2
before gc:[B@6f94fa3e
before gc:[B@5e481248
before gc:[B@66d3c617
[GC (System.gc()) [PSYoungGen: 7087K->224K(9216K)] 7728K->5993K(19456K), 0.0053839 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 224K->0K(9216K)] [ParOldGen: 5769K->5963K(10240K)] 5993K->5963K(19456K), [Metaspace: 4371K->4371K(1056768K)], 0.0242743 secs] [Times: user=0.00 sys=0.00, real=0.02 secs] 
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:[B@1d44bcfa
after gc:[B@266474c2
after gc:[B@6f94fa3e
after gc:[B@5e481248
after gc:[B@66d3c617
Heap
 PSYoungGen      total 9216K, used 224K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 2% used [0x00000000ff600000,0x00000000ff638230,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 5963K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 58% used [0x00000000fec00000,0x00000000ff1d2c88,0x00000000ff600000)
 Metaspace       used 4385K, capacity 4780K, committed 4992K, reserved 1056768K
  class space    used 494K, capacity 532K, committed 640K, reserved 1048576K

```







### 1.3 弱引用

**使用**：WeakReference<>

**GC**：只要发生GC，就会被回收。不会 OOM

**src**

```java
	/**
     * 弱引用
     * 1.软引用，只要这个对象发生GC，就会被回收。
     * 2.WeakHashMap
     * 3.ThreadLocalMap ThreadLocal
     * 4.Tomcat ConcurrentCache ConcurrentHashMap
     */
    public static void weakReference() {
        List<WeakReference<byte[]>> list = new LinkedList<>();
        for (int i = 0; i < 21; i++) {
            WeakReference<byte[]> weakReference = new WeakReference<>(new byte[1024 * 1024]);
            list.add(weakReference);
            System.out.println("insert data:" + weakReference.get());
        }
        // gc 之后已存在的全部被回收，剩下后边插入未被 gc 的数据
        list.forEach(temp -> System.out.println("before gc:" + temp.get()));
        // 主动 gc 之后全部被回收
        System.gc();
        list.forEach(temp -> System.out.println("after gc:" + temp.get()));
    }
```

**print**

```text
insert data:[B@6d6f6e28
insert data:[B@135fbaa4
insert data:[B@45ee12a7
insert data:[B@330bedb4
insert data:[B@2503dbd3
[GC (Allocation Failure) [PSYoungGen: 7295K->712K(9216K)] 7295K->720K(19456K), 0.0175392 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 
insert data:[B@4b67cf4d
insert data:[B@7ea987ac
insert data:[B@12a3a380
insert data:[B@29453f44
insert data:[B@5cad8086
insert data:[B@6e0be858
insert data:[B@61bbe9ba
[GC (Allocation Failure) [PSYoungGen: 8120K->728K(9216K)] 8128K->736K(19456K), 0.0018292 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
insert data:[B@610455d6
insert data:[B@511d50c0
insert data:[B@60e53b93
insert data:[B@5e2de80c
insert data:[B@1d44bcfa
insert data:[B@266474c2
insert data:[B@6f94fa3e
[GC (Allocation Failure) [PSYoungGen: 8273K->760K(9216K)] 8281K->768K(19456K), 0.0013182 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
insert data:[B@5e481248
insert data:[B@66d3c617
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:null
before gc:[B@5e481248
before gc:[B@66d3c617
[GC (System.gc()) [PSYoungGen: 4872K->952K(9216K)] 4880K->968K(19456K), 0.0018430 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 952K->0K(9216K)] [ParOldGen: 16K->862K(10240K)] 968K->862K(19456K), [Metaspace: 4376K->4376K(1056768K)], 0.0123685 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
after gc:null
Heap
 PSYoungGen      total 9216K, used 238K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 2% used [0x00000000ff600000,0x00000000ff63b998,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 862K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 8% used [0x00000000fec00000,0x00000000fecd7940,0x00000000ff600000)
 Metaspace       used 4386K, capacity 4780K, committed 4992K, reserved 1056768K
  class space    used 495K, capacity 532K, committed 640K, reserved 1048576K
```



### 1.4 虚引用

**使用**：ReferenceQueue，PhantomReference<>

**GC**：正常引用gc，当实例被回收时，会往关联的 ReferenceQueue 放入一个引用，通知实例被回收

**src**

```java
	public static void phantomReference() {
        ReferenceQueue<AccountDto> queue = new ReferenceQueue<>();
        List<byte[]> list = new ArrayList<>();

        String test01 = "测试对象1";
        AccountDto accountDto = new AccountDto();
        accountDto.setUsername("测试对象1");
        PhantomReference<AccountDto> reference = new PhantomReference<>(accountDto, queue);

        new Thread(() -> {
            while (true) {
                Reference<? extends AccountDto> poll = queue.poll();
                if (poll != null) {
                    System.out.println("############对象被回收了： " + poll.get());
                    break;
                }
            }

        }).start();


        new Thread(() -> {
            while (true) {
                list.add(new byte[1024 * 1024]);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
                AccountDto s = reference.get();
                System.out.println("正常输出:" + s);
            }
        }).start();
        // 是引用失效，让gc回收实例，触发通知
        accountDto = null;
        System.out.println("test-end");
        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.exit(1);
        }

    }
```



**print**

```text
test-end
正常输出:null
正常输出:null
[GC (Allocation Failure) [PSYoungGen: 7519K->1016K(9216K)] 7519K->3288K(19456K), 0.0151290 secs] [Times: user=0.05 sys=0.00, real=0.02 secs] 
############对象被回收了： null
正常输出:null
正常输出:null
正常输出:null
...
```

java中的引用

# kafka manager 使用说明

## 1.cluster

### 1.1 add cluster

- 填写截图如下 
![kafka-manager-addCluster02.jpg](https://hjl18.com/static/img/9de8643b039e2f5b62cd5e6356b98c5f.kafka-manager-addCluster02.webp)



- 其他参数说明

| 参数名                              | 参数说明                               | 默认值 | 备注                  |
| ----------------------------------- | -------------------------------------- | ------ | --------------------- |
| brokerViewUpdatePeriodSeconds       | Broker视图周期更新时间/单位（s）       | 30     |                       |
| clusterManagerThreadPoolSize        | 集群管理线程池大小                     | 2      |                       |
| clusterManagerThreadPoolQueueSize   | 集群管理线程池列队大小                 | 100    |                       |
| kafkaCommandThreadPoolSize          | kafka命令线程池大小                    | 2      |                       |
| kafkaCommandThreadPoolQueueSize     | kafka命令线程池列队大小                | 100    |                       |
| logkafkaCommandThreadPoolSize       | logkafka命令线程池大小                 | 2      |                       |
| logkafkaCommandThreadPoolQueueSize  | logkafka命令线程池列队大小             | 100    |                       |
| logkafkaUpdatePeriodSeconds         | Logkafka周期更新时间/单位（s）         | 30     |                       |
| partitionOffsetCacheTimeoutSecs     | Partition Offset缓存过期时间/单位（s） | 5      |                       |
| brokerViewThreadPoolSize            | Broker视图线程池大小                   | 8      | 3 * number_of_brokers |
| brokerViewThreadPoolQueueSize       | Broker视图线程池列队大小               | 1000   |                       |
| offsetCacheThreadPoolSize           | Offset缓存线程池大小                   | 8      |                       |
| offsetCacheThreadPoolQueueSize      | Offset缓存线程池列队大小               | 1000   |                       |
| kafkaAdminClientThreadPoolSize      | Kafka管理客户端线程池大小              | 8      |                       |
| kafkaAdminClientThreadPoolQueueSize | Kafka管理客户端线程池队列大小          | 1000   |                       |

### 1.2 Cluster List


![kafka-manager-addCluster04.jpg](https://hjl18.com/static/img/42522fcf23e7d598bff04cdc072a3749.kafka-manager-addCluster04.webp)
    

### 1.3 summary


![kafka-manager-addCluster05.jpg](https://hjl18.com/static/img/d3cf80adc459f126f6056a8db517fa59.kafka-manager-addCluster05.webp)


## 2. brokers
![kafka-manager-brokers01.jpg](https://hjl18.com/static/img/265eacc30d25d070373ce92fa3ce152c.kafka-manager-brokers01.webp)

## 3. topic

### 3.1 Create  
![kafka-manager-topic01.jpg](https://hjl18.com/static/img/bf372653361e9439c23ae27e70849662.kafka-manager-topic01.webp)

| 参数                           | 说明                                                         | 备注                                                         |
| ------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| Partitions                     | 分区，影响吞吐量，一个分区内消息先进先出，多个分区间随机读写 | 创建后不可修改                                               |
| Replication Factor             | 副本因子，需要大于min.insync.replicas，小于 broker 数量      | 创建后不可修改                                               |
| retention.ms                   | 数据保留时间，单位 ms                                        | kafka配置中有 log.retention.hours 进行默认配置               |
| max.message.bytes              | 消息的最大流                                                 |                                                              |
| segment.index.bytes            | 此配置是有关offsets和文件位置之间映射的索引文件的大小；一般不需要修改这个配置 | 索引文件，记录一条消息再log中的位置，文件满了之后会生成新的文件 |
| segment.bytes                  | log 日志存储块大小，kafka中log日志是分成一块块存储的，此配置是指log日志划分成块的大小 |                                                              |
| min.cleanable.dirty.ratio      | 此项配置控制log压缩器试图进行清除日志的频率。默认情况下，将避免清除压缩率超过50%的日志。这个比率避免了最大的空间浪费 |                                                              |
| min.insync.replicas            | 最小副本因子，只有当副本数>=min.insync.replicas，该 topic 才能进行正常的操作 |                                                              |
| delete.retention.ms            | 对于压缩日志保留的最长时间，也是客户端消费消息的最长时间，通log.retention.minutes的区别在于一个控制未压缩数据，一个控制压缩后的数据。此项配置可以在topic创建时的置顶参数覆盖 |                                                              |
| flush.messages                 | 此项配置指定时间间隔：强制进行fsync日志。例如，如果这个选项设置为1，那么每条消息之后都需要进行fsync，如果设置为5，则每5条消息就需要进行一次fsync。一般来说. | 建议你不要设置这个值。此参数的设置,需要在"数据可靠性"与"性能"之间做必要的权衡.如果此值过大,将会导致每次"fsync"的时间较长(IO阻塞),如果此值过小,将会导致"fsync"的次数较多,这也意味着整体的client请求有一定的延迟.物理server故障,将会导致没有fsync的消息丢失 |
| preallocate                    | 是否开启预分配功能                                           |                                                              |
| retention.bytes                | 如果使用“delete”的retention  策略，这项配置就是指在删除日志之前，日志所能达到的最大尺寸。默认情况下，没有尺寸限制而只有时间限制 |                                                              |
| flush.ms                       | 此项配置用来置顶强制进行fsync日志到磁盘的时间间隔；例如，如果设置为1000，那么每1000ms就需要进行一次fsync | 一般不建议使用这个选项                                       |
| cleanup.policy                 | 要么是”delete“要么是”compact“； 这个字符串指明了针对旧日志部分的利用方式；默认方式（"delete"）将会丢弃旧的部分当他们的回收时间或者尺寸限制到达时。”compact“将会进行日志压缩 |                                                              |
| file.delete.delay.ms           | 文件在索引中清除后的保留时间                                 | 一般不需要修改                                               |
| segment.jitter.ms              |                                                              |                                                              |
| index.interval.bytes           | 默认设置保证了我们每4096个字节就对消息添加一个索引，更多的索引使得阅读的消息更加靠近，但是索引规模却会由此增大； | 一般不需要改变这个选项                                       |
| compression.type               | producer用于压缩数据的压缩类型。                             | 默认是无压缩。正确的选项值是none、gzip、snappy。压缩最好用于批量处理，批量处理消息越多，压缩性能越好。 |
| segment.ms                     | 即使log的分块文件没有达到需要删除、压缩的大小，一旦log 的时间达到这个上限，就会强制新建一个log分块文件 |                                                              |
| unclean.leader.election.enable | 指明了是否能够使不在ISR中replicas设置用来作为leader          |                                                              |

### 3.2 List


![kafka-manager-topic02.jpg](https://hjl18.com/static/img/7f32c46c3369f2bcde14f69c5303ecc6.kafka-manager-topic02.webp)

### 3.3 one topic


![kafka-manager-topic04.jpg](https://hjl18.com/static/img/23ccd0cbbfe3b0773a035cb7d47f9357.kafka-manager-topic04.webp)

## 4.consumers

### 4.1 list 


![kafka-manager-consumers01.jpg](https://hjl18.com/static/img/35303bd4144bffeef814d8acd02436ac.kafka-manager-consumers01.webp)

### 4.2 one consumer


![kafka-manager-consumers02.jpg](https://hjl18.com/static/img/493367e4bcdea3efcd88edb297bc4161.kafka-manager-consumers02.webp)

kafka: kafka manager 使用说明

## 1. 拦截 rest 服务

### 1.1 过滤器（Filter）

#### 1.1.1 自定义过滤器

**自定义过滤器，只要实现Filter接口，并添加@Component注解即可**  



```
@Component
public class TimeFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("time filter init");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("time filter start");
        long startTime = System.currentTimeMillis();
        chain.doFilter(request, response);
        System.out.printf("耗时：%d \r\n", System.currentTimeMillis() - startTime);
        System.out.println("time filter finish");
    }

    @Override
    public void destroy() {
        System.out.println("time filter destroy");
    }
}
```

#### 1.1.2 第三方过滤器

**添加第三方过滤器，在配置类(@Configuration)中添加注入一个Bean(FilterRegistrationBea)，指定生效路径**  

```
@Configuration
public class WebConfig {
    @Bean
    public FilterRegistrationBean<TimeFilter> timeFilter(){
        FilterRegistrationBean<TimeFilter> registrationBean = new FilterRegistrationBean<>();
		// 设置过滤器
        TimeFilter timeFilter = new TimeFilter();
        registrationBean.setFilter(timeFilter);
		// 声明起作用的请求地址
        List<String> urls = new ArrayList<>(16);
        urls.add("/user/*");
        registrationBean.setUrlPatterns(urls);
        return registrationBean;
    }
}
```

#### 1.1.3 缺点

**在过滤器中只能获取到http请求数据，不能识别那个控制器处理当前请求**  

### 1.2 拦截器（Interceptor） 

#### 1.2.1 实现

需要实现HandlerInterceptor接口，并在配置类中进行注册  

**a.创建类，实现HandlerInterceptor接口，注册为一个组件(@Component)**

```
@Component
public class TimeInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 调用控制器之前
        System.out.println("preHandle");
        request.setAttribute("startTime", System.currentTimeMillis());
        System.out.println(((HandlerMethod)handler).getBean().getClass().getName());
        System.out.println(((HandlerMethod)handler).getMethod().getName());
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 调用控制器正常返回之后(异常时不调用)
        System.out.println("postHandle");
        Long startTime = (Long)request.getAttribute("startTime");
        System.out.println("postHandle Interceptor 耗时：" + (System.currentTimeMillis() - startTime));
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 调用控制器返回之后
        System.out.println("afterCompletion");
        Long startTime = (Long)request.getAttribute("startTime");
        System.out.println("afterCompletion Interceptor 耗时：" + (System.currentTimeMillis() - startTime));
    }
}
```

**b.配置类(@Configuration) 继承 WebMvcConfigurer接口，覆盖addInterceptors方法，用registry.addInterceptor(timeInterceptor) 添加拦截器**

```
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private TimeInterceptor timeInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(timeInterceptor);
    }

    @Bean
    public FilterRegistrationBean<TimeFilter> timeFilter(){
        FilterRegistrationBean<TimeFilter> registrationBean = new FilterRegistrationBean<>();
        TimeFilter timeFilter = new TimeFilter();
        registrationBean.setFilter(timeFilter);
        List<String> urls = new ArrayList<>(16);
        urls.add("/user/*");
        registrationBean.setUrlPatterns(urls);
        return registrationBean;
    }
}
```

**控制台打印**  

```
time filter start
preHandle
com.yui.study.security.demo.controller.UserController
getUserInfor
postHandle
postHandle Interceptor 耗时：435
afterCompletion
afterCompletion Interceptor 耗时：440
time filter 耗时：466 
time filter finish
```

#### 1.2.2 缺点

无法获取到调用方法的参数

#### 1.2.3 要记得点

handler可以获取访问的控制器的声明，为HandlerMethod实例
Exception ex 获取发生的异常

### 1.3 切片（Aspect）

#### 1.3.1 实现方式

**@Aspect 注解，声明作用范围（@Around）**

```
@Aspect
@Component
public class TimeAspect {
    @Around("execution(* com.yui.study.security.demo.controller.UserController.*(..))")
    public Object handleControllerMethod(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("aspect begin");
        long start = System.currentTimeMillis();
        // 获取参数
        for (Object arg : pjp.getArgs()) {
            System.out.println("arg is " + arg);
        }

        Object o = pjp.proceed();
        System.out.println("aspect end");
        System.out.println("aspect 耗时："+(System.currentTimeMillis() - start));
        return o;
    }
}
```

**控制台打印**  

```
time filter start
preHandle
com.yui.study.security.demo.controller.UserController$$EnhancerBySpringCGLIB$$2b45dbcf
getUserInfor
aspect begin
arg is 1
aspect end
aspect 耗时：6
postHandle
postHandle Interceptor 耗时：342
afterCompletion
afterCompletion Interceptor 耗时：348
time filter 耗时：375 
time filter finish

```

#### 1.3.2 范围控制注解

@Before() 调用方法之前
@After() 调用方法之后
@AfterThrowing 异常时
**@Around() 包含上述三种，一般使用这个**

#### 1.3.3 范围控制表达式，execution

详情可参考 [spring-framework官方文档](https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#aop)
**例子说明**

```
execution(* com.yui.study.security..*.*(..))
execution()： 表达式的主体asdFG
第一个“*”符号：表示返回值的类型任意
com.yui.study.security：	AOP所切的服务的包名，即，需要进行横切的业务类
包名后面的“..”：表示当前包及子包
第二个“*”：表示类名，*即所有类
.*(..)：表示任何方法名，括号表示参数，两个点表示任何参数类型
```

#### 1.3.4 缺点

获取不到原始的http请求

### 1.4 总结

**调用顺序**
filter -> Interceptor -> ControllerAdvice -> Aspect -> controllermark text

## 2. 异步处理 rest 服务

#### 2.1 Runnable 实现

**controller**

```
@RestController
public class AsyncController {
    private Logger logger =  LoggerFactory.getLogger(getClass());

    @RequestMapping("/order")
    public String test() throws InterruptedException {
        logger.info("主线程开始");
        Thread.sleep(10000);
        logger.info("主线程结束");
        return "SUCCESS";
    }
    @RequestMapping("/orderAsync")
    public Callable<String> test02() {
        logger.info("主线程开始");
        Callable<String> result = () -> {
            logger.info("副线程开始");
            Thread.sleep(10000);
            logger.info("副线程结束");
            return "SUCCESS";
        };
        logger.info("主线程结束");
        return result;

    }
}
```

**测试异步日志打印**

```
2018-12-06 15:22:08.137  INFO 14540 --- [nio-8081-exec-2] c.y.s.s.demo.async.AsyncController       : 主线程开始
2018-12-06 15:22:08.137  INFO 14540 --- [nio-8081-exec-2] c.y.s.s.demo.async.AsyncController       : 主线程结束
2018-12-06 15:22:08.140  WARN 14540 --- [nio-8081-exec-2] o.s.w.c.request.async.WebAsyncManager    : 
!!!
An Executor is required to handle java.util.concurrent.Callable return values.
Please, configure a TaskExecutor in the MVC config under "async support".
The SimpleAsyncTaskExecutor currently in use is not suitable under load.
-------------------------------
Request URI: '/orderAsync'
!!!
2018-12-06 15:22:08.145  INFO 14540 --- [      MvcAsync1] c.y.s.s.demo.async.AsyncController       : 副线程开始
2018-12-06 15:22:09.419  INFO 14540 --- [nio-8081-exec-4] c.y.s.s.demo.async.AsyncController       : 主线程开始
2018-12-06 15:22:09.419  INFO 14540 --- [nio-8081-exec-4] c.y.s.s.demo.async.AsyncController       : 主线程结束
2018-12-06 15:22:09.421  INFO 14540 --- [      MvcAsync2] c.y.s.s.demo.async.AsyncController       : 副线程开始
2018-12-06 15:22:18.146  INFO 14540 --- [      MvcAsync1] c.y.s.s.demo.async.AsyncController       : 副线程结束
2018-12-06 15:22:19.422  INFO 14540 --- [      MvcAsync2] c.y.s.s.demo.async.AsyncController       : 副线程结束
```

**警告内容是需要一个线程池来处理多线程**

```
@Configuration
public class WebConfig implements WebMvcConfigurer {

    private ThreadPoolTaskExecutor getAsyncExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(30);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("ronnie-task-");
        executor.initialize();
        return executor;
    }

    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        configurer.setTaskExecutor(getAsyncExecutor());
        WebMvcConfigurer.super.configureAsyncSupport(configurer);
    }
}
```

### 2.2 DeferredResult 实现

### 2.3 异步拦截器

```
	@Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        configurer.setTaskExecutor(getAsyncExecutor());
        configurer.registerCallableInterceptors();
        configurer.registerDeferredResultInterceptors();
        WebMvcConfigurer.super.configureAsyncSupport(configurer);
    }
```

## 3. 前后端分离工具

### 3.1 Swagger自动生成html文档(springfox)

#### 3.1.1 引入Swagger

**pom.xml**

```
		
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
```

**程序入口添加 @EnableSwagger2 注解**  

```
@SpringBootApplication
@EnableSwagger2
public class DemoApplication {
    /**
     * 启动入口
     * @param args
     */
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
```

#### 3.1.2 常用注解

**@ApiModelProperty("用户id")** ： 参数为对象时使用，注解在对象的属性上
**@ApiParam("用户id")** ： 参数为基本数据类型是使用，注解在参数前，如：

```
public User getUserInfor(@ApiParam("用户id") @PathVariable Long id){
	...
}
```

**@ApiOperation("用户信息查询服务")** 注解在方法上，修改方法默认名称


### 3.2 WireMock快速伪造RESTful服务