Mise en veille prolongée 5 bytecode Amélioration Association de gestion fonctionne dans une direction

Question

J'ai 2 entités JPA cartographié comme ceci:

@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; 
    } 

} 

Toutes les classes sont bytecode amélioré à l'aide d'améliorer hibernate plugin Maven:

<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> 

J'effectue deux tests afin de vérifier que les classes améliorées fonctionnent correctement:

@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)); 
} 

Seul le second test passe avec succès, par conséquent tandis que l'association est manipulée par la collection des parents, le champ de parent de l'enfant ne sont pas mis à jour, alors que dans Hibernate ORM 5.2.3.Final User Guide est dit

gestion de l'association bidirectionnelle bytecode améliorée fait que le premier travail d'exemple en gérant "l'autre côté" d'une association bidirectionnelle chaque fois qu'un côté est manipulé.

Où référencé "premier exemple" est

Exemple d'utilisation 204. Java normale incorrecte

Pourquoi dans mon cas test1 la gestion de l'association ne fonctionne pas? Qu'ai-je fait de mal?

Answer 1

Dans les tests unitaires, il peut arriver que les classes n'aient pas été améliorées, en particulier lorsque vous les exécutez via un IDE.

Assurez-vous que les classes améliorées sont contenues dans un module différent que vous importez dans le projet dans lequel vous effectuez le test.

Vous pouvez également exécuter le processus d'amélioration, vérifier que les classes sont améliorées et exécuter uniquement le test unitaire. Dans l'ensemble, je suppose que vous pourriez exécuter la version non améliorée de vos classes d'entités.

Quoi qu'il en soit, je ne pense pas que cette fonctionnalité soit vraiment nécessaire. Syncing both ends of the associations is the way to go, et il vous suffit de fournir des méthodes addChild et removeChild.