org.hibernate.MappingException: No se pudo determinar el tipo para: java.util.List, en la tabla: College, para las columnas: [org.hibernate.mapping.Column (estudiantes)]

Estoy usando Hibernate para todas las operaciones CRUD en mi proyecto. No funciona para las relaciones uno a varios y varios a uno. Me da el siguiente error.

org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]

Luego, de nuevo, revisé este video tutorial . Para mí es muy simple, al principio. Pero no puedo hacer que funcione. También ahora dice

org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]

He realizado algunas búsquedas en Internet, alguien dice que es un error en Hibernate , y algunos dicen que al agregar @GenereatedValue, este error se borrará, pero no funciona para mí.

College.java

@Entity
public class College {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int collegeId;
private String collegeName;


private List<Student> students;

@OneToMany(targetEntity=Student.class, mappedBy="college", fetch=FetchType.EAGER)
public List<Student> getStudents() {
    return students;
}
public void setStudents(List<Student> students) {
    this.students = students;
}//Other gettters & setters omitted

Student.java

@Entity
public class Student {


@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int studentId;
private String studentName;


private College college;

@ManyToOne
@JoinColumn(name="collegeId")
public College getCollege() {
    return college;
}
public void setCollege(College college) {
    this.college = college;
}//Other gettters & setters omitted

Main.java:

public class Main {

private static org.hibernate.SessionFactory sessionFactory;

  public static SessionFactory getSessionFactory() {
    if (sessionFactory == null) {
      initSessionFactory();
    }
    return sessionFactory;
  }

  private static synchronized void initSessionFactory() {
    sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();

  }

  public static Session getSession() {
    return getSessionFactory().openSession();
  }

  public static void main (String[] args) {
                Session session = getSession();
        Transaction transaction = session.beginTransaction();
        College college = new College();
        college.setCollegeName("Dr.MCET");

        Student student1 = new Student();
        student1.setStudentName("Peter");

        Student student2 = new Student();
        student2.setStudentName("John");

        student1.setCollege(college);
        student2.setCollege(college);



        session.save(student1);
        session.save(student2);
        transaction.commit();
  }


}

Consola:

 Exception in thread "main" org.hibernate.MappingException: Could not determine type  for: java.util.List, at table: College, for columns:  [org.hibernate.mapping.Column(students)]
at org.hibernate.mapping.SimpleValue.getType(SimpleValue.java:306)
at org.hibernate.mapping.SimpleValue.isValid(SimpleValue.java:290)
at org.hibernate.mapping.Property.isValid(Property.java:217)
at org.hibernate.mapping.PersistentClass.validate(PersistentClass.java:463)
at org.hibernate.mapping.RootClass.validate(RootClass.java:235)
at org.hibernate.cfg.Configuration.validate(Configuration.java:1330)
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1833)
at test.hibernate.Main.initSessionFactory(Main.java:22)
at test.hibernate.Main.getSessionFactory(Main.java:16)
at test.hibernate.Main.getSession(Main.java:27)
at test.hibernate.Main.main(Main.java:43)

El XML:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
    <!-- Database connection settings -->
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql://localhost:3306/dummy</property>
    <property name="connection.username">root</property>
    <property name="connection.password">1234</property>
    <!-- JDBC connection pool (use the built-in) -->
    <property name="connection.pool_size">1</property>
    <!-- SQL dialect -->
    <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
    <!-- Enable Hibernate's automatic session context management -->
    <property name="current_session_context_class">thread</property>
    <!-- Disable the second-level cache -->
    <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
    <!-- Echo all executed SQL to stdout -->
    <property name="show_sql">true</property>
    <!-- Drop and re-create the database schema on startup -->
    <property name="hbm2ddl.auto">update</property>

    <mapping class="test.hibernate.Student" />
    <mapping class="test.hibernate.College" />
</session-factory>

Está utilizando una estrategia de acceso al campo (determinada por la anotación @Id). Coloque cualquier anotación relacionada con JPA justo encima de cada campo en lugar de la propiedad getter

@OneToMany(targetEntity=Student.class, mappedBy="college", fetch=FetchType.EAGER)
private List<Student> students;

Agregar el @ElementCollectioncampo a la lista resolvió este problema:

    @Column
    @ElementCollection(targetClass=Integer.class)
    private List<Integer> countries;

Problema con las estrategias de acceso

Como proveedor de JPA, Hibernate puede introspectar tanto los atributos de entidad (campos de instancia) como los accesores (propiedades de instancia). De forma predeterminada, la ubicación de la @Idanotación proporciona la estrategia de acceso predeterminada. Cuando se coloca en un campo, Hibernate asumirá el acceso basado en el campo. Colocado en el captador de identificador, Hibernate utilizará el acceso basado en propiedades.

Acceso basado en campo

Cuando se usa el acceso basado en campo, agregar otros métodos a nivel de entidad es mucho más flexible porque Hibernate no considerará esos como parte del estado de persistencia

@Entity
public class Simple {

@Id
private Integer id;

@OneToMany(targetEntity=Student.class, mappedBy="college", 
fetch=FetchType.EAGER)
private List<Student> students;

//getter +setter
}

Acceso basado en propiedad

Cuando se usa el acceso basado en propiedades, Hibernate usa los accesos para leer y escribir el estado de la entidad

@Entity
public class Simple {

private Integer id;
private List<Student> students;

@Id
public Integer getId() {
    return id;
}

public void setId( Integer id ) {
    this.id = id;
}
@OneToMany(targetEntity=Student.class, mappedBy="college", 
fetch=FetchType.EAGER)
public List<Student> getStudents() {
   return students;
}
public void setStudents(List<Student> students) {
    this.students = students;
}

}

Pero no puede usar el acceso basado en campos y en propiedades al mismo tiempo. Se mostrará como ese error para ti

Para más idea sigue esto

@Access(AccessType.PROPERTY)
@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name="userId")
public User getUser() {
    return user;
}

Tengo los mismos problemas, lo resolví agregando @Access(AccessType.PROPERTY)

¡No se preocupe! Este problema se produce debido a la anotación. En lugar del acceso basado en el campo, el acceso basado en la propiedad resuelve este problema. El código de la siguiente manera:

package onetomanymapping;

import java.util.List;

import javax.persistence.*;

@Entity
public class College {
private int collegeId;
private String collegeName;
private List<Student> students;

@OneToMany(targetEntity = Student.class, mappedBy = "college", 
    cascade = CascadeType.ALL, fetch = FetchType.EAGER)
public List<Student> getStudents() {
    return students;
}

public void setStudents(List<Student> students) {
    this.students = students;
}

@Id
@GeneratedValue
public int getCollegeId() {
    return collegeId;
}

public void setCollegeId(int collegeId) {
    this.collegeId = collegeId;
}

public String getCollegeName() {
    return collegeName;
}

public void setCollegeName(String collegeName) {
    this.collegeName = collegeName;
}

}

Simplemente inserte la anotación @ElementCollection sobre su variable de lista de matriz, como se muestra a continuación:

@ElementCollection
private List<Price> prices = new ArrayList<Price>();

espero que esto ayude

En mi caso, fue una estupidez faltar la anotación @OneToOne, configuré @MapsId sin ella

Aunque soy nuevo en hibernar pero con poca investigación (ensayo y error, podemos decir) descubrí que se debe a una inconsistencia en la anotación de métodos / archivos.

cuando esté anotando @ID en la variable, asegúrese de que todas las demás anotaciones también se realicen solo en la variable y cuando lo esté anotando en el método getter, asegúrese de anotar todos los demás métodos getter solo y no sus respectivas variables.

En caso de que alguien más aterrice aquí con el mismo problema que encontré. Recibía el mismo error que el anterior:

Error al invocar el método init; La excepción anidada es org.hibernate.MappingException: No se pudo determinar el tipo para: java.util.Collection, en la tabla:

Hibernate usa la reflexión para determinar qué columnas están en una entidad. Tenía un método privado que comenzaba con 'get' y devolvía un objeto que también era una entidad de hibernación. Incluso los captadores privados que desea que hibernate ignore deben anotarse con @Transient. Una vez que agregué la anotación @Transient, todo funcionó.

@Transient 
private List<AHibernateEntity> getHibernateEntities() {
   ....
}