2020java面试题整理和解析（持续更新，一起探讨）

本文引用了其他作者的内容，为表尊重，都会贴出原链接，当然，本文也有很多自己的见解，欢迎大家指正，相互学习。

基础类

• 字符串常量存储位置，new String()存储位置，=
  =比较前面两种创建字符创结果，equals和==区别，字符串使用equals底层是怎么比较的。

String str1 = “abc”;

String str2 = “abc”;

String str3 = new String(“abc”);

String str4 = “a” + “bc”;

判断以下true or false

str1==str2

str1==str3

str1==str4
答案解析：

（1）本题考查常量池位置（方法区）、对象位置（堆），==比较的是句柄（也就是内存地址，Thinking in java有提及，我认为这个句柄这个概念很好），equals原本是Object类（超类）的方法，其方法中依然是用= =实现的，所以如果子类没有重写equqls方法的话，= =和equals效果相同，都是比较的句柄，对于基础数据类型= =比较的是数值，对于重写equqls的类String，Integer等包装类equals比较的是内容。

（2） str1= =str2为true,因为指向字符串常量池的同一个位置。str1==str3为false，以为方法区中内存地址不可能和堆内存地址相同，都不在一个位置。str1= =str4为true,因为“a” + “bc”生成了一个新的对象"abc"，在常量池中位置相同。

思考：String a= new String(“a”);创建了几个对象？写出你的答案

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

答：等于 -1，因为在数轴上取值时，中间值（0.5）向右取整，所以正 0.5 是往上取整，负 0.5 是直接舍弃。

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

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

• String str="i"与 String str=new String(“i”)一样吗？
  答：不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中，如果常量池不存在“i”,也会在常量池中创建"i"。
• 抽象类必须要有抽象方法吗？

答： 不需要，抽象类不一定非要有抽象方法。解析：有抽象方法的类，一定是抽象类，但是抽象类客户可以有一般人方法。在抽象类中 可以有构造方法吗？

• 抽象类能使用 final 修饰吗？
  答：不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类。
• Collection 和 Collections 有什么区别？

答：java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它定义了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。 Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

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

• 创建线程池有哪几种方式？

①. newFixedThreadPool(int nThreads)

创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程。

②. newCachedThreadPool()

创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。

③. newSingleThreadExecutor()

这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行。

④. newScheduledThreadPool(int corePoolSize)

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

• OSI 的七层模型都有哪些？

  应用层：网络服务与最终用户的一个接口。
  表示层：数据的表示、安全、压缩。
  会话层：建立、管理、终止会话。
  传输层：定义传输数据的协议端口号，以及流控和差错校验。
  网络层：进行逻辑地址寻址，实现不同网络之间的路径选择。
  数据链路层：建立逻辑连接、进行硬件地址寻址、差错校验等功能。
  物理层：建立、维护、断开物理连接。

• HashMap 和 Hashtable 有什么区别？

  答：
  1.hashMap去掉了HashTable 的contains方法，但是加上了containsValue（）和containsKey（）方法。
  2.hashTable同步的，而HashMap是非同步的，效率上比hashTable要高。
  3.hashMap允许空键值，而hashTable不允许。

• HashMap底层原理，初始化长度，扩容情况，安全（注意1.7和1.8区别）Hashtable、ConcurrentHashMap
  答案解析：
  （1）Hashtable:线程安全，但不用，因为太慢。
  （2）ConcurrentHashMap：线程安全，也比hashtable快，jdk1.7采用分段锁锁的包括多个HashEntry，1.8采用的锁是锁单个HashEntry，粒度更精细。
  （3） HASHMAP扩容为什么是0.75（hash冲突最少，0.75只是个统计值，不同编程语言不同，但基本在0.75附近，）
  （4）什么是hash冲突，根据key可以计算出hashcode，不同的key可以计算出hashcode相同时，就冲突了。
  （5）HashMap1.7用的数组加链表，1.8用的数组加链表加红黑树，当链表长度超过8变为红黑树。new HashMap时，没有指定长度，默认16，达到0.75负载时，2倍扩容，如果自己定义了，是2的n次方，则为该值，如果为非2的n次方，则比该数大的最近该数的2的n次方。

• 说下你知道的设计模式？

答：a.单例模式。b.工厂模式。c.策略模式。d.观察者模式。d.装饰者模式。

• 说下单例模式有哪几种？

答：有懒汉式和饿汉式，还有双重锁式。懒汉式严格的来说不是单例的，因为有线程安全问题，饿汉式在类加载时就创建实例了，会浪费资源。双重锁式比较好。

• 数据加密RSA非对称，签名，对称AES，MD5

  答案解析：对于RSA，记住口诀：公钥加密，私钥解密；私钥签名，公钥验签，工作中都有现成的工具类生公私钥对，加解密方法，验签方法；AES是对称加密，MD5一般用于登录密码加密。

• Lock用法，和synchronize区别。

答案解析：（1）lock是Java API提供的锁，而synchronize是java语言本身带的锁，（2）lock需要手动加锁释放锁，unlock时要放在finally中，否则可能会死锁，synchronize自定释放锁，（3）lock使用时可以通过尝试获取锁，获取到执行锁，获取不到可以在else分支中执行其他逻辑，但synchronize就不行了。（4）都可以锁代码块，但synchronize还可以用于方法。

• 多线程3种实现方式

答案解析：继承Thread类，实现Runnable、Callable接口。

• 如果我们想在主线程中拿到子线程的返回值，应该怎么做？

答：应该实现Callable接口，然后用future.get()获得返回值。

• 线程状态有几种状态？

答案解析：新建状态(New)、就绪状态(Runnable)、运行状态(Running)、阻塞状态(Blocked)、死亡状态(Dead)。

• jvm内存模型组成部分？

见《深入理解java虚拟机》60页。有兴趣的可以读读。

• 判断对象是否可回收：可达性分析、程序计数法，区别，优劣，现在虚拟机用的哪个

答案解析：可达性分析是类的根路径往下找，如果能找到，则为在使用状态，不回收，如果找不到，则为非使用状态，进行垃圾回收。程序计数法是是对象使用在对象头中标记数加一，结束调用则减一。现在虚拟机用的是可达性分析法。

what you need?!下图

• 堆内存分区（年轻代（Eden、survivor0、survivor1）、老年代）,这两个区内存回收算法（复制算法、标记清除、标记整理），算法内容优劣。

答案解析：
（1）1.8的jvm分为年轻代和老年代，年轻代包括Eden（伊甸园亚当和夏娃开始的地方吧，寓意新生，老外搞的有内涵！）、From Survivor、To Survivor(幸存者)，采用的复制算法进行垃圾回收，老年代用的标记清除和标记整理算法。

（2）复制算法把内存分为两等份，一份在使用，另一份在等待，回收时将存活的复制到空着的那份，另一份清空，缺点是浪费内存，所以使用与新生代，因为新生代的对象特点是朝生夕死，存活时间不会太长。

（3）标记清除算法是将要回收的进行标记，然后回收，存在问题是造成内存碎片化。

（4）标记整理是将不需要回收的进行复制到另外位置时，是连续布置，不会产生内存碎片化。

• G1垃圾回收算法，了解（最新的垃圾回收算法是G1,他们能保证垃圾回收时低延时）

• 如何用两个栈模拟队列（pust方法、pop方法）
  重点：栈：先进后出
  队列：先进先出
  push:向栈顶添加一个元素；pop:移除并返回栈顶元素

package day03.nowcoder;

import java.util.Stack;

/**
 * @author ZerlindaLi create at 2019/9/24 17:03
 * @version 1.0.0
 * @description QueenPushPop 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
 * 栈是后进先出 push:向栈顶添加一个元素；pop:移除并返回栈顶元素
 * 队列是先进先出
 */
public class QueenPushPop {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();

    /**
     * 栈的push方法向栈中添加元素,返回结果是当前添加的元素
     * @param node
     */
    public void push(int node) {
        stack1.push(node);
    }

    /**
     * pop方法移除并返回栈顶元素，如果是空栈，会抛出异常：EmptyStackException
     * @return
     */
    public int pop() {
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        int st2 = stack2.pop();

        while(!stack2.isEmpty()) {
            stack1.push(stack2.pop());
        }
        return st2;
    }

    public static void main(String[] args) {
        QueenPushPop qpp = new QueenPushPop();
        qpp.push(5);
        qpp.push(2);
        qpp.push(3);
        qpp.push(4);
        System.out.println(qpp.pop());
    }
}

代码来自这里

• jvm如何内存调优，调优参数有哪些？
  答：分析内存的工具：jdk的bin下的：
  Jconsole:看堆、cpu情况，cpu时配合linux的top命令，jps看进程
  Jmap快照看堆情况，调整内存参数：主要有
  方法区：-Xss，堆：-Xms、-Xmx

mysql

• mysql的索引有哪几种？
  答：
  普通索引：仅加速查询。
  唯一索引：加速查询 + 列值唯一（可以有null）。
  主键索引：加速查询 + 列值唯一（不可以有null）+ 表中只有一个。
  组合索引：多列值组成一个索引，专门用于组合搜索，其效率大于索引合并，遵循“最左前缀”原则，把最常用作为检索或排序的列放在最左，依次递减，组合索引相当于建立了col1,col1col2,col1col2col3三个索引，而col2或者col3是不能使用索引的。
  全文索引：对文本的内容进行分词，进行搜索。
  其中MySQL中的索引的存储类型有3种：BTREE、HASH、RTREE（空间索引）。

• 数据库设计的3大范式？
  答：
  1nf:即原子性，每一列都是不不可分割的。
  2nf：即在满足1nf的基础上，所有非主属性都必须依赖于主属性，而不能部分依赖。（解决办法拆分表） 。
  3nf：即在满足2nf基础上，所有非主属性对任何候选关键字都不存在传递依赖。（不传递依赖）

spring框架

• Spring是什么?

  Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置。
  主要由以下几个模块组成：
  Spring Core：核心类库，提供IOC服务；
  Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；
  Spring AOP：AOP服务；
  Spring DAO：对JDBC的抽象，简化了数据访问异常的处理；
  Spring ORM：对现有的ORM框架的支持；
  Spring Web：提供了基本的面向Web的综合特性，例如多方文件上传；
  Spring MVC：提供面向Web应用的Model-View-Controller实现。
  Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP（面向切面编程）、工具、消息和测试模块。
  

• 把类交给spring管理的方式有哪些？
  答案解析：一种是Spring方式，通过配置文件，配置在web.xml，一种是SpringBoot方式，通过注解加载进spring容器，启动类上的SpringBootApplication注解，在加上类上的Component（@controller/@Service/本质一样，只是语义区分而已）注解/@Bean注解，通过Autowire或者Resource引入调用。

• Spring 的优点？
  （1）spring属于低侵入式设计，代码的污染极低；

（2）spring的DI机制将对象之间的依赖关系交由框架处理，减低组件的耦合性；

（3）Spring提供了AOP技术，支持将一些通用任务，如安全、事务、日志、权限等进行集中式管理，从而提供更好的复用。

（4）spring对于主流的应用框架提供了集成支持。

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

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

AOP实现的关键在于 代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。

（1）AspectJ是静态代理的增强，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强，他会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。

（2）Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

• Spring的IoC理解：

（1）IOC就是控制反转，是指创建对象的控制权的转移，以前创建对象的主动权和时机是由自己把控的，而现在这种权力转移到Spring容器中，并由容器根据配置文件去创建实例和管理各个实例之间的依赖关系，对象与对象之间松散耦合，也利于功能的复用。DI依赖注入，和控制反转是同一个概念的不同角度的描述，即 应用程序在运行时依赖IoC容器来动态注入对象需要的外部资源。

（2）最直观的表达就是，IOC让对象的创建不用去new了，可以由spring自动生产，使用java的反射机制，根据配置文件在运行时动态的去创建对象以及管理对象，并调用对象的方法的。

（3）Spring的IOC有三种注入方式 ：构造器注入（用构造方法注入）、setter方法注入（用成员变量的set方法注入）、接口注入（用代码getBean注入）。

• 解释下aop、ioc？

  答案解析：aop和ioc是spring的两大核心思想，aop是面向切面编程，用的是动态代理和反射，常用的地方是事务、日志。ioc是控制反转，用的是工厂模式，通过两种方式可以将对象在项目启动时加载到内存，一是配置文件方式，在web.xml中配置，而是通过注解方式，启东时将有@Component、@Bean注解的类加载到内存。

• 代理模式有几种？
  a.静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者继承相同的父类.
  b.jdk动态代理的代理对象在创建时,需要使用业务实现类所实现的接口作为参数(因为在后面地理方法时需要根据接口内的方法名进行调用).如果业务实现类是没有实现接口而是直接定义业务方法的话,就无法使用jdk动态代理了.并且如果业务实现类中新增了接口中没有的方法,这些方法是无法被代理的(因为无法被调用)
  c.cglib是针对类来实现代理的,原理是对指定的业务类生成一个子类,并覆盖其中业务方法实现代理.因为采用的是继承,所以不能对final修饰的类进行代理.

• SpringBoot中starter原理简介
  答：starter可以当成是一个maven依赖组，引入这个组名就引入了所有的依赖和一些初始化配置。具体看参考文章。

参考

• springMVC执行流程
  第一步：发起请求到前端控制器(DispatcherServlet)
  第二步：前端控制器请求HandlerMapping查找 Handler （可以根据xml配置、注解进行查找）
  第三步：处理器映射器HandlerMapping向前端控制器返回Handler，HandlerMapping会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象，多个HandlerInterceptor拦截器对象），通过这种策略模式，很容易添加新的映射策略
  第四步：前端控制器调用处理器适配器去执行Handler
  第五步：处理器适配器HandlerAdapter将会根据适配的结果去执行Handler
  第六步：Handler执行完成给适配器返回ModelAndView
  第七步：处理器适配器向前端控制器返回ModelAndView （ModelAndView是springmvc框架的一个底层对象，包括 Model和view）
  第八步：前端控制器请求视图解析器去进行视图解析 （根据逻辑视图名解析成真正的视图(jsp)），通过这种策略很容易更换其他视图技术，只需要更改视图解析器即可
  第九步：视图解析器向前端控制器返回View
  第十步：前端控制器进行视图渲染 （视图渲染将模型数据(在ModelAndView对象中)填充到request域）
  第十一步：前端控制器向用户响应结果
  
• spring中人bean是多例还是单例？
  答：默认单实例多线程 ；可以在类上加@Scope(“prototype”)变成多例模式。
• 请解释Spring Bean的生命周期？

首先说一下Servlet的生命周期：实例化，初始init，接收请求service，销毁destroy；

Spring上下文中的Bean生命周期也类似，如下：

（1）实例化Bean：

对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。

（2）设置对象属性（依赖注入）：

实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息 以及 通过BeanWrapper提供的设置属性的接口完成依赖注入。

（3）处理Aware接口：

接着，Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给Bean：

①如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的就是Spring配置文件中Bean的id值；

②如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。

③如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文；

（4）BeanPostProcessor：

如果想对Bean进行一些自定义的处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。

（5）InitializingBean 与 init-method：

如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。

（6）如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法；由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术

• spring 中的 bean 是线程安全的吗？

Spring容器中的Bean是否线程安全，容器本身并没有提供Bean的线程安全策略，因此可以说spring容器中的Bean本身不具备线程安全的特性，但是具体还是要结合具体scope的Bean去研究。

• 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作用域。

• spring 事务实现方式有哪些？

编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。
基于 TransactionProxyFactoryBean 的声明式事务管理
基于 @Transactional 的声明式事务管理
基于 Aspectj AOP 配置事务

• 说一下 spring 的事务隔离？

事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度，当多个事务同时访问相同数据时，如果没有采取必要的隔离机制，就可能发生以下问题：
脏读：一个事务读到另一个事务未提交的更新数据。
幻读：例如第一个事务对一个表中的数据进行了修改，比如这种修改涉及到表中的“全部数据行”。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入“一行新数据”。那么，以后就会发生操作第一个事务的用户发现表中还存在没有修改的数据行，就好象发生了幻觉一样。
不可重复读：比方说在同一个事务中先后执行两条一模一样的select语句，期间在此次事务中没有执行过任何DDL语句，但先后得到的结果不一致，这就是不可重复读。

• 什么是 spring boot？

在Spring框架这个大家族中，产生了很多衍生框架，比如 Spring、SpringMvc框架等，Spring的核心内容在于控制反转(IOC)和依赖注入(DI),所谓控制反转并非是一种技术，而是一种思想，在操作方面是指在spring配置文件中创建，依赖注入即为由spring容器为应用程序的某个对象提供资源，比如 引用对象、常量数据等。
SpringBoot是一个框架，一种全新的编程规范，他的产生简化了框架的使用，所谓简化是指简化了Spring众多框架中所需的大量且繁琐的配置文件，所以 SpringBoot是一个服务于框架的框架，服务范围是简化配置文件。

• spring boot 配置文件有哪几种类型？它们有什么区别？
  Spring Boot提供了两种常用的配置文件，分别是properties文件和yml文件。相对于properties文件而言，yml文件更年轻，也有很多的坑。可谓成也萧何败萧何，yml通过空格来确定层级关系，使配置文件结构跟清晰，但也会因为微不足道的空格而破坏了层级关系。

• jpa 和 hibernate 有什么区别？

简答：前者是规范，后者是实现。
JPA Java Persistence API，是Java EE 5的标准ORM接口，也是ejb3规范的一部分。
Hibernate，当今很流行的ORM框架，是JPA的一个实现，但是其功能是JPA的超集。
JPA和Hibernate之间的关系，可以简单的理解为JPA是标准接口，Hibernate是实现。那么Hibernate是如何实现与JPA的这种关系的呢。Hibernate主要是通过三个组件来实现的，及hibernate-annotation、hibernate-entitymanager和hibernate-core。
hibernate-annotation是Hibernate支持annotation方式配置的基础，它包括了标准的JPA annotation以及Hibernate自身特殊功能的annotation。
hibernate-core是Hibernate的核心实现，提供了Hibernate所有的核心功能。
hibernate-entitymanager实现了标准的JPA，可以把它看成hibernate-core和JPA之间的适配器，它并不直接提供ORM的功能，而是对hibernate-core进行封装，使得Hibernate符合JPA的规范。

• IOC，AOP的实现原理？

IOC：通过反射机制生成对象注入
AOP：动态代理

• 什么是 spring cloud？

从字面理解，Spring Cloud 就是致力于分布式系统、云服务的框架。
Spring Cloud 是整个 Spring 家族中新的成员，是最近云服务火爆的必然产物。
Spring Cloud 为开发人员提供了快速构建分布式系统中一些常见模式的工具，例如
配置管理
服务注册与发现
断路器
智能路由
服务间调用
负载均衡
微代理
控制总线
一次性令牌
全局锁
领导选举
分布式会话
集群状态
分布式消息
……

其他

• 解释下缓存击穿/雪崩/穿透

答：
击穿：就是某一个热点数据，缓存中某一时刻失效了，因而大量并发请求打到数据库上，就像被击穿了一样，说白了，就是某个数据，数据库有，但是缓存中没有。
雪崩：其实把缓存击穿搞清楚了，那么你去理解缓存雪崩也会容易许多。
缓存雪崩，指的是大面积的 key 同时过期，导致大量并发打到我们的数据库。
不像击穿，只是因为 1 个 key 的过期。
所以，对于雪崩来说，一般，少量的 key 失效，所带来的数据库的并发压力是不会太大的。
而是大量 key 的同时失效，导致所有 key 的并发加起来，会影响到我们的数据库。
很多人会把缓存穿透和击穿搞混，主要是名词方面的混淆。
更多的，我觉得关注意思即可。
缓存穿透，与击穿的区别就是，
击穿：数据库里“有”数据；
穿透：数据库里“没”数据。
所以，缓存击穿可以规避，因为只是 redis 缓存数据失效了，而数据库里有数据，只要把数据库里的数据更新到 redis 上，那么就可以解决掉缓存击穿的问题。
但是，缓存穿透，意味着，这个数据，数据库里也没有。
所以，就不可能会把数据存到 redis 缓存里，因此只要有人来查询，就一定缓存中查不到，所以就一定要走数据库。
那么，假设很多人，故意去查那些数据库里也没有的记录，我们的 redis 就起不到屏障的作用，因为 redis 里不可能有数据，所以并发查询就一定会打到数据库的身上。

• 事务的特性和隔离级别

  答：很详细 mysql默认的隔离级别是REPEATABLE READ

引用的文章原地址：
1.辛苦了
2.感谢
3.6666