Spring Boot 无法扫描到子包中的Service实现类问题排查

Hey there! Let's break down why your Spring Boot app is failing to locate your Service implementation, even though you expect auto-scanning to work. Here are the most common culprits and how to fix them:

1. Your Application Class Is in the Wrong Package #

Spring Boot's default auto-scanning only covers the package where your @SpringBootApplication class lives and all its direct subpackages. If your Service implementation is in a sibling package (not a subpackage), it won't be picked up.

Example: #

• If your Application class is in com.myapp, then com.myapp.service is a valid subpackage (will be scanned).
• But if your Service is in com.myotherservice (a separate top-level package), or com.myapp's sibling like com.myapp2, it won't be scanned by default.

Fix: #

Either move your Service classes into the Application's package hierarchy, or explicitly specify the packages to scan in @SpringBootApplication:

@SpringBootApplication(scanBasePackages = {"com.myapp", "com.myotherservice"})
public class MyAppApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyAppApplication.class, args);
    }
}

2. Your Service Implementation Is Missing a Spring Stereotype Annotation #

Spring won't register a class as a managed Bean unless you mark it with an annotation like @Service, @Component, or @Repository (for DAOs). If your Service interface has @Service but the implementation doesn't, that's a problem—the annotation needs to be on the implementation class, not the interface.

Wrong: #

// Interface (don't put @Service here!)
@Service
public interface UserService {
    // ...
}

// Implementation (missing annotation)
public class UserServiceImpl implements UserService {
    // ...
}

Correct: #

// Interface (no annotation needed)
public interface UserService {
    // ...
}

// Implementation (annotated with @Service)
@Service
public class UserServiceImpl implements UserService {
    // ...
}

3. Maven Isn't Compiling Your Service Class #

Sometimes the issue isn't with Spring's scanning—it's that your Service implementation isn't even being compiled into the final JAR/WAR.

How to Check: #

Navigate to your project's target/classes directory (after running mvn clean install) and look for your Service implementation's .class file. If it's missing, your Maven build configuration is off.

Fix: #

Ensure your pom.xml has the correct build setup. For a standard Spring Boot project, it should look like this:

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

<!-- ... other dependencies ... -->

<build>
    <sourceDirectory>src/main/java</sourceDirectory>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Double-check there are no <exclude> rules in your build that would skip compiling your Service classes.

4. Custom Annotations Are Overriding Default Scanning #

If you've added annotations like @EnableJpaRepositories or @EntityScan to your Application class, make sure they don't accidentally restrict the default component scan range. While @SpringBootApplication includes @ComponentScan, adding custom scan annotations without specifying all necessary packages can leave your Service classes out.

Fix: #

Explicitly set the base packages for all scan-related annotations:

@SpringBootApplication(scanBasePackages = "com.myapp")
@EnableJpaRepositories(basePackages = "com.myapp.repository")
@EntityScan(basePackages = "com.myapp.entity")
public class MyAppApplication {
    // ...
}

5. Dependency Injection Mismatch (Less Likely, But Worth Checking) #

If your Controller is injecting the concrete Service class instead of the interface, and that class isn't scanned, you'll get the same error. Always inject the interface (best practice) to avoid this, but if you must inject the concrete class, ensure it's annotated and scanned.

Example: #

// Controller (inject interface, not concrete class)
@RestController
public class UserController {
    @Autowired
    private UserService userService; // Correct: inject interface
    // private UserServiceImpl userService; // Risky: injects concrete class
}

Start with checking the first two points—they're the most common causes for this issue in Spring Boot 1.5.x.

内容的提问来源于stack exchange，提问作者Nicklas2751