Java writing FTP download tool
- 2020-04-01 03:43:37
- OfStack
Need to use Java to write a tool for FTP, because there is only a little Java foundation, but because of several years not to use, almost not, had to do a little bit, can pick up.
However, because I compiled with javac under Linux instead of using IDE under WIN, I spent a little more time on running and compiling, but I knew a little more about how to compile and run JAVA.
For the FTP download tool, the code is as follows:
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;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
public class FtpClient {
private String host;
private int port;
private String username;
private String password;
private boolean binaryTransfer = true;
private boolean passiveMode = true;
private String encoding = "UTF-8";
private int clientTimeout = 3000;
private boolean flag=true;
private FTPClient ftpClient = null;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public boolean isBinaryTransfer() {
return binaryTransfer;
}
public void setBinaryTransfer(boolean binaryTransfer) {
this.binaryTransfer = binaryTransfer;
}
public boolean isPassiveMode() {
return passiveMode;
}
public void setPassiveMode(boolean passiveMode) {
this.passiveMode = passiveMode;
}
public String getEncoding() {
return encoding;
}
public void setEncoding(String encoding) {
this.encoding = encoding;
}
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;
try {
this.ftpClient = getFTPClient();
} catch (Exception e) {
System.out.println("Create FTPClient error!");
}
}
private FTPClient getFTPClient() throws IOException {
FTPClient ftpClient = new FTPClient();
ftpClient.setControlEncoding(encoding);
connect(ftpClient);
if (passiveMode) {
ftpClient.enterLocalPassiveMode();
}
setFileType(ftpClient);
try {
ftpClient.setSoTimeout(clientTimeout);
} catch (SocketException e) {
throw new IOException("Set timeout error.", e);
}
return ftpClient;
}
private void setFileType(FTPClient ftpClient) throws IOException {
try {
if (binaryTransfer) {
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
} else {
ftpClient.setFileType(FTPClient.ASCII_FILE_TYPE);
}
} catch (IOException e) {
throw new IOException("Could not to set file type.", e);
}
}
public boolean connect(FTPClient ftpClient) throws IOException {
try {
ftpClient.connect(host, port);
int reply = ftpClient.getReplyCode();
if (FTPReply.isPositiveCompletion(reply)) {
if (ftpClient.login(username, password)) {
setFileType(ftpClient);
return true;
}
} else {
this.ftpClient.disconnect();
throw new IOException("FTP server refused connection.");
}
} catch (IOException e) {
if (this.ftpClient.isConnected()) {
try {
this.ftpClient.disconnect();
} catch (IOException e1) {
throw new IOException("Could not disconnect from server.", e);
}
}
throw new IOException("Could not connect to server.", e);
}
return false;
}
private void disconnect() throws IOException {
try {
this.ftpClient.logout();
} catch (IOException e) {
System.out.println("logout may timeout!");
} finally {
if (this.ftpClient.isConnected()) {
this.ftpClient.disconnect();
}
}
}
public InputStream getStream(String serverFile) throws IOException {
InputStream inStream = null;
try {
inStream = this.ftpClient.retrieveFileStream(serverFile);
System.out.println("inStream get over!");
return inStream;
} catch (IOException e) {
System.out.println("get stream exception");
return null;
}
}
public boolean writeStream(InputStream input, String localFile) throws IOException {
FileOutputStream fout = new FileOutputStream(localFile);
int ch = 0;
if(input == null){
System.out.println("input is null");
return false;
}
try {
ch = input.read();
while(ch != -1){
fout.write(ch);
ch = input.read();
}
System.out.println("write over!");
return flag;
} catch (IOException e) {
throw new IOException("Couldn't get file from server.", e);
}
}
public boolean isExist(String remoteFilePath)throws IOException{
try{
File file=new File(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()+" existed");
break;
}else {
flag=false;
}
}
} catch (IOException e) {
throw new IOException("FILE EXCEPTION", e);
}
return flag;
}
//main for testing
public static void main(String[] args) throws 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(hostname);
System.out.println(ftp.isExist(serverFile));
ftp.writeStream(ftp.getStream(serverFile), localFile);
ftp.disconnect();
}
}
This tool is used for cluster uploading with another Hadoop tool, so the input and output streams are separated in order to facilitate the use of another tool.
One more tip on how to run in a Linux configuration:
If such code needs to run in a Linux environment, first configure the package that responds, for example
import org.apache.commons.net.ftp.FTPClient;
This package can be downloaded directly from the apache website. After unzipping, the corresponding jar can be found and referenced during compilation:
export FTPPATH="${ The path }/xxx.jar"
javac -classpath $CLASSPATH:$FTPPATH FtpClient.java
Also, specify the classpath at runtime:
java -classpath $CLASSPATH:$FTPPATH FtpClient
It is recommended that you do not include $FTPPATH in your CLASSPATH, just refer to the same environment variable as the package you use, there is no need to add it all at once, just as there is no need to import all the packages.
That's all for this article, and I hope it will help you learn Java.
Please take a moment to share the article with your friends or leave a comment. We sincerely appreciate your support!