重量级ORM框架--持久化框架Hibernate【关系映射详解】

已于 2022-08-09 10:42:09 修改
阅读量310 收藏
点赞数
文章标签： hibernate java 后端
于 2022-08-09 10:16:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmklo/article/details/126207544
版权

hibernate

Hibernate是一款重量级的持久层框架，目前市面上的我很少见还有项目在开发时候使用他，之所以要学习这个，因为公司最近有一个系统升级的项目，之前的老系统用到了Hibernate。

在这里插入图片描述

同样还是老套路，学习一个新技术或者新知识，首先去他的官网看

【官网】：https://hibernate.org/orm/
【官方教程】：https://hibernate.org/orm/documentation/getting-started/
【github地址】：https://github.com/hibernate

目前hibernate已经更新到了6的版本，这里使用的5的版本

在这里插入图片描述

注意： Hibernate5.1；5.2官方推荐使用JDK1.8以及JDBC4

文章目录

一、generator主键策略

在这里插入图片描述
generator配置：代表hibernate主键生成策略

【我们可以将其分为三大类】：

  1. 由数据库维护
    • identity：Mysql的auto_increment维护主键自增策略
    • sequence：Oracle使用sequence序列维护主键自增策略
    • native ：本地策略，由hibernate自己根据数据库选择最优策略
  2. 由hibernate维护
    • uuid：生成32位16进制的无效字符串【记住是一个字串】
    • increment：生成递增的数值类型（每次先查当前的最大的id值+1）
  3. 由开发者维护
    • asigned：必须要有程序员给定id的值，否则报错

二、对象关系映射：一对多映射

需求案例：客户 与 订单的需求关系：典型的一对多的关系

2.1 测试准备

这里我们需要在创建一张表t_order

CREATE TABLE `t_order` (
	`id` INT(10) NOT NULL AUTO_INCREMENT,
	`order_no` VARCHAR(20) NULL DEFAULT NULL COMMENT '订单编号' COLLATE 'utf8mb4_general_ci',
	`product_name` VARCHAR(20) NULL DEFAULT NULL COMMENT '产品名称' COLLATE 'utf8mb4_general_ci',
	`cust_id` INT(10) NULL DEFAULT NULL,
	PRIMARY KEY (`id`) USING BTREE,
	UNIQUE INDEX `t_order_id_uindex` (`id`) USING BTREE,
	INDEX `t_order_t_customer_c_id_fk` (`cust_id`) USING BTREE,
	CONSTRAINT `t_order_t_customer_c_id_fk` FOREIGN KEY (`cust_id`) REFERENCES `hibernate_db`.`t_customer` (`c_id`) ON UPDATE NO ACTION ON DELETE NO ACTION
)
COLLATE='utf8mb4_general_ci'
ENGINE=InnoDB
AUTO_INCREMENT=2;

2.2 创建实体

注意事项：

  1. 需要在Custom实体中先给一个List<Order>来关联多方的实体信息

  2. order实体表也需要给一个Custom的JavaBean对其进行关联

在这里插入图片描述

【Order】

public class Order implements Serializable {
    private static final long serialVersionUID = 1L;

    private String id; // 订单表主键
    private String orderNo; // 订单编号
    private String prodName; // 产品名称

    private Integer custId; // 外键客户id

    /*一个订单对一个客户，一个客户对多个订单*/
    private Customer customer;
}

2.3 hbm.xml文件修改

【customer.hbm.xml】
在Custom.hbm.xml文件里，我们需要做的是将order进行关联用set标签

<class name="com.wei.domain.Customer" table="t_customer">
        <id name="id" column="c_id">
            <generator class="identity"></generator>
        </id>
        <property name="name" column="c_name"></property>
        <property name="age" column="c_age"></property>
        <property name="gender" column="c_gender"></property>
        <property name="level" column="c_level"></property>

        <!--一对多配置-->
        <!--name设置本实体类(customer)关联的属性字段名-->
        <set name="orders" >
            <!--外键的字段名称-->
            <key column="cust_id"></key>
			<!--关联的实体对象的完整类路径-->
            <one-to-many class="com.wei.domain.Order"/>
        </set>
    </class>

一表中的关联配置使用的标签是：<one-to-many class="所关联的类的全类名"></on-to-mony>

【order.hbm.xml】

<class name="com.wei.domain.Order" table="t_order">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="orderNo" column="order_no"/>
        <property name="prodName" column="product_name"/>

        <!--多对一配置-->
        <many-to-one name="customer" column="cust_id" class="com.wei.domain.Customer"></many-to-one>
    </class>

多表中所关联的字段是用的标签是<many-to-one name="关联的本实体类在的字段名" column="外键字段" class=“所引用的实体类的全类名”></many-to-one>

2.4 编写测试类

    @Test
    public void test1() throws HibernateException {
        // 准备数据
        /*
        * 需求：一个客户两个订单
        * */
        Customer lisi  = new Customer();
        lisi.setName("里斯");
        lisi.setGender("1");
        lisi.setAge(32);
        lisi.setLevel("至尊VIP，年卡8级");
        
        Set<Order> orders = new HashSet<>();
        // 订单1
        Order order1 = new Order();
        order1.setOrderNo("20220807111");
        order1.setProdName("小米Ultr11");
        order1.setCustomer(lisi);
        // 订单2
        Order order2 = new Order();
        order2.setOrderNo("20220807134");
        order2.setProdName("华为MateBook_Pro 512G+8G");
        order2.setCustomer(lisi);
        // 客户添加订单
        orders.add(order1);
        orders.add(order2);
        lisi.setOrders(orders);
        
        Session session = HibernateUtil.getConnection();
        //4、开启事务
        Transaction tx = session.beginTransaction();
        //5、执行添加操作
        session.save(lisi);
        session.save(order1);
        session.save(order2);
        //6、提交事务
        tx.commit();
        //7、关闭资源
        HibernateUtil.closeSession(session);
    }

【订单表】
在这里插入图片描述
【客户表】
在这里插入图片描述

为了可以证实是否插入成功，我么可以再写一个方法来查询某一个客户的订单

/**
     * 查询用户guan连查询其所的订单
     *
     * @throws HibernateException
     */
    @Test
    public void test2() throws HibernateException {

        Session session = HibernateUtil.getConnection();
        //4、开启事务
        Transaction tx = session.beginTransaction();
        //5、执行添加操作
        Customer customer = session.get(Customer.class, 5);
        System.out.println("用户名称："+customer.getName());
        Set<Order> orders = customer.getOrders();
        for (Order order : orders) {
            System.out.println("订单："+order.getOrderNo());
        }
        //6、提交事务
        tx.commit();
        //7、关闭资源
        HibernateUtil.closeSession(session);
    }

在这里插入图片描述

三、casecode和inverse配置

3.1 CaseCade级联操作

级联操作，就是操作一个对象的时候，相同时操作他的关联对象。

  • 级联保存
<set name="orders" cascade="save-update">
     <!--外键的字段名称-->
     <key column="cust_id"></key>
     <one-to-many class="com.wei.domain.Order"/>
</set>

【测试】

@Test
    public void test3() throws HibernateException {
        // 准备数据
        Customer lisi = new Customer();
        lisi.setName("马云云");
        lisi.setGender("1");
        lisi.setAge(34);
        lisi.setLevel("至尊VIP，年卡n级");

        Set<Order> orders = new HashSet<>();
        // 订单1
        Order order1 = new Order();
        order1.setOrderNo("20220808123");
        order1.setProdName("阿里巴巴");
        order1.setCustomer(lisi);
        // 订单2
        Order order2 = new Order();
        order2.setOrderNo("20220808141");
        order2.setProdName("华强北 只能IPHONE watch");
        order2.setCustomer(lisi);
        // 客户添加订单
        orders.add(order1);
        orders.add(order2);
        lisi.setOrders(orders);

        Session session = HibernateUtil.getConnection();
        //4、开启事务
        Transaction tx = session.beginTransaction();
        //5、执行添加操作
        session.save(lisi); // 保存客户
        // 级联保存订单数据，所以配置在客户的映射文件中
        //6、提交事务
        tx.commit();
        //7、关闭资源
        HibernateUtil.closeSession(session);
    }

在这里插入图片描述

  • 级联删除
<set name="orders" cascade="save-update,delete" >
     <!--外键的字段名称-->
     <key column="cust_id"></key>
     <one-to-many class="com.wei.domain.Order"/>
</set>

【测试】

 @Test
    public void test4() throws HibernateException {

        Session session = HibernateUtil.getConnection();
        //4、开启事务
        Transaction tx = session.beginTransaction();
        //5、执行添加操作
        Customer cus = session.get(Customer.class, 6);// 级联删除
        //6、提交事务
        session.delete(cus);
        tx.commit();
        //7、关闭资源
        HibernateUtil.closeSession(session);
    }

在这里插入图片描述

如果没有级联删除，则会把外键的值置为空。级联删除则会在删除一个对象的同时将其关联的的对象也删除。

【实现级联操作的注意事项】：🔥🔥🔥

  1. 搞清楚谁级联操作谁？添加A的时候，级联添加B,那么级联操作的就是B，配置就在A

  2. 级联操作的核心是cascade="级联操作的属性"

    • save-update：级联保存
    • delete：级联删除
    • all：级联保存和删除

3.2 INVERSE反转配置

第一次听到这个概念让我想起了Spring的IOC

inverse配置：表示是否把关联表的维护权反转（放弃）

  • true：放弃
  • false：不放弃（不反转）

这里我们可以看一下级联保存的的时候，wmendeHibernate会自动地有两条SQL帮助我们去维护被关联的表
在这里插入图片描述
在这里插入图片描述
结论：
通常在一对多的关联关系中，多方不能放弃维护权，建议放弃一方，意味着需要在一方加上inverse=true的配置

四、对象关系映射：多对多映射

需求：用户 与 角色的关联关系：多对多的关系

4.1 多对多插入操作

4.1.1 数据库设计

在这里插入图片描述

4.1.2 对象设计

【User表】

public class User implements Serializable {

    private Integer id;
    private String name;
	// getter、setter...
 }

【Role表】

public class Role implements Serializable {

    private Integer id;
    private String name;
	// getter、setter...
 }

4.1.3 映射的配置🔥🔥

【Role.hbm.xml】

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wei.domain.Role" table="t_role">
        <id name="id" column="id"/>
        <property name="name" column="name"/>
        <!--多对多配置-->
        <!--
            table；配中间表的名字
        -->
        <set name="users" table="t_user_role" inverse="true">
            <!--当前表中间表的外键-->
            <key column="role_id"/>
            <!--class关联表的类名，column为对方关联的表在中间表的外键-->
            <many-to-many class="com.wei.domain.User" column="user_id"/>
        </set>
      </class>

</hibernate-mapping>

【User.hbm.xml】

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wei.domain.User" table="t_user">
        <id name="id" column="id"/>
        <property name="name" column="name"/>
        <!--多对多配置-->
        <!--
            table；配中间表的名字
        -->
        <set name="roles" table="t_user_role">
            <!--当前表中间表的外键-->
            <key column="user_id"/>
            <!--class关联表的类名，column为对方关联的表在中间表的外键-->
            <many-to-many class="com.wei.domain.Role" column="role_id"/>
        </set>
      </class>

</hibernate-mapping>

注意事项：

  1. 在配置任意一方的set集合关联字段的时候，我们知道hibernate是默认inverse=false的，这样一来在多对多的关系中，就会出现重复的维护冲突,所以我们需要在任意一方设置inverse=true
  2. 这里建议使用MySQL5的版本，因为hibernate创建表的时候会将存储引擎设置为myisam，如果使用了Mysql8的版本，需要在全局的核心配置文件中设置上
    <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>，否则会报SQL语法错误
  3. 在任意一方配置是都不能配置主键策略，否则无法关联外键的关联关系
  <!-- <property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property> -->
<property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

在这里插入图片描述

4.2 多对多查询

@Test
    public void test6() throws HibernateException {
        // 准备数据

        Session session = HibernateUtil.getConnection();
        //4、开启事务
        Transaction tx = session.beginTransaction();
        //5、执行添加操作
        User user = session.get(User.class, 1);
        System.out.println("当前用户："+user.getName());
        Set<Role> roles1 = user.getRoles();
        for (Role role : roles1) {
            System.out.println("当前用户的角色："+role.getName());
        }

        User user2 = session.get(User.class, 2);
        System.out.println("当前用户："+user2.getName());
        Set<Role> roles = user2.getRoles();
        for (Role role : roles) {
            System.out.println("当前用户的角色："+role.getName());
        }
        //6、提交事务
        tx.commit();
        //7、关闭资源
        HibernateUtil.closeSession(session);
    }

在这里插入图片描述

4.3 多对多级联添加操作

User.hbm.xml配置

<set name="roles" table="t_user_role" cascade="save-update">
     <!--当前表中间表的外键-->
     <key column="user_id"/>
     <!--class关联表的类名，column为对方关联的表在中间表的外键-->
     <many-to-many class="com.wei.domain.Role" column="role_id"/>
</set>

注意事项：
1.级联操作就是在任意一方设置casecade=级联配置—> 比如级联保存是save-update

 @Test
    public void test7() throws HibernateException {
        // 准备数据

        Session session = HibernateUtil.getConnection();
        //4、开启事务
        Transaction tx = session.beginTransaction();
        //5、执行添加操作
        User user1 = new User();
        user1.setId(3);
        user1.setName("大公鸡");
        Role r1 = new Role();
        r1.setName("五星红钻");
        r1.setId(3);
        Set<Role> roles = new HashSet<>();
        roles.add(r1);
        user1.setRoles(roles);
        
        session.save(user1);
        //6、提交事务
        tx.commit();
        //7、关闭资源
        HibernateUtil.closeSession(session);
    }

不过通常我更偏向于使用all 包括了级联保存和删除

五、对象关系映射：一对一映射

需求：中华人民共和国公民 与 个人身份证 是典型的一对一关系

5.1 数据库设计

在这里插入图片描述

5.2 实体类设计

5.2.1 外键关联

【IdCard实体类】

public class IdCard implements Serializable {
    private Integer id;
    private String name;

    private Person person;
	//getter、setter...
}

【Person实体类】

public class Personimplements Serializable {
    private Integer id;
    private String name;

    private IdCard card;
	//getter、setter...
}

5.2.2 主键关联

【IdCard实体类】

public class IdCard implements Serializable {
    private Integer id;
    private String name;

    private Person person;
	//getter、setter...
}

【Person实体类】

public class Personimplements Serializable {
    private Integer id;
    private String name;

    private IdCard card;
	//getter、setter...
}

5.3 配置文件

5.3.1 外键关联

【Person.hbm.xml】

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wei.domain.onetoone_fk.Person" table="t_person_fk">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <!--一对一配置-->
        <one-to-one name="card" class="com.wei.domain.onetoone_fk.IdCard"/>
      </class>

</hibernate-mapping>

【IdCard.hbm.xml】

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wei.domain.onetoone_fk.IdCard" table="t_card_fk">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <!--一对一配置 使用unique设置唯一外键 -->
        <many-to-one  name="person" class="com.wei.domain.onetoone_fk.Person" column="person_id" unique="true"/>
      </class>

</hibernate-mapping>

注意事项

  1. 在一对一的配置中给，我们需要设置任意一方的属性为many-to-one，然后通过核心的unique设置其外键是唯一

5.3.2 主键关联

【Person.hbm.xml】
与外键关联保持一致
【IdCard.hbm.xml】

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.wei.domain.onetoone_pk.IdCard" table="t_card_pk">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <!--一对一配置 主键关联 -->
        <one-to-one  name="person" class="com.wei.domain.onetoone_pk.Person" constrained="true"/>
      </class>

</hibernate-mapping>

注意事项：

  1. 逐渐概念需要使用one-to-one标签 其中使用constraint=”true“配置主键关联

5.4 测试

5.4.1 外键关联

@Test
    public void test8() throws HibernateException {
        // 准备数据
        Person p = new Person();
        p.setName("魏巍");
        IdCard idCard = new IdCard();
        idCard.setName("中华人民共和国个人身份证:61020210213826465456");
        idCard.setPerson(p);
        p.setCard(idCard);
        Session session = HibernateUtil.getConnection();
        //4、开启事务
        Transaction tx = session.beginTransaction();
        //5、执行添加操作
        session.save(p);
        session.save(idCard);

        //6、提交事务
        tx.commit();
        //7、关闭资源
        HibernateUtil.closeSession(session);
    }

5.4.2 主键关联

@Test
    public  void test10(){
        Session session = HibernateUtil.getConnection();

        Transaction tx = session.beginTransaction();
        com.wei.domain.onetoone_pk.Person p = new com.wei.domain.onetoone_pk.Person();

        p.setName("刘虎");
        com.wei.domain.onetoone_pk.IdCard card = new com.wei.domain.onetoone_pk.IdCard();
        card.setName("中国台湾身份证6675677457576386");
        card.setPerson(p);
        p.setCard(card);

        session.save(p);
        session.save(card);

        tx.commit();

        HibernateUtil.closeSession(session);
    }

【至此，第二章的hibernate的学习就此结束】
总结：

  1. 配置文件的方式配置一对一，一对多或者是多对多的关系都比较冗余（个人觉得），后期会学习注解是的JPA开发
@WAT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Go-Go关系持久化-一个ORM框架
08-13
Go 关系持久化 - 一个ORM框架
【ORM思想】源码分析篇：Hibernate的ORM思想分析
不想当架构师的程序员不是好程序员
08-20 950
源码分析篇：Hibernate框架分析 1. ORM的经典应用：Hibernate案例 Hibernate 就是应用 ORM 思想建立的一个框架，一般我们把它称之为全自动的 ORM 框架，程序员在使用 Hibernate 时几乎不用编写 sql 语句，而是通过操作对象即可完成对数据库的增删改查。 通过案例让大家对 ORM 思想有一个更深入的了解 1.1 创建 Maven 工程 1.2 编...
Hibernate框架如何实现ORM
xyls_2009的专栏
11-12 423
 本文转自 中国IT实验室     1.什么是ORM    ORM的全称是Object Relational Mapping，即对象关系映射。它的实现思想就是将关系数据库中表的数据映射成为对象，以对象的形式展现，这样开发人员就可以把对数据库的操作转化为对这些对象的操作。因此它的目的是为了方便开发人员以面向对象的思想来实现对数据库的操作。    2.什么是Hibernate   
hibernate 执行sql在哪个类_ORM之Hibernate运行过程分析
weixin_39944515的博客
11-29 89
ORMORM(Object Relational Mapping)吸收了面向对象的思想，把对 sql 的操作转换为对象的操作，从而让程序员使用起来更加方便和易于接受。这种转换是通过对象和表之间的元数据映射实现的，这是实现 ORM 的关键。由于类和表之间以及属性和字段之间建立起了映射关系，所以，通过 sql 对表的操作就可以转换为对象的操作，程序员从此无需编写 sql 语句，由框架根据映射关系自动生...
Hibernate持久层框架详解
superkeeper的博客
07-05 4140
一、hibernate框架的前世今生 1、前世：2001年，Gavin King开始开发hibernate框架。两年之后，Gavin King带领他的team完成了hibernate框架的开发，谁也没有想到两年前对SQL一概不知的小伙子，居然会成为全世界J2EE数据库解决方案的领导者。 2、今生：Hibernate版本更新速度很快，目前为止有两个阶段性的版本：Hibernate2，Hibe
数据持久层框架Hibernate使用方法
Michael的博客
07-13 395
Hibernate是一个开源的对象关系映射（ORM）框架，它对JDBC进行了轻量级的对象封装
sqltoy-orm框架系统-其他
06-11
sqltoy-orm是比hibernate+myBatis更加贴合项目的orm框架，具有hibernate增删改的便捷性同时也具有比myBatis更加灵活优雅的自定义sql查询功能。 sqltoy-orm支持以下数据库: oracle 从oracle11g到19c db2 9.5+,建议从...
ORM框架-VB、C.Net实体代码生成工具（EntitysCodeGenerate）-4.3.doc
11-29
ORM框架-VB、C.Net实体代码生成工具（EntitysCodeGenerate）-4.3.doc
SqlSugar开源ORM框架-.net
06-14
SqlSugar是一款简单易用的开源ORM框架。 优点： 简单易用、功能齐全、高性能、轻量级、服务齐全 支持数据库：MySql、SqlServer、Sqlite、Oracle 、 postgresql、达梦、人大金仓 性能： 比大部分的DbHelper性能要高，...
Android-GreenDao是AndroidORM(对象关系映射)框架
08-12
GreenDao是Android ORM(对象关系映射)框架，简化对数据库的操作，不用开发者自己拼装sql语句，减少出错率。开发者只需对实体类实例进行操作即可达到操作数据库的目的。Demo的GreenDao版本为3.2，通过注解方式生成...
9.3. Hibernate框架
Andy0214的专栏
06-03 5698
Hibernate是一个开源的持久层框架，它可以帮助我们将Java对象映射到数据库表中，并实现对象的持久化操作。Hibernate提供了丰富的API，可以方便地进行CRUD（增删改查）操作，而无需手动编写复杂的JDBC代码。
四、持久层框架（Hibernate）
dengbangtui3521的博客
03-06 127
一、一级缓存与二级缓存 　　1、一级缓存：Hibernate默认是开启一级缓存的，一级缓存存放在session里，一个Session做一次查询操作，会把这个操作的结果放在一级缓存中，如果短时间内这个session （同一个session）又做了同一个操作，那么hibernate直接从一级缓存中拿，而不用再去连接数据库，取数据。 一级缓存生命周期依赖于Session生命周期，Sessi...
二、持久层框架（Hibernate）
dengbangtui3521的博客
03-06 91
一、Hibernate对象的状态 　　实体类对象在Hibernate中有3中状态：瞬时，持久，脱管。 瞬时：没有和Hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，对象就消失了 持久：一个对象和Hibernate发生联系，有对应的Session，并且在数据库中有对应的一条记录 脱管：一个对象虽然在数据库中有对应的一条记录，但是它所对应的Session已经...
数据持久层Hibernate——01基本使用
weixin_43624810的博客
04-07 1147
目录 什么是HIbernate？ 快速入门使用 1.添加相关依赖 2.在 resource 目录下创建 logback.xml 3.在 resource 目录下创建 hibernate.cfg.xml 4.创建实体 5.创建 News.hbm.xml 该文件将实体的属性映射到数据表，从而完成数据库创表和和保存对象的操作 6.执行代码,执行会自动创表，插入数据 Session 概述 对象的四个状态 对象的基本操作 持久化（保存） 对象查询（单个） 修改单个对象 删除对象 .
重量级ORM框架--持久化框架Hibernate【基础入门】
mmklo的博客
08-07 540
在学习Hibernate之前，我们需要回顾下ORM，我们都肯定用过或者熟悉Mybatis的，(或者有看过我之前的MyBatis的博客)。我们都知道Mybatis是一款半自动的ORM框架。
Hibernate与 MyBatis的比较
weixin_34067980的博客
07-01 543
2012-11-16   最近做了一个Hibernate与MyBatis的对比总结，希望大家指出不对之处。 第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBati...
一、持久层框架（Hibernate）
dengbangtui3521的博客
03-05 155
一、Hibernate 　　使用JDBC做数据库相关功能开发会做很多重复性的工作，创建连接，关闭连接，把字段逐一映射到属性中等。Hibernate把这些进行封装起来，使得数据库访问变得轻松简单。 1、创建数据库，数据表 --创建数据库 create database test; --使用数据库 use test; --创建数据表 CREATE TABLE produc...
Hibernate持久层(原理、基本流程)
搬家啦x
08-16 4481
Hibernate持久层 Java中对象的持久化有3种方式： （1）序列化对象，存到格式化的文本中； （2）将对象持久化到XML文档中； （3）持久到数据库中，一般指关系型数据库。   以前：表示层 + 业务逻辑层 + 数据库层   其中业务逻辑层：除了负责业务逻辑意外，还要负责相关的数据库操作（增删改查）   为了使业务逻辑层的开发人员能真正专注于业务逻辑的开发，不纠缠与底层
MyBatis与Hibernate持久层框架简单总结
gaofengyan的博客
01-01 2578
目录 数据持久化操作框架及ORM关系 MyBatis框架         MyBatis主要的类 Hibernate框架 Hibernate实体类中有三种状态： 数据持久化操作框架及ORM关系 1.）MyBatis与Hibernate框架都是对底层数据库数据持久化进行操作的（ORM——对象、关系映射实现）框架。 2.）持久化：持久（Persistence),是程序数据在瞬时状态（如内...
数据持久化框架和ORM框架有什么区别？
最新发布
12-04
数据持久化框架和ORM框架都是用于实现数据持久化的技术，但它们之间有一些区别。数据持久化框架是一种将数据从内存中持久化到磁盘上的技术，它可以将内存中的对象保存到磁盘的某个文件中，以便在程序重新启动时可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@WAT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值