Este artículo ha compartido con usted dos formas de cargar y descargar archivos Java FTP para su referencia. El contenido específico es el siguiente
El primer método:
paquete com.cloudpower.util; import java.io.file; import java.io.fileInputStream; import java.io.fileOutputStream; import java.io.ioException; import sun.net.telnetinputputStream; import sun.net.telnetOutputStream; import sol.net.net.ftpclient;/*** java de java; @Title: ftp.java* @author: zhou lingbin*/public class ftp {/*** Nombre de archivo local*/String private LocalFileName; / *** Nombre de archivo remoto*/ String private RemoteFileName; / *** cliente ftp*/ privado ftpclient ftpclient; /***Conexión del servidor*@param ip servidor IP*@param puerto de servidor de puerto*@param nombre de usuario de usuario*@param contraseña contraseña*@param ruta del servidor ruta*@author zhou lingbin*@date 2012-7-11*/public void ConnectServerver (string ip, int port, string user, string contraseña, ruta de cadena) método // ftpClient = new ftpClient (); // ftpclient.openserver (ip, puerto); // El segundo método ftpClient = new ftpClient (ip); ftpclient.login (usuario, contraseña); // establecer en transmisión binaria ftpclient.binary (); System.out.println ("¡Iniciar sesión!"); if (path.length ()! = 0) {// Cambie el directorio en el sistema remoto al directorio especificado por la ruta del parámetro ftpclient.cd (ruta); } ftpClient.binary (); } Catch (ioException ex) {ex.printstacktrace (); tirar nueva runtimeException (ex); }} / *** Cierre la conexión* @author zhou lingbin* @date 2012-7-11* / public void CloseConnect () {try {ftpClient.closserver (); System.out.println ("Desconectar éxito"); } catch (ioException ex) {system.out.println ("no desconectar"); Ex.PrintStackTrace (); tirar nueva runtimeException (ex); }} / *** Cargar archivo* @param localfile archivo local* @param RemoteFile Archivo remoto* @author zhou lingbin* @date 2012-7-11* / public void upload (string localfile, string remotionFile) {this.localFileName = localfile; this.remoteFileName = RemoteFile; TelnetOutputStream OS = NULL; FileInputStream is = null; Pruebe {// Agregue el archivo remoto a la transmisión de salida OS = ftpclient.put (this.remoteFileName); // Obtener la transmisión de entrada del archivo local file_in = nuevo archivo (this.localFileName); IS = new FileInputStream (file_in); // crear un byte búfer [] bytes = nuevo byte [1024]; int c; while ((c = is.read (bytes))! = -1) {os.write (bytes, 0, c); } System.out.println ("Subir éxito"); } catch (ioException ex) {system.out.println ("no cargar"); Ex.PrintStackTrace (); tirar nueva runtimeException (ex); } finalmente {try {if (is! = null) {is.close (); }} catch (ioException e) {E.PrintStackTrace (); } Finalmente {try {if (os! = null) {os.close (); }} catch (ioException e) {E.PrintStackTrace (); }}}} / ** * Descargar archivo * @Param RemoteFile Remote File Path (Lado del servidor) * @param LocalFile Local File Path (Client) * @Author Zhou Lingbin * @Date 2012-7-11 * / public void descargar (cadena remota, cadena localfile) {telnetinputStream its = null; FileOutputStream OS = NULL; Pruebe {// Obtenga el nombre de archivo en la máquina remota y use TelnetInputStream para transferir el archivo al área local. is = ftpclient.get (remotsfile); Archivo file_in = nuevo archivo (localfile); OS = nuevo FileOutputStream (file_in); byte [] bytes = new Byte [1024]; int c; while ((c = is.read (bytes))! = -1) {os.write (bytes, 0, c); } System.out.println ("descargar éxito"); } catch (ioException ex) {system.out.println ("no descargar"); Ex.PrintStackTrace (); tirar nueva runtimeException (ex); } finalmente {try {if (is! = null) {is.close (); }} catch (ioException e) {E.PrintStackTrace (); } Finalmente {try {if (os! = null) {os.close (); }} catch (ioException e) {E.PrintStackTrace (); }}}} public static void main (string agrs []) {string filepath [] = {"/temp/aa.txt", "/temp/regist.log"}; String localFilePath [] = {"c: //tmp//1.txt", "c: //tmp//2.log"}; Ftp fu = new ftp (); /** Use el número de puerto predeterminado, el nombre de usuario, la contraseña y el directorio raíz para conectarse al servidor FTP*/fu.connectServer ("127.0.0.1", 22, "Anónimo", "ieuser@", "/temp"); // Descargar para (int i = 0; i <filepath.length; i ++) {fu.download (filepath [i], localFilePath [i]); } Cadena localFile = "e: //number.txt"; String RemoteFile = "/temp/haha.txt"; // cargar fu.upload (localfile, remotofile); fu.Closeconnect (); }}
No hay nada que decir sobre este método, es relativamente simple y no hay problema con el código confuso chino. Parece que hay una falla y no puede operar archivos grandes. Los amigos interesados pueden probarlo.
El segundo método:
clase pública ftpapche {private static ftpClient ftpClient = new ftpClient (); Cadena de cadena estática privada = System.getProperty ("File.Encoding"); /** * Descripción: cargar el archivo en el servidor FTP * * @versión1.0 * @param url * ftp servidor hostname * @param puerto * puerto del servidor FTP * @param username * ftp cuenta de inicio de sesión * @param contraseña * ftp contraseña de inicio de sesión * @param ruta * ftp servidor guarda el directorio, si es el director de root de la raíz, es "/" @param fileLead * nombre de archivo * nombre de archivo * nombre de archivo * FTP Server * @param Entrada * FUNCIÓN DE INPUTA DEL ARCHIVO LOCAL * @return return true con éxito, de lo contrario falso */ public static boolean uploadFile (string url, int port, string username, string contraseña, ruta de cadena, nombre de archivo, nombre de entrada, entrada input) {resultado boolean = false; intente {int respuesta; // Si se usa el puerto predeterminado, puede conectarse directamente al servidor FTP ftpclient.connect (url); // ftp.connect (url, puerto); // conectarse al servidor FTP // Inicie sesión en ftpclient.login (nombre de usuario, contraseña); ftpClient.setControlEncoding (codificación); // Verifique que la conexión sea una respuesta exitosa = ftpClient.getReplyCode (); if (! ftPreply.IspositiveCompletion (respuesta)) {System.out.println ("Conexión fallida"); ftpclient.disconnect (); resultado de retorno; } // Transferir el directorio de trabajo al directorio especificado Boolean Change = ftpClient.ChangeWorkingDirectory (ruta); ftpclient.setFileType (ftp.binary_file_type); if (cambio) {resultado = ftpclient.storeFile (new String (FileName.getBytes (codificación), "ISO-8859-1"), entrada); if (resultado) {System.out.println ("¡cargado con éxito!"); }} input.close (); ftpClient.logout (); } catch (ioException e) {E.PrintStackTrace (); } Finalmente {if (ftpClient.isConnected ()) {try {ftpClient.disconnect (); } catch (ioException IOE) {}}} Resultado de retorno; }/*** cargue archivos locales en el servidor FTP**/public void testuploadFromDisk () {try {FileInputStream in = new FileInputStream (nuevo archivo ("e: /Number.txt")); Boolean Flag = uploadFile ("127.0.0.1", 21, "Zlb", "123", "/", "jaja.txt", in); System.out.println (bandera); } catch (FileNotFoundException e) {E.PrintStackTrace (); }} /** * Descripción: Descargue el archivo desde el servidor FTP * * @versión1.0 * @param url * ftp servidor hostname * @param puerto * puerto de servidor ftp * @param username * ftp cuenta de inicio de sesión * @param contraseña * ftp inicio de sesión * @param remotepath * ruta relativa en el servidor ftp * @param filename * nombre de archivo a ser una contraseña de inicio de sesión * ftp * Guardar en local después de descargar * @return */ public static boolean Downfile (String url, int puerto, nombre de usuario de cadena, contraseña de cadena, cadena remotaPath, string filename, string localpath) {boolean resultado = false; intente {int respuesta; ftpClient.setControlEncoding (codificación); / * * Para cargar y descargar archivos chinos, algunos lugares recomiendan usar las siguientes dos oraciones en lugar de * nueva cadena (remotePath.getBytes (codificación), "ISO-8859-1") transcoding. * Después de la prueba, no se puede pasar. */// ftpClientConfig conf = new ftpClientConfig (ftpClientConfig.syst_nt); // conf.setserverLanguageCode ("zh"); ftpclient.connect (url, puerto); // Si se usa el puerto predeterminado, puede conectarse directamente al servidor FTP por ftpclient.login (nombre de usuario, contraseña); // Iniciar sesión // Establecer el tipo de transferencia de archivo en ftpclient.setfiletype (ftpclient.binary_file_type); // Obtenga el código de respuesta de inicio de sesión FTP Responder = ftpclient.getReplyCode (); // Verifique que el inicio de sesión sea exitoso if (! Ftpreprely.ispositiveCompletion (respuesta)) {ftpclient.disconnect (); System.err.println ("Conexión rechazada del servidor FTP"); resultado de retorno; } // transferir al directorio del servidor FTP al directorio especificado ftpclient.changeWorkingDirectory (new String (remotePath.getBytes (codificación), "ISO-8859-1")); // Obtenga la lista de archivos ftpfile [] fs = ftpclient.listfiles (); for (ftpfile ff: fs) {if (ff.getName (). Equals (FileName)) {file localFile = new File (localpath + "/" + ff.getName ()); OutputStream es = nuevo FileOutputStream (LocalFile); ftpClient.rcrieveFile (ff.getName (), is); is.close (); }} ftpClient.logout (); resultado = verdadero; } catch (ioException e) {E.PrintStackTrace (); } Finalmente {if (ftpClient.isConnected ()) {try {ftpClient.disconnect (); } catch (ioException IOE) {}}} Resultado de retorno; }/** * Descargue el archivo en el servidor FTP al local * */public void testdownfile () {try {boolean flag = downfile ("127.0.1", 21, "zlb", "123", "/", "jAHA.txt", "d:/"); System.out.println (bandera); } catch (Exception e) {E.PrintStackTrace (); }} public static void main (string [] args) {ftpapche fa = new ftpapche (); fa.testdownfile (); }}
De esta manera, debe prestar atención al problema del código confuso chino. Si lo configura incorrectamente, el nombre de archivo cargado puede ser un código confuso. A veces no se puede subir en absoluto. Por supuesto, no lo solicitará porque no hay excepción. He encontrado muchas soluciones en línea, y hay muchas opiniones diferentes. Casi todos fueron copiados de una versión, y no he sido probado por mí mismo. He sufrido mucho por esto. Se divide aproximadamente en las siguientes dos soluciones:
1. Agregue las siguientes tres oraciones para resolverlo
ftpClient.setControlEncoding ("GBK");
FtpClientConfig conf = new ftpClientConfig (ftpClientConfig.syst_nt);
conf.SetServerLanguageCode ("Zh");
Respuesta: Después de la prueba, simplemente no funciona, el problema anterior todavía existe
2. Es similar al método anterior, pero creo que este método es más confiable
Primero, agregue la oración ftpClient.setControlEncoding ("GBK"); Y luego, transcode a todos los chinos al formato "ISO-8859-1", como sigue:
ftpClient.ChangeWorkingDirectory (new String (remotePath.getBytes ("GBK"), "ISO-8859-1"));
Respuesta: Después de la prueba, todavía no funciona. La razón por la que dije que este método es más confiable. Por favor continúe leyendo.
Primero, hablemos de por qué necesitamos transcodificar:
Debido a que en el protocolo FTP, se especifica que el nombre del archivo se codifica como ISO-8859-1, el nombre del directorio o el nombre del archivo deben ser transcodificados.
La siguiente pregunta es, qué codificación debemos convertir a este formato. Por lo tanto, hay una segunda solución: convertir el formato GBK en formato ISO-8859-1. Además, algunas personas también dicen que esto debe hacerse. De hecho, creo que la razón por la que pueden decir que esto es una completa coincidencia. Su verdadero principio es que, dado que el formato de codificación especificado por el protocolo FTP es "ISO-8859-1", realmente tenemos que convertir el formato y luego convertirlo automáticamente en el formato de codificación del sistema cuando el servidor recibe el archivo. Por lo tanto, la clave no es especificar el formato, sino depender del formato de codificación del servidor FTP. Por lo tanto, si el formato de codificación del sistema FTP es "GBK", el segundo método definitivamente tendrá éxito; Sin embargo, si el formato de codificación del sistema es "UTF-8", todavía habrá código confuso. Por lo tanto, solo podemos obtener el formato de codificación del sistema a través del código, y luego convertirlo en el formato de codificación de ISO-8859-1 a través de este formato de codificación. El método de adquisición es el siguiente:
Cadena de cadena estática privada = System.getProperty ("File.Encoding");
Todos los códigos anteriores han sido probados por usted mismo, ¡espero que puedan resolver el problema para todos!