How to Build a Java Full Stack CRUD App with AI Using Spring Boot and React

Step 3: generate the DTOs and mapper

Request and response DTOs are where most developers spend more time than they should. AI eliminates that.

Using the Product entity, generate:

1. ProductRequestDTO (create and update):

   - All fields except id, createdAt, updatedAt
   - Validation annotations matching entity constraints

2. ProductResponseDTO (Java record syntax, Java 17):

   - All fields including id, createdAt, updatedAt
   - Price formatted as String with 2 decimal places

3. ProductMapper (@Component, manual mapping — no MapStruct):

   - toEntity(ProductRequestDTO dto)
   - toResponseDTO(Product entity)
   - toResponseDTOList(List<Product> entities)

Using Java records for response DTOs is a modern practice that signals professional code quality — one the AI will not default to unless specifically instructed.

Step 4: generate the service layer with proper exception handling

The service layer is where business logic lives and where most of the meaningful architectural decisions in a CRUD application reside.

Create ProductService using constructor injection (not @Autowired field injection).

Custom exception: ResourceNotFoundException extends RuntimeException

with constructor(String resourceName, String fieldName, Object fieldValue)

Methods:

- createProduct(ProductRequestDTO) → ProductResponseDTO
  (check existsByName, throw IllegalStateException if duplicate)
- getProductById(Long id) → ProductResponseDTO
  (throw ResourceNotFoundException if absent)
- getAllProducts(int page, int size, String sortBy, String sortDir) → Page<ProductResponseDTO>
- getProductsByCategory(String category) → List<ProductResponseDTO>
- updateProduct(Long id, ProductRequestDTO) → ProductResponseDTO
  (fetch existing entity, update fields, save — do not create a new entity instance)
- deleteProduct(Long id) → void

Apply @Transactional appropriately. Read-only methods: @Transactional(readOnly = true).

“Do not create a new entity instance” is the kind of constraint that prevents a consequential JPA mistake — creating a detached entity instead of updating the managed one — that AI without instruction would happily reproduce.

Step 5: generate the controller with global exception handling

Create ProductController and GlobalExceptionHandler.

Controller (base: /api/v1/products):

- ResponseEntity<ApiResponse<T>> for all responses
- OpenAPI annotations (@Tag, @Operation, @ApiResponse) on every endpoint
- POST /, GET /{id}, GET / (page, size, sortBy, sortDirection),
  GET /category/{category}, PUT /{id}, DELETE /{id}

GlobalExceptionHandler (@RestControllerAdvice):

- ResourceNotFoundException → 404
- IllegalStateException → 409
- MethodArgumentNotValidException → 400 with map of field → error message
- Exception → 500 with generic message

All use the same ApiResponse<T> structure.

Specifying OpenAPI annotations produces a controller that is API-documented from the moment it is generated — a signal of professional maturity that most entry-level candidates never demonstrate.

Step 6: generate the frontend API layer and components

With the backend complete, switch context to the React frontend.

I have a Spring Boot REST API at http://localhost:8080/api/v1/products.

The API returns responses wrapped in:

{ success: boolean, message: string, data: T, timestamp: string }

For paginated responses, data is:

{ content: Product[], totalElements: number, totalPages: number, number: number }

Create:

1. A productService.js file using Axios with:

   - Base URL configuration from environment variable
   - Functions: createProduct, getProductById, getAllProducts (with pagination params),
     getProductsByCategory, updateProduct, deleteProduct
   - Interceptor that attaches Authorization header from localStorage JWT token
   - Consistent error extraction from the response wrapper

2. A useProducts custom hook that:

   - Manages products state, loading, and error
   - Exposes all CRUD operations
   - Handles pagination state
   - Uses the productService functions internally

Generating the service and hook together ensures the hook’s interface matches what the service provides — the same coherence principle applied to the frontend.