java读取用户登入退出日志信息上传服务端

本文实例为大家分享了读取用户登入出日志并上传服务端的具体实现代码，供大家参考，具体内容如下

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

具体实现代码：

1. dmsserver.java

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();
        }
      }
    }
  }
}

2. dmsclient.java

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("客户端运行失败!");
    }
  }
}

3. ioutil.java

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();
      }
    }
  }
}

4. config.xml

<?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>

5.  server-config.xml

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

以上就是本文的全部内容，希望对大家的学习有所帮助。