Auditing related notes

Auditing  What does it mean ？

Auditing  It's for our audit , When we operate a record , You need to know who created this 、 When was it created 、 Who was the last modifier 、 When is the last modification time , You even need to modify the record …… These are all  Spring Data JPA  Inside  Auditing  Supported by , It provides us with four annotations to complete the above series of things , as follows ：

• @CreatedBy  Which user created it .

• @CreatedDate  When it was created .

• @LastModifiedBy  Finally, the user who modifies the entity .

• @LastModifiedDate  Time of last modification .

This is it.  Auditing  了 , So how to realize it ？

Auditing  How to achieve ？

Use the above four annotations to implement the method , There are three ways to achieve  Auditing, Let's have a look at .

The first way ： Directly add the above four annotations to the example

We also use the previous example , hold  User  Add four fields to the entity , Record the creator respectively 、 Creation time 、 Last modified by 、 Last modified .

First step ： stay  @Entity：User  Add four comments inside , And the new  @EntityListeners(AuditingEntityListener.class)  annotation .

And then when we're done ,User  The entity code of is as follows ：

@Entity

@Data

@Builder

@AllArgsConstructor

@NoArgsConstructor

@ToString(exclude = "addresses")

@EntityListeners(AuditingEntityListener.class)

public class User implements Serializable {

 @Id

 @GeneratedValue(strategy= GenerationType.AUTO)

 private Long id;

 private String name;

 private String email;

 @Enumerated(EnumType.STRING)

 private SexEnum sex;

 private Integer age;

 @OneToMany(mappedBy = "user")

 @JsonIgnore

 private List<UserAddress> addresses;

 private Boolean deleted;

 @CreatedBy

 private Integer createUserId;

 @CreatedDate

 private Date createTime;

 @LastModifiedBy

 private Integer lastModifiedUserId;

 @LastModifiedDate

 private Date lastModifiedTime;

}


stay  @Entity  In the entity, we need to do two operations ：

1. The four main fields record the creator 、 Creation time 、 Last modified by 、 Last modified , The code is as follows ：

 @CreatedBy

 private Integer createUserId;

 @CreatedDate

 private Date createTime;

 @LastModifiedBy

 private Integer lastModifiedUserId;

 @LastModifiedDate

 private Date lastModifiedTime;


2. among  AuditingEntityListener  It can't be less , Must pass this code ：

@EntityListeners(AuditingEntityListener.class)


stay  Entity  Annotate the entity of .

The second step ： Realization  AuditorAware  Interface , tell  JPA  Who is the current user .

We need to achieve  AuditorAware  Interface , as well as  getCurrentAuditor  Method , And return a  Integer  Of  user ID.

public class MyAuditorAware implements AuditorAware<Integer> {

 // Need to achieve AuditorAware Interface , Return to the current user ID

 @Override

 public Optional<Integer> getCurrentAuditor() {

 ServletRequestAttributes servletRequestAttributes =

 (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

 Integer userId = (Integer) servletRequestAttributes.getRequest().getSession().getAttribute(&quot;userId&quot;);

 return Optional.ofNullable(userId);

 }

}


The key step here , It's the realization of  AuditorAware  Interface method , As shown below ：

public interface AuditorAware<T> {

 T getCurrentAuditor();

}


It should be noted that ： Get users here  ID  There is more than one way , In practice , We may put the current  user  The information is in  Session  in , Maybe put the current information on  Redis  in , It could also be placed in  Spring  Of  security  Internal management . Besides , The implementation here will be slightly different , We use  security  For example ：

Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

if (authentication == null || !authentication.isAuthenticated()) {

 return null;

}

Integer userId = ((LoginUserInfo) authentication.getPrincipal()).getUser().getId();


Get at this time  userId  Your code may look like this , Just know about it .

The third step ： adopt  @EnableJpaAuditing  Annotations to open  JPA  Of  Auditing  function .

The third step is the most important step , If you want to make the above configuration effective , We need to turn on  JPA  Of  Auditing  function （ It is not turned on by default ）. The annotation to be used here is  @EnableJpaAuditing, The code is as follows ：

@Inherited

@Documented

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Import(JpaAuditingRegistrar.class)

public @interface EnableJpaAuditing {

//auditor User acquisition method , The default is to find AuditorAware Implementation class of ;

String auditorAwareRef() default "";

// Whether to set the time when creating and modifying , The default is true

boolean setDates() default true;

// Whether it is also used as modification when creating , The default is true

boolean modifyOnCreate() default true;

// How to generate time , The default is to take the current time ( Why provide this function ？ Because you may want to keep the same time during the test , It provides a custom method );

String dateTimeProviderRef() default "";

}


In understanding @EnableJpaAuditing After the annotation , We need to create one Configuration  file , add to  @EnableJpaAuditing  annotation , And put our  MyAuditorAware  Load it in , As shown below ：

@Configuration

@EnableJpaAuditing

public class JpaConfiguration {

 @Bean

 @ConditionalOnMissingBean(name = "myAuditorAware")

 MyAuditorAware myAuditorAware() {

 return new MyAuditorAware();

 }

}


Wise remark of an experienced person ：

• Here's a  Congifuration  Best practice writing . Why should we write a separate JpaConfiguration Configuration file for , Rather than taking @EnableJpaAuditing  Put it in  JpaApplication  In the class of ？ Because in that case  JpaConfiguration  Files can be loaded separately 、 Individual test , If it's all in  Appplication  Words in class , Don't you have to start the whole application every time you test ？

• MyAuditorAware  It can also be done through  @Component  Load annotation , Why do I recommend  @Bean  What is the way? ？ Because this way, users can know which components we have customized directly through our configuration file , Will not let the user have unnecessary surprise , This is a bit of writing  framework  Experience , For your reference .

Step four ： Let's write a test case to test it .

@DataJpaTest

@TestInstance(TestInstance.Lifecycle.PER_CLASS)

@Import(JpaConfiguration.class)

public class UserRepositoryTest {

 @Autowired

 private UserRepository userRepository;

 @MockBean

 MyAuditorAware myAuditorAware;

 @Test

 public void testAuditing() {

 // Because test case simulation web context Environment is not our focus , We use @MockBean,mock Lose our way , Looking forward to returning 13 This user ID

 Mockito.when(myAuditorAware.getCurrentAuditor()).thenReturn(Optional.of(13));

 // We don't explicitly specify the update time 、 Creation time 、 Updated by 、 founder

 User user = User.builder()

 .name("jack")

 .email("[email protected]")

 .sex(SexEnum.BOY)

 .age(20)

 .build();

 userRepository.save(user);

 // Verify whether there is a creation time 、 Update time ,UserID Whether it is right ;

 List<User> users = userRepository.findAll();

 Assertions.assertEquals(13,users.get(0).getCreateUserId());

 Assertions.assertNotNull(users.get(0).getLastModifiedTime());

 System.out.println(users.get(0));

 }

}


It should be noted that ：

• We make use of  @MockBean  simulation  MyAuditorAware  Return results  13  This  UserID;

• We test and verify  create_user_id  Is it what we expect .

The test results are as follows ：

User(id=1, name=jack, [email protected], sex=BOY, age=20, deleted=null, createUserId=13, createTime=Sat Oct 03 21:19:57 CST 2020, lastModifiedUserId=13, lastModifiedTime=Sat Oct 03 21:19:57 CST 2020)


The result is exactly what we expected .

So now, have you learned  Auditing  The first way ？ Besides ,Spring Data JPA  It also provides us with the second way ： Entities directly implement  Auditable  Interface can , Let's take a look .

The second way ： The entity implements Auditable  Interface

Let's change the upper  User  Entity object , as follows ：

@Entity

@Data

@Builder

@AllArgsConstructor

@NoArgsConstructor

@ToString(exclude = "addresses")

@EntityListeners(AuditingEntityListener.class)

public class User implements Auditable<Integer,Long, Instant> {

 @Id

 @GeneratedValue(strategy= GenerationType.AUTO)

 private Long id;

 private String name;

 private String email;

 @Enumerated(EnumType.STRING)

 private SexEnum sex;

 private Integer age;

 @OneToMany(mappedBy = &quot;user&quot;)

 @JsonIgnore

 private List<UserAddress> addresses;

 private Boolean deleted;

 private Integer createUserId;

 private Instant createTime;

 private Integer lastModifiedUserId;

 private Instant lastModifiedTime;

 @Override

 public Optional<Integer> getCreatedBy() {

 return Optional.ofNullable(this.createUserId);

 }

 @Override

 public void setCreatedBy(Integer createdBy) {

 this.createUserId = createdBy;

 }

 @Override

 public Optional<Instant> getCreatedDate() {

 return Optional.ofNullable(this.createTime);

 }

 @Override

 public void setCreatedDate(Instant creationDate) {

 this.createTime = creationDate;

 }

 @Override

 public Optional<Integer> getLastModifiedBy() {

 return Optional.ofNullable(this.lastModifiedUserId);

 }

 @Override

 public void setLastModifiedBy(Integer lastModifiedBy) {

 this.lastModifiedUserId = lastModifiedBy;

 }

 @Override

 public void setLastModifiedDate(Instant lastModifiedDate) {

 this.lastModifiedTime = lastModifiedDate;

 }

 @Override

 public Optional<Instant> getLastModifiedDate() {

 return Optional.ofNullable(this.lastModifiedTime);

 }

 @Override

 public boolean isNew() {

 return id==null;

 }

}


The difference from the first method is , Here we need to get rid of the four notes mentioned above , And implement the interface  Auditable  Methods , The code will become redundant and cumbersome .

Everything else remains the same , Let's run the test case just now again , It turns out that the effect is the same . Judging from the complexity of the code , I don't recommend this method . Then let's take a look at the third way .

The third way ： utilize  @MappedSuperclass  annotation

We are the first  6  I mentioned this annotation when I talked about the polymorphism of objects in class , It is mainly used to solve public  BaseEntity  The problem of , And it represents that each class that inherits it is an independent table .

Let's take a look first  @MappedSuperclass  The grammar of .

There is nothing in its annotation , In fact, it represents an abstract relationship , That is, the public fields of all subclasses . Then let's take a look at an example .

First step ： Create a  BaseEntity, There are some public fields and annotations of entities .

package com.example.jpa.example1.base;

import org.springframework.data.annotation.*;

import javax.persistence.MappedSuperclass;

import java.time.Instant;

@Data

@MappedSuperclass

@EntityListeners(AuditingEntityListener.class)

public class BaseEntity {

 @CreatedBy

 private Integer createUserId;

 @CreatedDate

 private Instant createTime;

 @LastModifiedBy

 private Integer lastModifiedUserId;

 @LastModifiedDate

 private Instant lastModifiedTime;

}


Be careful ：

  BaseEntity We need to use the four notes mentioned above , And add @EntityListeners(AuditingEntityListener.class), In this way, all subclasses do not need to be added .

The second step ： Entities inherit directly  BaseEntity  that will do .

Let's revise the above  User  Instance inheritance  BaseEntity, The code is as follows ：

@Entity

@Data

@Builder

@AllArgsConstructor

@NoArgsConstructor

@ToString(exclude = "addresses")

public class User extends BaseEntity {

 @Id

 @GeneratedValue(strategy= GenerationType.AUTO)

 private Long id;

 private String name;

 private String email;

 @Enumerated(EnumType.STRING)

 private SexEnum sex;

 private Integer age;

 @OneToMany(mappedBy = "user")

 @JsonIgnore

 private List<UserAddress> addresses;

 private Boolean deleted;

}


In this case ,User  Entities don't need to care too much , We only pay attention to the logic we need , as follows ：

• Removed  @EntityListeners(AuditingEntityListener.class);

• Removed  @CreatedBy、@CreatedDate、@LastModifiedBy、@LastModifiedDate  Public fields of four annotations .

Then let's run the above test case , Found that the effect is the same .

This way, , It's my favorite , It is also the most used way in practical work

. Its obvious advantage is that it is highly public , The code is simple , Less attention is needed .