loggableobject.java

jbpm的demo,带有流程设计

		checkLogger();
		log.info(mh(message));
	}

	/**
	 * <p>
	 * Log an error with info log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void info(Object message, Throwable throwable) {
		checkLogger();
		log.info(mh(message), throwable);
	}

	/**
	 * <p>
	 * Log a message with warn log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 */
	public void warn(String methodName, Object message) {
		checkLogger();
		log.warn(mh(methodName, message));
	}

	/**
	 * <p>
	 * Log an error with warn log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void warn(String methodName, Object message, Throwable throwable) {
		checkLogger();
		log.warn(mh(methodName, message), throwable);
	}

	/**
	 * <p>
	 * Log a message with warn log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 */
	public void warn(Object message) {
		checkLogger();
		log.warn(mh(message));
	}

	/**
	 * <p>
	 * Log an error with warn log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void warn(Object message, Throwable throwable) {
		checkLogger();
		log.warn(mh(message), throwable);
	}

	/**
	 * <p>
	 * Log a message with error log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 */
	public void error(String methodName, Object message) {
		checkLogger();
		log.error(mh(methodName, message));
	}

	/**
	 * <p>
	 * Log an error with error log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void error(String methodName, Object message, Throwable throwable) {
		checkLogger();
		log.error(mh(methodName, message), throwable);
	}

	/**
	 * <p>
	 * Log a message with error log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 */
	public void error(Object message) {
		checkLogger();
		log.error(mh(message));
	}

	/**
	 * <p>
	 * Log an error with error log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void error(Object message, Throwable throwable) {
		checkLogger();
		log.error(mh(message), throwable);
	}

	/**
	 * <p>
	 * Log a message with fatal log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 */
	public void fatal(String methodName, Object message) {
		checkLogger();
		log.fatal(mh(methodName, message));
	}

	/**
	 * <p>
	 * Log an error with fatal log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void fatal(String methodName, Object message, Throwable throwable) {
		checkLogger();
		log.fatal(mh(methodName, message), throwable);
	}

	/**
	 * <p>
	 * Log a message with fatal log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 */
	public void fatal(Object message) {
		checkLogger();
		log.fatal(mh(message));
	}

	/**
	 * <p>
	 * Log an error with fatal log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void fatal(Object message, Throwable throwable) {
		checkLogger();
		log.fatal(mh(message), throwable);
	}

	/**
	 * <p>
	 * Log a message with suicide log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 */
	public void suicide(String methodName, Object message) {
		checkLogger();
		log.fatal(mh(methodName, message));
		commitSuicide();
	}

	/**
	 * <p>
	 * Log an error with suicide log level.
	 * </p>
	 * 
	 * @param methodName
	 *            The name of the method that issued this message.
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void suicide(String methodName, Object message, Throwable throwable) {
		checkLogger();
		log.fatal(mh(methodName, message), throwable);
		commitSuicide();
	}

	/**
	 * <p>
	 * Log a message with suicide log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 */
	public void suicide(Object message) {
		checkLogger();
		log.fatal(mh(message));
		commitSuicide();
	}

	/**
	 * <p>
	 * Log an error with suicide log level.
	 * </p>
	 * 
	 * @param message
	 *            The log message.
	 * @param throwable
	 *            The cause for this message.
	 */
	public void suicide(Object message, Throwable throwable) {
		checkLogger();
		log.fatal(mh(message), throwable);
		commitSuicide();
	}

	/**
	 * ....when he might himself his quietus make with a bare bodkin....
	 */
	private void commitSuicide() {
		String mn = "commitSuicide";
		fatal(mn, "committing suicide...");
		fatal(mn, "Goodbye, cruel world !");
		System.exit(1);
	}

	/**
	 * Checks the Logger. This method is called before every log delegation to
	 * the underlying logger. This is necessary after an unmarshalling process
	 * in object serialization.
	 */
	private void checkLogger() {
		if (log != null)
			return;
		LogFactory logFactory = LogFactory.getFactory();
		log = logFactory.getInstance(logName);
	}

	/**
	 * Initializes the Logger.
	 * 
	 * @param logName
	 *            The name of the logger.
	 */
	private void initLogger(String logName) {
		LoggingConfigurator.configure();

		this.logName = logName;
		int dotPos = logName.lastIndexOf('.');
		if (dotPos < 0) {
			shortLogName = logName;
		} else {
			shortLogName = logName.substring(dotPos + 1);
		}
		checkLogger();
	}

	/**
	 * Creates an instance from a logger name.
	 * 
	 * @param logName
	 *            The name of a logger.
	 */
	public LoggableObject(String logName) {
		initLogger(logName);
	}

	/**
	 * Creates an instance from a class name.
	 * 
	 * @param clazz
	 *            The class whose name is used as logger name.
	 */
	public LoggableObject(Class clazz) {
		initLogger(clazz.getName());
	}

	/**
	 * Creates an instance from an object.
	 * 
	 * @param object
	 *            The object whose class name is used as logger name.
	 */
	public LoggableObject(Object object) {
		initLogger(object.getClass().getName());
	}

	/**
	 * Creates an instance.
	 */
	public LoggableObject() {
		initLogger(getClass().getName());
	}

	/**
	 * Generates the textual representation of this instance.
	 * 
	 * @return The String representation.
	 */
	public String toString() {
		StringBuffer envelope = new StringBuffer(shortLogName);
		StringBuffer sb = new StringBuffer();
		toStringAppend(sb);
		if (sb.length() > 0) {
			envelope.append('[');
			envelope.append(sb.toString());
			envelope.append(']');
		}
		String result = envelope.toString();
		envelope.setLength(0);
		sb.setLength(0);
		return result;
	}

	/**
	 * This methods accumulates the content of the text representations.
	 * Sub-classes of LoggableObject should override this method by the
	 * following statement order:
	 * <code>protected void toStringAppend(StringBuffer sb);</code><br>
	 * <code>&nbsp;&nbsp; super.toStringAppend(sb);</code><br>
	 * <code>&nbsp;&nbsp; toStringStartComma(sb);</code><br>
	 * <code>&nbsp;&nbsp; sb.append("foo=",foo);</code><br>
	 * <code>&nbsp;&nbsp; sb.append(",bar=",bar);</code><br>
	 * <code>}</code><br>
	 * 
	 * @param sb
	 *            The StringBuffer that accumulates the content.
	 */
	protected void toStringAppend(StringBuffer sb) {
	}

	/**
	 * Appends a separation comma to the StringBuffer argument if the buffer is
	 * not empty.
	 * 
	 * @param sb
	 *            The StringBuffer that accumulates the content.
	 */
	protected final void toStringStartComma(StringBuffer sb) {
		if (sb.length() > 0)
			sb.append(',');
	}
}