Spring Boot中配置AuditListener实现操作留痕审核

Spring Boot Data 提供支持透明地跟踪谁创建了实体或更改了实体以及这些事情发生的时间。所有记录均清晰保存。例如,如果一位用户进入该站点并登录该站点。然后这些时间会保存在数据库中,当用户再次登录网站时,这些记录也会保存在数据库中,我们可以说审计。

在本文中,我们将在 Spring Boot 应用程序中实现 AuditListener 的配置。

以下是在简单的 Spring Boot 应用程序中配置AuditListener的步骤。

步骤1:首先,我们将创建一个用户类。

import jakarta.persistence.*; 
import lombok.AllArgsConstructor; 
import lombok.Getter; 
import lombok.NoArgsConstructor; 
import lombok.Setter; 

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "user"
public class User { 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private Long id; 

    private String name; 
    private String email; 



用户类,用于维护用户详细信息并将这些数据保存到数据库中。

第 2 步:现在实施服务类。

import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import org.technous.batchprac2.dto.UserDTO; 
import org.technous.batchprac2.exception.ResourceNotFoundException; 
import org.technous.batchprac2.model.User; 
import org.technous.batchprac2.repository.UserRepository; 
import org.technous.batchprac2.service.UserService; 

import java.util.List; 

@Service
public class UserServiceIMPL implements UserService { 

    @Autowired
    private UserRepository userRepository; 
    public User userToDto(UserDTO userDTO){ 
        User user = new User(); 
        user.setFirstName(userDTO.getFirstName()); 
        user.setLastName(userDTO.getLastName()); 
        user.setEmailId(userDTO.getEmailId()); 
        return user; 
    } 
    public UserDTO dtoToUser(User user){ 
        UserDTO userDTO=new UserDTO(); 
        userDTO.setFirstName(user.getFirstName()); 
        userDTO.setLastName(user.getLastName()); 
        userDTO.setEmailId(user.getEmailId()); 
        return userDTO; 
    } 

    @Override
    public List<UserDTO> getAllUsers() { 
        List<User> user = userRepository.findAll(); 
        return null
    } 

    @Override
    public UserDTO getUserById(Long userId) throws ResourceNotFoundException { 
        User user = userRepository.findById(userId) 
                .orElseThrow((()->new ResourceNotFoundException("Employee not Found"))); 
        return dtoToUser(user); 
    } 

    @Override
    public UserDTO createUser(UserDTO userDTO) { 
        User ruser = userToDto(userDTO); 
        User rruser = userRepository.save(ruser); 
        return dtoToUser(rruser); 
    } 

    @Override
    public UserDTO updateUser(Long userId, UserDTO user) throws ResourceNotFoundException { 
        User useru = userRepository.findById(userId) 
                .orElseThrow(() -> new ResourceNotFoundException(
"User not found :: " + userId)); 

        useru.setEmailId(user.getEmailId()); 
        useru.setLastName(user.getLastName()); 
        useru.setFirstName(user.getFirstName()); 
        User updatedUser = userRepository.save(useru); 

        return dtoToUser(updatedUser); 
    } 

上面的代码是服务层的,我们在其中编写所有业务逻辑以将用户数据保存到数据库中。

第 3 步:现在我们将创建 Rest 

import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.http.ResponseEntity; 
import org.springframework.web.bind.annotation.*; 
import org.technous.batchprac2.dto.UserDTO; 
import org.technous.batchprac2.exception.ResourceNotFoundException; 
import org.technous.batchprac2.model.User; 
import org.technous.batchprac2.service.UserService; 
import java.util.List; 

@RestController
@RequestMapping("/api"
public class UserController { 

    @Autowired
    private UserService userService; 


    @GetMapping(
"/users"
    public List<UserDTO> getAllUsers() { 
        return userService.getAllUsers(); 
    } 

    @GetMapping(
"/users/{id}"
    public ResponseEntity<UserDTO> getUserById( 
            @PathVariable(value =
"id") Long userId) throws ResourceNotFoundException { 
        UserDTO user = userService.getUserById(userId); 
        return ResponseEntity.ok().body(user); 
    } 

    @PostMapping(
"/users"
    public UserDTO createUser(@RequestBody UserDTO userDTO) { 
        return userService.createUser(userDTO); 
    } 

    @PutMapping(
"/users/{id}"
    public ResponseEntity<UserDTO> updateUser( 
            @PathVariable(value =
"id") Long userId, 
            @RequestBody UserDTO userDetails) throws ResourceNotFoundException { 
        UserDTO user = userService.updateUser(userId,userDetails); 
        return ResponseEntity.ok(user); 
    } 


现在我们需要通过审核来保存用户,这意味着我们在用户更新时保存信息时跟踪信息,因此它们会自动更新系统的时间和数据。

第 4 步:现在,创建持续监视应用程序的 Auditable 类。


import jakarta.persistence.EntityListeners; 
import jakarta.persistence.MappedSuperclass; 
import jakarta.persistence.Temporal; 
import lombok.Getter; 
import lombok.Setter; 
import org.springframework.data.annotation.CreatedBy; 
import org.springframework.data.annotation.CreatedDate; 
import org.springframework.data.annotation.LastModifiedBy; 
import org.springframework.data.annotation.LastModifiedDate; 
import org.springframework.data.jpa.domain.support.AuditingEntityListener; 

import java.util.Date; 

import static jakarta.persistence.TemporalType.TIMESTAMP; 

@Setter
@Getter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class
public abstract class AudiTable<U> { 

    @CreatedBy
    protected U createdBy; 

    @CreatedDate
    @Temporal(TIMESTAMP) 
    protected Date createdDate; 

    @LastModifiedBy
    protected U lastModifiedBy; 

    @LastModifiedDate
    @Temporal(TIMESTAMP) 
    protected Date lastModifiedDate; 


当用户进入系统时,Entitylistner会持续监控他们。

第5步:现在,实现AuditAware接口(内置接口)。


import java.util.Optional; 

import org.springframework.data.domain.AuditorAware; 

public class AuditorAwareImpl implements AuditorAware<String> { 
    @Override
    public Optional<String> getCurrentAuditor() { 
        return Optional.of("Geeksforgeek"); 
    } 

AuditorAware界面是内置界面,他们监视想要修改系统数据并保存您提供的任何名称的人

第6步:现在,设置Spring Boot主应用程序。

import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.EnableAutoConfiguration; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 
import org.springframework.context.annotation.Bean; 
import org.springframework.data.domain.AuditorAware; 
import org.springframework.data.jpa.repository.config.EnableJpaAuditing; 
import org.technous.batchprac2.audit.AuditorAwareImpl; 

@EnableJpaAuditing(auditorAwareRef = "auditorAware"
@SpringBootApplication
public class AditingExampleApplication { 

    @Bean
    public AuditorAware<String> auditorAware() { 
        return new AuditorAwareImpl(); 
    } 
    public static void main(String[] args) { 
        SpringApplication.run(Batchprac2Application.class, args); 
    } 


在主应用程序中,我们需要制作一个像上面这样的bean。通过这个东西,所有审核中的申请都会被保存,更新也会被保存。

现在,如果我们运行这个应用程序,调用Rest API,这个应用会自动根据我们的系统时间填写createdBy、createdOn、updatedBy、updatedOn这个字段:在MySQL数据库中我们可以看到包含createdBy、createdOn、updatedBy和updatedOn。

如果任何用户尝试更新其数据,lastUpdatedTime 将发生变化。这样我们就可以在这里审核任何内容。