构造函数抛出异常；嵌套异常为java.lang.IllegalArgumentException:未找到域类的查询类

我在sts中创建了一个maven项目，我正在尝试为该项目创建一个war文件。我还为我的类配置了querydsl。一个类在我运行maven安装时给我一个错误响应。错误：创建文件[C:\Users\vince\Documents\workspace-spring-tool-suite-4-4.0.1.RELEASE\project\target\test classes\com\project\project\StoreBased\productBrandController.class]中定义的名为“productBrandController”的bean时出错：通过构造函数参数0表示的未满足的依赖关系；嵌套异常为org.springframework.beans.factory.BeanCreationException:创建名为“productBrandRepository”的bean时出错：调用init方法失败；嵌套异常为org.springframework.beans.Bean实例化异常：未能实例化[org.springframework.data.mongodb.repository.support.QuerydslMongoPredicateExecutor]：构造函数引发异常；嵌套异常为java.lang.IllegalArgumentException:未找到域类project.StoreBased.ProductBrand的查询类project.QProductBrand！我需要pom文件的帮助（不确定javax.xml.bind是否是罪魁祸首），也不确定我的输出目录是否正确（我已经尝试使用java而不是注释作为输出）。非常感谢你的帮助

这是一节课

import java.util.ArrayList;
import java.util.List;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.IndexDirection;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;


@Document(collection = "ProductBrand")
public class ProductBrand {

    @Id
    private String id;
    private ProductsBasic basic;
    @Indexed(direction = IndexDirection.ASCENDING)
    private String name;
    @Indexed(direction = IndexDirection.ASCENDING)
    private String units;
    @Indexed(direction = IndexDirection.ASCENDING)
    private double price;
    @Indexed(direction = IndexDirection.ASCENDING)
    private double price100g;
    private String manufacturer;
    private List<Manufacturer> manufacturerIndex;
    private boolean organic;
    private List<Organic> organicIndex;
    private String category;
    private List<Category> categoryIndex;
    private String subCategory;
    private List<SubCategory> subCategoryIndex;
    private boolean seasonal;
    private List<Seasonal> seasonalIndex;
    private boolean frozenGoods;
    private List<FrozenGoods> frozenGoodsIndex;
    private boolean refrigeratedGoods;
    private List<RefrigeratedGoods> refrigeratedGoodsIndex;
    private boolean available;
    private List<Available> availableIndex;
    @Indexed(direction = IndexDirection.ASCENDING)
    private String store;
    private List<Store> storeIndex;

    // public ProductBrand() {
    // super();
    // }

    public ProductBrand() {
        this.setAvailableIndex(new ArrayList<>());
        this.setCategoryIndex(new ArrayList<>());
        this.setSubCategoryIndex(new ArrayList<>());
        this.setFrozenGoodsIndex(new ArrayList<>());
        this.setManufacturerIndex(new ArrayList<>());
        this.setOrganicIndex(new ArrayList<>());
        this.setRefrigeratedGoodsIndex(new ArrayList<>());
        this.setSeasonalIndex(new ArrayList<>());
        this.setStoreIndex(new ArrayList<>());
    }

    public ProductBrand(String id, ProductsBasic basic, String name, String units, double price, double price100g,
        String manufacturer, List<Manufacturer> manufacturerIndex, boolean organic, List<Organic> organicIndex,
        String category, List<Category> categoryIndex, String subCategory, List<SubCategory> subCategoryIndex,
        boolean seasonal, List<Seasonal> seasonalIndex, boolean frozenGoods, List<FrozenGoods> frozenGoodsIndex,
        boolean refrigeratedGoods, List<RefrigeratedGoods> refrigeratedGoodsIndex, boolean available,
        List<Available> availableIndex, String store, List<Store> storeIndex) {
        super();
        this.id = id;
        this.basic = basic;
        this.name = name;
        this.units = units;
        this.price = price;
        this.price100g = price100g;
        this.manufacturer = manufacturer;
        this.setManufacturerIndex(manufacturerIndex);
        this.organic = organic;
        this.setOrganicIndex(organicIndex);
        this.category = category;
        this.setCategoryIndex(categoryIndex);
        this.subCategory = subCategory;
        this.setSubCategoryIndex(subCategoryIndex);
        this.seasonal = seasonal;
        this.setSeasonalIndex(seasonalIndex);
        this.frozenGoods = frozenGoods;
        this.setFrozenGoodsIndex(frozenGoodsIndex);
        this.refrigeratedGoods = refrigeratedGoods;
        this.setRefrigeratedGoodsIndex(refrigeratedGoodsIndex);
        this.available = available;
        this.setAvailableIndex(availableIndex);
        this.store = store;
        this.setStoreIndex(storeIndex);
    }

    public String getManufacturer() {
        return manufacturer;
    }

    public void setManufacturer(String manufacturer) {
        this.manufacturer = manufacturer;
    }

    public boolean isOrganic() {
        return organic;
    }

    public void setOrganic(boolean organic) {
        this.organic = organic;
    }

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    public String getSubCategory() {
        return subCategory;
    }

    public void setSubCategory(String subCategory) {
        this.subCategory = subCategory;
    }

    public boolean isSeasonal() {
        return seasonal;
    }

    public void setSeasonal(boolean seasonal) {
        this.seasonal = seasonal;
    }

    public boolean isFrozenGoods() {
        return frozenGoods;
    }

    public void setFrozenGoods(boolean frozenGoods) {
        this.frozenGoods = frozenGoods;
    }

    public boolean isRefrigeratedGoods() {
        return refrigeratedGoods;
    }

    public void setRefrigeratedGoods(boolean refrigeratedGoods) {
        this.refrigeratedGoods = refrigeratedGoods;
    }

    public boolean isAvailable() {
        return available;
    }

    public void setAvailable(boolean available) {
        this.available = available;
    }

    public void addProduktBrand(ProductBrand productBrand) {
        ProductBrand.add(productBrand);
    }

    public static void add(ProductBrand productBrand) {
    }

    public String getId() {
        return id;
    }

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

    public ProductsBasic getBasic() {
        return basic;
    }

    public void setBasic(ProductsBasic basic) {
        this.basic = basic;
    }

    public String getStore() {
        return store;
    }

    public void setStore(String store) {
        this.store = store;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getUnits() {
        return units;
    }

    public void setUnits(String units) {
        this.units = units;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getPrice100g() {
        return price100g;
    }

    public void setPrice100g(double price100g) {
        this.price100g = price100g;
    }

    public List<Manufacturer> getManufacturerIndex() {
        return manufacturerIndex;
    }

    public void setManufacturerIndex(List<Manufacturer> manufacturerIndex) {
        this.manufacturerIndex = manufacturerIndex;
    }

    public List<Organic> getOrganicIndex() {
        return organicIndex;
    }

    public void setOrganicIndex(List<Organic> organicIndex) {
        this.organicIndex = organicIndex;
    }

    public List<Category> getCategoryIndex() {
        return categoryIndex;
    }

    public void setCategoryIndex(List<Category> categoryIndex) {
        this.categoryIndex = categoryIndex;
    }

    public List<SubCategory> getSubCategoryIndex() {
        return subCategoryIndex;
    }

    public void setSubCategoryIndex(List<SubCategory> subCategoryIndex) {
        this.subCategoryIndex = subCategoryIndex;
    }

    public List<Seasonal> getSeasonalIndex() {
        return seasonalIndex;
    }

    public void setSeasonalIndex(List<Seasonal> seasonalIndex) {
        this.seasonalIndex = seasonalIndex;
    }

    public List<FrozenGoods> getFrozenGoodsIndex() {
        return frozenGoodsIndex;
    }

    public void setFrozenGoodsIndex(List<FrozenGoods> frozenGoodsIndex) {
        this.frozenGoodsIndex = frozenGoodsIndex;
    }

    public List<RefrigeratedGoods> getRefrigeratedGoodsIndex() {
        return refrigeratedGoodsIndex;
    }

    public void setRefrigeratedGoodsIndex(List<RefrigeratedGoods> refrigeratedGoodsIndex) {
        this.refrigeratedGoodsIndex = refrigeratedGoodsIndex;
    }

    public List<Available> getAvailableIndex() {
        return availableIndex;
    }

    public void setAvailableIndex(List<Available> availableIndex) {
        this.availableIndex = availableIndex;
    }

    public List<Store> getStoreIndex() {
        return storeIndex;
    }

    public void setStoreIndex(List<Store> storeIndex) {
        this.storeIndex = storeIndex;
    }

}

import java.util.List;
import java.util.Optional;

import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import project.QProductBrand;
import com.querydsl.core.types.dsl.BooleanExpression;


@RestController
@RequestMapping("/productbrand")
public class ProductBrandController {
    private ProductBrandRepository productBrandRepository;

    public ProductBrandController(ProductBrandRepository productBrandRepository) {
        this.productBrandRepository = productBrandRepository;
    }

    @GetMapping("/all")
    public List<ProductBrand> getAll() {
        List<ProductBrand> product = this.productBrandRepository.findAll();

        return product;
    }

    @GetMapping("/productbrand/{name}")
    public List<ProductBrand> getByName(@PathVariable("name") String name) {
        List<ProductBrand> product = this.productBrandRepository.findByName(name);

        return product;
    }

    @PutMapping
    public void insert(@RequestBody ProductBrand productBrand) {
        this.productBrandRepository.insert(productBrand);
    }

    @PostMapping
    public void update(@RequestBody ProductBrand productBrand) {
        this.productBrandRepository.save(productBrand);
    }

    @DeleteMapping("/{id}")
    public void delete(@PathVariable("id") ProductBrand id) {
        this.productBrandRepository.delete(id);
    }

    @GetMapping("/{id}")
    public Optional<ProductBrand> getById(@PathVariable("id") String id) {
        Optional<ProductBrand> brand = this.productBrandRepository.findById(id);
        return brand;

    }

    @GetMapping("/productBrand/{organic}")
    public List<ProductBrand> getByOrganic(@PathVariable("organic") boolean organic) {
        List<ProductBrand> brand = this.productBrandRepository.findByOrganic(organic);

        return brand;
    }

    @GetMapping("/productBrand/{manufacturer}")
    public List<ProductBrand> getByManufacturer(@PathVariable("manufacturer") String manufacturer) {
        List<ProductBrand> brand = this.productBrandRepository.findByManufacturer(manufacturer);

        return brand;
    }

    @GetMapping("/productBrand/{category}")
    public List<ProductBrand> getByCategory(@PathVariable("category") String category) {
        List<ProductBrand> brand = this.productBrandRepository.findByCategory(category);

        return brand;
    }

    @GetMapping("/productBrand/{seasonal}")
    public List<ProductBrand> getBySeasonal(@PathVariable("seasonal") boolean seasonal) {
        List<ProductBrand> brand = this.productBrandRepository.findBySeasonal(seasonal);

        return brand;
    }

    @GetMapping("/productBrand/{frozenGoods}")
    public List<ProductBrand> getByFrozenGoods(@PathVariable("frozenGoods") boolean frozenGoods) {
        List<ProductBrand> brand = this.productBrandRepository.findByFrozenGoods(frozenGoods);

        return brand;
    }

    @GetMapping("/productBrand/{refrigeratedGoods}")
    public List<ProductBrand> getByRefrigeratedGoods(@PathVariable("refrigeratedGoods") boolean refrigeratedGoods) {
        List<ProductBrand> brand = this.productBrandRepository.findByRefrigeratedGoods(refrigeratedGoods);

        return brand;
    }

    @GetMapping("/productBrand/{available}")
    public List<ProductBrand> getByAvailable(@PathVariable("available") boolean available) {
        List<ProductBrand> brand = this.productBrandRepository.findByAvailable(available);

        return brand;
    }


    @GetMapping("/recommended")
    public List<ProductBrand> getRecommended() {
        final boolean isOrganic = true;
        final boolean isSeasonal = true;

        QProductBrand qBrand = new QProductBrand("ProductBrand");

        BooleanExpression filterByOrganic = (qBrand.organicIndex).any().organic.gt(isOrganic);

        BooleanExpression filterBySeasonal = (qBrand.seasonalIndex).any().seasonal.gt(isSeasonal);

        List<ProductBrand> brand = (List<ProductBrand>) this.productBrandRepository
                .findAll(filterByOrganic.and(filterBySeasonal));

        return brand;
    }

}

import java.util.ArrayList；
导入java.util.List；
导入org.springframework.data.annotation.Id；
导入org.springframework.data.mongodb.core.index.IndexDirection；
导入org.springframework.data.mongodb.core.index.index；
导入org.springframework.data.mongodb.core.mapping.Document；
@文档（collection=“ProductBrand”）
公共类产品品牌{
@身份证
私有字符串id；
私人产品基础知识；
@索引（方向=索引方向.升序）
私有字符串名称；
@索引（方向=索引方向.升序）
专用字符串单元；
@索引（方向=索引方向.升序）
私人双价；
@索引（方向=索引方向.升序）
私人双价100克；
私人字符串制造商；
私有列表制造商索引；
私有布尔有机；
私有列表索引；
私有字符串类别；
私有列表分类索引；
私有字符串子类别；
私有列表子类别索引；
私营部门；
私人列表季节索引；
私人物品；
私人名单frozenGoodsIndex；
私人冷藏货物；
私有列表冷藏库索引；
私有布尔值可用；
私有列表可用索引；
@索引（方向=索引方向.升序）
私人字符串存储；
私有列表存储索引；
//公共产品品牌（）{
//超级（）；
// }
公共产品品牌（）{
this.setAvailableIndex（新的ArrayList（））；
this.setCategoryIndex（新的ArrayList（））；
这个.setSubCategoryIndex（newArrayList（））；
这个.setFrozenGoodsIndex（新的ArrayList（））；
这个.setManufacturerIndex（新的ArrayList（））；
这个.setOrganiIndex（新的ArrayList（））；
这个.setReflectionGoodIndex（新的ArrayList（））；
这个.setSeasonIndex（新的ArrayList（））；
这个.setStoreIndex（新的ArrayList（））；
}
公共产品品牌（字符串id、产品基本、字符串名称、字符串单位、双倍价格、双倍价格100g、，
字符串制造商，列表制造商索引，布尔有机，列表有机索引，
字符串类别、列表类别索引、字符串子类别、列表子类别索引、，
布尔季节，列表季节索引，布尔冻结商品，列表冻结商品索引，
布尔值冷藏库，列表冷藏库索引，布尔值可用，
列表可用索引、字符串存储、列表存储索引）{
超级（）；
this.id=id；
this.basic=basic；
this.name=名称；
这个。单位=单位；
这个价格=价格；
此参数。价格100g=价格100g；
这个。制造商=制造商；
此.setManufacturerIndex（manufacturerIndex）；
这个。有机=有机；
此.setOrganizationIndex（OrganizationIndex）；
this.category=类别；
这个.setCategoryIndex（categoryIndex）；
this.subCategory=子类别；
此.setSubCategoryIndex（子类别索引）；
这是季节性的；
这是设置季节指数（季节指数）；
this.frozencoods=冻结商品；
这个.setFrozenGoodsIndex（frozenGoodsIndex）；
this.冷藏食品=冷藏食品；
此.setReflectiveGoodIndex（ReflectiveGoodIndex）；
this.available=可用；
此.setAvailableIndex（availableIndex）；
this.store=商店；
这个.setStoreIndex（storeIndex）；
}
公共字符串getManufacturer（）{
退货制造商；
}
公共无效设置制造商（字符串制造商）{
这个。制造商=制造商；
}
公共布尔同构（）{
回归有机；
}
公共void setOrganic（布尔有机）{
这个。有机=有机；
}
公共字符串getCategory（）{
退货类别；
}
公共无效集合类别（字符串类别）{
this.category=类别；
}
公共字符串getSubCategory（）{
返回子类别；
}
公共无效集合子类别（字符串子类别）{
this.subCategory=子类别；
}
公共布尔IsSessional（）{
季节性回归；
}
公共空间设置季节（布尔季节）{
这是季节性的；
}
公共布尔值isFrozenGoods（）{
退回冷冻物品；
}
public void setFrozenCoods（布尔FrozenCoods）{
this.frozencoods=冻结商品；
}
公共布尔值isRefrigeratedGoods（）{
退回冷藏食品；
}
公共无效集合冷藏库（布尔冷藏库）{
this.冷藏食品=冷藏食品
import java.util.List;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductBrandRepository extends MongoRepository<ProductBrand, String>, QuerydslPredicateExecutor<ProductBrand> {

    List<ProductBrand> findByName(String name);

    List<ProductBrand> findByOrganic(boolean organic);

    List<ProductBrand> findBySeasonal(boolean seasonal);

    List<ProductBrand> findByFrozenGoods(boolean frozenGoods);

    List<ProductBrand> findByRefrigeratedGoods(boolean refrigeratedGoods);

    List<ProductBrand> findByAvailable(boolean available);

    List<ProductBrand> findByCategory(String category);

    List<ProductBrand> findByManufacturer(String manufacturer);

}

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.BETAapp</groupId>
    <artifactId>project</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>project</name>
    <description>demo</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-groovy-templates</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mustache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
    </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.4.0-b180725.0427</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mongodb.morphia/morphia -->
        <dependency>
            <groupId>org.mongodb.morphia</groupId>
            <artifactId>morphia</artifactId>
            <version>0.107</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.persistence/javax.persistence-api -->
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>2.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.querydsl/querydsl-apt -->
        <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-mongodb</artifactId>
            <version>4.2.1</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mongodb</groupId>
                    <artifactId>mongo-java-driver</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>com.mysema.maven</groupId>
                <artifactId>apt-maven-plugin</artifactId>
                <version>1.1.3</version>
                <dependencies>
                    <dependency>
                        <groupId>com.querydsl</groupId>
                        <artifactId>querydsl-apt</artifactId>
                        <version>4.2.1</version>
                    </dependency>
                </dependencies>
                <executions>
                    <execution>
                        <phase>generate-sources</phase>
                        <goals>
                            <goal>process</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>target/generated-sources/annotations</outputDirectory>
                            <processor>org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor</processor>
                            <logOnlyOnError>true</logOnlyOnError>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>


</project>

Your Query Classes are generated in different package (i.e. inside /annotations) and 
you are trying to find it from different package.

<outputDirectory>target/generated-sources/annotations</outputDirectory>

<outputDirectory>target/generated-sources/apt</outputDirectory>