通过自定制LogManager实现程序完全自定义的logger

if not exist "%CATALINA_HOME%\bin\tomcat-juli.jar" goto noJuli
set JAVA_OPTS=%JAVA_OPTS% -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djava.util.logging.config.file="%CATALINA_BASE%\conf\logging.properties"

package com.bes.logging;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;
public class ServerLogManager extends LogManager {
	private static ServerFileHandler handlerSingleton;
	private static ServerLogManager thisInstance;
	private Object lockObj = new Object();
	public ServerLogManager() {
		super();
	}
	public static synchronized ServerLogManager getInstance() {
		if (thisInstance == null) {
			thisInstance = new ServerLogManager();
		}
		return thisInstance;
	}
	public boolean addLogger(Logger logger) {
		boolean result = super.addLogger(logger);
		 //initialize Logger
		if (logger.getResourceBundleName() == null) {
			try {
				Logger newLogger = Logger.getLogger(logger.getName(),
						getLoggerResourceBundleName(logger.getName()));
				assert (logger == newLogger);
			} catch (Throwable ex) {
				//ex.printStackTrace();
			}
		}
		synchronized (lockObj) {
			internalInitializeLogger(logger);
		}
		return result;
	}
	/**
	 * Internal Method to initialize a list of unitialized loggers.
	 */
	private void internalInitializeLogger(final Logger logger) {
		// Explicitly remove all handlers.
		Handler[] h = logger.getHandlers();
		for (int i = 0; i < h.length; i++) {
			logger.removeHandler(h[i]);
		}
		logger.addHandler(getServerFileHandler());
		logger.setUseParentHandlers(false);
		logger.setLevel(Level.FINEST);// only for test
	}
	private static synchronized Handler getServerFileHandler() {
		if (handlerSingleton == null) {
			try {
				handlerSingleton = ServerFileHandler.getInstance();
				handlerSingleton.setLevel(Level.ALL);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return handlerSingleton;
	}
	public String getLoggerResourceBundleName(String loggerName) {
		String result = loggerName + "." + "LogStrings";
		return result;
	}
}

package com.bes.logging;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;
public class ServerFileHandler extends StreamHandler {
  private WrapperStream wrappedStream;
  private String absoluteFileName = null;
  static final String LOG_FILENAME_PREFIX = "server";
  static final String LOG_FILENAME_SUFFIX = ".log";
  private String logFileName = LOG_FILENAME_PREFIX + LOG_FILENAME_SUFFIX;
  public static final ServerFileHandler thisInstance = new ServerFileHandler();
  public static synchronized ServerFileHandler getInstance() {
    return thisInstance;
  }
  protected ServerFileHandler() {
    try {
      setFormatter(new UniformLogFormatter());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  public synchronized void publish(LogRecord record) {
    if (wrappedStream == null) {
      try {
        absoluteFileName = createFileName();
        openFile(absoluteFileName);
      } catch (Exception e) {
        throw new RuntimeException(
            "Serious Error Couldn't open Log File" + e);
      }
    }
    super.publish(record);
    flush();
  }
  public String createFileName() {
    String instDir = "";
    instDir = System.getProperty("com.bes.instanceRoot");
    if(instDir == null || "".equals(instDir)){
      instDir = ".";
    }
    return instDir + "/" + getLogFileName();
  }
  /**
   * Creates the file and initialized WrapperStream and passes it on to
   * Superclass (java.util.logging.StreamHandler).
   */
  private void openFile(String fileName) throws IOException {
    File file = new File(fileName);
    if(!file.exists()){
      if(file.getParentFile() != null && !file.getParentFile().exists()){
        file.getParentFile().mkdir();
      }
      file.createNewFile();
    }
    FileOutputStream fout = new FileOutputStream(fileName, true);
    BufferedOutputStream bout = new BufferedOutputStream(fout);
    wrappedStream = new WrapperStream(bout, file.length());
    setOutputStream(wrappedStream);
  }
  private class WrapperStream extends OutputStream {
    OutputStream out;
    long written;
    WrapperStream(OutputStream out, long written) {
      this.out = out;
      this.written = written;
    }
    public void write(int b) throws IOException {
      out.write(b);
      written++;
    }
    public void write(byte buff[]) throws IOException {
      out.write(buff);
      written += buff.length;
    }
    public void write(byte buff[], int off, int len) throws IOException {
      out.write(buff, off, len);
      written += len;
    }
    public void flush() throws IOException {
      out.flush();
    }
    public void close() throws IOException {
      out.close();
    }
  }
  protected String getLogFileName() {
    return logFileName;
  }
}

package com.bes.logging;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.ResourceBundle;
import java.util.logging.Formatter;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
public class UniformLogFormatter extends Formatter {
  private Date date = new Date();
  private HashMap loggerResourceBundleTable;
  private LogManager logManager;
  private static final char FIELD_SEPARATOR = '|';
  private static final String CRLF = System.getProperty("line.separator");
  private static final SimpleDateFormat dateFormatter = new SimpleDateFormat(
      "yyyy-MM-dd'T'HH:mm:ss.SSSZ");
  public UniformLogFormatter() {
    super();
    loggerResourceBundleTable = new HashMap();
    logManager = LogManager.getLogManager();
  }
  public String format(LogRecord record) {
    return uniformLogFormat(record);
  }
  private String uniformLogFormat(LogRecord record) {
    try {
      String logMessage = record.getMessage();
      int msgLength = 150; // typical length of log record
      if (logMessage != null)
        msgLength += logMessage.length();
      StringBuilder recordBuffer = new StringBuilder(msgLength);
      // add date to log
      date.setTime(record.getMillis());
      recordBuffer.append(dateFormatter.format(date)).append(
          FIELD_SEPARATOR);
      // add log level and logger name to log
      recordBuffer.append(record.getLevel()).append(FIELD_SEPARATOR);
      recordBuffer.append(record.getLoggerName()).append(FIELD_SEPARATOR);
      if (logMessage == null) {
        logMessage = "The log message is null.";
      }
      if (logMessage.indexOf("{0}") >= 0) {
        try {
          logMessage = java.text.MessageFormat.format(logMessage,
              record.getParameters());
        } catch (Exception e) {
          // e.printStackTrace();
        }
      } else {
        ResourceBundle rb = getResourceBundle(record.getLoggerName());
        if (rb != null) {
          try {
            logMessage = MessageFormat.format(
                rb.getString(logMessage),
                record.getParameters());
          } catch (java.util.MissingResourceException e) {
          }
        }
      }
      recordBuffer.append(logMessage);
      recordBuffer.append(CRLF);
      return recordBuffer.toString();
    } catch (Exception ex) {
      return "Log error occurred on msg: " + record.getMessage() + ": "
          + ex;
    }
  }
  private synchronized ResourceBundle getResourceBundle(String loggerName) {
    if (loggerName == null) {
      return null;
    }
    ResourceBundle rb = (ResourceBundle) loggerResourceBundleTable
        .get(loggerName);
    if (rb == null) {
      rb = logManager.getLogger(loggerName).getResourceBundle();
      loggerResourceBundleTable.put(loggerName, rb);
    }
    return rb;
  }
}