MeroPustak - Online #1 Education Course Portal

Chapter 5: Spring - Environment Setup

Introduction

To start using the Spring Framework, the first step is to set up the development environment. This chapter will guide you through the process of setting up your machine to develop Spring-based applications. We will cover different tools and frameworks required for building Spring applications and how to integrate them into your environment.

1. Prerequisites

Before you start setting up Spring, make sure you have the following installed:

Java Development Kit (JDK): Spring is built on top of Java, so having the JDK is essential. Make sure you have at least JDK 8 installed.
- Download it from the Oracle website or use OpenJDK.
- Verify installation by running the following command in your terminal:
```
java -version
```
IDE (Integrated Development Environment): An IDE makes Java and Spring development easier. The most popular choices for Java development are:
- Eclipse: A widely-used IDE that has plugins for Spring.
- IntelliJ IDEA: A feature-rich IDE that offers support for Spring Boot and other Spring technologies.
- Spring Tool Suite (STS): A customized version of Eclipse with built-in support for Spring development.
Build Tool: A build tool helps in managing dependencies and packaging applications. The two most commonly used build tools with Spring are:
- Maven: A project management and comprehension tool.
- Gradle: A build automation tool that is becoming more popular in the Java ecosystem.
Apache Tomcat or any other Servlet Container: If you are planning to develop web applications with Spring MVC or servlets, a servlet container such as Tomcat is required for running the application.
- Download and install Tomcat from the official site.

2. Setting Up Your Development Environment

a. Setting Up Spring with Maven

Maven is the most commonly used build tool with Spring. It simplifies dependency management and builds automation.

Install Maven:
- Download Maven from the official site.
- Extract the archive and set the MAVEN_HOME environment variable. Add the Maven bin directory to the PATH.
- Verify installation by running:
```
mvn -version
```

Create a Maven Project: You can create a Spring project using Maven in two ways: manually or by using Spring Initializr (recommended).

Using Spring Initializr:
- Visit the Spring Initializr.
- Choose Maven Project, Java, and the required Spring Boot version.
- Add dependencies like Spring Web, Spring Data JPA, and others as needed.
- Click Generate to download the project.

Manually Creating a Maven Project: If you prefer to create a project manually, you will need to configure the pom.xml file to include dependencies like Spring Core, Spring Web, etc. Here’s an example pom.xml for a simple Spring project:

<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.example</groupId>
    <artifactId>spring-application</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

b. Setting Up Spring Boot with Maven

Spring Boot Setup:
- With Spring Boot, setting up a project becomes very easy.
- Using Spring Initializr (https://start.spring.io/), you can generate a ready-to-use Spring Boot application with just a few clicks.
Run a Spring Boot Application: If you’ve created a Spring Boot project, you can run it directly using Maven:
```
mvn spring-boot:run
```

c. Setting Up Spring with Gradle

If you prefer using Gradle instead of Maven, you can set up Spring with Gradle as well.

Install Gradle:
- Download Gradle from the official site.
- Extract the archive and set the GRADLE_HOME environment variable. Add the Gradle bin directory to the PATH.
- Verify installation by running:
```
gradle -v
```
Create a Spring Project with Gradle: You can create a Spring project using Gradle and Spring Initializr in a similar way as Maven.
Build and Run with Gradle: Once your Gradle project is set up, you can build and run your Spring Boot application using:
```
gradle bootRun
```

3. Folder Structure of a Spring Project

The folder structure of a Spring project depends on whether you are using Spring Boot or traditional Spring Framework.

a. Spring Boot Folder Structure

In a typical Spring Boot project, the folder structure looks like this:

src/
├── main/
│   ├── java/
│   │   └── com/
│   │       └── example/
│   │           └── springapplication/
│   │               └── SpringApplication.java
│   ├── resources/
│   │   ├── application.properties
│   │   └── static/
│   │   └── templates/
├── test/
│   └── java/
│       └── com/
│           └── example/
│               └── springapplication/
│                   └── SpringApplicationTests.java

src/main/java: Contains the main Java source code.
src/main/resources: Contains resources such as application properties and static files like HTML, CSS, or JavaScript.
src/test/java: Contains test cases.

b. Traditional Spring Framework Project

A traditional Spring project will have a similar structure, but the configuration is usually done using XML files or Java-based configuration.

src/
├── main/
│   ├── java/
│   ├── resources/
│   │   └── spring/
│   │       └── applicationContext.xml
└── test/
    └── java/

src/main/resources/spring/applicationContext.xml: The Spring configuration file where beans are defined.

4. Testing Your Spring Application

Once your environment is set up, you can test your Spring application by running it in your chosen IDE (Eclipse, IntelliJ) or using the command line with Maven/Gradle.

For Spring Boot, simply use:

mvn spring-boot:run

For a traditional Spring application, you can run it through a servlet container like Apache Tomcat or run a simple main method in your application.

Conclusion

In this chapter, we learned how to set up the environment for developing Spring applications. We discussed the installation of JDK, build tools (Maven/Gradle), and the required IDEs. We also explored the folder structure for both Spring Boot and traditional Spring applications.

In the next chapter, we will look at the Spring Hello World Example, which will help you get your first Spring application up and running.