`
xinyoulinglei
  • 浏览: 126041 次
社区版块
存档分类
最新评论

java实现sftp实例

    博客分类：
  • SFTP
java 
阅读更多



import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Vector;

import org.apache.commons.lang.ArrayUtils;

import com.huawei.bme.commons.om.log.DebugLog;
import com.huawei.bme.commons.om.log.LogFactory;
import com.huawei.icity.commons.constants.KeyConstant;
import com.huawei.icity.commons.constants.NumberConstant;
import com.huawei.icity.commons.exception.SPMException;
import com.huawei.icity.commons.log.IcityLogFactory;
import com.huawei.icity.commons.log.IcityRuntimeLog;
import com.huawei.icity.commons.sysconfig.StaticInitData;
import com.huawei.icity.commons.utils.StringTools;
import com.huawei.icity.omp.common.util.CommonTools;
import com.huawei.icity.omp.interfaces.hint.constant.TimetaskConstants;
import com.huawei.mdmc.bfm.cms.assist.common.domain.SingleTableModel;
import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelSftp.LsEntry;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;

/**
* SFTP公共处理类 〈提供SFTP文件上传,下载,获取指定目录 下文件名集合， 获取指定目录 下文件集合等方法>
*
* @author mKF75022
* @version iCity Manager V100R002 2012-7-3
* @since iCity Manager V100R002C01
*/
public class SFTPTool
{
    /**
     * 调测日志记录器。
     */
    private static final DebugLog DEBUGGER = LogFactory.getDebugLog(SFTPTool.class);

    /**
     * 运行日志记录器。
     */
    private static final IcityRuntimeLog RUNTIMELOGGER = IcityLogFactory
            .getRuntimeLog(SFTPTool.class);

    /**
     * Sftp客户端对象
     */
    private ChannelSftp sftp = null;

    /**
     * SFTP IP地址
     */
    private String ip;

    /**
     * SFTP 端口
     */
    private String port;

    /**
     * SFTP 用户名
     */
    private String userName;

    /**
     * SFTP 密码
     */
    private String password;

    /**
     * SFTP上传模式:BINARY
     */
    // private static final int BINARY_FILE_TYPE = 2;

    /**
     *
     * 获取实例
     *
     * @return SFTPTool newinstance实例
     *
     */
    public static SFTPTool getNewInstance()
    {
        return new SFTPTool();
    }

    /**
     * 初始化连接参数
     *
     * @param sftpIP
     *            IP
     * @param sftpPort
     *            端口
     * @param sftpUsername
     *            用户名
     * @param sftpPassword
     *            密码
     */
    public void init(String sftpIP, String sftpPort, String sftpUsername, String sftpPassword)
    {
        // 获取SFTP连接信息
        this.ip = sftpIP;
        this.port = sftpPort;
        this.userName = sftpUsername;
        this.password = sftpPassword;
    }

    /**
     * 从SFTP将符合约定命名的文件都下载到本地 .
     *
     * @param sftpDir
     *            SFTP服务器文件存放路径
     * @param locDir
     *            本地文件存放路径
     * @param regex
     *            指定文件名的格式
     * @param needBackup
     *            是否需要文件备份(true:是;false:否)
     * @param needFullMatch
     *            是否要求全局匹配(true:是;false:否)
     * @param deleteFtpFile
     *            the delete ftp file
     * @return 下载到本地的文件列表
     */
    public List<File> synSFTPFileToLocal(String sftpDir, String locDir, String regex,
            boolean needBackup, boolean needFullMatch, boolean deleteFtpFile)
    {
        List<File> files = new ArrayList<File>(KeyConstant.INITIAL_NUMBER);
        try
        {
            this.connect(ip, Integer.parseInt(this.port), userName, password);

            // 获得FTP上文件名称列表
            List<String> ftpFileNameList = this.listFiles(sftpDir, regex, needFullMatch);

            File localFile = null;

            int size = ftpFileNameList.size();

            // 根据每个FTP文件名称创建本地文件。
            for (int i = 0; i < size; i++)
            {
                // 下载源文件
                localFile = this.download(sftpDir, locDir, ftpFileNameList.get(i), deleteFtpFile);
                if (localFile.exists())
                {
                    files.add(localFile);
                }
                if (needBackup)
                {
                    // 备份源文件生成默认备份文件路径(据请求文件路径,生成同级目录的备份文件夹绝对路径)
                    String parentDir = sftpDir.substring(NumberConstant.INT_0,
                            sftpDir.lastIndexOf("/") + 1);
                    String backupDir = parentDir + TimetaskConstants.DEFAULT_BACKUP_DIRNAME;
                    boolean bakExists = openDir(backupDir);
                    if (bakExists)
                    {
                        this.uploadFile(backupDir, localFile);
                    }
                    else
                    {
                        boolean parentExists = openDir(parentDir);
                        if (parentExists)
                        {
                            sftp.mkdir(TimetaskConstants.DEFAULT_BACKUP_DIRNAME);
                            this.uploadFile(backupDir, localFile);
                        }
                        else
                        {
                            DEBUGGER.error("sftp parentDir no exisits ");
                        }
                    }
                }
            }
        }
        catch (Exception e)
        {
            DEBUGGER.error("synSFTPFileToLocal Exception", e);
        }
        finally
        {
            this.disconnect();
        }
        return files;
    }

    /**
     * 连接sftp服务器
     *
     * @param sftpip
     *            ip地址
     * @param sftpport
     *            端口
     * @param sftpusername
     *            用户名
     * @param sftppassword
     *            密码
     * @return channelSftp
     * @throws SPMException
     */
    public ChannelSftp connect(String sftpip, int sftpport, String sftpusername, String sftppassword)
    {
        sftp = new ChannelSftp();
        try
        {
            JSch jsch = new JSch();
            jsch.getSession(sftpusername, sftpip, sftpport);
            Session sshSession = jsch.getSession(sftpusername, sftpip, sftpport);
            RUNTIMELOGGER.info("Session created");
            sshSession.setPassword(sftppassword);
            Properties sshConfig = new Properties();
            sshConfig.put("StrictHostKeyChecking", "no");
            sshSession.setConfig(sshConfig);
            // 设置超时时间为
            sshSession.setTimeout(Integer.parseInt(StaticInitData.getFtpConnectTimeOut())
                    * NumberConstant.INT_1000);
            sshSession.connect();
            Channel channel = sshSession.openChannel("sftp");
            channel.connect();
            sftp = (ChannelSftp) channel;

            // 设置文件类型
            // ftpClient.setFileType(BINARY_FILE_TYPE);

            // 与防火墙相关
            // ftpClient.enterLocalPassiveMode();
        }
        catch (JSchException e)
        {
            DEBUGGER.error("JSchException : {}", e);
        }
        return sftp;
    }

    // /**
    // * 创建指定文件夹
    // *
    // * @param dirName
    // * dirName
    // */
    // public void mkDir(String dirName)
    // {
    // try
    // {
    // sftp.mkdir(dirName);
    // }
    // catch (SftpException e)
    // {
    // DEBUGGER.error("mkDir Exception : " + e);
    // }
    // }

    /**
     * 创建指定文件夹
     *
     * @param dirName
     *            dirName
     */
    public void mkDir(String dirName)
    {
        String[] dirs = dirName.split("/");
        try
        {
            String now = sftp.pwd();
            for (int i = 0; i < dirs.length; i++)
            {
                boolean dirExists = openDir(dirs[i]);
                if (!dirExists)
                {
                    sftp.mkdir(dirs[i]);
                    sftp.cd(dirs[i]);

                }

            }
            sftp.cd(now);
        }
        catch (SftpException e)
        {
            DEBUGGER.error("mkDir Exception : " + e);
        }
    }

    /**
     * 打开指定目录
     *
     * @param directory
     *            directory
     * @return 是否打开目录
     */
    public boolean openDir(String directory)
    {
        try
        {
            sftp.cd(directory);
            return true;
        }
        catch (SftpException e)
        {
            DEBUGGER.error("openDir Exception : " + e);
            return false;
        }
    }

    /**
     *
     * 用sftp上传申请文档 测试报告 logo图片
     *
     * @param directory
     *            resourcePackage
     * @param singleTableModel
     *            单例模式
     * @return flag
     */
    public boolean uploadLogoFile(String directory, SingleTableModel singleTableModel)
    {
        File file = singleTableModel.getFileUpload();
        boolean flag = false;
        FileInputStream in = null;
        try
        {
            String now = sftp.pwd();
            // sftp.cd(directory);
            // add by lizhonghu 创建目录
            openAndMakeDir(directory);
            in = new FileInputStream(file);
            sftp.put(in, singleTableModel.getFileUploadFileName());
            sftp.cd(now);
            if (file.exists())
            {
                flag = true;
            }
            else
            {
                flag = false;
            }
        }
        catch (Exception e)
        {
            DEBUGGER.error("uploadFile Exception : " + e);
        }
        finally
        {
            try
            {
                if (null != in)
                {
                    try
                    {
                        in.close();
                    }
                    catch (IOException e)
                    {
                        DEBUGGER.error("IOException : " + e);
                    }
                }
            }
            catch (Exception e)
            {
                DEBUGGER.error("Exception : " + e);
            }
        }
        return flag;
    }

    /**
     * 创建指定文件夹
     *
     * @param directory
     *            路径+文件夹名
     * @return 成功与否
     */
    public boolean openAndMakeDir(String directory)
    {
        try
        {
            String now = sftp.pwd();
            if (now.equals(directory))
            {
                return true;
            }
            else
            {
                try
                {
                    sftp.cd(directory);
                    return true;
                }
                catch (SftpException e)
                {
                    if (directory.startsWith(now))
                    {
                        directory = directory.replaceFirst(now, "");
                    }
                    String[] dirList = directory.split("/");
                    dirList = (String[]) ArrayUtils.removeElement(dirList, "");
                    for (String dir : dirList)
                    {
                        try
                        {
                            sftp.cd(dir);
                        }
                        catch (SftpException e1)
                        {
                            sftp.mkdir(dir);
                            sftp.cd(dir);
                        }
                    }
                    return true;
                }
            }
        }
        catch (SftpException e)
        {
            DEBUGGER.error("openDir Exception : " + directory, e);
            return false;
        }
    }

    /**
     * 上传文件
     *
     * @param directory
     *            上传的目录
     * @param file
     *            要上传的文件 parentDir 上传目录的上级目录
     * @return 是否上传
     */
    public boolean uploadFile(String directory, File file)
    {
        boolean flag = false;
        FileInputStream in = null;
        try
        {
            String now = sftp.pwd();
            sftp.cd(directory);
            in = new FileInputStream(file);
            sftp.put(in, file.getName());
            sftp.cd(now);
            if (file.exists())
            {
                flag = true;
            }
            else
            {
                flag = false;
            }
        }
        catch (Exception e)
        {
            DEBUGGER.error("uploadFile Exception : " + e);
        }
        finally
        {
            try
            {
                if (null != in)
                {
                    try
                    {
                        in.close();
                    }
                    catch (IOException e)
                    {
                        DEBUGGER.error("IOException : " + e);
                    }
                }
            }
            catch (Exception e)
            {
                DEBUGGER.error("Exception : " + e);
            }
        }
        return flag;
    }

    /**
     * 下载文件.
     *
     * @param ftpDir
     *            存放下载文件的SFTP路径
     * @param locDir
     *            下载的文件 SFTP上的文件名称
     * @param ftpFileName
     *            FTP上的文件名称
     * @param deleteFtpFile
     *            the delete ftp file
     * @return 本地文件对象
     * @throws FileNotFoundException
     *             FileNotFoundException
     */
    public File download(String ftpDir, String locDir, String ftpFileName, boolean deleteFtpFile)
            throws FileNotFoundException
    {
        File file = null;
        FileOutputStream output = null;
        String localDir = CommonTools.buildLocalDir(locDir).append(File.separator)
                .append(ftpFileName).toString();
        try
        {
            String now = sftp.pwd();
            sftp.cd(ftpDir);
            file = new File(localDir);
            output = new FileOutputStream(file);
            sftp.get(ftpFileName, output);
            sftp.cd(now);
            if (deleteFtpFile)
            {
                sftp.rm(ftpFileName);
            }
        }
        catch (SftpException e)
        {
            if (DEBUGGER.isErrorEnable())
            {
                DEBUGGER.error("Failed to download", e);
            }
            e.toString();
        }
        finally
        {
            if (null != output)
            {
                try
                {
                    output.close();
                }
                catch (IOException e)
                {
                    DEBUGGER.error("create localFile failed:" + e);
                }
            }
        }
        return file;
    }

    /**
     * Description:断开FTP连接 <br>
     */
    public void disconnect()
    {
        if (null != sftp)
        {
            sftp.disconnect();

            if (null != sftp.getSession())
            {
                sftp.getSession().disconnect();
            }
        }
    }

    /**
     * 删除文件
     *
     * @param directory
     *            要删除文件所在目录
     * @param deleteFile
     *            要删除的文件
     * @param sftp
     */
    public void delete(String directory, String deleteFile)
    {
        try
        {
            String now = sftp.pwd();
            sftp.cd(directory);
            sftp.rm(deleteFile);
            sftp.cd(now);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 列出目录下的文件
     *
     * @param directory
     *            要列出的目录
     * @param regex
     *            指定文件名的格式
     * @param needFullMatch
     *            是否要求全局匹配(true:是;false:否)
     * @return 文件列表
     * @throws SftpException
     *             SftpException
     * @throws SPMException
     *             SPMException
     */
    @SuppressWarnings("unchecked")
    public List<String> listFiles(String directory, String regex, boolean needFullMatch)
            throws SftpException, SPMException
    {
        List<String> ftpFileNameList = new ArrayList<String>(KeyConstant.INITIAL_NUMBER);
        Vector<LsEntry> sftpFile = sftp.ls(directory);
        LsEntry isEntity = null;
        String fileName = null;
        Iterator<LsEntry> sftpFileNames = sftpFile.iterator();
        while (sftpFileNames.hasNext())
        {
            isEntity = (LsEntry) sftpFileNames.next();
            fileName = isEntity.getFilename();

            if (StringTools.isNullOrNone(regex))
            {
                ftpFileNameList.add(fileName);
            }
            else
            {
                if (fileName.matches(regex))
                {
                    ftpFileNameList.add(fileName);
                }
                else
                {
                    if (needFullMatch)
                    {
                        throw new SPMException("SYSTEM ERROR",
                                "system error,all file check terminated,invalid file name "
                                        + fileName);
                    }
                    else
                    {
                        DEBUGGER.error("Invalid file named " + fileName);
                    }
                }
            }
        }

        return ftpFileNameList;
    }

    public ChannelSftp getSftp()
    {
        return sftp;
    }

    public void setSftp(ChannelSftp sftp)
    {
        this.sftp = sftp;
    }

    public String getIp()
    {
        return ip;
    }

    public void setIp(String ip)
    {
        this.ip = ip;
    }

    public String getPort()
    {
        return port;
    }

    public void setPort(String port)
    {
        this.port = port;
    }

    public String getUserName()
    {
        return userName;
    }

    public void setUserName(String userName)
    {
        this.userName = userName;
    }

    public String getPassword()
    {
        return password;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }

}
分享到：
| log4j多文件输出日志信息
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA实现SFTP实例.txt

    资源内容：Java实现Sftp中文件的操作，如目录或文件创建及删除，拉取文件，上传文件。可以直接拿来使用。

    JAVA实现SFTP上传，下载，删除等方法

    在Java编程中，实现Secure File Transfer Protocol (SFTP) 功能是常见的需求，尤其是在处理远程文件操作时。本文将详细讲解如何使用开源库JSch来实现在Java中进行SFTP的上传、下载以及删除文件的方法。 JSch是一个...

    JAVA网络安全实现SFTP实例MySFTP.java

    JAVA网络安全实现SFTP实例MySFTP

    JAVA SFTP文件上传、下载及批量下载实例

    在本篇文章中，我们将详细介绍JAVA SFTP文件上传、下载及批量下载的实例，包括相关的概念、API介绍、代码实现等方面的内容。 首先，我们需要了解什么是SFTP？SFTP（Secure File Transfer Protocol）是一种安全的...

    java实现sftp客户端上传文件以及文件夹的功能

    Java实现SFTP（Secure File Transfer Protocol）客户端上传文件和文件夹是一项常见的任务，尤其是在系统集成或者数据迁移场景中。下面将详细介绍如何通过Java实现这一功能，主要涉及的技术点包括SFTP协议、JSch库的...

    java操作sftp的工具类(JSch)

    JSch是一个纯Java实现的SSH2库，允许开发人员连接到支持SFTP的服务器，进行文件的上传、下载以及执行其他相关操作。本文将详细介绍如何使用JSch进行SFTP操作，并提供一个简单的`SftpUtil`工具类示例。 首先，我们...

    JSch - Java实现的SFTP（文件上传详解篇）

    JSch - Java 实现的 SFTP（文件上传详解篇） JSch 是 Java Secure Channel 的缩写，JSch 是一个 SSH2 的纯 Java 实现。JSch 允许您连接到一个 SSH 服务器，并且可以使用端口转发、X11 转发、文件传输等，当然您也...

    基于Java的实例源码-用Java写的SFTP代码.zip

    本实例源码是基于Java实现的SFTP客户端，用于连接到支持SFTP的服务器并执行文件操作，如上传、下载和管理文件。 Java作为一种广泛使用的编程语言，拥有丰富的库和工具支持各种网络通信，包括SFTP。在Java中实现SFTP...

    java 开发sftp下载上传

    Java作为一种广泛应用的编程语言，提供了丰富的库和工具来实现SFTP功能。本篇文章将深入探讨如何使用Java进行SFTP的文件上传与下载操作。 首先，为了在Java中实现SFTP，我们需要一个支持SFTP的库，例如JSch（Java ...

    java版SFTP实现示例（使用jsch）

    在这个示例中，我们将探讨如何使用Java通过JSch库实现SFTP功能。 JSch是一个纯Java实现的SSH2库，它允许Java应用程序连接到支持SSH协议的服务器，执行SFTP操作。`jsch-0.1.43.jar`是JSch库的JAR文件，包含所有必要...

    java sftp文件上传

    Java SFTP文件上传是通过Java编程语言实现与Secure File Transfer Protocol（SFTP）服务器进行交互，将本地文件安全地传输到远程服务器的过程。SFTP是一种基于SSH的安全文件传输协议，它提供了在不安全网络上安全...

    JAVA通过SFTP实现远程上传下载demo代码

    本文将详细介绍如何使用Java通过SFTP实现远程文件的上传和下载，并提供一个简单的示例代码。 首先，为了实现SFTP功能，我们需要一个第三方库，如JSch（Java Secure Channel）。JSch是一个纯Java实现的SSH2库，它...

    java实现导出csv文件并上传sftp

    本篇文章将深入探讨如何使用Java实现CSV文件的生成，并将其通过SFTP（Secure File Transfer Protocol）协议上传到指定服务器。 首先，我们要介绍的是用于生成CSV文件的库：univocity-parsers。这是一个高效、灵活且...

    jsch.jar及实现代码 SftpUtil.java java使用sftp实现上传下载文件

    在这个场景中，我们将详细讨论如何使用`jsch.jar`库以及提供的`SftpUtil.java`工具类来实现在Java中执行SFTP任务。 首先，`jsch.jar`是Java Secure Channel的缩写，这是一个由JCraft公司开发的开源项目。它提供了对...

    用java写的SFTP代码源码下载

    本文将深入探讨如何使用Java实现SFTP功能，以及提供的源码下载。 Java作为一种广泛使用的编程语言，拥有丰富的库来支持各种网络协议，包括SFTP。在Java中实现SFTP，我们通常会使用JSch库，这是一个开源的Java SSH2...

    java实现ftp、sftp的文件上传和下载

    这篇内容将详细介绍如何使用Java实现FTP和SFTP的文件上传与下载，并涉及相关的Apache库。 FTP是一种基于TCP的服务，主要用于在互联网上进行文件传输。Java中可以使用Apache Commons Net库来实现FTP操作。首先，需要...

    java SFTP上传所需jar和秘钥工具

    1. **JSch (Java Secure Channel)**: JSch 是一个纯Java实现的SSH2库，它允许用户执行SFTP（Secure File Transfer Protocol）操作。SFTP是基于SSH协议的文件传输协议，提供了安全的文件传输能力。JSch-0.1.54.jar是...

    java使用sftp操作样例 包含jar和代码

    在这个示例中，我们不仅会探讨SFTP的基本概念，还会讲解如何在Java中实现SFTP操作，并涉及到提供的jar和代码。 1. **SFTP简介** SFTP是一种基于TCP的协议，用于在两个系统之间安全地传输文件。它通过SSH连接提供...

    jsch-0.1.42.jar及用java实现SFTP的例子

    5. **创建SFTP通道**：使用`Session`对象的`openChannel("sftp")`方法获取一个`ChannelSftp`实例。 6. **初始化SFTP通道**：调用`ChannelSftp`的`connect()`方法。 7. **执行SFTP操作**：如`cd()`（改变目录）、`...

    java_sftp.zip

    总的来说，这个Java SFTP项目提供了在Java环境下与Linux服务器进行文件交互的实例，对于学习和理解如何在Java中实现SFTP操作具有很好的参考价值。通过深入理解和实践，你可以更好地掌握Java与远程系统间的文件传输...

Magicbox
Global site tag (gtag.js) - Google Analytics