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

想写个小工具包用来在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也自行退出了循环。此时已没有其余线程在运行，程序结束退出。