BaseDao
package com.kaishengit.dao;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import javax.inject.Inject;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
@SuppressWarnings("unchecked")
public class BaseDao<T> {
@Inject
private SessionFactory sessionFactory;
private Class<?> clazz;
public BaseDao() {
ParameterizedType baseDaoType = (ParameterizedType) this.getClass().getGenericSuperclass(); //BaseDao<User>
clazz = (Class<?>) baseDaoType.getActualTypeArguments()[0];
}
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public Session getSession() {
return sessionFactory.getCurrentSession();
}
/**
* 添加或修改对象
* @param t
*/
public void save(T t) {
getSession().save(t);
}
public void update(T t) {
getSession().update(t);
}
/**
* 删除一个对象
* @param t
*/
public void delete(T t) {
getSession().delete(t);
}
/**
* 根据ID删除对象
* @param id
*/
public void delete(int id) {
getSession().delete(findById(id));
}
/**
* 根据ID查找对象
* @param id
* @return
*/
public T findById(int id) {
return (T)getSession().get(clazz, id);
}
/**
* 获取所有对象
* @return
*/
public List<T> findAll() {
return getCriteria().list();
}
/**
* 根据属性名称和值查找唯一的对象
* @param propertyName
* @param value
* @return
*/
public T findByPropertyForObject(String propertyName,Object value) {
Criteria cri = getCriteria();
cri.add(Restrictions.eq(propertyName, value));
return (T) cri.uniqueResult();
}
/**
* 根据属性名称和值查找对象
* @param propertyName
* @param value
* @return
*/
public List<T> findByPropertyForList(String propertyName,Object value) {
Criteria cri = getCriteria();
cri.add(Restrictions.eq(propertyName, value));
return cri.list();
}
/**
* 根据QueryFilter对象查找唯一对象
* @param filter
* @return
*/
public T findByPropertyForObject(QueryFilter filter) {
Criteria cri = getCriteria();
cri.add(createCriterion(filter));
return (T) cri.uniqueResult();
}
/**
* 根据QueryFilter集合(多条件)查找唯一对象
* @param filters
* @return
*/
public T findByPropertyForObject(List<QueryFilter> filters) {
Criteria cri = createCriterion(filters);
return (T) cri.uniqueResult();
}
/**
* 根据QueryFilter集合(多条件)查找对象
* @param filters
* @return
*/
public List<T> findByPropertyForList(List<QueryFilter> filters) {
Criteria cri = createCriterion(filters);
return cri.list();
}
/**
* 根据QueryFilter对象查找对象
* @param filter
* @return
*/
public List<T> findByPropertyForList(QueryFilter filter) {
Criteria cri = getCriteria();
cri.add(createCriterion(filter));
return cri.list();
}
/**
* 根据HQL查询唯一的对象
* @param hql
* @param args
* @return
*/
public T findByHqlForObject(String hql,Object...args) {
Query query = getSession().createQuery(hql);
for (int i = 0; i < args.length; i++) {
query.setParameter(i, args[i]);
}
return (T) query.uniqueResult();
}
/**
* 根据HQL查询对象
* @param hql
* @param args
* @return
*/
public List<T> findByHqlForList(String hql,Object...args) {
Query query = getSession().createQuery(hql);
for (int i = 0; i < args.length; i++) {
query.setParameter(i, args[i]);
}
return query.list();
}
public List<T> findByPage(int start,int size) {
Criteria cri = getCriteria();
cri.setFirstResult(start);
cri.setMaxResults(size);
return cri.list();
}
public List<T> findByPage(int start,int size,QueryFilter filter) {
Criteria cri = getCriteria();
cri.add(createCriterion(filter));
cri.setFirstResult(start);
cri.setMaxResults(size);
return cri.list();
}
public Page<T> findByHqlPageNumber(String hql1, int page, int rows,
Object...objects) {
Query query=getSession().createQuery(hql1);
for (int i = 0; i < objects.length; i++) {
query.setParameter(i, objects[i]);
}
int count=query.list().size();
Page<T> page1 = new Page<T>(page,count,rows);
query.setFirstResult(page1.getStartIndex());
query.setMaxResults(page1.getPageSize());
page1.setItems(query.list());
return page1;
}
public Page<T> findByHqlPageNumber(String hql,int pageNum,int pageSize) {
Query query = getSession().createQuery(hql);
int count=query.list().size();
Page<T> page = new Page<T>(pageNum,count,pageSize);
query.setFirstResult(page.getStartIndex());
query.setMaxResults(page.getPageSize());
page.setItems(query.list());
return page;
}
public Page<T> findByPageNum(int pageNum,int pageSize) {
Criteria cri = getCriteria();
@SuppressWarnings("static-access")
ResultTransformer resultTransformer = cri.ROOT_ENTITY;
cri.setProjection(Projections.rowCount());
Long count = (Long) cri.uniqueResult();
cri.setResultTransformer(resultTransformer);
cri.setProjection(null);
Page<T> page = new Page<T>(pageNum,count.intValue(),pageSize);
cri.setFirstResult(page.getStartIndex());
cri.setMaxResults(page.getPageSize());
List<T> result = cri.list();
page.setItems(result);
return page;
}
public Page<T> findByPageNum(int pageNum,int pageSize,QueryFilter filter) {
Criteria cri = getCriteria();
cri.add(createCriterion(filter));
@SuppressWarnings("static-access")
ResultTransformer resultTransformer = cri.ROOT_ENTITY;
cri.setProjection(Projections.rowCount());
Long count = (Long) cri.uniqueResult();
cri.setResultTransformer(resultTransformer);
cri.setProjection(null);
Page<T> page = new Page<T>(pageNum,count.intValue(), pageSize);
cri.setFirstResult(page.getStartIndex());
cri.setMaxResults(page.getPageSize());
List<T> result = cri.list();
page.setItems(result);
return page;
}
public Page<T> findByPageNum(int pageNum,int pageSize,List<QueryFilter> filters) {
Criteria cri = createCriterion(filters);
@SuppressWarnings("static-access")
ResultTransformer resultTransformer = cri.ROOT_ENTITY;
cri.setProjection(Projections.rowCount());
Long count = (Long) cri.uniqueResult();
cri.setResultTransformer(resultTransformer);
cri.setProjection(null);
Page<T> page = new Page<T>(pageNum,count.intValue(),pageSize);
cri.setFirstResult(page.getStartIndex());
cri.setMaxResults(page.getPageSize());
List<T> result = cri.list();
page.setItems(result);
return page;
}
/**
* @author YSC
* @param counthql
* @param hql
* @param pageNum
* @param rows
* @return
*/
public Page<T> findByHqlAndPageForList(String counthql, StringBuilder hql,
int pageNum, int rows,Object...args) {
Query countQuery = getSession().createQuery(counthql);
Query query = getSession().createQuery(hql.toString());
for (int i = 0; i < args.length; i++) {
countQuery.setParameter(i, args[i]);
query.setParameter(i, args[i]);
}
Long count = (Long) countQuery.uniqueResult();
Page<T> page = new Page<T>(pageNum,count.intValue(),rows);
query.setFirstResult(page.getStartIndex());
query.setMaxResults(page.getPageSize());
List<T> result = query.list();
page.setItems(result);
return page;
}
/**
* @author gaolin
* @param pageNum
* @param pageSize
* @param filters
* @return
*/
public Page<T> findByPageNumAndSum(int pageNum,int pageSize,List<QueryFilter> filters) {
Criteria cri = createCriterion(filters);
@SuppressWarnings("static-access")
ResultTransformer resultTransformer = cri.ROOT_ENTITY;
cri.setProjection(Projections.rowCount());
Long count = (Long) cri.uniqueResult();
cri.setResultTransformer(resultTransformer);
cri.setProjection(null);
Page<T> page = new Page<T>(pageNum,count.intValue(),pageSize);
cri.setFirstResult(page.getStartIndex());
cri.setMaxResults(page.getPageSize());
List<T> result = cri.list();
page.setItems(result);
return page;
}
//help method
private Criteria getCriteria() {
return getSession().createCriteria(clazz);
}
public Criteria createCriterion(List<QueryFilter> filters) {
Criteria cri = getCriteria();
if(filters != null && !filters.isEmpty()) {
for(QueryFilter filter : filters) {
cri.add(createCriterion(filter));
}
}
return cri;
}
private Criterion createCriterion(QueryFilter filter) {
String propertyName = filter.getPropertyName();
Object value = filter.getValue();
String re = filter.getRe();
if(QueryFilter.EQ.equalsIgnoreCase(re)) {
return Restrictions.eq(propertyName, value);
} else if(QueryFilter.GE.equalsIgnoreCase(re)) {
return Restrictions.ge(propertyName, value);
} else if(QueryFilter.GT.equalsIgnoreCase(re)) {
return Restrictions.gt(propertyName, value);
} else if(QueryFilter.LE.equalsIgnoreCase(re)) {
return Restrictions.le(propertyName, value);
} else if(QueryFilter.LT.equalsIgnoreCase(re)) {
return Restrictions.lt(propertyName, value);
} else if(QueryFilter.LIKE.equalsIgnoreCase(re)) {
return Restrictions.like(propertyName, value.toString(), MatchMode.ANYWHERE);
}
return null;
}
}
QueryFilter
package com.kaishengit.dao;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.StringUtils;
public class QueryFilter {
public static final String EQ = "eq"; //=
public static final String GE = "ge"; //>=
public static final String LE = "le"; //<=
public static final String LT = "lt"; //<
public static final String GT = "gt"; //>
public static final String LIKE = "like"; // like
private String propertyName;
private Object value;
private String re;
public QueryFilter(String propertyName,String re,Object value) {
this.propertyName = propertyName;
this.value = value;
this.re = re;
}
public QueryFilter() {}
public QueryFilter(String propertyName,Object value) {
this(propertyName,EQ,value);
}
public String getPropertyName() {
return propertyName;
}
public void setPropertyName(String propertyName) {
this.propertyName = propertyName;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
public String getRe() {
return re;
}
public void setRe(String re) {
this.re = re;
}
public static List<QueryFilter> builderQueryFilterByRequest(
HttpServletRequest request) {
List<QueryFilter> filters = new ArrayList<QueryFilter>();
Enumeration<String> e = request.getParameterNames();
while(e.hasMoreElements()) {
String parmName = e.nextElement();
if(parmName.startsWith("Q_")) {
if(parmName.indexOf("_") == parmName.lastIndexOf("_")) {
throw new IllegalArgumentException("比较规则错误");
} else {
String type = parmName.substring(parmName.indexOf("_")+1, parmName.lastIndexOf("_"));
String propertyName = parmName.substring(parmName.lastIndexOf("_")+1);
String value = request.getParameter(parmName);
if(StringUtils.isNotEmpty(value)) {
if(propertyName.contains("-")) {
String propertyType = propertyName.substring(propertyName.indexOf("-")+1);
propertyName = propertyName.substring(0,propertyName.indexOf("-"));
Object v = value;
if(propertyType.equalsIgnoreCase("i")) {
v = Integer.parseInt(value);
} else if(propertyType.equalsIgnoreCase("l")) {
v = Long.parseLong(value);
} else if(propertyType.equalsIgnoreCase("f")) {
v = Float.parseFloat(value);
} else if(propertyType.equalsIgnoreCase("d")) {
v = Double.parseDouble(value);
} else if(propertyType.equalsIgnoreCase("b")) {
v = Boolean.parseBoolean(value);
}
QueryFilter filter = new QueryFilter(propertyName, type, v);
filters.add(filter);
} else {
QueryFilter filter = new QueryFilter(propertyName, type, value);
filters.add(filter);
}
}
}
}
}
return filters;
}
/**
* @author YSC
* @param request
* @return
*/
@SuppressWarnings("unchecked")
public static List<QueryFilter> builderQueryFilterByParams(
HttpServletRequest request) {
List<QueryFilter> filters = new ArrayList<QueryFilter>();
Enumeration<String> e = request.getParameterNames();
while(e.hasMoreElements()) {
String parmName = e.nextElement();
if(parmName.startsWith("Q_")) {
if(parmName.indexOf("_") == parmName.lastIndexOf("_")) {
throw new IllegalArgumentException("比较规则错误");
} else {
String type = parmName.substring(parmName.indexOf("_")+1, parmName.lastIndexOf("_"));
String propertyName = parmName.substring(parmName.lastIndexOf("_")+1);
String value = request.getParameter(parmName);
if(StringUtils.isNotEmpty(value)) {
if(propertyName.contains("$")) {
String propertyType = propertyName.substring(propertyName.indexOf("$")+1);
propertyName = propertyName.substring(0,propertyName.indexOf("$"));
Object v = value;
if(propertyType.equalsIgnoreCase("i")) {
v = Integer.parseInt(value);
} else if(propertyType.equalsIgnoreCase("l")) {
v = Long.parseLong(value);
} else if(propertyType.equalsIgnoreCase("f")) {
v = Float.parseFloat(value);
} else if(propertyType.equalsIgnoreCase("d")) {
v = Double.parseDouble(value);
} else if(propertyType.equalsIgnoreCase("b")) {
v = Boolean.parseBoolean(value);
}
QueryFilter filter = new QueryFilter(propertyName, type, v);
filters.add(filter);
} else {
QueryFilter filter = new QueryFilter(propertyName, type, value);
filters.add(filter);
}
}
}
}
}
return filters;
}
public static List<QueryFilter> builderQueryFilterByRequestWithout(
HttpServletRequest request) {
List<QueryFilter> filters = new ArrayList<QueryFilter>();
Enumeration<String> e = request.getParameterNames();
while(e.hasMoreElements()) {
String parmName = e.nextElement();
if(parmName.startsWith("Q_")) {
if(parmName.indexOf("_") == parmName.lastIndexOf("_")) {
throw new IllegalArgumentException("比较规则错误");
} else {
String type = parmName.substring(parmName.indexOf("_")+1, parmName.lastIndexOf("_"));
String propertyName = parmName.substring(parmName.lastIndexOf("_")+1);
String value = request.getParameter(parmName);
if(!("staffname".equals(propertyName)||"companyname".equals(propertyName))){
if(StringUtils.isNotEmpty(value)) {
if(propertyName.contains("-")) {
String propertyType = propertyName.substring(propertyName.indexOf("-")+1);
propertyName = propertyName.substring(0,propertyName.indexOf("-"));
Object v = value;
if(propertyType.equalsIgnoreCase("i")) {
v = Integer.parseInt(value);
} else if(propertyType.equalsIgnoreCase("l")) {
v = Long.parseLong(value);
} else if(propertyType.equalsIgnoreCase("f")) {
v = Float.parseFloat(value);
} else if(propertyType.equalsIgnoreCase("d")) {
v = Double.parseDouble(value);
} else if(propertyType.equalsIgnoreCase("b")) {
v = Boolean.parseBoolean(value);
}
QueryFilter filter = new QueryFilter(propertyName, type, v);
filters.add(filter);
} else {
QueryFilter filter = new QueryFilter(propertyName, type, value);
filters.add(filter);
}
}
}
}
}
}
return filters;
}
/**
* @author YSC
* @param request
* @return
*/
public static List<String> createHqlFromRequest(HttpServletRequest request) {
@SuppressWarnings("unchecked")
Enumeration<String> e = request.getParameterNames();
List<String> slist = new ArrayList<String>();
while(e.hasMoreElements()) {
String parmName = e.nextElement();
if(parmName.startsWith("Q_")) {
if(parmName.indexOf("_") == parmName.lastIndexOf("_")) {
throw new IllegalArgumentException("比较规则错误");
} else {
String type = parmName.substring(parmName.indexOf("_")+1, parmName.lastIndexOf("_"));
String propertyName = parmName.substring(parmName.lastIndexOf("_")+1);
String value = request.getParameter(parmName);
if(StringUtils.isNotEmpty(value)) {
Object v = value;
if("EQ".equals(type)){
type = "=";
}else if("LT".equals(type)){
type = "<";
}else if("LE".equals(type)){
type = "<=";
}else if("GT".equals(type)){
type = ">";
}else if("GE".equals(type)){
type = ">=";
}else if("LIKE".equals(type)){
type = "like";
}
StringBuilder sb = new StringBuilder();
if(propertyName.contains("$")) {
String propertyType = propertyName.substring(propertyName.indexOf("$")+1);
propertyName = propertyName.substring(0,propertyName.indexOf("$"));
sb.append(propertyName).append(" ").append(type);
if(propertyType.equalsIgnoreCase("i")) {
v = Integer.parseInt(value);
sb.append(" "+v+" ");
} else if(propertyType.equalsIgnoreCase("l")) {
v = Long.parseLong(value);
sb.append(" "+v+" ");
} else if(propertyType.equalsIgnoreCase("f")) {
v = Float.parseFloat(value);
sb.append(" "+v+" ");
} else if(propertyType.equalsIgnoreCase("d")) {
v = Double.parseDouble(value);
sb.append(" "+v+" ");
} else if(propertyType.equalsIgnoreCase("b")) {
v = Boolean.parseBoolean(value);
sb.append(" "+v+" ");
}
}else{
sb.append(propertyName).append(" ").append(type);
sb.append(" '"+v+"'");
}
slist.add(sb.toString());
}
}
}
}
return slist;
}
}
相关推荐
1. **基本查询**：提供一个通用的方法，用于根据ID获取对象，例如`public T findById(Class<T> entityClass, Serializable id)`。这个方法会使用Hibernate的`Session`对象的`get`方法来执行查询。 2. **条件查询**...
标题"Spring+Hibernate工具类所有增删改查"暗示了这是一个集合了Spring和Hibernate框架中用于基本数据库操作的工具类库。这些工具类通常包含了一系列静态方法，用于执行常见的数据库CRUD（创建、读取、更新、删除）...
这个"hibernate5类包"包含了实现上述功能所需的全部类和库，例如`hibernate-core.jar`包含了核心ORM功能，`hibernate-entitymanager.jar`提供了JPA支持，`hibernate-infinispan.jar`则包含Infinispan缓存相关的组件...
在提供的压缩包中，`Hibernate增删改查的工具类`实现了这些基本功能，使得在项目中调用这些方法即可完成数据库操作。工具类通常包含静态方法，以便在不创建实例的情况下直接调用，减少了内存消耗。这些方法可能包括...
本篇将深入探讨Hibernate方法的实现，包括其基本概念、配置、实体类、会话工厂以及各种操作数据库的方法。 1. **Hibernate基础** Hibernate是基于Java的持久层框架，通过XML配置文件或注解来定义对象与数据库表...
`KindEntityDaoHibernate`类实现了`KindEntityDao`接口，并使用Hibernate作为底层的数据访问工具。在这个类中，我们可以通过编写Hibernate HQL或SQL查询语句来实现分页查询。 4. **Struts2 Action** 在Action类中...
4. **javassist.jar**：Hibernate使用javassist库来动态地生成字节码，以实现运行时的类增强，例如为实体类添加代理方法。 5. **jta.jar**或**jboss-transaction-api_1.2_spec.jar**：提供Java Transaction API，...
这个项目对于初学者来说，可以帮助他们理解Web应用开发的基本流程，了解Struts和Hibernate如何协同工作，以及MyEclipse如何辅助开发。同时，实践中遇到的问题和解决方法也是提升技能的重要途径。通过这个简单的登录...
使用Hibernate DAO生成工具，开发者可以自动生成与数据库表对应的DAO接口和实现类，这些类通常包含增删查改的基本方法。例如，对于一个名为`User`的表，工具会生成`UserDAO`接口和`UserDAOImpl`实现类，其中包含`...
【hibernate动态分表】是一种数据库设计策略，主要用于处理大数据量的问题，通过将数据分散到多个物理表中，以实现水平扩展，提高查询效率，减轻单表的压力。在Java Web开发中，Hibernate作为一款流行的ORM（对象...
使用`hibernate代码生成工具`，开发者可以节省大量时间，更专注于业务逻辑的实现，而不是重复的底层代码编写。此外，工具往往还支持定制化，允许用户根据项目需求调整生成的代码模板，如添加自定义注解、指定序列化...
4. **编写业务逻辑类**：实现具体的业务逻辑，并封装对Hibernate的访问操作。 #### 示例分析 以学生信息管理模块为例，该模块可能涉及的主要表有 `Student`、`Class`、`Course`、`Address` 以及 `Student_Course` ...
Hibernate 是一个对象关系映射（ORM）工具，它允许开发人员用面向对象的方式处理数据，将Java类与数据库表进行映射，从而避免了SQL语句的直接编写。通过Hibernate，我们可以方便地完成对数据库的CRUD操作，并且支持...
5. **DAO层设计**：创建Hibernate的Data Access Object（DAO）接口和实现类，这里包含对数据库的CRUD操作方法，比如使用Session对象执行SQL语句。 6. **Service层设计**：创建Service接口和实现类，将业务逻辑封装...
- **对象关系映射（ORM）**: Hibernate是ORM工具的代表，它将数据库表映射为Java类，表中的行映射为类的对象，列映射为对象的属性，实现了Java对象与数据库之间的透明交互。 - **SessionFactory和Session**: ...
首先，`HibernateUtil` 类是 Hibernate 教程中常见的一种工具类，它的主要作用是提供对 Hibernate 框架的简单封装，以方便进行数据库操作。在实际开发中，我们通常会创建一个静态方法来初始化 SessionFactory，这样...
8. **EasyDB**: 这可能是项目中的一个模块或工具，可能是一个简化版的数据库操作库，提供了基本的数据库连接、查询等功能，作为模拟Hibernate的基础。 通过这个项目，你可以深入理解ORM的工作机制，掌握Java反射和...
总之，这个压缩包提供了进行Hibernate开发的基本环境，包括了核心库、ORM支持和测试工具，开发者可以基于这些资源快速搭建并测试一个Hibernate项目。在实际开发中，还需要了解和掌握更多关于Hibernate的高级特性和...
通过这个项目，开发者不仅可以学习到J2EE、MySQL、Hibernate和Servlet的基本使用，还能理解如何在实际项目中整合这些技术，以实现高效的数据查询功能。对于初学者来说，这是一个很好的实践平台，对于有经验的开发者...
在这一版本中，对属性配置的关注尤为突出，这意味着开发者可以通过更灵活的方式定义和管理实体类中的属性，从而实现更为复杂的数据映射需求。 ### 属性配置详解 在Hibernate中，属性配置是核心组件之一，它定义了...