[내일배움캠프_Spring Boot 숙련주차] My Select Shop(상품 검색, 관심 상품 등록, 관심 상품 희망 최저가 수정, 관심 상품 조회 API 구현, Scheduler 구현)

설계 및 프로젝트 생성/설정

요구사항 파악

1. 키워드로 상품의 정보 검색

• 네이버 쇼핑 API 이용
• 상품 이름(title), 링크 URL(link), 이미지 URL(image), 최저가(price)

2. 관심 상품 등록하기

• DB에 상품정보 입력(INSERT)
  • 상품 이름(title), 링크 URL(link), 이미지 URL(image), 최저가(price)

3. 관심 상품의 "희망 최저가" 설정하기

• DB 업데이트(UPDATE): 등록된 관심상품의 "희망 최저가"만 업데이트

4. 관심 상품 조회하기

• DB 조회(Select)
• UI에 "최저가" 표시 조건: 희망하는 최저가보다 실제 최저자가 낮은 경우

API 설계

기능	Method	URL	반환
상품 검색 API	GET	/api/search?query=검색어	List<ItemDto>
관심 상품 등록하기	POST	/api/products	ProductResponseDto
관심 상품의 희망 최저가 업데이트	PUT	/api/products/{id}	ProductResponseDto
관심 상품 조회하기	GET	/api/products	List<ProductResponseDto>

프로젝트 생성

1. 프로젝트 생성 시 종속성 추가

프로젝트 생성 시 종속성 추가

2. build.gradle 내 JWT와 json 의존성 추가

// JWT
compileOnly group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.5'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.5'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.5'

// json
implementation 'org.json:json:20230227'

 

3. application.properties 내 데이터베이스 정보 추가

spring.datasource.url=jdbc:mysql://localhost:3306/shop
spring.datasource.username=root
spring.datasource.password={비밀번호}
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update

spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true

jwt.secret.key=7Iqk7YyM66W07YOA7L2U65Sp7YG065+9U3ByaW5n6rCV7J2Y7Yqc7YSw7LWc7JuQ67mI7J6F64uI64ukLg==

 

4. controller > HomeController 추가

package com.sparta.myselectshop.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {
    @GetMapping("/")
    public String home() {
        return "index";
    }
}

 

5. templates > index.html, static > css, js, images 넣기

결과 화면

---

Naver OpenAPI를 활용한 상품 검색 API

1. naver > controller > NaverApiController와 naver > dto > ItemDto 생성

@RestController
@RequiredArgsConstructor
@RequestMapping("/api")
public class NaverApiController {
    private final NaverApiService naverApiService;

    @GetMapping("/search")
    public List<ItemDto> searchItems(@RequestParam String query) {
        return naverApiService.searchItems(query);
    }
}

@Getter
@NoArgsConstructor
public class ItemDto {
    private String title;
    private String link;
    private String image;
    private int lprice;
    
    public ItemDto(JSONObject itemJson) {
        this.title = itemJson.getString("title");
        this.link = itemJson.getString("link");
        this.image = itemJson.getString("image");
        this.lprice = itemJson.getInt("lprice");
    }
}

 

2. naver > service > NaverApiService 생성

@Slf4j(topic = "NAVER API")
@Service
public class NaverApiService {

    private final RestTemplate restTemplate;

    public NaverApiService(RestTemplateBuilder builder) {
        this.restTemplate = builder.build();
    }

    public List<ItemDto> searchItems(String query) {
        // 요청 URL 만들기
        URI uri = UriComponentsBuilder
                .fromUriString("https://openapi.naver.com")
                .path("/v1/search/shop.json")
                .queryParam("display", 15)
                .queryParam("query", query)
                .encode()
                .build()
                .toUri();
        log.info("uri = " + uri);

        RequestEntity<Void> requestEntity = RequestEntity
                .get(uri)
                .header("X-Naver-Client-Id", "{Client-Id}")
                .header("X-Naver-Client-Secret", "{Client-Secret}")
                .build();

        ResponseEntity<String> responseEntity = restTemplate.exchange(requestEntity, String.class);

        log.info("NAVER API Status Code : " + responseEntity.getStatusCode());

        return fromJSONtoItems(responseEntity.getBody());
    }

    public List<ItemDto> fromJSONtoItems(String responseEntity) {
        JSONObject jsonObject = new JSONObject(responseEntity);
        JSONArray items  = jsonObject.getJSONArray("items");
        List<ItemDto> itemDtoList = new ArrayList<>();

        for (Object item : items) {
            ItemDto itemDto = new ItemDto((JSONObject) item);
            itemDtoList.add(itemDto);
        }

        return itemDtoList;
    }
}

 

Naver OpenAPI 활용한 상품 검색 API 기능 결과

---

관심 상품 API 구현

관심 상품 등록 API

관심 상품 등록 API 로직

1. Entity와 Dto 만들기

• entity > Product 엔티티 생성

@Entity // JPA가 관리할 수 있는 Entity 클래스 지정
@Getter
@Setter
@Table(name = "product") // 매핑할 테이블의 이름을 지정
@NoArgsConstructor
public class Product extends Timestamped {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String image;

    @Column(nullable = false)
    private String link;

    @Column(nullable = false)
    private int lprice;

    @Column(nullable = false)
    private int myprice;

    public Product(ProductRequestDto requestDto) {
        this.title = requestDto.getTitle();
        this.image = requestDto.getImage();
        this.link = requestDto.getLink();
        this.lprice = requestDto.getLprice();
    }
}

• dto > ProductRequestDto와 ProductResponseDto 생성

@Getter
@NoArgsConstructor
@AllArgsConstructor
public class ProductRequestDto {
    // 관심상품명
    private String title;
    // 관심상품 썸네일 image URL
    private String image;
    // 관심상품 구매링크 URL
    private String link;
    // 관심상품의 최저가
    private int lprice;
}

@Getter
@NoArgsConstructor
public class ProductResponseDto {
    private Long id;
    private String title;
    private String link;
    private String image;
    private int lprice;
    private int myprice;

    public ProductResponseDto(Product product) {
        this.id = product.getId();
        this.title = product.getTitle();
        this.link = product.getLink();
        this.image = product.getImage();
        this.lprice = product.getLprice();
        this.myprice = product.getMyprice();
    }
}

• entity > Timestamped 엔티티 생성

@Getter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class Timestamped {

    @CreatedDate
    @Column(updatable = false)
    @Temporal(TemporalType.TIMESTAMP)
    private LocalDateTime createdAt;

    @LastModifiedDate
    @Column
    @Temporal(TemporalType.TIMESTAMP)
    private LocalDateTime modifiedAt;
}

 

2. controller > ProductController 생성

@RestController
@RequiredArgsConstructor
@RequestMapping("/api")
public class ProductController {

    private final ProductService productService;

    @PostMapping("/products")
    public ProductResponseDto createProduct(@RequestBody ProductRequestDto requestDto) {
        return productService.createProduct(requestDto);
    }
}

 

3. service > ProductService 생성

@Service
@RequiredArgsConstructor
public class ProductService {

    private final ProductRepository productRepository;

    public ProductResponseDto createProduct(ProductRequestDto requestDto) {
        Product product = productRepository.save(new Product(requestDto));
        
        return new ProductResponseDto(product);
    }
}

 

4. repository > ProductRepository 생성

public interface ProductRepository extends JpaRepository<Product, Long> {
}

 

관심 상품 등록 API 호출

호출 후 결과

관심상품 희망 최저가 업데이트 API

관심 상품 희망 최저가 업데이트 API 로직

1. controller > ProductController와 dto > ProductMyPriceRequestDto 추가

@Getter
@Setter
public class ProductMypriceRequestDto {
    private int myprice;
}

@PutMapping("/products/{id}")
public ProductResponseDto updateProduct(@PathVariable Long id, @RequestBody ProductMypriceRequestDto requestDto) {
    return productService.updateProduct(id, requestDto);
}

 

2. service > ProductService 내 메서드 추가

• Product 엔티티 내 update 메서드 추가

...
@Entity
public class Product extends Timestamped {

    ...

    public void update(ProductMypriceRequestDto requestDto) {
        this.myprice = requestDto.getMyprice();
    }
}

@Transactional // Dirty Checking 수행
public ProductResponseDto updateProduct(Long id, ProductMypriceRequestDto requestDto) {
    int myprice = requestDto.getMyprice(); // myprice 가격 가져오기(조건: myprice가 100원 이상이어야함)

    if(myprice < MIN_MY_PRICE) {
        throw new IllegalArgumentException("유효하지 않은 관심 가격입니다. 최소 "+MIN_MY_PRICE+"원 이상으로 설정해 주세요.");
    }

    // 해당 상품이 존재하는지 확인
    Product product = productRepository.findById(id).orElseThrow(() ->
            new NullPointerException("해당 상품을 찾을 수 없습니다."));

    product.update(requestDto); // 업데이트 메서드 수행

    return new ProductResponseDto(product);
}

관심 상품 희망 최저가 업데이트 API 호출 후 결과

관심상품 조회 API

관심 상품 조회 API 로직

1. controller > ProductController 내 조회 메서드 추가

@GetMapping("/products")
public List<ProductResponseDto> getProducts() {
    return productService.getProducts();
}

 

2. service > ProductService 내 조회 메서드 추가

public List<ProductResponseDto> getProducts() {
    List<Product> productList = productRepository.findAll();
    List<ProductResponseDto> responseDtoList = new ArrayList<>();

    for (Product product : productList) {
        responseDtoList.add(new ProductResponseDto(product));
    }
    return responseDtoList;
}

관심 상품 조회 API 호출 결과

---

Scheduler(스케쥴러) 구현

ex) 매일 새벽 1시에 관심 상품 목록 제목으로 검색해서 최저가 정보 업데이트하는 기능

 

@Scheduled 어노테이션가 달려있는 메서드는 지정한 특정 시간마다 메서드 동작함

• Scheduled 기능 사용하기 위해 Spring에게 알려줘야함

@EnableScheduling // 설정 추가
@EnableJpaAuditing
@SpringBootApplication
public class MyselectshopApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyselectshopApplication.class, args);
    }
}

• scheduler > Scheduler 클래스 생성

@Slf4j(topic = "Scheduler")
@Component
@RequiredArgsConstructor
public class Scheduler {

    private final NaverApiService naverApiService;
    private final ProductService productService;
    private final ProductRepository productRepository;

    // 초, 분, 시, 일, 월, 주 순서
    @Scheduled(cron = "0 0 1 * * *") // 매일 새벽 1시
    public void updatePrice() throws InterruptedException {
        log.info("가격 업데이트 실행");
        List<Product> productList = productRepository.findAll();
        for (Product product : productList) {
            // 1초에 한 상품 씩 조회합니다 (NAVER 제한)
            TimeUnit.SECONDS.sleep(1);

            // i 번째 관심 상품의 제목으로 검색을 실행합니다.
            String title = product.getTitle();
            List<ItemDto> itemDtoList = naverApiService.searchItems(title);

            if (itemDtoList.size() > 0) {
                ItemDto itemDto = itemDtoList.get(0);
                // i 번째 관심 상품 정보를 업데이트합니다.
                Long id = product.getId();
                try {
                    productService.updateBySearch(id, itemDto);
                } catch (Exception e) {
                    log.error(id + " : " + e.getMessage());
                }
            }
        }
    }

}

• cron 명령어는 운영체제에서 어떤 특정 시간마다 어떤 작업을 자동 수행하고 싶을 때 사용하는 명령어
• cron 표현식 

CronExpression (Spring Framework 7.0.8 API)

• Product 엔티티 내 최저가 업데이트 메서드 추가

public void updateByItemDto(ItemDto itemDto) {
    this.lprice = itemDto.getLprice();
}

• Service 내 최저가 업데이트 메서드 추가

@Transactional
public void updateBySearch(Long id, ItemDto itemDto) {
    Product product = productRepository.findById(id).orElseThrow(() ->
            new NullPointerException("해당 상품은 존재하지 않습니다."));
    product.updateByItemDto(itemDto);
}