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

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

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操作

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。