Hibernate Las anotaciones no funcionan para getters pero funcionan para los atributos

Question

Tengo problemas con las anotaciones de hibernación.Para el código que se muestra a continuación tengo una clase de hotel, clase de cliente y uso customerhotelbooking para realizar un seguimiento de qué cliente ha reservado qué hotel y vice -versa pero cuando coloco anotaciones en getters de hotel y cliente, da una excepción y, sorprendentemente, funciona cuando lo coloco en los atributos. ¿alguien puede decir por qué es así?

`Caused by: org.hibernate.MappingException: Could not determine type for: com.xebia.hotelBooking.domain.Customer, at table: CustomerHotelBooking, for columns: [org.hibernate.mapping.Column(customer)] 
at org.hibernate.mapping.SimpleValue.getType(SimpleValue.java:290) 
at org.hibernate.mapping.SimpleValue.isValid(SimpleValue.java:274) 
at org.hibernate.mapping.Property.isValid(Property.java:217) 
at org.hibernate.mapping.PersistentClass.validate(PersistentClass.java:464) 
at org.hibernate.mapping.RootClass.validate(RootClass.java:236) 
at org.hibernate.cfg.Configuration.validate(Configuration.java:1193) 
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1378) 
at org.hibernate.cfg.AnnotationConfiguration.buildSessionFactory(AnnotationConfiguration.java:954) 
at org.jboss.seam.persistence.HibernateSessionFactory.createSessionFactory(HibernateSessionFactory.java:165) 
at org.jboss.seam.persistence.HibernateSessionFactory.startup(HibernateSessionFactory.java:79) 
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) 
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) 
at java.lang.reflect.Method.invoke(Method.java:597) 
at org.jboss.seam.util.Reflections.invoke(Reflections.java:22) 
at org.jboss.seam.util.Reflections.invokeAndWrap(Reflections.java:144) 
at org.jboss.seam.Component.callComponentMethod(Component.java:2249) 
at org.jboss.seam.Component.callCreateMethod(Component.java:2172) 
at org.jboss.seam.Component.newInstance(Component.java:2132)` 

que tienen grano de hotel, como se muestra `

@Id 
@GeneratedValue 
private int id; 

private String description; 

private String city; 

private String name; 

private String rating ; 

private int isBooked; 
` 

frijol de Cusomer como`

 @Id 
@GeneratedValue 
private int id; 

private String userName; 

private String password; 

`

y CustomerHotelBooking clase como

 @Id 
@GeneratedValue 
private int id; 

private Hotel hotel; 

private Customer customer; 


     @ManyToOne 
@Cascade(value = { CascadeType.ALL }) 
public Customer getCustomer() { 
    return customer; 
} 

/** 
    * @param customer the customer to set 
    */ 
public void setCustomer(Customer customer) { 
    this.customer = customer; 
} 

/** 
    * @return the user 
    */ 



/** 
    * @return the hotel 
    */ 
     @ManyToOne 
@Cascade(value = { CascadeType.ALL }) 
public Hotel getHotel() { 
    return hotel; 
} 

/** 
    * @param hotel 
    *   the hotel to set 
    */ 
public void setHotel(Hotel hotel) { 
    this.hotel = hotel; 
} 

Answer 1

The docs dicen:

2.2.2.2. Tipo de acceso

De forma predeterminada, el tipo de acceso de una jerarquía de clases se define por la posición de las anotaciones @Id o @EmbeddedId. Si estas anotaciones están en un campo, solo se consideran persistentes los campos y se accede al estado a través del campo. Si hay anotaciones en un getter, solo se considera que los getters persisten y se accede al estado a través del getter/setter. Eso funciona bien en la práctica y es el enfoque recomendado.

Por lo tanto, se espera y se documenta el comportamiento, por lo tanto, coloque las anotaciones de forma coherente, ya sea campos o captadores.

(Si lee la documentación que figura a continuación, dice que hay una forma de mezclar los tipos de acceso, utilizando la anotación @Access, pero no lo recomendaría, sea coherente. Personalmente, prefiero poner las anotaciones en los campos)