Java面试题 ¶

基础 ¶

java面向对象的特征 ¶

封装：说明的是一个类的行为和属性与其他类的关系是低耦合（模块之间）、高内聚（模块内）；可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对于外部它内部的细节是隐藏的，暴露出去的只是它的访问方法

继承：继承是父类和子类的关系；是从已有的类派生出新的类，新的类继承已有类的数据属性和行为，并能扩展能力

多态：类与类之间的关系；父类的引用指向子类的实例；多态必备的三个要素：继承、重写、父类引用指向子类实例

java中四种引用类型 ¶

• 强引用：Object object= new Object()，这种方式为强引用，强引用在任何时候都不会被 jvm 垃圾回收，即使抛出 OutOfMemoryError
• 软引用：通过SoftReference的get方法来获取对象。软引用，在jvm内存不足的情况下发生垃圾回收时会被回收
• 弱引用：通过WeakReference的get方法来获取对象。弱引用，只要发生垃圾回收都会回收该对象，不管内存是否充足
• 虚引用：虚引用和没有引用是一样的，需要和队列(ReferenceQueue)联合使用。当jvm扫描到虚引用对象时，会将此对象放入关联的引入队列中，后续可以通过判断队列中是否存这个对象，来进行回收前的一些处理

ArrayList和LinkedList区别 ¶

ArrayList 和 LinkedList 都实现了 List 接口

ArrayList 底层是数组，可以快速的通过索引进行随机访问，时间复杂度O(1)；插入删除随机元素开销很大，因为需要重排数据中所有数据

LinkedList 底层是链表，每个节点存储了两个引用，一个指向前一个元素，一个指向后一个元素，因此会比 ArrayList 更占内存；随机插入和删除效率高，不需要改变数据的大小；随机访问数据效率低，因为它会从第一个元素顺序遍历到需要访问的元素；LinkedList 更适用于：访问数据少，删除，插入数据多的场景

集合 ¶

线程 ¶

线程实现方式 ¶

1. 继承 Thread 类，重新 run 方法；启动线程时调用 Thread.start() 方法

   java

    1/**
    2 * 实现 Thread ，重写 run 方法
    3 */
    4private static void threadTest() {
    5    new Thread(){
    6        @Override
    7        public void run() {
    8            System.out.println(Thread.currentThread().getName());
    9        }
   10    }.start();
   11}

2. 实现 Runnable 接口，重写 run 方法；将 Runnable 实现类对象传入 Thread 构造方法，然后调用 Thread.start() 启动线程

   java

    1/**
    2 * 实现 Runnable 接口，并实现 run 方法
    3 * 创建 Thread 时传入 Runnable实现类实体
    4 */
    5private static void runnableTest() {
    6    new Thread(new Runnable() {
    7        @Override
    8        public void run() {
    9            System.out.println(Thread.currentThread().getName());
   10        }
   11    }).start();
   12}

3. 实现 Callable，重写 call 方法，配合 FutureTask ；一般用于有返回结果的非阻塞的执行方法

   java

    1/**
    2 * 实现 Callable 接口，配合 FutureTask
    3 * 可以获取线程执行结果
    4 * Callable ===> FutureTask ===> Thread
    5 */
    6private static void callableTest() throws Exception {
    7    Callable<String> callable = new Callable<>() {
    8        @Override
    9        public String call() {
   10            return Thread.currentThread().getName();
   11        }
   12    };
   13    FutureTask<String> futureTask = new FutureTask<>(callable);
   14    new Thread(futureTask).start();
   15    // 获取线程执行结果 ，超时时间
   16    System.out.println(futureTask.get(60, TimeUnit.SECONDS));
   17}

线程实现方式，底层都是实现 Runnable 方式

线程状态 ¶

操作系统层面讲

• new（新建状态）：创建了一个新的线程对象
• runnable（就绪状态）：调用线程的start()方法，处于就绪状态
• run（运行状态）： 获得了CPU时间片，执行程序代码；就绪状态是进入到运行状态的唯一入口
• block（阻塞状态）：因为某种原因，线程放弃对CPU的使用权，停止执行，直到进入就绪状态在有可能再次被CPU调度；阻塞又分为三种：等待阻塞、同步阻塞、其他阻塞
• dead（死亡状态）：线程run()、main()方法执行结束，或者因为异常退出了run()方法，则该线程结束生命周期；死亡状态线程不能再次复活

java 层面讲

java 的线程状态可查看 jdk 的 Thread.State 枚举，其中包含了 6 种线程状态

• new（初始化）：新建一个 Thread 实例，就进入了初始化状态
• runnable（可运行）
  • ready：此时线程等待 cpu 调度，调用 start() 后进入就绪状态；当前线程 sleep() 方法结束，其他线程 join() 结束，等待用户输入完毕，某个线程拿到对象锁，线程也将进入就绪状态
  • running：cpu 调度该线程，这也是进入线程运行状态的唯一方法
• blocked：阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态
• waiting：处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态
• timed_waiting：处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒
• terminated：当线程的run()方法完成时，或者主线程的main()方法完成时，就认为它终止了；这个线程对象也许是活的，但是它已经不是一个单独执行的线程；线程一旦终止了，就不能复生；在一个终止的线程上调用start()方法，会抛出 java.lang.IllegalThreadStateException 异常

java 中停止线程 ¶

使用 interrupt() 中断线程；如果线程在 等待状态时，调用 interrupt() 会抛出异常 InterruptedException

调用 interrupt() 不会立即终止线程，只是将 interrupted 标志设置为 true，需手动写逻辑终止线程

 1public static void main(String[] args) {
 2
 3    // 默认 interrupted 为 false
 4    System.out.println(Thread.currentThread().isInterrupted());  // false
 5
 6    // 设置 interrupted 为 true
 7    Thread.currentThread().interrupt();
 8
 9    // 这里直接跳过不执行，因为 interrupted 标志位为 true
10    // isInterrupted() 方法获取当前 interrupted ，并重置 interrupted 为 false
11    while (!Thread.currentThread().isInterrupted()){
12        System.out.println("-------------");
13    }
14}

sleep 和 wait 方法的区别 ¶

• sleep 方法属于 Thread 类的一个静态方法；wait 方法属于 Object 类的方法
• sleep 方法会使线程变成 超时等待状态（自动唤醒）；wait 方法会使线程变成等待状态（需要被唤醒）
• sleep 方法不会释放已经持有的锁资源；wait 在执行后会释放锁资源
• wait 只能在持有锁时才可以执行；sleep 没有这个限制

wait 方法会将持有锁的线程从 owner 扔到 WaitSet 集合中，这个操作是修改 ObjectMonitor 对象，如果没有持有 synchronized 锁的话，是没法操作 ObjectMonitor 对象的

synchronized 实现原理 ¶

synchronized 基于对象实现

MarkWord 在 Hot Spot 中结构如下

MarkWord 标记着四种锁信息：无锁、偏向锁、轻量级锁、重量级锁

synchronized 在 jdk 1.6 的优化 ¶

**锁消除：**在 synchronized 修饰的代码中，如果不存在操作临界资源的情况，会触发锁消除，即使写了 synchronized ，也不会触发

**锁膨胀：**如果在一个循环中，频繁的获取和释放锁资源，这样带来的消耗很大，锁膨胀就是将锁的范围扩大，避免频繁的竞争和获取锁资源带来的不必要消耗

**锁升级：**ReentrantLock 的实现，是基于乐观锁的 CAS 尝试获取锁资源，如果拿不到锁资源，才会挂起线程。synchronized 在 JDK 1.6 之前，完全就是获取不到锁，立即挂起当前线程，所以 synchronized 性能比较差，synchronized 就在 JDK 1.6 做了锁升级的优化

• 无锁、匿名偏向：当前对象没有作为锁存在
• 偏向锁：如果当前锁资源，只有一个线程在频繁的获取和释放，那么这个线程过来，只需要判断，当前指向的线程是否为当前线程
  • 如果是，直接拿走锁资源
  • 如果不是，基于 CAS 的方式，尝试将偏向锁指向当前线程。如果获取不到，触发锁升级，升级为轻量级锁（偏向锁状态出现了锁竞争的情况）
• 轻量级锁：会采用自旋锁的方式去频繁的以 CAS 的形式获取到锁资源（采用的是自适应自旋锁）
  • 如果成功获取到，拿着锁资源走
  • 如果自旋了一定次数，没有拿到锁资源，锁升级
• 重量级锁：就是最传统的 synchronized 方式，拿不到锁资源，就挂起当前线程（用户态 & 内核态）

ReentrantLock 和 synchronized ¶

• ReentrantLock 是个类，synchronized 是关键字，都是在 JVM 层面实现互斥锁的方式
• 如果竞争比较激烈，推荐使用 ReentrantLock 去实现，不存在锁升级概念。而 synchronized 是存在锁升级概念的，如果升级到重量级锁，是不存在锁降级的
• 实现原理不一样，ReentrantLock 基于 AQS 实现的，synchronized 基于 ObjectMonitor 实现的
• ReentrantLock 功能比 synchronized 更全面；ReentrantLock 支持公平锁或非公平锁；ReentrantLock 可以指定等待锁资源的时间

ThreadLocal 内存泄漏问题 ¶

ThreadLocal 实现原理

• 每个 Thread 中都存储着一个成员变量，ThreadLocalMap
• ThreadLocal 本身不存储数据，像是一个工具类，基于 ThreadLocal 去操作 ThreadLocalMap
• ThreadLocalMap 本身就是基于 Entry[] 实现的，因为一个线程可以绑定多个 ThreadLocal，这样一来可能需要存储多个数据，所以采用 Entry[] 的形式实现
• 每一个线程都有自己独立的 ThreadLocalMap ，再基于 ThreadLocal 对象本身作为 key，对 value进行存取
• ThreadLocalMap 的 key 是一个弱引用，弱引用的特点是，即便有弱引用在 GC 时也会被垃圾回收。这里是为了在 ThreadLocal 对象失去引用后，如果 key 的引用是强引用，会导致 ThreadLocal 对象无法被回收

内存泄漏

• key 的内存泄漏：ThreadLocalMap key 是弱引用 ThreadLocal 对象，解决了

• value 内存泄漏：如果 ThreadLocal 引用丢失，key 因为弱引用会被 GC 回收掉，如果同时线程还没有被回收，就会导致内存泄漏，内存中的 value 无法被回收，同时也无法被获取到；只需要在使用完毕 ThreadLocal 对象后，及时的调用 remove 方法，移除 Entry 即可

java 中锁分类 ¶

1. 可重入锁、不可重入锁

   java 提供的 synchronized、ReentrantLock、ReentrantReadWriteLock 都是可重入锁

   **重入：**当线程获取到 A 锁，在获取之后尝试再次获取 A 锁是可以直接拿到的

   **不可重入：**当线程获取到 A 锁，在获取后再次尝试获取 A 锁，无法获取到，因为 A 锁被当前线程占用着，需要等待自己释放锁再获取锁

2. 乐观锁、悲观锁

   java 提供的 synchronized、ReentranLock、ReentranReadWriteLock 都是悲观锁

   java 中 CAS 操作就是乐观锁的一种实现

   **悲观锁：**在获取不到锁资源时，会将线程挂起（进入 BLOCKED、WAITING），线程挂起会涉及到用户态和内存态的切换，而这种切换比较耗资源

   • 用户态：JVM 可以自行执行的指令，不需要借助操作系统执行
   • 内核态：JVM 不可以自行执行，需要操作系统才可以执行

   **乐观锁：**获取不到锁资源，可以再次让 CPU 调度，重新尝试获取锁资源

   Atomic 原子性类中，就是基于 CAS 乐观锁实现的

3. 公平锁、非公平锁

   java 提供的 synchronized 只能是非公平锁

   java 提供的 ReentrantLock、ReentranReadWriteLock 可以实现公平锁和非公平锁

   **公平锁：**线程 A 获取到了锁资源，线程 B 没有拿到，线程 B 去排队，线程 C 来了，锁被 A 持有，同时 B 在排队。C 排在 B 后面，直到 B 拿到锁资源或者 B 取消后，才可以尝试去竞争锁

   **非公平锁：**线程 A 获取到了锁资源，线程 B 没有拿到，线程 B 去排队，线程 C 来了，先尝试竞争一波

   • 拿到锁资源：插队成功
   • 没有拿到锁资源：依然需要排队在 B 的后面，等待 B 拿到锁资源或 B 取消后，才可以尝试竞争锁

4. 互斥锁、共享锁

   java 提供的 synchonized、ReentrantLocak 是互斥锁

   java 提供的 ReentrantReadWriteLock 有互斥锁也有共享锁

   **互斥锁：**同一时间点，只会有一个线程持有当前互斥锁

   **共享锁：**同一时间点，当前共享锁可以被多个线程同时持有

并发编程的三大特性 ¶

原子性

原子性指的是一个操作是不可分割的，不可中断的，一个线程在执行时，另外一个线程不会影响到他

可以通过 synchronized、CAS、Lock 锁、ThreadLocal 来保证并发编程的原子性

可见性

cpu 执行过程会存在缓存，需要保证所有线程读取到的数据是一致的

使用 synchroized 、 lock 都会在加锁和释放锁时对 cpu 缓存做一个同步到主内存的操作，如果在同步代码块中没有对数据进行修改，也能保证可见性

使用 volatile 来保证可见性

• volatile 属性被写时，JMM 会将当前线程对应的 cpu 缓存及时刷新到主内存中
• volatile 属性被读时，JMM 会将对应的 CPU 缓存中的内存设置为无效，必须从主内存中重新读取共享变量

有序性

在 java 中，java 文件中的内容会被编译，在执行前需要再次转为 CPU 可识别的指令，CPU 在执行这些指令时，为了提升执行效率，在不影响最终结果的前提下（满足某种要求），会对指令进行重排

可以使用 volatile 可以保证有序性，防止指令重排

JDK 中提供的线程池 ¶

newFixedThreadPool

这个线程池的线程是固定的 Executors.newFixedThreadPool(int nThreads)

1// 无界队列，线程核心数量和最大数量一致；线程空闲超过 0s 后关闭 （大于核心线程数的线程）
2public static ExecutorService newFixedThreadPool(int nThreads) {
3    return new ThreadPoolExecutor(nThreads, nThreads,
4                                  0L, TimeUnit.MILLISECONDS,
5                                  new LinkedBlockingQueue<Runnable>());
6}

构建该线程池时需要提供一个 nThreads 的属性，这个属性就是线程池中线程的个数（线程是懒加载，构建线程池时并没有创建线程，当任务提交时才会在线程池中构建线程）；任务会被添加到无界队列 LinkedBlockingQueue 中等待线程去 take() 出后执行

newSingleThreadExecutor

1// 无界队列，线程核心数量和最大数量一致且为1；线程空闲超过 0s 后关闭 （大于核心线程数的线程）
2public static ExecutorService newSingleThreadExecutor() {
3    // FinalizableDelegatedExecutorService 里面只是在 finalize 中去关闭了一次线程池（无意义）
4    return new FinalizableDelegatedExecutorService
5        (new ThreadPoolExecutor(1, 1,
6                                0L, TimeUnit.MILLISECONDS,
7                                new LinkedBlockingQueue<Runnable>()));
8}

单例线程池，线程池中只有一个工作线程在运行

任务执行顺序及任务进入无界队列的顺序，可用来处理 顺序处理的业务

newCachedThreadPool

1// 线程核心数量为0，最大为 Integer.MAX_VALUE；
2// 线程空闲超过 60s 后关闭 （大于核心线程数的线程）
3public static ExecutorService newCachedThreadPool() {
4    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
5                                  60L, TimeUnit.SECONDS,
6                                  new SynchronousQueue<Runnable>());
7}

第一次提交任务到线程池时，会直接创建一个工作线程；当工作线程执行完后，60s内没有任务，会结束这个工作线程

如果后续进来任务没有线程时，会创建新的工作线程去执行

特点：当任务提交到该线程池中时，必然会有工作线程进行处理

ScheduledExecutorService

1public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
2    return new ScheduledThreadPoolExecutor(corePoolSize);
3}

定时任务线程池，这个线程池可以一定周期去执行一个任务，或者延迟多久执行一个任务

newWorkStealingPool

1public static ExecutorService newWorkStealingPool() {
2    return new ForkJoinPool
3        (Runtime.getRuntime().availableProcessors(),
4         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
5         null, true);
6}

该线程池和前面几种区别很大

前面的线程池底层都是基于 ThreadPoolExecutor 构建的；newWorkStealingPool 线程池是基于 ForkJoinPool 构建出来的

线程池核心参数 ¶

ThreadPoolExecutor 有 7 个核心参数

1public ThreadPoolExecutor(int corePoolSize,   // 核心线程数量，始终存活
2                          int maximumPoolSize,  // 任务超过核心线程数量时，可创建的最大线程数量
3                          long keepAliveTime,  // 超过 corePoolSize 的线程数量空闲时存活时间
4                          TimeUnit unit,  // 存活时间单位
5                          BlockingQueue<Runnable> workQueue,  // 任务队列，存放当前没有线程处理的任务
6                          ThreadFactory threadFactory,  // 构建线程，可以设置线程的一些参数
7                          RejectedExecutionHandler handler  // 拒绝策略，线程池无法处理任务时
8) {

拒绝策略

• ThreadPoolExecutor.AbortPolicy：抛出错误 RejectedExecutionException
• ThreadPoolExecutor.CallerRunsPolicy：使用调用者线程执行任务，直接调用任务的 run 方法
• ThreadPoolExecutor.DiscardPolicy：丢弃任务
• ThreadPoolExecutor.DiscardOldestPolicy：丢弃最早的未处理任务

线程池状态 ¶

线程池核心属性是 ctl，基于 ctl 拿到线程池的状态以及工作线程个数

 1// ctl 是一个 int 类型的数值，内部基于 AtomicInteger 嵌套了一层，保证操作的原子性
 2// 线程池状态：ctl 高三位表示线程池状态
 3// 工作线程个数：ctl 低三位表示线程的个数
 4private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
 5
 6// Integer.SIZE 获取 Integer 的 bit 个数
 7// 申明一个常量 COUNT_BITS = 29
 8private static final int COUNT_BITS = Integer.SIZE - 3;
 9// COUNT_MASK 为当前线程池记录的工作线程个数
10private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
11
12// 线程池状态
13// 111：线程池正常，可接收任务处理
14private static final int RUNNING    = -1 << COUNT_BITS;
15// 000：线程池关闭状态，不会接受新任务，正在处理的任务正常执行，阻塞队列中任务也会执行
16private static final int SHUTDOWN   =  0 << COUNT_BITS;
17// 001：线程池停止状态，不接收新任务，当前线程池中任务和阻塞队列中任务全都不管
18private static final int STOP       =  1 << COUNT_BITS;
19// 010：线程池整理，从 STOP 或 SHTUDOWN 转换过来的，只是一个过渡状态，代表当前线程池立马关闭
20private static final int TIDYING    =  2 << COUNT_BITS;
21// 001：线程池结束，从 TIDYING 转换过来的，转换过来只需要执行一个 terminated 方法
22private static final int TERMINATED =  3 << COUNT_BITS;

@Contended 注解作用 ¶

使用@Contended来保证被标识的字段或者类不与其他字段出现内存争用

为了提高IO效率，CPU每次从内存读取数据并不是只读取我们需要计算的数据，而是将我们需要的数据周围的64个字节（intel处理器的缓存行是64字节）的数据一次性全部读取到缓存中。这64个字节的数据就称为一个缓存行

假设现在有两个线程都需要缓存行1（见图）中的数据做运算，假设CPU1需要缓存行1中的第一个字节数据做运算，CPU2需要缓存行1中的第二个字节做运算。此时CPU1和CPU2都需要将缓存行1读取到缓存中，这样就有可能出现缓存不一致现象，为了保证缓存一致性，出现了很多种的缓存一致性协议，其中intel使用了MESI协议来保证缓存一致性。

@Contended 注解作用就是让数据独占一个缓存行，可以提升运行效率

 1/**
 2 * @Contended 注解的作用
 3 * 使用@Contended来保证被标识的字段或者类不与其他字段出现内存争用
 4 * 为了提高IO效率，CPU每次从内存读取数据并不是只读取我们需要计算的数据，
 5 * 而是将我们需要的数据周围的64个字节（intel处理器的缓存行是64字节）的数据一次性全部读取到缓存中。这64个字节的数据就称为一个缓存行。
 6 * 假设现在有两个线程都需要缓存行1中的数据做运算，假设CPU1需要缓存行1中的第一个字节数据做运算，CPU2需要缓存行1中的第二个字节做运算。
 7 * 此时CPU1和CPU2都需要将缓存行1读取到缓存中，这样就有可能出现缓存不一致现象，为了保证缓存一致性，出现了很多种的缓存一致性协议，其中intel使用了MESI协议来保证缓存一致性。
 8 * 简单的说，当CPU1对缓存行1中的数据做了修改时，会通知CPU2，告诉他数据我修改了，你那边作废了，需要重新从内存读取。反之，CPU2对数据做出修改，CPU1也需要重新读取。这样就会导致大量的IO操作，导致性能降低。
 9 * <p>
10 * 为了避免这种现象，我们需要想办法将这两个数据放到不同的缓存行中，这样就可以避免频繁的读取数据，增加性能。
11 * <p>
12 * 注意：如果想要@Contended注解起作用，需要在启动时添加JVM参数
13 *
14 * @author 81497
15 * @date 2023/06/10
16 */
17public class ContendedDemo {
18    // volatile 使用内存屏障保证数据的可见性 （更新直接写主存、读取从主从读）
19    @Contended
20    public volatile long x;
21    public volatile long y;
22
23    public static void main(String[] args) throws InterruptedException {
24        testNoContended();
25
26    }
27
28    /**
29     * 定义了两个变量x和y，并且使用两个线程对这两个变量做赋值操作。
30     * 如果不加@Contended注解，x和y有很大概率位于同一个缓存行。
31     * 就会出现我们刚才所说的频繁的重新从内存读取数据。如果对x变量添加了@Contended注解，则可以保证x与y在不同的缓存行
32     * 不加 @Contended 注解执行时间：1261ms 左右波动；添加 @Contended 注解执行时间 385ms 左右波动，效率提升三倍左右
33     */
34    private static void testNoContended() throws InterruptedException {
35        ContendedDemo contendedDemo = new ContendedDemo();
36        Thread t1 = new Thread(() -> {
37            for (long i = 0; i < 1000000000L; i++) {
38                contendedDemo.x = i;
39            }
40        });
41        Thread t2 = new Thread(() -> {
42            for (long i = 0; i < 1000000000L; i++) {
43                contendedDemo.y = i;
44            }
45        });
46        long millis = System.currentTimeMillis();
47        t1.start();
48        t2.start();
49        t1.join();
50        t2.join();
51        System.out.println((System.currentTimeMillis()-millis)+"ms");
52    }
53}

什么是 CAS ¶

CAS(compare and swap)：也就是比较和交换，它是一条 CPU 的并发原语

它包含了三个参数：V，A，B。其中，V表示要读写的内存位置，A表示旧的预期值，B表示新值

它在替换内存某个位置的值时，首先查看内存中的值和预期值是否一致，如果一致，执行替换操作，这个操作是一个原子性操作

Java 中基于 Unsafe 的类提供了对 CAS 操作的方法，JVM 会帮助我们将方法实现 CAS 汇编指令

优点

比较传统的 synchroized 可以避免线程的挂起以及唤醒，避免了用户态内核态切换的时间成本

缺点

自旋时间可能过长，CPU开销较大

哲学家就餐问题 ¶

**描述：**哲学家就餐问题是计算机科学中一经典问题，用于演示并行计算中多线程同步（Synchronization）问题

**如下图：**假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉，假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉

代码实现

 1/**
 2 * 哲学家就餐
 3 * 假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。
 4 * 餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉，假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉
 5 *
 6 * @author 81497
 7 * @date 2023/06/05
 8 */
 9public class DiningPhilosophers {
10
11    public static void main(String[] args) {
12        // 筷子
13        Fork f0 = new Fork("f0");
14        Fork f1 = new Fork("f1");
15        Fork f2 = new Fork("f2");
16        Fork f3 = new Fork("f3");
17
18        // 哲学家
19        DiningPeople d1 = new DiningPeople(f0, f1, 1);
20        DiningPeople d2 = new DiningPeople(f1, f2, 2);
21        DiningPeople d3 = new DiningPeople(f2, f3, 3);
22        DiningPeople d4 = new DiningPeople(f3, f0, 4);
23
24        new Thread(d1).start();
25        new Thread(d2).start();
26        new Thread(d3).start();
27        new Thread(d4).start();
28    }
29
30    /**
31     * 哲学家
32     */
33    public static class DiningPeople extends Thread {
34        private final Fork left, right;
35        private final int index;
36
37        public DiningPeople(Fork left, Fork right, int index) {
38            this.left = left;
39            this.right = right;
40            this.index = index;
41        }
42
43        /**
44         * 规定奇数号哲学家先拿他左边的筷子，然后在去拿右边的筷子；而偶数号哲学家则相反。按此规定，将是1、2号哲学家竞争1号筷子；3、4号哲学家竞争3号筷子。
45         * 即5位哲学家都先竞争奇数号筷子，获得后，再去竞争偶数号筷子，最后总会有一位哲学家能够获得两只筷子而进餐
46         */
47        @Override
48        public void run() {
49            try {
50                while (true) {
51                    if (index % 2 == 0) {
52                        // 拿到左手筷子
53                        synchronized (left) {
54                            System.out.println(index + "拿到左手筷子");
55                            // 拿到右手筷子
56                            synchronized (right) {
57                                System.out.println(index + "哲学家开始吃饭");
58                                TimeUnit.MILLISECONDS.sleep(1000);
59                            }
60                        }
61                    } else {
62                        // 拿到左手筷子
63                        synchronized (right) {
64                            System.out.println(index + "拿到右手筷子");
65                            // 拿到右手筷子
66                            synchronized (left) {
67                                System.out.println(index + "哲学家开始吃饭");
68                                TimeUnit.MILLISECONDS.sleep(1000);
69                            }
70                        }
71                    }
72                    System.out.println(index + "哲学家吃饭结束");
73                    TimeUnit.MILLISECONDS.sleep(1000);
74
75                }
76            } catch (Exception e) {
77                e.printStackTrace();
78            }
79        }
80    }
81
82    /**
83     * 叉
84     */
85    public static class Fork {
86        private String name;
87
88        public Fork(String name) {
89            this.name = name;
90        }
91    }
92}

多线程事务控制 ¶

• 创建子线程个数的 CountDownLatch

• 创建主线程 CountDownLatch

• 共享数据，里面设置回滚标志

 1/**
 2 * 多个任务，同时成功或失败
 3 *
 4 * @author 81497
 5 * @date 2023/06/06
 6 */
 7public class TransactionIssues {
 8
 9    public static void main(String[] args) {
10        // 主线程监控
11        CountDownLatch mainLatch = new CountDownLatch(1);
12        // 子线程监控
13        CountDownLatch threadLatch = new CountDownLatch(4);
14        ShareData shareData = new ShareData(mainLatch, threadLatch);
15
16        // 启动四个子线程
17        new Work(shareData).start();
18        new Work(shareData).start();
19        new Work(shareData).start();
20        new Work(shareData).start();
21
22        try {
23            // 等待子线程结束，超时未结束会返回 false
24            if (!threadLatch.await(10, TimeUnit.SECONDS)) {
25                // 等待超时 设置共享变量为回滚
26                shareData.rollback = true;
27            }
28        } catch (InterruptedException e) {
29            // 当前线程被中断
30            shareData.rollback = true;
31        } finally {
32            System.out.println("主线程处理结束");
33            mainLatch.countDown();
34        }
35
36    }
37
38    /**
39     * 线程之间共享数据
40     */
41    public static class ShareData {
42        public ShareData(CountDownLatch mainLatch, CountDownLatch threadLatch) {
43            this.mainLatch = mainLatch;
44            this.threadLatch = threadLatch;
45        }
46
47        CountDownLatch mainLatch;
48        CountDownLatch threadLatch;
49        volatile boolean rollback;
50    }
51
52
53    public static class Work extends Thread {
54        private final ShareData shareData;
55
56        public Work(ShareData shareData) {
57            this.shareData = shareData;
58        }
59
60        @Override
61        public void run() {
62            try {
63                // 模拟业务执行时间
64                TimeUnit.MILLISECONDS.sleep(1000);
65                if ("Thread-0".equals(Thread.currentThread().getName())) {
66                    throw new IllegalArgumentException("异常");
67                }
68            } catch (Exception e) {
69                // 业务执行失败，设置回滚
70                System.out.println("子线程业务执行异常");
71                shareData.rollback = true;
72            } finally {
73                // 当前子线程执行结束
74                System.out.println(Thread.currentThread().getName() + "业务处理结束");
75                shareData.threadLatch.countDown();
76            }
77
78            try {
79                // 等待主线程处理结束，这里不设置超时时间
80                shareData.mainLatch.await();
81            } catch (InterruptedException e) {
82                // 等待超时，默认处理直接回滚数据
83                rollback();
84            }
85            if (shareData.rollback) {
86                rollback();
87            }
88            System.out.println(Thread.currentThread().getName() + "子线程处理结束");
89        }
90
91        private void rollback() {
92            System.out.println(Thread.currentThread().getName() + "回滚");
93            throw new RuntimeException(Thread.currentThread().getName() + "子线程回滚");
94            // 回滚失败可记录日志表
95        }
96
97    }
98}

交替输出问题 ¶

假设有两个线程 A、B，A 输出的是 123456 ，B 输出的是 ABCDEF，需要保证最终输出为：1A2B3C4D5E6F 交替输出

通过 LockSupport.park() 和 LockSupport.unpark() 实现；park 和 unpark 顺序无所谓，内部有一个标识（类似于 +1 -1 操作，只要标识正确就可以）

 1/**
 2 * 交替输出
 3 *
 4 * @author 81497
 5 * @date 2023/06/06
 6 */
 7public class AlternatingOutput {
 8    private static Thread t1, t2;
 9
10    public static void main(String[] args) {
11        char[] a = "123456".toCharArray();
12        char[] b = "ABCDEF".toCharArray();
13
14        t1 = new Thread(() -> {
15            for (char c : a) {
16                System.out.print(c);
17                // 唤醒 t2 线程
18                LockSupport.unpark(t2);
19                // 停止当前线程
20                LockSupport.park();
21
22            }
23        });
24        t2 = new Thread(() -> {
25            for (char c : b) {
26                // 停止当前线程
27                LockSupport.park();
28                System.out.print(c);
29                // 唤醒 t1 线程
30                LockSupport.unpark(t1);
31            }
32        });
33        // 启动线程
34        t1.start();
35        t2.start();
36    }
37}

利用锁实现

 1/**
 2 * 交替输出
 3 * 假设有两个线程 A、B，A 输出的是 123456 ，B 输出的是 ABCDEF，需要保证最终输出为：1A2B3C4D5E6F 交替输出
 4 *
 5 * @author 81497
 6 * @date 2023/06/06
 7 */
 8public class AlternatingOutput {
 9    private static Thread t1, t2;
10    static final char[] a = "123456".toCharArray();
11    static final char[] b = "ABCDEF".toCharArray();
12    // 保证执行顺序，先执行 t2 线程，再执行t1线程
13    static CountDownLatch downLatch = new CountDownLatch(1);
14
15    /**
16     * 利用锁实现
17     */
18    private static void test2() {
19        t1 = new Thread(() -> {
20            // 执行后等待门栓
21            try {
22                downLatch.await();
23            } catch (InterruptedException e) {
24                throw new RuntimeException(e);
25            }
26
27            synchronized (AlternatingOutput.class) {
28                for (char c : a) {
29                    try {
30                        // 唤醒阻塞线程
31                        System.out.print(c);
32                        AlternatingOutput.class.notify();
33                        AlternatingOutput.class.wait();
34                    } catch (InterruptedException e) {
35                        Thread.currentThread().interrupt();
36                        throw new RuntimeException(e);
37                    }
38
39                }
40                // 最后需要释放锁，不然总有个线程在等待，程序不能结束
41                AlternatingOutput.class.notify();
42            }
43        });
44        t2 = new Thread(() -> {
45            synchronized (AlternatingOutput.class) {
46                // 获取锁后就可以，关闭门闩
47                downLatch.countDown();
48                for (char c : b) {
49                    try {
50                        System.out.print(c);
51                        AlternatingOutput.class.notify();
52                        AlternatingOutput.class.wait();
53                    } catch (InterruptedException e) {
54                        Thread.currentThread().interrupt();
55                        throw new RuntimeException(e);
56
57                    }
58                }
59                // 最后需要释放锁，不然总有个线程在等待，程序不能结束
60                AlternatingOutput.class.notify();
61            }
62        });
63        // 启动线程
64        t1.start();
65        t2.start();
66    }
67}

Spring ¶

对 Spring 理解 ¶

发展历程

Spring 在 2004-03-24 发布了 1.0 的版本，截止到 2023 年，Spring 已经发布了 6.x 的版本，主要使用版本为 Spring5.x 版本

Spring 组成

Spring 是一个轻量级的 IOC 和 AOP 容器框架。是为 Java 程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于 XML 的配置、基于注解的配置、基于 Java 的配置

主要由以下几个模块组成

• Spring Core：核心类库，提供 IOC 服务
• Spring Context：提供框架式的 Bean 访问方式，以及企业级功能（JNDI、定时任务等）
• Spring AOP：AOP服务
• Spring DAO：对 JDBC 的抽象，简化数据访问异常的处理
• Spring ORM：对现有的 ORM 框架的支持
• Spring Web：提供了基本的面向 Web 的综合特性，例如多文件上传
• Spring MVC：提供面向 Web 应用的 Model-View-Controller 实现

Spring 好处

Spring 中用到的设计模式 ¶

单例模式

通过 xml 配置 bean 时，默认为单例

 1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4       xsi:schemaLocation="http://www.springframework.org/schema/beans
 5        https://www.springframework.org/schema/beans/spring-beans.xsd">
 6    <!--  默认 scope 为 singleton 单例 -->
 7    <bean id="helloService" class="org.lei.ch01.service.HelloService">
 8        <property name="name" value="小唐"/>
 9    </bean>
10</beans>

原型模式

通过 xml 配置 bean 时，可以声明 bean 为原型模式

 1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4       xsi:schemaLocation="http://www.springframework.org/schema/beans
 5        https://www.springframework.org/schema/beans/spring-beans.xsd">
 6    <!--  声明 bean，声明 scope 为原型模式 -->
 7    <bean id="helloService" class="org.lei.ch01.service.HelloService" scope="prototype">
 8        <property name="name" value="小唐"/>
 9    </bean>
10</beans>

模板模式

模板模式的核心是父类定义好流程，然后将流程中需要子类实现的方法就抽象给子类实现。Spring 中的 JdbcTemplate 就是这样实现的

JDBC 的固定步骤

1. 加载驱动
2. 获取连接通道
3. 构建 sql 执行语句
4. 执行 sql 语句
5. 关闭资源

在这些步骤中，第3步和第4步是不确定的，所以留给客户实现，而实际使用 jdbcTemplate 的时候也确实只需要构建 SQL 语句就行了。这就是典型的模板模式

观察者模式

观察者模式定义的是对象之间一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到通知并被自动更新。ApplicationListener 就使用到了观察者模式

工厂模式

简单工厂模式：简单工厂模式就是通过工厂根据传递进来的参数决定产生哪个对象，Spring 中我们通过 id 或 name 调用getBean 方法获取对象就是简单工厂模式

工厂方法模式：在 Spring 中我们一般是将 Bean 实例化直接交给容器去管理的，实现了使用和创建的分离，这时容器直接管理对象；还有种情况是，bean 的创建过程交给一个工厂去实现，而 Spring 容器管理这个工厂；在 Spring 中有两种工厂方法模式，一种是静态工厂方法模式，一种是动态工厂方法模式

适配器模式

将一个类的接口转换成客户希望的另一个接口。使得原本由于接口不兼容而不能在一起工作的那些类可以在一起工作，这就是适配器模式。在 Spring 中在 AOP 实现中的 Advice 和 interceptor 之间的转换就是通过适配器模式实现的

 1class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
 2    MethodBeforeAdviceAdapter() {
 3    }
 4
 5    public boolean supportsAdvice(Advice advice) {
 6        return advice instanceof MethodBeforeAdvice;
 7    }
 8
 9    public MethodInterceptor getInterceptor(Advisor advisor) {
10        MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice();
11        // 通知类型匹配对应的拦截器
12        return new MethodBeforeAdviceInterceptor(advice);
13    }
14}

装饰者模式

装饰者模式又称为包装模式（Wrapper），作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系替代继承关系，更加灵活，同时避免类型体系的快速膨胀

Spring 中用得到包装模式在类名上有两种表现：一种是类名中含有 Wrapper，另一种是类名含有 Decorator。基本上都是都是动态的给一个对象添加一些额外的职责

具体的使用在 SpringSession 框架中的 SessionRepositoryRequestWrapper 使用包装模式对原生的 request 的功能进行增强，可以将 session 中的数据和分布式数据库同步，这样即使当前 tomcat 崩溃，session 中的数据也不会丢失

代理模式

aop 就是基于代理模式

策略模式

策略模式对应于解决某个问题的的算法族，允许用户任选一个算法解决某个问题，同时可以方柏霓的更换或者增加新的算法。spring 中在实例化对象时会用到 策略模式，XmlBeanDefinitionReader，PropertiesBeanDefinitionReader

责任链模式

AOP 中的拦截器链

委托者模式

DelegatingFilterProxy，整合 Shiro、SpringSecurity 的时候都有用到

@Autowired 和 @Resource ¶

@Autowired 和 @Resource 都是做 bean 的注入时使用，@Resource 并不是 Spring 的注解，它的包是 javax.annotation.Resource，需要导入，但是 Spring 支持该注解的注入

共同点

两者都可以使用在字段和setter方法上。两者如果都写在字段上，那么久不需要再写 setter 方法

不同点

@Autowired 为 Spring 提供的注解，需要导入 org.springframework.beans.factory.annotation.Autowired ，只按照 byType 注入；@Autowired 注解是按照类型（byType）装配依赖对象，默认情况下它会要求依赖对象必须存在，可以设置它的 required 属性为 false。如果想按照名称（byName）注入，可以配合 @Qualififier 注解一起使用

@Resource 默认是按照名字自动注入（byName），由 J2EE 提供，需要导入包 Java.annotation.Resource。@Resource 有两个重要的属性：name 和 type，而 Spring 将 @Resource 注解的 name 属性解析为 bean 的名字，而 type 属性则解析为 bean 的类型。所以使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性则使用 byType 自动注入策略。如果既不指定 name 属性也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略

@Resource 装配顺序

1. 如果同时指定了 name 和 type，则从 Spring 上下文找到唯一匹配的 bean 进行装配，找不到则抛出异常
2. 如果指定了 name，则从上下文查找名称（id）匹配的 bean 进行装配，找不到则抛出异常
3. 如果指定 type，则从上下文找到类似匹配的唯一 bean 进行装配，找不到或是找到多个，都会抛出异常
4. 如果 name 和 type 属性都没指定，则自动按照 byName 进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配了则自动装配

Spring 中循环依赖 ¶

循环依赖几种情况

上图是循环依赖的三种情况，虽然方式不一样，但是循环依赖本质都是一样的，就是我完成创建要依赖的对象也依赖自己，相互依赖从而没法创建造成失败

代码演示

 1public class Main {
 2
 3    public static void main(String[] args) {
 4        A a = new A();
 5    }
 6
 7    static class A{
 8        B b=new B();
 9    }
10    static class B{
11        A a=new A();
12    }
13
14}

解决方法本质

先创建 A ，但是不进行初始化操作，也就是半成品对象，然后在创建 B 的时候先把 A 暴露出来，让 B 创建完成后找到 A 通过 set 方法设置 A 的属性，完成整体的实例化

Spring 解决循环依赖

Spring 几种作用域 ¶

Spring 容器中的 bean 可分为五个范围

**prototype（原型作用域）：**为每一个 bean 请求提供一个实例

**singleton（单例作用域）：**默认，每个容器中只有一个 bean 的实例，单例模式由 BeanFactory 自身来维护

**request（请求作用域）：**为每一个网络请求创建一个实例，在请求完成以后，bean 会失效，并被垃圾回收器回收

**session（会话作用域）：**与 request 范围类似，确保每个 session 中有一个 bean 的实例，在 session 过期后，bean 会随之失效并被回收

**global session（全局作用域）：**类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内

Spring 事务隔离级别

事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度，当多个事务访问相同的数据，如果没有采用必要的隔离机制，就可能发生以下问题：

Spring 支持的隔离级别

Spring 中事务传播 ¶

保证事务：ACID，A（Atomicity原子性）、I（Isolation隔离性）、D（Durability持久性）==》C（Consistency一致性）

Spring 中七种事务传播行为

参看 TransactionDefinition 接口中定义的常量

Spring 事务实现方式 ¶

**编程式事务：**通过编程方式管理事务，具有很大的灵活性，但难以维护

1. 通过PlatformTransactionManager实现编程式事务

   java

    1@Override
    2public StudentEntity update(StudentEntity studentEntity) {
    3    //事务定义
    4	DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    5    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    6    //新开事务
    7    TransactionStatus status = transactionManager.getTransaction(definition);
    8    try {
    9        studentsDao.update(studentEntity);
   10        //事务定义
   11        DefaultTransactionDefinition definition1 = new DefaultTransactionDefinition();
   12        definition1.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
   13        //新开事务
   14        TransactionStatus status1 = transactionManager.getTransaction(definition1);
   15        try {
   16            StudentEntity studentEntity1=new StudentEntity();
   17            BeanUtils.copyProperties(studentEntity,studentEntity1);
   18            studentEntity1.setId(2L);
   19            studentEntity1.setName("后续更新");
   20            studentsDao.update(studentEntity1);
   21            int a=10/0;
   22            transactionManager.commit(status1);
   23        }catch (Exception e){
   24            transactionManager.rollback(status1);
   25        }
   26        //提交事务
   27        transactionManager.commit(status);
   28    }catch (Exception e){
   29        //回滚事务
   30        transactionManager.rollback(status);
   31    }
   32}

2. 通过transactionTemplate实现编程式事务

   java

    1@Override
    2public StudentEntity update(StudentEntity studentEntity) {
    3	transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    4    this.transactionTemplate.execute(new TransactionCallbackWithoutResult() {
    5        @Override
    6        protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
    7            try {
    8                studentsDao.update(studentEntity);
    9                //设置事务的传播级别
   10                transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
   11                //新开事务
   12                transactionTemplate.execute(new TransactionCallbackWithoutResult() {
   13                    @Override
   14                    protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
   15                        try {
   16                            StudentEntity studentEntity1=new StudentEntity();
   17                            BeanUtils.copyProperties(studentEntity,studentEntity1);
   18                            studentEntity1.setId(2L);
   19                            studentEntity1.setName("后续更新");
   20                            studentsDao.update(studentEntity1);
   21                        }catch(Exception e){
   22                            //标记事务为回滚
   23                            transactionStatus.setRollbackOnly();
   24                        }
   25                    }
   26                });
   27                int a=10/0;
   28            }catch (Exception e){
   29                transactionStatus.setRollbackOnly();
   30            }
   31        }
   32    });
   33}

**声明式事务：**可以将事务管理和业务代码分离，只需要通过注解或xml配置管理事务；

1. 注解方式：@EnableTransactionManagement 和 @Transactional

2. xml 配置方式

   xml

    1<?xml version="1.0" encoding="UTF-8"?>
    2<beans xmlns="http://www.springframework.org/schema/beans"
    3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    4       xmlns:tx="http://www.springframework.org/schema/tx"
    5       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
    6        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
    7        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    8
    9<!--    DataSource -->
   10    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   11        <property name="url" value="jdbc:mysql://139.186.140.120:3312/learn?characterEncoding=utf8"/>
   12        <property name="username" value="root"/>
   13        <property name="password" value="123456"/>
   14    </bean>
   15<!--    SqlSessionFactory -->
   16    <bean id="sqlSesFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
   17        <property name="dataSource" ref="dataSource"/>
   18<!--        绑定 mybatis 配置文件，也可以完全取代不绑定 -->
   19        <property name="configLocation" value="classpath:mybatis-config.xml"/>
   20        <property name="mapperLocations" value="classpath:com/lei/dao/*.xml" />
   21    </bean>
   22<!--    sqlSessionTemplate -->
   23    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
   24<!--        只能使用构造方法注入，因为该类没有 set 方法-->
   25        <constructor-arg index="0" ref="sqlSesFactory"/>
   26    </bean>
   27<!--    配置声明式事务-->
   28    <bean id="transactionManagerger" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   29        <property name="dataSource" ref="dataSource"/>
   30    </bean>
   31<!--    通过spring的aop织入事务-->
   32<!--    配置事务通知-->
   33    <tx:advice id="txAdvice" transaction-manager="transactionManagerger">
   34<!--        给哪些方法配置事务-->
   35        <tx:attributes>
   36<!--       propagation配置事务的传播特性，默认为：REQUIRED    -->
   37            <tx:method name="*" propagation="REQUIRED"/>
   38        </tx:attributes>
   39    </tx:advice>
   40<!--    配置事务切入-->
   41    <aop:config>
   42        <aop:pointcut id="txPrintcut" expression="execution(* com.lei.service.*.*(..))"/>
   43        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPrintcut"/>
   44    </aop:config>
   45</beans>

Spring 事务实现原理 ¶

@Transactional 注解仅仅配置一些与事务相关的元数据，在运行时被事务设施读取消费，并根据这些元数据来配置 bean 的事务行为。主要功能大概是：一是声明哪些方法需要参与事务，二是配置相关的属性来定制事务参与方式和运行行为

Spring 事务主要得益于 Spring AOP，使用一个事务拦截器，在方法调用前后/周围进行事务性增强（advice），来驱动事务完成

@Transactional 注解可以标注在类上，也可以标注在方法上。当在类上时，默认应用到类里的所有方法，如果此时方法上也标注了，则方法的优先级更高。注意：方法一定是public修饰的

BeanPostProcessor ¶

针对 bean 对象初始化前后需要的处理操作

对于容器中创建的每一个bean，在创建的过程中可以执行一些自定义的逻辑，就可以编写一个类，并让他实现BeanPostProcessor接口，然后将这个类注册到一个容器中。容器在创建bean的过程中，会优先创建实现了BeanPostProcessor接口的bean，然后，在创建其他bean的时候，会将创建的每一个bean作为参数，调用BeanPostProcessor的方法。而BeanPostProcessor接口的方法，即是由我们自己实现的

 1public class BeanPostProcessorDemo implements BeanPostProcessor {
 2    @Override
 3    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
 4        System.out.println("准备创建 bean："+beanName);
 5        return bean;
 6    }
 7
 8    @Override
 9    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
10        System.out.println("创建完成 bean："+beanName);
11        return bean;
12    }
13}
14
15/*
16* 准备创建 bean：helloService
17* 创建完成 bean：helloService
18* 准备创建 bean：testService
19* 创建完成 bean：testService
20*/

Spring MVC ¶

执行流程

1. 用户发送请求至前端控制器 DispatcherServlet
2. DispatcherServlet 收到请求调用处理器映射器 HandlerMapping。
3. 处理器映射器根据请求url找到具体的处理器，生成处理器执行链 HandlerExecutionChain(包括处理器对象和处理器拦截器)一并返回给 DispatcherServlet。
4. DispatcherServle t根据处理器 Handler 获取处理器适配器 HandlerAdapter 执行 HandlerAdapter 处理一系列的操作，如：参数封装，数据格式转换，数据验证等操作
5. 执行处理器 Handler(Controller，也叫页面控制器)。
6. Handler 执行完成返回 ModelAndView
7. HandlerAdapter 将 Handler 执行结果 ModelAndView 返回到 DispatcherServlet
8. DispatcherServlet 将 ModelAndView 传给 ViewReslover 视图解析器
9. ViewReslover 解析后返回具体 View
10. DispatcherServlet 对 View 进行渲染视图（即将模型数据 model 填充至视图中）
11. DispatcherServlet 响应用户

组件说明

1. DispatcherServlet：前端控制器。用户请求到达前端控制器，它就相当于 mvc 模式中的c，dispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet 的存在降低了组件之间的耦合性,系统扩展性提高。由框架实现
2. HandlerMapping：处理器映射器。HandlerMapping 负责根据用户请求的 url 找到 Handler 即处理器，springmvc 提供了不同的映射器实现不同的映射方式，根据一定的规则去查找,例如：xml 配置方式，实现接口方式，注解方式等。由框架实现
3. Handler：处理器。Handler 是继 DispatcherServlet 前端控制器的后端控制器，在 DispatcherServlet 的控制下 Handler 对具体的用户请求进行处理。由于 Handler 涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发 Handler
4. HandlAdapter：处理器适配器。通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。由框架实现
5. ModelAndView 是 springmvc 的封装对象，将 model 和 view 封装在一起
6. ViewResolver：视图解析器。ViewResolver 负责将处理结果生成 View 视图，ViewResolver 首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户
7. View：是 springmvc 的封装对象，是一个接口, springmvc 框架提供了很多的 View 视图类型，包括：jspview，pdfview,jstlView、freemarkerView、pdfView等。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面

Spring Boot 自动装配 ¶

1. @SpringBootApplication注解标识启动类

   java

    1// 标注这是一个配置类
    2@SpringBootConfiguration
    3// 启用自动配置
    4@EnableAutoConfiguration
    5// 	
    6@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    7		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    8public @interface SpringBootApplication {
    9    // ..........
   10}

2. @EnableAutoConfiguration注解启动自动装配，该注解里面导入了AutoConfigurationImportSelector自动配置导入选择器

   java

   1@AutoConfigurationPackage
   2// AutoConfigurationImportSelector 会加载classpath下所有的 META-INF/spring.factories 中配置的 bean（去重、排除、过滤）
   3@Import(AutoConfigurationImportSelector.class)
   4public @interface EnableAutoConfiguration {
   5    // .....
   6}

3. AutoConfigurationImportSelector类核心部分

   java

    1protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    2    if (!isEnabled(annotationMetadata)) {
    3        return EMPTY_ENTRY;
    4    }
    5    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    6    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    7    configurations = removeDuplicates(configurations);
    8    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    9    checkExcludedClasses(configurations, exclusions);
   10    configurations.removeAll(exclusions);
   11    configurations = getConfigurationClassFilter().filter(configurations);
   12    fireAutoConfigurationImportEvents(configurations, exclusions);
   13    return new AutoConfigurationEntry(configurations, exclusions);
   14}

bootstrap.yml 作用 ¶

bootstrap.yml 需要 SpringCloud 支持用来程序引导时执行，应用于更加早期配置信息读取。可以理解成系统级别的一些参数配置，这些参数一般是不会变动的。一旦bootStrap.yml 被加载，则内容不会被覆盖

application.yml 可以用来定义应用级别的， 应用程序特有配置信息，可以用来配置后续各个模块中需使用的公共参数等

启动上下文时，Spring Cloud 会创建一个 Bootstrap Context，作为 Spring 应用的 Application Context 的父上下文

经常用来加载配置中心的内容，一个正常的 SpringBoot 项目启动时只会去加载对应的 application.yml 文件中相关信息，bootstrap.yml 会在 SpringBoot 正常启动前创建一个父容器，通过 bootstrap.yml 中的配置加载配置中心的内容

对敏感信息进行加密 ¶

可以通过SpringBoot 提供的后置处理器来实现对加密字符的解密

1. 配置文件

   yaml

   1server:
   2  address: ENCRY(awdsawqs)

2. 对加密数据解密

   java

    1public class ConfigA implements EnvironmentPostProcessor {
    2
    3    @Override
    4    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
    5
    6        for (PropertySource<?> propertySource : environment.getPropertySources()) {
    7            // 自定义的配置
    8            if (propertySource instanceof OriginTrackedMapPropertySource) {
    9                OriginTrackedMapPropertySource source = (OriginTrackedMapPropertySource) propertySource;
   10                for (String propertyName : source.getPropertyNames()) {
   11                    Object value = source.getProperty(propertyName);
   12                    if (value instanceof String) {
   13                        if (((String) value).matches("ENCRY\\(.*\\)")) {
   14                            // 需要覆盖原有配置值的map
   15                            Map<String, Object> map = new HashMap<>();
   16                            // 加密后字符串
   17                            String s = ((String) value).replaceAll("ENCRY\\((.*)\\)", "$1");
   18                            // 解密 todo
   19                            // 解密后的字符串放入 map
   20                            map.put(propertyName, s);
   21                            // 添加到前面，覆盖
   22                            environment.getPropertySources().addFirst(new OriginTrackedMapPropertySource(propertyName, map));
   23                        }
   24                    }
   25                }
   26            }
   27        }
   28    }
   29}

3. 在 META-INF/spring.factories 中配置

   properties

   1org.springframework.boot.env.EnvironmentPostProcessor=org.lei.ch02.config.ConfigA

4. 获取配置文件信息

   java

   1public static void main(String[] args) {
   2    ApplicationContext applicationContext = SpringApplication.run(Application.class);
   3    Environment environment = applicationContext.getBean(Environment.class);
   4    String s = environment.getProperty("server.address");
   5    System.out.println(s);   // 输出 awdsawqs，对加密字符串处理成功
   6}

可以使用 jasypt 来进行加密敏感信息

Indexed 注解 ¶

spring 5.0 提供的，它可以为 Spring 的模式注解添加索引，以提升应用启动性能

在应用中使用@ComponentScan扫描 package 时，如果 package 中包含很多的类，那么 Spring 启动的时候就会变慢

提升性能的一个方案就是提供一个 Component 的候选列表，Spring 启动时直接扫描注入这些列表就行了，而不需要一个个类去扫描，再筛选出候选 Component。

需要导入下面包

1<!--   spring 5.0 提供的可以复杂应用启动时间的注解  -->
2<dependency>
3    <groupId>org.springframework</groupId>
4    <artifactId>spring-context-indexer</artifactId>
5    <version>${spring.version}</version>
6</dependency>

在编译时就会收集所有通过 @Indexed 注解表示的 java 类，然后记录下 META-INF/spring.components 文件中，那么系统在启动时只需要读取一个该文件的内容就不用遍历所有的目录了，提升启动效率

@Component 默认已经被 @Indexed 注解标注了

AOP 中通知类型 ¶

导入依赖