El ejemplo de este artículo describe el método de copiar archivos entre dos servidores en Java. Compártelo con todos para tu referencia. El análisis específico es el siguiente:
Por lo general, la función de copia de archivos que utilizamos con más frecuencia es la función de copia de archivos entre los mismos servidores. Lo que se presenta aquí es la actualización funcional de la copia de archivos normal, que puede realizar la copia de archivos entre dos servidores.
1. Lado del servidor
Copie el código de la siguiente manera: paquete sterning;
importar java.io.BufferedInputStream;
importar java.io.DataInputStream;
importar java.io.DataOutputStream;
importar java.io.File;
importar java.io.FileInputStream;
importar java.net.ServerSocket;
importar java.net.Socket;
prueba de servidor de clase pública {
puerto int = 8821;
inicio vacío() {
Enchufe s = nulo;
intentar {
ServerSocket ss = nuevo ServerSocket(puerto);
mientras (verdadero) {
//Selecciona archivos para transferir
Cadena filePath = "D://lib.rar";
Archivo fi = nuevo archivo (filePath);
System.out.println("Longitud del archivo:" + (int) fi.length());
// lanzamientos de socket público aceptar()
// IOException escucha y acepta conexiones a este socket. Este método se bloquea hasta que se establece una conexión.
s = ss.accept();
System.out.println("Establecer conexión de socket");
DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream()));
dis.readByte();
DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
DataOutputStream ps = nuevo DataOutputStream(s.getOutputStream());
//Transmite el nombre y la longitud del archivo al cliente. Para que sea realmente aplicable a todas las plataformas, el procesamiento de nombres chinos, por ejemplo, aún requiere procesamiento. Para obtener más información, consulte el código preparado en Think In Java 4th.
ps.writeUTF(fi.getName());
ps.flush();
ps.writeLong((long) fi.length());
ps.flush();
int tamaño del búfer = 8192;
byte[] buf = nuevo byte[bufferSize];
mientras (verdadero) {
int lectura = 0;
si (fis! = nulo) {
leer = fis.read(buf);
}
si (leer == -1) {
romper;
}
ps.write(buf, 0, leer);
}
ps.flush();
// Tenga cuidado al cerrar el enlace del socket; de lo contrario, el cliente esperará datos del servidor.
// Hasta que se agote el tiempo de espera del socket, lo que da como resultado datos incompletos.
fis.cerrar();
s.cerrar();
System.out.println("Transferencia de archivo completada");
}
} captura (Excepción e) {
e.printStackTrace();
}
}
público estático vacío principal (String arg []) {
nuevo ServerTest().start();
}
}
2. Clase auxiliar útil de enchufe.
Copie el código de la siguiente manera: paquete de popa;
importar java.net.*;
importar java.io.*;
clase pública ClientSocket {
IP de cadena privada;
puerto internacional privado;
socket privado socket = nulo;
DataOutputStream fuera = nulo;
DataInputStream getMessageStream = nulo;
ClientSocket público (IP de cadena, puerto int) {
this.ip = ip;
this.port = puerto;
}
/** *//**
* Crear conexión de socket
*
* @throwsException
* excepción
*/
public void CreateConnection() lanza una excepción {
intentar {
socket = nuevo Socket(ip, puerto);
} captura (Excepción e) {
e.printStackTrace();
si (zócalo! = nulo)
socket.cerrar();
tirar e;
} finalmente {
}
}
public void sendMessage (String sendMessage) lanza una excepción {
intentar {
salida = nuevo DataOutputStream(socket.getOutputStream());
si (enviarMessage.equals("Windows")) {
out.writeByte(0x1);
salida.flush();
devolver;
}
si (enviarMensaje.equals("Unix")) {
out.writeByte(0x2);
salida.flush();
devolver;
}
si (enviarMensaje.equals("Linux")) {
out.writeByte(0x3);
salida.flush();
} demás {
out.writeUTF(enviarMensaje);
salida.flush();
}
} captura (Excepción e) {
e.printStackTrace();
si (¡fuera! = nulo)
fuera.cerrar();
tirar e;
} finalmente {
}
}
public DataInputStream getMessageStream() lanza una excepción {
intentar {
getMessageStream = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
devolver getMessageStream;
} captura (Excepción e) {
e.printStackTrace();
si (getMessageStream! = nulo)
getMessageStream.close();
tirar e;
} finalmente {
}
}
conexión pública vacía (shutDownConnection) {
intentar {
si (¡fuera! = nulo)
fuera.cerrar();
si (getMessageStream! = nulo)
getMessageStream.close();
si (zócalo! = nulo)
socket.cerrar();
} captura (Excepción e) {
}
}
}
3.Cliente
Copie el código de la siguiente manera: paquete de popa;
importar java.io.BufferedOutputStream;
importar java.io.DataInputStream;
importar java.io.DataOutputStream;
importar java.io.FileOutputStream;
prueba de cliente de clase pública {
ClientSocket privado cs = nulo;
private String ip = "localhost";//Establecer en la IP del servidor private int port = 8821;
cadena privada sendMessage = "Windwos";
prueba de cliente pública() {
intentar {
si (crearConexión()) {
enviarMensaje();
getMensaje();
}
} captura (Excepción ex) {
ex.printStackTrace();
}
}
crearConexión booleana privada() {
cs = nuevo ClientSocket(ip, puerto);
intentar {
cs.CreateConnection();
System.out.print("¡Conexión exitosa al servidor!" + "/n");
devolver verdadero;
} captura (Excepción e) {
System.out.print("¡Error al conectarse al servidor!" + "/n");
devolver falso;
}
}
enviar mensaje vacío privado () {
si (cs == nulo)
devolver;
intentar {
cs.sendMessage(enviarMensaje);
} captura (Excepción e) {
System.out.print("¡Error al enviar el mensaje!" + "/n");
}
}
getMessage vacío privado() {
si (cs == nulo)
devolver;
DataInputStream inputStream = nulo;
intentar {
flujo de entrada = cs.getMessageStream();
} captura (Excepción e) {
System.out.print("error de caché al recibir mensajes/n");
devolver;
}
intentar {
// Ruta de guardado local, el nombre del archivo se heredará automáticamente del servidor.
Cadena savePath = "E://";
int tamaño del búfer = 8192;
byte[] buf = nuevo byte[bufferSize];
int pasadolen = 0;
largo = 0;
savePath += inputStream.readUTF();
DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(savePath))));
len = inputStream.readLong();
System.out.println("La longitud del archivo es:" + len + "/n");
System.out.println("¡Comience a recibir archivos!" + "/n");
mientras (verdadero) {
int lectura = 0;
si (inputStream! = nulo) {
leer = inputStream.read(buf);
}
pasadolen += leer;
si (leer == -1) {
romper;
}
//La barra de progreso a continuación se creó originalmente para la barra de progreso de la interfaz gráfica. Si está imprimiendo un archivo aquí, es posible que algunos de los mismos porcentajes se impriman repetidamente.
System.out.println("Archivo recibido" + (pasadolen * 100/len) + "%/n");
fileOut.write(buf, 0, leer);
}
System.out.println("Recepción completada, archivo guardado como" + savePath + "/n");
archivoOut.close();
} captura (Excepción e) {
System.out.println("Error al recibir el mensaje" + "/n");
devolver;
}
}
público estático vacío principal (String arg []) {
nueva Prueba de Cliente();
}
}
Espero que este artículo sea útil para la programación Java de todos.