14.hibernate的入门

最新推荐文章于 2021-10-19 10:41:33 发布

code1997

最新推荐文章于 2021-10-19 10:41:33 发布

阅读量226

点赞数 1

分类专栏： javaee 文章标签： java hibernate

本文链接：https://blog.csdn.net/qq_44739500/article/details/109488045

版权

这篇博客介绍了Hibernate的基本概念，包括ORM思想和JDBC的不足。详细阐述了Hibernate的初次体验，包括框架搭建、CRUD操作和细节，如get和load的区别。同时，深入讨论了HQL查询、Criteria查询和主键生成策略。此外，还涵盖了对象状态转换和缓存机制的一级缓存和二级缓存的使用。

摘要由CSDN通过智能技术生成

hibernate

1 概念

1.1 分层好处

1.2 模型

模型：描述现实实物，面向对象的思想。
域模型：java中的实体类
数据模型：数据库中的表
数据模型之间的关系： 1对n n对n 1对1
域模型之间的关系：关联依赖聚集一般化

public class Person extends  Animal{
   //继承：：一般化关
系
   Father father;
    //每个person都有一个自己的father: 但两者可以是独立
的个体：关联关系

1.3 jdbc缺点

1.4 ORM

orm：object-relational-mapping，对象关系映射，持久层框架的设计原理。java中实体类的属性与关系型数据库表的字段创建一一对应关系。
目的：在进行crud时便于结果集的解析，和占位符的赋值。
1.5 关系模型和域模型的分歧

详细说以下粒度：

2 初次体验

2.1 框架的搭建和使用

1 导入pom依赖

    <dependencies>
        <!--核心包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.20.Final</version>
        </dependency>
        <!--日志相关包-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.30</version>
        </dependency>
        <!--自动生成字节码文件-->
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.24.0-GA</version>
        </dependency>
        <!--sql编译-->
        <dependency>
            <groupId>antlr</groupId>
            <artifactId>antlr</artifactId>
            <version>2.7.7</version>
        </dependency>
        <!--commons工具-->
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.2</version>
        </dependency>
        <!--事务-->
        <dependency>
            <groupId>javax.transaction</groupId>
            <artifactId>jta</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
    </dependencies>

2 创建表以及实体类

3 创建hibernate.cfg.xml

<?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>
        <!-- 下面是三个必须要有的配置：配置连接信息，hibernate的方言，银蛇文件的路径 -->
        <!-- 配置连接MySQL数据库的基本参数 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///java26</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">19971001</property>

        <!-- 配置Hibernate的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 下面两个是可选的配置哟！ -->
        <!-- 打印sql语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化sql语句 -->
        <property name="hibernate.format_sql">true</property>

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

4 创建hbm映射文件

<?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.zhiyou100.entity.Student" table="student">
        <id name="sid" column="sid">
            <generator class="native" />
        </id>
        <property name="sname" column="sname" />
        <property name="sage" column="sage" />
    </class>
</hibernate-mapping>

5 创建测试文件

demo01：

import org.hibernate.HibernateException;
import org.hibernate.Metamodel;
import org.hibernate.query.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import javax.persistence.metamodel.EntityType;

import java.util.Map;

/**
 * @author : code1997
 * @date :2020-09-2020/9/15 14:59
 */
public class Main {
   
    private static final SessionFactory ourSessionFactory;

    static {
   
        try {
   
            Configuration configuration = new Configuration();
            configuration.configure();

            ourSessionFactory = configuration.buildSessionFactory();
        } catch (Throwable ex) {
   
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static Session getSession() throws HibernateException {
   
        return ourSessionFactory.openSession();
    }

    public static void main(final String[] args) throws Exception {
   
        final Session session = getSession();
        try {
   
            System.out.println("querying all the managed entities...");
            final Metamodel metamodel = session.getSessionFactory().getMetamodel();
            for (EntityType<?> entityType : metamodel.getEntities()) {
   
                final String entityName = entityType.getName();
                final Query query = session.createQuery("from " + entityName);
                System.out.println("executing: " + query.getQueryString());
                for (Object o : query.list()) {
   
                    System.out.println("  " + o);
                }
            }
        } finally {
   
            session.close();
        }
    }
}

demo02：

import com.zhiyou100.entity.Student;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

/**
 * @author : code1997
 * @date :2020-09-2020/9/15 15:16
 */
public class Demo01 {
   
    public static void main(String[] args) {
   
        //1. 加载Hibernate的核心配置文件
        Configuration configuration = new Configuration().configure();
        //如果在Hibernate的核心配置文件没有设置加载哪个映射文件，则可手动加载映射文件
        //configuration.addResource("com/meimeixia/hibernate/demo01/Customer.hbm.xml");

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

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

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

        //5. 编写代码
        Student student = new Student(1001,"张久",18);

        session.save(student);//保存一个用户

        //6. 事务提交
        transaction.commit();

        //7. 释放资源
        session.close();
        sessionFactory.close();
    }
}

2.2 CRUD体验

package com.zhiyou100.dao;

import com.zhiyou100.entity.Student;
import com.zhiyou100.util.SessionUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;
import org.junit.Test;

import java.util.List;

/**
 * @author : code1997
 * @date :2020-09-2020/9/15 17:28
 */
public class StudentDao {
   

    @Test
    public void addOne(){
   
        Session session = SessionUtil.getSession();
        Transaction transaction = session.beginTransaction();
        try{
   
            Student student = new Student(1,"天球",18);
            session.save(student);
            transaction.commit();
        }catch (Exception exception){
   
            transaction.rollback();
            System.out.println("exception:"+ exception.getMessage());
        }finally {
   
            session.close();
        }
    }
    @Test
    public void deleteOne(){
   
        Session session = SessionUtil.getSession();
        Transaction transaction = session.beginTransaction();
        try{
   
            Student deleteStudent = session.get(Student.class, 10);
            if (deleteStudent!=null){
   
                System.out.println("删除成功");
                session.delete(deleteStudent);
            }else {
   
                System.out.println("用户不存在，删除失败");
            }
            transaction.commit();
        }catch (Exception exception){
   
            transaction.rollback();
            System.ou