Java中的IO介绍

本章内容

一 、File概念

File可以代表一个目录或者一个文件，并不能代表文件的内容 文件和流的区别：File关注的是文件本身的特征，如名称、路径、修改时间、大小。 流关注的是文件的内容。

二、File基本的操作

  1. 常见构造方法

    | File(String pathname) | 建立一个以pathname为路径的File对象， pathname可以是相对路径，也可以是绝对路径。 | | ———————————————— | —————————————————————————————— | | File(String parent,String child) | 建立一个以parent加上child为路径的File对象 | | File(File parent,String child) | 建立一个以parent加上child为路径的File对象 |

    注意：文件的路径如果考虑跨平台，就使用File.seperator

    相对路径：javase程序中，相对参照点为项目目录 src/test.项目目录下的src/test 绝对路径：e:/test

  2. 创建文件操作

    mkdir:创建单层目录 dir1/dir2:必须保证dir1是存在的，才能成功创建dir2 mkdirs：创建层级目录 dir1/dir2：如果dir1不存在，会先创建dir1,再创建dir2 createNewFile:创建文件 dir1/a :必须保证dir1是存在的，否则，会报系统找不到指定的路径的异常

  3. 文件的常用读操作（文件名称、文件名称）

    exists() //文件或者目录是否存在 isFile() //是否是文件 isDirectory() //是否是目录 getName() //取文件或者目录的名字 getPath() //取文件或者目录的路径 getAbsolutePath() //取文件绝对路径 lastModified() //最后修改日期 length() //文件或者目录的字节大小 list()//获得当前File对象所表示目录下的文件和目录名称，返回String[]类型的数据。 listFiles()//获得当前File对象所表示目录下的文件和目录，返回File[]类型的数据。

    代码实例

  4. 修改文件名称

    注意：修改的新文件名需要是不存在的 ,如果修改前后的目录一致，那就是重命名的效果，如果修改前后目录不一致，相当于会删除旧目录中的文件，以新的名称出现在新目录中

    //      File file = new File(baseDir,"11.txt");
//      file.renameTo(new File(baseDir,"bbb/111.txt"));

  5. 删除文件

            File file = new File(baseDir,"2.txt"); file.delete();

  6. 删除文件夹

    递归：

    1、自己调用自己

    2、必须要一个条件

    private static void myDelete(File dir) {// TODO Auto-generated method stubif(dir.isDirectory()) {File[] listFiles = dir.listFiles();for (File file : listFiles) {if(file.isDirectory()) {myDelete(file);}file.delete();}dir.delete();}}
​

  • 得有一个明确的递归出口(什么情况下不递归了)

  • 递归算法代码简洁，但是效率比较低

    1到n的累加和执行过程：

    | n=1 | 0x01 return 1 | fun(1) =1 | | —— | ———————- | ———————————- | | n=2 | 0x02 2+fun(1) | fun(2) =2+fun(1)=2+1=3 | | n=3 | 0x02 ：3+fun(2) | fun(3)= 3+fun(2)=3+3=6 | | n=4 | 0x02 ：4+fun(3) | fun(4)=4+fun(3)=4+6=10 | | n=5 | 0x02: 5+fun(4) | fun(5)=5+fun(4)=5+10=15 | | 栈底 | | |

    入栈：记录信息

    出栈：根据入栈记录的信息计算结果 fun(1) fun(2) ….. fun(5)

    public static int fun(int n){if(n<=1){return 1;           //0x01}else{return n+fun(n-1);  //0x02}}

public static void deleteFile(File f){        if(!f.exists()){           return;        }        //如果是一个文件        if(f.isFile()){            f.delete();//删除文件            System.out.println("删除文件"+f.getName());        } //如果是一个目录 if(f.isDirectory()){File fs[]=f.listFiles();//满足这个条件，不是空目录if(fs.length>0){for(File subFile:fs){deleteFile(subFile);}}//删除空目录 f.delete();System.out.println("删除目录"+f.getName());}    
}
三、流的概念

File类关心的是磁盘上存储的文件位置和名称等，而流是指程序运行中的数据通信信道，当然流类所关心的是文件的内容。

四、流的分类

根据流向分为：输入流，输出流

根据传输单位:字节流，字符流

根据是否和数据源可以直接交互:节点流，处理流

节点流：可以和数据源直接交互，FileInputStream,FileOutPutStream,FileWriter,FileReader

处理流：需要连接嵌套其它的流使用,BufferedReader,BufferedWriter

五、流的四个根类

  1. InputStream（字节输入流）

    • FileInputStream:节点流，字节输入流，按照字节为单位读文件，文件复制

    • ObjectInputStream：处理流，对象输入流，需要嵌套一个字节输入流进行使用，如FileInputStream，反序列化

  2. OutputStream（字节输出流）

    • FileOutputStream：节点流，字节输出流，按照字节为单位写，文件复制

    • ObjectOutPutStream：处理流，对象输出流，需要嵌套一个字节输出流，如FileOutputStream进行使用，序列化

  3. Reader（字符输入流）

    • FileReader：节点流，针对文件的字符输入流，以字符为单位读文件，存在乱码问题，不能直接按行进行读

    • BufferedReader：处理流，带缓冲区的字符输入流，以行为单位读文件 readLine:返回值为null表示读取结束

    • InputStreamReader：处理流，转换流（可以将字节流转换为字符流）,需要嵌套节点流使用，读文件的指定字符集编码，解决乱码问题

  4. Writer

    • FileWriter：节点流，针对文件的字符输出流，以字符为单位写文件，存在乱码问题，不能直接按行写

    • BufferedWriter ：处理流，带缓冲区的字符输出流，按照行写字符，newLine

    • OutPutStreamWriter：处理流，转换流（可以将字节流转换为字符流），需要嵌套节点流使用，写文件的时候指定字符集编码，解决乱码问题

六、字节流

  1. FileInputStream

    常用api

    FileInputStream是InputStream的子类。 FileInputStream是读取文件的字节输入流。 FileInputStream常用的构造方法： FileInputStream(File file) FileInputStream(String filename) FileInputStream覆盖实现了父类如下方法： int available() void close()

    字节输入流的代码结构

    ​
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
​
public class StreamDemo {
​public static void main(String[] args) throws IOException {//字节流//1、建立文件源（数据源的一种）File file = new File("src/1.txt");//2、建立流链接文件源FileInputStream input = new FileInputStream(file);//3、读取数据int read = input.read();byte[] bs = new byte[1024];int len = input.read(bs);int read2 = input.read(bs, 2, 5);//使用数据//4、关闭流input.close();}
​
}
​

    int read():一次读取1个字节，返回值表示读取的一个字节的数据（一个字节的数据不一定表示一个字符的编码），返回值为-1表示读取结束

    import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
public class StreamDemo {
​public static void main(String[] args) {//字节流//public abstract class InputStreamFile file = new File("src/1.txt");try {//如果是输入流，文件必须存在FileInputStream fileInputStream = new FileInputStream(file);int n;//read()读取流中的数据while((n=fileInputStream.read())!=-1) {System.out.println(n);}//关闭流fileInputStream.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}
​}
​
}
​

    int read(byte[ ] b)：将文件中读到的数据放到数组中，返回值为读取到的字节长度，返回值为-1表示读取结束

    ​
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
​
public class StreamDemo {
​public static void main(String[] args) {//字节流//public abstract class InputStreamFile file = new File("src/1.txt");try {//如果是输入流，文件必须存在FileInputStream fileInputStream = new FileInputStream(file);byte[] bs = new byte[1024];//int read(byte b[]) 将文件中的所有数据读到字节数组中（bs）//返回值是读取了多少个字节int len = fileInputStream.read(bs);
//          System.out.println(Arrays.toString(bs));
//          System.out.println(len);String str = new String(bs);System.out.println(str.trim());//关闭流fileInputStream.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}
​}
​
}
​

    int read(byte[] b,int off,int len)：将文件中读到的数据放到数组中的指定位置，指定长度，返回值为读取到的字节长度，返回值为-1表示读取结束

    import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;public class StreamDemo {public static void main(String[] args) {//字节流//public abstract class InputStreamFile file = new File("src/1.txt");try {//如果是输入流，文件必须存在FileInputStream fileInputStream = new FileInputStream(file);//			int n;
//			//read()读取流中的数据，每次读取一个字节
//			while((n=fileInputStream.read())!=-1) {
//				System.out.println(n);
//			}byte[] bs = new byte[1024];//int read(byte b[]) 将文件中的所有数据读到字节数组中（bs）//返回值是读取了多少个字节//第一个参数bs存了读取的数据//第二个参数1设置了bs数组从下标1的位置开始存//第三个参数3设置了从文件中读取几个字节int len = fileInputStream.read(bs,1,3);System.out.println(Arrays.toString(bs));System.out.println(len);String str = new String(bs);System.out.println(str);//关闭流fileInputStream.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

    注意：read（）和int read(byte[ ] b)方法返回值代表的意义

  2. FileOutputStream

    FileOutputStream是OutputStream的子类 FileOutputStream是写入文件的字节输出流 FileOutputStream常用的构造方法： FileOutputStream(File file) FileOutputStream(String filename) FileOutputStream(File file,boolean append) FileOutputStream(String filename,boolean append) FileOutputStream覆盖实现了父类如下方法： void close() void flush() void write(int b) ：写入一个字节的数据，参数就是要写入的数据的编码

    void write(byte[] b) ：将数组中的数据写到文件中，数组中存放的是字符的编码

    void write(byte[] b,int off,int len）：将数组指定位置指定长度的数据写入的文件中

    import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class OutputStreamDemo {public static void main(String[] args) throws IOException {//FileOutputStream//按照单位，字节流//按照方向，输出流//按照是否跟源进行关联，节点流//1、声明文件源File file = new File("src/output.txt");//2、创建字节输出流FileOutputStream fos = new FileOutputStream(file);//3、写出数据String str = "abcdefg";
//		for(int i=0;i<str.length();i++) {
//			fos.write(str.charAt(i));
//		}fos.write(str.getBytes(), 1, 3);//4、关闭流fos.close();}}

  3. 文件复制

    import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class CopyDemo {public static void main(String[] args) throws IOException {//文件复制File sourceFile = new File("G:\\video\\20220530-1-File概念.mp4");File targetFile = new File("f:\\64\\1.mp4");FileInputStream input = new FileInputStream(sourceFile);FileOutputStream output = new FileOutputStream(targetFile);//缓存可以减少io次数，可以大大的提升速度byte[] bs = new byte[1024*8];int len;while((len=input.read(bs))!=-1) {output.write(bs);bs = new byte[1024*8];}input.close();output.close();sourceFile.delete();}}

七、字符流

字符流：适合读写文本字符（按照字符读取，不能直接按照行读取）

  1. FileReader

    • 常用API:

      int read() ：一次读一个字符，返回值是读到的一个字符的编码，-1表示读取结束

      int read(char[] cbuf) ：返回值表示读取到字符的个数，参数表示存放读取到的数据的数组

      int read(char[] cbuf,int off,int len)：返回值表示读取到字符的个数，参数表示存放读取到的数据的数组

      void close()

  2. FileWriter

    • 常用API:

      void write(int ch) :写入单个字符到调用的输出流。

      void write(String str) :写入str到输出流。

      void write(String str, int off, int len),写入字符串的某一部分。

      void write(char[] cbuf)

      void write(char[] cbuf,int off,int len):写入字符数组的某一部分。

      void flush() :清空输出缓冲区。

      void close() ：关闭输出流。

import java.io.File;
import java.io.FileReader;
import java.io.IOException;public class CharIODemo {public static void main(String[] args) throws IOException {//Reader	字符输入流的父类//FileReader 文件字符输入流FileReader fr = new FileReader(new File("src/1.txt"));int n;while((n=fr.read())!=-1) {System.out.println((char)n);}char[] cs = new char[1024];while(fr.read(cs,1,3)!=-1) {System.out.println(new String(cs).trim());cs = new char[1024];}fr.close();//FileWriter 文件字符输出流//		FileWriter fw = new FileWriter(new File("src/1.txt"));fw.write("你吃了么?".toCharArray());fw.write(25105);fw.write((int)'我');
//		//参数为Stringfw.write("人情味儿发我放散阀");
//		fw.close();}}

八、嵌套流

流对象被其他处理流的多次连接，称为流的嵌套。

直接与数据源相连接的流是节点流

处理流连接节点流，提供附加性能

处理流可以被其它处理流继续连接，以获取需要的其它性能。

处理流不可以与节点（数据源）直接连接

image-20210721145536019

九、缓冲流

默认带了8192个字符的缓冲区，是为了提高性能，减少频繁和硬盘进行io的次数，

BufferedReader:处理流，字符输入流，是Reader的子类提供了readLine方法，很实用

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;public class BufferedReaderDemo {public static void main(String[] args) throws IOException {// BufferedReader//生成数据源File sourceFile = new File("src/1.txt");//生成节点流FileReader fr = new FileReader(sourceFile);//生成处理流 缓冲流BufferedReader br = new BufferedReader(fr);//boolean ready()返回true，则可以读while(br.ready()) {//String readLine()可以读出文件中的一行内容，如果没有则返回nullSystem.out.println(br.readLine());}br.close();}}

获得所有学生，并返回集合

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;public class StuDemo {public static void main(String[] args) throws IOException {//文件中读取内容，先封装成学生对象，再封装到集合中List<Stu> stuList = new ArrayList<Stu>();BufferedReader br = new BufferedReader(new FileReader(new File("src/stu.txt")));while(br.ready()) {//1,张三,18String stuStr = br.readLine();//{"1","张三","18"}String[] arr = stuStr.split(",");Stu stu = new Stu(Integer.parseInt(arr[0]),arr[1],Integer.parseInt(arr[2]));stuList.add(stu);}br.close();for (Stu stu : stuList) {System.out.println(stu);}}}

BufferedWriter:处理流，字符输出流，是Writer的子类，提供了newLine() write(str)方法

写入一个学生

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;public class BufferedWriterDemo {public static void main(String[] args) throws IOException {//BufferedWriterFile file = new File("src/stu.txt");//第二个参数为是否追加，true为追加写，false为覆盖写FileWriter fw = new FileWriter(file,true);BufferedWriter bw = new BufferedWriter(fw);Stu stu = new Stu(5,"田七",23);String str = stu.getSid()+","+stu.getSname()+","+stu.getSage();bw.write(str);bw.newLine();bw.close();}}

十、序列化

  1. 对象流

    • 对象输入流（ObjectInputStream）：

      ObjectInputStream in=newObjectInputStream(输入流对象);

      相应的方法：in.readObject();

    • 对象输出流（ObjectOutputStream）：

      ObjectOutputStream out=new ObjectOutputStream(输出流对象);

      相应的方法：out.writeObject(Object obj);

  2. 序列化

    • 序列化：就是将对象的内容分解成字节流，以便存储在文件中或在网络上传输。

      属性的要求：非transient 非静态 是可序列化类型（Serializable）

    • 反序列化：就是打开并读取字节流，且从该流中恢复该对象

      没有执行过反序列化的类型对应的代码块及构造方法

      能够序列化的对象必须是Serializable类型，对应的类型必须实现Serializable接口

    序列化类型中一般会要求提供一个serialVersionUID，作用是保证读（反序列化）和写（序列化）的过程中类型版本的一致性。如 写的时候版本id为1 那么读的时候版本id也必须是1，才能成功

     public static void write1() throws IOException{         //处理流           ObjectOutputStream writer=new ObjectOutputStream(new FileOutputStream(new File("src/data")));         for (int i = 0; i < 10; i++) {             Goods goods=new Goods("00"+i, "商品"+i, i+10.1f);             writer.writeObject(goods);        }         writer.flush();         writer.close();         }     
public static void read1() throws IOException, ClassNotFoundException{         //处理流           ObjectInputStream reader=new ObjectInputStream(new FileInputStream(new File("src/data")));         while(true){             try {                Object obj=reader.readObject();                System.out.println(obj);            } catch (EOFException e) {//EOFException:表示文件读取到末尾了                // TODO Auto-generated catch block                System.out.println("读取结束");                break;            }}reader.close();
}

    注意：使用EOFException判断文件是否读取到末尾

问题描述： 用类ObjectOutputStream向文件写读对象时，碰到一个问题：新建一个文件，用输出流ObjectOutputStream向文件连续写几个对象，关闭输出流，然 后读取，这些对象都可以读出；这时在向该文件增加对象，新写的对象就读不出了

问题出现的原因： ObjectOutputStream建立后第一次写入一个对象时， 会在对象数据前写入一些标志的数据“AC ED 00 05”（用二进制方式查看打开），应该是流相关的信息。当你关闭 ObjectOutputStream 后再重新打开往文件里面写对象时（append方式），就会再一次把“AC ED 00 05”写入文件，而这些信息并不是你写入对象的数据，所以当你用ObjectInputStream来读取对象时，流会将除第一个“AC ED 00 05”以外的数据当作各个对象的数据，造成无法解析，所以读取时有一个java.io.StreamCorruptedException出现。 这个可以通过编辑Info.dat来验证，只要将“AC ED 00 05”删除（第一个“AC ED 00 05”保留）就可以正常读出后来加入的对象。 给出一个比较笨的解决方法： 在以后要添加新的对象到Info.dat时，将里面原有的对象读出放入ArrayList中，清空文件，再将对象集一次写入。

尝试解决办法:

那个“AC ED 00 05”是 ObjectOutputStream.writeSystemHeader()写进去的，你可以继承ObjectOutputStream类，覆盖这个方法。 在你自己的writeSystemHeader()里判断是不是第一次写入一个文件，如果是向一个文件大小不为零的文件追加的话，就调用 super.reset(),如果是第一次写这个文件，不是追加，就调用super.writeSystemHeader()

/** * 此类继承ObjectOutputStream，重写writeStreamHeader()方法,以实现追加写入时去掉头部信息 */  
public static class MyObjectOutputStream extends ObjectOutputStream {  private static File f;  // writeStreamHeader()方法是在ObjectOutputStream的构造方法里调用的  // 由于覆盖后的writeStreamHeader()方法用到了f。如果直接用此构造方法创建  // 一个MyObjectOutputStream对象，那么writeStreamHeader()中的f是空指针  // 因为f还没有初始化。所以这里采用单态模式  private MyObjectOutputStream(OutputStream out, File f) throws IOException, SecurityException {  super(out);  }  // 返回一个MyObjectOutputStream对象，这里保证了new MyObjectOutputStream(out, f)  // 之前f已经指向一个File对象  public static MyObjectOutputStream newInstance(File file, OutputStream out) throws IOException {  f = file;// 本方法最重要的地方：构建文件对象，两个引用指向同一个文件对象  return new MyObjectOutputStream(out, f);  }  @Override  protected void writeStreamHeader() throws IOException {  // 文件不存在或文件为空,此时是第一次写入文件，所以要把头部信息写入。  if (!f.exists() || (f.exists() && f.length() == 0)) {  super.writeStreamHeader();  } else {  // 不需要做任何事情  }  }  
}  

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/466637.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

位运算+leetcode（1）

位运算+leetcode（1）

基础 1.基础知识 以下都是针对数字的二进制进行操作 >> 右移操作符<< 左移操作符~ 取反操作符 & 有0就是0&#xff0c;全一才一 | 有一才一 &#xff0c;全0才0^ 相同为0&#xff0c;相异为1 异或( ^ )运算的规律 a ^ 0 a a ^ a 0a ^ b ^ c a ^ (b …
阅读更多...
【GameFramework框架内置模块】1、全局配置（Config）

【GameFramework框架内置模块】1、全局配置（Config）

推荐阅读 CSDN主页GitHub开源地址Unity3D插件分享简书地址 大家好&#xff0c;我是佛系工程师☆恬静的小魔龙☆&#xff0c;不定时更新Unity开发技巧&#xff0c;觉得有用记得一键三连哦。 一、前言 【GameFramework框架】系列教程目录&#xff1a; https://blog.csdn.net/q7…
阅读更多...
在线问诊系统设计与实现的经验总结与整理

在线问诊系统设计与实现的经验总结与整理

随着互联网技术的快速发展&#xff0c;在线问诊服务作为一种新兴的医疗服务模式&#xff0c;正逐渐受到人们的关注和使用。本文将介绍在线问诊系统的设计原则和关键组件&#xff0c;以及如何实现一个安全、高效和可扩展的在线医疗服务平台。 内容&#xff1a; 1. 引言 - 在…
阅读更多...
C++ //练习 6.4 编写一个与用户交互的函数，要求用户输入一个数字，计算生成该数字的阶乘。在main函数中调用该函数。

C++ //练习 6.4 编写一个与用户交互的函数，要求用户输入一个数字，计算生成该数字的阶乘。在main函数中调用该函数。

C Primer&#xff08;第5版&#xff09; 练习 6.4 练习 6.4 编写一个与用户交互的函数&#xff0c;要求用户输入一个数字&#xff0c;计算生成该数字的阶乘。在main函数中调用该函数。 环境&#xff1a;Linux Ubuntu&#xff08;云服务器&#xff09; 工具&#xff1a;vim 代…
阅读更多...
【Django】Django文件上传

【Django】Django文件上传

文件上传 1 定义&场景 定义&#xff1a;用户可以通过浏览器将图片等文件上传至网站。 场景&#xff1a; 用户上传头像。 上传流程性的文档[pdf&#xff0c;txt等] 2 上传规范-前端[html] 文件上传必须为POST提交方式 表单 <form> 中文件上传时必须带有 enctype…
阅读更多...
每日一练：LeeCode-617、合并二叉树【二叉树+DFS】

每日一练：LeeCode-617、合并二叉树【二叉树+DFS】

本文是力扣LeeCode-617、合并二叉树【二叉树DFS】 学习与理解过程&#xff0c;本文仅做学习之用&#xff0c;对本题感兴趣的小伙伴可以出门左拐LeeCode。 给你两棵二叉树&#xff1a; root1 和 root2 。 想象一下&#xff0c;当你将其中一棵覆盖到另一棵之上时&#xff0c;两…
阅读更多...
Spring Boot 笔记 006 创建接口_注册

Spring Boot 笔记 006 创建接口_注册

1.1 由于返回数据都是以下这种格式&#xff0c;那么久再编写一个result实体类 报错了&#xff0c;原因是没有构造方法 可以使用lombok的注解自动生成&#xff0c;添加无参的构造器和全参的构造器 package com.geji.pojo;import lombok.AllArgsConstructor; import lombok.NoArg…
阅读更多...
ChatGPT高效提问—prompt实践（生成VBA）

ChatGPT高效提问—prompt实践（生成VBA）

ChatGPT高效提问—prompt实践&#xff08;生成VBA&#xff09; 2. 生成VBA函数操作Excel ​ 当前Excel表格数据无背景颜色&#xff0c;区分不明显。假如我们想美化数据展示效果&#xff0c;把标题行设置为浅蓝色&#xff0c;其余奇数行设置为橙色&#xff0c;该怎么操作呢&am…
阅读更多...
Java安全 URLDNS链分析

Java安全 URLDNS链分析

Java安全 URLDNS链分析 什么是URLDNS链URLDNS链分析调用链路HashMap类分析URL类分析 exp编写思路整理初步expexp改进最终exp 什么是URLDNS链 URLDNS链是Java安全中比较简单的一条利用链&#xff0c;无需使用任何第三方库&#xff0c;全依靠Java内置的一些类实现&#xff0c;但…
阅读更多...
Blazor OIDC 单点登录授权实例5 - 独立SSR App (net8 webapp ) 端授权

Blazor OIDC 单点登录授权实例5 - 独立SSR App (net8 webapp ) 端授权

目录: OpenID 与 OAuth2 基础知识Blazor wasm Google 登录Blazor wasm Gitee 码云登录Blazor OIDC 单点登录授权实例1-建立和配置IDS身份验证服务Blazor OIDC 单点登录授权实例2-登录信息组件wasmBlazor OIDC 单点登录授权实例3-服务端管理组件Blazor OIDC 单点登录授权实例4 …
阅读更多...
lv14 中断处理原理：接口及按键驱动 14

lv14 中断处理原理：接口及按键驱动 14

一、什么是中断 一种硬件上的通知机制&#xff0c;用来通知CPU发生了某种需要立即处理的事件 分为&#xff1a; 内部中断 CPU执行程序的过程中&#xff0c;发生的一些硬件出错、运算出错事件&#xff08;如分母为0、溢出等等&#xff09;&#xff0c;不可屏蔽 外部中断 外设…
阅读更多...
InternLM大模型实战-5.LMDeploy大模型量化部署实战

InternLM大模型实战-5.LMDeploy大模型量化部署实战

文章目录 前言笔记正文大模型部署背景部署挑战部署方案 LMDeploy框架量化推理引擎Turbomind推理服务api server 前言 本文是对于InternLM全链路开源体系系列课程的学习笔记 【LMDeploy 大模型量化部署实践】 https://www.bilibili.com/video/BV1iW4y1A77P/?share_sourcecopy_…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023