How to Create Your First Spring Boot Project Using Spring Initializr

Here’s a step-by-step guide for creating your first Spring Boot project using Spring Initializr:

Step 1: Go to Spring Initializr

  1. Open the Spring Initializr website: https://start.spring.io/.
  2. You will see a friendly interface that allows you to configure your new Spring Boot project.

Step 2: Configure Your Project

  1. Project Settings:
    • Project Type: Choose either Maven or Gradle (Maven is common for beginners).
    • Language: Select Java, Kotlin, or Groovy. Use Java for now to keep it simple.
    • Spring Boot Version: Select the latest stable version (e.g., 3.x.x).
  2. Project Metadata:
    • Group: Enter your domain or namespace (e.g., com.example).
    • Artifact: This is the name of your project (e.g., demo).
    • Name and Description: Optional, but you can customize these values.
    • Package Name: Auto-generated from Group and Artifact but can be edited.
    • Packaging: Choose Jar.
    • Java Version: Select the Java version installed on your machine (e.g., Java 23 for compatibility).
  3. Dependencies:
    • Click Add Dependencies and search for the necessary modules, such as:
      • Spring Web for building web applications (REST APIs, etc.).
      • Spring Data JPA if you want database integration.
      • H2 Database for testing with an in-memory database.
      • Spring Boot DevTools for automatic application reload during development.

Add any additional dependencies you need for your project.

Step 3: Download the Project

  1. After configuring your project, click on the Generate button.
  2. A .zip file containing your project will be downloaded.

Step 4: Import the Project into IntelliJ IDEA

  1. Open IntelliJ IDEA.
  2. Go to File > Open and select the folder where you extracted your project.
  3. If IntelliJ suggests importing the project as a Maven/Gradle project, confirm the selection.
  4. Upon importing the project, IntelliJ will automatically resolve and download the dependencies.

Step 5: Run the Spring Boot Application

  1. Locate the main class in the project. It is usually located in src/main/java/<package-name> and has an @SpringBootApplication annotation.
  2. Right-click on the main class and select Run .
  3. Once the application starts, you will see the Spring Boot banner in the console and a log message indicating that the application started successfully.

Example Project Structure

Here’s a high-level view of what your project structure will look like:

src
├── main
|   ├── java
|   │   └── com.example.demo
|   │       └── DemoApplication.java (Main class)
|   └── resources
|       ├── application.properties (Configuration file)
|       ├── static
|       └── templates
└── test

Next Steps

  • Open the application.properties file in the src/main/resources/ directory to specify configuration data, such as database properties.
  • Start building your business logic, controller classes, and database entities.

Congratulations! 🎉 You’ve successfully created your first Spring Boot project using Spring Initializr.

How do I use @Value to inject values from properties files in Spring?

In Spring, the @Value annotation allows you to inject values from properties files or environment variables into your application. Here’s how you can use it step by step:

1. Add a properties or file to your project yaml

Create a properties file, such as application.properties or application.yml, and add your key-value configurations.

Example (application.properties):

app.name=My Application
app.version=1.0.0
app.description=A demo application using @Value

Example (application.yml):

app:
  name: My Application
  version: 1.0.0
  description: A demo application using @Value

2. Enable property loading in your Spring application

Spring Boot automatically loads application.properties or application.yml when running your application. You don’t need any additional configuration for this if you’re using Spring Boot.

For a non-Boot Spring application, ensure you configure the @PropertySource annotation. For example:

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {
}

3. Inject property values using @Value

Add the @Value annotation to a field, constructor parameter, or setter to inject property values.

Example 1: Field Injection

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class AppProperties {

    @Value("${app.name}")
    private String appName;

    @Value("${app.version}")
    private String appVersion;

    @Value("${app.description}")
    private String appDescription;

    public void printProperties() {
        System.out.println("App Name: " + appName);
        System.out.println("App Version: " + appVersion);
        System.out.println("App Description: " + appDescription);
    }
}

Example 2: Constructor Injection

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class AppProperties {

    private final String appName;
    private final String appVersion;

    public AppProperties(
        @Value("${app.name}") String appName,
        @Value("${app.version}") String appVersion
    ) {
        this.appName = appName;
        this.appVersion = appVersion;
    }

    public void printProperties() {
        System.out.println("App Name: " + appName);
        System.out.println("App Version: " + appVersion);
    }
}

Example 3: Default Values

You can provide default values in case a specified property is not present:

@Value("${app.unknown:Default Value}")
private String unknownProperty;

4. Running the application

If you run a Spring Boot application with the above configuration, the values defined in application.properties (or application.yml) will be injected into the variables annotated with @Value.

5. Notes and Best Practices

  1. Use @ConfigurationProperties for Groups of Properties: When working with many properties, consider using @ConfigurationProperties instead of @Value. It is more organized and allows you to map properties to a dedicated class.
    • Example:
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @ConfigurationProperties(prefix = "app")
    public class AppConfigProps {
       private String name;
       private String version;
       private String description;
    
       // Getters and setters
    }
    
  2. Placeholders for Environment Variables: You can use ${ENVIRONMENT_VAR} placeholders to inject environment-specific variables.

  3. Property Validation (Optional): For strict validation of the presence of properties, consider combining @Value with property validation tools like Hibernate Validator or custom logic.

Maven Dependencies

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.2.6</version>
</dependency>

Maven Central

Spring Boot vs. Spring Framework: What’s the Difference?

Spring Boot and Spring Framework are closely related but serve distinct purposes in the world of Java development. Below is a comparison that highlights the key differences between the two:

1. Core Definition

  • Spring Framework:
    • A comprehensive framework that provides tools, libraries, and features to build a wide variety of Java applications. It includes modules such as Spring Core, Spring MVC, Spring Security, and more.
  • Spring Boot:
    • A framework built on top of the Spring Framework to simplify the development of Spring-based applications. It helps developers create standalone, production-ready applications with minimal configuration.

2. Configuration

  • Spring Framework:
    • Requires extensive XML configurations or Java-based configurations to set up an application.
    • Developers need to explicitly define and configure many components (e.g., beans, data sources, etc.).
  • Spring Boot:
    • Minimizes configuration by using auto-configuration and conventions over configurations.
    • Relies heavily on annotations like @SpringBootApplication, and dependencies are simplified via starters (e.g., spring-boot-starter-web, spring-boot-starter-data-jpa).
    • Enables a “just works” approach by setting up sensible defaults for most use cases.

3. Startup

  • Spring Framework:
    • Applications often rely on external application servers like Tomcat or Jetty for deployment. Configuration for deployment can be complex.
  • Spring Boot:
    • Provides an embedded application server (Tomcat, Jetty, or Undertow) so you can run the application directly—just like running a standalone Java program (using java -jar).
    • Simplifies startup and testing with its self-contained nature.

4. Dependencies

  • Spring Framework:
    • Developers need to manually manage dependencies for different project components and modules.
  • Spring Boot:
    • Uses Spring Boot starters, which are curated dependency descriptors that include the most commonly used libraries for specific types of applications.

5. Microservices

  • Spring Framework:
    • Not specifically designed for microservices but can be adapted with custom configurations.
  • Spring Boot:
    • Designed with microservices in mind. Provides embedded servers, REST API support, and tools like Spring Cloud to facilitate development and deployment of microservices.

6. Build and Deployment

  • Spring Framework:
    • Requires build tools to configure the application and deploy it on external application servers separately.
  • Spring Boot:
    • Generates standalone executable JAR or WAR files that include everything needed to run the application.

7. Learning Curve

  • Spring Framework:
    • Has a steeper learning curve because developers need to understand its modules and configure them manually.
  • Spring Boot:
    • Easier to get started with, thanks to its auto-configuration, starters, and reduced boilerplate code.

8. Use Cases

  • Spring Framework:
    • Suitable for complex, large-scale enterprise applications where fine-grained control over configurations, and application structures is needed.
  • Spring Boot:
    • Ideal for microservices architecture, cloud-native applications, rapid development, prototyping, and small to medium-sized applications.

9. Ecosystem

  • Both Spring Boot and Spring Framework are part of the broader Spring ecosystem. Spring Boot internally leverages the Spring Framework, so it doesn’t replace it but rather enhances it and makes it easier to use.

Example:

  • Spring Framework:
    Developers must explicitly set up dependencies, configure a dispatcher servlet, configure beans, and set up XML or Java-based configuration.
  • Spring Boot:
    A single annotation (@SpringBootApplication) bootstraps the application with default settings, embedded servers, and pre-configured components.

In Summary:

Think of Spring Boot as an opinionated way to work with the Spring Framework. If you need fine-grained control and customization, you’ll likely lean toward the Spring Framework. If you prefer convenience, rapid development, and minimal configuration, Spring Boot is the better choice.

How do I manage bean scopes in Spring Framework?

In the Spring Framework, beans are defined with different scopes that govern their lifecycle and interaction with the container. The scope determines how many instances of a bean are created and how they are shared within an application.

Common Bean Scopes in Spring

Spring provides several bean scopes, and they are managed through the @Scope annotation or XML configuration. Below are the commonly used scopes:

1. Singleton (Default Scope)

  • This is the default scope in Spring.
  • Ensures there is only one shared instance of the bean per Spring container.
  • Suitable for stateless beans.
  • Example:
@Component
public class MySingletonBean {
    // Default scope is singleton
}

Or explicitly:

@Component
@Scope("singleton")
public class MySingletonBean {
}

2. Prototype

  • A new instance of the bean is created every time it is requested.
  • Useful for stateful, non-shared objects.
  • Example:
@Component
@Scope("prototype")
public class MyPrototypeBean {
}

In XML:

<bean id="myBean" class="com.example.MyBean" scope="prototype" />

3. Request

  • A new bean instance is created for every HTTP request and is specific to the lifecycle of that request.
  • Used in web applications.
  • Example:
@Component
@Scope("request")
public class MyRequestScopedBean {
}

4. Session

  • A new bean instance is created for every HTTP session and remains valid for the session lifecycle.
  • Mainly used in web applications for session-specific data.
  • Example:
@Component
@Scope("session")
public class MySessionScopedBean {
}

5. Application

  • A new bean instance is shared across the entire ServletContext (application-wide).
  • Example:
@Component
@Scope("application")
public class MyApplicationScopedBean {
}

6. WebSocket

  • A new instance is created for the lifecycle of a WebSocket session.
  • Example:
@Component
@Scope("websocket")
public class MyWebSocketScopedBean {
}

Setting Bean Scope

  1. Using Annotations:
    • Leverage the @Scope annotation along with Spring’s @Component, @Service, @Controller, or @RestController.
    • Example:
    @Service
    @Scope("prototype")
    public class PrototypeService {
    }
    
  2. Using XML Configuration:
    • Define the scope inside the XML bean configuration.
    • Example:
    <bean id="myBean" class="com.example.MyService" scope="prototype" />
    
  3. Programmatically:
    • Define the bean and its scope programmatically using Java-based configuration.
    • Example:
    @Configuration
    public class AppConfig {
      @Bean
      @Scope("prototype")
      public MyService myService() {
          return new MyService();
      }
    }
    

Custom Scopes

You can define custom scopes in Spring by implementing the Scope interface. This is typically used in special cases like tenant-based architectures.

How the Container Manages Scopes

In singleton scope, the container ensures that only one instance of the bean exists at a time. In prototype and other scopes, however, the container provides a fresh instance depending on the request but does not manage the full lifecycle, such as destroying the bean (in the case of prototype beans).
If you use scopes such as request, session, or websocket, Spring’s WebApplicationContext is responsible for managing the beans’ lifecycle.

Key Points:

  • Singleton Scope is the default scope in Spring.
  • For web applications, consider request, session, or application scopes for beans tied to web-specific functionalities.
  • For stateful beans, do not use Singleton scope unless thread safety is accounted for.
  • Custom Scope definitions can extend the functionality of bean management.

What Is Spring Boot? A Beginner’s Introduction to Rapid Java Development

Spring Boot is a framework designed to simplify and speed up the development of Java-based applications, especially for web and microservices. It’s built on top of the Spring Framework but offers additional features to reduce the complexity of configuration, making it ideal for developers who want to quickly get started with production-ready applications. Below is an introduction to Spring Boot for beginners:


Key Features of Spring Boot

  1. Auto-Configuration:
    • Spring Boot automatically configures your application based on the libraries and dependencies it detects on the classpath. For example, if you include a library for an in-memory database like H2, Spring Boot configures a data source for you automatically.
  2. Embedded Servers:
    • Spring Boot comes with embedded HTTP servers (like Tomcat, Jetty, or Undertow) so you can run your web applications without deploying them to an external server.
  3. Starter Dependencies:
    • To simplify dependency management, Spring Boot provides “starter” dependencies—a curated set of libraries for specific functionalities. For example, spring-boot-starter-web is used for building web applications.
  4. Production-Ready Features:
    • Out of the box, it includes several production-ready features like health checks, metrics, and application monitoring via the Spring Boot Actuator module.
  5. Convention over Configuration:
    • Spring Boot adheres to the “convention over configuration” philosophy, which minimizes the need for manual setup. It works with sensible defaults but allows for customization where required.
  6. Developer Tools:
    • Spring Boot DevTools enhances the development experience by enabling features like hot reloading, which speeds up development cycles.

Why Use Spring Boot?

  • Rapid Development:
    Its default configurations allow developers to create standalone applications quickly without needing to write boilerplate code.
  • Microservices-Friendly:
    Spring Boot is highly suitable for building microservices architectures, thanks to its lightweight setup and embedded server capabilities.
  • Seamless Integration:
    It integrates easily with other Spring projects (e.g., Spring Data, Spring Security, etc.) and third-party libraries.
  • Great Ecosystem:
    The expansive Spring ecosystem includes numerous supported tools and plugins.
  • Minimized XML Configuration:
    You no longer need to deal with verbose XML configurations that were common in traditional Spring Framework setups, as most configurations can now be done using annotations or property files.

How Spring Boot Works

When creating a Spring Boot application:

  1. Start with a Starter Project:
    Use Spring Initializr, a web-based tool, to generate a base project with the desired dependencies.
  2. Dependency Injection:
    Utilize Spring’s core dependency injection (IoC Container) to wire together application components.
  3. Annotations:
    Spring Boot provides a set of annotations like @SpringBootApplication, @RestController, and @Bean to simplify development.
  4. Application Properties:
    The application.properties (or application.yml) file is used to customize configurations.
  5. Single Entry Point:
    Applications built with Spring Boot typically have a main class annotated with @SpringBootApplication, which acts as an entry point for the application.

Hello World Example with Spring Boot

Here’s an example of a basic Spring Boot application:

// Main application class
package org.kodejava.spring;

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);
    }
}
// Example REST Controller
package org.kodejava.spring;

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

@RestController
public class HelloWorldController {
    @GetMapping("/")
    public String helloWorld() {
        return "Hello, World!";
    }
}

To run this application:

  1. Run the DemoApplication class.
  2. Open a browser and navigate to `http://localhost:8080` to see “Hello, World!”

When to Use Spring Boot

  • You want to rapidly build standalone web or microservices.
  • You prefer convention over configuration.
  • You need ready-to-use tools for monitoring, metrics, and controlling your applications.
  • You want the simplicity of an embedded web server for quick deployment.

Conclusion

Spring Boot is a powerful framework that makes Java development faster, simpler, and more streamlined. Its rich ecosystem, ease of use, and production-ready features make it a great choice for developers at all levels, from beginners to experienced professionals.


Maven Dependencies

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>3.4.4</version>
    </dependency>
</dependencies>