Wat wordt bedoeld met “objectserialisatie”? Kun je het alsjeblieft uitleggen met wat voorbeelden?
Antwoord 1, autoriteit 100%
Serialisatie is de conversie van een object naar een reeks bytes, zodat het object gemakkelijk kan worden opgeslagen in permanente opslag of kan worden gestreamd via een communicatieverbinding. De bytestroom kan dan worden gedeserialiseerd – omgezet in een replica van het originele object.
Antwoord 2, autoriteit 97%
Je kunt serialisatie beschouwen als het proces waarbij een objectinstantie wordt omgezet in een reeks bytes (al dan niet binair, afhankelijk van de implementatie).
Het is erg handig wanneer u gegevens van één object over het netwerk wilt verzenden, bijvoorbeeld van de ene JVM naar de andere.
In Java is het serialisatiemechanisme ingebouwd in het platform, maar u moet de Serializable-interface implementeren om een object serialiseerbaar te maken.
U kunt ook voorkomen dat bepaalde gegevens in uw object worden geserialiseerd door het kenmerk te markeren als transient.
Ten slotte kunt u het standaardmechanisme overschrijven en uw eigen mechanisme opgeven; dit kan in sommige speciale gevallen geschikt zijn. Hiervoor gebruik je een van de verborgen functies in java.
Het is belangrijk op te merken dat wat geserialiseerd wordt de “waarde” van het object of de inhoud is, en niet de klassedefinitie. Methoden zijn dus niet geserialiseerd.
Hier is een heel eenvoudig voorbeeld met opmerkingen om het lezen te vergemakkelijken:
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();
}
}
Als we dit programma uitvoeren, wordt het bestand “o.ser” gemaakt en kunnen we zien wat er achter is gebeurd.
Als we de waarde van: someIntegerwijzigen in bijvoorbeeld Integer.MAX_VALUE, kunnen we de uitvoer vergelijken om te zien wat het verschil is.
Hier is een screenshot die precies dat verschil laat zien:
Zie jij de verschillen? 😉
Er is een extra relevant veld in Java-serialisatie: de serialversionUIDmaar ik denk dat dit is al te lang om het te dekken.
Antwoord 3, autoriteit 25%
Durf de 6 jaar oude vraag te beantwoorden, door een zeer hoog begrip toe te voegen voor mensen die nieuw zijn in Java
Wat is serialisatie?
Een object converteren naar bytes
Wat is deserialisatie?
Byte terug converteren naar een object (deserialisatie).
Wanneer wordt serialisatie gebruikt?
Als we het object willen volhouden.
Wanneer we willen dat het object na de levensduur van de JVM blijft bestaan.
Voorbeeld uit de echte wereld:
ATM: wanneer de rekeninghouder geld probeert op te nemen van de server via ATM, wordt de informatie van de rekeninghouder, zoals opnamegegevens, geserialiseerd en verzonden naar de server waar de gegevens worden gedeserialiseerd en gebruikt om bewerkingen uit te voeren.
Hoe serialisatie wordt uitgevoerd in Java.
-
Implementeer
java.io.Serializableinterface (markerinterface dus geen methode om te implementeren). -
Behoud het object: gebruik de klasse
java.io.ObjectOutputStream, een filterstroom die een wrapper is rond een bytestroom op een lager niveau (om Object naar bestandssystemen te schrijven of een afgeplatte object via een netwerkkabel en aan de andere kant opnieuw opgebouwd).
writeObject(<<instance>>)– om een object te schrijvenreadObject()– om een geserialiseerd object te lezen
Onthoud:
Als je een object serialiseert, wordt alleen de status van het object opgeslagen, niet het klassebestand of de methoden van het object.
Wanneer u een 2-byte-object hebt geserialiseerd, ziet u 51 bytes geserialiseerd bestand.
Stappen Hoe het object is geserialiseerd en de-geserialiseerd.
Antwoord voor: Hoe heeft het geconverteerd naar bestand van 51 bytes?
- Schrijft eerst de serialisatiestroom Magic Data (Stream_Magic = “AC ED” en Stream_Version = versie van de JVM).
- DAN schrijft het de metadata van de klasse in verband met een instantie (lengte van de klasse, de naam van de klasse, de serialversionUID).
- Dan schrijft het recursief de metadata van de superclass uit totdat deze
java.lang.Objectvindt. - start dan met de feitelijke gegevens die zijn gekoppeld aan het exemplaar.
- schrijft eindelijk de gegevens van objecten die zijn gekoppeld aan het exemplaar van metadata naar de werkelijke inhoud.
bewerken : referentie link lezen.
Dit beantwoordt een paar frequente vragen:
-
Hoe niet om elk veld in de klas te serialiseren.
ANS: Gebruik het tijdelijke trefwoord -
Wanneer kindklasse is geserialiseerd, wordt ouderklasse geserialiseerd?
ANS: Nee, als een ouder niet het Serializable Interface Ouders Field uitbreidt, wordt niet geserialiseerd. -
Wanneer een ouder is geserialiseerd, wordt Child Class Serialized?
ANS: Ja, door de standaardkame wordt ook geserialiseerd. -
Hoe te voorkomen dat kinderlessen worden geserialiseerd?
ANS: A. Overschrijven WriteObject en ReadObject-methode en gooiNotSerializableException.b. Ook kunt u alle velden voorbijgaan in Kinderklasse.
-
Sommige systeemniveau-klassen zoals thread, outputstream en zijn subklassen en socket zijn niet serialiseerbaar.
4, Autoriteit 5%
Serialisatie neemt een “live” -object in het geheugen en converteert deze naar een formaat dat ergens kan worden opgeslagen (bijv. in geheugen, op schijf) en later “deserialized” terug in een live-object.
5, Autoriteit 3%
Ik vond de manier waarop @oscarryz presenteert. Hoewel ik hier de verhaal van serialisatie die oorspronkelijk werd geschreven door @Amitgupta.
Zelfs al weet het wetenschap van de wetenschapper van de robotklasse en het hebben van serialized data Aarde’s wetenschapper niet in staat was om de gegevens te desorialiseren die robots werken.
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:
De wetenschappers van Mars wachtten op de volledige betaling. Zodra de betaling is gedaan MARS’s wetenschappers deelden de SerialversionUid met de wetenschappers van de aarde. De wetenschapper van de aarde zette het op robotklasse en alles werd prima.
6, Autoriteit 3%
Mijn twee cent uit mijn eigen blog:
Hier is een gedetailleerde uitleg van de serialisatie : (Mijn eigen blog)
serialisatie:
Serialisatie is het proces van aanhouden van de staat van een object. Het wordt vertegenwoordigd en opgeslagen in de vorm van een reeks bytes. Dit kan in een bestand worden opgeslagen. Het proces om de status van het object uit het bestand te lezen en het te herstellen, wordt het deialization genoemd.
Wat is de behoefte aan serialisatie?
In de moderne architectuur is het altijd nodig om de objectstatus op te slaan en vervolgens op te halen. Om bijvoorbeeld in Hibernate een object op te slaan, moeten we de klasse Serializable maken. Wat het doet, is dat zodra de objectstatus is opgeslagen in de vorm van bytes, het kan worden overgedragen naar een ander systeem dat vervolgens uit de status kan lezen en de klasse kan ophalen. De objectstatus kan afkomstig zijn uit een database of een andere jvm of uit een apart onderdeel. Met behulp van serialisatie kunnen we de objectstatus ophalen.
Codevoorbeeld en uitleg:
Laten we eerst eens kijken naar de itemklasse:
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 de bovenstaande code is te zien dat de klasse ItemSerializableimplementeert.
Dit is de interface waarmee een klasse serialiseerbaar is.
Nu kunnen we zien dat een variabele met de naam serialVersionUIDis geïnitialiseerd op Long-variabele. Dit aantal wordt berekend door de compiler op basis van de status van de klasse en de klasseattributen. Dit is het nummer dat de jvm helpt de status van een object te identificeren wanneer het de status van het object uit een bestand leest.
Daarvoor kunnen we de officiële Oracle-documentatie bekijken:
De serialisatie-runtime hoort bij elke serialiseerbare klasse a
versienummer, een zogenaamde serialVersionUID, die wordt gebruikt tijdens
deserialisatie om te controleren of de afzender en ontvanger van een geserialiseerd
object hebben klassen voor dat object geladen die compatibel zijn met
met betrekking tot serialisatie. Als de ontvanger een klasse heeft geladen voor de
object dat een andere serialVersionUID heeft dan die van de
corresponderende klasse van de afzender, dan zal deserialisatie resulteren in een
InvalidClassException. Een serialiseerbare klasse kan zijn eigen klasse declareren
serialVersionUID expliciet door een veld met de naam . te declareren
“serialVersionUID” die statisch, definitief en van het type lang moet zijn:
ANY-ACCESS-MODIFIER statische laatste lange serialVersionUID = 42L; Als een
serializable klasse declareert niet expliciet een serialVersionUID,
dan berekent de serialisatie-runtime een standaard
serialVersionUID-waarde voor die klasse op basis van verschillende aspecten van de
klasse, zoals beschreven in de Java(TM) Object Serialization
Specificatie. Het wordt echter sterk aanbevolen dat alle
serializable klassen declareren expliciet serialVersionUID-waarden, aangezien
de standaard serialVersionUID-berekening is zeer gevoelig voor klasse
details die kunnen variëren afhankelijk van de implementatie van de compiler, en kunnen
dus resulteren in onverwachte InvalidClassExceptions tijdens
deserialisatie. Daarom, om een consistente serialVersionUID te garanderen
waarde voor verschillende Java-compilerimplementaties, een serializable
class moet een expliciete serialVersionUID-waarde declareren. Het is ook
sterk aangeraden dat expliciete serialVersionUID-declaraties de
private modifier waar mogelijk, aangezien dergelijke verklaringen alleen van toepassing zijn op:
de onmiddellijk declarerende klasse–serialVersionUID-velden zijn dat niet
nuttig als geërfde leden.
Als je hebt gemerkt dat er een ander zoekwoord is dat we hebben gebruikt, is van voorbijgaande aard.
Als een veld niet serialiseerbaar is, moet het als tijdelijk worden gemarkeerd. Hier hebben we de itemCostPricegemarkeerd als tijdelijk en willen niet dat deze in een bestand wordt geschreven
Laten we nu eens kijken hoe we de status van een object in het bestand kunnen schrijven en het van daaruit kunnen lezen.
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 het bovenstaande kunnen we een voorbeeld zien van serialisatie en deserialization van een object.
Daarvoor gebruikten we twee klassen. Voor het serialiseren van het object hebben we objectoutputstream gebruikt. We hebben de methode writeObject gebruikt om het object in het bestand te schrijven.
Voor deserializing hebben we objectinputstream gebruikt die van het object uit het bestand leest. Het maakt gebruik van ReadObject om de objectgegevens uit het bestand te lezen.
De uitvoer van de bovenstaande code zou zijn als:
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]
Merk op dat Itemcostprice van desiERIalisized-object is null zoals niet geschreven is.
We hebben de basisprincipes van Java-serialisatie in deel I van dit artikel al besproken.
Laten we het nu diep bespreken en hoe het werkt.
Laten we eerst beginnen met de SerialversionUID.
De SerialversionUID wordt gebruikt als een versiebeheer in een serializable klasse.
Als u niet expliciet een serialVersionUID declareert, zal JVM dit automatisch voor u doen, op basis van verschillende eigenschappen van de klasse Serializable.
Java’s algoritme voor het berekenen van serialversionuid(Lees hier meer details)
- De klassenaam.
- De class modifiers geschreven als een 32-bits geheel getal.
- De naam van elke interface gesorteerd op naam.
- Voor elk veld van de klasse gesorteerd op veldnaam (behalve persoonlijke statische en persoonlijke tijdelijke velden: de naam van het veld.
modifiers van het veld geschreven als een 32-bits geheel getal. de descriptor
van het veld.- Als er een klasse-initiator bestaat, schrijf dan het volgende op: De naam van de methode, .
- De modifier van de methode, java.lang.reflect.Modifier.STATIC, geschreven als een 32-bits geheel getal.
- De descriptor van de methode, ()V.
- Voor elke niet-private constructor gesorteerd op naam en handtekening van de methode: De naam van de methode, . De modifiers van de
methode geschreven als een 32-bits geheel getal. De descriptor van de methode.- Voor elke niet-privémethode gesorteerd op methodenaam en handtekening: de naam van de methode. De modifiers van de methode geschreven als a
32-bits geheel getal. De beschrijving van de methode.- Het SHA-1-algoritme wordt uitgevoerd op de stroom bytes die wordt geproduceerd door DataOutputStream en produceert vijf 32-bits waarden sha[0..4]. De
hash-waarde wordt samengesteld uit de eerste en tweede 32-bits waarden van de
SHA-1 berichtoverzicht. Als het resultaat van het bericht digest, de vijf
32-bits woorden H0 H1 H2 H3 H4, staat in een array van vijf int-waarden met de naam
sha, zou de hash-waarde als volgt worden berekend:
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’s serialisatie-algoritme
Het algoritme om een object te serialiseren wordt hieronder beschreven:
1. Het schrijft de metadata uit van de klasse die aan een instantie is gekoppeld.
2. Het schrijft recursief de beschrijving van de superklasse uit totdat het java.lang.objectvindt.
3. Zodra het klaar is met het schrijven van de metadata-informatie, begint het met de daadwerkelijke gegevens die aan de instantie zijn gekoppeld. Maar deze keer is het
begint bij de hoogste superklasse.
4. Het schrijft recursief de gegevens die bij de instantie horen, beginnend bij de minste superklasse tot de meest afgeleide klasse.
Dingen om in gedachten te houden:
-
Statische velden in een klasse kunnen niet worden geserialiseerd.
public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; } -
Als de serialversionuid anders is in de leesklasse, wordt er een
InvalidClassException-uitzondering gegenereerd. -
Als een klasse serializable implementeert, dan zullen al zijn subklassen ook serialiseerbaar zijn.
public class A implements Serializable {....}; public class B extends A{...} //also Serializable -
Als een klasse een referentie van een andere klasse heeft, moeten alle referenties serialiseerbaar zijn, anders wordt het serialisatieproces niet uitgevoerd. In dat geval wordt NotSerializableExceptiontijdens runtime gegenereerd.
Bijvoorbeeld:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
Antwoord 7, autoriteit 2%
Serialisatie betekent persistente objecten in Java. Als u de status van het object wilt opslaan en de status later opnieuw wilt opbouwen (mogelijk in een andere JVM), kan serialisatie worden gebruikt.
Houd er rekening mee dat de eigenschappen van een object alleen worden opgeslagen. Als u het object opnieuw tot leven wilt brengen, moet u het klassenbestand hebben, omdat alleen de lidvariabelen worden opgeslagen en niet de lidfuncties.
bijvoorbeeld:
ObjectInputStream oos = new ObjectInputStream(
new FileInputStream( new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();
De Searialisable is een markeringsinterface die aangeeft dat je klasse serializeerbaar is. Marker-interface betekent dat het gewoon een lege interface is en als die interface wordt gebruikt, wordt de JVM geïnformeerd dat deze klasse serialiseerbaar kan worden gemaakt.
Antwoord 8
Serialisatie is het proces waarbij de toestand van een object wordt omgezet in bits, zodat het op een harde schijf kan worden opgeslagen. Wanneer u hetzelfde object deserialiseert, behoudt het later zijn staat. Hiermee kunt u objecten opnieuw maken zonder de eigenschappen van de objecten handmatig op te slaan.
http://en.wikipedia.org/wiki/Serialization
Antwoord 9
Java object serialisatie
Serializationis een mechanisme om een grafiek van Java-objecten te transformeren in een reeks bytes voor opslag (to disk file) of transmissie (across a network), dan met behulp van Deserialization kunnen we de grafiek van objecten herstellen.
Grafieken van objecten worden correct gerestaureerd met behulp van een mechanisme voor referentiedelen. , maar controleer voordat u het opslaat of de serialversionUID van input-bestand / netwerk en .class-bestand SerialversionUID hetzelfde is. Zo niet, gooi dan een java.io.InvalidClassException.
Elke versie van de versie moet de oorspronkelijke klasse-versie identificeren waarvoor het in staat is om streams te schrijven en waaruit het kan lezen. Een versie van de versie moet bijvoorbeeld verklaren:
SerialversionUID SYNTAX
// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L;
serialVersionUIDis essentieel voor het serialisatieproces. Maar het is optioneel voor de ontwikkelaar om het toe te voegen aan het Java-bronbestand. Als er geen serialVersionUID is opgenomen, genereert de serialisatieruntime een serialVersionUID en koppelt deze aan de klasse. Het geserialiseerde object bevat deze serialVersionUID samen met andere gegevens.
Opmerking– Het wordt sterk aanbevolen dat alle serialiseerbare klassen expliciet een serialVersionUID declareren, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, en kan dus resulteren in onverwachte serialVersionUID-conflicten tijdens deserialisatie, waardoor deserialisatie mislukt.
Serializeerbare klassen inspecteren
Een Java-object is alleen serialiseerbaar. als een klasse of een van zijn superklassen ofwel de java.io.Serializable-interface implementeert
of zijn subinterface, java.io.Externalizable.
-
Een klasse moet een java.io.Serializable interfaceimplementeren om het object succesvol te serialiseren. Serializable is een markeringsinterface en wordt gebruikt om de compiler te informeren dat de klasse die het implementeert, moet worden toegevoegd aan serialiseerbaar gedrag. Hier is Java Virtual Machine (JVM) verantwoordelijk voor de automatische serialisatie.
tijdelijk trefwoord:
java.io.Serializable interfaceAls we bij het serialiseren van een object niet willen dat bepaalde gegevensleden van het object worden geserialiseerd, kunnen we de tijdelijke modifier gebruiken. Het tijdelijke trefwoord voorkomt dat dat gegevenslid wordt geserialiseerd.
- Velden die als tijdelijk of statisch zijn gedeclareerd, worden genegeerd door het serialisatieproces.
+--------------+--------+-------------------------------------+ | 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. } -
Door de Externalizable-interface te implementeren, krijgt het object volledige controle over de inhoud en het formaat van de geserialiseerde vorm van het object. De methoden van de Externalizable-interface, writeExternal en readExternal, worden aangeroepen om de objectstatus op te slaan en te herstellen. Wanneer geïmplementeerd door een klasse, kunnen ze hun eigen status schrijven en lezen met behulp van alle methoden van ObjectOutput en ObjectInput. Het is de verantwoordelijkheid van de objecten om eventuele versiebeheer af te handelen.
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 } } -
Alleen objecten die de java.io.Serializable- of java.io.Externalizable-interface ondersteunen, kunnen
written to/read fromstromen. De klasse van elk serialiseerbaar object is gecodeerd, inclusief de klassenaam en handtekening van de klasse, de waarden van de velden en arrays van het object en de sluiting van alle andere objecten waarnaar wordt verwezen vanuit de oorspronkelijke objecten.
Serializeerbaar voorbeeld voor bestanden
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();
}
}
}
Serializeerbaar voorbeeld via netwerk
De status van het objectverdelen over verschillende adresruimten, ofwel in verschillende processen op hetzelfde computer, of zelfs in meerdere computers die via een netwerk zijn verbonden, maar die samenwerken door gegevens te delen en methoden aan te roepen.
/**
* 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
Antwoord 10
Serialisatie is het proces waarbij een object op een opslagmedium (zoals een bestand of een geheugenbuffer) wordt opgeslagen of in binaire vorm via een netwerkverbinding wordt verzonden. De geserialiseerde objecten zijn JVM-onafhankelijk en kunnen door elke JVM opnieuw worden geserialiseerd. In dit geval wordt de “in memory”-status van Java-objecten omgezet in een bytestroom. Dit type bestand kan niet worden begrepen door de gebruiker. Het is een speciaal type object, d.w.z. hergebruikt door de JVM (Java Virtual Machine). Dit proces van het serialiseren van een object wordt ook wel het leeglopen of rangschikken van een object genoemd.
Het te serialiseren object moet een java.io.Serializable-interface implementeren.
Standaard serialisatiemechanisme voor een object schrijft de klasse van het object, de klassehandtekening en de waarden van alle niet-transiënte en niet-statische velden.
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,
ObjectOutput-interface breidt de DataOutput-interface uit en voegt methoden toe voor het serialiseren van objecten en het schrijven van bytes naar het bestand. De ObjectOutputStreambreidt java.io.OutputStreamuit en implementeert de ObjectOutput-interface. Het serialiseert objecten, arrays en andere waarden naar een stream. Dus de constructor van ObjectOutputStreamwordt geschreven als:
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));
Bovenstaande code is gebruikt om de instantie van de klasse ObjectOutputte maken met de ObjectOutputStream( )-constructor die de instantie van de FileOuputStreamaanneemt als parameter.
De ObjectOutput-interface wordt gebruikt door de klasse ObjectOutputStreamte implementeren. De ObjectOutputStreamis geconstrueerd om het object te serialiseren.
Deserialiseren van een object in Java
De tegenovergestelde bewerking van de serialisatie wordt deserialisatie genoemd, d.w.z. het extraheren van de gegevens uit een reeks bytes staat bekend als deserialisatie, ook wel opblazen of unmarshalling genoemd.
ObjectInputStreambreidt java.io.InputStreamuit en implementeert ObjectInput-interface. Het deserialiseert objecten, arrays en andere waarden uit een invoerstroom. Dus de constructor van ObjectInputStreamwordt geschreven als:
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));
Bovenstaande code van het programma creëert de instantie van de klasse ObjectInputStreamom dat bestand te deserialiseren dat was geserialiseerd door de klasse ObjectInputStream. De bovenstaande code maakt de instantie met behulp van de instantie van de klasse FileInputStreamdie het opgegeven bestandsobject bevat dat moet worden gedeserialiseerd omdat de constructor ObjectInputStream()de invoerstroom nodig heeft.
Antwoord 11
Retourneer het bestand als een object: 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);
}
}
Antwoord 12
|*| Een klasse serialiseren: een object converteren naar bytes en bytes terug naar object (deserialisatie).
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}
|=> Object-serialisatie is een proces waarbij de toestand van een object wordt omgezet in een stroom van bytes.
- |-> Implementeer wanneer u wilt dat het object na de levensduur van de JVM blijft bestaan.
- |-> Seriedragend object kan worden opgeslagen in de database.
- |-> Serializable-objecten kunnen niet door mensen worden gelezen en begrepen, dus we kunnen beveiliging bereiken.
|=> Object-deserialisatie is het proces waarbij de staat van een object wordt verkregen en in een object (java.lang.Object) wordt opgeslagen.
- |-> Voordat de status wordt opgeslagen, wordt gecontroleerd of het serialVersionUID-formulier invoerbestand/netwerk en het .class-bestand serialVersionUID hetzelfde zijn.
  If not gooi java.io.InvalidClassException.
|=> Een Java-object is alleen serialiseerbaar als zijn klasse of een van zijn superklassen
- implementeert ofwel de java.io.Serializable interface of
- zijn subinterface, java.io.Externalizable.
|=> Statische velden in een klasse kunnen niet worden geserialiseerd.
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}
|=> Als u een variabele van een klasse niet wilt serialiseren, gebruikt u transient trefwoord
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}
|=> Als een klasse serializable implementeert, zijn alle subklassen ook serialiseerbaar.
|=> Als een klasse een referentie van een andere klasse heeft, moeten alle referenties serialiseerbaar zijn, anders wordt het serialisatieproces niet uitgevoerd. In dat geval wordt
NotSerializableException tijdens runtime gegenereerd.
Antwoord 13
Ik zal een analogie aanbieden om mogelijk te helpen bij het consolideren van het conceptuele doel/de praktische bruikbaarheid van objectserialisatie/deserialisatie.
Ik stel me objectserialisatie/deserialisatievoor in de context van een poging om een object door een regenwaterafvoer te verplaatsen. Het object wordt in wezen “ontbonden” of geserialiseerdin meer modulaire versies van zichzelf – in dit geval een reeks bytes– om effectief doorgang door een medium te krijgen. In computationele zin kunnen we het pad dat de bytes afleggen door de stormafvoer zien als verwant aan bytes die door een netwerk reizen. We transmuteren ons object om te voldoen aan een meer wenselijke manier van transport of formaat. Het geserialiseerde object wordt doorgaans opgeslagen in een binair bestand dat later kan worden gelezen van, geschreven naar of beide.
Misschien als ons object eenmaal door de afvoer kan glippen als een ontbonden reeks bytes, willen we die representatie van het object misschien opslaan als binaire gegevens in een database of harde schijf. Het belangrijkste is echter dat we met serialisatie/deserialisatie de mogelijkheid hebben om ons object in zijn binaire vorm te laten blijven nadat het is geserialiseerd, of de oorspronkelijke vorm van het object te “herhalen” door deserialisatie uit te voeren.