Clive Blog

JAVA基础

Thu, 12 Sep 2024 06:10:00 GMT

什么是jvm：Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果

1.为什么说 Java 语言“编译与解释并存”？

编译型：编译型语言会通过编译器将源代码一次性翻译成可被该平台执行的机器码。一般情况下，编译语言的执行速度比较快，开发效率比较低。

解释型：解释型语言open in new window会通过解释器open in new window一句一句的将代码解释（interpret）为机器代码后再执行。解释型语言开发效率比较快，执行速度比较慢。常见的解释性语言有 Python、JavaScript、PHP 等等。

这是因为 Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行

2.AOT 有什么优点？为什么不全部使用 AOT 呢？

JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation) 。和 JIT 不同的是，这种编译模式会在程序被执行前就将其编译成机器码，属于静态编译（C、 C++，Rust，Go 等语言就是静态编译）。AOT 避免了 JIT 预热等各方面的开销，可以提高 Java 程序的启动速度，避免预热时间长。并且，AOT 还能减少内存占用和增强 Java 程序的安全性（AOT 编译后的代码不容易被反编译和修改），特别适合云原生场景。

缺点：AOT 编译无法支持 Java 的一些动态特性，如反射、动态代理、动态加载、JNI（Java Native Interface）等。然而，很多框架和库（如 Spring、CGLIB）都用到了这些特性。如果只使用 AOT 编译，那就没办法使用这些框架和库了，或者说需要针对性地去做适配和优化

CGLIB 动态代理使用的是 ASM 技术，而这种技术大致原理是运行时直接在内存中生成并加载修改后的字节码文件也就是 .class 文件，如果全部使用 AOT 提前编译，也就不能使用 ASM 技术了。为了支持类似的动态特性，所以选择使用 JIT 即时编译器。

3.基本数据类型大小

byte:1字节

short:2字节

int:4字节

long:8字节

char:2字节

float:4字节

double:8字节

Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 True or False。

为什么说是几乎所有对象实例都存在于堆中呢？ 这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存

4.字符型常量和字符串常量的区别?

形式上: 字符常量是单引号引起的一个字符; 字符串常量是双引号引起的 0 个或若干个字符
含义上: 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)
占内存大小字符常量只占 2 个字节; 字符串常量占若干个字节 (注意： char 在 Java 中占两个字节)

5.对象的相等和引用相等的区别

对象的相等一般比较的是内存中存放的内容是否相等。
引用相等一般比较的是他们指向的内存地址是否相等。

6.深拷贝 vs 浅拷贝vs引用拷贝

浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。
引用拷贝：简单来说，引用拷贝就是两个不同的引用指向同一个对象。
==clone接口实现：浅克隆：创建新的引用地址，基本数据类型值传递，引用数据类型引用传递==

7.Object 类的常见方法有哪些？

getClass,clone,equals,hashCode,wait,join,toString,notify,notifyAll,finalize(实例被垃圾回收器回收的时候触发的操作)

8.Java 序列化中如果有些字段不想进行序列化，怎么办？

用关键字transient:阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。transient 只能修饰变量，不能修饰类和方法。

9.s`tring` 的底层实现由 `char[]` 改成了 `byte[]` ?

Java 9 为何要将 String 的底层实现由 char[] 改成了 byte[] ? 编码占位问题

新版的 String 其实支持两个编码方案：Latin-1 和 UTF-16。

10.字符串常量池的作用了解吗？

字符串常量池 是 JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。

11.字符型常量和字符串常量的区别?

形式上: 字符常量是单引号引起的一个字符; 字符串常量是双引号引起的 0 个或若干个字符
含义上: 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)
占内存大小字符常量只占 2 个字节; 字符串常量占若干个字节 (注意： char 在 Java 中占两个字节),

12.String#intern 方法有什么作用?

String.intern() 是一个 native（本地）方法，其作用是将指定的字符串对象的引用保存在字符串常量池中，可以简单分为两种情况：

如果字符串常量池中保存了对应的字符串对象的引用，就直接返回该引用。

如果字符串常量池中没有保存了对应的字符串对象的引用，那就在常量池中创建一个指向该字符串对象的引用并返回。

*   // 在堆中创建字符串对象”Java“     // 将字符串对象”Java“的引用保存在字符串常量池中     String s1 = "Java";     // 直接返回字符串常量池中字符串对象”Java“对应的引用     String s2 = s1.intern();     // 会在堆中在单独创建一个字符串对象     String s3 = new String("Java");     // 直接返回字符串常量池中字符串对象”Java“对应的引用     String s4 = s3.intern();     // s1 和 s2 指向的是堆中的同一个对象     System.out.println(s1 == s2); // true     // s3 和 s4 指向的是堆中不同的对象     System.out.println(s3 == s4); // false     // s1 和 s4 指向的是堆中的同一个对象     System.out.println(s1 == s4); //true

13.Exception 和 Error 有什么区别？

所有的异常都有一个共同的祖先 java.lang 包中的 Throwable 类。Throwable 类有两个重要的子类:

Exception :程序本身可以处理的异常，可以通过 catch 来进行捕获。Exception 又可以分为 Checked Exception (受检查异常，必须处理) 和 Unchecked Exception (不受检查异常，可以不处理)。
Error：Error 属于程序无法处理的错误，我们没办法通过 catch 来进行捕获不建议通过catch捕获。例如 Java 虚拟机运行错误（Virtual MachineError）、虚拟机内存不够错误(OutOfMemoryError)、类定义错误（NoClassDefFoundError）等。这些异常发生时，Java 虚拟机（JVM）一般会选择线程终止。

Checked Exception 和 Unchecked Exception 有什么区别？

Checked Exception 即受检查异常，Java 代码在编译过程中，如果受检查异常没有被 catch或者throws 关键字处理的话，就没办法通过编译。

14.finally 中的代码一定会执行吗？

不一定的！在某些情况下，finally 中的代码不会被执行。

就比如说 finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。

程序所在的线程死亡。
关闭 CPU。

15.泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

什么是泛型：泛型的本质就是参数化类型。也就是，将一个数据类型指定为参数。

泛型擦除：泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。

引入泛型有什么好处呢？

16.SPI机制

专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。

很多框架都使用了 Java 的 SPI 机制，比如：Spring 框架、数据库加载驱动、日志接口、以及 Dubbo 的扩展实现等等。

SPI 的优缺点？

通过 SPI 机制能够大大地提高接口设计的灵活性，但是 SPI 机制也存在一些缺点，比如：

需要遍历加载所有的实现类，不能做到按需加载，这样效率还是相对较低的。
当多个 ServiceLoader 同时 load 时，会有并发问题。

17.序列号&反序列化

序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。

（1）`serialVersionUID`

序列化号 serialVersionUID 属于版本控制的作用。反序列化时，会检查 serialVersionUID 是否和当前类的 serialVersionUID 一致。如果 serialVersionUID 不一致则会抛出 InvalidClassException 异常。

推荐每个序列化类都手动指定其 serialVersionUID，如果不手动指定，那么编译器会动态生成默认的 serialVersionUID。

serialVersionUID 不是被 static 变量修饰了吗？为什么还会被“序列化”？

static 修饰的变量是静态变量，属于类而非类的实例，本身是不会被序列化的。然而，serialVersionUID 是一个特例，serialVersionUID 的序列化做了特殊处理。当一个对象被序列化时，serialVersionUID 会被写入到序列化的二进制流中；在反序列化时，也会解析它并做一致性判断，以此来验证序列化对象的版本一致性。如果两者不匹配，反序列化过程将抛出 InvalidClassException，因为这通常意味着序列化的类的定义已经发生了更改，可能不再兼容。

也就是说，serialVersionUID 只是用来被 JVM 识别，实际并没有被序列化。

（2）如果有些字段不想进行序列化怎么办？

对于不想进行序列化的变量，可以使用 transient 关键字修饰。

transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

关于 transient 还有几点注意：

transient 只能修饰变量，不能修饰类和方法。
transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。
static 变量因为不属于任何对象(Object)，所以无论有没有 transient 关键字修饰，均不会被序列化。

为什么不推荐使用 JDK 自带的序列化？不支持跨语言调用；性能差；存在安全问题；

18.IO流

IO 即 Input/Output，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出

1.I/O 流为什么要分为字节流和字符流呢?

问题本质想问：不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时；
如果我们不知道编码类型的话，使用字节流的过程中很容易出现乱码问题

19.java的Unsafe类

20.创建对象的三个步骤

1.类加载检查

2.分配内存空间

3.类的初始化

4.设置对象头

5.执行init方式

21.成员变量与局部变量的区别有哪些？

从语法形式上看:成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

22.面向对象和面向过程的区别

面向过程性能比面向对象高，是因为java属于半编译型语言，不是cpu可以直接运行的语言

面向对象：面向对象易维护、易复用、易扩展。

23.==和 equals 的区别

==比较的是内存地址，基本数据则是值，equals比较的是引用对象的值
equals 没有被重写时等价于“==”，比较对象。

24、为什么 Java 中只有值传递？

Java 程序设计语言对对象采用的不是引用调用，实际上，对象引用是按值传递的。

【转】解决Jenkins用shell脚本部署后，jar包启动失败的问题

Fri, 05 Jan 2024 07:02:00 GMT

原文：https://blog.csdn.net/fenduo/article/details/114937832

使用root账号登录，在本地执行.sh脚本文件没有任何问题。

但是jenkins部署时死活不行，并且错误很奇怪，只有kill进程和拷jar包成功了。。。起服务就是起不来。

产生原因：

shell脚本发布时，会衍生进程，Jenkins默认会自动杀掉衍生进程

解决方案1：

在执行shell脚本前，加个build_ID参数即可

BUILD_ID=DONTKILLME

解决方案2：执行的脚本中加这一段也可以

```

#项目jar包名称

APP_NAME=smcc-0.0.1-SNAPSHOT.jar

#重启命令

pid=`ps -ef | grep $APP_NAME | grep -v grep |awk '{print $2}'`

if [ $pid ]; then

echo :App is running pid=$pid

kill -9 $pid

BUILD_ID=DONTKILLME

nohup java -jar $APP_NAME> sm.log 2>&1 &

```

2023届·1024闯关赢大奖-攻略

Wed, 25 Oct 2023 02:33:00 GMT

活动地址：http://1024.cliveyuan.cn/

攻略视频：

SpringBoot中使用策略模式优雅干掉if-else

Fri, 20 Oct 2023 08:49:00 GMT

前言

在阅读了一篇微信公众号文章《用设计模式干掉 if-else，太优雅了！》后，考虑到在SpringBoot项目中真实使用时，策略是IoC管理的而不是每次都由工厂创建，所以按自己的思路实现了一版比较简单的方案。

代码

代码清单

TypeEnum.java // 类型枚举类 ReceiptReq.java // 接口请求入参 ReceiptHandleStrategy.java // 接口 DefaultReceiptHandleStrategy.java // 默认接口实现 MT1101ReceiptHandleStrategy.java // MT1101类型对应的接口实现 Mt2101ReceiptHandleStrategy.java // MT2101类型对应的接口实现 ReceiptStrategyTest.java // 测试类

枚举类`TypeEnum.java`

package cn.cliveyuan.learn.test.strategy;  /**  * @author Clive Yuan  * @date 2023-10-20 16:32  */ public enum TypeEnum {     MT1101, MT2101, MT4101, MT8104, MT8105, MT9999 }

接口请求入参类`ReceiptReq.java`

package cn.cliveyuan.learn.test.strategy;  import lombok.Data;  /**  * @author Clive Yuan  * @date 2023-10-20 16:32  */ @Data public class ReceiptReq {     private TypeEnum typeEnum;     private String data; }

接口类`ReceiptHandleStrategy.java`

package cn.cliveyuan.learn.test.strategy;  /**  * @author Clive Yuan  * @date 2023-10-20 16:33  */ public interface ReceiptHandleStrategy {      /**      * 获取类型枚举 (每个类型实现类中指定)      */     TypeEnum getType();      /**      * 处理业务逻辑      */     void handleReceipt(ReceiptReq receipt); }

默认接口实现类`DefaultReceiptHandleStrategy.java`

package cn.cliveyuan.learn.test.strategy;  import org.springframework.context.annotation.Primary; import org.springframework.stereotype.Component;  import javax.annotation.PostConstruct; import javax.annotation.Resource; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects;  /**  * @author Clive Yuan  * @date 2023-10-20 16:34  */ @Component @Primary // 默认实现 public class DefaultReceiptHandleStrategy implements ReceiptHandleStrategy {     /**      * 从IoC容器中获取所有实现了ReceiptHandleStrategy接口的Bean      */     @Resource     private List<ReceiptHandleStrategy> receiptHandleStrategyList;     /**      * 定义一个静态Map用于存储类型枚举对应的实现      */     private static final Map<TypeEnum, ReceiptHandleStrategy> STRATEGY_MAP = new HashMap<>();      /**      * 初始化      * 遍历所有接口实现类,获取其类型并存入Map中      */     @PostConstruct     public void init() {         for (ReceiptHandleStrategy receiptHandleStrategy : receiptHandleStrategyList) {             // 跳过type为空的实现类,即当前默认实现类DefaultReceiptHandleStrategy             if (Objects.isNull(receiptHandleStrategy.getType())) continue;             STRATEGY_MAP.put(receiptHandleStrategy.getType(), receiptHandleStrategy);         }     }      @Override     public TypeEnum getType() {         // 当前为默认实现,这个类型不必填写         return null;     }      @Override     public void handleReceipt(ReceiptReq receipt) {         // 从Map中获取对应类型的实现类         ReceiptHandleStrategy receiptHandleStrategy = STRATEGY_MAP.get(receipt.getTypeEnum());         // 判断是否为空         if (Objects.isNull(receiptHandleStrategy)) {             throw new RuntimeException("Not support this type:" + receipt.getTypeEnum());         }         // 调用对应接口         receiptHandleStrategy.handleReceipt(receipt);     } }

MT1101类型对应的接口实现类`MT1101ReceiptHandleStrategy.java`

package cn.cliveyuan.learn.test.strategy;  import org.springframework.stereotype.Component;  /**  * @author Clive Yuan  * @date 2023-10-20 16:34  */ @Component public class MT1101ReceiptHandleStrategy implements ReceiptHandleStrategy {     @Override     public TypeEnum getType() {         // 填写对应的类型枚举         return TypeEnum.MT1101;     }      @Override     public void handleReceipt(ReceiptReq receipt) {         // 处理对应的业务场景         System.out.println("解析报文MT1101:" + receipt.getData());     } }

MT2101类型对应的接口实现类`Mt2101ReceiptHandleStrategy.java`

package cn.cliveyuan.learn.test.strategy;  import org.springframework.stereotype.Component;  /**  * @author Clive Yuan  * @date 2023-10-20 16:34  */ @Component public class Mt2101ReceiptHandleStrategy implements ReceiptHandleStrategy {     @Override     public TypeEnum getType() {         // 填写对应的类型枚举         return TypeEnum.MT2101;     }      @Override     public void handleReceipt(ReceiptReq receipt) {         // 处理对应的业务场景         System.out.println("解析报文MT2101:" + receipt.getData());     } }

测试类`ReceiptStrategyTest.java`

package cn.cliveyuan.learn.test.strategy;  import cn.cliveyuan.learn.test.BaseTest; import org.junit.Test;  import javax.annotation.Resource;  /**  * @author Clive Yuan  * @date 2023-10-20 16:36  */ public class ReceiptStrategyTest extends BaseTest {     @Resource     private ReceiptHandleStrategy receiptHandleStrategy;      @Test     public void test_01() {         ReceiptReq receipt = new ReceiptReq();         receipt.setTypeEnum(TypeEnum.MT1101);         receipt.setData("Hi, MT1101");         receiptHandleStrategy.handleReceipt(receipt);     }     @Test     public void test_02() {         ReceiptReq receipt = new ReceiptReq();         receipt.setTypeEnum(TypeEnum.MT2101);         receipt.setData("Hi, MT2101");         receiptHandleStrategy.handleReceipt(receipt);     }     @Test     public void test_03() {         ReceiptReq receipt = new ReceiptReq();         receipt.setTypeEnum(TypeEnum.MT4101);         receipt.setData("Hi, MT4101");         receiptHandleStrategy.handleReceipt(receipt);     } }

基础测试类`BaseTest.java`

package cn.cliveyuan.learn.test;   /**  * 基本测试  * @author Clive Yuan  * @date 2023-10-20 16:36  */  import cn.cliveyuan.learn.Application; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest(classes = Application.class) public class BaseTest { }

测试结果

test_01: 解析报文MT1101:Hi, MT1101 test_02: 解析报文MT2101:Hi, MT2101 test_03: java.lang.RuntimeException: Not support this type:MT4101

扩展性

如果要新加一个处理类型，只需2步：

在类型枚举TypeEnum.java中新增枚举值
新增一个接口ReceiptHandleStrategy的实现，并填写对应的类型枚举

结语

ReceiptHandleStrategy接口调用时只需要依赖这个接口即可，因为默认实现加了@Primary注解就会默认调用这个实现处理，并根据类型枚举路由到对应的实现，在实现的类里面就可以方便地依赖其他Bean做业务处理了。你对这种方式有什么看法呢？评论区见^_^

@Author: Clive 博客地址：cliveyuan.cn

【转】一文教你搞定所有前端鉴权与后端鉴权方案，让你不再迷惘

Wed, 13 Sep 2023 06:05:00 GMT

原文地址：https://juejin.cn/post/7129298214959710244

前言

大家好，我是易师傅，还记得之前在面试的时候，有一位面试官就问了，关于前端鉴权这块，Token、Cookie、Session、JWT、单点登录是什么？有什么作用？你一般是怎么做的？以及你是怎么存储的呢？那你又是怎么保证 它 的安全的呢？

一顿连问下来，我是焦头又烂额，欲言而又止.......

其实鉴权的方法有很多，下面我总结了常用的 10种鉴权方法，那么哪一种是最适合你的系统呢？哪一种又最安全呢？

那就让我们从下文慢慢探索寻找答案吧 ~

通过这篇文章你将学到什么？

在介绍鉴权方法之前，我们先要了解的是：什么是认证、授权、鉴权、权限控制以及他们之间的关系，有了他们做铺垫，那么我们才能做到从始至终的了解透彻 ~

什么是认证？

认证(Identification) 是指根据声明者所特有的识别信息，确认声明者的身份。

白话文的意思就是：你需要用身份证证明你自己是你自己。

比如我们常见的认证技术：

身份证
用户名和密码
用户手机：手机短信、手机二维码扫描、手势密码
用户的电子邮箱
用户的生物学特征：指纹、语音、眼睛虹膜
用户的大数据识别
等等

什么是授权？

授权(Authorization)：在信息安全领域是指资源所有者委派执行者，赋予执行者指定范围的资源操作权限，以便对资源的相关操作。

在现实生活领域例如： 银行卡（由银行派发）、门禁卡（由物业管理处派发）、钥匙（由房东派发），这些都是现实生活中授权的实现方式。

在互联网领域例如： web 服务器的 session 机制、web 浏览器的 cookie 机制、颁发授权令牌（token）等都是一个授权的机制。

什么是鉴权？

鉴权(Authentication) 在信息安全领域是指对于一个声明者所声明的身份权利，对其所声明的真实性进行鉴别确认的过程。

若从授权出发，则会更加容易理解鉴权。授权和鉴权是两个上下游相匹配的关系，先授权，后鉴权。

在现实生活领域： 门禁卡需要通过门禁卡识别器，银行卡需要通过银行卡识别器；

在互联网领域： 校验 session/cookie/token 的合法性和有效性

鉴权 是一个承上启下的一个环节，上游它接受授权的输出，校验其真实性后，然后获取权限（permission），这个将会为下一步的权限控制做好准备。

什么是权限控制？

权限控制(Access/Permission Control) 将可执行的操作定义为权限列表，然后判断操作是否允许/禁止

对于权限控制，可以分为两部分进行理解：一个是权限，另一个是控制。权限是抽象的逻辑概念，而控制是具体的实现方式。

在现实生活领域中： 以门禁卡的权限实现为例，一个门禁卡，拥有开公司所有的门的权限；一个门禁卡，拥有管理员角色的权限，因而可以开公司所有的门。

在互联网领域： 通过 web 后端服务，来控制接口访问，允许或拒绝访问请求。

认证、授权、鉴权和权限控制的关系？

看到这里，我们应该明白了认证、授权、鉴权和权限控制这四个环节是一个前后依次发生、上下游的关系;

需要说明的是，这四个环节在有些时候会同时发生。例如在下面的几个场景：

使用门禁卡开门： 认证、授权、鉴权、权限控制四个环节一气呵成，在瞬间同时发生
用户的网站登录： 用户在使用用户名和密码进行登录时，认证和授权两个环节一同完成，而鉴权和权限控制则发生在后续的请求访问中，比如在选购物品或支付时。

这里提个小问题，供大家思考：认证和鉴权之间的关系？欢迎大家在评论区讨论

既然我们已经了解了他们之间的关系，那么我们应该好好讲讲关于前端鉴权有哪些？以及他们之间存在的差异点又在哪里呢？

1. HTTP 基本鉴权

在 HTTP 中，基本认证方案（Basic Access Authentication) 是允许客户端（通常指的就是网页浏览器）在请求时，通过用户提供用户名和密码的方式，实现对用户身份的验证。

因为几乎所有的线上网站都不会走该认证方案，所以该方案大家了解即可

1.1 认证流程图

1.2 认证步骤解析

客户端(如浏览器)： 向服务器请求一个受限的列表数据或资源，例如字段如下


sql复制代码
 GET /list/ HTTP/1.1  Host: www.baidu.com  Authorization: Basic aHR0cHdhdGNoOmY=

服务器：客户端你好，这个资源在安全区 baidu.com 里，是受限资源，需要基本认证；

并且向客户端返回 401 状态码（Unauthorized 未被授权的）以及附带提供了一个认证域 www-Authenticate: Basic realm=”baidu.com”要求进行身份验证；

其中Basic 就是验证的模式，而 realm="baidu.com" 说明客户端需要输入这个安全域的用户名和密码，而不是其他域的
```
ini复制代码
 HTTP/1.1 401 Unauthorized  www-Authenticate: Basic realm= "baidu.com" 
```
客户端： 服务器，我已经携带了用户名和密码给你了，你看一下；（注：如客户端是浏览器，那么此时会自动弹出一个弹窗，让用户输入用户名和密码）；

输入完用户名和密码后，则客户端将用户名及密码以 Base64 加密方式发送给服务器

传送的格式如下 (其中 Basic 内容为：用户名:密码的 ase64 形式)：
```
ini复制代码
 GET /list/ HTTP/1.1   Authorization: Basic Ksid2FuZzp3YW5n== 
```
服务器： 客户端你好，我已经校验了Authorization 字段你的用户名和密码，是正确的，这是你要的资源。
```
erlang复制代码
 HTTP/1.1 200 OK  ... 
```

1.3 优点

简单，基本所有流行的浏览器都支持

1.4 缺点

不安全：
- 由于是基于 HTTP 传输，所以它在网络上几乎是裸奔的，虽然它使用了 Base64 来编码，但这个编码很容易就可以解码出来。
- 即使认证内容无法被解码为原始的用户名和密码也是不安全的，恶意用户可以再获取了认证内容后使用其不断的享服务器发起请求，这就是所谓的重放攻击。
无法主动注销：
- 由于 HTTP 协议没有提供机制清除浏览器中的 Basic 认证信息，除非标签页或浏览器关闭、或用户清除历史记录。

1.5 使用场景

内部网络，或者对安全要求不是很高的网络。

2. Session-Cookie 鉴权

Session-Cookie 认证是利用服务端的 Session（会话）和 浏览器（客户端） 的 Cookie 来实现的前后端通信认证模式。

在理解这句话之前我们先简单了解下 什么是 Cookie 以及 什么是 Session ？

2.1 什么是 Cookie

众所周知，HTTP 是无状态的协议（对于事务处理没有记忆能力，每次客户端和服务端会话完成时，服务端不会保存任何会话信息）；

所以为了让服务器区分不同的客户端，就必须主动的去维护一个状态，这个状态用于告知服务端前后两个请求是否来自同一浏览器。而这个状态可以通过 Cookie 去实现。

特点：

Cookie 存储在客户端，可随意篡改，不安全
有大小限制，最大为 4kb
有数量限制，一般一个浏览器对于一个网站只能存不超过 20 个 Cookie，浏览器一般只允许存放 300个 Cookie
Android 和 IOS 对 Cookie 支持性不好
Cookie 是不可跨域的，但是一级域名和二级域名是允许共享使用的（靠的是 domain）

2.2 什么是 Session

Session 的抽象概念是会话，是无状态协议通信过程中，为了实现中断/继续操作，将用户和服务器之间的交互进行的一种抽象；

具体来说，是服务器生成的一种 Session 结构，可以通过多种方式保存，如内存、数据库、文件等，大型网站一般有专门的 Session 服务器集群来保存用户会话；

原理流程：

客户端： 用户向服务器首次发送请求；
服务器： 接收到数据并自动为该用户创建特定的 Session / Session ID，来标识用户并跟踪用户当前的会话过程；
客户端： 浏览器收到响应获取会话信息，并且会在下一次请求时带上 Session / Session ID；
服务器： 服务器提取后会与本地保存的 Session ID进行对比找到该特定用户的会话，进而获取会话状态；
至此客户端与服务器的通信变成有状态的通信；

特点：

Session 保存在服务器上；
通过服务器自带的加密协议进行；

与 Cookie 的差异：

安全性： Cookie 由于保存在客户端，可随意篡改，Session 则不同存储在服务器端，无法伪造，所以 Session 的安全性更高；
存取值的类型不同： Cookie 只支持字符串数据，Session 可以存任意数据类型；
有效期不同： Cookie 可设置为长时间保持，Session 一般失效时间较短；
存储大小不同： Cookie 保存的数据不能超过 4K；

看到这里可能就有同学想到了，Session-Cookie 是不是就是把 Session 存储在了客户端的 Cookie 中呢？

Bingo，的确是这样的，我们接着往下看

2.3 Session-Cookie 的认证流程图

2.4 Session-Cookie 认证步骤解析

客户端： 向服务器发送登录信息用户名/密码来请求登录校验；
服务器： 验证登录的信息，验证通过后自动创建 Session（将 Session 保存在内存中，也可以保存在 Redis 中），然后给这个 Session 生成一个唯一的标识字符串会话身份凭证 session_id(通常称为 sid)，并在响应头 Set-Cookie 中设置这个唯一标识符；

注：可以使用签名对 sid 进行加密处理，服务端会根据对应的 secret 密钥进行解密（非必须步骤）
客户端： 收到服务器的响应后会解析响应头，并自动将 sid 保存在本地 Cookie 中，浏览器在下次 HTTP 请求时请求头会自动附带上该域名下的 Cookie 信息；
服务器： 接收客户端请求时会去解析请求头 Cookie 中的 sid，然后根据这个 sid 去找服务端保存的该客户端的 sid，然后判断该请求是否合法；

2.5 Session-Cookie 的优点

Cookie 简单易用
Session 数据存储在服务端，相较于 JWT 方便进行管理，也就是当用户登录和主动注销，只需要添加删除对应的 Session 就可以了，方便管理
只需要后端操作即可，前端可以无感等进行操作；

2.6 Session-Cookie 的缺点

依赖 Cookie，一旦用户在浏览器端禁用 Cookie，那么就 GG 思密达了；
非常不安全，Cookie 将数据暴露在浏览器中，增加了数据被盗的风险（容易被 CSRF 等攻击）；
Session 存储在服务端，增大了服务端的开销，用户量大的时候会大大降低服务器性能；
对移动端的支持性不友好；

2.7 使用场景

一般中大型的网站都适用（除了 APP 移动端）；
由于一般的 Session 需集中存储在内存服务器上（如 Redis），这样就会增加服务器的预算，所以预算不够请谨慎选择；

2.8 前端常用的 Session 库推荐

使用 express：express-session
使用 koa：koa-session

3. Token 鉴权

现在我们已经得知，Session-Cookie 的一些缺点，以及 Session 的维护给服务端造成很大困扰，我们必须找地方存放它，又要考虑分布式的问题，甚至要单独为了它启用一套 Redis 集群。那有没有更好的办法？

那 Token 就应运而生了

3.1 什么是 Token（令牌）

Token 是一个令牌，客户端访问服务器时，验证通过后服务端会为其签发一张令牌，之后，客户端就可以携带令牌访问服务器，服务端只需要验证令牌的有效性即可。

一句话概括；访问资源接口（API）时所需要的资源凭证

一般 Token 的组成：

uid (用户唯一的身份标识) + time (当前时间的时间戳) + sign (签名，Token 的前几位以哈希算法压缩成的一定长度的十六进制字符串)

Token 的认证流程图：

Token 认证步骤解析：

客户端： 输入用户名和密码请求登录校验；
服务器： 收到请求，去验证用户名与密码；验证成功后，服务端会签发一个 Token 并把这个 Token 发送给客户端；
客户端： 收到 Token 以后需要把它存储起来，web 端一般会放在 localStorage 或 Cookie 中，移动端原生 APP 一般存储在本地缓存中；
客户端发送请求： 向服务端请求 API 资源的时候，将 Token 通过 HTTP 请求头 Authorization 字段或者其它方式发送给服务端；
服务器： 收到请求，然后去验证客户端请求里面带着的 Token ，如果验证成功，就向客户端返回请求的数据，否则拒绝返还（401）；

Token 的优点：

服务端无状态化、可扩展性好： Token 机制在服务端不需要存储会话（Session）信息，因为 Token 自身包含了其所标识用户的相关信息，这有利于在多个服务间共享用户状态
支持 APP 移动端设备；
安全性好： 有效避免 CSRF 攻击（因为不需要 Cookie）
支持跨程序调用： 因为 Cookie 是不允许跨域访问的，而 Token 则不存在这个问题

Token 的缺点：

配合： 需要前后端配合处理；
占带宽： 正常情况下比 sid 更大，消耗更多流量，挤占更多宽带
性能问题： 虽说验证 Token 时不用再去访问数据库或远程服务进行权限校验，但是需要对 Token 加解密等操作，所以会更耗性能；
有效期短： 为了避免 Token 被盗用，一般 Token 的有效期会设置的较短，所以就有了 Refresh Token；

3.2 什么是 Refresh Token（刷新 Token）

业务接口用来鉴权的 Token，我们称之为 Access Token。

为了安全，我们的 Access Token 有效期一般设置较短，以避免被盗用。但过短的有效期会造成 Access Token 经常过期，过期后怎么办呢？

一种办法是：刷新 Access Token，让用户重新登录获取新 Token，会很麻烦；

另外一种办法是：再来一个 Token，一个专门生成 Access Token 的 Token，我们称为 Refresh Token；

Access Token： 用来访问业务接口，由于有效期足够短，盗用风险小，也可以使请求方式更宽松灵活；
Refresh Token： 用来获取 Access Token，有效期可以长一些，通过独立服务和严格的请求方式增加安全性；由于不常验证，也可以如前面的 Session 一样处理；

Refresh Token 的认证流程图：

Refresh Token 认证步骤解析：

客户端： 输入用户名和密码请求登录校验；
服务端： 收到请求，验证用户名与密码；验证成功后，服务端会签发一个 Access Token 和 Refresh Token 并返回给客户端；
客户端： 把 Access Token 和 Refresh Token 存储在本地；
客户端发送请求： 请求数据时，携带 Access Token 传输给服务端；
服务端：
- 验证 Access Token 有效：正常返回数据
- 验证 Access Token 过期：拒绝请求
客户端 ( Access Token 已过期) ：则重新传输 Refresh Token 给服务端；
服务端 ( Access Token 已过期) ：验证 Refresh Token ，验证成功后返回新的 Access Token 给客户端；
客户端： 重新携带新的 Access Token 请求接口；

3.3 Token 和 Session-Cookie 的区别

Session-Cookie 和 Token 有很多类似的地方，但是 Token 更像是 Session-Cookie 的升级改良版。

存储地不同： Session 一般是存储在服务端；Token 是无状态的，一般由前端存储；
安全性不同： Session 和 Token 并不矛盾，作为身份认证 Token 安全性比 Session 好，因为每一个请求都有签名还能防止监听以及重放攻击；
支持性不同： Session-Cookie 认证需要靠浏览器的 Cookie 机制实现，如果遇到原生 NativeAPP 时这种机制就不起作用了，或是浏览器的 Cookie 存储功能被禁用，也是无法使用该认证机制实现鉴权的；而 Token 验证机制丰富了客户端类型。

如果你的用户数据可能需要和第三方共享，或者允许第三方调用 API 接口，用 Token 。如果永远只是自己的网站，自己的 App，用什么就无所谓了。

4. JWT（JSON Web Token）鉴权

通过第三节，我们知道了 Token 的使用方式以及组成，我们不难发现，服务端验证客户端发送过来的 Token 时，还需要查询数据库获取用户基本信息，然后验证 Token 是否有效；

这样每次请求验证都要查询数据库，增加了查库带来的延迟等性能消耗；

那么这时候业界常用的 JWT 就应运而生了！！！

4.1 什么是 JWT

JWT 是 Auth0 提出的通过 对 JSON 进行加密签名来实现授权验证的方案；

就是登录成功后将相关用户信息组成 JSON 对象，然后对这个对象进行某种方式的加密，返回给客户端；客户端在下次请求时带上这个 Token；服务端再收到请求时校验 token 合法性，其实也就是在校验请求的合法性。

4.2 JWT 的组成

JWT 由三部分组成： Header 头部、 Payload 负载 和 Signature 签名

它是一个很长的字符串，中间用点（.）分隔成三个部分。列如：


复制代码
 eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Header 头部：

在 Header 中通常包含了两部分：

typ：代表 Token 的类型，这里使用的是 JWT 类型；
alg：使用的 Hash 算法，例如 HMAC SHA256 或 RSA.


json复制代码
 {    "alg": "HS256",    "typ": "JWT"  }

Payload 负载：

它包含一些声明 Claim (实体的描述，通常是一个 User 信息，还包括一些其他的元数据) ，用来存放实际需要传递的数据，JWT 规定了7个官方字段：

iss (issuer)：签发人
exp (expiration time)：过期时间
sub (subject)：主题
aud (audience)：受众
nbf (Not Before)：生效时间
iat (Issued At)：签发时间
jti (JWT ID)：编号

除了官方字段，你还可以在这个部分定义私有字段，下面就是一个例子。


json复制代码
 {    "sub": "1234567890",    "name": "John Doe",    "admin": true  }

Signature 签名

Signature 部分是对前两部分的签名，防止数据篡改。

首先，需要指定一个密钥（secret）。这个密钥只有服务器才知道，不能泄露给用户。然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。


scss复制代码
 HMACSHA256(    base64UrlEncode(header) + "." +    base64UrlEncode(payload),    secret)

4.3 JWT 的使用方式

客户端收到服务器返回的 JWT，可以储存在 Cookie 里面，也可以储存在 localStorage。

此后，客户端每次与服务器通信，都要带上这个 JWT。你可以把它放在 Cookie 里面自动发送，但是这样不能跨域，所以更好的做法是放在 HTTP 请求的头信息Authorization字段里面。


sql复制代码
 Authorization: Bearer <token>

4.4 JWT 的认证流程图

其实 JWT 的认证流程与 Token 的认证流程差不多，只是不需要再单独去查询数据库查找用户用户；简要概括如下：

4.5 JWT 的优点

不需要在服务端保存会话信息（RESTful API 的原则之一就是无状态），所以易于应用的扩展，即信息不保存在服务端，不会存在 Session 扩展不方便的情况；
JWT 中的 Payload 负载可以存储常用信息，用于信息交换，有效地使用 JWT，可以降低服务端查询数据库的次数

4.6 JWT 的缺点

加密问题： JWT 默认是不加密，但也是可以加密的。生成原始 Token 以后，可以用密钥再加密一次。
到期问题： 由于服务器不保存 Session 状态，因此无法在使用过程中废止某个 Token，或者更改 Token 的权限。也就是说，一旦 JWT 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。

4.7 前端常用的 JWT 库推荐

使用 express：express-jwt
使用 koa：koa-jwt

5. 单点登录（Single Sign On）

前面我们已经知道了，在同域下的客户端/服务端认证系统中，通过客户端携带凭证，可以维持一段时间内的登录状态。

但随着企业的发展，一个大型系统里可能包含 n 多子系统，用户在操作不同的系统时，需要多次登录，很麻烦，那么单点登录（SSO) 就可以很好的解决这个问题的，在多个应用系统中，只需要登录一次，就可以访问其他相互信任的应用系统。

例如登录天猫，淘宝也会自动登录；
登录百度贴吧，百度网盘也会自动登录；

5.1 同域下的 SSO（主域名相同）

当百度网站存在两个相同主域名下的贴吧子系统 tieba.baidu.com 和网盘子系统 pan.baidu.com 时，以下为他们实现 SSO 的步骤：

客户端： 用户访问某个子系统时（例如 tieba.baidu.com），如果没有登录，则跳转至 SSO 认证中心提供的登录页面进行登录；
服务端： 登录认证后，服务端把登录用户的信息存储于 Session 中，并且附加在响应头的 Set-Cookie 字段中，设置 Cookie 的 Domain 为 .baidu.com ；
客户端：再次发送请求时，携带主域名 Domain 下的 Cookie 给服务器，此时服务端就可以通过该 Cookie 来验证登录状态了；

其实我们不难发现，这就是我们上面讲的 Session-Cookie 认证 登录方式；但如果是不同域呢？毕竟不同域之间 Cookie 是不共享的，那怎么办？

5.2 跨域下的 SSO（主域名不同）

在我们常见的购物网站天猫 (tmall.com) 和淘宝 (taobao.com) 中，我们只需要登录其中某一个系统，另外一个系统打开后就会默认登录，那么这是怎么做的呢？

那么就有了 CAS（Central Authentication Service）中央授权服务，那么我们先主要说下 CAS 的流程；

单点登录下的 CAS 认证流程图：

单点登录下的 CAS 认证步骤详解：

客户端： 开始访问系统 A；
系统 A： 发现用户未登录，重定向至 CAS 认证服务（sso.com），同时 URL 地址参数携带登录成功后回跳到系统 A 的页面链接（sso.com/login?redir…
CAS 认证服务： 发现请求 Cookie 中没有携带登录的票据凭证（TGC），所以 CAS 认证服务判定用户处于 未登录 状态，重定向用户页面至 CAS 的登录界面，用户在 CAS 的登录页面上进行登录操作。
客户端： 输入用户名密码进行 CAS 系统认证；
CAS 认证服务： 校验用户信息，并且 生成 TGC 放入自己的 Session 中，同时以 Set-Cookie 形式写入 Domain 为 sso.com 的域下；同时生成一个 授权令牌 ST (Service Ticket) ，然后重定向至系统 A 的地址，重定向的地址中包含生成的 ST（重定向地址：www.taobao.com?token=ST-345678）
系统 A： 拿着 ST 向 CAS 认证服务发送请求，CAS 认证服务验证票据 (ST) 的有效性。验证成功后，系统 A 知道用户已经在 CAS 登录了（其中的 ST 可以保存到 Cookie 或者本地中），系统 A 服务器使用该票据 (ST) 创建与用户的会话，称为局部会话，返回受保护资源；

到这里客户端就可以跟系统 A 愉快的交往啦 ~

客户端： 开始访问系统 B；
系统 B： 发现用户未登录，重定向至 SSO 认证服务，并将自己的地址作为参数传递，并附上在 sso.com 域下的 cookie 值是第五步生成的 TGC；
CAS 认证服务： CAS 认证服务中心发现用户已登录，跳转回系统 B 的地址，并附上票据 (ST) ;
系统 B： 拿到票据 (ST)，去 CAS 认证服务验证票据 (ST) 的有效性。验证成功后，客户端也可以跟系统 B 交往了 ~

(PS：脚踏两只船，感觉有点渣呀 ~)

单点登录下需要注意的点：

如图中流程所示，我们发现 CAS 认证服务 在签发的 授权令牌 ST 后，直接重定向，这样其实是比较容易容易被窃取，那么我们需要在系统 A 或者系统 B 在向 CAS 验证成功 (如图中的第 14 步和第 11 步) 后，再生成另一个新的验证 Token 返回给客户端保存；
CAS 一般提供四个接口：
- /login：登录接口，用于登录到中央授权服务
- /logout：登出接口，用于从中央授权服务中登出
- /validate：用于验证用户是否登录中央授权服务
- /serviceValidate：用于让各个 Service 验证用户是否登录中央授权服务
CAS 生成的票据：
- TGT（Ticket Grangting Ticket） ：TGT 是 CAS 为用户签发的 登录票据，拥有了 TGT，用户就可以证明自己在 CAS 成功登录过。
- TGC：Ticket Granting Cookie： CAS Server 生成TGT放入自己的 Session 中，而 TGC 就是这个 Session 的唯一标识（SessionId），以 Cookie 形式放到浏览器端，是 CAS Server 用来明确用户身份的凭证。
- ST（Service Ticket） ：ST 是 CAS 为用户签发的访问某个 Service 的票据。

6. OAuth 2.0

在我们实际浏览网站的时候，当我们登录的时候除了输入当前网站的账号密码外，我们还发现可以通过第三方的 QQ 或者微信登录，那么这又是如何做到了呢，这就要谈到 OAuth 了。

OAuth 协议又有 1.0 和 2.0 两个版本，2.0 版整个授权验证流程更简单更安全，也是目前最主要的用户身份验证和授权方式。

6.1 什么是 OAuth 2.0？

OAuth 是一个开放标准，允许用户授权第三方网站 (CSDN、思否等) 访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方网站；

常见的提供 OAuth 认证服务的厂商： 支付宝、QQ、微信、微博

简单说，OAuth 就是一种授权机制。数据的所有者告诉系统，同意授权第三方应用进入系统，获取这些数据。系统从而产生一个短期的进入令牌（Token），用来代替密码，供第三方应用使用。

令牌与密码的差异：

令牌（Token） 与 密码（Password） 的作用是一样的，都可以进入系统，但是有三点差异。

令牌是短期的，到期会自动失效： 用户自己无法修改。密码一般长期有效，用户不修改，就不会发生变化。
令牌可以被数据所有者撤销，会立即失效。
令牌有权限范围（scope）： 对于网络服务来说，只读令牌就比读写令牌更安全。密码一般是完整权限。

OAuth 2.0 对于如何颁发令牌的细节，规定得非常详细。具体来说，一共分成四种授权模式 （Authorization Grant） ，适用于不同的互联网场景。

无论哪个模式都拥有三个必要角色：客户端、授权服务器、资源服务器，有的还有用户（资源拥有者），下面简单介绍下四种授权模式。

6.2 授权码模式

授权码（Authorization Code Grant) 方式，指的是第三方应用先申请一个授权码，然后再用该码获取令牌。

这种方式是最常用的流程，安全性也最高，它适用于那些有后端服务的 Web 应用。授权码通过前端传送，令牌则是储存在后端，而且所有与资源服务器的通信都在后端完成。这样的前后端分离，可以避免令牌泄漏。

一句话概括：客户端换取授权码，客户端使用授权码换token，客户端使用token访问资源

授权码模式的步骤详解

客户端：

打开网站 A，点击登录按钮，请求 A 服务，A 服务重定向 (重定向地址如下) 至授权服务器 (如QQ、微信授权服务)。
```
ini复制代码
 https://qq.com/oauth/authorize?    response_type=code&    client_id=CLIENT_ID&    redirect_uri=CALLBACK_URL&    scope=read 
```
上面 URL 中，response_type 参数表示要求返回授权码（code），client_id 参数让 B 知道是谁在请求，redirect_uri 参数是 B 接受或拒绝请求后的跳转网址，scope 参数表示要求的授权范围（这里是只读）
授权服务器：

授权服务网站 会要求用户登录，然后询问是否同意给予 A 网站授权。用户表示同意，这时授权服务网站 就会跳回 redirect_uri 参数指定的网址。跳转时，会传回一个授权码，就像下面这样。
```
ini复制代码
https://a.com/callback?code=AUTHORIZATION_CODE 
```
上面 URL 中，code 参数就是授权码。
网站 A 服务器：

拿到授权码以后，就可以向 授权服务器 (qq.com) 请求令牌，请求地址如下：
```
ini复制代码
 https://qq.com/oauth/token?   client_id=CLIENT_ID&   client_secret=CLIENT_SECRET&   grant_type=authorization_code&   code=AUTHORIZATION_CODE&   redirect_uri=CALLBACK_URL 
```
上面 URL 中，client_id 参数和 client_secret 参数用来让授权服务器确认 A 的身份（client_secret 参数是保密的，因此只能在后端发请求），grant_type参数的值是AUTHORIZATION_CODE，表示采用的授权方式是授权码，code 参数是上一步拿到的授权码，redirect_uri 参数是令牌颁发后的回调网址。
授权服务器：

收到请求以后，验证通过，就会颁发令牌。具体做法是向 redirect_uri 指定的网址，发送一段 JSON 数据。
```
json复制代码
 {        "access_token":"ACCESS_TOKEN",    "token_type":"bearer",    "expires_in":2592000,    "refresh_token":"REFRESH_TOKEN",    "scope":"read",    "uid":100101,    "info":{...}  } 
```
上面 JSON 数据中，access_token 字段就是令牌，A 网站在后端拿到了，然后返回给客户端即可。

6.3 隐藏式模式（Implicit Grant）

有些 Web 应用是纯前端应用，没有后端。这时就不能用上面的方式了，必须将令牌储存在前端。OAuth2.0 就规定了第二种方式，允许直接向前端颁发令牌。这种方式没有授权码这个中间步骤，所以称为（授权码）"隐藏式"（implicit）。

一句话概括：客户端让用户登录授权服务器换token，客户端使用token访问资源。

隐藏式模式的步骤详解

客户端：

打开网站 A，A 网站提供一个链接，要求用户跳转到 授权服务器，授权用户数据给 A 网站使用。如下链接：
```
ini复制代码
 https://qq.com/oauth/authorize?    response_type=token&    client_id=CLIENT_ID&    redirect_uri=CALLBACK_URL&    scope=read 
```
上面 URL 中，response_type参数为token，表示要求直接返回令牌。
授权服务器：

用户跳转到授权服务器，登录后同意给予 A 网站授权。这时，授权服务器就会跳回redirect_uri 参数指定的跳转网址，并且把令牌作为 URL 参数，传给 A 网站。
```
bash复制代码
 https://a.com/callback#token=ACCESS_TOKEN 
```
上面 URL 中，token参数就是令牌，A 网站因此直接在前端拿到令牌。

注意：

令牌的位置是 URL 锚点（fragment），而不是查询字符串（querystring），这是因为 OAuth 2.0 允许跳转网址是 HTTP 协议，因此存在"中间人攻击"的风险，而浏览器跳转时，锚点不会发到服务器，就减少了泄漏令牌的风险。

这种方式把令牌直接传给前端，是很不安全的。因此，只能用于一些安全要求不高的场景，并且令牌的有效期必须非常短，通常就是会话期间（session）有效，浏览器关掉，令牌就失效了。

6.4 用户名密码式模式（Password Credentials Grant）

如果你高度信任某个应用，OAuth 2.0 也允许用户把用户名和密码，直接告诉该应用。该应用就使用你的密码，申请令牌，这种方式称为"密码式"（password）。

一句话概括：用户在客户端提交账号密码换token，客户端使用token访问资源。

密码式模式的步骤详解

客户端：

A 网站要求用户提供 授权服务器(qq.com) 的用户名和密码。拿到以后，A 就直接向 授权服务器 请求令牌。
```
ini复制代码
 https://oauth.b.com/token?    grant_type=password&    username=USERNAME&    password=PASSWORD&    client_id=CLIENT_ID 
```
上面 URL 中，grant_type参数是授权方式，这里的password表示"密码式"，username和password是 授权服务器 的用户名和密码。
授权服务器：

授权服务器 验证身份通过后，直接给出令牌。

注意，这时不需要跳转，而是把令牌放在 JSON 数据里面，作为 HTTP 回应，A 网站因此拿到令牌。

这种方式需要用户给出自己的用户名/密码，显然风险很大，因此只适用于其他授权方式都无法采用的情况，而且必须是用户高度信任的应用。

6.5 客户端模式（Client Credentials Grant）

客户端模式指客户端以自己的名义，而不是以用户的名义，向授权服务器 进行认证。

主要适用于没有前端的命令行应用。

一句话概括：客户端使用自己的标识换token，客户端使用token访问资源。

客户端模式的步骤详解

客户端：

客户端向授权服务器 进行身份认证，并要求一个访问令牌。请求链接地址：
```
ini复制代码
 https://oauth.b.com/token?    grant_type=client_credentials&    client_id=CLIENT_ID&    client_secret=CLIENT_SECRET 
```
上面 URL 中，grant_type参数等于client_credentials表示采用凭证式，client_id和client_secret用来让授权服务器 确认 A 的身份。
授权服务器：

授权服务器 验证通过以后，直接返回令牌。

注意：这种方式给出的令牌，是针对第三方应用的，而不是针对用户的，即有可能多个用户共享同一个令牌。

6.5 授权模式选型

按授权需要的多端情况：

模式	需要前端	需要后端	需要用户响应	需要客户端密钥
授权码模式 Authorization Code	✅	✅	✅	✅
隐式授权模式 Implicit Grant	✅	❌	✅	❌
密码授权模式 Password Grant	✅	✅	✅	✅
客户端授权模式 Client Credentials	❌	✅	❌	✅

按照客户端类型与访问令牌所有者分类：

上述主要比较浅显的讲解了 OAuth2.0 的基本逻辑，如若想详细深入的了解，可查看官方文档 OAuth 或 RFC 6749；亦可查看 OAuth 2.0 概念及授权流程梳理做对比

7. 联合登录和信任登录

7.1 什么是联合登陆

联合登录 指同时包含多种凭证校验的登录服务，同时，也可以理解为使用第三方凭证进行校验的登录服务。

通俗点讲： 对于两个网站 A 和 B，在登录 A 网站的时候用 B 网站的帐号密码，就是联合登录，或者登录 B 网站的时候使用 A 网站的帐号密码，也是联合登录。

这样的概念其实与上面所讲的 OAuth2.0 的 用户名密码式模式 认证方式类似。

最经典的莫过于 APP 内嵌 H5 的使用场景，当用户从 APP 进入内嵌的 H5 时，我们希望 APP 内已登录的用户能够访问到 H5 内受限的资源，而未登录的用户则需要登录后访问。

这里思路主要有两种，一种是原生跳转内嵌 H5 页面时，将登录态 Token 附加在 URL 参数上，另一种则是内嵌 H5 主动通过与原生客户端制定的协议获取应用内的登录状态。

7.2 什么是信任登录

信任登录 是指所有不需要用户主动参与的登录，例如建立在私有设备与用户之间的绑定关系，凭证就是私有设备的信息，此时不需要用户再提供额外的凭证。信任登录又指用第三方比较成熟的用户库来校验凭证，并登录当前访问的网站。

通俗点讲： 在 A 网站有登录状态的时候，可以直接跳转到 B 网站而不用登录，就是 信任登录。

目前比较常见的第三方信任登录帐号如：QQ 号淘宝帐号、支付宝帐号、微博帐号等。

我们不难发现 OAtuth 2.0 其实就是信任登录的缩影，因为正是有了 OAuth，我们的信任登录才得以实现。

8. 唯一登录

— 假设现在产品经理提一个需求：我想要实现用户只能在一个设备上登录，禁止用户重复登录；

— 身为优秀的程序员的我们当然是满足他啦！！

8.1 什么是唯一登录

唯一登录，指的是禁止多人同时登录同一账号，后者的登录行为，会导致前者掉线。

通俗点讲就是：A 账号在 A 电脑上登录后，A 账号此时又用 B 电脑再次登录，则 A 电脑请求页面时，提示“重新登录”的信息，并跳转到登录页面

8.2 唯一登录流程图

8.3 唯一登录步骤详解

用户在客户端 A 操作：

输入账号请求登录接口；
后端生成对应 Token 并且返回给客户端 A，并且在服务端保存一个登录状态；
客户端A 保存 Token，并且每次请求都在 header 头中携带对应的 Token；

用户在客户端 B 操作：

突然用户在客户端 B 上开始登录操作，我们会发现，步骤和在客户端A上面的操作几乎是一致的；

只是后端在生成新的 Token 时，要先验证登录状态，然后再生成对应新的 Token；

9. 扫码登录

9.1 什么是扫码登录

扫码登录通常见于移动端 APP 中，很多 PC 端的网站都提供了扫码登录的功能，无需在网页上输入任何账号和密码，只需要让移动端 APP (如微信、淘宝、QQ等等) 中已登录用户主动扫描 二维码 ，再确认登录，以使 PC 端的同款应用得以快速登录的方式就是 扫码登录 。

9.2 什么是二维码

二维码 又称二维条码，常见的二维码为 QR Code，QR 全称 Quick Response，是一个近几年来移动设备上超流行的一种编码方式，它比传统的Bar Code条形码能存更多的信息，也能表示更多的数据类型。

通过上面所述，我们不难发现，扫码登录需要三端 (PC端、手机端、服务端) 来进行配合才能达到登录成功的效果；

9.3 扫码登录的认证流程图

9.4 扫码登录的步骤详解 (待扫码阶段、待确认阶段、已确认阶段)

待扫码阶段：

PC端：

打开某个网站 (如taobao.com) 或者某个 APP (如微信) 的扫码登录入口；就会携带 PC 端的设备信息向服务端发送一个获取二维码的请求；
服务端：

服务器收到请求后，随机生成一个 UUID 作为二维码 ID，并将 UUID 与 PC 端的设备信息 关联起来存储在 Redis 服务器中，然后返回给 PC 端；同时设置一个过期时间，在过期后，用户登录二维码需要进行刷新重新获取。
PC 端：

收到二维码 ID 之后，将二维码 ID 以 二维码的形式 展示，等待移动端扫码。并且此时的 PC 端开始轮询查询二维码状态，直到登录成功。

如果移动端未扫描，那么一段时间后二维码会自动失效。

已扫码待确认阶段：

手机端：

打开手机端对应已登录的 APP (微信或淘宝等)，开始扫描识别 PC 端展示的二维码；

移动端扫描二维码后，会自动获取到二维码 ID，并将移动端登录的信息凭证（Token）和二维码 ID 作为参数发送给服务端，此时手机必须是已登录（使用扫描登录的前提是移动端的应用为已登录状态，这样才可以共享登录态）。
服务端：

收到手机端发来的请求后，会将 Token 与二维码 ID 关联，为什么需要关联呢？因为，当我们在使用微信时，移动端退出时，PC 端也应该随之退出登录，这个关联就起到这个作用。然后会生成一个临时 Token，这个 Token 会返回给移动端，一次性 Token 用作确认时的凭证。

已确认阶段：

手机端：

收到确认信息后，点击确认按钮，移动端携带上一步中获取的 临时 Token 发送给服务端校验；
服务端：

服务端校验完成后，会更新二维码状态，并且给 PC 端生成一个 正式的 Token，后续 PC 端就是持有这个 Token 访问服务端。
PC端：

轮询到二维码状态为已登录状态，并且会获取到了生成的 Token，完成登录，后续访问都基于 Token 完成。

10. 一键登录（适用于原生APP）

10.1 账号密码登录

大家都知道，最传统的登录方式就是使用账号加密码登录，简单粗暴，一般也不会出现什么问题；

缺点：

但这种方式要求用户要记住自己的账号和密码，也就是有一个记忆成本。用户为了降低记忆成本，很可能会在不同平台使用同一套账号密码。从安全角度考虑，一旦某个平台的账号密码泄露了，会连累到该用户使用的其他平台。
另外，由于账号和个人身份无关，意味着同一个用户可以注册多个不同的账号，也就是可能会有恶意注册的情况发生。

直到手机卡的强制实名制才得以解决！

10.2 手机号验证码登录

随着无线互联的发展以及手机卡实名制的推广，手机号俨然已成为特别的身份证明，与账号密码相比，手机号可以更好地验证用户的身份，防止恶意注册。

但是手机号注册还是需要一系列繁琐的操作：输入手机号、等待短信验证码、输入验证码、点击登录。整个流程少说二十秒，而且如果收不到短信，也就登录补了，这类问题有可能导致潜在的用户流失。

从安全角度考虑，还存在验证码泄漏的风险。如果有人知道了你的手机号，并且窃取到了验证码，那他也能登录你的账号了。

所以就有了一键登录操作！

10.3 什么是一键登录

我们想一下，为什么我们需要验证码？验证码的作用就是确定这个手机号是你的，那除了使用短信，是否还有别的方式对手机号进行认证？

于是，就有了咱们的主角一键登录。

短信验证码的作用就是证明当前操作页面的用户与输入手机号的用户为相同的人，那么实际上只要我们能够获取到当前手机使用的手机卡号，直接使用这个号码进行登录，不需要额外的操作，这就是一键登录。

一键登录能不能做，取决于运营商是否开放相关服务；随着运营商开放了相关的服务，我们现在已经能够接入运营商提供的 SDK 并付费使用相关的服务。

一键登录流程图：

一键登录步骤详解：

SDK 初始化： 调用 SDK 方法，传入平台配置的 AppKey 和 AppSecret
唤起授权页： 调用 SDK 唤起授权接口，SDK 会先向运营商发起获取手机号掩码的请求，请求成功后跳到授权页。授权页会显示手机号掩码以及运营商协议给用户确认。
同意授权并登录： 用户同意相关协议，点击授权页面的登录按钮，SDK 会请求本次取号的 Token，请求成功后将 Token 返回给客户端
取号： 将获取到的 Token 发送到自己的服务器，由服务端携带 Token 调用运营商一键登录的接口，调用成功就返回手机号码。服务端用手机号进行登录或注册操作，返回操作结果给客户端，完成一键登录。

三大运营商开放平台：

移动 - 互联网能力开放平台
电信 - 天翼账号开放平台
联通 - WO+ 开放平台

由于国内三大运营商各自有独立的 SDK，所以会导致兼容方面的工作会特别繁琐。如果要采用一键登录的方案，不妨采用第三方提供了号码认证服务，下列几家供应商都拥有手机号码认证能力：

注意：

在认证过程中，需要用户打开蜂窝网络，如果手机设备没有插入 SIM 卡、或者关闭蜂窝网络的情况下，是无法完成认证的。所以就算接入一键登录，还是要兼容传统的登录方式，允许用户在失败的情况下，仍能正常完成登录流程。

总结

在学习了解上面的 10 种鉴权方法后，我们简单概括一下

HTTP 基本认证适用于内部网络，或者对安全要求不是很高的网络；
Session-Cookie 适用于一般中大型的网站（移动端 APP 除外）；
Token 和 JWT 都适用于市面上大部分的企业型网站，JWT 效能会优于 Token；
单点登录 适用于子系统较多的大型企业网站；
OAuth 2.0适用于需要快速注册用户型的网站；
扫码登录 适用于已完成部署了三端的企业；
一键登录 适用于原生 APP；

作者：易师傅
链接：https://juejin.cn/post/7129298214959710244
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

MySQL从库搭建方案

Thu, 07 Sep 2023 15:41:00 GMT

master开启bin-log,设置数据库

# master server # vim /etc/my.cnf [mysqld] log-bin=mysql-bin   #[必须]启用二进制日志 server-id=222       #[必须]服务器唯一ID，默认是1，一般取IP最后一段  # 设置需要写binlog的数据库 binlog-do-db=db1 binlog-do-db=db2  gtid-mode=on enforce-gtid-consistency=true

重启MySQL数据库

systemctl restart mysqld

创建slave账号

-- # master server mysql GRANT REPLICATION SLAVE ON *.* to 'slave1'@'主库host' identified by 'slave_pwd';

停服,记录bin-log-index, position, 关掉自动重启job!!!

-- # master server mysql show master status;

备份数据

# master server mkdir /tmp/db_backup mysqldump -uroot -p*** --databases db | gzip > /tmp/db_backup/db-20220607.sql.gz

还原数据

# slave server   192.168.0.1 is master server ip mkdir -p /home/db_data scp root@192.168.0.1:/tmp/db_backup/db-20220607.sql.gz /home/db_data # create db CREATE DATABASE `database0` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci; # import gunzip -f </home/db_data/db-20220607.sql.gz| mysql -u root -p****

配置slave,设置数据库

# slave server # vim /etc/my.cnf [mysqld] server-id=129 gtid-mode=on enforce-gtid-consistency=true master_info_repository=TABLE relay_log_info_repository=TABLE #replicate-rewrite-db = database0 -> slave_database0 #replicate-rewrite-db = database1 -> slave_database1 # 重启MySQL数据库!!!  # master_log_file 和 master_log_pos 改为上文记录的值 change master to master_host='192.168..0.1',master_user='slave1',master_password='slave_pwd',master_log_file='mysql-bin.000001',master_log_pos=0 for channel '2'; start slave; show slave status;

测试同步

在master数据表中添加记录, 查看slave对应的数据表中是否同步

启动服务

测试通过则同步启动应用服务器

验证数据

观察新增数据是否同步

其他

Error_code: 1032 如果出现主键重复或者更新数据不存在导致的主从不同步时,可执行set global slave_exec_mode='IDEMPOTENT' 来修改模式为幂等

Java下载网络文件

Fri, 30 Dec 2022 07:44:00 GMT

@SneakyThrows     private void doDown(String url, String path) {         BufferedInputStream in = new BufferedInputStream(new URL(url).openStream());         File file = new File(path);         FileOutputStream out = new FileOutputStream(file);         IOUtils.copy(in, out);         in.close();         out.close();     }

Linux 搭建Redis

Fri, 04 Nov 2022 09:21:00 GMT

前言

之前在本地都是使用windows安装，直接下载运行就好。现在想在linux下安装，但是网上版本太多了，自己记录一个有效的安装步骤。环境：

redis版本：5.0.7
linux服务器：CentOS 7.6

安装

1、redis是C开发的，所以安装 redis 需要C语言的编译环境，即安装gcc

yum install gcc

2、切到 /usr/local 目录下，下载 redis-5.0.7.tar.gz

wget http://download.redis.io/releases/redis-5.0.7.tar.gz

3、解压并修改文件名

tar xzf redis-5.0.7.tar.gz mv redis-5.0.7 redis

4、进入redis目录，然后进行编译

make

5、安装（这个PREFIX是编译时用于指定程序存放的路径）

make PREFIX=/usr/local/redis install

6、修改redis.conf文件里的daemonize为yes，表示后台启动

vim /etc/redis.conf

# 设置访问密码 requirepass xxx

# 设置端口号 port 6379

# 设置外网访问 protected-mode no

7、启动redis

service redis start

8、进入redis客户端。出现如下命令行表示安装成功

/usr/local/redis/bin/redis-cli

其它

查看 redis 进程

ps -ef | grep redis

service redis status

关闭 redis 服务(杀掉进程)

kill -9 pid

微信支付接口v3的坑

Fri, 01 Jul 2022 05:43:00 GMT

微信支付所需资料：

商户号
商户证书序列号
接口密钥(APIV3)
证书（apiclient_key.pem，apiclient_cert.p12，apiclient_cert.pem）

商户证书序列号

商户证书序列号是指apiclient_cert.pem这个证书的序列号
可以通过这个网站查看https://myssl.com/cert_decode.html
apiclient_cert.pem 这个证书在项目中其实是用不到的

微信公钥证书 wxPublicKey

这个是需要导出的
CertificateDownloader jar包下载

java -jar CertificateDownloader-1.1.jar -f 商户私钥文件路径 -k 证书解密的密钥(APIV3) -m 商户号 -o 证书保存路径 -s 商户证书序列号

证书内容作为 wxPublicKey

ItelliJ IDEA Mac Osx 10.5+ 快捷键

Mon, 13 Jun 2022 05:51:00 GMT

# Mac键盘符号和修饰键说明：

⌘ Command

⇧ Shift

⌥ Option

⌃ Control

↩︎ Return/Enter

⌫ Delete

⌦ 向前删除键（Fn+Delete）

↑ 上箭头

↓ 下箭头

← 左箭头

→ 右箭头

⇞ Page Up（Fn+↑）

⇟ Page Down（Fn+↓）

Home Fn + ←

End Fn + →

⇥ 右制表符（Tab键）

⇤ 左制表符（Shift+Tab）

⎋ Escape (Esc)

# editing (编辑)

⌘N, ⌃↩ 生成代码/创建文件

⌘⌥L 格式化代码

⌃⇧Space 智能代码补全

⌘D 复制当前行或选定的块

⌘⌫ 删除当前行或选定的块的行

⌘⌥T 包围代码

⌘/ 注释/取消注释与行注释

⌘⌥/ 注释/取消注释与块注释

⌥↑ 连续选中代码块、⌥↓ 减少当前选中的代码块

⌥↩ 显示意向动作和快速修复代码

⌃⌥O 优化import (移除无用的导入)

⌘⇧V 从最近的缓冲区粘贴

⌃⇧J 智能的将代码拼接成一行

⌘⇧U 大小写切换

⌘⇧8 列模式

⌘⌃G 选择所有出现

⌘F12 查看文件结构

⌘⌥] / ⌘⌥[ 快速定位到代码块结束/开始

⌘⇧+/- 展开/折叠所以代码块

⌘P 显示方法的参数信息

⌃O 覆盖方法（重写父类方法）

⌃I 实现方法（实现接口中的方法）

⌃⇧Q 显示上下文信息

⌃⌥I 自动缩进线

# Search/Replace（查询/替换）

Double ⇧ 查询任何东西

⌘F 当前文件查找、⌘⇧F全局查找

⌘R 当前文件替换、⌘⇧F全局替换

# Usage Search（使用查询）

⌥F7 / ⌘F7 在文件中查找用法 / 在类中查找用法

⌘⌥F7 显示用法

# Compile and Run（编译和运行）

⌘F9 编译Project

⌘⇧F9 编译选择的文件、包或模块

⌃⌥R 弹出 Run 的可选择菜单

⌃⌥D 弹出 Debug 的可选择菜单

⌃R 运行

⌃D 调试

⌃⇧R, ⌃⇧D 从编辑器运行上下文环境配置

# Debugging（调试）

F8 跳到下一步，如果当前行断点是一个方法，则不进入当前方法体内

F7 进入下一步，如果当前行断点是一个方法，则进入当前方法体内，如果该方法体还有方法，则不会进入该内嵌的方法中

⇧F7 智能步入，断点所在行上有多个方法调用，会弹出进入哪个方法

⇧F8 跳出

F9 恢复程序

⌥F8 计算表达式（可以更改变量值使其生效）

⌘R 重新执行

⌘F8 切换断点（若光标当前行有断点则取消断点，没有则加上断点）

⌘⇧F8 查看断点信息

# Navigation（导航）

⌘O 搜索类、 ⌘⇧O 搜索文件

⌘⌥O 前往指定的变量 / 方法

⌘⇧] / ⌘⇧[ 切换标签

⌘W 关闭活动的编辑器选项卡

⌘L 在当前文件跳转到某一行的指定处

⌘E 显示最近打开的文件记录列表，⌘⇧E 显示最近修改的文件

⌘⌥← / ⌘⌥→ 退回 / 前进到上一个操作的地方

⌘⇧⌫ 跳转到最后一个编辑的地方

⌥F1 显示当前文件选择目标弹出层，弹出层中有很多目标可以进行选择(如在代码编辑窗口可以选择显示该文件的Finder)

⌘B / ⌘ 鼠标点击进入光标所在的方法/变量的接口或是定义处

⌘⌥B 跳转到实现处，在某个调用的方法名上使用会跳到具体的实现处，可以跳过接口

⌘U 前往当前光标所在方法的父类的方法 / 接口定义

⌃J / F1 查看javadoc

# Refactoring（重构）

F5 复制文件到指定目录

F6 移动文件到指定目录

⌘⌫ 在文件上为安全删除文件，弹出确认框

⇧F6 重命名文件

⌘F6 更改签名

⌘⌥M 将选中的代码提取为方法

⌘⌥V 提取变量

⌘⌥F 提取字段

⌘⌥C 提取常量

⌘⌥P 提取参数

阿里云云服务器ECS磁盘扩容

Thu, 09 Jun 2022 01:07:00 GMT

官方教程

磁盘扩容

查看系统磁盘占用情况

df -h

实际步骤

yum install gdisk -y yum install cloud-utils-growpart xfsprogs -y growpart /dev/vda 1 resize2fs /dev/vda1

常用快捷键整理

Fri, 14 Jan 2022 09:19:00 GMT

#列编辑

sublime Text

windows: Ctrl+Shift+L
mac: ⌘+Shift+L

IDEA

windows: Alt+shift+Insert
mac: ⌘+Shift+8

选择相同项

sublime Text

windows: Alt+F3
mac: Ctrl+⌘+G

IDEA

windows: Ctrl+Alt+shift+J
mac: Ctrl+⌘+G

统一设置快捷键

选中列编辑(Add Cursors to Line Ends): cmd+shift+L alt+shift+L
选中相同项(Select All Occurrences of Find Match): cmd+ctrl+G ctrl+alt+G

jar 命令的使用

Mon, 25 Oct 2021 10:08:00 GMT

jar 命令

Usage: jar {ctxui}[vfmn0PMe] [jar-file] [manifest-file] [entry-point] [-C dir] files ... Options:     -c  create new archive     -t  list table of contents for archive     -x  extract named (or all) files from archive     -u  update existing archive     -v  generate verbose output on standard output     -f  specify archive file name     -m  include manifest information from specified manifest file     -n  perform Pack200 normalization after creating a new archive     -e  specify application entry point for stand-alone application          bundled into an executable jar file     -0  store only; use no ZIP compression     -P  preserve leading '/' (absolute path) and ".." (parent directory) components from file names     -M  do not create a manifest file for the entries     -i  generate index information for the specified jar files     -C  change to the specified directory and include the following file If any file is a directory then it is processed recursively. The manifest file name, the archive file name and the entry point name are specified in the same order as the 'm', 'f' and 'e' flags.  Example 1: to archive two class files into an archive called classes.jar:         jar cvf classes.jar Foo.class Bar.class  Example 2: use an existing manifest file 'mymanifest' and archive all the            files in the foo/ directory into 'classes.jar':         jar cvfm classes.jar mymanifest -C foo/ .

解压jar包

jar xvf app.jar

打包jar包

jar cvf0M app.jar BOOT-INF META-INF org

MySQL多库数据备份

Fri, 22 Oct 2021 06:17:00 GMT

mysqldump -uroot -p*** --databases prod_sl prod_yq prod_xw prod_hy prod_jl prod_zj prod_ww prod_hn | gzip > /home/backup/mysql/prod.sql.gz

Nginx 常用配置

Thu, 07 Oct 2021 15:11:00 GMT

通道断开问题 Broken pipe

Nginx 配置

    location / {       proxy_pass http://localhost:8004/api/;       client_max_body_size 100m;       proxy_set_header X-Real-IP $remote_addr;       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;       # 这是关键       proxy_ignore_client_abort   on;     }

如果没解决？

Exceptionhandler

if ("org.apache.catalina.connector.ClientAbortException".equals(ex.getClass().getName())) {             return null; }

IntelliJ IDEA 技巧

Sat, 25 Sep 2021 07:26:00 GMT

常用插件

IDEA背景图片: `Background Image Plus`

给IDEA设置背景图片

MyBatis插件: `Free Mybatis plugin`

生成mapper xml文件
快速从代码跳转到mapper及从mapper返回代码
mybatis自动补全及语法错误提示
集成mybatis generator gui界面
根据数据库注解，生成swagger model注解

Setter生成器: `GenerateAllSetter`

一键调用一个对象的所有的set方法

IDE无限试用: `IDE eval Reset`

https://zhile.io/2020/11/18/jetbrains-eval-reset-da33a93d.html

力扣算法题: `LeetCode Editor`

支持leetcode.com和leetcode-cn.com,可测试与提交问题
更多的插件使用教程：插件使用介绍

Maven Helper

easy way for analyzing and excluding conflicting dependencies
actions to run/debug maven goals for a module that contains the current file or on the root module
action to open terminal at the current maven module path
actions to run/debug the current test file.

Vue.js

Open your Vue.js project.
Make sure you have Vue.js listed in your project dependencies in package.json and it is installed.
Now, you will get Vue-specific code completion, navigation, and many other features in .vue files.

CamelCase

驼峰格式转换

Translation

翻译

初始配置

`Setting>Editor>General`

Code Completion 代码提示非首字母
Auto Import
- Add Unambiguous imports on the fly: IntelliJ IDEA 将在我们书写代码的时候自动帮我们导入需要用到的包。但是对于那些同名的包，还是需要手动 Alt + Enter 进行导入的，IntelliJ IDEA 目前还无法智能到替我们做判断
- Optimize imports on the fly: IntelliJ IDEA 将在我们书写代码的时候自动帮我们优化导入的包，比如自动去掉一些没有用到的包
Appearance
- Show line numbers 显示行数
- Show method separators 显示方法线

`Setting>Editor>CopyRight` 添加版权

实现方法体添加TODO

路径：Settings->Editor->File and Code Templates->Code 修改：Implemented Method Body

// TODO: Implements me

MySQL查询~ 存在一个表而不在另一个表中的数据

Mon, 23 Aug 2021 03:16:00 GMT

A、B两表，找出ID字段中，存在A表，但是不存在B表的数据。A表总共13w数据，去重后大约3W条数据，B表有2W条数据，且B表的ID字段有索引。

方法一

　　使用 not in ,容易理解,效率低 ~执行时间为：1.395秒~

1 select distinct A.ID from  A where A.ID not in (select ID from B)

方法二

　　使用 left join...on... , "B.ID isnull" 表示左连接之后在B.ID 字段为 null的记录 ~执行时间：0.739秒~

1 select A.ID from A left join B on A.ID=B.ID where B.ID is null

　　图解

方法三

　　逻辑相对复杂,但是速度最快 ~执行时间: 0.570秒~

1  select * from  B  2     where (select count(1) as num from A where A.ID = B.ID) = 0

解决Java调用 InetAddress.getLocalHost() 非常慢

Wed, 18 Aug 2021 07:34:00 GMT

在java中获取本机服务器ip时调用了

InetAddress.getLocalHost()

有的时候会非常耗时，特别是服务器上，这个时候这样配置下就能解决问题

首先，查看主机名：

hostname

输出的就是主机名，如：centos1 2. 将这个主机名加入到host文件中

vim /etc/hosts

添加一行127.0.0.1 centos1

完成

一文搞懂【密钥库】与【证书】文件格式

Tue, 10 Aug 2021 09:05:00 GMT

密钥库文件格式`keystore`

格式    :   JKS 扩展名  :   .jks/.ks 描述    :   [Java Keystore]密钥库的Java实现版本，provider为SUN 特点    :   密钥库和私钥用不同的密码进行保护   格式    :   JCEKS 扩展名  :   .jce 描述    :   [JCE Keystore]密钥库的JCE实现版本，provider为SUN JCE 特点    :   相对于JKS安全级别更高，保护Keystore私钥时采用TripleDES   格式    :   PKCS12 扩展名  :   .p12/.pfx 描述    :   [PKCS #12]个人信息交换语法标准 特点    :   1、包含私钥、公钥及其证书    2、密钥库和私钥用相同密码进行保护   格式    :   BKS 扩展名  :  .bks 描述    :  Bouncycastle Keystore]密钥库的BC实现版本，provider为BC 特点    :   基于JCE实现   格式    :  UBER 扩展名  :  .ubr 描述    :  [Bouncycastle UBER Keystore]密钥库的BC更安全实现版本，provider为BC

证书文件格式`certificate`

格式    :   DER 扩展名  :   .cer/.crt/.rsa 描述    :  [ASN .1 DER]用于存放证书 特点    :   不含私钥、二进制     格式    :   PKCS7 扩展名  :  .p7b/.p7r 描述    :  [PKCS #7]加密信息语法标准 特点    :  1、p7b以树状展示证书链，不含私钥    2、p7r为CA对证书请求签名的回复，只能用于导入     格式    :   CMS 扩展名  :   .p7c/.p7m/.p7s 描述    :  [Cryptographic Message Syntax] 特点    :  1、p7c只保存证书    2、p7m：signature with enveloped data    3、p7s：时间戳签名文件   格式    :   PEM 扩展名  :  .pem 描述    :  [Printable Encoded Message] 特点    :  1、该编码格式在RFC1421中定义，其实PEM是[Privacy-Enhanced Mail]的简写，但他也同样广泛运用于密钥管理    2、ASCII文件    3、一般基于base 64编码     格式    :   PKCS10 扩展名  :  .p10/.csr 描述    :  [PKCS #10]公钥加密标准[Certificate Signing Request] 特点    :   1、证书签名请求文件    2、ASCII文件    3、CA签名后以p7r文件回复     格式    :   SPC 扩展名  :  .pvk/.spc 描述    :  [Software Publishing Certificate] 特点    :   微软公司特有的双证书文件格式，经常用于代码签名，其中    1、pvk用于保存私钥    2、spc用于保存公钥

crt格式证书转为RSA公钥

        Security.addProvider(new BouncyCastleProvider());         String path = "/Users/cliveyuan/data/keys/xxx.crt";         CertificateFactory cf = CertificateFactory.getInstance("X.509", "BC");         X509Certificate cert = (X509Certificate) cf.generateCertificate(new FileInputStream(path));         PublicKey publicKey = cert.getPublicKey();         String publicKeyString = Base64.encodeBase64String(publicKey.getEncoded());         System.out.println(publicKeyString);

搭建email服务器

Tue, 10 Aug 2021 03:34:00 GMT

https://docs.iredmail.org/install.iredmail.on.rhel-zh_CN.html

前端框架vant整合mockJs踩坑之旅

Fri, 06 Aug 2021 17:39:00 GMT

背景: 最近看上一个前端框架vant,它是移动端UI框架,整合一些常用的功能来做一个开源的移动端UI脚手架

项目地址: vant-demo

一切都很顺利的时候, 启动mock时报错,各种调试,各种改依赖包版本号, 辗转了解了babel的作用,最后还是没能解决,几经放弃. 后来搜索资料发现一个配置搞掉了...

VUE_CLI_BABEL_TRANSPILE_MODULES = true

还是这篇文章启发了我, 表示非常感谢,不然今晚可能无眠了! vue运行报错：SyntaxError: Cannot use import statement outside a module

结语: 千里之堤溃于蚁穴

MySQL中的悲观锁与常见的死锁场景

Fri, 16 Jul 2021 08:20:00 GMT

在MySQL中，锁机制是并发条件下保护数据一致性与稳定性的一个非常重要的机制，并且事务的实现也依赖于于锁机制。其锁定的数据不单包括数据行记录，同时也包括缓冲池中的LRU列表数据、日志数据等。悲观锁(FOR UPDATE)则是日常开发中使用最多的一种锁，但是，由于事务隔离级别的多样性导致了悲观锁在使用时常常会有不同的表现，死锁在程序员稍不注意时就会发生。

1. 悲观锁概述

在通用的程序设计语言中，锁通常是基于某一个对象，或者是一组对象而言。在Python、Java和Golang中，分别提供了threading.Lock、synchronized以及sync.Mutex互斥所机制。而数据库要更为特殊一些，其原因就在于我们所管理的不是一个个的对象，而是一行行的数据。

InnoDB存储引擎支持的最小锁粒度为行锁，可以通过在事务中执行SELECT .. FOR UPDATE为某一行或者是多行数据添加互斥锁。锁的生命周期完全由InnoDB管理，当事务成功提交或者是失败回滚时，互斥锁则自动释放。

需要注意的一点是，互斥锁必须在事务中执行才会生效。当autocommit为ON时，需要显示的使用BEGIN开启事务，而后对数据添加互斥锁。

在程序设计语言中，锁的目的是串行化修改、删除操作， InnoDB中的互斥锁有着同样的目的。但是，由于事务隔离级别的分类，使得互斥锁的行为变得复杂许多。其中最让人感到迷惑的就是为了解决幻读问题所添加的GAP Lock。

2. 事务隔离级别概述

不同的事务隔离级别，悲观锁会产生不同的行为。所以，理解事务隔离级别是理解悲观锁的第一步。

InnoDB事务隔离级别从低到高依次为未提交读(READ UNCOMMITED)，提交读(READ COMMITED)，可重复读(READ REPEATABLE)以及串行化(SERIALIZABLE)。

未提交读指的是事务B可以读取到事务A未提交的数据，此时若事务A回滚，那么事务B读到的就是错误数据，也称为脏数据。该读取行为有时也会被称为脏读，因为未提交读会导致脏读的问题，从而导致数据混乱，所以该事务隔离级别基本不会被使用。

提交读是指在执行事务B时，可以读取到事务A提交到的数据，未提交的数据不可读取。提交读解决了脏读的问题，读取到的数据一定是已经持久化至磁盘的数据，但是会出现同一条SQL语句在执行时出现不一致的情况。例如事务A、B先后开始执行，事务A首先读取row-1的内容，而此时事务B对row-1的内容修改并提交，此时事务A再次读取row-1数据，发现其已经发生改变，而该变化并不是事务A自身进行的。这种情况又称为不可重复读。

可重复读，顾名思义，解决了提交读的不可重复读问题，使得事务在读取同一行数据时，结果并不会因为其它事务的执行而发生改变，数据发生的修改行为在整个事务内是可以自恰的。但是并没有解决幻读的问题，幻读是指其余事务在某一个区间内插入数据，而非修改数据，此时事务也会读取到这部分插入的数据。 InnoDB借助MVCC(多版本并发控制)以及锁机制来解决幻读问题。

MVCC即在数据中添加版本号，数据插入时会有初始版本号，在修改、删除时更新版本号。

串行化指事务串行化执行，自然就不会有出现上述出现的脏读、不可重复读以及幻读了。一个很重要的事实是，串行化的事务隔离级别执行效率并不会比可重复读事务隔离级别差很多。同样的，提交读执行效率也不会比可重复读执行效率高多少，所以在优化数据库时，事务隔离级别不应该是效率优化目标，而是业务优化目标。

3. MySQL中的锁

使用FOR UPDATE对某一行或者是多行数据添加的锁，其实是由MySQL更细粒度的锁组合而成的，不同的事务隔离级别有不同的组合方式。

在InnoDB存储引擎中，存在3种行锁的算法，其分别为:

Record Lock: 单个行记录上的锁，聚集索引及辅助索引均会添加锁。
Gap Lock: 间隙锁，锁定一个范围，但不包含行记录本身。
Next-Key Lock: Record Lock + Gap Lock，锁定行记录本身并且锁定一个范围。

下面用一个实际的例子来解释Record Lock以及Gap Lock。首先表结构定义如下:

CREATE TABLE lock_test (   id int(11) NOT NULL AUTO_INCREMENT,   a varchar(6) NOT NULL,   PRIMARY KEY (id),   KEY (a) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; -- 插入部分测试数据 insert into lock_test (a) values ("1"); insert into lock_test (a) values ("3"); insert into lock_test (a) values ("5"); insert into lock_test (a) values ("8");

接着执行下面的语句:

时间	会话A	会话B
1	BEGIN;
2	SELECT * FROM lock_test WHERE a = “5” FOR UPDATE;
3		BEGIN;
4		INSERT INTO lock_test (a) VALUES (“4”); 阻塞，等待会话A事务的提交
5	COMMIT;	Query OK, 1 row affected (6.87 sec)

尽管列a添加了辅助索引，但是在对该列使用FOR UPDATE添加悲观锁时，仍然会出现其它列被锁定的现象。这是因为a = "5"该行数据不仅被添加了Record Lock，并且也添加了Gap Lock，其目的就是为了解决幻读问题，前提是当前事务隔离级别为REPEATABLE READ。

在列a的辅助索引中，值”5”之前的值为”3”，故存在(3, 5)这个间隙，所以在插入值”4”时， InnoDB为了杜绝幻读现象的发生，使得只有在会话A事务提交时才允许插入操作的进行。另外一点需要注意的是，当查询的索引具有唯一属性时， InnoDB存储引擎会对Next-Key Lock进行优化，将其降级为Record Lock，即仅锁住索引本身，而不锁定一个范围。

For a unique index with a unique search condition, InnoDB locks only the index record found, not the gap before it.

4. 锁与事务之间的关联

前面提到了Gap Lock的存在主要是为了解决幻读问题的发生，而在READ COMMITTED事务隔离级别中，只解决了脏读问题，所以说，在该事务隔离级别下， FOR UPDATE仅会添加Record Lock，并不会添加Gap Lock。

For locking reads (SELECT with FOR UPDATE or FOR SHARE), UPDATE statements, and DELETE statements, InnoDB locks only index records, not the gaps before them.

Because gap locking is disabled, phantom problems may occur, as other sessions can insert new rows into the gaps

此外，如果用户通过索引查询一个值，并在其之上添加排它锁，当查询的值不存在时， READ COMMITTED与REPEATABLE READ两个事务隔离级别所产生的行为同样存在差异，一个最直观的差异就是REPEATABLE READ在并发条件下会产生死锁，而READ COMMITTED则不会。

READ COMMITTED事务隔离级别:

时间	会话A	会话B
1	BEGIN;
2	SELECT * FROM lock_test WHERE a = “100” FOR UPDATE;
3		BEGIN;
4		SELECT * FROM lock_test WHERE a = “100” FOR UPDATE; 不会被阻塞
5	INSERT INTO lock_test (a) VALUES (“100”); 不会被阻塞
6		INSERT INTO lock_test (a) VALUES (“100”); 不会被阻塞
7	COMMIT;
8		COMMIT;

所以说，当事务隔离级别为READ COMMITTED时，无法使用Next-Key Lock来帮助我们实现类似于update_or_create或者是get_or_create等方法，因为在并发条件下会造成重复数据创建，除非表中存在唯一索引。这也是Django框架官网中所提到的Multiply records问题。感兴趣的小伙伴可访问官网获取更多详细内容:

https://docs.djangoproject.com/en/2.2/ref/models/querysets/#get-or-create

REPEATABLE READ事务隔离级别:

时间	会话A	会话B
1	BEGIN;
2	SELECT * FROM lock_test WHERE a = “200” FOR UPDATE;
3		BEGIN;
4		SELECT * FROM lock_test WHERE a = “200” FOR UPDATE; 不会被阻塞
5	INSERT INTO lock_test (a) VALUES (“200”); 阻塞, 等待事务B的结束
6		INSERT INTO lock_test (a) VALUES (“200”); ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction，死锁发生

当在REPEATABLE READ事务隔离级别级别下实现get_or_create方法时，会产生死锁问题，原因就在于锁定的记录并不存在，多个事务可同时对其添加悲观锁，但是插入语句的执行位置是不确定的，所以就会有死锁问题的出现。解决此类问题的一个方法就是使用指数退避方式的重试。

5. 死锁

通常来讲，如果我们的SQL执行计划较为简单，几乎所有的执行均为单条语句执行时，死锁基本与我们无关。但是当执行计划稍加复杂，事务执行的语句较多时，就会出现死锁问题。一个最经典的死锁场景即为AB-BA死锁。

时间	会话A	会话B
1	BEGIN;
2	SELECT * FROM lock_test WHERE a = “200” FOR UPDATE;
3		BEGIN;
4		SELECT * FROM lock_test WHERE a = “400” FOR UPDATE;
5	SELECT * FROM lock_test WHERE a = “400” FOR UPDATE 阻塞, 等待事务B的结束
6		SELECT * FROM lock_test WHERE a = “200” FOR UPDATE; ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction，死锁发生

当MySQL检测到死锁时，会根据其事务权重选择性的回滚其中一个事务。但是，权重的判定完全由MySQL决定，业务系统无法人为的干预，如果某一个事务在业务系统中非常重要，但是MySQL却回滚了该事务，而业务系统仅捕捉了该异常并向外扩散的话，并不是我们期望的结果。所以，在绝大多数场景下，指数退避的重试策略要更好一些。或者对于关键性的业务逻辑，使用Redis等消息队列进行串行化操作。

另外一个死锁场景则是上一小节中我们所见到的并发执行if not exist then create模式所带来的死锁问题，该模式在业务场景下其实非常常见。

Linux 常用脚本

Mon, 05 Jul 2021 10:45:00 GMT

查看系统磁盘占用情况

df -h

查看文件夹大小

du -h --max-depth=1 .

删除7天以前的文件夹

find . -type d -mtime +7 -exec rm -rf {} \; # x为天数

查看Linux版本

cat /etc/redhat-release

设计模式

Tue, 11 May 2021 05:50:00 GMT

下面总结一下这 23 种设计模式，以方便小伙伴们日后复习和查阅。

分类	设计模式	简述	一句话归纳	目的	生活案例
创建型设计模式（简单来说就是用来创建对象的）	工厂模式（Factory Pattern）	不同条件下创建不同实例	产品标准化，生产更高效	封装创建细节	实体工厂
	单例模式（Singleton Pattern）	保证一个类仅有一个实例，并且提供一个全局访问点	世上只有一个我	保证独一无二	CEO
	原型模式（Prototype Pattern）	通过拷贝原型创建新的对象	拔一根猴毛，吹出千万个	高效创建对象	克隆
	建造者模式（Builder Pattern）	用来创建复杂的复合对象	高配中配和低配，想选哪配就哪配	开放个性配置步骤	选配
结构型设计模式（关注类和对象的组合）	代理模式（Proxy Pattern）	为其他对象提供一种代理以控制对这个对象的访问	没有资源没时间，得找别人来帮忙	增强职责	媒婆
	外观模式（Facade Pattern）	对外提供一个统一的接口用来访问子系统	打开一扇门，通向全世界	统一访问入口	前台
	装饰器模式（Decorator Pattern）	为对象添加新功能	他大舅他二舅都是他舅	灵活扩展、同宗同源	煎饼
	享元模式（Flyweight Pattern）	使用对象池来减少重复对象的创建	优化资源配置，减少重复浪费	共享资源池	全国社保联网
	组合模式（Composite Pattern）	将整体与局部（树形结构）进行递归组合，让客户端能够以一种的方式对其进行处理	人在一起叫团伙，心在一起叫团队	统一整体和个体	组织架构树
	适配器模式（Adapter Pattern）	将原来不兼容的两个类融合在一起	万能充电器	兼容转换	电源适配
	桥接模式（Bridge Pattern）	将两个能够独立变化的部分分离开来	约定优于配置	不允许用继承	桥
行为型设计模式（关注对象之间的通信）	模板模式（Template Pattern）	定义一套流程模板，根据需要实现模板中的操作	流程全部标准化，需要微调请覆盖	逻辑复用	把大象装进冰箱
	策略模式（Strategy Pattern）	封装不同的算法，算法之间能互相替换	条条大道通罗马，具体哪条你来定	把选择权交给用户	选择支付方式
	责任链模式（Chain of Responsibility Pattern）	拦截的类都实现统一接口，每个接收者都包含对下一个接收者的引用。将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。	各人自扫门前雪，莫管他们瓦上霜	解耦处理逻辑	踢皮球
	迭代器模式（Iterator Pattern）	提供一种方法顺序访问一个聚合对象中的各个元素	流水线上坐一天，每个包裹扫一遍	统一对集合的访问方式	逐个检票进站
	命令模式（Command Pattern）	将请求封装成命令，并记录下来，能够撤销与重做	运筹帷幄之中，决胜千里之外	解耦请求和处理	遥控器
	状态模式（State Pattern）	根据不同的状态做出不同的行为	状态驱动行为，行为决定状态	绑定状态和行为	订单状态跟踪
	备忘录模式（Memento Pattern）	保存对象的状态，在需要时进行恢复	失足不成千古恨，想重来时就重来	备份、后悔机制	草稿箱
	中介者模式（Mediator Pattern）	将对象之间的通信关联关系封装到一个中介类中单独处理，从而使其耦合松散	联系方式我给你，怎么搞定我不管	统一管理网状资源	朋友圈
	解释器模式（Interpreter Pattern）	给定一个语言，定义它的语法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子	我想说”方言“，一切解释权都归我	实现特定语法解析	摩斯密码
	观察者模式（Observer Pattern）	状态发生改变时通知观察者，一对多的关系	到点就通知我	解耦观察者与被观察者	闹钟
	访问者模式（Visitor Pattern）	稳定数据结构，定义新的操作行为	横看成岭侧成峰，远近高低各不同	解耦数据结构和数据操作	KPI考核
	委派模式（Delegate Pattern）	允许对象组合实现与继承相同的代码重用，负责任务的调用和分配	这个需求很简单，怎么实现我不管	只对结果负责	授权委托书

转载于http://c.biancheng.net/view/8462.html

Linux7 替换yum源

Mon, 18 Jan 2021 05:25:00 GMT

替换yum源

vim /etc/yum.repos.d/epel.repo

[epel] name=Extra Packages for Enterprise Linux 7 - $basearch baseurl=http://mirrors.aliyun.com/epel/7/$basearch failovermethod=priority enabled=1 gpgcheck=0 gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7  [epel-debuginfo] name=Extra Packages for Enterprise Linux 7 - $basearch - Debug baseurl=http://mirrors.aliyun.com/epel/7/$basearch/debug failovermethod=priority enabled=0 gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7 gpgcheck=0  [epel-source] name=Extra Packages for Enterprise Linux 7 - $basearch - Source baseurl=http://mirrors.aliyun.com/epel/7/SRPMS failovermethod=priority enabled=0 gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7 gpgcheck=0 ~

如何将自己的代码发布到Maven中央仓库？

Wed, 23 Dec 2020 08:24:00 GMT

转自：https://www.cnblogs.com/songyz/p/11387978.html

如何将自己的代码发布到Maven中央仓库？

去年在公司做工作流相关业务时，当时使用flowable做引擎，中途涉及到一些业务上的需求，自己整理了一些代码，考虑到开源精神，当时就想着将于公司业务无关的代码抽离出来，放到Maven中央仓库中，以供别人学习借鉴，跟着各路大神的帖子折腾了不少时间，一路曲折最终发布到仓库中，地址在此 https://mvnrepository.com/artifact/com.github.songyz0310/flowable-lang 需要的可以使用，我会不定期更新。回到本帖主题，本篇不涉及此工具包，主要说下关于Maven发布的步骤和心得。最近心血来潮，希望把这几年的java相关的东西整理下，暂定项目集 java-toolkits 。

第一步，注册GitHub的账户

地址：https://github.com

关于GitHub，无需我多说，Java语言本身就是开源的，作为Javaer又怎么离得开GitHub，注册没什么需要提的，这是我个人的GitHub地址，欢迎评价点星！

第二步，注册Sonatype的账户

地址：https://issues.sonatype.org/secure/Signup!default.jspa

【友情提示】这里的密码校验真的是很太苛刻了，基本上是我见过的最严格的的。注册过后一定要记在小本本上，否则，我敢说大部分人一小时之后就记不得了，

第三步，在Sonatype上提交关于本项目的发布申请

点击页面上方 Create 按钮即可创建此项目的 Issue。

1 Project: Community Support - Open Source Project Repository Hosting (OSSRH) 2 Issue TypeRequired: New Project 3  4 Summary: java-toolkits （自己项目名称） 5 Group Id：com.github.songyz0310 （maven项目坐标 Group Id） 6 Project URL：https://github.com/songyz0310/java-toolkits (项目地址) 7 SCM url：https://github.com/songyz0310/java-toolkits.git （源代码地址）

其他内容可以按照自己实际情况填写，可以用默认值的地方，可以不用填写。

当你提交后状态为等待工作人员审核，审核通过后状态会修改为 RESOLVED

关于此步骤审核我有个小疑问，我2018年发布flowable-lang项目时，跟2019年发布java-toolkits项目要求有些稍微的不同，后边这一次多了对于权限的校验，不过在工作人员的详细回复下，问题不大。毫无疑问，这次比上次校验的更严格了。当你看到最后这一条评论时，就证明你可以开始下一步了。

第四步，配置Maven

4.1，配置 settings.xml 文件

在servers节点内部添加如下server配置，这里就会用到第二步的注册信息（~偷笑~）

 1 <server>  2   <id>sonatype-nexus-snapshots</id>  3   <username>Sonatype账号</username>  4   <password>Sonatype密码</password>  5 </server>  6 <server>  7   <id>sonatype-nexus-staging</id>  8   <username>Sonatype账号</username>  9   <password>Sonatype密码</password> 10 </server>

4.2，配置项目 pom.xml 文件

增加开源许可协议，SCM信息，开发者信息等待根据自己信息填写即可

 1 <licenses>  2     <license>  3         <name>The Apache Software License, Version 2.0</name>  4         <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>  5     </license>  6 </licenses>  7 <scm>  8     <connection>scm:git:https://github.com/songyz0310/java-toolkits.git</connection>  9     <developerConnection>scm:git:https://github.com/songyz0310/java-toolkits.git</developerConnection> 10     <url>git:https://github.com/songyz0310/java-toolkits.git</url> 11 </scm> 12 <developers> 13     <developer> 14         <name>songyz</name> 15         <email>songyinzeng@gmail.com</email> 16         <organization>i1stcs</organization> 17     </developer> 18 </developers>

如果发布Release版本，需要添加Release的相关profile配置，distributionManagement节和maven-compiler-plugin节的配置信息根据自己的实际情况做修改。

 1 <profile>  2     <id>release</id>  3     <build>  4         <resources>  5             <resource>  6                 <directory>src/main/java</directory>  7                 <includes>  8                     <include>**/*.properties</include>  9                 </includes> 10             </resource> 11         </resources> 12         <plugins> 13             <!-- Source --> 14             <plugin> 15                 <groupId>org.apache.maven.plugins</groupId> 16                 <artifactId>maven-source-plugin</artifactId> 17                 <version>2.2.1</version> 18                 <executions> 19                     <execution> 20                         <phase>package</phase> 21                         <goals> 22                             <goal>jar-no-fork</goal> 23                         </goals> 24                     </execution> 25                 </executions> 26             </plugin> 27             <!-- Javadoc --> 28             <plugin> 29                 <groupId>org.apache.maven.plugins</groupId> 30                 <artifactId>maven-javadoc-plugin</artifactId> 31                 <version>2.9.1</version> 32                 <configuration> 33                     <show>private</show> 34                     <nohelp>true</nohelp> 35                     <charset>UTF-8</charset> 36                     <encoding>UTF-8</encoding> 37                     <docencoding>UTF-8</docencoding> 38                     <additionalparam>-Xdoclint:none</additionalparam> 39                     <!-- TODO 临时解决不规范的javadoc生成报错,后面要规范化后把这行去掉 --> 40                 </configuration> 41                 <executions> 42                     <execution> 43                         <phase>package</phase> 44                         <goals> 45                             <goal>jar</goal> 46                         </goals> 47                     </execution> 48                 </executions> 49             </plugin> 50             <!-- GPG --> 51             <plugin> 52                 <groupId>org.apache.maven.plugins</groupId> 53                 <artifactId>maven-gpg-plugin</artifactId> 54                 <version>1.5</version> 55                 <executions> 56                     <execution> 57                         <phase>verify</phase> 58                         <goals> 59                             <goal>sign</goal> 60                         </goals> 61                     </execution> 62                 </executions> 63             </plugin> 64             <!--Compiler --> 65             <plugin> 66                 <groupId>org.apache.maven.plugins</groupId> 67                 <artifactId>maven-compiler-plugin</artifactId> 68                 <version>3.0</version> 69                 <configuration> 70                     <source>1.8</source> 71                     <target>1.8</target> 72                     <fork>true</fork> 73                     <verbose>true</verbose> 74                     <encoding>UTF-8</encoding> 75                     <showWarnings>false</showWarnings> 76                 </configuration> 77             </plugin> 78             <!--Release --> 79             <plugin> 80                 <groupId>org.apache.maven.plugins</groupId> 81                 <artifactId>maven-release-plugin</artifactId> 82                 <version>2.5.1</version> 83             </plugin> 84         </plugins> 85     </build> 86     <distributionManagement> 87         <snapshotRepository> 88             <id>sonatype-nexus-snapshots</id> 89             <name>Sonatype Nexus Snapshots</name> 90             <url>https://oss.sonatype.org/content/repositories/snapshots/</url> 91         </snapshotRepository> 92         <repository> 93             <id>sonatype-nexus-staging</id> 94             <name>Nexus Release Repository</name> 95             <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url> 96         </repository> 97     </distributionManagement> 98 </profile>

第五步，配置PGP的公钥信息

由于我使用的是Windows，Mac和Linux用户请自行查找本步骤解决方案

Windows下使用gpg4win来进行配置。下载地址 https://www.gpg4win.org/get-gpg4win.html
安装好之后，打开cmd控制台，使用 gpg --list-keys 命令来查询自己配置的key
如果提示gpg不是可执行程序或命令，请配置Path路径到 GnuPG 的bin目录

生成密钥的命令 gpg --gen-key，过程中需要使用到姓名、邮箱等信息，这里的配置最好和Sonatype注册信息、pom文件配置信息保持一致，以免不必要的麻烦。
生成的过程中，会有个弹框要求输入Passphase信息，这个是密钥的密码，同样需要记牢。发布签名的过程中会用得到。

使用 gpg --list-keys 命令查询配置好的公私钥信息，使用 gpg --keyserver hkp://keyserver.ubuntu.com:11371 --send-keys <公钥key> 将公钥信息发送到ubuntu.com服务器，后续推送maven仓库会做校验。

第六步，打包Deploy

使用 mvn clean deploy -P <profile-id> 命令，一键打包。
打包过程中会要求输入gpg密钥的Passphase信息，输入即可。

【友情提示】如果打包过程中出现了401类的错误，可能是因为Maven的配置文件中Server节点配置的用户名和密码不正确，或者 Issue 还未审核通过。

第七步，发布Release

进入 https://oss.sonatype.org/#stagingRepositories 查看发布好的构件，点击左侧的Staging Repositories，可以使用Group Id或其他信息搜索自己的项目，

此时的构件状态为 Open，选中构件，并点击上方的 Close–>Confirm 在下边的Activity选项卡中查看状态。

当状态变成closed后，执行 Release–>Confirm 并在下边的Activity选项卡中查看状态。
成功后构件自动删除，一小段时间（约1-2个小时）后即可同步到maven的中央仓库。届时会有邮件通知。

至此，发布到Maven中央仓库完成。

第八步，收尾工作

对自己提交的Issue增加Comment，留言致谢并表示发布已经完成，请工作人员关闭Issue。

有始有终吧。☺☺☺收工~~~

java8函数式编程

Fri, 27 Nov 2020 07:32:00 GMT

转自https://zhuanlan.zhihu.com/p/63107670

Java8里面函数式编程

程序员

Java8里面引入了新的一个包java.util.function。里面定义了下面几个核心接口：

Function<T,R>：接收一个参数，返回一个结果。
Consumer<T>：接收一个参数，无返回。
Predicate<T>：接收一个参数，返回一个boolean的结果。
Supplier<R>：无参数，返回一个结果。
BiFunction<T,V,R>：接收两个参数，返回一个结果。
BiConsumer<T,V>：接收两个参数，无返回值。
BiPredicate<T,V>：接收两个参数，返回boolean值。

Function接口

//function表示具有返回值的，具有一个参数的方法 Function<String,Integer> function1=Integer::valueOf; Function function2=String::valueOf; //可以用lambda表达式 Function<Object,String> function3=(a)->a.toString(); //报错，因为无返回值 //Function out=System.out::println; //返回值是Boolean的function String o="123"; Function<String,Boolean> function4=o::equals; boolean equals=function4.apply("123");

Consumer接口

//Consumer可以用来表示只有一个参数，无返回值的方法 Consumer consumer=System.out::println; consumer.accept("123"); //可以用lambda表达式 Consumer consumer2=(a)->{};

Predicate接口

//用Predicate来表示 Predicate<String> predicate=o::equals;

Supplier接口

//无参数有返回 Supplier<Integer> supplier=o::hashCode; IntSupplier intSupplier=o::hashCode; Supplier supplier2=()-> "test";

二元参数相关

//二个参数的函数 BiFunction<String,String, Boolean> test= (str,str2)->true; BiConsumer<String,String> test2=(str,str2)->{}; BiPredicate<String,String> test3=(str,str2)->true;

发布于 2019-04-20

IOS抓包软件 Thor

Mon, 16 Nov 2020 02:55:00 GMT

https://www.jianshu.com/p/bb8231f48a07

git 常用脚本

Fri, 06 Nov 2020 02:15:00 GMT

一键清理本地分支：删除除master之外的本地分支，同步远程分支

执行前一定要提交当前分支的更改哦

git checkout master;git branch | xargs git branch \-d;git remote prune origin;

合并Commits

将多个提交记录进行合并

git rebase -i ${commitId}

commitId是最近一条不需要合并的commit的id

pick 2dfbc7e1 commit1 pick 2dfbc7e2 commit2 pick 2dfbc7e3 commit3

修改为

pick 2dfbc7e1 commit1 s 2dfbc7e2 commit2 s 2dfbc7e3 commit3

s 表示要合并的commit

#the first commit commit1 #the second commit commit2 #the third commit commit3

改为

#the first commit merge commits - commit1 - commit2 - commit3

最重要的一步：强制提交

git push --force

完成

生成

#全局配置 git config --global user.name "Clive Yuan" git config --global user.email "xxxx@foxmail.com" cd ~/.ssh     mkdir ~/.ssh ssh-keygen -t rsa -C "clive@xxx.com" cat ~/.ssh/id_rsa.pub ssh -T git@gitee.com

别名

up = pull --rebase --autostash acp = "!f() { git add -A && git commit -m \"$@\" && git push; }; f" ac = "!f() { git add -A && git commit -m \"$@\"; }; f" cleanbranch = "checkout master;branch | xargs branch \\-d;remote prune origin;"  # 忽略换行符  git config core.autocrlf false

Spring学习笔记

Wed, 03 Jun 2020 14:20:00 GMT

Spring

特点

轻量级
松耦合
万能胶
设计模式
面向Bean

关键策略

基于POJO的轻量级和最小侵入性编程
通过依赖注入和面向接口松耦合
基于切面和惯性进行声明式编程
通过切面和模板减少样板式代码

IoC 控制反转

将实例化bean的控制权交给spring框架

AOP 面向切面编程

将那些影响多个类的行为通过切面方式封装到一个可重用的模块中

idea license

Mon, 01 Jun 2020 03:33:00 GMT

https://zhile.io/custom/license

code: https://gitee.com/clive_private/codes/bwsak1ljteufpdrxgn9v356

crontab 启动springboot项目失败

Mon, 11 May 2020 09:34:00 GMT

记一次踩坑经历

起因

在Linux中使用用全路径shell启动springBoot项目

sh /home/code/app.sh

app.sh脚本中启动springBoot的命令是java -jar app.jar

问题就在这里，如果进入到命令的当前目录即/home/code/去执行app.sh是没问题的，全路径执行就不行

在使用crontab时，就算脚本是进入到对应目录去执行app.sh也是不行的

解决方案

启动springBoot命令这里使用java的全路径/usr/java/jdk1.8.xxx/java -jar app.jar

使用acme.sh免费申请Let's Encrypt泛域名证书SSL

Wed, 29 Apr 2020 04:01:00 GMT

https://zhuanlan.zhihu.com/p/112300451

CentOS8下安装mysql5.7

Tue, 28 Apr 2020 08:45:00 GMT

1、安装YUM Repo

由于CentOS 的yum源中没有mysql，需要到mysql的官网下载yum repo配置文件。

wget https://dev.mysql.com/get/mysql57-community-release-el7-9.noarch.rpm

然后进行repo的安装：

rpm -ivh mysql57-community-release-el7-9.noarch.rpm

执行完成后会在/etc/yum.repos.d/目录下生成两个repo文件mysql-community.repo mysql-community-source.repo

2、安装MySQL

使用yum命令即可完成安装

yum install mysql-community-server

 # 如果报错： No match for argument: mysql-community-server ，执行如下命令 之后再执行上述命令

yum module disable mysql

启动msyql：

systemctl start mysqld #启动MySQL

配置MySQL

获取安装时的临时密码：

grep 'temporary password' /var/log/mysqld.log

倘若没有：

1.删除原来安装过的mysql残留的数据

rm -rf /var/lib/mysql

2.再启动mysql

systemctl start mysqld #启动MySQL

mysql -u root -p

登录成功后修改密码：

set password=password("yourpassword");

设置安全选项：

mysql_secure_installation

其他设置：

systemctl stop mysqld #关闭MySQL systemctl restart mysqld #重启MySQL systemctl status mysqld #查看MySQL运行状态 systemctl enable mysqld #设置开机启动 systemctl disable mysqld #关闭开机启动

3、其他配置

开启远程控制

MySQL默认是没有开启远程控制的，必须添加远程访问的用户

grant all privileges on 数据库名.表名 to 创建的用户名(root)@"%" identified by "密码"; # 数据库名.表名 如果写成*.*代表授权所有的数据库   flush privileges; #刷新刚才的内容

#如：
grant all privileges on *.* to root@"113.64.243.1" identified by "123456789";

@ 后面是访问mysql的客户端IP地址（或是主机名） % 代表任意的客户端，如果填写 localhost 为本地访问（那此用户就不能远程访问该mysql数据库了）。

同时也可以为现有的用户设置是否具有远程访问权限。

配置默认编码为utf8：

vi /etc/my.cnf #添加 [mysqld] character_set_server=utf8 init_connect='SET NAMES utf8'

其他默认配置文件路径：

配置文件：/etc/my.cnf  日志文件：/var/log//var/log/mysqld.log  服务启动脚本：/usr/lib/systemd/system/mysqld.service  socket文件：/var/run/mysqld/mysqld.pid

git init project

Thu, 09 Apr 2020 01:54:00 GMT

Command line instructions

Git global setup git config --global user.name "cliveyuan" git config --global user.email "clive@cliveyuan.com"

Create a new repository

git clone git@gitee.com:opensource4clive/java-tools.git cd java-tools touch README.md git add README.md git commit -m "add README" git push -u origin master

Existing folder or Git repository

must create project in gitee before

cd existing_folder git init git remote add origin git@gitee.com:opensource4clive/java-tools.git git add -A git commit -am 'init' git push -u origin master

Git中撤销提交

Mon, 30 Mar 2020 07:20:00 GMT

Git中撤销提交

Git的几种状态

未修改             工作区 已修改    ↓             工作区 已暂存    ↓             暂存区 已提交    ↓             本地仓库 已推送    ↓             远程仓库

已修改未暂存

已经修改了文件，还未进行git add

恢复方法

使用一下任意命令

git checkout . git reset --hard

已暂存未提交

已经进行了git add，还未进行git commit

恢复方法

使用一下任意命令

git reset git checkout . git reset --hard

已提交未推送

已经进行了git ommit，还未进行git push

恢复方法

使用远程仓库覆盖本地仓库

git reset --hard origin/master

已推送

已经进行了git push

恢复方法

回滚本地仓库，强制推送覆盖远程仓库

git reset --hard HEAD^ git push -f

漫谈SQL优化

Fri, 20 Mar 2020 05:44:00 GMT

1. 前言

随着业务量的增长，用户数越来越多，随之产生的数据也呈几何级增长，从而慢查询越来越多。SQL优化一方面是找出系统的瓶颈，提高数据库服务器的整体性能，而另一方面需要合理的结构设计和参数调整，以提数据访问的速度，同时还要尽可能的节约系统资源，以便让系统性能最大化。

本文内容主要针对的是关系型数据库，以MySQL为例子

2. 需要准备的知识点

2.1 数据逻辑架构

第一层：客户端通过连接服务，将要执行的SQL指令传输过来
第二层：服务器解析并优化SQL，生成最终的执行计划并执行
第三层：存储引擎，负责数据的储存和提取

2.2 锁

数据库通过锁机制来解决并发场景-共享锁（读锁）和排他锁（写锁）。读锁是不阻塞的，多个客户端可以在同一时刻读取同一个资源。写锁是排他的，并且会阻塞其他的读锁和写锁。简单提下乐观锁和悲观锁。

乐观锁：通常用于数据竞争不激烈的场景，多读少写，通过版本号和时间戳实现。
悲观锁：通常用于数据竞争激烈的场景，每次操作都会锁定数据，要锁定数据需要一定的锁策略来配合。
表锁：锁定整张表，开销最小，但是会加剧锁竞争。
行锁：锁定行级别，开销最大，但是可以最大程度的支持并发。

但是MySQL的存储引擎的真实实现不是简单的行级锁，一般都是实现了多版本并发控制（MVCC）。MVCC是行级锁的变种，多数情况下避免了加锁操作，开销更低。MVCC是通过保存数据的某个时间点快照实现的。

2.3 事务

事务保证一组原子性的操作，要么全部成功，要么全部失败。一旦失败，回滚之前的所有操作。

隔离级别控制了一个事务中的修改，哪些在事务内和事务间是可见的。四种常见的隔离级别：

未提交读（Read UnCommitted），事务中的修改，即使没提交对其他事务也是可见的。事务可能读取未提交的数据，造成脏读。
提交读（Read Committed），一个事务开始时，只能看见已提交的事务所做的修改。事务未提交之前，所做的修改对其他事务是不可见的。也叫不可重复读，同一个事务多次读取同样记录可能不同。
可重复读（RepeatTable Read），同一个事务中多次读取同样的记录结果时结果相同。
可串行化（Serializable），最高隔离级别，强制事务串行执行。

2.4 常用存储引擎

InnoDB引擎： 支持事务、行级锁，被用来设计处理大量短期事务，具有高性能和自动崩溃恢复的特性
**MyISAM引擎：**不支持事务和行级锁，查询性能强，崩溃后无法安全恢复

3. 优化

3.1 优化方法

软优化：操作数据库
硬优化：是操作服务器硬件及参数设置

3.2 软优化

3.2.1 查询语句优化

用EXPLAIN命令分析一条查询语句的执行信息

EXPLAIN SELECT * FROM `user`

select_type，有几种值：simple（表示简单的select，没有union和子查询），primary（有子查询，最外面的select查询就是primary），union（union中的第二个或随后的select查询，不依赖外部查询结果），dependent union（union中的第二个或随后的select查询，依赖外部查询结果）
type，有几种值：system（表仅有一行（=系统表），这是const连接类型的一个特例），const（常量查询）, ref(非唯一索引访问，只有普通索引)，eq_ref（使用唯一索引或组件查询），all（全表查询），index（根据索引查询全表），range（范围查询）
possible_keys: 表中可能帮助查询的索引
key，选择使用的索引
key_len，使用的索引长度
rows，扫描的行数，越大越不好
extra，有几种值：Only index（信息从索引中检索出，比扫描表快），where used（使用where限制），Using filesort （可能在内存或磁盘排序），Using temporary（对查询结果排序时使用临时表）

3.2.2 优化子查询

在MySQL中，尽量使用JOIN来代替子查询。因为子查询需要嵌套查询，嵌套查询时会建立一张临时表，临时表的建立和删除都会有较大的系统开销，而连接查询不会创建临时表，因此效率比嵌套子查询高。

3.2.3 使用索引

使用索引可以显著地提高数据库查询速度，但是未恰当使用索引往往适得其反

如何创建索引:

尽量选择区分度高的列创建索引
对于查询频率高的列创建索引
尽量使用长度短的列作为索引
对于长VARCHAR/TEXT/BLOB使用前缀索引

索引未命中:

条件中包含OR / NOT IN / NOT EXIST / 不等于
模糊匹配字段以%开头
未使用联合索引中的第一个字段
数值的字符串列未使用单引号
在索引列上使用函数

3.2.4 分解表

对于字段较多的表，如果某些字段使用频率较低，此时应当，将其分离出来从而形成新的表
对应存储长文本如LONGTEXT，应当放到单独的表中进行存储

3.2.5 中间表

对于将大量连接查询的表可以创建中间表，从而减少在查询时造成的连接耗时

中间表复制源表部分数据，并且与源表相“隔离”，在中间表上做统计查询不会对在线应用产生负面影响
中间表上可以灵活的添加索引或增加临时用的新字段，从而达到提高统计查询效率和辅助统计查询作用

3.2.6 增加冗余字段

在设计数据库时，我们往往依照数据库的范式降低数据间的冗余度，但是冗余字段就像是把双刃剑，在业务需求上,有效的增加数据的冗余度，还可以提高数据的访问效率

空间换时间
业务快照

3.2.7 分析表

分析表主要是分析表中关键字的分布,检查表主要是检查表中是否存在错误,优化表主要是消除删除或更新造成的表空间浪费

ANALYZE TABLE user;

Op: 表示执行的操作
Msg_type: 信息类型,有status,info,note,warning,error
Msg_text: 显示信息

3.2.8 检查表

使用 CHECK关键字, 如CHECK TABLE user [option]

CHECK TABLE `user` FAST;

option 只对MyISAM有效, 共五个参数值:

QUICK: 不扫描行,不检查错误的连接
FAST: 只检查没有正确关闭的表
CHANGED: 只检查上次检查后被更改的表和没被正确关闭的表
MEDIUM: 扫描行,以验证被删除的连接是有效的,也可以计算各行关键字校验和
EXTENDED: 最全面的的检查,对每行关键字全面查找

3.2.9 优化表

使用OPTIMIZE关键字,如OPTIMIZE [LOCAL|NO_WRITE_TO_BINLOG] TABLE user;

OPTIMIZE LOCAL TABLE `user`;

LOCAL | NO_WRITE_TO_BINLOG都是表示不写入日志，优化表只对VARCHAR, BLOB和TEXT有效, 通过OPTIMIZE TABLE语句可以消除文件碎片, 在执行过程中会加上只读锁

3.3 硬优化

3.3.1 硬件配置

配置多核心和频率高的cpu,多核心可以执行多个线程
配置大内存,提高内存,即可提高缓存区容量,因此能减少磁盘I/O时间,从而提高响应速度
配置高速磁盘或合理分布磁盘:高速磁盘提高I/O,分布磁盘能提高并行操作的能力

3.3.2 优化数据库参数

优化数据库参数可以提高资源利用率,从而提高MySQL服务器性能.MySQL服务的配置参数都在my.cnf或my.ini,下面列出性能影响较大的几个参数.

key_buffer_size: 索引缓冲区大小
table_cache: 能同时打开表的个数
query_cache_size和query_cache_type:前者是查询缓冲区大小,后者是前面参数的开关,0表示不使用缓冲区,1表示使用缓冲区,但可以在查询中使用SQL_NO_CACHE表示不要使用缓冲区,2表示在查询中明确指出使用缓冲区才用缓冲区,即SQL_CACHE.
sort_buffer_size:排序缓冲区

3.3.3 分库分表 + 读写分离

当数据量达到一定的数量之后，限制数据库存储性能的就不再是数据库层面的优化就能够解决的；这个时候往往采用的是读写分离与分库分表同时也会结合缓存一起使用，而这个时候数据库层面的优化只是基础。读写分离适用于较小一些的数据量；分表适用于中等数据量；而分库与分表一般是结合着用，这就适用于大数据量的存储了。分库分表 + 读写分离，也就是把一个库拆分为多个库，部署在多个数据库服务上，这时作为主库承载写入请求。然后每个主库都挂载至少一个从库，由从库来承载读请求，从而减轻服务器压力

3.3.4 缓存集群

缓存系统的设计就是为了承载高并发而生。所以单机承载的并发量都在每秒几万，甚至每秒数十万，对高并发的承载能力比数据库系统要高出一到两个数量级。就是在写数据库的时候同时写一份数据到缓存集群里，然后用缓存集群来承载大部分的读请求。这样的话，通过缓存集群，就可以用更少的机器资源承载更高的并发。

4. 结语

要快速定位和解决慢SQL问题需要对数据库结构和运行机制有足够的了解，在设计数据库时就要考虑到数据量级，创建合适的字段类型和索引，设计合理的表结构可以避免慢SQL

mysql授权ip远程访问

Thu, 12 Mar 2020 01:21:00 GMT

/*授与所有权限给127.0.0.1这个ip 访问，如果不限制ip则填% */ GRANT ALL PRIVILEGES ON *.* TO 'root'@'127.0.0.1'  IDENTIFIED BY 'password' WITH GRANT OPTION;  /*添加权限:赋予username所有的db_name的数据库权限*/ GRANT ALL PRIVILEGES ON db_name.* TO 'username'@'%' WITH GRANT OPTION;

/*刷新权限*/ flush privileges;

mysql配置

Mon, 24 Feb 2020 09:15:00 GMT

解决Linux中mysql中文问号乱码

#[mysqld] character-set-server=utf8 init_connect='SET NAMES utf8'  [mysql] default-character-set=utf8  service mysqld restart;  show variables like 'character_set%';

解决mysql默认8小时断开

在mysql的my.ini最后加上  # this is myown dinifition for mysql connection timeout wait_timeout=31536000 interactive_timeout=31536000

Linux 安装 maven

Fri, 21 Feb 2020 02:30:00 GMT

下载maven包

cd ~  wget https://file.xlz168.cn/download/apache-maven-3.6.3.tar.gz  wget http://mirrors.hust.edu.cn/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz

解压 & 移动

mkdir /home/software tar -zxvf apache-maven-3.6.3-bin.tar.gz mv apache-maven-3.6.3 /home/software

配置环境变量

vim /etc/profile  #mvn export MVN_HOME=/home/software/apache-maven-3.6.3 export PATH=$MVN_HOME/bin:$PATH  source /etc/profile

验证

mvn -version

以上

CentOS 7 安装 Jenkins

Sun, 16 Feb 2020 03:06:00 GMT

原文：https://www.cnblogs.com/fangts/p/11095316.html

准备工作

首选需要安装JAVA环境 https://www.cnblogs.com/stulzq/p/9286878.html

如果你的系统没有自带git，那么也需要安装一个

yum install git

1.安装

第一种方法

sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key yum install jenkins

第二种方法

直接下载 rpm 安装

各个版本地址 https://pkg.jenkins.io/

wget https://pkg.jenkins.io/redhat/jenkins-2.156-1.1.noarch.rpm rpm -ivh jenkins-2.156-1.1.noarch.rpm

2.配置

vim /etc/sysconfig/jenkins  #监听端口 JENKINS_PORT="8080"

3.配置权限

为了不因为权限出现各种问题，这里直接使用root

修改用户为root

vim /etc/sysconfig/jenkins  #修改配置 $JENKINS_USER="root"

修改目录权限

chown -R root:root /var/lib/jenkins chown -R root:root /var/cache/jenkins chown -R root:root /var/log/jenkins

重启

service jenkins restart ps -ef | grep jenkins

4.启动

systemctl start jenkins

我这里启动失败了：

错误信息为Starting Jenkins bash: /usr/bin/java: No such file or directory是java环境配置的问题。

找到你的jdk目录，我是在 usr/local/java/jdk1.8.0_171/下，创建软链接即可：

ln -s /usr/local/java/jdk1.8.0_171/bin/java /usr/bin/java

然后重新启动

5.安装

访问jenkins地址 http:<ip或者域名>:8080

执行命令查看密码：

cat /var/lib/jenkins/secrets/initialAdminPassword

插件安装选择推荐插件

安装进行中

插件安装完成以后将会创建管理员账户

安装完成：

设置Jenkins，安装插件：Pipeline Maven Integration、Maven Integration、Publish Over SSH、Gitee

系统设置，配置远程应用服务器

全局工具配置，分别设置maven、jdk、git

创建构建任务

输入一个名字，例如我输入：helloPudding

进入配置页面，配置源代码

分两步操作

第一步清理服务器环境和第二步启动服务

配置maven打包命令，并跳过单元测试。

执行构建任务

发布jar到公共仓库时遇到问题

Wed, 30 Oct 2019 07:42:00 GMT

gpg 搜索不到public key

failureMessage No public key: Key with id: (1fcda02dd63733fe) was not ableto be located on http://pgp.mit.edu:11371/. Uploadyour public key and try the operation again.

gpg --keyserver http://pool.sks-keyservers.net:11371 --send-keys A81CC45E gpg --keyserver http://pgp.mit.edu:11371 --send-keys A81CC45E gpg --keyserver http://keyserver.ubuntu.com:11371 --send-keys A81CC45E  # 如果不行就将http换为hkp

java doc 去掉docLint校验

<plugin>                 <groupId>org.apache.maven.plugins</groupId>                 <artifactId>maven-javadoc-plugin</artifactId>                 <version>2.9.1</version>                 <executions>                     <execution>                         <id>attach-javadocs</id>                         <goals>                             <goal>jar</goal>                         </goals>                         <configuration>                             <additionalparam>-Xdoclint:none</additionalparam>                         </configuration>                     </execution>                 </executions>             </plugin>

参考文章：https://blog.csdn.net/qqhjqs/article/details/80963875

centos7 中文乱码解决方法

Tue, 20 Aug 2019 09:28:00 GMT

1.查看安装中文包：查看系统是否安装中文语言包（列出所有可用的公共语言环境的名称，包含有zh_CN）

locale -a |grep "zh_CN"

没有输出，说明没有安装，输入下面的命令安装：

yum groupinstall "fonts" -y

安装完成，查看安了哪些中文语言包

locale -a |grep "zh_CN"

zh_CN zh_CN.gb18030 zh_CN.gb2312 zh_CN.gbk zh_CN.utf8

显示问题

LC_CTYPE：用于字符分类和字符串处理，控制所有字符的处理方式，包括字符编码，字符是单字节还是多字节，如何打印等。是最重要的一个环境变量。

~/.bashrc 中添加 export LC_CTYPE='zh_CN.UTF-8'

cron 表达式示例

Fri, 16 Aug 2019 12:55:00 GMT

 每隔5秒执行一次：*/5 * * * * ?   每隔1分钟执行一次：0 */1 * * * ?   每天23点执行一次：0 0 23 * * ?   每天凌晨1点执行一次：0 0 1 * * ?   每月1号凌晨1点执行一次：0 0 1 1 * ?   每月最后一天23点执行一次：0 0 23 L * ?   每周星期天凌晨1点实行一次：0 0 1 ? * L   在26分、29分、33分执行一次：0 26,29,33 * * * ?   每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

Java中InputStream和String之间的转换方法

Mon, 12 Aug 2019 08:54:00 GMT

详见 https://blog.csdn.net/lmy86263/article/details/60479350

ssh-keygen 生成rsa密钥

Sun, 11 Aug 2019 07:23:00 GMT

全局配置

git config --global user.name "Clive Yuan" git config --global user.email "xxxx@foxmail.com"

创建公钥的目的：使用SSH公钥可以让你在你的电脑和码云通讯的时候使用安全连接（git的remote要使用SSH地址）

打开终端进入.ssh目录

cd ~/.ssh

如果.ssh文件夹不存在，执行指令自动创建

mkdir ~/.ssh

生成RSA密钥对

ssh-keygen -t rsa -C "你的邮箱@xxx.com"

为了方便全程回车即可（不用输入ras文件名及密码）

查看公钥内容

cat ~/.ssh/id_rsa.pub

将公钥内容复制并粘贴（注意：公钥内容以ssh-rsa开头，你的邮箱结尾）

粘贴地址 http://git.oschina.net/profile/sshkeys

添加公钥完成后进行测试公钥

测试SSH链接

ssh -T git@git.oschina.net

当终端提示welcome to Git@OSC ... 表示链接成功

至此以后只要拷贝ssh链接地址，然后利用git指令即可进行相关操作！

祝你成功！

mysql高版本驱动日期时区不正确

Tue, 09 Jul 2019 02:14:00 GMT

在高版本的mysql驱动中，数据库中的时间为正确的，但是查出来的时间与当前时间不匹配，相差了几个时区

解决方法：数据库连接中添加 serverTimezone=Asia/Shanghai

MBG(MyBatis Generator) 生成字段添加反引号(`)

Tue, 25 Jun 2019 09:03:00 GMT

数据库字段中有mysql关键字时，采用添加反引号的方法解决；是引用MBG时，参考如下配置：

 <context id="DB2Tables" targetRuntime="MyBatis3">         <property name="javaFileEncoding" value="UTF-8"/>         <property name="autoDelimitKeywords" value="true"/>         <property name="beginningDelimiter" value="`"/>         <property name="endingDelimiter" value="`"/>         <!-- other code ... -->         </context>

如果没生效，试下table标签中添加delimitIdentifiers="true" 默认是只有关键字的字段才加反引号，如果需要所有字段都加的话，在table标签中添加delimitAllColumns="true"属性

BTW:当时是因为其他子项目没编译通过，临时关闭了运行前编译，所以当时改了一通都没起作用。。。。

springboot 上传文件，MultipartFile为null

Tue, 25 Jun 2019 08:59:00 GMT

排除MultipartAutoConfiguration

@SpringBootApplication (exclude = {MultipartAutoConfiguration.class})

添加MultipartResolver

//显示声明CommonsMultipartResolver为mutipartResolver     @Bean(name = "multipartResolver")     public MultipartResolver multipartResolver() {         CommonsMultipartResolver resolver = new CommonsMultipartResolver();         resolver.setDefaultEncoding("UTF-8");         //resolveLazily属性启用是为了推迟文件解析，以在在UploadAction中捕获文件大小异常         resolver.setResolveLazily(true);         resolver.setMaxInMemorySize(40960);         //上传文件大小 5M 5*1024*1024         resolver.setMaxUploadSize(5 * 1024 * 1024);         return resolver;     }

添加@RequestParam

@PostMapping("/upload")     public ApiResponse upload(@RequestParam("file") MultipartFile multipartFile) {      // other code ...     }

centos7安装Nginx

Sat, 22 Jun 2019 15:57:00 GMT

安装所需环境

Nginx 是 C语言开发，建议在 Linux 上运行，当然，也可以安装 Windows 版本，本篇则使用 CentOS 7 作为安装环境。

一. gcc 安装
安装 nginx 需要先将官网下载的源码进行编译，编译依赖 gcc 环境，如果没有 gcc 环境，则需要安装：

yum install gcc-c++

二. PCRE pcre-devel 安装
PCRE(Perl Compatible Regular Expressions) 是一个Perl库，包括 perl 兼容的正则表达式库。nginx 的 http 模块使用 pcre 来解析正则表达式，所以需要在 linux 上安装 pcre 库，pcre-devel 是使用 pcre 开发的一个二次开发库。nginx也需要此库。命令：

yum install -y pcre pcre-devel

三. zlib 安装
zlib 库提供了很多种压缩和解压缩的方式， nginx 使用 zlib 对 http 包的内容进行 gzip ，所以需要在 Centos 上安装 zlib 库。

yum install -y zlib zlib-devel

四. OpenSSL 安装
OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及 SSL 协议，并提供丰富的应用程序供测试或其它目的使用。
nginx 不仅支持 http 协议，还支持 https（即在ssl协议上传输http），所以需要在 Centos 安装 OpenSSL 库。

yum install -y openssl openssl-devel

官网下载

1.直接下载.tar.gz安装包，地址：https://nginx.org/en/download.html

2.使用wget命令下载（推荐）。

wget -c https://nginx.org/download/nginx-1.10.1.tar.gz

我下载的是1.10.1版本，这个是目前的稳定版。

解压

依然是直接命令：

tar -zxvf nginx-1.10.1.tar.gz cd nginx-1.10.1

配置

其实在 nginx-1.10.1 版本中你就不需要去配置相关东西，默认就可以了。当然，如果你要自己配置目录也是可以的。
1.使用默认配置

./configure

2.自定义配置（不推荐）

./configure \ --prefix=/usr/local/nginx \ --conf-path=/usr/local/nginx/conf/nginx.conf \ --pid-path=/usr/local/nginx/conf/nginx.pid \ --lock-path=/var/lock/nginx.lock \ --error-log-path=/var/log/nginx/error.log \ --http-log-path=/var/log/nginx/access.log \ --with-http_gzip_static_module \ --http-client-body-temp-path=/var/temp/nginx/client \ --http-proxy-temp-path=/var/temp/nginx/proxy \ --http-fastcgi-temp-path=/var/temp/nginx/fastcgi \ --http-uwsgi-temp-path=/var/temp/nginx/uwsgi \ --http-scgi-temp-path=/var/temp/nginx/scgi

注：将临时文件目录指定为/var/temp/nginx，需要在/var下创建temp及nginx目录

编译安装

make make install

查找安装路径：

whereis nginx

启动、停止nginx

cd /usr/local/nginx/sbin/ ./nginx  ./nginx -s stop ./nginx -s quit ./nginx -s reload

./nginx -s quit:此方式停止步骤是待nginx进程处理任务完毕进行停止。
./nginx -s stop:此方式相当于先查出nginx进程id再使用kill命令强制杀掉进程。

查询nginx进程：

ps aux|grep nginx

重启 nginx

1.先停止再启动（推荐）：
对 nginx 进行重启相当于先停止再启动，即先执行停止命令再执行启动命令。如下：

./nginx -s quit ./nginx

2.重新加载配置文件：
当 ngin x的配置文件 nginx.conf 修改后，要想让配置生效需要重启 nginx，使用-s reload不用先停止 ngin x再启动 nginx 即可将配置信息在 nginx 中生效，如下：
./nginx -s reload

启动成功后，在浏览器可以看到这样的页面：

设置nginx全局变量

vi /etc/profile

export NGINX_HOME=/usr/local/nginx export PATH=$NGINX_HOME/sbin:$PATH

开机自启动

即在rc.local增加启动代码就可以了。

vi /etc/rc.local

增加一行 /usr/local/nginx/sbin/nginx
设置执行权限：

chmod 755 rc.local

到这里，nginx就安装完毕了，启动、停止、重启操作也都完成了，当然，你也可以添加为系统服务，我这里就不在演示了。

CentOS7下安装mysql5.7

Sat, 22 Jun 2019 15:53:00 GMT

1、安装YUM Repo

由于CentOS 的yum源中没有mysql，需要到mysql的官网下载yum repo配置文件。

wget https://dev.mysql.com/get/mysql57-community-release-el7-9.noarch.rpm

然后进行repo的安装：

rpm -ivh mysql57-community-release-el7-9.noarch.rpm

执行完成后会在/etc/yum.repos.d/目录下生成两个repo文件mysql-community.repo mysql-community-source.repo

2、安装MySQL

使用yum命令即可完成安装

yum install mysql-server

启动msyql：

systemctl start mysqld #启动MySQL

配置MySQL

获取安装时的临时密码：

grep 'temporary password' /var/log/mysqld.log

倘若没有：

1.删除原来安装过的mysql残留的数据

rm -rf /var/lib/mysql

2.再启动mysql

systemctl start mysqld #启动MySQL

登录：

mysql -u root -p

登录成功后修改密码：

set password=password("yourpassword");

设置安全选项：

mysql_secure_installation

其他设置：

systemctl stop mysqld #关闭MySQL systemctl restart mysqld #重启MySQL systemctl status mysqld #查看MySQL运行状态 systemctl enable mysqld #设置开机启动 systemctl disable mysqld #关闭开机启动

3、其他配置

开启远程控制

MySQL默认是没有开启远程控制的，必须添加远程访问的用户

grant all privileges on 数据库名.表名 to 创建的用户名(root)@"%" identified by "密码"; # 数据库名.表名 如果写成*.*代表授权所有的数据库   flush privileges; #刷新刚才的内容

#如：
grant all privileges on *.* to root@"113.64.243.1" identified by "123456789";

@ 后面是访问mysql的客户端IP地址（或是主机名） % 代表任意的客户端，如果填写 localhost 为本地访问（那此用户就不能远程访问该mysql数据库了）。

同时也可以为现有的用户设置是否具有远程访问权限。

配置默认编码为utf8：

vi /etc/my.cnf #添加 [mysqld] character_set_server=utf8 init_connect='SET NAMES utf8'

其他默认配置文件路径：

配置文件：/etc/my.cnf  日志文件：/var/log//var/log/mysqld.log  服务启动脚本：/usr/lib/systemd/system/mysqld.service  socket文件：/var/run/mysqld/mysqld.pid

PE私钥文件转字符串

Wed, 19 Jun 2019 03:32:00 GMT

openssl pkcs8 -topk8 -inform PEM -in clive.private.pem -outform PEM -nocrypt

maven 使用指南

Wed, 13 Mar 2019 02:16:00 GMT

下载源码

mvn dependency:resolve -Dclassifier=sources

【MAC】命令行终端切换wifi

Wed, 13 Mar 2019 02:14:00 GMT

查看wifi对应设备名

networksetup -listallhardwareports

关闭wifi

networksetup -setairportpower en0 off //en0 设备名

打开wifi

networksetup -setairportpower en0 on

加入wifi

networksetup -setairportnetwork en0 wifi名 wifi密码

tips：企业证书认证的wifi，无法获取密码，不能连接。

JDK环境安装与配置（Windows 10）

Mon, 11 Mar 2019 03:32:00 GMT

1.官网下载地址

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

2.安装

双击jdk-8u171-windows-x64.exe，选择目标安装目录，一般默认安装。

3.配置环境变量

1.新建系统变量：
变量名（N）：JAVA_HOME
变量值（V）：jdk的安装路径

2.新建系统变量：
变量名（N）：CLASSPATH
变量值（V）：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

3.添加修改系统变量：
变量名（N）：Path
变量值（V）：;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

4.验证

运行cmd，输入命令：java -version 和 javac -version

显示如下JDK版本信息即可:
java version "1.8.0_171"
Java(TM) SE Runtime Environment (build 1.8.0_171-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.171-b11, mixed mode)

JDK环境安装与配置（Linux CentOS 7）

Mon, 11 Mar 2019 03:25:00 GMT

本文安装JDK的版本为JDK1.8

更新系统软件

yum update

查找系统已安装的jdk组件

rpm -qa | grep -E '^open[jre|jdk]|j[re|dk]'

查看java版本

java -version

卸载以前已有的jdk

yum remove java-1.6.0-openjdk yum remove java-1.7.0-openjdk

mkdir /usr/java

下载jdk-8u111-linux-x64.tar.gz包，并上传至服务器/usr/java文件夹中。

url: https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html wget xxx.tar.gz

wget https://file.xlz168.cn/download/jdk-8u241-linux-x64.tar.gz

解压jdk-8u111-linux-x64.tar.gz包至/usr/java/jdk1.8.0_111文件夹

tar -xvf jdk-8u241-linux-x64.tar.gz

mv jdk1.8.0_241 /usr/java/

添加到环境变量

编辑/etc/profile文件，在export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL下面添加如下代码：

#jdk export JAVA_HOME=/usr/java/jdk1.8.0_241 export PATH=$JAVA_HOME/bin:$PATH export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

执行命令使配置生效

source /etc/profile

验证，是否安装成功

java -version

VirtualBox中安装CentOS7后无法上网的解决方案

Fri, 08 Mar 2019 07:57:00 GMT

安装了VirtualBox（CentOS7镜像）后无法上网，在网上找到了相应解决方案，所以分享记录下来

1 配置VirtualBox的虚拟网卡

1）打开网络和共享中心，找到VirtualBox Host-Only Network

2) 双击该适配器，点击属性，为网卡配置上IPv4的地址以及子网掩码，如下图所示。因为我的主机使用的是无线网络，所以主机的ip地址是192.168.0.102，子网掩码是255.255.255.0，默认网关、dhcp服务器、dns服务器都是192.168.0.1. 这里VirtualBox虚拟网卡的IP地址设置一个和主机地址同一网段的地址（192.168.0.110，这个地址也是将来虚拟机里网卡的默认网关地址），掩码设置和主机一样，其它的都不设置。

2 配置虚拟机的网卡
1）按照下图配置虚拟机的网络

其中，连接方式选择桥接网卡、界面名称选择你主机上网用的无线网卡、控制芯片选择桌面、混杂模式选择拒绝、勾选接入网络。
2）设置完成后，启动虚拟机
3 配置CentOS7的网络
1）修改网卡对应的配置文件，设置BOOTPROTO为dhcp，ONBOOT为yes
$ vi /etc/sysconfig/network-scripts/ifcfg-enp0s3

2）修改网关，设置NETWORKING为yes，GATEWAY为VirtualBox虚拟网卡的ip地址
$ vi /etc/sysconfig/network

3）修改DNS，设置nameserver为host主机的nameserver
$ vi /etc/resolv.cof

4) 重启网络服务，
$ service network restart
至此，整个配置就结束了，虚拟机也能上网了。

如果还不行的话可以先将防火墙关掉
syetemctl stop firewalld

一键搭建shadowsocks

Wed, 20 Feb 2019 02:27:00 GMT

原文 https://www.flyzy2005.com/fan-qiang/shadowsocks/bandwagonhost-shadowsocks/

github源码地址： https://github.com/flyzy2005/ss-fly

MySQL索引原理及慢查询优化

Tue, 12 Feb 2019 08:25:00 GMT

转自：https://tech.meituan.com/2014/06/30/mysql-index.html

背景

MySQL凭借着出色的性能、低廉的成本、丰富的资源，已经成为绝大多数互联网公司的首选关系型数据库。虽然性能出色，但所谓“好马配好鞍”，如何能够更好的使用它，已经成为开发工程师的必修课，我们经常会从职位描述上看到诸如“精通MySQL”、“SQL语句优化”、“了解数据库原理”等要求。我们知道一般的应用系统，读写比例在10:1左右，而且插入操作和一般的更新操作很少出现性能问题，遇到最多的，也是最容易出问题的，还是一些复杂的查询操作，所以查询语句的优化显然是重中之重。

本人从13年7月份起，一直在美团核心业务系统部做慢查询的优化工作，共计十余个系统，累计解决和积累了上百个慢查询案例。随着业务的复杂性提升，遇到的问题千奇百怪，五花八门，匪夷所思。本文旨在以开发工程师的角度来解释数据库索引的原理和如何优化慢查询。

select    count(*)  from    task  where    status=2     and operator_id=20839     and operate_time>1371169729     and operate_time<1371174603     and type=2;

系统使用者反应有一个功能越来越慢，于是工程师找到了上面的SQL。

并且兴致冲冲的找到了我，“这个SQL需要优化，给我把每个字段都加上索引”。

我很惊讶，问道：“为什么需要每个字段都加上索引？”

“把查询的字段都加上索引会更快”，工程师信心满满。

“这种情况完全可以建一个联合索引，因为是最左前缀匹配，所以operate_time需要放到最后，而且还需要把其他相关的查询都拿来，需要做一个综合评估。”

“联合索引？最左前缀匹配？综合评估？”工程师不禁陷入了沉思。

多数情况下，我们知道索引能够提高查询效率，但应该如何建立索引？索引的顺序如何？许多人却只知道大概。其实理解这些概念并不难，而且索引的原理远没有想象的那么复杂。

索引目的

索引的目的在于提高查询效率，可以类比字典，如果要查“mysql”这个单词，我们肯定需要定位到m字母，然后从下往下找到y字母，再找到剩下的sql。如果没有索引，那么你可能需要把所有单词看一遍才能找到你想要的，如果我想找到m开头的单词呢？或者ze开头的单词呢？是不是觉得如果没有索引，这个事情根本无法完成？

索引原理

除了词典，生活中随处可见索引的例子，如火车站的车次表、图书的目录等。它们的原理都是一样的，通过不断的缩小想要获得数据的范围来筛选出最终想要的结果，同时把随机的事件变成顺序的事件，也就是我们总是通过同一种查找方式来锁定数据。

数据库也是一样，但显然要复杂许多，因为不仅面临着等值查询，还有范围查询(>、<、between、in)、模糊查询(like)、并集查询(or)等等。数据库应该选择怎么样的方式来应对所有的问题呢？我们回想字典的例子，能不能把数据分成段，然后分段查询呢？最简单的如果1000条数据，1到100分成第一段，101到200分成第二段，201到300分成第三段……这样查第250条数据，只要找第三段就可以了，一下子去除了90%的无效数据。但如果是1千万的记录呢，分成几段比较好？稍有算法基础的同学会想到搜索树，其平均复杂度是lgN，具有不错的查询性能。但这里我们忽略了一个关键的问题，复杂度模型是基于每次相同的操作成本来考虑的，数据库实现比较复杂，数据保存在磁盘上，而为了提高性能，每次又可以把部分数据读入内存来计算，因为我们知道访问磁盘的成本大概是访问内存的十万倍左右，所以简单的搜索树难以满足复杂的应用场景。

磁盘IO与预读

前面提到了访问磁盘，那么这里先简单介绍一下磁盘IO和预读，磁盘读取数据靠的是机械运动，每次读取数据花费的时间可以分为寻道时间、旋转延迟、传输时间三个部分，寻道时间指的是磁臂移动到指定磁道所需要的时间，主流磁盘一般在5ms以下；旋转延迟就是我们经常听说的磁盘转速，比如一个磁盘7200转，表示每分钟能转7200次，也就是说1秒钟能转120次，旋转延迟就是1/120/2 = 4.17ms；传输时间指的是从磁盘读出或将数据写入磁盘的时间，一般在零点几毫秒，相对于前两个时间可以忽略不计。那么访问一次磁盘的时间，即一次磁盘IO的时间约等于5+4.17 = 9ms左右，听起来还挺不错的，但要知道一台500 -MIPS的机器每秒可以执行5亿条指令，因为指令依靠的是电的性质，换句话说执行一次IO的时间可以执行40万条指令，数据库动辄十万百万乃至千万级数据，每次9毫秒的时间，显然是个灾难。下图是计算机硬件延迟的对比图，供大家参考：

various-system-software-hardware-latencies

考虑到磁盘IO是非常高昂的操作，计算机操作系统做了一些优化，当一次IO时，不光把当前磁盘地址的数据，而是把相邻的数据也都读取到内存缓冲区内，因为局部预读性原理告诉我们，当计算机访问一个地址的数据的时候，与其相邻的数据也会很快被访问到。每一次IO读取的数据我们称之为一页(page)。具体一页有多大数据跟操作系统有关，一般为4k或8k，也就是我们读取一页内的数据时候，实际上才发生了一次IO，这个理论对于索引的数据结构设计非常有帮助。

索引的数据结构

前面讲了生活中索引的例子，索引的基本原理，数据库的复杂性，又讲了操作系统的相关知识，目的就是让大家了解，任何一种数据结构都不是凭空产生的，一定会有它的背景和使用场景，我们现在总结一下，我们需要这种数据结构能够做些什么，其实很简单，那就是：每次查找数据时把磁盘IO次数控制在一个很小的数量级，最好是常数数量级。那么我们就想到如果一个高度可控的多路搜索树是否能满足需求呢？就这样，b+树应运而生。

详解b+树

b+树

如上图，是一颗b+树，关于b+树的定义可以参见B+树，这里只说一些重点，浅蓝色的块我们称之为一个磁盘块，可以看到每个磁盘块包含几个数据项（深蓝色所示）和指针（黄色所示），如磁盘块1包含数据项17和35，包含指针P1、P2、P3，P1表示小于17的磁盘块，P2表示在17和35之间的磁盘块，P3表示大于35的磁盘块。真实的数据存在于叶子节点即3、5、9、10、13、15、28、29、36、60、75、79、90、99。非叶子节点只不存储真实的数据，只存储指引搜索方向的数据项，如17、35并不真实存在于数据表中。

b+树的查找过程

如图所示，如果要查找数据项29，那么首先会把磁盘块1由磁盘加载到内存，此时发生一次IO，在内存中用二分查找确定29在17和35之间，锁定磁盘块1的P2指针，内存时间因为非常短（相比磁盘的IO）可以忽略不计，通过磁盘块1的P2指针的磁盘地址把磁盘块3由磁盘加载到内存，发生第二次IO，29在26和30之间，锁定磁盘块3的P2指针，通过指针加载磁盘块8到内存，发生第三次IO，同时内存中做二分查找找到29，结束查询，总计三次IO。真实的情况是，3层的b+树可以表示上百万的数据，如果上百万的数据查找只需要三次IO，性能提高将是巨大的，如果没有索引，每个数据项都要发生一次IO，那么总共需要百万次的IO，显然成本非常非常高。

b+树性质

1.通过上面的分析，我们知道IO次数取决于b+数的高度h，假设当前数据表的数据为N，每个磁盘块的数据项的数量是m，则有h=㏒(m+1)N，当数据量N一定的情况下，m越大，h越小；而m = 磁盘块的大小 / 数据项的大小，磁盘块的大小也就是一个数据页的大小，是固定的，如果数据项占的空间越小，数据项的数量越多，树的高度越低。这就是为什么每个数据项，即索引字段要尽量的小，比如int占4字节，要比bigint8字节少一半。这也是为什么b+树要求把真实的数据放到叶子节点而不是内层节点，一旦放到内层节点，磁盘块的数据项会大幅度下降，导致树增高。当数据项等于1时将会退化成线性表。

2.当b+树的数据项是复合的数据结构，比如(name,age,sex)的时候，b+数是按照从左到右的顺序来建立搜索树的，比如当(张三,20,F)这样的数据来检索的时候，b+树会优先比较name来确定下一步的所搜方向，如果name相同再依次比较age和sex，最后得到检索的数据；但当(20,F)这样的没有name的数据来的时候，b+树就不知道下一步该查哪个节点，因为建立搜索树的时候name就是第一个比较因子，必须要先根据name来搜索才能知道下一步去哪里查询。比如当(张三,F)这样的数据来检索时，b+树可以用name来指定搜索方向，但下一个字段age的缺失，所以只能把名字等于张三的数据都找到，然后再匹配性别是F的数据了，这个是非常重要的性质，即索引的最左匹配特性。

关于MySQL索引原理是比较枯燥的东西，大家只需要有一个感性的认识，并不需要理解得非常透彻和深入。我们回头来看看一开始我们说的慢查询，了解完索引原理之后，大家是不是有什么想法呢？先总结一下索引的几大基本原则：

建索引的几大原则

1.最左前缀匹配原则，非常重要的原则，mysql会一直向右匹配直到遇到范围查询(>、<、between、like)就停止匹配，比如a = 1 and b = 2 and c > 3 and d = 4 如果建立(a,b,c,d)顺序的索引，d是用不到索引的，如果建立(a,b,d,c)的索引则都可以用到，a,b,d的顺序可以任意调整。 2.=和in可以乱序，比如a = 1 and b = 2 and c = 3 建立(a,b,c)索引可以任意顺序，mysql的查询优化器会帮你优化成索引可以识别的形式。 3.尽量选择区分度高的列作为索引,区分度的公式是count(distinct col)/count(*)，表示字段不重复的比例，比例越大我们扫描的记录数越少，唯一键的区分度是1，而一些状态、性别字段可能在大数据面前区分度就是0，那可能有人会问，这个比例有什么经验值吗？使用场景不同，这个值也很难确定，一般需要join的字段我们都要求是0.1以上，即平均1条扫描10条记录。

4.索引列不能参与计算，保持列“干净”，比如from_unixtime(create_time) = ’2014-05-29’就不能使用到索引，原因很简单，b+树中存的都是数据表中的字段值，但进行检索时，需要把所有元素都应用函数才能比较，显然成本太大。所以语句应该写成create_time = unix_timestamp(’2014-05-29’)。

5.尽量的扩展索引，不要新建索引。比如表中已经有a的索引，现在要加(a,b)的索引，那么只需要修改原来的索引即可。

回到开始的慢查询

根据最左匹配原则，最开始的sql语句的索引应该是status、operator_id、type、operate_time的联合索引；其中status、operator_id、type的顺序可以颠倒，所以我才会说，把这个表的所有相关查询都找到，会综合分析；比如还有如下查询：

select * from task where status = 0 and type = 12 limit 10;

select count(*) from task where status = 0 ;

那么索引建立成(status,type,operator_id,operate_time)就是非常正确的，因为可以覆盖到所有情况。这个就是利用了索引的最左匹配的原则

查询优化神器 - explain命令

关于explain命令相信大家并不陌生，具体用法和字段含义可以参考官网explain-output，这里需要强调rows是核心指标，绝大部分rows小的语句执行一定很快（有例外，下面会讲到）。所以优化语句基本上都是在优化rows。

慢查询优化基本步骤

0.先运行看看是否真的很慢，注意设置SQL_NO_CACHE 1.where条件单表查，锁定最小返回记录表。这句话的意思是把查询语句的where都应用到表中返回的记录数最小的表开始查起，单表每个字段分别查询，看哪个字段的区分度最高 2.explain查看执行计划，是否与1预期一致（从锁定记录较少的表开始查询） 3.order by limit 形式的sql语句让排序的表优先查 4.了解业务方使用场景 5.加索引时参照建索引的几大原则 6.观察结果，不符合预期继续从0分析

几个慢查询案例

下面几个例子详细解释了如何分析和优化慢查询。

复杂语句写法

很多情况下，我们写SQL只是为了实现功能，这只是第一步，不同的语句书写方式对于效率往往有本质的差别，这要求我们对mysql的执行计划和索引原则有非常清楚的认识，请看下面的语句：

select    distinct cert.emp_id  from    cm_log cl  inner join    (       select          emp.id as emp_id,          emp_cert.id as cert_id        from          employee emp        left join          emp_certificate emp_cert              on emp.id = emp_cert.emp_id        where          emp.is_deleted=0    ) cert        on (          cl.ref_table='Employee'           and cl.ref_oid= cert.emp_id       )        or (          cl.ref_table='EmpCertificate'           and cl.ref_oid= cert.cert_id       )  where    cl.last_upd_date >='2013-11-07 15:03:00'     and cl.last_upd_date<='2013-11-08 16:00:00';

0.先运行一下，53条记录 1.87秒，又没有用聚合语句，比较慢

53 rows in set (1.87 sec)

1.explain

+----+-------------+------------+-------+---------------------------------+-----------------------+---------+-------------------+-------+--------------------------------+ | id | select_type | table      | type  | possible_keys                   | key                   | key_len | ref               | rows  | Extra                          | +----+-------------+------------+-------+---------------------------------+-----------------------+---------+-------------------+-------+--------------------------------+ |  1 | PRIMARY     | cl         | range | cm_log_cls_id,idx_last_upd_date | idx_last_upd_date     | 8       | NULL              |   379 | Using where; Using temporary   | |  1 | PRIMARY     | <derived2> | ALL   | NULL                            | NULL                  | NULL    | NULL              | 63727 | Using where; Using join buffer | |  2 | DERIVED     | emp        | ALL   | NULL                            | NULL                  | NULL    | NULL              | 13317 | Using where                    | |  2 | DERIVED     | emp_cert   | ref   | emp_certificate_empid           | emp_certificate_empid | 4       | meituanorg.emp.id |     1 | Using index                    | +----+-------------+------------+-------+---------------------------------+-----------------------+---------+-------------------+-------+--------------------------------+

简述一下执行计划，首先mysql根据idx_last_upd_date索引扫描cm_log表获得379条记录；然后查表扫描了63727条记录，分为两部分，derived表示构造表，也就是不存在的表，可以简单理解成是一个语句形成的结果集，后面的数字表示语句的ID。derived2表示的是ID = 2的查询构造了虚拟表，并且返回了63727条记录。我们再来看看ID = 2的语句究竟做了写什么返回了这么大量的数据，首先全表扫描employee表13317条记录，然后根据索引emp_certificate_empid关联emp_certificate表，rows = 1表示，每个关联都只锁定了一条记录，效率比较高。获得后，再和cm_log的379条记录根据规则关联。从执行过程上可以看出返回了太多的数据，返回的数据绝大部分cm_log都用不到，因为cm_log只锁定了379条记录。

如何优化呢？可以看到我们在运行完后还是要和cm_log做join,那么我们能不能之前和cm_log做join呢？仔细分析语句不难发现，其基本思想是如果cm_log的ref_table是EmpCertificate就关联emp_certificate表，如果ref_table是Employee就关联employee表，我们完全可以拆成两部分，并用union连接起来，注意这里用union，而不用union all是因为原语句有“distinct”来得到唯一的记录，而union恰好具备了这种功能。如果原语句中没有distinct不需要去重，我们就可以直接使用union all了，因为使用union需要去重的动作，会影响SQL性能。

优化过的语句如下：

select    emp.id  from    cm_log cl  inner join    employee emp        on cl.ref_table = 'Employee'        and cl.ref_oid = emp.id   where    cl.last_upd_date >='2013-11-07 15:03:00'     and cl.last_upd_date<='2013-11-08 16:00:00'     and emp.is_deleted = 0   union select    emp.id  from    cm_log cl  inner join    emp_certificate ec        on cl.ref_table = 'EmpCertificate'        and cl.ref_oid = ec.id   inner join    employee emp        on emp.id = ec.emp_id   where    cl.last_upd_date >='2013-11-07 15:03:00'     and cl.last_upd_date<='2013-11-08 16:00:00'     and emp.is_deleted = 0

4.不需要了解业务场景，只需要改造的语句和改造之前的语句保持结果一致

5.现有索引可以满足，不需要建索引

6.用改造后的语句实验一下，只需要10ms 降低了近200倍！

+----+--------------+------------+--------+---------------------------------+-------------------+---------+-----------------------+------+-------------+ | id | select_type  | table      | type   | possible_keys                   | key               | key_len | ref                   | rows | Extra       | +----+--------------+------------+--------+---------------------------------+-------------------+---------+-----------------------+------+-------------+ |  1 | PRIMARY      | cl         | range  | cm_log_cls_id,idx_last_upd_date | idx_last_upd_date | 8       | NULL                  |  379 | Using where | |  1 | PRIMARY      | emp        | eq_ref | PRIMARY                         | PRIMARY           | 4       | meituanorg.cl.ref_oid |    1 | Using where | |  2 | UNION        | cl         | range  | cm_log_cls_id,idx_last_upd_date | idx_last_upd_date | 8       | NULL                  |  379 | Using where | |  2 | UNION        | ec         | eq_ref | PRIMARY,emp_certificate_empid   | PRIMARY           | 4       | meituanorg.cl.ref_oid |    1 |             | |  2 | UNION        | emp        | eq_ref | PRIMARY                         | PRIMARY           | 4       | meituanorg.ec.emp_id  |    1 | Using where | | NULL | UNION RESULT | <union1,2> | ALL    | NULL                            | NULL              | NULL    | NULL                  | NULL |             | +----+--------------+------------+--------+---------------------------------+-------------------+---------+-----------------------+------+-------------+ 53 rows in set (0.01 sec)

明确应用场景

举这个例子的目的在于颠覆我们对列的区分度的认知，一般上我们认为区分度越高的列，越容易锁定更少的记录，但在一些特殊的情况下，这种理论是有局限性的。

select    *  from    stage_poi sp  where    sp.accurate_result=1     and (       sp.sync_status=0        or sp.sync_status=2        or sp.sync_status=4    );

0.先看看运行多长时间,951条数据6.22秒，真的很慢。

951 rows in set (6.22 sec)

1.先explain，rows达到了361万，type = ALL表明是全表扫描。

+----+-------------+-------+------+---------------+------+---------+------+---------+-------------+ | id | select_type | table | type | possible_keys | key  | key_len | ref  | rows    | Extra       | +----+-------------+-------+------+---------------+------+---------+------+---------+-------------+ |  1 | SIMPLE      | sp    | ALL  | NULL          | NULL | NULL    | NULL | 3613155 | Using where | +----+-------------+-------+------+---------------+------+---------+------+---------+-------------+

2.所有字段都应用查询返回记录数，因为是单表查询 0已经做过了951条。

3.让explain的rows 尽量逼近951。

看一下accurate_result = 1的记录数：

select count(),accurate_result from stage_poi  group by accurate_result; +----------+-----------------+ | count() | accurate_result | +----------+-----------------+ |     1023 |              -1 | |  2114655 |               0 | |   972815 |               1 | +----------+-----------------+

我们看到accurate_result这个字段的区分度非常低，整个表只有-1,0,1三个值，加上索引也无法锁定特别少量的数据。

再看一下sync_status字段的情况：

select count(),sync_status from stage_poi  group by sync_status; +----------+-------------+ | count() | sync_status | +----------+-------------+ |     3080 |           0 | |  3085413 |           3 | +----------+-------------+

同样的区分度也很低，根据理论，也不适合建立索引。

问题分析到这，好像得出了这个表无法优化的结论，两个列的区分度都很低，即便加上索引也只能适应这种情况，很难做普遍性的优化，比如当sync_status 0、3分布的很平均，那么锁定记录也是百万级别的。

4.找业务方去沟通，看看使用场景。业务方是这么来使用这个SQL语句的，每隔五分钟会扫描符合条件的数据，处理完成后把sync_status这个字段变成1,五分钟符合条件的记录数并不会太多，1000个左右。了解了业务方的使用场景后，优化这个SQL就变得简单了，因为业务方保证了数据的不平衡，如果加上索引可以过滤掉绝大部分不需要的数据。

5.根据建立索引规则，使用如下语句建立索引

alter table stage_poi add index idx_acc_status(accurate_result,sync_status);

6.观察预期结果,发现只需要200ms，快了30多倍。

952 rows in set (0.20 sec)

我们再来回顾一下分析问题的过程，单表查询相对来说比较好优化，大部分时候只需要把where条件里面的字段依照规则加上索引就好，如果只是这种“无脑”优化的话，显然一些区分度非常低的列，不应该加索引的列也会被加上索引，这样会对插入、更新性能造成严重的影响，同时也有可能影响其它的查询语句。所以我们第4步调差SQL的使用场景非常关键，我们只有知道这个业务场景，才能更好地辅助我们更好的分析和优化查询语句。

无法优化的语句

select c.id, c.name, c.position, c.sex, c.phone, c.office_phone, c.feature_info, c.birthday, c.creator_id, c.is_keyperson, c.giveup_reason, c.status, c.data_source, from_unixtime(c.created_time) as created_time, from_unixtime(c.last_modified) as last_modified, c.last_modified_user_id
 from contact c
 inner join contact_branch cb on  c.id = cb.contact_id
 inner join branch_user bu on  cb.branch_id = bu.branch_id and bu.status in ( 1, 2)
 inner join org_emp_info oei on  oei.data_id = bu.user_id and oei.node_left >= 2875 and oei.node_right <= 10802 and oei.org_category = - 1
 order by c.created_time desc  limit 0 , 10;

还是几个步骤。

0.先看语句运行多长时间，10条记录用了13秒，已经不可忍受。

10 rows in set (13.06 sec)

1.explain

+----+-------------+-------+--------+-------------------------------------+-------------------------+---------+--------------------------+------+----------------------------------------------+ | id | select_type | table | type   | possible_keys                       | key                     | key_len | ref                      | rows | Extra                                        | +----+-------------+-------+--------+-------------------------------------+-------------------------+---------+--------------------------+------+----------------------------------------------+ |  1 | SIMPLE      | oei   | ref    | idx_category_left_right,idx_data_id | idx_category_left_right | 5       | const                    | 8849 | Using where; Using temporary; Using filesort | |  1 | SIMPLE      | bu    | ref    | PRIMARY,idx_userid_status           | idx_userid_status       | 4       | meituancrm.oei.data_id   |   76 | Using where; Using index                     | |  1 | SIMPLE      | cb    | ref    | idx_branch_id,idx_contact_branch_id | idx_branch_id           | 4       | meituancrm.bu.branch_id  |    1 |                                              | |  1 | SIMPLE      | c     | eq_ref | PRIMARY                             | PRIMARY                 | 108     | meituancrm.cb.contact_id |    1 |                                              | +----+-------------+-------+--------+-------------------------------------+-------------------------+---------+--------------------------+------+----------------------------------------------+

从执行计划上看，mysql先查org_emp_info表扫描8849记录，再用索引idx_userid_status关联branch_user表，再用索引idx_branch_id关联contact_branch表，最后主键关联contact表。

rows返回的都非常少，看不到有什么异常情况。我们在看一下语句，发现后面有order by + limit组合，会不会是排序量太大搞的？于是我们简化SQL，去掉后面的order by 和 limit，看看到底用了多少记录来排序。

select count() from contact c
 inner join contact_branch cb on  c.id = cb.contact_id
 inner join branch_user bu on  cb.branch_id = bu.branch_id and bu.status in ( 1, 2)
 inner join org_emp_info oei on  oei.data_id = bu.user_id and oei.node_left >= 2875 and oei.node_right <= 10802 and oei.org_category = - 1
 +----------+ | count() | +----------+ |   778878 | +----------+ 1 row in set (5.19 sec)

发现排序之前居然锁定了778878条记录，如果针对70万的结果集排序，将是灾难性的，怪不得这么慢，那我们能不能换个思路，先根据contact的created_time排序，再来join会不会比较快呢？

于是改造成下面的语句，也可以用straight_join来优化：

select c.id, c.name, c.position, c.sex, c.phone, c.office_phone, c.feature_info, c.birthday, c.creator_id, c.is_keyperson, c.giveup_reason, c.status, c.data_source, from_unixtime(c.created_time) as created_time, from_unixtime(c.last_modified) as last_modified, c.last_modified_user_id
from contact c
where exists ( select 1 from contact_branch cb
inner join branch_user bu
on cb.branch_id = bu.branch_id
and bu.status in ( 1, 2)
inner join org_emp_info oei
on oei.data_id = bu.user_id
and oei.node_left >= 2875
and oei.node_right <= 10802
and oei.org_category = - 1
where c.id = cb.contact_id
)
order by c.created_time desc limit 0 , 10;

验证一下效果 预计在1ms内，提升了13000多倍！
 <span class="hljs-number" style="color: rgb(165, 194, 97);">10</span> rows <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">in</span> <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">set</span> (<span class="hljs-number" style="color: rgb(165, 194, 97);">0.00</span> sec) </code></pre><p style="margin-bottom: 1rem; padding: 0px; font-size: 1.5rem; line-height: 1.75; color: rgb(51, 51, 51); font-family: &quot;PingFang SC&quot;, &quot;Lantinghei SC&quot;, &quot;Microsoft Yahei&quot;, &quot;Hiragino Sans GB&quot;, &quot;Microsoft Sans Serif&quot;, &quot;WenQuanYi Micro Hei&quot;, sans-serif; background-color: rgb(253, 253, 253);">本以为至此大工告成，但我们在前面的分析中漏了一个细节，先排序再join和先join再排序理论上开销是一样的，为何提升这么多是因为有一个limit！大致执行过程是：mysql先按索引排序得到前10条记录，然后再去join过滤，当发现不够10条的时候，再次去10条，再次join，这显然在内层join过滤的数据非常多的时候，将是灾难的，极端情况，内层一条数据都找不到，mysql还傻乎乎的每次取10条，几乎遍历了这个数据表！</p><p style="margin-top: 0px; margin-bottom: 1rem; padding: 0px; font-size: 1.5rem; line-height: 1.75; color: rgb(51, 51, 51); font-family: &quot;PingFang SC&quot;, &quot;Lantinghei SC&quot;, &quot;Microsoft Yahei&quot;, &quot;Hiragino Sans GB&quot;, &quot;Microsoft Sans Serif&quot;, &quot;WenQuanYi Micro Hei&quot;, sans-serif; background-color: rgb(253, 253, 253);">用不同参数的SQL试验下：</p><pre style="font-family: Courier, &quot;Courier New&quot;, monospace; font-size: 9px; padding: 0px; margin-bottom: 1rem; line-height: 1.42857; background: rgb(238, 238, 238); border-color: rgb(238, 238, 238);"><code class="language-sql hljs" style="font-family: Courier, &quot;Courier New&quot;, monospace; color: rgb(230, 225, 220); background-image: initial; background-color: rgb(35, 35, 35); padding: 0.5em; margin: 0px; white-space: pre-wrap; display: block; overflow-x: auto;"><span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">select</span>    sql_no_cache   c.id,    c.name,    c.position,    c.sex,    c.phone,    c.office_phone,    c.feature_info,    c.birthday,    c.creator_id,    c.is_keyperson,    c.giveup_reason,    c.status,    c.data_source,    from_unixtime(c.created_time) <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">as</span> created_time,    from_unixtime(c.last_modified) <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">as</span> last_modified,    c.last_modified_user_id     <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">from</span>    contact c    <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">where</span>    <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">exists</span> (       <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">select</span>          <span class="hljs-number" style="color: rgb(165, 194, 97);">1</span>               <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">from</span>          contact_branch cb                <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">inner</span> <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">join</span>          branch_user bu                                  <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">on</span>  cb.branch_id = bu.branch_id                                  <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">and</span> bu.status <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">in</span> (                <span class="hljs-number" style="color: rgb(165, 194, 97);">1</span>,             <span class="hljs-number" style="color: rgb(165, 194, 97);">2</span>)                          <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">inner</span> <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">join</span>             org_emp_info oei                                           <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">on</span>  oei.data_id = bu.user_id                                           <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">and</span> oei.node_left &gt;= <span class="hljs-number" style="color: rgb(165, 194, 97);">2875</span>                                           <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">and</span> oei.node_right &lt;= <span class="hljs-number" style="color: rgb(165, 194, 97);">2875</span>                                           <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">and</span> oei.org_category = - <span class="hljs-number" style="color: rgb(165, 194, 97);">1</span>                          <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">where</span>             c.id = cb.contact_id                  )            <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">order</span> <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">by</span>       c.created_time <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">desc</span>  <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">limit</span> <span class="hljs-number" style="color: rgb(165, 194, 97);">0</span> ,       <span class="hljs-number" style="color: rgb(165, 194, 97);">10</span>; Empty <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">set</span> (<span class="hljs-number" style="color: rgb(165, 194, 97);">2</span> <span class="hljs-keyword" style="font-weight: 700; color: rgb(194, 98, 48);">min</span> <span class="hljs-number" style="color: rgb(165, 194, 97);">18.99</span> sec) </code></pre><p style="margin-bottom: 1rem; padding: 0px; font-size: 1.5rem; line-height: 1.75; color: rgb(51, 51, 51); font-family: &quot;PingFang SC&quot;, &quot;Lantinghei SC&quot;, &quot;Microsoft Yahei&quot;, &quot;Hiragino Sans GB&quot;, &quot;Microsoft Sans Serif&quot;, &quot;WenQuanYi Micro Hei&quot;, sans-serif; background-color: rgb(253, 253, 253);">2 min 18.99 sec！比之前的情况还糟糕很多。由于mysql的nested loop机制，遇到这种情况，基本是无法优化的。这条语句最终也只能交给应用系统去优化自己的逻辑了。 通过这个例子我们可以看到，并不是所有语句都能优化，而往往我们优化时，由于SQL用例回归时落掉一些极端情况，会造成比原来还严重的后果。所以，第一：不要指望所有语句都能通过SQL优化，第二：不要过于自信，只针对具体case来优化，而忽略了更复杂的情况。</p><p style="margin-top: 0px; margin-bottom: 1rem; padding: 0px; font-size: 1.5rem; line-height: 1.75; color: rgb(51, 51, 51); font-family: &quot;PingFang SC&quot;, &quot;Lantinghei SC&quot;, &quot;Microsoft Yahei&quot;, &quot;Hiragino Sans GB&quot;, &quot;Microsoft Sans Serif&quot;, &quot;WenQuanYi Micro Hei&quot;, sans-serif; background-color: rgb(253, 253, 253);">慢查询的案例就分析到这儿，以上只是一些比较典型的案例。我们在优化过程中遇到过超过1000行，涉及到16个表join的“垃圾SQL”，也遇到过线上线下数据库差异导致应用直接被慢查询拖死，也遇到过varchar等值比较没有写单引号，还遇到过笛卡尔积查询直接把从库搞死。再多的案例其实也只是一些经验的积累，如果我们熟悉查询优化器、索引的内部原理，那么分析这些案例就变得特别简单了。</p><p style="margin-top: 0px; margin-bottom: 1rem; padding: 0px; font-size: 1.5rem; line-height: 1.75; color: rgb(51, 51, 51); font-family: &quot;PingFang SC&quot;, &quot;Lantinghei SC&quot;, &quot;Microsoft Yahei&quot;, &quot;Hiragino Sans GB&quot;, &quot;Microsoft Sans Serif&quot;, &quot;WenQuanYi Micro Hei&quot;, sans-serif; background-color: rgb(253, 253, 253);">本文以一个慢查询案例引入了MySQL索引原理、优化慢查询的一些方法论;并针对遇到的典型案例做了详细的分析。其实做了这么长时间的语句优化后才发现，任何数据库层面的优化都抵不上应用系统的优化，同样是MySQL，可以用来支撑Google/FaceBook/Taobao应用，但可能连你的个人网站都撑不住。套用最近比较流行的话：“查询容易，优化不易，且写且珍惜！”</p>



设计模式学习总结
Wed, 23 Jan 2019 05:26:00 GMT

设计模式
特点
总结
代理模式
1. 两个参与角色：代理人、被代理人
2.对于代理人来说这件事一定要做，但是自己又不想做或者没时间做，找代理
3.代理人必须获取被代理人的个人资料（持有被代理人的引用） 办事要求人，所以找代理







动态代理
Tue, 22 Jan 2019 16:37:00 GMT
jdk动态代理
 针对接口进行代理，代理者实现InvokeHandler
 cglib动态代理
 针对类进行代理，代理者实现MethodIntecptor


spring学习总结
Tue, 22 Jan 2019 15:41:00 GMT
spring是什么
 spring是一个简化企业应用开发复杂性的轻量级开源框架
 spring优点
 方便解耦，简化开发 支持AOP编程 易于集成
 spring原理
 IoC/DI: java反射机制 AOP：java动态代理、cglib代理
 spring 思想
 AOP: 解耦，专人做专事 BOP：面向Bean编程，一切从Bean开始 OOP：封装、继承、多态 IOC：控制权反转 DI/DL：先理清关系再赋值


Interface与abstract类的区别
Mon, 07 Jan 2019 02:45:00 GMT
Java中，抽象类和接口有相似的地方。下面我们就来细说说接口和抽象类的异同。
相同之处：
 1. 接口和抽象类都能定义方法和属性。
2. 接口和抽象类都是看作是一种特殊的类。大部分的时候，定义的方法要子类来实现
3. 抽象类和接口都可以不含有抽象方法。接口没有方法就可以作为一个标志。比如可序列化的接口Serializable，没有方法的接口称为空接口。没有抽象方法的抽象类，小编不知道有什么作用，总之是可以通过编译的。
4. 抽象类和接口都不能创建对象。
5. 抽象类和接口都能利用多态性原理来使用抽象类引用指向子类对象。
6. 继承和实现接口或抽象类的子类必须实现接口或抽象类的所有的方法，抽象类若有没有实现的方法就继续作为抽象类，要加abstract修饰。若接口的子类没有实现的方法，也要变为抽象类。
不同之处：
1. 接口能够多实现，而抽象类只能单独被继承，其本质就是，一个类能继承多个接口，而只能继承一个抽象类。
2. 方法上，抽象类的方法可以用abstract 和public或者protect修饰。而接口默认为public abttact 修饰。
3. 抽象类的方法可以有需要子类实现的抽象方法，也可以有具体的方法。而接口在老版本的jdk中，只能有抽象方法，但是Java8版本的接口中，接口可以带有默认方法。
4. 属性上，抽象类可以用各种各样的修饰符修饰。而接口的属性是默认的public static final
5. 抽象类中可以含有静态代码块和静态方法，而接口不能含有静态方法和静态代码块。
6. 抽象类可以含有构造方法，接口不能含有构造方法。
7. 设计层面上，抽象类表示的是子类“是不是”属于某一类的子类，接口则表示“有没有”特性“能不能”做这种事。如飞机和鸟都能飞，但是他们在设计上实现一个Fly接口，实现fly()方法。远比两个类继承飞行物抽象类好得多。因为，飞机和鸟有太多的属性不一样。
8. 设计层面上，另外一点，抽象类可以是一个模板，因为可以自己带集体方法，所以要加一个实现类都能有的方法，直接在抽象类中写出并实现就好，接口在以前的版本则不行。新版本Java8才有默认方法。
9. 既然说到Java 8 那么就来说明，Java8中的接口中的默认方法是可以被多重继承的。而抽象类不行。
10. 另外，接口只能继承接口。而抽象类可以继承普通的类，也能继承接口和抽象类。


Java 配置环境变量
Thu, 03 Jan 2019 14:35:00 GMT

(1)新建->变量名"JAVA_HOME"，变量值"C:\Java\${jdk_path}"（即JDK的安装路径） 
(2)编辑->变量名"Path"，在原变量值的最后面加上“;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin” 
(3)新建->变量名“CLASSPATH”,变量值“.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar”





MyBatis使用中遇到过的坎
Thu, 27 Dec 2018 06:11:00 GMT
 使用枚举进行if判断时不能直接使用枚举本身,而是要用xx.name()来获取枚举本身字符串;
 使用if判断的并且和或要小写and,or (大写的不能被识别)
 


Mac下移动硬盘的使用
Wed, 19 Dec 2018 13:29:00 GMT
转自:https://blog.csdn.net/u014443884/article/details/78687490
 
  ntfs的移动硬盘默认可以识别但是以only read的方式挂载的，需要读写的时候肯能无法使用 mac自带的mount_ntfs就可以挂载移动硬盘，默认挂载的时候ntfs的硬盘是只读的，所以这个时候需要先umount掉，然后再使用mount_ntfs命令以读写的方式挂载
 
 
 1.首先查看本地已经挂载的ntfs硬盘：
 mount | grep ntfs  
 结果如下：
 clive@cliveyuans-MacBook-Pro:~$ mount | grep ntfs  /dev/disk0s3 on /Volumes/BOOTCAMP (ntfs, local, read-only, noowners) /dev/disk3s1 on /Volumes/系统保留 (ntfs, local, nodev, nosuid, read-only, noowners) /dev/disk3s2 on /Volumes/clive-2 (ntfs, local, nodev, nosuid, read-only, noowners) 
 2.然后卸载该硬盘：
 umount /dev/disk3s2 
 3.本地创建一个挂载目录，然后使用mount_ntfs再次挂载：
 mkdir mnt mount_ntfs -o rw,nobrowse /dev/disk3s2  mnt 
 如果上述方法没用, 那么可以下载这个软件试试  NTFS For Mac


分布式锁的几种实现方式
Wed, 05 Dec 2018 03:29:00 GMT
转自:
 http://www.cnblogs.com/austinspark-jessylu/p/8043726.html


第一篇文章
Thu, 23 Feb 2017 14:46:24 GMT
Hello  World.
  第一篇文章总得写点儿什么?...
 
 
 public static void main(String[] args){     System.out.println(\"Hello Tale.\"); }

Clive Blog

JAVA基础

1.为什么说 Java 语言“编译与解释并存”？

2.AOT 有什么优点？为什么不全部使用 AOT 呢？

3.基本数据类型大小

4.字符型常量和字符串常量的区别?

5.对象的相等和引用相等的区别

6.深拷贝 vs 浅拷贝vs引用拷贝

7.Object 类的常见方法有哪些？

8.Java 序列化中如果有些字段不想进行序列化，怎么办？

9.string 的底层实现由 char[] 改成了 byte[] ?

10.字符串常量池的作用了解吗？

11.字符型常量和字符串常量的区别?

12.String#intern 方法有什么作用?

13.Exception 和 Error 有什么区别？

Checked Exception 和 Unchecked Exception 有什么区别？

14.finally 中的代码一定会执行吗？

15.泛型

16.SPI机制

SPI 的优缺点？

17.序列号&反序列化

（1）serialVersionUID

（2）如果有些字段不想进行序列化怎么办？

18.IO流

1.I/O 流为什么要分为字节流和字符流呢?

19.java的Unsafe类

20.创建对象的三个步骤

21.成员变量与局部变量的区别有哪些？

22.面向对象和面向过程的区别

23.==和 equals 的区别

24、为什么 Java 中只有值传递？

【转】解决Jenkins用shell脚本部署后，jar包启动失败的问题

2023届·1024闯关赢大奖-攻略

SpringBoot中使用策略模式优雅干掉if-else

前言

代码

代码清单

枚举类TypeEnum.java

接口请求入参类ReceiptReq.java

接口类ReceiptHandleStrategy.java

默认接口实现类DefaultReceiptHandleStrategy.java

MT1101类型对应的接口实现类MT1101ReceiptHandleStrategy.java

MT2101类型对应的接口实现类Mt2101ReceiptHandleStrategy.java

测试类ReceiptStrategyTest.java

基础测试类BaseTest.java

测试结果

扩展性

结语

【转】一文教你搞定所有前端鉴权与后端鉴权方案，让你不再迷惘

前言

通过这篇文章你将学到什么？

什么是认证？

什么是授权？

什么是鉴权？

什么是权限控制？

认证、授权、鉴权和权限控制的关系？

1. HTTP 基本鉴权

1.2 认证步骤解析

1.3 优点

1.4 缺点

1.5 使用场景

2. Session-Cookie 鉴权

2.1 什么是 Cookie

2.2 什么是 Session

2.3 Session-Cookie 的认证流程图

2.4 Session-Cookie 认证步骤解析

2.5 Session-Cookie 的优点

2.6 Session-Cookie 的缺点

2.7 使用场景

2.8 前端常用的 Session 库推荐

3. Token 鉴权

3.1 什么是 Token（令牌）

3.2 什么是 Refresh Token（刷新 Token）

3.3 Token 和 Session-Cookie 的区别

4. JWT（JSON Web Token）鉴权

4.1 什么是 JWT

4.2 JWT 的组成

4.3 JWT 的使用方式

4.4 JWT 的认证流程图

4.5 JWT 的优点

9.s`tring` 的底层实现由 `char[]` 改成了 `byte[]` ?

（1）`serialVersionUID`

枚举类`TypeEnum.java`

接口请求入参类`ReceiptReq.java`

接口类`ReceiptHandleStrategy.java`

默认接口实现类`DefaultReceiptHandleStrategy.java`

MT1101类型对应的接口实现类`MT1101ReceiptHandleStrategy.java`

MT2101类型对应的接口实现类`Mt2101ReceiptHandleStrategy.java`

测试类`ReceiptStrategyTest.java`

基础测试类`BaseTest.java`