anotação
A anotação do Hibernate é um método mais recente que não usa arquivos XML para definir mapeamentos. As anotações podem ser usadas nos metadados do mapeamento XML que são separados ou substituídos.
As anotações do Hibernate são uma maneira poderosa de fornecer mapeamentos de objetos de metadados e tabelas relacionais. Todos os metadados são irritados com o arquivo Pojo Java. Isso pode ajudar os usuários a entender a estrutura da tabela e POJO durante o processo de desenvolvimento.
Se você pretende portar o aplicativo para outros aplicativos ORM específicos do EJB3, você deverá usar anotações para representar as informações de mapeamento, mas se desejar maior flexibilidade, use o mapeamento baseado em XML.
Definindo a anotação do Hibernate no ambiente primeiro, você deve garantir que esteja usando o JDK5.0; caso contrário, precisará atualizar o JDK para o suporte nativo do JDK5.0 com anotações.
Em segundo lugar, você precisa instalar o pacote de distribuição de anotação 3.x da Hibernate, você pode usar o SourceForge: (baixar anotação de hibernação) e copiar hibernate-annotações.jar, lib/hibernate-comons-annatações.
Comentou a instância da classe:
Como mencionado, todos os metadados que trabalham com o hibernato de anotação trabalham no arquivo Pojo Java acima, isso pode ajudar os usuários a entender a estrutura da tabela e o POJO durante o desenvolvimento.
Considere o objeto que será armazenado usando a seguinte tabela de funcionários:
Criar funcionário da tabela (ID int não nulo auto_increntle, primeiro_name varchar (20) nulo padrão, last_name varchar (20) nulo padrão, nulo padrão nulo padrão, chave primária (id));
A seguir, é apresentado o mapeamento da classe de funcionários do objeto com anotações para mapear com a tabela de funcionários definidos:
importar javax.persistence.*; @entity @tabela (name = "funcionário") public classe funcionário {@id @generatedValue @column (name = "id") private int id; @Column (name = "primeiro_name") private string primeironame; @Column (name = "last_name") private string lastName; @Column (name = "salário") Salário privado; public funcionário () {} public int getId () {return id; } public void setId (int id) {this.id = id; } public String getFirstName () {return FirstName; } public void setFirstName (String First_Name) {this.firstName = First_Name; } public string getLastName () {return lastName; } public void setLastName (string last_name) {this.lastName = last_name; } public int getSalary () {retornar salário; } public void SetSalary (salário int) {this.salary = salário; }}O Hibernate detecta que a anotação @ID é contra um campo e assume que deve acessar as propriedades de um objeto diretamente através do domínio de tempo de execução. Se o @ID for anotado com o método getId (), a propriedade será acessada por padrão via métodos Getter e Setter. Portanto, todos os outros comentários também são colocados no método de campo ou getter, conforme selecionado abaixo da política. A seção a seguir explica os comentários usados na classe acima.
@Entity Anotation:
A descrição da especificação EJB3 está incluída no pacote javax.persistence, por isso importamos este pacote como a primeira etapa. Em segundo lugar, usamos a anotação @Entity para marcar essa classe como uma classe de funcionários da entidade Bean, para que ela tenha um construtor sem parâmetros, que finalmente é visível com proteção.
@Table Anotation:
A anotação @Table permite que a tabela especificada seja usada para manter informações detalhadas sobre a entidade no banco de dados.
A anotação @Table fornece quatro propriedades que permitem substituir o nome da tabela, seu diretório, seu esquema e executar restrições exclusivas nas colunas da tabela. Agora, estamos usando o nome da tabela de funcionários agora.
Anotações @id e @GeneratedValue:
Cada entidade Bean terá uma chave primária anotada na anotação @id da classe. A chave primária pode ser um único campo ou uma combinação de vários campos de acordo com a estrutura da tabela.
Por padrão, a anotação @ID determina automaticamente a estratégia de geração de chaves primárias mais apropriada a ser usada, mas pode ser usada aplicando a anotação @GeneratedValue, que aceita dois parâmetros, estratégia e gerador, para não ser discutido aqui, basta usar a estratégia de geração de chave padrão. Deixe o Hibernate determinar o tipo de gerador a ser usado para tornar a portabilidade do código entre diferentes bancos de dados.
@Column Anotation:
A anotação @column é usada para especificar os detalhes da coluna para um campo ou propriedade que será mapeada. As seguintes propriedades mais usadas podem ser anotadas usando colunas:
O atributo de nome permite especificar explicitamente o nome da coluna.
A propriedade Length permite mapear o tamanho de uma coluna que é especialmente para um valor de string.
A propriedade anulável permite que a coluna seja marcada não ao gerar o esquema.
A propriedade exclusiva permite colunas marcadas como contendo apenas valores exclusivos.
Crie uma classe de aplicativo:
Por fim, criaremos o método principal () da classe de aplicativo para executar o aplicativo. Usaremos este aplicativo para salvar alguns registros de funcionários e, em seguida, solicitaremos registros nas operações da CRUD.
importar java.util.list; importar java.util.date; importar java.util.iterator; importar org.hibernate.hibernateException; importar org.hibernate.session; importar org.hibernate.transaction; importar org.hibernate.cfg.annotationConfiguration; importar org.hibernate.sessionFactory; importar org.hibernate.cfg.configuration; classe pública gerencia o empregado {private static sessformactory; public static void main (string [] args) {try {factory = new AnoTationConfiguration (). configure (). //addpackage("com.xyz ") // Adicionar pacote, se usado. addannotatedclass (funcionário.class). buildSessionFactory (); } Catch (ex -throwable ex) {System.err.println ("Falha ao criar o objeto SessionFactory." + Ex); lançar uma nova excepçãoininitializerError (ex); } Gerencia o empregado eu = new ManageEmployee (); / * Adicione poucos registros de funcionários no banco de dados */ inteiro empid1 = me.addemployee ("zara", "ali", 1000); Inteiro empid2 = me.addemployee ("Daisy", "Das", 5000); Inteiro empid3 = me.addemployee ("John", "Paul", 10000); / * Liste todos os funcionários */ me.listemployee (); / * Atualize os registros do funcionário */ me.UpdateEmployee (empid1, 5000); / * Exclua um funcionário do banco de dados */ me.deleteemployee (empid2); / * Liste a nova lista dos funcionários */ me.listemployee (); } / * Método para criar um funcionário no banco de dados * / public integer addEmployee (string fname, string lname, int salário) {session session = factory.openssion (); Transação tx = nulo; Inteiro funcionárioID = nulo; tente {tx = session.begIntransaction (); Funcionário funcionário funcionário = new funcionário (); funcionário.setFirstName (fname); funcionário.setLastName (lname); funcionário.SetSalary (salário); empregado = (inteiro) session.save (funcionário); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } retornar o funcionárioID; } / * Método para ler todos os funcionários * / public void listemployees () {session session = Factory.opensssion (); Transação tx = nulo; tente {tx = session.begIntransaction (); Listar funcionários = session.createquery ("do funcionário"). List (); for (iterator iterator = funcionário.iterator (); iterator.hasnext ();) {funcionário = (funcionário) iterator.next (); System.out.print ("primeiro nome:" + funcionário.getfirstname ()); System.out.print ("Sobrenome:" + Employee.getLastName ()); System.out.println ("Salário:" + Employee.getSalary ()); } tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para atualizar o salário para um funcionário * / public void updateEmployee (número inteiro, salário int) {sessão session = factory.openssession (); Transação tx = nulo; tente {tx = session.begIntransaction (); Funcionário funcionário funcionário = (funcionário) session.get (funcionário.class, funcionário); funcionário.SetSalary (salário); session.Update (funcionário); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para excluir um funcionário dos registros * / public void DeLeteemployee (Integer Funcionário) {session Session = Factory.openssession (); Transação tx = nulo; tente {tx = session.begIntransaction (); Funcionário funcionário funcionário = (funcionário) session.get (funcionário.class, funcionário); session.Delete (funcionário); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }}} Configuração do banco de dados:
Agora, vamos criar um arquivo de configuração hibernate.cfg.xml para definir os parâmetros relevantes do banco de dados.
<? xml versão = "1.0" coding = "utf-8"?> <! Doctype Hibernate-Configuration System "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd" [Hibernate-configuration> <fssactory-figuration-3.0.dtd "Hibernate-Conacturation> <fssactory> org.hibernate.dialect.mysqldialect </property> <propriedade name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <!-assume que os alunos são o nome do banco de dados-> <names name "hibernate.connection.url"> name = "hibernate.connection.username"> root </propriedade> <propriedade name = "hibernate.connection.password"> cohondob </ouse>
Compilar e executar:
Aqui estão as etapas para compilar e executar o aplicativo acima. Verifique se o caminho e o caminho de classe estão definidos adequadamente antes de compilar e executar.
Remova o arquivo de mapeamento de funcionários.hbm.xml do caminho.
Crie o arquivo de origem do funcionário.java, como mostrado na imagem acima e compile -o.
Crie o arquivo de origem ManageEmployee.java, como mostrado na imagem acima e compile -o.
Execute o arquivo binário gerenciador do ManageEmploy para executar o programa.
Os seguintes resultados serão obtidos e os registros estarão na tabela de funcionários.
$ java ManagerEmployee ......... várias mensagens de log serão exibidas aqui ......... Nome: Zara Sobrenome: Ali Salário: 1000 Nome: Daisy Sobrenome: Das Salário: 5000 Nome: John Sobrenome Salário: Paul Salário: 10000 Salário: Paul Salário: Zara Nome: Ali Ali
Se você verificar a tabela de funcionários, ele deve ter os seguintes registros:
mysql> selecione * de funcionário;+----+------------+-----------+--------+| id | primeiro_name | Último nome | Salário |+----+------------+-----------+--------+| 29 | Zara | Ali | 5000 || 31 | John | Paul | 10000 |+----+------------+-----------+--------+2 linhas no conjunto (0,00 segmysql>
cache
O cache é sobre a otimização de desempenho do aplicativo e está localizado entre o aplicativo e o banco de dados para evitar vários acessos ao banco de dados e permitir que aplicativos críticos de desempenho tenham melhor desempenho.
O cache é importante para o hibernato e adota um esquema de cache de vários níveis descrito abaixo:
Cache de Nível 1:
O cache de primeiro nível é o cache da sessão, que é um cache obrigatório, e todas as solicitações através dele devem ser passadas. Os objetos de sessão estão sendo constantemente sendo alimentados por objetos antes de enviá -los para o banco de dados.
Se várias atualizações forem emitidas, o Hibernate tenta atrasar as atualizações pelo maior tempo possível para reduzir o número de atualizações emitidas por instruções SQL. Se você fechar a sessão, todos os objetos em cache serão perdidos, persistentes ou atualizados no banco de dados.
Cache de Nível 2:
O cache do nível 2 é opcional e o cache de nível 1 que sempre será procurado antes de qualquer tentativa de encontrar o cache de nível 2 de um objeto. O cache do segundo nível pode ser configurado por classe e por categoria, principalmente responsável pelos objetos em cache na sessão.
Qualquer cache de terceiros pode usar o Hibernate. A interface org.hibernate.cache.cacheprovider fornece e é necessário implementar uma implementação de cache de manipulação para fornecer hibernado.
Cache de nível de consulta:
O Hibernate também implementa a rígida integração do conjunto de resultados de consulta e cache de nível 2.
Esse é um recurso opcional que requer dois caches físicos adicionais para salvar os resultados e regiões da consulta em cache quando uma tabela é atualizada pela última vez. Isso é muito útil para consultas que geralmente são executadas com os mesmos parâmetros.
Cache de Nível 2:
O Hibernate usa o cache do nível 1, por padrão, você não faz nada com o cache do nível 1. Vamos direto para o cache opcional de segundo nível. Nem todas as classes se beneficiam do cache, por isso é importante desativar o cache do nível 2.
O cache do nível 2 do Hibernate é definido para duas etapas. Primeiro, você deve decidir qual estratégia de simultaneidade usar. Depois disso, você pode configurar a expiração do cache e usar o cache para fornecer atributos de cache físico.
Estratégia de simultaneidade:
Uma política de simultaneidade é um mediador responsável por armazenar itens de dados no cache e recuperá -los do cache. Se você deseja ativar o cache de nível 2, precisará decidir qual política de simultaneidade de cache usar para cada classe e coleta persistente.
Transacional: o uso dessa estratégia para ler principalmente dados para evitar transações simultâneas de dados desatualizados é fundamental em casos raros de atualizações.
LEAD-WRITE: Novamente usando essa estratégia, a leitura principal dos dados é fundamental para impedir que as transações simultâneas de dados obsoletos em casos raros de atualizações.
NONSTRITT-LEIT-WRITE: Essa estratégia não garante consistência entre cache e banco de dados. Com essa estratégia, a chave não é prestar atenção se os dados raramente são alterados e a possibilidade de dados obsoletos deve ser obsoleto.
Somente leitura: a política de simultaneidade é adequada para dados e nunca mudará. Os dados utilizados são apenas para referência.
Se quisermos usar o cache de segundo nível como nossa classe de funcionários, vamos adicionar os elementos de mapeamento necessários para dizer ao Hibernate para usar uma política de cache legível e escrita para instâncias dos funcionários.
<? xml versão = "1.0" coding = "utf-8"?> <! <meta attribute = "classe-descrição"> Esta classe contém os detalhes do funcionário. </meta> <cache usage = "read-write"/> <id name = "id" type = "int" column = "id"> <generator/> </id> <propriedades name = "primeironame" column = "primeiro_name" type = "string"/> (name) type = "int"/> </class> </hibernate-mapping>
A propriedade USAGE = "READ-WRITE" diz ao Hibernate para usar um cache definido por uma política de simultaneidade de leitura e gravação.
Provedor de cache:
Depois de considerar a política de simultaneidade da sua classe de candidatos ao cache, a próxima etapa é selecionar um provedor de cache. Forças de hibernato Selecionando um cache para servir o aplicativo inteiro.
Cache fornecido no arquivo de configuração Hibernate.cfg.xml especificado. Selecione Ehcache como o provedor de cache de segundo nível:
<? xml versão = "1.0" coding = "utf-8"?> <! Doctype Hibernate-Configuration System "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd" [Hibernate-configuration> <fssactory-figuration-3.0.dtd "Hibernate-Conacturation> <fssactory> org.hibernate.dialect.mysqldialect </property> <propriedade name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <!-assume que os alunos são o nome do banco de dados-> <names name "hibernate.connection.url"> name = "hibernate.connection.username"> root </propriedade> <propriedade name = "hibernate.connection.password"> root123 </propriedade> <propriedade name = "hibernate.cache.provider_class"> org.ibernate.cache.ehcacheprovider </propriedade> <! Resource = "Employee.hbm.xml"/> </session-factory> </Hibernate-Configuration>
Agora, você precisa especificar as propriedades da área de cache. O ehcache possui seu próprio arquivo de configuração ehcache.xml, no aplicativo no ClassPath. Em ehcache.xml, a configuração de cache da classe de funcionários pode ser assim:
<DiskStore Path = "java.io.tmpdir"/> <defaultCachemaxElementsinMemory = "1000" eternal = "false" timeToidleSeconds = "120" timeToliveSeconds = "120" Overflowtodisk = ""/> <cache name = "funcionário" maxElementsInMemory = "500" eternal = "true" timeToidleSeconds = "0" timeToliveSeconds = "0" overflowTodisk = "false"/>
É isso, agora ative o cache secundário da classe dos funcionários e o Hibernate agora têm o cache secundário, sempre que navegar para um funcionário ou quando o funcionário é carregado por um identificador.
Você deve analisar todas as suas classes e selecionar a estratégia de cache apropriada para cada classe. Às vezes, o cache secundário pode degradar o desempenho do aplicativo. Por isso, é recomendado para o aplicativo de referência que não permite o cache pela primeira vez, o que é muito adequado para o desempenho em cache e verificação. Se o cache não melhorar o desempenho do sistema, não faz sentido fazer qualquer tipo de cache.
Cache de nível de consulta:
Usando o cache de consulta, ele deve ser ativado primeiro no arquivo de configuração da propriedade hibernate.cache.use_query_cache = "true". Se esta propriedade estiver definida como true, deixe o Hibernate criar o cache necessário na memória para salvar o conjunto de consultas e identificadores.
Em seguida, usando o Cache de consulta, você pode usar o método SetCachable (booleano) da classe de consulta. Por exemplo:
O Hibernate também suporta suporte de cache de granulação muito fino através do conceito de uma área de cache. O cache faz parte do cache com um nome.
Este código usa um método para informar a Hibernate para armazenar e encontrar consultas sobre funcionários no cache.