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:

docker pull postgres

.NET Core Equivalent

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

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.

docker ps

.NET Core Equivalent

<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>

Step 3: Implement a Service Layer (Optional)

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

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

.NET Core Equivalent

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

Step 4: Build the Controller

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

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

.NET Core Equivalent

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

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

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

The above is the detailed content of Getting Started with Spring Boot or .NET Developers Part Building a Product Entity CRUD Application in Spring Boot. For more information, please follow other related articles on the PHP Chinese website!