JPA SPRING 泛型DAO

最新推荐文章于 2019-12-12 10:17:08 发布
最新推荐文章于 2019-12-12 10:17:08 发布
阅读量204 收藏
点赞数
分类专栏： EJB / 企业级服务器 文章标签： DAO JPA Spring ORM SQL 
package com.core.support.springSupportDao;

import java.io.Serializable;
import java.util.List;

/**
 * 此泛型DAO来自easyjweb
 * 泛型DAO接口
 */
public interface GenericDAO<T> {

	/**
	 * 根据Id查找一个类型为T的对象。
	 * 
	 * @param id
	 *            传入的ID的值
	 * @return 一个类型为T的对象
	 */
	T get(Serializable id);

	/**
	 * 持久化一个对象，该对象类型为T。
	 * 
	 * @param newInstance
	 *            需要持久化的对象，使用JPA标注。
	 */
	<T>T save(T newInstance);

	/**
	 * 根据对象id删除一个对象，该对象类型为T
	 * 
	 * @param id
	 *            需要删除的对象的id。
	 */
	void delete(Serializable id);

	/**
	 * 更新一个对象，主要用于更新一个在persistenceContext之外的一个对象。
	 * 
	 * @param transientObject
	 *            需要更新的对象，该对象不需要在persistenceContext中。
	 */
	void update(T transientObject);

	/**
	 * 根据对象的一个属性名和该属性名对应的值来查找一个对象。
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性名对应的值
	 * @return 一个对象，如果在该属性名和值的条件下找到多个对象，则抛出一个IllegalStateException异常
	 */
	T getBy(String propertyName, Object value);

	/**
	 * 根据一个查询条件及其参数，还有开始查找的位置和查找的个数来查找任意类型的对象。
	 * 
	 * @param queryName
	 *            命名查询的名字
	 * @param params
	 *            查询条件中的参数的值。使用Object数组，要求顺序和查询条件中的参数位置一致。
	 * @param begin
	 *            开始查询的位置
	 * @param max
	 *            需要查询的对象的个数
	 * @return 一个任意对象的List对象，如果没有查到任何数据，返回一个空的List对象。
	 */
	List executeNamedQuery(final String queryName, final Object[] params,
			final int begin, final int max);

	/**
	 * 根据一个查询条件及其参数，还有开始查找的位置和查找的个数来查找类型为T的对象。
	 * 
	 * @param query
	 *            查询的条件，使用位置参数，对象名统一为obj，查询条件从where后开始。比如：obj.name =
	 *            ?1 and obj.properties = ?2
	 * @param params
	 *            查询条件中的参数的值。使用Object数组，要求顺序和查询条件中的参数位置一致。
	 * @param begin
	 *            开始查询的位置
	 * @param max
	 *            需要查询的对象的个数
	 * @return 一个该类型对象的List对象，如果没有查到任何数据，返回一个空的List对象。
	 */
	List<T> find(String query, Object[] params, int begin, int max);

	/**
	 * 根据一个查询条件及其参数，还有开始查找的位置和查找的个数来查找任意类型的对象。
	 * 
	 * @param query
	 *            完整的查询语句，使用位置参数。比如：select user from User
	 *            user where user.name = ?1 and
	 *            user.properties = ?2
	 * @param params
	 *            查询条件中的参数的值。使用Object数组，要求顺序和查询条件中的参数位置一致。
	 * @param begin
	 *            开始查询的位置
	 * @param max
	 *            需要查询的对象的个数
	 * @return 一个任意对象的List对象，如果没有查到任何数据，返回一个空的List对象。
	 */
	List query(String query, Object[] params, int begin, int max);

	/**
	 * 根据jpql语句执行批量数据更新等操作
	 * 
	 * @param jpql
	 *            需要执行jpql语句
	 * @param params
	 *            语句中附带的参数
	 * @return
	 */
	int batchUpdate(String jpql, Object[] params);

	/**
	 * 执行SQL语句查询
	 * 
	 * @param nnq
	 * @return
	 */
	public List executeNativeNamedQuery(String nnq);

	List executeNativeQuery(final String nnq, final Object[] params,
			final int begin, final int max);

	/**
	 * 执行SQL语句
	 * 
	 * @param nnq
	 * @return
	 */
	public int executeNativeSQL(final String nnq);



/**
 *  flush()
 */
	public void flush();

}



package com.core.support.springSupportDao;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import javax.persistence.Query;

import org.springframework.orm.jpa.JpaCallback;
import org.springframework.orm.jpa.support.JpaDaoSupport;


import com.core.openstarbbsexception.JPAMothodParameterException;
import com.core.support.springSupportDao.GenericDAO;


public class GenericDAOImpl<T> extends JpaDaoSupport implements GenericDAO<T> {

	private Class<T> clazz;

	public GenericDAOImpl(Class<T> clazz) {
		this.clazz = clazz;
	}

	/*
	 * public void setClazz(Class<T> clazz) { this.clazz = clazz; } public
	 * Class<T> getClazz() { return clazz; }
	 */
	public T get(Serializable id) {
		if (id == null)
			return null;
		return this.getJpaTemplate().find(clazz,id);
	}

	public List<T> find(final String queryStr, final Object[] params,
			final int begin, final int max) {
		// TODO Auto-generated method stub
		List<T> ret = (List<T>) this.getJpaTemplate().execute(
				new JpaCallback() {

					public Object doInJpa(EntityManager em)
							throws PersistenceException {
						// TODO Auto-generated method stub
						String clazzName = clazz.getName();
						StringBuffer sb = new StringBuffer("select obj from ");
						sb.append(clazzName).append(" obj").append(" where ")
								.append(queryStr);
						Query query = em.createQuery(sb.toString());
						int parameterIndex = 1;
						if (params != null && params.length > 0) {
							for (Object obj : params) {
								query.setParameter(parameterIndex++, obj);
							}
						}
						if (begin >= 0 && max > 0) {
							query.setFirstResult(begin);
							query.setMaxResults(max);
						}
						if (begin >= 0 && max > 0) {
							query.setFirstResult(begin);
							query.setMaxResults(max);
						}
						return query.getResultList();
					}
				});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList<T>();
		}
	}

	public List query(final String queryStr, final Object[] params,
			final int begin, final int max) {
		// TODO Auto-generated method stub
		List ret = (List) this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				// TODO Auto-generated method stub
				Query query = em.createQuery(queryStr);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				if (begin >= 0 && max > 0) {
					query.setFirstResult(begin);
					query.setMaxResults(max);
				}
				/*
				 * if (begin >= 0 && max > 0) { query.setFirstResult(begin);
				 * query.setMaxResults(max); }
				 */
				return query.getResultList();
			}
		});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList();
		}
	}

	public void delete(Serializable id){
		if (id == null)
			try {
				throw new JPAMothodParameterException();
			} catch (JPAMothodParameterException e1) {
				e1.printStackTrace();
			}
		T object = this.get(id);
		if (object != null) {
			try {
				this.getJpaTemplate().remove(object);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public <T> T save(T instance) {
		// TODO Auto-generated method stub
		this.getJpaTemplate().persist(instance);
		return instance;
	}

	public T getBy(final String propertyName, final Object value) {
		if (propertyName == null || "".equals(propertyName) || value == null)
			try {
				throw new JPAMothodParameterException();
			} catch (JPAMothodParameterException e) {
				e.printStackTrace();
			}

		// TODO Auto-generated method stub
		List<T> ret = (List<T>) this.getJpaTemplate().execute(
				new JpaCallback() {

					public Object doInJpa(EntityManager em)
							throws PersistenceException {
						// TODO Auto-generated method stub
						String clazzName = clazz.getName();
						StringBuffer sb = new StringBuffer("select obj from ");
						sb.append(clazzName).append(" obj");
						Query query = null;
						if (propertyName != null && value != null) {
							sb.append(" where obj.").append(propertyName)
									.append(" = :value");
							query = em.createQuery(sb.toString()).setParameter(
									"value", value);
						} else {
							query = em.createQuery(sb.toString());
						}
						return query.getResultList();
					}
				});
		if (ret != null && ret.size() == 1) {
			return ret.get(0);
		} else if (ret != null && ret.size() > 1) {
			throw new java.lang.IllegalStateException(
					"worning  --more than one object find!!");
		} else {
			return null;
		}
	}

	public List executeNamedQuery(final String queryName,
			final Object[] params, final int begin, final int max) {
		List ret = (List) this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNamedQuery(queryName);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				if (begin >= 0 && max > 0) {
					query.setFirstResult(begin);
					query.setMaxResults(max);
				}
				return query.getResultList();
			}
		});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList();
		}
	}

	public void update(T instance) {
		// TODO Auto-generated method stub
		this.getJpaTemplate().merge(instance);
	}

	public void setClazzType(Class clazz) {
		this.clazz = clazz;
	}

	public Class getClassType() {
		return this.clazz;
	}

	public List executeNativeNamedQuery(final String nnq) {
		Object ret = this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNativeQuery(nnq);
				return query.getResultList();
			}
		});
		return (List) ret;
	}

	public List executeNativeQuery(final String nnq, final Object[] params,
			final int begin, final int max) {
		List ret = (List) this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNativeQuery(nnq);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				if (begin >= 0 && max > 0) {
					query.setFirstResult(begin);
					query.setMaxResults(max);
				}
				return query.getResultList();
			}
		});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList();
		}
	}

	public int executeNativeSQL(final String nnq) {
		Object ret = this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNativeQuery(nnq);
				return query.executeUpdate();
			}
		});
		return (Integer) ret;
	}

	public int batchUpdate(final String jpql, final Object[] params) {
		Object ret = this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createQuery(jpql);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				return query.executeUpdate();
			}
		});
		return (Integer) ret;
	}


	public void flush() {
		this.getJpaTemplate().execute(new JpaCallback() {
		public Object doInJpa(EntityManager em) throws PersistenceException {
			em.getTransaction().commit();
			return null;
			}
		});
	}
}



package com.core.openstarbbsexception;

/**
 * OpenStarBBS自定义异常。
 * @author treblesoftware
 *
 */
public class JPAMothodParameterException extends Exception {

	public JPAMothodParameterException(){
	super("JPA ORM SUPPORT EXCEPTION:com.core.support.dao.GenericDAOImpl 方法参数为NULL。错误"?);
	}
}
NationSoftware
关注
专栏目录
Hibernate泛型Dao
10-18
【标题】"Hibernate泛型Dao"是针对Java开发中的数据持久化框架Hibernate的一个高级应用，主要目的是为了提高代码的复用性和简洁性。在传统的Hibernate使用中，针对每个实体类，我们都需要创建一个对应的Dao（Data ...
泛型DAO模式在Java Web开发中的应用.pdf
最新发布
12-27
本文将详细介绍泛型DAO模式在Java Web开发中的应用，包括泛型机制、JPA框架、Struts框架和Spring框架的使用。 一、泛型机制 Java 5.0版本引入了泛型机制，提供了一种解决方案，使用类型参数来代替Object类型的变量...
struts2+jpa+spring 泛型版小结
jackyrongvip的专栏
08-25 959
  struts 2+jpa+spring 的,如果用上范型的话,还是能省不少事的哦.把以前的小结之. 首先搞个DAO的基础接口import java.io.Serializable;import java.util.List;import javax.persistence.Query;public interface IBaseDAO { public
JPA的泛型DAO设计及使用
banglaiqi4707的博客
03-10 679
使用如Hibernate或者JPA作为持久化的解决方案时，设计一个泛型的DAO抽象父类可以方便各个实体的通用CRUD操作。由于此时大部分实体DAO的CRUD操作基本一样，采用泛型设计解决这个问题，带来了简洁代码的好处。 问题的关键在于我们需要在代码中获取抽象DAO父类（BaseEntityDAOImpl<T>）中的泛型信息。 由于Java的泛型是基于泛型擦除实现的，因...
JPA 泛型DAO 封装(源码来自EasyJWeb)
NationSoftware的专栏
11-27 244
对于在Web容器中使用EntityManager对象，这里需要做一些改进，才能更安全。Servlet是非线程安全的，所以需要改变获得EntityManager对象的方式，这里使用ThreadLocal类。 ThreadLocal就是为每一个使用某变量的线程都提供一个该变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有一个该...
泛型DAO在JPA中的应用
SuperBoo的专栏
01-07 2000
泛型DAO在JPA中的应用 收藏import java.io.Serializable;import java.util.ArrayList;import java.util.List;import javax.persistence.EntityManager;import javax.persistence.PersistenceException;import ja
基于JDBC,JPA Annotation 实现的简易CRUD的泛型Dao
[203] 一直都有新高度
02-23 146
:D 想法的由来是蛮长的历史原因: [color=red][b][使用iBATIS的历史][/b][/color] 使用iBATIS已经有很长一段时间了,系统中的CRUD是使用模板工具生成的代码,虽说有工具生成,但看着一大堆CRUD的SqlMap.xml文件,依旧是很不爽的一件事情. [color=red][b][Hibernate与iBATIS的整合][/b][...
Java Web程序运用中泛型DAO的作用.zip
10-16
在实际的Java Web应用中，我们可以结合Spring框架的Hibernate或JPA支持，进一步简化泛型DAO的实现，利用Spring的模板类如JdbcTemplate、HibernateTemplate等，自动处理SQL执行和结果映射。 总的来说，泛型DAO在Java...
SpringBoot使用Spring-data-jpa简化数据访问层
05-09
对数据库的操作无非就“增删改查”。就最为普遍的单表操作而言，除了表和字段不同外，语句都是类似的，开发人员需要写...Spring-data-jpa的出现正可以让这样一个已经很“薄”的数据访问层变成只是一层接口的编写方式。
SSH2全注解整合（spring2.5+hibernate3.3+struts2.1+泛型DAO+proxool连接池）
03-30
泛型DAO（Data Access Object）是一种设计模式，用于抽象数据访问层的操作，提供通用的CRUD（Create, Read, Update, Delete）方法。通过泛型，DAO可以适用于多种类型的实体，降低了代码重复。例如，一个BaseDAO接口...
封装JPA的数据操作公共DAO基类
06-05
通过将公共通用操作写进父类简化代码，提高代码的复用。 面向接口 使用继承 泛型 引入JPA API查询 以及 元数据 提高代码的安全性.
[JDBC]Dao中的泛型使用
weixin_41985660的博客
09-17 254
package cn.wcs.dao.impl; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import cn.wcs.model.Product; import cn.wcs.utils.Jdb...
封装JPA的数据操作DAO类
menghuannvxia的专栏
11-23 5937
对JPA的实体操作进行了简单的封装，降低了数据操作的难度，提高了开发的效率。里面可能会有少许hibernate的元素。 DAO.java /************************* 版权声明 ********************************* * * 版权所有：百洋软件 * Copyright (c) 2009 by Pearl Ocean. * *
SpringBoot 入门（四）——JPA
禽兽先生不禽兽
07-31 1431
在上一篇博客SpringBoot 入门（三）——数据持久化中，已经明白了如何利用注解为实体类创建对应的表以及表与表之间的关系，那么有了表过后就要对表进行操作，SpringBoot 自带的 JPA 对于新手来说简直就是神器，只需要定义一个 Repository 接口，基本不用写什么代码，一些常规的 CRUD 操作就有了，下面就看看这是如何操作的。 引入的依赖 JPA 部分跟上一篇博客一样，就不重复...
SpringBoot使用JPA,详细介绍
LioSamson
12-12 712
一、ORM思想 定义:ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的。 常见的ORM框架：Mybatis（ibatis）、Hibernate、Jpa规范 二、Hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动...
JPA之抽象类与泛型接口
atnp70962的博客
07-05 886
实体类抽象父类 @MappedSuperclass @Data public abstract class CommonEntity { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @JsonFormat(pattern = "yyyy-MM-d...
Spring data jpa 实体类配置问题
Jim~LoveQ的博客
03-27 864
使用Spring data jpa 时候实体类注意事项： 碰到问题：使用SysUserRepository自带的find方法查询不到数据，使用findall查询到的拘束，基本都是null，除了个别可以查询到。 解决：为实体类配置IdClass,即实体类需要有一个与数据库中的表完全对应的实体类，然后还需要有一个实体类作为IdClass，即建一个普通实体类，里面只包含表中的ID所对应的所有字段。网上查...
Java Web开发中的泛型DAO模式应用分析
"本文探讨了泛型DAO模式在Java Web开发中的应用，特别是在Struts、Spring和JPA框架集成的环境中，如何提高代码的安全性、可读性和通用性。通过一个具体的用户管理系统案例，展示了泛型DAO模式相对于传统DAO模式的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值