J'ai besoin d'utiliser Java pour écrire un outil FTP, car il n'y a qu'un peu de bases Java, mais comme je ne l'ai pas utilisé depuis plusieurs années, je ne peux presque pas le faire, donc je dois le faire un peu Un peu, mais heureusement, je peux le ramasser.
Cependant, parce que j'utilise Javac pour compiler sous Linux, sans utiliser IDE pour faire ces choses sous Win, j'ai pris un peu de temps à exécuter et à compiler. Quelques.
Pour l'outil de téléchargement FTP, le code est le suivant:
La copie de code est la suivante:
Importer java.io.file;
import java.io.fileInputStream;
import java.io.filenotfoundException;
Importer java.io.fileOutputStream;
Importer java.io.ioException;
import java.io.inputStream;
import java.io.outputStream;
import java.net.socketException;
import org.apache.commons.net.ftp.ftpclient;
import org.apache.commons.net.ftp.ftpreply;
classe publique ftpclient {
hôte de chaîne privée;
port int privé;
Nom d'utilisateur de chaîne privée;
mot de passe de chaîne privé;
BinaryTransfer binaire privé = true;
Boolean privé passiveMode = true;
Encoding de chaînes privées = "UTF-8";
private int clienttimeout = 3000;
Flag booléen privé = true;
privé ftpClient ftpClient = null;
public String gethost () {
retour hôte;
}
public void sethost (string host) {
this.host = host;
}
public int getport () {
port de retour;
}
public void setport (int port) {
this.port = port;
}
public String getUserName () {
Retour Nom d'utilisateur;
}
public void setUsername (String username) {
this.userName = nom d'utilisateur;
}
public String getPassword () {
retour de mot de passe;
}
public void setPassword (mot de passe de chaîne) {
this.password = mot de passe;
}
public booléen isbinaryTransfer () {
retour binaryTransfer;
}
public void SetBinaryTransfer (bobinaire binaire) {
this.binaryTransfer = binaryTransfer;
}
public booléen iSpassiveMode () {
return passiveMode;
}
public void setPassiveMode (booléen passiveMode) {
this.passiveMode = passiveMode;
}
public String getEncoding () {
Encodage de retour;
}
public void setEncoding (String Encoding) {
this.encoding = codage;
}
public int GetClientTimeout () {
return ClientTimeOut;
}
public void setClientTimeout (int clientTimeout) {
this.clientTimeout = clientTimeout;
}
public ftpClient (String Host) {
this.username = "anonymous";
this.encoding = "utf-8";
this.binaryTransfer = true;
this.binaryTransfer = true;
this.port = 21;
this.host = host;
essayer {
this.ftpclient = getftpclient ();
} catch (exception e) {
System.out.println ("Créer une erreur ftpclient!");
}
}
FtpClient privé getftpclient () lève ioException {
FtpClient ftpClient = new ftpClient ();
ftpClient.setControleCcoding (codage);
connect (ftpClient);
if (passiveMode) {
ftpClient.enterLocalPassiveMode ();
}
setFileType (ftpClient);
essayer {
ftpClient.SetSoTimeout (clientTimeOut);
} catch (socketException e) {
lancer une nouvelle ioException ("Set Timeout Error.", E);
}
retour ftpClient;
}
private void SetFileType (ftpclient ftpclient) lance ioException {
essayer {
if (binaryTransfer) {
ftpClient.setFileType (ftpclient.binary_file_type);
} autre {
ftpClient.setFileType (ftpClient.ascii_file_type);
}
} catch (ioexception e) {
lancer une nouvelle ioException ("ne pouvait pas définir le type de fichier.", E);
}
}
Public Boolean Connect (ftpClient ftpClient) lève ioException {
essayer {
ftpclient.connect (hôte, port);
int réponse = ftpclient.getReplyCode ();
if (ftpreply.ispositivecompletion (réponse)) {
if (ftpclient.login (nom d'utilisateur, mot de passe)) {
setFileType (ftpClient);
Retour Vrai;
}
} autre {
this.ftpclient.disconnect ();
Jetez une nouvelle IOException ("FTP Server Refused Connection.");
}
} catch (ioexception e) {
if (this.ftpclient.isconnected ()) {
essayer {
this.ftpclient.disconnect ();
} catch (ioexception e1) {
lancer une nouvelle ioException ("ne pouvait pas se déconnecter du serveur.", E);
}
}
lancer une nouvelle ioException ("ne peut pas se connecter au serveur.", E);
}
retourne false;
}
private void disonnect () lève ioException {
essayer {
this.ftpclient.logout ();
} catch (ioexception e) {
System.out.println ("Logout May Timeout!");
} enfin {
if (this.ftpclient.isconnected ()) {
this.ftpclient.disconnect ();
}
}
}
public inputStream getStream (string serverfile) lève ioException {
InputStream insiteam = null;
essayer {
insiteam = this.ftpclient.ReverieveFileStream (serverfile);
System.out.println ("Instream Get Over!");
Retour Instream;
} catch (ioexception e) {
System.out.println ("Get Stream Exception");
retourner null;
}
}
Public Boolean WriteStream (entrée InputStream, String localfile) lève ioException {
FileoutputStream fout = new FileOutputStream (localFile);
int ch = 0;
if (input == null) {
System.out.println ("l'entrée est nul");
retourne false;
}
essayer {
ch = input.read ();
tandis que (ch! = -1) {
fout.write (ch);
ch = input.read ();
}
System.out.println ("Écrire!");
drapeau de retour;
} catch (ioexception e) {
Jetez une nouvelle ioException ("Impossible d'obtenir un fichier à partir du serveur.", E);
}
}
Public Boolean isExist (String RemoteFilePath) lève IOException {
essayer{
Fichier fichier = nouveau fichier (RemoteFilePath);
String RemotePath = RemoteFilePath.Substring (0, (RemoteFilePath.Indexof (file.getName ()) - 1));
String [] listNames = this.ftpclient.listNames (RemotePath);
System.out.println (RemoteFilePath);
for (int i = 0; i <listNames.length; i ++) {
System.out.println (listNames [i]);
if (RemoteFilePath.Equals (listNames [i])) {
Flag = true;
System.out.println ("File:" + File.getName () + "existant");
casser;
}autre {
Flag = false;
}
}
} catch (ioexception e) {
lancer une nouvelle ioException ("Fichier Exception", E);
}
drapeau de retour;
}
// principal pour les tests
public static void main (String [] args) lance ioException {
String hostname = "CP01-Testing-PS7130.cp01.baidu.com";
String ServerFile = "/ Home / Work / Check_disk.sh";
String localfile = "/ home / work / workspace / project / dhc2-0 / dhc / base / ftp / task_get";
FtpClient ftp = new ftpClient (nom d'hôte);
System.out.println (ftp.isexist (serverfile));
ftp.writeStream (ftp.getStream (serverfile), localfile);
ftp.disconnect ();
}
}
Cet outil est utilisé pour le téléchargement de cluster avec un autre outil Hadoop, de sorte que les flux d'entrée et de sortie sont séparés, qui consiste également à faciliter l'utilisation d'un autre outil.
Pour ajouter une chose, comment exécuter en configuration Linux:
Si un tel code doit être exécuté en Linux, tout d'abord, vous devez configurer le package réactif, par exemple
La copie de code est la suivante:
import org.apache.commons.net.ftp.ftpclient;
Ce package est juste téléchargé directement sur le site Web Apache.
La copie de code est la suivante:
export ftppath = "$ {path} /xxx.jar"
javac -classpath $ classpath: $ ftppath ftpclient.java
De même, ClassPath doit être spécifié lors de l'exécution:
La copie de code est la suivante:
java -classpath $ classpath: $ ftppath ftpclient
Il est recommandé de ne pas inclure $ ftppath dans ClassPath, se référer simplement aux variables d'environnement si vous l'utilisez.
Ce qui précède concerne cet article.
Veuillez prendre le temps de partager l'article avec vos amis ou de laisser un commentaire. Nous vous remercierons sincèrement pour votre soutien!