JAVA基础精选面试题（持续更新，一天五道，祝各位道友，早日飞升上仙）！

1.重载和重写的区别?

重载发生在一个类中，同名的方法如果有不同的参数列表（类型不同、个数不同、顺序不同）则视为重载。

重写发生在子类与父类之间，重写要求子类重写之后的方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常。

2.String 和 StringBuffer、StringBuilder 的区别是什么？

可变性：String 类中使用 final 关键字修饰字符数组来保存字符串，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串char[]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

线程安全性：String 中的对象是不可变的，也就可以理解为常量，线程安全。 StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

性能：每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

3.== 与 equals 的区别？

对于基本类型和引用类型 == 的作用效果是不同的，
基本类型：比较的是值是否相同；
引用类型：比较的是引用是否相同；
equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。

4.说说自己是怎么使用synchronized 关键字，在项目中用到了吗？

修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁。
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁修饰代码块。
指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。
双重校验锁实现对象单例（线程安全）

public class Singleton { private volatile static Singleton uniqueInstance; private Singleton() { }public static Singleton getUniqueInstance() { //先判断对象是否已经实例过，没有实例化过才进入加锁代码 if (uniqueInstance == null) { //类对象加锁 synchronized (Singleton.class) { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } } }
return uniqueInstance; }  }

5.抽象类和接口的区别是什么？

实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。

构造函数：抽象类可以有构造函数；接口不能有。

实现数量：类可以实现很多个接口；但只能继承一个抽象类【java只支持单继承】。

访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的抽象方法可以使用Public和Protected修饰，如果抽象方法修饰符为Private，则报错：The abstract method 方法名 in type Test can only set a visibility modifier, one of public or protected。
接口中除了static、final变量，不能有其他变量，而抽象类中则不一定。

设计层面：抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。

6.Collection 和 Collections 有什么区别？

Collection 是一个集合接口，它提供了对集合对象进行基本操作的通用接口方法，所有集合都是它的子类，比如 List、Set 等。
Collections 是一个包装类，包含了很多静态方法，不能被实例化，就像一个工具类，比如提供的排序方法： Collections. sort(list)

7.List、Set、Map 之间的区别是什么？

8. HashMap 和 Hashtable 有什么区别？

存储：HashMap 运行 key 和 value 为 null，而 Hashtable 不允许。
线程安全：Hashtable 是线程安全的，而 HashMap 是非线程安全的。
推荐使用：在 Hashtable 的类注释可以看到，Hashtable 是保留类不建议使用，推荐在单线程环境下使用 HashMap 替代，如果需要多线程使用则用 ConcurrentHashMap 替代。

9. 说一下 HashMap 的实现原理？

HashMap 基于 Hash 算法实现的，我们通过 put(key,value)存储，get(key)来获取。当传入 key 时，HashMap 会根据 key. hashCode() 计算出 hash 值，根据 hash 值将 value 保存在 bucket 里。
当计算出的 hash 值相同时，我们称之为 hash 冲突，HashMap 的做法是用链表和红黑树存储相同 hash 值的 value。当 hash 冲突的个数比较少时，使用链表否则使用红黑树。

10. 说一下 HashSet 的实现原理？

HashSet 是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，因此 HashSet 的实现比较简单，相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成， HashSet 不允许重复的值。

11.ArrayList和LinkedList的区别

ArrayList:基于动态数组，连续内存存储，适合下标访问（随机访问)，扩容机制:因为数组长度固定，超出长度存数据时需要新建数组，然后将老数组的数据拷贝到新数组，如果不是尾部插入数据还会涉及到元素的移动(往后复制一份，插入新元素)，使用尾插法并指定初始容量可以极大提升性能、甚至超过linkedList (需要创建大量的node对象)。

LinkedList:基于链表，可以存储在分散的内存中，适合做数据插入及删除操作，不适合查询:需要逐一遍历，遍历LinkedList必须使用iterator，不能使用for循环，因为每次for循环体内通过get(i)取得某一元素时都需要对list重新进行遍历，性能消耗极大。

12.ConcurrentHashMap原理,jdk7和jdk8版本的区别

总所周知，HashMap是非线程安全的工具类，在多线程环境下就需要一个线程安全的工具类来帮助我们实现线程安全，jdk1.5之前，我们使用HashTable，HashTable只是用synchronized同步关键字将put等大多数方法进行加锁，锁定的是整个对象，因此效率不高，jdk1.5之后，ConcurrentHashMap随着j.u.c包一起引入了JDK中，相对于HashTable，ConcurrentHashMap性能有了大幅提升，成为了线程安全的HashMap首选方案。

jdk7：
数据结构：ReentrantLock+Segment+HashEntry，一个Segment中包含了一个HashEntry数组，每个HashEntry又是一个链表结构。
元素查询：二次hash，第一次hash定位到Segment，第二次hash定位元素所在链表的头部锁：Segment分段锁，Segment继承了ReentrantLock,锁定操作的 Segment，其他Segment不受影响，并发度为Segment的个数，可以通过构造函数指定，数组扩容不影响其他Segment get方法无须加锁， volatile保证。

jdk8：
数据结构：synchronized+CAS+Node+红黑树，Node的val和next都用 volatile修饰，保证可见性查找，替换，赋值操作都使用CAS 。
锁：锁链表的head节点，不影响其他元素的读写，锁粒度更细，效率更高，扩容时，阻塞所有读写操作，并发扩容。
读操作无锁：Node的val和next使用volatile修饰，读写线程对该变量互相可见数组使用volatile修饰，保证扩容时被读线程感知。

13.哪些集合类是线程安全的？

Vector、Hashtable、Stack 都是线程安全的，而像 HashMap 则是非线程安全的，不过在JDK1.5之后随着 Java.util.concurrent 并发包的出现，它们也有了自己对应的线程安全类，比如 HashMap 对应的线程安全类就是 ConcurrentHashMap.

14.创建线程有哪几种方式？

创建线程有三种方式：
继承 Thread 重写 run 方法；
实现 Runnable 接口；
实现 Callable 接口。

15.说一下 runnable 和 callable有什么区别？

runnable 没有返回值，callable 可以拿到有返回值，
callable 可以看作是 runnable 的补充。

16.线程有哪些状态？

当线程对象对创建后，即进入了新建状态（NEW），;
当调用线程对象的start()方法（t.start();），线程即进入就绪状态（Runnable）；
CPU获取到时间片，进入到运行状态（Running）;
当线程调用 wait()或者sleep()时,进入阻塞状态（Blocked），当休眠时间结束后，或者调用notify或 notifyAll时会重新进入就绪状态（Runnable）,再重新获取时间片，进入运行状态，线程执行完了或者因异常退出了run()方法，该线程结束生命周期，进入终结状态(Dead)。

17.sleep() 和wait() 有什么区别？

类的不同：sleep() 来自 Thread，wait() 来自 Object。
释放锁：sleep() 不释放锁；wait() 释放锁。
用法不同 ： sleep() 时间到会自动恢复； wait() 可以使用 notify()/notifyAll()直接唤醒。

18.3.notify()和 notifyAll()有什么区别？

notifyAll()会唤醒所有的线程，notify()之后唤醒一个线程。
notifyAll() 调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。
而 notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制。

19.线程的 run() 和 start() 有什么区别？

start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。
run() 可以重复调用，而 start() 只能调用一次。

20.说一说几种常见的线程池及适用场景？

FixedThreadPool：可重用固定线程数的线程池。（适用于负载比较重的服务器）
SingleThreadExecutor：只会创建一个线程执行任务。（适用于需要保证顺序执行各个任务；并且在任意时间点，没有多线程活动的场景。）
CachedThreadPool：是一个会根据需要调整线程数量的线程池。（大小无界，适用于执行很多的短期异步任务的小程序，或负载较轻的服务器）
ScheduledThreadPool：继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。使用DelayQueue作为任务队列。

21.线程池中 submit() 和 execute() 方法有什么区别？

execute()：只能执行 Runnable 类型的任务。
submit()：可以执行 Runnable 和 Callable 类型的任务。
Callable 类型的任务可以获取执行的返回值，而 Runnable 执行无返回值。

22.在 Java 程序中怎么保证多线程的运行安全？

方法一：使用安全类，比如 Java. util. concurrent 下的类。
方法二：使用自动锁 synchronized。
方法三：使用手动锁 Lock。

23.什么是死锁？

当线程 A 持有独占锁 a，并尝试去获取独占锁 b 的同时，
线程 B 持有独占锁 b，并尝试获取独占锁 a 的情况下，
就会发生 AB 两个线程由于互相持有对方需要的锁，而发生的阻塞现象，我们称为死锁。

24.怎么防止死锁？

1.尽量使用 tryLock(long timeout, TimeUnit unit)的方法 (ReentrantLock、 ReentrantReadWriteLock)，
设置超时时间，超时可以退出防止死锁。
2.尽量使用 Java. util. concurrent 并发类代替自己手写锁。
3.尽量降低锁的使用粒度，尽量不要几个功能用同一把锁。
4.尽量减少同步的代码块。

25.ThreadLocal 是什么？有哪些使用场景？

ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
ThreadLocal 的经典使用场景是数据库连接和 session 管理等。

26.synchronized 和 Lock 有什么区别？

1.synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。
2.synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock 需要自己加锁和释放锁，如果使用不当没有 unLock() 去释放锁就会造成死锁。
3.通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

27.什么是 Java 序列化？什么情况下需要序列化？

Java 序列化是为了保存各种对象在内存中的状态，并且可以把保存的对象状态再读出来。
以下情况需要使用 Java 序列化：
1.想把的内存中的对象状态保存到一个文件中或者数据库中时候；
2.想用套接字在网络上传送对象的时候；
3.想通过 RMI（远程方法调用）传输对象的时候。

28.动态代理是什么？有哪些应用？

动态代理是运行时动态生成代理类。
应用: 动态代理的应用有 spring aop、rpc， Java 注解对象获取等。

29.怎么实现动态代理？

JDK 原生动态代理和 cglib 动态代理。JDK 原生动态代理是基于接口实现的，而 cglib 是基于继承当前类的子类实现的。

30.为什么要使用克隆？

克隆的对象可能包含一些已经修改过的属性，而 new 出来的对象的属性都还是初始化时候的值，
所以当需要一个新的对象来保存当前对象的“状态”就靠克隆方法了。

关于redis的面试题

31.Redis 是什么？都有哪些使用场景？

Redis 是一个使用 C 语言开发的高速缓存数据库。
Redis 使用场景：
记录帖子点赞数、点击数、评论数；
缓存近期热点数据；
记录用户会话信息。

32. Redis 有哪些功能？

数据缓存功能
分布式锁的功能
支持数据持久化
解决分布式会话

33.什么是缓存穿透？怎么解决？

缓存穿透：指查询一个一定不存在的数据，由于缓存是不命中时需要从数据库查询，查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，造成缓存穿透。
解决:

最常见的则是采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被这个bitmap拦截掉，从而避免了对底层存储系统的查询压力。
2.另外也有一个更为简单粗暴的方法（我们采用的就是这种），如果一个查询返回的数据为空（不管是数据不存在，还是系统故障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。

34.什么是缓存击穿？如何解决？

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。
缓存击穿解决方案: 1.设置永久不过期。【这种只适合】
2.使用互斥锁(mutex key)业界比较常用的做法，是使用mutex。简单地来说，就是在缓存失效的时候（判断拿出来的值为空），不是立即去load db，而是先使用缓存工具的某些带成功操作返回值的操作（比如Redis的 SETNX或者Memcache的ADD）去set一个mutex key，当操作返回成功时，再进行load db的操作并回设缓存；否则，就重试整个get缓存的方法。
代码如下:

public String get(key) {  String value = redis.get(key);  if (value == null) {
//代表缓存值过期
//设置3min的超时，防止del操作失败的时候，下次缓存过 期一直不能load db  if (redis.setnx(key_mutex, 1, 3 * 60) == 1) {
//代表设置成功  value = db.get(key);  redis.set(key, value, expire_secs);  redis.del(key_mutex);  } else {
//这个时候代表同时候的其他线程已经 load db并回设到缓存了，这时候重试获取缓存值即可  sleep(50);  get(key); //重试  }  } else { return value;  }  }

35. 什么是缓存雪崩？如何解决？

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

解决方案：
1.缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
2.如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
3.设置热点数据永远不过期。

36 .Redis 支持的数据类型有哪些？

Redis 支持的数据类型：string（字符串）、list（列表）、hash（字典）、set（集合）、zset（有序集合）。

37.怎么保证缓存和数据库数据的一致性？

合理设置缓存的过期时间。
新增、更改、删除数据库操作时同步更新 Redis，可以使用事物机制来保证数据的一致性。

38.Redis 持久化有几种方式？

Redis 的持久化有两种方式，或者说有两种策略：
RDB（Redis Database）：指定的时间间隔能对你的数据进行快照存储。
AOF（Append Only File）：每一个收到的写命令都通过 write函数追加到文件中。

39.Redis 怎么实现分布式锁？

Redis 分布式锁其实就是在系统里面占一个“坑”，其他程序也要占“坑”的时候，占用成功了就可以继续执行，失败了就只能放弃或稍后重试。占坑一般使用 setnx(set if not exists)指令，只允许被一个程序占有，使用完调用 del 释放锁。

40.Redis 淘汰策略有哪些？

volatile-lru：从已设置过期时间的数据集（server. db[i]. expires）中挑选最近最少使用的数据淘汰。
volatile-ttl：从已设置过期时间的数据集（server. db[i]. expires）中挑选将要过期的数据淘汰。
volatile-random：从已设置过期时间的数据集（server. db[i]. expires）中任意选择数据淘汰。
allkeys-lru：从数据集（server. db[i]. dict）中挑选最近最少使用的数据淘汰。
allkeys-random：从数据集（server. db[i]. dict）中任意选择数据淘汰。
no-enviction（驱逐）：禁止驱逐数据。

41.session 和 cookie 有什么区别？

1.存储位置不同：session 存储在服务器端；cookie 存储在浏览器端。
2.安全性不同：cookie 安全性一般，在浏览器存储，可以被伪造和修改。
3.容量和个数限制：cookie 有容量限制，每个站点下的 cookie 也有个数限制。
4.存储的多样性：session 可以存储在 Redis 中、数据库中、应用程序中；而 cookie 只能存储在浏览器中。

42.如何避免 SQL 注入？

1.使用预处理 PreparedStatement。
2.使用正则表达式过滤掉字符中的特殊字符。

43.throw 和 throws 的区别？

throw：是真实抛出一个异常。
throws：是声明可能会抛出一个异常。

44.final、finally、finalize 有什么区别？

final：是修饰符，如果修饰类，此类不能被继承；如果修饰方法和变量，则表示此方法和此变量不能在被改变，只能使用。

finally：是 try{} catch{} finally{} 最后一部分，表示不论发生任何情况都会执行，finally 部分可以省略，但如果 finally 部分存在，则一定会执行 finally 里面的代码。

finalize：是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法。

45.常见的异常类有哪些？

NullPointerException 空指针异常
ClassNotFoundException 指定类不存在
NumberFormatException 字符串转换为数字异常
IndexOutOfBoundsException 数组下标越界异常
ClassCastException 数据类型转换异常
FileNotFoundException 文件未找到异常
NoSuchMethodException 方法不存在异常
SocketException Socket 异常

46.说一下你熟悉的设计模式？

1.单例模式：保证被创建一次，节省系统开销。
2.工厂模式（简单工厂、抽象工厂）：解耦代码。
3.观察者模式：定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有的依赖者都会收到通知并自动更新。
4.外观模式：提供一个统一的接口，用来访问子系统中的一群接口，外观定义了一个高层的接口，让子系统更容易使用。
5.模版方法模式:定义了一个算法的骨架，而将一些步骤延迟到子类中，模版方法使得子类可以在不改变算法结构的情况下，重新定义算法的步骤。
6.代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用

47.spring框架使用了那些设计模式

spring的bean的创建默认使用单例模式
spring中获取bean对象通过的是工厂模式
spring的aop采用的是动态代理模式
在各种BeanFactory以及ApplicationContext实现中也都用到模板模式；

48.为什么要使用 spring？

1.spring 提供 ioc 技术，容器会帮你管理依赖的对象，从而不需要自己创建和管理依赖对象了，更轻松的实现了程序的解耦。
2. spring 提供了事务支持，使得事务操作变的更加方便。
3.spring 提供了面向切片编程，这样可以更方便的处理某一类的问题。
4.更方便的框架集成，spring 可以很方便的集成其他框架，比如 MyBatis、 hibernate 等。

49.spring 常用的注入方式有哪些？

1.setter 属性注入
2.构造方法注入
3.注解方式注入

50.spring 事务实现方式有哪些？

声明式事务:声明式事务也有两种实现方式，基于xml 配置文件的方式和注解方式（在类上添加 @Transaction 注解）
编码方式：提供编码的形式管理和维护事务。

51.并发事务会带来哪些问题?

脏读（Dirty read）: 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。
丢失修改（Lost to modify）: 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。
不可重复读（Unrepeatableread）: 指在一个事务内多次读同一数据。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。这就发生了在一个事务内两次读到的数据是不一样的情况，因此称为不可重复读。
幻读（Phantom read）: 幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录，就好像发生了幻觉一样，所以称为幻读。

52.事务的隔离级别有哪些?

READ-UNCOMMITTED(读取未提交)：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。
READ-COMMITTED(读取已提交)：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生。
REPEATABLE-READ(可重复读)：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
SERIALIZABLE(可串行化)：最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。

53.说一下 spring mvc 运行流程？

1.spring mvc 先将请求发送给 DispatcherServlet。
2.DispatcherServlet 查询一个或多个 HandlerMapping，找到处理请求的 Controller。
3.DispatcherServlet 再把请求提交到对应的 Controller。
4.Controller 进行业务逻辑处理后，会返回一个 ModelAndView。
5. Dispathcher 查询一个或多个 ViewResolver 视图解析器，找到 ModelAndView 对象指定的视图对象。
6. 视图对象负责渲染返回给客户端。

54.spring mvc 有哪些组件？

前置控制器 DispatcherServlet。
映射控制器 HandlerMapping。
处理器 Controller。
模型和视图 ModelAndView。
视图解析器 ViewResolver。

55.springmvc常见的注解

@Controller 作用在类上表示该类为控制层类
@RequestMapping用来处理请求地址映射的注解
@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出uri模板中的变量作为参数

@requestParam主要用于在SpringMVC后台控制层获取参数值
@ResponseBody该注解用于将Controller的方法返回的对象转换为json 格式
@RequestBody用于接收前端传来的json实体，接收参数也是对应的实体

56.MyBatis 中 #{}和 ${}的区别是什么？

#{}是预编译处理，${}是字符替换。在使用 #{}时，MyBatis 会将 SQL 中的 #{} 替换成“?”，配合 PreparedStatement 的 set 方法赋值，这样可以有效的防止 SQL 注入，保证程序的运行安全。

57.什么地方使用${}

的作用是字符拼接，不能防止 s q l 注入 , 当使用的作用是字符拼接，不能防止sql注入,当使用的作用是字符拼接，不能防止sql注入,当使用{}参数作为字段名或表名时使用。
比如: select * from t a b l e N a m e 比如我要用 {tableName} 比如我要用 tableName比如我要用{}在MyBatis的sql中拼接排序类型的时候

58.当实体类的属性名和表中的字段名不一致如何处理

通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。
通过类映射字段名和实体类属性名的一一对应的关系

59.MyBatis如何实现一对多

再resultMap中使用collection标签

60.ResultType和ResultMap的区别

1、resultmap：resultMap如果查询出来的列名和pojo的属性名不一致，通过定义一个resultMap对列名和pojo属性名之间作一个映射关系。
2、resulttype：resultType使用resultType进行输出映射，只有查询出来的列名和pojo中的属性名一致，该列才可以映射成功。

数据库

61. 连接查询（必会）

1.左连接（左外连接）以左表为基准进行查询,左表数据会全部显示出来,右表如果和左表匹配的数据则显示相应字段的数据,如果不匹配,则显示为 NULL;
2.右连接（右外连接）以右表为基准进行查询,右表数据会全部显示出来,右表如果和左表匹配的数据则显示相应字段的数据,如果不匹配,则显示为 NULL
3.内连接指连接结果仅包含符合连接条件的行，参与连接的两个表都应该符合连接条件。

62. 聚合函数（必会）

COUNT：统计行数量
SUM：获取单个列的合计值
AVG：计算某个列的平均值
MAX：计算列的最大值
MIN：计算列的最小值

63. 数据库三范式(必会)

第一范式：1NF 原子性，列或者字段不能再分，要求属性具有原子性，不可再分解；
第二范式：2NF 唯一性，一张表只说一件事，是对记录的惟一性约束，要求记录有惟一标识，
第三范式：3NF 直接性，数据不能存在传递关系，即每个属性都跟主键有直接关系，而不是间接关系。

64. 事务的特性（必会）

原子性：即不可分割性，事务要么全部被执行，要么就全部不被执行。
一致性或可串性。事务的执行使得数据库从一种正确状态转换成另一种正确状态
隔离性。在事务正确提交之前，不允许把该事务对数据的任何改变提供给任何其他事务
持久性。事务正确提交后，其结果将永久保存在数据库中，即使在事务提交后有了其它故障，事务的处理结果也会得到保存。

65. 事务并发带来哪些问题

在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务（多个用户对同一数据进行操作）。
并发虽然是必须的，但可能会导致以下的问题。
脏读（Dirty read）: 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。

丢失修改（Lost to modify）: 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。例如：事务1读取某表中的数据A=20，事务2也读取 A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务 1的修改被丢失。

不可重复读（Unrepeatableread）: 指在一个事务内多次读同一数据。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。这就发生了在一个事务内两次读到的数据是不一样的情况，因此称为不可重复读。

幻读（Phantom read）: 幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录，就好像发生了幻觉一样，所以称为幻读。

不可重复读和幻读区别：不可重复读的重点是修改，比如多次读取一条记录发现其中某些列的值被修改，幻读的重点在于新增或者删除比如多次读取一条记录发现记录增多或减少了。

66. 事务隔离级别有哪些

67. MySQL的默认隔离级别

MySQL InnoDB 存储引擎的默认支持的隔离级别是 REPEATABLE-READ （可重读）。
我们可以通过 SELECT @@tx_isolation; 命令来查看

68. 数据库锁（必会）行级锁和表级锁

1. 主要是针对锁粒度划分的，一般分为：行锁、表锁、库锁
行锁：访问数据库的时候，锁定整个行数据，防止并发错误。
表锁：访问数据库的时候，锁定整个表数据，防止并发错误。

2. 行锁和表锁的区别
表锁：开销小，加锁快，不会出现死锁；锁定力度大，发生锁冲突概率高，并发度最低
行锁：开销大，加锁慢，会出现死锁；锁定粒度小，发生锁冲突的概率低，并发度高

69. 悲观锁和乐观锁

(1)悲观锁：顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会 block 直到它拿到锁。
传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁

(2)乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没
有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于 write_condition 机制的其实都是提供的乐观锁。

存储引擎（高薪常问）

70.数据库存储引擎概述

数据库存储引擎是数据库底层软件组织，数据库管理系统（DBMS）使用数据引擎进行创建、查询、更新和删除数据。不同的存储引擎提供不同的存储机制、索引技巧、锁定水平等功能，使用不同的存储引擎，还可以获得特定的功能。现在许多不同的数据库管理系统都支持多种不同的数据引擎。
存储引擎主要有：

MyIsam , 2. InnoDB, 3. Memory, 4. Archive, 5. Federated 。

71. MyISAM 和 InnoDB 的区别

lnnoDB引擎: innoDB引擎提供了对数据库acid事务的支持，并且还提供了行级锁和外键的约束，它的设计的目标就是处理大数据容量的数据库系统。MySQL运行的时候，innoDB 会在内存中建立缓冲池，用于缓冲数据和索引。但是该引擎是不支持全文搜索，同时启动也比较的慢，它是不会保存表的行数的，所以当进行select count() from table指令的时候，需要进行扫描全表。由于锁的粒度小，写操作是不会锁定全表的, 所以在并发度较高的场景下使用会提升效率的。
MyIASM引擎: MySQL的默认引擎，但不提供事务的支持，也不支持行级锁和外键。因此当执行插入和更新语句时，即执行写操作的时候需要锁定这个表，所以会导致效率会降低。不过和InnoDB不同的是， MyIASM引擎是保存了表的行数，于是当进行select count() from table语句时，可以直接的读取已经保存的值而不需要进行扫描全表。所以，如果表的读操作远远多于写操作时，并且不需要事务的支持的，可以将MyIASM作为数据库引擎的首选。

72. 索引的概念和优点（了解）

概念：索引存储在内存中，为服务器存储引擎为了快速找到记录的一种数据结构。索引的主要作用是加快数据查找速度，提高数据库的性能。
优点：
(1) 创建唯一性索引，保证数据库表中每一行数据的唯一性
(2) 大大加快数据的检索速度，这也是创建索引的最主要的原因
(3) 加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
(4) 在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。

73. 索引的分类（必会）

普通索引：最基本的索引，它没有任何限制。
唯一索引：与普通索引类似，不同的就是索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。
主键索引：它是一种特殊的唯一索引，用于唯一标识数据表中的某一条记录，不允许有空值，一般用 primary key 来约束。
联合索引（又叫复合索引）：多个字段上建立的索引，能够加速复合查询条件的检索。
全文索引：老版本 MySQL 自带的全文索引只能用于数据库引擎为 MyISAM 的数据表，新版本 MySQL 5.6 的 InnoDB 支持全文索引。默认 MySQL 不支持中文全文检索，可以通过扩展 MySQL，添加中文全文检索或为中文内容表提供一个对应的英文索引表的方式来支持中文。

74.索引的底层实现原理（高薪常问）

索引是满足某种特定查找算法的数据结构，而这些数据结构会以某种方式指向数据，从而实现高效查找数据。具体来说MySQL中的索引，不同的数据引擎实现有所不同，但目前主流的数据库引擎的索引都是B+树实现的，B+树的搜索效率，可以到达二分法的性能，找到数据区域之后就找到了完整的数据结构了，所有索引的性能也是更好的。

75 .B+树的特点和优势（了解）

B+树的特征：
1.有k个子树的中间节点包含有k个元素（B树中是k-1个元素），每个元素不保存数据，只用来索引，所有数据都保存在叶子节点。
2.所有的叶子结点中包含了全部元素的信息，及指向含这些元素记录的指针，且叶子结点本身依关键字的大小自小而大顺序链接。
3.所有的中间节点元素都同时存在于子节点，在子节点元素中是最大（或最小）元素。

B+树的优势：
1.单一节点存储更多的元素，使得查询的IO次数更少。
2.所有查询都要查找到叶子节点，查询性能稳定。
3.所有叶子节点形成有序链表，便于范围查询。

76. 怎么验证MySQL的索引是否满足需求（必会）

使用explain查看SQL是如何执行查询语句的，从而分析你的索引是否满足需求。
explain语法: explain select * from table where type=1

77. 如何避免索引失效（高薪常问）

范围查询, 右边的列不能使用索引, 否则右边的索引也会失效
不要在索引上使用运算, 否则索引也会失效
字符串不加引号, 造成索引失效.
尽量使用覆盖索引, 避免 select *, 这样能提高查询效率.
or 关键字连接用 or 分割开的条件, 如果 or 前面的列有索引, or 后面的列没有索引, 那么查询的时候前后索引都会失效如果一定要用 or 查询, 可以考虑下 or 连接的条件列都加索引, 这样就不会失效了。

优化（高薪常问）

78. MySQL问题排查都有哪些手段

使用show processlist命令查看当前所有连接信息。
使用explain命令查询SQL语句执行计划。
开启慢查询日志，查看慢查询的SQL。

79. 说说对 SQL 语句优化有哪些方法？

Where 子句中：where 表之间的连接必须写在其他 Where 条件之前，那些可以过滤掉最大数量记录的条件必须写在 Where 子句的末尾.HAVING 最后。
用 EXISTS 替代 IN、用 NOT EXISTS 替代 NOT IN。
避免在索引列上使用计算
避免在索引列上使用 IS NULL 和 IS NOT NULL
对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描
应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描

80.如何做MySQL的性能优化

为搜索字段创建索引。
避免使用select *，
列出需要查询的字段。垂直分割分表。
选择正确的存储引擎。

81.大表如何优化

当MySQL单表记录数过大时，数据库的CRUD性能会明显下降，一些常见的优化措施如下：
限定数据的范围
务必禁止不带任何限制数据范围条件的查询语句。比如：我们当用户在查询订单历史的时候，我们可以控制在一个月的范围内；
读/写分离
经典的数据库拆分方案，主库负责写，从库负责读；
水平分表
保持数据表结构不变，通过某种策略存储数据分片。这样每一片数据分散到不同的表或者库中，达到了分布式的目的。水平拆分可以支撑非常大的数据量。水平拆分是指数据表行的拆分，表的行数超过200万行时，就会变慢，这时可以把一张的表的数据拆成多张表来存放。举个例子：我们可以将用户信息表拆分成多个用户信息表，这样就可以避免单一表数据量过大对性能造成影响。

82.分库分表之后,id 主键如何处理

因为要是分成多个表之后，每个表都是从 1 开始累加，这样是不对的，我们需要一个全局唯一的 id 来支持。
生成全局 id 有下面这几种方式：
**UUID：**不适合作为主键，因为太长了，并且无序不可读，查询效率低。比较适合用于生成唯一的名字的标示比如文件的名字。
数据库自增 id : 两台数据库分别设置不同步长，生成不重复ID的策略来实现高可用。这种方式生成的 id 有序，但是需要独立部署数据库实例，成本高，还会有性能瓶颈。
利用 redis 生成 id : 性能比较好，灵活方便，不依赖于数据库。但是，引入了新的组件造成系统更加复杂，可用性降低，编码更加复杂，增加了系统成本。
Twitter的snowflake算法：

83.数据库实际场景题

一个6亿的表a，一个3亿的表b，通过外间tid关联，
你如何最快的查询出满足条件的第50000到第50200中的这200条数据记录。
1、如果A表TID是自增长,并且是连续的,B表的ID为索引

select * from a,b where a.tid = b.id and a.tid>500000 limit 200;

2、如果A表的TID不是连续的,那么就需要使用覆盖索引.TID要么是主键, 要么是辅助索引,B表ID也需要有索引。

select * from b , (select tid from a limit 50000,200) a where b.id = a .t id;

存储过程（了解）

84. 存储过程概念（了解）

一组为了完成特定功能的 SQL 语句集，存储在数据库中，经过第一次编译后再次调用不需要再次编译，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程是数据库中的一个重要对象。

85. 存储过程的语法

CREATE PROCEDURE存储过程名（）
BEGIN ＜存储过程体＞END;

86.存储过程优化思路

尽量利用一些 sql 语句来替代一些小循环，例如聚合函数，求平均函数等。
中间结果存放于临时表，加索引。
少使用游标。 sql 是个集合语言，对于集合运算具有较高性能。而 cursors 是过程运算。比如对一个 100 万行的数据进行查询。游标需要读表 100 万次，而不使用游标则只需要少量几次读取。
事务越短越好。 sqlserver 支持并发操作。如果事务过多过长，或者隔离级别过高，都会造成并发操作的阻塞，死锁。导致查询极慢， cpu 占用率极低。
使用 try-catch 处理错误异常。 6. 查找语句尽量不要放在循环内。

87.什么是 spring boot以及作用？

spring boot 是为 spring 服务的，是用来简化新 spring 应用的初始搭建以及开发过程的。
作用: 1.配置简单
2.独立运行
3.自动装配
4.无代码生成和 xml 配置
5.提供应用监控
6.易上手
7.提升开发效率

88.spring boot 核心配置文件是什么？

spring boot 核心的两个配置文件：

bootstrap (. yml 或者 . properties)：boostrap 由父 ApplicationContext 加载的，比 applicaton 优先加载，且 boostrap 里面的属性不能被覆盖；
2.application (. yml 或者 . properties)：用于 spring boot 项目的自动化配置。

89.springboot自动装配原理

Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作。

里面有一个main方法运行了一个run()方法，在run方法中必须要传入一个被@SpringBootApplication注解的类。 @SpringBootApplication包含@EnableAutoConfiguration该注解，
@EnableAutoConfiguration开启自动配置功能，
在 @EnableAutoConfiguration中包含 @Import({AutoConfigurationImportSelector.class})注解，
该注解需要导入AutoConfigurationImportSelector自动配置选择器类，
该类会自动装载一些自动配置类。而这些配置类会完成相应的自动装配。

90.什么是 spring cloud？

spring cloud 是一系列框架的有序集合。
它利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 spring boot 的开发风格做到一键启动和部署。

91.spring cloud 的核心组件有哪些？

1.nacos：服务注册于发现。
2.Feign：基于动态代理机制，根据注解和选择的机器，拼接请求 url 地址，发起请求。
3. Ribbon：实现负载均衡，从一个服务的多台机器中选择一台。
4. Sentinel：提供了流量控制、熔断降级、系统负载保护等多个维度来保障服务之间的稳定性。
5. Gateway：网关管理，由 gateway 网关转发请求给对应的服务。

92.Spring的IoC理解：

（1）什么是IOC： IOC，Inversion of Control，控制反转，指将对象的控制权转移给 Spring框架，由 Spring 来负责控制对象的生命周期（比如创建、销毁）和对象间的依赖关系。
（2）什么是DI： IoC 的一个重点就是在程序运行时，动态的向某个对象提供它所需要的其他对象，这一点是通过DI（Dependency Injection，依赖注入）来实现的，即应用程序在运行时依赖 IoC 容器来动态注入对象所需要的外部依赖。而 Spring 的 DI 具体就是通过反射实现注入的，反射允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性。
（3）IoC的原理： Spring 的 IoC 的实现原理就是工厂模式加反射机制。

93.Spring的AOP理解：

OOP面向对象，允许开发者定义纵向的关系，但并不适用于定义横向的关系，会导致大量代码的重复，而不利于各个模块的重用。

AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。

94.BeanFactory和ApplicationContext有什么区别？

BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。
（1）BeanFactory是Spring里面最底层的接口，是IoC的核心，定义了 IoC的基本功能，ApplicationContext接口作为BeanFactory的子类，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能。
（2）BeanFactroy采用的是延迟加载形式来注入Bean的，只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。 ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。
（3）BeanFactory通常以编程的方式创建，ApplicationCotext还能以声明的方式创建。

95…Spring通知（Advice）有哪些类型？

（1）前置通知（Before Advice）：在连接点（Join point）之前执行的通知。
（2）后置通知（After Advice）：当连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
（3）环绕通知（Around Advice）：包围一个连接点的通知，这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也可以选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。
（4）返回后通知（AfterReturning Advice）：在连接点正常完成后执行的通知（如果连接点抛出异常，则不执行）
（5）抛出异常后通知（AfterThrowing advice）：在方法抛出异常退出时执行的通知

96. Spring中bean的作用域：

（1）singleton：默认作用域，单例bean，每个容器中只有一个bean的实例。
（2）prototype：为每一个bean请求创建一个实例。
（3）request：为每一个request请求创建一个实例，在请求完成以后， bean会失效并被垃圾回收器回收。
（4）session：与request范围类似，同一个session会话共享一个实例，不同会话使用不同的实例。
（5）global-session：全局作用域，所有会话共享一个实例。如果想要声明让所有会话共享的存储变量的话，那么这全局变量需要存储在global- session中。

97.Spring框架中的Bean是线程安全的么？如果线程不安全，那么如何处理？

Spring容器本身并没有提供Bean的线程安全策略，因此可以说Spring
容器中的Bean本身不具备线程安全的特性，但是具体情况还是要结合
Bean的作用域来讨论。
（1）对于prototype作用域的Bean，每次都创建一个新对象，也就是
线程之间不存在Bean共享，因此不会有线程安全问题。
（2）对于singleton作用域的Bean，所有的线程都共享一个单例实例
的Bean，因此是存在线程安全问题的。但是如果单例Bean是一个无状
态Bean，也就是线程中的操作不会对Bean的成员执行查询以外的操
作，那么这个单例Bean是线程安全的。比如Controller类、Service类和Dao等，这些Bean大多是无状态的，只关注于方法本身。

对于有状态的bean（比如Model和View），就需要自行保证线程安
全，最浅显的解决办法就是将有状态的bean的作用域由“singleton”改为“prototype”。
也可以采用ThreadLocal解决线程安全问题，为每个线程提供一个独立
的变量副本，不同线程只操作自己线程的副本变量。

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。同步机制采用了“时间换空间”的方式，仅提供一份变量，不同的线程在访问前需要获取锁，没获得锁的线程则需要排队。而 ThreadLocal采用了“空间换时间”的方式。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。

98.Spring基于xml注入bean的几种方式：

1.set()方法注入；
2.构造器注入：①通过index设置参数的位置；②通过type设置参数类型；
3.静态工厂注入；
4.实例工厂；

99.Spring的自动装配：

在spring中，使用autowire来配置自动装载模式，对象无需自己查找
或创建与其关联的其他对象，由容器负责把需要相互协作的对象引用
赋予各个对象。
（1）在Spring框架xml配置中共有5种自动装配：
no：默认的方式是不进行自动装配的，通过手工设置ref属性来进行装
配bean。
byName：通过bean的名称进行自动装配，如果一个bean的
property 与另一bean 的name 相同，就进行自动装配。
byType：通过参数的数据类型进行自动装配。
constructor：利用构造函数进行装配，并且构造函数的参数通过
byType进行装配。
autodetect：自动探测，如果有构造方法，通过 construct的方式自动
装配，否则使用 byType的方式自动装配。
（2）基于注解的自动装配方式：
使用@Autowired、@Resource注解来自动装配指定的bean。

100. @Autowired和@Resource之间的区别.

(1) @Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false）。
(2) @Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入。

101 .说一下Spring的事务传播行为.

spring事务的传播行为说的是，当多个事务同时存在的时候，spring如何处理这些事务的行为。
① PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。
② PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。
③ PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。
④ PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。
⑤ PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
⑥ PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
⑦ PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则按REQUIRED属性执行。
mybatis面试题

102.通常一个mapper.xml文件，都会对应一个Dao接口，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？

Mapper 接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Mapper接口生成代理对象 MappedProxy，代理对象会拦截接口方法，根据类的全限定名+方法名，唯一定位到一个MapperStatement并调用执行器执行所代表的sql，然后将sql执行结果返回。

103.Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？

Mybatis仅支持association关联对象和collection关联集合对象的延迟加载，association指的就是一对一，collection指的就是一对多查询。在Mybatis配置文件中，可以配置是否启用延迟加载 lazyLoadingEnabled=true|false。
延迟加载的基本原理是，使用CGLIB创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用a.getB().getName()，拦截器invoke()方法发现a.getB()是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调用a.setB(b)，于是a 的对象b属性就有值了，接着完成a.getB().getName()方法的调用。

104.Mybatis的一级、二级缓存:

（1）一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认打开一级缓存。
（2）二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache， HashMap 存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态),可在它的映射文件中配置；
（3）对于缓存数据更新机制，当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了C/U/D 操作后，默认该作用域下所有 select 中的缓存将被 clear 掉并重新更新，如果开启了二级缓存，则只根据配置判断是否刷新。

105.Xml映射文件中，除了常见的select|insert|updae|delete标签外，还有哪些标签？

106.在mapper中如何传递多个参数?

（1）第一种： //DAO层的函数 Public UserselectUser(String name,String area); //对应的xml,#{0}代表接收的是dao层中的第一个参数，#{1}代表dao层中第二参数，更多参数一致往后加即可。

<select id="selectUser"resultMap="BaseResultMap">
select * fromuser_user_t whereuser_name = #{0} anduser_area=#{1}
</select>

（2）第二种：使用 @param 注解:

public interface usermapper {
user selectuser(@param(“username”) string username,@param(“hashedpassword”) string hashedpassword);
}

然后,就可以在xml像下面这样使用(推荐封装为一个map,作为单个参数传递给mapper):

 <select id=”selectuser” resulttype=”user”> select id, username, hashedpassword from some_table where username = #{username} and hashedpassword = #{hashedpassword} </select>

（3）第三种：多个参数封装成map try{ //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的 SQL //由于我们的参数超过了两个，而方法中只有一个Object参数收集，因此我们使用Map集合来装载我们的参数

Map<String, Object> map = new HashMap(); map.put("start", start);
map.put("end", end); return sqlSession.selectList("StudentID.pagination", map); }catch(Exception e){ e.printStackTrace(); sqlSession.rollback(); throw e; } finally{ MybatisUtil.closeSqlSession();}

107. MySQL 的内连接、左连接、右连接有什么区别？

内连接关键字：inner join；左连接：left join；右连接：right join。内连接是把匹配的关联数据显示出来；左连接是左边的表全部显示出来，右边的表显示出符合条件的数据；右连接正好相反.

108.索引的优点和缺点—查询频率高的字段

优势

类似于书籍的目录索引，提高数据检索的效率，降低数据库的IO成本。
通过索引列对数据进行排序，降低数据排序的成本，降低CPU的消耗。
劣势
1 实际上索引也是一张表，该表中保存了主键与索引字段，并指向表的记录，所以索引列也是要占用空间的。
2 虽然索引大大提高了查询效率，同时却也降低更新表的速度，如对表进行INSERT、UPDATE、DELETE。因为更新表时，MySQL 不仅要保存数据，还要保存一下索引文件每次更新添加了索引列的字段，都会调整因为更新所带来的键值变化后的索引信息。

109.B+树的特点和作用

B-树简介
https://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw==&mid=2653190965&idx=1&sn=53f78fa037386f85531832cd5322d2a0&chksm=8c9909efbbee80f90512f0c36356c31cc74c388c46388dc2317d43c8f8597298f233ca9c29e9&scene=21#wechat_redirect

什么是B+树
https://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw==&mid=2653191027&idx=1&sn=4ba22e3ec8bd149f69fc0aba72e4347e&chksm=8c9909a9bbee80bfa1d8497ff0525df130414c1731b5aa5287bf16ea1cf86c8d8e6f20782184&scene=21#wechat_redirect

110.什么是聚集索引和非聚集索引。

在数据库的聚集索引（Clustered Index）中，叶子节点直接包含卫星数据。
在非聚集索引（NonClustered Index）中，叶子节点带有指向卫星数据的指针。

111.什么是最左前缀法则以及如何设计最左法则。

MySQL中的索引可以以一定顺序引用多列，这种索引叫作联合索引。如User 表的name和city加联合索引就是(name,city)，而最左前缀原则指的是，如果查询的时候查询条件精确匹配索引的左边连续一列或几列，则此列就可以被用到。
在创建联合索引时，索引字段的顺序需要考虑字段值去重之后的个数，较多的放前面。

112.说一下 MySQL 常用的引擎？

InnoDB支持事务, MyISAM不支持
InnoDB支持行级锁, MyISAM支持表级锁.
InnoDB支持外键, MyISAM不支持. MyISAM支持全文索引,
InnoDB不支持(但可以使用Sphinx插件)

113.MySQL由哪些部分组成, 分别用来做什么

1.连接器: 管理连接, 权限验证.
2 分析器: 词法分析, 语法分析.
3 优化器: 执行计划生成, 索引的选择.
4 执行器: 操作存储引擎, 返回执行结果.
5 存储引擎: 存储数据, 提供读写接口.

114.说说对 SQL 语句优化有哪些方法 [必须背会]

（1）Where 子句中：where 表之间的连接必须写在其他 Where 条件之前，那些可以过滤掉最大数量记录的条件必须写在 Where 子句的末尾.HAVING 最后。
（2）用 EXISTS 替代 IN、用 NOT EXISTS 替代 NOT IN。
（3）对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。（4）应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描（5）应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描

115.什么是存储过程？用什么来调用？

存储过程是一个预编译的 SQL 语句，优点是允许模块化的设计，就是说只需创建一次，以后在该程序中就可以调用多次。如果某次操作需要执行多次 SQL，使用存储过程比单纯 SQL 语句执行要快。可以用一个命令对象来调用存储过程。