Résumer les exemples d'utilisation de DetachedCriteria et Criteria

L'éditeur ci-dessous vous proposera une brève discussion sur la façon d'utiliser DetachedCriteria et Criteria (une lecture incontournable). L'éditeur pense que c'est plutôt bien, alors je vais le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons un coup d'œil

Dans la programmation Web conventionnelle, il existe un grand nombre de requêtes conditionnelles dynamiques, c'est-à-dire que l'utilisateur sélectionne librement certaines conditions sur la page Web et que le programme génère dynamiquement des instructions SQL. en fonction des conditions de sélection de l'utilisateur, effectuez une requête.

Par exemple, je me souviens que vous pouvez choisir des conditions de requête avancées dans Facebook. Il s'agit d'une requête dynamique. Nous ne pouvons pas prédire combien de requêtes seront utilisées. Si nous l'écrivons directement, notre couche Dao l'est évidemment. pas satisfait de nous. Signification

En réponse à cette demande, pour les applications en couches, la couche Web doit transmettre une liste de conditions de requête à l'objet de la couche métier, une fois que l'objet de la couche métier a obtenu cette liste de conditions. supprime les conditions dans l'ordre, construit l'instruction de requête. Une difficulté ici est de savoir comment construire la liste de conditions ? Map est traditionnellement utilisée, mais cette méthode présente de gros défauts. Les informations que Map peut transmettre sont très limitées. Elle ne peut transmettre que le nom et la valeur, mais ne peut pas indiquer le type d'opération conditionnelle à effectuer, si elle est supérieure à ou inférieure. que, comme, ou autre chose, l'objet de la couche métier doit saisir avec précision les conditions implicites de chaque entrée. Par conséquent, une fois que les conditions implicites changent, l'algorithme de construction de requête de l'objet de la couche métier doit être modifié en conséquence. Cependant, ce changement dans les conditions de requête est implicitement convenu, non limité par le code du programme, il est donc très sujet aux erreurs.

DetachedCriteria peut résoudre ce problème, c'est-à-dire que dans la couche Web, les programmeurs utilisent DetachedCriteria pour construire des conditions de requête, puis transmettent ce DetachedCriteria comme paramètre d'appel de méthode à l'objet de la couche métier. Une fois que l'objet de la couche métier a obtenu le DetachedCriteria, il peut directement construire les critères dans le cadre de la session pour la requête. À cet égard, la construction des instructions de requête a été entièrement déplacée vers la couche Web pour la mise en œuvre, tandis que la couche métier est uniquement responsable de l'achèvement de la persistance et de l'encapsulation des requêtes. Elle est complètement découplée de la construction des conditions de requête, ce qui est parfait !

La principale différence entre Criteria et DetachedCriteria

est que le formulaire de création est différent en ligne, il est donc créé. par Hibernate Session est créé, tandis que DetachedCriteria est hors ligne et ne nécessite pas de session lors de la création. Fournit 2 méthodes statiques pour créer des instances DetachedCriteria.

for

Class(Class) forEntityName(Name)

Le framework Spring fournit une prise en charge des requêtes hors ligne, très simple à utiliser ces méthodes
Le framework Spring fournit la méthode getHibernateTemplate().findByCriteria(dependentCriteria) pour renvoyer facilement les résultats de requête basés sur DetachedCriteria. La sous-classe de Criteria est DetachedCriteria, que nous pouvons simplement utiliser.

Après les avoir utilisés, nous devons dire que les Restrictions

sont une classe d'outils permettant de générer des conditions de requête. L'expression des Restrictions est la suivante
Opérateur HQL Opérateur QBC signifiant

= Restrictions.eq() est égal

<> 🎜> Les critères, c'est quelque chose qui doit être dit. Traduit, cela signifie conditions, normes, etc. C'est presque la même chose que nos hors ligneJetons donc un coup d'œil à un exemple

Vérifiez toutes les informations dans la table Utilisateur

Le nôtre Nous devons récupérer notre objet de session~~ La requête en ligne est similaire à notre requête, mais plus puissante !

 Restrictions.gt() 大于greater than 
= Restrictions.ge() 大于等于 greater than or equal 
< Restrictions.lt() 小于less than 
<= Restrictions.le() 小 于 等 于 less than or equal 
is null Restrictions.isnull() 等于空值 
is not null Restrictions.isNotNull() 非空值 
like Restrictions.like() 字符串模式匹配 
and Restrictions.and() 逻辑与 
and Restrictions.conjunction() 逻辑与 
or Restrictions.or() 逻辑或 
or Restrictions.disjunction() 逻辑或 
not Restrictions.not() 逻辑非 
in(列表) Restrictions.in() 等于列表中的某一个值 
not in(列表) Restrictions.not(Restrictions.in()) 不等于列表中任意一个值 
between x and y Restrictions.between() 闭区间 xy中的任意值 
not between x and y Restrictions.not(Restrictions..between()) 小于值X 或者大于值y

Les critères ne sont qu'un conteneur. Si vous souhaitez définir des conditions de requête, utilisez simplement la méthode add() pour ajouter des conditions de restrictions, par exemple, interroger des données dont l'âge est supérieur à 20 et inférieur à 40. Bien que nos instructions SQL puissent également être complétées, pour une meilleure encapsulation et une plus grande réutilisation du code, il est préférable de ne pas écrire directement nos instructions SQL. Ce n'est qu'après avoir vu le code encapsulé de l'entreprise que je pourrai ressentir la puissance incomparable de nos prédécesseurs, la flexibilité du code. la réutilisation est très élevée ! Ici, on peut passer des Restrictions illimitées pour les encapsuler, ce qui est très pratique à utiliser !

Vous pouvez également utiliser des combinaisons logiques pour interroger, comme combiner l'âge est égal à (eq) 20 ou (ou) l'âge est nul (isNull) :

Une seule requête Un critère est une instance de l'interface org.hibernate.criterion.Criterion.

La classe org.hibernate.criterion.Restrictions définit des méthodes d'usine pour obtenir certains types de critères intégrés.

Exploration d'association dynamique

 Criteria criteria = session.createCriteria(User.class);
 List users = criteria.list();
 Iterator iterator = users.iterator();
 while(iterator.hasNext()) {
  User user = (User) iterator.next();
  System.out.println(user.getId() + user.getName());   
 }

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.gt("age", new Integer(20)));
criteria.add(Restrictions.lt("age", new Integer(40)));
List users = criteria.list();

Notre mode d'exploration se présente sous la forme d'une association 1 à plusieurs ! A-t-il été capturé ?

Vous pouvez utiliser setFetchMode() pour définir la sémantique de la récupération relationnelle dynamique au moment de l'exécution

List cats = sess.createCriteria(Cat.class)

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

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

 .list();

Cette requête peut récupérer des partenaires et des chatons via des connexions externes.

DetachedCriteria的关联查询

假设要通过stuName查询一个学生Student记录，可以如下：

DetachedCriteria dc = DetachedCriteria.forClass(Student.class);
dc.add(Restrictions.like("stuName", stuName, MatchMode.ANYWHERE));

如果要通过Student的Team的teamName查询一个Student记录，很多人都会这么写：

DetachedCriteria dc = DetachedCriteria.forClass(Student.class); 
dc.add(Restrictions.like("team.teamName", teamName, MatchMode.ANYWHERE));

遗憾的是上述程序报错，说是在Student中找不到team.teamName属性，这是可以理解的。那么如何通过teamName查找、、Student呢？

可以这么写：

DetachedCriteria dc = DetachedCriteria.forClass(Student.class); 
dc.createAlias("team", "t"); 
dc.add(Restrictions.like("t.teamName", teamName, MatchMode.ANYWHERE));

没错，就是要先建立team的引用，才能用team导航到teamName

Department和Employee是一对多关联，查询条件为： 名称是“department”开发部门，部门里面的雇员年龄大于20岁；

DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
detachedCriteria.add(Restrictions.eq("name", "department"))
     .createAlias("employees", "e")
     .add(Restrictions.gt(("e.age"), new Integer(20)));
List list = this.getHibernateTemplate().findByCriteria(detachedCriteria);

投影(Projections)、聚合（aggregation）和分组（grouping）

org.hibernate.criterion.Projections是 Projection 的实例工厂。

我们通过调用setProjection()应用投影到一个查询。这个的意思就是查询哪一列的意思

用来进行聚合操作,和sql中的聚合类似.求和/求平均值/统计记录数/…等等.

还有用来获取获取对象的某些属性(表字段)或属性集合.正常情况下，查询返回的是对象或对象的集合.使用投影的话就可以只返回你需要的属性值.即Hibernate不把记录封装对象了,只返回你在投影中设置的属性的值(值的集合)的数组

List results = session.createCriteria(Cat.class)

 .setProjection( Projections.rowCount() )

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

 .list()

List results = session.createCriteria(Cat.class)

 .setProjection( Projections.projectionList()

  .add( Projections.rowCount() )

  .add( Projections.avg("weight") )

  .add( Projections.max("weight") )

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

 )

 .list();

在一个条件查询中没有必要显式的使用 “group by” 。某些投影类型就是被定义为 分组投影，他们也出现在SQL的group by子句中。

可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的

实现方式：

List results = session.createCriteria(Cat.class)

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

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

 .list();

List results = session.createCriteria(Cat.class)

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

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

 .list();

alias()和as()方法简便的将一个投影实例包装到另外一个 别名的Projection实例中。简而言之， 当你添加一个投影到一个投影列表中时 你可以为它指定一个别名：

List results = session.createCriteria(Cat.class)

 .setProjection( Projections.projectionList()//一个查询只能使用一个投影！这里只能这样处理啦！

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

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

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

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

 )

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

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

 .list();

也可以使用Property.forName()来表示投影：

List results = session.createCriteria(Cat.class)

 .setProjection( Projections.projectionList()

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

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

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

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

 )

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

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

 .list();

DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来执行它。
也可以使用spring封装好的哦！

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)

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

//创建一个Session

Session session = .;

Transaction txn = session.beginTransaction();

List results = query.getExecutableCriteria(session).setMaxResults(100).list();

txn.commit();

session.close();

也可以是作为子查询

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)

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

session.createCriteria(Cat.class)

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

 .list();

【相关推荐】

1. 浅谈php函数serialize()与unserialize()的使用方法

2. PHP sprintf() 函数使用方法详解

3. php session()函数使用方法详解

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!