spring面试问题与答案集锦

时间  2019-11-21
标签 spring 面试 问题 答案 集锦 栏目 Spring 繁體版
原文   原文链接

我收集了一些spring面试的问题，这些问题可能会在下一次技术面试中遇到。对于其余spring模块，我将单独分享面试问题和答案。前端

若是你能将在之前面试中碰到的，且你认为这些应该是一个有spring经验的人可能被问到的问题发给我，我将不胜感激！java

我将把它们添加到这个列表中。这将对其余学习者也会有很大的帮助。web

1. 什么是Spring框架?它的主要模块有哪些?面试

2. 使用Spring框架的好处是什么?spring

3.什么是控制反转(IoC)和依赖注入?数据库

4. 在Spring框架中的IoC是怎么样子的 ?编程

5. BeanFactory和ApplicationContext之间的区别?json

6. 将Spring配置到应用程序中的方式有哪些?设计模式

7. 基于xml的Spring配置是什么样子的?安全

8. 基于Spring java的配置是什么样子的?

9. 基于Spring注解的配置是什么样子的?

10. 请解释一下Spring Bean的生命周期?

11. Spring Bean做用域的有哪些?

12. Spring的内部Bean是什么?

13. 在Spring框架中，单例bean线程安全吗?

14. 如何在Spring中注入Java集合?请给个例子好吗?

15. 如何将一个java.util.属性注入到Spring Bean?

16. 解释一下Spring Bean的自动注入式什么样的?

17. 请解释一下不一样的bean自动注入模式?

18. 怎么打开基于注释的自动注入的?

19. 可否用例子解释一下@ required注解吗?

20.可否用例子解释一下@ autowired注解吗?

21. 可否用例子讲解一下@qualifier注解吗?

22. 构造方法注入和setter注入之间的区别吗?

23. spring框架的事件类型有哪些?

24. FileSystemResource和ClassPathResource之间的区别吗?

25. 列举一些Spring框架中使用的设计模式?

1. Spring框架是什么?它的主要模块有哪些?

Spring框架是一个Java平台,提供全面的基础设施支持开发Java应用程序。Spring处理基础设施部分,这样你就能够专一于应用程序部分。Spring框架内,把一级对象经过设计模式封装起来,您能够放心的集成到您本身的应用程序而不用关注他们如何在后台工做。

目前,Spring框架由功能组织成大约20个模块。这些模块分为核心容器、数据访问/集成、Web,AOP(面向切面的编程)、instrument(支持和类加载器的实现来在特定的应用服务器上使用)、消息、和测试,以下列图所示。

spring模块

2. 使用Spring框架的好处是什么?

下面是一些使用Spring框架的好处的列表：

  • 经过依赖注入(DI)方式,在构造方法或者java bean属性上，依赖关系是明确的和明显的。
  • IoC容器每每是轻量级的,特别是与EJB容器相比。这是有利于在有限的内存和CPU资源的计算机上开发和部署应用程序。
  • Spring不从新发明轮子，相反,它利用一些现有的技术如几个ORM框架,日志框架,JEE,quartz和JDK计时器,其余视图技术等。
  • Spring是模块化的。尽管包和类很重要,你只关心你须要的模块,忽略其它模块。
  • 在Spring测试应用程序很简单,由于依赖环境的代码被移入到框架自己。此外,经过使用JavaBean-style pojo方式,使用依赖注入注入测试数据变得更容易。
  • Spring的web框架是一个设计良好的web MVC框架,它能够很好的替代其它web框架如struts或者其它web框架。
  • Spring提供了一致的事务管理界面,能够管理小到一个本地事务(例如,使用一个数据库)和大到全局事务(例如,使用JTA)。

3. 什么是控制反转(IoC)和依赖项注入?

　　依赖注入和控制反转是对同一件事情的不一样描述，从某个方面讲，就是它们描述的角度不一样。

　　依赖注入是从应用程序的角度在描述，能够把依赖注入描述完整点：应用程序依赖容器建立并注入它所须要的外部资源；

　　而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所须要的外部资源。

　　在Java中,依赖注入可能发生三种方法:

  1. 构造方法注入
  2. setter方法注入
  3. 接口注入

4. Spring框架的IOC是怎么样的?

　　org.springframework.beans和org.springframework.context包是Spring框架IoC容器的基础。

　　BeanFactory接口提供了一个高级的配置机制来管理任意属性的对象。

　　ApplicationContext接口基于BeanFactory构建的(是一个子接口)并添加其余功能,如Spring的AOP功能,信息资源处理(用于国际化)、事件传播和应用程序层的特定上下文如在web应用程序中使用WebApplicationContext。

　　org.springframework.beans.factory.BeanFactory是Spring IoC容器真是展示,负责管理上述bean。BeanFactory接口是Spring IoC容器接口的核心。

5. BeanFactory和ApplicationContext之间的区别?

一个BeanFactory就像包含bean集合的工厂类。BeanFactory在内部持有多个Bean的定义，当客户端请求bean时,将bean进行实例化。 

初始化时BeanFactory可以保持对象的依赖关系。这减轻了负担从bean自己和bean客户机的配置。 BeanFactory在一个bean的生命周期也能其做用,它能够调用bean的自定义初始化和销毁方法。

表面上看,applicationContext和BeanFactory是同样。一样加载bean定义，将bean链接在一块儿,分发bean。但applicationContext还提供:

  1. 一种解析消息的手段,包括对国际化的支持。
  2. 一个更通用的加载文件资源的方法。
  3. bean事件注册为监听器。

三个经常使用的ApplicationContext实现是:

  1. ClassPathXmlApplicationContext:它从classpath路径下的一个XML文件加载context的,将Context做为classpath下的资源。加载应用程序classpath下的context使用的代码以下： 
    ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”);
  2. FileSystemXmlApplicationContext:它从文件系统的一个XML文件加载上下文定义的。从文件系统加载应用程序上下文经过以下代码实现。 
    ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);
  3. XmlWebApplicationContext:它从一个web应用程序中包含的XML文件加载context。

6. 将Spring配置应用程序的方式有哪些呢?

配置spring到您的应用程序有三种方式:

  1. 基于XML的配置
  2. 基于注解的配置
  3. 基于java的配置

7. 基于xml的Spring配置是什么样子的?

在Spring框架中,bean所需的依赖和服务在定义在配置文件中,配置文件一般是XML格式。一般这些配置文件都以<beans>标签开始，含有大量的bean定义和特定于应用程序的配置选项。Spring XML配置的主要目标是让全部spring组件经过使用XML配置文件。

这意味着不会出现任何其余类型的Spring配置(如经过Java类注释或配置)。Spring XML配置中使用Spring命名空间提供的XML标记中使用的配置;Spring命名空间主要有:context、bean、jdbc、tx, aop, mvc等。

<beans>
 
    <!-- JSON Support -->
    <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
    <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>
     
    <bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/>
 
</beans>

最简单的让您的应用程序加载配置文件和配置运行时组件方式是在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>

8. 基于java的Spring配置是什么样子的?

在支持spring的新java配置组件中，@Configuration注解的类和@Bean注解的方法是核心组件。

@Bean注解用于经过方法来实例化,配置和初始化一个新的由Spring IoC容器管理的对象。@Bean注解和<bean/>元素扮演相同的角色。

在一个类上使用@Configuration注解,其主要用途是做为bean定义的来源。此外, 在同一个类中@Configuration类容许inter-bean定义经过简单地调用实现依赖关系。最简单的@Configuration注解类以下:

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

上面注解类等价于基于XML配置文件以下:

<beans>
    <bean id="myService" class="com.howtodoinjava.services.MyServiceImpl"/>
</beans>

为了使这样的配置能生效,须要使用AnnotationConfigApplicationContext的帮助。

  
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.howtodoinjava")
public class AppConfig  {
    ...
}

在上面的示例中com.howtodoinjava包将被扫描,寻找任何带注解@Component的类,这些类将在容器内登记为Spring bean。

若是你使用以上的方式配置一个web应用程序,那么须要AnnotationConfigWebApplicationContext类来使之生效。AnnotationConfigWebApplicationContext的使用能够经过配置Spring ContextLoaderListener的servlet listener,Spring MVC DispatcherServlet等。

<web-app>
    <!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext -->
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>
 
    <!-- Configuration locations must consist of one or more comma- or space-delimited fully-qualified @Configuration classes. Fully-qualified packages may also be specified for component-scanning -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>com.howtodoinjava.AppConfig</param-value>
    </context-param>
 
    <!-- Bootstrap the root application context as usual using ContextLoaderListener -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
 
    <!-- Declare a Spring MVC DispatcherServlet as usual -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- Configure DispatcherServlet to use AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext -->
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>
                org.springframework.web.context.support.AnnotationConfigWebApplicationContext
            </param-value>
        </init-param>
        <!-- Again, config locations must consist of one or more comma- or space-delimited and fully-qualified @Configuration classes -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>com.howtodoinjava.web.MvcConfig</param-value>
        </init-param>
    </servlet>
 
    <!-- map all requests for /app/* to the dispatcher servlet -->
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>
</web-app>

9. 基于Spring注解的配置是什么样子的?

从Spring 2.5就可使用注解来配置依赖注入。而不是使用XML来描述一个bean的注入,你能够经过使用注解相关的类,方法或字段声明将bean配置的移到注解类自己。

注释注入执行XML注入以前,所以后者配置将会覆盖前者属性链接经过这两种方法。

默认状况下，spring容器没有打开自动注解功能。因此在使用具备spring注解以前,咱们须要在咱们的Spring配置文件启用它。若是你想在Spring应用程序中使用的自动注解，考虑配置文件上加上下面的配置。

<beans>
 
   <context:annotation-config/>
   <!-- bean definitions go here -->
 
</beans>

一旦配置了<context:annotation-config/>,代表在Spring中您能够开始使用属性,方法和构造函数的自动注入。

一些重要的注解:

  1. @required: @ required注解适用于bean属性setter方法。
  2. @autowired: @ autowired注解能够适用于bean属性setter方法,non-setter方法、构造函数和属性。
  3. @qualifier: @ qualifier注解加上@ autowired能够用来消除多个bean混乱来保证惟一的bean注入。
  4. jsr - 250注释:Spring支持基于jsr - 250的注解如@Resource、@PostConstruct和@PreDestroy。

10.请解释一下Spring Bean的生命周期?

一个Spring bean的生命周期很容易理解。当一个bean实例化时可能须要执行一些初始化动做进入使bean达到一个可用的状态。一样,当再也不须要bean时，将bean从容器中移除,可能须要销毁。

Spring beanFactory经过Spring容器负责管理bean的生命周期。bean的生命周期包括能够大致分类为两类的回调方法

  1. 初始化后的回调方法
  2. 销毁前的回调方法

Spring框架提供了如下四种方法控制bean的生命周期事件:

  • InitializingBean和DisposableBean回调接口
  • 其余知道接口为特定的行为
  • 定制的init()和destroy()方法在bean配置文件
  • @PostConstruct和@PreDestroy注解

例如, customInit()和 customDestroy()方法生命周期方法的例子。

<beans>
    <bean id="demoBean" class="com.howtodoinjava.task.DemoBean" init-method="customInit" destroy-method="customDestroy"></bean>
</beans>

11. Spring Bean的做用域scope有哪些?

spring容器中的bean有5中scope，分别是：

  1. 单例singleton:默认状况下都是单例的，它要求在每一个spring 容器内不论你请求多少次这个实例，都只有一个实例。单例特性是由beanfactory自己维护的。
  2. 原型prototype:这个bean的实例和单例相反,一个新的请求产生一个新的bean实例。
  3. 请求request:在一个请求内,将会为每一个web请求的客户端建立一个新的bean实例。一旦请求完成后,bean将失效，而后被垃圾收集器回收掉。
  4. 会话session:就像请求范围,这样能够确保每一个用户会话bean的一个实例。当用户结束其会话,bean失效。
  5. 全局会话global-session:应用到Portlet应用程序。基于Servlet的应用程序和会话相同。

12. spring的内部Bean是什么?

在Spring框架中,当一个bean只用于一个特定属性,建议将它声明为一个内在的bean。内部bean同时支持setter注入属性和构造函数注入“constructor-arg”。

例如,假设一个Customer类的引用Person类。在咱们的应用程序中,咱们将只建立一个Person类的实例,并在Customer使用它。

  
public class Customer
{
    private Person person;
     
    //Setters and Getters
}
public class Person
{
    private String name;
    private String address;
    private int age;
     
    //Setters and Getters
}

如今内部bean声明是这样的:

  
<bean id="CustomerBean" class="com.howtodoinjava.common.Customer">
    <property name="person">
        <!-- This is inner bean -->
        <bean class="com.howtodoinjava.common.Person">
            <property name="name" value="adminis"></property>
            <property name="address" value="India"></property>
            <property name="age" value="34"></property>
        </bean>
    </property>
</bean>

 

13. 在Spring框架中，单例bean是线程安全的吗?

Spring框架不对单例的bean作任何多线程的处理。单例的bean的并发问题和线程安全是开发人员的责任。

而实际上,大多数spring bean没有可变状态(例如服务和DAO的类),这样的话自己是线程安全的。但若是您的bean有可变状态(例如视图模型对象),这就须要你来确保线程安全。

这个问题最简单和明显的解决方案是改变bean Scope，可变的bean从“单例”到“原型”。

14. 如何在Spring里注入Java集合?请给个例子好吗?

Spring提供了四种类型的配置元素集合,以下:

<list>:帮助注入一组值,容许重复。
<set>:帮助注入一组值,不容许重复。
< map>:帮助注入一个K-V的集合,名称和值能够是任何类型的。
<props>:帮助注入一个名称-值对集合，名称和值都是字符串。

让咱们看看每种类型的例子。

<beans>
 
   <!-- Definition for javaCollection -->
   <bean id="javaCollection" class="com.howtodoinjava.JavaCollection">
 
      <!-- java.util.List -->
      <property name="customList">
        <list>
           <value>INDIA</value>
           <value>Pakistan</value>
           <value>USA</value>
           <value>UK</value>
        </list>
      </property>
 
     <!-- java.util.Set -->
     <property name="customSet">
        <set>
           <value>INDIA</value>
           <value>Pakistan</value>
           <value>USA</value>
           <value>UK</value>
        </set>
      </property>
 
     <!-- java.util.Map -->
     <property name="customMap">
         
        <map>
           <entry key="1" value="INDIA"/>
           <entry key="2" value="Pakistan"/>
           <entry key="3" value="USA"/>
           <entry key="4" value="UK"/>
        </map>
 
      </property>
       
      <!-- java.util.Properties -->
    <property name="customProperies">
        <props>
            <prop key="admin">admin@nospam.com</prop>
            <prop key="support">support@nospam.com</prop>
        </props>
    </property>
 
   </bean>
 
</beans>

 

15. 如何将一个java.util.属性注入到Spring Bean ?

第一个方法是使用<props>标记以下。

  
<bean id="adminUser" class="com.howtodoinjava.common.Customer">
  
    <!-- java.util.Properties -->
    <property name="emails">
        <props>
            <prop key="admin">admin@nospam.com</prop>
            <prop key="support">support@nospam.com</prop>
        </props>
    </property>
 
</bean>

也可使用“util:“名称空间建立bean的属性文件,并使用bean的setter方法注入。

<util:properties id="emails" location="classpath:com/foo/emails.properties" />

16. 解释一下Spring Bean的自动注入是怎么样的?

在spring框架中,在配置文件中设置bean的依赖是一个很好的办法,但spring容器也可以自动注入不一样bean之间的关系。这意味着，经过检查BeanFactory的内容它能够为您的bean自动注入其余bean。

能够为每一个bean指定是否自动注入,所以能够支持一些Bean支持自动注入,而一些bean不会自动注入。

下面从XML配置文件摘录了自动根据名称注入的bean。

<bean id="employeeDAO" class="com.howtodoinjava.EmployeeDAOImpl" autowire="byName" />

除了提供的自动装配模式bean配置文件,也能够在bean类中指定自动装配使用 @Autowired注释。

注意：在bean类使用@Autowired注解,您必须在spring应用程序中先启用下面的注解。

  
<context:annotation-config />

也能够经过在配置文件使用AutowiredAnnotationBeanPostProcessorbean来完成。

<bean class ="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

如今,当注释配置已经启用,您能够自由使用@Autowired来自动注入bean依赖关系,以你喜欢的方式。

  
@Autowired
public EmployeeDAOImpl ( EmployeeManager manager ) {
    this.manager = manager;
}

17. 请解释一下不一样的bean自动注入模式?

在Spring有五个自动注入模式。让咱们逐个讨论。

  1. no:默认状况下，spring框架的自动注入选项，即默认状况不开启自动注入。这意味着你必须使用标签在bean定义中显式地设置依赖项。
  2. byName:这个选项使基于bean的名称的依赖项注入。当自动装配在bean属性,用属性名搜索匹配的bean定义配置文件。若是找到这样的bean,注入属性。若是没有找到这样的bean,就会产生一个错误。
  3. byType:该选项容许基于bean的类型的依赖项注入。当在bean属性须要自动注入时,使用属性类的类型来搜索匹配的bean定义配置文件。若是找到这样的bean,注入属性。若是没有找到这样的bean,就会产生一个错误。
  4. constructor:构造方法相似于byType自动注入,但适用于构造方法的参数。在自动注入bean时,它在全部构造函数参数类型中寻找匹配的构造函数的类类型参数,而后进行自动注入,。请注意,若是在容器中没有一个bean构造函数参数类型知足,会抛出一个致命错误。
  5. autodetect:自动侦测使用两种模式即构造函数或byType模式的自动注入。首先它将试图寻找有效的构造方法参数,若是发现构造方法模式则选择。若是没有构造方法中定义bean,或者明确的默认无参构造方法,则选择byType模式自动注入。

18. 怎么打开基于注释的自动注入的?

要启用@Autowired,你必须注册AutowiredAnnotationBeanPostProcessor,你能够用两种方式。

1. 在bean配置文件使用<context:annotation-config >。

<beans>
    <context:annotation-config />
</beans>

2. 直接将AutowiredAnnotationBeanPostProcessor放到bean配置文件。

<beans>
    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
</beans>

19. 可否用例子解释一下@ required注解吗?

在大规模的应用程序中,IoC容器中可能会有成百上千的bean声明,以及它们之间的依赖关系一般是很是复杂的。

setter注入的缺点之一是,很难给你检查出所需的全部属性是否已经注入。

为了克服这个问题,您能够设置bean的“dependency-check”属性，能够设置四个属性的其中之一即 none, simple, objects or all (没有一个是默认选项)。

在现实生活中应用程序中,您将不会感兴趣检查全部上下文中的bean属性配置文件。而你想要检查一些特定的bean是否已设置特定的属性。在这种状况下，Spring的依赖项检查功能将再也不适用,。

为了解决这个问题,您可使用@Required注解。在bean属性使用@Required注解的setter方法类文件以下:

  
public class EmployeeFactoryBean extends AbstractFactoryBean<Object>
{
    private String designation;
      
    public String getDesignation() {
        return designation;
    }
  
    @Required
    public void setDesignation(String designation) {
        this.designation = designation;
    }
      
    //more code here
}

RequiredAnnotationBeanPostProcessor是一个spring bean后置处理程序,检查@Required注解的全部的bean属性是否已设置。使用这个bean属性检查后置处理程序,您必须注册在Spring IoC容器中。

<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />

若是@Required注解的任何属性没有设置,这个bean的处理器会抛出一个BeanInitializationException异常。

20.可否用例子解释一下@ autowired注解吗?

@Autowired注解提供了更细粒度的控制,以及应该如何完成自动注入。@Autowired注解和@Required注解同样，可用于bean的自动注入，它能够做用于构造方法,属性或具备任意名称和/或多个参数的方法。

例如,您可使用@Autowired注解的setter方法来代替在XML配置文件中的<property>元素。当Spring找到一个@Autowired注解的方法,它尝试使用byType自动注入的方法。

您能够将@Autowired应用到构造方法。一个构造方法使用@Autowired注解代表，即便在XML文件没有配置bean的<constructor-arg>元素，当建立bean时，构造方法也会自动注入。

  
public class TextEditor {
   private SpellChecker spellChecker;
 
   @Autowired
   public TextEditor(SpellChecker spellChecker){
      System.out.println("Inside TextEditor constructor." );
      this.spellChecker = spellChecker;
   }
 
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

没有构造方法参数的配置。

<beans>
 
   <context:annotation-config/>
 
   <!-- Definition for textEditor bean without constructor-arg -->
   <bean id="textEditor" class="com.howtodoinjava.TextEditor">
   </bean>
 
   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.howtodoinjava.SpellChecker">
   </bean>
 
</beans>

21. 可否用例子讲解一下@qualifier注解吗?

@Qualifier限定哪一个bean应该被自动注入。当Spring没法判断出哪一个bean应该被注入时，@Qualifier注解有助于消除歧义bean的自动注入。

参见下面的例子,

public class Customer
{
    @Autowired
    private Person person;
}

咱们有两个bean定义为Person类的实例。

<bean id="customer" class="com.howtodoinjava.common.Customer" />
 
<bean id="personA" class="com.howtodoinjava.common.Person" >
    <property name="name" value="lokesh" />
</bean>
 
<bean id="personB" class="com.howtodoinjava.common.Person" >
    <property name="name" value="alex" />
</bean>

Spring 知道哪一个bean应该自动注入?不。当您运行上面的例子时,抛出以下异常:

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:
    No unique bean of type [com.howtodoinjava.common.Person] is defined:
        expected single matching bean but found 2: [personA, personB]

要解决以上问题,你须要使用@Quanlifier注解告诉Spring 哪一个bean应该被autowired的。

  
public class Customer
{
    @Autowired
    @Qualifier("personA")
    private Person person;
}

22. 构造方法注入和setter注入之间的区别吗?

有如下几点明显的差别:

  1. 在Setter注入,能够将依赖项部分注入,构造方法注入不能部分注入，由于调用构造方法若是传入全部的参数就会报错。
  2. 若是咱们为同一属性提供Setter和构造方法注入，Setter注入将覆盖构造方法注入。可是构造方法注入不能覆盖setter注入值。显然，构造方法注入被称为建立实例的第一选项。
  3. 使用setter注入你不能保证全部的依赖都被注入,这意味着你能够有一个对象依赖没有被注入。在另外一方面构造方法注入直到你全部的依赖都注入后才开始建立实例。
  4. 在构造函数注入,若是A和B对象相互依赖：A依赖于B,B也依赖于A,此时在建立对象的A或者B时，Spring抛出ObjectCurrentlyInCreationException。因此Spring能够经过setter注入,从而解决循环依赖的问题。

23. spring框架的事件类型有哪些?

Spring的ApplicationContext具备代码层上支持事件和监听器的功能。咱们能够建立bean监听经过ApplicationContext发布的事件。ApplicationContext里的事件处理经过提供ApplicationEvent类和ApplicationListener接口来完成。因此若是一个bean实现了ApplicationListener接口,当一个ApplicationEvent发布到ApplicationContext时，该bean将接到通知。

public class AllApplicationEventListener implements ApplicationListener < ApplicationEvent >
{
    @Override
    public void onApplicationEvent(ApplicationEvent applicationEvent)
    {
        //process event
    }
}

Spring提供了如下5标准事件:

  1. ContextRefreshedEvent:当ApplicationContext初始化或刷新时发布这个事件。这个事件也能够经过ConfigurableApplicationContext接口的refresh()方法来触发。
  2. ContextStartedEvent:当ApplicationContext被ConfigurableApplicationContext接口的start()方法启动时发布这个事件。你能够在收到这一事件后查询你的数据库或重启/启动任何中止的应用程序。
  3. ContextStoppedEvent:当ApplicationContext被ConfigurableApplicationContext接口的stop()方法关闭时发布这个事件。你能够在收到这一事件后作一些清理工做。
  4. ContextClosedEvent:当ApplicationContext时被ConfigurableApplicationContext接口的close()方法关闭时发布这个事件。一个终结的上下文达到生命周期结束;它不能刷新或重启。
  5. RequestHandledEvent:这是一个网络自身的事件，告诉全部bean：HTTP请求服务已经处理完成。

除了上面的事件,您能够经过扩展ApplicationEvent类建立自定义事件。如：

  
public class CustomApplicationEvent extends ApplicationEvent
{
    public CustomApplicationEvent ( Object source, final String msg )
    {
        super(source);
        System.out.println("Created a Custom event");
    }
}

监听这个事件,建立一个监听器是这样的:

public class CustomEventListener implements ApplicationListener < CustomApplicationEvent >
{
    @Override
    public void onApplicationEvent(CustomApplicationEvent applicationEvent) {
        //handle event
    }
}

发布这个事件：

CustomApplicationEvent customEvent = new CustomApplicationEvent( applicationContext, "Test message" );
applicationContext.publishEvent ( customEvent );

24. FileSystemResource和ClassPathResource之间的区别吗?

在FileSystemResource中你须要给出spring-config.xml(Spring配置)文件相对于您的项目的相对路径或文件的绝对位置。

在ClassPathResource中Sping查找文件使用ClassPath，所以spring-config.xml应该包含在类路径下。

一句话,ClassPathResource在类路径下搜索和FileSystemResource在文件系统下搜索。

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

有不少不一样的设计模式,但有一些明显的:

    • 代理——在AOP大量使用,还有远程模块。
    • 单例——spring配置文件中定义的bean默认是单例的。
    • 模板方法——普遍使用处理重复逻辑的代码。例如RestTemplate, JmsTemplate, JpaTemplate.
    • 前端控制器——Spring提供了DispatcherServlet，确保传入请求被分派到你的控制器。
    • 视图助手——Spring有许多定制JSP标记,和velocity宏,协助在视图层分离展现代码。
    • 依赖注入——BeanFactory / ApplicationContext的核心概念。
    • 工厂模式——BeanFactory建立一个对象的实例。

 原文：https://howtodoinjava.com/interview-questions/top-spring-interview-questions-with-answers/

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程