|
|
Publié sur 09/08/2017 14:26:13
|
|
|
Supposons maintenant qu’il y a une classe Étudiant avec les attributs id, nom, âge
Chaîne hql = « de l’étudiant s » ;
Comme avant, nous le faisons généralement
Query query = session.createQuery(hql) ;
Ou si vous souhaitez chercher selon les conditions.
Chaîne hql = « from Students s où s.name comme 'King %' »
Query query = session.createQuery(hql) ;
Si vous utilisez QBC au lieu de HQL, alors le code est :
Critères critères =session.createCriteria(Student.class) ;
Critère de critère = Expression.like(« nom »,"king % ») ;
Je ne vois pas ça comme ça. Ensuite, on ajoute la condition de recherche à l’âge de 22 ans.
HQL:
Chaîne hql = « à partir des étudiants s où s.name comme 'Wang %' et s.age = 22 ;
Query query = session.createQuery(hql) ;
Liste = query.list() ;
QBC:
Critères critères =session.createCriteria(Student.class) ;
Critère 1 = Expression.like(« name »,"king % ») ;
Critère du critère 2 = Expression.eq (« age »,newInteger(22)) ;
critères.add(critère1).add(critère2) ;
Liste liste = criteria.list() ;
Cela paraît beaucoup plus encombrant. Mais quiconque a déjà réalisé un projet sait que lorsque la logique métier d’un module change, il doit souvent réécrire SQL, et la chose la plus agaçante et agaçante est de prendre le HQL ou SQL de quelqu’un d’autre.
Si vous utilisez QBC, cela augmente considérablement la lisibilité et la maintenabilité du code.
Il est important de noter que la valeur nulle est la valeur
Par exemple, lorsque nous voulons trouver un objet Student avec un nom nul, nous devons l’écrire ainsi
Critères critères =session.createCriteria(Student.class) ;
Critère de critère = Expression.isNull(« name ») ;
critères.add(critère).liste() ;
et en utilisant entre... et le temps
Critères critères =session.createCriteria(Student.class) ;
Critère du critère 1 = Expression.ge (« âge »,nouvel entier(20)) ; Limite inférieure
Critère du critère 2 = Expression.le(« age »,new Integer(25)) ; Plafond
//这里也可以把上述两个条件添加到第三个条件里
Critère critère 3 = Expression.and(critère1,critère2) ;
criteria.add(criterion3).list() ;
Équivalent à des étudiants âgés entre 20 et 25 ans
Équivalent à de Étudiant s où s.âge >= 20 ans et s.âge <=25
Ce qui suit est une comparaison des conditions de requête couramment utilisées entre HQL et QBC
Expression signifiant HQL QBC
plus grand ou égal à > = Expression.ge()
Plus grand que > Expression.gt()
Inférieur ou égal à < = Expression.le()
Moins de < Expression.lt()
égal = Expression.eq()
ne fait pas <>ou != Expression.ne()
Null est null Expression.isNull()
is notnull Expression.isNotNull()
Dans la plage spécifiée entre et Expression.entre()
Pas dans la plage spécifiée, pas entre, et Expression.not(Expression.between())
Appartenant à une collection dans Expression.in()
Ne faisant pas partie d’une collection, non, Expression.not(Expression.in())
et expression.et()
ou Expression.or()
Pas Expression.not()
Requête floue comme Expression.like
1. Créer une instance Critères net.sf.hibernate.Critères Cette interface représente une requête pour une classe de persistance spécifique. Session est l’usine utilisée pour fabriquer l’instance Critter.
Crit crit = sess.createCriteria(Cat.class) ;
crit.setMaxResults(50) ;
Liste chats = crit.list() ;
2. Restreindre la portée de l’ensemble des résultats Une condition de requête (Criterion) est une instance de l’interface net.sf.hibernate.expression.Criterion. La classe net.sf.hibernate.expression.Expression définit pour obtenir certains types de critères intégrés.
Liste chats = sess.createCriteria(Cat.class)
.add( Expression.like(« nom », « Fritz % ») )
.add( Expression.between(« weight », minWeight, maxWeight))
.list() ;
Les expressions peuvent être regroupées logiquement.
Liste chats = sess.createCriteria(Cat.class)
.add( Expression.like(« nom », « Fritz % ») )
.add( Expression.or( Expression.eq( « age », new Integer(0) ), Expression.isNull(« age »)))
.list() ;
Liste chats = sess.createCriteria(Cat.class)
.add( Expression.in( « name »,nouvelle String[]{"Fritz », « Izi », « Pk"}))
.add( Expression.disjunction()
.add( Expression.isNull(« age ») )
.add( Expression.eq (« age », new Integer(0) )
.add( Expression.eq (« age », new Integer(1) ) )
.add( Expression.eq (« age », nouveau Entier(2) ) ) ) )
.list() ;
Il existe de nombreux types de conditions prédéfinies (sous-classes d’expressions). Il y en a un particulièrement utile qui permet d’intégrer SQL directement.
Liste chats = sess.createCriteria(Cat.class)
.add( Expression.sql(« lower($alias.name) like lower( ?) », « Fritz % », Hibernate.STRING))
.list() ;
lorsque {alias} est un lieu de placement, il sera remplacé par l’alias de ligne de l’entité interrogée. (Original : Le lieu de remplacement {alias} sera remplacé par l’alias de ligne de l’entité interrogée.)
3. Trier les résultats Vous pouvez utiliser net.sf.hibernate.expression.Order pour trier l’ensemble des résultats.
Liste chats = sess.createCriteria(Cat.class)
.add( Expression.like(« nom », « F % »)
.addOrder( Order.asc(« nom »))
.addOrder( Order.desc(« age »))
.setMaxResults(50)
.list() ;
4. Associations Vous pouvez utiliser createCriteria() entre associations pour spécifier facilement les contraintes entre entités ayant des relations.
Liste chats = sess.createCriteria(Cat.class)
.add( Expression.like(« nom », « F % »)
.createCriteria (« chatons »)
.add( Expression.like(« name »,"F % »)
.list() ;
Notez que le second createCriteria() renvoie une nouvelle instance de Criteria, pointant vers un élément de la classe de collection des chatons. Les formes alternatives suivantes sont utiles dans des situations spécifiques.
Liste chats = sess.createCriteria(Cat.class)
.createAlias (« chatons », « kt »)
.createAlias(« mate », « mt »)
.add(Expression.eqProperty(« kt.name », « mt.name »))
.list() ;
(createAlias()) ne crée pas une nouvelle instance des Critères. Notez que la classe de collection de chatons détenue par l’instance Cat dans les deux requêtes précédentes n’est pas pré-filtrée par des critères ! Si vous souhaitez ne retourner que des chatons qui remplissent les critères, vous devez utiliser returnMaps().
Liste chats = sess.createCriteria(Cat.class)
.createCriteria (« chatons », « kt »)
.add( Expression.eq (« nom », « F % ») )
.returnMaps()
.list() ;
Iterator iter = cats.iterator() ;
tandis que ( iter.hasNext())
{
Map map = (Map) iter.next() ;
Chat chat = (Chat) map.get(Criteria.ROOT_ALIAS) ;
Chaton = (Chat) map.get(« kt ») ;
}
5. Récupération dynamique des associations Vous pouvez modifier la politique de récupération automatique des objets d’association en définissant FetchMode() à l’exécution.
Liste chats = sess.createCriteria(Cat.class)
.add( Expression.like(« nom », « Fritz % ») )
.setFetchMode(« mate », FetchMode.EAGER)
.list() ;
Cette requête permettra à la fois de rencontrer le partenaire et les chatons via une jonction extérieure.
6. Selon la classe Exemples de requêtes net.sf.hibernate.expression.Example, vous pouvez créer des conditions de requête à partir de l’instance spécifiée.
Chat chat = nouveau Chat() ;
chat.setSex('F') ;
cat.setColor(Color.BLACK) ;
Résultats de la liste = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list() ;
Les propriétés de version, de représentation et d’associations sont toutes ignorées. Par défaut, les attributs nuls sont également exclus. Vous pouvez ajuster la façon dont l’Exemple est appliqué. Vous pouvez
pour ajuster la manière dont l’exemple est appliqué. Exemple exemple = Exemple.create(cat) .excludeZeroes() //exclude les propriétés à valeur nulle
.excludeProperty(« color ») //exclus la propriété nommée « color » .ignoreCase() //effectue des comparaisons de chaînes insensibles à la casse
.enableLike() ; Utilisation de l’LIKE pour la comparaison de chaînes
Résultats de la liste = session.createCriteria(Cat.class)
.add(exemple)
.list() ;
Vous pouvez même utiliser des exemples pour établir des critères pour les objets associés. Résultats de la liste = session.createCriteria(Cat.class) .add(Example.create(cat) )
.createCriteria(« mate ») .add(Example.create(cat.getMate())) .list() ;
Le code de référence est le suivant :
|
Précédent:LINQ connexions gauche, droite et intérieureProchain:La différence entre les variables de définition de let et var dans js
|
