hibernate基础学习

转载自：http://blog.csdn.net/fb281906011/article/details/17628111

一：下载hibernate:http://hibernate.org/orm/downloads/并且进行解压，里面有个lib文件夹，里面全是Hibernate所依赖的jar包，当然，不能缺少的核心包hibernate3.jar(这里我用到的是hibernate3)，至于和现在的hibernate4有啥区别，自己也不清楚（希望有大牛能给我指正）；
二：jar包都准备好后，就可以新建一个Javaproject，将刚才的的jar包全部导入（当然可能不是所有jar包都需要，但是本屌也不清楚哪些可以不要，为了以防万一，都进行导入，安全起见嘛）；
三：工程建好后，我们就可以来进行我们的开发练习咯：
首先，我们先在src目录下新建一个hibernate.cfg.xml文件（至于为啥在src目录下，因为src目录最终会编译到一个bin文件夹中也就是类路径下（classpath下面），服务器启动时会自己在classpath下寻找该文件进行解析加载进来）；
其次，就开始进行对hibernate.cfg.xml文件配置进行讲解（我连接的是MySQL5数据库，这里必须将MySQL-connector-Java.jar驱动包导入）：

1. <span style="font-size:14px;"><hibernate-configuration>
2. <session-factory>
3. <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property><!-- mysql驱动 -->
4. <property name="hibernate.connection.url">jdbc:mysql:///test</property><!-- mysql默认连接数据库test以及默认端口3306 -->
5. <property name="hibernate.connection.username">root</property><!-- 用户名 -->
6. <property name="hibernate.connection.password">root</property><!-- 密码 -->
7. <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property><!-- mysql方言 -->
8. <property name="hbm2ddl.auto">create</property><!-- 更新数据库方式 -->
9. <property name="show_sql">true</property><!-- 是否后台打印语句 -->
10. <mapping resource="toone/com/cn/bo/User.hbm.xml"/><!--映射文件-->
11. </session-factory>
12. </hibernate-configuration></span>

以上属性（property）我们都可以在之前下载的Hibernate解压包中的etc文件夹下的hibernate.properties文件中找到（）。这里对hbm2ddl.auto进行说明一下（有四个值）：

create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。
create-drop ：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。
update：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据 model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。
validate:：启动时验证现有schema与你配置的hibernate是否一致，如果不一致就抛出异常，并不做更新。

四：接下来我们就可以来进行我们的实体开发了：

User.java

1. <span style="font-size:14px;">package toone.com.cn.bo;
2. import java.util.Date;
3. public class User {
4. private int id;//必须有主键，因为hibernate很多方法都需要用到主键id
5. private String name;
6. private Date birthday;//必须提供默认的构造方法，这里没有，但是所有类都带有默认的构造方法；</span>

1. <span style="font-size:14px;">  public int getId() {
2. return id;
3. }
4. public void setId(int id) {
5. this.id = id;
6. }
7. public String getName() {
8. return name;
9. }
10. public void setName(String name) {
11. this.name = name;
12. }
13. public Date getBirthday() {
14. return birthday;
15. }
16. public void setBirthday(Date birthday) {
17. this.birthday = birthday;
18. }
19. }</span><span style="font-size: 24px;">
20. </span>

User.hbm.xml（映射文件）

1. <span style="font-size:14px;"><hibernate-mapping package="toone.com.cn.bo.domain">
2. <class name="User" table="user"><!--这里的table值对应数据库中的表名；如果没有table值，默认等于类名小写 -->
3. <id name="id" column="id">
4. <generator class="native"></generator><!--采用主键自增长方式-->
5. </id>
6. <property name="name" column="name"/><!-- 这里的column值对应数据库中的属性名；如果没有column值，默认等于属性名 -->
7. <property name="birthday" column="birthday"/>
8. </class>
9. </hibernate-mapping></span>

五：最后我们就可以来进行我们的业务开发了（主要进行user的增删改查操作）：

以前的采用jdbc来进行连接数据库的方式是很烦琐的，这里就充分发挥了hibernate的方便与优势了：

Main.java

1. <span style="font-size:14px;">package toone.com.cn;
2. import java.util.Date;
3. import org.hibernate.HibernateException;
4. import org.hibernate.Session;
5. import org.hibernate.SessionFactory;
6. import org.hibernate.Transaction;
7. import org.hibernate.cfg.Configuration;
8. import toone.com.cn.bo.User;
9. public class Main {
10. public static void main(String[] args){
11. //这里千万注意，不能写成Configuration cfg = new Configuration();否则会报Hibernate Dialect must be explicitly set 错误信息将我们误导
12. //；实际上前面我们已经配置了mysql的方言；
13. Configuration cfg = new Configuration().configure();//对于configure()方法，我们可以引入其源代码进行查看，其会在类路
14. //径下自动去加载一个默认的hibernate.cfg.xml文件；如果我们想换其他名字，可以使用其重载方法，具体可以查看其源代码（下载的压缩包中有）
15. SessionFactory factory = cfg.buildSessionFactory();
16. User user = new User();
17. user.setName("Kobi");
18. user.setBirthday(new Date());
19. Session session = null;
20. Transaction tx = null;
21. try {
22. session = factory.openSession();
23. tx = session.beginTransaction();//开启事务
24. session.save(user);//进行保存
25. tx.commit();//提交事务
26. } catch (HibernateException e) {
27. if(tx!=null){
28. tx.rollback();//回滚事务
29. }
30. throw e;//必须抛出异常
31. }finally{
32. if(session!=null){
33. session.close();//关闭session
34. }
35. }
36. }
37. }</span>

好了，一个添加功能就已经实现，但是写到这里，我们可能发现我们每进行一次操作，比如添加，修改，删除，查找都需要执行这段代码：

1. Configuration cfg = new Configuration().configure();
2. SessionFactory factory = cfg.buildSessionFactory();

这段代码非常耗性能，因为它每次都需要去加载解析配置文件hibernate.cfg.xml，并且每次都需要创建session;因此我们不妨自己创建一个工具类，采用单利的方式来进行实现，并且该工具类实现实体的增删改查，代码如下：

HibernateUtils.java

1. <span style="font-size:14px;">package toone.com.cn.util;
2. import java.io.Serializable;
3. import org.hibernate.HibernateException;
4. import org.hibernate.Session;
5. import org.hibernate.SessionFactory;
6. import org.hibernate.Transaction;
7. import org.hibernate.cfg.Configuration;
8. public class HibernateUtils {
9. private static SessionFactory sessionfactory;
10. private HibernateUtils(){}
11. static{
12. Configuration cfg = new Configuration().configure();
13. sessionfactory = cfg.buildSessionFactory();
14. }
15. public static Session getSession(){
16. return sessionfactory.openSession();
17. }
18. //添加
19. public static void add(Object obj){
20. Session session = null;
21. Transaction tx = null;
22. try {
23. session = HibernateUtils.getSession();
24. tx = session.beginTransaction();
25. session.save(obj);//区别：save()方法如果没有开启事务，它会执行一条插入语句，但之后由于没有提交事务，它又进行
26. //session.persist(obj);//回滚了,而persist()方法在没有开启事务的时候，它根本不会去执行，即没有那条插入语句
27. tx.commit();
28. }finally{
29. if(session!=null){
30. session.close();
31. }
32. }
33. }
34. //修改
35. public static void update(Object obj){
36. Session session = null;
37. Transaction tx = null;
38. try {
39. session = HibernateUtils.getSession();
40. tx = session.beginTransaction();
41. session.update(obj);
42. tx.commit();
43. }finally{
44. if(session!=null){
45. session.close();
46. }
47. }
48. }
49. //删除
50. public static void delete(Object obj){
51. Session session = null;
52. Transaction tx = null;
53. try {
54. session = HibernateUtils.getSession();
55. tx = session.beginTransaction();
56. session.delete(obj);
57. tx.commit();
58. }finally{
59. if(session!=null){
60. session.close();
61. }
62. }
63. }
64. //查找 不需要开启事务
65. public static Object findById(Class clazz,Serializable id){
66. Session session = null;
67. try {
68. session = HibernateUtils.getSession();
69. //这里需要区分一下get()与load()的区别，load()不会立即//去访问数据库只有在第一次使用的时候才会去加载（懒加载）；
70. //load方法永远不可能返回空对象(如果不存在，其会产生一个user的子类)具体可以去查资料区别这两个方法
71. //Object obj = session.load(clazz, id);
72. Object obj = session.get(clazz, id);return obj;}finally{if(session!=null){session.close();}}}}
73. </span>

最后，一个实体的增删改查操作就完成了，下面我们可以重写Main.java文件来使用HibernateUtils工具类来对实体进行操作了：

Main.java

1. <span style="font-size:14px;">package toone.com.cn;
2. import java.util.Date;
3. import toone.com.cn.bo.User;
4. import toone.com.cn.util.HibernateUtils;
5. public class Main {
6. public static void main(String[] args){
7. User user = new User();
8. user.setName("Kobi");
9. user.setBirthday(new Date());
10. HibernateUtils.add(user);//添加
11. user.setName("Jams");
12. HibernateUtils.update(user);//修改
13. HibernateUtils.delete(user);//删除
14. User user1 = (User) HibernateUtils.findById(User.class, user.getId());//查找
15. System.out.println(user1.getName());
16. }
17. }</span>

总结：了解了Hibernate的基本作用，学会了使用其来进行增删改查操作，算是工作之余的一点收获吧，以后还得继续坚持发帖，不断学习！