SpringBoot系列教程JPA之指定id保存

I. 环境准备

下面简单的看一下后续的代码中，需要的配置（我们使用的是 mysql 数据库）
1. 表准备

沿用前一篇的表，结构如下
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;
  2. 项目配置 
  配置信息，与之前有一点点区别，我们新增了更详细的日志打印；本篇主要目标集中在添加记录的使用姿势，对于配置说明，后面单独进行说明 
  ## 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=
## jpa相关配置
spring.jpa.database=MYSQL
spring.jpa.hibernate.ddl-auto=none
spring.jpa.show-sql=true
spring.jackson.serialization.indent_output=true
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
  II. Insert 教程  
  首先简单的看一下，我们一般使用默认的数据库自增生成主键的使用方式，以便后面的自定义主键生成策略的对比 
  1. 自增主键 
  首先我们需要定义 PO，与数据库中的表绑定起来 
  @Data
@DynamicUpdate
@DynamicInsert
@Entity
@Table(name = "money")
public class MoneyPO {
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    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")
    @CreatedDate
    private Timestamp createAt;
    @Column(name = "update_at")
    @CreatedDate
    private Timestamp updateAt;
  注意上面的主键生成策略用的是 GenerationType.IDENTITY，配合 mysql 的使用就是利用数据库的自增来生成主键 id 
 * 新增数据
 * Created by @author yihui in 11:00 19/6/12.
public interface MoneyCreateRepositoryV2 extends JpaRepository<MoneyPO, Integer> {
  接下来保存数据就很简单了 
  private void addWithId() {
    MoneyPO po1 = new MoneyPO();
    po1.setId(20);
    po1.setName("jpa 一灰灰 1x");
    po1.setMoney(2200L + ((long) (Math.random() * 100)));
    po1.setIsDeleted((byte) 0x00);
    MoneyPO r1 = moneyCreateRepositoryV2.save(po1);
    System.out.println("after insert res: " + r1);
  强烈建议实际的体验一下上面的代码执行 
  首次执行确保数据库中不存在 id 为 20 的记录，虽然我们的 PO 对象中，指定了 id 为 20，但是执行完毕之后，新增的数据 id 却不是 20 
  Hibernate: select moneypo0_.id as id1_0_0_, moneypo0_.create_at as create_a2_0_0_, moneypo0_.is_deleted as is_delet3_0_0_, moneypo0_.money as money4_0_0_, moneypo0_.name as name5_0_0_, moneypo0_.update_at as update_a6_0_0_ from money moneypo0_ where moneypo0_.id=?
Hibernate: insert into money (is_deleted, money, name) values (?, ?, ?)
after insert res: MoneyPO(id=104, name=jpa 一灰灰 1x, money=2208, isDeleted=0, createAt=null, updateAt=null)
  上面是执行的 sql 日志，注意插入的 sql，是没有指定 id 的，所以新增的记录的 id 就会利用 mysql 的自增策略 
  当我们的 db 中存在 id 为 20 的记录时，再次执行，查看日志发现实际执行的是更新数据 
  Hibernate: select moneypo0_.id as id1_0_0_, moneypo0_.create_at as create_a2_0_0_, moneypo0_.is_deleted as is_delet3_0_0_, moneypo0_.money as money4_0_0_, moneypo0_.name as name5_0_0_, moneypo0_.update_at as update_a6_0_0_ from money moneypo0_ where moneypo0_.id=?
Hibernate: update money set create_at=?, money=?, name=?, update_at=? where id=?
after insert res: MoneyPO(id=20, name=jpa 一灰灰 1x, money=2234, isDeleted=0, createAt=null, updateAt=null)
  大胆猜测，save 的执行过程逻辑如 
      首先根据 id 到数据库中查询对应的数据 
      如果数据不存在，则新增（插入 sql 不指定 id） 
      如果数据存在，则判断是否有变更，以确定是否需要更新 
  2. 指定 id 
  那么问题来了，如果我希望当我的 po 中指定了数据库 id 时，db 中没有这条记录时，就插入 id 为指定值的记录；如果存在记录，则更新 
  要实现上面这个功能，自定义主键 id，那么我们就需要修改一下主键的生成策略了，官方提供了四种 
  取值 说明
GenerationType.TABLE 使用一个特定的数据库表格来保存主键
GenerationType.SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列
GenerationType.IDENTITY 主键由数据库自动生成（主要是自动增长型）
GenerationType.AUTO 主键由程序控制 
  从上面四种生成策略说明中，很明显我们要使用的就是 AUTO 策略了，我们新增一个 PO，并指定保存策略 
  @Data
@DynamicUpdate
@DynamicInsert
@Entity
@Table(name = "money")
public class AutoMoneyPO {
    @GeneratedValue(strategy = GenerationType.AUTO, generator = "myid")
    @GenericGenerator(name = "myid", strategy = "com.git.hui.boot.jpa.generator.ManulInsertGenerator")
    @Column(name = "id")
    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")
    @CreatedDate
    private Timestamp createAt;
    @Column(name = "update_at")
    @CreatedDate
    private Timestamp updateAt;
  采用自定义的生成策略，需要注意，@GenericGenerator(name = "myid", strategy = "com.git.hui.boot.jpa.generator.ManulInsertGenerator")这个需要有，否则执行会抛异常 
  这一行代码的意思是，主键 id 是由ManulInsertGenerator来生成 
 *  自定义的主键生成策略，如果填写了主键id，如果数据库中没有这条记录，则新增指定id的记录；否则更新记录
 *  如果不填写主键id，则利用数据库本身的自增策略指定id
 * Created by @author yihui in 20:51 19/11/13.
public class ManulInsertGenerator extends IdentityGenerator {
    @Override
    public Serializable generate(SharedSessionContractImplementor s, Object obj) throws HibernateException {
        Serializable id = s.getEntityPersister(null, obj).getClassMetadata().getIdentifier(obj, s);
        if (id != null && Integer.valueOf(id.toString()) > 0) {
            return id;
        } else {
            return super.generate(s, obj);
  具体的主键生成方式也比较简单了，首先是判断 PO 中有没有主键，如果有则直接使用 PO 中的主键值；如果没有，就利用IdentityGenerator策略来生成主键（而这个主键生成策略，正好是GenerationType.IDENTITY利用数据库自增生成主键的策略） 
  接下来我们再次测试插入 
  // 使用自定义的主键生成策略
AutoMoneyPO moneyPO = new AutoMoneyPO();
moneyPO.setId(20);
moneyPO.setName("jpa 一灰灰 ex");
moneyPO.setMoney(2200L + ((long) (Math.random() * 100)));
moneyPO.setIsDeleted((byte) 0x00);
AutoMoneyPO res = moneyCreateRepositoryWithId.save(moneyPO);
System.out.println("after insert res: " + res);
moneyPO.setMoney(3200L + ((long) (Math.random() * 100)));
res = moneyCreateRepositoryWithId.save(moneyPO);
System.out.println("after insert res: " + res);
moneyPO = new AutoMoneyPO();
moneyPO.setName("jpa 一灰灰 2ex");
moneyPO.setMoney(2200L + ((long) (Math.random() * 100)));
moneyPO.setIsDeleted((byte) 0x00);
res = moneyCreateRepositoryWithId.save(moneyPO);
System.out.println("after insert res: " + res);
  上面的代码执行时，确保数据库中没有主键为 20 的数据，输出 sql 日志如下 
  # 第一次插入
Hibernate: select automoneyp0_.id as id1_0_0_, automoneyp0_.create_at as create_a2_0_0_, automoneyp0_.is_deleted as is_delet3_0_0_, automoneyp0_.money as money4_0_0_, automoneyp0_.name as name5_0_0_, automoneyp0_.update_at as update_a6_0_0_ from money automoneyp0_ where automoneyp0_.id=?
Hibernate: insert into money (is_deleted, money, name, id) values (?, ?, ?, ?)
after insert res: AutoMoneyPO(id=20, name=jpa 一灰灰 ex, money=2238, isDeleted=0, createAt=null, updateAt=null)
# 第二次指定id插入
Hibernate: select automoneyp0_.id as id1_0_0_, automoneyp0_.create_at as create_a2_0_0_, automoneyp0_.is_deleted as is_delet3_0_0_, automoneyp0_.money as money4_0_0_, automoneyp0_.name as name5_0_0_, automoneyp0_.update_at as update_a6_0_0_ from money automoneyp0_ where automoneyp0_.id=?
Hibernate: update money set create_at=?, money=?, update_at=? where id=?
after insert res: AutoMoneyPO(id=20, name=jpa 一灰灰 ex, money=3228, isDeleted=0, createAt=null, updateAt=null)
# 第三次无id插入
Hibernate: insert into money (is_deleted, money, name) values (?, ?, ?)
after insert res: AutoMoneyPO(id=107, name=jpa 一灰灰 2ex, money=2228, isDeleted=0, createAt=null, updateAt=null)
  注意上面的日志输出 
      第一次插入时拼装的写入 sql 是包含 id 的，也就达到了我们指定 id 新增数据的要求 
      第二次插入时，因为 id=20 的记录存在，所以执行的是更新操作 
      第三次插入时，因为没有 id，所以插入的 sql 中也没有指定 id，使用 mysql 的自增来生成主键 id 
  II. 其他  
  0. 项目&博文 
     module: https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/102-jpa^[2] 
  1. 一灰灰 Blog 
  尽信书则不如，以上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现 bug 或者有更好的建议，欢迎批评指正，不吝感激 
  下面一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛 
      一灰灰 Blog 个人博客 
     https://blog.hhui.top 
      一灰灰 Blog-Spring 专题博客 
     http://spring.hhui.top 
   https://github.com/liuyueyi/spring-boot-demo: https://github.com/liuyueyi/spring-boot-demo 
   https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/102-jpa: https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/102-jpa 
   https://blog.hhui.top: https://blog.hhui.top 
   http://spring.hhui.top: http://spring.hhui.top 
                    前几天有位小伙伴问了一个很有意思的问题，使用 JPA 保存数据时，即便我指定了主键 id，但是新插入的数据主键却是 mysql 自增的 id；那么是什么原因导致的呢？又可以如何解决呢?本文将介绍一下如何使用 JPA 的 AUTO 保存策略来指定数据库主键 idI. 环境准备下面简单的看一下后续的代码中，需要的配置 （我们使用的是 mysql 数据库）1. 表准备沿用前一...
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
private String id;1234
这样也就指定了id和生成id所使用的策略，下面我们...
    @GeneratedValue(strategy = GenerationType.AUTO, generator = "myid")
    @GenericGenerator(name = "myid",
            strategy = "com.strategy.ManulInsertGenerator")
   	@Column(name = "id" )
	privat
				  最近开发过程中遇到一个很奇怪的问题，通过JPA保存数据后，将返回数据传入另一个方法中又保存了一遍，结果导致数据库中存在两条记录。按照正常得理解，保存后返回的数据在修改保存，应该还是一条数据。
  经过调试发现，第一次JPA保存后返回的数据ID与数据库中生成的ID不一致。这还是第一次遇到。网上搜索了下，发现有人说是数据库trigger的问题导致的。然后在数据库中查了下，该表果然有trigger...
				Spring-Data-Jpa 保存时save和saveAndFlush的区别
Jpa是我们经常用到的ORM框架，使用它可以快速便捷的操作数据库，那么它有一个保存方法，你肯定不会陌生，就是save方法和saveAndFlush，这两个方法可能会经常用到，那么什么时候使用save方法，什么时候使用saveAndFlush呢，下面就进行简单总结一下。
Jpa save
首先创建一个表，进行完整的代码演示。
-- auto-generated definition
create table t_user
/*创建客户表*/
    CREATE TABLE cst_customer (
      cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
      cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>
2. 在 application.properties 或 application.yml 中添加数据库连接配置和 MyBatis 相关配置，例如：
spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
mybatis.mapper-locations=classpath:mapper/*.xml
3. 编写 MyBatis 的 Mapper 接口和对应的 XML 文件，例如：
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM user WHERE id = #{id}")
    User findById(Long id);
<select id="findById" resultType="com.example.demo.entity.User">
    SELECT * FROM user WHERE id = #{id}
</select>
4. 在 Service 层中注入 Mapper，并使用对应的方法进行数据访问，例如：
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    public User findById(Long id) {
        return userMapper.findById(id);
5. 在 Controller 层中调用 Service 方法，例如：
@RestController
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping("/user/{id}")
    public User findById(@PathVariable Long id) {
        return userService.findById(id);
这样就完成了在 SpringBoot 中将 JPA 替换为 MyBatis 的过程。
取值	说明
`GenerationType.TABLE`	使用一个特定的数据库表格来保存主键
`GenerationType.SEQUENCE`	根据底层数据库的序列来生成主键，条件是数据库支持序列
`GenerationType.IDENTITY`	主键由数据库自动生成（主要是自动增长型）
`GenerationType.AUTO`	主键由程序控制