【整理】SpringMvc+Spring+Hibernate面试题

柔情只为你懂 2022-04-14 04:13 259阅读 0赞

## SpringMVC部分 ##

**1、什么是Spring MVC ？简单介绍下你对springMVC的理解?**

> Spring MVC是一个基于MVC架构的用来简化web应用程序开发的应用开发框架，它是Spring的一个模块,无需中间整合层来整合 ，它和Struts2一样都属于表现层的框架。在web模型中，MVC是一种很流行的框架，通过把Model，View，Controller分离，把较为复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。

**2、SpringMVC的流程？（重点）**

> （1）用户发送请求至前端控制器DispatcherServlet；  
> （2） DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；  
> （3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；  
> （4）DispatcherServlet通过HandlerAdapter处理器适配器调用处理器；  
> （5）执行处理器(Handler，也叫后端控制器)；  
> （6）Handler执行完成返回ModelAndView；  
> （7）HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；  
> （8）DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；  
> （9）ViewResolver解析后返回具体View；  
> （10）DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）  
> （11）DispatcherServlet响应用户。

**3、Springmvc的优点**

> （1）它是基于组件技术的。全部的应用对象,无论控制器和视图,还是业务对象之类的都是 java组件.并且和Spring提供的其他基础结构紧密集成.
> 
> （2）不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的)
> 
> （3）可以任意使用各种视图技术,而不仅仅局限于JSP
> 
> （4） 支持各种请求资源的映射策略
> 
> （5）它应是易于扩展的

**4、SpringMVC怎么样设定重定向和转发的？**

> （1）在返回值前面加"forward:"就可以让结果转发,譬如"forward:user?name=method4"
> 
> （2）在返回值前面加"redirect:"就可以让返回值重定向,譬如"redirect:http://www.baidu.com"

**5、如何解决POST请求中文乱码问题，GET的又如何处理呢？**

> （1）解决post请求乱码问题：
> 
> 在web.xml中加入：
> 
> <filter>
> 
>     <filter-name>CharacterEncodingFilter</filter-name>
> 
>     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
> 
>     <init-param>
> 
>         <param-name>encoding</param-name>
> 
>         <param-value>utf-8</param-value>
> 
>     </init-param>
> 
> </filter>
> 
> <filter-mapping>
> 
>     <filter-name>CharacterEncodingFilter</filter-name>
> 
>     <url-pattern>/\*</url-pattern>
> 
> </filter-mapping>
> 
> （2）get请求中文参数出现乱码解决方法有两个：
> 
> ①修改tomcat配置文件添加编码与工程编码一致，如下：
> 
> <ConnectorURIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
> 
>  ②另外一种方法对参数进行重新编码：
> 
> String userName = new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")
> 
> ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码。

**6、SpringMvc的控制器是不是单例模式,如果是,有什么问题,怎么解决？**

> 是单例模式,所以在多线程访问的时候有线程安全问题,不要用同步,会影响性能的,解决方案是在控制器里面不能写字段。

**7、SpingMvc中的控制器的注解一般用那个,有没有别的注解可以替代？**

> 一般用@Conntroller注解,表示是表现层,不能用用别的注解代替。

**8、 @RequestMapping注解用在类上面有什么作用？**

> 是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

**9、如果在拦截请求中,我想拦截get方式提交的方法,怎么配置？**

> 可以在@RequestMapping注解里面加上method=RequestMethod.GET。

**10、怎么样在方法里面得到Request,或者Session？**

> 直接在方法的形参中声明request,SpringMvc就自动把request对象传入。

**11、谈谈你mvc的理解**

> MVC是Model—View—Controler的简称。即模型—视图—控制器。MVC是一种设计模式，它强制性的把应用程序的输入、处理和输出分开。
> 
>     MVC中的模型、视图、控制器它们分别担负着不同的任务。
> 
>     视图: 视图是用户看到并与之交互的界面。视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业务逻辑处理。
> 
>     模型: 模型表示业务数据和业务处理。相当于JavaBean。一个模型能为多个视图提供数据。这提高了应用程序的重用性
> 
>     控制器: 当用户单击Web页面中的提交按钮时,控制器接受请求并调用相应的模型去处理请求。
> 
>             然后根据处理的结果调用相应的视图来显示处理的结果。
> 
>     MVC的处理过程：首先控制器接受用户的请求，调用相应的模型来进行业务处理，并返回数据给控制器。控制器调用相应的视图来显示处理的结果。并通过视图呈现给用户。

### \-------------------------------------------------------------------------------------------------------------------------- ###

### Hibernate部分 ###

**1、 Hibernate工作原理及为什么要用？（重）**

> 1.  读取并解析配置文件
> 2.  读取并解析映射信息，创建SessionFactory
> 3.  打开Sesssion
> 4.  创建事务Transation
> 5.  持久化操作
> 6.  提交事务
> 7.  关闭Session
> 8.  关闭SesstionFactory
> 
> 为什么要用：   
> 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
> 
> 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
> 
> 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
> 
> 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

** 2、什么是Hibernate的并发机制？怎么去处理并发问题？**

> Hibernate并发机制：
> 
> a、Hibernate的Session对象是非线程安全的,对于单个请求,单个会话,单个的工作单元(即单个事务,单个线程),它通常只使用一次, 然后就丢弃。
> 
> 如果一个Session 实例允许共享的话，那些支持并发运行的,例如Http request,session beans将会导致出现资源争用。 
> 
> 如果在Http Session中有hibernate的Session的话,就可能会出现同步访问Http Session。只要用户足够快的点击浏览器的“刷新”,  就会导致两个并发运行的线程使用同一个Session。  
> 
> b、多个事务并发访问同一块资源,可能会引发第一类丢失更新，脏读，幻读，不可重复读，第二类丢失更新一系列的问题。
> 
> 解决方案：设置事务隔离级别。   
> Serializable：串行化。隔离级别最高   
> Repeatable Read：可重复读   
> Read Committed：已提交数据读   
> Read Uncommitted：未提交数据读。隔离级别最差   
> 设置锁：乐观锁和悲观锁。   
> 乐观锁：使用版本号或时间戳来检测更新丢失,在的映射中设置 optimistic-lock=”all”可以在没有版本或者时间戳属性映射的情况下实现 版本检查，此时Hibernate将比较一行记录的每个字段的状态 行级悲观锁：Hibernate总是使用数据库的锁定机制，从不在内存中锁定对象！只要为JDBC连接指定一下隔 离级别，然后让数据库去搞定一切就够了。类LockMode 定义了Hibernate所需的不同的锁定级别：LockMode.UPGRADE,LockMode.UPGRADE\_NOWAIT,LockMode.READ;

**3、update和saveOrUpdate的区别？ **

> update()和saveOrUpdate()是用来对跨Session的PO进行状态管理的。   
> update()方法操作的对象必须是持久化了的对象。也就是说，如果此对象在数据库中不存在的话，就不能使用update()方法。   
> saveOrUpdate()方法操作的对象既可以使持久化了的，也可以使没有持久化的对象。如果是持久化了的对象调用saveOrUpdate()则会 更新数据库中的对象；如果是未持久化的对象使用此方法,则save到数据库中。

**4、hibernate的三种状态之间如何转换 **

>     当对象由瞬时状态(Transient)一save()时，就变成了持久化状态。
> 
>     当我们在Session里存储对象的时候，实际是在Session的Map里存了一份，
> 
>     也就是它的缓存里放了一份，然后，又到数据库里存了一份，在缓存里这一份叫持久对象(Persistent)。
> 
>     Session 一 Close()了，它的缓存也都关闭了，整个Session也就失效了，
> 
>     这个时候，这个对象变成了游离状态(Detached)，但数据库中还是存在的。
> 
>     当游离状态(Detached)update()时，又变为了持久状态(Persistent)。
> 
>     当持久状态(Persistent)delete()时，又变为了瞬时状态(Transient),
> 
>     此时，数据库中没有与之对应的记录。

**5、什么是SessionFactory,它是线程安全么？**

> SessionFactory 是Hibrenate单例数据存储和线程安全的，以至于可以多线程同时访问。一个SessionFactory 在启动的时候只能建立一次。SessionFactory应该包装各种单例以至于它能很简单的在一个应用代码中储存.

**6、Hibernate的五个核心接口 **

> Configuration 接口：配置Hibernate，根据其启动hibernate，创建   
> SessionFactory 对象；   
> SessionFactory 接口：初始化Hibernate，充当数据存储源的代理，创建   
> session 对象，sessionFactory 是线程安全的，意味着它的同一个实例可以被应   
> 用的多个线程共享，是重量级、二级缓存；   
> Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，   
> 避免多个线程共享同一个session，是轻量级、一级缓存；   
> Transaction 接口：管理事务；   
> Query 和Criteria 接口：执行数据库的查询。

**7、 hibernate如何管理缓存**

> Hibernate 中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存可以进行配置和更改，并且可以动态加载和卸载。 Hibernate还为查询结果提供了一个查询缓存，它依赖于第二级缓存。
> 
> 　　1. 一级缓存和二级缓存的比较：第一级缓存 第二级缓存 存放数据的形式 相互关联的持久化对象 对象的散装数据 缓存的范围 事务范围，每个事务都有单独的第一级缓存进程范围或集群范围，缓存被同一个进程或集群范围内的所有事务共享 并发访问策略由于每个事务都拥有单独的第一级缓存，不会出现并发问题，无需提供并发访问策略由于多个事务会同时访问第二级缓存中相同数据，因此必须提供适当的并发访问策略，来保证特定的事务隔离级别 数据过期策略没有提供数据过期策略。处于一级缓存中的对象永远不会过期，除非应用程序显式清空缓存或者清除特定的对象必须提供数据过期策略，如基于内存的缓存中的对象的最大数目，允许对象处于缓存中的最长时间，以及允许对象处于缓存中的最长空闲时间 物理存储介质内存内存和硬盘。对象的散装数据首先存放在基于内在的缓存中，当内存中对象的数目达到数据过期策略中指定上限时，就会把其余的对象写入基于硬盘的缓存中。缓存的软件实现 在Hibernate的Session的实现中包含了缓存的实现由第三方提供，Hibernate仅提供了缓存适配器(CacheProvider)。用于把特定的缓存插件集成到Hibernate中。启用缓存的方式只要应用程序通过Session接口来执行保存、更新、删除、加载和查询数据库数据的操作，Hibernate就会启用第一级缓存，把数据库中的数据以对象的形式拷贝到缓存中，对于批量更新和批量删除操作，如果不希望启用第一级缓存，可以绕过Hibernate API，直接通过JDBC　API来执行指操作。用户可以在单个类或类的单个集合的粒度上配置第二级缓存。如果类的实例被经常读但很少被修改，就可以考虑使用第二级缓存。只有为某个类或集合配置了第二级缓存，Hibernate在运行时才会把它的实例加入到第二级缓存中。 用户管理缓存的方式第一级缓存的物理介质为内存，由于内存容量有限，必须通过恰当的检索策略和检索方式来限制加载对象的数目。Session的evit()方法可以显式清空缓存中特定对象，但这种方法不值得推荐。 第二级缓存的物理介质可以是内存和硬盘，因此第二级缓存可以存放大量的数据，数据过期策略的maxElementsInMemory属性值可以控制内存中的对象数目。管理第二级缓存主要包括两个方面：选择需要使用第二级缓存的持久类，设置合适的并发访问策略：选择缓存适配器，设置合适的数据过期策略。
> 
> 　　2. 一级缓存的管理： 当应用程序调用Session的save()、update()、savaeOrUpdate()、get()或load()，以及调用查询接口的 list()、iterate()或filter()方法时，如果在Session缓存中还不存在相应的对象，Hibernate就会把该对象加入到第一级缓存中。当清理缓存时，Hibernate会根据缓存中对象的状态变化来同步更新数据库。 Session为应用程序提供了两个管理缓存的方法： evict(Object obj)：从缓存中清除参数指定的持久化对象。 clear()：清空缓存中所有持久化对象。
> 
> 　　3. 二级缓存的管理：
> 
> 　　3.1. Hibernate的二级缓存策略的一般过程如下：
> 
> 　　1) 条件查询的时候，总是发出一条select \* from table\_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。
> 
> 　　2) 把获得的所有数据对象根据ID放入到第二级缓存中。
> 
> 　　3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。
> 
> 　　4) 删除、更新、增加数据的时候，同时更新缓存。
> 
> 　　Hibernate的二级缓存策略，是针对于ID查询的缓存策略，对于条件查询则毫无作用。为此，Hibernate提供了针对条件查询的Query Cache。
> 
> 　　3.2. 什么样的数据适合存放到第二级缓存中？ 1 很少被修改的数据 2 不是很重要的数据，允许出现偶尔并发的数据 3 不会被并发访问的数据 4 参考数据,指的是供应用参考的常量数据，它的实例数目有限，它的实例会被许多其他类的实例引用，实例极少或者从来不会被修改。
> 
> 　　3.3. 不适合存放到第二级缓存的数据？ 1 经常被修改的数据 2 财务数据，绝对不允许出现并发 3 与其他应用共享的数据。
> 
> 　　3.4. 常用的缓存插件 Hibernater 的二级缓存是一个插件，下面是几种常用的缓存插件：
> 
> 　　EhCache：可作为进程范围的缓存，存放数据的物理介质可以是内存或硬盘，对Hibernate的查询缓存提供了支持。
> 
> 　　OSCache：可作为进程范围的缓存，存放数据的物理介质可以是内存或硬盘，提供了丰富的缓存数据过期策略，对Hibernate的查询缓存提供了支持。
> 
> 　　SwarmCache：可作为群集范围内的缓存，但不支持Hibernate的查询缓存。
> 
> 　　JBossCache：可作为群集范围内的缓存，支持事务型并发访问策略，对Hibernate的查询缓存提供了支持。
> 
> 　　3.5. 配置二级缓存的主要步骤：
> 
> 　　1) 选择需要使用二级缓存的持久化类，设置它的命名缓存的并发访问策略。这是最值得认真考虑的步骤。
> 
> 　　2) 选择合适的缓存插件，然后编辑该插件的配置文件。

** 8、 Hibernate 的检索方式有哪些 ?**

> ① 导航对象图检索   
> ② OID检索   
> ③ HQL检索   
> ④ QBC检索   
> ⑤ 本地SQL检索

**9、load()和get()的区别  **

> ①：如果数据库中，没有 OID 指定的对象。通过 get方法加载，则返回的是一个null；通过load加载，则返回一个代理对象，如果后面代码如果调用对象的某个属性会抛出异常：org.hibernate.ObjectNotFoundException；  
> ②：load 支持延迟加载，get不支持延迟加载。

**10、什么是懒加载？他的作用？ **

> 延迟加载，也叫懒加载，它是hibernate为提高程序执行效率而提供的一种机制，即只有真正使用该对象的数据时才会创建。
> 
> Hibernate中主要是通过代理（proxy）机制来实现延迟加载。它的具体过程：Hibernate从数据库获取某一个对象数据时、获取某一个对象的集合属性值时，或获取某一个对象所关联的另一个对象时，由于没有使用该对象的数据，hibernate并不是数据库加载真正的数据，而只是为该对象创建一个代理对象来代表这个对象，这个对象上的所有属性都是默认值；只有在真正需要使用该对象的数据时才创建这个真实对象，真正从数据库中加载它的数据，这样在某些情况下，就可以提高查询效率。

**-----------------------------------------------------------------------------------------------------------------------------------------------------------------------**

### Spring部分  ###

**1、Spring是什么？根据你的理解详细谈谈你的见解。**

> ◆目的：解决企业应用开发的复杂性
> 
> 　　◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
> 
> 　　◆范围：任何Java应用
> 
> 　　简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
> 
> 　　◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
> 
> 　　◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
> 
> 　　◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
> 
> 　　◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
> 
> 　　◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
> 
> 　　所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

**2、** **使用Spring的好处**

> AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。
> 
> IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。
> 
> Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。

**3、Spring的优点？**

> 1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦   
> 2.可以使用容易提供的众多服务，如事务管理，消息服务等   
> 3.容器提供单例模式支持   
> 4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能   
> 5.容器提供了众多的辅助类，能加快应用的开发   
> 6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等   
> 7.spring属于低侵入式设计，代码的污染极低   
> 8.独立于各种应用服务器   
> 9.spring的DI机制降低了业务对象替换的复杂性   
> 10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring 的部分或全部

**4、Spring管理事务有几种方式？**

> 有两种方式：
> 
> 1、编程式事务，在代码中硬编码。(不推荐使用)
> 
> 2、声明式事务，在配置文件中配置（推荐使用）
> 
> 声明式事务又分为两种：
> 
> a、基于XML的声明式事务
> 
> b、基于注解的声明式事务

**5、spring中自动装配的方式有哪些？**

> 1、 No：即不启用自动装配。
> 
> 2、 byName：通过属性的名字的方式查找JavaBean依赖的对象并为其注入。比如说类Computer有个属性printer，指定其autowire属性为byName后，Spring IoC容器会在配置文件中查找id/name属性为printer的bean，然后使用Seter方法为其注入。
> 
> 3、 byType：通过属性的类型查找JavaBean依赖的对象并为其注入。比如类Computer有个属性printer，类型为Printer，那么，指定其autowire属性为byType后，Spring IoC容器会查找Class属性为Printer的bean，使用Seter方法为其注入。
> 
> 4、 constructor：通byType一样，也是通过类型查找依赖对象。与byType的区别在于它不是使用Seter方法注入，而是使用构造子注入。
> 
> 5、 autodetect：在byType和constructor之间自动的选择注入方式。
> 
> 6、 default：由上级标签<beans>的default-autowire属性确定。

**6.什么是IOC，什么又是DI，他们有什么区别？**

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

**7.spring有两种代理方式**

> 若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。
> 
>       优点：因为有接口，所以使系统更加松耦合
> 
>       缺点：为每一个目标类创建接口
> 
> 若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。
> 
>       优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。
> 
>       缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好。

**7、解释Spring支持的几种bean的作用域。**

> Spring容器中的bean可以分为5个范围：
> 
> （1）singleton：这种bean范围是默认的，这种范围确保不管接受到多少个请求，每个容器中只有一个bean的实例，单例的模式由bean factory自身来维护。  
> （2）prototype：原形范围与单例范围相反，为每一个bean请求提供一个实例。  
> （3）request：在请求bean范围内会每一个来自客户端的网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。  
> （4）Session：与请求范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。  
> （5）global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

**8、Spring中bean的加载过程**

> （1）获取配置文件资源；
> 
> （2）对获取的xml资源进行一定的处理检验；
> 
> （3）处理包装资源；
> 
> （4）解析处理包装过后的资源；
> 
> （5）加载提取bean并注册(添加到beanDefinitionMap中)。

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

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

**10、Spring事务的实现方式和实现原理**

> （1）划分处理单元——IOC：
> 
> 由于spring解决的问题是对单个数据库进行局部事务处理的，具体的实现首相用spring中的IOC划分了事务处理单元。并且将对事务的各种配置放到了ioc容器中（设置事务管理器，设置事务的传播特性及隔离机制）。
> 
> （2）AOP拦截需要进行事务处理的类：
> 
> Spring事务处理模块是通过AOP功能来实现声明式事务处理的，具体操作（比如事务实行的配置和读取，事务对象的抽象），用TransactionProxyFactoryBean接口来使用AOP功能，生成proxy代理对象，通过TransactionInterceptor完成对代理方法的拦截，将事务处理的功能编织到拦截的方法中。 
> 
> 读取ioc容器事务配置属性，转化为spring事务处理需要的内部数据结构（TransactionAttributeSourceAdvisor），转化为TransactionAttribute表示的数据对象。 
> 
> （3）对事物处理实现（事务的生成、提交、回滚、挂起）：
> 
> spring委托给具体的事务处理器实现。实现了一个抽象和适配。适配的具体事务处理器：DataSource数据源支持、hibernate数据源事务处理支持、JDO数据源事务处理支持，JPA、JTA数据源事务处理支持。这些支持都是通过设计PlatformTransactionManager、AbstractPlatforTransaction一系列事务处理的支持。为常用数据源支持提供了一系列的TransactionManager。
> 
> （4）结合：
> 
> PlatformTransactionManager实现了TransactionInterception接口，让其与TransactionProxyFactoryBean结合起来，形成一个Spring声明式事务处理的设计体系。

**11、解释一下Spring AOP里面的几个名词**

> （1）切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。
> 
> （2）连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。 在Spring AOP中，一个连接点 总是 代表一个方法的执行。 通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。
> 
> （3）通知（Advice）：在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。 通知的类型将在后面部分进行讨论。许多AOP框架，包括Spring，都是以拦截器做通知模型， 并维护一个以连接点为中心的拦截器链。
> 
> （4）切入点（Pointcut）：匹配连接点（Joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。 切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
> 
> （5）引入（Introduction）：（也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。
> 
> （6）目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做 被通知（advised） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。
> 
> （7）织入（Weaving）：把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。 这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。
> 
> 切入点（pointcut）和连接点（join point）匹配的概念是AOP的关键，这使得AOP不同于其它仅仅提供拦截功能的旧技术。 切入点使得定位通知（advice）可独立于OO层次。 例如，一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上（例如服务层的所有业务操作）。

**12、通知有哪些类型？**

> （1）前置通知（Before advice）：在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。
> 
> （2）返回后通知（After returning advice）：在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。   
> （3）抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。   
> （4）后通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。   
> （5）环绕通知（Around Advice）：包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。   
> 环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架，例如Nanning和JBoss4，都只提供环绕通知。