🎽 인프런 워밍업 클럽 0기 백엔드 여섯 번째 과제

출처
https://inf.run/XKQg

스프링 컨테이너의 의미와 사용 방법에 대해 학습하여 과제를 수행했다.

⛳️ Spring Container란?

스프링은 자바 기반의 프레임워크로, 여러 기능을 제공한다.
그 중에서도 IoC(제어의 역전) 컨테이너는 객체의 생성, 소멸과 같은 생명주기 관리를 담당하는데, 이를 스프링 컨테이너라고 부른다.

스프링 컨테이너는 빈(Bean)이라 불리는 객체를 생성하고, 필요한 곳에 주입(Dependency Injection)해주는 역할을 한다.
이를 통해 코드의 유연성과 유지보수성이 향상되며, 객체 간의 의존성을 낮출 수 있다.

⛳️ FruitController

import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class FruitController {

    private final FruitService fruitService;

    @PostMapping("/api/v1/fruit")
    public void saveFruit(@RequestBody FruitInfoRequest request) {
        fruitService.saveFruit(request.name(), request.warehousingDate(), request.price());
    }

    @PutMapping("/api/v1/fruit")
    public void updateFruit(@RequestBody FruitIdRequest request) {
        fruitService.updateFruit(request.id());
    }

    @GetMapping("/api/v1/fruit/stat")
    public FruitAmountResponse getAmount(@RequestParam String name) {
        return fruitService.getAmount(name);
    }
}

⛳️ FruitService

import java.time.LocalDate;
import org.springframework.stereotype.Service;

@Service
public class FruitService {
    private final FruitRepository fruitRepository;

    public FruitService(FruitRepository fruitRepository) {
        this.fruitRepository = fruitRepository;
    }

    public void saveFruit(String name, LocalDate warehousingDate, long price) {
        fruitRepository.saveFruit(name, warehousingDate, price);
    }

    public void updateFruit(long id) {
        boolean isFruitNotExist = fruitRepository.isFruitNotExist(id);
        if (isFruitNotExist) {
            throw new IllegalArgumentException("해당하는 과일이 존재하지 않습니다.");
        }

        fruitRepository.updateFruit(id);
    }

    public FruitAmountResponse getAmount(String name) {
        return fruitRepository.getAmount(name);
    }
}

⛳️ FruitRepository

import java.time.LocalDate;

public interface FruitRepository {
    void saveFruit(String name, LocalDate warehousingDate, long price);

    boolean isFruitNotExist(long id);

    void updateFruit(long id);

    FruitAmountResponse getAmount(String name);
}

FruitRepository라는 인터페이스를 정의하여 과일에 대한 데이터를 저장하고 조회하는 기능을 추상화했다.

🌱 FruitMemoryRepository

FruitMemoryRepository는 애플리케이션 실행 중에 데이터를 메모리에 저장하며, FruitRepository 인터페이스를 구현하고 있다.
이 클래스는 @Repository 어노테이션을 통해 Bean으로 등록된다.

참고
메모리 기반의 저장소를 사용하면 간편하게 데이터를 관리할 수 있지만, 애플리케이션을 재시작하면 데이터가 초기화되므로 실제 프로덕션 환경에서는 사용에 제약이 있을 수 있다.

import java.time.LocalDate;
import java.util.HashMap;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Repository;

@Repository
@RequiredArgsConstructor
@Primary
public class FruitMemoryRepository implements FruitRepository {
    private final Map<Long, Fruit> store = new HashMap<>();
    private Long sequence = 0L;

    @Override
    public void saveFruit(String name, LocalDate warehousingDate, long price) {
        Fruit fruit = new Fruit(name, warehousingDate, price);
        sequence++;
        store.put(sequence, fruit);
        System.out.println("sequence = " + sequence);
        System.out.println("store.values().toString() = " + store.values());
    }

    @Override
    public boolean isFruitNotExist(long id) {
        Fruit foundFruit = store.get(id);
        return foundFruit == null;
    }

    @Override
    public void updateFruit(long id) {
        Fruit foundFruit = store.get(id);
        foundFruit.changeStatus();
        System.out.println("foundFruit.isSold() = " + foundFruit.isSold());
        System.out.println("foundFruit = " + foundFruit);
    }

    @Override
    public FruitAmountResponse getAmount(String name) {
        long salesAmount = getSalesAmount(name);
        long notSalesAmount = getNotSalesAmount(name);
        System.out.println("salesAmount = " + salesAmount);
        System.out.println("notSalesAmount = " + notSalesAmount);
        return new FruitAmountResponse(salesAmount, notSalesAmount);
    }

    private long getSalesAmount(String name) {
        return store.values().stream()
                .filter(fruit -> fruit.getName().equals(name))
                .filter(Fruit::isSold)
                .mapToLong(Fruit::getPrice)
                .sum();
    }

    private long getNotSalesAmount(String name) {
        return store.values().stream()
                .filter(fruit -> fruit.getName().equals(name))
                .filter(fruit -> !fruit.isSold())
                .mapToLong(Fruit::getPrice)
                .sum();
    }
}

Map은 키-값 쌍으로 데이터를 저장하며, 특정 키를 사용하여 빠르게 데이터에 접근할 수 있어 효과적으로 데이터를 관리할 수 있다.
따라서, FruitMemoryRepository에서는 Map을 테이블처럼 활용하여 데이터를 구조화했다.

또한, sequence를 키로 사용하여 고유한 식별자를 부여하고, 과일 데이터를 구분하여 저장함으로써 메모리 상에서 간편하게 데이터를 관리할 수 있어 사용했다.

▶️ 실행 결과

1. 과일 정보 저장

2. 팔린 과일 정보 기록

3. 특정 과일 기준으로 팔린 금액, 팔리지 않은 금액 조회

🌱 FruitMySqlRepository

FruitMySqlRepository는 MySQL 데이터베이스를 이용하여 데이터를 저장하고 조회하며, JdbcTemplate을 사용하여 간단한 SQL 쿼리를 실행한다.

이 Repository도 마찬가지로 @Repository 어노테이션을 통해 빈으로 등록되었고, 생성자 주입을 통해 JdbcTemplate을 주입받고 있다.

import java.time.LocalDate;
import lombok.RequiredArgsConstructor;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
@RequiredArgsConstructor
public class FruitMySqlRepository implements FruitRepository {
    private final JdbcTemplate jdbcTemplate;

    @Override
    public void saveFruit(String name, LocalDate warehousingDate, long price) {
        String sql = "insert into fruit (name, warehousingDate, price) values (?, ?, ?)";
        jdbcTemplate.update(sql, name, warehousingDate, price);
    }

    @Override
    public boolean isFruitNotExist(long id) {
        String readSql = "select * from fruit where id = ?";
        return jdbcTemplate.query(readSql, (rs, rowNum) -> 0, id).isEmpty();
    }

    @Override
    public void updateFruit(long id) {
        String sql = "update fruit set is_sold = 1 where id = ?";
        jdbcTemplate.update(sql, id);
    }

    @Override
    public FruitAmountResponse getAmount(String name) {
        String sql1 = "select sum(price) as salesAmount from fruit where is_sold = 1";
        String sql2 = "select sum(price) as notSalesAmount from fruit where is_sold = 0";

        Long salesAmount = jdbcTemplate.queryForObject(sql1, (rs, rowNum) -> rs.getLong("salesAmount"));
        Long notSalesAmount = jdbcTemplate.queryForObject(sql2, (rs, rowNum) -> rs.getLong("notSalesAmount"));

        return new FruitAmountResponse(salesAmount, notSalesAmount);
    }
}

⛳️ @Primary와 @Qulifier

스프링에서 여러 개의 동일한 타입의 Bean이 존재할 때, 해당 Bean을 주입받는 코드에서 어떤 빈을 사용할지 알려주지 않으면 에러가 발생한다.
이러한 상황에서 @Primary와 @Qualifier 어노테이션을 사용하여 어떤 빈을 주입받을지 명시하도록 한다.

@Repository
@RequiredArgsConstructor
@Primary
public class FruitMemoryRepository implements FruitRepository {
	// ...
}

@Primary 어노테이션은 여러 개의 동일한 타입의 Bean 중에서 우선적으로 주입받아야 할 Bean을 지정할 때 사용된다.
FruitMemoryRepository에서 @Primary 어노테이션을 사용했기 때문에FruitService에 FruitMemoryRepository 빈이 주입된다.

@Service
public class FruitService {

    private final FruitRepository fruitRepository;

    public FruitService(@Qualifier("fruitMySqlRepository") FruitRepository fruitRepository) {
        this.fruitRepository = fruitRepository;
    }

    // ...
}

@Qualifier 어노테이션은 특정한 Bean을 선택하여 주입받을 때 사용된다.
예를 들어, FruitService에서 특정 Bean을 선택하여 주입받고자 할 때 위와 같이 @Qualifier 어노테이션을 사용할 수 있다.

@Qualifier("fruitMySqlRepository")를 통해 FruitMySqlRepository를 명시적으로 선택하여 주입받는다.
이 경우, @Qualifier가 @Primary보다 우선순위가 높기 때문에 해당 Bean이 주입된다.

⛳️ 개인 회고

스프링은 다양한 어노테이션을 제공하면서 유연하고 확장 가능한 코드를 작성할 수 있는 환경을 제공한다. 이를 통해 개발 생산성과 유지보수성을 향상시킬 수 있음을 느꼈다.
이제는 테스트 코드 작성과 예외 처리, 그리고 프로젝트 구조에 대한 고민을 통해 코드의 완성도를 높이는 방향으로 더 발전해 나가고 싶다.