JAVA 实现简单的日志工具

因为需求有点变化，原来需要写入数据库的数据现在变为把json字符串写到文档，本来使用logback轻松可以做到日志写入，但是上面说需要自己写。

需求比较简单，在rest服务调用写文件接口，当文件大小超过定值时，新建文件进行存储。

开始我采用的方式是每次调用都会实例一个File，对文件进行写操作，完成后进行关闭，但是rest服务后期会做压力测试，当很多请求写同一个文件时，最后程序卡死了，所以最后想采用一个专门线程对单一文件进行写，所以需要在内存中申请一块内存，调用文件写接口将数据放入内存，然后线程将内存中数据写到文件。

为了提高写入内存，和从内存读取数据落地操作的并发性，我申请了两块内存，一块专门进行写，一块进行读取落地，当写入内存满滞后，进行两块内存作业的切换。后来考虑到采用当内存满才进行写入操作的方式，可能当程序发生错误时，会将很大一部分内存中的数据都丢失掉，所以我有参考oracle日志线程的功能，添加了定时落地功能，在内存满或者定时器时间到达时进行数据落地，具体代码如下，以供参考。

package com.liwe.commons;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.springframework.stereotype.Service;

@Service
public class FileBufferWrite implements Runnable {
	final static long filesize=1024;
	final int size = 1024;
	byte[] cache1 = new byte[size];
	byte[] cache2 = new byte[size];
	Object lockr = new Object();
	Thread thd = null;
	FileBufferWrite ptr = this;
	FileOutputStream fos;
	int pos = 0;
	int cacheforuse = 1;
	long filelen=0;
	int writting = 0;
	int lastlen=0;
	String pathName;
	public String getPathName() {
		return pathName;
	}


	public void setPathName(String pathName) {
		this.pathName = pathName;
	}

	File file=new File(pathName+"log.txt");
	public FileBufferWrite() {
	
	}


	public void switchcache() {
		if (pos != 0) {
			System.out.println("switch cache");
			cacheforuse = 1 - cacheforuse;
			lastlen=pos;
			pos = 0;
			synchronized (lockr) {
				lockr.notify();
			}
		}
	}

	public Thread getThread() {
		Thread thd = new Thread(this);
		thd.start();
		new Thread(new Runnable() {
			public void run() {
				while (true) {
					try {
						Thread.sleep(1000);
						synchronized (ptr) {
							while (writting == 1) {
								Thread.sleep(100);
							}
							switchcache();

						}
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

				}
			}
		}).start();
		return thd;
	}

	public void run() {
		try {
			while (true) {
				synchronized (lockr) {
					lockr.wait();
				}
				writting = 1;
				System.out.println("start write file from cache" + cacheforuse);
				try {
					byte[] bfw;
					bfw=new byte[lastlen];
					if (cacheforuse == 1) {
						System.arraycopy(cache2, 0,bfw, 0,lastlen);
					} else {
						System.arraycopy(cache1, 0,bfw, 0,lastlen);
					}
					try {
						file=new File(pathName+"log.txt");
						if(!file.getParentFile().exists())
							file.getParentFile().mkdirs();
						if(!file.exists())
							file.createNewFile();
							fos = new FileOutputStream(file);

					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					if(filelen+lastlen>filesize){
						
						File[] fl=new File(pathName).listFiles();
						int num=fl.length;
						fos.close();
						file.renameTo(new File(pathName+"log"+num+".txt"));
				
						file=new File(pathName+"log.txt");
						fos=new FileOutputStream(file);
						filelen=0;
						System.out.println("change file");
					}
					fos.write(bfw);
					fos.flush();
					filelen+=lastlen;
				
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("file write over");
				writting = 0;
			}

		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public synchronized void write(String str) throws InterruptedException {
		if (thd == null) {
			thd = getThread();
		}
		str+="\r\n";
		byte[] tmp = str.getBytes();
		if (pos + tmp.length > size) {
			System.out.println("cache filled");
			while (writting == 1) {
				System.out.println("sleeping");
				Thread.sleep(10);
			}
			switchcache();

			System.out.println("notify");

		}
		System.out.println("cache write");
		if (cacheforuse == 1) {
			System.arraycopy(tmp, 0, cache1, pos, tmp.length);
			pos += tmp.length;
		} else {
			System.arraycopy(tmp, 0, cache2, pos, tmp.length);
			pos += tmp.length;
		}
	}
}