hibernate入门

最新推荐文章于 2018-03-07 01:32:18 发布

YAOQINGGG

最新推荐文章于 2018-03-07 01:32:18 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏： hibernate 文章标签： hibernate 应用实例对象

本文链接：https://blog.youkuaiyun.com/YAOQINGGG/article/details/40161369

hibernate 专栏收录该内容

2 篇文章

订阅专栏

Hibernate简介

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库，一个J2EE数据库解决方案。

Hibernate的一个例子

这是一个完整的hibernate的例子的项目结构

1.其中role.java是一个普通的javabean

package com.hibernate;

public class Role {
	long roleId;
	String roleName;
	public long getRoleId() {
		return roleId;
	}
	public void setRoleId(long roleId) {
		this.roleId = roleId;
	}
	public String getRoleName() {
		return roleName;
	}
	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}
}

2.对象关系映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.hibernate">
    <class name="Role" table="role">
    	<id name="roleId" column="role_id">
            <generator class="native" />
        </id>
        <property name="roleName" type="java.lang.String" column="role_name" />
    </class>
</hibernate-mapping>

3.Hibernate的工具类，用来创建sessionFactory

package com.util;

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

public class HibernateUtil {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            return new Configuration().configure().buildSessionFactory();
        }
        catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

}

4.cfg文件，用来定义数据源，

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://127.0.0.1:3306/hibernate?useUnicode=true&characterEncoding=utf8</property>
        <property name="connection.username">root</property>
        <property name="connection.password">111111</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>

        <mapping resource="com/hibernate/Role.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

5.业务类，用来实现自己的逻辑

package com.impl;

import java.util.Date;

import org.hibernate.Session;

import com.hibernate.Role;
import com.util.HibernateUtil;

public class RoleImpl {

    public static void main(String[] args) {
    	RoleImpl mgr = new RoleImpl();

        mgr.insert("管理员");
        
        HibernateUtil.getSessionFactory().close();
    }

    private void insert( String roleName) {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        
        session.beginTransaction();

        Role theRole = new Role();
        theRole.setRoleName(roleName);
        session.save(theRole);

        session.getTransaction().commit();       
        
    }
}

核心接口

Hibernate的核心接口一共有6个，分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。这6个核心接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。

1) Session

Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSession对象称为用户session。

session接口的一些方法：

Transaction beginTransaction()

开始一个工作单元并返回一个与之相关Transaction对象，最为事务的开始，通常在需要对数据库进行更改例如save，update或delete时使用。在事务结束后需要调用Transaction的commit方法提交更改，该方法必须在Hibernate session关闭之前使用。

Query createQuery(String queryString)

返回一个给定HQL语句的Query对象。

SQLQuery createSQLQuery(String queryString)

返回一个用于执行原生SQL语句的SQLQuery对象

void delete(Object object)

删除与该对象关联的数据里内的一条记录。该对象可以是处于持久化状态也可以是处于瞬态但与数据库的记录有id联系。如果该对象的cascade属性为delete或all将会同时删除相关联的数据

Serializable save(Object object)

将一个实体实例持久化，返回该持久化实例的id。在持久化之前必须手动或自动的指派id。

void update(Object object)

通过给定的分离状态的实例的id更新数据库记录。如果在持久化类中有相同的id则会抛出异常。如果这个实例cascade设置为save-update或all是将同时更新所有关联的实例记录。

Void saveOrUpdate(Object object)

2) SessionFactory

SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。

3) Transaction

Transaction 接口是一个可选的API，可以选择不使用这个接口，取而代之的是Hibernate的设计者自己写的底层事务处理代码。Transaction接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA中的UserTransaction、甚至可以是CORBA事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移植。

4) Query

Query接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。

Query的一个用法：

// 执行sql语句，查询出list集合

Query query= session.createQuery( strHql );

query.setMaxResults(max);

query.setFirstResult(first);

List list= query.list();

// 更新的操作

Query q = session.createQuery("update Role set roleName='ad' where roleId='107'");

q.executeUpdate();

// 创建一个sqlQuery执行原生sql语句

SQLQuery sqlQuery = session.createSQLQuery(“select * from role where role_id=1”);

Query query= session.createQuery(“select * from role where roleId=1”);

5) Criteria

Criteria接口与Query接口非常类似，允许创建并执行面向对象的标准化查询。值得注意的是Query接口也是轻量级的，它不能在Session之外使用。

Criteria的用法：

Criteria criteria = session.createCriteria(User.class);
List users = criteria.list();

相当于执行了Hql语句：(Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_from T_USER this_)

查询也相当方便：例如查询” age”大于20且小于40的资料：
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.gt("age", new Integer(20)));
criteria.add(Restrictions.lt("age", new Integer(40)));
List users = criteria.list();

相当于执行了Hql语句： (Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_where this_.age>? and this_.age<?)

6) Configuration

Configuration 接口的作用是对Hibernate进行配置，以及对它进行启动。在Hibernate的启动过程中，Configuration类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。

Hibernate工作步骤

1、通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件。

2、由hibernate.cfg.xml中的<mappingresource="com/xx/User.hbm.xml"/>读取解析映射信息。

3、通过config.buildSessionFactory();//得到sessionFactory。
4、sessionFactory.openSession();//得到session。
5、session.beginTransaction();//开启事务。
6、persistent operate;
7、session.getTransaction().commit();//提交事务
8、关闭session;
9、关闭sessionFactory;