InputStream需要被多次使用的解决方案

最新推荐文章于 2024-10-11 16:48:28 发布
最新推荐文章于 2024-10-11 16:48:28 发布
阅读量759 收藏 2
点赞数
文章标签： java python
原文链接：https://my.oschina.net/sunchenbin/blog/632954
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

先把需求甩出来，我有两台SFTP服务器A、B，我需要从A中取出一批文件，上传到B中的目录①并且要备份到目录②，所以从A中我会得到一批InputStream。

这个时候，为了效率我可能会close掉这个到A的连接，这里如果close掉了，那么这个流就消失了。

还有假设我没有close掉A连接，那么当我将InputStream给put到B的目录①之后，继续put到B的备份目录②，这个时候你会发现，文件确实都上传上去了，但是目录②的文件大小是0k。

这是因为InputStream的特性，可以把他想成一个指针，每读取一个字节指针就向后移一次，整个文件读完，指针已经移到最后了，当下次再读的时候，是从InputStream末尾开始读的，也就什么都读不到，造成了0k的情况。

有人可能想将InputStream复制一份，很不幸的告诉你，InputStream不能被复制，就算复制了也没有效果，因为他本身不存储数据，他只是建立了一个流向文件的数据流，所以关掉连接的话从InputStream中就读不到文件了，可以把他理解成一个管道。

下面提供一种解决办法，将InputStream中的内容缓存到ByteArrayOutputStream这里面，ByteArrayOutputStream是可以被复制的，也就是在读取InputStream之后，将他缓存到ByteArrayOutputStream，那么这个时候即时关闭连接，我的内容也已经缓存到了ByteArrayOutputStream中，思想就是这有，下面直接看代码。

下面是一个实现上述需求的完整代码

package com.baozun.store.manager.tafile;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.util.FileCopyUtils;

import com.baozun.nebula.utilities.common.ProfileConfigUtil;
import com.baozun.store.util.SFTPUtils;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelSftp.LsEntry;
import com.jcraft.jsch.SftpException;

/** * 上传tafile文件 * * @author sunchenbin * @version 2015年11月27日 下午2:59:48 */
@Service("cogradientTafileManager")
public class CogradientTafileManager{

    private static final Logger log                 = LoggerFactory.getLogger(CogradientTafileManager.class);

    private ChannelSftp         sftpClient1         = null;

    private SFTPUtils           sftp1               = new SFTPUtils();

    private ChannelSftp         sftpClient2         = null;

    private SFTPUtils           sftp2               = new SFTPUtils();

    private Properties          properties          = ProfileConfigUtil.findPro("config/sftp.properties");

    private String              FROM_BASEPATH       = properties.getProperty("from.sftp.basePath");         // 读取文件的基本路径

    private final String        FROM_IP             = properties.getProperty("from.sftp.ip");                   // 读取文件的服务器IP地址

    private final String        FROM_USERNAME       = properties.getProperty("from.sftp.username");         // 读取文件的用户名

    private final String        FROM_USERPWD        = properties.getProperty("from.sftp.userpwd");              // 读取文件的密码

    private final String        FROM_PORT           = properties.getProperty("from.sftp.port");             // 读取文件的端口号

    private String              TO_BASEPATH         = properties.getProperty("to.sftp.basePath");               // 上传文件的基本路径

    private String              TO_BACKUP_BASEPATH  = properties.getProperty("to.sftp.backUpbasePath");     // 上传文件的备份路径

    private final String        TO_IP               = properties.getProperty("to.sftp.ip");                 // 上传文件的服务器IP地址

    private final String        TO_USERNAME         = properties.getProperty("to.sftp.username");               // 上传文件的用户名

    private final String        TO_USERPWD          = properties.getProperty("to.sftp.userpwd");                // 上传文件的密码

    private final String        TO_PORT             = properties.getProperty("to.sftp.port");                   // 上传文件的端口号

    private final String        TA_MEM              = "TA_MEM";                                             // 文件前缀

    private final String        TA_NOM              = "TA_NOM";                                             // 文件前缀

    private final String        BACKUP              = "backUp/";                                                // 创建备份文件夹
    /** * 将InputStream中的字节保存到ByteArrayOutputStream中。 */
    private ByteArrayOutputStream byteArrayOutputStream = null;

    /** * 需要执行的job方法 */
    public void doExcuteJob(){

        // 读取
        Map<String, ByteArrayOutputStream> inputStreamMap = buildFileMap();

        // 上传
        uploadTaFile(inputStreamMap);
    }

    /** * 上传tafile文件到sftp * * @param inputStreamMap */
    private void uploadTaFile(Map<String, ByteArrayOutputStream> inputStreamMap){
        // 连接上传文件的sftp
        sftpClient2 = sftp2.connect(TO_IP, Integer.parseInt(TO_PORT), TO_USERNAME, TO_USERPWD);
        log.info(TO_IP + " 连接成功");
        if(inputStreamMap.size() > 0){
            log.info("正在准备上传和备份文件");
            for (String key : inputStreamMap.keySet()){
                try{
                    InputStream inputStream1 = new ByteArrayInputStream(inputStreamMap.get(key).toByteArray());
                    InputStream inputStream2 = new ByteArrayInputStream(inputStreamMap.get(key).toByteArray());
                    sftpClient2.put(inputStream1, TO_BASEPATH + key);               
                    log.info("上传文件：" + key + " 成功");
                    sftpClient2.put(inputStream2, TO_BACKUP_BASEPATH + key);
                    log.info("上传备份文件：" + key + " 成功");
                }catch (Exception e){
                    log.error("上传文件失败！");
                    log.error(e.getMessage());
                }
                log.info("正在准备删除源文件："+key);
                try{
                    sftpClient1.rm(FROM_BASEPATH + key);
                }catch (SftpException e){
                    log.error("删除源文件失败！");
                    log.error(e.getMessage());
                }
                log.info("删除文件完成");
            }
            log.info("全部文件上传备份完成");
        }else {
            log.info("没有要操作的文件");
        }
        sftpClient1.exit();
        sftpClient2.exit();
    }

    /** * 读取sftp文件备份并返回读取的文件 * * @return */
    private Map<String, ByteArrayOutputStream> buildFileMap(){
        // 连接读文件的sftp
        sftpClient1 = sftp1.connect(FROM_IP, Integer.parseInt(FROM_PORT), FROM_USERNAME, FROM_USERPWD);
        log.info(FROM_IP + " 连接成功");
        // 存储文件
        Vector<LsEntry> ftpFiles = null;
        // TA_MEM和TA_NOM输入流
        Map<String, ByteArrayOutputStream> inputStreamMap = new HashMap<String, ByteArrayOutputStream>();
        log.info("正在检查备份文件目录...");
        // 检查并创建备份目录
        try{
            sftpClient1.cd(FROM_BASEPATH + BACKUP);
            log.info("备份文件目录backUp已存在无需创建");
        }catch (SftpException e){
            try{
                sftpClient1.mkdir(FROM_BASEPATH + BACKUP);
                log.info("正在创建备份文件目录backUp...");
            }catch (SftpException e1){
                log.error("创建备份文件目录backUp失败！");
                log.error(e1.getMessage());
            }
        }
        // tafile的读取备份并删除源文件
        try{
            ftpFiles = sftpClient1.ls(FROM_BASEPATH);
            if (ftpFiles != null && ftpFiles.size() > 0){
                for (LsEntry ftpFile : ftpFiles){
                    if (ftpFile.getFilename().startsWith(TA_MEM) || ftpFile.getFilename().startsWith(TA_NOM)){
                        log.info("正在获取TA_MEM和TA_NOM的文件输入流...");
                        inputStreamCacher(sftpClient1.get(FROM_BASEPATH + ftpFile.getFilename()));
                        inputStreamMap.put(ftpFile.getFilename(), byteArrayOutputStream);
                        log.info("正在准备备份文件："+ftpFile.getFilename());
                        FileCopyUtils.copy(
                                new File(FROM_BASEPATH + ftpFile.getFilename()),
                                new File(FROM_BASEPATH + BACKUP + ftpFile.getFilename()));
                        log.info("备份文件完成");
                    }
                }
            }else {
                log.info("没有需要处理的文件");
            }

        }catch (Exception e){
            log.error("读取文件失败！");
            log.error(e.getMessage());
        }
        return inputStreamMap;
    }

    public void inputStreamCacher(InputStream inputStream) {
        byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];  
        int len;  
        try {
            while ((len = inputStream.read(buffer)) > -1 ) {  
                byteArrayOutputStream.write(buffer, 0, len);  
            }
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }finally{
            try {
                byteArrayOutputStream.flush();
                byteArrayOutputStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

上面的关键代码我在这里列一下：

// 首先是将流缓存到byteArrayOutputStream中
public void inputStreamCacher(InputStream inputStream) {
        byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];  
        int len;  
        try {
            while ((len = inputStream.read(buffer)) > -1 ) {  
                byteArrayOutputStream.write(buffer, 0, len);  
            }
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }finally{
            try {
                byteArrayOutputStream.flush();
                byteArrayOutputStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

// 然后是这里将存好的byteArrayOutputStream取出来做这有的操作，搞两份就好了
InputStream inputStream1 = new ByteArrayInputStream(inputStreamMap.get(key).toByteArray());
InputStream inputStream2 = new ByteArrayInputStream(inputStreamMap.get(key).toByteArray());

到这里基本就实现我们的需求，应该还有其他的实现方式，比如把InputStream的指针还原到初始等等…知道的可以贴出来给大家看看。

转载于:https://my.oschina.net/sunchenbin/blog/632954

weixin_34185512
关注
request body数据多次读取解决方案及通用签名校验方式
fajing_feiyue的博客
11-02 3152
当用请求体里面的参体的参数用以签名的时候，就会遇到request body里面数据只能读取一次，再次读取就null的情况。故这里将解决多次读取request body的解决方案。 扩展HttpServletRequestWrapper，使用请求InputStream和基本缓存字节。并将过滤的优先级设为最前的优先级，是后续再请求体获取数据不至于为空。 @Configuration public cl...
为什么SpringMVC中请求的body不支持多次读取
08-25
这篇文章将详细介绍为什么 SpringMVC 中请求的 body 不支持多次读取，并提供解决方案。 在 Springboot 的项目中，使用 Servlet 的 Filter 来实现方法签名时，发现请求的 body 不支持多次读取。这是因为在 Servlet ...
InputStream重用技巧（利用ByteArrayOutputStream）
热门推荐
IT_Magician的专栏
07-04 1万+
有时间我们需要对同一个InputStream对象使用多次。比如，客户端从服务器获取数据 ，利用HttpURLConnection的getInputStream()方法获得Stream对象，这时既要把数据显示到前台（第一次读取），又想把数据写进文件缓存到本地（第二次读取）。 但第一次读取InputStream对象后，第二次再读取时可能已经到Stream的结尾了（EOFException）或者Str
Java | InputStream读取两次
cxcxrs的博客
09-25 339
在 Java 中，通常情况下不建议对同一个`InputStream`对象直接使用两次，因为`InputStream`是一次性读取的流，读取一次后，流中的位置指针会移动到末尾，再次读取可能无法获取到预期的数据。 但是如果确实需要使用同一个`InputStream`两次，可以采用以下方法：ByteArrayOutputStream缓存文件流。try-with-resources(TWR)方式关闭流资源。
Java解决InputStream流重复使用问题【100%解决】
主要从事JAVA开发，目前是CSDN博客Java领域新星创作者、阿里云博客专家、担任公司研发经理、技术负责人等。热爱编程，喜欢在Python、C、C++领域探索。
07-26 2425
我在做上传文件的时候，第一步要读取文件中的数据进行分析校验，第二步，校验通过后需求将源文件上传OSS，然后使用同一个InputStream流，发现上传OSS的文件为0kb了。
InputStream的重复读取
weixin_42865976的博客
09-11 3987
InputStream的重复读取 问题的引入 流只能读取一次，用System.out.println();打印了流的话 就会导致流被读取了一次 之后再读取的话 就会导致流的使用受到影响 解决方式 ①使用缓存 我们可以使用ByteArrayOutputStream将流数据缓存到内存中，达到多次读取的目的。 /* 利用ByteArrayOutputStream缓存I...
InputStream重复使用问题
qq_41609666的博客
01-30 470
重复使用InputStream
springboot 解决InputStream只能读取一次的问题
04-30
在Spring Boot后端开发中，我们经常会遇到处理上传文件或者接收HTTP请求时，需要多次读取`...在实际项目中，根据具体需求，可能还需要处理更多的细节和异常情况，但以上提供的解决方案已经提供了一个基本的框架。
Java实现inputstream流的复制代码实例
08-25
本文主要介绍了 Java 实现 InputStream 流的复制代码实例，通过示例代码详细地介绍了如何复制 InputStream 对象，并提供了实际的应用场景和解决方案。 InputStream 基础知识 在 Java 中，InputStream 是一个抽象类...
解决SpringBoot中InputStream单次读取问题的有效方法
Resource对象是Spring中定义的一个接口，表示一个资源，它有一个`getInputStream()`方法可以重复调用，从而允许多次读取数据。 以下是使用`InputStreamResource`的一个简单示例： ```java import org.spring...
解决InputStream流无法重复使用的问题
红烧柯基的博客
01-30 746
只能去加日志，打断点调试了，最终发现在校验文件之后，不管是inputStream还是in都是空的了，恍然大悟。由于流读过一次就不能再读了。之前的代码逻辑是用原来的inputStream去校验，然后用赋值后的in去上传文件，开始看到这里也没发现有什么问题，感觉很正常。这个功能之前的同事已经做了一版，一直以为是正常的，毕竟都很久了，但是我用的时候发现上传的文件总是空的，只能去仔细看下代码了。但是这种明显只适用于文件不大的时候，不知道如果文件较大的情况下，该怎么进一步优化，先记录下，后面遇到了再补充。
如何实现对InputStream的多次读取
manong1hao_的博客
10-27 936
学习养成使用AI编程思维
inputStream重复使用消费easyExcel
a984171281的博客
06-28 1244
【当然我也可以每个线程多次下载，但是每次都要连接ftp服务器，自己没有测试过性能，但是觉得不太雅观】但因为是多线程去跑同一个excel 解析多个sheet。就导致流被一个线程消费后别的线程无法使用。从FTP服务器上下载的文件流只能被easyexcel消费一次。clone流，或者把流放到缓存里。我这里采用的是clone多个流出来。方法使用很简单，就不多赘述。
请求中多次调用getInputStream解决方案
最新发布
qq_44541402的博客
10-11 307
在处理HTTP请求时，HttpServletRequest 对象的 getInputStream 方法只能被调用一次。这是因为请求的输入流（InputStream）是一个一次性资源，一旦被读取，就不能再次读取。因此，如果你在同一个请求中多次调用 getInputStream，后续的调用将会返回一个空的输入流或者抛出异常。
在Java中正确地重复使用流（流read后如何重复使用）
九离的博客
01-03 1105
在Java编程中，处理文件和数据流是常见的任务。然而，有时你可能需要多次使用相同的流，这时需要特别小心以确保正确性和性能。在Java中，正确地重复使用流需要细心的管理。关闭流、使用标记点、包装流以及复制流到内存都是一些有效的技术手段。通过谨慎地处理流，我们可以确保程序的正确性和性能。在使用流时，我们需要注意在何时关闭、重置以及如何正确地多次使用它们。有时，我们需要多次使用相同的输入流。在不再需要流的情况下，应该尽早关闭。
复用InputStream
猪头泽兜兜的
08-18 675
InputStream就是Java标准库提供的最基本的输入流。它位于java.io这个包里。java.io包提供了所有同步IO的功能。要特别注意的一点是，InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类。
关于重复使用InputStream对象的
兰亭幽梦
02-09 1786
关于重复使用InputStream对象的解决方法项目中使用Okhttp加载网络图片时，通过response.body().byteStream()获得InputStream流对象， 第一次需要用到该流去获得图片尺寸，而真正取图片显示时又使用了该流，当你去使用BitmapFactory.decodeStream(is, null, ops)获取bitmap时，bitmap总是null。第一次读取In
怎么重复使用inputStream?
我想问问天的专栏
06-30 1290
引语：     之前做项目的时候遇到一个问题,就是从网络中读取的图片要上传到oss,而且要对图片进行裁剪和压缩,其中上传和裁剪都要使用到图片的inputStream, 又因为inputstream不能重复读,导致裁剪是成功的,而上传是失败的.我们今天就提供两种方法来解决,inputStream不能重复读的问题. 问题分析: inputStream的内部有个p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值