Что такое сериализация объектов?
https://stackoverflow.com/questions/447898
-
19-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Что подразумевается под "сериализацией объектов"?Не могли бы вы, пожалуйста, объяснить это на нескольких примерах?
Решение
Сериализация - это преобразование объекта в серию байтов, так что объект может быть легко сохранен в постоянном хранилище или передан по каналу связи. Затем поток байтов можно десериализовать - преобразовать в копию исходного объекта.
Другие советы
Вы можете думать о сериализации как о процессе преобразования экземпляра объекта в последовательность байтов (которая может быть двоичной или не зависящей от реализации).
Это очень полезно, когда вы хотите передать данные одного объекта по сети, например, из одной JVM в другую.
В Java механизм сериализации встроен в платформу, но вам нужно реализовать интерфейс Serializable , чтобы сделать объект сериализуемым.
Вы также можете предотвратить сериализацию некоторых данных в вашем объекте, пометив атрибут как временный .
Наконец, вы можете переопределить механизм по умолчанию и предоставить свой собственный; это может подойти в некоторых особых случаях. Для этого вы используете одну из скрытых функций в java .
Важно отметить, что сериализованным является " value " объекта или содержимого, а не определения класса. Таким образом, методы не сериализуются.
Вот очень простой пример с комментариями, облегчающими его чтение:
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 , например Integer.MAX_VALUE , мы можем сравнить выходные данные, чтобы увидеть, в чем разница.
Вот скриншот, показывающий именно эту разницу:
Можете ли вы определить различия? ;)
В сериализации Java есть еще одно соответствующее поле: serialversionUID , но я предполагаю, что это уже слишком долго, чтобы покрыть это.
Осмеливаюсь ответить на вопрос 6-летней давности, добавляя только очень высокий уровень понимания для людей, не знакомых с Java
Что такое сериализация?
Преобразование объекта в байты и байтов обратно в объект (десериализация).
когда используется сериализация?
Когда мы хотим сохранить Объект.Когда мы хотим, чтобы объект существовал за пределами срока службы JVM.
Пример из реального мира:
Банкомат:Когда владелец счета пытается снять деньги с сервера через банкомат, информация о владельце счета, такая как данные о снятии средств, будет сериализована и отправлена на сервер, где данные десериализуются и используются для выполнения операций.
Как выполняется сериализация в java.
Реализовать
java.io.Serializableинтерфейс (маркерный интерфейс, поэтому нет метода для реализации).Сохранение объекта:Использование
java.io.ObjectOutputStreamкласс, поток фильтра, который является оболочкой вокруг потока байтов более низкого уровня (для записи объекта в файловые системы или передачи сплющенного объекта по сетевому проводу и перестроения на другой стороне).writeObject(<<instance>>)- для записи объектаreadObject()- для чтения сериализованного объекта
Вспомни:
Когда вы сериализуете объект, сохраняется только состояние объекта, а не файл класса объекта или методы.
Когда вы сериализуете 2-байтовый объект, вы видите сериализованный файл размером 51 байт.
Описывает, как объект сериализуется и десериализуется.
Отвечать за:Как он преобразовал файл в 51 байт?
- Сначала записываются магические данные потока сериализации (STREAM_MAGIC= "AC ED" и STREAM_VERSION=версия JVM).
- Затем он записывает метаданные класса, связанного с экземпляром (длина класса, имя класса, serialVersionUID).
- Затем он рекурсивно записывает метаданные суперкласса до тех пор, пока не найдет
java.lang.Object. - Затем начинается с фактических данных, связанных с экземпляром.
- Наконец, записывает данные объектов, связанных с экземпляром, начиная с метаданных и заканчивая фактическим содержимым.
Если вас интересует дополнительная информация отдела о сериализации Java, пожалуйста, проверьте это Ссылка.
Редактировать :Еще один хороший Ссылка читать.
Это даст ответы на несколько часто задаваемых вопросов:
Как не сериализовать ни одно поле в классе.
Ans:используйте ключевое слово transientКогда дочерний класс сериализуется, сериализуется ли родительский класс?
Ans:Нет, если parent не расширяет поле Serializable interface parents, родительское поле не сериализуется.Когда родительский класс сериализуется, сериализуется ли дочерний класс?
Ans:Да, по умолчанию дочерний класс также сериализуется.Как избежать сериализации дочернего класса?
Ans:a.Переопределите методы writeObject и readObject и выбросьтеNotSerializableException.b.также вы можете пометить все поля переходными в дочернем классе.
- Некоторые классы системного уровня, такие как Thread, OutputStream и его подклассы, а также Socket, не являются сериализуемыми.
Сериализация требует & "живого"! " объект в памяти и преобразование его в формат, который может быть сохранен где-то (например, в памяти, на диске) и позже " десериализованный " обратно в живой объект.
Мне понравилось, как @OscarRyz представляет. Хотя здесь я продолжаю историю сериализации , которая была изначально написана @amitgupta.
Даже зная о структуре классов роботов и имея сериализованные данные, ученые Земли не смогли десериализовать данные, которые могут заставить роботов работать.
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:
Ученые Марса ждали полной оплаты. Как только оплата была произведена, ученые Марса поделились serialversionUID с учеными Земли. Ученый Земли установил класс роботов, и все стало хорошо.
Мои два цента из моего собственного блога:
Вот подробное объяснение сериализации:(мой собственный блог)
Сериализация:
Сериализация - это процесс сохранения состояния объекта.Он представлен и хранится в виде последовательности байтов.Это может быть сохранено в файле.Процесс считывания состояния объекта из файла и его восстановления называется десериализацией.
В чем необходимость сериализации?
В современной архитектуре всегда необходимо сохранять состояние объекта, а затем извлекать его.Например, в режиме гибернации, чтобы сохранить объект, мы должны сделать класс сериализуемым.Что он делает, так это то, что как только состояние объекта сохраняется в виде байтов, оно может быть передано в другую систему, которая затем может считывать данные из состояния и извлекать класс.Состояние объекта может быть получено из базы данных, другой виртуальной машины или из отдельного компонента.С помощью сериализации мы можем восстановить состояние объекта.
Пример кода и объяснение:
Сначала давайте взглянем на класс Item:
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;
}
}
В приведенном выше коде видно, что Предмет класс реализует Сериализуемый.
Это интерфейс, который позволяет классу быть сериализуемым.
Теперь мы можем видеть переменную с именем serialVersionUID сериалВерсионНЫЙ идентификатор инициализируется длинной переменной.Это число вычисляется компилятором на основе состояния класса и атрибутов класса.Это число, которое поможет jvm идентифицировать состояние объекта, когда она считывает состояние объекта из файла.
Для этого мы можем ознакомиться с официальной документацией Oracle:
Среда выполнения сериализации связывает с каждым сериализуемым классом номер версии, называемый serialVersionUID, который используется во время десериализации для проверки того, что отправитель и получатель сериализованного у объекта есть загруженные классы для этого объекта, которые совместимы с в отношении сериализации.Если получатель загрузил класс для объекта , который имеет serialVersionUID, отличный от идентификатора класса соответствующего отправителя, то десериализация приведет к исключению InvalidClassException.Сериализуемый класс может объявить свой собственный serialVersionUID явно, объявив поле с именем "serialVersionUID", которое должно быть статическим, конечным и иметь тип long:ANY-ACCESS-MODIFIER статический конечный длинный serialVersionUID = 42L;Если сериализуемый класс явно не объявляет serialVersionUID, тогда среда выполнения сериализации вычислит значение serialVersionUID по умолчанию для этого класса на основе различных аспектов класс, как описано в Java (TM) для сериализации объектов Спецификация.Однако настоятельно рекомендуется, чтобы все сериализуемые классы явно объявляли значения serialVersionUID, поскольку вычисление serialVersionUID по умолчанию очень чувствительно к классу детали, которые могут варьироваться в зависимости от реализаций компилятора, и могут таким образом, привести к неожиданным исключениям InvalidClassException во время десериализации.Следовательно, чтобы гарантировать согласованное значение serialVersionUID в различных реализациях компилятора Java, сериализуемый класс должен объявлять явное значение serialVersionUID.Также настоятельно рекомендуется, чтобы явные объявления serialVersionUID использовали модификатор private, где это возможно, поскольку такие объявления применяются только к непосредственно объявляемому классу-поля serialVersionUID не являются полезны как унаследованные члены.
Если вы заметили, есть еще одно ключевое слово, которое мы использовали, которое преходящий.
Если поле не является сериализуемым, оно должно быть помечено как переходное.Здесь мы отметили Стоимость товара как временный и не хочу, чтобы он был записан в файл
Теперь давайте посмотрим, как записать состояние объекта в файл, а затем прочитать его оттуда.
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]
Обратите внимание на это Стоимость товара из десериализованного объекта получается ноль как это не было написано.
Мы уже обсуждали основы сериализации Java в части I этой статьи.
Теперь давайте подробно обсудим это и то, как это работает.
Во-первых, давайте начнем с serialversionuid.
Тот Самый serialVersionUID сериалВерсионНЫЙ идентификатор используется в качестве элемента управления версиями в сериализуемом классе.
Если вы явно не объявите serialVersionUID , JVM сделает это за вас автоматически, основываясь на различных свойствах сериализуемого класса.
Java-алгоритм вычисления serialversionuid (Подробнее читайте здесь)
- Имя класса.
- Модификаторы класса записываются в виде 32-битного целого числа.
- Название каждого интерфейса отсортировано по названию.
- Для каждого поля класса сортируется по имени поля (за исключением закрытых статических и закрытых временных полей:Название поля. Модификаторы поля записываются в виде 32-разрядного целого числа.Дескриптор поля.
- Если инициализатор класса существует, запишите следующее:Название метода, .
- Модификатор метода, java.lang.reflect.Modifier.СТАТИЧЕСКИЙ, записывается как 32-разрядное целое число.
- Дескриптор метода, ()V.
- Для каждого непубличного конструктора, отсортированного по имени метода и сигнатуре:Название метода, .Модификаторы метода записываются в виде 32-разрядного целого числа.Дескриптор метода.
- Для каждого непубличного метода, отсортированного по имени метода и сигнатуре:Название метода.Модификаторы метода записываются в виде 32-разрядного целого числа.Дескриптор метода.
- Алгоритм SHA-1 выполняется на потоке байтов, генерируемом DataOutputStream, и выдает пять 32-битных значений sha[0..4]. Значение хэша собирается из первого и второго 32-разрядных значений дайджеста сообщения SHA-1.Если результат дайджеста сообщения, пять 32-разрядных слов H0 H1 H2 H3 H4, находятся в массиве из пяти значений int с именем sha, хэш-значение будет вычислено следующим образом:
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
Алгоритм сериализации объекта описан следующим образом:
1.Он записывает метаданные класса, связанного с экземпляром.
2.Он рекурсивно записывает описание суперкласса до тех пор, пока не найдет java.lang.object.
3.Как только он завершает запись метаданных, он начинает с фактических данных, связанных с экземпляром.Но на этот раз он начинается с самого верхнего суперкласса.
4.Он рекурсивно записывает данные, связанные с экземпляром, начиная с наименьшего суперкласса и заканчивая наиболее производным классом.
Что Нужно иметь в виду:
Статические поля в классе не могут быть сериализованы.
public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; }Если serialversionuid отличается в классе read, он выдаст
InvalidClassExceptionисключение.Если класс реализует serializable, то все его подклассы также будут сериализуемыми.
public class A implements Serializable {....}; public class B extends A{...} //also SerializableЕсли класс имеет ссылку на другой класс, все ссылки должны быть сериализуемыми, иначе процесс сериализации не будет выполнен.В таком случае, Исключение NotSerializableException выбрасывается во время выполнения.
Например:
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 о том, что этот класс можно сделать сериализуемым.
Сериализация - это процесс преобразования состояния объекта в биты, чтобы его можно было сохранить на жестком диске. Когда вы десериализуете тот же объект, он сохранит свое состояние позже. Это позволяет вам воссоздавать объекты без необходимости сохранять свойства объектов вручную.
Сериализация - это процесс сохранения объекта на носителе данных (например, файла или буфера памяти) или передачи его по сетевому соединению в двоичном виде. Сериализованные объекты независимы от JVM и могут быть повторно сериализованы любой JVM. В этом случае & "В памяти"! Состояние объектов Java преобразуется в поток байтов. Этот тип файла не может быть понят пользователем. Это особые типы объектов, то есть повторно используемые JVM (виртуальной машиной Java). Этот процесс сериализации объекта также называется дефлятированием или маршалингом объекта.
Объект для сериализации должен реализовывать интерфейс java.io.Serializable.
Механизм сериализации по умолчанию для объекта записывает класс объекта, сигнатуру класса и значения всех непереходных и нестатических полей.
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,
ObjectOutput расширяет интерфейс DataOutput и добавляет методы для сериализации объектов и записи байтов в файл. ObjectOutputStream расширяет java.io.OutputStream и реализует интерфейс ObjectOutputStream( ). Он сериализует объекты, массивы и другие значения в поток. Таким образом, конструктор FileOuputStream записывается как:
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));
Приведенный выше код использовался для создания экземпляра класса ObjectInputStream с конструктором java.io.InputStream, который принимает экземпляр ObjectInput в качестве параметра.
Интерфейс FileInputStream используется для реализации класса ObjectInputStream(). <=> создан для сериализации объекта.
Десериализация объекта в Java
Противоположная операция сериализации называется десериализацией, т. е. извлечение данных из серии байтов называется десериализацией, которая также называется накачкой или демаршалингом.
<=> расширяет <=> и реализует интерфейс <=>. Он десериализует объекты, массивы и другие значения из входного потока. Таким образом, конструктор <=> записывается как:
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));
Над кодом программы создается экземпляр класса <=> для десериализации этого файла, который был сериализован классом <=>. Приведенный выше код создает экземпляр, используя экземпляр класса <=>, который содержит указанный файловый объект, который необходимо десериализовать, поскольку конструктору <=> требуется входной поток.
Serialization это механизм для преобразования графика объектов Java в массив байтов для хранения (to disk file) или передача(across a network), затем с помощью десериализация мы можем восстановить график объектов.Графики объектов восстанавливаются корректно с использованием механизма совместного использования ссылок. Но перед сохранением проверьте, совпадают ли serialVersionUID из входного файла /network и serialVersionUID файла .class.Если нет, выбросьте java.io.InvalidClassException.
Каждый версионный класс должен идентифицировать исходную версию класса, для которой он способен записывать потоки и из которой он может читать.Например, версионный класс должен объявлять:
Синтаксис serialVersionUID
// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L;
serialVersionUID сериалВерсионНЫЙ идентификатор имеет важное значение для процесса сериализации.Но разработчик не обязан добавлять его в исходный файл java.Если serialVersionUID не включен, среда выполнения сериализации сгенерирует serialVersionUID и свяжет его с классом.Сериализованный объект будет содержать этот serialVersionUID наряду с другими данными.
Примечание - Настоятельно рекомендуется, чтобы все сериализуемые классы явно объявляли serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, и, таким образом, может привести к неожиданным конфликтам serialVersionUID во время десериализации, что приведет к сбою десериализации.
Проверка сериализуемых классов
Объект Java является только сериализуемым.если класс или любой из его суперклассов реализует либо java.io.Сериализуемый интерфейс или его субинтерфейс, java.io.Externalizable (Экстернализуемый).
Класс должен реализовывать java.io.Сериализуемый интерфейс для того, чтобы успешно сериализовать свой объект.Serializable является интерфейсом-маркером и используется для информирования компилятора о том, что классу, реализующему его, необходимо добавить сериализуемое поведение. Здесь виртуальная машина Java (JVM) отвечает за его автоматическую сериализацию.
переходное Ключевое слово:
java.io.Serializable interfaceПри сериализации объекта, если мы не хотим, чтобы определенные элементы данных объекта сериализовались, мы можем использовать модификатор transient.Ключевое слово transient предотвратит сериализацию этого элемента данных.
- Поля, объявленные как временные или статические, игнорируются процессом сериализации.
+--------------+--------+-------------------------------------+ | 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. }Реализация экстернализуемого интерфейса позволяет объекту взять на себя полный контроль над содержимым и форматом сериализованной формы объекта.Методы Externalizable интерфейса, writeExternal и 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.Serializable или java.io.Externalizable
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();
}
}
@видеть
Сериализация - это процесс преобразования объекта Java в байтовый массив, а затем обратно в объект с сохраненным состоянием. Полезно для различных вещей, таких как отправка объектов по сети или кеширование на диск.
Узнайте больше из этой короткой статьи, которая довольно хорошо объясняет программную часть процесса , а затем перейдите к Serializable 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);
}
}
|*| Сериализация класса :Преобразование объекта в байты и байтов обратно в объект (десериализация).
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}
|=> Объектная сериализация - это процесс преобразования состояния объекта в пару байтов.
- |-> Реализовать, когда вы хотите, чтобы объект существовал за пределами срока службы JVM.
- |-> Сериализованный объект может быть сохранен в базе данных.
- |-> Сериализуемые - объекты не могут быть прочитаны и поняты людьми, поэтому мы можем обеспечить безопасность.
|=> Объект-Десериализация - это процесс получения состояния объекта и сохранения его в объекте (java.lang.Object).
- |-> Перед сохранением своего состояния он проверяет, совпадают ли serialVersionUID формы input-file/network и serialVersionUID файла .class.
Если нет, выбросьте java.io.InvalidClassException.
|=> Объект Java сериализуем только в том случае, если его класс или любой из его суперклассов
- реализует либо интерфейс java.io.Serializable, либо
- его субинтерфейс, java.io.Externalizable.
|=> Статические поля в классе не могут быть сериализованы.
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}
|=> Если вы не хотите сериализовать переменную класса, используйте ключевое слово transient
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}
|=> Если класс реализует serializable, то все его подклассы также будут сериализуемыми.
|=> Если класс имеет ссылку на другой класс, все ссылки должны быть сериализуемыми, иначе процесс сериализации не будет выполнен.В таком случае,
Исключение NotSerializableException генерируется во время выполнения.
