객체 직렬화(Serialization)

import java.io.*;

public class ObjectSerializeTest {
    public static void main(String[] args) throws Exception { 

        // 파일을 열어서 그곳에 객체를 직렬화시켜서 저장한다. 
        // 파일 출력스트림을 연다. 
        FileOutputStream fileout = new FileOutputStream("test.txt");

        // 객체스트림을 열고, 객체스트림을 통해 객체를 파일에 저장 
         ObjectOutputStream out = new ObjectOutputStream(fileout); 
        out.writeObject(new SerializableClass("Serialize Test Program", 1014));

        // 객체스트림을 닫는다. 
        out.close();

        // 직렬화 된 객체를 저장된 파일로 부터 객체를 해제시켜 원래의 객체로 복원
         // 파일 입력스트림으로부터 객체 입력스트림을 연다. 
        FileInputStream fileinput = new FileInputStream("test.txt"); 
        ObjectInputStream in = new ObjectInputStream(fileinput);

        // 객체 입력스트림으로부터 객체를 읽어온다. 
        SerializableClass sc = (SerializableClass)in.readObject();

        // 객체스트림을 닫는다.
        in.close(); 

        // 스트림으로부터 읽어들인 객체의 내용을 출력 
         // 원래 생성되었던 객체와 같은 값을 갖는다는 것을 알수가 있다. 
        System.out.println("String : " + sc.Sstr); 
        System.out.println("Integer : " + sc.Sint); 
    } 
}

// 하나의 문자열과 정수를 저장하고 있는 SerializableClass를 
// Serializable을 implements 함으로써 
// 스트림을 통해 직렬화되고 해제되어질 수 있다.
class SerializableClass implements Serializable {
    public String Sstr; 
    public int Sint;

    // 생성자
    public SerializableClass(String s, int i) { 
    this.Sstr = s; 
        this.Sint = i; 
    } 
}

public class Employee {
   private String name;              // 이름
   private String dept;              // 부서
   private String duties;            // 직책

   // 생성자
   public Employee (String name, String dept, String duties) {
       this.name = name;
       this.dept = dept;
       this.duties = duties;
    }

   // Emp 자체를 네트워크로 전송
    public static void main(String[] args){
        Employee Emp = new Employee("조한서", "인사","차장");
    }
}

import java.io.*;

public class SerialObject implements Serializable{
     private String name; // 이름
     private String dept; // 부서
     private String duties; // 직책

     public SerialObject (String name, String dept, String duties) {
          this.name = name;
          this.dept = dept;
          this.duties = duties;
     }

     public String toString() {
          return name + ":" + dept + ":" + duties;
     }
}

import java.io.*;

public class SerialObjectTest {
     public static void main(String[] args) throws Exception {
        FileOutputStream fileout = new FileOutputStream("test.txt"); 
        ObjectOutputStream out = new ObjectOutputStream(fileout);
        SerialObject se1 = new SerialObject("김언어", "개발부", "팀장");
        SerialObject se2 = new SerialObject("김서리", "자금부", "부장");
        SerialObject se3 = new SerialObject("이회계", "경리부", "차장");
        out.writeObject(se1);
        out.writeObject(se2);
        out.writeObject(se3);
        out.close();

        FileInputStream filein = new FileInputStream("test.txt");
        ObjectInputStream in = new ObjectInputStream(filein);
        SerialObject iso1 = (SerialObject)in.readObject();
        SerialObject iso2 = (SerialObject)in.readObject();
        SerialObject iso3 = (SerialObject)in.readObject();
        System.out.println(iso1.toString());
        System.out.println(iso2.toString());
        System.out.println(iso3.toString9));
        in.close();
     }
}

public interface Externalizable extends Serializable {
     public void writeExternal(ObjectOutput out) throws IOException;
     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

import java.io.*;

public class ExternalObject implements Externalizable {
     private int dept;  // 부서
     private String name;  // 이름
     private float duties;  // 직책

     public ExternalObject() {}

     public ExternalObject(int dept, String name, float duties) {
          this.dept = dept;
          this.name = name;
          this.duties = duties;
     }

     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
          System.out.println("readExternal() 메서드입니다.");
          dept = in.readInt();
          name = (String)in.readObject();
          duties = in.readFloat();
     }

     public void writeExternal(ObjectOutput out) throws IOException {
          System.out.println("writeExternal() 메서드입니다.");
          out.writeInt(dept);
          out.writeObject(name);
          out.writeFloat(duties);
     }

     public String toString(){
          return dept + ":" + name + ":" + duties;
     }
}

import java.io.*; 

public class ExternalObjectTest {
     public static void main(String[] args) throws IOException, ClassNotFoundException{
        FileOutputStream fileout= new FileOutputStream("exTest.txt"); 
        ObjectOutputStream out= new ObjectOutputStream(fileout);
        ExternalObject eo1 = new ExternalObject(1, "김사양", 170.25f);
        ExternalObject eo2 = new ExternalObject(2, "이거지", 190.01f);
        ExternalObject eo3 = new ExternalObject(3, "삼다수", 180.34f);
        out.writeObject(eo1 );
        out.writeObject(eo2 );
        out.writeObject(eo3 );
        out.close();

        FileInputStream filein = new FileInputStream("exTest.txt");
        ObjectInputStream in = new ObjectInputStream(filein);
        ExternalObject eso1 = (ExternalObject)in.readObject();
        ExternalObject eso2 = (ExternalObject)in.readObject();
        ExternalObject eso3 = (ExternalObject)in.readObject();
        System.out.println(eso1.toString());
        System.out.println(eso2.toString());
        System.out.println(eso3.toString());
        ois.close();
    }
}

import java.io.*;

public class TransientTest implements Serializable {

     // 멤버변수
     private String name;
     transient String passwd;

     // 생성자
     public TransientTest(String s, String p) {
          name = s;
          passwd = p;
          System.out.println("생성자가 호출되었습니다: " + name);
     }

     // toString() 메서드를 오버라이드하여
     // println() 메서드에서 사용할때, 내용을 출력하도록 변경
     public String toString() {
          return "이름은 " + name+ " : 패스워드 : " + passwd;
     }

     public static void main(String args[]) {
          TransientTest tt1, tt2;
          tt1 = new TransientTest("김가방","1234");
          tt2 = new TransientTest("이치민","0011");

          try {
               // 객체 직렬화로 파일에 저장하기 위해
               // FileOutputStream에서 ObjectOutputStream 생성
               ObjectOutputStream out 
                    = new ObjectOutputStream(new FileOutputStream("TransientTest.ser"));

               // writeObject() 메서드를 사용하여 객체 저장
               out.writeObject(tt1);
               out.writeObject(tt2);
               out.close();

               // 객체 직렬화로 파일에 저장된 객체를 복원하기 위해
               // FileInputStream에서 ObjectInputStream 생성
               ObjectInputStream in 
                    = new ObjectInputStream(new FileInputStream("TransientTest.ser"));

               TransientTest tt3, tt4;

               // 해당 스트림에서 readObject() 메서드를 호출
               tt3 = (TransientTest)in.readObject();
               tt4 = (TransientTest)in.readObject();

               System.out.println("다시 복원합니다");

               // 내용을 출력한다
               System.out.println(tt3);
               System.out.println(tt4);

          } catch(Exception e) {
               e.printStackTrace();
          }
     }
}

/*
실행 결과
생성자가 호출되었습니다: 김가방
생성자가 호출되었습니다: 이치민
다시 복원합니다
이름은 김가방 : 패스워드 : null
이름은 이치민 : 패스워드 : null
*/