Spring面试题

目录
一、Spring工作原理 
二、为什么要用Spring
三、请你谈谈SSH整合
四、介绍一下Spring的事务管理
五、什么是依赖注入，依赖注入的作用是什么? 
六、什么是AOP，AOP的作用是什么? 
七、Spring中的BeanFactory与ApplicationContext的作用有哪些?
八、连接池
九、跨库事务

一、Spring MVC工作原理
1. 客户端请求提交到DispatcherServlet
2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller
3. DispatcherServlet将请求提交到Controller
4. Controller调用业务逻辑处理后，返回ModelAndView
5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图
6. 视图负责将结果显示到客户端

二、为什么要用Spring 
1、Spring能很好的与各大框架进行集成
2、创建对象时，如果我们不用spring需要用工厂模式来创建，这个spring相当于工厂模式已经帮我们做了创建对象的功能(IOC、依赖注入)。
3、在用Hibernate的时候，如果不用spring每次都要写事务的提交代码，有了spring可以通过AOP帮助我们管理事务 
4、面向切面编程（AOP）在要记录日志的时候添加一条记录后需要在数据里同时添加一条添加成功了或失败的记录，那么就可以用Spring的Aop来处理，虽然不用Aop也能做但是不用Spring的Aop就会写很多重复的代码。

三、请你谈谈SSH整合 
SSH：Struts（表示层）+Hibernate（持久层）+Spring（业务层）

a、Struts 
Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。
b、Hibernate 
Hibernate是一个持久层框架，它只负责与关系数据库的操作。
c、Spring 
Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

项目中为什么使用SSH？

1.使用struts是因为struts是基于MVC设计模式，很好的将应用程序进行了分层，使开发者更关注于业务逻辑的实现，此外，struts有着丰富的taglib标签，如能灵活运用可大大提高开发效率。

2.使用spring：因为spring是基于IOC（inversion of control 反向控制）和 AOP框架多层J2EE系统的框架，它不强迫你必须每层都使用spring，模块化好，允许根据自己的需要使用它的某一个模块。采用IOC可以很容易实现bean的装配，提供简洁的AOP并据此实现事务管理等。

3.使用hibernate：因为hibernate为java应用程序提供了一个易用的、高效率的对象关系映射框架，hibernate是一个轻量级的持久性框架，功能丰富。

四、介绍一下Spring的事务管理 
事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。这样可以防止出现脏数据，防止数据库数据出现问题。

开发中为了避免这种情况一般都会进行事务管理。Spring中也有自己的事务管理机制，一般是使用TransactionMananger进行管理，可以通过Spring的注入来完成此功能。

五、什么是依赖注入，依赖注入的作用是什么? 
IOC是一种思想，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IOC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

依赖注入的作用：减少类间耦合度，避免用new来创建对象

六、什么是AOP，AOP的作用是什么? 
AOP，面向切面编程，就是把可重用的功能提取出来，然后将这些通用功能在合适的时候织入到应用程序中，比如事务管理、权限控制、日志记录、性能统计等。

AOP的作用
AOP并没有帮助我们解决任何新的问题，它只是提供了一种更好的办法，能够用更少的工作量来解决现有的一些问题，使得系统更加健壮，可维护性更好。

七、Spring中的BeanFactory与ApplicationContext的作用有哪些?
1、BeanFactory负责读取bean的配置文件，管理bean的加载、实例化，维护bean之间的依赖关系，负责bean的生命周期。 
2、ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能： 
a. 国际化支持
b. 资源访问
c. 事件传递

八、连接池
c3p0、dbcp

九、跨库事务
Atomikos、jotm

十五、spring中的核心类有那些，各有什么作用? 

BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能 

九、解释一下Dependency injection(DI,依赖注入)和IOC(Inversion of control,控制反转)? 

依赖注入DI是一个程序设计模式和架构模型， 一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

二十、AOP里面重要的几个名词概念解释： 

切面（Aspect）： 一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。 

连接点（Joinpoint）： 在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。 在Spring AOP中，一个连接点 总是 代表一个方法的执行。 通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。 

通知（Advice）： 在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。 通知的类型将在后面部分进行讨论。许多AOP框架，包括Spring，都是以拦截器做通知模型， 并维护一个以连接点为中心的拦截器链。 

切入点（Pointcut）： 匹配连接点（Joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。 切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。 

引入（Introduction）： （也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。 例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。 

目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做 被通知（advised） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。 

AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。 注意：Spring 2.0最新引入的基于模式（schema-based）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。 

织入（Weaving）： 把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。 这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。 

通知的类型： 

前置通知（Before advice）： 在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。 

返回后通知（After returning advice）： 在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。 

抛出异常后通知（After throwing advice）： 在方法抛出异常退出时执行的通知。 

后通知（After (finally) advice）： 当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。 

环绕通知（Around Advice）： 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。 

环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架，例如Nanning和JBoss4，都只提供环绕通知。 

切入点（pointcut）和连接点（join point）匹配的概念是AOP的关键，这使得AOP不同于其它仅仅提供拦截功能的旧技术。 切入点使得定位通知（advice）可独立于OO层次。 例如，一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上（例如服务层的所有业务操作）。

17.hibernate的三种状态之间如何转换 ？

解析：hibernate有三种状态分别是：瞬时态 持久态  游离态

之间的转换：

瞬时态 到 持久态：执行save（）操作

持久态 到 瞬时态:  执行delete()操作

持久态 到 游离态： session关闭

游离态 到 持久态： upate() 方法

18.hibernate拒绝连接、服务器崩溃的原因？最少写5个

解析：1）数据库实例没有开

2）服务器没有开

3）网络连接错误

4）驱动包没有加

5）url 或其它配置出错

19.简要介绍Hibernate?

解析：hibernate是一个非常优秀的ORMapping的映射框架，对jdbc进行了轻量级的封装，是开发者可以通过操作对象来操作数据库，在hibernate中主要的接口有5个分别是

Seesion  SessionFactory Configruation Transaction Query

Seesion:主要是用来完成对数据库中的数据进行CRUD操作的。

SeesionFactory: 是储存数据库数据源，是一个重量级对象，一般在一个数据库就只会创建一个。

Configruation:是用于读取配置文件和映射文件的类，用于创建SeesionFactory

Query：是用于执行hql语句的核心对象

 

20Hibernate中主键的生成方式有？

1）assign ： 手工来配置主键

2）native： 自动生成主键，使用于mysql类似的数据库

3）sequence: 自动生成主键，使用于Oracle类似的数据库

4）increment: 自动通过程序来生成主键，适用于所有的数据库

5） uuid : 随机生成32位16进制的主键

 

21.hibernate的缓存机制？

解析：hibernate的缓存分为一级缓存和二级缓存；一级缓存也就是我们常说的seession缓存，它的生命周期伴随着session的消失而消失，而在程序中session肯定是要关闭的，所以这种缓存很少使用。二级缓存也称为seesionFactory缓存，也就是说伴随着sessionFactory来消失，而一般在sessionFactory只有一个所以不会随意关闭，所以有用，但默认情况下二级缓存是关闭的需要手工打开，并且还需要加上一些配置，常用的二级缓存包有两种一种是Ehcacahe,

另一种是oscache,我用过的是ehcache,要加入二级缓存需要做如下的配置：

1）在添加show_sql 的位置加入三个东西，这里我就不写了

2）在需要二级缓存的对象的映射文件中加入<cache value="">因为并不是所有的pojo都要二级缓存，否则服务器压力太大，所以需要的地方才加。这里就涉及到了缓存策略：

主要有 read-only:只读，即只能读取数据，而不能对数据进行修改，一般用在不经常改动的地方。

       read-write:可读写，这种灵活性虽然很大，但效率性能上其实不是很高

       nostritct-read-wirte:不严格的读写，这种是只你修改写入数据后，并不会立即更新，需要过一段时间，使用类似新闻这种，效率性能得到了提高，但是不精确

       traction：事务处理的，已经没用，被前面的替代了

3）在加入了缓存策略以后，然后拷贝一个ehcache的xml文件放到src下面

4）需要用到 query.setCacheable(true)  开启二级缓存。

22.Spring主要用来做什么？

解析：spring的主要功能就是：IOC和AOP

IOC：即控制反转，也就是通过一个配置文件在该配置文件中描述了对象和对象的属性信息，通过反射的方法来产生这个对象，并且通过IOC方式，如果配置文件中对象的属性带有值，也会一块为对象附上值，而这些值可以是基本数据类型也可以是引用数据类型，因此IOC也称为依赖注入。可以替代工厂类

AOP：面向切面的编程，在SSH中主要用来是实现动态的代理设计，也就是说将一系列相同的操作封装到一个规则类，在实现这个实现类的时候，先执行这个规则类的初始化操作，在回收进行相应的收尾操作，可以简化ServiceImpl操作。

23.spring中的哪个类的哪个方法可用于获取bean

解析：采用ApplicationContext ac = ClassPathXmlApplicationContext("applicationContext.xml");

        ac.getBean()的方法可以获取bean对象。

 

24.spring中可以用注入获得属性值，还有其他的方式吗？

 解析：也可以采用读取配置文件的方式获取属性值

 

25.spring在项目中如何充当粘合剂 ？

解析：比如在web层中我们只需要定义业务层的接口，但具体的实现类我交spring来依赖注入，这样可以很好的解决耦合的问题，另外spring的事务管理可以很好的对hibernate进行事务配置。这些都可以看出spring在项目中起着一种管理作用。

 

26.spring的事务如何配置 ？

解析：这个实际就是AOP怎么写的，这个太难了，等面试的前一天路上看一下就可以了。

 

27.在Spring中，transaction事务处理的实现有那两种方式？

解析：1.代码控制事务：即在程序中引入一个新的模板类，在这类中封装事务管理功能。

2.参数配置控制事务：在applicationContext.xml文件中增加一个事务代理配置

 

28.在Spring框架中，如何解决Web页面乱码问题？

解析：如果在在spring框架中解决乱码的问题，可以采用使用spring自带的一个CharacterEncodingFilter 这个类可以实现，需要在web.xml的Filter处进行配置。

 

29.在Struts中，如何实现防止表单的重复提交操作？

解析：采用的Token(指令牌)的方式，可以很好的解决重复提交的问题，它的原理是在你提交之前会在你Pre页面设置一个随机数的值，然后在你的jsp页面上也会有一个随机值，然后在提交的时候会取得去对比这两个值，如果相等就进行提交，提交后会改变Pre之中的那个随机值，但页面中的随机值没有变，这样当你下次再重复提交的时候就提交不成功了。

 

30.Struts的入口类？

解析：Struts的入口类就是ActionServlet,由这个核心类来控制所有路径分发。

 

31.写出你熟悉的开源框架以及各自的作用。

解析：常用的开源框架有：

Struts：统一管理提交的路径

Spring：实现IOC和起到解耦合的作用

Hibernate：实现对数据的持久化操作。

应用服务器有：Tomcat Jboss等

 

32.请写出spring中I0C的三种实现机制

解析：1.setter getter 方法注入  2.构造方法注入  3 接口注入

 

33.Spring框架的优点都有什么？

解析：1.Spring是分层架构的，你可以选择你需要的层进行管理，而不需要的层可以不关心。

2.Spring的IOC和AOP可以很大程度上简化代码。

3.Spring可以降低组件之间的耦合性。

4.Spring是开源免费的。

 

34.描述一下Spring中实现DI（Dependency Injection）的几种方式

解析：1.set get注入，即在实现类中定义出该属性，并实现set方法，然后在spring配置中进行set的注入

2.构造方法的注入  3.接口的注入

 

35.简述你对IoC（Inversion of Control）的理解

解析：所谓的IOC，即控制反转，它的意思个人理解就是说，假设有类A和接口B，现在在类A中我需要调用接口B中的方法，那么最简单的方法就是在类A中对接口B进行实例化出对象来，接口不能自己独立实例化，所以现在假设有子类C，然后直接用子类帮父类进行实例化，然后就可以调用接口B中的方法了，但是这样耦合性过大，依靠IOC的话，就在类A中只定义出接口B，但具体的实现类，是在在spring的配置中，通过注入的方法来为接口B将C注入成B的实例。这就是IOC依赖注入

36.Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法。

解析：比如SeesionFactory 的实现就是依靠的是注入方式和spring提供的方式，还有在DAO的实现类的时候会继承HibernateDAOSupport,然后获得super.getHiberanteTempalte() 这个核心对象，都体现了spring对Hibernate提供了很好的支持。

 

37.如何在Spring的applicationContext.xml里面使用JNDI而不是datasource?

解析：可以采用spring中提供的一个类：如下：

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">

   <property name="jndiName">

    <value>XXX</value>  具体的值记不住就算了  

   </property>

</bean>

 

38.Spring里面如何配置数据库驱动？

解析：

   <bean id="dataSource" class="org.apache.commons.jdbc.BaseDataSoruce">

       <property name="driveClassName" vlaue="org.gjt.mm.mysql.Driver">

       <property name="url"  value="jdbc:mysql://localhost:3306/ajax">

      <prorperty name="username" value="root" >

       <property name="password" value="tiger">

  </bean>

 

39.Spring里面applicationContext.xml文件能不能改成其他文件名？

解析：可以的，

对于struts1.x 而言它的DelegtaingRequestProcessor 默认情况下是会去加载applicationContext.xml,但是我们可以通过设置来改变设置ContextConfigLoaction来改变其位置。

如下：

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

   <set-property property="contextConfigLoacation" value="/WEB-INF/classes/applicationContext-*.xml">

</plug-in>

对于Sruts2.而言默认情况下它的ContextLoaderListener,是去WEB-INF下面找，但可以通过

<context-param>来改变

<cotext-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/classes/applicationContext-*.xml</param-value>

</context-param>

<listener>

  <listener-class>org.springframework.web.context.ContextLoaderListenter</listener-class>

</listener>

 

 

40.如何在web应用里面配置spring?

解析：在你web.xml中加上ContxtLoaderListener 即可，如下

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

41.Spring里面如何定义hibernate mapping？

解析，要在spring中定义映射文件，则需要在spring的核心配置文件中applicationContext.xml

中设置：

  <property name="mappingResources">

     <list>

       <value>cn/mdj/vo/User.hbm.xml </value>

     <list>

  </property>

42.解释一下Dependency injection(DI,依赖注入)和IOC(Inversion of control,控制反转)?

解析：DI依赖注入应该是IOC控制反转的一个特例，因为控制反转的时候设置的值除基本数据类型外也可以是引用数据类型，而引用数据类型的时候，通常喜欢称为DI。

 

43.spring中的BeanFactory与ApplicationContext的作用和区别？

解析：BeanFactory 应该属于 ApplicationContext

功能上来讲：BeanFactory 主要是完成: 对bean配置文件的读取，加载，管理，实例化，维护等操作。

ApplicationContext:除了可以完成BeanFactory能完成的操作外还可以完成其他的操作：

如果国际化，事务，资源访问等。

注：

常用的获取ApplicationContext的方法：
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件

 

44.如何配置spring+struts?

解析：前面有这里就不再说了

 

45.spring的jdbc与传统的jdbc有什么区别，其核心类有那些?

解析：spring的jdbc,相对于传统jdbc而言，不需要在写DatabaseConnection数据库连接类，而且在DAO实现类的操作上，传统的JDBC依靠的是PreparedStatement 和Connection类在进行对数据库的操作，而在Spring+jdbc方式上操作的核心类是继承了JdbcDAOSupport的类，用的操作数据库的核心对象是super.getJdbcTemplate()

 

46.spring的配置的主要标签是什么?有什么作用?

<beans>
<bean id=”” class=”” init=”” destroy=”” singleton=””>
<property name=””>
<value></value>
</property>
<property name=””>
<ref local></ref>
</property>
</bean>
</beans>

 

47.Spring如何实现资源管理?

applicationContext.getResource(“classpath:文件名”):在src根目录下，在类路径下
applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目录下的基准往下走。
applicationContext.getResource(“file:c:/a.properties”)：在系统文件目录下。

 

48.Spring中ApplicationContext的作用是什么？

解析：

beanFactory
国际化(getMesage)
资源管理:可以直接读取一个文件的内容(getResource)
加入web框架中(加入一个servlet或监听器)
事件处理

 

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

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

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

 

50.请介绍一下Spring框架中Bean的生命周期

解析：

1）Spring通常通过配置文件定义Bean

2）初始化Bean。 通过方法或则通过接口

3）Bean的调用 。通过BeanFactoy 或则 ApplicationContext

4）Bean的销毁 。通过方法或则接口来实现

 

51.spring工作原理

解析：

1）springmvc将所有请求都提交给DispatchServlet,它委托其它模块来完成对请求的处理过程。

2）DispatchServlet会去寻找一个或多个的HandlerMapping,然后找到Controller

3）DispatchServlet请请求提交到目标Controller

4）Controller在处理完业务后会返回一个ModerAndView

5）DispatchServlet会去查找一个或多个ViewResover视图解析器，去找到ModerAndView的视图对象。

6）然后有这个视图对象来进行渲染返回客户端。

 

52.介绍一下Spring的事务管理：

解析：

事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。

spring提供了几个关于事务处理的类：

TransactionDefinition //事务属性定义

TranscationStatus //代表了当前的事务，可以提交，回滚。

 

53.

 

综合：

一、Spring基础知识及IOC_选择题

1. 下面关于spring描述错误的是：（ ）

A  Spring支持可插入的事务管理器，使事务划分更轻松，同时无需处理底层的问题。

B  Spring事务管理的通用抽象层还包括JTA策略和一个JDBC DataSource。

C  与JTA或EJB CMT一样，Spring的事务支持依赖于Java EE环境。

D  Spring事务语义通过AOP应用于 POJO，通过XML或Java SE 5注释进行配置。

参考答案：C

2. 下面选项哪个不是Spring中接口注入的方式？（ ）

A  接口注入　　

B  构造子注入　　

C  设值注入　　

D  指针注入

参考答案：D

3. 下列关于Spring特性中IoC描述错误的是：（）

A  IoC就是指程序之间的关系由程序代码直接操控。

B  所谓“控制反转”,是指控制权由应用代码转到外部容器，控制权的转移，

C  IoC将控制创建的职责搬进了框架中；并把它从应用代码脱离开来

D  当使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC容器会根据XML配置数据提供给它。

参考答案：A

 二、Spring基础知识及IOC_简答题

 

1. 请简述Spring的工作机制？

参考答案：Spring的工作机制可从以下几点来描述：（1）spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。 （2）DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller。（3）DispatcherServlet请请求提交到目标Controller （4）Controller进行业务逻辑处理后，会返回一个ModelAndView （5）Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象（6）视图对象负责渲染返回给客户端。

2. 请回答你为什么用Spring的工作机制？

参考答案：Spring能有效的组织你的中间层对象，不管你是否选择使用了EJB。如果你仅仅使用了strus或其他为j2ee的API特性的framework，spring致力于解决剩下的问题。Spring能够消除在许多工程中常见的对singleton的过多的使用。这个是一个很大的问题，它降低了系统的可测试性和面向对象的程度。通过把对接口编程而不是对类编程的代价几乎减少到没有，spring能够促进良好的变成习惯的养成。

3. 请简述Spring是什么？

参考答案：Spring是一个轻型的容器，是J2EE规范的轻量级实现，是企业应用的“一站式”解决方案。其中的核心就是bean工厂，用以构造我们需要的Model，spring是非侵入式的，Spring的应用中的对象不依赖于Spring的特定类。

4. 简述spring的组成？

参考答案：Spring主要由以下六个部分组成① Spring Core：核心容器，BeanFactory提供了组件生命周期的管理，组件的创建，装配，销毁等功能。SpringContext：ApplicationContext，扩展核心容器，提供事件处理、国际化等功能。它提供了一些企业级服务的功能，提供了JNDI，EJB，RMI的支持。② Spring AOP：提供切面支持。③ Spring DAO：提供事务支持，JDBC，DAO支持。④ Spring ORM：对流行的O/R Mapping封装或支持。⑤Spring Web：提供Web应用上下文，对Web开发提供功能上的支持，如请求，表单，异常等。⑥ Spring Web MVC：全功能MVC框架，作用等同于Struts。

5.简述Spring容器提供了哪些功能？

参考答案：Spring容器提供了对对象的管理，如Spring容器负责生成、组装、销毁组件，，另外Spring容器还提供了对持久化的支持，对事务的支持。另外Spring容器提供了国际化等功能。

6. 在Spring中，bean的注入有几种方式，各是什么？

参考答案：Spring中，Bean的注入有两中方式，分别是Setter注入和构造器注入。

7. 请简述：Spring bean的作用域？

参考答案：在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称prototype）, Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。当然，Spring2.0对Bean的类型的设计进行了重构，并设计出灵活的Bean类型支持，理论上可以有无数多种类型的Bean，用户可以根据自己的需要，增加新的Bean类型，满足实际应用需求。

8. 请叙述设值注入的优点？

参考答案：设置注入的优点：（1）与传统的JavaBean的写法更相似，程序开发人员更容易了解和接受。通过setter方法设定依赖关系显得更加直观、自然。（2）对于有复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。Spring在创建bean实例时，需要同时实例化其依赖的全部实例，因而导致性能的下降，而使用设值注入能够解决这些问题。（3）尤其是某些属性可选的情况下，多参数的构造器更加笨重。

9. 请叙述构造注入的优点？

参考答案：构造注入的优点：（1）可以在构造器中决定依赖关系的注入顺序，优先依赖的优先注入。（2）对于依赖关系无须变化的bean，构造注入更加有用处。因为没有setter方法，所有的依赖关系全部在构造器内设定，因此，无须担心后续的代码对依赖关系产生破坏。（3）依赖关系只能在构造器中设定，则只有组建的创建者才能改变组建的依赖关系。对组建的调用者而言，组建内部的依赖关系完全透明，更符合高内聚的原则。

10. 说出bean工厂创建bean的三种方式？

参考答案:Bean工厂创建bean的三种方式分别是：

（1）直接构造，需要一个default constructor和相应的setters/getters方法。

要注意的是,我们可以为getter/setter方法传递参数(用preperties标签),也可以为构造函数传递参数

（2）采用静态工厂方法，如:

<bean id="exampleBean"class="examples.ExampleBean2"

factory-method="createInstance"/>

这里要求examples.ExampleBean2类有个静态方法createInstance

（3）非静态工厂方法

<bean id="myFactoryBean" class="..."> </bean>

<bean id="exampleBean"

 factory-bean="myFactoryBean" factory-method="createInstance"/>

在这里,必须没有class标签,factory-bean是BeanFactory,factory-method是它的非静态方法，myFactoryBean可以通过容器来管理和配置。

11. 请写出bean的生命周期的方法？

参考答案：（1）通过设置bean的init-method属性指定初始化的方法，他的限制是方法无法接受任何参数，方法可以为static。（2）实现InitializingBean接口的afterPrioertiesSet（）方法。（3）销毁对象可以通过disposableBean的destroy的实现。

12. 请简述你对IOC的理解？

参考答案：IOC即Inversion of Control，就是反转控制，Ioc将控制创建的职责搬进了框架之中，并把它从应用代码中分隔开来，使用Ioc容器则需要指出组件需要什么对象在运行时容器会提供给它，容器是通过查看对象的参数表做到的，也可能根据配置数据如xml。

13. 请回答：IoC最大的好处是什么？

参考答案：IoC最大的好处是降低了对象的耦合性，实现了应用的松散耦合。因为把对象生成放在了XML里定义，所以当我们需要换一个实现子类将会变成很简单（一般这样的对象都是现实于某种接口的），只要修改XML就可以了。

14. 简述IoC的类型？

参考答案：IOC可以分为三种注入类型，分别是构造函数注入、属性注入和接口注入。Spring主要支持构造函数注入和属性注入。

 

15. Spring中依赖注入与传统编程之间的差别是什么？

参考答案：在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转；创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。依赖注入的主要作用是起到解耦合的作用。

 

三、.AOP_简答题

 

 

1. 说出Spring的通知类型有哪些？

参考答案：Spring的通知类型有(1) MethodBeforeAdvice  (2) AfterReturningAdvice  (3) MethodInterceptor (4)ThrowsAdvice

2. 谈谈目标对象实现接口与目标对象不实现接口有什么区别？

参考答案：目标对象实现接口与目标对象不实现接口主要有以下几点区别：

（1）如果目标对象实现了接口,默认采用JDK的动态代理机制实现AOP

（2）如果目标对象实现了接口,可以强制spring采用CGLIB实现代理

（3） 如果目标对象没有实现接口,必须采用CGLIB实现代理,spring会自动的在CGLIB和JDK动态代理之间切换

3. 请描述JDK动态代理和CGLI代理的区别？

参考答案：JDK 的动态代理只能对实现了接口的目标类进行代理，而不实现接口的类就不能使用 JDK 的动态代理 CGLIB 是针对类来实现代理，当没有实现接口的类需要代理时就需要通过 CGLIB 来实现代理了，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但是因为采用的是继承，所以不能对 finall 类进行继承。二者在某些特殊场合需混合使用

4. 简述ProxyFactoryBean的作用是什么？

参考答案：ProxyFactoryBean的作用是依照配置信息，将切面应用到目标对象，生成动态代理对象。

5. 叙述Spring中的自动代理的原理？

参考答案：Spring在生成代理对象的时候，默认情况下，会使用被代理对象的接口来生成代理对象。如果被代理对象没有实现接口，此时，Spring会使用CGLIB生成代理对象，此时该代理对象是被代理对象的子类。

5. 写出创建代理对象需指定的三要素是什么？

参考答案：创建代理对象需要指定的三要素是：target：设定目标对象（只能是一个）；proxyInterfaces：设定代理接口（目标对象所实现的接口）；interceptorNames：设定拦截器的名字（各个advice或advisor bean的列表）

6. 写出代理的两种方式分别是什么？

参考答案：代理的两种方式是：静态代理和动态代理，其中静态代理针对每个具体类分别编写代理类；针对一个接口编写一个代理类。而动态代理针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理

7. 请简述：什么是AOP？

参考答案：将程序中的交叉业务逻辑提取出来，称之为切面。将这些切面动态织入到目标对象，然后生成一个代理对象的过程。

8. 简述AOP核心？

参考答案：AOP核心主要包括以下内容：（1）Aspect（切面），（2）Joinpoint（连接点），（3）Advice（通知），（4）Pointcut（切入点），（5）Introduction（引入），（6）Weaving（织入），（7）Target（目标对象），（8）Proxy（代理对象）

9. 请叙述AOP事务的含义？

参考答案：Spring中进行事务管理的通常方式是利用AOP（面向切片编程）的方式，为普通java类封装事务控制，它是通过动态代理实现的，由于接口是延迟实例化的，spring在这段时间内通过拦截器，加载事务切片。

 

四、Spring对持久化的支持_简答题

1. 请叙述Spring对持久层支持所采用的策略？

参考答案：Spring对持久层采取了很好的支持，这些支持策略主要有：（1）Spring对持久层“不发明重复的轮子”，即没有重新实现新的持久层方案，对现有持久层方案做封装，更利于使用。（2）采用DAO模式。（3）提供了大量的模板类来简化编程（HibernateDaoSupport，JdbcTemplate等）（4）重新设计了一套完善的异常体系结构：① 类型丰富，细化异常类型。② 全都是运行时异常（RuntimeException）。

2. 请问Spring如何简化事务配置？

参考答案：pring简化事务配置有两种方式：第一种方式就是使用TransactionProxyFactoryBean创建事务代理（通常事务代理以Service层为目标bean）配置hibernate的事务管理器，使用HibernateTransactionManager类，该类实现了PlatformTransactionManager接口,针对hibernate 持久化连接的特定实现。第二种方式使用自动创建代理简化事务配置使用BeanNameAutoProxyCreator和DefaultAdvisorAutoProxyCreator创建代理时，并不一定是创建事务代理，关键在于传入的拦截器，如果传入事务拦截器，将可自动生成事务代理

3. 请简述Spring的事务机制？

参考答案：Spring对事务的支持很丰富，除了编程式的处理事务，Spring还支持声明式事务。其次Spring使用事务服务代理和事务管理器（如HibernateTransactionManager）来支持事务服务。另外Spring对事务的边界多了一种嵌套事务。

4．请回答：Spring API中的getCurrentSession()和openSession()两个方法的区别？

参考答案：getCurrentSession()和openSession()两个方法主要有两点的区别：（1）采用getCurrentSession（）创建的session会绑定到当前线程中，而采用openSession（）创建的session则不会。（2）采用getCurrentSession（）创建的session在commit或者rollback后会自动关闭，而采用openSession的方式需要手动进行关闭。

5. 请叙述Spring中使用Hibernate事务的步骤？

参考答案：Spring中使用Hibernate事务的步骤为：（1）配置数据源 （2）配置sessionfactory  （3）配置事务管理器 （4）创建事务服务代理

6. 请叙述关于Spring的声明式事务处理？

参考答案：Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。我们在使用Spring声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。

7. 请叙述Spring的事务传播属性与隔离级别？

参考答案：在使用Spring时，大部分会用到他的声明式事务，简单的在配置文件中进行一些规则配置，利用Spring的AOP功能就能轻松搞定事务问题；这里面就涉及到一个事务的传播属性问题Propagation，它在TransactionDefinition接口中定义，以供PlatfromTransactionManager使用,PlatfromTransactionManager是spring事务管理的核心接口。

在TransactionDefinition接口中定义了五个不同的事务隔离级别，ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应，ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。

 

五、Spring+Struts+Hibernate

1. Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法，并结合事务管理？

参考答案：Hibernate是最优秀的ORM框架，Spring对其提供了很好的支持，那么在Spring中使用Hibernate时要：（1）为每一个bean写hibernate映射文件，配置datasourse，hibernateDaoTemplate，sessionFactory，把datasourse和映射文件注入到sessionFactory （2）每个dao都继承spring容器中提供的一个类HibernateDaoSupport，为每个dao注入hibernateDaoTemplate（3）在dao中使用getHibernateDaoTemplate（）的方法。Spring中可以把需要进行事务控制的Biz注入到transactionProxy，为biz方法配置transactionAttribute

2．请比较一下Spring framework与Struts？

参考答案：Struts只是一个MVC框架（Framework），用于快速的开发Java Web应用。Struts实现的重点在C（Controller），包括Actionservlet/RequestProcessor和我们定制的Action，也为V（View）提供了一系列的标签（Custom Tag）。而Spring是一个轻型容器，其中核心是bean工厂（beanfactory），用以构造我们所需要的Model。在此基础上，spring提供了AOP（面向切面编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便我们实现j2ee的应用；Dao/ORM的实现方便我们进行数据库的开发；Web MVC和Spring Web提供了java Web应用的框架或与其他流行的Web框架进行集成。两者进行结合在一起使用是最好的方式。

3. 请叙述编写业务逻辑的方法？

参考答案：继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是Hibernate Session的轻量级封装。默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的。编写业务逻辑方法时，最好将异常一直向上抛出，在表示层（struts）处理。关于事务边界的设置，通常设置到业务层，不要添加到Dao上。

4. 在Web分层架构中业务层为什么都选择Spring？

参考答案：因为Service层需要处理业务逻辑和交叉业务逻辑，处理事务，日志，安全等，而这些与Spring的IoC特性，AOP等不谋而合。