Hibernate 5字节码增强关联管理仅在一个方向上工作

Question

I have 2 JPA Entities mapped like this :

@MappedSuperclass
public class AbstractEntity {

    private static final String INCREMENT_STRATEGY = "increment";

    private static final String INCREMENT_ID_GENERATOR_NAME = "INCREMENT_ID_GENERATOR";

    @Id
    @GenericGenerator(name = INCREMENT_ID_GENERATOR_NAME, strategy = INCREMENT_STRATEGY)
    @GeneratedValue(generator = INCREMENT_ID_GENERATOR_NAME)
    private Long id;

    public AbstractEntity() {
        super();
    }

    public Long getId() {
        return id;
    }
}

@Entity
public class Department extends AbstractEntity{


    @OneToMany(cascade = CascadeType.ALL, mappedBy = "department")
    private List<Employee> employees = new ArrayList<Employee>();

    public void setEmployees(List<Employee> employees) {
        this.employees = employees;
    }

    public List<Employee> getEmployees() {
        return employees;
    }

}

@Entity
public class Employee extends AbstractEntity {

    @ManyToOne(optional = true, cascade= CascadeType.ALL)
    @JoinColumn(name = "DEPARTMENT_ID")
    private Department department;

    public void setDepartment(Department department) {
        this.department = department;
    }

    public Department getDepartment() {
        return department;
    }

}

All classes are byte-code enhanced using hibernate enhance maven plugin :

<build>
    <plugins>
        <plugin>
            <groupId>org.hibernate.orm.tooling</groupId>
            <artifactId>hibernate-enhance-maven-plugin</artifactId>
            <version>5.2.2.Final</version>
            <dependencies>
                <dependency>
                    <groupId>org.hibernate</groupId>
                    <artifactId>hibernate-entitymanager</artifactId>
                    <version>5.2.2.Final</version>
                </dependency>
            </dependencies>
            <configuration>
                <enableDirtyTracking>true</enableDirtyTracking>
                <enableLazyInitialization>true</enableLazyInitialization>
                <enableAssociationManagement>true</enableAssociationManagement>
            </configuration>
        </plugin>
    </plugins>
</build>

I run two tests in order to verify that enhanced classes works properly :

@Test
public void test1() {
    Department department = new Department();
    Employee employee = new Employee();
    department.getEmployees().add(employee);
    assertThat(employee.getDepartment(), is(not(nullValue())));
}

@Test
public void test2() {
    Department department = new Department();
    Employee employee = new Employee();
    employee.setDepartment(department);
    assertThat(department.getEmployees().size(), is(1));
    assertThat(department.getEmployees().get(0), is(employee));
}

Only the second test passes successfully, hence while the association is manipulated through parent's collection, the child's parent field is not updated, whereas in Hibernate ORM 5.2.3.Final User Guide is said

Bytecode-enhanced bi-directional association management makes that first example work by managing the "other side" of a bi-directional association whenever one side is manipulated.

Where referenced "first example" is

Example 204. Incorrect normal Java usage

Why in my test1 case the association management doesn't work ? What did I do wrong?

Answer 1

In unit tests, it might happen that the classes haven't been enhanced, especially when you run them through an IDE.

Make sure the enhanced classes are contained in a different module that you import in the project where you do the testing.

Or you can run the enhance process, verify the classes are enhanced and only then run the unit test.

All in all, I guess you might be running the un-enhanced version of your entity classes.

Anyway, I don't think that this feature is really necessary. Syncing both ends of the associations is the way to go , and it only requires you to provide an addChild and removeChild methods.

Answer 2

Tracking down Andrei's JIRA issue I learned that:

to trigger the association management, at some point there has to be a change in the *ToMany field, even if it's with the same collection. The collection itself is not tracked for changes.

So, instead of:

customer.getInventories().add( customerInventory );

It's required a call to the setter:

Collection<CustumerInventory> inventories = customer.getInventories();
inventories.add( customerInventory ); 
custumer.setInventories( inventories );