Spring MVC的使用——DefferedResult
要使用Spring MVC的异步功能,你得先确保你用的是Servlet 3.0或以上的版本,Maven中如此配置:
1
2
3
4
5
6
7
8
9
10
11
|
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>
3.1
.
0
</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>
4.2
.
3
.RELEASE</version>
</dependency>
|
我这里使用的Servlet版本是3.1.0,Spring MVC版本是4.2.3,建议使用最新的版本。
由于Spring MVC的良好封装,异步功能使用起来出奇的简单。传统的同步模式的Controller是返回ModelAndView,而异步模式则是返回DeferredResult<ModelAndView>。
看这个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@RequestMapping
(value=
"/asynctask"
, method = RequestMethod.GET)
public
DeferredResult<ModelAndView> asyncTask(){
DeferredResult<ModelAndView> deferredResult =
new
DeferredResult<ModelAndView>();
System.out.println(
"/asynctask 调用!thread id is : "
+ Thread.currentThread().getId());
longTimeAsyncCallService.makeRemoteCallAndUnknownWhenFinish(
new
LongTermTaskCallback() {
@Override
public
void
callback(Object result) {
System.out.println(
"异步调用执行完成, thread id is : "
+ Thread.currentThread().getId());
ModelAndView mav =
new
ModelAndView(
"remotecalltask"
);
mav.addObject(
"result"
, result);
deferredResult.setResult(mav);
}
});
}
|
longTimeAsyncCallService是我写的一个模拟长时间异步调用的服务类,调用之,立即返回,当它处理完成时候,就钩起一个线程调用我们提供的回调函数,这跟“图3”描述的一样,它的代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
interface
LongTermTaskCallback {
void
callback(Object result);
}
public
class
LongTimeAsyncCallService {
private
final
int
CorePoolSize =
4
;
private
final
int
NeedSeconds =
3
;
private
Random random =
new
Random();
private
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(CorePoolSize);
public
void
makeRemoteCallAndUnknownWhenFinish(LongTermTaskCallback callback){
System.out.println(
"完成此任务需要 : "
+ NeedSeconds +
" 秒"
);
scheduler.schedule(
new
Runnable() {
@Override
public
void
run() {
callback.callback(
"长时间异步调用完成."
);
}
},
"这是处理结果:)"
, TimeUnit.SECONDS);
}
}
|
输出的结果是:
/asynctask 调用!thread id is : 46
完成此任务需要 : 3 秒
异步调用执行完成, thread id is : 47
由此可见返回结果的线程和请求处理线程不是同一线程。
还有个叫WebAsyncTask
返回DefferedResult<ModelAndView>并非唯一做法,还可以返回WebAsyncTask来实现“异步”,但略有不同,不同之处在于返回WebAsyncTask的话是不需要我们主动去调用Callback的,看例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@RequestMapping
(value=
"/longtimetask"
, method = RequestMethod.GET)
public
WebAsyncTask longTimeTask(){
System.out.println(
"/longtimetask被调用 thread id is : "
+ Thread.currentThread().getId());
Callable<ModelAndView> callable =
new
Callable<ModelAndView>() {
public
ModelAndView call()
throws
Exception {
Thread.sleep(
3000
);
//假设是一些长时间任务
ModelAndView mav =
new
ModelAndView(
"longtimetask"
);
mav.addObject(
"result"
,
"执行成功"
);
System.out.println(
"执行成功 thread id is : "
+ Thread.currentThread().getId());
return
mav;
}
};
return
new
WebAsyncTask(callable);
}
|
其核心是一个Callable<ModelAndView>,事实上,直接返回Callable<ModelAndView>都是可以的,但我们这里包装了一层,以便做后面提到的“超时处理”。和前一个方案的差别在于这个Callable的call方法并不是我们直接调用的,而是在longTimeTask返回后,由Spring MVC用一个工作线程来调用,执行,打印出来的结果:
/longtimetask被调用 thread id is : 56
执行成功 thread id is : 57
可见确实由不同线程执行的,但这个WebAsyncTask可不太符合“图3”所描述的技术规格,它仅仅是简单地把请求处理线程的任务转交给另一工作线程而已。
处理超时
如果“长时间处理任务”一直没返回,那我们也不应该让客户端无限等下去啊,总归要弄个“超时”出来。如图:
(图4)
其实“超时处理线程”和“回调处理线程”可能都是线程池中的某个线程,我为了清晰点把它们分开画而已。增加这个超时处理在Spring MVC中非常简单,先拿WebAsyncTask那段代码来改一下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
@RequestMapping
(value=
"/longtimetask"
, method = RequestMethod.GET)
public
WebAsyncTask longTimeTask(){
System.out.println(
"/longtimetask被调用 thread id is : "
+ Thread.currentThread().getId());
Callable<ModelAndView> callable =
new
Callable<ModelAndView>() {
public
ModelAndView call()
throws
Exception {
Thread.sleep(
3000
);
//假设是一些长时间任务
ModelAndView mav =
new
ModelAndView(
"longtimetask"
);
mav.addObject(
"result"
,
"执行成功"
);
System.out.println(
"执行成功 thread id is : "
+ Thread.currentThread().getId());
return
mav;
}
};
WebAsyncTask asyncTask =
new
WebAsyncTask(
2000
, callable);
asyncTask.onTimeout(
new
Callable<ModelAndView>() {
public
ModelAndView call()
throws
Exception {
ModelAndView mav =
new
ModelAndView(
"longtimetask"
);
mav.addObject(
"result"
,
"执行超时"
);
System.out.println(
"执行超时 thread id is :"
+ Thread.currentThread().getId());
return
mav;
}
}
);
return
new
WebAsyncTask(
3000
, callable);
}
|
注意看红色字体部分代码,这就是前面提到的为什么Callable还要外包一层的缘故,给WebAsyncTask设置一个超时回调,即可实现超时处理,在这个例子中,正常处理需要3秒钟,而超时设置为2秒,所以肯定会出现超时,执行打印log如下:
/longtimetask被调用 thread id is : 59
执行超时 thread id is :61
执行成功 thread id is : 80
嗯?明明超时了,怎么还会“执行成功”呢?超时归超时,超时并不会打断正常执行流程,但注意,出现超时后我们给客户端返回了“超时”的结果,那接下来即便正常处理流程成功,客户端也收不到正常处理成功所产生的结果了,这带来的问题就是:客户端看到了“超时”,实际上操作到底有没有成功,客户端并不知道,但通常这也不是什么大问题,因为用户在浏览器上再刷新一下就好了。:D
好,再来看DefferedResult方式的超时处理:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
@RequestMapping
(value =
"/asynctask"
, method = RequestMethod.GET)
public
DeferredResult<ModelAndView> asyncTask() {
DeferredResult<ModelAndView> deferredResult =
new
DeferredResult<ModelAndView>(2000L);
System.out.println(
"/asynctask 调用!thread id is : "
+ Thread.currentThread().getId());
longTimeAsyncCallService.makeRemoteCallAndUnknownWhenFinish(
new
LongTermTaskCallback() {
@Override
public
void
callback(Object result) {
System.out.println(
"异步调用执行完成, thread id is : "
+ Thread.currentThread().getId());
ModelAndView mav =
new
ModelAndView(
"remotecalltask"
);
mav.addObject(
"result"
, result);
deferredResult.setResult(mav);
}
});
deferredResult.onTimeout(
new
Runnable() {
@Override
public
void
run() {
System.out.println(
"异步调用执行超时!thread id is : "
+ Thread.currentThread().getId());
ModelAndView mav =
new
ModelAndView(
"remotecalltask"
);
mav.addObject(
"result"
,
"异步调用执行超时"
);
deferredResult.setResult(mav);
}
});
return
deferredResult;
}
|
非常类似,对吧,我把超时设置为2秒,而正常处理需要3秒,一定会超时,执行结果如下:
/asynctask 调用!thread id is : 48
完成此任务需要 : 3 秒
异步调用执行超时!thread id is : 51
异步调用执行完成, thread id is : 49
完全在我们预料之中。
异常处理
貌似没什么差别,在Controller中的处理和之前同步模式的处理是一样一样的:
1
2
3
4
5
6
|
@ExceptionHandler
(Exception.
class
)
public
ModelAndView handleAllException(Exception ex) {
ModelAndView model =
new
ModelAndView(
"error"
);
model.addObject(
"result"
, ex.getMessage());
return
model;
}
|
还要再弄个全局的异常处理啥的,和过去的做法都一样,在此不表了。