精华内容
下载资源
问答
  • 1.首先,对即将要操作的java对象的类需要实现序列接口Serializable,代码如下: import java.io.Serializable; public class User implements Serializable{ private static final long serialVersionUID = 1L; ...

    1.首先,对即将要操作的java对象的类需要实现序列化接口Serializable,代码如下:
    import java.io.Serializable;

    public class User implements Serializable{

    private static final long serialVersionUID = 1L;
    
    private String name = null;
    private String pwd = null;
    public String getName() {
    	return name;
    }
    public void setName(String name) {
    	this.name = name;
    }
    public String getPwd() {
    	return pwd;
    }
    public void setPwd(String pwd) {
    	this.pwd = pwd;
    }
    @Override
    public String toString() {
    	return "User [name=" + name + ", pwd=" + pwd + "]";
    }
    

    }
    2.将user类序列化存储到文件中,并从文件中反序列化读取java类,代码如下:
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;

    public class SerializedUser {
    public static void main(String[] args) throws Exception {
    User user = new User();
    user.setName(“zgj”);
    user.setPwd(“zgjzzm”);
    System.out.println(user.toString());
    //将user对象序列化存储到文件
    ObjectOutputStream ots = new ObjectOutputStream(new FileOutputStream(“C:\Users\Administrator\Desktop\编程学习\user.xml”));
    ots.writeObject(user);
    ots.flush();
    ots.close();
    //从文件中反序列化读取user对象信息
    ObjectInputStream in = new ObjectInputStream(new FileInputStream(“C:\Users\Administrator\Desktop\user.xml”));
    User user2 = (User)in.readObject();
    System.out.println(user2.toString());
    }
    }

    注意:文件类型可以使xml,也可以是txt

    运行结果:
    在这里插入图片描述

    展开全文
  • Java对象序列

    千次阅读 2014-03-15 22:53:38
    Java对象序列将那些实现Serializable接口的对象转换成一个字节序列,并能够在以后将这个字节序列完全恢复为原来的对象。这一过程甚至可以通过网络进行,这意味着序列机制能自动弥补不同操作系统之间的差异。也...

    什么是对象序列化?

    所谓的对象序列化(在一些书中也称为串行化),是指将对象转换成为二进制数据流的一种实现手段。通过将对象序列化,可以方便的实现对象的传输和存储。


    Java对象序列化将那些实现Serializable接口的对象转换成一个字节序列,并能够在以后将这个字节序列完全恢复为原来的对象。这一过程甚至可以通过网络进行,这意味着序列化机制能自动弥补不同操作系统之间的差异。也就是说,可以在运行windows系统的计算机上创建一个对象,将其序列化,通过网络将其发送给一台运行Unix系统的计算机,然后准确的重新组装,而却不必担心数据在不同机器上的表示会不同,也不必关心字节的顺序或者其他任何细节。 对象序列化是为了支持两种主要特性。一是Java的远程方法调用(RMI),它使存活于其他计算机上的对象使用起来就像是存活于本机上一样。当向远程对象发送消息时,需要通过对象序列化来传输参数和返回值。

    在JAVA中提供有ObjectInputStream与ObjectOutputStream这俩个类用语序列化对象的操作。这俩个类是用于存储和读取对象的输入输出流类,不难想象,只要把对象中的所有成员变量都存储起来,就等于保存了这个对象,之后从保存的对象中在将对象读取进来就可以继续使用此对象。
    ObjectInputStream与ObjectOutputStream这俩个类用于完成存储和读取对象成员变量取值的过程,如果一个类的对象想被序列化,则对象所在的类必须实现java.io.Serializable接口。该接口中没有定义任何方法,仅仅被用作一种标记,以被编译器作特殊处理。
    public class Person implements Serializable {
    	private static final long serialVersionUID = 1L;
    	private transient final String name;//如果某个属性不想被序列化,加上transient关键字
    	private final int age;
    
    	public Person(String name, int age) {
    		this.name = name;
    		this.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return "姓名:" + this.name + ": 年龄:" + this.age;
    	}
    }
    public class SerializableDemo {
    	public static void main(String[] args) {
    		File f = new File("D:" + File.separator + "text.txt");
    		serialize(f);
    		deserialize(f);
    	}
    
    	// 序列化对象的方法
    	public static void serialize(File f){
    		try {
    			OutputStream outputFile = new FileOutputStream(f);
    			ObjectOutputStream cout = new ObjectOutputStream(outputFile);
    			cout.writeObject(new Person("张三", 22));
    			cout.close();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 反序列化对象的方法
    	public static void deserialize(File f) {
    		try {
    			InputStream inputFile = new FileInputStream(f);
    			ObjectInputStream cin = new ObjectInputStream(inputFile);
    			Person p = (Person) cin.readObject();
    			System.out.println(p);
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

    serialVersionUID
    在对象进行序列化或反序列化操作的时候,要考虑JDK的版本问题,如果序列化的JDK版本和反序列化的JDK版本不统一则有可能造成异常。所以在序列化操作中引入了 serialVersionUID的常量,可以通过此常量来验证版本的一致性,在进行反序列列化时,JVM会把传来的字节流中的serialVersionUID与本地相应实体(类)的serialVersionUID进行比较,如果相同就认为是一致的,可以进行反序列化,否则就会出现序列化版本不一致的异常。

    序列化一组对象
    对象输出时只提供了一个对象的输出操作(writeObject(Object obj)).并没有提供多个对象的输出,所以如果现在要同时序列化多个对象的时候就可以使用对象数组进行操作,因为数组属于引用数据类型,所以可以直接使用Object类型进行接受。这种方法保存的对象有限,Java中引入类集框架解决数组的存储限制问题。

    参考书目:java编程思想, java从入门到精通
    展开全文
  • 【Java】Java对象序列I/O体系总结

    千次阅读 2020-03-07 16:08:14
    Java对象序列IO体系总结

    对象序列化体系概述

    • 通过使用ObjectInputStream和ObjectOutputStream类保存和读取对象的机制叫做序列化机制
    • 序列化与反序列化
      • 对象序列化是指将对象转换为字节序列的过程
      • 对象反序列化则是根据字节序列恢复对象的过程
    • 序列化一般用于以下场景:
      • 永久性保存对象,保存对象的字节序列到本地文件中
      • 通过序列化对象在网络中传递对象
      • 通过序列化在进程间传递对象

    支持序列化的接口和类

    • 序列化的过程,是将任何实现了Serializable接口或Externalizable接口的对象通过ObjectOutputStream类提供的相应方法转换为连续的字节数据,这些数据以后仍可通过ObjectInputStream类提供的相应方法被还原为原来的对象状态,这样就可以将对象完成的保存在本地文件中,或在网络间、进程间传递
    • 支持序列化的接口和类
      • Serializable接口
      • Externalizable接口
      • ObjectInputStream类
      • ObjectOutputStream类

    Serializable接口

    只有一个实现Serializable接口的对象可以被序列化工具存储和恢复。

    Serializable接口没有定义任何属性或方法。它只用来表示一个类可以被序列化。

    如果一个类可以序列化,它的所有子类都可以序列化。

    Externalizable接口

    可以让需要序列化的类实现Serializable接口的子接口Externalizable。

    Externalizable接口表示实现该接口的类在序列化中由该类本身来控制信息的写出和读入。

    ObjectOutputStream类

    ObjectOutputStream类继承OutputStream类,并实现了ObjectOutput接口,它负责向流写入对象。

    构造方法

    ObjectOutputStream(OutputStream out) 
    

    主要方法

    writeObject(Object obj) // 向指定的OutputStream中写入对象obj
    

    ObjectInputStream类

    ObjectInputStream类继承InputStream类,并实现了ObjectInput接口,它负责从流中读取对象 。

    构造方法

    ObjectInputStream(InputStream in) 
    

    主要方法

    readObject(Object obj) // 从指定的InputStream中读取对象 
    

    对象序列化的条件

    • 该对象类必须实现Serializable接口
    • 如果该类有直接或者间接的不可序列化的基类,那么该基类必须 有一个默认的构造器。该派生类需要负责将其基类中的数据写入 流中
    • 建议所有可序列化类都显式声明serialVersionUID值

    序列化与serialVersionUID

    这个属性,在IDEA里是不主动提示的,但Eclipse中会提示的,并建议开发者自己指定或者使用默认值。

    默认值是这么写的:

    private static long serialVersionUID = 1L;
    

    serialVersionUID在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。

    如果接收者加载的该对象的类的serialVersionUID与对应的发送者的类的版本号不同,则反序列化将会抛出InvalidClassException。

    序列化与transient关键词

    《举例浅谈Java关键词transient的使用》

    封装序列化文件操作工具

    《Java封装序列化文件工具类》

    展开全文
  • Java中要实现将对象保存起来持久,需要让对象实现Serializable接口,这样就能将java对象用二进制流保存并恢复。下面我将以保存到文件和保存到mysql来进行解析。先给出序列类的定义:   [html] view plain...

    Java中要实现将对象保存起来持久化,需要让对象实现Serializable接口,这样就能将java对象用二进制流保存并恢复。下面我将以保存到文件和保存到mysql来进行解析。先给出序列化类的定义:

     

    1. package model;  
    2.   
    3. import java.io.Serializable;  
    4. import java.util.Date;  
    5. /*  
    6.  * 实现可序列化接口  
    7.  */  
    8. public class Person implements Serializable{  
    9.     private String name;                                 //名字  
    10.     private int year;                                    //年龄  
    11.     private String city;                                 //城市  
    12.     private Date birth;                                  //生日  
    13.       
    14.     public String getName() {  
    15.         return name;  
    16.     }  
    17.     public void setName(String name) {  
    18.         this.name = name;  
    19.         this.year=year;  
    20.         this.city=city;  
    21.     }  
    22.     public int getYear() {  
    23.         return year;  
    24.     }  
    25.     public void setYear(int year) {  
    26.         this.year = year;  
    27.     }  
    28.     public String getCity() {  
    29.         return city;  
    30.     }  
    31.     public void setCity(String city) {  
    32.         this.city = city;  
    33.     }  
    34.       
    35.       
    36.     public Date getBirth() {  
    37.         return birth;  
    38.     }  
    39.     public void setBirth(Date birth) {  
    40.         this.birth = birth;  
    41.     }  
    42.     /*  
    43.      * (non-Javadoc)  
    44.      * @see java.lang.Object#toString()  
    45.      * 重写toString,不然序列化之后显示的是内存地址  
    46.      */  
    47.     public String toString(){  
    48.         return this.name+" "+this.year+" "+this.city+" "+this.birth.toString();  
    49.     }  
    50. }  
    package model;
    
    import java.io.Serializable;
    import java.util.Date;
    /*
     * 实现可序列化接口
     */
    public class Person implements Serializable{
    	private String name;                                 //名字
    	private int year;                                    //年龄
    	private String city;                                 //城市
    	private Date birth;                                  //生日
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    		this.year=year;
    		this.city=city;
    	}
    	public int getYear() {
    		return year;
    	}
    	public void setYear(int year) {
    		this.year = year;
    	}
    	public String getCity() {
    		return city;
    	}
    	public void setCity(String city) {
    		this.city = city;
    	}
    	
    	
    	public Date getBirth() {
    		return birth;
    	}
    	public void setBirth(Date birth) {
    		this.birth = birth;
    	}
    	/*
    	 * (non-Javadoc)
    	 * @see java.lang.Object#toString()
    	 * 重写toString,不然序列化之后显示的是内存地址
    	 */
    	public String toString(){
    		return this.name+" "+this.year+" "+this.city+" "+this.birth.toString();
    	}
    }
    



     

    1.保存对象到文件并恢复
    要保存到文件首先必须得获得文件输入流,然后将文件输入流作为参数,构造对象输入流,然后就能直接将对象输入到文件中。而要将对象恢复,则需要先获得文件输出流,然后将文件输出流作为参数,构造对象输出流,就能够得到对象,然后再强制性转换为原始对象即可,实现代码如下:

     

    1. package saveobject;  
    2.   
    3. import java.io.FileInputStream;  
    4. import java.io.FileNotFoundException;  
    5. import java.io.FileOutputStream;  
    6. import java.io.IOException;  
    7. import java.io.ObjectInputStream;  
    8. import java.io.ObjectOutputStream;  
    9.   
    10. import model.Person;  
    11.   
    12. public class FileHelper {  
    13.     private String fileName;  
    14.       
    15.     public FileHelper(){  
    16.           
    17.     }  
    18.       
    19.     public FileHelper(String fileName){  
    20.         this.fileName=fileName;  
    21.     }  
    22.       
    23.     /* 
    24.      * 将person对象保存到文件中 
    25.      * params: 
    26.      *  p:person类对象 
    27.      */  
    28.     public void saveObjToFile(Person p){  
    29.         try {  
    30.             //写对象流的对象   
    31.             ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(fileName));  
    32.               
    33.             oos.writeObject(p);                 //将Person对象p写入到oos中   
    34.               
    35.             oos.close();                        //关闭文件流   
    36.         } catch (FileNotFoundException e) {  
    37.             // TODO Auto-generated catch block   
    38.             e.printStackTrace();  
    39.         } catch (IOException e) {  
    40.             // TODO Auto-generated catch block   
    41.             e.printStackTrace();  
    42.         }   
    43.     }  
    44.       
    45.     /* 
    46.      * 从文件中读出对象,并且返回Person对象 
    47.      */  
    48.     public Person getObjFromFile(){  
    49.         try {  
    50.             ObjectInputStream ois=new ObjectInputStream(new FileInputStream(fileName));  
    51.               
    52.             Person person=(Person)ois.readObject();              //读出对象   
    53.               
    54.             return person;                                       //返回对象   
    55.         } catch (FileNotFoundException e) {  
    56.             // TODO Auto-generated catch block   
    57.             e.printStackTrace();  
    58.         } catch (IOException e) {  
    59.             // TODO Auto-generated catch block   
    60.             e.printStackTrace();  
    61.         } catch (ClassNotFoundException e) {  
    62.             // TODO Auto-generated catch block   
    63.             e.printStackTrace();  
    64.         }  
    65.           
    66.         return null;  
    67.     }  
    68. }  
    package saveobject;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    import model.Person;
    
    public class FileHelper {
    	private String fileName;
    	
    	public FileHelper(){
    		
    	}
    	
    	public FileHelper(String fileName){
    		this.fileName=fileName;
    	}
    	
    	/*
    	 * 将person对象保存到文件中
    	 * params:
    	 * 	p:person类对象
    	 */
    	public void saveObjToFile(Person p){
    		try {
    			//写对象流的对象
    			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(fileName));
    			
    			oos.writeObject(p);                 //将Person对象p写入到oos中
    			
    			oos.close();                        //关闭文件流
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} 
    	}
    	
    	/*
    	 * 从文件中读出对象,并且返回Person对象
    	 */
    	public Person getObjFromFile(){
    		try {
    			ObjectInputStream ois=new ObjectInputStream(new FileInputStream(fileName));
    			
    			Person person=(Person)ois.readObject();              //读出对象
    			
    			return person;                                       //返回对象
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		return null;
    	}
    }
    

     

     

    2.保存对象到数据库并恢复

    对象序列化之后得到的二进制流,所以要想保存序列化之后的对象,则必须用blob字段来保存。mysql中blob字段是用来存储二进制数据的。可以直接用PreparedStatement.setObject()方法来保存对象到数据库中。

    而要将对象恢复,则首先需要读出二进制数据,读出的方法是用ResultSet.getBlob()方法,然后用Blob对象的getBinaryStream()方法来获得二进制流对象,然后将该二进制流对象作为参数构造带缓冲区的流对象BufferedStream,然后用byte[]数组从BufferedInputStream流中读取二进制数据,然后用该byte数组来构造ByteArrayInputStream,然后用ByteArrayInputStream来构造ObjectInputStream,最后直接用ObjectInputStream对象的readObject方法读出对象数据,并强制性转化为原始的对象数据。

    实现代码如下所示:

     

    1. package saveobject;  
    2.   
    3. import java.io.BufferedInputStream;  
    4. import java.io.ByteArrayInputStream;  
    5. import java.io.IOException;  
    6. import java.io.InputStream;  
    7. import java.io.ObjectInputStream;  
    8. import java.sql.Blob;  
    9. import java.sql.Connection;  
    10. import java.sql.DriverManager;  
    11. import java.sql.PreparedStatement;  
    12. import java.sql.ResultSet;  
    13. import java.sql.SQLException;  
    14. import java.util.ArrayList;  
    15. import java.util.List;  
    16.   
    17. import model.Person;  
    18.   
    19. public class DBHelper {  
    20.     private static Connection conn;                                      //连接   
    21.     private PreparedStatement pres;                                      //PreparedStatement对象   
    22.       
    23.     static{  
    24.         try {  
    25.             Class.forName("com.mysql.jdbc.Driver");              //加载驱动   
    26.             System.out.println("数据库加载成功!!!");  
    27.             String url="jdbc:mysql://localhost:3306/testdb";  
    28.             String user="root";  
    29.             String password="20130436";  
    30.               
    31.             conn=DriverManager.getConnection(url,user,password); //建立连接   
    32.             System.out.println("数据库连接成功!!!");  
    33.         } catch (ClassNotFoundException | SQLException e) {  
    34.             // TODO Auto-generated catch block   
    35.             e.printStackTrace();  
    36.         }  
    37.     }  
    38.       
    39.     /* 
    40.      * 向数据库中的表testobj中插入多个Person对象 
    41.      * params: 
    42.      *  persons:Person对象list 
    43.      */  
    44.     public void savePerson(List<Person> persons){  
    45.         String sql="insert into objtest(obj) values(?)";  
    46.           
    47.         try {  
    48.             pres=conn.prepareStatement(sql);  
    49.             for(int i=0;i<persons.size();i++){  
    50.                 pres.setObject(1, persons.get(i));  
    51.                    
    52.                 pres.addBatch();                                   //实现批量插入   
    53.             }  
    54.               
    55.             pres.executeBatch();                                      //批量插入到数据库中   
    56.               
    57.             if(pres!=null)  
    58.                 pres.close();  
    59.               
    60.         } catch (SQLException e) {  
    61.             // TODO Auto-generated catch block   
    62.             e.printStackTrace();  
    63.         }  
    64.     }  
    65.       
    66.     /* 
    67.      * 从数据库中读出存入的对象 
    68.      * return: 
    69.      *  list:Person对象列表 
    70.      */  
    71.     public List<Person> getPerson(){  
    72.         List<Person> list=new ArrayList<Person>();  
    73.         String sql="select obj from objtest";  
    74.           
    75.         try {  
    76.             pres=conn.prepareStatement(sql);  
    77.               
    78.             ResultSet res=pres.executeQuery();  
    79.             while(res.next()){  
    80.                 Blob inBlob=res.getBlob(1);                             //获取blob对象   
    81.                   
    82.                 InputStream is=inBlob.getBinaryStream();                //获取二进制流对象   
    83.                 BufferedInputStream bis=new BufferedInputStream(is);    //带缓冲区的流对象   
    84.                   
    85.                 byte[] buff=new byte[(int) inBlob.length()];  
    86.                 while(-1!=(bis.read(buff, 0, buff.length))){            //一次性全部读到buff中   
    87.                     ObjectInputStream in=new ObjectInputStream(new ByteArrayInputStream(buff));  
    88.                     Person p=(Person)in.readObject();                   //读出对象   
    89.                       
    90.                     list.add(p);  
    91.                 }  
    92.                   
    93.             }  
    94.         } catch (SQLException | IOException | ClassNotFoundException e) {  
    95.             // TODO Auto-generated catch block   
    96.             e.printStackTrace();  
    97.         }  
    98.           
    99.         return list;  
    100.     }  
    101. }  
    package saveobject;
    
    import java.io.BufferedInputStream;
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.ObjectInputStream;
    import java.sql.Blob;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import model.Person;
    
    public class DBHelper {
    	private static Connection conn;                                      //连接
    	private PreparedStatement pres;                                      //PreparedStatement对象
    	
    	static{
    		try {
    			Class.forName("com.mysql.jdbc.Driver");              //加载驱动
    			System.out.println("数据库加载成功!!!");
    			String url="jdbc:mysql://localhost:3306/testdb";
    			String user="root";
    			String password="20130436";
    			
    			conn=DriverManager.getConnection(url,user,password); //建立连接
    			System.out.println("数据库连接成功!!!");
    		} catch (ClassNotFoundException | SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    	/*
    	 * 向数据库中的表testobj中插入多个Person对象
    	 * params:
    	 * 	persons:Person对象list
    	 */
    	public void savePerson(List<Person> persons){
    		String sql="insert into objtest(obj) values(?)";
    		
    		try {
    			pres=conn.prepareStatement(sql);
    			for(int i=0;i<persons.size();i++){
    				pres.setObject(1, persons.get(i));
    				 
    				pres.addBatch();                                   //实现批量插入
    			}
    			
    			pres.executeBatch();                                      //批量插入到数据库中
    			
    			if(pres!=null)
    				pres.close();
    			
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    	/*
    	 * 从数据库中读出存入的对象
    	 * return:
    	 * 	list:Person对象列表
    	 */
    	public List<Person> getPerson(){
    		List<Person> list=new ArrayList<Person>();
    		String sql="select obj from objtest";
    		
    		try {
    			pres=conn.prepareStatement(sql);
    			
    			ResultSet res=pres.executeQuery();
    			while(res.next()){
    				Blob inBlob=res.getBlob(1);                             //获取blob对象
    				
    				InputStream is=inBlob.getBinaryStream();                //获取二进制流对象
    				BufferedInputStream bis=new BufferedInputStream(is);    //带缓冲区的流对象
    				
    				byte[] buff=new byte[(int) inBlob.length()];
    				while(-1!=(bis.read(buff, 0, buff.length))){            //一次性全部读到buff中
    					ObjectInputStream in=new ObjectInputStream(new ByteArrayInputStream(buff));
    					Person p=(Person)in.readObject();                   //读出对象
    					
    					list.add(p);
    				}
    				
    			}
    		} catch (SQLException | IOException | ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		return list;
    	}
    }
    


    测试用的main方法:

     

     

    1. package controller;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.Date;  
    5. import java.util.List;  
    6.   
    7. import model.Person;  
    8. import saveobject.DBHelper;  
    9. import saveobject.FileHelper;  
    10.   
    11. public class MainApp {  
    12.     public static void main(String[] args){  
    13.         FileHelper fh=new FileHelper("E:\\obj.txt");  
    14.           
    15.         Person p=new Person();  
    16.         p.setName("张斌");  
    17.         p.setYear(24);  
    18.         p.setCity("威海");  
    19.         p.setBirth(new Date(95,2,16));  
    20.         fh.saveObjToFile(p);                               //存入person对象   
    21.           
    22.         Person person=fh.getObjFromFile();                 //取出person对象   
    23.         System.out.println(person.toString());  
    24.           
    25.         Person p1=new Person();  
    26.         p1.setName("张斌");  
    27.         p1.setYear(24);;  
    28.         p1.setCity("江西");  
    29.         p1.setBirth(new Date(94,1,2));  
    30.           
    31.           
    32.         Person p2=new Person();  
    33.         p2.setName("福国");  
    34.         p2.setYear(30);  
    35.         p2.setCity("吉林");  
    36.         p2.setBirth(new Date(95,4,23));  
    37.           
    38.         Person p3=new Person();  
    39.         p3.setName("羿赫");  
    40.         p3.setYear(20);  
    41.         p3.setCity("海南");  
    42.         p3.setBirth(new Date(93,9,29));  
    43.           
    44.         DBHelper db=new DBHelper();  
    45.         List<Person> slist=new ArrayList<Person>();  
    46.         slist.add(p1);  
    47.         slist.add(p2);  
    48.         slist.add(p3);  
    49.           
    50.         //db.savePerson(slist);   
    51.           
    52.         List<Person> glist=db.getPerson();  
    53.           
    54.         for(int i=0;i<glist.size();i++){  
    55.             System.out.println(glist.get(i).toString());  
    56.         }  
    57.     }  
    58. }  
    package controller;
    
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    import model.Person;
    import saveobject.DBHelper;
    import saveobject.FileHelper;
    
    public class MainApp {
    	public static void main(String[] args){
    		FileHelper fh=new FileHelper("E:\\obj.txt");
    		
    		Person p=new Person();
    		p.setName("张斌");
    		p.setYear(24);
    		p.setCity("威海");
    		p.setBirth(new Date(95,2,16));
    		fh.saveObjToFile(p);                               //存入person对象
    		
    		Person person=fh.getObjFromFile();                 //取出person对象
    		System.out.println(person.toString());
    		
    		Person p1=new Person();
    		p1.setName("张斌");
    		p1.setYear(24);;
    		p1.setCity("江西");
    		p1.setBirth(new Date(94,1,2));
    		
    		
    		Person p2=new Person();
    		p2.setName("福国");
    		p2.setYear(30);
    		p2.setCity("吉林");
    		p2.setBirth(new Date(95,4,23));
    		
    		Person p3=new Person();
    		p3.setName("羿赫");
    		p3.setYear(20);
    		p3.setCity("海南");
    		p3.setBirth(new Date(93,9,29));
    		
    		DBHelper db=new DBHelper();
    		List<Person> slist=new ArrayList<Person>();
    		slist.add(p1);
    		slist.add(p2);
    		slist.add(p3);
    		
    		//db.savePerson(slist);
    		
    		List<Person> glist=db.getPerson();
    		
    		for(int i=0;i<glist.size();i++){
    			System.out.println(glist.get(i).toString());
    		}
    	}
    }

    程序结果截图:

     

     

    数据库截图:

     

    如果是数据完全可以使用JSON方式。毕竟redis直接set、get使用起
    来门槛低很多。redis是没有提供专用的设置对象方法,需要自己进行改写。如果是担心JSON转对象会消耗资源的情况,这个问题需要考量几个地方,第一
    点:就是使用的JSON转换lib是否就会存在性能问题。第二点:就是数据的数据量级别,如果是存储百万级的大数据对象,建议采用存储序列化对象方式。如
    果是少量的数据级对象,或者是数据对象字段不多,还是建议采用JSON转换成String方式。毕竟redis对存储字符类型这部分优化的非常好。具体采
    用的方式与方法,还要看你所使用的场景。
    
    

    Redis不支持直接将Java对象存储到数据库中,所以需要将java对象进行序列化得到字节数组,然后将字节数组存入到redis中,需要数据的时候就从redis数据库中取出字节数组,再经过反序列化将自己数组转换成对象使用(jdk序列化性能比谷歌公司的Protobuf序列化性能要差一些,而且序列化后的字节长度要也会长一些,所以推荐使用Protobuf,Protobuf如何进行序列化请看我的另一篇帖子)
    实体类
    User.java

    [java]  view plain  copy
     
      在CODE上查看代码片 派生到我的代码片
    1. import java.io.Serializable;  
    2. public class User implements Serializable{  
    3. private static final long serialVersionUID = 2724888087391664167L;  
    4. private String id;  
    5. private String username;  
    6. private String password;  
    7. public User() {  
    8. }  
    9. public User(String id, String username, String password) {  
    10. this.id = id;  
    11. this.username = username;  
    12. this.password = password;  
    13. }  
    14. public String getId() {  
    15. return id;  
    16. }  
    17. public void setId(String id) {  
    18. this.id = id;  
    19. }  
    20. public String getUsername() {  
    21. return username;  
    22. }  
    23. public void setUsername(String username) {  
    24. this.username = username;  
    25. }  
    26. public String getPassword() {  
    27. return password;  
    28. }  
    29. public void setPassword(String password) {  
    30. this.password = password;  
    31. }  
    32. public static long getSerialversionuid() {  
    33. return serialVersionUID;  
    34. }  
    35. @Override  
    36. public String toString() {  
    37. return "User [id=" + id + ", username=" + username + ", password="  
    38. + password + "]";  
    39. }  
    40. }  
    序列化反序列化工具类
    SerializeUtils.java
    [java]  view plain  copy
     
      在CODE上查看代码片 派生到我的代码片
    1. import java.io.ByteArrayInputStream;  
    2. import java.io.ByteArrayOutputStream;  
    3. import java.io.IOException;  
    4. import java.io.ObjectInputStream;  
    5. import java.io.ObjectOutputStream;  
    6. public class SerializeUtils {  
    7. public static byte[] serialize(Object obj){  
    8. byte[] bytes = null;  
    9. try {  
    10. ByteArrayOutputStream baos=new ByteArrayOutputStream();;  
    11. ObjectOutputStream oos=new ObjectOutputStream(baos);  
    12. oos.writeObject(obj);  
    13. bytes=baos.toByteArray();  
    14. baos.close();  
    15. oos.close();  
    16. catch (IOException e) {  
    17. e.printStackTrace();  
    18. }  
    19. return bytes;  
    20. }  
    21. public static Object deSerialize(byte[] bytes){  
    22. Object obj=null;  
    23. try {  
    24. ByteArrayInputStream bais=new ByteArrayInputStream(bytes);  
    25. ObjectInputStream ois=new ObjectInputStream(bais);  
    26. obj=ois.readObject();  
    27. catch (Exception e) {  
    28. e.printStackTrace();  
    29. }  
    30. return obj;  
    31. }  
    32. }  
    测试类RedisTest.java
    [java]  view plain  copy
     
      在CODE上查看代码片 派生到我的代码片
    1. import java.util.HashMap;  
    2. import java.util.List;  
    3. import java.util.Map;  
    4. import java.util.Set;  
    5. import org.junit.Test;  
    6. import redis.clients.jedis.Jedis;  
    7. public class RedisTest{  
    8. private static Jedis jedis;  
    9. static{  
    10. //访问本地redis  
    11. jedis = new Jedis("127.0.0.1",6379);  
    12. }  
    13. @Test  
    14. public void serialize(){  
    15. User user=new User("1000""宝宝""xioabao");  
    16. jedis.set(user.getId().getBytes(), SerializeUtils.serialize(user));  
    17. byte[] bytes=jedis.get(user.getId().getBytes());  
    18. System.out.println((User)SerializeUtils.deSerialize(bytes));  
    19. }  
    20. }  
    展开全文
  • Java对象序列与反序列

    千次阅读 2016-07-25 22:59:18
    Java对象转换为字节序列的过程称为序列,用途是对象永久保存、传输。序列运行时使用一个称为 serialVersionUID 的版本号与每个可序列类相关联,该序列号在反序列过程中用于验证序列对象的发送者和接收者...
  • java对象序列的用途

    2016-03-21 10:02:13
    所谓java对象序列就是将对象的状态转换成字节流,以后可以通过这些值再生成相同状态的对象!对象序列是对象持久的一种实现方法,它是将一个对象的属性和方法转化为一种序列的格式以用于存储和传输,反序列...
  • 因此可以通过序列化储存java对象,再通过反序列得到对象。 新建一个maven项目,添加相关的Jar包依赖。 <dependencies> <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> ...
  • java对象序列

    千次阅读 2007-01-05 23:36:00
    java对象序列概述 序列的过程就是对象写入字节流和从字节流中读取对象。 将对象状态转换成字节流之后,可以用java.io包中的各种字节流类将其保存在文件中,管道到另一线程中或通过网络连接将对象数据发送到另...
  • 对象的序列 : 把Java对象转换为字节序列并存储至一个储存媒介的过程。 对象的反序列:把字节序列恢复为Java对象的过程。 (2) 序列详细解释 对象的序列涉及三个点关键点:Java对象、字节序列、存储。 1. ...
  • 项目要改版,TUser或者User要修改属性,添加或者删除某些字段,那么数据库已保存的数据还能被反序列化为原有对象,并进行扩展么? 修改User.java package cn.vicky.po.vo; import java.io.Serializable; /**...
  • Java基础学习总结——Java对象的序列和反序列 一、序列和反序列的概念  把对象转换为字节序列的过程称为对象的序列。  把字节序列恢复为对象的过程称为对象的反序列。  对象的序列主要有两种用途...
  • 一个类要想被序列,就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法,就如同之前的cloneable接口一样。实现了这个接口之后,就表示这个类具有被序列的能力。 先让我们实现一个具有序列能力...
  • Java 保存对象本地

    千次阅读 2018-07-20 11:46:48
    对象保存在本地第一时间一般想到的都是ObjectOutput,但是我在网上无意中发现还可以将对象转为json字符串来保存,于是让我有种恍然大悟的感觉,我们在保存对象时候有时候并不需要保存信息,有时候只需要保存对这个...
  • Java对象的XML序列

    千次阅读 2012-03-06 19:13:46
    Java对象的序列(serialization)是对象的持久存储和对象状态的网络传输的 关键环节,在RMI(Remote Method Invocation)、JMS(Java Message Service)和EJB(EnterpriseJavaBeans)中都有应用。对象序列可以实现分布式...
  • Redis不支持直接将Java对象存储到数据库中,所以需要将java对象进行序列得到字节数组,然后将字节数组存入到redis中,需要数据的时候就从redis数据库中取出字节数组,再经过反序列将自己数组转换成对象使用(jdk...
  • java对象的初始和清理

    千次阅读 2016-10-31 23:02:19
    对于初始和清理(cleanup),C++引入了构造器(constructor)的概念,这是一个在创建对象时被自动调用的特殊方法,Java也采用了构造器,并额外提供了“垃圾回收器”; 1、使用构造器确保初始 (1)Java中每个...
  • redis不支持直接将java对象存储到数据库中,所以需要将java对象进行序列得到字节数组,然后将字节数组存入到redis中,需要数据的时候就从redis数据库中取出字节数组,再经过反序列将自己数组转换成对象使用(jdk...
  • java对象序列学习笔记

    千次阅读 2004-06-30 13:00:00
    目前网络上关于对象序列的文章不少,但是我发现详细叙述用法和原理的文章太少。本人把自己经过经验总结和实际运用中的体会写成的学习笔记贡献给大家。希望能为整个java社区的繁荣做一点事情。序列的过程就是对象...
  • Java对象的序列和反序列

    千次阅读 2015-07-13 09:44:43
     把对象转换为字节序列的过程称为对象的序列。  把字节序列恢复为对象的过程称为对象的反序列。  对象的序列主要有两种用途:  1) 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中;  2) 在...
  • ++++++++++++++++++++++++++++++++++++++++++ 本文系本站原创,欢迎转载! 转载请注明出处: ... ++++++++++++++++++++++++++++++++++++++++++ 本地C代码中创建Java对象 创建Java域的
  • java线程 在其他对象上同步、线程本地存储ThreadLocal:thinking in java4 21.3.6
  • 下面我们详细了解Java程序中new一个普通对象时,HotSpot虚拟机是怎么样创建这个对象的,包括5个步骤:相应类加载检查过程、在Java堆中为对象分配内存、分配后内存初始...最后我们再从JVM指令角度来解释下Java对象创建。
  • Java对象模型

    千次阅读 2020-02-06 14:44:49
    Java对象模型
  • java对象内存存储结构理解

    千次阅读 2018-09-16 13:19:52
    一、java程序的操作系统的内存申请 操作系统的空间申请是以进程为单位。进程包含至少一个线程,当我们运行一个java程序时,开启一个javaw虚拟机进程,并且默认构建一个线程(即main线程),进程向操作系统申请操作...
  • java对象的初始和回收

    千次阅读 2017-07-25 11:32:21
    对象的初始和回收  系统生成对象时,会自动为对象分配内存空间,并调用相应的构造函数对其初始,在对象没有...Java提供了四种方法生成对象,使用new关键字仅仅是其中一种方法。  1. 使用new关键字生成对
  • 9个Java对象的初始和回收的面试题

    千次阅读 2016-06-06 10:49:49
    Java的初始和回收相关知识是公司在面试开发人员时常考察的问题,这里列出了8大常见的题型。 1.Java中是如何区分重载方法的? 通过重载方法的参数类型和顺序来进行区分的。 注意:若参数类型和顺序均相同时,...
  • 系统解耦与序列、持久 从开始学习和实践系统设计起就一直围绕着这样一个问题——怎样降低系统的耦合度,使系统更加健壮、更加灵活?无论桌面应用还是网络应用,确实它的系统中无非包含如下几方面的内容——如何...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 206,148
精华内容 82,459
关键字:

java对象本地化存储

java 订阅