Spring MVC的异步模式

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;      }

还要再弄个全局的异常处理啥的，和过去的做法都一样，在此不表了。