[Spring] 김영한 스프링 핵심원리 <섹션2.스프링 핵심원리 이해1 - 예제 만들기> 정리

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

 

프로젝트 생성

dependencies 아무것도 선택x

비즈니스 요구사항과 설계

• 회원
  • 회원을 가입하고 조회할 수 있다.
  • 회원은 일반과 VIP 두 가지 등급이 있다.
  • 회원 데이터는 자체 DB를 구축할 수 있고, 외부 시스템과 연동할 수 있다. (미확정) ⇒ 인터페이스로 역할과 구현을 구분
• 주문과 할인 정책
  • 회원은 상품을 주문할 수 있다.
  • 회원 등급에 따라 할인 정책을 적용할 수 있다.
  • 할인 정책은 모든 VIP는 1000원을 할인해주는 고정 금액 할인을 적용해달라. (나중에 변경 될 수 있다.)
  • 할인 정책은 변경 가능성이 높다. 회사의 기본 할인 정책을 아직 정하지 못했고, 오픈 직전까지 고민을 미루고 싶다. 최악의 경우 할인을 적용하지 않을 수 도 있다. (미확정) ⇒ 인터페이스로 역할과 구현을 구분

회원 도메인 설계

회원 도메인 협력 관계

• 클라이언트가 회원 서비스를 호출 → 회원 서비스는 가입과 조회라는 2가지 기능을 제공
• 회원 저장소(인터페이스)를 따로 만들어서 회원 데이터에 따로 접근하는 계층을 만든다
• 회원 저장소(인터페이스) 역할의 구현을 3가지로 나누어, 이 셋 중에 하나로 구현체를 선택하면 되도록 만든다
• 자체 db, 외부 시스템 연동도 미확정이지만 개발을 손놓고 있을 수는 없기 떄문에.. 메모리 회원 저장소를 일단 만들어서 개발을 진행
• 메모리 → 서버가 재부팅되면 데이터가 날아감 → 나중에 db나 저장소가 선택되면 그 부분을 구현해서 교체. 역할과 구현을 교체한다

회원 클래스 다이어그램

• 멤버 서비스를 인터페이스로 → 이에 대한 구현체 MemberServiceImpl
• 멤버 서비스 레파지토리(회원 저장소 인터페이스) → 이에 대한 구현 클래스가 메모리멤버 레파지토리와 db멤버 레파지토리

⇒ 실제 서버가 실행되지 않고 클래스들을 분석해서 보여주는 정적인 부분

구현체들은 동적으로 결정되는 부분. 서버가 떠야 결정되므로 객체 다이어그램을 따로 그려서 서버가 실제 떴을 때의 동작을 그려낸다

 

회원 객체 다이어그램

• 실제 객체 간의 메모리 참조를 그린 그림
• 회원 서비스는 MemberServiceImpl
• 클라이언트는 회원 서비스를 참조, 회원 서비스는 메모리 회원 저장소를 참조

⇒ 실제 유한 인스턴스끼리의 참조. 동적인 부분.

항상 이 3가지의 다이어그램으로 개념적인 부분을 표현

회원 도메인 개발

회원 등급

package hello.core.member;
 public enum Grade { //회원 등급 2가지
     BASIC,
		 VIP
}

• enum : 관련있는 상수끼리 모아 상수를 대표할 수 있는 이름으로 타입을 정의, 마치 클래스처럼 보이게 하는 상수 ⇒ 별도의 자바로 선언, class 내부에서 선언, class 외부에서 선언

[Java] Enum의 사용법

• enum을 통해 BASIC과 VIP 두 가지의 타입이 있는 회원 등급을 관리

 

회원 엔티티

package hello.core.member;

public class Member {
    private Long id;
    private String name;
    private Grade grade;
    //id,이름,grade 3가지 속성을 보유

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

    //getter-setter method를 통해서 private의 값을 세팅
    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;
    }
}

• getter setter method : 객체지향 프로그래밍에서는 외부 메소드를 통해 데이터에 접근하여 변경하도록 유도 → 이 역할을 하는 것이 Setter (변수를 할당)
• 외부에서 객체의 데이터를 읽을 때도 메소드를 사용 → 이러한 역할을 하는 것이 Getter (변수를 반환)

 

회원 저장소

회원 저장소 인터페이스

package hello.core.member;

public interface MemberRepository {
    void save(Member member); //회원을 저장

    Member findById(Long memberId); //회원의 아이디로 회원을 찾는 기능
}

//인터페이스에 대한 구현체가 필요. 인터페이스와 구현체를 다른 패키지에 두는 것이 좋은 설계, 이번에는 같은 패키지로

메모리 회원 저장소 구현체

package hello.core.member;
import java.util.HashMap;
import java.util.Map;

//db가 확정되지 않았으므로 메모리멤버 리파지토리를 이용. MemberRepository의 구현체
public class MemoryMemberRepository implements MemberRepository{
    @Override
    public void save(Member member) {
        store.put(member.getId(), member);
    }

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

    private static Map<Long, Member> store = new HashMap<>(); //저장소 역할
    //concurrent 동시성 이슈가 있으므로 실무에서는 단순 HashMap이 아닌 concurrent hashmap을 사용해야 함.

}

회원 서비스

회원 서비스 인터페이스

package hello.core.member;

public interface MemberService {
    void join(Member member);
    Member findMember(Long memberId);
}

회원 서비스 구현체

package hello.core.member;

//멤버 서비스 implement의 구현체 -> 회원 가입과 조회를 위해서 어떤 것이 필요할까? => 멤버 레파지토리 인터페이스가 필요
public class MemberServiceImpl implements MemberService {

    //오른쪽 부분 -> 실제 할당하는 부분이 구현체를 의존 (추상화, 구체화 둘 다에 의존) => DIP 위반
    private final MemberRepository memberRepository = new MemoryMemberRepository();
    //단순히 인터페이스만 적으면 null point exception 발생 -> 구현 객체 선택(MemoryMemberRepository)
    @Override
    public void join(Member member) {
        memberRepository.save(member); //다형성에 의해 memberRepository의 save가 호출됨
    }

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

회원 도메인 실행과 테스트

회원 도메인 - 회원 가입 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); //Long type이라 L 붙여줘야 됨
        memberService.join(member); //id가 1, 이름이 memberA인 멤버의 회원가입 실제 동작

        Member findMember = memberService.findMember(1L); //가입 멤버와 findMember가 일치하면 제대로 동작한 것
        System.out.println("member = " + member.getName()); //이름을 출력해서 확인
        System.out.println("fineMember = " + findMember.getName());
    }
}

지금까지는 Spring 관련 코드x 순수한 자바로만 이루어진 코드들

이렇게 print를 통해 메인 메소드를 테스트 하는 것은 한계가 있음 ⇒ JUnit test framework 사용 (오류 발생한 경우 오류를 빨리 catch할 수 있음) 필수로 사용함.

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);

    }
}

이러한 방식은 OCP,DIP를 잘 지키고 있는가? 인터페이스뿐만 아니라 구현체까지 모두 의존한다는 문제점이 있음. MemberRepository

주문과 할인 도메인 설계

주문 도메인 역할

1. 주문 생성: 클라이언트(메인 같은 코드 혹은 컨트롤러) 는 데이터를 넘겨서 주문 서비스에 주문 생성을 요청한다.

2. 회원 조회: 할인을 위해서는 회원 등급이 필요하다. 그래서 주문 서비스는 회원 저장소에서 회원을 조회한다.(findbyId)

3. 할인 적용: 주문 서비스는 회원 등급에 따른 할인 여부를 할인 정책에 위임한다.

4. 주문 결과 반환: 주문 서비스는 할인 결과를 포함한 주문 결과를 반환한다.(실제로는 주문 데이터를 만들어서 db에 저장)

 

 

주문 도메인 전체 (역할, 구현)

• 역할 → 구현을 분리. 자유롭게 구현 객체를 조립 가능. 회원 저장소 뿐만 아니라 할인 정책을 변경 가능
• 클라이언트에 주문 서비스에 주문 생성→ 회원 조회하고 할인정책을 조회해서 클라이언트에 반환

 

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

• OrderService 인터페이스 → 이에 대한 구현체 OrderServiceImpl

 

주문 도메인 객체 다이어그램

클라이언트가 주문 서비스 구현체를 호출 → 메모리 회원 저장소와 정액 할인 정책을 호출

역할들의 협력 관계를 재사용 할 수 있다는 말 ⇒ 메모리 회원 저장소가 변화해도, 할인 정책이 변화해도 주문 서비스 구현체를 수정할 필요가 없다는 말

이런 식으로 저장소와 할인 정책이 변화해도 주문 서비스 역할을 변경할 필요가 없다

 

주문과 할인 도메인 개발

할인 정책 인터페이스

package hello.core.discount;

import hello.core.member.Member;

public interface DiscountPolicy {
    //@return 할인대상 금액
    int discount(Member member, int price);
}

정액 할인 정책 구현체

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){ //VIP면 1000원 할인
            return discountFixAmount;
        } else{
            return 0; //VIP 아니면 할인 없음
        }
    }
}

주문 엔티티

package hello.core.order;

public class Order {
    private Long memberId;
    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;
    }

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

주문 서비스 인터페이스

package hello.core.order;

public interface OrderService {
    //주문 생성 -> 주문 결과 반환
    Order createOrder(Long memberId, String itemName, int itemPrice);

}

주문 서비스 구현체

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;

//단일 책임 원칙을 잘 지킨 방식 할인에 대한 변경이 필요하면 주문쪽 코드를 고칠 필요가x
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); //최종 생성된 주문 정보를 넘긴다
    }
}

 

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

실행

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= new Member(memberId,"memberA", Grade.VIP );
        memberService.join(member); //회원을 생성해서 가입시킴 -> 메모리 객체에 넣어놓음

        Order order = orderService.createOrder(memberId, "itemA",10000);
        System.out.println("order = "+order);
        System.out.println("order.calculatePrice = "+ order.calculatePrice());
        //이러한 프린트 방식보다는 JUnit을 이용하기

    }
}

테스트

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; //long으로 하면 null이 들어갈 수 없음
        Member member = new Member(memberId, "memberA", Grade.VIP);
        memberService.join(member);

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

    }

}

단위테스트(스프링이나 컨테이너 도움 없이 자바 코드로 테스트 하는 것)를 잘 만드는 것이 중요하다

 

단축키

commnad+n : genarate 단축키

command+a : 전체 선택

option+enter : 뭔가.. 잘 안 될 때… 빨간줄 위에서 치면 문제 해결해줌

command+shift+enter : 세미콜론 자동완성

psvm+enter : public static void main(String[] args) 단축키

command+option+v :

sout+enter: System.*out*.println(); 단축키

soutv+enter: 변수를 위에서 선택 가능

F2: 오류난 곳으로 바로 이동