Este ejemplo comparte el código de implementación específico para leer el inicio de sesión del usuario y la carga del servidor para su referencia. El contenido específico es el siguiente
El cliente se ejecuta en un servidor que proporciona al usuario servicios UNIX. Se usa para leer y recopilar la información aguas arriba y aguas abajo de los usuarios en el servidor, combinarlos y organizarlos, y luego enviarlos al servidor para su resumen.
Código de implementación específico:
1. Dmsserver.java
paquete 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.preintwriter; import java.net.net.serversocket; import java.net; java.util.hashmap; import java.util.list; import java.util.map; import java.util.concurrent.blockingqueue; import java.util.concurrent.executorservice; import java.util.concutors.executors; importación; importar org.dom4j.document; import org.dom4j.element; import org.dom4j.io.saxreader; /** * servidor DMS, utilizado para recibir * registros de emparejamiento enviados por cada cliente y guardarlos en un archivo local * @author administrador * */public class DMSServer {// Definición de propiedades // Serversocket Servidor de Servidor de Servidor de Servidor se usa para recibir el servidor conectado al cliente; // Grupo de subprocesos utilizado para administrar los subprocesos que manejan las solicitudes del cliente Executorservice Threadpool; // Guardar todos los archivos enviados por los clientes para emparejar registros de archivos privados ServerLogFile; // Message cola Bloqueo privado <string> Messagequeue = new LinkedBlowingqueue <string> (); public dmsserver () lanza excepción {try {system.out.println ("El servidor está inicializando ..."); // 1 Pase el servidor de archivos de configuración-config.xml map <string, string> config = loadConfig (); // 2 inicializa el atributo init (config); System.out.println ("Inicialización del servidor completada ..."); } catch (Exception e) {System.out.println ("¡Inicialización fallida!"); tirar E; }} / *** El primer paso para inicializar el método del constructor es analizar el archivo de configuración* @return El mapa devuelto se guarda en cada elemento del archivo de configuración, donde la tecla: el nombre de la etiqueta,* valor es el texto en el medio del etiqueta* @throws excepción* / mapa privado <string> loadconfig () Excepción de excepción {try inty {saxreader ‘saxreer = new saxreader (new sax Reader ();););););); Documento doc = Reader.read (nuevo archivo ("Server-Config.xml")); Elemento root = doc.getRootElement (); Map <string, string> config = new HashMap <String, String> (); /** Obtenga todas las sub-etiquetas en la etiqueta <Entafact> y guarde el nombre de cada sub-TAG como clave, y el texto* en el medio es valor en la colección de mapas*/ list <ememem> list = root.elements (); for (elemento e: list) {string key = e.getName (); Valor de cadena = E.GetTextTrim (); config.put (clave, valor); } return config; } Catch (Exception e) {System.out.println ("Resistir la excepción del archivo de configuración!"); E.PrintStackTrace (); tirar E; }} /** * El segundo paso de inicializar el método del constructor es inicializar el atributo de acuerdo con el elemento de configuración * @param config * @throws excepción * /private void init (map <string, string> config) lanza la excepción { / * * inicializar el atributo con <logrecfile> en el archivo de configuración de la configuración: servidor: servidor * Inicializar la propiedad: hilo de la propiedad con <streatsum> en el archivo de shusing, en el archivo de configuración de fijación, donde está configurado. creado. Este valor se usa como el número de subprocesos de grupo de subprocesos* Inicialice la propiedad con <ververport> En el archivo de configuración: servidor, aquí este valor es el puerto del servidor de ServerSocket*/ this.server = new Serversocket (integer.parseInt (config.get ("serverport")))); this.serverLogFile = new File (config.get ("logrecfile")); this.threadPool = ejecutors.newFixedThreadPool (integer.parseInt (config.get ("threadsum"))); } /** * Método para comenzar a trabajar en el servidor * @throws Exception * /public void start () lanza la excepción { / * * Requisitos de implementación: * Primero inicie un hilo por separado para ejecutar el saveloghandler * Esta tarea es guardar todos los registros de emparejamiento * y luego comenzar a escuchar el bucle de puertos del servidor. Una vez que un cliente está conectado, * instanciar a un cliente cliente y luego entregar la tarea al grupo de subprocesos * para asignar subprocesos para manejar la interacción con el cliente. * */ try {System.out.println ("El servidor comienza a funcionar ..."); Saveloghandler slh = new Saveloghandler (); nuevo hilo (slh) .Start (); while (true) {socket socket = server.accept (); threadpool.execute (New ClientHandler (Socket)); }} catch (Exception e) {E.PrintStackTrace (); tirar E; }} public static void main (string [] args) {try {dmsserver server = new dmsServer (); servidor.start (); } Catch (Exception e) {System.out.println ("¡La estación no pudo iniciar el servidor!"); }}} / ** * Este hilo es responsable de obtener cada registro emparejado de la cola de mensajes, * y guardarlo en el archivo ServerLogFile * @Author Administrator * * / Private Class SavelogHandler implementos runnables {public void run () {printWriter pw = null; intente {pw = new PrintWriter (nuevo FileOutputStream (ServerLogFile, true)); while (true) {if (messagequeue.size ()> 0) {pw.println (messagequeue.poll ()); } else {pw.flush (); Thread.sleep (500); }}} Catch (Exception e) {E.PrintStackTrace (); } finalmente {if (pw! = null) {pw.close (); }}}}} / ** * Manejar una solicitud de cliente especificada * @author administrador * * / private clase ClientHandler implementa runnable {private socket socket; Public ClientHandler (Socket Socket) {this.socket = Socket; } public void run(){ /* * Idea: * First receive all paired logs sent by the client, * until "OVER", then save these paired* logs to the local file, and reply to the client * "OK" * Execute steps: * 1: Create an output stream through Socket to send a response to the client * 2: Create an input stream through Socket, read the logs sent by the client * 3: Read each line of string sent by the client, and * first determine whether it is the Cadena "Over". Si no, es un registro emparejado y guárdelo en el archivo local. Si es así, * deja de leer. * 4: Responda al cliente "OK" después de leer con éxito todos los registros */ PrintWriter pw = null; Pruebe {// 1 pw = new PrintWriter (new OutputStreamWriter (Socket.getOutputStream (), "UTF-8")); // 2 BufferedReader BR = New BufferedReader (new InputStreamReader (Socket.getInputStream (), "UTF-8")); // Message de 3 cadenas = NULL; while ((mensaje = br.readline ())! = null) {if ("over" .equals (mensaje)) {break; } // Escriba el registro en un archivo para guardar Messagequeue.offer (mensaje); } // 4 pw.println ("ok"); pw.flush (); } catch (Exception e) {E.PrintStackTrace (); pw.println ("error"); pw.flush (); } Finalmente {try {// Desconecte del cliente para liberar el recurso Socket.close (); } catch (ioException e) {E.PrintStackTrace (); }}}}}}}}}}}} 2. Dmsclient.java
paquete 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.util.util.util.util.utily; java.util.hashmap; import java.util.list; import java.util.map; import java.util.map.entry; import java.util.set; importar org.dom4j.document; import org.dom4j.element; import org.dom4j.io.saxreader; import com.dms.bo.logdata; import com.dms.bo.logrec; /*** Este cliente se ejecuta en el servidor que proporciona a los usuarios servicios UNIX. * Se usó para leer y recopilar la información aguas arriba y aguas abajo de los usuarios en el servidor, y * emparejarlos y ordenarlos y enviarlos al servidor para su resumen. * @Author Administrator * */public class DMSClient {// Definición de atributos // Paso 1: Analice las propiedades requeridas del archivo de registro del sistema de registro de LOG // UNIX LOGFILE; // Guardar el archivo del archivo de registro analizado TextLogFile; // Archivo de marcador Archivo privado LastPositionFile; // Número de entradas para cada registro de análisis privado int lote; // Paso 2: Empareje los atributos del registro // Guardar el archivo de archivo privado logrecfile; // Guardar el archivo de archivo privado LoginLogFile; // Paso 3: analice los atributos del registro // dirección del servidor String String ServerHost; // Puerto de servidor privado int serverport; /*** Método del constructor, utilizado para inicializar la excepción del cliente* @throws*/public dmsclient () lanza la excepción {try {// 1 analizar el archivo de configuración config.xml map <string, string> config = loadConfig (); // Pilation System.out.println (config); // 2 inicializa el atributo init (config); } catch (Exception e) {System.out.println ("¡Inicialización fallida!"); tirar E; }} / ** * Inicialice el segundo paso del método Constructor, inicialice los atributos de acuerdo con el elemento de configuración * @param config * @throws excepción * / private void init (map <string, string> config) lanza la excepción {try {logFile = new File (config.get ("logFile"); textLogFile = new File (config.get ("textLogFile")); lastPositionFile = new File (config.get ("lastPositionFile")); lote = Integer.ParseInt (config.get ("lote")); logrecfile = nuevo archivo (config.get ("logrecfile")); LoginLogFile = new File (config.get ("LoginLogFile")); servidorHost = config.get ("serverhost"); serverport = integer.parseInt (config.get ("serverport")); } catch (Exception e) {System.out.println ("¡Propiedad de inicialización fallida!"); E.PrintStackTrace (); tirar E; }} / ** * El primer paso en la inicialización del método del constructor es analizar el archivo de configuración * @return El mapa devuelto se guarda en cada elemento del archivo de configuración, donde la tecla: el nombre de la etiqueta, * valor es el texto en el medio del etiqueta * @throws mapa * / private <string, string> loadconfig () lanza excepción {try {saxreader readerer = new sax Reader = new Saxreader = new saxrewews * / private Map <String, String, String> LoadConfig () se lanza excepción {intent {saxreader readerer = new saxreader = new saxreader = new saxrews * / private Map <String, String> LoadConfig (). Documento doc = lector.read (nuevo archivo ("config.xml")); Elemento root = doc.getRootElement (); Map <string, string> config = new HashMap <String, String> (); /** Obtenga todas las sub-etiquetas en la etiqueta <Entafact> y use el nombre de cada sub-TAG como clave, el texto* en el medio en el medio se almacena en la colección de mapas como valor*/ list <emement> list = root.elements (); for (elemento e: list) {string key = e.getName (); Valor de cadena = E.GetTextTrim (); config.put (clave, valor); } return config; } Catch (Exception e) {System.out.println ("¡Excepción del archivo de configuración de analizador!"); E.PrintStackTrace (); tirar E; }} / *** Método para que el cliente comience a trabajar* Tres pasos del bucle:* 1: analizar el registro* 2: emparejarse el registro* 3: Enviar el registro* / public void start () {parselogs (); MatchLogs (); sendLogs (); // while (true) {// // parse log // if (! parselogs ()) {// continúa; //} // // emparejando log /// if (! MatchLogs ()) {// continúa; //} // // Enviar LOG // SENDLOGS () ;// *** Step 3: Enviar Log* fallido* / private boolean sendLogs () { /** Idea de implementación:* Lea todos los registros emparejados en el archivo LogRecfile* y conecte al servidor y envíelo, si el servidor* si los recibe todos, puede eliminar el archivo, lo que significa que el envío* se completa. * Pasos de implementación:* 1: El archivo de loGRecfile debe existir* 2: Leer y almacenar todos los registros emparejados en una colección* Espere para enviar* 3: Conecte al servidor a través de Socket* 4: Cree de salida SEMANDER* 5: Envíe todos los registros emparejados en secuencia al servidor en línea* 6: Envíe una sola cadena "para indicar que todos los registros* se han enviado* 7: Crear flujo de entrada* 8: Read la cadena de respuesta: la cadena de respuesta: la cadena de respuesta: la cadena de respuesta: la cadena de respuesta: la cadena de respuesta: la cadena de respuesta: si la cadena de respuesta es la cadena de respuesta. "OK", significa que el servidor es normal * ha recibido todos los registros, y luego el archivo LogRecfile * se puede eliminar y devolverse verdadero significa que el envío se completa. * */ Socket socket = null; Pruebe {// 1 if (! logrecfile.exists ()) {system.out.println (logrecfile+"no existen!"); devolver falso; } // 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 para (String Log: Matches) {pw.println (log); } // 6 pw.println ("over"); pw.flush (); // 7 BufferedReader BR = New BufferedReader (new InputStreamReader (Socket.getInputStream (), "UTF-8")); // Respuesta de 8 cadenas = br.readline (); // 9 if ("ok" .equals (respuesta)) {logrecfile.delete (); devolver verdadero; } else {System.out.println ("Enviar registro de registro!"); devolver falso; }} capt (excepción e) {system.out.println ("Enviar registro fallido!"); E.PrintStackTrace (); } Finalmente {if (Socket! = Null) {try {Socket.close (); } catch (ioException e) {E.PrintStackTrace (); }} return false; } /*** Paso 2: Empareje el registro* @return true: emparejamiento con éxito* falso: emparejamiento fallido* /private boolean matchlogs () { /** Idea de implementación:* Leer todo el nuevo registro analizado en el primer paso con el registro de registro que fue el último emparejado con éxito* y luego seguir al usuario,* el mismo PID, uno es 7 y el otro es 8 para el emparejamiento. * Siempre que pueda encontrar un Tipo 8, puede encontrar un registro de inicio de sesión que pueda emparejarse con *. * * Pasos de implementación: * 1: Sentencia necesaria * 1.1: Si existe logrecfile. Si existe, ya no será * Se realizará un nuevo trabajo de emparejamiento para evitar sobrescribir. * 1.2: El archivo TextLogFile debe existir. * 2: Lea TextLogFile y lea los registros y * a la colección. (Several LogData instances) * 3: If the loginLogFile file exists, it means * There is a log that was not paired successfully last time, and it is also read * and saved in the collection waiting to be paired together* 4: Pairing work* 4.1: Create a collection to save all paired logs* 4.2: Create two maps to save login and logout logs* 4.3: traverse all logs to be paired and save them into two maps according to Iniciar sesión e inicio de sesión * * Donde la tecla: Usuario, PID * Valor: Instancia de LogData * 4.4: atraviese el mapa de inicio de sesión y encuentre el registro de inicio de sesión correspondiente en el mapa de inicio de sesión de acuerdo con la clave * de cada registro de inicio de sesión, y * guarde el registro emparejado en el conjunto de registros pareados. Y elimine el registro de inicio de sesión en el registro emparejado* del mapa de inicio de sesión. De esta manera, ** solo no debería tener ningún emparejamiento cuando inicie sesión en el mapa. * 5: Escriba registros emparejados a logrecfile* 6: escriba todos los registros no apareados en LoginLogFile* 7: Eliminar el archivo TextLogFile* 8: return True, indicando que el emparejamiento se completa**/try {// 1 //1.1 if (logrecfile.exists ()) {return true; } //1.2 if (! TextLogFile.Exists ()) {System.out.println (TextLogFile+"¡No existir!"); devolver falso; } // 2 list <RogData> list = ioutil.loadLogData (TextLogFile); // 3 if (loginLogFile.Exists ()) {list.addall (ioutil.loadLogData (LoginLogFile)); } // 4 //4.1 Lista <logrec> coincidentes = new ArrayList <logrec> (); //4.2 map <string, logData> loginmap = new Hashmap <String, LogData> (); Map <string, logData> logOutMap = new HashMap <String, LogData> (); //4.3 para (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 (entrada <string, logData> e: EntrySet) {logData logOut = e.getValue (); LogData login = loginmap.remove (e.getKey ()); Logrec logrec = new Logreg (inicio de sesión, inicio de sesión); Matches.Add (logrec); } // 5 ioutil.savecollection (coincidencias, logrecfile); // 6 ioutil.savecollection (LoginMap.Values (), LoginLogFile); // 7 textlogFile.delete (); // 8 devolver verdadero; } catch (Exception e) {System.out.println ("¡fallado en el registro de emparejamiento!"); E.PrintStackTrace (); } return false; } /*** Paso 1: analice el registro* @return true: parse exitoso* falso: parse fallido* /private boolean parselogs () { /** Idea de implementación:* Logos de lotes de lectura de bucle, luego Parse* 5 Información en cada registro, y finalmente forme una cadena, escriba el archivo TextLogFile en* unidades de comportamiento** Pasos de implementación:* 1: Trabajo de juicio necesario* 1.1:: ¿Se utiliza la cadena de la cadena? y * El primer paso repite la ejecución, haciendo que el registro anterior se sobrescribiera *, debe juzgar aquí. Si guarda el registro analizado* el archivo de registro existe y el primer paso ya no se ejecutará. * Este archivo de registro se eliminará después de emparejarse el segundo paso. * 1.2: El archivo de archivo de registro debe existir (archivo wtmpx) * 1.3: todavía hay un registro que se pueda analizar * 2: cree un randomaccessfile para leer el archivo de registro * 3: mueva el puntero a la última posición de lectura, prepare * iniciar un nuevo trabajo de análisis * 4: parsing work * 4.1: Crear una recopilación de la lista para guardar cada registro de registro (la instancia de logdata) * 4.2: Cada registro (usuario, PID, Tipo, Tiempo, Host) * y guárdelo con una instancia de LogData, y luego guarde * la instancia de LogData en la colección * 5: Guardar todos los registros en la colección en unidades de comportamiento a * TextLogFile * 6: Guardar información de marcador * 7: Return True, indicando que el trabajo se completa * */ RandomAccessfile RAF = null; intente {// 1 //1.1 if (textLogFile.Exists ()) {return true; } //1.2 if (! LogFile.exists ()) {System.out.println (logFile+"¡No existir!"); devolver falso; } //1.3 Long LastPosition = HasLogs (); // Pilating // System.out.println (// "LastPosition:"+LastPosition //); if (lastPosition <0) {System.out.println ("¡No se pueden analizar registros!"); devolver falso; } // 2 raf = new RandomAccessFile (logFile, "r"); // 3 raf.seek (LastPosition); // 4 list <RogData> list = new ArrayList <RogData> (); para (int i = 0; i <batch; i ++) {// Antes de cada análisis, determine si todavía hay registros que se pueden analizar si (logFile.length ()-lastPosition <logData.log_length) {break; } // analizar el usuario raf.seek (lastPosition+logData.user_offset); String user = ioutil.ReadString (raf, logData.user_length) .trim (); // analizar PID raf.seek (lastPosition+logData.pid_offset); int pid = raf.readInt (); // Tipo de analizador Raf.seek (LastPosition+LogData.Type_OffSet); tipo corto = raf.readshort (); // tiempo de analización raf.seek (lastPosition+logData.time_offset); int time = raf.readInt (); // pegar host raf.seek (lastPosition+logData.host_offset); String host = ioutil.readString (raf, logData.host_length) .trim (); LogData log = new LogData (usuario, pid, type, tiempo, host); list.add (log); // pilando // system.out.println (log); // cargar un registro, actualizar lastPosition lastPosition = raf.getFilePointer (); } // 5 ioutil.savecollection (lista, textlogFile); // 6 Guardar el archivo de marcador ioutil.savelong (LastPosition, LastPositionFile); // 7 return verdadero; } catch (Exception e) {System.out.println ("¡Pasando el registro fallido!"); E.PrintStackTrace (); } finalmente {if (raf! = null) {try {raf.close (); } catch (ioException e) {E.PrintStackTrace (); }} return false; } /*** El primer paso es analizar un enlace en el registro. * Según la ubicación del registro del archivo de marcador, determine si todavía hay * registro para analizar. Si lo hay, se devolverá la última posición*. Si no hay, return -1. * @return */ private long hasLogs () {try {/ * * Si LastPositionFile no existe, significa que * nunca se ha analizado, por lo que puede analizar desde cero */ 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 ("¡Falló en el cliente!"); }}} 3. Ioutil.java
paquete 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.araylist; import java.util.collection; com.dms.bo.logdata; /** * Esta clase es una clase de herramientas que es responsable de las operaciones IO del cliente * @Author Administrator * */public class Ioutil {/** * Lea cada línea de cadena desde el archivo dado (registro de pares) * y guarde una colección para devolver * @param archivo * @return * @throws excepción */public static list <string> loadlogrec (archivo de archivo) arroja excepción {buffedreer rereader; intente {br = new BufferedReader (new InputStreamReader (new FileInputStream (File))); List <String> list = new ArrayList <String> (); Línea de cadena = nulo; while ((línea = br.readline ())! = null) {list.add (línea); } Lista de retorno; } catch (Exception e) {E.PrintStackTrace (); tirar E; } finalmente {if (br! = null) {br.close (); }}} /** * Lea cada registro emparejado del archivo dado y guárdelo en * una colección y luego regrese. * @param archivo * @return * @throws excepción */ public static list <nogData> LoadLogData (archivo de archivo) lanza la excepción {BufferedReader br = null; intente {br = new BufferedReader (new InputStreamReader (new FileInputStream (File))); List <RogData> list = new ArrayList <RogData> (); Línea de cadena = nulo; while ((línea = br.readline ())! = null) {logData logData = new LogData (línea); list.add (logData); } Lista de retorno; } catch (Exception e) {E.PrintStackTrace (); tirar E; } finalmente {if (br! = null) {br.close (); }}} / ** * Escriba el valor largo especificado en la primera línea del archivo dado como una cadena * @param l * @param * @throws excepción * / public static void savelong (long lon, archivo) lanza excepción {printwriter pw = null; intente {pw = new PrintWriter (archivo); pw.println (lon); } catch (Exception e) {E.PrintStackTrace (); tirar E; } finalmente {if (pw! = null) {pw.close (); }}}} /*** Escriba la cadena devuelta por el método ToString de cada elemento en la colección al archivo especificado en unidades de comportamiento. * @param c * @param archivo * @throws excepción */ public static void saveCollection (colección c, archivo de archivo) lanza la excepción {printWriter pw = null; intente {pw = new PrintWriter (archivo); for (objeto o: c) {pw.println (o); }} catch (Exception e) {E.PrintStackTrace (); tirar E; } finalmente {if (pw! = null) {pw.close (); }}} / ** * Comience continuo desde la posición actual de los bytes de longitud RandomAccessfile * de lectura dado y conviértelos en una cadena y return * @param raf * @param longitud * @return * @throws excepción * / public static string readString (randomAcessfile raf, int raf.read (datos); devolver nueva cadena (datos, "ISO8859-1"); } catch (Exception e) {E.PrintStackTrace (); tirar E; }} / ** * Lea la primera línea de cadena desde el archivo dado y luego * return * @param archivo * @return * @throws excepción * / public static long readlong (archivo archivo) lanza la excepción {bufferedreader br = null; intente {br = new BufferedReader (new InputStreamReader (new FileInputStream (File))); Línea de cadena = br.readline (); regresar long.parselong (línea); } catch (Exception e) {E.PrintStackTrace (); tirar E; } finalmente {if (br! = null) {br.close (); }}}}
4. Config.xml
<? xml versión = "1.0" encoding = "utf-8"?> <Eftact> <!-Nombre de archivo de registro del sistema Unix-> <logFile> wtmpx </logFile> <!-Guardar el nombre del archivo de registro resuelto-> <ExtLogFile> log.txt </textLogfile> <!-Nombre de archivo de marcador-> <LastPositionFile> Last PoseSion.txtxtxtxtx. of entries per parsed log--> <batch>10</batch> <!-- Paired log file name --> <logrecfile>logrec.txt</logrecfile> <!-- Unpaired log file name --> <loginlogfile>login.txt</loginlogfile> <!-- Unpaired log file name --> <loginlogfile>login.txt</loginlogfile> <!-dirección del servidor-> <vernerhost> localhost </vernerhost> <!-puerto del servidor-> <ververport> 8088 </ververport> </form>
5. Server-config.xml
<? xml versión = "1.0" encoding = "utf-8"?> <Ettor> <!-Nombre del archivo del servidor que guarda el archivo de registro emparejado-> <logrecfile> servidor-logs.txt </logrecfile> <!-Número de hilos de piscina de hilos-> <stifreSum> 30 </ifreSum> <!-Porter de servidor-<RENTERPORT-8088 </SERVER SERVERPORT
Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.