ORM (Object-Relational Mapping, объектно-реляционное отображение) — технология программирования, которая связывает базы данных с концепциями объектно-ориентированных языков программирования. В объектно-ориентированном программировании объекты приложения представляют объекты реального мира. ORM предназначена для преобразования объектов в форму для их сохранения в файлах или базах данных, а также их дальнейшего извлечения в программе с сохранением свойств объектов и отношений между ними. Такие объекты называют «хранимыми» (persistent). ORM освобождает программиста от работы с SQL-скриптами и позволяет сосредоточиться на ООП.
Для сохранения Java-объектов в базе данных и чтения из БД следует использовать JPA. JPA (Java Persistence API) — программный интерфейс API, входящий с версии Java 5 в состав платформ Java SE и Java EE. Существует несколько реализаций интерфейса JPA, среди которых наиболее популярным является Hibernate.
Непосредственно JPA представлен в пакете javax.persistence и включает платформо-независимый объектно-ориентированный язык запросов JPQL.
JPA оперирует таким понятием, как сущность Entity, которая является POJO-классом и связана с БД с помощью аннотации @Entity или через файл конфигурации XML. К такому классу предъявляются следующие требования :
При этом сущность может иметь непустые конструкторы, наследоваться или быть наследованной, содержать методы, не связанные со свойствами (методы get/set), и реализовывать интерфейсы. Entities могут быть связаны друг с другом (один-к-одному, один-ко-многим, многие-к-одному и многие-ко-многим).
Примеры сущностей Entity
В самом простом виде (без методов определения и получения значения свойств) JPA сущности можно представить следующим образом :
При описании сущностей были использованы аннотации. Пример использования аннотаций при описании сущности представлено здесь.
Java Persistence Query Language (JPQL) — платформо-независимый объектно-ориентированный язык запросов являющийся частью спецификации JPA.
JPQL используется для написания запросов к сущностям, хранящимся в реляционной базе данных. JPQL во многом похож на SQL, но в отличие от последнего, оперирует запросами, составленными по отношению к сущностям JPA, в отличие от прямых запросов к таблицам базы данных. В дополнение к получению объектов (запросы SELECT), JPQL поддерживает запросы, основанные на операторах UPDATE и DELETE. JPA реализует концепцию ORM.
JPQL основан на Hibernate Query Language (HQL), более раннем не стандартизованном языке запросов, включённом в библиотеку объектно-реляционного отображения Hibernate. Hibernate и HQL были созданы до появления спецификации JPA. JPQL является подмножеством языка запросов HQL.
Примеры JPQL
JPQL запрос получения списка авторов сущности «Author», упорядоченных в алфавитном порядке, имеет вид :
Запрос получения списка авторов, когда-либо опубликованных издательством «Publisher Press» :
JPA Entities and DB Relationships
JPA Entities && DB Relationships
What is Entity?
What is DB Relationships?
Horror Example
One-to-One Relationship
Нужно подключить H2 DB к нашему проекту. Здесь нужно подчеркнуть то, что нам нужна Ultimate IDEA для комфортной работы с DB и другими вещами. Если она у вас уже есть тогда идем непосредственно к подключению DB. Заходим в tab Database и делаем как на скрине:
Далее переходим к настройкам DB. Вы можете ввести свои данные, и даже свою СУБД, повторюсь, H2 DB я использую для простоты.
Далее настроим схему. Этот шаг не обязателен но желателен, если у вас несколько схем в DB.
Применяем настройки, и в итоге у нас должно получиться что то вроде этого:
Базу данных мы создали, и настроили доступ к ней из IDEA. Теперь нужно создать таблички в ней и заполнить какими-то данными. Для примера я возьму две сущности: Author и Book. У книги может быть автор, может быть несколько авторов, а может и не быть. На этом примере мы создадим все виды связей. Но в данном пункте — One-to-One relationship. Создадим соответствующий скрипт, который создает DB Tables:
Результат выполнения в консоле:
Давайте посмотрим на диаграмму наших таблиц. Для этого ПКМ на нашу DB:
На UML диаграмме мы можем видеть все primary keys и foreign keys, также видим связь наших таблиц.
Напишем скрипт который заполняет нашу DB тестовыми данными:
То бишь, что получается? One-to-One relationship нужно тогда, когда сущность одной таблицы связанная с одной сущностью другой ( или вообще не связанная если NOT NULL убрать у BOOK_ID). В нашем примере у одной книжки ДОЛЖЕН быть один автор. Никак иначе.
Теперь самое интересное, как связать Java класс с DB сущностями? Очень просто. Создадим два класса Book и Author. На примере я разберу 1 класс, и ключевые поля связи. Возьму за пример Author класс:
Теперь настроим Hibernate. Для этого создадим hibernate.cfg.xml файл:
Теперь у нас сущность должна определиться. Можем это проверить в persistence tab’е:
Также нам нужно настроить assign data:
One-to-Many Relationship
В результате выполнения инициализирующего скрипта у нас получится следующее:
Чувствуете разницу с предыдущей таблицей?
One-to-Many Relationship — у нас у одного автора может быть несколько книг. Левой сущности соответствует одна или несколько правой.
Отличие в mapping’e будет в аннотациях и полях:
В Author класса появляется поле:
Оно уже является сетом, так как у нас может быть несколько книг. @OneToMany говорит о типе отношения. FetchType.Lazy говорит, что не нужно нам подгружать весь список книг если это не указанно в запросе. Также следует сказать, что данное поле НЕЛЬЗЯ добавлять в toString, иначе пойдем курить StackOverflowError. Об этом у меня заботится мой любимый Lombok:
В классе Book мы делаем обратную связь (Many-to-One):
Здесь мы делаем вывод, что One-to-Many является зеркальным отображением Many-to-One и наоборот. Следует подчеркнуть, что Hibernate нечего не знает о двунаправленных связях. Для него это две разные связи: одна в одну сторону, другая — в противоположную.
В hibernate.cfg.xml особо нечего не поменялось.
Many-to-One Relationship
В результате выполнения инициализирующего скрипта получим результат:
Отличие в mapping’e будет в аннотациях и полях:
В классе Author больше нет сета, так как он переместился в Book класс.
Many-to-Many Relationship
Посмотрите на инициализирующий скрипт, здесь появляется дополнительная таблица HAS. У нас получается что то вроде author-has-book.
В результате выполнения скрипта мы получим такие таблицы:
В нашем примере получается, что у книги может быть много автором, и у автора может быть много книг. Они могут пересекаться.
В классах mapping’a будут присутствовать сеты в классах. Но, как я уже сказал, таблица HAS — это не сущность.
@JoinTable — как раз таки и будет связывать атрибут с дополнительной таблицей HAS. В ней мы указываем два атрибута, которые будут указывать на primary keys двух сущностей.
Тут указываем FetchType и поле, по которому будем мапиться.
Entity (сущности) — зачем они нужны?
В ходе одного обучающего проекта наткнулся на необходимость использовать Entity (сущность). В данном случае, существует 3 класса, наследуемые друг от друга:
От него наследуется NamedEntity:
1 ответ 1
Решить каким образом использовать сущности и использовать ли их вообще поможет понимание следующей модели представления даннных.
Когда мы говорим о сущностях в абстрактном смысле мы всегда в том или ином виде подразумеваем использование какой-либо модели данных. В частности, в программировании применяется EER-модель (Enhanced Entity-Relationship model). Расширенная модель включает все концепции ER-модели (entity-relationship model) и дополнительно включает понятия подкласса, суперкласса и относящиеся к ним понятия специализации, обобщения и категоризации. Далее рассмотрим базовую ER-модель.
«Набор данных, обычно относящихся к какой-либо предметной области или тематической области, и структурированных таким образом, чтобы обеспечить установление отношений между отдельными элементами данных в соответствии с различными потребностями пользователей.» G. Knott & N. Waites, Computing 3rd edition
ER-модель, модель «сущность — связь»
Модель была предложена в в 70-х годах Питером Пин-Шэн Ченом (сайт, статья). Модель «сущность-связь» основывается на некой важной семантической информации о реальном мире и предназначена для логического представления данных. Она определяет значения данных в контексте их взаимосвязи с другими данными. Важным для нас является тот факт, что из модели «сущность-связь» могут быть порождены все существующие модели данных (иерархическая, сетевая, реляционная, объектная), поэтому она является наиболее общей.
Apache NetBeans 12.6
В этом документе содержится краткое описание некоторых возможностей, добавленных в спецификацию Java Enterprise Edition 6 (Java EE 6). В качестве иллюстрации новых возможностей в этом учебном курсе используется пример создания простого веб-приложения Java EE, содержащего фасад компонента сеанса без сохранения состояния EJB 3.1 для класса сущностей. Для создания класса сущностей и сеансного компонента в среде IDE используются мастеры. В созданном мастером коде используются запросы, определенные в интерфейсе Criteria API, который является частью JPA 2.x и входит в состав спецификации Java EE 6. Затем создается управляемый компонент с именем, имеющий доступ к фасаду сеанса и уровню представления, на котором используется инфраструктура вида Facelets, как указано в спецификации JSF 2.x.
Упражнения по темам руководства
Для работы с этим учебным курсом требуется следующее программное обеспечение и ресурсы.
Версия 7.2, 7.3, 7.4, 8.0, Java EE
GlassFish Server Open Source Edition 3.1.2.2
Предпосылки
Предполагается, что читатель обладает базовыми знаниями по следующим технологиям или опытом программирования с их использованием:
Программирование на Java
Создание проекта веб-приложения
В этом упражнении создается простое веб-приложение. При создании веб-приложения укажите в качестве целевого контейнера Java EE сервер GlassFish. Сервер GlassFish совместим с Java EE и включает в себя библиотеки JSF 2.x, необходимые для этого приложения.
В мастере создания проектов в качестве версии Java EE можно выбрать Java EE 6 Web или Java EE 7 Web. Java EE 6 Web и Java EE 7 Web являются упрощенными профилями Java EE 6, которые содержат подмножество полной платформы Java EE. Профили Java EE Web разработаны для веб-приложений, не требующих расширенных технологий Java EE, таких как поддержка удаленных интерфейсов, полная спецификация EJB 3.1 и API-интерфейс службы передачи сообщений Java (JMS).
Веб-профили поддерживают обработку транзакций и управление сохранением состояния, которые часто используются в корпоративных веб-приложениях. Профили Java EE Web можно использовать для веб-приложений, в которых применяются компоненты сеансов с локальным интерфейсом или без интерфейса. При использовании в приложении удаленного интерфейса необходим полный профиль Java EE.
Выберите ‘Файл’ > ‘Создать проект’ (Ctrl-Shift-N; ⌘-Shift-N в Mac) в главном меню.
Выберите «Веб-приложение» из категории «Java Web» и нажмите кнопку «Далее».
Введите SimpleEE6App в качестве имени проекта и укажите местоположение проекта.
Снимите флажок «Использовать отдельную папку», если он установлен. Нажмите кнопку «Далее». (В рамках этого руководства копирование библиотек проекта в отдельную папку нецелесообразно, поскольку совместное использование библиотек с другими пользователями или проектами не требуется.)
Выберите сервер GlassFish и укажите Java EE 6 или Java EE 7 в качестве версии Java EE. Нажмите кнопку «Далее».
Выберите в панели «Платформы» JavaServer Faces. Нажмите кнопку «Завершить».
По умолчанию при разработке веб-приложения Java EE, развертываемого на сервере GlassFish, в среде IDE будет выбрана библиотека JSF 2.x. Версия используемой по умолчанию библиотеки JSF зависит от версии, поставляемой в комплекте с сервером GlassFish. Библиотека JSF 2.x позволяет использовать Facelets в качестве языка страниц и обеспечивает поддержку JSF 1.2 и JSP.
Создание класса сущностей и фасада сеанса
В этом разделе будет создан класс сущностей и фасад сеанса для класса сущностей. Класс сущностей – это простой старый объект Java (Plain Old Java Object, POJO), простой класс Java, идентифицированный аннотацией @Entity как сущность. Начиная со спецификации Java EE 5 классы сущностей можно использовать в качестве объектов с сохраняемым состоянием для представления таблиц в базе данных. Интерфейс Java Persistence API позволяет использовать сохранение состояния в веб-приложениях без необходимости создания модуля EJB.
Фасад сеанса для класса сущностей в этом приложении является сеансным компонентом без сохранения состояния. Архитектура Enterprise JavaBean (EJB) 3.1, представленная как часть спецификации Java EE 6, позволяет создавать компоненты сеансов без бизнес-интерфейсов, которые требовались в EJB 3.0. Спецификация Java EE 6 также допускает упаковку компонентов EJB напрямую в архив WAR. Благодаря этому упрощается разработка небольших приложений за счет исключения необходимости создания отдельных модулей EJB, которые запаковываются как архив JAR в архив EAR. Однако для больших приложений J2EE, которые распределяются на разных машинах, остается необходимость в создании архивов EAR для отделения бизнес-логики от уровня представления.
Подробные сведения об использовании EJB 3.1 в среде IDE приведены в учебном курсе Создание приложения J2EE с помощью EJB 3.1.
Дополнительные сведения о компонентах сеансов см. в главе Что такое компонент сеанса? в Руководстве по Java EE 7.
Создание класса сущности
В этом упражнении с помощью мастера создания класса сущностей будет создан простой класс сущностей с сохраняемым состоянием. Также будет описан мастер создания блока сохранения состояния, которая определяет источник данных и диспетчер сущностей, используемые в приложении. Будет добавлено одно поле в класс для представления данных в таблице и созданы методы получения и установки для нового поля.
Класс сущностей должен иметь первичный ключ. При создании класса сущностей с помощью мастера в среде IDE по умолчанию создается поле id и создается аннотация @Id для объявления этого поля в качестве первичного ключа. Также в среде IDE добавляется аннотация @GeneratedValue и указывается стратегия создания ключей для первичного поля id.
Использование в проекте интерфейса Java Persistence значительно упрощает разработку приложения в силу отсутствия необходимости настройки дескрипторов развертывания для определения информации относительно объектно-реляционного сопоставления для сохраняющих состояние полей или свойств. Вместо этого можно использовать аннотации для определения этих свойства непосредственно в простом классе Java.
Сохранением состояния объекта управляет интерфейс API EntityManager. Интерфейс API EntityManager обрабатывает контекст сохранения состояния, а каждый контекст сохранения состояния представляет собой группу экземпляров объекта. При разработке приложения для обозначения экземпляра контекста с сохранением состояния для классов сущностей к классу можно добавить аннотации. В дальнейшем жизненный цикл экземпляров объекта управляется контейнером.
Для создания класса сущностей выполните следующие действия.
Щелкните узел проекта правой кнопкой мыши и выберите команду «Создать» > «Другие».
Выберите «Класс сущностей» в категории «Сохранение состояния». Нажмите кнопку «Далее».
В поле «Имя класса» введите Message.
В поле «Пакет» введите entities.
Выберите команду «Создать блок сохранения состояния». Нажмите кнопку «Далее».
Источник данных для jdbc/sample находится в составе пакета среды IDE при установке среды IDE и сервера приложений GlassFish. Однако можно указать другой источник данных, если это необходимо.
Можно сохранить другие параметры по умолчанию (имя блока сохранения состояния, поставщик сохранения состояния EclipseLink). Убедитесь в том, что для блока сохранения состояния используется интерфейс API транзакций Java и что для стратегии создания таблиц установлено значение «Создать», т. е. таблицы на основе классов сущностей создаются при развертывании приложения.
В мастере создания блока сохранения состояния нажмите кнопку «Завершить».
Щелкните правой кнопкой мыши в редакторе и выберите команду «Вставить код» (Alt-Insert; Ctrl-I для Mac), а затем «Получение и установка».
В диалоговом окне «Создание методов получения и установки» выберите поле message и нажмите кнопку «Создать».
Если проанализировать блок сохранения состояния в редакторе XML, можно увидеть, что в приложении используется интерфейс API транзакций Java (JTA) ( transaction-type=»JTA» ). Это указывает на то, что управление жизненным циклом сущностей в контексте сохранения состояния осуществляется контейнером. В результате требуется меньше строк кода, так как жизненный цикл сущностей управляется контейнером, а не приложением. Подробные сведения об использовании JTA для управления транзакциями приведены в документации по интерфейсу Java Transaction API.
Создание фасада сеанса
В этом упражнении будет использоваться мастер создания фасада сеанса без сохранения состояния для сущности Message. Согласно спецификации EJB 3.1. теперь бизнес-интерфейсы для сеансных компонентов не являются обязательными. В этом приложении, где клиент, имеющий доступ к компоненту, является локальным клиентом, для отображения компонента существует возможность использования представления с локальным интерфейсом или без интерфейса.
Для создания сеансного компонента выполните следующие шаги.
Щелкните узел проекта правой кнопкой мыши и выберите команду «Создать» > «Другие».
Выберите «Сеансные компоненты для сущностных классов» из категории Enterprise JavaBeans. Нажмите кнопку «Далее».
Выберите сущность Message и нажмите кнопку «Добавить». Нажмите кнопку «Далее».
В поле «Пакет» введите boundary. Нажмите кнопку «Завершить».
Обратите внимание на то, что создавать бизнес-интерфейс для сеансного компонента не требуется. Вместо этого в данном приложении компонент будет отображаться для локально управляемого компонента в представлении без интерфейса.
При создании фасада для сущности с помощью мастера в среде IDE по умолчанию добавляется аннотация PersistenceContext ( @PersistenceContext(unitName = «SimpleEE6AppPU») ) для внедрения ресурса диспетчера сущностей в элемент сеансного компонента и для определения имени блока сохранения состояния. В этом примере имя блока сохранения состояния объявлено явно, но имя не является обязательным, если в приложении используется только один блок сохранения состояния.
Создание управляемого компонента JSF и страниц JSF
Подробные сведения о поддержке спецификации JavaServer Faces 2.x в среде IDE см. в разделе Поддержка JSF 2.x в IDE NetBeans.
Подробные сведения о спецификации JavaServer Faces 2.x см. в главе Технология JavaServer Faces учебного курса по Java EE 7.
Создание управляемого компонента
В этом упражнении будет создан простой управляемый компонент JSF, используемый для получения доступа к фасаду сеанса. Спецификация JSF 2.x позволяет использовать аннотации в классе компонента для определения класса как управляемого компонента JSF, а также указания области и имени компонента.
Для создания управляемого компонента выполните следующие шаги.
Щелкните узел проекта правой кнопкой мыши и выберите команду «Создать» > «Другие».
Выберите «Управляемый компонент JSF» из категории «JavaServer Faces». Нажмите кнопку «Далее».
В поле «Имя класса» введите MessageView.
Имя управляемого компонента MessageView используется в качестве значения для inputText и commandButton на странице JSF index.xhtml при вызове методов в компоненте.
В поле «Пакет» введите my.presentation.
В поле «Имя», используемое для управляемого компонента, введите MessageView.
Установите контекст для запроса. Нажмите кнопку «Завершить».
При нажатии кнопки «Готово» в среде IDE создается класс компонента, который затем открывается в редакторе. В окне ‘Проекты’ отобразятся следующие файлы.
В редакторе можно увидеть, что в среде IDE добавлены аннотации @ManagedBean и @RequestScoped и имя компонента.
Щелкните правой кнопкой мыши в редакторе и выберите команду «Вставить код» (Alt-Insert; Ctrl-I для Mac), затем во всплывающем окне выберите «Вызов компонента EJB».
В диалоговом окне «Вызов компонента EJB» выберите MessageFacade. Нажмите кнопку «ОК».
При нажатии кнопки «ОК» в среде IDE добавляется следующий код (выделено полужирным шрифтом) для ввода компонента.
Для создания нового экземпляра добавьте следующий код.
Добавьте следующий код к классу.
Щелкните правой кнопкой мыши в области редактора и выберите команду ‘Исправить операторы импорта’ (Alt-Shift-I; ⌘-Shift-I в Mac) и сохраните изменения.
Можно использовать автозавершение кода в редакторе, упрощающее ввод кода.
Изменение страницы-указателя
В этом упражнении будет выполнено несколько простых изменений страницы index.xhtml для добавления компонентов пользовательского интерфейса. Выполняется добавление формы с текстовым полем для ввода и кнопкой.
Автозавершение кода JSF может помочь при вводе кода.
Создание страницы результатов
Щелкните узел проекта правой кнопкой мыши и выберите команду «Создать» > «Другие».
В категории «JavaServer Faces» выберите «Страница JSF». Нажмите кнопку «Далее».
В поле «Имя файла» введите theend.
Убедитесь в том, что флажок «Facelets» установлен. Нажмите кнопку «Завершить».
Когда вы начинаете вводить данные, среда IDE автоматически добавляет определение библиотеки тегов xmlns:h=»http://xmlns.jcp.org/jsf/html» в файл для элементов JSF.
Запуск приложения
Кодировка приложения завершена. Теперь можно протестировать приложение в браузере.
Щелкните правой кнопкой мыши узел проекта в окне «Проекты» и выберите «Выполнить».
Введите сообщение в текстовое поле. Нажмите кнопку «Отправить сообщение».
При нажатии кнопки «Отправить сообщение» сообщение сохраняется в базе данных, и извлекается и отображается число сообщений
Загрузка проекта решения
Простые проекты, используемые в этом руководстве, можно загрузить следующими способами.
Выполните проверку исходных файлов проекта на выходе из примеров NetBeans, выполнив перечисленные ниже действия.
Выберите в главном меню «Группа > Subversion > Проверить».
В диалоговом окне «Проверка» введите следующий URL-адрес репозитория: https://svn.netbeans.org/svn/samples
Нажмите кнопку Browse («Обзор») для открытия диалогового окна Browse Repository Folders («Обзор папок репозитория»).
Разверните корневой узел и выберите samples/javaee/SimpleEE6App. Нажмите кнопку «ОК».
Укажите локальную папку для исходных файлов (папка должна быть пустой).
Нажмите кнопку «Завершить».
После нажатия кнопки «Готово» среда IDE инициализирует локальную папку в качестве репозитория Subversion и выполняет проверку исходных файлов проекта на выходе.
Щелкните команду «Открыть проект» в диалоговом окне, которое появится после завершения проверки.
Примечания.
Для получения исходных файлов на редактирование требуется клиент Subversion. For more about installing Subversion, see the section on Setting up Subversion in the Guide to Subversion in IDE NetBeans.
Дополнительные сведения
For more information about using IDE NetBeans to develop Java EE applications, see the following resources:
Подробные сведения об использовании технологий Java EE для развертывания приложений см. в Учебном курсе по Java EE 7.
To send comments and suggestions, get support, and keep informed on the latest developments on the IDE NetBeans Java EE development features, join the nbj2ee mailing list.
