简介Spring中常用的hql查询方法

合集下载

hql union all 语句

hql union all 语句
HQL（Hibernate Query Language）是Hibernate框架的一种查询语言，类似于SQL，用于查询数据库中的数据。

HQL提供了丰富的查询语句来操作数据库。

UNION ALL是HQL中用于合并多个查询结果集的操作符。

它的作用是将多个查询的结果集按照列的顺序进行合并，并保留所有的重复记录。

UNION ALL的语法如下：
```
query1 UNION ALL query2
```
例如，假设有两个实体类ClassA和ClassB，它们分别对应数据库中的两张表classA_table和classB_table。

我们可以使用UNION ALL 来查询这两个表的数据并合并结果集。

示例HQL查询语句如下：```
SELECT a.id, FROM ClassA a
UNION ALL
SELECT b.id, FROM ClassB b
```
上述查询会返回一个包含两个实体类的对象列表，其中每个对象包含id和name这两个属性。

除了UNION ALL，HQL还提供了其他合并结果集的操作符，比如UNION（合并结果集并去除重复记录）和EXCEPT（从第一个查询结果集中去除第二个查询结果集中的记录）。

这些操作符可以帮助我们进行更加灵活的数据查询和筛选。

需要注意的是，HQL中的UNION ALL只能用于查询语句，无法直接用于更新和删除操作。

如果需要进行更新或删除操作，可以使用HQL 的其他语句或者结合SQL的操作来实现。

Hibernate 中的HQL查询的总结(夏杰)

Hibernate 中的HQL查询的总结一．Spring+Hibernate 中1.保存一个实体getHibernateTemplate().save(user);2.根据id号从数据库中查询到一个实体Useruser=(User)getHibernateTemplate().load(User.class,fromUse rId));3.删除一个实体方法一：直接删除getHibernateTemplate().delete((Message)；方法二：嵌套一个根据id号查询到一个实体，再删除getHibernateTemplate().delete((Message)getHibernateTempla te().load(Message.class, msgId));4.查询符合添加的记录的个数，函数count(*)Object obj = getSession().createQuery("select count(*)from Message where recepUser.id="+recepUserId+" and msgType=1").uniqueResult();//表示只返回一个结果5.修改一个实体getHibernateTemplate().update(message);6.设定查询记录的起始位置和得到的记录数List<Message> list = getSession().createQuery("from Message where (fromUser.id="+userId+" or recepUser.id="+userId+") and msgType=2 order by id desc").setMaxResults(想要得到的记录数).setFirstResult(取得记录的起点).list();7. intValue()返回的结果是整数int msgCount=((Long)getSession().createQuery("select count(*) from Message where from User.id="+userId+" or recepUser.id="+userId).uniqueResult()).intValue();二．只有Hibernate 中1.保存数据/*** 保存数据** @param t传入的泛型* @return*/public boolean save(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.save(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}2.删除数据/*** 删除数据** @param t传入的泛型* @return*/public boolean delete(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.delete(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}3.修改数据/*** 修改数据** @param t传入的泛型* @return*/public boolean update(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.update(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}4.查询单条数据，返回查询得到的唯一的结果实体对象/*** 查询单条数据** @param hql* @return返回查询得到的唯一的结果实体对象*/public T queryFrom(String hql) {// T表示泛型对象,T泛型定义T t = null;// 引用实体对象session = HibernateUtil.getSession();try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询語句t = (T) query.uniqueResult();// 将查询结果转换为实体对象session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return t;// 返回查询得到的实体对象}5.通过泛型定义的查询多条语句方法/*** 通过泛型定义的查询多条语句方法** @param hql** @return 查询得到的结果集List*/public List<T> queryList(String hql) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合对象}6. 返回指定条数的查询结果的方法/*** 返回指定条数的查询结果的方法** @param hql* @param showNumber所要查询的数据的结果的条数* @return返回查询得到的集合对象*/public List<T> queryTypeListNumber(String hql, int showNumber,Type type) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句// for(int i=0;i<params.length;i++){//把传递过来的参数数组遍历出来，遍历赋值给hql语句中的未知待定数据// query=query.setParameter(i, params[i]);// }query=query.setParameter(0, type);query.setMaxResults(showNumber);// 设这所要查询的数据的结果的条数list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合集合对象}7.查询所有用户信息String hql = "from User";list = session.createQuery(hql) //创建Query对象 .list();8.保存用户session.save(user);9.通过用户名和密码查询用户（参数不一定，用动态赋值）//HQL查询语句String hql = "from User u where ername=? and u.password=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username)//动态赋值.setParameter(1, password);//动态赋值10.判断指定用户名的用户是否存在//HQL查询语句String hql = "from User u where ername=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username);//动态赋值Object user = query.uniqueResult();//返回User对象//如果用户存在exist为trueif(user != null){exist = true;}11.根据id删除一条留言信息//加载指定id的留言信息Message message = (Message)session.get(Message.class, id);session.delete(message); //删除留言12.查询所有文章中都有哪些作者（Group By）hql = "select author from ArticleInfo group by author";//查询文章详细信息的hql语句List authorList = objectDao.queryListObject(hql);//执行查询request.setAttribute("authorList", authorList);13.分组查询，各部门名称和各部门的人数（Group By）hql="select u.dept,count(*) from User u group by u.dept";Query query=session.creatQuery(hql);List<Object[]> list=query.list();//object[]是数组，可以同时多个属性查询obj[o],obj[1],obj[2],,,,//for循环输出信息For(object[] obj;list){Sysout.("部门"+obj[0]);Sysout.("人数"+obj[1])}14.查询文章的回复// 文章回复内容的详细查询hql = "from ReArticleInfo where re_id=" + id + " order by id desc";//查询文章详细内容的hql语句ObjectDao<ReArticleInfo> re_objectDao = new ObjectDao<ReArticleInfo>();//实例化持久化类List<ReArticleInfo> list = null;//定义List集合15.In的条件嵌套查询（双重条件，条件在其他表中）跨表hql_article_commend = "from ArticleInfo where commend='是' and author in (select account from UserInfo where freeze='解冻')";hql_article_vistor = "from ArticleInfo where author in (select account from UserInfo where freeze='解冻') order by visit desc";16.多对一映射在user表中，通过Author对象查询userString hql="from Category c wherec.typeName='"+category.getTypeName()+"'andc.author='"+category.getAuthor().getId()+"'";。

hql对数据库的查询语句

hql对数据库的查询语句HQL是Hibernate Query Language的缩写，是Hibernate框架中用于数据库查询的一种查询语言。

HQL语句类似于SQL语句，但是它面向对象，直接操作对象而不是表。

下面列举了10个常用的HQL查询语句示例：1. 查询所有记录：```hqlSELECT * FROM 表名```2. 查询指定字段的记录：```hqlSELECT 字段1, 字段2 FROM 表名```3. 条件查询：```hqlSELECT * FROM 表名 WHERE 条件```4. 模糊查询：```hqlSELECT * FROM 表名 WHERE 字段 LIKE '%关键字%'```5. 分页查询：```hqlSELECT * FROM 表名 LIMIT 起始位置, 每页数量```6. 排序查询：```hqlSELECT * FROM 表名 ORDER BY 字段 ASC/DESC```7. 连接查询：```hqlSELECT * FROM 表1, 表2 WHERE 表1.字段 = 表2.字段```8. 统计查询：```hqlSELECT COUNT(*) FROM 表名```9. 分组查询：```hqlSELECT 字段, COUNT(*) FROM 表名 GROUP BY 字段```10. 子查询：```hqlSELECT * FROM 表名WHERE 字段IN (SELECT 字段FROM 表名WHERE 条件)```以上是一些常用的HQL查询语句示例，通过使用不同的关键字和语法结构，可以实现各种复杂的查询需求。

在实际使用中，可以根据具体情况调整查询语句，灵活运用HQL来满足业务需求。

总结一下，HQL是Hibernate框架中用于数据库查询的一种查询语言，它类似于SQL语句，但是更加面向对象。

通过使用不同的关键字和语法结构，我们可以实现各种复杂的查询需求，例如条件查询、模糊查询、分页查询、排序查询、连接查询、统计查询、分组查询和子查询等。

HQL多表查询

6.4 HQL的多表查询对象之间总是有各种各样的关系，关联关系是类之间最常见的关系。

多表查询是H QL中的强大功能之一，包括内连接、左连接和右连接等。

多表查询的设置及运行都比较麻烦，在运行本节中的示例时，务必保证每一步都没有错误。

6.4.1 表之间的关联关系在数据库joblog中用到了3个表：student（学生表）、course（课程表）和sc （选课表）。

这些表的详细信息见6.1.1节“示例中用到的默认数据库表和数据”。

在现实模型中，一个学生可以选择多门课程，一个课程可以被多个学生选择，student和course是多对多的关联关系。

为了便于演示HQL的多表查询，本节中假设student和course之间是单向关联关系。

在多对多的关联关系中，一般来说有个中间表，这个表描述了多对多关系，这就是选课表sc，sc每一行数据代表一个学生的选课和成绩。

各个表的主键、外键设置如下。

student表的主键是id字段。

course表的主键是id字段。

sc表的主键是id字段。

sc表中的Sno字段是student表id字段的外键。

sc表中的Cno字段是course表id字段的外键。

图6-8是3个表之间关系的直观表示。

图6-8 3个表之间的关系在MySQL Query Browser中设置好上述关系。

如果此处设置不正确，可能会影响多表连接查询。

其中sc表的建表信息如下（其中包含了外键关系）。

CREATE TABLE 'joblog'. 'sc' ('id' int(10) unsigned NOT NULL auto_increment COMMENT 'id','Sno' int(10) unsigned NOT NULL default '0' COMMENT '学号','Cno' int(10) unsigned NOT NULL default '0' COMMENT '课程号','Grade' int(10) unsigned default NULL COMMENT '成绩',PRIMARY KEY ('id'),KEY 'FK_sc_1' ('Sno'),KEY 'FK_sc_2' ('Cno'),CONSTRAINT 'FK_sc_1' FOREIGN KEY ('Sno') REFERENCES 'student' ('id'), /* 外键信息 */ CONSTRAINT 'FK_sc_2' FOREIGN KEY ('Cno') REFERENCES 'course' ('id') /* 外键信息 */ ) ENGINE=InnoDB DEFAULT CHARSET=gb2312;6.4.2 表中的数据这一节中用到了3个表的数据，student表和course表的数据如6.1节中图6-2和6-4所示，但是sc表的内容变为图6-9所示的数据，其中Sno和Cno存储的分别是student表和course表中对应的主键值。

---Spring中常用的hql查询方法

示例：
User u=new User();
u.setPassword("123");//必须符合的条件但是这两个条件时并列的（象当于sql中的and）
u.setName("bb");
list=this.getHibernateTemplate().findByExample(u,start,max);
ValueBean valueBean= new ValueBean();
valueBean.setMyName("test");
valueBean.setMyPasswrod("123");
2、
String queryString= "from er u where =:myName and u.password=:myPassword";
u.setName("bb");
list=this.getHibernateTemplate().findByExample(u,start,max);
返回：用户名为bb密码为123的对象
五、findByExample(Object exampleEntity, int firstResult, int maxResults)
<![CDATA[
from er
]]>
</query>
</hibernate-mapping>
2、如下使用查询：
this.getHibernateTemplate().findByNamedQuery("queryAllUser");

hql查询语句

.1.from子句from Person表明从Person持久化类中选出全部的实例。

推荐：from Person as p2.select子句select from Person as pselect .firstName from Person as pselect new list(, p.address) from Person as pselect new ClassTest(, p.address) from Person as p (有前提)select as personName from Person as pselect new map( as personName) from Person as p (与new map()结合更普遍) 3.统计函数查询:1: count() 统计记录的条数2: min() 求最小值3: max() 求最大值4: sum() 求和4: avg() 求平均值//取得Student的数量Query query=session.createQuery("select count(*) from Student")//avg()取得Student平均年龄Query query=session.createQuery("select avg(s.age) from Student as s")//upper()方法将字符串转为大写Query query=session.createQuery("select upper() from Student as s")//去除重复行distinctQuery query=session.createQuery("select distinct s.age from Student as s") select count(*) from Personselect max(p.age) from Person as pselect || "" || p.address from Person as p4.多态查询from Person as pfrom ng.Object ofrom Named as n5.where子句from Person where name like "tom%"from Person as p where like "tom%"from Cat cat where like "kit%"select * from cat_table as table1 cat_table as table2 where table1.mate = table2.id and like "kit%"from Foo foo where foo.bar.baz.customer.address.city like "fuzhou%" from Cat cat, Cat rival where cat.mate = rival.mateselect cat, matefrom Cat cat, Cat matewhere cat.mate = matefrom Cat as cat where cat.id = 123from Cat as cat where cat.mate.id = 69from Person as personwhere person.id.country = 'AU'and person.id.medicareNumber = 123456from Account as accountwhere account.owner.id.country = 'AU'and account.owner.id.medicareNumber = 123456from Cat cat where cat.class = DomesticCatfrom Account as a where .firstName like "dd%" // 正确from Account as a where like "dd%" // 错误6.表达式=, <>, >, <, >=, <=, between, not between, in, not in, is, like等。

hibernate查询数据库的三种方式

Hibernate查询数据库的三种方式一、Hibernate的HQL与SQL查询1.Hql（Hibernate Query Language）是面向对象的查询查询方式，HQL查询提供了更加丰富的和灵活的查询特性，因此Hibernate将HQL查询方式立为官方推荐的标准查询方式，提供了类似标准SQL语句的查询方式，同时也提供了面向对象的封装。

HQL查询语句from关键字后面跟的类名＋类对象，where后用对象的属性做条件；示例代码：（User是映射数据库的一个类）public boolean checkUser(UserForm userForm){//TODO Auto-generated method stub//String HQLString="from User u whereername='"+userForm.getUsername()+"'";String HQLString="from User u where ername=:uname";Session session=HibernateSessionFactory.currentSession();//获取事务session.beginTransaction();Query query=session.createQuery(HQLString);query.setParameter("uname",userForm.getUsername());//绑定参数Object list=query.list().get(0);//list获取数据集，get获取数据集的某条记录//提交事务session.getTransaction().commit();//关闭SessionHibernateSessionFactory.closeSession();User user=(User)list;if(user.getPassword().equals(userForm.getPassword())){return true;}else{return false;}}2.sql是面向数据库表查询，from后面跟的是表名，where后用表中字段做条件；示例代码：([xxdb].[dbo].[student]就是要查询的数据库表)public boolean checkUser(UserForm userForm){//TODO Auto-generated method stub//String SQLString="select*from[xxdb].[dbo].[student]u whereerName='"+userForm.getUsername()+"'";String SQLString=”select*from[xxdb].[dbo].[student]u whereerName=:uname”;Session session=HibernateSessionFactory.currentSession();session.beginTransaction();//Query query=session.createSQLQuery(SQLString).addEntity(User.class);//实体查询Query query=session.createSQLQuery(SQLString).addScalar("userid",StandardBasicTypes.INTEGER).addScalar("username",StandardBasicTypes.STRING).addScalar("password",StandardBasicTypes.STRING).addScalar("gender",StandardBasicTypes.INTEGER);//标量查询query.setParameter("uname",userForm.getUsername());//绑定参数Object list=query.list().get(0);//list获取数据集，get获取数据集的某条记录session.getTransaction().commit();HibernateSessionFactory.closeSession();User user=(User)list;if(user.getPassword().equals(userForm.getPassword())){return true;}else{return false;}}3.对比hql和sql查询方式我们可以发现他们之间的不同：a.首先是查询语句的不同，hql语句from后面跟的类名＋类对象，where后用对象的属性做条件，而sql语句from后面跟的是表名，where后用表中字段做条件，这也就是面向对象和面向数据库的一个区别。

Hibernate查询sql结果行数、查询列表的几种方法

Hibernate查询sql结果⾏数、查询列表的⼏种⽅法⼀、前⾔这个东西，难度⼏乎没有，就是繁琐。

⼀条简单的select count（*） from table_name都能有多种书写⽅式。

总是忘，这⾥记录下。

⼀、通过Criteria 查询查询⾏数：Criteria criteriaCount = getCriteria();criteriaCount = criteriaCount.add(Restrictions.eq("dispatchTaskId", dispatchTaskId));criteriaCount.setProjection(Projections.rowCount());Integer totalCount = ((Long) criteriaCount.uniqueResult()).intValue();查询列表：Criteria criteria = getCriteria();criteria.add(Restrictions.eq("eventId", eventInformationId));List<EventTaskAssignment> list = criteria.list();⼆、通过原⽣sql查询查询⾏数：SQLQuery queryCount = getSession().createSQLQuery("SELECT COUNT(*) FROM incidentInformation WHERE ii.incidentInformationId = :incidentInformationId AND dti.taskstate = :taskstate");queryCount.setParameter("incidentInformationId", incidentInformationId);queryCount.setParameter("taskstate", ETaskStatus.STATUS_INIT.getStatusValue());int count = ((BigDecimal) queryCount.uniqueResult()).intValue();return count;查询列表：1、返回的item为数据库表对应poSQLQuery query = getSession().createSQLQuery(sqlQuery);query.setParameter("userId", userId);query.addEntity(EventTaskAssignment.class);List<EventTaskAssignment> items = query.list();2、返回的item为voSQLQuery query = getSession().createSQLQuery(sqlBuffer.toString());query.setParameter("eventInformationId", eventInformationId);query.addScalar("userId", StandardBasicTypes.STRING);query.addScalar("userName", StandardBasicTypes.STRING);query.setResultTransformer(Transformers.aliasToBean(UserRoles.class));List<UserRoles> list = query.list();三、通过hibernate的查询语⾔查询String countHql = "select count(*) from a where and a.approveResult = :approveResult and a.approverId = :approverId";Query countQuery = getSession().createQuery(countHql);countQuery.setParameter("approverId", approverId);int count = ((Long) countQuery.uniqueResult()).intValue();。

hql查询语句用法详解

hql查询语句用法详解HQL（Hive Query Language）是用于查询和操作Apache Hive数据仓库的查询语言。

HQL类似于SQL（Structured Query Language），但在某些方面有所不同。

下面是HQL查询语句的用法详解：1. 查询语法:SELECT [DISTINCT] column_listFROM table_name[WHERE condition][GROUP BY column_list][HAVING condition][ORDER BY column_list [ASC|DESC]][LIMIT n]●`SELECT`子句指定要从表中检索的列，可以使用`*`表示所有列，也可以指定特定的列。

●`DISTINCT`关键字可选，用于去除结果中的重复行。

●`FROM`子句指定要查询的表名。

●`WHERE`子句可选，用于指定查询的条件。

●`GROUP BY`子句可选，用于对结果进行分组。

●`HAVING`子句可选，用于指定对分组结果的条件。

●`ORDER BY`子句可选，用于对结果进行排序，默认为升序（ASC），也可以指定降序（DESC）。

●`LIMIT`子句可选，用于限制结果集的行数。

2. 过滤条件:在`WHERE`子句中，可以使用比较运算符（例如`=`, `<>`, `<`, `>`, `<=`, `>=`）进行条件过滤，也可以使用逻辑运算符（例如`AND`, `OR`, `NOT`）进行条件组合。

例如：SELECT * FROM employees WHERE salary > 5000 AND department = 'IT'3. 聚合函数:HQL支持常见的聚合函数，例如`COUNT`, `SUM`, `AVG`,`MIN`, `MAX`等。

这些函数通常与`GROUP BY`子句一起使用来对数据进行统计分析。

Spring试题及答案

Spring考试试题1)下面关于Spring的说话正确的是（）（选择两项）A）Spring是一个重量级的框架B）Spring是一个轻量级的框架C）Spring是一个IOC和AOP容器D）Spring是一个入侵式的框架2）下面关于IOC的理解，正确的是（）（选择两项）A）控制反转B）对象被动的接受依赖类C）对象主动的去找依赖类D）一定要用接口3）下面关于AOP的理解，正确的是（）（选择两项）A）面向纵向的开发B）面向横向的开发C）AOP关注是面D）AOP关注的是点4）Spring的组成一共有（）块组成。

A）1 B）3 C）5 D）75）Spring各模块之间关系（）（选择两项）A）Spring各模块之间是紧密联系的，相互依赖的B）Spring各模块之间可以单独存在C）Spring的核心模块是必须的，其他模块是基于核心模块D）Spring的核心模块不是必须的，可以不要6）Spring核心模块的作用（）A）做AOP的B）做IOC的，用来管理Bean的C）是用来支持HiberneteD）是用来支持Struts的7）对Hibernate的支持主要用到Spring的那个模块（）A）Spring核心模块B）Spring ORM模块C）Spring MVC模块D）Spring Web模块8）对Struts的支持主要用到Spring的那个模块（）A）Spring核心模块B）Spring ORM模块C）Spring MVC模块D）Spring Web模块9）Spring的通知类型有（）（多项选择）A）Before通知B）After return通知C）Throws通知D）Around通知10）下面关于切入点的说法正确的是（）（多项选择）A）是AOP中一系列连连接点的集合B）在做AOP时定义切入点是必须的C）在做AOP时定义切入点不是必须的D）可以用正则表达式来定义切入点11)Spring包装Hibernate之后的Hibernate的DAO应该继承那个类（）A）HibernateDAOB）SessionFactoryC）HibernateDAOSuportD）Session12）下面对Spring包装Struts1.2的说法正确的是（）（选择两项）A）Spring包装Struts的ActionServletB）Spring包装Struts的ActionC）主要是利用Spring的依赖注入D）主要利用Spring的面向方面的编程13）Spring包装Struts时那些Spring模块是必须的（）（选择两项）A）Spring核心模块B）Spring AOP模块C）Spring MVC模块D）Spring WEB模块14)Spring中Before通知的目标对象要实现的接口是（）A）MethodBeforeAdviceB）ThrowsAdviceC）AfterReturningAdviceD）MethodInterceptor15）Spring中around通知的目标对象要实现的接口是（）A）MethodBeforeAdviceB）ThrowsAdviceC）AfterReturningAdviceD）MethodInterceptor16）Spring中Before通知的目标对象要实现的接口中before方法中的三个常用的参数依次是（）A）方法，方法的参数，目标对象B）方法的参数，方法，目标对象C）目标对象，方法，方法的参数D）方法的参数，目标对象，方法17）Spring中around通知的目标对象要实现的接口中invoke中方法的参数是（）A）方法B）目标对象C）方法执行参数D）Exception18）下面是Spring依赖注入方式的是（）（选择两项）A）set方法注入B）构造方法的注入C）get方法的注入D）接口的注入19）下面关于在Spring中配置Bean的id属性的说法正确的是（）（选择两项）A）id属性是必须，没有id属性就会报错B）id属性不是必须的，可以没有C）id属性的值可以重复D）id属性的值不可以重复20）下面关于在Spring中配置Bean的name属性的说法正确的是（）（选择两项）A）name属性是必须，没有name属性就会报错B）name属性不是必须的，可以没有C）name属性的值可以重复D）name属性的值不可以重复21)下面是IOC自动装载方法的是（）（选择两项）A）byNameB）byTypeC）constructorD）byMethod22）下面关于在Spring中配置Bean的init-method的说法正确的是（）A）init-method是在最前面执行的B）init-method在构造方法后，依赖注入前执行C）init-method在依赖注入之后执行D）init-method在依赖注入之后，构造函数之前执行23）下面关于Spring配置文件说话正确的是（）（选择两项）A）Spring配置文件必须叫applicationContext.xmlB）Spring配置文件可以不叫applicationContext.xmlC）Spring配置文件可以有多个D）Spring配置文件只能有一个24）看下面的代码，说法正确的是（）<bean id="userTable" class="erTable"><property name="userName"><value>ACCP</value></property></bean>A）其中<property name="userName">的userName是UserTable中的属性，可以不要get、set方法。

hql语句

hql语句什么是HQL呢？HQL是Hibernate Query Language的缩写，提供更加丰富灵活、更为强大的查询能力；HQL更接近SQL语句查询语法。

同时也提供了更加面向对象的封装。

完整的HQL语句形势如下：Select/update/delete……from …… where …… group by …… having …… order by …… asc/desc 非常类似标准的SQL语句。

1、实体查询：String hql ="from Customer c";List<Customer> list = session.createQuery(hql).list();可以看到所有的关联信息全部查出来了。

上面的代码执行结果是，查询出Customer实体对象所对应的所有数据，而且将数据封装成Admin实体对象，并且放入list中返回。

因为HQL语句与标准SQL语句相似，所以我们也可以在HQL 语句中使用where字句，并且可以在where字句中使用各种表达式，比较操作符以及使用“and”,”or”连接不同的查询条件的组合。

看下面的一些简单的例子：fromUseruserwhereuser.age=20;fromUseruserwhereuser.age between20and30;fromUseruserwhereuser.agein(20,30);isnull; like‘%zx%’;fromUseruserwhere(user.age%2)=1;fromUseruserw hereuser.age= like ‘%zx%’;2.实体的更新与删除如果我们想将数据库中所有18岁的用户的年龄全部改为20岁，那么我们要首先将年龄在18岁的用户检索出来，然后将他们的年龄修改为20岁，最后调用Session.update()语句进行更新。

如下面的代码：Transaction trans=session.beginTransaction();String hql=”update User user set user.age=20 where user.age=18”;Query queryupdate=session.createQuery(hql);intret=queryupdate.executeUpdate();trans.mit();3. 属性查询很多时候我们在检索数据时，并不需要获得实体对象所对应的全部数据，而只需要检索实体对象的部分属性所对应的数据。

java hql hibernate 正则

在Java Hibernate中，HQL（Hibernate Query Language）是用于在Hibernate框架中执行查询的查询语言。

而正则表达式则是一种用于匹配和搜索字符串模式的工具。

在HQL中使用正则表达式，可以通过使用REGEXP关键字来实现。

以下是一个示例查询，演示如何在HQL中使用正则表达式：
java
String hql = "FROM Employee E WHERE REGEXP '.*经理.*'";
Query query = session.createQuery(hql);
List<Employee> employees = query.list();
在上面的示例中，查询从Employee表中选择所有名称中包含"经理"的员工。

REGEXP关键字用于指定正则表达式模式，'.*经理.*'表示匹配包含"经理"的任意字符串。

请注意，具体的正则表达式语法可能因数据库和Hibernate版本而有所不同。

上述示例中的正则表达式语法适用于大多数数据库和Hibernate版本，但具体情况可能会有所差异。

建议查阅相关文档以获取特定数据库和Hibernate版本的详细信息。

hql基本语句

hql基本语句（最新版）目录1.HQL 简介2.HQL 基本语句分类3.查询语句示例4.插入语句示例5.更新语句示例6.删除语句示例正文1.HQL 简介HQL（Hibernate Query Language）是 Hibernate 的一种查询语言，它可以用来操作数据库。

HQL 是基于 SQL 的，但它的语法和 SQL 有所不同。

使用 HQL 可以实现对数据库的查询、插入、更新和删除等操作。

2.HQL 基本语句分类HQL 基本语句主要分为四类：查询语句、插入语句、更新语句和删除语句。

3.查询语句示例查询语句用来从数据库中获取数据。

以下是一个查询语句示例：```select * from User where age > 18;```4.插入语句示例插入语句用来向数据库中插入数据。

以下是一个插入语句示例：```insert into User (name, age) values ("Tom", 20);```5.更新语句示例更新语句用来更新数据库中的数据。

以下是一个更新语句示例：```update User set age = age + 1 where age > 18;```6.删除语句示例删除语句用来删除数据库中的数据。

以下是一个删除语句示例：```delete from User where age > 25;```通过使用 HQL 语句，我们可以方便地操作数据库，提高开发效率。

Spring中表达式语言spring-expression简单使用

Spring 中表达式语⾔spring-expression 简单使⽤前⾔Spring Expression Language （简称 SpEL ）是⼀个⽀持查询和操作运⾏时对象导航图功能的强⼤的表达式语⾔，它的语法类似于传统 EL(如jsp 中的EL 表达式)，但提供额外的功能，最出⾊的就是函数调⽤和简单字符串的模板函数。

SpEL 作为Spring 框架的基础，但并不依赖于Spring 容器，可以独⽴使⽤。

简单使⽤引⼊maven 依赖简单字⾯量⽀持字符串，⽇期，数值(整型，浮点型，⼗六进制)，布尔等类型输出结果为变量引⽤通过#'变量名'的⽅式来使⽤变量<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.1.RELEASE</version></dependency>//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//解析表达式并获取结果System.out.println(expressionParser.parseExpression("'hello'").getValue());System.out.println(expressionParser.parseExpression("123").getValue());System.out.println(expressionParser.parseExpression("12.34").getValue());System.out.println(expressionParser.parseExpression("10e2").getValue());System.out.println(expressionParser.parseExpression("true").getValue());System.out.println(expressionParser.parseExpression("new java.util.Date()").getValue());hello12312.341000.0trueSat Sep 25 19:39:38 CST 2021//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext();//设置变量evaluationContext.setVariable("a", 12);evaluationContext.setVariable("b", 34);evaluationContext.setVariable("c", 56);//解析表达式System.out.println(expressionParser.parseExpression("#a+#b-#c").getValue(evaluationContext));输出为-10对象的属性和⽅法定义⼀个普通beanpublic class User {private String name;public User(String name) { = name;}public void setName(String name) { = name;}public String getName() {return name;}}通过对象.属性的⽅式来引⽤//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext(); evaluationContext.setVariable("user", new User("lisi"));System.out.println(expressionParser.parseExpression("#").getValue(evaluationContext)); System.out.println(expressionParser.parseExpression("#user.getName()").getValue(evaluationContext));输出为lisilisi数组，集合，map//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext();//设置数组变量evaluationContext.setVariable("users", new User[]{new User("Tom")});//设置集合变量evaluationContext.setVariable("userList", Collections.singletonList(new User("Mary")));//设置map变量evaluationContext.setVariable("userMap", Collections.singletonMap("u123", new User("u123")));System.out.println(expressionParser.parseExpression("#users[0].name").getValue(evaluationContext)); System.out.println(expressionParser.parseExpression("#userList[0].name").getValue(evaluationContext)); System.out.println(expressionParser.parseExpression("#userMap['u123'].name").getValue(evaluationContext));输出为TomMaryu123普通⽅法调⽤和在Java中使⽤没有区别//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();System.out.println(expressionParser.parseExpression("'hello'.substring(2)").getValue());输出为llo操作符⽀持关系操作符(⼤于⼩于等于)，逻辑操作符(and or not)，算数操作符(加减乘除)//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();System.out.println(expressionParser.parseExpression("1 < 4").getValue());System.out.println(expressionParser.parseExpression("1 < 4 and 5 > 9 ").getValue());System.out.println(expressionParser.parseExpression("1 + 3 - 5").getValue());引⽤IOC容器中的bean定义bean的配置⽂件import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;@Configurationpublic class BeanConfig {@Beanpublic User user() {return new User("lisi");}}默认⽀持#{}的格式来引⽤bean//创建表达式解析器ExpressionParser expressionParser = new SpelExpressionParser();//创建数据上下⽂StandardEvaluationContext evaluationContext = new StandardEvaluationContext();//创建IOC容器上下⽂ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);//创建bean表达式上下⽂BeanExpressionContext beanExpressionContext = new BeanExpressionContext((ConfigurableBeanFactory) context.getAutowireCapableBeanFactory(), null); evaluationContext.setRootObject(beanExpressionContext);//添加属性访问器从IOC容器中获取beanevaluationContext.addPropertyAccessor(new BeanExpressionContextAccessor());System.out.println(expressionParser.parseExpression("#{}", new TemplateParserContext()).getValue(evaluationContext));输出为lisi@Value注解我们在项⽬中很多地⽅都会⽤到@Value注解@Value("${name}")private String name;@Value("#{}")private String personName;解析@Value注解的过程就会使⽤到SpELpublic class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactoryimplements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {@Nullablepublic Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);try {Object shortcut = descriptor.resolveShortcut(this);if (shortcut != null) {return shortcut;}Class<?> type = descriptor.getDependencyType();Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {//字符串类型就表⽰是@Value注解注⼊if (value instanceof String) {// 使⽤StringValueResolver处理${}占位符String strVal = resolveEmbeddedValue((String) value);BeanDefinition bd = (beanName != null && containsBean(beanName) ?getMergedBeanDefinition(beanName) : null);//处理bean表达式，#{}这种格式value = evaluateBeanDefinitionString(strVal, bd);}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());try {return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());}catch (UnsupportedOperationException ex) {// A custom TypeConverter which does not support TypeDescriptor resolution...return (descriptor.getField() != null ?converter.convertIfNecessary(value, type, descriptor.getField()) :converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));}}......}@Nullableprotected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition) { if (this.beanExpressionResolver == null) {return value;}Scope scope = null;if (beanDefinition != null) {String scopeName = beanDefinition.getScope();if (scopeName != null) {scope = getRegisteredScope(scopeName);}}return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));}}默认使⽤的beanExpressionResolver为StandardBeanExpressionResolver。

HibernateHQL--实体、属性查询,全参数绑定,引用查询

是Hibernate官方推荐的查询模式，比Criteria功能更强大。

1）实体查询:出现类名和属性名必须注意大小写区分；当不同路径下存在相同类名，需要写入在hql中写入包名；查询目标实体存在着继承关系，将查询目标的所有子类的库表记录一起返回。

String hql = “from TUser”;Query query = session.createQuery(hql);List list = query.list();2）属性查询：有时页面不需要取整个对象，而只取某个属性。

List list = session.createQuery(“select user.age from TUser user”).list();Iterator it = list.iterator();while(it.hasNext()){//返回的list中，每个条目都是一个对象数组，依次包含我们所获取的数据。

Object[] results = (Object[])it.next();System.out.println(results[0]);System.out.println(results[1]);}注：如果觉得返回数组的方式不够灵活，可以在HQL中构造对象实例。

List list = this.session.createQuery(“select new TUser(,user.age) from TUser user”).list();Iterator it = list.iterator();while(it.hasNext()){TUser user = (TUser)it.next();System.out.println(user.getName());}注：通过HQL动态构造对象实例，此时查询结果中的TUser对象只是一个Java对象，仅用于对查询结果的封装，除了在构造时赋予的属性值之外，其他属性均为未赋值状态，当我们通过session对此对象进行更新，将导致对user对象的数据库插入一条新数据，而不是更新原有对象。

HQL语句的用法

HQL语句的用法一个ORM框架是建立在面向对象的基础上的。

最好的例子是Hibernate如何提供类SQL查询。

虽然HQL的语法类似于SQL，但实际上它的查询目标是对象。

HQL拥有面向对象语言的所有的特性，这其中包括多态、继承和组合。

这就相当于一个面向对象的SQL，为了提供更强大的功能，HQL还提供了很多的查询函数。

这些函数可以被分为四类：1. 投影函数2. 约束函数3. 聚合函数4. 分组函数使用HQL可以建立简单的查询，也可以建立更复杂的查询。

在本文中并不讨论那些非常复杂的查询，如含有子查询和很多连接的查询。

本文只讨论连接两个表的查询。

现在让我们开始接近HQL吧！投影如谓投影，就是一个可以访问的对象或对象的属性。

在HQL中，可以使用from和select子句来完成这个工作。

from子句返回指定的类的所有实例。

如from Order将返回Order类的所有实例。

换句话说，以上的查询相当于以下的SQL语句：select * from orderfrom 是最简单的查询子句。

from后面可以跟一个或多个类名（类名也可以带有别名）。

为了得到Order和Product的所有实例，可以使用如下的查询：from Order, Product和类名一样，别名也可以在from后使用，如下代码如示：from Order as o, Product p当查询很复杂时，加入别名可以减少语句的长度。

我们可以看看如下的SQL语句：select o.*, p.* from order o, product p where o.order_id = p.order_id我们可以很容易看出，上面的查询是一对多的关系。

在HQL中相当于一个类中包含多个其它类的实例。

因此，以上的SQL写成HQL就是：from Order as o inner join o.products as product现在让我们考虑另外一个从表中得到指定属性的情况。

HQL详解

除了有当前session创建的criteria接口外，Hibernate还提供了在session不可用时，组织查询语句的游离态的DetachCriteria类，它的查询条件设置与criteria类似，只是它不由session创建，而是在需要session可用时，再调用getExecutableCriteria()执行查询。
(2) 根据需要使用add函数设置各种criterion查询条件，使用setProjection设置projection
(3) 调用Criteria的list或者scroll方法即执行查询语句，检索数据库，把查询结果返回放在List或ScrollableResults中。
(4) 读取List和ScrollableResults，即可取出查询对象。
图8-1是Criteria相关类的结构图。
图8-1 Criteria相关类图
由图8-1可见，Criteria接口和DetachedCriteria类都继承了CriteriaSpecification接口，开发人员在使用QBC查询时，都是直接选择用Criteria或DetachedCriteria。而它们两个都是一样使用可以设置各种查询条件或者查询结果的Criterion，Projection等接口。
Criteria crit=detachedCriteria.getExecutableCriteria(session);
List results = crit.list();
DetachedCriteria 提供了4个静态方法forClass(Class)或forEntityName(Name)进行DetachedCriteria实例的创建。DetachedCriteria也提供了add(Criterion)、addOrder(Order)、setProjection(Projection)、createAlias()、createCriteria()等方法用于构造查询及其返回结果，与Criteria提供的函数不同的是，DetachedCriteria类提供的函数返回也是DetachedCriteria 类。

spring练习题

1.MVC设计模式的目的是【 D 】A.使程序结构更清晰B.使程序更好维护C.保证视图和模型的隔离 D在逻辑上将视图、模型和控制器分开2、在三层结构中，数据访问层承担的责任是【 A 】A.定义实体类B.数据的增删改查操作C.业务逻辑的描述D.页面展示和控制转发3、下面关于数据持久化概念的描述，错误的是【 B 】A.保存在内存中数据的状态是瞬时状态B.持久状态的数据在关机后数据依然存在C.数据可以由持久状态转换为瞬时状态D.将数据转换为持久状态的机制称为数据持久化4、下面关于Hibernate的说法，错误的是【 C 】A.Hibernate是一个“对象-关系映射”的实现B.Hibernate是一种数据持久化技术C.Hibernate是JDBC的替代技术D.使用Hibernate可以简化持久化层的编码5、Hibernate配置文件中，不包含下面的【 A 】A.“对象-关系映射”信息B.连接数目C.show_sql等参数的配置D.数据库连接信息6、在使用了Hibernate的系统中，要想在删除某个客户数据的同时删除该客户对应的所有订单数据，下面方法可行的是。

【 B 】A.配置客户和订单关联的cascade属性为save-updateB.配置客户和订单关联的cascade属性为allC.设置多对一关联的inverse属性为trueD.设置多对一关联的inverse属性为false7、执行下面的hql查询，关于返回值的说法，正确的是。

【 B 】select ername,erid from er u where u is not nullA.语法错误，不能执行B.返回一个类型为List的实例C.返回一个数组D.当返回结果只有一条时，返回一个数组8、下面关于“依赖注入”的说法，错误的是【 D 】A.将组件间的依赖关系采取配置文件的方式管理，而不是硬编码在代码中B.降低了组件间的耦合，使程序更容易维护和升级C.促进了“面向接口”编程，使构建大规模程序更轻松D.需要定义大量接口，增加了编码复杂度9、关于Spring的说法错误的是【 C 】A.packB.packetC.packageD.packege10、关于Spring AOP，下面说法错误的是【 C 】A.支持前置通知、后置通知、环绕通知B.采用代理的方式实现C.在Spring2.0以前的版本中通过<aop:config>、<aop:pointcut>和<aop:advisor>配置D.与“依赖注入”实现紧密结合fr.close();fw.close();三、多选题(20分,每小题4分)1、下面关于Spring的说话正确的是【B C 】A.Spring是一个重量级的框架B.Spring是一个轻量级的框架C.Spring是一个IOC和AOP容器D.Spring是一个入侵式的框架2、下面关于IOC的理解，正确的是【 A B 】A.控制反转B.对象被动的接受依赖类C.对象主动的去找依赖类D.一定要用接口3、下面关于AOP的理解，正确的是【B C 】A.面向纵向的开发B.面向横向的开发C.AOP关注是面D.AOP关注的是点4、Spring的组成一共有多少块组成。

hql to_char语法

hql to_char语法在HQL (Hibernate Query Language) 中，没有类似于 SQL 中的TO_CHAR 函数。

HQL 是面向对象的查询语言，主要用于处理持久化对象。

但是，你可以通过使用一些 HQL 的表达式和函数来实现类似于 TO_CHAR 的功能。

下面是一些常用的 HQL 表达式和函数，可以用于处理日期、数字和字符串的格式转换：1. 格式化日期：```javaSELECT CONCAT(YEAR(dateColumn), '-',MONTH(dateColumn), '-', DAY(dateColumn))FROM EntityName```2. 格式化数字：```javaSELECT CONCAT('Number: ', CAST(numberColumn AS string)) FROM EntityName```3. 格式化字符串：```javaSELECT CONCAT('Prefix: ', stringColumn, ', Suffix: ', otherStringColumn)FROM EntityName```请注意，以上示例中的 "EntityName" 是你要查询的实体类的名称，"dateColumn"、"numberColumn"、"stringColumn" 和"otherStringColumn" 是实体类中的属性名称。

除了上述示例中的表达式和函数外，你还可以使用其他 HQL 表达式和函数来进一步自定义格式转换。

你可以根据实际情况选择最适合的表达式和函数。

希望以上信息对你有所帮助！如果你有任何其他的问题，请随时提问。

用HQL进行实体查询

⽤HQL进⾏实体查询实体查询例⼦1：Hql代码1. String hql=”from User user ”; 2. List list=session.CreateQuery(hql).list();因为HQL语句与标准SQL语句相似，所以我们也可以在HQL语句中使⽤where字句，并且可以在where字句中使⽤各种表达式，⽐较操作符以及使⽤“and”,”or”连接不同的查询条件的组合。

看下⾯的⼀些简单的例⼦：Hql代码1. from User user where user.age=20;例⼦2（返回⼀个属性）：Hql代码1. String hql= "select c.customerNamefrom Customer c“;2. Query query= session.createQuery(hql);3. Iteratorit = query.list().iterator();4. System.out.println(query.list().size());5. while(it.hasNext()) {6. String c = (String)it.next();7. System.out.println(c);8. }例⼦3（返回多个属性）：如果返回多个属性，那么它们将被装⼊数组或者集合中Hql代码1. String hql= "select c.customerId, c.customerName“+2. “from Customer c“;3. Query query= session.createQuery(hql);4. Iteratorit = query.list().iterator();5. while(it.hasNext()) {6. Object[] obj= (Object[])it.next(); // List list= (List)it.next();7. Long id = (Long)obj[0]; //Long id = (Long)list.get(0);8. String name = (String)obj[1]; //String name = (String)list.get(1);9. System.out.println(id.longValue() + " " + name);10. }。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Spring中常用的hql查询方法(getHibernateTemplate())－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－一、find(String queryString);示例：this.getHibernateTemplate().find("from er");返回所有User对象二、find(String queryString , Object value);示例：this.getHibernateTemplate().find("from er u where=?", "test");或模糊查询：this.getHibernateTemplate().find("from er u where like ?", "%test%");返回name属性值为test的对象（模糊查询，返回name属性值包含test的对象）三、find(String queryString, Object[] values);示例：String hql= "from er u where =? and u.password=?"this.getHibernateTemplate().find(hql, new String[]{"test", "123"});返回用户名为test并且密码为123的所有User对象－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－四、findByExample(Object exampleEntity)示例：User u=new User();u.setPassword("123");//必须符合的条件但是这两个条件时并列的（象当于sql中的and）u.setName("bb");list=this.getHibernateTemplate().findByExample(u,start,max);返回：用户名为bb密码为123的对象五、findByExample(Object exampleEntity, int firstResult, int maxResults)示例：User u=new User();u.setPassword("123");//必须符合的条件但是这两个条件时并列的（象当于sql中的and）u.setName("bb");list=this.getHibernateTemplate().findByExample(u,start,max);返回：满足用户名为bb密码为123，自start起共max个User对象。

（对象从0开始计数）---------------------------------------------------六、findByNamedParam(String queryString , String paramName , Object value)使用以下语句查询：String queryString = "select count(*) from er u where=:myName";String paramName= "myName";String value= "xiyue";this.getHibernateTemplate().findByNamedParam(queryString, paramName, value);System.out.println(list.get(0));返回name为xiyue的User对象的条数七、findByNamedParam(String queryString , String[] paramName , Object[] value)示例：String queryString = "select count(*) from er u where=:myName and u.password=:myPassword";String[] paramName= new String[]{"myName", "myPassword"};String[] value= new String[]{"xiyue", "123"};this.getHibernateTemplate().findByNamedParam(queryString, paramName, value);返回用户名为xiyue密码为123的User对象八、findByNamedQuery(String queryName)示例：1、首先需要在User.hbm.xml中定义命名查询<hibernate-mapping><class>......</class><query name="queryAllUser"><![CDATA[from er]]></query></hibernate-mapping>2、如下使用查询：this.getHibernateTemplate().findByNamedQuery("queryAllUser");九、findByNamedQuery(String queryName, Object value)示例：1、首先需要在User.hbm.xml中定义命名查询<hibernate-mapping><class>......</class><query name="queryByName"><![CDATA[from er u where = ?]]></query></hibernate-mapping>2、如下使用查询：this.getHibernateTemplate().findByNamedQuery("queryByName", "test");十、findByNamedQuery(String queryName, Object[] value)示例：1、首先需要在User.hbm.xml中定义命名查询<hibernate-mapping><class>......</class><query name="queryByNameAndPassword"><![CDATA[from er u where =? and u.password =?]]></query></hibernate-mapping>2、如下使用查询：String[] values= new String[]{"test", "123"};this.getHibernateTemplate().findByNamedQuery("queryByNameAndP assword" , values);十一、findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)示例：1、首先需要在User.hbm.xml中定义命名查询<hibernate-mapping><class>......</class><query name="queryByName"><![CDATA[from er u where =:myName]]></query></hibernate-mapping>2、如下使用查询：this.getHibernateTemplate().findByNamedQuery("queryByName" , "myName", "test");十二、findByNamedQueryAndNamedParam(String queryName, String[] paramName, Object[] value)示例：1、首先需要在User.hbm.xml中定义命名查询<hibernate-mapping><class>......</class><query name="queryByNameAndPassword"><![CDATA[from er u where =:myName andu.password=:myPassword]]></query></hibernate-mapping>2、如下使用查询：String[] names= new String[]{"myName", "myPassword"};String[] values= new String[]{"test", "123"};this.getHibernateTemplate().findByNamedQuery("queryByNameAndP assword" , names, values);十三、findByValueBean(String queryString , Object value);示例：1、定义一个ValueBean，属性名必须和HSQL语句中的：后面的变量名同名，此处必须至少有两个属性，分别为myName和myPassword，使用setter 方法设置属性值后ValueBean valueBean= new ValueBean();valueBean.setMyName("test");valueBean.setMyPasswrod("123");2、String queryString= "from er u where =:myName and u.password=:myPassword";this.getHibernateTemplate().findByValueBean(queryString , valueBean);十四、findByNamedQueryAndValueBean(String queryName , Object value);示例：1、首先需要在User.hbm.xml中定义命名查询<hibernate-mapping><class>......</class><query name="queryByNameAndPassword"><![CDATA[from er u where =:myName andu.password=:myPassword]]></query></hibernate-mapping>2、定义一个ValueBean，属性名必须和User.hbm.xml命名查询语句中的：后面的变量名同名，此处必须至少有两个属性，分别为myName和myPassword，使用setter方法设置属性值后ValueBean valueBean= new ValueBean();valueBean.setMyName("test");valueBean.setMyPasswrod("123");3、String queryString= "from er u where =:myName and u.password=:myPassword";this.getHibernateTemplate().findByNamedQueryAndValueBean("query ByNameAndPassword", valueBean);。