java读取用户登入退出日志信息上传服务端
本文实例为大家分享了读取用户登入出日志并上传服务端的具体实现代码，供大家参考，具体内容如下
该客户端运行在给用户提供unix服务的服务器上。用来读取并收集该服务器上用户的上下线信息，并进行配对整理后发送给服务端汇总。
具体实现代码：
1.DMSServer.java
packagecom.dms;
importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
importjava.io.PrintWriter;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;
importjava.util.concurrent.BlockingQueue;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.LinkedBlockingQueue;
importorg.dom4j.Document;
importorg.dom4j.Element;
importorg.dom4j.io.SAXReader;
/**
*DMS服务端，用来接收每个客户端发送过来的
*配对日志并保存在本地文件中
*@authorAdministrator
*
*/
publicclassDMSServer{
//属性定义
//用来接收客户端连接的服务端的ServerSocket
privateServerSocketserver;
//用来管理处理客户端请求的线程的线程池
privateExecutorServicethreadPool;
//保存所有客户端发送过来配对日志的文件
privateFileserverLogFile;
//消息队列
privateBlockingQueue<String>messageQueue=newLinkedBlockingQueue<String>();
publicDMSServer()throwsException{
try{
System.out.println("服务端正在初始化...");
//1解析配置文件server-config.xml
Map<String,String>config=loadConfig();
//2根据配置文件内容初始化属性
init(config);
System.out.println("服务端初始化完毕...");
}catch(Exceptione){
System.out.println("初始化服务端失败!");
throwe;
}
}
/**
*构造方法初始化第一步，解析配置文件
*@return返回的Map中保存的是配置文件中的
*每一条内容，其中key:标签的名字，
*value为标签中间的文本
*@throwsException
*/
privateMap<String,String>loadConfig()throwsException{
try{
SAXReaderreader=newSAXReader();
Documentdoc
=reader.read(newFile("server-config.xml"));
Elementroot=doc.getRootElement();
Map<String,String>config
=newHashMap<String,String>();
/*
*获取<config>标签中的所有子标签
*并将每一个子标签的名字作为key,中间的
*文本作为value存入Map集合
*/
List<Element>list=root.elements();
for(Elemente:list){
Stringkey=e.getName();
Stringvalue=e.getTextTrim();
config.put(key,value);
}
returnconfig;
}catch(Exceptione){
System.out.println("解析配置文件异常!");
e.printStackTrace();
throwe;
}
}
/**
*构造方法初始化第二步,根据配置项初始化属性
*@paramconfig
*@throwsException
*/
privatevoidinit(Map<String,String>config)throwsException{
/*
*用配置文件中的<logrecfile>初始化属性：serverLogFile
*用配置文件中的<threadsum>初始化属性：threadPool，这里创建固定大小线程池。该值作为线程池线程数量
*用配置文件中的<serverport>初始化属性：server,这里这个值为ServerSocket的服务端口
*/
this.server=newServerSocket(
Integer.parseInt(config.get("serverport"))
);
this.serverLogFile=newFile(
config.get("logrecfile")
);
this.threadPool=Executors.newFixedThreadPool(
Integer.parseInt(config.get("threadsum"))
);
}
/**
*服务端开始工作的方法
*@throwsException
*/
publicvoidstart()throwsException{
/*
*实现要求:
*首先单独启动一个线程，用来运行SaveLogHandler
*这个任务，目的是保存所有配对日志
*然后开始循环监听服务端端口，一旦一个客户端连接了，
*就实例化一个ClientHander,然后将该任务交给线程池
*使其分配线程来处理与该客户端的交互。
*
*/
try{
System.out.println("服务端开始工作...");
SaveLogHandlerslh=newSaveLogHandler();
newThread(slh).start();
while(true){
Socketsocket=server.accept();
threadPool.execute(newClientHandler(socket));
}
}catch(Exceptione){
e.printStackTrace();
throwe;
}
}
publicstaticvoidmain(String[]args){
try{
DMSServerserver=newDMSServer();
server.start();
}catch(Exceptione){
System.out.println("启动服务端失败!");
}
}
/**
*该线程负责从消息队列中取出每一条配对日志，
*并存入到serverLogFile文件
*@authorAdministrator
*
*/
privateclassSaveLogHandlerimplementsRunnable{
publicvoidrun(){
PrintWriterpw=null;
try{
pw=newPrintWriter(
newFileOutputStream(
serverLogFile,true
)
);
while(true){
if(messageQueue.size()>0){
pw.println(messageQueue.poll());
}else{
pw.flush();
Thread.sleep(500);
}
}
}catch(Exceptione){
e.printStackTrace();
}finally{
if(pw!=null){
pw.close();
}
}
}
}
/**
*处理一个指定客户端请求
*@authorAdministrator
*
*/
privateclassClientHandlerimplementsRunnable{
privateSocketsocket;
publicClientHandler(Socketsocket){
this.socket=socket;
}
publicvoidrun(){
/*
*思路:
*首先接收客户端发送过来的所有配对日志，
*直到读取到"OVER"为止，然后将这些配对
*日志保存到本地的文件中，并回复客户端
*"OK"
*执行步骤:
*1:通过Socket创建输出流，用来给客户端
*发送响应
*2:通过Socket创建输入流，读取客户端发送
*过来的日志
*3:循环读取客户端发送过来的每一行字符串，并
*先判断是否为字符串"OVER",若不是，则是
*一条配对日志，那么保存到本地文件，若是，
*则停止读取。
*4:成功读取所有日志后回复客户端"OK"
*/
PrintWriterpw=null;
try{
//1
pw=newPrintWriter(
newOutputStreamWriter(
socket.getOutputStream(),"UTF-8"
)
);
//2
BufferedReaderbr=newBufferedReader(
newInputStreamReader(
socket.getInputStream(),"UTF-8"
)
);
//3
Stringmessage=null;
while((message=br.readLine())!=null){
if("OVER".equals(message)){
break;
}
//将该日志写入文件保存
messageQueue.offer(message);
}
//4
pw.println("OK");
pw.flush();
}catch(Exceptione){
e.printStackTrace();
pw.println("ERROR");
pw.flush();
}finally{
try{
//与客户端断开连接释放资源
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}
}
2.DMSClient.java
packagecom.dms;
importjava.io.BufferedReader;
importjava.io.File;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
importjava.io.PrintWriter;
importjava.io.RandomAccessFile;
importjava.net.Socket;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;
importjava.util.Map.Entry;
importjava.util.Set;
importorg.dom4j.Document;
importorg.dom4j.Element;
importorg.dom4j.io.SAXReader;
importcom.dms.bo.LogData;
importcom.dms.bo.LogRec;
/**
*该客户端运行在给用户提供unix服务的服务器上。
*用来读取并收集该服务器上用户的上下线信息，并
*进行配对整理后发送给服务端汇总。
*@authorAdministrator
*
*/
publicclassDMSClient{
//属性定义
//第一步:解析日志所需属性
//unix系统日志文件
privateFilelogFile;
//保存解析后日志的文件
privateFiletextLogFile;
//书签文件
privateFilelastPositionFile;
//每次解析日志的条目数
privateintbatch;
//第二步:配对日志所需要属性
//保存配对日志的文件
privateFilelogRecFile;
//保存未配对日志的文件
privateFileloginLogFile;
//第三步:发送日志所需要属性
//服务端地址
privateStringserverHost;
//服务端端口
privateintserverPort;
/**
*构造方法，用来初始化客户端
*@throwsException
*/
publicDMSClient()throwsException{
try{
//1解析配置文件config.xml
Map<String,String>config=loadConfig();
//打桩
System.out.println(config);
//2根据配置文件内容初始化属性
init(config);
}catch(Exceptione){
System.out.println("初始化失败!");
throwe;
}
}
/**
*构造方法初始化第二步,根据配置项初始化属性
*@paramconfig
*@throwsException
*/
privatevoidinit(Map<String,String>config)throwsException{
try{
logFile=newFile(
config.get("logfile")
);
textLogFile=newFile(
config.get("textlogfile")
);
lastPositionFile=newFile(
config.get("lastpositionfile")
);
batch=Integer.parseInt(
config.get("batch")
);
logRecFile=newFile(
config.get("logrecfile")
);
loginLogFile=newFile(
config.get("loginlogfile")
);
serverHost=config.get("serverhost");
serverPort=Integer.parseInt(
config.get("serverport")
);
}catch(Exceptione){
System.out.println("初始化属性失败!");
e.printStackTrace();
throwe;
}
}
/**
*构造方法初始化第一步，解析配置文件
*@return返回的Map中保存的是配置文件中的
*每一条内容，其中key:标签的名字，
*value为标签中间的文本
*@throwsException
*/
privateMap<String,String>loadConfig()throwsException{
try{
SAXReaderreader=newSAXReader();
Documentdoc
=reader.read(newFile("config.xml"));
Elementroot=doc.getRootElement();
Map<String,String>config
=newHashMap<String,String>();
/*
*获取<config>标签中的所有子标签
*并将每一个子标签的名字作为key,中间的
*文本作为value存入Map集合
*/
List<Element>list=root.elements();
for(Elemente:list){
Stringkey=e.getName();
Stringvalue=e.getTextTrim();
config.put(key,value);
}
returnconfig;
}catch(Exceptione){
System.out.println("解析配置文件异常!");
e.printStackTrace();
throwe;
}
}
/**
*客户端开始工作的方法
*循环执行三步:
*1:解析日志
*2:配对日志
*3:发送日志
*/
publicvoidstart(){
parseLogs();
matchLogs();
sendLogs();
//while(true){
////解析日志
//if(!parseLogs()){
//continue;
//}
////配对日志
//if(!matchLogs()){
//continue;
//}
////发送日志
//sendLogs();
//}
}
/**
*第三步:发送日志
*@returntrue:发送成功
*false:发送失败
*/
privatebooleansendLogs(){
/*
*实现思路:
*将logRecFile文件中的所有配对日志读取
*出来然后连接上服务端并发送过去，若服务端
*全部接收，就可以将该文件删除，表示发送
*完毕了。
*实现步骤:
*1:logRecFile文件必须存在
*2:将所有配对日志读取出来并存入一个集合
*等待发送
*3:通过Socket连接服务端
*4:创建输出流
*5:顺序将所有配对日志按行发送给服务端
*6:单独发送一个字符串"OVER"表示所有日志
*均已发送完毕
*7:创建输入流
*8:读取服务端发送回来的响应字符串
*9:若响应的字符串为"OK",表示服务端正常
*接收了所有日志,这时就可以将logRecFile
*文件删除并返回true表示发送完毕。
*
*/
Socketsocket=null;
try{
//1
if(!logRecFile.exists()){
System.out.println(logRecFile+"不存在!");
returnfalse;
}
//2
List<String>matches
=IOUtil.loadLogRec(logRecFile);
//3
socket=newSocket(serverHost,serverPort);
//4
PrintWriterpw=newPrintWriter(
newOutputStreamWriter(
socket.getOutputStream(),"UTF-8"
)
);
//5
for(Stringlog:matches){
pw.println(log);
}
//6
pw.println("OVER");
pw.flush();
//7
BufferedReaderbr=newBufferedReader(
newInputStreamReader(
socket.getInputStream(),"UTF-8"
)
);
//8
Stringresponse=br.readLine();
//9
if("OK".equals(response)){
logRecFile.delete();
returntrue;
}else{
System.out.println("发送日志失败!");
returnfalse;
}
}catch(Exceptione){
System.out.println("发送日志失败!");
e.printStackTrace();
}finally{
if(socket!=null){
try{
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
returnfalse;
}
/**
*第二步:配对日志
*@returntrue:配对成功
*false:配对失败
*/
privatebooleanmatchLogs(){
/*
*实现思路:
*将第一步解析的新日志，与上次为配对成功
*的登入日志全部读取出来，然后再按照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()){
returntrue;
}
//1.2
if(!textLogFile.exists()){
System.out.println(textLogFile+"不存在!");
returnfalse;
}
//2
List<LogData>list
=IOUtil.loadLogData(textLogFile);
//3
if(loginLogFile.exists()){
list.addAll(
IOUtil.loadLogData(loginLogFile)
);
}
//4
//4.1
List<LogRec>matches
=newArrayList<LogRec>();
//4.2
Map<String,LogData>loginMap
=newHashMap<String,LogData>();
Map<String,LogData>logoutMap
=newHashMap<String,LogData>();
//4.3
for(LogDatalogData:list){
Stringkey=logData.getUser()+","+
logData.getPid();
if(logData.getType()==LogData.TYPE_LOGIN){
loginMap.put(key,logData);
}elseif(logData.getType()==LogData.TYPE_LOGOUT){
logoutMap.put(key,logData);
}
}
//4.4
Set<Entry<String,LogData>>entrySet
=logoutMap.entrySet();
for(Entry<String,LogData>e:entrySet){
LogDatalogout=e.getValue();
LogDatalogin=loginMap.remove(e.getKey());
LogReclogRec=newLogRec(login,logout);
matches.add(logRec);
}
//5
IOUtil.saveCollection(matches,logRecFile);
//6
IOUtil.saveCollection(
loginMap.values(),loginLogFile
);
//7
textLogFile.delete();
//8
returntrue;
}catch(Exceptione){
System.out.println("配对日志失败!");
e.printStackTrace();
}
returnfalse;
}
/**
*第一步:解析日志
*@returntrue:解析成功
*false:解析失败
*/
privatebooleanparseLogs(){
/*
*实现思路:
*循环读取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,表示工作完毕
*
*/
RandomAccessFileraf=null;
try{
//1
//1.1
if(textLogFile.exists()){
returntrue;
}
//1.2
if(!logFile.exists()){
System.out.println(logFile+"不存在!");
returnfalse;
}
//1.3
longlastPosition=hasLogs();
//打桩
//System.out.println(
//"lastPosition:"+lastPosition
//);
if(lastPosition<0){
System.out.println("没有日志可以解析了!");
returnfalse;
}
//2
raf=newRandomAccessFile(logFile,"r");
//3
raf.seek(lastPosition);
//4
List<LogData>list
=newArrayList<LogData>();
for(inti=0;i<batch;i++){
//每次解析前都判断是否还有日志可以解析
if(logFile.length()-lastPosition
<LogData.LOG_LENGTH
){
break;
}
//解析user
raf.seek(lastPosition+LogData.USER_OFFSET);
Stringuser
=IOUtil.readString(
raf,LogData.USER_LENGTH
).trim();
//解析PID
raf.seek(lastPosition+LogData.PID_OFFSET);
intpid=raf.readInt();
//解析TYPE
raf.seek(lastPosition+LogData.TYPE_OFFSET);
shorttype=raf.readShort();
//解析TIME
raf.seek(lastPosition+LogData.TIME_OFFSET);
inttime=raf.readInt();
//解析HOST
raf.seek(lastPosition+LogData.HOST_OFFSET);
Stringhost
=IOUtil.readString(
raf,LogData.HOST_LENGTH
).trim();
LogDatalog=newLogData(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
returntrue;
}catch(Exceptione){
System.out.println("解析日志失败!");
e.printStackTrace();
}finally{
if(raf!=null){
try{
raf.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
returnfalse;
}
/**
*第一步解析日志中的一个环节，
*根据书签文件记录的位置判断是否还有
*日志可以解析，若有，则将上次最后的位置
*返回，若没有则返回-1。
*@return
*/
privatelonghasLogs(){
try{
/*
*若lastPositionFile不存在，则说明
*从来没有解析过，那么从头开始解析即可
*/
if(!lastPositionFile.exists()){
return0;
}
longlastPosition
=IOUtil.readLong(lastPositionFile);
if(logFile.length()-lastPosition
>=LogData.LOG_LENGTH){
returnlastPosition;
}
}catch(Exceptione){
e.printStackTrace();
}
return-1;
}
publicstaticvoidmain(String[]args){
try{
DMSClientclient=newDMSClient();
client.start();
}catch(Exceptione){
System.out.println("客户端运行失败!");
}
}
}
3.IOUtil.java
packagecom.dms;
importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.io.RandomAccessFile;
importjava.util.ArrayList;
importjava.util.Collection;
importjava.util.List;
importcom.dms.bo.LogData;
/**
*该类是一个工具类，负责客户端的IO操作
*@authorAdministrator
*
*/
publicclassIOUtil{
/**
*从给定的文件中读取每一行字符串(配对日志)
*并存入一个集合后返回
*@paramfile
*@return
*@throwsException
*/
publicstaticList<String>loadLogRec(Filefile)throwsException{
BufferedReaderbr=null;
try{
br=newBufferedReader(
newInputStreamReader(
newFileInputStream(
file
)
)
);
List<String>list
=newArrayList<String>();
Stringline=null;
while((line=br.readLine())!=null){
list.add(line);
}
returnlist;
}catch(Exceptione){
e.printStackTrace();
throwe;
}finally{
if(br!=null){
br.close();
}
}
}
/**
*从给定的文件中读取每一条配对日志，并存入
*一个集合中然后返回。
*@paramfile
*@return
*@throwsException
*/
publicstaticList<LogData>loadLogData(Filefile)throwsException{
BufferedReaderbr=null;
try{
br=newBufferedReader(
newInputStreamReader(
newFileInputStream(
file
)
)
);
List<LogData>list=newArrayList<LogData>();
Stringline=null;
while((line=br.readLine())!=null){
LogDatalogData=newLogData(line);
list.add(logData);
}
returnlist;
}catch(Exceptione){
e.printStackTrace();
throwe;
}finally{
if(br!=null){
br.close();
}
}
}
/**
*将指定的long值以字符串的形式写入到
*给定文件的第一行
*@paraml
*@paramfile
*@throwsException
*/
publicstaticvoidsaveLong(
longlon,Filefile)throwsException{
PrintWriterpw=null;
try{
pw=newPrintWriter(file);
pw.println(lon);
}catch(Exceptione){
e.printStackTrace();
throwe;
}finally{
if(pw!=null){
pw.close();
}
}
}
/**
*将集合中每个元素的toString方法返回的字符串
*以行为单位写入到指定文件中。
*@paramc
*@paramfile
*@throwsException
*/
publicstaticvoidsaveCollection(
Collectionc,Filefile)throwsException{
PrintWriterpw=null;
try{
pw=newPrintWriter(file);
for(Objecto:c){
pw.println(o);
}
}catch(Exceptione){
e.printStackTrace();
throwe;
}finally{
if(pw!=null){
pw.close();
}
}
}
/**
*从给定的RandomAccessFile当前位置开始连续
*读取length个字节，并转换为字符串后返回
*@paramraf
*@paramlength
*@return
*@throwsException
*/
publicstaticStringreadString(
RandomAccessFileraf,intlength)throwsException{
try{
byte[]data=newbyte[length];
raf.read(data);
returnnewString(data,"ISO8859-1");
}catch(Exceptione){
e.printStackTrace();
throwe;
}
}
/**
*从给定文件中读取第一行字符串，然后将其
*转换为一个long值后返回
*@paramfile
*@return
*@throwsException
*/
publicstaticlongreadLong(Filefile)throwsException{
BufferedReaderbr=null;
try{
br=newBufferedReader(
newInputStreamReader(
newFileInputStream(
file
)
)
);
Stringline=br.readLine();
returnLong.parseLong(line);
}catch(Exceptione){
e.printStackTrace();
throwe;
}finally{
if(br!=null){
br.close();
}
}
}
}
4.config.xml
<?xmlversion="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>
5. server-config.xml
<?xmlversion="1.0"encoding="UTF-8"?> <config> <!--服务端保存配对日志文件的文件名--> <logrecfile>server-logs.txt</logrecfile> <!--线程池线程数量--> <threadsum>30</threadsum> <!--服务端端口--> <serverport>8088</serverport> </config>
以上就是本文的全部内容，希望对大家的学习有所帮助。