springMVC 注解版

时间：2014-05-31 18:36:49 阅读：619 评论：0 收藏：0 [点我收藏+]

关于Spring MVC注解 @Transactional 事务标签 @InitBinder 标签

分类： Java开发源代码分享2012-06-14 10:59 7721人阅读评论(2) 收藏举报

主要用到了spring-aop-2.5.6.jar的AOP支持包！

之前我们在AccountService中加入了注解@Transactional标签，但是要想要真正发挥事务作用，还需要一些配置。
主要需要调整dao.xml文件
dao.xml-事务管理

Xml代码

<bean
id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource" />
<tx:annotation-driven
transaction-manager="transactionManager" />

[xml] view plain copy

<bean
id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource" />
<tx:annotation-driven
transaction-manager="transactionManager" />

[xml] view plain copy

<bean
id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource" />
<tx:annotation-driven
transaction-manager="transactionManager" />

细化一下AccountService接口方法
AccountService.java

Java代码

/**
* 2010-1-23
*/
package org.zlex.spring.service;
import org.springframework.dao.DataAccessException;
import org.springframework.transaction.annotation.Transactional;
import org.zlex.spring.domain.Account;
/**
* 账户业务接口
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
public interface AccountService {
/**
* 获得账户
*
* @param username
* @param password
* @return
*/
@Transactional(readOnly = true)
Account read(String username, String password);
/**
* 获得账户
*
* @param id
* @return
*/
@Transactional(readOnly = true)
Account read(int id);
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
}

[java] view plain copy

/**
* 2010-1-23
*/
package org.zlex.spring.service;
import org.springframework.dao.DataAccessException;
import org.springframework.transaction.annotation.Transactional;
import org.zlex.spring.domain.Account;
/**
* 账户业务接口
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
public interface AccountService {
/**
* 获得账户
*
* @param username
* @param password
* @return
*/
@Transactional(readOnly = true)
Account read(String username, String password);
/**
* 获得账户
*
* @param id
* @return
*/
@Transactional(readOnly = true)
Account read(int id);
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
}

[java] view plain copy

/**
* 2010-1-23
*/
package org.zlex.spring.service;
import org.springframework.dao.DataAccessException;
import org.springframework.transaction.annotation.Transactional;
import org.zlex.spring.domain.Account;
/**
* 账户业务接口
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
public interface AccountService {
/**
* 获得账户
*
* @param username
* @param password
* @return
*/
@Transactional(readOnly = true)
Account read(String username, String password);
/**
* 获得账户
*
* @param id
* @return
*/
@Transactional(readOnly = true)
Account read(int id);
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
}

这里我把注解@Transactional调整到了具体的方法上，也就是说这样写的话，凡是加入注解的标注的方法都属于事务配置！
Account register(Account account);用做用户注册作用！
@Transactional(readOnly = true)只读属性
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)只读关闭，遇到DataAccessException异常回滚！如果不对异常进行处理，该异常将一直向上层抛出，直至抛出到页面！
如果你的Eclipse集成了SpringIDE，你可以观察一下这时的xml配置文件和AccoutServiceImpl.java的变化！
bubuko.com,布布扣

这次，来个用户注册功能演示，故意在某个位置制造一个异常，看看是否正常回滚！
先看注册控制器
RegisterController.java

Java代码

/**
* 2010-2-4
*/
package org.zlex.spring.controller;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.zlex.spring.domain.Account;
import org.zlex.spring.service.AccountService;
/**
* 用户注册控制器
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
@Controller
@RequestMapping(value = "/register.do")
public class RegisterController {
@Autowired
private AccountService accountService;
@InitBinder
public void initBinder(WebDataBinder binder) {
// 忽略字段绑定异常
// binder.setIgnoreInvalidFields(true);
DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
binder.registerCustomEditor(Date.class, "birthday",
new CustomDateEditor(format, true));
}
@RequestMapping(method = RequestMethod.GET)
public String initForm(ModelMap model) {
Account account = new Account();
model.addAttribute("account", account);
// 直接跳转到登录页面
return "account/register";
}
@RequestMapping(method = RequestMethod.POST)
protected String submit(@ModelAttribute("account") Account account) {
int id = accountService.register(account).getId();
// 跳转到用户信息页面
return "redirect:profile.do?id=" + id;
}
}

[java] view plain copy

/**
* 2010-2-4
*/
package org.zlex.spring.controller;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.zlex.spring.domain.Account;
import org.zlex.spring.service.AccountService;
/**
* 用户注册控制器
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
@Controller
@RequestMapping(value = "/register.do")
public class RegisterController {
@Autowired
private AccountService accountService;
@InitBinder
public void initBinder(WebDataBinder binder) {
// 忽略字段绑定异常
// binder.setIgnoreInvalidFields(true);
DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
binder.registerCustomEditor(Date.class, "birthday",
new CustomDateEditor(format, true));
}
@RequestMapping(method = RequestMethod.GET)
public String initForm(ModelMap model) {
Account account = new Account();
model.addAttribute("account", account);
// 直接跳转到登录页面
return "account/register";
}
@RequestMapping(method = RequestMethod.POST)
protected String submit(@ModelAttribute("account") Account account) {
int id = accountService.register(account).getId();
// 跳转到用户信息页面
return "redirect:profile.do?id=" + id;
}
}

[java] view plain copy

/**
* 2010-2-4
*/
package org.zlex.spring.controller;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.zlex.spring.domain.Account;
import org.zlex.spring.service.AccountService;
/**
* 用户注册控制器
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
@Controller
@RequestMapping(value = "/register.do")
public class RegisterController {
@Autowired
private AccountService accountService;
@InitBinder
public void initBinder(WebDataBinder binder) {
// 忽略字段绑定异常
// binder.setIgnoreInvalidFields(true);
DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
binder.registerCustomEditor(Date.class, "birthday",
new CustomDateEditor(format, true));
}
@RequestMapping(method = RequestMethod.GET)
public String initForm(ModelMap model) {
Account account = new Account();
model.addAttribute("account", account);
// 直接跳转到登录页面
return "account/register";
}
@RequestMapping(method = RequestMethod.POST)
protected String submit(@ModelAttribute("account") Account account) {
int id = accountService.register(account).getId();
// 跳转到用户信息页面
return "redirect:profile.do?id=" + id;
}
}

@InitBinder用于表单自定义属性绑定。这里我们要求输入一个日期格式的生日。
@RequestMapping(method = RequestMethod.GET)用于初始化页面。
@RequestMapping(method = RequestMethod.POST)用于提交页面。
再看注册页面
register.jsp

Jsp代码

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>注册</title>
<link rel="stylesheet" type="text/css" href="css/style.css" />
<script type="text/javascript" src="js/calendar.js"></script>
</head>
<body>
<fieldset><legend>用户注册</legend><form:form
commandName="account">
<ul>
<li><form:label path="username">用户名:</form:label><form:input
path="username" /></li>
<li><form:label path="password">密码:</form:label><form:password
path="password" /></li>
<li><form:label path="birthday">生日:</form:label><form:input
path="birthday" onfocus="showDate(this);" /></li>
<li><form:label path="email">Email:</form:label><form:input
path="email" /></li>
<li>
<button type="submit">注册</button>
<button type="reset">重置</button>
</li>
</ul>
</form:form></fieldset>
</body>
</html>

这里我用了一个JavaScript日期控制标签：

Html代码

<script type="text/javascript" src="js/calendar.js"></script>

[html] view plain copy

<script type="text/javascript" src="js/calendar.js"></script>

[html] view plain copy

<script type="text/javascript" src="js/calendar.js"></script>

使用起来就像是这样：
bubuko.com,布布扣
非常好用！！！当然，你完全可以使用JE上的那个JS控件！
接下来稍微调整一下AccountService接口及其实现AccountServiceImpl
AccountService.java

Java代码

public interface AccountService {
// 省略
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
// 省略
}

[java] view plain copy

public interface AccountService {
// 省略
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
// 省略
}

[java] view plain copy

public interface AccountService {
// 省略
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
// 省略
}

Java代码

@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
// 省略
@Override
public Account register(Account account) {
accountDao.create(account);
return accountDao.read(account.getUsername());
}
}

[java] view plain copy

@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
// 省略
@Override
public Account register(Account account) {
accountDao.create(account);
return accountDao.read(account.getUsername());
}
}

[java] view plain copy

@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
// 省略
@Override
public Account register(Account account) {
accountDao.create(account);
return accountDao.read(account.getUsername());
}
}

为了在插入一条记录后获得当前用户的主键，我们还得这么玩！的确有点雷人～
从架构考虑，这是符合业务要求的实现！如果用iBatis或者Hibernate，这个问题就有数据库一次IO处理完成了！
再看看AccountDao接口及其实现AccountDaoImpl
AccountDao.java

Java代码

public interface AccountDao {
// 省略
/**
* 构建用户记录
*
* @param account
* @return
*/
void create(Account account);
}

[java] view plain copy

public interface AccountDao {
// 省略
/**
* 构建用户记录
*
* @param account
* @return
*/
void create(Account account);
}

[java] view plain copy

public interface AccountDao {
// 省略
/**
* 构建用户记录
*
* @param account
* @return
*/
void create(Account account);
}

AccountDaoImpl.java

Java代码

@Repository
public class AccountDaoImpl implements AccountDao {
// 省略
@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
}
}

[java] view plain copy

@Repository
public class AccountDaoImpl implements AccountDao {
// 省略
@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
}
}

[java] view plain copy

@Repository
public class AccountDaoImpl implements AccountDao {
// 省略
@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
}
}

来个注册演示！ bubuko.com,布布扣
注册：

信息展示：

来制造一起事故！
先看看数据库目前的状况！

在AccountDaoImpl中来个破坏！

Java代码

@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
throw new RecoverableDataAccessException("TEST");
}

[java] view plain copy

@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
throw new RecoverableDataAccessException("TEST");
}

[java] view plain copy

@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
throw new RecoverableDataAccessException("TEST");
}

我们强行在执行完Insert语句后抛出DataAccessException异常（RecoverableDataAccessException）！ bubuko.com,布布扣
来个注册试试！

Spring 注解学习手札（五）业务层事务处理

博客分类：

Spring

Spring AOP Web Blog SQL

控制器层、持久层都有了一些介绍，剩下的就是业务层了！
业务层中的关键问题在于事务控制！Spring的注解式事务处理其实很简单！ bubuko.com,布布扣

相关参考：
Spring 注解学习手札（一）构建简单Web应用
 Spring 注解学习手札（二）控制层梳理
 Spring 注解学习手札（三）表单页面处理
 Spring 注解学习手札（四）持久层浅析
 Spring 注解学习手札（五）业务层事务处理
 Spring 注解学习手札（六）测试
 Spring 注解学习手札（七）补遗——@ResponseBody，@RequestBody，@PathVariable
Spring 注解学习手札（八）补遗——@ExceptionHandler

这里将用到以下几个包：

引用

aopalliance-1.0.jar
commons-collections.jar
commons-dbcp.jar
commons-logging-1.1.1.jar
commons-pool.jar
jstl.jar
log4j-1.2.15.jar
mysql-connector-java-5.1.6-bin.jar
spring-aop-2.5.6.jar
spring-beans-2.5.6.jar
spring-context-2.5.6.jar
spring-context-support-2.5.6.jar
spring-core-2.5.6.jar
spring-jdbc-2.5.6.jar
spring-tx-2.5.6.jar
spring-web-2.5.6.jar
spring-webmvc-2.5.6.jar
standard.jar

主要增加了spring-aop-2.5.6.jar的AOP支持包！

之前我们在AccountService中加入了注解@Transactional标签，但是要想要真正发挥事务作用，还需要一些配置。
主要需要调整dao.xml文件
dao.xml-事务管理

Xml代码

<bean
id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource" />
<tx:annotation-driven
transaction-manager="transactionManager" />

细化一下AccountService接口方法
AccountService.java

Java代码

/**
* 2010-1-23
*/
package org.zlex.spring.service;
import org.springframework.dao.DataAccessException;
import org.springframework.transaction.annotation.Transactional;
import org.zlex.spring.domain.Account;
/**
* 账户业务接口
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
public interface AccountService {
/**
* 获得账户
*
* @param username
* @param password
* @return
*/
@Transactional(readOnly = true)
Account read(String username, String password);
/**
* 获得账户
*
* @param id
* @return
*/
@Transactional(readOnly = true)
Account read(int id);
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
}

这里我把注解@Transactional调整到了具体的方法上，也就是说这样写的话，凡是加入注解的标注的方法都属于事务配置！
Account register(Account account);用做用户注册作用！ bubuko.com,布布扣

@Transactional(readOnly = true)只读属性
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)只读关闭，遇到DataAccessException异常回滚！如果不对异常进行处理，该异常将一直向上层抛出，直至抛出到页面！
如果你的Eclipse集成了SpringIDE，你可以观察一下这时的xml配置文件和AccoutServiceImpl.java的变化！ bubuko.com,布布扣

这次，来个用户注册功能演示，故意在某个位置制造一个异常，看看是否正常回滚！ bubuko.com,布布扣

先看注册控制器
RegisterController.java

Java代码

/**
* 2010-2-4
*/
package org.zlex.spring.controller;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.zlex.spring.domain.Account;
import org.zlex.spring.service.AccountService;
/**
* 用户注册控制器
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
@Controller
@RequestMapping(value = "/register.do")
public class RegisterController {
@Autowired
private AccountService accountService;
@InitBinder
public void initBinder(WebDataBinder binder) {
// 忽略字段绑定异常
// binder.setIgnoreInvalidFields(true);
DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
binder.registerCustomEditor(Date.class, "birthday",
new CustomDateEditor(format, true));
}
@RequestMapping(method = RequestMethod.GET)
public String initForm(ModelMap model) {
Account account = new Account();
model.addAttribute("account", account);
// 直接跳转到登录页面
return "account/register";
}
@RequestMapping(method = RequestMethod.POST)
protected String submit(@ModelAttribute("account") Account account) {
int id = accountService.register(account).getId();
// 跳转到用户信息页面
return "redirect:profile.do?id=" + id;
}
}

Jsp代码

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>注册</title>
<link rel="stylesheet" type="text/css" href="css/style.css" />
<script type="text/javascript" src="js/calendar.js"></script>
</head>
<body>
<fieldset><legend>用户注册</legend><form:form
commandName="account">
<ul>
<li><form:label path="username">用户名:</form:label><form:input
path="username" /></li>
<li><form:label path="password">密码:</form:label><form:password
path="password" /></li>
<li><form:label path="birthday">生日:</form:label><form:input
path="birthday" onfocus="showDate(this);" /></li>
<li><form:label path="email">Email:</form:label><form:input
path="email" /></li>
<li>
<button type="submit">注册</button>
<button type="reset">重置</button>
</li>
</ul>
</form:form></fieldset>
</body>
</html>

这里我用了一个JavaScript日期控制标签：

Html代码

<script type="text/javascript" src="js/calendar.js"></script>

使用起来就像是这样：
bubuko.com,布布扣

非常好用！！！

当然，你完全可以使用JE上的那个JS控件！
接下来稍微调整一下AccountService接口及其实现AccountServiceImpl
AccountService.java

Java代码

public interface AccountService {
// 省略
/**
* 注册用户
*
* @param account
* @return
*/
@Transactional(readOnly = false, rollbackFor = DataAccessException.class)
Account register(Account account);
// 省略
}

Java代码

@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
// 省略
@Override
public Account register(Account account) {
accountDao.create(account);
return accountDao.read(account.getUsername());
}
}

为了在插入一条记录后获得当前用户的主键，我们还得这么玩！ bubuko.com,布布扣

的确有点雷人～
从架构考虑，这是符合业务要求的实现！如果用iBatis或者Hibernate，这个问题就有数据库一次IO处理完成了！ bubuko.com,布布扣

再看看AccountDao接口及其实现AccountDaoImpl
AccountDao.java

Java代码

public interface AccountDao {
// 省略
/**
* 构建用户记录
*
* @param account
* @return
*/
void create(Account account);
}

AccountDaoImpl.java

Java代码

@Repository
public class AccountDaoImpl implements AccountDao {
// 省略
@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
}
}

来个注册演示！

信息展示：

来制造一起事故！

先看看数据库目前的状况！
bubuko.com,布布扣

在AccountDaoImpl中来个破坏！ bubuko.com,布布扣

Java代码

@Override
public void create(Account account) {
String sql = "INSERT INTO account(username, password, birthday, email) VALUES(?,?,?,?)";
jdbcTemplate.update(sql, new Object[] { account.getUsername(),
account.getPassword(), account.getBirthday(),
account.getEmail() });
throw new RecoverableDataAccessException("TEST");
}

我们强行在执行完Insert语句后抛出DataAccessException异常（RecoverableDataAccessException）！ bubuko.com,布布扣

来个注册试试！

点击提交看看返回的异常！ bubuko.com,布布扣

异常回滚生效！

数据库中当然是什么都没有，我就不废话了！ bubuko.com,布布扣

@RequestParam @RequestBody @PathVariable 等参数绑定注解详解(转)

引言：

接上一篇文章，对@RequestMapping进行地址映射讲解之后，该篇主要讲解request 数据到handler method 参数数据的绑定所用到的注解和什么情形下使用；

简介：

handler method 参数绑定常用的注解,我们根据他们处理的Request的不同内容部分分为四类：（主要讲解常用类型）

A、处理requet uri 部分（这里指uri template中variable，不含queryString部分）的注解： @PathVariable;

B、处理request header部分的注解： @RequestHeader, @CookieValue;

C、处理request body部分的注解：@RequestParam, @RequestBody;

D、处理attribute类型是注解： @SessionAttributes, @ModelAttribute;

1、 @PathVariable

当使用@RequestMapping URI template 样式映射时，即 someUrl/{paramId}, 这时的paramId可通过 @Pathvariable注解绑定它传过来的值到方法的参数上。

示例代码：

@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {

  @RequestMapping("/pets/{petId}")
  public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {    
    // implementation omitted
  }
}

上面代码把URI template 中变量 ownerId的值和petId的值，绑定到方法的参数上。若方法参数名称和需要绑定的uri template中变量名称不一致，需要在@PathVariable("name")指定uri template中的名称。

2、 @RequestHeader、@CookieValue

@RequestHeader 注解，可以把Request请求header部分的值绑定到方法的参数上。

示例代码：

这是一个Request 的header部分：

Host                    localhost:8080
Accept                  text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language         fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding         gzip,deflate
Accept-Charset          ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive              300

@RequestMapping("/displayHeaderInfo.do")
public void displayHeaderInfo(@RequestHeader("Accept-Encoding") String encoding,
                              @RequestHeader("Keep-Alive") long keepAlive)  {

  //...

}

上面的代码，把request header部分的 Accept-Encoding的值，绑定到参数encoding上了， Keep-Alive header的值绑定到参数keepAlive上。

@CookieValue 可以把Request header中关于cookie的值绑定到方法的参数上。

例如有如下Cookie值：

JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84

参数绑定的代码：

@RequestMapping("/displayHeaderInfo.do")
public void displayHeaderInfo(@CookieValue("JSESSIONID") String cookie)  {

  //...

}

即把JSESSIONID的值绑定到参数cookie上。

3、@RequestParam, @RequestBody

@RequestParam

A）常用来处理简单类型的绑定，通过Request.getParameter() 获取的String可直接转换为简单类型的情况（ String--> 简单类型的转换操作由ConversionService配置的转换器来完成）；因为使用request.getParameter()方式获取参数，所以可以处理get 方式中queryString的值，也可以处理post方式中 body data的值；

B）用来处理Content-Type: 为 application/x-www-form-urlencoded编码的内容，提交方式GET、POST；

C) 该注解有两个属性： value、required； value用来指定要传入值的id名称，required用来指示参数是否必须绑定；

示例代码：

@Controller
@RequestMapping("/pets")
@SessionAttributes("pet")
public class EditPetForm {

    // ...

    @RequestMapping(method = RequestMethod.GET)
    public String setupForm(@RequestParam("petId") int petId, ModelMap model) {
        Pet pet = this.clinic.loadPet(petId);
        model.addAttribute("pet", pet);
        return "petForm";
    }

    // ...

@RequestBody

该注解常用来处理Content-Type: 不是application/x-www-form-urlencoded编码的内容，例如application/json, application/xml等；

它是通过使用HandlerAdapter 配置的HttpMessageConverters来解析post data body，然后绑定到相应的bean上的。

因为配置有FormHttpMessageConverter，所以也可以用来处理 application/x-www-form-urlencoded的内容，处理完的结果放在一个MultiValueMap<String, String>里，这种情况在某些特殊需求下使用，详情查看FormHttpMessageConverter api;

示例代码：

@RequestMapping(value = "/something", method = RequestMethod.PUT)
public void handle(@RequestBody String body, Writer writer) throws IOException {
  writer.write(body);
}

4、@SessionAttributes, @ModelAttribute

@SessionAttributes:

该注解用来绑定HttpSession中的attribute对象的值，便于在方法中的参数里使用。

该注解有value、types两个属性，可以通过名字和类型指定要使用的attribute 对象；

示例代码：

@Controller
@RequestMapping("/editPet.do")
@SessionAttributes("pet")
public class EditPetForm {
    // ...
}

@ModelAttribute

该注解有两个用法，一个是用于方法上，一个是用于参数上；

用于方法上时：通常用来在处理@RequestMapping之前，为请求绑定需要从后台查询的model；

用于参数上时：用来通过名称对应，把相应名称的值绑定到注解的参数bean上；要绑定的值来源于：

A） @SessionAttributes 启用的attribute 对象上；

B） @ModelAttribute 用于方法上时指定的model对象；

C）上述两种情况都没有时，new一个需要绑定的bean对象，然后把request中按名称对应的方式把值绑定到bean中。

用到方法上@ModelAttribute的示例代码：

// Add one attribute
// The return value of the method is added to the model under the name "account"
// You can customize the name via @ModelAttribute("myAccount")

@ModelAttribute
public Account addAccount(@RequestParam String number) {
    return accountManager.findAccount(number);
}

这种方式实际的效果就是在调用@RequestMapping的方法之前，为request对象的model里put（“account”， Account）；

用在参数上的@ModelAttribute示例代码：

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)
public String processSubmit(@ModelAttribute Pet pet) {
   
}

首先查询 @SessionAttributes有无绑定的Pet对象，若没有则查询@ModelAttribute方法层面上是否绑定了Pet对象，若没有则将URI template中的值按对应的名称绑定到Pet对象的各属性上。

补充讲解：

问题：在不给定注解的情况下，参数是怎样绑定的？

通过分析AnnotationMethodHandlerAdapter和RequestMappingHandlerAdapter的源代码发现，方法的参数在不给定参数的情况下：

若要绑定的对象时简单类型：调用@RequestParam来处理的。

若要绑定的对象时复杂类型：调用@ModelAttribute来处理的。

这里的简单类型指java的原始类型(boolean, int 等)、原始类型对象（Boolean, Int等）、String、Date等ConversionService里可以直接String转换成目标对象的类型；

下面贴出AnnotationMethodHandlerAdapter中绑定参数的部分源代码：

private Object[] resolveHandlerArguments(Method handlerMethod, Object handler,
            NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {

        Class[] paramTypes = handlerMethod.getParameterTypes();
        Object[] args = new Object[paramTypes.length];

        for (int i = 0; i < args.length; i++) {
            MethodParameter methodParam = new MethodParameter(handlerMethod, i);
            methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
            GenericTypeResolver.resolveParameterType(methodParam, handler.getClass());
            String paramName = null;
            String headerName = null;
            boolean requestBodyFound = false;
            String cookieName = null;
            String pathVarName = null;
            String attrName = null;
            boolean required = false;
            String defaultValue = null;
            boolean validate = false;
            Object[] validationHints = null;
            int annotationsFound = 0;
            Annotation[] paramAnns = methodParam.getParameterAnnotations();

            for (Annotation paramAnn : paramAnns) {
                if (RequestParam.class.isInstance(paramAnn)) {
                    RequestParam requestParam = (RequestParam) paramAnn;
                    paramName = requestParam.value();
                    required = requestParam.required();
                    defaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
                    annotationsFound++;
                }
                else if (RequestHeader.class.isInstance(paramAnn)) {
                    RequestHeader requestHeader = (RequestHeader) paramAnn;
                    headerName = requestHeader.value();
                    required = requestHeader.required();
                    defaultValue = parseDefaultValueAttribute(requestHeader.defaultValue());
                    annotationsFound++;
                }
                else if (RequestBody.class.isInstance(paramAnn)) {
                    requestBodyFound = true;
                    annotationsFound++;
                }
                else if (CookieValue.class.isInstance(paramAnn)) {
                    CookieValue cookieValue = (CookieValue) paramAnn;
                    cookieName = cookieValue.value();
                    required = cookieValue.required();
                    defaultValue = parseDefaultValueAttribute(cookieValue.defaultValue());
                    annotationsFound++;
                }
                else if (PathVariable.class.isInstance(paramAnn)) {
                    PathVariable pathVar = (PathVariable) paramAnn;
                    pathVarName = pathVar.value();
                    annotationsFound++;
                }
                else if (ModelAttribute.class.isInstance(paramAnn)) {
                    ModelAttribute attr = (ModelAttribute) paramAnn;
                    attrName = attr.value();
                    annotationsFound++;
                }
                else if (Value.class.isInstance(paramAnn)) {
                    defaultValue = ((Value) paramAnn).value();
                }
                else if (paramAnn.annotationType().getSimpleName().startsWith("Valid")) {
                    validate = true;
                    Object value = AnnotationUtils.getValue(paramAnn);
                    validationHints = (value instanceof Object[] ? (Object[]) value : new Object[] {value});
                }
            }

            if (annotationsFound > 1) {
                throw new IllegalStateException("Handler parameter annotations are exclusive choices - " +
                        "do not specify more than one such annotation on the same parameter: " + handlerMethod);
            }

            if (annotationsFound == 0) {// 若没有发现注解
                Object argValue = resolveCommonArgument(methodParam, webRequest);    //判断WebRquest是否可赋值给参数
                if (argValue != WebArgumentResolver.UNRESOLVED) {
                    args[i] = argValue;
                }
                else if (defaultValue != null) {
                    args[i] = resolveDefaultValue(defaultValue);
                }
                else {
                    Class<?> paramType = methodParam.getParameterType();
                    if (Model.class.isAssignableFrom(paramType) || Map.class.isAssignableFrom(paramType)) {
                        if (!paramType.isAssignableFrom(implicitModel.getClass())) {
                            throw new IllegalStateException("Argument [" + paramType.getSimpleName() + "] is of type " +
                                    "Model or Map but is not assignable from the actual model. You may need to switch " +
                                    "newer MVC infrastructure classes to use this argument.");
                        }
                        args[i] = implicitModel;
                    }
                    else if (SessionStatus.class.isAssignableFrom(paramType)) {
                        args[i] = this.sessionStatus;
                    }
                    else if (HttpEntity.class.isAssignableFrom(paramType)) {
                        args[i] = resolveHttpEntityRequest(methodParam, webRequest);
                    }
                    else if (Errors.class.isAssignableFrom(paramType)) {
                        throw new IllegalStateException("Errors/BindingResult argument declared " +
                                "without preceding model attribute. Check your handler method signature!");
                    }
                    else if (BeanUtils.isSimpleProperty(paramType)) {// 判断是否参数类型是否是简单类型，若是在使用@RequestParam方式来处理,否则使用@ModelAttribute方式处理
                        paramName = "";
                    }
                    else {
                        attrName = "";
                    }
                }
            }

            if (paramName != null) {
                args[i] = resolveRequestParam(paramName, required, defaultValue, methodParam, webRequest, handler);
            }
            else if (headerName != null) {
                args[i] = resolveRequestHeader(headerName, required, defaultValue, methodParam, webRequest, handler);
            }
            else if (requestBodyFound) {
                args[i] = resolveRequestBody(methodParam, webRequest, handler);
            }
            else if (cookieName != null) {
                args[i] = resolveCookieValue(cookieName, required, defaultValue, methodParam, webRequest, handler);
            }
            else if (pathVarName != null) {
                args[i] = resolvePathVariable(pathVarName, methodParam, webRequest, handler);
            }
            else if (attrName != null) {
                WebDataBinder binder =
                        resolveModelAttribute(attrName, methodParam, implicitModel, webRequest, handler);
                boolean assignBindingResult = (args.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1]));
                if (binder.getTarget() != null) {
                    doBind(binder, webRequest, validate, validationHints, !assignBindingResult);
                }
                args[i] = binder.getTarget();
                if (assignBindingResult) {
                    args[i + 1] = binder.getBindingResult();
                    i++;
                }
                implicitModel.putAll(binder.getBindingResult().getModel());
            }
        }

        return args;
    }

RequestMappingHandlerAdapter中使用的参数绑定，代码稍微有些不同，有兴趣的同仁可以分析下，最后处理的结果都是一样的。

示例：

@RequestMapping ({"/", "/home"})
    public String showHomePage(String key){
        
        logger.debug("key="+key);
        
        return "home";
    }

这种情况下，就调用默认的@RequestParam来处理。

    @RequestMapping (method = RequestMethod.POST)
    public String doRegister(User user){
        if(logger.isDebugEnabled()){
            logger.debug("process url[/user], method[post] in "+getClass());
            logger.debug(user);
        }

        return "user";
    }

这种情况下，就调用@ModelAttribute来处理

@RequestBody

作用：

i) 该注解用于读取Request请求的body部分数据，使用系统默认配置的HttpMessageConverter进行解析，然后把相应的数据绑定到要返回的对象上；

ii) 再把HttpMessageConverter返回的对象数据绑定到 controller中方法的参数上。

使用时机：

A) GET、POST方式提时，根据request header Content-Type的值来判断:

application/x-www-form-urlencoded，可选（即非必须，因为这种情况的数据@RequestParam, @ModelAttribute也可以处理，当然@RequestBody也能处理）；
multipart/form-data, 不能处理（即使用@RequestBody不能处理这种格式的数据）；
其他格式，必须（其他格式包括application/json, application/xml等。这些格式的数据，必须使用@RequestBody来处理）；

B) PUT方式提交时，根据request header Content-Type的值来判断:

application/x-www-form-urlencoded，必须；
multipart/form-data, 不能处理；
其他格式，必须；

说明：request的body部分的数据编码格式由header部分的Content-Type指定；

@ResponseBody

作用：

该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用时机：

返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

HttpMessageConverter

<span style="font-family:Microsoft YaHei;">/**
 * Strategy interface that specifies a converter that can convert from and to HTTP requests and responses.
 *
 * @author Arjen Poutsma
 * @author Juergen Hoeller
 * @since 3.0
 */
public interface HttpMessageConverter<T> {

    /**
     * Indicates whether the given class can be read by this converter.
     * @param clazz the class to test for readability
     * @param mediaType the media type to read, can be {@code null} if not specified.
     * Typically the value of a {@code Content-Type} header.
     * @return {@code true} if readable; {@code false} otherwise
     */
    boolean canRead(Class<?> clazz, MediaType mediaType);

    /**
     * Indicates whether the given class can be written by this converter.
     * @param clazz the class to test for writability
     * @param mediaType the media type to write, can be {@code null} if not specified.
     * Typically the value of an {@code Accept} header.
     * @return {@code true} if writable; {@code false} otherwise
     */
    boolean canWrite(Class<?> clazz, MediaType mediaType);

    /**
     * Return the list of {@link MediaType} objects supported by this converter.
     * @return the list of supported media types
     */
    List<MediaType> getSupportedMediaTypes();

    /**
     * Read an object of the given type form the given input message, and returns it.
     * @param clazz the type of object to return. This type must have previously been passed to the
     * {@link #canRead canRead} method of this interface, which must have returned {@code true}.
     * @param inputMessage the HTTP input message to read from
     * @return the converted object
     * @throws IOException in case of I/O errors
     * @throws HttpMessageNotReadableException in case of conversion errors
     */
    T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException;

    /**
     * Write an given object to the given output message.
     * @param t the object to write to the output message. The type of this object must have previously been
     * passed to the {@link #canWrite canWrite} method of this interface, which must have returned {@code true}.
     * @param contentType the content type to use when writing. May be {@code null} to indicate that the
     * default content type of the converter must be used. If not {@code null}, this media type must have
     * previously been passed to the {@link #canWrite canWrite} method of this interface, which must have
     * returned {@code true}.
     * @param outputMessage the message to write to
     * @throws IOException in case of I/O errors
     * @throws HttpMessageNotWritableException in case of conversion errors
     */
    void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException;

}
</span>

该接口定义了四个方法，分别是读取数据时的 canRead(), read() 和写入数据时的canWrite(), write()方法。

在使用 <mvc:annotation-driven />标签配置时，默认配置了RequestMappingHandlerAdapter（注意是RequestMappingHandlerAdapter不是AnnotationMethodHandlerAdapter,详情查看Spring 3.1 document “16.14 Configuring Spring MVC”章节），并为他配置了一下默认的HttpMessageConverter：

    ByteArrayHttpMessageConverter converts byte arrays.

    StringHttpMessageConverter converts strings.

    ResourceHttpMessageConverter converts to/from org.springframework.core.io.Resource for all media types.

    SourceHttpMessageConverter converts to/from a javax.xml.transform.Source.

    FormHttpMessageConverter converts form data to/from a MultiValueMap<String, String>.

    Jaxb2RootElementHttpMessageConverter converts Java objects to/from XML — added if JAXB2 is present on the classpath.

    MappingJacksonHttpMessageConverter converts to/from JSON — added if Jackson is present on the classpath.

    AtomFeedHttpMessageConverter converts Atom feeds — added if Rome is present on the classpath.

    RssChannelHttpMessageConverter converts RSS feeds — added if Rome is present on the classpath.

ByteArrayHttpMessageConverter: 负责读取二进制格式的数据和写出二进制格式的数据；

StringHttpMessageConverter：负责读取字符串格式的数据和写出二进制格式的数据；

ResourceHttpMessageConverter：负责读取资源文件和写出资源文件数据；

FormHttpMessageConverter：负责读取form提交的数据（能读取的数据格式为 application/x-www-form-urlencoded，不能读取multipart/form-data格式数据）；负责写入application/x-www-from-urlencoded和multipart/form-data格式的数据；

MappingJacksonHttpMessageConverter: 负责读取和写入json格式的数据；

SouceHttpMessageConverter：负责读取和写入 xml 中javax.xml.transform.Source定义的数据；

Jaxb2RootElementHttpMessageConverter: 负责读取和写入xml 标签格式的数据；

AtomFeedHttpMessageConverter: 负责读取和写入Atom格式的数据；

RssChannelHttpMessageConverter: 负责读取和写入RSS格式的数据；

当使用@RequestBody和@ResponseBody注解时，RequestMappingHandlerAdapter就使用它们来进行读取或者写入相应格式的数据。

HttpMessageConverter匹配过程：

@RequestBody注解时：根据Request对象header部分的Content-Type类型，逐一匹配合适的HttpMessageConverter来读取数据；

spring 3.1源代码如下：

private Object readWithMessageConverters(MethodParameter methodParam, HttpInputMessage inputMessage, Class paramType)
            throws Exception {

        MediaType contentType = inputMessage.getHeaders().getContentType();
        if (contentType == null) {
            StringBuilder builder = new StringBuilder(ClassUtils.getShortName(methodParam.getParameterType()));
            String paramName = methodParam.getParameterName();
            if (paramName != null) {
                builder.append(‘ ‘);
                builder.append(paramName);
            }
            throw new HttpMediaTypeNotSupportedException(
                    "Cannot extract parameter (" + builder.toString() + "): no Content-Type found");
        }

        List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
        if (this.messageConverters != null) {
            for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
                allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
                if (messageConverter.canRead(paramType, contentType)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Reading [" + paramType.getName() + "] as \"" + contentType
                                +"\" using [" + messageConverter + "]");
                    }
                    return messageConverter.read(paramType, inputMessage);
                }
            }
        }
        throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
    }

@ResponseBody注解时：根据Request对象header部分的Accept属性（逗号分隔），逐一按accept中的类型，去遍历找到能处理的HttpMessageConverter；

源代码如下：

private void writeWithMessageConverters(Object returnValue,
                HttpInputMessage inputMessage, HttpOutputMessage outputMessage)
                throws IOException, HttpMediaTypeNotAcceptableException {
            List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
            if (acceptedMediaTypes.isEmpty()) {
                acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
            }
            MediaType.sortByQualityValue(acceptedMediaTypes);
            Class<?> returnValueType = returnValue.getClass();
            List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
            if (getMessageConverters() != null) {
                for (MediaType acceptedMediaType : acceptedMediaTypes) {

                    for (HttpMessageConverter messageConverter : getMessageConverters()) {
                        if (messageConverter.canWrite(returnValueType, acceptedMediaType)) {
                            messageConverter.write(returnValue, acceptedMediaType, outputMessage);
                            if (logger.isDebugEnabled()) {
                                MediaType contentType = outputMessage.getHeaders().getContentType();
                                if (contentType == null) {
                                    contentType = acceptedMediaType;
                                }
                                logger.debug("Written [" + returnValue + "] as \"" + contentType +
                                        "\" using [" + messageConverter + "]");
                            }
                            this.responseArgumentUsed = true;
                            return;
                        }
                    }
                }
                for (HttpMessageConverter messageConverter : messageConverters) {
                    allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
                }
            }
            throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
        }

补充：

MappingJacksonHttpMessageConverter 调用了 objectMapper.writeValue(OutputStream stream, Object)方法，使用@ResponseBody注解返回的对象就传入Object参数内。若返回的对象为已经格式化好的json串时，不使用@RequestBody注解，而应该这样处理：

1、response.setContentType("application/json; charset=UTF-8");

2、response.getWriter().print(jsonStr);

直接输出到body区，然后的视图为void。

前段时间项目中用到了RESTful模式来开发程序，但是当用POST、PUT模式提交数据时，发现服务器端接受不到提交的数据（服务器端参数绑定没有加任何注解），查看了提交方式为application/json，而且服务器端通过request.getReader() 打出的数据里确实存在浏览器提交的数据。为了找出原因，便对参数绑定（@RequestParam、 @RequestBody、 @RequestHeader 、 @PathVariable）进行了研究，同时也看了一下HttpMessageConverter的相关内容，在此一并总结。

简介：

@RequestMapping

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

RequestMapping注解有六个属性，下面我们把她分成三类进行说明。

1、 value， method；

value：指定请求的实际地址，指定的地址可以是URI Template 模式（后面将会说明）；

method：指定请求的method类型， GET、POST、PUT、DELETE等；

2、 consumes，produces；

consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;

produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；

3、 params，headers；

params：指定request中必须包含某些参数值是，才让该方法处理。

headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。

示例：

1、value / method 示例

默认RequestMapping("....str...")即为value的值；

@Controller
@RequestMapping("/appointments")
public class AppointmentsController {

    private AppointmentBook appointmentBook;
    
    @Autowired
    public AppointmentsController(AppointmentBook appointmentBook) {
        this.appointmentBook = appointmentBook;
    }

    @RequestMapping(method = RequestMethod.GET)
    public Map<String, Appointment> get() {
        return appointmentBook.getAppointmentsForToday();
    }

    @RequestMapping(value="/{day}", method = RequestMethod.GET)
    public Map<String, Appointment> getForDay(@PathVariable @DateTimeFormat(iso=ISO.DATE) Date day, Model model) {
        return appointmentBook.getAppointmentsForDay(day);
    }

    @RequestMapping(value="/new", method = RequestMethod.GET)
    public AppointmentForm getNewForm() {
        return new AppointmentForm();
    }

    @RequestMapping(method = RequestMethod.POST)
    public String add(@Valid AppointmentForm appointment, BindingResult result) {
        if (result.hasErrors()) {
            return "appointments/new";
        }
        appointmentBook.addAppointment(appointment);
        return "redirect:/appointments";
    }
}

value的uri值为以下三类：

A）可以指定为普通的具体值；

B) 可以指定为含有某变量的一类值(URI Template Patterns with Path Variables)；

C) 可以指定为含正则表达式的一类值( URI Template Patterns with Regular Expressions);

example B)

@RequestMapping(value="/owners/{ownerId}", method=RequestMethod.GET)
public String findOwner(@PathVariable String ownerId, Model model) {
  Owner owner = ownerService.findOwner(ownerId);  
  model.addAttribute("owner", owner);  
  return "displayOwner"; 
}

example C)

@RequestMapping("/spring-web/{symbolicName:[a-z-]+}-{version:\d\.\d\.\d}.{extension:\.[a-z]}")
  public void handle(@PathVariable String version, @PathVariable String extension) {    
    // ...
  }
}

2 consumes、produces 示例

cousumes的样例：

@Controller
@RequestMapping(value = "/pets", method = RequestMethod.POST, consumes="application/json")
public void addPet(@RequestBody Pet pet, Model model) {    
    // implementation omitted
}

方法仅处理request Content-Type为“application/json”类型的请求。

produces的样例：

@Controller
@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, produces="application/json")
@ResponseBody
public Pet getPet(@PathVariable String petId, Model model) {    
    // implementation omitted
}

方法仅处理request请求中Accept头中包含了"application/json"的请求，同时暗示了返回的内容类型为application/json;

3 params、headers 示例

params的样例：

@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {

  @RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, params="myParam=myValue")
  public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {    
    // implementation omitted
  }
}

仅处理请求中包含了名为“myParam”，值为“myValue”的请求；

headers的样例：

@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {

@RequestMapping(value = "/pets", method = RequestMethod.GET, headers="Referer=http://www.ifeng.com/")
  public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {    
    // implementation omitted
  }
}

仅处理request的header中包含了指定“Refer”请求头和对应值为“http://www.ifeng.com/”的请求；

http://www.codeweblog.com/stag/spring-requestmapping-method-requestmethod-post/

Springmvc构造RESTful详细讲解

Rest介绍

/blog/1　HTTP　GET　=>　　得到id　=　1的blog
bubuko.com,布布扣

/blog/1　HTTP　DELETE　=>　删除　id　=　1的blog
bubuko.com,布布扣

/blog/1　HTTP　PUT　=>　　更新id　=　1的blog
bubuko.com,布布扣

/blog　　　HTTP　POST　=>　　新增BLOG

以下详细解一下spring rest使用.

首先，我们带着如下两个问题查看本文。

1.如何在java构造没有扩展名的RESTful url,如 /forms/1,而不是 /forms/1.do

2.浏览器的form标签不支持提交delete,put请求，如何曲线解决

springmvc rest 实现

springmvc的resturl是通过@RequestMapping 及@PathVariable annotation提供的,
通过如@RequestMapping(value="/blog /{id}",method=RequestMethod.DELETE)即可处理/blog/1 的delete请求.

@RequestMapping(value="/blog/{id}",method=RequestMethod.DELETE)
2 bubuko.com,布布扣

public　ModelAndView　delete(@PathVariable　Long　id,HttpServletRequest　request,HttpServletResponse　response)　{
3 bubuko.com,布布扣

　 blogManager.removeById(id);
4 bubuko.com,布布扣

　 return　new　ModelAndView(LIST_ACTION);
5 bubuko.com,布布扣

}

@RequestMapping @PathVariable如果URL中带参数，则配合使用，如

@RequestMapping(value="/blog/{blogId}/message/{msgId}",method=RequestMethod.DELETE)
2 bubuko.com,布布扣

public　ModelAndView　delete(@PathVariable("blogId")　Long　blogId,@PathVariable("msgId")　Long　msgId,HttpServletRequest　request,HttpServletResponse　response)　{
3 bubuko.com,布布扣

}

1.springmvc web.xml配置

2 bubuko.com,布布扣

　 <servlet-mapping>
3 bubuko.com,布布扣

　 <servlet-name>default</servlet-name>
4 bubuko.com,布布扣

　 <url-pattern>/static/*</url-pattern>
5 bubuko.com,布布扣

　 </servlet-mapping>
6 bubuko.com,布布扣

　 <servlet>
7 bubuko.com,布布扣

　　　 <servlet-name>springmvc</servlet-name>
8 bubuko.com,布布扣

　　　 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
9 bubuko.com,布布扣

　　　 <load-on-startup>1</load-on-startup>
10 bubuko.com,布布扣

　 </servlet>
11 bubuko.com,布布扣

13 bubuko.com,布布扣

　 <filter>
14 bubuko.com,布布扣

　 <filter-name>UrlRewriteFilter</filter-name>
15 bubuko.com,布布扣

　 <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
16 bubuko.com,布布扣

　 <init-param>
17 bubuko.com,布布扣

　　　　 <param-name>confReloadCheckInterval</param-name>
18 bubuko.com,布布扣

　　　　 <param-value>60</param-value>
19 bubuko.com,布布扣

　　　 </init-param>
20 bubuko.com,布布扣

　 <init-param>
21 bubuko.com,布布扣

　　　　　　　 <param-name>logLevel</param-name>
22 bubuko.com,布布扣

　　　　　　　 <param-value>DEBUG</param-value>
23 bubuko.com,布布扣

　　　　　 </init-param>
24 bubuko.com,布布扣

　 </filter>
25 bubuko.com,布布扣

　 <filter-mapping>
26 bubuko.com,布布扣

　 <filter-name>UrlRewriteFilter</filter-name>
27 bubuko.com,布布扣

　 <url-pattern>/*</url-pattern>
28 bubuko.com,布布扣

　 </filter-mapping>
29 bubuko.com,布布扣

31 bubuko.com,布布扣

　 <servlet-mapping>
32 bubuko.com,布布扣

　　　 <servlet-name>springmvc</servlet-name>
33 bubuko.com,布布扣

　　　 <url-pattern>/</url-pattern>
34 bubuko.com,布布扣

　 </servlet-mapping>
35 bubuko.com,布布扣

37 bubuko.com,布布扣

　 <filter>
38 bubuko.com,布布扣

　 <filter-name>HiddenHttpMethodFilter</filter-name>
39 bubuko.com,布布扣

　 <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
40 bubuko.com,布布扣

　 </filter>
41 bubuko.com,布布扣

　 <filter-mapping>
43 bubuko.com,布布扣

　 <filter-name>HiddenHttpMethodFilter</filter-name>
44 bubuko.com,布布扣

　 <servlet-name>springmvc</servlet-name>
45 bubuko.com,布布扣

　 </filter-mapping>

2.webapp/WEB-INF/springmvc-servlet.xml配置,使用如下两个class激活@RequestMapping annotation

<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
2 bubuko.com,布布扣

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
3 bubuko.com,布布扣

3.Controller编写

/**
2

　 *　@RequestMapping("/userinfo")　具有层次关系，方法级的将在类一级@RequestMapping之一,
3 bubuko.com,布布扣

　 *　如下面示例,　访问方法级别的@RequestMapping("/new"),则URL为　/userinfo/new
4 bubuko.com,布布扣

　 */
5

@Controller
6 bubuko.com,布布扣

@RequestMapping("/userinfo")
7 bubuko.com,布布扣

public　class　UserInfoController　extends　BaseSpringController{
8 bubuko.com,布布扣

　 //默认多列排序,example:　username　desc,createTime　asc
9 bubuko.com,布布扣

　 protected　static　final　String　DEFAULT_SORT_COLUMNS　=　null;
10 bubuko.com,布布扣

　 private　UserInfoManager　userInfoManager;
12 bubuko.com,布布扣

　 private　final　String　LIST_ACTION　=　"redirect:/userinfo";
14 bubuko.com,布布扣

　 /**
16

　 *　通过spring自动注入
17 bubuko.com,布布扣

　 **/
18

　 public　void　setUserInfoManager(UserInfoManager　manager)　{
19 bubuko.com,布布扣

　 this.userInfoManager　=　manager;
20 bubuko.com,布布扣

　 }
21

　 /**　列表　*/
23 bubuko.com,布布扣

　 @RequestMapping
24 bubuko.com,布布扣

　 public　ModelAndView　index(HttpServletRequest　request,HttpServletResponse　response,UserInfo　userInfo)　{
25 bubuko.com,布布扣

　 PageRequest<Map>　pageRequest　=　newPageRequest(request,DEFAULT_SORT_COLUMNS);
26 bubuko.com,布布扣

　 //pageRequest.getFilters();　//add　custom　filters　
27 bubuko.com,布布扣

　 Page　page　=　this.userInfoManager.findByPageRequest(pageRequest);
29 bubuko.com,布布扣

　 savePage(page,pageRequest,request);
30 bubuko.com,布布扣

　 return　new　ModelAndView("/userinfo/list","userInfo",userInfo);
31 bubuko.com,布布扣

　 }
32

　 /**　进入新增　*/
34 bubuko.com,布布扣

　 @RequestMapping(value="/new")
35 bubuko.com,布布扣

　 public　ModelAndView　_new(HttpServletRequest　request,HttpServletResponse　response,UserInfo　userInfo)　throws　Exception　{
36 bubuko.com,布布扣

　 return　new　ModelAndView("/userinfo/new","userInfo",userInfo);
37 bubuko.com,布布扣

　 }
38

　 /**　显示　*/
40 bubuko.com,布布扣

　 @RequestMapping(value="/{id}")
41 bubuko.com,布布扣

　 public　ModelAndView　show(@PathVariable　Long　id,HttpServletRequest　request,HttpServletResponse　response)　throws　Exception　{
42 bubuko.com,布布扣

　 UserInfo　userInfo　=　(UserInfo)userInfoManager.getById(id);
43 bubuko.com,布布扣

　 return　new　ModelAndView("/userinfo/show","userInfo",userInfo);
44 bubuko.com,布布扣

　 }
45

　 /**　编辑　*/
47 bubuko.com,布布扣

　 @RequestMapping(value="/{id}/edit")
48 bubuko.com,布布扣

　 public　ModelAndView　edit(@PathVariable　Long　id,HttpServletRequest　request,HttpServletResponse　response)　throws　Exception　{
49 bubuko.com,布布扣

　 UserInfo　userInfo　=　(UserInfo)userInfoManager.getById(id);
50 bubuko.com,布布扣

　 return　new　ModelAndView("/userinfo/edit","userInfo",userInfo);
51 bubuko.com,布布扣

　 }
52

　 /**　保存新增　*/
54 bubuko.com,布布扣

　 @RequestMapping(method=RequestMethod.POST)
55 bubuko.com,布布扣

　 public　ModelAndView　create(HttpServletRequest　request,HttpServletResponse　response,UserInfo　userInfo)　throws　Exception　{
56 bubuko.com,布布扣

　 userInfoManager.save(userInfo);
57 bubuko.com,布布扣

　 return　new　ModelAndView(LIST_ACTION);
58 bubuko.com,布布扣

　 }
59

　 /**　保存更新　*/
61 bubuko.com,布布扣

　 @RequestMapping(value="/{id}",method=RequestMethod.PUT)
62 bubuko.com,布布扣

　 public　ModelAndView　update(@PathVariable　Long　id,HttpServletRequest　request,HttpServletResponse　response)　throws　Exception　{
63 bubuko.com,布布扣

　 UserInfo　userInfo　=　(UserInfo)userInfoManager.getById(id);
64 bubuko.com,布布扣

　 bind(request,userInfo);
65 bubuko.com,布布扣

　 userInfoManager.update(userInfo);
66 bubuko.com,布布扣

　 return　new　ModelAndView(LIST_ACTION);
67 bubuko.com,布布扣

　 }
68

　 /**　删除　*/
70 bubuko.com,布布扣

　 @RequestMapping(value="/{id}",method=RequestMethod.DELETE)
71 bubuko.com,布布扣

　 public　ModelAndView　delete(@PathVariable　Long　id,HttpServletRequest　request,HttpServletResponse　response)　{
72 bubuko.com,布布扣

　 userInfoManager.removeById(id);
73 bubuko.com,布布扣

　 return　new　ModelAndView(LIST_ACTION);
74 bubuko.com,布布扣

　 }
75

　 /**　批量删除　*/
77 bubuko.com,布布扣

　 @RequestMapping(method=RequestMethod.DELETE)
78 bubuko.com,布布扣

　 public　ModelAndView　batchDelete(HttpServletRequest　request,HttpServletResponse　response)　{
79 bubuko.com,布布扣

　 String[]　items　=　request.getParameterValues("items");
80 bubuko.com,布布扣

　 for(int　i　=　0;　i　<　items.length;　i++)　{
81 bubuko.com,布布扣

　　 java.lang.Long　id　=　new　java.lang.Long(items[i]);
82 bubuko.com,布布扣

　　 userInfoManager.removeById(id);
83 bubuko.com,布布扣

　 }
84

　 return　new　ModelAndView(LIST_ACTION);
85 bubuko.com,布布扣

　 }
86

}
88

/userinfo　　=>　index()
2 bubuko.com,布布扣

　 /userinfo/new　=>　_new()
3 bubuko.com,布布扣

　 /userinfo/{id}　=>　show()
4 bubuko.com,布布扣

　 /userinfo/{id}/edit　　=>　edit()
5 bubuko.com,布布扣

　 /userinfo　POST　=>　create()
6 bubuko.com,布布扣

　 /userinfo/{id}　PUT　=>　update()
7 bubuko.com,布布扣

　 /userinfo/{id}　DELETE　=>　delete()
8 bubuko.com,布布扣

　 /userinfo　DELETE　=>　batchDelete()
9 bubuko.com,布布扣

注(不使用 /userinfo/add　 => add() 方法是由于add这个方法会被maxthon浏览器当做广告链接过滤掉,因为包含ad字符)

4.jsp 编写

<form:form　action="${ctx}/userinfo${userInfo.userId}"　method="put">
2 bubuko.com,布布扣

</form:form>

生成的html内容如下, 生成一个hidden的_method=put,并于web.xml中的HiddenHttpMethodFilter配合使用，在服务端将post请求改为put请求

<form　id="userInfo"　action="/springmvc_rest_demo/userinfo/2"　method="post">
2 bubuko.com,布布扣

　 <input　type="hidden"　name="_method"　value="put"/>
3 bubuko.com,布布扣

</form>

另外一种方法是你可以使用ajax发送put,delete请求.

5.静态资源的URL重写

如上我们描述，现因为将default servlet映射至/static/的子目录，现我们访问静态资源将会带一个/static/前缀.

如 /foo.gif, 现在访问该文件将是 /static/foo.gif.

那如何避免这个前缀呢，那就是应用URL rewrite,现我们使用 http://tuckey.org/urlrewrite/, 重写规则如下

<urlrewrite>
2 bubuko.com,布布扣

3 bubuko.com,布布扣

　　 <rule>
4

　　　 <condition　operator="notequal"　next="and"　type="request-uri">.*.jsp</condition>
5 bubuko.com,布布扣

　　　 <condition　operator="notequal"　next="and"　type="request-uri">.*.jspx</condition>
6 bubuko.com,布布扣

　　　　 <from>^(/.*\..*)$</from>
7 bubuko.com,布布扣

　　　　 <to>/static$1</to>
8 bubuko.com,布布扣

　　 </rule>
9

</urlrewrite>

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

第一讲：SpringMVC 页面跳转实例，通过请求访问start.jsp页面

1.1 加包

1.2 web.xml

        <servlet>

          <servlet-name>springMVC</servlet-name>

          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

          <load-on-startup>1</load-on-startup>

      </servlet>

      <servlet-mapping>

          <servlet-name>springMVC</servlet-name>

          <url-pattern>*.do</url-pattern>

      </servlet-mapping>

abc
1.3 建springMVC-servlet.xml(注：spring默认要求建立在WEB-INF目录下，并且名称为servlet-name_servlet.xml

    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        <context:component-scan base-package="com.wdl.cn.controllers" />
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/page/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>

1.4 StartController.java

    package com.wdl.cn.controllers;

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;

    @Controller
    public class StartController {

        @RequestMapping(value="/start")
        public String start(){
            System.out.println("start method invoked...");
            return "start";
        }
    }

1.5 新建 WEB-INF/page/start.jsp

1.6 访问：http://localhost:8080/springMVC_001/start.do
总结：本例子搭建一个简单的spingmvc实例，通过本例学习springMVC最简单的流程及搭建元素。
第二讲灵活指定springmvc映射文件及路径
    更多情况下，对于第一讲中的springMVC-servlet.xml 文件，我们并不想去放在WEB-INF，或者说我们可能在一个项目中并不是只有这一个文件，所以本节我们来讲述如何灵活配置此文件及文件名。
2.1 修改web.xml

    <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*:/com/wdl/cn/config/mvc/*.xml</param-value>
          </init-param>
          <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
          <servlet-name>springMVC</servlet-name>
          <url-pattern>*.do</url-pattern>
      </servlet-mapping>

2.2 将WEB-INF下面的springMVC-servlet.xml 移动到com.wdl.cn.config.mvc包下并将其修改名称为springMVC-first.xml

2.3 测试原来的路径 : http://localhost:8080/springMVC_002/start.do

总结：本讲主要学习了如何灵活配置springMVC配置文件。下节将重点讲述@RequestMapping的使用。

第三讲 springMVC_003 @RequestMapping的使用

3.1 @RequestMapping 使用位置
    a.使用于方法，此方法则可以被请求访问；
    b.使用于类，则可以将请求分（又叫分路径，分模块）包处理
3.2 将controller类上加@RequestMapping,修改StartController.java

    package com.wdl.cn.controllers;

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;

    @Controller
    @RequestMapping(value="/test")
    public class StartController {

        @RequestMapping(value="/start")
        public String start(){
            System.out.println("start method invoked...");
            return "start";
        }
    }

3.3 访问：http://localhost:8080/springMVC_003/test/start.do ，由此可见，可以通过在类上加@RequestMapping将请求分路径。

3.4 @RequestMapping 参数详解
    a.value表示访问的路径
    b.method 表示请求的方式 GET | POST
    step1:修改StartController.java

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;

    @Controller
    @RequestMapping(value="/test")
    public class StartController {

        @RequestMapping(value="/start",method=RequestMethod.GET)
        public String start(){
            System.out.println("start method invoked...");
            return "start";
        }
        @RequestMapping(value="/start",method=RequestMethod.POST)
        public String start2(){
            System.out.println("start2 method invoked...");
            return "start";
        }
    }

step2:修改start.jsp模拟POST请求
3.5 访问http://localhost:8080/springMVC_003/test/start.do，接着转到start.jsp页面，接着点击页面的中按钮，发送POST请求，则可以看出不同的请求方式可以调用不同的方法。
3.6 参数传递（常用参数传递，restful风格参数传递）

      a.httpservletreqeust方式参数传递
        step1:修改StartController.java


    package com.wdl.cn.controllers;

    import javax.servlet.http.HttpServletRequest;

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;

    @Controller
    @RequestMapping(value="/test")
    public class StartController {

        @RequestMapping(value="/start",method=RequestMethod.GET)
        public String start(HttpServletRequest request){
            System.out.println("start method invoked...");
            String name = request.getParameter("name");
            int age = Integer.parseInt(request.getParameter("age"));
            System.out.println("name=" + name + " age = " + age);
            return "start";
        }
        @RequestMapping(value="/start",method=RequestMethod.POST)
        public String start2(){
            System.out.println("start2 method invoked...");
            return "start";
        }
    }
    step2:访问：http://localhost:8080/springMVC_003/test/start.do?name=zhangsan&age=45

      b.restfull风格参数传递
        step1:修改StartController.java

    package com.wdl.cn.controllers;

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;

    @Controller
    @RequestMapping(value="/test")
    public class StartController {

        @RequestMapping(value="/start/{name}/{age}",method=RequestMethod.GET)
        public String start(@PathVariable("name") String name,@PathVariable("age") int age){
            System.out.println("start method invoked...");
            System.out.println("name="+name+" age="+age);
            return "start";
        }
        @RequestMapping(value="/start",method=RequestMethod.POST)
        public String start2(){
            System.out.println("start2 method invoked...");
            return "start";
        }
    }

    step2:访问时，将参数值加入请求路径 http://localhost:8080/springMVC_003/test/start/zhangsan/45.do
总结：本讲主要讲述请求参数传递，主要掌握HttpServletRequest方式与restfull风格参数传递，下讲主要讲述form表单提交

第四讲 form表单提交
    使用struts2后，我们习惯将form表单的数据封装成一个对象，这也是面向对象编程的一个思维，本节讲述form表单提交。
    具体代码见UserController.java

    package com.wdl.cn.controllers;

    import java.text.SimpleDateFormat;
    import java.util.Date;

    import javax.servlet.http.HttpSession;

    import org.springframework.beans.propertyeditors.CustomDateEditor;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.InitBinder;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.servlet.ModelAndView;

    import com.wdl.cn.entity.User;

    @Controller
    @RequestMapping(value="/form")
    public class UserController {

        @RequestMapping(value="/add",method=RequestMethod.GET)
        public String toUserAddPage(){
            System.out.println("toUserAddPage method invoked...");
            return "useradd";
        }

        @RequestMapping(value="/add",method=RequestMethod.POST)
        public ModelAndView addUser(HttpSession session,User user){
            System.out.println("addUser method invoked...");
            System.out.println(user);
            ModelAndView mav = new ModelAndView();
            session.setAttribute("abc", user);
            mav.setViewName("redirect:/form/add.do");
            mav.addObject("abc", user);
            //return "useradd";
            return mav;
        }

        @InitBinder
        public void initBinder(WebDataBinder binder){
            binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), false));
        }
    }

     注：addUser方法中参数User则是接收请求发过来的参数；initBinder方法则是用来绑定用户提交的数据，前台提交过来的日期，在这里后面并不知情，则由这个方法来处理。
总结：本讲主要讲述如何来提交表单数据，并将其封装成一个对象。

第五节一个Controller处理多个请求
      很多情况下，我们都想把有关联的请求放在一个controller中，比如，对于一个用户的增删改查，都可以放在一个controller类中。对于springMVC注解的方式有两种方式可以实现。
    1.一个controller类中每个处理请求的方法的@requestMapping的param中可以带参数，比如：@RequestMapping(param="method=method1"),在类级别的@RequestMapping上面指定请求路径。

    package com.wdl.cn.controllers;

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;

    @Controller
    @RequestMapping(value="/manyRequest")
    public class ReceiveManyRequestController {
        @RequestMapping(params="method=method1")
        public ModelAndView methodOne(){
            System.out.println("method methodOne invoked...");
            ModelAndView mav = new ModelAndView("ReceiveManyRequest");
            mav.addObject("msg", "请求第一个方法");
            return mav;
        }
        @RequestMapping(params="method=method2")
        public ModelAndView methodTwo(){
            System.out.println("method methodTwo invoked...");
            ModelAndView mav = new ModelAndView("ReceiveManyRequest");
            mav.addObject("msg", "请求第二个方法");
            return mav;
        }

    }

      2.每个接收请求的方法的@RequestMapping的value中指定请求路径，看ReceveManyRequestController2.java

    package com.wdl.cn.controllers;

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;

    @Controller
    @RequestMapping(value="/manyRequest")
    public class ReceiveManyRequestController2 {
        @RequestMapping(value="/request1")
        public ModelAndView methodOne(){
            System.out.println("method methodOne invoked...");
            ModelAndView mav = new ModelAndView("ReceiveManyRequest");
            mav.addObject("msg", "请求第一个方法");
            return mav;
        }
        @RequestMapping(value="/request2")
        public ModelAndView methodTwo(){
            System.out.println("method methodTwo invoked...");
            ModelAndView mav = new ModelAndView("ReceiveManyRequest");
            mav.addObject("msg", "请求第二个方法");
            return mav;
        }
    }

这里访问WEB-INF目录下的页面，这个还不知道有没有类似struts2那样的通配符来可以访问不同的action,不同的method，不同的页面，用户则很爽，有的话求告知，而且我还有一个问题就是配置了如下的配置，但却访问不到静态资源，望解答！！-----访问路径：http://localhost:8080/Springmvc3/images/4.jpg

bubuko.com,布布扣

好了，其他不说了，看如下：

配置视图解析器

bubuko.com,布布扣

package com.tgb.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.tgb.entity.User;

@Controller
@RequestMapping("/test")
//这里也可以写成@RequestMapping("/test.do")也可以不写，因为在web.xml中配置了*.do
public class TestController {
	
	@RequestMapping(params="method=addUser")
	public String addUser(User user){
		System.out.println("dddddddddd");
		return "success";
	}
	
	@RequestMapping(value="/test0")//默认为get方式
	public String test0(){
		System.out.println("访问路径：test/test0.do");
		return "success";
	}

	@RequestMapping(value="/test1",method=RequestMethod.POST)
	public String test1(String sex){
		System.out.println(sex);
		System.out.println("访问路径为：test/test1.do,而且是get方式______"+sex);
		return "success";
	}
	
	@RequestMapping(value="/test2",method=RequestMethod.GET,params="param=test2")
	public String test2(){
		System.out.println("访问路径为：test/test1.do?param=test2,而且是get方式");
		return "success";
	}
	
	//REST风格的参数
	@RequestMapping(value="/test3/{name}")
	public String test3(@PathVariable String name){//形参和接收参数的名称一致
		System.out.println(name);
		System.out.println("访问路径为：test/test3/zhangsan.do");
		System.out.println("看这里的访问路径，直接就将‘zhangsan’这个参数值就传递给了@RequestMapping(value=\"/test3/{name}\")中的name参数名，可随意命名参数名称，");
		return "success";
	}
	
	@RequestMapping(value="/test5/{name}")
	public String test5(@PathVariable("name")String rename){//形参和接收参数的名称不一致
		System.out.println(rename);

		System.out.println("访问路径为：test/test5/zhangsan.do");
		System.out.println("看这里的访问路径，直接就将‘zhangsan’这个参数值就传递给了@RequestMapping(value=\"/test5/{name}\")中的name参数名，可随意命名参数名称，" +
				"然后后面的@PathVariable(\"name\")中的name名称要和上面的那个name保持一致，然后把此name绑定到形参rename");
		return "success";
	}
	
	@RequestMapping(value="/test4/{sex}/{sno}")
	//这里我写成@RequestMapping(value="test4/{sex}/{sno}")也是可以滴
	public String test4(@PathVariable("sex")String sex,@PathVariable("sno")String sno){
		System.out.println(sex);
		System.err.println(sno);
		System.out.println("访问路径：test/test4/male/10506.do");
		return "success";
	}
	
	//支持正则
	@RequestMapping(value="/test6/{textualPart:[a-z-]+}.{numericPart:[\\d]+}")
	public String test6(@PathVariable String textualPart,@PathVariable String numericPart){
		System.out.println(textualPart);//输出sometxt
		System.out.println(numericPart);//输出123
		System.out.println("访问路径：test/test6/sometxt.123.do");
		return "success";
	}
	
	//访问WEB-INF下的views文件中的不同目录的页面，这里访问的是user目录下的，不知道其他有什么好的办法没
	@RequestMapping(value="/test7")
	public String test7(){
		System.out.println("访问路径：test/test7.do");
		return "user/success";
	}
	
}

springMVC 注解版,布布扣,bubuko.com

springMVC 注解版

标签：des c style class blog code

原文地址：http://www.cnblogs.com/steven9801/p/3762468.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

springMVC 注解版

关于Spring MVC注解 @Transactional 事务标签 @InitBinder 标签

Spring 注解学习手札（五） 业务层事务处理

@RequestParam @RequestBody @PathVariable 等参数绑定注解详解(转)

引言：

简介：

1、 @PathVariable

2、 @RequestHeader、@CookieValue

3、@RequestParam, @RequestBody

4、@SessionAttributes, @ModelAttribute

补充讲解：

问题： 在不给定注解的情况下，参数是怎样绑定的？

@RequestBody

@ResponseBody

HttpMessageConverter

HttpMessageConverter匹配过程：

补充：

简介：

1、 value， method；

2、 consumes，produces；

3、 params，headers；

示例：

1、value / method 示例

2 consumes、produces 示例

3 params、headers 示例

http://www.codeweblog.com/stag/spring-requestmapping-method-requestmethod-post/

Spring 注解学习手札（五）业务层事务处理

问题：在不给定注解的情况下，参数是怎样绑定的？