Hibernate对数据库的简单操作

   自学是一件很有趣的事，一旦和某种有目的性的行为挂钩，估计趣味就会降低很多。自从开始学习java的时候，就决定一如既往的走下去，不离不弃。

   虽然，Sun已经离开了很久，但是java爱好者开发者依然激情饱满，java有着很多优秀的开发包，组件。每一次新的技术，开源产品的诞生都是爱好者们狂欢的季节，忘乎所以的学习，测试，追寻，创新，分享，争辩等等，唯恐遗失了什么似得。

    java的学习从来不会寂寞，从来也没有担心由于太多的包装，封装，集成让我们失去了思考，失去了创造的能力。

    简单的做了一些Hibernate的增加数据，查询数据，删除数据的操作

先在已有的数据库中找了一个数据库MyBookShop数据库，里面有一张名为Books的表，为了不破坏其中的数据使用Sql语句从新建立了一张表BooksTemp

取了Books表中的四个字段

1. selecet Id , Title , Author, ISBN into BooksTemp from Books 

Hibernate中通过XML文件指定对象与关系数据之间的映射。

1. <?xml version="1.0" encoding="utf-8"?> 
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
4. <!--  
5.     Mapping file autogenerated by MyEclipse Persistence Tools 
6. --> 
7. <hibernate-mapping> 
8.     <!--  
9.         name:实体Bean，即类名 
10.         table：实体Bean对应的数据库中的表名 
11.         schema:数据库拥有者 
12.         catalog:使用的数据库名称 
13.      --> 
14.     <class name="xiao.zhang.bean.BooksTemp" table="booksTemp" schema="dbo" catalog="MyBookShop"> 
15.         <!--  
16.             主键列 
17.             generator class:主键生成的标识 
18.          --> 
19.         <id name="id" type="java.lang.Integer"> 
20.             <column name="Id" /> 
21.              
22.             <generator class="increment"/> 
23.         </id> 
24.         <property name="title" type="java.lang.String"> 
25.             <column name="Title" length="200" /> 
26.         </property> 
27.         <property name="author" type="java.lang.String"> 
28.             <column name="Author" length="200" /> 
29.         </property> 
30.         <property name="isbn" type="java.lang.String"> 
31.             <column name="ISBN" length="50" /> 
32.         </property> 
33.     </class> 
34. </hibernate-mapping> 

使用Hibernate进行简单的操作：

1. Session session = HibernateSessionFactory.getSession(); 
2.         BooksTemp book; 
3.         Transaction trans; 
4.          
5.         // 查询单条数据 
6.         // Session session=HibernateSessionFactory.getSession(); 
7.         // BooksTemp book=(BooksTemp)session.load(BooksTemp.class, 4939); 
8.         // System.out.println(book.getTitle()); 
9.         // Session session=HibernateSessionFactory.getSession(); 
10.         // BooksTemp book=(BooksTemp)session.get(BooksTemp.class, 4939); 
11.         // System.out.println(book.getTitle()); 
12.         // Session session; 
13.         // session = HibernateSessionFactory.getSession(); 
14.         // BooksTemp book; 
15.          
16.          
17.         /** 
18.          * 下面的语句只打印输出一次SQL语句 
19.          *  
20.          * 使用load(Class, Serializable)还是使用get(Class, Serializable)有相同的结果 
21.          *  
22.          * 可以证明Hibernate具有缓存功能 
23.          */ 
24.  
25.         // book= (BooksTemp) session.get(BooksTemp.class, 4939); 
26.         // System.out.println(book.getTitle()); 
27.         // book= (BooksTemp) session.load(BooksTemp.class, 4939); 
28.         // System.out.println(book.getTitle()); 
29.         // 查询所有数据 
30.         // session=HibernateSessionFactory.getSession(); 
31.         // String hql="from BooksTemp where Id between 4939 and 4960"; 
32.         // List<BooksTemp> booksList=session.createQuery(hql).list(); 
33.         // for(int i=0; i<booksList.size(); i++){ 
34.         // System.out.println(booksList.get(i).getId()+"-----"+booksList.get(i).getAuthor()); 
35.         // } 
36.          
37.         // 修改 
38.         // 删除单条数据 
39.         /** 
40.          * 数据库操作增删改必须使用事务 
41.          */ 
42.           
43.         // trans = session.beginTransaction(); 
44.         // trans.begin(); 
45.         // book = (BooksTemp) session.get(BooksTemp.class, 4944); 
46.         // if (book != null) { 
47.         // System.out.println(book.getId() + "----" + book.getAuthor()); 
48.         // session.delete(book); 
49.         // } else { 
50.         // System.out.println("这条记录不存在"); 
51.         // } 
52.         // trans.commit(); 
53.          
54.         // 删除所有数据 
55.         /** 
56.          *  
57.          * 删除一定数量的记录 
58.          *  
59.          */ 
60.         // trans = session.beginTransaction(); 
61.         // trans.begin(); 
62.         // String hql = "from BooksTemp where Id between ? and ?"; 
63.         // Query query = session.createQuery(hql); 
64.         /** 
65.          * 在Hibernate中的在JDBC中使用PreparedStatement命令时设置占位的参数值有所不同 
66.          *  
67.          * Hibernate遵循了一般规律从占位符编号0开始 
68.          *  
69.          * Hibernate删除数据判断数据存在再删除 
70.          */ 
71.         // query.setInteger(0, 4939); 
72.         // query.setInteger(1, 4960); 
73.         // List booksList=query.list(); 
74.         // System.out.println("一共删除"+booksList.size()+"行"); 
75.         // for(int i=0; i<booksList.size(); i++){ 
76.         // session.delete(booksList.get(i)); 
77.         // } 
78.         // trans.commit(); 
79.          
80.          trans = session.beginTransaction(); 
81.          trans.begin(); 
82.          int start=4961; 
83.          int end=4970; 
84.          List booksList; 
85.          for(int i=start; i<=end; i++){ 
86.              String hql = "from BooksTemp where Id=?"; 
87.              Query query = session.createQuery(hql); 
88.              query.setInteger(0, i); 
89.              booksList=query.list(); 
90.              if(booksList!=null&&booksList.size()==1){ 
91.                  session.delete(booksList.get(0)); 
92.              } 
93.          } 
94.          trans.commit(); 

    在进行查询操作的时候查询同一条一句时，在控制台中显示一条SQL语句，说明访问数据库只进行了一次，这与Hibernate的缓存机制有关。

    缓存是位于应用程序与物理数据源之间，用于临时存放复制数据的内存区域，目的是为了减少应用程序对物理数据源访问的次数，从而提高应用程序的运行性能. 

 Hibernate在查询数据时，首先到缓存中去查找，如果找到就直接使用，找不到的时候就会从物理数据源中检索，所以，把频繁使用的数据加载到缓存区后，就可以大大减少应用程序对物理数据源的访问，使得程序的运行性能明显的提升.

本文转自 secondriver 51CTO博客，原文链接：http://blog.51cto.com/aiilive/931241，如需转载请自行联系原作者