Ich muss Java verwenden, um ein FTP -Tool zu schreiben, da es nur ein bisschen Java -Grundlagen gibt, aber da ich es einige Jahre lang nicht mehr verwendet habe, kann ich es fast nicht tun, also muss ich es ein wenig tun Ein bisschen, aber zum Glück kann ich es abholen.
Da ich Javac unter Linux kompilieren kann und IDE nicht verwendet, um diese Dinge unter Gewinn zu tun, habe ich mir jedoch einige Zeit genommen, um zu rennen und zu kompilieren. . Manche.
Für das FTP -Download -Tool lautet der Code wie folgt:
Die Codekopie lautet wie folgt:
Import Java.io.file;
import Java.io.FileInputStream;
importieren java.io.filenotfoundException;
importieren java.io.fileoutputStream;
importieren java.io.ioException;
importieren java.io.inputstream;
importieren java.io.outputstream;
importieren java.net.socketException;
import org.apache.commons.net.ftp.ftpclient;
import org.apache.commons.net.ftp.ftpreply;
öffentliche Klasse ftpclient {
privater String -Host;
privater Int -Port;
privater String -Benutzername;
privates Zeichenfolgenkennwort;
privat boolean binaryTransfer = true;
private boolean passiveremode = true;
private String coding = "utf-8";
private int clientTimeout = 3000;
private boolesche Flagge = wahr;
private ftpclient ftpclient = null;
public String Gethost () {
Return Host;
}
public void Sethost (String -Host) {
this.host = host;
}
public int getSport () {
Rückgabeanschluss;
}
public void setport (int port) {
this.port = port;
}
public String getUnername () {
Rückgabe -Benutzername;
}
public void setUnername (String -Benutzername) {
this.username = userername;
}
public String getPassword () {
Passwort zurückgeben;
}
public void setPassword (String -Passwort) {
this.Password = Passwort;
}
public boolean isBinaryTransfer () {
BinaryTransfer zurückgeben;
}
public void setBaryTransfer (boolean BinaryTransfer) {
this.BinaryTransfer = BinaryTransfer;
}
public boolean ispassivemode () {
Passivemode zurückgeben;
}
public void setpassivemode (boolean passivemode) {
this.passivemode = passivemode;
}
public String getcodeing () {
Return Codierung;
}
public void setencoding (String coding) {
this.encoding = codieren;
}
public int getClienttimeout () {
ClientTimeout zurückgeben;
}
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;
versuchen {
this.ftpclient = getftpclient ();
} catch (Ausnahme e) {
System.out.println ("FTPClient -Fehler erstellen!");
}
}
private ftpclient getftpclient () löst IOException {aus
Ftpclient ftpclient = new ftpclient ();
ftpclient.setControlencoding (codieren);
Connect (ftpclient);
if (passiveremode) {
ftpclient.enterLocalPassivemode ();
}
setFiletype (ftpclient);
versuchen {
ftpclient.setsotimeout (ClientTimeout);
} catch (socketException e) {
Neue IOException ("Timeout -Fehler festlegen", e);
}
return ftpclient;
}
private void setFiletype (ftpclient ftpclient) löst ioException {aus
versuchen {
if (binaryTransfer) {
ftpclient.setFiletype (ftpclient.berary_file_type);
} anders {
ftpclient.setFiletype (ftpclient.ascii_file_type);
}
} catch (ioException e) {
Neue IOException werfen ("konnte nicht den Dateityp festlegen", e);
}
}
public boolean connect (ftpclient ftpclient) löst ioException {aus
versuchen {
ftpclient.connect (Host, Port);
int Reply = ftpclient.getReplyCode ();
if (ftpreply.ispositiveCompletion (Antwort)) {
if (ftpclient.login (Benutzername, Passwort)) {
setFiletype (ftpclient);
zurückkehren;
}
} anders {
this.ftpclient.disconnect ();
Neue IOException werfen ("FTP Server verweigerte die Verbindung.");
}
} catch (ioException e) {
if (this.ftpclient.isconnected ()) {
versuchen {
this.ftpclient.disconnect ();
} catch (ioException e1) {
Neue IOException werfen ("konnte die Verbindung nicht vom Server trennen.", E);
}
}
Neue IOException ("konnte keine Verbindung zum Server herstellen", e);
}
false zurückgeben;
}
private void disconnect () löst ioException {aus
versuchen {
this.ftpclient.logout ();
} catch (ioException e) {
System.out.println ("Abmelden Mai Timeout!");
} Endlich {
if (this.ftpclient.isconnected ()) {
this.ftpclient.disconnect ();
}
}
}
public InputStream getStream (String Serverfile) löst IOException {aus
InputStream Instream = NULL;
versuchen {
instream = this.ftpclient.retrieveFilESTREAM (Serverfile);
System.out.println ("Instrom überschreiten!");
Return -Antrieb;
} catch (ioException e) {
System.out.println ("Stream -Ausnahme erhalten");
null zurückkehren;
}
}
public boolean writeStream (InputStream -Eingabe, String localfile) löst IoException {aus
FileOutputStream fout = new FileOutputStream (localFile);
int ch = 0;
if (input == null) {
System.out.println ("Eingabe ist null");
false zurückgeben;
}
versuchen {
CH = input.read ();
while (ch! = -1) {
fout.write (ch);
CH = input.read ();
}
System.out.println ("Schreiben Sie über!");
Rückflagge;
} catch (ioException e) {
Neue IOException werfen ("konnte keine Datei vom Server erhalten.", E);
}
}
public boolean isexist (String remoteFilepath) löst ioException {aus
versuchen{
Datei Datei = neue Datei (RemoteFilePath);
String remotepath = remoteFilepath.substring (0, (remoteFilepath.indexof (file.getName ())-1));
String [] listnames = this.ftpclient.listnames (remotepath);
System.out.println (RemoteFilepath);
für (int i = 0; i <listNames.length; i ++) {
System.out.println (ListNames [i]);
if (remoteFilepath.equals (ListNames [i])) {
Flag = wahr;
System.out.println ("Datei:"+file.getName ()+"existiert");
brechen;
}anders {
Flag = Falsch;
}
}
} catch (ioException e) {
Neue IOException ("Dateiausnahme", e) werfen;
}
Rückflagge;
}
// Haupt zum Testen
public static void main (String [] args) löst ioException {aus
String hostname = "cp01-testing-ps7130.cp01.baidu.com";
String serverfile = "/home/work/check_disk.sh";
String localFile = "/home/work/wortspace/project/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 ();
}
}
Dieses Tool wird zum Cluster -Hochladen mit einem anderen Hadoop -Tool verwendet, sodass die Eingangs- und Ausgangsströme getrennt sind, wodurch auch die Verwendung eines anderen Tools erleichtert wird.
So fügen Sie eine Sache hinzu, wie Sie in Linux -Konfiguration ausgeführt werden:
Wenn ein solcher Code in Linux ausgeführt werden muss, müssen Sie zunächst das Responsive Paket konfigurieren, z. B.
Die Codekopie lautet wie folgt:
import org.apache.commons.net.ftp.ftpclient;
Dieses Paket wird gerade direkt auf der Apache -Website heruntergeladen.
Die Codekopie lautet wie folgt:
exportieren ftppath = "$ {path} /xxx.jar"
Javac -ClassPath $ ClassPath: $ ftppath ftpclient.java
In ähnlicher Weise muss beim Ausführen der Klassenpfad angegeben werden:
Die Codekopie lautet wie folgt:
Java -ClassPath $ ClassPath: $ ftppath ftpclient
Es wird empfohlen, $ ftppath nicht in den Klassenpfad einzubeziehen. Wenn Sie es verwenden, müssen Sie nicht die Umgebungsvariablen verweisen.
Das obige dreht sich alles um diesen Artikel.
Bitte nehmen Sie sich etwas Zeit, um den Artikel mit Ihren Freunden zu teilen oder einen Kommentar zu hinterlassen. Wir werden uns aufrichtig für Ihre Unterstützung bedanken!