Spring Boot Pre-Interview Guide: Comprehensive Assignment

Series Navigation

Full Roadmap: See Spring Boot Pre-Interview Guide Roadmap

This assignment is a hands-on exercise that comprehensively applies everything covered in Parts 1 through 7.

Assignment Overview

Implement the backend API for an online marketplace. Sellers can register products, and buyers can search for products and place orders.

Submission Deadline

• Deadline: 7 days from the date the assignment is received

Tech Stack

• Required: Java 17+ or Kotlin, Spring Boot 3.x, JPA/Hibernate, Gradle
• Database: H2 (local), MySQL 8.0 (Docker)
• Optional: QueryDSL, Redis

Business Requirements

1. Member Management

• Member types: BUYER, SELLER, ADMIN
• Email duplication check during registration
• JWT token issuance upon login (Access Token + Refresh Token)
• Business registration number is required for sellers

2. Product Management (Seller Only)

• Product create/update/delete (own products only)
• Product image upload (up to 5 images, max 10MB each)
• Product status: DRAFT, ON_SALE, SOLD_OUT, DELETED
• Inventory management

3. Product Search (Public)

• Product list retrieval (pagination, search, filtering)
• Product detail retrieval
• Category-based retrieval
• Popular products list (with caching)

4. Order Management

• Buyer: Create order, cancel order, view order history
• Seller: View orders for own products, update shipping status
• Order status: PENDING -> CONFIRMED -> SHIPPED -> DELIVERED
• Order cancellation is only allowed in PENDING or CONFIRMED status

5. Notifications

• Notify seller when an order is created (asynchronous)
• Notify buyer when shipping status changes (asynchronous)
• Notifications can be replaced with logs (actual delivery implementation not required)

API Specification

Authentication API

Member API

Product API

Order API

Category API

Detailed Requirements

1. Authentication/Authorization

[Requirements]
- JWT-based authentication (Access Token: 1 hour, Refresh Token: 7 days)
- Passwords encrypted with BCrypt
- Role-based access control (BUYER, SELLER, ADMIN)
- Resource owner verification (can only modify own products/orders)

2. Product Search/Filtering

GET /api/v1/products?keyword=laptop&categoryId=1&minPrice=100000&maxPrice=2000000&status=ON_SALE&page=0&size=20&sort=createdAt,desc

3. Order Creation

// POST /api/v1/orders
{
  "orderItems": [
    {
      "productId": 1,
      "quantity": 2
    },
    {
      "productId": 3,
      "quantity": 1
    }
  ],
  "shippingAddress": {
    "zipCode": "12345",
    "address": "123 Teheran-ro, Gangnam-gu, Seoul",
    "addressDetail": "Unit 456",
    "receiverName": "John Doe",
    "receiverPhone": "010-1234-5678"
  }
}

[Order Processing Rules]
- Check and deduct inventory (consider concurrency)
- Allow simultaneous ordering of products from multiple sellers (separate orders per seller)
- Publish notification event to seller upon order creation
- Fail the order if inventory is insufficient

4. File Upload

[Requirements]
- Supported extensions: jpg, jpeg, png, gif
- Max file size: 10MB
- Max 5 images per product
- Storage path: /uploads/products/{productId}/{filename}
- Filenames are converted to UUID before saving

5. Caching

[Caching Targets]
- Popular products list: 10-minute TTL
- Category list: 1-hour TTL
- Product detail (optional): 5-minute TTL, invalidated on update

6. Logging

[Requirements]
- Assign a unique Request ID to every request (MDC)
- API request/response logging (AOP)
- Log format: [timestamp] [level] [requestId] [class] message

Technical Requirements

Project Structure Options

Choose one of the following two structures for implementation.

Option A: Single Module (Recommended)

marketplace/
└── src/main/java/com/example/
    ├── controller/
    ├── service/
    ├── repository/
    ├── domain/
    ├── dto/
    └── config/

Option B: Multi-Module (Challenge)

Two structure choices available:

B-1. Standard (with DIP)

marketplace/
├── marketplace-api/           # Controller, Security, Execution
├── marketplace-domain/        # Entity, Service, Repository interfaces
├── marketplace-infra/         # Repository implementations, External integrations
└── marketplace-common/        # Common exceptions, Utilities

B-2. Simplified (Pragmatic)

marketplace/
├── marketplace-api/           # Controller, Service, Security, Execution
├── marketplace-domain/        # Entities only
├── marketplace-infra/         # JpaRepository, QueryDSL
└── marketplace-common/        # Common exceptions, Utilities

Requirements when choosing multi-module:

• Consistently apply the chosen structure (B-1 or B-2)
• If B-1: No domain -> infra dependency, separate Repository interface/implementation
• If B-2: Services are located in the api module, use JpaRepository directly
• Specify the chosen structure and reasoning in README

Required Implementation

Optional Implementation (Bonus Points)

Data Model (Reference)

Member
├── id (PK)
├── email (UNIQUE)
├── password (encrypted)
├── name
├── phone
├── role (BUYER, SELLER, ADMIN)
├── businessNumber (SELLER only)
├── createdAt
└── updatedAt

Product
├── id (PK)
├── sellerId (FK -> Member)
├── categoryId (FK -> Category)
├── name
├── description
├── price
├── stockQuantity
├── status (DRAFT, ON_SALE, SOLD_OUT, DELETED)
├── salesCount
├── createdAt
└── updatedAt

ProductImage
├── id (PK)
├── productId (FK -> Product)
├── imageUrl
├── displayOrder
└── createdAt

Category
├── id (PK)
├── name
├── parentId (FK -> Category, nullable)
└── displayOrder

Order
├── id (PK)
├── buyerId (FK -> Member)
├── orderNumber (UNIQUE)
├── status (PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED)
├── totalAmount
├── shippingAddress (embedded)
├── orderedAt
└── updatedAt

OrderItem
├── id (PK)
├── orderId (FK -> Order)
├── productId (FK -> Product)
├── sellerId (FK -> Member)
├── productName (snapshot)
├── productPrice (snapshot)
├── quantity
└── subtotal

Evaluation Criteria

Base Score (70 points)

Bonus Points (35 points)

Deduction Factors

Submission Method

1. Upload code to a GitHub Repository
2. Include the following in README.md:
   • How to run (local, Docker)
   • Tech stack and rationale for choices
   • How to access API documentation
   • Project structure description
   • Additional implementations
3. Submit the Repository URL

Notes

Execution Environment

Single Module

# Local execution (H2)
./gradlew bootRun --args='--spring.profiles.active=local'

# Docker Compose execution
docker-compose up -d

Multi-Module

# Local execution (H2)
./gradlew :marketplace-api:bootRun --args='--spring.profiles.active=local'

# JAR build
./gradlew :marketplace-api:bootJar

# Docker Compose execution
docker-compose up -d

Test Accounts (Seed Data)

Questions

• Contact via email for questions during the assignment
• If requirements are ambiguous, make reasonable decisions, implement accordingly, and specify in README

Checklist

Please verify before submission:

• ./gradlew build succeeds
• docker-compose up runs successfully
• Swagger UI or REST Docs accessible
• All tests pass
• README.md completed
• Sensitive information excluded (.env, secret keys, etc.)
• Unnecessary files excluded (.idea, .DS_Store, etc.)

Hints

// 1. Pessimistic Lock
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("SELECT p FROM Product p WHERE p.id = :id")
Optional<Product> findByIdWithLock(@Param("id") Long id);

// 2. Optimistic Lock + Retry
@Version
private Long version;

// Publish event after order creation
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleOrderCreated(OrderCreatedEvent event) {
    // Handle notification asynchronously
    notificationService.notifySeller(event.getSellerId(), event.getOrderId());
}

rootProject.name = 'marketplace'

include 'marketplace-api'
include 'marketplace-domain'
include 'marketplace-infra'
include 'marketplace-common'

// marketplace-common: No dependencies (common utilities, exceptions)

// marketplace-domain
dependencies {
    implementation project(':marketplace-common')
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
}

// marketplace-infra
dependencies {
    implementation project(':marketplace-common')
    implementation project(':marketplace-domain')
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    // QueryDSL (optional)
    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
    runtimeOnly 'com.h2database:h2'
    runtimeOnly 'com.mysql:mysql-connector-j'
}

// marketplace-api (execution module)
dependencies {
    implementation project(':marketplace-common')
    implementation project(':marketplace-domain')
    implementation project(':marketplace-infra')
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-security'
}

// marketplace-domain/.../ProductRepository.java (interface)
public interface ProductRepository {
    Product save(Product product);
    Optional<Product> findById(Long id);
}

// marketplace-infra/.../ProductRepositoryImpl.java (implementation)
@Repository
@RequiredArgsConstructor
public class ProductRepositoryImpl implements ProductRepository {
    private final ProductJpaRepository jpaRepository;

    @Override
    public Product save(Product product) {
        return jpaRepository.save(product);
    }
}

// marketplace-infra/.../ProductJpaRepository.kt
interface ProductJpaRepository : JpaRepository<Product, Long>, ProductJpaRepositoryCustom {
    fun findBySellerId(sellerId: Long, pageable: Pageable): Page<Product>
}

// marketplace-infra/.../ProductJpaRepositoryCustom.kt
interface ProductJpaRepositoryCustom {
    fun search(keyword: String?, categoryId: Long?, pageable: Pageable): Page<Product>
}

// marketplace-infra/.../ProductJpaRepositoryImpl.kt (QueryDSL)
class ProductJpaRepositoryImpl(
    private val queryFactory: JPAQueryFactory
) : ProductJpaRepositoryCustom {
    override fun search(...) = queryFactory.selectFrom(product).where(...).fetch()
}

// marketplace-api/.../ProductService.kt (Service is located in the api module)
@Service
class ProductService(
    private val productJpaRepository: ProductJpaRepository  // Direct injection
) { ... }

// Application.java in marketplace-api
@SpringBootApplication(scanBasePackages = "com.example")
public class MarketplaceApplication { }

FROM gradle:8.5-jdk17 AS builder
WORKDIR /app

# Copy Gradle files first (caching)
COPY build.gradle settings.gradle ./
COPY gradle ./gradle
COPY marketplace-common/build.gradle ./marketplace-common/
COPY marketplace-domain/build.gradle ./marketplace-domain/
COPY marketplace-infra/build.gradle ./marketplace-infra/
COPY marketplace-api/build.gradle ./marketplace-api/

RUN gradle dependencies --no-daemon || true

# Copy source and build
COPY . .
RUN gradle :marketplace-api:bootJar --no-daemon -x test

# Runtime
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=builder /app/marketplace-api/build/libs/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

View Implementation Code

Good Luck!

Previous: Part 7 - Advanced Patterns Back to Start: Part 1 - Core Application Layer