JAVA FTP 上传文件

发布时间：2020-07-12 15:41:23 来源：网络阅读：1453 作者：IT达仁栏目：软件技术

下面展示通过http 方式上传文件到服务器：

/**

文件上传接口
@param request【module】【filename】
@param response
@throws IOException */
@RequestMapping("/upload")
br/>*/
@RequestMapping("/upload")
String module=params.get("module");//请求模块，根据模块请求的文件放到不通目录
log.info("upload method param:"+module);
if (!validPublicModule(module)) {
ReponseUtils.renderJsonp(request, response, RespObj.failedObj("上传目录不正确"));
return;
}
//打开连接FTP
FtpUtils ftp=FtpUtils.getInstance();
InputStream input = null;
if(filename != null){
log.info("ftp opern sucess:");
String newFileName=newfileName(filename);
input=filename.getInputStream();
String ftppath=getDirPath(module) ;
Boolean isfalg=ftp.uploadFile(input, newFileName, ftppath);
if(!isfalg){
ReponseUtils.renderJsonp(request, response, RespObj.failedObj("文件上传异常"));
return;
}
RespObj obj = RespObj.successObj();
String url=ftppath+File.separator+newFileName;
log.info("ftp url:"+url);
obj.setData(url);
obj.setErrorMsg("sucess");
ReponseUtils.renderJsonp(request, response, obj);
}
}
```
    FTP 工具类：

    package com.ejauto.core.ftp;
```

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

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 org.apache.log4j.Logger;

import com.ejauto.core.utils.Constants;

public class FtpUtils {

Logger log = Logger.getLogger(FtpUtils.class);

private FTPClient ftpClient = null;
private String server;
private int port;
private String userName;
private String userPassword;

private FtpUtils(String server,int port,String userName,String userPassword) {
    this.server = server;
    this.port = port;
    this.userName = userName;
    this.userPassword = userPassword;
}

/**
 * 连接服务器
 * @return 连接成功与否 true:成功， false:失败
 */
public boolean open() {

    if (ftpClient != null && ftpClient.isConnected()) {
        return true;
    }
    try {
        ftpClient = new FTPClient();
        // 连接
        ftpClient.connect(this.server, this.port);
        ftpClient.login(this.userName, this.userPassword);
        setFtpClient(ftpClient);
        // 检测连接是否成功
        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            this.close();
            System.err.println("FTP server refused connection.");
            //System.exit(1);
        }
        log.info("open FTP success:" + this.server + ";port:" + this.port + ";name:" + this.userName
                + ";pwd:" + this.userPassword);
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE); // 设置上传模式.binally  or ascii
        return true;
    } catch (Exception ex) {
        this.close();
        ex.printStackTrace();
        return false;
    }
}

/**
 * 切换到父目录
 * @return 切换结果 true：成功， false：失败
 */
@SuppressWarnings("unused")
private boolean changeToParentDir() {
    try {
        return ftpClient.changeToParentDirectory();
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 改变当前目录到指定目录
 * @param dir 目的目录
 * @return 切换结果 true：成功，false：失败
 */
@SuppressWarnings("unused")
private boolean cd(String dir) {
    try {
        return ftpClient.changeWorkingDirectory(dir);
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 获取目录下所有的文件名称
 * 
 * @param filePath 指定的目录
 * @return 文件列表,或者null
 */
@SuppressWarnings("unused")
private FTPFile[] getFileList(String filePath) {
    try {
        return ftpClient.listFiles(filePath);
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }
}

/**
 * 层层切换工作目录
 * @param ftpPath 目的目录
 * @return 切换结果
 */
public boolean changeDir(String ftpPath) {
    if (!ftpClient.isConnected()) {
        return false;
    }
    try {
        // 将路径中的斜杠统一
        char[] chars = ftpPath.toCharArray();
        StringBuffer sbStr = new StringBuffer(256);
        for (int i = 0; i < chars.length; i++) {
            if ('\\' == chars[i]) {
                sbStr.append('/');
            } else {
                sbStr.append(chars[i]);
            }
        }
        ftpPath = sbStr.toString();
        if (ftpPath.indexOf('/') == -1) {
            // 只有一层目录
            ftpClient.changeWorkingDirectory(new String(ftpPath.getBytes(), "iso-8859-1"));
        } else {
            // 多层目录循环创建
            String[] paths = ftpPath.split("/");
            for (int i = 0; i < paths.length; i++) {
                ftpClient.changeWorkingDirectory(new String(paths[i].getBytes(), "iso-8859-1"));
            }
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 循环创建目录，并且创建完目录后，设置工作目录为当前创建的目录下
 * @param ftpPath 需要创建的目录
 * @return
 */
public boolean mkDir(String ftpPath) {
    if (!ftpClient.isConnected()) {
        return false;
    }
    try {
        // 将路径中的斜杠统一
        char[] chars = ftpPath.toCharArray();
        StringBuffer sbStr = new StringBuffer(256);
        for (int i = 0; i < chars.length; i++) {
            if ('\\' == chars[i]) {
                sbStr.append('/');
            } else {
                sbStr.append(chars[i]);
            }
        }
        ftpPath = sbStr.toString();

        if (ftpPath.indexOf('/') == -1) {
            // 只有一层目录
            ftpClient.makeDirectory(new String(ftpPath.getBytes(), "iso-8859-1"));
            ftpClient.changeWorkingDirectory(new String(ftpPath.getBytes(), "iso-8859-1"));
        } else {
            // 多层目录循环创建
            String[] paths = ftpPath.split("/");
            for (int i = 0; i < paths.length; i++) {
                ftpClient.makeDirectory(new String(paths[i].getBytes(), "iso-8859-1"));
                ftpClient.changeWorkingDirectory(new String(paths[i].getBytes(), "iso-8859-1"));
            }
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 上传文件到FTP服务器
 * @param localDirectoryAndFileName 本地文件目录和文件名
 * @param ftpFileName 上传到服务器的文件名
 * @param ftpDirectory FTP目录如:/path2/pathb2/,如果目录不存在会自动创建目录
 * @return
 */
public boolean uploadFile(InputStream fis, String ftpFileName, String ftpDirectory) {
    if (!ftpClient.isConnected()) {
        return false;
    }
    boolean flag = false;
    if (ftpClient != null) {
        //File srcFile = new File(localDirectoryAndFileName);
        //InputStream fis = null;
        try {
            //fis = new InputStream(srcFile);
            // 创建目录
            this.mkDir(ftpDirectory);
            ftpClient.setBufferSize(100000);
            ftpClient.setControlEncoding("UTF-8");
            // 设置文件类型（二进制）
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            ftpClient.enterLocalPassiveMode();
            // 上传
            log.error("ftpClient.storeFile:");
            flag = ftpClient.storeFile(new String(ftpFileName.getBytes("UTF-8"),"iso-8859-1"), fis);
        } catch (Exception e) {
            this.close();
            e.printStackTrace();
            log.error("Exception:"+e.getMessage());
            return false;
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return flag;
}

/**
 * 从FTP服务器上下载文件
 * @param ftpDirectoryAndFileName ftp服务器文件路径，以/dir形式开始
 * @param localDirectoryAndFileName 保存到本地的目录
 * @return
 */
public boolean get(String ftpDirectoryAndFileName, String localDirectoryAndFileName) {
    if (!ftpClient.isConnected()) {
        return false;
    }
    ftpClient.enterLocalPassiveMode(); // Use passive mode as default
    try {
        // 将路径中的斜杠统一
        char[] chars = ftpDirectoryAndFileName.toCharArray();
        StringBuffer sbStr = new StringBuffer(256);
        for (int i = 0; i < chars.length; i++) {
            if ('\\' == chars[i]) {
                sbStr.append('/');
            } else {
                sbStr.append(chars[i]);
            }
        }
        ftpDirectoryAndFileName = sbStr.toString();
        String filePath = ftpDirectoryAndFileName.substring(0, ftpDirectoryAndFileName.lastIndexOf("/"));
        String fileName = ftpDirectoryAndFileName.substring(ftpDirectoryAndFileName.lastIndexOf("/") + 1);
        this.changeDir(filePath);
        ftpClient.retrieveFile(new String(fileName.getBytes(), "iso-8859-1"),
                new FileOutputStream(localDirectoryAndFileName)); // download
        // file
        //System.out.println(ftpClient.getReplyString()); // check result
        //System.out.println("从ftp服务器上下载文件：" + ftpDirectoryAndFileName + "， 保存到：" + localDirectoryAndFileName);
        return true;
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 返回FTP目录下的文件列表
 * @param pathName
 * @return
 */
public String[] getFileNameList(String pathName) {
    try {
        return ftpClient.listNames(pathName);
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }
}

/**
 * 删除FTP上的文件
 * @param ftpDirAndFileName 路径开头不能加/，比如应该是test/filename1
 * @return
 */
public boolean deleteFile(String ftpDirAndFileName) {
    if (!ftpClient.isConnected()) {
        return false;
    }
    try {
        return ftpClient.deleteFile(ftpDirAndFileName);
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 删除FTP目录
 * @param ftpDirectory
 * @return
 */
public boolean deleteDirectory(String ftpDirectory) {
    if (!ftpClient.isConnected()) {
        return false;
    }
    try {
        return ftpClient.removeDirectory(ftpDirectory);
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 关闭链接
 */
public void close() {
    try {
        if (ftpClient != null && ftpClient.isConnected()) {
            ftpClient.disconnect();
        }
        System.out.println("成功关闭连接，服务器ip:" + this.server + ", 端口:" + this.port);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public FTPClient getFtpClient() {
    return ftpClient;
}

public void setFtpClient(FTPClient ftpClient) {
    this.ftpClient = ftpClient;
}

public void download(HttpServletResponse response,String ftpDirectoryAndFileName){

    if (!ftpClient.isConnected()) {
        return ;
    }
    ftpClient.enterLocalPassiveMode(); // Use passive mode as default
    try {
        // 将路径中的斜杠统一
        char[] chars = ftpDirectoryAndFileName.toCharArray();
        StringBuffer sbStr = new StringBuffer(256);
        for (int i = 0; i < chars.length; i++) {
            if ('\\' == chars[i]) {
                sbStr.append('/');
            } else {
                sbStr.append(chars[i]);
            }
        }
        ftpDirectoryAndFileName = sbStr.toString();
        String filePath = ftpDirectoryAndFileName.substring(0, ftpDirectoryAndFileName.lastIndexOf("/"));

        String fileName = ftpDirectoryAndFileName.substring(ftpDirectoryAndFileName.lastIndexOf("/") + 1);
        this.changeDir(filePath);
        InputStream inputStream = ftpClient.retrieveFileStream(new String(fileName.getBytes(), "iso-8859-1"));

        ServletOutputStream outputStream = null;
        try {
            response.setHeader("content-disposition", "attachment;filename="+fileName);
            //通知浏览器下载文件类型，解决部分浏览器下载APK为.htm格式
            response.setContentType("application/octet-stream");

            outputStream = response.getOutputStream();
            byte[] buffer = new byte[8192];
            int len = inputStream.read(buffer);
            while (len != -1) {
                outputStream.write(buffer, 0, len);
                len = inputStream.read(buffer);
            }
            outputStream = response.getOutputStream();

            ByteArrayOutputStream swapStream = new ByteArrayOutputStream();  
            byte[] buff = new byte[100];  
            int rc = 0;  
            while ((rc = inputStream.read(buff, 0, 100)) > 0) {  
                swapStream.write(buff, 0, rc);  
            }  
            byte[] in2b = swapStream.toByteArray();  
            outputStream.write(in2b);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(inputStream!=null){
                    inputStream.close();
                }
                if(outputStream!=null){
                    outputStream.flush();
                    outputStream.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }catch(Exception e){
        log.info(e.getMessage());
        e.printStackTrace();
    }
}

public void downloadImg(HttpServletResponse response,String ftpDirectoryAndFileName){

    if (!ftpClient.isConnected()) {
        return ;
    }
    ftpClient.enterLocalPassiveMode(); // Use passive mode as default
    try {
        // 将路径中的斜杠统一
        char[] chars = ftpDirectoryAndFileName.toCharArray();
        StringBuffer sbStr = new StringBuffer(256);
        for (int i = 0; i < chars.length; i++) {
            if ('\\' == chars[i]) {
                sbStr.append('/');
            } else {
                sbStr.append(chars[i]);
            }
        }
        ftpDirectoryAndFileName = sbStr.toString();
        String filePath = ftpDirectoryAndFileName.substring(0, ftpDirectoryAndFileName.lastIndexOf("/"));

        String fileName = ftpDirectoryAndFileName.substring(ftpDirectoryAndFileName.lastIndexOf("/") + 1);
        this.changeDir(filePath);
        InputStream inputStream = ftpClient.retrieveFileStream(new String(fileName.getBytes(), "iso-8859-1"));

        ServletOutputStream outputStream = null;
        try {
            outputStream = response.getOutputStream();
            byte[] buffer = new byte[8192];
            int len = inputStream.read(buffer);
            while (len != -1) {
                outputStream.write(buffer, 0, len);
                len = inputStream.read(buffer);
            }
            outputStream = response.getOutputStream();

            ByteArrayOutputStream swapStream = new ByteArrayOutputStream();  
            byte[] buff = new byte[100];  
            int rc = 0;  
            while ((rc = inputStream.read(buff, 0, 100)) > 0) {  
                swapStream.write(buff, 0, rc);  
            }  
            byte[] in2b = swapStream.toByteArray();  
            outputStream.write(in2b);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(inputStream!=null){
                    inputStream.close();
                }
                if(outputStream!=null){
                    outputStream.flush();
                    outputStream.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }catch(Exception e){
        log.info(e.getMessage());
        e.printStackTrace();
    }
}

public boolean upload(InputStream fis, String ftpDirectory){

    String ftpFileName = ftpDirectory.substring(ftpDirectory.indexOf("/"));

    return uploadFile(fis, ftpFileName, ftpDirectory);

}

public static FtpUtils getInstance(){

    String host = Constants.FTP_HOST;
    int port = Integer.valueOf(Constants.FTP_PORT).intValue();
    String user = Constants.FTP_USERNAME;
    String pwd = Constants.FTP_PWD;

    FtpUtils f = new FtpUtils(host, port, user, pwd);

    if(f.open()){
        return f;
    }

    return null;
}
public static void main(String[] args) {
    FileInputStream input = null;
    FtpUtils f=FtpUtils.getInstance();

}

public String getFilePath(HttpServletResponse response,String fileName) throws IOException{

 if (!ftpClient.isConnected()) {
     return "";
 }
 ftpClient.enterLocalPassiveMode(); // Use passive mode as default
 ftpClient.getPassiveLocalIPAddress();
 System.out.println("getPassiveLocalIPAddress:"+ftpClient.getLocalAddress());
 String url="ftp://"+ftpClient.getLocalAddress()+File.separator+fileName;//拼接ftp 路径
 return url;
}

}

向AI问一下细节

JAVA FTP 上传文件

猜你喜欢

最新资讯

相关推荐

相关标签