[Refactor]: 인덱싱으로 검색 최적화 (#109)

* [Feat]: TestGenerator

# Conflicts:
#	src/main/java/com/backend/global/security/SecurityConfig.java

* [Test]: 상품 목록 조회 성능 테스트

* [Test]: K6 연동

* [Feat]: 인덱싱 적용

* [Docs]: .env.default 추가

* [Feat]: h2-console 설정

Author: eunchan96

.env.default

@@ -0,0 +1,2 @@
+PG_TOSS_CLIENT_KEY=NEED_TO_SET
+PG_TOSS_SECRET_KEY=NEED_TO_SET

.gitignore

@@ -40,8 +40,8 @@ out/
 db_dev.mv.db
 db_dev.trace.db
 src/main/generated/
+k6-tests/results
 
 ### env ###
 .env
-*.env
-.env.*
+*.env

build.gradle.kts

@@ -63,6 +63,7 @@ dependencies {
     testImplementation("org.springframework.security:spring-security-test")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     testImplementation("com.github.codemonstur:embedded-redis:1.4.2")
+    implementation("net.datafaker:datafaker:2.1.0")
 }
 
 tasks.withType<Test> {

k6-tests/docker-compose.yml

@@ -0,0 +1,12 @@
+version: "3.8"
+services:
+  k6:
+    image: grafana/k6:latest
+    container_name: k6-load-test
+    working_dir: /scripts
+    volumes:
+      - ./:/scripts
+      - ./results:/results
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    command: run getProducts-test.js

k6-tests/getProducts-test.js

@@ -0,0 +1,104 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { Rate, Trend } from 'k6/metrics';
+
+// 커스텀 메트릭
+const errorRate = new Rate('errors');
+const searchDuration = new Trend('search_duration');
+
+// 테스트 설정
+export const options = {
+    stages: [
+        { duration: '30s', target: 10 },   // 워밍업: 10명
+        { duration: '1m', target: 30 },    // 30명으로 증가
+        { duration: '2m', target: 30 },    // 30명 유지
+        { duration: '30s', target: 0 },    // 종료
+    ],
+    thresholds: {
+        'http_req_duration': ['p(95)<1000', 'p(99)<2000'],
+        'errors': ['rate<0.05'],
+    },
+    summaryTrendStats: ['avg', 'min', 'med', 'max', 'p(90)', 'p(95)', 'p(99)'],
+};
+
+const BASE_URL = 'http://host.docker.internal:8080';  // Docker에서 로컬 접근
+
+// 다양한 검색 시나리오
+const scenarios = [
+    { name: '키워드_일반', params: `keyword=${encodeURIComponent('아이폰')}` },
+    { name: '키워드_희소', params: `keyword=${encodeURIComponent('MacBook Pro M3')}` },
+    { name: '카테고리', params: 'category=1' },
+    { name: '지역', params: `location=${encodeURIComponent('서울')}` },
+    { name: '복합검색', params: `keyword=${encodeURIComponent('아이폰')}&category=1&location=${encodeURIComponent('서울')}` },
+    { name: '페이징', params: 'page=5&size=20' },
+];
+
+export default function() {
+    // 랜덤하게 시나리오 선택
+    const scenario = scenarios[Math.floor(Math.random() * scenarios.length)];
+    const url = `${BASE_URL}/api/v1/products?${scenario.params}`;
+
+    const startTime = new Date();
+    const response = http.get(url, {
+        tags: { scenario: scenario.name },
+        timeout: '10s',
+    });
+    const duration = new Date() - startTime;
+
+    // 400 에러 상세 정보 출력
+    if (response.status === 400) {
+        console.log(`\n❌ 400 에러 상세 정보:`);
+        console.log(`시나리오: ${scenario.name}`);
+        console.log(`URL: ${url}`);
+        console.log(`응답 본문: ${response.body}`);
+        console.log(`응답 헤더: ${JSON.stringify(response.headers)}\n`);
+    }
+
+    // 응답 검증
+    const success = check(response, {
+        '상태 200': (r) => r.status === 200,
+        '응답시간 < 2초': (r) => r.timings.duration < 2000,
+        '데이터 존재': (r) => {
+            try {
+                const body = JSON.parse(r.body);
+                return body.data && body.data.content !== undefined;
+            } catch {
+                return false;
+            }
+        },
+    });
+
+    if (!success) {
+        console.log(`❌ 실패: ${scenario.name} - Status: ${response.status}`);
+    }
+
+    // 메트릭 기록
+    errorRate.add(!success);
+    searchDuration.add(duration);
+
+    // 사용자 행동 시뮬레이션
+    sleep(Math.random() * 2 + 1);  // 1~3초 대기
+}
+
+// 테스트 종료 후 요약
+export function handleSummary(data) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+
+    const duration = data.metrics.http_req_duration?.values || {};
+    const reqs = data.metrics.http_reqs?.values || {};
+    const errors = data.metrics.errors?.values || {};
+
+    console.log('\n=== 현재 상태 성능 테스트 결과 ===');
+    console.log(`평균 응답시간: ${duration.avg?.toFixed(2) || 'N/A'}ms`);
+    console.log(`P95 응답시간: ${duration['p(95)']?.toFixed(2) || 'N/A'}ms`);
+    console.log(`P99 응답시간: ${duration['p(99)']?.toFixed(2) || 'N/A'}ms`);
+    console.log(`최대 응답시간: ${duration.max?.toFixed(2) || 'N/A'}ms`);
+    console.log(`총 요청 수: ${reqs.count || 0}`);
+    console.log(`에러율: ${errors.rate ? (errors.rate * 100).toFixed(2) : '0.00'}%`);
+
+    return {
+        'stdout': JSON.stringify(data, null, 2),
+        [`results/getProducts-test-${timestamp}.json`]: JSON.stringify(data, null, 2),
+        'results/getProducts-test-latest.json': JSON.stringify(data, null, 2),  // 항상 최신 결과
+    };
+}

src/main/java/com/backend/domain/product/entity/Product.java

@@ -22,7 +22,16 @@
 import static java.time.LocalDateTime.now;
 
 @Entity
-@Table(name = "products")
+@Table(name = "products", indexes = {
+        // 기본 목록 조회 (상태, 최신순)
+        @Index(name = "idx_status_create", columnList = "status, create_date DESC"),
+        // 판매자 목록 조회 (회원, 상태, 최신순)
+        @Index(name = "idx_seller_status_create", columnList = "seller_id, status, create_date DESC"),
+        // 카테고리 목록 조회 (카테고리, 상태, 최신순)
+        @Index(name = "idx_category_status_create", columnList = "category, status, create_date DESC"),
+        // 지역 목록 조회 (지역, 상태, 최신순)
+        @Index(name = "idx_location_status_create", columnList = "location, status, create_date DESC")
+})
 @Getter
 @NoArgsConstructor
 public class Product extends BaseEntity {

src/main/java/com/backend/global/security/SecurityConfig.java

@@ -7,6 +7,7 @@
 import org.springframework.http.HttpMethod;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.security.config.annotation.web.configurers.HeadersConfigurer;
 import org.springframework.security.config.http.SessionCreationPolicy;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -26,7 +27,7 @@ public class SecurityConfig {
     @Bean
     public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
         http.csrf(AbstractHttpConfigurer::disable)
-                .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                 .authorizeHttpRequests(auth -> auth
                         // 정적 리소스(/static, /public, /resources, /META-INF/resources)..
                         .requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll()
@@ -35,22 +36,23 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                         .requestMatchers("/billing.html", "/payments/**", "/toss/**").permitAll()
 
                         // 공개 API (기존)..
+                        .requestMatchers("/favicon.ico", "/h2-console/**").permitAll()
                         .requestMatchers("/api/v1/auth/**", "/swagger-ui/**", "/v3/api-docs/**",
                                 "/swagger-ui.html", "/webjars/**", "/notifications/**", "/ws/**",
                                 "/api/test/**", "/bid-test.html", "/websocket-test.html").permitAll()
                         .requestMatchers(HttpMethod.GET,
-                                "/api/*/products",
-                                "/api/*/products/{productId:\\d+}",
-                                "/api/*/products/members/{memberId:\\d+}"
-                        ).permitAll()
+                                "/api/*/products", "/api/*/products/{productId:\\d+}",
+                                "/api/*/products/members/{memberId:\\d+}").permitAll()
+                        .requestMatchers("/api/*/test-data/**").permitAll()
 
                         .anyRequest().authenticated()
                 )
+                .headers(headers -> headers.frameOptions(HeadersConfigurer.FrameOptionsConfig::sameOrigin))
+                .csrf(AbstractHttpConfigurer::disable)
                 .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
                 .formLogin(AbstractHttpConfigurer::disable)
                 .httpBasic(AbstractHttpConfigurer::disable)
                 .logout(AbstractHttpConfigurer::disable);
-
         return http.build();
     }
 

src/main/java/com/backend/global/testdata/controller/TestDataController.java

@@ -0,0 +1,107 @@
+package com.backend.global.testdata.controller;
+
+import com.backend.domain.member.repository.MemberRepository;
+import com.backend.domain.product.repository.ProductRepository;
+import com.backend.global.testdata.generator.TestDataGenerator;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.Builder;
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/v1/test-data")
+@Profile("dev")
+@Tag(name = "TestData", description = "테스트 데이터 생성 API (개발용)")
+@RequiredArgsConstructor
+public class TestDataController {
+
+    private final TestDataGenerator testDataGenerator;
+    private final ProductRepository productRepository;
+    private final MemberRepository memberRepository;
+
+    @PostMapping("/generate")
+    @Operation(summary = "테스트 데이터 생성")
+    public ResponseEntity<TestDataGenerationResult> generateTestData(
+            @RequestParam(defaultValue = "1000") int count
+    ) {
+        if (count > 10000) {
+            return ResponseEntity.badRequest()
+                    .body(TestDataGenerationResult.fail("최대 10000개까지만 생성 가능"));
+        }
+
+        long startTime = System.currentTimeMillis();
+
+        try {
+            testDataGenerator.generateTestData(count);
+
+            long duration = System.currentTimeMillis() - startTime;
+
+            return ResponseEntity.ok(TestDataGenerationResult.success(
+                    count,
+                    duration,
+                    productRepository.count(),
+                    memberRepository.count()
+            ));
+
+        } catch (Exception e) {
+            return ResponseEntity.status(500)
+                    .body(TestDataGenerationResult.fail(e.getMessage()));
+        }
+    }
+
+    @GetMapping("/stats")
+    @Operation(summary = "현재 데이터 통계")
+    public ResponseEntity<DataStats> getDataStats() {
+        return ResponseEntity.ok(DataStats.builder()
+                .productCount(productRepository.count())
+                .memberCount(memberRepository.count())
+                .build());
+    }
+
+    @DeleteMapping("/cleanup")
+    @Operation(summary = "테스트 데이터 정리")
+    public ResponseEntity<String> cleanupTestData() {
+        // 테스트 데이터만 삭제하는 로직
+        return ResponseEntity.ok("테스트 데이터 정리 완료");
+    }
+}
+
+@Data
+@Builder
+class TestDataGenerationResult {
+    private boolean success;
+    private String message;
+    private Integer generatedCount;
+    private Long durationMs;
+    private Long totalProducts;
+    private Long totalMembers;
+
+    static TestDataGenerationResult success(int count, long duration, long products, long members) {
+        return TestDataGenerationResult.builder()
+                .success(true)
+                .message("테스트 데이터 생성 완료")
+                .generatedCount(count)
+                .durationMs(duration)
+                .totalProducts(products)
+                .totalMembers(members)
+                .build();
+    }
+
+    static TestDataGenerationResult fail(String message) {
+        return TestDataGenerationResult.builder()
+                .success(false)
+                .message(message)
+                .build();
+    }
+}
+
+@Data
+@Builder
+class DataStats {
+    private Long productCount;
+    private Long memberCount;
+}

src/main/java/com/backend/global/testdata/generator/MemberTestDataGenerator.java

@@ -0,0 +1,59 @@
+package com.backend.global.testdata.generator;
+
+import com.backend.domain.member.dto.MemberSignUpRequestDto;
+import com.backend.domain.member.dto.MemberSignUpResponseDto;
+import com.backend.domain.member.entity.Member;
+import com.backend.domain.member.service.MemberService;
+import com.backend.global.response.RsData;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import net.datafaker.Faker;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+@Component
+@Profile({"dev", "test", "local"})
+@RequiredArgsConstructor
+@Slf4j
+public class MemberTestDataGenerator {
+    
+    private final MemberService memberService;
+    private final Faker faker = new Faker(new Locale("ko"));
+    
+    public List<Member> generate(int count) {
+        log.info("회원 데이터 생성 시작: {}개", count);
+
+        List<Member> members = new ArrayList<>();
+        
+        for (int i = 0; i < count; i++) {
+            MemberSignUpRequestDto request = new MemberSignUpRequestDto(
+                    faker.internet().emailAddress(),
+                    "password123",
+                    faker.name().name(),
+                    faker.phoneNumber().cellPhone(),
+                    faker.address().fullAddress()
+            );
+
+            try {
+                RsData<MemberSignUpResponseDto> result = memberService.signup(request);
+                if ("200-1".equals(result.resultCode())) {
+                    memberService.findById(result.data().memberId())
+                            .ifPresent(members::add);
+                }
+
+                if ((i + 1) % 100 == 0) {
+                    log.info("진행률: {}/{}", i + 1, count);
+                }
+                
+            } catch (Exception e) {
+                log.warn("회원 생성 실패 ({}번째): {}", i + 1, e.getMessage());
+            }
+        }
+
+        return members;
+    }
+}