sinkhandler.java

这是个爬虫和lucece相结合最好了

/* SinkHandler
 * Copyright (C) 2005 Internet Archive.
 *
 * Created on Jul 7, 2003
 *
 * This file is part of the Heritrix web crawler (crawler.archive.org).
 *
 * Heritrix is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * any later version.
 *
 * Heritrix is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser Public License
 * along with Heritrix; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package org.archive.io;

import java.util.Iterator;
import java.util.Vector;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;



/**
 * A handler that keeps an in-memory vector of all events deemed loggable by
 * configuration.
 * Use it to iterate over logged events long after their occurance. One such
 * use is as a sink for WARNING+SEVERE loggable events. Has support for
 * whether a log record has been already-read.
 * TODO: Add being able to get LogRecords by log level: i.e. return all
 * Level.SEVERE, etc.
 * TODO: Back the vector with a bdbje collection.
 * @author stack
 * @version $Date: 2006-09-22 17:23:04 +0000 (Fri, 22 Sep 2006) $ $Revision: 4646 $
 */
public class SinkHandler extends Handler {
    /**
     * Alerts that have occured.
     */
    private Vector<SinkHandlerLogRecord> sink
     = new Vector<SinkHandlerLogRecord>();
    
    public SinkHandler() {
        LogManager manager = LogManager.getLogManager();
        String className = getClass().getName();
        String tmp = manager.getProperty(className + ".level");
        if (tmp != null) {
            setLevel(Level.parse(tmp));
        }
    }
    
    public void publish(LogRecord record) {
        if (!isLoggable(record)) {
            return;
        }
        this.sink.add(new SinkHandlerLogRecord(record));
    }

    public void flush() {
        // Nothing to do.
    }

    public void close() throws SecurityException {
        flush();
    }
    
    /**
     * @return SinkHandler instance if one registered or null.
     */
    public static SinkHandler getInstance() {
        SinkHandler h = null;
        Handler[] handlers = Logger.getLogger("").getHandlers();
        for (int i = 0; i < handlers.length; i++) {
            if (handlers[i] instanceof SinkHandler) {
                h = (SinkHandler) handlers[i];
                break;
            }
        }
        if (h == null) {
            // None setup automatically (Not found in heritrix.properties --
            // can happen when deployed in a containter such as tomcat).
            // Create one manually here.
            h = new SinkHandler();
            h.setLevel(Level.WARNING);
            Logger.getLogger("").addHandler(h);
        }
        return h;
    }
    
    /**
     * @return all SinkHandlerLogRecords.
     */
    public Vector getAll() {
        return this.sink;
    }
    
    /**
     * @return Return all unread SinkHandlerLogRecords or null if none unread
     */
    public Vector<SinkHandlerLogRecord> getAllUnread() {
        if (this.sink == null) {
            return null;
        }
        Vector<SinkHandlerLogRecord> newLogRecords;
        newLogRecords = new Vector<SinkHandlerLogRecord>();
        for (final Iterator i = this.sink.iterator(); i.hasNext();) {
            SinkHandlerLogRecord lr = (SinkHandlerLogRecord) i.next();
            if (!lr.isRead()) {
                newLogRecords.add(lr);
            }
        }
        return (newLogRecords.size() == 0) ? null : newLogRecords;
    }
    
    /**
     * @return Count of all records.
     */
    public int getCount() {
        return this.sink != null? this.sink.size(): 0;
    }
    
    /**
     * @return The count of unread log records.
     */
    public int getUnreadCount() {
        if (this.sink == null) {
            return 0;
        }
        int n = 0;
        for (final Iterator i = this.sink.iterator(); i.hasNext();) {
            SinkHandlerLogRecord lr = (SinkHandlerLogRecord)i.next();
            if (!lr.isRead()) {
                n++;
            }
        }
        return n;
    }

    /**
     * @param id The <code>sequenceNumber</code> ID of the log record to find.
     * @return A SinkHandlerLogRecord of the given ID or null if not found.
     */
    public SinkHandlerLogRecord get(long id) {
        if (this.sink == null) {
            return null;
        }
        for (final Iterator i = this.sink.iterator(); i.hasNext();) {
            SinkHandlerLogRecord lr = (SinkHandlerLogRecord)i.next();
            if (lr.getSequenceNumber() == id) {
                return lr;
            }
        }
        return null;
    }

    /**
     * @param id The <code>sequenceNumber</code> ID of the log record to find.
     * @return The removed SinkHandlerLogRecord or null if none removed.
     */
    public SinkHandlerLogRecord remove(final long id) {
        SinkHandlerLogRecord shlr = null;
        if (this.sink == null) {
            return  shlr;
        }
        for (final Iterator i = this.sink.iterator(); i.hasNext();) {
            SinkHandlerLogRecord lr = (SinkHandlerLogRecord)i.next();
            if (lr.getSequenceNumber() == id) {
                i.remove();
                shlr = lr;
                break;
            }
        }
        return shlr;
    }

    /**
     * @param id The <code>sequenceNumber</code> ID of the log record to find
     * and mark as read.
     */
    public void read(final long id) {
        for (final Iterator i = this.sink.iterator(); i.hasNext();) {
            SinkHandlerLogRecord lr = (SinkHandlerLogRecord)i.next();
            if (lr.getSequenceNumber() == id) {
                lr.setRead();
                break;
            }
        }
    }
}