lostecho/Hui-s-notebook
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add logseq-java

Browse Source
This commit is contained in:
Lostecho
2024-02-02 00:12:49 +08:00
parent 1cd5bb460f
commit c7947017c3
875 changed files with 57100 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
logseq-java/journals/2022_03_28.md Normal file
View File

@@ -0,0 +1,47 @@
- [[计算机基础理论]]
- [[DOS命令]]
- [[windows快捷键]]
- [[Java发展历程]]
- [[JDK环境搭建]]
- [[HelloWorld详解]]
-
-
-
- collapsed:: true
#+BEGIN_CAUTION
学习模式
#+END_CAUTION
- 学习阶段
collapsed:: true
- 第一阶段
- 重点：JavaSE 集合 数据库 Mybatis
- 个人项目
- 第二阶段
- 重点 SSM SpringBoot
- 个人项目
- 第三阶段
- 重点 Linux Redis ES全文检索引擎 前后端分离开发
- 团队项目简历项目
- 第四阶段
- 重点 SpringCloud Alibaba RabbitMQ服务器 分布式事务
- 团队项目简历项目
- 上课模式
collapsed:: true
- 不用PPT 笔记代码纯手打，画图现画
- 上课时间 45min 休息10min
- 整理笔记
collapsed:: true
- 一个知识点一个笔记
- 每个笔记包含
- 笔记名称（重要程度：低中高）
- 课程目标
- 课程内容
- 课程小结
- 课程资料
collapsed:: true
- 视频15min范围内
- 20220328-01-知识点名称(一)
- 20220328-01-知识点名称(二)
- 20220328-01-知识点名称(三)
- [课程视频](https://www.woniuxy.com/book/)
- [预习资料](https://www.woniuxy.com/book/)

85
logseq-java/journals/2022_03_29.md Normal file
View File

@@ -0,0 +1,85 @@
- [[Java跨平台原理]]
- [[IDE集成开发环境]]
- [[基本数据类型]]
- [[标识符]]
- [[变量]]
- [[隐式转换]]
-
-
-
-
-
-
- ## 总结
collapsed:: true
- 1. Java跨平台原理
- Java程序运行在JVM虚拟机上,通过不同平台上的不同的JVM做到跨平台
- 2. IDE集成开发工具
- 常见工具
- Eclipse,IDEA
- IDEA的下载安装
- IDEA新建项目
- Create-->Java--> Create project from template
Project name
Project location
- ((6243a9f6-b334-4daf-b1ec-b51335bba244))
- com 公司
gov 政府
edu 教育
org 开源
- 公司组织名称
- 项目名称
- IDEA设置调整
- 字体大小
- 背景修改
- 设置Eclipse快捷键
- Eclipse快捷键
- 3.标识符
- 系统默认标识符,称为关键字
- 共50个
- goto const不常用
true false null为保留关键字
- 自定义标识符
- 组成:数字,字母,_,$
不以数字开头,区分大小写
不能为关键字
- 命名原则:
类名使用大驼峰
方法名,变量名,参数名使用小驼峰
常量名单词大写,用_分割
- 4. 变量
- 3种注释
- 单行
```java
//单行注释
```
- 多行
```java
/*
*多行
*注释
*/
```\
- 文档
```java
/**
*文档
*注释
*/
```
- 变量是在一定范围内可以变化的量
- 两种变量声明
- 分类:
- 全局变量
- 局部变量
- 注意:
- 定义后必须赋初值
- 同一方法内不能重复
- 常量
- 恒久不变的量
- 5. 基本数据类型
- |byte|short|int(默认整数)|long|float|double(默认浮点)|char|boolean|
- 6. 隐式转换
- 小容量数据向大容量数据自动向上转换
- 字符集
- ASCII码

58
logseq-java/journals/2022_03_30.md Normal file
View File

@@ -0,0 +1,58 @@
- [[强制转换]]
- [[算术运算符]]
- [[关系运算符]]
- [[自增运算符]]
- [[复合赋值运算符]]
- [[进制转换]]
-
-
-
-
-
- 总结
collapsed:: true
- 隐式转换
- 小于int类型变量在计算式会自动提升为int类型
- Java在计算数字时会自动检测值是否超出范围
- 强制转换
- 小容量类型装超出范围的变量时要用到强制转换
- ```java
int a=200;
byte b = (byte) a;
```
- 强制转换讯在丢失精度,数据不准确的风险
- double强制转换int可去掉小数点
- 算数运算符
- 共5个 + - * / %
- 参与运算表达式表示字符串拼接
- 关系运算符
- ((6243f2ea-e08c-4ec2-850d-3ecf6e67889a))
- 关系运算符结果为布尔值
- 键盘录入
```java
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串：");
String str = scanner.nextLine();
System.out.println("请输入整数：");
int num = scanner.nextInt();
```
- 自增运算符
- i++和++i单独使用时效果一样
- 嵌入至其它表达式中时:
i++ 要先用i的值计算,然后自己再+1
++i 要i自己先加1,然后在进行其它计算
- i--和--i为自减运算符
- 运算符优先级
- 复合赋值运算符
- 赋值运算符 =
将 = 右边的值赋给左边的变量
- 复合赋值运算符
+= -= *= /= %= <<= >>= >>>=
- num += 1 相当于num = num +1
- 进制转换
- 2进制,8进制,10进制,16进制
- 10进制转2进制
- 1byte有8个二进制位,从右到左位数变高,最左为符号位,0为正,1为负
- 原码,反码,补码
- 2进制转10进制

98
logseq-java/journals/2022_03_31.md Normal file
View File

@@ -0,0 +1,98 @@
- [[位运算符]]
- [[逻辑运算符]]
- [[IF判断]]
- [[嵌套判断]]
- [[switch]]
- [[while循环]]
- [[for循环]]
- [[do while 循环]]
-
-
-
-
- ## 总结
collapsed:: true
- 位运算符
- & | ^的两侧可以放置数值,也可以放布尔表达式
- 按位与 &
- 按照二进制比较,同为1则为1,否则为0
- 按位或 |
- 按照二进制比较,有1就是1,否则为0
- 异或 ^
- 按照二进制比较,01的结果为1,11和00都是0
- 取反 ~
- 将二进制0变成1,1变成0
- 移位运算
- << 表示将数字的二进制整体向左移动
- \>> 表示将数字的二进制整体向右移动,原本符号不变
- \>>> 表示将数字的二进制整体向右移动,不考虑符号
- 逻辑运算符
- 两侧只能放布尔表达式
- 逻辑与 &&
- 两个都为true式整个结果才是true
- 短路与,前面表达式为false时,后面表达式不会执行
- 逻辑或 ||
- 两个只要有true,整个结果就是true
- 短路与,前面表达式为true时,后面表达式不会执行
- 逻辑非 !
- 假变真,真变假
- IF逻辑判断
- Java代码执行顺序
- 从上至下,从左至右
- IF流程控制
- 单分支
- ```java
if(布尔表达式){
//代码
}
```
- 双分支
- ```java
if(布尔表达式){
//代码1
}else{
//代码2
}
```
- 三目运算符
- if双分支的简写
- ```java
数据类型 变量 = (布尔表达式)? 值1 : 值2;
```
- 多分支和嵌套
- 当要判断的条件很多时,嵌套判断阅读维护性差
- 多分支
- ```java
if(布尔表达式1){
//代码1
}else if(布尔表达式2){
//代码2
}else if(布尔表达式3){
//代码3
}……{
}else{
//代码n
}
```
- switch
- switch与if区别在于switch判断的是几个固定的值
- ```java
int num = 值;
switch(num){
case 值1:
//代码1
break;
case 值2:
//代码2
break;
case 值3:
//代码3
break;
……
default:
//默认语句代码
break;
}
```
-
-

0
logseq-java/journals/2022_04_01.md Normal file
View File

1
logseq-java/journals/2022_04_02.md Normal file
View File

@@ -0,0 +1 @@
- [[周考1]]

15
logseq-java/journals/2022_04_04.md Normal file
View File

@@ -0,0 +1,15 @@
- [[格式化输出]]
- [[数组排序]]
- [[多维数组]]
- [[方法]]
- [[继承]]
-
-
-
-
-
-
-
-
-
-

6
logseq-java/journals/2022_04_05.md Normal file
View File

@@ -0,0 +1,6 @@
- [[命令行参数]]
- [[方法]]
- [[继承]]
- [[静态方法]]
- [[jar]]
- [[模块]]

29
logseq-java/journals/2022_04_06.md Normal file
View File

@@ -0,0 +1,29 @@
- [[面向对象]]
- [[类和对象的创建]]
- [[数组排序]]
- [[数组内存分析]]
-
-
-
-
-
-
- 总结
collapsed:: true
- 数组的排序
- 获取数组的最值
- 定义最值为数组第一个，for循环遍历比较，使用中间变量交换最值
- 查询数组中的元素
- 数组反转
- 交换元素中从头开始和从尾开始对应的元素
- 冒泡排序
- 两两比较，并交换位置
- 选择排序
- 通过比较确定最值的下标，并在比较结束后交换最值的位置
- 数组内存分析
- 数组内存
- 数组为自定义变量，在栈中存储的是内存中的地址
- 当给一个数组重新定义时，会改变栈中指向堆中的地址，原来的数据失去引用会被回收
- 常见错误
- 下标越界：下标超出程序中数组的下标范围
- 空指针：数组没有具体存储空间

78
logseq-java/journals/2022_04_07.md Normal file
View File

@@ -0,0 +1,78 @@
- [[传参]]
- [[调试]]
- [[方法重载]]
- [[面向对象的定义]]
-
-
-
-
-
-
- 总结
collapsed:: true
- 参数的传参
- 方法的定义
- 主函数
```java
public static void main(String[] args){
//主函数的代码
}
```
- 定义方法
```java
访问修饰符 static 返回类型 方法的方法名(参数列表){
//方法的代码块
}
```
- 参数列表：数据类型 参数名, 数据类型 参数名,数据类型 参数名……
- 分类
- 有参有返回
- 有参无返回
- 无参有返回
- 无参无返回
- 如果知道一个方法,需要传递什么参数?
- 方法在完成业务时,需要外部提供什么,就定义什么
- 调试Debug
- F5
- 进入断点方法内部
- F6
- 逐行执行代码,不进入方法内部
- F7
- 推出当前断电方法的内部
- F8
- 到达下一个断点
- 方法的重载
- 在同一个类中，相同的方法，不同的参数列表(参数的类型，参数的个数，参数的顺序)的方法
- 面向对象
- 面向过程
- 强调完成事务的过程,注重的是步骤
- 面向对象
- 在合适的时间找合适的人或物干对应的事情
- 万物皆对象
- 万物皆对象,但对象因我的关注而存在
- 类和对象
- 类是对大量对象的一种抽象,归纳
- 对象是类的一种具体实例
- 需要抽象对象的东西
- 属性
- 一大帮对象拥有的共同值,强调Has,是对对象的一种静态描述
- 行为
- 一大帮对象能干什么事,强调Do,是对对象的一种动态描述
- 创建类
- ```java
访问修饰符 class 类的类名{
//属性
访问修饰符 数据类型 属性的名称;
//行为
访问修饰符 返回类型 方法的方法名称(参数列表){
// 方法中的代码
return 返回值;
}
}
```
- 创建对象
- new
- ```java
类名 对象名 = new 类()
```
-

90
logseq-java/journals/2022_04_08.md Normal file
View File

@@ -0,0 +1,90 @@
- [[属性和行为]]
- [[对象的内存模型分析]]
- [[static]]
- [[访问修饰符]]
- [[this]]
- [[getter与setter]]
-
-
-
-
- 总结
id:: 624faffe-39f4-4020-9f12-39a039a8a618
collapsed:: true
- 属性和行为
id:: 624fb005-9338-408d-9042-057369983bc9
- 属性的使用
id:: 624fb021-f3cc-4cc9-b8e9-7041e05ef903
- 对象.属性
id:: 624fb035-d5f0-45db-b52f-bab47d78d7aa
- 行为的使用
id:: 624fb024-208d-48c5-8cfe-3032cee5f1d9
- 对象.行为
id:: 624fb041-6174-4622-9a10-498d2d7fd57d
- 对象的内存模型
id:: 62512765-08f0-4106-a64a-b64e16d1f202
- JVM内存分配
id:: 62512770-0853-4244-ae3d-793aa9f81512
- 栈
id:: 6251277a-226a-44a2-85ee-bf9bb5db25e5
- 用来存储方法的调用关系，以及方法内部的变量
id:: 62512783-8b92-4702-8208-57139384662b
- 堆
id:: 6251279d-e3c1-4454-805d-478eceaeecb7
- 放置使用new关键字创建出来的对象，全局动态字符串常量池
id:: 625127a9-c892-492e-afaf-2ca61f481311
- 本地方法栈
id:: 625127d6-fdcb-4f58-8b11-b43a0136d3a3
- 放置跟操作系统进行交互的本地方法
id:: 625127df-acc1-4ab2-a351-d78fe5ae4296
- 程序计数器
id:: 625127f3-4b2d-4351-ae12-9fcf6ae3db04
- 放置代码的执行顺序
id:: 625127fd-6e4c-4c95-bc1d-d009ecc27e2f
- 元空间
id:: 62512807-ee93-4f57-88e6-43b03c7cca0b
- 放置类的类对象
id:: 62512813-5158-4785-ae45-d7ecb4c0b13e
- 对象的内存模型
id:: 62512820-ddbf-427c-bbbb-5df3124a61cc
- static关键字
id:: 62512837-668a-423e-9a0c-5a8844cb1c27
- 如果某个方法有写static，表示这个方法是一个静态方法，没有则是动态方法
id:: 62512841-f8a7-4dfa-85ed-c314f65c66ba
- 如果一个方法不能和任何一个对象挂靠，那么这个方法就应该是个静态方法
id:: 62512872-e7c9-491f-819e-61352e3ea925
- 静态方法的使用
id:: 6251289b-4037-4a04-b61c-335032ae043c
- 通过类名.静态方法调用，也称类方法
id:: 625128a4-904e-4e79-8be4-6df24b009c7d
- 静态方法和非静态方法的调用
id:: 625128b6-23e5-405c-8f00-8d4630226c2e
- 静态方法不能直接调用非静态方法，可以直接调用静态方法
id:: 625128eb-7774-4247-9d74-3a9f117d2803
- 非静态方法可以直接调用静态方法
id:: 6251291d-2634-4cc7-880e-da2c02576d3f
- 访问修饰符
id:: 6251293b-dde1-4786-9e7d-461977662314
- ((624ff0b4-39b0-4eef-9c71-0990589ca29a))
id:: 6251296b-d185-4cc4-938d-63955c0d0237
- 封装
id:: 62512971-334b-45d7-b0f9-735d5d0d2d6a
- 隐藏 private
id:: 62512993-3596-47c6-b503-b4e17f70d632
- 包装 使用方法针对属性控制
id:: 62512980-86af-43dc-983f-50a9a380b536
- 变量的二义性
id:: 625129b8-349c-4fef-bdfe-14e8a70e488b
- this
id:: 625129d9-78fa-47e5-880d-47eaa0c19b59
- 谁在调用this 所在方法，这个this 就是谁
id:: 625129dd-b45d-4a50-9bae-5ef2fb5bbdde
- getter和setter
id:: 625129e5-e317-48d6-b7f3-0acf62c247c1
- Setter方法 ： 专门用来修改对象的私有属性的值
id:: 625129f1-475d-4d1b-b950-1392bd7c988a
- Getter 方法： 专门用来获得对象的私有属性的值
id:: 625129fe-6918-4d7e-9211-d5620c7b7361
-
- id:: 62512953-95f2-44c4-aef3-8feebcb9e676
- id:: 62512943-6cf5-4c98-8c16-702d6edfb023

69
logseq-java/journals/2022_04_11.md Normal file
View File

@@ -0,0 +1,69 @@
- [[构造器]]
- [[JavaBean规范]]
- [[this()]]
- [[继承]]
- [[重写]]
- [[super关键字]]
-
-
-
- 总结
collapsed:: true
- 构造器（构造方法）
- > 配合new关键字，创建类的实例
- 编译器会自动在类中给每个类构造一个无参的方法
- 该方法的方法名与类名一致
- 该方法没有任何返回值，连void都没有
- 构造器的作用
- 配合new，创建类的实例
- 无参构造器
- 在堆空间中为对象申请空间，对象多大申请多大
- 针对对象属性，在次划分空间
- 针对对象属性进行初始化赋值，基本数据类型为0，引用数据类型为null
- 分类
- 无参构造器：构造方法中没有参数
- 有参构造器：构造方法中有参数
- 作用：让对象在创建时候就初始化某些值
- 执行步骤
- 给对象在堆空间中，申请内存空间
- 给对象的属性，分配对应的空间
- 给对象的属性初始化赋值：基本数据类型为0，引用数据类型为null
- 执行构造器中剩余的代码，完成对象的属性赋初值
- IDEA快捷生成构造器
- Alt + Insert --> Constructor
- 写有参构造器之前一定要先写一个无参构造器
- JavaBean规范
- 业务对象：用来完成业务逻辑的对象
- 实体对象（JavaBean）：用来传输数据使用的对象，通常这种对象只有属性，没有行为
- 规范
- 类必须public公开
- 所有属性必须私有，提供对应getter和setter方法
- 如果提供有参构造器，必须先提供无参构造器
- this()
- 代表本类的其它构造器
- 继承
- > 作用：抽取公共代码
- 当一个子类继承另一个父类后，可以使用父类中的行为和属性
- 使用extends完成父子之间的继承
- 继承一定要满足is-a的关系
- 不要为了继承而继承
- 在继承中，使用new关键字产生一个子类对象时只创建了一个对象
- 不能被继承
- 父类私有的东西
- 父类的构造器
- 重写Override
- 父子之间，由子类去重新编写父类的方法
- 注意
- 子类不能重写父类的私有方法
- 重写方法的返回值类型可以不一样，但是父类的返回类型范围要大于子类，且这两种类型存在继承关系
- 注解
- 作用
- 解释代码
- 与第三方达成一定的约定，完成一定的业务
- 重写toString
id:: 62541250-f1f9-47b5-a565-b10caede7af5
- super
- super. 父类的
- super() 父类的构造器
- this的范围大于super的范围
-

83
logseq-java/journals/2022_04_12.md Normal file
View File

@@ -0,0 +1,83 @@
- [[final]]
- [[抽象类]]
- [[接口]]
- [[多态]]
-
-
-
- 总结
collapsed:: true
- final
- 最终的，最后的
- 修饰类
- 表示该类为最终类，不能被继承
- 修饰方法
- 表示该方法不能被子类重写
- 修饰变量
- 表示该量为一个常量
- 抽象类
- 具有抽象方法的类
- 当某一方法没有具体的实现案例时，此方法为一个抽象方法
- 不能被实例化，因为有方法不确定
- 抽象类中的抽象方法在子类中重写去实现
- 特点
- 具有抽象方法的类，一定是个抽象类
- 抽象类不一定具有抽象方法
- 抽象类通过abstract定义，并且抽象方法一定要在子类中实现
- 假如子类也实现不了这个方法，将子类也定义为抽象类
- 抽象类无法实例化
- 可放置的元素
- 抽象方法
- 非抽象方法
- 成员属性
- 构造器
- 面试题
- 抽象方法，可以定义成私有的不？
- 答：私有代表无法被重写，抽象方法是一定要子类重写！
- 抽象方法，可以定义为static的么？
- 答：static方法的调用方式：类名.方法名 意味着：这个方法一定有过实现；但是抽象方法实现了么？
- 抽象方法，可以定义为final的么？
- 答：final 定义在方法上，表示这个方法不能被重写；但是抽象方法一定需要子类重写！
- 接口
- 也是一种抽象，比抽象类还要抽象
- 作用：帮系统拓展新的功能
- 使用
- ```java
public interface 接口的接口名{
//需要拓展的功能
}
```
- ```java
访问修饰符 class 类的类名 extends 父类 implements 接口{
//原有及接口拓展的功能
}
```
- 特点
- 接口不能被实例化
- 接口中抽象方法，默认为publlic abstract
- 接口中抽象方法，必须要通过类给与实现
- 接口中的抽象方法，实现类可以变成抽象类，及可以实现接口中的方法
- 类只能单继承，但是接口可以多实现
- 类只能单继承，但是接口可以多继承
- 多态
- 多种形态
- > 相同的行为，不同的实现
- 静态多态
- 重载
- 动态多态
- 根据传入的对象不一样，调用相同的行为，拥有不同的实现
- 动态多态先决条件
- 必须要继承，必须要有方法的重写
- 父类的引用，可以指向子类的实现
- 父类的引用，看不到子类独有的东西
- 子类的引用，可以看到父类的东西，也可以看到自己独有的
- 动态绑定技术
- 父类的引用，指向不同子类的是实现，会自动调用对应子类的行为
- 用处
- 多态集合
- ```java
Object[] objts = new Object[10];
```
- 多态参数
- 在一个方法中，将父类定为参数，调用的时候，传入对应子类的实现
- 由于多态的特点，做到：传入不同的子类，调用相同的行为，可以做到不同的实现

84
logseq-java/journals/2022_04_13.md Normal file
View File

@@ -0,0 +1,84 @@
- [[向上转型与向下转型]]
- [[面向对象的特征]]
- [[静态代码块]]
- [[实例代码块]]
- [[Object类常用API]]
- [[字符串概述]]
-
-
- 总结
collapsed:: true
- 向上转型
- 基本数据类型的向上转型
- 隐式转换
- 引用数据类型的向上转型
- 只能发生在父子之间
- 向下转型
- 基本数据类型的向下转型
- 显式转换
- 引用数据类型的向上转型
- instanceof关键字
- 判断某一个对象是否是某一种类型的对象
- 面向对象的特征
- 封装
- 继承
- 抽象
- 多态
- 静态代码块
- 执行在类加载期间，先加载父类，后加载子类
- ```java
static{
//执行的代码
}
```
- 实例代码块
- ```java
{
//执行的代码
}
```
- Object类常用API
- API
- Application Programming Interface 应用编程接口
- 目的：
- 简化程序员的开发
- Object类
- 是所有Java类的超类，基类，父类。所以所有的类，都拥有它的方法
- toString
- 打印对象的内存地址
- toString的重写
- equals
- 比较2个对象，是否是同一个对象！
- == 在比较基本数据类型时，直接比较变量的值！
- == 在比较引用数据类型时，比较的是 地址值！
- equals的重写
- finalize
- IDEA生成API文档
- 字符串概述
- 字符串
- 将多个字符串到一起
- String
- String类型的字符串：长度固定，内容固定
- 字面量写法
- 通过new关键创建对象
- String常见方法
- indexOf
- charAt
- concat
- contains
- equals
- equalsIgnoreCase
- startWith
- endWith
- getBytes
- toCharArry
- isEmpty
- trim
- split
- substring
- replace
- lastIndexOf
- toUpperCase
- toLowerCase
- valueOf
- intern

74
logseq-java/journals/2022_04_14.md Normal file
View File

@@ -0,0 +1,74 @@
- [[StringBuilder]]
- [[StringBuffer]]
- [[Arrays]]
- [[System]]
- [[Runtime]]
- [[Math]]
- [[Random]]
- [[UUID]]
- [[BigDecimal]]
-
-
- 总结
collapsed:: true
- StringBuilder
- 长度，内容可变的字符串
- 常用API
- append
- insert
- capacity
- length
- setCharAt
- deleteCharAt
- delete
- reverse
- substring
- indexOf
- lastIndexOf
- StringBuffer
- 所有API及操作与StringBuilder一致
- Arrays
- toString
- sort
- binarySearch
- copyOf
- equals
- System
- exit
- gc
- currentTimeMillis
- nanoTime
- arraycopy
- getProperties
- Runtime
- Math
- random
- abs
- pow
- max
- min
- round
- Random
- ```java
Random a = new Random();
```
- 回溯历史
- Random(long seed)
- {{embed [[UUID]]}}
- BigDecimal
- 解决浮点数精度丢失的问题
- 使用字符串作为参数最精准
- 加减乘除
- add
- subtract
- multiply
- divide
- 除法除不尽
- 收尾
- ROUND_DOWN 去尾
- 只保留小数点后指定位数
- ROUND_UP 收尾
- 保留小数点后指定位数,如果保留位的后一位不为零,保留位的值加1
- ROUND_HALF_UP 四舍五入
- 保留小数点后指定位数,如果保留位的后一位<5,保留位数的值不加1,保留位的后一位>=5,保留位数的值加1
-

3
logseq-java/journals/2022_04_15.md Normal file
View File

@@ -0,0 +1,3 @@
- [[包装类]]
- [[Date]]
- [[Calendar]]

1
logseq-java/journals/2022_04_16.md Normal file
View File

@@ -0,0 +1 @@
- [[周考2]]

1
logseq-java/journals/2022_04_17.md Normal file
View File

@@ -0,0 +1 @@
- [[正则表达式]]

24
logseq-java/journals/2022_04_18.md Normal file
View File

@@ -0,0 +1,24 @@
- [[JDK1.8日期API]]
- [[异常]]
- [[编译异常]]
- [[异常捕获]]
- [[异常抛出]]
- [[运行异常]]
- [[自定义异常]]
- [[集合]]
- [[ArrayList]]
-
- 总结
collapsed:: true
- JDK1.8日期API
- LocalDate
- LocalTime
- LocalDateTime
- 异常概述
- 编译时异常
- 异常的捕获
- 异常的抛出
- 运行时异常
- 自定义异常
- 集合的概念
- ArrayList

76
logseq-java/journals/2022_04_19.md Normal file
View File

@@ -0,0 +1,76 @@
- [[ArrayList]]
- [[迭代器]]
- [[泛型]]
- [[匿名内部类]]
- [[LinkedList]]
- [[Vector]]
- [[HashSet]]
-
-
- 总结
collapsed:: true
- ArrayList
- API
- add()
- set()
- remove()
- contains()
- indexOf()
- isEmpty()
- clear()
- 遍历
- for循环
- 增强for循环
- 迭代器遍历
- 排序
- Collections
- addAll
- sort
- 自然排序
- 要求元素身上必须实现Comparable接口
- 自定义排序
- 自己定义比较器,完成排序规则
- 底层结构
- 迭代器
- 源自于 “迭代器模式”,为了统一集合的遍历方式
- Iterable接口的目的：为了让集合具备一定的遍历能力
- Iterator接口的目的：为了让集合进行具体的遍历
- 泛型
- 问题：集合在遍历时，向下转型中抛出 类型转换错误的问题
- 泛型：用来规范集合中元素类型
- 格式：<数据类型>
- 泛型接口
- 泛型类
- 泛型擦除
- 匿名内部类
- 定义在某一个方法的内部
- 类没有名字
- 实例化和类的定义一起放置
- 生命周期和方法同步
- LinkedList
- 底层为链表结构
- API与ArrayList一致
- 区别
- 底层结构ArrayList为数组,LinkedList为链表
- ArrayList适用于查询,新增和删除节点时效率低
- LinkedList适用于新增和删除节点,查询效率低
- Vector
- 向量,List中一种非常古老的集合
- API和底层结构与ArrayList一致
- Vector的方法都加了synchronized关键字
- HashSet
- 特点
- 元素存储时可以有序和无序
- 不允许重复元素
- 没有下标
- API
- add
- remove
- size
- 遍历
- 增强for循环
- 迭代器模式
- forEach方法
id:: 625f6ab3-c8c2-4a00-b127-284ce2e9c373
- 排序
- 借助ArrayList的功能排序

102
logseq-java/journals/2022_04_20.md Normal file
View File

@@ -0,0 +1,102 @@
- [[TreeSet]]
- [[HashMap]]
- [[TreeMap]]
- [[LinkedHashMap]]
- [[HashTable]]
- [[集合的交并差]]
- [[IO流]]
- [[字节流]]
-
-
-
- 总结
collapsed:: true
- TreeSet
- 红黑二叉树
- 所有节点要么红,要么黑
- 根节点一定为黑
- 红色节点的子节点,一定要为黑
- 从任何一种末梢子节点开始到根节点的过程中一定要有相同个数的黑色节点树
- {{embed ((625fe239-5548-4c66-ba66-f6fb1629b682))}}
- API方法与HashSet一致
- 排序借助ArrayList实现
- 去重
- 不依靠hashcode 以及equals
- 依靠比较器Comparable
- 元素一定要实现Comparable接口
- HashMap
- Map
- 基于Key-Vaalue的结构
- 特点
- Key不能重复
- Value可以重复
- 底层结构
- JDK1.7之前：数组 + 链表
- JDK1.7之后：数组 + 链表 + 红黑二叉树
- API方法
- put
- get
- replace
- delete
- deleteAll
- keySet
- values
- 去重
- 依靠hashcode和equals
- Key一定要重写 hashcode ，equals 方法
- 遍历
- forEach
- 获得Key的集合
- 通过Set集合获得每个元素
- TreeMap
- 特点
- Key去重,Value不去重
- Key有序存储
- 不能放null键,可以放null值
- API与HashMap一致
- 去重
- 借助比较器Comparable
- Key元素身上一定要实现Comparable
- LinkedHashMap
- HashMap为单向的,LinkedHashMap为双向的,底层原理一致
- API与HashMap一致
- HashTable
- 方法上有添加synchronized关键字
- 集合的交并差
- 交集
- retainAll
- 并集
- removeAll-->addAll
- 差集
- 利用第三个集合去除相加的部分后相加
- IO流
- Input
- 从程序外部将资源使用流的方式读取到程序内部
- Out
- 从程序内部将资源使用流的方式输出到程序外部
- 分类
- 走向
- 输入流
- 输出流
- 单位
- 字节流
- 字符流
- 功能
- 节点流
- 功能流
- 使用场景
- 上传下载文件
- 操作步骤
- 创建流
- 操作流
- 关闭流
- 字节流
- 流操作的最小单位
- 方向
- 输入字节流InputStream
- 输出字节流OutputStream
- File类
- mkdir
- exist
- isDirectory
- listFiles

43
logseq-java/journals/2022_04_21.md Normal file
View File

@@ -0,0 +1,43 @@
- [[File]]
- [[字符流]]
- [[缓冲流]]
- [[Properties]]
- [[序列化]]
-
-
- 总结
collapsed:: true
- 字节流
- 特点
- 可操作文本文件和二进制文件
- File类
- 代表文件或目录
- 字节输入流FileInputStream
- 读取文件内容到程序内部
- 字节输出流FileOutputStream
- 文件复制
- 先读取，再写入
- 文件输入流，文件输出流
- 字符流
- FileReader
- FileWrite
- 缓冲流
- 功能流的一种
- 特点
- 不直接面对数据源，是节点流的一种功能封装
- 字节缓冲流
- BufferedInputStream
- BufferedOutputStream
- 字符缓冲流
- BufferedReader
- BufferedWriter
- 流太多如何选择？
- 遇事不决，选字节流+缓冲流
- Properties
- 属性，也是一种Map体系的集合
- 使用
- setProperties
- getProperties
- 项目的应用
- 获取.properties文件中的属性
- PropertierUtil

54
logseq-java/journals/2022_04_22.md Normal file
View File

@@ -0,0 +1,54 @@
- [[其它功能流]]
- [[网络编程]]
- [[InetAddress]]
- [[URL]]
- [[TCP/IP]]
- [[Socket]]
- [[互联网企业面试题]]
-
- 总结
collapsed:: true
- 其它功能流
- PrintWriter
- PrintStream
- 网络编程
- 程序和程序之间，电脑和电脑之后，可能需要网络进行通讯
- 又被称为Socket套接字编程
- 网络编程的3要素
- IP地址
- 网络端口
- 通讯协议
- 端口
- 独立的进程，必须要开独立的端口
- 而且相互之间，互不干扰
- 端口取值范围：0 - 65535
- OSI七层模型
- InetAddress
- 代表 计算机的IP地址
- getHostName
- getHostAddress
- URL
- Uniform Resource Location 统一资源定位符
- URI ：
- Uniform Resource Identifier 统一资源标识符
- URL类
- TCP/IP
- 计算机用于网络通讯的一种底层协议
- 特点：
- 依赖连接
- 数据在通讯的过程中，采用1问1答的模式
- 3次握手的步骤
- 客户端发起一个请求，申请建立连接
- 服务端接收到请求，并返回数据包，告诉客户端： 我同意建立连接
- 客户端再次发起请求，真实建立连接
- 断开连接
- 客户端发起 断开连接的请求
- 服务端确认收到请求，并响应数据包，告诉客户端：我收到了，稍等我一下
- 服务端清空客户端的所有消息，并再次响应数据包，告诉客户端：咱们真正断开吧
- 客户端发送数据包，真正的断开连接
- UDP协议
- 相当于发短信，相当于邮寄信件，不需要建立连接
- Socket
- 套接字，用于连接 上三层 和下三层 之间的一种传输技术
- 给服务端传输信息
- 服务端给客户端传输消息

1
logseq-java/journals/2022_04_24.md Normal file
View File

@@ -0,0 +1 @@
- [[汽车租车系统]]

5
logseq-java/journals/2022_04_26.md Normal file
View File

@@ -0,0 +1,5 @@
- [[数据库]]
- [[MySQL]]
- [[数据库管理系统]]
- [[SQL]]
-

1
logseq-java/journals/2022_04_29.md Normal file
View File

@@ -0,0 +1 @@
- [[JDBC]]

11
logseq-java/journals/2022_05_10.md Normal file
View File

@@ -0,0 +1,11 @@
- [[反射]]
- [[Class]]
- [[泛型]]的上下限
collapsed:: true
- List<? super Number>类型为 Number及其父类
- List<? extends Number>类型为 Number及其子类
- MySQL索引的数据结构？
- 聚集索引与非聚集索引的区别？
- MySQL索引的类型？
- 索引失效的场景？
- 解释一下回表、索引覆盖、最左匹配、索引下推。

3
logseq-java/journals/2022_05_11.md Normal file
View File

@@ -0,0 +1,3 @@
- [[XML]]
- [[MySQL]]
id:: 6512a7e5-fe06-4402-bc78-92dc913bf98b

1
logseq-java/journals/2022_05_12.md Normal file
View File

@@ -0,0 +1 @@
- [[Mybatis]]

3
logseq-java/journals/2022_05_21.md Normal file
View File

@@ -0,0 +1,3 @@
- [[HTML]]
- [[元素]]
- [[属性]]

1
logseq-java/journals/2022_05_22.md Normal file
View File

@@ -0,0 +1 @@
- [[JavaScript]]

1
logseq-java/journals/2022_05_23.md Normal file
View File

@@ -0,0 +1 @@
- [[jQuery]]

2
logseq-java/journals/2022_06_18.md Normal file
View File

@@ -0,0 +1,2 @@
- [[Spring]]
- [[Feishu+Logseq]]

2
logseq-java/journals/2022_07_05.md Normal file
View File

@@ -0,0 +1,2 @@
- [[深圳蜗牛Java面试题]]
- [[Nginx服务器]]

2
logseq-java/journals/2022_07_06.md Normal file
View File

@@ -0,0 +1,2 @@
- [[Redis]]
- [[Linux]]

10
logseq-java/journals/2022_07_07.md Normal file
View File

@@ -0,0 +1,10 @@
- [[乐观锁]]
- [[事务在什么情况下会失效]] #DOING
- Mysql四种常见的[[数据库引擎]]
- [[InnoDB]]
- [[MyISAM]]
- [[MEMORY]]
- [[Archive]]
- [[@Resource和@Autowired的区别]]
- [[Collection 和 Collections 有什么区别]]
-

2
logseq-java/journals/2022_07_08.md Normal file
View File

@@ -0,0 +1,2 @@
- [[Redis主从复制]]
- [[Redis哨兵模式]]

10
logseq-java/journals/2022_07_09.md Normal file
View File

@@ -0,0 +1,10 @@
- [[多线程]]
- [[多线程的创建]]
- [[线程状态]]
- [[线程安全]]
- [[synchronized]]
- [[线程同步]]
- [[生产者消费模式]]
- [[定时器]]
- [[死锁]]
- [[守护线程]]

7
logseq-java/journals/2022_07_11.md Normal file
View File

@@ -0,0 +1,7 @@
- [[全文检索引擎]]
- [[ElasticSearch]]
- [[Kibana]]
- [[Spring Data JPA]]
- [[七大设计原则]]
- [[设计模式]]
- [[GOF32]]

6
logseq-java/journals/2022_07_12.md Normal file
View File

@@ -0,0 +1,6 @@
- [[ElasticSearch条件查询]]
- [[ElasticSearch分页]]
- [[反射]]
- [[重写和重载的区别在哪里]]
- [[GC]]
- [[同步函数]]

2
logseq-java/journals/2022_07_13.md Normal file
View File

@@ -0,0 +1,2 @@
- [[Spring调用外部接口]]
- [[Swagger]]

4
logseq-java/journals/2022_07_14.md Normal file
View File

@@ -0,0 +1,4 @@
- [[组件化开发]]
- [[Vue]]
- [[Vue-Cli]]
- [[跨域]]

2
logseq-java/journals/2022_07_18.md Normal file
View File

@@ -0,0 +1,2 @@
- [[Vue-Router]]
- [[JWT]]

7
logseq-java/journals/2022_07_19.md Normal file
View File

@@ -0,0 +1,7 @@
- [[Swagger]]
- [[PowerDesigner]]
- [[禅道]]
- [[迭代增量式开发]]
- [[瀑布模型]]
- [[计划驱动]]
- [[敏捷开发]]

1
logseq-java/journals/2022_07_20.md Normal file
View File

@@ -0,0 +1 @@
- [[工业园区智慧管理系统]]

3
logseq-java/journals/2022_07_21.md Normal file
View File

@@ -0,0 +1,3 @@
- [[SpringMVC框架的工作流程]]
- [[Servlet的生命周期]]
- [[重定向和请求转发的区别是什么]]

1
logseq-java/journals/2022_08_05.md Normal file
View File

@@ -0,0 +1 @@
- [[产品需求文档]]

2
logseq-java/journals/2022_08_08.md Normal file
View File

@@ -0,0 +1,2 @@
- [[Spring Cloud]]
- [[Ribbon]]

1
logseq-java/journals/2022_08_23.md Normal file
View File

@@ -0,0 +1 @@
- [[RabbitMQ]]

173
logseq-java/journals/2022_09_13.md Normal file
View File

@@ -0,0 +1,173 @@
- 索引的概念
- 用于提高查找速度的一种数据结构
- 为什么要用B+树，B-树和B+树区别，为什么不用红黑树
- Hash表结构存储数据
- 通过key的hash计算得到存储下表
- Hash只能进行等值查询，切换速度非常快，但是无法用于范围查询
- 二叉查找树
- 左边小，右边大，自身带排序
- 二分查找
- 极端情况
- 根节点的选取，如果选取不好就会不平衡
- 出现某一个方向子树过长
- 平衡二叉树
- 改善二叉树极端情况
- 降低IO次数，每走一个节点进行一次IO
- 数的高度过高，IO性能下降
- B树
- 存放指针及数据，保存了排序功能
- 指定阶数M，一个节点包含的子节点最大数量M越大，高度越低
- 范围查询大的时候需要返回根节点再次便利
- 存储了data信息，记录增多的时候树的高度会变高
- B+树
- 数据全部存在子节点中，非子节点只存储键值和指针
- 子节点之间添加链表结构，解决范围查询时需要返回根节点
- 范围查询效率提高很多，单个查询比B+树提高不大
- 那些情况适合建立索引，那些不适合建立索引
- 频繁使用where
- 分组字段，分组的前提为排序
- 统计字段
- 加了索引不需要产生中间表去重
- 频繁更新字段
- 数据单一固定
- 数据量大(数据类型text)
- where条件不怎么用的
- 索引分类，最左前缀，聚簇索引
- 主键索引
- 唯一索引(一级索引)
- 普通索引(二级索引)
- 联合索引(需要符合最左前缀原则)
- 最左前缀
- 第一个值为从小到大排序，第二个不是
- 第一个值确定的情况下，第二个值是有序的
- 从最左边开始连续的索引都可以匹配上，直到遇到范围查询，> < between
- 已经排序好的字段是会生效的，
- a=1 and b>1 ab都会生效
- a>1 and b=1 b索引会失效，a>1 时b为无序的
- MyISAM和InnoDB数据结构
- MYD数据 MYI索引
- ibd数据和索引，读一个文件速度更快
- 聚簇索引
- 根据主键索引可以直接拿到数据，索引和数据放在一起
- InnoDB
- 定义主键为聚簇索引
- 未定义索引，选择第一个部位null唯一索引
- 以上都没用，使用一个6字节长整型的隐式字段ROWID字段构建聚簇索引，该RPWID字段会在插入新行时自动递增
- 非聚簇索引(辅助索引)
- 除聚簇索引外
- 只存储主键ID
- 查询可能需要回表，通过辅助索引查询得到ID去主键索引中查找
- MyISAM中通过主键查询得到数据在硬盘中的地址，再根据该地址去磁盘中寻找
- 主键索引唯一，辅助索引可能等值也会查询出多个数据
- 索引覆盖
- 通过辅助索引可以获得全部数据，不需要回表
- 索引失效
- select *
- %左边
- 未最左匹配
- 数据库认为不要
- 计算
- or
- ！= > <
- 优化
- 辅助索引覆盖
- 自增主键ID
- 避免select *
- 少用子查询，能使用外连接就外连接，避免笛卡尔积
- 使用短索引，非叶子节点存储更多索引降低树的高度
- 为什么推荐使用自增主键作为索引
- 页分裂
- 降低复杂度
- List集合
- 结合源码，回答核心流程，夹带关键字
- ArrayList
- 如何扩容，大小如何自动增加
- 1. 初始化，未给定长度，默认调用午餐构造器
- elementdata 常量数组为空
- new之后数组长度为0
- 2. 添加第一个元素
- 计算容量，比较长度后返回初始化长度为10
- 3. 数组扩容
- grow方法增加长度
- 新容量为老容量加上老容量右移以为，即1.5倍
- 掉用复制数组的方法
- 复制某个ArrayList到另一个里面去
- clong，addAll，copy，stream流
- 重写Clone方法
- 浅复制
- 返回一个一样的ArrayList，其中一个改变了元素，另一个也会改变
- 两个集合中存储同一份元素引用
- 深复制
- 重写clone方法，使用迭代器便利，重新创建引用对象，逐个添加
- 索引中ArrayList增加或删除某个元素的运行过程，效率很低吗
- 效率很低，添加或删除某个元素都需要对数组中的元素进行移位，需要不断进行ArrayCopy很浪费时间
- 添加，后面元素都后移一位，再添加
- 删除，后面元素都前移一位覆盖
- 很大的数组需要拷贝，如何快速拷贝
- 创建时就指定数组的大小
- 获得线程安全的ArrayList
- synchorizoned关键字
- LinkedList和ArrayList如何选择
- ArrayList底层为数组，查询效率高，增删效率低
- LinkedList底层为链表，查询效率低，增删效率高
- Vector
- 扩容为2倍，线程安全
- Set
- HashSet
- 无序，去重，非线程安全
- new新建HashMap
- 底层通过HashMap的key值实现的，值为常量PRESENT(一个空的Object对象)
- put调用setValue方法
- 添加时为什么要给个value为PRESENT常量
- PRESENT决定返回oldValue还是null判断是否已经存在
- HashSet remove方法比较PRESENT
- HashMap的删除方法成功会返回value，失败返回null，通过返回判断是否删除
- 去重原理
- hashcode和equals方法
- 先判断hash值，再通过==和wquals判断，返回true则为重复元素
- HashSet和TreeSet
- 无序HashSet，有序TreeSet
- 如何得到一个线程安全的Set集合
- Collections.synchorizeonedSet()
- HashMap的底层结构
- jdk1.7 数组+单向链表
- jdk1.8 数组+链表(单向/双向)+红黑树
- 内部定义静态Node类
- Node<K, V>
- TreeNode有TreeNode left，TreeNode right继承LinkedHashMap.Entry继承HashMap.Node
- 如何解决Hash碰撞
- 存放元素需要通过Hash计算来得到Hash值，Hash值为元素要存放的位置，当两个不同元素经过Hash计算得到的Hash值相同，两个元素要存放在同一个位置，产生冲突
- HashMap的put方法
- 初始化table数组长度为16，第一次添加table为null，通过resize()方法,给新容量16，阈值16*0.75
- threadhold，扩容因子0.75
- 何时从单链表转化为红黑树
- 常量TREEIFY_THREADHOLD = 8 通过treeify()方法重组为红黑二叉树
- 扩容方法
- 通过resize方法扩容，判断是否达到阈值，达到就扩容为原来的两倍
- 数组长度小于临界值MIN_TREEIFY_64或等于null时
- 何时扩容
- 转红黑树时要判断，转换时需要搬运元素，第一个元素要扩容
- 添加一个元素后
- HashMap设置长度为11，那么数组容量为多少
- tbaleSizeFor()方法重组
- hash计算更加平均，与数组长度值有关
- 设置为大于我们自定义的值的第一个2的幂次方的值，设置为11长度为16
- HashMap何时从红黑树转化为单链表模式
- 扩容时需要搬运数据，如果红黑二叉树不需要转化条件就会转化为链表
- resize()方法转移红黑二叉树时会调用splite()方法
- lohead，hihead，分割时会产生高位树和低位树，小于等于6时调用untreeify方法退回链表结构
- 多线程并发使用时，容易造成死循环/死锁
- 非线程安全
- jdk1.7头插法，jdk1.8尾插法
- ConcurrentHashMap
- 线程安全的集合
- ConcurrentHashMap在jdk1.7和1.8的区别
- jdk1.7 Segment段数组+Entry数组+单链表
- Segment继承ReenTrantLock类，每一个segment相当于一个锁，这就是分段锁
- 当其它线程进行put操作时，发现锁资源被占用时回去进行节点创建避免线程空闲，这种思想也叫**预创建**
- segment长度固定为16，HashEntry可以扩容
- jdk1.8 和HashMap结构一样
- CAS + setCtl
- 如何保证线程安全
- key和value不支持null的原因
- 二义性

7
logseq-java/journals/2022_09_14(1).md Normal file
View File

@@ -0,0 +1,7 @@
- 简历
- 所做的部分
- 技术方案
- 业务亮点
- 描述5行左右
- 项目职责，5-6条，不写登录，注册，crud，不写业务逻辑，写负责完成那些业务
- 在

7
logseq-java/journals/2022_09_14.md Normal file
View File

@@ -0,0 +1,7 @@
- 简历
- 所做的部分
- 技术方案
- 业务亮点
- 描述5行左右
- 项目职责，5-6条，不写登录，注册，crud，不写业务逻辑，写负责完成那些业务
- 人技能，写一行

2
logseq-java/journals/2022_09_17(1).md Normal file
View File

@@ -0,0 +1,2 @@
- 面试
-

2
logseq-java/journals/2022_09_17.md Normal file
View File

@@ -0,0 +1,2 @@
- 面试
- 面试准备

1
logseq-java/journals/2022_09_18.md Normal file
View File

@@ -0,0 +1 @@
- [两年Java的面试经验 - Yrion - 博客园 (cnblogs.com)](https://www.cnblogs.com/wyq178/p/8840944.html)

14
logseq-java/journals/2023_09_15.md Normal file
View File

@@ -0,0 +1,14 @@
- [[Java并发编程基础面试题]]
- [[JVM面试题]]
- [[Java 基础面试题]]
- [[Mysql数据库面试题]]
- [[Spring Cloud面试题]]
- [[Spring Boot面试题]]
- [[Spring 面试题]]
- [[Mybatis 面试题]]
- [[网络相关面试题]]
- [[Redis面试题]]
- [[Zookeeper面试题]]
- [[分布式消息队列面试题]]
- [[一线大厂场景问题详解]]
- [[常见算法面试题]]

68
logseq-java/journals/2023_09_26.md Normal file
View File

@@ -0,0 +1,68 @@
- DONE Spring
:LOGBOOK:
CLOCK: [2023-10-07 Sat 13:05:14]--[2023-10-08 Sun 18:00:35] => 28:55:21
:END:
- https://www.bilibili.com/video/BV1rb4y147F2
- [[Spring是如何创建一个bean对象的]]
- [[Spring源码]]
- 微服务SpringCloud
- 什么是单例池，作用是什么
- Bean和普通对象之间的区别是什么
- @PostConstruct注解是如何工作的
- Bean的初始化是如何工作的
- Bean的初始化和实例化的区别是什么
- 什么是初始化后
- 推断构造方法是什么意思
- 什么是先bytype再byname
- Spring Aop底层是怎么工作的
- Spring事务底层是怎么工作的
- [[@Configuration注解的作用是什么]]
- [[Spring为什么要用三级缓存来解决循环依赖]]
- [[@Async为什么会导致循环依赖解决不了]]
- [[构造方法和多例导致的循环依赖]]
- [[SpringMVC处理请求底层原理流程]]
- SpringMVC容器创建源码分析
- [[SpringMVC父子容器原理分析]]
- [[SpringMVC父子容器源码分析]]
- SpringMVC的零配置
- [[手写代码模拟SpringBoot]]
- [[Springboot如何选择TomCAT还是Jett底层]]
- [[@ConditionOnClass注解底层原理]]
- [[SpringBoot零配置底层原理实现]]
- Spring是什么
- [[Spring的事务传播机制]]
- [[Spring框架中Bean的创建过程]]
- [[Spring中的Bean是线程安全的吗]]
- Spring中的单例Bean是线程安全的吗
- [[Spring框架中使用了哪些设计模式及应用场景]]
- [[Spring容器启动流程是怎样的]]
- [[Spring如何处理事务]]
- Spring如何处理循环依赖问题
- Spring事务的实现原理及隔离级别
- [[Spring事务什么时候会失效]]
- Spring用到了哪些设计模式
- Spring支持的Bane的作用域
- Spring中Bean是线程安全的吗
- Spring中的Bean创建的声明周期有哪些步骤
- [[Spring中的事务是如何实现的]]
- Spring中什么时候@Transactional会失效
- Spring中后置处理器的作用
- [[如何实现AOP，项目哪些地方用到了AOP]]
- [[说说常用的SpringBoot注解，及其实现]]
- [[还读过哪些框架源码，介绍一下你还熟悉的]]
- 介绍一下Spring，读过源码介绍一下大致流程
- 什么时候@Transactional失效
- 说一下Spring的事务机制
- [[对AOP的理解]]
- [[对IOC的理解]]
- 简述Spring bean的生命周期
- Spring用到了哪些设计模式
- Spring中Bean是线程安全的吗
- [[如何理解SpringBoot的starter]]
- [[如何实现一个IOC容器]]
- [[什么是bean的自动装配，有哪些方式]]
- DOING Spring待解决问题
:LOGBOOK:
CLOCK: [2023-10-08 Sun 18:00:28]
:END:
- [[如何实现一个自定义的starter]]

12
logseq-java/journals/2023_09_28.md Normal file
View File

@@ -0,0 +1,12 @@
- 统计字符出现字数
- 使用split方法然后获得所有片段的长度
- 使用replace方法替换为空
- [[树]] #数据结构
- 二叉树的遍历
- 先序遍历
- ![image.png](../assets/image_1695911709943_0.png)
- private void preOrder(BTnode<Character> t)
- 中序遍历
- ![image.png](../assets/image_1695911700708_0.png)
- 后序遍历
- ![image.png](../assets/image_1695911682910_0.png)

125
logseq-java/journals/2023_10_07.md Normal file
View File

@@ -0,0 +1,125 @@
- [[MySQL]]
:LOGBOOK:
CLOCK: [2023-10-07 Sat 13:05:28]
:END:
- DONE 多线程
:LOGBOOK:
CLOCK: [2023-10-07 Sat 13:11:17]--[2023-10-19 Thu 17:21:38] => 292:10:21
:END:
- [[Java创建线程的方式有哪些]]
- [[线程生命周期状态]]
- [[什么是线程安全，线程安全的本质]]
- [[ThreadLocal使用场景]]
- [[ThreadLocal内存泄漏]]
- [[Java中21种锁]]
- [[为什么阿里禁用Executors创建线程]]
- [[如何根据实际需要，定制自己的线程池]]
- [[CAS缺点]]
- [[线程池线程复用原理]]
- [[阻塞和非阻塞队列的并发安全原理]]
- [[公平锁和非公平锁]]
- [[自旋锁优缺点]]
- [[合适的线程数量，CPU核心数和线程数的关系]]
- [[CAS是一种什么样的同步机制]]
- [[线程加锁有哪些方式，Synchronized和lock的区别]]
- [[进程和线程的区别，使用线程真的能节省时间]]
- [[线程有几种状态]]
- [[ThreadLocal是什么，工作中有用到过吗]]
- [[ThreadLocal如何实现]]
- [[ThreadLocal父子线程怎么共享数据]]
- [[ThreadLocalMap的结构及扩容机制]]
- [[解决hash冲突方法]]
- [[你知道哪几种锁，分别有什么特点]]
- [[什么是阻塞队列，Java中有哪些阻塞队列]]
- [[ConcurrentHashMap为什么放弃了分段锁]]
- [[HashMap内部如何工作]]
- [[什么是指令重排序，为什么要重排序]]
- [[什么是内存可见性]]
- [[主内存和工作内存的关系]]
- [[什么是happen-before原则]]
- [[为什么需要AQS，AQS的作用和重要性]]
- [[一个线程调用两次start()方法会出现什么情况]]
- [[为什么多线程会带来性能问题]]
- [[线程池有几种拒绝策略]]
- [[哪些解决死锁的策略]]
- [[你知道哪些线程安全问题]]
- [[线程池中提交一个任务是怎么样的]]
- DONE JVM
:LOGBOOK:
CLOCK: [2023-10-07 Sat 13:11:28]--[2023-10-17 Tue 20:44:40] => 247:33:12
:END:
- https://www.bilibili.com/video/BV1dA411U7or
- [[JVM主要组成部分]]
- [[JVM内存结构]]
- [[垃圾回收算法]]
- [[垃圾回收器]]
- [[JVM调优]]
- [[JDK自带调优工具]]
- [[生产环境OOM问题]]
- [[生产环境CPU飙高问题]]
- [[类加载机制]]
- [[对象完整创建流程]]
- [[对象分配内存时的指针碰撞和空闲列表机制]]
- [[对象头]]
- [[对象分配内存时的并发问题解决CAS与TLAB机制]]
- [[如何计算对象占用内存大小]]
- [[对象指针压缩]]
- [[栈上分配，逃逸分析，标量替换]]
- [[引用计数法有什么问题]]
- [[GC Root可达性分析法]]
- [[什么样的类能被回收]]
- [[JVM内部各种垃圾收集算法]]
- [[CMS垃圾回收过程]]
- [[CMS比较严重的问题并发收集阶段再次触发Full GC]]
- [[垃圾收集底层三色标记算法]]
- [[G1垃圾收集过程]]
- [[G1收集器最大停顿时间时如何实现的]]
- [[内存泄漏如何排查和解决]]
- [[GC什么时候都能做吗，GC安全点和安全区域]]
- [[字符串常量池]]
- [[基本类型包装类常量池如何实现的]]
- 堆的分代
- 年轻代minor gc
- Eden
- S0
- S1
- 老年代full gc
- 可达性分析法
- GCRoots，以root为节点分析引用的对象
- jvisualvm
- 双击进去查看内部的运行情况
- arthas
- java -jar运行jar包
- dashboard
- thread 线程号
- 定位代码运行位置
- thread -b
- 查看死锁
- jad
- 反编译代码
- ognl
- 修改线上系统变量的值
- STW机制
- 用户线程会被暂停
- 电商网站
- 有压力频繁full gc
- 亿级流量电商
- 每个用户平均点击20，30次
- 日活用户500万
- 付费转换率10%
- 日均50万单
- 大促在抢购前几分钟产生
- 每秒1000多单
- 4核8G部署 300单/秒
- 一个订单对象1KB
- 每秒300KB订单
- 其他对象放大20倍
- eden800M，s0，s1，100M，old2G
- 一秒产生60M对象，运行14秒占满eden
- 因为动态对象年龄，每秒60M对象直接移动到老年代
- 能够对JVM调优，让其不发生Full GC
- 可以，调大新生代的区域大小，让清理的时间延长
- 长期存活对象移动到老年代
- 动态对象年龄
- 一批对象的总大小大于这块susrvivor区域内存大小的50%，大于等于这批对象年龄最大值的对象可以直接进入老年代
-

47
logseq-java/journals/2023_10_08.md Normal file
View File

@@ -0,0 +1,47 @@
- DOING Spring Cloud
:LOGBOOK:
CLOCK: [2023-10-08 Sun 16:30:20]
:END:
- Sentinel
- Nacos
- Zookeeper
- Spring面试题
- TODO 看视频学习
- https://www.bilibili.com/video/BV1z94y1W7G9
- [[BeanDefination]]
- [[BeanFactory]]
- [[Bean生命周期]]
- [[@Autowired]]
- Redis
- TODO 看视频学习
- https://www.bilibili.com/video/BV1it4y1W7D1
- [[Redis是单线程还是多线程]]
- [[Redis单线程为什么还能这么快]]
- [[跳表]]
- [[key过期了为什么内存没有释放]]
- [[内存淘汰策略]]
- [[删除key的命令会阻塞redis吗]]
- [[主从哨兵集群优缺点]]
- [[hash分片算法]]
- [[redis执行命令有死循环阻塞bug]]
- [[线上事故，主从切换导致缓存雪崩]]
- [[持久化机制]]
- [[线上事故，redis主节点宕机数据全部丢失]]
- [[Redis线上数据如何备份]]
- [[主从复制风暴]]
- [[网络抖动导致频繁主从切换]]
- [[Redis集群为什么至少需要三个主节点]]
- [[Redis集群支持批量操作命令吗]]
- [[Lua脚本能在Redis集群里面执行吗]]
- [[Redis主从切换导致分布式锁丢失]]
- [[缓存问题]]
- [[缓存数据库双写不一致问题]]
- [[多级缓存架构解决Redis线上集群缓存雪崩]]
- [[Redis分布式锁底层如何实现]]
- [[Redis和Mysql保证数据一致性]]
- [[设置key的过期时间]]
- [[Redis数据结构]]
- [[主从复制的核心原理]]
- [[布隆过滤器，优缺点]]
- [[分布式缓存方案]]
- [[Redis事务实现]]

82
logseq-java/journals/2023_10_09.md Normal file
View File

@@ -0,0 +1,82 @@
- 消息队列
- https://www.bilibili.com/video/BV1yT411H7YK
- RabbitMQ
- 使用场景
- 异步发送 验证码，短信，邮件
- MySQL与Redis，ES之间数据的同步
- 分布式事务
- 削峰填谷
- [[消息不丢失]]
- [[消息重复消费]]
- [[死信交换机/延迟队列]]
- [[消息堆积]]
- [[高可用机制]]
- DOING 消息顺序消费
:LOGBOOK:
CLOCK: [2023-10-09 Mon 21:25:36]
:END:
- Kafka
- 消息不丢失
- ![image.png](../assets/image_1696857129269_0.png)
- 生产者发送消息到Brocker丢失
- 异步发送消息
- 回调机制接受异常记录日志补偿
- 消息重试机制
- ![image.png](../assets/image_1696857225846_0.png)
- 消息在Brocker中存储丢失
- 发送确认机制acks
- 0，写入消息不等待服务器响应
- 1，leader节点收到消息
- all，所有节点收到消息
- Kafka Cluster
- 先保存到leader，再同步到follower
- 消费者从Brocker接收消息丢失
- 多个Brocker
- ![image.png](../assets/image_1696857536672_0.png)
- 分区机制
- 每个主题划分为多个分区（Partition）
- topic分区中消息只能由消费者中唯一一个消费者处理，不同分区分配给不同消费者
- 分区中的消息都有偏移量，消费者默认自动按期提交已经消费的偏移量，默认5s，如果出现重平衡情况可能会重复消费或丢失数据
- 禁用自动提交偏移量，改为手动
- 同步提交
- 异步提交
- 同步+异步组合提交
- 消费的顺序性
- 即时消息单对单聊天和群聊，保证发送方和接收方消费顺序一致性
- 充值和消费的消息要顺序发送
- 只提供一个分区，从而避免跨分区消费消息
- 设置同一个分区存储号
- 设置同一个key，保证哈希值相同
- 高可用机制
- 集群
- 分区备份机制
- topic分为p0，p1，p2三个分区
- ![image.png](../assets/image_1696858281407_0.png)
- 一个leader，多个follower存储副本
- leader发生故障，follower提升为leader
- follower副本分类
- ISR（in-sync replica）需要同步复制保存的follower
- 普通，异步复制保存
- leader宕机，优先从ISR中选择
- ISR都宕机，从普通follower选取
- 数据存储和清理
- 存储机制
- topic名称，分区号，对应文件夹名称
- 文件分段存储,多个segment
- .index
- .log
- .timeindex
- 删除无用文件更加方便，提高磁盘利用率
- 查找数据更加便捷
- 清理机制
- 清理策略
- 根据消息的保留时间，如果超过指定时间，就会触发清理过程，默认168h
- 根据topic存储数据大小，所占日志文件超过一定阈值，开始删除最早的消息
- 高性能设计
- 消息分区：不受单台服务器限制
- 顺序读写：磁盘顺序读写，提高读写效率
- 页缓存：把磁盘中的数据缓存到内存，将对磁盘的访问变为对内存的访问
- 零拷贝：减少上下文切换及数据拷贝
- 通过系统直接将页缓存中的数据拷贝到网卡中，减少内核态和用户态的切换
- 消息压缩：减少磁盘IO和网络IO
- 分批发送：消息打包分批发送，减少网络开销

2
logseq-java/journals/2023_10_19.md Normal file
View File

@@ -0,0 +1,2 @@
- [[SpringBoot自动装配]]
-

33
logseq-java/journals/2023_10_20.md Normal file
View File

@@ -0,0 +1,33 @@
- MySQL版本类问题
- 工作中使用的是什么版本的MySQL，为什么选择这个版本
- percon版本，拥有防火墙，审计功能，对原版本有一定优化
- 知识点
- MySQL常见发行版本
- 官方版本，社区，企业
- percona MySQL，对MySQL社区版本进行一定优化
- MariaDB，5.5版本代码发展起来的，不一定完全兼容
- 各个发行版本之间的区别
- ||MySQL|Percona MySQL|MariaDB|
|服务器特性|开源|开源|开源|
||支持分区表|支持分区表|支持分区表|
||InnoDB|XtraDB|XtraDB|
||企业版监控工具，社区版不提供|Percon Monitor工具|Monyog|
|高可用特性|基于日志点复制|基于日志点复制|基于日志点复制|
||基于Gtid复制(5.6版本起)|基于Gtid复制|基于Gtid复制，但Gtid同MySQL不兼容|
||MGR|MGR&PXC|Galera Cluster|
||MySQL Router|Proxy SQL|MaxScale|
|安全特性|企业版防火墙|ProxySQL FireWall|MaxScale FireWall|
||企业版用户审计|审计日志|审计日志|
||用户密码生命周期|用户密码生命周期|-|
||sha256，caching_sha2|sha256，caching_sha2|ed25519，sha256|
|开发及管理|窗口函数（8.0）|窗口函数（8.0）|窗口函数（10.2）|
||-|-|支持基于日志回滚|
||-|-|支持记在表中记录修改|
||Super read_only|Super read_only|-|
- 如何决定是否要对MySQL进行升级，如何进行升级
- 高版本可以作为低版本的从机
- 可以给业务带来的益处
- 升级可能对业务带来的影响
- 数据库升级方案的定制，DBA操作
- 升级失败的回滚方案
- 最新MySQL版本，有什么新特性

27
logseq-java/journals/2023_10_22.md Normal file
View File

@@ -0,0 +1,27 @@
- DOING SSM框架
:LOGBOOK:
CLOCK: [2023-10-22 Sun 19:56:32]
:END:
- [【冒死上传】比啃书强十倍！23年最牛SSM框架面试教程（SpringBoot+SpringMvc+Mybatis）高质量夺命连环47问|完整版-允许白嫖！！_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1hh4y1q7je/)
- Spring中定义Bean的方式 #card
- 使用@Bean
- 使用@Component
- 使用@Controller，@Service，@Repository
- 使用@Configuration
- 使用@Import(.class)导入
- 使用@ControllerAdevice、@RestControllerAdvice
- 底层不是用的Spring AOP那套，Spring MVC自己实现了
- 使用BeanDefination
- xml配置\<bean/>标签
- @ImportResource(classpath:spring.xml)
- Spring的自动配置 #card
- 使用SpringBoot时会引入一个starter包，间接引用spring-boot-autoconfigure的包，里面有各种各样的配置类，里面配置了各种Bean
- @SpringBootApplication注解，内部有三个注解
- @SpringBootConfiguration
- @EnableAutoConfiguration，自动配置的开关，正常情况下我们的应用程序不会扫描SpringBootConfigure这个包的路径文件，开启了这个注解才会
- @ComponentScan
- 自动将第三方组件的Bean加载到IOC容器中，不需要手动去写相关Bean的配置，在启动类上有一个@SpringBootApplication注解，这个是一个复合注解，内部有一个@EnbaleAutoConfiguration注解，第三方jar包内部的配置类就是有@Configuration注解以及@Bean注解，同时在resources/META-INFO/spring.factories文件中有这些需要加载的配置类的路径
- {{embed [[#{} 与 ${} 的区别]]}}
- ApplicationContext和BeanFactory有什么区别
- 都是接口，分别代表应用容器和Bean工厂
- Application继承了BeanFactory，有BeanFactory的全部功能，也是一个Bean工厂，还继承了其它接口并增加了国际化，事件发布，加载资源文件，获取系统环境变量等功能

3
logseq-java/journals/2023_10_24.md Normal file
View File

@@ -0,0 +1,3 @@
- Ribbon负载均衡如何配置
- SpringCloud是什么
- 两个表有大量重复数据取出不一样的

7
logseq-java/journals/2023_10_25.md Normal file
View File

@@ -0,0 +1,7 @@
- TODO 多线程案例
- 线程池
- completablefuture
- 分布式事务案例
- zookeeper
- seata
- spring事务

10
logseq-java/journals/2023_10_26.md Normal file
View File

@@ -0,0 +1,10 @@
- [[雪花算法]]
- [[MySQL为什么使用B+树索引]]
- [[MySQL适合创建索引的情况]]
- [[MySQL索引失效]]
- [[MVCC]]
- [[MySQL中锁机制]]
- [[Spring事务]]
- [[微服务架构优缺点]]
- [[Ribbon负载均衡策略]]
- [[限流，降级，如何配置]]

506
logseq-java/journals/2023_12_18.md Normal file
View File

@@ -0,0 +1,506 @@
- mysql如何解决幻读
- 幻读，一个事务前后两次读取到的事务条数不一致
- MVCC
- 类似乐观锁，通过事务版本，通过undo的版本链进行管理，高版本可以看到事务的变更，低版本看不到高版本事务的变更，实现了不同事物之间的事物隔离
- 一个事务只能看到第一次查询之前已经提交的事务的修改以及当前事务的修改
- 一个事务不能看到当前事务第一次查询之后创建的事务，以及未提交的事务修改
- 如果存在当前读的情况下还是会出现幻读，当前读不是读的快照，而是内存
- 对于当前读LBCC基于锁的机制
- 行锁，表锁，间隙锁
- 在RR下，InnoDB采用一个MVCC的机制解决幻读的问题，如果存在当前读还是会幻读，尽量避免当前读或加锁来解决
- ![thumbnailwebp](https://static.flomoapp.com/file/2023-09-11/30463/1694258207_qFYxjC0q.jpg?OSSAccessKeyId=LTAI4G9PcaGksWVKCPrE1TVL&Expires=1703169857&Signature=s7w6CtfPnTidfhMkgHj10GvjuzM%3D)
- MySQL锁
- **全局锁**
- 针对整个数据库是锁，分为读锁和写锁
- 使用FLUSH TABLE WITH READ LOCK (FTWRL)添加全局读锁
- 使用UNLOCK TABLES释放锁定
- 在全库备份和全库导出时需要加全局锁
- 使用mysqldump --single-transaction -uroot -p example >example.sql导出备份文件添加single-transaction可以不用加全局锁
- **表锁**
- MyISAM表的读操作会自动加上读锁，写操作加上写锁
- InnoDB在必要情况下使用表锁，主要使用行锁实现MVCC，提供更好的并发性能和更少的锁冲突
- lock table example read；
- unlock tables；
- 使用场景
- -
- 读密集型应用
- -
- 写操作不频繁
- -
- 数据量不大
- -
- 全表更新或删除
- 风险
- -
- 性能下降
- -
- 并发性能差
- -
- 锁等待和超时
- -
- 写操作影响大
- -
- 死锁的可能性
- **行锁**
- 锁定单行数据，粒度更细，但是需要更多系统资源
- 主要由InnoDB提供
- select for update
- select lock in share mode
- insert update delete都会添加排他锁
- 使用场景
- -
- 高并发读写操作
- -
- 单行操作
- -
- 短期锁
- -
- 实现并发控制
- -
- 复杂的事物处理
- 风险
- -
- 死锁
- -
- 锁升级，升级为表锁，导致更多锁冲突
- -
- 锁等待
- -
- 资源消耗
- -
- 难以排查和调试
- -
- 事物隔离级别
- **乐观锁**
- 使用版本号来实现乐观锁
- **悲观锁**
- **意向共享锁和意向排他锁**
- **临键锁和记录锁**
- MySQL事物ACID特性
- 事物四大隔离级别
- 事务的底层锁机制
- MVCC并发优化机制
- volatile关键字
- -
- 可以保证在多线程环境下共享变量的可见性
- -
- 通过增加内存屏障防止多个指令之间的重排序
- 可见性是指当一个线程对于共享变量的修改，其他线程可以立刻看到修改后的一个值，可见性是由几个方面造成的，一个是CPU层面的高速缓存，CPU内部有三级缓存就会导致缓存一致性问题，而在多线程环境下缓存一致性就会导致可见性问题，对于增加了volatile关键字的一个共享变量，JVM虚拟机会自动添加一个#lock的汇编指令。而这个指令会根据不同的CPU型号添加总线锁或缓存锁
- 总线锁锁定cpu的前端总线，导致同一时刻只能有一个线程和内存通信，避免了多线程并发造成的可见性问题， 缓存锁是对总线锁的一个优化，总线锁导致cpu的使用效率大幅下降，缓存锁只针对cpu三级缓存中的目标数据加锁，缓存锁使用mesi一致性协议实现的
- 指令在编写的顺序和执行的顺序不一致导致内存可见性问题，指令重排序本质上是一种性能优化的手段，来自于几个方面，第一个方法是CPU层面针对于mesi协议的更进一步优化去提升cpu的利用率，引入一个叫storebuffer的一个机制，这种优化机制会导致cpu的乱序执行，为了避免这样的问题cpu提供了内存屏障指令，上层应用可以在合适的地方插入内存屏障避免cpu指令重排序
- 编译器在编译过程中在不改变单线程语义和程序正确性的前提下，对指令进行合理的重排序从而去优化整体的一个性能，添加了volatile关键字就不会触发编译器的优化，在jvm里面会插入内存屏障指令去避免重排序
- 除了volatile关键字从1.5开始jmm使用了一种Happens-Before的模型去描述多线程之间一个可见性的关系，如果两个操作具备happens-before关系那么这两个操作就具备可见性的一个关系 ，不需要通过volaitle增加可见性的保障
- mq中间件消息堆积
- 消费慢场景，
- **jvm处理慢**
- 加密解密，大数据量处理耗时，增加机器
- **数据入库慢**
- 新增不会是瓶颈，新增不锁行，可能是因为索引太多导致新增的性能下降
- 更多是对同一行记录的更新操作，更新会锁行导致执行排队
- 采用分而治之，将资源分散在几条记录里面
- 确实达到了瓶颈，使用分布式数据库中间间mycat，或使用分布式数据库mongodb，es
- **依赖外部慢**
- 对外部提要求，增加性能
- 一些非实时场景数据先入库持久化
- 要求外部也提供异步能力，给他们提供回调入口来操作数据
- 如何分析一条sql的性能
- explain，执行计划
- mysql内置了一个优化器，优化器的任务就是优化sql，尽可能以更低的成本去执行
- type表示mysql访问数据的方式，常见的有全表扫描（all）、遍历索引（index）、区间查询（range）、常量或等值查询（ref、eq_ref）、主键等值查询（const）、表中只有一条记录（system）
- system>const>eq_ref>ref>range>index>all
- key表示查询过程中实际会用到的索引名称
- rows表示查询过程中可能需要扫描的行数，不一定准确，是mysql抽样统计的数据
- Extra表示一些额外信息，通常会显示是否使用了索引，是否需要排序，是否会有用到临时表等
- select * 需要回到主键索引上查找对应的字段，需要回表，如果筛选出来的数据大部分都回表，mysql会选择全表扫描，如果认为索引回表的效率高才会走索引
- 有时候利用复合索引可以利用索引覆盖在来避免回表的过程
- MySQL性能分析
- **查**
- **看执行频次**
- 使用show global status like ‘Com_______’查看增删改各种操作执行频次
- **慢查询日志**
- 默认情况下超过10s就是慢查询，这个一般设置为1s long_query_time = 1
- 通过show VARIABLES LIKE 'slow_query_log'
- **show profile**
- 通过SELECT @@have_profiling 查看当前是否支持show profiles功能，返回yes就是支持
- 通过SELECT @@profiling 常看当前是否开启了show profiles性能分析功能，返回0不支持，返回1 支持
- 使用show PROFILES 查看执行的SQL列表，获取SQL的执行时间
- 使用show profile for query query_id 可以查看SQL执行各个阶段的用时
- 执行show profile cpu for query query_id可以查询指定query_id的SQL语句的CPU的使用情况
- **explain执行计划**
- 在select语句前增加explain关键字，执行完成之后就会返回执行计划的信息，如果from中包含子查询，MySQL会执行子查询并将结果放入临时表中
- id：id列的编号时select的序列号，有几个select就有几个id，id按照select出现的顺序增长，id列值越大优先级越高，id相同按照执行计划从上往下执行，id为空最后执行
- select_type:表示对应行是简单还是复杂查询，有simple，primary，subquery，union
- type：表示连接类型、性能由好到差为NULL、system、const、eq_ref、ref、range、index、all，需要避免all全表扫描的出现
- possible_keys:表示在当前语句中可能用到的索引
- key：表示当前语句中用到的索引
- key_len:表示索引中使用的字节数，该值为索引字段最大可能长度，并非实际使用长度，在不损失精度的情况下，长度越短越好
- rows：MySQL认为必须执行查询的行数，在InnoDB中是一个估计值
- filtered：表示返回结果的函数占需要读取函数的百分比，越高越好
- 负载均衡算法
- **静态**
- -
- 轮询
- -
- 随机
- -
- 权重
- -
- IP
- -
- URL哈希
- -
- 一致性哈希，IP+URL
- **动态**
- -
- 最少连接数
- -
- 最快响应
- -
- 观察：以连接数和响应时间为平衡依据
- -
- 预测：收集当前服务器性能指标，预测下个时间段性能最佳服务器
- -
- 动态性能分配：收集服务器各项性能指标，动态调整流量分配
- -
- 服务质量：根据服务质量选择
- -
- 服务类型：根据服务类型选择
- **自定义**
- -
- 灰度发布：平滑过渡的发布方式，降低发布风险，减少影响范围，出现故障快速回滚，不影响用户
- -
- 版本隔离：为了兼容或过渡，某些应用有多个版本，保证1.0版本不会调到1.1版本服务
- -
- 故障隔离： 生产出故障之后将故障的实例隔离，不影响其他用户，同时保留故障信息便于分析
- -
- 定制策略：根据业务情况定制跟业务场景最为匹配的策略
- 轮询+权重=加权轮询
- 最快响应+权重，可以根据响应时间动态调整服务器权重
- **中间件使用的算法**
- -
- Nginx
- -
- RonundRobin：轮询
- -
- WeightedRoundRobin:加权轮询
- -
- IPHash：按照IP的Hash选择
- -
- URLHash：按请求URL的Hah选择
- -
- Fair：根据后端服务器响应时间判断选择复制最轻服务器分流
- -
- Dubbo
- -
- RandomLoadBalance：加权随机
- -
- RoundRobinLoadBanlance：加权轮询
- -
- LeastActionLoadBalance：最少连接数
- -
- ShortestResponseLoadBalance：最短响应时间
- -
- ConsistentHashLoadBalance：一致性Hash
- -
- Ribbon
- -
- RoundRobinRule：轮询
- -
- RandomRule：随机
- -
- WeightedResponseTimeRule：根据响应时间来分配权重
- -
- BestAvailableRule：先过滤掉由于多次访问故障处于断路器跳闸状态的服务，然后选择一个并发量最小的服务
- -
- RetryRule：先按照轮询策略获取服务，如果获取服务失败在指定时间内进行重试，获取可用的服务
- -
- ZoneAvoidanceRule:根据性能和可用性选择服务
- -
- AvailableFilteringRule：会先过滤掉由于多次访问故障处于断路器状态的服务，还有并发量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问
- 什么是缓存穿透？如何避免？
- 被攻击，缓存key不存在，去数据库查询
- 布隆过滤器，bitmap
- 一种概率的判断算法，判断一个数据是否存在，通过一个二进制数据和一个Hash算法实现
- 误判问题
- 哈希冲突，计算出来不一定存在
- 通过增大数组和增加哈希函数
- 如何解决重复消费
- 如果使用了消息中间件，没有办法避免MQ中消息重复的
- 消费是做幂等性处理
- -
- MVCC多版本并发控制(生产的时候带上数据的版本号)，该方法有很多不便
- -
- 去重表方案，利用数据库特性建立
- 为什么kafka不支持读写分离？
- 读写分离，主从架构，主写从读
- -
- 数据一致性问题
- -
- 延时问题，数据同步为异步操作，kafka保证数据可靠性需要保存到硬盘，延时比较高
- -
- 实现了主写从读，负载均衡无法实现
- -
- 不实现读写分离架构简单，出错可能性小
- -
- 多副本机制简单很多
- 有几百万消息持续积压几小时，如何解决？
- 消息挤压，——线上故障（消费者）几百万消息MQ中挤压
- -
- 修复消费者，可能消耗几个小时。
- 临时扩容，一个消费者1秒消费1000，3个消费者3000，一分钟18万，800万需要40-50分钟
- 临时借调机器，队列和消费者10倍
- 需要建立一个消费者同时也是一个生产者，将原来的消息消费然后重新生产传送到其他queue里面，同时将原来三个queue里面的消息扩散到30个queue中
- 1. 积压消息的类型，那些消息重要，那些不重要（快速消费）确定哪些业务的消息处理是优先级最高的，优先处理这些消息；
2. 考虑将部分业务逻辑转移到备用系统上，以减轻主系统的压力；
3. 查看具体业务是否有查询，插入，修改操作，评估 DB 处理能力（优化索引）；
4. 评估是否可以批量操作或者多线程处理
5. 水平扩展服务器资源，包括数据库，服务器，消息队列服务器，来提升性能；
- AQS唤醒节点时，为什么从后往前找？
- Node节点插入到整个AQS队列时是先把当前节点的上一个指针指向前面的节点，再把tail指向尾，这个时候会有一个CPU调度的问题，如果卡在这个位置就会出现前一个节点的指针还是指向null，会总成一个节点丢失的问题
- 当某一个节点取消之后，会执行一个cancelAcquire方法，这个方法也是先去调整上一个指针的指向，next指针是后续才动的
- 插入和取消都是先动前面prev的节点，所有prev才是指向的优先级较高或时效性较好的指向
- 从前往后找会错过某个节点，造成某个null然后挂起，之前线程已经释放资源并没有释放锁
- hashmap方法体内线程安全
- 可能会存在逃逸现象，不能保证方法体内都是线程安全的，只要hashmap出现被多个线程引用的情况就会出行线程不安全问题
- 前后端自增数据ID容易被人猜到，长度大于16位给前端会有精度丢失问题
- 自增id，水平越权，不可能不考虑，属于重大隐私安全问题。用uuid会损失插入性能，再不济使用雪花算法
- 16位千万亿数据量级别
- long类型数据返回给前端会精度丢失，通过一个转换器转换为字符串解决
- mysql一主二从
- 解决高并发主从同步延迟数据不一致问题
- 提高效率降低延迟
- 增加从服务器配置，增加带宽，参数优化，修改并发复制的参数，避免长事务的sql，或者在主从服务器的负载均衡主服务器权重大一些，强一致性的方案，直接读取主库
- 分布式ID
- mysql使用自增ID
- 分布式ID的解决方案和算法没有太大关系，雪花算法顶多是一个主键解决方案（唯一主键解决方案），
- 假如让你设计一个订单表，订单号会用主键吗
- 主键代表的含义是这张表唯一的标识或流水号，不应该具备任何业务含义，可不可以用单表主键做业务ID？当然可以，很多小的后端系统就这么用的，但是大型的分布式式系统里面往往会有一个分布式ID的生成服务，这个服务用雪花算法用什么都和我们没有关系，但是需要保证给我们的业务ID在我们这个业务领域里面是唯一的，这个订单号不管在支付系统，物流系统还是财务系统，都应该是能够唯一标识订单的，有些ID还会用各种业务字符串来让这个业务ID更加清楚的表达业务含义，不如在订单号前加order前缀，或者加部门这些信息，所以你看现在这些快递单号为什么纯数字不行，邮政公司还要牵头加一个什么物流公司的拼音前缀，都是有原因的，小系统自增和雪花算法都没有区别，但是在大系统里面系统ID和业务ID是不一致的，最好分开，做关联查询的时候呢，最佳方案是用业务id
- 分库分表重复的问题
- 为什么要分库分表，数量的增长单表无法容纳了，这个时候单纯用分库分表解决可能以后还要在分库分表，数据还要再重新散列一遍，需要分库分表时需要慎重考虑是否能够更引入一个可以横向扩展的分布式数据库来解决
- **基于stata的xa做分布式事务**
- xa性能最差，但是强一致性，
- 协调事务2pc，3pc
- 最终一致性，本地消息表，事务消息
- 默认at是两阶段提交，两点对于sql进行分析，sql执行前后的数据镜像进行保存，生成一些回滚日志，优点代码无侵入，缺点是必须要基于关系型数据库
- tcc，try confirm and cancer，需要侵入代码，手动编写预留，确认，回滚的方法，本来是一个操作逻辑需要分散在三个方法里去做，因为设计到预留资源的问题，数据库也要一起跟着变化，特别不适合已经有完善数据库设计的项目，saga是基于最终一致性的方案，通过状态机去执行一个已经定义好控制流程的json文件来控制整个流程的提交，回滚的方式，但是和TCC一样也需要侵入代码去实现补偿逻辑，前面三种都有一个共同问题，都是补偿型事务，就是弱一致性，如果需要强一致性，只有xa模式。这个模式是只要实现了xa协议的数据库都可以很好支持，我们用的库是mysql5.7当然支持了，而且代码编写上和at模式一样没有侵入，还能和at模式进行简单切换，性能差该一个配置文件即可，实际业务和钱有关需要强一致性，并发量并不大，xa模式没有问题
- **分表之后按照时间查询**
- 按照某一个字段进行水平拆分
- 决定按照某个字段去分表，就不可能不带着这个字段去查询
- 倒序查询，表少可以查询出来到内存中进行聚合，ES，MongoDB这种分布式数据库都是这么做的，但是mysql不是分布式的，单机会成为性能瓶颈，表太多这么做性能直线下降，分表的本意就是为了提高性能，做评论审核页面就是按照时间倒序去排序的，技术往往是结合来做的，我们有三张表，是按照用户维度，文章维度分表，还有一个全量表，因为有分页限制查询不会慢，审核完成后再同步到另外两套表中 ，完美解决了业务问题
- spring解决循环依赖
- 温柔方案
- 开启支持循环依赖的配置，spring就会在初始化bean的时候启用三级缓存来解决，a、b两个互相依赖的bean，spring在初始化a的时候先去一二三级缓存中拿a，如果没有就会去实例化a并把啊的对象工厂放到三级缓存中，然后初始化a的时候给a set了各种属性，发现依赖b，然后去创建b，创建b的过程也是一样的，b可以在三级缓存中拿到a的对象工厂，并且这个工厂对象会把a的对象放到二级缓存中，b可以顺利完成初始化，同时把b放入一级缓存中，b初始化完成之后， a顺利注入b完成初始化，这样就解决了循环依赖的问题
- 粗鲁方案
- Spring默认不启用支持循环依赖
- 循环依赖是代码不规范导致的，正确的情况是不应该出现循环依赖，写一个c去分别应用a和b
- 为什么都使用hashmap
- 使用时都是在方法体里面声明
- 每一个方法调用时都是单独线程
- 用static修饰变为静态全局变量，多线程调用put方法才会出问题，用currenthashmap才有意义，声明一个static的hashmap大部分情况下是当作一个jvm的缓存来使用的，有分布式缓存redis，jvm缓存caffeine不太用hashmap
- **幂等性**
- 新增收入利润的情况，
- 提交两次编辑和新增同一个接口，编辑不会有问题，但是新增时会有问题，新增两个数据
- 底层逻辑是**串行查询**
- 通过分布式锁解决
- 解决的核心是做重复性判断，高并发场景下两个线程同时查到没有然后分别插入，分布式锁锁的是查询的过程，保证查询是串行操作，查到的一定是数据库里面最新的数据，然后去做相应 的业务逻辑，先去通过唯一性的标识查询该条数据有没有，然后插入或更新数据
- **解决分布式事务**
- 协调事务和最终一致性方案
- 协调事务：2PC，3PC，协调者高可用，协调不一致，一方提交或回滚成功了，第二方提交或回滚失败，只能降低这种情况发生概率，无法完全避免，存在一定的阻塞，性能相对来说差一些。XA
- 最终一致性方案：本地消息表，TCC，Saga，无阻塞，可以提供较好的性能，但是无法保证强一致性，本地消息表存在写入失败或更新失败的问题，TCC需要先预留资源，涉及到幂等的问题
- 分布式事务一定遵循分布式理论的，当分区条件满足时，一致性和可用性就无法同时满足。
- 怎么同时解决一致性和可用性的问题？无法解决
- 用会员积分来兑换商品，会员积分和订单是两个服务，采用dubbo来交互，采用阿里云seata，seata最大核心功能就是事务协调器，支持dubbo，而且seata还支持4种模式at，tcc，saga，xa模式，积分来兑换商品的业务场景相对简单，不涉及到优惠券这种复杂的业务逻辑，综合考虑用at模式来实现。at模式基于 数据源代理对sql进行解析，把操作过的数据记录在undo'log表种，简单来说，就是参与事务的ab双方会注册到事务协调器，并且获取到一个全局事务ID注册到本地，a先开启本地事务拿到本地锁，事务提交前拿到全局锁释放本地锁，a的事务准备好之后b拿到本地锁，开始本地事务操作，b操作完成之后释放本地锁，开始争抢全局锁，此时ab双方都处于prepare状态，事务协调器向双发发起commit命令，a执行commit命令后会释放全局锁，b获取全局锁执行commit，a失败后b获取不到全局锁会回滚，a成功b失败，全局事务失败，事务协调器向a发送回滚命令。a根据全局事务的ID在本地表中查询回滚的数据回滚，由此来保证数据的强一致性
- 还有一个注册送积分的，这里面对一致性要求没有那么高，采用的方式是注册完成之后下发一条kafaka消息，如果要做分布式事务呢，在本地建一个本地消息表，在注册这个事务的时候往本地消息表里写一条赠送积分的消息，并把状态置于待确认，后期赠送完成之后可以把消息更新为已确认或者删除这条消息，但是真正工作里没有这样做，原因是我们发现赠送失败的场景几乎没有，并且这个数据就算是出错了，在业务层面也是可以接受的，采用无事务的思想，通过日日记录异常监控报警来保证赠送积分的成功，如果真的因为各种原因赠送失败了，通过人工介入来处理
- **hashmap的结构，put和get操作**
- **hashmap为什么 @使用红黑树**
- **concurrentHashMap，1.7segment，1.8synchronized和CAS，**
- concurrenthashmap使用reentrantLock
- **synchronized，jdk版本升级有优化**，reentrantlock是java代码实现的，优化比较少
- **synchronized对锁的优化**
- 两个线程竞争锁，升级成为重量级锁
- 看是XX部门，部门的日常工作主要有哪些
- InnoDB和myISAM的区别
- InnoDB为什么能支持事务
- redolog和undolog的区别
- binglog作用
- 同步binlog主一个时间，从一个事件，底层怎么解决，或者说同一个sql主和从是不一致的，binlog是怎么让他们同步的？主生成的sql和从生成的sql不一定一致，他有没有做过什么处理
- volatile有什么作用
- synchronized底层怎么实现的
- synchronized锁升级
- 偏向锁的批量重偏向是多少次，为什么是这么多次（跟字节有关）
- reentrantlock怎么实现公平，怎么实现可重入
- redis分布式锁的原理
- 看门狗还有多少时间会续期
- redis设置锁怎么保证原子性
- lua一定是原子性的吗
- cas的aba问题怎么解决
- 分布式id有了解吗，雪花算法怎么实现的，头几个代表的是什么，分布式id遇到时钟回拨怎么解决
- hashmap为什么升级为红黑树
- arraylist和linkedlist查询时间复杂度和空间复杂度
- 有没有可能redis因为主从哨兵，两个线程拿到同一个锁的情况，怎么办（红锁，有一半以上节点拿到锁才成功）
- redis中的锁是ca还是ap（说ap，问有没有可能两个线程拿到同样锁的情况）
- cp锁和ap锁有什么区别
- 主从同步 出了一些问题，怎么保证最终一致性
- DDD了解吗
- 生产环境上3主3从的数据库，现在有个机器要去连，你会连6个Datasource还是怎么连，yaml文件你怎么配置，或者说你会用什么样的中间件去做一些代理还是怎么样
- nginx有了解吗，nginx挂了怎么办，可不可以做集群
- 伪IP有了解过吗
- keep alive有了解过吗
- safe-hdfs这种分布式存储有了解过吗
- redis的rdb和aof有啥区别
- rdb突然断电怎么办
- 哨兵模式原理
- 双亲委派机制
- 垃圾回收机制原理
- 让你JVM调优，你会怎么调
- 聊了很多锁，IO密集型和CPU密集型分别适合哪些锁
- countdownlatch和信号量都知道吗
- rabbitMQ的死信队列和延迟队列有了解吗
- 消息丢失怎么办
- rabbitMQ能不能业务逻辑上最终一致性
- TCP和HTTP协议
- 为什么是三次握手
- 为什么挥手是四次
- Object的equals和hashcode是干什么用的
- hashmap怎么解决哈希碰撞
- 多线程线程越多越好吗
- Spring中一个类2个方法，a和b都加了事务注解，a方法调用b方法，b的事务会生效吗
- 直接声明string=a和new一个string构造传a有什么区别
- new一个字符串想要加入常量池里面应该怎么做
- 哈希数组，哈希桶原理，通过哈希取余计算得到下标
- synchorinzed锁升级
- 查询sql执行性能
- 可重复读，读取未提交的数据
- bean的生命周期
- spring加载时缓存预热
- 线程池核心参数
- 1. 离职原因：被裁员 面试时：原本的工作没有办法满足我的成长，期望找一个更大的平台发挥。
- 2. 离职原因：原单位钱太少 面试时：我觉得自己己经具备了一定的积累，希望可以迈向一个新的台阶。
- 3. 离职原因：跟同事处不来。 面试时：我很重视平台的发展，我认业个人才 只有放在合适的平台才能够最大程度的发挥出 自己的才干。
- 4. 离职原因：有个大领导。 面试时：虽然我已经有相当的经验和技能，但仍希望能够拓宽自己的知识面，进行更深入的学习和实践。
- 5. 离职原因：原单位扯皮甩锅大战。 面试时：我认为一个良好的工作氛围能够提高 工作氛围，明确的分 工和相对完善的制度是提高生产力的基本保障。
- 6. 离职原因：提拔无望。 面试时：我认为人不应该满足现状，而是应该积极进取，如果不能够适时挑战自己，逼自己 一把，怎么能够最大程度的挖掘自己的潜力呢？
- 7.离职原因：大*管理制度太多。 面试时：贵公司所推崇的人性化管理非常符合 我对工作环境的预期，我也相信在这样的环境中，我能够发挥出更大的主观能动性。
- MySQL为什么使用B+树索引
- B树是一种多路平衡树，存储大量数据时相对高度比二叉树矮很多，而数据存储在磁盘上，磁盘IO效率比较低，特别时随机磁盘IO，树的高度决定磁盘IO次数，IO次数越少，性能提升越大
- B+树优化
- -
- 所有数据都存储在叶子节点上，非叶子节点只存储索引，每一层存储索引数据增加，相同层数下数据量更多
- -
- 叶子节点中的数据使用双向链表方式进行关联，查询时只需查两个节点进行遍历即可
- -
- 由于所有数据都存储在叶子节点，B+树的IO次数更加稳定
- -
- 叶子节点存储所有数据，全局扫描能力更强，只需要扫描叶子节点
- -
- 采用自增主键，能更好避免增加数据时带来叶子节点分裂导致大量运算的问题
- SpringIOC的工作流程
- -
- IOC是什么
- 控制反转
- -
- Bean的声明方式
- xml
- -
- IOC工作流程
- -
- IOC容器初始化阶段
- 根据程序内部的xml或注解等Bean的声明方式，通过解析和加载后生成BeanDefination，然后将BeanDefination注册到IOC容器内部，通过注解和xml声明的注解解析后都会得到一个BeanDefination实体，这个实体包含Bean的一些定义和基本属性，最后将BeanDefination保存到一个map集合里面，完成IOC的初始化
- IOC容器的作用就是对这些注册的Bean 的定义信息进行处理和维护，它是IOC容器控制反转的一个核心
- 2.完成Bean的初始化和依赖注入
- -
- 通过反射区去针对没有设置lazy-init属性的单例Bean进行初始化
- -
- 完成Bean的依赖注入
- -
- Bean的使用
- 通过@Autowired注解或BeanFactory.getBean()从IOC容器中获取一个指定的bean的实例，针对设置了lazy-init属性及非单例Bean的实例化，在每一次获取Bean对象时调用Bean的初始化方法完成实例化，并且SpringIOC容器不会去管理这些Bean
- Redis哨兵和集群的区别
- 主从，读写分离，提升工作效率
- 哨兵，监控机制，主节点故障
- Cluster，Slot槽0-16383，分配区间，多个主从节点，主节点故障自动转移
- -
- 客户端实现更加复杂
- -
- Slave节点只是一个冷备节点，不分胆担读写压力
- -
- 对于批量操作指令有限制
- 为什么禁止@Transactions
- -
- 方法上添加后会导致长事务，一个方法存在较多耗时操作，带来锁的竞争影响性能导致数据库连接池消耗殆尽，影响程序正常执行
- -
- 如果有事务嵌套，容易引起事务混乱，导致程序运行结果出现异常
- -
- 将事务控制逻辑放在注解里面，项目复杂度增加，事务控制变复杂，导致代码可读性和可维护性下降
- 使用编程式事务
- -
- 灵活控制事务的范围
- -
- 减少事务的锁定时间
- -
- 提高系统的性能
- ES数据和数据库数据不一致
- SpringBoot优势
- SpringBoot自动装配流程
- Spring import注解
- 注册Bean注入IOC容器（5种）
- 负载均衡算法
- kakfa如何确定key的分区
- HashMap 开放寻址法
- 头插法和尾插法
- redis使用头插
- Rdis优势，数据丢失场景，解决脑裂
- 分布式锁过期
- Redis分布式锁数据类型
- 时间轮实现
- 接口非常慢如何解决（慢SQL，SQL语句分页，数据量过大，频繁更新，分库分表）
- 线程池在工作中如何使用，参数如何设置
- 线程池如何线程复用
- 关于招呼模版：您好，我对您的发布的岗位非常感兴趣，我有XX、XX、XX、等项目经验/工作经验，有XX\XX\XX项目成果/工作成果，熟练掌握XX\XX\XX软件应用，持有XX\XX等资格证书，对工作中XX\XX模块非常熟悉，具体您可以看看我的简历：（附上你的简历链接，简历链接推荐用腾讯文档，设置PDF，记住要生成永久链接）
- 如果你在第一步就通过话术引导对方对你产生兴趣，再附上简历的链接，这样一目了然，做事逻辑性这么强，HR肯定排着队要录用你！最后记得登陆你的腾讯表格，看看该文件被查阅的数据，了解你自己的市场竞争力，知己知彼才能打胜仗。
- -
- 先做一个自我介绍（这是必须的）
- -
- 说一下你之前做项目的一个业务流程（详细业务流程）
- -
- 这个项目你使用了多线程吗？你是如何实现的？
- -
- 你说多线程这块你做了性能优化，你能说一下优化的方式和优化的结果吗？
- -
- 事务使用过吗？事务和锁一起使用会不会有什么问题？是先使用锁还是先使用事务？
- -
- springcloud 的注册服务使用的什么？除了这个还有其他的了解吗？
- -
- 消息队列用过吗？你大致讲一下。
- -
- 先做一个 10 分钟左右的简短介绍，包括几个方面：你工作的经验，你在这些工作中你的优势是什么？你擅长什么？
- -
- mybatis 中的 #{} 和 ${} 有什么区别？默认使用哪个？为什么这么使用？
- -
- 介绍一下 Spring，说一下 Spring 常用注解的用途。
- -
- 说一下 SpringAOP 的概念，实际运用场景。
- -
- 现在有个对象 user，通过参数传递到其他方法中去，然后 user 的 name 改变了，那么传递的这个对象是值传递还是引用传递，为什么？顺便解释一下值传递和引用传递。
- -
- 项目中是如何使用事务的？
- -
- 项目中用过多线程吗？如何保证多线程线程安全的？具体你做了哪些操作来实现的？
- -
- 你之前做过 PHP？你讲一下 PHP 和 Java 的区别呢？
- -
- 先做个自我介绍。
- -
- 现有一多文件上传需求，要求在 5M 带宽的服务器上上传超过 100 张图片，并且保证用户可以尽快看到上传结果。
- -
- springcloud 中 A 服务要调用 B 服务，同时需要将 token 传入 B 服务中，请问使用什么方式传递？
- -
- 讲一下你现在做的系统的业务逻辑，用到了什么技术？
- -
- mybatis 分页是怎么做的？
- -
- 事务你用过吗？
- -
- 用过哪些工具类？处理时间和 JSON 你是用的什么工具？
- -
- MongoDB 中针对于百万级别的数据，如何优化查询？如何分页？如何创建索引？做过数据统计那么统计的精度是每天还是每个月还是每年？如果去动态查询这些统计数据？