what’s new in spring 3

spring3发布已经很久了，但现在为止还不太清楚spring3到底增加了些什么内容，好像一夜之间，就从spring2.x升级到了spring3了，也没感觉到有什么变化。不过的确，对于使用ssh的人来说，spring确实没带来太多的惊喜。除了spring mvc增强之外，其它的部分也暂时用不上了。从网上找到一个英文版的《what's new in spring 3》pdf，原文作者为Habuma。简单翻译一下，从spring1到spring3作一个升级性的描述，看每个版本都增加了什么。以方便直接使用spring3或从spring2升级上来的开发人员从总体上对spring有一个了解和把握。

 

单从配置文件上来说，从spring1.x开始，开始使用了基于bean的声明式语法，所有的声明都是以bean开头的，即便是事务也是以继承AbstractTransactionBeanProxy来实现的；从spring2开始，就有了命名空间了，其中事务可以以tx命名空间开始，aop也可以aop命名空间开始了；到spring2.5，加入了注解的概念，开始让配置文件有所简化，spring也走上了一个从xml到annotation发展的道路。

 

第一部分：功能的增强
spring1.0
Dependency Injection：引入了依赖注入的思想，使得对象之间的关系更好地进行维护了；
POJO-oriented development：引进了而向pojo开发的编程开式，所有的对象都可以为简单的java对象；
Declarative AOP and transactions：申明式事务以及面向切面编程的支持，可以通过继承beanTransaction的方式进行事务编程；
MVC framework：引入了一个简单的mvc开发框架，从web层面提出一个开发方式。

spring2.0
Problem-specific XML：更简单的xml书写方式，提供命名空间支持；
Extensible configuration：支持自定义xml解析器，可以增加第三方的xml解析方式；
Bean scoping：bean生命周期的支持，可以增加为request,session周期内了；
Groovy, JRuby, and BeanShell：脚本语言支持；
JSP tag library：提供了一套mvc标签库，mvc框架增强；
Java 5 autoboxing and generics：java5的自动包装和解包，在配置层面可以直接用数字等代替了

Spring2.5
Annotation-driven wiring：提供了基于注解的配置方式，可以在java类上直接使用注解来将对象配置成一个bean；
Automatic bean configuration：提供自动发现机制，通过声明一个package，使spring直接从一个package中寻找bean并自动配置；
New annotation-driven MVC framework：mvc框架增强，提供@Controller等注解；
JUnit 4-based integration testing：junit4整合测试，使用基于注解的测试方式

第二部分：书写方式的变化
spring1.0
标签<property>和<value>以及和<ref>必须分开写，即首先写一个<property>标签，再在里面写一个<value>标签。

 

改进了1.0的写法，替代<value>标签，value可以直接作为一个属性写在<property>里面了，即如下的书写方式：

 

 

<property name="color" value="blue" />

 

spring2.0
提供了命名空间的支持，即不再需要书写<property>标签了，而是以命名空间属性的方式来书写，将属性直接写在bean声明中：

<bean id="linus"      class="com.springinaction.peanuts.Linus"      p:blanket-ref="blanket" />

 spring2.5
提供了自动发现机制，可以直接从一个package中寻找所有的bean配置了：

<context:component-scan   base-package="com.springinaction.peanuts" />

 

第三部分：spring3带来了什么
Spring Expression Language
spring解析式语言，和ognl相同的一套语法解析器，可以在spring配置文件中，注解配置中使用表达式，来从另一个地方读取一些数据，或者直接引用另一个对象的一些属性。支持的引用范围有：

• Any bean ID：所有的bean都可以通过#{beanId}进行引用
• systemProperties：系统变量，读取系统环境变量，通过#{systemProperties.favoriteColor}的读取方式
• Scope/Context-specific：上下文变量，如request,session等

MVC增强

• @RequestParam：在mvc方法中使用注解来注入一个界面参数（spring2.5)
• @PathVariable：不再使用参数，而是使用更rest的路径变量来进行注入，如http://localhost:8080/spitter/{name}/list，来注入name变量
• @RequestHeader：请求头注入，直接从request请求头信息中读取信息
• @CookieValue：从cookie中读取注入信息
• DefaultValue：除注入信息外，可以提供默认的信息

声明式验证
通过支持Hibernate or JSR-303来达到bean自动验证的目的

ETag Support
通过ShallowEtagHeaderFilter来达到界面缓存的目的，如果数据没变化，直接返回相应的界面，而不再进行请求
HTTP Methods支持
通过@RequestMapping来支持http put和delete请求
多种view支持
支持其它界面展现形式，比如json,rss等

总结
从spring1.x到spring3.x，总的一个思路是spring在向着使开发更简单化发展，当然随着技术的进步，本身也会越来越复杂，但复杂是仅指在框架内部，在使用上是越来越简单的。包括从xml的配置全面转向Annotataion，都表明了spring是向着使开发更简单的目标前进的。

 

=====转载http://www.iflym.com/index.php/code/whats-new-in-spring-3-english-translate.html================

 

SpringMVC：

 

1:mvc annotation-driven 新增标签
以下为spring mvc 3.1中annotation-driven所支持的全部配置。

<
mvc:annotation-driven
  
message-codes-resolver
 =
"bean ref"
 
validator
=
""
 
conversion-service
=
""
>

     <
mvc:return-value-handlers
>
        <
bean
>
</
bean
>
    </
mvc:return-value-handlers
>

    <
mvc:argument-resolvers
>
    </
mvc:argument-resolvers
>

    <
mvc:message-converters
>
    </
mvc:message-converters
>
[/color]
</
mvc:annotation-driven
>

<mvc:annotation-driven  message-codes-resolver ="bean ref" validator="" conversion-service="">
   
     <mvc:return-value-handlers>
        <bean></bean>
    </mvc:return-value-handlers>
    
    <mvc:argument-resolvers>
    </mvc:argument-resolvers>
    
    <mvc:message-converters>
    </mvc:message-converters>[/color]
</mvc:annotation-driven>

其中3.1新增部分如下
return-value-handlers
允许注册实现了HandlerMethodReturnValueHandler接口的bean，来对handler method的特定的返回类型做处理。
HandlerMethodReturnValueHandler接口中定义了两个方法
supportsReturnType 方法用来确定此实现类是否支持对应返回类型。
handleReturnValue 则用来处理具体的返回类型。

例如以下的handlerMethod

@RequestMapping
(
"/testReturnHandlers"
)
public
 User testHandlerReturnMethod(){
    User u  = new
 User();
    u.setUserName("test"
);
    return
 u;
}

	@RequestMapping("/testReturnHandlers")
	public User testHandlerReturnMethod(){
		User u  = new User();
		u.setUserName("test");
		return u;
	}

所返回的类型为一个pojo，正常情况下spring mvc无法解析，将转由DefaultRequestToViewNameTranslator 解析出一个缺省的view name，转到 testReturnHandlers.jsp，
我们增加以下配置

<
mvc:annotation-driven
 
validator
=
"validator"
>
color
=
red
]        
<
mvc:return-value-handlers
>
           <
bean
  
class
=
"net.zhepu.web.handlers.returnHandler.UserHandlers"
>
</
bean
>
    </
mvc:return-value-handlers
>
[/color]
</
mvc:annotation-driven
>

	<mvc:annotation-driven validator="validator">
[color=red]        <mvc:return-value-handlers> 
            <bean  class="net.zhepu.web.handlers.returnHandler.UserHandlers"></bean> 
		</mvc:return-value-handlers>[/color]
	</mvc:annotation-driven>

及如下实现类

public
 
class
 UserHandlers 
implements
 HandlerMethodReturnValueHandler {
    Logger logger = LoggerFactory.getLogger(this
.getClass());
    @Override
    public
 
boolean
 supportsReturnType(MethodParameter returnType) {
        Class<?> type = returnType.getParameterType();
        if
(User.
class
.equals(type))
        {
            return
 
true
;
        }
        return
 
false
;
    }

    @Override
    public
 
void
 handleReturnValue(Object returnValue,
            MethodParameter returnType, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest) throws
 Exception {
        logger.info("handler  for return type users "
);
        mavContainer.setViewName("helloworld"
);
    }

}

public class UserHandlers implements HandlerMethodReturnValueHandler {
    Logger logger = LoggerFactory.getLogger(this.getClass());
	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		Class<?> type = returnType.getParameterType();
		if(User.class.equals(type))
		{
			return true;
		}
		return false;
	}

	@Override
	public void handleReturnValue(Object returnValue,
			MethodParameter returnType, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest) throws Exception {
		logger.info("handler  for return type users ");
		mavContainer.setViewName("helloworld");
	}

}

此时再访问 http://localhost:8080/springmvc/testReturnHandlers ，将交由 UserHandlers来处理返回类型为User的返回值。

argument-resolvers
允许注册实现了WebArgumentResolver接口的bean，来对handlerMethod中的用户自定义的参数或annotation进行解析
例如

<
mvc:annotation-driven
 
validator
=
"validator"
>
    <
mvc:argument-resolvers
>
        <
bean
            class
=
"net.zhepu.web.handlers.argumentHandler.MyCustomerWebArgumentHandler"
 
/>
    </
mvc:argument-resolvers
>

</
mvc:annotation-driven
>

	<mvc:annotation-driven validator="validator">
		<mvc:argument-resolvers>
			<bean
				class="net.zhepu.web.handlers.argumentHandler.MyCustomerWebArgumentHandler" />
		</mvc:argument-resolvers>

	</mvc:annotation-driven>

对应java代码如下

public
 
class
 MyCustomerWebArgumentHandler 
implements
 WebArgumentResolver {

    @Override
    public
 Object resolveArgument(MethodParameter methodParameter,
            NativeWebRequest webRequest) throws
 Exception {
        if
 (methodParameter.getParameterType().equals(MyArgument.
class
)) {
            MyArgument argu = new
 MyArgument();
            argu.setArgumentName("winzip"
);
            argu.setArgumentValue("123456"
);
            return
 argu;
        }
        return
 UNRESOLVED;
    }

}

public class MyCustomerWebArgumentHandler implements WebArgumentResolver {

	@Override
	public Object resolveArgument(MethodParameter methodParameter,
			NativeWebRequest webRequest) throws Exception {
		if (methodParameter.getParameterType().equals(MyArgument.class)) {
			MyArgument argu = new MyArgument();
			argu.setArgumentName("winzip");
			argu.setArgumentValue("123456");
			return argu;
		}
		return UNRESOLVED;
	}

}

这里我们定义了一个 customer webArgumentHandler，当handler method中参数类型为 MyArgument时生成对参数的类型绑定操作。
注意新注册的webArgumentHandler的优先级最低，即如果系统缺省注册的ArgumentHandler已经可以解析对应的参数类型时，就不会再调用到新注册的customer ArgumentHandler了。

message-converters
允许注册实现了HttpMessageConverter接口的bean，来对requestbody 或responsebody中的数据进行解析
例如
假设我们使用 text/plain格式发送一串字符串来表示User对象，各个属性值使用”|”来分隔。例如 winzip|123456|13818888888，期望转为user对象，各属性内容为user.username = winzip,user.password=123456;user.mobileNO = 13818888888
以下代码中supports表示此httpmessageConverter实现类针对 User类进行解析。
构造函数中调用 super(new MediaType("text", "plain"));以表示支持 text/plain格式的输入。

public
 
class
 MyCustomerMessageConverter 
extends
        AbstractHttpMessageConverter<Object> {
    @Override
    protected
 
boolean
 supports(Class<?> clazz) {
        if
 (clazz.equals(User.
class
)) {
            return
 
true
;
        }
        return
 
false
;
    }

    public
 MyCustomerMessageConverter() {
        super
(
new
 MediaType(
"text"
, 
"plain"
));
    }

    @Override
    protected
 Object readInternal(Class<? 
extends
 Object> clazz,
            HttpInputMessage inputMessage) throws
 IOException,
            HttpMessageNotReadableException {
        Charset charset;
        MediaType contentType = inputMessage.getHeaders().getContentType();
        if
 (contentType != 
null
 && contentType.getCharSet() != 
null
) {
            charset = contentType.getCharSet();
        } else
 {
            charset = Charset.forName("UTF-8"
);
        }
        String input = FileCopyUtils.copyToString(new
 InputStreamReader(
                inputMessage.getBody(), charset));
        logger.info(input);
        String[] s = input.split("\\|"
);
        User u = new
 User();
        u.setUserName(s[0
]);
        u.setPassword(s[1
]);
        u.setMobileNO(s[2
]);
        return
 u;
    }

    @Override
    protected
 
void
 writeInternal(Object t, HttpOutputMessage outputMessage)
            throws
 IOException, HttpMessageNotWritableException {

    }

public class MyCustomerMessageConverter extends
		AbstractHttpMessageConverter<Object> {
	@Override
	protected boolean supports(Class<?> clazz) {
		if (clazz.equals(User.class)) {
			return true;
		}
		return false;
	}

	public MyCustomerMessageConverter() {
		super(new MediaType("text", "plain"));
	}

	@Override
	protected Object readInternal(Class<? extends Object> clazz,
			HttpInputMessage inputMessage) throws IOException,
			HttpMessageNotReadableException {
		Charset charset;
		MediaType contentType = inputMessage.getHeaders().getContentType();
		if (contentType != null && contentType.getCharSet() != null) {
			charset = contentType.getCharSet();
		} else {
			charset = Charset.forName("UTF-8");
		}
		String input = FileCopyUtils.copyToString(new InputStreamReader(
				inputMessage.getBody(), charset));
		logger.info(input);
		String[] s = input.split("\\|");
		User u = new User();
		u.setUserName(s[0]);
		u.setPassword(s[1]);
		u.setMobileNO(s[2]);
		return u;
	}

	@Override
	protected void writeInternal(Object t, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {

	}

修改servlet context xml配置文件，增加message-converters的相应配置如下。

<
mvc:message-converters
>
    <
bean
 
class
=
"net.zhepu.web.handlers.messageConverterHandler.MyCustomerMessageConverter"
>
</
bean
>
</
mvc:message-converters
>

        <mvc:message-converters>
            <bean class="net.zhepu.web.handlers.messageConverterHandler.MyCustomerMessageConverter"></bean>
        </mvc:message-converters>

message-codes-resolver
先看看spring mvc中对于messageCodeResolver的用法。
spring mvc中使用DefaultMessageCodesResolver作为缺省的MessageCodesResolver的实现类，其作用是对valid errors中的errorcode进行解析。其解析方式如下
当解析error global object注册的errorcode时，errorcode的查找顺序为
1：errorcode.validationobjectname
2：errorcode
例如
以下声明中

public
 String helloWorld2(
@ModelAttribute
(
"user"
) User u,
            BindingResult result)

public String helloWorld2(@ModelAttribute("user") User u,
			BindingResult result)

当使用 result.reject("testFlag");来注册一个globat error object时，spring mvc将在messageSource中先查找 testFlag.user这个errorcode,当找不到时再查找testFlag这个errorcode。

当解析fields error时，将按以下顺序生成error code
1.: code + "." + object name + "." + field
2.: code + "." + field
3.: code + "." + field type
4.: code

还是以上面的代码为例，当使用 result.rejectValue("userName", "testFlag");来注册一个针对user.UserName属性的错误描述时，errors对象中将生成以下的error code list,
1.: testFlag.user.userName
2.: testFlag.userName
3.: testFlag.java.lang.String
4.: testFlag

而mvc:annotation-driven新增的属性message-codes-resolver则提供了注册自定义的MessageCodesResolver的手段。
例如上面想要在所有的error code前增加前缀validation.的话，可以这么来做

<
mvc:annotation-driven
 
validator
=
"validator"
 
message-codes-resolver
=
"messageCodeResolver"
>
</
mvc:annotation-driven
>

<mvc:annotation-driven validator="validator" message-codes-resolver="messageCodeResolver">
</mvc:annotation-driven>

新增messageCodeResolver bean定义如下

<bean id=
"messageCodeResolver"
 
class
=
"org.springframework.validation.DefaultMessageCodesResolver"
>
    <property name="prefix"
 value=
"validation."
></property>
</bean>

	<bean id="messageCodeResolver" class="org.springframework.validation.DefaultMessageCodesResolver">
	    <property name="prefix" value="validation."></property>
	</bean>

此时，所有的errorcode都会生成缺省前缀 validation.
例如前面的 result.reject("testFlag"); 生成的error code list就变为了
validation.testFlag.user 和 validation.testFlag了。




2: @RequestMapping 新增参数Consumes 和Produces
前面介绍过@RequestMapping的参数中有一个header的参数，来指定handler method能接受的http request 请求的header内容。
而consumes和produces则更进一步，直接指定所能接受或产生的request请求的content type。
例如

@RequestMapping
(value=
"/testMsgConverter"
,consumes=
"text/plain"
,produces=
"application/json"
)

@RequestMapping(value="/testMsgConverter",consumes="text/plain",produces="application/json")

表示handlermethod接受的请求的header中的 Content-Type为text/plain;
Accept为application/json


3: URI Template 新增功能
这部分的例子直接照抄Spring 3.1 M2: Spring MVC Enhancements 中的示例

1: @PathVariable 声明的参数可自动加入到model中。
例如

@RequestMapping
(
"/develop/apps/edit/{slug}"
)
public
 String editForm(
@PathVariable
 String slug, Model model) {
    model.addAttribute("slug"
, slug);
    // ...
}

@RequestMapping("/develop/apps/edit/{slug}")
public String editForm(@PathVariable String slug, Model model) {
	model.addAttribute("slug", slug);
    // ...
}

现在可以写为

@RequestMapping
(
"/develop/apps/edit/{slug}"
)
public
 String editForm(
@PathVariable
 String slug, Model model) {
    // model contains "slug" variable
}

@RequestMapping("/develop/apps/edit/{slug}")
public String editForm(@PathVariable String slug, Model model) {
    // model contains "slug" variable
}

2：handler method中的redirect string可支持url template了
例如

@RequestMapping
(
    value="/groups/{group}/events/{year}/{month}/{slug}/rooms"
,
    method=RequestMethod.POST)
public
 String createRoom(
    @PathVariable
 String group, 
@PathVariable
 Integer year,
    @PathVariable
 Integer month, 
@PathVariable
 String slug) {
    // ...
    return
 
"redirect:/groups/"
 + group + 
"/events/"
 + year + 
"/"
 + month + 
"/"
 + slug;
}

@RequestMapping(
    value="/groups/{group}/events/{year}/{month}/{slug}/rooms",
    method=RequestMethod.POST)
public String createRoom(
    @PathVariable String group, @PathVariable Integer year,
    @PathVariable Integer month, @PathVariable String slug) {
    // ...
    return "redirect:/groups/" + group + "/events/" + year + "/" + month + "/" + slug;
}

现在可写为

@RequestMapping
(
    value="/groups/{group}/events/{year}/{month}/{slug}/rooms"
,
    method=RequestMethod.POST)
public
 String createRoom(
    @PathVariable
 String group, 
@PathVariable
 Integer year,
    @PathVariable
 Integer month, 
@PathVariable
 String slug) {
    // ...
    return
 
"redirect:/groups/{group}/events/{year}/{month}/{slug}"
;
}

@RequestMapping(
    value="/groups/{group}/events/{year}/{month}/{slug}/rooms",
    method=RequestMethod.POST)
public String createRoom(
    @PathVariable String group, @PathVariable Integer year,
    @PathVariable Integer month, @PathVariable String slug) {
    // ...
    return "redirect:/groups/{group}/events/{year}/{month}/{slug}";
}

3：url template中可支持databinding 了
例如

@RequestMapping
(
"/people/{firstName}/{lastName}/SSN"
)
public
 String find(Person person,
                   @PathVariable
 String firstName,
                   @PathVariable
 String lastName) {
    person.setFirstName(firstName);
    person.setLastName(lastName);
    // ...
}

@RequestMapping("/people/{firstName}/{lastName}/SSN")
public String find(Person person,
                   @PathVariable String firstName,
                   @PathVariable String lastName) {
    person.setFirstName(firstName);
    person.setLastName(lastName);
    // ...
}

现在可以写成

@RequestMapping
(
"/people/{firstName}/{lastName}/SSN"
)
public
 String search(Person person) {
    // person.getFirstName() and person.getLastName() are populated
    // ...
}

@RequestMapping("/people/{firstName}/{lastName}/SSN")
public String search(Person person) {
    // person.getFirstName() and person.getLastName() are populated
    // ...
}

4: Validation For @RequestBody

@RequestBody现在直接支持@valid标注了,如果validation失败，将抛出
RequestBodyNotValidException。
具体处理逻辑可见 spring 中的RequestResponseBodyMethodProcessor中的以下代码。

public
 Object resolveArgument(MethodParameter parameter,
                                  ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest,
                                  WebDataBinderFactory binderFactory) throws
 Exception {
        Object arg = readWithMessageConverters(webRequest, parameter, parameter.getParameterType());
        if
 (shouldValidate(parameter, arg)) {
            String argName = Conventions.getVariableNameForParameter(parameter);
            WebDataBinder binder = binderFactory.createBinder(webRequest, arg, argName);
            binder.validate();
            Errors errors = binder.getBindingResult();
            if
 (errors.hasErrors()) {
                throw
 
new
 RequestBodyNotValidException(errors);
            }
        }
        return
 arg;
    }

	
public Object resolveArgument(MethodParameter parameter,
								  ModelAndViewContainer mavContainer,
								  NativeWebRequest webRequest,
								  WebDataBinderFactory binderFactory) throws Exception {
		Object arg = readWithMessageConverters(webRequest, parameter, parameter.getParameterType());
		if (shouldValidate(parameter, arg)) {
			String argName = Conventions.getVariableNameForParameter(parameter);
			WebDataBinder binder = binderFactory.createBinder(webRequest, arg, argName);
			binder.validate();
			Errors errors = binder.getBindingResult();
			if (errors.hasErrors()) {
				throw new RequestBodyNotValidException(errors);
			}
		}
		return arg;
	}

5:annotation-driven缺省注册类的改变

Spring 3.0.x中使用了annotation-driven后，缺省使用DefaultAnnotationHandlerMapping 来注册handler method和request的mapping关系。

AnnotationMethodHandlerAdapter来在实际调用handlermethod前对其参数进行处理。

并在dispatcherServlet中，当用户未注册自定义的ExceptionResolver时，注册AnnotationMethodHandlerExceptionResolver来对使用@ExceptionHandler标注的异常处理函数进行解析处理(这也导致当用户注册了自定义的exeptionResolver时将可能导致无法处理@ExceptionHandler)。

在spring mvc 3.1中，对应变更为
DefaultAnnotationHandlerMapping -> RequestMappingHandlerMapping
AnnotationMethodHandlerAdapter -> RequestMappingHandlerAdapter
AnnotationMethodHandlerExceptionResolver -> ExceptionHandlerExceptionResolver

以上都在使用了annotation-driven后自动注册。
而且对应分别提供了AbstractHandlerMethodMapping , AbstractHandlerMethodAdapter和 AbstractHandlerMethodExceptionResolver以便于让用户更方便的实现自定义的实现类。