Hibernate小试

Hibernate框架

​ hibernate是一个对象关系映射框架(object relation mapping)，主要完成对象和关系模型之间的相互转化，对象可以持久化到关系型数据库中，关系型数据库中的模型也可以转换为实体对象。

​ 用一个用户登陆和注册例子演示Hibernate框架，本例采用逆向工程，用maven创建项目：

逆向工程就是先在数据库中建好表，根据表来创建相应的实体

建表语句：

DROP DATABASE IF EXISTS `test`;
CREATE DATABASE `test` DEFAULT charset=utf8;

USE `test`;

CREATE TABLE `tb_user`(
    `uid` INT PRIMARY KEY auto_increment,
    `username` VARCHAR(30) NOT NULL,
    `password` CHAR(32) NOT NULL,
    `email` VARCHAR(50) NOT NULL
)DEFAULT charset=utf8;

User类:

package com.feng.hibernate.domain;

import java.io.Serializable;

/**
 * 用户实体类
 */
public class User implements Serializable{
    private Integer id; //用户id
    private String username; //用户名
    private String password; //用户密码
    private String email; //邮箱

    public UserTest() {
    }

    public UserTest(String username, String password, String email) {
        this.username = username;
        this.password = password;
        this.email = email;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

现在User类是一个POJO(Plain Ordinary Java Object)

POJO类 创建的对象就是一个普通的java对象

POJO+annotation/XML => PO 普通的java对象加注解或XML配置变为可持久化对象

本例采用注解的方式配置实体类

注解配置比XML的耦合度高，但是注解配置简单，便于程序的开发

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity  //标注这个类是一个实体
@Table(name="tb_user") 
//标明该实体和数据库中的tb_user表对应，如果没有name属性则是类名和数据库中的表名对应
public class User implements Serializable{
    @Id //对应表中的主键
    @GeneratedValue(strategy=GenerationType.IDENTITY) //定义了主键的生成规则，为自增长
    @Column(name="uid") //对应的表中name
    private Integer id; //用户id
    private String username; //用户名
    private String password; //用户密码
    private String email; //邮箱

导官方的注解包，这样就降低和hibernate的耦合

XML配置

<?xml version="1.0"?>

<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.feng.hibernate.domain">

    <class name="User" table="tb_user">
        <id name="id" column="uid">
            <generator class="native"/>
        </id>
        <property name="username"/>
        <property name="password"/>
        <property name="email"/>
    </class>

</hibernate-mapping>

XML配置是耦合度最低的做法，但是XML配置复杂度大

文件名: User.hbm.xml

写实体类的注意事项：

• 实现Serializable接口
• 有id属性
• 保留无参构造方法
• 不要使用基本数据类型，使用其对应的包装类
• 不要用final修饰类

Hibernate配置文件：

<?xml version='1.0' encoding='utf-8'?>
<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<!DOCTYPE hibernate-configuration>

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <!-- 配置数据库的连接 采用了mysql5.7的版本 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/test?                           useUnicode=true&amp;characterEncodeing=utf8</property>
        <property name="connection.username">root</property>
        <property name="connection.password">feng</property>

        <!-- JDBC connection pool (use the built-in) -->
        <!-- 数据库连接池 -->
        <property name="connection.pool_size">10</property>

        <!-- SQL dialect -->
        <!-- 配置数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL57Dialect</property>

        <!-- Echo all executed SQL to stdout -->
        <!-- 这里配置是执行代码时按格式化显示Sql语句， 方便调试 -->
        <!-- 注意以后项目上线后这里需要注释掉或者该为false -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <!-- 这里主要是正向工程需要配置，本次采用逆向工程不要配置 -->
        <!-- 主要有两个值一个是create：数据库中没有表会根据实体创建对应的表，每次执行都会创建表 -->
        <!-- 一个是update数据库中没有也会创建对应的表，如果实体结构改变也会相应的更改表的结构 -->
        <!-- <property name="hbm2ddl.auto">update</property> -->

        <!-- 这里配置数据库会话与当前线程的绑定 -->
        <property name="current_session_context_class">thread</property>

        <!-- 实体映射的配置 -->
        <!-- 注解的方式配置 -->
        <mapping class="com.feng.hibernate.domain.User"/>
        <!-- XML的配置 -->
        <mapping resource="com/feng/hibernate/domain/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

该文件名为hibernate.cfg.xml，放在src工程目录下

maven添加hibernate依赖包

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.2.10.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
</dependency>

Hibernate工具类:

package com.feng.hibernate.util;

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

/**
 * hibernate工具类
 */
public final class HibernateUtil {
    private static SessionFactory factory;
    static {
        factory = new Configuration().configure().buildSessionFactory();
    }
    private HibernateUtil() {
        throw new AssertionError();
    }

    /**
     * 获得与当前上下文绑定的session对象
     * @return session对象
     */
    public static Session getSession() {
        return factory.getCurrentSession();
    }
}

Hibernate的会话工厂在整个项目中只需存在一个实例，通过工厂获取Session对象，可以通过getCurrentSession()方法和openSession方法。

• openSession()获取Session对象，每次都会获取重新获取一个Session对象
• getCurrentSession()获取与线程绑定的Session对象，当线程中没有这个对象时就创建这个对象并与当前线程绑定，如果当前线程中有了Session对象就直接从线程中拿Session类的对象，不会再创建新的Session对象，这样可以避免线程的资源竞争和多次的创建没必要的Session对象浪费性能

持久层:

• 接口的设计

package com.feng.hibernate.persistent;

import com.feng.hibernate.domain.User;

/**
 * 用户数据操作接口
 */
public interface UserDao {
    /**
     * 根据用户名查找用户
     * @param name 用户民
     * @return 存在放回User对象，否则返回null
     */
    User findByUsername(String name);
    /**
     * 保存用户
     * @param user 用户对象
     * @return 保存成功返回主键，否则返回null
     */
    Integer save(User user);
    /**
     * 根据id查找用户
     * @param id 主键
     * @return 存在返回User对象，否则返回null
     */
    User findById(Integer id);

    /**
     * 根据id更新信息
     * @param user User对象
     * @return 更新成功返回更新后的对象，否则返回null
     */
    User updateById(User user);
}

• 实现类

package com.feng.hibernate.persistent.impl;

import java.util.List;

import com.feng.hibernate.domain.User;
import com.feng.hibernate.persistent.UserDao;
import com.feng.hibernate.util.HibernateUtil;


public class UserDaoImpl implements UserDao{

    @Override
    public User findByUsername(String name) {
        List<User> users = HibernateUtil.getSession().createQuery("from User as u where u.username=:username",User.class)
            .setParameter("username", name).getResultList();
        return users.size()==1?users.get(0):null;
    }

    @Override
    public Integer save(User user) {
        User temp = this.findByUsername(user.getUsername());
        if(temp==null) {
            return (Integer) HibernateUtil.getSession().save(user);
        }
        return null;
    }

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

    @Override
    public User updateById(User user) {
        return (User) HibernateUtil.getSession().merge(user);
    }
}

测试代码

package com.feng.hibernate.persistent.impl;

import javax.persistence.NamedNativeQuery;

import org.hibernate.Session;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import com.feng.hibernate.domain.User;
import com.feng.hibernate.persistent.UserDao;
import com.feng.hibernate.util.HibernateUtil;

public class UserDaoImplTest {
    private static UserDao UserDao = new UserDaoImpl();
    private static Session session;

    @Before
    public void testUp() {
        session = HibernateUtil.getSession();
        session.beginTransaction();
    }

    @After
    public void testDown() {
        session.getTransaction().commit();
        session.close();
    }
    @Test
    public void testSave() {
        Integer key = UserDao.save(new User("段誉", "12345", "12345@qq.com"));
        Assert.assertNotNull(key);
        System.out.println(key);
        Integer key1 = UserDao.save(new User("段誉", "12345", "12345@qq.com"));
        Assert.assertNull(key1);
    }

    @Test
    public void testFindByName() {
        User user = UserDao.findByUsername("段誉");
        Assert.assertNotNull(user);
        System.out.println(user);
        User user1 = UserDao.findByUsername("段誉123");
        Assert.assertNull(user1);
    }

    @Test
    public void testFindById() {
        User user = UserDao.findById(1);
        Assert.assertNotNull(user);
        System.out.println(user);
        User user1 = UserDao.findById(2);
        Assert.assertNull(user1);
    }

    @Test
    public void testUpdateById() {
        User temp = new User("段誉1234", "12345", "12345@qq.com");
        temp.setId(1);
        User user = UserDao.updateById(temp);
        Assert.assertNotNull(user);
        System.out.println(user);
    }
}