La principal investigación en este artículo es el contenido relevante de la consulta HQL Hibernate, como sigue.
El lenguaje de consultas Hibernate (HQL) es una declaración de consulta completamente orientada a objetos con funciones de consulta muy potentes; Tiene polimorfismo, asociación y otras características. La consulta HQL también es el método de consulta recomendado oficialmente por Hibernate.
A continuación, analizamos los métodos de consulta relevantes a través de un estudio de caso
Classes.java:
clases de clase pública {/*class id*/private int id;/*nombre de clase*/name de cadena privada;/*relación entre clase y estudiantes*/set privado <estudiante> estudiantes; // omitir los métodos de setter y getter}Student.java:
Estudiante de clase pública {/*estudiante id*/private int id;/*nombre de estudiante*/name de cadena privada;/*relación entre estudiantes y clases*/clases privadas; // omitir los métodos setter y getter}Classes.hbm.xml:
<? xml versión = "1.0"?> < <class name = "classes" table = "t_classes" lazy = "false"> <id name = "id"> <generador/generador/> </id> <propiedad name = "name"/> <!-One-to-many mapping, inverse = "true" verdadero para entregar la relación a la pareja-> <name de set = "estudiantes" inverse = "verdadero"> <play columna = "columna =" classid "/"/" </set> </sclass> </ Hibernate Mapping>
Estudiante.hbm.xml:
<? xml versión = "1.0"?> < table = "t_student"> <id name = "id"> <generador // id> <!-Map Propiedades normales-> <propiedad name = "name"/> <!-Mappes de muchos a uno, agregue una clave extranjera al final múltiple-> <muchos a uno name = "classes" column = "classesid"/> </sclass> </bercernate-mapping>
/*Devuelve la lista de atributos de conjunto de resultados, el tipo de elemento y los tipos de atributos en la clase de entidad son los mismos*/ list <string> sesions = session.createQuery ("Seleccione el nombre del estudiante"). LIST (); /*Viajar*/ for (iterator <String> iter = students.iterator (); iter.hasNext ();) {string name = (string) iter.next (); System.out.println (nombre); }Nota: Al consultar un solo atributo, el conjunto devuelto es una colección, y el tipo de elemento de colección es el tipo de atributo.
/*Consulta múltiples propiedades, devolviendo una matriz de objetos*/ list <object []> sesions = session.createQuery ("Seleccione ID, nombre del estudiante"). List (); /*Transip*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: Consulta de múltiples atributos Devuelve una colección de matrices de objetos de tipo. Esto es fácil de entender. Al consultar un solo atributo es el tipo de elemento de colección devuelto, es el tipo de atributo, pero ¿qué pasa con múltiples tipos? Esa debe ser una matriz de objetos para procesar, es decir, objeto [].
/*Establecimos el constructor correspondiente para el objeto Entity, y luego podemos devolver una colección de tipos de objetos de entidad consultando el objeto*/ list Students = session.createQuery ("Seleccione nuevo estudiante (id, nombre) del estudiante"). LIST (); /*Viajar*/ para (iterator iterator = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getid () + "," + student.getName ()); }Nota: Además del segundo método, devolvemos una matriz de objetos, también podemos establecer el constructor correspondiente para el objeto de entidad, y luego consultar el objeto consultando el objeto y luego devolver una colección de tipos de entidad.
/*Los alias se pueden usar*/ List <Object []> Students = Session.CreateQuery ("Seleccione S.ID, S.Name del Estudiante S"). List (); /*Transip*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); } /*Return es una colección de tipos de objetos de entidad*/ list <deuding> students = session.createQuery ("del estudiante"). List (); /*Transip*/ for (iterator <entudent> iter = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getName ()); }Nota: Las entidades de consulta pueden usar directamente el formulario del nombre de clase.
/*Use Seleccionar para usar alias*/ list <deuding> students = session.createQuery ("Seleccione S de Student s"). List (); /*Transip*/ for (iterator <entudent> iter = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getName ()); }Nota: Si desea usar la palabra clave SELECT, debe usar un alias. Se debe tener en cuenta otro punto: HQL no admite la forma de SELECT *.
/ ** * Si utiliza la lista para consultar el objeto Entity, se emitirá una instrucción de consulta para obtener los datos del objeto de la entidad * * Hibernate: seleccione Student0_.id como id0_, student0_.name as name0_, * student0_.createtime as createTime0_, student0_.classesid como classesid0_ * from t_student0_ */ list <sion session. Estudiante "). List (); /*Viajar*/ para (iterator <deude> iter = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getName ()); }Nota: Cuando se usa el método .list () para consultar objetos, solo se emitirá una declaración, es decir, una declaración que obtiene los datos de objetos físicos.
/*** El problema N+1 ocurrirá. El llamado N+1 se refiere a emitir n+1 declaraciones SQL * * 1: emitir una declaración que consulte la lista de identificación * Hibernate: Seleccione Student0_.id como col_0_0_ Desde t_student student0_ * * n: emisión n declaraciones sql basadas en la identificación para cargar el objeto correspondiente * Hibernate: Seleccione Student0_.id como ID0_0_, stement0_. student0_.creatEtime como createTime0_0_, student0_.classesid como classisid0_0_ * de t_student student0_ donde student0_.id =? * */ Iterator <estudiante> iter = session.createQuery ("del estudiante"). Iterate (); /*Viajar*/ while (iter.hasnext ()) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getName ()); }Nota: Al realizar la consulta de objetos a través de Iterator (), se emitirán las declaraciones N+1. Primero, se emitirá una declaración para consultar la identificación del objeto de entidad, y luego se emitirán n declaraciones en función de sus respectivos ID para consultar n objetos. El rendimiento formal es relativamente pobre.
/*Almacenamiento de la colección consultada en el caché de primer nivel, es decir, caché de nivel de sesión*/ List <Student> Students = Session.CreateQuery ("De Student"). List (); /*Transip*/ for (iterator <entudent> iter = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getName ()); } System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Avoid N+1 problem* * Because after performing La operación de la lista, los datos se colocarán en la memoria caché de la sesión (caché de primer nivel), cuando se use iterate, * primero, se emitirá una consulta de instrucción la lista de identificación, y luego se emitirán los datos correspondientes en el caché de acuerdo con la identificación de datos que coinciden en el caché *, no hay estados de SQL en base a la ID de la identificación. Cache, puede mejorar el rendimiento, de lo contrario, ocurrirá el problema de N+1**/ iterator <deuding> itere = session.createQuery ("de Student"). ITere ();Nota: De hecho, Hibernate proporciona la consulta Iterator () para mejorar el rendimiento, entonces, ¿por qué ayuda demasiado? La razón es que Iterator () obtiene datos del caché de primer nivel. Si hay datos en el caché, su eficiencia será sin duda bastante poderosa. Sin embargo, cuando consulto la primera vez, ¿cómo podría haber datos en el caché? Esto lleva al llamado problema N+1. El código anterior puede evitar el problema N+1. Su idea es usar list () primero para consultar, porque después de la lista () se consulta, los datos existe en el resumen de caché de primer nivel, y cuando se usa iterator (), la eficiencia será muy alta.
/*Consulta de acuerdo con las condiciones (los alias generalmente se usan aquí, lo cual es más conveniente)*/ List <Object []> Students = Session.CreateQuery ("Seleccione S.ID, S.Name de Student s donde S.Name Like '%0%'"). List (); /*Viajar*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: La consulta condicional es la misma que SQL nativa, los cuales están donde las palabras clave. Además, generalmente es más conveniente usar alias. El programa anterior es consultar múltiples atributos, por lo que devuelve una colección de tipos de matriz de objetos, y los elementos en la matriz de objetos son los atributos correspondientes.
/*Programación Chenged*/ List <Object []> Students = Session.CreateQuery ("Seleccione S.ID, S.Name de Student s ¿Dónde?") .SetParameter (0, "%0%") .List (); /*Viajar*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: Los parámetros se pueden pasar a través de marcadores de posición, lo que puede evitar la inyección de SQL.
/*Programación de chip*/ List <Object []> Students = Session.CreateQuery ("Seleccione S.ID, S.Name de Student S donde S.Name Like: MyName") .SetParameter ("myName", "%0%") .list (); /*Array de objeto*/ for (iterator <object []> iter = standers.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: Me gusta: No hay espacio después del colon Myname, de lo contrario ocurrirá un error.
[Java] Ver copia simple/ * adopta el método in, solo se puede usar un parámetro formal */ list <object [] estudiantes = session.createQuery ("Seleccione s.id, s.name del estudiante s donde s.id en (: ids)") .SetParameterList ("ids", nuevo objeto [] {1, 2, 3, 4, 5}) .list ();); /*Transip*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: Solo hay un parámetro formal en los soportes después de In. Cuando establecemos el valor del parámetro, podemos pasar el valor a través de la matriz de objeto.
/* Consulta a los estudiantes En 2009-08, puede llamar a la fecha de formateo de la fecha de MySQL function*/ list <object []> sesions = session.createQuery ("Seleccione s.id, s.name de Student s where date_format (s.createTime, '%y-%m') =?") .SetParameter (0, 2009-08 ") .list ();; /*Viajar*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); } SimpleDateFormat sdf = new SimpleDateFormat ("yyyy-mm-dd hh: mm: ss"); /*Estudiantes de 2009-08-01 a 2009-08-20 pueden llamar a la fecha de formateo de la fecha de MySQL*/ list <object []> estudiantes = session.createQuery ("Seleccione s.id, s.name de Student s donde s.createTime entre? Y?") .SetParameter (0, sdf.parse ("2009-08-01 00:00:00"))). sdf.parse ("2009-08-20 23:59:59") .list (); /*Transip*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); } / * Usar SELECT * Debe usar las declaraciones SQL originales, y es similar a la consulta de HQL múltiples propiedades, por lo que devuelve una colección de tipos de matriz de objetos */ list <object []> sesions = session.CreateSQLQuery ("Seleccionar * de t_student"). LIST (); /*Transip*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: HQL no admite el formulario de consulta de SELECT *, pero Hibernate admite declaraciones SQL originales. Podemos usar declaraciones SQL para consultar. Además, es similar a los atributos múltiples de la consulta de HQL, por lo que devuelve una colección de tipos de matriz de objetos.
/*Consulta de página, setFirStresult (1) significa comenzar desde los primeros datos; setMaxResult (2) significa que se muestran 2 piezas de datos por página*/ list students = session.createQuery ("del estudiante") .setFirStresult (1) .setMaxResults (2) .list (); /*Viajar*/ para (iterator iterator = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getName ()); } /*Consulta de navegación, s.classes.ame navegue de estudiante a clase en clase (esto se está navegando de más fin a menos final, lo cual también es posible)*/ List <Student> Students = Session.CreateQuery ("de Student s donde S.Classes.Name Like '%2%'") .List (); /*Viajar*/ para (iterator <deude> iter = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println (student.getName ()); }Nota: El nombre S.Classes.Name en la instrucción de consulta anterior es obtener el nombre de la clase de la navegación del estudiante a las clases de clases. También puede navegar en reversa: navegar de clase a estudiante para obtener un cierto atributo. Además, la declaración de consulta en el programa significa consultar a todos los estudiantes con 2 en el nombre de la clase.
/ *Conexión interna, simplemente use la palabra clave unirse */ list <object []> stents = session.createQuery ("Seleccione C.Name, S.Name de Student S Joins S.Classes C") .List (); /*Transacción*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: La palabra clave en la conexión interna es unirse y la conexión aún se realiza utilizando alias y navegación. La declaración de consulta anterior significa: Consulte el nombre de clase y el nombre del alumno de la tabla de estudiantes y la tabla de clase (la conexión interna significa que debe haber atributos dignos en la consulta, como ninguna clase o que no hay estudiantes o estudiantes no pueden consultar sin clases).
/*Left Join usa la palabra clave izquierda unión*/ list <object []> students = session.createQuery ("Seleccione C.Name, S.Name de Student S Left S.Classes C") .List (); /*Transip*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }Nota: La palabra clave utilizada para la unión izquierda es la unión de la izquierda. La declaración de consulta anterior significa: desde la tabla de estudiantes y de clase, consulte el nombre de clase y el nombre del estudiante. Debido a que es un conectado a la izquierda, los estudiantes sin clase también serán consultados.
[java] Ver copia simple/*La palabra clave de unión derecha es correcta unión*/ list <object []> sesions = session.createQuery ("Seleccione C.Name, S.Name desde el Estudiante S Right S.Classes C") .List (); /*Transip*/ for (iterator <object []> iter = students.iterator (); iter.hasnext ();) {object [] obj = (object []) iter.next (); System.out.println (obj [0] + "," + obj [1]); }NOTA: La palabra clave que usa la unión correcta es una unión correcta. La declaración de consulta anterior significa: desde la tabla de estudiantes y de clase, consulte el nombre de clase y el nombre del estudiante. Debido a que es una conexión a la derecha, se consultarán clases sin estudiantes.
Long Count = (Long) session.CreateQuery ("Seleccione recuento (*) del estudiante"). Uniqueresult ();Nota: Solo se pueden usar consultas estadísticas en HQL con *. Uniqueresult () significa que solo hay un conjunto de resultados y el tipo de devolución largo.
/*Declaración de consulta*/ String hql = "Seleccione C.Name, Count (s) de las clases C unirse a C. Estudentes S Grupo por C.Name Order by C.Name"; Lista <Object []> Students = Session.CreateQuery (HQL) .List (); /*Viajar*/ for (int i = 0; i <standers.size (); i ++) {object [] obj = (object []) students.get (i); System.out.println (obj [0] + "," + obj [1]); }Nota: HQL también admite la agrupación, clasificación, etc. La declaración anterior significa: Consulte el nombre de cada clase y consulte el número de estudiantes en cada clase, grupo por nombre de clase, ordenado por nombre de clase
Lo anterior se trata del ejemplo del código de consulta HQL Hibernate en este artículo, espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!