HMCL 2.3.2

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/AppenderControl.java

@@ -0,0 +1,59 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging;
+
+import org.jackhuang.hellominecraft.logging.appender.IAppender;
+
+public class AppenderControl {
+
+    private final ThreadLocal<AppenderControl> recursive = new ThreadLocal();
+    private final IAppender appender;
+    private final Level level;
+    private final int intLevel;
+
+    public AppenderControl(IAppender appender, Level level) {
+	this.appender = appender;
+	this.level = level;
+	this.intLevel = (level == null ? Level.ALL.level : level.level);
+    }
+
+    public IAppender getAppender() {
+	return this.appender;
+    }
+
+    public void callAppender(LogEvent event) {
+	if ((this.level != null)
+		&& (this.intLevel < event.level.level)) {
+	    return;
+	}
+
+	if (this.recursive.get() != null) {
+	    System.err.println("Recursive call to appender " + this.appender.getName());
+	    return;
+	}
+	try {
+	    this.recursive.set(this);
+
+	    try {
+		this.appender.append(event);
+	    } catch (RuntimeException ex) {
+		System.err.println("An exception occurred processing Appender " + this.appender.getName());
+		ex.printStackTrace();
+		if (!this.appender.ignoreExceptions()) {
+		    throw ex;
+		}
+	    } catch (Exception ex) {
+		System.err.println("An exception occurred processing Appender " + this.appender.getName());
+		ex.printStackTrace();
+		if (!this.appender.ignoreExceptions()) {
+		    throw new LoggingException(ex);
+		}
+	    }
+	} finally {
+	    this.recursive.set(null);
+	}
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/Configuration.java

@@ -0,0 +1,30 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging;
+
+import java.util.ArrayList;
+import org.jackhuang.hellominecraft.logging.appender.ConsoleAppender;
+import org.jackhuang.hellominecraft.logging.appender.IAppender;
+import org.jackhuang.hellominecraft.logging.layout.DefaultLayout;
+
+/**
+ *
+ * @author hyh
+ */
+
+public class Configuration {
+    
+    public ArrayList<IAppender> appenders = new ArrayList<IAppender>();
+    
+    public static Configuration DEFAULT;
+    
+    static {
+	DEFAULT = new Configuration();
+	DEFAULT.appenders.add(new ConsoleAppender("Console", new DefaultLayout(), true, new ConsoleAppender.SystemOutStream(), true));
+    }
+    
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/Level.java

@@ -0,0 +1,37 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging;
+
+/**
+ *
+ * @author hyh
+ */
+public enum Level {
+
+    OFF(0),
+    FATAL(1),
+    ERROR(2),
+    WARN(3),
+    INFO(4),
+    DEBUG(5),
+    TRACE(6),
+    ALL(2147483647);
+
+    public final int level;
+
+    private Level(int i) {
+	level = i;
+    }
+
+    public boolean lessOrEqual(Level level) {
+	return this.level <= level.level;
+    }
+
+    public boolean lessOrEqual(int level) {
+	return this.level <= level;
+    }
+
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/LogEvent.java

@@ -0,0 +1,22 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging;
+
+import org.jackhuang.hellominecraft.logging.message.IMessage;
+
+/**
+ *
+ * @author hyh
+ */
+public class LogEvent {
+    
+    public Level level;
+    public String threadName;
+    public Throwable thrown;
+    public IMessage message;
+    
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/LoggingException.java

@@ -0,0 +1,19 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging;
+
+/**
+ *
+ * @author hyh
+ */
+public class LoggingException extends RuntimeException {
+
+    public LoggingException(Exception e) {
+	super(e);
+    }
+    
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/appender/AbstractAppender.java

@@ -0,0 +1,45 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.appender;
+
+import java.io.Serializable;
+import org.jackhuang.hellominecraft.logging.layout.ILayout;
+
+/**
+ *
+ * @author hyh
+ */
+public abstract class AbstractAppender implements IAppender {
+
+    String name;
+    private final ILayout<? extends Serializable> layout;
+    private final boolean ignoreExceptions;
+
+    public AbstractAppender(String name, ILayout<? extends Serializable> layout) {
+	this(name, layout, true);
+    }
+
+    public AbstractAppender(String name, ILayout<? extends Serializable> layout, boolean ignoreExceptions) {
+	this.name = name;
+	this.layout = layout;
+	this.ignoreExceptions = ignoreExceptions;
+    }
+
+    @Override
+    public String getName() {
+	return name;
+    }
+
+    @Override
+    public boolean ignoreExceptions() {
+	return ignoreExceptions;
+    }
+
+    @Override
+    public ILayout<? extends Serializable> getLayout() {
+	return this.layout;
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/appender/ConsoleAppender.java

@@ -0,0 +1,78 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.appender;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.Serializable;
+import org.jackhuang.hellominecraft.logging.layout.ILayout;
+
+/**
+ *
+ * @author hyh
+ */
+public class ConsoleAppender extends OutputStreamAppender {
+
+    public ConsoleAppender(String name, ILayout<? extends Serializable> layout, boolean ignoreExceptions, OutputStream stream, boolean immediateFlush) {
+	super(name, layout, ignoreExceptions, stream, true);
+    }
+
+    public static class SystemOutStream extends OutputStream {
+
+	@Override
+	public void close() {
+	}
+
+	@Override
+	public void flush() {
+	    System.out.flush();
+	}
+
+	@Override
+	public void write(byte[] b) throws IOException {
+	    System.out.write(b);
+	}
+
+	@Override
+	public void write(byte[] b, int off, int len)
+		throws IOException {
+	    System.out.write(b, off, len);
+	}
+
+	@Override
+	public void write(int b) throws IOException {
+	    System.out.write(b);
+	}
+    }
+
+    public static class SystemErrStream extends OutputStream {
+
+	@Override
+	public void close() {
+	}
+
+	@Override
+	public void flush() {
+	    System.err.flush();
+	}
+
+	@Override
+	public void write(byte[] b) throws IOException {
+	    System.err.write(b);
+	}
+
+	@Override
+	public void write(byte[] b, int off, int len)
+		throws IOException {
+	    System.err.write(b, off, len);
+	}
+
+	@Override
+	public void write(int b) {
+	    System.err.write(b);
+	}
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/appender/IAppender.java

@@ -0,0 +1,24 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging.appender;
+
+import java.io.Serializable;
+import org.jackhuang.hellominecraft.logging.LogEvent;
+import org.jackhuang.hellominecraft.logging.layout.ILayout;
+
+/**
+ *
+ * @author hyh
+ */
+public interface IAppender {
+    
+    void append(LogEvent event);
+    String getName();
+    boolean ignoreExceptions();
+    ILayout<? extends Serializable> getLayout();
+    
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/appender/OutputStreamAppender.java

@@ -0,0 +1,52 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.appender;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.Serializable;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import org.jackhuang.hellominecraft.logging.LogEvent;
+import org.jackhuang.hellominecraft.logging.LoggingException;
+import org.jackhuang.hellominecraft.logging.layout.ILayout;
+
+/**
+ *
+ * @author hyh
+ */
+public abstract class OutputStreamAppender extends AbstractAppender {
+
+    protected final OutputStream stream;
+    protected final boolean immediateFlush;
+    private final Lock readLock = new ReentrantReadWriteLock().readLock();
+
+    public OutputStreamAppender(String name, ILayout<? extends Serializable> layout, boolean ignoreExceptions, OutputStream stream, boolean immediateFlush) {
+	super(name, layout, ignoreExceptions);
+
+	this.immediateFlush = immediateFlush;
+	this.stream = stream;
+    }
+
+    @Override
+    public void append(LogEvent event) {
+	this.readLock.lock();
+	try {
+	    byte[] bytes = getLayout().toByteArray(event);
+	    if (bytes.length > 0) {
+		stream.write(bytes);
+	    }
+	    if(event.thrown != null)
+		event.thrown.printStackTrace(new PrintStream(stream));
+	} catch (IOException ex) {
+	    System.err.println("Unable to write to stream for appender: " + getName());
+	    throw new LoggingException(ex);
+	} finally {
+	    this.readLock.unlock();
+	}
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/layout/AbstractStringLayout.java

@@ -0,0 +1,22 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging.layout;
+
+import org.jackhuang.hellominecraft.logging.LogEvent;
+
+/**
+ *
+ * @author hyh
+ */
+public abstract class AbstractStringLayout implements ILayout<String> {
+
+    @Override
+    public byte[] toByteArray(LogEvent event) {
+	return toSerializable(event).getBytes();
+    }
+    
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/layout/DefaultLayout.java

@@ -0,0 +1,25 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging.layout;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import org.jackhuang.hellominecraft.logging.LogEvent;
+
+/**
+ *
+ * @author hyh
+ */
+public class DefaultLayout extends AbstractStringLayout {
+    private static final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
+
+    @Override
+    public String toSerializable(LogEvent event) {
+	return "[" + sdf.format(new Date()) + "][" + event.threadName + "/" + event.level.name() + "] " + event.message.getFormattedMessage() + "\n";
+    }
+    
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/layout/ILayout.java

@@ -0,0 +1,22 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging.layout;
+
+import java.io.Serializable;
+import org.jackhuang.hellominecraft.logging.LogEvent;
+
+/**
+ *
+ * @author hyh
+ * @param <T>
+ */
+public interface ILayout<T extends Serializable> {
+    
+    byte[] toByteArray(LogEvent event);
+    T toSerializable(LogEvent event);
+    
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/logger/AbstractLogger.java

@@ -0,0 +1,523 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.logger;
+
+import org.jackhuang.hellominecraft.logging.Level;
+import org.jackhuang.hellominecraft.logging.message.IMessage;
+import org.jackhuang.hellominecraft.logging.message.IMessageFactory;
+import org.jackhuang.hellominecraft.logging.message.ParameterizedMessageFactory;
+import org.jackhuang.hellominecraft.logging.message.StringFormattedMessage;
+
+public abstract class AbstractLogger
+	implements ILogger {
+
+    public static final Class<? extends IMessageFactory> DEFAULT_MESSAGE_FACTORY_CLASS = ParameterizedMessageFactory.class;
+
+    private static final String FQCN = AbstractLogger.class.getName();
+    private static final String THROWING = "throwing";
+    private static final String CATCHING = "catching";
+    private final String name;
+    private final IMessageFactory messageFactory;
+
+    public AbstractLogger() {
+	this.name = getClass().getName();
+	this.messageFactory = createDefaultMessageFactory();
+    }
+
+    public AbstractLogger(String name) {
+	this.name = name;
+	this.messageFactory = createDefaultMessageFactory();
+    }
+
+    public AbstractLogger(String name, IMessageFactory messageFactory) {
+	this.name = name;
+	this.messageFactory = (messageFactory == null ? createDefaultMessageFactory() : messageFactory);
+    }
+
+    private IMessageFactory createDefaultMessageFactory() {
+	try {
+	    return (IMessageFactory) DEFAULT_MESSAGE_FACTORY_CLASS.newInstance();
+	} catch (InstantiationException e) {
+	    throw new IllegalStateException(e);
+	} catch (IllegalAccessException e) {
+	    throw new IllegalStateException(e);
+	}
+    }
+
+    @Override
+    public void catching(Level level, Throwable t) {
+	if (isEnabled(level, (Object) null, null)) {
+	    log(level, this.messageFactory.newMessage(CATCHING), t);
+	}
+    }
+
+    @Override
+    public void catching(Throwable t) {
+	catching(Level.ERROR, t);
+    }
+
+    @Override
+    public void debug(IMessage msg) {
+	if (isEnabled(Level.DEBUG, msg, null)) {
+	    log(Level.DEBUG, msg, null);
+	}
+    }
+
+    @Override
+    public void debug(IMessage msg, Throwable t) {
+	if (isEnabled(Level.DEBUG, msg, t)) {
+	    log(Level.DEBUG, msg, t);
+	}
+    }
+
+    @Override
+    public void debug(Object message) {
+	if (isEnabled(Level.DEBUG, message, null)) {
+	    log(Level.DEBUG, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void debug(Object message, Throwable t) {
+	if (isEnabled(Level.DEBUG, message, t)) {
+	    log(Level.DEBUG, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void debug(String message) {
+	if (isEnabled(Level.DEBUG, message)) {
+	    log(Level.DEBUG, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void debug(String message, Object[] params) {
+	if (isEnabled(Level.DEBUG, message, params)) {
+	    IMessage msg = this.messageFactory.newMessage(message, params);
+	    log(Level.DEBUG, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public void debug(String message, Throwable t) {
+	if (isEnabled(Level.DEBUG, message, t)) {
+	    log(Level.DEBUG, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void entry() {
+	entry(new Object[0]);
+    }
+
+    @Override
+    public void entry(Object[] params) {
+	if (isEnabled(Level.TRACE, (Object) null, null)) {
+	    log(Level.TRACE, entryMsg(params.length, params), null);
+	}
+    }
+
+    private IMessage entryMsg(int count, Object[] params) {
+	if (count == 0) {
+	    return this.messageFactory.newMessage("entry");
+	}
+	StringBuilder sb = new StringBuilder("entry params(");
+	int i = 0;
+	for (Object parm : params) {
+	    if (parm != null) {
+		sb.append(parm.toString());
+	    } else {
+		sb.append("null");
+	    }
+	    i++;
+	    if (i < params.length) {
+		sb.append(", ");
+	    }
+	}
+	sb.append(")");
+	return this.messageFactory.newMessage(sb.toString());
+    }
+
+    @Override
+    public void error(IMessage msg) {
+	if (isEnabled(Level.ERROR, msg, null)) {
+	    log(Level.ERROR, msg, null);
+	}
+    }
+
+    @Override
+    public void error(IMessage msg, Throwable t) {
+	if (isEnabled(Level.ERROR, msg, t)) {
+	    log(Level.ERROR, msg, t);
+	}
+    }
+
+    @Override
+    public void error(Object message) {
+	if (isEnabled(Level.ERROR, message, null)) {
+	    log(Level.ERROR, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void error(Object message, Throwable t) {
+	if (isEnabled(Level.ERROR, message, t)) {
+	    log(Level.ERROR, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void error(String message) {
+	if (isEnabled(Level.ERROR, message)) {
+	    log(Level.ERROR, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void error(String message, Object[] params) {
+	if (isEnabled(Level.ERROR, message, params)) {
+	    IMessage msg = this.messageFactory.newMessage(message, params);
+	    log(Level.ERROR, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public void error(String message, Throwable t) {
+	if (isEnabled(Level.ERROR, message, t)) {
+	    log(Level.ERROR, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void fatal(IMessage msg) {
+	if (isEnabled(Level.FATAL, msg, null)) {
+	    log(Level.FATAL, msg, null);
+	}
+    }
+
+    @Override
+    public void fatal(IMessage msg, Throwable t) {
+	if (isEnabled(Level.FATAL, msg, t)) {
+	    log(Level.FATAL, msg, t);
+	}
+    }
+
+    @Override
+    public void fatal(Object message) {
+	if (isEnabled(Level.FATAL, message, null)) {
+	    log(Level.FATAL, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void fatal(Object message, Throwable t) {
+	if (isEnabled(Level.FATAL, message, t)) {
+	    log(Level.FATAL, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void fatal(String message) {
+	if (isEnabled(Level.FATAL, message)) {
+	    log(Level.FATAL, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void fatal(String message, Object[] params) {
+	if (isEnabled(Level.FATAL, message, params)) {
+	    IMessage msg = this.messageFactory.newMessage(message, params);
+	    log(Level.FATAL, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public void fatal(String message, Throwable t) {
+	if (isEnabled(Level.FATAL, message, t)) {
+	    log(Level.FATAL, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public String getName() {
+	return this.name;
+    }
+
+    @Override
+    public void info(IMessage msg) {
+	if (isEnabled(Level.INFO, msg, null)) {
+	    log(Level.INFO, msg, null);
+	}
+    }
+
+    @Override
+    public void info(IMessage msg, Throwable t) {
+	if (isEnabled(Level.INFO, msg, t)) {
+	    log(Level.INFO, msg, t);
+	}
+    }
+
+    @Override
+    public void info(Object message) {
+	if (isEnabled(Level.INFO, message, null)) {
+	    log(Level.INFO, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void info(Object message, Throwable t) {
+	if (isEnabled(Level.INFO, message, t)) {
+	    log(Level.INFO, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void info(String message) {
+	if (isEnabled(Level.INFO, message)) {
+	    log(Level.INFO, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void info(String message, Object[] params) {
+	if (isEnabled(Level.INFO, message, params)) {
+	    IMessage msg = this.messageFactory.newMessage(message, params);
+	    log(Level.INFO, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public void info(String message, Throwable t) {
+	if (isEnabled(Level.INFO, message, t)) {
+	    log(Level.INFO, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    protected abstract boolean isEnabled(Level paramLevel, IMessage paramIMessage, Throwable paramThrowable);
+
+    protected abstract boolean isEnabled(Level paramLevel, Object paramObject, Throwable paramThrowable);
+
+    protected abstract boolean isEnabled(Level paramLevel, String paramString);
+
+    protected abstract boolean isEnabled(Level paramLevel, String paramString, Object[] paramArrayOfObject);
+
+    protected abstract boolean isEnabled(Level paramLevel, String paramString, Throwable paramThrowable);
+
+    protected abstract void abstractLog(Level level, IMessage msg, Throwable t);
+
+    @Override
+    public boolean isErrorEnabled() {
+	return isEnabled(Level.ERROR);
+    }
+
+    @Override
+
+    public boolean isFatalEnabled() {
+	return isEnabled(Level.FATAL);
+    }
+
+    @Override
+    public boolean isInfoEnabled() {
+	return isEnabled(Level.INFO);
+    }
+
+    @Override
+    public boolean isTraceEnabled() {
+	return isEnabled(Level.TRACE);
+    }
+
+    @Override
+    public boolean isWarnEnabled() {
+	return isEnabled(Level.WARN);
+    }
+
+    @Override
+    public boolean isDebugEnabled() {
+	return isEnabled(Level.DEBUG);
+    }
+
+    @Override
+    public boolean isEnabled(Level level) {
+	return isEnabled(level, (Object) null, null);
+    }
+
+    @Override
+    public void log(Level level, IMessage msg) {
+	if (isEnabled(level, msg, null)) {
+	    log(level, msg, null);
+	}
+    }
+
+    @Override
+    public void log(Level level, IMessage msg, Throwable t) {
+	if (isEnabled(level, msg, t)) {
+	    abstractLog(level, msg, t);
+	}
+    }
+
+    @Override
+    public void log(Level level, Object message) {
+	if (isEnabled(level, message, null)) {
+	    log(level, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void log(Level level, Object message, Throwable t) {
+	if (isEnabled(level, message, t)) {
+	    log(level, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void log(Level level, String message) {
+	if (isEnabled(level, message)) {
+	    log(level, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void log(Level level, String message, Object[] params) {
+	if (isEnabled(level, message, params)) {
+	    IMessage msg = this.messageFactory.newMessage(message, params);
+	    log(level, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public void log(Level level, String message, Throwable t) {
+	if (isEnabled(level, message, t)) {
+	    log(level, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void printf(Level level, String format, Object[] params) {
+	if (isEnabled(level, format, params)) {
+	    IMessage msg = new StringFormattedMessage(format, params);
+	    log(level, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public <T extends Throwable> T throwing(T t) {
+	return throwing(Level.ERROR, t);
+    }
+
+    @Override
+    public <T extends Throwable> T throwing(Level level, T t) {
+	if (isEnabled(level, (Object) null, null)) {
+	    log(level, this.messageFactory.newMessage(THROWING), t);
+	}
+	return t;
+    }
+
+    @Override
+    public String toString() {
+	return this.name;
+    }
+
+    @Override
+    public void trace(IMessage msg) {
+	if (isEnabled(Level.TRACE, msg, null)) {
+	    log(Level.TRACE, msg, null);
+	}
+    }
+
+    @Override
+    public void trace(IMessage msg, Throwable t) {
+	if (isEnabled(Level.TRACE, msg, t)) {
+	    log(Level.TRACE, msg, t);
+	}
+    }
+
+    @Override
+    public void trace(Object message) {
+	if (isEnabled(Level.TRACE, message, null)) {
+	    log(Level.TRACE, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void trace(Object message, Throwable t) {
+	if (isEnabled(Level.TRACE, message, t)) {
+	    log(Level.TRACE, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void trace(String message) {
+	if (isEnabled(Level.TRACE, message)) {
+	    log(Level.TRACE, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void trace(String message, Object[] params) {
+	if (isEnabled(Level.TRACE, message, params)) {
+	    IMessage msg = this.messageFactory.newMessage(message, params);
+	    log(Level.TRACE, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public void trace(String message, Throwable t) {
+	if (isEnabled(Level.TRACE, message, t)) {
+	    log(Level.TRACE, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void warn(IMessage msg) {
+	if (isEnabled(Level.WARN, msg, null)) {
+	    log(Level.WARN, msg, null);
+	}
+    }
+
+    @Override
+    public void warn(IMessage msg, Throwable t) {
+	if (isEnabled(Level.WARN, msg, t)) {
+	    log(Level.WARN, msg, t);
+	}
+    }
+
+    @Override
+    public void warn(Object message) {
+	if (isEnabled(Level.WARN, message, null)) {
+	    log(Level.WARN, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void warn(Object message, Throwable t) {
+	if (isEnabled(Level.WARN, message, t)) {
+	    log(Level.WARN, this.messageFactory.newMessage(message), t);
+	}
+    }
+
+    @Override
+    public void warn(String message) {
+	if (isEnabled(Level.WARN, message)) {
+	    log(Level.WARN, this.messageFactory.newMessage(message), null);
+	}
+    }
+
+    @Override
+    public void warn(String message, Object[] params) {
+	if (isEnabled(Level.WARN, message, params)) {
+	    IMessage msg = this.messageFactory.newMessage(message, params);
+	    log(Level.WARN, msg, msg.getThrowable());
+	}
+    }
+
+    @Override
+    public void warn(String message, Throwable t) {
+	if (isEnabled(Level.WARN, message, t)) {
+	    log(Level.WARN, this.messageFactory.newMessage(message), t);
+	}
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/logger/ILogger.java

@@ -0,0 +1,146 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging.logger;
+
+import org.jackhuang.hellominecraft.logging.Level;
+import org.jackhuang.hellominecraft.logging.message.IMessage;
+
+/**
+ *
+ * @author hyh
+ */
+public interface ILogger {
+    
+  void catching(Level paramLevel, Throwable paramThrowable);
+
+  void catching(Throwable paramThrowable);
+
+  void debug(IMessage paramIMessage);
+
+  void debug(IMessage paramIMessage, Throwable paramThrowable);
+
+  void debug(Object paramObject);
+
+  void debug(Object paramObject, Throwable paramThrowable);
+
+  void debug(String paramString);
+
+  void debug(String paramString, Object[] paramArrayOfObject);
+
+  void debug(String paramString, Throwable paramThrowable);
+
+  void entry();
+
+  void entry(Object[] paramArrayOfObject);
+
+  void error(IMessage paramIMessage);
+
+  void error(IMessage paramIMessage, Throwable paramThrowable);
+
+  void error(Object paramObject);
+
+  void error(Object paramObject, Throwable paramThrowable);
+
+  void error(String paramString);
+
+  void error(String paramString, Object[] paramArrayOfObject);
+
+  void error(String paramString, Throwable paramThrowable);
+
+  void fatal(IMessage paramIMessage);
+
+  void fatal(IMessage paramIMessage, Throwable paramThrowable);
+
+  void fatal(Object paramObject);
+
+  void fatal(Object paramObject, Throwable paramThrowable);
+
+  void fatal(String paramString);
+
+  void fatal(String paramString, Object[] paramArrayOfObject);
+
+  void fatal(String paramString, Throwable paramThrowable);
+
+  String getName();
+
+  void info(IMessage paramIMessage);
+
+  void info(IMessage paramIMessage, Throwable paramThrowable);
+
+  void info(Object paramObject);
+
+  void info(Object paramObject, Throwable paramThrowable);
+
+  void info(String paramString);
+
+  void info(String paramString, Object[] paramArrayOfObject);
+
+  void info(String paramString, Throwable paramThrowable);
+
+  boolean isDebugEnabled();
+
+  boolean isEnabled(Level paramLevel);
+
+  boolean isErrorEnabled();
+
+  boolean isFatalEnabled();
+
+  boolean isInfoEnabled();
+
+  boolean isTraceEnabled();
+
+  boolean isWarnEnabled();
+
+  void log(Level paramLevel, IMessage paramIMessage);
+
+  void log(Level paramLevel, IMessage paramIMessage, Throwable paramThrowable);
+
+  void log(Level paramLevel, Object paramObject);
+
+  void log(Level paramLevel, Object paramObject, Throwable paramThrowable);
+
+  void log(Level paramLevel, String paramString);
+
+  void log(Level paramLevel, String paramString, Object[] paramArrayOfObject);
+
+  void log(Level paramLevel, String paramString, Throwable paramThrowable);
+
+  void printf(Level paramLevel, String paramString, Object[] paramArrayOfObject);
+
+  <T extends Throwable> T throwing(Level paramLevel, T paramT);
+
+  <T extends Throwable> T throwing(T paramT);
+
+  void trace(IMessage paramIMessage);
+
+  void trace(IMessage paramIMessage, Throwable paramThrowable);
+
+  void trace(Object paramObject);
+
+  void trace(Object paramObject, Throwable paramThrowable);
+
+  void trace(String paramString);
+
+  void trace(String paramString, Object[] paramArrayOfObject);
+
+  void trace(String paramString, Throwable paramThrowable);
+
+  void warn(IMessage paramIMessage);
+
+  void warn(IMessage paramIMessage, Throwable paramThrowable);
+
+  void warn(Object paramObject);
+
+  void warn(Object paramObject, Throwable paramThrowable);
+
+  void warn(String paramString);
+
+  void warn(String paramString, Object[] paramArrayOfObject);
+
+  void warn(String paramString, Throwable paramThrowable);
+
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/logger/Logger.java

@@ -0,0 +1,156 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.logger;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.jackhuang.hellominecraft.logging.AppenderControl;
+import org.jackhuang.hellominecraft.logging.Configuration;
+import org.jackhuang.hellominecraft.logging.Level;
+import org.jackhuang.hellominecraft.logging.LogEvent;
+import org.jackhuang.hellominecraft.logging.appender.IAppender;
+import org.jackhuang.hellominecraft.logging.message.IMessage;
+import org.jackhuang.hellominecraft.logging.message.IMessageFactory;
+
+public class Logger extends AbstractLogger {
+
+    protected volatile PrivateConfig config;
+    private final Map<String, AppenderControl> appenders = new ConcurrentHashMap();
+    
+    public Logger(String name) {
+	this(name, null, Level.INFO);
+    }
+
+    public Logger(String name, IMessageFactory messageFactory, Level defaultLevel) {
+	super(name, messageFactory);
+	this.config = new PrivateConfig(Configuration.DEFAULT, this, defaultLevel);
+    }
+
+    public synchronized void setLevel(Level level) {
+	if (level != null) {
+	    this.config = new PrivateConfig(this.config, level);
+	}
+    }
+
+    public Level getLevel() {
+	return this.config.level;
+    }
+
+    @Override
+    public void abstractLog(Level level, IMessage data, Throwable t) {
+	LogEvent event = new LogEvent();
+	event.level = level;
+	event.message = data;
+	event.thrown = t;
+	event.threadName = Thread.currentThread().getName();
+
+	log(event);
+    }
+
+    public void log(LogEvent event) {
+	callAppenders(event);
+    }
+
+    protected void callAppenders(LogEvent event) {
+	for (AppenderControl control : this.appenders.values()) {
+	    control.callAppender(event);
+	}
+    }
+
+    @Override
+    public boolean isEnabled(Level level, String msg) {
+	return this.config.filter(level, msg);
+    }
+
+    @Override
+    public boolean isEnabled(Level level, String msg, Throwable t) {
+	return this.config.filter(level, msg, t);
+    }
+
+    @Override
+    public boolean isEnabled(Level level, String msg, Object[] p1) {
+	return this.config.filter(level, msg, p1);
+    }
+
+    @Override
+    public boolean isEnabled(Level level, Object msg, Throwable t) {
+	return this.config.filter(level, msg, t);
+    }
+
+    @Override
+    public boolean isEnabled(Level level, IMessage msg, Throwable t) {
+	return this.config.filter(level, msg, t);
+    }
+
+    public void addAppender(IAppender appender) {
+	this.appenders.put(appender.getName(), new AppenderControl(appender, null));
+    }
+
+    public void removeAppender(IAppender appender) {
+	this.appenders.remove(appender.getName());
+    }
+
+    public Map<String, IAppender> getAppenders() {
+	Map map = new HashMap();
+	for (Map.Entry entry : this.appenders.entrySet()) {
+	    map.put(entry.getKey(), ((AppenderControl) entry.getValue()).getAppender());
+	}
+	return map;
+    }
+
+    public String toString() {
+	String nameLevel = "" + getName() + ":" + getLevel();
+	return nameLevel;
+    }
+
+    protected class PrivateConfig {
+
+	public final Configuration config;
+	private final Level level;
+	private final int intLevel;
+	private final Logger logger;
+
+	public PrivateConfig(Configuration c, Logger logger, Level level) {
+	    this.level = level;
+	    this.intLevel = this.level.level;
+	    this.logger = logger;
+	    
+	    this.config = c;
+	    for(IAppender appender : config.appenders)
+		addAppender(appender);
+	}
+
+	public PrivateConfig(PrivateConfig pc, Level level) {
+	    this(pc.config, pc.logger, level);
+	}
+
+	boolean filter(Level level, String msg) {
+
+	    return this.intLevel >= level.level;
+	}
+
+	boolean filter(Level level, String msg, Throwable t) {
+
+	    return this.intLevel >= level.level;
+	}
+
+	boolean filter(Level level, String msg, Object[] p1) {
+
+	    return this.intLevel >= level.level;
+	}
+
+	boolean filter(Level level, Object msg, Throwable t) {
+
+	    return this.intLevel >= level.level;
+	}
+
+	boolean filter(Level level, IMessage msg, Throwable t) {
+
+	    return this.intLevel >= level.level;
+	}
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/logger/SimpleLogger.java

@@ -0,0 +1,130 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.logger;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import org.jackhuang.hellominecraft.logging.Level;
+import org.jackhuang.hellominecraft.logging.message.IMessage;
+import org.jackhuang.hellominecraft.logging.message.IMessageFactory;
+
+public class SimpleLogger extends AbstractLogger {
+
+    private static final char SPACE = ' ';
+    private DateFormat dateFormatter;
+    private Level level;
+    private final boolean showDateTime;
+    private final boolean showContextMap;
+    private PrintStream stream;
+    private final String logName;
+
+    public SimpleLogger(String name, Level defaultLevel, boolean showLogName, boolean showShortLogName, boolean showDateTime, boolean showContextMap, String dateTimeFormat, IMessageFactory messageFactory, PrintStream stream) {
+	super(name, messageFactory);
+	this.level = defaultLevel;
+	if (showShortLogName) {
+	    int index = name.lastIndexOf(".");
+	    if ((index > 0) && (index < name.length())) {
+		this.logName = name.substring(index + 1);
+	    } else {
+		this.logName = name;
+	    }
+	} else if (showLogName) {
+	    this.logName = name;
+	} else {
+	    this.logName = null;
+	}
+	this.showDateTime = showDateTime;
+	this.showContextMap = showContextMap;
+	this.stream = stream;
+
+	if (showDateTime) {
+	    try {
+		this.dateFormatter = new SimpleDateFormat(dateTimeFormat);
+	    } catch (IllegalArgumentException e) {
+		this.dateFormatter = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss:SSS zzz");
+	    }
+	}
+    }
+
+    public void setStream(PrintStream stream) {
+	this.stream = stream;
+    }
+
+    public Level getLevel() {
+	return this.level;
+    }
+
+    public void setLevel(Level level) {
+	if (level != null) {
+	    this.level = level;
+	}
+    }
+
+    @Override
+    public void abstractLog(Level level, IMessage msg, Throwable throwable) {
+	StringBuilder sb = new StringBuilder();
+
+	if (this.showDateTime) {
+	    Date now = new Date();
+	    String dateText;
+	    synchronized (this.dateFormatter) {
+		dateText = this.dateFormatter.format(now);
+	    }
+	    sb.append(dateText);
+	    sb.append(' ');
+	}
+
+	sb.append(level.toString());
+	sb.append(' ');
+	if ((this.logName != null) && (this.logName.length() > 0)) {
+	    sb.append(this.logName);
+	    sb.append(' ');
+	}
+	sb.append(msg.getFormattedMessage());
+	Object[] params = msg.getParameters();
+	Throwable t;
+	if ((throwable == null) && (params != null) && ((params[(params.length - 1)] instanceof Throwable))) {
+	    t = (Throwable) params[(params.length - 1)];
+	} else {
+	    t = throwable;
+	}
+	if (t != null) {
+	    sb.append(' ');
+	    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+	    t.printStackTrace(new PrintStream(baos));
+	    sb.append(baos.toString());
+	}
+	this.stream.println(sb.toString());
+    }
+
+    @Override
+    protected boolean isEnabled(Level level, String msg) {
+	return this.level.level >= level.level;
+    }
+
+    @Override
+    protected boolean isEnabled(Level level, String msg, Throwable t) {
+	return this.level.level >= level.level;
+    }
+
+    @Override
+    protected boolean isEnabled(Level level, String msg, Object[] p1) {
+	return this.level.level >= level.level;
+    }
+
+    @Override
+    protected boolean isEnabled(Level level, Object msg, Throwable t) {
+	return this.level.level >= level.level;
+    }
+
+    @Override
+    protected boolean isEnabled(Level level, IMessage msg, Throwable t) {
+	return this.level.level >= level.level;
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/AbstractMessageFactory.java

@@ -0,0 +1,24 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.message;
+
+/**
+ *
+ * @author hyh
+ */
+public abstract class AbstractMessageFactory
+	implements IMessageFactory {
+
+    @Override
+    public IMessage newMessage(Object message) {
+	return new ObjectMessage(message);
+    }
+
+    @Override
+    public IMessage newMessage(String message) {
+	return new SimpleMessage(message);
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/IMessage.java

@@ -0,0 +1,20 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.jackhuang.hellominecraft.logging.message;
+
+import java.io.Serializable;
+
+/**
+ *
+ * @author hyh
+ */
+public interface IMessage extends Serializable {
+    String getFormattedMessage();
+    String getFormat();
+    Object[] getParameters();
+    Throwable getThrowable();
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/IMessageFactory.java

@@ -0,0 +1,19 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.message;
+
+/**
+ *
+ * @author hyh
+ */
+public abstract interface IMessageFactory {
+
+    public abstract IMessage newMessage(Object paramObject);
+
+    public abstract IMessage newMessage(String paramString);
+
+    public abstract IMessage newMessage(String paramString, Object[] paramArrayOfObject);
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/ObjectMessage.java

@@ -0,0 +1,64 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.message;
+
+public class ObjectMessage
+        implements IMessage {
+
+    private static final long serialVersionUID = -5903272448334166185L;
+    private transient Object obj;
+
+    public ObjectMessage(Object obj) {
+        if (obj == null) {
+            obj = "null";
+        }
+        this.obj = obj;
+    }
+
+    @Override
+    public String getFormattedMessage() {
+        return this.obj.toString();
+    }
+
+    @Override
+    public String getFormat() {
+        return this.obj.toString();
+    }
+
+    @Override
+    public Object[] getParameters() {
+        return new Object[]{this.obj};
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if ((o == null) || (getClass() != o.getClass())) {
+            return false;
+        }
+
+        ObjectMessage that = (ObjectMessage) o;
+
+        return this.obj != null ? this.obj.equals(that.obj) : that.obj == null;
+    }
+
+    @Override
+    public int hashCode() {
+        return this.obj != null ? this.obj.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return "ObjectMessage[obj=" + this.obj.toString() + "]";
+    }
+
+    @Override
+    public Throwable getThrowable() {
+        return (this.obj instanceof Throwable) ? (Throwable) this.obj : null;
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/ParameterizedMessage.java

@@ -0,0 +1,336 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.message;
+
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ *
+ * @author hyh
+ */
+public class ParameterizedMessage
+        implements IMessage {
+
+    public static final String RECURSION_PREFIX = "[...";
+    public static final String RECURSION_SUFFIX = "...]";
+    public static final String ERROR_PREFIX = "[!!!";
+    public static final String ERROR_SEPARATOR = "=>";
+    public static final String ERROR_MSG_SEPARATOR = ":";
+    public static final String ERROR_SUFFIX = "!!!]";
+    private static final long serialVersionUID = -665975803997290697L;
+    private static final int HASHVAL = 31;
+    private static final char DELIM_START = '{';
+    private static final char DELIM_STOP = '}';
+    private static final char ESCAPE_CHAR = '\\';
+    private final String messagePattern;
+    private final String[] stringArgs;
+    private transient Object[] argArray;
+    private transient String formattedMessage;
+    private transient Throwable throwable;
+
+    public ParameterizedMessage(String messagePattern, String[] stringArgs, Throwable throwable) {
+        this.messagePattern = messagePattern;
+        this.stringArgs = stringArgs;
+        this.throwable = throwable;
+    }
+
+    public ParameterizedMessage(String messagePattern, Object[] objectArgs, Throwable throwable) {
+        this.messagePattern = messagePattern;
+        this.throwable = throwable;
+        this.stringArgs = parseArguments(objectArgs);
+    }
+
+    public ParameterizedMessage(String messagePattern, Object[] arguments) {
+        this.messagePattern = messagePattern;
+        this.stringArgs = parseArguments(arguments);
+    }
+
+    public ParameterizedMessage(String messagePattern, Object arg) {
+        this(messagePattern, new Object[]{arg});
+    }
+
+    public ParameterizedMessage(String messagePattern, Object arg1, Object arg2) {
+        this(messagePattern, new Object[]{arg1, arg2});
+    }
+
+    private String[] parseArguments(Object[] arguments) {
+        if (arguments == null) {
+            return null;
+        }
+        int argsCount = countArgumentPlaceholders(this.messagePattern);
+        int resultArgCount = arguments.length;
+        if ((argsCount < arguments.length)
+                && (this.throwable == null) && ((arguments[(arguments.length - 1)] instanceof Throwable))) {
+            this.throwable = ((Throwable) arguments[(arguments.length - 1)]);
+            resultArgCount--;
+        }
+
+        this.argArray = new Object[resultArgCount];
+        System.arraycopy(arguments, 0, this.argArray, 0, resultArgCount);
+        String[] strArgs;
+        if ((argsCount == 1) && (this.throwable == null) && (arguments.length > 1)) {
+            strArgs = new String[1];
+            strArgs[0] = deepToString(arguments);
+        } else {
+            strArgs = new String[resultArgCount];
+            for (int i = 0; i < strArgs.length; i++) {
+                strArgs[i] = deepToString(arguments[i]);
+            }
+        }
+        return strArgs;
+    }
+
+    @Override
+    public String getFormattedMessage() {
+        if (this.formattedMessage == null) {
+            this.formattedMessage = formatMessage(this.messagePattern, this.stringArgs);
+        }
+        return this.formattedMessage;
+    }
+
+    @Override
+    public String getFormat() {
+        return this.messagePattern;
+    }
+
+    @Override
+    public Object[] getParameters() {
+        if (this.argArray != null) {
+            return this.argArray;
+        }
+        return this.stringArgs;
+    }
+
+    @Override
+    public Throwable getThrowable() {
+        return this.throwable;
+    }
+
+    protected String formatMessage(String msgPattern, String[] sArgs) {
+        return format(msgPattern, sArgs);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        ParameterizedMessage that = (ParameterizedMessage) o;
+        if (this.messagePattern != null ? !this.messagePattern.equals(that.messagePattern) : that.messagePattern != null)
+            return false;
+
+        return Arrays.equals(this.stringArgs, that.stringArgs);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = this.messagePattern != null ? this.messagePattern.hashCode() : 0;
+        result = HASHVAL * result + (this.stringArgs != null ? Arrays.hashCode(this.stringArgs) : 0);
+        return result;
+    }
+
+    public static String format(String messagePattern, Object[] arguments) {
+        if ((messagePattern == null) || (arguments == null) || (arguments.length == 0))
+            return messagePattern;
+
+        StringBuilder result = new StringBuilder();
+        int escapeCounter = 0;
+        int currentArgument = 0;
+        for (int i = 0; i < messagePattern.length(); i++) {
+            char curChar = messagePattern.charAt(i);
+            if (curChar == ESCAPE_CHAR) {
+                escapeCounter++;
+            } else if ((curChar == DELIM_START)
+                    && (i < messagePattern.length() - 1)
+                    && (messagePattern.charAt(i + 1) == DELIM_STOP)) {
+                int escapedEscapes = escapeCounter / 2;
+                for (int j = 0; j < escapedEscapes; j++)
+                    result.append(ESCAPE_CHAR);
+
+                if (escapeCounter % 2 == 1) {
+                    result.append(DELIM_START);
+                    result.append(DELIM_STOP);
+                } else {
+                    if (currentArgument < arguments.length)
+                        result.append(arguments[currentArgument]);
+                    else
+                        result.append(DELIM_START).append(DELIM_STOP);
+                    currentArgument++;
+                }
+                i++;
+                escapeCounter = 0;
+            } else {
+                if (escapeCounter > 0) {
+                    for (int j = 0; j < escapeCounter; j++)
+                        result.append(ESCAPE_CHAR);
+                    escapeCounter = 0;
+                }
+                result.append(curChar);
+            }
+        }
+        return result.toString();
+    }
+
+    public static int countArgumentPlaceholders(String messagePattern) {
+        if (messagePattern == null) return 0;
+
+        int delim = messagePattern.indexOf(123);
+
+        if (delim == -1) return 0;
+        int result = 0;
+        boolean isEscaped = false;
+        for (int i = 0; i < messagePattern.length(); i++) {
+            char curChar = messagePattern.charAt(i);
+            if (curChar == ESCAPE_CHAR) {
+                isEscaped = !isEscaped;
+            } else if (curChar == DELIM_START) {
+                if ((!isEscaped)
+                        && (i < messagePattern.length() - 1)
+                        && (messagePattern.charAt(i + 1) == DELIM_STOP)) {
+                    result++;
+                    i++;
+                }
+
+                isEscaped = false;
+            } else {
+                isEscaped = false;
+            }
+        }
+        return result;
+    }
+
+    public static String deepToString(Object o) {
+        if (o == null) return null;
+        if (o instanceof String) return (String) o;
+        StringBuilder str = new StringBuilder();
+        Set dejaVu = new HashSet();
+        recursiveDeepToString(o, str, dejaVu);
+        return str.toString();
+    }
+
+    private static void recursiveDeepToString(Object o, StringBuilder str, Set<String> dejaVu) {
+        if (o == null) {
+            str.append("null");
+            return;
+        }
+        if ((o instanceof String)) {
+            str.append(o);
+            return;
+        }
+        Class oClass = o.getClass();
+        if (oClass.isArray()) {
+            if (oClass == byte[].class) {
+                str.append(Arrays.toString((byte[]) (byte[]) o));
+            } else if (oClass == short[].class) {
+                str.append(Arrays.toString((short[]) (short[]) o));
+            } else if (oClass == int[].class) {
+                str.append(Arrays.toString((int[]) (int[]) o));
+            } else if (oClass == long[].class) {
+                str.append(Arrays.toString((long[]) (long[]) o));
+            } else if (oClass == float[].class) {
+                str.append(Arrays.toString((float[]) (float[]) o));
+            } else if (oClass == double[].class) {
+                str.append(Arrays.toString((double[]) (double[]) o));
+            } else if (oClass == boolean[].class) {
+                str.append(Arrays.toString((boolean[]) (boolean[]) o));
+            } else if (oClass == char[].class) {
+                str.append(Arrays.toString((char[]) (char[]) o));
+            } else {
+                String id = identityToString(o);
+                if (dejaVu.contains(id)) {
+                    str.append("[...").append(id).append("...]");
+                } else {
+                    dejaVu.add(id);
+                    Object[] oArray = (Object[]) (Object[]) o;
+                    str.append("[");
+                    boolean first = true;
+                    for (Object current : oArray) {
+                        if (first) first = false;
+                        else str.append(", ");
+                        recursiveDeepToString(current, str, new HashSet(dejaVu));
+                    }
+                    str.append("]");
+                }
+            }
+        } else if ((o instanceof Map)) {
+            String id = identityToString(o);
+            if (dejaVu.contains(id)) {
+                str.append("[...").append(id).append("...]");
+            } else {
+                dejaVu.add(id);
+                Map oMap = (Map) o;
+                str.append("{");
+                boolean isFirst = true;
+                for (Object o1 : oMap.entrySet()) {
+                    Map.Entry current = (Map.Entry) o1;
+                    if (isFirst) isFirst = false;
+                    else str.append(", ");
+                    Object key = current.getKey();
+                    Object value = current.getValue();
+                    recursiveDeepToString(key, str, new HashSet(dejaVu));
+                    str.append("=");
+                    recursiveDeepToString(value, str, new HashSet(dejaVu));
+                }
+                str.append("}");
+            }
+        } else if ((o instanceof Collection)) {
+            String id = identityToString(o);
+            if (dejaVu.contains(id)) {
+                str.append("[...").append(id).append("...]");
+            } else {
+                dejaVu.add(id);
+                Collection oCol = (Collection) o;
+                str.append("[");
+                boolean isFirst = true;
+                for (Iterator i$ = oCol.iterator(); i$.hasNext();) {
+                    Object anOCol = i$.next();
+                    if (isFirst) isFirst = false;
+                    else str.append(", ");
+                    recursiveDeepToString(anOCol, str, new HashSet(dejaVu));
+                }
+                str.append("]");
+            }
+        } else if ((o instanceof Date)) {
+            Date date = (Date) o;
+            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
+
+            str.append(format.format(date));
+        } else {
+            try {
+                str.append(o.toString());
+            } catch (Throwable t) {
+                str.append("[!!!");
+                str.append(identityToString(o));
+                str.append("=>");
+                String msg = t.getMessage();
+                String className = t.getClass().getName();
+                str.append(className);
+                if (!className.equals(msg)) {
+                    str.append(":");
+                    str.append(msg);
+                }
+                str.append("!!!]");
+            }
+        }
+    }
+
+    public static String identityToString(Object obj) {
+        if (obj == null) return null;
+        return obj.getClass().getName()+"@"+Integer.toHexString(System.identityHashCode(obj));
+    }
+
+    @Override
+    public String toString() {
+        return "ParameterizedMessage[messagePattern="+this.messagePattern+", stringArgs="+Arrays.toString(this.stringArgs)+", throwable="+this.throwable+"]";
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/ParameterizedMessageFactory.java

@@ -0,0 +1,20 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.message;
+
+/**
+ *
+ * @author hyh
+ */
+public final class ParameterizedMessageFactory extends AbstractMessageFactory {
+
+    public static final ParameterizedMessageFactory INSTANCE = new ParameterizedMessageFactory();
+
+    @Override
+    public IMessage newMessage(String message, Object[] params) {
+	return new ParameterizedMessage(message, params);
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/SimpleMessage.java

@@ -0,0 +1,69 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.message;
+
+/**
+ *
+ * @author hyh
+ */
+public class SimpleMessage
+	implements IMessage {
+
+    private static final long serialVersionUID = -8398002534962715992L;
+    private final String message;
+
+    public SimpleMessage() {
+	this(null);
+    }
+
+    public SimpleMessage(String message) {
+	this.message = message;
+    }
+
+    @Override
+    public String getFormattedMessage() {
+	return this.message;
+    }
+
+    @Override
+    public String getFormat() {
+	return this.message;
+    }
+
+    @Override
+    public Object[] getParameters() {
+	return null;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+	if (this == o) {
+	    return true;
+	}
+	if ((o == null) || (getClass() != o.getClass())) {
+	    return false;
+	}
+
+	SimpleMessage that = (SimpleMessage) o;
+
+	return this.message != null ? this.message.equals(that.message) : that.message == null;
+    }
+
+    @Override
+    public int hashCode() {
+	return this.message != null ? this.message.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+	return "SimpleMessage[message=" + this.message + "]";
+    }
+
+    @Override
+    public Throwable getThrowable() {
+	return null;
+    }
+}

HMCLAPI/src/main/java/org/jackhuang/hellominecraft/logging/message/StringFormattedMessage.java

@@ -0,0 +1,94 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.jackhuang.hellominecraft.logging.message;
+
+import java.util.Arrays;
+import java.util.IllegalFormatException;
+
+public class StringFormattedMessage
+	implements IMessage {
+
+    private static final long serialVersionUID = -665975803997290697L;
+    private final String messagePattern;
+    private final transient Object[] argArray;
+    private String[] stringArgs;
+    private transient String formattedMessage;
+    private transient Throwable throwable;
+
+    public StringFormattedMessage(String messagePattern, Object[] arguments) {
+	this.messagePattern = messagePattern;
+	this.argArray = arguments;
+	if ((arguments != null) && (arguments.length > 0) && ((arguments[(arguments.length - 1)] instanceof Throwable))) {
+	    this.throwable = ((Throwable) arguments[(arguments.length - 1)]);
+	}
+    }
+
+    @Override
+    public String getFormattedMessage() {
+	if (this.formattedMessage == null) {
+	    this.formattedMessage = formatMessage(this.messagePattern, this.argArray);
+	}
+	return this.formattedMessage;
+    }
+
+    @Override
+    public String getFormat() {
+	return this.messagePattern;
+    }
+
+    @Override
+    public Object[] getParameters() {
+	if (this.argArray != null) {
+	    return this.argArray;
+	}
+	return this.stringArgs;
+    }
+
+    protected String formatMessage(String msgPattern, Object[] args) {
+	try {
+	    return String.format(msgPattern, args);
+	} catch (IllegalFormatException ife) {
+	    System.err.println("Unable to format msg: " + msgPattern);
+	    ife.printStackTrace();
+	}
+	return msgPattern;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+	if (this == o) {
+	    return true;
+	}
+	if ((o == null) || (getClass() != o.getClass())) {
+	    return false;
+	}
+
+	StringFormattedMessage that = (StringFormattedMessage) o;
+
+	if (this.messagePattern != null ? !this.messagePattern.equals(that.messagePattern) : that.messagePattern != null) {
+	    return false;
+	}
+
+	return Arrays.equals(this.stringArgs, that.stringArgs);
+    }
+
+    @Override
+    public int hashCode() {
+	int result = this.messagePattern != null ? this.messagePattern.hashCode() : 0;
+	result = 31 * result + (this.stringArgs != null ? Arrays.hashCode(this.stringArgs) : 0);
+	return result;
+    }
+
+    @Override
+    public String toString() {
+	return "StringFormatMessage[messagePattern=" + this.messagePattern + ", args=" + Arrays.toString(this.argArray) + "]";
+    }
+
+    @Override
+    public Throwable getThrowable() {
+	return this.throwable;
+    }
+}