精华内容
下载资源
问答
  • 主要介绍了Java连接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服务器

    千次阅读 2019-03-22 17:56:13
    ftp是基于tcp协议的传输协议,基本模式就是请求应答模式,对于协议的详细信息可以百度,也可以查看这篇博客 ftp协议。 下面就java语言的tcp来实现该协议的获取文件大小,遍历目录,上传文件,下载文件功能,好了...

    ftp是基于tcp协议的传输协议,基本模式就是请求应答模式,对于协议的详细信息可以百度,也可以查看这篇博客 ftp协议

    下面就java语言的tcp来实现该协议的获取文件大小,遍历目录,上传文件,下载文件功能,好了废话不多说上代码。

    package com.telrob.ftp;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    public class DataConnect {
    	private Socket dataSocket=null;
    	private InputStream dataIn=null;
    	private OutputStream dataOut=null;
    	
    	public Socket getDataSocket() {
    		return dataSocket;
    	}
    	public void setDataSocket(Socket dataSocket) {
    		this.dataSocket = dataSocket;
    	}
    	public InputStream getDataIn() {
    		return dataIn;
    	}
    	public void setDataIn(InputStream dataIn) {
    		this.dataIn = dataIn;
    	}
    	
    	
    	
    	public DataConnect(Socket dataSocket, InputStream dataIn, OutputStream dataOut) {
    		super();
    		this.dataSocket = dataSocket;
    		this.dataIn = dataIn;
    		this.dataOut = dataOut;
    	}
    	public OutputStream getDataOut() {
    		return dataOut;
    	}
    	public void setDataOut(OutputStream dataOut) {
    		this.dataOut = dataOut;
    	}
    	public void destoryInput() throws IOException {
    		dataSocket.close();
    		dataIn.close();
    	}
    	
    	
    	public void destoryOutput() throws IOException {
    		dataSocket.close();
    		dataOut.close();
    	}
    }
    

     

     

    package com.telrob.ftp;
    
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.Socket;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * ftp类
     * @author wh
     *
     */
    public class MFtp {
    	private String ip;
    	private String userName;
    	private String password;
    	private int port=21;
    	private String line;
    	
    	//命令端口
    	private Socket cmdSocket=null;
    	
    	private OutputStream cmdOut=null;
    	
    	private BufferedReader cmdBr=null;
    	
    	//数据端口
    	
    	private boolean debug=false;
    	
    	public MFtp(String ip,String userName,String password) {
    		this.ip=ip;
    		this.userName=userName;
    		this.password=password;
    	}
    	
    	public MFtp(String ip,String userName,String password,int port) {
    		this.ip=ip;
    		this.userName=userName;
    		this.password=password;
    		this.port=port;
    	}
    	/**
    	 * 设置debug模式
    	 * @param d
    	 */
    	public void setDebug(boolean d) {
    		this.debug=d;
    	}
    	/**
    	 * 创建连接
    	 * @return
    	 * @throws Exception
    	 */
    	public boolean createConnect() throws Exception {
    		cmdSocket=new Socket(ip,port);
    		cmdOut=cmdSocket.getOutputStream();
    		cmdBr=new BufferedReader(new InputStreamReader(cmdSocket.getInputStream()));
    		line=cmdBr.readLine();
    		line=sendCmd("USER "+userName+"\r\n");
    		line=sendCmd("PASS "+password+"\r\n");
    		if(line.startsWith("230 User logged in")) {
    			return true;
    		}
    		return false;
    	}
    	/**
    	 * 发送命令
    	 * @param cmd
    	 * @return
    	 * @throws Exception 
    	 */
    	public String sendCmd(String cmd) throws Exception {
    		if(cmdSocket!=null) {
    			debugger("cmd:  ["+cmd+"]");
    			cmdOut.write(cmd.getBytes("GBK"));
    			String line=cmdBr.readLine();
    			debugger("response:  ["+line+"]");
    			return line;
    		}else {
    			throw new Exception("创建连接失败!");
    		}
    	}
    	
    	/**
    	 * 获取文件大小
    	 * @param name
    	 * @return
    	 */
    	public long getFileSize(String path) {
    		try {
    			line=sendCmd("SIZE "+path+"\r\n");
    			if(line!=null&&!line.equals("")) {
    				String[]sz=line.split(" ");
    				return Long.parseLong(sz[1]);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return 0;
    	}
    	
    	public boolean uploadFile(String path,FileInputStream in) throws Exception {
    		DataConnect dc=getDataStream(2);
    		
    		try {
    			String line=sendCmd("STOR "+path+"\r\n");
    			if(line.startsWith("125")) {
    				OutputStream out=dc.getDataOut();
    				int len=0;
    				byte[]bb=new byte[1024*4];
    				while((len=in.read(bb))>0) {
    					out.write(bb,0,len);
    				}
    				return true;
    			}else {
    				return false;
    			}
    		}catch(Exception e) {
    			e.printStackTrace();
    		}finally {
    			dc.destoryOutput();
    		}
    		return false;
    	}
    	/***
    	 * 下载文件
    	 * @param path 文件路径
    	 * @param fileout 文件输出流
    	 * @return
    	 * @throws Exception 
    	 */
    	public boolean downLoadFile(String path,OutputStream fileout) throws Exception {
    		DataConnect dc=getDataStream(1);
    		InputStream in=dc.getDataIn();
    		try {
    			String line=sendCmd("RETR "+path+"\r\n");
    			if(line.startsWith("150")||line.startsWith("125")) {
    				int len=0;
    				byte[]bb=new byte[1024*4];
    				while((len=in.read(bb))>0) {
    					fileout.write(bb,0,len);
    				}
    			}
    			line = cmdBr.readLine();
    			if(line.contains("Transfer complete")) {
    				return true;
    			}else {
    				return false;
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}finally {
    			dc.destoryInput();
    		}
    		return false;
    	}
    	/**
    	 * 列出目录对应的文件或者文件夹
    	 * @param path
    	 * @return
    	 * @throws Exception 
    	 */
    	public List<MFtpFile> listFile(String path) throws Exception{
    		List<MFtpFile>fileList=new ArrayList<MFtpFile>();
    		DataConnect dc=getDataStream(1);
    		InputStream in=dc.getDataIn();
    		sendCmd("LIST "+path+"\r\n");
    		StringBuffer buffer=new StringBuffer();
    		int len;
    		byte[]bb=new byte[1024];
    		while((len=in.read(bb))>0) {
    			buffer.append(new String(bb,0,len,"GBK"));
    		}
    		String line=cmdBr.readLine();
    		
    		String relult=buffer.toString();
    		String[]item=relult.split("\r\n");
    		for(String d:item) {
    			if(d.equals("")) {
    				continue;
    			}
    			fileList.add(new MFtpFile(d,path));
    		}
    		dc.destoryInput();
    		return fileList;
    	}
    	/***
    	 * 获取数据流
    	 * @param type 1输入流 2,输出流
    	 * @return
    	 * @throws Exception
    	 */
    	private  DataConnect getDataStream(int type) throws Exception {
    		line=sendCmd("PASV\r\n");
    		String[]ll=line.split(",");
    		String[]pp=ll[5].split("\\)");
    		int port=Integer.parseInt(pp[0]);
    		int tp=port;
    		int basep=Integer.parseInt(ll[4]);
    		//返回的第一个数字*256+第二个数字
    		port=basep*256+port;
    		Socket dataSocket=new Socket(ip, port);
    		if(type==1) {
    			InputStream dataIn=dataSocket.getInputStream();
    			
    			return new DataConnect(dataSocket,dataIn,null);
    		}else {
    			OutputStream out=dataSocket.getOutputStream();
    			return new DataConnect(dataSocket,null,out);
    		}
    		
    	}
    	/**
    	 * 调试
    	 * @param str
    	 */
    	private void debugger(String str) {
    		if(debug) {
    			str=str.replaceAll("\r\n", "");
    			System.out.println(str);
    		}
    	}
    }
    

     

    package com.telrob.ftp;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    import java.util.Locale;
    
    /**
     * 封装ftp文件对象
     * @author wh
     *
     */
    public class MFtpFile {
    	//是否为目录
    	private boolean isDirectory=false;
    	//目录名称
    	private String fileName;
    	
    	private String absoluteName;
    	//文件大小
    	private long size;
    	//最后一次修改时间
    	private Date time;
    	
    	public MFtpFile() {}
    	
    	public MFtpFile(String line,String base) {
    		//需要对协议中的一行进行解析 格式如下 
    		// 12-01-17  02:47PM       <DIR>          code
    		// 03-08-18  05:40PM             85660682 Dev-Cpp.zip
    		List<String>list=parse(line);
    		if(list!=null&&list.size()==4) {
    			SimpleDateFormat fmt=new SimpleDateFormat("MM-dd-yy hh:mma",Locale.US);
    			try {
    				String tm=list.get(0)+" "+list.get(1);
    				time=fmt.parse(list.get(0)+" "+list.get(1));
    				if(list.get(2).contains("DIR")) {
    					isDirectory=true;
    					size=0;
    				}else {
    					isDirectory=false;
    					size=Long.parseLong(list.get(2));
    				}
    				fileName=list.get(3);
    				absoluteName=base+"/"+list.get(3);
    			} catch (ParseException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	public boolean isDirectory() {
    		return isDirectory;
    	}
    	public void setDirectory(boolean isDirectory) {
    		this.isDirectory = isDirectory;
    	}
    	public String getFileName() {
    		return fileName;
    	}
    	public void setFileName(String fileName) {
    		this.fileName = fileName;
    	}
    	public long getSize() {
    		return size;
    	}
    	public void setSize(long size) {
    		this.size = size;
    	}
    	public Date getTime() {
    		return time;
    	}
    	public void setTime(Date time) {
    		this.time = time;
    	}
    	
    	
    	public String getAbsoluteName() {
    		return absoluteName;
    	}
    
    	public void setAbsoluteName(String absoluteName) {
    		this.absoluteName = absoluteName;
    	}
    
    	private List<String>parse(String ss){
    		List<String>list=new ArrayList<String>();
    		//03-08-18  05:40PM             85660682 Dev-Cpp.zip
    		String[]items=ss.split(" ");
    		int i=0;
    		for(String s:items) {
    			
    			if(!s.equals("")) {
    				list.add(s);
    				i++;
    			}
    			if(i==3) {
    				break;
    			}
    		}
    		
    		String item2=list.get(2);
    		int last=ss.indexOf(item2)+item2.length();
    		String names=ss.substring(last, ss.length());
    		list.add(names.trim());
    		return list;
    	}
    }
    

    下面试测试类

    package com.telrob.ftp;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.util.List;
    
    public class Test2 {
    	public static void main(String[] args) throws Exception {
    		
    		MFtp ftp=new MFtp("192.168.9.111", "zhang", "123456");
    		
    		String line="";
    		ftp.setDebug(true);
    		if(ftp.createConnect()) {
    			long size=ftp.getFileSize("apache-activemq-5.15.0-bin.zip");
    			FileOutputStream fout=new FileOutputStream("test.zip");
    			ftp.downLoadFile("apache-activemq-5.15.0-bin.zip", fout);
    			//ftp.uploadFile("dd.jpeg",new  FileInputStream("dd.jpeg"));
    			fout.close();
    			list(ftp,"");
    		}
    	}
    	
    	static int total=0;
    	public static void list(MFtp ftp,String path) throws Exception {
    		List<MFtpFile> list=ftp.listFile(path);
    		if(list!=null&&list.size()>0) {
    			for(MFtpFile mf:list) {
    				//System.out.println("total:"+total++);
    				if(mf.isDirectory()) {
    					list(ftp,mf.getAbsoluteName());
    					System.out.println("@@dir:"+mf.getAbsoluteName());
    				}else {
    					System.out.println("##file:"+mf.getAbsoluteName());
    				}
    			}
    		}
    	}
    }
    

     

    展开全文
  • java 连接ftp服务器 从页面进行下载

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

    昨天来的个需求,我们的客户需要下载对账文件的话,需要自己去登录ftp 服务器去进行下载

    本身是有商户后台,所以想吧这个功能直接添加到商户后台页面上,web进行下载。这是背景。

    之前没有了解过这个,所以还是在网上查找了一番 ,找到了这篇博客

     参考:   https://blog.csdn.net/rodge_rom/article/details/78888541

    我看了一下这个里面的方法,有个返回流的,我就看到希望了,所以,进行了一番修改

    在这导入工具类之前,我们需要导入个jar包

            commons-net-3.6.jar  

    我会附上链接,不需要兄弟们找了 http://mvnrepository.com/artifact/commons-net/commons-net/3.6

    看自己用的什么框架,引入方法我就不说了,需要下载的话,点击红框的jar就可以了


    下面是修改完后的工具类

    工具类里只需要修改 两 处地方

    ftp_address=“你自己ftp服务器地址”

    ftp_port=“ftp服务器的端口”

    其他都不用动

    介绍在下面(工具类很长)所以使劲往下拉

    package com.ecard.products.utils;
    
    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.util.HashMap;
    import java.util.Map;
    /**
     * FTP服务工具类 
     *  
     * @author:  DangYangFei
     * @time:    2018年6月12日 14:36:37
     * @version: V1.0.0 
     */  
    public class FTPUtil {
    
        /** 日志对象 **/
        private static final Logger LOGGER = LoggerFactory.getLogger(FTPUtil.class);
    
        /** FTP地址 **/
        private  String FTP_ADDRESS = "";
    
        /** FTP端口 **/
        private  int FTP_PORT = 0;
    
        /** FTP用户名 **/
        private  String FTP_USERNAME = "";
    
        /** FTP密码 **/
        private  String FTP_PASSWORD = "";
    
        /** FTP基础目录 **/
        private  String BASE_PATH = "";
        /** 初始化登录ftp 默认false 登录成功返回true **/
        private  Boolean b=false;
    
        public Boolean getB() {
            return b;
        }
    
        /**
         *  2018-6-13 12:39:55
         *   新添,初始化登录ftp,连接失败 返回b 为:false ,成功 为 :true
         * @param FTP_USERNAME
         * @param FTP_PASSWORD
         * @param BASE_PATH
         */
        public FTPUtil(String FTP_ADDRESS, int FTP_PORT, String FTP_USERNAME, String FTP_PASSWORD, String BASE_PATH) {
            this.FTP_ADDRESS = FTP_ADDRESS;
            this.FTP_PORT = FTP_PORT;
            this.FTP_USERNAME = FTP_USERNAME;
            this.FTP_PASSWORD = FTP_PASSWORD;
            this.BASE_PATH = BASE_PATH;
            b = login(FTP_ADDRESS, FTP_PORT, this.FTP_USERNAME, this.FTP_PASSWORD);
        }
    
        /** 本地字符编码  **/
        private static String localCharset = "GBK";
    
        /** FTP协议里面,规定文件名编码为iso-8859-1 **/
        private static String serverCharset = "ISO-8859-1";
    
        /** UTF-8字符编码 **/
        private static final String CHARSET_UTF8 = "UTF-8";
    
        /** OPTS UTF8字符串常量 **/
        private static final String OPTS_UTF8 = "OPTS UTF8";
    
        /** 设置缓冲区大小4M **/
        private static final int BUFFER_SIZE = 1024 * 1024 * 4;
    
        /** FTPClient对象 **/
        private static FTPClient ftpClient = null;
    
        /**
         * 下载指定文件到本地
         *
         * @param ftpPath FTP服务器文件相对路径,例如:test/123
         * @param fileName 要下载的文件名,例如:test.txt
         * @param savePath 保存文件到本地的路径,例如:D:/test
         * @return 成功返回true,否则返回false
         */
        public boolean downloadFile(String ftpPath, String fileName, String savePath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return flag;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return flag;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            File file = new File(savePath + '/' + ftpName);
                            try {
                                OutputStream os = new FileOutputStream(file);
                                flag = ftpClient.retrieveFile(ff, os);
                            } catch (Exception e) {
                                System.out.println(e.getMessage());
                                LOGGER.error(e.getMessage(), e);
                            }
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("下载文件失败"+e);
                    LOGGER.error("下载文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭:"+close);
                }
            }
            return flag;
        }
    
        /**
         * 下载该目录下所有文件到本地
         *
         * @param ftpPath FTP服务器上的相对路径,例如:test/123
         * @param savePath 保存文件到本地的路径,例如:D:/test
         * @return 成功返回true,否则返回false
         */
        public boolean downloadFiles(String ftpPath, String savePath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return flag;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return flag;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        File file = new File(savePath + '/' + ftpName);
                        try  {
                            OutputStream os = new FileOutputStream(file);
                            ftpClient.retrieveFile(ff, os);
                        } catch (Exception e) {
                            System.out.println(e.getMessage()+e);
                            LOGGER.error(e.getMessage(), e);
                        }
                    }
                    flag = true;
                } catch (IOException e) {
                    System.out.println("下载文件失败"+e);
                    LOGGER.error("下载文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭:"+close);
                }
            }
            return flag;
        }
    
        /**
         * 获取该目录下所有文件,以字节数组返回
         *
         * @param ftpPath FTP服务器上文件所在相对路径,例如:test/123
         * @return Map<String, Object> 其中key为文件名,value为字节数组对象
         */
        public Map<String, byte[]> getFileBytes(String ftpPath) {
            // 登录
            Map<String, byte[]> map = new HashMap<String, byte[]>();
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return map;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return map;
                    }
                    for (String ff : fs) {
                        try  {
                            InputStream is = ftpClient.retrieveFileStream(ff);
                            String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
                            byte[] buffer = new byte[BUFFER_SIZE];
                            int readLength = 0;
                            while ((readLength = is.read(buffer, 0, BUFFER_SIZE)) > 0) {
                                byteStream.write(buffer, 0, readLength);
                            }
                            map.put(ftpName, byteStream.toByteArray());
                            ftpClient.completePendingCommand(); // 处理多个文件
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                            LOGGER.error(e.getMessage(), e);
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭:"+close);
                }
            }
            return map;
        }
    
        /**
         * 根据名称获取文件,以字节数组返回
         *
         * @param ftpPath FTP服务器文件相对路径,例如:test/123
         * @param fileName 文件名,例如:test.xls
         * @return byte[] 字节数组对象
         */
        public byte[] getFileBytesByName(String ftpPath, String fileName) {
            // 登录
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return byteStream.toByteArray();
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return byteStream.toByteArray();
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            try {
                                InputStream is = ftpClient.retrieveFileStream(ff);
                                byte[] buffer = new byte[BUFFER_SIZE];
                                int len = -1;
                                while ((len = is.read(buffer, 0, BUFFER_SIZE)) != -1) {
                                    byteStream.write(buffer, 0, len);
                                }
                            } catch (Exception e) {
                                System.out.println(e.getMessage()+e);
                                LOGGER.error(e.getMessage(), e);
                            }
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭:"+close);
                }
            }
            return byteStream.toByteArray();
        }
    
        /**
         * 获取该目录下所有文件,以输入流返回
         *
         * @param ftpPath FTP服务器上文件相对路径,例如:test/123
         * @return Map<String, InputStream> 其中key为文件名,value为输入流对象
         */
        public Map<String, InputStream> getFileInputStream(String ftpPath) {
            // 登录
            Map<String, InputStream> map = new HashMap<String, InputStream>();
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return map;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return map;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        InputStream is = ftpClient.retrieveFileStream(ff);
                        map.put(ftpName, is);
                        ftpClient.completePendingCommand(); // 处理多个文件
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭:"+close);
                }
            }
            return map;
        }
    
        /**
         * 根据名称获取文件,以输入流返回
         *
         * @param ftpPath FTP服务器上文件相对路径,例如:test/123
         * @param fileName 文件名,例如:test.txt
         * @return InputStream 输入流对象
         */
        public InputStream getInputStreamByName(String ftpPath, String fileName) {
            // 登录
            InputStream input = null;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录不存在");
                        return input;
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + ftpPath + "该目录下没有文件");
                        return input;
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            input = ftpClient.retrieveFileStream(ff);
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }finally {
                    Boolean connect = closeConnect();
                    System.out.println("连接关闭状态:" + connect);
                }
            }
            return input;
        }
    
        /**
         * 根据文件夹,文件 名称,判断是否存在
         *
         * @param ftpPath FTP服务器上文件相对路径,例如:test/123
         * @param fileName 文件名,例如:test.txt
         * @return map
         */
        public Map checkoutFtpPathAndFileName(String ftpPath, String fileName) {
            // 登录
            Map<String,Boolean> map = new HashMap<String, Boolean>();
            map.put("filePath",false);
            map.put("fileName",false);
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + ftpPath);
                    // 判断是否存在该目录
                    if (!ftpClient.changeWorkingDirectory(path)) {
                        System.out.println(BASE_PATH + ftpPath + "该目录不存在");
                         map.put("filePath",false);
                    }else {
                        map.put("filePath",true);
                    }
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String[] fs = ftpClient.listNames();
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + ftpPath + "该目录下没有文件");
                        map.put("fileName",false);
                    }
                    for (String ff : fs) {
                        String ftpName = new String(ff.getBytes(serverCharset), localCharset);
                        if (ftpName.equals(fileName)) {
                            map.put("fileName",true);
                        }
                    }
                } catch (IOException e) {
                    System.out.println("获取文件失败"+e);
                    LOGGER.error("获取文件失败", e);
                }
            }
            return map;
        }
        /**
         * 删除指定文件
         *
         * @param filePath 文件相对路径,例如:test/123/test.txt
         * @return 成功返回true,否则返回false
         */
        public boolean deleteFile(String filePath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    String path = changeEncoding(BASE_PATH + filePath);
                    flag = ftpClient.deleteFile(path);
                } catch (IOException e) {
                    System.out.println("删除文件失败"+e);
                    LOGGER.error("删除文件失败", e);
                } finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭:"+close);
                }
            }
            return flag;
        }
    
        /**
         * 删除目录下所有文件
         *
         * @param dirPath 文件相对路径,例如:test/123
         * @return 成功返回true,否则返回false
         */
        public boolean deleteFiles(String dirPath) {
            // 登录
            boolean flag = false;
            if (ftpClient != null) {
                try {
                    ftpClient.enterLocalPassiveMode();  // 设置被动模式,开通一个端口来传输数据
                    String path = changeEncoding(BASE_PATH + dirPath);
                    String[] fs = ftpClient.listNames(path);
                    // 判断该目录下是否有文件
                    if (fs == null || fs.length == 0) {
                        System.out.println(BASE_PATH + dirPath + "该目录下没有文件");
                        LOGGER.error(BASE_PATH + dirPath + "该目录下没有文件");
                        return flag;
                    }
                    for (String ftpFile : fs) {
                        ftpClient.deleteFile(ftpFile);
                    }
                    flag = true;
                } catch (IOException e) {
                    System.out.println("删除文件失败"+e);
                    LOGGER.error("删除文件失败", e);
                }finally {
                    Boolean close = closeConnect();
                    System.out.println("连接是否关闭:"+close);
                }
            }
            return flag;
        }
    
        /**
         * 连接FTP服务器
         *
         * @param address  地址,如:127.0.0.1
         * @param port     端口,如:21
         * @param username 用户名,如:root
         * @param password 密码,如:root
         */
        private Boolean login(String address, int port, String username, String password) {
            ftpClient = new FTPClient();
            try {
                ftpClient.connect(address, port);
                ftpClient.login(username, password);
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                int reply = ftpClient.getReplyCode();
                if (!FTPReply.isPositiveCompletion(reply)) {
                    closeConnect();
                    System.out.println("FTP服务器连接失败:"+"地址:"+address+"  端口:"+port+"  用户名:"+username+"  密码:"+password);
                    LOGGER.error("FTP服务器连接失败");
                }else {
                    b=true;
                }
            } catch (Exception e) {
                System.out.println("FTP登录失败"+e);
                LOGGER.error("FTP登录失败", e);
            }
            return b;
        }
    
        /**
         * 关闭FTP连接
         *
         */
        public Boolean closeConnect() {
            Boolean b=false;
            if (ftpClient != null && ftpClient.isConnected()) {
                try {
                    ftpClient.logout();
                    b=true;
                } catch (IOException e) {
                    System.out.println("关闭FTP连接失败"+e);
                    LOGGER.error("关闭FTP连接失败", e);
                }
            }
            return b;
        }
    
        /**
         * FTP服务器路径编码转换
         *
         * @param ftpPath FTP服务器路径
         * @return String
         */
        private static String changeEncoding(String ftpPath) {
            String directory = null;
            try {
                if (FTPReply.isPositiveCompletion(ftpClient.sendCommand(OPTS_UTF8, "ON"))) {
                    localCharset = CHARSET_UTF8;
                }
                directory = new String(ftpPath.getBytes(localCharset), serverCharset);
            } catch (Exception e) {
                System.out.println("路径编码转换失败"+e);
                LOGGER.error("路径编码转换失败", e);
            }
            return directory;
        }
    
        /**
         * 在服务器上递归创建目录
         *
         * @param dirPath 上传目录路径
         * @return
         */
        private void createDirectorys(String dirPath) {
            try {
                if (!dirPath.endsWith("/")) {
                    dirPath += "/";
                }
                String directory = dirPath.substring(0, dirPath.lastIndexOf("/") + 1);
                ftpClient.makeDirectory("/");
                int start = 0;
                int end = 0;
                if (directory.startsWith("/")) {
                    start = 1;
                }else{
                    start = 0;
                }
                end = directory.indexOf("/", start);
                while(true) {
                    String subDirectory = new String(dirPath.substring(start, end));
                    if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                        if (ftpClient.makeDirectory(subDirectory)) {
                            ftpClient.changeWorkingDirectory(subDirectory);
                        } else {
                            System.out.println("创建目录失败");
                            LOGGER.info("创建目录失败");
                            return;
                        }
                    }
                    start = end + 1;
                    end = directory.indexOf("/", start);
                    //检查所有目录是否创建完毕
                    if (end <= start) {
                        break;
                    }
                }
            } catch (Exception e) {
                System.out.println("上传目录创建失败"+e);
                LOGGER.error("上传目录创建失败", e);
            }
        }
    }

    这里有很多方法,但是现在我的这个需要返回流的形式,所以只用的这个

    开始介绍用法

        利用有参构造 进行初始化登录ftp  如果登录成功了会返回true 否则返回false

         有参构造最后面的ftp_base_path 这个参数说一下
         这个参数传的是你当前账号登录以后所能看到的当前路径,也就是说直接给他个空串就可以了

        链接成功以后呢,b 返回的就是true ,我们就可以继续往下进行操作了

            String ftpUserName = "";
            String ftpPassword = "";
            String ftpPath = "/"+"文件夹名"+"/";
            String fileName = "文件名";
            FTPUtil ftpUtil = new FTPUtil(ftpUserName, ftpPassword, "");
            Boolean b = ftpUtil.getB();

            校验一下文件夹和文件是否存在, 这个是我自己改了一下,你们可以自己去工具类里进行修改成自己想要的字段

            这里的返回也是,两个参数 ,false 代表不存在,true代表存在

            添加这个方法是因为实际业务需要进行判断返回前端进行提示,所以故此添加

           Map map = ftpUtil.checkoutFtpPathAndFileName(ftpPath, fileName)
            Boolean filePahtBoolean = map.get("filePath")
            Boolean fileNameBoolean = map.get("fileName")

            这个方法需要手动自己关闭连接,所以 ftpUtil.closeConnect(),成功返回true, 失败返回false

            上面的都齐全了,下面我们开始页面进行下载了

            这个方法只需要把文件所在的    路径  和  文件名   传进去就可以了,返回的是一个InputStream

    InputStream inputStream = ftpUtil.getInputStreamByName(ftpPath, fileName)

            页面进行下载弹出框

            这个就不多介绍了, 弹出框文件的名称  修改成功自己的命名规则就可以了

    /**
     *
     * @param fileName  文件名称
     * @param inputStream 读取文件返回流
     * @param response
     */
        public static void downloadFtpFile(String fileName,InputStream inputStream ,HttpServletResponse response) {
            try {
                BufferedInputStream br = new BufferedInputStream(inputStream);
                byte[] buf = new byte[1024];
                int len = 0;
                response.reset();
                response.setContentType("application/x-msdownload");
                response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
                OutputStream out = response.getOutputStream();
                while ((len = br.read(buf)) > 0) out.write(buf, 0, len);
                br.close();
                out.close();
            } catch (IOException e) {
                System.out.println("文件读取错误。");
            }
        }
    


    展开全文
  • java ftp 服务器

    2018-02-23 10:44:17
    一个简单的demo,适合初学者,java语言使用第三方API,进程FTP上传下载的demo
  • java实现连接FTP服务器,实现文件的上传和下载 最近项目需要使用FTP服务器,来进行文件的上传和下载!本文主要介绍连接FTP服务器,进行文件的上传和下载,至于如何搭建FTP服务器,网上有很多教程,大家可以自行百度...

    java实现连接FTP服务器,实现文件的上传和下载

    最近项目需要使用FTP服务器,来进行文件的上传和下载!本文主要介绍连接FTP服务器,进行文件的上传和下载,至于如何搭建FTP服务器,网上有很多教程,大家可以自行百度!!!

    废话不多说,直接上代码:
    下面是实现FTP的连接、文件上传以及文件的下载代码:

    package com.soyuan.wxdemo.utils;
    import java.io.File;
    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 lombok.extern.slf4j.Slf4j;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.apache.commons.net.ftp.FTP;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPReply;

    @Slf4j
    public class FtpUtil {

        /**
         * 获取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 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();
        }
    }
    

    }

    下面是我自己写的测试代码:为了方便和可配置,我将FTP的配置添加到了配置文件中:
    配置文件代码:

    ftp:
      #  FTP的IP地址
      ftpHost: "172.26.100.150"
      #  FTP的端口 默认是21
      ftpPort: 21
      #  FTP登陆的用户名
      ftpUserName: "Lenovo"
      #  FTP登陆密码
      ftpPassword: "Password1103"
      #  FTP服务器上指定目录
      ftpPath: "/face"
      #  FTP服务器文件路径
      filePath: "/face"
      #  FTP服务器上文件名
      fileName: ""
      #  FTP上传文件夹位置
      uploadFile: "E:/upload"
      #  FTP上传文件名称
      uploadFileName: "5.jpg"
      #  FTP下载指定文件夹
      downloadFile: "E:/download"
      #  FTP下载 指定文件名
      downloadFileName: "5.jpg"
    

    自定义的FTP配置类:

    @Data
    @Component
    @ConfigurationProperties(prefix = "ftp")
    public class FTPBean {
    
        private String ftpHost;
    
        private Integer ftpPort;
    
        private String ftpUserName;
    
        private String ftpPassword;
    
        private String ftpPath;
    
        private String filePath;
    
        private String fileName;
    
        private String uploadFile;
    
        private String uploadFileName;
    
        private String downloadFile;
    
        private String downloadFileName;
    
    
    }
    

    测试代码:

    package com.soyuan.wxdemo;
    
    import com.soyuan.wxdemo.utils.FTPBean;
    import com.soyuan.wxdemo.utils.FtpUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    @Slf4j
    public class FtpTest {
    
    
        @Autowired
        private FTPBean ftpBean;
        
        @Test
        public void test() throws FileNotFoundException {
    
            FtpUtil.downloadFile(ftpBean.getFtpHost(), ftpBean.getFtpUserName(), ftpBean.getFtpPassword(), ftpBean.getFtpPort(),
                    ftpBean.getFtpPath(), ftpBean.getDownloadFile(), ftpBean.getDownloadFileName());
    
            String filePath=ftpBean.getUploadFile();
            String fileName= ftpBean.getUploadFileName();
    
            log.info(filePath+File.separatorChar+fileName);
    
            FileInputStream input = new FileInputStream(new File(filePath+File.separatorChar+fileName));
            FtpUtil.uploadFile(ftpBean.getFtpHost(), ftpBean.getFtpUserName(), ftpBean.getFtpPassword(), ftpBean.getFtpPort(), ftpBean.getFtpPath(), fileName, input);
    
        }
    }
    
    问题总结:
    		在连接FTP服务器时,要保证自己的网段和FTP服务器的网段处于同一网段;
    		定义配置文件时,要保证自定义的配置类可以被spring扫描的到,否则无法实现自动注入。
    
    
    展开全文
  • Java连接FTP服务器并且实现对其文件的上传和下载

    万次阅读 多人点赞 2015-11-12 17:46:26
    概述  FTP是File Transfer Protocol(文件传输协议)的英文简称,而中文简称为“文传协议”。FTP作为网络共享文件的传输协议,在网络应用软件...本文就主要针对这两个操作来进行说明(当然,也包括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文件服务器

    千次阅读 2018-03-07 20:51:37
    Ftp是一种常见的文件存储服务器,在很多的项目中都有使用,方便存储各种格式的文件,使用java连接ftp文件服务器也是常用的工具类。 下面是使用连接ftp文件服务器的步骤: 下载jar包 使用的是maven来管理jar...
  • --ftp--> <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</artifactId> <version>3.6</version> </dependency> ...
  • JAVA操作FTP文件服务器上传与下载文件,包含远程动态创建文件夹、查看文件是否存在、删除文件、上传文件和下载文件等方法
  • 连接FTP服务器问题1. IE 浏览器访问FTP , a) 地址栏输入ftp地址。输入用户名:密码: 2. 谷歌浏览器可以正常访问,没有资源管理器视图3. Windows 资源管理器访问(其实就是ie访问)4. Java 使用org.apache....
  • JAVA读取FTP服务器文件内容

    千次阅读 2019-03-12 16:59:41
    import org.apache.commons.net.ftp.FTPClient; import org.apache.commons.net.ftp.FTPFile; import org.apache.commons.net.ftp.FTPReply; import java.io.*; import java.net.SocketException; public class F....
  • 实现从FTP服务器下载PDF,标有注释。
  • java+jsp代码实现从FTP服务器上传下载文件。 里面给了java方法和jsp页面的代码。主要是实现从FTP服务器上面下载文件到自己本地文件夹下面。另外还给了几个网站供大家参考。
  • java读取远程ftp服务器文件公司要做一个农行银企通平台的接口,因为农行银企通平台不稳定,需要经常调试重启计算机,所以安装在单独的PC上,服务器上的应用需要读取农行银企通平台下载的文件。所以在PC上安装了ftp...
  • 一、讲解Java中实现ftp,需要依赖commons-net-3.3.jar包,首先下载该jar包,这东西,都...1.ftp上传下载工具类import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import j
  • 这句话就是导致上传下载失败的原因,网上翻了翻,应该是和ftp服务器的防火墙等设置有关,前几天用的时候,程序中用ftp.enterLocalPassiveMode();还是正常的,今天就突然不行了,应该是公司的服务器相关设置被改了。...
  • JAVA 搭建FTP服务器

    千次阅读 2018-09-13 17:39:13
    FTP服务器就是一种支持FTP协议并用来作文件的中转服务器,WEB服务器也可同事作为FTP服务器。 目前在做C/S的系统,自然就涉及到了远程更新的方面,这也是C/S在系统维护方面的劣势。 然后我就想到了用FTP服务器来做...
  • Java写文件到ftp服务器

    千次阅读 2018-02-07 17:37:30
    // 如果采用默认端口,可以使用ftp.connect(host)的方式直接连接FTP服务器 ftp.login(username, password);// 登录 reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { ftp....
  • 所在的项目,是需要采集模块,向客户提供的ftp服务器采集所需数据,另外,由于之前已经在其他地方跑通,所以代码是现成的 问题 1. 系统的ftp程序无法连接远程的服务器 【问题重现】:530 Non-anonymous sessions ...
  • @Service示例,用于使用Spring Boot从FTP服务器连接,上传和下载文件。 该项目实现了@Service Spring Boot,该服务启用并提供了一个简单的API,以便其他开发人员可以重用它来连接到实现FTP协议的服务器。 它提供了...
  • Java FTP 实现跨服务器文件上传下载

    热门讨论 2013-11-19 13:44:01
    Java 程序实现的 FTP服务器文件上传下载功能。
  • NULL 博文链接:https://j2ee2009.iteye.com/blog/665917
  • java实现FTP和 SFTP连接远程服务器下载文件 文章目录java实现FTP和 SFTP连接远程服务器下载文件前言一、FTP是什么?如何实现。1.实现代码二、SFTP是什么?如何实现。1.代码实现总结 前言 为什魔写这片文章呢,因为...
  • javaftp服务器上传下载文件

    千次阅读 2016-12-29 09:55:15
    Java连接FTP服务器并且实现对其文件的上传和下载 标签: <a href="http://w
  • JavaFTP服务器中获取PDF文件数据

    千次阅读 2019-06-12 15:17:23
    Java 直接读取本地磁盘的PDF文件很容易,但是要从FTP中获取文件数据缺需要使用工具来连接FTP服务器,之后才能从中获取到相应的文件数据 操作系统类型:windows 开发工具: idea 项目管理:maven 需要的jar包 ...
  • Java代码在本机上传文件到FTP服务器的时候成功,但是部署到测试服务器的时候出现,连接FTP成功但是上传失败,并且报Connected time out错误; 测试服务器和FTP服务都在阿里云上;(使用内网外网连接都有错) 原因...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,062
精华内容 21,624
关键字:

java连接ftp服务器

java 订阅