Java 最多见 200+ 面试题全解析：面试必备（2019）

时间  2019-12-07 标签 java 多见 面试 解析 必备

【说明】

文章面试题整理出自：http://www.javashuo.com/article/p-muydmgqx-cb.htmlphp

目录css

【说明】html

适宜阅读人群前端

1、Java 基础java

2、容器mysql

3、多线程git

4、反射程序员

5、对象拷贝github

6、Java Webweb

7、异常

8、网络

9、设计模式

10、Spring/Spring MVC

11、Spring Boot/Spring Cloud

12、Hibernate

十3、Mybatis

十4、RabbitMQ

未更新完成。。。。

十5、Kafka

十6、Zookeeper

十7、MySql

十8、Redis

十9、JVM

这篇文章多数答案都是出自网上，同时对不少文章进行阅读和拼接，因此没有写明出处，有些感受写的不错或者比较好理解的文章就附了一个链接，有不少答案不是很细致，若是想细致研究，每一个问题能够延伸一篇篇幅很长的文章，因此须要单独花时间去了解学习。其实面试题不少技术也没有用过，从网上看一些文章，大致写一下，可能会存在问题，后面有时间，我会将知识点系统看一篇，完善和补充，欢迎你们提意见

本文的主题，咱们这份面试题，包含的内容了十九了模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。以下图所示：

 

适宜阅读人群

    须要面试的初/中/高级 java 程序员

    想要查漏补缺的人

    想要不断完善和扩充本身 java 技术栈的人

    java 面试官

 

下面一块儿来看 208 道面试题，具体的内容。

1、Java 基础

1.JDK 和 JRE 有什么区别？

  • JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
  • JRE：Java Runtime Environment 的简称，Java 运行环境，为 Java 的运行提供了所需环境。

具体来讲 JDK 其实包含了 JRE，同时还包含了编译 Java 源码的编译器 Javac，还包含了不少 Java 程序调试和分析的工具。简单来讲：若是你须要运行 Java 程序，只需安装 JRE 就能够了，若是你须要编写 Java 程序，须要安装 JDK

2.== 和 equals 的区别是什么？

== 的做用

  • 基本类型：比较的是值是否相同。
  • 引用类型：比较的是引用是否相同。

equals 的做用：比较的都是值是否相同。

【代码示例】

String x = "string";
String y = "string";
String z = new String("string");
System. out. println(x==y); // true
System. out. println(x==z); // false
System. out. println(x. equals(y)); // true
System. out. println(x. equals(z)); // true

【代码解读】

由于 x 和 y 指向的是同一个引用，因此 == 也是 true，而 new String() 方法则重写开辟了内存空间，因此 == 结果为 false，而 equals 比较的一直是值，因此结果都为 true。

3.两个对象的 hashCode()相同，则 equals()也必定为 true，对吗？

不对，两个对象的 hashCode() 相同，equals() 不必定 true。

【代码示例】

String str1 = "通话";
String str2 = "重地";
System. out. println(String. format("str1：%d | str2：%d",  str1. hashCode(),str2. hashCode()));
System. out. println(str1. equals(str2));

【代码结果】

str1：1179395 | str2：1179395
     
false

【代码解读】

      很显然“通话”和“重地”的 hashCode() 相同，然而 equals() 则为 false，由于在散列表中，hashCode() 相等即两个键值对的哈希值相等，然而哈希值相等，并不必定能得出键值对相等。

4.final 在 java 中有什么做用？

  • final 修饰的类叫最终类，该类不能被继承。
  • final 修饰的方法不能被重写。
  • final 修饰的变量叫常量，常量必须初始化，初始化以后值就不能被修改。

5.java 中的 Math.round(-1.5) 等于多少？

   等于 -1，Math. round 四舍五入大于 0. 5 向上取整的。

6.String 属于基础的数据类型吗？

  String 不属于基础类型，基础类型有 8 种：byte、boolear、char、short、int、float、long、double，String 属于对象。

7.java 中操做字符串都有哪些类？它们之间有什么区别？

操做字符串的类有：String、StringBuffer、StringBuilder。

String 和 StringBuffer、StringBuilder 的区别在于 :

String 声明的是不可变的对象，每次操做都会生成新的 String 对象，而后将指针指向新的 String 对象,

而 StringBuffer、StringBuilder 能够在原有对象的基础上进行操做，因此在常常改变字符串内容的状况下最好不要使用 String。

StringBuffer 和 StringBuilder 最大的区别在于:

  线程是否安全 性能 推荐使用场景
StringBuffer 线程安全 低 多线程环境
StringBuilder 非线程安全 高 单线程环境

 

8.String str="i"与 String str=new String(“i”)同样吗？

不同，由于内存的分配方式不同。String str="i"的方式，Java 虚拟机会将其分配到常量池中；而 String str=new String("i") 则会被分到堆内存中。

9.如何将字符串反转？

【代码示例】

使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

// StringBuffer reverse
StringBuffer stringBuffer = new StringBuffer();
stringBuffer. append("abcdefg");
System. out. println(stringBuffer. reverse()); // gfedcba
// StringBuilder reverse
StringBuilder stringBuilder = new StringBuilder();
stringBuilder. append("abcdefg");
System. out. println(stringBuilder. reverse()); // gfedcba

10.String 类的经常使用方法都有那些？

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

11.抽象类必需要有抽象方法吗？

不须要，抽象类不必定非要有抽象方法。

【代码示例】

abstract class Cat {
    public static void sayHi() {
        System. out. println("hi~");
    }
}

12.普通类和抽象类有哪些区别？

  • 普通类不能包含抽象方法，抽象类能够包含抽象方法。
  • 抽象类不能直接实例化，普通类能够直接实例化。

13.抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其余类继承的，若是定义为 final 该类就不能被继承，这样彼此就会产生矛盾，因此 final 不能修饰抽象类

14.接口和抽象类有什么区别？

  • 默认方法实现：抽象类能够有默认的方法实现；接口不能有默认的方法实现。
  • 实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。
  • 构造函数：抽象类能够有构造函数；接口不能有。
  • main 方法：抽象类能够有 main 方法，而且咱们能运行它；接口不能有 main 方法。
  • 实现数量：类能够实现不少个接口；可是只能继承一个抽象类。
  • 访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法能够是任意访问修饰符。

15.java 中 IO 流分为几种？

  • 按功能来分：输入流（input）、输出流（output）
  • 按类型来分：字节流和字符流。
  • 字节流和字符流的区别是：字节流按 8 位传输以字节为单位输入输出数据，字符流按 16 位传输以字符为单位输入输出数据。

16.BIO、NIO、AIO 有什么区别？

  • BIO：Block IO 同步阻塞式 IO，就是咱们日常使用的传统 IO，它的特色是模式简单使用方便，并发处理能力低。
  • NIO：New IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端经过 Channel（通道）通信，实现了多路复用。
  • AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操做基于事件和回调机制。

17.Files的经常使用方法都有哪些？

  • Files. exists()：检测文件路径是否存在。
  • Files. createFile()：建立文件。
  • Files. createDirectory()：建立文件夹。
  • Files. delete()：删除一个文件或目录。
  • Files. copy()：复制文件。
  • Files. move()：移动文件。
  • Files. size()：查看文件个数。
  • Files. read()：读取文件。
  • Files. write()：写入文件。

2、容器

18.java 容器都有哪些？

  • Collection
    • List
      • ArrayList
      • LinkedList
      • Vector
      • Stack
    • Set
      • HashSet
      • LinkedHashSet
      • TreeSet
  • Map
    • HashMap
      • LindedHashMap
    • TreeMap
    • ConcurrentHashMap
    • Hashtable

19.Collection 和 Collections 有什么区别？

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

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

List、Set、Map 的区别主要体如今两个方面：元素是否有序、是否容许元素重复。

具体能够参考这篇文章：http://www.javashuo.com/article/p-rytwayvv-dd.html

21.HashMap 和 Hashtable 有什么区别？

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

22.如何决定使用 HashMap 仍是 TreeMap？

对于在 Map 中插入、删除、定位一个元素这类操做，HashMap 是最好的选择，由于相对而言 HashMap 的插入会更快，但若是你要对一个 key 集合进行有序的遍历，那 TreeMap 是更好的选择

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

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

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

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

25.ArrayList 和 LinkedList 的区别是什么？

  • 数据结构实现：ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。
  • 随机访问效率：ArrayList 比 LinkedList 在随机访问的时候效率要高，由于 LinkedList 是线性的数据存储方式，因此须要移动指针从前日后依次查找。
  • 增长和删除效率：在非首尾的增长和删除操做，LinkedList 要比 ArrayList 效率要高，由于 ArrayList 增删操做要影响数组内的其余数据的下标。

综合来讲，在须要频繁读取集合中的元素时，更推荐使用 ArrayList，而在插入和删除操做较多时，更推荐使用 LinkedList。

26.如何实现数组和 List 之间的转换？

  • 数组转 List：使用 Arrays. asList(array) 进行转换。
  • List 转数组：使用 List 自带的 toArray() 方法。

【代码示例】

// list to array
List<String> list = new ArrayList<String>();
list. add("王磊");
list. add("的博客");
list. toArray();
// array to list
String[] array = new String[]{"王磊","的博客"};
Arrays. asList(array);

27.ArrayList 和 Vector 的区别是什么？

  • 线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。
  • 性能：ArrayList 在性能方面要优于 Vector。
  • 扩容：ArrayList 和 Vector 都会根据实际的须要动态的调整容量，只不过在 Vector 扩容每次会增长 1 倍，而 ArrayList 只会增长 50%。

28.Array 和 ArrayList 有何区别？

  • Array 能够存储基本数据类型和对象，ArrayList 只能存储对象。
  • Array 是指定固定大小的，而 ArrayList 大小是自动扩展的。
  • Array 内置方法没有 ArrayList 多，好比 addAll、removeAll、iteration 等方法只有 ArrayList 有。

29.在 Queue 中 poll()和 remove()有什么区别？

  • 相同点：都是返回第一个元素，并在队列中删除返回的对象。
  • 不一样点：若是没有元素 poll()会返回 null，而 remove()会直接抛出 NoSuchElementException 异常。

【代码示例】

Queue<String> queue = new LinkedList<String>();
queue. offer("string"); // add
System. out. println(queue. poll());
System. out. println(queue. remove());
System. out. println(queue. size());

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

Vector、Hashtable、Stack 都是线程安全的，而像 HashMap 则是非线程安全的，不过在 JDK 1.5 以后随着 Java. util. concurrent 并发包的出现，它们也有了本身对应的线程安全类，好比 HashMap 对应的线程安全类就是 ConcurrentHashMap。

31.迭代器 Iterator 是什么？

Iterator 接口提供遍历任何 Collection 的接口。咱们能够从一个 Collection 中使用迭代器方法来获取迭代器实例。迭代器取代了 Java 集合框架中的 Enumeration，迭代器容许调用者在迭代过程当中移除元素。

32.Iterator 怎么使用？有什么特色？

【代码示例】

List<String> list = new ArrayList<>();
Iterator<String> it = list. iterator();
while(it. hasNext()){
  String obj = it. next();
  System. out. println(obj);
}

Iterator 的特色是更加安全，由于它能够确保，在当前遍历的集合元素被更改的时候，就会抛出 ConcurrentModificationException 异常。

33.Iterator 和 ListIterator 有什么区别？

  • Iterator 能够遍历 Set 和 List 集合，而 ListIterator 只能遍历 List。
  • Iterator 只能单向遍历，而 ListIterator 能够双向遍历（向前/后遍历）。
  • ListIterator 从 Iterator 接口继承，而后添加了一些额外的功能，好比添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

34.怎么确保一个集合不能被修改？

能够使用 Collections. unmodifiableCollection(Collection c) 方法来建立一个只读集合，这样改变集合的任何操做都会抛出 Java. lang. UnsupportedOperationException 异常。

【代码示例】

List<String> list = new ArrayList<>();
list. add("x");
Collection<String> clist = Collections. unmodifiableCollection(list);
clist. add("y"); // 运行时此行报错
System. out. println(list. size());

 

3、多线程

35.并行和并发有什么区别？

  • 并行：一个处理器同时处理多个任务。
  • 并发：多个处理器或多核处理器同时处理多个不一样的任务。

36.线程和进程的区别？

一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也能够有多个线程来增长程序的执行速度。

37.守护线程是什么？

守护线程是运行在后台的一种特殊进程。它独立于控制终端而且周期性地执行某种任务或等待处理某些发生的事件。在 Java 中垃圾回收线程就是特殊的守护线程。

38.建立线程有哪几种方式？

建立线程有三种方式：

  • 继承 Thread 从新 run 方法；
  • 实现 Runnable 接口；
  • 实现 Callable 接口。

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

runnable 没有返回值，callable 能够拿到有返回值，callable 能够看做是 runnable 的补充。

40.线程有哪些状态？

线程的状态：

  • NEW 还没有启动
  • RUNNABLE 正在执行中
  • BLOCKED 阻塞的（被同步锁或者IO锁阻塞）
  • WAITING 永久等待状态
  • TIMED_WAITING 等待指定的时间从新被唤醒的状态
  • TERMINATED 执行完成

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

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

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

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

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

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

44.建立线程池有哪几种方式？

线程池建立有七种方式，最核心的是最后一种：

  • newSingleThreadExecutor()：它的特色在于工做线程数目被限制为 1，操做一个无界的工做队列，因此它保证了全部任务的都是被顺序执行，最多会有一个任务处于活动状态，而且不容许使用者改动线程池实例，所以能够避免其改变线程数目；
  • newCachedThreadPool()：它是一种用来处理大量短期工做任务的线程池，具备几个鲜明特色：它会试图缓存线程并重用，当无缓存线程可用时，就会建立新的工做线程；若是线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 做为工做队列；
  • newFixedThreadPool(int nThreads)：重用指定数目（nThreads）的线程，其背后使用的是无界的工做队列，任什么时候候最多有 nThreads 个工做线程是活动的。这意味着，若是任务数量超过了活动队列数目，将在工做队列中等待空闲线程出现；若是有工做线程退出，将会有新的工做线程被建立，以补足指定的数目 nThreads；
  • newSingleThreadScheduledExecutor()：建立单线程池，返回 ScheduledExecutorService，能够进行定时或周期性的工做调度；
  • newScheduledThreadPool(int corePoolSize)：和newSingleThreadScheduledExecutor()相似，建立的是个 ScheduledExecutorService，能够进行定时或周期性的工做调度，区别在于单一工做线程仍是多个工做线程；
  •  newWorkStealingPool(int parallelism)：这是一个常常被人忽略的线程池，Java 8 才加入这个建立方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序；
  •  ThreadPoolExecutor()：是最原始的线程池建立，上面1-3建立方式都是对ThreadPoolExecutor的封装

45.线程池都有哪些状态？

  •  RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。
  •  SHUTDOWN：不接受新的任务提交，可是会继续处理等待队列中的任务。
  • STOP：不接受新的任务提交，再也不处理等待队列中的任务，中断正在执行任务的线程。
  • TIDYING：全部的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。
  • TERMINATED：terminated()方法结束后，线程池的状态就会变成这个。

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

  • execute()：只能执行 Runnable 类型的任务。
  • submit()：能够执行 Runnable 和 Callable 类型的任务。

Callable 类型的任务能够获取执行的返回值，而 Runnable 执行无返回值。

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

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

【手动锁代码示例】

Lock lock = new ReentrantLock();
lock. lock();
try {
    System. out. println("得到锁");
} catch (Exception e) {
    // TODO: handle exception
} finally {
    System. out. println("释放锁");
    lock. unlock();
}

48.多线程锁的升级原理是什么？

在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，JVM 让其持有偏向锁，并将threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否尤为线程 id 一致，若是一致则能够直接使用，若是不一致，则升级偏向锁为轻量级锁，经过自旋循环必定次数来获取锁，不会堵塞，执行必定次数以后就会升级为重量级锁，进入堵塞，整个过程就是锁升级的原理。

锁的升级的目的：在 Java 6 以后优化 synchronized 的实现方式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，减低了锁带来的性能消耗。

锁升级是为了减低了锁带来的性能消耗。

49.什么是死锁？

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

50.怎么防止死锁？

  • 尽可能使用 tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时能够退出防止死锁。
  • 尽可能使用 Java. util. concurrent 并发类代替本身手写锁。
  • 尽可能下降锁的使用粒度，尽可能不要几个功能用同一把锁。
  • 尽可能减小同步的代码块。

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

ThreadLocal 为每一个使用该变量的线程提供独立的变量副本，因此每个线程均可以独立地改变本身的副本，而不会影响其它线程所对应的副本。

ThreadLocal 的经典使用场景是数据库链接和 session 管理等。

52.说一下 synchronized 底层实现原理？

synchronized 是由一对 monitorenter/monitorexit 指令实现的，monitor 对象是同步的基本实现单元。在 Java 6 以前，monitor 的实现彻底是依靠操做系统内部的互斥锁，由于须要进行用户态到内核态的切换，因此同步操做是一个无差异的重量级操做，性能也很低。但在 Java 6 的时候，Java 虚拟机 对此进行了大刀阔斧地改进，提供了三种不一样的 monitor 实现，也就是常说的三种不一样的锁：偏向锁（Biased Locking）、轻量级锁和重量级锁，大大改进了其性能。

53.synchronized 和 volatile 的区别是什么？

  • volatile 是变量修饰符；synchronized 是修饰类、方法、代码段。
  • volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则能够保证变量的修改可见性和原子性。
  • volatile 不会形成线程的阻塞；synchronized 可能会形成线程的阻塞。

54.synchronized 和 Lock 有什么区别？

  • synchronized 能够给类、方法、代码块加锁；而 lock 只能给代码块加锁。
  • synchronized 不须要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会形成死锁；而 lock 须要本身加锁和释放锁，若是使用不当没有 unLock()去释放锁就会形成死锁。
  • 经过 Lock 能够知道有没有成功获取锁，而 synchronized 却没法办到。

55.synchronized 和 ReentrantLock 区别是什么？

synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，可是在 Java 6 中对 synchronized 进行了很是多的改进。

主要区别以下：

  •     ReentrantLock 使用起来比较灵活，可是必须有释放锁的配合动做；
  •     ReentrantLock 必须手动获取与释放锁，而 synchronized 不须要手动释放和开启锁；
  •     ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等。
  •     volatile 标记的变量不会被编译器优化；synchronized 标记的变量能够被编译器优化。
     

56.说一下 atomic 的原理？

atomic 主要利用 CAS (Compare And Wwap) 和 volatile 和 native 方法来保证原子操做，从而避免 synchronized 的高开销，执行效率大为提高。

 

4、反射

57.什么是反射？

反射是在运行状态中，对于任意一个类，都可以知道这个类的全部属性和方法；对于任意一个对象，都可以调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。

58.什么是 java 序列化？什么状况下须要序列化？

Java 序列化是为了保存各类对象在内存中的状态，而且能够把保存的对象状态再读出来。

如下状况须要使用 Java 序列化：

  • 想把的内存中的对象状态保存到一个文件中或者数据库中时候；
  • 想用套接字在网络上传送对象的时候；
  • 想经过RMI（远程方法调用）传输对象的时候。

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

动态代理是运行时动态生成代理类。

动态代理的应用有 spring aop、hibernate 数据查询、测试框架的后端 mock、rpc，Java注解对象获取等。

60.怎么实现动态代理？

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

5、对象拷贝

61.为何要使用克隆？

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

62.如何实现对象克隆？

  • 实现 Cloneable 接口并重写 Object 类中的 clone() 方法。
  • 实现 Serializable 接口，经过对象的序列化和反序列化实现克隆，能够实现真正的深度克隆。

63.深拷贝和浅拷贝区别是什么？

  • 浅克隆：当对象被复制时只复制它自己和其中包含的值类型的成员变量，而引用类型的成员对象并无复制。
  • 深克隆：除了对象自己被复制外，对象所包含的全部成员变量也将复制。

 

6、Java Web

64.jsp 和 servlet 有什么区别？

JSP 是 servlet 技术的扩展，本质上就是 servlet 的简易方式。servlet 和 JSP 最主要的不一样点在于，servlet 的应用逻辑是在 Java 文件中，而且彻底从表示层中的 html 里分离开来，而 JSP 的状况是 Java 和 html 能够组合成一个扩展名为 JSP 的文件。JSP 侧重于视图，servlet 主要用于控制逻辑。

65.jsp 有哪些内置对象？做用分别是什么？

JSP 有 9 大内置对象：

  •     request：封装客户端的请求，其中包含来自 get 或 post 请求的参数；
  •     response：封装服务器对客户端的响应；
  •     pageContext：经过该对象能够获取其余对象；
  •     session：封装用户会话的对象；
  •     application：封装服务器运行环境的对象；
  •     out：输出服务器响应的输出流对象；
  •     config：Web 应用的配置对象；
  •     page：JSP 页面自己（至关于 Java 程序中的 this）；
  •     exception：封装页面抛出异常的对象。

66.说一下 jsp 的 4 种做用域？

  • page：表明与一个页面相关的对象和属性。
  • request：表明与客户端发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件；须要在页面显示的临时数据能够置于此做用域。
  • session：表明与某个用户与服务器创建的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户本身的 session 中。
  • application：表明与整个 Web 应用程序相关的对象和属性，它实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局做用域。

67.session 和 cookie 有什么区别？

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

【分享】

cookie 的总数量没有限制，可是每一个域名的COOKIE 数量和每一个COOKIE 的大小是有限制的！

  • IE 每一个域名限制为50 个。
  • Firefox 每一个域名cookie 限制为50 个。
  • Opera 每一个域名cookie 限制为30 个。
  • Safari/webkit 貌似没有cookie 限制。可是假如cookie 不少，则会使header 大小超过服务器的处理的限制，致使错误发生。
  • 不一样浏览器间每一个cookie 文件大小也不一样
  • Firefox 和safari 是4097 个字节，包括名（name）、值（value）和等号。
  • Opera 是4096 个字节，包括：名（name）、值（value）和等号。
  • IE 是4095 个字节，包括：名（name）、值（value）和等号。

68.说一下 session 的工做原理？

session 的工做原理是客户端登陆完成以后，服务器会建立对应的 session，session 建立完以后，会把 session 的 id 发送给客户端，客户端再存储到浏览器中。这样客户端每次访问服务器时，都会带着 sessionid，服务器拿到 sessionid 以后，在内存找到与之对应的 session 这样就能够正常工做了。

69.若是客户端禁止 cookie 能实现 session 还能用吗？

能够用，session 只是依赖 cookie 存储 sessionid，若是 cookie 被禁用了，能够使用 url 中添加 sessionid 的方式保证 session 能正常使用。

70.spring mvc 和 struts 的区别是什么？

  • 拦截级别：struts2 是类级别的拦截；spring mvc 是方法级别的拦截。
  • 数据独立性：spring mvc 的方法之间基本上独立的，独享 request 和 response 数据，请求数据经过参数获取，处理结果经过 ModelMap 交回给框架，方法之间不共享变量；而 struts2 虽然方法之间也是独立的，但其全部 action 变量是共享的，这不会影响程序运行，却给咱们编码和读程序时带来了必定的麻烦。
  • 拦截机制：struts2 有以本身的 interceptor 机制，spring mvc 用的是独立的 aop 方式，这样致使struts2 的配置文件量比 spring mvc 大。
  • 对 ajax 的支持：spring mvc 集成了ajax，全部 ajax 使用很方便，只须要一个注解 @ResponseBody 就能够实现了；而 struts2 通常须要安装插件或者本身写代码才行。

71.如何避免 sql 注入？

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

72.什么是 XSS 攻击，如何避免？

XSS 攻击：即跨站脚本攻击，它是 Web 程序中常见的漏洞。原理是攻击者往 Web 页面里插入恶意的脚本代码（css 代码、Javascript 代码等），当用户浏览该页面时，嵌入其中的脚本代码会被执行，从而达到恶意攻击用户的目的，如盗取用户 cookie、破坏页面结构、重定向到其余网站等。

预防 XSS 的核心是必须对输入的数据作过滤处理。

73.什么是 CSRF 攻击，如何避免？

CSRF：Cross-Site Request Forgery（中文：跨站请求伪造），能够理解为攻击者盗用了你的身份，以你的名义发送恶意请求，好比：以你名义发送邮件、发消息、购买商品，虚拟货币转帐等。

防护手段：

  •     验证请求来源地址；
  •     关键操做添加验证码；
  •     在请求地址添加 token 并验证。

7、异常

74.throw 和 throws 的区别？

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

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

  • final：是修饰符，若是修饰类，此类不能被继承；若是修饰方法和变量，则表示此方法和此变量不能在被改变，只能使用。
  • finally：是 try{} catch{} finally{} 最后一部分，表示不论发生任何状况都会执行，finally 部分能够省略，但若是 finally 部分存在，则必定会执行 finally 里面的代码。
  • finalize： 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法。

76.try-catch-finally 中哪一个部分能够省略？

try-catch-finally 其中 catch 和 finally 均可以被省略，可是不能同时省略，也就是说有 try 的时候，必须后面跟一个 catch 或者 finally。

77.try-catch-finally 中，若是 catch 中 return 了，finally 还会执行吗？

finally 必定会执行，即便是 catch 中 return 了，catch 中的 return 会等 finally 中的代码执行完以后，才会执行。

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

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

8、网络

79.http 响应码 301 和 302 表明的是什么？有什么区别？

301：永久重定向。

302：暂时重定向。

它们的区别是，301 对搜索引擎优化（SEO）更加有利；302 有被提示为网络拦截的风险。

【分享】

其余的一些常见的响应码 能够参考以前的一篇文章：https://blog.csdn.net/u011665991/article/details/82458808

80.forward 和 redirect 的区别？

forward 是转发 和 redirect 是重定向：

  •     地址栏 url 显示：foward url 不会发生改变，redirect url 会发生改变；
  •     数据共享：forward 能够共享 request 里的数据，redirect 不能共享；
  •     效率：forward 比 redirect 效率高。

81.简述 tcp 和 udp的区别？

tcp 和 udp 是 OSI 模型中的运输层中的协议。tcp 提供可靠的通讯传输，而 udp 则常被用于让广播和细节控制交给应用的通讯传输。

二者的区别大体以下：

  •     tcp 面向链接，udp 面向非链接即发送数据前不须要创建连接；
  •     tcp 提供可靠的服务（数据传输），udp 没法保证；
  •     tcp 面向字节流，udp 面向报文；
  •     tcp 数据传输慢，udp 数据传输快；

82.tcp 为何要三次握手，两次不行吗？为何？

若是采用两次握手，那么只要服务器发出确认数据包就会创建链接，但因为客户端此时并未响应服务器端的请求，那此时服务器端就会一直在等待客户端，这样服务器端就白白浪费了必定的资源。若采用三次握手，服务器端没有收到来自客户端的再此确认，则就会知道客户端并无要求创建请求，就不会浪费服务器的资源

83.说一下 tcp 粘包是怎么产生的？

tcp 粘包可能发生在发送端或者接收端，分别来看两端各类产生粘包的缘由：

  • 发送端粘包：发送端须要等缓冲区满才发送出去，形成粘包；
  • 接收方粘包：接收方不及时接收缓冲区的包，形成多个包接收。

84.OSI 的七层模型都有哪些？

  • 物理层：利用传输介质为数据链路层提供物理链接，实现比特流的透明传输。
  • 数据链路层：负责创建和管理节点间的链路。
  • 网络层：经过路由选择算法，为报文或分组经过通讯子网选择最适当的路径。
  • 传输层：向用户提供可靠的端到端的差错和流量控制，保证报文的正确传输。
  • 会话层：向两个实体的表示层提供创建和使用链接的方法。
  • 表示层：处理用户信息的表示问题，如编码、数据格式转换和加密解密等。
  • 应用层：直接向用户提供服务，完成用户但愿在网络上完成的各类工做。

85.get 和 post 请求有哪些区别？

  • get 请求会被浏览器主动缓存，而 post 不会。
  • GET使用URL或Cookie传参，而POST将数据放在BODY中。
  • get 传递参数有大小限制，而 post 没有。
  • post 参数传输更安全，get 的参数会明文限制在 url 上，post 不会。

说到get 和 post 请求有哪些区别，大多数同窗都会想到这几个标准答案，可是这三个答案是不是正确的仍是有待商榷。

    1. GET使用URL或Cookie传参，而POST将数据放在BODY中

GET和POST是由HTTP协议定义的。在HTTP协议中，Method和Data（URL， Body， Header）是正交的两个概念，也就是说，使用哪一个Method与应用层的数据如何传输是没有相互关系的。

HTTP没有要求，若是Method是POST数据就要放在BODY中。也没有要求，若是Method是GET，数据（参数）就必定要放在URL中而不能放在BODY中。

那么，网上流传甚广的这个说法是从何而来的呢？我在HTML标准中，找到了类似的描述。这和网上流传的说法一致。可是这只是HTML标准对HTTP协议的用法的约定。怎么能当成GET和POST的区别呢？

并且，现代的Web Server都是支持GET中包含BODY这样的请求。虽然这种请求不可能从浏览器发出，可是如今的Web Server又不是只给浏览器用，已经彻底地超出了HTML服务器的范畴了。

    2. GET方式提交的数据有长度限制，则POST的数据则能够很是大

先说结论：HTTP协议对GET和POST都没有对长度的限制。HTTP协议明确地指出了，HTTP头和Body都没有长度的要求。

首先是"GET方式提交的数据有长度限制"，若是咱们使用GET经过URL提交数据，那么GET可提交的数据量就跟URL的长度有直接关系了。而实际上，URL不存在参数上限的问题，HTTP协议规范没有对URL长度进行限制。这个限制是特定的浏览器及服务器对它的限制。IE对URL长度的限制是2083字节(2K+35)。对于其余浏览器，如Netscape、FireFox等，理论上没有长度限制，其限制取决于操做系统的支持。

注意这个限制是整个URL长度，而不只仅是你的参数值数据长度。

POST也是同样，POST是没有大小限制的，HTTP协议规范也没有对POST数据进行大小限制，起限制做用的是服务器的处理程序的处理能力。

固然，咱们常说GET的URL会有长度上的限制这个说法是怎么回事呢？虽然这个不是GET和POST的本质区别，可是咱们也能够说说致使URL长度限制的两方面的缘由：

1. 浏览器。早期的浏览器会对URL长度作限制。而如今的具体限制是怎么样的，我本身没有亲测过，就不复制网上的说法啦。

2. 服务器。URL长了，对服务器处理也是一种负担。本来一个会话就没有多少数据，如今若是有人恶意地构造几个M大小的URL，并不停地访问你的服务器。服务器的最大并发数显然会降低。另外一种攻击方式是，告诉服务器Content-Length是一个很大的数，而后只给服务器发一点儿数据，服务器你就傻等着去吧。哪怕你有超时设置，这种故意的次次访问超时也能让服务器吃不了兜着走。有鉴于此，多数服务器出于安全啦、稳定啦方面的考虑，会给URL长度加限制。可是这个限制是针对全部HTTP请求的，与GET、POST没有关系。

    3. POST比GET安全，由于数据在地址栏上不可见

这个说法其实也是基于上面的1，2两点的基础上来讲的，我以为没什么问题，可是须要明白为何使用GET在地址栏上就不安全了，以及还有没有其余缘由说明“POST比GET安全”。

经过GET提交数据，用户名和密码将明文出如今URL上，由于登陆页面有可能被浏览器缓存，其余人查看浏览器的历史纪录，那么别人就能够拿到你的帐号和密码了，除此以外，使用GET提交数据还可能会形成Cross-site request forgery攻击。

3、个人理解

“1. GET使用URL或Cookie传参，而POST将数据放在BODY中”，这个是由于HTTP协议用法的约定。并不是它们的自己区别。

“2. GET方式提交的数据有长度限制，则POST的数据则能够很是大”，这个是由于它们使用的操做系统和浏览器设置的不一样引发的区别。也不是GET和POST自己的区别。

“3. POST比GET安全，由于数据在地址栏上不可见”，这个说法没毛病，但依然不是GET和POST自己的区别。

虽然这三点不是它们的自己区别，但至少是它们在使用上的区别，因此我在面试这个问题时，若是面试者可以回答上面三点我基本会给个及格分。那么你想不想要更高的分数？

4、终极区别

GET和POST最大的区别主要是GET请求是幂等性的，POST请求不是。这个是它们本质区别，上面的只是在使用上的区别。

    什么是幂等性？幂等性是指一次和屡次请求某一个资源应该具备一样的反作用。简单来讲意味着对同一URL的多个请求应该返回一样的结果。

正由于它们有这样的区别，因此不该该且不能用get请求作数据的增删改这些有反作用的操做。由于get请求是幂等的，在网络很差的隧道中会尝试重试。若是用get请求增数据，会有重复操做的风险，而这种重复操做可能会致使反作用（浏览器和操做系统并不知道你会用get请求去作增操做）。

5、个人建议

若是面试官问你这个问题时，我建议你说出上面三点，同时要说明那三点是它们在使用上的区别，固然也要把它们的终极区别给说出来。

PS：曾经有一个研读了HTTP协议的人去一家公司面试，面试官问他这个问题时，他回答“GET是用于获取数据的，POST通常用于将数据发给服务器。其余GET和POST没什么区别”，因而被刷了。

由于有些面试官心中也只有那一个“标准答案”。


86.如何实现跨域？

实现跨域有如下几种方案：

  • 服务器端运行跨域 设置 CORS 等于 *；
  • 在单个接口使用注解 @CrossOrigin 运行跨域；
  • 使用 jsonp 跨域；

87.说一下 JSONP 实现原理？

ajax请求受同源策略影响，不容许进行跨域请求，而script标签src属性中的连接却能够访问跨域的js脚本，利用这个特性，服务端再也不返回JSON格式的数据，而是返回一段调用某个函数的js代码，在src中进行了调用，这样实现了跨域。

【分享】具体能够参考此文章：

https://blog.csdn.net/u011897301/article/details/52679486/

https://blog.csdn.net/u011897301/article/details/52679486/

9、设计模式

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

一共23种设计模式！

引用《软件秘笈-设计模式那点事》书籍：

按照目的来分，设计模式能够分为建立型模式、结构型模式和行为型模式。
建立型模式用来处理对象的建立过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。

建立型模式用来处理对象的建立过程，主要包含如下5种设计模式：


结构型模式用来处理类或者对象的组合，主要包含如下7种设计模式：


行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含如下11种设计模式：

  • 责任链模式（Chain of Responsibility Pattern）
  • 命令模式（Command Pattern）
  • 解释器模式（Interpreter Pattern）
  • 迭代器模式（Iterator Pattern）
  • 中介者模式（Mediator Pattern）
  • 备忘录模式（Memento Pattern）
  • 观察者模式（Observer Pattern）
  • 状态模式（State Pattern）
  • 策略模式（Strategy Pattern）
  • 模板方法模式（Template Method Pattern）
  • 访问者模式（Visitor Pattern）

举两个单例模式，其余的本身网上学习吧
单例模式实现1：

public class Singleton {
    // 类共享实例对象
    private static Singleton singleton = null;
    // 私有构造方法
    private Singleton() {
        System.out.println("-- this is Singleton!!!");
    }
    // 得到单例方法
    public synchronized static Singleton getInstance() {
        // 判断 共享对象是否为null ，如何为null则new一个新对象
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}


单例模式实现2：

public class Singleton {
    // 类共享实例对象 实例化
    private static Singleton singleton = new Singleton();
    // 私有构造方法
    private Singleton() {
        System.out.println("-- this is Singleton!!!");
    }
    // 得到单例方法
    public static Singleton getInstance() {
        // 直接返回共享对象
        return singleton;
    }
}

89.简单工厂和抽象工厂有什么区别？

工厂模式主要是为建立对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：

  • 1. 简单工厂模式(Simple Factory)
  • 2. 工厂方法模式(Factory Method)
  • 3. 抽象工厂模式(Abstract Factory)

这三种模式从上到下逐步抽象，而且更具通常性。还有一种分类法，就是将简单工厂模式看为工厂方法模式的一种特例，两个归为一类。二者皆可，这本为使用《Java与模式》的分类方法。
在什么样的状况下咱们应该记得使用工厂模式呢？大致有两点：

  • 1.在编码时不能预见须要建立哪一种类的实例。
  • 2.系统不该依赖于产品类实例如何被建立、组合和表达的细节

具体的能够参考这篇文章：https://www.cnblogs.com/zhangchenliang/p/3700820.html

10、Spring/Spring MVC

90.为何要使用 spring？

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架，它由Rod Johnson建立。它是为了解决企业应用开发的复杂性而建立的。Spring使用基本的JavaBean来完成之前只可能由EJB完成的事情。

91.解释一下什么是 aop？

    AOP（Aspect-Oriented Programming）指一种程序设计范型，该范型以一种称为切面（aspect）的语言构造为基础，切面是一种新的模块化机制，用来描述分散在对象、类或方法中的横切关注点（crosscutting concern）。

    Spring提供了面向切面编程的丰富支持，容许经过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该作的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

92.解释一下什么是 ioc？

       IoC就是(Inversion of Control)，控制反转。在Java开发中，IoC意味着将你设计好的类交给系统去控制，而不是在你的类内部控制。这称为控制反转。

   Spring经过一种称做控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会经过被动的方式传递进来，而不是这个对象本身建立或者查找依赖对象。你能够认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

93.spring 有哪些主要模块？

Spring有七大模块组成：

  • 核心容器（Spring Core）

　　核心容器提供Spring框架的基本功能。Spring以bean的方式组织和管理Java应用中的各个组件及其关系。Spring使用BeanFactory来产生和管理Bean，它是工厂模式的实现。BeanFactory使用控制反转(IoC)模式将应用的配置和依赖性规范与实际的应用程序代码分开。

  • 应用上下文（Spring Context）

　　Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，如JNDI、EJB、电子邮件、国际化、校验和调度功能。

  • Spring面向切面编程（Spring AOP）

　　经过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring框架中。因此，能够很容易地使 Spring框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。经过使用 Spring AOP，不用依赖 EJB 组件，就能够将声明性事务管理集成到应用程序中。

  • JDBC和DAO模块（Spring DAO）

　　JDBC、DAO的抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理，和不一样数据库供应商所抛出的错误信息。异常层次结构简化了错误处理，而且极大的下降了须要编写的代码数量，好比打开和关闭连接。

  • 对象实体映射（Spring ORM）

　　Spring框架插入了若干个ORM框架，从而提供了ORM对象的关系工具，其中包括了Hibernate、JDO和 IBatis SQL Map等，全部这些都听从Spring的通用事物和DAO异常层次结构。

  • Web模块（Spring Web）

　　Web上下文模块创建在应用程序上下文模块之上，为基于web的应用程序提供了上下文。因此Spring框架支持与Struts集成，web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工做。

  • MVC模块（Spring Web MVC）

　　MVC框架是一个全功能的构建Web应用程序的MVC实现。经过策略接口，MVC框架变成为高度可配置的。MVC容纳了大量视图技术，其中包括JSP、POI等，模型来有JavaBean来构成，存放于m当中，而视图是一个街口，负责实现模型，控制器表示逻辑代码，由c的事情。Spring框架的功能能够用在任何J2EE服务器当中，大多数功能也适用于不受管理的环境。Spring的核心要点就是支持不绑定到特定J2EE服务的可重用业务和数据的访问的对象，毫无疑问这样的对象能够在不一样的J2EE环境，独立应用程序和测试环境之间重用。

94.spring 经常使用的注入方式有哪些？

以前写过一篇文章 经常使用的注解，有须要的能够参考：http://www.javashuo.com/article/p-srydofeh-bh.html

  • @Configuration把一个类做为一个IoC容器，它的某个方法头上若是注册了@Bean，就会做为这个Spring容器中的Bean。
  • @Scope注解 做用域
  • @Lazy(true) 表示延迟初始化
  • @Service用于标注业务层组件、
  • @Controller用于标注控制层组件（如struts中的action）
  • @Repository用于标注数据访问组件，即DAO组件。
  • @Component泛指组件，当组件很差归类的时候，咱们能够使用这个注解进行标注。
  • @Scope用于指定scope做用域的（用在类上）
  • @PostConstruct用于指定初始化方法（用在方法上）
  • @PreDestory用于指定销毁方法（用在方法上）
  • @DependsOn：定义Bean初始化及销毁时的顺序
  • @Primary：自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将做为首选者，不然将抛出异常
  • @Autowired 默认按类型装配，若是咱们想使用按名称装配，能够结合@Qualifier注解一块儿使用。以下：
  • @Autowired @Qualifier("personDaoBean") 存在多个实例配合使用
  • @Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。
  • @PostConstruct 初始化注解
  • @PreDestroy 摧毁注解 默认 单例  启动就加载
  • @Async异步方法调用

95.spring 中的 bean 是线程安全的吗？

Spring框架并无对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题须要开发者自行去搞定。但实际上，大部分的Spring bean并无可变的状态(好比Serview类和DAO类)，因此在某种程度上说Spring的单例bean是线程安全的。若是你的bean有多种状态的话（好比 View Model 对象），就须要自行保证线程安全。

最浅显的解决办法就是将多态bean的做用域由“singleton”变动为“prototype”。

96.spring 支持几种 bean 的做用域？

当经过spring容器建立一个Bean实例时，不只能够完成Bean实例的实例化，还能够为Bean指定特定的做用域。Spring支持以下5种做用域：

  • singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例

  • prototype：原型模式，每次经过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例

  • request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不一样的Bean实例。只有在Web应用中使用Spring时，该做用域才有效

  • session：对于每次HTTP Session，使用session定义的Bean豆浆产生一个新实例。一样只有在Web应用中使用Spring时，该做用域才有效

  • globalsession：每一个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。典型状况下，仅在使用portlet context的时候有效。一样只有在Web应用中使用Spring时，该做用域才有效

　　其中比较经常使用的是singleton和prototype两种做用域。对于singleton做用域的Bean，每次请求该Bean都将得到相同的实例。容器负责跟踪Bean实例的状态，负责维护Bean实例的生命周期行为；若是一个Bean被设置成prototype做用域，程序每次请求该id的Bean，Spring都会新建一个Bean实例，而后返回给程序。在这种状况下，Spring容器仅仅使用new 关键字建立Bean实例，一旦建立成功，容器不在跟踪实例，也不会维护Bean实例的状态。

　　若是不指定Bean的做用域，Spring默认使用singleton做用域。Java在建立Java实例时，须要进行内存申请；销毁实例时，须要完成垃圾回收，这些工做都会致使系统开销的增长。所以，prototype做用域Bean的建立、销毁代价比较大。而singleton做用域的Bean实例一旦建立成功，能够重复使用。所以，除非必要，不然尽可能避免将Bean被设置成prototype做用域。

97.spring 自动装配 bean 有哪些方式？

　　Spring中bean有三种装配机制，分别是：

  • 1. 在xml中显示配置；
  • 2. 在java中显示配置；
  • 3. 隐式的bean发现机制和自动装配。

【分享】

有须要的能够参考：http://www.javashuo.com/article/p-wmnlpxni-gk.html

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

事务：事务逻辑上的一组操做,组成这组操做的各个逻辑单元,要么一块儿成功,要么一块儿失败.好比，保证数据的运行不会说A给B钱,A钱给了B却没收到。

实现事务的三种方式：

  • 1.aspectJ AOP实现事务：
  • 2.事务代理工厂Bean实现事务：
  • 3.注解方式实现事务：

在须要进行事务的方法上增长一个注解“@Transactional(rollbackFor = MyExepction.class )”

99.说一下 spring 的事务隔离？

  • 事务特性（4种）:
    • 原子性 （atomicity）:强调事务的不可分割.
    • 一致性 （consistency）:事务的执行的先后数据的完整性保持一致.
    • 隔离性 （isolation）:一个事务执行的过程当中,不该该受到其余事务的干扰
    • 持久性（durability） :事务一旦结束,数据就持久到数据库
  • 若是不考虑隔离性引起安全性问题:
    • 脏读 :一个事务读到了另外一个事务的未提交的数据
    • 不可重复读 :一个事务读到了另外一个事务已经提交的 update 的数据致使屡次查询结果不一致.
    • 虚幻读 :一个事务读到了另外一个事务已经提交的 insert 的数据致使屡次查询结果不一致.
  • 解决读问题: 设置事务隔离级别（5种）
    • DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
    • 未提交读（read uncommited） :脏读，不可重复读，虚读都有可能发生
    • 已提交读 （read commited）:避免脏读。可是不可重复读和虚读有可能发生
    • 可重复读 （repeatable read） :避免脏读和不可重复读.可是虚读有可能发生.
    • 串行化的 （serializable） :避免以上全部读问题.
    • Mysql 默认:可重复读
    • Oracle 默认:读已提交

  1. read uncommited：是最低的事务隔离级别，它容许另一个事务能够看到这个事务未提交的数据。
  2. read commited：保证一个事物提交后才能被另一个事务读取。另一个事务不能读取该事物未提交的数据。
  3. repeatable read：这种事务隔离级别能够防止脏读，不可重复读。可是可能会出现幻象读。它除了保证一个事务不能被另一个事务读取未提交的数据以外还避免了如下状况产生（不可重复读）。
  4. serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读以外，还避免了幻象读（避免三种）。
  • 事务的传播行为（7种）

PROPAGION_XXX :事务的传播行为

  • * 保证同一个事务中
    • PROPAGATION_REQUIRED 支持当前事务，若是不存在 就新建一个(默认)
    • PROPAGATION_SUPPORTS 支持当前事务，若是不存在，就不使用事务
    • PROPAGATION_MANDATORY 支持当前事务，若是不存在，抛出异常
  • * 保证没有在同一个事务中
    • PROPAGATION_REQUIRES_NEW 若是有事务存在，挂起当前事务，建立一个新的事务
    • PROPAGATION_NOT_SUPPORTED 以非事务方式运行，若是有事务存在，挂起当前事务
    • PROPAGATION_NEVER 以非事务方式运行，若是有事务存在，抛出异常
    • PROPAGATION_NESTED 若是当前事务存在，则嵌套事务执行

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

流程 

  • 一、用户发送请求至前端控制器DispatcherServlet 
  • 二、DispatcherServlet收到请求调用HandlerMapping处理器映射器。 
  • 三、处理器映射器找到具体的处理器，生成处理器对象及处理器拦截器(若是有则生成)一并返回给DispatcherServlet。 
  • 四、DispatcherServlet调用HandlerAdapter处理器适配器 
  • 五、HandlerAdapter通过适配调用具体的处理器(Controller，也叫后端控制器)。 
  • 六、Controller执行完成返回ModelAndView 
  • 七、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet 
  • 八、DispatcherServlet将ModelAndView传给ViewReslover视图解析器 
  • 九、ViewReslover解析后返回具体View 
  • 十、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。 
  • 十一、DispatcherServlet响应用户

101.spring mvc 有哪些组件？

名称 简介
HandlerMapping 管理请求(request)和处理句柄(Handler)之间的映射关系
HandlerAdapter 处理句柄适配器,
1.每一个HandlerAdapter包装一个Handler,
2.HandlerAdapter主要用于隔离调用者DispatcherServlet和各式各样的Handler
HandlerExceptionResolver 处理句柄异常解析器
ViewResolver 视图解析器：根据视图名称和Locale解析为具体View对象用来渲染页面
RequestToViewNameTranslator 请求到视图名称的翻译器:从request中获取视图名称,做为ViewResolver的补充
LocaleResolver Locale地区解析器
处理本地化/国际化语言相关，结合上下文和当前请求分析获得应该使用的Locale地区
ThemeResolver 主题解析器，处理UI主题(look and feel)相关
MultipartResolver Multipart上传数据解析器
FlashMapManager 管理FlashMap结构的重定向参数

102.@RequestMapping 的做用是什么？

@RequestMapping

RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。

【分享】具体能够参考文章：https://www.cnblogs.com/qq78292959/p/3760560.html

103.@Autowired 的做用是什么？

这个注解就是spring能够自动帮你把bean里面引用的对象的setter/getter方法省略，它会自动帮你set/get。

<bean id="userDao" class="..."/>
<bean id="userService" class="...">
    <property name="userDao">
      <ref bean="userDao"/>
    </property>
</bean>

这样你在userService里面要作一个userDao的setter/getter方法。

但若是你用了@Autowired的话，你只须要在UserService的实现类中声明便可。

@Autowired

private IUserDao userdao;

11、Spring Boot/Spring Cloud

104.什么是 spring boot？

 SpringBoot是一个框架，一种全新的编程规范，他的产生简化了框架的使用，所谓简化是指简化了Spring众多框架中所需的大量且繁琐的配置文件，因此 SpringBoot是一个服务于框架的框架，服务范围是简化配置文件

105.为何要用 spring boot？

最明显的特色是，让文件配置变的至关简单、让应用部署变的简单（SpringBoot内置服务器，并装备启动类代码），能够快速开启一个Web容器进行开发

  •   （1）一个简单的SpringBoot工程是不须要在pom.xml手动添加什么配置的，若是与其余技术合用 好比postMan（文档在线自动生成、开发功能测试的一套工具）、Swagger(文档在线自动生成、开发功能测试的一套工具)，则须要在pom.xml中添加依赖，由程序自动加载依赖jar包等配置文件。
  •   （2）咱们以前在利用SSM或者SSH开发的时候，在resources中储存各类对应框架的配置文件，而如今咱们只须要一个配置文件便可，配置内容也大致有 服务器端口号、数据库链接的地址、用户名、密码。这样，虽然简单 但在必定问题上而言，这也是极不安全的，将全部配置，放在一个文件里，是很危险的，但对于通常项目而言并不会有太大影响。
  •    （3）在SpringBoot建立时会自动建立Bootdemo1Application启动类,表明着本工程项目和服务器的启动加载，在springBoot中是内含服务器的，因此不需手动配置Tomact，但注意端口号冲突问题。

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

 核心配置文件是指在resources根目录下的application.properties或application.yml配置文件，读取这两个配置文件的方法有两种，都比较简单

107.spring boot 配置文件有哪几种类型？它们有什么区别？

这里我理解的是两种类型 application.properties和application.yml

application.yml配置结构

spring:
 application:
  name: wxxcx mvc:
  view:
    prefix: /WEB-INF/jsp/ suffix: jsp

application.properties配置结构

spring.application.name=wxxcx
server.port = 9000
server.context-path = /
server.tomcat.uri-encoding = UTF-8
spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

 

108.spring boot 有哪些方式能够实现热部署？

SpringBoot热部署方式一共有两种，分别使用两种不一样的依赖

　　SpringBoot 1.3后才拥有SpringBoot devtools热部署

　　①：spring-boot-devtools   ②：Spring Loaded

  • 方式一： 在项目的pom文件中添加依赖:
<!--热部署jar-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>
  • 方式二： 在项目中添加以下代码
<build>
        <plugins>
            <plugin>
                <!-- springBoot编译插件-->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <dependencies>
                    <!-- spring热部署 -->
                    <!-- 该依赖在此处下载不下来，能够放置在build标签外部下载完成后再粘贴进plugin中 -->
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>springloaded</artifactId>
                        <version>1.2.6.RELEASE</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

添加完毕后须要使用mvn指令运行：

　　　　首先找到IDEA中的Edit configurations ,而后进行以下操做：（点击左上角的"+",而后选择maven将出现右侧面板，在红色划线部位输入如图所示指令，你能够为该指令命名(此处命名为MvnSpringBootRun)）

　　　　点击保存将会在IDEA项目运行部位出现，点击绿色箭头运行便可

109.jpa 和 hibernate 有什么区别？

简单的能够理解为：

  • Hibernate是JPA规范的一个具体实现
  • hibernate有JPA没有的特性 
  • hibernate 的效率更快
  • JPA 有更好的移植性，通用性

【分享】

分享两篇文章供你们参考：http://www.javashuo.com/article/p-oyqczifh-cv.html

http://baijiahao.baidu.com/s?id=1602675844799153392&wfr=spider&for=pc

110.什么是 spring cloud？

  •  Spring Cloud是一个微服务框架，相比Dubbo等RPC框架, Spring Cloud提供的全套的分布式系统解决方案。 
  • Spring Cloud对微服务基础框架Netflix的多个开源组件进行了封装，同时又实现了和云端平台以及和Spring Boot开发框架的集成。 
  •  Spring Cloud为微服务架构开发涉及的配置管理，服务治理，熔断机制，智能路由，微代理，控制总线，一次性token，全局一致性锁，leader选举，分布式session，集群状态管理等操做提供了一种简单的开发方式。
  •  Spring Cloud 为开发者提供了快速构建分布式系统的工具，开发者能够快速的启动服务或构建应用、同时可以快速和云平台资源进行对接。   

分享两篇文章供你们参考：http://www.javashuo.com/article/p-rpmlxxjs-ee.html

https://blog.csdn.net/kkkloveyou/article/details/79210420

https://spring.io/projects/spring-cloud

111.spring cloud 断路器的做用是什么？

在分布式环境下，特别是微服务结构的分布式系统中， 一个软件系统调用另一个远程系统是很是广泛的。这种远程调用的被调用方多是另一个进程，或者是跨网路的另一台主机, 这种远程的调用和进程的内部调用最大的区别是，远程调用可能会失败，或者挂起而没有任何回应，直到超时。更坏的状况是， 若是有多个调用者对同一个挂起的服务进行调用，那么就颇有可能的是一个服务的超时等待迅速蔓延到整个分布式系统，引发连锁反应， 从而消耗掉整个分布式系统大量资源。最终可能致使系统瘫痪。

断路器（Circuit Breaker）模式就是为了防止在分布式系统中出现这种瀑布似的连锁反应致使的灾难。

一旦某个电器出问题，为了防止灾难，电路的保险丝就会熔断。断路器相似于电路的保险丝， 实现思路很是简单，能够将须要保护的远程服务嗲用封装起来，在内部监听失败次数， 一旦失败次数达到某阀值后，全部后续对该服务的调用，断路器截获后都直接返回错误到调用方，而不会继续调用已经出问题的服务， 从而达到保护调用方的目的, 整个系统也就不会出现由于超时而产生的瀑布式连锁反应。

分享一篇文章供你们参考：http://www.cnblogs.com/chry/p/7278853.html

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

Spring Cloud由众多子项目组成，如Spring Cloud Config、Spring Cloud Netflix、Spring Cloud Consul 等，提供了搭建分布式系统及微服务经常使用的工具，如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性token、全局锁、选主、分布式会话和集群状态等，知足了构建微服务所需的全部解决方案。

  • 服务发现——Netflix Eureka
  • 客服端负载均衡——Netflix Ribbon
  • 断路器——Netflix Hystrix
  • 服务网关——Netflix Zuul
  • 分布式配置——Spring Cloud Config

分享一篇文章供你们参考：https://blog.csdn.net/springML/article/details/82492643

12、Hibernate

113.为何要使用 hibernate？

114.什么是 ORM 框架？

115.hibernate 中如何在控制台查看打印的 sql 语句？

116.hibernate 有几种查询方式？

117.hibernate 实体类能够被定义为 final 吗？

118.在 hibernate 中使用 Integer 和 int 作映射有什么区别？

119.hibernate 是如何工做的？

120.get()和 load()的区别？

121.说一下 hibernate 的缓存机制？

122.hibernate 对象有哪些状态？

123.在 hibernate 中 getCurrentSession 和 openSession 的区别是什么？

124.hibernate 实体类必需要有无参构造函数吗？为何？

 

十3、Mybatis

125.mybatis 中 #{}和 ${}的区别是什么？

  • 1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，若是传入的值是111,那么解析成sql时的值为order by "111", 若是传入的值是id，则解析成的sql为order by "id".
  • 2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，若是传入的值是111,那么解析成sql时的值为order by user_id,  若是传入的值是id，则解析成的sql为order by id.
  • 3. #方式可以很大程度防止sql注入。
  • 4.$方式没法防止Sql注入。
  • 5.$方式通常用于传入数据库对象，例如传入表名.
  • 6.通常能用#的就别用$.
  • MyBatis排序时使用order by 动态参数时须要注意，用$而不是#

分享一篇文章供你们参考：http://www.javashuo.com/article/p-hrsexklz-em.html

126.mybatis 有几种分页方式？

  • 一、数组分页
  • 二、sql分页
  • 三、拦截器分页
  • 四、RowBounds分页

固然如今也有不少分页插件：好比PageHelper等

分享一篇文章供你们参考：http://www.javashuo.com/article/p-hrsexklz-em.html

https://blog.csdn.net/chenbaige/article/details/70846902

127.RowBounds 是一次性查询所有结果吗？为何？

是一次性查询所有结果，只不过会根据参数丢掉一部分

分享一篇文章供你们参考：https://blog.csdn.net/u010077905/article/details/38469653

128.mybatis 逻辑分页和物理分页的区别是什么？

  •   1：逻辑分页 虽然看起来实现了分页的功能，但其实是将查询的全部结果放置在内存中，每次都从内存获取。内存开销比较大,在数据量比较小的状况下效率比物理分页高;在数据量很大的状况下,内存开销过大,容易内存溢出,不建议使用
  •   2：物理分页 这种分页方法从底层上就是每次只查询对应条目数量的数据,内存开销比较小,在数据量比较小的状况下效率比逻辑分页仍是低,在数据量很大的状况下,建议使用物理分页

129.mybatis 是否支持延迟加载？延迟加载的原理是什么？

 在mybatis 中默认没有使用延迟加载 ,可是经过配置  <setting name="lazyLoadingEnabled" value="true"/>实现延迟加载

延迟加载的原理:动态代理:在Hibernate中,被动态代理的延迟对象是one方;many方仍是第一个普通的一个对象;

分享几篇文章供你们参考：http://www.cnblogs.com/trisaeyes/archive/2007/01/08/614996.html

                                            https://www.cnblogs.com/llynic/p/6377783.html

130.说一下 mybatis 的一级缓存和二级缓存？

一级缓存是SqlSession级别的缓存。在操做数据库时须要构造sqlSession对象，在对象中有一个数据结构用于存储缓存数据。不一样的sqlSession之间的缓存数据区域是互相不影响的。也就是他只能做用在同一个sqlSession中，不一样的sqlSession中的缓存是互相不能读取的

二级缓存是mapper级别的缓存，多个SqlSession去操做同一个Mapper的sql语句，多个SqlSession能够共用二级缓存，二级缓存是跨SqlSession的。二级缓存的做用范围更大。

分享几篇文章供你们参考：https://blog.csdn.net/weixin_36380516/article/details/73194758

                                          https://zhidao.baidu.com/question/140731349194225845.html

131.mybatis 和 hibernate 的区别有哪些？

  •    Hibernate 框架 

        Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了很是轻量级的对象封装,创建对象与数据库表的映射。是一个全自动的、彻底面向对象的持久层框架。

  •  Mybatis框架

        Mybatis是一个开源对象关系映射框架，原名：ibatis,2010年由谷歌接管之后改名。是一个半自动化的持久层框架。

  •     2.1 开发方面

        在项目开发过程中，就速度而言：

            hibernate开发中，sql语句已经被封装，直接能够使用，加快系统开发；

            Mybatis 属于半自动化，sql须要手工完成，稍微繁琐；

        可是，凡事都不是绝对的，若是对于庞大复杂的系统项目来讲，发杂语句较多，选择hibernate 就不是一个好方案。

  •     2.2 sql优化方面

        Hibernate 自动生成sql,有些语句较为繁琐，会多消耗一些性能；

        Mybatis 手动编写sql，能够避免不须要的查询，提升系统性能；

  •     2.3 对象管理比对

        Hibernate 是完整的对象-关系映射的框架，开发工程中，无需过多关注底层实现，只要去管理对象便可；

        Mybatis 须要自行管理 映射关系；

  •     2.4 缓存方面   
    •   相同点：
    •  Hibernate和Mybatis的二级缓存除了采用系统默认的缓存机制外，均可以经过实现你本身的缓存或为其余第三方缓    存方案，建立适配器来彻底覆盖缓存行为。
    • 不一样点：
    • Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置，而后再在具体的表-对象映射中配置是那种缓存。
    • MyBatis的二级缓存配置都是在每一个具体的表-对象映射中进行详细配置，这样针对不一样的表能够自定义不一样的缓存机制。而且Mybatis能够在命名空间中共享相同的缓存配置和实例，经过Cache-ref来实现。

比较：

  • Hibernate 具备良好的管理机制，用户不须要关注SQL，若是二级缓存出现脏数据，系统会保存，；
  • Mybatis 在使用的时候要谨慎，避免缓存CAche 的使用。

Hibernate优点

  • Hibernate的DAO层开发比MyBatis简单，Mybatis须要维护SQL和结果映射。

  • Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。

  • Hibernate数据库移植性很好，MyBatis的数据库移植性很差，不一样的数据库须要写不一样SQL。

  • Hibernate有更好的二级缓存机制，能够使用第三方缓存。MyBatis自己提供的缓存机制不佳。

Mybatis优点

  • MyBatis能够进行更为细致的SQL优化，能够减小查询字段。

  • MyBatis容易掌握，而Hibernate门槛较高。

一句话总结

  • Mybatis：小巧、方便、高效、简单、直接、半自动化
  • Hibernate：强大、方便、高效、复杂、间接、全自动化

132.mybatis 有哪些执行器（Executor）？

Mybatis有三种基本的Executor执行器:  SimpleExecutor、ReuseExecutor、BatchExecutor。

  • SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完马上关闭Statement对象。
  • ReuseExecutor：执行update或select，以sql做为key查找Statement对象，存在就使用，不存在就建立，用完后，不关闭Statement对象，而是放置于Map内，供下一次使用。简言之，就是重复使用Statement对象。
  • BatchExecutor：执行update（没有select，JDBC批处理不支持select），将全部sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每一个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

    做用范围：Executor的这些特色，都严格限制在SqlSession生命周期范围内。

Mybatis中如何指定使用哪种Executor执行器？

答：在Mybatis配置文件中，能够指定默认的ExecutorType执行器类型，也能够手动给DefaultSqlSessionFactory的建立SqlSession的方法传递ExecutorType类型参数。

133.mybatis 分页插件的实现原理是什么？

实现原理： 就是在StatementHandler以前进行拦截，对MappedStatement进行一系列的操做（大体就是拼上分页sql）

分享几篇文章供你们参考：http://www.javashuo.com/article/p-mhntlwix-bg.html

134.mybatis 如何编写一个自定义插件？

 由于本人目前没有写过自定义四插件，因此网上找了一篇文章供你们分享

https://www.jianshu.com/p/96ddaec4aea7

十4、RabbitMQ

135.rabbitmq 的使用场景有哪些？

  • 场景1：单发送单接收
  • 场景2：单发送多接收场景3：Publish/Subscribe
  • 场景3：Publish/Subscribe
  • 场景4：Routing (按路线发送接收)
  • 场景5：Topics (按topic发送接收)

分享几篇文章供你们参考：https://www.cnblogs.com/luxiaoxun/p/3918054.html

136.rabbitmq 有哪些重要的角色？

  •     none
    • 一、不能访问 management plugin
  •     management
    • 一、用户能够经过AMQP作的任何事外加：
    • 二、列出本身能够经过AMQP登入的virtual hosts  
    • 三、查看本身的virtual hosts中的queues, exchanges 和 bindings
    • 四、查看和关闭本身的channels 和 connections
    • 五、查看有关本身的virtual hosts的“全局”的统计信息，包含其余用户在这些virtual hosts中的活动。
  •     policymaker
    • 一、management能够作的任何事外加：
    • 二、查看、建立和删除本身的virtual hosts所属的policies和parameters
  •     monitoring
    • 一、management能够作的任何事外加：
    • 二、列出全部virtual hosts，包括他们不能登陆的virtual hosts
    • 三、查看其余用户的connections和channels
    • 四、查看节点级别的数据如clustering和memory使用状况
    • 五、查看真正的关于全部virtual hosts的全局的统计信息
  •     administrator
    • 一、policymaker和monitoring能够作的任何事外加:
    • 二、建立和删除virtual hosts
    • 三、查看、建立和删除users
    • 四、查看建立和删除permissions
    • 五、关闭其余用户的connections

分享几篇文章供你们参考：https://www.cnblogs.com/luxiaoxun/p/3918054.html

137.rabbitmq 有哪些重要的组件？

Spring AMQP 是基于 Spring 框架的AMQP消息解决方案，提供模板化的发送和接收消息的抽象层，提供基于消息驱动的 POJO的消息监听等，很大程度上方便了咱们进行相关程序的开发。

Message消息是当前模型中操纵的基本单位，它由Producer产生，通过路由转发被Consumer所消费。它是生产者和消费者发送和处理的对象。消息头是由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其余消息的优先权）、delivery-mode（指出该消息可能须要持久性存储）等。

Exchange用来接收生产者发送的消息并将这些消息路由给服务器中的队列。

Exchange包含4种类型：Direct, Topic, Fanout, Headers。不一样的类型，他们如何处理绑定到队列方面的行为会有所不一样。

  1. Direct类型: 容许一个队列经过一个固定的Routing-key(一般是队列的名字)进行绑定。 Direct交换器将消息根据其routing-key属性投递到包含对应key属性的绑定器上。
  2. Topic类型: 支持消息的Routing-key用*或#的模式，进行绑定。*匹配一个单词，#匹配0个或者多个单词。例如，binding key *.user.# 匹配routing key为 usd.user和eur.user.db，可是不匹配user.hello。
  3. Fanout类型：它只是将消息广播到全部绑定到它的队列中,而不考虑routing key的值。
  4. Header类型： 它根据应用程序消息的特定属性进行匹配，这些消息可能在binding key中标记为可选或者必选。

Queue队列，它表明了Message Consumer接收消息的地方，它用来保存消息直到发送给消费者。Queue有如下一些重要的属性。

  1. 持久性：若是启用，队列将会在消息协商器(Broker)重启前都有效。
  2. 自动删除：若是启用，那么队列将会在全部的消费者中止使用以后自动删除掉自身。
  3. 惰性：若是没有声明队列，那么在执行到使用的时候会致使异常，并不会主动声明。
  4. 排他性：若是启用，队列只能被声明它的消费者使用。

Binding绑定，生产者发送消息到Exchange,接收者从Queue接收消息，而绑定(Binging)是生产者和消费者消息传递的重要链接，它是链接生产者和消费者进行信息交流的关键。

简单来讲，RabbitMQ就是一个消息代理机制。它的工做就是接收和转发消息。你能够把它看成是一个邮局：寄信人把信件放入邮箱，邮递员就会把信件投递到你的收件人处。在这个比喻中，RabbitMQ就扮演着邮箱、邮局以及邮递员的角色。其中：

  • Exchange: 就是顺丰和韵达。
  • routingkey: 就是邮件地址的概念.
  • queue: 就是邮箱接收软件，可是能够接收多个地址的邮件，经过bind实现。
  • producer： 消息生产者，就是投递消息的程序。
  • consumer：消息消费者，就是接受消息的程序。
  • channel：消息通道，在客户端的每一个链接里，可创建多个channel，每一个channel表明一个会话任务。
     

138.rabbitmq 中 vhost 的做用是什么？

vhost本质上是一个mini版的RabbitMQ服务器，拥有本身的队列、绑定、交换器和权限控制；

vhost经过在各个实例间提供逻辑上分离，容许你为不一样应用程序安全保密地运行数据；

RabbitMQ的Vhost主要是用来划分不一样业务模块。不一样业务模块之间没有信息交互。

Vhost之间相互彻底隔离，不一样Vhost之间没法共享Exchange和Queue。所以Vhost之间数据没法共享和分享。若是要实现这种功能，须要Vhost之间手动构建对应代码逻辑。

分享几篇文章供你们参考：https://www.cnblogs.com/zhengchunyuan/p/9253725.html

                                            https://www.rabbitmq.com/vhosts.html

139.rabbitmq 的消息是怎么发送的？
RabbitMQ事务和Confirm发送方消息确认

分享几篇文章供你们参考：http://www.javashuo.com/article/p-hvhpcctx-hs.html

140.rabbitmq 怎么保证消息的稳定性？

正常状况下，若是消息通过交换器进入队列就能够完成消息的持久化，但若是消息在没有到达broker以前出现意外，那就形成消息丢失，有没有办法能够解决这个问题？RabbitMQ有两种方式来解决这个问题：

  1. 经过AMQP提供的事务机制实现；
  2. 使用发送者确认模式实现；

分享几篇文章供你们参考：http://www.javashuo.com/article/p-wwzmdhfg-hh.html

141.rabbitmq 怎么避免消息丢失？

  1. 消息持久化
  2. ACK确认机制
  3. 设置集群镜像模式
  4. 消息补偿机制

分享几篇文章供你们参考：https://blog.csdn.net/u011665991/article/details/89946185

142.要保证消息持久化成功的条件有哪些？

须要将queue，exchange和Message都持久化。

分享几篇文章供你们参考：https://blog.csdn.net/u011665991/article/details/89946411

未更新完成。。。。

143.rabbitmq 持久化有什么缺点？

144.rabbitmq 有几种广播类型？

145.rabbitmq 怎么实现延迟消息队列？

146.rabbitmq 集群有什么用？

147.rabbitmq 节点的类型有哪些？

148.rabbitmq 集群搭建须要注意哪些问题？

149.rabbitmq 每一个节点是其余节点的完整拷贝吗？为何？

150.rabbitmq 集群中惟一一个磁盘节点崩溃了会发生什么状况？

151.rabbitmq 对集群节点中止顺序有要求吗？

 

十5、Kafka

152.kafka 能够脱离 zookeeper 单独使用吗？为何？

153.kafka 有几种数据保留的策略？

154.kafka 同时设置了 7 天和 10G 清除数据，到第五天的时候消息达到了 10G，这个时候 kafka 将如何处理？

155.什么状况会致使 kafka 运行变慢？

156.使用 kafka 集群须要注意什么？

 

十6、Zookeeper

157.zookeeper 是什么？

158.zookeeper 都有哪些功能？

159.zookeeper 有几种部署模式？

160.zookeeper 怎么保证主从节点的状态同步？

161.集群中为何要有主节点？

162.集群中有 3 台服务器，其中一个节点宕机，这个时候 zookeeper 还能够使用吗？

163.说一下 zookeeper 的通知机制？

 

十7、MySql

164.数据库的三范式是什么？

165.一张自增表里面总共有 7 条数据，删除了最后 2 条数据，重启 mysql 数据库，又插入了一条数据，此时 id 是几？

166.如何获取当前数据库版本？

167.说一下 ACID 是什么？

168.char 和 varchar 的区别是什么？

169.float 和 double 的区别是什么？

170.mysql 的内链接、左链接、右链接有什么区别？

171.mysql 索引是怎么实现的？

172.怎么验证 mysql 的索引是否知足需求？

173.说一下数据库的事务隔离？

174.说一下 mysql 经常使用的引擎？

175.说一下 mysql 的行锁和表锁？

176.说一下乐观锁和悲观锁？

177.mysql 问题排查都有哪些手段？

178.如何作 mysql 的性能优化？

 

十8、Redis

179.redis 是什么？都有哪些使用场景？

Redis是一个基于内存的高性能开源的 key—value型 单线程 数据库，支持string、list、set、zset和hash类型数据。

适用场景： 对扩展性要求高的数据

  1. 数据高并发的读写
  2. 海量数据的读写

不适场景：

  1. 须要事务支持（非关系型数据库）
  2. 基于sql结构化查询储存，关系复杂

180.redis 有哪些功能？

  1. 全页面缓存
  2. 顺序排列
  3. 会话session存储
  4. 队列
  5. pub/sub

具体参考文章：https://blog.csdn.net/sinat_34496643/article/details/80077319

181.redis 和 memecache 有什么区别？

  • redis相比memcached有哪些优点？ 　　

　　　(1) memcached全部的值均是简单的字符串，redis做为其替代者，支持更为丰富的数据类型 
　　　(2) redis的速度比memcached快不少 (3) redis能够持久化其数据

  • Memcache与Redis的区别都有哪些？    

　　　1)、存储方式 Memecache把数据所有存在内存之中，断电后会挂掉，数据不能超过内存大小。 Redis有部份存在硬盘上，这样能保证数据的持久性。 
　　　2)、数据支持类型 Memcache对数据类型支持相对简单。 Redis有复杂的数据类型。 
　　　3)、使用底层模型不一样 它们之间底层实现方式 以及与客户端之间通讯的应用协议不同。 Redis直接本身构建了VM 机制 ，由于通常的系统调用系统函数的话，会浪费必定的时间去移动和请求。 

182.redis 为何是单线程的？

　　　redis利用队列技术将并发访问变为串行访问，消除了传统数据库串行控制的开销

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

     缓存穿透是指查询一个必定不存在的数据，因为缓存是不命中时须要从数据库查询，查不到数据则不写入缓存，这将致使这个不存在的数据每次请求都要到数据库去查询，形成缓存穿透。

解决办法：

     1.布隆过滤 2. 缓存空对象. 将 null 变成一个值.

具体参考文章：https://blog.csdn.net/u011665991/article/details/89956398

184.redis 支持的数据类型有哪些？

redis支持丰富的数据类型，从最基础的string到复杂的经常使用到的数据结构都有支持：

  1. string：最基本的数据类型，二进制安全的字符串，最大512M。
  2. list：按照添加顺序保持顺序的字符串列表。
  3. set：无序的字符串集合，不存在重复的元素。
  4. sorted set：已排序的字符串集合。
  5. hash：key-value对的一种集合。
  6. bitmap：更细化的一种操做，以bit为单位。
  7. hyperloglog：基于几率的数据结构。

这些众多的数据类型，主要是为了支持各类场景的须要，固然每种类型都有不一样的时间复杂度。其实这些复杂的数据结构至关于以前在《解读REST》这个系列博客基于网络应用的架构风格中介绍到的远程数据访问（Remote Data Access = RDA）的具体实现，即经过在服务器上执行一组标准的操做命令，在服务端之间获得想要的缩小后的结果集，从而简化客户端的使用，也能够提升网络性能。好比若是没有list这种数据结构，你就只能把list存成一个string，客户端拿到完整的list，操做后再完整的提交给redis，会产生很大的浪费。

185.redis 支持的 java 客户端都有哪些？

Redisson,Jedis，lettuce等等，官方推荐使用Redisson。

186.jedis 和 redisson 有哪些区别？

  • Jedis api 在线网址：http://tool.oschina.net/uploads/apidocs/redis/clients/jedis/Jedis.html
  • redisson 官网地址：https://redisson.org/
  • redisson git项目地址：https://github.com/redisson/redisson
  • lettuce 官网地址：https://lettuce.io/
  • lettuce git项目地址：https://github.com/lettuce-io/lettuce-core

概念：

　　Jedis：是Redis的Java实现客户端，提供了比较全面的Redis命令的支持，

　　Redisson：实现了分布式和可扩展的Java数据结构。

　　Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。

优势：

　　Jedis：比较全面的提供了Redis的操做特性

　　Redisson：促使使用者对Redis的关注分离，提供不少分布式相关操做服务，例如，分布式锁，分布式集合，可经过Redis支持延迟队列

　　Lettuce：主要在一些分布式缓存框架上使用比较多

可伸缩：

Jedis：使用阻塞的I/O，且其方法调用都是同步的，程序流须要等到sockets处理完I/O才能执行，不支持异步。Jedis客户端实例不是线程安全的，因此须要经过链接池来使用Jedis。

Redisson：基于Netty框架的事件驱动的通讯层，其方法调用是异步的。Redisson的API是线程安全的，因此能够操做单个Redisson链接来完成各类操做

Lettuce：基于Netty框架的事件驱动的通讯层，其方法调用是异步的。Lettuce的API是线程安全的，因此能够操做单个Lettuce链接来完成各类操做

结论：

建议使用：Jedis + Redisson

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

  1. 对删除缓存进行重试，数据的一致性要求越高，我越是重试得快。
  2. 按期全量更新，简单地说，就是我按期把缓存所有清掉，而后再全量加载。
  3. 给全部的缓存一个失效期。

分享几篇文章供你们参考：http://www.javashuo.com/article/p-qixzjbwk-nq.html

188.redis 持久化有几种方式？

  • RDB：RDB 持久化机制，是对 redis 中的数据执行周期性的持久化。
  • AOF：AOF 机制对每条写入命令做为日志，以 append-only 的模式写入一个日志文件中，在 redis 重启的时候，能够经过回放 AOF 日志中的写入指令来从新构建整个数据集。

补充：

经过 RDB 或 AOF，均可以将 redis 内存中的数据给持久化到磁盘上面来，而后能够将这些数据备份到别的地方去，好比说阿里云等云服务。

若是 redis 挂了，服务器上的内存和磁盘上的数据都丢了，能够从云服务上拷贝回来以前的数据，放到指定的目录中，而后从新启动 redis，redis 就会自动根据持久化数据文件中的数据，去恢复内存中的数据，继续对外提供服务。

若是同时使用 RDB 和 AOF 两种持久化机制，那么在 redis 重启的时候，会使用 AOF 来从新构建数据，由于 AOF 中的数据更加完整。

RDB 优缺点

  •     RDB会生成多个数据文件，每一个数据文件都表明了某一个时刻中 redis 的数据，这种多个数据文件的方式，很是适合作冷备，能够将这种完整的数据文件发送到一些远程的安全存储上去，好比说 Amazon 的 S3 云服务上去，在国内能够是阿里云的 ODPS 分布式存储上，以预约好的备份策略来按期备份redis中的数据。
  •     RDB 对 redis 对外提供的读写服务，影响很是小，可让 redis 保持高性能，由于 redis 主进程只须要 fork 一个子进程，让子进程执行磁盘 IO 操做来进行 RDB 持久化便可。
  •     相对于 AOF 持久化机制来讲，直接基于 RDB 数据文件来重启和恢复 redis 进程，更加快速。
  •     若是想要在 redis 故障时，尽量少的丢失数据，那么 RDB 没有 AOF 好。通常来讲，RDB 数据快照文件，都是每隔 5 分钟，或者更长时间生成一次，这个时候就得接受一旦 redis 进程宕机，那么会丢失最近 5 分钟的数据。
  •     RDB 每次在 fork 子进程来执行 RDB 快照数据文件生成的时候，若是数据文件特别大，可能会致使对客户端提供的服务暂停数毫秒，或者甚至数秒。

AOF 优缺点

  •     AOF 能够更好的保护数据不丢失，通常 AOF 会每隔 1 秒，经过一个后台线程执行一次fsync操做，最多丢失 1 秒钟的数据。
  •     AOF 日志文件以 append-only 模式写入，因此没有任何磁盘寻址的开销，写入性能很是高，并且文件不容易破损，即便文件尾部破损，也很容易修复。
  •     AOF 日志文件即便过大的时候，出现后台重写操做，也不会影响客户端的读写。由于在 rewrite log 的时候，会对其中的指导进行压缩，建立出一份须要恢复数据的最小日志出来。再建立新日志文件的时候，老的日志文件仍是照常写入。当新的 merge 后的日志文件 ready 的时候，再交换新老日志文件便可。
  •     AOF 日志文件的命令经过很是可读的方式进行记录，这个特性很是适合作灾难性的误删除的紧急恢复。好比某人不当心用 flushall 命令清空了全部数据，只要这个时候后台 rewrite 尚未发生，那么就能够当即拷贝 AOF 文件，将最后一条 flushall 命令给删了，而后再将该 AOF 文件放回去，就能够经过恢复机制，自动恢复全部数据。
  •     对于同一份数据来讲，AOF 日志文件一般比 RDB 数据快照文件更大。
  •     AOF 开启后，支持的写 QPS 会比 RDB 支持的写 QPS 低，由于 AOF 通常会配置成每秒 fsync 一第二天志文件，固然，每秒一次 fsync，性能也仍是很高的。（若是实时写入，那么 QPS 会大降，redis 性能会大大下降）
  •     之前 AOF 发生过 bug，就是经过 AOF 记录的日志，进行数据恢复的时候，没有恢复如出一辙的数据出来。因此说，相似 AOF 这种较为复杂的基于命令日志/merge/回放的方式，比基于 RDB 每次持久化一份完整的数据快照文件的方式，更加脆弱一些，容易有 bug。不过 AOF 就是为了不 rewrite 过程致使的 bug，所以每次 rewrite 并非基于旧的指令日志进行 merge 的，而是基于当时内存中的数据进行指令的从新构建，这样健壮性会好不少。

RDB和AOF到底该如何选择

    不要仅仅使用 RDB，由于那样会致使你丢失不少数据
    也不要仅仅使用 AOF，由于那样有两个问题，第一，你经过 AOF 作冷备，没有 RDB 作冷备，来的恢复速度更快; 第二，RDB 每次简单粗暴生成数据快照，更加健壮，能够避免 AOF 这种复杂的备份和恢复机制的 bug。
    redis 支持同时开启开启两种持久化方式，咱们能够综合使用 AOF 和 RDB 两种持久化机制，用 AOF 来保证数据不丢失，做为数据恢复的第一选择; 用 RDB 来作不一样程度的冷备，在 AOF 文件都丢失或损坏不可用的时候，还能够使用 RDB 来进行快速的数据恢复。
分享几篇文章供你们参考：https://blog.csdn.net/yinxiangbing/article/details/48627997

189.redis 怎么实现分布式锁？

官方推荐采用Redlock算法，即便用string类型，加锁的时候给的一个具体的key，而后设置一个随机的值；取消锁的时候用使用lua脚原本先执行获取比较，而后再删除key。具体的命令以下：

SET resource_name my_random_value NX PX 30000

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

190.redis 分布式锁有什么缺陷？

(一)缓存和数据库双写一致性问题
(二)缓存雪崩问题
(三)缓存击穿问题
(四)缓存的并发竞争问题

分享几篇文章供你们参考：

191.redis 如何作内存优化？

1. 关闭 Redis 的虚拟内存[VM]功能，即 redis.conf 中 vm-enabled = no
2. 设置 redis.conf 中 maxmemory ，用于告知 Redis 当使用了多少物理内存后拒绝继续写入的请求，可防止 Redis 性能下降甚至崩溃
3.可为指定的数据类型设置内存使用规则，从而提升对应数据类型的内存使用效率

  •     Hash 在 redis.conf 中有如下两个属性，任意一个超出设定值，则会使用 HashMap 存值
    •         hash-max-zipmap-entires 64 表示当 value 中的 map 数量在 64 个如下时，实际使用 zipmap 存储值
    •         hash-max-zipmap-value 512 表示当 value 中的 map 每一个成员值长度小于 512 字节时，实际使用 zipmap 存储值
  •     List 在 redis.conf 中也有如下两个属性
    •         list-max-ziplist-entires 64
    •         list-max-ziplist-value 512

4. 在 Redis 的源代码中有一行宏定义 REDIS-SHARED-INTEGERS = 10000 ，修改该值能够改变 Redis 存储数值类型的内存开销

192.redis 淘汰策略有哪些？

  • noeviction:当内存限制达到，谁也不删除，返回错误。
  • allkeys-lru:尝试回收最少使用的键，使得新添加的数据有空间存放。
  • volatile-lru:尝试回收最少使用的键，但仅限于在过时集合的键，使得新添加的数据有空间存放。
  • allkey-random:回收随机的键，使得新添加的数据有空间存放。
  • volatile-random:回收随机的键，使得新添加的数据有空间存放，但仅限于过时集合的键。
  • volatile-ttl:回收在过时集合的键，而且优先回收存货时间较短的键，使得新添加的数据有空间存放。

193.redis 常见的性能问题有哪些？该如何解决？

  1. Master写内存快照，save命令调度rdbSave函数，会阻塞主线程的工做，当快照比较大时对性能影响是很是大的，会间断性暂停服务，因此Master最好不要写内存快照。
  2. Master AOF持久化，若是不重写AOF文件，这个持久化方式对性能的影响是最小的，可是AOF文件会不断增大，AOF文件过大会影响Master重启的恢复速度。Master最好不要作任何持久化工做，包括内存快照和AOF日志文件，特别是不要启用内存快照作持久化,若是数据比较关键，某个Slave开启AOF备份数据，策略为每秒同步一次。
  3. Master调用BGREWRITEAOF重写AOF文件，AOF在重写的时候会占大量的CPU和内存资源，致使服务load太高，出现短暂服务暂停现象。
  4. Redis主从复制的性能问题，为了主从复制的速度和链接的稳定性，Slave和Master最好在同一个局域网内

 

十9、JVM

194.说一下 jvm 的主要组成部分？及其做用？

195.说一下 jvm 运行时数据区？

196.说一下堆栈的区别？

197.队列和栈是什么？有什么区别？

198.什么是双亲委派模型？

199.说一下类加载的执行过程？

200.怎么判断对象是否能够被回收？

201.java 中都有哪些引用类型？

202.说一下 jvm 有哪些垃圾回收算法？

203.说一下 jvm 有哪些垃圾回收器？

204.详细介绍一下 CMS 垃圾回收器？

205.新生代垃圾回收器和老生代垃圾回收器都有哪些？有什么区别？

206.简述分代垃圾回收器是怎么工做的？

207.说一下 jvm 调优的工具？

208.经常使用的 jvm 调优的参数都有哪些？

联系我们 沪ICP备13005482号-10