1. 스프링 핵심 원리 이해1

Spring/스프링 핵심 원리 - 기본편(인프런 김영한)

1. 스프링 핵심 원리 이해1 - 예제 만들기

kyung.Kh 2024. 5. 5. 18:37

1. 비즈니스 요구사항과 설계

회원 : 가입/조회, 등급, 자체 DB 구축
주문과 할인 정책 : 할인 정책 차등 적용, 변경 가능성 높음

회원 데이터와 할인 정책 같은 부분은 지금 결정하기 어려움 → 객체지향 설계 방법 적용

인터페이스를 만들고 구현체를 언제든지 갈아끼우는 방법

2. 회원 도메인 설계

회원 도메인 요구 사항

회원 가입/조회
회원 등급 분류 (일반/VIP)
데이터 자체 DB 구축, 외부 시스템 연동

회원 도메인 협력 관계

! https://velog.velcdn.com/images/sgn07124/post/8d19e0f1-7b52-4e0c-b5fa-71ffed03d798/image.png

회원 클래스 다이어그램

실제 서버를 실행하지 않고 클래스들만 볼 수 있음

회원 객체 다이어그램

객체 간의 메모리 참조가 어떻게 되는지 그린 것으로 실제 View한 인스턴스끼리의 참조

회원 서비스 : MemberServiceImpl

메모리 회원 저장소 : MemoryMemberRepository

3. 회원 도메인 개발

회원 등급 : Member

package hello.core.member;

public enum Grade {
    BASIC,
    VIP
}

회원 엔티티 : Member

package hello.core.member;

public class Member {

    private Long id;
    private String name;
    private Grade grade;

    public Member(Long id, String name, Grade grade) {  // 생성자
        this.id = id;
        this.name = name;
        this.grade = grade;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }
}

생성자 생성 후, private에 접근하기 위해 getter & setter 생성

회원 저장소 인터페이스 : MemberResitory

package hello.core.member;

public interface MemberRepository {

    void save(Member member);

    Member findById(Long memberId);
}

메모리 회원 저장소 구현체 : MemoryMemberRepository

package hello.core.member;

import java.util.HashMap;
import java.util.Map;

public class MemoryMemberRepository implements MemberRepository {

    private static Map<Long, Member> store = new HashMap<>();

    @Override
    public void save(Member member) {  // 저장
        store.put(member.getId(), member);
    }

    @Override
    public Member findById(Long memberId) {  // 검색
        return store.get(memberId);
    }
}

DB가 확정이 되지 않았기 때문에 MemoryMemberRepository를 만듦
실무에서는 동시성 이슈 때문에 ConcurrentHashMap을 사용한다.

회원 서비스 인터페이스 : MemberService

package hello.core.member;

public interface MemberService {

    void join(Member member);

    Member findMember(Long memberId);
}

회원 서비스 구현체 : MemberServiceImpl

package hello.core.member;

public class MemberServiceImpl implements MemberService {

    private final MemberRepository memberRepository = new MemoryMemberRepository();  // 구현 객체를 선택해줘야 함

    @Override
    public void join(Member member) {
        memberRepository.save(member);
    }

    @Override
    public Member findMember(Long memberId) {
        return memberRepository.findById(memberId);
    }
}

4. 회원 도메인 실행과 테스트

회원 객체 다이어그램에서 실제 서버가 동작 할 때, 클라이언트가 회원 서비스(MemberServiceImpl)을 사용하게 되고, 실제 회원 서비스는 메모리 회원 저장소를 사용하게 된다.

회원 도메인 : main

package hello.core;

import hello.core.member.Grade;
import hello.core.member.Member;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;

public class MemberApp {
    public static void main(String[] args) {
        MemberService memberService = new MemberServiceImpl();
        Member member = new Member(1L, "memberA", Grade.VIP);  // 새로운 회원
        memberService.join(member);  // 새로운 회원인 memberA를 가입시킴

        Member findMember = memberService.findMember(1L);  // id가 1L인 회원을 find
        System.out.println("new member = " + member.getName());
        System.out.println("find member = " + findMember.getName());
    }
}

애플리케이션 로직을 통한 테스트는 좋지 않다. → JUnit 사용

회원 도메인 : test

package hello.core.member;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

public class MemberServiceTest {

    MemberService memberService = new MemberServiceImpl();

    @Test
    void join() {
        //given
        Member member = new Member(1L, "memberA", Grade.VIP);

        //when
        memberService.join(member);
        Member findMember = memberService.findMember(1L);

        //then
        Assertions.assertThat(member).isEqualTo(findMember);
    }
}

만약에 findMember가 2L이면 equal하지 않으므로 에러 발생!

테스트를 잘 작성하는게 매우 중요함❗️

회원 도메인 설계의 문제점

다른 저장소로 변경 시 OCP 원칙 지켜지지 않는다.
DIP가 잘 지켜지지 않는다.
의존관계가 인터페이스와 구현 두 가지에 모두 의존

추상화(MemberRepository memberRepository)와 구체화(new MemoryMemberRepository()) 모두 의존하고 있다.

5. 주문과 할인 도메인 설계

주문과 할인 정책

회원 등급에 따라 할인 등급 차등
할인 정책 변경 가능성 높음

주문 도메인 협력, 역할, 책임

주문 도메인 전체 - 역할과 구현 모두 적용

역할과 구현을 분리했기 때문에 자유롭게 구현 객체를 조립할 수 있게 설계되어 회원 저장소, 할인 정책 등을 유연하게 변경할 수 있다.

주문 도메인 클래스 다이어그램

주문 도메인 다이어그램1

회원을 메모리에서 조회하고, 정액 할인 정책을 지원해도 주문 서비스를 변경하지 않아도 된다.역할들의 협력 관계를 그대로 재사용 할 수 있다.

주문 도메인 다이어그램2

회원을 메모리가 아닌 DB에서 조회하고, 정률 할인 정책을 지원해도 주문 서비스를 변경하지 않아도 된다. 협력 관계를 그대로 재사용 할 수 있다.

6. 주문과 할인 도메인 개발

할인 정책 인터페이스 : DiscountPolicy

package hello.core.discount;

import hello.core.member.Member;

public interface DiscountPolicy {

    /* @return 할인 대상 금액 */
    int discount(Member member, int price);
}

정액 할인 정책 구현체 : FixDiscountPolicy

package hello.core.discount;

import hello.core.member.Grade;
import hello.core.member.Member;

public class FixDiscountPolicy implements DiscountPolicy {

    private int discountFixAmount = 1000;  // 1000원 할인

    @Override
    public int discount(Member member, int price) {
        if (member.getGrade() == Grade.VIP) {  // enum 타입은 == 사용해야 됨
            return discountFixAmount;  // 1000원 할인
        } else {
            return 0;  // 할인 x
        }
    }
}

주문 엔티티 : Order

package hello.core.order;

public class Order {

    private Long memberId;  // 회원 id
    private String itemName;  // 제품 이름
    private int itemPrice;  // 제품 가격
    private int discountPrice;  // 할인 가격

    public Order(Long memberId, String itemName, int itemPrice, int discountPrice) {  // 생성자 생성
        this.memberId = memberId;
        this.itemName = itemName;
        this.itemPrice = itemPrice;
        this.discountPrice = discountPrice;
    }

    /* 비즈니스 개산 로직 */
    public int calculatePrice() {
        return itemPrice - discountPrice;  // 최종 결과
    }

    public Long getMemberId() {
        return memberId;
    }

    public void setMemberId(Long memberId) {
        this.memberId = memberId;
    }

    public String getItemName() {
        return itemName;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    public int getItemPrice() {
        return itemPrice;
    }

    public void setItemPrice(int itemPrice) {
        this.itemPrice = itemPrice;
    }

    public int getDiscountPrice() {
        return discountPrice;
    }

    public void setDiscountPrice(int discountPrice) {
        this.discountPrice = discountPrice;
    }

    @Override
    public String toString() {
        return "Order{" +
                "memberId=" + memberId +
                ", itemName='" + itemName + '\\'' +
                ", itemPrice=" + itemPrice +
                ", discountPrice=" + discountPrice +
                '}';
    }
}

생성자, getter & setter, toString()을 (control+Enter)로 생성한다.

주문 서비스 인터페이스 : OrderService

package hello.core.order;

public interface OrderService {
    Order createOrder(Long memberId, String itemName, int itemPrice);
}

주문 서비스 구현체 : OrderServiceImpl

package hello.core.order;

import hello.core.discount.DiscountPolicy;
import hello.core.discount.FixDiscountPolicy;
import hello.core.member.Member;
import hello.core.member.MemberRepository;
import hello.core.member.MemoryMemberRepository;

public class OrderServiceImpl implements OrderService {

    private final MemberRepository memberRepository = new MemoryMemberRepository();
    private final DiscountPolicy discountPolicy = new FixDiscountPolicy();

    @Override
    public Order createOrder(Long memberId, String itemName, int itemPrice) {  // 단일 체계 원칙이 잘 지켜짐
        Member member = memberRepository.findById(memberId);
        int discountPrice = discountPolicy.discount(member, itemPrice);

        return new Order(memberId, itemName, itemPrice, discountPrice);
    }
}

주문 생성 요청 → 회원 정보 조회 → 할인 정책 적용 → 주문 객체를 생성 후 반환
메모리 회원 리포지토리와, 고정 금액 할인 정책을 구현체로 생성
@override 부분에서 단일 체계 원칙이 잘 지켜짐 → OrderService는 할인에 대한 정보는 전혀 모르고 결과만 알려주기 때문 (할인 정책을 수정할 때, OrderService는 건드리지 않아도 됨)

7. 주문과 할인 도메인 실행과 테스트

주문과 할인 정책 실행 - main

package hello.core;

import hello.core.member.Grade;
import hello.core.member.Member;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;
import hello.core.order.Order;
import hello.core.order.OrderService;
import hello.core.order.OrderServiceImpl;

public class OrderApp {
    public static void main(String[] args) {
        MemberService memberService = new MemberServiceImpl();
        OrderService orderService = new OrderServiceImpl();

        Long memberId = 1L;  // member을 저장해야되므로
        Member member = new Member(memberId, "memberA", Grade.VIP);
        memberService.join(member);

        Order order = orderService.createOrder(memberId, "itemA", 10000);

        System.out.println("order = " + order);

    }
}

애플리케이션 로직을 통한 테스트는 좋지 않다 → JUnit 사용

주문과 할인 정책 실행 - test

package hello.core.order;

import hello.core.member.Grade;
import hello.core.member.Member;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

public class OrderServiceTest {

    MemberService memberService = new MemberServiceImpl();
    OrderService orderService = new OrderServiceImpl();

    @Test
    void createOrder() {
        Long memberId = 1L;
        Member member = new Member(memberId, "memberA", Grade.VIP);
        memberService.join(member);

        Order order = orderService.createOrder(memberId, "itemA", 10000);
        Assertions.assertThat(order.getDiscountPrice()).isEqualTo(1000);
    }
}

자바 단일 테스트(순수 자바 코드)를 하는게 중요

[출처]

스프링 기본 2 객체 지향 원리 적용

인프런 김영한님의 스프링 기본편을 바탕으로 작성했습니다.

728x90