62. Spring 常见面试问题

我贴了很多Spring教程最近。这篇文章将帮助你渡过难关Spring面试问题详细解释核心概念。

Spring框架是web应用程序中最流行的J2EE框架之一。依赖注入和面向切面编程是Spring框架的核心。如果你擅长Spring框架，那么被选中的几率会很高。

Spring面试问题

1. 什么是Spring框架？
2. Spring框架的一些重要特性和优势是什么？
3. 你对依赖注入有什么理解？
4. 如何在Spring框架中实现DI？
5. Spring5有什么新特性？
6. 什么是Spring WebFlux？
7. 使用Spring工具套件有什么好处？
8. 列出一些重要的Spring模块？
9. 你对面向切面编程有什么理解？
10. AOP中的Aspect、Advice、Pointcut、JointPoint和Advice参数是什么？
11. SpringAOP和AspectJ AOP有什么区别？
12. 什么是Spring Ioc容器？
13. 什么是Spring Bean？
14. Spring Bean配置文件的重要性是什么？
15. 将类配置为Spring Bean有哪些不同的方法？
16. SpringBean的不同范围是什么？
17. Spring Bean的生命周期是什么？
18. 如何在Spring Bean中获取ServletContext和ServletConfig对象？
19. 什么是Bean wiring和@Autowired注解？
20. 什么是不同类型的Spring Bean自动布线？
21. Spring Bean提供线程安全性吗？
22. 什么是Spring Mvc中的控制器？
23. Spring中@Component、@Repository和@Service注解之间有什么区别？
24. 什么是DispatcherServlet和ContextLoaderListener？
25. 什么是Spring的ViewResolver？
26. 什么是MultipartResolver，以及何时使用它？
27. 如何在Spring Mvc框架中处理异常？
28. 如何在Java程序中创建ApplicationContext？
29. 我们可以有多个Spring配置文件吗？
30. 什么是ContextLoaderListener？
31. 创建Spring Mvc应用程序所需的最低配置是什么？
32. Spring框架和MVC架构有什么关系？
33. 如何在Spring Mvc应用程序中实现本地化？
34. 我们如何使用Spring创建restfulweb服务来返回JSON响应？
35. 您使用过哪些重要的Spring注解？
36. 我们可以发送一个对象作为控制器处理程序方法的响应吗？
37. 如何在Spring Mvc应用程序中上传文件？
38. 如何在springwebmvc框架中验证表单数据？
39. 什么是Spring Mvc拦截器以及如何使用它？
40. 什么是SpringJDBCTemplate类以及如何使用它？
41. 如何在springweb应用程序中使用tomcatjndi数据源？
42. 您将如何在Spring实现事务管理？
43. 什么是Spring Dao？
44. 如何集成Spring和Hibernate框架？
45. 什么是Spring安全？
46. 如何注射java.util.Properties属性变成Spring Bean？
47. 列举一下Spring框架中使用的一些设计模式？
48. Spring框架的一些最佳实践是什么？

Spring面试问答

1. 什么是Spring框架？

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

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

   我喜欢spring，因为它为Spring Mvc和等特定任务提供了许多特性和不同的模块。因为它是一个开源框架，有很多在线资源和活跃的社区成员，所以使用Spring框架既简单又有趣。

   推荐阅读:Spring框架

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

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

   spring框架的一些特性包括：

   • 轻量级的，并且使用框架进行开发的开销非常小。
   • 依赖注入或控制反转来编写彼此独立的组件，spring容器负责将它们连接在一起以实现我们的工作。
   • Spring Ioc容器管理Spring Bean生命周期和特定于项目的配置，如JNDI查找。
   • Spring Mvc框架可以用来创建web应用程序以及能够返回XML和JSON响应的restfulweb服务。
   • 支持事务管理、JDBC操作、文件上传、异常处理等，配置非常少，可以使用注解或Spring Bean配置文件。

   使用Spring框架的一些优点是：

   • 减少应用程序不同组件之间的直接依赖，通常Spring Ioc容器负责初始化资源或bean，并将它们作为依赖项注入。
   • 在Spring框架中编写单元测试用例很容易，因为我们的业务逻辑与实际的资源实现类没有直接的依赖关系。我们可以很容易地编写一个测试配置，并为测试目的注入模拟bean。
   • 减少锅炉板代码的数量，如初始化对象、打开/关闭资源。我非常喜欢JdbcTemplate类，因为它可以帮助我们删除JDBC编程所附带的所有样板代码。
   • Spring框架分为几个模块，它帮助我们保持应用程序的轻量级。例如，如果我们不需要Spring事务管理特性，那么就不需要在项目上添加这种依赖性。
   • Spring框架支持大多数J2EE特性，甚至更多。它总是在新技术之上，例如，有一个Android的Spring项目可以帮助我们为native编写更好的代码安卓应用。这使得spring框架成为一个完整的包，我们不需要为不同的需求考虑不同的框架。

3. 你对依赖注入有什么理解？

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

   使用依赖注入的一些好处是分离关注点、减少样板代码、可配置组件和易于单元测试。

   更多信息请访问依赖注入教程. 我们也可以使用依赖注入的googleguice自动化依赖注入的过程。但在大多数情况下，我们所寻找的不仅仅是依赖注入，这就是为什么Spring是首选。

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

   我们可以使用基于springxml和基于注解的配置在Spring应用程序中实现DI。为了更好的理解，请阅读Spring注射依赖在这个例子中，您可以学习JUnit测试用例的两种方法。这篇文章还包含一个示例项目zip文件，您可以下载该文件并在其中进行演示以了解更多信息。

5. Spring5有什么新特性？

   spring5给Spring框架带来了一个巨大的更新。Spring 5的一些新功能包括：

   1. Spring5运行在Java8+上，支持JavaEE7。所以我们可以使用lambda表达式和Servlet 4.0特性。很高兴看到Spring试图支持最新版本。
   2. Spring Framework5.0自带了自己的Commons日志桥；Spring Jcl代替了标准的Commons日志记录。
   3. 支持通过索引文件“META-INF”提供spring组件信息/Spring.组件“而不是类路径扫描。
   4. Spring Web Flux将反应式编程引入Spring框架。
   5. spring5现在也支持Kotlin编程。这是向支持函数式编程迈出的一大步，正如Java也在向函数式编程迈进一样。
   6. 在Spring Test Context框架中支持junit5和并行测试执行。

   有关这些功能的详细信息，请访问Spring5特色.

6. 什么是Spring WebFlux？

   Spring Web Flux是spring5中引入的新模块。Spring Web Flux是Spring框架中实现反应式编程模型的第一步。

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

   你可以在SpringWebFlux教程.

7. 使用Spring工具套件有什么好处？

   我们可以在Eclipse中安装插件来获得Spring工具套件的所有特性。然而，STS与Eclipse一起提供了其他一些重要的功能，比如Maven支持、用于创建不同类型Spring项目的模板以及tc服务器，以提高Spring应用程序的性能。

   我喜欢STS，因为它突出了Spring组件，如果您使用AOP切入点和advice，那么它会清楚地显示哪些方法将位于特定的切入点之下。因此，我宁愿在开发基于Spring的应用程序时使用STS，而不是自己安装所有东西。

8. 列出一些重要的Spring模块？

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

   • Spring背景–；用于依赖注入。
   • 面向切面编程–；面向切面编程。
   • Spring Dao–；用于使用DAO模式的数据库操作
   • SpringJDBC–；用于JDBC和数据源支持。
   • Spring对象关系映射–；用于ORM工具支持，如Hibernate
   • Spring Web模块&#用于创建web应用程序。
   • SpringMVC&#用于创建web应用程序、web服务等的模型-视图-控制器实现。

9. 你对面向切面编程有什么理解？

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

   AOP从普通面向对象编程中不可能的类中去掉横切任务的直接依赖关系。例如，我们可以有一个单独的类来记录日志，但是这些类必须调用这些方法来记录数据。更多关于Spring Aop支持的信息，请访问Spring AOP示例.

10. AOP中的Aspect、Advice、Pointcut、JointPoint和Advice参数是什么？

    方面：Aspect是一个实现横切关注点的类，例如事务管理。方面可以是一个普通的类，然后在Spring Bean配置文件中配置，或者我们可以使用Spring Aspectj支持将一个类声明为Aspect，使用@Aspect annotation.

    建议：Advice是对特定连接点执行的操作。就编程而言，它们是在应用程序中达到具有匹配切入点的特定连接点时执行的方法。你可以把建议看作Spring拦截器或Servlet筛选器.

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

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

    建议论点：我们可以在advice方法中传递参数。我们可以在切入点中使用args（）表达式来应用于匹配参数模式的任何方法。如果我们需要在advice方法中使用相同的名称，那么我们需要使用相同的方法。

    这些概念一开始看起来很混乱，但是如果你Spring方面，建议示例这样你就可以很容易地和他们联系起来了。

11. SpringAOP和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。

12. 什么是Spring Ioc容器？

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

    Spring框架IoC容器类是org.springframework.beans and org.springframework.context packages and provides us different ways to decouple the object dependencies.

    我们使用的一些有用的ApplicationContext实现是；

    • AnnotationConfigApplicationContext: For standalone java applications using annotations based configuration.
    • ClassPathXmlApplicationContext: For standalone java applications using XML based configuration.
    • FileSystemXmlApplicationContext: Similar to ClassPathXmlApplicationContext except that the xml configuration file can be loaded from anywhere in the file system.
    • AnnotationConfigWebApplicationContext and XmlWebApplicationContext for web applications.

13. 什么是Spring Bean？

    任何由Spring Ioc容器初始化的普通java类都称为Spring Bean。我们用SpringApplicationContext to get the Spring Bean instance.

    Spring Ioc容器管理Spring Bean的生命周期、Bean作用域以及在Bean中注入任何必需的依赖项。

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

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

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

15. 将类配置为Spring Bean有哪些不同的方法？

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

    1. XML配置：这是最流行的配置，我们可以使用上下文文件中的bean元素来配置Spring Bean。例如：

       
       <bean name="myBean"></bean>
       

    2. 基于Java的配置：如果只使用注解，则可以使用@Bean annotation. This annotation is used with @Configuration classes to configure a spring bean. Sample configuration is:

       
       @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);
       

    3. 基于注解的配置@spring也可以作为@spring的注解来配置，@Service-Controller也可以将它们作为@Service-Controller来配置。对于这些类，我们需要提供基本包位置来扫描这些类。例如：

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

16. SpringBean的不同范围是什么？

    为Spring Bean定义了五个作用域。

    1. 独生子女：将为每个容器只创建一个bean实例。这是Spring Bean的默认范围。在使用这个范围时，请确保Spring Bean没有共享的实例变量，否则可能会导致数据不一致的问题，因为它不是线程安全的。
    2. 原型：每次请求bean时都会创建一个新实例。
    3. 请求：这与prototype scope相同，但它是用于web应用程序的。将为每个HTTP请求创建一个新的bean实例。
    4. 阶段：容器将为每个HTTP会话创建一个新的bean。
    5. 全球会议：这用于为Portlet应用程序创建全局会话bean。

    Spring框架是可扩展的，我们也可以创建自己的作用域，但是大多数时候我们对框架提供的作用域很在行。

    为了设置Spring Bean的作用域，我们可以使用bean元素中的“；scope”；属性，或者@scope注解用于基于注解的配置。

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

    Spring Bean由Spring容器初始化，所有依赖项也被注入。当上下文被销毁时，它还会销毁所有初始化的bean。这在大多数情况下都能很好地工作，但有时我们希望在使bean准备好使用之前初始化其他资源或进行一些验证。Spring框架支持Spring Bean中的后初始化和预销毁方法。

    我们可以通过两种方法来实现这一点–；实现InitializingBean and DisposableBean interfaces or using 初始化方法和销毁方法属性。更多详情，请阅读Spring Bean生命周期法.

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

    有两种方法可以在Spring Bean中获得特定于容器的对象。

    1. 实现Spring*感知接口，对于这些ServletContextAware和ServletConfigAware接口，有关这些感知接口的完整示例，请阅读感知Spring接口
    2. 使用@Autowired annotation with bean variable of type ServletContext and ServletConfig. They will work only in servlet container specific environment only though.

       
       @Autowired
       ServletContext servletContext;
       

19. 什么是Bean wiring和@Autowired注解？

    初始化时注入Spring Bean依赖项的过程称为Spring Bean连接。

    通常，最好的做法是显式地连接所有bean依赖项，但是spring框架也支持自动连接。我们可以利用@Autowired annotation with fields or methods for 按类型自动布线. 为了使这个注解起作用，我们还需要在Spring Bean配置文件中启用基于注解的配置。这可以通过上下文：注解配置元素。

    有关的详细信息@Autowired annotation, please read Spring自动布线示例.

20. 什么是不同类型的Spring Bean自动布线？

    Spring框架中有四种类型的自动连接。

    1. 按名称自动连线
    2. 按类型自动连线
    3. 按构造函数自动连线
    4. 自动布线@自动连线和@限定符注解

    在Spring3.1之前，自动检测自动连线也支持类似于autowire的构造函数或byType。有关这些选项的详细信息，请阅读Spring豆自动布线.

21. Spring Bean提供线程安全性吗？

    Spring Bean的默认范围是singleton，因此每个上下文只有一个实例。这意味着所有拥有类级变量的线程都可以更新，这将导致数据不一致。因此在默认模式下，Spring Bean不是线程安全的。

    但是，我们可以将Spring Bean的作用域更改为请求、原型或会话，以达到线程安全性，但要牺牲性能。这是一个基于项目需求的设计决策。

22. 什么是Spring Mvc中的控制器？

    就像MVC设计模式一样，Controller是处理所有客户机请求并将它们发送到配置的资源来处理它的类。在SpringMVC，org.springframework.web.servlet.DispatcherServlet is the front controller class that initializes the context based on the spring beans configurations.

    控制器类负责根据请求映射处理不同类型的客户端请求。我们可以使用@Controller annotation. Usually, it’s used with @RequestMapping annotation to define handler methods for specific URI mapping.

23. Spring中@Component、@Controller、@Repository和@Service注解之间有什么区别？

    @组件用于指示类是组件。这些类用于自动检测，并在使用基于注解的配置时配置为bean。

    @控制器通常在应用程序中使用特定类型的RequestMapping。

    @存储库注解用于指示组件用作存储库和存储/检索/搜索数据的机制。我们可以将此注解应用于DAO模式实现类。

    @服务用于指示类是服务。通常，提供一些服务的businessfacade类都用这个来注解。

    我们可以将上述任何注解用于类以进行自动检测，但是提供了不同的类型，以便您可以轻松区分带注解类的用途。

24. 什么是DispatcherServlet和ContextLoaderListener？

    DispatcherServlet is the front controller in the Spring MVC application and it loads the spring bean configuration file and initialize all the beans that are configured. If annotations are enabled, it also scans the packages and configure any bean annotated with @Component, @Controller, @Repository or @Service annotations.

    ContextLoaderListener is the listener to start up and shut down Spring’s root WebApplicationContext. It’s important functions are to tie up the lifecycle of ApplicationContext to the lifecycle of the ServletContext and to automate the creation of ApplicationContext. We can use it to define shared beans that can be used across different spring contexts.

25. 什么是Spring的ViewResolver？

    ViewResolver implementations are used to resolve the view pages by name. Usually we configure it in the spring bean configuration file. For example:

    
    <!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
    <beans:bean>
    	<beans:property name="prefix" value="/WEB-INF/views/" />
    	<beans:property name="suffix" value=".jsp" />
    </beans:bean>
    

    InternalResourceViewResolver is one of the implementation of ViewResolver interface and we are providing the view pages directory and suffix location through the bean properties. So if a controller handler method returns “home”, view resolver will use view page located at /WEB-INF/视图/主页.jsp.

26. 什么是MultipartResolver，以及何时使用它？

    MultipartResolver interface is used for uploading files – CommonsMultipartResolver and StandardServletMultipartResolver are two implementations provided by spring framework for file uploading. By default there are no multipart resolvers configured but to use them for uploading files, all we need to define a bean named “multipartResolver” with type as MultipartResolver in spring bean configurations.

    一旦配置完成，任何多部分请求都将由配置的MultipartResolver解析，并传递一个包装好的HttpServletRequest。然后在controller类中使用它来获取文件并进行处理。完整的例子，请阅读Spring Mvc文件上传示例.

27. 如何在Spring Mvc框架中处理异常？

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

    1. 基于控制器–我们可以在控制器类中定义异常处理程序方法。我们只需要用@ExceptionHandler注解来注解这些方法。
    2. 全局异常处理程序–异常处理是一个跨领域的问题，Spring提供了@ControllerAdvice注解，我们可以使用它来定义我们的全局异常处理程序。
    3. 异常处理解决程序–对于一般的例外情况，大多数时候我们提供静态页面。Spring框架提供HandlerExceptionResolver interface that we can implement to create global exception handler. The reason behind this additional way to define global exception handler is that Spring framework also provides default implementation classes that we can define in our spring bean configuration file to get spring framework exception handling benefits.

    完整的例子，请阅读Spring异常处理示例.

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

    在独立的java程序中创建spring上下文有以下几种方法。

    1. 注解配置应用程序上下文：如果我们在独立的java应用程序中使用Spring并使用注解进行配置，那么我们可以使用它初始化容器并获取bean对象。
    2. ClassPathXmlApplicationContext：如果我们在独立应用程序中有Spring Bean配置xml文件，那么我们可以使用这个类来加载文件并获取容器对象。
    3. FileSystemXmlApplicationContext：这与ClassPathXmlApplicationContext类似，只是可以从文件系统中的任何位置加载xml配置文件。

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

    对于Spring Mvc应用程序，我们可以通过contextConfigLocation. This location string can consist of multiple locations separated by any number of commas and spaces. For example;

    
    <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>
    

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

    
    <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"/>
    

30. 什么是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>
    

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

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

    • 添加spring-context and spring-webmvc dependencies in the project.
    • 配置DispatcherServlet in the web.xml file to handle requests through spring container.
    • 定义bean的Spring Bean配置文件，如果使用注解，那么必须在这里配置它。我们还需要为视图页面配置视图解析器。
    • 定义了用于处理客户端请求的请求映射的控制器类。

以上步骤足以创建一个简单的Spring Mvchelloworld应用程序。

32. Spring框架和MVC架构有什么关系？

    顾名思义，Spring Mvc构建在模型视图控制器建筑。DispatcherServlet is the Front Controller in the Spring MVC application that takes care of all the incoming requests and delegate it to different controller handler methods.

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

    视图页面可以是JSP、静态HTMLs等，视图解析器负责找到正确的视图页面。一旦确定了视图页面，控制权就被交还给DispatcherServlet控制器。DispatcherServlet负责呈现视图并将最终响应返回给客户端。

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

    Spring通过资源包为本地化或i18n提供了极好的支持。使我们的应用程序本地化所需的基本步骤包括：

    1. 为不同区域设置创建消息资源包，例如消息_英语属性，消息_fr.属性等。
    2. 在类型为的Spring Bean配置文件中定义messagesourcebeanResourceBundleMessageSource or ReloadableResourceBundleMessageSource.
    3. 要更改区域设置支持，请定义CookieLocaleResolver类型的localeResolver bean并配置LocaleChangeInterceptor拦截器。示例配置如下：

       
       <beans:bean id="messageSource">
       <beans:property name="basename" value="classpath:messages" />
       <beans:property name="defaultEncoding" value="UTF-8" />
       </beans:bean>
        
       <beans:bean id="localeResolver"
          >
           <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>
               <beans:property name="paramName" value="locale" />
           </beans:bean>
       </interceptors>
       

    4. 使用spring:message element in the view pages with key names, DispatcherServlet picks the corresponding value and renders the page in corresponding locale and return as response.

    完整的例子，请阅读Spring本地化示例.

34. 我们如何使用Spring创建restfulweb服务来返回JSON响应？

    我们可以使用Spring框架来创建返回JSON数据的restfulweb服务。Spring提供了与杰克逊JSON我们可以用来在restfulweb服务中发送JSON响应的API。

    我们需要执行以下步骤来配置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. 配置RequestMappingHandlerAdapter bean in the spring bean configuration file and set the messageConverters property to MappingJackson2HttpMessageConverter bean. Sample configuration will be:

       
       <!-- Configure to plugin JSON as request and response in method handler -->
       <beans:bean>
           <beans:property name="messageConverters">
               <beans:list>
                   <beans:ref bean="jsonMessageConverter"/>
               </beans:list>
           </beans:property>
       </beans:bean>
            
       <!-- Configure bean to convert JSON to POJO and vice versa -->
       <beans:bean id="jsonMessageConverter">
       </beans:bean>
       

    3. 在控制器处理程序方法中，使用@ResponseBody annotation. Sample code:

       
       @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，那么我们可以使用restemplate类轻松地实现它。

    完整的例子，请阅读Spring Restful Webservice示例.

35. 您使用过哪些重要的Spring注解？

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

    • @控制器&#用于Spring Mvc项目中的控制器类。
    • @请求映射–；用于在控制器处理程序方法中配置URI映射。这是一个非常重要的注解，所以你应该仔细看看Spring Mvc请求映射注解示例
    • @回应书–；用于发送对象作为响应，通常用于发送XML或JSON数据作为响应。
    • @路径变量–；用于将动态值从URI映射到处理程序方法参数。
    • @自动连线–；用于Spring Bean中的自动连接依赖项。
    • @限定符–；使用@Autowired注解，以避免在存在多个bean类型实例时发生混淆。
    • @服务–；用于服务类。
    • @范围–；用于配置Spring Bean的作用域。
    • @配置,@组件扫描和@豆子–；用于基于java的配置。
    • 用于配置方面和建议的AspectJ注解，@方面,@以前,@之后,@周围,@切入点等。

36. 我们可以发送一个对象作为控制器处理程序方法的响应吗？

    是的，我们可以用@回应书注解。这就是我们在restfulweb服务中发送JSON或基于XML的响应的方式。

37. 如何在Spring Mvc应用程序中上传文件？

    Spring为通过多部分解器接口实现。它非常易于使用，只需更改配置即可使其正常工作。显然，我们需要编写控制器处理程序方法来处理传入的文件并对其进行处理。有关完整的示例，请参阅Spring文件上传示例.

38. 如何在springwebmvc框架中验证表单数据？

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

    对于自定义验证器实现，我们需要在控制器类中配置它。完整的例子，请阅读Spring Mvc表单验证示例.

39. 什么是Spring Mvc拦截器以及如何使用它？

    Spring Mvc拦截器类似于Servlet过滤器，允许我们拦截客户端请求并处理它。我们可以在三个地方拦截客户请求–；预处理,后手柄和竣工后.

    我们可以通过实现HandlerInterceptor接口或扩展抽象类来创建spring拦截器HandlerInterceptor适配器.

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

40. 什么是SpringJDBCTemplate类以及如何使用它？

    Spring框架提供了与JDBCAPI的良好集成，并提供了JdbcTemplate实用程序类，可用于避免数据库操作逻辑（如打开/关闭连接、ResultSet、PreparedStatement等）中的bolier板代码。

    对于JdbcTemplate示例，请参阅Spring JDBC示例.

41. 如何在springweb应用程序中使用tomcatjndi数据源？

    为了使用servlet容器配置的JNDI数据源，我们需要在Spring Bean配置文件中配置它，然后将其作为依赖项注入到Spring Bean中。然后我们可以用它JdbcTemplate to perform database operations.

    示例配置为：

    
    <beans:bean id="dbDataSource">
        <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
    </beans:bean>
    

    完整示例请参考Spring Tomcat JNDI示例.

42. 您将如何在Spring实现事务管理？

    Spring框架通过声明性事务管理和程序化事务管理提供事务管理支持。声明式事务管理应用最为广泛，因为它易于使用，并且在大多数情况下都能工作。

    我们使用带注解的方法@Transactional annotation for Declarative transaction management. We need to configure the transaction manager for the DataSource in the spring bean configuration file.

    
    <bean id="transactionManager"
       >
        <property name="dataSource" ref="dataSource" />
    </bean>
    

43. 什么是Spring Dao？

    Spring Dao支持以一种一致且简单的方式与JDBC、Hibernate等数据访问技术一起使用。例如我们有JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport and JpaDaoSupport for respective technologies.

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

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

    我们可以使用Spring Orm模块来集成Spring和Hibernate框架，如果您使用的是hibernate3+，其中SessionFactory提供了当前会话，那么您应该避免使用HibernateTemplate or HibernateDaoSupport classes and better to use DAO pattern with dependency injection for the integration.

    Spring Orm提供了对使用Spring声明性事务管理的支持，因此您应该利用它而不是使用Hibernate锅炉板代码来进行事务管理。

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

    • Spring Hibernate集成示例
    • Spring Mvc-Hibernate集成示例

45. 什么是Spring安全？

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

    通过使用诸如@EnableWebSecurity. You should go through the following posts to learn how to use the Spring Security framework.

    • Servlet Web应用中的Spring安全性
    • Spring Mvc和Spring Security集成示例

46. 如何注射java.util.Properties属性变成Spring Bean？

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

    
    <bean id="propertyConfigurer" 
     >
        <property name="location" value="/WEB-INF/application.properties" />
    </bean> 
    
    <bean>
        <property name="maxReadResults" value="${results.read.max}"/>
    </bean>
    

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

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

47. 列举一下Spring框架中使用的一些设计模式？

    Spring框架使用了很多设计模式，其中一些常见的模式有：

    1. 单例模式：创建具有默认作用域的bean。
    2. 工厂模式：Bean工厂类
    3. 原型图案：Bean作用域
    4. 适配器模式：Spring Web和Spring MVC
    5. 代理模式：Spring面向切面编程支持
    6. 模板方法模式：JdbcTemplate、HibernateTemplate等
    7. 前控制器：Spring MVC DispatcherServlet
    8. 数据访问对象：Spring Dao支持
    9. 依赖注入和面向切面编程

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

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

    1. 避免模式引用中的版本号，以确保我们拥有最新的配置。
    2. 根据Spring Bean的关注点（比如spring）划分Spring Bean配置-jdbc.xml文件，Spring-安全.xml.
    3. 对于在Spring Mvc的多个上下文中使用的Spring Bean，在根上下文中创建它们并使用listener初始化。
    4. 尽可能多地配置bean依赖项，尽量避免自动连接。
    5. 对于spring应用程序来说，创建文件属性的最佳方法是读取属性。
    6. 对于较小的应用程序，注解是有用的，但是对于较大的应用程序，注解可能会成为一个难题。如果我们把所有的配置都放在XML文件中，那么维护它就更容易了。
    7. 为组件使用正确的注解，以便于理解其用途。对于服务使用@Service，对于DAO bean使用@Repository。
    8. Spring框架有很多模块，可以根据需要使用。删除通过Spring工具套件模板创建项目时通常添加的所有额外依赖项。
    9. 如果您使用方面，请确保尽可能缩小连接品脱，以避免对不需要的方法提出建议。考虑更易于使用并避免任何问题的自定义注解。
    10. 在有实际好处时使用依赖注入，为了松耦合，不要使用依赖注入，因为它更难维护。

以上是Spring框架面试问题的全部内容。我希望这些问题能对你接下来的J2EE面试有所帮助。一旦我发现问题，我会继续在列表中添加更多的问题。如果你知道更多的问题，应该是一部分的清单，确保添加一个评论，我将包括它。