spring题库

1.谈谈你对MVC的理解：

解析：MVC是一种设计模式,是将输入，输出，控制进行了分离。

M：(mode)即模型层：用于对数据的持久化操作，也可以说是表示业务数据和业务处理的，一个模型层可以为多个视图层提供数据，提高了重用性。

V:(view)即：视图层，是用于展示的，也就是说想用户显示相关数据和接受用户输入数据。

C：control即控制层，是用于连接模型层和视图层的中间层，可以很好的解决耦合问题。控制层将视图层接受到的数据交给控制层，有控制层调用模型层来完成相关处理，模型层处理完后，然后通过控制层想展示层显示结果。

2.Struts1.x和Struts2.x的区别？

解析：

1）Struts1.x是由W3C组织提供的框架，Struts2.x原名是webwork，后有W3C收购而该名

2）Struts1.x的提交路径是*.do ;Struts2.x 提交路径是*.action

3）Struts1.x中统一管理提交路径的核心类是ActionServlet,Struts2.x中统一管理提交路径的是核心是Filter

4）Struts1.x中有ActionForm Struts2.x中没有ActionForm只有Action

5）Struts1.x 要依赖Servlet API,每个excute方法都会带上HttpSerrvletRequest 和 response 将其进行了暴露，Struts2.x中不依赖于Servlet,这样可以不必要的去放访问这连个，当然也提供了方法来得到request和response，提供的类为ServletActionContext 可以去获取request和response

3.项目中为什么要使用SSH?

解析：SSH分别代表Struts Spring Hibernate，

首先如果使用了Struts，那么Struts是MVC设计模式的一种很好的体现，会将这个应用程序的输入，输出，控制进行很好的分离，使得开发者更多的关注业务逻辑的实现，第二点在于使用Struts后，Struts提供了大量的taglib，如果很好的使用这些标签库可以很大的提高开发效率。

其次Hibernate是一个很好ORMaping框架，可以通过操作类来改变数据库中表，并且其完全自动化的操作很好的节省了开发的时间，不像JDBC方式中采用PreparedStament那样一个一个set get那样处理过于冗余，所以如果不是对性能很高的要求，使用hibernate是个不错的选择。

最后Spring,主要体现在IOC和AOP；即控制反转和面向切面的编程，利用IOC和很容易为实现类中注入bean对象；利用AOP可以很容易的实现事务处理方面的操作。

综合而言:SSH使用与否取决于项目和公司的进度而定。

4.Struts和Spring是如何整合的？

解析：Struts有Strust1.x版本和Struts2.x版本，两个结合Spring的方式有点不同；

如果是Struts1.3结合Spring3.0，那么就需要在Struts的核心配置文件struts-config.xml中进行一些配置：

（1）需要加载IOC容器，也就说需要一个ContextLoadPlugIn,即需要下面的配置：

<plug-inclassName="org.springframework.web.struts.ContextLoaderPlugIn"><set-property properrty="ContextConfigLocation" value="/WEB-INF/classes/application-context.xml">

</set-property>

</plug-in>

（2）需要替换委托处理器，在没有用spring的情况下，action的创建是由RequestProcessor来处理完成的，而如果用了Spring后，应该叫Spring来管理这个action的创建，所以需要一个处理器替换即配置：

<controllerprocessName="org.springframework.web.struts.DelegatingRequestProcessor"></controller>

如果是struts2.x去结合spring，也要完成类似的操作，只不过是写在了web.xml而不是struts2的核心文件struts.xml中，需要的做的工作仍然是：

1.加载IOC容器：只不过不是plug-in 插件而是：

<context-param>

<param-name>ContextConfigLocation</param-name>

<param-value>/WEB-INF/classes/appliactionContext.xml</param-value>

</context-param>

2.替换委托处理器，变成了监听器

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

</listener>

5.Struts如何实现国际化？

解析：Struts1.x中实现国际化靠的是bean标签中的<bean-message key="" />标签来实现的，

其中key的内容对应国际化中不同的资源文件中的key.

Struts2.x实现国际化同样首先需要定义多个同文件名但不同的资源文件。然后依靠的是Struts标签库中的:<s:i18n name=""></s:i18n> 和<s:text name=""></s:text>实现。

i18n 中name对应的资源文件名 text中的name对应key值。

6.logic的标签有那几个？

分为条件循环跳转

条件如：logic:present 循环如：<logic:iterate name="" id="" ></logic:iterate> 跳转：logic:forward

7.Struts中的action是单实例还是多实例的？

解析：单实例的，当多个用户去访问一个请求的时候，在服务器内存中只有一个与之对应的action对象。

因为当服务器加载strtus配置的时候就会创建一个action，那么以后的没发送一个请求过来，服务器都会去检索是否存在一个action与此请求对应，如果有就会直接使用这个action，而不会再去创建新的action，所以是单实例的。

8.DispatchAction是用什么技术实现的？

解析：DispatchAction 是Action的一个子类，主要是用来实现分发的，即一个action可以处理多个功能。普通的Action，在处理业务的时候只能写在execute方法中，但是有了分发的DispatchAction，相同的业务就可以放到同一个action中了，便于管理，实现的技术仍然是action的技术，但多传递了一个参数即status状态参数。

10Sturts2 和 Struts1. 的不同点主要在？

解析：不同主要在处理的核心类：Struts1.x和核心处理类是ActionServlet Struts2.x的核心类主要是Filter;其它的不同点，找前面的回答即可。

11.Struts的工作流程？

解析：

Struts1.x的工作流程：

*.jsp 提交---》根据路径*.do找打对应的ActionServlet,ActionServlet在初始化的时候会去加载核心配置文件struts-config.xml，然后反射创建ActionForm 和Action ，首先进入的是ActionForm,ActionForm负责接收参数，和参数的基本验证，当参数验证未通过的时候，会根据return errors,找到配置中input,对应的路径，跳转到错误页。当验证通过会进入action，执行逻辑判断和页面的跳转，依靠的是mapping.findForward(),对应于配置中的<forward>路径。

Struts2.x的工作流程：

*.jsp页面提交--》提交的路径是/*，但路径的后缀为*.action-->找到对应的Filter-->过滤器会进行路径分配，符合的进入action中，在action中主要有validate来进行参数的验证，这个action必须去继承一个类ActionSupport类，验证不通过同样找到input来进行错误页跳转，通过进入execute方法继续操作，跳转路径通过<result>来配置。

12.什么是Hibernate的并发机制？怎么去处理并发问题?

解析：hibernate的并发机制主要体现在两个方面：

1）hibernate的session是非线程安全的，对于单个请求，单个回话，单元的操作完成之后，这个session就丢弃了，如果将Hibernate的session进行共享，那么就可以实行并发了。

2）多个事务对同一资源的访问也可以实现并发，但这样会带来资源的错乱，因此要解决资源错乱，即处理并发的问题：

1）设置事务的隔离级别：

serializabled 串行化最高

Repeatedable 可重复读

Commit reader 已提交的读

Uncommit reader 未提交的读

2）加锁有乐观锁和悲观锁

乐观硕的性能要比悲观锁的并发并能高

13.Hibernate 与 JDBC的联系？

解析：简单的来讲：hibernate = jdbc的封装+xml文件。因为hibernate实质是将jdbc进行了轻量级的封装，包括jdbc的数据库连接已经sql语句CRUD封装成了HQL语句，对数据库表的查询该成了对类的查询。

14. Hibernate与Spring的联系？

解析：hibernate于spring的联系反映在hibernate的一些对象交给了spring来管理创建，比如hibernate的数据库连接类，不需要单独去建立，有spring来注入完成，以及想dao层的hibernateTemplate ，sessionFactory都有spring来完成管理，即依赖注入的关系。

15.Hibernate自带的分页机制是什么？如果不使用Hibernate自带的分页，则采用什么方式分页？

解析：hibernate的自带分页机制的实现依靠的是在获取到session对象以后，创建出query对象，然后依靠query.setFirstResult() 来设置显示的第一条 query.setMaxResults() 来最后一条数据。如果不依赖这种分页，还可以采用sql的方式实现分页，即执行createSqlQuery也可以实现分页。

16.update（）和saveOrUpdate（）的区别？

解析：update 和 savaOrUpdate 都是session对pojo的操作，但不同点在于，update修改的数据必须在数据库存在，savaOrupdate可以在数据库没有这条数据，没有的是候会执行保存操作。

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中提供的一个类：如下：

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

</property>

</bean>

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

解析：

</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-class>org.springframework.web.context.ContextLoaderListenter</listener-class>

</listener>

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

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

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

</listener>

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

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

中设置：

<list>

<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的配置的主要标签是什么?有什么作用?

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="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等不谋而合。