高频面经汇总：https://blog.csdn.net/qq_40262372/article/details/116075528

8.1Spring相关 面试题总结

8.1.1什么是Spring框架？

  Spring是一种轻量级开发框架，旨在提高开发人员的开发效率以及系统的可维护性。

  目的：解决企业应用开发的复杂性

  功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

  范围：任何Java应用

  简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

Spring官网列出的Spring的6个特性：

核心技术，测试，数据访问，Web支持，继承，语言。

8.1.2 列举一些重要的Spring模块

Spring Core可以说Spring其他所有的功能都需要依赖该类库。主要提供IoC依赖注入功能

Spring AOP: 提供面向切面的编程实现。

Spring JDBC: Java数据库连接。

Spring ORM: 用于支持Hibernate等ORM工具。

Spring Web:为创建Web应用程序提供支持。

Spring Test:提供了对Junit测试的支持。

8.1.3 @RestController和@Controller

  Controller 返回一个页面

  单独使用@Controller不加@ResponseBody的话一般都会返回一个视图，这个情况属于比较传统的Spring MVC的应用，对应于前后端不分离的情况。

RestController返回JSON或XML形式数据

但@RestController只返回对象，对象数据直接以JSON或XML形式写入HTTP响应(Response)中，这种情况属于RESTFUL WEB服务，这也是目前日常开发所接触的最常用的情况(前后端分离)

Controller+ResponseBody返回JSON或XML形式数据

  如果想在Spring4之前开发RESTFUL Web服务的话，只需要结合ResponseBody即可。

8.1.4 (1次)SpringIOC&AOP

谈谈自己对于Spring Ioc和AOP的理解

IoC

  IoC(控制反转)是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。IoC在其他语言中也有应用，并非Spring特有。IoC容器是Spring用来实现IoC的载体，IoC容器实际上就是个Map(key,value)，Map中存放的是各种对象。

  将对象之间的相互依赖关系交给IoC容器来管理，并由IoC容器完成出来对象的注入。这样可以很大程度上简化应用的开发，把应用从复杂的依赖关系中解放出来。IoC容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件/注解即可，完全不用考虑对象是如何被创建出来的。在实际项目中一个Service类可能有几百甚至上千类作为它的底层，加入我们需要实例化这个Service,你可能要每次都要搞清楚这个Service所有底层类的构造函数，这可能会把人逼疯。如果利用了IoC的话，你只需要配置好，然后在需要的地方引用就行了，这大大增加了项目的可维护性且降低了开发难度。

  Spring时代一般使用XML文件来配置Bean，后来开发人员觉得XML文件来配置不太友好，于是SpringBoot注解就慢慢流行起来了。

直接去工厂取，而不是去关联对象，因为可能一个类中会用多个对象，有工厂的话，那么只需要工厂一个类，而不是很多的类，减少耦合。

Ioc的例子：

AOP

  AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任(例如事务管理、日志管理、权限控制)封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

  Spring AOP是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy,去创建代理对象，而对于没有实现接口的对象(有些类单类，不去实现接口)，就无法使用JDK Proxy去进行代理，这时候Spring AOP会使用Cglib，这时候Spring AOP会使用Cglib生成一个被代理对象的子类来作为代理，如下图所示：

代码实现：

 

就相当于一个类不能满足要求了，另外开一个类去获得该类的方法，然后自己在添加方法。

这个是动态代理，没有专门写一个类来扩展，是需要的时候我们另开一个类代理，因此我们就会有一个Proxy.newProxyInstance方法来获得当前需要被代理的类，然后被代理后就在invoke中加入要另外添加的东西。

  当然也可以使用AspectJ,任何对象都可以使用，基于字节码操作，编译时增强；但是Spring AOP只能用作Spring Beans上，基于代理(Proxy)，运行时增强。

方式一：使用Spring的API接口

方式二：自定义来实现AOP

方式三：使用注解实现

还要导入aop包

代理模式：

静态代理模式的好处：

• 可以使真实觉得的操作更加纯粹!不用关注一些公共的业务
• 公共也就是交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理。

缺点:

• 一个真实角色就会产生一个代理角色；代码量会翻倍~开发效率会变低~

动态代理的好处：

• 可以使真实觉得的操作更加纯粹!不用关注一些公共的业务
• 公共也就是交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理。
• 一个动态代理类就是一个接口，一般就是对应的一类业务
• 一个动态代理类可以代理多个类多个类，只要是实现了同一个接口即可。

8.1.5(2次)Spring bean

Spring中的bean的作用域有那些?

Bean的含义：被Spring IOC容器初始化、装配、管理的对象。那么对于Spring托管的单例ServiceBean，如何保证安全？Spring的单例是基于BeanFatory也就是Spring容器的，单例Bean在此容器内只有一个，Java的单例是基于JVM，每个JVM中内只有一个实例。

  后三个仅在WEB框架使用。

  Singleton:唯一bean实例，Spring中的bean是单例；

  Prototype:每次请求都会创建一个新的bean实例，一个bean对象多个对象实例

  Request:每一次HTTP请求都会产生一个新的bean,该bean仅在当前HTTP request内有效

  Session：每一次HTTP请求都会产生一个新的bean,该bean仅在当前HTTP session内有效

  Global-session:全局session作用域，仅仅在基于portlet的web应用中才有意义，Spring5已经没有了。

Spring中的单例bean的线程安全了解吗？

  大部分时候我们并没有在系统中使用多线程，所以很少有人会关注这个问题。单例bean存在线程问题，主要是因为当多个线程操作同一个对象的时候，对这个对象的非静态成员变量的写操作会存在线程安全问题。

  常见的两种解决方法：

  1.在Bean对象中尽量避免定义可变的成员变量(不太现实)。

  2.在类中定义一个ThreadLocal成员变量，将需要的可变成员变量保存在ThreadLocal中。

@Component和@Bean的区别是什么？

1.作用对象不同：@Component注解作用于类，而@Bean注解作用于方法,因为这个方法返回的就是new 类。

2.@Component通常是通过类路径扫描来自动装配到Spring容器中(会调用ComponentScan注解去扫描路径)。@Bean告诉了Spring这是某个类的示例，当我们需要用它的时候就给我。

3.当我们要引用第三方库的类时，我们只能用@Bean。

将一个类声明为Spring的bean的注解有那些？

  我们一般使用@Autowired注解自动装配bean，要想把类标识成@Autowired能自动装配的bean，采用以下注解实现：

  @Component:通用的注解，可标注任意类为Spring组件。如果一个Bean不知道属于哪个层，可以使用@Component注解标注。

  @Repository:对应持久层即Dao层，主要有用于数据库的操作。

  @Service：对应服务层，主要涉及一些复杂的逻辑，需要用到Dao层。

  @Controller:对应Spring MVC控制层，主要用户接受用户请求并调用Service层返回数据给前端页面。

(1次)Spring中的bean生命周期？

 总结下来，只有4个。

  1.实例化

  2.属性赋值

  3.初始化

  4.销毁

实例化à属性赋值->初始化->销毁

(1次)Bean的注入方式：

1.set方法注入：

2.构造器注入：

构造器可以用三个方式：1.参数名称 2.参数下标 3.参数类型

3.静态工厂注入：

  我们编写一个静态的工厂方法，这个工厂方法会返回一个我们需要的值，然后在配置文件中，我们指定使用这个工厂方法创建bean。注意是静态方法！

4.实例工厂注入

  实例工厂与静态工厂，不同的是，静态工厂调用工厂方法不需要先创建工厂类的对象，因为静态方法可以直接通过类调用，所以在上面的配置文件中，并不会声明工厂类的bean。但是，实例工厂，需要一个实例对象，才能调用它的工程方法。

(1次)Bean的扫描加载过程(找了半天直接上源码对照看即可！相信自己)：

如何从一个配置文件到一个对象：

bean定义对象：定义bean的一些属性，比如作用域，是否懒加载等。

从xml文件到最后的bean拿来应用放在哪里，bean放在IOC容器(是一个概念)中，实际上用数据结构存储，用的Map存储。

既然是一个容器，那么肯定有一个入口，所有Spring容器有一个根接口。BeanFactory

选择入口和容器都有了，那么就该放对象了，放对象的操作。

因此在容器中就会有一个beanDefination，给容器添加元素。

有不同类型进行定义Bean，因此其中会有一个统一接口BeanDefinitionReader去解析成统一规格给BeanDefinition。

那么从BeanDefinition直接到实例化,直接到到了吗？肯定不会这么简单啊。进一步再回忆Spring是什么？

我需要单独都写一个框架吗？肯定不是啊。因此Spring底层肯定满足扩展性、扩展性、扩展性

因此从BeanDefinition无论是new还是反射，都不会到实例化的。

为什么要使用反射？反射性能不是低吗？ 反射只是成十万对象的时候才会出现性能瓶颈，几十个、几百个不印象的是不会成为性能问题。因为反射足够的灵活！！我们想要new一个实例出来，必须要知道这个类。我们在配置文件中写好了类吗？我们在配置文件中是写好了类的完全限定名，我们知道这个限定名，是无法直接获取class对象和字节码文件的。

Xml读到BeanDefinition去的是${jdbc.url}还是实际的值。正确答案是带参数占位符的${jdbc.url}，因此我们要想实例化，肯定要去把这个替换掉成为我们想要的实际值。所以在BeanDefinition到实例化肯定还有过程。

在进行反射之前，肯定要换成真实变量，所以就要开始慢慢引入把占位符的东西换成我们真实需要的东西。

  这个PostProcessor就是将占位符、空配符换成我们真实的属性。这两个是不同阶段的操作，因此要分成BeanFactory和Bean。

  

  BeanDefinition读过来后，我们要进行实例化了，要修改工厂中的某些对象，将那些占位符的修改成真实值。因此经过BeanFactoryPostProcessor将BeanDefinition中一些具有占位符的属性换成我们真实的值。

  

BeanFactoryPostProcessor可以修改bean的definition参数，上图是自己建立的一个类，然后去实现BeanFactoryPostProcessor接口。

Spring一开始出来的时候，是写xml,后来注解可以用了，我们把注解集成到Spring生态中去。

通过BeanFactoryPostProcessor修改完后，我们就可以通过反射对类进行实例化。

  通过反射获得Class（三种方式：1.Class.forName(类的路径)；2.类名.class；3.对象.forClass()），然后通过Class获得类构造器（.getDelcareConstructor），然后通过类构造器获得实例对象(.getIntance)

  这样创建的对象是不完整的，创建对象是真正包括两块的：

那么回到IOC容器中，我们在实例化后，还有一系列的初始化操作，调用aware接口的方法。Bean的生命周期操作。

Spring的实例化也非常喜欢出幺蛾子，为了构造好Spring生态也是不容易啊！！(bean的生命周期开始秀了)，填充属性的时候出出现，对象的不同导致·用aware

其中有我自己标签定义的Bean，然后可能去调用容器中的对象。

Aware里全是去设置值的。

例子解释aware，一个类先是用name，get\set

现在又增加一个属性beanName，也有set/get

beanName我是后来又加的，意味着我们又增加set方法吗？实则不需要，我们只用实现BeanNameAware即可(有别名之类的，因此要统一名字)，然后会让我强行重写set方法。这里实际上就是在注入了

  实现了aware接口我们就去拿容器的对象了。

  跟直接set有什么区别：

  直接set的前提是你要有对象，在容器里面怎么调用这个set。

所以容器里的aware帮你去set，之后得到对象后直接get即可。  在这里我们已经把bean对象搞定了，但是为了Spring大生态，这里Bean对象还要经过加工才可以。调试源码的例子：

populateBean 是给注入普通属性

initializeBean 是注入Aware接口的属性

如果去掉setBeanName的复制，那么下面就是这样的注入属性了

这个就会变为空了。

  

Before,after都是AOP织入进去的。

中间就是自己自定义的方法，bean配置中有一个init-method

加载Bean的时候可以执行自己定义的方法一次。

Before与After 用的AOP，AOP基于动态代理，动态代理两种方式解决，jdk,cglib： 有接口用jdk，没接口用cglib。

然后获取真正的Bean对象

总结下来：生命周期包括：实例化，初始化，销毁

看懂refresh的十三个方法就把Spring源码搞懂了。

1.准备容器，prepareRefresh，设置启动时间之类的，初始化资源之类，跟Bean无关的。

2.obtainBeanFactory,如果存在就毁掉，重新重建，里面开始加载beanDefinition(beanDefinitionMap和beanDefinitionNames)，loadBeanDefinitions一直套娃,一直在重载。

3.得到BeanDefinition后，就开始用BeanFactoryPostProcessors。一直给我们BeanDefinition设置属性值

4.invokeBeanFactoryPostProcessor()调用这个PostProcessor，容器中全部没有类，全靠反射搞类。

5.实例化这边这么多步骤，要不要做准备工作呢？before,after 要进行postprocessor准备工作还要准备监听器，广播器。registerBeanPostProcessors 做准备工作，等到后面before或after才开始执行

6.finishBeanFactoryInitialization开始实例化了。里面也是set,add。也是设置属性。最后一行，preInstantiate,默认单例，容器里有且只有一个对象，在每次创建前先要去获取，再看有没有，源码里有doXXX是实际干活的方法，看见什么代码，意味着Bean创建成功。一路搞构造器，新建实例。

7. 填充属性，是填充我们自己set的内容，比如姓名=zhangsan

8.invokeAwareMethods，将aware接口的beanName赋值，但是applicitioncontext没有赋值

9.applicationcontext是在before完成的

10.initMethod方法

11.AfterMethod

12.继续循环。直到新注册的bean搞完。

8.1.6(1次) Spring MVC

8.1.6.1 MVC介绍

  谈到SpringMVC,我们不得不提一下之前Model1和Model2这两个没有SpringMVC时代。

Model1(视图层+模型层):

整个web项目都是用JSP写的，只有少量的JavaBean去和数据库打交道。这个模式下Jsp即使控制层又是表现层。显而易见，这个模式存在很多问题。①前端后端依赖严重，难以进行测试并开发效率低。②控制逻辑和表现逻辑是混杂一起，导致代码复用率低。

Model2:

整个是由Javabean(Model)+JSP(View)+Servlet(Controller)。这种开发模式就是早期的JavaWeb MVC，但是用这种模式开发不可避免地会重复造轮子，这会大大降低程序的可维护性和复用性。

随着Spring轻量级开发框架的流行，Spring生态圈出现了Spring MVC是当前最优秀的MVC框架。可以帮助我们进行更简洁的Web层的开发，并且它与Spring框架集成。Spring MVC一般把后端项目分成Service层（处理业务）、Dao层（数据库操作）、Entity层（实体类）、Controller（控制层，返回数据给前台页面）。

处理器中包含映射器和适配器。映射器是寻找Handler，返给前端控制器，然后再给适配器与Hanlder处理器弄。

8.1.6.2(1次) MVC流程，@RequestMapping的注解具体怎么实现的？

  1.Spring扫描所有的Bean

  2.遍历这些bean，依次判断是否是处理器，并检测其HandlerMethod

  3.遍历Handler中的所有方法，找出其中被@RequestMapping注解标记的方法。

  4.获取方法method上的@RequestMapping实例

  5.检查方法所属的类有没有@RequestMapping注解

  6.将类和方法的RequestMapping结合

  7.当请求到达时，去UrlMap中找匹配的Url，以及获取对应mapping实例，然后去handerMethods中获取匹配HandlerMethod实例。

  8.将RequestMappingInfo实例以及处理方法注册到缓存中。

  

8.1.6.3 MVC自动装配流程

8.1.7 Spring框架中用到了那些设计模式？

  工厂设计模式：Spring使用工厂模式通过BeanFactory、ApplicationContext创建bean对象。

  代理模式：Spring AOP功能的实现。

  单例设计模式：Spring中的Bean默认都是单例的。

  包装器设计模式：我们的项目需要连接不同类型的数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们根据客户的需求能够动态切换不同的数据源。

  观察者模式：Spring事件驱动模型就是观察者模式最经典的一个应用。

  适配器模式：SpringAOP的增强或通知(Advice)使用到了适配器模式、Spring MVC中也是使用了适配器模式适配Controller。 加一个适配器的类，引入网线，转成USB，这样电脑用USB就可以上网了。

8.1.8Spring事务

介绍

 Spring事务的本事其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。对于纯JDBC操作数据库，想要用到事务，可以按照这几步：

1.获得连接

2.开启事务

3.执行JDBC

4.提交事务/回滚事务

5.关闭连接

Spring的事务是帮我们做了第2步和第4步，是利用动态代理方法。

Sprig管理事务的方式有几种？

 1.编程式事务，在代码中硬编码。(不推荐使用)

 2.声明式事务，在配置文件中配置(推荐使用)

声明式事务分为以下两种：

1.基于XML的声明式事务

2.基于注解的声明式事务

Spring事务的隔离级别有哪几种？

TransactionDefinition接口中定义了五个表示隔离级别的常量(sql是4个+一个默认)：

1.Default:使用后端数据库默认的隔离级别，Mysql默认采用的是可重复读。Sqlsever默认采用的是读已提交。

2—5与sql的四个事务一样：读未提交、读已提交、可重读、串行化。

Spring事务中有哪几种事务传播行为？

事务传播：指的是当一个事务被另一个事务调用时，这个事务方法应该如何进行。

例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢,还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。

支持当前事务的情况：

1.如果当前存在事务，则加入该事务。没有的话，就新建一个事务。

2……，没有的话，就以非事务的方式运行

3……,没有的话，就抛出异常。

不支持当前事务的情况：

1.总是新建事务，如果一个事务A已经存在，则先将存在的事务A挂起，去跑B

2.总是以非事务方式运行，如果当前存在事务，则把当前事务挂起

3.总是以非事务方式运行，如果当前存在事务，则抛出异常

其他情况：

1.如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则取支持当前事务的第一种情况。

(1次)@Transactional(rollbackFor=Exception.class)注解了解吗？

怎么实现：

1.配置文件开启注解驱动，在相关的类和方法上通过注解@Transactional标识。

2.spring在启动的时候会去解析生成相关的bean,这时候会查看拥有相关注解的类和方法，并且为这些类和方法生成代理，并根据@Transaction的相关参数进行相关配置注入，这样就在代理中我们把相关的事务处理掉了(开启正常提交事务，异常回滚事务)。

3.真正的数据库的事务和回滚是通过binlog或者redo log实现的。

8.1.9 (1次)Spring、SpringMVC、SpringBoot、SpringCloud的联系与区别

   Spring:一个轻量级的控制反转和面向切面的容器。

   SpringMVC: MVC 框架提供了模型-视图-控制的体系结构和可以用来开发灵活、松散耦合的 web 应用程序的组件

   SpringBoot: 它基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。

  SpringCloud: 它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。

联系与区别：Spring提供IOC和AOP的容器，并具有强大的扩展功能；Springmvc在上面拓展了WEB开发，基于Servlet的一个MVC框架，通过XML配置，统一开发前端视图和后端逻辑；SpringBoot专注于微服务方面的接口开发，和前端解耦，同时也解决了Spring配置非常复杂，各种XML、Servlet处理起来比较繁琐，默认优于配置，简化了SpringMVC的配置流程；SpringCould更关注全局微服务的整合和管理，相当于管理多个springBoot框架的单体微服务。

8.1.10 SpringCloud微服务治理

  

  有了微服务，那么我们就需要去管理他们，然后就会有很大一堆方法了。

网关就是整个整体的守门人；日志采集，追踪工具，服务注册发现都是用来采集信息的；然后需要监控平台来展现这些采集的信息，并进行监控和分析。最后根据分析的结果采取治理策略，有的服务快撑不住了要限流，有的服务坏了要熔断，并且还能够及时的调整这些服务的配置。

8.1.11 springBoot核心注解，自动装配原理

核心注解

  说到springboot的核心注解，肯定是springBootApplication注解当之无愧了。这个注解里面有三个注解，我一个一个说：

1.@springbootConfiguration

用来代替 applicationContext.xml 配置文件，所有这个配置文件里面能做到的事情都可以通过这个注解所在类来进行注册。

2.@ComponentScan

用来代替配置文件中的 component-scan 配置，开启组件扫描，即自动扫描包路径下的 @Component 注解进行注册 bean 实例到 context 中。

3.@EnableAutoConfiguration

用来提供自动配置

自动装配

JAVA与计算机基础高频面试题：

https://blog.csdn.net/qq_40262372/article/details/112556249