Java框架之Hibernate實戰篇-有解無憂

從零開始Hibernate實戰篇：（四篇實戰代碼，循序漸進，注意事項和學習內容在代碼注釋里面，面向有一定基礎的同學使用）

第一篇：基礎篇(搭建)

Hibernate開發基本步驟：

1.匯入jar包（hibernate-release-5.0.7.Final\lib的檔案里面去找所需要的jar包）

2.寫物體類+物體類的映射檔案

User.java

/**
 * Project Name:hibernate_demo
 * File Name:User.java
 * Package Name:cn.itcast.entity
 *
*/

package cn.itcast.entity;

/**
 * @author zhouP
 * @version
 * @see
 */
public class User {

    // hibernate要求物體類有一個屬性唯一的
    private int uid;

    private String username;

    private String password;

    private String address;

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getUid() {
        return uid;
    }

}

User.hbm.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>
    <!-- 1.配置類和表對應 class屬性：物體類全路徑（類路徑） table屬性：資料庫表名稱 -->
    <class name="cn.itcast.entity.User" table="t_user">
        <!-- 2.配置物體類id與表id對應 hibernate要求物體類有一個屬性唯一值 hibernate要求表有欄位作為唯一值 -->
        <!-- id標簽 name屬性：物體類里面id屬性名稱 column屬性：生成的表欄位名稱 -->
        <id name="uid" column="uid">
            <!-- 配置資料庫表id的增長策略 native:主鍵自動增長 -->
            <generator class="native"></generator>
        </id>

        <!-- 配置其他屬性和表欄位對應 name屬性：物體類屬性名稱 column屬性：生成表欄位名稱 -->
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="address" column="address"></property>
        
    </class>

</hibernate-mapping>

3.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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate_test</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>

<!-- 第二部分：配置hibernate資訊（可選的） -->
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<!-- 兩個重要配置ddl、dialect(分頁時用) -->
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<!-- 第三部分：把映射檔案放到核心組態檔中（必須的）（檔案路徑） -->
<mapping resource="cn/itcast/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>

4.撰寫Hibernate工具類

package cn.itcast.utils;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {

    // 創建sessionFactory的程序，特別浪費資源，建議一個專案一般創建一個sessionFactory物件
    // static Configuration cfg = null;

    static SessionFactory sessionFactory = null;
    // 靜態代碼塊實作
    static {
        // cfg = new Configuration();
        // cfg.configure();
        // sessionFactory = cfg.buildSessionFactory();
        sessionFactory = new Configuration().configure().buildSessionFactory();

    }

    // 提供方法回傳sessionFactory
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

}

5.測驗代碼

package cn.itcast.hibernatetest;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

public class HibernateDemo {

    @Test
    public void testAdd() {
        // 第一步：加載hibernate核心組態檔
        // Configuration cfg = new Configuration();
        // cfg.configure();
        // 第二步：創建SessionFactory物件
        // SessionFactory sessionFactory = cfg.buildSessionFactory();

        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        // 第三步：使用SessionFactory創建session物件
        Session session = sessionFactory.openSession();
        // 第四步：開啟事務
        Transaction tx = session.beginTransaction();

        // 第五步：寫具體的邏輯 curd操作
        // 添加功能
        User user = new User();
        user.setUsername("Mr Li");
        user.setPassword("1234");
        user.setAddress("武漢");

        // 呼叫session的方法實作添加
        session.save(user);

        // 第六步：提交事務
        tx.commit();
        // 第七步：關閉資源
        session.close();
        sessionFactory.close();

    }

}

第二篇：Hibernate API 練習篇

1.創建專案（略）2.匯入jar包（略）3.物體類+其映射檔案（略）

4.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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql:///hibernate_test2</property>
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">root</property>
    
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    <property name="hibernate.show_sql">true</property>
    <property name="hibernate.format_sql">true</property>
    <property name="hibernate.hbm2ddl.auto">update</property>
    
    <!-- 在hibernate核心組態檔中配置 -->
    <property name="hibernate.current_session_context_class">thread</property>
    <!-- 把映射檔案放到hibernate核心組態檔當中 -->
    <mapping resource="cn/itcast/entity/User.cfg.xml"/>
    </session-factory>    
    </hibernate-configuration>

5.Hibernate相關測驗代碼：

（1）HibernateDemo.java

package cn.itcast.hibernatetest;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;


public class HibernateDemo {

    @Test
    public void testSaveOrUpdate() {
        // 1.呼叫工具類得到sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        // 2.獲取session
        Session session = sessionFactory.openSession();
        // 3.開啟事務
        Transaction tx = session.beginTransaction();
        // 4.添加操作
        // User user = new User();
        // user.setUid(1);
        // user.setUsername("王第一");
        // user.setPassword("12345");
        // user.setAddress("杏林二小");
        // session.save(user);

        // 把uid=1的記錄username修改
        // User user = new User();
        // user.setUid(1);
        // user.setUsername("韓梅梅梅");
        // session.save(user);要用update
        // session.update(user);

        // User user = session.get(User.class, 2);
        // user.setAddress("興隆林業局");
        // // 物體類物件是持久態，做修改
        // session.saveOrUpdate(user);

        // User user = new User();
        // user.setUsername("rose");
        // user.setPassword("1314");
        // user.setAddress("阿爾巴尼亞");
        // session.save(user);

        // User user = new User();
        // user.setUsername("jack");
        // user.setPassword("520");
        // user.setAddress("朝鮮");
        // session.save(user);

        User user = new User();
        user.setUsername("jack");
        user.setPassword("124");
        user.setAddress("china");
        session.save(user);

        // 5.提交事務
        try {
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            // 6.關閉資源
            session.close();
            sessionFactory.close();
        }

    }

    @Test
    public void testDelete() {
        // 1.利用工具類創建sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        // 2.得到session
        Session session = sessionFactory.openSession();
        // 3.開啟事務
        Transaction tx = session.beginTransaction();
        // 4.洗掉操作
        // 第一種洗掉方法
        // User user = session.get(User.class, 1);
        // session.delete(user);

        // 第二種洗掉方法
        User user = new User();
        user.setUid(3);
        session.delete(user);

        // 5.提交事務
        try {
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            // 6.關閉資源
            session.close();
            sessionFactory.close();
        }

    }

    @Test
    public void testUpdate() {
        // 1.工具類中得到sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        // 2.得到session
        Session session = sessionFactory.openSession();
        // 3.開啟事務
        Transaction tx = session.beginTransaction();
        // 4.更新操作(修改uid=2記錄的username值)
        // 4.1根據id查詢(如果資料庫中沒有此id，執行的是查詢)
        User user = session.get(User.class, 2);
        // 4.2向回傳的username物件里面設定修改之后的值
        user.setUsername("修改之后的值");
        // 4.3呼叫session的update方法
        // 執行程序：到user物件里面找到uid值，根據uid進行修改
        session.update(user);
        // 5.提交事務
        try {
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            // 6.關閉資源
            session.close();
            sessionFactory.close();
        }

    }

}

（2）HibernateQueryData.java

package cn.itcast.hibernatetest;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

public class HibernateQueryData {

    // 使用SQLQuery物件
    @Test
    public void testQuery() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 創建SQLQuery物件
            SQLQuery sqlQuery = session.createSQLQuery("select * from t_user");
            // 回傳的list中的每部分是物件的形式
            sqlQuery.addEntity(User.class);
            // 呼叫SQLQuery里面的方法...導包是：import java.util.List;
            @SuppressWarnings("unchecked")
            List<User> list = sqlQuery.list();

            // 驗證：當呼叫SQLQuery方法：回傳的list集合，默認里面每一部分是陣列結構
            for (User user : list) {
                System.out.println(user);
            }
            // List<Object[]> list = sqlQuery.list();
            //
            // for (Object[] objects : list) {
            // System.out.println(Arrays.toString(objects));
            // }
            // 提交事務
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();

        }
    }

    // 使用Criteria物件
    @Test
    public void testCriteria() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            // 創建criteria物件
            Criteria criteria = session.createCriteria(User.class);
            @SuppressWarnings("unchecked")
            List<User> list = criteria.list();
            for (User user : list) {
                System.out.println(user);
            }
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }

    // 使用query物件
    @Test
    public void demoQuery() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = HibernateUtils.getSessionobject();
            // 開啟事務
            tx = session.beginTransaction();

            // 1 創建Query物件
            Query query = session.createQuery("from User");

            // 2 呼叫query物件里面的方法得到結果
            @SuppressWarnings("unchecked")
            List<User> list = query.list();

            // 遍歷list集合四種： 普通for、增強for、迭代器、list迭代器
            // 遍歷set集合兩種：增強for、迭代器
            // 遍歷map集合兩種：得到所有key，根據key得到value； 得到key-value關系
            for (User user : list) {
                System.out.println(user);
            }

            // 提交事務
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }
}

（3）HibernateSelect.java

package cn.itcast.hibernatetest;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

public class HibernateSelect {

    // 事務規范代碼
    @Test
    public void testTx() {
        Session session = null;
        Transaction tx = null;
        try {
            // 于本地執行緒系結的session
            session = HibernateUtils.getSessionobject();
            // 開啟事務
            tx = session.beginTransaction();

            // 添加
            User user = new User();
            user.setAddress("華豐");
            user.setPassword("789");
            user.setUsername("化華");

            session.save(user);

            // 模擬出事情了：java.lang.ArithmeticException: / by zero
            // 10/0 此時，不能插入資料

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // 下面session不能關閉，JUnit關倍訓報錯，可以插入資料，
            // org.hibernate.SessionException: Session was already closed
            // org.hibernate.SessionException: Session was already closed
            // session.close();
        }

    }

    // 一級快取特性
    @Test
    public void testDemo() {

        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;

        try {
            // 1.呼叫工具類得到sessionFactory
            sessionFactory = HibernateUtils.getSessionFactory();
            // 2.獲取session
            session = sessionFactory.openSession();

            // 3.開啟事務
            tx = session.beginTransaction();
            // 4.操作：查詢
            User user = session.get(User.class, 5);

            user.setAddress("之前室china，現在是哈爾濱");
            session.update(user);

            // 5.提交事務
            tx.commit();

        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // 6.關閉資源
            session.close();
            sessionFactory.close();
        }

    }

    // 驗證一級快取存在
    @Test
    public void testCasch() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.根據id=2查詢
            // 執行第一個get方法是否查詢資料庫，是否發送陳述句
            User user1 = session.get(User.class, 2);
            System.out.println(user1);

            // 2.在 根據id查詢
            // 執行第二個get方法是否查詢資料庫，是否發送陳述句
            // 結果是！只有一條查詢陳述句，兩條查詢結果
            User user2 = session.get(User.class, 2);
            System.out.println(user2);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }

}

第三篇：Hibernate 一對多、多對多實戰篇

1.cn.itcast.entity包里面：

（1）Customer.java

package cn.itcast.entity;

import java.util.HashSet;
import java.util.Set;

public class Customer {
    // 用戶id
    private Integer cid;

    // 用戶名稱
    private String custName;

    // 用戶級別
    private String custLevel;

    // 用戶來源
    private String custSource;

    // 聯系電話
    private String custPhone;

    // 手機
    private String custMobile;

    // 在客戶物體類里面表示多個聯系人，一個客戶有多個聯系人
    // hibernate要求使用集合表示多的資料，使用set集合:
    // import java.util.HashSet;import java.util.Set;
    private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();

    public Set<LinkMan> getSetLinkMan() {
        return setLinkMan;
    }

    public void setSetLinkMan(Set<LinkMan> setLinkMan) {
        this.setLinkMan = setLinkMan;
    }

    public Integer getCid() {
        return cid;
    }

    public void setCid(Integer cid) {
        this.cid = cid;
    }

    public String getCustName() {
        return custName;
    }

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

    public String getCustLevel() {
        return custLevel;
    }

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

    public String getCustSource() {
        return custSource;
    }

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

    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;
    }

}

Customer.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>
<!-- 1.配置類和表對應
       class標簽
       name屬性：物體類的全路徑
       table屬性：資料庫表名稱 -->
<class name="cn.itcast.entity.Customer" table="t_customer">
<id name="cid" column="cid">
<generator class="native"></generator>
</id>
<property name="custName" column="custName"></property>
<property name="custLevel" column="custLevel"></property>
<property name="custSource" column="custSource"></property>
<property name="custPhone" column="custPhone"></property>
<property name="custMobile" column="custMobile"></property>

<!-- 在客戶映射檔案中，表示所有聯系人
     使用set標簽：表示所有聯系人
     set標簽里面有name屬性：屬性值寫在客戶物體類里面，表示聯系人的set集合名稱 
     reverse屬性默認值：false表示不放棄維護
                    true表示放棄維護-->
<set name="setLinkMan" inverse="true">
<!-- 一對多建表，有外鍵
     hibernate機制：雙向維護外鍵，在一和多那一方都配置外鍵
     column屬性值：外鍵名稱
      -->
<key column="clid"></key>
<!-- 客戶所有的聯系人，class里面寫聯系人物體類全路徑 -->
<one-to-many class="cn.itcast.entity.LinkMan"/>
</set>
</class>
</hibernate-mapping>

（2）LinkMan.java

package cn.itcast.entity;

public class LinkMan {
    // 聯系人編號（主鍵）
    private Integer lkm_id;

    // 聯系人姓名
    private String lkm_name;

    // 聯系人性別
    private String lmk_gender;

    // 聯系人辦公電話
    private String lkm_phone;

    // 在聯系人物體類里面表示所有客戶，一個聯系人只能屬于一個客戶
    // Customer customer=new Customer();
    private Customer customer;

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public Integer getLkm_id() {
        return lkm_id;
    }

    public void setLkm_id(Integer lkm_id) {
        this.lkm_id = lkm_id;
    }

    public String getLkm_name() {
        return lkm_name;
    }

    public void setLkm_name(String lkm_name) {
        this.lkm_name = lkm_name;
    }

    public String getLmk_gender() {
        return lmk_gender;
    }

    public void setLmk_gender(String lmk_gender) {
        this.lmk_gender = lmk_gender;
    }

    public String getLkm_phone() {
        return lkm_phone;
    }

    public void setLkm_phone(String lkm_phone) {
        this.lkm_phone = lkm_phone;
    }

}

LinkMan.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="cn.itcast.entity.LinkMan" table="t_linkman">
<id name="lkm_id" column="lkm_id">
<generator class="native"></generator>
</id>
<property name="lkm_name" column="lkm_name"></property>
<property name="lmk_gender" column="lmk_gender"></property>
<property name="lkm_phone" column="lkm_phone"></property>

<!-- 表示聯系人所屬客戶
    name屬性：因為在聯系人物體類使用customer物件表示，寫customer名稱
    class屬性：customer全路徑
    column屬性：外鍵名稱 -->
    <many-to-one name="customer" class="cn.itcast.entity.Customer" column="clid"></many-to-one>
</class>
</hibernate-mapping>

2.HibernateUtils包里面的HibernateUtils.java工具類，添加本地執行緒系結的session的方法

package cn.itcast.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {

    // 加載核心組態檔，靜態代碼塊實作
    static Configuration cfg = null;

    static SessionFactory sessionFactory = null;
    static {
        cfg = new Configuration();
        cfg.configure();
        sessionFactory = cfg.buildSessionFactory();
    }

    // 提供回傳與本地執行緒系結的session的方法
    public static Session getSessionObject() {
        return sessionFactory.getCurrentSession();
    }

    // 提供方法回傳sessionFactory
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void main(String[] args) {

    }
}

3.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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate_test3</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!-- 第二部分：配置hibernate資訊，可選 -->
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 配置資料庫方言
    在mysql里面實作分頁，關鍵字limit，只能用在mysql里面
    在oracle資料庫，實作分頁rownum
    讓hibernate框架識別不同資料庫的自己特有的陳述句 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.current_session_context_class">thread</property>
<!-- 第三部分：把映射檔案放到核心組態檔中，必須的-->
<mapping resource="cn/itcast/entity/Customer.hbm.xml"/>
<mapping resource="cn/itcast/entity/LinkMan.hbm.xml"/>

<mapping resource="cn/itcast/manytomany/User.hbm.xml"/>
<mapping resource="cn/itcast/manytomany/Role.hbm.xml"/>


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

4.Hibernatetest包

(1)HibernateOnetoMany.java

package hibernatetest;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.Customer;
import cn.itcast.entity.LinkMan;
import cn.itcast.utils.HibernateUtils;


public class HibernateOnetoMany {

    // 演示:一對多級聯保存
    @Test
    public void testUpdate() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 添加一個客戶，為這個客戶添加一個聯系人
            // 1 創建客戶和聯系人物件
            Customer customer = new Customer();
            customer.setCustLevel("vip");
            customer.setCustMobile("8888");
            customer.setCustName("橡果國際");
            customer.setCustPhone("18345782345");
            customer.setCustSource("上海");

            LinkMan linkman = new LinkMan();
            linkman.setLkm_name("王小卓");
            linkman.setLkm_phone("173456379876");
            linkman.setLmk_gender("女");

            // 2 在客戶表示所有聯系人，在聯系人表示客戶
            // 建立客戶物件和聯系人物件關系
            // 2.1 把聯系人物件 放到客戶物件的set集合里面
            customer.getSetLinkMan().add(linkman);
            // 2.2 把客戶物件放到聯系人里面
            linkman.setCustomer(customer);

            // 3 保存到資料庫
            session.save(customer);
            session.save(linkman);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }

    // 演示:一對多級聯保存
    @Test
    public void testAddDemo2() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            Customer customer = new Customer();
            customer.setCustLevel("普通");
            customer.setCustName("奧克斯");
            customer.setCustPhone("18932222237");
            customer.setCustSource("北京");

            LinkMan linkman = new LinkMan();
            linkman.setLkm_name("陳小橋");
            linkman.setLkm_phone("15024324567");
            linkman.setLmk_gender("女");

            customer.getSetLinkMan().add(linkman);
            // 少了這句，linkman.setCustomer(customer);只執行t_customer表的insert陳述句
            // 添加它和session.save(linkman);，則t_linkman表中添加的新資料（陳小橋）才會加進去
            linkman.setCustomer(customer);

            // save() 保存要有哦！
            session.save(customer);
            session.save(linkman);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // sessionFactory.close();
            // session.close();
        }
    }

    // 演示：一對多級聯洗掉
    @Test
    public void testDeleteDemo() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.根據id查詢客戶物件
            Customer customer = session.get(Customer.class, 12);
            // 2.呼叫洗掉方法
            session.delete(customer);
            // 3.提交事務
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            // sessionFactory.close();
        }
    }

    // 演示：一對多修改
    @Test
    public void testUpdateDemo() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            // 1.根據id查詢聯系人，根據id查詢客戶
            Customer customer1 = session.get(Customer.class, 3);
            LinkMan linkman1 = session.get(LinkMan.class, 1);
            // 2.設定持久態物件值
            // i.把聯系人放到客戶里面
            customer1.getSetLinkMan().add(linkman1);
            // ii.把客戶放到聯系人里面
            linkman1.setCustomer(customer1);
            // 3.提交事務
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            // sessionFactory.close();
        }

    }

}

(2)HibernateManytoMany.java

package hibernatetest;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.manytomany.Role;
import cn.itcast.manytomany.User;
import cn.itcast.utils.HibernateUtils;


public class HibernateManytoMany {
    // 演示維護第三張表
    @Test
    public void testTable1() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 讓某個用戶擁有某個角色
            // 1.查詢
            User user1 = session.get(User.class, 2);
            Role role1 = session.get(Role.class, 2);
            // 2.放
            user1.getSetRole().add(role1);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            // sessionFactory.close();
        }
    }

    // 演示：維護第三張表
    @Test
    public void testTable2() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 讓某個用戶沒有某個角色
            User user2 = session.get(User.class, 2);
            Role role2 = session.get(Role.class, 3);

            // 從用戶里面把角色去掉
            user2.getSetRole().remove(role2);
            // 提交事務
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            // sessionFactory.close();
        }

    }

    // 演示：多對多級聯洗掉
    @Test
    public void testSave() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 添加兩個用戶，為每個用戶相加兩個角色
            // 1.創建物件
            User user3 = new User();
            user3.setUser_name("春花");
            user3.setUser_password("8766899");

            User user4 = new User();
            user4.setUser_name("mary");
            user4.setUser_password("456");

            Role role3 = new Role();
            role3.setRole_name("pig");
            role3.setRole_memo("粉色的");

            Role role4 = new Role();
            role4.setRole_name("秘書");
            role4.setRole_memo("秘書");

            Role role5 = new Role();
            role5.setRole_name("保安");
            role5.setRole_memo("保安");

            // 2.建立關系，把角色放到用戶里面
            user3.getSetRole().add(role3);
            user3.getSetRole().add(role4);

            user4.getSetRole().add(role4);
            user4.getSetRole().add(role5);

            // 3.保存
            session.save(user3);
            session.save(user4);

            // 4.提交事務
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            // sessionFactory.close();
        }
    }

    // 演示：多對多級聯保存
    @Test
    public void testDelete() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            User user5 = session.get(User.class, 1);
            session.delete(user5);
            // 提交事務
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            // sessionFactory.close();
        }
    }
}

5.cn.itcast.manytomany包

(1)Role.java

package cn.itcast.manytomany;

import java.util.HashSet;
import java.util.Set;

public class Role {

    private Integer role_id;

    private String role_name;

    private String role_memo;

    // 一個角色有多個客戶
    private Set<User> setUser = new HashSet<User>();

    public Set<User> getSetUser() {
        return setUser;
    }

    public void setSetUser(Set<User> setUser) {
        this.setUser = setUser;
    }

    public Integer getRole_id() {
        return role_id;
    }

    public void setRole_id(Integer role_id) {
        this.role_id = role_id;
    }

    public String getRole_name() {
        return role_name;
    }

    public void setRole_name(String role_name) {
        this.role_name = role_name;
    }

    public String getRole_memo() {
        return role_memo;
    }

    public void setRole_memo(String role_memo) {
        this.role_memo = role_memo;
    }

}

Role.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>
<!-- 1.配置類和表對應
    class標簽
    name屬性：物體類的全路徑
    table屬性：資料庫表名稱 -->
<class name="cn.itcast.manytomany.Role" table="t_role">
<id name="role_id" column="role_id">
<generator class="native"></generator>
</id>
<property name="role_name" column="role_name"></property>
<property name="role_memo" column="role_memo"></property>
<!-- 在角色里面表示所有用戶，使用set標簽 -->
<set name="setUser" table="user_role">
<!-- 角色在第三張表外鍵 -->
<key column="roleid"></key>
<many-to-many class="cn.itcast.manytomany.User" column="userid"></many-to-many>
</set>
</class>
</hibernate-mapping>

（2）User.java

package cn.itcast.manytomany;

import java.util.HashSet;
import java.util.Set;

public class User {

    private Integer user_id;

    private String user_name;

    private String user_password;

    // 一個用戶可以有多個角色
    private Set<Role> setRole = new HashSet<Role>();

    public Set<Role> getSetRole() {
        return setRole;
    }

    public void setSetRole(Set<Role> setRole) {
        this.setRole = setRole;
    }

    public Integer getUser_id() {
        return user_id;
    }

    public void setUser_id(Integer user_id) {
        this.user_id = user_id;
    }

    public String getUser_name() {
        return user_name;
    }

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    public String getUser_password() {
        return user_password;
    }

    public void setUser_password(String user_password) {
        this.user_password = user_password;
    }

}

User.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="cn.itcast.manytomany.User" table="t_user">
<id name="user_id" column="user_id">
<generator class="native"></generator>
</id>
<property name="user_name" column="user_name"></property>
<property name="user_password" column="user_password"></property>
<!-- 在用戶里面表示所有角色，使用set標簽
    name屬性：角色set集合名稱
    table屬性：第三張表名稱 -->
<set name="setRole" table="user_role" cascade="save-update,delete">
<!-- key標簽里面的配置
    配置當前映射檔案在第三張表外鍵的名稱
     -->
<key column="userid"></key>
<!-- class標簽：角色物體類的全路徑
    column標簽：角色在第三張表外鍵名稱 -->
<many-to-many class="cn.itcast.manytomany.Role" column="roleid"></many-to-many>
</set>
</class>
</hibernate-mapping>

第四篇：HQL、QBC 、查詢、檢索策略、批量抓取等相關練習篇

1.cn.itcast.entity包

(1)Cutomer.java

package cn.itcast.entity;

import java.util.HashSet;
import java.util.Set;

public class Customer {
    private Integer cid;

    private String custName;

    private String custLevel;

    private String custSource;

    private String custPhone;

    private String custMobile;

    // 在客戶物體類里面表示多個聯系人，一個客戶有多個聯系人
    private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();

    public Set<LinkMan> getSetLinkMan() {
        return setLinkMan;
    }

    public void setSetLinkMan(Set<LinkMan> setLinkMan) {
        this.setLinkMan = setLinkMan;
    }

    public Integer getCid() {
        return cid;
    }

    public void setCid(Integer cid) {
        this.cid = cid;
    }

    public String getCustName() {
        return custName;
    }

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

    public String getCustLevel() {
        return custLevel;
    }

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

    public String getCustSource() {
        return custSource;
    }

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

    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;
    }

}

Customer.hbm.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="cn.itcast.entity.Customer" table="t_customer">
    <id name="cid" column="cid">
    <generator class="native"></generator>
    </id>
    <property name="custName" column="custName"></property>
    <property name="custLevel" column="custLevel"></property>
    <property name="custSource" column="custSource"></property>
    <property name="custPhone" column="custPhone"></property>
    <property name="custMobile" column="custMobile"></property>
    <!-- 在客戶映射檔案中，表示所有聯系人 
            使用set標簽表示所有聯系人
            set標簽里面有name屬性：
                 屬性值寫在客戶物體類里面表示聯系人的set集合名稱
                 
             inverse屬性默認值：false不放棄關系維護
                            true表示放棄關系維護
        -->
    <set name="setLinkMan" batch-size="10">
    <!-- 一對多建表，有外鍵
                hibernate機制：雙向維護外鍵，在一和多那一方都配置外鍵    
                column屬性值：外鍵名稱
             -->
    <key column="clid"></key>
    <one-to-many class="cn.itcast.entity.LinkMan"/>
    </set>
    </class>
    </hibernate-mapping>

(2).LinkMan.java

package cn.itcast.entity;

public class LinkMan {
    private Integer lkm_id; // 聯系人編號(主鍵)

    private String lkm_name;// 聯系人姓名

    private String lkm_gender;// 聯系人性別

    private String lkm_phone;// 聯系人辦公電話

    // 在聯系人物體類中表示所屬客戶，一個聯系人只能有一個客戶
    private Customer customer;

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public Integer getLkm_id() {
        return lkm_id;
    }

    public void setLkm_id(Integer lkm_id) {
        this.lkm_id = lkm_id;
    }

    public String getLkm_name() {
        return lkm_name;
    }

    public void setLkm_name(String lkm_name) {
        this.lkm_name = lkm_name;
    }

    public String getLkm_gender() {
        return lkm_gender;
    }

    public void setLkm_gender(String lkm_gender) {
        this.lkm_gender = lkm_gender;
    }

    public String getLkm_phone() {
        return lkm_phone;
    }

    public void setLkm_phone(String lkm_phone) {
        this.lkm_phone = lkm_phone;
    }

}

LinkMan.hbm.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="cn.itcast.entity.LinkMan" table="t_linkman">
    <id name="lkm_id" column="lkm_id">
    <generator class="native"></generator>
    </id>
    <property name="lkm_name" column="lkm_name"></property>
    <property name="lkm_gender" column="lkm_gender"></property>
    <property name="lkm_phone" column="lkm_phone"></property>
   
    <!-- 表示聯系人所屬客戶 
            name屬性：因為在聯系人物體類使用customer物件表示，寫customer名稱
            class屬性：customer全路徑
            column屬性：外鍵名稱
        -->
    <many-to-one name="customer" class="cn.itcast.entity.Customer" column="clid"></many-to-one>
    </class>
    </hibernate-mapping>

2.utils包(同上)

HibernateUtils.java

package ustils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {

    static Configuration cfg = null;

    static SessionFactory sessionFactory = null;
    static {
        cfg = new Configuration();
        cfg.configure();
        sessionFactory = cfg.buildSessionFactory();
    }

    public static Session getSessionobject() {
        return sessionFactory.getCurrentSession();
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void main(String[] args) {

    }
}

3.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="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql:///hibernate_test4</property>
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">root</property>
    
    <property name="hibernate.show_sql">true</property>
    <property name="hibernate.format_sql">true</property>
    <property name="hibernate.hbm2ddl.auto">update</property>
    <property name="hibernate.current_session_context_class">thread</property>
    
    <mapping resource="cn/itcast/entity/Customer.hbm.xml"/>
    <mapping resource="cn/itcast/entity/LinkMan.hbm.xml"/>
    </session-factory>
    </hibernate-configuration>

4.cn.itcast.hibernantetest包

（1）HibernateDemo.java

package cn.itcast.hibernantetest;

import java.util.List;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.Customer;
import cn.itcast.entity.LinkMan;
import ustils.HibernateUtils;

public class HibernateDemo {

    // 演示物件導航查詢
    @Test
    public void testSelect1() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;

        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.查詢cid=1客戶
            Customer customer = session.get(Customer.class, 1);
            // 2.再查詢這個客戶里面的所有聯系人(此時，得到set集合，沒有發送陳述句)
            Set<LinkMan> linkman = customer.getSetLinkMan();

            // 發送了陳述句
            System.out.println(linkman.size());

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }

    // 演示檢索策略
    @Test
    public void testSelect2() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;

        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 根據cid=1客戶
            // 執行get方法之后是否發送sql陳述句
            // 呼叫get方法馬上發送sql陳述句查詢資料庫
            // Customer customer = session.get(Customer.class, 1);
            // System.out.println(customer.getCid());
            /*
             * 1 呼叫load方法之后，不會馬上發送sql陳述句 （1）回傳物件里面只有 id值
             * 
             * 2 得到物件里面不是id的其他值時候才會發送陳述句
             */
            Customer customer = session.load(Customer.class, 1);
            System.out.println(customer.getCid());
            System.out.println(customer.getCustName());

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }

    // 演示批量抓取
    @Test
    public void testSelect3() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;

        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 查詢所有客戶
            Criteria criteria = session.createCriteria(Customer.class);
            // 得到每個客戶里面所有的聯系人
            List<Customer> list = criteria.list();

            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
                // 每個客戶里面的所有聯系人
                Set<LinkMan> setlinkman = customer.getSetLinkMan();
                for (LinkMan linkMan : setlinkman) {
                    System.out.println((linkMan.getLkm_id() + "::" + linkMan.getLkm_name()));
                }
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }
}

（2）HibernateHQL.java

package cn.itcast.hibernantetest;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.Customer;
import ustils.HibernateUtils;

public class HibernateHQL {

    // 演示查詢所有
    @Test
    public void testSelect1() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建query物件
            Query query = session.createQuery("from Customer");
            // 2.呼叫方法得到結果
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示條件查詢
    @Test
    public void testSelect2() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建query物件
            // SELECT *FROM t_customer WHERE cid=? AND custName=?
            Query query = session.createQuery("from Customer c where c.cid=? and c.custName=?");
            // 2.設定條件
            // 向？里面設定值
            // setParameter方法兩個引數
            // 第一個引數：int型別是？位置，？位置從0開始
            // 第二個引數：具體引數值
            // 設定第一個？值
            query.setParameter(0, 1);
            // 設定第二個？值
            query.setParameter(1, "百度");
            // 3.呼叫方法得到結果
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示條件查詢-模糊查詢
    @Test
    public void testSelect3() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建query物件
            Query query = session.createQuery("from Customer c where c.custName like ?");
            // 2.設定？的值
            query.setParameter(0, "%蒂%");
            // 3.呼叫方法得到結果
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示：排序查詢
    @Test
    public void testSelect4() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建query物件
            Query query = session.createQuery("from Customer order by cid desc");
            // 2.呼叫方法得到結果
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示:分頁查詢
    @Test
    public void testSelect5() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建query物件
            // 寫查詢所有的陳述句
            Query query = session.createQuery("from Customer");
            // 2.設定分頁資料
            // 2.1.設定開始位置
            query.setFirstResult(3);
            // 2.2.設定每頁記錄數
            query.setMaxResults(3);
            // 3.呼叫方法得到結果
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示:投影查詢
    @Test
    public void testSelect6() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建query物件
            Query query = session.createQuery("select custLevel from Customer");
            // 2.呼叫方法得到結果
            List<Object> list = query.list();
            for (Object object : list) {
                System.out.println(object);
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示:聚集函式的使用
    @Test
    public void testSelect7() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建query物件
            Query query = session.createQuery("select count(*) from Customer");
            // 2.呼叫方法得到結果
            // query物件里面有方法，直接回傳物件形式
            Object obj = query.uniqueResult();
            // 回傳int型別
            // int count=(int)obj;

            // 首先把object變成long型別，再變成int型別
            Long lobj = (Long) obj;
            int count = lobj.intValue();
            System.out.println(count);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

}

（3）HibernateQBC.java

package cn.itcast.hibernantetest;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.itcast.entity.Customer;
import ustils.HibernateUtils;


public class HibernateQBC {

    // 演示：查詢所有
    @Test
    public void testSelect1() {

        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建物件
            Criteria criteria = session.createCriteria(Customer.class);
            // 2.呼叫方法得到結果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示：條件查詢
    @Test
    public void testSelect2() {

        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建criteria物件
            Criteria criteria = session.createCriteria(Customer.class);
            // 2.使用criteria物件里面的方法設定條件值
            // 首先使用add方法，表示設定條件值
            // 在add方法里面使用類的方法實作條件設定
            // 類似于cid=？
            // criteria.add(Restrictions.eq("cid", 1));
            // criteria.add(Restrictions.eq("custName", "瑪莎拉蒂"));
            // 上面是eq，下面是like
            criteria.add(Restrictions.like("custName", "%百%"));
            // 3.呼叫方法得到結果
            List<Customer> list = criteria.list();

            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示：排序查詢
    @Test
    public void testSelect3() {

        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建物件
            Criteria criteria = session.createCriteria(Customer.class);
            // 2.設定對哪個屬性進行排序，設定排序規則
            criteria.addOrder(Order.desc("cid"));
            // 3.呼叫方法，得到結果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示：分頁查詢
    @Test
    public void testSelect4() {

        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建物件
            Criteria criteria = session.createCriteria(Customer.class);
            // 2.設定分頁，起始和記錄數
            criteria.setFirstResult(3);
            criteria.setMaxResults(3);
            // 3.呼叫方法得到結果
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示：統計查詢
    @Test
    public void testSelect5() {

        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建物件
            Criteria criteria = session.createCriteria(Customer.class);
            // 2.設定操作
            criteria.setProjection(Projections.rowCount());
            // 3.呼叫方法得到結果
            Object obj = criteria.uniqueResult();
            Long lobj = (Long) obj;
            int count = lobj.intValue();
            System.out.println(count);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

    // 演示：離線查詢
    @Test
    public void testSelect6() {

        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 1.創建物件
            // Criteria criteria = session.createCriteria(Customer.class);
            DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
            // 2.最終執行時候才需要得到session
            Criteria criteria = detachedCriteria.getExecutableCriteria(session);
            List<Customer> list = criteria.list();
            for (Customer customer : list) {
                System.out.println(customer.getCid() + "::" + customer.getCustName());
            }
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }

    }

}

（4）HibernateManyTable.java

package cn.itcast.hibernantetest;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import ustils.HibernateUtils;

public class HibernateManyTable {

    // 演示hql內連接查詢（2種）
    @Test
    public void testSelect1() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 內連接的list回傳的是陣列的形式；迫切內外連接的list放回的是物件的形式
            // Query query = session.createQuery("from Customer c inner join
            // c.setLinkMan");
            // List list = query.list();

            Query query = session.createQuery("from Customer c inner join fetch c.setLinkMan");
            List list = query.list();

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }

    // 演示hql外連接查詢（3種）
    @Test
    public void testSelect2() {
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();

            // 左外連接的list回傳的是陣列的形式；迫切左外連接的list放回的是物件的形式
            // Query query = session.createQuery("from Customer c left outer
            // join c.setLinkMan");
            // List list = query.list();

            // Query query = session.createQuery("from Customer c left outer
            // join fetch c.setLinkMan");
            // List list = query.list();

            // 右外連接，沒有迫切右外連接
            Query query = session.createQuery("from Customer c right outer join fetch c.setLinkMan");
            List list = query.list();

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }
}

Hibernate定義陳述：

Hibernate是一個開放源代碼的物件關系映射框架，它對JDBC進行了非常輕量級的物件封裝，它將POJO與資料庫表建立映射關系，是一個全自動的orm框架，hibernate可以自動生成SQL陳述句，自動執行，使得Java程式員可以隨心所欲的使用物件編程思維來操縱資料庫， Hibernate可以應用在任何使用JDBC的場合，既可以在Java的客戶端程式使用，也可以在Servlet/JSP的Web應用中使用，最具革命意義的是，Hibernate可以在應用EJB的JaveEE架構中取代CMP，完成資料持久化的重任，-------來自百度百科

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/168603.html

標籤：Java

上一篇：Java筆記：陣列，例外，泛型

下一篇：使用python生成包含1000個隨機字符的字串，然后統計每個字符的出現次數。（使用字典）