Hibernate基础

叁歲伎倆 2022-02-05 09:01 253阅读 0赞

\*\*

## 一、什么是Hibernate？ ##

\*\*  
　　Hibernate是一个轻量级的ORMapping框架  
　　ORMapping原理（Object Relational Mapping）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70]

**ORMapping基本对应规则**：

*  1：类跟表相对应
 *  2：类的属性跟表的字段相对应
 *  3：类的实例与表中具体的一条记录相对应
 *  4：一个类可以对应多个表，一个表也可以对应对个类
 *  5：DB中的表可以没有主键，但是Object中必须设置主键字段
 *  6：DB中表与表之间的关系（如：外键）映射成为Object之间的关系
 *  7：Object中属性的个数和名称可以和表中定义的字段个数和名称不一样

**ORMapping的基本实现方式**：  
使用JDBC，用SQL来操作数据库，只是看动态生成还是人工写代码来实现。  
大家想想，我们实现过ORMapping吗？

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 1]

\*\*

## 二、Hibernate能干什么： ##

\*\*

Hibernate主要用来实现Java对象和表之间的映射，除此之外还提供还提供数据查询和获取数据的方法，可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。

Hibernate的目标是对于开发者通常的数据持久化相关的编程任务，解放其中的95%。对于以数据为中心的程序来说,它们往往只在数据库中使用存储过程来实现商业逻辑,Hibernate可能不是最好的解决方案;对于那些在基于Java的中间层应用中，它们实现面向对象的业务模型和商业逻辑的应用，Hibernate是最有用的。

Hibernate可以帮助你消除或者包装那些针对特定厂商的SQL代码，并且帮你把结果集从表格式的表示形式转换到一系列的对象去。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 2]

一个非常简要的Hibernate体系结构的高层概要图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 3]

Hibernate运行时体系结构  
“最小”的体系结构方案，要求应用程序提供自己的 JDBC 连接并管理自己的事务。这种方案使用了Hibernate API 的最小子集.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 4]

“全面解决”的体系结构方案，将应用层从底层的JDBC/JTA API中抽象出来，而让Hibernate来处理这些细节。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 5]

\*\*

## 三、Hibernate中的对象 ##

\*\*  
SessionFactory (org.hibernate.SessionFactory)  
针对单个数据库映射关系经过编译后的内存镜像，是线程安全的（不可变）。 它是生成的工厂，本身要用到。  
Session (org.hibernate.Session)  
表示应用程序与持久储存层之间交互操作的一个单线程对象，此对象生存期很短，隐藏了连接，也是的工厂。  
Transaction (org.hibernate.Transaction)  
应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很短。它通过抽象将应用从底层具体的、以及事务隔离开。  
ConnectionProvider (org.hibernate.connection.ConnectionProvider)  
生成连接的工厂（有连接池的作用）。它通过抽象将应用从底层的或隔离开。仅供开发者扩展/实现用，并不暴露给应用程序使用。  
TransactionFactory (org.hibernate.TransactionFactory)  
生成对象实例的工厂。仅供开发者扩展/实现用，并不暴露给应用程序使用。

示例如下：  
数据库表：Student.sql

CREATE TABLE "STUDENT" 
    (    
        "STUNO" VARCHAR2(20), 
        "STUNAME" VARCHAR2(20), 
        "STUPASS" VARCHAR2(20), 
        "STUSEX" VARCHAR2(2), 
        "MOBILE" VARCHAR2(20), 
        "EMAIL" VARCHAR2(20), 
        "ADDRESS" VARCHAR2(50), 
        "STUAGE" NUMBER
    )

配置文件：hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
        <session-factory>
            
            <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
            
            <property name="connection.username">zhengcheng</property>
            
            <property name="connection.password">123123</property>
            
            <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
            
            
            <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
            
            <property name="current_session_context_class">thread</property>
            
            <property name="show_sql">true</property>
            
            <property name="format_sql">true</property>
            
            
            <mapping resource="Student.hbm.xml" />    
        </session-factory>
    </hibernate-configuration>

1：与被描述的类同名 ，如：Student.hbm.xml  
2：存放位置与所描述类存放在同一文件夹下  
3：主要有如下四部分配置 ：  
（1）类和表的映射  
（2）主键的映射  
（3）类的属性和DB中字段的映射  
（4）关系的映射  
4：配置的时候可以到hibernate发行包里面找个例子，比如可以用“\\project\\hibernate-core\\src\\test\\java\\org\\hibernate\\test\\cid”下面的Customer.hbm.xml作例子  
映射文件：Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
        <class name="hibDemo1.entity.Student" table="STUDENT">
            <id name="stuNo" type="java.lang.String" column="STUNO">
                
                <generator class="assigned" />
            </id>
            
            <property name="stuName" type="java.lang.String" column="STUNAME" length="50" not-null="true" />
            
            
            <property name="stuPass" type="java.lang.String" column="STUPASS">
                <column name="STUPASS" length="50" not-null="true"></column>
            </property>
            <property name="stuSex" type="java.lang.String" column="STUSEX" />
            <property name="stuAge" type="java.lang.Integer" column="STUAGE" />
            <property name="Mobile" type="java.lang.String" column="MOBILE" />
            <property name="Email" type="java.lang.String" column="EMAIL" />
            <property name="Address" type="java.lang.String" column="ADDRESS" />
        </class>
    </hibernate-mapping>

客户端文件：

java代码：StudentService.java

package hibDemo1.dao;
    
    import hibDemo1.entity.Student;
    
    import java.util.List;
    
    import org.hibernate.HibernateException;
    import org.hibernate.Query;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    
    public class StudentService { 
        private static Configuration conf;
        private static SessionFactory sf;
        private static Transaction tx;
    
        static { 
            try { 
                conf = new Configuration().configure();
                sf = conf.buildSessionFactory();
    
            } catch (HibernateException e) { 
                e.printStackTrace();
            }
        }
    
        public static Session getSession() { 
            return sf.openSession();         //过去老的方法，不需要使用事务
            //return sf.getCurrentSession(); // 新的方法，需要和事务一起使用，可以保证每个用户创建的session独立，需要在配置文件中配置
                                            //<property name="current_session_context_class">thread</property>
        }
    
        /** * 获取所有学生列表 * * @return */
        public List<Student> GetAllStudent() { 
            List<Student> list = null;
            Session session = getSession();
            if (session != null) { 
                try { 
                    String hql = "from Student";
                    Query query = session.createQuery(hql);
                    list = query.list();
                } catch (HibernateException e) { 
                    e.printStackTrace();
                } finally { 
                    session.close();
                }
            }
            return list;
        }
    
        /** * 获取单个学生信息 * * @param stuNo * @return */
        public Student GetStudentBystuNo(String stuNo) { 
            Student stu = null;
            Session session = getSession();
            if (session != null) { 
                try { 
                    // get如果没有查询到数据，则返回null
                    // stu = (Student) session.get(Student.class, stuNo);
    
                    // load如果没有查询到数据，则抛出异常
                    stu = (Student) session.load(Student.class, stuNo);
                } catch (HibernateException e) { 
                    e.printStackTrace();
                } finally { 
                    session.close();
                }
            }
            return stu;
        }
    
        /** * 添加一个学生 * * @param stu * @author Administrator */
        public boolean AddStudent(Student stu) { 
            boolean b = false;
            Session session = getSession();
            if (session != null) { 
    
                try { 
                    // 开启一个事务
                    tx = session.beginTransaction();
                    // 保存
                    session.save(stu);
                    // 提交事务
                    tx.commit();
    
                    return true;
    
                } catch (HibernateException e) { 
                    e.printStackTrace();
                    tx.rollback();
                } finally { 
                    session.close();
                }
            }
            return b;
        }
    
        /** * 更新一个学生 * * @param stu * @author Administrator */
        public boolean UpdateStudent(String stuNo, String newName) { 
            boolean b = false;
            Session session = getSession();
            if (session != null) { 
    
                try { 
                    // 开启一个事务
                    tx = session.beginTransaction();
    
                    // 获取一个学生对象
                    Student stu = (Student) session.load(Student.class, stuNo);
    
                    // 更新某个属性
                    stu.setStuName(newName);
    
                    // 提交事务
                    tx.commit();
    
                    return true;
    
                } catch (HibernateException e) { 
                    e.printStackTrace();
                    tx.rollback();
                } finally { 
                    session.close();
                }
            }
            return b;
        }
    
        /** * 更新一个学生 * * @param stu * @author Administrator */
        public boolean DeleteStudent(String stuNo) { 
            boolean b = false;
            Session session = getSession();
            if (session != null) { 
    
                try { 
                    // 开启一个事务
                    tx = session.beginTransaction();
    
                    // 获取一个学生对象
                    Student stu = (Student) session.load(Student.class, stuNo);
    
                    // 删除操作
                    session.delete(stu);
    
                    // 提交事务
                    tx.commit();
    
                    return true;
    
                } catch (HibernateException e) { 
                    e.printStackTrace();
                    tx.rollback();
                } finally { 
                    session.close();
                }
            }
            return b;
        }
    }

test.java

package hibDemo.test;
    
    import hibDemo1.dao.StudentService;
    import hibDemo1.entity.Student;
    
    import java.util.List;
    import java.util.Scanner;
    
    public class test { 
    
        public static void main(String[] args) { 
    
            // 添加学生信息
            // AddStudent();
    
            // 显示所有学生信息
            ShowAll();
    
            // 显示单个学生信息
            // ShowOne();
    
            //更新学生信息
            //Update();
            
            //删除学生信息
            //Delete();
            
            ShowAll();
        }
    
        public static void ShowAll() { 
            StudentService service = new StudentService();
            List<Student> list = service.GetAllStudent();
            for (Student student : list) { 
                System.out.println(student.getStuNo() + " " + student.getStuName());
            }
        }
    
        public static void ShowOne() { 
            String no = "A004";
            StudentService service = new StudentService();
            Student student = service.GetStudentBystuNo(no);
            if (student != null) { 
                System.out.println(student.getStuNo() + " " + student.getStuName());
            } else { 
                System.out.println("no data");
            }
        }
    
        public static void AddStudent() { 
            Scanner input = new Scanner(System.in);
            Student stu = new Student();
            System.out.print("请输入学生编号：(A001)");
            stu.setStuNo(input.next());
            System.out.print("请输入学生姓名：(A001)");
            stu.setStuName(input.next());
            stu.setStuPass("888888");
            System.out.print("请输入学生年龄：(0-100)");
            stu.setStuAge(input.nextInt());
            System.out.print("请输入学生手机号：(A001)");
            stu.setMobile(input.next());
            System.out.print("请输入学生邮箱：(A001)");
            stu.setEmail(input.next());
            System.out.print("请输入学生地址：(A001)");
            stu.setAddress(input.next());
    
            StudentService service = new StudentService();
            service.AddStudent(stu);
        }
    
        public static void Update() { 
            Scanner input = new Scanner(System.in);
            System.out.print("输入要修改的学号：");
            String stuNo = input.next();
            System.out.print("输入要修改的姓名：");
            String newName = input.next();
    
            StudentService service = new StudentService();
            service.UpdateStudent(stuNo, newName);
        }
    
        public static void Delete() { 
            Scanner input = new Scanner(System.in);
            System.out.print("输入要修改的学号：");
            String stuNo = input.next();
    
            StudentService service = new StudentService();
            service.DeleteStudent(stuNo);
        }
    }

**说明：**  
1：SessionFactory sf = new Configuration().configure().buildSessionFactory();这句话的意思是读取hibernate.cfg.xml，创建Session工厂，是线程安全的。  
默认是”hibernate.cfg.xml”，不用写出来，如果文件名不是”hibernate.cfg.xml”，那么需要显示指定，如下：  
SessionFactory sf = new Configuration(). configure( “javass.cfg.xml” ).buildSessionFactory();  
2：Session是应用程序主要使用的Hibernate接口，约相当于JDBC的Connection+Statement/PreparedStatement的功能，是线程不安全的

3：在Hibernate4里面，已经不推荐使用Configuration类了，而改为使用 ServiceRegistryBuilder和MetadataSources来代替，新的写法大致如下：  
ServiceRegistryBuilder builder = new ServiceRegistryBuilder().configure();  
builder.applySetting(“connection.driver\_class”, “oracle.jdbc.driver.OracleDriver”);  
builder.applySetting(“connection.url”, “jdbc:oracle:thin:@localhost:1521:orcl”);  
builder.applySetting(“connection.username”, “ztb”);  
builder.applySetting(“connection.password”, “ztb”);  
builder.applySetting(“connection.pool\_size”, “2”);  
builder.applySetting(“hibernate.dialect”, “org.hibernate.dialect.OracleDialect”);  
builder.applySetting(“show\_sql”, “true”);

MetadataSources sources = new MetadataSources( builder.buildServiceRegistry() );  
sources.addResource(“cn/javass/h4/hello/UserModel.hbm.xml”);

MetadataImpl metadata = (MetadataImpl) sources.buildMetadata();  
SessionFactory sf = metadata.getSessionFactoryBuilder().buildSessionFactory();  
这种写法，现在还没有实现完全，不太好用，所以官方给出的示例里面还是采用以前的方式，大家先了解一下。  
4：这里使用的事务Transaction是Hibernate的Transaction，需要有，不能去掉。

为什么必须有这个Hibernate的事务呢？以HelloWorld为例来看看：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 6]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70]: /images/20220205/4cb7d7176dcf4c9c9212ef840b4064c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 1]: /images/20220205/965b7b001c7740fb86c3165847e970a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 2]: /images/20220205/d13c7f4b8d3f46408328c8519b4ed493.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 3]: /images/20220205/6aadd2ce8abf4f5aaaae4d20f5a8193f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 4]: /images/20220205/dc781f057e824e64a23d3e8517129a1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 5]: /images/20220205/926082aa7383467c95ec524397f9de79.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW9ob25nX2Jv_size_16_color_FFFFFF_t_70 6]: /images/20220205/d2ffc3e5a25f4b62a12e6a04e11c7017.png