Spring Boot REST API with H2, Spring Data JPA, and Complete CRUD Operations

[akash-coded]

Spring Boot REST API with H2, Spring Data JPA, and Complete CRUD Operations

🔧 Overview

This application demonstrates a complete CRUD Spring Boot REST API with:

• Full Spring Data JPA integration
• H2 in-memory database with data.sql for seeding
• Entity validation, error handling, and DTO layering
• Clean Controller → Service → Repository architecture
• Reusable and beautiful code organization
• Swagger/OpenAPI config (optional for visual API testing)

---

📁 Project Structure

src/
└── main/
    ├── java/com/example/crudbeauty/
    │   ├── controller/
    │   │   └── ProductController.java
    │   ├── dto/
    │   │   └── ProductDTO.java
    │   ├── exception/
    │   │   ├── GlobalExceptionHandler.java
    │   │   └── ResourceNotFoundException.java
    │   ├── model/
    │   │   └── Product.java
    │   ├── repository/
    │   │   └── ProductRepository.java
    │   ├── service/
    │   │   ├── ProductService.java
    │   │   └── impl/ProductServiceImpl.java
    │   └── CrudBeautyApplication.java
    └── resources/
        ├── application.properties
        ├── data.sql
        └── schema.sql (optional)

---

📦 Dependencies (pom.xml)

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
</dependencies>

---

⚙ application.properties

spring.datasource.url=jdbc:h2:mem:crudbeautydb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.format_sql=true

---

🌟 Entity (Product.java)

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank
    @Size(max = 100)
    private String name;

    @Min(1)
    private double price;

    @NotBlank
    private String category;
    
    // Getters and setters
}

---

🎯 DTO (ProductDTO.java)

public class ProductDTO {
    private Long id;
    private String name;
    private double price;
    private String category;
    
    // Getters, setters, constructors
}

---

📚 Repository

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByCategoryIgnoreCase(String category);
}

---

🧠 Service Layer

Interface

public interface ProductService {
    ProductDTO create(ProductDTO dto);
    List<ProductDTO> findAll();
    ProductDTO findById(Long id);
    List<ProductDTO> findByCategory(String category);
    ProductDTO update(Long id, ProductDTO dto);
    void delete(Long id);
}

Implementation

@Service
public class ProductServiceImpl implements ProductService {
    @Autowired private ProductRepository repo;
    
    private ProductDTO toDTO(Product p) { ... }
    private Product toEntity(ProductDTO d) { ... }

    public ProductDTO create(ProductDTO dto) { return toDTO(repo.save(toEntity(dto))); }

    public List<ProductDTO> findAll() {
        return repo.findAll().stream().map(this::toDTO).collect(Collectors.toList());
    }

    public ProductDTO findById(Long id) {
        return toDTO(repo.findById(id).orElseThrow(() -> new ResourceNotFoundException("Product not found")));
    }

    public List<ProductDTO> findByCategory(String category) {
        return repo.findByCategoryIgnoreCase(category).stream().map(this::toDTO).collect(Collectors.toList());
    }

    public ProductDTO update(Long id, ProductDTO dto) {
        Product existing = repo.findById(id).orElseThrow(() -> new ResourceNotFoundException("Product not found"));
        existing.setName(dto.getName());
        existing.setPrice(dto.getPrice());
        existing.setCategory(dto.getCategory());
        return toDTO(repo.save(existing));
    }

    public void delete(Long id) {
        repo.deleteById(id);
    }
}

---

🎛 Controller

@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired private ProductService service;

    @PostMapping
    public ResponseEntity<ProductDTO> create(@Valid @RequestBody ProductDTO dto) {
        return ResponseEntity.status(HttpStatus.CREATED).body(service.create(dto));
    }

    @GetMapping
    public List<ProductDTO> getAll() { return service.findAll(); }

    @GetMapping("/{id}")
    public ProductDTO getById(@PathVariable Long id) { return service.findById(id); }

    @GetMapping("/category")
    public List<ProductDTO> getByCategory(@RequestParam String category) {
        return service.findByCategory(category);
    }

    @PutMapping("/{id}")
    public ProductDTO update(@PathVariable Long id, @RequestBody @Valid ProductDTO dto) {
        return service.update(id, dto);
    }

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

---

🛑 Exception Handling

@ResponseStatus(HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) { super(message); }
}

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<?> handleValidation(MethodArgumentNotValidException ex) { ... }

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<?> handleNotFound(ResourceNotFoundException ex) { ... }
}

---

💾 Data Seeding (data.sql)

INSERT INTO PRODUCT (id, name, price, category) VALUES
(1, 'Monitor', 150.0, 'Electronics'),
(2, 'Notebook', 5.0, 'Stationery'),
(3, 'Shoes', 60.0, 'Apparel');

---

🚀 Run the App

• mvn spring-boot:run
• H2 Console: http://localhost:8080/h2-console
• Test endpoints via Postman or Swagger (add springdoc-openapi dependency)

[akash-coded]

Enterprise-Product-API.postman_collection.json

[akash-coded]

Here's a step-by-step guide to integrate SpringDoc Swagger UI into your existing Spring Boot application and generate OpenAPI docs automatically from annotations:

---

✅ Step 1: Add SpringDoc Dependency

In your pom.xml, add this dependency:

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.2.0</version>
</dependency>

---

✅ Step 2: Verify Spring Boot Compatibility

Ensure your project uses Spring Boot 3.x (for SpringDoc 2.x) or Spring Boot 2.x (for SpringDoc 1.x).

For Spring Boot 3.x, springdoc-openapi-starter-webmvc-ui is required (as above).
For Spring Boot 2.x, use springdoc-openapi-ui.

---

✅ Step 3: Add Basic Config (Optional)

Create a configuration class if you want to customize metadata.

package com.example.config;

import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import org.springdoc.core.models.GroupedOpenApi;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SwaggerConfig {

    @Bean
    public OpenAPI enterpriseOpenAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("Enterprise Product API")
                        .description("API documentation for Product Management")
                        .version("1.0.0"));
    }

    @Bean
    public GroupedOpenApi productApi() {
        return GroupedOpenApi.builder()
                .group("products")
                .pathsToMatch("/api/products/**")
                .build();
    }
}

---

✅ Step 4: Annotate Your Controller and Model

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;

@RestController
@RequestMapping("/api/products")
@Tag(name = "Product APIs", description = "CRUD operations for Products")
public class ProductController {

    @GetMapping
    @Operation(summary = "Get all products")
    public List<Product> getAllProducts() {
        ...
    }

    @PostMapping
    @Operation(summary = "Add a new product")
    public Product addProduct(@RequestBody Product p) {
        ...
    }

    // More endpoints...
}

Also add @Schema annotations on your model class if desired:

import io.swagger.v3.oas.annotations.media.Schema;

@Schema(description = "Product Entity")
public class Product {

    @Schema(description = "Unique ID", example = "101")
    private Long id;

    @Schema(description = "Product name", example = "Laptop")
    private String name;

    ...
}

---

✅ Step 5: Add Actuator (Optional, but useful)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

---

✅ Step 6: Run Your Application

• Port: 8080 (or 8081 if you've changed it)

• Visit Swagger UI:

  http://localhost:8081/swagger-ui.html
  

• Visit OpenAPI JSON:

  http://localhost:8081/v3/api-docs
  

• Visit YAML version (optional):

  http://localhost:8081/v3/api-docs.yaml
  

---

✅ Pro Tips

• You can version your APIs using GroupedOpenApi and base paths.
• Use @Parameter, @ApiResponse, and @RequestBody annotations for richer documentation.
• You can also export Postman collection from Swagger UI via [SwaggerHub](https://swagger.io/tools/swaggerhub/), or use openapi-generator.

---

swagger-config.json

[akash-coded]

Here’s a fully annotated sample controller for your Spring Boot + SpringDoc Swagger setup, crafted to demonstrate enterprise-grade API design and documentation.

---

📁 File: ProductController.java

package com.example.productapi.controller;

import com.example.productapi.model.Product;
import com.example.productapi.service.ProductService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.tags.Tag;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/products")
@Tag(name = "Product APIs", description = "Enterprise-grade Product CRUD operations")
public class ProductController {

    @Autowired
    private ProductService productService;

    @Operation(summary = "Get all products", responses = {
            @ApiResponse(responseCode = "200", description = "List of all products",
                    content = @Content(mediaType = "application/json",
                            schema = @Schema(implementation = Product.class)))
    })
    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @Operation(summary = "Get product by ID", responses = {
            @ApiResponse(responseCode = "200", description = "Product found",
                    content = @Content(mediaType = "application/json",
                            schema = @Schema(implementation = Product.class))),
            @ApiResponse(responseCode = "404", description = "Product not found",
                    content = @Content)
    })
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(
            @Parameter(description = "ID of the product to be fetched") @PathVariable Long id) {
        return productService.getProductById(id)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    @Operation(summary = "Add a new product", responses = {
            @ApiResponse(responseCode = "201", description = "Product created successfully")
    })
    @PostMapping
    public ResponseEntity<Product> addProduct(
            @Parameter(description = "Product object to be added", required = true)
            @RequestBody Product product) {
        return ResponseEntity.status(201).body(productService.addProduct(product));
    }

    @Operation(summary = "Update a product", responses = {
            @ApiResponse(responseCode = "200", description = "Product updated successfully"),
            @ApiResponse(responseCode = "404", description = "Product not found")
    })
    @PutMapping("/{id}")
    public ResponseEntity<Product> updateProduct(
            @PathVariable Long id,
            @RequestBody Product product) {
        return productService.updateProduct(id, product)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    @Operation(summary = "Delete a product", responses = {
            @ApiResponse(responseCode = "204", description = "Product deleted"),
            @ApiResponse(responseCode = "404", description = "Product not found")
    })
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
        return productService.deleteProduct(id)
                ? ResponseEntity.noContent().build()
                : ResponseEntity.notFound().build();
    }
}

---

📁 File: Product.java

package com.example.productapi.model;

import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.persistence.*;

@Entity
@Schema(description = "Product entity representing items in the catalog")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Schema(description = "Unique ID of the product", example = "1")
    private Long id;

    @Schema(description = "Name of the product", example = "Wireless Mouse")
    private String name;

    @Schema(description = "Category of the product", example = "Electronics")
    private String category;

    @Schema(description = "Price of the product", example = "49.99")
    private double price;

    // Getters and setters omitted for brevity
}

---

🧠 Tips for Students

• Run the application → open http://localhost:8081/swagger-ui.html to interact visually.
• Use the Try it out button to test endpoints.
• Explore error responses, required fields, and parameter annotations.
• Extend models with validation (e.g., @NotBlank, @Min, etc.) to auto-document request constraints.

[akash-coded]

Here's a clean and production-inspired setup to integrate:

---

🧾 1. application.properties — H2 + Logging Config

# H2 DB config
spring.datasource.url=jdbc:h2:mem:productdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# Hibernate
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=none  # We'll use schema.sql

# Enable H2 console
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

# Logging SQL queries
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

# Custom port
server.port=8081

Open H2 console at:
http://localhost:8081/h2-console
Use DB URL: jdbc:h2:mem:productdb

---

🧬 2. schema.sql — Define Table Schema

CREATE TABLE product (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    category VARCHAR(100),
    price DOUBLE
);

---

🌱 3. data.sql — Seed Sample Data

INSERT INTO product (name, category, price) VALUES ('Laptop', 'Electronics', 800.0);
INSERT INTO product (name, category, price) VALUES ('Book', 'Books', 40.0);
INSERT INTO product (name, category, price) VALUES ('Shoes', 'Apparel', 120.0);

These files must be placed in src/main/resources.

---

🧪 4. Sample Unit Test — ProductServiceImplTest

package com.example.productapi.service.impl;

import com.example.productapi.model.Product;
import com.example.productapi.repository.ProductRepository;
import com.example.productapi.service.ProductService;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

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

class ProductServiceImplTest {

    @Mock
    private ProductRepository repository = mock(ProductRepository.class);

    @InjectMocks
    private ProductService service = new ProductServiceImpl(repository);

    @Test
    void testGetAllProducts() {
        List<Product> products = Arrays.asList(
                new Product(1L, "Laptop", 800.0, "Electronics"),
                new Product(2L, "Book", 40.0, "Books")
        );
        when(repository.findAll()).thenReturn(products);

        List<Product> result = service.getAllProducts();

        assertEquals(2, result.size());
        verify(repository, times(1)).findAll();
    }

    @Test
    void testAddProduct() {
        Product product = new Product(null, "Mouse", 25.0, "Electronics");
        Product saved = new Product(10L, "Mouse", 25.0, "Electronics");
        when(repository.save(product)).thenReturn(saved);

        Product result = service.addProduct(product);

        assertEquals(saved.getId(), result.getId());
    }
}

[akash-coded]

Here’s how to evolve your Spring Boot REST API into a more enterprise-grade and layered architecture by integrating:

---

🔌 1. DTOs + ModelMapper Integration

Why?

• Clean API contracts
• Hide internal model structure
• Prevent over-posting and sensitive field exposure

✅ Steps:

1. Add Maven Dependency

<dependency>
  <groupId>org.modelmapper</groupId>
  <artifactId>modelmapper</artifactId>
  <version>3.1.1</version>
</dependency>

2. Create DTO Class

public class ProductDTO {
    private Long id;
    private String name;
    private String category;
    private double price;
}

3. Configure ModelMapper Bean

@Configuration
public class MapperConfig {
    @Bean
    public ModelMapper modelMapper() {
        return new ModelMapper();
    }
}

4. Use in Service or Controller

@Autowired
private ModelMapper modelMapper;

public ProductDTO convertToDto(Product product) {
    return modelMapper.map(product, ProductDTO.class);
}

public Product convertToEntity(ProductDTO dto) {
    return modelMapper.map(dto, Product.class);
}

---

⚠️ 2. Custom Exceptions & Global Exception Handling

🔥 Example: ProductNotFoundException

public class ProductNotFoundException extends RuntimeException {
    public ProductNotFoundException(String message) {
        super(message);
    }
}

📍 Global Exception Handler

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<String> handleNotFound(ProductNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, String>> handleValidation(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(err ->
            errors.put(err.getField(), err.getDefaultMessage()));
        return ResponseEntity.badRequest().body(errors);
    }
}

---

⚡ 3. Enable Caching via @Cacheable

🧱 Add Spring Cache Dependency

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

🔧 Enable Caching in Main App Class

@SpringBootApplication
@EnableCaching
public class ProductApiApplication { ... }

🏷️ Use @Cacheable in Service

@Cacheable("products")
public List<ProductDTO> getAllProducts() {
    simulateDelay(); // Imagine this hits DB
    return repository.findAll().stream()
        .map(p -> modelMapper.map(p, ProductDTO.class))
        .collect(Collectors.toList());
}

---

📄 4. Sorting & Pagination

Add to ProductRepository

public interface ProductRepository extends JpaRepository<Product, Long> {
    Page<Product> findByCategory(String category, Pageable pageable);
}

Modify Controller

@GetMapping("/products")
public Page<ProductDTO> getPagedProducts(
    @RequestParam(defaultValue = "0") int page,
    @RequestParam(defaultValue = "5") int size,
    @RequestParam(defaultValue = "id") String sortBy) {

    Pageable pageable = PageRequest.of(page, size, Sort.by(sortBy));
    return repository.findAll(pageable).map(p -> modelMapper.map(p, ProductDTO.class));
}

---

🧠 Final Folder Structure

src/main/java/com/example/productapi
├── controller
│   └── ProductController.java
├── dto
│   └── ProductDTO.java
├── exception
│   └── ProductNotFoundException.java
│   └── GlobalExceptionHandler.java
├── model
│   └── Product.java
├── repository
│   └── ProductRepository.java
├── service
│   ├── ProductService.java
│   └── impl
│       └── ProductServiceImpl.java
├── config
│   └── MapperConfig.java
└── ProductApiApplication.java

[akash-coded]

Here is the downloadable ZIP file containing a structured Spring Boot project with the following enterprise-ready setup:

✅ Folder structure for controller, dto, exception, model, repository, service, config
✅ application.properties for H2 + logging
✅ schema.sql and data.sql for DB seeding
✅ Ready for enhancements like DTOs, custom exceptions, caching, pagination

📦 product-api-enterprise.zip

[akash-coded]

This is the final version of the project. This is an enhanced Spring Boot enterprise project ready with:

• ✅ DTOs using ProductDTO
• ✅ ModelMapper integration via config
• ✅ Custom Exception (ProductNotFoundException)
• ✅ Global Exception Handler
• ✅ Caching enabled using @Cacheable
• ✅ Folder structure aligned to enterprise practices

✅ Now adding Swagger/OpenAPI annotations to the controllers and services.

We have:

1. Created a fully annotated ProductController.java from scratch.
2. Added Swagger annotations and REST methods.
3. Placed it in the correct folder structure inside your enhanced project.

We’ll repackage the entire enhanced application with Swagger support so you can download and run it.

🚀 Your Swagger-enabled, enterprise-grade Spring Boot REST API is ready for download:

👉 Download the project - product-api-enterprise-swagger.zip

To use Swagger UI:

1. Run the Spring Boot application.

2. Open your browser and go to:

   http://localhost:8080/swagger-ui.html
   

   or

   http://localhost:8080/swagger-ui/index.html
   

[Sdey0907]

### Task - Spring Boot REST API_Crudbeauty_Sayan Dey_Completed

Product_crudbeauty_RESTAPI_SpringBoot.zip

[prasetha21-max]

PRASETHA N
crudbeauty.zip