利用ajax实现服务端异步任务状态监听

拼搏现实的明天。 2022-08-09 06:53 293阅读 0赞

项目中为了改善用户体验，一些耗时操作常常会使用异步方式执行，但是一旦将任务放入后台，用户就不能及时得到任务执行的结果。所以需要涉及一种方式能够持续跟踪任务的进行情况。每个监听任务会被分配一个任务ID，在任务监听结束后被释放。

全局监听器的实现

基于单例模式设置一个HashMap能被系统全局访问用于存放任意任务的监听数据。同时Value部分使用特殊特殊结构。

结构设计

即HashMap中的Value存储的部分。

  1. public class ValueStruc { 
  3.     private boolean expireable;
  4.     private Date expireTime;
  5.     private Object value;
  6.     private int readCount;
  8.     public ValueStruc(){}
  9.     public ValueStruc(Object value, Date expireTime){
  10.         this.value = value;
  11.         this.expireable = true;
  12.         this.expireTime = expireTime;
  13.         this.readCount = 0;
  14.     }
  15.     public ValueStruc(Object value){
  16.         this.value = value;
  17.         this.readCount = 0;
  18.     }
  20.     public Object readValue(){
  21.         readCount = readCount +1;
  22.         return this.value;
  23.     }
  25.     public boolean expired(){
  26.         if(expireable){
  27.             return new Date().after(expireTime);
  28.         } else {
  29.             return false;
  30.         }
  31.     }
  33.     public boolean isExpireable(){
  34.         return this.expireable;
  35.     }
  37.     public void setExpireable(boolean exb){
  38.         this.expireable = exb;
  39.     }
  41.     public Date getExpireTime(){
  42.         return expireTime;
  43.     }
  45.     public void setExpireTime(Date exd){
  46.         this.expireTime = exd;
  47.     }
  49.     public Object getValue(){
  50.         return value;
  51.     }
  53.     public void setValue(Object v){
  54.         this.value = v;
  55.     }
  57.     public int getReadCount(){
  58.         return readCount;
  59.     }
  61.     public void setReadCount(int readCount){
  62.         this.readCount = readCount;
  63.     }
  65. }

监听器

用于在程序的任意位置注册监听ID，更新、读取ID对应的信息。同时应该支持ID的过期清除，读取行为记录等。
代码如下：

  1. public class DataObserver { 
  3.     private HashMap<String, ValueStruc> map;
  4.     private volatile static DataObserver instance;
  5.     private DataObserver(){
  6.         map = new HashMap<String, ValueStruc>();
  7.     }
  8.     public static DataObserver getInstance(){
  9.         if(instance == null){
  10.             synchronized(DataObserver.class){
  11.                 if(instance == null){
  12.                     instance = new DataObserver();
  13.                 }
  14.             }
  15.         }
  16.         return instance;
  17.     }
  19.     /** * 注册Key<br> * 基本：输入键值对，key, value<br> * 可选：如果需要有有效时间，则加入秒数，否则写入负数即可表示为不设置过期时间,0没有意义<br> * Function: register * * @author wengshengyuan DateTime 2015-10-12 上午9:16:01 * @param key * @param value * @param Sec * @return ValueStruc,已存在该key则返回null */
  20.     public ValueStruc register(String key, Object value, int Sec) {
  21.         if(map.containsKey(key))
  22.             return null;
  23.         Date now = new Date();
  24.         if(Sec > 0){
  25.             Date expireTime = DateUtils.addSeconds(now, Sec);
  26.             ValueStruc v = new ValueStruc(value, expireTime);
  27.             map.put(key, v);
  28.             return v;
  29.         } else {
  30.             ValueStruc v = new ValueStruc(value);
  31.             map.put(key, v);
  32.             return v;
  33.         }
  34.     }
  36.     /** * 更新已存在的值 * Function: update * * @author wengshengyuan DateTime 2015-10-12 下午1:45:46 * @param key * @param value * @return 返回新的值，若没有该Key， 返回null */
  37.     public ValueStruc update(String key, Object value){
  38.         if(map.containsKey(key)){
  39.             ValueStruc v = map.get(key);
  40.             v.setValue(value);
  41.             map.put(key, v);
  42.             return v;
  43.         } else {
  44.             return null;
  45.         }
  46.     }
  48.     /** * 读取key<br> * Function: read * * @author wengshengyuan DateTime 2015-10-12 上午9:29:48 * @param key * @return 写入的Object, 过期或者没有均返回null */
  49.     public Object read(String key){
  50.         ValueStruc v = map.get(key);
  51.         if(v == null)
  52.             return null;
  53.         if(v.expired()){
  54.             map.remove(key);
  55.             return null;
  56.         }
  57.         return v.readValue();
  58.     }
  60.     /** * 删除某一Key的值<br> * 若删除成功，则返回之前的值，若删除不成功，则返回null * Function: remove * * @author wengshengyuan DateTime 2015-10-12 上午11:09:39 * @param key * @return */
  61.     public ValueStruc remove(String key){
  62.         return map.remove(key);
  63.     }
  65.     /** * 清空map * Function: clear * * @author wengshengyuan DateTime 2015-10-12 上午11:10:23 */
  66.     public void clear(){
  67.         map = new HashMap<String, ValueStruc>();
  68.     }
  69. }

使用方式

注册

在执行异步方法前，生成监听ID， 并传入异步执行体。执行状态的更新由异步任务更新。

  1. String observerID = "taskName_"+UUIDUtils.getUUID32();
  2. DataObserver.getInstance().register(observerID,value,-1);
  3. AsyncTask task = new AsyncTask(String observerID);
  4. task.start();

更新

在异步任务中随时调用

  1. DataObserver.getInstance().update(observerID, value);

读取

  1. DataObserver.getInstance().read(observerID);

Controller层接口

JAVA服务端API实现

通过Controller定义数据传输接口。包括：增、删、改、查和清除等功能。这里以查询为例。
Controller代码如下：

  1. @Controller
  2. @RequestMapping(value="/api/observer")
  3. public class DataObserverAPI { 
  5.     @ResponseBody
  6.     @RequestMapping(value = "observe/{key}", method = RequestMethod.GET)
  7.     public ResultInfo observe(HttpServletRequest request, @PathVariable("key") String key){
  8.         ResultInfo result = new ResultInfo();
  9.         Object o = DataObserver.getInstance().read(key);
  10.         if(o == null){
  11.             result.setStateId(-1);
  12.             result.setErrorMsg("未查询到信息");
  13.         } else {
  14.             result.addObj2Map("value", o);
  15.         }
  16.         return result;
  17.     }
  19.     @ResponseBody
  20.     @RequestMapping(value = "regester/{key}/{value}/{timeout}", method = RequestMethod.GET)
  21.     public ResultInfo testObserver(HttpServletRequest request, @PathVariable("key") String key, @PathVariable("value") String value
  22.             , @PathVariable("timeout") int timeout){
  23.         ResultInfo result = new ResultInfo();
  24.         ValueStruc v =  DataObserver.getInstance().regester(key, value, timeout);
  25.         if(v == null){
  26.             result.setStateId(-1);
  27.             result.setErrorMsg("插入失败");
  28.         } else {
  29.             result.addObj2Map("value", v);
  30.         }
  31.         return result;
  32.     }
  34.     @ResponseBody
  35.     @RequestMapping(value = "update/{key}/{value}", method = RequestMethod.GET)
  36.     public ResultInfo update(HttpServletRequest request, @PathVariable("key") String key, @PathVariable("value") String value){
  37.         ResultInfo result = new ResultInfo();
  38.         ValueStruc v =  DataObserver.getInstance().update(key, value);
  39.         if(v == null){
  40.             result.setStateId(-1);
  41.             result.setErrorMsg("更新失败");
  42.         } else {
  43.             result.addObj2Map("value", v);
  44.         }
  45.         return result;
  46.     }
  48.     @ResponseBody
  49.     @RequestMapping(value="remove/{key}", method = RequestMethod.GET)
  50.     public ResultInfo clear(HttpServletRequest request, @PathVariable("key") String key){
  51.         ResultInfo result = new ResultInfo();
  52.         ValueStruc v = DataObserver.getInstance().remove(key);
  53.         result.addObj2Map("value", v);
  54.         return result;
  55.     }
  57.     @ResponseBody
  58.     @RequestMapping(value = "clear", method = RequestMethod.GET)
  59.     public void clear(){
  60.         DataObserver.getInstance().clear();
  61.     }
  63. }

前端js实现

以通过接口调用服务器执行ping命令，并监听ping的结果为例，js代码如下（以下结合AngularJs，其他脚本亦类似）：

第一步：调用异步服务并获取监听ID

通过约定，在调用异步任务发起后返回注册的监听ID。

  1. //调用服务
  2. this.ping = function($scope){ 
  3.         var url = ctx + 'godmode/ping';
  4.         var data = {
  5.             ip : $scope.pingIP
  6.         };
  7.         $.ajax({
  8.             type:"post",
  9.             url:url,
  10.             async:false,
  11.             data :data,
  12.             success: function(r){ 
  13.                 console.log(r);
  14.                 $scope.observerID = r.map.observerID[0];
  15.             },
  16.             error:function(){ 
  17.                 $interva
  18.             }
  19.         });
  20.     }

第二步：监听ID数据

  1. //定时调用监听
  2.     var timer = $interval(function(){ 
  3.         myService.observePing($scope,$interval);
  4.     },1000);
  6.     //监听服务
  7.     this.observePing = function($scope,$interval){ 
  8.         console.log('observing:'+$scope.observerID);
  9.         $.ajax({
  10.                 type : "get",
  11.                 url: ctx + "api/observer/observe/"+$scope.observerID,
  12.                 dataType: "json",
  13.                 async: true,
  14.                 timeout: 10000,
  15.                 error: function(r) { 
  16.                     console.log('canceling observer');
  17.                     $interval.cancel(timer);
  18.                 },
  19.                 success: function(r) { 
  20.                     if (r.stateId == 0) {
  21.                         var text = "";
  22.                         $.each(r.map.value[0], function(index, item) { 
  23.                             text = text + item + "\n";
  24.                         });
  25.                         $scope.pingResults = text;
  26.                     } else {
  27.                         //监听资源释放后，停止interval
  28.                         console.log('canceling observer');
  29.                         $interval.cancel(timer);
  30.                     }
  31.                 }
  32.             });
  33.     }

发表评论

表情：
评论列表 （有 0 条评论，293人围观）

还没有评论，来说两句吧...

相关阅读

    相关 ajax异步下载文件并判断状态

    今日需要对公司的代码进行更新，发现之前有的文件丢失导致下载不到直接跳转到一个空的页面，第一反应是应该没有用异步请求，直接用a标签或者表单之类的处理下载文件请求了。 但是...

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 586 阅读