读取用户登入出日志并上传服务端

该客户端运行在给用户提供unix服务的服务器上。用来读取并收集该服务器上用户的上下线信息,并进行配对整理后发送给服务端汇总。
package com.dms;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;



/**
 * DMS服务端,用来接收每个客户端发送过来的
 * 配对日志并保存在本地文件中
 * @author Administrator
 *
 */
public class DMSServer {
	//属性定义
	//用来接收客户端连接的服务端的ServerSocket
	private ServerSocket server;
	//用来管理处理客户端请求的线程的线程池
	private ExecutorService threadPool;
	//保存所有客户端发送过来配对日志的文件
	private File serverLogFile;
	//消息队列
	private BlockingQueue<String> messageQueue = new LinkedBlockingQueue<String>();
	
	public DMSServer() throws Exception{
		try {
			System.out.println("服务端正在初始化...");
			//1 解析配置文件server-config.xml
			Map<String,String> config = loadConfig();
			
			//2 根据配置文件内容初始化属性
			init(config);
			System.out.println("服务端初始化完毕...");
		} catch (Exception e) {
			System.out.println("初始化服务端失败!");
			throw e;
		}
	}
	
	/**
	 * 构造方法初始化第一步,解析配置文件
	 * @return 返回的Map中保存的是配置文件中的
	 *         每一条内容,其中key:标签的名字,
	 *         value为标签中间的文本
	 * @throws Exception 
	 */
	private Map<String,String> loadConfig() throws Exception{
		try {
			SAXReader reader = new SAXReader();
			Document doc
				= reader.read(new File("server-config.xml"));
			Element root = doc.getRootElement();
			
			Map<String,String> config
				= new HashMap<String,String>();
			/*
			 * 获取<config>标签中的所有子标签
			 * 并将每一个子标签的名字作为key,中间的
			 * 文本作为value存入Map集合
			 */
			List<Element> list = root.elements();
			for(Element e : list){
				String key = e.getName();
				String value = e.getTextTrim();
				config.put(key, value);
			}
			return config;
		} catch (Exception e) {
			System.out.println("解析配置文件异常!");
			e.printStackTrace();
			throw e;
		}
	}
	
	/**
	 * 构造方法初始化第二步,根据配置项初始化属性
	 * @param config
	 * @throws Exception 
	 */
	private void init(Map<String,String> config) throws Exception{
		/*
		 * 用配置文件中的<logrecfile>初始化属性:serverLogFile
		 * 用配置文件中的<threadsum>初始化属性:threadPool,这里创建固定大小线程池。该值作为线程池线程数量
		 * 用配置文件中的<serverport>初始化属性:server,这里这个值为ServerSocket的服务端口
		 */
		this.server = new ServerSocket(
			Integer.parseInt(config.get("serverport"))	
		);
		
		this.serverLogFile = new File(
			config.get("logrecfile")	
		);
		this.threadPool = Executors.newFixedThreadPool(
			Integer.parseInt(config.get("threadsum"))	
		);
	}	
	/**
	 * 服务端开始工作的方法
	 * @throws Exception
	 */
	public void start() throws Exception{
		/*
		 * 实现要求:
		 *  首先单独启动一个线程,用来运行SaveLogHandler
		 *  这个任务,目的是保存所有配对日志
		 *  然后开始循环监听服务端端口,一旦一个客户端连接了,
		 *  就实例化一个ClientHander,然后将该任务交给线程池
		 *  使其分配线程来处理与该客户端的交互。
		 *  
		 */
		try {
			System.out.println("服务端开始工作...");
			SaveLogHandler slh=new SaveLogHandler();
			new Thread(slh).start();
			
			while(true){
				Socket socket=server.accept();
				
				threadPool.execute(new ClientHandler(socket));
			}
			
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		} 
	}
	
	public static void main(String[] args) {
		try {
			DMSServer server = new DMSServer();
			server.start();
		} catch (Exception e) {
			System.out.println("启动服务端失败!");
		}
	}
	/**
	 * 该线程负责从消息队列中取出每一条配对日志,
	 * 并存入到serverLogFile文件
	 * @author Administrator
	 *
	 */
	private class SaveLogHandler implements Runnable{
		public void run(){
			PrintWriter pw = null;
			try {
				pw = new PrintWriter(
					new FileOutputStream(
						serverLogFile,true	
					)	
				);
				while(true){
					if(messageQueue.size()>0){
						pw.println(messageQueue.poll());
					}else{
						pw.flush();
						Thread.sleep(500);
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally{
				if(pw != null){
					pw.close();
				}
			}
		}
	}
	
	/**
	 * 处理一个指定客户端请求
	 * @author Administrator
	 *
	 */
	private class ClientHandler implements Runnable{
		private Socket socket;
		public ClientHandler(Socket socket){
			this.socket = socket;
		}
		public void run(){
			/*
			 * 思路:
			 * 首先接收客户端发送过来的所有配对日志,
			 * 直到读取到"OVER"为止,然后将这些配对
			 * 日志保存到本地的文件中,并回复客户端
			 * "OK"
			 * 执行步骤:
			 * 1:通过Socket创建输出流,用来给客户端
			 *   发送响应
			 * 2:通过Socket创建输入流,读取客户端发送
			 *   过来的日志
			 * 3:循环读取客户端发送过来的每一行字符串,并
			 *   先判断是否为字符串"OVER",若不是,则是
			 *   一条配对日志,那么保存到本地文件,若是,
			 *   则停止读取。
			 * 4:成功读取所有日志后回复客户端"OK"      
			 */
			PrintWriter pw = null;
			try {
				//1
				pw = new PrintWriter(
					new OutputStreamWriter(
						socket.getOutputStream(),"UTF-8"	
					)	
				);
				//2
				BufferedReader br = new BufferedReader(
					new InputStreamReader(
						socket.getInputStream(),"UTF-8"	
					)	
				);
				
				//3
				String message = null;
				while((message = br.readLine())!=null){
					if("OVER".equals(message)){
						break;
					}
					//将该日志写入文件保存
					messageQueue.offer(message);
				}
				
				//4
				pw.println("OK");
				pw.flush();
				
				
			} catch (Exception e) {
				e.printStackTrace();
				pw.println("ERROR");
				pw.flush();
			} finally{
				try {
					//与客户端断开连接释放资源
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}





package com.dms;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.dms.bo.LogData;
import com.dms.bo.LogRec;

/**
 * 该客户端运行在给用户提供unix服务的服务器上。
 * 用来读取并收集该服务器上用户的上下线信息,并
 * 进行配对整理后发送给服务端汇总。
 * @author Administrator
 *
 */
public class DMSClient {
	//属性定义
	
	//第一步:解析日志所需属性
	//unix系统日志文件
	private File logFile;
	//保存解析后日志的文件
	private File textLogFile;
	//书签文件
	private File lastPositionFile;
	//每次解析日志的条目数
	private int batch;
	
	//第二步:配对日志所需要属性
	//保存配对日志的文件
	private File logRecFile;
	//保存未配对日志的文件
	private File loginLogFile;
	
	//第三步:发送日志所需要属性
	//服务端地址
	private String serverHost;
	//服务端端口
	private int serverPort;
	
	/**
	 * 构造方法,用来初始化客户端
	 * @throws Exception 
	 */
	public DMSClient() throws Exception{
		try {
			//1 解析配置文件config.xml
			Map<String,String> config	= loadConfig();
			//打桩
			System.out.println(config);
			
			//2 根据配置文件内容初始化属性
			init(config);
			
		} catch (Exception e) {
			System.out.println("初始化失败!");
			throw e;
		}
	}
	/**
	 * 构造方法初始化第二步,根据配置项初始化属性
	 * @param config
	 * @throws Exception 
	 */
	private void init(Map<String,String> config) throws Exception{
		try {
			logFile = new File(
				config.get("logfile")
			);
			textLogFile = new File(
				config.get("textlogfile")	
			);
			lastPositionFile = new File(
				config.get("lastpositionfile")	
			);
			batch = Integer.parseInt(
				config.get("batch")
			);
			logRecFile = new File(
				config.get("logrecfile")	
			);
			loginLogFile = new File(
				config.get("loginlogfile")	
			);
			serverHost = config.get("serverhost");
			serverPort = Integer.parseInt(
				config.get("serverport")	
			);			
			
		} catch (Exception e) {
			System.out.println("初始化属性失败!");
			e.printStackTrace();
			throw e;
		}
	}
	
	
	/**
	 * 构造方法初始化第一步,解析配置文件
	 * @return 返回的Map中保存的是配置文件中的
	 *         每一条内容,其中key:标签的名字,
	 *         value为标签中间的文本
	 * @throws Exception 
	 */
	private Map<String,String> loadConfig() throws Exception{
		try {
			SAXReader reader = new SAXReader();
			Document doc
				= reader.read(new File("config.xml"));
			Element root = doc.getRootElement();
			
			Map<String,String> config
				= new HashMap<String,String>();
			/*
			 * 获取<config>标签中的所有子标签
			 * 并将每一个子标签的名字作为key,中间的
			 * 文本作为value存入Map集合
			 */
			List<Element> list = root.elements();
			for(Element e : list){
				String key = e.getName();
				String value = e.getTextTrim();
				config.put(key, value);
			}
			return config;
		} catch (Exception e) {
			System.out.println("解析配置文件异常!");
			e.printStackTrace();
			throw e;
		}
	}
	
	/**
	 * 客户端开始工作的方法
	 * 循环执行三步:
	 * 1:解析日志
	 * 2:配对日志
	 * 3:发送日志
	 */
	public void start(){
		parseLogs();
		matchLogs();
		sendLogs();
//		while(true){
//			//解析日志
//			if(!parseLogs()){
//				continue;
//			}
//			//配对日志
//			if(!matchLogs()){
//				continue;
//			}
//			//发送日志
//			sendLogs();
//		}
	}
	/**
	 * 第三步:发送日志
	 * @return true:发送成功
	 *         false:发送失败
	 */
	private boolean sendLogs(){
			/*
			 * 实现思路:
			 * 将logRecFile文件中的所有配对日志读取
			 * 出来然后连接上服务端并发送过去,若服务端
			 * 全部接收,就可以将该文件删除,表示发送
			 * 完毕了。
			 * 实现步骤:
			 * 1:logRecFile文件必须存在
			 * 2:将所有配对日志读取出来并存入一个集合
			 *   等待发送
			 * 3:通过Socket连接服务端
			 * 4:创建输出流
			 * 5:顺序将所有配对日志按行发送给服务端
			 * 6:单独发送一个字符串"OVER"表示所有日志
			 *   均已发送完毕
			 * 7:创建输入流
			 * 8:读取服务端发送回来的响应字符串
			 * 9:若响应的字符串为"OK",表示服务端正常
			 *   接收了所有日志,这时就可以将logRecFile
			 *   文件删除并返回true表示发送完毕。
			 *       
			 */
		Socket socket = null;
		try {
			//1
			if(!logRecFile.exists()){
				System.out.println(logRecFile+"不存在!");
				return false;
			}
			//2
			List<String> matches 
				= IOUtil.loadLogRec(logRecFile);
			
			//3
			socket = new Socket(serverHost,serverPort);
			
			//4
			PrintWriter pw = new PrintWriter(
				new OutputStreamWriter(
					socket.getOutputStream(),"UTF-8"	
				)	
			);
			
			//5
			for(String log : matches){
				pw.println(log);
			}
			
			//6
			pw.println("OVER");
			pw.flush();
			
			//7
			BufferedReader br = new BufferedReader(
				new InputStreamReader(
					socket.getInputStream(),"UTF-8"	
				)	
			);
			
			//8
			String response = br.readLine();
			//9
			if("OK".equals(response)){
				logRecFile.delete();
				return true;
			}else{
				System.out.println("发送日志失败!");
				return false;
			}
			
		} catch (Exception e) {
			System.out.println("发送日志失败!");
			e.printStackTrace();
		} finally{
			if(socket != null){
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return false;
	}
	
	/**
	 * 第二步:配对日志
	 * @return true:配对成功
	 *         false:配对失败
	 */
	private boolean matchLogs(){
		
			/*
			 * 实现思路:
			 * 将第一步解析的新日志,与上次为配对成功
			 * 的登入日志全部读取出来,然后再按照user,
			 * pid相同,type一个是7,一个是8进行配对。
			 * 只要能找到类型为8的,一定可以找到一个
			 * 能与之配对的登入日志。
			 * 
			 * 实现步骤:
			 * 1:必要的判断
			 *   1.1:logRecFile是否存在,存在则不再
			 *       进行新的配对工作,避免覆盖。
			 *   1.2:textLogFile文件必须存在。    
			 * 2:读取textLogFile将日志读取出来,并
			 *   存入到集合中。(若干LogData实例)
			 * 3:若loginLogFile文件若存在,则说明
			 *   有上次未配对成功的日志,也将其读取
			 *   出来存入集合等待一起配对
			 * 4:配对工作
			 *   4.1:创建一个集合,用于保存所有配对日志
			 *   4.2:创建两个Map分别保存登入日志与登出日志
			 *   4.3:遍历所有待配对的日志,按照登入与登出
			 *       分别存入两个Map中,
			 *       其中key:user,pid
			 *           value:LogData实例
			 *   4.4:遍历登出Map,并根据每条登出日志的key
			 *       去登入Map中找到对应的登入日志,并
			 *       以一个LogRec实例保存该配对日志,然后
			 *       存入配对日志的集合中。并将该配对日志
			 *       中的登入日志从登入Map中删除。这样一来
			 *       登入Map中应当只剩下没有配对的了。
			 *  5:将配对日志写入到logRecFile中
			 *  6:将所有未配对日志写入到loginLogFile中
			 *  7:将textLogFile文件删除
			 *  8:返回true,表示配对完毕
			 * 
			 */
		try {
			//1
			//1.1
			if(logRecFile.exists()){
				return true;
			}
			//1.2
			if(!textLogFile.exists()){
				System.out.println(textLogFile+"不存在!");
				return false;
			}
			
			//2
			List<LogData> list 
				= IOUtil.loadLogData(textLogFile);
			
			//3
			if(loginLogFile.exists()){
				list.addAll(
					IOUtil.loadLogData(loginLogFile)
				);
			}
			
			//4
			//4.1
			List<LogRec> matches 
				= new ArrayList<LogRec>();
			//4.2
			Map<String,LogData> loginMap
				= new HashMap<String,LogData>();
			Map<String,LogData> logoutMap
				= new HashMap<String,LogData>();
			
			//4.3
			for(LogData logData : list){
				String key = logData.getUser()+","+
			               logData.getPid();
				if(logData.getType()==LogData.TYPE_LOGIN){
					loginMap.put(key, logData);
				}else	if(logData.getType()==LogData.TYPE_LOGOUT){
					logoutMap.put(key, logData);
				}
			}
			
			//4.4
			Set<Entry<String,LogData>> entrySet
					= logoutMap.entrySet();
			for(Entry<String,LogData> e : entrySet){
				LogData logout = e.getValue();
				LogData login = loginMap.remove(e.getKey());
				LogRec logRec = new LogRec(login,logout);
				matches.add(logRec);
			}
			
			//5
			IOUtil.saveCollection(matches, logRecFile);
			
			//6
			IOUtil.saveCollection(
					loginMap.values(),loginLogFile
			);
			
			//7
			textLogFile.delete();
			
			//8
			return true;
			
			
		} catch (Exception e) {
			System.out.println("配对日志失败!");
			e.printStackTrace();
		}
		return false;
	}
	
	/**
	 * 第一步:解析日志
	 * @return true:解析成功
	 *         false:解析失败
	 */
	private boolean parseLogs(){
		/*
		 * 实现思路:
		 * 循环读取batch条日志,然后将每条日志中的
		 * 5个信息解析出来,最终组成一个字符串,以
		 * 行为单位,写入到textLogFile文件中
		 * 
		 * 实现步骤:
		 * 1:必要的判断工作
		 *   1.1:为了避免解析的日志还没有被使用,而
		 *       第一步又重复执行导致之前日志被覆盖
		 *       的问题,这里需要判断,若保存解析后
		 *       的日志文件存在,则第一步不再执行。
		 *       该日志文件会在第二步配对完毕后删除。
		 *   1.2:logFile文件必须存在(wtmpx文件)
		 *   1.3:是否还有日志可以解析
		 * 2:创建RandomAccessFile来读取logFile
		 * 3:将指针移动到上次最后读取的位置,准备
		 *   开始新的解析工作
		 * 4:解析工作
		 *   4.1:创建一个List集合,用于保存解析后
		 *       的每一条日志(LogData实例)
		 *   4.2:循环batch次,解析每条日志中的
		 *       5项内容(user,pid,type,time,host)
		 *       并用一个LogData实例保存,然后将
		 *       该LogData实例存入集合
		 * 5:将集合中的所有的日志以行为单位保存到
		 *   textLogFile中 
		 * 6:保存书签信息         
		 * 7:返回true,表示工作完毕
		 * 
		 */
		RandomAccessFile raf = null;
		try {
			//1
			//1.1
			if(textLogFile.exists()){
				return true;
			}
			
			//1.2
			if(!logFile.exists()){
				System.out.println(logFile+"不存在!");
				return false;
			}
			//1.3
			long lastPosition = hasLogs();
			//打桩
//			System.out.println(
//					"lastPosition:"+lastPosition
//			);
			
			if(lastPosition<0){
				System.out.println("没有日志可以解析了!");
				return false;
			}
			
			//2
			raf = new RandomAccessFile(logFile,"r");
			
			//3
			raf.seek(lastPosition);
			
			//4
			List<LogData> list
				= new ArrayList<LogData>();
			for(int i=0;i<batch;i++){
				//每次解析前都判断是否还有日志可以解析
				if(logFile.length()-lastPosition
						<LogData.LOG_LENGTH
				){
					break;
				}
				//解析user
				raf.seek(lastPosition+LogData.USER_OFFSET);
				String user 
					= IOUtil.readString(
							raf, LogData.USER_LENGTH
						).trim();
				
				//解析PID
				raf.seek(lastPosition+LogData.PID_OFFSET);
				int pid = raf.readInt();
				
				//解析TYPE
				raf.seek(lastPosition+LogData.TYPE_OFFSET);
				short type = raf.readShort();
				
				//解析TIME
				raf.seek(lastPosition+LogData.TIME_OFFSET);
				int time = raf.readInt();
				
				//解析HOST
				raf.seek(lastPosition+LogData.HOST_OFFSET);
				String host 
					= IOUtil.readString(
							raf, LogData.HOST_LENGTH
						).trim();
				
				LogData log = new LogData(user, pid, type, time, host);
				
				list.add(log);
				//打桩
//				System.out.println(log);
				
				//当解析完一条日志后,更新lastPosition
				lastPosition = raf.getFilePointer();
			}
			
			//5
			IOUtil.saveCollection(list, textLogFile);
			
			//6 保存书签文件
			IOUtil.saveLong(
					lastPosition, lastPositionFile);
			
			//7
			return true;
			
			
		} catch (Exception e) {
			System.out.println("解析日志失败!");
			e.printStackTrace();
		} finally{
			if(raf != null){
				try {
					raf.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		return false;
	}
	/**
	 * 第一步解析日志中的一个环节,
	 * 根据书签文件记录的位置判断是否还有
	 * 日志可以解析,若有,则将上次最后的位置
	 * 返回,若没有则返回-1。
	 * @return
	 */
	private long hasLogs(){
		try {
			/*
			 * 若lastPositionFile不存在,则说明
			 * 从来没有解析过,那么从头开始解析即可
			 */
			if(!lastPositionFile.exists()){
				return 0;
			}
			
			long lastPosition 
				= IOUtil.readLong(lastPositionFile);
			
			if(logFile.length()-lastPosition
					>=LogData.LOG_LENGTH){
				return lastPosition;
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		return -1;
	}
	
	
	public static void main(String[] args) {
		try {
			DMSClient client = new DMSClient();
			client.start();
		} catch (Exception e) {
			System.out.println("客户端运行失败!");
		}
	}
}








package com.dms;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import com.dms.bo.LogData;

/**
 * 该类是一个工具类,负责客户端的IO操作
 * @author Administrator
 *
 */
public class IOUtil {
	/**
	 * 从给定的文件中读取每一行字符串(配对日志)
	 * 并存入一个集合后返回
	 * @param file
	 * @return
	 * @throws Exception 
	 */
	public static List<String> loadLogRec(File file) throws Exception{
		BufferedReader br = null;
		try {
			br = new BufferedReader(
				new InputStreamReader(
					new FileInputStream(
						file	
					)	
				)	
			);
			List<String> list 
				= new ArrayList<String>();
			String line = null;
			while((line = br.readLine())!=null){
				list.add(line);
			}
			return list;
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		} finally{
			if(br != null){
				br.close();
			}
		}
	}
	/**
	 * 从给定的文件中读取每一条配对日志,并存入
	 * 一个集合中然后返回。
	 * @param file
	 * @return
	 * @throws Exception 
	 */
	public static List<LogData> loadLogData(File file) throws Exception{
		BufferedReader br = null;
		try {
			br = new BufferedReader(
				new InputStreamReader(
					new FileInputStream(
						file	
					)	
				)	
			);
			List<LogData> list = new ArrayList<LogData>();
			String line = null;
			while((line = br.readLine())!=null){
				LogData logData = new LogData(line);
				list.add(logData);
			}
			return list;
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		} finally{
			if(br!=null){
				br.close();
			}
		}
	}
	
	/**
	 * 将指定的long值以字符串的形式写入到
	 * 给定文件的第一行
	 * @param l
	 * @param file
	 * @throws Exception 
	 */
	public static void saveLong(
					long lon,File file) throws Exception{
		PrintWriter pw = null;
		try {
			pw = new PrintWriter(file);
			pw.println(lon);
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		} finally{
			if(pw != null){
				pw.close();
			}
		}
	}
	
	/**
	 * 将集合中每个元素的toString方法返回的字符串
	 * 以行为单位写入到指定文件中。
	 * @param c
	 * @param file
	 * @throws Exception 
	 */
	public static void saveCollection(
								Collection c,File file) throws Exception{
		PrintWriter pw = null;
		try {
			pw = new PrintWriter(file);
			for(Object o : c){
				pw.println(o);
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		} finally{
			if(pw != null){
				pw.close();
			}
		}
	}
	
	/**
	 * 从给定的RandomAccessFile当前位置开始连续
	 * 读取length个字节,并转换为字符串后返回
	 * @param raf
	 * @param length
	 * @return
	 * @throws Exception 
	 */
	public static String readString(
					RandomAccessFile raf,int length) throws Exception{
		try {
			byte[] data = new byte[length];
			raf.read(data);
			return new String(data,"ISO8859-1");
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		}
	}
	
	/**
	 * 从给定文件中读取第一行字符串,然后将其
	 * 转换为一个long值后返回
	 * @param file
	 * @return
	 * @throws Exception 
	 */
	public static long readLong(File file) throws Exception{
		BufferedReader br = null;
		try {
			br = new BufferedReader(
				new InputStreamReader(
					new FileInputStream(
						file	
					)	
				)	
			);
			String line = br.readLine();
			return Long.parseLong(line);
		} catch (Exception e) {
			e.printStackTrace();
			throw e;
		} finally{
			if(br != null){
				br.close();
			}
		}
	}
}







<?xml version="1.0" encoding="UTF-8"?>
<config>
	<!-- unix系统日志文件名 -->
	<logfile>wtmpx</logfile>
	<!-- 保存解析后日志的文件名 -->
	<textlogfile>log.txt</textlogfile>
	<!-- 书签文件名 -->
	<lastpositionfile>last-position.txt</lastpositionfile>
	<!-- 每次解析日志的条目数 -->
	<batch>10</batch>
	<!-- 配对日志文件名 -->
	<logrecfile>logrec.txt</logrecfile>
	<!-- 未配对日志文件名 -->
	<loginlogfile>login.txt</loginlogfile>
	<!-- 服务端地址 -->
	<serverhost>localhost</serverhost>
	<!-- 服务端端口 -->
	<serverport>8088</serverport>
</config>








<?xml version="1.0" encoding="UTF-8"?>
<config>
	<!-- 服务端保存配对日志文件的文件名 -->
	<logrecfile>server-logs.txt</logrecfile>
	<!-- 线程池线程数量 -->
	<threadsum>30</threadsum>
	<!-- 服务端端口 -->
	<serverport>8088</serverport>
</config>








关注代码技巧免费领教程绝对可靠

代码技巧