ch12 직렬화 - LenKIM/everyone-is-effective-java-study GitHub Wiki

public class BombSerialization {
    static byte[] bomb() {
        Set<Object> root = new HashSet<>();
        Set<Object> s1 = root;
        Set<Object> s2 = new HashSet<>();
        for (int i = 0; i < 100; i++) {
            Set<Object> t1 = new HashSet<>();
            Set<Object> t2 = new HashSet<>();
            t1.add("foo"); // t1을 t2와 다르게 만든다.
          
            s1.add(t1);
            s1.add(t2);
            s2.add(t1);
            s2.add(t2);
          
            s1 = t1;
            s2 = t2;
        }
        return serialize(root); 
    }
  public static void main(String[] args) {
        System.out.println(bomb().length);
        deserialize(bomb());
    }
}

public class Name impements Serializable {
 /**
    * 성. null이 아니어야 함.
    * @serial
    */
    private final String lastName;
 
/**
    * 이름. null이 아니어야 함.
    * @serial
    */
    private final String firstName;
 
/**
    * 중간이름. 중간이름이 없다면 null
    * @serial
    */
    private final String middleName;
 
... // 생략
}

public final class StringList implements Serializable {
    private int size = 0;
    private Entry head = null;
 
    private static class Entry implements Serializable {
        String data;
        Entry next;
        Entry previous;
    }
    ... // 나머지 코드는 생략
}

public final class StringList implements Serializable {
    private transient int size = 0;
    private transient Entry head = null;
 
    // 이제는 직렬화되지 않는다.
    private static class Entry {
        String data;
        Entry next;
        Entry previous;
    }
    // 지정한 문자열을 이 리스트에 추가한다.
    public final void add(String s) { ... }
 
    /**
     * 이 {@code StringList} 인스턴스를 직렬화한다.
     *
     * @serialData 이 리스트의 크기*포함된 문자열의 개수)를 기록한 후
     * ({@code int}), 이어서 모든 원소를(각각은 {@code String})
     * 순서대로 기록한다.
     */
    private void writeObject(ObjectOutputStream s) throws IOException {
        s.defaultWriteObject();
        s.writeInt(size);
 
        // 모든 원소를 올바른 순서로 기록한다.
        for (Entry e = head; e != null; e = e.next)
            s.writeObject(e.data);
    }
     
    private void readObject(ObjectInputStream s) throws IOException,               
                                                    ClassNotFoundException {
        s.detaultReadObject();
        int numElements = s.readInt();
         
        // 모든 원소를 읽어 이 리스트에 삽입한다.
        for(int i =0; i < numElements; i++)
            add((String) s.readObject());
    }
    ... // 나머지 코드는 생략
}

private synchronized void writeObject(ObjectOutputStream s) throws IOException{
    s.defaultWriteObject();
}

//코드 88-1 방어적 복사를 사용하는 불변 클래스
public final class Period {
    private final Date start;
    private final Date end;
  
    /**
     * @param  start 시작 시각
     * @param  end 종료 시각. 시작 시각보다 뒤여야 한다.
     * @throws IllegalArgumentException 시작 시각이 종료 시각보다 늦을 때 발생한다.
     * @throws NullPointerException start나 end가 null이면 발생한다.
     */
    public Period(Date start, Date end) {
        this.start = new Date(start.getTime());
        this.end = new Date(end.getTime());
        if (this.start.compareTo(this.end) > 0)
            throw new IllegalArgumentException(this.start + "가 " + this.end + "보다 늦다.");
    }
  
    public Date start() {
        return new Date(start.getTime());
    }
  
    public Date end() {
        return new Date(end.getTime());
    }
  
    @Override
    public String toString() {
        return start + " - " + end;
    }
}

//코드 88-2 허용되지 않는 Period 인스턴스를 생성할 수 있다
public class BogusPeriod {
    // 진짜 Period 인스턴스에서는 만들어질 수 없는 바이트 스트림
    private static final byte[] serializedForm = {
            (byte) 0xac, (byte) 0xed, 0x00, 0x05, 0x73, 0x72, 0x00, 0x06,
            0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x40, 0x7e, (byte) 0xf8,
            0x2b, 0x4f, 0x46, (byte) 0xc0, (byte) 0xf4, 0x02, 0x00, 0x02,
            0x4c, 0x00, 0x03, 0x65, 0x6e, 0x64, 0x74, 0x00, 0x10, 0x4c,
            0x6a, 0x61, 0x76, 0x61, 0x2f, 0x75, 0x74, 0x69, 0x6c, 0x2f,
            0x44, 0x61, 0x74, 0x65, 0x3b, 0x4c, 0x00, 0x05, 0x73, 0x74,
            0x61, 0x72, 0x74, 0x71, 0x00, 0x7e, 0x00, 0x01, 0x78, 0x70,
            0x73, 0x72, 0x00, 0x0e, 0x6a, 0x61, 0x76, 0x61, 0x2e, 0x75,
            0x74, 0x69, 0x6c, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x68, 0x6a,
            (byte) 0x81, 0x01, 0x4b, 0x59, 0x74, 0x19, 0x03, 0x00, 0x00,
            0x78, 0x70, 0x77, 0x08, 0x00, 0x00, 0x00, 0x66, (byte) 0xdf,
            0x6e, 0x1e, 0x00, 0x78, 0x73, 0x71, 0x00, 0x7e, 0x00, 0x03,
            0x77, 0x08, 0x00, 0x00, 0x00, (byte) 0xd5, 0x17, 0x69, 0x22,
            0x00, 0x78};
  
    public static void main(String[] args) {
        Period p = (Period) deserialize(serializedForm);
        System.out.println(p);
    }
  
    private static Object deserialize(byte[] sf) {
        try {
            InputStream is = new ByteArrayInputStream(sf);
            ObjectInputStream ois = new ObjectInputStream(is);
            Object obj = ois.readObject();
            return obj;
        } catch (IOException | ClassNotFoundException e) {
            throw new IllegalArgumentException(e);
        }
    }
}
  
/*
    실행결과
  
    Sat Jan 02 05:00:00 KST 1999 - Mon Jan 02 05:00:00 KST 1984
*/

// 코드 88-3 유효성 검사를 수행하는 readObject 메서드 - 아직 불완전
public final class Period implements Serializable {
    // 코드 생략
  
    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
        s.defaultReadObject();
  
        // 불변식을 만족하는지 검사
        if (start.compareTo(end) > 0) {
            throw new InvalidObjectException(this.start + "가 " + this.end + "보다 늦다.");
        }
    }
}

public class MutablePeriod {
  
    private final Period period;
    private final Date start;
    private final Date end;
  
    public MutablePeriod() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(bos);
  
            // 유효한 Period 인스턴스를 직렬화 함 (현재 시간의 start와 end를 가진 Period 생성)
            out.writeObject(new Period(new Date(), new Date()));
  
            // Period 내부의 Date 필드에 악의적인 참조를 추가함
            byte[] ref = {0x71, 0, 0x7e, 0, 5}; // Ref #5
            bos.write(ref); // start 필드
            ref[4] = 4; // Ref # 4
            bos.write(ref); // end 필드
  
            // Period 인스턴스를 역직렬화 한 후, Date 참조를 훔침
            ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
            period = (Period) in.readObject();
            start = (Date) in.readObject();
            end = (Date) in.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new AssertionError(e);
        }
    }
  
    public static void main(String[] args) {
        MutablePeriod mp = new MutablePeriod();
        Period p = mp.period;
        Date pEnd = mp.end;
  
        pEnd.setYear(50);
        System.out.println(p);
  
        Date pStart = mp.start;
        pStart.setYear(122);
        System.out.println(p);
    }
}
  
/*
    실행결과
  
    Tue May 07 10:14:18 KST 2019 - Sun May 07 10:14:18 KST 1950
    Sat May 07 10:14:18 KST 2022 - Sun May 07 10:14:18 KST 1950
*/

//코드 88-5 방어적 복사와 유효성 검사를 수행하는 readObject 메서드
public final class Period implements Serializable {
    // final 제거
    private Date start;
    private Date end;
  
    // 코드 생략
  
    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
        s.defaultReadObject();
  
        // 가변적 요소를 방어적으로 복사
        start = new Date(start.getTime());
        end = new Date(end.getTime());
  
        // 불변식을 만족하는지 검사
        if (start.compareTo(end) > 0) {
            throw new InvalidObjectException(this.start + "가 " + this.end + "보다 늦다.");
        }
    }
}
  
/*
    MutablePeriod 실행결과
  
    Tue May 07 10:18:19 KST 2019 - Tue May 07 10:18:19 KST 2019
    Tue May 07 10:18:19 KST 2019 - Tue May 07 10:18:19 KST 2019
*/

public class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() { ... }
    private Object readResolve() {
        return INSTANCE;
    }
}

//코드 89-1 잘못된 싱글턴 - transient가 아닌 참조 필드를 가지고 있다
public class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();
    private String[] favoriteSongs = {"Hound Dog", "Heartbreak Hotel"};
  
    private Elvis() {
    }
  
    public void printFavorites() {
        System.out.println(Arrays.toString(favoriteSongs));
    }
  
    private Object readResolve() {
        return INSTANCE;
    }
}

//코드 89-2 도둑 클래스
public class ElvisStealer implements Serializable {
    private static final long serialVersionUID = 0;
    static Elvis impersonator;
    private Elvis payload;
  
    private Object readResolve() {
        // resolve되기 전의 Elvis 인스턴스의 참조를 저장
        impersonator = payload;
        // favoriteSongs 필드에 맞는 타입의 객체를 반환
        return new String[] {"My way"};
    }
}

ublic class ElvisImpersonator {
    private static final byte[] serializedForm = new byte[]{
            (byte) 0xac, (byte) 0xed, 0x00, 0x05, 0x73, 0x72, 0x00, 0x05,
            // 코드 생략
    };
  
    private static Object deserialize(byte[] sf) {
      // 코드 생략
    }
  
    public static void main(String[] args) {
        // ElvisStealer.impersonator 를 초기화한 다음,
        // 진짜 Elvis(즉, Elvis.INSTANCE)를 반환
        Elvis elvis = (Elvis) deserialize(serializedForm);
        Elvis impersonator = ElvisStealer.impersonator;
        elvis.printFavorites();
        impersonator.printFavorites();
    }
}
  
/*
    실행 결과
  
    [Hound Dog, Heartbreak Hotel]
    [My way]
*/

//코드 89-4 열거 타입 싱글턴 - 전통적인 싱글턴보다 우수하다
public enum Elvis {
    INSTANCE;
    private String[] favoriteSongs = {"Hound Dog", "Heartbreak Hotel"};
    public void printFavorites() {
        System.out.println(Arrays.toString(favoriteSongs));
    }
}

//코드 90-1 Period 클래스용 직렬화 프록시
public class SerializationProxy implements Serializable {
      private final Date start;
      private final Date end;
  
      SerializationProxy(Period p) {
          this.start = p.start;
          this.end = p.end;
      }
  
      private static final long serialVersionUID = 0; // 아무값이나 상관없음(아이템 87)
}

//직렬화 프록시 패턴용 writeReplace 메서드
private Object writeReplace() {
    return new SerializationProxy(this);
}

private void readObject(ObjectInputStream stream)
        throws InvalidObjectException {
    throw new InvalidObjectException("프록시가 필요합니다.");
}

// Period.SerializationProxy용 readResolve 메서드
private Object readResolve() {
    return new Period(start, end);  // public 사용자를 사용
}