由hibernate换成dbutils卡极了
总么回事 一样的版面 一样的数据量，由于
hibernateJAR包太多了，臃肿，现由hibernate换成dbutils，可卡极了，
hibernate原来是经过优化的，dbutils没做优化，区别真那么大吗？也不太知道dbutils怎么对数据库操作方面的优化。
坐等红薯解答
SQL 语句贴出来，只让别人给优化，谁知道你的语句是怎么写的，工具是怎么用的
那只能是SQL本身就有问题。
SQL的问题，跟dbutils 无关，可以查看你的sql
导航 超级混乱您的访问出错了(404错误)
很抱歉，您要访问的页面不存在。
1、请检查您输入的地址是否正确。
进行查找。
3、感谢您使用本站，1秒后自动跳转dbutils通用类,dbutils分页查询 - 不念书的小子 - ITeye博客
博客分类：
dbutils通用类,dbutils分页查询,第一部分是公共类,封装好了操作数据库的方法。第二部分是分页的bean。
第一部分：
public class DBUtilsTemplate {
private DataSource dataS
private QueryRunner queryR
private static final Log LOG = LogFactory.getLog(DBUtilsTemplate.class);
public DBUtilsTemplate(DataSource dataSources) {
public DBUtilsTemplate() {
dataSource = MyDataSource.getdataSource();
* @param sql
插入sql语句
* @param params
* @return 返回影响行数
public int insert(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
int affectedRows = 0;
if (params == null) {
affectedRows = queryRunner.update(sql);
affectedRows = queryRunner.update(sql, params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("insert.插入记录错误：" + sql, e);
return affectedR
* 插入数据库，返回自动增长的主键
* @param sql -
执行的sql语句
* @return 主键 注意；此方法没关闭资源
public int insertForKeys(String sql, Object[] params) {
int key = 0;
Connection conn =
PreparedStatement stmt =
ResultSet rs =
conn = dataSource.getConnection();
stmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
ParameterMetaData pmd = stmt.getParameterMetaData();
if (params.length & pmd.getParameterCount()) {
throw new SQLException("参数错误:" + pmd.getParameterCount());
for (int i = 0; i & params. i++) {
stmt.setObject(i + 1, params[i]);
stmt.executeUpdate();
rs = stmt.getGeneratedKeys();
if (rs.next()) {
key = rs.getInt(1);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("insertForKey.插入返回主键错误：" + sql, e);
} finally {
if (rs != null) { // 关闭记录集
rs.close();
} catch (SQLException e) {
e.printStackTrace();
if (stmt != null) { // 关闭声明
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
if (conn != null) { // 关闭连接对象
conn.close();
} catch (SQLException e) {
e.printStackTrace();
private ScalarHandler scalarHandler = new ScalarHandler() {
public Object handle(ResultSet rs) throws SQLException {
Object obj = super.handle(rs);
if (obj instanceof BigInteger)
return ((BigInteger) obj).longValue();
public long count(String sql, Object... params) {
Number num = 0;
queryRunner = new QueryRunner(dataSource);
if (params == null) {
num = (Number) queryRunner.query(sql, scalarHandler);
num = (Number) queryRunner.query(sql, scalarHandler, params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("count.统计数量错误" + sql, e);
return (num != null) ? num.longValue() : -1;
* 执行sql语句
* @param sql
* @return 受影响的行数
public int update(String sql) {
return update(sql, null);
* 单条修改记录
* @param sql
* @param param
* @return 受影响的行数
public int update(String sql, Object param) {
return update(sql, new Object[] { param });
* 单条修改记录
* @param sql
* @param params
* @return 受影响的行数
public int update(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
int affectedRows = 0;
if (params == null) {
affectedRows = queryRunner.update(sql);
affectedRows = queryRunner.update(sql, params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("update.单条修改记录错误：" + sql, e);
return affectedR
* 批量修改记录
* @param sql
* @param params
二维参数数组
* @return 受影响的行数的数组
public int[] batchUpdate(String sql, Object[][] params) {
queryRunner = new QueryRunner(dataSource);
int[] affectedRows = new int[0];
affectedRows = queryRunner.batch(sql, params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("update.批量修改记录错误：" + sql, e);
return affectedR
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql
* @return 查询结果
public List&Map&String, Object&& find(String sql) {
return find(sql, null);
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql
* @param param
* @return 查询结果
public List&Map&String, Object&& find(String sql, Object param) {
return find(sql, new Object[] { param });
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql
* @param params
* @return 查询结果
@SuppressWarnings("unchecked")
public List&Map&String, Object&& findPage(String sql, int page, int count, Object... params) {
sql = sql + " LIMIT ?,?";
queryRunner = new QueryRunner(dataSource);
List&Map&String, Object&& list = new ArrayList&Map&String, Object&&();
if (params == null) {
list = (List&Map&String, Object&&) queryRunner.query(sql, new MapListHandler(), new Integer[] { page,
list = (List&Map&String, Object&&) queryRunner.query(sql, new MapListHandler(), ArrayUtils.addAll(
params, new Integer[] { page, count }));
} catch (SQLException e) {
e.printStackTrace();
LOG.error("map 数据分页查询错误", e);
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql
* @param params
* @return 查询结果
@SuppressWarnings("unchecked")
public List&Map&String, Object&& find(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
List&Map&String, Object&& list = new ArrayList&Map&String, Object&&();
if (params == null) {
list = (List&Map&String, Object&&) queryRunner.query(sql, new MapListHandler());
list = (List&Map&String, Object&&) queryRunner.query(sql, new MapListHandler(), params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("map 数据查询错误", e);
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass
* @param sql
* @return 查询结果
public &T& List&T& find(Class&T& entityClass, String sql) {
return find(entityClass, sql, null);
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass
* @param sql
* @param param
* @return 查询结果
public &T& List&T& find(Class&T& entityClass, String sql, Object param) {
return find(entityClass, sql, new Object[] { param });
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass
* @param sql
* @param params
* @return 查询结果
@SuppressWarnings("unchecked")
public &T& List&T& find(Class&T& entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
List&T& list = new ArrayList&T&();
if (params == null) {
list = (List&T&) queryRunner.query(sql, new BeanListHandler(entityClass));
list = (List&T&) queryRunner.query(sql, new BeanListHandler(entityClass), params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("Error occured while attempting to query data", e);
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass
* @param sql
* @return 对象
public &T& T findFirst(Class&T& entityClass, String sql) {
return findFirst(entityClass, sql, null);
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass
* @param sql
* @param param
* @return 对象
public &T& T findFirst(Class&T& entityClass, String sql, Object param) {
return findFirst(entityClass, sql, new Object[] { param });
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass
* @param sql
* @param params
* @return 对象
@SuppressWarnings("unchecked")
public &T& T findFirst(Class&T& entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object =
if (params == null) {
object = queryRunner.query(sql, new BeanHandler(entityClass));
object = queryRunner.query(sql, new BeanHandler(entityClass), params);
} catch (SQLException e) {
LOG.error("返回一条记录错误：findFirst" + e.getMessage());
e.printStackTrace();
return (T)
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql
* @return 封装为Map的对象
public Map&String, Object& findFirst(String sql) {
return findFirst(sql, null);
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql
* @param param
* @return 封装为Map的对象
public Map&String, Object& findFirst(String sql, Object param) {
return findFirst(sql, new Object[] { param });
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql
* @param params
* @return 封装为Map的对象
@SuppressWarnings("unchecked")
public Map&String, Object& findFirst(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Map&String, Object& map =
if (params == null) {
map = (Map&String, Object&) queryRunner.query(sql, new MapHandler());
map = (Map&String, Object&) queryRunner.query(sql, new MapHandler(), params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("findFirst.查询一条记录错误" + sql, e);
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql
* @param columnName
* @return 结果对象
public Object findBy(String sql, String params) {
return findBy(sql, params, null);
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql
* @param columnName
* @param param
* @return 结果对象
public Object findBy(String sql, String columnName, Object param) {
return findBy(sql, columnName, new Object[] { param });
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql
* @param columnName
* @param params
* @return 结果对象
public Object findBy(String sql, String columnName, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object =
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnName));
object = queryRunner.query(sql, new ScalarHandler(columnName), params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("findBy。错误" + sql, e);
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql
* @param columnIndex
* @return 结果对象
public Object findBy(String sql, int columnIndex) {
return findBy(sql, columnIndex, null);
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql
* @param columnIndex
* @param param
* @return 结果对象
public Object findBy(String sql, int columnIndex, Object param) {
return findBy(sql, columnIndex, new Object[] { param });
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql
* @param columnIndex
* @param params
* @return 结果对象
public Object findBy(String sql, int columnIndex, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object =
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnIndex));
object = queryRunner.query(sql, new ScalarHandler(columnIndex), params);
} catch (SQLException e) {
e.printStackTrace();
LOG.error("findBy.错误" + sql, e);
* @param &T&分页查询
* @param beanClass
* @param sql
* @param page
* @param count
* @param params
public &T& List&T& findPage(Class&T& beanClass, String sql, int page, int pageSize, Object... params) {
if (page &= 1) {
return query(beanClass, sql + " LIMIT ?,?", ArrayUtils.addAll(params, new Integer[] { page, pageSize }));
public &T& List&T& query(Class&T& beanClass, String sql, Object... params) {
queryRunner = new QueryRunner(dataSource);
return (List&T&) queryRunner.query(sql, isPrimitive(beanClass) ? columnListHandler : new BeanListHandler(
beanClass), params);
} catch (SQLException e) {
e.printStackTrace();
private List&Class&?&& PrimitiveClasses = new ArrayList&Class&?&&() {
add(Long.class);
add(Integer.class);
add(String.class);
add(java.util.Date.class);
add(java.sql.Date.class);
add(java.sql.Timestamp.class);
// 返回单一列时用到的handler
private final static ColumnListHandler columnListHandler = new ColumnListHandler() {
protected Object handleRow(ResultSet rs) throws SQLException {
Object obj = super.handleRow(rs);
if (obj instanceof BigInteger)
return ((BigInteger) obj).longValue();
// 判断是否为原始类型
private boolean isPrimitive(Class&?& cls) {
return cls.isPrimitive() || PrimitiveClasses.contains(cls);
第二部分：
public class PageHelp {
private int pageS
private int totalC
private int currentP
private int startI
private int[] indexes = new int[0];
private int nextI
private int previousI
private int pageC
private int lastI
private String currentU
public String getCurrentUrl() {
return currentU
public void setCurrentUrl(String currentUrl) {
this.currentUrl = currentU
public PageHelp(List items, int totalCount, int startIndex) {
pageSize = Constants.PAGE_SIZE;
setPageSize(pageSize);
setTotalCount(totalCount);
setItems(items);
setStartIndex(startIndex);
public void setTotalCount(int totalCount) {
if (totalCount & 0) {
this.totalCount = totalC
int count = totalCount / pageS
if (totalCount % pageSize & 0) {
indexes = new int[count];
for (int i = 0; i & i++) {
indexes[i] = pageSize *
this.totalCount = 0;
* 得到总记录数
public int getTotalCount() {
return totalC
public void setIndexes(int[] indexes) {
this.indexes =
* 得到分页索引的数组
public int[] getIndexes() {
public void setStartIndex(int startIndex) {
if (totalCount &= 0) {
this.startIndex = 0;
} else if (startIndex &= totalCount) {
this.startIndex = indexes[indexes.length - 1];
} else if (startIndex & 0) {
this.startIndex = 0;
this.startIndex = indexes[startIndex / pageSize];
public int getStartIndex() {
return startI
public void setNextIndex(int nextIndex) {
this.nextIndex = nextI
public int getNextIndex() {
int nextIndex = getStartIndex() + pageS
if (nextIndex &= totalCount) {
return getStartIndex();
return nextI
public void setPreviousIndex(int previousIndex) {
this.previousIndex = previousI
public int getPreviousIndex() {
int previousIndex = getStartIndex() - pageS
if (previousIndex & 0) {
return previousI
public void setPageCount(int pageCount) {
this.pageCount = pageC
public int getPageCount() {
int count = totalCount / pageS
if (totalCount % pageSize & 0)
public int getCurrentPage() {
return getStartIndex() / pageSize + 1;
public void setCurrentPage(int currentPage) {
this.currentPage = currentP
public void setLastIndex(int lastIndex) {
this.lastIndex = lastI
public int getLastIndex() {
if (indexes.length == 0) {
return indexes[indexes.length - 1];
public int getPageSize() {
return pageS
public void setPageSize(int pageSize) {
this.pageSize = pageS
* 得到已分页好的结果集
public List getItems() {
public void setItems(List items) {
this.items =
使用方法：
考虑到分层的话可以这样使用：
public class CommonDaoImpl extends DBUtilsTemplate implements CommonDao
还可以直接new
DBUtilsTemplate () 使用。
分页使用方法：
//(String sql, int page, int count, Object... params);
List list= ucd.findPage(sql, p, Constants.PAGE_SIZE, "y");
int totalRows=总记录数
return new PageHelp(list, totalRows, p);
在jsp中显示分页方法：
&table width="100%" border="0" align="center" cellpadding="0"
cellspacing="0"&
&tr align="center"&
&a href="${pageList.currentUrl}&page=0"&第一页&/a&&&&&
&a href="${pageList.currentUrl}&page=${pageList.previousIndex}"&上一页&/a&&&&&
&c:forEach items="${pageList.indexes}" var="itempage"
varStatus="stuts"&
&c:choose&
&c:when test="${pageList.currentPage ==stuts.index+1}"&
&a style="color: red"& ${stuts.index+1}&/a&
&c:otherwise&
&/c:otherwise&
&/c:choose&
&/c:forEach&
&a href="${pageList.currentUrl}&page=${pageList.nextIndex}"&
下一页&/a& &&&&
&a href="${pageList.currentUrl}&page=${pageList.lastIndex}"&最后页&/a&
&&&&总数： ${ pageList.totalCount}
&&&&总页数： ${ pageList.pageCount}
解释：currentUrl
是在action中 获取PageHelp 对象后，对他的属性currentUrl
重新赋值（即：当前请求url）
放上去一个效果图吧：
补充：数据源,使用的是dbcp
public class MyDataSource {
private static P
private static DataSource dataS
properties = new Properties();
properties.load(MyDataSource.class.getResourceAsStream("/dbcpconfig.properties"));
BasicDataSourceFactory b = new BasicDataSourceFactory();
dataSource = b.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
public static DataSource getdataSource() {
return dataS
数据源配置文件：
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/cc
username=root
password=cc
#初始化连接
initialSize=5
#最大连接数量
maxActive=40
#最大空闲连接
maxIdle=20
#最小空闲连接
#超时等待时间以毫秒为单位 6000毫秒/1000等于60秒
maxWait=10000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=]
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=characterEncoding=UTF-8
#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true
#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=
#是否自动回收超时连接（一般是忘了释放的）
removeAbandoned=true
# 将被遗弃的数据库连接的回收记入日志。
logAbandoned=true
# 数据库连接过多长时间不用将被视为被遗弃而收回连接池中。
removeAbandonedTimeout=30
#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
#defaultTransactionIsolation=REPEATABLE_READ
#db.pool.default.whenExhaustedAction=grow
#新增参数，用于8小时问题
testOnBorrow=true
testOnReturn=false
testWhileIdle=true
validationQuery=select 1
不念书的小子
浏览: 386421 次
来自: 北京
简单粗暴，我喜欢
zhangpeili 写道
Connection co ...
小第也要准备搞一个这样系统。有机会请前辈多指点。可以加QQ好友 ...
擦，我也遇到了，谢谢博主！Java Hibernate
Criteria 用法 -
- ITeye博客
博客分类：
15.1. 创建一个Criteria 实例org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。 Criteria crit = sess.createCriteria(Cat.class);crit.setMaxResults(50);List cats = crit.list();15.2. 限制结果集内容一个单独的查询条件是org.hibernate.criterion.Criterion 接口的一个实例。org.hibernate.criterion.Restrictions类 定义了获得某些内置Criterion类型的工厂方法。 List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.between("weight", minWeight, maxWeight) )
.list();约束可以按逻辑分组。 List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.or(
Restrictions.eq( "age", new Integer(0) ),
Restrictions.isNull("age")
.list();List cats = sess.createCriteria(Cat.class)
.add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
.add( Restrictions.disjunction()
.add( Restrictions.isNull("age") )
.add( Restrictions.eq("age", new Integer(0) ) )
.add( Restrictions.eq("age", new Integer(1) ) )
.add( Restrictions.eq("age", new Integer(2) ) )
.list();Hibernate提供了相当多的内置criterion类型(Restrictions 子类), 但是尤其有用的是可以允许你直接使用SQL。 List cats = sess.createCriteria(Cat.class)
.add( Restrictions.sqlRestriction("lower({alias}.name) like lower(?)", "Fritz%", Hibernate.STRING) )
.list();{alias}占位符应当被替换为被查询实体的列别名。 Property实例是获得一个条件的另外一种途径。你可以通过调用Property.forName() 创建一个Property。 Property age = Property.forName("age");List cats = sess.createCriteria(Cat.class)
.add( Restrictions.disjunction()
.add( age.isNull() )
.add( age.eq( new Integer(0) ) )
.add( age.eq( new Integer(1) ) )
.add( age.eq( new Integer(2) ) )
.add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )
.list();15.3. 结果集排序你可以使用org.hibernate.criterion.Order来为查询结果排序。 List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.addOrder( Order.asc("name") )
.addOrder( Order.desc("age") )
.setMaxResults(50)
.list();List cats = sess.createCriteria(Cat.class)
.add( Property.forName("name").like("F%") )
.addOrder( Property.forName("name").asc() )
.addOrder( Property.forName("age").desc() )
.setMaxResults(50)
.list();15.4. 关联你可以使用createCriteria()非常容易的在互相关联的实体间建立 约束。 List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%") )
.createCriteria("kittens")
.add( Restrictions.like("name", "F%") )
.list();注意第二个 createCriteria()返回一个新的 Criteria实例，该实例引用kittens 集合中的元素。 接下来，替换形态在某些情况下也是很有用的。 List cats = sess.createCriteria(Cat.class)
.createAlias("kittens", "kt")
.createAlias("mate", "mt")
.add( Restrictions.eqProperty("kt.name", "mt.name") )
.list();(createAlias()并不创建一个新的 Criteria实例。) Cat实例所保存的之前两次查询所返回的kittens集合是 没有被条件预过滤的。如果你希望只获得符合条件的kittens， 你必须使用ResultTransformer。 List cats = sess.createCriteria(Cat.class)
.createCriteria("kittens", "kt")
.add( Restrictions.eq("name", "F%") )
.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)
.list();Iterator iter = cats.iterator();while ( iter.hasNext() ) {
Map map = (Map) iter.next();
Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
Cat kitten = (Cat) map.get("kt");}15.5. 动态关联抓取你可以使用setFetchMode()在运行时定义动态关联抓取的语义。 List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.setFetchMode("kittens", FetchMode.EAGER)
.list();这个查询可以通过外连接抓取mate和kittens。 查看第 19.1 节 “ 抓取策略(Fetching strategies) ”可以获得更多信息。 15.6. 查询示例org.hibernate.criterion.Example类允许你通过一个给定实例 构建一个条件查询。 Cat cat = new Cat();cat.setSex('F');cat.setColor(Color.BLACK);List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();版本属性、标识符和关联被忽略。默认情况下值为null的属性将被排除。 你可以自行调整Example使之更实用。 Example example = Example.create(cat)
.excludeZeroes()
//exclude zero valued properties
.excludeProperty("color")
//exclude the property named "color"
.ignoreCase()
//perform case insensitive string comparisons
.enableLike();
//use like for string comparisonsList results = session.createCriteria(Cat.class)
.add(example)
.list();你甚至可以使用examples在关联对象上放置条件。 List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.createCriteria("mate")
.add( Example.create( cat.getMate() ) )
.list();15.7. 投影(Projections)、聚合（aggregation）和分组（grouping）org.hibernate.criterion.Projections是 Projection 的实例工厂。我们通过调用 setProjection()应用投影到一个查询。 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();List results = session.createCriteria(Domestic.class, "cat")
.createAlias("kittens", "kit")
.setProjection( Projections.projectionList()
.add( Projections.property("cat.name"), "catName" )
.add( Projections.property("kit.name"), "kitName" )
.addOrder( Order.asc("catName") )
.addOrder( Order.asc("kitName") )
.list();你也可以使用Property.forName()来表示投影： List results = session.createCriteria(Cat.class)
.setProjection( Property.forName("name") )
.add( Property.forName("color").eq(Color.BLACK) )
.list();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();15.8. 离线(detached)查询和子查询DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来执行它。 DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
.add( Property.forName("sex").eq('F') );
Session session = ....;Transaction txn = session.beginTransaction();List results = query.getExecutableCriteria(session).setMaxResults(100).list();<mit();session.close();DetachedCriteria也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者Property获得。 DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight").avg() );session.createCriteria(Cat.class)
.add( Property.forName("weight).gt(avgWeight) )
.list();DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight") );session.createCriteria(Cat.class)
.add( Subqueries.geAll("weight", weights) )
.list();甚至相互关联的子查询也是有可能的： DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
.setProjection( Property.forName("weight").avg() )
.add( Property.forName("cat2.sex").eqProperty("cat.sex") );session.createCriteria(Cat.class, "cat")
.add( Property.forName("weight).gt(avgWeightForSex) )
.list();15.9. 根据自然标识查询(Queries by natural identifier)对大多数查询，包括条件查询而言，因为查询缓存的失效(invalidation)发生得太频繁，查询缓存不是非常高效。然而，有一种特别的查询，可以通过不变的自然键优化缓存的失效算法。在某些应用中，这种类型的查询比较常见。条件查询API对这种用例提供了特别规约。 首先，你应该对你的entity使用&natural-id&来映射自然键，然后打开第二级缓存。 &class name="User"&
&cache usage="read-write"/&
&id name="id"&
&generator class="increment"/&
&natural-id&
&property name="name"/&
&property name="org"/&
&/natural-id&
&property name="password"/&&/class&注意,此功能对具有mutable自然键的entity并不适用。 然后，打开Hibernate 查询缓存。 现在，我们可以用Restrictions.naturalId()来使用更加高效的缓存算法。 session.createCriteria(User.class)
.add( Restrictions.naturalId()
.set("name", "gavin")
.set("org", "hb")
).setCacheable(true)
.uniqueResult();
jiaguwen123
浏览: 230981 次
来自: 深圳
关于这个心跳的发送和接收 晚上全是the fuccking s ...
你的想法在大的物流公司已经实现了，只不过他们使用是GPS定位
2,AuthenticationHandler类的写法
pac ...
总结的不错哟！}