- 浏览: 48446 次
- 性别:
- 来自: 北京
最新评论
-
wused:
请问一下要在哪里捕捉异常,捕捉什么异常?
spring+quartz定时器突然停止 -
shaotine_wu:
您好,您这里只是用proguard.jar扰码了APK中引用的 ...
android proguard -
saintlu:
同样的问题,如何解决啊?
commons.net.FTPClient在linux不可下载 -
nolongerc:
在linux时文件的路径发生改变。
commons.net.FTPClient在linux不可下载
@SuppressWarnings("unchecked")
public class SimpleHibernateDao<T, PK extends Serializable> {
protected Logger logger = LoggerFactory.getLogger(getClass());
protected SessionFactory sessionFactory;
protected Class<T> entityClass;
/**
* 用于Dao层子类使用的构造函数.
* 通过子类的泛型定义取得对象类型Class.
* eg.
* public class UserDao extends SimpleHibernateDao<User, Long>
*/
public SimpleHibernateDao() {
this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
}
/**
* 用于用于省略Dao层, 在Service层直接使用通用SimpleHibernateDao的构造函数.
* 在构造函数中定义对象类型Class.
* eg.
* SimpleHibernateDao<User, Long> userDao = new SimpleHibernateDao<User, Long>(sessionFactory, User.class);
*/
public SimpleHibernateDao(final SessionFactory sessionFactory, final Class<T> entityClass) {
this.sessionFactory = sessionFactory;
this.entityClass = entityClass;
}
public SessionFactory getSessionFactory() {
return sessionFactory;
}
@Resource(name="sessionFactory")
public void setSessionFactory(final SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
/**
* 取得当前Session.
*/
public Session getSession() {
return sessionFactory.getCurrentSession();
}
/**
* 保存新增或修改的对象.
*/
public void save(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().save(entity);
logger.debug("save entity: {}", entity);
}
public void update(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().update(entity);
logger.debug("update entity: {}", entity);
}
/**
* 删除对象.
*
* @param entity 对象必须是session中的对象或含id属性的transient对象.
*/
public void delete(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().delete(entity);
logger.debug("delete entity: {}", entity);
}
/**
* 按id删除对象.
*/
public void delete(final PK id) {
Assert.notNull(id, "id不能为空");
delete(get(id));
logger.debug("delete entity {},id is {}", entityClass.getSimpleName(), id);
}
/**
* 按id获取对象.
*/
public T get(final PK id) {
Assert.notNull(id, "id不能为空");
return (T) getSession().get(entityClass, id);
}
public void evict(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().evict(entity);
logger.debug("evict entity: {}", entity);
}
/**
* 获取全部对象.
*/
public List<T> getAll() {
return find();
}
/**
* 按属性查找对象列表,匹配方式为相等.
*/
public List<T> findBy(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return find(criterion);
}
/**
* 按属性查找唯一对象,匹配方式为相等.
*/
public T findUniqueBy(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T) createCriteria(criterion).uniqueResult();
}
/**
* 按id列表获取对象.
*/
public List<T> findByIds(List<PK> ids) {
return find(Restrictions.in(getIdName(), ids));
}
/**
* 按HQL查询对象列表.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public <X> List<X> find(final String hql, final Object... values) {
return createQuery(hql, values).list();
}
/**
* 按HQL查询对象列表.
*
* @param values 命名参数,按名称绑定.
*/
public <X> List<X> find(final String hql, final Map<String, Object> values) {
return createQuery(hql, values).list();
}
/**
* 按HQL查询唯一对象.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public <X> X findUnique(final String hql, final Object... values) {
return (X) createQuery(hql, values).uniqueResult();
}
/**
* 按HQL查询唯一对象.
*
* @param values 命名参数,按名称绑定.
*/
public <X> X findUnique(final String hql, final Map<String, Object> values) {
return (X) createQuery(hql, values).uniqueResult();
}
/**
* 执行HQL进行批量修改/删除操作.
*/
public int batchExecute(final String hql, final Object... values) {
return createQuery(hql, values).executeUpdate();
}
/**
* 执行HQL进行批量修改/删除操作.
* @return 更新记录数.
*/
public int batchExecute(final String hql, final Map<String, Object> values) {
return createQuery(hql, values).executeUpdate();
}
/**
* 根据查询HQL与参数列表创建Query对象.
*
* 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public Query createQuery(final String queryString, final Object... values) {
Assert.hasText(queryString, "queryString不能为空");
Query query = getSession().createQuery(queryString);
if (values != null) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
}
return query;
}
/**
* 根据查询HQL与参数列表创建Query对象.
*
* @param values 命名参数,按名称绑定.
*/
public Query createQuery(final String queryString, final Map<String, Object> values) {
Assert.hasText(queryString, "queryString不能为空");
Query query = getSession().createQuery(queryString);
if (values != null) {
query.setProperties(values);
}
return query;
}
/**
* 按Criteria查询对象列表.
*
* @param criterions 数量可变的Criterion.
*/
public List<T> find(final Criterion... criterions) {
return createCriteria(criterions).list();
}
/**
* 按Criteria查询唯一对象.
*
* @param criterions 数量可变的Criterion.
*/
public T findUnique(final Criterion... criterions) {
return (T) createCriteria(criterions).uniqueResult();
}
/**
* 根据Criterion条件创建Criteria.
*
* 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数.
*
* @param criterions 数量可变的Criterion.
*/
public Criteria createCriteria(final Criterion... criterions) {
Criteria criteria = getSession().createCriteria(entityClass);
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
/**
* 初始化对象.
* 使用load()方法得到的仅是对象Proxy, 在传到View层前需要进行初始化.
* 只初始化entity的直接属性,但不会初始化延迟加载的关联集合和属性.
* 如需初始化关联属性,可实现新的函数,执行:
* Hibernate.initialize(user.getRoles()),初始化User的直接属性和关联集合.
* Hibernate.initialize(user.getDescription()),初始化User的直接属性和延迟加载的Description属性.
*/
public void initEntity(T entity) {
Hibernate.initialize(entity);
}
/**
* @see #initEntity(Object)
*/
public void initEntity(List<T> entityList) {
for (T entity : entityList) {
Hibernate.initialize(entity);
}
}
/**
* 为Query添加distinct transformer.
*/
public Query distinct(Query query) {
query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return query;
}
/**
* 为Criteria添加distinct transformer.
*/
public Criteria distinct(Criteria criteria) {
criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return criteria;
}
/**
* 通过Set将不唯一的对象列表唯一化.
* 主要用于HQL/Criteria预加载关联集合形成重复记录,又不方便使用distinct查询语句时.
*/
public <X> List<X> distinct(List list) {
Set<X> set = new LinkedHashSet<X>(list);
return new ArrayList<X>(set);
}
/**
* 取得对象的主键名.
*/
public String getIdName() {
ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
return meta.getIdentifierPropertyName();
}
}
只要dao层extends就行了,@Resouce (sessionFactory)注入sessionFactory.
些类一般放在声明式事务中.
/**
* 提供访问私有变量,提取泛型类型Class,提取集合中元素的属性等Utils函数。
*
* @author Allen
*
*/
public class ReflectionUtils {
private static Logger logger = LoggerFactory
.getLogger(ReflectionUtils.class);
/**
* 转换object 到clazz的property类型的值.
*
* @param value 待转换的对象
* @param clazz 提供类型信息的Class
* @param propertyName 提供类型信息的Class的属性.
*/
public static Object convertValue(Object value, Class<?> clazz, String propertyName) {
try {
Class<?> toType = BeanUtils.getPropertyDescriptor(clazz, propertyName).getPropertyType();
DateConverter dc = new DateConverter();
dc.setUseLocaleFormat(true);
dc.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss" });
ConvertUtils.register(dc, Date.class);
return ConvertUtils.convert(value, toType);
} catch (Exception e) {
throw convertToUncheckedException(e);
}
}
/**
* 提取集合中的对象的属性(通过getter函数),组合成由分割符分隔的字符串.
*
* @param collection 来源集合.
* @param propertyName 要提取的属性名.
* @param separator 分隔符.
*/
@SuppressWarnings("unchecked")
public static String fetchElementPropertyToString(final Collection collection,final String propertyName,final String separator)
{
List list=fetchElementPropertyToList(collection, propertyName);
return StringUtils.join(list, separator);
}
/**
* 提取集合中的对象的属性(通过getter函数),组合成List.
*
* @param collection 来源集合.
* @param propertyName 要提取的属性名.
*
*/
@SuppressWarnings("unchecked")
public static List fetchElementPropertyToList(final Collection collection,final String propertyName)
{
List list=new ArrayList();
for(Object obj:collection)
{
try {
list.add(PropertyUtils.getProperty(obj, propertyName));
} catch (Exception e) {
e.printStackTrace();
convertToUncheckedException(e);
}
}
return list;
}
/**
* 将反射时的checked exception转换为unchecked exception.
*/
public static IllegalArgumentException convertToUncheckedException(Exception e)
{
if(e instanceof IllegalAccessException|| e instanceof IllegalArgumentException||e instanceof NoSuchMethodException)
{
return new IllegalArgumentException("Refelction Exception.",e);
}
else
return new IllegalArgumentException(e);
}
/**
* 通过反射,获得Class定义中声明的父类的泛型参数的类型.
* eg.
* public UserDao extends HibernateDao<User>
*
* @param clazz The class to introspect
* @return the first generic declaration, or Object.class if cannot be determined
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> getSuperClassGenricType(final Class clazz)
{
return getSuperClassGenricType(clazz,0);
}
/**
* 通过反射,获得定义Class时声明的父类的泛型参数的类型.
*
* 如public UserDao extends HibernateDao<User,Long>
*
* @param clazz clazz The class to introspect
* @param index the Index of the generic declaration,start from 0.
* @return the index generic declaration, or Object.class if cannot be determined
*/
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(final Class clazz,final int index)
{
Type genType=clazz.getGenericSuperclass();//注意由于只有一个父类,所以这么写
//如果不是参数化类型,则返回Object.class
if(!(genType instanceof ParameterizedType))
{
logger.warn(clazz.getSimpleName()+"'s superclass not ParameterizedType");
return Object.class;
}
//可能有多个参数,所以这么写
Type[] params=((ParameterizedType)genType).getActualTypeArguments();
if(index>=params.length||index<0){
logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
+ params.length);
return Object.class;
}
//如果是基本类型,如int
if (!(params[index] instanceof Class)) {
logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
}
return (Class)params[index];
}
public static Object invokeMethod(final Object object,final String methodName,final Class<?>[] parameterTypes,
final Object[] parameters)throws InvocationTargetException{
Method method=getDeclaredMethod(object,methodName,parameterTypes);
if(method==null)
throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
method.setAccessible(true);
try {
return method.invoke(object, parameters);
} catch (IllegalAccessException e) {
e.printStackTrace();
logger.error("不可能抛出的异常:{}", e.getMessage());
}
return null;
}
/**
* 循环向上转型,获取对象的DeclaredMethod.
* @param object
* @param methodName
* @param parameterTypes
* @return
*/
protected static Method getDeclaredMethod(Object object,String methodName,Class<?>[] parameterTypes)
{
Assert.notNull(object,"object不能为空");
for(Class<?> superClass=object.getClass();superClass!=Object.class;superClass=superClass.getSuperclass())
{
try {
return superClass.getDeclaredMethod(methodName, parameterTypes);
}
catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
return null;
}
/**
* 直接设置对象属性值,无视private/protected修饰符,不经过setter函数。
* @param object
* @param fieldName
* @param value
*/
public static void setFieldValue(final Object object,final String fieldName,final Object value)
{
Field field=getDeclaredField(object, fieldName);
if(field==null)
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
makeAccessible(field);
try {
field.set(object, value);
} catch (IllegalAccessException e) {
e.printStackTrace();
logger.error("不可能抛出的异常:{}",e.getMessage());
}
}
/**
* 直接读取对象属性值,不管private/protected修饰符,不经过getter函数。
*
* @param object
* @param fieldName
* @return
*/
public static Object getFieldValue(final Object object,
final String fieldName) {
Field field = getDeclaredField(object, fieldName);
if (field == null)
throw new IllegalArgumentException("Could not find field ["
+ fieldName + "] on target [" + object + "]");
makeAccessible(field);
Object result = null;
try {
result = field.get(object);
} catch (IllegalAccessException e) {
e.printStackTrace();
logger.error("不可能抛出的异常{}", e.getMessage());
}
return result;
}
/**
* 循环向上转型,获取对象的DeclaredField.
*
* @param field
*/
protected static void makeAccessible(final Field field) {
if (!Modifier.isPublic(field.getModifiers())
|| !Modifier.isPublic(field.getDeclaringClass().getModifiers()))
field.setAccessible(true);
}
/**
* 循环向上转型,获取对象的DeclaredField.
*
* @param object
* @param fieldName
* @return
*/
protected static Field getDeclaredField(final Object object,
final String fieldName) {
Assert.notNull(object, "object不能为空");
// 必须有东西,null和" "均不可++
Assert.hasText(fieldName, "必须指定fieldName");
// 找不到时从父类里去找。
for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass
.getSuperclass()) {
try {
return superClass.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
return null;
}
}
发表评论
-
spring+quartz定时器突然停止
2010-04-22 17:41 7814在spring使用quartz定时器中,有时定时器突然停了, ... -
jdbcTemplate和hibernateTemplate之二
2009-12-03 10:34 3116HibernateTemplate: 在我们dao层使用 ... -
jdbcTemplate和hibernateTemplate之一
2009-12-02 18:26 5209jdbcTemplate原理: 我们都知道在使用jdbc连接 ... -
spring事务说明和简单实例-2
2009-11-05 18:30 997二声明式事务: 声明式事务用于管理自己写的dao,servic ... -
事务级别
2009-11-05 12:02 1009事务隔离级别: a:脏读取:一个事务读取了另外一个并行事务未提 ... -
spring事务说明和简单实例-1
2009-11-04 16:15 1124spring事务一为"声明式,一为"可编程 ...
相关推荐
"Hibernate封装DAO层"就是将Hibernate的功能整合到DAO设计模式中,以实现更加高效、规范的数据库操作。 1. **DAO设计模式**: DAO模式是软件设计模式的一种,它的核心思想是创建一个独立于具体数据库操作的对象,...
ifunsu封装基于springjdbc的dao层,具体用法请看本站博客http://blog.csdn.net/ifunsu 。
自己封装的dao层,自我感觉很牛逼。可以下下来看看,提点优化建议
- 封装的Dao层方法应遵循单一职责原则,每个方法对应一个明确的操作,如增删改查。 7. **版本控制与乐观锁**: - 如果需要处理并发更新,MongoTemplate支持MongoDB的版本字段(`_version`),利用`@Version`注解...
MongoDB DAO层封装是数据库操作的重要一环,它在应用程序与数据库之间建立了一层抽象,使得数据访问更加简便和高效。在这个项目中,我们主要基于MongoDB 3.0版本和Spring Data 1.5进行整合,实现了DAO层的封装。下面...
Service层和DAO层是软件开发中常见的两种设计模式,主要用于分离业务逻辑和数据访问操作。在Java Web开发中,它们通常被应用于三层架构或MVC(Model-View-Controller)模型中。 DAO(Data Access Object)层是负责...
在C#编程中,"通用Dao层"是一个常见的设计模式,用于封装数据库操作,使得业务逻辑层能够专注于处理业务规则,而无需关心底层数据访问的细节。本篇将重点探讨如何利用C#的特性(Attribute)标签来实现这一目标,同时...
自己做项目每次用jdbc访问数据库都要进行get和set方法的交互,麻烦,就设计了一个封装类,可以直接把sql语言或对象参数传进去不用那些方法了,不过1.0版本只针对classes12.jar包可以用,开发了2.0版本可以兼容各种...
springMvc+Mybatis 最新版+Dao 层封装; 使用了 2016-07-28 maven 上下载的当前最新版本jar包 4.3.2 搭建的 springMVC + Mybatis +DAO 层封装..仅供参考学习...
在DAO层的封装中,我们需要创建一个通用的DAO接口,如`BaseDAO<T>`,然后为每种实体类创建具体的DAO实现。使用Spring的`@Repository` Annotation标记DAO实现,使其能够被Spring管理。在这个接口中,我们可以定义一个...
在给定的`TestDao`中,我们可以猜测这是一个用于测试DAO层实现的类。它可能包含了对DAO方法的调用,用于验证DAO功能的正确性。在单元测试中,我们通常会使用Mock框架(如Mockito)来模拟数据库操作,避免实际访问...
标题"ifunsu封装基于springjdbc的dao层api"指的是一个特定的项目或库,名为ifunsu,它已经对Spring JDBC进行了封装,以创建更易用的数据访问对象(DAO)层API。DAO层是应用程序中负责与数据库进行交互的部分,通常...
标题和描述中提到的"action层,dao层,service层,entity层"是这种分层架构的典型组成部分,下面将详细解释每一层的功能和它们之间的交互。 1. **Action层(控制层)**: 这一层主要负责接收用户的请求,进行业务...
本篇将围绕“Spring3 JDBC通用DAO封装”这一主题展开,介绍如何实现一个高效的DAO层,并分享相关代码示例。 1. **Spring3 JDBC概述** Spring3 JDBC通过提供JdbcTemplate和SimpleJdbcInsert等工具类,帮助开发者...
通过以上设计,我们可以构建出一个高效、灵活且易于维护的Mybatis通用DAO层。这种设计封装了数据库操作的细节,使得业务逻辑层可以更专注于业务本身,提升了开发效率。在实际项目中,可以根据具体需求进行适当的扩展...
2. **代码复用性**:一个泛型DAO类可以用于处理任何实体类型,大大减少了代码量,提高了代码的可维护性。 3. **灵活性**:能够轻松地扩展功能,如添加新的查询方法,而无需修改大量现有代码。 #### 实现细节 在给...
在IT行业中,DAO(Data Access Object)层是软件设计模式中的一个重要组成部分,它主要用于封装对数据库的操作,使得业务逻辑层与数据访问层解耦。"DAO层自动生成"这一技术旨在提高开发效率,减少手动编写重复代码的...
Java之JDBC连接数据库实现增删改查(2018 使用Dao层实现 完美封装解决硬编码问题) 配置文件 db.properties(保存数据库账号和密码等) 工具类 JDBCUtil.java(抽取公共部分,解决硬编码问题) 用户账号实体类 User....
建模工具类在Dao层可能包含诸如连接管理、事务处理、SQL执行等通用功能,例如`JDBCUtils`,这是一个常用的Java JDBC辅助类,用于简化数据库连接的获取和释放,以及执行SQL语句。 `JDBCUtils`文件可能包含以下功能:...
本项目是关于一个图书管理系统的DAO层实现,适合初学者理解和学习。 首先,"图书管理系统"是一个常见的应用场景,它涉及到书籍信息的添加、查询、修改和删除等操作。在设计此类系统时,我们需要考虑实体类(Entity ...