SSH中一些典型的问题

struts2

1-1：为什么每次请求都要创建一个Action对象？  

是出于对线程安全的考虑，每个request都不会相互影响

1-2：ModelDriven拦截器的配置中refreshModelBeforeResult解决了什么问题？  

先把旧的model对象从ValueStack中移除，然后再把新的model对象压入ValueStack！

官方解释：

set to true if you want the model to be refreshed on the value stack after action execution and before result execution. The setting is useful if you want to change the model instance during the action execution phase, like when loading it from the data layer. This will result in getModel() being called at least twice.

一般不需要配，顺便骂句谁出的这么坑爹的问题。

1-3：为什么在web.xml中配置的StrutsPrepareAndExecuteFilter要过滤所有的请求？

其实这里可以选择性的过滤，但是一般大家都是/*,所有的请求都必须经过StrutsPrepareAndExecuteFilter这个请求转发器。

它会去找struts.xml文件，一般放在src下面的第一层目录，然后找到相应的资源去转发。

1-4：请你给我谈谈ValueStack？     

所谓值栈就是在一个栈里面堆了一大坨的数值，在action中可以这样获得ValueStack vs1 = ActionContext.getContext().getValueStack();

其实值栈就类似于一个map的容器，里面存放的是键值对，但是有个区别，这个值栈的键都是String类型的。我们一般可以这样来拿出值栈里面的内容

名字属性获取 : 也可以用el表达式${aa}或者ognl表达式

其中ognl表达式主要就是去访问值栈，它的查找路线为用于按request > session > application顺序访问其属性（attribute），#user.username相当于按顺序在以上三个范围（scope）内读取user.username属性，直到找到为止

1-5：Struts2是如何实现MVC设计模式的？  

自己去理解，按自己的request走一遍就知道了。不懂MVC还用STRUTS?

 

Spring

2-1：你为什么要用Spring？ 
XXX，为什么要用？好用才用的啊。spring有很多作用比如他的安全机制，事务管理,日志管理等等。。最主要的是把耦合度降到最低。
2-2：请你聊一聊IOC/DI？ 
把工厂和对象生成这两者独立分隔开来，提高灵活性和可维护性。具体的太多了。
2-3：什么是声明式的事务管理？为什么要使用声明式的事务管理？Spring如何实现声明式的事务管理？ 
Spring 的声明式事务管理在底层是建立在 AOP 的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。 
使用声明式的事务管理可重用性高。这里就列举一种最常用的配置吧。

Xml代码  

1. <</span>bean id="dataSource"  
2.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
3.         <</span>property name="driverClassName" value="${jdbc.driverClassName}" />  
4.         <</span>property name="url" value="${jdbc.url}" />  
5.         <</span>property name="username" value="${jdbc.username}" />  
6.         <</span>property name="password" value="${jdbc.password}" />  
7.     </</span>bean>  
8.     <</span>bean id="transactionManager"  
9.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
10.         <</span>property name="sessionFactory">  
11.             <</span>ref local="sessionFactory" />  
12.         </</span>property>  
13.     </</span>bean>  
14.       
15.       
16.     <</span>bean id="nativeJdbcExtractor" lazy-init="true"  
17.         class="org.springframework.jdbc.support.nativejdbc.SimpleNativeJdbcExtractor" />  
18.     <</span>bean id="lobHandler" lazy-init="true"  
19.         class="org.springframework.jdbc.support.lob.OracleLobHandler">  
20.         <</span>property name="nativeJdbcExtractor">  
21.             <</span>ref bean="nativeJdbcExtractor" />  
22.         </</span>property>  
23.     </</span>bean>  
24.       
25.       
26.     <</span>bean id="sessionFactory"  
27.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
28.         <</span>property name="dataSource" ref="dataSource" />  
29.         <</span>property name="lobHandler" ref="lobHandler" />  
30.         <</span>property name="mappingDirectoryLocations">  
31.             <</span>list>  
32.                 <</span>value>classpath*:XXX</</span>value>  
33.             </</span>list>  
34.         </</span>property>  
35.         <</span>property name="hibernateProperties">  
36.             <</span>props>  
37.                  
38.                 <</span>prop key="hibernate.dialect">${hibernate.dialect}</</span>prop>  
39.                 <</span>prop key="hibernate.show_sql">${hibernate.show_sql}</</span>prop>  
40.                 <</span>prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</</span>prop>  
41.                 <</span>prop key="hibernate.default_schema">${hibernate.default_schema}</</span>prop>  
42.             </</span>props>  
43.         </</span>property>  
44.     </</span>bean>  
45.     <</span>bean id="txProxyTemplate" abstract="true"  
46.         class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
47.         <</span>property name="transactionManager">  
48.             <</span>ref local="transactionManager"></</span>ref>  
49.         </</span>property>  
50.         <</span>property name="transactionAttributes">  
51.             <</span>props>  
52.                 <</span>prop key="save*">PROPAGATION_REQUIRED,-exception</</span>prop>  
53.                 <</span>prop key="update*">PROPAGATION_REQUIRED,-exception</</span>prop>  
54.                 <</span>prop key="delete*">PROPAGATION_REQUIRED,-exception</</span>prop>  
55.                 <</span>prop key="*">PROPAGATION_REQUIRED,readOnly</</span>prop>  
56.             </</span>props>  
57.         </</span>property>  
58.     </</span>bean>  

 2-4：把spring和hibernate集成，定义事务管理特性的时候，为何要将除了添加、删除、更新操作之外的方法，即主要执行 查询任务的方法定义为read-only？ 
应用这项属性时，底层的数据库可以对读取进行最优化，但要配合PROPAGATION_REQUIRED，PROPAGATION_REQUIRES_NEW或PROPAGATION_NESTED使用，即只能在事物中使用。简单的说就是增快查询速度。

Hibernate

3-1：请你谈谈你对OR映射的理解？ 
对象关系映射，把关系数据库的数据结构与你的对象关联起来，以操作对象操纵关系数据库。
3-2：很多人说Hibernate不适合大项目，性能有问题，你是如何理解的？ 
好不好是看你怎么用，不一定用了hibernate就不使用sql了，一些复杂的 比如说统计需要的数据一般都是直接用sql去执行的。使用hibernate最重要的一点是
看你如何去使用懒加载，在适当的时候使用懒加载会提高你的性能。
3-3：Hibernate为什么一定要定义一个数据库标识 ？ 
因为要对应数据库表的主键，唯一性原则。
3-4：为什么Hibernate建议你的实体类实现hashCode和equals方法？ 
多对多双向关系，如果hashCode和equals正常写之，将出现load不上的问题。
经常使用set集合来保存相关对象，而set集合是不允许重复的。而hibernate正是去"=="比较两个对象是否是同一个，所以它会去比较hashCode和用equals来比较。
3-5：谈谈你对Hibernate实体类中的数据库标识与数据库主键之间关系的认识？ 
是对象与关系数据库中的表识别的唯一标识。
3-6：谈谈你对Hibernate关联映射与数据库外键之间关系的认识？ 
关系映射中一个外键就相当于一个对象的实例，这样就形成了1-1 ，1-N，N-1，N-N这种关系。
3-7：调用session.save()方法，hibernate一定会发出insert语句吗？谈谈你的理解 
save, 把一个瞬态的实例持久化标识符，及时的产生,它要返回标识符，在save之前hibernate会去根据主键查一次，看能否保存。
3-8：调用session.update()方法，hibernate一定会发出update语句吗？谈谈你的理解 
update是把一个脱管状态的对象或自由态对象（一定要和一个记录对应）更新到数据库。在update之前hibernate会去根据主键查一次，看能否可以更新。
3-9：请你聊一下以下名词、概念或用法：lazy、lazy=”extra”、inverse、fetch、fetch=”join”、fetch=”subselect”、batch-size 
lazy概念：只有真正使用该对象内普通属性时，才会创建，对于hibernate而言，正真使用的时候才会发出sql，load支持lazy（懒加载），get不支持懒加载。
extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate
lazy=”extra”时并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据。
inverse – 标记由哪一方来维护关联关系（双向关联中会用到，inverse默认值为false。如果inverse设置为true，表示将由对方维护两者之间的关联关系。
fetch是抓取策略：
fetch = "select"是在查询的时候先查询出一端的实体，然后在根据一端的查询出多端的实体，会产生1+n条sql语句;
fetch = "join"是在查询的时候使用外连接进行查询，不会差生1+n的现象
fetch=”subselect”发送一条select语句抓取在前面查询到的所有实体对象的关联集合

batch-size 

是来设置批量更新的HQL/SQL数量 如果达到此数量会提交给数据库 但是生成的HQL/SQL语句一个也不会少
3-10：配置了lazy=”true”一定会实现懒加载吗？ 
get()是不能实现懒加载的。必须使用load()。fetch要使用select 
3-11：请你谈谈Hibernate中的“N+1”问题 
一对多是查询一次会带出N次查询。就是一些主外键关系的对象。当进行一个表的查询时，当这个表与另外的表是多对一，或者是一对多关联时，就会出现N+1问题，当查询一条语句时，比如主键name=1,而与这个 name相关联的另一张表对应name的有N个记录，这时就出另外发出N条语句去查询，而我又不要那些记录，这时就是N+1问题。