Что такое criteria api
Обзор Hibernate Criteria API
Одним из способов манипулирования объектом и транслирования его в таблицу базы данных (БД) является Criteria API, который позволяет создавать запросы с критериями программным методом. Наиболее значимые области применения Criteria API :
Для создания объекта org.hibernate.Criteria используется метод createCriteria интерфейса сессии Session, которому в качестве параметра необходимо передать сущность. Следующий код формирует объект Criteria для выполнения транзакций с сущностью разработчика Developer.
Чтение данных
Следующий код позволяет прочитать данные и сформировать коллекцию. Чтобы прочитать определенное количество записей необходимо использовать метод setMaxResults (int) объекта Criteria. Метод setFirstResult (int) определяет первую запись. Т.е. данные методы позволяют определить параметры OFFSET, LIMIT, используемые в SQL-запросах некоторых типов БД.
Сортировка данных в запросе Criteria
Для сортировки данных в запросе используется метод addOrder, которому в качестве параметра необходимо передать порядок сортировки (Order) :
Ограничения данных в запросе Criteria
Для ограничения/фильтрации объектов набора используется параметр Restrictions.[eq | lt | le | gt | ge | like | between | isNotNull | isNull]. Следующий код демонстрирует использование в критерии параметра Restrictions.
Пример использования org.hibernate.Criteria
Рассмотрим пример использования org.hibernate.Criteria и сущности Developer. В примере создадим и запишем новые сущности в базу данных, после чего извлечем определенные записи. При описании сущности будем использовать аннотации. По сути, это модифицированный пример использования Sequence для генерирования идентификаторов записей в Hibernate, описанный здесь. Поэтому ниже будут представлены только используемые методы, связанные с org.hibernate.Criteria. Сначала определим объекты базы данных.
Таблица и генератор запросов
В примере потребуется таблица DEVELOPERS и генератор последовательностей SEQ_DEVELOPER в схеме SCOTT.
Листинг сущности Developer
При описании сущности (методы set/get не отображены) используем аннотации. Подробнее об аннотациях, используемых при описании сущности, представлено здесь.
Сохранение новых записей в БД
Для сохранения записей в таблице БД определяем массив DEVELOPERS и два метода. Первый метод addDevelopers в цикле перебирает массив данных и вызывает второй метод addDeveloper, который формирует объект Developer и сохраняет его в БД.
При выполнении метода addDevelopers в консоль приложения будет выведена информация, представленная ниже. Hibernate подготавливает один запрос получения идентификатора записи и для каждой записи отдельный SQL-запрос вставки.
Фильтрация записей
Метод listDevelopers позволяет прочитать записи разработчиков, у которых опыт работы превышает значение min_experience. В методе формируется объект criteria, которому добавляется условие (ограничение Restrictions) с параметром «experience» и значением min_experience.
В результате выполнения метода listDevelopers в консоль будет выведена информация, представляющая сформированный hibernate запрос и прочитанные данные для значение min_experience равное 5 :
Выполнение функции суммирования
Как было описано выше Criteria можно использовать для выполнения агрегированных функций. Следующий метод totalSalary позволяет просуммировать заработок всех разработчиков. Для этого используется метод setProjection критерия, параметр которого определяет агрегированную функцию. Метод list вернет набор из одной записи, значение которой определяет результат выполненной функции.
Выполнение метода выведет следующую информацию в консоль : SQL-запрос суммирования значения поля salary и значение :
Делаем динамический отчет средствами JPA Criteria.Api
Очень часто в корпоративной разработке происходит диалог:
В данной статье мы рассмотрим, каким образом можно сделать запросы по таблице с изменяющимся списком критериев в среде Spring+JPA/Hibernate без прикручивания дополнительных библиотек.
Основных вопросов всего два:
Specification – итоговые ограничения запроса, содержит объекты Predicate как условия WHERE, HAVING. Предикаты – конечные выражения, которые могут принимать значения true или false.
Одиночное условие состоит из поля, оператора сравнения и значения для сравнения. Также условия могут быть вложенными. Опишем полностью условие классом SearchCriteria:
Теперь опишем сам построитель. Он будет уметь строить спецификацию на основании поданного списка условий, а также объединять несколько спецификаций определенным образом:
Теперь осталось реализовать рекурсивный разбор нашей структуры SearchCriteria. Отмечу, метод buildPath, который по Root – области определения объекта T будет находить путь к полю, на которое ссылается SearchCriteria.key:
Напишем тестовый кейс для нашего построителя:
Итого, мы научили наше приложение разбирать логическое выражение, используя Criteria.API. Набор операций в текущей реализации ограничен, но читатель может самостоятельно реализовать нужные ему. На практике решение применено, но пользователям не интересно(у них лапки) строить выражение глубже первого уровня рекурсии.
ДИСКЛЭЙМЕР обработчик не претендует на полную универсальность, при необходимости добавлять усложненные JOIN-ы придется лезть в реализацию.
Реализованную версию с расширенными тестами вы можете найти в моем репозитории на Github
JPA Criteria
JPQL запросы штука весьма удобная, почти такая же, как и SQL, только с классами и атрибутами. Но, как и у всякой удобной вещи, у неё есть недостатки, даже два:
Хорошая новость — в JPA есть механизм, который решает обе эти проблемы.
Criteria API и программно создаваемые запросы.
Примером запросов, создаваемых программно, может служить любой фильтр в любом приложении, который позволяет фильтровать данные по нескольким полям. Если рассматривать модель данных из примера с отношениями между сущностями, то можно представить себе фильтр людей по:
Причём фильтроваться люди могут по любой комбинации этих полей, например по адресу проживания и месту работы или по имени и адресу проживания. В терминах JPQL и SQL выразить такой запрос невозможно, потому что нет оператора «выбрать, у которых поле равно такому-то значению или игнорировать условие, если значение не установлено».
Вариантов реализации такого фильтра несколько. Можно сделать 16 различных запросов и в зависимости от того, какие значения фильтра установлены, выбирать подходящий запрос. Я даже не буду объяснять, почему это плохое решение и почему так делать никогда нельзя 😉
Можно собирать запрос из составляющих, пользуясь тем, что запрос это строка. Недостатков у этого подхода тоже много: абсолютно нечитаемый код запроса в итоге, высокая вероятность составить кривой запрос, сложность поддержания генератора запроса в актуальном состоянии и т.д.
Наконец третий и наиболее правильный вариант, это использование программно определяемых запросов и JPA Criteria API.
Начну с простого: загрузка всех сущностей заданного класса:
Hibernate — примеры Criteria. Обзор Hibernate Criteria API
Hibernate — примеры установки критериев (ограничений) Criteria. Сравнение с HQL
Hibernate Criteria API является альтернативным подходом к Hibernate Query Language (HQL). Этот подход более объектно-ориентирован и позволяет сократить необходимый код. Может быть рекомендован в проектах с большим количеством запросов с критериями.
Используемые технологии:
1. Описание задачи
Рассмотреть основы Hibernate Criteria и сравнить код с аналогом на HQL.
Будем делать следующую выборку — из таблицы с контактами вытаскиваем только те значения, у которых дата младше (новее) чем год назад.
2. Структура проекта
Используется база данных и классы из Hibernate – быстрый старт. Пример приложения Hello World. Там же есть исходники. Рекомендую прочитать эту статью, чтобы было понятно что и откуда берется_вставляется. Для наглядности приведу пример данных и таблицу, используемую в этой статье:
3. Пример кода HQL
Рассмотрим вначале как выглядит код выборки из базы данных с установленными ограничениями в стиле HQL (примеры HQL: select, insert, delete, update).
Создаем запрос, который звучит как: вытащить все данные из ContactEntity где дата соответствует промежутку startDate — endDate и отсортировать результат по дате.
4. Пример с использованием Criteria
Приведу распространенный, но уже устаревший вариант создания ограничений:
Смысл и результат такие же как в предыдущем пункте.
Важно
Criteria API
Простой запрос Criteria
Создать объект criteria и возвратить все записи ContactEntity из базы данных
Сортировка в запросе Criteria
Отсортировать результаты по возрастанию firstName :
Отсортировать результаты по убыванию firstName :
Запросы с ограничениями Criteria
Restrictions. eq; lt; le; gt; ge
Значение value равно 400:
Значение value меньше 400:
Значение value меньше или равно 400:
Значение value больше 400:
Значение value больше или равно 400:
Restriction.like
Значение firstName начинается с Name и дальше любые символы:
Restriction.between
Значение birth_date находится между датами:
Restriction.isNull, isNotNull
Значение birth_date — null :
Значение birth_date — не null :
Разделение результатов запроса Criteria
Начать с 20 записи и возвратить 15 следующих записей из базы данных:
Использовать или нет Criteria?
Как уже было сказано в замечании выше — в таком виде как в этой статье, нежелательно. Необходимо использовать стандарт JPA. Тем не менее кода, использующего этот подход очень много и он еще долго будет поддерживаться.
Также следует учесть, что вы не имеете никакого контроля над запросом, генерируемым Hibernate. Соответственно если важна производительность, то возможно следует рассмотреть другой подход.
Ещё одним минусом является сам текст запроса — в случае ошибки будет сложно отлавливать какой из запросов написан неверно. В случае именованных запросов всё будет замапино на объекты Java и увидеть исключение гораздо проще.
Вывод: использовать или нет Criteria нужно принимать исходя из потребностей проекта.
Ссылки для скачивания
hibernateCriteria — sql дамп для MySQL вместе с таблицами и данными
Hibernate Criteria — проект в IntelliJ IDEA
One thought on “ Hibernate — примеры Criteria. Обзор Hibernate Criteria API ”
Обратите внимание, что Expression — уже @Deprecated. Но, что более важно в версии Hibernate, которая используется в этой статье и Restrictions тоже уходит в прошлое. Jboss.org указывает, что org.hibernate.Criteria API должно считаться устаревшим, а вместо этого необходимо использовать спецификацию JPA и javax.persistence.criteria.CriteriaQuery. JPA будет описываться в отдельной статье
С нетерпением жду)) У вас рассылка на почту приходит о новых статьях?
Добавить комментарий Отменить ответ
Для отправки комментария вам необходимо авторизоваться.
Шпаргалка Java программиста 1: JPA и Hibernate в вопросах и ответах
Знаете ли вы JPA? А Hibernate? А если проверить?
За время работы Java программистом я заметил, что как правило программисты постоянно и планомерно используют от силы 10-20% от возможностей той или иной технологии, при этом остальные возможности быстро забываются и при появлении новых требований, переходе на новую работу или подготовке к техническому интервью приходится перечитывать все документации и спецификации с нуля. Зато наличие краткого конспекта особенностей тех или иных технологий (шпаргалок) позволяет быстро освежить в памяти особенности той или иной технологии.
Данная статья будет полезна и для тех кто только собирается изучать JPA и Hibernate (В этом случае рекомендую сразу открывать ответы), и для тех кто уже хорошо знает JPA и Hibernate (В этом случае статья позволит проверить свои знания и освежить особенности технологий). Особенно статья будет полезна тем кто собирается пройти техническое интервью, где возможно будут задавать вопросы по JPA и Hibernate (или сам собирается провести техническое интервью).
Рекомендую так считать правильные ответы: если вы ответили на вопрос по вашему мнению правильно и полностью — поставьте себе 1 балл, если ответили только частично — 0.5 балл. Везде где только возможно я старался добавлять цитаты из оригинальной документации (но из-за ограничений лицензии Oracle не могу давать слишком большие цитаты из документации).
Общие вопросы
JPA (Java Persistence API) это спецификация Java EE и Java SE, описывающая систему управления сохранением java объектов в таблицы реляционных баз данных в удобном виде. Сама Java не содержит реализации JPA, однако есть существует много реализаций данной спецификации от разных компаний (открытых и нет). Это не единственный способ сохранения java объектов в базы данных (ORM систем), но один из самых популярных в Java мире.
Entity это легковесный хранимый объект бизнес логики (persistent domain object). Основная программная сущность это entity класс, который так же может использовать дополнительные классы, который могут использоваться как вспомогательные классы или для сохранения состояния еntity.
И это тоже допустимо
Может, при этом он сохраняет все свойства Entity, за исключением того что его нельзя непосредственно инициализировать.
1) Entity класс должен быть отмечен аннотацией Entity или описан в XML файле конфигурации JPA,
2) Entity класс должен содержать public или protected конструктор без аргументов (он также может иметь конструкторы с аргументами),
3) Entity класс должен быть классом верхнего уровня (top-level class),
4) Entity класс не может быть enum или интерфейсом,
5) Entity класс не может быть финальным классом (final class),
6) Entity класс не может содержать финальные поля или методы, если они участвуют в маппинге (persistent final methods or persistent final instance variables),
7) Если объект Entity класса будет передаваться по значению как отдельный объект (detached object), например через удаленный интерфейс (through a remote interface), он так же должен реализовывать Serializable интерфейс,
8) Поля Entity класс должны быть напрямую доступны только методам самого Entity класса и не должны быть напрямую доступны другим классам, использующим этот Entity. Такие классы должны обращаться только к методам (getter/setter методам или другим методам бизнес-логики в Entity классе),
9) Enity класс должен содержать первичный ключ, то есть атрибут или группу атрибутов которые уникально определяют запись этого Enity класса в базе данных,
JPA указывает что она может работать как с свойствами классов (property), оформленные в стиле JavaBeans, либо с полями (field), то есть переменными класса (instance variables). Соответственно, при этом тип доступа будет либо property access или field access.
JPA указывает что она может работать как с свойствами классов (property), оформленные в стиле JavaBeans, либо с полями (field), то есть переменными класса (instance variables). Оба типа элементов Entity класса называются атрибутами Entity класса.
Допустимые типы атрибутов у Entity классов:
1. примитивные типы и их обертки Java,
2. строки,
3. любые сериализуемые типы Java (реализующие Serializable интерфейс),
4. enums;
5. entity types;
6. embeddable классы
7. и коллекции типов 1-6
Допустимые типы атрибутов, входящих в первичный ключ:
1. примитивные типы и их обертки Java,
2. строки,
3. BigDecimal и BigInteger,
4. java.util.Date и java.sql.Date,
В случае автогенерируемого первичного ключа (generated primary keys) допустимы
1. только числовые типы,
В случае использования других типов данных в первичном ключе, он может работать только для некоторых баз данных, т.е. становится не переносимым (not portable),
Сложные структуры JPA
Встраиваемый (Embeddable) класс это класс который не используется сам по себе, только как часть одного или нескольких Entity классов. Entity класс могут содержать как одиночные встраиваемые классы, так и коллекции таких классов. Также такие классы могут быть использованы как ключи или значения map. Во время выполнения каждый встраиваемый класс принадлежит только одному объекту Entity класса и не может быть использован для передачи данных между объектами Entity классов (то есть такой класс не является общей структурой данных для разных объектов). В целом, такой класс служит для того чтобы выносить определение общих атрибутов для нескольких Entity, можно считать что JPA просто встраивает в Entity вместо объекта такого класса те атрибуты, которые он содержит.
Может, но только в случае если такой класс не используется как первичный ключ или ключ map’ы.
1. Такие классы должны удовлетворять тем же правилам что Entity классы, за исключением того что они не обязаны содержать первичный ключ и быть отмечены аннотацией Entity (см. вопрос 10),
2. Embeddable класс должен быть отмечен аннотацией Embeddable или описан в XML файле конфигурации JPA,
Существуют следующие четыре типа связей
1. OneToOne (связь один к одному, то есть один объект Entity может связан не больше чем с один объектом другого Entity ),
2. OneToMany (связь один ко многим, один объект Entity может быть связан с целой коллекцией других Entity),
3. ManyToOne (связь многие к одному, обратная связь для OneToMany),
4. ManyToMany (связь многие ко многим)
Каждую из которых можно разделить ещё на два вида:
1. Bidirectional
2. Unidirectional
Bidirectional — ссылка на связь устанавливается у всех Entity, то есть в случае OneToOne A-B в Entity A есть ссылка на Entity B, в Entity B есть ссылка на Entity A, Entity A считается владельцем этой связи (это важно для случаев каскадного удаления данных, тогда при удалении A также будет удалено B, но не наоборот).
Undirectional- ссылка на связь устанавливается только с одной стороны, то есть в случае OneToOne A-B только у Entity A будет ссылка на Entity B, у Entity B ссылки на A не будет.
Mapped Superclass это класс от которого наследуются Entity, он может содержать анотации JPA, однако сам такой класс не является Entity, ему не обязательно выполнять все требования установленные для Entity (например, он может не содержать первичного ключа). Такой класс не может использоваться в операциях EntityManager или Query. Такой класс должен быть отмечен аннотацией MappedSuperclass или соответственно описан в xml файле.
Example: Concrete class as a mapped superclass
В JPA описаны три стратегии наследования мапинга (Inheritance Mapping Strategies), то есть как JPA будет работать с классами-наследниками Entity:
1) одна таблица на всю иерархию наследования (a single table per class hierarchy) — все enity, со всеми наследниками записываются в одну таблицу, для идентификации типа entity определяется специальная колонка “discriminator column”. Например, если есть entity Animals c классами-потомками Cats и Dogs, при такой стратегии все entity записываются в таблицу Animals, но при это имеют дополнительную колонку animalType в которую соответственно пишется значение «cat» или «dog». Минусом является то что в общей таблице, будут созданы все поля уникальные для каждого из классов-потомков, которые будет пусты для всех других классов-потомков. Например, в таблице animals окажется и скорость лазанья по дереву от cats и может ли пес приносить тапки от dogs, которые будут всегда иметь null для dog и cat соотвественно.
2) объединяющая стратегия (joined subclass strategy) — в этой стратегии каждый класс enity сохраняет данные в свою таблицу, но только уникальные колонки (не унаследованные от классов-предков) и первичный ключ, а все унаследованные колонки записываются в таблицы класса-предка, дополнительно устанавливается связь (relationships) между этими таблицами, например в случае классов Animals (см.выше), будут три таблицы animals, cats, dogs, причем в cats будет записана только ключ и скорость лазанья, в dogs — ключ и умеет ли пес приносить палку, а в animals все остальные данные cats и dogs c ссылкой на соответствующие таблицы. Минусом тут являются потери производительности от объединения таблиц (join) для любых операций.
3) одна таблица для каждого класса (table per concrete class strategy) — тут все просто каждый отдельный класс-наследник имеет свою таблицу, т.е. для cats и dogs (см.выше) все данные будут записываться просто в таблицы cats и dogs как если бы они вообще не имели общего суперкласса. Минусом является плохая поддержка полиморфизма (polymorphic relationships) и то что для выборки всех классов иерархии потребуются большое количество отдельных sql запросов или использование UNION запроса.
Для задания стратегии наследования используется аннотация Inheritance (или соответствующие блоки
Java Persistence 2.1. Chapter 2.12, J7EE javadoc
В JPA описаны два типа fetch стратегии:
1) LAZY — данные поля будут загруженны только во время первого доступа к этому полю,
2) EAGER — данные поля будут загруженны немедленно,
Основные операции с Entity
EntityManager это интерфейс, который описывает API для всех основных операций над Enitity, получение данных и других сущностей JPA. По сути главный API для работы с JPA. Основные операции:
1) Для операций над Entity: persist (добавление Entity под управление JPA), merge (обновление), remove (удаления), refresh (обновление данных), detach (удаление из управление JPA), lock (блокирование Enity от изменений в других thread),
2) Получение данных: find (поиск и получение Entity), createQuery, createNamedQuery, createNativeQuery, contains, createNamedStoredProcedureQuery, createStoredProcedureQuery
3) Получение других сущностей JPA: getTransaction, getEntityManagerFactory, getCriteriaBuilder, getMetamodel, getDelegate
4) Работа с EntityGraph: createEntityGraph, getEntityGraph
4) Общие операции над EntityManager или всеми Entities: close, isOpen, getProperties, setProperty, clear
Interface used to interact with the persistence context.
An EntityManager instance is associated with a persistence context. A persistence context is a set of entity instances in which for any persistent entity identity there is a unique entity instance. Within the persistence context, the entity instances and their lifecycle are managed. The EntityManager API is used to create and remove persistent entity instances, to find entities by their primary key, and to query over entities.
The set of entities that can be managed by a given EntityManager instance is defined by a persistence unit. A persistence unit defines the set of all classes that are related or grouped by the application, and which must be colocated in their mapping to a single database.
У Entity объекта существует четыре статуса жизненного цикла: new, managed, detached, или removed. Их описание
1) new — объект создан, но при этом ещё не имеет сгенерированных первичных ключей и пока ещё не сохранен в базе данных,
2) managed — объект создан, управляется JPA, имеет сгенерированные первичные ключи,
3) detached — объект был создан, но не управляется (или больше не управляется) JPA,
4) removed — объект создан, управляется JPA, но будет удален после commit’a транзакции.
An entity instance can be characterized as being new, managed, detached, or removed.
• A new entity instance has no persistent identity, and is not yet associated with a persistence context.
• A managed entity instance is an instance with a persistent identity that is currently associated with a persistence context.
• A detached entity instance is an instance with a persistent identity that is not (or no longer) associated with a persistence context.
• A removed entity instance is an instance with a persistent identity, associated with a persistence context, that will be removed from the database upon transaction commit.
1) Если статус Entity new, то он меняется на managed и объект будет сохранен в базу при commit’е транзакции или в результате flush операций,
2) Если статус уже managed, операция игнорируется, однако зависимые Entity могут поменять статус на managed, если у них есть аннотации каскадных изменений,
3) Если статус removed, то он меняется на managed,
4) Если статус detached, будет выкинут exception сразу или на этапе commit’а транзакции,
1) Если статус Entity new, операция игнорируется, однако зависимые Entity могут поменять статус на removed, если у них есть аннотации каскадных изменений и они имели статус managed,
2) Если статус managed, то статус меняется на removed и запись объект в базе данных будет удалена при commit’е транзакции (так же произойдут операции remove для всех каскадно зависимых объектов),
3) Если статус removed, то операция игнорируется,
4) Если статус detached, будет выкинут exception сразу или на этапе commit’а транзакции,
1) Если статус detached, то либо данные будет скопированы в существующей managed entity с тем же первичным ключом, либо создан новый managed в который скопируются данные,
1) Если статус Entity new, то будет создана новый managed entity, в который будут скопированы данные прошлого объекта,
2) Если статус managed, операция игнорируется, однако операция merge сработает на каскадно зависимые Entity, если их статус не managed,
3) Если статус removed, будет выкинут exception сразу или на этапе commit’а транзакции,
1) Если статус Entity managed, то в результате операции будут востановлены все изменения из базы данных данного Entity, так же произойдет refresh всех каскадно зависимых объектов,
2) Если статус new, removed или detached, будет выкинут exception,
1) Если статус Entity managed или removed, то в результате операции статус Entity (и всех каскадно-зависимых объектов) станет detached.
2) Если статус new или detached, то операция игнорируется,
Аннотации JPA
Она определяет тип доступа (access type) для класса entity, суперкласса, embeddable или отдельных атрибутов, то есть как JPA будет обращаться к атрибутам entity, как к полям класса (FIELD) или как к свойствам класса (PROPERTY), имеющие гетеры (getter) и сетеры (setter).
Для такого перекрывания существует четыре аннотации:
1. AttributeOverride чтобы перекрыть поля, свойства и первичные ключи,
2. AttributeOverrides аналогично можно перекрыть поля, свойства и первичные ключи со множественными значениями,
3. AssociationOverride чтобы перекрывать связи (override entity relationship),
4. AssociationOverrides чтобы перекрывать множественные связи (multiple relationship),
Example 2: Overriding of the mapping for the phoneNumbers relationship defined in the ContactInfo
embeddable class.
The Cacheable annotation specifies whether an entity should be cached if caching is enabled when
the value of the persistence.xml shared-cache-mode element is ENABLE_SELECTIVE or
DISABLE_SELECTIVE. The value of the Cacheable annotation is inherited by subclasses; it can be
overridden by specifying Cacheable on a subclass.
Cacheable(false) means that the entity and its state must not be cached by the provider.
If the shared-cache-mode element is not specified in the persistence.xml file and the
javax.persistence.sharedCache.mode property is not specified when the entity manager
factory for the persistence unit is created, the semantics of the Cacheable annotation are undefined.
Convert и Converts — позволяют указать класс для конвертации Basic аттрибута Entity в другой тип (Converts — позволяют указать несколько классов конвертации). Классы для конвертации должны реализовать интерфейс AttributeConverter и могут быть отмечены (но это не обязательно) аннотацией Converter.
Аннотация EntityListeners позволяет задать класс Listener, который будет содержать методы обработки событий (сallback methods) определенных Entity или Mapped Superclass.
Callback методы служат для вызова при определенных событиях Entity (то есть добавить обработку например удаления Entity методами JPA), могут быть добавлены к entity классу, к mapped superclass, или к callback listener классу, заданному аннотацией EntityListeners (см предыдущий вопрос). Существует семь callback методов (и аннотаций с теми же именами):
1) PrePersist
2) PostPersist
3) PreRemove
4) PostRemove
5) PreUpdate
6) PostUpdate
7) PostLoad
Подробнее, см Javadoc 7ee или спецификация JPA2.1 глава 3.5.2
Для этого служит аннотация OrderBy и OrderColumn
Подробнее, см Javadoc 7ee или спецификация JPA2.1 глава 11.1.42
Для этого служит аннотация Transient
Подробнее, см Javadoc 7ee или спецификация JPA2.1 глава 11.1.52
Сложные вопросы JPA
У JPA есть шесть видов блокировок, перечислим их в порядке увеличения надежности (от самого ненадежного и быстрого, до самого надежного и медленного):
1) NONE — без блокировки
2) OPTIMISTIC (или синоним READ, оставшийся от JPA 1) — оптимистическая блокировка,
3) OPTIMISTIC_FORCE_INCREMENT (или синоним WRITE, оставшийся от JPA 1) — оптимистическая блокировка с принудительным увеличением поля версионности,
4) PESSIMISTIC_READ — пессимистичная блокировка на чтение,
5) PESSIMISTIC_WRITE — пессимистичная блокировка на запись (и чтение),
6) PESSIMISTIC_FORCE_INCREMENT — пессимистичная блокировка на запись (и чтение) с принудительным увеличением поля версионности,
Подробнее, см Javadoc 7ee и описание оптимистичных и пессимистичных блокировок баз данных.
JPA говорит о двух видов кэшей (cache):
1) first-level cache (кэш первого уровня) — кэширует данные одной транзакции,
2) second-level cache (кэш второго уровня) — кэширует данные дольше чем одна транзакция. Провайдер JPA может, но не обязан реализовывать работу с кэшем второго уровня. Такой вид кэша позволяет сэкономить время доступа и улучшить производительность, однако оборотной стороной является возможность получить устаревшие данные.
Подробнее, см JPA 2.1 specification, 3.9 Caching
JPA говорит о пяти значениях shared-cache-mode из persistence.xml, который определяет как будет использоваться second-level cache:
1) ALL — все Entity могут кэшироваться в кеше второго уровня,
2) NONE — кеширование отключено для всех Entity,
3) ENABLE_SELECTIVE — кэширование работает только для тех Entity, у которых установлена аннотация Cacheable(true) или её xml эквивалент, для всех остальных кэширование отключено,
4) DISABLE_SELECTIVE — кэширование работает для всех Entity, за исключением тех у которых установлена аннотация Cacheable(false) или её xml эквивалент
5) UNSPECIFIED — кеширование не определенно, каждый провайдер JPA использует свою значение по умолчанию для кэширования,
Подробнее, см JPA 2.1 specification, 3.9 Caching
Для этого существует EntityGraph API, используется он так: с помощью аннотации NamedEntityGraph для Entity, создаются именованные EntityGraph объекты, которые содержат список атрибутов у которых нужно поменять fetchType на EAGER, а потом данное имя указывается в hits запросов или метода find. В результате fetchType атрибутов Entity меняется, но только для этого запроса. Существует две стандартных property для указания EntityGraph в hit:
1) javax.persistence.fetchgraph — все атрибуты перечисленные в EntityGraph меняют fetchType на EAGER, все остальные на LAZY
2) javax.persistence.loadgraph — все атрибуты перечисленные в EntityGraph меняют fetchType на EAGER, все остальные сохраняют свой fetchType (то есть если у атрибута, не указанного в EntityGraph, fetchType был EAGER, то он и останется EAGER)
С помощью NamedSubgraph можно также изменить fetchType вложенных объектов Entity.
Подробнее, см JPA 2.1 specification, 3.7 EntityGraph
Для работы с кэшем второго уровня (second level cache) в JPA описан Cache интерфейс, содержащий большое количество методов по управлению кэшем второго уровня (second level cache), если он поддерживается провайдером JPA, конечно. Объект данного интерфейса можно получить с помощью метода getCache у EntityManagerFactory.
Подробнее, см JPA 2.1 specification, 7.10 Cache Interface
Для получения такой информации в JPA используется интерфейс Metamodel. Объект этого интерфейса можно получить методом getMetamodel у EntityManagerFactory или EntityManager.
Подробнее, см JPA 2.1 specification, 5 Metamodel API
JPQL (Java Persistence query language) это язык запросов, практически такой же как SQL, однако вместо имен и колонок таблиц базы данных, он использует имена классов Entity и их атрибуты. В качестве параметров запросов так же используются типы данных атрибутов Entity, а не полей баз данных. В отличии от SQL в JPQL есть автоматический полиморфизм (см. следующий вопрос). Также в JPQL используется функции которых нет в SQL: такие как KEY (ключ Map’ы), VALUE (значение Map’ы), TREAT (для приведение суперкласса к его объекту-наследнику, downcasting), ENTRY и т.п.
Подробнее, см JPA 2.1 specification, Chapter 4 Query Language
В отличии от SQL в запросах JPQL есть автоматический полиморфизм, то есть каждый запрос к Entity возвращает не только объекты этого Entity, но так же объекты всех его классов-потомков, независимо от стратегии наследования (например, запрос select * from Animal, вернет не только объекты Animal, но и объекты классов Cat и Dog, которые унаследованы от Animal). Чтобы исключить такое поведение используется функция TYPE в where условии (например select * from Animal a where TYPE(a) IN (Animal, Cat) уже не вернет объекты класса Dog).
Подробнее, см JPA 2.1 specification, Chapter 4 Query Language
Criteria API это тоже язык запросов, аналогичным JPQL (Java Persistence query language), однако запросы основаны на методах и объектах, то есть запросы выглядят так:
Подробнее, см JPA 2.1 specification, Chapter 6 Criteria API
Отличия Hibernate 5.0 от JPA 2.1 или JPA 2.0 от JPA 2.1
1) Конструктор без аргументов не обязан быть public или protected, рекомендуется чтобы он был хотя бы package видимости, однако это только рекомендация, если настройки безопасности Java позволяют доступ к приватным полям, то он может быть приватным,
2) JPA категорически требует не использовать final классы, Hibernate лишь рекомендует не использовать такие классы чтобы он мог создавать прокси для ленивой загрузки, однако позволяет либо выключить прокси Proxy(lazy=false), либо использовать в качестве прокси интерфейс, содержащий все методы маппинга для данного класса (аннотацией Proxy(proxyClass=интерфейс.class) )
В отличии JPA в Hibernate есть уникальная стратегия наследования, которая называется implicit polymorphism.
Hibernate supports the three basic inheritance mapping strategies:
table per class hierarchy
table per subclass
table per concrete class
In addition, Hibernate supports a fourth, slightly different kind of polymorphism:
В спецификации JPA 2.1 появились:
1) Entity Graphs — механизм динамического изменения fetchType для каждого запроса,
2) Converters — механизм определения конвертеров для задания функций конвертации атрибутов Entity в поля базы данных,
3) DDL генерация — автоматическая генерация таблиц, индексов и схем,
4) Stored Procedures — механизм вызова хранимых процедур из JPA,
5) Criteria Update/Delete — механизм вызова bulk updates или deletes, используя Criteria API,
6) Unsynchronized persistence contexts — появление возможности указать SynchronizationType,
7) Новые возможности в JPQL/Criteria API: арифметические подзапросы, generic database functions, join ON clause, функция TREAT,
8) Динамическое создание именованных запросов (named queries)
Подробнее о изменении интерфейсов и API в JPA 2.1:
1) Интерфейс EntityManager получил новые методы createStoredProcedureQuery, isJoinedToTransaction и createQuery(CriteriaUpdate или CriteriaDelete)
2) Абстрактный класс AbstractQuery стал наследоваться от класса CommonAbstractCriteria, появились новые интерфейсы CriteriaUpdate, CriteriaDelete унаследованные CommonAbstractCriteria,
3) PersistenceProvider получил новые функции generateSchema позволяющие генерить схемы,
4) EntityManagerFactory получил методы addNamedQuery, unwrap, addNamedEntityGraph, createEntityManager (с указанием SynchronizationType)
5) Появился новый enum SynchronizationType, Entity Graphs, StoredProcedureQuery и AttributeConverter интерфейсы,