泛型Dao

最新推荐文章于 2022-04-01 00:43:02 发布
最新推荐文章于 2022-04-01 00:43:02 发布
阅读量595 收藏
点赞数
分类专栏： java 文章标签： 泛型 分页
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013725455/article/details/40212871
版权

 

泛型DAO

 

package com.oracle.dao;

 

import java.util.List;

 

import com.oracle.util.Pagination;

 

public interface GenericDao<T,PK>{

       publicT save(T entity);

       publicT findById(PK id);  //主键

       publicList<T> findAll();

       publicvoid update(T entity);

       publicvoid delete(T entity);

      

       publicObject queryUniqueObject(String hql,Object[] params);

       //分页

       publicPagination<T>queryByPageList(String hql,Object[] params,intpageNumber,int pageSize,int maxElements);

             

}

 

 

package com.oracle.dao.impl;

 

import java.io.Serializable;

import java.lang.reflect.ParameterizedType;

import java.util.List;

 

import org.hibernate.Query;

import org.hibernate.Session;

 

import com.oracle.dao.GenericDao;

import com.oracle.util.Pagination;

import com.oracle.util.SessionFactoryUtils;

 

public class GenericDaoImpl<T, PKextends Serializable> implements

              GenericDao<T, PK> {

       privateClass<T> clazz = null;

//获取当前类的类名

       publicGenericDaoImpl() {

              clazz = (Class<T>)((ParameterizedType) getClass()

                            .getGenericSuperclass()).getActualTypeArguments()[0];

       }

 

       @Override

       publicT save(T entity) {

              Session session =SessionFactoryUtils.createSessionFactory() .getCurrentSession();

              session.beginTransaction();

              session.save(entity);

              session.getTransaction().commit();

              return entity;

       }

 

       @Override

       publicT findById(PK id) {

              T entity = null;

              Session session =SessionFactoryUtils.createSessionFactory() .getCurrentSession();

              session.beginTransaction();

              entity = (T) session.get(clazz, id);

              session.getTransaction().commit();

              return entity;

       }

 

       @Override

       publicList<T> findAll() {

              List<T> list = null;

              Session session =SessionFactoryUtils.createSessionFactory() .getCurrentSession();

              session.beginTransaction();

              String hql = "from " +clazz.getName();

              Query query = session.createQuery(hql);

              list = query.list();

              session.getTransaction().commit();

              return list;

       }

 

       @Override

       publicvoid update(T entity) {

              Session session =SessionFactoryUtils.createSessionFactory() .getCurrentSession();

              session.beginTransaction();

              session.update(entity);

              session.getTransaction().commit();

       }

 

       @Override

       publicvoid delete(T entity) {

              Session session =SessionFactoryUtils.createSessionFactory() .getCurrentSession();

              session.beginTransaction();

              session.delete(entity);

              session.getTransaction().commit();

       }

 

       @Override

       publicObject queryUniqueObject(String hql, Object[] params) {

              Object obj = null;

              Session session =SessionFactoryUtils.createSessionFactory() .getCurrentSession();

              session.beginTransaction();

              Query query = session.createQuery(hql);

              if (params != null) {

                     for(int i = 0; i < params.length; i++) {

                            query.setParameter(i, params[i]);

                     }

              }

              obj = query.uniqueResult();

              session.getTransaction().commit();

              return obj;

       }

 

 

//分页查询

       @Override

       publicPagination<T> queryByPageList(String hql, Object[] params,

                     intpageNumber, int pageSize, int maxElements) {

              Pagination<T> pagination = newPagination(pageSize, pageNumber, maxElements);

              Session session =SessionFactoryUtils.createSessionFactory()

                            .getCurrentSession();

              session.beginTransaction();

              Query query = session.createQuery(hql);

              if (params != null) {

                     for(int i = 0; i < params.length; i++) {

                            query.setParameter(i, params[i]);

                     }

              }

              query.setFirstResult((pageNumber-1)*pageSize);

              query.setMaxResults(pageSize);

              //获取当前页的记录集合

              List<T> pageList = query.list();

              //给pagination的集合属性赋值

              pagination.setPageList(pageList);

              session.getTransaction().commit();

              return pagination;

       }

 

}

 

 

package com.oracle.dao;

 

import com.oracle.model.GuestBook;

import com.oracle.util.Pagination;

 

public interface GuestBookDao extendsGenericDao<GuestBook, Integer> {

       publicPagination<GuestBook> queryByPageList(int pageNumber,int pageSize);

}

 

 

package com.oracle.dao.impl;

 

import com.oracle.dao.GuestBookDao;

import com.oracle.model.GuestBook;

import com.oracle.util.Pagination;

 

public class GuestBookDaoImpl extendsGenericDaoImpl<GuestBook, Integer> implements

              GuestBookDao {

 

       @Override

       publicPagination<GuestBook> queryByPageList(int pageNumber, int pageSize) {

              String hql = "from GuestBook orderby createTime desc";

              //求总记录数

              int maxElements =Integer.parseInt(queryUniqueObject("select count(*) from                                                GuestBook",null).toString());

             

              return queryByPageList(hql, null,pageNumber, pageSize, maxElements);

       }

 

}

 

 

package com.oracle.biz;

 

import java.util.List;

 

import com.oracle.model.GuestBook;

import com.oracle.util.Pagination;

 

public interface GuestBookBiz {

       publicGuestBook addGuestBook(GuestBook guestBook);

       publicList<GuestBook> getAllGuestBooks();

       publicPagination<GuestBook> queryByPageList(int pageSize,int pageNumber);

}

 

 

package com.oracle.biz.impl;

 

import java.util.List;

 

import com.oracle.biz.GuestBookBiz;

import com.oracle.dao.GuestBookDao;

import com.oracle.dao.impl.GuestBookDaoImpl;

import com.oracle.model.GuestBook;

import com.oracle.util.Pagination;

 

public class GuestBookBizImpl implementsGuestBookBiz {

       privateGuestBookDao guestBookDao = new GuestBookDaoImpl();

       @Override

       publicGuestBook addGuestBook(GuestBook guestBook) {

              return guestBookDao.save(guestBook);

       }

 

       @Override

       publicList<GuestBook> getAllGuestBooks() {

              return guestBookDao.findAll();

       }

 

       @Override

       publicPagination<GuestBook> queryByPageList(int pageSize, int pageNumber) {

              return guestBookDao.queryByPageList(pageNumber,pageSize);

       }

 

}

 

 

package com.oracle.action;

 

import java.io.IOException;

 

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

importjavax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

 

import com.oracle.biz.GuestBookBiz;

importcom.oracle.biz.impl.GuestBookBizImpl;

import com.oracle.model.GuestBook;

import com.oracle.util.Pagination;

 

public class GuestBookAction extendsHttpServlet {

       privateGuestBookBiz guestBookBiz = new GuestBookBizImpl();

       publicfinal static int PAGESIZE = 6;

       publicvoid doGet(HttpServletRequest request, HttpServletResponse response)

                     throwsServletException, IOException {

              String page =request.getParameter("p");

              int pageNumber = 1;

              if(page!=null){

                     pageNumber= Integer.parseInt(page);

              }

              Pagination<GuestBook> pagination =guestBookBiz.queryByPageList(PAGESIZE,                                                                              pageNumber);

              request.getSession().setAttribute("pagination",pagination);

              request.getRequestDispatcher("pageList.jsp").forward(request,response);

             

       }

 

       publicvoid doPost(HttpServletRequest request, HttpServletResponse response)

                     throwsServletException, IOException {

              doGet(request, response);

       }

 

}

 

 

package com.oracle.util;

 

import java.util.List;

 

public class Pagination<T> {

       privateint pageSize = 6; //每页的记录数

       privateint pageNumber = 1; //页码

       privateint maxElements;       //总记录数

       privateList<T> pageList; //每页的元素集合

       privateint offset;    //偏移量

 

       publicPagination() {}

 

       publicPagination(int maxElements) {

              this.maxElements = maxElements;

       }

 

       publicPagination(int pageSize, int pageNumber, int maxElements) {

              this.pageSize = pageSize;

              this.maxElements = maxElements;

              this.pageNumber = pageNumber;

       }

 

       publicint getPageNumber() {

              return pageNumber;

       }

 

       publicvoid setPageNumber(int pageNumber) {

              //计算总页数

              int total = (int) Math.ceil(maxElements /pageSize);

              //如果当前页码大于总页数

              if (pageNumber > total) {

                     this.pageNumber= total;

              } else if (pageNumber <= 1) {

                     pageNumber= 1;

              } else {

                     this.pageNumber= pageNumber;

              }

       }

 

       publicvoid setMaxElments(int maxElements) {

              this.maxElements = maxElements;

       }

 

       publicint getMaxElements() {

              return maxElements;

       }

 

       publicint getOffset() {

              return offset;

       }

 

       publicvoid setOffset(int offset) {

              if (offset <= 0) {

                     this.offset= 0;

              } else if (offset > maxElements) {

                     this.offset= maxElements - 1;

              } else {

                     this.offset= offset;

              }

       }

 

       publicint getPageSize() {

              return pageSize;

       }

 

       publicList<T> getPageList() {

              return pageList;

       }

 

       publicvoid setPageList(List<T> pageList) {

              this.pageList = pageList;

       }

}

 

 

 

package com.oracle.test;

 

import java.text.SimpleDateFormat;

import java.util.List;

 

import org.hibernate.Criteria;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.criterion.Criterion;

import org.hibernate.criterion.Order;

importorg.hibernate.criterion.Restrictions;

 

import com.oracle.model.GuestBook;

import com.oracle.util.SessionFactoryUtils;

 

public class TestGuestBookCriteria {

       publicstatic void main(String[] args) {

              // testCriteria();

              //testCriteriaByExpression();

              testCriteriaPager();

       }

 

       privatestatic void testCriteria() {

              SessionFactory sessionFactory =SessionFactoryUtils

                            .createSessionFactory();

              Session session =sessionFactory.getCurrentSession();

              session.beginTransaction();

              // 创建Criteria对象

              Criteria criteria =session.createCriteria(GuestBook.class);

              // 通过查询返回一个集合

              List<GuestBook> guestBooks =criteria.list();

              // 遍历集合中的数据

              for (GuestBook gb : guestBooks) {

                     System.out.println(gb.getTitle());

              }

              session.getTransaction().commit();

       }

 

       privatestatic void testCriteriaByExpression() {

              SessionFactory sessionFactory =SessionFactoryUtils

                            .createSessionFactory();

              Session session =sessionFactory.getCurrentSession();

              session.beginTransaction();

              // 创建Criteria对象

              Criteria criteria =session.createCriteria(GuestBook.class);

              // 创建查询条件对象

              Criterion criterion = null;

              criterion =Restrictions.eq("ip", "192.168.1.168");

              // 添加条件

              criteria.add(criterion);

              // 再添加筛选条件

              criteria.add(Restrictions.like("title","学习H%"));

 

              // 通过查询返回一个集合

              List<GuestBook> guestBooks =criteria.list();

              // 遍历集合中的数据

              for (GuestBook gb : guestBooks) {

                     System.out.println(gb.getTitle());

              }

              session.getTransaction().commit();

       }

 

       privatestatic void testCriteriaPager() {

              SessionFactory sessionFactory =SessionFactoryUtils

                            .createSessionFactory();

              Session session =sessionFactory.getCurrentSession();

              session.beginTransaction();

              // 创建Criteria对象

              Criteria criteria =session.createCriteria(GuestBook.class);

              int pageSize = 5;// 每页的记录数

              int pageIndex = 3;// 页码

              // 设置每页记录的起始索引从0开始

              criteria.setFirstResult((pageIndex-1)*pageSize);

              // 设置每页显示的记录数

              criteria.setMaxResults(pageSize);

             

              //添加排序表达式 :根据时间子程序

              criteria.addOrder(Order.desc("createTime"));

             

              // 通过查询返回该页的数据集合

              List<GuestBook> guestBooks =criteria.list();

              SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");

              // 遍历集合中的数据

              for (GuestBook gb : guestBooks) {

                     System.out.println(gb.getTitle()+"\t"+sdf.format(gb.getCreateTime()));

              }

 

              session.getTransaction().commit();

       }

}

 

 

<%@ page language="java"import="java.util.*" pageEncoding="UTF-8"%>

<%@ tagliburi="http://jsptags.com/tags/navigation/pager" prefix="pg"%>

<%@ tagliburi="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTDHTML 4.01 Transitional//EN">

<html>

<head>

 

<title>My JSP 'pageList.jsp' startingpage</title>

 

</head>

 

<body>

       <tableborder="1px" width="700px">

              <tr>

                     <th>编号</th>

                     <th>标题</th>

                     <th>留言时间</th>

                     <th>操作</th>

              </tr>             

              <c:forEachitems="${pagination.pageList }" var="guestBook" >

                     <tr>

                            <td>${guestBook.id }</td>

                            <td>${guestBook.title }</td>

                            <td>${guestBook.createTime}</td>

                            <td><ahref="viewGuestBook.action?id=${guestBook.id }">查看</a>

                                   <ahref="delGuestBook.action?id=${guestBook.id }">删除</a></td>

                     </tr>

              </c:forEach>

       </table>

       <!--分页的链接,开始-->

       <pg:pagerid="pagination" url="guestBook.do"

              items="${pagination.maxElements}"

              maxPageItems="${pagination.pageSize}"maxIndexPages="10">

              <pg:index>

                     <pg:prev>

                            <ahref="${pageUrl}&p=${pageNumber}">&lt;上一页</a>

                     </pg:prev>

                     <pg:pages>

                            <ahref="${pageUrl}&p=${pageNumber}">${pageNumber}</a>

                     </pg:pages>

                     <pg:next>

                            <ahref="${pageUrl}&p=${pageNumber}">下一页&gt;</a>

                     </pg:next>

              </pg:index>

       </pg:pager>

       <!--分页的链接,结束-->

</body>

</html>

 

导入以下包：

DoNotStop
关注
专栏目录
guestbook.zip
05-13
javaweb中guestbook留言本项目的代码。 主要有用户的增删改查功能，还有servlet技术的应用
基于Java spring MVC框架 开发初步 ——以做一个留言板为例
zccst的专栏
12-21 1万+
Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE
Java --- Servlet中的过滤器Filter
__静禅__
12-13 637
  转载：源文件请查看：https://www.cnblogs.com/zlbx/p/4888312.html       Filter，过滤器，顾名思义，即是对数据等的过滤，预处理过程。为什么要引入过滤器呢？在平常访问网站的时候，有时候发一些敏感的信息，发出后显示时 就会将敏感信息用*等字符替代，这就是用过滤器对信息进行了处理。这只是一个简单的例子，当然，过滤器那么强大，它的功能也不可能局...
JDBC中 DAO＜T＞的设计和优化遇见问题我的解决方法
mua_qiang的博客
04-01 740
让人头疼的代码Type type = this.getClass().getGenericSuperclass(); ParameterizedType parameterizedType = (ParameterizedType) type; Type[] types = parameterizedType.getActualTypeArguments();
java servlet filter_Servlet之Filter详细讲解
weixin_39759890的博客
02-24 694
Filter，过滤器，顾名思义，即是对数据等的过滤，预处理过程。为什么要引入过滤器呢？在平常访问网站的时候，有时候发一些敏感的信息，发出后显示时 就会将敏感信息用*等字符替代，这就是用过滤器对信息进行了处理。这只是一个简单的例子，当然，过滤器那么强大，它的功能也不可能局限于此，它不仅能预处 理数据，只要是发送过来的请求它都是可以预处理的，同时，它还可以对服务器返回的响应进行预处理，这样，大大减轻了...
泛型dao
03-27
在Java编程语言中，"泛型DAO"（Generic DAO）是一种设计模式，它允许开发者创建可重用的数据访问对象（DAOs），以处理多种不同类型的实体对象，而无需为每种对象编写单独的DAO实现。这种方法提高了代码的复用性和可...
Hibernate泛型Dao
10-18
【标题】"Hibernate泛型Dao"是针对Java开发中的数据持久化框架Hibernate的一个高级应用，主要目的是为了提高代码的复用性和简洁性。在传统的Hibernate使用中，针对每个实体类，我们都需要创建一个对应的Dao（Data ...
JdbcTemplate通用泛型Dao实现
08-09
本文将深入探讨`JdbcTemplate`通用泛型Dao实现的相关知识点，帮助开发者更好地理解和应用这一技术。 首先，让我们了解什么是`JdbcTemplate`。它是Spring框架的一部分，用于处理SQL操作。`JdbcTemplate`提供了一组...
java泛型T.class的获取
热门推荐
ykdsg的专栏
04-11 9万+
   很早之前写过利用泛型和反射机制抽象DAO ，对其中获取子类泛型的class一直不是很理解。关键的地方是HibernateBaseDao的构造方法中的Type genType = getClass().getGenericSuperclass(); Type[] params = ((ParameterizedType) genType).getActualTypeArguments(
GenericHibernateDao
chris
07-08 137
编写Spring+Hibernate框架下的应用，总是离不了编写一个通用的泛型GenericHibernateDao。查阅了网上不少的GenericHibernateDao实现，归纳整理为如下实现，供后续编码参考。 GenericDao.java: [code="java"] package dao; import java.io.Serializable; import jav...
三种方式实现二维码（java）
WuTing的专栏
08-02 1万+
使用zxing，qrcode，js插件方式实现二维码的创建和读写
使用 Velocity 模板引擎快速生成代码
WuTing的专栏
06-21 4254
Velocity 模板引擎介绍 在现今的软件开发过程中，软件开发人员将更多的精力投入在了重复的相似劳动中。特别是在如今特别流行的 MVC 架构模式中，软件各个层次的功能更加独立，同时代码的相似度也更加高。所以我们需要寻找一种来减少软件开发人员重复劳动的方法，让程序员将更多的精力放在业务逻辑以及其他更加具有创造力的工作上。Velocity 这个模板引擎就可以在一定程度上解决这个问题。 Veloci
模板语言语法
WuTing的专栏
06-21 447
一、变量 和我们所熟知的其他编程语言一样，Velocity 也可以在模板文件中有变量的概念。 1. 变量定义 #set($name =“velocity”) 等号后面的字符串 Velocity 引擎将重新解析，例如出现以$开始的字符串时，将做变量的替换。 #set($hello =“hello $name”) 上面的这个等式将会给$hello 赋值为“hello velocity” 2
跨域请求解决方案
WuTing的专栏
10-20 411
什么是跨域？ 跨域，指的是浏览器不能执行其他网站的脚本。它是由浏览器的同源策略造成的，是浏览器对javascript施加的安全限制。跨域的形式：域名不同，协议不同（http,https）解决方法： 1、前端跨域请求 2、后端处理跨域请求@PropertySource("classpath:crossdomain.properties") @Component @Order(Integer.MI
飞思卡尔智能车平台，基于 python+CNN实现识别道路图像类型，图像处理计算轨迹线
最新发布
11-06
【作品名称】：飞思卡尔智能车平台，基于 python+CNN实现识别道路图像类型，图像处理计算轨迹线 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：飞思卡尔智能车平台，CNN识别道路图像类型，图像处理计算轨迹线 飞思卡尔智能车平台，基于 python+CNN实现识别道路图像类型，图像处理计算轨迹线 飞思卡尔智能车平台，基于 python+CNN实现识别道路图像类型，图像处理计算轨迹线 【资源声明】：本资源作为“参考资料”而不是“定制需求”，代码只能作为参考，不能完全复制照搬。需要有一定的基础看懂代码，自行调试代码并解决报错，能自行添加功能修改代码。
计算机图形学之动画和模拟算法：Procedural Animation：布料模拟算法.docx
11-06
计算机图形学之动画和模拟算法：Procedural Animation：布料模拟算法.docx
毕设项目：基于Node+VUE后台管理系统
11-06
毕设项目：基于Node+VUE后台管理系统 element-vue-node-mysql
Spring+Hibernate框架下泛型DAO实现与使用
"这篇文档详细介绍了在Spring+Hibernate框架下如何使用Hibernate泛型DAO，以提高代码的可重用性和可维护性。作者通过查阅多种实现方式，汇总了一个通用的泛型DAO接口`GenericDao`的实现，方便开发人员进行后续的编码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值