Java hibernate在多对多关系查询中未定位连接表

在使用hibernate和jpa的spring mvc应用程序中，我在

WordKey

实体和

Concept

实体之间存在多对多关系

WordKey

有一个

concepts

集合，

Concept

有一个

WordKey

集合。我不想使用

fetchType=EAGER

，因为性能是个问题。相反，一旦用户选择了

WordKey

，我想用查询结果填充

集合

，该查询以

selectedKeyWord

wk

作为参数，并返回与基础数据库中的

WordKey

关联的

概念的集合。如何在JPQL中编写此查询

这是我到目前为止提出的问题。它不工作（请参阅下面的错误）：

堆栈跟踪中生成的特定错误为：

com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException:  
Table 'mydb.concept_wordkey' doesn't exist

以下是
概念
实体：

@Entity
@Table(name = "concept")
public class Concept implements Serializable{

    @EmbeddedId
    public EmbedPK conceptPk;

    @ManyToMany(cascade={CascadeType.ALL})
    private Set<WordKey> wordkeys;

    public EmbedPK getConceptPk(){return conceptPk;}

    protected Set<WordKey> getWordkeysInternal() {
        if (this.wordkeys == null) {this.wordkeys = new HashSet<WordKey>();}
        return this.wordkeys;
    }

    public List<WordKey> getWordkeys() {
        List<WordKey> sortedWordkeys = new ArrayList<WordKey>(getWordkeysInternal());
        PropertyComparator.sort(sortedWordkeys, new MutableSortDefinition("wordkey", true, true));
        return Collections.unmodifiableList(sortedWordkeys);
    }

    public WordKey getWordkey(String s) {return getWordkey(s, false);}

    public WordKey getWordkey(String ps, boolean ignoreNew) {
        ps = ps.toLowerCase();
        for (WordKey s1 : getWordkeysInternal()) {
            if (!ignoreNew || !s1.isNew()) {
                String keyword = s1.getName();
                keyword = keyword.toLowerCase();
                if (keyword.equals(ps)) {return s1;}
            }
        }
        return null;
    }
}

@Entity
@Table(name = "wordkey")
public class WordKey {

    @Id
    @Column(name="keyword")
    private String name;

    @ManyToMany(cascade = {CascadeType.ALL})
    @JoinTable(name="wordkey_junction",
        joinColumns={@JoinColumn(name="keyword")},
        inverseJoinColumns={@JoinColumn(name="conceptid"),@JoinColumn(name="effectiveTime")})
    private Set<Concept> concepts = new HashSet<Concept>();

    public String getName(){return name;}
    public void setName(String nm){name=nm;}

    protected Set<Concept> getConceptsInternal() {
        if (this.concepts == null) {this.concepts = new HashSet<Concept>();}
        return this.concepts;
    }

    public List<Concept> getConcepts() {
        List<Concept> sortedConcepts = new ArrayList<Concept>(getConceptsInternal());
        PropertyComparator.sort(sortedConcepts, new MutableSortDefinition("conceptid", true, true));
        return Collections.unmodifiableList(sortedConcepts);
    }

    public Concept getConcept(BigInteger s) {return getConcept(s, false);}

    public Concept getConcept(BigInteger ps, boolean ignoreNew) {
        for (Concept s1 : getConceptsInternal()) {
            if (!ignoreNew || !s1.isNew()) {
                BigInteger compName = s1.getConceptPk().getId();
                if (compName == ps) {return s1;}
            }
        }
        return null;
    }
}

我认为在
概念
类中的
@manytomy（cascade={CascadeType.ALL}）
中需要一个mappedBy。将您的注释添加到
@manytomy（cascade={CascadeType.ALL}，mappedBy=“concepts”）
，然后重试

您需要这样告诉Hibernate将您的多对多的
wordKey
集合映射到
wordKey
类上的
Concept
集合，这将反过来向集合公开您的
wordKey\u连接

如果这不起作用，或者您不想要双向关系，请告诉我。
您需要指定mid（外部参照）表

注意-这是使用规范化进行多个映射的一般方法。如果你能用表格结构更新问题，你会得到一个好答案

@Entity
@Table(name = "concept")
public class Concept implements Serializable{

    @EmbeddedId
    public EmbedPK conceptPk;

    @ManyToMany(cascade={CascadeType.ALL})
    private Set<WordKey> wordkeys;

    public EmbedPK getConceptPk(){return conceptPk;}

    protected Set<WordKey> getWordkeysInternal() {
        if (this.wordkeys == null) {this.wordkeys = new HashSet<WordKey>();}
        return this.wordkeys;
    }

    public List<WordKey> getWordkeys() {
        List<WordKey> sortedWordkeys = new ArrayList<WordKey>(getWordkeysInternal());
        PropertyComparator.sort(sortedWordkeys, new MutableSortDefinition("wordkey", true, true));
        return Collections.unmodifiableList(sortedWordkeys);
    }

    public WordKey getWordkey(String s) {return getWordkey(s, false);}

    public WordKey getWordkey(String ps, boolean ignoreNew) {
        ps = ps.toLowerCase();
        for (WordKey s1 : getWordkeysInternal()) {
            if (!ignoreNew || !s1.isNew()) {
                String keyword = s1.getName();
                keyword = keyword.toLowerCase();
                if (keyword.equals(ps)) {return s1;}
            }
        }
        return null;
    }
}

@Entity
@Table(name = "wordkey")
public class WordKey {

    @Id
    @Column(name="keyword")
    private String name;

    @ManyToMany(cascade = {CascadeType.ALL})
    @JoinTable(name="wordkey_junction",
        joinColumns={@JoinColumn(name="keyword")},
        inverseJoinColumns={@JoinColumn(name="conceptid"),@JoinColumn(name="effectiveTime")})
    private Set<Concept> concepts = new HashSet<Concept>();

    public String getName(){return name;}
    public void setName(String nm){name=nm;}

    protected Set<Concept> getConceptsInternal() {
        if (this.concepts == null) {this.concepts = new HashSet<Concept>();}
        return this.concepts;
    }

    public List<Concept> getConcepts() {
        List<Concept> sortedConcepts = new ArrayList<Concept>(getConceptsInternal());
        PropertyComparator.sort(sortedConcepts, new MutableSortDefinition("conceptid", true, true));
        return Collections.unmodifiableList(sortedConcepts);
    }

    public Concept getConcept(BigInteger s) {return getConcept(s, false);}

    public Concept getConcept(BigInteger ps, boolean ignoreNew) {
        for (Concept s1 : getConceptsInternal()) {
            if (!ignoreNew || !s1.isNew()) {
                BigInteger compName = s1.getConceptPk().getId();
                if (compName == ps) {return s1;}
            }
        }
        return null;
    }
}

@ManyToMany(cascade = {CascadeType.ALL})
    @JoinTable(name = "midTableName",
            joinColumns = {@JoinColumn(name = "foreignKey")},
            inverseJoinColumns = {@JoinColumn(name = "OtherEntityForeignKey")})