本节主要学习SpringBoot + JPA(底层使用Hibernate实现)集成案例。

1.JPA概述

1.1 JPA简介

JPA是Java Persistence API的简称，中文名Java持久化层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。

JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。针对主流的ORM技术进行统一：Hibernate，mybatis，Toplink，JDO，OpenJPA。

JPA是一种技术标准/规范，需要第三方ORM框架来具体支持，一般默认实现是Hibernate。

ORM框架的思想：面向对象的思想与面向关系的数据库进行关联映射。

1.2 JPA与EJB关系

由于历史的原因，EJB 3（Enterprise JavaBean 企业级JavaBean，重量级框架，对标Spring框架）与JPA有着藕断丝连的关系。EJB 2.X中，EJB有三种类型的Bean，分别是会话Bean（Session Bean）、实体Bean（Entity Bean）和消息驱动Bean（Message Driven Bean），需要大型web服务器支持(Jboss，WebSphere，WebLogic)。

随着EJB3规范的推出,EJB中的实体Bean(Enity Bean)逐渐被JPA规范所替代,这也是为什么JPA的规范会包含在EJB3的规范中的原因。但JPA不仅能够在EJB环境中使用,也能够在J2SE的环境中使用,相对于EJB2.X的实体BEAN,使用的范围更广。总之,简单的说,JPA虽然出自EJB3,但是其使用的范围却大于EJB3,不仅可以在JavaEE中,也可以在JavaSE的环境中。

1.3 JPA优势与劣势

事实上，JPA并不是一项技术，而是一种标准，因为JPA只是一套接口，本身不能完成任何事情。JPA只是规范了Java持久化的官方标准。JPA有以下几个优点：

可持久化Java对象：JPA能够直接持久化复杂的Java对象，并能够使用JPQL语言进行复杂的查询。JPQL是JPA专用的查询语言，是类似于SQL的面向对象的查询语言。

使用简单：JPA使用注释（Annotation）定义Java对象与关系数据库之间的映射，而传统的ORM多使用xml配置文件。JPA使用起来比ORM要方便。使用JPA不用关注底层使用什么数据库。

规范标准化：JPA是JCP组织发布的，是Java官方规定的统一的API。目前已经有多种框架实现JPA标准。使用了JPA的系统可以自由选择遵循JPA标准的框架，并能够自由更换。

事务性、大数据量：JPA底层使用关系数据库进行存储，因此具备关系数据库的特点，例如事务性、数据完整性、并发访问、大数据量等。

数据库无关性：JPA开发的系统与具体的数据库关联性很小，可以自由的切换不同的数据库，而不用考虑不同数据库的差异性。

同时JPA也不是一项完美的技术，它本身也有一些劣势：

数据库优化问题：程序员只关注面向对象的操作而不能直接操作SQL语句（ORM关注对象与SQL语句转换），导致程序员针对特定数据库优化比较困难；

复杂查询问题：ORM框架擅长增删改，不擅长查询，特别是复杂查询，包括多表查询、子查询、层次查询、递归查询等，无法利用特定数据库的特性。

对象关联映射问题：ORM框架涉及到对象关联映射（一对一，一对多，多对多），如果涉及到很多表，容易造成对象相互引用或死锁问题。

系统性能问题：JPA具体实现，都是针对JDBC的重度封装，开发效率会很高，但是在实际维护中系统性能问题尤为突出，真所谓开发一时爽,维护火葬场。

目前的整体趋势是：国内使用mybatis居多，国外使用JPA居多(JPA资料比较少，特别是性能优化)

2.JPA案例

2.1 创建SpringBoot项目

创建springboot-jpa项目，勾选以下选项：

2.2 进行数据库配置

在application.properties文件中进行如下配置：

# 端口配置
server.port=8080

# 数据源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot-jpa?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

# jpa配置
# 设置数据库
spring.jpa.database=mysql
# 设置自动生成策略,要慎重选择，生产环境必须是update
# create 每次系统运行都会创建数表，覆盖以前的表和数据
# create-drop 先创建后删除
# update 有表创建，表结构不一致，更新表结构,只能增加不能减少
# none 没有变化
# validate 创建ddl会进行验证，一般用的少
spring.jpa.hibernate.ddl-auto=update

#设置存储引擎 (mysql: InnoDB ==> 支持事务 ， MyISAM ==> 不支持事务)
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect

# 输出sql语句
spring.jpa.show-sql=true

2.3 编写实体类

package raky.train.entity;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

/**
 *
 * 使用jpa注解  ===> database ==>ddl==> 生成表
 *
 * @Entity 是一个实体，与数据库表对应的实体类
 * @Table(name = "user") 数据库的表名user ，默认是类名，首字母小写
 * @Id 主键
 * @GeneratedValue(strategy = GenerationType.IDENTITY) 主键的生成策略
 *      mysql一般使用GenerationType.IDENTITY 自动编号
 * @Column(name = "name",length = 64,nullable = false) 列名
 *   |==> name 列的名称
 *   |==> length 列的大小,默认值是255
 *   |==> nullable 是否为空 false 不为空，true 为空
 *   |==> columnDefinition  属性列定义
 *   |==> unique  唯一性 默认false，不唯一；true 唯一性
 *   |==> insertable 是否支持插入 默认是true
 *   |==> updatable  是否支持更新 默认是true
 *   |==> table  表名，一般不写
 *   |==> precision 列的总长度
 *   |==> scale 列的小数点占用的位数
 *
 *   decimal(8,2) ==> 8.总长度 2.小数位数 123456.78
 *
 *   precision属性和scale属性表示精度，
 *   当字段类型为double时，precision表示数值的总长度，scale表示小数点所占的位数
 *  @author  raky
 *
 */
@Entity
@Table(name = "user")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "name",length = 64,nullable = false)
    private String name;

    @Column(name = "pass",nullable = false)
    private String pass;

    @Column(name = "age",columnDefinition = "int(3) default 0")
    private Integer age;
}

2.4 编写持久化层接口

package raky.train.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import raky.train.entity.User;

/**
 * JpaRepository 父接口，已经包含了对数据库的CRUD操作
 * 程序员不用去写具体实现
 */
public interface UserDao extends JpaRepository<User,Integer>, JpaSpecificationExecutor<User> {
}

2.5 编写服务层代码

服务层接口：raky.train.service.UserService.java

package raky.train.service;

import raky.train.entity.User;
import java.util.List;

public interface UserService {
    int insert(User user);
    int update(User user);
    int delete(Integer id);
    User getOne(Integer id);
    List<User> getList(User user);
}

服务层实现类：raky.train.service.impl.UserServiceImpl.java

package raky.train.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import raky.train.dao.UserDao;
import raky.train.entity.User;
import raky.train.service.UserService;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public int insert(User user) {
       userDao.save(user);
       return 1;
    }
    @Override
    public int update(User user) {
        userDao.saveAndFlush(user);
        return 1;
    }
    @Override
    public int delete(Integer id) {
        userDao.deleteById(id);
        return 1;
    }
    @Override
    public User getOne(Integer id) {
        return  userDao.findById(id).get();
    }
    @Override
    public List<User> getList(User user) {
        return userDao.findAll(new Specification<User>(){
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> list = new ArrayList<Predicate>();
                if(!StringUtils.isEmpty(user.getName())){
                    list.add(criteriaBuilder.like(root.get("name").as(String.class),"%" + user.getName() + "%"));
                }
                if(user.getAge() != null && user.getAge() != 0){
                    list.add(criteriaBuilder.equal(root.get("age").as(Integer.class),user.getAge()));
                }
                return criteriaQuery.where(list.toArray(new Predicate[list.size()])).getRestriction();
            }
        });
    }
}

2.6 编写控制层代码

package raky.train.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import raky.train.entity.User;
import raky.train.service.UserService;
import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/insert",method = RequestMethod.POST)
    public int insert(@RequestBody User user){
        return userService.insert(user);
    }

    @RequestMapping(value = "/update",method = RequestMethod.POST)
    public int update(@RequestBody User user){
        return userService.update(user);
    }

    @RequestMapping(value = "/delete/{id}",method = RequestMethod.GET)
    public int delete(@PathVariable("id") Integer id){
        return userService.delete(id);
    }

    @RequestMapping(value = "/get/{id}",method = RequestMethod.GET)
    public User getOne(@PathVariable("id") Integer id){
        return userService.getOne(id);
    }

    @RequestMapping(value = "/list",method = RequestMethod.POST)
    public List<User> getList(@RequestBody User user){
        return userService.getList(user);
    }
}

2.7 调试运行

如何调试运行接口，请参考我的学习笔记《SpringBoot快速开发RESTful接口》案例。

以调用getOne为例，在浏览器中输入以下网址，运行结果如下：

控制器会打印具体的SQL语句，如下图：

2.8 JPA注解红色警告处理

实体类中JPA注解如果出现如下红色警告，具体如下：

解决方案：File ==》Settings ==》inspections，进行如下处理：

至此，SpringBoot整合JPA案例学习笔记整理完毕。如果对大家有帮助，整理不易，希望多点赞，多收藏和多转发，在此表示感谢。每天进步一点点，多实践多总结，越分享越快乐。有技术问题，欢迎大家沟通交流，或者在评论区留言。