Hibernate(ORMapping) 上手实例与配置过程

原创 2016年09月13日 01:16:01

利用一晚上的时间配置了一下Hibernate,做了一个简单的demo练习实现对数据库的增删改查,接下来我一步步的分析并且会指出每一步大家该注意的地方。
首先引进jar包:

这里写图片描述

接下来,我们来看一下目录:

这里写图片描述

好了,现在就开始我们的工作:
1 . 建立实体类User,和数据库中的表有对应关系,实现每个属性的get和set方法(有三个属性),并实现可序列化。

package User;
import java.io.Serializable;

public class User implements Serializable {

    public User() {
        //默认的构造方法
    }
    private Integer id;
    private String loginName;
    private String loginPwd;
    public String getLoginPwd() {
        return loginPwd;
    }
    public void setLoginPwd(String loginPwd) {
        this.loginPwd = loginPwd;
    }
    public String getLoginName() {
        return loginName;
    }
    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
}

2.写Hibernate的映射文件,在这个文件中写数据库表和实体类的映射关系。
以下是一个简单的映射文件的配置。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernat mapping DTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.hibtest1.entity.User" table="users" catalog="bookshop">

<id name="id" type="java.lang.Integer">
      <column name = "Id"/><!-- 指定主键 -->
      <generator class = "native"></generator>
      <!-- generator用来指定主键的生成策略,常用值为native和assigned -->
</id> 

<property name="loginName" type="java.lang.String">
     <column name="LoginName" length="50"/>
     </property>

     <property name="loginPwd" type="java.lang.String">
     <column name="LoginPwd" length="16"/>
     </property>
     </class>
</hibernate-mapping>
<!-- 是Hibernate的映射文件,告知Hibernate框架实体类Users映射到数据库中的哪个表,以及属性和字段的对应关系  -->
<!-- 配置了从User实体类到数据库users表的映射,每个class中配置一个实体类的映射信息 -->

3.最后写hibernate.cfg.xml,即hibernate的配置文件,在这个文件中写连接数据库的相关信息和hibernate的参数,并将映射文件加载进来。

<?xml version="1.0" encoding="UTF-8"?>
<!-- hibernate的配置文件 -->
<!-- 需要配置连接数据库的相关信息和hibernate的参数 -->
<!-- 数据库的相关信息包括驱动,username,password,url等 -->
<!-- dialect参数必须配置,用来配置Hibernate使用的不同数据库类型 -->
<!-- show_sql表示程序运行时在控制台输出执行的sql语句 -->
<!DOCTYPE hibernate-configution PUBLIC 
       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
       "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

       <hibernate-configution>
       <session-factory>

           <property name="show_sql">true</property>
           <property name="eclipse.connection.profile">bookshop</property>
           <property name="connection.url">jdbc:mysql://localhost:3306/bookshop</property>
           <property name="connection.username">root</property>
           <property name="connection.password">12345</property>
           <property name="driver_class">com.mysql.jdbc.Driver</property>
           <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

           <mapping resource="com.hibtest1/entity/User.hbm.xml"/>
    <!-- 声明加载之前写的数据库和表的映射文件User.hbm.xml -->   


       </session-factory>
       </hibernate-configution>

4.到此,所有准备工作已经做完,接下来我们要编写测试类,实现向数据库中添加数据,并且一起经历整个Hibernate操作处理的过程。

(1) TestAdd.java

package User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class TestAdd {

    public static void main(String[] args) {
        new TestAdd().addUser();
    }

    public void addUser() {
        //建立持久化对象,并赋初值(实例化实体类)
        User user = new User();
        user.setLoginName("huqianmenfg");
        user.setLoginPwd("12345");

        //初始化,读取配置文件hibernate.cfg.xml
        Configuration config = new Configuration().configure();
        //读取创建sessionFactory
        SessionFactory sessionFactory = config.buildSessionFactory();
        //打开session
        Session session = sessionFactory.openSession();
        //事务处理
        Transaction tx=null;
        try {
            //开始一个事务
            tx = session.beginTransaction();
            //持久化操作,保存user对象信息
            session.save(user);
            //提交事务
            tx.commit();
        } catch(Exception e) {
             if(tx != null) {
                 tx.rollback();
                 //回滚
             }
        } finally {
            session.close();
        }
    }
}
/*
 * 注意: 除了持久化对象的建立过程以及赋值过程之外,所有的操作步骤都是固定的,整个hibernate的处理过程就是这样的
 * Hibernate的处理过程:读取配置文件,根据Configuration创建sessionFactory,用来生产session,接着就是生产session的过程。
 * 最后进行事务提交和处理的过程。事务提交的过程中,如果提交成功,则提交数据,否则回滚。
 * 
 * 需要注意的是:Session的save方法必须在事务环境中完成,并需要使用commit方法来提交事务,提交成功后数据才会被写入数据库。
 * */
运行最后的测试类,就可以实现将user用户数据添加到数据库中,方便简单!!!

以上完成了用hibernate实现向数据库中添加数据的过程,接下来我们来实现查询、修改和删除数据的过程。

(2)TestDelete.java

package User;

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

public class TestDelete {

    public static void main(String[] args) {

    }
    private void testDelete() {
        //读取配置文件
        Configuration config = new Configuration();
        //创建sessionFactory
        SessionFactory sessionFactory = config.buildSessionFactory();
        //打开session
        Session session = sessionFactory.openSession();
        Transaction tx = null;
        //加载要删除的数据,和查询的方法一样(其实本质就是查询到需要删除的值,都用的是session.get());
        //也是根据主键进行查询,方便后期的删除过程。
        User user = (User)session.get(User.class, new Integer(1));
        //注意删除的过程需要加事务处理和 try-catch 异常处理机制
        try {
            //开启一个事务
            tx = session.beginTransaction();
            //进行删除操作
            session.delete(user);
            //提交这个事务
            tx.commit();
        } catch(Exception e) {
            if(tx != null) {
                tx.rollback();//回滚
            }
            e.printStackTrace();
        } finally {
            session.close();//在 finally 中关闭 session
        }

    }
}
/*
 *注意: 实现删除功能的方法都是private void 类型的方法。
 * */

(3) TestUpdate.java

package User;

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

public class TestUpdate {

    public static void main(String[] args) {

    }

    private void testUpdate() {
        //加载配置文件
        Configuration config = new Configuration();
        //创建sessionFactory
        SessionFactory sessionFactory = config.buildSessionFactory();
        //得到session
        Session session = sessionFactory.openSession();
        //得到需要修改的数据,根据主键查询即可
        User user = (User)session.get(User.class, new Integer(2));
        Transaction tx = null;
        //直接在外部修改数据
        user.setLoginName("qianmenghu");
        //以下是事务处理
        try {
            //开启事务
            tx = session.beginTransaction();
            //执行修改操作
            session.update(user);
            //提交事务
            tx.commit();
        } catch(Exception e) {
            if(tx != null) {
                tx.rollback();//出错即回滚
            }
            e.printStackTrace();
        } finally {
            session.close();
        }

    }
}
/*
 * 注意:执行修改操作的时候需要在事务的外部修改数据。直接用user.set方法就可以实现。
 * 其他的步骤都和之前的操作一样,修改也要进行事务处理
 * 除了查询不需要进行事务处理之外,别的(添加、删除、修改),只要是对数据有相应的改动的操作,都需要进行事务处理。
 * 获取操作数据的方式都是相同的。
 * */

接下来是实现查询的功能,查询功能中不需要进行事务处理,直接根据主键查询即可。

(4) TestLoad.java

package User;

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

/*
 * 查询功能:根据主键将一条数据从数据库中查询出来
 * */
public class TestLoad {

    public static void main(String[] args) {

    }
    private void testLoad() {
        //初始化,读取配置文件
        Configuration config = new Configuration().configure();
        //打开sessionFactory
        SessionFactory sessionFactory = config.buildSessionFactory();
        //创建session
        Session session = sessionFactory.openSession();
        //加载数据
        User user = (User)session.get(User.class, new Integer(1));
        //在控制台输出用户名和密码
        System.out.println(user.getLoginName()+" "+user.getLoginPwd());
    }
}
/*
 * 注意: 查询过程中,直接读取配置文件,打开sessionFactory,创建session即可。
 * 创建完session之后就可以根据主键查询数据,采用session.get(User.class, new Integer(1))
 * 查询过程中不需要事务处理过程,只有在修改或者添加数据的过程中才需要进行事务处理。
 * 还有就是session.get()的第一个参数是通过反射得到user对象的所有属性值,get方法调完之后就可以在控制台显示属性的信息。
 */

以上就是按照顺序实现增删改查的功能的过程和实现,我们可以发现,hibernate已经为我们封装好了这几种操作的接口,我们直接用session调用接口即可,只需要一句话就能完成增删改查操作,而不是像以前一样需要写sql语句自己完成增删改查过程。极大的简化了程序员的编码工作。

接下来是福利:(哈哈哈哈—)

我们可以在 eclipse中自动添加hibernate支持(通过配置直接添加),从而可以自动生成hibernate实体类和hibernate配置文件,配置完数据库的相关信息之后还可以直接生成映射文件。

1 . 我们自己实现的过程中,在测试类中需要读取配置信息,读取解析映射信息,创建session工厂最终生成session实例,最后调用session接口的方法实现增删改查操作。
2 . 但是当我们利用eclipse自动添加hibernate支持的时候,会自动创建工厂,我们只需要创建session实例即可。
3 . 接下来,我们在2的基础上,直接写一个BaseHibernateDao类,将数据的增删改查方法都写进去。
4 .写接口,写实现,实现继承BaseHibernateDao类,调方法实现功能。

(1)BaseHibernate.java

package User;

public interface BaseHibernate {
    public  void add(User user);
    public User get(Integer id);
    public void delete(User user);
    public void update(User user);
}

(2)BaseHibernateImpl.java

package User;

public class BaseHibernateImpl extends BaseHibernateDao implements BaseHibernate {

    @Override
    public void add(User user) {

        super.add(user);
    }

    @Override
    public User get(Integer id) {
        return (User)super.get(User.class, id);
    }

    @Override
    public void delete(User user) {

        super.delete(user);
    }

    @Override
    public void update(User user) {

        super.update(user);
    }

}

(3)BaseHibernateDao.java

package User;

import java.io.Serializable;

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

//是一个抽象类,抽象类的作用?为什么要写成抽象类?
public abstract class BaseHibernateDao {

    /* 添加数据 */
    // protected类型,无返回值,参数是 Object 类型(传进来user对象)
    protected void add(Object object) {
        Transaction tran = null;
        // 获取session
        // 如果eclipse自动创建一个HibernateSessionFactory的话,这里可以直接用
        // 即 Session session = HibernateSessionFactory.getSession();

        //常规方法获取session
        Configuration config = new Configuration().configure();
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession();

        //事务处理
        try {
            tran = session.beginTransaction();
            session.save(object);
            tran.commit();
        } catch(Exception e) {
            if(tran != null) {
                tran.rollback();//回滚
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    //添加没有返回值,但是查询有返回值,返回值类型是Object,参数类型是按照id升序排列的所有对象
    protected Object get(Class cla, Serializable id) {
        Object object = null;
        Configuration config = new Configuration().configure();
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession();
        try {
            object = session.get(cla, id);
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            session.close();
        }
        return object;
    }

    //删除数据,没有返回值
    protected void delete(Object object) {
        Transaction tran = null;
        Configuration config = new Configuration().configure();
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession();
        try {
            tran = session.beginTransaction();
            session.delete(object);
            tran.commit();
        } catch(Exception e) {
            if(tran != null) {
                tran.rollback();
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    //修改数据,无返回值
    protected void update(Object object) {
        Transaction tran = null;
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        try {
            tran = session.beginTransaction();
            session.update(object);
            tran.commit();
        } catch(Exception e) {
            if(tran != null) {
                tran.rollback();
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}
//在这个类中,实现了增删改查四种方法,我们为了方便调用,写一个接口,然后写一个实现类去实现这个接口,
//在实现类中继承本类,利用本类中的方法去实现功能。此后操作的时候就直接调用接口就可以实现增删改查的功能。

至此,eclipse自动添加hibernate的支持,完整实现对数据的增删改查。我们的工作就先告一段落!
待更!!!

版权声明:本文为博主原创文章,未经博主允许不得转载。

Hibernate映射的基本操作

Hibernate映射的基本操作                                                                      ++YONG原创,转载请注明...
  • qjyong
  • qjyong
  • 2007年10月17日 17:36
  • 15796

hibernate学习之七(hibernate映射map详解)

原来我们无论是学习一对多还是多对多,只有有集合的地方我们都是用的set来完成的,如果我们需要用map集合的时候,项目中该怎么实现那;简单了解篇下面我先来写一个简单的.从数据库看是2个表,但是从实体类看...
  • wufagang
  • wufagang
  • 2017年03月25日 20:37
  • 815

hibernate mapping配置详解

mapping配置有两种方式:注解和XML   对应的mapping文件都要配置在hibernate.cfg.xml中     1.XML ...
  • dare_
  • dare_
  • 2014年02月20日 09:29
  • 6289

Hibernate Mapping笔记

用Hibernate已经有一段时间了,觉得关键还是设计对象时与数据库的映射策略最为关键。故而将已前写的笔记再翻出来看了看,今天将其记录在这里(好久都没来这写东西了,近来项目超得紧)Hibernate ...
  • eastlift
  • eastlift
  • 2007年10月02日 17:55
  • 5876

深入Hibernate映射文件(二)——<hibernate-mapping>的属性

根元素中可以指定以下属性: (1)schema: 制定所映射的数据库的Schema名, ()catalog ()default-casade:设置Hibernate默认的级联风格,该属性的默认值...
  • Titilover
  • Titilover
  • 2012年02月28日 10:43
  • 4062

关于ormapping

ormapping的意思是object-relation mapping 对象关系映射。即表明ormapping是让对象跟数据库建立关系的框架。那么它是怎样建立关系的呢? 通过配置文件,拿我们老生常...
  • andy_px
  • andy_px
  • 2015年09月01日 21:02
  • 974

OR Mapping 的原理

OR-Mapping是面向对象分析设计的产物,主要解决对象层次的映射、对象关系的映射以及对象的持久化问题,也是分层设计要解决的问题之一。OR-Mapping会给程序设计带来那些好处呢?在面向对象的分层...
  • SpringFileld
  • SpringFileld
  • 2013年12月29日 17:25
  • 2516

ormapping框架和jdbc的比较

ormapping框架的优点和缺点: 优点 1,比较简单,简化了DAO层的编码工作 2,数据缓存:一级缓存 二级缓存 查询缓存 3,移植性比较好 缺点 1,因为sql语句...
  • A__17
  • A__17
  • 2015年09月23日 15:42
  • 529

自定义ORMapping—关系表转换为实体或实体集合对象

概述        ORMapping,中文翻译过来就是,关系对象的映射,他的作用就是使我们编程时,不用过多的关注持久层,只需要关注对象,关注业务就可以了。 ORMapping主要完成两个功能:自动生...
  • jiben2qingshan
  • jiben2qingshan
  • 2014年06月30日 22:46
  • 2147

OR Mapping的数据模式

程序语言已经由面向过程的模型全面转向为面向对象的模型,UML的出现更加革新了软件开发方法论。O/R Mapping的概念也就应运而生了。 为什么要提出O/R Mapping概念  程序语言已经由面向...
  • yaba213
  • yaba213
  • 2009年09月16日 08:53
  • 1861
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Hibernate(ORMapping) 上手实例与配置过程
举报原因:
原因补充:

(最多只允许输入30个字)