(update() обновляется, если первичного ключа нет, будет сообщено об ошибке.
saveOrUpdate() сохраняет или обновляет, выполняет вставку без первичного ключа.
Обновление: Это операция обновления для временных (переходных) или просто отсоединенных (отсоединенных) операций. Операция обновления для временных объектов обычно не имеет никакого эффекта. Для отдельных объектов выполняется операция синхронизации, то есть данные базы данных изменяются. И состояние объекта также становится управляемым объектом.
SaveOrUpdate: он также работает с временными или отдельными операциями. Что касается вставки или обновления, его необходимо проанализировать в соответствии с некоторыми конкретными условиями, указанными в идентификаторе. Однако я лично считаю, что когда очевидно, что произойдет только операция вставки, лучше избегать использования saveOrUpdate и просто использовать save напрямую)
Начнем с некоторых понятий:
В Hibernate основной концепцией является управление состоянием PO. У ЗП есть три состояния:
1. Не сохранившийся ВО
На данный момент это объект памяти VO, жизненный цикл которого управляется JVM.
2. PO был сохранен, и данные базы данных сопоставляются в это время в течение жизненного цикла сеанса, и база данных управляет жизненным циклом.
3. Он был сохранен, но теперь отключен от сеанса. Если вы запустите этот PO, который был отключен от сеанса, в качестве VO, вы также можете войти в другой сеанс и продолжить управление состоянием PO в это время. , он становится ПО. Второе состояние. Этот вид ПО на самом деле пересекает
Сессия выполняет обслуживание состояния.
В традиционном JDO1.x PO имеет только первые два состояния. Как только PO отделяется от PM, он теряет свое состояние и больше не связан с данными базы данных. Он становится чистым VO памяти.
Даже если вы добавите новый ЛС, его статус невозможно будет восстановить.
Преимущество Hibernate в том, что после того, как PO покидает сеанс, он все еще может поддерживать состояние. После входа в новый сеанс возможность управления состоянием восстанавливается.
Вам нужно использовать session.update или session.saveOrUpdate, о чем упоминается в справочнике Hibernate в разделе «требуется немного другое программирование».
модель"
Теперь официально войдите в эту тему:
Проще говоря, update и saveOrUpdate используются для управления статусом межсессионных заказов на покупку.
Если предположить, что вашему PO не требуется пересекать сеансы, то нет необходимости его использовать. Например, если вы открываете сеанс, управляете PO, а затем закрываете его, вы больше не будете использовать этот PO.
Тогда нет необходимости использовать обновление.
Итак, давайте посмотрим на приведенный выше пример:
Java-код
Foo foo=sess.load(Foo.class,id);;
foo.setXXX(xxx);;
sess.flush();;
сесс.коммит();;
Foo foo=sess.load(Foo.class,id);; foo.setXXX(xxx);; sess.flush();; sess.commit();;
Все операции объекта PO foo выполняются в течение жизненного цикла сеанса, поэтому нет необходимости явно выполнять такие операции, как sess.update(foo). Hibernate автоматически обнаружит, что объект foo имеет
был изменен, поэтому в базу данных отправляется обновленный sql. Конечно, если вы настаиваете на добавлении sess.update(foo), это не будет ошибкой, но в этом нет необходимости.
Межсессионный режим означает, что после закрытия сеанса вы все равно используете этот объект PO в качестве VO. Позже вы измените его свойства вне сеанса, а затем захотите открыть его снова.
Откройте сеанс и сохраните изменения атрибута VO в базе данных, затем вам нужно будет использовать обновление.
Java-код
// в первом сеансе
Кот cat = (Cat); firstSession.load(Cat.class, catId);;
Cat потенциалMate = новый Cat();;
firstSession.save(potentialMate);;
// на более высоком уровне приложения
cat.setMate(potentialMate);;
// позже, в новом сеансе
SecondSession.update(cat); // обновляем кота
SecondSession.update(mate); // обновляем помощника
// в первом сеансе Cat cat = (Cat); firstSession.load(Cat.class, catId);; Cat потенциальныхMate = new Cat();;
firstSession.save(potentialMate); // на более высоком уровне приложения cat.setMate(potentialMate); // позже, в
новый сеанс SecondSession.update(cat); // обновление кота SecondSession.update(mate); // обновление партнера
Объекты cat и mate получаются в первом сеансе. После закрытия первого сеанса они становятся третьим состоянием PO, а PO, который в это время был отключен сеансом.
Информация об их статусе по-прежнему сохраняется. Когда они входят во второй сеанс, они могут сразу обновить статус. Но из-за операции модификации кота: cat.setMate
(potentialMate); выполняется вне сеанса. Hibernate не может знать, что объект cat был изменен. Второй сеанс не знает об этом изменении, поэтому оно должно быть явным.
Вызовите SecondSession.update(cat); чтобы уведомить Hibernate о том, что объект cat был изменен, и вам необходимо отправить запрос обновления sql.
Так что это роль обновления. Оно будет записано только тогда, когда объект PO синхронизирует свой статус между сеансами. Когда объект PO не требуется обрабатывать в нескольких сеансах,
При выполнении управления состоянием нет необходимости записывать обновления.
Давайте поговорим об использовании saveOrUpdate:
Разница между saveOrUpdate и update заключается в стратегии, которую Hibernate принимает для PO при межсеансовом управлении состоянием PO.
Например, когда вы пишете DAOImpl, добавьте сопряжение к объекту cat, как определено ниже:
Java-код
public void addMate (Cat cat, Mate mate {);
Сеанс сеанс = ...;
Транзакция TX = ...;
session.update(кот);;
cat.addMate(mate);;
tx.commit();;
сеанс.закрыть();;
};
public void addMate(Cat cat, Mate mate {сеанс сеанса = ...; Transacton tx = ...; session.update(cat);;
cat.addMate(mate);; tx.commit();; session.close();;
Очевидно, вам необходимо инкапсулировать операции Hibernate в DAO, чтобы программистам бизнес-уровня и программистам веб-уровня не нужно было знать Hibernate и напрямую вызывать DAO.
На этом этапе возникает проблема: существует необходимая предпосылка для правильной работы приведенного выше кода, то есть объект cat параметра вызова метода должен быть сохраненным PO, то есть он должен
Сначала запросите его из базы данных, а затем используйте следующим образом. Но программисты бизнес-уровня явно не знают этой внутренней тайны, если его дело — время от времени добавлять кота.
Его приятель, он, очевидно, назовет его так, появится новый объект кота, а затем addMate:
Java-код
Кот кот = новый Кот();;
кот.setXXX();;
daoimpl.addMate(кот,приятель);;
Кот cat = новый Cat();; cat.setXXX();; daoimpl.addMate(cat,mate);;
Но обратите внимание, что этот объект cat является всего лишь VO, он не был сохранен, это не PO и он не имеет права вызывать метод addMate, поэтому вызов метода addMate на самом деле не приведет к
Чтобы отправить запрос обновления в базу данных, объект cat должен быть сначала сохранен в базе данных. Только после того, как он действительно станет PO, он может быть квалифицирован для addMate.
Вы должны сделать это следующим образом:
Java-код
Кот кот = новый Кот();;
кот.setXXX();;
daoimpl.addCat(кот);;
daoimpl.addMate(кот, приятель);;
Кот cat = новый Cat();; cat.setXXX();; daoimpl.addCat(cat);; daoimpl.addMate(cat, mate);;
Сначала сохраните cat, а затем выполните другие операции сохранения над cat. Поэтому программисты бизнес-уровня должны знать, в каком состоянии находится объект-кот, первый он или третий.
Если это первый тип, вам нужно сначала сохранить, а затем добавитьMate, если это третий тип, просто добавьтеMate напрямую;
Но самое фатальное то, что если все программное обеспечение имеет много слоев, то объект cat, который получает программист бизнес-уровня, может быть котом, переданным из верхнего уровня веб-приложения, а он сам этого не знает.
Независимо от того, является ли кот ВО, не был сохранен или был сохранен, то у него вообще нет возможности написать программу.
Таким образом, такой DAOImpl, очевидно, проблематичен. Он приведет к появлению множества ловушек программирования для программистов бизнес-уровня. Программисты бизнес-уровня должны иметь глубокое понимание каждой пары PO, которую они называют.
Какое управление состоянием осуществляется, необходимо иметь глубокое понимание точного состояния своего ПО объекта в любой момент времени, чтобы обеспечить корректность программирования. Очевидно, это невозможно, но с.
saveOrUpdate, эти проблемы легко решаются.
Теперь вам нужно изменить метод addMate:
Java-код
public void addMate (Cat cat, Mate mate {);
Сеанс сеанс = ...;
Транзакция TX = ...;
session.saveOrUpdate(cat);;
cat.addMate(mate);;
tx.commit();;
сеанс.закрыть();;
};
public void addMate (Cat cat, Mate mate); {сеанс сеанса = ...; Transacton tx = ...;
(кот);; cat.addMate(mate);; tx.commit();; session.close();;
Как указано выше, если программист бизнес-уровня передает сохраненный объект PO, Hibernate обновит объект cat (при условии, что программист бизнес-уровня изменил его вне сеанса).
атрибут cat), если передается новый объект, сохраните объект PO в базе данных.
Кстати: будет ли Hibernate обновлять объект кошки или сохранять объект кошки в это время, зависит от настройки unsave-value.
Таким образом, программистам бизнес-уровня больше не придется беспокоиться о статусе PO. Для них не имеет значения, является ли cat новым объектом, просто VO, или он запрашивается из базы данных.
Независимо от объектов PO, все они могут быть добавлены непосредственно в addMate:
Java-код
daoimple.addMate(кот, приятель);;
daoimple.addMate(кот, приятель);;
Это то, что делает saveOrUpdate.
Эта статья взята из блога CSDN. При перепечатке указывайте источник: http://blog.csdn.net/zhrl0000/archive/2009/12/17/5027965.aspx.
-