1. O ciclo de vida do objeto persistente
Depois que o aplicativo usa a estrutura Hibernate, os objetos persistentes criados pelo aplicativo passarão por um conjunto completo de ciclos de vida para concluir as operações do banco de dados, entre as quais os três estados principais são transitórios, persistência e destacados. As transições desses três estados podem ser controladas no aplicativo, conforme mostrado na figura abaixo:
Para entender claramente esses estados, aqui está um exemplo para ver as diferenças entre os objetos nesses estados. Os seguintes códigos nos Estados Unidos são os seguintes:
(1) Crie uma montagem de Hibernate_session e adicione um pacote JAR correspondente;
(2) Configure o Hibernate, adicione a classe de usuário da entidade correspondente e seus arquivos de mapeamento e configure a conexão de banco de dados correspondente;
Classe de arquivo do usuário Mapeamento de arquivo user.hbm.xml Código:
<? xml versão = "1.0"?> <! Doctype Hibernate-mapping público "-// Hibernate/hibernate mapeamento dtd 3.0 // pt" "http://hibernate.sourceforge.net/hibernate-mappp-3.0.dtd"> <! -> <Hibernate-mapping> <classe name = "com.hibernate.user"> <id name = "id"> <generator/> </dod> <propriedade name = "name"/> <propriedade name = "senha"/> <name = "createTime"/> name = "expireTime"/> </class> </hibrinate "/>
Código de configuração de conexão do banco de dados Hibernate:
<? xml versão = "1.0" coding = "utf-8"?> <! <Session-Factory> <propriedade name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <propriedade name = "hibernate.connection.url"> jdbc: mySql: // lochost: 3306/hibernate_session </session> </propriedades> <propriedade name = "hibernate.connection.password"> ab12 </propriedade> <!-dialeto: dialeto, a API subjacente encapsulada, semelhante ao tempo de execução, converte o banco de dados no idioma correspondente na configuração-> <nome da propriedade "" hibernate.dialect "/org.hibernate.dialect.mys Name =" Resource = "com/hibernate/user.hbm.xml"/> </session-factory> </Hibernate-Configuration>
(3) Adicione uma classe pública do membro estático SessionFactory para criar um objeto de sessão e seu objeto de sessão;
pacote com.hibernate; importar org.hibernate.session; importar org.Hibernate.SessionFactory; importar org.hibernate.cfg.configuration; Public Class Session {fábrica de sessão estática privada; // Declare a variável local estática SessionFactory, o banco de dados espelho estático {tente {// crie e obtenha o arquivo de configuração para o banco de dados de configuração e obtenha hibernate.cfg.xml configuração cfg = new Configuration (). Configure (); fábrica = cfg.buildSessionFactory (); // Construa uma imagem de banco de dados} Catch (Exceção e) {E.PrintStackTrace (); // Mensagem de erro de impressão}} public static session getSession () {return factory.openssion (); // retorna o objeto de sessão criado} public static sessfactory getSessionFactory () {retornar fábrica; // retorna a sessão correspondente} // fecha o objeto de sessão public static void Closesession (sessão session) {if (session! = Null) {if (session.isopen ()) {session.close (); }}}}}(4) Adicione uma pasta de origem e adicione um pacote chamado com.hibernate na pasta e adicione um arquivo de classe chamado SessionTest ao pacote.
pacote com.hibernate; importar java.util.date; import junit.framework.testcase; importar org.hibernate.session; importar org.hibernate.transaction; classe pública sessiontest estende o teste {} 2. Método de conversão do estado
1. O objeto entra diretamente no estado persistente
1.1 Obter método
Obtenha uma linha de informações do banco de dados e sincronize as informações no objeto criado. Este método retorna um objeto e retorna nulo se nenhum conteúdo for encontrado. O exemplo a seguir usa o método Get Session para obter um objeto e converter o objeto em uma instância.
public void testGet1 () {sessão session = null; Transação tx = nulo; tente {session = hibernateUtils.getSession (); // Aberta transação tx = session.begIntransaction (); // O objeto carregado por get é um objeto persistente // executar pode emitir uma declaração de consulta imediatamente e, se não existir, ele retornará o usuário nulo do usuário = (usuário) session.get (user.class, "FF80808145BC28CC0145BC28CE020002"); System.out.println (user.getName ()); // estado persistente // objeto com o estado persistente muda quando as propriedades do objeto mudam // hibernate sincronizará user.setName ("zhao liu"); session.gettransaction (). Commit (); } catch (Exceção e) {e.printStackTrace (); if (tx! = null) {tx.rollback (); }} finalmente {hibernateutils.closhessession (sessão); }} Defina pontos de interrupção para obter o objeto do usuário.
Este objeto é obtido e um objeto de usuário é obtido após a fundição. O método setName é adicionado ao programa, o que significa que o nome no banco de dados será atualizado. Após a conclusão da execução, o banco de dados será verificado, conforme mostrado na figura abaixo para atualizar os resultados.
1.2 Método de carga
A função é semelhante ao método GET e também obtém dados do banco de dados e o sincroniza no objeto. Este método suporta operação preguiçosa. Ele retorna um objeto persistente ou um proxy, por isso precisa ser convertido.
public void testLoad1 () {sessão session = null; tente {session = hibernateUtils.getSession (); // A declaração de consulta não será verificada imediatamente porque a carga suporta preguiçosa (carga de atraso/carga preguiçosa) // O que ensinar preguiçoso? Somente quando esse objeto for realmente usado e depois criado, a declaração de consulta será emitida para Hibernate. É principalmente melhorar o desempenho. preguiçoso é uma característica muito importante em Hibernate. Como o preguiçoso do hibernato é implementado? Implementado por objetos proxy. Os objetos proxy usam principalmente // gerados pela biblioteca CGLIB em vez do proxy dinâmico do JDK, porque o proxy dinâmico do JDK só pode gerar proxy para classes que implementam desculpas. O CGLIB pode gerar // proxy para classes. Ele adota o método de herança Usuário do usuário = (Usuário) session.load (user.class, "8A1B653745BCC7B50145BCC7B7B7140001"); System.out.println (user.getName ()); // estado persistente // Objetos com estado persistente, quando as propriedades do objeto mudarem // hibernate sincronizam o user.setName ("zhaoliu"); session.gettransaction (). Commit (); } catch (Exceção e) {e.printStackTrace (); } finalmente {hibernateutils.closhessession (sessão); }} Consulta para obter o objeto do usuário, como mostrado na figura abaixo:
Analisando a figura acima, o objeto de usuário obtido não está completo ou não há objeto de usuário comum, mas é um proxy. Ele usa o CGLIB para pré -carregar o objeto e só é realmente criado ao usar o objeto.
1.3 Obtenha Vs Carga
Os métodos de obter e carregar são muito importantes. Eles são frequentemente levados durante entrevistas com Hibernate. A seguir, é apresentada uma comparação dos dois seguintes.
Semelhanças:
(1) as funções são as mesmas e os dados de relacionamento são convertidos em objetos;
(2) O método de uso é o mesmo e também são necessárias duas diferenças nos parâmetros:
(1) O método de carga suporta operação preguiçoso, pré -carrega o objeto e é criado apenas quando usado. Obtenha diretamente dados relacionais em objetos;
(2) Se o objeto de carga de carga não existir, uma objectNotFoundException será lançada e, se o GET não receber os dados, ele retornará nulo.
2. Construa manualmente objetos destacados
Existe outro método para obter um objeto. É diferente dos métodos GET e LOAD. É um método manual. Primeiro, um objeto é comum e, em seguida, os dados do objeto são obtidos pela formulação de um ID. O método é o seguinte:
public void testUer () {sessão session = null; tente {session = hibernateUtils.getSession (); session.BegIntransaction (); // Construa manualmente o usuário do ObjectUser destacado = novo usuário (); user.setId ("8A1B653745BCC7B50145BCC7B7B7140001"); // estado persistente // objeto com estado persistente, quando as propriedades do objeto mudam // hibernate sincroniza session.gettransaction (). Commit () com o banco de dados ao limpar o cache (verificação de dados suty); } catch (Exceção e) {e.printStackTrace (); } finalmente {hibernateutils.closhessession (sessão); }} Veja o diagrama de resultados obtidos:
O diagrama de resultados de análise é usado no código para definir o número de identificação para o objeto. Depois que o número de identificação for formulado, o objeto pode ser operado. Depois que a transação é enviada, ela é sincronizada com o banco de dados e a especificação manual é usada para especificar manualmente as informações do objeto.
2.1 Método de exclusão
Para excluir o objeto especificado no banco de dados, o objeto deve ser convertido no estado persistente antes de excluí -lo. Você pode usar métodos get, carregamento ou manual para especificar o objeto. O método é o seguinte:
sessão = hibernateutils.getSession (); session.BegIntransaction (); Usuário Usuário = (Usuário) session.load (User.class, "8A1B653745BCC6D50145BCC6D67A0001"); // É recomendável usar esse método para excluir, carregar primeiro e depois excluir session.delete (usuário);
2.2 ATUALIZAÇÃO
Atualize os dados, esse método modificará os dados no banco de dados. Ao usá -lo, haverá uma situação na quantidade, que atualizará o valor de um determinado campo no banco de dados ou atualizará toda a linha do banco de dados.
2.2.1 Atualizar um valor de campo
Se você deseja atualizar apenas o valor de um determinado campo, antes de atualizar, precisará usar o carregamento ou converter o objeto em um código de status persistente da seguinte forma:
// obtenha sessão de sessão session = hibernateUtils.getSession (); // Abra a transação session.BegIntransaction (); // ou você pode usar outro método para ativar //session.gettransaction (). BEGIN (); // Carregar para obter objeto de usuário // Método 1: Use o método de carregamento // usuário do usuário = (usuário) session.load (user.class, "8a1b653745bc7b50145bcc7b7b7140001"); // Método 2: obtenha manualmente o usuário = novo usuário (); user.setId ("8A1B653745BCC7B50145BCC7B7B7140001"); // atualize o nome user.setName ("zhangsan"); session.Update (usuário); session.gettransaction (). Commit ();2.2.2 Atualize a linha inteira <r />, se você deseja atualizar os dados de toda a linha, poderá converter manualmente o estado para o estado destacado e especificar manualmente o valor de ID do objeto. O código é o seguinte:
// obtenha sessão de sessão session = hibernateUtils.getSession (); // Abra a transação session.BegIntransaction (); // ou pode usar outro método para ativar //session.gettransaction (). BEGIN (); // obtenha manualmente o usuário = novo usuário (); user.setId ("8A1B653745BCC7B50145BCC7B7B7140001"); // atualize o nome user.setName ("zhangsan"); session.Update (usuário); session.gettransaction (). Commit (); Ver Resultados da Atualização:
Analisando os resultados da atualização, na verdade, ele atualiza toda a linha de dados do banco de dados. Existem muitas incertezas nesta operação de atualização e não é recomendável usá -la.
2.3 Método salvar
Insira dados. Ao executar o método SALVE, a instrução Inserir do banco de dados é chamada para adicionar uma nova linha ao banco de dados. O objeto salvo será convertido em estado persistente. Nesse estado, o objeto pode atualizar o objeto novamente e será atualizado para o banco de dados com alterações quando a transação for finalmente enviada. do seguinte modo:
public void testSave2 () {sessão session = null; Transação tx = nulo; tente {session = hibernateUtils.getSession (); // Aberta transação tx = session.begIntransaction (); // status transitório usuário usuário = novo usuário (); user.setName ("Zhangsi"); user.setPassword ("123"); user.setCreateTime (new Date ()); user.setexpiretime (new Date ()); // estado persistente // objeto com o estado persistente muda quando as propriedades do objeto alteram // hibernate sincronizará session.save (usuário); user.setName ("lisi"); tx.Commit (); } catch (Exceção e) {e.printStackTrace (); if (tx! = null) {tx.rollback (); }} finalmente {hibernateutils.closhessession (sessão); } // status destacado} Veja o exemplo anterior Execute a visualização do resultado:
Resultado da análise: a sessão realmente faz duas operações ao enviar a transação. Combinado com o processo de atualização no código, primeiro, um novo objeto de usuário é adicionado e, em seguida, uma operação de salvamento é executada. Ele chamará a instrução INSERT e uma operação do SetName será feita no código e o nome é re-modificado. No entanto, ele não foi sincronizado com o banco de dados no momento, mas está na memória. Neste momento, haverá dois estados. Dizemos que os bits de dados neste momento são dados sujos e, finalmente, atualizam para o banco de dados ao enviar a transação.