FTP es la abreviatura inglesa del protocolo de transferencia de archivos (protocolo de transferencia de archivos), y la abreviatura china se llama "Protocolo de transferencia escrita". Se utiliza para la transferencia bidireccional de archivos de control en Internet. Al mismo tiempo, también es una aplicación. Existen diferentes aplicaciones FTP basadas en diferentes sistemas operativos, y todas estas aplicaciones se adhieren al mismo protocolo para transferir archivos. En el uso de FTP, los usuarios a menudo encuentran dos conceptos: "Descargar" y "Cargar". Archivos "Descargar" significa copiar archivos del host remoto a su propia computadora; Los archivos "cargar" significa copiar archivos de su propia computadora al host remoto. En el idioma de Internet, los usuarios pueden cargar archivos (descargar) a (desde) hosts remotos a través de programas de clientes.
Primero, Serv-U se descargó para configurar su computadora como un servidor de archivos FTP para un funcionamiento fácil. El siguiente código se usa en el servidor FTP y los datos relevantes de la conexión FTP deben escribirse en el código para completarlo.
1. Carga y descarga de archivos FTP (tenga en cuenta que está cargando y descarga de archivos individuales)
import java.io.file; import java.io.fileInputStream; import java.io.filenotfoundexception; import java.io.fileOutputStream; import java.io.ioException; import java.io.inputstream; import java.io.outStream; import Org.apache.commons.net. org.apache.commons.net.ftp.ftpclient; importar org.apache.commons.net.ftp.ftpfile; importar org.apache.commons.net.ftp.ftpreply;/*** Implementar la carga de archivos ftp y descarga de archivos*/clase pública ftpapche {ftpClient estaticar privado ftpClient = new ftpClient (); Cadena de cadena estática privada = System.getProperty ("File.Encoding"); /** * Descripción: cargar archivos 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 directorio, si es el directorio root de filene de filene. FTP Server * @param Entrada * FUNCIÓN DE INPUTA DEL ARCHIVO LOCAL * @return return True con éxito, de lo contrario, devolverá falso */ public static boolean uploadFile (string url, int port, string username, string contraseña, ruta de cadena, nombre de archivo, inputstream input) {resultado boolean = false; intente {int respuesta; // Si usa el puerto predeterminado, puede conectarse directamente al servidor FTP ftpclient.connect (url); // ftp.connect (url, puerto); // Conecte el 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 ("d: /test02/list.txt")); Boolean Flag = uploadFile ("10.0.0.102", 21, "admin", "123456", "/", "lis.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 del servidor ftp * @param username * ftp cuenta de inicio de sesión * @param contraseña * ftp contraseña * ftp * @param ruta remotepath * ruta relativa en el ftp * @param filename * nombre de archivo a la contraseña de inicio de sesión * ftp * al local después de descargar * @return */ public static static boolean downfile (url de cadena, int puerto, nombre de usuario de cadena, contraseña de cadena, string remotePath, 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 ("10.0.0.102", 21, "admin", "123456", "/", "ip.txt", "e:/"); System.out.println (bandera); } catch (Exception e) {E.PrintStackTrace (); }} public static void main (string [] args) {ftpapche fa = new ftpapche (); fa.testdownfile (); fa.testuploadFromDisk (); }}2. Carga y descarga de carpetas FTP (tenga en cuenta que toda la carpeta es la carpeta completa)
paquete ftp; import java.io.bufferedInputStream; import java.io.bufferedOutputStream; import java.io.file; import java.io.fileInputStream; import java.io.filenotfoundException; import java.io.fileOutStream; import java.io.io.io.ioexception; importar.utile.utile.utilon; org.apache.commons.net.ftp.ftpclient; importar org.apache.commons.net.ftp.ftpclientconfig; importar org.apache.commons.net.ftp.ftpfile; importar org.apache.commons.net.ftp.ftpreply; importar org.apache.log4j.logger; clase pública FtpClient ftpClient; tira de cuerda privada; private intport; usuario de cadena privada; contraseña de cadena privada; Private static logger logger = logger.getLogger (ftptest_04.class.getName ()); / * * * * Ftp constructor */ public ftptest_04 (string strip, int intport, string user, string contraseña) {this.strip = strip; this.intport = intport; this.user = usuario; this.password = contraseña; this.ftpClient = new ftpClient (); } / *** @return Determine si el inicio de sesión es exitoso** / public boolean ftplogin () {boolean islogin = false; FtpClientConfig ftpClientConfig = new ftpClientConfig (); ftpClientConfig.setserververezoneId (TimeZone.getDefault (). getId ()); this.ftpclient.setControlEncoding ("gbk"); this.ftpclient.configure (ftpClientConfig); Pruebe {if (this.intport> 0) {this.ftpclient.connect (this.strip, this.intport); } else {this.ftpclient.connect (this.strip); } // FTP Server Connection Respuesta int respuesta = this.ftpclient.getReplyCode (); if (! ftPreply.IspositiveCompletion (respuesta)) {this.ftpclient.disconnect (); logger.error ("Inicie sesión en el servicio FTP fallido!"); devolver islogin; } this.ftpclient.login (this.user, this.password); // Establezca el protocolo de transmisión this.ftpclient.enterLocalPassivEmode (); this.ftpClient.SetFileType (ftpclient.binary_file_type); logger.info ("Felicitaciones" + this.user + "registrado con éxito en el servidor FTP"); islogin = true; } catch (Exception e) {E.PrintStackTrace (); logger.error (this.user + "Iniciar sesión en el servicio FTP fallado!" + E.getMessage ()); } this.ftpClient.SetBufferSize (1024 * 2); this.ftpClient.SetDatateTimeOut (30 * 1000); devolver islogin; }/ *** @Exit Close Server Link**/ public void ftPlogout () {if (null! = This.ftpclient && this.ftpclient.isconnected ()) {try {boolean reuslt = this.ftpClient.logout (); // exit ftp servidor if (reuslt) {logger.info ("" Servidor "); }} catch (ioException e) {E.PrintStackTrace (); logger.warn ("Excepción de salir del servidor FTP!" + E.getMessage ()); } Finalmente {try {this.ftpclient.disconnect (); // cierre la conexión al servidor FTP} Catch (ioException e) {E.PrintStackTrace (); logger.warn ("Excepción de cerrar la conexión del servidor FTP!"); }}}}}/**** Sube el archivo ftp* @param localfile local archivo local* @param romotuploadepath de carga del servidor: debería terminar con/*** public boolean uploadfile (archivo localfile, string romotuploadepath) {bufferedRstream instrame = null; éxito booleano = falso; Pruebe {this.ftpclient.changeWorkingDirectory (RomotuploadePath); // Cambie la ruta de trabajo InSteam = new BufferedInputStream (nueva FileInputStream (LocalFile)); logger.info (localFile.getName () + "Start upload ..."); éxito = this.ftpClient.storeFile (localFile.getName (), InSteam); if (éxito == true) {logger.info (localfile.getName () + "cargado con éxito"); devolver el éxito; }} Catch (FileNotFoundException e) {E.PrintStackTrace (); logger.error (localfile + "no encontrado"); } catch (ioException e) {E.PrintStackTrace (); } Finalmente {if (Instail! = Null) {try {Insteam.Close (); } catch (ioException e) {E.PrintStackTrace (); }}} return éxito; } / **** Descargar archivo* @param El nombre del archivo RemoteFileName se descargará* @param LocalDires Descargar en la ruta local* @param remoteDownloadPath La ruta donde se encuentra remotoFileName se encuentra** / public boolean descargarfile (string remotionFileName, string localDires, string remoteDownownloadpath) {string string strfileNdires + remotionFileName; BufferedOutputStream Outstream = null; éxito booleano = falso; intente {this.ftpclient.changeworkingDirectory (remoTeDeDownloadPath); OutStream = new BufferedOutputStream (nuevo FileOutputStream (strFilePath)); logger.info (remotoFileName + "Iniciar descarga ..."); éxito = this.ftpClient.retrieveFile (remotaFileName, Outstream); if (éxito == true) {logger.info (remotoFileName + "descargado con éxito a" + strfilePath); devolver el éxito; }} catch (Exception e) {E.PrintStackTrace (); logger.error (remotofileName + "descargar fallido"); } finalmente {if (null! = outstream) {try {outstream.flush (); Outstream.close (); } catch (ioException e) {E.PrintStackTrace (); }}} if (éxito == falso) {logger.error (remotaFileName + "Descargar fallido !!!"); } return éxito; }/**** @upload carpeta* @param localDirectory* carpeta local* @param remotedirectoryPath* Ftp Server ruta termina con el directorio "/"**/public boolean uploadDirectory (String localDirectory, StrotedirectoryPath) {Archivo SRC = nuevo archivo (localDirectory); Pruebe {remotedirectoryPath = remotedirectoryPath + src.getName () + "/"; boolean makindirflag = this.ftpclient.makedirectory (remotedirectorypath); System.out.println ("localDirectory:" + localDirectory); System.out.println ("RemotedirectoryPath:" + RemotedirectoryPath); System.out.println ("src.getName ():" + src.getName ()); System.out.println ("RemotedirectoryPath:" + RemotedirectoryPath); System.out.println ("Makedirflag:" + Makedirflag); // ftpclient.listDirectorories (); } catch (ioException e) {E.PrintStackTrace (); logger.info (remotedirectorypath + "creación de directorio fallida"); } Archivo [] allFile = src.ListFiles (); for (int currentFile = 0; currentFile <allFile.length; currentFile ++) {if (! AllFile [currentFile] .IsDirectory ()) {String srcName = allFile [currentFile] .getPath (). ToString (); uploadfile (nuevo archivo (srcName), remotedirectorypath); }} for (int currentFile = 0; currentFile <allFile.length; currentFile ++) {if (allFile [currentFile] .IsDirectory ()) {// recursivo uploadDirectory (allFile [currentFile] .getPath (). toString (), remotedirectorypath); }} return verdadero; } / **** @download de la carpeta* @param localDirectoryPath Dirección local* @param Remotedirectory Remote Carper** / public boolean downloadDirectory (String localDirectoryPath, string remotedirectory) {try {string filename = new File (remotedirectory) .getName (); localDirectoryPath = localDirectoryPath + nombre de archivo + "//"; nuevo archivo (localDirectoryPath) .mkdirs (); Ftpfile [] allfile = this.ftpclient.listfiles (remotedirectory); for (int currentFile = 0; currentFile <allFile.length; currentFile ++) {if (! AllFile [currentFile] .IsDirectory ()) {downloadFile (allFile [currentFile] .getName (), localDirectoryPath, remotedirectory); }} for (int currentFile = 0; currentFile <allFile.Length; currentFile ++) {if (allFile [currentFile] .IsDirectory ()) {String strRemotedirectoryPath = remotedirectory+ "/"+ allFile [currentFile] .getName (); downloadDirectory (localDirectoryPath, strremotedirectorypath); }}} Catch (ioException e) {E.PrintStackTrace (); logger.info ("Descargar carpeta fallida"); devolver falso; } return verdadero; } // ftpClient set y obtienen funciones públicos ftpClient getftpClient () {return ftpClient; } public void setftpClient (ftpClient ftpClient) {this.ftpClient = ftpClient; } public static void main (string [] args) lanza ioexception {ftptest_04 ftp = new ftptest_04 ("10.0.0.102", 21, "admin", "123456"); ftp.ftPlogin (); System.out.println ("1"); // Carpeta de carga boolean uploadflag = ftp.uploaddirectory ("d: // test02", "/"); // Si es administrador/, entonces se pasan todos los archivos. Si es justo/, se pasa en la carpeta System.out.println ("Supeadflag:" + uploadflag); // Descargar carpeta ftp.downloadDirectory ("d: // tm", "/"); ftp.ftplogout (); }}Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo sea de ayuda para el estudio o el trabajo de todos. ¡También espero apoyar a Wulin.com más!