百问百答

如果我们说另一种不同的语言，那么我们就会发觉有一个不同的世界

　　　　　　　　　　　　　　　　　　　　　　——Luduing Wittgerstein

1、面向对象的特征有哪些

封装

最常见的是把属性私有化封装在一个类里面，只能通过方法去访问

继承

子类继承父类，从而继承了父类的方法和属性

抽象

比如一个英雄类，抽象出了name、hp这些属性，使得开发过程中更加易于理解

多态

多态分操作符的多态和类的多态，类的多态指父类引用指向子类对象，并且有继承，有重写

 

2、String是最基本的数据类型吗

不是，String 是类类型

基本数据类型有四类八种

整型 byte short int long

字符 char

浮点 double float

布尔 boolean

 

3、int 和integer有什么区别

int是基本数据类型32位证书

Integer是类类型，是int的包装类

int和integer之间可以通过自动装箱、自动拆箱互相转换

自动装箱：不需要调用构造方法，通过=符号把基本类型转换为类类型就叫装箱

自动拆箱：不需要调用integer的intvalue方法，通过=就自动转换为int类型，就叫拆箱

 

4、String和StringBuffer的区别

String是immutable的，其内容一旦创建好之后，就不可以发生改变

StringBufffer是可以变长的，内容也可以发生改变

改变的原理是StringBuffer内部采用了字符数组存放数据，在需要增加长度的时候，创建新的数组，并且把原来的数据复制到新的数组这样的办法实现

 

5、为什么String类型不可变

String的成员变量都是private final的，初始化之后不可变。

不可变的好处：最主要还是安全问题

·便于实现字符串池

在java中会大量的使用String常量，如果每一次声明一个String都要创建一个String

对象，那将会造成极大的空间资源浪费。于是提出了String pool的概念，在堆中开辟一块存储空间String tool，当初始化String变量时，如果该字符串已经存在了，就不会创建一个新的字符串变量，而是会返回已经存在了的字符串的引用

· 使线程安全

· 避免安全问题

· 加快字符串处理速度

可通过反射破坏String的不可变性

 

6、运行时异常与一般异常有什么区别？

运行时异常又叫做非可排查异常，在编译过程中，不要求必须进行显示捕捉

一般异常又叫做可排查异常，在编译过程中，必须进行处理，要么捕捉，要么通过throws抛出去

 

7、说出ArrayList，Vector，LinkedList的存储性能和特性

ArrayList和Vector，两者都继承了抽象类AbstractList，但是Vector是线程安全的，而ArrayList是非线程安全的

ArrayList和LinkedList区别，参见8

 

 

8、ArrayList和LinkedList的区别

· ArrayList的实现是基于数组，LinkedList的实现是基于双向链表

· 对于随机访问，ArrayList优于LinkedList，ArrayList可以根据下标O（1）时间复杂度对元素进行随机访问。而LinkedList的每一个元素都依靠地址指针和它后一个元素连接在一起，在这种情况下，查找某个元素的时间复杂度是O（n）

· 对于插入和删除操作，LinkedList优于ArrayList，因为当匀速被添加在LinkedList任意位置的时候，不需要像ArrayList那样重新计算大小或者更新索引

· LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素

 

9、Collection和Collections的区别

Collection是接口，是List和Set的父接口

Collections是工具类，提供了排序、混淆等等实用方法

 

10、&和&&的区别

&有两个作用，分别是位与和逻辑与

&& 就是逻辑与

作为逻辑与，& 和 &&分别表示长路与和短路与

长路与两次都会被运损

短路与 只要第一个是false，第二个就不进行运算了

 

11、HashMap和Hashtable的区别

HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式

区别1：HashMap可以存放null，Hashtable不能

区别2：HashMap不是线程安全的类，Hashtable是

 

12、final、finally、finalize的区别

final

final修饰类、方法、基本类型变量

修饰类，表示该类不能被继承

修饰方法，表示该方法不能被重写

修饰基本类型变量，表示该变量只能被赋值一次

修饰引用 表示引用只有一次指向对象的机会

finally

finally用于异常处理的场面，无论是否有异常抛出，都会执行

finalize

finalize是Object的方法，所有类都继承了该方法。当一个对象满足垃圾回收的条件，并且被回收的时候，其finalize（）方法就会被调用

 

13、Overload和Override的区别，即重载和重写的区别，OverLoaded的方法是否可以改变返回值的类型？

OverLoad。重载

Override 重写

可以，重载其实本质上就是完全不同的方法，只是恰好取了相同的名字

 

14、Error和Exception的区别

Error和Exception都实现了Throwable接口

Error指的是JVM层面的错误，比如内存不足OOM

Exception指的是代码逻辑的异常，比如数组下表越界等

 

15、abstract 、class、抽象类和interface接口的区别

使用方式：

抽象类只能通过继承被使用

接口必须通过实现被使用

 

实现方法：

抽象类不近可以提供抽象方法，也可以提供实现方法

接口只能提供抽象方法，不能提供实现方法，但从1.8开始，接口可以提供实现方法了，前提是要在方法前加一个default修饰符

 

16、heap和stack有什么区别

heap：堆

stack：栈

存放的内容不一样：

heap是存放对象的

stack是存放基本类型，引用、方法调用的

 

存取方式不一样：

heap是自动增加大小的，所以不需要指定大小，但是存取相对较慢

stack是固定大小，并且是FILO陷入后厨的顺序，并且存取速度比较快

 

17、GC是什么？为什么要有GC

GC是垃圾回收英文的缩写

所谓的垃圾，指的是哪些不再被使用的对象，JVM的垃圾回收机制使得开发人员从无聊、容易犯错的手动释放内存资源的过程中解放出来，开发人员可以专注进行业务开发，而资源回收的工作交由更加专业的垃圾回收机制自动完成

 

18、short s1=1，s1=s1+1，有什么错误

short s1=1 无错误，1最终为short类型

s1=s1+1，会出现强制转换错误

 

19、Math.round（11.5）等于多少，Math,round（-11.5）等于多少？

Math.round取整数，四舍五入，第一步为12，第二部为-11

 

20、String s = new String（“xyz”）创建了几个String Object？

构造方法本身就是一个字符串对象

然后new'关键字一定会创建一个对象

所以总共创建了两个String对象

 

21、接口是否可继承接口？抽象类是否可实现接口？抽象类是否可继承实体类？

1>可以，比如List就是继承了Collection

2>可以

3>可以，所有抽象类都继承了Object

 

22、List、Set、Map是否继承自Collection接口

List和Set继承了Collection接口

Map和Collection之间没有继承关系，一个是键值对，一个是单值，无法兼容

 

23、abstract的method是否可同时是static，是否可同时是synchroized？

都不可以

 

24、数组没有length()方法？String有没有该方法？

数组获取长度的手段是.length属性

String获取长度的手段是length()方法

集合获取长度的手段是size()方法

文件获取长度的手段是length()方法

 

25、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢？

以hashSet为例，判断重复的逻辑是：

1>首先看hashcode是否相同，如果不同，就是不重复的

2>如果hashcode一样，再比较equals，如果不同就是不重复的，否则就是重复的

 

26、构造器Constructor是否可被override？是否可继承String类？

子类不能继承父类构造方法，所以就不存在重写父类的构造方法

 

27、switch是否能作用在byte上，是否能作用在long上，是否能作用在String上？

switch可以作用在byte、short、int、String、ENUM上，但是不能作用在long上面

 

28、try{}里有一个return语句，那么紧跟在这个try后的finally{}李的code会不会被执行，什么时候执行，在return前还是后?

try里的return和 finally里的return都会执行，但是当前方法知会采纳finally中return的值

 

29、两个对象值相同(x.equals(y)==true),但却可有不同的hash code，这句话对不对？

因为hashcode（)方法和equals（）方法都可以通过自定义重写，是可以做到equals相同，但是hashcode不同的

 

30、垃圾回收的有点和原理。并考虑2种回收机制

java提供垃圾回收机制，自行GC，将开发人员从容易犯错的内存管理中解放出来

原理：当某一个对象，没有任何引用指向它的时候，那么它就满足垃圾回收的条件，在适当的时候，jvm虚拟机进行GC将其回收，释放空间，以便后续再利用

常见回收机制：

1>定时回收

每隔30分钟进行一次回收，这种机制的弊端是如果垃圾产生的较快，有可能30分钟内垃圾已经把内存占用光了，导致性能变慢

2>当垃圾占到某个百分比的时候，进行回收

比如当垃圾占用到70%的时候，进行回收。这种机制的弊端是，如果垃圾产生的频率很快，那么jvm就必须高频率的进行垃圾回收。而在垃圾回收的过程中，jvm会停顿下来，只做垃圾回收，而影响业务功能的正常运行。

一般来说会将两种机制结合使用

 

31、你所知道的集合类有哪些？主要方法

常见的集合：ArrayList、LinkedList、HashSet、HashMap等等

常见方法：size()，add()，remove()等等

 

32、char型变量中能不能存储一个中文汉字？

char是16位的，占用2个字节。

汉字通常使用GBK编码，也是使用两个字节

所以可以存放汉字

 

33、解析XML文档有集中方式

SAX和DOM

SAX是逐行读取，直到找到目标为止

DOM是先全文档加载，然后读取

 

34、关键字：throws、throw、try~catch、finally分表代表什么意义，在try块中可以抛出异常吗？

throws：用在方法声明上面，表示该方法有可能抛出某个异常

throw：抛出一个指定异常

try~catch：在try中有可能会抛出某个异常，一旦某个异常抛出后，就会在catch中进行捕捉，一般是一起用的

finally：表示无论是否捕捉住异常，都会执行

 

35、java源文件中是否包括多个类？有什么限制

可以包括多个类，但是只能出现一个public修饰的类，但是可以出现多个非public修饰的类

 

36、java中有集中类型的流？

所有的流都是基于字节流，所以最基本的流是：

输入输出字节流：InputStream、OutputStream

在字节流的基础上，封装了字符流：Reader、Writer

进一步又封装了缓存流：BufferedReader、PrintWriter

以及数据流：DataInputStream、DataOutputStream

对象流：ObjectInputStream、ObjectOutputStream

等等

 

37、会出现内存泄露吗，具体说明

会的

当某些对象不被使用，但是又有非直接引用指向的时候，那么就不满足垃圾回收的条件，从而形成内存泄露

demo：

static ArrayList<Object> al = new ArrayList<Object>();
public static void main(String[] args){
for(int i = 0; i < 100; i++){
Object o = new Object();
al.add(o);
}
}

 

38、多态实现的机制是什么？

· 父类引用指向子类对象

· 重写

 

39、静态变量和实例变量的区别

静态变量直接通过类就可以访问，无需实例

示例变量，比如通过类的具体实例，才可以访问

 

40、什么是java序列化？如何实现java序列化

序列化就是把一个java对象，通过某种介质进行传输，比如Socket输入输出流，或者保存在一个文件里

实现java序列化的手段是让该类实现接口Serializable，这个接口是一个标识性接口，没有任何方法，仅仅用于表示该例可以序列化

 

41、是否可以从一个static方法内部发出对非static方法的调用？

不行，因为非static方法需要一个具体的实例才可以调用，而调用static方法的时候，不一定存在一个实例

 

42、List、Map、Set三个接口，存取元素的时候，各有什么特点？

List是有顺序的，并且可以重复的

Set是无序的，不可以重复

Map保存数据的方式是键值对

 

43、Anonymous Inner Class（匿名内部类）是否可以extends其他类，是否可以实现接口？

匿名内部类本质上就是在继承其他的类，实现其他的接口

 

44、内部类可以应用外部类的成员吗？有没有什么限制？

可以使用

如果是非静态内部类，可以使用外部类的所有成员

如果使静态内部类，只能使用外部类的静态成员

 

45、多线程有几种实现方式，都是什么？

三种

· 继承一个Thread类

· 实现Runnable接口

· 匿名内部类

 

46、sleep和wait有什么区别

这二者之间没有任何关系

sleep是Thread类的方法，指的是当前线程暂停

wait是Object类的方法，指的占用当前对象的线程临时释放对当前对象的占用，以使得其他线程有机会占用当前对象。所以调用wait方法一定是在synchronized中进行的

 

47、说说数据连接池的工作机制是什么

连接原理：因为创建链接和关闭连接的行为是非常耗时的。会显著降低软件的性能表现，解决办法就是先创建N条数据库连接Connection，循环使用，但是不进行关闭，这样再执行SQL语句，就不需要额外创建链接了，直接使用。现成的连接就可以，从而节约了创建链接和关闭连接的时间开销

 

48、简述synchronized和java,util,concurrent.locks.Lock的异同

·Lock是一个接口，而synchronized是java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现

·Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一直获取下去，借助Lock这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生

·synchronized在发生异常和同步快结束的时候，会自动释放锁。而Lock必须手动释放，如果忘记释放锁，一样会造成死锁

 

49、Class.forName的作用，为什么要这么用

Class.forName常见场景是在数据库驱动初始化的时候调用

Class.forName本身的意义是加载类到JVM中，一旦一个类被加载到JVM中，它的静态属性就会被初始化，在初始化的过程中就会执行相关代码，从而达到“加载驱动的效果”

 

50、当一个线程进入到一个对象的一个synchronized方法后，其他线程是否可进入此对象的其他方法

视情况而定，如果该对象的其他方法也是有synchronized修饰的，那么其他线程就会被挡在外面，否则其他线程就可以进入其他方法

 

51、举例常见的runtime exception

NullpointException 空指针

ArithMeiticException 算数

ClassCastException 类型转换

ConcurrentModificationException 同步修改

IndexOutOfBoundsException 数组越界

NegativeArraySizeException 为数组分配的空间是负数

 

52、进程、线程和任务之间的区别是什么？

　　进程：是一个OS的抽象概念，是用来执行程序的环境，程序通常运行在用户模式，通过系统调用或自陷来进入内核模式。

　　线程：可被调度的运行在CPU上的可执行上下文，内核拥有多个线程，一个进程有一个或多个线程。

　　任务：一个Linux的可运行实体，可以指一个进程（含有单个线程），或一个多线程的进程里的一个线程，或内核线程。

53、什么是上下文切换？

　　内核程序切换CPU让其在不同的地址空间上做操作（上下文）。

　　有时也称做进程切换或任务切换，是指CPU 从一个进程或线程切换到另一个进程或线程。（百度百科）

54、paging和swapping之间的区别是什么？

　　内存和 SWAP 的这种交换过程称为页面交换(Paging),值得注意的是 paging 和 swapping 是两个完全不同的概念,国内很多参考书把这两个概念混为一谈,swapping 也翻译成交换,在操作系统里是指把某程序完全交换到硬盘以腾出内存给新程序使用,和 paging 只交换程序的部分(页面)是两个不同的概念。纯粹的 swapping 在现代操作系统中已经很难看到了,因为把整个程序交换到硬盘的办法既耗时又费力而且没必要,现代操作系统基本都是 paging 或者 paging/swapping 混合,swapping 最初是在 Unix system V 上实现的。（阿里云PTS）

55、说说进程和线程　　

    进程是程序分配静态资源的基本单位

　　线程是程序动态执行的基本单位

 

56、缓存行大小标准以及一致性

　　64个字节

　　没有一致性标准

 

57、抽象类和接口的区别

　　相同点：

　　　　·都不能被实例化

　　　　·接口的实现类或者抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化

　　不同点：

　　　　·接口只有定义，不能有方法的实现，1.8之后可以定义default，而抽象类可以有定义与实现，方法可在抽象类中实现

　　　　·实现接口的关键字未implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以使用接口可以间接实现多重继承

　　　　·接口强调特定功能的实现，而抽象类强调所述关系

　　　　·接口成员默认为public static final，必须赋初始值，不能被修改；其他所有的成员方法都是public、abstract的。抽象类中成员变量默认为default，可以在子类中被重新定义，也可以被重新赋值；抽象方法被abstrace修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号

 

58、JVM区域分布

java虚拟机的内存分为三个区域：栈stack、堆heap、方法区method area

栈stack：

1>栈描述的是方法执行的内存模型，每个方法都被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等）

2>jvm为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）

3>栈属于线程私有，不能实现线程间的共享

4>栈的存储特性是“先进后出，后进先出”

5>栈是系统自动分配，速度快，栈是一个连续的内存空间！

 

堆：

1>堆用于存储创建好的对象和数组（数组也是对象）

2>jvm只有一个堆，被所有线程共享

3>堆是一个不连续的内存空间，分配灵活，速度慢

 

方法区（静态区）：

1>jvm只有一个方法区，被所有线程共享

2>方法区实际也是堆，只是被用于存储类和常量相关的信息

3>用来存放程序中永远不变的内容（类信息【class对象】、静态变量、字符串常量等）

 

内存分析图：

 59、描述你知道的设计模式

1>简单工厂模式

    优点：工厂中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除与具体产品的依赖.

    客户实例化对象时不需要关系该对象是由哪个子类实例化的。

    优点：帮助封装、解耦。

    缺点：可能增加客户端的复杂度，不方便扩展子厂

2>、单例模式

  ·某个类只能有一个实例

  ·它必须自行创建这个实例

  ·它必须自行向整个系统提供这个实例

优点：

  ·实例控制：单例模式会阻止其他对象实例化自己的单例对象的副本，从而确定所有对象都访问唯一实例

  ·灵活性：因为类控制了是实例化过程，所以类可以灵活更改实例过程

缺点：

 ·开销：虽然数量少，但如果每次对象请求引用时都要检查是否存在类的实例，仍然需要一些开销，可以通过使用静态初始化解决此问题

 ·可能的开发混淆：使用单例对象（尤其是在类库中定义的对象），开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问类库源码，因此开发人员可能会意外发现自己无法直接实例化此类。

 ·对象生存期：不能解决删除单个对象的问题

 

60、简述回调

1>同步调用

类A的方法a（）调用类B（）中的方法b（），一直等到b()方法执行完毕，a（）方法继续走、

该调用方式适用于b()方法执行时间不长的情况下，因为b()方法若是阻塞，则后方代码无法执行，会造成流程阻塞。

 

2>异步调用

为了解决上述同步调用中可能出现的阻塞，导致流程卡顿的一种方式。

类A的方法a()通过

 

3>回调

类A的a（）方法调用类B的b()方法

类B的b()方法执行完毕主动调用类的A的callback()方法

是一种双向调用方式

回调具体参见https://www.cnblogs.com/richered/p/12170519.html

 

61、说说RPC、为什么需要RPC，以及常用的RPC框架？

RPC：远程过程调用

 

为什么需要RPC：

如果没有统一的RPC框架，各个团队的服务提供方就需要各自实现一套序列化、反序列化、网络框架、线程池、收发线程、超时处理、状态机等“业务之外”的重复技术劳动，造成整体的低效

 

RPC框架的职责：屏蔽各种复杂性

1、调用方client感觉就像调用本地函数一样，来调用服务

2、提供方server感觉就像实现一个本地函数一样，来实现服务

 

常见的框架：

1、Dubbo

2、gRPC

3、BRPC

62、为什么要用MQ？有哪些常见的MQ

MQ使用核心（优点）：解耦、异步、流量削峰

缺点：1>系统可用性降低

　　  2>系统复杂程度提高

　　　3>一致性问题

四大主流MQ：kafka、ActiveMQ、RabbitMQ、RocketMQ

 

63、简述同步和异步的区别

同步是阻塞模式

异步是非阻塞模式

同步是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程会一直等待下去，直到收到返回消息才会继续执行下去

异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样会提高执行效率

 

64、简述一个web请求都经历了哪些步骤，最终用户才能收到响应

1、浏览器通过DNS解析域名

2、客户端通过TCP/IP协议建立到服务器TCP连接

3、客户端向服务器发送HTTP协议请求包，请求服务器里的资源文档

4、服务器向客户机发送HTTP协议应答包，如果请求的资源包含有动态语言的内容，那么服务器会调用动态语言的解释引擎负责处理“动态内容”，并将处理得到的数据返回给客户端

5、客户端与服务端断开。由客户端解释HTML文档，在客户端屏幕上渲染图形结果

65、TCP三次握手和四次挥手，为什么需要三次握手才能建立连接，而不是两次或者四次？

三次握手：

1、client首先发一个连接试探（syn），本次交互不产生任何数据交互，server如收到该连接试探，需要确认，而client处于syn_sent状态，也就是等待状态。

2、Server如果监听到该数据报文请求，如同意连接，则向client发送确认。其确认信息简单说法为：syn+ack。此时Server的状态为syn_rcvd状态。

3、当client收到Serve的syn+ack消息，（简易说法：收到可以确认发消息的提示）client进入established（建立连接完成）状态，便可以发请求了。

 

为什么需要三次握手建立连接？

首先，client和Server通信前，都需要进行连接，而三次挥手的作用就是：双方都能明确自己和对方的收、发能力是正常的。

第一次握手：Client发送，Server收；Server端可以确认Client的发送，Server的接收能力正常

第二次握手：Server发送，Client收；Clien端可以确认Server的发送，Client的接收能力正常，从Client的角度看：收到的Server发送过来响应数据包，说明Server接收到了第一次握手时发送的syn试探请求，并且成功发送了响应数据包，说明Server的接受、发送能力正常。另一方面收到了Server的响应数据包，则说明Client第一次发送的包到达了Server端，那么Client的发送、接收能力都正常。

第三次握手：Client发包，Server收；则Server端便可得出结论：Client的接收、发送能力和Server的接收、发送能力都正常。第一次握手和第二次握手Server并不知道Client的接收能力和自己的发送能力是否正常。而在第三次握手的时候，Server收到了Client对第二次握手做出的回应，因此，从服务端的角度，自己第二次握手的数据包发送出去了，Client也接收到了。因此Server的发送能力正常，而Client的接收能力也正常。

因此从上述中可以得出结论，其动作最少需要三次握手，两次达不到都让双方得出自己的接收、发送以及对方的接收、发送能力是否正常的结论。

 

为什么需要四次挥手才能断开连接？

因为服务端在listen状态下，收到建立连接请求的syn报文后,把ack和syn放在一个报文里边发送给客户端（此处的两步是合成一步走）。而在关闭连接时，当收到对方的FIN报文时，仅仅表示对方不再发送数据，但是还是能接收数据，己方是否现在关闭数据连接通道需要上层应用来决定，因此己方ACk和FIN一般都会分开发送

 

66、简述反向代理

反向代理方式是指以代理服务器来接受ｉｎｔｅｒｎｅｔ上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到结果返回给ｉｎｔｅｒｎｅｔ上请求连接的客户端，此时代理服务器对外表现就是一个服务器。

反向代理服务器对于客户端而言像是原始服务器，并且客户端不需要进行任何特别的设置。

正向代理简称代理，ＶＰＮ便是如此。跳板机也是如此。

 

67、事务四大特征

原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败

持久性：当事务提交或者回滚后，数据库会持久化保存数据

隔离性：多个事务时间，相互隔离

一致性：事务操作前后，数据总量不变

 

68、简述ORM

Mybatis就是ORM框架的代表。ORM就是定义实体类和映射表之间的关系，将数据库操作的dao接口用xml文件进行实现

 

69、SpringMVC请求流程

1、前端请求

2、至spring容器中，由DispatcherServlet（前端控制器）拦截处理

3、DispatcherServlet将url转发至HandllerMapping（处理器映射）

4、HandllerMapping进行解析url，读取完成返回给DispatcherServlet调用链

5、DispatcherServlet将调用链转发给HandlAdapter,HandlAdapter（处理器适配器）通过反射根据调用链进行调用controller

6、controller无论返回给HandlAdapter的是string还是moduleandview，HandlAdapter都会转换成ModuleAndView返回给DispatcherServlet

7、DispatcherServlet将ModuleAndView给ViewResolver（视图解析器）进行解析，并将结果(module)返回

8、DispatcherServlet将得到的module传给View进行渲染

 

70、Spring事务隔离级别

1、串行化：T1在执行过程中，T2既不能读也不能写

2、可重复读：T1在执行的过程中，T2只能能读但不能改，T2可以添加数据（幻读）

3、读已提交：T1在执行的过程，T2可以读也可以写，但是T1只能读取到T2提交之后的数据（不可重复读）

4、读未提交：T1在执行过程中，T2可以读也可以写，T1可以读到T2未提交的数据（脏读）

71、spring核心组件

· DispatcherServlet 前端控制器，接收前端请求

· HandllerMapping 处理器映射

· HandlAdapter 处理器适配器：根据处理器映射器的用户请求，通过适配器模式完成Handler的调用

· Handler 处理器/控制器 业务开发，作用：处理请求

· ModuleAndView 视图模型：用于封装处理器返回的数据以及相应的视图

· ViewResolver 视图解析器，对ModuleAndView进行解析，可配置SpringMVC提供多个视图解析器实现，根据需要进行配置

· View，完成数据渲染

 

72、jvm堆内存划分

年轻代（eden、Survivor）、老年代（Old、Thenured）、持久代

 

73、垃圾回收过程

1、新创建的对象，绝大多数会存储在Eden中

2、当Eden满了（达到一定比例）不能创建对象，则触发垃圾回收（GC），将无用对象清理掉，然后剩余对象复制到某个Survivor，如S1、同时清理Eden区

3、当Eden区再次满了，会将S1中的不能清空的对象存到另外一个Survivor中，如S2同时将Eden区中的不能清空的对象，也复制到S1中，保证Eden和S1，均被清空

4、重复多次（默认15次）Survivor中没有被清理的对象，则会复制到老年代Old（Thenured）区中

5、当Old区满了，则会触发一个一次完整的垃圾回收（FullGC），之前新生代的垃圾回收成为（minorGC）

 

74、服务流量处理三大手段，三者之间的关系

熔断：请求不同，则主动断开，不是一直在请求

降级：弃车保帅，降流量大的服务引流至不用的的服务容器上

限流：对并发访问进行限速，手段通常有拒绝服务、服务降级、特权请求

熔断是降级的一种方式，降级是限流的一种方式

 

75、Spring Framework的优点

·由于 Spring Frameworks 的分层架构，用户可以自由选择自己需要的组件。

·Spring Framework 支持 POJO(Plain Old Java Object) 编程，从而具备持续集成和可测试性。

·由于依赖注入和控制反转，JDBC 得以简化。

·它是开源免费

 

76、Spring Framework有哪些不同的功能？

·轻量级 - Spring 在代码量和透明度方面都很轻便

·IOC - 控制反转

·AOP - 面向切面编程可以将应用业务逻辑和系统服务分离，以实现高内聚

·容器 - Spring负责创建和管理对象（Bean）的声明周期和配置

·MVC - 对web应用提供了高度可配置性，其他框架的集成也非常方便

·事务管理 - 提供了用于事务管理的通用抽象层。spring的事务支持也可用于容器较少的环境

·JDBC异常 - Spring的JDBC抽象层提供了一个异常层次结构，简化了错误处理策略

 

77、什么是Spring IOC容器

Spring框架的核心是Spring容器。容器创建对象，将他们装配在一起，配置它们并管理它们的完整生命周期。Spring容器使用依赖注入来管理组成应用程序的组件。容器通过读取提供的配置元数据来接收对象进行实例化、配置和组装的指令。该元数据可以通过xml、java注解或java源代码提供

 

78、什么是依赖注入

在依赖注入中，你不比创建对象，但你必须描述如何创建它们。你不是直接在代码中将组件和服务连接在一起，而是描述配置文件中哪些组件需要哪些服务。由IOC容器将它们装配在一起

 

79、通过几种方式完成依赖注入

三种

·构造函数注入

·setter注入

·接口注入

 

80、列举IOC的一些好处

·将最小化应用程序中的代码量

·将你的应用程序易于测试，因为它不需要单元测试用例中的任何单例或JNDI查找机制

·以最小的应用和最少的侵入机制促进松耦合

·支持即时的实例化和延迟加载服务

 

81、什么是Spring bean

·它们是构成用户应用程序主干的对象

·Bean是由IOC容器管理

·是由IOC容器实例化，配置、装配和管理

·Bean是基于用户提供给容器的配置元数据创建

 

82、Spring提供了哪些配置方式

·基于xml配置

·基于注解配置

·基于java api配置

 

83、Spring bean容器的生命周期是什么样的

1、Spring 容器根据配置中的bean定义实例化bean

2、Spring使用依赖注入填充所有属性，如bean中所定义的配置

3、如果bean实现BeanNameAware接口，则工厂通过传递bean的ID来调用setBeanName（）

4、如果bean实现了BeanFactoryAware接口，工厂通过传递自身的实例来调用setBeanFactory()

5、如果存在与Bean关联的任何BeanPostProcessors，则调用preProcessBeforeInitialization()

6、如果bean指定了init（）方法（<bean>的init-method属性），那么将调用它

7、最后，如果存在与bean关联的任何BeanPostProcessors，则将调用postProcessAfterInitialization()方法

8、如果bean实现了DisposableBean接口，当spring容器关闭时，会调用destory()

9、如果为bean指定destory方法（<bean>的destory-method属性），那么将调用它

 

84、什么是aop

面向切面变成，与OOP相辅相成，提供了与OOP不同的抽象软件结构视角

在OOP中，我们以类作为我们的单元，而aop中的基本单元是切面

 

85、什么是切点（JoinPoint）

程序运行中的一些时间点，例如一个方法的执行，或者一个异常的处理

在aop中，join point总是方法的执行点

 

86、什么是通知（Advice）

特定JoinPoint处的Aspect所采取的动作成为Advice。Spring aop使用一个advice作为拦截器，在JoinPoint“周围”维护一些列的拦截器

 

87、aop有哪些实现方式

实现 AOP 的技术，主要分为两大类：

• 静态代理 - 指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；
  • 编译时编织（特殊编译器实现）
  • 类加载时编织（特殊的类加载器实现）。
• 动态代理 - 在运行时在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。
  • JDK 动态代理
  • CGLIB

 

88、对称加密和非对称加密的区别

1、加密和解密过程不同

　　对称加密过程和解密过程使用的同一个密钥，加密过程相当于用原文+密钥可以传输出密文，同时解密过程用密文-密钥可以密钥推导出原文。但是非对称加密采用了两个密钥，一般使用公钥进行加密，使用私钥进行解密

2、加密解密速度不同

　　对称加解密速度比较快，适合数据比较长使用，非对称加密和解密话费的时间长，速度相对较慢，适合少量数据使用

3、传输的安全性不同

对称加密中无法确保密钥被安全传递，密文在传输过程中是可能被第三方截获的，如果密码本也被第三方截获，则传输的密码信息将被第三方破获，安全性较低

非对称加密算法中私钥是基于不同的算法生成不同的随机数，私钥通过一定的加密算法推导出公钥，但私钥到公钥的推导过程是单向的，也就是说公钥无法反推导出私钥。所以安全性较高

 

区别主要在：加密算法、安全性、流程图、加密耗时

 

89、程序内存溢出的原因

1、堆溢出

　　·代码可能存在大对象分配

　　·可能存在内存泄露，导致在多次GC之后，还是无法找到一块足够大的内存容纳当前对象

   解决方法：

　　1、检查是否存在大对象的分配，最有可能是大数组分配

    2、通过jmap命令，把堆内存dump下来，使用mat工具分析一下，检查是否存在内存泄露的问题

    3、如果没有找到明显的内存泄露，使用-Xmx加大堆内存

　  4、还有一点容易被忽略，检查是否有大量的自定义Finalizable对象，也有可能是框架内部提供的，考虑其存在的必要性

2、永久代/元空间溢出

　　·在java7之前频繁的错误使用String.intern()方法

　　·运行后期间生成了大量的代理类，导致方法区被撑爆，无法卸载

　　·应用长时间运行，没有重启

　　解决方法：

　　1、检查是否永久代空间或者元空间设置的过小

　　2、检查代码中是否存在大量的反射操作

　　3、dump之后通过mat检查是否存在大量由于反射生成的代理类

　　4、重启JVM

3、方法栈溢出

　　创建了大量的线程导致。

　　解决方法：

　　1、通过-Xxs降低每个线程栈大小的容量

　　2、线程总数也收到了系统空闲内存和操作系统的限制，检查是否该系统下有此限制

4、非常规溢出

　　分配超大数组

5、swap溢出

　　·swap分区大小分配不足

　　·其他进程消耗了所有的内存

　　解决方案：

　　1、其他服务进程选择性的拆分出去

　　2、加大swap分区大小，或者加大机器内存大小

6、本地方法溢出

等等

 

90、什么是MVC模式

软件架构模式，把软件系统分为三个基本部分：模型/数据（Model）、视图(View)和控制器(Controller)

 

91、TCP保证可靠传输的手段有哪些

　　·将数据截断为合理的长度

　　·超时重发

　　·对于收到的请求，给出确认时间

　　·校验出包有错，丢弃报文段，不给出响应，TCP发送数据段，超时时会重发数据

　　·对失序数据进行重新排序，然后才交给应用层

　　·TCP还能提供流量控制

 

92、String类可以被继承吗

不可以，有final修饰符

 

93、final修饰符的作用

修饰类，类不可被继承

修饰方法、方法不能被重写

修饰基本类型变量，标识该变量只有一次赋值机会

修饰引用，表示该应用只有1此指向对象的机会

 

 

94、重写和重载的区别

重写是子类对父类的允许访问的方法实现进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写

重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法都必须有一个独一无二的参数类型列表

 95、HashMap是线程安全的吗，如何实现线程安全

不安全

·HashTable

·synchronizedMap()

·ConcurrentHashMap

96、linux中如何干掉python进程

·killall python

·sudo pkill python

97、SQL慢查询怎么排查

1、查询慢查询数量

sleetc * from slow_log where start_time > ""

2、查询当前进行的查询状态

select * frominformation_schema.processlist

慢查询表查询结果里买呢有几个重要的指标start_time（开始时间）、query_time（查询时间）

rows_sent 和 rows_examined发送的结果数以及查询扫过的行数，这两个值特别重要，特别是 rows_examined。基本上就能告诉我们，哪个查询是需要注意的“大”查询。

98、进程间的通信方式有哪些

·匿名管道通信

·高级管道通信

·有名管道通信

·消息队列通信

·信号量通信

·信号

·共享内存通信

·套接字通信

99、缓存雪崩、击穿、穿透是什么

雪崩：当某一个时刻出现啊规模的缓存失效的情况，那么导致大量的请求打在数据库上面，导致数据库压力巨大，如果在高并发的情况下，可能就回导致数据库宕机。这是手如果运维马上重启数据库，马上又会有新的流量把数据库打死，这就是缓存雪崩

击穿：和缓存雪崩类似，缓存雪崩是大规模的key失效，而缓存击穿是一个热点key、有大并发集中对其进行访问，突然间这个key失效了，导致大并发全部打在数据库上，导致数据库压力剧增，

穿透：假如发送的请求传进来的key是不存在的，那么就查不到缓存，查不到缓存就会去查数据库。假如有这样大量的请求一直打在数据库上，这就是穿透

100、微信发红包的测试用例

　　功能：

　　1、红包最多可以输入的金额

　　2、红包一次性可以发送的最大个数

　　3、在输入红包的钱数和个数只能输入数字

　　4、当余额不足，红包发送失败

　　5、发送的红包自己是否可以领取

　　6、发送的红包他人是否可以领取

　　7、红包超过24小时是否可以领取

　　8、红包超时未领取，是否退回原账户

　　9、是否可以自己选择支付方式

　　10、红包描述可以输入的最大字符

　　11、余额不足时，是否可以切换支付方式

　　12、用户是否可以多次抢一个红包

　　13、余额不足时，是否可以自动匹配支付方式

　　14、直接输入小数点，那么小数点之前是否有0

　　15、是否可以连续多次发红包

　　16、输入钱数为0，“塞钱包”置灰

　　17、断网，无法发红包、抢红包

　　18、支付时指纹、面容、密码支付

　　19、可以返回键、取消发红包

　　性能测试：

　　1、弱网抢红包、发红包的时间

　　2、不同网速抢红包、发红包

　　3、发红包和收红包成功后的跳转时间

　　4、收发红包的耗电量

　　5、退款到账时间

　　兼容：

　　1、ios、android

　　2、电脑端

　　3、2/3/4g，wifi，联通/移动/电信

　　4、不同分辨率

　　界面：

　　1、发红包界面错别字

　　2、收红包界面错别字

　　3、发红包收红包界面布局是否合理

　　4、颜色搭配

    参考：https://blog.nowcoder.net/n/c8e332c4cf66445da182d5c307040301

101、线程同步机制

　　·临界区

　　·互斥量

　　·时间

　　·信号量

102、路由器和交换机分别在网络协议哪一层？

　　路由器在网络层

　　交换机在数据链路层

103、TCP拥塞机制

TCP拥塞控制属于端到端的控制方法，其核心便是观察感知网络的拥塞状态，然后调整发送速度。在TCP中引入了拥塞窗口，流量控制中引入了接收窗口。最终TCP的发送窗口为min

·如何感知网络？丢包、确认代表网络畅通

·慢启动

·拥塞避免

·拥塞发生

·快速恢复

104、索引的优缺点

优点：

1、创建唯一性索引，保证数据库表中每一行数据的唯一性

2、大大加快数据的检索速度，这也是创建索引的最主要的原因

3、加速表和表之间的链接，特别是在实现数据的参考完整性方面特别有意义

4、在使用分组和排序字句进行数据检索时，同样可以显著减少查询中分组和排序的时间

5、通过使用索引，可以在查询的过程中使用优化隐藏器，提高系统的性能

缺点：

1、创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加

2、索引需要占用物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大

3、当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，降低了数据的维护速度

105、乐观锁和悲观锁

乐观锁和悲观锁是两种思想，用于解决并发场景下的数据竞争问题

乐观锁：乐观锁在操作数据时非常乐观，认为别人不会同事修改数据。因此乐观锁不会上锁，只是在执行更新的时候判断一下在此期间别人是否修改了数据；如果别人修改了数据则放弃操作，否则执行操作

悲观锁：悲观锁在操作数据的时候比较悲观，认为别人会同事修改数据。因此操作数据时直接把数据锁住，直到操作完成后才会释放锁，上锁期间其他人也不能修改数据

　　

106、Redis为什么效率那么高

1、完全基于内存，绝大部分请求是纯粹的内存操作，非常快速

2、数据结构简单，对数据操作也简单，Redis中的数据结构是专门进行设计的

3、采用单线程，避免了不必要的上下文切换和竞争条件

4、使用多路I/O复用模型，非阻塞IO

5、底层模型不同，自己构建了VM机制，一般的效用系统函数的话，会浪费一定的时间去移动和请求

107、如何判断网络丢包

·mtr

·ping

·traceroute

108、MySQL事务隔离级别

脏读

可重复读

不可重复读

幻读

109、http协议状态码

1xx：信息提示

2xx：成功

3xx：重定向

4xx：客户端错误

5xx：服务端错误

110、http协议请求方法

GET： 请求指定的页面信息，并返回实体主体。

HEAD： 只请求页面的首部。

POST： 请求服务器接受所指定的文档作为对所标识的URI的新的从属实体。

PUT： 从客户端向服务器传送的数据取代指定的文档的内容。

DELETE： 请求服务器删除指定的页面。

OPTIONS： 允许客户端查看服务器的性能。

TRACE： 请求服务器在响应中的实体主体部分返回所得到的内容。

PATCH(patch)： 实体中包含一个表，表中说明与该URI所表示的原内容的区别。

MOVE： 请求服务器将指定的页面移至另一个网络地址。

COPY： 请求服务器将指定的页面拷贝至另一个网络地址。

LINK： 请求服务器建立链接关系。

UNLINK： 断开链接关系。

WRAPPED(wrapped)： 允许客户端发送经过封装的请求。