精华内容
下载资源
问答
  • 文件流对象
    千次阅读
    2022-02-23 15:49:58

    1 根据文件路径下载文件模板,前端拿到的是stream 文件流
    2 将文件流下载下来

    • 第一步 当然是写请求方法了,如下
    //下载模板
    export function download (params) {
        return request({
            url:'/file/s3/file/xxxxxx.doc',//你懂的
            method:'get',
            responseType: 'blob',//重点 重点 重点 
            params
        })
    }
    
    //记得在axios相应拦截器中 返回相应的blob
    // 判断是否为文件流
        if (response?.headers?.['content-type'] === 'application/octet-stream') {
          return response.data
        }
    
    • 下一步当然是发送请求了
    download().then((result) => {
    	//type 的配置对于我 可有可无,写上为了记录下
            const blob = new Blob([result],{ type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document;charset=UTF-8' })
            this.downloadFile('xxxxx.doc',blob);
          }).catch((err) => {
            console.log(err);
          });
    

    因为使用的vue,所以有个全局配置

    // 下载
    Vue.prototype.downloadFile = (fileName, blob) => {
      if ('download' in document.createElement('a')) {
        // 非IE下载
        const eLink = document.createElement('a')
        eLink.download = fileName
        eLink.style.display = 'none'
        eLink.href = URL.createObjectURL(blob)
        document.body.appendChild(eLink)
        eLink.click()
        // 释放URL 对象
        URL.revokeObjectURL(eLink.href)
        document.body.removeChild(eLink)
      } else {
        // IE10+下载
        navigator.msSaveBlob(blob, fileName)
      }
    }
    
    其他的可以参考如下博文

    两个方案呢哦
    可以看看的
    三人行必有我师焉

    更多相关内容
  • File文件,字节输入,字节输入,字符输入,字节输出的详解 File文件概述 1.File类型:用于表示一个文件或者是文件夹的路径的对象(抽象路径名) 2.路径:用于描述文件或者是文件夹的所在路径的所在的字符串 3....

    File文件,字节输入流,字节输入流,字符输入流,字节输出流的详解

    File文件概述
    1.File类型:用于表示一个文件或者是文件夹的路径的对象(抽象路径名)
    2.路径:用于描述文件或者是文件夹的所在路径的所在的字符串
    3.路径分类:绝对路径和相对路径
    4.绝对路径:从跟目录开始的路径,称为绝对路径,在window中盘符路径就是跟目录,在Linu目录中从根目录开始的路径就是绝对路径
    5.相对路径:相对于某个路径而言的路径,相对于不同的路径,同样的相对路径,表达的是不同的路径
    File文件的构造方法:
    1.File(String path) 把字符的路径,封装成一个File对象
    2.File(String parent,String child) 将父级路径和子级路径封装成File对象,其实就是描述的就是父级路径和子级路径封装的一个路经
    3.File(File parent,String child) 将父级File对象和字级路径封装成一个File对象,其实就是在描述父级路径和资级路径封装的路径

    public class FileDemo01 {
         public static void main(String[] args) {
        	 //将一个字符串串封装成一个file文件对象
    	     File file = new File("x");
    	     System.out.println(file);
    	     
    	     //将一个父级路径和子级路径封装成一个file文件,其实 就是描述的是父级和子级拼接后的路径
    	     File file2 = new File("x/y","z");
    	     System.out.println(file2);
    	     
    	     //将父级File对象和字节路径封装成一个file对象,其实就是父级路径和子级路径的拼接后的路径
    	     File file3 = new File("x/y/z");
    	     file3 = new File("x/y/z","aaa.txt"); 
    	     System.out.println(file3);
    	     
    	 }
    }
    

    File类型的创建方法和删除方法
    1.boolean createNewFile() 创建当前的File对象所描述的路径的文件
    2.boolean mkdir() 创建当前对象的所描述的路径的文件夹(如果父级路径不存在,那么就会自动创建父级路径)
    3.boolean mkirs() 创建当前的File对象所描述的路径的文件夹
    4.delete():删除调用者所描述的文件或者文件夹
    备注:delete在删除文件夹的时候,只能删除空的文件夹,delete不能走回收站

           //创建一个文件
    		File file = new File("x/y/a.txt");
    		file.createNewFile();
    		//创建一个文件夹
    		File nFile = new File("k");
    		nFile.mkdir();
    		//创建多级文键夹
    		File nFile2 =new File("a/b/c/n");
    		nFile2.mkdirs();
    		//删除
    		nFile.delete();
    

    File类型的重名功能
    1.renameTo(File dest)
    调用者是当前的文件或者文件夹的路径对象
    参数列表是变化后的文件或者是文件夹的路径对象
    2.注意事项:
    如果在同一个文件夹下,修改路径就是 重命名
    如果不在同一个文件夹下,修改路径就是剪切

          //重命名方法,实现数据的重名称,如果在不同的目录下相同的文件就是剪切
    	   File file = new File("x/y/a.txt");
    	   File file2 = new File("a/b/c/d/a.txt");
    	   file.renameTo(file2);
    	   //调用者是当前的文件夹或者是目录,被调用者是变化之后的文件夹或者路径对象,如果在相同的目录下就是重命名
    	   File file3 = new File("a/b/c/d/f.txt");
    	   file2.renameTo(file3);
    

    File文件的判断功能和获取功能
    1.exists();判断当前调用者File文件,是否存在
    2.isFile();判断当前调用者是否是文件
    3.isDiretory():判断当前文件是不是文件夹
    4.getAbsolutepath():获取当前File对象的绝对路径
    5.getPath():获取的就是在构造方法中封装的路径
    6.String[] String:获取当前文件夹中的所有的文件和文件夹的名称,到数组中
    7.File[] listFiles():获取当前文件夹的所有的文件和文件夹的File对象在File对象数组中

    File file = new File("a");
    System.out.println(file.exists());       //判断文件是否存在
    System.out.println(file.isFile());       //判断当前调用者是不是文件
    System.out.println(file.isDirectory());  //判读当前的调用者是不是文件夹
    //获取最底层的文件的名称
    File file = new File("a/b/c/d/f.txt");
    //打印构造方法的路径
    System.out.println(file.getName());
    //打印文件的路径
    System.out.println(file.getParent());
    //打印文件的绝对路径
    System.out.println(file.getAbsolutePath());
    

    通过控制台输入一个字符串,判断是否是指定的文件夹下,所有的大于20M的以.wmv的文件的绝对路径?

    package cn.ujiuye.file;
    import java.io.File;
    import java.util.Scanner;
    /**
     * @author liugang
     *
     */
    public class FileTest {
    	public static void main(String[] args) {
    		@SuppressWarnings("resource")
    		Scanner sc = new Scanner(System.in);
    		while (true) {
    			System.out.println("请输入你要查询的路径:");
    			String src = sc.next();
    			if (src.equals("d:/aaa")) {
    				File file = new File(src);
    				File[] listFiles = file.listFiles();
    				//判断该文件夹下所有的大于.20M的所有的文件的绝对路径
    				if (listFiles != null) {
    					for (File file2 : listFiles) {
    						if (file2.isFile() &&file2.getName().endsWith(".wmv") &&file.length() > 20 * 1024 * 1024) {
    							System.out.println(file2.getAbsolutePath());
    						}
    					}
    					break;
    				}
    			} else {
    				System.out.println("您当前输入的路径不对,请重新输入");
    			}
    		}
    
    	}
    }
    
    

    IO概述
    站在内存的角度上,从其他的设备进入内存的,都是输入,从内存到其他的设备的都是输出,I/O就是用于设备之间的进行传递的数据交互的对象的所属的类型。
    字节流
    可以直接操作字节信息的流对象,根据流对象,可以分成字节输入流和字节输出流,顶层父类分别是:InputStream和OuputStream

    InputStream
    1.字节输入流的顶层父类
    2.常用的方法:
    int read(): 从当前的字节流获取一个字节
    int read(byte[] arr):将arr.length个字节,读取到arr中
    InputStream是一个抽象类,不能直接创建对象,只能由子类创建对象
    read():一次读取一个字节,返回值类型是int类型,原因是要把返回的字节的前面加上24个0.无论读取到的是负数还是整数,都会是变成整数,只要是从文件中读取的数据,都是整数,如果返回值是-1,说明不是从文件中读取的数据,而是专门为方法准备的文件末尾的标记,说明:虽然每次都调用了该方法,但是返回的却不同,因为文件的指针不断的向后移。

           //创建字节输入流对象,将输入流从磁盘的文件中读取到计算机的内存中
    		FileInputStream fis = new FileInputStream("a.txt");
    		//读取的字节
    		int ins;
    		while((ins = fis.read())!=-1) {
    			System.out.println((char)ins);
    		}
    		//关闭流
    		fis.close();
    
     public class FileInPutStreamDemo03 {
    	public static void main(String[] args) throws IOException {
    		//创建字节输入流对象,将输入流从磁盘的文件中读取到计算机的内存中
    		FileInputStream fis = new FileInputStream("a.txt");
    		byte[] arr = new byte[2];
    		//显然将你读取到的数据写到文件中去
    		int len =fis.read(arr);
    		System.out.println(Arrays.toString(arr) + ">>>" +new String(arr,0,len)+">>>"+len);
    		
    		len =fis.read(arr);
    		System.out.println(Arrays.toString(arr) + ">>>" +new String(arr,0,len)+">>>"+len);
    		
    		fis.close();
    	}
    }
    

    OutputStrea字节输出流
    1.字节输出流的顶层父类
    2.常用方法:
    write(int b) :将一个字节信息写到指定的设备中
    write(byte[] arr):将一个字节的所有的信息,写到指定的设备中
    write(byte[] arr,int offsert,int len):将一个字节数组从arr中的offert索引开始,共len字节写到指定的设备中
    3.字节输出流
    FileOutputStream(File f) 将f的描述的路径封装成字节输出流对象
    FileOutputStream(String path):将path描述的文件路径封装成字节输出流对象,使用字节输出流写入数据,关联到文件中

    package cn.ujiuye.inputOut;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * @author liugang
     *
     */
    public class FileOutStreamDemo06 {
        public static void main(String[] args) throws IOException {
        	//创建一个文件输出流对象
    		FileOutputStream fis = new FileOutputStream("y.txt");
    		//声明一个数组
    		byte[] arr = {100,101,102};
    		//fis.write(arr);
    		//将数组指定的元素填到指定的位置
    		fis.write(arr,0,2);
    		fis.close();
    	}
    }
    
    package cn.ujiuye.inputOut;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * @author liugang
        *    一个一个的拷贝
     */
    public class FileOutStreamDemo05 {
        public static void main(String[] args) throws IOException {
        	//创建一个文件输入流对象
        	FileInputStream fis = new FileInputStream("y.txt");
        	//创建一个文件输出流对象
    		FileOutputStream fos = new FileOutputStream("y.copy.txt");
    		int read;
    		while((read = fis.read())!=-1){
    			fos.write(read);
    		}
    		//关闭字节
    		fos.close();
    		fis.close();
    		
    	}
    }
    
    

    高效缓存流
    1.BufferedInputStream和BufferOutputStream
    2.是包装类型:本身不具备读写的功能,只是在具体的流对象的基础上,对其进行加强,例如FileInputStream和FileOutputStream,原本的效率较低,加强之后,就效率较高。

    package cn.ujiuye.inputOut;
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * @author liugang
        *    一个一个的拷贝
     */
    public class BufferedOutStreamInputStream {
        public static void main(String[] args) throws IOException {
        	
        	long start = System.currentTimeMillis();
        	//创建一个文件输入流对象
        	FileInputStream fis = new FileInputStream("aa.avi");
        	//创建一个文件输出流对象
    		FileOutputStream fos = new FileOutputStream("bb.avi");
    		//加强版的输入流和输出流  高效缓存流
    		BufferedInputStream in = new BufferedInputStream(fis);
    		BufferedOutputStream out =  new BufferedOutputStream(fos);
    		//从文件中读取数据
    		int read;
    		while((read = in.read())!=-1) {
    			//把数据从内存中写到文件中去
    			out.write(read);
    		}
    		//关闭字节
    		in.close();
    		out.close();
    		long end = System.currentTimeMillis();
    		System.out.println(end - start);
    	}
    }
    
    

    字符流
    使用字符流处理字符的问题:
    1.使用字节流写字符
    可以使用,但是要先把字符串转化成字节数组,再储存在文件中,比较麻烦
    2,使用字节流读取字符
    如果是纯文本可以一次读取一个字节
    如果是存中文,可以一次读取两个字节(GBK)
    如果是中英文混砸,每次不知道读取多少字节,因此无论字节数组准备多大都会出现乱码
    解决方法:
    在GBK编码中,如果是一个英文,那么读取的字节是正数,如果读取的是正数,那么就可以断定是英文字符,就读取一个字节转化为字符即可。
    在GBK编码,如果是一个中文,那么就一定读取的是第一个字节是负数,如果读取的是一个负数,就说明读取到的就是一个中文,两个字节一起转化为字符。
    字符流的使用
    1.顶级顶层父类:Reader Writer
    2.常用方法:
    Reader:
    read():读取一个字符,返回值如果是-1,表达到达文件的末尾
    read(char[] arr):将一堆字符储存在一个字符数组中
    Writer:
    writer(int c):写出一个字符
    write(String str):写出一个字符串
    write(将一个字符数组的所有的内容写出)
    write(char[] arr,int offset,int len):将字符数组的一部分写到目标中
    3.抽象类不能直接创建子类。需要具体的子类来创建
    4.使用FileReader和FileWriter可以作为创建对象的类型

    public class FileReaderDemo01 {
        public static void main(String[] args) throws IOException {
    		//加载字符输入流对象
        	FileReader reader = new FileReader("a.txt");
    		//循环遍历,实现数据的读取操作,每次内部会根据其数据的特点会分配空间
        	int b;
    		while((b = reader.read()) != -1) {
    			System.out.println(b + "::" +(char)b);
    		}
    		reader.close();
    	}
    
    public class WriterDemo02 {
        public static void main(String[] args) throws IOException {
    		//字符输出流
        	FileWriter wr = new FileWriter("a.txt",true);
    		//直接写入你想写入的对象
        	wr.write("你好你好呀");
    		wr.write("谢女士,请问你还好吗?");
    		wr.write("加油");
    		wr.write("love");
    		wr.close();
    	}
    }
    
    public class WriterDemo03 {
        public static void main(String[] args) throws IOException {
    		//字符输入流
        	FileReader fr = new FileReader("a.txt");
        	//字符输出流
        	FileWriter wr = new FileWriter("a_copy.txt");
        	
        	//循环遍历数据实现复制操作
        	int b;
        	while((b = fr.read())!= -1) {
        		wr.write(b);
        	}
        	//关闭流对象
        	fr.close();
        	wr.close();
    	
    	}
    }
    

    字符流的拷贝
    1.使字符输入流读取信息,使用的字符流出流写出信息,完成文件的使用字符流拷贝
    2.字符流拷贝的必要性:
    没有必要使用字符流来进行拷贝,因为字符流会先将字节信息转化为字符,读取到内存中,最后还有把字符信息转化为字节信息,写到另外的一个文件中,中间做了两个没有意义的相反的操作,浪费了时间.
    应用场景:
    1.如果是在读取到字符以后,需要人为的阅读和修改这个字符,那么就使用字符流
    2.如果只是简单的将信息进行转移或者是拷贝,就不需要转成字符了
    在这里插入图片描述

    public class FileReaderDemo03 {
        public static void main(String[] args) throws IOException {
    		//创建字符输入流和字节输出流
        	FileReader fr = new FileReader("a.txt");
    		FileWriter fw = new FileWriter("a_capy1.txt");
    		//创建数组,一次读入一组字符,加快读的效率
    		char[] chs = new char[1024*8];
    		int b;
    		while((b = fr.read(chs))!=-1) {
    			fw.write(chs,0,b);
    		}
    		fr.close();
    		fw.close();
    	}
    }
    
    
    

    字符流不能操作非纯文本文件:因为当字符流读取到一个字节的时候,需要查询编码表是不是非纯文本,如果是,就有可能读取的字符无法转化成对应的字符,因为这个字节信息在编码表中没有对应的字符,就只能使用英文的?来代替,这一步就是对内容进行篡改,字符信息,后面再转化就不可能正确了.

    高效缓存字符流和高效缓存字节流基本上类似,就不多介绍了,下面举个例题来介绍一下:将文件夹中的第一行转化成最后一行,第二行转化成倒数第二行?

    package cn.ujiuye.writerreader;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author liugang
     *
     */
    public class BufferReadWriterTest {
        public static void main(String[] args) throws IOException {
        	//定义一个缓存字符输入流
    		BufferedReader br = new BufferedReader(new FileReader("x.txt"));
    		//定义一个集合
    		List<String> list = new ArrayList<String>();
    		//集合遍历
    		String line;
    		while((line = br.readLine())!=null) { //一行一行的读入数据,便于反转时读出方便
    			list.add(line);
    		}
    		br.close();
    		//定义一个字符输出流
    		BufferedWriter bw = new BufferedWriter(new FileWriter("x_copyfan.txt"));
    		//遍历集合倒序输出
    		for(int i = list.size()-1;i >= 0;i--) {
    			bw.write(list.get(i));
    			bw.newLine();              //换行操作
    		}
    		bw.close();
    	}
    }
    
    
    展开全文
  • //生成blob对象 console.log(blob) link.style.display = "none"; link.href = URL.createObjectURL(blob); link.setAttribute("download", "冲突设备" + ".xls"); //下载的文件名以及文件格式 document.body....
    this.$axios({
            url: "/api/getblob",
            method: "post",
            headers: {
              "Content-Type": "multipart/form-data",
              token: localStorage.getItem("token"),
            },
            data: formData,
            responseType: "blob",//关键点
          }).then((res) => {
              console.log(res);
              //下载文件操作
              const link = document.createElement("a");
              let blob = new Blob([res.data], { type: "application/vnd.ms-excel" });//生成blob对象
              console.log(blob)
              link.style.display = "none";
              link.href = URL.createObjectURL(blob);
              link.setAttribute("download", "冲突设备" + ".xls"); //下载的文件名以及文件格式
              document.body.appendChild(link);
              link.click();
              document.body.removeChild(link);
          });
    
    展开全文
  • 接口返回二进制文件流,前端通过blob对象实现下载

    万次阅读 热门讨论 2018-09-06 16:15:57
    但是在某些情况下,接口会返回一个二进制文件流,在控制台打印或者network的preview中就是一串看不懂的字符串(下图) 第一次遇到的时候也是一脸迷茫,就顺着惯性思维总觉得接口返回的不对。但其实只是自己技术...

    场景:项目中请求图片或者下载文件一般情况下都是接口返回url或者接口本身就是一个get请求访问接口直接下载。但是在某些情况下,接口会返回一个二进制文件流,在控制台打印或者network的preview中就是一串看不懂的字符串(下图)

    第一次遇到的时候也是一脸迷茫,就顺着惯性思维总觉得接口返回的不对。但其实只是自己技术有限,没有接触到而已。这就是接口返回的文件的二进制流,通过js的Blob对象是可以转成文件下载下来的。

    二进制流转图片:如果接口返回的是个图片,前端需求是展示这个图片,可以直接将api放到img标签的src中,和普通ajax请求的接口一样,这样在浏览器network中可以看到这个图片和请求一样,不过类型成了img类型的。

    二进制流下载:借助blob对象,直接贴代码

          let xhr = new XMLHttpRequest()
          let fileName = 'file.docx' // 文件名称 
          xhr.open('GET', Api, true)
          xhr.responseType = 'arraybuffer'
          xhr.setRequestHeader(token, 'xxxxx') // 请求头中的验证信息等(如果有)
          xhr.onload = function() {
            if (this.status === 200) {
              let type = xhr.getResponseHeader('Content-Type')
    
              let blob = new Blob([this.response], {type: type})
              if (typeof window.navigator.msSaveBlob !== 'undefined') {
                /*
                 * IE workaround for "HTML7007: One or more blob URLs were revoked by closing
                 * the blob for which they were created. These URLs will no longer resolve as 
                 * the data backing the URL has been freed." 
                 */
                window.navigator.msSaveBlob(blob, fileName)
              } else {
                let URL = window.URL || window.webkitURL
                let objectUrl = URL.createObjectURL(blob)
                if (fileName) {
                  var a = document.createElement('a')
                  // safari doesn't support this yet
                  if (typeof a.download === 'undefined') {
                    window.location = objectUrl
                  } else {
                    a.href = objectUrl
                    a.download = fileName
                    document.body.appendChild(a)
                    a.click()
                    a.remove()
                  }
                } else {
                  window.location = objectUrl
                }
              }
            }
          }
          xhr.send()

    09/12更新:

    在接口做验证的时候,如果验证失败,接口返回json信息,但是由于设置了responseType='arraybuffer',这时候this.response将不再是json字符串,而是ArrayBuffer对象,要处理它来将后台返回的信息展示出来。

    let uint8 = new Uint8Array(this.response) // 提取uint8Array
    let resToString = decodeURIComponent(escape((String.fromCharCode(...uint8)))) // 解决乱码

    得到的resToString就是后台返回的json字符串了。

    只通过String.fromCharCode会出现中文乱码的情况

    展开全文
  • 使用ajax提交文件流对象

    千次阅读 2016-12-21 14:36:05
    var files = document.getElementById("upfile").files; var url = ""; // FormData 对象 var form = new FormData();// 可以增加表单数据 form.append("file", files[0]);// 文件对象 $.a
  • 参数response 是文件流传输必须的, 然后chatFileParam是业务需要用来获取服务器文件的,你们可以不看,不写 /** * 页面下载文件 * @param response * @param chatFileParam */ @ApiOperation(value = ...
  • 这里写自定义目录标题后台传文件流blob对象前端下载文件问题解决方案,转成bolb对象创建Blob对象创建链接 后台传文件流blob对象前端下载文件 问题 在页面下载文件时,可以根据路径如 a 标签的 href="" ,但是有时将...
  • 接口返回文件流,转为blob和file对象

    千次阅读 2021-08-17 15:56:41
    // 先把文件流地址转为blob类型 var request = new XMLHttpRequest(); request.open('GET', url, true); request.responseType = 'blob'; request.onload = function(res) { // 把blob转为File类型 const file = ...
  • 最近在使用websocket时遇到了文件对象的传输问题:对于前端页面传来的文件流、字符串需要转为文件对象再传输给api接口。那么首先想到的是将文件流或字符串存入文件再从直接读取以获取文件文件对象,这种方式固然可行...
  • 文件和文件流

    万次阅读 多人点赞 2019-08-08 20:16:26
    文件和文件流 1. File类 Java.io.File类可以获取文件以及文件夹的一些基本的属性 常用的方法 文件名称,路径,大小,判断是否存在,删除,创建 // 创建一个文件对象(可以是文件,可以是文件夹) File file = new ...
  • PostMan处理文件流,上传和下载文件流 一.遇到的问题 postman 进行call api的时候,如果得到的是文件,将会出现一堆乱码 二.解决方案 这时候可以直接下载 在返回body的右上角下载保存就行 也可以在call api的时候就...
  • C++:流文件做为函数的参数

    千次阅读 2018-11-06 10:45:20
    ofstream LOG; int i = 5; int j = 8; LOG.open("LOG.txt", ios::app); calculation(i, j, LOG);...////////////////////////////////////////////////////// calculation(int i, int j, ofstream &...
  • 怎么把文件对象转化为字节

    千次阅读 2019-10-17 15:14:48
    //创建字节对象 byte[] buffer; File file = new File("d://文件转字节测试文档.txt"); FileInputStream fis = new FileInputStream(file); ByteArrayOutputStream baos = new ByteArrayOutputStream(fis....
  • js 文件与文件流之间互换

    千次阅读 2019-09-17 14:48:10
    直接看代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="ie=edge">...js文件间互换</title> &...
  • 前端获取后端返回的文件流并下载

    千次阅读 2021-08-19 22:17:45
    ⏹前端获取后端返回的文件流并下载
  • 需求:前端接收并展示后端返回的一个图片对象文件流),没有图片的时候,显示默认图片。
  • 正常返回的数据是 可以读成图片 但是异常的时候返回的是对象(字段) 这种时候需要判断情况,就是说分别获取流文件对象信息,而Response.body()这个只能用一次,所以推出这个解决方法 import okhttp3.*; import ...
  • java 文件读取

    千次阅读 2021-03-07 08:56:42
    其中第一个步骤由系统完成,只需要创建对应的流对象即可,对象创建完成以后步骤1就完成了,第二个步骤使用输入流对象中的read方法即可实现了。使用输入流进行编程时,代码一般分为3个部分:1、创建流对象,2、读取...
  • 实现表格导出功能时,后端接口返回一堆看不懂的乱码,第一反应是不是接口出错了,其实不是,后端直接返回了一个二进制,前端需要通过blob对象来实现文件下载功能。 后端返回结果如下: 代码如下: let param = {}...
  • vue 接收后端文件流 并下载

    千次阅读 2021-11-09 16:37:49
    在vue框架中, 接收并下载文件流(blob对象)  可以通过将其转成blob对象,添加到a标签或者iframe标签中来模拟下载(或者pdf预览) 1.首先设置responseType对象格式为 blob:  responseType:‘blob’ 在项目reques....
  • Java实现文件写入——IO

    千次阅读 2021-02-12 14:52:34
    输入输出的重要性:输入和输出功能...Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类...
  • js 通过文件地址URL转为File文件对象

    千次阅读 2022-07-05 17:32:39
    通过文件地址URL,将所指文件转为File文件对象
  • C++流对象

    千次阅读 2017-09-14 21:16:18
    在程序设计当中免不了要对数据进行输入输出,在C语言中我们经常使用scanf()、printf()进行输入输出操作,但是在C++中,我们使用流对象来对数据进行输入输出操作,流在输入源和输出目标之间充当了桥梁的作用。...
  • axios下载文件流处理返回值

    千次阅读 2020-06-23 10:42:07
    1、文件流 2、json 对象 responseType 值的类型 值数据类型''DOMString(默认类型)arraybufferArrayBuffer 对象blobBlob 对象documentDocumnet 对象jsonJavaScript object, parsed from a JSON string returned by ...
  • 前端音频文件流

    千次阅读 2021-01-12 10:37:58
    前端H5语音插件demo,语音二进制流转成audio可播放格式 ... blob语音 前端播放 ...前端H5中JS用FileReader对象读取blob对象二进制数据,文件传输 https://www.cnblogs.com/dongxixi/p/11005607...
  • Java返回文件流给前端

    千次阅读 2022-03-03 17:11:07
    import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind....
  • js实现文件流下载文件

    千次阅读 2022-02-15 13:47:57
    则是向指定的url提交数据 // 文件流转blob对象下载 function downloadFile(data, type, fileName) { let blob = new Blob([data], {type: `application/${type};charset=utf-8`}); // 获取heads中的filename文件名 ...
  • C#数据流:文件流、内存流、网络流

    千次阅读 2017-10-06 16:28:56
    System.IO下的Stream类是所有数据的基类,当我们对数据进行逐字节操作时,首先需要将数据转换为数据。C#数据主要分为三类:FileStream、MemoryStream、NetworkStream,还有常用的StreamReader、S
  • java中文件的输入(FileInputStream)和输出(FileOutputStream),使用场景是什么,通过二者实现文件内容的写入和读取
  • 将Java对象写入文件

    千次阅读 2021-03-06 03:50:20
    对象的序列化指将一个Java对象写入IO中,与此对应的反是,对象的反序列化则指从IO中恢复该Java对象。如果需要需要让某个对象支持序列化机制,则必须让它的类是可序列化的(serializable)。为了让某个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 903,716
精华内容 361,486
关键字:

文件流对象

友情链接: 7405239.rar