两万字《Java完全自学手册》15张导图，送给所有的零基础小白（建议收藏）_java学习路线

session、cookie、token

首先我们要明白HTTP是一种无状态协议，怎么理解呢？很简单

夏洛：大爷，楼上322住的是马冬梅家吧？
大爷：马冬什么？ 
夏洛：马冬梅。 
大爷：什么冬梅啊？ 
夏洛：马冬梅啊。 
大爷：马什么梅？
夏洛：行，大爷你先凉快着吧。

这段对话都熟悉吧，HTTP就是那个大爷，那如果我们就直接把“大爷”放给用户，用户不用干别的了，就不停的登录就行了。

既然“大爷不靠谱”，我们找“大娘”去吧。

哈哈哈，开个玩笑，言归正传。

为了解决用户频繁登录的问题，在服务端和客户端共同维护一个状态——会话，就是所谓session，我们根据会话id判断是否是同一用户，这样用户就开心了。

但是服务器可不开心了，因为用户越来越多，都要把session存在服务器，这对服务器来说是一个巨大的开销，这是服务器就找来了自己的兄弟帮他分担（集群部署，负载均衡）。

但是问题依然存在，如果兄弟挂了怎么办，兄弟们之间的数据怎么同步，用户1把session存放在机器A上，下次访问时负载均衡到了机器B，完了，找不到，用户又要骂娘。

这时有人思考，为什么一定要服务端保存呢，让客户端自己保存不就好了，所以就诞生了cookie，下一次请求时客户段把cookie发送给服务器，说我已经登录了。

但是空口无凭，服务器怎么知道哪个cookie是我发过去的呢？如何验证成了新的问题。

有人想到了一个办法，用加密令牌，也就是token，服务器发给客户端一个令牌，令牌保存加密后id和密钥，下一次请求时通过headers传给服务端，由于密钥别人不知道，只有服务端知道，就实现了验证，且别人无法伪造。

MVC与三层架构

三层架构与MVC的目标一致：都是为了解耦和、提高代码复用。MVC是一种设计模式，而三层架构是一种软件架构。

MVC

Model 模型

模型负责各个功能的实现（如登录、增加、删除功能），用JavaBean实现。

View 视图

用户看到的页面和与用户的交互。包含各种表单。 实现视图用到的技术有html/css/jsp/js等前端技术。

常用的web 容器和开发工具

Controller 控制器

控制器负责将视图与模型一一对应起来。相当于一个模型分发器。接收请求，并将该请求跳转（转发，重定向）到模型进行处理。模型处理完毕后，再通过控制器，返回给视图中的请求处。

三层架构

表现层（UI）(web层)、业务逻辑层（BLL）(service层)、数据访问层（DAL）(dao层) ，再加上实体类库（Model）

• 实体类库（Model），在Java中，往往将其称为Entity实体类。数据库中用于存放数据，而我们通常选择会用一个专门的类来抽象出数据表的结构，类的属性就一对一的对应这表的属性。一般来说，Model实体类库层需要被DAL层，BIL层和UI层引用。
• 数据访问层（DAL），主要是存放对数据类的访问，即对数据库的添加、删除、修改、更新等基本操作，DAL就是根据业务需求，构造SQL语句，构造参数，调用帮助类，获取结果，DAL层被BIL层调用
• 业务逻辑层（BLL），BLL层好比是桥梁，将UI表示层与DAL数据访问层之间联系起来。所要负责的，就是处理涉及业务逻辑相关的问题，比如在调用访问数据库之前，先处理数据、判断数据。

完整讲解

JavaWeb完整讲解

集合

工欲善其事必先利其器，集合就是我们的器。

ArrayList

底层实现

由什么组成，我说了不算，看源码。怎么看呢？

List<Object> list = new ArrayList<>();

新建一个ArrayList,按住ctrl或command用鼠标点击。

    /\*\*
 \* The array buffer into which the elements of the ArrayList are stored.
 \* The capacity of the ArrayList is the length of this array buffer. Any
 \* empty ArrayList with elementData == DEFAULTCAPACITY\_EMPTY\_ELEMENTDATA
 \* will be expanded to DEFAULT\_CAPACITY when the first element is added.
 \* 翻译
 \* 数组缓冲区，ArrayList的元素被存储在其中。ArrayList的容量是这个数组缓冲区的长度。
 \* 任何空的ArrayList，如果elementData == DEFAULTCAPACITY\_EMPTY\_ELEMENTDATA，
 \* 当第一个元素被添加时，将被扩展到DEFAULT\_CAPACITY。
 \*/
    transient Object[] elementData; 

毋庸置疑，底层由数组组成，那数组的特点就是ArrayList的特点。

• 由于数组以一块连续的内存空间，每一个元素都有对应的下标，查询时间复杂度为O(1)。好比你去住酒店，每个房间都挨着，房门都写着房间号。你想找哪一间房是不是很容易。
• 相对的，一块连续的内存空间你想打破他就没那么容易，牵一发而动全身，所以新增和删除的时间复杂度为O(n)，想像你在做excel表格的时候，想增加一列，后面的列是不是都要跟着移动。
• 元素有序，可重复。可用在大多数的场景，这个就不需要过多解释了。

扩容

我们知道数组是容量不可变的数据结构，随着元素不断增加，必然要扩容。

所以扩容机制也是集合中非常容易爱问的问题，在源码中都可以一探究竟。

1.初始化容量为10，也可以指定容量创建。

    /\*\*
 \* Default initial capacity.
 \* 定义初始化容量
 \*/
    private static final int DEFAULT_CAPACITY = 10;

2.数组进行扩容时，是将旧数据拷贝到新的数组中，新数组容量是原容量的1.5倍。（这里用位运算是为了提高运算速度）

private void grow(int minCapacity) {
  int newCapacity = oldCapacity + (oldCapacity >> 1);
}

3.扩容代价是很高得，因此再实际使用时，我们因该避免数组容量得扩张。尽可能避免数据容量得扩张。尽可能，就至指定容量，避免数组扩容的发生。

为什么扩容是1.5倍？

• 如果大于1.5，也就是每次扩容很多倍，但其实我就差一个元素的空间，造成了空间浪费。
• 如果小于1.5，扩容的意义就不大了，就会带来频繁扩容的问题。

所以，1.5是均衡了空间占用和扩容次数考虑的。

线程安全问题

怎么看线程安全？说实话我以前都不知道，看网上说安全就安全，说不安全就不安全。

其实都在源码里。找到增加元素的方法，看看有没有加锁就知道了。

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

没有加锁，所以线程不安全

在多线程的情况下,插入数据的时可能会造成数据丢失，一个线程在遍历,另一个线程修改,会报ConcurrentModificationException(并发修改异常)错误.

多线程下使用怎么保证线程安全？

保证线程安全的思路很简单就是加锁，但是你可没办法修改源码去加个锁，但是你想想编写java的大佬会想不到线程安全问题？

早就给你准备了线程安全的类。

1.Vector

Vector是一个线程安全的List类，通过对所有操作都加上synchronized关键字实现。

找到add方法，可以看到被synchronized关键字修饰，也就是加锁，但synchronized是重度锁，并发性太低，所以实际一般不使用，随着java版本的更新，慢慢废弃。

public void add(E e) {
            int i = cursor;
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.add(i, e);
                expectedModCount = modCount;
            }
            cursor = i + 1;
            lastRet = -1;
        }

2.Collections

注意是Collections而不是Collection。

Collections位于java.util包下，是集合类的工具类，提供了很多操作集合类的方法。其中Collections.synchronizedList(list)可以提供一个线程安全的List。

对于Map、Set也有对应的方法

3.CopyOnWrite（写时复制）

写时复制，简称COW，是计算机程序设计领域中的一种通用优化策略。

当有多人同时访问同一资源时，他们会共同获取指向相同的资源的指针，供访问者进行读操作。

当某个调用者修改资源内容时，系统会真正复制一份副本给该调用者，而其他调用者所见到的最初的资源仍然保持不变。修改完成后，再把新的数据写回去。

通俗易懂的讲，假设现在有一份班级名单，但有几个同学还没有填好，这时老师把文件通过微信发送过去让同学们填写（复制一份），但不需要修改的同学此时查看的还是旧的名单，直到有同学修改好发给老师，老师用新的名单替换旧的名单，全班同学才能查看新的名单。

共享读，分开写。读写分离，写时复制。

在java中，通过CopyOnWriteArrayList、CopyOnWriteArraySet容器实现了 COW 思想。

平时查询的时候，都不需要加锁，随便访问，只有在更新的时候，才会从原来的数据复制一个副本出来，然后修改这个副本，最后把原数据替换成当前的副本。修改操作的同时，读操作不会被阻塞，而是继续读取旧的数据。

    /\*\* The lock protecting all mutators \*/
    final transient ReentrantLock lock = new ReentrantLock();

    /\*\* The array, accessed only via getArray/setArray. \*/
    private transient volatile Object[] array;

源码里用到了ReentrantLock锁和volatile关键字，会在《资深程序员修炼》专栏中做全面深度讲解。

LinkedList

LinkedList和ArrayList同属于List集合。其共同特点可归纳为：

存储单列数据的集合，存储的数据是有序并且是可以重复的。

但两者也有不同，往下看吧

底层实现

LinkedList类的底层实现的数据结构是一个双向链表。同时还实现了Deque接口，所以会有些队列的特性，会在下面讲。

class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

先简单说一下链表这种数据结构，与数组相反，链表是一种物理存储单元上非连续、非顺序的存储结构，一个最简单的链表（单链表）有节点Node和数值value组成。通俗的讲，就像串在一起的小鱼干，中间用线连着。

transient Node<E> first;

transient Node<E> last;

链表中保存着对最后一个节点的引用，这就是双端链表

在单链表的结点中增加一个指向其前驱的pre指针就是双向链表，一种牺牲空间换时间的做法。

双端链表不同于双向链表，切记！

关于链表更详细代码级讲解会放《糊涂算法》专栏更新。敬请期待！

简单了解过后分析一下链表的特点：

• 查询速度慢，因为是非连续空间，没有下标。想像你需要在一份名单上找到你的名字，没有序号，你只能从头开始一个一个的看。
• 删改速度快，因为非连续，也就没有那么多约束。想像从一根项链上扣下来一块，只需要改变引用就可以了，不会牵一发而动全身。
• 元素有序，可重复。

如何解决查询慢的问题？

如果我查找的元素在尾部，则需要遍历整个链表，所以有了双端链表。

即使不在尾部，我如果只能一个方向遍历，也很麻烦，所以有了双向队列，牺牲空间换时间。

那么空间可不可以再牺牲一点？

可以，就是跳跃链表，简称「跳表」。

通过建立多级索引来加快查询速度。

线程安全问题

老办法，看看add()方法。分为「头插法」和「尾插法」。

    /\*\*
 \* Inserts the specified element at the beginning of this list.
 \*
 \* @param e the element to add
 \*/
    public void addFirst(E e) {
        linkFirst(e);
    }

    /\*\*
 \* Appends the specified element to the end of this list.
 \*
 \* <p>This method is equivalent to {@link #add}.
 \*
 \* @param e the element to add
 \*/
    public void addLast(E e) {
        linkLast(e);
    }

都没加锁，百分之一百的不安全。

如何解决线程不安全问题

1.ConcurrentLinkedQueue

一个新的类，位于java.util.concurrent(juc)包下。实现了Queue接口。

class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
        implements Queue<E>, java.io.Serializable{}

使用violate关键字实现加锁。

 private transient volatile Node<E> head;

 private transient volatile Node<E> tail;

1.Collections

和ArrayList一样，使用Collections.synchronizedList()。

Map：存储双列数据的集合，通过键值对存储数据，存储 的数据是无序的，Key值不能重复，value值可以重复

和ArrayList对比一下

共同点：有序，可重复。线程不安全。

不同点：底层架构，查询和删改的速度

完整讲解

集合完整讲解

JVM

重点来了，Java程序员一定要深入研究的内容

完整讲解

JVM完整讲解

多线程

理解多线程，才能更好的理解框架源码，进行高并发的架构设计，重中之重。

并行和并发

并行：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。

并发：多个处理器或多核处理器同时处理多个任务。

举例：

并发 = 两个队列和一台咖啡机。

并行 = 两个队列和两台咖啡机。

线程和进程

一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有多个线程来增加程序的执行速度。

守护线程

守护线程是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。在 Java 中垃圾回收线程就是特殊的守护线程。

创建线程4种方式

• 继承 Thread 重新 run 方法；
• 实现 Runnable 接口；
• 实现 Callable 接口。
• 线程池

synchronized 底层实现

synchronized 是由一对 monitorenter/monitorexit 指令实现的，monitor 对象是同步的基本实现单元。

在 Java 6 之前，monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作，性能也很低。

但在 Java 6 的时候，Java 虚拟机 对此进行了大刀阔斧地改进，提供了三种不同的 monitor 实现，也就是常说的三种不同的锁：偏向锁（Biased Locking）、轻量级锁和重量级锁，大大改进了其性能。

synchronized 和 volatile 的区别

volatile 是变量修饰符；synchronized 是修饰类、方法、代码段。

volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的修改可见性和原子性。

volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。

synchronized 和 Lock 区别

synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。

synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁。

lock 需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。

通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

synchronized 和 ReentrantLock 区别

synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在 Java 6 中对 synchronized 进行了非常多的改进。

主要区别如下：

ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；

ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；

ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等。

volatile 标记的变量不会被编译器优化；synchronized 标记的变量可以被编译器优化。

设计模式

好多人觉得设计模式模式，那是因为你学的还不够深入，还没有看过源码，所以我特意将设计模式往前放了。

今天我们一块看一下简单工厂模式，其实他不属于23种设计模式，但为了更好的理解后面的工厂方法和抽象工厂，我们还是需要先了解一下。

定义

官方定义

定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。

通俗解读

我们不必关心对象的创建细节，只需要根据不同参数获取不同产品即可。

难点：写好我们的工厂。

结构图

代码演示

本文源码：简单工厂模式源码 提取码: qr5h

目录结构

建议跟着一条学设计模式的小伙伴都建一个maven工程，并安装lombok依赖和插件。

并建立如下包目录，便于归纳整理。

pom如下

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.10</version>
    </dependency>

开发场景

汽车制造工厂，既可以生产跑车，也可以生产SUV，未来还会生产新能源汽车。

代码实现

1.创建抽象产品Car

public abstract class Car {
    public String color;
    abstract void run();
}

2.创建具体产品

SuvCar

public class SuvCar extends Car{
    public SuvCar(){
        this.color="green";
    }

    @Override
    public void run() {
        System.out.println("SuvCar running---------");
    }
}

SportsCar

public class SportsCar extends Car{

    public SportsCar(){
        this.color="red";
    }

    @Override
    public void run() {
        System.out.println("SportsCar running-------");
    }
}

3.创建静态工厂

在简单工厂模式中用于被创建实例的方法通常为静态方法，因此简单工厂模式又被成为静态工厂方法(Static Factory Method)。

/\*\*
 \* 简单/静态工厂，少数产品
 \*/
public class CarFactory {

   public static Car getCar(String type){
        if (type.equals("sport")){
            return new SportsCar();
        }else if (type.equals("suv")){
            return new SuvCar();
        }else {
            return null;
        }
    }
}

4.编写测试类

public class MainTest {
    public static void main(String[] args) {
        SportsCar sport = (SportsCar) CarFactory.getCar("sport");
        sport.run();
        System.out.println(sport.color);
    }
}

5.输出结果

接口和抽象类

补充一个知识：

接口和抽象类有什么区别？

什么时候用接口，什么时候用抽象类？

接口和抽象类有什么区别？

• 接口是针对方法的整合，抽象类是针对子类的整合。
• 人有男人，女人，人是抽象类。人可以吃东西，狗也可以吃东西，吃东西这个动作是接口。
• 接口可以多继承，抽象类不行。
• 接口中基本数据类型为static, 而抽类象不是。
• 抽象类有构造器，方法可以实现，除了不能被实例化，和普通类没有区别，接口不是。

什么时候用接口，什么时候用抽象类？

• 当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
• 再简单点说，有属性定义的时候，用抽象类，只有方法的时候，用接口。

应用场景

• 工厂类负责创建对的对象比较少，因为不会造成工厂方法中的业务逻辑过于复杂
• 客户端只知道传入工厂类的参数，对如何创建对象不关心
• 由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

总结

优点

• 通过工厂类，无需关注生产的细节，只需要传递对应参数即可。
• 可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点

• 违背开闭原则，扩展不易。
• 工厂类职责过重，一旦异常，系统瘫痪。
• 无法动态的增加产品，扩展困难。

问题：在不修改的工厂的前提下，怎么生产新能源汽车？下一节的工厂方法模式给大家讲解。

更多设计模式

更多设计模式

SSM框架

这对于初学者来说，是一个坎，前几年学完这些，已经可以开始找工作了，所以恭喜你能坚持带这里，胜利就在前方。

Redis

随着QPS的逐渐升高，传统的mysql数据库已经无法满足。所以有了基于内存的redis缓存数据库来存储热点数据。

Zookeeper

Zookeeper作为统一配置文件管理和集群管理框架，是后续学习其他框架的基础，在微服务中，还可以用来做注册中心。

Kafka

学习心得

1.按计划行事

凡事预则立，不预则废。一个好的计划是成功的一半，而这一半，一条已经帮你整理好了，你只需要收藏即可。

最后

🍅 硬核资料：关注即可领取PPT模板、简历模板、行业经典书籍PDF。
🍅 技术互助：技术群大佬指点迷津，你的问题可能不是问题，求资源在群里喊一声。
🍅 面试题库：由技术群里的小伙伴们共同投稿，热乎的大厂面试真题，持续更新中。
🍅 知识体系：含编程语言、算法、大数据生态圈组件（Mysql、Hive、Spark、Flink）、数据仓库、Python、前端等等。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！