Что такое JavaBean?

Есть термин, чтобы сделать его звучащим особенным. Реальность далеко не такая загадочная.

В основном, "Боб":

• является сериализуемым объектом (то есть он реализует java.io.Serializable и делает это правильно), что
• имеет "свойства", чьи геттеры и сеттеры являются просто методами с определенными именами (например, getFoo() является геттером для свойства "Foo"), и
• имеет открытый конструктор 0-arg (поэтому он может быть создан по желанию и настроен путем установки его свойств).

Обновить:

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

Конечно, чтобы сделать это, класс должен соблюдать определенные ограничения. Главным среди них является то, что все поля экземпляров должны быть либо примитивными типами (int, bool и т.д.), Экземплярами некоторого класса, который также сериализуем, или помечены как transient чтобы Java не пыталась включить их. (Это, конечно, означает, что transient поля не выживут при прохождении через поток. Класс, имеющий transient поля, должен быть готов к их повторной инициализации в случае необходимости.)

Класс, который не может соблюдать эти ограничения, не должен реализовывать Serializable (и, IIRC, компилятор Java даже не допустит этого).

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

• Внедрить интерфейс java.io.Serializable - сохранить состояние объект
• использовать открытый пустой конструктор аргументов - для создания объекта
• И предоставить общедоступные методы getter и setter. Чтобы получить и установить значения частных переменных (свойств).

Свойства JavaBeans

JavaBean - это объект Java, который удовлетворяет определенным соглашениям о программном обеспечении:

• Класс JavaBean должен реализовать либо Serializable, либо Externalizable

• Класс JavaBean должен иметь конструктор no-arg

• Все свойства JavaBean должны иметь общедоступные методы настройки и генерации

• Все переменные экземпляра JavaBean должны быть частными

Пример JavaBeans

@Entity
public class Employee implements Serializable{

   @Id
   private int id;
   private String name;   
   private int salary;  

   public Employee() {}

   public Employee(String name, int salary) {
      this.name = name;
      this.salary = salary;
   }
   public int getId() {
      return id;
   }
   public void setId( int id ) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName( String name ) {
      this.name = name;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Java Beans используются для меньшего количества кода и более рабочего подхода... Java Beans используются в Java EE как универсальный контракт для обнаружения и доступа к среде выполнения. Например, JavaServer Pages (JSP) использует Java Beans как объекты передачи данных между страницами или между сервлетами и JSP. Java EE JavaBeans Activation Framework использует Java Beans для интеграции поддержки типов данных MIME в Java EE. API управления Java EE использует JavaBeans в качестве основы для инструментария управления ресурсами в среде Java EE.

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

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

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

Объяснение с примером.

1. import java.io.Serializable

Что касается сериализации, см. документацию .

2. частные поля

Поля должны быть закрытыми, чтобы внешние классы не могли легко изменять эти поля. Вместо прямого доступа к этим полям используются обычные методы getter/setter.

3. Конструктор

Открытый конструктор без каких-либо аргументов.

4. геттер/сеттер

Методы Getter и setter для доступа к закрытым полям.

/** 1. import java.io.Serializable */
public class User implements java.io.Serializable {
    /** 2. private fields */
    private int id;
    private String name;

    /** 3. Constructor */
    public User() {
    }
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    /** 4. getter/setter */
    // getter
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    // setter
    public void setId(int id) {
        this.id = is;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Вы найдете Сериализацию полезной при развертывании вашего проекта на нескольких серверах, поскольку beans будет сохраняться и переноситься через них.

Java Beans является стандартом, и его основные требования синтаксиса были четко объяснены другими ответами.

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

Если вы читаете учебник Oracle на Java Beans, вы можете получить лучшее понимание в этом.

Согласно Википедии:

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

• Свойства класса должны быть доступны с помощью get, set, (может использоваться для логических свойств вместо get) и других методов (так называемых методов доступа и методов мутаторов) в соответствии со стандартным соглашением об именах. Это позволяет легко автоматизировать проверку и обновление состояния bean в рамках фреймворка, многие из которых включают настраиваемые редакторы для различных типов свойств. У сеттеров может быть один или несколько аргументов.

• Класс должен быть сериализуемым. [Это позволяет приложениям и фреймворкам надежно сохранять, сохранять и восстанавливать состояние bean способом, не зависящим от VM и платформы.]

Для получения дополнительной информации следуйте этой ссылке .

Java Bean - это Java-класс [концептуальный], который должен следовать следующим соглашениям:

• Он должен иметь конструктор no-arg.
• Он должен быть Serializable.
• Он должен предоставлять методы для установки и получения значений свойств, известных как методы getter и setter.

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

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

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

При создании классов Java Bean должно выполняться два основных соглашения:

• Каждое свойство "класса Java Bean реализуется путем определения двух открытых функций (функция" get "и функция" set ")
• " операции" класса Java Bean - это другие публичные функции, определенные в классе.

Они сериализуемы, имеют конструктор с нулевым аргументом и разрешают доступ к свойствам с использованием методов getter и setter. Название "Bean" было предоставлено для охвата этого стандарта, целью которого является создание повторно используемых программных компонентов для Java. according to wiki

Объекты, составляющие основу вашего приложения и управляемые контейнером IoC Spring, называются beans. A bean - это объект, который создается, монтируется и управляется иным образом контейнером IoC Spring. В противном случае bean является просто одним из многих объектов вашего приложения. according to spring io.

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

JavaBean - это инструмент разработки, который можно визуализировать при работе с повторно используемыми программными компонентами.

JavaBean основан на спецификации Sun JavaBeans и может быть повторно использованными компонентами. Его самая большая особенность - повторное использование.

Java Bean по сути является классом, который классифицирует класс как bean:

1. Он должен реализовывать сериализуемый интерфейс (интерфейс Marker).
2. Конструктор должен быть открытым и не иметь аргументов (то, что другие называют его конструктором без аргументов).
3. Он должен иметь геттер и сеттеры.

Приятно отметить, что поле serialVersionUID важно для поддержания состояния объекта. Ниже код квалифицируется как bean-компонент:

public class DataDog implements java.io.Serializable {

private static final long serialVersionUID = -3774654564564563L;

private int id;
private String nameOfDog;

//The constructor should NOT have arguments
public DataDog () {}


/** 4. getter/setter */

// getter(s)
public int getId() {
    return id;
}
public String getNameOfDog() {
    return nameOfDog;
}
// setter(s)
public void setId(int id) {
    this.id = id;
}
public void setNameOfDog(String nameOfDog) {
    this.nameOfDog = nameOfDog;
}}