JPA的入门案例

1.1    需求介绍

本章节我们是实现的功能是保存一个客户到数据库的客户表中。

1.2    开发包介绍

由于JPA是sun公司制定的API规范，所以我们不需要导入额外的JPA相关的jar包，只需要导入JPA的提供商的jar包。我们选择Hibernate作为JPA的提供商，所以需要导入Hibernate的相关jar包。

1.3    搭建开发环境[重点]

1.3.1     导入jar包

对于JPA操作，只需要从hibernate提供的资料中找到我们需要的jar导入到工程中即可。

• 传统工程导入jar包

　　

• maven工程导入坐标

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6 
 7     <groupId>cn.itheima</groupId>
 8     <artifactId>jpa-test</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10 
11     <properties>
12         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
13         <project.hibernate.version>5.0.7.Final</project.hibernate.version>
14     </properties>
15 
16     <dependencies>
17         <!-- junit -->
18         <dependency>
19             <groupId>junit</groupId>
20             <artifactId>junit</artifactId>
21             <version>4.12</version>
22             <scope>test</scope>
23         </dependency>
24 
25         <!-- hibernate对jpa的支持包 -->
26         <dependency>
27             <groupId>org.hibernate</groupId>
28             <artifactId>hibernate-entitymanager</artifactId>
29             <version>${project.hibernate.version}</version>
30         </dependency>
31 
32         <!-- c3p0 -->
33         <dependency>
34             <groupId>org.hibernate</groupId>
35             <artifactId>hibernate-c3p0</artifactId>
36             <version>${project.hibernate.version}</version>
37         </dependency>
38 
39         <!-- log日志 -->
40         <dependency>
41             <groupId>log4j</groupId>
42             <artifactId>log4j</artifactId>
43             <version>1.2.17</version>
44         </dependency>
45 
46         <!-- Mysql and MariaDB -->
47         <dependency>
48             <groupId>mysql</groupId>
49             <artifactId>mysql-connector-java</artifactId>
50             <version>5.1.6</version>
51         </dependency>
52 
53         <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
54         <dependency>
55             <groupId>org.projectlombok</groupId>
56             <artifactId>lombok</artifactId>
57             <version>1.18.8</version>
58             <scope>provided</scope>
59         </dependency>
60 
61     </dependencies>
62 
63 </project>

1.3.2     创建客户的数据库表和客户的实体类

• 创建客户的数据库表

 1     /*创建客户表*/
 2     CREATE TABLE cst_customer (
 3       cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
 4       cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
 5       cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
 6       cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
 7       cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
 8       cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
 9       cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
10       PRIMARY KEY (`cust_id`)
11     ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

• 创建客户的实体类

 1 public class Customer implements Serializable {
 2     
 3     private Long custId;
 4     private String custName;
 5     private String custSource;
 6     private String custIndustry;
 7     private String custLevel;
 8     private String custAddress;
 9     private String custPhone;
10     
11     public Long getCustId() {
12         return custId;
13     }
14     public void setCustId(Long custId) {
15         this.custId = custId;
16     }
17     public String getCustName() {
18         return custName;
19     }
20     public void setCustName(String custName) {
21         this.custName = custName;
22     }
23     public String getCustSource() {
24         return custSource;
25     }
26     public void setCustSource(String custSource) {
27         this.custSource = custSource;
28     }
29     public String getCustIndustry() {
30         return custIndustry;
31     }
32     public void setCustIndustry(String custIndustry) {
33         this.custIndustry = custIndustry;
34     }
35     public String getCustLevel() {
36         return custLevel;
37     }
38     public void setCustLevel(String custLevel) {
39         this.custLevel = custLevel;
40     }
41     public String getCustAddress() {
42         return custAddress;
43     }
44     public void setCustAddress(String custAddress) {
45         this.custAddress = custAddress;
46     }
47     public String getCustPhone() {
48         return custPhone;
49     }
50     public void setCustPhone(String custPhone) {
51         this.custPhone = custPhone;
52     }
53 }

1.3.3     编写实体类和数据库表的映射配置[重点]

• 在实体类上使用JPA注解的形式配置映射关系

 1 /**
 2 *        * 所有的注解都是使用JPA的规范提供的注解，
 3  *        * 所以在导入注解包的时候，一定要导入javax.persistence下的
 4  */
 5 @Entity //声明实体类
 6 @Table(name="cst_customer") //建立实体类和表的映射关系
 7 public class Customer {
 8     
 9     @Id//声明当前私有属性为主键
10     @GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
11     @Column(name="cust_id") //指定和表中cust_id字段的映射关系
12     private Long custId;
13     
14     @Column(name="cust_name") //指定和表中cust_name字段的映射关系
15     private String custName;
16     
17     @Column(name="cust_source")//指定和表中cust_source字段的映射关系
18     private String custSource;
19     
20     @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
21     private String custIndustry;
22     
23     @Column(name="cust_level")//指定和表中cust_level字段的映射关系
24     private String custLevel;
25     
26     @Column(name="cust_address")//指定和表中cust_address字段的映射关系
27     private String custAddress;
28     
29     @Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
30     private String custPhone;
31     
32     public Long getCustId() {
33         return custId;
34     }
35     public void setCustId(Long custId) {
36         this.custId = custId;
37     }
38     public String getCustName() {
39         return custName;
40     }
41     public void setCustName(String custName) {
42         this.custName = custName;
43     }
44     public String getCustSource() {
45         return custSource;
46     }
47     public void setCustSource(String custSource) {
48         this.custSource = custSource;
49     }
50     public String getCustIndustry() {
51         return custIndustry;
52     }
53     public void setCustIndustry(String custIndustry) {
54         this.custIndustry = custIndustry;
55     }
56     public String getCustLevel() {
57         return custLevel;
58     }
59     public void setCustLevel(String custLevel) {
60         this.custLevel = custLevel;
61     }
62     public String getCustAddress() {
63         return custAddress;
64     }
65     public void setCustAddress(String custAddress) {
66         this.custAddress = custAddress;
67     }
68     public String getCustPhone() {
69         return custPhone;
70     }
71     public void setCustPhone(String custPhone) {
72         this.custPhone = custPhone;
73     }
74 }

• 使用lombok（idea插件需要配置，还要引入jar包，最终版）

 1 package cn.itcast.domain;
 2 
 3 import lombok.Getter;
 4 import lombok.Setter;
 5 import lombok.ToString;
 6 
 7 import javax.persistence.*;
 8 
 9 /**
10  * 客户的实体类
11  *      配置映射关系
12  *
13  *
14  *   1.实体类和表的映射关系
15  *      @Entity:声明实体类
16  *      @Table : 配置实体类和表的映射关系
17  *          name : 配置数据库表的名称
18  *   2.实体类中属性和表中字段的映射关系
19  *
20  *
21  */
22 @Entity
23 @Setter
24 @Getter
25 @ToString
26 @Table(name = "cst_customer")
27 public class Customer {
28 
29     /**
30      * @Id：声明主键的配置
31      * @GeneratedValue:配置主键的生成策略
32      *      strategy
33      *          GenerationType.IDENTITY ：自增，mysql
34      *                 * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
35      *          GenerationType.SEQUENCE : 序列，oracle
36      *                  * 底层数据库必须支持序列
37      *          GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
38      *          GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
39      * @Column:配置属性和字段的映射关系
40      *      name：数据库表中字段的名称
41      */
42     @Id
43     @GeneratedValue(strategy = GenerationType.IDENTITY)
44     @Column(name = "cust_id")
45     private Long custId; //客户的主键
46 
47     @Column(name = "cust_name")
48     private String custName;//客户名称
49 
50     @Column(name="cust_source")
51     private String custSource;//客户来源
52 
53     @Column(name="cust_level")
54     private String custLevel;//客户级别
55 
56     @Column(name="cust_industry")
57     private String custIndustry;//客户所属行业
58 
59     @Column(name="cust_phone")
60     private String custPhone;//客户的联系方式
61 
62     @Column(name="cust_address")
63     private String custAddress;//客户地址
64 
65 }

• 常用注解的说明

        @Entity
            作用：指定当前类是实体类。
        @Table
            作用：指定实体类和表之间的对应关系。
            属性：
                name：指定数据库表的名称
        @Id
            作用：指定当前字段是主键。
        @GeneratedValue
            作用：指定主键的生成方式。。
            属性：
                strategy ：指定主键生成策略。
        @Column
            作用：指定实体类属性和数据库表之间的对应关系
            属性：
                name：指定数据库表的列名称。
                unique：是否唯一  
                nullable：是否可以为空  
                inserttable：是否可以插入  
                updateable：是否可以更新  
                columnDefinition: 定义建表时创建此列的DDL  
                secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]

1.3.4     配置JPA的核心配置文件

在java工程的src路径下创建一个名为META-INF的文件夹，在此文件夹下创建一个名为persistence.xml的配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
 3     <!--需要配置persistence-unit节点
 4         持久化单元：
 5             name：持久化单元名称
 6             transaction-type：事务管理的方式
 7                     JTA：分布式事务管理（（不同的表分不到不同的数据库，使用分布式事务管理））
 8                     RESOURCE_LOCAL：本地事务管理
 9     -->
10     <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
11         <!--jpa的实现方式 -->
12         <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
13 
14         <!--可选配置：配置jpa实现方的配置信息-->
15         <properties>
16             <!-- 数据库信息
17                 用户名，javax.persistence.jdbc.user
18                 密码，  javax.persistence.jdbc.password
19                 驱动，  javax.persistence.jdbc.driver
20                 数据库地址   javax.persistence.jdbc.url
21             -->
22             <property name="javax.persistence.jdbc.user" value="root"/>
23             <property name="javax.persistence.jdbc.password" value="root"/>
24             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
25             <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
26 
27             <!--配置jpa实现方(hibernate)的配置信息
28                 显示sql           ：   false|true
29                 自动创建数据库表    ：  hibernate.hbm2ddl.auto
30                         create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
31                         update      ：程序运行时创建表（如果有表，不会创建表）
32                         none        ：不会创建表
33 
34             -->
35             <property name="hibernate.show_sql" value="true" />
36             <property name="hibernate.hbm2ddl.auto" value="update" />
37         </properties>
38     </persistence-unit>
39 </persistence>

1.4    实现保存操作

 1 package cn.itheima.test;
 2 
 3 import cn.itcast.domain.Customer;
 4 import org.junit.Test;
 5 
 6 import javax.persistence.EntityManager;
 7 import javax.persistence.EntityManagerFactory;
 8 import javax.persistence.EntityTransaction;
 9 import javax.persistence.Persistence;
10 
11 public class JpaTest {
12 
13     /**
14      * 测试jpa的保存
15      * 案例：保存一个客户到数据库中
16      * Jpa的操作步骤
17      * 1.加载配置文件创建工厂（实体管理器工厂）对象
18      * 2.通过实体管理器工厂获取实体管理器
19      * 3.获取事务对象，开启事务
20      * 4.完成增删改查操作
21      * 5.提交事务（回滚事务）
22      * 6.释放资源
23      */
24     @Test
25     public void testSave() {
26         //1.加载配置文件创建工厂（实体管理器工厂）对象
27         EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
28         //2.通过实体管理器工厂获取实体管理器
29         EntityManager em = factory.createEntityManager();
30         //3.获取事务对象，开启事务
31         EntityTransaction tx = em.getTransaction(); //获取事务对象
32         tx.begin();
33         //4.完成增删改查操作：保存一个客户到数据库中
34         Customer customer = new Customer();
35         customer.setCustName("传智播客3");
36         customer.setCustIndustry("教育");
37         //保存，
38         em.persist(customer); //保存操作
39         //5.提交事务
40         tx.commit();
41         //6.释放资源
42         em.close();
43         factory.close();
44 
45     }
46 }