log4jimpl.java

中国移动定位引擎的客户端

package ffcs.logging;

import java.io.IOException;
import java.io.Serializable;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.Priority;

import ffcs.config.Config;

public class Log4jImpl implements Log, Serializable {
	public static final long serialVersionUID = 0x800343;

	private static final boolean is12 = Priority.class
			.isAssignableFrom(Level.class);

	private static final String FQCN = Log4jImpl.class.getName();

	private transient Logger logger = null;

	private String name = null;

	private static DatagramSocket ds = null;

	private static String alertHost = null;

	private static int alertPort = 9999;
	
	private static LogSynch logSynch = null;
	
	
	static {
		try{
			logSynch = new LogSynch();
			logSynch.start();
		}catch(Exception e){
			e.printStackTrace();
		}
		initUDPClient();
	}

	
	public Log4jImpl(String name) {
		this.logger = Logger.getLogger(name);

	}
  
	public Log4jImpl(Class clazz) {

		this.logger = Logger.getLogger(clazz);

	}
	 private static void initUDPClient(){
		  try {
				alertHost = Config.getInstance().getGlobalProp("alertHost");
				alertPort = Integer.parseInt(Config.getInstance().getGlobalProp(
						"alertPort"));
			} catch (Throwable e) {
				e.printStackTrace();
			}
			try {
				ds = new DatagramSocket();
			} catch (Throwable e) {
				e.printStackTrace();
			}
	  }
	public void trace(Object message) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.DEBUG, message, null);
		} else {
			getLogger().log(FQCN, Level.DEBUG, message, null);
		}
	}

	public void trace(Object message, Throwable t) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.DEBUG, message, t);
		} else {
			getLogger().log(FQCN, Level.DEBUG, message, t);
		}
		
	}

	public void debug(Object message) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.DEBUG, message, null);
		} else {
			getLogger().log(FQCN, Level.DEBUG, message, null);
		}
	}

	public void debug(Object message, Throwable t) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.DEBUG, message, t);
		} else {
			getLogger().log(FQCN, Level.DEBUG, message, t);
		}
	}

	public void info(Object message) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.INFO, message, null);
		} else {
			getLogger().log(FQCN, Level.INFO, message, null);
		}
	}

	public void info(Object message, Throwable t) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.INFO, message, t);
		} else {
			getLogger().log(FQCN, Level.INFO, message, t);
		}
	}

	public void warn(Object message) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.WARN, message, null);
		} else {
			getLogger().log(FQCN, Level.WARN, message, null);
		}
	}

	public void warn(Object message, Throwable t) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.WARN, message, t);
		} else {
			getLogger().log(FQCN, Level.WARN, message, t);
		}
	}

	public void error(Object message) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.ERROR, message, null);
		} else {
			getLogger().log(FQCN, Level.ERROR, message, null);
		}
	}

	public void error(Object message, Throwable t) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.ERROR, message, t);
		} else {
			getLogger().log(FQCN, Level.ERROR, message, t);
		}
	}

	public void fatal(Object message) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.FATAL, message, null);
		} else {
			getLogger().log(FQCN, Level.FATAL, message, null);
		}
	}

	public void fatal(Object message, Throwable t) {
		if (is12) {
			getLogger().log(FQCN, (Priority) Level.FATAL, message, t);
		} else {
			getLogger().log(FQCN, Level.FATAL, message, t);
		}
	}

	public Logger getLogger() {
		if (logger == null) {
			logger = Logger.getLogger(name);
		}
		
		return (this.logger);
	}

	/**
	 * Check whether the Log4j Logger used is enabled for <code>DEBUG</code>
	 * priority.
	 */
	public boolean isDebugEnabled() {
		return getLogger().isDebugEnabled();
	}

	public boolean isErrorEnabled() {
		if (is12) {
			return logger.isEnabledFor((Priority) Level.ERROR);
		} else {
			return getLogger().isEnabledFor(Level.ERROR);
		}
	}

	/**
	 * Check whether the Log4j Logger used is enabled for <code>FATAL</code>
	 * priority.
	 */
	public boolean isFatalEnabled() {
		if (is12) {
			return getLogger().isEnabledFor((Priority) Level.FATAL);
		} else {
			return getLogger().isEnabledFor(Level.FATAL);
		}
	}

	/**
	 * Check whether the Log4j Logger used is enabled for <code>INFO</code>
	 * priority.
	 */
	public boolean isInfoEnabled() {
		return getLogger().isInfoEnabled();
	}

	/**
	 * Check whether the Log4j Logger used is enabled for <code>TRACE</code>
	 * priority. For Log4J, this returns the value of
	 * <code>isDebugEnabled()</code>
	 */
	public boolean isTraceEnabled() {
		return getLogger().isDebugEnabled();
	}

	/**
	 * Check whether the Log4j Logger used is enabled for <code>WARN</code>
	 * priority.
	 */
	public boolean isWarnEnabled() {
		if (is12) {
			return logger.isEnabledFor((Priority) Level.WARN);
		} else {
			return logger.isEnabledFor(Level.WARN);
		}
	}

	public void infoAndAlert(Object message, Throwable t, int source,int errorNo) {
		infoAndAlert(message, t,source,errorNo,alertHost,alertPort);
	}

	public void warnAndAlert(Object message, Throwable t, int source,int errorNo) {
		warnAndAlert(message, t,source,errorNo,alertHost,alertPort);
	}

	public void errorAndAlert(Object message, Throwable t, int source,int errorNo) {
		errorAndAlert(message, t,source,errorNo,alertHost,alertPort);
	}
	
    public void infoAndAlert(Object message, Throwable t,int source,int errorNo,String host,int port){
		send(10,source,errorNo,message.toString(),host,port);
		this.info(message,t);
    }

    public void warnAndAlert(Object message, Throwable t,int source,int errorNo,String host,int port){
		send(4,source,errorNo,message.toString(),host,port);
		this.warn(message,t);
    }
    
    public void clearAlert(int source,int errorNo,Object message){
    	clearAlert(source,errorNo,message.toString(),alertHost,alertPort);
    }
    
    public void clearAlert(int source,int errorNo,Object message,String host,int port){
    	send(5,source,errorNo,message.toString(),host,port);
    }
 
    public void errorAndAlert(Object message, Throwable t, int source,int errorNo,String host,int port){
		send(1,source,errorNo,message.toString(),host,port);
		this.error(message,t);
    }

	public void send(int msgType, int moduleType, int errorNo, String errMsg,
			String destHost, int destPort) {
		if(destHost==null){
			this.error("发送告警时，host ip为空");
			return;
		}
		int msgLength = 0;
		byte[] error = null;

		if (errMsg != null) {
			error = errMsg.getBytes();
			msgLength = error.length;
		}

		byte[] pack = new byte[16 + msgLength];
		int pos = 0;
		System.arraycopy(toByteArray(16 + msgLength), 0, pack, pos, 4);
		pos += 4;
		System.arraycopy(toByteArray(msgType), 0, pack, pos, 4);
		pos += 4;
		System.arraycopy(toByteArray(moduleType),0,pack,pos,4);
		pos += 4;
		System.arraycopy(toByteArray(errorNo), 0, pack, pos, 4);
		if (errMsg != null) {
			pos += 4;
			System.arraycopy(error, 0, pack, pos, error.length);
		}
		
        try{
        	send(pack, InetAddress.getByName(destHost), destPort);
        }catch(IOException ioe){
        	this.equals(ioe);
        }
	}
	protected void send(byte[] buf,InetAddress destIA,int destPort){
		DatagramPacket dp = new DatagramPacket(buf, buf.length, destIA, destPort);
		send(dp);
		
      }
	protected void send(DatagramPacket dp) {
		if(ds==null){
			this.warn("发送告警的UDP客户端初始化失败,告警未能发送");
			return;
		}
		try {
				ds.send(dp);
		} catch (IOException ioe) {
			this.error(ioe);
		}
	}
    /**
     * 整数到字节数组的转换
     * @param number int
     * @return byte[]
     */
   protected  byte[] toByteArray(int number) {
        int temp = number;
        byte[] b = new byte[4];
        for (int i = b.length - 1; i > -1; i--) {
            b[i] = new Integer(temp & 0xff).byteValue();
            temp = temp >> 8;
        }
        return b;
    }
}