Ошибка зависимостей Spring Boot в IntelliJ

The dependency error you’re experiencing occurs because IntelliJ IDEA’s Application configuration handles dependencies differently than the Maven run configuration, leading to incomplete classpath resolution for certain dependencies such as Apache HTTP components.

Contents

• Understanding the Configuration Differences
• Root Causes of Dependency Issues
• Solutions for Application Configuration
• Resolving the Apache HTTP ClassNotFoundException
• Best Practices for Spring Boot Development
• Prevention Strategies

Understanding the Configuration Differences

IntelliJ IDEA’s Application configuration and Maven run configuration fundamentally differ in how they resolve and manage dependencies:

• Maven Configuration: Uses Maven’s dependency‑resolution mechanism, which correctly handles all scopes including provided, test, and runtime. When you run spring‑boot:run, Maven builds the complete classpath including all necessary dependencies.

• Application Configuration: Relies on IntelliJ’s internal dependency resolver, which may not properly handle all Maven scopes and dependency types. This is why certain dependencies work with Maven but fail with the Application configuration.

As noted in the research findings, “IntelliJ IDEA is not injecting the provided dependencies into the CLASSPATH” and this is why Spring is unable to create the embedded servlet container [source: Stack Overflow].

Root Causes of Dependency Issues

Several factors contribute to the dependency‑resolution problems:

1. Classpath Incompleteness

The Application configuration often doesn’t include all the dependencies that Maven resolves. This is particularly problematic for:

• Dependencies with provided scope
• Transitive dependencies
• Runtime dependencies

According to user reports, “Unless IntelliJ is made aware that the project is a Maven one, it won’t download those dependencies at all” [source: Stack Overflow].

2. Module Configuration Issues

IntelliJ IDEA’s module settings can affect dependency resolution. One user found that “in Project Modules, uncheck main & test so they are not modules” helped resolve dependency issues [source: JetBrains Community].

3. Maven Integration Problems

When IntelliJ doesn’t properly recognize the project as a Maven project, it fails to download and manage dependencies correctly, leading to incomplete classpaths.

Solutions for Application Configuration

Solution 1: Add Dependencies with “Provided” Scope to Classpath

In IntelliJ IDEA 2022.3.1 and later, there’s a specific option to handle this:

1. Go to Run > Edit Configurations
2. Select your Application configuration
3. In the Modify options dropdown, check “Add dependencies with ‘provided’ scope to classpath”

This directly addresses the issue where “dependencies with ‘provided’ scope” are not being included in the classpath [source: Stack Overflow].

Solution 2: Use Spring Boot Run Configuration Instead

The most reliable approach is to use IntelliJ IDEA’s dedicated Spring Boot run configuration:

1. Right‑click your main application class
2. Select Run ‘YourApplicationName’
3. IntelliJ will automatically create a proper Spring Boot run configuration

This configuration is specifically designed for Spring Boot applications and handles dependencies correctly [source: IntelliJ IDEA Documentation].

Solution 3: Configure Maven Integration

Ensure your project is properly recognized as a Maven project:

1. Check that the Maven tool window shows your project structure correctly
2. Verify that dependencies are downloaded in the Maven tool window
3. Right‑click the project and select Maven > Reload Project

As one user noted, “you need to let it scan and add dependencies” for proper integration [source: Reddit].

Resolving the Apache HTTP ClassNotFoundException

The specific ClassNotFoundException: org.apache.http.protocol.HttpRequestExecutor error indicates that Apache HTTP client dependencies are missing from the classpath:

1. Check Dependencies in pom.xml

Verify that you have the Apache HTTP client dependency in your pom.xml:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.13</version>
</dependency>

2. Verify Dependency Scope

Ensure the dependency is not in provided scope unless you have a specific reason:

<!-- Wrong for this case -->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.13</version>
    <scope>provided</scope>
</dependency>

3. Force Dependency Resolution

Add the dependency to Spring Boot’s exclusion list to force resolution:

<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-s3</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Then explicitly add the Apache HTTP client dependency.

Best Practices for Spring Boot Development

1. Prefer Spring Boot Run Configuration

Always use IntelliJ IDEA’s Spring Boot run configuration when available, as it provides the most reliable dependency resolution and debugging experience.

2. Regular Dependency Updates

Keep your dependencies updated and consistent:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

3. Dependency Scoping Best Practices

Use appropriate dependency scopes:

• compile: Dependencies needed at compile and runtime
• provided: Dependencies available at runtime (like servlet API)
• runtime: Dependencies needed at runtime but not compile
• test: Dependencies needed for testing only

Prevention Strategies

1. Regular Project Validation

Use IntelliJ’s built‑in tools to validate your project setup:

• File > Invalidate Caches / Restart
• Maven > Reload Project
• File > Project Structure to verify module settings

2. Consistent Development Environment

Ensure all team members use the same IntelliJ IDEA version and settings to avoid configuration discrepancies.

3. Automated Testing

Set up integration tests that verify application startup with different run configurations to catch dependency issues early:

@SpringBootTest
class ApplicationStartupTests {
    
    @Test
    void contextLoads() {
        // This test verifies the application context loads correctly
    }
}

Sources

1. IntelliJ Run Configuration Spring Boot vs Maven Issues - Stack Overflow
2. Spring Boot | IntelliJ IDEA Documentation
3. Run Spring‑boot’s main using IDE - Stack Overflow
4. Spring Boot run configuration | IntelliJ IDEA Documentation
5. Difficulty Getting Spring Boot Project Working – JetBrains Community
6. Application Running via Spring Boot Run but not via IntelliJ Idea - Stack Overflow
7. No matter how I create my Spring boot project, IntelliJ is unable to recognize the dependencies - Reddit

Conclusion

The dependency issues you’re experiencing stem from fundamental differences between IntelliJ IDEA’s Application configuration and Maven run configuration in how they handle classpath resolution. The key takeaways are:

1. Use Spring Boot run configuration for the most reliable development experience with Spring Boot applications.
2. Configure IntelliJ to include “provided” scope dependencies in the classpath when using Application configuration.
3. Verify Maven integration and ensure all dependencies are properly downloaded and recognized.
4. Check dependency scopes in your pom.xml to ensure Apache HTTP components are included.
5. Regular project validation helps prevent and resolve configuration issues.

By implementing these solutions, you should be able to resolve the ClassNotFoundException and have consistent behavior across different run configurations in IntelliJ IDEA.