Почему у Java есть временные поля?

Прежде чем понимать ключевое слово transient, нужно понять концепцию сериализации. Если читатель знает о сериализации, пропустите первую точку.

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

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

Теперь, каково ключевое слово transient и его назначение?

По умолчанию все переменные объекта преобразуются в постоянное состояние. В некоторых случаях вам может потребоваться избегать сохранения некоторых переменных, потому что вам не нужно сохранять эти переменные. Таким образом, вы можете объявить эти переменные как transient. Если переменная объявлена ​​как transient, она не будет сохранена. Это основная цель ключевого слова transient.

Я хочу объяснить приведенные выше два момента следующим примером:

package javabeat.samples;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class NameStore implements Serializable{
    private String firstName;
    private transient String middleName;
    private String lastName;

    public NameStore (String fName, String mName, String lName){
        this.firstName = fName;
        this.middleName = mName;
        this.lastName = lName;
    }

    public String toString(){
        StringBuffer sb = new StringBuffer(40);
        sb.append("First Name : ");
        sb.append(this.firstName);
        sb.append("Middle Name : ");
        sb.append(this.middleName);
        sb.append("Last Name : ");
        sb.append(this.lastName);
        return sb.toString();
    }
}

public class TransientExample{
    public static void main(String args[]) throws Exception {
        NameStore nameStore = new NameStore("Steve", "Middle","Jobs");
        ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("nameStore"));
        // writing to object
        o.writeObject(nameStore);
        o.close();

        // reading from object
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("nameStore"));
        NameStore nameStore1 = (NameStore)in.readObject();
        System.out.println(nameStore1);
    }
}

И вывод будет следующим:

First Name : Steve
Middle Name : null
Last Name : Jobs

Среднее имя объявляется как transient, поэтому оно не будет храниться в постоянном хранилище.

Источник

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

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

Мой небольшой вклад:

Что такое переходное поле?
В принципе, любое поле, измененное ключевым словом transient является переходным полем.

Почему в Java необходимы временные поля?
Ключевое слово transient дает вам некоторый контроль над процессом сериализации и позволяет исключить некоторые свойства объекта из этого процесса. Процесс сериализации используется для сохранения объектов Java, главным образом для сохранения их состояний во время их передачи или бездействия. Иногда имеет смысл не сериализовывать определенные атрибуты объекта.

В каких полях следует отмечать переходные процессы?
Теперь мы знаем цель transient ключевого слова и переходных полей, важно знать, какие поля отмечать переходные процессы. Статические поля также не сериализуются, поэтому соответствующее ключевое слово также будет делать трюк. Но это может испортить ваш классный дизайн; это то, где ключевое слово transient приходит на помощь. Я стараюсь не разрешать поля, значения которых могут быть получены из других, чтобы быть сериализованными, поэтому я отмечаю их переходные. Если у вас есть поле под названием " interest, значение которого может быть вычислено из других полей (principal, rate и time), сериализация его не требуется.

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

transient переменная - это переменная, которая не может быть сериализована.

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

transient используется, чтобы указать, что поле класса не нужно сериализовать. Вероятно, лучшим примером является поле Thread. Обычно нет причин для сериализации Thread, поскольку его состояние очень "специфично для потока".

Системы сериализации, отличные от родной Java, также могут использовать этот модификатор. Например, Hibernate не будет сохранять поля, отмеченные как @Transient, так и модификатором переходного. Терракота также уважает этот модификатор.

Я считаю, что образный смысл модификатора - это "это поле для использования только в памяти". Не сохраняйте или не перемещайте его за пределы этой конкретной виртуальной машины каким-либо образом. т.е. вы не можете полагаться на его значение в другом пространстве памяти VM. Подобно volatile, вы не можете полагаться на определенную семантику памяти и семантики.

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

public class User implements Serializable {

    private static final long serialVersionUID = 1234L;

    private String username;
    private String email;
    private transient String password;
    private Date birthday;
    private int age;

    public User(String username, String email, String password, Date birthday,
            int age) {
        this.username = username;
        this.email = email;
        this.password = password;
        this.birthday = birthday;
        this.age = age;
    }

    public void printInfo() {
        System.out.println("username: " + username);
        System.out.println("email: " + email);
        System.out.println("password: " + password);
        System.out.println("birthday: " + birthday);
        System.out.println("age: " + age);
    }

    // getters and setters

}

В этом классе модели есть три важных момента: Он должен реализовывать интерфейс Serializable. В противном случае, получите java.io.NotSerializableException при попытке сериализации объекта класса. Константа с именем serialVersionUID объявляется и назначается длинное значение:

private static final long serialVersionUID = 1234L;

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

Обратите внимание, что поле пароля отмечено как переходное:

private transient String password;

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

Переменная - переменная, которая не может быть сериализована. Вы используете ключевое слово transient, чтобы указать виртуальной машине Java, что указанная переменная не является частью постоянного состояния объекта.

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

В следующей таблице приведен список спецификаторов доступа и модификаторов Java, которые могут применяться к переменным, методам и классам.

SPECIFIER/MODIFIER  LOCAL VARIABLE  INSTANCEVARIABLE    METHOD   CLASS
public              NA              A                   A         A
protected           NA              A                   A         NA
default             A               A                   A         A
private             NA              A                   A         NA
final               A               A                   A         A
static              NA              A                   A         NA
synchronized        NA              NA                  A         NA
native              NA              NA                  A         NA
volatile            NA              A                   NA        NA
transient           NA              A                   NA        NA
strictfp            NA              NA                  A         A

Поскольку не все переменные имеют сериализуемую природу

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

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

public class Foo implements Serializable 
{
 private String attr1;
 private String attr2;
 ...
}

Теперь, если вы не хотите TRANSFERT/ SAVED этого объекта SO, вы можете использовать ключевое слово > transient

private transient attr2;

Пример

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

Проще говоря, переходное ключевое слово java защищает поля от Serialize в качестве их счетчиков противоположных полей.

В этом фрагменте кода наш абстрактный класс BaseJob реализует интерфейс Serializable, мы распространяемся от BaseJob, но нам не нужно сериализовать удаленные и локальные источники данных; сериализуйте только теги organizationName и isSynced.

public abstract class BaseJob implements Serializable{
   public void ShouldRetryRun(){}
}

public class SyncOrganizationJob extends BaseJob {

   public String organizationName;
   public Boolean isSynced

   @Inject transient RemoteDataSource remoteDataSource;
   @Inject transient LocalDaoSource localDataSource;

   public SyncOrganizationJob(String organizationName) {
     super(new 
         Params(BACKGROUND).groupBy(GROUP).requireNetwork().persist());

      this.organizationName = organizationName;
      this.isSynced=isSynced;

   }
}

согласно google переходный смысл == длится только на короткое время; непостоянно.

теперь, если вы хотите сделать что-нибудь переходное в java, используйте ключевое слово transient.

В: где использовать переходный процесс?

A: Обычно в java мы можем сохранять данные в файлы, приобретая их в переменных и записывая эти переменные в файлы, этот процесс называется Serialization. Теперь, если мы хотим, чтобы переменные данные записывались в файл, мы сделали бы эту переменную переходной.

transient int result = 10;

Примечание: переходные переменные не могут быть локальными.

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

    class Employee{
    String name;
    Date dob;
    transient int age;
    public int calculateAge(Date dob){
        int age = 0;
        //calculate age based on Date of birth
        return age;
    }
}

Здесь в приведенном выше примере я сделал "возраст" как переходный. Когда я записываю возраст в файл, его значение не нужно хранить. У меня есть функция, которая рассчитывает возраст на основе DOB. Мы можем использовать переменные для тех переменных-членов, которых мы не хотим записывать на диск.

Надеюсь, поможет.!