JPA基础使用

JPA入门–Hibernate使用

概念

什么是JPA?

JPA是Java Persistence API的简称。

JPA作为 Java EE 5.0 平台标准的 对象关系映射(ORM) 规范

将得到所有 Java EE 服务器的支持。 Sun 这次吸取了之前 EJB 规范惨痛失败的经历,在充分吸收现有 ORM 框架(如Hibernate)的基础上,得到了一个易于使用、伸缩性强的 ORM 规范。

从目前的开发社区的反应上看
JPA 受到了极大的支持和赞扬, JPA 作为 ORM 领域标准化整合者的目标已经实现

作用

直白点说,能够更好的对数据库进行操作管理,我们只需要操作JPA便可实现对数据库的CRUD

Hibernate

Hibernate是一个开放源代码的对象关系映射(ORM)框架,它对JDBC进行了非常轻量级(相对于EJB这一套)的对象封装,它将POJO(就是咱们的domain)与数据库表建立映射关系,是一个全自动的orm框架,Hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库

添加依赖

使用maven管理项目,在pom.xml里面加入依赖

pom.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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>jap</artifactId>
<groupId>com.ifueen.JPA</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>jap01</artifactId>

<dependencies>
<!-- hibernate核心包 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.8.Final</version>
</dependency>

<!-- hibernate对于jpa的支持包 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.3.8.Final</version>
</dependency>

<!-- mysql核心驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>

<!-- junit测试包 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

</dependencies>

</project>

idea自动将需要的包下载下来

配置核心文件persistence.xml

idea会自动生成persistence.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"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<persistence-unit name="jap01">

<properties>

<!-- 必配的 -->
<!-- 配置数据库链接 -->
<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
<property name="hibernate.connection.url" value="jdbc:mysql:///jpa"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="594395fzk"/>
<!-- 数据库方言 -->
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>

<!-- 选配-->
<!-- 生成组策略 -->
<property name="hibernate.hbm2ddl.auto" value="create"/>
<!-- 设置sql可见 -->
<property name="hibernate.show_sql" value="true"/>
<!-- 设置sql格式 -->
<property name="hibernate.format_sql" value="true"/>

</properties>
</persistence-unit>
</persistence>

生成数据表

新建实体类User

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
package com.ifueen.employee;

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

@Entity
@Table(name = "t_user")
public class User {
@Id
@GeneratedValue
private Long id;
private String name;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Id
public Long getId() {
return id;
}

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

public User() {
}

@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}

新建测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.ifueen.employee;

import org.junit.Test;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;


public class UserTest {
@Test
public void test(){
/*拿到工厂对象*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jap01");
/*创建EntityManager*/
factory.createEntityManager();
}
}

然后运行测试类,就可以生成,注意,前提是先要将相关的数据库建好

运行结果

CRUD操作

使用Hibernate进行增删改查操作

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
package com.ifueen.employee;

import org.junit.Test;

import javax.persistence.*;
import java.util.List;


public class UserTest {
@Test
public void test(){
/*拿到工厂对象*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jap01");
/*创建EntityManager*/
factory.createEntityManager();
}

/**
* 增加方法
* */
@Test
public void add(){
/*拿到工厂对象*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jap01");
/*创建EntityManager*/
EntityManager manager = factory.createEntityManager();
//开启事务
EntityTransaction transaction = manager.getTransaction();
transaction.begin();
//执行sql操作
User user = new User();
user.setName("远方只有在死亡中凝聚野花一片");
manager.persist(user);
//提交事务
transaction.commit();
//关闭资源
manager.close();
factory.close();
}

/**
* 查询单个方法
* */
@Test
public void find(){
/*拿到工厂对象*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jap01");
/*创建EntityManager*/
EntityManager manager = factory.createEntityManager();
//执行sql操作
User user = manager.find(User.class, 1L);
System.out.println(user);
//关闭资源
manager.close();
factory.close();
}

/**
* 查询所有方法
* */
@Test
public void findAll(){
/*拿到工厂对象*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jap01");
/*创建EntityManager*/
EntityManager manager = factory.createEntityManager();
//写jpql的语句
String 写jpql的语句="select u from User u";
//拿到查询的对象
Query query = manager.createQuery(写jpql的语句);
//执行查询,得到list集合
List resultList = query.getResultList();
//java8新新特性lmada表达式
resultList.forEach(e->{
System.out.println(e);
});
//关闭资源
manager.close();
factory.close();
}


/**
* 修改的方法
* */
@Test
public void update(){
/*拿到工厂对象*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jap01");
/*创建EntityManager*/
EntityManager manager = factory.createEntityManager();
//开启事务
EntityTransaction transaction = manager.getTransaction();
transaction.begin();
//先查询出需要更新的字段
User user = manager.find(User.class, 1L);
user.setName("九月");
//更新操作
manager.merge(user);
//提交事务
transaction.commit();
//关闭资源
manager.close();
factory.close();
}

/**
* 删除的方法
* */
@Test
public void delete(){
/*拿到工厂对象*/
EntityManagerFactory factory = Persistence.createEntityManagerFactory("jap01");
/*创建EntityManager*/
EntityManager manager = factory.createEntityManager();
//开启事务
EntityTransaction transaction = manager.getTransaction();
transaction.begin();
//先查询出需要更新的字段
User user = manager.find(User.class, 1L);
//执行删除操作
manager.remove(user);
//提交事务
transaction.commit();
//关闭资源
manager.close();
factory.close();
}


}

我们还可以将拿到EntityManager对象抽取出来成为一个工具类,在当前模块中进行使用,当然,抽取工具类完全看自己愿不愿意,都没关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.ifueen.util;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import java.lang.management.ManagementFactory;

/**
* JPA的工具类
* */
public class JPAUtil {
private JPAUtil() {}
private static EntityManagerFactory factory = null;
static {
factory = Persistence.createEntityManagerFactory("jpa01");
}
public static EntityManager getJpa(){
return factory.createEntityManager();
}
}

面试题:关于生成表结构的区别?

四种生成表结构的方式区别如下

1
2
3
4
5
6
7
8
9
10
11
<property name="hibernate.hbm2ddl.auto" value="update"/>
这种方式生成表结构会自动创建,然后在hibernate结束的时候将给删除,一般测试人员使用较多

<property name="hibernate.hbm2ddl.auto" value="create"/>
这种方式在每次运行的时候都会生成新的表,而且会覆盖之前的表,不太推荐使用

<property name="hibernate.hbm2ddl.auto" value="update"/>
这种方式在每次运行的时候都会去判断是否存在这张表,如果不存在就新建,如果存在就保留并且更新相关的字段,开发的时候用这种方式较多

<property name="hibernate.hbm2ddl.auto" value="validate"/>
这种方式在加载的时候先验证创建数据库表结构,只会和数据库中的表进行比较,不会创建新表,但是会插入新值
❤赏点钱让我买杯快乐水8❤