精华内容
下载资源
问答
  • 主要介绍了Java连接ftp服务器实例代码 的相关资料,需要的朋友可以参考下
  • java ftp连接

    2017-03-08 16:50:50
    在网上找了好久没有现成的ftp连接池jar包,自己花了一些时间实现了一个简单的连接池,用了一段时间稳定性还可以。
  • Java的Random类详解 Random类专门用于生成一个伪随机数,它有两个构造器:一个构造器使用默认的种子(以当前时间作为种子),另一个构造器需要程序员显示传入一个long型整数的种子. Random类比Math类的rando ... spring ...

    android 获取SD卡相关信息

    Object localOb; String str1 = null; try { localOb = new FileReader("/sys/block/mmcblk0/device/t ...

    PHP内核的学习--创建PHP扩展

    开始看PHP内核也有一段时间了,现在开始边学边总结,今天就总结一下如何创建自己的PHP扩展. 我的环境如下: 系统:Ubuntu 14.04 php版本:5.5.19 参考摘录:用C/C++扩展你的P ...

    HtmlHelper用法大全

    HTML扩展类的所有方法都有2个参数: 以textbox为例子 public static string TextBox( this HtmlHelper htmlHelper, string nam ...

    Servlet中乱码问题

    页面编码方式为utf-8 当使用post传值时 request.setContentType("utf-8"); 当使用get传值时 String str = request.ge ...

    Java的Random类详解

    Random类专门用于生成一个伪随机数,它有两个构造器:一个构造器使用默认的种子(以当前时间作为种子),另一个构造器需要程序员显示传入一个long型整数的种子. Random类比Math类的rando ...

    spring boot 搭建

    http://www.ityouknow.com/springboot/2018/06/12/spring-boo-java-simple.html 在http://start.spring.io/下 ...

    让JSON.js完全适应.NET

    动机:.net 默认的时间序列化方式为\/Date(数字 时区)\/,序列化成JSON在前端很难处理,有没有一种好的处理方式呢? 改进: JSON = new function(){ this.dec ...

    力扣(LeetCode)448. 找到所有数组中消失的数字

    给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组,数组中的元素一些出现了两次,另一些只出现一次. 找到所有在 [1, n] 范围之间没有出现在数组中的数字. 您能在不使 ...

    debian 安装使用NTP

    编程之路刚刚开始,错误难免,希望大家能够指出. 领导要求,要4台机器时钟同步,上网查了查,主要看了看ptp和ntp,感觉ntp就够用,索性就直接上手ntp了. 以下内容纯属最基础的内容,只适合第一次接 ...

    展开全文
  • java ftp 服务器

    2018-02-23 10:44:17
    一个简单的demo,适合初学者,java语言使用第三方API,进程FTP上传下载的demo
  • java 连接 FTP 文件操作(上传,下载,删除,复制.zipjava 连接 FTP 文件操作(上传,下载,删除,复制.zip
  • 主要为大家详细介绍了Java语言实现简单FTP软件,FTP连接管理模块的实现方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java 连接 FTP 文件操作(上传,下载,删除,复制
  • 主要介绍了java使用apache commons连接ftp修改ftp文件名失败原因解析,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • java连接FTP服务器

    千次阅读 2019-06-03 00:05:57
    这一期,我们来学习一下如何用Java连接FTP服务器。在工程项目中,我们往往需要连接FTP服务器。当我们有此需求时,可以从两个方面考虑。第一,根据FTP协议自己写出一套程序,这是一种思路,当然这是一件很费时又耗...

           这一期,我们来学习一下如何用Java连接FTP服务器。在工程项目中,我们往往需要连接FTP服务器。当我们有此需求时,可以从两个方面考虑。第一,根据FTP协议自己写出一套程序,这是一种思路,当然这是一件很费时又耗成本的一件事。我们是工程师,我们的目的是把需求实现,而不是科研项目。所以得考虑另一种思路,去寻找已经做好的API。好巧,刚好有一个开源组织为我们做好了这个API,那就是伟大的Apache。下面就开始时根据Apache给我们提供的API完成我们的需求。

          第一步,下载jar包,登录官网如下:

    然后找到“Projects”点进去,出现下拉框。点击“Project List”

     

     

    找到Commons点进去

     

    往下滑,找到“net”

    点进去,然后在左上角找到“download”

     

    点击然后往下滑,找到如图

    其中Binaries是编译后的jar,Source是源代码。一般使用的是编译后的jar,将其下载,下载之后就是新建项目导jar包。如何导jar,不会再这里说。此时,我们jar已经准备好。我们还需要一个ftp服务器,如何建立ftp服务器也不会再这里说。现在假设你已经创建好项目,已经建立好ftp服务器,下面就直接上代码了。

    package my;
    
    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.io.UnsupportedEncodingException;
    import java.text.SimpleDateFormat;
    
    import org.apache.commons.net.ftp.FTP;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPFile;
    import org.apache.commons.net.ftp.FTPReply;
    
    public class TestFTPClient
    {
    	// API里对中文FTP目录的处理有点问题
    	// 在调用 changeWorkingDirectory() / listFiles()等方法时,将参数路径转换一下
    	public static String ftpPath(String path)
    	{
    		try
    		{
    			return new String(path.getBytes("UTF-8"), FTP.DEFAULT_CONTROL_ENCODING);
    		} catch (UnsupportedEncodingException e)
    		{
    			return "";
    		}
    	}
    
    	public static void main(String[] args) throws Exception
    	{
    		FTPClient ftp = new FTPClient();
    
    		// 连接服务器
    		ftp.connect("127.0.0.1", 21);
    		int reply = ftp.getReplyCode();
    		if (!FTPReply.isPositiveCompletion(reply))
    		{
    			ftp.disconnect();
    			System.out.println("** 无法连接至FTP服务器!");
    			System.exit(1);
    		}
    
    		if (!ftp.login("test", "123456"))
    		{
    			ftp.logout();
    			System.out.println("** 错误的用户名或密码!");
    			System.exit(1);
    		}
    
    		System.out.println("Connected.");
    
    		// 字节传输 BINARY_FILE_TYPE
    		// 文本传输 ASCII_FILE_TYPE
    		// 一般使用BINARY模式来传输文件,很少使用 ASCII_FILE_TYPE
    		ftp.setFileType(FTP.BINARY_FILE_TYPE);
    
    		// 主动模式: enterLocalActiveMode()
    		// 被动模式: enterLocalPassiveMode()
    		// 一般选择被动模式
    		ftp.enterLocalPassiveMode();
    
    		// 设置控制通道的字符集, 要与服务端的设定一致
    		ftp.setControlEncoding("UTF-8");
    		// 切换目录 ( 用ftpPath() 转换一下 )
    		// boolean rc = ftp.changeWorkingDirectory(ftpPath("/图片"));
    		// if(!rc)
    		// {
    		// System.out.println("切换目录出错!");
    		// }
    		// ...
    		//
    		// 列出所有的文件/子目录
    		// listFile(ftp);
    		//上传一个文件
    		//upload(ftp);
    		// 下载一个文件
    		download(ftp);
    		ftp.logout();
    		ftp.disconnect();
    		System.out.println("Quit.");
    	}
    
    	public static void listFile(FTPClient ftp)
    	{
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("> list");
    		FTPFile[] ftpFiles;
    		try
    		{
    			ftpFiles = ftp.listFiles();
    			for (FTPFile f : ftpFiles)
    			{
    				String time = sdf.format(f.getTimestamp().getTime());
    				String info = "";
    				if (f.isDirectory())
    					info = String.format("+ %-20s", f.getName());
    				else
    					info = String.format("  %-20s %8d   %s", f.getName(), f.getSize(), time);
    
    				System.out.println(info);
    			}
    		} catch (IOException e)
    		{
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    
    	// 上传一个文件
    	public static void upload(FTPClient ftp)
    	{
    		File localFile = new File("E:\\代码\\HBiuder.zip");
    		InputStream inStream;
    		OutputStream outStream;
    		try
    		{
    			String remotePath = ftpPath(localFile.getName());
    			inStream = new FileInputStream(localFile);
    			//
    			// 小文件直接 用
    			// ftp.storeFile(remotePath, inStream);
    			//大文件时用这个方法
    			outStream = ftp.storeFileStream(remotePath);
    			// 大文件,可以自己掌握进度
    			byte[] buffer = new byte[4000];
    			while (true)
    			{
    				int n = inStream.read(buffer);
    				if (n <= 0)
    					break;
    
    				outStream.write(buffer, 0, n);
    			}
    			inStream.close();
    			outStream.close();
    
    		} catch (FileNotFoundException e1)
    		{
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		} catch (IOException e)
    		{
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    	//文件下载
    	public static void download(FTPClient ftp) throws Exception
    	{
    	       File localFile = new File("D:/tmp/copy.zip");
    	        localFile.getParentFile().mkdirs();
    	        
    	        
    	        // 
    	        String remotePath = ftpPath("/HBiuder.zip");
    	        OutputStream outStream = new FileOutputStream(localFile);
    	             
    	        // 小文件直接 用 
    	        // ftp.retrieveFile(remotePath, outStream);
    	        
    	        // 大文件,可以自己掌握进度
    	        InputStream inStream = ftp.retrieveFileStream(remotePath);
    	        if(inStream == null)
    	        	throw new Exception("远程文件不存在!" + remotePath);
    	        
    	        byte[] buffer = new byte[4000];
    	        while(true)
    	        {
    	        	int n =inStream.read(buffer);
    	        	if(n <= 0) break;
    	        	
    	        	outStream.write(buffer,0,n);
    	        }
    	        inStream.close();
    	        outStream.close();
    	}
    
    }
    

     仅供参考,如有不足,多多指教。

    展开全文
  • java连接ftp服务器

    2020-09-11 14:03:27
    使用Java连接Ftp并且实现文件的上传下载 1.使用maven工程的话需要引入Maven的pom <!--连接ftp使用--> <dependency> <groupId>commons-net</groupId> <artifactId>commons-...

    使用Java连接Ftp并且实现文件的上传下载

    1.使用maven工程的话需要引入Maven的pom

            <!--连接ftp使用-->
            <dependency>
                <groupId>commons-net</groupId>
                <artifactId>commons-net</artifactId>
                <version>3.3</version>
            </dependency>
            <!--打印日志使用-->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.7.25</version>
            </dependency>

    2.使用Java代码实现连接

    import org.apache.commons.net.ftp.FTP;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPReply;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.*;
    import java.net.SocketException;
    
    /**
     * @wsh
     * 实现连接FTP服务器,实现文件的上传和下载
     */
    public class FtpUtils {
    
        //打印日志使用
        private static final Logger log = LoggerFactory.getLogger(FtpUtils.class);
    
    
        /**
         * 获取FTPClient对象
         *
         * @param ftpHost
         *            FTP主机服务器
         * @param ftpPassword
         *            FTP 登录密码
         * @param ftpUserName
         *            FTP登录用户名
         * @param ftpPort
         *            FTP端口 默认为21
         * @return
         */
        public static FTPClient getFTPClient(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort) {
            FTPClient ftpClient = null;
            try {
                //创建一个ftp客户端
                ftpClient = new FTPClient();
                // 连接FTP服务器
                ftpClient.connect(ftpHost, ftpPort);
                // 登陆FTP服务器
                ftpClient.login(ftpUserName, ftpPassword);
    
                if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                    log.info("未连接到FTP,用户名或密码错误。");
                    ftpClient.disconnect();
                } else {
                    log.info("FTP连接成功。");
                }
            } catch (SocketException e) {
                e.printStackTrace();
                log.info("FTP的IP地址可能错误,请正确配置。");
            } catch (IOException e) {
                e.printStackTrace();
                log.info("FTP的端口错误,请正确配置。");
            }
            return ftpClient;
        }
    
        /**
         * 下载文件
         *
         * @param ftpHost ftp服务器地址
         * @param ftpUserName anonymous匿名用户登录,不需要密码。administrator指定用户登录
         * @param ftpPassword 指定用户密码
         * @param ftpPort ftp服务员器端口号
         * @param ftpPath  ftp文件存放物理路径
         * @param localPath 本地存储文件的路径
         * @param fileName 文件名称
         */
        public static void downloadFile(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort, String ftpPath, String localPath, String fileName) {
    
            FTPClient ftpClient = null;
    
            try {
                ftpClient = getFTPClient(ftpHost, ftpUserName, ftpPassword, ftpPort);
                ftpClient.setControlEncoding("UTF-8"); // 中文支持
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                ftpClient.enterLocalPassiveMode();
                ftpClient.changeWorkingDirectory(ftpPath);
    
                File localFile = new File(localPath + File.separatorChar + fileName);
                OutputStream os = new FileOutputStream(localFile);
                ftpClient.retrieveFile(fileName, os);
                os.close();
                ftpClient.logout();
    
            } catch (FileNotFoundException e) {
                log.error("没有找到" + ftpPath + "文件");
                e.printStackTrace();
            } catch (SocketException e) {
                log.error("连接FTP失败.");
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
                log.error("文件读取错误。");
                e.printStackTrace();
            }
        }
    
        /**
         * 上传文件
         *
         * @param ftpHost ftp服务器地址
         * @param ftpUserName anonymous匿名用户登录,不需要密码。administrator指定用户登录
         * @param ftpPassword 指定用户密码
         * @param ftpPort ftp服务员器端口号
         * @param ftpPath  ftp文件存放物理路径
         * @param fileName 文件路径
         * @param input 文件输入流,即从本地服务器读取文件的IO输入流
         */
        public static void uploadFile(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort, String ftpPath, String fileName,InputStream input){
            FTPClient ftp=null;
            try {
                ftp=getFTPClient(ftpHost, ftpUserName, ftpPassword, ftpPort);
    
                ftp.makeDirectory(ftpPath);
                ftp.changeWorkingDirectory(ftpPath);
    
                ftp.setFileType(FTP.BINARY_FILE_TYPE);
                fileName=new String(fileName.getBytes("GBK"),"iso-8859-1");
                ftp.storeFile(fileName, input);
                input.close();
                ftp.logout();
                System.out.println("upload succes!");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

     

    展开全文
  • Java 自定义FTP连接

    千次阅读 2018-01-11 21:09:42
    一、引入FTP包和连接池包 dependency> groupId>commons-netgroupId> artifactId>commons-netartifactId> version>3.5version> dependency> dependency> groupId>org.apache.commonsgroupId> artifa

    一、引入FTP包和连接池包

    <!-- ftp连接start -->
    <dependency>
        <groupId>commons-net</groupId>
        <artifactId>commons-net</artifactId>
        <version>3.5</version>
    </dependency>
    <!-- ftp连接start -->
    
    <!-- 自定义连接池 start-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.5.0</version>
    </dependency>
    <!-- 自定义连接池 end-->

    二、在项目根路径新建一个配置文件,把连接池配置属性和FTPClient属性配置在配置文件中,ftpClient.properties配置文件如下

    #FTP连接池配置
    #最大数
    ftpClient_maxTotal=50
    #最小空闲
    ftpClient_minIdle=10
    #最大空闲
    ftpClient_maxIdle=100
    #最大等待时间
    ftpClient_maxWait=3000
    #池对象耗尽之后是否阻塞,maxWait<0时一直等待
    ftpClient_blockWhenExhausted=true
    #取对象是验证
    ftpClient_testOnBorrow=true
    #回收验证
    ftpClient_testOnReturn=true
    #创建时验证
    ftpClient_testOnCreate=true
    #空闲验证
    ftpClient_testWhileIdle=false
    #后进先出
    ftpClient_lifo=false
    
    #FTP连接属性配置
    #ip
    ftpClient_host=192.168.158.98
    #端口
    ftpClient_port=21
    #登录名
    ftpClient_username=ftpadmin
    #密码
    ftpClient_pasword=eakom123456
    #连接是否为主动模式
    ftpClient_passiveMode=true
    #编码
    ftpClient_encoding=UTF-8
    #超时时间
    ftpClient_clientTimeout=600
    #线程数
    ftpClient_threaNum=1
    #文件传送类型
    #0=ASCII_FILE_TYPE(ASCII格式) 1=EBCDIC_FILE_TYPE 2=LOCAL_FILE_TYPE(二进制文件)  
    ftpClient_transferFileType=2
    #是否重命名
    ftpClient_renameUploaded=true
    #重新连接时间
    ftpClient_retryTimes=1200
    #缓存大小
    ftpClient_bufferSize=1024
    #默认进入的路径
    ftpClient_workingDirectory=/home/ftpadmin/

    三、新建一个FTP客户端属性类

    package com.eakom.common.util.ftpPool;
    /**
     * FTP属性相关的配置
     * @author eakom
     * @date 2018年1月11日
     */
    public class FTPConfig{
        private String host;
        private int port;
        private String username;
        private String password;
        private boolean passiveMode;
        private String encoding;
        private int clientTimeout;
        private int threadNum;
        private int transferFileType;
        private boolean renameUploaded;
        private int retryTimes;
        private int bufferSize;
        private String workingDirectory;
    
    
        public String getWorkingDirectory() {
            return workingDirectory;
        }
        public void setWorkingDirectory(String workingDirectory) {
            this.workingDirectory = workingDirectory;
        }
        public int getBufferSize() {
            return bufferSize;
        }
        public void setBufferSize(int bufferSize) {
            this.bufferSize = bufferSize;
        }
        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 getPassiveMode() {
            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 int getThreadNum() {
            return threadNum;
        }
        public void setThreadNum(int threadNum) {
            this.threadNum = threadNum;
        }
        public int getTransferFileType() {
            return transferFileType;
        }
        public void setTransferFileType(int transferFileType) {
            this.transferFileType = transferFileType;
        }
        public boolean isRenameUploaded() {
            return renameUploaded;
        }
        public void setRenameUploaded(boolean renameUploaded) {
            this.renameUploaded = renameUploaded;
        }
        public int getRetryTimes() {
            return retryTimes;
        }
        public void setRetryTimes(int retryTimes) {
            this.retryTimes = retryTimes;
        }
    
    }
    

    类中的属性与配置文件ftpClient.properties中的属性相对应

    四、新建一个FTP客户端工厂类,继承于commons-pool 包中的BasePooledObjectFactory类,并重写create()、 wrap(FTPClient ftpClient)、destroyObject(PooledObject p)和validateObject(PooledObject p)四个方法

    package com.eakom.common.util.ftpPool;
    
    import java.io.IOException;
    
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPReply;
    import org.apache.commons.pool2.BasePooledObjectFactory;
    import org.apache.commons.pool2.PooledObject;
    import org.apache.commons.pool2.impl.DefaultPooledObject;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class FTPClientFactory extends BasePooledObjectFactory<FTPClient> {
        private static Logger logger = LoggerFactory.getLogger(FTPClientFactory.class);
        private FTPConfig ftpConfig;
    
        public FTPClientFactory(FTPConfig ftpConfig) {
            this.ftpConfig = ftpConfig;
        }
        /**
         * 新建对象
         */
        @Override
        public FTPClient create() throws Exception {
            FTPClient ftpClient = new FTPClient();
            ftpClient.setConnectTimeout(ftpConfig.getClientTimeout());
            try {
                ftpClient.connect(ftpConfig.getHost(), ftpConfig.getPort());
                int reply = ftpClient.getReplyCode();
                if (!FTPReply.isPositiveCompletion(reply)) {
                    ftpClient.disconnect();
                    logger.error("FTPServer 拒绝连接");
                    return null;
                }
                boolean result = ftpClient.login(ftpConfig.getUsername(),ftpConfig.getPassword());
                if (!result) {
                    logger.error("ftpClient登陆失败!");
                    throw new Exception("ftpClient登陆失败! userName:"+ ftpConfig.getUsername() + " ; password:"
                            + ftpConfig.getPassword());
                }
                ftpClient.setFileType(ftpConfig.getTransferFileType());
                ftpClient.setBufferSize(ftpConfig.getBufferSize());
                ftpClient.setControlEncoding(ftpConfig.getEncoding());
                if (ftpConfig.getPassiveMode()) {
                    ftpClient.enterLocalPassiveMode();
                }
                ftpClient.changeWorkingDirectory(ftpConfig.getWorkingDirectory());
            } catch (IOException e) {
                logger.error("FTP连接失败:", e);
            }
            return ftpClient;
        }
    
        @Override
        public PooledObject<FTPClient> wrap(FTPClient ftpClient) {
            return new DefaultPooledObject<FTPClient>(ftpClient);
        }
    
        /**
         * 销毁对象
         */
        @Override
        public void destroyObject(PooledObject<FTPClient> p) throws Exception {
            FTPClient ftpClient = p.getObject();
            ftpClient.logout();
            super.destroyObject(p);
        }
    
        /**
         * 验证对象
         */
        @Override
        public boolean validateObject(PooledObject<FTPClient> p) {
            FTPClient ftpClient = p.getObject();
            boolean connect = false;
            try {
                connect = ftpClient.sendNoOp();
                if(connect){                
                    ftpClient.changeWorkingDirectory(ftpConfig.getWorkingDirectory());
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return connect;
        }
    }
    

    五、新建FTP连接池类,连接池中有带有一个构造方法,连接器初始化时,自动新建commons-pool包中的GenericObjectPool类,初始化连接池;

    package com.eakom.common.util.ftpPool;
    
    import java.io.InputStream;
    import java.util.Properties;
    
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.pool2.impl.GenericObjectPool;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    
    
    public class FTPClientPool{
        private GenericObjectPool<FTPClient> ftpClientPool;
        public FTPClientPool(InputStream in){
            Properties pro = new Properties();
            try {
                pro.load(in);
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(-1);
            }
            // 初始化对象池配置
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
            poolConfig.setBlockWhenExhausted(Boolean.parseBoolean(pro.getProperty("ftpClient_blockWhenExhausted")));
            poolConfig.setMaxWaitMillis(Long.parseLong(pro.getProperty("ftpClient_maxWait")));
            poolConfig.setMinIdle(Integer.parseInt(pro.getProperty("ftpClient_minIdle")));
            poolConfig.setMaxIdle(Integer.parseInt(pro.getProperty("ftpClient_maxIdle")));
            poolConfig.setMaxTotal(Integer.parseInt(pro.getProperty("ftpClient_maxTotal")));
            poolConfig.setTestOnBorrow(Boolean.parseBoolean(pro.getProperty("ftpClient_testOnBorrow")));
            poolConfig.setTestOnReturn(Boolean.parseBoolean(pro.getProperty("ftpClient_testOnReturn")));
            poolConfig.setTestOnCreate(Boolean.parseBoolean(pro.getProperty("ftpClient_testOnCreate")));
            poolConfig.setTestWhileIdle(Boolean.parseBoolean(pro.getProperty("ftpClient_testWhileIdle")));
            poolConfig.setLifo(Boolean.parseBoolean(pro.getProperty("ftpClient_lifo")));
    
            FTPConfig ftpConfig=new FTPConfig();
            ftpConfig.setHost(pro.getProperty("ftpClient_host"));
            ftpConfig.setPort(Integer.parseInt(pro.getProperty("ftpClient_port")));
            ftpConfig.setUsername(pro.getProperty("ftpClient_username"));
            ftpConfig.setPassword(pro.getProperty("ftpClient_pasword"));
            ftpConfig.setClientTimeout(Integer.parseInt(pro.getProperty("ftpClient_clientTimeout")));
            ftpConfig.setEncoding(pro.getProperty("ftpClient_encoding"));
            ftpConfig.setWorkingDirectory(pro.getProperty("ftpClient_workingDirectory"));
            ftpConfig.setPassiveMode(Boolean.parseBoolean(pro.getProperty("ftpClient_passiveMode")));
            ftpConfig.setRenameUploaded(Boolean.parseBoolean(pro.getProperty("ftpClient_renameUploaded")));
            ftpConfig.setRetryTimes(Integer.parseInt(pro.getProperty("ftpClient_retryTimes")));
            ftpConfig.setTransferFileType(Integer.parseInt(pro.getProperty("ftpClient_transferFileType")));
            ftpConfig.setBufferSize(Integer.parseInt(pro.getProperty("ftpClient_bufferSize")));
            // 初始化对象池
            ftpClientPool = new GenericObjectPool<FTPClient>(new FTPClientFactory(ftpConfig), poolConfig);
        }
        public FTPClient borrowObject() throws Exception {
        /*  System.out.println("获取前");
            System.out.println("活动"+ftpClientPool.getNumActive());
            System.out.println("等待"+ftpClientPool.getNumWaiters());
            System.out.println("----------");*/
            return ftpClientPool.borrowObject();
        }
        public void returnObject(FTPClient ftpClient) {
    
            /*System.out.println("归还前");
            System.out.println("活动"+ftpClientPool.getNumActive());
            System.out.println("等待"+ftpClientPool.getNumWaiters());
            System.out.println("----------");*/
            ftpClientPool.returnObject(ftpClient);
            System.out.println("归还后");
            System.out.println("活动"+ftpClientPool.getNumActive());
            System.out.println("等待"+ftpClientPool.getNumWaiters());
            System.out.println("----------");
        }
    }
    

    六、测试连接池
    同时启动多个线程,观察连接池内,FTPClient的数量的变化

    package com.eakom.common.util.ftpPool;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Date;
    
    import org.apache.commons.net.ftp.FTPClient;
    
    public class Ftp {
        private static FTPClientPool ftpClientPool;
        static{
    //      ftpClientPool=new FTPClientPool(Thread.currentThread().getContextClassLoader().getResourceAsStream("ftpClient.properties"));
            ftpClientPool=new FTPClientPool(Ftp.class.getClassLoader().getResourceAsStream("ftpClient.properties"));
        }
        public static void main(String[] args) {
            for(int i=0;i<50;i++){
                Thread thread=new Thread(new Runnable() {
                    @Override
                    public void run() {
                        sendFile();
                    }
                });
                thread.start();
                try {
                    thread.sleep(15);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
    
    
        }
        public static void sendFile(){
            long start = System.currentTimeMillis();
            InputStream inputStream = null;
            FTPClient ftpClient = null;
            try {
                ftpClient = ftpClientPool.borrowObject();
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                String path="C:/Users/Administrator/Desktop/44/中文.txt";
                File file = new File(path);
                ftpClient.changeWorkingDirectory("/home/ftpadmin/aa");
                inputStream = new FileInputStream(file);
    
    
                    String fileName =new Date().getSeconds()+new Date().getSeconds()+".txt";
                    boolean flag = ftpClient.storeFile(new String(fileName.getBytes("GBK"), "iso-8859-1") , inputStream);
                    long end = System.currentTimeMillis();
                    System.out.println("**********************************************"+flag);
                    long lo=end-start;
                    System.out.println("耗时:"+lo);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                ftpClientPool.returnObject(ftpClient);          
            }
        }
    }
    

    至此,FTPClient连接创建完成,如果问题,欢迎大家指正,谢谢!

    展开全文
  • 主要为大家详细介绍了java判断ftp目录是否存在的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 我已经使用org.apache.commons.net.ftp.FtpClient来创建一个可靠的FTP类,它应该可以并行下载多个文件,然后重试失败。奇怪的是,我似乎无法让代码识别失败。例如,如果我在传输过程中拉动我的以太网电缆,则代码...
  • Java——通过Java代码连接ftp服务器

    千次阅读 2021-06-04 08:55:53
    import org.apache.commons.net.ftp.FTPReply; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype....
  • java连接ftp工具类

    千次阅读 2019-05-25 14:36:50
    这里使用了org.apache.commons.net.ftp这个类库,仅仅是对这个类库稍微封装了一下方便使用,这里写了一个工具类,大家可以参考一下。 依赖 <dependency> <groupId>commons-net</groupId> <...
  • java远程telnet ftp和ssh连接的方法

    热门讨论 2012-04-01 14:10:10
    java连接telnet java连接ssh java连接FTP
  • Java_ftp连接

    2019-11-02 17:14:20
    //常用的一些方法 makeDirectory(str) //创建目录(str)=mkdir str changeWorkingDirectory(str) //改变工作目录=cd str ftpClient.enterLocalActiveMode(); //主动模式 ftpClient....1 在FTP服务中,涉及...
  • java 连接ftp服务器 从页面进行下载

    千次阅读 多人点赞 2018-06-13 15:13:35
    昨天来的个需求,我们的客户需要下载对账文件的话,需要自己去登录ftp 服务器去进行下载本身是有商户后台,所以想吧这个功能直接添加到商户后台页面上,web进行下载。这是背景。之前没有了解过这个,所以还是在网上...
  • Java-ftp测试类

    2015-10-21 15:41:48
    很实用详细的ftp工具类!让你很容易测试你的ftp服务!
  • java实现连接登录Ftp,下载Ftp指定文件夹下的所有文件,并解压所有压缩文件,同时支持对指定文件夹进行文件压缩
  • 我已经通过Java连接到服务器,但过了一段时间我无法连接.根据WinSCP,我可以连接整个时间.现在问题是服务器是问题的原因还是程序.有我的代码:private FTPClient ftpClient = null;public FtpServerConnector() throws...
  • FTP和SFTP工具类(java)

    2017-12-13 10:17:04
    FTP和SFTP工具类,基于java语言 其中FTP修改默认模式为被动模式 文档还包括了需要引用的maven依赖内容
  • 校验FTP是否能正常连接Java

    千次阅读 2021-02-28 14:04:39
    展开全部先写一个异常类,如果FTP的用户名或者密码不正确e68a8462616964757a686964616f31333337623465就通过这个异常类抛出异常,代码如下:FTPException.javapublicclassFTPExceptionextendsException{...
  • javaftp上传下载文件

    2018-06-04 23:56:52
    javaftp下载和上传文件.和sftp下载上传文件,jar包已经maven化.放入仓库即可使用
  • java 连接FTP 后,调用FTPClient.storeFile()方法时,就停止在那里,什么反应都没有,也不抛出异常,出现假死状态。 原因:ftp server可能每次开启不同的端口来传输数据,但是在linux上或者其他服务器上面,由于安全...
  • Java实现ftp文件传输

    2018-07-30 23:10:31
    Java实现ftp文件传输,包含客户端和服务端,通过socket连接
  • ftp支持主动和被动模式上传下载,sftp支持上传功能
  • ftp连接需要的jar包 <!-- Ftp 所依赖的jar包 begin--> <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</artifactId> ...
  • springboot集成ftp连接池工具,很好的解决了并发大用户上传附件慢的问题

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,941
精华内容 27,976
关键字:

javaftp长连接

java 订阅
友情链接: quartusII-licence.rar