Spring面试题总结

一、什么是Spring?

Spring是一个轻量级的IoC和AOP容器框架。目的是解决企业应用开发的复杂性，使用基本的JavaBean来完成之前只可能由EJB完成的事情，并提供了更多的企业应用功能，Spring的用途不只限于服务器端的开发，从简单性、可测试性和松耦合的角度而言，任何Java应用均可以从Spring中受益。Spring 框架目标是简化Java企业级应用开发，并经过POJO为基础的编程模型促进良好的编程习惯。

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

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

三、Spring由哪些模块组成?

简单能够分红6大模块：

• Core ：spring的核心功能： IOC容器, 解决对象建立及依赖关系

• Web ：Spring对web模块的支持。

  • 能够与struts整合,让struts的action建立交给spring
  • spring mvc模式
• DAO ：Spring 对jdbc操做的支持 【JdbcTemplate模板工具类】

• ORM ：spring对orm的支持：

  • 既能够与hibernate整合，【session】
  • 也可使用spring的对hibernate操做的封装
• AOP ：切面编程
• SpringEE ：spring 对javaEE其余模块的支持

• core container（核心容器）

  • beans：全部应用都要用到的，它包含访问配置文件，建立和管理bean以及进行控制反转、依赖注入操做相关的全部类。
  • core核心模块：提供基本组成部分，包括ioc和Di包含Spring框架基本的核心工具类，Spring的其余组件都须要使用这个包里的类。
  • context上下文模块：访问定义和配置的任何对象的媒介Context模块构建于Core和Beans基础之上，提供了一种相似JNDI注册器的框架式的对象访问方法，Context继承了Beans的特性，为Spring核心提供了大量扩展，追加了对国际化、事件传播、资源加载和对Context的透明建立支持。
• aop模块：提供面向切面编程实现，定义方法拦截器和切入点。
• aspects模块：与aspectJ集成，AspectJ是面向切面框架。
• spring应用上下文，说的简单点就是容器的对象，是对spring容器抽象的实现

四、核心容器（应用上下文) 模块。

这是基本的Spring模块，提供spring 框架的基础功能，BeanFactory 是 任何以spring为基础的应用的核心。Spring 框架创建在此模块之上，它使Spring成为一个容器。

五、BeanFactory实现举例。

Bean 工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从正真的应用代码中分离。
最经常使用的BeanFactory 实现是XmlBeanFactory 类。

六、XMLBeanFactory

最经常使用的就是org.springframework.beans.factory.xml.XmlBeanFactory ，它根据XML文件中的定义加载beans。该容器从XML 文件读取配置元数据并用它去建立一个彻底配置的系统或应用。

七、解释AOP模块

AOP模块用于发给咱们的Spring应用作面向切面的开发， 不少支持由AOP联盟提供，这样就确保了Spring和其余AOP框架的共通性。这个模块将元数据编程引入Spring。

八、解释对象/关系映射集成模块。

Spring 经过提供ORM模块，支持咱们在直接JDBC之上使用一个对象/关系映射映射(ORM)工具，Spring 支持集成主流的ORM框架，如Hiberate，JDO和 iBATIS SQL Maps。Spring的事务管理一样支持以上全部ORM框架及JDBC。

九、解释WEB模块

Spring的WEB模块是构建在application context模块基础之上，提供一个适合web应用的上下文。这个模块也包括支持多种面向web的任务，如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业务对象。它也有对Jakarta Struts的支持。

十、Spring配置文件

Spring配置文件是个XML 文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用。

十一、ApplicationContext一般的实现是什么?

• FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
• ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你须要正确设置classpath由于这个容器将在classpath里找bean配置。
• WebXmlApplicationContext：此容器加载一个XML文件，此文件定义了一个WEB应用的全部bean。

十二、BeanFactory和ApplicationContexts有什么区别？

Application contexts提供一种方法处理文本消息，一个一般的作法是加载文件资源（好比镜像），它们能够向注册为监听器的bean发布事件。另外，在容器或容器内的对象上执行的那些不得不禁bean工厂以程序化方式处理的操做，能够在Application contexts中以声明的方式处理。Application contexts实现了MessageSource接口，该接口的实现以可插拔的方式提供获取本地化消息的方法。

1三、一个Spring的应用看起来象什么？

• 一个定义了一些功能的接口。
• 这实现包括属性，它的Setter ， getter 方法和函数等。
• Spring AOP。
• Spring 的XML 配置文件。
• 使用以上功能的客户端程序。

1四、FileSystemResource和ClassPathResource有何区别？

在FileSystemResource中须要给出spring-config.xml文件在你项目中的相对路径或者绝对路径。
在ClassPathResource中spring会在ClassPath中自动搜寻配置文件，因此要把ClassPathResource文件放在ClassPath下。
若是将spring-config.xml保存在了src文件夹下的话，只需给出配置文件的名称便可，由于src 文件夹是默认。
简而言之，ClassPathResource在环境变量中读取配置文件，FileSystemResource在配置文件中读取配置文件。

1五、怎么回答面试官：你对Spring的理解？

来源：
• https://www.zhihu.com/questio...
下面我就截几个答案：
1、

2、

1六、Spring的核心类有哪些，各有什么做用？

• BeanFactory：产生一个新的实例，能够实现单例模式
• BeanWrapper：提供统一的get及set方法
• ApplicationContext：提供框架的实现，包括BeanFactory的全部功能

1七、Spring 框架中都用到了哪些设计模式？

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

1、依赖注入

一、什么是Spring IOC 容器？

Spring IOC 负责建立对象，管理对象（经过依赖注入（DI），装配对象，配置对象，而且管理这些对象的整个生命周期。
Spring的IoC理解
（1）IOC就是控制反转。就是对象的建立权反转交给Spring，由容器控制程序之间的依赖关系，做用是实现了程序的解耦合，而非传统实现中，由程序代码直接操控。(依赖)控制权由应用代码自己转到了外部容器，由容器根据配置文件去建立实例并管理各个实例之间的依赖关系，控制权的转移，是所谓反转，而且由容器动态的将某种依赖关系注入到组件之中。BeanFactory 是Spring IoC容器的具体实现与核心接口，提供了一个先进的配置机制，使得任何类型的对象的配置成为可能，用来包装和管理各类bean。
（2）最直观的表达就是，IOC让对象的建立不用去new了，能够由spring自动生产，这里用的就是Java的反射机制，经过反射在运行时动态的去建立、调用对象。spring就是根据配置文件在运行时动态的去建立对象，并调用对象的方法的。
（3）Spring的IOC有三种注入方式 ：

• set方法注入；
• 构造方法进行注入；
• 注解进行注入。

详细的说：
（4）IoC，控制反转：将对象交给容器管理，你只须要在spring配置文件总配置相应的bean，以及设置相关的属性，让spring容器生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化以及装配好，而后在你须要调用的时候，就把它已经初始化好的那些bean分配给你须要调用这些bean的类。就是将对象的控制权反转给spring容器管理。
（5）DI机制（Dependency Injection，依赖注入）：能够说是IoC的其中一个内容，在容器实例化对象的时候主动的将被调用者（或者说它的依赖对象）注入给调用对象。好比对象A须要操做数据库，之前咱们老是要在A中本身编写代码来得到一个Connection对象，有了 spring咱们就只须要告诉spring，A中须要一个Connection，至于这个Connection怎么构造，什么时候构造，A不须要知道。在系统运行时，spring会在适当的时候制造一个Connection，而后像打针同样，注射到A当中，这样就完成了对各个对象之间关系的控制。

二、IOC的优势是什么？

IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试，单元测试再也不须要单例和JNDI查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。

三、请问什么是IoC和DI？而且简要说明一下DI是如何实现的？

IoC叫控制反转，是Inversion of Control的缩写，DI（Dependency Injection）叫依赖注入，是对IoC更简单的诠释。控制反转是把传统上由程序代码直接操控的对象的调用权交给容器，经过容器来实现对象组件的装配和管理。所谓的"控制反转"就是对组件对象控制权的转移，从程序代码自己转移到了外部容器，由容器来建立对象并管理对象之间的依赖关系。IoC体现了好莱坞原则 - "Don’t call me, we will call you"。依赖注入的基本原则是应用组件不该该负责查找资源或者其余依赖的协做对象。配置对象的工做应该由容器负责，查找资源的逻辑应该从应用组件的代码中抽取出来，交给容器来完成。DI是对IoC更准确的描述，即组件之间的依赖关系由容器在运行期决定，形象的来讲，即由容器动态的将某种依赖关系注入到组件之中。
一个类A须要用到接口B中的方法，那么就须要为类A和接口B创建关联或依赖关系，最原始的方法是在类A中建立一个接口B的实现类C的实例，但这种方法须要开发人员自行维护两者的依赖关系，也就是说当依赖关系发生变更的时候须要修改代码并从新构建整个系统。若是经过一个容器来管理这些对象以及对象的依赖关系，则只须要在类A中定义好用于关联接口B的方法（构造器或setter方法），将类A和接口B的实现类C放入容器中，经过对容器的配置来实现两者的关联。
依赖注入能够经过setter方法注入（设值注入）、构造器注入和接口注入三种方式来实现，Spring支持setter注入和构造器注入，一般使用构造器注入来注入必须的依赖关系，对于可选的依赖关系，则setter注入是更好的选择，setter注入须要类提供无参构造器或者无参的静态工厂方法来建立对象。

四、请说明一下springIOC原理是什么？若是你要实现IOC须要怎么作？请简单描述一下实现步骤？

IoC（Inversion of Control，控制倒转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来讲，就是由spring来负责控制对象的生命周期和对象间的关系。
IoC的一个重点是在系统运行中，动态的向某个对象提供它所须要的其余对象。这一点是经过DI（Dependency Injection，依赖注入）来实现的。好比对象A须要操做数据库，之前咱们老是要在A中本身编写代码来得到一个Connection对象，有了spring咱们就只须要告诉spring，A中须要一个Connection，至于这个Connection怎么构造，什么时候构造，A不须要知道。在系统运行时，spring会在适当的时候制造一个Connection，而后像打针同样，注射到A当中，这样就完成了对各个对象之间关系的控制。A须要依赖Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3以后一个重要特征是反射（reflection），它容许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是经过反射来实现注入的。
举个简单的例子，咱们找女友常见的状况是，咱们处处去看哪里有长得漂亮身材又好的女孩子，而后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，这个过程是复杂深奥的，咱们必须本身设计和面对每一个环节。传统的程序开发也是如此，在一个对象中，若是要使用另外的对象，就必须获得它（本身new一个，或者从JNDI中查询一个），使用完以后还要将对象销毁（好比Connection等），对象始终会和其余的接口或类藕合起来。
②实现IOC的步骤
定义用来描述bean的配置的Java类
解析bean的配置，將bean的配置信息转换为上面的BeanDefinition对象保存在内存中，spring中采用HashMap进行对象存储，其中会用到一些xml解析技术
遍历存放BeanDefinition的HashMap对象，逐条取出BeanDefinition对象，获取bean的配置信息，利用Java的反射机制实例化对象，將实例化后的对象保存在另一个Map中便可。

五、什么是Spring的依赖注入？

依赖注入，是IOC的一个方面，是个一般的概念，它有多种解释。这概念是说你不用建立对象，而只须要描述它如何被建立。你不在代码里直接组装你的组件和服务，可是要在配置文件里描述哪些组件须要哪些服务，以后一个容器（IOC容器）负责把他们组装起来。

六、有哪些不一样类型的IOC（依赖注入）方式？

• 构造器依赖注入：构造器依赖注入经过容器触发一个类的构造器来实现的，该类有一系列参数，每一个参数表明一个对其余类的依赖。
• Setter方法注入：Setter方法注入是容器经过调用无参构造器或无参static工厂 方法实例化bean以后，调用该bean的setter方法，即实现了基于setter的依赖注入。
• 工厂注入：这个是遗留下来的，不多用的了！

七、构造方法注入和设值注入有什么区别？

请注意如下明显的区别：
在设值注入方法支持大部分的依赖注入，若是咱们仅须要注入int、string和long型的变量，咱们不要用设值的方法注入。对于基本类型，若是咱们没有注入的话，能够为基本类型设置默认值。在构造方法注入不支持大部分的依赖注入，由于在调用构造方法中必须传入正确的构造参数，不然的话为报错。
设值注入不会重写构造方法的值。若是咱们对同一个变量同时使用了构造方法注入又使用了设置方法注入的话，那么构造方法将不能覆盖由设值方法注入的值。很明显，由于构造方法尽在对象被建立时调用。
在使用设值注入时有可能还不能保证某种依赖是否已经被注入，也就是说这时对象的依赖关系有多是不完整的。而在另外一种状况下，构造器注入则不容许生成依赖关系不完整的对象。
在设值注入时若是对象A和对象B互相依赖，在建立对象A时Spring会抛出sObjectCurrentlyInCreationException异常，由于在B对象被建立以前A对象是不能被建立的，反之亦然。因此Spring用设值注入的方法解决了循环依赖的问题，因对象的设值方法是在对象被建立以前被调用的。

八、哪一种依赖注入方式你建议使用，构造器注入，仍是Setter方法注入？

两种依赖方式均可以使用，构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。

九、请举例说明如何在Spring中注入一个Java Collection？

Spring提供了如下四种集合类的配置元素：

• <list> : 该标签用来装配可重复的list值。
• <set> : 该标签用来装配没有重复的set值。
• <map>: 该标签可用来注入键和值能够为任何类型的键值对。
• <props> : 该标签支持注入键和值都是字符串类型的键值对。

2、Spring Beans

一、什么是Spring beans?

Spring beans是那些造成Spring应用的主干的Java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans经过容器中配置的元数据建立。好比，以XML文件中<bean/>的形式定义。
这里有四种重要的方法给Spring容器提供配置元数据。
• XML配置文件。
• 基于注解的配置。
• 基于java的配置。
• Groovy DSL配置

Spring框架定义的beans都是单件beans。在bean tag中有个属性”singleton”，若是它被赋为TRUE，bean 就是单件，不然就是一个 prototype bean。默认是TRUE，因此全部在Spring框架中的beans 缺省都是单件。

二、一个Spring Bean定义包含什么？

一个Spring Bean 的定义包含容器必知的全部配置元数据，包括如何建立一个bean，它的生命周期详情及它的依赖。

三、如何给Spring容器提供配置元数据?

这里有三种重要的方法给Spring 容器提供配置元数据。
• XML配置文件。
• 基于注解的配置。
• 基于Java的配置。

四、你怎样定义类的做用域?

当定义一个<bean> 在Spring里，咱们还能给这个bean声明一个做用域。它能够经过bean 定义中的scope属性来定义。如，当Spring要在须要的时候每次生产一个新的bean实例，bean的scope属性被指定为prototype。另外一方面，一个bean每次使用的时候必须返回同一个实例，这个bean的scope 属性 必须设为 singleton。

五、解释Spring支持的几种bean的做用域。

Spring框架支持如下五种bean的做用域：
• singleton : bean在每一个Spring ioc 容器中只有一个实例。
• prototype：一个bean的定义能够有多个实例(每次从容器中调用Bean时，都会返回一个新的实例，prototype一般翻译为原型)。
• request：每次http请求都会建立一个bean，该做用域仅在基于web的Spring ApplicationContext情形下有效。
• session：在一个HTTP Session中，一个bean定义对应一个实例。该做用域仅在基于web的Spring ApplicationContext情形下有效。
• global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该做用域仅在基于web的Spring ApplicationContext情形下有效。
缺省的Spring bean 的做用域是Singleton.

六、Spring框架中的单例bean是线程安全的吗?

不，Spring框架中的单例bean不是线程安全的。

七、解释Spring框架中bean的生命周期。

（1）实例化一个Bean－－也就是咱们常说的new；
（2）按照Spring上下文对实例化的Bean进行配置－－也就是IOC注入；
（3）若是这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String)方法，此处传递的就是Spring配置文件中Bean的id值；
（4）若是这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory(setBeanFactory(BeanFactory)传递的是Spring工厂自身（能够用这个方式来获取其它Bean，只需在Spring配置文件中配置一个普通的Bean就能够）；
（5）若是这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文（一样这个方式也能够实现步骤4的内容，但比4更好，由于ApplicationContext是BeanFactory的子接口，有更多的实现方法）；
（6）若是这个Bean关联了BeanPostProcessor接口，将会调用postProcessBeforeInitialization(Object obj, String s)方法，BeanPostProcessor常常被用做是Bean内容的更改，而且因为这个是在Bean初始化结束时调用那个的方法，也能够被应用于内存或缓存技术；
（7）若是Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法。
（8）若是这个Bean关联了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法、；
注：以上工做完成之后就能够应用这个Bean了，那这个Bean是一个Singleton的，因此通常状况下咱们调用同一个id的Bean会是在内容地址相同的实例，固然在Spring配置文件中也能够配置非Singleton。
（9）当Bean再也不须要时，会通过清理阶段，若是Bean实现了DisposableBean这个接口，会调用那个其实现的destroy()方法；
（10）最后，若是这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

八、 哪些是重要的bean生命周期方法？你能重载它们吗？

有两个重要的bean 生命周期方法，第一个是setup ， 它是在容器加载bean的时候被调用。第二个方法是 teardown 它是在容器卸载类的时候被调用。
The bean 标签有两个重要的属性（init-method和destroy-method）。用它们你能够本身定制初始化和注销方法。它们也有相应的注解（@PostConstruct和@PreDestroy）。

九、什么是Spring的内部bean？

当一个bean仅被用做另外一个bean的属性时，它能被声明为一个内部bean，为了定义inner bean，在Spring 的 基于XML的 配置元数据中，能够在 <property/>或 <constructor-arg/> 元素内使用<bean/> 元素，内部bean一般是匿名的，它们的Scope通常是prototype。

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

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

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

十一、什么是bean装配?

装配，或bean 装配是指在Spring 容器中把bean组装到一块儿，前提是容器须要知道bean的依赖关系，如何经过依赖注入来把它们装配到一块儿。

十二、什么是bean的自动装配？

Spring 容器可以自动装配相互合做的bean，这意味着容器不须要<constructor-arg>和<property>配置，能经过Bean工厂自动处理bean之间的协做。

1三、解释不一样方式的自动装配

有五种自动装配的方式，能够用来指导Spring容器用自动装配方式来进行依赖注入。

• no：默认的方式是不进行自动装配，经过显式设置ref 属性来进行装配。
• byName：经过参数（bean）名 自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，以后容器试图匹配、装配和该bean的属性具备相同名字的bean。
• byType:：经过参数（bean）类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，以后容器试图匹配、装配和该bean的属性具备相同类型的bean。若是有多个bean符合条件，则抛出错误。
• constructor：这个方式相似于byType， 可是要提供给构造器参数，若是没有肯定的带参数的构造器参数类型，将会抛出异常。
• autodetect：首先尝试使用constructor来自动装配，若是没法工做，则使用byType方式。

自动装配没有自定义装配方式那么精确，并且不能自动装配简单属性（基本类型、字符串等），在使用时应注意。

1四、自动装配有哪些局限性 ?

自动装配的局限性是：

• 重写： 你仍需用 <constructor-arg>和 <property> 配置来定义依赖，意味着总要重写自动装配。
• 基本数据类型：你不能自动装配简单的属性，如基本数据类型，String字符串，和类。
• 模糊特性：自动装配不如显式装配精确，若是有可能，建议使用显式装配。

1五、你能够在Spring中注入一个null 和一个空字符串吗？

能够。

1六、Spring框架中的单例Beans是线程安全的么？

Spring框架并无对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题须要开发者自行去搞定。但实际上，大部分的Spring bean并无可变的状态(好比Serview类和DAO类)，因此在某种程度上说Spring的单例bean是线程安全的。若是你的bean有多种状态的话（好比 View Model 对象），就须要自行保证线程安全。
最浅显的解决办法就是将多态bean的做用域由“singleton”变动为“prototype”

3、Spring注解

一、什么是基于Java的Spring注解配置? 给一些注解的例子.

基于Java的配置，容许你在少许的Java注解的帮助下，进行你的大部分Spring配置而非经过XML文件。
以@Configuration 注解为例，它用来标记类能够当作一个bean的定义，被Spring IOC容器使用。另外一个例子是@Bean注解，它表示此方法将要返回一个对象，做为一个bean注册进Spring应用上下文。

二、 什么是基于注解的容器配置?

相对于XML文件，注解型的配置依赖于经过字节码元数据装配组件，而非尖括号的声明。
开发者经过在相应的类，方法或属性上使用注解的方式，直接组件类中进行配置，而不是使用xml表述bean的装配关系。

三、怎样开启注解装配？

注解装配在默认状况下是不开启的，为了使用注解装配，咱们必须在Spring配置文件中配置 <context:annotation-config/>元素。

四、@Required注解

这个注解代表bean的属性必须在配置的时候设置，经过一个bean定义的显式的属性值或经过自动装配，若@Required注解的bean属性未被设置，容器将抛出BeanInitializationException。

五、@Autowired注解

@Autowired 注解提供了更细粒度的控制，包括在何处以及如何完成自动装配。它的用法和@Required同样，修饰setter方法、构造器、属性或者具备任意名称和/或多个参数的PN方法。

六、@Qualifier注解

当有多个相同类型的bean却只有一个须要自动装配时，将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆，指定须要装配的确切的bean。

七、若是有请谈一下autowired 和resource区别是什么？

一、共同点
二者均可以写在字段和setter方法上。二者若是都写在字段上，那么就不须要再写setter方法。
二、不一样点
（1）@Autowired
@Autowired为Spring提供的注解，须要导入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入。
@Autowired注解是按照类型（byType）装配依赖对象，默认状况下它要求依赖对象必须存在，若是容许null值，能够设置它的required属性为false。若是咱们想使用按照名称（byName）来装配，能够结合@Qualifier注解一块儿使用。
（2）@Resource
@Resource默认按照ByName自动注入，由J2EE提供，须要导入包javax.annotation.Resource。@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。因此，若是使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。若是既不制定name也不制定type属性，这时将经过反射机制使用byName自动注入策略。

八、请说明一下@Controller和@RestController的区别是什么？

@RestController注解至关于@ResponseBody ＋ @Controller合在一块儿的做用

九、Resource 是如何被查找、加载的？

Resource 接口是 Spring 资源访问策略的抽象，它自己并不提供任何资源访问实现，具体的资源访问由该接口的实现类完成——每一个实现类表明一种资源访问策略。 Spring 为 Resource 接口提供了以下实现类：

• UrlResource：访问网络资源的实现类。
• ClassPathResource：访问类加载路径里资源的实现类。
• FileSystemResource：访问文件系统里资源的实现类。
• ServletContextResource：访问相对于 ServletContext 路径里的资源的实现类：
• InputStreamResource：访问输入流资源的实现类。
• ByteArrayResource：访问字节数组资源的实现类。 这些 Resource 实现类，针对不一样的的底层资源，提供了相应的资源访问逻辑，并提供便捷的包装，以利于客户端程序的资源访问。

4、Spring数据访问

一、解释JDBC抽象和DAO模块。

经过使用JDBC抽象和DAO模块，保证数据库代码的简洁，并能避免数据库资源错误关闭致使的问题，它在各类不一样的数据库的错误信息之上，提供了一个统一的异常访问层。它还利用Spring的AOP 模块给Spring应用中的对象提供事务管理服务。

二、在Spring框架中如何更有效地使用JDBC?

使用Spring JDBC框架，资源管理和错误处理的代价都会被减轻。因此开发者只需写statements 和 queries从数据存取数据，JDBC也能够在Spring框架提供的模板类的帮助下更有效地被使用，这个模板叫JdbcTemplate （例子见这里here）

三、JdbcTemplate

JdbcTemplate类提供了不少便利的方法解决诸如把数据库数据转变成基本数据类型或对象，执行写好的或可调用的数据库操做语句，提供自定义的数据错误处理。

四、Spring对DAO的支持

Spring对数据访问对象（DAO）的支持旨在简化它和数据访问技术如JDBC，Hibernate or JDO 结合使用。这使咱们能够方便切换持久层。编码时也不用担忧会捕获每种技术特有的异常。

五、使用Spring经过什么方式访问Hibernate?

在Spring中有两种方式访问Hibernate：

• 控制反转 Hibernate Template和 Callback。
• 继承 HibernateDAOSupport提供一个AOP 拦截器。

六、Spring支持的ORM

Spring支持如下ORM：

• Hibernate
• iBatis
• JPA (Java Persistence API)
• TopLink
• JDO (Java Data Objects)
• OJB

七、如何经过HibernateDaoSupport将Spring和Hibernate结合起来？

用Spring的 SessionFactory 调用 LocalSessionFactory。集成过程分三步：
• 配置the Hibernate SessionFactory。
• 继承HibernateDaoSupport实现一个DAO。
• 在AOP支持的事务中装配。

八、Spring支持的事务管理类型

Spring支持两种类型的事务管理：

• 编程式事务管理：这意味你经过编程的方式管理事务，给你带来极大的灵活性，可是难维护。
• 声明式事务管理：这意味着你能够将业务代码和事务管理分离，你只需用注解和XML配置来管理事务。

九、Spring框架的事务管理有哪些优势？

• 它为不一样的事务API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一个不变的编程模式。
• 它为编程式事务管理提供了一套简单的API而不是一些复杂的事务API如
• 它支持声明式事务管理。
• 它和Spring各类数据访问抽象层很好得集成。

十、你更倾向用那种事务管理类型？

大多数Spring框架的用户选择声明式事务管理，由于它对应用代码的影响最小，所以更符合一个无侵入的轻量级容器的思想。声明式事务管理要优于编程式事务管理，虽然比编程式事务管理（这种方式容许你经过代码控制事务）少了一点灵活性。

5、Spring面向切面编程（AOP）

一、解释AOP

面向切面的编程，或AOP， 是一种编程技术，容许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。

二、pring的AOP理解：

AOP，通常称为面向方面（切面）编程，做为面向对象的一种补充，用于解剖封装好的对象内部，找出其中对多个对象产生影响的公共行为，并将其封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），切面将那些与业务无关，却被业务模块共同调用的逻辑提取并封装起来，减小了系统中的重复代码，下降了模块间的耦合度，同时提升了系统的可维护性。可用于权限认证、日志、事务处理。
AOP实现的关键在于AOP框架自动建立的AOP代理，AOP代理主要分为静态代理和动态代理。静态代理的表明为AspectJ；动态代理则以Spring AOP为表明。
（1）AspectJ是静态代理的加强，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，所以也称为编译时加强，他会在编译阶段将AspectJ织入到Java字节码中，运行的时候就是加强以后的AOP对象。
（2）Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的所有方法，而且在特定的切点作了加强处理，并回调原对象的方法。
Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。JDK动态代理经过反射来接收被代理的类，而且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。
若是目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，能够在运行时动态的生成某个类的子类，注意，CGLIB是经过继承的方式作的动态代理，所以若是某个类被标记为final，那么它是没法使用CGLIB作动态代理的。

三、 AOP操做术语

链接点（Joinpoint）：程序执行的某个特定位置（如：某个方法调用前、调用后，方法抛出异常后）。一个类或一段程序代码拥有一些具备边界性质的特定点，这些代码中的特定点就是链接点。Spring仅支持方法的链接点。

切点（Pointcut）：若是链接点至关于数据中的记录，那么切点至关于查询条件，一个切点能够匹配多个链接点。Spring AOP的规则解析引擎负责解析切点所设定的查询条件，找到对应的链接点。
加强（Advice）：加强是织入到目标类链接点上的一段程序代码。Spring提供的加强接口都是带方位名的，如：BeforeAdvice、AfterReturningAdvice、ThrowsAdvice等。
引介（Introduction）：引介是一种特殊的加强，它为类添加一些属性和方法。这样，即便一个业务类本来没有实现某个接口，经过引介功能，能够动态的未该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。
织入（Weaving）：织入是将加强添加到目标类具体链接点上的过程，AOP有三种织入方式：①编译期织入：须要特殊的Java编译期（例如AspectJ的ajc）；②装载期织入：要求使用特殊的类加载器，在装载类的时候对类进行加强；③运行时织入：在运行时为目标类生成代理实现加强。Spring采用了动态代理的方式实现了运行时织入，而AspectJ采用了编译期织入和装载期织入的方式。
切面（Aspect）：切面是由切点和加强（引介）组成的，它包括了对横切关注功能的定义，也包括了对链接点的定义。

四、Aspect切面

AOP核心就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组API提供横切功能。好比，一个日志模块能够被称做日志的AOP切面。根据需求的不一样，一个应用程序能够有若干切面。在Spring AOP中，切面经过带有@Aspect注解的类实现。

五、在Spring AOP中，关注点和横切关注的区别是什么？

关注点是应用中一个模块的行为，一个关注点可能会被定义成一个咱们想实现的一个功能。横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，好比日志，安全和数据传输，几乎应用的每一个模块都须要的功能。所以这些都属于横切关注点。

六、链接点

链接点表明一个应用程序的某个位置，在这个位置咱们能够插入一个AOP切面，它其实是个应用程序执行Spring AOP的位置。

七、通知

通知是个在方法执行前或执行后要作的动做，其实是程序执行时要经过SpringAOP框架触发的代码段。
Spring切面能够应用五种类型的通知：

• before：前置通知，在一个方法执行前被调用。
• after: 在方法执行以后调用的通知，不管方法执行是否成功。
• after-returning: 仅当方法成功完成后执行的通知。
• after-throwing: 在方法抛出异常退出时执行的通知。
• around: 在方法执行以前和以后调用的通知。

八、切点

切入点是一个或一组链接点，通知将在这些位置执行。能够经过表达式或匹配的方式指明切入点。

九、什么是引入?

引入容许咱们在已存在的类中增长新的方法和属性。

十、什么是目标对象?

被一个或者多个切面所通知的对象。它一般是一个代理对象。也指被通知（advised）对象。

十一、什么是代理?

代理是通知目标对象后建立的对象。从客户端的角度看，代理对象和目标对象是同样的。

十二、有几种不一样类型的自动代理？

• BeanNameAutoProxyCreator
• DefaultAdvisorAutoProxyCreator
• Metadata autoproxying

1三、什么是织入。什么是织入应用的不一样点？

织入是将切面和到其余应用类型或对象链接或建立一个被通知对象的过程。
织入能够在编译时，加载时，或运行时完成。

1四、解释基于XML Schema方式的切面实现。

在这种状况下，切面由常规类以及基于XML的配置实现。

1五、解释基于注解的切面实现

在这种状况下(基于@AspectJ的实现)，涉及到的切面声明的风格与带有java5标注的普通java类一致。

参考资料：
https://segmentfault.com/a/11...
http://ifeve.com/spring-inter...