hibernate @OneToMany 连接表未创建

Question

I have two tables Quiz and Question which I want to associate with a @OneToMany relationship but the join table is not being created in mysql workbench database. Here are the entities:

Quiz.java

@Entity
public class Quiz {
    
        // attributes :
    private Integer idQuiz;
    private String quizTopic;

   @OneToMany
   @JoinColumn(name = "quiz_Id")
   private List<Question> questions;

        // constructors 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "quiz_Id")
    public Integer getIdQuiz() {
        return idQuiz;
    }

    @Column(name = "quiz_topic")
    public String getQuizTopic() {
        return quizTopic;
    }
//setters
}

Question.java

@Entity
public class Question {

    // attributes
    private Integer idQuestion;
    private String value;
    private String op1;
    private String op2;
    private String op3;
    private String correctAnswer;

// constructors  

// Getters :
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "question_Id")
public Integer getIdQuestion() {
    return idQuestion;
}

@Column(name = "question_value")
public String getValue() {
    return value;
}

@Column(name = "question_op1")
public String getOp1() {
    return op1;
}

@Column(name = "question_op2")
public String getOp2() {
    return op2;
}

@Column(name = "question_op3")
public String getOp3() {
    return op3;
}

@Column(name = "question_op4")
public String getCorrectAnswer() {
    return correctAnswer;
}
 //setters
}

no foreign keys are created

here is what I get after running

    Hibernate: create table question (question_id integer not null auto_increment, question_op4 varchar(255), question_op1 varchar(255), question_op2 varchar(255), question_op3 varchar(255), question_value varchar(255), primary key (question_id)) engine=InnoDB
Hibernate: create table quiz (quiz_id integer not null auto_increment, quiz_topic varchar(255), primary key (quiz_id)) engine=InnoDB

application.properties:

spring.main.web-application-type=none
spring.application.ui.title=Quiz
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/quiz?createDatabaseIfNotExist=true&useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=justpass
spring.jpa.show-sql=true

Answer 1

The annotation

@OneToMany
private ArrayList<Question> questions;

will not create a join table. It should create a foreign-key in the Question table to the Quiz table. This foreign key is not the same as the

private Integer idQuestion;

column.

Answer 2

For your solution it dependes wether you want to build a uni- or bidirectional @OneToMany relationship. If you want a unidirectional one-to-many relationship you have to define a @JoinColumn to tell Hibernate that it shall create a foreign key with the given name in the related table. Most of the time a unidirectional one to many relationship is the easiest and sufficient way to go.

Unidirectional

@OneToMany
@JoinColumn(name = "quiz_id")
private List<Question> questions;

By this Hibernate will create the foreign key with name " quiz_id " in the question table.

In the bidirectional case we are able to access the quiz from the question vice versa the questions from the quiz. In this case you will you will have to define the variable which shall represent the parent class in the child class. For example if the quiz shall be the parent class, you will define the annotation. @OneToMany(mappedBy = "quiz") . Additionally to this you will have to define the question to be the @ManyToOne side as well. All in all:

Bidirectional

Quiz.java:

@OneToMany(mappedBy = "quiz")
private List<Question> questions;

Question.java

@ManyToOne(fetch = FetchType.LAZY)
private Quiz quiz;

You will want to define the fetch type to be lazy due to performance reasons (I even ran into some overflow errors in the past, without the lazy method).

Keep in mind that if you are using the bidirectional mapping together with serialization libraries such as jackson, you will run into the JSON infinite recursion problem when de-/serializing from/to JSON.In this case you will want to use @JsonIdentityInfo to serialize the id only instead of the complete entity (which will lead to infinite recursion) or @JsonIgnore respectively @JsonManagedReference and @JsonBackReference to not serialize the child dependencies of an entity.

I also recommend to use the properties cascade defining the cascade type and orphanRemoval for the deletion of entities when you work with relationships, but I did not want to blow up my answer with unrelated information.

Answer 3

It looks suspicious that you try to mix up access strategies in the Quiz entity.

As it is stated in the documentation :

As a JPA provider, Hibernate can introspect both the entity attributes (instance fields) or the accessors (instance properties). By default, the placement of the @Id annotation gives the default access strategy. When placed on a field, Hibernate will assume field-based access. When placed on the identifier getter, Hibernate will use property-based access.

So, instead of this:

@OneToMany
@JoinColumn(name = "quiz_Id")
private List<Question> questions;

put the @OneToMany and @JoinColumn(name = "quiz_Id") annotations on the appropriate getter:

@OneToMany
@JoinColumn(name = "quiz_Id")
public List<Question> getQuestions() {
   return questions;
}

then try to recreate your schema by setting the spring.jpa.hibernate.ddl-auto property like this:

spring.jpa.hibernate.ddl-auto=create