c3p0 参数 模糊查询_Hibernate day03笔记
Hibernate的關聯關系映射:(多對多)多對多的配置:
步驟一創建實體和映射:
Student:
public class Student {
private Integer sid;
private String sname;
//學生選擇多門課程.
private Set courses = new HashSet();
...
}
Course:
public class Course {
private Integer cid;
private String cname;
//課程可以被多個學生選擇:
private Set students = new HashSet();
...
}
Student.hbm.xml
Course.hbm.xml
抓取策略(優化)檢索方式立即檢索：立即查詢，在執行查詢語句時，立即查詢所有的數據。
延遲檢索：延遲查詢，在執行查詢語句之后，在需要時在查詢。(懶加載)
檢查策略類級別檢索：當前的類的屬性獲取是否需要延遲。
關聯級別的檢索：當前類 關聯 另一個類是否需要延遲。
類級別檢索get：立即檢索。get方法一執行，立即查詢所有字段的數據。
load：延遲檢索。默認情況，load方法執行后，如果只使用OID的值不進行查詢，如果要使用其他屬性值將查詢 。 Customer.hbm.xml
lazy 默認值true，表示延遲檢索，如果設置false表示立即檢索。
@Test
publicvoiddemo02() {
//類級別
Session session = factory.openSession();
session.beginTransaction();
//1立即
//????????Customer customer = (Customer) session.get(Customer.class, 1);
//2延遲
Customer customer = (Customer) session.load(Customer.class, 1);
//打印
System.out.println(customer.getCid());
System.out.println(customer.getCname());
session.getTransaction().commit();
session.close();
}
關聯級別檢索一對多或多對多介紹容器 提供兩個屬性：fetch、lazy
fetch：確定使用sql格式
lazy：關聯對象是否延遲。fetch：join、select、subselect
join：底層使用迫切左外連接
select：使用多個select語句(默認值)
subselect：使用子查詢lazy：false、true、extra
false：立即
true：延遲(默認值)
extra：極其懶惰
fetch="join"fetch="join" ，lazy無效。底層使用迫切左外連接，使用一條select將所有內容全部查詢。
@Test
publicvoiddemo03() {
//關聯級別：一對多，
// * Customer.hbm.xml
// *** select語句使用左外連接，一次性查詢所有
Session session = factory.openSession();
session.beginTransaction();
//1查詢客戶
Customer customer = (Customer) session.get(Customer.class, 1);
System.out.println(customer.getCname());
//2查詢客戶訂單數
Set orderSet = customer.getOrderSet();
System.out.println(orderSet.size());
//3查詢客戶訂單詳情
for(Order order : orderSet) {
System.out.println(order);
}
session.getTransaction().commit();
session.close();
}
fetch="select"當前對象 和 關聯對象 使用多條select語句查詢。
lazy="false" , 立即，先查詢客戶select，立即查詢訂單select
lazy="true",延遲，先查詢客戶select，需要訂單時，再查詢訂單select
lazy="extra"，極其懶惰(延遲)，先查詢客戶select， 如果只需要訂單數，使用聚合函數(不查詢詳情)
fetch="subselect"將使用子查詢。注意：必須使用Query否則看不到效果。
lazy= 同上
@Test
publicvoiddemo04() {
//關聯級別：一對多，
//演示3：* Customer.hbm.xml
Session session = factory.openSession();
session.beginTransaction();
//1查詢客戶
List allCustomer = session.createQuery("from Customer").list();
Customer customer = allCustomer.get(0);
System.out.println(customer.getCname());
//2查詢客戶訂單數
Set orderSet = customer.getOrderSet();
System.out.println(orderSet.size());
//3查詢客戶訂單詳情
for(Order order : orderSet) {
System.out.println(order);
}
session.getTransaction().commit();
session.close();
}
多對一介紹 ()
fetch取值：join、select
join：底層使用迫切左外連接
select：多條select語句lazy取值：false、proxy、no-proxy
false：立即
proxy：采用關聯對象 類級別檢索的策略。
訂單 關聯 客戶 (多對一)
訂單 立即獲得 客戶，需要在客戶Customer.hbm.xml
訂單 延遲獲得 客戶，需要在客戶Customer.hbm.xml
no-proxy 不研究
fetch="join"fecth="join" select語句使用左外連接，此時lazy無效。
@Test
publicvoiddemo05() {
//關聯級別：多對一，
//演示1：* Order.hbm.xml lazy無效
// *注意：檢查Customer.hbm.xml和Order.hbm.xml沒有額外的配置
Session session = factory.openSession();
session.beginTransaction();
//1查詢訂單
Order order = (Order) session.get(Order.class, 1);
System.out.println(order.getPrice());
//2查詢訂單客戶信息
Customer customer = order.getCustomer();
System.out.println(customer.getCname());
session.getTransaction().commit();
session.close();
}fetch="select"將采用多條select語句，lazy="proxy"是否延遲，取決關聯對象 類級別檢索策略。
lazy="false"
lazy="proxy"
批量查詢當客戶 關聯查詢 訂單，給每一個客戶生產一個select語句查詢訂單。批量查詢使用in語句減少查詢訂單語句個數。
默認：select * from t_order where customer_id = ?
批量：select * from t_order where customer_id in (?,?,?,?) 5表示括號中?個數。
@Test
publicvoiddemo06() {
//批量查詢
Session session = factory.openSession();
session.beginTransaction();
//1查詢所有客戶
List allCustomer = session.createQuery("from Customer").list();
//2遍歷
for(Customer customer : allCustomer) {
System.out.println(customer.getCname());
System.out.println(customer.getOrderSet().size());
}
session.getTransaction().commit();
session.close();
}檢索總結
檢索策略優點缺點優先考慮使用的場合
立即檢索對應用程序完全透明，不管對象處于持久化狀態還是游離狀態，應用程序都可以從一個對象導航到關聯的對象(1)select語句多
(2)可能會加載應用程序不需要訪問的對象，浪費許多內存空間。(1)類級別
(2)應用程序需要立即訪問的對象
(3)使用了二級緩存
延遲檢索由應用程序決定需要加載哪些對象，可以避免執行多余的select語句，以及避免加載應用程序不需要訪問的對象。因此能提高檢索性能，并節省內存空間。應用程序如果希望訪問游離狀態的代理類實例，必須保證她在持久化狀態時已經被初始化。(1)一對多或者多對多關聯
(2)應用程序不需要立即訪問或者根本不會訪問的對象
表連接檢索(1)對應用程序完全透明，不管對象處于持久化狀態還是游離狀態，都可從一個對象導航到另一個對象。
(2)使用了外連接，select語句少(1)可能會加載應用程序不需要訪問的對象，浪費內存。
(2)復雜的數據庫表連接也會影響檢索性能。(1)多對一或一對一關聯
(2)需要立即訪問的對象
(3)數據庫有良好的表連接性能。
Customer Get(int id)
Return Session.load(Customer.class,id);layz=false
在Service層獲得在頁面要上要用到的屬性=> 在Service層中確保數據已經查詢方式總結
1.通過OID檢索(查詢)
get()立即、如果沒有數據返回null
load()延遲，如果沒有數據拋異常。
2.導航對象圖檢索方式：關聯查詢
customer.getOrderSet()
user.getPost().getDepartment().getDepName();
3.原始sql語句
SQLQuery sqlQuery = session.createSQLQuery("sql 語句") --->表，表字段(列)
sqlQuery.list() 查詢所有
sqlQuery.uniqueResult() 查詢一個
4.HQL，hibernate query language hibernate 查詢語言【1】
Query query = session.createQuery("hql語句") --> 對象，對象屬性
5.QBC，query by criteria 純面對對象查詢語言【2】
HQL【掌握】介紹
查詢所有客戶
@Test
publicvoiddemo01(){
//1查詢所有
Session session = factory.openSession();
session.beginTransaction();
//1使用簡單類名，存在自動導包
// * Customer.hbm.xml
//????????Query query = session.createQuery("from Customer");
//2使用全限定類名
Query query = session.createQuery("from com.itheima.a_init.Customer");
List allCustomer = query.list();
for(Customer customer : allCustomer) {
System.out.println(customer);
}
session.getTransaction().commit();
session.close();
}
選擇查詢
@Test
publicvoiddemo02(){
//2簡單條件查詢
Session session = factory.openSession();
session.beginTransaction();
//1指定數據，cid OID名稱
//????????Query query = session.createQuery("from Customer where cid = 1");
//2如果使用id，也可以(了解)
//????????Query query = session.createQuery("from Customer where id = 1");
//3對象別名,格式：類[as]別名
//????????Query query = session.createQuery("from Customer as c where c.cid = 1");
//4查詢所有項，mysql--> select * from...
Query query = session.createQuery("select c from Customer as c where c.cid = 1");
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer);
session.getTransaction().commit();
session.close();
}投影查詢(部分)
@Test
publicvoiddemo04(){
//4投影
Session session = factory.openSession();
session.beginTransaction();
//1默認
//如果單列，select c.cname from，需要List
//如果多列，select c.cid,c.cname from，需要List ,list存放每行，Object[]多列
//????????Query query = session.createQuery("select c.cid,c.cname from Customer c");
//2將查詢部分數據，設置Customer對象中
// *格式：new Customer(c.cid,c.cname)
// *注意：Customer必須提供相應的構造方法。
// *如果投影使用oid，結果脫管態對象。
Query query = session.createQuery("select new Customer(c.cid,c.cname) from Customer c");
List allCustomer = query.list();
for(Customer customer : allCustomer) {
System.out.println(customer.getCid() + " : "+ customer.getOrderSet().size());
}
session.getTransaction().commit();
session.close();
}
排序
@Test
publicvoiddemo03(){
//3排序，mysql--> select... order by字段[asc]|desc ,....
Session session = factory.openSession();
session.beginTransaction();
Query query = session.createQuery("from Customer order by cid desc");
List allCustomer = query.list();
for(Customer customer : allCustomer) {
System.out.println(customer.getCid());
}
session.getTransaction().commit();
session.close();
}
分頁
@Test
publicvoiddemo05(){
//分頁
Session session = factory.openSession();
session.beginTransaction();
Query query = session.createQuery("from Customer");
// *開始索引, startIndex算法：startIndex = (pageNum - 1) * pageSize;
// *** pageNum當前頁(之前的pageCode)
query.setFirstResult(0);
// *每頁顯示個數，pageSize
query.setMaxResults(2);
List allCustomer = query.list();
for(Customer customer : allCustomer) {
System.out.println(customer.getCid());
}
session.getTransaction().commit();
session.close();
}
綁定參數
@Test
publicvoiddemo06(){
/* 6綁定參數
*方式1：占位符，使用?在hql語句替換具體參數
*設置參數query.setXxx(int , object)
*參數1：?位置，從0開始。
*參數2：實際參數
*例如：String --> query.setString(int,String)
*方式2：別名,格式"屬性= :別名"
*設置參數query.setXxx(String,object)
*參數1：別名
*參數2：實際參數
*例如：Integer --> query.setInteger(String,Integer)
*提供公共設置方法
* ????setParameter(int|string , Object)
*/
Session session = factory.openSession();
session.beginTransaction();
Integer cid = 1;
//方式1
//????????Query query = session.createQuery("from Customer where cid = ?");
//????????query.setInteger(0, cid);
//方式2
Query query = session.createQuery("from Customer where cid = :xxx");
//????????query.setInteger("xxx", cid);
query.setParameter("xxx", cid);
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer);
session.getTransaction().commit();
session.close();
}
聚合函數和分組
@Test
publicvoiddemo07(){
/* 7聚合函數
*/
Session session = factory.openSession();
session.beginTransaction();
//1
//????????Query query = session.createQuery("select count(*) from Customer");
//2別名
//????????Query query = session.createQuery("select count(c) from Customer c");
//3 oid
Query query = session.createQuery("select count(cid) from Customer");
Long numLong = (Long) query.uniqueResult();
intnum = numLong.intValue();
System.out.println(num);
session.getTransaction().commit();
session.close();
}
連接查詢
1.交叉連接 ，等效 sql 笛卡爾積
2.隱式內連接，等效 sql 隱式內連接
3.內連接，等效sql內連接
4.迫切內連接，hibernate底層使用 內連接。
5.左外連接，等效sql左外連接
6.迫切左外連接，hibernate底層使用 左外連接
7.右外連接，等效sql右外連接
內連接和迫切內連接？
左外連接和迫切左外連接？
@Test
publicvoiddemo08(){
/* 8鏈接查詢：左外連接和迫切左外連接？
* *左外連接, left outer join
*底層使用sql的左外連接，hibernate進行數據自動封裝，將一條記錄，封裝給兩個對象(Customer，Order)
*將兩個對象添加到一個對象數組中Object[Customer,Order]
* *迫切左外鏈接left outer join fetch
*底層使用sql的左外連接，hibernate將一條記錄封裝給Customer，講order數據封裝Order，并將order關聯到Customer
* ????????????customer.getOrderSet().add(order)
*默認查詢的數據重復
*/
Session session = factory.openSession();
session.beginTransaction();
//左外連接
//????????List list = session.createQuery("from Customer c left outer join c.orderSet ").list();
//迫切左外鏈接(默認數據重復)
//????????List list = session.createQuery("from Customer c left outer join fetch c.orderSet ").list();
//迫切左外鏈接(去重復)
List
list = session.createQuery("select distinct c from Customer c left outer join fetch c.orderSet ").list();
session.getTransaction().commit();
session.close();
}
命名查詢思想：將HQL從java源碼中，提取到配置文件中。
分類：全局、布局
配置
全局：*.hbm.xml HQL語句
局部： HQL
獲得
全局：
session.getNamedQuery("queryName")
局部：
session.getNamedQuery("className.queryName") 需要使用類的全限定名稱
@Test
publicvoiddemo09(){
/* 9命名查詢
*/
Session session = factory.openSession();
session.beginTransaction();
//全局
//List list = session.getNamedQuery("findAll").list();
//局部
List list = session.getNamedQuery("com.itheima.a_init.Customer.findAll").list();
System.out.println(list.size());
session.getTransaction().commit();
session.close();
}
QBC【了解】
QBC查詢:
QBC:Query By Criteria條件查詢.面向對象的查詢的方式.QBC簡單的查詢:
//簡單查詢:
List list = session.createCriteria(Customer.class).list();
for (Customer customer : list) {
System.out.println(customer);
}QBC分頁的查詢:
Criteria criteria = session.createCriteria(Order.class);
criteria.setFirstResult(10);
criteria.setMaxResults(10);
List list = criteria.list();QBC排序查詢:
Criteria criteria = session.createCriteria(Customer.class);
//????????criteria.addOrder(org.hibernate.criterion.Order.asc("age"));
criteria.addOrder(org.hibernate.criterion.Order.desc("age"));
List list = criteria.list();QBC條件查詢:
//按名稱查詢:
/*Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq("cname", "tom"));
List list = criteria.list();*/
//模糊查詢;
/*Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.like("cname", "t%"));
List list = criteria.list();*/
//條件并列查詢
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.like("cname", "t%"));
criteria.add(Restrictions.ge("age", 35));
List list = criteria.list();
離線查詢(了解)DetachedCriteria 離線查詢對象，不需要使用Session就可以拼湊查詢條件。一般使用在web層或service層拼湊。將此對象傳遞給dao層，此時將與session進行綁定執行查詢。
離線查詢條件與QBC一樣的。
@Test
publicvoiddemo10(){
/* 10離線查詢
*/
//web & service
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
detachedCriteria.add(Restrictions.eq("cid", 1));
//---------------dao
Session session = factory.openSession();
session.beginTransaction();
//離線Criteria與session綁定
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
List allCustomer = criteria.list();
System.out.println(allCustomer.size());
session.getTransaction().commit();
session.close();
}
常見配置整合c3p0(連接池) (了解)整合c3p0
步驟一：導入c3p0 jar包
步驟二：hibernate.cfg.xml 配置
hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider
c3p0具體配置參數
###########################
### C3P0 Connection Pool###
###########################
#hibernate.c3p0.max_size 2
#hibernate.c3p0.min_size 2
#hibernate.c3p0.timeout 5000
#hibernate.c3p0.max_statements 100
#hibernate.c3p0.idle_test_period 3000
#hibernate.c3p0.acquire_increment 2
#hibernate.c3p0.validate false
事務回顧事務：一組業務操作，要么全部成功，要么全部不成功。
特性：ACID
原子性：整體
一致性：數據
隔離性：并發
持久性：結果隔離問題：
臟讀：一個事務讀到另一個事務未提交的內容
不可重復讀：一個事務讀到另一個事務已提交的內容(insert)
虛讀(幻讀)：一個事務讀到另一個事務已提交的內容(update)隔離級別--解決問題
read uncommittd，讀未提交。存在3個問題。
read committed，讀已提交。解決：臟讀。存在2個問題。
repeatable read ，可重復讀。解決：臟讀、不可重復讀。存在1個問題。(MySQL默認事務)
serializable，串行化。單事務。沒有問題。
hibernate設置隔離級別在hibernate.cfg.xml 配置
hibernate.connection.isolation 4
lost update 丟失更新
悲觀鎖：丟失更新肯定會發生。
采用數據庫鎖機制。
讀鎖：共享鎖。
select .... from ... lock in share mode;
寫鎖：排他鎖。(獨占)
select ... from .... for update
樂觀鎖：丟失更新肯定不會發生
在表中提供一個字段(版本字段)，用于標識記錄。如果版本不一致，不允許操作。
hibernate處理丟失更新悲觀鎖：寫鎖
@Test
publicvoiddemo01(){
//1查詢所有
Session session = factory.openSession();
session.beginTransaction();
Customer customer = (Customer) session.get(Customer.class, 1 ,LockMode.UPGRADE);
System.out.println(customer);
session.getTransaction().commit();
session.close();
}
樂觀鎖：
在PO對象(javabean)提供字段，表示版本字段。一般Integer
在*.hbm.xml 文件配置
步驟一：
步驟二：
步驟三：測試
@Test
publicvoiddemo02(){
//1查詢所有
Session session = factory.openSession();
session.beginTransaction();
//????????Order order = new Order();
//????????order.setPrice(998d);
//????????session.save(order);
Order order = (Order) session.get(Order.class, 32);
order.setPrice(889d);
session.getTransaction().commit();
session.close();
}
總結
以上是生活随笔為你收集整理的c3p0 参数 模糊查询_Hibernate day03笔记的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 乱码 讯飞 语音识别_一段讯飞、百度等语
- 下一篇： 为什么码农要了解业务呢？网友：不是敲代码