按顺序依次为

秒（0~59）

    它有两种配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具体参看SpringSide)，功能相同，只是一个在web.xml配置，另一个在application.xml配置而已。

    Open Session In View在request把session绑定到当前thread期间一直保持hibernate session在open状态，使session在request的整个期间都可以使用，如在View层里PO也可以lazy loading数据，如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。 

OpenSessionInViewInterceptor配置

<beans>
   <bean name="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
         <property name="sessionFactory">
         <ref bean="sessionFactory"/>
    </property>
   </bean>
   <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
       <property name="interceptors">
         <list>
            <ref bean="openSessionInViewInterceptor"/>
       </list>
     </property>
     <property name="mappings">
     ... 
    </property>
   </bean> ...
</beans> 

OpenSessionInViewFilter配置

<web-app>
 ... 
  <filter>
     <filter-name>hibernateFilter</filter-name>
     <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter </filter-class>
     <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
    <init-param>
       <param-name>singleSession</param-name>
       <param-value>true</param-value>
    </init-param>
  </filter>
 ... 
  <filter-mapping>
     <filter-name>hibernateFilter</filter-name>
     <url-pattern>*.do</url-pattern>
   </filter-mapping>
 ... 
</web-app> 

很多人在使用OpenSessionInView过程中提及一个错误：

org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into FlushMode.AUTO or remove 'readOnly' marker from transaction definition 

看看OpenSessionInViewFilter里的opensession方法

protected Session openSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException ...{
    Session session = SessionFactoryUtils.getSession(sessionFactory, true);
    session.setFlushMode(FlushMode.NEVER);
    return session;
}

    可以看到OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。然后把该sessionFactory绑定到TransactionSynchronizationManager，使request的整个过程都使用同一个session，在请求过后再接除该sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。

    也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有。

采用spring的事务声明,使方法受transaction控制

    <bean id="baseTransaction" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"       abstract="true">
         <property name="transactionManager" ref="transactionManager"/>
         <property name="proxyTargetClass" value="true"/>
         <property name="transactionAttributes">
             <props>
                 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
                 <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
                 <prop key="save*">PROPAGATION_REQUIRED</prop>
                 <prop key="add*">PROPAGATION_REQUIRED</prop>
                 <prop key="update*">PROPAGATION_REQUIRED</prop>
                 <prop key="remove*">PROPAGATION_REQUIRED</prop>
             </props>
         </property>
     </bean>

     <bean id="userService" parent="baseTransaction">
         <property name="target">
             <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>
         </property>
    </bean> 

对于上例，则以save,add,update,remove开头的方法拥有可写的事务，如果当前有某个方法，如命名为importExcel()，则因没有transaction而没有写权限，这时若方法内有insert,update,delete操作的话，则需要手动设置flush model为Flush.AUTO,如

session.setFlushMode(FlushMode.AUTO); 
session.save(user);  
session.flush(); 

     尽管Open Session In View看起来还不错，其实副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal方法代码，这个方法实际上是被父类的doFilter调用的，因此，我们可以大约了解的OpenSessionInViewFilter调用流程: request(请求)->open session并开始transaction->controller->View(Jsp)->结束transaction并close session.

     一切看起来很正确，尤其是在本地开发测试的时候没出现问题，但试想下如果流程中的某一步被阻塞的话，那在这期间connection就一直被占用而不释放。最有可能被阻塞的就是在写Jsp这步，一方面可能是页面内容大，response.write的时间长，另一方面可能是网速慢，服务器与用户间传输时间久。当大量这样的情况出现时，就有连接池连接不足，造成页面假死现象。

Open Session In View是个双刃剑，放在公网上内容多流量大的网站请慎用。

hibernate open session in view 抛出异常解决方法

 在使用open-session-in-view的时候，如果使用不当，有可能抛出两种异常
1，NonUniqueObjectException
2，在配合spring使用的时候会可能会抛出org.springframework.dao.InvalidDataAccessApiUsageException

先说1，这个异常的抛出原因和解决办法见这里：
javaeye上有了很好的事例:http://www.javaeye.com/topic/11581
解决办法可以用merge，也可以别的办法。
出现的原因，可以参考一下我前边的文章中将merge和update的区别的内容。
http://www.blogjava.net/dreamstone/archive/2007/07/29/133071.html

2的解决办法：在这里
springside的一篇文章做了详细说明
http://calvin.blog.javascud.org/post/46.htm

好了，现在问题解决了，但关于open-session-in-view的使用还有一些探讨，是否应该使用，使用的好处与坏处。
见这两篇jdon上的文章:
http://www.jdon.com/jivejdon/thread/22374.html
http://www.jdon.com/jivejdon/thread/28955.html

    　举例：假设有在一个应用系统中，有一个共享的数据必须被并发同时访问，首先，将这个数据封装在数据对象中，称为Data   Class，同时，将有多个访问类，专门用于在同一时刻访问这同一个数据对象。
　　为了完成上述并发访问同一资源的功能，需要引入锁Lock的概念，也就是说，某个时刻，当有一个访问类访问这个数据对象时，这个数据对象必须上锁Locked，用完后就立即解锁unLocked，再供其它访问类访问。
　　使用传统的编程习惯，我们会创建一个抽象类，所有的访问类继承这个抽象父类，如下：
abstract   class   Worker{
　　abstract   void   locked();
　　abstract   void   accessDataObject();
　　abstract   void   unlocked();
}

　缺点：

        *   accessDataObject()方法需要有“锁”状态之类的相关代码。
        *   Java只提供了单继承，因此具体访问类只能继承这个父类，如果具体访问类还要继承其它父类，比如另外一个如Worker的父类，将无法方便实现。
        *   重用被打折扣，具体访问类因为也包含“锁”状态之类的相关代码，只能被重用在相关有“锁”的场合，重用范围很窄。

            仔细研究这个应用的“锁”，它其实有下列特性：
        *   “锁”功能不是具体访问类的首要或主要功能，访问类主要功能是访问数据对象，例如读取数据或更改动作。  

“锁”行为其实是和具体访问类的主要功能可以独立、区分开来的

“锁”功能其实是这个系统的一个纵向切面，涉及许多类、许多类的方法。  

　因此，一个新的程序结构应该是关注系统的纵向切面，例如这个应用的“锁”功能，这个新的程序结构就是aspect（方面）
　　在这个应用中，“锁”方面（aspect）应该有以下职责：
　　提供一些必备的功能，对被访问对象实现加锁或解锁功能。以保证所有在修改数据对象的操作之前能够调用lock()加锁，在它使用完成后，调用unlock()解锁。
AOP应用范围

　　很明显，AOP非常适合开发J2EE容器服务器，目前JBoss   4.0正是使用AOP框架进行开发。
　　具体功能如下：
Authentication   权限
Caching   缓存
Context   passing   内容传递
Error   handling   错误处理
Lazy   loading　懒加载
Debugging　　调试
logging,   tracing,   profiling   and   monitoring　记录跟踪　优化　校准

Performance   optimization　性能优化
Persistence　　持久化
Resource   pooling　资源池
Synchronization　同步
Transactions   事务
AOP有必要吗？
　　当然，上述应用范例在没有使用AOP情况下，也得到了解决，例如JBoss   3.XXX也提供了上述应用功能，但是没有使用AOP。
　　但是，使用AOP可以让我们从一个更高的抽象概念来理解软件系统，AOP也许提供一种有价值的工具。可以这么说：因为使用AOP结构，现在JBoss   4.0的源码要比JBoss   3.X容易理解多了，这对于一个大型复杂系统来说是非常重要的。
　　从另外一个方面说，好像不是所有的人都需要关心AOP，它可能是一种架构设计的选择，如果选择J2EE系统，AOP关注的上述通用方面都已经被J2EE容器实现了，J2EE应用系统开发者可能需要更多地关注行业应用方面aspect。

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">         
  <property name="dataSource">
   <ref bean="dataSource"/>
  </property>
  <property name="mappingResources">
   <list>
    <value>org/appfteaching/model/TArticleclass.hbm.xml</value>
   </list>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">${hibernate.dialect}</prop>
          <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
          <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
          <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
          <prop key="hibernate.cache.use_query_cache">true</prop>
          <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
   </props>   
  </property>  
 </bean> 

2.其次,在src目录下的ehcache.xml中配置如下信息(如果是默认ehcache.xml则会有<cache name="sampleCache1">和<cache name="sampleCache2>",去掉)

<cache name="org.hibernate.cache.StandardQueryCache"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="4200"
        overflowToDisk="true"
        />

    <!-- Sample cache named sampleCache2
        This cache contains 1000 elements. Elements will always be held in memory.
        They are not expired. -->

    <cache name="org.hibernate.cache.UpdateTimestampsCache"
        maxElementsInMemory="5000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        />

3.将你要缓存的model加进ehcache.xml里

<cache name="org.appfteaching.model.TArticleclass"
     maxElementsInMemory="1000"
        eternal="false"
        timeToIdleSeconds="100"
        timeToLiveSeconds="4200"
        overflowToDisk="true"
     />  

4.最后一步,在TArticleclass.hbm.xml里加上

<cache usage="read-write"/>

启动Tomcat,如发现如下错误

Could not find configuration [org.hibernate.cache.UpdateTimestampsCache]; using defaults.
Could not find configuration [org.hibernate.cache.StandardQueryCache]; using defaults.

则是第二步没有做,加上即可.配置完毕

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessagePreparator;

public class SpringMail {
 public static void main(String[] args) throws Exception {
        ApplicationContext ctx = new FileSystemXmlApplicationContext(
                "applicationContext.xml");
        JavaMailSender sender = (JavaMailSender) ctx.getBean("mailSender");
        SpringMail springMail = new SpringMail();
       
        //测试发送只有文本信息的简单测试
        springMail.sendTextMail(sender);
       
        //测试发送带附件的邮件
        springMail.sendMimeMessage(sender);
    }
   
    /** *//**
     * 测试发送只有文本信息的简单测试
     * @param sender 邮件发送器
     * @throws Exception
     */
    private void sendTextMail(JavaMailSender sender) throws Exception {
        SimpleMailMessage mail = new SimpleMailMessage();
        mail.setTo("superman_wshm@126.com");
        mail.setFrom("superman_wshm@126.com");
        mail.setSubject("test by amigo");
        mail.setText("spring Mail的简单测试");
        sender.send(mail);
       
        System.out.println("成功发送文本文件！");
    }
   
    /** *//**
     * 发送带附件的邮件
     * @param sender 邮件发送器
     * @throws Exception
     */
    private void sendMimeMessage(final JavaMailSender sender) throws Exception {
        //附件文件集合
        final List files = new ArrayList();
        MimeMessagePreparator mimeMail = new MimeMessagePreparator() {
            public void prepare(MimeMessage mimeMessage) throws MessagingException {
                mimeMessage.setRecipient(Message.RecipientType.TO,
                        new InternetAddress("superman_wshm@126.com"));
                mimeMessage.setFrom(new InternetAddress("superman_wshm@126.com"));
                mimeMessage.setSubject("Spring发送带附件的邮件", "gb2312");
               
                Multipart mp = new MimeMultipart();
               
                //向Multipart添加正文

                MimeBodyPart content = new MimeBodyPart();
                content.setText("内含spring邮件发送的例子，请查收!");
               
                //向MimeMessage添加（Multipart代表正文）
                mp.addBodyPart(content);
                files.add("com/action/SpringMail.java");
                files.add("applicationContext.xml");
               
                //向Multipart添加附件
                Iterator it = files.iterator();
                while(it.hasNext()) {
                    MimeBodyPart attachFile = new MimeBodyPart();
                    String filename = it.next().toString();
                    FileDataSource fds = new FileDataSource(filename);
                    attachFile.setDataHandler(new DataHandler(fds));
                    attachFile.setFileName(fds.getName());
                    mp.addBodyPart(attachFile);
                }
               
                files.clear();
               
                //向Multipart添加MimeMessage
                mimeMessage.setContent(mp);
                mimeMessage.setSentDate(new Date());
            }
        };

        //发送带附件的邮件
        sender.send(mimeMail);
       
        System.out.println("成功发送带附件邮件!");
    }

}

Spring配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="mailSender"
  class="org.springframework.mail.javamail.JavaMailSenderImpl">
  <property name="host">
   <value>smtp.126.com</value>
  </property>
  <property name="javaMailProperties">
   <props>
    <prop key="mail.smtp.auth">true</prop>
    <prop key="mail.smtp.timeout">25000</prop>
   </props>
  </property>
  <property name="username">
   <value>superman_wshm</value>
  </property>
  <property name="password">
   <value>******</value>
  </property>
 </bean>

</beans>


 刚才发现一bug，当附件名为中文时，会出现中文乱码问题，对sendMimeMessage方法进行了部分修改，如下：
   

               sun.misc.BASE64Encoder enc = new sun.misc.BASE64Encoder();
                files.add("src/SpringMail.java");
                files.add("src/applicationContext.xml");
                files.add("src/谢星星.xml");
                
                //向Multipart添加附件
                Iterator it = files.iterator();
             while (it.hasNext()) {
                    MimeBodyPart attachFile = new MimeBodyPart();
                    String filename = it.next().toString();
                    FileDataSource fds = new FileDataSource(filename);
                    attachFile.setDataHandler(new DataHandler(fds));
                    attachFile.setFileName("=?GBK?B?"+enc.encode(fds.getName().getBytes())+"?=");
                    mp.addBodyPart(attachFile);
                }

      MVC框架如Struts、Webwork，都在Servlet的基础上创建了一个自己的绝对空间，在自己的空间里定义MVC世界和规则。无论这个世界定义得是否漂亮，程序员都有一个学习世界的过程。

      而Spring MVC则完全保留着Servlet概念中的request，response和session，并没有强制建立一个自己的概念模型（当然，他也有很烂的SimpleFormController，但你完全可以把它踢在一旁不管），也不强制需要FormBean和一堆XML定义。

      同时，它透明完成了与Spring的集成，Multi-action的派发，提供了绑定request数据用的binder等基本API。

      所以，如果想简单，使用Spring MVC的原始形态是一个很好的，类似于RoR中ActionPack的方案。

      推荐使用一个Controller响应一组相关动作的MultiActionController。同时，虽然一点不喜欢FormController定义的概念模型，但还是不影响发挥拿来主义，在共性比较明显后台管理模块，定义MultiActionFormController，自动完成某些共同的Form流程。

      你还是很喜欢WebWork?好在我们也提供了sample，见2.4 WebWork 。

2.写给在用其他MVC框架程序员的快速入门

      也许，所有程序员都先放下自己框架里的概念模型，还原回一个JSP/Servlet程序员的角度，思考一个JSP/Servlet框架需要的功能。

     0. 配置文件

         Spring的配置文件默认为WEB-INF/xxxx-servelet.xml。

         其中xxx为web.xml中org.springframework.web.servlet.DispatcherServlet的servlet-name。

     1. 与Spring集成及IOC

          天然兮，由DispatcherServlet完成。

      2. Action及Multi-Action 分发

          Spring将按照配置文件定义的URL，Mapping到具体Controller类，再根据URL里的action= xxx或其他参数，利用反射调用Controller里对应的Action方法。

      3. 输入数据绑定

          Spring提供Binder 通过名字的一一对应反射绑定Pojo，也可以直接从request.getParameter()取数据。

          如果没有另外加入框架封装，需要手工调用Binder.

      4. 输入数据验证

          Sping 提供了Validator接口，而Spring Module还整合了Commons-Validaor 。

      5. 结果数据放回View

          有个ModelAndView的概念，代表了返回的View名及数据(Model，一个Map)。可以用modelAndView.addObject()放入数据。当然，也可以直接request.setAttribute()。

      6. Interceptor

          AOP概念，其实Servlet里面早有Filter概念，不过Inteceptor可以更灵活的Mapping，另提供postHandle的插入点

          preHandle() handler开工之前。
          postHandle() hander开工之后，但DispatchServlet还没有渲染页面。
          afterCompletion() 一切完工之后。
        

      7. Redirect，Forward页面及Token防止重复提交。

          Spring提供 "redirect:index.jsp", "forward:index.jsp"这样的简写。

          Spring Simple Form提供了防止重复提交的机制。

      8. 如果想直接编写Response返回字符串, 而不是返回一个View

          将函数的返回类型设为void，使用ss封装的 rendText(response,String text)函数。

3.Spring MVC Multi-action

3.1 基本配置

   <bean id="methodNameResolver" class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
        <property name="paramName">
            <value>method</value>
        </property>
        <property name="defaultMethodName">
            <value>index</value>      
      </property> 
</bean>

以上配置将按xxx.do?method= list 将调用controller的list()方法

不过还要争取早日改为Web2.0式的写法./book/list.htm 要优于/book.do?action= list。

其余配置和其他Spring MVC配置差不多，请看bookstore-servlet.xml，留意下面几个关键节点
<bean id="exceptionResolver">
<bean id="methodNameResolver">
<bean id="viewResolver">
<bean id="urlMapping">(留意最新的urlMapping简写语法.)

4.SpringSide BaseController

   继承于Spring的MultiActionController, 对其作了少量扩展--主要是对数据绑定的扩展，还加了一个SaveMessage函数。

   1.对数据绑定的扩展：

   a.InitBinder() 初始化Binder，注册日期类并允许数字类为空。

   b.对Bind and Validate函数的再包装
   本来Spring已有bind函数完成bind and validate, 但这个函数一来没有使用BindException作返回值而是抛出一个ServletException只好自己另外实现一个bindObject()函数。

   c.另外稍稍扩展了一些函数使其更好用。

2.SaveMessage():

如果是redirect的关系，message信息放在request.attribute()就会丢失，SaveMessage()将其放在session。
 配合messageFilter，在渲染页面前，把它从session又移回request。

5.后台管理通用的BaseManageController

  Spring MVC中的SimpleFormController中的交互机制有值得参考的部分，但其只有一个onSubmit函数不能很好的表达CRUD的语义，所以将两者结合成Multi-ActionFormController是比较好的方法。通过约定命名，在基类实现list()，create()等函数和默认流程，而在子类实现onList(),onCreate()函数。

   目前只是初步结合两者，还有很大的改进空间。

   参考了RoR中的命名。BaseManageController即按照此命名定义基类。

1. list 显示对象列表的页面
2. create新增对象的输入界面
3. edit 修改对象的输入界面
4. show 只读显示对象detai的页面
5. save 新增对象的保存
6. update 修改对象的保存
7. remove 删除单个对象
8. removeAll 批量删除对象
9. query 查询