春季面试问题与回答

教程

Spring

I have posted a lot of Spring Tutorials recently. This post will help you get through Spring interview Questions explaining the core concepts in detail.

Spring Framework 是最流行的 Java EE 框架之一，用于 Web 应用程序。依赖注入和面向切面编程是 Spring 框架的核心。如果你擅长 Spring Framework，在 Java 面试中被选中的机会会大大提高。

专业提示: 核心 Java 是任何基于 Java 的框架的基础，所以如果你正在准备面试，那么请阅读核心 Java 面试题和 Java 面试题文章。

Spring 面试题及答案

在这里，我提供了近 50 个 Spring 面试题及其答案。它已更新到 Spring 5，因此涵盖了所有最新功能，比如用于响应式编程的 Spring WebFlux。

1. 什么是Spring框架？

Spring是最广泛使用的Java EE框架之一。Spring框架的核心概念是“依赖注入”和“面向切面编程”。

Spring框架也可以用于普通的Java应用程序，通过实现依赖注入来实现不同组件之间的松耦合。我们可以使用Spring对面向切面编程的支持来执行诸如日志记录和身份验证等横切任务。

I like spring because it provides a lot of features and different modules for specific tasks such as Spring MVC and Spring JDBC. Since it’s an open-source framework with a lot of online resources and active community members, working with the Spring framework is easy and fun at the same time.

推荐阅读：Spring框架

2. Spring框架的一些重要特性是什么？

Spring框架建立在两个设计概念之上——依赖注入和面向切面编程。

Spring框架的一些特性包括：

轻量级，使用框架开发时几乎没有额外开销。
依赖注入或控制反转，可以编写彼此独立的组件，Spring容器负责将它们连接起来以实现我们的工作。
春季IoC容器管理Spring Bean的生命周期和项目特定的配置，例如JNDI查找。
Spring MVC框架可用于创建Web应用程序，以及能够返回XML和JSON响应的RESTful Web服务。
通过很少的配置，可以支持事务管理、JDBC操作、文件上传、异常处理等，可以使用注解或Spring Bean配置文件实现。

3.使用Spring框架的优势是什么？

使用Spring框架的一些优势包括：

减少应用程序不同组件之间的直接依赖关系。Spring IoC容器负责初始化资源或Bean并将它们注入为依赖项。
在Spring框架中编写单元测试用例很容易，因为我们的业务逻辑与实际资源实现类没有直接依赖关系。我们可以轻松编写测试配置并为测试目的注入我们的模拟Bean。
减少样板代码的数量，例如初始化对象、打开/关闭资源。我很喜欢JdbcTemplate类，因为它帮助我们消除与JDBC编程相关的所有样板代码。
Spring框架被划分为多个模块，有助于保持我们的应用程序轻量化。例如，如果我们不需要Spring事务管理功能，就不需要将其依赖添加到我们的项目中。
Spring框架支持大多数Java EE功能，甚至更多。它始终处于新技术的前沿，例如，有一个针对Android的Spring项目，帮助我们更好地编写本机Android应用程序的代码。这使得Spring框架成为一个完整的包，我们无需为不同的需求寻找不同的框架。

4. Spring 5的重要特性是什么？

Spring 5是对Spring 4的重大改进。一些重要的特性包括：

对Java 8及更高版本的支持，因此我们可以使用lambda表达式。
对Java EE7和Servlet 4.0规范的支持。
现在通过NIO 2流执行文件操作，如果您的应用程序涉及大量文件处理，这是一个巨大的改进。
引入spring-jcl来简化日志记录，之前由于没有单一的日志记录点而显得混乱。
对Kotlin、Lombok、Reactor 3.1 Flux以及 Mono以及RxJava的支持。
引入了将响应式编程带入Spring的Spring WebFlux。
支持JUnit 5。
支持通过索引文件“META-INF/spring.components”提供Spring组件信息，而不是类路径扫描。

请查看Spring 5功能以获取此版本的详细概述。

5. 什么是Spring WebFlux？

Spring WebFlux是Spring 5中引入的新模块。Spring WebFlux是迈向Spring框架响应式编程模型的第一步。

Spring WebFlux是Spring MVC模块的替代品。Spring WebFlux用于创建基于事件循环执行模型的完全异步和非阻塞的应用程序。

您可以在Spring WebFlux教程中了解更多信息。

6. 什么是依赖注入？

依赖注入设计模式允许我们消除硬编码的依赖关系，使我们的应用程序松散耦合、可扩展和可维护。我们可以实现依赖注入模式，将依赖关系解析从编译时移到运行时。

使用依赖注入的一些好处包括关注点分离、减少样板代码、可配置组件以及简单的单元测试。

在依赖注入教程中了解更多信息。我们还可以使用Google Guice进行依赖注入来自动化依赖注入的过程。但在大多数情况下，我们不仅仅是在寻找依赖注入，这就是Spring站在顶端的地方。

7. 如何在Spring框架中实现DI？

我们可以使用基于Spring XML的配置，也可以使用基于注解的配置来实现Spring应用程序中的DI。为了更好地理解，请阅读Spring依赖注入示例，在其中您可以学习两种方式，并附有JUnit测试用例。该文章还包含一个示例项目的zip文件，您可以下载并进行操作以获取更多信息。

8. 使用Spring Tool Suite的好处是什么？

我们可以将插件安装到Eclipse中，以获取Spring Tool Suite的所有功能。然而，STS与Eclipse捆绑，并附带一些其他重要的内容，如Maven支持、用于创建不同类型的Spring项目的模板，以及用于在Spring应用程序中获得更好性能的tc server。

I like STS because it highlights the Spring components and if you are using AOP pointcuts and advice, then it clearly shows which methods will come under the specific pointcut. So rather than installing everything on our own, I prefer using STS when developing Spring-based applications.

9. 列举一些重要的Spring模块？

一些重要的Spring框架模块包括：

Spring Context – 用于依赖注入。
Spring AOP – 用于面向切面的编程。
Spring DAO – 使用DAO模式进行数据库操作。
Spring JDBC – 提供JDBC和DataSource支持。
Spring ORM – 提供ORM工具支持，如Hibernate。
Spring Web Module – 用于创建Web应用程序。
Spring MVC – 用于创建Web应用程序、Web服务等的Model-View-Controller实现。

10. 什么是面向方面编程（AOP）？

企业应用程序具有一些通用的横切关注点，适用于不同类型的对象和应用程序模块，例如日志记录、事务管理、数据验证、身份验证等。通过面向对象编程中的类来实现应用程序的模块化。在AOP中，应用程序的模块化是通过切面来实现的，并且它们被配置为横跨不同的类方法。

AOP从不可能在普通面向对象编程中实现的类中剥离了横切任务的直接依赖关系。例如，我们可以为日志记录单独创建一个类，但其他类将不得不调用这些方法。但是，在AOP中，我们配置了方面，方法执行会自动发生。了解更多关于Spring AOP支持的信息，请查阅Spring AOP示例。

11. 什么是Aspect、Advice、Pointcut、JointPoint和Advice Arguments在AOP中的含义？

**方面**：方面是一个实现横切关注点（cross-cutting concerns）的类，例如事务管理。方面可以是一个普通类，在Spring Bean配置文件中配置，然后进行配置，或者我们可以使用Spring AspectJ支持，通过`@Aspect`注解声明一个类作为Aspect。

**建议**：建议是针对特定连接点（join point）采取的行动。在编程方面，它们是在应用程序中达到具有匹配切入点（join point）的特定连接点时执行的方法。您可以将建议视为Spring拦截器或Servlet过滤器。

**切入点**：切入点是与连接点匹配的正则表达式，用于确定是否需要执行建议。切入点使用不同类型的表达式与连接点匹配。Spring框架使用AspectJ切入点表达式语言来确定将应用建议方法的连接点。

**连接点**：连接点是应用程序中的特定点，例如方法执行、异常处理、更改对象变量值等。在Spring AOP中，连接点始终是方法的执行。

建议参数: 我们可以在建议方法中传递参数。我们可以在切入点中使用args()表达式，以应用于与参数模式匹配的任何方法。如果我们使用这个，那么我们需要在建议方法中使用相同的名称，从而确定参数类型。

这些概念起初可能令人困惑，但如果您查看Spring Aspect，Advice Example，然后您可以很容易地与它们联系。

12. Spring AOP和AspectJ AOP之间有什么区别？

AspectJ是面向切面编程的行业标准实现，而Spring为某些情况实现了AOP。Spring AOP和AspectJ之间的主要区别有：

Spring AOP比AspectJ更简单使用，因为我们不需要担心织入过程。
Spring AOP支持AspectJ注解，因此如果您熟悉AspectJ，那么使用Spring AOP会更容易。
Spring AOP仅支持基于代理的AOP，因此它只能应用于方法执行连接点。AspectJ支持各种类型的切入点。
Spring AOP的缺点之一是它只能应用于通过Spring上下文创建的bean。

13. 什么是Spring IoC容器？

控制反转（IoC）是实现对象依赖之间松耦合的机制。为了在运行时实现对象的松耦合和动态绑定，对象定义它们的依赖关系，这些依赖关系由其他装配器对象注入。Spring IoC容器是一个程序，它将依赖关系注入对象并使其准备好供我们使用。

Spring框架IoC容器类属于org.springframework.beans和org.springframework.context包，为我们提供了不同的方式来解耦对象之间的依赖关系。

一些有用的ApplicationContext实现包括：

AnnotationConfigApplicationContext：用于使用基于注解的配置的独立Java应用程序。
ClassPathXmlApplicationContext：用于使用基于XML的配置的独立Java应用程序。
FileSystemXmlApplicationContext：与ClassPathXmlApplicationContext类似，只是可以从文件系统的任何位置加载XML配置文件。
AnnotationConfigWebApplicationContext和XmlWebApplicationContext用于Web应用程序。

14. 什么是Spring Bean？

任何由Spring IoC容器初始化的普通Java类都被称为Spring Bean。我们使用Spring ApplicationContext 来获取Spring Bean实例。

Spring IoC容器管理Spring Bean的生命周期、Bean范围，并注入Bean中所需的任何依赖项。

15. Spring Bean配置文件的重要性是什么？

我们使用Spring Bean配置文件来定义所有将由Spring上下文初始化的Bean。当我们创建Spring ApplicationContext的实例时，它读取spring bean XML文件并初始化所有Bean。一旦上下文被初始化，我们可以使用它来获取不同的Bean实例。

除了Spring Bean配置，该文件还包含Spring MVC拦截器、视图解析器和其他元素，以支持基于注解的配置。

16. 如何配置Spring Bean的不同方法？

配置Spring Bean有三种不同的方法。

XML配置：这是最常见的配置方式，我们可以在上下文文件中使用bean元素来配置Spring Bean。例如：

<bean name="myBean" class="com.journaldev.spring.beans.MyBean"></bean>

基于Java的配置：如果只使用注解，可以使用@Bean注解来配置Spring bean。该注解与@Configuration类一起使用，以配置Spring bean。示例配置如下：

@Configuration
@ComponentScan(value="com.journaldev.spring.main")
public class MyConfiguration {

	@Bean
	public MyService getService(){
		return new MyService();
	}
}

要从Spring上下文中获取此bean，我们需要使用以下代码片段：

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
		MyConfiguration.class);
MyService service = ctx.getBean(MyService.class);

基于注解的配置：我们还可以使用@Component、@Service、@Repository和@Controller注解与类一起配置它们作为Spring bean。对于这些注解，我们需要提供要扫描这些类的基本包位置。例如：

<context:component-scan base-package="com.journaldev.spring" />

17. Spring Bean有哪些不同的作用域？

Spring Bean定义了五种作用域。

singleton：每个容器只会创建一个bean实例。这是Spring Bean的默认作用域。在使用这个作用域时，请确保Spring Bean没有共享实例变量，否则可能会导致数据不一致的问题，因为它不是线程安全的。
prototype：每次请求bean时都会创建一个新的实例。
request：这与原型作用域相同，但是它适用于Web应用程序。每个HTTP请求都会为bean创建一个新实例。
session：容器会为每个HTTP会话创建一个新的bean。
global-session：用于为Portlet应用程序创建全局会话bean。

Spring框架是可扩展的，我们也可以创建自己的作用域。但是大多数情况下，我们使用框架提供的作用域就足够了。要设置Spring Bean的作用域，我们可以在bean元素中使用“scope”属性或者在基于注解的配置中使用@Scope注解。

18. 什么是Spring Bean的生命周期？

Spring Beans由Spring容器初始化，并注入所有依赖项。当上下文被销毁时，它也销毁所有初始化的bean。在大多数情况下，这是有效的，但有时我们想在使bean准备好使用之前初始化其他资源或进行一些验证。Spring框架支持在spring bean中提供后初始化和预销毁方法。

我们可以通过两种方式实现这一点 – 通过实现InitializingBean和DisposableBean接口，或者使用spring bean配置中的init-method和destroy-method属性。有关更多详细信息，请阅读Spring Bean生命周期方法。

19. 如何在Spring Bean中获取ServletContext和ServletConfig对象？

有两种方法可以在spring bean中获取容器特定的对象。

实现Spring *Aware接口，对于这些ServletContextAware和ServletConfigAware接口，关于这些aware接口的完整示例，请阅读Spring Aware接口。
使用@Autowired注解与类型为ServletContext和ServletConfig的bean变量。它们只能在特定于Servlet容器的环境中工作。

@Autowired
ServletContext servletContext;

20. 什么是Bean自动装配和 @Autowired注解？

在初始化时注入Spring Bean依赖关系的过程称为Spring Bean自动装配。

通常，最佳实践是显式地装配所有bean的依赖关系，但Spring框架也支持自动装配。我们可以使用@Autowired注解与字段或方法进行按类型自动装配。为了使此注解起作用，我们还需要在Spring bean配置文件中启用基于注解的配置。这可以通过context:annotation-config元素来实现。

有关@Autowired注解的更多详细信息，请阅读Spring自动装配示例。

21. 不同类型的Spring Bean自动装配有哪些？

在Spring框架中有四种自动装配的类型。

按名称自动装配
按类型自动装配
按构造函数自动装配
使用 @Autowired 和 @Qualifier 注解进行自动装配

在Spring 3.1之前，还支持 按自动检测自动装配，类似于按构造函数或按类型自动装配。有关这些选项的更多详细信息，请阅读 Spring Bean自动装配。

22. Spring Bean是否提供线程安全性？

Spring bean的默认作用域是singleton，因此每个上下文只会有一个实例。这意味着所有具有任何线程都可以更新的类级变量将导致不一致的数据。因此，在默认模式下，Spring beans不是线程安全的。

然而，我们可以更改spring bean的作用域为请求、原型或会话，以实现线程安全，但代价是性能。这是一个设计决策，基于项目需求。

23. Spring MVC中的控制器是什么？

就像MVC设计模式一样，控制器是负责处理所有客户端请求并将它们发送到配置的资源以处理它们的类。在Spring MVC中，DispatcherServlet是初始化上下文的前端控制器类，根据spring beans的配置。

A Controller class is responsible to handle a different kind of client requests based on the request mappings. We can create a controller class by using @Controller annotation. Usually, it’s used with @RequestMapping annotation to define handler methods for specific URI mapping.

24. 在Spring中，@Component、@Controller、@Repository和@Service注解有什么区别？

@Component 用于表示一个类是一个组件。这些类用于自动检测，并在使用基于注解的配置时配置为Bean。

@Controller 是一种特定类型的组件，在MVC应用程序中使用，通常与RequestMapping注解一起使用。

@Repository 注解用于指示一个组件被用作存储/检索/搜索数据的仓库，并且可以将此注解应用于DAO模式实现类。

@Service 用于表示一个类是一个服务。通常，提供某些服务的业务外观类被标注为这个注解。

我们可以对一个类使用上述任何注解进行自动检测，但提供了不同类型以便于您轻松区分注解类的目的。

25. DispatcherServlet和ContextLoaderListener是什么？

DispatcherServlet是Spring MVC应用程序中的前端控制器，它加载Spring bean配置文件并初始化所有已配置的bean。如果启用了注释，它还会扫描包并配置任何使用@Component、@Controller、@Repository或@Service注释的bean。

ContextLoaderListener是启动和关闭Spring根WebApplicationContext的监听器。其重要功能是将ApplicationContext的生命周期与ServletContext的生命周期绑定，并自动创建ApplicationContext。我们可以使用它来定义可以在不同Spring上下文中共享的bean。

26. Spring中的ViewResolver是什么？

ViewResolver实现用于按名称解析视图页面。我们在Spring bean配置文件中配置它。例如：

<!-- 将由@Controllers选择用于渲染的视图解析为/WEB-INF/views目录中的.jsp资源 -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<beans:property name="prefix" value="/WEB-INF/views/" />
	<beans:property name="suffix" value=".jsp" />
</beans:bean>

InternalResourceViewResolver是ViewResolver接口的实现之一，我们通过bean属性提供视图页面目录和后缀位置。因此，如果控制器处理程序方法返回“home”，视图解析器将使用位于/WEB-INF/views/home.jsp的视图页面。

27. 什么是MultipartResolver及其使用场景？

MultipartResolver接口用于上传文件 – CommonsMultipartResolver和StandardServletMultipartResolver是Spring框架提供的两个文件上传的实现。默认情况下，没有配置multipart解析器，但是要使用它们上传文件，我们只需在Spring Bean配置中定义一个名为“multipartResolver”的类型为MultipartResolver的bean。

配置完成后，任何多部分请求都将由配置的MultipartResolver解析，并传递给包装后的HttpServletRequest。然后在控制器类中使用它来获取文件并处理它。有关完整示例，请阅读Spring MVC文件上传示例。

28. 如何在Spring MVC框架中处理异常？

Spring MVC框架提供以下方法帮助我们实现健壮的异常处理。

基于控制器 – 我们可以在控制器类中定义异常处理方法。我们只需使用@ExceptionHandler注解标注这些方法。

全局异常处理器 – 异常处理是一个横切关注点，Spring提供了@ControllerAdvice注解，我们可以与任何类一起使用以定义全局异常处理器。

HandlerExceptionResolver实现 – 对于通用异常，大多数时候我们提供静态页面。Spring框架提供了HandlerExceptionResolver接口，我们可以实现它来创建全局异常处理器。之所以有这种额外定义全局异常处理器的方式，是因为Spring框架还提供了默认实现类，我们可以在spring bean配置文件中定义以获得Spring框架异常处理的好处。

为了一个完整的示例，请阅读Spring异常处理示例。

29. 如何在Java程序中创建ApplicationContext？

有以下几种方法可以在独立的Java程序中创建Spring上下文。

AnnotationConfigApplicationContext：如果我们在独立的Java应用程序中使用Spring，并使用注解进行配置，则可以使用此方法来初始化容器并获取bean对象。
ClassPathXmlApplicationContext：如果我们在独立应用程序中有一个Spring bean配置XML文件，则可以使用此类来加载文件并获取容器对象。
FileSystemXmlApplicationContext：这与ClassPathXmlApplicationContext类似，只是XML配置文件可以从文件系统的任何位置加载。

30. 我们可以拥有多个Spring配置文件吗？

对于Spring MVC应用程序，我们可以通过contextConfigLocation定义多个spring上下文配置文件。该位置字符串可以由多个位置组成，用任意数量的逗号和空格分隔。例如;

<servlet>
	<servlet-name>appServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
            <param-name>contextConfigLocation</param-name>
	    <param-value>/WEB-INF/spring/appServlet/servlet-context.xml,/WEB-INF/spring/appServlet/servlet-jdbc.xml</param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
</servlet>

我们还可以通过context-param定义多个根级别的spring配置并加载它。例如;

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/root-security.xml</param-value>
</context-param>

另一种选择是在上下文配置文件中使用import元素导入其他配置，例如：

<beans:import resource="spring-jdbc.xml"/>

31. 什么是ContextLoaderListener？

ContextLoaderListener是用于加载根上下文并定义将对所有其他上下文可见的spring bean配置的监听器类。它在web.xml文件中配置如下：

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
	
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

32. 创建Spring MVC应用程序所需的最低配置是什么？

要创建一个简单的Spring MVC应用程序，我们需要执行以下任务。

在项目中添加spring-context和spring-webmvc依赖。
配置 DispatcherServlet 在 web.xml 文件中，以通过 Spring 容器处理请求。
Spring Bean 配置文件用于定义 Beans，如果使用注解，则需要在此处进行配置。此外，我们需要为视图页面配置视图解析器。
控制器类中定义了用于处理客户端请求的请求映射。

上述步骤足以创建一个简单的 Spring MVC Hello World 应用程序。

33. 如何将 Spring MVC 框架与 MVC 架构关联起来？

正如其名称所示，Spring MVC 建立在 Model-View-Controller 架构之上。DispatcherServlet 是 Spring MVC 应用程序中的前端控制器，负责处理所有传入的请求并将它们委托给不同的控制器处理方法。

在 Spring 框架中，模型可以是任何 Java Bean，就像其他任何 MVC 框架一样，Spring 提供了将表单数据自动绑定到 Java Beans 的功能。我们可以将模型 Beans 设置为在视图页面中使用的属性。

视图页面可以是 JSP、静态 HTML 等，视图解析器负责查找正确的视图页面。一旦识别出视图页面，控制权就会返回给 DispatcherServlet 控制器。DispatcherServlet 负责渲染视图并将最终响应返回给客户端。

34. 如何在Spring MVC应用程序中实现本地化？

Spring通过资源包（resource bundles）为本地化（i18n）提供了出色的支持。使我们的应用程序本地化所需的基本步骤如下：

为不同的区域创建消息资源包，例如messages_en.properties，messages_fr.properties等。
在Spring bean配置文件中定义messageSource bean，类型为ResourceBundleMessageSource或ReloadableResourceBundleMessageSource。
为了支持区域更改，定义localeResolver bean，类型为CookieLocaleResolver，并配置LocaleChangeInterceptor拦截器。示例配置如下：

<beans:bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<beans:property name="basename" value="classpath:messages" />
<beans:property name="defaultEncoding" value="UTF-8" />
</beans:bean>
 
<beans:bean id="localeResolver"
    class="org.springframework.web.servlet.i18n.CookieLocaleResolver">
    <beans:property name="defaultLocale" value="en" />
    <beans:property name="cookieName" value="myAppLocaleCookie"></beans:property>
    <beans:property name="cookieMaxAge" value="3600"></beans:property>
</beans:bean>
 
<interceptors>
    <beans:bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
        <beans:property name="paramName" value="locale" />
    </beans:bean>
</interceptors>

在视图页面中使用spring:message元素，使用关键字，DispatcherServlet选择相应的值，并以相应的区域呈现页面并作为响应返回。

有关完整示例，请阅读Spring本地化示例。

35. 我们如何使用Spring创建返回JSON响应的Restful Web服务？

我们可以使用Spring框架创建返回JSON数据的Restful web服务。Spring提供了与Jackson JSON API的集成，我们可以用它在restful web服务中发送JSON响应。

我们需要执行以下步骤，配置我们的Spring MVC应用程序以发送JSON响应。

1. 添加Jackson JSON依赖项，如果您使用的是Maven，可以使用以下代码完成：

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.databind-version}</version>
</dependency>

2. 在spring bean配置文件中配置RequestMappingHandlerAdapter bean，并将消息转换器属性设置为MappingJackson2HttpMessageConverter bean。示例配置将是：

<!-- 配置插件以在方法处理器中作为请求和响应使用JSON -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <beans:property name="messageConverters">
        <beans:list>
            <beans:ref bean="jsonMessageConverter"/>
        </beans:list>
    </beans:property>
</beans:bean>
     
<!-- 配置bean以将JSON转换为POJO，反之亦然 -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>

3. 在控制器处理方法中，使用@ResponseBody注解返回对象作为响应。示例代码：

@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
    logger.info("Start getEmployee. ID="+empId);
     
    return empData.get(empId);
}

4. 您可以通过任何API调用rest服务，但如果您想使用Spring，则可以使用RestTemplate类轻松完成。

为了一个完整的示例，请阅读Spring Restful Webservice Example。

36. 你使用过哪些重要的Spring注解？

我在我的项目中使用过一些Spring注解：

@Controller – 用于Spring MVC项目中的控制器类。
@RequestMapping – 用于配置控制器处理程序方法中的URI映射。这是一个非常重要的注解，所以你应该阅读Spring MVC RequestMapping Annotation Examples
@ResponseBody – 用于将对象作为响应发送，通常用于将XML或JSON数据作为响应发送。
@PathVariable – 用于将URI中的动态值映射到处理程序方法参数中。
@Autowired – 用于在Spring Bean中自动注入依赖关系。
@Qualifier – 与@Autowired注解一起使用，以避免存在多个Bean类型时的混淆。
@Service – 用于服务类。
@Scope – 用于配置Spring Bean的作用域。
@Configuration，@ComponentScan和@Bean – 用于基于Java的配置。
用于配置切面和通知的AspectJ注解，@Aspect，@Before，@After，@Around，@Pointcut等。

37. 我们能否将对象作为控制器处理方法的响应发送？

是的，我们可以通过使用@ResponseBody注解来实现。这是在RESTful Web服务中发送基于JSON或XML的响应的方法。

38. 如何在Spring MVC应用程序中上传文件？

Spring提供了内置支持，通过MultipartResolver接口实现来上传文件。这非常容易使用，只需要进行配置更改即可使其运作。我们需要编写控制器处理方法来处理传入的文件并对其进行处理。有关完整的示例，请参考Spring文件上传示例。

39. 如何在Spring Web MVC框架中验证表单数据？

Spring支持基于JSR-303注解的验证，并提供了一个Validator接口，我们可以实现它来创建自定义的验证器。要使用基于JSR-303的验证，我们需要使用所需的验证来注解bean变量。

对于自定义验证器的实现，我们需要在控制器类中进行配置。有关完整示例，请阅读Spring MVC表单验证示例。

40. 什么是Spring MVC拦截器，如何使用？

Spring MVC拦截器类似于Servlet过滤器，允许我们拦截客户端请求并处理它们。我们可以在三个位置拦截客户端请求 – preHandle，postHandle和afterCompletion。

我们可以通过实现HandlerInterceptor接口或扩展抽象类HandlerInterceptorAdapter来创建Spring拦截器。

我们需要在Spring bean配置文件中配置拦截器。我们可以定义一个拦截器来拦截所有客户端请求，也可以为特定的URI映射进行配置。有关详细示例，请参阅Spring MVC拦截器示例。

41. 什么是Spring的JdbcTemplate类，如何使用它？

Spring框架与JDBC API的集成非常出色，并提供了JdbcTemplate实用类，我们可以使用它来避免在数据库操作逻辑中重复编写代码，比如打开/关闭连接、ResultSet、PreparedStatement等。

有关JdbcTemplate的示例，请参阅Spring JDBC示例。

42. 如何在Spring Web应用程序中使用Tomcat JNDI数据源？

要使用servlet容器配置的JNDI DataSource，我们需要在spring bean配置文件中进行配置，然后将其注入到spring beans作为依赖项。然后我们可以使用JdbcTemplate来执行数据库操作。

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
</beans:bean>

有关完整示例，请参阅Spring Tomcat JNDI Example。

43. 如何在Spring中实现事务管理？

Spring框架通过声明式事务管理和编程式事务管理提供事务管理支持。声明式事务管理是最广泛使用的，因为它易于使用并且在大多数情况下都有效。

我们使用@Transactional注解来注解方法以进行声明式事务管理。我们需要在spring bean配置文件中为DataSource配置事务管理器。

<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

44. 什么是Spring DAO？

Spring DAO支持与JDBC、Hibernate等数据访问技术一起以一致且简单的方式工作。例如，我们有JdbcDaoSupport、HibernateDaoSupport、JdoDaoSupport和JpaDaoSupport用于相应的技术。

Spring DAO还在异常层次结构上提供了一致性，我们不需要捕获特定的异常。

45. 如何集成Spring和Hibernate框架？

如果您使用的是Hibernate 3+，其中SessionFactory提供当前会话，则我们可以使用Spring ORM模块来集成Spring和Hibernate框架，那么您应该避免使用HibernateTemplate或HibernateDaoSupport类，最好使用依赖注入的DAO模式进行集成。

Spring ORM支持使用Spring声明式事务管理，因此您应该利用它，而不是采用Hibernate的样板代码进行事务管理。

为了更好地理解，您应该阅读以下教程：

46. 什么是Spring Security？

Spring Security框架专注于在Java应用程序中提供身份验证和授权。它还负责处理大多数常见的安全漏洞，如CSRF攻击。

在Web应用程序中使用Spring Security非常有益且易于使用，通过使用诸如@EnableWebSecurity等注解。您应该阅读以下帖子以了解如何使用Spring Security框架。

47. 如何将java.util.Properties注入到Spring Bean中？

我们必须定义propertyConfigurer bean，它将从给定的属性文件加载属性。然后，我们可以使用Spring EL支持将属性注入到其他bean的依赖项中。例如：

<bean id="propertyConfigurer" 
  class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
    <property name="location" value="/WEB-INF/application.properties" />
</bean> 

<bean class="com.journaldev.spring.EmployeeDaoImpl">
    <property name="maxReadResults" value="${results.read.max}"/>
</bean>

如果您正在使用注解来配置Spring Bean，那么您可以像下面这样注入属性。

@Value("${maxReadResults}") 
private int maxReadResults;

48. 在Spring Framework中使用了哪些设计模式？

Spring Framework使用了许多设计模式，其中一些常见的包括：

单例模式：使用默认范围创建bean。
工厂模式：Bean工厂类
原型模式：Bean作用域
适配器模式：Spring Web和Spring MVC
代理模式：Spring面向切面编程支持
模板方法模式：JdbcTemplate，HibernateTemplate等
前端控制器：Spring MVC DispatcherServlet
数据访问对象: Spring DAO 支持
依赖注入和面向切面编程

49. Spring框架的一些最佳实践是什么？

Spring框架的一些最佳实践包括：

避免在模式引用中使用版本号，以确保我们具有最新的配置。
根据关注点划分Spring Bean配置，例如spring-jdbc.xml，spring-security.xml。
对于在Spring MVC中在多个上下文中使用的Spring Bean，请在根上下文中创建并使用监听器进行初始化。
尽可能配置Bean依赖关系，尽量避免自动装配。
对于应用程序级别的属性，最佳方法是创建一个属性文件并在Spring Bean配置文件中读取它。
对于较小的应用程序，注解是有用的，但对于较大的应用程序，注解可能变得繁琐。如果我们将所有配置放在XML文件中，维护将会更容易。
使用正确的注解以便轻松理解组件的目的。对于服务使用@Service，对于DAO bean使用@Repository。
Spring框架有许多模块，使用您需要的模块。删除通过Spring Tool Suite模板创建项目时通常添加的所有额外依赖项。
如果您正在使用切面，请确保将连接点保持尽可能窄，以避免在不需要的方法上增加通知。考虑使用更易于使用且避免任何问题的自定义注解。
只有在真正受益时才使用依赖注入，不要仅仅因为松耦合而使用它，因为这样更难维护。

50. 什么是Spring Boot？

Spring Boot使Spring框架独特。它为我们提供了一种简便的方式来创建不同类型的Java应用程序，并将它们与Servlet容器运行环境连接起来。因此，我们得到一个单独的JAR文件，我们可以运行以执行项目。这样，我们可以在非常短的时间内获得一个部署就绪的项目骨架，从而节省了大量时间。这样，我们可以更专注于业务逻辑，而不是按照常规的构建代码，然后将其部署在Servlet容器上的通用过程。由于这是一个非常广泛的主题，我建议您查看Spring Boot面试问题。

关于Spring框架的面试问题就介绍到这里。希望这些问题能帮助您准备Java EE面试。我会不断添加更多问题到列表中，一旦找到它们，我会包含在内。

Source:
https://www.digitalocean.com/community/tutorials/spring-interview-questions-and-answers

20. 什么是Bean自动装配和@Autowired注解？

24. 在Spring中，@Component、@Controller、@Repository和@Service注解有什么区别？

20. 什么是Bean自动装配和 @Autowired注解？