自定义基座实时采集uniapp日志

自定义基座实时采集uniapp日志

打测试包给远端现场(测试/客户)实际测试时也能实时看到日志了，也有代码行数显示。

流程设计

uniapp收集代码

重写console方法

通过条件编译，在app使用环境重写日志打印方法

 // #ifdef APP-PLUS=function(...args){
 console.log = function (...args) {
     try {
         _this.$plugins.getUtils("consoleLog", {'level': 'log', 'args': args})
     } catch (e) {
         console.info('console.log 打印失败', e);
     }
 }
 console.error = function (...args) {
     try {
         _this.$plugins.getUtils("consoleLog", {'level': 'error', 'args': args})
     } catch (e) {
         console.info('console.error 打印失败', e);
     }
 }
 console.warn = function (...args) {
     try {
         _this.$plugins.getUtils("consoleLog", {'level': 'warn', 'args': args})
     } catch (e) {
         console.info('console.warn 打印失败', e);
     }
 }
 // #endif

发送给安卓层

/**
 * 快捷调用安卓工具类方法
 * this.$plugins.getUtils('method',{userId:'test'})
 * @param {Object} method
 * @param {Object} jsonObject
 * @param {Object} successCallback
 * @param {Object} errorCallback
 * @return {String} 原始字符串，如果是json化返回的就是一个json字符串 不是对象!!!
 */
getUtils: function(method, jsonObject, successCallback, errorCallback) {
	try {
		var success = typeof successCallback !== 'function' ? null : function(args) {
				successCallback(args);
			},
			fail = typeof errorCallback !== 'function' ? null : function(code) {
				errorCallback(code);
			};
		var callbackID = plus.bridge.callbackId(success, fail);
		return plus.bridge.exec(_BARCODE, "getUtils", [callbackID, method, jsonObject]);
	} catch (e) {
		console.error(e)
		errorCallback(e)
	}

},

//初始化方法，一般是登录后调用
_this.$plugins.getUtils("initConsoleLog", {'userId': _this.GLOBAL.$USER_INFO.user_iidd})

安卓自定义基座收集日志

跳转方法

/**
  * 工具类获取
  *
  * @param pWebview
  * @param array
  * @return
  */
 public void getUtils(IWebview pWebview, JSONArray array) {
     Log.i("getUtils", "工具类获取" + array.toString());
     String result = null;
     String CallBackID = array.optString(0);
     try {
         //方法
         String method = array.optString(1);
         JSONObject json = new JSONObject(array.optString(2));
         result = this.utilMethood(method, json, pWebview);
     } catch (Exception e) {
         e.printStackTrace();
         JSUtil.execCallback(pWebview, CallBackID, e.getMessage(), JSUtil.ERROR, false);
     }
     Log.i("getUtils", "工具类返回信息:\n" + result);
     JSUtil.execCallback(pWebview, CallBackID, result, JSUtil.OK, true);
 }

初始化日志信息方法

/**
 * WebSocket调试信息推送客户端
 */
private PushConsoleWebSocketClient pushConsoleWebSocketClient = null;

/**
 * 初始化推送
 */
public static boolean pushLogInit = false;

/**
 * 调试日志地址
 */
public static String LOG_WS_URL = "ws://127.0.0.1:5080/weblog/uniapplogv2/";

/**
 * 调试id
 */
public static String LOG_WS_USERID = null;

/**
 * 初始化日志信息
 *
 * @param params
 * @param pWebview
 * @return
 */
private String initConsoleLog(JSONObject params, IWebview pWebview) {
    LOG_WS_USERID = params.optString("userId");
    Log.i(TAG, "uniapp层初始化日志信息: " + LOG_WS_USERID);
    if (null != LOG_WS_USERID && !"".equals(LOG_WS_USERID)) {
        try {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        pushConsoleWebSocketClient = PushConsoleWebSocketClient.builder(LOG_WS_URL, "系统名称", LOG_WS_USERID);
                        pushConsoleWebSocketClient.connect();
                        pushLogInit = true;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();

        } catch (Exception e) {
            Log.e(TAG, "initConsoleLog: 初始化调试信息推送服务异常", e);
        }
    }
    return ResultUtil.ok("日志初始化完毕");
}

推送日志调试信息方法

/**
 * 推送日志信息到调试页面
 *
 * @param log   日志内容
 * @param level 日志等级
 */
private void pushLogToCache(String level, JSONArray log) {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                com.alibaba.fastjson.JSONObject params = new com.alibaba.fastjson.JSONObject();
                params.put("code", "push");
                params.put("sys", pushConsoleWebSocketClient.getSys());
                params.put("userId", pushConsoleWebSocketClient.getUserId());
                params.put("level", level);
                params.put("timestamp", System.currentTimeMillis());
                params.put("time", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));
                try {
                    params.put("log", parseUniappConsoleLog(log));
                } catch (Exception e) {
                    params.put("log", log);
                }
                pushConsoleWebSocketClient.send(params.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    thread.start();
//        executorService.submit(thread);
}
   

安装自定义基座

安卓WebSocket客户端

安卓WebSocket客户端推送负责将调试日志推送给后端

gradle依赖

//WebSocket连接
implementation 'org.java-websocket:Java-WebSocket:1.5.3'

import android.util.Log;

import com.inspur.mobilefsp.plugins.WfmPlugin;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.JSONObject;

import java.net.URI;
import java.net.URISyntaxException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.Charset;

/**
 * WebSocket客户端类，用于与服务器建立WebSocket连接并处理消息。
 * 该类实现了WebSocketClient接口，并提供了连接、消息处理和错误处理的功能。
 *
 * @author 淡梦如烟
 * @date 20250211
 */
public class PushConsoleWebSocketClient extends WebSocketClient {

    /**
     * 日志标签，用于标识日志输出的来源
     */
    public final static String TAG = "PushLogClient";

    /**
     * WebSocket服务器的URL
     */
    private String url;

    /**
     * 系统名称
     */
    private String sys;

    /**
     * 用户ID
     */
    private String userId;

    /**
     * 构造函数，初始化WebSocket客户端
     *
     * @param serverUrl WebSocket服务器的URL
     * @param sys       系统名称
     * @param userId    用户ID
     * @throws URISyntaxException 如果提供的URL格式不正确
     */
    public PushConsoleWebSocketClient(String serverUrl, String urlParams, String sys, String userId) throws URISyntaxException {
        super(new URI(serverUrl + urlParams));
        this.url = serverUrl;
        this.sys = sys;
        this.userId = userId;
    }

    /**
     * 建造者生成客户端
     *
     * @param serverUrl
     * @param sys
     * @param userId
     * @return
     */
    public static PushConsoleWebSocketClient builder(String serverUrl, String sys, String userId) {
        try {
        	//自定义参数，自行实现
            JSONObject json = new JSONObject();
            json.put("code", "pushStart");
            json.put("userId", userId);
            json.put("sys", sys);
            JSONObject password = new JSONObject();
            password.put("userId", userId);
            password.put("timestamp", System.currentTimeMillis());
            //aes加密 ，自行实现或者用第三方包
            String encode = QEncodeUtil.aesEncrypt(json.toString(), "aes秘钥2");
            encode = URLEncoder.encode(encode, "UTF-8");
            //百分号不能作为参数
            encode = encode.replaceAll("%", "BaiFenHao");
            String url = serverUrl + encode;
            Log.e(TAG, "builder: websocket地址:" + url);
            PushConsoleWebSocketClient pushConsoleWebSocketClient = new PushConsoleWebSocketClient(serverUrl, encode, sys, userId);
            return pushConsoleWebSocketClient;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取WebSocket服务器的URL
     *
     * @return WebSocket服务器的URL
     */
    public String getUrl() {
        return url;
    }

    /**
     * 获取系统名称
     *
     * @return 系统名称
     */
    public String getSys() {
        return sys;
    }

    /**
     * 获取用户ID
     *
     * @return 用户ID
     */
    public String getUserId() {
        return userId;
    }

    /**
     * 当WebSocket连接成功建立时调用
     *
     * @param handshake 握手信息
     */
    @Override
    public void onOpen(ServerHandshake handshake) {
        // WebSocket连接已成功建立
        // 在此执行任何必要的操作
        Log.i(TAG, "onOpen: " + handshake.getHttpStatus());
        WfmPlugin.pushLogInit = true;
    }

    /**
     * 当接收到来自服务器的消息时调用
     *
     * @param message 收到的消息内容
     */
    @Override
    public void onMessage(String message) {
        // 处理来自服务器的传入消息
        Log.i(TAG, "onMessage: " + message);
    }

    /**
     * 当WebSocket连接关闭时调用
     *
     * @param code   关闭状态码
     * @param reason 关闭原因
     * @param remote 是否由远程服务器关闭
     */
    @Override
    public void onClose(int code, String reason, boolean remote) {
        Log.e(TAG, "onClose: code[" + code + "];remote[" + remote + "];url[" + this.url + "];reason:" + reason);
        // WebSocket连接已关闭
        // 在此执行任何必要的清理操作
//        this.reconnectAfterMillis(100L);
    }

    /**
     * 重连锁
     */
    private static boolean reConnectLock = false;

    /**
     * 延迟重连
     *
     * @param millis
     */
    public void reconnectAfterMillis(Long millis) {
        try {
            if (reConnectLock) {
                return;
            }
            reConnectLock = true;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 尝试在5秒后重新连接
                        Thread.sleep(millis);
                        reconnect();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        reConnectLock = false;
                    }
                }
            }).start();
        } catch (Exception e) {
            e.printStackTrace();
            reConnectLock = false;
        } finally {
        }

    }

    /**
     * 当WebSocket连接期间发生错误时调用
     *
     * @param ex 发生的异常
     */
    @Override
    public void onError(Exception ex) {
        Log.e(TAG, "onError: ", ex);
        // 处理WebSocket连接期间发生的任何错误
//        this.reconnectAfterMillis(5000L);
    }
}

后台代码

springboot接受日志和推送日志

package com.faker.weblog.websocket;

import cn.hutool.core.net.URLDecoder;
import com.alibaba.fastjson2.JSONObject;
import com.faker.weblog.model.dto.PushUniappLogDto;
import com.faker.weblog.util.Toolkit;
import com.faker.weblog.wrapper.WrapMapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModelProperty;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

@Lazy
@Component
@Slf4j
@ServerEndpoint("/uniapplogv2/{id}")
@Api(value = "websocket日志接受和推送uniapp日志工具")
public class UniappLogWebHandleV2 {
    @ApiModelProperty(value = "客户端id")
    private String id;

    @ApiModelProperty(value = "是否初始化", example = "true")
    private boolean initialized = false;

    @ApiModelProperty(value = "是否接受日志消息", example = "true")
    private boolean isPullLogs = false;

    @ApiModelProperty(value = "系统名称", example = "fakerSys")
    private String sys;

    @ApiModelProperty(value = "用户id", example = "test")
    private String userId;

    /**
     * 日志列表
     */
    private static ConcurrentHashMap<String, ConcurrentHashMap<String, List<String>>> logListMap = new ConcurrentHashMap<>();

    /**
     * 获取日志列表
     *
     * @return
     */
    public ConcurrentHashMap<String, ConcurrentHashMap<String, List<String>>> getlogListMap() {
        return logListMap;
    }

    /**
     * 清理日志列表
     */
    public static void cleanLogListMap() {
        logListMap.clear();
    }

    /**
     * concurrent包的线程安全Map，用来存放每个客户端对应的MyWebSocket对象。
     */
    private static ConcurrentHashMap<String, UniappLogWebHandleV2> webSocketMap = new ConcurrentHashMap<String, UniappLogWebHandleV2>();

    /**
     * websocket的session
     */
    private Session session;

    /**
     * 获取session
     *
     * @return
     */
    public Session getSession() {
        return this.session;
    }

    /**
     * 新的WebSocket请求开启
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("id") String id) {
        log.info("新的WebSocket请求开启:" + id);
        try {
            String decode = id.replaceAll("BaiFenHao", "%");
            decode = URLDecoder.decode(decode, Charset.forName("UTF-8"));
            String aesJson = com.faker.dba.util.QEncodeUtil.aesDecrypt(decode, "aes秘钥2");
            JSONObject jsonObject = JSONObject.parseObject(aesJson);
            String userId = jsonObject.getString("userId");
            String password = jsonObject.getString("password");
            String sign = jsonObject.getString("sign");
            if (jsonObject.get("isPullLogs") != null) {
                this.isPullLogs = jsonObject.getBoolean("isPullLogs");
            }
            this.sys = jsonObject.getString("sys");
            this.userId = userId;
            this.session = session;
			
			//鉴权方法，自行实现
            this.validate(userId, sign, password);

            this.id = id;
            webSocketMap.put(id, this);

            String code = jsonObject.getString("code");
            if ("pushStart".equalsIgnoreCase(code)) {
            	//app推送方法
                if (thisLististMap == null) {
                    thisLististMap = new ConcurrentHashMap<>();
                    logListMap.put(this.sys, thisLististMap);
                }
                List<String> logList = thisLististMap.get(this.userId);
                if (logList == null) {
                    logList = new ArrayList<>();
                    thisLististMap.put(this.userId, logList);
                }
            } else if ("webStart".equalsIgnoreCase(code)) {
                //pc端查看日志方法
                this.isPullLogs = true;
                this.sys = jsonObject.getString("watchSys");
                this.userId = jsonObject.getString("watchUserId");

                ConcurrentHashMap<String, List<String>> thisLististMap = logListMap.get(this.sys);
                if (thisLististMap != null) {
                    List<String> logList = thisLististMap.get(this.userId);
                    if (logList != null) {
                        for (String log : logList) {
                            try {
                                session.getBasicRemote().sendText(log);
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("鉴权错误:" + id, e);
        }
    }


    /**
     * WebSocket 请求关闭
     */
    @OnClose
    public void onClose() {
        // 从set中删除
        log.info("WebSocket请求关闭:" + id);
        webSocketMap.remove(id);
    }

    /**
     * 发生异常
     */
    @OnError
    public void onErro(Throwable throwable) {
        throwable.printStackTrace();
    }


    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session) throws IOException {
        log.debug("websocket来自客户端的消息:{}", message);
        JSONObject jsonObject = JSONObject.parseObject(message);
        String code = jsonObject.getString("code");
        if (this.initialized) {
            if ("push".equalsIgnoreCase(code)) {
                PushUniappLogDto params = JSONObject.parseObject(message, PushUniappLogDto.class);
                if (Toolkit.isNullOrEmpty(params.getSys())) {
                    log.warn("系统名称不能为空");
                    return;
                }
                if (Toolkit.isNullOrEmpty(params.getUserId())) {
                    log.warn("用户id不能为空");
                    return;
                }
                if (Toolkit.isNullOrEmpty(params.getLevel())) {
                    log.warn("日志等级不能为空");
                    return;
                }
                if (Toolkit.isNullOrEmpty(params.getLog()) || "[]".equals(params.getLog())) {
                    log.warn("日志信息不能为空");
                    return;
                }
                this.sendLogs(JSONObject.toJSONString(params));
            }
        } else {
            log.warn("[" + this.sys + "][" + this.userId + "]未初始化" + this.initialized);
        }
    }

    /**
     * token鉴权
     *
     * @param userId
     * @param sign
     * @param password
     * @throws IOException
     */
    public void validate(String userId, String sign, String password) throws IOException {
        if (Toolkit.isNotNull(userId) && Toolkit.isNotNull(sign)) {
            //校验userId和密码 这里简化为校验userId和时间戳的aes加密信息，校验通过初始化连接
            try {
                String aesJson = com.faker.dba.util.QEncodeUtil.aesDecrypt(sign, "aes秘钥1");
                JSONObject aesJsonObject = JSONObject.parseObject(aesJson);
                if (aesJsonObject.get("userId") == null || aesJsonObject.get("timestamp") == null) {
                    session.getBasicRemote().sendText("加密信息校验错误，已记录!" + "<br>" + aesJson + "<br>");
                    session.close();
                }
                if (userId.equals(aesJsonObject.getString("userId"))) {
                    if (aesJsonObject.getLong("timestamp") > System.currentTimeMillis() - 1000 * 60 * 5
                            || aesJsonObject.getLong("timestamp") < System.currentTimeMillis() + 1000 * 60 * 5) {
                        this.initialized = true;
                        session.getBasicRemote().sendText(JSONObject.toJSONString(WrapMapper.ok("签名[" + sign + "]正确，已记录!")));
                    } else {
                        session.getBasicRemote().sendText(JSONObject.toJSONString(WrapMapper.error("签名[" + sign + "]已过期，已记录!")));
                        session.close();
                    }

                } else {
                    session.getBasicRemote().sendText(JSONObject.toJSONString(WrapMapper.error("签名[" + sign + "]错误，已记录!")));
                    session.close();
                }
            } catch (Exception e) {
                log.error("加密信息[" + password + "]校验错误", e);
                session.getBasicRemote().sendText(JSONObject.toJSONString(WrapMapper.error("加密信息校验错误，已记录!" + "<br>" + e.getMessage())));
                session.close();
            }
        } else if (Toolkit.isNotNull(userId) && Toolkit.isNotNull(password)) {
            //todo 校验登录密码

        } else {
            log.error("登录信息错误[" + userId + "][" + password + "][" + sign + "]");
            session.getBasicRemote().sendText(JSONObject.toJSONString(WrapMapper.error("登录信息错误，已记录!")));
            session.close();
        }
    }

    /**
     * 向客户端发送消息
     *
     * @param message
     */
    public void sendLogs(String message) {
        ConcurrentHashMap<String, List<String>> thisLististMap = logListMap.get(this.sys);
        if (thisLististMap == null) {
            thisLististMap = new ConcurrentHashMap<>();
        }
        List<String> logList = thisLististMap.get(this.userId);
        if (logList == null) {
            logList = new ArrayList<>();
        }
        logList.add(message);
        //日志暂存最新的100条
        if (logList.size() > 100) {
            logList.remove(0);
        }
        this.sendToUser(message);
    }

    /**
     * 向指定客户端发送消息
     *
     * @param message
     */
    private void sendToUser(String message) {
        for (UniappLogWebHandleV2 webSocket : webSocketMap.values()) {
            if (webSocket.isInitialized() && webSocket.isPullLogs() && webSocket.getSys().equals(this.sys) && webSocket.getUserId().equals(this.userId)) {
                log.debug("【websocket消息】广播消息, message={}", message);
                try {
                    Session session = webSocket.getSession();
                    session.getBasicRemote().sendText(message);
                } catch (Exception e) {
                    log.error("【websocket消息】广播消息, message={}", message);
                }
            }
        }
    }

    /**
     * 向所有客户端发送消息
     *
     * @param message
     */
    public void sendToAll(String message) {
        for (UniappLogWebHandleV2 webSocket : webSocketMap.values()) {
            if (!webSocket.isInitialized()) {
                continue;
            }
            log.debug("【websocket消息】广播消息, message={}", message);
            try {
                Session session = webSocket.getSession();
                session.getBasicRemote().sendText(message);
            } catch (Exception e) {
                log.error("【websocket消息】广播消息, message={}", message);
            }
        }
    }

    public String getId() {
        return id;
    }

    public String getSys() {
        return sys;
    }

    public String getUserId() {
        return userId;
    }

    public boolean isInitialized() {
        return initialized;
    }

    public boolean isPullLogs() {
        return isPullLogs;
    }
}

html页面渲染日志

const id = JSON.stringify({
    code: 'webStart',
    userId: userToken.userId,
    sign: userToken.token,
    isPullLogs: true,
    watchSys: $('#sys').val(),
    watchUserId: $('#userId').val()
})
//aes加密
const aes = aesEncrypt(id)
//替换百分号
const url = encodeURIComponent(aes).replaceAll('%', 'BaiFenHao')
console.log('[信息]传输协议秘钥', id, aes, url)
// 指定websocket路径
var wsUrl = 'ws://' + location.host + '/weblog/uniapplogv2/' + url;

try {
    if (null != websocket && undefined != websocket) {
        websocket.close();
    }
} catch (e) {
    console.warn(e)
}
websocket = new WebSocket(wsUrl);
websocket.onmessage = function (event) {
    // 接收服务端的实时日志并添加到HTML页面中
    $("#log-container div").append(showColorLog(event.data));
    $("#log-container div").append('<br/>')
    if (localStorage.autoJump == '是') {
        // 滚动条滚动到最低部
        $("#log-container").scrollTop($("#log-container div").height() - $("#log-container").height());
    }
};
websocket.onopen = function (event) {
    reloadLock = false;
}

websocket.onerror = function (error) {
    console.log('onerror', error)
    // $("#log-container div").append('<br/><br/>连接已断开...    5秒后尝试重新连接........ <br/><br/>');
    // setTimeout(reloadWebSocket(), 5000)
}
websocket.onclose = function (event) {
    console.log('onclose', event)
    $("#log-container div").append('<br/><br/>连接已关闭...    5秒后尝试重新连接........ <br/><br/>');
    setTimeout(reloadWebSocket, 5000)
}

总结

给远程调试提供方便，websocket推送消耗较少，也是有序推送，完善好重连机制比post提交更方便查看。