javaEE之------Hibernate学习笔记

 Hibernate框架需要配置
hibernate.cfg.xml文件（里面设置的是连接数据库和映射值对象）<mapping resource="路径名。。。。.xml">

还需要值对象：
如  Custom.hbm.xml    通过hibernate里面进行配值(里面是 数据库中的数据字段大小，是都是id等） 里面的字段必须要要和值对象中一致值对象和改xml文件存放在一起。
基本上里面的一些配置文件都是拷贝的。
单表：


查

  SessionFactory sessionfactory=config.buildSessionFactory();
	
		/*通过会话工厂类产生一个会话实例*/
	
	Session session=sessionfactory.openSession();


	/*通过会话产生一个查询对象Query*/
	
	Query query=session.createQuery("from bean.Customer");
	
		/*进行查询返回一个集合List*/
	
		List<Customer> cuslist=query.list();

增

	Session session=HibernateSessionFactory.getSession();


	/*定义事务开始*/


	Transaction tran=session.beginTransaction();


	Dept dept=new Dept(new Long(1001),"math","shanghai");
	
session.save(dept);


	/*提交事务，真正保存到数据库中*/


	tran.commit(); 

删除
   

 Session session=HibernateSessionFactory.getSession();
	  
	 /*首先查找待删除记录 通过ID*/
	    
   	 Dept dept=(Dept)session.get(Dept.class,new Long(10));
	   
	 Transaction tran=session.beginTransaction();
	  
	  session.delete(dept);
	
	    tran.commit();
	}

修改
 

Session session=   HibernateSessionFactory.getSession();
	
  	 Transaction tran=session.beginTransaction();
	    
		/*首先查找待修改记录 通过ID*/
	   
	 Dept dept=
  (Dept)session.get(Dept.class,new Long(10));


	    dept.setDname("math");
	
	   session.saveOrUpdate(dept);
	
	   tran.commit();

数据中 主键的自动增加：
值对象的配置中 generator的使用 。

 <id name="customerId" type="java.lang.String">
            <column name="customerID" length="8" />
            <generator class="assigned"></generator>
        </id>

有一下几种方式：

assigned  ：自己设置，手动，主键由外部程序负责生成，无需Hibernate参与。
identity ：自动生成，用户不用管理，自动增长列，则增加一条记录时主键的值可以不赋值。用数据		库提供的主键生成机制。

increment: 主键按数值顺序递增 有的数据不支持，由hibernate生成，多线程会出现问题
sequence:  采用数据库提供的sequence 机制生成主键，给定序列 1  --3---5---7--。。。。
native：由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种作为主键生成	方式。
	
uuid.hex：由Hibernate为ID列赋值，可以不用指定。

Hibernate 查询语句：

Session session=HibernateSessionFactory.getSession();


	Query query=session.createQuery("from Customer");
	//相当于 limit 10 ，10  下标从10开始，往后10个，  分页技术中就是这样的。
	
query.setFirstResult(10); //设置查询记录开始位置，索引从0开始。
	query.setMaxResults(10);//设置查询返回的最大记录个数。
	
List list=query.list();

条件查询：
一 ，部分查询：

Session session=HibernateSessionFactory.getSession();


	Query query=session.createQuery("from Customer cus where cus.name='zhou'");
//查询		name是zhou的名

二：单一属性查询

session = HibernateSessionFactory.getSession();

List cnames = session.createQuery("select cname from Customer").list();
//java中的变量名。
for (int i=0;i< cnames.size();i++) {

String name = (String)cnames.get(i);

System.out.println(name);
}


三：多个属性的查询,使用对象数组
session = HibernateSessionFactory.getSession();
//查询多个属性，其集合元素是对象数组

//数组元素的类型，跟实体类的属性的类型相关

List students = session.createQuery("select sno, sname from Students").list();
for (int i=0;i< students.size();i++) {
Object[] obj = (Object[])students.get(i);

System.out.println(obj[0] + ", " + obj[1]);

}


四：可以封装成一个list，多个属性的查询,使用List集合装部分列

Session session = HibernateSessionFactory.getSession();
      Query query = session.createQuery(
"select new list(cus.name,cus.phone) from Customer cus"//这里封装一个集合
);

List list = query.list();
for (int i = 0; i < list.size(); i++) {
List temp=(List)list.get(i);
System.out.println(temp.get(0)); 
//0是索引
}




五：使用Map集合装部分列
Session session = HibernateSessionFactory.getSession();

Query query = session.createQuery(
"select new map(cus.name,cus.phone) from Customer cus"
);

List list = query.list();
for (int i = 0; i < list.size(); i++) {
Map temp=(Map)list.get(i);
System.out.println(temp.get("1")); 
//"1"是key 
}


六，内连接查询
Query query=session.createQuery("select c.name, s.name from Student s join s.classes c ").list();
for (Iterator iter = students.iterator();iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + ", " + obj[1]);

}

七：外链接：
这是写到Query query=session.createQuery（内容）；
select c.name, s.name from Classes c left join c.students s 
select c.name, s.name from Classes c right join c.students s 

八：带参数的查询
?作为参数 
如" from Customer cus where cus.name=?";
     Session session = HibernateSessionFactory.getSession();
    Query query = session.createQuery("from Customer cus where cus.name=?");   
 query.setParameter(0, "zhou");
 //设置参数，从0开始。
 List list = query.list();

参数名称:name
如" from Customer cus where cus.name=:name";
Session session = HibernateSessionFactory.getSession();  
Query query = session.createQuery("from Customer cus where cus.name=:name ");
  query.setParameter("name", "zhou");
//设置参数，就不用写数字了，直接可以设置名字
  List list = query.list();
   条件查询，使用 ？的方式传递参数
Query query = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.name LIKE ?");
 
query.setParameter(0, “%周%”); //传递参数参数的索引是从0开始的。   
   如条件查询，使用":参数"名称的方式传递参数

Query query = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.name LIKE :myname");
query.setParameter("myname", "张三");
//传递参数
因为setParameter方法返回Query接口，
所以可用省略方式来查询
List students = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.name LIKE :myname and s.id = :myid")
setParameter("myname", "%周%").setParameter("myid", 15).list();

嵌入原生sql测试
：
SQLQuery sqlQuery = session.createSQLQuery("select * from t_student");

List students = sqlQuery.list();
for (Iterator iter = students.iterator();iter.hasNext();) {
Object[] obj = (Object[])iter.next();
System.out.println(obj[0] + ", " + obj[1]);
}




多表操作：
比如 学生和院系
多 对 一

配置 学生 .xml
<hibernate-mapping>
  
 <class name="bean.Student" table="student" catalog="support">       
<id name="sno" type="java.lang.String">
  <column name="sno" length="4" />         
 <generator class="assigned"></generator> 
<!--这里设置 id是自己设置的-->     
</id>
<!--name设定待映射的持久化类的属性名-->
<!--column设定和持久化类的属性对应的表的外键-->?
<!--class设定持久化类的属性的类型-->
        
<many-to-one name="dept" class="bean.Dept" fetch="select">    
<column name="deptid" length="4" />      
  </many-to-one>
 这就是多 对 一 的关系     
<property name="sname" type="java.lang.String">
   <column name="sname" length="20" />
        </property>
  </class>
</hibernate-mapping>


对于部门端：
Dept.hbm.xml
<hibernate-mapping>
   
<class name="bean.Dept" table="dept" catalog="support">
 <id name="deptid" type="java.lang.String">
  <column name="deptid" length="4" />
    <generator class="assigned"></generator>
         </id>
 <property name="deptname" type="java.lang.String">
    <column name="deptname" length="30" />
</property>
<!-- name设定待映射的持久化类的属性名-->
      
 <set name="students" inverse="true">
<!--部门里面增加与一个字段集合，一对多，便于区分，和学生相关联，主键和外键的关系students只是一个名字，所关联的持久类对应的表的外键-->
  
         <key>  <!--外键-->
<column name="deptid" length="4" />
        </key>
<!--设定持久化所关联的类-->
    <one-to-many class="bean.Student" />
     <!--这是多方--> 
 </set>
</class>
</hibernate-mapping>


上面是测试的：
我们在部门中，我们添加了一个set集合，名字为students，我们这里可以直接获得
Session s=HibernateSessionFactory.getSession();
Query q=s.createQuery("from Dept");
List l=q.list();
for(int i=0;i<l.size();i++){
   Dept dept=(Dept)l.get(i);
   System.out.println(dept.getDeptid());
  Set stu= dept.getStudents();//通过院系实例可以查询该院学生
        Iterator it=stu.iterator();
        while(it.hasNext()){
 Student st=(Student)it.next();
 System.out.print(st.getSno()+"  ");
        }
       }






级联：
表 多对多
学生类映射文件
    
<class name="Student">          
         ......
     <!-- name="teachers" 表示:Student类中有一个属性叫teachers (是Set集合)-->  
   <!-- table="teacher_student" 表示:中间关联表。表名叫teacher_student -->       <set name="teachers" table="teacher_student">  
<!-- column="student_id" 表示:中间表teacher_student的字段-->  
      <!-- Student类的id与中间表teacher_student的字段student_id对应-->  
        <key column="student_id"/>              
           <!-- column="teacher_id" 表示:中间表teacher_student的字段-->  
            <!-- class="Teacher" 表示:中间表teacher_student的字段teacher_id与 Teacher类的id对应-->  
<many-to-many class="Teacher”
   column="teacher_id"/>  
      </set>  
 </class>






教师类映射文件
   
<class name="Teacher">          
        ......
       <set name="students" table="teacher_student">  
            <key column="teacher_id"/>              
            <many-to-many class="Student" 
               column="student_id"/>  
  </set>     
</class>     
  注意：把多对多关联分解为两个一对多关联，具有更好的可扩展性和操作性。

详细的ppt下载