扔掉log4j、log4j2，自己动手实现一个多功能日志记录框架，包含文件，数据库日志写入，实测5W+/秒日志文件写入，2W+/秒数据库日志写入，虽然它现在还没有logback那么强大

讲到log4j，现在国外基本是没有开发者用这个框架了，原因大致有几点，1、功能太少；2、效率低下；3、线程锁bug等等等各种莫名其妙的bug一直都没解决。

其实最重要的是log4j的作者自己也放弃了log4j，该作者现在在维护logback项目(现在主流的日志记录框架，彻底推翻了log4j的架构重写了，功能很强大)，所以log4j以后基本不会再用了。

讲到这里，还是要研究一下要怎么实现的日志记录框架，那么要写个日志记录框架，得要熟悉日志记录系统的整体设计思路。于是自己构思了一晚上，花了一上午时间写了一个简单的日志记录系统（就是logGuide0.1.1），姑且称为一个简单框架吧。

由于后面又继续对logGuide进行开发更新，所以现在的版本有这些：

如果有兴趣研究这一块的话，源码在这里：

logGuide 0.1.1比较简陋就不在提供了。

老核心源码（logGuide 0.2.1）：http://download.csdn.net/detail/eguid_1/9491573

最新logGuide 0.3.2.jar包（非源码）下载：http://download.csdn.net/detail/eguid_1/9532267

[b][b]最新logGuide 0.3.2（源码）[/b]下载：http://download.csdn.net/detail/eguid_1/9532617[/b]

新核心日志记录（[b]logGuide 0.3.1）大致分为5层结构:[/b]

1、写入区        ---> 传入消息，传入消息后交由分发器进行分发

2、分发器        ---> 分发消息，缓冲消息数据(消息分为普通日志和异常错误日志)，调用缓冲区缓冲消息日志

3、缓冲区        ---> 缓冲消息日志，把所有消息缓冲到一个双缓冲队列中，交由缓冲分发器进行消息分发处理

4、缓冲分发器 ---> 由一个后台保护线程调用持久层写出日志

5、持久层        ---> 写出消息日志，缓冲区通过持久层实现写出日志，配置文件中配置可以实现文件和数据库同时写出

当前最新版本：

[b]logGuide 0.3.2版本[/b]

[b]1、增加独立数据库缓存核心[/b]

[b]2、优化数据库写入效率[/b]

[b]3、优化文件写入逻辑[/b]



[b]logGuide 0.3.1版本（重大更新版本）[/b]

1、[b]源代码推翻重写[/b]

2、[b]优化代码结构，结构更加清晰，各功能模块分工更加明确[/b]

3、[b]优化NIO+BQ缓冲核心，占用资源更少，速度更快，[b]实测 最高50822/每秒
日志文件写出速度[/b][/b]

[b]4、[b]增加数据库持久化功能，可通过配置文件配置[/b][/b]

[b]5、[b]消息格式可配置[/b][/b]



logGuide 0.2.1版本

1、支持配置文件方式指定两种日志记录文件(infoPath=log.log,errorPath=error.log)在项目文件中的路径(注意:目前支持项目文件中的路径，其他路径会出现异常)

2、支持读写顺序日志记录(先读后写)和读写同时两种方式记录(通过配置文件中的auto='false/true'来指定哪种方式，默认先读后写)

3、优化代码结构，可读性更好

logGuide 0.1.1版本

1、实现第三方动态日志记录

2、采用双缓冲队列，更好的多线程并发条件下的日志写入，安全与效率并重

3、采用NIO文件底层操作，更快的读写效率

4、采用读写同时日志记录(并发，写入为单独线程操作)，提高组件运行效率

[b]logGuide 0.2.1文件写出核心代码：[/b]

<span style="font-size:18px;">private static FileChannel infoChannel = null;
private static FileChannel errorChannel = null;

private static BlockingQueue<Object> bq = null;
private static ByteBuffer buffer = null;
private static int index = 0;// 用于控制是否开启自动写入
static {
Properties pro = new Properties();
File infoFile = null;
File errorFile = null;
try {
InputStream is = FileBuffer.class.getClassLoader()
.getResourceAsStream("logConf.properties");
pro.load(is);
} catch (Exception e) {
e.printStackTrace();
}
String infoFilePath = pro.getProperty("infoPath");
String errorFilePath = pro.getProperty("errorPath");
String status = pro.getProperty("auto");
if (status != null && status.equals("true")) {
index = 0;
} else {
index = 1;
}
String path = FileBuffer.class.getClassLoader().getResource("/")
.getPath();
if (infoFilePath != null) {
infoFile = new File(path + infoFilePath);
try {
createFile(infoFile);
} catch (IOException e) {
e.printStackTrace();
}
}
if (errorFilePath != null) {
errorFile = new File(path + errorFilePath);
try {
createFile(errorFile);
} catch (IOException e) {
e.printStackTrace();
}
}
bq = new LinkedBlockingQueue<Object>();
buffer = ByteBuffer.allocate(1024);
try {
infoChannel = new RandomAccessFile(infoFile, "rw").getChannel();
errorChannel = new RandomAccessFile(errorFile, "rw").getChannel();
} catch (Exception e) {
e.printStackTrace();
}
// 如果index=0则自动更新
if (index == 0) {
AutoWrite();
}
}

/**
* 把消息存放进缓冲队列
*
* @param msg
* @param name
* @throws Exception
*/
public static void addMsgToFile(StringBuilder msg, String name){

Map<String, Object> map = null;
map = new HashMap<String, Object>();
if (msg != null) {
map.put("fileName", name);
map.put("msg", msg);
}
bq.offer(map);
OneWrite();
}
/**
*  index为1时为1次消息1次写入
*/
private static void OneWrite()
{

if (index == 1) {
try {
writen();
} catch (Exception e) {
System.out.println("日志写入失败"+e.getMessage());
}
}
}
/**
* 开启自动写入
*/
private static void AutoWrite() {
Thread t = new Thread() {
public void run() {
while (true) {
try {
writen();
} catch (Exception e) {
e.printStackTrace();
}
}
}
};
//开启写入线程
t.start();
}

/**
* 将缓冲队列中的文件写入到对应的文件中
*
* @throws Exception
*/

private static void writen() throws Exception {

if (bq.peek() != null) {
Map map = (Map) bq.poll();
String name = (String) map.get("fileName");
StringBuilder msg = (StringBuilder) map.get("msg");
if (name != null && name.equals("info")) {
wirteInfo(msg);
} else if (name != null && name.equals("error")) {
writeError(msg);
}
} else {
Thread.sleep(200);
}
}

/**
* 写入普通消息
*
* @param msg
*/
private static void wirteInfo(StringBuilder msg) {
bufferWrite(buffer, infoChannel, msg);
}

// 写入错误消息
private static void writeError(StringBuilder msg) {
bufferWrite(buffer, errorChannel, msg);
}

/**
* 使用NIO将消息缓冲进buffer，通过buffer写出到到指定通道
*
* @param buffer
* @param fc
* @param msg
*/
private static void bufferWrite(ByteBuffer b, FileChannel fc,
StringBuilder msg) {
b.clear();
msg.append("\r\n");
b.put(msg.toString().getBytes());
try {
b.flip();
fc.write(b, fc.size());
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 是否存在文件，如果不存在则创建
*
* @param file
* @throws IOException
*/
private static void createFile(File file) throws IOException {
if (!file.exists()) {
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
throw e;
}
}
}</span>