что такое java beans
Что такое java beans
Объекты JavaBean могут быть управляющими элементами GUI, но могут быть и не представленными визуально. Управляющие элементы GUI в Java обычно являются объектами JavaBean, чтобы ими можно было управлять инструментами компоновки. В J2EE простые объекты JavaBean обычно берутся из JSP, где они обеспечивают разделение презентации на языке HTML и кода на языке Java, содержащегося в объектах JavaBean.
Свойства JavaBean
Методы доступа к свойствам иногда называют аксессорами. Аксессоры могут быть методами get и set и подчиняются соглашениям об именах:
void setимя_свойства(тип_свойства value); // метод set
тип_свойства getимя_свойства() // метод get
Для булевского свойства метод get может быть следующим:
boolean isимя_свойства() // метод get для булевского свойства
Пример: пользовательский объект JavaBean
Ниже приведен пример простого объекта JavaBean (Customer) с двумя простыми свойствами: name и email. Обратите внимание, что свойства определяются парами методов set/get.
public class Customer <
private String name;
private String email;
public String getName() <
return name;
>
public void setName(String aName) <
name = aName;
>
public String getEmail() <
return email;
>
public void setEmail(String aEmail) <
email = aEmail;
>
Такие простые объекты JavaBean часто используются в JSP, где они позволяют передавать значения из форм Web-страниц.
Индексированные свойства
Индексированные свойства могут возвращать значение по указанному индексу или целый массив значений.
У индексированных свойств следующие сигнатуры:
void setимя_свойства(int index, тип_свойства value); // индексированный set
тип_свойства getter(int index); // индексированный get
void setимя_свойства(тип_свойства values[]); // массив set
тип_свойства[]getимя_свойства(); // массив get
Привязанные свойства
Механизм привязанных свойств обеспечивает рассылку уведомлений при изменении свойства. Объекты, заинтересованные в получении уведомлений об изменениях, регистрируют себя заранее, и когда свойство изменяется, зарегистрированным объектам отправляется соответствующее уведомление. Обычно это уведомление рассылается посредством события, выдаваемого компонентом с привязанным свойством после задания свойства.
Объект JavaBean с привязанным свойством предлагает методы регистрации и отмены регистрации заинтересованных объектов, называемых получателями. Разработчики могут определить свой собственный механизм уведомлений, но библиотеки Java предоставляют несколько распространенных классов поддержки в составе пакета java.beans.
Ограниченные свойства
Ограниченные свойства схожи с привязанными свойствами, но уведомление отправляется до фактического задания свойства. Это позволяет заинтересованным сторонам запретить изменение свойства, выдав исключительную ситуацию PropertyVetoException.
События и уведомление
Для поддержки этой модели связи модель компонентов JavaBean предоставляет:
Следующая диаграмма классов иллюстрирует эти концепции для объекта JavaBean EventSource с простым свойством int.
Во время настройки конкретные получатели регистрируются с объектом JavaBean. В один из последующих моментов другой объект вызывает метод setProperty, который запустит процесс уведомления путем создания объекта событий. Объект JavaBean EventSource вызовет метод propertyChange во всех зарегистрированных получателях. Получатели событий получат событие, прочтут его значения и отреагируют на него.
На следующей последовательной диаграмме иллюстрируется порядок вызовов:
Уведомление получателей выполняется синхронно по отношению к экземпляру JavaBean, который является источником события, однако получатель событий может обрабатывать их в другой нити.
Внутренний анализ
Постоянные данные
Настройка
Внешний вид и характеристики объекта JavaBean можно настраивать во время проектирования. Это особенно важно для визуальных объектов JavaBean, применяемых в графических пользовательских интерфейсах. Настройка выполняется с помощью редактора свойств или программ настройки. Программы настройки предоставляют пользовательский интерфейс для настройки экземпляра JavaBean во время проектирования.
BeanContext
BeanContext определяет логическую иерархию включений, позволяющую объектам JavaBean выяснять, какие функции и службы доступны в их среде. Механизмы BeanContext предоставляют поддержку логической иерархии включений объектов JavaBean и поиска служб, предлагаемых входящими в иерархию объектами JavaBean.
Среда активации объектов JavaBean™
Дополнительная информация
Дополнительная информация об объектах JavaBean приведена в документе JavaBeans API Specification, Version 1.01 на Web-сайте http://java.sun.com/. Выберите ссылку Docs & Training > Java 2 Platform, Standard Edition > Java 2 SDK, SE v1.3 documentation > JavaBeans > JavaBeans Specification.
© Copyright IBM Corp. 1987, 2006. Все права защищены.
Что такое java beans
[an error occurred while processing this directive]
Конспект лекций по Java. Занятие 25
[an error occurred while processing this directive](none)
Технология JavaBeans
Что такое JavaBeans
В исходной документации по JavaBeans от Sun определено: «Целью технологии JavaBeans является определение модели программных компонент такой, что фирмы-разработчики ( third party firms ) могут создавать и устанавливать Java-компоненты, которые могут быть скомпонованы конечными пользователями в законченные приложения».
В компонентном программировании подразумевается наличие не только самих компонент, но и некоторой визуальной среды разработки, позволяющей в диалоге строить программу из этих компонент. Причем, результат процесса сразу виден на экране. Технология JavaBean также неявно подразумевает наличие такой среды, но никоим образом не определяет ее. Соответствующие диалоговые среды разработки есть и, наверное, еще будут созданы новые. Эти среды отличаются друг от друга, иногда значительно, но все опираются на JavaBean, который является в этом смысле некоторым стандартом.
В процессе компонентного программирования можно выделить три группы действующих лиц, или три роли. Во-первых, это конечный пользователь, т.е. прикладной программист, который в визуальной среде собирает программу из отдельных компонент. Во-вторых, это разработчик готовых компонент. И, в-третьих, это разработчик визуальных сред компоновки программ.
Соответственно, тут возможны варианты. Можно, например, создать среду и технологию построения компонент под эту среду. Именно так поступила MicroSoft, создав Visual Basic и технологии OLE и ActiveX. А можно сделать универсальную технологию, которая позволяла бы не только создавать компоненты, но и визуальные среды, использующие эти компоненты. JavaBean создана в расчете именно на этот вариант.
Кроме того, нужно учитывать, что универсальная технология, претендующая на стандарт, должна учитывать интересы всех указанных групп действующих лиц. Она должна иметь средства, позволяющие разработчикам визуальных сред подключать различные компоненты в палитру доступных компонент, что вызывает необходимость наличия средств анализа готовых компонент. Она должна иметь правила разработки компонент, с тем, чтобы разработанная компонента могла быть интегрирована в визуальную среду. И, наконец, она должна определять средства связи компонент, которые прикладной программист использует для объединения готовых компонент в законченное приложение.
Три указанные роли являются, конечно, некоторым идеалом и в реальности эти роли зачастую пересекаются. Так, фирмы разработчики визуальных сред (таких как, JBuilder, Semantec Cafe, VisualJ и др.) включают в состав своих продуктов разработанные ими библиотеки, содержащие бины; разработчики прикладного ПО в процессе разработки не только используют существующие бины, но и создают свои.
Что такое Bean
В документации от Sun бин определяется так: «A Java Bean is a reusable software component that can be manipulated visually in a builder tool.» («Java Bean это многократно используемый программный компонент, которым можно манипулировать визуально в (визуальных) средах разработки»).
В простейшем случае бин — это отдельный класс, представляющий определенную компоненту. В более сложных случаях — это набор взаимосвязанных классов, каждый из которых играет определенную роль. Так многие классы стандартной библиотеки Java являются бинами, например, JLabel, JTextField и др.
Основной класс бина должен удовлетворять одному требованию — он должен иметь конструктор по умолчанию (default constructor). Это требование естественно. Предполагается, что визуальная среда будет создавать экземпляры бинов и использовать для этого конструкторы по умолчанию. Есть и другие требования к бинам. Мы их рассмотрим далее.
Бины могут быть совершенно разными как по размерам, сложности, так и по области применения. Каждый конкретный бин может поддерживать ту или иную степень функциональности, но типичные универсальные возможности, которые обеспечивает бин следующие.
Рассмотрим эти возможности подробнее. И начнем с конца, с persistence («сохраняемости»), как с самого простого.
Это свойство обеспечивается выполнением следующего требования. Каждый бин в заголовке описания класса должен содержать » implements java.io.Serializable «, т.е. бины должны быть сериализуемыми. Предполагается, что визуальная среда при сохранении скомпонованного приложения дополнительно сохраняет настройки компонент, сделанные пользователем в процессе разработки приложения и делает она это путем сериализации бина, например, в некоторый файл. При повторном входе в среду разработки и загрузке приложения эти настройки восстанавливаются. Для этого среда разработки просто десериализует бины из файла.
Свойства бинов (Bean properties)
Обычно каждый бин имеет свойства, которые определяют, как он будет работать и/или как он будет выглядеть. Эти свойства являются private или protected полями класса бина, которые доступны для выборки и/или модификации через специальные public методы. Другими словами бин обеспечивает доступ к своим свойствам через public методы ‘get. ‘ и ‘set. ‘. Эти методы называют аксессорами (accessor) или, жаргонно, getters и setters и имеют определенные правила построения. Так утверждение «данный бин имеет свойство name типа String » означает, что у этого бина
Такой подход соответствует общим принципам объектно-ориентированного программирования, когда внутренние поля класса недоступны непосредственно и могут быть извлечены/изменены только посредством вызова методов класса.
Рассмотрим, к примеру, JLabel по документации. Во-первых, JLabel удовлетворяет интерфейсу Serializable, во-вторых, имеет конструктор по умолчанию
и, в-третьих, имеет ряд методов аксессоров, например,
public String getText()
public void setText(String text)
Правила построение методов доступа к атрибутам (аксессоров)
Аксессоры строятся по следующим правилам
Эти правила относятся к простым свойствам. Кроме того, свойства могут быть индексированными или, другими словами, атрибут бина может быть массивом.
Для индексированных свойств выработаны следующие правила.
Они должны быть описаны как поля-массивы, например,
private String[] messages;
и должны быть такие методы
Так, для приведенного выше примера должны быть методы
public String getMessages(int index);
public void setMessages(int index, String message);
public String[] getMessages();
public void setMessages(String[] messages);
Bean-методы
Кроме аксессоров, бин может иметь любое количество других методов, как обычный класс Java.
Интроспекция бинов при помощи reflection API
Описанных выше правил достаточно для осуществления простейшей интроспекции бинов с использованием reflection API. Вспомним возможности интроспекции, рассмотренные нами ранее.
В результате соответствующая визуальнае среда разработки может построить диалог, в котором будет предоставлена возможность задавать значения этих атрибутов. Наличие конструктора по умолчанию позволяет построить объект bean-класса, set-методы позволят установить в этом объекте значения атрибутов, введенные пользователем, а благодаря сериализации объект с заданными атрибутами можно сохранить в файле и восстановить значение объекта при следующем сеансе работы с данной визуальной средой. Более того, можно изобразить на экране внешний вид бина (если это визуализируемый бин) в процессе разработки и менять этот вид в соответствии с задаваемыми пользователем значениями атрибутов.
Связанные свойства (bound properties) и события
Еще одним важным аспектом технологии JavaBeans является возможность бинов взаимодействовать с другими объектами, в частности, с другими бинами. JavaBeans реализует такое взаимодействие путем генерации (firing) событий и прослушивания (listening) событий.
События и событийную модель Java мы рассматривали на 20-м занятии. В приложении к бинам взаимодействие объектов с бином через событийную модель выглядит так. Объект, который интересуется тем, что может произойти во внешнем, по отношению к нему, бине, может зарегистрировать себя как слушателя (listener) этого бина. В результате, при возникновении соответствующего события в бине будет вызван определенный метод данного объекта, которому в качестве параметра будет передан объект-событие (event). Причем, если зарегистрировалось несколько слушателей, то эти методы будут последовательно вызваны для каждого слушателя.
Теперь, если мы захотим добавить в наше приложение вывод какой-то информации по данному файлу, например, вывод имени файла где-нибудь внизу или вверху экрана, нам придется внимательно отследить, где в программе может изменятся это поле и вставить в этих точках обновление имени файла на экране. В данном приложении это вполне приемлемо, так как оно является небольшим и обозримым, но в более сложных случаях это может вызвать проблемы.
Создание и использование связанного свойства
Разберемся практически, как создавать и использовать связанные свойства.
Начнем с события, которое должно быть сгенерировано при изменении связанного свойства. Это событие класса java.beans.PropertyChangeEvent (см. документацию).
Далее можно действовать по следующей инструкции.
Пункт 4-й должен быть реализован для каждого класса-слушателя, а п.5 — для каждого порожденного объекта-слушателя.
Java Beans
Я тут подумал и решил устроить тебе еще одну маленькую лекцию, которая будет тебе очень полезна. Пока ты не работал программистом, ты, скорее всего, не сталкивался со специальной терминологией, и я хочу тебя сейчас познакомить с несколькими распространёнными понятиями.
Лет 10 назад массовое распространение получила концепция EJB – E nterprise J ava B eans.
— А что значит Java Beans?
— Bean по-английски боб. А Java Beans – это, стало быть, кофейные бобы (Java – сорт кофе). Такой айтишный юмор.
Бизнес-логику программы представляли в виде набора высокоуровневых объектов – бинов, которые умели обмениваться сообщениями, сохранять себя, находить друг друга по имени, и еще кучу всего. Обычно это достигалось за счет специального супер-навороченного родительского класса, хотя были и другие подходы. Поведение таких объектов очень регламентировалось.
Три самых известных вида EJB-бинов:
Entity Bean – бин, цель которого — хранить некоторые данные. В логику такого бина встроен механизм сохранения себя и своих полей в базу данных. Такой объект может быть уничтожен, а потом воссоздан из базы заново. Но кроме хранения данных у него нет никакой логики.
Session Bean – это функциональный бин. У каждого Session Bean есть своя функция. Один делает одно, другой другое. Такие бины работают с другими объектам и бинами, а не со своими данными.
Session Beans делятся на две категории.
Stateless Session Bean – это бин, который не хранит во внутренних переменных важных данных, нужных для его работы. Такой бин можно уничтожить, а затем заново создать, и он будет выполнять свою функцию, как и раньше.
Statefull Session Bean – это бин, который хранит у себя внутри данные, которые использует при работе. Если мы вызываем методы этого бина, то в каждом следующем вызове он может использовать часть данных, переданных ему в предыдущих. И все равно этот бин – это не то же самое, что обычный объект.
Но в использовании бинов тоже было не все так радужно, поэтому скоро маятник качнулся в обратную сторону. И разработчики стали все чаще использовать обычные объекты. Им даже придумали специальное название.
POJO ( P lain O ld J ava O bject) – старый обычный Java-объект. Такие объекты не обладали какими-то суперфункциями и не наследовались от суперобъектов. Самые обычные Java-объекты.
Со временем в назначении объектов/классов возникла специализация. Как результат – выделились некоторые роли, объекты которых получили новые названия.
DTO — Data Transfer Object – объект, который создается с целью быть использованным при транспортировке данных. Обычно к таким объектам два требования: а) уметь хранить данные, б) уметь сериализоваться. Т.е. их используют только для пересылки данных.
Создал объект, записал в него нужные данные из бизнес-логики, сериализовал в JSON/XML и отправил куда-надо. Или наоборот – пришло сообщение – десериализовал его в DTO-объект и вытягивай из него данные.
Entity – это объект, который хранится в базе данных. Но они не содержат никакой бизнес-логики. Можно сказать, что это – данные бизнес-модели.
Есть еще DAO – Data Access Object. Задача DAO — сохранять объекты в базу и доставать их из нее. Entity сам такой работой не занимается – он не содержит никакой логики и, следовательно, не может ничего никуда сохранять.
Пусть это и небольшая ознакомительная лекция, но больше ты сейчас все равно не поймешь. Каждую из этих тем можно днями рассказывать, а EJB – годами.
Но я хочу, чтобы ты хотя бы представлял, о чем речь, если столкнёшься с такими вещами в разговоре, переписке, на форуме или на собеседовании.
— Гм. Спасибо, Билаабо. Да, думаю, технических терминов мне не хватает. Спасибо большое тебе еще раз.
Что такое JavaBean точно?
кроме того, есть ли реальная синтаксические разница между Бобом и обычным классом? Есть ли специальное определение или интерфейс?
в принципе, почему для этого есть термин?
редактировать: если вы можете быть так добры и добавить информацию о Serializable интерфейс, и что это значит, к вашему ответу, я был бы очень благодарен.
15 ответов
вот именно. Это просто съезд. Хотя от этого зависит множество библиотек.
С уважением Serializable с документация по API:
Сериализуемость класса включена классом, реализующим java.Ио.Сериализуемый интерфейс. Классов, которые не реализуют это интерфейс не имеет ни своей государственной сериализуются и десериализуются. Все подтипы сериализуемого класса сами являются сериализуемыми. Этот интерфейс сериализации не имеет методов или полей и служит только для определите семантику сериализуемости.
другими словами, сериализуемые объекты могут быть записаны в потоки, и, следовательно, файлы, базы данных объектов, что угодно.
кроме того, нет синтаксической разницы между JavaBean и другим классом-класс определяет JavaBean, если он соответствует стандартам.
для этого есть термин, потому что стандарт позволяет библиотекам программно делать вещи с экземплярами классов, которые вы определяете предопределенным способом. Например, если библиотека хочет передать в поток любой объект, который вы передаете в нее, она знает, что это возможно, потому что ваш объект сериализуем (предполагая, что lib требует, чтобы ваши объекты были правильными JavaBeans).
для этого есть термин, чтобы он звучал особенным. Реальность далеко не так таинственна.
конечно, для этого класс должен соблюдать определенные ограничения. Главным из них является то, что все поля экземпляра должны быть примитивными типами (int, bool и т. д.), экземплярами некоторого класса, который также сериализуем, или помечены как transient Так что Java не будет пытаться включить их. (Это конечно значит, что transient поля не переживут путешествие по ручью. Класс, который имеет transient поля должны быть готовы к повторной инициализации при необходимости.)
класс, который не может соблюдать эти ограничения не должны выполнять Serializable (и, IIRC, компилятор Java даже не пусть это не так.)
JavaBeans-это классы Java, которые придерживаются чрезвычайно простого соглашения о кодировании. Все, что вам нужно сделать, это
JavaBean-это объект Java, который удовлетворяет определенным соглашениям программирования:
класс JavaBean должен реализовать либо Serializable или Externalizable
класс JavaBean должен иметь конструктор no-arg
все свойства JavaBean должны иметь методы public setter и getter
все переменные экземпляра JavaBean должны быть рядовой
Java Beans используют для меньшего кода и большего подхода к работе. Java-бобы используются в Java EE в качестве универсального контракта для обнаружения и доступа во время выполнения. Например, JavaServer Pages (JSP) использует Java Beans в качестве объектов передачи данных между страницами или между сервлетами и JSPs. Java EE JavaBeans Activation Framework использует Java Beans для интеграции поддержки типов данных MIME в Java EE. API управления Java EE использует JavaBeans в качестве основы для инструментария ресурсы для управления в среде Java EE.
в сериализации объекта объект может быть представлен в виде последовательности байтов, которая включает данные объекта, а также информацию о типе объекта и типах данных, хранящихся в объекте.
после того, как сериализованный объект был записан в файл, его можно прочитать из файла и десериализовать, то есть информацию о типе и байты, которые представляют объект и его данные могут использоваться для воссоздания объекта в памяти.
вы найдете сериализацию полезной при развертывании проекта на нескольких серверах, так как бобы будут сохраняться и передаваться через них.
объяснение с примером.
1. импорт java.Ио.Сериализуемый
Что касается сериализации, см. документация.
2. частные поля
поля должны быть частными для предотвращения внешних классов легко изменять эти поля. Вместо того, чтобы непосредственно доступ к этим полям, используемые usuagly методы геттер/сеттер будут.
3. Конструктор
общественный конструктор без каких-либо аргументов.
4. getter/setter
методы Getter и setter для доступа к частным полям.
класс должен иметь открытый конструктор по умолчанию (без аргументов). Это позволяет легко создавать экземпляры в рамках редактирования и активации.
свойства класса должны быть доступны с помощью get, set, is (может использоваться для булевых свойств вместо get) и других методов (так называемых методов доступа и методов мутатора) в соответствии со стандартным соглашением об именах. Это позволяет легко автоматизировать проверка и обновление состояния компонента в рамках, многие из которых включают пользовательские редакторы для различных типов свойств. Сеттеры могут иметь один или несколько аргументов.
класс должен быть сериализуемым. [Это позволяет приложениям и фреймворкам надежно сохранять, хранить и восстанавливать состояние компонента независимо от виртуальной машины и платформы.]
для получения дополнительной информации следуйте этому ссылка.
Java Beans является стандартом, и его основные синтаксические требования были четко объяснены другими ответами.
однако, IMO, это больше, чем простой стандарт синтаксиса. Реальный смысл или предполагаемое использование Java Beans, вместе с различными инструментами поддержки вокруг стандарта, для облегчения повторного использования кода и компонентного программного обеспечения, т. е. позволяют разработчикам создавать приложения путем сборки существующих компонентов (классов) и без необходимости писать какой-либо код (или только нужно написать немного кода клея). К сожалению, эта технология недооценена и недостаточно используется промышленностью, что можно сказать из ответов в этой теме.
Если Вы читаете Oracle учебник по Java Beans, вы можете получить лучшее понимание в этом.
Что касается второй части вашего вопроса, сериализация-это механизм сохранения используется для хранения объектов в виде последовательности байтов подпись. Менее формально, он сохраняет состояние объекта, чтобы вы могли получить его позже, путем де-сериализации.
Java Bean-это класс java [conceptual], который должен следовать следующим соглашениям:
это многоразовый программный компонент. Он может инкапсулировать много объектов в один объект, чтобы к одному и тому же объекту можно было получить доступ из нескольких мест и шаг к простоте обслуживания кода.
они сериализуемы, имеют конструктор с нулевым аргументом и разрешают доступ к свойствам с помощью методов getter и setter. Название «Bean» было дано, чтобы охватить этот стандарт, который направлен на создание многоразовых программных компонентов для Java. according to wiki
объекты, которые образуют основу вашего приложения и управляются контейнером Spring IoC, называются бобами. Боб-это объект, который создается, собирается и иным образом управляется Весенний контейнер МОК. В противном случае, фасоль-это просто один из многих объектов в вашем приложении. according to весна io.
существует два основных соглашения, которые должны соблюдаться при создании классов Java Bean:
чтобы понять JavaBean, вам нужно заметить следующее: JavaBean является концептуальным материалом и не может представлять класс конкретных вещей
JavaBean-это инструмент разработки, который можно визуализировать в работе многоразовых программных компонентов
JavaBean основан на спецификации Sun JavaBeans и может быть многоразовыми компонентами. Его самой большой особенностью является re-usability.
Java Bean по существу является классом, что классифицирует класс как bean: 1. Он должен реализовать сериализуемый интерфейс (интерфейс маркера). 2. Конструктор должен быть общедоступным и не иметь аргументов (то, что другие люди называют конструктором no-arg). 3. У него должны быть геттер и сеттер.
хорошо отметить, что поле serialVersionUID важно для поддержания состояния объекта. Ниже код квалифицируется как bean: