精华内容
下载资源
问答
  • java上传文件到ftp
    2019-09-23 11:41:52

    依赖的包

    commons-net 包

    <dependency>
        <groupId>commons-net</groupId>
        <artifactId>commons-net</artifactId>
    </dependency>
    

    使用方法

        /**
         * @param hostname    ftp 服务器ip
         * @param port        ftp服务器端口号
         * @param username    用户名
         * @param password    密码
         * @param basePath    ftp服务器根路径
         * @param inputStream 文件输入流
         * @param remote      ftp远程服务器文件名
         * @return 是否上传成功
         * @throws IOException
         */
        public static boolean uploadFile(String hostname, int port, String username, String password, String basePath, FileInputStream inputStream, String remote) throws IOException {
            //1、创建一个FtpClient对象
            FTPClient ftpClient = new FTPClient();
    
            //2、创建FTP连接
            ftpClient.connect(hostname, port);
    
            //3、登录FTP 服务器,使用用户名密码
            ftpClient.login(username, password);
    
            //4、上传文件
            // FTPClient默认是 字符串,会将二进制转为 utf-8字符串。
            // 上传二进制文件
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            //切换路径,这样可以将文件上传到此路径,否则会上传到根路径
            ftpClient.changeWorkingDirectory(basePath);
            boolean re = ftpClient.storeFile(remote, inputStream);
    
            //5、关闭连接
            ftpClient.logout();
    
            return re;
        }
    
    • 测试代码

       @Test
          public void testFTPClient() throws IOException {
      
      
              String hostname = "192.168.43.106";
              int port = 21;
              String username = "ftpuser";
              String password = "123456";
              String basePath = "/home/ftpuser/www/img";
              File imageFile = new File("/Users/liujian/Desktop/timg.jpg");
              FileInputStream inputStream = new FileInputStream(imageFile);
              String remote = "mv.jpg";
      
              boolean f = FTPClientUtils.uploadFile(hostname, port, username, password, basePath, inputStream, remote);
              if (f) {
                  System.out.println("上传成功");
              } else {
                  System.out.println("上传失败");
              }
      
          }
      
    更多相关内容
  • java上传文件到ftp.txt

    2019-06-05 16:08:25
    通过java程序来实现将本地文件上传到ftp服务器的功能
  • java上传文件到ftp服务器,从ftp服务器下载东西demo,日管理
  • java实现ftp断点续上传文件到FTP服务器,支持断点续,同时支持LINUX主机,代码里面包括了比较多的java网络操作类,比如连接FTP的常规类、递归创建远程服务器目录 上传文件到服务器,新上传和断点续操作,远程...
  • 主要介绍了JAVA技术实现上传下载文件到FTP服务器(完整),本文使用 Apache Jakarta Commons Net(commons-net-3.3.jar) 基于FileZilla Server服务器实现FTP服务器上文件上传/下载/删除等操作,需要的朋友可以参考下
  • java代码参考的https://www.jianshu.com/p/44d9b05691a8大佬的代码,场景是原项目测试时期是存储文件到本地的,但是部署服务器之后有FTP文件服务器存在,需要将原本的代码更改为上传到ftp的代码。 1、是有多个pom...

    因为个人原因,不在csdn上更新了,欢迎各位来到我的个人博客:

    https://tdsgpo.top

    java代码参考的Java 实现ftp文件上传 - 简书大佬的代码,场景是原项目测试时期是存储文件到本地的,但是部署服务器之后有FTP文件服务器存在,需要将原本的代码更改为上传到ftp的代码。

    1、是有多个pom文件的项目需要把maven放在最外面一层的pom文件里面,不然会出现依赖循环问题。

    2、不能在ftp上创建文件夹的问题,可能存在已经创建好的根目录的文件所属用户不是ftp的使用者用户。需要 chown 用户 目录或文件名,更改文件夹拥有者。

    接下来是使用到的代码部分:

    3、有可能在切换目录的时候会出现550 Fial to change directoty 的报错,这个时候可能hi应为ftp服务器配置的问题,需要设置以下选项:

    首先 vi /etc/vsftpd/vsftpd.conf

    然后观察以下选项,是否一致

    chroot_list_enable=YES(NO)
    设置是否启用chroot_list_file配置项指定的用户列表文件。默认值为NO。
    chroot_list_file=/etc/vsftpd.chroot_list
    用于指定用户列表文件,该文件用于控制哪些用户可以切换到用户家目录的上级目录。
    chroot_local_user=YES(NO)
    用于指定用户列表文件中的用户是否允许切换到上级目录。默认值为NO。

    最后service vsftpd restart 重启

    1、pom依赖

    <!--commons-net -->
    <dependency>
        <groupId>commons-net</groupId>
        <artifactId>commons-net</artifactId>
        <version>3.5</version>
    </dependency>

    2、FTP工具类

    package www.hrabbit.cn.util;
    
    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;
    
    import java.io.*;
    import java.net.MalformedURLException;
    
    /**
     * @Auther: hrabbit
     * @Date: 2018-04-21 下午12:35
     * @Description:
     */
    public class FTPUtils {
    
        public static FTPClient ftpClient = null;
    
        /**
         * 初始化ftp服务器
         */
        public static void initFtpClient(String hostname,String username,String password,Integer port) {
            ftpClient = new FTPClient();
            ftpClient.setControlEncoding("utf-8");
            try {
                //连接ftp服务器
                ftpClient.connect(hostname, port);
                //登录ftp服务器
                ftpClient.login(username, password);
                //是否成功登录服务器
                int replyCode = ftpClient.getReplyCode();
                if(!FTPReply.isPositiveCompletion(replyCode)){
                    System.out.println("ftp服务器登录成功");
                }
            }catch (MalformedURLException e) {
                e.printStackTrace();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 上传文件
         * @param pathname ftp服务保存地址
         * @param fileName 上传到ftp的文件名
         * @param inputStream 输入文件流
         * @return
         */
        public static boolean uploadFile(String hostname,String username,String password,Integer port, String pathname, String fileName,InputStream inputStream){
            boolean flag = false;
            try{
                System.out.println("开始上传文件");
                initFtpClient(hostname,username,password,port);
                ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
                ftpClient.enterLocalPassiveMode();
                CreateDirecroty(pathname);
                ftpClient.makeDirectory(pathname);
                ftpClient.setControlEncoding("utf-8");
                ftpClient.storeFile(fileName, inputStream);
                System.out.println("上传结束");
                inputStream.close();
                ftpClient.logout();
                flag = true;
                System.out.println("上传文件成功");
    
            }catch (Exception e) {
                System.out.println("上传文件失败");
                e.printStackTrace();
            }finally{
                if(ftpClient.isConnected()){
                    try{
                        ftpClient.disconnect();
                    }catch(IOException e){
                        e.printStackTrace();
                    }
                }
                if(null != inputStream){
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return true;
        }
        //改变目录路径
        public static boolean changeWorkingDirectory(String directory) {
            boolean flag = true;
            try {
                flag = ftpClient.changeWorkingDirectory(directory);
                if (flag) {
                    System.out.println("进入文件夹" + directory + " 成功!");
                } else {
                    System.out.println("进入文件夹" + directory + " 失败!开始创建文件夹");
                }
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            return flag;
        }
    
        //创建多层目录文件,如果有ftp服务器已存在该文件,则不创建,如果无,则创建
        public static boolean CreateDirecroty(String remote) throws IOException {
            boolean success = true;
            String directory = remote + "/";
            // 如果远程目录不存在,则递归创建远程服务器目录
            if (!directory.equalsIgnoreCase("/") && !changeWorkingDirectory(new String(directory))) {
                int start = 0;
                int end = 0;
                if (directory.startsWith("/")) {
                    start = 1;
                } else {
                    start = 0;
                }
                end = directory.indexOf("/", start);
                String path = "";
                String paths = "";
                while (true) {
                    String subDirectory = new String(remote.substring(start, end).getBytes("UTF-8"), "iso-8859-1");
                    path = path + "/" + subDirectory;
                    if (!existFile(path)) {
                        if (makeDirectory(subDirectory)) {
                            changeWorkingDirectory(subDirectory);
                        } else {
                            System.out.println("创建目录[" + subDirectory + "]失败");
                            changeWorkingDirectory(subDirectory);
                        }
                    } else {
                        changeWorkingDirectory(subDirectory);
                    }
    
                    paths = paths + "/" + subDirectory;
                    start = end + 1;
                    end = directory.indexOf("/", start);
                    // 检查所有目录是否创建完毕
                    if (end <= start) {
                        break;
                    }
                }
            }
            return success;
        }
    
        //判断ftp服务器文件是否存在
        public static boolean existFile(String path) throws IOException {
            boolean flag = false;
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);
            if (ftpFileArr.length > 0) {
                flag = true;
            }
            return flag;
        }
        //创建目录
        public static boolean makeDirectory(String dir) {
            boolean flag = true;
            try {
                flag = ftpClient.makeDirectory(dir);
                if (flag) {
                    System.out.println("创建文件夹" + dir + " 成功!");
    
                } else {
                    System.out.println("创建文件夹" + dir + " 失败!");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return flag;
        }
    
        /** * 下载文件 *
         * @param pathname FTP服务器文件目录 *
         * @param filename 文件名称 *
         * @param localpath 下载后的文件路径 *
         * @return */
        public static  boolean downloadFile(String hostname,String username,String password,Integer port,String pathname, String filename, String localpath){
            boolean flag = false;
            OutputStream os=null;
            try {
                System.out.println("开始下载文件");
                initFtpClient(hostname,username,password,port);
                //切换FTP目录
                ftpClient.changeWorkingDirectory(pathname);
                FTPFile[] ftpFiles = ftpClient.listFiles();
                for(FTPFile file : ftpFiles){
                    if(filename.equalsIgnoreCase(file.getName())){
                        File localFile = new File(localpath + "/" + file.getName());
                        os = new FileOutputStream(localFile);
                        ftpClient.retrieveFile(file.getName(), os);
                        os.close();
                    }
                }
                ftpClient.logout();
                flag = true;
                System.out.println("下载文件成功");
            } catch (Exception e) {
                System.out.println("下载文件失败");
                e.printStackTrace();
            } finally{
                if(ftpClient.isConnected()){
                    try{
                        ftpClient.disconnect();
                    }catch(IOException e){
                        e.printStackTrace();
                    }
                }
                if(null != os){
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return flag;
        }
    
        /** * 删除文件 *
         * @param pathname FTP服务器保存目录 *
         * @param filename 要删除的文件名称 *
         * @return */
        public static boolean deleteFile(String hostname,String username,String password,Integer port,String pathname, String filename){
            boolean flag = false;
            try {
                System.out.println("开始删除文件");
                initFtpClient(hostname,username,password,port);
                //切换FTP目录
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.dele(filename);
                ftpClient.logout();
                flag = true;
                System.out.println("删除文件成功");
            } catch (Exception e) {
                System.out.println("删除文件失败");
                e.printStackTrace();
            } finally {
                if(ftpClient.isConnected()){
                    try{
                        ftpClient.disconnect();
                    }catch(IOException e){
                        e.printStackTrace();
                    }
                }
            }
            return flag;
        }
    }

    欢迎大家光临我的个人博客,里面还有更多的好东西

    Hexohttps://tdsgpo.top/

    展开全文
  • Apache commons-net 上传文件FTP服务器
  • java上传文件到FTP服务器

    万次阅读 多人点赞 2019-03-17 00:58:52
    前段时间,项目中使用上传文件到FTP服务器,再此略作整理,形成一个util工具,方便日后使用。 项目代码已上传至github:https://github.com/hack-feng/ftpdemo.git 点击直接前往 首先定义一个FTP服务器和上传...

    欢迎来到小生的博客,各种工具类,常用知识点、技巧持续更新中。。。。。。。
    感谢大家点赞关注,希望大家能够给小生更多的支持。
    祝您阅读愉快!
    有任何疑问可以加小生QQ群咨询:107680366

    前段时间,项目中使用到了上传文件到FTP服务器,再此略作整理,形成一个util工具,方便日后使用。
    项目代码已上传至github:https://github.com/hack-feng/ftpdemo.git
    点击直接前往

    其中部分生成规则可以根据实际业务进行修改,删除

    首先定义一个FTP服务器和上传文件的基础信息
    封装一个FtpBean.java实体类

    public class FtpBean {
    	/**
    	 * 部分信息如果传空的话,默认赋值,根据业务需求修改
    	 */
    	//FTP服务器地址
    	private String address;
    	//FTP服务器端口号
    	private String port;
        //FTP服务器用户名
    	private String username;
    	//FTP服务器密码
    	private String password;
    	//上传文件名称
    	private String fileName;
    	//基本路径
    	private String basepath;
    	//文件输入流
    	private InputStream inputStream;
    	//保存文件方式  默认:1-覆盖;2-文件名称后面+(递增数据) 
    	private Integer saveFileType;
    	//省略get,set方法,详情可查询github上的源码
    

    创建FTP上传工具类 FtpUtil.java:

    public class FtpUtil {
    	
    	public static boolean uploadFile(FtpBean ftpBean) {
    		
    		boolean result = false;
    		FTPClient ftp = new FTPClient();
    		try {
    			int reply;
    			ftp.connect(ftpBean.getAddress(), Integer.valueOf(ftpBean.getPort()));// 连接FTP服务器
    			// 如果采用默认端口,可以使用ftp.connect(host)的方式直接连接FTP服务器
    			ftp.login(ftpBean.getUsername(), ftpBean.getPassword());// 登录
    			reply = ftp.getReplyCode();
    			
    			if (!FTPReply.isPositiveCompletion(reply)) {
    				ftp.disconnect();
    				return result;
    			}
    			
    			String tempPath = ftpBean.getBasepath();
    			String fileName = ftpBean.getFileName();
    			if (!ftp.changeWorkingDirectory(ftpBean.getBasepath())) {
    				//判断目录是否存在,如果目录不存在创建目录,目录存在则跳转到此目录下
    				String []tempPathList = tempPath.split("/");
    				for (String dir : tempPathList) {
    					if(dir != null && dir != ""){
    						if (!ftp.changeWorkingDirectory(dir)) {
    							if (!ftp.makeDirectory(dir)) {
    								return result;
    							} else {
    								ftp.changeWorkingDirectory(dir);
    							}
    						}
    					}
    				}
    			}
    			
    			//保存文件方式  默认:1-覆盖;2-文件名称后面+(递增数据) 
    			if(ftpBean.getSaveFileType() == 2){
    				FTPFile[]file = ftp.listFiles();
    				Integer i = 1;
    				//采用递归,文件名重复自动加(i)
    				fileName = aaa(file, i, fileName, fileName);
    			}
    			//设置上传文件的类型为二进制类型
    			ftp.setFileType(FTP.BINARY_FILE_TYPE);
    			//设置模式很重要
    			ftp.enterLocalActiveMode();
    			//上传文件
    			result = ftp.storeFile(fileName, ftpBean.getInputStream());
    			if(!result){
    				return result;
    			}
    
    			ftpBean.getInputStream().close();
    			ftp.logout();
    			result = true;
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (ftp.isConnected()) {
    				try {
    					ftp.disconnect();
    				} catch (IOException ioe) {
    				}
    			}
    		}
    		return result;
    	}
    	
    	
    	//递归重命名去重复
    	public static String aaa(FTPFile[] file, int i, String fileName, String nameFlag){
    		boolean isOk = true;
    		for (FTPFile file2 : file) {
    			String flag = file2.getName();
    			if(nameFlag.equals(flag)){
    				String []fileNames = fileName.split("\\.");
    				if(fileNames.length > 0){
    					nameFlag = "";
    				}
    				for (int j = 0; j < fileNames.length; j++) {
    					if(j == fileNames.length-1){
    						nameFlag = nameFlag+"("+i+")."+fileNames[j];
    					}else if(j == fileNames.length-2){
    						nameFlag = nameFlag + fileNames[j];
    					}else{
    						nameFlag = nameFlag + fileNames[j] + ".";
    					}
    				}
    				i += 1;
    				isOk = false;
    			}else{
    				isOk = true;
    			}
    		}
    		
    		if(isOk == false){
    			nameFlag = aaa(file, i, fileName, nameFlag);
    		}
    		return nameFlag;
    	}
    }
    

    生成上传路径规则工具类 GenerateDirUtil.java:

    public class GenerateDirUtil {
    	
    	public static enum Type{
    		DEFAULT,
    		FILETYPE
    	}
    
    	/**
    	 *  <p>
    	 *  type为DEFAULT或者type为null时:获取原文件所在路径,直接在FTP创建此路径保存
    	 *  type为FILETYPE时:则根据文件类型创建目录
    	 *  </p>
    	 *  @method_Name    : fileDirectory
    	 *  @author         : Maple
    	 *  @creation       : 2019年3月15日 下午1:59:31 
    	 *  @param file
    	 *  @return
    	 */
    	public static String fileDirectory(File file, Type type){
    		if(Type.FILETYPE.equals(type)){
    			String resDir = "/";
    			resDir = new MimetypesFileTypeMap().getContentType(file);
    			resDir.replace('\\', '/');
    			return "/"+resDir;
    		}else{
    			String resDir = "/";
    			resDir = file.getParent();
    			return resDir;
    		}
    	}
    }
    

    创建测试用例FtpDemo.java:

    public class FtpDemo {
    	
    	public static void main(String[] args){
    		
    		//获取本地需要上传的文件,此处只用作测试
    		File file = new File("D:\\test\\ftp.txt");
    		
    		if(file.isFile() && file.exists()){
    			
    			//设置FTP上传的基本信息,可直接初始化数据
    			FtpBean ftp = new FtpBean();
    			
    			//自动生成路径,默认取源文件路径,为FILETYPE时,取文件类型做路径
    			//如使用自己的路径,直接ftp.setBasepath赋值即可
    			String basepath = GenerateDirUtil.fileDirectory(file, GenerateDirUtil.Type.FILETYPE);
    			ftp.setBasepath(basepath);
    			
    			/**
    			 * 文件名生成方式
    			 * 1、自己命名			ftp.setBasepath("aaaa.txt");
    			 * 2、取文件原名字		ftp.setBasepath(file.getName());
    			 * 3、根据时间戳自动生成	
    			 */
    			SimpleDateFormat sdfms = new SimpleDateFormat("yyyyMMddHHmmssSSS");
    			String date = sdfms.format(System.currentTimeMillis());
    			//添加三位自动生成的数字,防止重复
    			int i=(int)(Math.random()*900)+100; 
    			String fileName = date + i +".txt";
    			ftp.setFileName(fileName);
    			
    			//测试命名重复递增
    			fileName = "aaa.txt";
    			
    			try{
    				//将文件转换成一个输入流
    				InputStream in = new FileInputStream(file);
    				ftp.setInputStream(in);
    				//传入文件名称,和文件输入流,上传至FTP服务器
    				boolean isOk = FtpUtil.uploadFile(ftp);
    				if(isOk){
    					System.out.println("文件上传成功");
    				}else{
    					System.out.println("文件上传失败");
    				}
    				in.close();
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}else{
    			System.out.println("文件不存在");
    		}
    	}
    }
    

    待上传的文件截图:
    在这里插入图片描述
    上传至FTP服务器后的截图,分别用按时间戳命名和固定不重复命名两种方法实现:

    展开全文
  • 主要介绍了Java实现ftp上传下载、删除文件及在ftp服务器上传文件夹的方法,需要的朋友可以参考下
  • java上传文件ftp

    2021-12-29 15:57:24
    import org.apache.commons.net.ftp.FTPClient; import org.apache.commons.net.ftp.FTPReply; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java....
    package com.company.project.utils;
    
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPReply;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.util.Map;
    
    /**
     * ftp 上传文件
     * FTPClient commons.net 3.0.1版本
     * 上传文件至指定ftp路径
     * @author Lenovo
     * oracle每天更新工参三次。抽取一次。上传至ftp目录
     */
    public class FtpClientUpFile {
    
        private static final String hostname = "10.*.*.4";//FTP IP
    
        private static final int port = 21;//FTP 端口号
    
        private static final String username = "ftpuser";//FTP 登录账号
    
        private static final String password = "123456"; //FTP 登录密码
    
        private static final String pathname = "/data/ftp/";//FTP 工作路径
    
        private static final SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd"); //FTP服务器上文件
    
    
        /**
         * 上传文件(可供Action/Controller层使用)
         *
         * @param fileName    上传到FTP服务器后的文件名称
         * @param inputStream 输入文件流
         * @return
         */
        public static boolean uploadFile(String fileName, FileInputStream inputStream) {
    
            boolean flag = false;
            FTPClient ftpClient = new FTPClient();
            //设置超时
            ftpClient.setConnectTimeout(60 * 60 * 1000);
            //设置编码
            ftpClient.setControlEncoding("UTF-8");
            try {
                //连接FTP服务器
                ftpClient.connect(hostname, port);
                //登录FTP服务器
                ftpClient.login(username, password);
                //是否成功登录FTP服务器
                int replyCode = ftpClient.getReplyCode();
                if (!FTPReply.isPositiveCompletion(replyCode)) {
                    return flag;
                }
                System.out.println("===========登录FTP成功了==========");
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                //切换路径 创建路径
                ftpClient.makeDirectory(pathname);
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.enterLocalPassiveMode();
                
                String pathDir1 = pathname+df.format(new Date());
                boolean pathIsExis = ftpClient.changeWorkingDirectory(pathDir1);
                System.out.println("查看文件夹是否存在");
                if(!pathIsExis){//不存在文件夹则创建并且进入文件夹
                    ftpClient.makeDirectory(pathDir1);
                    ftpClient.changeWorkingDirectory(pathDir1);
                }
    
                //设置缓冲
                ftpClient.setBufferSize(1024 * 1024 * 20);
                //保持连接
                ftpClient.setKeepAlive(true);
                boolean a = ftpClient.storeFile(new String(fileName.getBytes("utf-8"), "iso-8859-1"), inputStream);
                if (a) {
                    flag = true;
                    System.out.println("===========创建文件成功==============" + a);
                    String fileName2 = fileName;  //这里可以将名字更改
                    boolean status = ftpClient.rename(fileName, fileName2);
                    if (status)
                        System.out.println("===========修改文件名称成功==============" + status);
                }else{
                    flag = false;
                }
                inputStream.close();
                ftpClient.logout();
                flag = true;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return flag;
    
        }
    
    
        public static void main(String[] args) {
            String fileName = "tousu.xlsx.gz";
            String originfilename = "E:\\data\\"+fileName;
            FileInputStream inputStream;
            try {
                inputStream = new FileInputStream(originfilename);
                boolean a = uploadFile(fileName, inputStream);
                System.out.println("上传文件结果============" + a);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    
        /**
         * 测试上传
         *
         * @param map 从数据库获取到的文件信息 (包含文件路径FILE_PATH 文件类型FILE_TYPE等信息)
         */
        public void testUpdFtpFile(Map<String, Object> map) {
            /*上传附件到FTP*/
            FileInputStream inputStream = null;
            try {
                //找到要上传的文件
                String originfilename = "E:\\work\\files\\" + map.get("FILE_PATH").toString();
                //转成流
                inputStream = new FileInputStream(originfilename);
                //上传后的文件名+文件类型
                String ftpName = "上传到FTP后的文件名." + map.get("FILE_TYPE");
                boolean updFtpFile = FtpClientUpFile.uploadFile(ftpName, inputStream);
                if (updFtpFile) {
                    //打印下日志
                    System.out.println(("=======文件已上传到FTP========"));
                }
            } catch (Exception e) {
                System.out.println("上传异常");
                e.printStackTrace();
            }
        }
    
    
    }

    展开全文
  • 代码实现 /** * @param filePath:要上传文件全路径 * @param ftpPath:要上传ftp全路径 * @ftpIP FTP 的IP * @username 用户名 * @password 密码 * @function 将指定的文件上传到ftp指定路径 * @author */ ...
  • NULL 博文链接:https://zhou-hong-liang.iteye.com/blog/305214
  • 使用java语言上传文件到ftp服务器中,一般都是将文件压缩成压缩包,然后上传到ftp服务器中的 ftp服务器也是可以在本地搭建的,这里我就不说怎么搭建了,后面再说如何搭建本地的ftp服务器,可以用来学习 首先我们先...
  • Java 上传文件到ftp服务器

    千次阅读 2017-01-20 09:04:48
     前两篇文章我们搭建了一个ftp服务器,并对服务器进行了相应的配置,这篇文章我们来说一下我们如何上传文件。  先介绍一下项目,本项目采用的是spring mvc +spring +mybatis ,用maven 进行项目管理。看一下...
  • Java上传文件到FTP中文名称处理

    千次阅读 2020-01-10 15:18:31
    在上传文件到FTP服务器时,使用英文名都是能够正常上传文件的,但是文件名称带中文时会服务器会返回如下错误信息: The filename, directory name, or volume label syntax is incorrect. 经过调试发现,下面这句...
  • 搜索热词下面是编程之家 jb51.cc 通过网络收集整理的代码...import org.apache.commons.net.ftp.FTPClient;import java.io.FileInputStream;import java.io.IOException;public class FtpFileUpload {public static...
  • 2.关闭匿名访问 ... 4.查看服务状态 ...使用postman进行测试:上传文件进行测试 一般都会存在用户目录下:如果不是用户的目录下地址,则自动会存入用户下。(只会跑用户目录下存储)..........
  • java实现文件上传到ftp服务器上 内容精选换一换域名认证时,需要将下载的认证文件上传到网站根目录,然后进行认证。用户使用的服务器不同,文件上传的位置有所不同,请参照以下方法完成认证文件上传。如果网站所...
  • JAVA上传文件到FTP

    千次阅读 2019-06-24 11:25:08
    需求说明:将指定文件上传到FTP上传成功后修改文件名。 获取文件名及路径(这里是从数据库获取,所以前面的代码就不CV了) /** * 测试上传 * @param map 从数据库获取文件信息 (包含文件路径FILE_...
  • 在项目开发过程中,遇到需要将页面上选择的文件上传FTP服务器,遇到一些坑,比如上传文件中文名乱码,上传时指定上传目录不能自动创建等问题。 2、FTP上传文件工具类 public class FtpUtil { private String ...
  • java通过上传文件ftp服务器

    千次阅读 2021-11-22 20:00:23
    ftp工具类 import org.apache.commons.lang.StringUtils; import org.apache.commons.net.ftp.FTPClient; import org.apache.commons.net.ftp.FTPClientConfig; import org.apache.commons.net.ftp.FTPFile; ...
  • 1.上传文件到ftp服务器,并解决上传文件名称乱码问题服务器public class FtpUploadUtils {urlprivate static Logger log = Logger.getLogger(FtpUploadUtils.class);对象/*** @throws BmsException** 上传附件金融...
  • 文件传输协议(File Transfer Protocol,FTP)是用于在网络上进行文件传输的一套标准协议,它工作在 OSI 模型的第七层, TCP 模型的第四层, 即应用层, 使用 TCP 传输而不是 UDP, 客户在和服务器建立连接前要经过...
  • java ftp上传文件

    千次阅读 2022-03-23 13:52:26
    <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</artifactId>...import java.io.IOException;...import java.io.InputStream;...import java...
  • Java项目实现文件上传FTP

    千次阅读 2021-07-21 15:08:45
    街道一个需求,需要提供一个接口,将资质文件(图片)上传到FTP上, 因为之前是前端页面通过Node直接上传到FTP的,现在需要后台提供一个接口由后端接口上传到FTP。 二、pom依赖及配置文件 项目是否是SpringBoot工程...
  • JAVA操作FTP文件服务器上传与下载文件,包含远程动态创建文件夹、查看文件是否存在、删除文件上传文件和下载文件等方法
  • Java文件上传到ftp服务器

    千次阅读 2020-06-09 16:34:48
    Java文件上传到ftp服务器 首先简单介绍一下什么是FTP,以及如何在自己的电脑上搭建一个ftp服务器; —— FTP文件传输协议(FTP)是一种客户端/服务器协议,用于将文件传输主机或与主机交换文件。它可以使用...
  • NULL 博文链接:https://gougang.iteye.com/blog/1595305
  • java实现的ftp文件上传

    2016-03-16 11:39:46
    java实现的ftp文件上传

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,433
精华内容 20,173
关键字:

java上传文件到ftp