El uso específico de Criteria en Java

Recientemente utilicé Spring e Hibernate para el desarrollo del proyecto. Creo que Criteria es más fácil de usar. El método de consulta

se puede diseñar de manera flexible para realizar consultas fácilmente según las características. Criterios de montaje condicional. Ahora resuma el uso de los Criterios de Hibernate:

A continuación se proporciona CriteriaSpecification diseñada por Hibernate como la interfaz principal de Criteria y DetachedCriteria.

La principal diferencia entre Criteria y DetachedCriteria es que el formulario de creación es diferente. Criteria está en línea, por lo que se crea mediante Hibernate Session mientras que DetachedCriteria está fuera de línea y se crea cuando

Session. no es necesario, DetachedCriteria proporciona dos métodos estáticos paraClass(Class) o forEntityName(Name)

para crear instancias de DetachedCriteria. El marco de Spring proporciona el método getHibernateTemplate

().findByCriteria(detachedCriteria), que puede devolver fácilmente resultados de consulta

basados ​​en DetachedCriteria.

Tanto Criteria como DetachedCriteria pueden usar Criterion y Projection para establecer condiciones de consulta. Puede configurar

FetchMode (el modo de consulta y recuperación conjuntas) y configurar el método de clasificación. Para Criteria, también puede configurar FlushModel

(la forma de vaciar la sesión) y LockMode (modo de bloqueo de base de datos).

El criterio y la proyección se explican en detalle a continuación.

Criterio es la condición de consulta de Criterios. Criteria proporciona el método add(criterio de criterio) para

agregar condiciones de consulta.

Las principales implementaciones de la interfaz Criterion incluyen: Ejemplo, Unión y SimpleExpresión. El uso real de

Junction son sus dos subclases, conjunción y disyunción, que utilizan operadores Y y O

respectivamente para unir el conjunto de condiciones de consulta.

Se pueden crear instancias de Criterio a través de la clase de herramienta Restricciones. Las Restricciones proporcionan una gran cantidad de métodos estáticos

, como eq (igual a), ge (mayor o igual a). ), entre, etc. Crear condiciones de consulta de criterio

(instancia de SimpleExpression).

Además, Restricciones también proporciona métodos para crear instancias de conjunción y disyunción, y agrega condiciones de consulta al método add(Criteria) de la instancia para formar un conjunto de condiciones de consulta

En cuanto a la creación de Ejemplo, el Ejemplo en sí proporciona un método estático create(Object

entity), que se crea en función de un objeto (en el uso real, generalmente es un objeto asignado a una base de datos). Luego puede establecer algunas

condiciones de filtro:

Ejemplo ejemploUsuario =Ejemplo.create(u)

.ignoreCase() // Ignorar mayúsculas y minúsculas

.enableLike(MatchMode.ANYWHERE);

// Para los atributos de tipo String, el valor coincidirá dondequiera que esté. Equivalente a %value%

El proyecto permite principalmente a Criteria realizar consultas de informes e implementar agrupaciones. El proyecto tiene principalmente tres implementaciones:

SimpleProjection, ProjectionList y Property. La creación de instancias de SimpleProjection y

ProjectionList se completa con las proyecciones integradas. Por ejemplo, el promedio, el recuento, el máximo,

mínimo y la suma proporcionados pueden facilitar la tarea a los desarrolladores. Realizar consulta estadística en cada campo.

La propiedad es la configuración de las condiciones de consulta para un determinado campo, como a través de Property.forName("color").in

(new String[]{"black"," red ","write"}); luego podrá crear una instancia de Proyecto. Agréguelo a las condiciones de consulta mediante el método add(Project) de

criterios.

Al utilizar Criteria para realizar consultas, lo principal que hay que tener claro es qué clases y métodos proporciona Hibernate para cumplir con la creación y el ensamblaje de las condiciones de consulta durante el desarrollo.

Aquí se muestran varios usos:

1. Cree una instancia de Criteria

La interfaz org.hibernate.Criteria representa una consulta para una clase de persistencia específica. La sesión es una fábrica de instancias de Criteria.

Criterios crit = sess.createCriteria(Cat.class);

crit.setMaxResults(50);

Lista gatos = crit.list();

2. Limitar el contenido del conjunto de resultados

Una única condición de consulta es una instancia de la interfaz org.hibernate.criterion.Criterion.

La clase org.hibernate.criterion.Restrictions define métodos de fábrica para obtener algunos tipos de criterios integrados.

Lista de gatos = sess.createCriteria(Cat.class)

.add( Restrictions.like("name", "Fritz%") )

. add( Restrictions.between("weight", minWeight, maxWeight) )

.list();

Las restricciones se pueden agrupar lógicamente.

Lista gatos = sess.createCriteria(Cat.class)

.add( Restrictions.like("nombre", "Fritz%") )

. agregar( Restricciones.o(

Restricciones.eq( "edad", nuevo entero(0) ),

Restricciones.isNull("edad")

) )

.list();

Lista de gatos = sess.createCriteria(Cat.class)

.add( Restrictions.in( "nombre", new String[] { "Fritz", "Izi", "Pk" } ) )

.add( Restrictions.disjunction()

.add( Restrictions.isNull("age ") )

.add( Restrictions.eq("edad", nuevo Integer(0) ) )

.add( Restrictions.eq("edad", nuevo Integer(1 ) ) )

.add( Restrictions.eq("age", new Integer(2) ) )

) )

.list();

Hibernate proporciona bastantes tipos de criterios integrados (subclases de Restricciones), pero uno que es particularmente útil le permite

usar SQL directamente.

Lista gatos = sess.createCriteria(Cat.class)

.add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz %",

Hibernate.STRING) )

.list();

{alias} el marcador de posición debe reemplazarse con el alias de columna de la entidad consultada.

Las instancias de propiedad son otra forma de obtener una condición. Puede crear una

Propiedad llamando a Property.forName().

Edad de la propiedad = Property.forName("edad");

Lista de gatos = sess.createCriteria(Cat.class)

.add( Restrictions.disjunction ()

.add( edad.isNull() )

.add( edad.eq( nuevo entero(0) ) )

.add( edad .eq( nuevo entero(1) ) )

.add( edad.eq( nuevo entero(2) ) )

) )

.add( Property.forName("nombre").in( new String[] { "Fritz", "Izi", "Pk" } ) )

.list();

3 . Clasificación del conjunto de resultados

Puede utilizar org.hibernate.criterion.Order para ordenar los resultados de la consulta.

Lista de gatos = sess.createCriteria(Cat.class)

.add( Restrictions.like("nombre", "F%")

.addOrder ( Order.asc("nombre") )

.addOrder( Order.desc("edad") )

.setMaxResults(50)

.list ();

Lista de gatos = sess.createCriteria(Cat.class)

.add( Property.forName("name").like("F%") ) p>

.addOrder( Property.forName("nombre").asc() )

.addOrder( Property.forName("edad").desc() )

.setMaxResults(50)

.list();

4. Asociación

Puedes usar createCriteria() para crear fácilmente relaciones entre entidades relacionadas. Crear restricciones.

List cats = sess.createCriteria(Cat.class)

.add( Restrictions.like("name", "F%")

.add( Restrictions.like("nombre", "F%")

.list();

Tenga en cuenta que el segundo createCriteria() devuelve una nueva instancia de Criteria que hace referencia a un elemento de la colección de gatitos.

A continuación, los patrones de sustitución también son útiles en determinadas situaciones.

Lista gatos = sess.createCriteria(Cat.class)

.createAlias("gatitos", "kt")

.createAlias("mate", "mt")

.add( Restrictions.eqProperty("kt.name", "mt.name") )

.list();

(createAlias() no crea una nueva instancia de Criteria).

La colección de gatitos devuelta por las dos consultas anteriores guardadas por la instancia de Cat no está prefiltrada por las condiciones. Si deseas obtener sólo

gatitos que cumplan los criterios, debes utilizar returnMaps().

Lista gatos = sess.createCriteria(Cat.class)

.createCriteria("gatitos", "kt")

.add( Restrictions.eq( "nombre", "F%") )

.returnMaps()

.list();

Iterador iter = cats.iterator();

mientras ( iter.hasNext() ) {

Mapa mapa = (Mapa) iter.next();

Gato gato = (Gato) map.get (Criteria.ROOT_ALIAS);

Gato gatito = (Cat) map.get("kt");

}

5. p>

Puede utilizar setFetchMode() para definir la semántica de la recuperación relacional dinámica en tiempo de ejecución.

Lista gatos = sess.createCriteria(Cat.class)

.add( Restrictions.like("nombre", "Fritz%") )

. setFetchMode("mate", FetchMode.EAGER)

.setFetchMode("kittens", FetchMode.EAGER)

.list();

Esta consulta puede Agarra compañeros y gatitos a través de conexiones externas.

6. Ejemplo de consulta

La clase org.hibernate.criterion.Example le permite construir una consulta condicional basada en una instancia determinada.

Gato gato = new Cat();

cat.setSex('F');

cat.setColor(Color.BLACK);

Resultados de la lista = session.createCriteria(Cat.class)

.add( Ejemplo.create(cat) )

.list();

Se ignoran los atributos de versión, identificadores y asociaciones. Las propiedades con valores nulos se excluirán de forma predeterminada.

Puedes ajustar el Ejemplo para hacerlo más práctico.

Ejemplo de ejemplo = Ejemplo.create(cat)

.excludeZeroes() //excluir propiedades con valor cero

.excludeProperty("color") //excluir la propiedad denominada "color"

.ignoreCase() //realiza comparaciones de cadenas que no distinguen entre mayúsculas y minúsculas

.enableLike() //usa like para comparaciones de cadenas

; Resultados de la lista = session.createCriteria(Cat.class)

.add(example)

.list();

Incluso puedes usar ejemplos en los archivos asociados Condiciones de colocación del objeto.

Resultados de la lista = session.createCriteria(Cat.class)

.add( Ejemplo.create(cat) )

.createCriteria("mate")

.add( Ejemplo.create( cat.getMate() ) )

.list();

7.

org.hibernate.criterion.Projections es la fábrica de instancias de Projection. Aplicamos proyección a una consulta llamando a

setProjection().

Resultados de la lista = session.createCriteria(Cat.class)

.setProjection( Projections.rowCount() )

.add( Restrictions.eq("color ", Color.BLACK) )

.list();

Lista de resultados = session.createCriteria(Cat.class)

.setProjection( Projections.projectionList ()

.add( Projections.rowCount() )

.add( Projections.avg("peso") )

.add( Projections.max ("peso") )

.add( Projections.groupProperty("color") )

)

.list();

No es necesario utilizar explícitamente "agrupar por" en una consulta condicional. Ciertos tipos de proyección se definen como proyecciones de grupo y también aparecen en la cláusula group by de SQL.

Opcionalmente, puede asignar un alias a una proyección para que una restricción u orden pueda hacer referencia al valor proyectado.

Las siguientes son dos implementaciones

diferentes:

Listar resultados = session.createCriteria(Cat.class)

.setProjection( Projections.alias( Projections. groupProperty( "color"), "colr" ) )

.addOrder( Order.asc("colr") )

.list();

Listar resultados = session.createCriteria(Cat.class)

.setProjection( Projections.groupProperty("color").as("colr") )

.addOrder( Order.asc (" colr") )

.list();

Los métodos alias() y as() simplemente envuelven una instancia de proyección en otra instancia de proyección con alias.

En resumen,

Cuando agregas una proyección a una lista de proyecciones, puedes especificar un alias para ella:

Resultados de lista = session.createCriteria(Cat.class)

.setProjection( Projections.projectionList()

.add( Projections.rowCount(), "catCountByColor" )

.add( Projections.avg("peso "), " avgWeight" )

.add( Projections.max("peso"), "maxWeight" )

.add( Projections.groupProperty("color"), " color" )

)

.addOrder( Order.desc("catCountByColor") )

.addOrder( Order.desc("avgWeight") )

.list();

Lista de resultados = session.createCriteria(Domestic.class, "cat")

.createAlias("gatitos", "kit")

.setProjection( Projections.projectionList()

.add( Projections.property("cat.name"), "catName" )

.add ( Projections.property ("kit.name"), "kitName" )

)

.addOrder( Order.asc("catName") )

.addOrder( Pedido .asc("kitName") )

.list();

Property.forName() también se puede utilizar para representar la proyección:

Lista de resultados = session.createCriteria(Cat.class)

.setProjection( Property.forName("nombre") )

.add( Property.forName("color").eq (Color. NEGRO) )

.list();

Listar resultados = session.createCriteria(Cat.class)

.setProjection( Projections.projectionList()

.add( Projections.rowCount().as("catCountByColor") )

.add( Property.forName("peso").avg().as(" avgWeight") )

.add( Property.forName("peso").max().as("maxWeight") )

.add( Property.forName("color").group().as("color" )

)

.addOrder( Order.desc("catCountByColor") )

.addOrder( Order.desc("avgWeight") )

.list();

8. Consulta y subconsulta sin conexión (separadas)

La clase DetachedCriteria le permite crear una consulta fuera de una sesión y ejecutarla usando cualquier sesión

.

Consulta DetachedCriteria = DetachedCriteria.forClass(Cat.class)

.add( Property.forName("sex").eq('F') );

//Crear una sesión

Sesión sesión = .;

Transacción txn = sesión.beginTransaction();

Lista de resultados = query.getExecutableCriteria(sesión ).setMaxResults(100).list();

txn.commit();

session.close();

DetachedCriteria también se puede expresar como subconsulta. Las instancias de condición que contienen subconsultas se pueden obtener a través de Subconsultas o

Propiedad.

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)

.setProjection( Property.forName("weight").avg() );

sesión .createCriteria(Cat.class)

.add( Property.forName("weight).gt(avgWeight) )

.list();

DetachedCriteria pesos = DetachedCriteria.forClass(Cat.class)

.setProjection( Property.forName("peso") );

session.createCriteria(Cat.class)

.add( Subqueries.geAll("weight", pesos) )

.list();

También son posibles subconsultas interrelacionadas:

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")

.setProjection( Property.forName("peso").avg() )

.add( Property.forName( "cat2.sex").eqProperty("cat.sex") );

session.createCriteria(Cat.class, "cat")

.add( Property.forName( "peso).gt(avgWeightForSex) )

.list();