Hibernate小试

来源：互联网发布：闾丘露薇知乎编辑：程序博客网时间：2024/06/05 05:35

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);    }}

阅读全文

0 0