Descripción detallada del código de transmisión de archivos ftp utilizando el conjunto de herramientas Apache en Java

Este artículo introduce cómo usar el conjunto de herramientas Apache Commons-La herramienta ftp proporcionada por net realiza la subida y descarga de archivos al servidor ftp.

I. Preparación

Necesita referenciar commons-net-3.5.jar paquete.

Importar usando maven:

<dependency>
  <groupId>commons-net</groupId>
  <artifactId>commons-net</artifactId>
  <version>3.5</version>
</dependency>

Descarga manual:

https://es.oldtoolbag.com/softs/550085.html

II. Conectar al servidor FTP

/**
   * Conectar al servidor FTP
   * @throws IOException
   */
public static final String ANONYMOUS_USER="anonymous";
private FTPClient connect(){
	FTPClient client = new FTPClient();
	try{
		//Conectar al servidor FTP
		client.connect(this.host, this.port);
		//Inicio de sesión
		if(this.user==null||"".equals(this.user)){
			//Usar inicio de sesión anónimo
			client.login(ANONYMOUS_USER, ANONYMOUS_USER);
		} else{
			client.login(this.user, this.password);
		}
		//Establecer formato de archivo
		client.setFileType(FTPClient.BINARY_FILE_TYPE);
		//Obtener respuesta del servidor FTP
		int reply = client.getReplyCode();
		if(!FTPReply.isPositiveCompletion(reply)){
			client.disconnect();
			return null;
		}
		//Cambiar directorio de trabajo
		changeWorkingDirectory(client);
		System.out.println("===Conectado a FTP: ")+servidor+":"+port);
	}
	catch(IOException e){
		return null;
	}
	return client;
}
/**
   * Cambiar directorio de trabajo, crear directorio si el directorio remoto no existe
   * @param client
   * @throws IOException
   */
private void changeWorkingDirectory(FTPClient client) throws IOException{
	if(this.ftpPath!=null&&!"".equals(this.ftpPath)){
		Boolean ok = client.changeWorkingDirectory(this.ftpPath);
		if(!ok){
			//ftpPath no existe, crear directorio manualmente
			StringTokenizer token = new StringTokenizer(this.ftpPath,"\\",//");
			while(token.hasMoreTokens()){
				String path = token.nextToken();
				client.makeDirectory(path);
				client.changeWorkingDirectory(path);
			}
		}
	}
}
/**
   * Desconectar conexión FTP
   * @param ftpClient
   * @throws IOException
   */
public void close(FTPClient ftpClient) throws IOException{
	if(ftpClient!=null && ftpClient.isConnected()){
		ftpClient.logout();
		ftpClient.disconnect();
	}
	System.out.println("!!!Desconectar conexión FTP: ")+servidor+":"+port);
}

host: dirección IP del servidor ftp
port: puerto del servidor ftp
user: usuario de inicio de sesión
password: contraseña de inicio de sesión
Si el usuario de inicio de sesión está vacío, se utiliza el usuario anónimo para iniciar sesión.
ftpPath: ruta ftp, si la ruta ftp no existe, se crea automáticamente. Si es una estructura de directorios de múltiples niveles, se deben crear directorios iterativamente.

Tres, subir archivo

/**
   * Subir archivo
   * @param targetName Nombre del archivo subido a ftp
   * @param localFile Ruta del archivo local
   * @return
   */
public Boolean subir(String targetName,String localFile){
	//Conectar al servidor ftp
	FTPClient ftpClient = connect();
	if(ftpClient==null){
		System.out.println("Conectando al servidor FTP["+servidor+":"+puerto+"]¡Fallo!");
		return false;
	}
	File file = new File(localFile);
	//Establecer nombre de archivo después de la subida
	if(targetName==null||"".equals(targetName))
	      targetName = file.getName();
	FileInputStream fis = null;
	try{
		long now = System.currentTimeMillis();
		//Comenzando subida de archivo
		fis = new FileInputStream(file);
		System.out.println(">>>Comenzando subida de archivo："+);
		Boolean ok = ftpClient.storeFile(targetName, fis);
		if(ok){
			//Éxito de subida
			long times = System.currentTimeMillis(); - now;
			System.out.println(String.format(">>>Éxito de subida: tamaño：%s, tiempo de subida：%d segundos", formatSize(file.length()), times/1000));
		} else//Fallo de subida
		System.out.println(String.format(">>>Fallo de subida: tamaño：%s", formatSize(file.length())));
	}
	catch(IOException e){
		System.err.println(String.format(">>>Fallo de subida: tamaño：%s", formatSize(file.length())));
		e.printStackTrace();
		return false;
	}
	finally{
		try{
			if(fis!=null)
			          fis.close();
			close(ftpClient);
		}
		catch(Exception e){
		}
	}
	return true;
}

Cuatro, descargar archivo

/**
   * Descargar archivo
   * @param localPath Ruta de almacenamiento local
   * @return
   */
public int descargar(String localPath){
	// Conectar al servidor ftp
	FTPClient ftpClient = connect();
	if(ftpClient==null){
		System.out.println("Conectando al servidor FTP["+servidor+":"+puerto+"]¡Fallo!");
		return 0;
	}
	File dir = new File(localPath);
	if(!dir.exists())
	      dir.mkdirs();
	FTPFile[] ftpFiles = null;
	try{
		ftpFiles = ftpClient.listFiles();
		if(ftpFiles==null||ftpFiles.length==0)
		        return 0;
	}
	catch(IOException e){
		return 0;
	}
	int c = 0;
	for (int i=0;i<ftpFiles.length;i++{
		FileOutputStream fos = null;
		try{
			String name = ftpFiles[i].getName();
			fos = new FileOutputStream(new File(dir.getAbsolutePath()+File.separator+name));
			System.out.println("<<<Inicio de descarga de archivo:")+name);
			long now = System.currentTimeMillis();
			Boolean ok = ftpClient.retrieveFile(new String(name.getBytes("UTF-8"),"ISO-8859-1"), fos);
			if(ok){
				//Descarga exitosa
				long times = System.currentTimeMillis(); - now;
				System.out.println(String.format("<<<Descarga exitosa: tamaño：%s, tiempo de subida：%d segundos", formatSize(ftpFiles[i].getSize()), times/1000));
				c++;
			} else{
				System.out.println("<<<Descarga fallida");
			}
		}
		catch(IOException e){
			System.err.println("<<<Descarga fallida");
			e.printStackTrace();
		}
		finally{
			try{
				if(fos!=null)
				            fos.close();
				close(ftpClient);
			}
			catch(Exception e){
			}
		}
	}
	return c;
}

formatear el tamaño del archivo

private static final DecimalFormat DF = new DecimalFormat("#.##");
  /**
   * formatear el tamaño del archivo (B, KB, MB, GB)
   * @param size
   * @return
   */
  private String formatSize(long size){
    " B";1024{
      " KB"; + return size
    }1024*1024{
      " KB";/1024 + else if(size<
    }1024*1024*1024{
      return (size/(1024*1024)) + " MB";
    }else{
      double gb = size/(1024*1024*1024);
      return DF.format(gb)+" GB";
    }
  }

Cinco, prueba

public static void main(String args[]){
    FTPTest ftp = new FTPTest("192.168.1.10",21,null,null,"/temp/2016/12");
    ftp.upload("newFile.rar", "D:",/ftp/TeamViewerPortable.rar");
    System.out.println("");
    ftp.download("D:",/ftp/");
  }

Resultado

=== Conectar a FTP:192.168.1.10:21
>>> Comienza a subir el archivo: TeamViewerPortable.rar
>>> Subida exitosa: tamaño:5 MB, tiempo de subida:3segundo
!!! Desconectar la conexión FTP:192.168.1.10:21
=== Conectar a FTP:192.168.1.10:21
<<< Comienza a descargar el archivo: newFile.rar
<<< Descarga exitosa: tamaño:5 MB, tiempo de subida:4segundo
!!! Desconectar la conexión FTP:192.168.1.10:21

Resumen

Esto es todo el contenido detallado sobre la implementación de la transferencia de archivos FTP utilizando la herramienta Apache en Java que se menciona en este artículo. Espero que sea útil para todos. Los amigos interesados pueden continuar leyendo otros temas relacionados en este sitio. Si hay algo que no está bien, por favor déjenos un mensaje. Agradecemos el apoyo de los amigos a este sitio!

Declaración: El contenido de este artículo se ha obtenido de la red, es propiedad del autor original, el contenido se ha contribuido y subido por los usuarios de Internet de manera autónoma. Este sitio no posee los derechos de propiedad, no ha sido editado por humanos y no asume ninguna responsabilidad legal. Si encuentra contenido sospechoso de copyright, por favor envíe un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, reemplace # con @) para denunciar y proporcionar evidencia relevante. Una vez confirmado, este sitio eliminará inmediatamente el contenido sospechoso de infracción.