FTP, SFTP, FTPS examples In Java .

最新推荐文章于 2023-02-20 14:56:19 发布
最新推荐文章于 2023-02-20 14:56:19 发布
阅读量2k 收藏 3
点赞数
分类专栏： JAVA

http://blog.csdn.net/luoshenhappy99/article/details/7448385

The FTP (File Transfer Protocol), FTPS (FTP over SSL), SFTP (FTP over SSH) and SCP (Secure Copy over SSH) . 

http://commons.apache.org/proper/commons-net/apidocs/org/apache/commons/net/ftp/FTPSClient.html


The examples of FTP/FTPs, the jar supporting them is org.apache.commons.net.ftp.

[java] view plain copy print ?
  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.security.NoSuchAlgorithmException;  
  6. import java.util.Vector;  
  7.   
  8. import org.apache.commons.net.ftp.FTPClient;  
  9. import org.apache.commons.net.ftp.FTPFile;  
  10. import org.apache.commons.net.ftp.FTPReply;  
  11. import org.apache.commons.net.ftp.FTPSClient;  
  12. import org.apache.log4j.Logger;  
  13.   
  14. public class FtpClient{  
  15.   
  16.     private static final Logger logger = Logger.getLogger(FtpClient.class);  
  17.   
  18.     private FTPClient client;  
  19.   
  20.     public FtpClient(boolean ftps) {  
  21.         if (ftps) {  
  22.             try {  
  23.                 client = new FTPSClient(true);  
  24.             } catch (NoSuchAlgorithmException e) {  
  25.                 e.printStackTrace();  
  26.             }  
  27.         } else {  
  28.             client = new FTPClient();  
  29.         }  
  30.     }  
  31.   
  32.     public boolean changeDir(String remotePath) throws Exception {  
  33.         return client.changeWorkingDirectory(remotePath);  
  34.     }  
  35.   
  36.     public boolean connect(String host, String login, String password, int port) throws Exception {  
  37.         logger.debug("FTP request connect to " + host + ":" + port);  
  38.         client.connect(host, port);  
  39.         int reply = client.getReplyCode();  
  40.         if (FTPReply.isPositiveCompletion(reply)) {  
  41.             logger.debug("FTP request login as " + login);  
  42.             if (client.login(login, password)) {  
  43.                 client.enterLocalPassiveMode();  
  44.                 return true;  
  45.             }  
  46.         }  
  47.         disconnect();  
  48.         return false;  
  49.     }  
  50.   
  51.     public void disconnect() throws Exception {  
  52.         logger.debug("FTP request disconnect");  
  53.         client.disconnect();  
  54.     }  
  55.   
  56.   
  57.     protected boolean downloadFileAfterCheck(String remotePath, String localFile) throws IOException {  
  58.   
  59.         boolean rst;  
  60.         FileOutputStream out = null;  
  61.         try {  
  62.             File file = new File(localFile);  
  63.             if (!file.exists()) {  
  64.                 out = new FileOutputStream(localFile);  
  65.                 rst = client.retrieveFile(remotePath, out);  
  66.             } else {  
  67.                 rst = true;  
  68.             }  
  69.         } finally {  
  70.             if (out != null) {  
  71.                 out.close();  
  72.             }  
  73.         }  
  74.         if (out != null) {  
  75.             out.close();  
  76.         }  
  77.         return rst;  
  78.     }  
  79.   
  80.     protected boolean downloadFile(String remotePath, String localFile) throws IOException {  
  81.   
  82.         boolean rst;  
  83.         FileOutputStream out = null;  
  84.         try {  
  85.             out = new FileOutputStream(localFile);  
  86.             rst = client.retrieveFile(remotePath, out);  
  87.         } finally {  
  88.             if (out != null) {  
  89.                 out.close();  
  90.             }  
  91.         }  
  92.         return rst;  
  93.     }  
  94.   
  95.     public Vector<String> listFileInDir(String remoteDir) throws Exception {  
  96.         if (changeDir(remoteDir)) {  
  97.             FTPFile[] files = client.listFiles();  
  98.             Vector<String> v = new Vector<String>();  
  99.             for (FTPFile file : files) {  
  100.                 if (!file.isDirectory()) {  
  101.                     v.addElement(file.getName());  
  102.                 }  
  103.             }  
  104.             return v;  
  105.         } else {  
  106.             return null;  
  107.         }  
  108.     }  
  109.   
  110.     public boolean uploadFile(String localFile, String remotePath) throws IOException {  
  111.         FileInputStream in = new FileInputStream(localFile);  
  112.         boolean rst;  
  113.         try {  
  114.             rst = client.storeFile(remotePath, in);  
  115.         } finally {  
  116.             in.close();  
  117.         }  
  118.         return rst;  
  119.     }  
  120.   
  121.     @Override  
  122.     public Vector<String> listSubDirInDir(String remoteDir) throws Exception {  
  123.         if (changeDir(remoteDir)) {  
  124.             FTPFile[] files = client.listFiles();  
  125.             Vector<String> v = new Vector<String>();  
  126.             for (FTPFile file : files) {  
  127.                 if (file.isDirectory()) {  
  128.                     v.addElement(file.getName());  
  129.                 }  
  130.             }  
  131.             return v;  
  132.         } else {  
  133.             return null;  
  134.         }  
  135.     }  
  136.   
  137.     protected boolean createDirectory(String dirName) {  
  138.         try {  
  139.             return client.makeDirectory(dirName);  
  140.         } catch (IOException e) {  
  141.             e.printStackTrace();  
  142.         }  
  143.         return false;  
  144.     }  
  145.   
  146.   
  147.     public boolean isARemoteDirectory(String path) {  
  148.         String cache = "/";  
  149.         try {  
  150.             cache = client.printWorkingDirectory();  
  151.         } catch (NullPointerException e) {  
  152.             //nop   
  153.         } catch (IOException e) {  
  154.             e.printStackTrace();  
  155.         }  
  156.         try {  
  157.             boolean isDir = changeDir(path);  
  158.             changeDir(cache);  
  159.             return isDir;  
  160.         } catch (IOException e) {  
  161.             //e.printStackTrace();  
  162.         } catch (Exception e) {  
  163.             //e.printStackTrace();  
  164.         }  
  165.         return false;  
  166.     }  
  167.   
  168.     public String getWorkingDirectory() {  
  169.         try {  
  170.             return client.printWorkingDirectory();  
  171.         } catch (IOException e) {  
  172.         }  
  173.         return null;  
  174.     }  
  175.   
  176. }  
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.Vector;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.commons.net.ftp.FTPSClient;
import org.apache.log4j.Logger;

public class FtpClient{

	private static final Logger logger = Logger.getLogger(FtpClient.class);

	private FTPClient client;

	public FtpClient(boolean ftps) {
		if (ftps) {
			try {
				client = new FTPSClient(true);
			} catch (NoSuchAlgorithmException e) {
				e.printStackTrace();
			}
		} else {
			client = new FTPClient();
		}
	}

	public boolean changeDir(String remotePath) throws Exception {
		return client.changeWorkingDirectory(remotePath);
	}

	public boolean connect(String host, String login, String password, int port) throws Exception {
		logger.debug("FTP request connect to " + host + ":" + port);
		client.connect(host, port);
		int reply = client.getReplyCode();
		if (FTPReply.isPositiveCompletion(reply)) {
			logger.debug("FTP request login as " + login);
			if (client.login(login, password)) {
				client.enterLocalPassiveMode();
				return true;
			}
		}
		disconnect();
		return false;
	}

	public void disconnect() throws Exception {
		logger.debug("FTP request disconnect");
		client.disconnect();
	}


	protected boolean downloadFileAfterCheck(String remotePath, String localFile) throws IOException {

		boolean rst;
		FileOutputStream out = null;
		try {
			File file = new File(localFile);
			if (!file.exists()) {
				out = new FileOutputStream(localFile);
				rst = client.retrieveFile(remotePath, out);
			} else {
				rst = true;
			}
		} finally {
			if (out != null) {
				out.close();
			}
		}
		if (out != null) {
			out.close();
		}
		return rst;
	}

	protected boolean downloadFile(String remotePath, String localFile) throws IOException {

		boolean rst;
		FileOutputStream out = null;
		try {
			out = new FileOutputStream(localFile);
			rst = client.retrieveFile(remotePath, out);
		} finally {
			if (out != null) {
				out.close();
			}
		}
		return rst;
	}

	public Vector<String> listFileInDir(String remoteDir) throws Exception {
		if (changeDir(remoteDir)) {
			FTPFile[] files = client.listFiles();
			Vector<String> v = new Vector<String>();
			for (FTPFile file : files) {
				if (!file.isDirectory()) {
					v.addElement(file.getName());
				}
			}
			return v;
		} else {
			return null;
		}
	}

	public boolean uploadFile(String localFile, String remotePath) throws IOException {
		FileInputStream in = new FileInputStream(localFile);
		boolean rst;
		try {
			rst = client.storeFile(remotePath, in);
		} finally {
			in.close();
		}
		return rst;
	}

	@Override
	public Vector<String> listSubDirInDir(String remoteDir) throws Exception {
		if (changeDir(remoteDir)) {
			FTPFile[] files = client.listFiles();
			Vector<String> v = new Vector<String>();
			for (FTPFile file : files) {
				if (file.isDirectory()) {
					v.addElement(file.getName());
				}
			}
			return v;
		} else {
			return null;
		}
	}

	protected boolean createDirectory(String dirName) {
		try {
			return client.makeDirectory(dirName);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}


	public boolean isARemoteDirectory(String path) {
		String cache = "/";
		try {
			cache = client.printWorkingDirectory();
		} catch (NullPointerException e) {
			//nop
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			boolean isDir = changeDir(path);
			changeDir(cache);
			return isDir;
		} catch (IOException e) {
			//e.printStackTrace();
		} catch (Exception e) {
			//e.printStackTrace();
		}
		return false;
	}

	public String getWorkingDirectory() {
		try {
			return client.printWorkingDirectory();
		} catch (IOException e) {
		}
		return null;
	}

}



 


the example of SFTP, the jar supporting this is com.jcraft.jsch


[java] view plain copy print ?
  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.util.Vector;  
  6.   
  7. import org.apache.commons.vfs.FileSystemException;  
  8. import org.apache.commons.vfs.FileSystemOptions;  
  9. import org.apache.commons.vfs.provider.sftp.SftpClientFactory;  
  10. import org.apache.commons.vfs.provider.sftp.SftpFileSystemConfigBuilder;  
  11.   
  12. import com.jcraft.jsch.Channel;  
  13. import com.jcraft.jsch.ChannelSftp;  
  14. import com.jcraft.jsch.JSchException;  
  15. import com.jcraft.jsch.Session;  
  16. import com.jcraft.jsch.SftpException;  
  17. import com.jcraft.jsch.ChannelSftp.LsEntry;  
  18.   
  19. public class SFTPClient{  
  20.   
  21.     private ChannelSftp command;  
  22.   
  23.     private Session session;  
  24.   
  25.     public SFTPClient() {  
  26.         command = null;  
  27.     }  
  28.   
  29.     public boolean connect(String host, String login, String password, int port) throws JSchException {  
  30.   
  31.         //If the client is already connected, disconnect  
  32.         if (command != null) {  
  33.             disconnect();  
  34.         }  
  35.         FileSystemOptions fso = new FileSystemOptions();  
  36.         try {  
  37.             SftpFileSystemConfigBuilder.getInstance().setStrictHostKeyChecking(fso, "no");  
  38.             session = SftpClientFactory.createConnection(host, port, login.toCharArray(), password.toCharArray(), fso);  
  39.             Channel channel = session.openChannel("sftp");  
  40.             channel.connect();  
  41.             command = (ChannelSftp) channel;  
  42.   
  43.         } catch (FileSystemException e) {  
  44.             e.printStackTrace();  
  45.             return false;  
  46.         }  
  47.         return command.isConnected();  
  48.     }  
  49.   
  50.     public void disconnect() {  
  51.         if (command != null) {  
  52.             command.exit();  
  53.         }  
  54.         if (session != null) {  
  55.             session.disconnect();  
  56.         }  
  57.         command = null;  
  58.     }  
  59.   
  60.     public Vector<String> listFileInDir(String remoteDir) throws Exception {  
  61.         try {  
  62.             Vector<LsEntry> rs = command.ls(remoteDir);  
  63.             Vector<String> result = new Vector<String>();  
  64.             for (int i = 0; i < rs.size(); i++) {  
  65.                 if (!isARemoteDirectory(rs.get(i).getFilename())) {  
  66.                     result.add(rs.get(i).getFilename());  
  67.                 }  
  68.             }  
  69.             return result;  
  70.         } catch (Exception e) {  
  71.             e.printStackTrace();  
  72.             System.err.println(remoteDir);  
  73.             throw new Exception(e);  
  74.         }  
  75.     }  
  76.   
  77.     public Vector<String> listSubDirInDir(String remoteDir) throws Exception {  
  78.         Vector<LsEntry> rs = command.ls(remoteDir);  
  79.         Vector<String> result = new Vector<String>();  
  80.         for (int i = 0; i < rs.size(); i++) {  
  81.             if (isARemoteDirectory(rs.get(i).getFilename())) {  
  82.                 result.add(rs.get(i).getFilename());  
  83.             }  
  84.         }  
  85.         return result;  
  86.     }  
  87.   
  88.     protected boolean createDirectory(String dirName) {  
  89.         try {  
  90.             command.mkdir(dirName);  
  91.         } catch (Exception e) {  
  92.             return false;  
  93.         }  
  94.         return true;  
  95.     }  
  96.   
  97.     protected boolean downloadFileAfterCheck(String remotePath, String localPath) throws IOException {  
  98.         FileOutputStream outputSrr = null;  
  99.         try {  
  100.             File file = new File(localPath);  
  101.             if (!file.exists()) {  
  102.                 outputSrr = new FileOutputStream(localPath);  
  103.                 command.get(remotePath, outputSrr);  
  104.             }  
  105.         } catch (SftpException e) {  
  106.             try {  
  107.                 System.err.println(remotePath + " not found in " + command.pwd());  
  108.             } catch (SftpException e1) {  
  109.                 e1.printStackTrace();  
  110.             }  
  111.             e.printStackTrace();  
  112.             return false;  
  113.         } finally {  
  114.             if (outputSrr != null) {  
  115.                 outputSrr.close();  
  116.             }  
  117.         }  
  118.         return true;  
  119.     }  
  120.   
  121.     protected boolean downloadFile(String remotePath, String localPath) throws IOException {  
  122.         FileOutputStream outputSrr = new FileOutputStream(localPath);  
  123.         try {  
  124.             command.get(remotePath, outputSrr);  
  125.         } catch (SftpException e) {  
  126.             try {  
  127.                 System.err.println(remotePath + " not found in " + command.pwd());  
  128.             } catch (SftpException e1) {  
  129.                 e1.printStackTrace();  
  130.             }  
  131.             e.printStackTrace();  
  132.             return false;  
  133.         } finally {  
  134.             if (outputSrr != null) {  
  135.                 outputSrr.close();  
  136.             }  
  137.         }  
  138.         return true;  
  139.     }  
  140.   
  141.     protected boolean uploadFile(String localPath, String remotePath) throws IOException {  
  142.         FileInputStream inputSrr = new FileInputStream(localPath);  
  143.         try {  
  144.             command.put(inputSrr, remotePath);  
  145.         } catch (SftpException e) {  
  146.             e.printStackTrace();  
  147.             return false;  
  148.         } finally {  
  149.             if (inputSrr != null) {  
  150.                 inputSrr.close();  
  151.             }  
  152.         }  
  153.         return true;  
  154.     }  
  155.   
  156.     public boolean changeDir(String remotePath) throws Exception {  
  157.         try {  
  158.             command.cd(remotePath);  
  159.         } catch (SftpException e) {  
  160.             return false;  
  161.         }  
  162.         return true;  
  163.     }  
  164.   
  165.     public boolean isARemoteDirectory(String path) {  
  166.         try {  
  167.             return command.stat(path).isDir();  
  168.         } catch (SftpException e) {  
  169.             //e.printStackTrace();  
  170.         }  
  171.         return false;  
  172.     }  
  173.   
  174.     public String getWorkingDirectory() {  
  175.         try {  
  176.             return command.pwd();  
  177.         } catch (SftpException e) {  
  178.             e.printStackTrace();  
  179.         }  
  180.         return null;  
  181.     }  
  182.   
  183. }  

 

caolaosanahnu
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java ftps_java-FTP
weixin_34081203的博客
02-12 475
总结一下工作中用到的，ftp传输文件的操作案例。一、设计思路java中实现ftp传输的开源jar包邮很多，这里推荐commons-net包下面的ftp工具类，用起来简单，用的人也多。下面粘贴一段源码，我们可以从这个方法点进去可以看到这个类中上传文件需要的参数，一个是文件名，一个是输入流。public boolean storeFile(String remote, InputStream loca...
java ftps上传_java – 使用FTPS将文件从android传输到服务器
weixin_42317115的博客
02-19 252
您可以尝试以下代码,我希望它也适用于您的情况.该代码使用Apache Commons vsf2通过安全ftp连接(SFTP)上传文件try {String filepath = "";String serverAddress = "";String userId = "";String password = "";String remoteDirectory = "";String keyPath...
java ftp插件下载_增强的Java FTP工具----扩展免费版的edtftpj
weixin_39902608的博客
02-13 67
import com.enterprisedt.net.ftp.FTPException;import com.enterprisedt.net.ftp.FileTransferClient;import com.enterprisedt.net.ftp.WriteMode;import org.apache.commons.logging.Log;import org.apache.common...
启用并设置服务器配置的作用_ftp自动连接，ftp自动连接ftp服务器并设置定时上传及java配置ftp环境...
weixin_29816689的博客
01-21 197
IIS7服务器管理工具具备所有服务器管理工具的功能，比如批量管理。同时它还有很多的自主研发功能。比如同步操作、到期提醒、数据安全和定期执行。当然适用的系统也有Windows和liunx操作系统。还支持Vnc和Ftp批量操作。这款软件还有一个非常重要的特点，这是一款中文软件，非常符合国人的用户需求。这是一款不可小看的一款管理工具。工具也在不断更新中，开发人员技术人员都在不断努力的为广大用户做出努力。...
java ftps_Java - FTPS
weixin_42116701的博客
02-12 762
import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.PrintWriter;import java.security.NoSuchA...
浅谈 FTP、FTPS 与 SFTP的区别
01-09
FTPS（FTP over SSL/TLS）是 FTP 的安全版本，它通过SSL或TLS加密机制提供安全保障。FTPS 分为两种模式：隐式 SSL 和显式 SSL。隐式 SSL 在端口 990 上运行，所有数据交换都在 SSL 会话中进行，而显式 SSL 允许...
java common FTPClient ftp sftp
06-06
内容概要：java common来操作的ftp和sftp。读取文件、操作文件、删除文件、移动文件（文件改名）等一系列操作，只要导入依赖.txt里面的依赖，就可以直接使用，test类用来快速使用，提示都给足了，ftp的一系列操作...
ftp_sftp_x64.rar
06-21
项目中需要将文件从windows部署至linux，每次使用winscp或xftp手动重复执行效率低且容易出错。此包中为2个批处理程序ftp和sftp，稍微修改就可以实现脚本自动从windows通过ftp或sftp向linux传文件，效率高不出错。
ftp.zip_ftp.java_java ftp
09-20
9. **安全性**：虽然基础的FTP协议不提供加密，但可以使用FTPS（FTP over TLS/SSL）或SFTP（SSH File Transfer Protocol）增强安全性。Java中可能需要使用特定库如Apache Commons Net来支持这些安全协议。 以上是对...
javaftp4j实现ftps加密上传
02-22
ftp4j是一个功能丰富的Java FTP客户端库，它支持FTP、FTPS和SFTP协议。使用ftp4j进行FTPS上传，你需要以下步骤： 1. 添加ftp4j库依赖：在项目中引入ftp4j的jar包或者Maven/Gradle依赖，确保可以调用其API。 2. ...
ftps java实现
05-19
ftps java实现
JAVA遍历下载FTPS服务器上的文件
08-09
JAVA遍历下载FTPS服务器上的文件，
java实现ftp和sftp的工具类
01-29
ftp支持主动和被动模式上传下载，sftp支持上传功能
java ftps转的，修改了下不错保存在这里
02-21
java ftps转的，修改了下不错保存在这里
ftps和https双向认证demo
05-31
ftps和https双向认证 使用pfx和jks证书
java ftps test
普普通通
12-07 3261
<br />class JavaTest {<br />    public static void main(String[] args) {<br />  ByteArrayOutputStream Log = new ByteArrayOutputStream();<br />  PrintStream printLog = new PrintStream(Log);<br />  PrintWriter LogPrinter = new PrintWriter(Log);<br />  try  {
java 链接ftps服务器
ma1476684479的博客
04-13 5221
之前链接ftps服务器时候创建client的时候总是链接不上,后来找到原因 我之前用的包时commons.net 1.3的版本 后来改成commons.net 3.1的 这个版本中有一个FTPSclient方法 用于链接fpts服务器 具体链接代码: maven导的包 <dependency> <groupId>com...
基于TLS双向验证的java模拟FTPS的Server端和client端
qq_45815075的博客
02-20 1217
基于TLS双向验证的java模拟FTPS的Server端和client端
Java使用FTP、FTPS上传文件
Love_Long的博客
12-02 3343
1.ftp和ftps ftp文件传输协议是应用层协议，用于传输文件信息，linux上需要安装vsftpd才能使用(明文传输) ftps为FTP协议和数据通道添加了SSL功能，可以对传输信息加密 2.ftp传输文件 引入maven依赖 <!-- https://mvnrepository.com/artifact/commons-net/commons-net --&...
java.sftp 下载数据文件
最新发布
02-08
Java提供了多种方式来进行SFTP（SSH File Transfer Protocol）下载数据文件的操作。其中一种常用的方式是使用JSch库，它是一个纯Java实现的SSH2协议的库。 以下是使用JSch库进行SFTP下载数据文件的基本步骤： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值