Почему Entity не может быть финальным классом?

Почему Entity не может быть final классом

Краткий ответ

JPA/Hibernate Entity не может быть final, потому что Hibernate использует прокси (proxy) и cglib для ленивой загрузки и отслеживания изменений (dirty checking). Если класс final, Hibernate не может создать подкласс, и функционал не будет работать.

Как работает Hibernate Proxy

Без proxy (если бы класс был final)

EntityManager.find(User.class, 1);

Это возвращает непосредственно User объект
нет ленивой загрузки
нет отслеживания изменений

С proxy (нормальная работа)

EntityManager.find(User.class, 1);

Это возвращает UserProxy (подкласс User)
UserProxy может отложить загрузку связанных сущностей
UserProxy отслеживает все изменения

Пример: Lazy Loading

// Entity
@Entity
@Table(name = "users")
public class User {  // НЕ final!
    @Id
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "company_id")
    private Company company;  // загружается лениво
    
    public String getName() { return name; }
    public Company getCompany() { return company; }
}

// Использование
User user = entityManager.find(User.class, 1);
System.out.println(user.getName());  // OK, User загружена

// При обращении к lazy-loaded полю:
Company company = user.getCompany();  // SELECT запрос к Company таблице!
// Это работает потому что user - это прокси объект

Как Hibernate создаёт proxy

Hibernate использует bytecode enhancement (cglib или javassist):

public class User { }  // исходный класс

// Hibernate создаёт во время выполнения:
public class UserHibernateProxy extends User { 
    // переопределяет все методы
    // отслеживает доступ к полям
}

User user = ... ; // На самом деле это UserHibernateProxy
user instanceof UserHibernateProxy;  // true!
user instanceof User;  // true! (потому что UserHibernateProxy extends User)

Что произойдёт если сделать Entity final

@Entity
public final class User {  // ❌ НЕПРАВИЛЬНО!
    @Id
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private Company company;
}

// Результат:
User user = entityManager.find(User.class, 1);
user.getCompany();  // LazyInitializationException!
// Потому что Hibernate не смог создать прокси

Отслеживание изменений (Dirty Checking)

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

@Entity
public class User {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
}

User user = entityManager.find(User.class, 1);
// user - это прокси объект
user.setName("New Name");  // прокси фиксирует изменение

// Когда вызовешь flush/commit:
// UPDATE users SET name = 'New Name' WHERE id = 1

Правила для Entity

Практический пример: что можно и нельзя

// ✅ Правильно
@Entity
public class User {  // публичный класс
    @Id
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private Company company;  // lazy loading будет работать
    
    public User() {}  // public конструктор
    
    public void setCompany(Company company) {
        this.company = company;  // методы не final
    }
}

// ❌ Неправильно
@Entity
public final class User {  // final класс
    @Id
    private final Long id;  // final поле
    
    @ManyToOne(fetch = FetchType.LAZY)
    private Company company;
    
    private User() {}  // private конструктор
    
    public final void setCompany(Company company) {  // final метод
        this.company = company;
    }
}

Другие проблемы с final Entity

1. LazyInitializationException

@Entity
public final class User {
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
    private List<Order> orders;
}

// Вне транзакции
User user = em.find(User.class, 1);
em.clear();  // сессия закрыта

user.getOrders();  // LazyInitializationException!
// Потому что Orders не могут быть загружены (нет прокси)

2. Проблемы с наследованием

// Если Entity final, нельзя использовать @Inheritance
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public final class Employee {  // ❌ Проблема!
    @Id
    private Long id;
}

public class Manager extends Employee {}  // Не может быть подклассом

Современные подходы

1. Hibernate 5.4+: immutable Entity

@Entity
@Immutable  // для read-only сущностей
public class AuditLog {
    @Id
    private Long id;
    
    private String action;
    private LocalDateTime timestamp;
}

AuditLog log = em.find(AuditLog.class, 1);
log.action = "new";  // будет проигнорировано

2. Используй DTO для transfer

// Может быть final
public final class UserDto {
    private Long id;
    private String name;
}

// Entity
@Entity
public class User {
    @Id
    private Long id;
    private String name;
    
    public UserDto toDto() {
        return new UserDto(id, name);
    }
}

3. Spring Data JPA с interfaces

// Projection interface (может быть как угодно)
public interface UserProjection {
    Long getId();
    String getName();
}

// Entity (не final)
@Entity
public class User implements UserProjection {
    @Id
    private Long id;
    private String name;
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    List<UserProjection> findAllProjectedBy();  // projection
}

Hibernate 6.0+: Улучшения

Hibernate 6.0 снижает требования через bytecode enhancement:

// С bytecode enhancement (build-time)
@Entity
public final class User {  // можно final!
    @Id
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private Company company;  // works!
}

// Конфигурация Gradle
plugins {
    id 'org.hibernate.orm' version '6.0.0'
}

hibernate {
    enhance {
        enableLazyInitialization = true
        enableDirtyTracking = true
    }
}

Общее правило (JPA Specification)

JPA спецификация требует:

@Entity
public class User {
    // ✅ Требования
    // 1. Публичный или protected конструктор без параметров
    // 2. Не final
    // 3. Методы не final (если нужна ленивая загрузка)
    // 4. Должен быть Serializable для некоторых операций
}

Вывод

Entity не может быть final, потому что ORM (Object-Relational Mapping) требует динамического создания подклассов (прокси) для поддержки:

1. Lazy Loading - отложенная загрузка связанных сущностей
2. Dirty Checking - отслеживание изменений
3. Transaction Management - управление транзакциями

Это основное ограничение JPA/Hibernate архитектуры. Если ты не используешь ORM (например, для read-only логирования), можешь использовать final, но тогда это не будет Entity в смысле JPA.