Spring经典高频面试题，原来是长这个样子

傷城~ 2023-06-04 02:43 7阅读 0赞

# Spring经典高频面试题，原来是长这个样子 #

2019年08月23日 15:01:32 [博文视点][Link 1] 阅读数 719

本文链接： [https://blog.csdn.net/broadview2006/article/details/100037214][https_blog.csdn.net_broadview2006_article_details_100037214]

本文选自《Spring 5核心原理与30个类手写实战》一书，文末参与互动有机会赢取本书。本文题目目录：

1  什么是Spring框架，Spring框架有哪些主要模块

2  使用Spring框架能带来哪些好处

3  什么是控制反转（IoC），什么是依赖注入

4  在Java中依赖注入有哪些方式

5  BeanFactory和ApplicationContext有什么区别

6  Spring提供几种配置方式来设置元数据

7  如何使用XML配置方式配置Spring

8  Spring提供哪些配置形式

9  怎样用注解的方式配置Spring

10  请解释Spring Bean的生命周期

11  更多经典高频面试题

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

1  什么是Spring框架，Spring框架有哪些主要模块

Spring框架是一个为Java应用程序开发提供综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发。Spring框架本身也是按照设计模式精心打造的，这使得我们可以在开发环境中安心地集成Spring框架，不必担心Spring是如何在后台工作的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

2  使用Spring框架能带来哪些好处

下面列举了一些使用Spring框架带来的主要好处。

（1）Dependency Injection（DI）使得构造器和JavaBean properties文件中的依赖关系一目了然。

（2）与EJB容器相比较，IoC容器更加趋向于轻量级。这样一来使用IoC容器在有限的内存和CPU资源的情况下进行应用程序的开发和发布就变得十分有利。

（3）Spring并没有闭门造车，Spring利用了已有的技术，比如ORM框架、logging框架、J2EE、Quartz和JDK Timer，以及其他视图技术。

（4）Spring框架是按照模块的形式来组织的。由包和类的编号就可以看出其所属的模块，开发者只需选用需要的模块即可。

（5）要测试一个用Spring开发的应用程序十分简单，因为测试相关的环境代码都已经囊括在框架中了。更加简单的是，利用JavaBean形式的POJO类，可以很方便地利用依赖注入来写入测试数据。

（6）Spring的Web框架也是一个精心设计的Web MVC框架，为开发者在Web框架的选择上提供了一个除主流框架（比如Struts）和过度设计的、不流行Web框架以外的选择。

（7）Spring提供了一个便捷的事务管理接口，适用于小型的本地事务处理（比如在单DB的环境下）和复杂的共同事务处理（比如利用JTA的复杂DB环境）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

3  什么是控制反转（IoC），什么是依赖注入

（1）控制反转是应用于软件工程领域的，在运行时被装配器对象用来绑定耦合对象的一种编程技巧，对象之间的耦合关系在编译时通常是未知的。在传统的编程方式中，业务逻辑的流程是由应用程序中早已被设定好关联关系的对象来决定的。在使用控制反转的情况下，业务逻辑的流程是由对象关系图来决定的，该对象关系图由装配器负责实例化，这种实现方式还可以将对象之间的关联关系的定义抽象化。绑定的过程是通过“依赖注入”实现的。

（2）控制反转是一种以给予应用程序中目标组件更多控制为目的设计范式，并在实际工作中起到了有效的作用。

（3）依赖注入是在编译阶段尚未知所需的功能是来自哪个的类的情况下，将其他对象所依赖的功能对象实例化的模式。这就需要一种机制来激活相应的组件以提供特定的功能，所以依赖注入是控制反转的基础。否则如果在组件不受框架控制的情况下，框架又怎么知道要创建哪个组件呢？

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

4  在Java中依赖注入有哪些方式

（1）构造器注入。

（2）Setter方法注入。

（3）接口注入。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

5  BeanFactory和ApplicationContext有什么区别

BeanFactory 可以理解为含有Bean集合的工厂类。BeanFactory 包含了Bean的定义，以便在接收到客户端请求时将对应的Bean实例化。

BeanFactory还能在实例化对象时生成协作类之间的关系。此举将Bean自身从Bean客户端的配置中解放出来。BeanFactory还包含Bean生命周期的控制，调用客户端的初始化方法（Initialization Method）和销毁方法（Destruction Method）。

从表面上看，ApplicationContext如同BeanFactory一样具有Bean定义、Bean关联关系的设置及根据请求分发Bean的功能。但ApplicationContext在此基础上还提供了其他功能。

（1）提供了支持国际化的文本消息。

（2）统一的资源文件读取方式。

（3）已在监听器中注册的Bean的事件。

以下是三种较常见的 ApplicationContext 实现方式。

（1） ClassPathXmlApplicationContext： 从ClassPath的XML配置文件中读取上下文，并生成上下文定义。应用程序上下文从程序环境变量中取得。

ApplicationContext context = new ClassPathXmlApplicationContext(“application.xml”);

（2）FileSystemXmlApplicationContext ：由文件系统中的XML配置文件读取上下文。

ApplicationContext context = new FileSystemXmlApplicationContext(“application.xml”);

（3）XmlWebApplicationContext：由Web应用的XML文件读取上下文。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

6  Spring提供几种配置方式来设置元数据

Spring提供以下三种配置方式来设置元数据：

（1）基于XML的配置。

（2）基于注解的配置。

（3）基于Java的配置。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

7  如何使用XML配置方式配置Spring

在Spring框架中，依赖和服务需要专门的配置文件实现，一般用XML格式的配置文件。这些配置文件的格式采用公共的模板，由一系列的Bean定义和专门的应用配置选项组成。

Spring XML配置的主要目的是使所有的Spring组件都可以用XML文件的形式来进行配置。这意味着不会出现其他的Spring配置类型（比如声明配置方式或基于Java Class的配置方式）。

Spring的XML配置方式是使用被Spring命名空间所支持的一系列的XML标签来实现的。Spring主要的命名空间有context、beans、jdbc、tx、aop、mvc和aso。例如：

下面这个web.xml仅配置了DispatcherServlet，最简单的配置便能满足应用程序配置运行时组件的需求。

<web-app>   <display-name>Archetype Created Web Application</display-name>   <servlet>      <servlet-name>spring</servlet-name>      <servlet-class>         org.springframework.web.servlet.DispatcherServlet      </servlet-class>      <load-on-startup>1</load-on-startup>   </servlet>   <servlet-mapping>      <servlet-name>spring</servlet-name>      <url-pattern>/</url-pattern>   </servlet-mapping></web-app>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

8  Spring提供哪些配置形式

Spring对Java配置的支持是由@Configuration注解和@Bean注解来实现的。由@Bean注解的方法将会实例化、配置和初始化一个新对象，这个对象将由Spring的IoC容器来管理。@Bean声明所起到的作用与元素类似。被@Configuration所注解的类则表示这个类的主要目的是作为Bean定义的资源。被@Configuration声明的类可以通过在同一个类内部调用@bean方法来设置嵌入Bean的依赖关系。

最简单的@Configuration 声明类请参考下面的代码：

@Configurationpublic class AppConfig{    @Bean   public MyService myService() {       return new MyServiceImpl();   }}

与上面的@Beans配置文件相同的XML配置文件如下：

上述配置方式的实例化方式如下：

public static void main(String[] args) {    ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);   MyService myService = ctx.getBean(MyService.class);   myService.doStuff();}

要使用组件扫描，仅需用@Configuration进行注解即可：

@Configuration@ComponentScan(basePackages = "com.gupaoedu")public class AppConfig { }

在上面的例子中，com.gupaoedu包首先会被扫描到，然后在容器内查找被@Component 声明的类，找到后将这些类按照Spring Bean定义进行注册。

如果你要在Web应用开发中选用上述配置方式，需要用AnnotationConfigWebApplicationContext类来读取配置文件，可以用来配置Spring的Servlet监听器ContrextLoaderListener或者Spring MVC的DispatcherServlet。

例如：

<web-app>
       <context-param>      <param-name>contextClass</param-name>      <param-value>         org.springframework.web.context.support.AnnotationConfigWebApplicationContext      </param-value>   </context-param>   <context-param>      <param-name>contextConfigLocation</param-name>      <param-value>com.gupaoedu.AppConfig</param-value>   </context-param>   <listener>      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>   </listener>   <servlet>      <servlet-name>dispatcher</servlet-name>      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>      <init-param>         <param-name>contextClass</param-name>         <param-value>            org.springframework.web.context.support.AnnotationConfigWebApplicationContext         </param-value>      </init-param>      <init-param>         <param-name>contextConfigLocation</param-name>         <param-value>com.gupaoedu.web.MVCConfig</param-value>      </init-param>   </servlet>   <servlet-mapping>      <servlet-name>dispatcher</servlet-name>      <url-pattern>/web/*</url-pattern>   </servlet-mapping></web-app>

9  怎样用注解的方式配置Spring

Spring在2.5版本以后开始支持用注解的方式配置依赖注入。可以用注解的方式来替代XML方式的Bean描述，可以将Bean描述转移到组件类的内部，只需要在相关类上、方法上或者字段声明上使用注解即可。注解注入将会被容器在XML注入之前处理，所以后者会覆盖前者对于同一个属性的处理结果。

注解装配在Spring中是默认关闭的，需要在Spring文件中进行配置才能使用基于注解的装配模式。如果你想要在应用程序中使用注解的方式，请参考如下配置：

配置完成以后，就可以用注解的方式在Spring中向属性、方法和构造方法中自动装配变量。

下面是几种比较重要的注解类型。

（1）@Required：该注解应用于设值方法。

（2）@Autowired：该注解应用于设值方法、非设值方法、构造方法和变量。

（3）@Qualifier：该注解和@Autowired注解搭配使用，用于消除特定Bean自动装配的歧义。

（4）JSR-250 Annotations：Spring支持基于JSR-250 注解的注解，即@Resource、@PostConstruct和@PreDestroy。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

10  请解释Spring Bean的生命周期

Spring Bean的生命周期简单易懂。在一个Bean实例被初始化时，需要执行一系列初始化操作以使其达到可用的状态。同样，当一个Bean不再被调用时需要进行相关的析构操作，并从Bean容器中移除。

Spring Bean Factory 负责管理在Spring容器中被创建的Bean的生命周期。Bean的生命周期由两组回调方法组成。

（1）初始化之后调用的回调方法。

（2）销毁之前调用的回调方法。

Spring提供了以下4种方式来管理Bean的生命周期事件：

（1）InitializingBean和DisposableBean回调接口。

（2）针对特殊行为的其他Aware接口。

（3）Bean配置文件中的 customInit() 方法和 customDestroy() 方法。

（4）@PostConstruct和@PreDestroy注解方式。

使用customInit()和 customDestroy()方法管理Bean生命周期的代码样例如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70][]

更多经典高频面试题

11  Spring Bean作用域的区别是什么

12  什么是Spring Inner Bean

13  Spring中的单例Bean是线程安全的吗

14  请举例说明如何在Spring中注入一个Java集合

15  如何向Spring Bean中注入java.util.Properties

16  请解释Spring Bean的自动装配

17  自动装配有哪些局限性

18  请解释各种自动装配模式的区别

19  请举例解释@Required注解

20  请举例说明@Qualifier注解

21  构造方法注入和设值注入有什么区别

22  Spring中有哪些不同类型的事件

23  FileSystemResource和ClassPathResource有什么区别

24  Spring中用到了哪些设计模式

25  在Spring中如何更有效地使用JDBC

26  请解释Spring中的IoC容器

27  在Spring中可以注入null或空字符串吗

# Java框架经典面试题之Spring（内附答案）  #

2018-09-10 17:30

Spring 框架是一个开源的Java平台，它为容易而快速的开发出耐用的Java应用程序提供了全面的基础设施。今天千锋小编着重给大家总结了一些关于Spring框架的经典面试题，希望能助大家的面试一臂之力。

1、Spring框架中有哪些不同类型的事件？

Spring 提供了以下5中标准的事件：

*  上下文更新事件（ContextRefreshedEvent）：该事件会在ApplicationContext被初始化或者更新时发布。也可以在调用ConfigurableApplicationContext 接口中的refresh()方法时被触发。
 *  上下文开始事件（ContextStartedEvent）：当容器调用ConfigurableApplicationContext的Start()方法开始/重新开始容器时触发该事件。
 *  上下文停止事件（ContextStoppedEvent）：当容器调用ConfigurableApplicationContext的Stop()方法停止容器时触发该事件。
 *  上下文关闭事件（ContextClosedEvent）：当ApplicationContext被关闭时触发该事件。容器被关闭时，其管理的所有单例Bean都被销毁。
 *  请求处理事件（RequestHandledEvent）：在Web应用中，当一个http请求（request）结束触发该事件。

2、Spring 框架中都用到了哪些设计模型？

Spring框架中使用到了大量的设计模式，下面列举了比较有代表性的：

*  代理模式—在AOP和remoting中被用的比较多。
 *  单例模式—在spring配置文件中定义的bean默认为单例模式。
 *  模板方法—用来解决代码重复的问题。
 *  前端控制器—Srping提供了DispatcherServlet来对请求进行分发。
 *  视图帮助(View Helper )—Spring提供了一系列的JSP标签，高效宏来辅助将分散的代码整合在视图里。
 *  依赖注入—贯穿于BeanFactory / ApplicationContext接口的核心理念。
 *  工厂模式—BeanFactory用来创建对象的实例。

3、使用Spring框架的好处是什么？

1.  轻量：Spring 是轻量的，基本的版本大约2MB。
2.  控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
3.  面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
4.  容器：Spring 包含并管理应用中对象的生命周期和配置。
5.  MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
6.  事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
7.  异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。

4、解释Spring支持的几种bean的作用域？

Spring框架支持以下五种bean的作用域：

1.  singleton : bean在每个Spring ioc 容器中只有一个实例。
2.  prototype：一个bean的定义可以有多个实例。
3.  request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
4.  session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
5.  global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。

5、在 Spring中如何注入一个java集合？

Spring提供以下几种集合的配置元素：

*  <list>类型用于注入一列值，允许有相同的值。
 *  <set> 类型用于注入一组值，不允许有相同的值。
 *  <map> 类型用于注入一组键值对，键和值都可以为任意类型。
 *  <props>类型用于注入一组键值对，键和值都只能为String类型。

6.聊一聊 Spring 中的线程安全性

ImportNew. 2018-10-23 12:00

来源：SylvanasSun ，

juejin.im/post/5a0045ef5188254de169968e

Spring与线程安全

Spring作为一个IOC/DI容器，帮助我们管理了许许多多的“bean”。但其实，Spring并没有保证这些对象的线程安全，需要由开发者自己编写解决线程安全问题的代码。

Spring对每个bean提供了一个scope属性来表示该bean的作用域。它是bean的生命周期。例如，一个scope为singleton的bean，在第一次被注入时，会创建为一个单例对象，该对象会一直被复用到应用结束。

我们交由Spring管理的大多数对象其实都是一些无状态的对象，这种不会因为多线程而导致状态被破坏的对象很适合Spring的默认scope，每个单例的无状态对象都是线程安全的（也可以说只要是无状态的对象，不管单例多例都是线程安全的，不过单例毕竟节省了不断创建对象与GC的开销）。

无状态的对象即是自身没有状态的对象，自然也就不会因为多个线程的交替调度而破坏自身状态导致线程安全问题。无状态对象包括我们经常使用的DO、DTO、VO这些只作为数据的实体模型的贫血对象，还有Service、DAO和Controller，这些对象并没有自己的状态，它们只是用来执行某些操作的。例如，每个DAO提供的函数都只是对数据库的CRUD，而且每个数据库Connection都作为函数的局部变量（局部变量是在用户栈中的，而且用户栈本身就是线程私有的内存区域，所以不存在线程安全问题），用完即关（或交还给连接池）。

有人可能会认为，我使用request作用域不就可以避免每个请求之间的安全问题了吗？这是完全错误的，因为Controller默认是单例的，一个controller对象是会被多个线程共享的，这就又回到了线程的安全问题。当然，你也可以把Controller的scope改成prototype，实际上Struts2就是这么做的，但有一点要注意，Spring MVC对请求的拦截粒度是基于每个方法的，而Struts2是基于每个类的，所以把Controller设为多例将会频繁的创建与回收对象，严重影响到了性能。

通过阅读上文其实已经说的很清楚了，Spring根本就没有对bean的多线程安全问题做出任何保证与措施。对于每个bean的线程安全问题，根本原因是每个bean自身的设计。不要在bean中声明任何有状态的实例变量或类变量，如果必须如此，那么就使用ThreadLocal把变量变为线程私有的，如果bean的实例变量或类变量需要在多个线程之间共享，那么就只能使用synchronized、lock、CAS等这些实现线程同步的方法了。

下面将通过解析ThreadLocal的源码来了解它的实现与作用，ThreadLocal是一个很好用的工具类，它在某些情况下解决了线程安全问题（在变量不需要被多个线程共享时）。

ThreadLocal

ThreadLocal是一个为线程提供线程局部变量的工具类。它的思想也十分简单，就是为线程提供一个线程私有的变量副本，这样多个线程都可以随意更改自己线程局部的变量，不会影响到其他线程。不过需要注意的是，ThreadLocal提供的只是一个浅拷贝，如果变量是一个引用类型，那么就要考虑它内部的状态是否会被改变，想要解决这个问题可以通过重写ThreadLocal的initialValue()函数来自己实现深拷贝，建议在使用ThreadLocal时一开始就重写该函数。

ThreadLocal与像synchronized这样的锁机制是不同的。首先，它们的应用场景与实现思路就不一样，锁更强调的是如何同步多个线程去正确地共享一个变量，ThreadLocal则是为了解决同一个变量如何不被多个线程共享。从性能开销的角度上来讲，如果锁机制是用时间换空间的话，那么ThreadLocal就是用空间换时间。

ThreadLocal中含有一个叫做ThreadLocalMap的内部类，该类为一个采用线性探测法实现的HashMap。它的key为ThreadLocal对象而且还使用了WeakReference，ThreadLocalMap正是用来存储变量副本的。

/\*\*

\* ThreadLocalMap is a customized hash map suitable only for

\* maintaining thread local values. No operations are exported

\* outside of the ThreadLocal class. The class is package private to

\* allow declaration of fields in class Thread. To help deal with

\* very large and long-lived usages, the hash table entries use

\* WeakReferences for keys. However, since reference queues are not

\* used, stale entries are guaranteed to be removed only when

\* the table starts running out of space.

\*/

static class ThreadLocalMap \{

/\*\*

\* The entries in this hash map extend WeakReference, using

\* its main ref field as the key (which is always a

\* ThreadLocal object). Note that null keys (i.e. entry.get()

\* == null) mean that the key is no longer referenced, so the

\* entry can be expunged from table. Such entries are referred to

\* as "stale entries" in the code that follows.

\*/

static class Entry extends WeakReference<ThreadLocal<?>> \{

/\*\* The value associated with this ThreadLocal. \*/

Object value;

Entry(ThreadLocal<?> k, Object v) \{

super(k);

value = v;

....

ThreadLocal中只含有三个成员变量，这三个变量都是与ThreadLocalMap的hash策略相关的。

/\*\*

\* ThreadLocals rely on per-thread linear-probe hash maps attached

\* to each thread (Thread.threadLocals and

\* inheritableThreadLocals). The ThreadLocal objects act as keys,

\* searched via threadLocalHashCode. This is a custom hash code

\* (useful only within ThreadLocalMaps) that eliminates collisions

\* in the common case where consecutively constructed ThreadLocals

\* are used by the same threads, while remaining well-behaved in

\* less common cases.

\*/

private final int threadLocalHashCode = nextHashCode();

/\*\*

\* The next hash code to be given out. Updated atomically. Starts at

\* zero.

\*/

private static AtomicInteger nextHashCode =

new AtomicInteger();

/\*\*

\* The difference between successively generated hash codes - turns

\* implicit sequential thread-local IDs into near-optimally spread

\* multiplicative hash values for power-of-two-sized tables.

\*/

private static final int HASH\_INCREMENT = 0x61c88647;

/\*\*

\* Returns the next hash code.

\*/

private static int nextHashCode() \{

return nextHashCode.getAndAdd(HASH\_INCREMENT);

唯一的实例变量threadLocalHashCode是用来进行寻址的hashcode，它由函数nextHashCode()生成，该函数简单地通过一个增量HASH\_INCREMENT来生成hashcode。至于为什么这个增量为0x61c88647，主要是因为ThreadLocalMap的初始大小为16，每次扩容都会为原来的2倍，这样它的容量永远为2的n次方，该增量选为0x61c88647也是为了尽可能均匀地分布，减少碰撞冲突。

/\*\*

\* The initial capacity -- MUST be a power of two.

\*/

private static final int INITIAL\_CAPACITY = 16;

/\*\*

\* Construct a new map initially containing (firstKey, firstValue).

\* ThreadLocalMaps are constructed lazily, so we only create

\* one when we have at least one entry to put in it.

\*/

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) \{

table = new Entry\[INITIAL\_CAPACITY\];

int i = firstKey.threadLocalHashCode & (INITIAL\_CAPACITY - 1);

table\[i\] = new Entry(firstKey, firstValue);

size = 1;

setThreshold(INITIAL\_CAPACITY);

要获得当前线程私有的变量副本需要调用get()函数。首先，它会调用getMap()函数去获得当前线程的ThreadLocalMap，这个函数需要接收当前线程的实例作为参数。如果得到的ThreadLocalMap为null，那么就去调用setInitialValue()函数来进行初始化，如果不为null，就通过map来获得变量副本并返回。

setInitialValue()函数会去先调用initialValue()函数来生成初始值，该函数默认返回null，我们可以通过重写这个函数来返回我们想要在ThreadLocal中维护的变量。之后，去调用getMap()函数获得ThreadLocalMap，如果该map已经存在，那么就用新获得value去覆盖旧值，否则就调用createMap()函数来创建新的map。

/\*\*

\* Returns the value in the current thread's copy of this

\* thread-local variable. If the variable has no value for the

\* current thread, it is first initialized to the value returned

\* by an invocation of the \{@link \#initialValue\} method.

\* @return the current thread's value of this thread-local

\*/

public T get() \{

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null) \{

ThreadLocalMap.Entry e = map.getEntry(this);

if (e != null) \{

@SuppressWarnings("unchecked")

T result = (T)e.value;

return result;

return setInitialValue();

/\*\*

\* Variant of set() to establish initialValue. Used instead

\* of set() in case user has overridden the set() method.

\* @return the initial value

\*/

private T setInitialValue() \{

T value = initialValue();

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null)

map.set(this, value);

else

createMap(t, value);

return value;

protected T initialValue() \{

return null;

ThreadLocal的set()与remove()函数要比get()的实现还要简单，都只是通过getMap()来获得ThreadLocalMap然后对其进行操作。

/\*\*

\* Sets the current thread's copy of this thread-local variable

\* to the specified value. Most subclasses will have no need to

\* override this method, relying solely on the \{@link \#initialValue\}

\* method to set the values of thread-locals.

\* @param value the value to be stored in the current thread's copy of

\* this thread-local.

\*/

public void set(T value) \{

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null)

map.set(this, value);

else

createMap(t, value);

/\*\*

\* Removes the current thread's value for this thread-local

\* variable. If this thread-local variable is subsequently

\* \{@linkplain \#get read\} by the current thread, its value will be

\* reinitialized by invoking its \{@link \#initialValue\} method,

\* unless its value is \{@linkplain \#set set\} by the current thread

\* in the interim. This may result in multiple invocations of the

\* \{@code initialValue\} method in the current thread.

\* @since 1.5

\*/

public void remove() \{

ThreadLocalMap m = getMap(Thread.currentThread());

if (m != null)

m.remove(this);

getMap()函数与createMap()函数的实现也十分简单，但是通过观察这两个函数可以发现一个秘密：ThreadLocalMap是存放在Thread中的。

/\*\*

\* Get the map associated with a ThreadLocal. Overridden in

\* InheritableThreadLocal.

\* @param t the current thread

\* @return the map

\*/

ThreadLocalMap getMap(Thread t) \{

return t.threadLocals;

/\*\*

\* Create the map associated with a ThreadLocal. Overridden in

\* InheritableThreadLocal.

\* @param t the current thread

\* @param firstValue value for the initial entry of the map

\*/

void createMap(Thread t, T firstValue) \{

t.threadLocals = new ThreadLocalMap(this, firstValue);

// Thread中的源码

/\* ThreadLocal values pertaining to this thread. This map is maintained

\* by the ThreadLocal class. \*/

ThreadLocal.ThreadLocalMap threadLocals = null;

/\*

\* InheritableThreadLocal values pertaining to this thread. This map is

\* maintained by the InheritableThreadLocal class.

\*/

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

仔细想想其实就能够理解这种设计的思想。有一种普遍的方法是通过一个全局的线程安全的Map来存储各个线程的变量副本，但是这种做法已经完全违背了ThreadLocal的本意，设计ThreadLocal的初衷就是为了避免多个线程去并发访问同一个对象，尽管它是线程安全的。而在每个Thread中存放与它关联的ThreadLocalMap是完全符合ThreadLocal的思想的，当想要对线程局部变量进行操作时，只需要把Thread作为key来获得Thread中的ThreadLocalMap即可。这种设计相比采用一个全局Map的方法会多占用很多内存空间，但也因此不需要额外的采取锁等线程同步方法而节省了时间上的消耗。

ThreadLocal中的内存泄漏

我们要考虑一种会发生内存泄漏的情况，如果ThreadLocal被设置为null后，而且没有任何强引用指向它，根据垃圾回收的可达性分析算法，ThreadLocal将会被回收。这样一来，ThreadLocalMap中就会含有key为null的Entry，而且ThreadLocalMap是在Thread中的，只要线程迟迟不结束，这些无法访问到的value会形成内存泄漏。为了解决这个问题，ThreadLocalMap中的getEntry()、set()和remove()函数都会清理key为null的Entry，以下面的getEntry()函数的源码为例。

/\*\*

\* Get the entry associated with key. This method

\* itself handles only the fast path: a direct hit of existing

\* key. It otherwise relays to getEntryAfterMiss. This is

\* designed to maximize performance for direct hits, in part

\* by making this method readily inlinable.

\* @param key the thread local object

\* @return the entry associated with key, or null if no such

\*/

private Entry getEntry(ThreadLocal<?> key) \{

int i = key.threadLocalHashCode & (table.length - 1);

Entry e = table\[i\];

if (e != null && e.get() == key)

return e;

else

return getEntryAfterMiss(key, i, e);

/\*\*

\* Version of getEntry method for use when key is not found in

\* its direct hash slot.

\* @param key the thread local object

\* @param i the table index for key's hash code

\* @param e the entry at table\[i\]

\* @return the entry associated with key, or null if no such

\*/

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) \{

Entry\[\] tab = table;

int len = tab.length;

// 清理key为null的Entry

while (e != null) \{

ThreadLocal<?> k = e.get();

if (k == key)

return e;

if (k == null)

expungeStaleEntry(i);

else

i = nextIndex(i, len);

e = tab\[i\];

return null;

在上文中我们发现了ThreadLocalMap的key是一个弱引用，那么为什么使用弱引用呢？使用强引用key与弱引用key的差别如下：

但要注意的是，ThreadLocalMap仅仅含有这些被动措施来补救内存泄漏问题。如果你在之后没有调用ThreadLocalMap的set()、getEntry()和remove()函数的话，那么仍然会存在内存泄漏问题。

在使用线程池的情况下，如果不及时进行清理，内存泄漏问题事小，甚至还会产生程序逻辑上的问题。所以，为了安全地使用ThreadLocal，必须要像每次使用完锁就解锁一样，在每次使用完ThreadLocal后都要调用remove()来清理无用的Entry

# spring和springMVC的面试问题总结 #

2017年08月30日 10:44:25 [一页知秋否][Link 2] 阅读数 112249更多

分类专栏： [springmvc][] [spring][]

本文链接： [https://blog.csdn.net/qq\_39470733/article/details/77709607][https_blog.csdn.net_qq_39470733_article_details_77709607]

1.Spring中AOP的应用场景、Aop原理、好处？

答：AOP--Aspect Oriented Programming面向切面编程；用来封装横切关注点，具体可以在下面的场景中使用:

Authentication 权限、Caching 缓存、Context passing 内容传递、Error handling 错误处理Lazy loading懒加载、Debugging调试、logging, tracing, profiling and monitoring 记录跟踪优化　校准、Performance optimization　性能优化、Persistence 持久化、Resource pooling　资源池、Synchronization　同步、Transactions 事务

原理：AOP是面向切面编程，是通过动态代理的方式为程序添加统一功能，集中解决一些公共问题。

优点：1.各个步骤之间的良好隔离性耦合性大大降低   
           2.源代码无关性，再扩展功能的同时不对源码进行修改操作

2.Spring中IOC的作用与原理？对象创建的过程。

答：IOC--Inversion of Control控制反转。当某个角色需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例对象。但在spring中创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者 直接使用。

3.介绍spring框架

它是一个一站式（full-stack全栈式）框架，提供了从表现层-springMVC到业务层-spring再到持久层-springdata的一套完整的解决方案。我们在项目中可以只使用spring一个框架，它就可以提供表现层的mvc框架，持久层的Dao框架。它的两大核心IoC和AOP更是为我们程序解耦和代码简洁易维护提供了支持。

4.Spring常见创建对象的注解？

答：@Component@Controller@ Service@ Repository

5.Spring中用到的设计模式

答：简单工厂、工厂方法、单例模式、适配器、包装器、代理、观察者、策略、模板方法

详细介绍:请参考本微博的：开发常用设计模式

6.Spring的优点？

答：1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦   
2.可以使用容易提供的众多服务，如事务管理，消息服务等   
3.容器提供单例模式支持   
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能   
5.容器提供了众多的辅助类，能加快应用的开发   
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等   
7.spring属于低侵入式设计，代码的污染极低   
8.独立于各种应用服务器   
9.spring的DI机制降低了业务对象替换的复杂性   
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring 的部分或全部

7.Spring Bean的作用域之间有什么区别？

Spring容器中的bean可以分为5个范围。所有范围的名称都是自说明的，但是为了避免混淆，还是让我们来解释一下：

singleton：这种bean范围是默认的，这种范围确保不管接受到多少个请求，每个容器中只有一个bean的实例，单例的模式由bean factory自身来维护。

prototype：原形范围与单例范围相反，为每一个bean请求提供一个实例。

request：在请求bean范围内会每一个来自客户端的网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。

Session：与请求范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。

global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。

全局作用域与Servlet中的session作用域效果相同。

8.Spring管理事务有几种方式？

答：有两种方式：

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

2、声明式事务，在配置文件中配置（推荐使用）

声明式事务又分为两种：

a、基于XML的声明式事务

b、基于注解的声明式事务

9.spring中自动装配的方式有哪些？

答：1、 No：即不启用自动装配。

2、 byName：通过属性的名字的方式查找JavaBean依赖的对象并为其注入。比如说类Computer有个属性printer，指定其autowire属性为byName后，Spring IoC容器会在配置文件中查找id/name属性为printer的bean，然后使用Seter方法为其注入。

3、 byType：通过属性的类型查找JavaBean依赖的对象并为其注入。比如类Computer有个属性printer，类型为Printer，那么，指定其autowire属性为byType后，Spring IoC容器会查找Class属性为Printer的bean，使用Seter方法为其注入。

4、 constructor：通byType一样，也是通过类型查找依赖对象。与byType的区别在于它不是使用Seter方法注入，而是使用构造子注入。

5、 autodetect：在byType和constructor之间自动的选择注入方式。

6、 default：由上级标签<beans>的default-autowire属性确定。

10.spring中的核心类有那些，各有什么作用？

答：BeanFactory：产生一个新的实例，可以实现单例模式

BeanWrapper：提供统一的get及set方法

ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

11.Bean的调用方式有哪些？

答：有三种方式可以得到Bean并进行调用：  
1、使用BeanWrapper  
HelloWorld hw=new HelloWorld();  
BeanWrapper bw=new BeanWrapperImpl(hw);  
bw.setPropertyvalue(”msg”,”HelloWorld”);  
system.out.println(bw.getPropertyCalue(”msg”));  
2、使用BeanFactory  
InputStream is=new FileInputStream(”config.xml”);  
XmlBeanFactory factory=new XmlBeanFactory(is);  
HelloWorld hw=(HelloWorld) factory.getBean(”HelloWorld”);  
system.out.println(hw.getMsg());  
3、使用ApplicationConttext  
ApplicationContext actx=new FleSystemXmlApplicationContext(”config.xml”);  
HelloWorld hw=(HelloWorld) actx.getBean(”HelloWorld”);  
System.out.println(hw.getMsg());

12.什么是IOC，什么又是DI，他们有什么区别？

答：依赖注入DI是一个程序设计模式和架构模型， 一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个 数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外 部以减少依赖

应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所 以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

13.spring有两种代理方式：

答: 若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。

优点：因为有接口，所以使系统更加松耦合

缺点：为每一个目标类创建接口

若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。

缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好。

14.springMVC的流程？

答：1.用户发送请求至前端控制器DispatcherServlet

2.DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3.处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4.DispatcherServlet通过HandlerAdapter处理器适配器调用处理器

5.执行处理器(Controller，也叫后端控制器)。

6.Controller执行完成返回ModelAndView

7.HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

8.DispatcherServlet将ModelAndView传给ViewReslover视图解析器

9.ViewReslover解析后返回具体View

10.DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。

11.DispatcherServlet响应用户

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70][]

15.Springmvc的优点

答：1.它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是 java组件.并且和Spring提供的其他基础结构紧密集成.

2.不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的)

3. 可以任意使用各种视图技术,而不仅仅局限于JSP

4 . 支持各种请求资源的映射策略

5 .它应是易于扩展的

转载于:https://www.cnblogs.com/think90/p/11436813.html

[Link 1]: https://me.csdn.net/broadview2006
[CC 4.0 BY-SA]: http://creativecommons.org/licenses/by-sa/4.0/
[https_blog.csdn.net_broadview2006_article_details_100037214]: https://blog.csdn.net/broadview2006/article/details/100037214
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jyb2FkdmlldzIwMDY_size_16_color_FFFFFF_t_70]: /images/20230601/48ab3ff9c890436eb3b4f3a3c4188b49.png
[Link 2]: https://me.csdn.net/qq_39470733
[springmvc]: https://blog.csdn.net/qq_39470733/article/category/7096184
[spring]: https://blog.csdn.net/qq_39470733/article/category/7096188
[https_blog.csdn.net_qq_39470733_article_details_77709607]: https://blog.csdn.net/qq_39470733/article/details/77709607
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70]: /images/20230601/2b1bbf49a90f4432a8bf2dd1fdf3bc0f.png