객체 일련화란?
"객체 일련화"는 무엇을 의미하는가?몇 가지 예를 들어 설명해 주시겠습니까?
직렬화는 객체를 일련의 바이트로 변환하는 것으로, 객체를 영구 저장소에 쉽게 저장하거나 통신 링크를 통해 스트리밍할 수 있다.바이트 스트림을 역직렬화할 수 있다 - 원래 개체의 복제본으로 변환할 수 있다.
직렬화는 객체 인스턴스(instance)를 바이트의 시퀀스(이진일 수도 있고 구현에 따라 다를 수도 있음)로 변환하는 과정이라고 생각할 수 있다.
예를 들어, 한 JVM에서 다른 JVM으로 하나의 객체 데이터를 네트워크를 통해 전송하고자 할 때 매우 유용하다.
자바에서는 직렬화 메커니즘이 플랫폼에 내장되어 있지만, 직렬화 가능한 인터페이스를 구현해야 개체를 직렬화 할 수 있다.
또한 속성을 임시로 표시하여 개체의 일부 데이터가 직렬화되는 것을 방지할 수 있다.
마지막으로 기본 메커니즘을 재정의하고 고유한 메커니즘을 제공할 수 있다. 이것은 일부 특별한 경우에 적합할 수 있다.이렇게 하려면 Java의 숨겨진 기능 중 하나를 사용하십시오.
직렬화되는 것은 클래스 정의가 아니라 객체의 "값" 또는 내용이라는 것을 알아두는 것이 중요하다.따라서 방법은 직렬화되지 않는다.
다음은 읽기 쉽도록 코멘트가 포함된 매우 기본적인 샘플이다.
import java.io.*;
import java.util.*;
// This class implements "Serializable" to let the system know
// it's ok to do it. You as programmer are aware of that.
public class SerializationSample implements Serializable {
// These attributes conform the "value" of the object.
// These two will be serialized;
private String aString = "The value of that string";
private int someInteger = 0;
// But this won't since it is marked as transient.
private transient List<File> unInterestingLongLongList;
// Main method to test.
public static void main( String [] args ) throws IOException {
// Create a sample object, that contains the default values.
SerializationSample instance = new SerializationSample();
// The "ObjectOutputStream" class has the default
// definition to serialize an object.
ObjectOutputStream oos = new ObjectOutputStream(
// By using "FileOutputStream" we will
// Write it to a File in the file system
// It could have been a Socket to another
// machine, a database, an in memory array, etc.
new FileOutputStream(new File("o.ser")));
// do the magic
oos.writeObject( instance );
// close the writing.
oos.close();
}
}
이 프로그램을 실행하면 "o.ser"라는 파일이 만들어지고 그 뒤에 무슨 일이 일어났는지 알 수 있다.
다음 값을 변경하는 경우: someInteger를 정수(예: 정수)로 변경하십시오.MAX_VALUE, 우리는 그 차이가 무엇인지 보기 위해 출력을 비교할 수 있다.
여기 그 차이를 정확하게 보여주는 스크린샷이 있다.
차이점을 알아낼 수 있겠니?;)
Java 직렬화에는 다음과 같은 추가 관련 필드가 있다.시리얼버전UID는 근데 벌써 너무 길어서 커버가 안 되나 봐봐.
6살짜리 질문에 과감하게 대답하고, 자바에 처음 온 사람들을 위한 매우 높은 수준의 이해도를 추가했다.
직렬화란?
개체를 바이트로 변환
탈직렬화란 무엇인가?
바이트를 개체로 다시 변환하는 중(디시리얼라이제이션).
직렬화는 언제 사용되나?
개체를 지속하고 싶을 때.JVM의 수명을 초과하여 객체가 존재하기를 원할 때.
실제 환경 예:
ATM : 계좌 보유자가 ATM을 통해 서버에서 돈을 인출하려고 할 때 인출내역과 같은 계좌 보유자 정보가 일련화 되어 해당 내역을 탈직렬화하여 운용하는 서버로 전송된다.
자바에서 직렬화를 수행하는 방법.
실행하다
java.io.Serializable인터페이스(프로젝트 인터페이스를 제공하므로 구현할 방법이 없음).개체 유지:사용하다
java.io.ObjectOutputStreamclass, 하위 수준 바이트 스트림 주위의 래퍼인 필터 스트림(파일 시스템에 오브젝트를 쓰거나 네트워크 와이어를 통해 평평해진 오브젝트를 전송하고 반대편에 재구성하는 것).
writeObject(<<instance>>)- 목적어를 쓰다readObject()- 직렬화된 객체를 읽으려면
다음 사항을 기억하십시오.
개체를 직렬화하면 개체의 클래스 파일이나 메서드가 아니라 개체의 상태만 저장된다.
2바이트 개체를 직렬화하면 51바이트 직렬화 파일이 나타난다.
개체를 직렬화 및 직렬화 해제하는 단계.
답변:어떻게 51바이트 파일로 변환되었는가?
- 먼저 직렬화 스트림 매직 데이터(STREAM_MAGIAL= "AC ED" 및 스트림_VERSION=JVM 버전)를 쓴다.
- 그런 다음 인스턴스와 연결된 클래스의 메타데이터(클래스 길이, 클래스 이름, serialVersionUID)를 기록한다.
- 그런 다음 슈퍼클래스의 메타데이터를 찾을 때까지 반복적으로 작성한다.
java.lang.Object. - 그런 다음 인스턴스와 연결된 실제 데이터로 시작하십시오.
- 마지막으로 메타데이터에서 실제 컨텐츠로 시작하는 인스턴스와 연결된 개체의 데이터를 기록한다.
당신은 또한 여기서 나의 유튜브 비디오 설명을 확인할 수 있다.
편집 : 읽을 참조 링크.
이렇게 하면 몇 가지 자주 묻는 질문에 답할 수 있다.
클래스의 필드를 직렬화하지 않는 방법.
ANS: 임시 키워드 사용자식 클래스가 직렬화되면 부모 클래스가 직렬화되는가?
Ans: 아니, 부모가 직렬화 가능한 인터페이스 부모 필드를 확장하지 않으면 직렬화되지 마십시오.부모가 직렬화되면 자식 클래스가 직렬화되는가?
앤스: 그래, 기본적으로 아동 클래스도 직렬화 돼.아동 클래스가 직렬화되는 것을 방지하는 방법
스st: a. 를 무시하고 writeObject 및 readObject 서서방 throw서기 throw throw throw throw throw의의의의의지지지지지지지지지지지지지지지지지지NotSerializableException.또한 아동 클래스의 모든 필드를 일시적 상태로 표시할 수 있다.
Thread, OutputStream 및 그 하위 클래스, Socket과 같은 일부 시스템 레벨 클래스는 직렬화할 수 없다.
직렬화는 메모리에 있는 "실시간" 객체를 가져다가 어딘가에 저장될 수 있는 형식(예: 메모리, 디스크)으로 변환하고 나중에 "직접화"된 객체를 다시 라이브 객체로 변환하는 것이다.
@OscarRyz가 선물하는 방식이 마음에 들었다.비록 여기서 나는 @amitgupta에 의해 원래 쓰여진 연재화 이야기를 계속하고 있다.
비록 로봇 클래스 구조에 대해 알고 있고 직렬화된 데이터를 가지고 있지만, 지구의 과학자는 로봇을 작동시킬 수 있는 데이터를 역직렬화할 수 없었다.
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:
화성의 과학자들은 완전한 지불을 기다리고 있었다.일단 지불이 끝났을 때, 화성의 과학자들은 연재버전을 공유했다.지구과학자들과의 UID.지구의 과학자는 그것을 로봇 수업으로 정했고 모든 것이 좋아졌다.
내 블로그에서 얻은 나의 2센트:
직렬화:
직렬화는 물체의 상태를 지속시키는 과정이다.바이트 순서의 형태로 표시되고 저장된다.이것은 파일에 저장할 수 있다.파일에서 개체의 상태를 읽고 복원하는 프로세스를 탈직렬화라고 한다.
연재화의 필요성은 무엇인가?
현대 건축에서는 항상 객체 상태를 저장한 다음 그것을 회수할 필요가 있다.예를 들어, 최대 절전 모드에서는 객체를 저장하려면 클래스를 직렬화할 수 있도록 만들어야 한다.그것이 하는 일은 일단 객체 상태가 바이트 형태로 저장되면, 그것은 다른 시스템으로 전송될 수 있고, 그것은 그 상태에서 읽고 클래스를 불러올 수 있다.개체 상태는 데이터베이스나 다른 jvm 또는 별도의 구성 요소에서 발생할 수 있다.직렬화의 도움으로 우리는 객체 상태를 검색할 수 있다.
코드 예제 및 설명:
먼저 Item Class:
public class Item implements Serializable{
/**
* This is the Serializable class
*/
private static final long serialVersionUID = 475918891428093041L;
private Long itemId;
private String itemName;
private transient Double itemCostPrice;
public Item(Long itemId, String itemName, Double itemCostPrice) {
super();
this.itemId = itemId;
this.itemName = itemName;
this.itemCostPrice = itemCostPrice;
}
public Long getItemId() {
return itemId;
}
@Override
public String toString() {
return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
}
public void setItemId(Long itemId) {
this.itemId = itemId;
}
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}
public Double getItemCostPrice() {
return itemCostPrice;
}
public void setItemCostPrice(Double itemCostPrice) {
this.itemCostPrice = itemCostPrice;
}
}
위의 코드에서 Item class가 Serializable을 구현하는 것을 볼 수 있다.
이것은 클래스를 직렬화할 수 있게 해주는 인터페이스다.
이제 serialVersion이라는 변수를 볼 수 있다.UID가 Long 변수로 초기화되었다.이 숫자는 컴파일러가 클래스의 상태와 클래스 속성에 기초하여 계산한다.jvm이 파일에서 객체의 상태를 읽을 때 객체의 상태를 식별하는 데 도움이 되는 숫자다.
이를 위해 공식 Oracle 설명서를 살펴보십시오.
직렬화 런타임은 serialVersion이라고 하는 각 직렬화 가능 클래스와 버전 번호를 연결한다.직렬화된 개체의 송신자와 수신기가 직렬화와 관련하여 호환되는 클래스를 로드했는지 확인하기 위해 역직렬화 중에 사용되는 UID.수신기가 다른 serialVersion을 가진 객체의 클래스를 로드한 경우해당 발송인 클래스의 UID보다 높은 UID를 가진 후 역직렬화하면 InvalidClassException이 발생한다.직렬화할 수 있는 클래스는 자체 serialVersion을 선언할 수 있음"serialVersion" 필드를 선언하여 UID를 명시적으로 표시정적, 최종 및 긴 형식이어야 하는 UID: ANY-Access-Modifier 정적 직렬 버전UID = 42L; 직렬화할 수 있는 클래스가 serialVersion을 명시적으로 선언하지 않는 경우UID, 그러면 직렬화 런타임에 기본 serialVersion이 계산됨Java(TM) Object Serialization Specification에 설명된 대로 클래스의 다양한 측면을 기반으로 하는 클래스의 UID 값.그러나 모든 직렬화 가능 클래스는 serialVersion을 명시적으로 선언할 것을 강력히 권장한다.기본 serialVersion 이후 UID 값UID 계산은 컴파일러 구현에 따라 달라질 수 있는 클래스 세부 정보에 매우 민감하므로 탈시리얼화 중에 예상치 못한 InvalidClassExceptions가 발생할 수 있다.따라서 일관된 serialVersion 보장서로 다른 Java 컴파일러 구현의 UID 값, 직렬화할 수 있는 클래스는 명시적 serialVersion을 선언해야 함UID 값.또한 명시적 serialVersion이(가)UID 선언은 즉시 선언하는 class-serialVersion에만 적용되므로 가능한 경우 개인 수정자를 사용한다.UID 필드는 상속된 구성원으로서 유용하지 않다.
만약 당신이 우리가 사용한 또 다른 키워드가 있다면 그것은 일시적인 것이다.
필드를 일련화할 수 없는 경우 일시적임을 표시해야 한다.여기서는 CostPrice 항목을 일시적 항목으로 표시했으며 파일에 기록하지 마십시오.
이제 파일 안에 있는 물체의 상태를 어떻게 쓰고 거기서 어떻게 읽는지 살펴봅시다.
public class SerializationExample {
public static void main(String[] args){
serialize();
deserialize();
}
public static void serialize(){
Item item = new Item(1L,"Pen", 12.55);
System.out.println("Before Serialization" + item);
FileOutputStream fileOut;
try {
fileOut = new FileOutputStream("/tmp/item.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(item);
out.close();
fileOut.close();
System.out.println("Serialized data is saved in /tmp/item.ser");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void deserialize(){
Item item;
try {
FileInputStream fileIn = new FileInputStream("/tmp/item.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
item = (Item) in.readObject();
System.out.println("Serialized data is read from /tmp/item.ser");
System.out.println("After Deserialization" + item);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
위에서 우리는 물체의 직렬화와 탈직렬화의 예를 볼 수 있다.
그것을 위해 우리는 두 개의 수업을 이용했다.개체를 직렬화하기 위해 ObjectOutputStream을 사용해 왔다.writeObject 방법을 사용하여 파일에 객체를 작성했다.
역직렬화를 위해 우리는 파일에서 객체를 읽는 ObjectInputStream을 사용해 왔다.파일에서 객체 데이터를 읽기 위해 readObject를 사용한다.
위 코드의 출력은 다음과 같다.
Before SerializationItem [itemId=1, itemName=Pen, itemCostPrice=12.55]
Serialized data is saved in /tmp/item.ser
After DeserializationItem [itemId=1, itemName=Pen, itemCostPrice=null]
항목CostPrice from deserialized object는 기록되지 않았기 때문에 null입니다.
우리는 이미 이 기사의 1부에서 자바 직렬화의 기본에 대해 논의하였다.
이제 그 문제와 그 작동 방식에 대해 깊이 논의해 봅시다.
먼저 serialversionuid부터 시작해보자.
serialVersionUID는 Serialable 클래스에서 버전 제어로 사용된다.
명시적으로 serialVersion을 선언하지 않은 경우UID, JVM이 직렬화 가능 클래스의 다양한 속성을 기반으로 자동으로 실행해 줄 것이다.
Java의 serialversionuid 계산 알고리즘(자세한 내용은 여기에서 읽어 보십시오)
- 반 이름.
- 32비트 정수로 작성된 클래스 한정자.
- 이름별로 정렬된 각 인터페이스의 이름.
- 필드 이름별로 정렬된 클래스의 각 필드에 대해(전용 정적 및 개인 임시 필드 제외):필드의 이름.32비트 정수로 작성된 필드의 수정자.필드의 설명자.
- 클래스 이니셜라이저가 있는 경우 다음을 기록하십시오.메서드의 이름, .
- 메서드의 수식어, java.lang.reflect.수식어정적, 32비트 정수로 기록.
- 메서드의 설명자()V.
- 메서드 이름 및 서명별로 정렬된 각 비개인 생성자에 대해:메서드의 이름, . 32비트 정수로 작성된 메서드의 수정자.메소드의 설명자.
- 메서드 이름 및 서명별로 정렬된 각 비 개인 메서드에 대해:메서드의 이름.32비트 정수로 작성된 메서드의 수정자.메소드의 설명자.
- SHA-1 알고리즘은 DataOutputStream에서 생성된 바이트 스트림에서 실행되며 5개의 32비트 값 shah[0..4]을 생성한다.해시 값은 SHA-1 메시지 다이제스트의 첫 번째 및 두 번째 32비트 값에서 수집된다.메시지 다이제스트의 결과인 5개의 32비트 단어 H0 H1 H2 H3 H4가 sha라는 5개의 int 값의 배열 안에 있다면 해시 값은 다음과 같이 계산될 것이다.
long hash = ((sha[0] >>> 24) & 0xFF) |
> ((sha[0] >>> 16) & 0xFF) << 8 |
> ((sha[0] >>> 8) & 0xFF) << 16 |
> ((sha[0] >>> 0) & 0xFF) << 24 |
> ((sha[1] >>> 24) & 0xFF) << 32 |
> ((sha[1] >>> 16) & 0xFF) << 40 |
> ((sha[1] >>> 8) & 0xFF) << 48 |
> ((sha[1] >>> 0) & 0xFF) << 56;
자바의 직렬화 알고리즘
개체를 직렬화하는 알고리즘은 다음과 같이 설명된다.
와1. 인스턴스와 연결된 클래스의 메타데이터를 기록한다.
2. java.lang.object를 찾을 때까지 superclass에 대한 설명을 반복적으로 쓴다.
일단 데이터로 3. 메타데이터 정보 작성을 마치면, 해당 인스턴스와 관련된 실제 데이터로 시작한다.하지만 이번에는 최상급 슈퍼클래스에서 시작한다.
4 최소 수퍼클래스부터 가장 파생된 클래스까지 인스턴스와 관련된 데이터를 재귀적으로 기록한다.
명심해야 할 사항:
클래스의 정적 필드는 직렬화할 수 없음.
public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; }유체가 유체가 .
InvalidClassException예외의클래스가 직렬화 가능을 구현하면 모든 하위 클래스도 직렬화 가능해진다.
public class A implements Serializable {....}; public class B extends A{...} //also Serializable클래스에 다른 클래스의 참조가 있는 경우 모든 참조가 직렬화 가능해야 하며 그렇지 않으면 직렬화 프로세스가 수행되지 않는다.이 경우 NotSerializable런타임에 예외가 발생함
예:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
직렬화는 Java에서 객체를 지속하는 것을 의미한다.개체의 상태를 저장하고 나중에 상태를 재구성하려는 경우(다른 JVM에 있을 수 있음) 직렬화를 사용할 수 있다.
개체의 속성만 저장된다는 점에 유의하십시오.개체를 다시 부활시키려면 클래스 파일이 있어야 하는데, 멤버 변수는 멤버 기능만 저장되고 멤버 기능은 저장되지 않기 때문이다.
예:
ObjectInputStream oos = new ObjectInputStream(
new FileInputStream( new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();
Searializable은 클래스가 직렬화할 수 있음을 표시하는 마커 인터페이스입니다.마커 인터페이스는 빈 인터페이스일 뿐이며, 이 인터페이스를 사용하면 JVM에 이 클래스를 직렬화할 수 있음을 알린다.
직렬화는 물체의 상태를 비트로 변환하여 하드 드라이브에 저장할 수 있도록 하는 과정이다.동일한 객체를 역직렬화하면 나중에 해당 상태를 유지한다.손으로 개체의 속성을 저장하지 않고도 개체를 재생성할 수 있다.
http://en.wikipedia.org/wiki/Serialization
Java 개체 일련화
Serialization Java 객체의 그래프를 저장용 바이트 배열로 변환하는 메커니즘이다(to disk file는 는()across a network)) 그런 다음 탈직렬화를 사용하여 객체 그래프를 복원할 수 있다.참조 공유 메커니즘을 사용하여 개체의 그래프를 올바르게 복원한다.그러나 저장하기 전에 serialVersion을(를) 확인하십시오.입력 파일/네트워크 및 .class 파일 serialVersion의 UIDUID는 동일하다. 그렇지 않으면 를 던지십시오.
각 버전 클래스는 스트림을 쓸 수 있고 읽을 수 있는 원본 클래스 버전을 식별해야 한다.예를 들어, 버전 클래스는 다음을 선언해야 한다.
직렬 버전UID 구문
// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L;
직렬 버전UID는 직렬화 과정에 필수적이다.그러나 개발자가 그것을 자바 소스 파일에 추가하는 것은 선택 사항이다.serialVersion인 경우UID가 포함되지 않은 경우 직렬화 런타임에서 serialVersion이 생성됨UID를 수업과 연계시켜라.직렬화된 개체에 이 serialVersion이 포함됨UID와 다른 데이터.
참고 - 모든 직렬화 가능 클래스는 serialVersion을 명시적으로 선언하는 것이 권장됨따라서 예기치 않은 serialVersion이 발생할 수 있음역직렬화 중 UID 충돌이 발생하여 역직렬화가 실패함
Java 개체는 오직 직렬화 할 수 있다. 클래스나 그 슈퍼클래스가 java.io을 구현하는 경우.직렬화할 수 있는 인터페이스 또는 하위 인터페이스인 java.io.외관상 가능.
수업은 java.io을 구현해야 한다.개체를 성공적으로 직렬화하기 위한 직렬화 가능한 인터페이스.직렬화 가능은 마커 인터페이스로, 컴파일러가 이를 구현하는 클래스가 직렬화 가능 동작을 추가해야 함을 알리는 데 사용된다.여기서 자바 가상 머신(JVM)은 자동 직렬화를 담당한다.
임시 키워드:
java.io.Serializable interface개체를 직렬화하는 동안 개체의 특정 데이터 구성원이 직렬화되지 않도록 하려면 과도 수식어를 사용하십시오.일시적인 키워드는 데이터 구성원이 직렬화되는 것을 방지한다.
- 과도 또는 정적으로 선언된 필드는 직렬화 프로세스에서 무시된다.
+--------------+--------+-------------------------------------+ | Flag Name | Value | Interpretation | +--------------+--------+-------------------------------------+ | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.| +--------------+--------+-------------------------------------+ |ACC_TRANSIENT | 0x0080 | Declared transient; not written or | | | | read by a persistent object manager.| +--------------+--------+-------------------------------------+class Employee implements Serializable { private static final long serialVersionUID = 2L; static int id; int eno; String name; transient String password; // Using transient keyword means its not going to be Serialized. }Externalable 인터페이스를 구현하면 객체가 객체의 직렬화된 형태의 내용과 형식을 완전히 제어할 수 있다고 가정할 수 있다.Externalable 인터페이스의 방법, 쓰기External 및 readExternal은 객체 상태를 저장 및 복원하기 위해 호출된다.클래스에 의해 구현되면 ObjectOutput과 ObjectInput의 모든 방법을 사용하여 자신의 상태를 쓰고 읽을 수 있다.발생하는 모든 버전 관리를 처리하는 것은 개체의 책임이다.
class Emp implements Externalizable { int eno; String name; transient String password; // No use of transient, we need to take care of write and read. @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(eno); out.writeUTF(name); //out.writeUTF(password); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.eno = in.readInt(); this.name = in.readUTF(); //this.password = in.readUTF(); // java.io.EOFException } }를 만이 java.io.java.io를 지지한다.직렬화 가능 또는 java.io.외부 가능 인터페이스는
written to/read from시물 각 한 객체의 및 등을 각 직렬화할 수 있는 개체의 클래스는 클래스의 클래스 이름과 시그니처, 개체의 필드 및 배열 값, 초기 개체에서 참조된 다른 개체의 닫힘 등을 포함하여 인코딩된다.
파일에 대한 일련 번호 지정 예
public class SerializationDemo {
static String fileName = "D:/serializable_file.ser";
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
Employee emp = new Employee( );
Employee.id = 1; // Can not Serialize Class data.
emp.eno = 77;
emp.name = "Yash";
emp.password = "confidential";
objects_WriteRead(emp, fileName);
Emp e = new Emp( );
e.eno = 77;
e.name = "Yash";
e.password = "confidential";
objects_WriteRead_External(e, fileName);
/*String stubHost = "127.0.0.1";
Integer anyFreePort = 7777;
socketRead(anyFreePort); //Thread1
socketWrite(emp, stubHost, anyFreePort); //Thread2*/
}
public static void objects_WriteRead( Employee obj, String serFilename ) throws IOException{
FileOutputStream fos = new FileOutputStream( new File( serFilename ) );
ObjectOutputStream objectOut = new ObjectOutputStream( fos );
objectOut.writeObject( obj );
objectOut.close();
fos.close();
System.out.println("Data Stored in to a file");
try {
FileInputStream fis = new FileInputStream( new File( serFilename ) );
ObjectInputStream ois = new ObjectInputStream( fis );
Object readObject;
readObject = ois.readObject();
String calssName = readObject.getClass().getName();
System.out.println("Restoring Class Name : "+ calssName); // InvalidClassException
Employee emp = (Employee) readObject;
System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);
ois.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void objects_WriteRead_External( Emp obj, String serFilename ) throws IOException {
FileOutputStream fos = new FileOutputStream(new File( serFilename ));
ObjectOutputStream objectOut = new ObjectOutputStream( fos );
obj.writeExternal( objectOut );
objectOut.flush();
fos.close();
System.out.println("Data Stored in to a file");
try {
// create a new instance and read the assign the contents from stream.
Emp emp = new Emp();
FileInputStream fis = new FileInputStream(new File( serFilename ));
ObjectInputStream ois = new ObjectInputStream( fis );
emp.readExternal(ois);
System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);
ois.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
네트워크를 통한 직렬화 가능 예제
동일한 컴퓨터의 서로 다른 프로세스에서 또는 네트워크를 통해 연결된 여러 컴퓨터에 있는 서로 다른 주소 공간에 오브젝트 상태를 분산시키지만, 데이터를 공유하고 메소드를 호출하여 함께 작동한다.
/**
* Creates a stream socket and connects it to the specified port number on the named host.
*/
public static void socketWrite(Employee objectToSend, String stubHost, Integer anyFreePort) {
try { // CLIENT - Stub[marshalling]
Socket client = new Socket(stubHost, anyFreePort);
ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream());
out.writeObject(objectToSend);
out.flush();
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// Creates a server socket, bound to the specified port.
public static void socketRead( Integer anyFreePort ) {
try { // SERVER - Stub[unmarshalling ]
ServerSocket serverSocket = new ServerSocket( anyFreePort );
System.out.println("Server serves on port and waiting for a client to communicate");
/*System.in.read();
System.in.read();*/
Socket socket = serverSocket.accept();
System.out.println("Client request to communicate on port server accepts it.");
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
Employee objectReceived = (Employee) in.readObject();
System.out.println("Server Obj : "+ objectReceived.name );
socket.close();
serverSocket.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
@ 참조
직렬화는 저장 매체(파일, 메모리 버퍼 등)에 객체를 저장하거나 이진 형태로 네트워크 연결을 통해 전송하는 과정이다.직렬화된 개체는 JVM 독립적이며, JVM에 의해 다시 직렬화될 수 있다.이 경우 "메모리 내" 자바 객체 상태는 바이트 스트림으로 변환된다.이 형식의 파일은 사용자가 이해할 수 없다.JVM(Java Virtual Machine)에 의해 재사용되는 특별한 유형의 개체다.물체를 직렬화하는 이 과정을 물체를 탈기 또는 습기화라고도 한다.
직렬화할 객체는 반드시 구현되어야 함java.io.Serializable 및 및 의 값을 기록한다객체에 대한 기본 직렬화 메커니즘은 객체의 클래스, 클래스 시그니처 및 모든 비투과 및 비정적 필드의 값을 기록한다.
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,
ObjectOutput인터페이스가 확장됨DataOutput인터페이스 및 파일에 객체를 직렬화하고 바이트를 쓰는 메소드를 추가한다.그ObjectOutputStream연장하다java.io.OutputStream도구 및 도구ObjectOutput접 스트림에 객체, 배열 및 기타 값을 직렬화한다.따라서 의 생성자는ObjectOutputStream다음과 같이 기록된다.
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));
위의 코드가 의 인스턴스를 만드는 데 사용됨ObjectOutput…과 어깨를 나란히 하다ObjectOutputStream( )는 건설업子이다.FileOuputStream매개 변수로서
그ObjectOutput인터페이스는 구현에 의해 사용된다.ObjectOutputStream. 학급ObjectOutputStream객체를 직렬화하도록 구성된다.
Java에서 개체 역직렬화
직렬화의 반대작용을 탈직렬화(deserialization)라고 한다. 즉, 일련의 바이트로부터 데이터를 추출하는 것을 탈직렬화(deserialization)라고 하는데, 이를 탈직렬화(deserialization)라고도 하며, 이를 팽창 또는 언마샬링이라고도 한다.
ObjectInputStream연장하다java.io.InputStream도구 및 도구ObjectInput접 및 입력 스트림에서 객체, 배열 및 기타 값을 역직렬화한다.따라서 의 생성자는ObjectInputStream다음과 같이 기록된다.
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));
에서는 '그대로'의 예를 .ObjectInputStream클래스: 에 의해 일련화된 파일을 역직렬화함ObjectInputStream. 위의 코드는 의 인스턴스를 사용하여 인스턴스를 생성한다.FileInputStream다음 이유로 역직렬화해야 하는 지정된 파일 객체를 포함하는 클래스ObjectInputStream()시공자는 입력 스트림이 필요하다.
직렬화는 자바 객체를 바이트 배열로 만든 다음 보존 상태로 다시 객체로 만드는 과정이다.네트워크를 통해 객체를 보내거나 물건을 디스크에 캐싱하는 등 다양한 용도로 유용하다.
프로세스의 프로그래밍 부분을 잘 설명하는 이 짧은 기사에서 자세히 읽은 다음 직렬화 가능한 javadoc으로 이동하십시오.당신은 또한 이 관련된 질문을 읽는 것에 흥미가 있을지도 모른다.
파일을 개체로 반환: http://www.tutorialspoint.com/java/java_serialization.htm
import java.io.*;
public class SerializeDemo
{
public static void main(String [] args)
{
Employee e = new Employee();
e.name = "Reyan Ali";
e.address = "Phokka Kuan, Ambehta Peer";
e.SSN = 11122333;
e.number = 101;
try
{
FileOutputStream fileOut =
new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf("Serialized data is saved in /tmp/employee.ser");
}catch(IOException i)
{
i.printStackTrace();
}
}
}
import java.io.*;
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Name: " + e.name);
System.out.println("Address: " + e.address);
System.out.println("SSN: " + e.SSN);
System.out.println("Number: " + e.number);
}
}
|*| 클래스 직렬화 : 객체를 바이트와 바이트로 변환(Deserialization)
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}
는 물체의 의 증기로 => 객체-시리얼라이징은 물체의 상태를 바이트의 증기로 변환하는 과정이다.
- |-> JVM의 수명을 넘어 객체가 존재하기를 원할 때 구현한다.
- |-> 직렬화된 객체는 데이터베이스에 저장할 수 있다.
- |-> 직렬화할 수 있는 사물은 인간이 읽고 이해할 수 없기 때문에 우리는 신중을 기할 수 있다.
|=> 오브젝트-디시리얼라이징은 오브젝트의 상태를 가져와 오브젝트(java.lang)에 저장하는 과정이다.목적어).
- |-> 상태를 저장하기 전에 serialVersion 여부를 확인한다.UID 양식 입력 파일/네트워크 및 .class 파일 serialVersionUID는 똑같다.
  If는 java.io을 던지지 않는다.잘된된 ClassException.
|=> Java 객체는 그 클래스나 그 슈퍼클래스 중 어느 것이라도 직렬화할 수 있을 뿐이다.
- ling haughdoesci를 한다.직렬화할 수 있는 인터페이스 또는
- 그것의 하위 인터페이스인 java.io.외관상 가능.
할 수 => 클래스의 정적 필드는 연재할 수 없다.
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}
|=> 클래스의 변수를 직렬화하지 않으려면 과도 키워드를 사용하십시오.
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}
한 할 수 => 한 클래스가 직렬화할 수 있는 기능을 구현하면 모든 하위 클래스도 직렬화할 수 있다.
해야 하며 직렬화 되지 않는다=> 클래스에 다른 클래스의 참조가 있는 경우 모든 참조가 직렬화 가능해야 하며 그렇지 않으면 직렬화 프로세스가 수행되지 않는다.이런 경우에는
NotSerialableNotSerialable런타임에 예외가 발생함
나는 오브젝트 일련화/불필수화의 개념적 목적/실용성을 확고히 하는 데 도움이 될 수 있는 비유를 제시할 것이다.
나는 스톰 드레인(storm drain)을 통해 물체를 이동하려는 맥락에서 물체 일련화/불직화를 상상한다.개체는 매체를 통한 통로를 효과적으로 허가하기 위해 본질적으로 "감축"되거나 그 자체의 더 모듈형 버전(이 경우, 일련의 바이트)으로 직렬화된다.계산적인 의미에서, 우리는 스톰 드레인에서 바이트로 이동한 경로를 네트워크를 통해 이동하는 바이트와 유사하다고 볼 수 있다.우리는 보다 바람직한 교통수단, 즉 형식에 부합하기 위해 우리의 목적을 변화시키고 있다.직렬화된 개체는 일반적으로 나중에 읽거나 쓰거나 둘 다로 읽을 수 있는 이진 파일에 저장된다.
아마도 일단 우리의 물체가 분해된 일련의 바이트로서 배수구를 빠져나갈 수 있게 되면, 우리는 그 물체의 표현을 데이터베이스나 하드 디스크 드라이브 내의 이진 데이터로 저장하기를 원할 것이다.그러나 가장 중요한 테이크아웃은 직렬화/직렬화를 통해 직렬화된 후 우리의 개체를 그것의 이진 형태로 유지하도록 하거나, 탈직렬화를 수행함으로써 개체의 원래 형태를 "재시도"할 수 있다는 것이다.
직렬화는 개체의 특정 상태를 바이트 코드로 변환하여 저장하는 과정이다.이 변환된 바이트 코드는 수신 JVM이 공유된 개체의 상태를 검색하기 위해 바이트 코드를 역직렬화하는 2 JVM 사이의 개체 상태를 전송하는 데 사용된다.serialVersion을 사용하여 serialization 및 deserialization 수행관련된 JVMS에서 참조하는 UID.
Java에서도 직렬화 및 외부화 인터페이스를 사용하여 동일한 결과를 얻음
참조URL: https://stackoverflow.com/questions/447898/what-is-object-serialization
'programing' 카테고리의 다른 글
| 서로 다른 것을 참조하는 마우스 호버 기능서로 다른 것을 참조하는 마우스 호버 기능같은 Vue.js 함수에서. (0) | 2022.05.20 |
|---|---|
| 현재 프로세스가 GDB에서 실행 중인지 탐지하는 방법 (0) | 2022.05.20 |
| 수업에서 개인 필드의 수정을 방지하려면 어떻게 해야 하는가? (0) | 2022.05.20 |
| Vue js 동적으로 구성 요소 가져오기 (0) | 2022.05.20 |
| Vue v-on:click.native in JSX? (0) | 2022.05.20 |