Hibernate

最新推荐文章于 2023-07-13 08:13:54 发布

南离火

最新推荐文章于 2023-07-13 08:13:54 发布

阅读量145

点赞数

分类专栏： hibernate 框架文章标签： hibernate

本文链接：https://blog.csdn.net/weixin_45517802/article/details/114982831

版权

hibernate 同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

框架

2 篇文章 0 订阅

订阅专栏

Hibernate是什么

hibernate是一款优秀的持久化orm框架，解决持久化操作，使得程序员可以从编写繁复的jdbc工作中解放出来，专注于业务，提高程序员的开发效率，并且有可靠的移植性，降低了系统耦合度。

持久化

把数据保存到可永久保存的存储设备中，持久化的主要应用是将内存中的数据存储在关系型的数据库中，当然也可以存储在磁盘文件中，xml数据文件中。

ORM

就是对象关系映射，它的作用是在关系型数据库和对象之间做一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的sql语句打交道，只要像平时操作对象一样操作它就可以了。

为什么要做持久化和orm设计

代码复杂
用jdbc的编程访问数据库，代码量较大，特别是访问字段较多的表的时候，代码显得繁琐，容易出错，程序员需要耗费大量的时间，精力去编写数据库访问的sql语句，还要十分小心其中大量重复的源代码是否有疏漏，并不能集中精力于业务逻辑开发上面，
orm则建立了java对象与数据库对象之间的映射关系，程序员不需要编写复杂的sql语句，直接操作java对象即可，从而大大降低了代码量，也使程序员更加专注于业务逻辑的实现。
数据库连接问题
采用jdbc编程，必须保证各种关系数据之间不能出错，极其痛苦。
orm建立java对象与数据库对象关系映射的同时，也自动根据数据库对象之间的关系创建java对象的关系，并且提供了维持这些关系完整，有效的机制。
耦合度
jdbc属于数据访问层，但是使用jdbc编程时，程序员必须知道后台是用什么数据库，有哪些表，各个表有哪些字段，各个字段的类型是什么，表与表之间关系，创建了什么索引等等与后台数据库相关的详细信息，相关软件程序员兼职数据库dba.
使用orm技术，可以将数据库层完全隐蔽，呈现给程序员的只有java对象，程序员只需要根据业务逻辑的需要调用java对象的getter和setter方法，就可以实现对后台数据库的操作，程序员不必知道后台采用什么数据库，有哪些表，有什么字段，表与表之间有什么关系。
于是，系统设计人员把orm搭建好后，把java 对象交给程序员去实现业务逻辑，使持久层与数据层清晰分界。

建立数据库

create database hibernate_demo01;
use hibernate_demo01;
CREATE TABLE cst_customer (
cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT ‘客户编号(主键)’,
cust_name varchar(32) NOT NULL COMMENT ‘客户名称(公司名称)’,
cust_source varchar(32) DEFAULT NULL COMMENT ‘客户信息来源’,
cust_industry varchar(32) DEFAULT NULL COMMENT ‘客户所属行业’,
cust_level varchar(32) DEFAULT NULL COMMENT ‘客户级别’,
cust_phone varchar(64) DEFAULT NULL COMMENT ‘固定电话’,
cust_mobile varchar(16) DEFAULT NULL COMMENT ‘移动电话’,
PRIMARY KEY (cust_id)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

搭建一个maven项目

pom文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>hibernate</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>Maven Quick Start Archetype</name>
  <url>http://maven.apache.org</url>

<properties>
   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>

  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <!--hibernate依赖-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.3.7.Final</version>
    </dependency>

     <!--mysql依赖-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>hibernate-abc</finalName>
  </build>
</project>

在这里插入图片描述

创建实体类

package org.example.pojo;

public class Customer {
    private Long cust_id;
    private String cust_name;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_phone;
    private String cust_mobile;

    public Long getCust_id() {
        return cust_id;
    }

    public void setCust_id(Long cust_id) {
        this.cust_id = cust_id;
    }

    public String getCust_name() {
        return cust_name;
    }

    public void setCust_name(String cust_name) {
        this.cust_name = cust_name;
    }

    public String getCust_source() {
        return cust_source;
    }

    public void setCust_source(String cust_source) {
        this.cust_source = cust_source;
    }

    public String getCust_industry() {
        return cust_industry;
    }

    public void setCust_industry(String cust_industry) {
        this.cust_industry = cust_industry;
    }

    public String getCust_level() {
        return cust_level;
    }

    public void setCust_level(String cust_level) {
        this.cust_level = cust_level;
    }

    public String getCust_phone() {
        return cust_phone;
    }

    public void setCust_phone(String cust_phone) {
        this.cust_phone = cust_phone;
    }

    public String getCust_mobile() {
        return cust_mobile;
    }

    public void setCust_mobile(String cust_mobile) {
        this.cust_mobile = cust_mobile;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "cust_id=" + cust_id +
                ", cust_name='" + cust_name + '\'' +
                ", cust_source='" + cust_source + '\'' +
                ", cust_industry='" + cust_industry + '\'' +
                ", cust_level='" + cust_level + '\'' +
                ", cust_phone='" + cust_phone + '\'' +
                ", cust_mobile='" + cust_mobile + '\'' +
                '}';
    }
}

创建实体与表的隐射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="org.example.pojo.Customer" table="cst_customer">
        <!-- 建立类中的属性与表中的主键相对应 -->
        <id name="cust_id" column="cust_id">
            <!-- 主键的生成策略，后面会讲，现在使用的是本地生成策略 -->
            <generator class="native" />
        </id>

        <!-- 建立类中的普通属性和表中的字段相对应 -->
        <property name="cust_name" column="cust_name" />
        <property name="cust_source" column="cust_source" />
        <property name="cust_industry" column="cust_industry" />
        <property name="cust_level" column="cust_level" />
        <property name="cust_phone" column="cust_phone" />
        <property name="cust_mobile" column="cust_mobile" />
    </class>
</hibernate-mapping>

创建hibernate的核心配置文件

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory >
        <!--初始化数据库连接-->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!--最好在后面加上编码格式，以防添加数据到数据库乱码 ?useUnicode=true&amp;characterEncoding=UTF-8-->
        <property name="connection.url">jdbc:mysql:///hibernate_demo01?useUnicode=true&amp;characterEncoding=UTF-8</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!--方言-->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- 打印sql语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化sql语句 -->
        <property name="hibernate.format_sql">true</property>

        <!-- 告诉Hibernate的核心配置文件加载哪个映射文件 -->
        <mapping resource="Customer.hbm.xml"/>

    </session-factory>
</hibernate-configuration>

最后创建测试类进行测试

package org.example;

import org.example.pojo.Customer;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import java.util.List;

public class HibernateDemo1 {



    /**
     * 保存用户的案例
     */
    @Test
    public void AddInfo() {
        //1. 加载Hibernate的核心配置文件
        Configuration configuration = new Configuration().configure();


        //2. 创建SessionFactory对象，类似于JDBC中的连接池
        SessionFactory sessionFactory = configuration.buildSessionFactory();

        //3. 通过SessionFactory获取到Session对象，类似于JDBC中的Connection
        Session session = sessionFactory.openSession();

        //4. 手动开启事务，（最好是手动开启事务）
        Transaction transaction = session.beginTransaction();

        //5. 编写代码
        Customer customer = new Customer();
        customer.setCust_name("aaa");
        customer.setCust_industry("服务业");
        customer.setCust_level("一级");
        customer.setCust_mobile("12345678909");
        customer.setCust_phone("0735666");
        customer.setCust_source("市场调查");
        session.save(customer);//保存一个用户

        //6. 事务提交
        transaction.commit();
        //7. 释放资源
        session.close();
        sessionFactory.close();
    }



    /**
     *更新用户的实例
     */
    @Test
    public void UpdateInfo(){
        //1. 加载Hibernate的核心配置文件
        Configuration configuration = new Configuration().configure();


        //2. 创建SessionFactory对象，类似于JDBC中的连接池
        SessionFactory sessionFactory = configuration.buildSessionFactory();

        //3. 通过SessionFactory获取到Session对象，类似于JDBC中的Connection
        Session session = sessionFactory.openSession();

        //4. 手动开启事务，（最好是手动开启事务）
        Transaction transaction = session.beginTransaction();

        //5. 编写代码
        Customer customer = new Customer();
        customer.setCust_id(2L);
        customer.setCust_name("李某");
        session.update(customer);


        //6. 事务提交
        transaction.commit();
        //7. 释放资源
        session.close();
        sessionFactory.close();
    }


    /**
     * 删除用户实例
     */
    @Test
    public void DeleteInfo(){
        //1. 加载Hibernate的核心配置文件
        Configuration configuration = new Configuration().configure();


        //2. 创建SessionFactory对象，类似于JDBC中的连接池
        SessionFactory sessionFactory = configuration.buildSessionFactory();

        //3. 通过SessionFactory获取到Session对象，类似于JDBC中的Connection
        Session session = sessionFactory.openSession();

        //4. 手动开启事务，（最好是手动开启事务）
        Transaction transaction = session.beginTransaction();

        //5. 编写代码
        Customer customer = new Customer();
        customer.setCust_id(1L);
        session.delete(customer);

        //6. 事务提交
        transaction.commit();
        //7. 释放资源
        session.close();
        sessionFactory.close();
    }

    /**
     * 查询用户实例
     */
    @Test
    public void SelectInfo(){
        //1. 加载Hibernate的核心配置文件
        Configuration configuration = new Configuration().configure();


        //2. 创建SessionFactory对象，类似于JDBC中的连接池
        SessionFactory sessionFactory = configuration.buildSessionFactory();

        //3. 通过SessionFactory获取到Session对象，类似于JDBC中的Connection
        Session session = sessionFactory.openSession();

        //4. 手动开启事务，（最好是手动开启事务）
        Transaction transaction = session.beginTransaction();

        //5. 编写代码
        List list=session.createQuery(" from Customer").list();
        for (Object o : list) {
            System.out.println(o);
        }

        //6. 事务提交
        transaction.commit();
        //7. 释放资源
        session.close();
        sessionFactory.close();
    }
}