|
|
Postat pe 09.08.2017 14:26:13
|
|
|
Acum să presupunem că există o clasă Student cu atribute de id, nume, vârstă
String hql = "de la Student s";
Așa cum obișnuiam, de obicei facem
Query query = session.createQuery(hql);
Sau dacă vrei să cauți în funcție de condiții.
Șir hql = "de la Student s unde s.name ca 'King%'"
Query query = session.createQuery(hql);
Dacă folosești QBC în loc de HQL, atunci codul este:
Criterii criterii =session.createCriteria(Student.class);
Criteriul criteriului = Expression.like("name","king%");
Nu pot să văd lucrurile așa. Apoi adăugăm condiția de căutare la vârsta de 22 de ani.
HQL:
Șirul hql = "de la Studenți s unde s.name ca 'Wang%' și s.age = 22 ";
Query query = session.createQuery(hql);
List list = query.list();
QBC:
Criterii criterii =session.createCriteria(Student.class);
Criteriul 1 = Expression.like("name","king%");
Criteriul criteriului2 = Expression.eq("age",newInteger(22));
criterii.add(criterion1).add(criterion2);
List list = criteria.list();
Pare mult mai greoi. Dar oricine a făcut un proiect știe că atunci când logica de business a unui modul se schimbă, adesea trebuie să rescrie SQL, iar cel mai enervant și enervant lucru este să iei HQL-ul sau SQL-ul altcuiva.
Dacă folosești QBC, crește considerabil lizibilitatea și mentenabilitatea codului.
Este important de menționat că valoarea nulă este valoarea
De exemplu, când vrem să găsim un obiect Student cu un nume nul, ar trebui să-l scriem astfel.
Criterii criterii =session.createCriteria(Student.class);
Criteriul criteriului = Expression.isNull("nume");
criteria.add(criterion).list();
și folosind între... și timp
Criterii criterii =session.createCriteria(Student.class);
Criteriul criteriului 1 = Expression.ge("vârstă",noul Întreg(20)); Limită inferioară
Criteriul criteriului2 = Expression.le("vârstă",nou Întreg(25)); Tavan
//这里也可以把上述两个条件添加到第三个条件里
Criteriul criteriului3 = Expresie.și(criteriul1,criteriul2);
criteria.add(criterion3).list();
Echivalent cu de la studenții care au între 20 și 25 de ani
Echivalent cu de la Student s unde s.age >= 20 și s.age <=25
Următoarea este o comparație a condițiilor de interogare folosite frecvent pentru HQL și QBC
Expresia însemnând HQL QBC
mai mare sau egal cu > = Expression.ge()
Mai mare decât > Expression.gt()
Mai mic sau egal cu < = Expression.le()
Mai puțin de < Expression.lt()
egal = Expression.eq()
nu este egal cu <>sau!= Expression.ne()
Null este null Expression.isNull()
is notnull Expression.isNotNull()
În intervalul specificat între și Expression.between()
Nu în intervalul specificat, nu între Expression.not(Expression.between())
Aparținând unei colecții în Expression.in()
Nu face parte dintr-o colecție, nu este Expression.not(Expression.in())
și expression.and()
sau Expression.or()
Nu Expression.not()
Interogare neclară ca Expression.like
1. Creează o instanță Criteria net.sf.hibernate.Criteria Această interfață reprezintă o interogare pentru o clasă de persistență specifică. Session este fabrica folosită pentru fabricarea instanței Criteria.
Criterii crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
Listă pisici = crit.list();
2. Restrângerea domeniului setului de rezultate O condiție de interogare (Criterion) este o instanță a interfeței net.sf.hibernate.expression.Criterion. Clasa net.sf.hibernate.expression.Expression definește pentru a obține unele tipuri Criterion încorporate.
Listă pisici = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.add( Expression.between("weight", minWeight, maxWeight))
.list();
Expresiile pot fi grupate logic.
Listă pisici = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.add( Expression.or( Expression.eq( "age", new Enter(0)), Expression.isNull("age")))
.list();
Listă pisici = sess.createCriteria(Cat.class)
.add( Expression.in( "name",new String[]{"Fritz","Izi","Pk"}))
.add( Expression.disjunction()
.add( Expression.isNull("vârstă") )
.add( Expression.eq ("age", new Integer (0) ) )
.add( Expression.eq("age", new Enterger(1) )
.add( Expression.eq ("age", new Enter(2) ) ) ) ) )
.list();
Există multe tipuri de condiții predefinite (subclase de Expresii). Există unul deosebit de util care îți permite să încorporezi SQL direct.
Listă pisici = sess.createCriteria(Cat.class)
.add( Expression.sql("lower($alias.name) ca lower(?)", "Fritz%", Hibernate.STRING))
.list();
unde {alias} este un înlocuitor, acesta va fi înlocuit cu aliasul de linie al entității interogate. (Original: {alias} va fi înlocuit cu aliasul de rând al entității interogate.)
3. Sortează rezultatele Poți folosi net.sf.hibernate.expression.order pentru a sorta setul de rezultate.
Listă pisici = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.addOrder( Order.asc("nume"))
.addOrder( Order.desc("age"))
.setMaxResults(50)
.list();
4. Asocieri Poți folosi createCriteria() între asocieri pentru a specifica ușor constrângerile între entități cu relații.
Listă pisici = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.createCriteria ("pisoi")
.add( Expression.like("name","F%")
.list();
Rețineți că al doilea createCriteria() returnează o nouă instanță a Criteria, indicând către un element al clasei de colecție a pisicuțelor. Următoarele forme alternative sunt utile în situații specifice.
Listă pisici = sess.createCriteria(Cat.class)
.createAlias("pisoi", "kt")
.createAlias("partener", "mt")
.add(Expression.eqProperty("kt.name", "mt.name"))
.list();
(createAlias()) nu creează o nouă instanță a Criteriilor. Rețineți că clasa de colecție a pisicuțelor deținută de instanța Pisicilor în primele două interogări nu este pre-filtrată după criterii! Dacă vrei să returnezi doar pisicuțele care îndeplinesc criteriile, trebuie să folosești returnMaps().
Listă pisici = sess.createCriteria(Cat.class)
.createCriteria("pisoi", "kt")
.add( Expression.eq ("name", "F%") )
.returnMaps()
.list();
Iterator iter = cats.iterator();
în timp ce ( iter.hasNext())
{
Map map = (Map) iter.next();
Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
Pisică pisică = (Pisică) map.get("kt");
}
5. Preluarea dinamică a asocierilor Poți schimba politica automată de preluare a obiectelor de asociere prin setarea FetchMode() la runtime.
Listă pisici = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.list();
Această interogare va ajunge atât la partener, cât și la pui prin unirea exterioară.
6. Conform clasei Example queries net.sf.hibernate.expression.Example, poți crea condiții de interogare din instanța specificată.
Pisică pisică = pisică nouă();
cat.setSex('F');
cat.setColor(Color.BLACK);
Rezultate listă = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();
Proprietățile versiunii, proprietățile de reprezentare și asocierile sunt toate ignorate. În mod implicit, atributele null sunt de asemenea excluse. Poți ajusta modul în care este aplicat exemplul. Poţi
pentru a ajusta modul în care este aplicat exemplul. Exemplu exemplu = Exemplu.create(cat) .excludeZeroes() //exclude proprietăți cu valori zero
.excludeProperty("color") //exclude proprietatea denumită "color" .ignoreCase() //perform comparații de șiruri insensibile la majuscule
.enableLike(); Folosirea lui like pentru comparații de corzi
Rezultate listă = session.createCriteria(Cat.class)
.add(exemplu)
.list();
Poți chiar folosi exemple pentru a stabili criterii pentru obiectele asociate. Rezultatele listei = session.createCriteria(Cat.class) .add(Example.create(cat) )
.createCriteria("mate") .add(Example.create(cat.getMate())) .list();
Codul de referință este următorul:
|
Precedent:LINQ conexiuni stânga, dreapta și interioarăUrmător:Diferența dintre variabilele de definiție let și var în js
|
