Spring3 MVC 深入研究

一、前言：

大家好，Spring3 MVC是非常优秀的MVC框架，由其是在3.0版本发布后，现在有越来越多的团队选择了Spring3 MVC了。Spring3 MVC结构简单，应了那句话简单就是美，而且他强大不失灵活，性能也很优秀。

官方的下载网址是：http://www.springsource.org/download   （本文使用是的Spring 3.0.5版本）

 

Struts2也是比较优秀的MVC构架，优点非常多比如良好的结构。但这里想说的是缺点，Struts2由于采用了值栈、OGNL表达式、struts2标签库等，会导致应用的性能下降。Struts2的多层拦截器、多实例action性能都很好。可以参考我写的一篇关于Spring MVC与Struts2与Servlet比较的文章 http://elf8848.iteye.com/admin/blogs/698217

 

Spring3 MVC的优点：

1、Spring3 MVC的学习难度小于Struts2，Struts2用不上的多余功能太多。呵呵，当然这不是决定因素。

2、Spring3 MVC很容易就可以写出性能优秀的程序，Struts2要处处小心才可以写出性能优秀的程序（指MVC部分）

3、Spring3 MVC的灵活是你无法想像的，Spring的扩展性有口皆碑，Spring3 MVC当然也不会落后，不会因使用了MVC框架而感到有任何的限制。

 

Struts2的众多优点：略...   (呵呵，是不是不公平？)

 

众多文章开篇时总要吹些牛，吸引一下读者的眼球，把读者的胃口调起来，这样大家才有兴趣接着往后看。本文也没能例外。不过保证你看了之后不会后悔定有收获。

 

 

二、核心类与接口：

 

先来了解一下，几个重要的接口与类。现在不知道他们是干什么的没关系，先混个脸熟，为以后认识他们打个基础。

 

DispatcherServlet   -- 前置控制器

 

HandlerMapping接口 -- 处理请求的映射

HandlerMapping接口的实现类：

SimpleUrlHandlerMapping  通过配置文件，把一个URL映射到Controller

DefaultAnnotationHandlerMapping  通过注解，把一个URL映射到Controller类上

 

HandlerAdapter接口 -- 处理请求的映射

AnnotationMethodHandlerAdapter类，通过注解，把一个URL映射到Controller类的方法上

 

Controller接口 -- 控制器

由于我们使用了@Controller注解，添加了@Controller注解注解的类就可以担任控制器（Action）的职责,

所以我们并没有用到这个接口。

 

 

 

HandlerInterceptor 接口--拦截器

无图，我们自己实现这个接口，来完成拦截的器的工作。

 

 

ViewResolver接口的实现类

UrlBasedViewResolver类 通过配置文件，把一个视图名交给到一个View来处理

InternalResourceViewResolver类，比上面的类，加入了JSTL的支持

 

View接口

JstlView类

 

LocalResolver接口

 

HandlerExceptionResolver接口 --异常处理

SimpleMappingExceptionResolver实现类

 

 

ModelAndView类

无图。

 

 

 

 

 

三、核心流程图

 

本图是我个人画的，有不严谨的地方，大家对付看吧。总比没的看强。

 

 

 

四、DispatcherServlet说明

 

使用Spring MVC,配置DispatcherServlet是第一步。

DispatcherServlet是一个Servlet,所以可以配置多个DispatcherServlet。

DispatcherServlet是前置控制器，配置在web.xml文件中的。拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求，依据某某规则分发到目标Controller(我们写的Action)来处理。

 

“某某规则”：是根据你使用了哪个HandlerMapping接口的实现类的不同而不同。

 

先来看第一个例子：

<web-app>
    <servlet>
        <servlet-name>example</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>example</servlet-name>
        <url-pattern>*.form</url-pattern>
    </servlet-mapping>
</web-app>

 <load-on-startup>1</load-on-startup>是启动顺序，让这个Servlet随Servletp容器一起启动。

 <url-pattern>*.form</url-pattern> 会拦截*.form结尾的请求。

 

 <servlet-name>example</servlet-name>这个Servlet的名字是example，可以有多个DispatcherServlet，是通过名字来区分的。每一个DispatcherServlet有自己的WebApplicationContext上下文对象。同时保存的ServletContext中和Request对象中，关于key，以后说明。

 

在DispatcherServlet的初始化过程中，框架会在web应用的 WEB-INF文件夹下寻找名为[servlet-name]-servlet.xml 的配置文件，生成文件中定义的bean。

 

 

第二个例子：

<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:/springMVC.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

指明了配置文件的文件名，不使用默认配置文件名，而使用springMVC.xml配置文件。

其中<param-value>**.xml</param-value> 这里可以使用多种写法
1、不写,使用默认值:/WEB-INF/<servlet-name>-servlet.xml
2、<param-value>/WEB-INF/classes/springMVC.xml</param-value>
3、<param-value>classpath*:springMVC-mvc.xml</param-value>
4、多个值用逗号分隔

 

Servlet拦截匹配规则可以自已定义，Servlet拦截哪种URL合适？ 

当映射为@RequestMapping("/user/add")时：
1、拦截*.do，例如：/user/add.do，弊端：所有的url都要以.do结尾。不会影响访问静态文件。
2、拦截/app/*，例如：/app/user/add，弊端：请求的url都要包含/app，@RequestMapping("/user/add")中不须要包含/app。
3、拦截/，例如：/user/add，弊端：对jpg,js,css静态文件的访问也被拦截不能正常显示。后面有解决办法。
4、拦截/*，可以走到Action中，但转发到jsp时再次被拦截，不能访问到jsp。

 

 

五、双亲上下文的说明

 

如果你使用了listener监听器来加载配置，一般在Struts+Spring+Hibernate的项目中都是使用listener监听器的。如下

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

Spring会创建一个全局的WebApplicationContext上下文，称为根上下文 ，保存在 ServletContext中，key是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE属性的值。可以使用工具类取出上下文：WebApplicationContextUtils.getWebApplicationContext(ServletContext);

 

DispatcherServlet是一个Servlet,可以同时配置多个，每个 DispatcherServlet有一个自己的 WebApplicationContext上下文，这个上下文继承了 根上下文 中所有东西。 保存在 ServletContext中，key是"org.springframework.web.servlet.FrameworkServlet.CONTEXT"+Servlet名称。当一个Request对象产生时，会把这个WebApplicationContext上下文保存在Request对象中，key是DispatcherServlet.class.getName() + ".CONTEXT"。可以使用工具类取出上下文：RequestContextUtils.getWebApplicationContext(request);

 

Spring中的 ApplicationContext实例可以被限制在不同的作用域（scope）中。
在web MVC框架中，每个 DispatcherServlet有它自己的WebApplicationContext ，这个context继承了根 WebApplicationContext 的所有bean定义。
这些继承的bean也可以在每个serlvet自己的所属的域中被覆盖（override），覆盖后的bean 可以被设置上只有这个servlet实例自己使用的属性。

 

总结：不使用listener监听器来加载spring的配置，改用DispatcherServlet来加载spring的配置，不要双亲上下文，只使用一个DispatcherServlet，事情就简单了，什么麻烦事儿也没有了。

 

 

六、springMVC-mvc.xml 配置文件片段讲解 （未使用默认配置文件名）

 

   <!-- 自动扫描的包名 -->
   <context:component-scan base-package="com.app,com.core,JUnit4" ></context:component-scan>

   <!-- 默认的注解映射的支持 -->
   <mvc:annotation-driven />

   <!-- 视图解释类 -->
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <property name="suffix" value=".jsp"/><!--可为空,方便实现自已的依据扩展名来选择视图解释类的逻辑  -->
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
   </bean>

<!-- 拦截器 -->
   <mvc:interceptors>
    <bean class="com.core.mvc.MyInteceptor" />
</mvc:interceptors>

    <!-- 对静态资源文件的访问  方案一 （二选一） -->
    <mvc:default-servlet-handler/>

    <!-- 对静态资源文件的访问  方案二 （二选一）-->
<mvc:resources mapping="/images/**" location="/images/" cache-period="31556926"/>
<mvc:resources mapping="/js/**" location="/js/" cache-period="31556926"/>
<mvc:resources mapping="/css/**" location="/css/" cache-period="31556926"/>

 

<context:component-scan/> 扫描指定的包中的类上的注解，常用的注解有：

@Controller 声明Action组件
@Service    声明Service组件    @Service("myMovieLister") 
@Repository 声明Dao组件
@Component   泛指组件, 当不好归类时. 
@RequestMapping("/menu")  请求映射
@Resource  用于注入，( j2ee提供的 ) 默认按名称装配，@Resource(name="beanName") 
@Autowired 用于注入，(srping提供的) 默认按类型装配 
@Transactional( rollbackFor={Exception.class}) 事务管理
@ResponseBody
@Scope("prototype")   设定bean的作用域

 

<mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。<mvc:annotation-driven /> 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MVC为@Controllers分发请求所必须的。
并提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）。
后面，我们处理响应ajax请求时，就使用到了对json的支持。
后面，对action写JUnit单元测试时，要从spring IOC容器中取DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean，来完成测试，取的时候要知道是<mvc:annotation-driven />这一句注册的这两个bean。

 

<mvc:interceptors/> 是一种简写形式。通过看前面的大图，知道，我们可以配置多个HandlerMapping。<mvc:interceptors/>会为每一个HandlerMapping，注入一个拦截器。其实我们也可以手动配置为每个HandlerMapping注入一个拦截器。

 

<mvc:default-servlet-handler/> 使用默认的Servlet来响应静态文件。

 

<mvc:resources mapping="/images/**" location="/images/" cache-period="31556926"/> 匹配URL  /images/**  的URL被当做静态资源，由Spring读出到内存中再响应http。

 

 
七、如何访问到静态的文件，如jpg,js,css？

如何你的DispatcherServlet拦截 *.do这样的URL，就不存在访问不到静态资源的问题。如果你的DispatcherServlet拦截“/”，拦截了所有的请求，同时对*.js,*.jpg的访问也就被拦截了。

 

目的：可以正常访问静态文件，不要找不到静态文件报404。
 
方案一：激活Tomcat的defaultServlet来处理静态文件

<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.css</url-pattern>
</servlet-mapping>
要配置多个，每种文件配置一个

要写在DispatcherServlet的前面， 让 defaultServlet先拦截，这个就不会进入Spring了，我想性能是最好的吧。

Tomcat, Jetty, JBoss, and GlassFish  默认 Servlet的名字 -- "default"
Google App Engine 默认 Servlet的名字 -- "_ah_default"
Resin 默认 Servlet的名字 -- "resin-file"
WebLogic 默认 Servlet的名字  -- "FileServlet"
WebSphere  默认 Servlet的名字 -- "SimpleFileServlet" 

 

 

方案二： 在spring3.0.4以后版本提供了mvc:resources 
mvc:resources 的使用方法：

<!-- 对静态资源文件的访问 -->
<mvc:resources mapping="/images/**" location="/images/" />

  
/images/**映射到ResourceHttpRequestHandler进行处理，location指定静态资源的位置.可以是web application根目录下、jar包里面，这样可以把静态资源压缩到jar包中。cache-period 可以使得静态资源进行web cache 
 
如果出现下面的错误，可能是没有配置<mvc:annotation-driven />的原因。 
报错WARNING: No mapping found for HTTP request with URI [/mvc/user/findUser/lisi/770] in DispatcherServlet with name 'springMVC'

 

使用<mvc:resources/>元素,把mapping的URI注册到SimpleUrlHandlerMapping的urlMap中,
key为mapping的URI pattern值,而value为ResourceHttpRequestHandler,
这样就巧妙的把对静态资源的访问由HandlerMapping转到ResourceHttpRequestHandler处理并返回,所以就支持classpath目录,jar包内静态资源的访问.
另外需要注意的一点是,不要对SimpleUrlHandlerMapping设置defaultHandler.因为对static uri的defaultHandler就是ResourceHttpRequestHandler,
否则无法处理static resources request.

 

 

方案三 ，使用<mvc:default-servlet-handler/>

 

<mvc:default-servlet-handler/>

 

会把"/**" url,注册到SimpleUrlHandlerMapping的urlMap中,把对静态资源的访问由HandlerMapping转到org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler处理并返回.
DefaultServletHttpRequestHandler使用就是各个Servlet容器自己的默认Servlet.

 

 

补充说明：多个HandlerMapping的执行顺序问题：

DefaultAnnotationHandlerMapping的order属性值是：0

<mvc:resources/ >自动注册的 SimpleUrlHandlerMapping的order属性值是： 2147483646

 

<mvc:default-servlet-handler/>自动注册 的SimpleUrlHandlerMapping 的order属性值是： 2147483647

 

spring会先执行order值比较小的。当访问一个a.jpg图片文件时，先通过 DefaultAnnotationHandlerMapping 来找处理器，一定是找不到的，我们没有叫a.jpg的Action。再 按order值升序找，由于最后一个 SimpleUrlHandlerMapping 是匹配 "/**"的，所以一定会匹配上，再响应图片。

 

访问一个图片，还要走层层匹配。真不知性能如何？改天做一下压力测试，与Apache比一比。

 

最后再说明一下，如何你的DispatcherServlet拦截 *.do这样的URL，就不存上述问题了。

 

 

八、请求如何映射到具体的Action中的方法？
方案一：基于xml配置映射，可以利用SimpleUrlHandlerMapping、BeanNameUrlHandlerMapping进行Url映射和拦截请求。
配置方法略。
 
方案二：基于注解映射，可以使用DefaultAnnotationHandlerMapping。

<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">  </bean>

 

但前面我们配置了<mvc:annotation-driven />，他会自动注册这个bean,就不须要我们显示的注册这个bean了。  

 

 
以上都可以注入interceptors，实现权限控制等前置工作。
我们使用第2种，基于注解来使用spring MVC

 

 

 并在action类上使用：
@Controller
@RequestMapping("/user")
 
 
 
九、Spring中的拦截器：
Spring为我们提供了：
org.springframework.web.servlet.HandlerInterceptor接口，

org.springframework.web.servlet.handler.HandlerInterceptorAdapter适配器，
实现这个接口或继承此类，可以非常方便的实现自己的拦截器。
 
有以下三个方法：
 
Action之前执行:
 public boolean preHandle(HttpServletRequest request,
   HttpServletResponse response, Object handler);
 
生成视图之前执行
 public void postHandle(HttpServletRequest request,
   HttpServletResponse response, Object handler,
   ModelAndView modelAndView);
 
最后执行，可用于释放资源
 public void afterCompletion(HttpServletRequest request,
   HttpServletResponse response, Object handler, Exception ex)
 
 
分别实现预处理、后处理（调用了Service并返回ModelAndView，但未进行页面渲染）、返回处理（已经渲染了页面） 
在preHandle中，可以进行编码、安全控制等处理； 
在postHandle中，有机会修改ModelAndView； 
在afterCompletion中，可以根据ex是否为null判断是否发生了异常，进行日志记录。 
参数中的Object handler是下一个拦截器。
 

十、如何使用拦截器？
自定义一个拦截器，要实现HandlerInterceptor接口：

public class MyInteceptor implements HandlerInterceptor {
    略。。。
}

 

Spring MVC并没有总的拦截器，不能对所有的请求进行前后拦截。
Spring MVC的拦截器，是属于HandlerMapping级别的，可以有多个HandlerMapping ，每个HandlerMapping可以有自己的拦截器。
当一个请求按Order值从小到大，顺序执行HandlerMapping接口的实现类时，哪一个先有返回，那就可以结束了，后面的HandlerMapping就不走了，本道工序就完成了。就转到下一道工序了。
拦截器会在什么时候执行呢？ 一个请求交给一个HandlerMapping时，这个HandlerMapping先找有没有处理器来处理这个请求，如何找到了，就执行拦截器，执行完拦截后，交给目标处理器。
如果没有找到处理器，那么这个拦截器就不会被执行。

 

在spring MVC的配置文件中配置有三种方法：

方案一，（近似）总拦截器，拦截所有url

   <mvc:interceptors>
    <bean class="com.app.mvc.MyInteceptor" />
</mvc:interceptors>

为什么叫“近似”，前面说了，Spring没有总的拦截器。

<mvc:interceptors/>会为每一 个HandlerMapping，注入一个拦截器。总有一个HandlerMapping是可以找到处理器的，最多也只找到一个处理器，所以这个拦截器总会被执行的。起到了总拦截器的作用。

 

 
方案二， （近似） 总拦截器， 拦截匹配的URL。

<mvc:interceptors >
  <mvc:interceptor>
        <mvc:mapping path="/user/*" /> <!-- /user/*  -->
        <bean class="com.mvc.MyInteceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

就是比 方案一多了一个URL匹配。

 

 

 

方案三,HandlerMappint上的拦截器

<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
 <property name="interceptors">
     <list>
         <bean class="com.mvc.MyInteceptor"></bean>
     </list>
 </property>
</bean>

  如果使用了<mvc:annotation-driven />， 它会自动注册DefaultAnnotationHandlerMapping 与AnnotationMethodHandlerAdapter 这两个bean,所以就没有机会再给它注入interceptors属性，就无法指定拦截器。

当然我们可以通过人工配置上面的两个Bean，不使用 <mvc:annotation-driven />，就可以 给interceptors属性 注入拦截器了。

 

其实我也不建议使用<mvc:annotation-driven />，而建议手动写配置文件，来替代 <mvc:annotation-driven />，这就控制力就强了。

 

 

 

 

十一、如何实现全局的异常处理？

在spring MVC的配置文件中：

<!-- 总错误处理-->
<bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="defaultErrorView">
        <value>/error/error</value>
    </property>
    <property name="defaultStatusCode">
        <value>500</value>
    </property>
<property name="warnLogCategory">
        <value>org.springframework.web.servlet.handler.SimpleMappingExceptionResolver</value>
    </property>
</bean>

 

这里主要的类是SimpleMappingExceptionResolver类，和他的父类AbstractHandlerExceptionResolver类。

具体可以配置哪些属性，我是通过查看源码知道的。

你也可以实现HandlerExceptionResolver接口，写一个自己的异常处理程序。spring的扩展性是很好的。

 

 

通过SimpleMappingExceptionResolver我们可以将不同的异常映射到不同的jsp页面（通过exceptionMappings属性的配置）。

 

同时我们也可以为所有的异常指定一个默认的异常提示页面（通过defaultErrorView属性的配置），如果所抛出的异常在exceptionMappings中没有对应的映射，则Spring将用此默认配置显示异常信息。

注意这里配置的异常显示界面均仅包括主文件名，至于文件路径和后缀已经在viewResolver中指定。如/error/error表示/error/error.jsp

 

 

显示错误的jsp页面：

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>
<%@ page import="java.lang.Exception"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GBK">
<title>错误页面</title>
</head>
<body>
<h1>出错了</h1>
<%
Exception e = (Exception)request.getAttribute("exception");
out.print(e.getMessage());
%>
</body>
</html>

其中一句：request.getAttribute("exception")，key是exception，也是在SimpleMappingExceptionResolver类默认指定的，是可能通过配置文件修改这个值的，大家可以去看源码。

 

 参考文章：

http://www.blogjava.net/wuxufeng8080/articles/191150.html

http://fangjunai.blog.163.com/blog/static/1124970520108102013839/

 

 

 

十二、如何把全局异常记录到日志中？

在前的配置中，其中有一个属性warnLogCategory，值是“SimpleMappingExceptionResolver类的全限定名”。我是在SimpleMappingExceptionResolver类父类AbstractHandlerExceptionResolver类中找到这个属性的。查看源码后得知：如果warnLogCategory不为空，spring就会使用apache的org.apache.commons.logging.Log日志工具，记录这个异常，级别是warn。

值：“org.springframework.web.servlet.handler.SimpleMappingExceptionResolver”，是“SimpleMappingExceptionResolver类的全限定名”。这个值不是随便写的。  因为我在log4j的配置文件中还要加入log4j.logger.org.springframework.web.servlet.handler.SimpleMappingExceptionResolver=WARN，保证这个级别是warn的日志一定会被记录，即使log4j的根日志级别是ERROR。

 

 

 

 

 十三、如何给spring3 MVC中的Action做JUnit单元测试？

 使用了spring3 MVC后，给action做单元测试也很方便，我以前从来不给action写单元测试的，再在不同了，方便了，所以一定要写。

 

 JUnitActionBase类是所有JUnit的测试类的父类

 

package test;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.junit.BeforeClass;
import org.springframework.mock.web.MockServletContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.XmlWebApplicationContext;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.HandlerExecutionChain;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter;
import org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping;
/**
* 说明： JUnit测试action时使用的基类
*
* @author  赵磊
* @version 创建时间：2011-2-2 下午10:27:03
*/
public class JUnitActionBase {
    private static HandlerMapping handlerMapping;
    private static HandlerAdapter handlerAdapter;
    /**
     * 读取spring3 MVC配置文件
     */
    @BeforeClass
 public static void setUp() {
        if (handlerMapping == null) {
            String[] configs = { "file:src/springConfig/springMVC.xml" };
            XmlWebApplicationContext context = new XmlWebApplicationContext();
            context.setConfigLocations(configs);
            MockServletContext msc = new MockServletContext();
            context.setServletContext(msc);         context.refresh();
            msc.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, context);
            handlerMapping = (HandlerMapping) context
                    .getBean(DefaultAnnotationHandlerMapping.class);
            handlerAdapter = (HandlerAdapter) context.getBean(context.getBeanNamesForType(AnnotationMethodHandlerAdapter.class)[0]);
        }
    }

    /**
     * 执行request对象请求的action
     *
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    public ModelAndView excuteAction(HttpServletRequest request, HttpServletResponse response)
 throws Exception {
        HandlerExecutionChain chain = handlerMapping.getHandler(request);
        final ModelAndView model = handlerAdapter.handle(request, response,
                chain.getHandler());
        return model;
    }
}

 

 

 

 

 

 

这是个JUnit测试类，我们可以new Request对象，来参与测试，太方便了。给request指定访问的URL，就可以请求目标Action了。

 

package test.com.app.user;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.servlet.ModelAndView;

import test.JUnitActionBase;

/**
* 说明： 测试OrderAction的例子
*
* @author  赵磊
* @version 创建时间：2011-2-2 下午10:26:55
*/

public class TestOrderAction extends JUnitActionBase {
    @Test
    public void testAdd() throws Exception {
    MockHttpServletRequest request = new MockHttpServletRequest();
        MockHttpServletResponse response = new MockHttpServletResponse();
        request.setRequestURI("/order/add");
        request.addParameter("id", "1002");
        request.addParameter("date", "2010-12-30");
        request.setMethod("POST");
        // 执行URI对应的action
        final ModelAndView mav = this.excuteAction(request, response);
        // Assert logic
        Assert.assertEquals("order/add", mav.getViewName());
        String msg=(String)request.getAttribute("msg");
        System.out.println(msg);
    }
}

 需要说明一下 ：由于当前最想版本的Spring(Test) 3.0.5还不支持@ContextConfiguration的注解式context file注入，所以还需要写个setUp处理下，否则类似于Tiles的加载过程会有错误，因为没有ServletContext。3.1的版本应该有更好的解决方案，参见： https://jira.springsource.org/browse/SPR-5243 。

参考 ：http://www.iteye.com/topic/828513

 

 

 

 

 十四、转发与重定向

可以通过redirect/forward:url方式转到另一个Action进行连续的处理。

可以通过redirect:url 防止表单重复提交 。

写法如下：

return "forward:/order/add";

return "redirect:/index.jsp";

 

 

 

 

 十五、处理ajax请求

 

1、引入下面两个jar包，我用的是1.7.2，好像1.4.2版本以上都可以，下载地址： http://wiki.fasterxml.com/JacksonDownload

jackson-core-asl-1.7.2.jar 

jackson-mapper-asl-1.7.2.jar

 

2、spring的配置文件中要有这一行，才能使用到spring内置支持的json转换。如果你手工把POJO转成json就可以不须要使用spring内置支持的json转换。

<mvc:annotation-driven />

 

3、使用@ResponseBody注解

/**
 * ajax测试
* http://127.0.0.1/mvc/order/ajax
 */

@RequestMapping("/ajax")
@ResponseBody
public Object ajax(HttpServletRequest request){
    List<String> list=new ArrayList<String>();
    list.add("电视");
nbsp;       list.add("洗衣机");
    list.add("冰箱");
    list.add("电脑");
    list.add("汽车");
    list.add("空调");
    list.add("自行车");
    list.add("饮水机");
    list.add("热水器");
    return list;
}

 

 

 

• 查看图片附件

• 19:22
• 评论 / 浏览 (9 / 3375)
• 分类:企业架构

2010-10-24

缩略显示

日志解决方案

博客分类： 
• Spring

Apache

日志解决方案 

一、org.apache.commons.logging.Log方案

二、slf4j方案

 

参见：

java日志，需要知道的几件事(commons-logging,log4j,slf4j,logback)

http://www.iteye.com/topic/934593

 

log4j logback slf4j项目配置中的简单总结

http://www.iteye.com/topic/345924

 

 

 

• 13:16
• 评论 / 浏览 (0 / 274)
• 分类:企业架构

2009-03-21

缩略显示

8 使用注解实现AOP

博客分类： 
• Spring

AOPSpringBeanXML

1  引入aop命名空间

    xmlns:aop="http://www.springframework.org/schema/aop"     

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

 

2配置,打开对@Aspect注解的支持

<aop:aspectj-autoproxy/>

 

 

3 引入 jar包

      cglib-nodep-2.1_3.jar

      aspectjweaver.jar

      aspectjrt.jar

 

例子:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
        <aop:aspectj-autoproxy/>
        <bean id="myInterceptor" class="cn.service.MyInterceptor"/>  这是AOP切面,在业务方法执行时插入其它方法 ,也可使用第6讲中的"自动扫描" 就不用在这里配置了,但要在MyInterceptor 类加上@Conponent
       <bean id="personService" class="cn.service.impl.PersonServiceBean"></bean>  这是业务类
</beans>

 

 

 

 

 

package cn.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
 * 切面
 *
 */
@Aspect
public class MyInterceptor {
    @Pointcut("execution (* cn.service.impl.PersonServiceBean.*(..))")  //目标是PersonServiceBean类的所有方法
      private void anyMethod() {}//声明一个切入点

    @Before("anyMethod() && args(name)")
    public void doAccessCheck(String name) {
        System.out.println("前置通知:"+ name);
    }
    @AfterReturning(pointcut="anyMethod()",returning="result")
    public void doAfterReturning(String result) {
        System.out.println("后置通知:"+ result);
    }
    @After("anyMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
    @AfterThrowing(pointcut="anyMethod()",throwing="e")
    public void doAfterThrowing(Exception e) {
        System.out.println("例外通知:"+ e);
    }

    @Around("anyMethod()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
        //if(){//判断用户是否在权限
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("退出方法");
        //}
        return result;
    }

}

 

execution (* cn.service.impl.PersonServiceBean.*(..))
任何返回类型  包名.类名.任何方法(任意参数)

execution (* cn.service.impl..*.*(..))
任何返回类型 cn.service.impl 及子包  任意类.任意方法(任意参数)   .  impl..  后有两点,表示本包及子包下面, 没有两点, 表示本包下面.

 

 

 

 

• 08:29
• 评论 / 浏览 (0 / 390)

2009-03-20

缩略显示

7 组件自动扫描

博客分类： 
• Spring

SpringprototypeBeanDAOXML

1 引入 context 命名空间(在 spring的配置文件 中)

           xmlns:context="http://www.springframework.org/schema/context"  

           http://www.springframework.org/schema/context

           http://www.springframework.org/schema/context/spring-context-2.5.xsd

 

2 打开配置 <context:component-scan base-package="包名(扫描本包及子包)"/>

 

例子:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

          <context:component-scan base-package="cn.pic"/>
</beans>

 -----------------------------------------------------

spring 会自动扫描cn.pic包下面有如下注解 的类

@Service          标注业务层组件    @Service("myMovieLister")

@Controller      控制层组件,如Action

@Repository    DAO层组件

@Component   泛指组件, 当不好归类时.

 

 

----------------------------------------------------------------------

用注解 设定bean的作用域

@Scope("prototype")

值有:

singleton,

prototype,

session ,

request,

session,

global session

• 17:46
• 评论 / 浏览 (0 / 311)

2009-03-20

缩略显示

6 @Autowired 与@Resource

博客分类： 
• Spring

SpringBeanDAOXML

1 引入 context 命名空间(在 spring的配置文件 中)

           xmlns:context="http://www.springframework.org/schema/context"  

           http://www.springframework.org/schema/context

           http://www.springframework.org/schema/context/spring-context-2.5.xsd

2 在 spring的配置文件 打开配置,  就可以使用注解处理器了

 <context:annotation-config/>

3 引入 注解用的 jar包

lib\j2ee\common-annotations.jar

 

--------------------------------------------------------------------------------------

例子 :

spring的配置文件 如下 :  多了三行命名空间  与一个<context...../>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

          <context:annotation-config/>

          <bean id="personDaoxxxx" class="cn.dao.impl.PersonDaoBean"></bean>

</beans>

 

----------------------------------------------------------------------------------

@Autowired 与@Resource 都可以用来装配bean.  都可以写在字段上,或写在set方法上

@Autowired (srping提供的) 默认按类型装配

@Resource ( j2ee提供的 ) 默认按名称装配,当找不到(不写name属性)名称匹配的bean再按类型装配.

可以通过@Resource(name="beanName") 指定被注入的bean的名称, 要是指定了name属性, 就用 字段名 去做name属性值,一般不用写name属性.

@Resource(name="beanName")指定了name属性,按名称注入但没找到bean, 就不会再按类型装配了.

推荐@Autowired 与@Resource作用有字段 上,  就不用写set方法了,也不要写@Resource(name="beanName").

 

---------------------------------------------------------------------------

例子1:

public class PersonServiceBean implements PersonService {
    @Resource
    private PersonDao personDao;

    public void save(){
        personDao.add();
    }
}

 

例子2:

@Service
@Transactional
public class BonuManager {

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        bonuslogDAO = new SimpleHibernateTemplate<Bonuslog, Integer>(sessionFactory, Bonuslog.class);
    }

    @Autowired
    private ScoresetManager scoresetManager;

    @Autowired
    private TopicManager topicManager;

    @Autowired
    private UserManager userManager;


    public void addLog(Topics topics, Users author, Users winer, String winnerName, Postid post, int bonus, int isbest) {
        Bonuslog bonuslog = new Bonuslog();
        bonuslog.setAnswername("");
        bonuslog.setBonus(bonus);
        bonuslog.setExtid(scoresetManager.getCreditsTrans());
        bonuslog.setIsbest(isbest);
        bonuslog.setPostid(post);
        bonuslog.setDateline(Utils.getNowTime());
        bonuslog.setTopics(topics);
        bonuslog.setUsersByAuthorid(author);

        bonuslogDAO.save(bonuslog);
        if (logger.isDebugEnabled()) {
            logger.debug("添加悬赏日志{}成功", bonuslog.getId());
        }
    }
}

• 15:06
• 评论 / 浏览 (0 / 3053)

2009-03-08

缩略显示

5 Spring2.0 用<tx:实现事务管理

博客分类： 
• Spring

配置管理AOPSpringBeanHibernate

转自:生菜肥羊

http://wlh269.iteye.com/blog/324120 声明式事务管理 

他写的不错, 我收藏了.

 

采用声明式事务 
1、声明式事务配置 
* 配置SessionFactory 
* 配置事务管理器 
* 事务的传播特性 
* 那些类那些方法使用事务 
2、编写业务逻辑方法 
* 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是Hibernate session的封装     * 默认的回滚是RuntimeException（包括继承RuntimeException的子类），普通异常不回滚   
  
* 在编写业务逻辑方法时，最好将异常一直往上抛出，在呈现层处理(struts)     

* spring的事务需要设置到业务方法上（事务边界定义到Facade类上），不要添加到Dao上 

3、了解事务的几种传播特性 
1. PROPAGATION_REQUIRED : 如果存在一个事务，则支持当前事务。如果没有事务则开启 
2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行 
3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。 
4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。 
5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。 
6. PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常 
7. PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 
     则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行 

4、Spring事务的隔离级别 
1. ISOLATION_DEFAULT： 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别. 
     另外四个与JDBC的隔离级别相对应 
2. ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。 
     这种隔离级别会产生脏读，不可重复读和幻像读。 
3. ISOLATION_READ_COMMITTED ： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据 
4. ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。 
     它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。 
5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。 
     除了防止脏读，不可重复读外，还避免了幻像读。

<?xml version= "1.0"  encoding= "UTF-8" ?>

<beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

    <!-- 配置SessionFactory -->
    <bean id="sessionFactory"   class = "org.springframework.orm.hibernate3.LocalSessionFactoryBean" >
      <property  name="configLocation"  value= "classpath:hibernate.cfg.xml" />
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionMgr"   class = "org.springframework.orm.hibernate3.HibernateTransactionManager" >
     <property name="sessionFactory" >
        <ref bean="sessionFactory" />
     </property>
    </bean>
    <!-- 配置事务传播特性 -->
    <tx:advice id="txAdvice"  transaction-manager= "transactionMgr" >
         <tx:attributes>
             <tx:method name="add*"  propagation= "REQUIRED" />
              <tx:method name="del*"  propagation= "REQUIRED" />
              <tx:method name="update*"  propagation= "REQUIRED" />
              <tx:method name="*"  read-only= "true" />
         </tx:attributes>
    </tx:advice>
    <!-- 那些类使用事务 -->
    <aop:config>
      <aop:pointcut id="point-cut"  expression= "execution(* com.wlh.spring.manager.*.*(..))" />
      <aop:advisor advice-ref="txAdvice"  pointcut-ref= "point-cut" />
    </aop:config>


</beans>

• 11:50
• 评论 / 浏览 (0 / 596)

2009-02-24

缩略显示

4 spring中bean的作用域

博客分类： 
• Spring

BeanSpringWebprototypeXML

bean的作用域这个概念很重要, 他是在spring的XML文件中配置的. 

在spring1.x中bean只有singleton(单例)、prototype2种作用域.

 

Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。Spring2.0有五种类型的Bean。

 

1、singleton作用域

   如果不指定scope,默认值即为 scope="singleton".

   bean的作用域设置为singleton时，Spring 只会为每一个bean创建一个实例,并保持bean的引用.

   配置实例：

 

<bean id="bean的id" class="bean的包名.类名" cope="singleton"/>

或

<bean id="bean的id" class="bean的包名.类名" singleton="true"/>

 

 

 

 

2、prototype

   prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）都会产生一个新的bean实例，相当于一个new的操作.

   spring一旦将实例交给(注入)客户端,就不再持有这个bean的引用 ,所以无法对 prototype作用域的bean定义destroy-method.清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。

配置实例：

 

<bean id="bean的id" class="bean的包名.类名" cope="prototype"/>

或

<beanidbeanid="bean的id" class="bean的包名.类名" singleton="false"/>

 

 

 

 

3、request

request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效.

配置实例：

request、session、global session使用的时候，首先要在初始化web的web.xml中做如下配置：

如果你使用的是Servlet 2.4及以上的web容器，那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可：

 

<web-app>
 ...
<listener>
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>
...
</web-app>

 

 

 

如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现：

 

<web-app>
 ...
<filter>
    <filter-name>requestContextFilter</filter-name>
    <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class> </filter>
<filter-mapping>
    <filter-name>requestContextFilter</filter-name>
    <url-pattern>/*</url-pattern>
 </filter-mapping>
...
</web-app>

 

接着既可以配置bean的作用域了：

<bean id="bean的id" class="bean的包名.类名" scope="request"/>

4、session

session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效.

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

 

<bean id="bean的id" class="bean的包名.类名" scope="session"/>

 

 

5、global session

global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么，web会自动当成session类型来使用。

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

 

<bean id="role" class="spring.chapter2.maryGame.Role" scope="global session"/>

 

 

6、自定义bean装配作用域

在spring 2.0中作用域是可以任意扩展的，你可以自定义作用域，甚至你也可以重新定义已有的作用域（但是你不能覆盖singleton和prototype），spring的作用域由接口org.springframework.beans.factory.config.Scope来定义，自定义自己的作用域只要实现该接口即可，下面给个实例：

我们建立一个线程的scope，该scope在表示一个线程中有效，代码如下：

 

 

publicclass MyScope implements Scope ...{ 
privatefinal ThreadLocal threadScope = new ThreadLocal() ...{
protected Object initialValue() ...{
returnnew HashMap(); 
} 
}; 
public Object get(String name, ObjectFactory objectFactory) ...{ 
Map scope = (Map) threadScope.get(); 
Object object = scope.get(name); 
if(object==null) ...{ 
object = objectFactory.getObject(); 
scope.put(name, object); 
} 
return object; 
} 
public Object remove(String name) ...{ 
Map scope = (Map) threadScope.get(); 
return scope.remove(name); 
}
publicvoid registerDestructionCallback(String name, Runnable callback) ...{ 
}
public String getConversationId() ...{
// TODO Auto-generated method stub
returnnull;
} 
}

 

 

 

 

 

 

 

• 15:18
• 评论 / 浏览 (0 / 1143)

2009-02-16

缩略显示

为什么要针对接口编程

博客分类： 
• Spring

编程JDBC框架

接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。

 

接口反映了系统设计人员对系统的抽象理解的程度。

 

接口都是在一定的环境中产生的。脱离原先的环境，所有的接口将失去原有的意义。

 

----------------

 

接口统一了，实现可以千差万别，我们都可以按相同的方式访问。拿JDBC来说，很多东西都是接口，实际上就像是个架子，各个不同的数据库厂商或者第三方根 据这个框架往里面塞具体的驱动实现，对于JDBC的使用者而言，这些都不必关心，按着JDBC的统一方式访问数据库就可以了，很多时候这样做也带来代码重 用的方便，对不同的数据库，只需要修改少量参数而不必修改具体访问细节，而这一步也很容易放到具体程序之外，从而使代码尽可能的独立于具体的数据库，这对 于程序的维护是很有好处的。

对于用户是不是真的需要知道具体类，我想：
1、就算真的需要知道具体的类，在类的对象产生后还有一个如何操纵对象的问题，假如程序中需要的具体对象所属的类不一样，但接口一致的话，那么我们很容易以利用多态写出更简洁且容易扩展的代码。
2、很多时候对象的最终的使用者和类/对象的构造者并不是同一个人，他们之间还需要一个抽象层作为contract，这个时候接口的作用还是很明显，就像前边提到的JDBC。

• 17:02
• 评论 / 浏览 (0 / 480)

2009-02-16

缩略显示

3 我对Spring的认识

博客分类： 
• Spring

SpringAOP编程IOC单元测试

Spring是一个实现了AOP功能的IoC容器, 是一个轻量级的框架.

 

利用Spring提供的AOP支持,可以简化代码逻辑,分离应用程序关注点.   声明式事务 就是基于AOP实现的.

 

Spring为我们提供了 依赖注入,AOP,事务抽象,基于模板的异常封装.

 

Spring将针对接口编程的思想发挥到了极致,好的设计比具体的实现技术更重要,一条通用的设计准则是将接口与实现分开,上层的调用者对底层的实现应当一无所知.比如JDK中的集合类接口.  

 

方便的 针对接口编程,利用依赖注入来解耦合, 方便编写单元测试.

 

• 16:45
• 评论 / 浏览 (1 / 323)

2009-02-13

缩略显示

2 Spring2.0用注解实现事务管理

博客分类： 
• Spring

配置管理SpringAOPBeanSQL

Spring2.0框架的事务处理有两大类:

1 编码式事务 , 这个不说.

2 声明式事务 , 就说这个.

 

声明式事务又有三种实现方法:

1 (第一种) 最早的方法,用TransactionProxyFactoryBean,他是一个有AOP代理功能的FactoryBean.他返回的对象有事务.

还要在spring的配置文件XML中配置,比较麻烦,不详细说.

<!-- 事务测试DAO -->
<bean id="go_TestPOAO" class="pic.dao.transaction_test.TestPOAOImpl" parent="go_POAOBase"></bean>

<!-- 事务测试DAO 声明式事务管理 -->
<bean id="go_TestPOAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="proxyInterfaces">
            <list>
                <value>pic.dao.transaction_test.TestPOAO</value>
            </list>
        </property>
        <property name="target" ref="go_TestPOAO"/>
        <property name="transactionManager" ref="transactionManager"/>
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
</bean>

 2 (第二种) 使用<tx:>来实现声明式事务 ,也要在spring的配置文件XML中配置,比较麻烦,不详细说.

<tx:advice id="">
.....
</tx:advice>

<aop:config>
.....
</aop:config>

 

 

3 (第三种) 这个方法方便,使用注解来实现声明式事务, 下面详细说说这个方法:

 

第一步:引入<tx:>命名空间 ,在spring的配置文件中修改, beans根元素里多了三行,如下

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

 

第二步:在spring的配置文件中修改,将所有具有@Transactional 注解的bean自动配置为声明式事务支持

<!--JDBC事务管理器,根据你的情况使用不同的事务管理器,如果工程中有Hibernate,就用Hibernate的事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref local="dataSource"/>
        </property>
</bean>

<!-- 用注解来实现事务管理 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

 

第三步: 在接口或类的声明处 ,写一个@Transactional. 要是只的接口上写, 接口的实现类就会继承下来.

接口的实现类的具体方法,还可以覆盖类声明处的设置.

@Transactional
public class TestPOAOImpl extends POAOBase implements TestPOAO
{
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void test1()
    {
        String sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解赵云',30)";
        execute(sql);

        sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解张飞',26)";
        execute(sql);

        int a = 9 / 0; //异常

        sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解关羽',33)";
        execute(sql);
        System.out.println("走完了");
    }
//execute() 方法略...
}

 

注意的几点:

1  @Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.

 

2 默认情况下,一个有事务方法, 遇到RuntiomeException 时会回滚 .  遇到 受检查的异常 是不会回滚 的. 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .

 

 

 

@Transactional  的所有可选属性如下:

 

属性	类型	默认值	说明
propagation	Propagation枚举	REQUIRED	事务传播属性 (下有说明)
isolation	isolation枚举	DEFAULT	事务隔离级别 (另有说明)
readOnly	boolean	false	是否只读
timeout	int	-1	超时(秒)
rollbackFor	Class[]	{}	需要回滚的异常类
rollbackForClassName	String[]	{}	需要回滚的异常类名
noRollbackFor	Class[]	{}	不需要回滚的异常类
noRollbackForClassName	String[]	{}	不需要回滚的异常类名

 

 

 事务的隔离级别 有如下可选:

可以去看spring源码 : org.springframework.transaction.annotation.Isolation

我的"隔离级别"相关文章   有不明白的,可以去看看.

 

DEFAULT	采用数据库默认隔离级别
READ_UNCOMMITTED	请看"隔离级别"相关文章
READ_COMMITTED	请看"隔离级别"相关文章
REPEATABLE_READ	请看"隔离级别"相关文章
SERIALIZABLE	请看 "隔离级别"相关文章

 

 

 

 

 

 

 

 

 

事务的传播属性 ,有如下可选

可以去看spring源码 : org.springframework.transaction.annotation.Propagation

 

REQUIRED	业务方法需要在一个事务中运行,如果方法运行时,已处在一个事务中,那么就加入该事务,否则自己创建一个新的事务.这是spring默认的传播行为.
SUPPORTS	如果业务方法在某个事务范围内被调用,则方法成为该事务的一部分,如果业务方法在事务范围外被调用,则方法在没有事务的环境下执行.
MANDATORY	只能在一个已存在事务中执行,业务方法不能发起自己的事务,如果业务方法在没有事务的环境下调用,就抛异常
REQUIRES_NEW	业务方法总是会为自己发起一个新的事务,如果方法已运行在一个事务中,则原有事务被挂起,新的事务被创建,直到方法结束,新事务才结束,原先的事务才会恢复执行.
NOT_SUPPORTED	声明方法需要事务,如果方法没有关联到一个事务,容器不会为它开启事务.如果方法在一个事务中被调用,该事务会被挂起,在方法调用结束后,原先的事务便会恢复执行.
NEVER	声明方法绝对不能在事务范围内执行,如果方法在某个事务范围内执行,容器就抛异常.只有没关联到事务,才正常执行.
NESTED	如果一个活动的事务存在,则运行在一个嵌套的事务中.如果没有活动的事务,则按REQUIRED属性执行.它使用了一个单独的事务, 这个事务拥有多个可以回滚的保证点.内部事务回滚不会对外部事务造成影响, 它只对DataSourceTransactionManager 事务管理器起效.

 

• 12:47
• 评论 / 浏览 (8 / 1061)
• 论坛回复 / 浏览 (8 / 5895)
• 分类:企业架构

2009-02-13

缩略显示

1 隔离级别(spring事务管理 )

博客分类： 
• Spring

SpringOracleMySQLSQL ServerSQL

数据库提供了四种事务隔离级别, 不同的隔离级别采用不同的锁类开来实现.

在四种隔离级别中, Serializable的级别最高, Read Uncommited级别最低.

大多数数据库的默认隔离级别为: Read Commited,如Sql Server , Oracle.

少数数据库默认的隔离级别为Repeatable Read, 如MySQL InnoDB存储引擎

即使是最低的级别,也不会出现 第一类 丢失 更新问题 .

• Read Uncommited :读未提交数据( 会出现脏读,不可重复读,幻读 ,避免了 第一类丢失 更新 )
  
• Read Commited :读已提交的数据(会出现不可重复读,幻读)
  
• Repeatable Read :可重复读(会出现幻读)
  
• Serializable :串行化

 

丢失 更新   : 
当两个或多个事务选择同一行，然后基于最初选定的值更新该行时，会发生丢失更新问题。每个事务都不知道其它事务的存在。最后的更新将重写由其它事务所做的更新，这将导致数据丢失。 　　
例:
事务A和事务B同时修改某行的值，
1.事务A将数值改为1并提交
2.事务B将数值改为2并提交。
这时数据的值为2，事务A所做的更新将会丢失。 
解决办法：对行加锁，只允许并发一个更新事务。

 

脏读: 一个事务读到另一个事务未提交的更新数据

例:

1.Mary的原工资为1000, 财务人员将Mary的工资改为了8000(但未提交事务)         
2.Mary读取自己的工资 ,发现自己的工资变为了8000，欢天喜地！
3.而财务发现操作有误，回滚了事务,Mary的工资又变为了1000, 像这样,Mary记取的工资数8000是一个脏数据。

 

不可重复读: 在同一个事务中,多次读取同一数据,返回的结果有所不同. 换句话说就是,后续读取可以读到另一个事务已提交的更新数据. 相反"可重复读"在同一事务多次读取数据时,能够保证所读数据一样,也就是后续读取不能读到另一事务已提交的更新数据.

例:

1.在事务1中，Mary 读取了自己的工资为1000,操作并没有完成
2.在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.
3.在事务1中，Mary 再次读取自己的工资时，工资变为了2000
解决办法：如果只有在修改事务完全提交之后才可以读取数据，则可以避免该问题。

 

幻读: 一个事务读取到另一个事务已提交的insert数据.

例:

第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时 (此时第一事务还未提交) ，第二个事务向表中插入一行新数据。这时第一个事务再去读取表时,发现表中还有没有修改的数据行，就好象发生了幻觉一样。

 

 

 

 

评论

2 楼 chokee 2015-05-14  

1 楼 幻影桃花源 2011-12-22  

太好了，謝謝