仅一行代码完成各种数据库操作，基于spring的HibernateTemplate

最新推荐文章于 2024-11-01 14:31:36 发布
最新推荐文章于 2024-11-01 14:31:36 发布
阅读量424 收藏
点赞数
分类专栏： SQL Hibernate 文章标签： mysql Hibernate

1. [代码][Java]代码

import  java.sql.SQLException;
import  java.util.ArrayList;
import  java.util.Collection;
import  java.util.List;
import  java.util.Map;
 
import  org.hibernate.Criteria;
import  org.hibernate.HibernateException;
import  org.hibernate.Query;
import  org.hibernate.Session;
import  org.hibernate.criterion.MatchMode;
import  org.hibernate.criterion.Projections;
import  org.hibernate.criterion.Property;
import  org.springframework.orm.hibernate3.HibernateCallback;
import  org.springframework.orm.hibernate3.HibernateTemplate;
 
public  class  BaseHibernate {
     private  static  HibernateTemplate hibernateTemplate;
 
     @SuppressWarnings ( "static-access" )
     public  void  setHibernateTemplate(HibernateTemplate hibernateTemplate) {
         this .hibernateTemplate = hibernateTemplate;
     }
 
     /**
      * 插入对象
      *
      * @param entity
      * @return
      */
     public  int  save(Object entity) {
         return  (Integer) hibernateTemplate.save(entity);
     }
 
     /**
      * 删除对象
      *
      * @param entity
      */
     public  void  delete(Object entity) {
         hibernateTemplate.delete(entity);
     }
 
     /**
      * 修改对象
      *
      * @param entity
      */
     public  void  update(Object entity) {
         hibernateTemplate.update(entity);
     }
 
     /**
      * 根据ID查询对象
      *
      * @param entityClass
      *            类名,如:String.class
      * @param id
      *            ID值
      */
     public  <T> T query(Class<T> entityClass,  int  id) {
         return  hibernateTemplate.get(entityClass, id);
     }
 
     /**
      * 查询全部
      *
      * @param className
      *            类名
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  <T> List<T> queryAll(Class<?> className) {
         return  hibernateTemplate.find( "from "  + className.getName());
     }
 
     /**
      * 分页
      *
      * @param entityClass
      *            类名
      * @param index
      *            当前页数
      * @param size
      *            每页显示的大小
      * @param order
      *            排序类型
      * @param propertyName
      *            要排序的属性名
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  <T> List<T> paging( final  Class<?> entityClass,  final  int  index,
             final  int  size,  final  Order order,  final  String... propertyName) {
         List<T> list = hibernateTemplate.executeFind( new  HibernateCallback() {
             public  Object doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 Criteria criteria = session.createCriteria(entityClass);
                 if  (propertyName !=  null  && propertyName.length >  0 ) {
                     switch  (order) {
                     case  ASC:
                         criteria.addOrder(org.hibernate.criterion.Order
                                 .asc(propertyName[ 0 ]));
                         break ;
                     case  DESC:
                         criteria.addOrder(org.hibernate.criterion.Order
                                 .desc(propertyName[ 0 ]));
                         break ;
                     }
                 }
                 criteria.setFirstResult((index -  1 ) * size);
                 criteria.setMaxResults(size);
                 return  criteria.list();
             }
         });
         return  list;
     }
 
     @SuppressWarnings ( "unchecked" )
     public  long  getSumRecord( final  Class<?> className) {
         List<Long> count =  new  ArrayList<Long>();
         count = hibernateTemplate.find( "select COUNT(*) from "
                 + className.getName());
         return  count.size() >  0  ? (count.get( 0 )) : 0L;
     }
 
     /**
      * 获取总页数
      *
      * @param className
      *            类名
      * @param size
      *            每页显示的大小
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  long  sumPage( final  Class<?> className,  int  size) {
         List<Long> count =  new  ArrayList<Long>();
         count = hibernateTemplate.find( "select COUNT(*) from "
                 + className.getName());
         return  count.size() >  0  ? (count.get( 0 ) -  1  + size) / size : 0L;
     }
 
     /**
      * 根据字段查询
      *
      * @param params
      *            字段列表
      * @param values
      *            值列表
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  <T> List<T> queryByProperty( final  Class<?> className,
             final  Map<String, Object> params) {
         return  hibernateTemplate.executeFind( new  HibernateCallback() {
             public  List<?> doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 Criteria criteria = session.createCriteria(className);
                 for  (String field : params.keySet())
                     criteria.add(Property.forName(field).eq(params.get(field)));
                 return  criteria.list();
             }
         });
     }
 
     /**
      * 根据字段查询可以分的页数
      *
      * @param className
      *            要查询的实体类
      * @param params
      *            属性列表
      * @param size
      *            每页显示的大小
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  long  queryByPropertyGetSumPage( final  Class<?> className,
             final  Map<String, Object> params,  final  int  size) {
         List<Integer> object = hibernateTemplate
                 .executeFind( new  HibernateCallback() {
                     public  Object doInHibernate(Session session)
                             throws  HibernateException, SQLException {
                         Criteria criteria = session.createCriteria(className);
                         for  (String field : params.keySet())
                             criteria.add(Property.forName(field).eq(
                                     params.get(field)));
                         criteria.setProjection(Projections.rowCount());
                         return  criteria.list();
                     }
                 });
         int  count = object ==  null  ?  0  : object.get( 0 );
         return  count >  0  ? (count + size -  1 ) / size : 0L;
     }
 
     /**
      * 获取总记录数根据属性
      *
      * @param className
      * @param params
      * @param size
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  long  queryByPropertyGetSumRecord( final  Class<?> className,
             final  Map<String, Object> params) {
         List<Integer> object = hibernateTemplate
                 .executeFind( new  HibernateCallback() {
                     public  Object doInHibernate(Session session)
                             throws  HibernateException, SQLException {
                         Criteria criteria = session.createCriteria(className);
                         for  (String field : params.keySet())
                             criteria.add(Property.forName(field).eq(
                                     params.get(field)));
                         criteria.setProjection(Projections.rowCount());
                         return  criteria.list();
                     }
                 });
         return  object ==  null  ?  0  : object.get( 0 );
     }
 
     /**
      * 根据字段查询并分页显示
      *
      * @param className
      *            要分页的实体类
      * @param params
      *            字段列表
      * @param index
      *            当前页
      * @param size
      *            每页显示的大小
      * @param order
      *            排序
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  <T> List<T> queryByPropertyPaging( final  Class<?> className,
             final  Map<String, Object> params,  final  int  index,  final  int  size,
             final  Order order,  final  String... field) {
         return  hibernateTemplate.executeFind( new  HibernateCallback() {
             public  List<?> doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 Criteria criteria = session.createCriteria(className);
                 for  (String f : params.keySet())
                     criteria.add(Property.forName(f).eq(params.get(f)));
                 if  (field !=  null  && field.length !=  0 ) {
                     switch  (order) {
                     case  ASC:
                         criteria.addOrder(org.hibernate.criterion.Order
                                 .asc(field[ 0 ]));
                         break ;
                     case  DESC:
                         criteria.addOrder(org.hibernate.criterion.Order
                                 .desc(field[ 0 ]));
                         break ;
                     }
                 }
                 criteria.setFirstResult((index -  1 ) * size);
                 criteria.setMaxResults(size);
                 return  criteria.list();
             }
         });
     }
 
     /**
      * 保存或更新对象
      *
      * @param entity
      *            对象
      */
     public  void  saveOrUpdate(Object entity) {
         hibernateTemplate.saveOrUpdate(entity);
     }
 
     /**
      * 批量修改
      *
      * @param queryString
      *            HQL语句
      * @return 受影响行数
      */
     public  int  bulkUpdate(String queryString) {
         return  hibernateTemplate.bulkUpdate(queryString);
     }
 
     /**
      * 批量修改
      *
      * @param queryString
      *            HQL语句
      * @param values
      *            参数的值
      * @return 受影响行数
      */
     public  int  bulkUpdate(String queryString, Object... values) {
         return  hibernateTemplate.bulkUpdate(queryString, values);
     }
 
     /**
      * 批量删除
      *
      * @param collection
      *            要删除的集合
      */
     public  void  deleteAll(Collection<?> collection) {
         hibernateTemplate.deleteAll(collection);
     }
 
     /**
      * 模糊查询
      *
      * @param className
      *            类名
      * @param field
      *            字段名
      * @param value
      *            值
      * @param matchMode
      *            匹配模式:ANYWHERE->任意位置、END->结束、START->开始、EXACT->精确匹配
      */
     @SuppressWarnings ( "unchecked" )
     public  <T> List<T> Querylike( final  Class<?> className,  final  String field,
             final  String value,  final  MatchMode matchMode) {
         List objects =  new  ArrayList<Object>();
         objects = hibernateTemplate.executeFind( new  HibernateCallback() {
             public  Object doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 Criteria criteria = session.createCriteria(className);
                 criteria.add(Property.forName(field).like(value, matchMode));
                 return  criteria.list();
             }
         });
         return  objects;
     }
 
     /**
      * 执行hql查询语句
      *
      * @param hql
      *            hql语句
      * @param values
      *            值列表
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  <T> Object executeQuery( final  String hql,  final  Object... values) {
         return  hibernateTemplate.execute( new  HibernateCallback() {
 
             public  Object doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 Query query = session.createQuery(hql);
                 setParams(query, values);
                 return  query.list();
             }
         });
     }
 
     /**
      * 查询单个值
      *
      * @param hql
      *            hql语句
      * @param values
      *            参数列表
      * @return 返回单个值
      */
     @SuppressWarnings ( "unchecked" )
     public  <T> Object executeSacale( final  String hql,  final  Object... values) {
         return  hibernateTemplate.execute( new  HibernateCallback() {
             public  Object doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 Query query = session.createQuery(hql);
                 setParams(query, values);
                 query.setMaxResults( 1 );
                 return  query.uniqueResult();
             }
         });
     }
 
     /**
      * 执行hql删除、修改语句
      *
      * @param hql
      *            hql语句
      * @param values
      *            值列表
      * @return
      */
     @SuppressWarnings ( "unchecked" )
     public  int  executNonQuery( final  String hql,  final  Object... values) {
         return  hibernateTemplate.execute( new  HibernateCallback() {
             public  Integer doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 Query query = session.createQuery(hql);
                 setParams(query, values);
                 return  query.executeUpdate();
             }
         });
     }
 
     /**
      * 删除表数据
      * @param tableName 表名
      */
     
     @SuppressWarnings ( "unchecked" )
     public  void  truncate( final  String tableName) {
         hibernateTemplate.execute( new  HibernateCallback() {
             public  Object doInHibernate(Session session)
                     throws  HibernateException, SQLException {
                 session.createSQLQuery( "truncate table "  + tableName).executeUpdate();
                 return  new  ArrayList();
             }
         });
 
     }
 
     private  void  setParams(Query query, Object... values) {
         if  (!isEmptyOrNull(values)) {
             for  ( int  i =  0 ; i < values.length; i++) {
                 query.setParameter(i, values[i]);
             }
 
         }
     }
 
     /**
      * 判断值是否为空或
      *
      * @param values
      * @return
      */
     private  boolean  isEmptyOrNull(Object... values) {
         if  (values ==  null  || values.length ==  0 )
             return  true ;
         return  false ;
     }
 
}

2. [代码]排序类型

 
/**
  * 排序类型
  * @author cheng
  *
  */
public  enum  Order {
     /**
      * 升序排列
      */
     ASC,
     /**
      * 降序排列
      */
     DESC;

3. [代码]实例应用

public  interface  UsersDao{ 
          /**
      * 根据属性查询
      * @param attrName 属性名
      * @param attrValues 属性值
      * @return Users集合
      */
     public  List<Users> queryByProperty(Map<String, Object> propertys);
}
//UserDaoImpl
 
import  java.util.List;
import  java.util.Map;
 
import  org.ps.dao.UsersDao;
import  org.ps.entity.Users;
import  org.ps.util.BaseHibernate;
import  org.ps.util.Order;
 
public  class  UserDaoImpl  extends  BaseHibernate  implements  UsersDao {
 
public  List<Users> queryByProperty(Map<String, Object> propertys) {
         return  super .queryByProperty(Users. class , propertys);
     }
}
我为bug代言
关注
专栏目录
HibernateTemplate.execute(HibernateCallback action)回调方式
07-08 7103
今天在做codereview的时候，发现同事用了以下方法返回一个list。看了后台日志之后，很是奇怪，为什么只有一条sql，后台却打出了101条select。 /** * 根据练习加载试题 * 每次练习考试，有多条试题questionBank * 如果试题questionBank是选择题，又会对应4个选项questionOptions。 * 因此questionBank对象中有一个questionOptions集合，他们的关系是一对多 * @param pmId 练习ID
数据库分页sql和hibernatetemplate分页操作
zlc521520的博客
05-11 356
MySQL -- 从10行开始，查询20行；即查询10~30行的数据 select * from table limit 10,20 Oracle select * from (select a.*,rownum rc from 表名 where rownum&lt;=endrow) a where a.rc&gt;=startrow 上面的rownum开始为啥是 小于 而不...
HibernateTemplate灵活方法来完成数据库操作
frost131314的专栏
03-21 593
Hibernate的复杂用法HibernateCallback HibernateTemplate还提供一种更加灵活的方式来操作数据库，通过这种方式可以完全使用Hibernate的操作方式。 HibernateTemplate的灵活访问方式是通过如下两个方法完成：  （1）Object execute(HibernateCallback action)  （2）List execute(H
mybatis中@Param用法注意事项
热门推荐
showgood119的专栏
12-01 1万+
背景：    DAO中定义了一个方法为：List getAllPeople(@Param("vo") SearchVo vo,@Param("id")String id) ；    service层调用这个方法是：  peopleDao.getAllPeople(ViewSearchVo vo,String id) ；    其中ViewSearchVo 是searchVo 的子类，而且 a
mybatis Map<String,Object>params 传参 0 与 判断条件 ！='' 问题
bei_fang_du_lang的专栏
01-18 6350
最近刚刚接触mybatis，遇到一个坑，记录一下。在调用mybatis的sqlSession对象传递参数，且参数类型为Map时，map.put('condition1',0)——情形1map.put('condition1','0')——情形2在配置文件中，test="condition1 != '' ">情形1下返回结果为false，即 0 与 '' 相等情形2下返回结果为true，即'0'与'
一行代码完成HibernateTemplate各种数据库操作
血公子的专栏
12-26 9673
import java.sql.SQLException; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map; import org.hibernate.Criteria; import org.hibernate.HibernateExcept
Spring Framework 学习笔记(5) Spring 和 JDBC 操作数据库
张云飞Vir的专栏
07-08 191
1. 背景 JDBC 是基础的操作数据库的方式，在开发中要写“打开数据库，建立PrepareStatement, 遍历并读取字段绑定到对象”等很多行的“样板代码”，Spring 的一个重要思想是“使用模板消除样板代码”。 2.知识 Spring将数据访问过程中固定的和可变的部分明确划分为两个不同的类：模板(template)和 回调(callback)。模板管理过程中固定的部分，而回调处理自定义...
【Spring学习笔记】—— （四）数据库操作模板 JdbcTemplate
小牛肉的博客
03-18 404
系列博客： 【Spring学习笔记】—— （一）Spring框架概述 + 基于XML的IoC配置 【Spring学习笔记】—— （二）基于注解的IoC 【Spring学习笔记】—— （三）AOP 【Spring学习笔记】—— （四）数据库操作模板 JdbcTemplate 文章目录1. JdbcTemplate 概述2. 基本使用3. IoC 配置 Spring 内置数据源4. Jdbc...
Spring 访问数据库
qq_44336097的博客
04-27 823
数据库基本上是现代应用程序的标准存储，绝大多数程序都把自己的业务数据存储在关系数据库中，可见，访问数据库几乎是所有应用程序必备能力。 我们在前面已经介绍了Java程序访问数据库的标准接口JDBC，它的实现方式非常简洁，即：Java标准库定义接口，各数据库厂商以“驱动”的形式实现接口。应用程序要使用哪个数据库，就把该数据库厂商的驱动以jar包形式引入进来，同时自身仅使用JDBC接口，编译期并不需要特定厂商的驱动。 使用JDBC虽然简单，但代码比较繁琐。Spring为了简化数据库访问，主要做了以下几点工作：
同一个数据库实例，不同用户下多表创建视图，Hibernate完成ORM映射，Spring整合，后台实现
loverain90的专栏
07-23 3310
同一个数据库实例，不同用户下多表创建视图，Hibernate完成ORM映射，Spring整合，后台实现 1、同一个数据库实例，同用户，多表创建视图 2、同一个数据库实例，不同用户下，多表创建视图 3、同一个数据库，不同数据库实例，多表创建视图 4、不同类型数据库，多表创建视图 1、同一个数据库实例，同用户，多表创建视图暂缺！！ 2、同一个数据库实例，不同用户下，多表创建视图步骤一、创建实例，创建两个
深入理解Spring Redis的使用 (一) Spring Redis基本使用
weixin_57907028的博客
08-10 7841
关于spring redis框架的使用，网上的例子很多很多。但是在自己最近一段时间的使用中，发现这些教程都是入门教程，包括很多的使用方法，与spring redis丰富的api大相径庭，真是浪费了这么优秀的一个框架。这里，我们就对比之前对spring orm中对hibernate的使用，来理解使用spring redis的使用。（本文章不做redis基本命令使用的讲解） 1. Redis使用场景 Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库
spring-boot入门（四）与数据库交互
lan墨的博客
01-07 4124
spring-boot入门（四）与数据库交互 前面几章已经介绍了如何与页面交互，这章将介绍如何与数据库进行交互 1. 配置数据源 这里为了方便使用tomcat数据源，后面会讲解其它数据源的配置。在application.yml里面添加如下代码： spring: datasource: url: jdbc:mysql://localhost:3306/db_order?u
Spring测试Hibernate执行update方法之后数据库未更新的原因
weixin_41641941的博客
06-17 2684
昨天在写Dao层之后进行测试，用Junit执行session.save()方法的时候可以持久化到数据库，但是测试执行session.update()的时候却显示执行成功但是数据库却没有变化，网上的回答说是事务没有开启，但我的Hibernate事务都是交给Spring来管理的 <!-- 事务配置 声明式事务 --> <bean id="transactionManager" ...
spring的15个经典面试题
javalingyu的博客
04-24 6415
总结Spring框架的15个经典面试题。 什么是Spring框架？ Spring是一种轻量级框架，旨在提高开发人员的开发效率以及系统的可维护性。 我们一般说的Spring框架就是Spring Framework，它是很多模块的集合，使用这些模块可以很方便地协助我们进行开发。这些模块是核心容器、数据访问/集成、Web、AOP（面向切面编程）、工具、消息和测试模块。比如Core Container中的Core组件是Spring所有组件的核心，Beans组件和Context组件是实现IOC和DI的基础，AO
mysql到doris的DDL整库转换工具
fengjian的博客
11-01 446
适用于常规的mysql-ddl到doris-ddl的整库转换，附全部代码
【重学 MySQL】七十九、深入探索用户变量
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
10-30 905
定义：用户变量以“@”符号开头，后面跟着变量名。变量名可以是任何随机的、复合的标量表达式，只要其中没有列指定。赋值可以使用SET语句来定义和赋值用户变量，如。也可以使用SELECT语句来为用户变量赋值，但必须使用“:=”赋值运算符，因为在SELECT语句中，MySQL将“=”运算符视为等于运算符。例如，。作用域：会话用户变量的作用域是当前会话，而局部变量的作用域是其定义的BEGIN/END语句块。命名：会话用户变量以“@”符号开头，而局部变量不需要。使用场景。
easy-es使用以及Es和MySQL同步
weixin_51918722的博客
10-31 524
它主要就是简化了ES相关的API, 使用起来像MP一样舒服。
【MySql】第五章（存储函数与存储过程）习题
最新发布
她是不会无条件的！！
11-01 550
【MySql】第五章（存储函数与存储过程）习题
mysql 8.0.39 Caused by: java.sql.SQLException: Illegal mix of collations 异常解决
LFCuiYs的博客
10-30 416
发现设置utf8mb3_general_ci 会报错，所以要与参数一直 改成utf8mb4_general_ci 即可生效。java服务可以正常启动，页面发现查询报错Illegal mix of collations。经查看发现是关联表排序异常，因是mysql 8.0.39。然后定位异常 调成一直参数问题解决。
Spring HibernateTemplate事务操作实践与误区解析
在Spring框架中，HibernateTemplate是一个用于简化与Hibernate ORM集成的工具类，它封装了Hibernate的Session对象，提供了一种更加面向切面的方式来管理数据操作。然而，当涉及到事务管理时，直接使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值