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对象序列化将那些实现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从入门到精通
 

对象序列化体系概述
 
通过使用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 
    copy 
    print
    ? 
   
 
  
 
  
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();  
    }  
}  
 
 
 
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
    ? 
   
 
  
 
  
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;  
    }  
}  
 
 
 
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
    ? 
   
 
  
 
  
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;  
    }  
}  
 
 
 
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
    ? 
   
 
  
 
  
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());  
        }  
    }  
}  
 
 
 
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 
    

      
    
  
    
     
   
 
  
 
  
 import java.io.Serializable;   
 public class User implements Serializable{   
 private static final long serialVersionUID = 2724888087391664167L;   
 private String id;   
 private String username;   
 private String password;   
 public User() {   
 }   
 public User(String id, String username, String password) {   
 this.id = id;   
 this.username = username;   
 this.password = password;   
 }   
 public String getId() {   
 return id;   
 }   
 public void setId(String id) {   
 this.id = id;   
 }   
 public String getUsername() {   
 return username;   
 }   
 public void setUsername(String username) {   
 this.username = username;   
 }   
 public String getPassword() {   
 return password;   
 }   
 public void setPassword(String password) {   
 this.password = password;   
 }   
 public static long getSerialversionuid() {   
 return serialVersionUID;   
 }   
 @Override   
 public String toString() {   
 return "User [id=" + id + ", username=" + username + ", password="   
 + password + "]";   
 }   
}  
 
 
 
序列化反序列化工具类
SerializeUtils.java
 
 
 
  
 
   
 
    [java] 
    view plain 
    copy 
    

      
    
  
    
     
   
 
  
 
  
 import java.io.ByteArrayInputStream;   
 import java.io.ByteArrayOutputStream;   
 import java.io.IOException;   
 import java.io.ObjectInputStream;   
 import java.io.ObjectOutputStream;   
 public class SerializeUtils {   
 public static byte[] serialize(Object obj){   
 byte[] bytes = null;   
 try {   
 ByteArrayOutputStream baos=new ByteArrayOutputStream();;   
 ObjectOutputStream oos=new ObjectOutputStream(baos);   
 oos.writeObject(obj);   
 bytes=baos.toByteArray();   
 baos.close();   
 oos.close();   
 } catch (IOException e) {   
 e.printStackTrace();   
 }   
 return bytes;   
 }   
 public static Object deSerialize(byte[] bytes){   
 Object obj=null;   
 try {   
 ByteArrayInputStream bais=new ByteArrayInputStream(bytes);   
 ObjectInputStream ois=new ObjectInputStream(bais);   
 obj=ois.readObject();   
 } catch (Exception e) {   
 e.printStackTrace();   
 }   
 return obj;   
 }   
}  
 
 
 
测试类RedisTest.java
 
 
 
  
 
   
 
    [java] 
    view plain 
    copy 
    

      
    
  
    
     
   
 
  
 
  
 import java.util.HashMap;   
 import java.util.List;   
 import java.util.Map;   
 import java.util.Set;   
 import org.junit.Test;   
 import redis.clients.jedis.Jedis;   
 public class RedisTest{   
 private static Jedis jedis;   
 static{   
 //访问本地redis   
 jedis = new Jedis("127.0.0.1",6379);   
 }   
 @Test   
 public void serialize(){   
 User user=new User("1000", "宝宝", "xioabao");   
 jedis.set(user.getId().getBytes(), SerializeUtils.serialize(user));   
 byte[] bytes=jedis.get(user.getId().getBytes());   
 System.out.println((User)SerializeUtils.deSerialize(bytes));   
 }   
}