`
jieke_ZJ
  • 浏览: 44782 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

java对象序列化并存储到文件和数据库

 
阅读更多

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

 

[html] view plain copy print?
  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.保存对象到文件并恢复
要保存到文件首先必须得获得文件输入流，然后将文件输入流作为参数，构造对象输入流，然后就能直接将对象输入到文件中。而要将对象恢复，则需要先获得文件输出流，然后将文件输出流作为参数，构造对象输出流，就能够得到对象，然后再强制性转换为原始对象即可，实现代码如下:

 

[java] view plain copy print?
  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方法读出对象数据，并强制性转化为原始的对象数据。

实现代码如下所示:

 

[java] view plain copy print?
  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方法:

 

 

[java] view plain copy print?
  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. }  
分享到：
| Dubbo架构与底层实现
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java对象序列化和反序列化

    Java对象序列化与反序列化是Java编程中重要的概念，主要应用于数据持久化、网络传输以及存储等场景。本文将详细解析这两个概念及其在实际应用中的实现方式。 **一、Java对象序列化** 1. **定义**: Java对象序列化...

    Java 文件 序列化 读写

    Java文件序列化是Java平台中一种重要的数据存储和交换机制，它允许我们将对象的状态转换为字节流，以便可以保存到磁盘、网络传输或在内存中存储，然后在需要时将这些字节流恢复为原来的对象。这个过程称为序列化...

    Java对象的序列化和反序列化实践

    1. **概念**：序列化是将Java对象转换为字节流的过程，以便它可以被保存到磁盘、存储在数据库中或在网络上传输。 2. **作用**：主要目的是为了持久化对象，使对象的状态可以在程序运行的不同时间点保持不变，或者...

    C#和Java的序列化反序列化

    在编程领域，序列化和反序列化是两个关键的概念，特别是在跨平台通信、持久化存储以及数据传输中扮演着重要角色。本篇文章将深入探讨C#和Java中的序列化与反序列化机制。 首先，我们要了解什么是序列化。序列化是指...

    java程序，序列化和反序列化操作对文件的运用

    在Java编程语言中，序列化和反序列化是两种重要的技术，它们允许我们将对象的状态转换为字节流，以便存储到磁盘上或通过网络进行传输。这些技术在处理持久化数据、对象缓存以及跨进程通信（如RMI - 远程方法调用）时...

    java序列化(Serializable)的作用和反序列化.doc

    ### Java序列化(Serializable)的作用与反序列化详解 #### 一、序列化的概念 序列化是指将程序中的对象转换为一系列字节流的过程，主要用于保存对象的状态或在网络之间传输对象。序列化的主要目的是为了能够持久化...

    Java 多次序列化对象到同壹個文件及反序列化的问题

    多次序列化同一个对象到同一个文件可能会引发一系列问题，这主要涉及到序列化版本标识符（`serialVersionUID`）以及对象状态的改变。本文将深入探讨这些问题及其解决方案。 首先，了解Java中的序列化机制。当一个类...

    Java序列化_Java序列化结构_

    Java序列化是Java平台中的一种持久化机制，它允许对象的状态被转换成字节流，以便存储、网络传输或在不同时间点恢复。这个过程被称为序列化，而反向操作称为反序列化。序列化在许多场景下都非常有用，比如在分布式...

    java反序列化利用程序UI版Beta1.1.rar

    1. **Java序列化机制**：Java对象序列化是通过实现`Serializable`接口来标记一个类可被序列化。`ObjectOutputStream`用于将对象写入流，`ObjectInputStream`用于从流中读取并反序列化对象。 2. **易受攻击的库**：...

    java自动序列化

    Java序列化是将对象转换为字节流的过程，目的是为了保存对象的状态以便稍后恢复或传输到其他地方。通过实现`Serializable`接口，一个Java对象就可以被序列化。这个接口是一个标记接口，没有定义任何方法，仅表示对象...

    Android-Android上的Java对象反序列化

    在Android平台上，Java对象反序列化是一个常见的操作，它涉及到将序列化的数据转换回原来的对象实例。这在数据存储、网络通信以及跨进程通信（IPC）等场景中扮演着重要角色。本文将深入探讨Android上Java对象反序列...

    java序列化全解

    Java序列化是Java平台中的一种核心机制，它允许对象的状态被转换成字节流，以便存储到磁盘、数据库，或者在网络中进行传输。这对于实现持久化、远程方法调用（RMI）以及Enterprise JavaBeans（EJB）等高级功能至关...

    Java实现序列化例子

    Java序列化是Java平台提供的一种将对象转换为字节流，以便存储到磁盘、数据库或网络中的机制。它是Java语言内置的一种特性，主要用于持久化数据，也可以在进程间传递对象，或者在网络上传输对象。在Java中，如果一个...

    java序列化(Serializable)的作用和反序列化

    ### Java序列化(Serializable)的作用与反序列化详解 #### 一、序列化是什么？ 序列化是指将程序中的对象转换为字节流的过程，从而方便存储或传输这些对象。通常，序列化用于将对象的状态（即其实例变量的值，而非...

    Java对象序列化详细解析[参考].pdf

    Java对象序列化是一种将Java对象转换为字节流的过程，以便可以存储或在网络上传输。这一过程至关重要，因为它允许我们持久化对象的状态，以便在稍后的时间点恢复这些对象。在Java中，对象序列化主要涉及到`...

    对象的序列化和反序列化

    对象的序列化和反序列化是Java编程语言中重要的概念，它们主要用于持久化对象的状态，以便在需要时能够恢复。序列化是将一个对象转换为字节流的过程，而反序列化则是将字节流还原为原来的对象。这两个过程在许多场景...

    java中对象的序列化

    总的来说，Java对象序列化是一种强大的工具，允许你在不同场景下保存和恢复对象的状态，如在文件系统、数据库或网络之间传递对象。虽然大部分时候无需编写自定义代码，但在某些复杂情况，可能需要定制序列化和反序列...

    Android 序列化对象存储到sharepreference

    总结，Android序列化对象存储到SharedPreferences是一种实用技巧，它结合了Java序列化和Android的SharedPreferences机制，为开发者提供了在应用间保存简单对象的便捷方式。然而，由于SharedPreferences的局限性，...

    Java序列化对象工具类 Eclipse工程（SerializUtil.zip）

    Java序列化是Java平台中的一种持久化机制，它允许对象的状态被转换成字节流，以便存储、在网络上传输或在以后的时间恢复。这个过程被称为序列化，而反过程称为反序列化。在Java中，如果一个对象需要支持序列化，那么...

    java 序列化 将实体类本地序列化

    Java序列化是Java平台中的一种标准机制，允许将对象的状态转换为字节流，以便可以存储这个状态（例如，到磁盘或通过网络传输），之后再恢复为原来的对象。这在许多场景下都非常有用，例如持久化数据、跨网络传输对象...

Magicbox
Global site tag (gtag.js) - Google Analytics