Обновление экземпляра суперкласса до экземпляра подкласса при использовании стратегии с одной таблицей в спящем режиме

Question

Я работаю над системой управления проектами, в которой работают три пользователя: сотрудник, менеджер и HRM.Сотрудник и менеджер находятся в одной и той же сущности и имеют рекурсивные отношения «многие ко многим» (назовем эту сущность «Сотрудник»).Сущность Employee и HRM наследуют сущность User.Используемая здесь стратегия наследования гибернации - одна таблица.Первоначально, когда пользователь зарегистрирован, он сохраняется как экземпляр пользователя (репозиторий типа «Пользователь»).Я хочу обновить пользовательский экземпляр до экземпляра сотрудника или экземпляра менеджера, когда он назначен для конкретного проекта.Как это можно реализовать с помощью данных весны jpa.Я делаю проект, используя весеннюю загрузку.

Я создал сущности, используя классы Java, и сопоставил каждую сущность.Я не предоставил класс Project и Tasks в следующем коде.При необходимости я могу предоставить.

Ниже приведен класс User.

@Entity
@Table(name = "users")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
        name="User_Type",
        discriminatorType=DiscriminatorType.STRING
        )
public class User{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id")
    private Long id;

    private String name;

    private String email;

    private String password;

    private String mobilenumber;

    private String gender;

    private String resetToken;

    @ManyToMany(fetch = FetchType.LAZY, cascade={CascadeType.ALL})
    @JoinTable(name = "user_roles", 
        joinColumns = @JoinColumn(name = "user_id"), 
        inverseJoinColumns = @JoinColumn(name = "role_id"))
    private Set<Role> roles = new HashSet<>();//roles refer to the employee,manager and HRM roles

//public getters and setters

Ниже приведен унаследованный класс Employee

@Entity
@DiscriminatorValue("Employee")
public class Employee extends User {
    @ManyToMany(fetch = FetchType.LAZY, cascade = { CascadeType.ALL })
    @JoinTable(name = "employee_project",
    joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "project_id")
    )
    private Set<Project> project = new HashSet<>();

    @ManyToMany
    @JoinTable(name = "employee_tasks",
    joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "task_id")
    )
    private Set<Task> tasks = new HashSet<>();

    @ManyToMany
    @JoinTable(name = "rm_employee",
    joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "rm_id")
    )
    private Set<Employee> managers = new HashSet<>();

    @ManyToMany
    @JoinTable(name = "rm_employee",
    joinColumns = @JoinColumn(name = "rm_id"),
    inverseJoinColumns = @JoinColumn(name = "user_id")
    )
    private Set<Employee> employees = new HashSet<>();

//public getters and setters

.экземпляр User к экземпляру Employee, который приводит к CastException.

Optional<User> optional = userRepo.findById(id);

Employee employee = (Employee)optional.get();

Ниже приведен эскиз модели er

Answer 1

Мне удалось решить вопрос без использования наследства. На самом деле мне пришлось избегать наследования, поскольку в отношении java тип не может быть изменен с одного на другой. Как и в этом примере, тип User не может быть преобразован в Employee или Manager, как вы хотите. Поэтому решение состоит в том, чтобы создать два отдельных класса для менеджера и сотрудника (это не должно расширять класс User, как я сделал в этом вопросе). Эти два должны быть аннотированы как сущность и должны иметь поле Id. Вы можете иметь конструктор с указанным выше полем Id в обоих классах, и когда бы вы ни назначали пользователя для проекта, вы можете использовать этот конструктор в зависимости от того, является ли он менеджером или сотрудником для создания соответствующего экземпляра менеджера или сотрудника.

класс работника выглядит следующим образом

public class Employee{

    @Id
    private Long employeeId;

    @ManyToMany(fetch = FetchType.LAZY, cascade = { CascadeType.ALL })
    @JoinTable(name = "employee_project",
    joinColumns = @JoinColumn(name = "employee_id"),
    inverseJoinColumns = @JoinColumn(name = "project_id")
    )
    private Set<Project> project = new HashSet<>();

    @ManyToMany
    @JoinTable(name = "employee_rm",
    joinColumns = @JoinColumn(name = "employee_id"),
    inverseJoinColumns = @JoinColumn(name = "rm_id")
    )
    private Set<Manager> managers = new HashSet<>();

    @ManyToMany
    @JoinTable(name = "employee_tasks",
    joinColumns = @JoinColumn(name = "employee_id"),
    inverseJoinColumns = @JoinColumn(name = "task_id")
    )
    private Set<Task> tasks = new HashSet<>();

    public Employee() {}

    public Employee(Set<Project> project, Set<Manager> managers, Set<Task> tasks, Long employeeId ) {
        super();
        this.project = project;
        this.managers = managers;
        this.tasks = tasks;
        this.employeeId=employeeId;
    }
//with public getters and setters

и класс менеджеров выглядит следующим образом

@Entity
public class Manager {

    @Id
    private Long managerId ;

    @ManyToMany
    @JoinTable(name = "manager_employee",
    joinColumns = @JoinColumn(name = "manager_id"),
    inverseJoinColumns = @JoinColumn(name = "user_id")
    )
    private Set<Employee> employees = new HashSet<>();

    @OneToOne
    @JoinColumn(name="project_id")
    private Project project;

    public Manager() {}

    public Manager(Long managerId) {
        super();
        this.managerId = managerId;
    }
//public getters and setters