hibernate что это такое
Hibernate для начинающих
Я сталкивался (да и не только я) с проблемой развертывания Hibernate и решил попробовать осветить данную тему. Hibernate — это популярный framework, цель которого связать ООП и реляционную базу данных. Работа с Hibernate сократит время разработки проекта в сравнении с обычным jdbc.
Потом в pom.xml вставляем. Нам понадобятся две зависимости: hibernate-core и mysql-connector, но если вы хотите больше функционала — вы должны подключить больше зависимостей.
Существуют стандартные рекомендации подключать зависимости по отдельности, но я так не делаю.
И щелкаем на Import Changes Enable Auto-Import, автоматически импортируя изменения.
Подключаемся к базе данных, которая развернута на локальном компьютере, выбираем поставщика баз данных MySQL.
Вводим имя базы данных, имя пользователя и пароль. Протестируйте соединение.
Выбираем проект и через framework support просим у хибернейта создать за нас Entity файлы и классы с Getter и Setter.
Выбираем Generate Persistence Mapping через кладку Persistence, выбираем jenerate Persistance Mapping, а в появившемся окне прописываем схему базы данных, выбираем prefix и
sufix к автоматически сгенерированным названиям. Будут сгенерированы названия xml файлов и классов с аннотациями:
Дописываем в hibernate.cfg username и password (звёзды поставил я, а так пишите обычным шрифтом).
Вот и все! Дальше через класс main запускаем проект.
Это моя первая статья. Рассчитываю на здравую критику.
Основы Hibernate в Java
Hibernate – это объектно-реляционное картографическое решение с открытым исходным кодом на Java. Он легкий и устраняет все недостатки, с которыми мы сталкиваемся при работе с JDBC.
Что такое Hibernate в Java?
Hibernate – это фреймворк на Java, который поставляется с уровнем абстракции и обрабатывает реализации внутри. Реализации включают в себя такие задачи, как написание запроса для операций CRUD или установление соединения с базами данных и т. д.
Фреймворк – это в основном программное обеспечение, которое обеспечивает абстракцию для нескольких технологий, таких как JDBC, сервлет и т. д.
Hibernate разрабатывает логику сохранения, которая хранит и обрабатывает данные для более длительного использования. Это легкий инструмент ORM и, что самое важное, с открытым исходным кодом, что дает ему преимущество перед другими фреймворками.
Что такое инструмент ORM?
Это метод, который отображает объект, хранящийся в базе данных. Инструмент ORM упрощает создание данных, манипулирование ими и доступ к ним. Для взаимодействия с базами данных он внутренне использует Java API.
Давайте посмотрим на необходимость использования гибернации в Java.
Потребность в Hibernate Framework
Hibernate устраняет недостатки других технологий, таких как JDBC. Давайте посмотрим, как он оптимизирует задачи лучше, чем JDBC.
Hibernate предоставляет оптимальные и эффективные решения для любой задачи, преодолевая все недостатки JDBC. Давайте посмотрим на различные операции, а также на технологии и базы данных, с которыми мы можем работать.
Введение
Фреймворк с открытым исходным кодом доступен для всех бесплатно. Исходный код для гибернации можно найти в Интернете, что также позволяет вносить изменения.
В преимуществе легкости каркаса можно увидеть значительно меньший пакет для установки. Эффективность увеличивается, если для выполнения не используются никакие контейнеры. Хотя спящий режим может работать с несколькими технологиями одновременно, это не означает, что спящий режим не может работать в одиночку. Мы можем работать и с гибернацией в одиночку, т.е. без каких-либо технологий.
Hibernate имеет особую природу, в которой не требуется реализовывать интерфейсы API спящего режима или расширять классы API.
Функции, поддерживаемые Hibernate
Ниже приведены базы данных, поддерживаемые спящим режимом в Java.
Hibernate почти поддерживает все основные СУБД, что делает его эффективным и простым в работе.
Технологии, поддерживаемые Hibernate
Hibernate поддерживает множество технологий.
Давайте рассмотрим несколько преимуществ гибернации в java.
Hibernate в вопросах и ответах
1. Что такое Hibernate Framework?
Hibernate — это библиотека с открытым исходным кодом (open source) для Java, предназначенная для решения задач ORM (object-relational mapping, объектно-реляционного отображения). Она представляет собой свободное программное обеспечение, распространяемое на условиях GNU Lesser General Public License. Hibernate Framework имеет легкий в использовании каркас для отображения объектно-ориентированной модели данных в традиционные реляционные базы данных и предоставляет стандартные средства JPA.
2. Преимущества использования Hibernate Framework?
Библиотека Hibernate является одним из самых востребованных ORM фреймворков для Java, поскольку :
3. Объекты Hibernate SessionFactory, Session и Transaction
SessionFactory | Экземпляр SessionFactory создается методом buildSessionFactory (ServiceRegistry) объекта org.hibernate.Configuration и предназначен для получения объекта Session. Инициализируется SessionFactory один раз. Внутреннее состояние SessionFactory неизменно (immutable), т.е. он является потокобезопасным. Internal state (внутреннее состояние) включает в себя все метаданные об Object Relational Mapping, определяемые при создании SessionFactory. SessionFactory также предоставляет методы для получения метаданных класса и статистики, типа данных о втором уровне кэша, выполняемых запросах и т.д. |
Session | Однопоточный объект, устанавливающий связь между объектами/сущностями приложения и базой данных. Сессия создается при необходимости работы с БД и ее необходимо закрыть сразу же после использования. Экземпляр Session является интерфейсом между кодом в java приложении и hibernate framework, предоставляя методы для операций CRUD. |
Transaction | Однопоточный объект, используемый для атомарных операций. Это абстракция приложения от основных JDBC или JTA транзакций. org.hibernate.Session может занимать несколько org.hibernate.Transaction в определенных случаях. |
Пример использования объектов SessionFactory, Session, Transaction.
4. Конфигурационный файл Hibernate
Файл конфигурации hibernate.cfg.xml содержит информацию о базе данных (драйвер, пул подключений, диалект) и параметрах подключения к серверу БД (url, login, password). В качестве параметров подключения можно использовать как JDBC, так и JNDI. В файле конфигурации также определяются дополнительные параметры, которые будут использованы при работе с сервером БД, Так, здесь необходимо определить маппинги сущностей/классов.
Чтобы отобразить в консоли SQL-скрипты, генерируемые Hibernate, необходимо в hibernate.cfg.xml определить истиное значение свойства «show_sql». Помните, что это необходимо использовать только на уровне разработки и тестирования. В финальной версии свойство «show_sql» должно быть отключено.
Пример файла конфигурации связанных сущностей.
5. Файл mapping
6. Важные аннотации для отображения в Hibernate
Наиболее употребительные аннотации Hibernate из пакета javax.persistence представлены в следующей таблице :
@Entity | Определение класса как сущность entity bean |
@Table, @Column | Определение таблицы в БД и наименования колонки в таблице |
@Id | Поле Primary Key в сущности entity bean |
@GeneratedValue | Определение стратегии создания основных ключей |
@SequenceGenerator | Определение генератора последовательности |
@OneToMany, @ManyToOne, @ManyToMany | Определение связи между сущностными бинами |
Подробнее об аннотациях в сущностных бинах.
7. Отличие методов openSession и getCurrentSession
Методы openSession и getCurrentSession объекта SessionFactory возвращают сессию Session.
Метод getCurrentSession объекта SessionFactory возвращает сессию, связанную с контекстом. Но для того, чтобы метод вернул не NULL, необходимо настроить параметр current_session_context_class в конфигурационном файле hibernate. Поскольку полученный объект Session связан с контекстом hibernate, то отпадает необходимость в его закрытии; он закрывается вместе с закрытием SessionFactory.
Метод openSession объекта SessionFactory всегда создает новую сессию. В этом случае необходимо обязательно контролировать закрытие объекта сессии по завершению всех операций с базой данных. Для многопоточной среды необходимо создавать новый объект Session для каждого запроса.
При загрузке больших объемов данных без удержания большого количества информации в кэше можно использовать метод openStatelessSession(), который возвращает Session без поддержки состояния. Полученный объект не реализует первый уровень кэширования и не взаимодействует со вторым уровнем. Сюда же можно отнести игнорирование коллекций и некоторых обработчиков событий.
8. Отличие методов get и load объекта Session
Для загрузки информации из базы данных в виде набора/коллекции сущностей объект Session имеет несколько методов. Наиболее часто используемые методы get и load. Метод get загружает данные сразу же при вызове, в то время как load использует прокси объект и загружает данные только тогда, когда это требуется на самом деле (при обращении к данным). В этом плане load имеет преимущество в плане ленивой загрузки данных.
Метод load вызывает исключение, если данные не найдены. Поэтому load нужно использовать только при уверенности в существовании данных. Если необходимо удостовериться в наличии данных в БД, то нужно использовать метод get.
9. Различные состояния Entity Bean
Сущность Entity Bean может находиться в одном из трех состояний :
transient | Состояние сущности, при котором она не была связана с какой-либо сессией и не является persistent. Сущность может перейти в состояние persistent при вызове метода save(), persist() или saveOrUpdate() объекта сессии. |
persistent | Экземпляр сущности, полученный методами get() или load() объекта сессии, находится в состоянии persistent, т.е. связан с сессией. Из состояния persistent сущность можно перевести в transient после вызова метода delete() сессии. |
detached | Если объект находился в сотоянии persistent, но перестал быть связанным с какой-либо сессией, то он переходит в состояние detached. Такой объект можно сделать персистентным, используя методы update(), saveOrUpdate(), lock() или replicate(). |
Из состояний transient и detached объект можно перевести в состояние persistent в виде нового объекта после вызова метода merge().
10. Отличия методов save, saveOrUpdate и persist
Метод save используется для сохранения сущности в базе данных. Этот метод возвращает сгенерированный идентификатор. Возникаемые проблемы с использованием save связаны с тем, что метод может быть вызван без транзакции. А следовательно если имеется отображение нескольких связанных объектов, то только первичный объект будет сохранен, т.е. можно получить несогласованные данные.
Метод hibernate persist аналогичен save, но выполняется с транзакцией. Метод persist не возвращает сгенерированный идентификатор сразу.
Метод saveOrUpdate используется для вставки или обновления сущности. Если объект уже присутствуют в базе данных, то будет выполнен запрос обновления. Метод saveOrUpdate можно применять без транзакции, но это может привести к аналогичным проблемам, как и в случае с методом save.
11. Использование метода сессии merge
Метод Hibernate merge объекта сессии может быть использован для обновления существующих значений. Необходимо помнить, что данный метод создает и возвращает копию из переданного объекта сущности. Возвращаемый объект является частью контекста персистентности с отслеживанием любых изменений, а переданный объект не отслеживается.
12. Отсутствие в Entity Bean конструктора без параметров
Hibernate использует рефлексию для создания экземпляров Entity бинов при вызове методов get или load. Для этого используется метод Class.newInstance, который требует наличия конструктора без параметров. Поэтому, в случае его отсутствия, будет вызвано исключение HibernateException.
13. Entity Bean не должна быть final
Hibernate использует прокси классы для ленивой (lazy) загрузки данных (т.е. не сразу, а по необходимости). Это достигается с помощью расширения Entity Bean. Отсюда следует, что если бы он был final, то это было бы невозможно.
Ленивая загрузка данных во многих случаях повышает производительность, а следовательно важна и от нее не следует отказываться.
14. Сортировка данных в Hibernate
При использовании алгоритмов сортировки из Collection API используется сортированный список (sorted list). Для маленьких коллекций это не приводит к излишнему расходу ресурсов. Однако на больших коллекциях это может привести к потере производительности и ошибкам OutOfMemory.
Entity Bean’ы для работы с сортированными коллекциями должны реализовывать интерфейс Comparable/Comparator. При использовании фреймворка Hibernate для загрузки данных можно применить Collection API и команду order by для получения сортированного списка (ordered list). Ordered list является лучшим способом получения sorted list, т.к. используется сортировка на уровне базы данных, работающая быстрее и не приводящая к утечке памяти. Пример запроса к БД для получения ordered list :
Hibernate использует следующие типы коллекций : Bag, Set, List, Array, Map.
15. Использование Query Cache в Hibernate
Hibernate реализует область кэша для запросов ResultSet, который тесно взаимодействует с кэшем второго уровня Hibernate. Для подключения этой дополнительной функции необходимо определить истинное значение свойства hibernate.cache.use_query_cache в файле конфигурации hibernate.cfg.xml и в коде при обращении к БД использовать метод setCacheable(true). Кэшированные запросы полезны только при их частом исполнении с повторяющимися параметрами.
Определение свойства в файле конфигурации Hibernate :
Формирование запроса с использованием метода setCacheable (true) :
16. Язык запросов HQL
Hibernate включает мощный язык запросов HQL (Hibernate Query Language), который очень похож на родной SQL. В сравнении с SQL, HQL полностью объектно-ориентирован и использует понятия наследования, полиформизма и связывания.
HQL использует имя класса взамен имени таблицы, а также имя свойства вместо имени колонки. Пример HQL :
17. Нативный SQL-запрос в Hibernate
Для выполнения нативного запроса необходимо использовать SQLQuery, который может выполнять чистый SQL-запрос. Но необходимо учитывать, что в этом случае можно потерять все преимущества HQL (ассоциации, кэширование). Пример нативного SQL-запроса :
18. Преимущества поддержки нативного SQL-запроса
Использование нативного SQL может быть необходимо при выполнении некоторых запросов к базам данных, которые могут не поддерживаться в Hibernate. Т.е. включение в запросы специфичных для БД «фишек».
19. Именованный запрос, Named SQL Query
Hibernate поддерживает использование именованных запросов, которые можно определить в одном месте и использовать в любом месте в коде. Именованные запросы поддерживают как HQL, так и Native SQL. Для создания Named SQL Query можно использовать JPA аннотации @NamedQuery, @NamedNativeQuery или конфигурационный файл отображения (mapping files). Пример описания и использования Named SQL Query.
20. Преимущества именованных запросов Named SQL Query
Named Query имеют глобальный характер, т.е. заданные в одном месте, доступны в любом месте кода. Синтаксис Named Query проверяется при создании SessionFactory, что позволяет заметить ошибку на раннем этапе, а не при запущенном приложении и выполнении запроса.
Одним из основных недостатков именованного запроса является то, что его сложнее отлаживать. Сложности могут быть связаны с поиском места определения запроса. Поэтому не разбрасывайтесь описанием запросов в различных участках. Можно все связанные с сущностью запросы описать непосредственно в классе, используя аннотацию @NamedQueries, как это показано в следующем коде :
21. Использование org.hibernate.Criteria
Hibernate Criteria API представляет альтернативный подход HQL и позволяет выполнять запросы в БД без написания SQL кода. Для создания экземпляров Criteria используется класс Session. Пример Criteria с необязательным обрамлением в транзакцию :
Приведенный выше запрос вернет первые 10 записей из таблицы сущности User. Метод setMaxResults представляет собой аналог команды LIMIT в SQL-запросе. Чтобы прочитать определенное количество записей с с определенной позиции (LIMIT 2, 15) необходимо дополнительно использовать метод setFirstResult :
Подробнее о org.hibernate.Criteria можно прочитать здесь.
22. Hibernate proxy и ленивая загрузка (lazy load)
Hibernate может использовать прокси для поддержки отложенной загрузки. При соответствующем атрибут fetch аннотации связи (fetch определяет стратегию загрузки дочерних объектов) из базы данных не загружаются связанные объекты. При первом обращении к дочернему объекту с помощью метода get, если связанная сущность отсутствует в кэше сессии, то прокси код перейдет к базе данных для загрузки связанной сущности. Для этого используется javassist, чтобы эффективно и динамически создавать реализации подклассов Entity Bean объектов.
Подробнее об атрибуте загрузки связанных объектов fetch.
23. Каскадные связи
При наличии зависимостей (связей) между сущностями необходимо определить влияние различных операций одной сущности на связанные. Это можно реализовать с помощью аннотации каскадных связей @Cascade. Пример использования @Cascade :
Помните, что имеются некоторые различия между enum CascadeType в Hibernate и в JPA. Поэтому обращайте внимание на импортируемый пакет при использовании аннотации и константы типа. Наиболее часто используемые CascadeType перечисления описаны ниже :
24. Управление транзакциями
Hibernate не допускает большинство операций без использования транзакций. Для начала транзакции необходимо выполнить метод beginTransaction объекта сессии Session, возвращающий ссылку, которую можно использовать для подтверждения или отката транзакции.
Любое вызываемое в Hibernate исключение автоматически вызывает rollback.
Hibernate — Краткое руководство
JDBC предоставляет гибкую архитектуру для написания независимого от базы данных приложения, которое может работать на разных платформах и взаимодействовать с разными СУБД без каких-либо изменений.
Плюсы и минусы JDBC
Чистая и простая обработка SQL
Хорошая производительность с большими данными
Очень хорошо для небольших приложений
Простой синтаксис так легко выучить
Сложный, если он используется в крупных проектах
Большие накладные расходы на программирование
Трудно реализовать концепцию MVC
Запрос специфичен для СУБД
Чистая и простая обработка SQL
Хорошая производительность с большими данными
Очень хорошо для небольших приложений
Простой синтаксис так легко выучить
Сложный, если он используется в крупных проектах
Большие накладные расходы на программирование
Трудно реализовать концепцию MVC
Запрос специфичен для СУБД
Почему объектно-реляционное сопоставление (ORM)?
Когда мы работаем с объектно-ориентированной системой, существует несоответствие между объектной моделью и реляционной базой данных. СУБД представляют данные в табличном формате, тогда как объектно-ориентированные языки, такие как Java или C #, представляют их как взаимосвязанный граф объектов.
Рассмотрим следующий Java-класс с правильными конструкторами и связанной с ним публичной функцией —
Учтите, что вышеперечисленные объекты должны быть сохранены и извлечены в следующую таблицу RDBMS:
Первая проблема: что если нам нужно изменить дизайн нашей базы данных после разработки нескольких страниц или нашего приложения? Во-вторых, загрузка и хранение объектов в реляционной базе данных подвергает нас следующим пяти проблемам несоответствия:
Sr.No. | Несоответствие и описание | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 |
Sr.No. | преимущества |
---|---|
1 | Давайте бизнес-кодам обращаться к объектам, а не к таблицам БД. |
2 | Скрывает детали SQL-запросов от ОО-логики. |
3 | По материалам JDBC «под капотом». |
4 | Не нужно заниматься реализацией базы данных. |
5 | Объекты, основанные на бизнес-концепциях, а не на структуре базы данных. |
6 | Управление транзакциями и автоматическая генерация ключей. |
7 | Быстрая разработка приложения. |
Решение ORM состоит из следующих четырех объектов:
Sr.No. | Решения |
---|---|
1 | API для выполнения основных операций CRUD над объектами постоянных классов. |
2 | Язык или API для указания запросов, которые ссылаются на классы и свойства классов. |
3 | Настраиваемое средство для указания метаданных отображения. |
4 | Техника взаимодействия с транзакционными объектами для выполнения грязной проверки, отложенной выборки ассоциаций и других функций оптимизации. |
Java ORM Frameworks
В Java есть несколько постоянных сред и опций ORM. Постоянная структура — это служба ORM, которая сохраняет и извлекает объекты в реляционную базу данных.
Hibernate — Обзор
Hibernate — это решение O bject- R elational M (ORM) для JAVA. Это постоянный фреймворк с открытым исходным кодом, созданный Гэвином Кингом в 2001 году. Это мощный высокопроизводительный сервис объектно-реляционной персистентности и запросов для любого Java-приложения.
Hibernate отображает классы Java в таблицы базы данных и из типов данных Java в типы данных SQL и освобождает разработчика от 95% общих задач программирования, связанных с сохранением данных.
Hibernate находится между традиционными объектами Java и сервером базы данных и выполняет все действия по сохранению этих объектов на основе соответствующих механизмов и шаблонов O / R.
Преимущества гибернации
Hibernate занимается отображением классов Java в таблицы базы данных с использованием файлов XML и без написания какой-либо строки кода.
Предоставляет простые API-интерфейсы для хранения и извлечения объектов Java непосредственно в базу данных и из нее.
Если в базе данных или в любой таблице произошли изменения, вам нужно изменить только свойства XML-файла.
Абстрагирует незнакомые типы SQL и предоставляет способ работы со знакомыми объектами Java.
Hibernate не требует сервера приложений для работы.
Управляет сложными ассоциациями объектов вашей базы данных.
Минимизирует доступ к базе данных с помощью умных стратегий извлечения.
Обеспечивает простой запрос данных.
Hibernate занимается отображением классов Java в таблицы базы данных с использованием файлов XML и без написания какой-либо строки кода.
Предоставляет простые API-интерфейсы для хранения и извлечения объектов Java непосредственно в базу данных и из нее.
Если в базе данных или в любой таблице произошли изменения, вам нужно изменить только свойства XML-файла.
Абстрагирует незнакомые типы SQL и предоставляет способ работы со знакомыми объектами Java.
Hibernate не требует сервера приложений для работы.
Управляет сложными ассоциациями объектов вашей базы данных.
Минимизирует доступ к базе данных с помощью умных стратегий извлечения.
Обеспечивает простой запрос данных.
Поддерживаемые базы данных
Hibernate поддерживает практически все основные СУБД. Ниже приведен список нескольких ядер баз данных, поддерживаемых Hibernate.
Поддерживаемые технологии
Hibernate поддерживает множество других технологий, в том числе —
Hibernate — Архитектура
Hibernate имеет многоуровневую архитектуру, которая помогает пользователю работать без знания базовых API. Hibernate использует базу данных и данные конфигурации для предоставления приложениям постоянных сервисов (и постоянных объектов).
Ниже приводится очень высокий уровень представления архитектуры приложений Hibernate.
Ниже приведено подробное представление архитектуры приложений Hibernate с ее важными основными классами.
Hibernate использует различные существующие API Java, такие как JDBC, API транзакций Java (JTA) и интерфейс именования и каталогов Java (JNDI). JDBC обеспечивает элементарный уровень абстракции функциональности, общей для реляционных баз данных, что позволяет Hibernate поддерживать практически любую базу данных с драйвером JDBC. JNDI и JTA позволяют интегрировать Hibernate с серверами приложений J2EE.
В следующем разделе дается краткое описание каждого из объектов класса, участвующих в Hibernate Application Architecture.
Объект конфигурации
Объект конфигурации — это первый объект Hibernate, который вы создаете в любом приложении Hibernate. Обычно создается только один раз во время инициализации приложения. Он представляет файл конфигурации или свойств, требуемый Hibernate.
Объект конфигурации содержит два ключевых компонента:
Настройка отображения классов — этот компонент создает связь между классами Java и таблицами базы данных.
Настройка отображения классов — этот компонент создает связь между классами Java и таблицами базы данных.
SessionFactory Object
Объект конфигурации используется для создания объекта SessionFactory, который, в свою очередь, настраивает Hibernate для приложения, используя предоставленный файл конфигурации, и позволяет создавать экземпляр объекта Session. SessionFactory является потокобезопасным объектом и используется всеми потоками приложения.
SessionFactory — это тяжеловесный объект; обычно создается во время запуска приложения и сохраняется для последующего использования. Вам потребуется один объект SessionFactory для каждой базы данных с использованием отдельного файла конфигурации. Итак, если вы используете несколько баз данных, вам придется создать несколько объектов SessionFactory.
Объект сеанса
Сессия используется для получения физического соединения с базой данных. Объект Session является легким и предназначен для реализации каждый раз, когда необходимо взаимодействие с базой данных. Постоянные объекты сохраняются и извлекаются через объект Session.
Объекты сеанса не должны оставаться открытыми в течение длительного времени, потому что они обычно не являются потокобезопасными, и их следует создавать и уничтожать по мере необходимости.
Объект сделки
Транзакция представляет собой единицу работы с базой данных, и большинство СУБД поддерживает функциональность транзакций. Транзакции в Hibernate обрабатываются соответствующим менеджером транзакций и транзакциями (из JDBC или JTA).
Это необязательный объект, и приложения Hibernate могут не использовать этот интерфейс, а вместо этого управлять транзакциями в собственном коде приложения.
Объект запроса
Объекты запросов используют строку SQL или язык запросов Hibernate (HQL) для извлечения данных из базы данных и создания объектов. Экземпляр Query используется для привязки параметров запроса, ограничения количества результатов, возвращаемых запросом, и, наконец, для выполнения запроса.
Критерий Объект
Объекты критериев используются для создания и выполнения объектно-ориентированных запросов критериев для извлечения объектов.
Hibernate — Окружающая среда
Скачивание Hibernate
Предполагается, что в вашей системе уже установлена последняя версия Java. Ниже приведены простые шаги для загрузки и установки Hibernate в вашей системе:
На момент написания этого руководства я скачал hibernate-distribution3.6.4.Final, и когда вы распакуете загруженный файл, он даст вам структуру каталогов, как показано на следующем рисунке
На момент написания этого руководства я скачал hibernate-distribution3.6.4.Final, и когда вы распакуете загруженный файл, он даст вам структуру каталогов, как показано на следующем рисунке
Установка Hibernate
После того, как вы загрузили и разархивировали последнюю версию установочного файла Hibernate, вам необходимо выполнить два простых шага. Убедитесь, что вы устанавливаете переменную CLASSPATH правильно, иначе вы столкнетесь с проблемой при компиляции приложения.
Теперь скопируйте все файлы библиотеки из / lib в ваш CLASSPATH и измените переменную classpath, чтобы включить все JAR —
Наконец, скопируйте файл hibernate3.jar в свой CLASSPATH. Этот файл находится в корневом каталоге установки и является основным JAR, который необходим Hibernate для своей работы.
Теперь скопируйте все файлы библиотеки из / lib в ваш CLASSPATH и измените переменную classpath, чтобы включить все JAR —
Наконец, скопируйте файл hibernate3.jar в свой CLASSPATH. Этот файл находится в корневом каталоге установки и является основным JAR, который необходим Hibernate для своей работы.
Необходимые условия гибернации
Ниже приведен список пакетов / библиотек, необходимых для Hibernate, и вам следует установить их перед началом работы с Hibernate. Чтобы установить эти пакеты, вам нужно будет скопировать файлы библиотеки из / lib в ваш CLASSPATH и соответственно изменить переменную CLASSPATH.
Sr.No. | Пакеты / Библиотеки | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 |
Sr.No. | Свойства и описание | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 |
Sr.No. | Свойства и описание | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 |
Sr.No. | База данных и диалект собственности | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 |
Sr.No. | Методы и описание сессии | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 |
Тип отображения | Тип Java | Тип ANSI SQL |
---|---|---|
целое число | int или java.lang.Integer | INTEGER |
долго | длинный или java.lang.Long | BIGINT |
короткая | короткий или java.lang.Short | SMALLINT |
поплавок | плавать или java.lang.Float | FLOAT |
двойной | double или java.lang. Double | DOUBLE |
big_decimal | java.math.BigDecimal | NUMERIC |
персонаж | java.lang.String | СИМ (1) |
строка | java.lang.String | VARCHAR |
байт | байт или java.lang.Byte | TINYINT |
логический | логическое или java.lang. булево | НЕМНОГО |
да нет | логическое или java.lang. булево | CHAR (1) («Y» или «N») |
истина / ложь | логическое или java.lang. булево | CHAR (1) («T» или «F») |
Типы даты и времени
Тип отображения | Тип Java | Тип ANSI SQL |
---|---|---|
Дата | java.util.Date или java.sql.Date | ДАТА |
время | java.util.Date или java.sql.Time | ВРЕМЯ |
отметка времени | java.util.Date или java.sql.Timestamp | TIMESTAMP |
календарь | java.util.Calendar | TIMESTAMP |
calendar_date | java.util.Calendar | ДАТА |
Двоичные и крупные типы объектов
Тип отображения | Тип Java | Тип ANSI SQL |
---|---|---|
двоичный | байт[] | VARBINARY (или BLOB) |
текст | java.lang.String | CLOB |
сериализуемым | любой класс Java, который реализует java.io.Serializable | VARBINARY (или BLOB) |
CLOB | java.sql.Clob | CLOB |
капля | java.sql.Blob | большой двоичный объект |
JDK-связанные типы
Тип отображения | Тип Java | Тип ANSI SQL |
---|---|---|
учебный класс | java.lang.Class | VARCHAR |
место действия | java.util.Locale | VARCHAR |
часовой пояс | java.util.TimeZone | VARCHAR |
валюта | java.util.Currency | VARCHAR |
Hibernate — Примеры
Давайте теперь возьмем пример, чтобы понять, как мы можем использовать Hibernate для обеспечения персистентности Java в автономном приложении. Мы пройдем различные этапы создания приложения Java с использованием технологии Hibernate.
Создать классы POJO
Первым шагом в создании приложения является создание класса или классов Java POJO в зависимости от приложения, которое будет сохранено в базе данных. Давайте рассмотрим наш класс Employee с методами getXXX и setXXX, чтобы сделать его совместимым с JavaBeans классом.
POJO (обычный старый Java-объект) — это Java-объект, который не расширяет и не реализует некоторые специализированные классы и интерфейсы, требуемые инфраструктурой EJB соответственно. Все обычные объекты Java являются POJO.
Когда вы разрабатываете класс для сохранения в Hibernate, важно предоставить совместимый с JavaBeans код, а также один атрибут, который будет работать как индексный атрибут id в классе Employee.
Создать таблицы базы данных
Вторым шагом будет создание таблиц в вашей базе данных. Там будет одна таблица, соответствующая каждому объекту, вы готовы предоставить постоянство. Рассмотрим выше объекты должны быть сохранены и извлечены в следующую таблицу RDBMS —
Создать файл конфигурации сопоставления
На этом этапе создается файл сопоставления, который инструктирует Hibernate, как сопоставить определенный класс или классы с таблицами базы данных.
Элемент является необязательным и может использоваться для создания описания класса.
Элемент сопоставляет атрибут уникального идентификатора в классе с первичным ключом таблицы базы данных. Атрибут name элемента id ссылается на свойство в классе, а атрибут column ссылается на столбец в таблице базы данных. Атрибут type содержит тип отображения hibernate, при этом типы отображения преобразуются из Java в тип данных SQL.
Элемент в элементе id используется для автоматической генерации значений первичного ключа. Атрибут class элемента генератора установлен на native, чтобы позволить hibernate подобрать алгоритм идентификации, последовательности или hilo для создания первичного ключа в зависимости от возможностей базовой базы данных.
используется для сопоставления свойства класса Java со столбцом в таблице базы данных. Атрибут имени элемента ссылается на свойство в классе, а атрибут столбца ссылается на столбец в таблице базы данных. Атрибут type содержит тип отображения hibernate, при этом типы отображения преобразуются из Java в тип данных SQL.
Элемент является необязательным и может использоваться для создания описания класса.
Элемент сопоставляет атрибут уникального идентификатора в классе с первичным ключом таблицы базы данных. Атрибут name элемента id ссылается на свойство в классе, а атрибут column ссылается на столбец в таблице базы данных. Атрибут type содержит тип отображения hibernate, при этом типы отображения преобразуются из Java в тип данных SQL.
Элемент в элементе id используется для автоматической генерации значений первичного ключа. Атрибут class элемента генератора установлен на native, чтобы позволить hibernate подобрать алгоритм идентификации, последовательности или hilo для создания первичного ключа в зависимости от возможностей базовой базы данных.
используется для сопоставления свойства класса Java со столбцом в таблице базы данных. Атрибут имени элемента ссылается на свойство в классе, а атрибут столбца ссылается на столбец в таблице базы данных. Атрибут type содержит тип отображения hibernate, при этом типы отображения преобразуются из Java в тип данных SQL.
Доступны другие атрибуты и элементы, которые будут использоваться в документе сопоставления, и я постараюсь охватить как можно больше при обсуждении других тем, связанных с Hibernate.
Создать класс приложения
Наконец, мы создадим наш класс приложения с методом main () для запуска приложения. Мы будем использовать это приложение для сохранения нескольких записей сотрудника, а затем будем применять операции CRUD к этим записям.
Компиляция и выполнение
Вот шаги для компиляции и запуска вышеупомянутого приложения. Убедитесь, что вы правильно установили PATH и CLASSPATH, прежде чем приступить к компиляции и выполнению.
Создайте файл конфигурации hibernate.cfg.xml, как описано в главе о конфигурации.
Создайте файл сопоставления Employee.hbm.xml, как показано выше.
Создайте исходный файл Employee.java, как показано выше, и скомпилируйте его.
Создайте исходный файл ManageEmployee.java, как показано выше, и скомпилируйте его.
Выполните двоичный файл ManageEmployee, чтобы запустить программу.
Создайте файл конфигурации hibernate.cfg.xml, как описано в главе о конфигурации.
Создайте файл сопоставления Employee.hbm.xml, как показано выше.
Создайте исходный файл Employee.java, как показано выше, и скомпилируйте его.
Создайте исходный файл ManageEmployee.java, как показано выше, и скомпилируйте его.
Выполните двоичный файл ManageEmployee, чтобы запустить программу.
Вы получите следующий результат, и записи будут созданы в таблице EMPLOYEE.
Если вы проверите свою таблицу EMPLOYEE, она должна иметь следующие записи:
Hibernate — O / R Mappings
До сих пор мы видели очень простое отображение O / R, используя hibernate, но есть три наиболее важных темы отображения, которые мы должны изучить подробно.
Коллекции сопоставлений
Если у сущности или класса есть коллекция значений для определенной переменной, то мы можем отобразить эти значения, используя любой из интерфейсов коллекции, доступных в Java. Hibernate может сохранять экземпляры java.util.Map, java.util.Set, java.util.SortedMap, java.util.SortedSet, java.util.List и любой массив постоянных сущностей или значений.
Sr.No. | Тип коллекции и описание карт | ||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 | java.util.Set Это сопоставляется с элементом и инициализируется с помощью java.util.HashSet. Это отображается с помощью элемента и инициализируется с помощью java.util.TreeSet. Атрибут sort может быть установлен как в компараторе, так и в естественном порядке. Это отображается с помощью элемента или и инициализируется с помощью java.util.ArrayList Это сопоставляется с элементом и инициализируется с помощью java.util.HashMap. Это отображается с помощью элемента и инициализируется с помощью java.util.TreeMap. Атрибут sort может быть установлен как в компараторе, так и в естественном порядке. Это сопоставляется с элементом и инициализируется с помощью java.util.HashSet. Это отображается с помощью элемента и инициализируется с помощью java.util.TreeSet. Атрибут sort может быть установлен как в компараторе, так и в естественном порядке. Это отображается с помощью элемента или и инициализируется с помощью java.util.ArrayList Это сопоставляется с элементом и инициализируется с помощью java.util.HashMap. Это отображается с помощью элемента и инициализируется с помощью java.util.TreeMap. Атрибут sort может быть установлен как в компараторе, так и в естественном порядке. Hibernate поддерживает массивы с Если вы хотите отобразить пользовательские интерфейсы коллекций, которые напрямую не поддерживаются Hibernate, вам нужно сообщить Hibernate о семантике ваших пользовательских коллекций, что не очень просто и не рекомендуется использовать. Ассоциация сопоставленийОтображение ассоциаций между классами сущностей и взаимосвязями между таблицами — это душа ORM. Ниже приведены четыре способа, которыми можно выразить кардинальность отношений между объектами. Отображение ассоциации может быть как однонаправленным, так и двунаправленным.
|