org.hibernate.MappingException: Tür belirlenemedi: java.util.List, tabloda: Kolej, sütunlar için: [org.hibernate.mapping.Column (öğrenciler)]

Projemdeki tüm CRUD işlemleri için Hazırda Bekletme kullanıyorum. Bire Çok ve Çoka Bir ilişkiler için işe yaramaz. Bana aşağıdaki hatayı veriyor.

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

Sonra tekrar bu video eğitiminden geçtim . Başlangıçta benim için çok basit. Ama çalışmasını sağlayamıyorum. Şimdi de diyor

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

İnternette bazı aramalar yaptım, biri Hibernate'de bir hata olduğunu söylüyor ve bazıları @GenereatedValue ekleyerek bu hatanın temizleneceğini söylüyor , ancak benim için çalışmıyor.

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


}

Konsol:

 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)

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>

Alan erişim stratejisini kullanıyorsunuz (@Id ek açıklaması ile belirlenir). Alıcı özelliği yerine, JPA ile ilgili herhangi bir ek açıklamayı her alanın hemen üstüne yerleştirin

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

@ElementCollectionList alanına eklenmesi bu sorunu çözdü:

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

Erişim stratejileriyle ilgili sorun

Bir JPA sağlayıcısı olarak Hibernate, hem varlık özniteliklerini (örnek alanları) hem de erişimcileri (örnek özellikleri) iç gözlem yapabilir. Varsayılan olarak, @Idek açıklamanın yerleştirilmesi varsayılan erişim stratejisini verir. Bir alana yerleştirildiğinde, Hazırda Bekletme, alan tabanlı erişimi üstlenir. Tanımlayıcı alıcıya yerleştirilen Hibernate, mülke dayalı erişimi kullanacaktır.

Alan tabanlı erişim

Alan tabanlı erişimi kullanırken, diğer varlık düzeyinde yöntemler eklemek çok daha esnektir çünkü Hazırda Bekletme, kalıcılık durumunun bu bölümlerini dikkate almaz

@Entity
public class Simple {

@Id
private Integer id;

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

//getter +setter
}

Mülkiyet tabanlı erişim

Mülk tabanlı erişim kullanılırken, Hibernate erişimcileri varlık durumunu hem okumak hem de yazmak için kullanır

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

}

Ancak aynı anda hem Alan tabanlı hem de Mülk tabanlı erişimi kullanamazsınız. Senin için o hatayı gösterecek

Daha fazla fikir için bunu takip edin

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

Ben de aynı sorunları yaşıyorum, ekleyerek çözdüm @Access(AccessType.PROPERTY)

Merak etmeyin! Bu sorun, ek açıklama nedeniyle oluşur. Alan tabanlı erişim yerine, Mülk tabanlı erişim bu sorunu çözmektedir. Kod aşağıdaki gibidir:

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

}

Aşağıdaki gibi, dizi listesi değişkeninizin üzerine @ElementCollection ek açıklamasını eklemeniz yeterlidir:

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

Umarım bu yardımcı olur

Hazırda bekletmek için yeni olmama rağmen, ancak çok az araştırmayla (deneme yanılma diyebiliriz), bunun yöntemlere / dosyalara açıklama eklemedeki tutarsızlıktan kaynaklandığını öğrendim.

Değişken üzerine @ID eklediğinizde, diğer tüm açıklamaların da yalnızca değişken üzerinde yapıldığından ve alıcı yöntemine açıklama eklediğinizde aynı şekilde diğer tüm alıcı yöntemlerine açıklama eklediğinizden ve ilgili değişkenlerine değil, not aldığınızdan emin olun.

Karşılaştığım sorunla başka birinin buraya gelmesi durumunda. Yukarıdakiyle aynı hatayı alıyordum:

İnit yönteminin çağrılması başarısız oldu; iç içe geçmiş istisna, org.hibernate.MappingException: java.util.Collection için tür belirlenemedi, tabloda:

Hazırda bekletme, bir varlıkta hangi sütunların olduğunu belirlemek için yansımayı kullanır. 'Get' ile başlayan ve aynı zamanda hazırda bekletilen bir varlık olan bir nesne döndüren özel bir yöntemim vardı. Hazırda bekletmeyi göz ardı etmek istediğiniz özel alıcılar bile @Transient ile açıklanmalıdır. @Transient ek açıklamasını ekledikten sonra her şey çalıştı.

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

Benim durumumda @OneToOne ek açıklamasının eksik olması aptalca, @MapsId'i onsuz ayarladım