2021.7.5学习

2021.7.5学习

一点点来吧

sql：一半了。

java面试题：io，并发，多线程，jvm，jdk 8 新特性 stream

springcloud netflix：Eureka，

深入理解java虚拟机：

算法：

项目练习：

kafka：要提上日程了

redis：redis还没学完啊，疯了

springboot快速构建微服务，springcloud 来管理微服务

7.5 mysql

1，mysql 中 insert 插入方式有哪几种

1,普通插入语句

2，插入或者更新

3，插入或者替换

4，插入或者忽略

1，普通插入语句

基本语法：

insert into table_name (key) values (value)

2,插入或者更新

如果我们希望插入一条新纪录，但是如果记录已经存在，就该更新记录，此时就可以使用

insert into table_name (key) values (value)
on deplicate key update ....

基本语法：

insert into table_name (key) values (value)
on deplicate key update ....

情景示例：

一张表存了用户的历史充值金额，如果是第一次充值就新增一条记录；如果用户充值过，就累加历史充值金额，需要保证单个用户数据不重复录入；

注意事项：insert into …. on duplicate key update.....,是基于唯一索引或者主键来判断唯一（是否存在）的，

如果不存在就插入，如果存在就跟跟新

另外： insert into …. on duplicate key update..... 是mysql 特有的语法

3，插入或者替换

如果我们想插入一条新数据，但是这个记录已经存在，就先删除原有记录，再插入新记录

情景示例：一张表存的每个客户最近一次交易订单信息，要求保证单个用户数据不重复记录，且执行效率最高与数据库交互最少，支撑数据库的高可用。

基本语法：

replace into

使用replace into 语句	，这样就不必先查询，在决定是否删除再插入

注意： insert into 语句是基于唯一索引或者主键来判断唯一（是否存在）的，

小tips ：

on duplicate key updae：如果插入行时出现唯一索引或者主键重复时，则执行旧的updae（这个所谓的旧的update 是啥）；如果不会导致唯一索引或者主键重复时，就直接添加新的行。

replace into：如果插入行时出现唯一索引或者主键重复时，则delete 老记录，而录入新记录；如果不会导致唯一索引或者主键重复时，就直接添加新的行。

replace into 与 insert on deplicate update 比较：

• 1，在没有主键或者唯一索引重复时，replace into 与 insert on deplicate update 相同。
• 2，在主键或者唯一索引重复时，replace 是 delete 老记录，而录入新的记录，所以原有的记录会被清楚，这个时候如果 replace 语句的字段不全的话，有些原有的字段的值会被自动填充默认值（如 null）
• 3，insert on deplicate update 只是影响一行，而 replace into可能影响多行。

replace into 影响多行的原因是在一个表中有超过一个的唯一索引。在这种情况下， replace into 将考虑每一个唯一索引，并对每一个索引对应的重复记录删除，然后插入这条新记录。

replace into 语法回顾：如果插入行出现唯一索引或者主键重复时，则delete老记录，而录入新记录；如果不会导致唯一索引或者主键重复时，就直接添加新行。

**最后：**replace into 对每个唯一索引都会有影响，可能会造成误删数据的情况，因此建议不要在多唯一索引的表中使用 replace into

4，插入或者忽略

如果我们希望插入一条新记录时，但是如果记录已经存在，就啥事也不干直接忽略，此时，可以使用 insert ignore into …

**注意事项：**同上，insert ignore into 语句是基于唯一索引或者主键来判断唯一（是否存在）的，

2，大量数据同时插入的场景

1，单条循环插入

使用for循环遍历逐条插入，一条数据在 0.01s到0.03s之间。逐条插入的平均速度是 0.02s*100000,(10w)，也就是33分钟左右。

2，修改sql语句批量插入

@Test
public void insertUsers2() {
     
    List<User> list= new ArrayList<User>();
	
    User user = new User();
    user.setPassword("正在送命");
    user.setPrice(3150);
    user.setHobby("种蘑菇");
	
    for (int i = 0; i < 100000; i++) {
        user.setUserName("提莫队长" + i);
        // 将单个对象放入参数list中
        list.add(user);
        
    }
    userMapper.insertListUser(list);
}

Integer insertListUser(List<User> user);

<insert id="insertListUser" parameterType="java.util.List">
    INSERT INTO `db`.`user_info`
        ( `id`,
          `username`,
          `password`,
          `price`,
          `hobby`) 
     values
    <foreach collection="list" item="item" separator="," index="index">
        (null,
        #{item.userName},
        #{item.password},
        #{item.price},
        #{item.hobby})
    </foreach>

</insert>

**注意点：**当批量操作数据量很大的时候。例如插入10w条数据的sql语句要操作的数据包超过了1m，mysql会报错，通过修改mysql的配置文件可以解决：

max_allowed_packet = xxm

3，分批量多次循环插入

如果不方便修改数据库配置或者插入的内容过多时，也可用通过后端代码控制，比如插入10w条数据，分100批次，每次插入1000条即可，也就是几秒种的事情；当然如果么条的内容很多的话，另说。

3,追问1：如果插入的速度依旧很慢，还有没有其他的优化手段。

• 方案A：通过 show processlist 命令，查询是否有其他长进程或者大量短进程抢占线程池资源？看能否通过把部分进程分配到备库从而减轻主库压力；或者，先把没有用的进程kill掉一些。

• 方案B：大批量导数据，也可以先关闭索引，数据导入后再开启索引。

  关闭表索引：alter table user_info disable keys;
  开启表索引：alter table user_info enable keys;
  

4,对于建表字段是否使用 not null

先说结论：

首先官方文档就建议我们在建表的时候要使用 not null。除非特殊情况。

出现场景：

当你收到快递信息的时候，显示的是尊敬的客户 null，此时你的昵称变成了 null。

可能出现的情况：

• 1,首次名称入库时出错，把名称字段填写失败，mysql 默认 null 值 ，业务层查询返回时格式化成了 null 字符串。
• 2，用户注册时，故意在名称中加了 \n,\r等下流数据，导致查询时返回了空字符串。正则校验时又出现了空指针。
• 3，用户名设置为 null。

关于字段为null ，可能会遇到的问题

• 1，mysql 中的 sum函数，没有统计到任何记录时，会返回null 而不是 0，可以使用 ifnull（null，0）函数把null转换成0；
• 2，mysql 中 count（字段），不会统计null值，count(*)才能同居所有行。
• 3，mysql 中 使用 =，<，>，这样的算数比较符操作 比较 null 的结果总是 null，这种比较就显得没有任何意义，需要使用 is null ，is not null，或者 isnull() 函数来比较。

最后：

可见mysql 中的 null 值很容易导致我们在统计，查询数据的时候出错，这里有些同学可能会问，有没有性能上的提升，算不算sql优化，其实把null，改成not null带来的性能提升可以忽略，除非确定它带来了问题，否额不需要把它当成优先的优化措施。

99，数据库的高可用

7.6 @EqualsAndHashCode

关于@qualsAndHashCode注解

@Data相当于@Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode这5个注解的合集。

可能要遇到的问题：

当使用 @data 注解时，默认就加上了 @EqualsAndHashCode 注解。equals() 和 hashcode() 方法。且不会使用父类的属性。这就导致了可能会出现的问题。

当有多个类有部分相同的属性，然后把这些属性提取出来，定义到父类中，恰好 id （数据库主键）也在父类当中，那么就会存在部分对象在比较时，他们并不相等，但是却因为 lombok 自动生成的 equals（） 和 hashcode（）方法判定相等，从而导致出错。

解决方法：

1，使用@Getter ，@Setter @Tostring 代替 @Data 并自定义 equals() 和 hashcode() 方法，比如有些类只需要判断主键 id 是否相等就够了。

2，或者在使用 @Data 时同时加上@equalsAndHashcode(callSuper = true)注解

@equalsAndHashcode 默认 callSuper = false

2，为啥要重写hashcode和equals方法

首先一点java中所有的类都是object的子类。

然后就是要说hash算法和hashmap了。

hash算法和hashmap

hash表默认长度是11，本质是一个线性表。

往hash表（hashmap）里存数据时：

1，先通过hash函数得到一个hash值

2，然后根据hash值往hash表中放

3，在这个过程中不可避免的会出现 hash冲突。

具体的做法就是为hash值相等的对象建立一个同义词链表。当我们往一个索引地址放入的时候，发现地址被占，那么就会新建一个链表放入这个值。
同理，查找的时候，我们要找这个值，首先会根据hash函数算出它的hash值，然后根据hash值当作索引查找，当发现这个索引里存的不是这个值，就会沿着链表一次查找。

虽然我们还是无法避免hash值冲突问题，但是hash函数设计合理，就能保证同义词链表的长度控制在一个合理的范围内。

所以：重写hashcode方法的重要性来了

简单的说：

1，当有一个属性 id，创建两个对象（k1，k2），他们的id都是1，此时没有重写 hashcode（）方法和 equals（)方法。注意他们的id虽然相同，但是他们在内存中的地址并不相同。

2，把k1放入hashmap中，通过k2的值来取，（k1,k2 的值相同），结果：取出的是一个null。必然是null，原因有两个，1，因为没有重写hashcode方法，2，没有重写equals方法。

首先，我们往 hashmap里放k1时，首先会调用这个类的hashcode方法计算它的hash值，随后把k1放入hash值所指引的内存位置
其次，我们没有在key里定义hashcode方法，这里调用的hashcode方法是object类中的（所有的类都是object的子类），而object类的hashcode方法返回的hash值其实是k1对象的内存地址。（假设是1000）。而k1，和k2的内存地址是不一样的，所以根据k2的内存地址拿到的是null。

重写hashcode方法

重写完hashcode方法后，这个时候由于k1,k2的值是一样的，所以根据hash函数得到的hash值是一样的。
但是根据k2,去取k2依旧是null，这是因为k1，k2,的hash值是一样的，产生了hash冲突，这个时候链表上可能会存在多个hash值相同的值，这个时候就需要通过 equals 方法来判断两者是否相等。
由于我们没有在对象中重写equals 方法，系统在这里调用的依旧是object 类的 equals() 方法。object类的固有方法是根据两个对象的内存地址来判断，所以k1,k2必然是不相等的，这就是重写了hashcode方法后依然得到的是 null。

所以：这就是重写 hashcode方法和 equals 方法的原因了

equals 方法需要满足的几个特性

1，自反性：x.equals(x) == true,和自己比较相等

2，对称性：x.equals(y) == y.equals(x)，两个对象调用 equals的结果应该是一样的。

3，传递性：如果 x.equals(y) == true ; y.equals(z) == true 则 x.equals(z) == true ；x和y相等，y和z相等，则x和z相等。

4，一致性：如果x对象个y对象有成员变量num1和num2，其中重写的equals方法只有num1参与了运算，则修改num2不会影响 x.equals(y) 的值。

而这时如某个类没有重写hashcode方法的话，equals判断两个值相等，但是hashcode的值不相等，如string 类，这样就会造成歧义。

最后附上 object 类的源码：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package java.lang;

public class Object {
    public Object() {
    }

    private static native void registerNatives();

    public final native Class<?> getClass();

    public native int hashCode();

    public boolean equals(Object var1) {
        return this == var1;
    }

    protected native Object clone() throws CloneNotSupportedException;

    public String toString() {
        return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
    }

    public final native void notify();

    public final native void notifyAll();

    public final native void wait(long var1) throws InterruptedException;

    public final void wait(long var1, int var3) throws InterruptedException {
        if (var1 < 0L) {
            throw new IllegalArgumentException("timeout value is negative");
        } else if (var3 >= 0 && var3 <= 999999) {
            if (var3 > 0) {
                ++var1;
            }

            this.wait(var1);
        } else {
            throw new IllegalArgumentException("nanosecond timeout value out of range");
        }
    }

    public final void wait() throws InterruptedException {
        this.wait(0L);
    }

    protected void finalize() throws Throwable {
    }

    static {
        registerNatives();
    }
}

3，@PostConstruct

@PostConstruct 基本：

@PostConstruct 是java自己的注解，是javax.annotation下的注解。

@PostConstruct 通常用来修饰一个非静态的void方法。被@PostConstruct 修饰的方法会在服务器加载 servlet 的时候执行，并且只会被服务器执行一次。@PostConstruct 在构造器之后执行，init() 方法之前执行。

该注解通常会在spring框架中使用，它在整个Bean初始化中的执行顺序。

执行顺序

Constructor(构造方法)->@Autowired(依赖注入)->PostConstruct(注释的方法)

7.7

7.8

7.9

session-cookie

好家伙，7.7，7.8连续两天没更

今天碰到一个词 uri鉴权，其实就是uri授权，然后不太明白，就去看了百度，查到的结果，是类似防盗链的意思，就是会在你的uri上附加授权信息（比如授权的权限，过期时间，等等），然后在拿到这个uri的时候进行解析，看是不是自己的。

在这个过程中呢，搜到了关于授权的四种方式：然后想起来之前面试的时候问了一个session和cookie的问题，回答的不好，重温一下。

session-cookie

cookie

首先http是无状态协议，服务器不会知道哪一个浏览器访问了它，因此需要一个标识来区分不同的浏览器。cookie就是这个管理服务器和浏览器之间状态的标识。cookie的原理是，浏览器第一次向服务器发送请求时，服务器在 response （响应）头部设置 set-cookie 字段，浏览器收到响应就会设置 cookie 并存储，在下一次该浏览器想服务器发送请求的时候就会在 request 头部带上cookie 字段，服务器收到cookie用来区分不同的浏览器

session

浏览器第一次访问服务端的时候，服务端会创建一次会话，在会话中保存浏览器的信息。session是保存在服务器段的，cookie是保存在客户端的，他们都是由服务器端生成的，

session-cookie 认证

1. 服务器在第一次受到浏览器的访问的时候创建sesion，然后保存session。然后给这个session 生成一个唯一标识符 jsessionId，然后把唯一标识符 jsessionId放进 response（响应头中）
2. 浏览器在接收到响应的时候，解析响应头，然后将jsessionId保存在本地cookie中，浏览器下次再向服务器请求的时候，带上jsessionId
3. 服务器在接收到客户端的请求时，先去解析请求头中的cookie中的jsessionId，然后识别这个客户端

ConcurrentHashMap

前来答题，首先关于ConcurrentHashMap第一印象就是线程安全的Map；数据结构的话是使用了数组+分段链表；动态扩容机制，默认长度是16，负载因子是0.75。没了

1，为什么要选择ConcurrentHashMap

在并发编程中使用HashMap可能导致程序死循环。使用线程安全的Hash table效率又非常低，基于以上两个原因，便有了ConcurrentHashMap。

• 1）线程不安全的HashMap

在多线程的环境下，使用HashMap进行put操作引起死循环，导致cpu利用率直接接近100%，所以在并发的情况下不能使用HashMap。HashMap在并发执行put操作时会引起死循环，是因为多线程环境下会导致HashMap的Entry链表形成环形数据结构，一但形成环形数据结构，Entry的next节点永远不为空，调用==.next()==时就会产生死循环获取Entry。（Entry就是hashMap的存储结构（还是存储单元，到底该怎么表达），里面时<key,value>键值对，）。

• 2）效率低下的hashtable

hash table 容器使用 synchronized 来保证线程安全，但在线程竞争激烈的情况下 hash table 的效率非常低下（类似于数据库中的串行化隔离级别）。因为当一个线程访问hash table的同步方法，其他线程也访问hash tab’le 的同步方法的时候，会进入阻塞或者轮询状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法获取元素，读写操作均需要获取锁，竞争越激烈效率越低。

因此，若未明确严格要求业务遵循串行化时（如转账，支付业务），建议不使用 hash table。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kSZS7BiI-1625821945828)(C:\Users\pengzhang1\Desktop\HashTable)]

• 3）ConcurrentHashMap 的分段锁技术可有效提升并发访问率

hash table 容器在竞争激烈的并发环境下表现出效率低下的原因是所有访问 hash table 的线程都必须竞争同一把锁，假如容器里面有多把锁，每一把锁用于锁容器其中一部分数据，那么当线程访问容器里不同数据段的数据时，线程间就不会存在严重的锁竞争，从而可以有效提高并发访问效率，这就是ConcurrentHashMap 所使用的分段锁技术。首先将数据分成一段一段的存储（一堆 Segmen），然后给每一段数据配一把锁，当一个线程占用锁访问其中一个分段数据的时候，其他段的数据也能被其他线程访问。

对于 ConcurrentHashMap 你至少要知道的几个点：

• 默认数组大小是 16
• 扩容因子是 0.75，扩容后数组大小翻倍
• 当存储的node总数量>=数组长度*扩容因子时，会进行扩容（数组中的元素，链表元素，红黑树元素都是内部类Node的实例或者子类实例，这里的node总数量是指所有put进map的node数量）
• 当链表长度>=8且数组长度<64时进行扩容
• 当数组下是链表时，在扩容的时候会从链表的尾部开始rehash
• 当链表长度>=8且数组长度>=64时链表会变成红黑树
• 树节点减少直至为空时会将所对应的数组下标置空，下次存储操作再定位在这个下标时会按照链表存储

=分段锁==技术。首先将数据分成一段一段的存储（一堆 Segmen），然后给每一段数据配一把锁，当一个线程占用锁访问其中一个分段数据的时候，其他段的数据也能被其他线程访问。

对于 ConcurrentHashMap 你至少要知道的几个点：

• 默认数组大小是 16
• 扩容因子是 0.75，扩容后数组大小翻倍
• 当存储的node总数量>=数组长度*扩容因子时，会进行扩容（数组中的元素，链表元素，红黑树元素都是内部类Node的实例或者子类实例，这里的node总数量是指所有put进map的node数量）
• 当链表长度>=8且数组长度<64时进行扩容
• 当数组下是链表时，在扩容的时候会从链表的尾部开始rehash
• 当链表长度>=8且数组长度>=64时链表会变成红黑树
• 树节点减少直至为空时会将所对应的数组下标置空，下次存储操作再定位在这个下标时会按照链表存储