Каковы различия между различными методами сохранения в Hibernate?

Ответ 1

Вот мое понимание методов. В основном они основаны на API, хотя я практически не использую их на практике.

saveOrUpdate Вызывает либо сохранение, либо обновление в зависимости от некоторых проверок. Например. если идентификатор не существует, вызывается save. В противном случае вызывается обновление.

сохранить Сохраняет сущность. Будет присвоен идентификатор, если он не существует. Если это так, то это делает обновление. Возвращает сгенерированный идентификатор объекта.

Обновление Попытка сохранить объект с использованием существующего идентификатора. Если идентификатор не существует, я считаю, что исключение выбрано.

saveOrUpdateCopy Это устарело и больше не должно использоваться. Вместо этого есть...

слияния Теперь это то, где мои знания начинают дрожать. Здесь важна разница между временными, отдельными и постоянными объектами. Для получения дополнительной информации о состояниях объектов см. Здесь. С сохранением и обновлением вы имеете дело с постоянными объектами. Они связаны с сеансом, поэтому Hibernate знает, что изменилось. Но когда у вас есть переходный объект, сеанс отсутствует. В этих случаях вам нужно использовать слияние для обновлений и сохраняться для сохранения.

сохраняются Как упоминалось выше, это используется для переходных объектов. Он не возвращает сгенерированный идентификатор.

Ответ 2

╔══════════════╦═══════════════════════════════╦════════════════════════════════╗
║    METHOD    ║            TRANSIENT          ║            DETACHED            ║
╠══════════════╬═══════════════════════════════╬════════════════════════════════╣
║              ║       sets id if doesn't      ║   sets new id even if object   ║
║    save()    ║     exist, persists to db,    ║    already has it, persists    ║
║              ║    returns attached object    ║ to DB, returns attached object ║
╠══════════════╬═══════════════════════════════╬════════════════════════════════╣
║              ║       sets id on object       ║             throws             ║
║   persist()  ║     persists object to DB     ║       PersistenceException     ║
║              ║                               ║                                ║
╠══════════════╬═══════════════════════════════╬════════════════════════════════╣
║              ║                               ║                                ║
║   update()   ║           Exception           ║     persists and reattaches    ║
║              ║                               ║                                ║
╠══════════════╬═══════════════════════════════╬════════════════════════════════╣
║              ║  copy the state of object in  ║    copy the state of obj in    ║
║    merge()   ║     DB, doesn't attach it,    ║      DB, doesn't attach it,    ║
║              ║    returns attached object    ║     returns attached object    ║
╠══════════════╬═══════════════════════════════╬════════════════════════════════╣
║              ║                               ║                                ║
║saveOrUpdate()║           as save()           ║            as update()         ║
║              ║                               ║                                ║
╚══════════════╩═══════════════════════════════╩════════════════════════════════╝

Ответ 3

• См. Hibernate Forum для объяснения тонких различий между persist и save. Похоже, разница заключается в том, что оператор INSERT в конечном счете выполняется. Поскольку сохранить возвращает идентификатор, оператор INSERT должен быть выполнен мгновенно независимо от состояния транзакции (что обычно плохое). Persist не будет выполнять никаких операторов за пределами текущей транзакции, чтобы назначить идентификатор. Save/Persist работают как с временными экземплярами, то есть с экземплярами, которые еще не назначены идентификатором и как таковые не сохраняются в БД.

• Обновить и Объединить работают как с отдельными экземплярами, то есть с экземплярами, которые имеют соответствующую запись в БД, но которые в настоящее время не привязаны (или управляются ) сессия. Разница между ними - это то, что происходит с экземпляром, который передается функции. update пытается повторно подключить экземпляр, это означает, что в противном случае не может быть другого экземпляра постоянного объекта, прикрепленного к сеансу, иначе будет создано исключение. merge, однако, просто копирует все значения в постоянный экземпляр сеанса (который будет загружен, если он не загружен в настоящий момент). Объект ввода не изменяется. Таким образом, слияние более общее, чем обновление, но может использовать больше ресурсов.

Ответ 4

Эта ссылка хорошо объясняет:

http://www.stevideter.com/2008/12/07/saveorupdate-versus-merge-in-hibernate/

У всех нас есть те проблемы, с которыми мы сталкиваемся достаточно редко, что, увидев их снова, мы знаем, что мы решили это, но не можем вспомнить, как это сделать.

Исключение NonUniqueObjectException, возникающее при использовании Session.saveOrUpdate() в Hibernate, является одним из моих. Я бы добавил новые функциональные возможности в сложное приложение. Все мои модульные тесты работают нормально. Затем при тестировании пользовательского интерфейса, пытаясь сохранить объект, я начинаю получать исключение с сообщением "другой объект с тем же значением идентификатора уже был связан с сеансом". Вот пример кода Java Persistence with Hibernate.

            Session session = sessionFactory1.openSession();
            Transaction tx = session.beginTransaction();
            Item item = (Item) session.get(Item.class, new Long(1234));
            tx.commit();
            session.close(); // end of first session, item is detached

            item.getId(); // The database identity is "1234"
            item.setDescription("my new description");
            Session session2 = sessionFactory.openSession();
            Transaction tx2 = session2.beginTransaction();
            Item item2 = (Item) session2.get(Item.class, new Long(1234));
            session2.update(item); // Throws NonUniqueObjectException
            tx2.commit();
            session2.close();

Чтобы понять причину этого исключения, важно понимать отдельные объекты и что происходит, когда вы вызываете saveOrUpdate() (или просто update()) для отдельного объекта.

Когда мы закрываем отдельный сеанс Hibernate, постоянные объекты, с которыми мы работаем, отсоединяются. Это означает, что данные все еще находятся в памяти приложений, но Hibernate больше не отвечает за отслеживание изменений объектов.

Если мы затем модифицируем наш отдельный объект и хотим его обновить, мы должны повторно привязать объект. Во время процесса повторной привязки Hibernate проверит, есть ли другие копии одного и того же объекта. Если он найдет что-либо, он должен сказать нам, что он не знает, что такое "настоящая" копия. Возможно, другие изменения были внесены в те другие копии, которые мы ожидаем сохранить, но Hibernate не знает о них, потому что в то время они не управляли ими.

Вместо того, чтобы сохранять, возможно, плохие данные, Hibernate сообщает нам о проблеме через исключение NonUniqueObjectException.

Так что нам делать? В Hibernate 3 у нас есть merge() (в Hibernate 2, используйте saveOrUpdateCopy()). Этот метод заставит Hibernate копировать любые изменения из других отдельных экземпляров в экземпляр, который вы хотите сохранить, и таким образом объединяет все изменения в памяти перед сохранением.

        Session session = sessionFactory1.openSession();
        Transaction tx = session.beginTransaction();
        Item item = (Item) session.get(Item.class, new Long(1234));
        tx.commit();
        session.close(); // end of first session, item is detached

        item.getId(); // The database identity is "1234"
        item.setDescription("my new description");
        Session session2 = sessionFactory.openSession();
        Transaction tx2 = session2.beginTransaction();
        Item item2 = (Item) session2.get(Item.class, new Long(1234));
        Item item3 = session2.merge(item); // Success!
        tx2.commit();
        session2.close();

Важно отметить, что merge возвращает ссылку на недавно обновленную версию экземпляра. Он не привязывает элемент к сеансу. Если вы проверите, например, равенство (item == item3), вы обнаружите, что в этом случае он возвращает false. Вероятно, вы захотите работать с item3 с этой точки вперед.

Также важно отметить, что Java Persistence API (JPA) не имеет концепции отсоединенных и повторно подключенных объектов и использует EntityManager.persist() и EntityManager.merge().

В целом я обнаружил, что при использовании Hibernate saveOrUpdate() обычно достаточен для моих нужд. Обычно мне нужно использовать слияние, когда у меня есть объекты, которые могут иметь ссылки на объекты того же типа. Совсем недавно причина исключения была в коде, подтверждающем, что ссылка не была рекурсивной. Я загружал один и тот же объект в свою сессию как часть проверки, вызывая ошибку.

Где вы столкнулись с этой проблемой? Работали ли слияния для вас или вам понадобилось другое решение? Вы предпочитаете всегда использовать слияние или предпочитаете использовать его только по мере необходимости для конкретных случаев.

Ответ 5

На самом деле разница между методами hibernate save() и persist() зависит от используемого класса генератора.

Если наш класс генератора назначен, то нет никакой разницы между методами save() и persist(). Поскольку назначенный генератор означает, что в качестве программиста нам нужно указать значение первичного ключа для сохранения в базе данных справа [Надеюсь, вы знаете эту концепцию генераторов] В случае другого, кроме назначенного класса генератора, предположим, что если наше имя класса генератора является Increment означает, что спящий режим сам присваивает значение идентификатора первичного ключа вправо базы данных [кроме назначенного генератора, спящий режим используется только для того, чтобы заботиться о значении идентификатора первичного ключа помнить ], поэтому в этом случае, если мы назовем метод save() или persist(), то он будет вставлять запись в базу данных обычно Но слушайте, что метод save() может вернуть значение первичного ключа, которое генерируется спящим, и мы можем видеть его с помощью

long s = session.save(k);

В этом же случае persist() никогда не вернет клиенту значение.

Ответ 6

Я нашел хороший пример, показывающий различия между всеми методами сохранения в спящем режиме:

http://www.journaldev.com/3481/hibernate-session-merge-vs-update-save-saveorupdate-persist-example

Вкратце, согласно приведенной выше ссылке:

сохранить()

• Мы можем вызывать этот метод вне транзакции. Если мы используем это без транзакции, и у нас есть каскадирование между объектами, тогда только первичный объект будет сохранен, если мы не очистим сеанс.
• Итак, если есть другие объекты, сопоставленные с основным объектом, они сохраняются во время совершения транзакции или когда мы очищаем сеанс.

сохраняться()

• Это похоже на использование save() в транзакции, поэтому он безопасен и заботится о любых каскадных объектах.

saveOrUpdate()

• Может использоваться с транзакцией или без нее и точно так же, как save(), если она используется без транзакции, отображаемые объекты не будут сохранены un; ess мы очищаем сеанс.

• Результаты для вставки или обновления запросов на основе предоставленных данных. Если данные присутствуют в базе данных, выполняется запрос обновления.

обновление()

• Обновление Hibernate должно использоваться там, где мы знаем, что мы только обновляем информацию о сущности. Эта операция добавляет объект объекта в постоянный контекст, и дальнейшие изменения отслеживаются и сохраняются при совершении транзакции.
• Следовательно, даже после вызова обновления, если мы установим любые значения в сущности, они будут обновляться при совершении транзакции.

слияния()

• Слияние Hibernate можно использовать для обновления существующих значений, однако этот метод создает копию из переданного объекта объекта и возвращает его. Возвращаемый объект является частью постоянного контекста и отслеживается для любых изменений, передаваемый объект не отслеживается. Это основное отличие от merge() от всех других методов.

Также для практических примеров всех этих вопросов, пожалуйста, обратитесь к ссылке, упомянутой выше, она показывает примеры для всех этих различных методов.

Ответ 7

Имейте в виду, что если вы вызываете обновление для отдельного объекта, в базе данных всегда будет сделано обновление, измените ли вы объект или нет. Если это не то, что вы хотите, вы должны использовать Session.lock() с LockMode.None.

Вы должны вызывать обновление только в том случае, если объект был изменен вне области вашего текущего сеанса (в отключенном режиме).

Ответ 8

Ни один из следующих ответов не прав. Все эти методы кажутся похожими, но на практике делают совершенно разные вещи. Трудно дать короткие комментарии. Лучше дать ссылку на полную документацию об этих методах: http://docs.jboss.org/hibernate/core/3.6/reference/en-US/html/objectstate.html