Что такое сериализация объектов? [дубликат]


этот вопрос уже есть ответ здесь:

Что подразумевается под "сериализация объектов"? Не могли бы вы объяснить это на нескольких примерах?

14 322

14 ответов:

сериализация-это преобразование объекта в серию байтов, так что объект может быть легко сохранен в постоянное хранилище или передан по каналу связи. Затем поток байтов может быть десериализован-преобразован в реплику исходного объекта.

сериализацию можно рассматривать как процесс преобразования экземпляра объекта в последовательность байтов (которая может быть двоичной или не зависеть от реализации).

это очень полезно, когда вы хотите передать данные одного объекта по сети, например, от одного JVM к другому.

в Java механизм сериализации встроен в платформу, но вам нужно реализовать сериализуемые интерфейс для создания объекта упорядочиваемый.

вы также можете предотвратить сериализацию некоторых данных в объекте, пометив атрибут как транзиторная.

наконец, вы можете переопределить механизм по умолчанию, и предоставить свой собственный; это может быть пригодно в некоторых особых случаях. Для этого вы используете один из скрытые функции в java.

важно заметить, что сериализуется "значение" объекта или его содержимое, а не класс определение. Таким образом, методы не сериализуются.

вот очень простой пример с комментариями, чтобы облегчить его чтение:

import java.io.*;
import java.util.*;

// This class implements "Serializable" to let the system know
// it's ok to do it. You as programmer are aware of that.
public class SerializationSample implements Serializable {

    // These attributes conform the "value" of the object.

    // These two will be serialized;
    private String aString = "The value of that string";
    private int    someInteger = 0;

    // But this won't since it is marked as transient.
    private transient List<File> unInterestingLongLongList;

    // Main method to test.
    public static void main( String [] args ) throws IOException  { 

        // Create a sample object, that contains the default values.
        SerializationSample instance = new SerializationSample();

        // The "ObjectOutputStream" class has the default 
        // definition to serialize an object.
        ObjectOutputStream oos = new ObjectOutputStream( 
                               // By using "FileOutputStream" we will 
                               // Write it to a File in the file system
                               // It could have been a Socket to another 
                               // machine, a database, an in memory array, etc.
                               new FileOutputStream(new File("o.ser")));

        // do the magic  
        oos.writeObject( instance );
        // close the writing.
        oos.close();
    }
}

когда мы запускаем эту программу, создается файл "o.ser", и мы можем видеть, что произошло позади.

Если мы изменим значение: someInteger, например целое число.Массив, мы можем сравнить, чтобы увидеть, в чем разница.

вот скриншот, показывающий именно это разница:

alt text

можете ли вы определить различия? ;)

существует дополнительное соответствующее поле в сериализации Java:serialversionUID но я думаю, что это уже слишком долго, чтобы покрыть его.

смея ответить на 6-летний вопрос, добавив только очень высокий уровень понимания для людей, новых для Java

что такое сериализация?

преобразование объекта в байты и байты обратно в объект (десериализация).

когда сериализация?

когда мы хотим сохранить объект. Когда мы хотим, чтобы объект существовал за пределами времени жизни JVM.

Реальный Мир Пример:

ATM: когда владелец счета пытается снять деньги с сервера через банкомат, информация о владельце счета, такая как данные вывода, будет сериализована и отправлена на сервер, где данные десериализуются и используются для выполнения операций.

как выполняется сериализация в Java.

  1. реализовать java.io.Serializable интерфейс (интерфейс маркера, так что не метод осуществлять.)

  2. сохраняйте объект: используйте java.io.ObjectOutputStream класс, поток фильтра, который является оболочкой вокруг байтового потока более низкого уровня (для записи объекта в файловые системы или передачи сплющенного объекта по сетевому проводу и перестроения на другой стороне).

    • writeObject(<<instance>>) - написать объект
    • readObject() - для чтения сериализованного объекта

помните:

когда вы сериализуйте объект, будет сохранено только состояние объекта, а не файл класса или методы объекта.

при сериализации 2-байтового объекта вы видите 51 байтовый сериализованный файл.

действия как объект сериализации и де-сериализации.

ответ Для: как он преобразуется в файл 51 bytes?

  • сначала записывает данные магии потока сериализации (STREAM_MAGIC= "AC ED" и STREAM_VERSION=версия виртуальная машина Java.)
  • затем он записывает метаданные класса, связанного с экземпляром (длина класса, имя класса, serialVersionUID).
  • затем он рекурсивно записывает метаданные суперкласса, пока не найдет java.lang.Object.
  • начинается с фактических данных, связанных с экземпляром.
  • наконец записывает данные объектов, связанных с экземпляром, начиная от метаданных до фактического содержимого.

если вас интересует больше информации о сериализации Java, пожалуйста, проверьте это ссылке.

Edit : еще один хороший ссылке читать.

это ответит на несколько частых вопросов:

  1. как не сериализовать любое поле в классе.
    Ответ: используйте переходное ключевое слово

  2. когда дочерний класс сериализуется ли родительского класса получить сериализован?
    Ответ: Нет, если parent не расширяет сериализуемый интерфейс, поле parents не сериализуется.

  3. когда родитель сериализуется ли дочерний класс сериализуется?
    Ответ: да, по умолчанию дочерний класс также сериализуется.

  4. Как избежать сериализации дочернего класса?
    Ответ: A. переопределить writeObject и readObject метод и throw NotSerializableException.

    б. также вы можете отметьте все поля переходные в дочернем классе.

  5. некоторые классы системного уровня, такие как Thread, OutputStream и его подклассы, а также сокет не являются сериализуемыми.

сериализация берет "живой" объект в памяти и преобразует его в формат, который может быть сохранен где-то (например. в памяти, на диске), а затем "десериализован" обратно в живой объект.

Мне понравилось, как @OscarRyz представляет. Хотя здесь я продолжаю история сериализации который был первоначально написан @amitgupta.

даже зная о структуре класса роботов и имея сериализованные данные, ученый Земли не смог десериализовать данные, которые могут заставить роботов работать.

Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:

ученые Марса ждали полной оплаты. После того, как оплата была сделана ученые Марса поделились serialversionUID С учеными Земли. Ученый земли установил его в класс роботов, и все стало хорошо.

сериализация означает сохранение объектов в java. Если вы хотите сохранить состояние объекта и хотите перестроить состояние позже (может быть в другом JVM), можно использовать сериализацию.

обратите внимание, что свойства объекта будут сохранены. Если вы хотите снова воскресить объект, у вас должен быть файл класса, потому что будут сохранены только переменные-члены, а не функции-члены.

например:

ObjectInputStream oos = new ObjectInputStream(                                 
                                 new FileInputStream(  new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();

Searializable является a интерфейс маркера, который отмечает, что ваш класс является сериализуемым. Интерфейс маркера означает, что это просто пустой интерфейс, и использование этого интерфейса уведомит JVM о том, что этот класс можно сделать сериализуемым.

мои два цента из моего собственного блога:

вот подробное объяснение сериализации: (мой личный блог)

сериализация:

сериализация это процесс сохранения состояния объекта. Он представляется и хранится в виде последовательности байт. Это может быть сохранено в файле. Процесс считывания состояния объекта из файла и его восстановления называется десериализация.

в чем необходимость сериализации?

в современной архитектуре всегда есть необходимость хранить состояние объекта, а затем извлекать его. Например, в Hibernate для хранения объекта мы должны сделать класс Сериализуемым. То, что он делает, заключается в том, что как только состояние объекта сохраняется в виде байтов, оно может быть передано в другую систему, которая затем может считывать из состояния и извлекать класс. Состояние объекта может быть получено из базы данных или другой jvm или из отдельного компонента. С помощью сериализации мы можем получить состояние объекта.

пример кода и объяснение:

сначала давайте посмотрим на класс элемента:

public class Item implements Serializable{

    /**
    *  This is the Serializable class
    */
    private static final long serialVersionUID = 475918891428093041L;
    private Long itemId;
    private String itemName;
    private transient Double itemCostPrice;
    public Item(Long itemId, String itemName, Double itemCostPrice) {
        super();
        this.itemId = itemId;
        this.itemName = itemName;
        this.itemCostPrice = itemCostPrice;
      }

      public Long getItemId() {
          return itemId;
      }

     @Override
      public String toString() {
          return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
       }


       public void setItemId(Long itemId) {
           this.itemId = itemId;
       }

       public String getItemName() {
           return itemName;
       }
       public void setItemName(String itemName) {
            this.itemName = itemName;
        }

       public Double getItemCostPrice() {
            return itemCostPrice;
        }

        public void setItemCostPrice(Double itemCostPrice) {
             this.itemCostPrice = itemCostPrice;
        }
}

в приведенном выше коде видно, что Item класс реализует сериализуемые.

это интерфейс, который позволяет классу быть сериализуемым.

теперь мы можем видеть переменная называется serialVersionUID инициализируется в длинную переменную. Это число вычисляется компилятором на основе состояния класса и атрибутов класса. Это число, которое поможет jvm определить состояние объекта, когда он считывает состояние объекта из файла.

для этого мы можем взглянуть на официальную документацию Oracle:

среда выполнения сериализации связывается с каждым сериализуемым классом a версия число, называемое serialVersionUID, которое используется во время десериализация для проверки того, что отправитель и получатель сериализованного объект имеет загруженные классы для этого объекта, которые совместимы с уважение к сериализации. Если получатель загрузил класс для объект, который имеет другой serialVersionUID, чем у объекта соответствующий класс отправителя, то десериализация приведет к InvalidClassException. Сериализуемый класс может объявить свой собственный serialVersionUID явно путем объявления поля с именем "serialVersionUID", который должен быть статическим, окончательным и типа long: Любой-доступ-модификатор статические заключительные долго serialVersionUID = 42Л; если сериализуемый класс явно не объявляет serialVersionUID, затем среда выполнения сериализации вычислит значение по умолчанию serialVersionUID значение для этого класса на основе различных аспектов класс, как описано в сериализации объекта Java(TM Спецификация. Однако, настоятельно рекомендуется, чтобы все сериализуемые классы явно объявили serialVersionUID значения, поскольку по умолчанию serialVersionUID вычисление очень чувствительны к класс сведения, которые могут отличаться в зависимости от реализаций компилятора, и могут таким образом привести к неожиданному InvalidClassExceptions во время десериализация. Поэтому, чтобы гарантировать непротиворечивое serialVersionUID значение через различные реализации компилятора Java, сериализуемый класс должен объявить явное serialVersionUID значение. Также сильно рекомендуется, чтобы явные объявления serialVersionUID использовали частный модификатор, где это возможно, поскольку такие объявления применяются только к поля немедленно объявляющего класса--serialVersionUID не являются полезно в качестве наследуемых членов.

если вы заметили, что есть еще одно ключевое слово, которое мы использовали, которое является транзиторная.

если поле не сериализуемо,оно должно быть помечено как переходное. Здесь мы отметили itemCostPrice в качестве транзиторной и не хочу, чтобы это было записано в файл

теперь давайте посмотрим, как написать состояние объекта в файл, а затем прочитать его оттуда.

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]

обратите внимание, что itemCostPrice от десериализованного объекта null как это не было написано.

мы уже обсуждали основы сериализации Java в части I этой статьи.

теперь давайте обсудим это глубоко и как это завод.

сначала давайте начнем с serialversionuid.

The serialVersionUID используется в качестве элемента управления версиями в Сериализуемом классе.

если вы явно не объявите serialVersionUID, JVM сделает это за вас автоматически, основываясь на различных свойствах Сериализуемого класса.

алгоритм вычисления serialversionuid Java (Подробнее читайте здесь)

  1. имя класса.
    1. модификаторы класса, записанные как 32-разрядное целое число.
    2. имя каждого интерфейса, отсортированного по имени.
    3. для каждого поля класса, отсортированного по имени поля (кроме частных статических и частных переходных полей: имя поля. Этот модификаторы поля записывается как 32-разрядное целое число. Дескриптор поля.
    4. если инициализатор класса существует, выпишите следующее: имя метода .
    5. модификатор метода, java.ленг.отражать.Модификатор.Статический, записанный как 32-разрядное целое число.
    6. дескриптор метода, ()В.
    7. для каждого не частного конструктора, отсортированного по имени метода и подписи: имя метода, . Модификаторы метод записывается как 32-разрядное целое число. Дескриптор метода.
    8. для каждого не частного метода, отсортированного по имени метода и подписи: имя о методе. Модификаторы метода записываются в виде 32-разрядное целое число. Дескриптор метода.
    9. алгоритм SHA-1 выполняется на потоке байтов, производимых DataOutputStream и производит пять 32-разрядных значений sha[0..4]. Этот хэш-значение собирается из первого и второго 32-разрядных значений Дайджест сообщения SHA-1. Если результат дайджеста сообщения, то пять 32-битные слова H0 H1 H2 H3 H4, находится в массиве из пяти значений int с именем ша, хэш-значение будет вычисляться следующим образом:
    long hash = ((sha[0] >>> 24) & 0xFF) |
>            ((sha[0] >>> 16) & 0xFF) << 8 |
>            ((sha[0] >>> 8) & 0xFF) << 16 |
>            ((sha[0] >>> 0) & 0xFF) << 24 |
>            ((sha[1] >>> 24) & 0xFF) << 32 |
>            ((sha[1] >>> 16) & 0xFF) << 40 |
>            ((sha[1] >>> 8) & 0xFF) << 48 |
>        ((sha[1] >>> 0) & 0xFF) << 56;

алгоритм сериализации Java

алгоритм сериализации объекта описан ниже:
1. Он записывает метаданные класса, связанного с экземпляром.
2. Он рекурсивно записывает описание суперкласса, пока не найдет java.ленг.объект.
3. Как только он закончит писать метаданные, затем он начинается с фактических данных, связанных с экземпляром. Но в этот раз начинается с самого верхнего суперкласса.
4. Он рекурсивно записывает данные, связанные с экземпляром, начиная от наименьшего суперкласса до наиболее производного класса.

Вещи, Чтобы Иметь В Виду:

  1. статические поля в классе не могут быть сериализованы.

    public class A implements Serializable{
         String s;
         static String staticString = "I won't be serializable";
    }
  2. если serialversionuid отличается в классе чтения он будет бросать InvalidClassException исключения.

  3. если класс реализует Serializable, то все его подклассы также быть сериализуемыми.

    public class A implements Serializable {....};
    
    public class B extends A{...} //also Serializable
  4. если класс имеет ссылку на другой класс, все ссылки должны быть Сериализуемыми в противном случае процесс сериализации не будет выполняться. В таком случае, NotSerializableException бросается в во время выполнения.

например:

public class B{
     String s,
     A a; // class A needs to be serializable i.e. it must implement Serializable
}

сериализация - это процесс преобразования состояния объекта в биты, чтобы он мог храниться на жестком диске. Когда вы десериализовать один и тот же объект, он запомнит свое состояние. Это позволяет воссоздавать объекты без необходимости сохранять свойства объектов вручную.

http://en.wikipedia.org/wiki/Serialization

сериализация-это процесс сохранения объекта на носителе данных (например, в файле или буфере памяти) или передачи его по сетевому соединению в двоичной форме. Сериализованные объекты независимы от JVM и могут быть повторно сериализованы любой JVM. В этом случае состояние объектов java "в памяти" преобразуется в поток байтов. Этот тип файла не может быть понят пользователем. Это специальные типы объектов, т. е. повторно используемые JVM (виртуальная машина Java). Этот процесс сериализация объекта также называется дефляцией или маршалингом объекта.

сериализуемый объект должен реализовывать java.io.Serializable интерфейс. Механизм сериализации по умолчанию для объекта записывает класс объекта, сигнатуру класса и значения всех непереходных и нестатических полей.

class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,

ObjectOutput интерфейс расширяет DataOutput интерфейс и добавляет методы для сериализации объектов и записи байтов в файл. Элемент ObjectOutputStream выходит java.io.OutputStream и реализует ObjectOutput интерфейс. Он сериализует объекты, массивы и другие значения в поток. Таким образом, конструктор ObjectOutputStream написано:

ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));

выше код был использован для создания экземпляра ObjectOutput класс ObjectOutputStream( ) конструктор, который принимает экземпляр FileOuputStream в качестве параметра.

The ObjectOutput интерфейс используется путем реализации ObjectOutputStream класса. Элемент ObjectOutputStream создан для того, чтобы сериализовать объект.

десериализация объекта в java

противоположная операция сериализации называется десериализацией, т. е. для извлечения данных из серии байтов известна как десериализация, которая также называется раздуванием или unmarshalling.

ObjectInputStream выходит java.io.InputStream и осуществляет ObjectInput интерфейс. Он десериализует объекты, массивы и другие значения из входного потока. Таким образом, конструктор ObjectInputStream написано как:

ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));

выше код программы создает экземпляр ObjectInputStream класс для десериализации этого файла, который был сериализован ObjectInputStream класса. Приведенный выше код создает экземпляр, используя экземпляр FileInputStream класс, который содержит указанный файловый объект, который должен быть десериализован, потому что ObjectInputStream() конструктор нуждается во входном потоке.

сериализация-это процесс превращения объекта Java в массив байтов, а затем снова в объект с сохраненным состоянием. Полезно для различных вещей, таких как отправка объектов по сети или кэширование вещей на диск.

Читать подробнее эта короткая статья, которая объясняет программную часть процесса довольно хорошо а затем перейти к to сериализуемый 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);
        }
    }

Java Сериализация Объектов

enter image description here

Serialization - это механизм преобразования графа объектов Java в массив байтов для хранения (to disk file) или передачи(across a network), затем с помощью десериализации мы можем восстановить граф объектов. Графики объектов восстанавливаются правильно с помощью механизма совместного использования ссылок. но прежде чем хранение, проверьте, является ли serialVersionUID из входного файла / сети И.класс файла serialVersionUID одинаковы. Если нет, бросьте 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 конфликтов во время десериализации, в результате десериализации, чтобы потерпеть неудачу.

Проверка Сериализуемых Классов

enter image description here


объект Java является только сериализуемым. если класс или любой из его суперклассов реализует либоjava.io.Serializable интерфейс или его подинтерфейс, java. io. Externalizable.

  • класс должен реализоватьjava.io.Serializable интерфейс для того, чтобы успешно сериализовать свой объект. Serializable является интерфейсом маркера и используется для информирования компилятора о том, что класс, реализующий его, должен быть добавлен serializable behavior. здесь виртуальная машина Java (JVM) отвечает за ее автоматическую сериализацию.

    переходные Ключевое слово:java.io.Serializable interface

    при сериализации объекта, если мы не хотим, чтобы определенные элементы данных объекта были сериализованы, мы можем использовать переходный модификатор. Переходное ключевое слово будет допустить, что члены данных могут быть сериализованы.

    • поля, объявленные как переходные или статические, игнорируются процессом сериализации.

    переходный & летучие

    +--------------+--------+-------------------------------------+
    |  Flag Name   |  Value | Interpretation                      |
    +--------------+--------+-------------------------------------+
    | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.|
    +--------------+--------+-------------------------------------+
    |ACC_TRANSIENT | 0x0080 | Declared transient; not written or  |
    |              |        | read by a persistent object manager.|
    +--------------+--------+-------------------------------------+
    class Employee implements Serializable {
        private static final long serialVersionUID = 2L;
        static int id;
    
        int eno; 
        String name;
        transient String password; // Using transient keyword means its not going to be Serialized.
    }
  • реализация интерфейса Externalizable позволяет объекту взять на себя полный контроль над содержимым и форматом сериализованной формы объекта. Методы 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();
    }
}

@see

|*| сериализация класса: преобразование объекта в байты и байты обратно в объект (десериализация).

class NamCls implements Serializable
{
    int NumVar;
    String NamVar;
}

|=> Object-сериализация-это процесс преобразования состояния объекта в пару байтов.

  • |-> реализовать, когда вы хотите, чтобы объект существовал за пределами срока службы JVM.
  • |-> сериализованный объект может храниться в базе данных.
  • |-> сериализуемый-объекты не могут быть прочитаны и понятый людьми, чтобы мы могли достичь безопасности.

|=> Object-десериализация-это процесс получения состояния объекта и сохранения его в объект(java.ленг.Объект.)

  • |-> перед сохранением своего состояния он проверяет weather serialVersionUID form input-file / network and .файл класса serialVersionUID такие же.
    и nbsp&nbspIf не бросают Java.Ио.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 выбрасывается во время выполнения.

Java предоставляет механизм, называемый сериализацией объектов, где объект может быть представлен в виде последовательности байтов, которая включает данные объекта, а также информацию о типе объекта и типах данных, хранящихся в объекте. Он в основном используется для перемещения состояния объекта в сети (известный как маршалинг).