// 직렬화: Object → byte[]
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data.ser"));
oos.writeObject(myObject);

// 역직렬화: byte[] → Object
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.ser"));
MyClass obj = (MyClass) ois.readObject();

// RMI, 소켓 통신 등에서 객체 전송
socket.getOutputStream().write(serializedBytes);

// 세션 정보, 설정값 등을 파일로 저장
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("session.dat"))) {
    oos.writeObject(sessionData);
}

// Redis, Memcached 등에 객체 저장 시
byte[] serialized = serialize(cacheObject);
redisTemplate.set(key, serialized);

public interface Serializable {
    // 메서드 없음
}

public class User implements Serializable {
    private String name;
    private int age;
    // ...
}

// 부모 클래스가 Serializable을 구현하면 자식도 자동으로 직렬화 가능
class Parent implements Serializable { }
class Child extends Parent { }  // Serializable

class Parent {  // Serializable 아님
    String parentData = "초기값";
}

class Child extends Parent implements Serializable {
    String childData;
}

// Enum: 자동으로 직렬화 가능, name()으로 직렬화됨
enum Status { ACTIVE, INACTIVE }

// Record (Java 14+): Serializable 구현 시 직렬화 가능
record Point(int x, int y) implements Serializable { }

public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private int age;
}

// serialVersionUID 자동 계산에 영향을 주는 요소들:
// - 클래스 이름
// - 필드 이름, 타입, 순서
// - 메서드 시그니처
// - 인터페이스 구현
// - 컴파일러 구현 (!)

1. v1 서버가 User 객체를 직렬화해서 Redis에 저장

2. 서버를 v2로 업데이트 (age 필드 추가)

3. v2 서버가 Redis에서 읽으려고 함
   → InvalidClassException! (serialVersionUID 불일치)

// serialVersionUID 명시하면 배포 후에도 기존 데이터 읽기 가능
class User implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int age;  // 새 필드는 기본값(0)으로 역직렬화
}

public class User implements Serializable {
    private String username;
    private transient String password;  // 직렬화 제외
    private transient Connection dbConn; // 직렬화 불가능한 객체
}

// 역직렬화 후
user.username  // "john" (직렬화된 값)
user.password  // null (기본값)
user.dbConn    // null (기본값)

public class CacheEntry implements Serializable {
    private String key;
    private Object value;

    // 1. 민감 정보
    private transient String secretToken;

    // 2. 캐시/파생 값 (다시 계산 가능)
    private transient int cachedHashCode;

    // 3. 직렬화 불가능한 객체
    private transient Logger logger;
    private transient Thread workerThread;
}

public class ObjectOutputStream extends OutputStream {
    // 핵심 메서드
    public final void writeObject(Object obj);
    public void writeInt(int val);
    public void writeUTF(String str);
    public void flush();
    public void close();
}

try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("data.ser"))) {
    oos.writeObject(user);
    oos.writeInt(100);
    oos.writeUTF("metadata");
}

public class ObjectInputStream extends InputStream {
    // 핵심 메서드
    public final Object readObject();
    public int readInt();
    public String readUTF();
    public void close();
}

try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("data.ser"))) {
    User user = (User) ois.readObject();
    int value = ois.readInt();
    String metadata = ois.readUTF();
}

public class SecureUser implements Serializable {
    private String username;
    private String password;

    // 정확한 시그니처: private void writeObject(ObjectOutputStream)
    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.defaultWriteObject();  // 기본 필드 직렬화

        // 커스텀 처리: 비밀번호 암호화
        String encrypted = encrypt(password);
        oos.writeObject(encrypted);
    }

    // 정확한 시그니처: private void readObject(ObjectInputStream)
    private void readObject(ObjectInputStream ois)
            throws IOException, ClassNotFoundException {
        ois.defaultReadObject();  // 기본 필드 역직렬화

        // 커스텀 처리: 비밀번호 복호화
        String encrypted = (String) ois.readObject();
        this.password = decrypt(encrypted);
    }
}

private void readObject(ObjectInputStream ois)
        throws IOException, ClassNotFoundException {
    ois.defaultReadObject();

    // 불변식 검증
    if (age < 0 || age > 150) {
        throw new InvalidObjectException("Invalid age: " + age);
    }
    if (name == null || name.isEmpty()) {
        throw new InvalidObjectException("Name cannot be empty");
    }
}

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

public class Product implements Externalizable {
    private String name;
    private double price;
    private transient int viewCount;  // transient 무의미

    // 필수: public 무인자 생성자
    public Product() { }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(name);
        out.writeDouble(price);
        // viewCount는 직렬화하지 않음
    }

    @Override
    public void readExternal(ObjectInput in)
            throws IOException, ClassNotFoundException {
        name = in.readUTF();
        price = in.readDouble();
        viewCount = 0;  // 초기화
    }
}

Singleton original = Singleton.getInstance();

// 직렬화 후 역직렬화
ObjectOutputStream oos = new ObjectOutputStream(...);
oos.writeObject(original);

ObjectInputStream ois = new ObjectInputStream(...);
Singleton restored = (Singleton) ois.readObject();

original == restored  // false! 싱글톤이 깨짐

ois.readObject() 호출
    ↓
JVM이 내부적으로 객체 역직렬화 (새 객체 생성)
    ↓
JVM이 readResolve() 있는지 확인
    ↓
있으면 readResolve() 반환값을 최종 결과로 사용

public class Singleton implements Serializable {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() { }

    public static Singleton getInstance() {
        return INSTANCE;
    }

    // 역직렬화 시 기존 인스턴스 반환
    private Object readResolve() {
        return INSTANCE;  // 새 객체 대신 싱글톤 반환
    }
}

public class User implements Serializable {
    private final String name;
    private final int age;

    public User(String name, int age) {
        // 생성자에서 검증
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("이름은 필수");
        }
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("나이가 유효하지 않음");
        }
        this.name = name;
        this.age = age;
    }

    // 직렬화 시 User 대신 Proxy 저장
    private Object writeReplace() {
        return new SerializationProxy(this);
    }

    // 공격자가 User를 직접 역직렬화하려 하면 차단
    private void readObject(ObjectInputStream s) throws InvalidObjectException {
        throw new InvalidObjectException("프록시를 통해서만 역직렬화 가능");
    }

    private static class SerializationProxy implements Serializable {
        private final String name;
        private final int age;

        SerializationProxy(User user) {
            this.name = user.name;
            this.age = user.age;
        }

        // 역직렬화 시 생성자를 통해 User 생성 → 검증 로직 실행
        private Object readResolve() {
            return new User(name, age);  // 생성자 검증이 여기서 실행됨
        }
    }
}

// 개발자가 작성하는 코드
ObjectOutputStream oos = new ObjectOutputStream(...);
oos.writeObject(user);  // 그냥 이렇게만 호출

// JVM 내부에서 일어나는 일
// 1. user 객체에 writeReplace() 있나? → 리플렉션으로 확인
// 2. 있으면 writeReplace() 호출

// 공격 시나리오
// 1. 공격자가 악의적인 바이트 스트림 생성
// 2. 서버에서 readObject() 호출
// 3. 역직렬화 과정에서 연쇄적으로 메서드 호출
// 4. 최종적으로 Runtime.exec() 등 위험한 메서드 실행

// HashSet의 해시 충돌을 이용한 DoS
// 같은 해시값을 가진 수만 개의 문자열로 HashSet 생성
// 역직렬화 시 O(n^2) 시간 소요

// 깊이 중첩된 객체로 스택 오버플로우 유발
// Set<Set<Set<...>>> 구조로 깊이 수천의 중첩

# JVM 옵션으로 설정
java -Djdk.serialFilter=com.myapp.*;!* MyApp

# 패턴 의미:
# com.myapp.*   → com.myapp 패키지 허용
# !*            → 그 외 모든 클래스 거부

ObjectInputStream ois = new ObjectInputStream(inputStream);

// 람다로 필터 설정
ois.setObjectInputFilter(info -> {
    Class<?> clazz = info.serialClass();

    if (clazz != null) {
        // 화이트리스트 검사
        if (clazz.getName().startsWith("com.myapp.")) {
            return ObjectInputFilter.Status.ALLOWED;
        }
        return ObjectInputFilter.Status.REJECTED;
    }

    // 리소스 제한 검사
    if (info.depth() > 10) {
        return ObjectInputFilter.Status.REJECTED;
    }

    return ObjectInputFilter.Status.UNDECIDED;
});

// 패턴 기반 필터 생성
ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
    "com.myapp.**;" +           // com.myapp과 하위 패키지 허용
    "java.util.*;" +            // java.util 패키지 허용
    "!com.dangerous.*;" +       // com.dangerous 패키지 거부
    "maxarray=1000;" +          // 배열 최대 크기
    "maxdepth=10;" +            // 최대 객체 그래프 깊이
    "maxrefs=1000;" +           // 최대 참조 수
    "maxbytes=100000"           // 최대 바이트 수
);

ois.setObjectInputFilter(info -> {
    // 클래스 정보
    Class<?> clazz = info.serialClass();

    // 배열 길이 (배열인 경우)
    long arrayLength = info.arrayLength();

    // 객체 그래프 깊이
    long depth = info.depth();

    // 지금까지 읽은 참조 수
    long references = info.references();

    // 지금까지 읽은 바이트 수
    long streamBytes = info.streamBytes();

    return ObjectInputFilter.Status.ALLOWED;
});

// 의존성: com.fasterxml.jackson.core:jackson-databind

ObjectMapper mapper = new ObjectMapper();

// JSON 문자열로 직렬화 (가장 일반적)
String json = mapper.writeValueAsString(user);
// 결과: {"name":"김철수","age":25}

// 바이트 배열로 직렬화 (네트워크 전송용)
byte[] bytes = mapper.writeValueAsBytes(user);
// 결과: JSON 문자열을 UTF-8 바이트로 인코딩한 것

// 역직렬화
User user = mapper.readValue(json, User.class);
List<User> users = mapper.readValue(json,
    new TypeReference<List<User>>() {});

// 개발자가 작성하는 코드
@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody User user) {
    // user 객체가 이미 만들어져서 들어옴
}

// spring-web.jar 안의 코드 (단순화)
public class MappingJackson2HttpMessageConverter {

    public Object read(Class<?> clazz, HttpInputMessage inputMessage) {
        String json = readBody(inputMessage);
        return objectMapper.readValue(json, clazz);  // Spring이 호출
    }
}

// Spring이 컨트롤러 메서드를 분석할 때 (리플렉션)
Method method = controller.getClass().getMethod("createUser", User.class);
Parameter[] params = method.getParameters();  // 리플렉션
Class<?> paramType = params[0].getType();     // → User.class

1. 클라이언트가 POST /users 요청 (JSON body)
2. Spring이 컨트롤러 메서드 찾음
3. 리플렉션으로 파라미터 타입 확인 → User.class
4. Jackson에게 전달: objectMapper.readValue(json, User.class)
5. Jackson이 리플렉션으로 User 객체 생성
6. 컨트롤러 메서드 호출