JAVA面试遇到的问题归纳总结

面试遇到的问题归纳总结（持续更新中）

**

一、面向对象的特性？

**
回答：面向对象有四个基本特性：抽象、封装、继承、多态。这四个特性，概括起来可以这么理解，抽象、封装、继承是多态的基础，多态是抽象、封装、继承的表现。

解释一下什么是面向对象？

首先先解释一下什么是对象，一切事物皆是对象，既所有的东西都是对象，对象就是可以看到，感觉到，听到，触摸到，尝到，闻到的东西，简单的说对象是一个字包含的实体，用一组可识别的特性和行为来标识。
面向对象编程其实就是针对对象来进行编程的意思。

那么什么类又是什么呢？

类就是具有相同的属性和功能的对象的抽象的集合。
那么怎样来用这个类呢？
很简单，只需要将类实例化一下就好了，那什么又叫实例化呢，实例就是一个真实的对象，实例化就是创建对象的过程。

说一说对面向对象中继承性的理解？

对象的继承代表一种is a关系，如果有两个对象A和B，可以描述为B是A，则表明B可以继承A；
继承者还可以理解为是对被继承者的特殊化，因为它除了具有被继承者的特性外，还具有自身独有的特性；
**

学习继承记住的三句话：如果子类继承于父类，

**
第一，子类拥有父类非private的属性和功能；
第二，子类拥有自己的属性和方法，即子类可以扩展父类没有的属性和功能；
第三，子类还可以以自己的方式实现父类的功能（方法重写）
**

此外继承也是有缺点的：

**
当父类改变，子类不得不改变；
继承会破坏包装，父类实现细节暴露给子类，增大了两个类之间的耦合性；

**

说一说对面向对象中封装性的理解？

**
每个对象都包含它能进行操作所需要的所有信息，这个特效称为封装，因此对象不必依赖其他对象来完成自己的操作；
**优点：**第一，良好的封装能减少耦合；
第二，类内部的实现可以进行自由修改；
第三，类具有清晰的对外接口

**

二、说一说对面向对象中多态性的理解？

**
**

（1）、什么是多态

**
不同类的对象对同一消息作出不同的响应就叫做多态。就像上课铃响了，上体育课的学生跑到操场上站好，上语文课的学生在教室里坐好一样。

**

（2）、多态的作用

**
简单讲就是解耦。再详细点讲就是，多态是设计模式的基础，不能说所有的设计模式都使用到了多态，但是23种中的很大一部分，都是基于多态的。

**

（3）、多态存在的三个条件

**
1、有继承关系　　
2、子类重写父类方法　　
3、父类引用指向子类对象

补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：
1、static方法，因为被static修饰的方法是属于类的，而不是属于实例的
2、final方法，因为被final修饰的方法无法被子类重写
3、private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢。

**

（4）、多态的分类

**
1、编译时多态，即方法的重载，从JVM的角度来讲，这是一种静态分派（static dispatch）
2、运行时多态，即方法的重写，从JVM的角度来讲，这是一种动态分派（dynamic dispatch）
**

（5）、总结出了多态无非就是三句话：

**
比如我们有一个父类Father，有一个子类Children。

1、向上转型是自动的。即Father f = new Children()是自动的，不需要强转
2、向下转型要强转。即Children c = new Father()是无法编译通过的，必须要Children c = (Children)new Father()，让父类知道它要转成具体哪个子类
3、父类引用指向子类对象，子类重写了父类的方法，调用父类的方法，实际调用的是子类重写了的父类的该方法。即Father f = new Children()，f.toString()实际上调用的是Children中的toString()方法。

**

三、抽象类和接口的区别？

**
1）抽象类要被子类继承，接口要被类实现。

2）接口只能做方法声明，抽象类中既可以作方法声明，又可以做方法实现。

3）接口里定义的变量只能是公共的静态的常量，默认即为public static final类型，抽象类中的变量是普通变量。

4）接口是设计的结果，抽象类是重构的结果。因此抽象类中可以有构造方法，而接口中不能有构造方法。

5）抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高。

6）抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量。

7）抽象类主要用来抽象类别，接口主要用来抽象功能。

四、Overload（重载）和Override（重写）的区别？

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

重载：

1）重载是在同一个类中，方法名是相同的；
2）重载必须要有不同的参数列表；
3）重载可以有不同的返回值类型；
4）重载可以有不同的访问修饰符；
5）重载可以抛出不同的异常；

重写：

1）重写参数列表必须与被重写方法的参数列表相同；
2）重写返回值类型必须与被重写方法的返回值类型相同；
3）重写访问修饰符的限定必须大于被重写方法的访问修饰符
（public>protected>default>private）
4）重写方法一定不能抛出新的检查异常或者重写的方法申明更加宽泛的检查异常

五、谈谈final, finally, finalize的区别？

Final:

1）修饰符（关键字）；如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承，因此一个类不能既被声明为abstract的，又被声明为final 的；
2）将变量或方法声明为final，可以保证它们在使用中不被改变；被声明为final 的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改；
3）被声明为final 的方法也同样只能使用，不能重载。

Finally:

1）再异常处理时提供finally 块来执行任何清除操作；
2）如果抛出一个异常，那么相匹配的catch 子句就会执行，然后控制就会进入finally 块（如果有的话）。

Finalize:

1）是一个方法名；Java 技术允许使用finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。
2）这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。
3）它是在Object 类中定义的，因此所有的类都继承了它。
4）子类覆盖finalize() 方法以整理系统资源或者执行其他清理工作。
5）finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

六、静态变量和实例变量的区别？

1）语法角度来看，静态变量前要加static关键字，而实例变量前不加。
2）程序运行角度来看，实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
3）程序运行角度来看，静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码文件，不用创建任何实例象，静态变量就会被分配空间，静态变量就可以被使用了。
4）总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

七、&与&&的区别？

按位与：

a&b是把a和b都转换成二进制数然后再进行与的运算；

逻辑与：

a&&b就是当且仅当两个操作数均为 true时，其结果才为 true；只要有一个为零，a&&b就为零。

八、集合

（一）、介绍一下集合类框架

首先，集合类框架经常使用的是继承Collection接口和继承Map接口两个体系。

Collection接口：Collection接口的常见实现接口为List和Set。

1、List：List接口的主要实现类有ArrayList、LinkedList以及Vector

1）有序，可以重复；
2）ArrayList就是一个可以扩容的对象数组，是线程不安全的；
3）LinkedList是一个双向链表；
4）Vector是线程安全的；
5）线程安全：加锁就是线程安全的，不加锁就是线程不安全的，就是多线程访问时，采用加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问，直到该线程读取完，其他线程才可使用，不会出现数据不一致或者数据污染；
6）线程不安全：就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据；

2、Set：Set接口的主要实现类是HashSet、TreeSet、LinkedHashSet；

1）无序，不可重复；
2）HashSet：实现基于HashMap，实际上就是HashMap中的key；
3）TreeSet：底层由TreeMap实现；
4）LinkedHashSet：底层由LinkedHashMap实现；

Map接口：实现类常见有HashMap、TreeMap、Hash Table等;

1、Map接口的特点是存储方式都是键值对的形式，键不可重复，值可以重复；
2、HashMap的底层是基于哈希表来实现的，往HashMap中添加元素的时候，首先会调用HashCode方法得到元素的哈希码值，经过运算可以得到该码在哈希表中的位置，它是线程不安全的；
3、TreeMap是基于二叉树来实现的，会对元素的键进行排序。
4、Hash Table底层和HashMap原理一样，都是哈希表，但是是线程安全的。

（二）、数组合集合的区别？

1、数组特点：大小固定，只能存储相同数据类型的数据；
2、集合特点：大小可动态扩展，可以存储各种类型的数据；
3、数组转换为集合：Arrays.asList(数组)；

（三）、Collection和Collections的差别？

1、他俩都是java.util包下的。
2、Collection是一个集合接口，它底下有很多集合的实现。
3、Collections是一个集合的帮助类，提供了一系列的静态方法对集合进行搜索、排序、线程安全化的操作。

（四）、LinkedList与ArrayList有什么差别？

1、他俩都是实现了List接口，都是有序可重复的。
2、ArrayList是基于动态数组，LinkedList是基于链表。
3、ArrayList的查询效率高，可以根据下标直接定位查询，但是增删改的效率低，因为要移动数据。
4、LinkedList的增删改效率高，但是查的效率低，因为它必须得从链表的一端开始逐一遍历。

（五）、ArrayList与Vector有什么差别？

1、他俩都是实现了List接口，都是有序可重复的。
2、ArrayList是线程不安全的，Vector是线程安全的。所以ArrayList的执行效率高于vector。
3、当向一个集合中添加元素时，超过他俩的初始容量时，ArrayList每次添加原来的0.5倍，vector添加为原来的1倍，并且vector提供我们自己来设置存储空间增长的大小。

（六）、HashMap和Hash Table的区别？

1、两者都实现了Map接口，都是以键值对来存储数据。并且key值都不重复。
2、HashMap是线程不安全的，HashTable是线程安全的。
3、HashTable相比于HashMap也是支持多线程的操作而导致性能不如HashMap。
4、HashMap支持空的key和value，HashTable不支持。

（七）、List和Map的区别？

1、List是存储单链数据集合，Map是存储key和value的双链的数据集合；
2、List是有序的，可以重复的，Map存储的数据是无序的，key值不能重复，value值可以重复；
3、List继承Collection接口，Map没有父类；

（八）、什么是iterator？

Iterator接口提供遍历任何Collection接口的实现类，我们可以从实现类中获取迭代器实例，迭代器允许调用者在迭代过程中移除元素。

（九）、集合框架中的泛型有什么优点？

泛型为集合类框架引入了可以存放相同对象的容器，因此，如果在集合中添加其他的对象，就会在编译时报错，避免了运行时出现ClassCastException。泛型也使代码变得整洁，不用使用显示转换和instanceOf操作符。

（十）、哪些集合提供对元素的随机访问？

ArrayList（有序）、HashMap、TreeMap、HashTable（key值）。

（十一）、 集合类常用方法？

add(E e) ，添加元素
clear() ，暴力清除集合中所有元素
contains(Object o)， 返回值类型：boolean。判断集合是否包含某个元素
isEmpty() ，返回值类型：boolean。如果此集合不包含元素，则返回true。
iterator() 迭代器。返回值类型：Iterator
size() 返回值类型：int。返回集合中的元素数

九、什么是反射？

在运行状态中，对于任意一个类都能知道它的所有属性和方法，对于任意一个对象都能调用它的任意方法和属性，这种动态获取信息及调用对象方法的功能称为反射。缺点是破坏了封装性以及泛型约束。反射是框架的核心，Spring 大量使用反射。

十、什么是泛型？

泛型本质是参数化类型，解决不确定对象具体类型的问题。泛型在定义处只具备执行 Object 方法的能力。

泛型的好处：

①类型安全，放置什么出来就是什么，不存在 ClassCastException。
②提升可读性，编码阶段就显式知道泛型集合、泛型方法等处理的对象类型。
③代码重用，合并了同类型的处理代码。

十一、Io

（一）、java.io 包下有哪些流？
1、主要分为字符流和字节流
2、字符流一般用于文本文件
3、字节流一般用于图像或其他文件
4、字符流包括了字符输入流 Reader 和字符输出流 Writer
5、字节流包括了字节输入流 InputStream 和字节输出流 OutputStream
6、字符流和字节流都有对应的缓冲流，字节流也可以包装为字符流，缓冲流带有一个 8KB 的缓冲数组，可以提高流的读写效率
7、除了缓冲流外还有过滤流 FilterReader、字符数组流 CharArrayReader、字节数组流 ByteArrayInputStream、文件流 FileInputStream 等。

十二、多线程

（一）、程序，进程，线程的基本概念+并行与并发的基本概念？

程序：是为完成特殊任务，用某种语言编写一组指令的集合，即指一段静态的代码，静态的对象。
进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。
线程：进程可以进一步细化为线程，是一个程序内部的一条执行路径，说的简单一点线程就是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，可以使用多线程对其进行运算提速。
并行：多个CPU同时执行多个任务：比如多个人同时做不同的事情。
并发：一个CPU同时执行多个任务：比如秒杀平台，多个人同时做一件事。

（二）、什么是线程安全，什么是线程不安全？

通俗的说加锁就是线程安全，不加锁就是线程不安全；
线程安全：就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能访问，直到该线程读取完，其他线程才可以使用，不会出现数据不一致或者数据污染。
线程不安全：就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

（三）、什么是自旋锁？

基本概念：自旋锁是SMP架构中的一种low-level的同步机制；
当线程A想要获取一把自旋锁而该锁又被其它线程锁持有时，线程A会在一个循环中自旋以检测锁是不是已经可用了。
自旋锁需要注意的地方：
①、由于自旋时不释放CPU，因而持有自旋锁的线程应尽快释放自旋锁，否则等待该自旋锁的线程会一直在那里自旋，这就会浪费CPU时间。
②、持有自旋锁的线程在sleep之前应该释放自旋锁以便其他线程可以获得自旋锁。

（四）、什么是乐观锁，什么是悲观锁？

乐观锁
乐观锁（ Optimistic Locking）其实是一种思想。相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。
悲观锁
Java在JDK1.5之前都是靠synchronized关键字保证同步的，这种通过使用一致的锁定协议来协调对共享状态的访问，可以确保无论哪个线程持有共享变量的锁，都采用独占的方式来访问这些变量。独占锁其实就是一种悲观锁，所以可以说synchronized是悲观锁。

（五）、线程相关的API

1)、start( ):启动当前线程，调用线程中的run( )方法
2)、run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3)、currentThread():静态方法，返回执行当前代码的线程
4)、getName():获取当前线程的名字
5)、setName():设置当前线程的名字
6)、yield():主动释放当前线程的执行权
7)、join():在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去
8)、stop():过时方法。当执行此方法时，强制结束当前线程
9)、sleep（long millitime）：线程休眠一段时间
10)、isAlive（）：判断当前线程是否存活

（六）、sleep( )和wait( )的区别？

（1）、各自所在的类不同，sleep方法是在Thread类中的静态方法，wait方法是Object类中的方法；
（2）是否释放锁，sleep方法不释放锁，而wait方法释放锁；
（3）用途不同，sleep方法是来暂停线程的，wait方法是进行线程间交互的
（4）用法不同，sleep方法用完之后，线程会自动苏醒，而wait方法用完之后，线程不会自动苏醒，需要我们通过该对象去调用它的notify方法或者notifyAll方法去唤醒它；

十三、Jvm（java虚拟机）

十四、MySql

（一）、MySQL中left join、right join与inner join的区别，

https://www.cnblogs.com/bad-robot/p/9788959.html
1、left join(左联接) 返回包括左表中的所有记录和右表中联结字段相等的记录。
2、right join(右联接) 返回包括右表中的所有记录和左表中联结字段相等的记录。
3、inner join(等值连接) 只返回两个表中联结字段相等的行。

（二）、什么是索引？

索引是对数据库表中一列或多列的值进行排序的一种结构，使用索引可快速访问数据库表中的特定信息。

举例说明索引：

如果把数据库中的某一张看成一本书，那么索引就像是书的目录，可以通过目录快速查找书中指定内容的位置，对于数据库表来说，可以通过索引快速查找表中的数据。

什么时候使用索引？

数据库中表的数据量较大的情况下，对于查询响应时间不能满足业务需求，可以合理的使用索引提升查询效率。

索引的优点有哪些？

①建立索引的列可以保证行的唯一性，生成唯一的rowId；
②建立索引可以有效缩短数据的检索时间；
③建立索引可以加快表与表之间的连接；
④ 为用来排序或者是分组的字段添加索引可以加快分组和排序顺序；

索引的缺点有哪些？

①创建索引和维护索引需要时间成本，这个成本随着数据量的增加而加大；
②创建索引和维护索引需要空间成本，每一条索引都要占据数据库的物理存储空间，数据量越大，占用空间也越大；
③会降低表的增删改的效率，因为每次增删改索引需要进行动态维护，导致时间变长；

基本索引类型：

① 普通索引（单列索引）
② 复合索引（组合索引）
③ 唯一索
④ 主键索引
⑤ 全文索引

（三）、什么是事务？

事务是一组sql语句，要么全部执行成功，要么全部执行失败，通常一个事务对应一个完整的业务（例如银行账户转账业务，该业务就是一个最小的工作单元）
事务的提交：COMMIT;
事务的回滚：ROLLBACK;
事务的关闭：CLOSE;

特性：

原子性，一致性，隔离性，持久性。
事务的原子性：事务是最小单元，不可再分，要么全部执行成功，要么全部执行失败回滚。
事务的一致性：一致性是指事务必须使数据库从一个一致的状态变到另外一个一致的状态，也就是执行事务之前和之后的状态都必须处于一致的状态。
不一致性：包含三点，脏读，幻读，不可重复读；
脏读：一个事务处理过程里读取了另外一个未提交的事务中的数据；
可重复读：一个事务在它运行期间，两次查找相同的表，出现了不同的数据；
幻读：在一个事务中读取到了别的事务插入的数据，导致前后不一致；

事务的隔离性：隔离性是指当前多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。
事务的持久性：DBMS（数据库管理系统）对数据的修改时永久性的。

（四）、三大范式？

十五、Jsp内置对象

十六、框架

（一）、mybatis

1、什么是 MyBatis？

答：MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。

2、讲下 MyBatis 的缓存

答：MyBatis 的缓存分为一级缓存和二级缓存,一级缓存放在 session 里面,默认就有,二级缓
存放在它的命名空间里,默认是不打开的,使用二级缓存属性类需要实现 Serializable 序列化
接口(可用来保存对象的状态),可在它的映射文件中配置

4、简述 Mybatis 的插件运行原理，以及如何编写一个插件？

答：
1）Mybatis 仅可以编写针对 ParameterHandler、ResultSetHandler、StatementHandler、
Executor 这 4 种接口的插件，Mybatis 通过动态代理，为需要拦截的接口生成代理对象以实
现接口方法拦截功能，每当执行这 4 种接口对象的方法时，就会进入拦截方法，具体就是
InvocationHandler 的 invoke()方法，当然，只会拦截那些你指定需要拦截的方法。
2）实现 Mybatis 的 Interceptor 接口并复写 intercept()方法，然后在给插件编写注解，指定
要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

（二）、mybaitsPlus

（三）、spring

1、Ioc

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。
IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

我对IoC(控制反转)和DI(依赖注入)的理解

在平时的java应用开发中，我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成，在没有使用Spring的时候，每个对象在需要使用他的合作对象时，自己均要使用像new object() 这样的语法来将合作对象创建出来，这个合作对象是由自己主动创建出来的，创建合作对象的主动权在自己手上，自己需要哪个合作对象，就主动去创建，创建合作对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起，而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。

（四）、springMvc

1、springMVC的一个具体执行流程：

1）、用户发送请求至前端控制器DispatcherServlet；
2）、DispatcherServlet收到请求调用HandlerMapping处理器映射器；
3）、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器然后一并返回给DispatcherServlet;
4）、DispattcherServlet通过HandlerAdapter处理器适配器调用处理器；
5）、执行处理器（Controller，也叫后端控制器）；
6）、Controller执行完后返回ModleAndView；
7）、HandlerAdapter将Controller执行结果ModleAndView返回给DIspatcherServlet；
8）、DispatcherServlet将ModleAndView传给ViewReslover视图解析器；
9）、ViewReslover解析后返回具体View；
10）、DispatcherServlet对View进行渲染视图（既将模型数据填充至视图中）；

11）、DispatcherServlet响应用户；

（一）、

@RequestBody的作用其实是将前端传过来json格式的数据在后端转为java对象。@ResponseBody的作用其实是将后端中的java对象传到前端页面展示时转为json格式的数据。

（五）、springBoot

SpringBoot入门
简介：
简化Spring应用开发的一个框架；
整个Spring技术的一个大整合；
J2EE开发的一站式解决方案；
什么是微服务:
2014,martin fowler
微服务：架构风格
一个应用应该是一组小型服务；可以通过HTTP的方式进行互通；
每一个功能元素最终都是一个可以独立替换和独立升级的软件单元；
大型的分布式就给部署和运维带来巨大的挑战；
这时就会用到spring cloud来解决这个挑战；
Spring
优点：
快速创建独立运行的spring项目以及主流框架集成；
使用嵌入式的Servlet容器，应用无需打成war包；
Starters自动依赖于版本控制；
大量的自动配置，简化开发，也可修改默认值；
无需配置xml，无代码生成，开箱即用；
准生产环境的运行是应用监控；
与云计算的天然集成；
缺点：入门容易，精通难；
Web开发：
1、使用SpringBoot：
1）、创建一个SpringBoot应用，选中 我们需要的模块；
2）、SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来
3）、自己编写业务代码

自动配置原理？
这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？Xxx
2、

（六）、SpringCloud

（七）、SpringData

（八）、redis

（九）、部署服务器