sftpjava,sftpjava连接

发布时间：2023-01-09

本文目录一览：

  1. java通过sftp上传大文件，时间长，而且会提示超出GC开销限制，内存溢出，这种问题怎么解决
  2. java向SFTP服务器上传文件，如何判断服务器上的文件夹是否存在？
  3. java ftp 和 sftp的区别
  4. java连接Sftp服务器后，使用第三方jar com.jcraft.jsch.ChannelSftp;用get()方法获取的InputStream流为空
  5. java sftp上传文件 ，在cd时 空指针异常，服务器上path存在
  6. sftp免密用java怎么调用

java通过sftp上传大文件，时间长，而且会提示超出GC开销限制，内存溢出，这种问题怎么解决

public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    request.setCharacterEncoding("GBK");
    HttpSession session = (HttpSession) request.getSession();
    final long MAX_SIZE = 10 * 1024 * 1024; // 设置上传文件最大为 10M
    // 允许上传的文件格式的列表
    final String[] allowedExt = new String[] { "jpg", "jpeg", "gif", "png", "JPG", "bmp", "BMP" };
    response.setContentType("text/html;charset=gbk");
    // 设置字符编码为UTF-8, 这样支持汉字显示
    response.setCharacterEncoding("GBK");
    String strImageName = (String) session.getAttribute("strName");
    if (ServletFileUpload.isMultipartContent(request)) {
        // 实例化一个硬盘文件工厂,用来配置上传组件ServletFileUpload
        DiskFileItemFactory dfif = new DiskFileItemFactory();
        dfif.setSizeThreshold(4096); // 设置上传文件时用于临时存放文件的内存大小,这里是4K.多于的部分将临时存在硬盘
        dfif.setRepository(new File(this.getServletContext().getRealPath("/") + "Image")); // 设置存放临时文件的目录,web根目录下的Image目录
        // 用以上工厂实例化上传组件
        ServletFileUpload sfu = new ServletFileUpload(dfif); // 设置最大上传尺寸
        sfu.setSizeMax(MAX_SIZE);
        PrintWriter out = response.getWriter();
        // 从request得到 所有 上传域的列表
        List fileList = null;
        try {
            fileList = sfu.parseRequest(request);
        } catch (FileUploadException e) { // 处理文件尺寸过大异常
            if (e instanceof SizeLimitExceededException) {
                out.println("文件尺寸超过规定大小:" + MAX_SIZE + "字节p /");
                out.println("a href='addGoods.jsp' 返回/a");
                return;
            }
            e.printStackTrace();
        }
        // 没有文件上传
        if (fileList == null || fileList.size() == 0) {
            out.println("请选择要上传文件ap /");
            out.println("a href='addGoods.jsp' 返回/a");
            return;
        }
        // 得到所有上传的文件
        Iterator fileItr = fileList.iterator();
        // 循环处理所有文件
        this.list = new ArrayList();
        while (fileItr.hasNext()) {
            long size = 0;
            // 得到当前文件
            FileItem fileItem = (FileItem) fileItr.next();
            // 忽略简单form字段而不是上传域的文件域(input type="text" /等)
            if (fileItem == null || fileItem.isFormField()) {
                System.out.println(fileItem.getFieldName());
                String inputstr = fileItem.getString("GBK");
                list.add(inputstr);
                continue;
            }
            // 得到文件的完整路径
            String path = fileItem.getName();
            // 得到文件的大小
            size = fileItem.getSize();
            if ("".equals(path) || size == 0) {
                out.println("请选择上传文件p /");
                out.println("a href='addGoods.jsp' 返回/a");
                return;
            }
            System.out.println("文件的完整路径" + path);
            // 得到去除路径的文件名
            String t_name = path.substring(path.lastIndexOf("\\") + 1);
            // 得到文件的扩展名(无扩展名时将得到全名)
            String t_ext = t_name.substring(t_name.lastIndexOf(".") + 1);
            // 拒绝接受规定文件格式之外的文件类型
            int allowFlag = 0;
            int allowedExtCount = allowedExt.length;
            for (; allowFlag < allowedExtCount; allowFlag++) {
                if (allowedExt[allowFlag].equals(t_ext))
                    break;
            }
            if (allowFlag == allowedExtCount) {
                out.println("请上传以下类型的文件p /");
                for (allowFlag = 0; allowFlag < allowedExtCount; allowFlag++)
                    out.println("*." + allowedExt[allowFlag] + " ");
                out.println("p /a href='addGoods.jsp' 返回/a");
                return;
            }
            long now = System.currentTimeMillis();
            // 根据系统时间生成上传后保存的文件名
            String u_name = this.getServletContext().getRealPath("/") + "ImageDown\\" + t_name;
            try {
                // 保存文件
                fileItem.write(new File(u_name));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
}

java向SFTP服务器上传文件，如何判断服务器上的文件夹是否存在？

如果你的JAVA部署的tomcat，就是你要查找文件的服务器，那就用：

File file = new File("文件路径");

如果你本地的JAVA想要访问远程的一个服务器的文件是否存在，就得用如下方法：

URL url = new URL("文件路径：可以是本地服务器的路径，也可以是远程服务器的路径");
HttpURLConnection urlcon = (HttpURLConnection) url.openConnection();
// message = urlcon.getHeaderField(0);
// 文件存在 'HTTP/1.1 200 OK' 文件不存在 'HTTP/1.1 404 Not Found'
Long TotalSize = Long.parseLong(urlcon.getHeaderField("Content-Length"));
if (TotalSize > 0) {
    return true;
} else {
    return false;
}

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

java ftp 和 sftp的区别

文件传送协议FTP(File Transfer Protocol)是TCP/IP协议簇中的一个成员，也是现在因特网上最广泛的文件传送协议。FTP协议包括两个部分，一个是FTP客户端，另一个是FTP服务器。当然，FTP服务器是用来存储文件资源的，FTP客户端通过访问FTP服务器来获得资源的。 安全文件传送协议SFTP(Secure File Transfer Protocol)可以为文件传送提供安全的加密/解密技术。基本语法和FTP差不多。SFTP是SSH的一部分，在SSH软件包中，已经包含了一个SFTP(Secure File Transfer Protocol)的安全文件传输子系统，SFTP本身没有单独的守护进程，它必须使用sshd守护进程（端口号默认是22）来完成相应的连接操作。由于这种传输方式使用了加密/解密技术，文件传送相对来说是很安全的，但是是有代价的，它的传输效率比FTP要低得多。 引自：网页链接

java连接Sftp服务器后，使用第三方jar com.jcraft.jsch.ChannelSftp;用get()方法获取的InputStream流为空

java连接Sftp服务器后，使用第三方jar com.jcraft.jsch.ChannelSftp;用get()方法获取的InputStream流为空，检查下第3方初始化这些写对没有，或者就是没得到流，打印看看，解决问题。

java sftp上传文件 ，在cd时 空指针异常，服务器上path存在

try {
    s;
} catch (SftpException sException) {
    if (s == sException.id) { // 如果文件夹不存在，则进行新建
        s;
        s;
    }
}

用这个就可以解决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.ChannelS;
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;
    /**
     * 获取实例
     *
     * @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) {
                            s;
                            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) {
        String[] dirs = dirName.split("/");
        try {
            String now = s;
            for (int i = 0; i < dirs.length; i++) {
                boolean dirExists = openDir(dirs[i]);
                if (!dirExists) {
                    s(dirs[i]);
                    s(dirs[i]);
                }
            }
            s;
        } catch (SftpException e) {
            DEBUGGER.error("mkDir Exception : " + e);
        }
    }
    /**
     * 打开指定目录
     *
     * @param directory directory
     * @return 是否打开目录
     */
    public boolean openDir(String directory) {
        try {
            s;
            return true;
        } catch (SftpException e) {
            DEBUGGER.error("openDir Exception : " + e);
            return false;
        }
    }
}
推荐文章