Run Spring Boot Maven Project in Eclipse

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

Eclipse is a popular IDE for Java development, and it provides excellent support for Spring Boot projects. In this tutorial, we will walk you through the steps to create, import, and run a Spring Boot Maven project in Eclipse.

Prerequisites

• JDK 17 or later
• Maven
• Eclipse IDE installed on your machine (Eclipse IDE for Enterprise Java and Web Developers recommended)
• Spring Boot (version 3.2+ recommended)

Step 1: Set Up a Spring Boot Project Using Spring Initializr

Use Spring Initializr to generate a new Spring Boot project with the following configuration:

• Project: Maven Project
• Language: Java
• Spring Boot: 3.2.x
• Dependencies: Spring Web

Download the generated project, unzip it, and open it in Eclipse.

Example Project Structure

The basic structure of a Spring Boot project with Maven looks like this:

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       └── DemoApplication.java
│   │   └── resources/
│   │       ├── application.properties
│   └── test/
│       └── java/
│           └── com/example/demo/
│               └── DemoApplicationTests.java
├── mvnw
├── mvnw.cmd
├── pom.xml
└── .mvn/
    └── wrapper/
        └── maven-wrapper.properties

Step 2: Import the Maven Project into Eclipse

1. Open Eclipse: Launch Eclipse on your machine.

2. Import Project:

   • Click on File -> Import....
   • In the Import dialog, select Existing Maven Projects under the Maven folder and click Next.
   • Click Browse and navigate to the root directory of your Spring Boot project. Select the pom.xml file.
   • Ensure that your project is selected in the Projects list and click Finish.

Eclipse will import the project and resolve all dependencies specified in the pom.xml file.

Step 3: Explore the Project Structure

After the project is imported, you can explore the project structure in the Project Explorer panel on the left side of the Eclipse window. You should see the standard Maven project layout with src/main/java, src/main/resources, src/test/java, and src/test/resources directories.

Step 4: Create the Application Class

Create a Java class named DemoApplication in the src/main/java/com/example/demo directory.

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Explanation:

• @SpringBootApplication: Marks this class as the main entry point for the Spring Boot application.
• main method: Starts the Spring Boot application.

Step 5: Create a Simple REST Controller

To verify the application works as expected, let's create a simple REST controller.

Create a Java class named HelloController in the src/main/java/com/example/demo directory:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

Explanation:

• @RestController: Marks this class as a REST controller.
• @GetMapping("/hello"): Maps HTTP GET requests to the /hello endpoint to the sayHello method.
• sayHello method: Returns a "Hello, World!" message.

Step 6: Run the Application

Using Eclipse

1. Run the Application:

   • Right-click on the DemoApplication class in the Project Explorer.
   • Select Run As -> Spring Boot App.

   Eclipse will build the project and start the Spring Boot application.

2. View the Output:

   • The Console window will open at the bottom of the Eclipse window.
   • You should see logs indicating that the application has started successfully.

Verifying the Application

Open a web browser or a tool like Postman and navigate to the following URL to verify the application:

• Hello Endpoint:
  • URL: http://localhost:8080/hello
  • Method: GET
  • Response: Hello, World!

You should see the "Hello, World!" message returned by the HelloController.

Step 7: Creating a Test Class

Create a Java class named DemoApplicationTests in the src/test/java/com/example/demo directory.

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class DemoApplicationTests {

    @Test
    void contextLoads() {
    }
}

Explanation:

• @SpringBootTest: Indicates that this is a Spring Boot test.
• contextLoads method: Tests if the Spring application context loads successfully.

Running Tests

1. Run Tests:

   • Right-click on the DemoApplicationTests class in the Project Explorer.
   • Select Run As -> JUnit Test.

2. View Test Results:

   • The Console window will open at the bottom of the Eclipse window.
   • You should see the test results indicating that the tests passed successfully.

Conclusion

In this tutorial, you have learned how to create, import, and run a Spring Boot Maven project in Eclipse. We covered:

• Setting up a Spring Boot project using Spring Initializr with Maven.
• Importing the Maven project into Eclipse.
• Creating the main application class.
• Creating a simple REST controller to verify the application works as expected.
• Running the application using Eclipse.
• Creating and running tests.

By following these steps, you can easily set up and manage Spring Boot projects using Maven in Eclipse, leveraging its powerful development and debugging features.