简单搭建
- 环境：java 1.8 ，idea 社区版本,mysql 8.0
- pom.xml依赖文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| <dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.13</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.2.Final</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
|
- 核心配置文件src-main-java-resources-hibernate.cfg.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 配置关于数据库连接的四个项：driverClass url username password -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/Shanghai</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">123456</property>
<!-- 可以将向数据库发送的SQL语句显示出来 -->
<property name="hibernate.show_sql">true</property>
<!-- 格式化SQL语句 -->
<property name="hibernate.format_sql">true</property>
<!-- hibernate的方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 配置hibernate的映射文件所在的位置 -->
<mapping resource="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
34
35
36
37
38
39
40
41
42
| package xyz.shi.domain;
public class User {
private int id;
private String name;
private String password;
public int getId() {
return id;
}
public User () {
}
public User(int id,String name, String password) {
this.name = name;
this.id = id;
this.password = password;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setPassword(String password) {
this.password = password;
}
public String getPassword() {
return password;
}
@Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", password=" + password +
'}';
}
}
|
- src-main-java-resources-User.hbm.xml 映射文件
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
| <?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="xyz.shi.domain">
<!--
name：即实体类的全名
table：映射到数据库里面的那个表的名称
catalog：数据库的名称
-->
<class name="User" table="users" catalog="test">
<!-- class下必须要有一个id的子元素 -->
<!-- id是用于描述主键的 -->
<id name="id" column="id">
<!-- 主键生成策略 -->
<generator class="native"/>
</id>
<!--
使用property来描述属性与字段的对应关系
如果length忽略不写，且你的表是自动创建这种方案，那么length的默认长度是255
-->
<property name="name" column="name" length="20"/>
<property name="password" column="password" length="20"/>
</class>
</hibernate-mapping>
|
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
| import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;
import org.junit.Test;
import xyz.shi.domain.User;
import java.util.List;
public class HibernateTest {
// 保存一个User
@Test
public void saveUserTest() {
// 创建一个User
User c = new User();
c.setName("叶子");
c.setPassword("1111");
// 使用Hibernate的API来完成将User信息保存到mysql数据库中的操作
Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession(); // 相当于得到一个Connection
// 开启事务
session.beginTransaction();
// 操作
session.save(c);
// 事务提交
session.getTransaction().commit();
session.close();
sessionFactory.close();
}
// 根据id查询一个User对象
@Test
public void findUserByIdTest() {
Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession(); // 相当于得到一个Connection
// 开启事务
session.beginTransaction();
// 根据业务来编写代码
User c = session.get(User.class, 10);
System.out.println(c.getName());
// 事务提交
session.getTransaction().commit();
session.close();
sessionFactory.close();
}
// 修改操作
@Test
public void updateUserTest() {
Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession(); // 相当于得到一个Connection
// 开启事务
session.beginTransaction();
// 根据业务来编写代码
User c = session.get(User.class, "62");
c.setName("郑敏");
session.update(c); // 修改操作
// 事务提交
session.getTransaction().commit();
session.close();
sessionFactory.close();
}
// 删除操作---根据id进行删除
@Test
public void deleteUserTest() {
Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession(); // 相当于得到一个Connection
// 开启事务
session.beginTransaction();
// 根据业务来编写代码
User c = session.get(User.class, "62");
session.delete(c); // 删除操作
// 事务提交
session.getTransaction().commit();
session.close();
sessionFactory.close();
}
// 查询所有User
@Test
public void findAllUserTest() {
Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession(); // 相当于得到一个Connection
// 开启事务
session.beginTransaction();
// 根据业务来编写代码
Query query = session.createQuery("from User"); // HQL语句，它类似于SQL语句
List<User> list = query.list();
for (User user : list) {
System.out.println(user);
}
// 事务提交
session.getTransaction().commit();
session.close();
sessionFactory.close();
}
}
|
优化代码
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
| package xyz.shi.domain.utils;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils {
// SessionFactory全局只需要有一个就可以了，因为它的创建和销毁需要消耗大量的资源，初始化信息会比较多，并且它是线程安全的，可以在多线程的环境下使用它
private static SessionFactory sessionFactory;
static {
// 初始化SessionFactory方式一：
/*
Configuration cfg = new Configuration(); // 代表配置文件的一个对象
cfg.configure(); // 读取默认的配置文件(hibernate.cfg.xml)
// cfg.configure("hibernate.cfg.xml"); // 读取指定位置的配置文件
sessionFactory = cfg.buildSessionFactory();
*/
// 初始化SessionFactory方式二：
sessionFactory = new Configuration() //
.configure() //
.buildSessionFactory(); // 方法链
}
/**
* 获取全局唯一的SessionFactory
*
* @return
*/
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* 从全局唯一的SessionFactory中打开一个Session
*
* @return
*/
public static Session openSession() {
return sessionFactory.openSession();
}
}
|
-
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
| package xyz.shi.entity;
import java.util.List;
public class QueryResult {
private int count; // 总记录数
private List list; // 一页的数据
public void setCount(int count) {
this.count = count;
}
public int getCount() {
return count;
}
public void setList(List list) {
this.list = list;
}
public List getList() {
return list;
}
public QueryResult(int count, List list) {
this.count = count;
this.list = list;
}
@Override
public String toString() {
return "QueryResult{" +
"count=" + count +
", list=" + list +
'}';
}
}
|
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
| package xyz.shi.dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import xyz.shi.domain.User;
import xyz.shi.entity.QueryResult;
import xyz.shi.utils.HibernateUtils;
import java.util.List;
public class UserDao {
/*
* 保存
*/
public void save(User user) {
Session session = HibernateUtils.openSession();
try {
Transaction tx = session.beginTransaction(); // 开启事务
session.save(user);
tx.commit(); // 提交事务
} catch (RuntimeException e) {
session.getTransaction().rollback(); // 回滚事务
throw e;
} finally {
session.close(); // 关闭session
}
}
/*
* 更新
*/
public void update(User user) {
Session session = HibernateUtils.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
session.update(user);// 操作
tx.commit();
} catch (RuntimeException e) {
tx.rollback();
throw e;
} finally {
session.close();
}
}
/*
* 删除
*/
public void delete(int id) {
Session session = HibernateUtils.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Object user = session.get(User.class, id); // 要先获取到这个对象
session.delete(user); // 删除的是实体对象
tx.commit();
} catch (RuntimeException e) {
tx.rollback();
throw e;
} finally {
session.close();
}
}
/*
* 根据id查询一个User数据
*/
public User getById(int id) {
Session session = HibernateUtils.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
User user = (User) session.get(User.class, id);// 操作
tx.commit();
return user;
} catch (RuntimeException e) {
tx.rollback();
throw e;
} finally {
session.close();
}
}
/*
* 查询所有
*/
public List<User> findAll() {
Session session = HibernateUtils.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
// 方式一：使用HQL语句
// 这里的FROM User 并不是表的名字，而是User.hbm.xml中的<class name="User" 这个name
List<User> list = session.createQuery("FROM User").list(); // 使用HQL查询
tx.commit();
return list;
} catch (RuntimeException e) {
tx.rollback();
throw e;
} finally {
session.close();
}
}
/**
* 分页的查询数据列表
* @param firstResult 从结果列表中的哪个索引开始取数据
* @param maxResults 最多取多少条数据
* @return 一页的数据列表
*/
@SuppressWarnings("unchecked")
public QueryResult findAll(int firstResult, int maxResults) {
Session session = HibernateUtils.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
// 查询一页的数据列表
// 方式一：
// Query query = session.createQuery("FROM User");
// query.setFirstResult(firstResult);
// query.setMaxResults(maxResults);
// List<User> list = query.list(); // 使用HQL查询
// 方式二：方法链
List<User> list = session.createQuery( //
"FROM User") //
.setFirstResult(firstResult) //
.setMaxResults(maxResults) //
.list();
// 查询总记录数
// session.createQuery("SELECT COUNT(*) FROM User").list().get(0);
// Long count = (Long) session.createQuery("SELECT COUNT(*) FROM User").uniqueResult();
Long count = (Long) session.createQuery( //
"SELECT COUNT(*) FROM User") //
.uniqueResult();
tx.commit();
// 返回结果
return new QueryResult(count.intValue(), list);
} catch (RuntimeException e) {
tx.rollback();
throw e;
} finally {
session.close();
}
}
}
|
session.createQuery(“FROM User”).list()，这里的FROM User 并不是表的名字，而是User.hbm.xml中的<class name=”User” 这个name
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
47
48
49
50
51
52
53
54
55
|
import org.junit.Test;
import xyz.shi.dao.UserDao;
import xyz.shi.domain.User;
import xyz.shi.entity.QueryResult;
import java.util.List;
public class UserDaoTest {
private UserDao userDao = new UserDao();
@Test
public void save() {
User user = new User();
user.setName("2222");
user.setPassword("11");
userDao.save(user);
}
@Test
public void update() {
User byId = userDao.getById(10);
byId.setName("456");
userDao.update(byId);
}
@Test
public void delete() {
userDao.delete(3);
}
@Test
public void getById() {
System.out.println(userDao.getById(10));
}
@Test
public void findAll() {
List<User> list = userDao.findAll();
for (User user : list) {
System.out.println(user);
}
}
@Test
public void findAll1() {
QueryResult result = userDao.findAll(0, 5);
System.out.println(result.getCount());
for (Object o : result.getList()) {
System.out.println(o);
}
}
}
|