Necesito usar Java para escribir una herramienta FTP, porque solo hay un poco de conceptos básicos de Java, pero como no la he usado durante varios años, casi no puedo hacerlo, así que tengo que hacerlo un poco Bit, pero afortunadamente puedo recogerlo.
Sin embargo, debido a que uso Javac para compilar bajo Linux, no usar IDE para hacer estas cosas en Win, me tomé un tiempo para ejecutar y compilar. Alguno.
Para la herramienta de descarga FTP, el código es el siguiente:
La copia del código es la siguiente:
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.outputstream;
import java.net.socketException;
importar org.apache.commons.net.ftp.ftpclient;
importar org.apache.commons.net.ftp.ftpreply;
clase pública ftpclient {
host de cadena privada;
Puerto privado int;
nombre de usuario de cadena privada;
contraseña de cadena privada;
binario booleano privado = true;
Passivemode privado booleano = true;
Encoding de cadena privada = "UTF-8";
Private int Clienttimeout = 3000;
bandera booleana privada = verdadero;
privado ftpClient ftpClient = null;
public String gethost () {
Host de regreso;
}
public void sethost (host de cadena) {
this.host = host;
}
public int getPort () {
puerto de retorno;
}
public void setport (int puerto) {
this.port = puerto;
}
public String getUsername () {
devolver el nombre de usuario;
}
public void setUsername (String UserName) {
this.Username = UserName;
}
public String getPassword () {
devolver contraseña;
}
public void setPassword (String Password) {
this.password = contraseña;
}
Public boolean isbinaryTransfer () {
devolver binarytransfer;
}
public void setBinaryTransfer (binaro binarytransfer) {
this.binaryTransfer = binaryTransfer;
}
Public boolean ispassivemode () {
return Passivemode;
}
public void setPassivemode (boolean passivemode) {
this.passivemode = passiveMode;
}
public String getencoding () {
codificación de retorno;
}
public void setEncoding (codificación de cadenas) {
this.Encoding = Encoding;
}
public int getClientTimeOut () {
devolver ClientTimeout;
}
public void setClientTimeOut (int clientTimeout) {
this.clienttimeout = clientTimeout;
}
public ftpClient (host de cadena) {
this.username = "Anónimo";
this.encoding = "UTF-8";
this.binaryTransfer = true;
this.binaryTransfer = true;
this.port = 21;
this.host = host;
intentar {
this.ftpClient = getftpClient ();
} Catch (Exception e) {
System.out.println ("Crear error ftpClient!");
}
}
privado ftpclient getftpClient () lanza ioexception {
FtpClient ftpClient = new ftpClient ();
ftpClient.setControlEncoding (codificación);
conectar (ftpClient);
if (passiveMode) {
ftpClient.EnterLocalPassivEmode ();
}
setFileType (ftpClient);
intentar {
ftpClient.SetSoTimeOut (ClientTimeout);
} Catch (SocketException e) {
tirar nueva IOException ("Establezca el error de tiempo de espera", e);
}
devolver ftpClient;
}
Private void setFileType (ftpClient ftpClient) lanza ioexception {
intentar {
if (binarytransfer) {
ftpClient.setFileType (ftpclient.binary_file_type);
} demás {
ftpClient.setFileType (ftpclient.ascii_file_type);
}
} Catch (ioException e) {
tirar nueva IOException ("no podría establecer el tipo de archivo", e);
}
}
Public Boolean Connect (ftpClient ftpClient) lanza ioexception {
intentar {
ftpclient.connect (host, puerto);
int respuesta = ftpclient.getReplyCode ();
if (ftpreply.ispositiveCompletion (respuesta)) {
if (ftpclient.login (nombre de usuario, contraseña)) {
setFileType (ftpClient);
devolver verdadero;
}
} demás {
this.ftpclient.disconnect ();
tirar nueva IOException ("El servidor FTP rechazó la conexión");
}
} Catch (ioException e) {
if (this.ftpclient.isconnected ()) {
intentar {
this.ftpclient.disconnect ();
} catch (ioException e1) {
tirar nueva IOException ("no se pudo desconectar del servidor", e);
}
}
tirar nueva IOException ("No se pudo conectar al servidor", e);
}
devolver falso;
}
privado vacío desconectado () lanza ioexception {
intentar {
this.ftpclient.logout ();
} Catch (ioException e) {
System.out.println ("¡El tiempo de espera de sesión de cierre de sesión!");
} finalmente {
if (this.ftpclient.isconnected ()) {
this.ftpclient.disconnect ();
}
}
}
Public InputStream GetStream (String ServerFile) lanza IOException {
InputStream Insteam = NULL;
intentar {
Instail = this.ftpClient.retrieveFilEstream (ServerFile);
System.out.println ("¡Instream, supere!");
Instalar de regreso;
} Catch (ioException e) {
System.out.println ("Get Stream Exception");
regresar nulo;
}
}
public boolean WriteStream (Entrada InputStream, String Localfile) lanza IoException {
FileOutputStream fout = new FileOutputStream (LocalFile);
int ch = 0;
if (input == null) {
System.out.println ("La entrada es nula");
devolver falso;
}
intentar {
ch = input.read ();
while (ch! = -1) {
fout.write (CH);
ch = input.read ();
}
System.out.println ("¡Escribe sobre!");
Bandera de regreso;
} Catch (ioException e) {
tirar nueva IOException ("No se pudo obtener el archivo del servidor", e);
}
}
Public boolean isExist (String RemoteFilepath) lanza ioexception {
intentar{
Archivo archivo = nuevo archivo (remotaFilePath);
String remotePath = remoteFilePath.substring (0, (remotaFilePath.IndexOf (file.getName ())-1));
Cadena [] listNames = this.ftpclient.listNames (remotePath);
System.out.println (remotafilepath);
para (int i = 0; i <listNames.length; i ++) {
System.out.println (listNames [i]);
if (remotaFilePath.equals (listNames [i])) {
bandera = verdadero;
System.out.println ("archivo:"+file.getName ()+"existió");
romper;
}demás {
bandera = falso;
}
}
} Catch (ioException e) {
tirar nueva IOException ("Excepción de archivo", e);
}
Bandera de regreso;
}
// Principal para pruebas
public static void main (string [] args) lanza ioexception {
String hostName = "CP01-Testing-PS7130.CP01.Baidu.com";
String serverFile = "/home/work/check_disk.sh";
String localFile = "/home/work/workspace/proyecto/dhc2-0/dhc/base/ftp/task_get";
FtpClient ftp = new ftpClient (hostname);
System.out.println (ftp.isexist (serverfile));
ftp.WriteStream (ftp.getstream (serverfile), localfile);
ftp.disconnect ();
}
}
Esta herramienta se utiliza para la carga de clúster con otra herramienta Hadoop, por lo que las secuencias de entrada y salida están separadas, lo que también es para facilitar el uso de otra herramienta.
Para agregar una cosa, cómo ejecutarse en la configuración de Linux:
Si dicho código debe ejecutarse en Linux, en primer lugar, debe configurar el paquete receptivo, por ejemplo
La copia del código es la siguiente:
importar org.apache.commons.net.ftp.ftpclient;
Este paquete se acaba de descargar directamente en el sitio web de Apache.
La copia del código es la siguiente:
exportar ftppath = "$ {ruta} /xxx.jar"
javac -classpath $ classpath: $ ftppath ftpclient.java
Del mismo modo, ClassPath debe especificarse cuando se ejecute:
La copia del código es la siguiente:
java -classpath $ classpath: $ ftppath ftpclient
Se recomienda no incluir $ ftppath en classpath, solo consulte las variables de entorno si lo usa.
Lo anterior se trata de este artículo.
Tómese un tiempo para compartir el artículo con sus amigos o deje un comentario. ¡Te agradeceremos sinceramente por tu apoyo!