Как проверить наличие изменения в сущности

Как проверить наличие изменения в сущности

Проверка изменений в сущностях — важная задача при работе с базами данных и ORM. В Java существует несколько подходов для отслеживания и проверки изменений объектов.

1. Использование JPA и Hibernate dirty checking

Hibernate автоматически отслеживает изменения:

@Entity
@Table(name = "users")
public class User {
    @Id
    private Long id;
    
    @Column
    private String name;
    
    @Column
    private String email;
    
    // getters, setters
}

public void updateUserWithTracking() {
    // Получаем сущность
    User user = userRepository.findById(1L).orElse(null);
    
    // Изменяем свойство
    user.setEmail("newemail@example.com");
    
    // Hibernate автоматически отслеживает изменения
    // При commit() будет выполнен UPDATE запрос
    userRepository.save(user);  // или просто оставить внутри транзакции
    
    // В logback будет видно:
    // UPDATE users SET email = 'newemail@example.com' WHERE id = 1
}

2. Проверка изменённых полей через Hibernate API

Получение информации об изменениях:

@Service
public class UserService {
    @Autowired
    private SessionFactory sessionFactory;
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public void checkChanges() {
        User user = userRepository.findById(1L).orElse(null);
        
        // Получаем Session
        Session session = sessionFactory.getCurrentSession();
        
        // Проверяем, является ли объект Persistent
        if (session.contains(user)) {
            // Получаем информацию об изменениях
            SessionImplementor impl = (SessionImplementor) session;
            PersistenceContext pc = impl.getPersistenceContext();
            
            // Получаем entry для объекта
            EntityEntry entry = pc.getEntry(user);
            
            if (entry != null) {
                // Оригинальные значения
                Object[] originalValues = entry.getLoadedState();
                
                // Текущие значения
                Object[] currentValues = entry.getStatus() == Status.LOADING ? 
                    null : entry.getVersion();
                
                // Сравниваем
                System.out.println("Объект был изменён");
            }
        }
    }
}

3. Вручную отслеживать изменения через копию

Паттерн: сравнение оригинала с копией:

public class UserChangeDetector {
    
    // Копируем оригинальное состояние
    private User originalUser;
    private User currentUser;
    
    public UserChangeDetector(User user) {
        // Глубокая копия
        this.originalUser = deepCopy(user);
        this.currentUser = user;
    }
    
    // Проверяем, был ли объект изменён
    public boolean hasChanged() {
        return !Objects.equals(originalUser, currentUser);
    }
    
    // Получаем список изменённых полей
    public Set<String> getChangedFields() {
        Set<String> changedFields = new HashSet<>();
        
        if (!Objects.equals(originalUser.getName(), currentUser.getName())) {
            changedFields.add("name");
        }
        if (!Objects.equals(originalUser.getEmail(), currentUser.getEmail())) {
            changedFields.add("email");
        }
        if (!Objects.equals(originalUser.getPhone(), currentUser.getPhone())) {
            changedFields.add("phone");
        }
        
        return changedFields;
    }
    
    // Получаем изменение для конкретного поля
    public FieldChange getFieldChange(String fieldName) {
        Object oldValue = getFieldValue(originalUser, fieldName);
        Object newValue = getFieldValue(currentUser, fieldName);
        
        if (Objects.equals(oldValue, newValue)) {
            return null;  // Не изменилось
        }
        
        return new FieldChange(fieldName, oldValue, newValue);
    }
    
    private Object getFieldValue(User user, String fieldName) {
        try {
            Field field = User.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(user);
        } catch (Exception e) {
            return null;
        }
    }
    
    private User deepCopy(User user) {
        // Используем ObjectMapper или другой способ
        ObjectMapper mapper = new ObjectMapper();
        try {
            String json = mapper.writeValueAsString(user);
            return mapper.readValue(json, User.class);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

public class FieldChange {
    private String fieldName;
    private Object oldValue;
    private Object newValue;
    
    public FieldChange(String fieldName, Object oldValue, Object newValue) {
        this.fieldName = fieldName;
        this.oldValue = oldValue;
        this.newValue = newValue;
    }
    
    // getters
}

4. Использование @DynamicUpdate в Hibernate

Обновление только изменённых полей:

@Entity
@Table(name = "users")
@DynamicUpdate  // Только изменённые поля в UPDATE
@DynamicInsert  // Только непустые поля в INSERT
public class User {
    @Id
    private Long id;
    
    @Column
    private String name;
    
    @Column
    private String email;
    
    @Column(columnDefinition = "TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
    private LocalDateTime updatedAt;
    
    @PreUpdate
    public void preUpdate() {
        this.updatedAt = LocalDateTime.now();
    }
}

// Теперь UPDATE содержит только изменённые поля:
// UPDATE users SET email = ?, updated_at = ? WHERE id = ?

5. Событийная система (Observer Pattern)

Использование JPA Listeners:

public class UserEntityListener {
    private static final Logger logger = LoggerFactory.getLogger(UserEntityListener.class);
    
    @PreUpdate
    public void preUpdate(User user) {
        logger.info("Сущность User будет обновлена: {}", user.getId());
    }
    
    @PostUpdate
    public void postUpdate(User user) {
        logger.info("Сущность User была обновлена: {}", user.getId());
    }
    
    @PrePersist
    public void prePersist(User user) {
        logger.info("Сущность User будет создана");
    }
    
    @PostLoad
    public void postLoad(User user) {
        logger.info("Сущность User загружена: {}", user.getId());
    }
}

@Entity
@Table(name = "users")
@EntityListeners(UserEntityListener.class)  // Подписываемся на события
public class User {
    @Id
    private Long id;
    
    @Column
    private String name;
    
    // ...
}

6. Использование @Version для оптимистичной блокировки

Отслеживание версии сущности:

@Entity
@Table(name = "users")
public class User {
    @Id
    private Long id;
    
    @Column
    private String name;
    
    @Column
    private String email;
    
    @Version  // Автоматически инкрементируется при update
    private Long version;
    
    // Getters, Setters
}

// Использование
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public void updateUser(Long id, String newName) {
        User user = userRepository.findById(id).orElse(null);
        
        // Version = 1
        user.setName(newName);
        userRepository.save(user);
        // Version = 2 (автоматически увеличена)
        
        // UPDATE users SET name = ?, version = 2 WHERE id = ? AND version = 1
        
        // Если версия не совпадает, будет OptimisticLockingFailureException
    }
}

7. Аудит изменений с использованием Hibernate Envers

Отслеживание истории изменений:

// Зависимость
// <dependency>
//     <groupId>org.hibernate</groupId>
//     <artifactId>hibernate-envers</artifactId>
// </dependency>

@Entity
@Table(name = "users")
@Audited  // Включаем аудит
public class User {
    @Id
    private Long id;
    
    @Column
    private String name;
    
    @Column
    private String email;
}

// Использование
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private AuditReader auditReader;
    
    public void auditUserChanges(Long userId) {
        // Получаем все версии сущности
        List<Number> revisions = auditReader.getRevisions(User.class, userId);
        
        for (Number revision : revisions) {
            User user = auditReader.find(User.class, userId, revision);
            System.out.println("Версия " + revision + ": " + user.getName());
        }
    }
}

8. Сравнение объектов через equals и hashCode

Правильная реализация:

@Entity
@Table(name = "users")
public class User {
    @Id
    private Long id;
    
    @Column
    private String name;
    
    @Column
    private String email;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        
        User user = (User) o;
        
        return Objects.equals(id, user.id) &&
               Objects.equals(name, user.name) &&
               Objects.equals(email, user.email);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id, name, email);
    }
}

// Использование
User user1 = new User(1L, "John", "john@example.com");
User user2 = new User(1L, "John", "john@example.com");

if (user1.equals(user2)) {
    System.out.println("Объекты идентичны");
}

9. JSON для сравнения сущностей

Конвертирование в JSON и сравнение:

@Service
public class UserChangeService {
    private final ObjectMapper objectMapper = new ObjectMapper();
    
    public Map<String, Object> detectChanges(User oldUser, User newUser) 
            throws JsonProcessingException {
        
        // Конвертируем в JSON
        JsonNode oldJson = objectMapper.valueToTree(oldUser);
        JsonNode newJson = objectMapper.valueToTree(newUser);
        
        // Используем JsonPatch для сравнения
        JsonPatch patch = JsonPatch.fromJson(
            objectMapper.valueToTree(
                JsonDiff.asJson(oldJson, newJson)
            )
        );
        
        // Вычисляем различия
        Map<String, Object> changes = new HashMap<>();
        
        Iterator<String> fieldNames = oldJson.fieldNames();
        while (fieldNames.hasNext()) {
            String fieldName = fieldNames.next();
            JsonNode oldValue = oldJson.get(fieldName);
            JsonNode newValue = newJson.get(fieldName);
            
            if (!oldValue.equals(newValue)) {
                changes.put(fieldName, new Object[]{
                    oldValue.asText(),
                    newValue.asText()
                });
            }
        }
        
        return changes;
    }
}

10. Практический пример: полное отслеживание изменений

@Service
@Transactional
public class UserUpdateService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private AuditLogRepository auditLogRepository;
    
    public void updateUserWithAudit(Long userId, UserUpdateDTO updateDTO) {
        User user = userRepository.findById(userId).orElseThrow();
        
        // Сохраняем оригинальное состояние
        User original = deepCopy(user);
        
        // Применяем изменения
        user.setName(updateDTO.getName());
        user.setEmail(updateDTO.getEmail());
        user.setPhone(updateDTO.getPhone());
        
        // Сохраняем изменённую сущность
        userRepository.save(user);
        
        // Логируем изменения
        List<AuditLog> changes = detectAndLogChanges(original, user);
        auditLogRepository.saveAll(changes);
    }
    
    private List<AuditLog> detectAndLogChanges(User original, User updated) {
        List<AuditLog> logs = new ArrayList<>();
        
        if (!Objects.equals(original.getName(), updated.getName())) {
            logs.add(new AuditLog(
                "User name changed from '" + original.getName() + 
                "' to '" + updated.getName() + "'"
            ));
        }
        
        if (!Objects.equals(original.getEmail(), updated.getEmail())) {
            logs.add(new AuditLog(
                "User email changed from '" + original.getEmail() + 
                "' to '" + updated.getEmail() + "'"
            ));
        }
        
        return logs;
    }
    
    private User deepCopy(User user) {
        // Реализация глубокого копирования
        return new User(user.getId(), user.getName(), user.getEmail());
    }
}

Заключение

Проверка изменений в сущностях можно осуществить несколькими способами:

1. Hibernate Dirty Checking — автоматически отслеживает изменения в транзакции
2. Сравнение через копию — ручное сравнение оригинала с текущим состоянием
3. @Version — оптимистичная блокировка с версионированием
4. @EntityListener — реагирование на события жизненного цикла
5. Hibernate Envers — полная история изменений сущности
6. JSON сравнение — конвертирование и diff анализ
7. equals/hashCode — правильная реализация сравнения объектов

Выбирайте подход в зависимости от требований: для простого отслеживания используйте dirty checking, для истории — Envers, для многопользовательского доступа — @Version.