纯搭建Hibernate web项目框架

最新推荐文章于 2024-06-17 14:02:04 发布

美好阳光

最新推荐文章于 2024-06-17 14:02:04 发布

阅读量884

点赞数

导入相关jar包如下：

antlr-2.7.7.jar
dom4j-1.6.1.jar
geronimo-jta_1.1_spec-1.1.1.jar
hibernate-core-5.0.7.Final.jar
hibernate-commons-annotations-5.0.1.Final.jar
hibernate-entitymanager-5.0.7.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
jandex-2.0.0.Final.jar
javassist-3.18.1-GA.jar
jboss-logging-3.3.0.Final.jar
log4j-1.2.16.jar
mysql-connector-java-5.1.13-bin.jar
slf4j-api-1.6.1.jar
slf4j-log4j12-1.7.2.jar

搭建结构

src
| —— entity
| —— | —— User.java [实体类]
| —— hibernate
| —— | —— config
| —— | —— | —— hibernate.cfg.xml [Hibernate核心配置]
| —— | —— mapping
| —— | —— | —— User.hbm.xml [对象关系映射配置]
| —— | —— utils
| —— | —— | —— HibernateUtil.java [Hibernate工具类]
| —— test
| —— | —— UserTest.java [测试类]

Hibernate核心配置

[ hibernate.cfg.xml ]

<?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>
        <!-- 数据库驱动和连接地址 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
        <!-- 数据库用户名和密码 -->
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        <!-- 数据库连接池大小 -->
        <property name="hibernate.connection.pool.size">15</property>

        <!-- 分别是批量查询和批量增删改操作的数量，数值越大，内存损耗越大 -->
        <property name="jdbc.fetch_size">50</property>
        <property name="jdbc.batch_size">50</property>
        <!-- 结果集是否可滚动 -->
        <property name="jdbc.use_scrollable_resultset">false</property>

        <!-- 连接数据库时是否使用Unicode编码 -->
        <property name="Connection.useUnicode">true</property>
        <!-- 数据的编码方式 -->
        <property name="connection.characterEncoding">utf-8</property>

        <!-- 数据库“方言”类，它能将不同类型的sql语法转换成统一格式 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 是否在控制台输出sql语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 对象关系映射配置文件 -->
        <mapping resource="hibernate/mapping/User.hbm.xml" />
    </session-factory>
</hibernate-configuration>
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

数据库表和实体类

1.创建数据库和表

CREATE DATABASE test;

CREATE TABLE `user` (
  `id` varchar(8) NOT NULL,
  `name` varchar(16) NOT NULL default '' COMMENT '用户名',
  `pwd` varchar(16) NOT NULL default '' COMMENT '密码',
  `sex` tinyint(1) default '1' COMMENT '性别',
  `join_date` date default NULL COMMENT '注册时间',
  PRIMARY KEY  (`id`)
);
 
 1
2
3
4
5
6
7
8
9
10

2.创建实体类

实体类的属性跟数据库表的字段一一对应

[ User.java ]

package entity;

import java.util.Date;

public class User {

    private String id;      // id
    private String name;    // 用户名
    private String pwd;     // 密码
    private int sex;        // 性别
    private Date joinDate;  // 注册时间

    public User() {}

    public User(String id, String name, String pwd, int sex, Date joinDate) {
        super();
        this.id = id;
        this.name = name;
        this.pwd = pwd;
        this.sex = sex;
        this.joinDate = joinDate;
    }

    // getters and setters ...

}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.创建对象关系映射配置

即类属性和表字段的对应关系，Hibernate将根据该配置对数据库进行操作

[ User.hbm.xml ]

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="entity">
    <class name="User" table="user">
        <id name="id" column="id" />
        <property name="name" type="string" column="name" />
        <property name="pwd" type="string" column="pwd" />
        <property name="sex" type="int" column="sex" />
        <property name="joinDate" type="date" column="join_date" />
    </class>
</hibernate-mapping>
 
 1
2
3
4
5
6
7
8
9
10
11
12

Hibernate工具类

该工具类用于创建Session对象，Hibernate通过该对象对数据库进行操作

[ HibernateUtil.java ]

package hibernate.utils;

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

public class HibernateUtil {

    // 读取Hibernate配置文件并初始化SessionFactory
    static {
        String path = "hibernate/config/hibernate.cfg.xml";
        Configuration config = new Configuration().configure(path);
        factory = config.buildSessionFactory();
    }

    private static SessionFactory factory;

    /**
     * 获取开启着的session
     * @return
     */
    public static Session getSession() {
        return factory.openSession();
    }

    /**
     * 关闭session
     * @param session
     */
    public static void closeSession(Session session) {
        if (session != null) {
            if (session.isOpen()) {
                session.close();
            }
        }
    }

    /**
     * 获取SessionFactory
     * @return
     */
    public static SessionFactory getSessionFactory() {
        return factory;
    }

}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

测试

在这里，我使用了JUnit进行测试

[ UserTest.java ]

package test;

import hibernate.utils.HibernateUtil;
import org.hibernate.Session;
import entity.User;
import org.junit.Test;
import java.util.Date;

public class UserTest {

    /** 
     * 添加测试
     * */
    @Test
    public void addTest() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();     // 开始事务
        User user = new User("001", "YoriChan", "123456", 1, new Date());
        session.save(user);
        session.getTransaction().commit();
        System.out.println("添加成功");
        HibernateUtil.closeSession(session);
        // 添加成功
    }

    /** 
     * 删除测试
     * */
    @Test
    public void deleteTest() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        User user = new User();
        user.setId("001");
        session.delete(user);
        session.getTransaction().commit();
        System.out.println("删除成功");
        HibernateUtil.closeSession(session);
        // 删除成功
    }

    /**
     * 修改测试
     * */
    @Test
    public void updateTest() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        User user = new User("001", "陈昱霖", "123456", 1, new Date());
        session.update(user);
        session.getTransaction().commit();
        System.out.println("修改成功");
        HibernateUtil.closeSession(session);
        // 修改成功
    }

    /** 
     * 查询测试
     * 通过用户id进行查询
     * */
    @Test
    public void findTest() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        User user = session.load(User.class, "001");
        System.out.println("查询结果：" + user.getName());
        HibernateUtil.closeSession(session);
        // 查询结果：YoriChan
    }

}