A principal pesquisa deste artigo é o conteúdo relevante da consulta HQL de hibernato, como segue.
O Hibernate Query Language (HQL) é uma declaração de consulta completamente orientada a objetos com funções de consulta muito poderosas; Possui polimorfismo, associação e outras características. A consulta HQL também é o método de consulta oficialmente recomendado pelo Hibernate.
Em seguida, analisamos os métodos de consulta relevantes por meio de um estudo de caso
Classes.java:
Classes de classe pública {/*classe ID*/private int id;/*Nome da classe*/Nome da sequência privada;/*Relacionamento entre a classe e os alunos*/Conjunto privado <estudante> alunos; // omitir métodos de setter e getter}Estudante.java:
Public Class Student {/*ID do aluno*/Private Int ID;/*Nome do aluno*/Nome da sequência privada;/*Relacionamento entre estudantes e aula*/aulas particulares aulas; // omita Métodos de Setter e Getter}Classes.hbm.xml:
<? xml versão = "1.0"?> <! Doctype hibernate-mapping public "-// hibernate/hibernate mapeando dtd 3.0 // pt" "http://hibernate.sourceforge.net/hibernate name = "Classes" tabela = "t_classes" lazy = "false"> <id name = "id"> <generator/generator/> </id> <propriedade name = "name"/> <!-One-to-gany mapeando, inverse = "true" significa de mãos dadas ao par de colunos-> <sett = "estudantes" em "" </set> </s class> </ hibernate-mapping>
Student.hbm.xml:
<? xml versão = "1.0"?> <! Doctype hibernate-mapping public "-// hibernate/hibernate mapeando dtd 3.0 // pt" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibermate-mapping.netge.net/hibernate tabela = "t_student"> <id name = "id"> <generator // id> <!-mapear propriedades normais-> <propriedade name = "name"/> <!-mapeamento de muitos para one, adicione uma chave estranha ao fim múltiplo-> <many-one name = "classes" column = "clasesid"/> </class> </hibern
/*Retorne a lista de atributos do conjunto de resultados, o tipo de elemento e os tipos de atributo na classe de entidade são os mesmos*/ list <tring> alunos = session.createquery ("selecione nome do aluno"). List (); /*Travel*/ for (iterator <string> iter = student.iterator (); iter.hasnext ();) {string name = (string) iter.next (); System.out.println (nome); }Nota: Ao consultar um único atributo, o conjunto retornado é uma coleção e o tipo do elemento de coleta é o tipo de atributo.
/*Consulta múltiplas propriedades, retornando uma matriz de objeto*/ list <object []> alunos = session.createquery ("Selecione ID, nome do aluno"). List (); /*Transip*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }NOTA: Consultando vários atributos retorna uma coleção de matrizes de objetos de tipo. Isso é fácil de entender. Ao consultar um único atributo é o tipo de elemento de coleção retornado, é o tipo de atributo, mas e os vários tipos? Isso deve ser uma matriz de objetos para processar, ou seja, objeto [].
/*Definimos o construtor correspondente para o objeto da entidade e, em seguida, podemos retornar uma coleção de tipos de objeto de entidade, consultando o objeto*/ listar alunos = session.createquery ("selecione novo aluno (id, nome) do aluno"). List (); /*Travel*/ for (iterator iter = student.iterator (); iter.hasnext ();) {Student = (aluno) iter.next (); System.out.println (Student.getId () + "," + Student.getName ()); }Nota: Além do segundo método, retornamos uma matriz de objetos, também podemos definir o construtor correspondente para o objeto da entidade e, em seguida, consultar o objeto, consultando o objeto e, em seguida, retornam uma coleção de tipos de entidade.
/*Aliases podem ser usados*/ list <object []> alunos = session.createquery ("Selecione s.id, s.name FROM student s"). List (); /*Transip*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); } /*Return é uma coleção de tipos de objetos de entidade*/ list <estudante> alunos = session.createquery ("do aluno"). List (); /*Transip*/ for (iterator <vertudy> iter = student.iterator (); iter.hasnext ();) {estudante estudante = (aluno) iter.next (); System.out.println (Student.getName ()); }Nota: As entidades de consulta podem usar diretamente o formulário do nome da classe.
/*Use Selecionar para usar o Alias*/ List <veryd> alunos = session.CreateQuery ("Selecione S de Student S"). List (); /*Transip*/ for (iterator <vertudy> iter = student.iterator (); iter.hasnext ();) {estudante estudante = (aluno) iter.next (); System.out.println (Student.getName ()); }NOTA: Se você deseja usar a palavra -chave Selecionar, deve usar um alias. Outro ponto deve ser observado: o HQL não suporta a forma de seleção *.
/** * If you use list to query the entity object, a query statement will be issued to obtain the entity object data* * Hibernate: select student0_.id as id0_, student0_.name as name0_, * student0_.createTime as createTime0_, student0_.classesid as classesid0_ * from t_student student0_ */ List<Student> students = session.createQuery("from Aluno "). List (); /*Travel*/ for (iterator <estudante> iter = estudante.iterator (); iter.hasnext ();) {Student = (aluno) iter.Next (); System.out.println (Student.getName ()); }Nota: Ao usar o método .list () para consultar objetos, apenas uma instrução será emitida, ou seja, uma declaração que obtém os dados do objeto físico.
/*** O problema n+1 ocorrerá. O chamado n+1 refere-se à emissão de N+1 STSTIAÇÕES SQL * * 1: emitindo uma declaração que consulta a lista de identificação * Hibernate: selecione Student0_.id como col_0_0_ de t_student student0_ * * n: emitindo n sql declarações baseadas no id para carregar o objeto relevante * hibranTe: * student0_.createTime como createTime0_0_, student0_.classeSesid como classisid0_0_ * de t_student student0_ where student0_.id =? * */ Iterator <estudante> iter = session.CreateQuery ("do aluno"). Iteate (); /*Travel*/ while (iter.hasNext ()) {Student Student = (Student) iter.Next (); System.out.println (Student.getName ()); }Nota: Ao executar a consulta de objeto através do iterador (), as instruções N+1 serão emitidas. Primeiro, uma declaração será emitida para consultar o ID do objeto da entidade e, em seguida, as instruções N serão emitidas com base em seus respectivos IDs para consultar os objetos. O desempenho formal é relativamente ruim.
/*Armazenando a coleção consultada no cache de primeiro nível, ou seja, cache no nível da sessão*/ list <estudante> alunos = session.createquery ("do aluno"). List (); /*Transip*/ for (iterator <vertudy> iter = student.iterator (); iter.hasnext ();) {estudante estudante = (aluno) iter.next (); System.out.println (Student.getName ()); } System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Avoid N+1 problem* * Because after performing the list operation, the data will be placed in the session cache (first-level cache), when using iterate, * First, a statement querying the id list will be issued, and then the corresponding data will be loaded in the cache according to the id. If there is data matching it in the cache*, no SQL statements querying based on the id will be issued, and the data in the cache will be directly used * * The Iterate method If there is data in the Cache, ele pode melhorar o desempenho, caso contrário, o problema 1**/ iteradorNota: De fato, o Hibernate fornece consulta iterator () para melhorar o desempenho, então por que isso ajuda muito? O motivo é que o iterator () busca dados do cache de primeiro nível. Se houver dados no cache, sua eficiência será, sem dúvida, bastante poderosa. No entanto, quando eu pergunta pela primeira vez, como poderia haver dados no cache? Isso leva ao chamado problema n+1. O código acima pode evitar o problema n+1. Sua idéia é usar a lista () primeiro a consultar, porque após a consulta da lista (), os dados existem no resumo do cache de primeiro nível e, ao usar o iterator (), a eficiência será muito alta.
/*Consulta de acordo com as condições (os alias são geralmente usados aqui, o que é mais conveniente)*/ list <objeto []> alunos = session.createquery ("selecione s.id, s.name entre os alunos onde s.name como '%0%'"). Lista (); /*Travel*/ for (iterator <object []> iter = student.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: A consulta condicional é a mesma que o SQL nativo, ambos onde as palavras -chave. Além disso, geralmente é mais conveniente usar alias. O programa acima é consultar vários atributos, para que retorne uma coleção de tipos de matriz de objetos e os elementos da matriz de objetos são os atributos correspondentes.
/*Programação Chenged*/ list <object []> alunos = session.createQuery ("Selecione S.id, s.name FROM Student s Where s.name gosta?") .SetParameter (0, "%0%") .list (); /*Travel*/ for (iterator <object []> iter = student.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }NOTA: Os parâmetros podem ser passados através de espaços reservados, o que pode impedir a injeção de SQL.
/*Programação de chip*/ list <object []> alunos = session.createquery ("selecione s.id, s.name do aluno s where s.name como: myName") .setParameter ("myname", "%0%") .list (); /*Matriz de objeto*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: Como: não há espaço após o cólon MyName, caso contrário, ocorrerá um erro.
[Java] Ver Plain Copy/ * Adote o método IN, apenas um parâmetro formal pode ser usado */ list <object []> alunos = session.CreateQuery ("Selecione S.Id, s.name entre os alunos em que s.id in (: ids)") .setParameterList ("IDS", novo objeto [] {1, 2, 3, 4, 5). /*Transip*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: Existe apenas um parâmetro formal nos colchetes após a entrada. Quando definimos o valor do parâmetro, podemos passar o valor através da matriz de objetos.
/* Query estudantes em 2009-08, você pode ligar para a função de formatação de data do MySQL*/ list <object []> alunos = session.CreateQuery ("Selecione s.id, s.name entre os alunos onde o date_format (s.CreateTime, '%y-%m') =?") .Setameter (0, "2009-08". /*Travel*/ for (iterator <object []> iter = student.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); } SimpledateFormat sdf = new SimpleDateFormat ("AAAA-MM-DD HH: MM: SS"); /*Os alunos de 2009-08-01 a 2009-08-20 podem ligar para a função de formatação de data do MySQL*/ list <object []> alunos = session.createquiery ("Selecione s.id, s.name do aluno s) onde o s.createTime entre? E?") .SetParameter (0, sdf.Parse ("2009-08. sdf.parse ("2009-08-20 23:59:59")) .list (); /*Transip*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); } / * Use Selecionar * Você deve usar as instruções SQL originais e é semelhante à consulta de várias propriedades HQL, para retornar uma coleção de tipos de matriz de objetos */ list <object []> alunos = session.createsqlquery ("selecione * de t_student"). List (); /*Transip*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }NOTA: O HQL não suporta a forma de consulta de selecionar *, mas o Hibernate suporta instruções SQL originais. Podemos usar instruções SQL para consultar. Além disso, é semelhante aos atributos múltiplos de consulta do HQL, por isso retorna uma coleção de tipos de matriz de objetos.
/*Consulta de página, setFirstresult (1) significa a partir dos primeiros dados; setMaxResult (2) significa que 2 dados são exibidos por página*/ List os alunos = session.CreateQuery ("do aluno") .SetFirstResult (1) .SetMaxResults (2) .List (); /*Travel*/ for (iterator iter = student.iterator (); iter.hasnext ();) {Student = (aluno) iter.next (); System.out.println (Student.getName ()); } /*Consulta de navegação, s.classes.name Navegue de aluno para aula na aula (isso está navegando de mais fim para menos final, o que também é possível)*/ list <estudante> alunos = session.createquery ("dos alunos onde s.classes.name como '%2%'") .list (); /*Travel*/ for (iterator <estudante> iter = estudante.iterator (); iter.hasnext ();) {Student = (aluno) iter.Next (); System.out.println (Student.getName ()); }NOTA: O S.Classes.name na declaração de consulta acima é obter o nome da classe da navegação do aluno para as classes da classe. Você também pode navegar no contrário: navegue de aula para o aluno para obter um determinado atributo. Além disso, a declaração de consulta no programa significa consultar todos os alunos com 2 no nome da aula.
/ *Conexão interna, basta usar a palavra -chave de junção */ list <object []> alunos = session.createquery ("Selecione c.name, s.name da junta do aluno s.classes c") .list (); /*Transação*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }NOTA: A palavra -chave na conexão interna é ingressada e a conexão ainda é feita usando alias e navegação. A declaração de consulta acima significa: Consulte o nome da aula e o nome do aluno da tabela e da tabela de aula do aluno (conexão interna significa que deve haver atributos dignos na consulta, como nenhuma aula ou nenhum aluno ou alunos não pode consultar sem aulas).
/*A junção esquerda usa palavras -chave à esquerda JONE*/ LIST <Object []> alunos = session.createquery ("Selecione c.name, s.name da parte esquerda do aluno. /*Transip*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }NOTA: A palavra -chave usada para a junção esquerda é deixada de junção. A declaração de consulta acima significa: Da tabela de estudantes e aula, consulte o nome da aula e o nome do aluno. Por ser conectado à esquerda, os alunos sem aula também serão consultados.
[Java] Ver Plain Cópia/*A palavra -chave de junção direita é correta*/ list <object []> alunos = session.createQuery ("Selecione c.name, s.name da junção direita do aluno S.Classes C") .List (); /*Transip*/ for (iterator <object []> iter = estudantes.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: A palavra -chave usando a junção correta é a junção correta. A declaração de consulta acima significa: Da tabela de estudantes e aula, consulte o nome da aula e o nome do aluno. Por ser uma direita, as aulas sem estudantes serão consultadas.
Long count = (long) session.createquery ("Selecione contagem (*) do aluno"). UnikeResult ();Nota: Somente consultas estatísticas podem ser usadas no HQL com *. UnikeResult () significa que existe apenas um conjunto de resultados e o tipo de retorno longo.
/*Declaração de consulta*/ string hql = "Selecione c.name, contagem (s) das classes c junte -se ao grupo c.Students s por c.name Order by c.name"; List <object []> alunos = session.createquery (HQL) .list (); /*Travel*/ for (int i = 0; i <estudantes.size (); i ++) {object [] obj = (objeto []) estudantes.get (i); System.out.println (obj [0] + "," + obj [1]); }Nota: HQL também suporta agrupamento, classificação, etc. A declaração acima significa: Consulte o nome de cada classe e consulte o número de estudantes em cada aula, grupo por nome de classe, classificar por nome de classe
O exposto acima é sobre o exemplo do código de consulta HBernate HQL neste artigo, espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!