Was ist Objektserialisierung?
https://stackoverflow.com/questions/447898
-
19-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Was ist mit „Objektserialisierung“ gemeint? Können Sie bitte es mit einigen Beispielen erläutern?
Lösung
Serialisierung ist die Umwandlung von einem Objekt in eine Reihe von Bytes, so dass das Objekt leicht zu persistenten Speicher oder gestreamt über eine Kommunikationsverbindung gespeichert werden können. Der Byte-Strom kann dann deserialisiert werden. - in eine Kopie des ursprünglichen Objekts umgewandelt
Andere Tipps
Sie können als das Verfahren der Serialisierung denken eine Objektinstanz in eine Folge von Bytes Umwandlung (die binär sein kann oder nicht, abhängig von der Implementierung).
Es ist sehr nützlich, wenn Sie ein Objekt Daten über das Netzwerk übertragen werden sollen, zum Beispiel von einer JVM zu einem anderen.
In Java, der Serialisierungsmechanismus in die Plattform integriert ist, aber Sie müssen zur Umsetzung der Serializable Schnittstelle ein Objekt serialisierbar zu machen.
Sie können auch einige Daten in Ihrem Objekt verhindern, wie durch Markieren Sie das Attribut serialisiert transiente .
Schließlich können Sie den Standardmechanismus außer Kraft setzen, und geben Sie Ihre eigenen; Dies kann in einigen besonderen Fällen geeignet sein. Um dies zu tun, verwenden Sie einen der versteckte Funktionen in Java .
Es ist wichtig zu bemerken, dass der „Wert“ des Objekts, was serialisiert wird ist, oder der Inhalt und nicht die Klassendefinition. So Methoden werden nicht serialisiert.
Hier ist ein sehr einfaches Beispiel mit Kommentaren seine Lektüre zu erleichtern:
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();
}
}
Wenn wir dieses Programm ausführen, die Datei „o.ser“ erstellt wird, und wir können sehen, was hinter passiert ist.
Wenn wir den Wert ändern. someInteger , um zum Beispiel Integer.MAX_VALUE , so können wir die Ausgabe vergleichen, um zu sehen, was der Unterschied ist,
Hier ist ein Screenshot genau diesen Unterschied zeigt:
Können Sie die Unterschiede? ;)
Es gibt ein zusätzliches entsprechendes Feld in Java Serialisierung: Die serialVersionUID aber ich denke, das schon zu lange ist es zu decken.
Daring 6 Jahre alte Frage zu beantworten, das Hinzufügen nur ein sehr hohes Niveau Verständnis für Menschen neu in Java
Was ist Serialisierung?
, ein Objekt zu konvertieren Bytes und Bytes zurück zum Objekt (Deserialisierung).
, wenn sich die Serialisierung verwendet?
Wenn wir das Objekt dauerhaft beibehalten möchten. Wenn wir das Objekt existieren über die gesamte Lebensdauer der JVM wollen.
Real World Beispiel:
ATM. Wenn der Kontoinhaber versucht, Geld von dem Server über Geldautomaten abheben, der Kontoinhaber Informationen wie withdrawl Details werden serialisiert und an den Server gesendet werden, in dem die Einzelheiten deserialisiert und verwendet Operationen auszuführen
Wie die Serialisierung in Java ausgeführt wird.
-
java.io.SerializableSchnittstelle (Marker-Schnittstelle, so dass keine Methode zu implementieren) Umsetzung. -
das Objekt persistent: Verwendung
java.io.ObjectOutputStreamKlasse, einen Filterstrom, der eine Hülle um einen untergeordneten Bytestrom ist (schreiben Objektsysteme zur Datei oder ein abgeflachte Objekt über ein Netzwerk Draht übertragen und auf der anderen Seite wieder aufgebaut ).-
writeObject(<<instance>>)- ein Objekt schreiben -
readObject()- ein serialisierte Objekt lesen
-
Beachten Sie:
Wenn Sie ein Objekt serialisiert, nur den Zustand des Objekts wird gespeichert, nicht die Klasse des Objektdatei oder Methoden.
Wenn Sie ein 2-Byte-Objekt serialisiert, sehen Sie 51 Bytes serialisiert Datei.
Die Schritte, wie das Objekt serialisiert und deserialisiert ist.
Antwort für: Wie kam es zu 51 Byte-Datei konvertieren?
- Erste schreibt die Serialisierungsstream Magie Daten (STREAM_MAGIC = "AC ED" und STREAM_VERSION = Version der JVM).
- Dann schreibt sie aus den Metadaten der Klasse mit einer Instanz (Länge der Klasse, der Name der Klasse, serialVersionUID) zugeordnet ist.
- Dann rekursiv es schreibt den Metadaten der übergeordneten Klasse, bis es
java.lang.Objectfindet. - beginnt dann mit den tatsächlichen Daten mit der Instanz verbunden.
- schreibt schließlich die Daten von Objekten, die mit der Instanz von Metadaten eigentlichen Inhalt zu starten.
Wenn Sie in mehr in dept Informationen über Java Serialisierung Interesse überprüfen Sie bitte diesen Link .
Bearbeiten : Eine weitere gute Link lesen.
Dies wird einige häufige Fragen beantworten:
-
Wie kein Feld in der Klasse serialisiert.
Am: verwendet transientes Schlüsselwort -
Wenn Kind Klasse serialisiert wird nicht übergeordnete Klasse serialisiert bekommen?
Antwort:. Nein, wenn Eltern nicht Serializable Schnittstelle Eltern Feld erstreckt nicht serialisiert bekommen -
Wenn Eltern serialisiert werden nicht serialisiert Kind Klasse bekommen?
Antwort: Ja, die standardmäßig Kindklasse auch serialisiert bekommen .
-
Wie Kind Klasse zu vermeiden, serialisiert zu werden?
Antwort: a. Außer Kraft setzen und write readObject- Methode und wirftNotSerializableException.
b. Auch können Sie alle Felder transient in der Kinderklasse kennzeichnen.
- Einige System-Level-Klassen wie Fäden, Outputstream und seine Unterklassen und Sockel sind nicht serialisierbar.
Die Serialisierung wird ein „live“ Objekt im Speicher zu nehmen und es in ein Format umgewandelt werden, die irgendwo gespeichert werden können (z. B. im Speicher auf der Festplatte) und später „deserialisiert“ zurück in ein Live-Objekt.
Ich möchte die Art und Weise @OscarRyz präsentiert. Obwohl hier bin ich weiterhin die Geschichte der Serialisierung , die von ursprünglich geschrieben wurde @amitgupta.
Auch wenn über die Roboter Klassenstruktur zu kennen und serialisierten Daten der Erde Wissenschaftler haben waren die Daten nicht in der Lage zu deserialisieren, die Roboter einsetzen kann.
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:
Mars Wissenschaftler für die vollständige Zahlung warteten. Einmal wurde die Zahlung Wissenschaftler Mars getan teilten sich die serialVersionUID mit Erde Wissenschaftler. Erde Wissenschaftler setzen Sie sich auf Roboter-Klasse und alles wurde gut.
Mein zwei Cent von meinem eigenen Blog:
Hier ist eine detaillierte Erklärung der Serialisierung : (mein eigenes Blog)
Serialisierung:
Serialisierung ist der Prozess, den Zustand eines Objekts persistierender. Es wird dargestellt und in der Form einer Folge von Bytes gespeichert. Dies kann in einer Datei gespeichert werden. Der Prozess um den Zustand des Objekts aus der Datei zu lesen und wiederherstellen es heißt Deserialisierung.
Was ist die Notwendigkeit von Serialisierung?
In moderner Architektur, gibt es immer einen Bedarf Objektzustand zu speichern und dann abrufen. Zum Beispiel in dem Ruhezustand, ein Objekt speichern wir die Klasse Serializable machen sollten. Was sie tut, ist, dass, wenn der Objektzustand in Form von Bytes gespeichert wird, kann es auf ein anderes System übertragen werden, die dann von dem Zustand und rufen Sie die Klasse lesen können. Der Objektzustand kann aus einer Datenbank oder einer anderen Jvm oder aus einem separaten Bauteil. Mit Hilfe von Serialisierung können wir den Objektzustand abzurufen.
Code-Beispiel und Erläuterung:
Lassen Sie uns zunächst auf die Item-Klasse einen Blick:
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;
}
}
In dem obigen Code kann man sehen, dass Item Klasse implementiert Serializable .
Dies ist die Schnittstelle, die eine Klasse serialisiert werden kann.
Jetzt können wir eine Variable sehen genannt serialVersionUID wird nach Long Variable initialisiert. Diese Zahl wird durch die auf dem Stand der Klasse basiert Compiler berechnet und die Klassenattribute. Das ist die Zahl, die die Jvm zu identifizieren den Zustand eines Objekts wird helfen, wenn es um den Zustand des Objekts aus der Datei liest.
, dass wir einen Blick auf die offizielle Oracle-Dokumentation haben:
Die Serialisierung Runtime ordnet jede serializable Klasse einer Versionsnummer, eine so genannte serialVersionUID, die während verwendet wird Deserialisierung zu überprüfen, ob der Absender und Empfänger einer serialisierten Objekt haben Klassen für das Objekt geladen, die mit kompatibel sind Bezug auf die Serialisierung. Wenn der Empfänger eine Klasse für das beladene Objekt, das eine unterschiedliche serialVersionUID als die von der HAS entsprechenden Klasse des Senders wird dann Deserialisierung in eine Folge InvalidClassException. Eine serializable Klasse kann seine eigene erklären serialVersionUID ausdrücklich durch ein Feld namens erklärt „SerialVersionUID“, die lange statisch, endgültig und muss Typ: ANY-ACCESS-Modifier static final lange serialVersionUID = 42L; Wenn ein serializable Klasse nicht erklären nicht explizit eine serialVersionUID, dann wird die Serialisierung Laufzeit eine Standard berechnen serialVersionUID Wert für diese Klasse auf der Grundlage verschiedenen Aspekte der Klasse, wie sie in der Java (TM) Objektserialisierung beschrieben Spezifikation. Es wird jedoch dringend, dass alle empfohlen serializable Klassen erklären ausdrücklich serialVersionUID Werte, da die Standard-serialVersionUID Berechnung ist sehr empfindlich gegenüber Klasse Details, die je nach Compiler-Implementierungen variieren und können Damit ergeben sich in unerwarteten InvalidClassExceptions während Deserialisierung. Daher eine konsistente serialVersionUID garantieren Wert über verschiedene Java-Compiler-Implementierungen, ein serialisierbare Klasse muss einen expliziten serialVersionUID Wert. Es ist auch dringend empfohlen, dass explizite serialVersionUID Erklärungen der Verwendung Privater Modifikator, wo möglich, da solche Erklärungen gelten nur für die sofort deklarierte Klasse - serialVersionUID Felder nicht nützlich als geerbten Mitglieder.
Wenn Sie bemerkt haben, gibt es ein weiteres Schlüsselwort wir verwendet haben, das ist transiente .
Wenn ein Feld nicht serialisierbar ist, muss es transiente gekennzeichnet sein. Hier haben wir markiert die itemCostPrice als vorübergehend und nicht wollen, dass es in eine Datei geschrieben werden
Lassen Sie uns jetzt einen Blick darauf, wie der Zustand eines Objekts in die Datei zu schreiben und lesen Sie es dann von dort aus.
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();
}
}
}
In der obigen können wir ein Beispiel für die Serialisierung und Deserialisierung eines Objekts sehen.
Für die verwendeten wir zwei Klassen. Für die Serialisierung des Objekts haben wir Object verwendet. Wir haben die Methode write verwendet, um das Objekt in der Datei zu schreiben.
Für Deserialisieren haben wir Object verwendet, die aus der Datei aus dem Objekt liest. Es verwendet readObject- die Objektdaten aus der Datei zu lesen.
Die Ausgabe des obigen Codes sei wie:
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]
Beachten Sie, dass itemCostPrice von entserialisierten Objekt ist null , da es nicht geschrieben wurde.
Wir haben diskutiert bereits die Grundlagen der Java Serialisierung in Teil I dieses Artikels.
Lassen Sie uns es jetzt diskutieren tief und wie es funktioniert.
Lassen Sie uns zunächst mit der serialVersionUID starten.
Die serialVersionUID wird als Versionskontrolle in einer Serializable-Klasse verwendet.
Wenn Sie nicht explizit eine serialVersionUID erklären, wird JVM es automatisch für Sie tun, basierend auf verschiedenen Eigenschaften der Serializable Klasse.
Java-Algorithmus zur Berechnung serialVersionUID (Lesen Sie mehr Details hier)
- Der Klassenname.
- Die Klasse Modifikatoren geschrieben als 32-Bit-Integer.
- Der Name jedes sortiert Schnittstelle mit Namen.
- Für jedes Feld der Klasse von Feldnamen sortiert (außer private static und private transiente Felder. Der Name des Feldes Die Modifikatoren des Feldes als 32-Bit-Ganzzahl geschrieben. der Deskriptor des Feldes.
- Wenn ein Klasseninitialisierer vorhanden ist, schreiben Sie folgendes: Der Name der Methode,
.- Der Modifikator des Verfahrens java.lang.reflect.Modifier.STATIC als ganzzahlige 32-Bit geschrieben.
- Der Deskriptor des Verfahrens () V.
- Für jede nicht-privaten Konstruktor von Methodennamen sortiert und Unterschrift: Der Name des Verfahrens. Die Modifikatoren der Verfahren nach einer 32-Bit-Ganzzahl geschrieben. Der Deskriptor des Verfahrens.
- Für jede nicht-private Methode sortiert nach Methode Namen und Unterschrift: Der Name der Methode. Die Modifikatoren des Verfahrens als geschriebenen 32-Bit-Ganzzahl. Der Deskriptor des Verfahrens.
- Der SHA-1-Algorithmus wird auf den Strom von Bytes, die von Dataoutputstream erzeugt ausgeführt und erzeugt fünf 32-Bit-Werte sha [0..4]. Das Hash-Wert von den ersten und zweiten 32-Bit-Werten des zusammengefügten SHA-1 Message Digest. Wenn das Ergebnis der Message-Digest, die fünf 32-Bit-Worte H0 H1 H2 H3 H4, sind in einer Reihe von fünf Werten int benannt sha, würde der Hash-Wert wie folgt berechnet werden:
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;
Java Serialisierung Algorithmus
Der Algorithmus der Serialisierung eines Objekts wird wie folgt beschrieben unter:
1. Es schreibt die Metadaten der Klasse mit einer Instanz verbunden.
2. Er schreibt rekursiv aus der Beschreibung der übergeordneten Klasse, bis es findet java.lang.Object .
3. Sobald es fertig ist die Metadaten-Informationen zu schreiben, es beginnt dann mit den tatsächlichen Daten mit der Instanz zugeordnet. Aber dieses Mal, es geht von der obersten übergeordneten Klasse.
4. Er schreibt rekursiv die Daten mit der Instanz zugeordnet, ausgehend von den am wenigsten übergeordneten Klasse auf die am meisten abgeleitete Klasse.
Dinge im Auge zu behalten:
-
Statische Felder in einer Klasse kann nicht serialisiert werden.
public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; } -
Wenn die serialVersionUID in der Leseklasse unterschiedlich ist, wird es eine
InvalidClassExceptionAusnahme auslösen. -
Wenn eine Klasse serialisierbar implementiert dann alle seine Unterklassen auch serialisierbar sein.
public class A implements Serializable {....}; public class B extends A{...} //also Serializable -
Wenn eine Klasse eine Referenz einer anderen KlasseAlle Referenzen müssen Serializable sein sonst Serialisierung Prozess wird nicht durchgeführt werden. In einem solchen Fall NotSerializableException wird zur Laufzeit geworfen.
Beispiel:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
Serialisierung bedeutet Objekte in Java persistierenden. Wenn Sie den Zustand des Objekts speichern wollen und später den Staat wieder aufbauen (in einer anderen JVM sein) Serialisierung verwendet werden kann.
Beachten Sie, dass die Eigenschaften eines Objekts nur dann gespeichert werden soll. Wenn Sie das Objekt wieder zu beleben wollen wieder sollten Sie die Klassendatei haben, da die Elementvariablen nur die Mitgliederfunktionen gespeichert und nicht werden.
Beispiel:
ObjectInputStream oos = new ObjectInputStream(
new FileInputStream( new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();
Die Searializable ist eine Markierungsschnittstelle, die markiert, dass Ihre Klasse ist serializable. Marker-Schnittstelle bedeutet, dass es nur eine leere Schnittstelle und die Verwendung dieser Schnittstelle wird die JVM benachrichtigen, dass diese Klasse kann serializable gemacht werden.
Serialisierung ist der Prozess, den Zustand eines Objekts auf Bits der Umwandlung so, dass es auf einer Festplatte gespeichert werden können. Wenn Sie das gleiche Objekt deserialisieren, wird es seinen Zustand später behalten. Damit können Sie Objekte erstellen, ohne dass die Eigenschaften der Objekte von Hand speichern.
Serialisierung ist der Prozess, um ein Objekt in einem Speichermedium zu speichern (wie beispielsweise eine Datei oder einen Speicherpuffer) oder über eine Netzwerkverbindung in binärer Form zu übertragen. Die serialisierte Objekte sind JVM unabhängig und kann von jedem JVM erneut serialisiert werden. In diesem Fall wird der „im Speicher“ Java-Objekte Zustand in einen Byte-Strom umgewandelt. Diese Art der Datei kann vom Anwender nicht verstanden werden. Es ist eine besondere Art von Objekt das heißt von der JVM (Java Virtual Machine) wiederverwendet werden. Dieser Prozess ein Objekt serialisiert wird auch Abblasen oder Rangier- ein Objekt genannt.
Das Objekt serialisiert werden muss java.io.Serializable Schnittstelle implementieren.
Standardserialisierung Mechanismus für ein Objekt schreibt die Klasse des Objekts, die Klassensignatur und die Werte aller nicht-flüchtig und nicht-statische Felder.
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,
ObjectOutput Schnittstelle erweitert die DataOutput Schnittstelle und fügt Methoden für Objekte der Serialisierung und Bytes in die Datei zu schreiben. Die ObjectOutputStream erstreckt java.io.OutputStream und Geräte ObjectOutput Schnittstelle. Es serialisiert Objekte, Arrays und andere Werte in einem Stream. Damit der Konstruktor von ObjectOutputStream geschrieben wie:
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));
über Code verwendet worden ist die Instanz der ObjectOutput Klasse mit dem ObjectOutputStream( ) Konstruktor zu erstellen, die die Instanz des FileOuputStream als Parameter annimmt.
Die ObjectOutput Schnittstelle wird durch die Implementierung der ObjectOutputStream-Klasse verwendet. Die ObjectOutputStream ist konstruiert, um das Objekt zu serialisieren.
Deserialisieren ein Objekt in Java
Der entgegengesetzte Betrieb der Serialisierung heißt Deserialisierung das heißt die Daten aus einer Reihe von Bytes zu extrahieren, wird S als Deserialisierung bekannt, die auch Aufpumpen oder unmarshalling genannt wird.
ObjectInputStream erweitert java.io.InputStream und implementiert ObjectInput Schnittstelle. Es deserialisiert Objekte, Arrays und andere Werte von einem Eingangsstrom. Damit der Konstruktor von ObjectInputStream geschrieben wie:
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));
über Code des Programms erstellt die Instanz der Klasse ObjectInputStream diese Datei deserialisieren, die von der ObjectInputStream Klasse serialisiert worden war. Der obige Code erstellt die Instanz der Instanz der FileInputStream-Klasse, die das angegebene Datei-Objekt enthält, die deserialisiert werden muss, weil der ObjectInputStream() Konstruktor den Eingangsstrom benötigt.
Serialization ist ein Mechanismus, eine grafische Darstellung der Java-Objekte in eine Anordnung von Bytes für die Speicherung (to disk file) oder Getriebe (across a network), dann unter Verwendung Deserialisierung wir die Graphen von Objekten wiederherstellen.
Graphen von Objekten korrekt unter Verwendung eines Referenz Sharing-Mechanismus gestellt. Aber vor dem Speichern prüfen, ob serialVersionUID von Input-Datei / Netzwerk und .class-Datei serialVersionUID gleich ist. Wenn nicht, einen java.io.InvalidClassException werfen.
Jede versioniert Klasse muss die ursprüngliche Klassenversion identifizieren, für die es in der Lage Schreibströme ist und aus dem sie lesen. Zum Beispiel muss eine versioniert Klasse deklariert:
serialVersionUID Syntax
// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L;
serialVersionUID ist wesentlich für die Serialisierung. Aber es ist optional für die Entwickler in die Java-Quelldatei hinzuzufügen. Wenn ein serialVersionUID nicht enthalten ist, wird die Serialisierung Laufzeit eine serialVersionUID erzeugen und es mit der Klasse zuordnen. Das serialisierte Objekt enthält diese serialVersionUID zusammen mit anderen Daten.
Hinweis - Es wird dringend empfohlen, dass alle serializable Klassen explizit eine serialVersionUID erklären, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations , und in unerwarteten serialVersionUID Konflikten während der Deserialisierung somit zur Folge haben kann, so dass die Deserialisierung zum Scheitern verurteilt.
Inspizieren Serializable Klassen
Ein Java-Objekt ist nur serializable. wenn eine Klasse oder eine ihrer Oberklassen implementiert entweder die java.io.Serializable Schnittstelle oder seine Subschnittstelle, java.io.Externalizable .
-
Eine Klasse implementieren muss java.io.Serializable Schnittstelle , um erfolgreich sein Objekt zu serialisieren. Serializable ist eine Marker-Schnittstelle und verwendet, um die Compiler zu informieren, dass die Klasse der Umsetzung es serializable Verhalten hinzugefügt werden muss. Hier Java Virtual Machine (JVM) ist zuständig für die automatische Serialisierung.
transientes Stichwort:
java.io.Serializable interfaceWährend der Serialisierung eines Objekts, wenn wir bestimmte Datenelemente des Objekts wollen nicht serialisiert werden wir die transiente Modifikator verwenden können. Das transiente Schlüsselwort wird, dass die Daten Mitglied verhindert serialisiert werden.
- Felder deklariert als transient oder statisch durch die Serialisierung ignoriert.
+--------------+--------+-------------------------------------+ | 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. } -
die Externalizable Schnittstelle Implementierung ermöglicht das Objekt die vollständige Kontrolle über den Inhalt und das Format des Objekts serialisiert Form anzunehmen. Die Verfahren der Externalizable Schnittstelle, writeExternal und REAdExternal werden genannt die Objekte Zustand zu speichern und wiederherzustellen. Wenn von einer Klasse implementiert können sie ihren eigenen Staat mit all den Methoden der ObjectOutput und ObjectInput schreiben und lesen. Es ist die Verantwortung der Objekte jede Versionierung zu handhaben, die auftritt.
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 } } -
Es werden nur Objekte, die die java.io.Serializable oder java.io.Externalizable Schnittstelle unterstützen
written towerden können /read fromStreams. Die Klasse jedes Objekt serializable codiert, einschließlich der Klassenname und Unterschrift der Klasse, die Werte des Objektfeldern und Arrays, und die Schließung aller anderen Objekte aus der ursprünglichen Objekte referenziert werden.
Serializable Beispiel für Dateien
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();
}
}
}
Serializable Beispiel über ein Netzwerk
Verteilen Objekt 's Zustand in verschiedenen Adressräumen, entweder in verschiedenen Prozessen auf demselben Computer, oder sogar in mehreren Computern über ein Netzwerk verbunden, aber die zusammenarbeiten, um den Austausch von Daten und Methoden aufrufen.
/**
* 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();
}
}
@see
Serialisierung ist der Prozess ein Java-Objekt in Byte-Array von Dreh- und dann zurück in Objekt wieder mit seinem gut erhaltenen Zustand. Nützlich für verschiedene Dinge wie Objekte über das Netzwerk oder die Caching Dinge auf der Festplatte zu senden.
Lesen Sie mehr von diesem kurzen Artikel, die Programmierung Teil des Prozesses recht gut erklärt und bewegen über, um dann zu Serializable javadoc . Sie können auch bei der Lektüre diese Frage im Zusammenhang .
Gibt die Datei als Objekt: 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);
}
}
| * | Serialisieren einer Klasse. Konvertieren eines Objekts zu Bytes und Bytes zurück zum Objekt (Deserialisierung)
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}
|. => Objekt-Serialisierung ist Prozess den Zustand eines Objekts in Dampf von Bytes Umwandlung
- | -.> Implementieren Sie, wenn Sie das Objekt wollen über die gesamte Lebensdauer der JVM existieren
- | -> serialisierte Objekt kann in der Datenbank gespeichert werden
.
- | -.> Serializable-Objekte können nicht von Menschen gelesen und verstanden werden, so dass wir Sicherheit acheive können
|. => Objekt-Deserialisierung ist der Prozess, den Zustand eines Objekts zu bekommen und speichern Sie es in ein Objekt (java.lang.Object)
- | -> Vor dem Zustand speichert sie prüft, ob serialVersionUID Formulareingabe-Datei / Netzwerk und .class-Datei serialVersionUID ist gleiche
. & Nbsp & nbspWenn nicht java.io.InvalidClassException werfen.
| => Ein Java-Objekt ist nur serializable, wenn seine Klasse oder eine ihrer Oberklassen
- implementiert entweder die java.io.Serializable Schnittstelle in oder
- seine Subschnittstelle, java.io.Externalizable.
|. => Statische Felder in einer Klasse kann nicht serialisiert werden
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}
| => Wenn Sie nicht wollen, eine Variable einer Klasse Verwendung transient Schlüsselwort
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}
| => Wenn eine Klasse serialisierbar implementiert dann alle seine Unterklassen auch serialisierbar sein
| => Wenn eine Klasse eine Referenz einer anderen Klasse hat, alle Referenzen Serializable sein müssen, sonst Serialisierung Prozess wird nicht durchgeführt werden. In einem solchen Fall wird
NotSerializableException zur Laufzeit geworfen.
