JPA : Ensure that children entities are owned by entity's parent entity

Question

So let's say you have

class Employee {
 @ManyToOne
 @JoinColumn
 private Department department;
}

class Department {


}

class EmployeeGroup {

   @OneToMany
   @JoinTable
   private Set<Employee> employees;

   @ManyToOne
   @JoinColumn
   private Department department;
}

How would you ensure that all employees from a specific group, are from the same Department as the EmployeeGroup's department ?

I've tried with array of @JoinColumn within @JoinTable... but It seems that hibernate can't share in link table the same column for fk_department_id in both Foreign keys.

What I expect to get is : a link table with three columns, fk_group_id, fk_employee_id, fk_department_id, and 2 FK (department_id, employee_Id) to employee table, and (department_id, group_id) to emp_group table.

Is it possible without ComplexPK?

Business case : you have two departments, IT and Finance, 3 groups, Java Group and .NET group which belong to IT department, HR group which belong to Finance department. You have 5 employees. all of them are in IT department, two of them also in Java group, two of them in .NET group, and one of them is an internship member which does not belong to any groups yet, but it is in the same department. Now I want to ensure that when you take 1 employee from IT department and say employee.getGroups(), all of them are also IT groups and the collection does not contain accidentally the HR group.

Answer 1

How would you ensure that all employees from a specific group, are from the same Department as the EmployeeGroup's department?

If you want to make this restriction in Hibernate/JPA level which is also the DB level you need to make this restriction with a composite primary key, the primary key will hold both the DepartmentPK and the EmployeeGroupPK for every Employee.

is it possible without ComplexPK?

The short answer is No, because only a composite primary key can provide these restrictions on all sides foreach Employee.

Otherwise you will keep your mapping as it is and make these restrictions in the business level.

Answer 2

In this particular scenario why are you making relationship between employee and department classes?(I don't think it is a well normalized design too)

Why don't you just specify the below mentioned relations: 1. One To Many relation in EmployeeGroup with Employeee 2. Many To One relation in EmployeeGroup with Department 3. Many To One relation in Employee with EmployeeGroup 4. One To Many relation in Department with EmployeeGroup

In this way, you can derive the department of an employee via its employee group and make sure that employees belonging to same employee group belong to same department.

Answer 3

How would you ensure that all employees from a specific group, are from the same Department as the EmployeeGroup's department?

You can ensure that by making a relation between Employee and EmployeeGroup which has an association with Department and remove Department<-->Employee association, so to know which Department an Employee belongs to, you should navigate through EmplpoyeeGroup association.

So when the employee is not in any groups, how would you guess the department?

You can solve this by using a default group for each Department, so every Employee that is not affected to a group, must belong to his Department's default group, so your mapping will be :

public class Employee{    
    @ManyToOne(optional = false)
    @JoinColumn(name = "EmployeeGroup_id")
    private EmployeeGroup employeeGroup; 

    ...
}

public class Department{
    @OneToMany(mappedBy = "department")
    private List<EmployeeGroup> employeeGroup;        

    @OneToOne(optional = false, orphanRemoval = true, cascade = CascadeType.ALL)
    @JoinColumn(name = "DefaultEmployeeGroup_id")
    private EmployeeGroup defaultEmployeeGroup;

    ...
}

class EmployeeGroup {

    @OneToMany(mappedBy = "employeeGroup")
    private Set<Employee> employees;

    @ManyToOne(optional = false)
    @JoinColumn(name ="department"_id)
    private Department department;

    ...
}

This solution may remove a redundant association between Employee and Department and will enforce the business rule on the database side.

The Second solution:

Is checking integrity between Employee's group and his Department in your code, by checking the setDepartment(Department) and setEmployeeGroup(EmployeeGroup) in your Employee class. Here the business rule won't be checked in the database layer (if other application uses the same database).

Note:

• I don't prefer a composite primary key for sake of simplicity unless I don't have a choice.
• I don't think it's a good idea to use @JoinTable with @OneToMany for EmployeeGroup.employees field, Hibernate will create a separate table for EmployeeGroup-->Employee association.

Hope it helps.