# 面试题

> 因为是新手如果有错的地方 谢谢大家提出我会改正
> 排版我会明天重新排版一下 目前有点乱

[TOC]

# 一 . Java基础

#### Java基础

##### 1 . JDK和JRE有什么区别

+ **JDK :** Java开发工具包 , 提供了Java的开发工具和运行环境
+ **JRE :** Java运行环境 , 为Java的运行提供了所需环境

***

> JDK中包含了JRE , 同时还包含了编译Java源码的编译器 javac , 以及很多java程序调试和分析的工具
>
> 如果只需要运行java环境 安装JRE即可 , 如果需要编写Java程序 则需要安装JDK

##### 2 . == 和 equals的区别是什么?

+ **== : 对于基本类型和引用类型的作用效果是不同的**
  + **基本类型** : 比较的是值
  + **引用类型 **: 比较的是引用
+ **equals : 本质上与 " == " 相同 ,** 只不过很多类重写了Object的equeals方法 , 把它变成了值比较 , 例如 String , Integer , 所以一般情况下equals比较的是值是否相等

##### 3 . 什么是引用？ 什么是地址？ 你怎么理解

例 ： String s = new String（"A"）;

- **引用 ( s)： **可以说是~~引用变量~~ ，相当于为对象或数组起的一个名称 ， 可以在程序中使用栈中的引用变量来访问堆中的数组或对象 
- **地址 ： **在堆内存中开辟一块空间 , 这个空间地址便是对象本身

##### 4 . 两个对象的hashCode相等 , 则equals()页相等吗 ?

两个对象的hashCode()相等  , equals()不一定为true

因为在散列表中 , hashCide()相等即两个键值对的哈希值相等 , 并不一定能得出键值对相等

##### 5 . final 在 Java 中有什么作用?

**final修饰类 **: 被final修饰的类叫最终类 , 该类无法被继承

**final修饰方法 : **被final修饰的方法无法被重写

**final修饰变量 : **final修饰的变量叫常量 , 常量必须被初始化 , 初始化之后值不能被修改

##### 6 . Java 中的 Math.roud(-1.5) 等于多少?

**等于 -1**

因为在数轴上取值时 , 中间的(0.5向右取整) , 所以正0.5是向上取整

而(-0.5)是向下取整 , 也可以说直接舍去

##### 7 . String属于基础的数据类型吗 ?

**String是引用类型 不属于基础的数据类型 ,**

基础类型有 byte , short , int , long , float , double , boolean , char

##### 8 . 八大基本类型的字节以及二进制位数是多少

byte short int long float double boolean char

字节这边对应上面可直接记为 1 2 4 8 4 8 1 2

二进制位数各自乘以8 : 1 2 4 8 4 8 1 2 * 8

8  16 32 64 42 64 8 16

##### 9 . Java 中的操作字符串都有哪些 ? 它们之间有什么区别

**操作字符串的类有 : String StringBuffer StringBuider**
**String :** 声明的是不可变的对象 , 每次操作都会生成新的字符串对象

**StringBuilder和StringBuffer :** 可以在原有对象的基础上进行操作 , 所以在经常改变字符串的情况下最好不要使用Spring

**StringBuilder 和 StringBuffer**

(1)  **StringBuffer **是线程安全的

**StringBuilder **是线程不安全的

所以在单线程的情况下推荐使用 **StringBuilder**提高性能

多线程的情况下推荐使用安全的**StringBuffer**

##### 10 . String str="a"与 String str = new String("a") 是相同的吗

**不相同 **

String str = "a" 是字符串常量池中的常量

String str = new String("a") 这里的str是 new String("a") 的地址值

详情可见 :https://www.kuangstudy.com/bbs/1401770676905381889

##### 11 . String类的常用方法都有哪些 ?

```java
toLowerCase():		将字符串转换为小写字母
toUpperCase():		将字符串转换为大写字母
replace():		字符串替换
equals():		字符串比较
split():		分割字符串
substring():	截取字符串
shaboString
  
length():		返回字符串的长度
charAt():		返回指定索引出的字符
getBytes():		返回字符串的byte类型数组
trim():			去除字符串的两端空白
```

##### 12. 重写和重载有什么区别 ?

+ **方法的重写和重载都是实现多态的方式**

```
   重写实现的是编译时的多态性
   重载实现的是运行时的多态性
  ```

+ **重载发生在一个类中**

```
  同名的方法有不同的参数列表 , 对返回值类型没有特殊要求则视为重载
  ```

+ **重写发生在子类和父类之间**

```
  重写要求子类重写方法 : 方法名 参数列表 返回值类型必须相同 , 且访问权限修饰符不能大于被重写方法
  ```

##### 13 . 接口和抽象类有什么区别

**关键字不同**

**抽象类有构造方法 , 接口没有构造方法**

**接口可以实现多个 , 抽象类只能单实现**

##### 14 . BIO NIO AIO 有什么区别

**BIO : ** Blocak IO 同步阻塞式IO , 就是我们平常使用的传统IO , 它的特点是模式简单使用方便 , 并发处理能力低

**NIO : ** New IO 同步非阻塞IO , 是传统IO的升级 , 客户端和服务器端 通过 Channel(通道) 通讯 , 实现了多路复用

**AIO : ** Asynchronous IO 是NIO的升级 , 也叫NIO2 , 实现了异步非阻塞IO , 异步IO的操作基于事件和回调机制

##### 15 . Files的常用方法都有哪些

```apl
Files.exists() : 检测文件路径是否存在
Files.createFiles() : 创建文件
Files.createDirectory() : 创建文件夹
Files.delete() : 删除一个文件夹或目录

Files.copy() : 复制文件
Files.move() : 移动文件
Files.size() : 查看文件个数
Files.read() : 读取文件
Files.write() : 写入文件
```

##### 16 . 静态变量和实例变量的区别

静态变量 :

```
也称之为类变量,归全类共有,可以通过类名直接访问;
```

实例变量 :

```
必须依存于某一实例,只能通过对象才能访问
```

##### 17 . 如何将字符串反转

```
1 . 将对象封装到StringBuilder 或 StringBuffer中，
2 . 调用reverse（）方法反转
```

##### 18 . Java中有哪些引用类型

Java语言中除了基本引用类型之外都是引用类型

```
强引用   软引用    弱引用  虚引用
```

**强引用 :** 证明该对象还活着 gc 不会回收该引用 , 当内存不足时 , 哪怕抛出 OutOfMemeryError 异常也不会回收该对象 , JVM判定该对象正在使用 , 回收会导致系统错误 , 将该引用赋值为null 就可以被垃圾收集

**软引用 :** 相对于强引用弱化一些 , 当内存不足时 , 回收该对象 , 通常用来实现内存中的缓存 , 如果还有空闲内存就保留 , 没有就进行回收

**弱引用 :** 用来构建一种没有约束的特殊关系 当 JVM 触发 gc 时回收该对象 ,

**虚引用 :** 也叫幻象引用 , 确保对象被finalize 以后做某些事的一种机制 ,  JVM 可以在任何时候回收

##### 19 . 面向对象

**把相关的数据和方法组织为一个整体来看待**

**相比面向过程，面向过程比较直接高效，面向对象更易于复用、扩展、维护**

**封装：**

```
封装的意义在于明确标识出允许外部使用的所有成员函数和数据项，外部调用无需修改或者关心内部实现
```

**继承：**

```
继承基类的方法，并做出自己的改变和扩展，子类共性的方法或者属性直接使用父类的
```

**多态：**

```
继承 ，方法重写，父类引用指向子类对象
```

**orm框架：**

```
操作数据库，我们不需要关心链接如何让建立,sql如何执行，只需要引入mybatis，调用方法即可。
```

##### 20 . java动态代理

**代理模式:** 为其他对象提供一种代理以控制对这个对象的访问

真正对象和代理对象是实现同一个接口,先访问代理类再访问要访问的对象

**代理模式分为:** 静态代理、动态代理

**优点:** 保护对象  降低程序的耦合性 提高扩展性

##### 21 . 泛型

**优点:** 类型安全  消除强制类型转换   更高的效率

泛型类型必须为引用类型

**三种使用方式:** 泛型类 泛型接口 泛型方法

##### 22 . 注解

用于为java代码提供元数据(用来描述数据的数据)

基本语法@interface

元注解: 可以用到注解上的注解 或者说是一种基本注解

常用:@Retention() 说明生命周期

RetentionPolicy.SOURCE 只在源码阶段保留

RetentionPolicy.CLASS只被保留到编译进行时,不会被加载到JVM中

RetentionPolicy.RUNTIME 可以保留到程序运行时,会被加载到JVM中

@Target 注解运用的地方

ElementType.FIELD 可以给属性进行注解

ElementType.METHOD 可以给方法进行注解

ElementType.TYPE 可以给一个类型进行注解，比如类、接口

##### 23 . NoClassDefFoundError 和ClassNotFoundException的区别

我们可以从异常中恢复程序 , 而不可以从错误中恢复

ClassNotFoundException是一个异常 : ClassNotFoundException产生的原因 , 在Java中我们支持Class.forName方法来动态的加载一个类 , 任意一个类名作为一个参数传递给这个方法 , 都可以使这个方法得到加载 , 如果在java过程中没有找到 就会产生

NoClassDefFoundError 是一个错误 ,  产生的原因是 , java是找不到这个类名的定义 , 常出现的地方有 , 打包的时候没有找到该类

##### 24 .throw 和throws的区别

throw是语句抛出一个异常。

语法：throw (异常对象);

throw e;

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常) ， 可以单独使用

####   反射

```
1.获取Class对象的三种方式：

通过全限定类名 : Class.forName("全类名")      
通过类名 : 类名.class    
通过对象 : 对象.getClass()

2.原理: 能够在运行状态中,对于任意一个实体类,都能够获取到这个类的所有属性和方法,

对于任意一个对象,都能够调用它的任意方法和属性, 这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
```

#### 容器

![img](面试题复习测试.assets/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9RQ3U4NDlZVGFJT1B3UFRLSkpYYW9ydzFGSk1OUkthT1RmQzRXSVZ1WE05QzRpYUNYUnNUdTVPNTFVUGVpYmY2d2RHZkVOWEdETjV4NjVrYkpKR0NYUzZ3LzY0MA)

##### 1 . 介绍一下List Set Map

首先 : **List Set **继承自集合库的顶级接口 **Collection** , 而 **Map** 是一个单独的集合接口

- **List** List以及它的所有实现类保持了每个元素的插入顺序 , 且它的数值可以为空
- **Set** 底层的数据结构是 Hash表 , 它的元素是无序排列的 , 是不可重复的 .但是通过 set 的实现类 TreeSet 以及LinkHashSet 是可以进行排序的 , 且Set不可为空
- **Map** 与 Set 一样对元素进行无序存储 , 但某些实现类对元素进行了排序 如: TreeMap 根据键对其中的元素进行升序排序 ; map 也是不可重复的 , 所以它的键可以含有一个空值 , 值允许出现很多空值

##### 2 . Collection 和 Collections 有什么区别

- **Collection : **是一个集合接口 (集合库的一个顶级接口) , 它提供了对 集合对象进行基本操作的通用接口方法 , 其直接集成接口有 List 和 Set
  	- 了解即可 : Collection接口 在java类库中有很多具体的实现 , Collection接口 的意义是为各种具体的集合提供了最大化的统一操作方式 , 其直接继承接口有 List 和 Set .

- **Collections : **是集合的一个工具类库

##### 3 . ArrayList 和 LinkedList有什么区别

首先ArrayList和LinkedList都是List集合下的

**ArrayList**  ArrayList是用数组实现的 , 所以增删慢 查询快

**LinkedList **是以链表的形式存储它的数据

- 相对于 ArrayList , LinkedList 的插入 增删操作速度更快 . 因为当元素被添加到集合任意位置的时候 , 不需要像数组那样重新计算大小或者是更新索引
- 但是 LinkedList 比 ArrayList 更占内存 , 因为 LinkedList 为 每一个节点存储了两个引用 .

##### 4 . 如何实现数组和List之间的转换

**List 转换数组 : **调用ArrayList 的 toArray() 方法

**数组 转换List :** 调用Arrays的 asList()方法

##### 5 . Array 和 ArrayList有什么区别

容量大小功能

Array 可以容纳基本类型和对象 , 而 ArrayList只能容纳对象

Array 是指定大小的 , 而ArrayList 初始大小是固定的

Array 没有提供ArrayList 那么多功能 , 比如 addAll , removeAll等

##### 6 . HashMap 和 Hashtable有什么不同

HashMap 去掉了 Hashtable 的 contains 方法 但是加上了containsValue() 和 containsKey()

Hashtable 同步的 , HashMap 是非同步的 所以效率比 Hashtable 高

HashMap 允许空键值 , Hashtable不允许

##### **7 . HashMap的实现原理**

**HashMap是基于Hash算法实现的**

- 当我们通过 put() 存储数据时
- 当传入key时 , HashMap会根据Key计算出Key的Hash值 , 根据Hash值value保存在bucket中

**Hash冲突时**

- 当计算出相同的Hash值时 ， Hash冲突时 ， 这个键值对会存储在链表中

**问题 :  如果两个键的HashCode相同  如何获取值对象**

- 当我们调用 get() HashMap会使用键对象的hashcode找到bucket位置 , 然后获取值对象

**问题 : 如果两个值存储在一个bucket**

- 遍历链表找到值对象 , 然后获取值对象

**问题 : 因为没有值比较 如何确定能找到值对象 ? **

- 找到 bucket 位置后调用 key.equals() 找到链表中正确节点 , 最终找到要找的值对象

##### 8 . HashMap 与 ArrayList的内存容量

**ArrayList : **jdk1.2的时候初始化容量为 10 , 经过版本的不断迭代JDK1.8之后更新为 , 初始容量为 0 ,添加元素之后容量为 10 .

**HashMap : **HashMap初始容量为 16 , 负载因子为 75% , 当一个集合被填满到 75% 时 , 会重建一个原来HahMap两倍的数组 , 并将原来的集合存放到新的集合中 .

##### 9 . hashcode()方法的作用

**hashcode()方法主要配合基于散列的集合一起使用, 比如HashSet  HashMap**

```
1 . 当集合需要添加新的对象时，先调用这个对象的hashcode()方法，得到对应的hashcode值，
2 . 实际上hashmap中会有一个 table 保存已经存进去的对象的hashcode值，
3 . 如果table中没有该hashcode值，则直接存入，
4 . 如果有，就调用equals方法与新元素进行比较，相同就不存了，不同就存入
```

##### 10 . 高并发的情况下 你怎么使用List 集合

```
1 . 首先我们可以使用List集合下线程安全的 Vector
2 . 也可以使用一些 Controllers 下的加锁方法 , 比如 synchronizedList()
3 . 写时复制
```

##### 11 . HashMap的数据结构

在JDK1.7和JDK1.8不同

JDK1.7中

```
使用的是数组加链表
```

JDK1.8中

```
使用的是数组加链表加红黑树 , 当HashMap中数组链表的长度大于8且数组长度大于64的时候它会转化为红黑树
```

红黑树 :

```
红黑树 是基于二叉树实现了平衡二叉树, 它的优势就是提升了查询效率
```

####  线程

##### 1 . 什么是线程 ?

**线程 : **线程时操作系统中能够进行运算调度的最小计量单位 ,  它被包含在进程之中 , 是进程的实际运作单位 , 可以使用多线程进行运算提速 .

##### 2 . 线程的创建方式 ? (三种)

**(1) . 继承Thread类 创建线程**

- 定义Thread子类 , 并重写Thread的run(), 该run()的方法体就是要实现的业务逻辑
- 创建Thread的实例 , 就创建了线程对象
- 调用线程对象的 start() 来启动线程

**(2) . 继承 Runnable 接口**

- 实现Runnable接口的实现类, 并重写接口的run() , run() 内写要执行的业务
- 创建Runnable的实现类的实例 , 并依此实例Thread的tarage来创建Thread对象 , 该Thread对象才是真正的实例对象
- 调用该线程的start() 来启动线程
  **了解即可 :
  (1) . Runnable中只有run()没有start() 所以即使实现了Runnable接口也没办法使用线程 , 需要借助其他类才可以 ; 
  (2) . Thread中也没有run() . Thread实现了Runnable , 所以重写了Runnable的run()
  
  **

**(3) . 通过 Callable 和 Future创建线程**
**了解即可 : **因为Runnable接口无法获取到线程执行的结果 , 所以java提供了Callable接口 , 类似于Runnable接口 , 只有两个地方不同 :
(1) Callable需要实现call(),有返回值 , 但不能直接Callable创建线程 , 需要使用Runnable来创建线程 , Future来进行接收 ; 
(2)且call() 可以抛出异常 , 而Runnable 只能在内部消化异常
补充 : (3) : Callable 比 Runnable 效率更高
补充 : (4) : Future当调用FutureTask.get()方法时会阻塞主线程 , 反之则不会

##### 3 . 线程的生命周期 (五态)

线程的创建有多种说法但基本上有五个过程:
(1) . **新建状态 : **当线程对象创建后就进入了新建状态
(2) . **就绪状态 :** 当调用了线程的start() , 线程就进入了就绪状态 , 这时候线程还没有启动
(3) . **运行状态 : **当CPU调度了处于就绪状态的线程时 , 这是线程就进入了运行状态
(4) . **阻塞状态 :** 处于线程池中的线程因为某种原因 , 暂时放弃对CPU的使用权 , 停止执行 , 直到其进入了就绪状态 , 才有机会被CPU选中继续执行

> 1 . 等待阻塞 : 运行状态中的线程执行 wait() , 本线程进入到等待状态
> 2 . 同步阻塞 : 线程在获取synchronized同步锁失败 ( 因为锁被其他状态占用 ) , 它会进入到同步阻塞状态
> 3 . 其他阻塞 : 调用线程的 sleep() 或者 join() 发出了IO请求时 ,  线程会进入到阻塞状态 , 当sleep()超时 , join() 等线程终止或超时或者IO处理完毕时线程重新转入就绪

(5) . **死亡状态 : **线程执行完了或因为异常退出了run() , 该线程结束声明周期

##### 4 . 线程池的创建方式(四种)

四种方式 ：

```
1、newCachedThreadPool  
创建一个可缓存的线程池，如果线程池的长度超过需要处理的，可灵活回收空闲线程，	
若不满足处理需求则创建新线程。

2、newFixedThreadPool 
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

3、newScheduledThreadPool 
创建一个定长线程池，支持定时及周期性任务执行。

4、newSingleThreadExecutor 
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
```

##### 5 . 为什么阿里巴巴不用这个线程池来创建

线程池**不允许使用Executors去创建，**而是通过**ThreadPoolExecutor的方式**，这样的处理方式让写的同学更加明确线程池的运行规则，避免资源耗尽的风险。
说明: Executors返回的线程池对象的弊端如下:

1. FixedThreadPool和SingleThreadPool允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致内存耗尽。
2. CachedThreadPool和ScheduleThreadPool允许创建的线程数量为Integer.MAX_VALUE，可能会产生大量的线程，从而导致内存耗尽溢出。

##### 6 . 并行 并发

并行 ： 多个对象访问多个线程

并发 ：对象被多个线程所访问 ， 访问次数过多 对象运转不过来则会出现高并发问题

##### 7 . 怎么解决线程出现的问题 -- 线程同步

sybnchronized：

Lock锁 ：

##### 8 . 悲观锁和乐观锁

**悲观锁：**进行加锁操作后，使得该对象变为该线程的独有对象

**缺陷：**线程切换要不停的释放和获取锁 会导致优先级倒置，synchronized锁是一种典型的悲观锁。

**乐观锁：**认为对对象的操作不会引发冲突，只在最后提交更改时验证是否发生冲突，如果冲突则再试一遍知道成功为止，也称为自旋

##### 9.java中wait和sleep方法的不同

最大的不同是在 等待时wait会 释放锁，而sleep一直持有锁。

sleep属于Thread类，wait属于object类

#  二 . 数据库

#### 数据库

##### 1.相关概念

**数据库：**就是存储和管理数据的仓库。长期存储在计算机中的、有组织的、可共享的、统一管理的大量数据的集合。

**分类：**现在分为关系型数据库 、非关系型数据库

**关系型数据库：**底层以二维表的形式保存数据的库。

##### 2.Redis

1.Redis是非关系型、基于内存的数据库，提供键值对形式的数据存储

支持每秒十几万的读写操作，性能远超关系型数据库，支持集群、分布式、主从同步

使用场景：读取缓存用的数据（读操作远大于写操作的数据）如首页；  高速读写场合。

##### 2.1缓存

类别: 浏览器缓存  CDN缓存   网关(代理)缓存  进程内缓存  进程外缓存  数据库缓存

问题: "缓存更新"和"缓存与数据的一致性"问题

**缓存雪崩**: 大量请求并发进入时,由于某些原因未能起到预期的缓冲效果 ,造成数据库压力过重  解决:加锁排队或者 缓存时间增加随机值

##### 3 . 数据库去重

1. 使用distinct关键字 ， 在添加时就进行去重操作

#### JDBC

##### 1.JDBC概述

Java数据库连接   就是利用Java语言连接并访问数据库的一门技术

##### 2.JDBC连接数据库

jdbc中主要包含两个包(java.sql和javax.sql),并且Java中已经包含这两个包了

除jdbc的包之外,我们在操作数据库时还需要导入该数据库对应的驱动包(jar包)

连接数据库6步:  1.注册驱动  2.获取连接  3.获取传输器  4.执行sql语句  5.处理结果 6. 释放资源

如下代码操作:

```
/* 新增表记录: 往account表中添加一条记录: null 'hellen' 3500 */
@Test
public void testAdd() throws Exception {
	//注册驱动
	Class.forName( "com.mysql.cj.jdbc.Driver" );
	//获取连接
	Connection conn = DriverManager.getConnection( 
		"jdbc:mysql:///jt_db?characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false", 
		"root", "root" );
	//获取传输器
	Statement stat = conn.createStatement();
	//执行SQL语句, 返回执行结果
	String sql = "insert into account value(null, 'hellen', 3500 )";
	int rows = stat.executeUpdate(sql); 
	//处理结果
	System.out.println( "影响的行数为: "+rows );
	//释放资源
	stat.close();
	conn.close();
}
```

##### 3.JDBC优缺点

1.优点： 相比使用第三方框架连接访问数据库速度要快一些,因为这是最为传统,底层的方法。

2.缺点：包含大量的代码，后期难以维护。

自身没有连接池

查询结果需要开发人员手动处理，如果是非常复杂的数据处理起来是非常麻烦的。

##### 4.连接池

如果使用连接池:
	可以在程序一启动之后,就创建一批连接放在一个池中(容器), 当用户需要连接时, 不用自己创建, 而是从连接池中获取一个连接对象, 再基于这个连接对象去访问数据库, 用完连接后, 不用将连接关闭, 而是还回连接池中。这样一来，用户使用的都是池中的这一批连接，可以减少连接创建和关闭的次数，提高程序的执行效率！

##### 5.数据库事务（DataBase Transaction）ACID

原子性： 事务中的sql是一个整体，不能被分割

一致性： 事务执行前后数据之和是保持一致的z

隔离性： 在事务并发时，一个事务理论上看不到另外一个事务的状态

持久性： 一旦事务提交就会持久的保存到数据库中

#### Mybatis

##### 6 . JDBC 和 Mybatis 的区别

Myabtis对JDBC访问数据库的过程进行了简化和封装 , 极大的简化了JDBC的代码 , 且自带连接池 , 将sql语句与程序进行分开 , 提高了程序的扩展性, 自动处理了查询后的结果,将处理后的结果返回

##### 7 . mybatis的#{}和${}的区别

#{}:

```
(1) 将传入的数据当成一个字符串 , sql在解析时会加上引号 , 当成字符串来解析
(2) 能够防止sql注入 , mybatis在处理#{}时 , 会将sql中能够的#{}替换为?号 , 调用PreparedStatement的set方法来赋值 , 提高系统安全性
```

${} :

```
(1) 将传入的数据直接显示在sql中
(2) 无法防止sql注入 , 一般用来传入数据库对象(属性)
```

# 三 . Web框架

#### Spring

##### 1 . 什么是spring?

- **Spring是一个轻量级的容器框架 ,是免费开源的 他有两个核心特性是 控制反转 和面向切面 . 其目的是为了解决企业级应用开发的复杂度 .**

###### (1) . Spring有优缺点?

- **优点 : **
  - 方便解耦 , 简化了程序的开发 
    Spring将所有对象的创建和依赖关系的维护交给了 Spring管理
  - AOP的支持
    Spring提供面向切面编程 , 可以方便的事项对程序进行权限拦截 , 运行监控等功能
  - 声明式事务
    只需要配置就完成对事务的管理
  - 方便程序的测试
    Spring 对 Junit4支持 , 可以通过注解方便的测试Spring程序
  - 方便集成各种优秀框架
    Spring 不排除各种优秀的开源框架 , 其内部提供了对各种优秀框架的直接支持
  - 降低了JavaEE API的使用难度
    Spring 对JavaEE开发中非常难用的一些API , 都提供了封装 , 这些API应用难度大大降低
- **缺点 : **
- Spring大量依赖反射 , 反射非常占用内存
- Spring不支持分布式

###### (2) . 为什么使用Spring , Spring是如何简化Java开发的?

- 为了降低Java开发的复杂性 , Spring做了一下四个策略
  - 基于pojo的轻量级和最小侵入性编程
  - 通过IOC , 依赖注入 和面向接口实现松耦合
  - 基于切面 进行声明式编程
  - 通过切面和模板减少样式

> 了解即可 : 
> Spring的最小侵入式 : Spring不会强制让你的应用所继承的类与框架强制绑定

###### (3) Spring中用到了那些设计模式和实现原理

1 . 简单工厂 :

```
由一个工厂类根据传入的参数 , 动态决定应该创建哪一个产品类
Spring中的BeanFactory就是简单工厂模式的体现 , 根据传入一个唯一的标识来获得Bean对象 
```

2 . 工厂方法 :

```
实现了FactoryBean接口的bean是工厂Bean 
```

3 . 单例模式 :

```
保证一个类仅有一个实例 , 并提供一个访问它的全局访问点
```

4 . 适配器模式 :

```
spring定义了一个适配接口 , 使得每一种Controller有一个对应的适配器实现类 , 让适配器代替Controller执行相应的方法 ,这样在扩展Controller时 , 只需要增加一个适配器类就完成了SpringMVC的扩展
```

5 . 装饰器模式 :

```

6 . 代理模式

```
为其他对象提供一种代理以控制这个对象的访问 
Spring的AOP功能用来到JDK的动态代理和CGLIB代理
```

7 . 观察者模式

```
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
```

8 . 策略模式

```
定义一系列的算法 , 把它们一个个封装其阿里 , 并使它们可相互替换 , 本模式使得算法可独立于使用他的客户而变化

```

9 . 模板方法

```
用来解决代码的重复问题
```

###### (4).依赖注入和工厂模式

1.通过依赖注入，类就是POJO，它只知道依赖不关心怎么获取他们

2.工厂模式: 类需要通过工厂获取

##### 2 . 什么是IOC

- **控制反转 :** IOC实际上就是个容器 map(key, value) , 
- 在项目启动时候 , 它会读取配置文件中的bean节点,  根据全限定类名使用反射创建对象到map中 ,
- 还会扫描repository , service , controller , component 四个注解的类 , 通过反射创建对象到map中
- 控制反转最常用的功能是 **依赖注入 ,** 它是控制反转的一种实现 , 当运行需要某含有依赖关系的类时 , 会从IOC容器中获取对象 控制对象的生命周期 ,借助"第三方"实现具有依赖关系的对象之间的解耦 , 这叫做控制反转 ;

###### (1) bean的生命周期

```
1 . 解析得到 BeanDefintion
2 . 推断构造方法 , 进行实例化得到一个对象
3 . 对对象中的加了 @Autowired注解 的属性进行属性填充
4 . 回调 Aware 方法 , 比如 BeanNameAware , BeanFactoryAware
5 . 调用 BeanPostProcessor 的初始化前方法
6 . 调用 初始化方法
7 . 调用 BeanPostProcessor 初始化后方法 , 同时这里会进行 AOP 动态代理
8 . 如果当前创建的 bean 是单例的 , 则会把 bean 放入到单例池
9 . 使用 bean
10 . Spring容器关闭时 , 调用 DisposableBean 中 destory()
```

###### (2) BeanFactory 和 FactoryBean的区别

**BeanFactory :**

```
（1）. 后缀 "Factory" , 它是一个工厂类(接口) , 我们通过它获取工厂管理的对象 ,
（2）. 在Spring中 BeanFactory是IOC容器的核心注解 , 
（3）. 它的职责包括 : 实例化 定位 配置应用程序中的对象及建立这些对象间的依赖
```

**FactoryBean : **

```
是Bean的一个创建方式 , 对Bean的扩展 , 对于复杂的Bean对象初始化创建使用其可封装对象的创建细节 , FactoryBean在IOC容器的基础上给Bean的实现加上了一个简单工厂模式

```

###### (3) BeanFactory 和 ApplicationContext有什么区别

- ApplicationContext是BeanFactory的子类 , ApplicationContext提供了更完整的功能
- 区别 : 
  - **BeanFactory : **采用的是延迟加载的形式来注入Bean的,即只有在使用到某个Bean的时候 , 才对该Bean进行加载实例化 , 这样就不能提取发现一些 spring 的配置问题
  - **ApplicationContext :** 在容器启动时 , 一次性创建了所有的bean , 这样容器在启动时 , 我们就可以发现spring中存在的配置错误
  - 相比于基本的BeanFactory , ApplicationContext唯一的不足是占用内存空间 , 当程序内配置的Bean较多时 , 程序启动较慢
  - BeanFactory通常以编译的方式被创建 , ApplicationContext还能以声明的方式创建
  - BeanFactory和ApplicationContext都支持BeanPostProcessor 和 BenaFactoryPostProcessor的使用**但是BeanFactory需要手动注册 ， 而ApplicationContext是自动注册**

###### (4) Spring中bean支持的几种作用域

- **singleton :** 单例模式 , 每个容器中只有一个bean的实例 , 单例模式由BeanFactory自身来维护 , 该对象的生命周期是与IOC容器一直的
 - **protorype : **为每一个bean请求提供一个实例 , 在每次注入时都会创建一个新的对象
 - **request : **bean被定义为在每个HTTP请求中创建一个单例对象 , 也就是说在单个请求中都会复用这一个单例对象
 - **session : **与request范围类似 , 确保每个session中有一个Bean的实例 , 在session过期后 , Bean会随之失效
 - **application :** bean被定义在ServletContext的生命周期中复用一个单例对象
 - **websocket :** bean被定义在websocket的生命周期中复用一个的单例对象

###### (5) Spring框架中的单例Bean是线程安全的吗

单例Bean不是线程安全的

Spring中的Bean默认的是单例模式 , 框架并没有对Bean进行多线程的封装处理

###### (6) 什么是Bean的自动装配

Bean的自动装配有四种方式

1 . byName  根据id/Name

2 . byType   根据类型

3 . constructor 根据构造参数

4 . no 人工指定

##### 3 .  什么是AOP

AOP是面向切面编程  , 是OOP的一种延伸范式 , 将那些与业务无关 , 但是对多个对象产生影响的公共行为和逻辑 , 抽取并封装为一个可重用的模块 , 比如 事务 , 日志等 , 减少了系统中的重复代码 , 降低了模块间的耦合度 , 提高了系统的可维护性;

###### (1) . JDK动态代理和CGLIB动态代理的区别

**JDK动态代理 ：**

```
JDK动态代理是面向接口 , 在创建代理实现类时比CGlib要快 , 创建代理速度快

利用反射机制生成一个实现代理接口的匿名类 , 在调用具体方法前调用InvokeHandler来处理.
```

**CGLIB动态代理 :**

```
CGlib动态代理是通过字节码底层继承要代理类来实现
(如果代理类被 final 所修饰 , 那么抱歉会失败)
在创建代理这一块没有JDK快 , 但是运行速度比JDK到动态代理要快
```

###### (2) . Spring的通知类型有哪些?

在AOP的术语中 , 切面的工作被称为通知 , 实际上是程序执行时要通过SpringAOP框架触发的代码段

Spring切面可以应用5种类型的通知 :

```
1 . 前置通知 (Before) : 在目标方法被调用之前调用通知功能
2 . 后置通知 (After)  : 在目标方法完成之后调用通知自 , 此时不会关心方法的输出是什么
3 . 返回通知 (After-returning) : 在目标方法成功执行之后调用通知
4 . 异常通知 (After-throwing)  : 在目标方法抛出异常后调用通知
5 . 环绕通知 (Around) : 通知包裹了被通知的方法 , 在被通知的方法调用之前和调用之后执行自定义的行为
```

##### 4 . spring的事务

###### (1) . Spring事务的实现方式原理

(1) . XML的方式配置

(2) , 注解的方式 @Transactional

###### (2) . Spring的事务传播机制

多个事务方法相互调用时 , 事务如何在这些方法间传播

```
方法A是一个事务的方法 , 在方法A执行中调用了方法B
无论方法B有没有事务,都会对方法A造成影响 ,
这种影响具体是什么就由两个方法所定义的事务传播类型所决定
```

REQUIRED(Spring默认的事务传播机制) : 如果当前没有事务 , 则自己新建一个事务 , 如果当前存在事务 , 则加入这个事务

SUPPORTS : 当前存在事务 , 则加入当前事务 ,如果当前没有事务 , 就以非事务方法执行

MANDATORY : 当前存在事务 , 则加入当前事务 , 如果当前事务不存在 则抛出异常

REQUIRES_NEW : 创建一个新事务 , 如果存在当前事务 , 则挂起事务

NOT_SUPPORTED : 以非事务方式执行 ,如果存在当前事务 , 则挂起当前事务

NEVER : 不使用事务 , 如果当前事务存在 , 则抛出异常

NESTER : 如果当前事务存在 , 则在嵌套事务中执行 , 否则REQUIREAD查找是

####  SpringMVC

##### 1 . 简介

```
SpringMVC是Spring框架的一个模块，是一个基于mvc的web框架。
```

##### 2. SpringMVC的工作流程

1. 用户向服务器发送请求 ， DispatcherServler接受到发过来的请求

2. 对url进行解析交给HandlerMapper处理 ， HandelMapper取查找具体的Hander
3. 交给处理器适配器
4. 处理器适配器 开始查找执行处理器 ， 也就是执行持久层的业务代码
5. Handler执行完成后 ， 向DispatcherServlet 返回一个Model And View 对象
6. 根据返回的 Model And View 选一个适合的 ViewResolver视图解析器
7. 视图解析器 结合 Model And View 渲染视图
8. 将渲染的结果返回给客户端

##### 3 . SpringMVC的常用注解

##### 4. SpringMVC 和 MVC 的区别

##### 3.什么是ORM

mvc框架中的重要一部分，实现了数据模型与数据库的解耦

ORM：对象关系映射的简称，将对象和表进行关联

#### SpringBoot

##### 1 . 简介

简化了spring的开发 ，消除了设置spring应用程序所需的XML配置，且内置TomCat能够独立运行 ， 是开发人员更容易的上手

#####  2 . SpringBoot的自动配置

![image-20210621143052785](面试题复习测试.assets/image-20210621143052785.png)

StringBootApplication - 自动配置原理

SpringBootApplication下有三个主要注解 ，

```
一个是 ComponentScan 扫描器 ， 
```

```
还有SpringBootConfiguration ，它下面有个注解时 Configuration 说明SpringBootApplication是一个配置类
```

```
剩下一个@EnableAutoConfiguartion注解时最主要的自动配置
(1) 在它里面包含一个注解@ImportAutoConfivurationImportSelector.class 
(2) 这个注解里有selectimport方法 , 这个方法会返回一个String【】 ， 数组里面是全限定类名 ， 
(3) 这些类路径存放在META-INF/Spring.factories中 ，
(4) Spring运行 ， 调用SpringAPI   SpringFactoriesLoader。loadFactoryNames 
(5) 然后使用@Import导入自动配置类
```

# 四 . Http

##### 5.从浏览器输入url到数据加载完成，整个过程

1.浏览器先查看浏览器缓存，系统缓存，路由缓存，如果有缓存直接显示。如果没有则将域名发送至DNS域名解析器，

将网址解析为ip地址（通过ip找到网络中计算机，通过端口号访问服务器中对应的应用）

2.浏览器基于http协议向服务器发起请求

3.服务器响应请求，分配线程处理请求

4.服务器基于TCP协议，与数据库建立连接，获取数据，响应至浏览器

5.浏览器接收响应，读取页面内容进行页面渲染。

# 五 . 前端

##### 1.Vue

Vue是一套用于构建用户界面的渐进式JavaScript框架。

核心库只关注视图层，方便与第三方库或既有 项目整合。

##### 2.基础语法

1.单向绑定数据 v-bind  简写（：）

2.双向绑定数据v-model

3.方法 methods

4.条件指令 v-if      v-else     v-else-if 切换开销大

v-show 基于css进行切换  需要频繁地切换，则使用v-show较好

5.列表循环指令 v-for   v-for="(n, index) in 5"可获取索引

##### 3.组件（component）

组件可以扩展HTML元素，封装可重用的代码

##### 4.js获取DOM元素

1.document.getElementById()

2.document.getElementByName()

3.document.getElementByTagName()

4.document.getElementByClassName()

##### 5.生命周期

beforeCreate  实例被创建出来之前执行

created   执行时，data 和 methods 都已经被初始化好了

beforeMount   数据挂载前执行

mounted   实例被挂载后执行

beforeUpdate   执行时，内存中的数据已更新，但是页面尚未被渲染

updated   执行时，内存中的数据已更新，并且页面已经被渲染

beforeDestroy   vue对象销毁前执行

destroyed  实例销毁之后执行

##### 6.路由（router）

Vue.js 路由允许我们通过不同的URL访问不同的内容

可以实现多视图的单页Web应用

Vue.js路由需要载入 vue-router 库

# 六 . SpringCloud

##### 1 . 简介

SpringCloud 可以说是一个生态圈 ， 利用SpringBoot的开发便利性 巧妙地简化了分布式系统基础设施的开发 ， 将各家公司开发成熟的服务框架集合起来 ， 这些框架相互协作 ，共同来搭建分布式系统 ， 最终给开发者留出一套简单易懂 、易部署 和易维护的一站式解决方案 ， SpringCloud是目前最常用的微服务框架++

##### 2 . 什么是分布式

为了解决 ： 单个服务器容量和性能问题而采用的优化手段，

将一个业务拆分成不同的子业务 ，分布在不同的服务器上执行，服务之间通过远程调用协同工作，对外提供服务

从理念上将 ，分布式的实现有两种：
**水平扩展 ：**

```
当一台机器扛不住流量时，就通过添加机器的方式 ，将流量平分到所有服务器上，所有服务器都可以提供相同的服务
```

**例：** tomcat默认配置的最大访问量是150 ， 当并发访问量为400超过tomcat的最大访问量之后 ， 添加机器 ，将流量平分到所有服务器上 ， 服务器相同的业务。也就代表网址的内容不会改变。

**垂直拆分 ：**

```
前端有多种查询请求，一台机器扛不住，可以将不同的业务需求分发到不同的机器上，比如A机器处理余票查询的请求，B机器处理支付的请求
```

**例 ：**秉持单一原则 ，安装功能进行拆分 ，将一个复杂的功能拆分成多个单一、简单的功能，这也功能也叫做微服务 ， 将多个微服务组合起来就是微服务架构

##### 3 . 什么是微服务架构

**微服务架构** :

>       将单一的应用程序划分为一组组小的服务 ，拆分完成后 ，每一个服务都运行在独立的进行中，服务与服务之间采用轻量级的通信机制来沟通
>
>       **微服务 ：** 就是被划分的小的服务
>
> 例 ： SpringCloud中采用Http的Restful风格

4 . 什么是负载均衡

5 . 什么是网关

6 . 什么是服务与注册

面试题(总结中~)

总共已有 0 条评论