观察者模式小练习：多日志监控 by 嗡汤圆

来源：互联网发布：chmod u x mysql.sh 编辑：程序博客网时间：2024/04/28 18:11

想写个小工具包用来在web项目中提供实时查看各系统日志输出的功能。以下仅仅是小练手。
具体特性如下：
1. 观察者模式实现
2. 任意多文件实时捕获输出
3. 多用户查看同一文件时，维持单一读取线程，保证IO效率
4. 当无用户查看某文件时，自动停止对该文件的监控

说明

若想简单实现查看某文件的变化，只要写个循环一直读取就好了，但是这样会造成一个问题：用户少的情况下，少数线程循环读取文件速度变化不明显，若用户数量增多则会出现性能问题。即使假设有10000个用户只读取1个文件，这10000个线程均会循环读取文件，造成磁盘反复在不同位置跳动，严重影响IO性能，因此需要对磁盘性能资源进行统一管理。

设计

观察者模式的基本实现

借助JDK自己的Observable和Observer即可。

监视文件的Observable

该类既有Observable的特性，且需要具备循环运行的能力，因此也要实现Runnable接口。
代码如下：

public class TailSubject extends Observable implements Runnable {    private static final Logger logger = LoggerFactory.getLogger(TailSubject.class);    private File logFile;/*日志文件位置*/    private long sampleInterval = 200;/*默认读取延迟*/    private boolean startFromTop = false;/*是否从头开始*/    private boolean tailing = false;/*是否循环读取*/    public TailSubject(String filePath) {        this.logFile = new File(filePath);    }    public TailSubject(File file) {        this.logFile = file;    }    public void setInterval(long interval){        this.sampleInterval = interval;    }    public void setStartFromTop(boolean flag){        this.startFromTop = flag;    }    public void startTailing() {        logger.info("start tailing");        this.tailing = true;    }    public void kill() {        logger.info("stop tailing");        this.tailing = false;    }    public void run() {        logger.info("thread started");        long filePointer = 0;        if (this.startFromTop) {            logger.info("start from top");            filePointer = 0;        } else {            logger.info("start from " + this.logFile.length());            filePointer = this.logFile.length();        }        try {            RandomAccessFile file = new RandomAccessFile(this.logFile, "r");/* readOnlyFile */            while (this.tailing) {                long fileLength = this.logFile.length();                if (fileLength < filePointer) {                    logger.info("log file length reduced.");                }                if (fileLength > filePointer) {                    file.seek(filePointer);                    String line = file.readLine();                    while (line != null) {                        /*在这里通知观察者*/                        setChanged();/*setChanged此步骤必须*/                        notifyObservers(line);                        line = file.readLine();                    }                    filePointer = file.getFilePointer();                }                Thread.currentThread();                Thread.sleep(this.sampleInterval);            }        } catch (IOException e) {            logger.error(e.toString());        } catch (InterruptedException e) {            logger.error(e.toString());        }    }}

Observer的基本实现

直接集成Observer类即可，需要重写update方法。

// 以更新时记录日志的观察者和屏幕输出的观察者为例，如下：public class LoggingObserver implements Observer {    private static final Logger logger = LoggerFactory.getLogger(LoggingObserver.class);    public void update(Observable o, Object arg) {        logger.info("LoggingObserver updating:" + arg);    }}public class SysoutObserver implements Observer {    public void update(Observable o, Object arg) {        System.out.println("SysoutObserver updating:" + arg);    }}

Observable的统一管理

单例模式建立一个Observable资源的管理类，确保一个文件仅有一个Observable在监视它，同时在没有观察者订阅时自动结束监视线程，以节省磁盘资源。

public class TailPool {    private static final Logger logger = LoggerFactory.getLogger(TailPool.class);    private static HashMap<String, TailSubject> subjects;    public static volatile TailPool instance;    private TailPool() {        subjects = new HashMap<String, TailSubject>();    }    public static TailPool getInstance(){        if(instance == null){            synchronized (TailPool.class) {                if(instance == null){                    instance = new TailPool();                }            }        }        return instance;    }    /*注册Observer*/    public synchronized TailSubject subscribe(String filePath){        if(subjects.containsKey(filePath)){            logger.info("subject already exist.");            return subjects.get(filePath);        }        logger.info("creating new subject:"+filePath);        TailSubject subject = new TailSubject(filePath);        subject.startTailing();        subjects.put(filePath, subject);        new Thread(subject).start();        return subject;    }    /*取消Observer观察*/    public synchronized void unSubscribe(String filePath, Observer obs){        TailSubject subject = subjects.get(filePath);        if(subject == null){            logger.info("subject doesn't exist");        } else {            subject.deleteObserver(obs);            int observerCount = subject.countObservers();            logger.info("subject has "+observerCount+" observers left.");            if(observerCount == 0){                logger.info("no observer, stopping, remove subject from subject cache.");                subject.kill();                subjects.remove(filePath);            }        }    }}

使用

    String file = "C://log1";    LoggingObserver ob1 = new LoggingObserver();    TailPool.getInstance().subscribe(file).addObserver(ob1);/*订阅*/    TailPool.getInstance().unSubscribe(file, ob1);/*取消订阅*/

实例演示

这里演示订阅两个文件的监视，其中文件1有两个观察者（LoggingObserver，SysoutObserver），文件2只有一个LoggingObserver。在监视结束后陆续取消以上观察者的监听，并观察程序是否自动结束循环并退出。

启动、订阅

String file = "C://log1";String file2 = "C://log2";LoggingObserver ob1 = new LoggingObserver();SysoutObserver ob2 = new SysoutObserver();LoggingObserver ob3 = new LoggingObserver();TailPool.getInstance().subscribe(file).addObserver(ob1);TailPool.getInstance().subscribe(file).addObserver(ob2);TailPool.getInstance().subscribe(file2).addObserver(ob3);

效果如下：
这里写图片描述
可以看到第一个Observer注册的时候新建了一个文件监听线程，第二个Observer由于观察了同一个文件，因此直接在已有的线程注册一个自己，而不是新建线程“subject already exist”。
第三个Observer观察不同的文件，因此有新建了一个线程。

日志文件输出

通过记事本修改日志文件模拟文件的变化。效果如下
这里写图片描述
可以看到修改第一个文件时，两个观察者都得到了通知，并分别以Log和system.out.println的形式进行了更新。修改第二个文件时，第三个观察者输出了更新。

停止观察并退出

依次调用unSubscribe，观察程序是否退出。

System.in.read();logger.info("unsubscribing...");TailPool.getInstance().unSubscribe(file, ob1);TailPool.getInstance().unSubscribe(file, ob2);TailPool.getInstance().unSubscribe(file2, ob3);

手动敲一个回车即可开始停止的过程。分别依次取消各个观察者的监听。
这里写图片描述
可以看到第一个文件在Observer1取消时由于还有Observer2，因此不会退出。在Observer2也取消后，线程自行退出循环。同理Observer3取消时，线程2也自行退出了循环。此时已没有其余线程在运行，程序结束退出。

0 0