Spring Boot(Maven+JPA+H2)遇Not a managed type及Bean创建错误求助

算力阿峰

2026-7-4

Spring Boot启动报错：Not a managed type: class com.factory.ordersystem.entities.Address

2023-12-16T23:43:15.665+01:00  WARN 22472 --- [  restartedMain] ConfigServletWebServerApplicationContext : Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'addressController' defined in file [C:\target\classes\com\factory\ordersystem\controller\AddressController.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'addressService' defined in file [C:\target\classes\com\factory\ordersystem\service\AddressService.class]: Unsatisfied dependency expressed through constructor parameter 0: Error creating bean with name 'addressRepository' defined in com.factory.ordersystem.repository.AddressRepository defined in @EnableJpaRepositories declared on JpaRepositoriesRegistrar.EnableJpaRepositoriesConfiguration: Not a managed type: class com.factory.ordersystem.entities.Address

相关代码

AddressController

package com.factory.ordersystem.controller;

import com.factory.ordersystem.entities.Address;
import com.factory.ordersystem.service.AddressService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/addresses")
public class AddressController {

    private final AddressService addressService;

    public AddressController(AddressService addressService) {
        this.addressService = addressService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<Address> getAddressById(@PathVariable Long id) {
        Optional<Address> address = addressService.getAddressById(id);
        return address != null ?
                (ResponseEntity<Address>) ResponseEntity.ok() :
                ResponseEntity.notFound().build();
    }

    @GetMapping
    public ResponseEntity<List<Address>> getAllAddresses() {
        List<Address> addresses = addressService.getAllAddresses();
        return ResponseEntity.ok(addresses);
    }

    @PostMapping
    public ResponseEntity<Address> createAddress(@RequestBody Address address) {
        Address createdAddress = addressService.createAddress(address);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdAddress);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Address> updateAddress(@PathVariable Long id, @RequestBody Address updatedAddress) {
        Optional<Address> updated = Optional.ofNullable(addressService.updateAddress(id, updatedAddress));

        return updated.map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteAddress(@PathVariable Long id) {
        boolean deleted = addressService.deleteAddress(id);
        return deleted ?
                ResponseEntity.noContent().build() :
                ResponseEntity.notFound().build();
    }
}

Address实体类

package com.factory.ordersystem.entities;

import javax.persistence.*;
import javax.validation.constraints.NotBlank;

@Entity
public class Address {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank
    private String street;

    @NotBlank
    private String city;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;

    public Address() {
    }

    public Address(String street, String city) {
        this.street = street;
        this.city = city;
    }

    public Long getId() {
        return id;
    }

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

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    @Override
    public String toString() {
        return "Address{" +
                "id=" + id +
                ", street='" + street + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

AddressRepository

package com.factory.ordersystem.repository;

import com.factory.ordersystem.entities.Address;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface AddressRepository extends JpaRepository<Address, Long> {
}

AddressService

package com.factory.ordersystem.service;

import com.factory.ordersystem.entities.Address;
import com.factory.ordersystem.exception.ResourceNotFoundException;
import com.factory.ordersystem.repository.AddressRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class AddressService {

    private final AddressRepository addressRepository;

    @Autowired
    public AddressService(AddressRepository addressRepository) {
        this.addressRepository = addressRepository;
    }

    public List<Address> getAllAddresses() {
        return addressRepository.findAll();
    }

    public Optional<Address> getAddressById(Long id) {
        return addressRepository.findById(id);
    }

    public Address createAddress(Address address) {
        return addressRepository.save(address);
    }

    public Address updateAddress(Long id, Address updatedAddress) {
        Optional<Address> optionalAddress = addressRepository.findById(id);
        if (optionalAddress.isPresent()) {
            Address existingAddress = optionalAddress.get();
            existingAddress.setStreet(updatedAddress.getStreet());
            existingAddress.setCity(updatedAddress.getCity());
            return addressRepository.save(existingAddress);
        } else {
            throw new ResourceNotFoundException("Address with id " + id + " not found");
        }
    }

    public boolean deleteAddress(Long id) {
        if (addressRepository.existsById(id)) {
            addressRepository.deleteById(id);
            return true;
        } else {
            return false;
        }
    }
}

application.properties

# DataSource Configuration
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
spring.datasource.password=password
spring.datasource.driverClassName=org.h2.Driver

# Hibernate Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.open-in-view=false

# H2 Console Configuration
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>3.2.0</version>
       <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.factory.ordersytem</groupId>
    <artifactId>com.exam.pgr209</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>com.exam.pgr209</name>
    <description>order machine backend exam</description>
    <properties>
       <java.version>21</java.version>
    </properties>
    <dependencies>
       <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-jpa</artifactId>
       </dependency>
       <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
       </dependency>

       <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-devtools</artifactId>
          <scope>runtime</scope>
          <optional>true</optional>
       </dependency>
       <dependency>
          <groupId>com.h2database</groupId>
          <artifactId>h2</artifactId>
          <scope>runtime</scope>
       </dependency>
       <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
          <scope>test</scope>
       </dependency>

       <dependency>
          <groupId>javax.persistence</groupId>
          <artifactId>javax.persistence-api</artifactId>
          <version>2.2</version>
       </dependency>

       <dependency>
          <groupId>javax.validation</groupId>
          <artifactId>validation-api</artifactId>
          <version>2.0.1.Final</version> <!-- or the latest version -->
       </dependency>

    </dependencies>

    <build>
       <plugins>
          <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
       </plugins>
    </build>

</project>

已尝试的排查步骤

使用VM调试
重构文件结构
重新创建文件
观看"not a managed type"错误教程视频
尝试集成Lombok
与已知可行项目对比
大量查阅资料
检查拼写错误
配置@EntityScan

解决方案

1. 替换JPA和Validation的导入包（核心问题）

Spring Boot 3.2.0基于Jakarta EE 9+，不再支持Java EE的javax.*包，需将实体类中的导入替换为jakarta.*：

import jakarta.persistence.*;
import jakarta.validation.constraints.NotBlank;

2. 移除pom.xml中过时的依赖

Spring Boot 3.x的starter已包含Jakarta相关依赖，手动添加的javax.persistence-api和validation-api会导致依赖冲突，删除这两个依赖：

<!-- 移除以下两个依赖 -->
<dependency>
   <groupId>javax.persistence</groupId>
   <artifactId>javax.persistence-api</artifactId>
   <version>2.2</version>
</dependency>

<dependency>
   <groupId>javax.validation</groupId>
   <artifactId>validation-api</artifactId>
   <version>2.0.1.Final</version>
</dependency>

3. 确认主类的包扫描范围

确保Spring Boot主类（带@SpringBootApplication注解）位于com.factory.ordersystem包下，默认会扫描该包及其子包的组件。若主类在其他包，需添加注解指定扫描路径：

@SpringBootApplication
@EntityScan(basePackages = "com.factory.ordersystem.entities")
@EnableJpaRepositories(basePackages = "com.factory.ordersystem.repository")
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

4. 清理并重新构建项目

执行Maven命令清理缓存并重新构建：

mvn clean install

内容的提问来源于stack exchange，提问作者Yousef A.

Spring Boot(Maven+JPA+H2)遇Not a managed type及Bean创建错误求助

相关代码 #

AddressController #

Address实体类 #

AddressRepository #

AddressService #

application.properties #

pom.xml #

已尝试的排查步骤 #

解决方案 #

1. 替换JPA和Validation的导入包（核心问题） #

2. 移除pom.xml中过时的依赖 #

3. 确认主类的包扫描范围 #

4. 清理并重新构建项目 #