安科网

Java 持久化操作之 --io流与序列化

BitTigerio

BitTigerio

2018-05-15

关注 关注

摘自：http://www.cnblogs.com/lsy131479/p/8728724.html

1)File类操作文件的属性

1.File类的常用方法

Java 持久化操作之 --io流与序列化

1.

文件的绝对完整路径：getAbsolutePath()

文件名：getName()

文件相对路径：getPath()

文件的上一级目录：getParent()

文件的大小为：length()

删除文件：delete()

具体操作请参考如下代码：

Java 持久化操作之 --io流与序列化
package text;
import java.io.File;
import java.util.Scanner;
/**
 * 
 * @author: 房上的猫
 * 
 * @time: 下午7:55:16
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *        消费信息
 *
 */
public class TextFile {
    public static void main(String[] args) 
    {
        try {
            FileText();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static void FileText() throws Exception
    {
        //1.实例化对象指定判断路径
        File file=new File("D:\\TextFile\\A.txt");
        //2.判断A.txt是否存在
        if(file.exists())
        {
            //判断是否是文件夹
            if(file.isDirectory())
            {
                System.out.println("这是一个文件夹");
            }else
            {
                System.out.println("当前文件存在");
                System.out.println("这是一个文件");
                System.out.println("文件的绝对完整路径："+file.getAbsolutePath());
                System.out.println("文件名："+file.getName());
                System.out.println("文件相对路径："+file.getPath());
                System.out.println("文件的上一级目录："+file.getParent());
                System.out.println("文件的大小为："+file.length());    
                Scanner input=new Scanner(System.in);
                System.out.println("请按1删除此文件=======");
                if(input.nextInt()==1)
                {
                    boolean flog1= file.delete();
                    if(flog1)
                    {
                        System.out.println("删除成功");
                    }
                }
            }
        }else
        {
            System.out.println("当前文件不存在---开始创建");
            //3.不存在则创建新文件
            boolean flog=file.createNewFile();
            if(flog)
            {
                System.out.println("文件创建成功");
            }    
        }
    }
}
Java 持久化操作之 --io流与序列化


2)IO流（堵塞型io）

Java 持久化操作之 --io流与序列化

如何读写文件？

分析：流是指一连串流动的字符，是以先进先出方式发送信息的通道

输入/输出流于数据源：

Java 持久化操作之 --io流与序列化

java流的分类：

我们可以对它进行如下分类：

·按处理的数据类型可分为字节流与字符流

·按流的流向可分为输入流(in)与输出流(out)

·按流的功能可分为节点流(Node)和过滤流(Filter)

在Java中，字节流一般适用于处理字节数据(诸如图片、视频),字符流适用于处理字符数据(诸如文本文件)，但二者并没有严格的功能划分，因为有转换流的存在，使得对于数据的处理变得更加灵活。

1）字节流读写文件

一般用于处理字节数据，但字节流采用ASCII编码的，所以处理字符数据时容易出现中文乱码

1.输入流

InputStream：此抽象类是表示字节输入流的所有类的超类（基类）

序号

方法描述

1

public final int read(byte[] r, int off, int len)throws IOException
从所包含的输入流中将 len个字节读入一个字节数组中。如果len为-1，则返回已读字节数。

2

Public final int read(byte [] b)throws IOException
从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b中。

3

1.public final Boolean readBooolean()throws IOException,

2.public final byte readByte()throws IOException,

3.public final short readShort()throws IOException

4.public final Int readInt()throws IOException

从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。

4

public String readLine() throws IOException
从输入流中读取下一文本行。

所有字节输入流都是以此类发散出来的，但此类是一个抽象类，不可被实例化，所以实际编程过程中，都是使用它发散出来的一些子类，下面是输入流的关系图：

Java 持久化操作之 --io流与序列化

输入流最常用的就是FileInputStream类：

1-1文本文件的读取：用FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。

·有多种构造方法可用来创建对象。

·可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

·····InputStream f = new FileInputStream("C:/java/hello");

·也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

·····File f = new File("C:/java/hello");

·····InputStream out = new FileInputStream(f);

·创建了InputStream对象，就可以使用下面的方法来读取流或者进行其他的流操作。

字节流：

基类：InputStream 子类：FileInputStream

构造：

FileInputStream(File file) || FileInputStream(String name)

Java 持久化操作之 --io流与序列化

方法：

read() 按字节读

read(byte[] b) 读到字节数组缓冲区，数组存满统一批次循环读取

read(byte[] b, int off, int len) 向数组存放时进行了限制，起始位置off和终止位置len

int available() 表示当前还剩多少个字节未读取

Java 持久化操作之 --io流与序列化

注意：read方法返回 int 类型 返回读入字节数组的长度，如果读取到文件末尾的时候，则返回-1

代码演示按字节读取到控制台：

四步走：1.导入相关类 2.创建字节流对象 3.实现读取文本文件的数据 4.关闭文件流对象

测试文档：

使用Read（）读取

废话不多说 举个栗子：

Java 持久化操作之 --io流与序列化
package text;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
public class FileInputStream01 {
    public static void main(String[] args) {
        //创建字节流对象
        InputStream fls=null;
        try {
            fls=new FileInputStream("D://TextFile//A.txt");
            //实现读取操作
            int data;//存储读取的字节
            while((data=fls.read())!=-1)
            {
                //System.out.print(data);//读取的是数字
                System.out.print((char)data);//读取的是和文件一致
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            try {
                if(fls!=null)
                fls.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

修改代码使用Read（byte[] b）读取

Java 持久化操作之 --io流与序列化
int len;//存储读入数组的长度
byte[] wrods=new byte[1024];
while((len=fls.read(wrods))!=-1)
{
    System.out.print(new String(wrods,0,len));//String构造方法 把字节byte[] 转换成字符串形式，0代表截取起始位置，len表示截取终止位置
}
Java 持久化操作之 --io流与序列化

结果与上述一致：

1.输出流

OutputStream：此抽象类是表示字节输出流的所有类的超类（基类）

序号

方法描述

1

public final void write(byte[] w, int off, int len)throws IOException
将指定字节数组中从偏移量 off开始的 len个字节写入此字节数组输出流。

2

Public final int write(byte [] b)throws IOException
将指定的字节写入此字节数组输出流。

3

1.public final void writeBooolean()throws IOException,

2.public final void writeByte()throws IOException,

3.public final void writeShort()throws IOException,

4.public final void writeInt()throws IOException

这些方法将指定的基本数据类型以字节的方式写入到输出流。

4

Public void flush()throws IOException
刷新此输出流并强制写出所有缓冲的输出字节。

5

public final void writeBytes(String s) throws IOException
将字符串以字节序列写入到底层的输出流，字符串中每个字符都按顺序写入，并丢弃其高八位。

所有字节输出流都是以此类发散出来的，但此类是一个抽象类，不可被实例化，所以实际编程过程中，都是使用它发散出来的一些子类，下面是输出流的关系图：

Java 持久化操作之 --io流与序列化

输出流最常用的就是FileOutputStream类：

1-2文本文件的写入：用FileOutputStream

该类用来创建一个文件并向文件中写数据。

如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

有两个构造方法可以用来创建 FileOutputStream 对象。

使用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("C:/java/hello")

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

File f = new File("C:/java/hello");

OutputStream f = new FileOutputStream(f);

输出流：

基类：OutputStream

子类：FileOutputStream ..............

构造:

Java 持久化操作之 --io流与序列化

方法：

Java 持久化操作之 --io流与序列化

废话不多说 举个栗子：

Java 持久化操作之 --io流与序列化
package text;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class FileoutputStream {
    public static void main(String[] args) {
        //创建输出字节流
        OutputStream fls =null;
        try {
            //以File类对象作为参数，或 String name
            //构造一个参数
            //fls=new FileOutputStream(new File("D://TextFile//B.txt"));
            
            //file - 为了进行写入而打开的文件。
            //append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处 
            fls=new FileOutputStream(new File("D://TextFile//B.txt"),true);
            //声明要写入的内容
            String name="我是测试字符串";
            //将字符串转换为字节数组
            byte[] words=name.getBytes();
            //写入方法一
            //fls.write(words);
            //写入方法二
            fls.write(words,0,words.length);
            System.out.println("写入成功");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            try {
                fls.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

1-3文件读取和写入同步

废话不多说 举个栗子：

Java 持久化操作之 --io流与序列化
package text;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class FileoutputStream {
    public static void main(String[] args) {
        //创建输出字节流
        OutputStream fls =null;
        try {
            //以File类对象作为参数，或 String name
            //构造一个参数
            //fls=new FileOutputStream(new File("D://TextFile//B.txt"));
            
            //file - 为了进行写入而打开的文件。
            //append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处 
            fls=new FileOutputStream(new File("D://TextFile//B.txt"),true);
            //声明要写入的内容
            String name="我是测试字符串";
            //将字符串转换为字节数组
            byte[] words=name.getBytes();
            //写入方法一
            //fls.write(words);
            //写入方法二
            fls.write(words,0,words.length);
            System.out.println("写入成功");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            try {
                fls.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

2）字符流读和缓冲流读文件

用BufferedReader 和 BufferedWriter读写文本文件//字符流

或 FileReader

字符编码：ASCII码 0~127 8位二进制数1个字节。 16位二进制数表示一个字符 两个字节

字符流：输入流

基类：Reader----FileReader

Java 持久化操作之 --io流与序列化

构造：

Java 持久化操作之 --io流与序列化

常用方法：

Java 持久化操作之 --io流与序列化

1）如果 使用字节流读取带有汉字的文件会怎么样那

Java 持久化操作之 --io流与序列化
package text;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
public class FileInputStream01 {
    public static void main(String[] args) {
        //创建字节流对象
        InputStream fls=null;
        try {
            fls=new FileInputStream("D://TextFile//A.txt");
            //实现读取操作
            int data;//存储读取的字节
            while((data=fls.read())!=-1)
            {
                //System.out.print(data);//读取的是数字
                //System.out.println("还剩："+fls.available()+"字节未读取");            
                System.out.print((char)data);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            try {
                if(fls!=null)
                fls.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

运行结果如下：

Java 持久化操作之 --io流与序列化

很明显出现了乱码

2）下面使用FileReader字符流 Read（）读取文件，示例如下

Java 持久化操作之 --io流与序列化
package text;
/**
 * 使用字符流读取文本文件
 *<p>Title:FileReaderDemo</p>
 *<p>Description:</p>
 *<p>Company:</p>
 * @author MLQ
 * @date 2018年3月7日 下午12:38:35
 */
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class FileReaderDemo {
    public static void main(String[] args) {
        //创建一个字符流对象
        Reader rd=null;
        try {
            rd=new FileReader("D://TextFile//A.txt");
            int word;//就收读取的字符
            while((word=rd.read())!=-1)
            {
                System.out.print((char)word);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            if(rd!=null)
            {
                try {
                    rd.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

运行结果你会发现，乱码消失了

3）下面使用FileReader字符流 Read（char[] b）读取文件，示例如下

修改代码如下：

Java 持久化操作之 --io流与序列化
package text;
/**
 * 使用字符流读取文本文件
 *<p>Title:FileReaderDemo</p>
 *<p>Description:</p>
 *<p>Company:</p>
 * @author MLQ
 * @date 2018年3月7日 下午12:38:35
 */
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class FileReaderDemo {
    public static void main(String[] args) {
        //创建一个字符流对象
        Reader rd=null;
        StringBuffer sb=new StringBuffer();
        try {
            rd=new FileReader("D://TextFile//A.txt");
            int word;//就收读取的字符
            char[] ch=new char[1024];
            while((word=rd.read(ch))!=-1)
            {
                sb.append(ch,0,word);
            }
            System.out.println(sb.toString());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            if(rd!=null)
            {
                try {
                    rd.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

运行结果如下：

Java 持久化操作之 --io流与序列化

温馨提示：如果上述的代码 sb.append(ch,0,word) 只写数组的话，会把空格也会追加到 StringBuffer。读取文

件的时候最后可能没有写满数组

4)使用BufferedReader读取文本文件

（增强）

BufferedReader类是Reader类的子类

bufferedReader类带有缓冲区

按行读取内容的ReadLine（）方法

实现步骤：

Java 持久化操作之 --io流与序列化

构造：

Java 持久化操作之 --io流与序列化

方法：

Java 持久化操作之 --io流与序列化

演示代码如下：

Java 持久化操作之 --io流与序列化
package text;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.*;
public class BufferedReader01 {
    public static void main(String[] args) {
        //创建一个字符流对象
        Reader rd=null;
        //创建BufferedReader对象
        BufferedReader bf=null;
        StringBuffer sb=new StringBuffer();
        try {
            rd=new FileReader("D://TextFile//A.txt");
            bf=new BufferedReader(rd);//传入Reader对象
            String word=null;//接收返回值，读到末尾返回null
            while((word=bf.readLine())!=null)
            {
                System.out.println(word);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally
        {
            if(rd!=null)
            {
                try {
                    rd.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bf!=null)
            {
                try {
                    bf.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

运行结果如下：

Java 持久化操作之 --io流与序列化

3）字符流读和缓冲流写文件

基类：Write 子类：FileWrite

Java 持久化操作之 --io流与序列化

构造：

Java 持久化操作之 --io流与序列化

方法：

Java 持久化操作之 --io流与序列化

演示代码如下：

3-1）使用FileWrite字符流写入文档

Java 持久化操作之 --io流与序列化
package text;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class FileWriter01 {
    public static void main(String[] args) {
        //创建写入字符流
        Writer rd=null;
        try {
            rd=new FileWriter("D://TextFile//A.txt",true);
            String s="我是写入测试编码";
            rd.write(s);//写入文档
            rd.flush();//刷新缓冲区
            System.out.println("写入成功");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            if(rd!=null)
            {
                try {
                    rd.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

3-2）使用BufferedWrite字符流写入文件

如何提高字符流写文本文件的效率？

解：使用FileWrite类与BufferReader类

BufferedWrite类是Write类的子类

BufferedWrite类带有缓冲区

步骤：

Java 持久化操作之 --io流与序列化

构造：

Java 持久化操作之 --io流与序列化

方法：

Java 持久化操作之 --io流与序列化

代码演示如下：

Java 持久化操作之 --io流与序列化
package text;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class BufferedWrite01 {
    public static void main(String[] args) {
        //创建FileWrite 和 BufferedWrite 对象
        Writer wd=null;
        BufferedWriter bw=null;
        //创建FileReader  和 BufferedReader  对象
        Reader ed=null;
        BufferedReader br=null;
        try {
            wd=new FileWriter("D:\\TextFile\\A.txt");
            bw=new BufferedWriter(wd);
            bw.write("我是测试员");
            bw.newLine();//换行符方法
            bw.write("负责测试程序运行问题");
            bw.flush();
            System.out.println("成功写入");
            //读取文本文件信息
            ed=new FileReader("D:\\TextFile\\A.txt");
            br=new BufferedReader(ed);
            String word=null;
            while((word=br.readLine())!=null)
            {
                System.out.println(word);
            }
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally
        {
            if(wd!=null){
                try {
                    wd.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(ed!=null){
                try {
                    ed.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
Java 持久化操作之 --io流与序列化

4）使用数据流读写文件

二进制文件读写：

使用DataInputStream 和 DataOutputStream 读写二进制文件 //属于字节流

DataInputStream 类：

FileInputStream的子类

与FileInputStream类结合使用读取二进制文件

DataOutputStream 类：

FileOutputStream的子类

与FileOutputStream类结合使用写二进制文件

Java 持久化操作之 --io流与序列化

DataOutputStream:

Java 持久化操作之 --io流与序列化Java 持久化操作之 --io流与序列化

演示代码如下：

实现步骤：

Java 持久化操作之 --io流与序列化

[

Java 持久化操作之 --io流与序列化
package text;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
@SuppressWarnings("unused")
public class DataInOutStream {
    @SuppressWarnings("resource")
    public static void main(String[] args)throws Exception {
        DataInputStream di=null;
        DataOutputStream ds=null;
        di=new DataInputStream(new FileInputStream("D://TextFile//dd.class"));
        ds=new DataOutputStream(new FileOutputStream("D://TextFile//coty.class"));
        int len;//接收读取的字节
        while((len=di.read())!=-1)
        {
            ds.write(len);
        }
        System.out.println("执行完毕");
        if(di!=null)
        di.close();
        ds.close();
    }
}
Java 持久化操作之 --io流与序列化

3）序列化和反序列化

序列化和反序列化的过程

Java 持久化操作之 --io流与序列化

序列化的步骤：

1.实现 Serializable 接口

2.创建对象输出流

3.调用 writeObject()方法将对象写入文件

4.关闭对象输出流

使用集合保存对象，可以将集合中的所有对象序列化

序列化构造和常用方法

Java 持久化操作之 --io流与序列化Java 持久化操作之 --io流与序列化

反序列化构造和常用方法

Java 持久化操作之 --io流与序列化Java 持久化操作之 --io流与序列化

实现序列化 和 反序列化 演示代码：

Java 持久化操作之 --io流与序列化Java 持久化操作之 --io流与序列化Student 类

Java 持久化操作之 --io流与序列化Java 持久化操作之 --io流与序列化测试类

提示：如果不希望Student类某一属性被序列化可使用 transient 修饰

biu ～biu ～ biu ～

注：最后在提一句：使用序列化操作时，一定要将准备序列化的类或数据声明为可序列化操作！！！！

Java 持久化操作之 --io流与序列化

持久化 序列化 system io流

BitTigerio

BitTigerio

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

Redis持久化RDB和AOF区别详解

触发机制--主要三种方式。主进程通过fork()函数，创建子进程生成DRB文件，在此期间访问redis仍然能正常响应。save 300 10 #300秒修改了10次就自动生成RDB文件。stop-writes-on-bgsave-error yes #b

温攀峰 2020-10-23

可持久化数据结构（线段树，trie树）

又称主席树，因为发明这一算法的人的名字缩写为HJT。通过下图主席树的结构进行一下理解，黑色部分是普通的线段树，有颜色部分为每次的修改。看一下实现过程。「区间第k小」给定 n 个整数构成的序列 a，将对于指定的闭区间 [l,r] 查询其区间内的第 k 小值。

Dyancsdn 2020-07-28

NC-UAP客户化开发-4.NC数据库持久化技术

JDBCFrameWork为NC访问数据库提供统一的数据操作访问，简化数据访问操作。BaseDao是在JDBCFrameWork之上提供数据持久化的工具类。管理连接会话的生命周期，并提供了对单表VO操作的常用实现；可以传递构造参数选择不同的数据源。SQLP

鲁氏汤包王 2020-06-08

vuex持久化 vuex-persistedstate

// ...// ...getItem: key => Cookies.get(key),setItem: (key, value) => Cookies.set(key, value, { expires: 7 }),

Callmesmallpure 2020-05-31

scrapy持久化存储

管道文件中一个管道类对应的是将数据存储到一种平台，所以需要在pipelines.py文件中定义新的管道类

MiracleZhao 2020-05-29

redis持久化

1 客户端执行save命令----》redis服务端----》异步创建RDB二进制文件。no-appendfsync-on-rewrite yes #在aof重写的时候，是否要做aof的append操作，因为aof重写消耗性能，磁盘消耗，正常aof写磁盘有

无能力者只知抱怨 2020-05-09

c#反射在ORM中的应用

对象关系映射模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。.NET中EF,Log4就是这种框架。什么是“持久化”持久，即把数据保存到可永

技术之博大精深 2020-05-03

RabbitMQ消息队列怎样做到服务宕机或重启消息不丢失

RabbitMQ默认情况下的交换机和队列以及消息是非持久化的，也就是说在服务器重启或者宕机恢复后，之前创建的交换机和队列都将不复存在，之前未消费的消息也就消失不见了。原因在于每个队列和交换机的durable属性。RabbitMQ确保持久性消息能从服务器重启

shenzhenzsw 2020-05-01

Redis，持久化方案

Redis目前已经成为主流的内存数据库了，但是大部分人仅仅是停留在会用的阶段，你真的了解Redis内部的工作原理吗？什么是AOF，AOF如何实现持久化？RDB完成后会自动生成一个文件，保存在dir配置的指定目录下，文件名是dbfileName指定。Redi

jokewinl 2020-04-20

cnblogs 博客爬取 + scrapy + 持久化

sql = ‘‘‘insert into cnb values ‘‘‘

Catastrophe 2020-04-11

Linux 环境下配置Redis 持久化 及其余配置内容

（一）因为redis 是基于把内存的，重启后redis中的内容会清除。　　1 进入redis 的 redis.conf 文件 编辑命令。　　2 esc　　　　shitf + zz 退出保存编辑内容。　　2 下拉找到 configuration. 　　3

ljbhander 2020-04-11

Redis主从架构

　　单机的 redis，能够承载的 QPS 大概就在上万到几万不等。对于缓存来说，一般都是用来支撑读高并发的。因此架构做成主从架构，一主多从，主负责写，并且将数据复制到其它的 slave 节点，从节点负责读。这样也可以很轻松实现水平扩容，支撑读高并发。一个

JavaWDB 2020-03-26

查看redis是否支持持久化

redis-cli -h 172.21.1.74172.21.1.74:6379> auth yourpasswdOK172.21.1.74:6379> info persistencePersistenceloading:0rdb_chan

fansenjun 2020-03-03

Redis:两种持久化方式RDB和Aof对比(3)

默认的持久化方案。在指定时间间隔内，执行指定次数的写操作，则会将内存中的数据写入到磁盘中。在指定目录下生成一个dump.rdb文件。重启会通过加载dump.rdp文件恢复数据。出现是为了弥补RDB的不足。# appendfsync always appen

wangxiaoxue 2020-02-17

SpringBoot整合ActiveMQ实现持久化

　　　　　　结论：当服务器宕机，重启服务器之后，没有被消费的消息依然在数据库中，这样就做到了持久化操作。　　　　　　结论：被消费的消息，将不会做持久化操作，就会从队列中清除。

Java高知 2020-02-14

寒假13

1 持久化类Pojo 持久化类有一个属性ID，用来标识类的每个对象。xml配置文件主要用于配置数据库连接和Hibernate运行时所需的各种属性

DAV数据库 2020-02-14

Redis持久化方案

l RDB是Redis默认采用的持久化方式。l RDB方式是通过快照完成的，当符合一定条件时Redis会自动将内存中的数据进行快照并持久化到硬盘。

wangxiaoxue 2020-01-29

Redis持久化

RDB是通过直接将K-V键值对保存在硬盘文件来持久化。通过两个命令可以让服务器执行rdb操作。但是BGSAVE命令执行期间，服务器处理SAVE,BGSAVE,BGREWRITEAOF三个命令的方式会有所不同。RDB文件没有手动载入的命令，服务器启动时会主动

qiqizhiyun 2020-01-29

redis持久化问题处理

这个是最近在开发的过程中遇到的问题，因为需要频繁使用redis作为中间查询操作，突然故障了，服务中止，然后抛出异常

凌风郎少 2020-01-14

Redis的持久化机制-RDB

如果宕机重启，那么内存里的数据肯定会没有的，那么再次启动redis后，则会恢复。由于定时全量备份是重量级操作，所以对于实时备份，就无法处理了。RDB适合大量数据的恢复，但是数据的完整性和一致性可能会不足。

杜引强 2020-01-13
BitTigerio

BitTigerio

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号