java,通过接口读取日志文件

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import lombok.Data;

@Data
@Component
@ConfigurationProperties(prefix = "server-log")
public class LogReaderProperties {
    private String filePath;
    private boolean enabled = false;
}

package com.touchsmail.controller.tools.log;

import com.touchsmail.util.StringUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import java.time.*;
import java.time.format.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

@RestController
@RequestMapping("/service/logs")
public class SystemLogController {

    //    private static final String LOG_FILE_PATH = "/Users/edy/Documents/console.log";
    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    private final ExecutorService executor = Executors.newCachedThreadPool();

    @Resource
    private LogReaderProperties properties;

    // 增加响应头，处理中文乱码
    private HttpHeaders getHeaders() {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.TEXT_PLAIN);
        headers.set(HttpHeaders.CONTENT_ENCODING, "UTF-8");
        headers.set(HttpHeaders.CONTENT_TYPE, "text/plain;charset=UTF-8");
        return headers;
    }


    private void checkEnabled() {
        if (!properties.isEnabled()) {
            throw new IllegalStateException("log not open!");
        }
    }

    private void checkFileExists() {
        if (StringUtils.isBlank(properties.getFilePath()) || !Files.exists(Paths.get(properties.getFilePath()))) {
            throw new IllegalStateException("log file does not exist!");
        }
    }

    @GetMapping("/")
    public ResponseEntity<String> explain() {
        checkEnabled();
        checkFileExists();
        final String content = "// 读取全部日志\n" +
                "GET http://localhost:6001/service/logs/all\n" +
                "\n" +
                "// 读取最新10条日志\n" +
                "GET http://localhost:6001/service/logs/latest?lines=10\n" +
                "\n" +
                "// 读取指定时间范围的日志\n" +
                "GET http://localhost:6001/service/logs/time?startTime=2024-12-01 00:00:00&endTime=2024-12-31 00:00:00\n" +
                "\n" +
                "// 流式读取日志\n" +
                "GET http://localhost:6001/service/logs/stream?bufferSize=100"+
                "// 流式追踪最新日志\n" +
                "GET http://localhost:6001/service/logs/realtime";
        return new ResponseEntity<>(content, getHeaders(), HttpStatus.OK);
    }

    @GetMapping("/all")
    public ResponseEntity<String> readAllLogs() {
        checkEnabled();
        checkFileExists();
        try {
            String content = new String(Files.readAllBytes(Paths.get(properties.getFilePath())), StandardCharsets.UTF_8);
            return new ResponseEntity<>(content, getHeaders(), HttpStatus.OK);
        } catch (IOException e) {
            return new ResponseEntity<>("读取日志文件失败: " + e.getMessage(), getHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @GetMapping("/latest")
    public ResponseEntity<String> readLatestLogs(@RequestParam(defaultValue = "10") int lines) {
        try {
            checkEnabled();
            checkFileExists();
            List<String> allLines = Files.readAllLines(Paths.get(properties.getFilePath()), StandardCharsets.UTF_8);
            int startIndex = Math.max(0, allLines.size() - lines);
            List<String> latestLines = allLines.subList(startIndex, allLines.size());

            StringBuilder result = new StringBuilder();
            for (String line : latestLines) {
                result.append(line).append("\n");
            }

            return new ResponseEntity<>(result.toString(), getHeaders(), HttpStatus.OK);
        } catch (IOException e) {
            return new ResponseEntity<>("读取日志文件失败: " + e.getMessage(), getHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @GetMapping("/time")
    public ResponseEntity<String> readLogsByTimeRange(
            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime) {
        try {
            checkEnabled();
            checkFileExists();
            List<String> allLines = Files.readAllLines(Paths.get(properties.getFilePath()), StandardCharsets.UTF_8);
            StringBuilder result = new StringBuilder();

            for (String line : allLines) {
                try {
                    String timeStr = line.substring(0, 19);
                    LocalDateTime logTime = LocalDateTime.parse(timeStr, DATE_FORMAT);

                    if ((logTime.isEqual(startTime) || logTime.isAfter(startTime)) &&
                            (logTime.isEqual(endTime) || logTime.isBefore(endTime))) {
                        result.append(line).append("\n");
                    }
                } catch (Exception e) {
                    // Skip malformed log entries
                    continue;
                }
            }

            return new ResponseEntity<>(result.toString(), getHeaders(), HttpStatus.OK);
        } catch (IOException e) {
            return new ResponseEntity<>("读取日志文件失败: " + e.getMessage(), getHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @GetMapping("/stream")
    public ResponseEntity<String> streamLog(@RequestParam(defaultValue = "100") int maxLines) {
        try {
            checkEnabled();
            checkFileExists();
            List<String> lines = new ArrayList<>();
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(new FileInputStream(properties.getFilePath()), StandardCharsets.UTF_8))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    lines.add(line);
                    if (lines.size() > maxLines) {
                        lines.remove(0);
                    }
                }
            }

            StringBuilder result = new StringBuilder();
            for (String line : lines) {
                result.append(line).append("\n");
            }

            return new ResponseEntity<>(result.toString(), getHeaders(), HttpStatus.OK);
        } catch (IOException e) {
            return new ResponseEntity<>("读取日志文件失败: " + e.getMessage(), getHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 实时读取日志文件内容并推送给客户端
     *
     * @param initialLines 初次读取日志的行数（可选，默认为 0，不读取初始内容，直接开始实时监控和推送新增日志）
     * @param filePath     日志文件路径，不传就用配置文件中的
     * @return SseEmitter 用于推送实时日志内容
     */
    @GetMapping("/realtime")
    public SseEmitter streamLogRealtime(@RequestParam(defaultValue = "0") int initialLines, @RequestParam(required = false) String filePath) {
//        checkEnabled();

        SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);
        Path logFilePath = (filePath != null && !filePath.isEmpty()) ? Paths.get(filePath) : Paths.get(properties.getFilePath());

        if (!Files.exists(logFilePath)) {
            throw new RuntimeException("Log file not found: " + filePath);
        }

        executor.execute(() -> {
            try {
                WatchService watchService = FileSystems.getDefault().newWatchService();
                logFilePath.getParent().register(watchService, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE);

                AtomicLong filePointer = new AtomicLong(Files.size(logFilePath));

                // 读取最后 N 行日志
                if (initialLines > 0) {
                    List<String> lastLines = readLastLines(logFilePath, initialLines);
                    for (String line : lastLines) {
                        emitter.send(SseEmitter.event().data(line));
                    }
                }

                ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
                scheduler.scheduleAtFixedRate(() -> {
                    try {
                        long newSize = Files.size(logFilePath);
                        if (newSize > filePointer.get()) {
                            // 使用 UTF-8 读取文件内容，避免乱码
                            try (RandomAccessFile file = new RandomAccessFile(logFilePath.toFile(), "r");
                                 InputStreamReader isr = new InputStreamReader(new FileInputStream(file.getFD()), StandardCharsets.UTF_8);
                                 BufferedReader reader = new BufferedReader(isr)) {

                                file.seek(filePointer.get()); // 移动到上次读取的位置
                                String line;
                                while ((line = reader.readLine()) != null) {
                                    emitter.send(SseEmitter.event().data(line)); // 发送 UTF-8 正确编码的日志
                                }
                                filePointer.set(file.getFilePointer()); // 更新文件指针
                            }
                        }
                    } catch (IOException e) {
                        emitter.completeWithError(e);
                    }
                }, 0, 1, TimeUnit.SECONDS);

                while (true) {
                    WatchKey key = watchService.take();
                    boolean fileDeleted = false;

                    for (WatchEvent<?> event : key.pollEvents()) {
                        Path changed = (Path) event.context();
                        if (changed.endsWith(logFilePath.getFileName())) {
                            if (event.kind() == StandardWatchEventKinds.ENTRY_DELETE) {
                                fileDeleted = true;
                            }
                        }
                    }

                    key.reset();

                    if (fileDeleted) {
                        emitter.send(SseEmitter.event().data("Log file deleted. Stopping log streaming."));
                        emitter.complete();
                        scheduler.shutdown();
                        break;
                    }
                }
            } catch (IOException | InterruptedException e) {
                emitter.completeWithError(e);
            }
        });

        return emitter;
    }


    /**
     * 读取文件的最后 n 行
     *
     * @param filePath 文件路径
     * @param lines    需要读取的行数
     * @return 最后 n 行的内容列表
     */
    private List<String> readLastLines(Path filePath, int lines) throws IOException {
        List<String> result = new ArrayList<>();
        // 使用 BufferedReader 以 UTF-8 编码读取文件
        try (BufferedReader reader = Files.newBufferedReader(filePath, StandardCharsets.UTF_8)) {
            // 获取文件的所有行
            List<String> allLines = Files.readAllLines(filePath, StandardCharsets.UTF_8);

            // 从末尾读取最后 lines 行
            int start = Math.max(allLines.size() - lines, 0);
            for (int i = start; i < allLines.size(); i++) {
                result.add(allLines.get(i));
            }
        }
        return result;
    }



    /**
     * 在类销毁时关闭线程池
     */
    @PreDestroy
    public void shutdownExecutor() {
        executor.shutdown();
    }

}

//调用说明
GET http://localhost:8080/service/logs/

// 读取全部日志
GET http://localhost:8080/service/logs/all

// 读取最新10条日志
GET http://localhost:8080/service/logs/latest?lines=10

// 读取指定时间范围的日志
GET http://localhost:8080/service/logs/time?startTime=2024-12-01 00:00:00&endTime=2024-12-30 00:00:00

// 流式读取日志
GET http://localhost:8080/service/logs/stream?bufferSize=100

// 流式追踪最新日志
GET [http://localhost:8080/service/logs/stream?bufferSize=100](http://localhost:6001/service/logs/realtime?
    initialLines={{$random.integer(100)}}&
    filePath={{$random.alphanumeric(8)}})

package com.touchsmail.controller.tools.log;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;


@RestController
@RequestMapping("/service/logs")
public class LogStreamingController {

    private final LogStreamingService logStreamingService;

    public LogStreamingController(LogStreamingService logStreamingService) {
        this.logStreamingService = logStreamingService;
    }

    @GetMapping("/realtime")
    public SseEmitter streamLogRealtime(@RequestParam(defaultValue = "0") int initialLines,
                                        @RequestParam(required = false) String filePath) {
        return logStreamingService.streamLogRealtime(initialLines, filePath);
    }
}

package com.touchsmail.controller.tools.log;

import org.springframework.stereotype.Service;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import javax.annotation.Resource;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

@Service
public class LogStreamingService {

    private final ExecutorService executor = Executors.newCachedThreadPool();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    private final CopyOnWriteArrayList<SseEmitter> emitters = new CopyOnWriteArrayList<>();
    private final WatchService watchService;
    private final ConcurrentHashMap<Path, AtomicLong> filePointers = new ConcurrentHashMap<>();

    @Resource
    private LogReaderProperties properties;

    public LogStreamingService() throws IOException {
        this.watchService = FileSystems.getDefault().newWatchService();
        startFileWatcher();
    }

    public SseEmitter streamLogRealtime(int initialLines, String filePath) {

        if (!properties.isEnabled()) {
            throw new IllegalStateException("log not open!");
        }

        Path logFilePath = (filePath != null && !filePath.isEmpty()) ? Paths.get(filePath) : Paths.get(properties.getFilePath());

        if (!Files.exists(logFilePath)) {
            throw new RuntimeException("Log file not found: " + logFilePath);
        }

        SseEmitter emitter = new SseEmitter(0L);
        emitters.add(emitter);

        executor.execute(() -> sendInitialLines(emitter, logFilePath, initialLines));

        AtomicLong filePointer = filePointers.computeIfAbsent(logFilePath, path -> new AtomicLong(getFileSize(path)));

        scheduler.scheduleAtFixedRate(() -> {
            try {
                readNewLines(emitter, logFilePath, filePointer);
            } catch (IOException e) {
                emitter.completeWithError(e);
            }
        }, 0, 1, TimeUnit.SECONDS);

        // Schedule a heart beat every 30 seconds
        scheduler.scheduleAtFixedRate(() -> {
            try {
                emitter.send(SseEmitter.event().data("heartbeat"));
            } catch (IOException e) {
                emitter.completeWithError(e);
            }
        }, 0, 30, TimeUnit.SECONDS);

        emitter.onCompletion(() -> emitters.remove(emitter));
        emitter.onTimeout(() -> emitters.remove(emitter));

        return emitter;
    }

    private void sendInitialLines(SseEmitter emitter, Path logFilePath, int initialLines) {
        try {
            List<String> lastLines = readLastLines(logFilePath, initialLines);
            for (String line : lastLines) {
                emitter.send(SseEmitter.event().data(line));
            }
        } catch (IOException e) {
            emitter.completeWithError(e);
        }
    }

    private void readNewLines(SseEmitter emitter, Path logFilePath, AtomicLong filePointer) throws IOException {
        long newSize = Files.size(logFilePath);
        if (newSize > filePointer.get()) {
            try (RandomAccessFile file = new RandomAccessFile(logFilePath.toFile(), "r");
                 InputStreamReader isr = new InputStreamReader(new FileInputStream(file.getFD()), StandardCharsets.UTF_8);
                 BufferedReader reader = new BufferedReader(isr)) {

                file.seek(filePointer.get());
                String line;
                while ((line = reader.readLine()) != null) {
                    emitter.send(SseEmitter.event().data(line));
                }
                filePointer.set(file.getFilePointer());
            }
        }
    }

    private List<String> readLastLines(Path path, int n) throws IOException {
        List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
        return lines.subList(Math.max(lines.size() - n, 0), lines.size());
    }

    private long getFileSize(Path path) {
        try {
            return Files.exists(path) ? Files.size(path) : 0;
        } catch (IOException e) {
            return 0;
        }
    }

    private void startFileWatcher() {
        executor.execute(() -> {
            while (true) {
                try {
                    WatchKey key = watchService.take();
                    for (WatchEvent<?> event : key.pollEvents()) {
                        if (event.kind() == StandardWatchEventKinds.ENTRY_DELETE) {
                            Path deletedFile = (Path) event.context();
                            emitters.forEach(emitter -> {
                                try {
                                    emitter.send(SseEmitter.event().data("Log file deleted: " + deletedFile));
                                    emitter.complete();
                                } catch (IOException ignored) {
                                }
                            });
                            emitters.clear();
                        }
                    }
                    key.reset();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
    }
}