输出堆栈流程到前端页面

获取消息

success: function (taskId) {
            getMessage(taskId, function () {
                document.getElementById("download-iframe").src = "/patch/" + taskId + "/file";
            });
        },

递归调用，循环获取最新的消息堆栈

var isRun = false;

function getMessage(taskId, callback) {
    if (isRun) {
        return;
    }
    isRun = true;
    $("#continue").fadeOut();
    getMessageIfNotComplete(taskId, callback);

}

function getMessageIfNotComplete(taskId, callback) {
    try {
        setTimeout(function () {
            $.ajax("/message/" + taskId, {
                type: 'get',
                dataType: 'text',
                success: function (message) {
                    if (message === 'EOF') {
                        isRun = false;
                        callback && callback();
                        $("#continue").fadeIn();
                        return;
                    }
                    printMessage(message);
                    getMessageIfNotComplete(taskId, callback);
                },
                error: function (response) {
                    printMessage(response.responseText);
                    isRun = false;
                }
            });
        }, 1000);
    } catch (e) {
        printMessage(e);
        isRun = false;
    }
}

后台代码

• controller

    /**
     * 获取任务消息
     *
     * @param taskId 任务ID
     * @return 消息
     */
    @GetMapping(value = "/message/{taskId}", produces = {"text/html;charset=UTF-8"})
    public ResponseEntity<String> getMessage(@PathVariable("taskId") String taskId) {
        final List<String> messageList = messageService.getMessage(taskId);
        if (CollectionUtils.isEmpty(messageList)) {
            return ResponseEntity.ok(StringUtils.EMPTY);
        }
        log.info(StringUtils.join(messageList, "\n"));

        return ResponseEntity.ok(StringUtils.join(messageList, "<br/>"));
    }

• service

package com.thunisoft.np.patch.service;

import com.thunisoft.np.patch.util.LockUtils;
import com.thunisoft.np.patch.util.SysUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * package com.thunisoft.np.patch.service <br/>
 * description: 执行命令，返回前端的，消息service <br/>
 * Copyright 2019, Inc. All rights reserved.
 *
 * @author fanzhongwei
 * @date 20-7-24
 */
@Service
@Slf4j
public class MessageService {
    /** 消息缓存 */
    private Map<String, List<String>> messageCache = new ConcurrentHashMap<>();
    /** 任务是否完成 */
    private Map<String, Boolean> taskCompletedMap = new ConcurrentHashMap<>();

    /**
     * 添加任务消息
     *
     * @param taskId 任务ID
     * @param message 消息
     */
    public void putMessage(String taskId, String message) {
        LockUtils.lock(taskId);
        try {
            messageCache.computeIfAbsent(taskId, key -> new ArrayList<>())
                .add(message);
        } finally {
            LockUtils.unlock(taskId);
        }
    }

    /**
     * 添加任务消息
     *
     * @param taskId  任务ID
     * @param message 消息
     */
    public void putMessage(String taskId, String message, Object... args) {
        putMessage(taskId, SysUtils.format(message, args));
    }

    /**
     * 添加任务消息
     *
     * @param taskId   任务ID
     * @param messages 消息
     */
    public void putMessage(String taskId, List<String> messages) {
        LockUtils.lock(taskId);
        try {
            messageCache.computeIfAbsent(taskId, key -> new ArrayList<>())
                .addAll(messages);
        } finally {
            LockUtils.unlock(taskId);
        }
    }

    /**
     * 获取任务消息
     *
     * @param taskId 任务ID
     * @return 消息
     */
    public List<String> getMessage(String taskId) {
        LockUtils.lock(taskId);
        try {
            List<String> messageList = messageCache.get(taskId);
            if (CollectionUtils.isEmpty(messageList)) {
                if (BooleanUtils.isTrue(taskCompletedMap.get(taskId))) {
                    return Collections.singletonList("EOF");
                }
                return Collections.emptyList();
            }

            List<String> result = Arrays.asList(messageList.toArray(new String[] {}));
            messageList.clear();
            return result;
        } finally {
            LockUtils.unlock(taskId);
        }
    }

    /**
     * 任务完成
     *
     * @param taskId 任务ID
     */
    public void complete(String taskId) {
        taskCompletedMap.put(taskId, true);
    }
}