用spring mvc有一段时间了,今天有时间对这个框架的一些使用进行一些总结。
官网上面对spring mvc有一个很详细的demo,地址:
就拿这个例子作为总结的代码。
1.首先介绍一下WebApplicationInitializer,可以通过下面的代码来实现对spring servlet的配置
public class MyWebApplicationInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext container) {
ServletRegistration.Dynamic registration = container.addServlet("dispatcher", new DispatcherServlet());
registration.setLoadOnStartup(1);
registration.addMapping("/example/*");
}
}
上面的代码功能等价于
<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>/example/*</url-pattern>
</servlet-mapping>
</web-app>
2.定义一个controller
@Controller
public class SimpleController {
@RequestMapping("/simple")
public @ResponseBody String simple() {
return "Hello world!";
}
}
这样就完成了一个controller,@RequestMapping(
"/simple")定义访问的url,其中可以使用一个参数“method”, 取值可以是RequestMethod.POST,RequestMethod.GET, RequestMethod.DEL等,用来限定访问的方法
3.使用hibernate validation作为验证
定义一个JavaBean:
public class JavaBean {
@NotNull
@Max(5)
private Integer number;
@NotNull
@Future
@DateTimeFormat(iso=ISO.DATE)
private Date date;
public Integer getNumber() {
return number;
}
public void setNumber(Integer number) {
this.number = number;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
}
定义一个controller:
@Controller
public class ValidationController {
// enforcement of constraints on the JavaBean arg require a JSR-303 provider on the classpath
@RequestMapping("/validate")
public @ResponseBody String validate(@Valid JavaBean bean, BindingResult result) {
if (result.hasErrors()) {
return "Object has validation errors";
} else {
return "No errors";
}
}
}
@Valid说明需要对JavaBean这个参数进行验证,验证的规则由hibernate的validation限定,里面有最基本的@NotNull,@Max,@Min,@reg等等,强大的验证规则。其中BindingResult会返回验证的信息。
4.定义返回值类型:
@Controller
public class MappingController {
@RequestMapping("/mapping/path")
public @ResponseBody String byPath() {
return "Mapped by path!";//最简单的,只定义了request的url
}
@RequestMapping(value="/mapping/path/*", method=RequestMethod.GET)
public @ResponseBody String byPathPattern(HttpServletRequest request) {//拿到的HttpServletRequest基本上什么都可以做到了
return "Mapped by path pattern ('" + request.getRequestURI() + "')";
}
@RequestMapping(value="/mapping/method", method=RequestMethod.GET)
public @ResponseBody String byMethod() {
return "Mapped by path + method";
}
@RequestMapping(value="/mapping/parameter", method=RequestMethod.GET, params="foo")
public @ResponseBody String byParameter() {
return "Mapped by path + method + presence of query parameter!";//定义了必须符合url+方法+参数三个规则的请求才可以被捕捉
}
@RequestMapping(value="/mapping/parameter", method=RequestMethod.GET, params="!foo")
public @ResponseBody String byParameterNegation() {
return "Mapped by path + method + not presence of query parameter!";//params="!foo",不能有foo这个参数的url+方法的请求
}
@RequestMapping(value="/mapping/header", method=RequestMethod.GET, headers="FooHeader=foo")
public @ResponseBody String byHeader() {
return "Mapped by path + method + presence of header!";//附加header的规则
}
@RequestMapping(value="/mapping/header", method=RequestMethod.GET, headers="!FooHeader")
public @ResponseBody String byHeaderNegation() {
return "Mapped by path + method + absence of header!";//没有FooHeader的headers
}
@RequestMapping(value="/mapping/consumes", method=RequestMethod.POST, consumes=MediaType.APPLICATION_JSON_VALUE)
public @ResponseBody String byConsumes(@RequestBody JavaBean javaBean) {
return "Mapped by path + method + consumable media type (javaBean '" + javaBean + "')";//这个在后面的convert再说
}
@RequestMapping(value="/mapping/produces", method=RequestMethod.GET, produces=MediaType.APPLICATION_JSON_VALUE)
public @ResponseBody JavaBean byProducesJson() {//返回JavaBean的json数据
return new JavaBean();
}
@RequestMapping(value="/mapping/produces", method=RequestMethod.GET, produces=MediaType.APPLICATION_XML_VALUE)
public @ResponseBody JavaBean byProducesXml() {//返回JavaBean的xml数据
return new JavaBean();
}
}
5.请求参数的处理
@Controller
@RequestMapping("/data")
public class RequestDataController {
@RequestMapping(value="param", method=RequestMethod.GET)
public @ResponseBody String withParam(@RequestParam String foo) {
return "Obtained 'foo' query parameter value '" + foo + "'";//RequestParam ,获得一个foo的参数,还可以指定参数的名字,例如下面的的
}
@RequestMapping(value="group", method=RequestMethod.GET)
public @ResponseBody String withParamGroup(JavaBean bean) {
return "Obtained parameter group " + bean;
}
@RequestMapping(value="path/{var}", method=RequestMethod.GET)
public @ResponseBody String withPathVariable(@PathVariable String var) {//使用@PathVariable ,参数需要在url中出现例如 xxx/path/hello
return "Obtained 'var' path variable value '" + var + "'";// "hello"这个参数就会被获取到
}
@RequestMapping(value="{path}/simple", method=RequestMethod.GET)// url=/pets;foo=11/simple
public @ResponseBody String withMatrixVariable(@PathVariable String path, @MatrixVariable String foo) {
//path=pets; foo=11
return "Obtained matrix variable 'foo=" + foo + "' from path segment '" + path + "'";
}
@RequestMapping(value="{path1}/{path2}", method=RequestMethod.GET)// url = /42;foo1=11/21;foo2=22
public @ResponseBody String withMatrixVariablesMultiple (
@PathVariable String path1, @MatrixVariable(value="foo", pathVar="path1") String foo1,
@PathVariable String path2, @MatrixVariable(value="foo", pathVar="path2") String foo2) {//类似上面的,分块分解参数
return "Obtained matrix variable foo=" + foo1 + " from path segment '" + path1
+ "' and variable 'foo=" + foo2 + " from path segment '" + path2 + "'";
}
@RequestMapping("/owners/{ownerId}")// 例如url:/owners/42/pets/21.
public class RelativePathUriTemplateController {
@RequestMapping("/pets/{petId}")
public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
// implementation omitted
}
}
// GET /owners/42;q=11/pets/21;q=22
@RequestMapping(value = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)
public void findPet(
@MatrixVariable(value="q", pathVar="ownerId") int q1,
@MatrixVariable(value="q", pathVar="petId") int q2) {
// q1 == 11
// q2 == 22
}
// GET /owners/42;q=11;r=12/pets/21;q=22;s=23
@RequestMapping(value = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)//@MatrixVariable 允许组合所有参数成为一个
public void findPet(
@MatrixVariable Map < String, String > matrixVars,
@MatrixVariable(pathVar = "petId" ) Map<String, String> petMatrixVars) {
// matrixVars: [" q " : [11,22], " r " : 12, " s " : 23]
// petMatrixVars: [" q " : 11, " s " : 23]
}
/*
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(value="header", method=RequestMethod.GET)
public @ResponseBody String withHeader(@RequestHeader String Accept) {//@RequestHeader 可以指定你想或者header中的哪个属性的信息
return "Obtained 'Accept' header '" + Accept + "'";//例如@RequestHeader("Keep-Alive") 获得 300
}
// cookie中有一个值openid_provider=415A4AC178C59DACE0B2C9CA727CDD84 ,也可以指定变量名withCookie(@CookieValue("openid_provider") param);
@RequestMapping(value="cookie", method=RequestMethod.GET)
public @ResponseBody String withCookie(@CookieValue String openid_provider) {
return "Obtained 'openid_provider' cookie '" + openid_provider + "'";
}
/**
*响应流媒体,一般是xml和json数据,可以使用consumes="application/json"指定接受的是json还是xml
*spring可以把POST的数据转换成为一个bean
*例如有个class JavaBean implements Serializable {
* private Interger id;
* private Stirng name;
* private String status;
* public JavaBean (){
*
* }
* }
* @RequestMapping(value="body", method=RequestMethod.POST)
* public @ResponseBody String withBody(@RequestBody JavaBean bean) {//响应流媒体
* return "Posted request body '" + bean + "'";
* }
* $.post("/body",{'id':1, 'name': 'people', 'status': 'yes'},function(result){
* alert(result);
* });
* spring 会把post过来的数据组成一个bean,这种方式尽量少用
*/
@RequestMapping(value="body", method=RequestMethod.POST)
public @ResponseBody String withBody(@RequestBody String body) {//响应流媒体
return "Posted request body '" + body + "'";
}
@RequestMapping(value="entity", method=RequestMethod.POST)
public @ResponseBody String withEntity(HttpEntity<String> entity) {
return "Posted request body '" + entity.getBody() + "'; headers = " + entity.getHeaders();
}//这个就牛b了,把整个http请求的数据都给你了,有HttpEntity来传递请求数据当然有一个返回应答的数据流类
@RequestMapping("/something")
public ResponseEntity<String> handle(HttpEntity<byte[]> requestEntity) throws
UnsupportedEncodingException {
String requestHeader = requestEntity.getHeaders().getFirst("MyRequestHeader"));
byte[] requestBody = requestEntity.getBody();
// do something with request header and body
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.set("MyResponseHeader", "MyValue");//设置好header后和body-〉hello world组成ResponseEntity返回
return new ResponseEntity<String>("Hello World", responseHeaders, HttpStatus.CREATED);
}
/**
*@RequestBody @ResponseBody分别是HttpEntity和ResponseEntity的去掉header的body部分
*/
}
在这里还有一种参数的形式@ModelAttribute,@ModelAttribute的定义有两种,一种是定义在方法上,另一种是定义在参数里,当这个annotation定义在方法上,表示controller返回的是一个JavaBean,当annotation定义在参数里,表示post过来的数据会被转换成为JavaBean。
首先定义一个JavaBean的class:
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = -8333984959652704635L;
private Integer id;
private String firstName;
private String lastName;
private String currency;
private Double money;
......getter/setter
}
有一个controller:
@Controller
@RequestMapping("EDIT")
public class PetSitesEditController {
@ModelAttribute("people")
public Person getPerson() {
return this.person ;
}//对于这个这个controller来说,其他的方法的返回的jsp页面里面都会有一个people属性被返回,因为@ModelAttribute注解的方法会在这个controller的其他方法调用前被调用
}
在jsp页面中可以访问${
people}这个属性,如果在
@ModelAttribute没有指定属性的名字,那么默认就是person
看下面
有一个jsp页面
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Edit Person</h1>
<c:url var="saveUrl" value="/main/edit/${personAttribute.id}" />
<form:form modelAttribute="personAttribute" method="POST" action="${saveUrl}">
<table>
<tr>
<td><form:label path="id">Id:</form:label></td>
<td><form:input path="id" disabled="true"/></td>
</tr>
<tr>
<td><form:label path="firstName">First Name:</form:label></td>
<td><form:input path="firstName"/></td>
</tr>
<tr>
<td><form:label path="lastName">Last Name</form:label></td>
<td><form:input path="lastName"/></td>
</tr>
<tr>
<td><form:label path="money">Money</form:label></td>
<td><form:input path="money"/></td>
</tr>
<tr>
<td><form:label path="currency">Currency:</form:label></td>
<td><form:select path="currency" items="${currencies}"/></td>
</tr>
</table>
<input type="submit" value="Save" />
</form:form>
</body>
</html>
post过来的数据
personAttribute.id = 1, personAttribute.
firstName = John....
@RequestMapping(value = "/edit/{id}", method = RequestMethod.POST)
public String saveEdit(@ModelAttribute("personAttribute") Person person,
@PathVariable Integer id) {
//spring会把post过来的person信息组合成为一个JavaBean,这里还获得了id这个信息
}
controller代码
根据@ModelAttribute两种用法,可以这样子实现
@Controller
public class PersonController {
@ModelAttribute("person")
public Person getPerson() {
return new Person();
}
@RequestMapping(value = "/new")
public String add(@ModelAttribute("person") Person person) {
return "add person";
}
}
/*
* 访问url /new
* 首先会执行getPerson的方法,然后再执行add方法,其中person这个bean已经被new出来了,所以在add方法中可以被获得,这个有点像下面要说的convert,但是功能要稍微弱一些。
*/
6.convert,这是spring mvc最令我佩服的地方
首先定义一个convert
public class AccountConverter implements Converter<String, Account> {
private AccountManager accountManager;
@Autowired
public AccountConverter(AccountManager accountManager) {//ioc一个accoutManager,用来根据id查出accout
this.accountManager = accountManager;
}
@Override
public Account convert(String id) {
return this.accountManager.getAccount(id);
}
}
下面一个controller:
@Controller
@RequestMapping("/accounts")
public class AccountController {
@RequestMapping(value="/{account}/edit", method = RequestMethod.GET)
public String edit(@PathVariable Account account) {
//操作accout类
return "accounts/edit";
}
}
下面描述了convert的运作过程
7.redirect,重点用法在return中
@Controller
@RequestMapping("/redirect")
public class RedirectController {
private final ConversionService conversionService;
@Inject
public RedirectController(ConversionService conversionService) {
this.conversionService = conversionService;
}
@RequestMapping(value="/uriTemplate", method=RequestMethod.GET)
public String uriTemplate(RedirectAttributes redirectAttrs) {
redirectAttrs.addAttribute("account", "a123"); // Used as URI template variable
redirectAttrs.addAttribute("date", new LocalDate(2011, 12, 31)); // Appended as a query parameter
return "redirect:/redirect/{account}";
}
@RequestMapping(value="/uriComponentsBuilder", method=RequestMethod.GET)
public String uriComponentsBuilder() {
String date = this.conversionService.convert(new LocalDate(2011, 12, 31), String.class);
UriComponents redirectUri = UriComponentsBuilder.fromPath("/redirect/{account}").queryParam("date", date)
.build().expand("a123").encode();
return "redirect:" + redirectUri.toUriString();
}
@RequestMapping(value="/{account}", method=RequestMethod.GET)
public String show(@PathVariable String account, @RequestParam(required=false) LocalDate date) {
return "redirect/redirectResults";
}
}
8.org.springframework.ui.Model,Model这个类中有一些css的配置,可以允许我们使用,有时可能会用到
@Controller
@RequestMapping("/views/*")
public class ViewsController {
@RequestMapping(value="html", method=RequestMethod.GET)
public String prepare(Model model) {
model.addAttribute("foo", "bar");
model.addAttribute("fruit", "apple");
return "views/html";
}
}
9.文件上传、下载:
上传代码
@Controller
@RequestMapping("/fileupload")
public class FileUploadController {
@ModelAttribute
public void ajaxAttribute(WebRequest request, Model model) {
model.addAttribute("ajaxRequest", AjaxUtils.isAjaxRequest(request));
}
@RequestMapping(method=RequestMethod.GET)
public void fileUploadForm() {
}
@RequestMapping(method=RequestMethod.POST)
public void processUpload(@RequestParam MultipartFile file, Model model) throws IOException {//MultipartFile可以指定变量名@MultipartFile("file001") file
//file.isEmpty(),file.getBytes();,file.getInputStream();
model.addAttribute("message", "File '" + file.getOriginalFilename() + "' uploaded successfully");
}
}
文件下载
@RequestMapping(value = "/files/{file_name}", method = RequestMethod.GET)
public void getFile(
@PathVariable("file_name") String fileName,
HttpServletResponse response) {
try {
// get your file as InputStream
InputStream is = ...;
// copy it to response's OutputStream
IOUtils.copy(is, response.getOutputStream());
response.flushBuffer();
} catch (IOException ex) {
log.info("Error writing file to output stream. Filename was '" + fileName + "'");
throw new RuntimeException("IOError writing file to output stream");
}
}//本人比较喜欢这个
@RequestMapping(value = "/files/{file_name}", method = RequestMethod.GET)
@ResponseBody
public FileSystemResource getFile(@PathVariable("file_name") String fileName) {
return new FileSystemResource(myService.getFileFor(fileName));
}
10.ajax 部分,有关 Servlet 3 async processing feature:
首先说一下Servlet 3 的一些特性,
一个普通 Servlet 的主要工作流程大致如下:首先,Servlet 接收到请求之后,可能需要对请求携带的数据进行一些预处理;接着,调用业务接口的某些方法,以完成业务处理;最后,根据处理的结果提交响应,Servlet 线程结束。其中第二步的业务处理通常是最耗时的,这主要体现在数据库操作,以及其它的跨网络调用等,在此过程中,Servlet 线程一直处于阻塞状态,直到业务方法执行完毕。在处理业务的过程中,Servlet 资源一直被占用而得不到释放,对于并发较大的应用,这有可能造成性能的瓶颈。对此,在以前通常是采用私有解决方案来提前结束 Servlet 线程,并及时释放资源
现在通过使用 Servlet 3.0 的异步处理支持,之前的 Servlet 处理流程可以调整为如下的过程:首先,Servlet 接收到请求之后,可能首先需要对请求携带的数据进行一些预处理;接着,Servlet 线程将请求转交给一个异步线程来执行业务处理,线程本身返回至容器,此时 Servlet 还没有生成响应数据,异步线程处理完业务以后,可以直接生成响应数据(异步线程拥有 ServletRequest 和 ServletResponse 对象的引用),或者将请求继续转发给其它 Servlet。如此一来, Servlet 线程不再是一直处于阻塞状态以等待业务逻辑的处理,而是启动异步线程之后可以立即返回。
一个简单的demo
@WebServlet(urlPatterns = "/demo", asyncSupported = true)
public class AsyncDemoServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp)
throws IOException, ServletException {
resp.setContentType("text/html;charset=UTF-8");
PrintWriter out = resp.getWriter();
out.println("开始时间:" + new Date() + ".");
out.flush();
//在子线程中执行业务调用,并由其负责输出响应,主线程退出
AsyncContext ctx = req.startAsync();
new Thread(new Executor(ctx)).start();
out.println("结束时间:" + new Date() + ".");
out.flush();
}
}
public class Executor implements Runnable {
private AsyncContext ctx = null;
public Executor(AsyncContext ctx){
this.ctx = ctx;
}
public void run(){
try {
//等待十秒钟,以模拟业务方法的执行
Thread.sleep(10000);
PrintWriter out = ctx.getResponse().getWriter();
out.println("业务处理完毕的时间:" + new Date() + ".");
out.flush();
ctx.complete();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出的结果:
开始时间:Thu Jul 27 09:49:30 CST 2013
开始时间:Thu Jul 27 09:49:30 CST 2013
业务处理完毕的时间: Thu Jul 27 09:49:40 CST 2013
下面是spring mvc 3.2 对其的支持。对于spring mvc 里面有三种方式的支持,分别是Callable,DeferredResult,WebAsyncTask
Callable:
@RequestMapping("/response-body")
public @ResponseBody Callable<String> callable(final @RequestParam(required=false, defaultValue="true") boolean handled) {
//进行一些与处理之后,把最耗时的业务逻辑部分放到Callable中,注意,如果你需要在new Callable中用到从页面传入的参数,需要在参数前加入final
return new Callable<String>() {
@Override
public String call() throws Exception {
if(handled){
Thread.sleep(2000);
}else{
Thread.sleep(2000*2);
}
return "Callable result";
}
};
}
WebAsyncTask:
(一)对于Callable来说会默认使用SimpleAsyncTaskExecutor类来执行,这个类非常简单而且没有重用线程。而在实际中,你将可能会需要使用AsyncTaskExecutor类来针对你所处的环境进行适当的配置。
(二)在servlet中timeout是一个很重要的问题,servlet容器会尝试重用request和response对象,对于一个timeout但是实际上没有结束的异步请求来说,使用同一个request和response对象影响将无法估量。
WebAsyncTask中有一个setTimeout的选项,其中他的核心原理是callable
@RequestMapping("/custom-timeout-handling")
public @ResponseBody WebAsyncTask<String> callableWithCustomTimeoutHandling() {
Callable<String> callable = new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(2000);
return "Callable result";
}
};
return new WebAsyncTask<String>(1000, callable);//允许指定timeout时间
}
最后一个是DeferredResult<?> ,一个DeferredResult<?> 允许应用程序从一个线程中返回,而何时返回则由线程决定
@Controller
@RequestMapping("/async")
public class DeferredResultController {
private final Queue<DeferredResult<String>> responseBodyQueue = new ConcurrentLinkedQueue<DeferredResult<String>>();
private final Queue<DeferredResult<ModelAndView>> mavQueue = new ConcurrentLinkedQueue<DeferredResult<ModelAndView>>();
private final Queue<DeferredResult<String>> exceptionQueue = new ConcurrentLinkedQueue<DeferredResult<String>>();
@RequestMapping("/deferred-result/response-body")
public @ResponseBody DeferredResult<String> deferredResult() {
DeferredResult<String> result = new DeferredResult<String>();
this.responseBodyQueue.add(result);
return result;
}
@RequestMapping("/deferred-result/model-and-view")
public @ResponseBody DeferredResult<ModelAndView> deferredResultWithView() {
DeferredResult<ModelAndView> result = new DeferredResult<ModelAndView>();
this.mavQueue.add(result);
return result;
}
@RequestMapping("/deferred-result/exception")
public @ResponseBody DeferredResult<String> deferredResultWithException() {
DeferredResult<String> result = new DeferredResult<String>();
this.exceptionQueue.add(result);
return result;
}
//上面三个分别接受了请求之后就return了
// 这里允许我们在其他的线程中处理数据,并且无需实时返回
@RequestMapping("/deferred-result/timeout-value")
public @ResponseBody DeferredResult<String> deferredResultWithTimeoutValue() {
// Provide a default result in case of timeout and override the timeout value
// set in src/main/webapp/WEB-INF/spring/appServlet/servlet-context.xml
return new DeferredResult<String>(1000L, "Deferred result after timeout");
}
//创建一个计划任务,每2秒处理一次
@Scheduled(fixedRate=2000)
public void processQueues() {
for (DeferredResult<String> result : this.responseBodyQueue) {
result.setResult("Deferred result");
this.responseBodyQueue.remove(result);
}
for (DeferredResult<String> result : this.exceptionQueue) {
result.setErrorResult(new IllegalStateException("DeferredResult error"));
this.exceptionQueue.remove(result);
}
for (DeferredResult<ModelAndView> result : this.mavQueue) {
result.setResult(new ModelAndView("views/html", "javaBean", new JavaBean("bar", "apple")));
this.mavQueue.remove(result);
}
}
@ExceptionHandler
@ResponseBody
public String handleException(IllegalStateException ex) {
return "Handled exception: " + ex.getMessage();
}
}
11. Interceptor,通过继承HandlerInterceptor, 实现preHandle(..)方法来 定义一些列方法执行前后的动作
官方例子
<mvc:interceptors>
<ref bean="officeHoursInterceptor"/>
</mvc:interceptors>
<bean id="officeHoursInterceptor"
class="samples.TimeBasedAccessInterceptor">
<property name="openingTime" value="9"/>
<property name="closingTime" value="18"/>
</bean>
package samples;
public class TimeBasedAccessInterceptor extends HandlerInterceptorAdapter {
private int openingTime;
private int closingTime;
public void setOpeningTime(int openingTime) {
this.openingTime = openingTime;
}
public void setClosingTime(int closingTime) {
this.closingTime = closingTime;
}
public boolean preHandle(
HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
Calendar cal = Calendar.getInstance();
int hour = cal.get(HOUR_OF_DAY);
if (openingTime <= hour && hour < closingTime) {
return true;
} else {
response.sendRedirect("http://host.com/outsideOfficeHours.html");
return false;
}
}
}
HandlerInterceptorAdapter 里面有很多方法,下面是api的部分文档
那些pre,after和post开头的方法基本可以满足interceptor的各种需要
这里基本结束了spring mvc 3.2的总结,在写这个文章的前几天spring已经出4.0了,看了一下,发现里面开始有websocket的支持了。