meethigher-Java监控本地日志并实现实时查看

已于 2023-06-08 21:37:53 修改
阅读量2.1k 收藏 5
点赞数
分类专栏： java 文章标签： java intellij-idea 开发语言
于 2021-12-08 00:55:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30460361/article/details/121782212
版权

每次查看日志，都需要去服务器上看，太麻烦了，所以简单实现一个在线日志实时监控功能，可以方便实时查看了。

源码meethigher/log-monitor

参考

实现功能

  1. 指定目录下的日志文件查询。支持按照时间范围查询
  2. 下载日志
  3. 实时查看日志

实现逻辑

  1. 文件的按照时间查询，采用FileChannel的lastModified属性获取时间，查询lastModified在指定时间范围内即可。
  2. 下载功能，直接网上抄就行
  3. 实时查看日志，通过websocket实现。每个websocket请求进来会开启一个线程监听一个日志文件，请求断开线程关闭。考虑到这本身也不是一个常用的功能，使用了显式创建线程的方式。

查询与下载

放上具体的业务逻辑代码

@Service
public class LogMonitorServiceImpl implements LogMonitorService {

    private final Logger log = LoggerFactory.getLogger(LogMonitorServiceImpl.class);

    /**
     * 日志根目录、默认目录
     */
    @Value("${log.monitor.defaultPath}")
    private String logRootPath;

    /**
     * 获取路径
     *
     * @param logPath
     * @return
     */
    private String getLogPath(String logPath) throws CommonException {
        String path = null;
        if (ObjectUtils.isEmpty(logPath)) {
            path = logRootPath;
        } else {
            if (!logPath.contains(logRootPath)) {
                throw new CommonException(ResponseEnum.NO_ACCESS_FOR_THIS_PATH);
            }
            path = logPath;
        }
        return path;
    }

    /**
     * 按照时间查询日志
     *
     * @param startTime
     * @param endTime
     * @param dir
     * @return
     */
    private List<String> queryLogByTime(Long startTime, Long endTime, File dir) {
        List<String> files = new LinkedList<>();
        for (String s : Objects.requireNonNull(dir.list())) {
            File file = new File(dir, s);
            long lastModified = file.lastModified();
            if (startTime <= lastModified && endTime >= lastModified) {
                files.add(file.getAbsolutePath().replaceAll("\\\\", "/"));
            }
        }
        log.info("queryLogByTime");
        return files;
    }

    /**
     * 查询所有日志
     *
     * @param dir
     * @return
     */
    private List<String> queryLogWithoutTime(File dir) {
        List<String> files = new LinkedList<>();
        for (String s : Objects.requireNonNull(dir.list())) {
            File file = new File(dir, s);
            files.add(file.getAbsolutePath().replaceAll("\\\\", "/"));
        }
        log.info("queryLogWithoutTime");
        return files;
    }


    @Override
    public List<String> queryLog(QueryLogRequest request) throws CommonException {
        String logPath = getLogPath(request.getLogPath());
        File dir = new File(logPath);
        if (!dir.exists() || !dir.isDirectory()) {
            throw new CommonException(ResponseEnum.DIR_NOT_EXIST_OR_DIR_IS_A_FILE);
        }
        if (!ObjectUtils.isEmpty(request.getStartTime()) && !ObjectUtils.isEmpty(request.getEndTime())) {
            return queryLogByTime(request.getStartTime(), request.getEndTime(), dir);
        } else {
            return queryLogWithoutTime(dir);
        }
    }

    @Override
    public String downloadLog(DownloadLogRequest request, HttpServletResponse response) throws CommonException {
        String logPath = getLogPath(request.getLogPath());
        File file = new File(logPath);
        if (!file.exists() || !file.isFile()) {
            throw new CommonException(ResponseEnum.FILE_NOT_EXIST_OR_FILE_IS_DIRECTORY);
        }
        // 实现文件下载
        byte[] buffer = new byte[1024];
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        try {
            // 配置文件下载
            response.setHeader("content-type", "application/octet-stream");
            response.setContentType("application/octet-stream");
            // 下载文件能正常显示中文
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(request.getDownloadName(), "UTF-8"));
            fis = new FileInputStream(file);
            bis = new BufferedInputStream(fis);
            OutputStream os = response.getOutputStream();
            int i = bis.read(buffer);
            while (i != -1) {
                os.write(buffer, 0, i);
                i = bis.read(buffer);
            }
            log.info("下载文件成功!");
        } catch (Exception e) {
            log.info("下载文件失败!");
            throw new CommonException(ResponseEnum.DOWNLOAD_FILE_FAILED);
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

实时查看日志

websocket使用spring-websocket

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

websocket配置类

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Value("${log.websocket}")
    private String path;

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new SocketEventHandler(), path).setAllowedOrigins("*");
    }
}

websocket处理器

public class SocketEventHandler extends AbstractWebSocketHandler {

    private final Logger log = LoggerFactory.getLogger(SocketEventHandler.class);

    @Override
    public void afterConnectionEstablished(WebSocketSession session) {
        log.info("进行连接");
        WebSocketUtils.addSessoin(session);
        WebSocketUtils.startMonitor(session.getId());
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
        log.info("关闭连接");
        WebSocketUtils.reduceSession(session);
    }
}

websocket工具类

public class WebSocketUtils {

    private static final Logger log = LoggerFactory.getLogger(WebSocketUtils.class);
    /**
     * 已连接的websocket
     */
    private static Map<String, WebSocketSession> onlineSession = new HashMap<>();

    /**
     * 添加用户
     *
     * @param session
     */
    public static void addSessoin(WebSocketSession session) {
        onlineSession.put(session.getId(), session);
        log.info("{}的用户连接websocket", session.getId());
    }

    /**
     * 移除用户
     *
     * @param session
     */
    public static void reduceSession(WebSocketSession session) {
        onlineSession.remove(session.getId());
        log.info("{}的用户断开websocket", session.getId());
    }

    /**
     * 开启监测
     * 本质是一监控一线程
     *
     * @param sessionId
     */
    public static void startMonitor(String sessionId) {
        WebSocketSession session = onlineSession.get(sessionId);
        String query = session.getUri().getQuery();
        String logPath = query.substring(query.indexOf("=") + 1);
        new FileMonitor(session.getId(), logPath);
    }

    /**
     * 关闭监控
     * session关闭，相应线程也会关闭
     *
     * @param sessionId
     */
    public static void endMonitor(String sessionId) {
        WebSocketSession session = onlineSession.get(sessionId);
        sendMessageTo(sessionId,"<error>ERROR 监控线程出现异常！</error>");
        try {
            session.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 发送消息给指定用户
     *
     * @param sessionId
     * @param message
     */
    public static void sendMessageTo(String sessionId, String message) {
        WebSocketSession session = onlineSession.get(sessionId);
        try {
            session.sendMessage(new TextMessage(message));
        } catch (Exception e) {
            e.printStackTrace();
            WebSocketUtils.endMonitor(sessionId);
        }
    }

    /**
     * session是否在线
     * 用于决定线程是否关闭
     *
     * @param sessionId
     * @return
     */
    public static boolean currentSessionAlive(String sessionId) {
        return onlineSession.containsKey(sessionId);
    }
}

文件监听器

public class FileMonitor {

    private static final Logger log = LoggerFactory.getLogger(FileMonitor.class);

    /**
     * 绑定的websocket
     */
    private String sessionId;

    /**
     * 绑定的监控日志路径
     */
    private String logPath;

    /**
     * 监控时间间隔，单位ms
     */
    private Long monitorDelay;

    public FileMonitor(String sessionId, String logPath) {
        this.sessionId = sessionId;
        this.logPath = logPath;
        this.monitorDelay = 500L;
        startFileMonitor(monitorDelay);
    }

    public FileMonitor(String sessionId, String logPath, Long monitorDelay) {
        this.sessionId = sessionId;
        this.logPath = logPath;
        this.monitorDelay = monitorDelay;
        startFileMonitor(monitorDelay);
    }

    private void startFileMonitor(Long monitorDelay) {
        Thread thread = new Thread(new FileMonitorRunnable(sessionId, logPath, monitorDelay));
        thread.start();
    }
}

文件监听线程Runnable

public class FileMonitorRunnable implements Runnable {

    private static final Logger log = LoggerFactory.getLogger(FileMonitorRunnable.class);

    private ByteBuffer byteBuffer = ByteBuffer.allocate(1024 * 100);

    private CharBuffer charBuffer = CharBuffer.allocate(1024 * 50);

    private CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();

    private boolean isRunning = true;

    private String sessionId;

    private String logPath;

    private Long monitorDelay;

    public FileMonitorRunnable(String sessionId, String logPath, Long monitorDelay) {
        this.sessionId = sessionId;
        this.logPath = logPath;
        this.monitorDelay = monitorDelay;
    }

    @Override
    public void run() {
        File file = new File(logPath);
        FileChannel channel = null;
        try {
            channel = new FileInputStream(file).getChannel();
            channel.position(channel.size());
        } catch (Exception e) {
            log.info("监控文件失败，检查路径是否正确");
            WebSocketUtils.endMonitor(sessionId);
            e.printStackTrace();
        }
        long lastModified = file.lastModified();
        //TODO: 初次连接将所有内容丢回去？这个考虑到数据如果很多先不丢
        while (isRunning) {
            long now = file.lastModified();
//            log.info("{}的连接正在通过线程{}监控{}文件",sessionId,Thread.currentThread().getName(),logPath);
            if (now != lastModified) {
                log.info("{}的连接正在通过线程{}监控{}的文件update", sessionId, Thread.currentThread().getName(), logPath);
                String newContent = getNewContent(channel);
                WebSocketUtils.sendMessageTo(sessionId, newContent);
                lastModified = now;
            }
            try {
                Thread.sleep(monitorDelay);
            } catch (InterruptedException e) {
                e.printStackTrace();
                WebSocketUtils.endMonitor(sessionId);
            }
            isRunning = WebSocketUtils.currentSessionAlive(sessionId);

        }
    }

    private String getNewContent(FileChannel channel) {
        try {
            byteBuffer.clear();
            charBuffer.clear();
            int length = channel.read(byteBuffer);
            if (length != -1) {
                byteBuffer.flip();
                decoder.decode(byteBuffer, charBuffer, true);
                charBuffer.flip();
                return charBuffer.toString();
            } else {
                channel.position(channel.size());
            }
        } catch (Exception e) {
            e.printStackTrace();
            WebSocketUtils.endMonitor(sessionId);
        }
        return null;
    }
}

最终效果

放几张图片

言成言成啊
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实时读取log日志文件
小江专栏
10-16 3万+
需求： 需求：正在开发一个监控系统，要求将多台日志信息实时采集出来，然后保存到Kafka中，后期对日志数据进行spark运算、大数据处理分析，日志按大小，时间切分。 运用的技术：RandomAccessFile类中seek方法可以从指定位置读取文件，可以用来实现文件实时读取，JDK文档有对RandomAccessFile的介绍。 思想：在每一次读取后，close一下就不会影响重命
SpringBoot如何使用WebSocket+jsch实现前后端交互获取服务器log并返回前端？
cxmfly11的博客
03-18 1630
注意springContextHolder的作用是websocket的特殊属性导致Autowired用不了，直接Autowired会拉入一个null对象。三、新建WebSocket服务端，在其中处理websocket逻辑。二、配置工具类，并在工具类中拉入websocket进行消息发送。在JschUtil中的发送方法中使用websocket发送消息。二、新建WebSocket配置类。
探索 Graphite-Tattle: 一款面向 Java 开发者的轻量级日志分析工具
最新发布
gitblog_00090的博客
03-15 665
探索 Graphite-Tattle: 一款面向 Java 开发者的轻量级日志分析工具 在开发过程中，我们常常需要关注和分析日志以便更好地理解程序的运行状态和问题所在。但是，传统的日志分析方式往往效率低下、耗时较长且难以快速定位问题。为了改善这一状况，我们很高兴向大家推荐一款专门针对 Java 开发者设计的轻量级日志分析工具——Graphite-Tattle。 项目简介 Graphite-Tat...
获取并监控远程服务器日志
qq_36364521的博客
06-28 337
测试JSch
java 通过ssh 连接执行shell命令，文件传输
kaili_0230的博客
10-24 5312
JSch 是SSH2的纯 Java 实现
利用Java实现 实时写入、实时读取监控日志文件
Monster_Xu的博客
11-30 3398
创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都。可以看到程序启动后会将文件中已有的数据立即读出来，因为在。- initialDelay和delay参数的时间单位。切换到实时读取程序窗口，可以看到实时读取程序正在按照。，就会取消后续执行。否则，只能通过执行程序的取消或终止。- 一次执行终止和下一次执行开始之间的延迟时间;方法中我们将首次执行的延迟时间设置为。如果任务的任一执行遇到。- 首次执行的延迟时间;方法中给定的延迟时间。
java创建对象时类的加载顺序
samuBO的博客
11-16 272
执行顺序 父类静态变量 or 父类静态代码块[看位置，顺序执行,从上往下] 子类静态变量 or子类静态代码块[看位置，顺序执行,从上往下] 父类非静态变量 or 父类非静态代码块[看位置，顺序执行,从上往下] 父类构造方法 子类非静态变量 or 子类非静态代码块[看位置，顺序执行,从上往下] 子类构造方法 注： 静态代码块只执行一次 因为static修饰的在类被加载时也被加载 （https://www.cnblogs.com/lwthad/p/10253322.html） public class .
Java实现服务器Web实时日志
学校牛肉面的博客
08-31 3891
起因 服务器没有登陆的权限，看服务器日志需要找同事，由于老是麻烦同事就看在网上是否有web日志查看的功能，有ELK的介绍，不想搞这么大动作，看到同猿的一篇文章 用websocket+tail 命令实现实时日志查看 。在原来的代码改了下，项目结果如下：   代码 https://gitee.com/davegrohl/LogView  ...
线上日志操作
m0_68927002的博客
03-23 1656
Log4j 共八个日志级别；日志写在哪；日志书写规范与注意事项；日志统一收集；线上日志排查方法；阿里云日志查询
Java用WebSocket + tail命令实现Web实时日志
热门推荐
叉叉哥的BLOG
11-25 2万+
在Linux操作系统中，经常需要查看日志文件的实时输出内容，通常会使用tail -f或者taif命令。查看实时日志可能会需要首先SSH连上Linux主机，步骤很麻烦不说，如果是生产环境的服务器，可能还会控制各种权限。基于Web的实时日志可以解决这个问题。由于传统的HTTP协议是请求/响应模式，而实时日志需要不定时的持续的输出，由服务器主动推送给客户端浏览器。所以这里使用的是HTML5的WebSock
java实现实时展示运行日志（2）- 使用 springboot + Elasticsearch + logstash 实现收集、存储、查询日志功能 记录
daoerZ的博客
09-29 1397
利用 spingboot + Elasticsearch + logstash 实现收集、存储、查询日志功能，logstash采集业务系统的日志，存储到es里；Spring Data Elasticsearch提供了访问es的接口，Spring Data Elasticsearch是Spring Data项目下的一个子模块，使用spingboot自动引入spring-data。 环境（windo...
python实现tail实时查看服务器日志
蝉之洞
01-08 5303
import paramiko from paramiko_expect import SSHClientInteraction host = your host port = your port username = your un # 自行修改输出函数 json_list = [] def output_func(msg): sys.stdout.write(msg) ...
java利用aop实现日志_利用spring aop优雅地实现日志功能
weixin_31493023的博客
02-17 864
日常编码过程中，我们经常都会遇到在处理实际领域业务前后附加的逻辑，例如：权限校验，写操作日志，事务管理，推送等等。spring提供了一种技术：面向切面的编程，即 AOP，它允许程序员对横切关注点或行为进行模块化。AOP 的核心构造是切面，它将那些影响多个类的行为封装到可重用的模块中。AOP 和 IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中...
Jsch连接服务器失败解决办法其他工具可以连接成功但是Jsch不行解决办法
风水道人
11-15 716
Jsch连接服务器失败解决办法其他工具可以连接成功但是Jsch不行解决办法
Java实时读取日志文件
听雨草堂
08-21 424
古怪的需求# 在实习的公司碰到一个古怪的需求：在一台服务器上写日志文件，每当日志文件写到一定大小时，比如是1G，会将这个日志文件改名成另一个名字，并新建一个与原文件名相同的日志文件，再往这个新建的日志文件里写数据；要求写一个程序能实时地读取日志文件中的内容，并且不能影响写操作与重命名操作。 RandomAccessFile类中seek方法可以从指定位置读取文件，可以用来实现文件实时读取。JDK文...
java日志查看工具finder介绍
陈苏漾的IT生涯
02-14 2173
FinderWeb是一个高性能的Web版分布式文件管理工具，它具有体积小，易部署，功能强大等特点
java实现实时展示运行日志（1）-springboot + websocket 实现后台主动将日志推送到前端页面
daoerZ的博客
09-29 7555
最近有一个需求，要将任务运行的日志实时显示在前端页面上，让用户及时了解该任务的执行情况。分两部分：后台如何获取日志信息？获取日志信息后，如何实时展示在前端页面上？ 本文先讨论下实时展示到页面，可采取的方案有两种：①ajax轮询，隔3-5秒访问后台，获取日志信息响应；②无需前端请求，后台主动将日志信息推送到前端页面展示。以上两者都是可行的，没有绝对的优劣。本文就第二种方案使用websocket实现...
Java实时监控日志文件并输出
yingbin920的博客
05-27 668
   最近有一个银行数据漂白系统,要求操作人员在页面调用远端Linux服务器的shell,并将shell输出的信息保存到一个日志文件,前台页面要实时显示日志文件的内容.这个问题难点在于如何判断哪些数据是新增加的,通过查看JDK 的帮助文档,java.io.RandomAccessFile可以解决这个问题.为了模拟这个问题,编写LogSvr和 LogView类,LogSvr不断向mock.log日...
java物联网平台后端架构构思设计
11-02
Java物联网平台后端架构设计的关键是确保系统具备良好的可扩展性、高性能和稳定性，能够处理大量的设备连接、数据传输和业务逻辑。以下是一个可能的设计思路： 1. 技术选型：选择成熟稳定的Java开发框架，如Spring、Spring Boot和Spring Cloud，以及分布式消息队列Apache Kafka用于异步消息处理。使用MySQL或者NoSQL数据库存储设备和数据信息。 2. 架构设计：采用微服务架构，将系统划分为多个独立的服务单元，例如设备管理服务、数据接收服务、数据处理和分析服务、数据存储服务、用户管理服务等。每个服务拥有独立的数据存储和处理能力，可以独立扩展和部署。 3. 设备管理服务：处理设备的注册与认证，管理设备的状态和信息。为设备提供实时的状态监测和故障诊断，并支持设备的远程控制和固件升级。 4. 数据接收服务：接收来自设备的数据传输请求，提供数据接收的API接口和队列处理机制，确保数据的实时性和可靠性。 5. 数据处理和分析服务：对接收到的数据进行实时处理和分析，提取有价值的信息。可以使用流式计算框架（如Apache Storm或Spark Streaming）对数据进行实时处理，根据设定的规则进行数据过滤和判断，并将结果发送给其他服务或者存储到数据库中。 6. 数据存储服务：负责将处理后的数据存储到数据库中，可以选择关系型数据库（如MySQL）或者NoSQL数据库（如MongoDB）来存储设备和数据信息，根据实际需求设计存储方案。 7. 用户管理服务：处理用户的注册、登录和权限管理等功能。为用户提供API接口或者网页前端，管理用户信息和权限控制。 8. 安全策略：确保系统具备高安全性，包括设备认证、数据传输加密、权限控制等。采用HTTPS协议进行数据传输，使用加密算法对敏感数据进行加密。 9. 监控和日志：设置系统监控和错误日志，确保对系统进行实时监测，及时发现和处理问题。 10. 云平台适配：可以考虑将该物联网平台适配到常用的云平台（如AWS或阿里云），利用云服务的弹性和扩展性。 以上是一个大致的Java物联网平台后端架构设计思路，具体的实现还需要根据具体情况进行调整和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值