0
0

Hibernate基本使用

Hibrenate框架
一、Hibrenate
1、是一个持久层框架，实现jdbc的封装。是一个全自动的ORM框架
2、ORM：对象 关系(数据库表) 映射，orm致力于将数据库操作转换成Java程序熟悉的对象操作。
3、ORM主要体现在两个方面
a、java程序通过jdbc与数据库程序交互；类似于 请求—响应
b、orm在请求时，由java程序向数据库传递sql时，通过操作的对象 对于操作表，通过操作的对象属性 对应 操作的表字段
c、orm在响应是，一般就是查询操作，且返回结果，将ResultSet集合中装载的查询组装成对应的实体对象；根据查询时指定的对象，组装成与之对应的对象；根据表字段与对象属性名对应的关系实现数据赋值
二：全自动与半自动
1、 全自动orm:
a) 在请求和响应过程中，都是用orm机制自动进行处理的
2、 半自动orm
a) 在请求过程中，操作对此与对应的表的关系，依然需要使用手动编写的sql实现
b) 在响应过程中，将查询结果自动组成对象

三：hibernate基本使用
1、创建maven程序
2、引入hibernate 和mysql依赖

<dependency><groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>5.1.4.Final</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.29</version></dependency>

3、创建hibernate.cfg.xml文件

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPEhibernate-configurationPUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!-- 第一部分： 配置数据库信息 必须的 --><propertyname="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property><propertyname="hibernate.connection.url">jdbc:mysql:///hibernate_day01</property><propertyname="hibernate.connection.username">root</property><propertyname="hibernate.connection.password">root</property><!-- 第二部分： 配置hibernate信息 可选的--><!-- 输出底层sql语句 --><propertyname="hibernate.show_sql">true</property><!-- 输出底层sql语句格式 --><propertyname="hibernate.format_sql">true</property><!-- hibernate帮创建表，需要配置之后 update: 如果已经有表，更新，如果没有，创建 --><propertyname="hibernate.hbm2ddl.auto">update</property><!-- 配置数据库方言在mysql里面实现分页 关键字 limit，只能使用mysql里面在oracle数据库，实现分页rownum 让hibernate框架识别不同数据库的自己特有的语句 --><propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property><!--第三部分:把映射文件放到核心配置文件中必须的--><mappingresource="cn/itcast/entity/Car.hbm.xmL"/></session-factory></hibernate-configuration>

4、使用框架
4.1、创建实体类

packagecom.hibernate;importjavax.persistence.criteria.CriteriaBuilder;importjava.io.Serializable;/**
 * @author pgg
 * @date 2022/4/6
 */publicclassCarimplementsSerializable{privateInteger cid;privateString cname;privateString color;publicCar(){}publicCar(Integer cid,String cname,String color){this.cid = cid;this.cname = cname;this.color = color;}publicIntegergetCid(){return cid;}publicvoidsetCid(Integer cid){this.cid = cid;}publicStringgetCname(){return cname;}publicvoidsetCname(String cname){this.cname = cname;}publicStringgetColor(){return color;}publicvoidsetColor(String color){this.color = color;}}

4.2、自定义orm配置文件

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping><classname="com.hibernate.Car"table="t_car"><idname="cid"column="cid"></id><propertyname="cname"column="cname"/><propertyname="color"column="color"/></class></hibernate-mapping>

4.3、编写dao,使用hibernate实现语句库的交互
4.3.1、hiberante有一个Session对象，该对象提供了CRUD方法
4.3.1.1、每一个session对象内置connection连接
4.3.1.2、session.save/update/delete/get()…
4.3.2、hibernate有一个sessionFactory对象，创建session对象：sessionFactory.openSession()
4.3.3、hibernate有一个Configuration对象，创建sessionFactory对象

第一步 加载hibernate核心配置文件

第二步 创建SessionFactory对象

第三步 使用SessionFactory创建session对象

第四步 开启事务

第五步 写具体逻辑 crud操作

第六步 提交事务

第七步 关闭资源

    @TestpublicvoidtestAdd(){//        第一步 加载hibernate核心配置文件// 到src下面找到名称是hibernate.cfg.xml//在hibernate里面封装对象Configuration cfg =newConfiguration();
        cfg.configure();//        第二步 创建SessionFactory对象//读取hibernate核心配置文件内容，创建sessionFactory//在过程中，根据映射关系，在配置数据库里面把表创建SessionFactory sessionFactory = cfg.buildSessionFactory();//        第三步 使用SessionFactory创建session对象// 类似于连接Session session = sessionFactory.openSession();//        第四步 开启事务Transaction tx = session.beginTransaction();//        第五步 写具体逻辑 crud操作//添加功能User user =newUser();
        user.setUsername("小王");
        user.setPassword("250");
        user.setAddress("日本");//调用session的方法实现添加
        session.save(user);//        第六步 提交事务
        tx.commit();//        第七步 关闭资源
        session.close();
        sessionFactory.close();}

四：hibernate操作对象状态
瞬时态：刚刚创建的对象属于瞬时态，在jvm中存在，在数据库和session对象中部存在
持久态：jvm中存在，数据库中存在，session缓存中存在，操作jvm中对象，就会通过session，自动更新数据库中的数据
save()、update() 是将瞬时态对象 转换成持久态
get() 直接获取一个持久态
注意：delete 删除的对象必须是持久态，删除后属于瞬时态
游离态：jvm中存在，数据库中存在，session缓存中不存在
session.close()、session.clear()

五：hibernate的crud
1、hiberante有一个Session对象，该对象提供了CRUD方法,其直接提供的方法只能实现但记录的CRUD

一：session提供的单条记录的查询

  1. session.get()/session.load()
  2. session.get(类名.class,id)： 根据主键值，查找单条记录，通过类名.class对象类型，找到对应的orm,从而找到操作的表；id值即为orm配置时字段的值 如：
packagecom.hibernate.dao;importcom.hibernate.domain.Car;importcom.hibernate.util.HibernateUtil;importorg.hibernate.Session;publicclassCarDao{publicvoidfind1(){Session session=HibernateUtil.getSession();Car car=session.get(Car.class,1);System.out.println(car.getCname());}publicvoidfind2(){Session session=HibernateUtil.getSession();Car car=session.load(Car.class,1);System.out.println(car);}}

六：get和load的特点
懒加载：懒加载不是不加载，只加载id主键，当需要使用数据再通过id去与数据库交互查询
相同点：都是根据主键查找单条记录
不同点：
get方法会从数据库直接获取数据对象，如果没有数据，返回null
load方法会先获得一个代理对象，再需要使用数据时再从数据库中获取数据（懒加载），如果数据不存在，则在获取时抛出异常
load方法查询时，默认是懒加载查询，可以通过设置，关闭懒加载（2中方式）
方式一：在orm文件中通过懒加载属性关闭

<hibernate-mapping><class name="com.hibernate.domain.Car" table="t_car"  lazy="false"><id name="cid" column="cid"></id><property name="cname" column="cname"/><property name="color" column="color"/></class></hibernate-mapping>

方式二：将实体类Car，使用final关键字修饰
load方法懒加载的体现是先获得代理，然后需要数据时代理再查数据；代理实现有两种方式：1、基于父类 2、实现接口 确保代理对象与目标实体对象有相同的api(方法)，final修饰的类不能被继承，即不能产生代理，即关闭懒加载

publicfinalclassCarimplementsSerializable{privateInteger cid;privateString cname;privateString color;publicCar(){}}

关闭懒加载后，数据存在，直接获得数据对象，数据不存在，依然会抛出异常
七：hibernate增删改查操作
注意：增删改时需要开启事务，提交事务
1、保存：session.save(对象);

/**
     * 保存
     */publicvoidsave1(){Car car=newCar(1,"bm3","蓝色");Session session=HibernateUtil.getSession();
        session.beginTransaction();//开始事务
        session.save(car);
        session.getTransaction().commit();//提交事务}

2、修改：session.update(对象)；
扩展：对于持久态对象，修改对象就相当于修改数据，而不需要执行修改方法

/**
     *修改的方法
     */publicvoidupdate1(){Car car=newCar(1,"bm2","白色");Session session=HibernateUtil.getSession();
        session.beginTransaction();//开始事务
        session.update(car);
        session.getTransaction().commit();//提交事务}/**
     * 扩展修改的方法 只针对持久态对象
     */publicvoidupdate(){Session session=HibernateUtil.getSession();Car car=session.get(Car.class,1);//持久态
        car.setColor("红色");
        session.beginTransaction();//开始事务
        session.getTransaction().commit();//提交事务}

3.删除：session.delete(对象)；不能通过主键删除
尽管从删除逻辑而言，通过主键数据就可以删除整体记录，但Hibernate对数据库的操作都是一对象的操作体现的，所以删除时也必须删除对象（1、对象可以只包含主键 2、对象必须时持久态才能删除）

/**
     * 方式一：删除操作
     */publicvoiddelete1(){Session session=HibernateUtil.getSession();Car car=newCar();
        car.setCid(1);
        session.beginTransaction();//开始事务
        session.delete(car);
        session.getTransaction().commit();//提交事务}/**
     * 方式二：删除操作
     */publicvoiddelete2(){Session session=HibernateUtil.getSession();Car car=newCar();
        car.setCid(1);
        session.beginTransaction();//开始事务
        session.delete(car);
        session.getTransaction().commit();//提交事务}/**
     * 方式三：删除操作
     */publicvoiddelete3()throwsInterruptedException{Session session=HibernateUtil.getSession();Car car=newCar(1,"bmw","red");
        session.beginTransaction();//开始事务
        session.save(car);
        session.getTransaction().commit();//提交事务Thread.sleep(20000);
        session.beginTransaction();//开始事务
        session.delete(car);
        session.getTransaction().commit();//提交事务}

4、扩展：
保存或修改：session.saveOrUpdate(对象)；先根据主键值做查询，数据存在执行修改，数据不存在，执行保存

/**
     * 保存或修改
     */publicvoidsaveOrUpdate1(){Session session=HibernateUtil.getSession();Car car=newCar(1,"bmw","blue");
        session.beginTransaction();//开始事务
        session.saveOrUpdate(car);
        session.getTransaction().commit();//提交事务}

5、扩展
保存或修改：session.merge(对象) ；先根据主键值做查询，数据存在执行修改，数据不存在，执行保存

/**
     * 保存或修改
     */publicvoidmerge(){Session session=HibernateUtil.getSession();Car car=newCar(1,"bmw","blue");
        session.beginTransaction();//开始事务
        session.merge(car);
        session.getTransaction().commit();//提交事务}

saveOrUpdate和merge区别：
1、区别体现再修改时，
2、无论哪个方法实现修改，都可以将瞬时态对象转换成持久态对象，如果再session缓存中，之前已经存在了一个相同的id的持久态对象，那么saveOrUpdate方法会抛出异常（有两个不同的对象却有相同的id）,但是merge方法会修改成功，因为merge会将两个相同的对象数据合并
merge修改的对象并没有变成持久态，而是将对象的数据覆盖到原持久态对象中

扩展：保存时的主键生成机制
只需要在orm配置文件中，使用id的子标签《generator》标签指定生成机制
HIbernate提供了多种主键生成机制，常用的有：
1、uuid varchar主键 32位16进制唯一数
2、identity 一般时mysql等 int类型的主键 自增，需要在建表时也设置主键自增
3、sequence 是oracle int类型的主键，序列自增，因为Oracle的序列是一个独立的数据库对象，拥有自己的名字，所以在设置sequence序列生成机制时需要通过传递指定序列的名，如果没有传递，则默认使用hibernate_sequence名字的 序列
4、foregin 一对一关联时，有关联表外键值充当主键值
5、assigned 默认 手动提供主键值
6、native:使用当前数据库默认支持的主键生成方式，如果是mysql则相当于identity,如果是Oracle,则相当于是sequence

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping><classname="com.hibernate.domain.Book"table="t_book"lazy="false"><idname="bno"column="bno"><!--指定主键生成机制--><generatorclass="uuid"></generator></id><propertyname="bname"column="bname"/><propertyname="author"column="author"/></class></hibernate-mapping>

注意：使用主键生成机制时，save方法执行保存后，会以返回值的形式将生成的主键返回

标签： hibernate
本文转载自: https://blog.csdn.net/qq_45429856/article/details/123997078
版权归原作者 程序员小庞 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Hibernate基本使用”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航