Question

我正在使用Grails应用程序进行开发。我想要做的是锁定请求/响应，创建一个承诺，让其他人解决它，这是代码中的其他地方，然后然后刷新响应。

我觉得奇怪的是Promise promise = task {}接口没有类似于resolve或类似的方法。

我需要锁定响应，直到有人解析了promise，这是在开发模式下设置的全局/静态属性。

承诺界面： http://grails.org/doc/latest/api/grails/async/Promise.html

我查看了GPars文档，找不到任何类似解决方法的内容。

如何创建一个承诺，锁定响应或请求，然后在有人解析响应时刷新响应？

Answer 1

你可以在承诺上调用get()，直到任务正在完成，但我想象那不是你想要的。您想要的似乎等同于GPars DataflowVariable：

http://gpars.org/1.0.0/javadoc/groovyx/gpars/dataflow/DataflowVariable.html

允许使用左移位运算符来解析另一个线程的值。目前没有办法直接通过Grails使用左移操作符，但是自Grails＆＃39; promise API只是GPars上的一个层，这可以通过直接使用GPars API来完成，例如：

 import org.grails.async.factory.gpars.*
 import groovyx.gpars.dataflow.*
 import static grails.async.Promise.*

 def myAction() {
    def dataflowVar = new DataflowVariable()
    task {
       // do some calculation and resolve data flow variable
       def expensiveData = ...
       dataflowVar << expensiveData
    }
    return new GParsPromise(dataflowVar)        
 }

Answer 2

我花了很长时间才能解决这个问题并得到一个有效的答案。

我必须说，Grails似乎还有很长的路要走。

任务{}

将始终立即执行，因此在dispatch（）或任何被调用的问题之前，调用不会被暂停。

试试看：

    public def test() {
            def dataflowVar = new groovyx.gpars.dataflow.DataflowVariable()

            task {
                    // do some calculation and resolve data flow variable
                    println '1111111111111111111111111111111111111111111111111111'
                    //dataflowVar << expensiveData
            }

            return new org.grails.async.factory.gpars.GparsPromise(dataflowVar);
    }

如果您想知道这是为了什么，那就是在grails中自动刷新lesscss，这在使用less语句时会出现问题。触摸文件时，lesscss编译器将触发重新编译，并且只有在完成后才应该响应客户端。

在客户端，我有一些javascript，一直使用刷新操作替换最后一个：

在我的控制器中：

    /**
     * Refreshes link resources. refresh?uri=/resource/in/web-app/such/as/empty.less
     */
    public def refresh() {
            return LessRefresh.stackRequest(request, params.uri);
    }

为此写的课程：

import grails.util.Environment
import grails.util.Holders

import javax.servlet.AsyncContext
import javax.servlet.AsyncEvent
import javax.servlet.AsyncListener
import javax.servlet.http.HttpServletRequest

/**
 * @Author SecretService
 */
class LessRefresh {
        static final Map<String, LessRefresh> FILES = new LinkedHashMap<String, LessRefresh>();

        String file;
        Boolean touched
        List<AsyncContext> asyncContexts = new ArrayList<AsyncContext>();
        String text;

        public LessRefresh(String file) {
                this.file = file;
        }

        /** Each request will be put on hold in a stack until dispatchAll below is called when the recompilation of the less file finished **/
        public static AsyncContext stackRequest(HttpServletRequest request, String file) {
                if ( !LessRefresh.FILES[file] ) {
                        LessRefresh.FILES[file] = new LessRefresh(file);
                }

                return LessRefresh.FILES[file].handleRequest(request);
        }

        public AsyncContext handleRequest(HttpServletRequest request) {
                if ( Environment.current == Environment.DEVELOPMENT ) {

                        // We only touch it once since we are still waiting for the less compiler to finish from previous edits and recompilation
                        if ( !touched ) {
                                touched = true
                                touchFile(file);
                        }

                        AsyncContext asyncContext = request.startAsync();

                        asyncContext.setTimeout(10000)

                        asyncContexts.add (asyncContext);

                        asyncContext.addListener(new AsyncListener() {

                                @Override
                                void onComplete(AsyncEvent event) throws IOException {
                                        event.getSuppliedResponse().writer << text;
                                }

                                @Override
                                void onTimeout(AsyncEvent event) throws IOException {

                                }

                                @Override
                                void onError(AsyncEvent event) throws IOException {

                                }

                                @Override
                                void onStartAsync(AsyncEvent event) throws IOException {

                                }
                        });

                        return asyncContext;
                }

                return null;
        }

        /** When recompilation is done, dispatchAll is called from LesscssResourceMapper.groovy **/
        public void dispatchAll(String text) {
                this.text = text;

                if ( asyncContexts ) {

                        // Process all
                        while ( asyncContexts.size() ) {

                                AsyncContext asyncContext = asyncContexts.remove(0);

                                asyncContext.dispatch();
                        }

                }

                touched = false;
        }

        /** A touch of the lessfile will trigger a recompilation **/
        int count = 0;
        void touchFile(String uri) {
                if ( Environment.current == Environment.DEVELOPMENT ) {
                        File file = getWebappFile(uri);

                        if (file && file.exists() ) {
                                ++count;

                                if ( count < 5000 ) {
                                        file << ' ';
                                }
                                else {
                                        count = 0

                                        file.write( file.getText().trim() )
                                }
                        }
                }
        }

        static File getWebappFile(String uri) {
                new File( Holders.getServletContext().getRealPath( uri ) )
        }

}

在lesscsss-recources插件的LesscssResourceMapper.groovy中：

    ...
    try {
            lessCompiler.compile input, target
            // Update mapping entry
            // We need to reference the new css file from now on
            resource.processedFile = target
            // Not sure if i really need these
            resource.sourceUrlExtension = 'css'
            resource.contentType = 'text/css'
            resource.tagAttributes?.rel = 'stylesheet'

            resource.updateActualUrlFromProcessedFile()

            // ==========================================
            // Call made here!
            // ==========================================
            LessRefresh.FILES[resource.sourceUrl.toString()]?.dispatchAll( target.getText() );

    } catch (LessException e) {
            log.error("error compiling less file: ${originalFile}", e)
    }
    ...

在index.gsp文件中：

<g:set var="uri" value="${"${App.files.root}App/styles/empty.less"}"/>
<link media="screen, projection" rel="stylesheet" type="text/css" href="${r.resource(uri:uri)}" refresh="${g.createLink(controller:'home', action:'refresh', params:[uri:uri])}" resource="true">

JavaScript方法refreshResources替换上一个链接href = ...

    /**
     * Should only be used in development mode
     */
    function refreshResources(o) {
            o || (o = {});

            var timeoutBegin      = o.timeoutBegin      || 1000;
            var intervalRefresh   = o.intervalRefresh   || 1000;
            var timeoutBlinkAvoid = o.timeoutBlinkAvoid || 400 ;
            var maxErrors         = o.maxErrors         || 200 ;

            var xpath = 'link[resource][type="text/css"]';

            // Find all link[resource]
            $(xpath).each(function(i, element) {
                    refresh( $(element) );
            });

            function refresh(element) {

                    var parent     = element.parent();
                    var next       = element.next();
                    var outer      = element.clone().attr('href', '').wrap('<p>').parent().html();
                    var uri        = element.attr('refresh');
                    var errorCount = 0;

                    function replaceLink() {
                            var link = $(outer);

                            link.load(function () {
                                    // The link has been successfully added! Now remove the other ones, then do again

                                    errorCount = 0;

                                    // setTimeout needed to avoid blinking, we allow duplicates for a few milliseconds
                                    setTimeout(function() {
                                            var links = parent.find(xpath + '[refresh="'+uri+'"]');

                                            var i = 0;
                                            // Remove all but this one
                                            while ( i < links.length - 1 ) {
                                                    links[i++].remove();
                                            }

                                            replaceLinkTimeout();

                                    }, timeoutBlinkAvoid );

                            });

                            link.error(function(event, handler) {
                                    console.log('Error refreshing: ' + outer );

                                    ++errorCount;

                                    if ( errorCount < maxErrors ) {
                                            // Load error, it happens. Remove this & redo!
                                            link.remove();

                                            replaceLink();
                                    }
                                    else {
                                            console.log('Refresh: Aborting!')
                                    }

                            });

                            link.attr('href', urlRandom(uri)).get(0);
                            link.insertBefore(next); // Insert just after
                    }

                    function urlRandom(uri) {
                            return uri + "&rand=" + Math.random();
                    }

                    function replaceLinkTimeout() {
                            setTimeout(function() {
                                    replaceLink();
                            }, intervalRefresh ) ;

                    }

                    // Waith 1s before triggering the interval
                    setTimeout(function() {
                            replaceLinkTimeout();
                    }, timeoutBegin);
            }

    };

<强>评论

我不确定为什么Javascript 样式承诺尚未添加到 Grails堆栈。您无法在onComplete中渲染或填充此类内容。渲染，重定向和不可用的东西。

有些东西告诉我，Grails和Promises / Futures还没有。 GPars库的设计似乎没有考虑到以后要解决的核心功能。至少这样做并不简单。

如果dispatch（）方法实际上可以调用一些参数来从解析上下文传递，那将是很好的。我可以使用静态属性来解决这个问题。

我可能会继续编写自己的解决方案，并可能围绕AsyncContext类提供更合适的解决方案，但就目前而言，这对我来说已经足够了。

我只是想自动刷新我的资源。

...呼

编辑：

我支持多个文件。现在已经完成了！

Groovy / Grails承诺/期货。没有.resolve（1,2,3）方法。奇怪？

2 个答案: