websocket實現(xiàn)方法日志實時查詢過程

更新時間：2025年07月21日 15:02:29 作者：老葉童鞋

本文介紹了一種基于Redis生成唯一key的方案,前端傳遞key至服務器,服務器據此生成日志文件并通過WebSocket線程實時讀取返回內容,結合logback實現(xiàn)日志記錄與監(jiān)控

1、通過logback生成日志工具類

package utils;

import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
import ch.qos.logback.core.rolling.RollingFileAppender;
import ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy;
import ch.qos.logback.core.util.FileSize;
import ch.qos.logback.core.util.OptionHelper;
import cn.sunline.dds.common.framework.constants.SocketLog;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;

/**
 * 日志構建器
 * @author Mr.Ye
 * @Description: 該方法不會在控制臺打印日志，只用于生成指定文件的日志
 */
public class LoggerBuilder {  
  
    private static final Map<String,Logger> container = new HashMap<>();

    private static SocketLog socketLog;

    public static Logger getLogger(String key) {
        Logger logger = container.get(key);
        if(logger != null) {
            return logger;
        }
        synchronized (LoggerBuilder.class) {
            logger = container.get(key);
            if(logger != null) {
                return logger;
            }
            logger = build(key);
            container.put(key,logger);
        }
        return logger;
    }
    //刪除container中的log
    public static void close(String key) {
        if (container.containsKey(key)) {
            container.remove(key);
        }
    }
  
    private static Logger build(String key) {
        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();  
        Logger logger = context.getLogger("FILELOGGER");
        logger.setAdditive(false);  
        RollingFileAppender appender = new RollingFileAppender();  
        appender.setContext(context);  
        appender.setName("FILELOGGER");
        appender.setFile(OptionHelper.substVars("/logs/"+ key + ".log",context));
        appender.setAppend(true);  
        appender.setPrudent(false);
        //重命名日志文件
        SizeAndTimeBasedRollingPolicy policy = new SizeAndTimeBasedRollingPolicy();
        String fp = OptionHelper.substVars("/logs/" + key + ".log.%d{yyyy-MM-dd}.%i",context);
        policy.setMaxFileSize(FileSize.valueOf("128MB"));
        policy.setFileNamePattern(fp);
        policy.setMaxHistory(7);
        policy.setTotalSizeCap(FileSize.valueOf("32GB"));
        policy.setParent(appender);
        policy.setContext(context);
        policy.start();
  
        PatternLayoutEncoder encoder = new PatternLayoutEncoder();  
        encoder.setContext(context);  
        encoder.setPattern("%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n");
        encoder.start();  
  
        appender.setRollingPolicy(policy);  
        appender.setEncoder(encoder);  
        appender.start();  
        logger.addAppender(appender);  
        return logger;  
    }
}

2、構建websocket方法

package socket;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Data: 2022/04/22
 * @author Mr.Ye
 * @deprecated 由于讀寫文件占用資源較大，所以暫時不使用
 */
@ServerEndpoint("/log/{key}")
@Component
public class LogWebSocket {
    private final Logger logger = LoggerFactory.getLogger(LogWebSocket.class);

    /**
     * 記錄當前總共有多少個連接
     */
    private static final AtomicInteger ONLINE_COUNT = new AtomicInteger(0);
    /**
     * 項目路徑
     */
    private static final String PROPERTY = System.getProperty("user.dir");

    /**
     * 存放當前正在做靈活開發(fā)的session對象
     */
    private static final Map<String, Session> CLIENTS = new ConcurrentHashMap<>();

    /**
     * 新的WebSocket請求開啟
     * @describe 當前方法各系統(tǒng)通用，通過file獲取日志文件，linux下可以使用tail -f持續(xù)獲取日志文件更方便
     */
    @OnOpen
    public void onOpen(Session session,@PathParam("key")String key) {
        try {
            System.out.println("------------------key------------------:"+key);
            // 建立連接梳理 加 1
            ONLINE_COUNT.incrementAndGet();
            // 將當前創(chuàng)建的session 存儲起來
            CLIENTS.put(session.getId(), session);
            logger.info("有新窗口打開連接加入：{}，當前正在查詢總數為：{}", session.getId(), ONLINE_COUNT.get());
            String url = PROPERTY+ "/logs/"+key+".log";
            LogFileTailer tailer = new LogFileTailer(url);
            tailer.addListener(log -> {
                try {
//                    session.getBasicRemote().sendText(log + "<br />");
                    session.getBasicRemote().sendText(log);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            tailer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * WebSocket請求關閉
     */
    @OnClose
    public void onClose(Session session) {
        // 建立連接梳理 減 1
        ONLINE_COUNT.decrementAndGet();
        // 刪除緩存起來的session
        CLIENTS.remove(session.getId());
        logger.info("有一窗口連接關閉：{}，當前正在開發(fā)總數為：{}", session.getId(), ONLINE_COUNT.get());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        error.printStackTrace();
        // 建立連接梳理 減 1
        ONLINE_COUNT.decrementAndGet();
        // 刪除緩存起來的session
        CLIENTS.remove(session.getId());
        logger.error("發(fā)生錯誤，刪除當前session：{}，剩余正在總數為：{}", session.getId(), ONLINE_COUNT.get());
    }
}

3、日志監(jiān)聽獲取

package socket;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.function.Consumer;

/**
 * @Data: 2022/04/24
 * @author Mr.Ye
 * @deprecated 由于讀寫文件占用資源較大，所以暫時不使用
 */
public class LogFileTailer extends Thread {

	private File logfile;

	private Consumer<String> callback;

	/**
	 * 監(jiān)視開關，true = 打開監(jiān)視
	 */
	private boolean tailing = true;

	/**
	 * 
	 * @param file 要監(jiān)視的文本文件
	 */
	public LogFileTailer(String file) {
		logfile = new File(file);

	}

	/**
	 *Tailing 開關
	 * @param tailing
	 */
	public void Tailing(boolean tailing) {
		this.tailing = tailing;

	}

	/**
	 * 設置回調事件
	 * 
	 * @param callback 回調事件
	 */
	public void addListener(Consumer<String> callback) {
		this.callback = callback;
	}

	@Override
	public void run() {
		/*上一次讀取文件位置*/
		long filePointer =0;
		try {
			RandomAccessFile file  = new RandomAccessFile(logfile, "r");
			while (tailing) {
				long fileLength = logfile.length();
				if (fileLength < filePointer) {
					file = new RandomAccessFile(logfile, "r");
					filePointer = 0;
				}
				if (fileLength > filePointer) {
					file.seek(filePointer);
					String line = file.readLine();

					while (line != null) {
						line = new String(line.getBytes("ISO-8859-1"), "utf-8");
						if (callback != null){
							callback.accept(line);
						}
						line = file.readLine();
					}

					filePointer = file.getFilePointer();
				}

//				sleep(sampleInterval);
			}

			file.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

4、問題補充

SpringBoot中需要注入bean，通過注入一個ServerEndpointExporter,該Bean會自動注冊使用@ServerEndpoint注解申明的websocket endpoint。

要注意：如果使用獨立的servlet容器，而不是直接使用springboot的內置容器，

就不要注入ServerEndpointExporter，因為它將由容器自己提供和管理，所以在注入

ServerEndpointExporter時需要增加一些配置

package conf;

import org.springframework.boot.web.servlet.ServletContextInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;

/**
 * 注入一個ServerEndpointExporter,
 * 該Bean會自動注冊使用@ServerEndpoint注解申明的websocket endpoint
 * @author Mr.Ye
 *
 */
@Configuration
public class WebSocketConfig implements ServletContextInitializer {

    /**
     * 要注意，如果使用獨立的servlet容器，而不是直接使用springboot的內置容器，
     * 就不要注入ServerEndpointExporter，因為它將由容器自己提供和管理
     * 所以增加以下配置：
     * @return
     */
	@Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        servletContext.setInitParameter("org.apache.tomcat.websocket.textBufferSize", String.valueOf(10 * 1024 * 1024));
        servletContext.setInitParameter("org.apache.tomcat.websocket.binaryBufferSize", String.valueOf(10 * 1024 * 1024));
    }
}