Spring Boot数据持久化方案---Spring Boot Jpa

数据持久化：关于数据持久化的方案有很多，常见的如JdbcTemplate、MyBatis等，JdbcTemplat配置简单、使用简单，但是其功能有限，而MyBatis功能齐全使用灵活，很多的公司也使用它来做持久化，而Jpa也是常用的持久化方案，今天我们就SpringBoot结合Jpa来做一个简单的持久化介绍。

Jpa介绍

Jpa（Java Persistence Api），java持久化Api，Jpa是一套ORM规范，而不是具体的实现，类似有JDBC，只提供规范，需要各数据库厂商做具体的实现，我们在Spring Boot中使用Jpa实际是就是Spring Data Jpa，Spring Data是Spring中的一个子项目，在使用中，只要我们的方法名符合其规范，它就知道你要干啥，而不需要我们自己去实现SQL。

项目搭建

使用IDEA创建Spring Boot项目，添加相关的依赖（web、mysql、jpa），如下图所示：

项目搭建后添加Druid依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.5.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.lzycug</groupId>
	<artifactId>spring-data-jpa-demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring-data-jpa-demo</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
			<version>5.1.27</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.10</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

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

</project>

至此项目环境搭建完成。

数据源及Jpa配置

在application.properties配置数据源信息及Jpa相关信息

#数据源配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/learn_test?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456
#jpa配置
spring.jpa.database=mysql
#是否在控制台打印sql
spring.jpa.show-sql=true
#数据库平台
spring.jpa.database-platform=mysql
#每次启动项目时，数据库的初始化策略
spring.jpa.hibernate.ddl-auto=update
#指定默认的存储引擎为InnoDB
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect

重点关注最后一行配置，默认在创建库表的时候会使用MyISAM来做表的引擎，在这里我们指定默认的存储引擎为InnoDB，这里有个坑，如果不设置这个信息的话，我们在项目启动的时候会报错提示无法注入我们的持久层Bean对象，这里需关注。

基本使用

使用ORM框架对象关系映射，我们无需自己去手动创建表，框架会根据实体类创建相对应的表，我们先创建一个user的实体类。

package com.lzycug.learn.jpa.entity;

import javax.persistence.*;

/**
 * description：
 * author：lzyCug
 * date: 2020/9/23 18:01
 */
@Entity(name = "t_user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

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

    private String password;

    private Integer age;

    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

使用@Entity注解来标识这是一个实体类，需要创建对应的库表，默认表明为类名，可使用name属性自定义表名，@Id注解说明这是表主键，@GeneratedValue注解定义主键的自增策略，对于表中的其他字段，默认会和属性名保持一致，可使用@Column注解来实现自定义属性字段，标明表中字段的名称，长度，是否为空等信息

@GeneratedValue注解定义主键的自增策略属性
–IDENTITY：采用数据库ID自增长的方式来自增主键字段，Oracle 不支持这种方式；
–AUTO：JPA自动选择合适的策略，是默认选项；
–SEQUENCE：通过序列产生主键，通过@SequenceGenerator注解指定序列名，MySql不支持这种方式
–TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。

配置完上面的信息后，在项目启动时会创建一个名为t_user的用户表

要对表信息进行持久化的操作，我们需要创建一个持久层接口，并继承Jpa提供的接口来实现一些公共的业务操作。

package com.lzycug.learn.jpa.dao;

import com.lzycug.learn.jpa.entity.User;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import java.util.List;

/**
 * description：
 * author：lzyCug
 * date: 2020/9/23 18:38
 */
public interface UserDao extends JpaRepository<User, Integer> {
    List<User> findUserByUsernameEqualsAndPasswordLike(String username, String password);

    @Query(value = "select * from t_user where age = (select max(age) from t_user)", nativeQuery = true)
    User getUserMaxAge();
}

我们自定义的持久层接口继承JpaRepository接口后，会有简单的一些CRUD方法，而且在Spring Data中，只要我们的命名符合其规范，我们也是不需要去自己编写SQL语句的，而对于一些特殊的要求就需要我们使用@Query注解来自定义sql实现功能。

模拟测试

编写service类注入dao接口对象

package com.lzycug.learn.jpa.service.impl;

import com.lzycug.learn.jpa.dao.UserDao;
import com.lzycug.learn.jpa.entity.User;
import com.lzycug.learn.jpa.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * description：
 * author：lzyCug
 * date: 2020/9/23 18:46
 */
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    public boolean saveUser(User user) {
        User saveUser = userDao.save(user);
        System.out.println(saveUser);
        return true;
    }

    @Override
    public List<User> findUserByUsernameEqualsAndPasswordLike(String username, String password) {
        return userDao.findUserByUsernameEqualsAndPasswordLike(username, password);
    }

    @Override
    public User getUserMaxAge() {
        return userDao.getUserMaxAge();
    }
}

编写controller注入service来进行测试

package com.lzycug.learn.jpa.controller;

import com.lzycug.learn.jpa.entity.Result;
import com.lzycug.learn.jpa.entity.User;
import com.lzycug.learn.jpa.service.UserService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * description：
 * author：lzyCug
 * date: 2020/9/23 18:47
 */
@RestController
@RequestMapping("/jpa")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping("save")
    public Result saveUser() {
        // 模拟客户端传递的用户信息
        User user = new User();
        user.setUsername("王五");
        user.setPassword("123456");
        user.setAge(25);
        user.setAddress("北京西单");
        boolean res = userService.saveUser(user);
        return res ? Result.ok() : Result.error();
    }

    @GetMapping("user")
    public Result<User> findUserByUsernameEqualsAndPasswordLike() {
        List<User> userList = userService.findUserByUsernameEqualsAndPasswordLike("李四", "123456");
        return Result.ok(userList);
    }

    @GetMapping("userMax")
    public Result<User> getUserMaxAge() {
        User user = userService.getUserMaxAge();
        return Result.ok(user);
    }
}

启动项目，使用测试工具访问接口，即可实现Spring Data Jpa持久化数据。