1-Hibernate-常見概念

Hibernate

實體類編寫規則

（1）要求實體類有屬性作爲唯一值（id）
（2）實體類屬性使用包裝類
- 學生有屬性爲分數，Integer可爲null，表明學生未參加考試

主鍵生成策略

<id name="id" column="id">
    <!-- 設置數據庫表id增長策略
        native：生成表的id自增長
     -->
    <generator class="native"></generator>
</id>

generator標籤class屬性：

• increment：用於long、short、int，由hibernate自動以遞增的方式生成唯一標識符，每次增量爲1
• dentity：採用底層數據庫本身提供的主鍵生成標識符，主要用於MySQL，DB2，SQLServer，要求數據庫把主鍵定義成自增長
• sequence：用於Oracle，hibernate根據底層數據庫序列生成標識符，要求數據庫支持序列
• native：根據底層數據庫選擇相對應的生成策略
• uuid:使用uuid生成策略，實體類id屬性必須爲字符串

crud操作

1. Insert

        // 5 insert操作
        User user = new User();
        user.setUsername("root");
        user.setPassword("root");

2. session.save(user);Select

        /*
         * 5 執行查詢操作
         * 調用session的get方法
         * 第一個參數：實體類的class
         * 第二個參數：id值
         */
        User user = session.get(User.class, 1);
        System.out.println(user);

3. Update

        //5 執行修改操作
        //5.1 根據id查詢
        User user = session.get(User.class, 1);
        //5.2 set方法設置
        user.setPassword("123");
        //5.3 調用session的update方法修改（底層通過id來進行修改）
        session.update(user);

4. Delete

        //5 執行刪除操作
        //第一種 ：根據id查詢對象，調用session對象delete方法
        User user = session.get(User.class, 2);
        session.delete(user);
        //第二種：
        User user2 = new User();
        user2.setId(3);
        session.delete(user2);

Hibernate緩存

1. 緩存：

數據存在數據庫中，數據庫本身是一個文件系統，使用流方式存取數據，效率低。
通過把數據存入內存中，不需要使用流方式，可以直接在內存中讀取數據，效率高。

2. Hibernate一級緩存

（1）hibernate一級緩存默認打開
（2）使用範圍：session範圍，從session創建到session關閉
（3）存儲數據 持久態數據

3. Hibernate二級緩存

（1）很少使用，redis替代
（2）範圍：SessionFactory範圍

Hibernate本地線程綁定session

（1）在覈心配置文件中進行配置

<!-- 本地線程綁定Session -->
<property name="hibernate.current_session_context_class">thread</property>

（2）調用SessionFactory中方法

public static Session getSession() {
    return SESSION_FACTORY.getCurrentSession();
}

Hibernate的API

1. Query對象

參數是hql語句

            //創建Query對象
            Query query = session.createQuery("from User");
            //調用query對象裏的list方法得到結果
            List<User> list = query.list();

2. Criteria對象

參數是實體類.class

            //創建criteria對象
            Criteria criteria = session.createCriteria(User.class);
            //調用criteria對象裏的list方法得到結果
            List<User> list = criteria.list();

3. SQLQuery對象

Hibernate一對多操作（兩張表間通過外鍵建立一對多關係）

1. 一對多映射配置

以學生班級爲例：一個學生對應一個班級，一個班級對應多個學生
（1）創建學生、班級實體類，並建立聯繫
學生類：

//一個學生對應一個班級
    private Classs classs;
    public Classs getClasss() {
        return classs;
    }
    public void setClasss(Classs classs) {
        this.classs = classs;
    }

班級類：

//一個班級對應多個學生
    private Set<Student> students = new HashSet<>();
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }

（2）配置映射文件
學生映射文件

<class name="com.wzw.hibernate.model.Student" table="student">
        <id name="sId" column="sid">
            <generator class="native"></generator>
        </id>
        <property name="sName" column="sname"></property>
        <property name="sAge" column="sage"></property>
        <!-- 表示學生所屬的班級 
            name屬性：班級實體類的classs對象名稱
            class屬性:Classs全路徑
            column屬性：外鍵名稱
        -->
        <many-to-one name="classs" class="com.wzw.hibernate.model.Classs" column="cid"></many-to-one>
    </class>

班級映射文件

<class name="com.wzw.hibernate.model.Classs" table="class">
        <id name="cId" column="cid">
            <generator class="native"></generator>
        </id>
        <property name="cName" column="cname"></property>
        <!-- 在班級類映射文件中，表示班級所擁有的全部學生
            set標籤：
            name屬性：在班級實體類中表示學生的set集合名稱
         -->
        <set name="students">
            <!-- 一對多建表，有外鍵
                hibernate：雙向維護外鍵，既一和多雙方都要配置
             -->
             <key column="sid"></key>
             <!-- 班級的所有學生,class裏寫學生的全路徑-->
             <one-to-many class="com.wzw.hibernate.model.Student"/>
        </set>
    </class>

（3）創建核心配置文件，將映射文件引入核心配置文件中

<!-- hibernate自動創建表
            update：如果已經有表，更新；如果沒有，創建
         -->
        <property name="hibernate.hbm2ddl.auto">update</property> 
        <!-- <property name="hibernate.hbm2ddl.auto">update</property> -->
        <!-- 配置數據庫方言
            在MySQL裏實現分頁關鍵字 limit，只能在MySQL裏使用
            在Oracle中，rownum
            讓hibernate框架識別不同數據庫的語句
         -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- 3 把映射文件放到核心配置文件中 -->
        <mapping resource="com/wzw/hibernate/model/Classs.hbm.xml"/>
        <mapping resource="com/wzw/hibernate/model/Student.hbm.xml"/>

2. 一對多級聯保存

            // 添加
            // 1 創建學生對象與班級對象
            Student student = new Student();
            student.setsName("wzw");
            student.setsAge(16);

            Classs classs = new Classs();
            classs.setcName("104班");
            //2 建立學生與班級間聯繫
            student.setClasss(classs);
            classs.getStudents().add(student);
            //3 insert
            session.save(classs);
            session.save(student);

3. 一對多級聯刪除

（1）獲取待刪除班級id
（2）根據班級id獲取班級學生
（3）刪除學生
（4）刪除班級

Hibernate多對多操作（兩張表間通過第三張表建立多對多關係）

一個用戶對應多個角色，一個角色對應多個用戶

1. 多對多映射配置

（1）創建用戶、角色實體類，並建立聯繫
用戶類：

    //一個用戶對應多個角色
    private Set<Role> roles = new HashSet<>();
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

角色類：

    //一個角色對應多個用戶
    private Set<User> users = new HashSet<>();  
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }

（2）配置映射文件
User：

<!-- name:Set<Role> roles
        table:第三張表名稱
-->
<set name="roles" table="user_role">
<!-- key標籤column屬性：配置當前的映射文件user在第三張表中外鍵的名稱user_id -->
    <key column="user_id"></key>
        <!-- class:Role全路徑
            column：Role在第三張表中外鍵的名稱role_id
        -->
    <many-to-many class="com.wzw.hibernate.model.Role" column="role_id"></many-to-many>
</set>

Role：

<set name="users" table="user_role">
    <key column="role_id"></key>
    <many-to-many class="com.wzw.hibernate.model.User" column="user_id"></many-to-many>
</set>

（3）創建核心配置文件，並將映射文件引入配置文件中

        <!-- 3 把映射文件放到核心配置文件中 -->
        <mapping resource="com/wzw/hibernate/model/User.hbm.xml"/>
        <mapping resource="com/wzw/hibernate/model/Role.hbm.xml"/>

2. 多對多級聯保存

Role.hbm.xml:

<set name="users" table="user_role" cascade="save-update">

User.hbm.xml:

<set name="roles" table="user_role" cascade="save-update">

            //級聯保存
            //1 創建用戶與角色對象
            User user1 = new User();
            User user2 = new User();
            user1.setUsername("zhangsan");
            user1.setPassword("123");
            user2.setUsername("lisi");
            user2.setPassword("123");

            Role role1 = new Role();
            Role role2 = new Role();
            Role role3 = new Role();
            role1.setRole_name("root");
            role2.setRole_name("S");
            role3.setRole_name("A");

            //2 User與Role建立聯繫
            //user1--role1/role2
            //user2--role2/role3
            user1.getRoles().add(role1);
            user2.getRoles().add(role2);
            user2.getRoles().add(role2);
            user2.getRoles().add(role3);

            //3 添加
            session.save(user1);
            session.save(user2);

3. 多對多級聯刪除

HIbernate查詢方式

1. 對象導航查詢

根據id查詢A對象，再查詢A中的B對象（Set）

2. OID查詢

根據id查詢某條記錄，返回對象

3. hql查詢

Query對象，hql語句

4. QBC查詢

Criteria對象

5. 本地sql查詢

SQLQuery對象，sql語句

（懶加載）Hibernate檢索策略

1. hibernate檢索策略分爲兩類：

get()立即查詢:
根據id查詢，調用get方法，一調用get方法馬上發送查詢語句查詢數據庫
load()延遲查詢：
根據id查詢，調用load方法，不會馬上發送查詢語句查詢數據庫，只有得到對象裏面的值時纔會發送語句查詢

2. 延遲查詢分爲兩類

類級別延遲
根據id查詢返回實體類對象，調用load方法不會馬上發送語句
關聯級別延遲
先查詢A，再查詢A中所有的B，而這個過程是否需要延遲，這個過程稱爲關聯級別延遲