В чем разница между JavaBean и POJO?
Я не уверен в разнице. Я использую Hibernate, и в некоторых книгах они используют JavaBean и POJO как взаимозаменяемый термин. Я хочу знать, есть ли разница не только в контексте Hibernate, но и в общих понятиях.
JavaBean следует определенным соглашениям. Именование геттера / сеттера, наличие общедоступного конструктора по умолчанию, возможность сериализации и т. Д. См. Соглашения JavaBeans .
POJO (обычный старый Java-объект) строго не определен. Это Java-объект, который не требует реализации определенного интерфейса или наследования от определенного базового класса, или использования определенных аннотаций для совместимости с данной средой, и может быть любым произвольным (часто относительно простым) Java-объект
Обратите внимание, что JavaBean может быть и обычно является POJO, и многие POJO на самом деле являются JavaBean-компонентами.
Нет, по определению POJO Java Bean не является POJO, потому что для того, чтобы считаться Java Bean, класс должен следовать определенным соглашениям о кодировании (например, иметь конструктор без аргументов, иметь методы, начинающиеся со слов «get» и / или «set») или распространяться с помощью класса BeanInfo.
Поскольку это соглашения , я думаю, вы можете успешно утверждать, что bean-компонент может быть POJO (например, вы не наследуете от интерфейса JavaBean или подобного)
Спецификация JavaBeans не в состоянии определить JavaBean, кроме очень свободно, как «программный компонент многократного использования» (или некоторые другие). Он не должен иметь конструктор без аргументов, не нуждается в методах, начинающихся с «get» или «set», не должен быть сериализуемым, даже не должен быть классом.
В математическом плане мы можем сказать, что Javabeans образуют подмножество POJO, потому что определенные ограничения, накладываемые на POJO, делают его Javabean.
Все JavaBean-компоненты являются POJO, но не все POJO-объекты являются JavaBean-компонентами.
JavaBean — это объект Java, который удовлетворяет определенным правилам программирования:
- класс JavaBean должен реализовывать либо Serializable, либо Externalizable;
- класс JavaBean должен иметь открытый конструктор без аргументов;
- все свойства JavaBean должны иметь открытые методы установки и получения (в зависимости от ситуации);
- все переменные экземпляра JavaBean должны быть закрытыми.
Я думал, что POJO не могут реализовать Serializable .
«класс JavaBean должен иметь конструктор без аргументов»; также добавить публику здесь
JavaBean является сериализуемым, и поэтому JavaBean НЕ является POJO.
По словам Мартина Фаулера, POJO — это объект, который инкапсулирует бизнес-логику, в то время как бин (за исключением определения, уже указанного в других ответах) — это всего лишь контейнер для хранения данных, а операции, доступные над объектом, просто устанавливают и получают данные.
Этот термин был придуман, когда Ребекка Парсонс, Джош МакКензи и я готовились к выступлению на конференции в сентябре 2000 года. В этой беседе мы говорили о многих преимуществах кодирования бизнес-логики в обычные объекты Java, а не с использованием Entity Beans. Мы задались вопросом, почему люди были против использования обычных объектов в своих системах, и пришли к выводу, что это потому, что простым объектам не хватает причудливого имени. Итак, мы дали им один, и это очень хорошо завоевало популярность.
http://www.martinfowler.com/bliki/POJO.html
POJO: Если класс может быть выполнен с базовым JDK, без какой-либо поддержки сторонних сторонних библиотек, то он называется POJO
JavaBean: Если класс содержит только атрибуты с аксессорами (сеттерами и геттерами), они называются javabeans. Обычно Java-бины не содержат никакой логики бизнес-процессов, а используются для хранения некоторых данных.
Все Javabeans являются POJO, но все POJO не являются Javabeans
Pojo — Простой старый объект Java
Класс pojo — это обычный класс без каких-либо специальностей, класс, полностью не связанный с технологией / фреймворком. Класс не реализует из технологии / фреймворка и не расширяет API-интерфейс технологии / фреймворка тем, что класс называется классом pojo.
Класс pojo может реализовывать интерфейсы и расширять классы, но суперкласс или интерфейс не должны быть технологией / фреймворком.
class ABC ---- >Класс ABC не реализует или не расширяет технологии / рамки, поэтому это класс pojo.
class ABC extends HttpServlet --- >Класс ABC, расширяющийся от api технологии сервлетов, поэтому это не класс pojo.
class ABC implements java.rmi.Remote ---- >Класс ABC реализуется из rmi api, поэтому это не класс pojo.
class ABC implements java.io.Serializable --- >этот интерфейс является частью языка Java, а не частью технологии / framework. так что это класс pojo.
class ABC extends Thread -- >Здесь поток также является классом языка Java, так что это также класс Pojo.
class ABC extends Test -- >если класс Test расширяется или реализуется из технологий / инфраструктуры, то ABC также не является классом pojo, поскольку он наследует свойства класса Test. если класс Test не является классом pojo, то класс ABC также не является классом pojo.
теперь этот пункт является исключительным случаем
@Entity class ABC -- >@Entity это аннотация, заданная hibernate api или jpa api, но все же мы можем назвать этот класс классом pojo. класс с аннотациями, данными из технологии / framework, в этом исключительном случае называется pojo class.
Java-бины — это особый тип POJO.
Специальности, перечисленные ниже с указанием причины
POJOS с определенными соглашениями (getter / setter, общедоступный конструктор без аргументов, приватные переменные) и находятся в действии (например, используются для чтения данных по форме) JAVABEANS .
В итоге: сходства и различия:
java beans: Pojo: -must extends serializable -no need to extends or implement. or externalizable. -must have public class . - must have public class -must have private instance variables. -can have any access specifier variables. -must have public setter and getter method. - may or may not have setter or getter method. -must have no-arg constructor. - can have constructor with agruments.Все бобы JAVA являются POJO, но не все POJO являются бобами JAVA.
Вы видели формальные определения выше, сколько бы они ни стоили.
Но не слишком зацикливайтесь на определениях. Давайте просто посмотрим больше на смысл вещей здесь.
JavaBeans используются в приложениях Enterprise Java, где пользователи часто получают доступ к данным и / или коду приложения удаленно, то есть с сервера (через сеть или частную сеть) через сеть. Следовательно, соответствующие данные должны передаваться в последовательном формате на компьютеры пользователей или с них — следовательно, для объектов Java EE требуется реализация интерфейса Serializable. Эта большая часть природы JavaBean ничем не отличается от объектов приложений Java SE, данные которых считываются или записываются в файловую систему. Надежное использование классов Java по сети из ряда комбинаций пользовательских компьютеров и ОС также требует принятия соглашений об их обработке. Отсюда вытекает необходимость реализации этих классов как открытых, с закрытыми атрибутами, конструктором без аргументов и стандартизированными методами получения и установки.
Приложения Java EE также будут использовать классы, отличные от тех, которые были реализованы как JavaBeans. Они могут использоваться при обработке входных данных или организации выходных данных, но не будут использоваться для объектов, передаваемых по сети. Следовательно, приведенные выше соображения не должны применяться к ним, если они допустимы как объекты Java. Эти последние классы упоминаются как POJO — простые старые объекты Java.
В общем, вы могли видеть Java Beans как просто объекты Java, адаптированные для использования по сети.
С 1995 года в мире программного обеспечения очень много ажиотажа и немало хулиганства.
Programming difference between POJO and Bean
I have the following two classes. Can I say the first one is a POJO class and the second one as a Bean class? 1) POJO class, since it has only getter and setter method, and all the member are declared as private
public class POJO < private int id; private String name; public int getId() < return id; >public String getName() < return name; >public void setId() < this.id = id; >public void setName() < this.name = name; >> 2) Bean class — all the member variables are private, has getters and setters and implements Serializable interface
public class Bean implements java.io.Serializable < private String name; private Integer age; public String getName() < return this.name; >public void setName(String name) < this.name = name; >public Integer getAge() < return this.age; >public void setAge(Integer age) < this.age = age; >> Что такое бин и как он отличается от POJO класса?
В мире Java-программирования неизменным является использование классов и объектно-ориентированного подхода. Однако, кроме обычных классов, существуют так называемые «бины» (beans) и POJO-классы (Plain Old Java Object).
Более того, многие разработчики даже не знают главных отличий между этими понятиями и время от времени используют их взаимозаменяемо. В этой статье мы рассмотрим, что такое бин и POJO класс, и какие основные отличия между ними.
Будем рассматривать контекст использования Java-приложений, где POJO — это простая модель данных, без специальных зависимостей и дополнительных требований, в то время, как бин — это сервисный класс, который может быть управляем и образовывать единую систему компонентов.
Понимание бина и POJO класса в программировании
Бин и его отличие от POJO класса
В программировании бин или JavaBean – это класс с определенными свойствами, методами доступа и операциями, которые позволяют управлять значениями свойств. Свойства бина могут иметь различные типы данных, такие как примитивы, объекты, массивы и другие. Бины могут использоваться для передачи данных между компонентами приложения или для сохранения этих данных в базе данных.
POJO (Plain Old Java Object) класс – это обычный Java-класс, который не имеет зависимостей от какой-либо конкретной библиотеки или фреймворка. POJO классы обычно не содержат аннотаций или XML-конфигураций, и их можно использовать в различных программах без изменений. POJO классы обычно используются для инкапсуляции данных и реализации бизнес-логики в приложениях.
Главное отличие между бином и POJO классом заключается в том, что бины имеют определенный набор свойств и методов, которые упрощают управление этими свойствами и их значениями. POJO классы же могут содержать любые методы и поля согласно потребностям программы без дополнительных ограничений. Таким образом, бины и POJO классы используются в различных контекстах в программных приложениях и имеют свои преимущества и ограничения в зависимости от конкретной задачи.
Определение
Что такое бин?
Бин (англ. bean) или JavaBean — это специальный класс на языке Java, который реализует определенный набор правил, позволяющих ему быть управляемым контейнером. Бины создаются и используются в различных технологиях Java, таких как Java EE, Spring, Hibernate и других.
Основным назначением бинов является хранение и обеспечение доступа к состоянию объектов и их поведению. Они позволяют изолировать код, упрощая модификацию и расширение программы, а также повышают ее гибкость и масштабируемость.
Как бин отличается от POJO класса?
POJO (англ. Plain Old Java Object) – это простой класс на языке Java, который не зависит от других фреймворков или технологий. Как правило, он не содержит дополнительных интерфейсов или аннотаций. Он может быть использован в любой технологии Java.
Основное отличие бина от POJO состоит в том, что бин реализует некоторые интерфейсы, которые могут быть использованы в различных технологиях. Кроме того, бин может содержать специальные аннотации, которые определяют его поведение в контейнере.
Таким образом, бин является объектом с дополнительными функциональными возможностями, которые были разработаны специально для работы с контейнерами.
Отличия по устройству
Бины и POJO классы отличаются по своей внутренней структуре и устройству. POJO классы представляют собой простые Java классы, не зависимые от каких-либо фреймворков и спецификаций. Они содержат простые поля класса, геттеры и сеттеры для доступа к этим полям, а также простые методы обработки данных.
Бины же, являются особыми Java классами, которые используются в контейнере IoC для управления зависимостями и жизненным циклом компонентов приложения. Для этого они должны реализовывать соответствующие интерфейсы и аннотации, такие как @Autowired, @Component, @Repository и другие.
Бины также могут использоваться для реализации сервисов, обработки данных, управления транзакциями и других функций, необходимых для работы приложения. Они могут быть созданы как вручную, так и автоматически при помощи спецификаций Spring, EJB и других.
Таким образом, отличия по устройству между бинами и POJO классами заключаются в том, что бины являются особыми Java классами, которые используются в контейнере IoC для управления зависимостями и жизненным циклом компонентов приложения, в то время как POJO классы являются простыми Java классами, которые не зависят от каких-либо фреймворков и спецификаций.
Отличия по функционалу
Одно из ключевых отличий между бином и POJO классом заключается в их функционале. POJO класс представляет собой простой, чистый Java объект, обычно используемый для хранения данных. Его главная задача — предоставлять геттеры и сеттеры для доступа к полям. Он не обладает каким-либо дополнительным функционалом.
С другой стороны, бин — это Java-объект, который поддерживает дополнительный функционал, такой как управление жизненным циклом, интеграция с другими сервисами и т.д. Бин может иметь аннотации и конфигурационные файлы для его настройки и управления.
Бин обычно используется в контексте Java-фреймворков, таких как Spring, для реализации инверсии контроля, управления транзакциями и других подобных функций. Его использование позволяет создавать более гибкие и масштабируемые приложения с более высокой степенью модульности.
Преимущества использования бина и POJO класса
Бин
Бин — это класс Java, который используется для хранения данных, предназначенных для передачи между компонентами приложения. Его главное преимущество заключается в том, что он создает объекты, которые могут быть управляемыми контейнером.
Бин-компонент имеет следующие достоинства:
- Он позволяет разделить уровень бизнес-логики и уровень презентации;
- Управляемый компонент может быть использован многократно в приложении, что повышает его эффективность и снижает затраты на разработку;
- Контейнер управляет жизненным циклом бина и обеспечивает все необходимые сервисы, такие как события, безопасность и транзакции.
POJO класс
POJO (Plain Old Java Object) — это Java-класс, который не использует какие-либо специфические для фреймворков API и библиотеки. Его основное преимущество заключается в простоте и гибкости. Он представляет простой объект Java со свойствами и методами, которые могут быть использованы любым приложением, без дополнительных настроек.
POJO класс имеет следующие достоинства:
- Он дает большую свободу в проектировании приложения;
- Он не зависит от каких-либо сторонних библиотек и фреймворков, что делает его более надежным и портируемым;
- Он является более простым для отладки и тестирования.
Примеры использования бинов
1. Хранение настроек приложения
Бины широко используются в веб-приложениях для хранения настроек. Например, можно создать бин, который содержит параметры подключения к базе данных и использовать его в различных частях приложения. Это позволяет с легкостью изменять параметры подключения без необходимости менять код приложения.
2. Взаимодействие с базами данных
Бины также используются для работы с базами данных. Например, можно создать бин, который содержит методы для получения и обновления данных в базе данных. Это позволяет разработчикам сосредоточиться на бизнес-логике приложения, а не на мелких деталях работы с базой данных.
3. Валидация форм на стороне сервера
Бины могут быть использованы для валидации данных, полученных от пользователя. Например, можно создать бин, который содержит методы для проверки правильности заполнения формы. Если данные заполнены неправильно, бин может сгенерировать сообщение об ошибке и вернуть его пользователю.
4. Создание RESTful API
Бины используются для создания RESTful API. Например, можно создать бин, который предоставляет интерфейс для создания, чтения, обновления и удаления данных. Это позволяет использовать RESTful API для взаимодействия с приложением из любого языка программирования или с помощью HTTP-запросов.
| Название | Тип | Описание |
|---|---|---|
| dataSource | javax.sql.DataSource | Источник данных, используемый при подключении к базе данных |
| getUsers() | List | Метод для получения списка пользователей из базы данных |
| updateUser(User user) | void | Метод для обновления данных пользователя в базе данных |
Использование бинов и POJO классов в фреймворках
Бины в Spring Framework
Spring Framework предоставляет инверсию контроля и управление зависимостями для приложений Java. Чтобы использовать фреймворк, нужно создать бины, которые являются объектами, которые будут управляться контейнером Spring. Бины используются для хранения и передачи данных между классами. Они отличаются от POJO классов тем, что обычно не содержат состояния и не имеют методов доступа.
Бины в JavaServer Faces
JavaServer Faces (JSF) является фреймворком для создания веб-приложений на языке Java. В JSF бины используются для управления состоянием веб-приложения. Бины JSF могут быть POJO классами с аннотациями.
Бины в Struts
Apache Struts — это фреймворк для создания MVC приложений на языке Java. Бины используются для связывания модели и представления. Контроллер Struts использует бины для управления данными. Бины в Struts могут быть POJO классами с аннотациями.
Пользовательские бины в AEM
Adobe Experience Manager (AEM) разработан для управления веб-сайтами и мобильными приложениями. В AEM пользовательские бины используются для создания классов, которые хранят информацию о контенте и могут быть использованы в веб-сайтах. Эти бины могут быть POJO классами с аннотациями.
Заключение
Бины и POJO классы являются важной частью фреймворков и могут использоваться для управления состоянием и передачи данных. Их основные отличия заключаются в том, что бины обычно не содержат состояния и не имеют методов доступа, а POJO классы могут содержать состояние и методы доступа. Но оба типа классов могут быть использованы в большинстве фреймворков.
Выбор подходящего класса под задачу
Что такое бин и POJO?
Бин — это Java класс, который реализует специальный интерфейс и имеет заданный жизненный цикл. Он часто используется в контейнерах управления бизнес-логикой. POJO — это обычный Java класс, который не имеет связей с каким-либо фреймворком или контейнером. Он может быть использован в различных архитектурных решениях и имеет свободный жизненный цикл.
Как выбрать подходящий класс?
Выбор между бином и POJO зависит от конкретной задачи и контекста ее использования. Если нужно использовать класс для бизнес-логики, то использование бина может быть удобным решением, так как это позволяет управлять его жизненным циклом и ресурсами. Однако, если нет необходимости в таком уровне управления, использование POJO класса может быть проще и более гибким в плане архитектуры и расширяемости.
Также, выбор может зависеть от текущей архитектуры приложения. Если уже используется контейнер управления бизнес-логикой, то использование бина может быть более естественным и привычным. Если же проект базируется на простой архитектуре и не использует контейнеры, использование POJO класса может быть более логичным решением.
В итоге, выбор между бином и POJO классом должен быть обоснован и зависеть от конкретных требований и контекста проекта.
Почему Entity — это POJO-класс?
Однако, на той же википедии написано, что Entity-класс может и наследоваться, и интерфейсы реализовывать, и аннотации использовать. Так вот, означает ли это, что Entity-класс должен быть POJO именно до его превращения в Entity? Или я чего-то не понимаю?
Отслеживать
задан 19 дек 2019 в 9:24
539 3 3 серебряных знака 14 14 бронзовых знаков
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
В этих определениях важно слово заранее заданные. В библиотеке Entity Java Beans сущности наследовались от класса EJBObject , что накладывало серьёзные ограничения на разработку.
Например, вы не могли просто взять готовую библиотеку классов, и подключить её к проекту. Чтобы сделать свои классы сущностями в смысле Entity Java Beans, вы должно были их переписать. Сами классы становились большими, потому что помимо своей основной задачи они переопределяли «нужные» методы из EJBObject .
POJO означает, что вы не должны наследоваться ни от какого специального базового класса наподобие EJBObject . Но конечно вы можете наследовать POJO-классы друг от друга так, как это диктует логика предметной области.