(update() atualiza, se não houver chave primária, um erro será relatado.
saveOrUpdate() salva ou atualiza, executa inserção sem chave primária.
Atualização: É uma operação de atualização para objetos transitórios (transientes) ou apenas desanexados (desanexados). A operação de atualização para objetos transitórios geralmente não tem efeito. Para objetos desanexados, é realizada uma operação de sincronização, ou seja, os dados do banco de dados são alterados. E o estado do objeto também se torna um objeto gerenciado
SaveOrUpdate: Também opera em operações transitórias ou desanexadas. Quanto à inserção ou atualização, deve ser analisado de acordo com algumas condições específicas especificadas no id. Porém, eu pessoalmente acho que quando for óbvio que apenas a operação de inserção ocorrerá, é melhor evitar usar saveOrUpdate e apenas usar save diretamente)
Vamos começar com alguns conceitos:
No Hibernate, o conceito central é o gerenciamento de estado do PO. Um PO tem três estados:
1. VO que não persiste
Neste momento, é um objeto de memória VO e o ciclo de vida é gerenciado pela JVM.
2. O PO foi persistido e os dados do banco de dados são mapeados neste momento durante o ciclo de vida da sessão, e o banco de dados gerencia o ciclo de vida.
3. Foi persistido, mas agora foi desanexado da Sessão. Se você executar este PO que foi desanexado da Sessão como um VO, também poderá entrar em outra Sessão e continuar gerenciando o estado do PO. , torna-se um PO O segundo estado. Este tipo de PO realmente atravessa
A sessão realiza manutenção de estado.
No JDO1.x tradicional, o PO possui apenas os dois primeiros estados. Depois que um PO é separado do PM, ele perde seu estado e não está mais associado aos dados do banco de dados.
Mesmo se você adicionar uma nova MP, seu status não poderá ser restaurado.
A força do Hibernate é que depois que um PO sai da sessão, ele ainda pode manter o estado. Depois de entrar em uma nova sessão, a capacidade de gerenciamento de estado é restaurada.
Você precisa usar session.update ou session.saveOrUpdate, que é o que a referência do Hibernate mencionou em "requer uma programação um pouco diferente
modelo"
Agora entre oficialmente neste tópico:
Simplificando, update e saveOrUpdate são usados para gerenciar o status de pedidos de compra entre sessões.
Supondo que seu PO não precise cruzar Sessões, então não há necessidade de usá-lo. Por exemplo, se você abrir uma Sessão, operar o PO e depois fechá-la, você não usará este PO novamente.
Então não há necessidade de usar atualização.
Então, vejamos o exemplo acima:
Código Java
Foo foo=sess.load(Foo.class,id);;
foo.setXXX(xxx);;
sess.flush();;
sess.commit();;
Foo foo=sess.load(Foo.class,id);; foo.setXXX(xxx);;
As operações do objeto PO foo são todas concluídas dentro de um ciclo de vida de sessão, portanto não há necessidade de executar explicitamente operações como sess.update(foo). O Hibernate detectará automaticamente que o objeto foo foi
foi modificado, então uma atualização sql é enviada ao banco de dados. Claro, não é errado você insistir em adicionar sess.update(foo), mas não há necessidade de fazer isso.
Cross-Session significa que após o encerramento da Sessão, você ainda usa este objeto PO como VO. Posteriormente, você modifica suas propriedades fora da Sessão e deseja abri-lo novamente.
Abra uma sessão e salve as modificações do atributo VO no banco de dados, então você precisa usar update.
Código Java
//na primeira sessão
Gato gato = (Cato);
Cat potencialMate = new Cat();;
firstSession.save(potentialMate);;
//em uma camada superior da aplicação
cat.setMate(potencialMate);;
// mais tarde, em uma nova sessão
secondSession.update(cat); // atualiza gato
secondSession.update(mate); // atualiza companheiro
// na primeira sessão Cat cat = (Cat);
firstSession.save(potentialMate); // em uma camada superior da aplicação cat.setMate(potentialMate); // mais tarde, em um
nova sessão secondSession.update(cat); // atualiza cat secondSession.update(mate); // atualiza mate
Os objetos cat e mate são obtidos na primeira sessão. Após o fechamento da primeira sessão, eles se tornam o terceiro estado do PO, e o PO que a Sessão desanexou neste momento.
Suas informações de status ainda são retidas. Ao entrarem na segunda sessão, eles podem atualizar imediatamente o status. Mas devido à operação de modificação em cat: cat.setMate
(potentialMate); é executado fora da sessão. O Hibernate não pode saber que o objeto cat foi modificado. A segunda sessão não conhece esta modificação, portanto deve ser explícita.
Chame secondSession.update(cat); para notificar o Hibernate que o objeto cat foi modificado e você deve enviar o sql de atualização.
Portanto, este é o papel da atualização. Ele só será escrito quando um objeto PO estiver sincronizando seu status entre as sessões. Quando um objeto PO não precisa ser processado entre sessões,
Ao realizar o gerenciamento de estado, não há necessidade de gravar atualizações.
Vamos falar sobre o uso de saveOrUpdate:
A diferença entre saveOrUpdate e update está na estratégia que o Hibernate adota para PO no gerenciamento de estado de PO entre sessões.
Por exemplo, ao escrever um DAOImpl, adicione um posicionamento ao objeto cat, conforme definido abaixo:
Código Java
public void addMate(Gato gato, companheiro companheiro);
Sessão sessão = ...;
Transação tx = ...;
sessão.update(gato);;
cat.addMate(companheiro);;
tx.commit();;
sessão.close();;
};
public void addMate(Cat cat, Mate mate); { Sessão sessão = ...;
cat.addMate(mate);; tx.commit();; session.close();;
Obviamente, você precisa encapsular as operações do Hibernate no DAO, para que os programadores da camada de negócios e da camada Web não precisem conhecer o Hibernate e chamar diretamente o DAO.
Neste ponto surge o problema: existe um pré-requisito necessário para que o código acima seja executado corretamente, ou seja, o parâmetro de chamada do método objeto cat deve ser um PO que foi persistido, ou seja, deve
Primeiro consulte-o no banco de dados e depois use-o assim. Mas os programadores da camada de negócios obviamente não conhecem esse mistério interno: se seu negócio é adicionar um gato de vez em quando.
Seu mate, ele obviamente irá chamá-lo assim, um novo objeto cat será lançado e então addMate:
Código Java
Gato gato = novo Gato();;
cat.setXXX();;
daoimpl.addMate(gato,companheiro);;
Gato gato = new Cat();; cat.setXXX();;
Mas observe que este objeto cat é apenas um VO, não foi persistido, não é um PO e não está qualificado para chamar o método addMate, portanto, chamar o método addMate não irá realmente para
Para enviar atualização sql no banco de dados, o objeto cat deve ser salvo primeiro no banco de dados. Somente depois de realmente se tornar um PO ele poderá ser qualificado para addMate.
Você tem que fazer assim:
Código Java
Gato gato = novo Gato();;
cat.setXXX();;
daoimpl.addCat(gato);;
daoimpl.addMate(gato, companheiro);;
Gato gato = new Cat();; cat.setXXX();; daoimpl.addCat(cat);;
Persista o gato primeiro e depois execute outras operações de persistência no gato. Portanto, os programadores da camada de negócios devem saber em que estado se encontra o objeto cat, se é o primeiro ou o terceiro.
Se for o primeiro tipo, você precisa salvar primeiro e depois addMate; se for o terceiro tipo, basta adicionarMate diretamente;
Mas o mais fatal é que se todo o software tiver muitas camadas, o objeto cat que o programador da camada de negócios obtém pode ser o cat passado da camada superior do aplicativo da web, e ele mesmo não sabe disso.
Quer cat seja VO, não tenha sido persistido ou tenha sido persistido, então ele não tem como escrever um programa.
Portanto, tal DAOImpl é obviamente problemático. Ele causará muitas armadilhas de programação para os programadores da camada de negócios. Os programadores da camada de negócios devem ter um conhecimento profundo de cada par PO de DAO que chamam.
Qualquer que seja o tipo de gerenciamento de estado realizado, você deve ter um conhecimento profundo do estado exato de seu objeto PO a qualquer momento para garantir a correção da programação. Obviamente, isso é impossível.
saveOrUpdate, esses problemas são facilmente resolvidos.
Agora você precisa modificar o método addMate:
Código Java
public void addMate(Gato gato, companheiro companheiro);
Sessão sessão = ...;
Transação tx = ...;
session.saveOrUpdate(cat);;
cat.addMate(companheiro);;
tx.commit();;
sessão.close();;
};
public void addMate(Cat cat, Mate mate); { Sessão sessão = ...;
(gato);; cat.addMate(companheiro);; tx.commit();;
Como acima, se o programador da camada de negócios passar um objeto PO que foi persistido, então o Hibernate atualizará o objeto cat (assumindo que o programador da camada de negócios o modificou fora da Sessão).
atributo cat), se o que for passado for um novo objeto, salve o objeto PO no banco de dados.
BTW: Se o Hibernate atualiza o objeto cat ou salva o objeto cat neste momento depende da configuração do valor não salvo.
Dessa forma, os programadores da camada de negócios não precisam mais se preocupar com o status do PO. Para eles, não importa se cat é um objeto novo, apenas um VO, ou se é consultado no banco de dados.
Independentemente dos objetos PO, todos eles podem ser adicionados diretamente ao addMate:
Código Java
daoimple.addMate(gato, companheiro);;
daoimple.addMate(gato, companheiro);;
Isso é o que saveOrUpdate faz.
Este artigo vem do blog CSDN. Indique a fonte ao reimprimir: http://blog.csdn.net/zhrl0000/archive/2009/12/17/5027965.aspx.
-