不断获得；java.lang.IllegalArgumentException:没有为该名称定义查询；即使我有一个合适的@NamedQuery名称

我有HibernateJPA应用程序。我在DAO类的函数中不断得到“java.lang.IllegalArgumentException:没有为该名称[Singer.findAll]定义查询”，即使我在@NamedQuery中正确定义了该名称。这是我的实体类

package ch8.entities;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "singer")
@NamedQueries({
        @NamedQuery(name = Singer.FIND_BY_ID,
                query = "select distinct s from Singer s "
                        + "left join fetch s.albums a "
                        + "left join fetch s.instruments i "
                        + "where s.id = :id"),

        @NamedQuery(name = Singer.FIND_ALL_WITH_ALBUM,
                query = "select distinct s from Singer s "
                        + "left join fetch s.albums a "
                        + "left join fetch s.instruments i"),

        @NamedQuery(name = Singer.FIND_ALL,
                query = "select s from Singer s")
})
@SqlResultSetMapping(name = "singerResult",
        entities = @EntityResult(entityClass = Singer.class))
public class Singer implements Serializable {
    private Long id;
    private String firstName;
    private String lastName;
    private Date birthDate;
    private Long version;
    private Set<Album> albums = new HashSet<>();
    private Set<Instrument> instruments = new HashSet<>();
    public static final String FIND_ALL = "Singer.findAll";
    public static final String FIND_BY_ID = "Singer.findById";
    public static final String FIND_ALL_WITH_ALBUM = "Singer.findAllWithAlbum";

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ID")
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    @Column(name = "FIRST_NAME")
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    @Column(name = "LAST_NAME")
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    @Temporal(TemporalType.DATE)
    @Column(name = "BIRTH_DATE")
    public Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    @Version
    @Column(name = "VERSION")
    public Long getVersion() {
        return version;
    }

    public void setVersion(Long version) {
        this.version = version;
    }

    @OneToMany(mappedBy = "singer", cascade = CascadeType.ALL, orphanRemoval = true)
    public Set<Album> getAlbums() {
        return albums;
    }

    public void setAlbums(Set<Album> albums) {
        this.albums = albums;
    }

    @ManyToMany
    @JoinTable(name = "singer_instrument",
    joinColumns = @JoinColumn(name = "SINGER_ID"),
    inverseJoinColumns = @JoinColumn(name = "INSTRUMENT_ID"))
    public Set<Instrument> getInstruments() {
        return instruments;
    }

    public void setInstruments(Set<Instrument> instruments) {
        this.instruments = instruments;
    }

    @Override
    public String toString () {
        return "Singer - Id: " + id + ", First name: "
                + firstName + ", Last name: " + lastName
                + ", Birthday: " + birthDate;
    }

    public boolean addAlbum(Album album) {
        if (albums == null) {
            albums = new HashSet<Album>();
            albums.add(album);
            return true;
        }
        if (albums.contains(album))
            return false;
        albums.add(album);
        return true;
    }

    public boolean removeAlbum(Album album) {
        if (album == null)
            return false;
        if (!albums.contains(album))
            return false;
        albums.remove(album);
        return true;
    }
}

包ch8.1；
导入javax.persistence.*；
导入java.io.Serializable；
导入java.util.Date；
导入java.util.HashSet；
导入java.util.Set；
@实体
@表（name=“singer”）
@命名查询({
@NamedQuery（name=Singer.FIND_BY_ID，
query=“从Singer s中选择不同的s”
+“左加入获取s.albums a”
+“左连接获取s.i”
+“其中s.id=：id”），
@NamedQuery（name=Singer.FIND_ALL_WITH_相册，
query=“从Singer s中选择不同的s”
+“左加入获取s.albums a”
+“左联取s.i”），
@NamedQuery（name=Singer.FIND_ALL，
query=“从Singer s中选择s”）
})
@SQLResultsMapping（name=“singerResult”，
entities=@EntityResult（entityClass=Singer.class））
公共类Singer实现了可序列化{
私人长id；
私有字符串名；
私有字符串lastName；
私人生日；
私人长版；
私有集相册=新HashSet（）；
私有集合工具=新HashSet（）；
公共静态最终字符串FIND_ALL=“Singer.findAll”；
公共静态最终字符串FIND_BY_ID=“Singer.findById”；
public static final String FIND_ALL_WITH_ALBUM=“Singer.findAllWithAlbum”；
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
@列（name=“ID”）
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
@列（name=“FIRST_name”）
公共字符串getFirstName（）{
返回名字；
}
public void setFirstName（字符串firstName）{
this.firstName=firstName；
}
@列（name=“LAST_name”）
公共字符串getLastName（）{
返回姓氏；
}
public void setLastName（字符串lastName）{
this.lastName=lastName；
}
@时态（TemporalType.DATE）
@列（name=“出生日期”）
公共日期getBirthDate（）{
返回出生日期；
}
公共无效设置出生日期（日期出生日期）{
this.birthDate=生日；
}
@版本
@列（name=“VERSION”）
公共长getVersion（）{
返回版本；
}
公共版本（长版本）{
this.version=版本；
}
@OneToMany（mappedBy=“singer”，cascade=CascadeType.ALL，orphan=true）
公共集getAlbums（）{
归还相册；
}
公共无效设置相册（设置相册）{
this.albums=相册；
}
@许多
@可接合（name=“singer_instrument”，
joinColumns=@JoinColumn（name=“SINGER\u ID”），
inverseJoinColumns=@JoinColumn（name=“INSTRUMENT\u ID”））
公共集合仪表（）{
返回仪器；
}
公用仪器（成套仪器）{
这个。仪器=仪器；
}
@凌驾
公共字符串toString（）{
返回“Singer-Id:+Id+”，名字：
+姓氏：“+lastName”
+，生日：“+生日；
}
公共布尔添加相册（相册）{
如果（相册==null）{
albums=新的HashSet（）；
相册。添加（相册）；
返回true；
}
if（相册包含（相册））
返回false；
相册。添加（相册）；
返回true；
}
公共布尔removeAlbum（相册）{
如果（相册==null）
返回false；
如果（！albums.contains（album））
返回false；
相册。删除（相册）；
返回true；
}
}

和刀类

package ch8.dao;

import ch8.entities.Singer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.Collection;

@Transactional
@Repository("singerDao")
public class SingerDao implements Dao<Singer> {
    @PersistenceContext
    private EntityManager entityManager;

...some other functions...

    @Override
    @Transactional(readOnly = true)
    public Collection<Singer> findAll() {
        return entityManager.createNamedQuery(Singer.FIND_ALL, Singer.class).getResultList();
    }

...some other functions...

}

包ch8.dao；
导入ch8.entities.Singer；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
导入org.springframework.stereotype.Repository；
导入org.springframework.transaction.annotation.Transactional；
导入javax.persistence.EntityManager；
导入javax.persistence.PersistenceContext；
导入java.util.Collection；
@交易的
@存储库（“singerDao”）
公共类SingerDao实现Dao{
@持久上下文
私人实体管理者实体管理者；
…其他一些功能。。。
@凌驾
@事务（只读=真）
公共集合findAll（）{
返回entityManager.createNamedQuery（Singer.FIND_ALL，Singer.class）.getResultList（）；
}
…其他一些功能。。。
}

---

我认为这可能与类映射有关，因为常规的createQuery（字符串，类）不起作用。

多亏了JLazar0的建议，我找到了解决问题的方法。和往常一样，问题不是因为错误的逻辑、错误的配置或坚持。我之所以一直得到“没有为该名称定义查询”，尽管一切似乎都很好，是因为我在LocalContainerEntityManagerFactoryBean.setPackagesToScan（）中有错误的包名。在方法参数中进行了一些小的修改之后，我的代码通过了所有的测试。

---

无论如何，感谢所有试图提供帮助的人

首先，一切似乎都是正确的，您能否通过在命名查询定义的名称和createNamedQuery方法中都添加字符串“test”来执行测试？如果我理解正确，您所说的是这样的

@NamedQuery（name=“test”，query=“从Singer s中选择s”）

和

返回entityManager.createNamedQuery（“test”，Singer.class）.getResultList（）

在本例中，结果是相同的（java.lang.IllegalArgumentException:No query defined for the name[test]），在persistence.xml中设置事务类型