SpringBoot系列教程JPA之基础环境搭建

10次阅读

共计 5582 个字符，预计需要花费 14 分钟才能阅读完成。

JPA（Java Persistence API）Java 持久化 API，是 Java 持久化的标准规范，Hibernate 是持久化规范的技术实现，而 Spring Data JPA 是在 Hibernate 基础上封装的一款框架。JPA 作为标准，实际上并没有说局限于某个固定的数据源，事实上 mysql，mongo，solr 都是 ok 的。接下来我们将介绍下 springboot 结合 jpa 来实现 mysql 的 curd 以及更加复杂一点的 sql 支持

<!– more –>

jpa 系列教程将包含以下几块

  • 环境搭建
  • 基础的插入、修改、删除数据的使用姿势
  • 基础的单表查询，如(>, <, = , in, like, between)，分页，排序等
  • 多表关联查询
  • 事物使用

本篇为开始第一篇，先搭建一个可以愉快玩耍的 jpa 项目

I. 环境搭建

我们选择的数据库为 mysql，所以有必要先安装一下，这里跳过 mysql 的安装教程，直接进入 springboot 项目的搭建

1. pom 依赖

我们这里选择的是 2.0.4.RELEASE 版本进行演示

 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from update -->
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.45</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

上面的 pom 依赖中，关键的是下面两个，第一个引入的是 jpa 相关包，后面那个则是 mysql 的连接依赖，相当于指定操作 mysql 数据库

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

2. 数据准备

创建一个测试表进行后续的读写操作，为了后续的事物讲解方便，我们创建一个表，里面存了每个人的钱

CREATE TABLE `money` (`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT ''COMMENT' 用户名 ',
  `money` int(26) NOT NULL DEFAULT '0' COMMENT '钱',
  `is_deleted` tinyint(1) NOT NULL DEFAULT '0',
  `create_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

在表中随意插入几条数据，以方便后面使用

INSERT INTO `money` (`id`, `name`, `money`, `is_deleted`, `create_at`, `update_at`)
VALUES
    (1, '一灰灰 blog', 100, 0, '2019-04-18 17:01:40', '2019-04-18 17:01:40'),
    (2, '一灰灰 2', 200, 0, '2019-04-18 17:01:40', '2019-04-18 17:01:40');

3. 属性配置

创建 springboot 工程之后，添加 mysql 的相关配置，在 resources 目录下，新建文件 application.properties

## DataSource
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/story?useUnicode=true&characterEncoding=UTF-8&useSSL=false
#spring.datasource.driver-class-name= com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=

4. 项目构建并测试

根据 JPA 的一般使用姿势，我们需要针对上面的表，创建一个对应的 POJO 对象，将它们关联起来，代码如下：

  • 注意下几个注解 @Entity, @Table, @Column, @Id, @GeneratedValue
  • 注意下 POJO 中字段的类型，这里保证了和 db 的字段定义类型一致
  • （关于上面两点的更多知识点，后面的文章会给出更详细用法说明，欢迎持续跟进）
package com.git.hui.boot.jpa.entity;

import lombok.Data;

import javax.persistence.*;
import java.sql.Date;

/**
 * Created by @author yihui in 21:01 19/6/10.
 */
@Data
@Entity
@Table(name = "money")
public class MoneyPO {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;

    @Column(name = "name")
    private String name;

    @Column(name = "money")
    private Long money;

    @Column(name = "is_deleted")
    private Byte isDeleted;

    @Column(name = "create_at")
    private Date createAt;

    @Column(name = "update_at")
    private Date updateAt;
}

表结构定义完毕之后，接下来就是定义 db 的操作 api，jpa 的使用，通过方法名来解析出对应的 sql，我们这里定义一个简单的 Money 表的操作 API:

  • MoneyDemoRepository 继承自 JpaRepository
  • 两个泛型参数，第一个表示这个 repository 操作的表绑定的 POJO，第二个表示自增 id 类型
package com.git.hui.boot.jpa.repository;

import com.git.hui.boot.jpa.entity.MoneyPO;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * Created by @author yihui in 21:01 19/6/10.
 */
public interface MoneyDemoRepository extends JpaRepository<MoneyPO, Integer> {}

上面两个定义完毕之后，不需要其他的操作，就可以进行测试环境了，上面这个 Repository 提供了一些简单的操作

package com.git.hui.boot.jpa;

import com.git.hui.boot.jpa.demo.JpaQueryDemo;
import com.git.hui.boot.jpa.entity.MoneyPO;
import com.git.hui.boot.jpa.repository.MoneyDemoRepository;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Created by @author yihui in 20:58 19/6/10.
 */
@SpringBootApplication
public class Application {public Application(MoneyDemoRepository moneyDemoRepository) {MoneyPO moneyPO = moneyDemoRepository.findById(1).get();
        System.out.println(moneyPO);
    }

    public static void main(String[] args) {SpringApplication.run(Application.class);
    }
}

针对上面的测试 case 进行简单的说明，前面定义了一个 POJO 对象和一个 RepositoryAPI，我们想直接操作对应的表，需要借助这个RepositoryAPI 对象，但是它是接口类型，我们没法直接使用的，因为我们是在 Spring 生态体系中，所以可以直接通过 IoC 注入方式使用

所以上面的测试中，MoneyDemoRepository 对象实际上是由框架生成的一个代理对象，下面我们看下执行结果

5. 小结

从上面的步骤下来，会发现搭建一个 jpa 的项目工程属于比较简单的过程，添加必要的依赖，稍微注意的是两个

  • 创建一个 POJO 与我们实际的表关联起来
  • 创建一个 RepositoryApi 继承自org.springframework.data.repository.CrudRepository
  • 通过 IoC/DI 方式注入 RepositoryApi 对象，然后可以愉快的进行 db 操作

II. 其他

0. 项目

  • 工程：https://github.com/liuyueyi/spring-boot-demo
  • 项目: https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/102-jpa

1. 一灰灰 Blog

尽信书则不如，以上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现 bug 或者有更好的建议，欢迎批评指正，不吝感激

下面一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

  • 一灰灰 Blog 个人博客 https://blog.hhui.top
  • 一灰灰 Blog-Spring 专题博客 http://spring.hhui.top

正文完
jpa mysql springboot
发表至：无分类
2019-06-16
 0