Problème de mappage JPA @OneToMany

Question

J'essaie de faire des mappages JPA/Hibernate pour mapper deux tables, mais j'obtiens cette erreur. toute aide serait grandement appréciée !!

Restaurants.java

@Entity 
@Table(name="RESTAURANTS") 
public class Restaurants{ 

    @Id 
    @GeneratedValue(strategy=GenerationType.AUTO) 
    private Long id; 

    @OneToMany(mappedBy="restaurant") 
    private LinkedList<Menus> menus = new LinkedList<Menus>(); 


    /* constructors **/ 
    public Restaurants(){ 
     this.dateJoined = new Date(); 
    }; 

    /* getters and setters **/ 

    @Id 
    @GeneratedValue(generator="increment") 
    @GenericGenerator(name="increment", strategy = "increment") 
    public Long getId() {return id;} 
    public void setId(Long id) {this.id = id;} 

    public LinkedList<Menus> getMenus() {return menus;} 
    public void setMenus(LinkedList<Menus> menus) {this.menus = menus;} 

}

Menus.java

@Entity 
@Table(name = "MENUS") 

public class Menus { 
    @Id 
    @GeneratedValue(strategy=GenerationType.AUTO) 
    private Long id; 
    private Long restaurantID; 

    @OneToMany 
    @JoinColumn(name="restaurant") 
    private Restaurants restaurant; 

    /* constructors */ 

    public Menus(){} 

    /* getters and setters */ 

    @Id 
    @GeneratedValue(generator="increment") 
    @GenericGenerator(name="increment", strategy = "increment") 
    @Column(nullable = false) 
    public Long getId() {return id;}  
    public void setId(Long id) {this.id = id;} 

    public Long getRestaurantID() {return restaurantID;}  
    public void setRestaurantID(Long restaurantID) {this.restaurantID = restaurantID;} 

    public void setRestaurant(Restaurants restaurant) {this.restaurant = restaurant;} 
    public Restaurants getRestaurant() {return restaurant;} 
} 

Avec cette erreur

Exception dans le fil "principal" org.hibernate.MappingException: Impossible de déterminer pour: bb.entities.Restaurants, à table: MENUS, pour colonnes: [org.hibernate.mapping.Column (restaurant)] à org.hibernate.mapping.SimpleValue.getType (SimpleValue.java:306) au org.hibernate.mapping.SimpleValue.isValid (SimpleValue.java:290) au org.hibernate.mapping.Property.isValid (Property.java : 217) à org.hibernate.mapping.PersistentClass.validate (PersistentClass.java:464) à org.hibernate.mapping.RootClass.validate (RootClass.java:235) à org.hibernate.cfg.Configuration.validate (Configuration.java:1362) à org.hibernate.cfg.Configuration.bui ldSessionFactory (Configuration.java:1865) à bb.TestMain.setUp (TestMain.java:26) à bb.TestMain.main (TestMain.java:59)

Merci.

Answer 1

Cela semble être une idée fausse dans l'utilisation de l'annotation @OneToMany. L'annotation @OneToMany est utilisée pour représenter le côté 1 dans une relation 1: M et la relation @ManyToOne inverse est utilisée pour représenter le côté M. Par conséquent, une annotation @OneToMany doit être définie sur un type de collection dans une entité et non sur un type de référence normal.

Vous devez donc:

• utiliser une association @OneToOne si c'est la nature des relations entre les entités.
• ou, décider quelle entité représente le côté 1 dans la relation 1: M. En passant par l'utilisation de la classe LinkedList dans Restaurants, je considère que la classe Restaurants d'être le 1 côté, et utiliser l'annotation @OneToMany dans la classe Restaurants, tout en utilisant la relation @ManyToOne inverse dans la classe Menus. Le code raffiné serait:

Restaurants.java

... 
@OneToMany(mappedBy="restaurant") 
private List<Menus> menus = new LinkedList<Menus>(); 

Menus.java

@ManyToOne 
@JoinColumn(name="restaurant") 
private Restaurants restaurant; 

Notez le changement dans la déclaration de la variable membre menus de LinkedList<Menus> à List<Menus>. Apparemment, dans ce cas, il est plus sage de déclarer n'importe quelle collection avec le type d'interface de la collection, au lieu de la classe de collection concrète. La raison en est que le fournisseur JPA sous-jacent utilisera ses propres types de collection concrets au moment de l'exécution, dans le but de transmettre par proxy les valeurs de collection. Hibernate, par exemple, utilisera un PeristentList lors de l'exécution, pour représenter la liste dans une entité gérée, et non un LinkedList tel que créé par l'entité. Si vous utilisez le type concret, Hibernate peut échouer dans le mappage de la colonne ou échouer lors de la récupération des enregistrements associés à partir de la base de données; Je ne suis pas sûr des détails du comportement d'exécution, sauf que je connais l'échec éventuel.