logger.java.svn-base

日志组件,添加到应用中,可在数据库中查询日志

package com.gisinfo.common.log;

import com.gisinfo.common.util.CommonUtil;

import java.util.*;
import java.io.Serializable;

/**
 * User: Ken
 * Date: 2008-5-20
 * Time: 16:02:40
 */
/*
private Level level = Level.DEBUG;  // 重要级别
    private String who;                  // 谁
    private Date when;                   //什么时候
    private String where;                //在什么地方
    private String toWho;                //对谁
    private String doWhat;               //做了什么事情
    private String systemName;          //所属系统
    private String description;         //时间描述
 */
public class Logger extends Observable  implements Serializable {
    public static enum LoggerType {
        SYSTEM_LOGGER, CUSTOM_LOGGER
    }

    private LoggerType loggerType;
    private static LoggerConfig loggerConfig = new LoggerConfig();
    //private List<LogEvent> events = new ArrayList<LogEvent>();
    private List<LogWriter> logWriters = new ArrayList<LogWriter>();
    private String sign = "";
    private Level recordLevel = null;
    private String class_Name_Key = "class";

    public Level getRecordLevel() {
        return this.recordLevel;
    }


    public void addEventOccurHandler(LogEventOccur occur) {
        addObserver(occur);
    }

    public void removeAllEventOccurHandler() {
        deleteObservers();
    }

    public LoggerType getLoggerType() {
        return loggerType;
    }

    public void setLoggerType(LoggerType loggerType) {
        this.loggerType = loggerType;
    }

    

    Logger(String sign,boolean isCustomLogger) {
        this.sign = sign;
        loggerType= isCustomLogger?Logger.LoggerType.CUSTOM_LOGGER:Logger.LoggerType.SYSTEM_LOGGER;
        if (!LoggerConfig.loadConfigSuccess) return;
        recordLevel = LoggerConfig.getLevel(sign,isCustomLogger);
        initWriter(sign,isCustomLogger);


    }

    private void initWriter(String classString, boolean customLogger) {
        List<String> writers = LoggerConfig.getWriterByStr(classString,customLogger);
        if (writers == null) {
            LoggerConfig.writeInfo("找不到" + classString + "的writer!");
            return;
        }
        for (String name : writers) {
            WriterBean bean = LoggerConfig.getWriterBeanByName(name);
            if (bean == null) {
                LoggerConfig.writeInfo("找不到writer:" + name + "!");
                continue;
            }
            String className = bean.getProperty(class_Name_Key);
            if (CommonUtil.isNullOrEmpty(className)) {
                LoggerConfig.writeInfo("找不到writer:" + name + "的class!");
                continue;
            }
            LogWriter lw = LoggerFactory.getLogWriter(name, className);
            if (lw == null) {
                LoggerConfig.writeInfo("writer:" + name + "加载失败！");
                continue;
            }

            lw.setProperties(bean.getProperties());
            lw.init();
            this.addLogWriter(lw);

        }
    }


    private boolean shouldRecord(Level level) {
        return LoggerConfig.loadConfigSuccess && level.isMoreImportantOrEquals(recordLevel);
    }

    public static Logger getLogger(Class aClass) {
        return LoggerFactory.getLogger(aClass.getName());
    }
    public static Logger getCustomLogger(String loggerSign) {
        return LoggerFactory.getCustomLogger(loggerSign);
    }


    public static Logger getLogger(String sign) {
        return LoggerFactory.getLogger(sign);
    }


    public void addLogWriter(LogWriter lw) {
        this.logWriters.add(lw);
    }

    public void removeAllWriter() {
        this.logWriters.clear();
    }


    public void debug(LogEvent event) {
        record(event, Level.DEBUG);
        // write();
    }

    public void info(LogEvent event) {
        record(event, Level.INFO);
    }

    public void warn(LogEvent event) {
        record(event, Level.WARN);
    }

    public void exception(LogEvent event) {
        record(event, Level.EXCEPTION);
    }

    public void error(LogEvent event) {
        record(event, Level.ERROR);
    }

    public void trace(LogEvent event) {
        record(event, Level.TRACE);
    }

    private void record(LogEvent event, Level level) {
        if (!shouldRecord(level)) return;
        event.setLogger(this);
        event.setWhen(new Date());
        event.setLevel(level);

        addEvents(event);
    }

    void addEvents(LogEvent event) {
        //this.events.add(event);
        //writeImmediately(event);
        for (LogWriter lw : logWriters) {
            if (!lw.isWriteImmediately()) lw.addEvent(event);
            else {
                List<LogEvent> temp = new ArrayList<LogEvent>();
                temp.add(event);
                try {
                    lw.writeLog(temp);
                } catch (LogException e) {
                    LoggerConfig.writeInfo(e);
                }
            }
        }
        setChanged();
        notifyObservers(event);
    }

    /* private void writeImmediately(LogEvent event) {
        for (LogWriter lw : logWriters) {
            if (!lw.isWriteImmediately()) return;
            List<LogEvent> temp = CommonUtil.arrayToList(new Object[]{event});
            try {
                lw.writeLog(temp);
            } catch (LogException e) {
                LoggerConfig.writeInfo(e);
            }
        }
    }*/

    /*private synchronized List<LogEvent> handleEvent() {
        List<LogEvent> temp = new ArrayList<LogEvent>();
        for (LogEvent e : this.events) temp.add(e);
        events.clear();
        return temp;
    }*/

    /* void write() {
        List<LogEvent> temp = handleEvent();
        for (LogWriter lw : logWriters) {
            try {
                lw.writeLog(temp);
            } catch (LogException e1) {
                LoggerConfig.writeInfo(e1);
            }
        }
    }*/


    public List<LogWriter> getLogWriters() {
        return logWriters;
    }

    public void setLogWriters(List<LogWriter> logWriters) {
        if (logWriters == null) return;
        this.logWriters = logWriters;
    }

    public String toString() {
        return "Logger{" +
                "sign='" + sign + '\'' +
                '}';
    }

    public String getSign() {
        return sign;
    }
}