Getting Started with Spring Boot 3 for .NET Developers Part 2: Building a Product Entity CRUD Application in Spring Boot

After exploring the basics of Spring Boot 3 in the previous post, let’s dive deeper by implementing a Product entity CRUD (Create, Read, Update, Delete) operation. Along the way, we’ll compare core Spring Boot concepts with their .NET Core counterparts to help bridge the gap for .NET developers transitioning to the Java ecosystem.

Setting Up the Project

Before starting, ensure you have a Spring Boot project ready with the following dependencies:

• Spring Web: For building REST APIs.
• Spring Data JPA: For database interactions.
• PostgreSQL Driver: For connecting to a PostgreSQL database.

Run PostgreSQL Locally Using Docker

To run PostgreSQL locally, use Docker to quickly set up an instance:

1. Pull the PostgreSQL image:
   

   docker pull postgres
   

2. Run a PostgreSQL container:
   

   docker run --name postgres-db -e POSTGRES_PASSWORD=yourpassword -e POSTGRES_USER=yourusername -e POSTGRES_DB=mydatabase -p 5432:5432 -d postgres
   

   Replace yourusername, yourpassword, and mydatabase with your desired username, password, and database name.

3. Verify the database is running:
   

   docker ps
   

4. Use a database client (e.g., DBeaver, pgAdmin, or psql) to connect to localhost:5432 and verify your database is accessible.

Update the pom.xml File

If you are using Maven, include the following dependencies in your pom.xml file to ensure all necessary libraries are available:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.5.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Also, ensure the following plugin is included for building the project:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Comparison with .NET Core:
In .NET Core, package references are managed using the csproj file. Equivalent dependencies for a PostgreSQL-backed web API might look like this:

<ItemGroup>
  <PackageReference Include="Microsoft.AspNetCore.App" />
  <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.0" />
</ItemGroup>

Configure PostgreSQL Database

Update your application.yml file to connect to a PostgreSQL database:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydatabase
    username: yourusername
    password: yourpassword
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: update

Replace mydatabase, yourusername, and yourpassword with your actual PostgreSQL database details. The ddl-auto=update setting ensures that Hibernate creates or updates tables automatically based on your entity definitions.

Comparison with .NET Core:
In .NET Core, similar configurations would reside in appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=mydatabase;Username=yourusername;Password=yourpassword"
  },
  "EntityFramework": {
    "MigrationsAssembly": "YourProjectName"
  }
}

Project Structure Overview

Spring Boot projects organize code into packages:

• entity: Contains data models.
• repository: Interfaces for database operations.
• controller: REST endpoints.
• service (optional): Business logic.

This structure is similar to the typical layers in a .NET Core project: Models, Data/Repositories, Controllers, and Services.

Step 1: Define the Product Entity

In Spring Boot, entities represent database tables, similar to models in Entity Framework Core. Use annotations like @Entity and @Id to map the class to a table:

package com.example.demo.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String description;
    private Double price;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

.NET Core Equivalent

public class Product
{
    public long Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public double Price { get; set; }
}

Step 2: Create a Repository

In Spring Boot, repositories are interfaces extending JpaRepository. They provide built-in CRUD operations, akin to DbContext in EF Core.

package com.example.demo.repository;

import com.example.demo.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

.NET Core Equivalent

public class ProductRepository
{
    private readonly DbContext _context;

    public ProductRepository(DbContext context)
    {
        _context = context;
    }

    public async Task<List<Product>> GetAllAsync() => await _context.Products.ToListAsync();

    // Other CRUD methods
}

Step 3: Implement a Service Layer (Optional)

The service layer handles business logic. While optional, it’s a good practice for larger applications.

package com.example.demo.service;

import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Optional<Product> getProductById(Long id) {
        return productRepository.findById(id);
    }

    public Product saveProduct(Product product) {
        return productRepository.save(product);
    }

    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
}

.NET Core Equivalent

public class ProductService
{
    private readonly ProductRepository _repository;

    public ProductService(ProductRepository repository)
    {
        _repository = repository;
    }

    public async Task<List<Product>> GetAllProductsAsync() => await _repository.GetAllAsync();

    // Other methods
}

Step 4: Build the Controller

Controllers handle HTTP requests, just like in ASP.NET Core.

package com.example.demo.controller;

import com.example.demo.entity.Product;
import com.example.demo.service.ProductService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Optional<Product> product = productService.getProductById(id);
        return product.map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.saveProduct(product);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
        return ResponseEntity.noContent().build();
    }
}

.NET Core Equivalent

[ApiController]
[Route("api/products")]
public class ProductController : ControllerBase
{
    private readonly ProductService _service;

    public ProductController(ProductService service)
    {
        _service = service;
    }

    [HttpGet]
    public async Task<IActionResult> GetAllProducts() => Ok(await _service.GetAllProductsAsync());

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProductById(long id)
    {
        var product = await _service.GetProductByIdAsync(id);
        return product == null ? NotFound() : Ok(product);
    }

    [HttpPost]
    public async Task<IActionResult> CreateProduct([FromBody] Product product)
    {
        var createdProduct = await _service.SaveProductAsync(product);
        return CreatedAtAction(nameof(GetProductById), new { id = createdProduct.Id }, createdProduct);
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteProduct(long id)
    {
        await _service.DeleteProductAsync(id);
        return NoContent();
    }
}

Step 5: Testing Your API

Run your application and test the endpoints using tools like Postman or cURL. Ensure your PostgreSQL database is running and properly configured.

Once the application is up and running, test the CRUD endpoints with Postman or cURL. Ensure PostgreSQL is running and correctly configured.

Testing Endpoints with Postman:

• GET /api/products: Fetch all products.
• GET /api/products/{id}: Fetch a single product by ID.
• POST /api/products: Create a new product.
• DELETE /api/products/{id}: Delete a product by ID.

Key Comparisons

Feature	Spring Boot 3	.NET Core
Dependency Injection	Built-in with @Autowired or constructor injection	Built-in with AddScoped, AddSingleton
ORM Tool	Spring Data JPA	Entity Framework Core
Routing	@RequestMapping, @GetMapping	[Route], [HttpGet]
Middleware	Spring Interceptors	ASP.NET Middleware
Response Handling	ResponseEntity	IActionResult

Conclusion

Creating a CRUD application in Spring Boot is simple, especially for those familiar with .NET Core. The principles of dependency injection, ORM, and RESTful APIs are similar in both ecosystems. This guide is just the start—future posts will cover Lombok integration, Swagger/OpenAPI, validation, error handling, and database migrations. Stay tuned!

Happy coding!

---

References

1. Spring Boot Documentation: https://spring.io/projects/spring-boot
2. PostgreSQL Documentation: https://www.postgresql.org/docs/
3. Spring Data JPA Documentation: https://spring.io/projects/spring-data-jpa
4. .NET Core Documentation: https://docs.microsoft.com/en-us/aspnet/core/?view=aspnetcore-7.0