Hibernate(一)

最新推荐文章于 2021-02-13 01:35:32 发布

渣渣敲代码

最新推荐文章于 2021-02-13 01:35:32 发布

阅读量194

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_27181955/article/details/80572403

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

写这篇博客的原因是作为自己开发过程中的笔记，仅用于学习参考。当中或许借鉴了某位大神的真迹造成侵权，请联系我。

一、Hibernate框架简介

Hibernate是对JDBC的进一步封装。它的一个主要出发点就是希望简化Java对象持久化的编程。因为直接使用JDBC时需要程序员编写大量繁杂的代码。

Hibernate是一个开源的ORM（对象-关系映射）框架，它的作用就是在POJO（普通JAVA对象）和关系型数据库之间做一个映射，把关系型数据库的字段与内存中java对象的属性做映射。这样，程序员在操作数据库的时候，就不用再写复杂的sql语句，就可以完成操作数据库的工作。

Hibernate框架是持久层框架，作用是将JAVA对象持久化到数据库中。
Hibernate不要求程序员将POJO一一映射到数据库表，可以多个表对应一个POJO，也可以将多个POJO持久化到一个表中。

二、Hibernate框架的核心组件

Configuration类：它用来读取Hibernate的配置文件，并生成SessionFactory对象。Hibernate的配置文件有全局配置文件（hibernate.properties或hibernate.cfg.xml）和映射文件（*.hbm.xml）。
SessionFactory接口：用来产生Session对象。
Session接口：用来操作POJO。
Query接口：用来对POJO进行查询操作。
Transaction接口：用来管理Hibernate事务。

其实刚开始对于Hibernate的这些核心组件混个脸熟就行，因为既然是核心组件，以后肯定经常用到。

三、Hibernate的运行过程

Hibernate的运行过程

上图是Hibernate的运行过程。大致过程是：

由Configuration类读取配置文件，包括数据库用户名、密码等；
SessionFactory生成Session对象，可以用Session对象生成Transaction对象进行事务操作，也可以用Session对象生成Query对象，执行查询操作，其实还有Criteria可以执行查询操作。

四、HelloWorld入门程序示例

1.导包

单个hibernate.jar包

  <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>

完整的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.liu.learn</groupId>
    <artifactId>hibernatelearn</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>


    <properties>
        <hibernate.version>5.0.7.final</hibernate.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

    <build>
        <!--映射文件需要设置资源目录，才可以访问到-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>


        </resources>
    </build>
</project>

2.主配置文件：hibernate.cfg.xml

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



    <!--必填5个配置，数据库基本配置4个，一个数据库方言配置-->
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql:///crm</property>
    <property name="hibernate.connection.username">root</property>
    <property name="connection.password">123456</property>
    <!--数据库方言配置-->
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>



    <!-- 将hibernate生成的sql语句打印到控制台 -->
    <property name="hibernate.show_sql">true</property>
    <!-- 将hibernate生成的sql语句格式化(语法缩进) -->
    <property name="hibernate.format_sql">true</property>
    <!--
		## auto schema export  自动导出表结构. 自动建表
		#hibernate.hbm2ddl.auto create		自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
		#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
		#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
		#hibernate.hbm2ddl.auto validate	校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
		 -->
    <property name="hibernate.hbm2ddl.auto">update</property>
    <!--引入orm数据-->
    <mapping resource="com/liu/learn/hibernate/bean/Customer.hbm.xml"></mapping>
  </session-factory>
</hibernate-configuration>

3.写实体和orm元数据

实体：

package com.liu.learn.hibernate.bean;

public class Customer {
    private long custId;
    private String custName;
    private long custUserId;
    private long custCreateId;
    private String custSource;
    private String custIndustry;
    private String custLevel;
    private String custLinkman;
    private String custPhone;
    private String custMobile;

    public long getCustId() {
        return custId;
    }

    public void setCustId(long custId) {
        this.custId = custId;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public long getCustUserId() {
        return custUserId;
    }

    public void setCustUserId(long custUserId) {
        this.custUserId = custUserId;
    }

    public long getCustCreateId() {
        return custCreateId;
    }

    public void setCustCreateId(long custCreateId) {
        this.custCreateId = custCreateId;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustLinkman() {
        return custLinkman;
    }

    public void setCustLinkman(String custLinkman) {
        this.custLinkman = custLinkman;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustMobile() {
        return custMobile;
    }

    public void setCustMobile(String custMobile) {
        this.custMobile = custMobile;
    }
}

Orm元数据：

<?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 package="com.liu.learn.hibernate.bean">
    <!--
		class元素: 配置实体与表的对应关系的
			name: 完整类名
			table:数据库表名
	 -->
    <class name="Customer" table="cst_customer">
        <!-- id元素:配置主键映射的属性
				name: 填写主键对应属性名
				column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名
				type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.
						每个类型有三种填法: java类型|hibernate类型|数据库类型
				not-null(可选):配置该属性(列)是否不能为空. 默认值:false
				length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度
		 -->
        <id name="custId" column="cust_id">
            <generator class="native" ></generator>
        </id>

        <property name="custName" column = "cust_name"></property>
        <property name="custSource" column="cust_source" ></property>
        <property name="custIndustry" column="cust_industry" ></property>
        <property name="custLevel" column="cust_level" ></property>
        <property name="custLinkman" column="cust_linkman" ></property>
        <property name="custPhone" column="cust_phone" ></property>
        <property name="custMobile" column="cust_mobile" ></property>
    </class>
</hibernate-mapping>

4.写测试代码

    @Test
    public void fun1(){
        Configuration configuration = new Configuration();
//       加载主配置文件
//        要确保尽可能的少加载主配置文件，因为消耗性能很大
        configuration.configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
//        打开一个新的session每次都是一个新的session
//        在web环境中一般我们使用getCurrentSession()来获取一个相同的session
        Session session = sessionFactory.openSession();
        //获得事物并开启事物
        Transaction transaction = session.beginTransaction();
        Customer customer = new Customer();
        customer.setCustId(123);
        customer.setCustName("helloWorld");
        customer.setCustMobile("123123123");
        session.save(customer);
        //提交事务
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

五、api学习

1.学习Configuration对象

//学习Configuration对象
// Configuration功能: 配置加载类.用于加载主配置,orm元数据加载
public class Demo {

	@Test
	public void fun1(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration();
		//2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
		conf.configure();
		//3 读取指定orm元数据(扩展),如果主配置中已经引入映射配置.不需要手动加载
		//conf.addResource(resourceName);
		//conf.addClass(persistentClass);
		
		//4 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		
	}
}

2.学习SessionFactory对象

//学习SessionFactory对象
// SessionFactory功能: 用于创建操作数据库核心对象session对象的工厂.
//					 简单说功能就一个---创建session对象
//注意:1.sessionfactory 负责保存和使用所有配置信息.消耗内存资源非常大.
//	  2.sessionFactory属于线程安全的对象设计.
//结论: 保证在web项目中,只创建一个sessionFactory.
public class Demo2 {

	@Test
	public void fun1(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration();
		//2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
		conf.configure();
		//3 读取指定orm元数据(扩展),如果主配置中已经引入映射配置.不需要手动加载
		//conf.addResource(resourceName);
		//conf.addClass(persistentClass);
		
		//4 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		//--------------------------------------------------
		//5 获得session
		//打开一个新的session对象
		sf.openSession();
		//获得一个与线程绑定的session对象(明天讲解)
		sf.getCurrentSession();
	}
}

3.//学习Session对象

public class Demo3 {

	@Test
	//事务操作
	public void fun1(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration().configure();
		//2 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		//3 获得session
		Session session = sf.openSession();
		//4 session获得操作事务的Transaction对象
		//获得操作事务的tx对象
		//Transaction tx = session.getTransaction();
		//开启事务并获得操作事务的tx对象(建议使用)
		Transaction tx2 = session.beginTransaction();
		//----------------------------------------------
		
		
		//----------------------------------------------
		tx2.commit();//提交事务
		tx2.rollback();//回滚事务
		session.close();//释放资源
		sf.close();//释放资源
	}
	
	@Test
	//session的新增
	public void fun2(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration().configure();
		//2 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		//3 获得session
		Session session = sf.openSession();
		//4 session获得操作事务的Transaction对象
		//获得操作事务的tx对象
		//Transaction tx = session.getTransaction();
		//开启事务并获得操作事务的tx对象(建议使用)
		Transaction tx2 = session.beginTransaction();
		//----------------------------------------------
		Customer c = new Customer();
		c.setCust_name("传智播客");
		
		session.save(c);
		//----------------------------------------------
		tx2.commit();//提交事务
		session.close();//释放资源
		sf.close();//释放资源
	}
	@Test
	//session的查询
	//查询id为1的customer对象
	public void fun3(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration().configure();
		//2 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		//3 获得session
		Session session = sf.openSession();
		//4 session获得操作事务的Transaction对象
		//获得操作事务的tx对象
		//Transaction tx = session.getTransaction();
		//开启事务并获得操作事务的tx对象(建议使用)
		Transaction tx2 = session.beginTransaction();
		//----------------------------------------------
		
		Customer customer = session.get(Customer.class, 1l);
		
		System.out.println(customer);
		//----------------------------------------------
		tx2.commit();//提交事务
		session.close();//释放资源
		sf.close();//释放资源
	}
	@Test
	//session的修改
	//修改id为1的customer对象的name属性为xx
	public void fun4(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration().configure();
		//2 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		//3 获得session
		Session session = sf.openSession();
		//4 session获得操作事务的Transaction对象
		//获得操作事务的tx对象
		//Transaction tx = session.getTransaction();
		//开启事务并获得操作事务的tx对象(建议使用)
		Transaction tx2 = session.beginTransaction();
		//----------------------------------------------
		//1 获得要修改的对象
		Customer c = session.get(Customer.class, 1l);
		//2 修改
		c.setCust_name("xx");
		//3 执行update
		session.update(c);
		//----------------------------------------------
		tx2.commit();//提交事务
		session.close();//释放资源
		sf.close();//释放资源
	}
	@Test
	//session的删除
	//删除id为1的customer对象
	public void fun5(){
		//1 创建,调用空参构造
		Configuration conf = new Configuration().configure();
		//2 根据配置信息,创建 SessionFactory对象
		SessionFactory sf = conf.buildSessionFactory();
		//3 获得session
		Session session = sf.openSession();
		//4 session获得操作事务的Transaction对象
		//获得操作事务的tx对象
		Transaction tx = session.getTransaction();
		tx.begin();
		//开启事务并获得操作事务的tx对象(建议使用)
		Transaction tx2 = session.beginTransaction();
		//----------------------------------------------
		//1 获得要修改的对象
		Customer c = session.get(Customer.class, 1l);
		//2 调用delete删除对象
		session.delete(c);
		//----------------------------------------------
		tx2.commit();//提交事务
		session.close();//释放资源
		sf.close();//释放资源
	}
}