Hibernate 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:
Sessão session = sessionFactory.opensssion (); Query Query = session.createquery ("de funcionário"); query.setcacheable (true); list os usuários = query.list (); sessionFactory.Clossession ();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.
Sessão session = sessionFactory.opensssion (); Query Query = session.createquery ("de funcionário"); query.setCacheable (true); query.setcacheregion ("funcionário"); listar usuários = query.list (); sessionFactory.closession ();Este código usa um método para informar a Hibernate para armazenar e encontrar consultas sobre funcionários no cache.
Hibernate SQL nativo
Você pode usar o SQL nativo para expressar consultas de banco de dados. Se você deseja usar funções específicas do banco de dados, como solicitações de consulta ou conectar palavras-chave no Oracle. Hibernate3.x permite o uso de instruções SQL manuscritas, incluindo procedimentos armazenados, todas as operações de criação, atualização, exclusão e carga.
O aplicativo criará uma consulta SQL nativa (na interface da sessão) a partir da sessão CreateSqlQuery () Método:
Public SqlQuery CreateSqlQuery (String SQLString) lança HibernateException
Ao passar uma consulta SQL para o método CreateSqlQuery (), você pode usar o método AddEntity () associado a qualquer entidade de hibernato existente, ou a um resultado escalar usando o método Addentity (), AddJoin () e Addscalar ().
Consulta escalar:
A consulta SQL mais básica é obter uma lista de escalares (valores numéricos) de uma ou mais tabelas. Aqui estão os valores da sintaxe usando os escalares nativos do SQL:
String sql = "Selecione First_Name, salário do funcionário"; SQLQLQUERY query = session.createsqlquery (sql); query.setResultTransformer (critério.alias_to_entity_map); list Results = query.list ();
Consulta de entidade:
As consultas acima todos retornam os valores escalares, ou seja, os dados "nus" retornados do ResultSet. A seguir, é apresentada a sintaxe para obter objetos de entidade como um todo da consulta SQL nativa através do método Addentity ().
String sql = "selecione * do funcionário"; sqlQuery query = session.createsqlquery (sql); query.addentity (funcionário.class); list Results = query.list ();
Nomeado SQL Query:
A seguir, é apresentada a sintaxe para obter objetos de entidade das consultas SQL nativas e usar consultas SQL nomeadas através do método addentity ().
String sql = "selecione * do funcionário onde id =: funcionário_id"; sqlquery query = session.createsqlquery (sql); query.addentity (employee.class); query.setParameter ("funcionário_id", 10); listar resultados = query.list (); Exemplo de SQL nativo:
Considere a seguinte aula de Pojo:
Public Class Funcionário {private Int ID; String privada primeiro nome; string privada stringname; salário privado int; public funcionário () {} funcionário público (string fname, string lname, int salário) {this.firstname = fname; this.LastName = lname; this.salary = salá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; }}Vamos criar a seguinte tabela de funcionários para armazenar o objeto do funcionário:
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));
O seguinte será arquivos mapeados.
<? xml versão = "1.0" coding = "utf-8"?> <! <meta attribute = "classe-descrição"> Esta classe contém os detalhes do funcionário. </meta> <id name = "id" type = "int" column = "id"> <gerator/> </id> <propriedade name = "primeironame" column = "First_name" type = "string"/> <names name = "Salary" column = "last_name" type = ""/> <names)
Por fim, criaremos o método principal () da classe de aplicativo para executar, e usaremos aplicativos de consulta SQL nativos:
importar java.util.*; importar org.hibernate.hibernateException; importar org.hibernate.session; importar org.hibernate.transaction; importar org.hibernate.SessionFactory; importar org.Hibernate.sqlQuery; importar org.hibernate.criteria; importar org.hibernate.hibernate; importação org.hibernate.cfg.configuration; classe pública ManagemEmployee {StickTactory particular; public static void main (string [] args) {try {factory = new Configuration (). Configure (). 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", 2000); Inteiro empid2 = me.addemployee ("Daisy", "Das", 5000); Inteiro empid3 = me.addemployee ("John", "Paul", 5000); Inteiro empid4 = me.addemployee ("mohd", "yasee", 3000); / * Liste os funcionários e seu salário usando a consulta escalar */ me.ListeMployeEssCalar (); / * Liste as informações completas dos funcionários usando a consulta de entidade */ me.listemployesesentity (); } / * 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 = novo funcionário (fname, lname, 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 usando consulta escalar * / public void listemployeeessCalar () {session = factory.openssession (); Transação tx = nulo; tente {tx = session.begIntransaction (); String sql = "selecione First_Name, salário do funcionário"; SqlQuery query = session.createsqlquery (sql); query.setResultTransformer (critério.alias_to_entity_map); Dados da lista = query.list (); for (objeto objeto: dados) {map linha = (map) objeto; System.out.print ("primeiro nome:" + row.get ("primeiro_name")); System.out.println (", salário:" + row.get ("salário")); } tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para ler todos os funcionários usando consulta de entidade * / public void listEmployesesentity () {Session Session = factory.openssession (); Transação tx = nulo; tente {tx = session.begIntransaction (); String sql = "selecione * do funcionário"; SqlQuery query = session.createsqlquery (sql); query.addentity (funcionário.class); Listar funcionários = query.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 (); }}} Compilar e executar:
Aqui estão as etapas para compilar e executar o aplicativo acima. Certifique -se de que o caminho e o caminho de classe sejam definidos adequadamente antes de compilar e executar.
Execute o arquivo binário gerenciador do ManageEmploy para executar o programa.
Os seguintes resultados serão obtidos e o registro será criado na tabela de funcionários.
$ java ManageEmployee
....... MOHD Sobrenome: Yasee Salário: 3000
Se você verificar a tabela de funcionários, deve registrar que ela possui:
mysql> selecione * do funcionário;
+------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------