关于在 Grails 中进行异步处理的简单方法的建议

Question

假设我有一个像这样的简单控制器：

class FooController {

  def index = {
     someVeryLongCompution() //e.g crawl a set of web pages
     render "Long computation was launched."
  }
}

当调用索引操作时，我希望该方法立即返回给用户，同时异步运行长计算。

我知道最可靠的方法是在架构中使用消息代理，但我想知道是否有更简单的方法。

我尝试了 Executor 插件，但是它会阻止 http 请求返回，直到长计算完成为止。

我尝试了 Quartz 插件，但这似乎对于周期性任务很有用（除非有办法只运行一次作业？）

你们是如何在 Grails 中处理此类请求的？

Answer 1

您想在同一个 Grails 服务器上还是不同的服务器上处理veryLongComputation()？

如果是同一台服务器，则不需要 JMS，另一种选择是创建一个新线程并异步处理计算。

def index = {
     def asyncProcess = new Thread({
          someVeryLongComputation()
     } as Runnable )
     asyncProcess.start()

     render "Long computation was launched."
  }

Answer 2

如果您在 Grails Quartz 中使用简单触发器并将重复计数设置为 0，则作业将仅运行一次。但是，它与用户请求分开运行，因此您需要找到某种方式在完成后与用户进行通信。

Answer 3

我知道这是一个非常老的问题，只是想给出更新的答案。

从 grails 2.3 开始，框架支持使用 Servlet 3.0 异步请求处理的异步调用（当然，必须使用 servlet 3.0 容器，并且配置中的 servlet 版本应为 3.0，默认情况下）

它记录在此处：http://grails.org/doc/latest/guide/async.html

一般情况，有两种方法可以实现您的要求：

import static grails.async.Promises.*
   def index() {
      tasks books: Book.async.list(),
            totalBooks: Book.async.count(),
            otherValue: {
              // do hard work
            }
   }

或 Servlet 异步方法：

def index() {
    def ctx = startAsync()
    ctx.start {
        new Book(title:"The Stand").save()
        render template:"books", model:[books:Book.list()]
        ctx.complete()
    }
}

小注释 - grails 方法使用 Promise，这是一个重大的（异步）飞跃。任何 Promise 都可以链接到进一步的 Promise，对成功和失败进行回调等。

Answer 4

您是否尝试过 Grails Promisses API？它应该像这样简单

import static grails.async.Promise
import static grails.async.Promises

class FooController {

  def index = {
     Promise p = Promises.task {
         someVeryLongCompution() //e.g crawl a set of web pages
     }
     render "Long computation was launched."
  }
}

Answer 5

尝试 Spring 事件插件 - 它支持异步事件侦听器。

Answer 6

如果您想使用 Quartz 插件（就像我们一直做的那样），您可以这样做。它对我们来说效果很好：

DEFINE A JOB（没有定时触发器）

static triggers =  {
    simple name:'simpleTrigger', startDelay:0, repeatInterval: 0, repeatCount: 0
}

CALL.triggerNow()以异步模式手动执行作业。

MyJob.triggerNow([key1:value1, key2: value2]); 

专业提示 #1

要从另一端获取命名参数...

def execute(context) {
    def value1 = context.mergedJobDataMap.get('key1');
    def value2 = context.mergedJobDataMap.get('key2');
    ...
    if (value1 && value2) {
      // This was called by triggerNow(). We know this because we received the parameters.
    } else {
      // This was called when the application started up. There are no parameters. 
    }
}

专业提示 #2

执行方法总是在应用程序启动时被调用，但是命名参数参数为空。

文档： http://grails.org/version/Quartz%20plugin/24 #Dynamic%20Jobs%20Scheduling

Answer 7

解决此类问题的最佳解决方案是通过 JMS 插件 使用 JMS。

对于更简单的实现，不需要外部服务器/服务，您可以尝试 Spring Events 插件。

Answer 8

Grails 2.2.1 解决方案 我有一个额外的要求，即报告完成后必须自动弹出一个窗口。所以我选择了上面的 servlet 方式。我用 json 格式的字符串替换了渲染视图，返回它看起来像这样。
另外，我的客户端不是 gsp 视图，而是 ExtJS 4.1.1（HTML5 产品）

enter code here
def index() {
    def ctx = startAsync() 
    ctx.start ({

        Map retVar = [reportId: reportId, success: success];
        String jsonString = retVar as JSON;

        log.info("generateTwoDateParamReport before the render out String is: " + jsonString);

        ctx.getOriginalWebRequest().getCurrentResponse().setContentType("text/html");
        ctx.getOriginalWebRequest().getCurrentResponse().setCharacterEncoding("UTF-8");
        log.info("current contentType is: "ctx.getOriginalWebRequest().getCurrentResponse().contentType);
        try {
           ctx.getOriginalWebRequest().getCurrentResponse().getWriter().write(jsonString);
           ctx.getOriginalWebRequest().getCurrentResponse().getWriter().flush();
           ctx.getOriginalWebRequest().getCurrentResponse().setStatus(HttpServletResponse.SC_OK);
        }
        catch (IOException ioe)
        {
            log.error("generateTwoDateParamReport flush data to client failed.");
        }
        ctx.complete();
        log.info("generateNoUserParamsReport after complete");
    });
}