Что такое JavaBean?

Question

Я понял, я думаю, что "Bean" - это класс Java со свойствами и геттерами / сеттерами. Насколько я понимаю, это эквивалент структуры Си. Это правда?

Кроме того, есть ли реальная синтаксическая разница между бином и обычным классом? Есть какое-то специальное определение или интерфейс?

В основном, почему есть термин для этого?

Изменить: Если вы можете быть так добры и добавить информацию о Serializable интерфейс, и что это значит, на ваш ответ, я был бы очень благодарен.

Answer 1

JavaBean - это просто стандарт

1. Все свойства частные (используйте геттеры / сеттеры)
2. Публичный конструктор без аргументов
3. инвентарь Serializable,

Вот и все. Это просто соглашение. От этого зависит множество библиотек.

Что касается Serializable Из документации API:

Сериализуемость класса обеспечивается классом, реализующим интерфейс java.io.Serializable. Классы, которые не реализуют этот интерфейс, не будут сериализованы или десериализованы. Все подтипы сериализуемого класса сами по себе сериализуемы. Интерфейс сериализации не имеет методов или полей и служит только для определения семантики сериализации.

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

Кроме того, нет никакой синтаксической разницы между JavaBean и другим классом - класс определяет JavaBean, если он следует стандартам.

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

Answer 2

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

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

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

Обновить:

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

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

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

Answer 3

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

1. Реализовать интерфейс java.io.Serializable - чтобы сохранить состояние объекта
2. использовать открытый пустой конструктор аргументов - для создания объекта
3. И предоставьте общедоступные методы получения и установки - чтобы получить и установить значения частных переменных (свойств).

Answer 4

Свойства JavaBeans

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

1. Класс JavaBean должен реализовывать либо Serializable или жеExternalizable

2. Класс JavaBean должен иметь конструктор без аргументов

3. Все свойства JavaBean должны иметь публичные методы установки и получения

4. Все переменные экземпляра 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;
   }
}

Answer 5

Пояснение с примером.

1. импорт java.io.Serializable

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

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

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

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

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

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

Методы получения и установки для доступа к закрытым полям.

/** 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;
    }
}

Answer 6

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

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

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

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

Answer 7

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

Они были изобретены на ранних этапах Java как часть создания графических интерфейсов. Они следовали шаблонам, которые легко разбирались инструментами, позволяя им создать панель свойств, чтобы вы могли редактировать атрибуты Бина. В общем, свойства Bean представляют элемент управления на экране (Think x,y,width,height,text,..)

Вы также можете думать об этом как о строго типизированной структуре данных.

Со временем они стали полезными для многих инструментов, которые использовали один и тот же тип доступа (например, Hibernate для сохранения структур данных в базе данных).

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

Теперь я вижу бины как аннотированные шары свойств - они действительно полезны только для аннотаций, которые они несут.

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

Кстати, когда все это происходило, кто-то расширил концепцию до чего-то под названием Enterprise Java Beans. Это... разные. и они достаточно сложны, чтобы многие люди чувствовали, что они не поняли всей концепции Бина, и перестали использовать этот термин. Я думаю, именно поэтому вы обычно слышите bean-компоненты, называемые POJO (поскольку каждый java-объект является POJO, это технически нормально, но когда вы слышите, как кто-то говорит POJO, они чаще всего думают о чем-то, что следует биновому шаблону)

Answer 8

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

Answer 9

Компонент - это класс Java с именами методов, которые соответствуют руководящим принципам JavaBean (также называемым шаблонами проектирования) для свойств, методов и событий.. Таким образом, любой общедоступный метод класса компонента, который не является частью определения свойства, является методом компонента. Как минимум, Java-класс, даже если он имеет свойство в качестве единственного члена (конечно, требуются сопутствующие общедоступные методы получения и установки), открытый метод в качестве единственного члена или только один метод регистрации общедоступного прослушивателя событий, является Java-компонентом. Кроме того, свойство может быть либо свойством только для чтения (имеет метод получения, но не сеттером), либо свойством только для записи (имеет только метод установки). Компонент Java должен быть общедоступным классом, чтобы быть видимым для любого инструмента или контейнера beanbox. Контейнер должен иметь возможность создавать его экземпляры; таким образом, у него тоже должен быть открытый конструктор. Спецификация JavaBeans не требует, чтобы у bean-компонента был открытый конструктор с нулевым аргументом, явный или по умолчанию, чтобы контейнер мог его создать. Если бы вы могли предоставить файл (с расширением.ser), содержащий сериализованный экземпляр, инструмент beanbox мог бы использовать этот файл для создания экземпляра bean-прототипа. В противном случае у bean-компонента должен быть открытый конструктор с нулевым аргументом, явный или используемый по умолчанию.

После создания экземпляра компонента JavaBean API ( java.beans.*) Может проанализировать его и вызвать для него методы. Если класс SimpleBeanInfo, реализующий интерфейс BeanInfo или расширяющий реализацию BeanInfo, не доступен, интроспекция включает использование отражения (неявной интроспекции) для изучения методов, поддерживаемых целевым компонентом, а затем применение простых шаблонов проектирования (рекомендаций) для вывода те методы, какие свойства, события и общедоступные методы поддерживаются. Если доступен класс, реализующий интерфейс BeanInfo (для компонента Foo он должен называться FooBeanInfo), API обходит неявный интроспекцию и использует общедоступные методы (getPropertyDescriptor(), getMethodDescriptors(), getEventSetDescriptors()) этого класса для получения Информация. Если доступен класс, расширяющий SimpleBeanInfo,в зависимости от того, какие общедоступные методы SimpleBeanInfo (getPropertyDescriptor(), getMethodDescriptors(), getEventSetDescriptors()) переопределяются, он будет использовать эти переопределенные методы для получения информации; для метода, который не переопределен, по умолчанию будет использоваться соответствующая неявная интроспекция. Компонент должен быть создан в любом случае, даже если в нем не выполняется неявная интроспекция. Таким образом, требование общедоступного конструктора zeri-args. Но, конечно, для его распознавания не обязательно использовать интерфейс Serializable или Externalizable. Однако в спецификации JavaBean сказано: "Мы также хотели бы, чтобы он был" тривиальным "для обычного случая крошечного Bean, который просто хочет сохранить свое внутреннее состояние и не хочет думать об этом". Итак, все bean-компоненты должны реализовывать интерфейс Serializable или Externalizable. В общем и целом,Спецификация JavaBeans не является точной и быстрой в отношении того, что представляет собой компонент. "Написание компонентов JavaBeans на удивление легко. Вам не нужен специальный инструмент, и вам не нужно реализовывать какие-либо интерфейсы. Написание bean-компонентов - это просто вопрос соблюдения определенных соглашений о кодировании. Все, что вам нужно сделать, это сделать свой класс похожим на bean - инструменты, использующие bean-компоненты, смогут распознать и использовать ваш bean-компонент ". Тривиально, даже следующий класс является JavaBean,Все, что вам нужно сделать, это сделать ваш класс похожим на bean-компонент - инструменты, использующие bean-компоненты, смогут распознать и использовать ваш bean-компонент. "Тривиально, даже следующий класс является JavaBean,Все, что вам нужно сделать, это сделать ваш класс похожим на bean-компонент - инструменты, использующие bean-компоненты, смогут распознать и использовать ваш bean-компонент ". Тривиально, даже следующий класс является JavaBean,

public class Trivial implements java.io.Serializable {}

Скажем, у конструктора bean-компонента есть параметры. Предположим, что это простые типы. Контейнер может не знать, какие значения им присвоить; даже в этом случае полученный экземпляр нельзя будет повторно использовать. Это может иметь смысл только в том случае, если пользователь может настраивать (указывать значения), например, аннотациями или файлами конфигурации xml, как в Spring beans. И предположим, что некоторые параметры являются типами классов или интерфейсов. Опять же, контейнер может не знать, какие значения ему присвоить. Это может иметь смысл только в том случае, если пользователь может настраивать (указывать определенные объекты), например, аннотациями или файлами конфигурации xml. Однако даже в Spring (через файлы конфигурации xml) назначение определенных объектов (со строковыми именами) аргументам конструктора (атрибуту или элементу аргументов конструктора) не является типобезопасным; это в основном похоже на внедрение ресурсов.Ссылки на другие bean-компоненты Spring (называемые соавторами; через элемент в элементе аргумента конструктора) в основном являются внедрением зависимостей и, следовательно, безопасным для типов. Очевидно, что у зависимости (компонента-сотрудника) может быть конструктор с введенными параметрами; эти внедренные зависимости могут иметь конструктор с параметрами и так далее. В этом сценарии, в конечном итоге, вам понадобятся некоторые классы bean-компонентов (например, MyBean.class), которые контейнер может создать, просто вызвав new MyBean(), прежде чем он сможет создать другие взаимодействующие bean-компоненты через внедрение зависимостей в конструкторы - таким образом, требование для у beans есть общедоступный конструктор с нулевым аргументом. Предположим, если контейнер не поддерживает внедрение зависимостей и / или не позволяет назначать значения простого типа конструктору через некоторые аннотации или файлы конфигурации xml, как в Spring,Конструкторы bean-компонентов не должны иметь параметров. Даже приложению bean-компонентов Spring потребуются некоторые bean-компоненты, чтобы иметь общедоступный конструктор с нулевым аргументом (например, в сценарии, где ваше приложение Spring не имеет bean-компонента с простыми типами в качестве аргументов конструктора).

Управляемые компоненты JSF запускаются в веб-контейнере. Их можно настроить либо с помощью аннотации @ManagedBean, либо с помощью файла ресурсов конфигурации приложения managed-bean.xml. Однако он поддерживает инъекцию только через инъекцию ресурсов (не типизированную); не подходит для инъекций в конструкторы. Спецификация JSF требует, чтобы у управляемых bean-компонентов были общедоступные конструкторы без аргументов. Далее говорится: "Начиная с версии 2.3 данной спецификации, использование средств управляемого компонента, как указано в этом разделе, настоятельно не рекомендуется. Лучшим и более согласованным интегрированным решением для решения той же проблемы является использование внедрения контекстов и зависимостей (CDI), как указано в JSR-365."Другими словами, будут использоваться управляемые компоненты CDI, которые предлагают безопасное внедрение зависимостей в конструкторы, похожие на в Spring beans.Спецификация CDI принимает спецификацию Managed Beans, которая применяется ко всем контейнерам платформы JEE, а не только к веб-уровню.Таким образом, веб-контейнер должен реализовывать спецификацию CDI.

Вот выдержка из спецификации Managed Bean"Управляемые компоненты - это объекты, управляемые контейнером, с минимальными требованиями, иначе известные под аббревиатурой" POJOs "(простые старые объекты Java)… их можно рассматривать как расширенную версию Java EE компонентной модели JavaBeans, которая существует на платформе Java SE. …. Читатель не упустит из виду, что у Managed Beans есть предшественник в одноименном средстве, найденном в технологии JavaServer Faces (JSF)... Управляемые Beans, как определено в этой спецификации, представляют собой обобщение тех, что есть в JSF; в частности, Managed Beans можно использовать в любом месте приложения Java EE, а не только в веб-модулях. Например, в базовой модели компонентов управляемые компоненты должны предоставлять конструктор без аргументов, но спецификацию, основанную на управляемых компонентах, например CDI (JSR-299),может ослабить это требование и позволить управляемым компонентам предоставлять конструкторам более сложные сигнатуры, если они следуют некоторым четко определенным правилам... Управляемый компонент не должен быть: конечным классом, абстрактным классом, нестатическим внутренним классом. Управляемый компонент не может быть сериализуемым, в отличие от обычного компонента JavaBean ". Таким образом, спецификация для управляемых компонентов, также известных как POJO или POJO beans, допускает расширение, как в CDI.

Спецификация CDI переопределяет управляемые bean-компоненты как: При работе в Java EE класс Java верхнего уровня является управляемым bean-компонентом, если он соответствует требованиям:

• Это не внутренний класс. • Это неабстрактный класс или аннотируется @Decorator. • Он не реализует javax.enterprise.inject.spi.Extension. • Он не аннотирован @Vetoed или в пакете с аннотацией @Vetoed. • У него есть соответствующий конструктор: либо класс имеет конструктор без параметров, либо класс объявляет конструктор с аннотацией @Inject.

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

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

• Он не аннотирован аннотацией, определяющей компонент EJB, и не объявлен как класс EJB-компонента в ejb-jar.xml.

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

EJB запускаются в контейнере EJB. Его спецификация говорит: "Компонент сеансового компонента - это управляемый компонент". "Класс должен иметь открытый конструктор, который не принимает аргументов", - говорится как для сеансового компонента, так и для компонента, управляемого сообщениями. Кроме того, в нем говорится: "Класс сеансового компонента - это не требуется для реализации интерфейса SessionBean или интерфейса Serializable ". По той же причине, что и JSF-бины, что внедрение зависимостей EJB3 в основном является инъекцией ресурсов, JSF-бины не поддерживают конструкторы с аргументами, то есть посредством внедрения зависимостей. Однако, если контейнер EJB реализует CDI, "Необязательно: класс может иметь дополнительный конструктор, аннотированный аннотацией Inject, "он говорит как для сессионного компонента, так и для компонента, управляемого сообщениями, потому что" EJB, упакованный в архив bean-компонента CDI и не аннотированный аннотацией javax.enterprise.inject.Vetoed, считается поддерживаемым CDI фасоль.

Answer 10

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

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

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

Answer 11

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

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

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

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

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

Answer 12

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

Answer 13

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

1. Он должен иметь конструктор без аргументов.
2. Это должно быть Serializable.
3. Он должен предоставлять методы для установки и получения значений свойств, известные как методы получения и установки.

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

Answer 14

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

Существует два основных соглашения, которым необходимо следовать при создании классов Java Bean:

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

Answer 15

Выше 6 или 7 раз повторялось, что для JavaBeans требуется конструктор без аргументов.

Это НЕПРАВИЛЬНО, такого требования нет, особенно в контексте Java Spring.

Также нет упоминания об этом требовании в версии (1.01) спецификации, которая описывает API JavaBeanns (https://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/). Более того, в этой спецификации «нулевой конструктор» упоминается только 2 раза в следующих контекстах: «Каждый настройщик должен иметь нулевой конструктор». «Каждый PropertyEditor должен иметь нулевой конструктор».

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

Answer 16

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

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

Answer 17

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;
}}

Answer 18

Если вы знакомы с C / Golang, вы никогда не слышали C bean или Go bean, потому что у них есть ключевое слово, с помощью которого разработчики могут легко определять типы структур без написания сложных ключевых слов ООП.

      type User struct {
  Name string
  Age int
}

var user User

user.Name = "name"
user.Age = 18

var bytes, err = json.Marshal(user)

Ошибка Java - отсутствие типов, и разработчики находят эту нехватку серьезной.

Затем был изобретен Java Bean как еще одно скучное правило для создания class притворяться struct, мир ваш редактор или компилятор не будет плакать или кричать о вашем небезопасном доступе к членам класса.

Answer 19

POJO(простой старый объект Java):- POJO - это обычный объект Java, без ограничений, кроме тех, которые навязаны языком Java.

Сериализация:- Используется для сохранения состояния объекта и отправки его по сети. Он преобразует состояние объекта в поток байтов. Мы можем воссоздать объект Java из потока байтов с помощью процесса, называемого десериализацией.

Сделайте так, чтобы ваш класс реализовал интерфейс java.io.Serializable. И используйте метод writeObject() класса ObjectOutputStream для достижения сериализации.

Класс JavaBean:- Это специальный объект POJO, имеющий некоторые ограничения (или соглашения). 1. Реализуйте сериализацию 2. Имейте общедоступный конструктор без аргументов 3. Все свойства являются частными с общедоступными методами получения и установки.

Многие фреймворки, например Spring, используют объект JavaBean.

Answer 20

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

Answer 21

Если вы хотите понять Java-Beans, вам сначала нужно понять программные компоненты.

Программные компоненты

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

Компонент – это:

• Связанный (имеет зависимости)
• Statefull (сохраняет состояния переменных экземпляра)
• Не стандартизирован, он предназначен для конкретного варианта использования (основное отличие между Java-EE Beans).
• Работает на клиентской машине

Java-бины (корпоративные бины)

• Стандартизированные компоненты, работающие на сервере Java EE.
• Включение различной бизнес-логики для выполнения конкретной услуги
• Упрощение разработки сложных многоуровневых распределенных систем

Java Beans — это скорее концепция управления большими системами. Поэтому им нужна стандартизация.

Источник

Answer 22

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

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

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

Answer 23

Аннотация Spring @Bean указывает, что метод создает компонент, которым будет управлять контейнер Spring.

Дополнительная ссылка: https://www.concretepage.com/spring-5/spring-bean-annotation

Answer 24

JavaBean

В вычислениях, основанных на платформе Java, JavaBeans — это технология, разработанная Sun Microsystems и выпущенная в 1996 году как часть JDK 1.1.

«Бобы» JavaBeans — это классы, которые инкапсулируют один или несколько объектов в один стандартизированный объект (бин). Эта стандартизация позволяет обрабатывать bean-компоненты более общим образом, упрощая повторное использование кода и самоанализ. Это, в свою очередь, позволяет рассматривать bean-компоненты как программные компоненты и визуально манипулировать ими с помощью редакторов и IDE без необходимости какой-либо начальной настройки или знания каких-либо внутренних деталей реализации.

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

JavaBean — это класс Java, который должен следовать следующим соглашениям:

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

Зачем использовать JavaBean?

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

Функции JavaBean

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

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

• getPropertyName

Например, если имя свойства — firstName, имя метода будет getFirstName() для чтения этого свойства. Этот метод называется аксессором.

• setPropertyName

Например, если имя свойства — firstName, имя метода будет setFirstName() для записи этого свойства. Этот метод называется мутатором.

• Самоанализ

Самоанализ — это процесс анализа Бина для определения его возможностей. Это важная функция API Java Beans, поскольку она позволяет другому приложению, например инструменту проектирования, получать информацию о компоненте.

• Настройка

Настройщик может предоставить пошаговое руководство, которому должен следовать процесс, чтобы использовать компонент в определенном контексте.

• События

Бины могут взаимодействовать с моделью EventObject EventListener.[требуется уточнение]

• Упорство

Постоянство — это способность сохранять текущее состояние Бина, включая значения свойств Бина и переменных экземпляра, в энергонезависимой памяти и извлекать их позже.

• Методы

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

Преимущества JavaBean

Ниже перечислены преимущества JavaBean:

1. Свойства и методы JavaBean могут быть доступны другому приложению.
2. Это обеспечивает легкость повторного использования программных компонентов.
3. Бин может зарегистрироваться для получения событий от других объектов и может генерировать события, которые отправляются этим другим объектам.
4. Вспомогательное программное обеспечение может быть предоставлено для помощи в настройке bean-компонента. Параметры конфигурации bean-компонента можно сохранить в постоянном хранилище и восстановить.

Недостатки JavaBean

Ниже перечислены недостатки JavaBean:

1. JavaBeans изменяемы. Таким образом, он не может использовать преимущества неизменяемых объектов.2. Необходимость создавать геттеры для каждого свойства и сеттеры для многих, большинства или всех из них может привести к огромному количеству шаблонного кода. Это можно смягчить с помощью таких инструментов, как Lombok.
2. Класс с конструктором без аргументов может быть создан в недопустимом состоянии.[1] Если такой класс создается вручную разработчиком (а не автоматически какой-либо инфраструктурой), разработчик может не понять, что экземпляр класса был создан неправильно. Компилятор не может обнаружить такую ​​проблему, и даже если она задокументирована, нет гарантии, что разработчик увидит документацию.
3. Класс с конструктором без аргументов может быть создан в недопустимом состоянии. Если такой класс создается разработчиком вручную (а не автоматически какой-либо инфраструктурой), разработчик может не осознавать, что класс был создан неправильно. создан. Компилятор не может обнаружить такую ​​проблему, и даже если она задокументирована, нет гарантии, что разработчик увидит документацию. Компоненты JavaBeans по своей природе изменяемы, и поэтому им не хватает преимуществ, предлагаемых неизменяемыми объектами.

Пример кода

      public class Player implements java.io.Serializable {

/** Properties **/
private boolean deceased = false;

private List list;

/** Property "name", readable/writable. */
private String name = null;

/** No-arg constructor (takes no arguments). */
public Player() {
}

public List getList() {
    return list;
}

public void setList(final List list) {
    this.list = list;
}

/**
 * Getter for property "name".
 */
public String getName() {
    return name;
}

/**
 * Setter for property "name".
 *
 * @param value
 */
public void setName(final String value) {
    this.name = value;
}

/**
 * Getter for property "deceased"
 * Different syntax for a boolean field (is v.s. get)
 */
public boolean isDeceased() {
    return deceased;
}

/**
 * Setter for property "deceased".
 * @param value
 */
public void setDeceased(boolean value) {
    deceased = value;
  }
}

Answer 25

Java Bean - это компонент или базовый строительный блок в архитектуре JavaBeans. Архитектура JavaBeans - это компонентная архитектура, которая выигрывает от возможности многократного использования и взаимодействия компонентного подхода.

Допустимая архитектура компонентов должна позволять собирать программы из стандартных блоков программного обеспечения (в данном случае Beans), возможно, предоставляемых разными поставщиками, а также позволять архитектору / разработчику выбирать компонент (Bean), понимать его возможности и включать это в приложение.

Поскольку классы / объекты являются основными строительными блоками в языке ООП, как Java, они являются естественными претендентами будучи Bean в JavaBeans архитектуры.

Процесс преобразования простого Java-класса в Java-компонент на самом деле является не чем иным, как превращением его в повторно используемый и взаимодействующий компонент. Это будет преобразовано в класс java, обладающий такими способностями, как:

1. управление свойствами, событиями и методами класса, доступными другому приложению. (У вас может быть класс BeanInfo, который сообщает только о тех свойствах, событиях и методах, которые необходимы внешнему приложению)
2. постоянство (быть сериализуемым или извлекаемым - это также подразумевает наличие конструкторов без аргументов, использующих переходные процессы для полей)
3. возможность регистрироваться на события, а также генерировать события (например, для использования связанных свойств и ограничений)
4. настройщики (для настройки Bean-компонента с помощью графического интерфейса пользователя или путем предоставления документации)

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

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

Answer 26

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

Типичное использование фасоли в реальном мире:

• простые многоразовые объекты POJO (простые старые объекты Java)
• визуальные объекты
• Spring использует Beans для обработки объектов (например, объект User, который необходимо сериализовать в сеансе)
• EJB (Enterprise Java Beans), более сложные объекты, такие как JSF Beans (JSF - старая, довольно устаревшая технология) или JSP Beans

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

Как их использовать, это только ваше изобретение, но наиболее распространенные случаи я перечислил выше.