java中继承+接口+泛型的无解组合

最新推荐文章于 2025-08-20 15:04:37 发布
最新推荐文章于 2025-08-20 15:04:37 发布
阅读量737 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java Java JAVA java 接口 泛型 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zai829/article/details/8599868
本文介绍了一种基于Java的通用DAO设计模式，通过抽象基类BaseHibernateDao实现了CRUD等常见操作，极大减少了开发工作量。具体展示了User实体类、IBaseDao接口及其实现类BaseHibernateDao的代码细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

不废话直接上代码：

 

工程结构图：

 

实体User：

package com.smonk.user.entity;

public class User {
//....
}


IBaseDao：

package com.smonk.common.base;

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

public interface IBaseDao<T, ID extends Serializable> {

 public abstract List<T> findAll();

 /**
  * 查找所有，并分页
  * @param page 要返回的页数
  * @param pageSize 没有记录数
  * @return
  */
 public abstract List<T> findAll(int page, int pageSize);

 public abstract void save(T entity);

 public abstract void delete(T entity);

 /**
  * 与findByProperty相似，当properyName == value 时把相应的记录删除
  */
 public abstract void deleteByProperty(String propertyName, Object value);

 public abstract List<T> findByExample(T example);

 /**
  * 通过属性查找
  * @param propertyName 属性名称
  * @param value 属性的值
  * @return
  */
 public abstract List<T> findByProperty(String propertyName, Object value);

 /**
  * 通过多个属性查找
  * @param propertyNames 属性名称数组
  * @param values 属性值数组
  * @return
  */
 public abstract List<T> findByPropertys(String[] propertyNames,
   Object[] values);

 /**
  * 通过多个属性查找，并分页， 属性名称数组和属性值数组的序列要对应
  * 
  * @param propertyNames 属性名称数组
  * @param values 属性值数组
  * @param page 页码
  * @param pageSize 每页内容条数
  * @return
  */
 public List<T> findByPropertys(String[] propertyNames, Object[] values,
   int page, int pageSize);

 /**
  * 通过属性查找，并分页， 属性名称数组和属性值数组的序列要对应
  * @param propertyNames 属性名称
  * @param values 属性值
  * @param page 页码
  * @param pageSize 每页内容条数
  * @return
  */
 public List<T> findByProperty(String propertyName, Object value, int page,
   int pageSize);

 /**
  * 统计所有记录的总数
  * @return 总数
  */
 public int countAll();

 /**
  * 统计数据库中当propertyName=value时的记录总数
  * @param propertyName
  * @param value
  * @return
  */
 public int countByProperty(String propertyName, Object value);

 /**
  * 统计数据库中当多个propertyName=value时的记录总数
  * @param propertyNames
  * @param values
  * @return
  */
 public int countByPropertys(String[] propertyNames, Object[] values);

 public abstract void saveOrUpdate(T entity);

 public abstract T findById(ID id);

 public abstract void update(T entity);

 /**
  * 获得持久化对象的类型
  * @return
  */
 public abstract Class<T> getPersistentClass();

 /**
  * 查找并通过某一属性排序
  * @param property 排序依据的顺序
  * @param isSequence 是否顺序排序
  */
 public List<T> findAndOrderByProperty(int firstResult, int fetchSize,
   String propertyName, boolean isSequence);

 /**
  * 查找并通过某一属性排序
  * @param property 排序依据的顺序
  * @param isSequence 是否顺序排序
  */
 public List<T> findAllAndOrderByProperty(String propertyName,
   boolean isSequence);

}


 

BaseHibernateDao:

package com.smonk.common.base;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;

import org.hibernate.Query;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public abstract class BaseHibernateDao<T, ID extends Serializable> extends
		HibernateDaoSupport implements IBaseDao<T, ID> {
	private Class<T> persistentClass;

	@SuppressWarnings("unchecked")
	public BaseHibernateDao() {
		// 获取持久化对象的类型
		this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
				.getGenericSuperclass()).getActualTypeArguments()[0];
	}

	public Class<T> getPersistentClass() {
		return persistentClass;
	}

	/**
	 * 通过id查找
	 * @param id
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T findById(ID id) {
		return (T) this.getHibernateTemplate().get(getPersistentClass(), id);
	}

	public void save(T entity) {
		this.getHibernateTemplate().save(entity);
	}

	/**
	 * 删除
	 */
	public void delete(T entity) {
		this.getHibernateTemplate().delete(entity);
	}

	/**
	 * 通过属性删除
	 */
	public void deleteByProperty(String propertyName, Object value) {
		String queryString = "delete from " + getPersistentClass().getName()
				+ " as model where model." + propertyName + "= ?";
		Query query = this.getSession().createQuery(queryString);
		query.setParameter(0, value);
		query.executeUpdate();
	}

	/**
	 * saveOrUpdate
	 */
	public void saveOrUpdate(T entity) {
		this.getHibernateTemplate().saveOrUpdate(entity);
	}

	/**
	 * 更新
	 */
	public void update(T entity) {
		this.getHibernateTemplate().update(entity);
	}

	/**
	 * 分页查找所有的记录
	 * @param page 要返回的页数
	 * @param pageSize 没有记录数
	 * @return
	 */
	public List<T> findAll(int page, int pageSize) {
		String queryString = "from " + getPersistentClass().getName();
		Query query = this.getSession().createQuery(queryString);
		int firstResult = (page - 1) * pageSize;
		query.setFirstResult(firstResult);
		query.setMaxResults(pageSize);
		return query.list();
	}

	/**
	 * 统计所有记录的总数
	 * @return 总数
	 */
	public int countAll() {
		String queryString = "select count(*) from "
				+ getPersistentClass().getName();
		Query query = this.getSession().createQuery(queryString);
		List list = query.list();
		Long result = (Long) list.get(0);
		return result.intValue();
	}

	/**
	 * find By Example
	 * @param entity
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<T> findByExample(T entity) {
		return this.getHibernateTemplate().findByExample(entity);
	}

	@SuppressWarnings("unchecked")
	public List<T> findAll() {
		return this.getHibernateTemplate().find(
				"from " + getPersistentClass().getName());
	}

	/**
	 * 通过属性查找
	 * @param propertyName 属性名称
	 * @param value 属性的值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<T> findByProperty(String propertyName, Object value) {
		String queryString = "from " + getPersistentClass().getName()
				+ " as model where model." + propertyName + "= ?";
		return this.getHibernateTemplate().find(queryString, value);

	}

	/**
	 * 通过多个属性组合查询
	 * @param propertyNames 属性名称数组
	 * @param values 对应于propertyNames的值 return 匹配的结果
	 */
	public List<T> findByPropertys(String[] propertyNames, Object[] values) {
		StringBuffer strBuffer = new StringBuffer();
		strBuffer.append("from " + getPersistentClass().getName());
		strBuffer.append(" as model where ");
		for (int i = 0; i < propertyNames.length; i++) {
			if (i != 0)
				strBuffer.append(" and");
			strBuffer.append(" model.");
			strBuffer.append(propertyNames[i]);
			strBuffer.append("=");
			strBuffer.append("? ");
		}
		String queryString = strBuffer.toString();
		return this.getHibernateTemplate().find(queryString, values);
	}

	/**
	 * 通过属性查找并分页
	 * @param propertyName 属性名称
	 * @param value 属性值
	 * @param page 页数
	 * @param pageSize 每页显示条数
	 */
	public List<T> findByProperty(String propertyName, Object value, int page,
			int pageSize) {
		return this.findByPropertys(new String[] { propertyName },
				new Object[] { value }, page, pageSize);
	}

	/**
	 * 通过多个属性组合查询
	 * @param propertyNames 属性名称数组
	 * @param values 对应于propertyNames的值
	 * @param page 页数
	 * @param pageSize 每页显示数 return 匹配的结果 return 匹配的结果
	 */
	public List<T> findByPropertys(String[] propertyNames, Object[] values,
			int page, int pageSize) {

		StringBuffer strBuffer = new StringBuffer();
		strBuffer.append("from " + getPersistentClass().getName());
		strBuffer.append(" as model where ");
		for (int i = 0; i < propertyNames.length; i++) {
			if (i != 0)
				strBuffer.append(" and");
			strBuffer.append(" model.");
			strBuffer.append(propertyNames[i]);
			strBuffer.append("=");
			strBuffer.append("? ");
		}
		String queryString = strBuffer.toString();

		int firstResult = (page - 1) * pageSize;

		Query query = this.getSession().createQuery(queryString);
		query.setFirstResult(firstResult);
		query.setMaxResults(pageSize);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}

		return query.list();
	}

	/**
	 * 通过属性统计数量
	 * @param propertyName 属性名称
	 * @param value 属性值
	 */
	public int countByProperty(String propertyName, Object value) {
		String[] propertyNames = new String[] { propertyName };
		Object[] values = new Object[] { value };
		return this.countByPropertys(propertyNames, values);
	}

	/**
	 * 通过多个属性统计数量
	 * @param propertyNames 属性名称数组
	 * @param values 对应的属性值数组 return
	 */
	public int countByPropertys(String[] propertyNames, Object[] values) {
		StringBuffer strBuffer = new StringBuffer();
		strBuffer.append("select count(*) from "
				+ getPersistentClass().getName());
		strBuffer.append(" as model where ");
		for (int i = 0; i < propertyNames.length; i++) {
			if (i != 0)
				strBuffer.append(" and");
			strBuffer.append(" model.");
			strBuffer.append(propertyNames[i]);
			strBuffer.append("=");
			strBuffer.append("? ");
		}

		String queryString = strBuffer.toString();
		Query query = this.getSession().createQuery(queryString);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}

		List list = query.list();
		Long result = (Long) list.get(0);
		return result.intValue();
	}

	/**
	 * 查找T并通过某一属性排序
	 * @param property 排序依据的顺序
	 * @param isSequence 是否顺序排序,false为倒序
	 */
	public List<T> findAndOrderByProperty(int firstResult, int fetchSize,
			String propertyName, boolean isSequence) {
		String queryString = "from " + getPersistentClass().getName()
				+ " as model order by model." + propertyName;
		if (isSequence == false) {
			queryString = queryString + " DESC";
		}

		Query queryObject = getSession().createQuery(queryString);
		queryObject.setFirstResult(firstResult);
		queryObject.setMaxResults(fetchSize);
		return queryObject.list();

	}

	/**
	 * 查找所有并通过某个属性排序
	 * @param propertyName 排序依据的属性名称
	 * @param isSequence 是否顺序排列
	 */
	public List<T> findAllAndOrderByProperty(String propertyName,
			boolean isSequence) {
		String queryString = "from " + getPersistentClass().getName()
				+ " as model order by model." + propertyName;
		if (isSequence == false) {
			queryString = queryString + " DESC";
		}

		Query queryObject = getSession().createQuery(queryString);
		return queryObject.list();
	}

}


IUserDao:

package com.smonk.user.dao;

import com.smonk.common.base.IBaseDao;
import com.smonk.user.entity.User;

public interface IUserDao extends IBaseDao<User, Integer> {
	/**
	 * 通过用户名查找用户
	 * @param userName 用户名
	 * @return TUser 用户对象，如果用户名不存在返回null
	 */
	public User findByUserName(String userName);
}


UserHibernateDao:

package com.smonk.user.dao;

import java.util.List;

import com.smonk.common.base.BaseHibernateDao;
import com.smonk.user.entity.User;

public class UserHibernateDao extends BaseHibernateDao<User, Integer> implements
		IUserDao {

	// property constants
	public static final String USER_NAME = "userName";

	/**
	 * 通过名称查找用户
	 * @return User
	 */
	public User findByUserName(String userName) {
		List<User> userList = super.findByProperty(USER_NAME, userName);
		if (userList.size() != 0) {
			return userList.get(0);
		} else {
			return null;
		}
	}
	
	public static void main(String[] args) {
		Integer id = 10;
		IUserDao dao = new UserHibernateDao();
		dao.findById(id);
	}
}


请看只有寥寥几句的UserDao拥有多少功能！！！：

 

亲，请问这样的架构省了多少代码？省了多少人天？省了多少枯燥与烦扰？。。。
zaikooLu
关注
37、Java 中的静态导入、注解与泛型基础
kappa的博客
06-26 20
本文深入介绍了Java中的三个核心特性：静态导入、注解和泛型。通过示例详细解析了它们的基本概念、使用方法以及应用场景。静态导入简化了对静态成员的调用；注解为程序提供了额外的元数据信息；泛型则通过参数化类型实现了类型安全的代码重用。最后，还综合演示了三者的应用实例，并总结了它们的实际优势与注意事项。
Java总结(8)集合里的泛型
ActionReaction的专栏
06-20 707
IO流： 1 IO流用来处理设备之间的数据传输。 2 java对数据的操作是通过流的方式。 3 Java用于操作流的对象都在IO包中。 4 流按操作数据分为两种：字节流(InputStream,OutputStream)与字符流(Writer,Reader)。 5 流按流向分为：输入流，输出
泛型 Generic
luorufeng的专栏
09-20 109
 泛型的本质：类型参数化。 一：泛型的优点：    a, 让我们少写几个类的代码，b,让我们定义安全的泛型类 二：自定义泛型类： package gen01; /** * 自定义泛型类 BasicController * @author john * * @param &lt;E&gt; * @param &lt;S&gt; */ public cl...
Entity实体类为什么要实现Serializable接口才能被序列化？
一勺菠萝丶的博客
06-19 2833
引起这个疑问，还是从Hibernate使用查询缓存说起；对象实例除了存在于内存，二级缓存还会将对象写进硬盘在需要的时候再读取出来使用，此时就必须提到一个概念：序列化。 程序在运行时实例化出对象，这些对象存在于内存中，随着程序运行停止而消失，但如果我们想把某些对象（一般都是各不相同的属性）保存下来或者传输给其他进程，在程序终止运行后这些对象仍然存在，可以在程序再次运行时读取这些对象的信息，或者在其他...
public abstract class 和 public interface&策略模式
菜鸟的博客
10-11 9509
直观，先上代码： public interface： public interface ChannelsPayService { <T extends Serializable> T tradeCreate(TradeOrderDto order); <R extends Serializable> NotifyHandleResultDto<R&...
java接口取代继承,设计模式：组合、接口、委托替代继承
weixin_30022923的博客
03-22 473
针对“会飞”这样一个行为特性，我们可以定义一个 Flyable 接口，只让会飞的鸟去实现这个接口。对于会叫、会下蛋这些行为特性，我们可以类似地定义 Tweetable 接口、EggLayable 接口。我们将这个设计思路翻译成 Java 代码的话，就是下面这个样子：public interface Flyable {void fly();}public interface Tweetable {v...
利用泛型抽取Dao层，加事务注解问题（java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType）
gaojiyinhang2的专栏
12-09 1770
想利用泛型抽取BaseDao层，简化操作时出现问题： @Transactional这个注解是可以继承的，于是就想写在抽取的BaseDao层上，让实现的类可以不用写@Transactional，就可开启事务。 问题描述： 由于偷懒，没给BaseDao抽接口，代码如下： [java] view plaincopy package com.liang.ssh2.base; 
深入解析Java编程中接口的运用
09-03
Java编程中的接口是一种重要的面向对象特性，它提供了一种方式来定义对象之间的交互规范，而无需关注具体的实现细节。接口的本质可以理解为一种特殊的抽象类，但与抽象类不同的是，接口只包含常量（静态、不可变）和...
Java进阶之泛型与语法糖
lishinho的博客
07-19 922
Java泛型是一个重要的Java概念，虽然Java的继承和接口丰富了多态的灵活性，但我们仍然希望编写更通用的代码，能够适用“非特定的类型”，而不是一个具体的接口或类。同时泛型是如何产生并使用的，我们的代码里泛型究竟充当了什么样的角色？ 一，Java的编译期与运行期 从你写下Java代码（打印helllo world）到运行显示出你输入的效果，你的Java程序究竟经历了什么？ 程序从高级程序语言编译到机器语言；通过编译器的语法糖优化java程序用于提高代码效率 Java程序的编译与优化分为两个阶段，一
Java顺序表：算法设计中的高效工具，泛型实现与注意事项
[Java顺序表：算法设计中的高效工具，泛型实现与注意事项](https://media.geeksforgeeks.org/wp-content/cdn-uploads/20230726162247/Array-data-structure.png) # 1. Java顺序表概述与基本概念 ## 1.1 顺序表的...
public interface BaseService「T,ID extends Serializable」{}参数是什么意思
小肥羊的博客
07-07 2413
public interface BaseService<T,ID extends Serializable>{ //ID是泛型的参数，这个ID一定要是一个实现了Serializable的类型，所谓的Serializable,就是java提供的通用数据保存和读取的接口。至于从什么地方读出来和保存到哪里去都被隐藏在函数参数的背后了。这样，任何类型只要实现了Serializable接口，就可以被保存到文件中，或者作为数据流通过网络发送到别的地方。也可以用管道来传输到系统的其他程序中。这样子极大的简化
hibernate 泛型 DAO
jazywoo_在路上
09-11 657
Data Access Object (DAO) 是一般的J2EE项目中的一个常见的模块，在我们用一般的方法去实现DAO的过程中会发现在为每个pojo实现DAO的的时候会不断地区重复的写一些常用的方法，如update(),delete(),find()等。            为了解决以上所述的缺点，可以采用DAO用泛型实现的方法，把通用的方法抽出来放到基类中，以后为pojo实现DAO的时候
java interface泛型_java – 使用泛型和接口实现组合
weixin_34364239的博客
02-16 887
我正在努力实现以下目标：我的类X有一个通用的Y.然而,这个泛型Y需要访问X的资源,我想通过接口来处理它,以便允许其他人继承任意选择的类.然而,我目前的方法会产生一系列泛型：public interface X>> {Object getO();}public interface Y>> {void doSomething();}我想要实现的目标：public class G...
通常在Dao和Service 中使用BaseDao<T extends Serializable>的泛型
阿狸_桃子
05-26 2433
经常看到那些写好的项目的dao是用的泛型，就不不理解为什么，看到了这个论坛上的两个例子，粘给大家： 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 　　Java语言引入泛型的好处是安全简单。 　　在Java SE 1.5之前，没有泛型的情况的下，通
关于interface（接口继承）extends（接口）interface的问题
热门推荐
程序大视界
03-25 1万+
前序 一直以来，我们学习java就被灌输了一个观点： 类和抽象类（class）只能被继承（extends），接口（interface）只能被实现（implements）。 有个概念我们一直没有弄懂的是：类（class）可以实现接口（interface），但是接口（interface）跟接口（interface）之间呢？ 类可以继承类和实现接口，如下： public class A...
深入理解 Spring 的 @ControllerAdvice
最新发布
Roc的博客
08-20 754
简单来说，是一个组件注解（被@Component元注解标注），它允许你将一个类声明为一个全局的、跨多个控制器的增强器（Advice）。你可以把它理解为 Spring MVC 版本的AOP（面向切面编程），但它不是基于代理，而是专门为控制器层设计的。全局异常处理全局数据绑定全局数据预处理命名清晰：类名如，明确其职责。区分使用场景开发，优先使用，专注于返回统一的 JSON 异常响应。开发传统多页应用，使用，可以混合处理异常、绑定模型等。避免过度使用。
【实时Linux实战系列】基于实时Linux的自适应控制系统
望获实时Linux系统
08-19 1004
本文介绍了基于实时Linux的自适应控制系统开发技术，重点阐述了其在工业自动化、航空航天等领域的应用价值。文章详细说明了环境准备、案例实现步骤和调试方法，包括温度自适应控制系统的开发过程，涉及实时任务调度、传感器数据采集和PWM控制等关键技术。同时提供了常见问题的解决方案和性能优化建议，为开发者掌握这一技术提供了实用指导。该技术能显著提升系统响应速度和稳定性，适用于需要高精度实时控制的各类场景。
08.常见文本处理工具
weixin_56408536的博客
08-18 822
查看二进制文件的不同。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值