关闭

Hibernate---QBC查询(1)

2863人阅读 评论(0) 收藏 举报
分类:

一.条件查询

条件查询是根据面向对象特色的数据查询方式,条件查询通过如下三个类完成:

1>Criteria:代表一次查询

2>Criterion:代表一个查询条件

3>Restrictions:产生查询条件的工具类

执行条件查询的步骤如下:

1>获得Hibernate的Session对象

2>以Session对象创建Criteria对象

3>使用Restrictions的静态方法创建Criterion查询条件

4>向Criteria查询中添加Criterion查询条件

5>执行Criteria的list()或uniqueResult()方法返回结果集

程序示例如下:

方法1:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Student.class)
				.add(Restrictions.gt("name", "cname")).list();
		for(Object obj : list){
			Student s = (Student)obj;
			System.out.println(s.getName());
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>

方法2:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List<Student> list = sess.createCriteria(Student.class)
				.add(Restrictions.gt("name", "cname")).list();
		for(Student s : list){
			System.out.println(s.getName());
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
注意:方法1的List不带泛型信息,需要进行显示的数据类型转换,方法2的List带泛型信息,可以直接使用;

在SQL语句中,字符串之间可以比较大小;

Criteria包含如下五个方法:

1>Criteria setFirstResult(int firstResult):设置查询返回的第一行记录(索引从0开始);

2>Criteria setMaxResult(int maxResult):设置查询返回的记录数;

这两个方法与Query的两个类似方法的功能一样,都用于完成查询分页;

3>Criteria add(Criterion criterion):增加查询条件

4>Criteria addOrder(Order order):增加排序规则,例如addOrder(Order.desc("type"));

    Order实例代表一个排序标准,Order有如下静态方法:

    4-1>static Order asc(String propertyName):根据propertyName属性升序排列

    4-2>static Order desc(String propertyName):根据propertyName属性降序排列

5>List list():返回结果集

Criterion接口代表一个查询条件,该查询条件由Restrictions负责产生,Restrictions是专门用于产生查询条件的工具类,他的方法大部分都是静态方法,常用的方法如下:

1>static eq | ne | gt | ge | lt | le(String propertyName,Object value)

判断指定属性值是否等于,不等于,大于,大于等于,小于,小于等于指定值

2>static eq | ne | gt | ge | lt | leProperty(String propertyName,String otherPropertyName)

判断第一个属性(由propertyName参数决定)的值是否等于,不等于,大于,大于等于,小于,小于等于第二个属性(由otherPropertyName参数确定)的值

3>static Criterion allEq(Map propertyNameValues)

判断指定属性(由Map参数的key指定)和指定值(由Map参数的value指定)是否完全相等

注意:Map必须是Map<String,T>类型的,String是字段名称,T是该字段的值,每一个map存放的多个键值对只对应书记表同一条数据记录

4>static Criterion between(String propertyName,Object lo,Object hi)

判断属性值在某个值范围之内

5>static Criterion ilike(String propertyName,Object value)

判断属性值匹配某个字符串,不区分大小写,条件字符串要不是完整的字符串去匹配,要不采用%通配符进行匹配

6>static Criterion ilike(String propertyName,String value,MatchMode matchMode)

判断属性值匹配某个字段,不区分大小写,模式是以判断以某个字符串开头或者结尾等,这个匹配字符串可以是整个值的字符串,也可以是其中的一部分,也可以使用%通配符

7>static Criterion like(String propertyName,Object value)

判断属性值匹配某个字符串,区分大小写,条件字符串要不是完整的字符串去匹配,要不采用%通配符进行匹配(理论上这个匹配区分大小写,但是实际测试不区分,和ilike一样)

8>static Criterion like(String propertyName,String value,MatchMode matchMode)

判断属性值匹配某个字段,区分大小写,模式是以判断以某个字符串开头或者结尾等,这个匹配字符串可以是整个值的字符串,也可以是其中的一部分,也可以使用%通配符(理论上这个匹配区分大小写,但是实际测试不区分,和ilike一样)

9>static Criterion in(String propertyName,Collection values)

判断属性值在在某个集合内

10>static Criterion in(String propertyName,Object[ ] values)

判断属性值是数组元素的其中之一

11>static Criterion isEmpty(String propertyName)

判断属性值是否为空,这个测试出错,暂时不知道这个方法的应用场景,应该是涉及到关联的集合

12>static Criterion isNotEmpty(String propertyName)

判断属性值是否不为空,这个测试出错,暂时不知道这个方法的应用场景,应该是涉及到关联的集合

13>static Criterion isNull(String propertyName)

判断属性值是否为空

14>static Criterion isNotNull(String propertyName)

判断属性值是否不为空

15>static Criterion not(Criterion expression)

对Criterion求反,两个条件进行嵌套,例如.add(Restrictions.not(Restrictions.eq("name", "cname")))

16>static Criterion sizeEq(String propertyName,int size)

判断某个属性的元素个数是否与size相等,这个测试出错,暂时不知道这个方法的应用场景,应该是涉及到关联的集合

17>static Criterion sqlRestriction(String sql)

直接使用sql语句作为筛选条件,例如:.add(Restrictions.sqlRestriction("type > 15"))

18>static Criterion sqlRestriction(String sql,Object[ ] values,Type[ ] types)

直接使用带参数占位符的SQl语句作为条件,并指定多个参数值,例如.add(Restrictions.sqlRestriction("type > ? and id > ?",new String[]{"17","17"},new Type[]{StringType.INSTANCE,StringType.INSTANCE}))

19>static Criterion sqlRestriction(String sql,Object value,Type type)

直接使用带参数占位符的SQl语句作为条件,并指定参数值,例如.add(Restrictions.sqlRestriction("type > ?","17",StringType.INSTANCE))

===========================================================

二.关联和动态关联

如果需要使用关联实体的属性来增加查询条件,则应该对属性再次使用createCriteria()方法,createCriteria()方法有如下重载版本:

1>Criteria createCriteria(String associationPath):使用默认的连接方式进行关联

2>Criteria createCriteria(String associationPath,JoinType joinType):以JoinType指定的连接方式进行关联;支持INNER_JOIN、LEFT_OUTER_JOIN、RIGHT_OUTER_JOIN、FULL_JOIN等枚举值;

3>Criteria createCriteria(String associationPath,String alias):该方法的功能与第一个方法的功能基本相似,只是该方法允许为关联实体指定别名;

4>Criteria createCriteria(String associationPath,String alias,JoinType joinType):该方法的功能与第二个方法的功能基本相似,只是该方法允许为关联实体指定别名;

5>Criteria createCriteria(String associationPath,String alias,JoinType joinType,Criterion withClause):该方法的功能最强大,该方法既可为关联实体指定别名,也可指定连接类型,还可以通过withClause指定自定义的连接条件---这个可用于实现非等值连接;

对比上面的方法,他们功能基本相似,只是有的能显示指定连接方式;

如下示例根据关联实体的属性过滤数据:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Student.class)
				//此处增加限制条件必须是Student实体存在的属性
				.add(Restrictions.gt("studentNumber", 20050231))
				//如果要增加对Student的关联类的属性限制
				//必须重载createCriteria()
				//如果此关联属性是集合,则只要集合里任意一个对象的属性满足下面条件即可
				.createCriteria("enrolments")
				.add(Restrictions.eq("semester", 4)).list();
		for(Object obj:list){
			Student s = (Student)obj;
			System.out.println(s.getName());
			System.out.println(s.getEnrolments().size());
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
使用关联类的条件查询,依然是查询原有持久化类的实例,而不是查询被关联类的实例;


为了达到上面这种效果,也可以使用createAlias()方法来代替createCriteria()方法,createAlias()方法同样有三个重载的版本:

1>Criteria createAlias(String associationPath,String alias):该方法的功能基本等同于Criteria createCriteria(String associationPath,String alias);

2>Criteria createAlias(String associationPath,String alias,JoinType joinType):该方法的功能基本等同于Criteria createCriteria(String associationPath,String alias,JoinType joinType)

3>Criteria createAlias(String associationPath,String alias,JoinType joinType,Criterion withClause):该方法的功能基本等同于Criteria createCriteria(String associationPath,String alias,JoinType joinType,Criterion withClause);

因此,程序可以将上面的查询替换为如下形式:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Student.class)
				//此处增加限制条件必须是Student实体存在的属性
				.add(Restrictions.gt("studentNumber", 20050231))
				//如果要增加对Student的关联类的属性限制
				//必须重载createCriteria()
				//如果此关联属性是集合,则只要集合里任意一个对象的属性满足下面条件即可
				.createAlias("enrolments","al")
				.add(Restrictions.eq("al.semester", 4)).list();
		for(Object obj:list){
			Student s = (Student)obj;
			System.out.println(s.getName());
			System.out.println(s.getEnrolments().size());
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
createAlias()方法并不是创建一个新的Criteria实例,他只是给关联实体(包括集合里包含的关联实体)起一个别名,让后面的过滤条件可根据该关联实体进行筛选;

在默认情况下,条件查询将根据持久化注解指定的延迟加载策略来加载关联实体,如果希望在条件查询中改变延迟加载策略(就像HQl查询中使用fetch关键字一样),则可以通过Criteria的setFetchMode()方法来实现,该方法也接受一个FetchMode枚举类型的值,FetchMode支持如下枚举值:

1>DEFAULT:使用配置文件指定延迟加载策略处理;

2>JOIN:使用外连接,预初始化所有的关联实体;

3>SELECT:启用延迟加载,系统将使用单独的select语句来初始化关联实体,只有当真正访问关联实体的时候,才会执行第二条select语句;

如果想让程序在初始化Student对象时,也可以初始化Student关联的Enrolment实体,则可使用如下查询方法

<span style="font-size:18px;"><strong>public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Student.class)
				//此处增加限制条件必须是Student实体存在的属性
				.add(Restrictions.gt("studentNumber", 20050231))
				.setFetchMode("enrolments", FetchMode.JOIN)
				.list();
		tx.commit();
		HibernateSessionFactory.closeSession();
		for(Object obj:list){
			Student s = (Student)obj;
			System.out.println(s.getName());
			System.out.println(s.getEnrolments().size());
		}
	}</strong></span>
上面程序的setFetchMode()方法将会初始化Student关联的enrolments集合,由于这个方法让程序查询Student实体时同步抓取了Student关联的Enrolemnt实体,虽然程序在HibernateSeeionFactory.closeSession处关闭了session,但程序依然可以在下面通过Student获取关联的Enrolment实体。如果程序将这个方法注释掉,程序会在下面的调用中引发LazyInitializationException异常(延迟初始化异常),导致该异常的典型原因就是,当程序试图获取延迟加载的关联实体或集合属性时,Session的关闭导致无法加载到关联实体或集合属性,程序就会引发LazyInitializationException异常了;

===========================================================

三.投影、聚合和分组

投影运算实际上就是一种基于列的运算,通常用于投影到指定列(也就是过滤其他列,类似于select子句的作用),还可以完成sql语句中常用的分组,组筛选等功能;

Hibernate的条件过滤中使用Projection代表投影运算,Projection是一个接口,而Projections作为Projection的工厂,负责生成Projection对象;

一旦产生了Projection对象之后,就可以通过Criteria提供的setProjection(Projection projection)方法来进行投影运算,从该方法上来看,每个Criteria只能接收一个投影运算,似乎无法进行多个投影运算,但实际上,hibernate又提供了一个ProjectionList类,该类是Projection的子类,并可以包含多个投影运算,通过这种方式即可完成多个投影运算;

因此,一个条件查询的投影运算通常有如下程序结构:

List cats = session.createCriteria(Cat.class)

.setProjection(Projections.projectionList()

.add(Projections.rowCount())

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

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

.add(Projections.min("weight"))

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

.list();

从上面的粗体字代码可以看出,所谓投影运算实际上和sql语句里的聚集函数,分组语句(group by子句)有类似的功能,使用条件查询的投影运算时,不能使用显示的分组子句,但某些投影的类型的实质就是分组投影,这些投影运算将会出现在sql语句的group by子句中,如上面的groupProperty("color")投影;

在Projections工具类提供了如下几个静态方法:

1>AggregateProjection avg(String propertyname):计算特定属性的平均值,类似于avg函数;

2>CountProjection count(String propertyname):统计查询结果在某列上的记录条数,类似于count(column)函数;

3>CountProjection countDistinct(String propertyname):统计查询结果在某列上不重复的记录条数,类似于count(distinct column)函数;

4>PropertyProjection groupProperty(String propertyname):将查询结果按某列上的值进行分组,类似于添加group by子句;

5>AggregateProjection max(String propertyname):统计查询结果在某列上的最大值,类似于max函数;

6>AggregateProjection min(String propertyname):统计查询结果在某列上的最小值,类似于min函数;

7>Projection rowCount():统计查询结果的记录条数,类似于count(*)的功能;

8>AggregateProjection sum(String propertyname):统计查询结果在某列上的总和,类似于sum函数;

下面的程序示范如何通过投影运算来进行分组,使用聚集函数功能:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Enrolment.class)
				.createAlias("student", "s")
				.setProjection(Projections.projectionList()
						//统计记录条数
						.add(Projections.rowCount())
						//统计选择该课程里最大的学生姓名
						.add(Projections.max("s.name"))
						//按照course进行分组
						.add(Projections.groupProperty("course")))
				.list();
		for(Object obj:list){
			Object[] objs = (Object[])obj;
			Course c = (Course)objs[2];
			System.out.println(c.getName());
			System.out.println(objs[0]);
			System.out.println(objs[1]);
			System.out.println("------------");
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
		
	}</strong></span>
上面程序为条件查询增加了分组功能,并通过Projections统计了每组的记录条数,统计Student名字最大的值;

从上面的程序可以看出,对于增加了投影运算后的条件查询,查询返回的结果是数组,数组的前N个元素依次是投影运算的结果,最后一个数组元素才是条件查询得到的实体,由此可见,投影运算的实质和group by子句,聚集函数的功能大致一致;

除此之外,如果希望对分组(投影)后的属性进行排序,那就需要为投影运算指定一个别名,为投影运算指定别名有如下三个方法:

1>使用Projections的alisa()方法为指定投影指定别名;

Projections的alias()方法为指定Projection指定别名,并返回Projection对象,一旦为指定Projection指定了别名,程序就可以根据该Projection别名来进行其他操作了,比如排序,条件查询示例如下

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Enrolment.class)
				.createAlias("student", "s")
				.setProjection(Projections.projectionList()
						//统计记录条数
						.add(Projections.rowCount())
						//统计选择该课程里最大的学生姓名,如果以这个为别名进行排序,原来的这个投影查询条件运算不能省略
						.add(Projections.max("s.name"))
						//按照course进行分组
						.add(Projections.groupProperty("course"))
						.add(Projections.alias(Projections.max("s.name"), "s")))
				.addOrder(Order.asc("s"))
				.list();
		for(Object obj:list){
			Object[] objs = (Object[])obj;
			Course c = (Course)objs[2];
			System.out.println(c.getName());
			System.out.println(objs[0]);
			System.out.println(objs[1]);
			System.out.println("------------");
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
上面程序示范了为Projection指定别名的方法;

2>使用SimpleProjection的as()方法为自身指定别名;

如果条件查询所使用的投影运算是SimpleProjection及其子类,则可以直接使用该投影对象的as()方法来为自身指定别名,条件查询如下:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Enrolment.class)
				.createAlias("student", "s")
				.setProjection(Projections.projectionList()
						//统计记录条数
						.add(Projections.rowCount())
						//统计选择该课程里最大的学生姓名,如果以这个为别名进行排序,原来的这个投影查询条件运算不能省略
						.add(Projections.max("s.name").as("s"))
						//按照course进行分组
						.add(Projections.groupProperty("course")))
				.addOrder(Order.asc("s"))
				.list();
		for(Object obj:list){
			Object[] objs = (Object[])obj;
			Course c = (Course)objs[2];
			System.out.println(c.getName());
			System.out.println(objs[0]);
			System.out.println(objs[1]);
			System.out.println("------------");
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>

3>使用ProjectionList的add()方法添加投影时指定别名;

ProjectionList的add()方法有两种重载形式:一种是直接添加一个投影,另一种是在添加投影时指定别名,示例如下:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Enrolment.class)
				.createAlias("student", "s")
				.setProjection(Projections.projectionList()
						//统计记录条数
						.add(Projections.rowCount())
						//统计选择该课程里最大的学生姓名,如果以这个为别名进行排序,原来的这个投影查询条件运算不能省略
						.add(Projections.max("s.name"),"s")
						//按照course进行分组
						.add(Projections.groupProperty("course")))
				.addOrder(Order.asc("s"))
				.list();
		for(Object obj:list){
			Object[] objs = (Object[])obj;
			Course c = (Course)objs[2];
			System.out.println(c.getName());
			System.out.println(objs[0]);
			System.out.println(objs[1]);
			System.out.println("------------");
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
除此之外,hibernate还提供了Property执行投影运算,Property投影的作用类似于sql语句中的select,条件查询的结果只有被Property投影的列才会被选出,示例如下:

如果只选择显示一列:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Enrolment.class)
				.setProjection(Property.forName("semester"))
				.list();
		for(Object obj:list){
			
			System.out.println(obj);
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
上面的条件查询执行的结果不在是对象集合,而是semester属性所组成的集合;

如果选择显示多列:

<span style="font-size:18px;"><strong>	public void Query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//使用createCriteria开始条件查询
		List list = sess.createCriteria(Enrolment.class)
				.setProjection(Projections.projectionList()
						.add(Property.forName("semester"))
						.add(Property.forName("year")))
				.add(Property.forName("name").eq("ss"))
				.list();
		for(Object obj:list){
			
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
上面的代码最后还能添加过滤条件,比如上面是name属性等于ss的记录

===========================================================

四.离线查询和子查询

条件查询的离线查询由DetachedCriteria来代表,DetachedCriteria类允许在一个Session范围之外创建一个查询,并且可以使用任意Session来执行它;

使用DetachedCriteria来执行离线查询,通常使用如下的方法来获得一个离线查询:

//创建指定持久化类的离线查询

DetachedCriteria.forClass(Class entity)

除此之外,DetachedCriteria还可代表子查询,当把DetachedCriteria传入Criteria中作为查询条件时,DetachedCriteria就变成了子查询,条件实例包含子查询通过Subqueries或者Property来获得;

如下程序示范了使用DetachedCriteria进行离线查询和子查询:

离线查询:

<span style="font-size:18px;"><strong>	public void Query(){
		//定义一个离线查询
		DetachedCriteria query = DetachedCriteria.forClass(Student.class)
				.setProjection(Property.forName("name"));
		//打开Session和事务
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//执行离线查询
		List list = query.getExecutableCriteria(sess).list();
		for(Object obj:list){
			System.out.println(obj);
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
子查询:

<span style="font-size:18px;"><strong>	public void Query(){
		//定义一个离线查询
		DetachedCriteria query = DetachedCriteria.forClass(Student.class)
				.setProjection(Property.forName("name"));
		//打开Session和事务
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		//执行子查询
		List<Student> list = sess.createCriteria(Student.class)
				//下面两行代码作用相同,都示范了通过子查询添加查询条件
				//.add(Property.forName("name").in(query))
				.add(Subqueries.propertyIn("name", query))
				.list();
		for(Student obj:list){
			System.out.println(obj.getName());
		}
		tx.commit();
		HibernateSessionFactory.closeSession();
	}</strong></span>
从上面的程序来看,当创建一个DetachedCriteria对象之后,该对象到底被作为离线查询使用还是作为子查询使用,都与DetachedCriteria无关;

如果程序使用Session的getExecutableCriteria()方法来执行DetachedCriteria对象,则他被当成离线查询使用,如果程序使用Property(或Subqueries的系列类方法)来操作DetachedCriteria对象,则他被当作子查询使用;

Property类提供了eq()、eqAll、ge()、geAll()、gt()、gtAll()、in等系列方法,这些方法与SQL子查询中的运算符一一对应,除此之外,Subqueries也提供了eq()、eqAll、ge()、geAll()、gt()、gtAll()、in等静态方法,这些方法与Property同名的实例方法的功能基本相似,在这种情况下,DetachedCriteria被当成子查询使用;

-----------------------------------------------------------------

补充1:

	public static void query(){
		Session sess = HibernateSessionFactory.getSession();
		Transaction tx = sess.beginTransaction();
		Criteria criteria = sess.createCriteria(User.class,"user");
		criteria.createCriteria("institution","institution");
		ProjectionList pList = Projections.projectionList();
		pList.add(Property.forName("user.id").as("aa"))
			.add(Projections.property("user.username").as("bb"))
			.add(Projections.property("institution.institutionName").as("cc"));
		criteria.setProjection(pList);
		criteria.setResultTransformer(Transformers.aliasToBean(Temp.class));
		List list = criteria.list(); 
		tx.commit();
		HibernateSessionFactory.closeSession();
	}

这个方法的含义是:

1>查询User类的指定字段;

2>查处的结果使用setResultTransformer方法进行规整,必须有一个Temp的类去接收指定的字段,如下:

package com.anlw.entity;

public class Temp {
	private int aa;
	private String bb;
	private String cc;
	public int getAa() {
		return aa;
	}
	public void setAa(int aa) {
		this.aa = aa;
	}
	public String getBb() {
		return bb;
	}
	public void setBb(String bb) {
		this.bb = bb;
	}
	public String getCc() {
		return cc;
	}
	public void setCc(String cc) {
		this.cc = cc;
	}
	
}


3>Property.froName()方法与Projections.property()方法的作用一样,都是指定自定义查询的字段;













3
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:46221次
    • 积分:654
    • 等级:
    • 排名:千里之外
    • 原创:25篇
    • 转载:0篇
    • 译文:0篇
    • 评论:6条
    文章分类
    最新评论