正文

hibernate下的增删改查

hx1098  2022-04-09  647

关键词：

概述：

关系--对象映射的中间件，属于开源ORM框架，是我们业务逻辑层中的调用数据库的中间件

演变：

jdbc---hibernater---mybatis

hibernate和mybatis区别？

1：hiberanter学习的难度要比mybatis要大，复杂度要高
2：hibernate不需要写sql语句，自动生成，而mybatis需要写sql语句进行数据操作
3：hibernate支持分页(API)，而mybatis不支持分页(那是属于插件)
4：hibernate支持事务处理，而mybaits不支持事务处理(Spring)
5：hibernate支持一级缓存、二级缓存和查询缓存，而mybaits本身没有缓存（加载第三方缓存技术）

环境搭建步骤：

1：导包

  <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.3.3.Final</version>
    </dependency>


2：加载配置文件hibernate.cfg.xml（数据库连接信息）
3：需要增加映射文件(写的不是sql语句，写的是实体entity和表table中的字段、类型对应关系)

数据库工具类：

public class HibernateUitls {

    public static Session getSession() {
        // 获取数据库的连接工厂
        // 从工厂中获取连接session
        Configuration config = new Configuration();
        config.configure("hibernate.cfg.xml");
        SessionFactory sf = config.buildSessionFactory();// 获取工厂
        Session session = sf.openSession();
        return session;
    }
}

增删改查操作

/**
 * 测试hibernate增删改查
* @author lisi
* @date 2018年8月20日
 */
public class HibernateTest {


    /**
     * 查询操作---读操作
     */
    @Test
    public void query(){

        Session session = HibernateUitls.getSession();
        Note note = session.get(Note.class, 63);//根据主键查询
        if (note != null) {
            System.out.println(note.getContext());
        }
    }

    /**
     * 增加---写操作
     */
    @Test
    public void save(){
        Session session = HibernateUitls.getSession();

        Note note = new Note();
        note.setId(3000);
        note.setContext("java20增加测试数1");
        note.setLikeCount(10);
        note.setUserId(1);
        note.setPublishTime(new Date(System.currentTimeMillis()));

        Transaction ts = session.beginTransaction();//开启事务处理

        session.save(note);//保存数据
        ts.commit();//提交事物--
        session.close();//关闭连接 
    }


    /**
     * 修改数据
     */
    @Test
    public void update(){

        Session session = HibernateUitls.getSession();

//      Note note = new Note();
        Note note = session.get(Note.class, 3000);
        //note.setId(3000);
        note.setContext("java20增加测试数2");
        Transaction ts = session.beginTransaction();//开启事务处理
        session.update(note);
        ts.commit();//提交事物--
        session.close();//关闭连接 

    }

    /**
     * 删除操作
     *  1：先查询数据是否存在
     *  2：如果存在，则删除，不存在，则不执行delete
     *  3：hibernate做的安全设置
     */
    @Test
    public void delete(){

        Session session = HibernateUitls.getSession();

        Note note = new Note();
        note.setId(3000);
        Transaction ts = session.beginTransaction();//开启事务处理
        session.delete(note);
        ts.commit();//提交事物--
        session.close();//关闭连接 
    }

}

Hibernate主键管理

策略生成的位置配置：

<id name="id" type="integer" column="id">
    <generator class="identity"></generator>
</id>

1.sequence 序列

主要用于oracle数据库

2.identity 主键自增

主要用于mysql、SqlServer
主键自增

3.native

自动识别当前数据库的类型
如果数据库为oracle，则默认的ID生成策略为sequence
如果数据库为mysql等，则默认的ID生成策略为identity

4.increment

代表当前数据库表的主键ID，查询数据库ID最大值+1

5.uuid/hilo

采用UUID和hilo的算法，生成一个字符串，当成主键ID

6.assigned

是hibernate默认的主键生成策略，增加set方法

Hibernate查询操作

SQL：面向结构的查询 Structured Query Language（结构化）

select * from note 或者 SELECT * FROM NOTE
HQL：面向对象的查询 hibernater query language（对象化）

select userid（实体类中的属性名称） from Note（实体类名）

HQL和SQL区别？

- HQL是面向对象的查询，SQL是面向结构化的查询
- HQL查询时候对查询属性大小写比较敏感，SQL在查询的时候对属性的大小写依赖于我们的配置
- HQL支持count、sum、avg等，但是HQL不支持类型转换，比如日期转换、字符串转换
- HQL不建议使用left join，而SQL可以无条件的使用
- HQL在做查询的时候，如果是查询所有字段信息，则可以省略select *,直接使用from  实体类名
- HQL在查询的时候，使用的是类名和属性名，SQL查询的时候，使用的表名和字段名
- HQL和SQL在使用上，或者处理业务上，HQL只能进行简单操作，SQL可以进行复杂操作

结构化：

HQL查询

普通查询

1：查询所有的数据

2：根据条件进行查询

3：分页条件

4：统计个数

代码如下：

/**
 * hibernate普通查询
* @author lisi
* @date 2018年8月21日
 */
public class HQLTest {


    /**
     * 查询所有的数据
     */
    @Test
    public void query(){
        Session session = HibernateUitls.getSession();
        String hql = "from Note";
        Query query = session.createQuery(hql);
        List<Note> list = query.list();//获取查询结果集
        //list.isEmpty()    只会判断list中的数据是否为空
        //list != null && list.size() > 0  判断的是对象list是否存在，并且判断list中是否有数据
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getContext());
            }
        }
    }

    /**
     * 根据条件查询
     *  select * from note where userId = 3
     */
    @Test
    public void test2(){
        Session session = HibernateUitls.getSession();

        //jpa-style
        //String hql = "from Note where userId=?0";//?代表占位符,占位符下标是从0开始
        String hql = "from Note where userId = :userid";
        Query query = session.createQuery(hql);
//      query.setInteger(0, 3);
//      query.setParameter(0, 3);
        query.setParameter("userid", 3);

        List<Note> list = query.list();//获取查询结果集
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getContext());
            }
        }
    }

    /**
     * 分页查询
     * 
     *  select * from note limit 0,3;
     */
    @Test
    public void test3(){
        Session session = HibernateUitls.getSession();
        String hql = "from Note";

        Query query = session.createQuery(hql);

        query.setFirstResult(1);//分页条件limit的第一个参数,下标是从0开始
        query.setMaxResults(3);//分页条件limit的第二个参数，代表需要查询的条数

        List<Note> list = query.list();//获取查询结果集
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getId());
            }
        }
    }


    /**
     * 统计个数
     *  select count(1) from note
     */
    @Test
    public void test4(){
        Session session = HibernateUitls.getSession();
        String hql = "select count(0) from Note";
        Query query = session.createQuery(hql);
        Long count = (Long) query.uniqueResult();
        System.out.println("统计个数为：" + count);
    }
}

Criteria查询

多条件查询、可以根据实体类属性的字段、排序、分组、分页、统计个数、and、or等

示例代码：

/**
 * 多条件查询
* @author likang
* @date 2018年8月21日
 */
public class CriteriaTest {


    /**
     * select * from note;
     */
    @Test
    public void test1(){
        Session session = HibernateUitls.getSession();
        Criteria criteria = session.createCriteria(Note.class);
        List<Note> list = criteria.list();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getContext());
            }
        }
    }

    /**
     * select * from note where userId = 3;
     * select * from note where userId = 2 and id = 2005;
     * select * from note where userId = 2 or id = 2005;
     * select * from note where userId = 2 or id = 2005 order by id desc/asc;
     */
    @Test
    public void test2(){
        Session session = HibernateUitls.getSession();
        Criteria criteria = session.createCriteria(Note.class);
//      criteria.add(Restrictions.eq("userId", 2));
//      criteria.add(Restrictions.eq("id", 2005));
        criteria.add(Restrictions.or(Restrictions.eq("userId", 2), Restrictions.eq("id", 2005)));
//      criteria.addOrder(Order.desc("id"));
        criteria.addOrder(Order.asc("id"));

        List<Note> list = criteria.list();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getContext());
            }
        }
    }

    /**
     * hibernate5新特性写法：
     *  select * from note where userId = 3;
     */
    @Test
    public void test3(){
        Session session = HibernateUitls.getSession();
        CriteriaBuilder crb = session.getCriteriaBuilder();
        CriteriaQuery<Note> criteria = crb.createQuery(Note.class);
        Root<Note> root = criteria.from(Note.class);
        criteria.where(crb.equal(root.get("userId"), 1));
        Query<Note> query = session.createQuery(criteria);
        List<Note> list = query.list();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getContext());
            }
        }
    }
}

NativeSQL查询

原生查询、支持sql语句的查询

示例代码：

/**
 * 原生sql语句查询
* @author lisi
* @date 2018年8月21日
 */
public class NativeSQLTest {


    @Test
    public void test1(){
        Session session = HibernateUitls.getSession();
        String sql = "select * from note";
//      SQLQuery query = session.createSQLQuery(sql);
//      List<Object[]> list = query.list();
//      if (list != null && list.size() > 0) {
//          for (Object[] obj : list) {
//              System.out.println(obj[1]);
//          }
//      }

        SQLQuery query = session.createSQLQuery(sql);
        query.addEntity(Note.class);//在进行遍历之前，提前进行数据映射转换
        List<Note> list = query.list();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getContext());
            }
        }
    }


    /**
     * hibernate5新特性写法：
     */
    @Test
    public void test2(){
        Session session = HibernateUitls.getSession();
        String sql = "select * from note where userId = 3";
        NativeQuery query = session.createNativeQuery(sql);

        query.addEntity(Note.class);//在进行遍历之前，提前进行数据映射转换
        List<Note> list = query.list();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println("内容为：" + list.get(i).getContext());
            }
        }
    }

}

Hibernate注解应用

类上面注解：

@Entity
@Table(name="note")

方法属性注解：

@Id
@Column(name="数据库中字段主键")
@GeneratedValue(generator="identity")
private int id;//主键


其它字段：

    @Column(name="数据库中字段名称")

修改hibernate.cfg.xml配置文件：

<mapping class="com.xdl.entity.Note"/>

Hibernate特性

延迟加载

hibernate中的API，有一些是具有延迟加载的特性，对象在调用的时候，才会进行数据加载(什么时候调用，什么时候加载)

get、list方法，不具有延迟加载特性
load、find方法，具有延迟加载特性

问题：

    ...... no session

问题请求：

接口请求--->web.xml--->action--->service--->dao(session关闭)--->view

解决：

接口请求--->web.xml--->action--->service--->dao(session不关闭)--->view--->关闭session(事务spring)

缓存（性能优化）

缓存：对象在第一次使用的时候，是进行数据加载(需要查询数据库)，下一次查询同样条件的数据，则直接从缓存中获取，而并发查询数据库(速度快、减轻数据库服务器压力)

一级缓存

自动开启，不需要做任何的配置和修改特点： session独享
二级缓存

特定： session共享
查询缓存

持久化（session）

临时状态

可以被JVM进行垃圾回收
持久化状态

不能更直接被JVM回收，可以先变成其它两种状态之后，才会进行垃圾回收
游离状态

可以被JVM进行垃圾回收

技术分享图片

Spring+Hibernate整合

整合结构：

技术分享图片

整合步骤：

1：导包
    hibernate-core
2：导入spring包

3：加载spring和hibernate配置文件

4：在spring的配置文件中，增加数据库的连接信息和事务管理

5：将原来的工程进行改造---jdbc实现类注释，增加一个hibernate实现类

6：实现接口方法

7：部署、启动、访问

核心代码：

applicationContext.xml:

<!-- 加载hibernateTemplate -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <!-- 加载sessionFacotory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="c3p0"></property>
        <property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
    </bean>

    <!-- 处理事务 -->
    <bean id="txManger" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 事务支持注解驱动 -->
    <!-- proxy-target-class:属性默认为false，则代表是使用jdk本身的代理(静态代理)
        true:则代表使用的是cglib代理(动态代理模式)
     -->
    <tx:annotation-driven transaction-manager="txManger" proxy-target-class="true"/>



HibernateServiceImpl.java:

 @Repository
    public class HibernateServiceImpl implements INoteService{

        @Resource
        private HibernateTemplate hibernateTemplate;

        @Override
        public List<Note> queryNoteList(int userid) {
            DetachedCriteria dCriteria = DetachedCriteria.forClass(Note.class);
            dCriteria.add(Restrictions.eq("userId", userid));
            List<Note> list = (List<Note>) hibernateTemplate.findByCriteria(dCriteria);
            String hql = "from Note where userId=:userId";
            List<Note> list1 = (List<Note>) hibernateTemplate.findByNamedParam(hql, "userId", userid);
            return list1;
        }

        @Override
        public int deleteNotesById(int id) {
            Note note = hibernateTemplate.get(Note.class, id);
            if (note != null) {
                hibernateTemplate.delete(note);
                return 1;
            }
            return 0;
        }
    }


如果有删除操作,需要在删除的action的类头上加上标注,将只读模式关闭
@Transactional(readOnly=false)//将只读模式进行关闭
DeleteAction.java:

hibernate的增删改查操作

接上一章节HQL的预编译语句 HIbernate中的预编译与Spring的预编译的处理差不多。 1：使用标准的? 　2：使用命名参数　　 2.1：使用名称逐个设置。　　2.2：使用Map(key的值等于参数的名称) ... 查看详情

框架[hibernate]利用hibernate进行单表的增删改查-web实例

...15本文源自【大学之旅_谙忆的博客】前面两篇博客已经将Hibernate的基础知识讲解得差不多了，差不多到写实例的时候了。本篇只用hibernate进行单表的增删改查、应用Hibernate，对students表进行增删改查。service层和DAO层，我都是直接... 查看详情

hibernate--单表的增删改查

语法：如果利用Hibernate修改数据库时，需要使用事务处理，一个事务提交时才真正将修改过的记录更新到数据库中。1、增加记录Sessionsession=HibernateSessionFactory.getSession();Transactiontran=session.beginTransaction();//定义事... 查看详情

hibernateorm框架——续第一章：java增删改查与hibernate的增删改查的对比

一、1）项目结构 2）SQLserver2008数据库的编写createdatabaseEmpuseEmpcreatetableemp(enovarchar(10),enamevarchar(50),salaryfloat)insertintoempvalues(‘1‘,‘zss1‘,2000);insertintoempvalues(‘2‘,‘zss2‘,2000);updateemp 查看详情

hibernateorm框架——续第一章：hibernate的增删改查（第一个hibernate代码的优化）

一：.项目结构二、代码1）HibernateUtilpackageutil;importorg.hibernate.SessionFactory;importorg.hibernate.boot.MetadataSources;importorg.hibernate.boot.registry.StandardServiceRegistry;importorg.hibernate.bo 查看详情

hibernate和jsp做数据库单表的增删改查

虽然很基础，但是我转牛角尖了~~~~这是几个文件1.最重要的。Java文件1packagecom.chinasofti.hibb.struts;234importorg.hibernate.Session;5importorg.hibernate.SessionFactory;6importorg.hibernate.Transaction;7importorg.hibernate.cfg.Con 查看详情

hibernate5-简单的增删改查

1.创建项目,项目名称hibernatedemo1,目录结构如图所示650)this.width=650;"src="https://s3.51cto.com/wyfs02/M00/8F/48/wKioL1jaCszg_DWFAAAqpX-CQts379.png-wh_500x0-wm_3-wmp_4-s_2762162931.png"title="QQ截图20170328150252.png"a 查看详情

初识hibernate框架之一：进行简单的增删改查操作

Hibernate的优势l 优秀的Java持久化层解决方案（DAO）l 主流的对象—关系映射工具产品l 简化了JDBC繁琐的编码l 将数据库的连接信息都存放在配置文件l 自己的ORM框架l 一定要手动实现Hibernate（模拟Hibern... 查看详情

hibernate基于maven和struts2搭建的增删改查

...入相应jar包三、选中entity模块，右键AddFrameworkSupport,找到hibernate确认四、配置一个数据库五、建立并配置hibernate.cfg.xml信息六、用hibernate创建实体对象七、在util模块编写hibernateUtil类，在dao模块调用Util和实体创建查看详情

双向多对一关系的增删改查

Person类：package com.bjsxt.hibernate;import java.util.List;import javax.persistence.CascadeType;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import&n 查看详情

struts2+spring+hibernate实现员工管理增删改查功能之ssh框架整合

前言转载请标明出处：http://www.cnblogs.com/smfx1314/p/7795837.html本项目是我写的一个练习，目的是回顾ssh框架的整合以及使用。项目介绍：此项目主要有前台管理员通过登录进入员工管理系统页面，之后可以对员工... 查看详情

idea+maven+ssm框架实现的简单的增删改查

...可以与Spring框架无缝整合的特性收到了越来越多的欢迎。Hibernate框架在面对需要存储过程或者复杂SQL时显得力不从心，不能提供高效的数据库控制。而Mybat 查看详情

java：oracle（table的增删改查，data的增删改查）

1、oracle命名规范：和Java的命名规范很像1.严格区分大小写2.所有的sql语句都要以‘;‘结尾3.所有的sql都要使用空格区分:sqlplus空格/空格as空格sysdba回车4.无论是表名还是列名都必须以字母开头java中的class必须要以大写字母开头，... 查看详情

hibernate的增删改操作

6.CUD操作工具类 public class ConfigUtil { public static SessionFactory sessionFactory; & 查看详情

spring和hibernate基础的增删改

所有的dao层可以有个superDao比如：BaseHibernateDao继承的类是hibernate4publicclassBaseHibernateDaoextendsHibernateDaoSupport{　　@Resource(name="jsbcTemplate")　　protectedJdbcTemlatejdbcTemplate;　　@Resource(name="sessionF 查看详情

orm的增删改查

字段的增删改查 orm增加字段phone=models.CharField(max_length=64,default=‘120‘)后来添加的字段需要设置默认值orm删除字段注释掉字段,执行数据库迁移命令(慎重)修改字段直接修改字段,执行数据库迁移命令记录的增删改查单表查询res=... 查看详情

datagrid的增删改查前台页面

公共js:前台页面：查看详情

jstree的增删改查

ajax请求数据：$("#rolesJsTree").jstree({"core":{"check_callback":true,//默认为flase，回导致api无法正常使用。‘data‘:{‘url‘:‘/Sys/Role/GetRoleJosn‘,‘dataType‘:‘json‘,}},"plugins":["dnd"]}); 判断节点选中：varref=$(‘#rolesJsT 查看详情