参考

背景

  • jpa自带的审计只关注了四个字段
    • @CreatedDate
    • @CreatedBy
    • @LastModifiedDate
    • @LastModifiedBy
  • 而业务需求中需要在填充两个个字段

实践 - 1

第一步 建立公共字段的实体

  • 关注点 @Embeddable ```java package io.tn.jpa.audit.bean;

import lombok.Getter; import lombok.Setter;

import javax.persistence.Column; import javax.persistence.Embeddable; import java.time.LocalDateTime;

/**

  • 测试审计 *
  • @author tn
  • @className AuditBean

  • @date 2021-02-03 12:09 */ @Embeddable @Getter @Setter public class AuditBean {

    /**

    • 创建人名称 */ @Column(columnDefinition = “ varchar(100) default ‘admin’ comment ‘创建人名称’”) private String createUserName;
  1. /**
  2.  * 创建人uuid
  3.  */
  4. @Column(columnDefinition = " varchar(100) default '1' comment '创建人uuid'")
  5. private String createUserUuid;
  7. /**
  8.  * 更新人名称
  9.  */
  10. @Column(columnDefinition = " varchar(100)  comment '更新人名称'")
  11. private String updateUserName;
  13. /**
  14.  * 更新人uuid
  15.  */
  16. @Column(columnDefinition = " varchar(100)  comment '更新人uuid'")
  17. private String updateUserUuid;
  20. /**
  21.  * 表示该字段为创建时间字段，在这个实体被insert的时候，会自动为其赋值
  22.  */
  23. @Column(columnDefinition = "timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建日期' ")
  24. private LocalDateTime createTime;
  27. /**
  28.  * 表示该字段为修改时间字段，在这个实体被update的时候，会自动为其赋值
  29.  */
  30. @Column(columnDefinition = "timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新日期'")
  31. private LocalDateTime updateTime;

}

  1. <a name="o2gOQ"></a>
  2. ## 第二步 数据实体实现公共字段
  4. - 关注点 `@Embeddable`
  5. - `@EntityListeners(AuditListener.class)`
  6. - `AuditListener.class<br />`
  7. ```java
  8. @Table(name = "mysql80")
  9. @Entity
  10. @Setter
  11. @Getter
  12. @Builder
  13. @AllArgsConstructor
  14. @NoArgsConstructor
  15. @DynamicInsert //动态插入
  16. @DynamicUpdate //动态赋值
  17. @EntityListeners(AuditListener.class)
  18. public class Mysql80 implements Auditable {
  19.     @Id
  20.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  21.     private Integer id;
  22.     private String name,sex;
  24.     @Embedded
  25.     private AuditBean audit;
  26. }

第三步 新增接口

  1. package io.tn.jpa.audit.config;
  3. import io.tn.jpa.audit.bean.AuditBean;
  5. public interface Auditable {
  7.     AuditBean getAudit();
  9.     void setAudit(AuditBean audit);
  10. }

第四步 使用上面新增的接口建立监听器

  • 关注点 @PrePersist @PreUpdate ```java package io.tn.jpa.audit.config;

import io.tn.jpa.audit.bean.AuditBean;

import javax.persistence.PrePersist; import javax.persistence.PreUpdate; import java.time.LocalDateTime;

public class AuditListener {

  1. @PrePersist
  2. public void setCreatedOn(Auditable auditable) {
  3.     AuditBean audit = auditable.getAudit();
  5.     if(audit == null) {
  6.         audit = new AuditBean();
  7.         auditable.setAudit(audit);
  8.     }
  10.     audit.setCreateUserUuid("123");
  11.     audit.setCreateUserName("asd");
  12.     audit.setCreateTime(LocalDateTime.now());
  13.     audit.setUpdateUserUuid("123");
  14.     audit.setUpdateUserName("asd");
  15.     audit.setUpdateTime(LocalDateTime.now());
  16. }
  18. @PreUpdate
  19. public void setUpdadtedOn(Auditable auditable) {
  20.     AuditBean audit = auditable.getAudit();
  21.     audit.setUpdateUserUuid("123");
  22.     audit.setUpdateUserName("asd");
  23.     audit.setUpdateTime(LocalDateTime.now());
  24. }

}

  1. <a name="cTMbv"></a>
  2. ## 第五步测试
  4. - dao
  5. ```java
  7. import com.detabes.jpa.server.dao.JpaBasicsDao;
  8. import io.tn.jpa.audit.bean.Mysql80;
  10. /**
  11.  * 测试审计
  12.  *
  13.  * @author tn
  14.  * @className Mysql80Dao
  15.  * @date 2021-02-03 12:12
  16.  */
  17. public interface Mysql80Dao extends JpaBasicsDao<Mysql80, Integer> {
  18.     @Query("update Mysql80 m set m.sex=?1 where m.id=?2 ")
  19.     @Modifying
  20.     @Transactional(rollbackOn=Exception.class)
  21.     int updata(String sex, Integer id);
  22. }
  • test
    • 注意点： 更新时发生了更新字段未更新，自定义sql时同样发生了字段为赋值 ```java package io.tn.jpa.audit;

import io.tn.jpa.audit.bean.Mysql80; import io.tn.jpa.audit.dao.Mysql80Dao; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest class AuditApplicationTests {

  1. @Resource
  2. private Mysql80Dao mysql80Dao;
  4. @Test
  5. void contextLoads() {
  6. }
  9. @Test
  10. void testJpaAudit(){
  11.     Mysql80 mysql80 = new Mysql80();
  12.     mysql80.setName("adaa");
  13.     mysql80.setSex("assda");
  14.     mysql80Dao.save(mysql80);
  15. }
  17.  @Test
  18. void testJpaAuditUpdate2() throws Exception {
  19.     Mysql80 mysql801 = mysql80Dao.findById(3).get();
  20.     mysql801.setSex("sad");
  21.     mysql801.setSex("323");
  22.     mysql80Dao.save(mysql801);
  23. }
  25. @Test
  26. void testJpaAuditUpdate() throws Exception {
  27.     Mysql80 mysql80 = new Mysql80();
  28.     mysql80.setName("我的");
  29.     mysql80.setSex("我的");
  30.     mysql80.setId(3);
  31.     mysql80Dao.updateEntity(mysql80,"id");
  32. }
  34. @Test
  35. void testJpaAuditSql(){
  36.     mysql80Dao.updata("mysql80",1);
  37. }

}

  1. <a name="d0Cak"></a>
  2. # 实践 - 2
  3. <a name="wI0QB"></a>
  4. ## 第一步 建立公共字段的实体
  6. - 关注点 `@EntityListeners({CustomAuditingListener.class})`
  7. - `CustomAuditingListener.class<br />`
  8. ```java
  9. package com.detabes.user.bean;
  11. import com.detabes.jpa.server.entity.mysql.JpaFields;
  12. import com.detabes.user.config.jpa.CustomAuditingListener;
  13. import lombok.Getter;
  14. import lombok.Setter;
  15. import org.hibernate.annotations.DynamicInsert;
  16. import org.hibernate.annotations.DynamicUpdate;
  17. import org.hibernate.annotations.SelectBeforeUpdate;
  19. import javax.persistence.*;
  21. /**
  22.  * 公共的实体类
  23.  *
  24.  * @author tn
  25.  * @className CommonBean
  26.  * @date 2021-01-21 14:20
  27.  */
  28. @MappedSuperclass
  29. @DynamicInsert
  30. @DynamicUpdate
  31. @SelectBeforeUpdate
  32. @Access(AccessType.FIELD)
  33. @Getter
  34. @Setter
  35. @EntityListeners({CustomAuditingListener.class})
  36. public class CommonBean<B> extends JpaFields<B> {
  38.     @Id
  39.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  40.     @Column(columnDefinition = "int(11) COMMENT '主键，自动生成'")
  41.     private Integer id;
  42.     /**
  43.      * 创建人名称
  44.      */
  45.     @Column(columnDefinition = " varchar(100) default 'admin'  comment '创建人名称'")
  46.     private String createUserName;
  48.     /**
  49.      * 创建人uuid
  50.      */
  51.     @Column(columnDefinition = " varchar(100) default '1'  comment '创建人uuid'")
  52.     private String createUserUuid;
  54.     /**
  55.      * 更新人名称
  56.      */
  57.     @Column(columnDefinition = " varchar(100)  comment '更新人名称'")
  59.     private String updateUserName;
  61.     /**
  62.      * 更新人uuid
  63.      */
  64.     @Column(columnDefinition = " varchar(100)  comment '更新人uuid'")
  65.     private String updateUserUuid;
  66. }

第二步 实体继承公共实体

  1. package com.detabes.user.bean;
  3. import lombok.Getter;
  4. import lombok.Setter;
  5. import org.hibernate.annotations.DynamicInsert;
  6. import org.hibernate.annotations.DynamicUpdate;
  8. import javax.persistence.Column;
  9. import javax.persistence.Entity;
  10. import javax.persistence.Index;
  11. import javax.persistence.Table;
  13. /**
  14.  * 测试
  15.  *
  16.  * @author tn
  17.  * @version 1
  18.  * @date 2021-01-22 10:05:52
  19.  */
  20. @Entity
  21. @Table(name = "test", schema = "test")
  22. @org.hibernate.annotations.Table(appliesTo = "test", comment = "测试")
  23. @Getter
  24. @Setter
  25. @DynamicUpdate
  26. @DynamicInsert
  27. public class TestBean extends CommonBean<TestBean> {
  29.     /**
  30.      * 全系统唯一UUID
  31.      */
  32.     @Column(columnDefinition = " varchar(100)  not null comment '全系统唯一UUID'")
  33.     private String uuid;
  35.     /**
  36.      * name
  37.      */
  38.     @Column(columnDefinition = " varchar(100)  not null comment 'name'")
  39.     private String name;
  41. }

第三步 注册监听器

  • 关注点 @PrePersist @PreUpdate ```java package com.detabes.user.config.jpa;

import com.detabes.user.util.RequestUtil; import com.detabes.user.vo.user.UserTokenVO; import org.springframework.beans.factory.aspectj.ConfigurableObject; import org.springframework.stereotype.Component;

import javax.persistence.PrePersist; import javax.persistence.PreUpdate; import java.lang.reflect.Field;

/**

  • description: jpa自动填充默认信息 *
  • @author lmz
  • @company Peter
  • @date 2021/2/3 13:41
  • @expection

  • @return */ @Component public class CustomAuditingListener implements ConfigurableObject { private final String[] CREATE_FILED = {“createUserName”, “createUserUuid”, “updateUserName”, “updateUserUuid”}; private final String[] UPDATE_FILED = {“updateUserName”, “updateUserUuid”};

    @PrePersist private void prePersist(Object obj) {

    1.  markForCreate(obj);

    }

    @PreUpdate private void preUpdate(Object obj) {

    1.  markForUpdate(obj);

    }

    /**

    • description: 新增时的填充 *
    • @param ae ae
    • @return void
    • @author lmz
    • @company Peter
    • @date 2021/2/3 13:45

    • @expection */ public void markForCreate(Object ae) { UserTokenVO userTokenInfo = RequestUtil.getUserTokenInfo(); String[] propertyValue = {userTokenInfo.getLoginName(), userTokenInfo.getUuid(), userTokenInfo.getLoginName()

      1.      , userTokenInfo.getUuid()};

      //反射填充字段 try {

      1.  addValue(ae, ae.getClass(), CREATE_FILED, propertyValue);

      } catch (Exception e) {

      1.  e.printStackTrace();

      }

      }

      /**

    • description: 更新时的填充 *
    • @param ae ae
    • @return void
    • @author lmz
    • @company Peter
    • @date 2021/2/3 13:46

    • @expection */ public void markForUpdate(Object ae) { UserTokenVO userTokenInfo = RequestUtil.getUserTokenInfo(); String[] propertyValue = {userTokenInfo.getLoginName(), userTokenInfo.getUuid()}; //反射填充字段 try {

      1.  addValue(ae, ae.getClass(), UPDATE_FILED, propertyValue);

      } catch (Exception e) {

      1.  e.printStackTrace();

      } }

      protected void addValue(Object object, Class<?> aClass, String[] propertyName, String[] propertyValue) throws NoSuchFieldException, IllegalAccessException { for (int i = 0; i < propertyName.length; i++) {

      1.  String filedName = propertyName[i];
      2.  Field declaredField = ReflectUtil.getField(aClass,filedName);
      3.  declaredField.setAccessible(true);
      4.  //填充对应的值
      5.  declaredField.set(object, propertyValue[i]);

      } } }

```

第四步测试

  • 同上
  • 注意点： 更新时发生了更新字段未更新义sql时同样发生了字段为赋值 在
  • 在实际使用中出现了事务问题
    • 在做查询后对其返回值进行修改后更新到表中出现了事务问题，原本方法是没有事物的，由于使用了上面的方法导致强行加上了事务，解决方法是在具体的数据库操作方法上加上事物