개발은 꽃

[Spring Boot JPA] 회원 기능 개발

메성 — Thu, 17 Feb 2022 23:05:51 +0900

실전! 스프링 부트와 JPA 활용1 - 웹 애플리케이션 개발 - 인프런 | 강의

실무에 가까운 예제로, 스프링 부트와 JPA를 활용해서 웹 애플리케이션을 설계하고 개발합니다. 이 과정을 통해 스프링 부트와 JPA를 실무에서 어떻게 활용해야 하는지 이해할 수 있습니다., - 강

www.inflearn.com

회원 기능

회원 등록
회원 조회

회원 등록

@Getter @Setter
public class MemberForm {

    @NotEmpty(message = "회원 이름은 필수입니다. ")
    private String name;

    private String city;
    private String street;
    private String zipcode;
}


//Controller
@PostMapping("/members/new")
public String create(@Valid MemberForm memberForm, BindingResult result) {

  if(result.hasErrors()) {
    return "members/createMemberForm";
  }

  Address address = new Address(memberForm.getCity(), memberForm.getStreet(), memberForm.getZipcode());
  Member member = new Member();
  member.setName(memberForm.getName());
  member.setAddress(address);

  memberService.join(member);
  return "redirect:/";
}

javax.validation을 통해서 쉽게 validation check가 가능
- @NotEmpty, @Valid
- 스프링 2.3부터는 따로 라이브러리를 추가해야한다.
- ```
implementation 'org.springframework.boot:spring-boot-starter-validation'
```

BindingResult
- ```
import org.springframework.validation.BindingResult;
```
- @Vaild와 함께 BindingResult를 파라미터로 가지고 있으면, @Valid에 체크한 오류가 BindingResult에 담겨서 Controller가 실행이 된다.
- Controller에서는 BindingResult의 hasErrors 메소드를 통해서 분기 처리가 가능하고, view 단에서 오류에 관련된 내용을 들고 가게 된다.
  - ```
  <style>
  .fieldError {
  border-color: #bd2130;
  }
  </style>
  
  <input type="text" th:field="*{name}" class="form-control" placeholder="이름을 입력하세요"
        th:class="${#fields.hasErrors('name')}? 'form-control fieldError' : 'form-control'">
  
  <p th:if="${#fields.hasErrors('name')}" th:errors="*{name}">Incorrect date</p>
```
- hasErrors에 필드값 name이 있으면 해당 분기를 타게되고 input에 관련된 이벤트를 실행하게 된다. 추가로 th:errors로 인해 @NotEmpty에 정의한 메시지가 출력되게 된다.

주의해야할 점

화면에서 주고받을 데이터(DTO)와 Entity의 필드값이 같다고 하더라도 별개의 클래스를 만들어 놓는 것이 좋다.
둘의 성격이 다르기 때문에!

회원 목록

Entity와 DTO

API를 만들 때 데이터를 넘기는 경우 Entity를 넘기면(외부로 반환) 절대 안 되고 DTO를 넘겨야한다.
- 만약, Member Entity에 새로운 필드를 추가하게 되면, API 스펙이 변경이 되어 큰 이슈가 발생될 수 있다.
Entity는 순수하게 유지하는 것이 좋다.
화면에서 사용하는 데이터는 DTO를 따로 만들어 사용하는 것이 좋다.

회원 Repository 개발

@Repository
public class MemberRepository {

    @PersistenceContext
    private EntityManager em;

    public void save(Member member) {
        em.persist(member);
    }

    public Member findOne(Long id) {
        return em.find(Member.class, id);
    }

    //jpql 사용
    public List<Member> findAll() {
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }

    //jpql 사용
    public List<Member> findByName(String name) {
        return em.createQuery("select m from Member m where m.name = :name", Member.class)
                .setParameter("name", name)
                .getResultList();
    }
}

@Repository
- Spring Bean으로 등록
- @Component가 내장되어 있어 ComponentScan 시 스프링 빈으로 등록이 됨
@PersistenceContext
- 해당 어노테이션이 있으면 스프링이 EntityManager를 주입해준다.
em.persist(member);
- EntityManager에 의해 member Entity를 영속성 컨텍스트에 넣어주고 트랜잭션이 커밋되는 시점에 member를 저장하게 한다.(insert)
em.find(Member.class, id);
- 단건 조회로서, 첫번째는 타입이고 두번째는 key값을 넣어주면 된다.
em.createQuery("select m from Member m", Member.class) .getResultList();
- jpql을 사용한 것으로 쿼리문과 거의 비슷하나 from 절에 Member는 테이블이 아닌 Entity이다.
- 첫번째 파라미터는 쿼리, 두번째 파라미터는 from 절에서 사용하는 Entity를 넣어준다.

회원 서비스 개발

@Service
@Transactional(readOnly = true)
public class MemberService {

    @Autowired
    private MemberRepository memberRepository;

    /**
     * 회원 가입
     */
    @Transactional
    public Long join(Member member) {
        validateDuplicateMember(member);    //중복 회원 검증
        memberRepository.save(member);
        return member.getId();  //@GeneratedValue에 의해 id를 저장하지 않아도 값이 들어감
    }

    private void validateDuplicateMember(Member member) {
        List<Member> findMembers = memberRepository.findByName(member.getName());
        //EXCEPTION
        if(!findMembers.isEmpty()) {
            throw new IllegalStateException("이미 존재하는 회원입니다.");
        }
    }

    /**
     * 회원 전체 조회
     */
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    /**
     * 회원 조회
     */
    public Member findOne(Long id) {
        return memberRepository.findOne(id);
    }
}

@Transactional(readOnly = true)
- 메소드 단계에서 readOnly 조건을 주게 되면, DB에게 해당 메소드에서 실행하는 로직은 단순히 읽기만 하니 많은 리소스를 사용하지 말라라는 의미를 줄 수 있다.
- Class 단계에서 Transactional을 사용하면 클래스 내에 있는 메소드에 모두 적용이 된다. 만약 트랜잭션의 조건을 변경하고 싶으면 join 메소드처럼 @Transactional을 걸어놓으면 된다.
@Transactional
- 데이터 변경 시 어떤 이슈에 의해 중간에 오류가 나면 모두 rollback 처리할 수 있도록 해주는 어노테이션이다.
- 데이터 변경 작업이 있으면 무조건 @Transactional을 줘야한다.
validateDuplicateMember()
- 해당 메소드에서 중복체크를 하더라도 멀티 스레드에 의해 회원가입을 동시에 하는 경우가 발생할 수 있다.
- 이런 일을 대비하기 위해서 Member의 Name을 DB에서 유니크한 제약 조건을 걸어두는 것이 좋다.
@Autowired
- 스프링에 의해서 인스턴스의 주입을 받을 수 있다.
- 해당 소스에서는 필드 인젝션 처리한 예이다.
- Setter Injection
  - 필드 인젝션 말고 세터 인젝션 방법도 있는데, 해당 방법을 사용하게 되면 테스트를 짤 때 Mock 객체를 넣어줌으로 원활하게 테스트가 가능하다.
  - ```
  public class MemberService {
   private MemberRepository memberRepository;
   
   @Autowired
   public void setMemberRepository(MemberRepository memberRepository) {
     this.memberRepository = memberRepository;
   }
  }
```
- 하지만 Setter를 사용하게 되면 MemberService가 뜨고 중간에 Setter에 의해서 Repository가 변경되는 경우가 발생할 수도 있다. 그러므로 가장 좋은 방법은 MemberSerivce의 생성자에 인젝션 처리를 하는 것이다.
- 생성자 Injection
- 롬복 사용 Injection

회원 기능 테스트

회원 가입을 성공해야한다.
회원 가입 시 같은 이름이면 예외를 발생시킨다.

@Transactional이 테스트 케이스에 존재하게 되면 기본적으로 Rollback 처리를 한다.

이로 인해서 Repository.save하는 경우 console에 insert는 안보이게 되는데, 만약 insert 하는 것을 보고 싶다면 EntityManager를 테스트 케이스에서 주입 받은 후 flush 처리를 하면 된다.

@Transactional  //rollback이 가능
public class MemberServiceTest {

    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;
  	@Autowired EntityManager em;

    @Test
    public void 회원가입() throws Exception {
        //given
        Member member = new Member();
        member.setName("Lim");

        //when
        Long savedId = memberService.join(member);

        //then
      	em.flush();	//member가 들어간 영속성 컨텍스트가 쿼리로 DB에 반영(강제로 DB에 반영)
        assertEquals(member, memberRepository.findOne(savedId));
    }
}

쿼리에 반영 후 Transactional에 의해서 마지막에 롤백을 하게 된다.
만약 DB에 넣고 싶다면 해당 메소드에 Rollback(false)를 입력해주면 된다.

@Test
@Rollback(false)
public void 회원가입() throws Exception {
      
}

Exception 처리 테스트

@Test
public void 중복_회원_예외() throws Exception {
  //given
  Member member1 = new Member();
  member1.setName("Lim1");
  Member member2 = new Member();
  member2.setName("Lim1");

  //when
  memberService.join(member1);
  try {
    memberService.join(member2); //예외가 발생해야 한다.
  } catch (IllegalStateException e) {
    return;
  }

  //then
  fail("에외가 발생해야 한다.");   //해당 라인을 타게되면 테스트 실패
}

MemberService.join에서 IllegalStateException 예외가 발생하면 catch를 하고 return을 함으로써 fail() 메소드를 안 타게 되어 테스트가 성공하게 된다.

하지만 코드의 복잡성을 줄이기 위해 아래와 같이 작성할 수 있다.

@Test(expected = Exception 종류)를 함으로써 코드를 줄일 수 있다.

@Test(expected = IllegalStateException.class)
public void 중복_회원_예외() throws Exception {
  //given
  Member member1 = new Member();
  member1.setName("Lim1");
  Member member2 = new Member();
  member2.setName("Lim1");

  //when
  memberService.join(member1);
  memberService.join(member2); //예외가 발생해야 한다.

  //then
  fail("에외가 발생해야 한다.");   //해당 라인을 타게되면 테스트 실패
}

전체 소스 확인

@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional  //rollback이 가능
public class MemberServiceTest {

    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;

    @Test
    public void 회원가입() throws Exception {
        //given
        Member member = new Member();
        member.setName("Lim");

        //when
        Long savedId = memberService.join(member);

        //then
        assertEquals(member, memberRepository.findOne(savedId));
    }

    @Test(expected = IllegalStateException.class)
    public void 중복_회원_예외() throws Exception {
        //given
        Member member1 = new Member();
        member1.setName("Lim1");
        Member member2 = new Member();
        member2.setName("Lim1");

        //when
        memberService.join(member1);
        memberService.join(member2); //예외가 발생해야 한다.

        //then
        fail("에외가 발생해야 한다.");   //해당 라인을 타게되면 테스트 실패
    }
}

@RunWith(SpringRunner.class)
- Junit 실행 시 스프링이랑 같이 엮어서 실행하겠다.
@SpringBootTest
- 스프링 부트를 띄운 상태에서 테스트하겠다.
- 해당 어노테이션이 없으면 @Autowired가 모두 실패 한다.
- 스프링 컨테이너 안에서 테스트를 돌리는 것으로 보면 된다.
@Transactional
- 테스트가 끝나면 모두 Rollback 처리를 한다.

메모리 DB 사용
- 실제 사용하는 DB가 아닌 테스트용으로 잠깐 사용할 DB를 메모리를 통해 사용할 수 있다.
- test 패키지 밑에 resources의 패키지를 추가하여 test 할 시에는 메모리 DB를 탈 수 있도록 할 수 있다.
  - 운영 소스인 java 및 resources와 테스트 소스인 test 및 resources가 있을 때 test의 경우 test 밑에 있는 resources의 yml을 바라보게 된다.
- test용 resources/application.yml
  - ```
  spring:
    datasource:
      url: jdbc:h2:mem:test
      username: sa
      password:
        driver-class-name: org.h2.Driver
  
    jpa:
      hibernate:
        ddl-auto: create
      properties:
        hibernate:
  #        show_sql: true
          format_sql: true
        
  logging:
    level:
      org.hibernate.SQL: debug
      org.hibernate.type: trace
  server:
    port: 8083
```
- h2의 경우 h2에서 제공해주는 메모리 DB url을 설정함으로써, 운영 DB 접속 여부에 상관없이 메모리 DB를 활용하여 테스트를 진행할 수 있다.
- 하지만 스프링 부트의 경우 아래 application.yml처럼 모두 주석처리 해줘도 된다. 스프링 부트가 기본적으로 메모리 DB를 제공해준다.
  - ```
  #spring:
  #  datasource:
  #    url: jdbc:h2:mem:test
  #    username: sa
  #    password:
  #      driver-class-name: org.h2.Driver
  #
  #  jpa:
  #    hibernate:
  #      ddl-auto: create
  #    properties:
  #      hibernate:
  ##        show_sql: true
  #        format_sql: true
  
  logging:
    level:
      org.hibernate.SQL: debug
      org.hibernate.type: trace
  server:
    port: 8083
```
- 메모리 DB를 사용하게 되면 마지막에 모두 drop처리를 한다.

[이슈] 스프링 빈 순환 참조 (Error Msg: The dependencies of some of the beans in the application context form a cycle)

메성 — Wed, 20 Oct 2021 14:48:20 +0900

스프링 빈을 참조하는데 A와 B가 서로 참조하는 경우 스프링 빈 순환 참조 문제가 발생할 수 있다.

***************************
APPLICATION FAILED TO START
***************************
Description:
The dependencies of some of the beans in the application context form a cycle:
┌─────┐
| userServiceImpl defined in URL [jar:file:/app.jar!/BOOT-INF/classes!/com/mesung/domain/service/impl/userServiceImpl.class]
↑     ↓
| orderServiceImpl (field private com.meusng.domain.service.userService com.meusng.domain.service.orderServiceImpl.userService)
└─────┘

위 로그처럼 userServiceImpl과 orderServiceImpl에서 서로 참조를 하게 되면, 스프링은 어떤 걸 먼저 생성해야 하는지 모르기 때문에 에러를 뱉어내게 된다.

그래서 임시방편으로 @RequiredArgsConstructor를 주석 처리 후 직접 생성자를 만들어서 순환 참조가 발생되는 빈(orderServiceImpl)에 @Lazy 어노테이션을 줌으로써 지연 로딩을 통해 해결할 수 있다.

public class OrderSerivceImpl implements OrderService {
    private final UserService userService;
  public UserServiceImpl(@Lazy UserService userService) {
    this.userService = userService;
}

[Java8] Optional

메성 — Tue, 28 Sep 2021 21:37:51 +0900

더 자바, Java 8 - 인프런 | 강의

자바 8에 추가된 기능들은 자바가 제공하는 API는 물론이고 스프링 같은 제 3의 라이브러리 및 프레임워크에서도 널리 사용되고 있습니다. 이 시대의 자바 개발자라면 반드시 알아야 합니다. 이

www.inflearn.com

Optional은 언제 사용되는 것인가?

아래 소스를 확인해보자.

public class App {
  public static void main(String[] args) {

    OnlineClass spring_boot = new OnlineClass(1, "spring boot", true);

    Duration studyDuration = spring_boot.getProgress().getStudyDuration();
    //출력을 하면 결과는 어떻게 될까?
    System.out.println(studyDuration);

  }
}

public class OnlineClass {

    private Integer id;
    private String title;
    private boolean closed;
    public Progress progress;

    public OnlineClass(Integer id, String title, boolean closed) {
        this.id = id;
        this.title = title;
        this.closed = closed;
    }

    public Integer getId() {
        return id;
    }

    ...

    public Progress getProgress() {
        return progress;
    }

    public void setProgress(Progress progress) {
        this.progress = progress;
    }
}

public class Progress {

    private Duration studyDuration;
    private boolean finished;

    public Duration getStudyDuration() {
        return studyDuration;
    }

    public void setStudyDuration(Duration studyDuration) {
        this.studyDuration = studyDuration;
    }
}

main을 보면 OnlineClass를 생성 후 OnlineClass에 있는 Progress 인스턴스가 의존하고 있는 Duration을 호출하려는 로직을 가지고 있다.
하지만 결과는 'NullPointerException'이 나타난다.
이유는 당연하다. 현재 OnlineClass의 Progress는 Null이기 때문이다.
그렇다면 이런 이슈를 방지 하기 위해 우리는 기존에 어떻게 체크를 해왔는가?

Optional 전 해결방안(조건문 활용)

public static void main(String[] args) {
  ...
    
  OnlineClass spring_boot = new OnlineClass(1, "spring boot", true);
  Progress progress = spring_boot.getProgress();
  if (progress != null) {
    System.out.println(progress.getStudyDuration());
  }
}

보시는 바와 같이 OnlineClass에서 Progress를 가져온 후 조건문을 통해 null 체크하는 방식을 사용해왔다.
하지만 이런 방식은 개발자 이슈가 나타날 수 있는 경우이다. 즉, 사람이기에 null 체크하는 부분을 잊을 수 있다는 것이다.

Optional 전 해결방안(throw Exception)

public class OnlineClass {
  ...
    
  public Progress getProgress() {
    if (this.progress == null) {
      throw new IllegalStateException();
    }
    return progress;
  }
}

getProgress()할 때 미리 null 체크를 하여 Exception을 던지는 방법이다.
하지만 위 같은 방법을 보면 로직 처리 하는 부분에 Exception을 던지도록 하였는데, 이 방법은 그리 좋은 방법이 아니다.
- 그 이유는, Exception을 발생하도록 하게 되면 Java에서는 Stack Trace를 찍게 된다. 즉, 해당 Exception이 발생하기 까지의 어떤 콜 스택을 거쳐서 Exception이 발생했는지에 대해 찍게 된다. 결과적으로 리소스를 사용하게 된다는 것이다.
- 그러므로 정말 필요한 경우에믄 Exception을 사용해야된다.

Optional 사용 해결방안

public class OnlineClass {
  ...
    
  public Optional<Progress> getProgress() {
  	//progress가 null일 경우 optional.empty()를 반환
    return Optional.ofNullable(progress);
  }
}

public static void main(String[] args) {
  ...
    
  OnlineClass spring_boot = new OnlineClass(1, "spring boot", true);
  spring_boot.getProgress()
                .ifPresent(duration -> {
                    System.out.println(duration.getStudyDuration());
                });
}

Optional 사용 시 주의사항

리턴값으로만 쓰기를 권장한다.

메소드 매개변수 타입으로 쓰지 말아라(매개변수 타입으로 Null이 들어올 수가 있다.)

public void setProgress(Optional<Progress> progress) {
  progress.ifPresent(p -> this.progress = p);
}
//progress 매개변수가 Null로 들어올 경우 위 로직은 다시 NullPoineException이 발생한다. 

//만약 정상적으로 실행하고 싶다면 아래와 같이 한번 더 Null 체크를 해줘야 한다.
if(progress != null) {
    progress.ifPresent(p -> this.progress = p);
}

맵의 키 타입, 인스턴스 필드 타입으로 쓰지 말아라.

Optional을 리턴하는 메소드에서 null을 리턴하지 말아라.
- 굳이 빈값을 리턴하고 싶으면 null을 리턴하지 말고 Optinal.empty()를 리턴하도록 해라
Primitive 용 Optional은 따로 존재한다.
- OptionalDouble, OptionalInt, ...
- 만약 Optional.of(10)을 하게되면 Optional 안에서 박싱, 언박싱을 진행하므로 성능상 이슈가 있을 수 있다.

Optional 주요 사용 메소드

public static void main(String[] args) {

  List<OnlineClass> springClasses = new ArrayList<>();
  springClasses.add(new OnlineClass(1, "spring boot", true));
  springClasses.add(new OnlineClass(2, "spring data jpa", true));
  springClasses.add(new OnlineClass(3, "spring mvc", false));
  springClasses.add(new OnlineClass(4, "spring core", false));
  springClasses.add(new OnlineClass(5, "rest api development", false));
  
}

Optional of()와 ofNullable()
- of(); -> of 메소드 안에 파라미터가 Null이 아님을 확신할 때 사용. 만약 파라미터가 Null이면 NullPointerException 발생
- ofNullable(); -> ofNullable 메소드 안에 파라미터가 Null일수도 있을 경우 사용.

Optional 값 여부 확인

isPresent(); -> Optoinal의 값이 있는지 판단(true/false 반환)(Null이면 NPE)

isEmpty(); (Java 11 부터 제공) -> true/false 반환(Null이면 NPE)

public static void main(String[] args) {

  ...

  //isPresent
  Optional<OnlineClass> spring = springClasses.stream()
    .filter(onlineClass -> onlineClass.getTitle().startsWith("spring"))
    .findFirst();
  boolean present = spring.isPresent();
  System.out.println(present);	//true

  //isEmpty
  Optional<OnlineClass> jpa = springClasses.stream()
    .filter(onlineClass -> onlineClass.getTitle().startsWith("jpa"))
    .findFirst();
	boolean present2 = jpa.isEmpty();
  System.out.println(present2);	//true
}

Optional 값 호출

get(); -> Optional 값 가져옴(Null이면 NPE).

public static void main(String[] args) {
  ...
  Optional<OnlineClass> optional = springClasses.stream()
  			.filter(onlineClass -> onlineClass.getTitle().startsWith("spring"))
		  	.findFirst();

  //get을 통해 Optional의 값을 호출할 수 있음
  OnlineClass onlineClass = optional.get();
  System.out.println(onlineClass.getTitle());	//spring boot
}

위 소스 처럼 get()을 통해 Optional의 값을 호출할 수 있으나, 만약 Optional이 없는 경우에는 어떻게 될까?

public static void main(String[] args) {
  ...
  Optional<OnlineClass> optional = springClasses.stream()
          .filter(onlineClass -> onlineClass.getTitle().startsWith("jpa"))
          .findFirst();

  //get을 통해 Optional의 값을 호출할 수 있음
  OnlineClass onlineClass = optional.get();
  System.out.println(onlineClass.getTitle());	//NoSuchElementException
}

현재 'jpa'로 시작되는 타이틀은 존재하지 않는다. 이런 경우에는 NoSuchElementException으로 RuntimeException이 발생하게 된다. 결과적으로 get()이란 메소드를 사용하는 것은 크게 권장하지 않는다.

Optional 값 있는 경우 해당 값 사용

ifPresent(); -> 값이 있을 경우에만 해당 메소드 로직 수행(Null이면 NPE)

위에서 사용한 get() 메소드 대신 ifPresent()를 사용해보자.

public static void main(String[] args) {
  ...
  Optional<OnlineClass> optional = springClasses.stream()
                  .filter(onlineClass -> onlineClass.getTitle().startsWith("spring"))
                  .findFirst();
  optional.ifPresent(onlineClass -> System.out.println(onlineClass.getTitle()));
  //결과 : spring boot

  Optional<OnlineClass> optional = springClasses.stream()
                  .filter(onlineClass -> onlineClass.getTitle().startsWith("jpa"))
                  .findFirst();
  optional.ifPresent(onlineClass -> System.out.println(onlineClass.getTitle()));
  //결과 : 빈값
}

이 처럼 Optional의 값을 사용하고 싶을 때는 ifPresent를 사용하는 것이 효율적이다.

Optional 값 있는 경우 가져오고, 없는 경우 정의한 값 리턴

orElse(); -> (상수로 이미 만들어져있는 것을 사용할 때 사용하는 것을 권장)(Null이면 NPE)

public static void main(String [] args) {
  Optional<OnlineClass> optional = springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().startsWith("jpa"))
                .findFirst();

  //orElse : 값이 있는 경우 해당 값을 가져오고, 없는 경우 orElse 매개변수에 있는 값을 리턴한다.
  OnlineClass onlineClass = optional.orElse(createNewClass());
  System.out.println(onlineClass.getTitle())
}

private static OnlineClass createNewClass() {
  System.out.println("creating new class");
  return new OnlineClass(6, "New Class", false);
}
//결과
//creating new class
//New Class

위 처럼 값이 없는 경우에는 새롭게 생성한 클래스를 리턴하는 모습을 볼 수 있다.

값이 있는 경우에도 확인해보자.

public static void main(String [] args) {
  Optional<OnlineClass> optional = springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().startsWith("spring"))
                .findFirst();

  //orElse : 값이 있는 경우 해당 값을 가져오고, 없는 경우 orElse 매개변수에 있는 값을 리턴한다.
  OnlineClass onlineClass = optional.orElse(createNewClass());
  System.out.println(onlineClass.getTitle())
}

private static OnlineClass createNewClass() {
  System.out.println("creating new class");
  return new OnlineClass(6, "New Class", false);
}
//결과
//creating new class
//spring boot

여기서 주의해야할 점은, 분명 값이 있는데도 불구하고 새롭게 생성하는 클래스의 로직을 타는 것을 볼 수 있다.
즉, 값이 있든 없든 orElse()에 속해있는 로직은 무조건 탄다.
'create new class' 출력

Optional 값 있는 경우 가져오고, 없는 경우 로직 처리

orElseGet(); -> (동적으로 작업을 해서 만들어야할 경우 사용하는 것을 권장)(Null이면 NPE)

orElse()를 보면 뭔가 찝찝하다.. 값이 있다면 새롭게 생성하는 클래스를 호출하기 싫은데.. 이럴 때 orElseGet()을 사용하면 된다.

public static void main(String [] args) {
  Optional<OnlineClass> optional = springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().startsWith("spring"))
                .findFirst();

  //orElseGet : 값이 있는 경우 해당 값을 가져오고, 없는 경우에만 orElseGet 매개변수에 있는 값을 리턴한다.
  OnlineClass onlineClass = optional.orElseGet(createNewClass());
  System.out.println(onlineClass.getTitle())
}

private static OnlineClass createNewClass() {
  System.out.println("creating new class");
  return new OnlineClass(6, "New Class", false);
}
//결과
//spring boot

Optional 값 있는 경우 가져오고 없는 경우 예외 처리

orElseThrow();

또한, 클래스를 새롭게 생성하지 않고 Exception을 날려줄 수도 있다.(Null이면 NPE)

public static void main(String [] args) {
  Optional<OnlineClass> optional = springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().startsWith("jpa"))
                .findFirst();

  //람다식
  OnlineClass onlineClass = optional.orElseThrow(() -> {
    return new IllegalArgumentException();
  });

  //메소드 레퍼런스
   OnlineClass onlineClass = optional.orElseThrow(IllegalArgumentException::new)
     System.out.println(onlineClass.getTitle())
}

private static OnlineClass createNewClass() {
  System.out.println("creating new class");
  return new OnlineClass(6, "New Class", false);
}

결과적으로 isPresent() 와 get()은 사용하지 않는 것이 좋다.

isPresent(); 와 get(); 대신 ifPresent, orElseGet, orElseThrow등을 사용하라

이유는 get(); isPresent()를 통해서 로직을 구성할 시 코드가 길어지는 것을 볼 수 있다.

public static void main(String [] args) {
  Optional<OnlineClass> optional = springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().startsWith("spring"))
                .findFirst();

//isPresent()와 get() 사용
if(optional.isPresent()) {
  OnlineClass onlineClass = optional.get();
} else {
  OnlineClass onlineClass = createNewClass();
}
//orElseGet() 사용
OnlineClass onlineClass = optional.orElseGet(createNewClass());

Java9에서는 ifPresentOrElse();를 통해 ifPresent와 orElseGet을 동시에 사용할 수 있다.

Optional에 있는 값 필터링

filter();

Optional의 filter() 메소드를 통해 Optional의 조건 값을 줄 수 있다.

public static void main(String [] args) {
  ...
  springClasses.add(new OnlineClass(5, "rest api development", false));

  Optional<OnlineClass> optional = springClasses.stream()
    .filter(onlineClass -> onlineClass.getTitle().startsWith("rest"))
    .findFirst();

  //filter를 통해 optional 안에 있는 값의 조건을 줄 수 있다.
  Optional<OnlineClass> optional1 = optional.filter(onlineClass -> onlineClass.isClosed());
  System.out.println(optional1.isEmpty());
}

//결과 : true

Optional에 있는 값 변환

map();

Optional의 mpa() 메소드를 통해 Optional의 리턴값을 변환할 수 있다.

public static void main(String [] args) {
  ...
  springClasses.add(new OnlineClass(5, "rest api development", false));

  Optional<OnlineClass> optional = springClasses.stream()
    .filter(onlineClass -> onlineClass.getTitle().startsWith("rest"))
    .findFirst();

  //map을 통해 getId()를 호출할 시 Optional<Integer> 형태로 리턴이 된다.
  Optional<Integer> integer = optional.map(onlineClass -> onlineClass.getId());
  System.out.println(integer.isPresent());
}

//결과 : true

flatMap();

map으로 추출 시 Optional<>이 아닌 Opitonal을 한번 더 감싼 Optional<Optional<>>이라면 flatMap을 통해 한번에 Optional<>로 변경할 수 있다.

public class OnlineClass {
  public Optional<Progress> getProgress() {
    return Optional.ofNullable(progress);
  }
}

public static void main(String [] args) {
  ...
  springClasses.add(new OnlineClass(5, "rest api development", false));

  Optional<OnlineClass> optional = springClasses.stream()
    .filter(onlineClass -> onlineClass.getTitle().startsWith("rest"))
    .findFirst();

  //map으로 표현하면 아래와 같다.
  Optional<Optional<Progress>> progress1 = optional.map(onlineClass -> onlineClass.getProgress());
  Optional<Progress> progress2 = progress1.orElse(Optional.empty());

  //flatMap을 사용할 시 쌍으로 되어있는 Optional을 풀 수 있다.
  Optional<Progress> progress = optional.flatMap(onlineClass -> onlineClass.getProgress());
}

Stream의 flatMap()을 사용하는 경우는 input은 하나인데 output이 여러개일 경우 사용하는 것으로서 Optional과는 다르다.
- Ex. input은 하나인데, list1과 list2가 output 되는 경우, flatMap을 사용하여 list1과 list2를 하나의 list로 변경

[Java8] Stream API

메성 — Sat, 14 Aug 2021 16:22:24 +0900

더 자바, Java 8 - 인프런 | 강의

www.inflearn.com

스트림

데이터를 담고 있는 저장소(컬렉션)이 아니다.

스트림이 처리하는 데이터 소스를 변경하지 않는다.

List<String> names = new ArrayList<>();
names.add("mesung");
names.add("ms");
names.add("11st");

Stream<String> stringStream = names.stream().map(String::toUpperCase);
//대문자로 변경하는 로직을 태워도 names의 근본 값들은 변경되지 않는다.

스트림으로 처리하는 데이터는 오직 한번만 처리한다.
- 컨베이어 벨트처럼 한번 지나가면 끝!
무제한일 수도 있다. 단 Short Circuti 메소드를 사용해서 몇개의 리스트만 보겠다라고 제한을 들 수도 있다.)

스트림에는 중간 연산와 종료 연산가 있으며, 중간 단계의 경우 근본적으로 lazy하다.

List<String> names = new ArrayList<>();
names.add("mesung");
names.add("ms");
names.add("11st");

names.stream()
  .map(s -> {
    System.out.println(s);
    return s.toUpperCase(Locale.ROOT);
  });

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

//결과
//==========

lazy한다는 의미는 중간 연산의 경우 종료 연산을 만날 때까지는 실행하지 않고 정의만 한 것이다.
즉, 스트림 파이프 라인을 정의해야 한다! -> 중간 연산와 종료 연산의 조합(무조건 종료 연산이 있어야한다.)

public static void main(String[] args) {
  List<String> names = new ArrayList<>();
  names.add("mesung");
  names.add("ms");
  names.add("11st");

  List<String> collect = names.stream()
    .map(s -> {
      System.out.println(s);
      return s.toUpperCase(Locale.ROOT);
    })
    .collect(Collectors.toList());
  collect.forEach(System.out::println);

  System.out.println("==========");
}

//결과
//mesung
//ms
//11st
//MESUNG
//MS
//11ST
//==========

손쉽게 병렬 처리를 할 수가 있다.

스트림 파이프라인

0 또는 다수의 중간 연산과 한개의 종료 연산으로 구성되어 있다.
스트림의 데이터 소스는 반드시 종료 여난이 실행될 때만 처리된다.

중간 연산

Stream을 리턴한다.
filter, map, limit, skip, sorted

종료 연산

Stream을 리턴하지 않는다.
collect, allMatch, count, forEach, min, max

스트림 사용 예제

문제

직접 풀어보시고 아래 답변 확인하시면 도움이 될 겁니다.

public class App {

    public static void main(String[] args) {

        List<OnlineClass> springClasses = new ArrayList<>();
        springClasses.add(new OnlineClass(1, "spring boot", true));
        springClasses.add(new OnlineClass(2, "spring data jpa", true));
        springClasses.add(new OnlineClass(3, "spring mvc", false));
        springClasses.add(new OnlineClass(4, "spring core", false));
        springClasses.add(new OnlineClass(5, "rest api development", false));

        System.out.println("===================");
        System.out.println("spring 으로 시작하는 수업");

        System.out.println("===================");
        System.out.println("close 되지 않은 수업");

        System.out.println("=========메서드 레퍼런스 사용==========");
        System.out.println("close 되지 않은 수업");

        System.out.println("===================");
        System.out.println("수업 이름만 모아서 스트림 만들기");



        List<OnlineClass> javaClasses = new ArrayList<>();
        javaClasses.add(new OnlineClass(6, "The Java, Test", true));
        javaClasses.add(new OnlineClass(7, "The Java, Code manipulation", true));
        javaClasses.add(new OnlineClass(8, "The Java, 8 to 11", false));

        List<List<OnlineClass>> keesunEvents = new ArrayList<>();
        keesunEvents.add(springClasses);
        keesunEvents.add(javaClasses);

        System.out.println("===================");
        System.out.println("두 수업 목록에 들어있는 모든 수업 아이디 출력");
        // TODO

        System.out.println("===================");
        System.out.println("10부터 1씩 증가하는 무제한 스트림 중에서 앞에 10개 빼고 최대 10개 까지만");
        // TODO

        System.out.println("===================");
        System.out.println("자바 수업 중에 Test가 들어있는 수업이 있는지 확인");
        // TODO

        System.out.println("===================");
        System.out.println("스프링 수업 중에 제목에 spring이 들어간 것만 모아서 List로 만들기");
        // TODO

    }
}

예제 답변

public class App {
    public static void main(String[] args) {

        List<OnlineClass> springClasses = new ArrayList<>();
        springClasses.add(new OnlineClass(1, "spring boot", true));
        springClasses.add(new OnlineClass(2, "spring data jpa", true));
        springClasses.add(new OnlineClass(3, "spring mvc", false));
        springClasses.add(new OnlineClass(4, "spring core", false));
        springClasses.add(new OnlineClass(5, "rest api development", false));

        System.out.println("===================");
        System.out.println("spring 으로 시작하는 수업");
        springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().startsWith("spring"))
                .forEach(onlineClass -> System.out.println(onlineClass.getId()));

        System.out.println("===================");
        System.out.println("close 되지 않은 수업");
        springClasses.stream()
                .filter(onlineClass -> !onlineClass.isClosed())
                .forEach(onlineClass -> System.out.println(onlineClass.getId()));
        System.out.println("=========메서드 레퍼런스 사용==========");
        springClasses.stream()
                .filter(Predicate.not(OnlineClass::isClosed))
                .forEach(onlineClass -> System.out.println(onlineClass.getId()));

        System.out.println("===================");
        System.out.println("수업 이름만 모아서 스트림 만들기");
        springClasses.stream()
                .map(onlineClass -> onlineClass.getTitle())
                .forEach(System.out::println);


        List<OnlineClass> javaClasses = new ArrayList<>();
        javaClasses.add(new OnlineClass(6, "The Java, Test", true));
        javaClasses.add(new OnlineClass(7, "The Java, Code manipulation", true));
        javaClasses.add(new OnlineClass(8, "The Java, 8 to 11", false));

        List<List<OnlineClass>> keesunEvents = new ArrayList<>();
        keesunEvents.add(springClasses);
        keesunEvents.add(javaClasses);

        System.out.println("===================");
        System.out.println("두 수업 목록에 들어있는 모든 수업 아이디 출력");
        //me
        keesunEvents.stream()
                .flatMap(list -> list.stream())
                .forEach(onlineClass -> System.out.println(onlineClass.getId()));

        //keesun
        keesunEvents.stream()
                .flatMap(Collection::stream)
                .forEach(onlineClass -> System.out.println(onlineClass.getId()));


        System.out.println("===================");
        System.out.println("10부터 1씩 증가하는 무제한 스트림 중에서 앞에 10개 빼고 최대 10개 까지만");
        Stream.iterate(10, i -> i + 1)
                .skip(10)
                .limit(10)
                .forEach(System.out::println);

        System.out.println("===================");
        System.out.println("자바 수업 중에 Test가 들어있는 수업이 있는지 확인");
        //me
        keesunEvents.stream()
                .flatMap(list -> list.stream())
                .filter(onlineClass -> onlineClass.getTitle().contains("Java"))
                .filter(onlineClass -> onlineClass.getTitle().contains("Test"))
                .map(onlineClass -> onlineClass.getTitle())
                .forEach(System.out::println);

        //keesun
        boolean test = javaClasses.stream()
                .anyMatch(onlineClass -> onlineClass.getTitle().contains("Test"));
        System.out.println(test);

        System.out.println("===================");
        System.out.println("스프링 수업 중에 제목에 spring이 들어간 것만 모아서 List로 만들기");
        //me
        List<OnlineClass> springClass = springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().contains("spring"))
                .collect(Collectors.toList());
        springClass.forEach(spring -> System.out.println(spring.getTitle()));

        //keesun
        List<String> springTitle = springClass.stream()
                .filter(onlineClass -> onlineClass.getTitle().contains("spring"))
                .map(onlineClass -> onlineClass.getTitle())
                .collect(Collectors.toList());
        springTitle.forEach(System.out::println);

    }
}

flatMap : 다중 리스트를 단일 리스트로 변경할 수 있는 중간 단계

[Spring Boot JPA] 테이블 설계 및 Entity 개발 시 주의사항

메성 — Sat, 14 Aug 2021 14:55:23 +0900

실전! 스프링 부트와 JPA 활용1 - 웹 애플리케이션 개발 - 인프런 | 강의

실무에 가까운 예제로, 스프링 부트와 JPA를 활용해서 웹 애플리케이션을 설계하고 개발합니다. 이 과정을 통해 스프링 부트와 JPA를 실무에서 어떻게 활용해야 하는지 이해할 수 있습니다., 본

www.inflearn.com

테이블 설계

1:N 관계에서는 N 쪽이 무조건 외래키가 존재한다.
일대다, 다대일 양방향 관계에서는 연관관계의 주인을 정해야하는데, 외래키가 있는 쪽을 연관관계의 주인으로 정하는 것이 좋다.
- Ex. 주문과 회원일 경우 주문쪽이 연관관계의 주인
- 연관관계의 주인쪽에 값을 세팅해야지만 값이 변경된다.
- 연관관계의 주인을 FK로 정해야하는데 그 이유는, 연관관계를 맺고 있는 두 테이블(회원과 주문)의 수정작업이 있을 때, FK(주문 테이블쪽의 회원ID)를 수정해야지만 유지보수 측면에서 우수하다. 즉, 주문 테이블의 회원번호가 변경되었으니 회원의 회원번호도 변경된다라는 것을 자연스럽게 인식할 수 있다.
- 회원과 주문사이의 연관관계가 맺어있을 경우 연관관계의 주인은 주문의 회원번호가 되고, 회원의 주문관련컬럼은 단순히 매핑만 되는 것으로 회원쪽 Entity에 매핑 여부를 기입한다.

public class Member {
  //Member 1 : Order N | 이쪽 orderList는 단순히 Order에게 매핑만 된다. orderList가 변경되어도 Order의 FK는 변경되지 않는다.
  @OneToMany(mappedBy = "member")  
    private List<Order> orderList = new ArrayList<>();
}

public class Order {
  //Order N : Member 1 | 해당 값의 변경이 일어날 시 member의 id값도 변경이 일어난다. 
  @ManyToOne  
  @JoinColumn(name = "member_id") //FK
  private Member member;
}

일대일 관계인 경우 FK는 보통 access가 많은 쪽으로 정하면 된다.
- 그렇다면 연관관계의 주인은 FK가 있는 곳으로 잡으면 된다.
- Ex. 주문과 배달의 경우 주문쪽이 access가 많고 해당에 FK를 줄 것이므로 연관관계의 주인은 주문이 된다.

Entity 개발

주요 어노테이션

JPA 내장 타입 세팅

@Embeddable : JPA에 내장되어 있는 타입일 경우 / 본 클래스에 기입
@Embedded : 본 클래스를 의존하는 곳에 기입
@Embeddable이나 @Embedded 둘 중에 하나만 기입되어져 있으면 JPA 내장 타입으로 정의할 수 있다.

@Embeddable
@Getter
public class Address {

    private String city;
    private String street;
    private String zipcode;

    protected Address() {}

    public Address(String city, String street, String zipcode) {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }
}

@Entity
@Getter @Setter
public class Delivery {

    @Id @GeneratedValue
    @Column(name = "delivery_id")
    private Long id;

    @OneToOne(mappedBy = "delivery", fetch = FetchType.LAZY)
    private Order order;

    @Embedded
    private Address address;

    @Enumerated(EnumType.STRING)
    private DeliveryStatus status;  //READY, COMP
}

상속 관계 전략

@Inheritance(strategy = InheritanceType.SINGLE_TABLE)

한 테이블에 모든 item을 때려 박음

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "dtype")
@Getter @Setter
public abstract class Item {

    @Id
    @GeneratedValue
    @Column(name = "item_id")
    private Long id;

	...
    
}

@Inheritance(strategy = InheritanceType.JOINED)
- 정규화된 스타일
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
- 상속하고 있는 item 값들의 테이블들이 세팅되는 방식
- Ex. Album, Book, Movie의 테이블이 생성

Enum 사용시 주의사항

Status를 사용할 때 보통 Enum을 사용하는데, Entity에서 EnumStatus를 세팅할 때 주의해야할 점이 있다.
@Enumerated는 Enum의 타입을 정하는데,

public enum DeliveryStatus {
    READY, COMP
}

@Enumerated(EnumType.STRING) //입력한 그대로 문자타입
private DeliveryStatus status; //READY, COMP

@Enumerated(EnumType.ORDINAL)	//숫자 타입으로 저장됨(default)
private DeliveryStatus status; //READY : 1, COMP : 2

ORDINAL이 디폴트인데 해당 형태로 등록이 되어있을 때 위 처럼 READY와 COMP 사이에 다른 상태가 들어오면 COMP는 2가 아닌 3으로 변경되어 원하는 로직을 구성 못할 수 있다.

Getter와 Setter

실무에서 엔티티의 데이터는 조회할 일이 매우 많으므로 Getter는 열어두는 것이 일반적으로 좋다.
하지만 Setter의 경우는 다르다.
Setter를 호출하게 되면 데이터가 변하므로, Setter를 열어두면 가까운 미래에 엔티티가 변경되는 지점을 찾기가 어려워잔다.
그러므로 Setter 대신 변경 지점이 명확하도록 메소드를 별도로 지정하는 것이 좋다. 아래 코드처럼 Setter 대신 addStock과 removeStock 메소드를 Entity내에 만들어 놓는다.

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "dtype")
@Getter
public abstract class Item {

	...
    
    /**
     * stock 증가
     */
    public void addStock(int quantity) {
        this.stockQuantity += quantity;
    }

    /**
     * stock 감소
     */
    public void removeStock(int quantity) {
        int realStock = this.stockQuantity - quantity;
        if (realStock < 0) {
            throw new NotEnoughStockException("need more stock");
        }
        this.stockQuantity = realStock;
    }
}

Entity의 식별자

보통 Entity의 식별자는 Long id;를 사용하는데 객체의 경우 타입이 존재하므로 어떤 객체의 변수인지 쉽게 구분할 수 있다.
하지만 Table의 경우 타입이 없으므로 @Column을 지정할 때는 객체이름_id로 작성하는 것이 유지보수에 편하다.

@Id @GeneratedValue
@Column(name = "order_id")
private Long Id;

값 타입

@Embeddable
@Getter
public class Address {

    private String city;
    private String street;
    private String zipcode;

    protected Address() {}

    public Address(String city, String street, String zipcode) {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }
}

위 처럼 값 타입의 경우 Setter를 지정하지 않고, 생성자에 값을 모두 초기화해서 변경 불가능한 클래스를 만드는 것이 좋다.
JPA 스펙상 Entity나 임베디드(@Embeddable) 타입은 기본 생성자를 public이나 protected로 두는 것이 좋다.
JPA가 이런 제약(기본 생성자를 만드는 제약)을 두는 이유는 JPA 구현 라이브러리가 객체를 생성할 때 리플렉션 같은 기술을 사용할 수 있도록 지원해야 하기 때문이다.

엔티티 설계 시 주의점

가급적이면 Setter를 사용하지 말자.
- 변경 포인트가 너무 많아서 유지보수가 힘들다.
모든 연관관계는 지연로딩으로 설정해야한다.
- @XToOne인 경우에는 모두 지연 로딩으로 변경해줘야 한다. 기본이 즉시 로딩이므로,
  - 즉시 로딩으로 하게 되면 실무에서 매우 위험할 수 있다.
- //@OneToOne(fetch = FetchType.LAZY) //@ManyToOne(fetch = FetchType.LAZY) public class Order { @ManyToOne(fetch = FetchType.LAZY) //Order N : Member 1 @JoinColumn(name = "member_id") //FK private Member member; }
- member의 fetchType을 LAZY로 안할 경우 order 조회하는 순간 order가 member를 찾게된다.
  - 즉, 100개의 order 쿼리를 조회할 때 각각의 쿼리가 100개의 member 쿼리를 조회하게 된다.
  - 성능 똥망

컬렉션은 필드에서 초기화하자.

List<Order> orderList = new ArrayList<>();

테이블 및 컬럼명 생성 전략.
- 스프링 부트에서는 @Table 및 @Column을 지정하지 않으면 기본 세팅에 따라 변경된다.(SpringPhysicalNamingStrategy)
  - 카멜 케이스 -> 언더 스코어
  - 점 -> 언더 스코어
  - 대문자 -> 소문자
```
private int orderPrice; //주문 가격
//order_pirce로 변경
```

Cascade

public class Order {
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItem> orderItemList = new ArrayList<>();  
}

원래는 OrderItem에 먼저 세팅을 하고 Order를 저장해야하는데, Order에 값들을 저장하게되면 Cascade에 의해서 OrderItem에도 값들이 저장되게 된다.

public class Order {
  @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
  @JoinColumn(name = "delivery_id")
  private Delivery delivery;  
}

Order 저장 시 Delivery도 자동으로 값 저장이 된다.

연관관계 메소드

양방향인 객체들을 저장하려고 할 때 각각의 객체를 생성해서 각각 넣어줘야 한다.

public static void main(String [] args) {
  Member member = new Member();
  Order order = new Order();
  member.getOrders().add(order);
  order.setMember(member);
}

하지만 연관관계 메소드를 작성함으로써 좀 더 간단하게 작성이 가능하다.

public class Order {
  ...
  // ====연관관계 메소드====
  public void setMember(Member member) {
    this.member = member;
    member.getOrders().add(this);
  }

  public void addOrderItem(OrderItem orderItem) {
    orderItemList.add(orderItem);
    orderItem.setOrder(this );
  }

  public void setDelivery(Delivery delivery) {
    this.delivery = delivery;
    delivery.setOrder(this);
  }
  
}

[Mokito] Mock 객체 Stubbing

메성 — Sun, 13 Jun 2021 20:05:16 +0900

Mock 객체 Stubbing

Mock 객체의 행동이란,

리턴 값이 있는 메소드는 모두 Null 을 리턴하고 있다.
- Optional 타입인 경우 Optional.empty로 리턴
Primitive 타입은 모두 Primitive 값을 따르고 있다.
- Ex. Boolean인 경우 'false' / Integer 혹은 Long인 경우 0
Collection의 경우 모두 비어있는 Collection을 가지고 있다.
Void 메소드의 경우 예외를 던지지 않고 아무 일도 발생하지 않는다.

Stubbing이란,

Mock 객체의 행동을 조작하는 것을 말한다.
Mock객체의 when 메소드를 활용하여 Stubbing을 진행해보자.

Ex. 리턴값이 있는 when 메소드 활용 1

@Mock MemberService memberService
memberService.findById(1L);

//위 메소드를 호출할 때 아래와 같은 인스턴스를 받고 싶다면... Mock객체를 통해서 Stubbing을 하여 받을 수 있다.
Member member = new Member();
member.setId(1L);
member.setEmail("abc@gmail.com");

//Mock객체를 Stubbing
Mockito.when(memberService.findById(1L)).thenReturn(Optional.of(member));

Ex. 리턴값이 있는 when 메소드 활용 2(Service단 로직의 리턴값을 Stubbing을 활용하여 반환해보자.)
- studyService.createNewStudy(1L, study)를 호출하여 우리가 선언한 Member 인스턴스의 값이 반환되는 지 확인해보자.
- ```
assertEquals("abc@gmail.com", memberService.findById(1L).get().getEmail());
```
- 그러나 만약 memberService.findById()의 값이 '1L'이 아닌 다른 값이면 stubbing한 Member 인스턴스가 반환되지 않으니 주의해야한다.
- 단, any()를 사용하게 되면 어떤 변수가 들어와도 stubbing한 Member 인스턴스를 반환할 수 있다.
  - assertEquals("abc@gmail.com", memberService.findById(any()).get().getEmail());
  - any() 뿐만 아니라 다양한 ArgumentMatchers 사용 가능
  - https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/ArgumentMatchers.html

mockito-core 3.11.1 javadoc (org.mockito)

Latest version of org.mockito:mockito-core https://javadoc.io/doc/org.mockito/mockito-core Current version 3.11.1 https://javadoc.io/doc/org.mockito/mockito-core/3.11.1 package-list path (used for javadoc generation -link option) https://javadoc.io/doc/org

javadoc.io

Ex. 예외를 던지는 when 메소드 활용 1

//Mockito.when() 활용
when(memberService.findById(1L)).thenThrow(new RuntimeException());

//Mockito.doThrow() 활용
doThrow(new IllegalAccessError()).when(memberService).validate(1L);
assertThrows(IllegalArgumentException.class, () -> {
  memberService.validate(1L);
});

Ex. 리턴값 or 예외를 던지는 when 메소드 활용 (stubbing한 메소드를 반복 호출할 때의 순서에 따른 결과물을 다르게 나타낼 수 있음)

when(memberService.findById(any()))
  .thenReturn(Optional.of(member))
  .thenThrow(new RuntimeException())
  .thenReturn(Optional.empty());

//thenReturn
Optional<Member> byId = memberService.findById(1L);
assertEquals("abc@gmail.com", byId.get().getEmail());

//thenThrow
assertThrows(RuntimeException.class, () -> {
  memberService.findById(2L);
});

//thenReturn
assertEquals(Optional.empty(), memberService.findById(3L));

https://www.inflearn.com/course/the-java-application-test/dashboard

더 자바, 애플리케이션을 테스트하는 다양한 방법 - 인프런 | 강의

자바 프로그래밍 언어를 사용하고 있거나 공부하고 있는 학생 또는 개발자라면 반드시 알아야 하는 애플리케이션을 테스트하는 다양한 방법을 학습합니다., 그냥 개발자를 넘어 '더 나은 개발

www.inflearn.com

[SpringBoot 실습] 등록, 수정, 삭제, 조회 화면 만들기

메성 — Sun, 3 Jan 2021 22:25:28 +0900

등록, 수정, 삭제, 조회 화면 만들기

게시글 등록 화면 만들기

게시글 등록 화면을 만들기 위해 오픈소스 부트스트랩을 사용하겠다.

부트스트랩, 제이쿼리 등 프론트엔드 라이브러리를 사용할 수 있는 방법은 2가지가 있는데, 하나는 외부 CDN을 사용하는 것이고, 하나는 직접 라이브러리를 받아서 사용하는 것이다.

우리는 외부 CDN을 사용하여 프론트엔드를 구현하겠다.

실무에서는 외부 CDN 방식을 사용하지 않는다. 직접 구현해야지!!

레이아웃 방식을 사용하여 부트스트랩과 제이쿼리를 index.mustache에 추가해야한다.

레이아웃 방식 : 공통 영역을 별도의 파일로 분리하여 필요한 곳에서 가져다 쓰는 방식

해당 부트스트랩과 제이쿼리를 머스테치 화면 어디에서다 필요하므로 공통으로 사용되는 레이아웃 파일을 만들어 추가하는 것이 좋다.

src/main/resources/templates 디렉토리에 layout 디렉토리를 추가로 생성한다. footer.mustache, header.mustache 를 추가하겠다.

header.mustache

<!-- header.mustache -->
<!DOCTYPE HTML>
<html>
<head>
    <title>스프링부트 웹서비스</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
</head>
<body>

footer.mustache

<!-- footer.mustache -->
<script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"></script>

</body>
</html>

코드를 보면 css와 js의 위치가 서로 다른 것을 확인할 수 있는데, 이는 페이지 로딩속도를 높이기 위해서 그런 것이다. 즉, css는 header에 위치하고 js는 footer에 위치한 것이다.

HTML의 경우 위에서부터 코드가 실행되므로 head가 다 실행되고 나서야 body가 실행된다. 즉, head가 다 불러지지 않으면 사용자 쪽에서는 백지 화면만 노출되는 것을 볼 것이다.

특히 서비스를 하다보면 js의 용량이 커지게 되는데 크면 클수록 body 부분의 실행이 늦어지기 때문에 js는 body 하단에 두어 화면이 다 그려진 뒤 호출하는 것이 좋다.

반면, css는 당연히 화면을 그리는 역할을 하는 것으로 head에 불러오는 것이 좋다. 추가로 bootstrap.js의 경우 제이쿼리가 필수적이므로 bootstrap.min.js보다 먼저 호출하게 하였다. 이런 상황을 bootstrap.js가 제이쿼리에 의존한다라고 보면된다.

이제 head와 footer를 나누었으니, index.mustache의 코드는 꼭 필요한 코드만 남길 수가 있다.

index.mustache

<!-- index.mustache -->
{{>layout/header}}
    <h1>스프링 부트로 시작하는 웹 서비스</h1>
{{>layout/footer}}}

그럼 이제 index에 글 등록하는 화면을 만들어보자.

index.mustache - version2

{{>layout/header}}
<h1>스프링부트로 시작하는 웹 서비스 Ver.2</h1>
<div class="col-md-12">
    <div class="row">
        <div class="col-md-6">
            <a href="/posts/save" role="button" class="btn btn-primary">글 등록</a>
        </div>
    </div>
</div>
{{>layout/footer}}

a태그를 통해 글 등록 버튼이 생성되었는데, 이 버튼을 클릭 시 이동할 페이지의 주소는 /posts/save가 되는 것이다.

IndexController.java

그럼 /posts/save에 관련된 Controller를 생성하자.

@Controller
public class IndexController {
    ...

    @GetMapping("/posts/save")
    public String postsSave() {
        return "posts-save";
    }
}

posts-save 페이지를 나타낼 posts-save.mustache를 생성하자. 위치는 index.mustache와 동일하다.

posts-save.mustache

{{>layout/header}}

<h1>게시글 등록</h1>

<div class="col-md-12">
    <div class="col-md-4">
        <form>
            <div class="form-group">
                <label for="title">제목</label>
                <input type="text" class="form-control" id="title" placeholder="제목을 입력하세요">
            </div>
            <div class="form-group">
                <label for="author"> 작성자 </label>
                <input type="text" class="form-control" id="author" placeholder="작성자를 입력하세요">
            </div>
            <div class="form-group">
                <label for="content"> 내용 </label>
                <textarea class="form-control" id="content" placeholder="내용을 입력하세요"></textarea>
            </div>
        </form>
        <a href="/" role="button" class="btn btn-secondary">취소</a>
        <button type="button" class="btn btn-primary" id="btn-save">등록</button>
    </div>
</div>

{{>layout/footer}}

그럼 이제 다시 프로젝트를 실행해보자.

하지만 현재는 등록버튼을 눌러도 기능이 존재하지 않아 아무것도 등록할 수가 없다. 그럼 이제 등록을 할 수 있도록 js를 구현해보자.

src/main/resources에 static/js/app 디렉토리를 생성하자.

index.js

const index = {
    init: function () {
        const _this = this;
        $('#btn-save').on('click', function () {
            _this.save();
        });
    },
    save: function () {
        const data = {
            title: $('#title').val(),
            author: $('#author').val(),
            content: $('#content').val()
        };

        $.ajax({
            type: 'POST',
            url: '/api/v1/posts',
            dataType: 'json',
            contentType: 'application/json; charset=utf-8',
            data: JSON.stringify(data)
        }).done(function () {
            alert('글이 등록되었습니다.');
            window.location.href = '/';
        }).fail(function (error) {
            alert(JSON.stringify(error));
        });
    }
};
index.init();

첫 문장을 보면 const index = {...}라는 코드를 선언했는데, 이렇게 선언한 이유에 대해서 살펴보자.

만약 index.js가 아래와 같이 function을 작성한 상황이라면,

const init = function() {
  ...
};

const save = function() {
  ...
};

init();

이런 상황일 때, index.mustache에 a.js가 추가되어 a.js도 a.js만의 init과 save function이 존재한다면 어떨까? 계속 중복된 function들이 존재할 것이다. 이를 방지하기 위해 브라우저 스코프를 사용하게 된다.

브라우저 스코프는 공용 공간으로 쓰이기 때문에 나중에 로딩된 js의 init, save가 먼저 로딩된 js의 function을 덮어쓰게 된다.

여러 사람들이 참여하는 프로젝트에서는 중복된 함수 이름이 자주 발생할 수 있는데, function을 만들 때 모든 function의 이름을 확인하면서 function을 만들 수는 없다. 그러므로, index.js에서만 유효한 범위(스코프)를 만들어 사용하는 것이다. 즉, const index란 객체를 만들어 해당 객체에서 필요한 모든 function들을 선언하게 되고, 해당 function들은 index 객체 안에서만 유효하기 때문에 다른 js와 겹칠 위험이 사라진다.

자 그럼 index.js를 머스테치 파일에서 사용할 수 있도록 footer.mustache에 추가해보자.

footer.mustache

<!-- footer.mustache -->
<script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"></script>

<!--index.js 추가-->
<script src="/js/app/index.js"></script>

</body>
</html>

index.js 호출 코드를 보면 절대 경로(/)로 바로 시작하는데 그 이유는, 스프링 부트는 기본적으로 src/main/resources/static에 위치한 자바스크립트, CSS, 이미지 등 정적 파일들은 URL에서 /로 설정된다.

Ex. url 설정

src/main/resources/static/js/... : http://도메인/js/
src/main/resources/static/css/... : http://도메인/css/
src/main/resources/static/image/... : http://도메인/image/

그럼 이제 게시글 등록을 해보자.

Alert 창이 정상적으로 나왔으니, 이제 DB에 접속하여 데이터가 등록되었는지 확인해보자.

Localhost:8082/h2-console에 접속.

등록 기능이 정상적으로 작동한 것을 확인할 수 있다.

[SpringBoot 실습] 기본 페이지 만들기

메성 — Sun, 3 Jan 2021 22:22:01 +0900

기본 페이지 만들기

index.mustache

이제 첫 페이지륻 담당할 index.mustache를 src/main/resources/templates에 생성해보자.

<!DOCTYPE HTML>
<html>
<head>
    <title>스프링 부트 웹 서비스</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
    <h1>스프링 부트로 시작하는 웹 서비스</h1>
</body>
</html>

IndexController.java

이제 이 머스테치에 URL을 매핑해보자. URL 매핑은 당연히 Controller에서 해야하니 IndexController를 생성하자.

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

머스테치 스타터로 인해 컨트롤러에서 문자열 반환 시 앞의 경로와 뒤의 파일 확장자는 자동으로 지정이 된다. 앞의 경로는 src/main/resources/templates이고, 뒤의 파일 확장자는 .mustache가 붙는 것이다.

IndexControllerTest.java

그럼 이제 코드가 완성되었으니 테스트 코드로 검증해보자.

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class IndexControllerTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void roadMain() {
        //when
        String body = this.restTemplate.getForObject("/", String.class);

        //then
        assertThat(body).contains("스프링 부트로 시작하는 웹 서비스");
    }
}

이번 테스트는 URL 호출 시 페이지의 내용이 제대로 호출되는 지에 대한 테스트이다.

TestRestTemplate을 통해 "/"로 호출이 되면 index.mustache에 포함된 코드들이 있는지 확인하게 된다.

이제 서버를 실행 후 localhost:8082로(포트번호 8082로 설정)로 접속해보면 아래와 같이 index.mustache로 만든 페이지가 성공적으로 브라우저에 나타난다.

[SpringBoot 실습] 서버 템플릿 엔진과 머스테치 소개

메성 — Sun, 3 Jan 2021 22:19:30 +0900

서버 템플릿 엔진과 머스테치 소개

이번에는 머스테치(Mustache)를 통해 화면 영역을 개발하는 방법을 배워보자.

템플릿 엔진이란 무엇인가?

웹 개발에 있어 템플릿 엔진이란, 지정된 템플릿 양식과 데이터가 합쳐져 HTML 문서를 출력하는 소프트웨어를 이야기한다. 예전 스프링이나 서블릿을 사용했다면, JSP, Freemaker 등이 떠오를테고 요즘은 리액트, 뷰 등이 떠오를 것이다.

이것들 모두 결과적으로는 지정된 템플릿과 데이터 를 이용하여 HTML을 생성하는 템플릿 엔진이다.

다만 약간의 다른 점이 있는데,

서버 템플릿 엔진 : JSP, Freemaker
클라이언트 템플릿 엔진 : 리액트, 뷰

만약 아래와 같은 코드가 주어진다면 결과는 어떻게 되는 지 생각해보자.

<script type="text/javascript">

  $(document).ready(function() {
    if(a=="1") {
      <%
          System.out.println("test");
      %>
    }
  });

해당 코드는 if문에 상관없이 무조건 test가 콘솔에 출력된다. 그 이유는 프론트 엔드의 자바스크립트가 작동하는 영역과 JSP가 작동하는 영역이 서로 다르기 때문인데, JSP를 비롯한 서버 템플릿 엔진은 서버에서 구동되는 것이다.

서버 템플릿 엔진을 이용한 화면 생성은 서버에서 Java 코드로 문자열을 만든 뒤 이 문자열을 HTML로 변환하여 브라우저로 전달 한다. 앞 코드를 다시 보면, HTML을 만드는 과정에서 System.out.println("test");를 실행할 뿐이고, 이때 자바스크립트 코드는 단순한 문자열일 뿐이다.

서버 템플릿 엔진

Server(Java 코드 실행) -> Java 코드 실행값 + HTML(JavaScript 문자)를 브라우저에서 실행

반면, 자바스크립트는 브라우저 위에서 작동한다

앞 코드에서 자바스크립트 코드가 실행되는 장소는 서버가 아닌 브라우저 이다. 즉, 브라우저에서 작동될 때는 서버 템플릿 엔진의 손을 벗어나 제어가 불가능한 것이다.

클라이언트 템플릿 엔진인 리액트나 뷰를 이용한 SPA는 브라우저에서 화면을 생성하므로, 서버에서 JSON 혹은 xml 형식으로 데이터만 전달하고 클라이언트에서 조립하는 방식을 사용하는 것이다.

클라이언트 템플릿 엔진

Server(Java 코드 실행) -> JSON || XML 형식으로 반환 -> JSON + HTML(JavaScript(VUE, REACT))를 브라우저에서 실행

예로, 최근엔 리액트가 뷰와 같은 자바스크립트 프레임워크에서 서버 사이드 렌더링을 지원하는 것을 볼 수 있다. 이 방식은 자바스크립트 프레임워크의 화면 생성 방식을 서버에서 실행하는 것을 말한다. 다만, 스프링 부트를 사용하면 자바스크립트를 서버사이드에서 렌더링하도록 구현하는 것은 많은 비용이 들므로 현재는 추천하지 않는다.

머스테치란

머스테치(http://mustache.github.io)는 수많은 언어를 지원하는 가장 심플한 템플릿 엔진이다. 이 엔진은 대부분의 언어를 지원하고 있어 자바에서 사용될 때는 서버 템플릿 엔진으로 사용되고, 자바스크립트에서 사용될 때는 클라이언트 템플릿 엔진으로 사용될 수 있다.

템플릿 엔진의 단점들을 살펴보자.

JSP, Velocity : 스프링 부트에서는 권장하지 않는다.

Freemarker : 템플릿 엔진으로는 과하게 많은 기능을 지원한다.

Thymeleaf : 스프링에서 적극적으로 밀고 있으나 문법이 어렵다. 하지만 vue.js를 사용해본 경험이 있어 태그 속성 방식이 익숙하면 Thymeleaf도 사용하면 좋다.

머스테치의 장점을 살펴보자.

문법이 다른 템플릿 엔진보다 심플하다.
로직 코드를 사용할 수 없어 View의 역할과 서버의 역할이 명확히 구분된다.
Mustache.js와 Mustache.java 2가지가 다 있어, 하나의 문법으로 클라이언트/서버 템플릿을 모두 사용 가능하다.

템플릿 엔진은 화면 역할에만 충실한 것이 가장 좋다. 많은 기능을 제공하고 있으면 API와 템플릿 엔진, 자바스크립트가 서로 로직을 나눠 갖게 되어 유지보수할 때 어려운 점을 겪을 수 있다.

머스테치 플러그인 설치

Plugins -> Handlebars/Mustache 설치 -> 인텔리제이 재시작

프로젝트에서 머스테치를 사용할 수 있도록 의존성을 build.gradle에 등록

compile('org.springframework.boot:spring-boot-starter-mustache')

일반적으로 머스테치의 파일 위치는 기본적으로 src/main/resource/templates이고, 이 위치에 머스테치 파일을 두면 스프링 부트에서 자동으로 로딩한다.

[The Java] 프록시 패턴

메성 — Sun, 3 Jan 2021 22:15:04 +0900

프록시 패턴이란,

프록시는 대리한다 라는 개념으로 리얼 서브젝트를 참조하고 있다.
서브젝트는 인터페이스로서 프록시와 리얼 서브젝트가 공유하고 있고, 클라이언트는 서브젝트 인터페이스 타입으로 프록시를 사용한다.
클라이언트는 프록시를 거쳐 리얼 서브젝트를 사용하기 때문에 프록시는 리얼 서브젝트에 대한 접근을 관리하거나 부가기능을 제공하고 리턴값을 변경할 수도 있다.
리얼 서브젝트는 자신이 해야할 일만 하면서(SRP) 프록시를 이용해 부가적인 기능(접근제한, AOP, 로깅, 트랜잭션)을 제공할 수 있다.
- 부가적인 기능마저 리얼 서브젝트에서 제공해주면 매우 복잡해지고 객체지향적 개념에서도 벗어나게 된다.

프록시 패턴을 소스로 확인해보자

//BookService
public interface BookService {
  void rent(Book book);
}

//BookServiceProxy
public class BookServiceProxy implements BookService {
  BookService bookService;

  public BookServiceProxy(BookService bookService) {
    this.bookService = bookService;
  }

  @Override
  public void rent(Book book) {
    System.out.println("aaaa");
    bookService.rent(book);
    System.out.println("bbbb");
  }
}

//DefaultBookService
public class DefaultBookService implements BookService{
  public void rent(Book book) {
    System.out.println("rent : " + book.getTitle());
  }
}

//Test
public class BookServiceTest {
  //BookServiceProxy가 DefaultBookService를 참조하기 위해 파라미터를 받음
  BookService bookService = new BookServiceProxy(new DefaultBookService());

  @Test
  public void di() {
    Book book = new Book();
    book.setTitle("spring");
    bookService.rent(book);
  }
}

실행결과
결과에서도 확인하듯이, 리얼 서브젝트(DefaultBookService)의 수정없이 프록시(BookServiceProxy)의 수정으로 결과값이 변경되는 것을 볼 수 있다.

프록시의 단점

부가적인 기능이나 서브젝트에 위임하는 작업이 중복 될 수가 있다.

//BookServiceProxy
public class BookServiceProxy implements BookService {
  BookService bookService;

  public BookServiceProxy(BookService bookService) {
    this.bookService = bookService;
  }

  @Override
  public void rent(Book book) {
    System.out.println("aaaa");
    bookService.rent(book);
    System.out.println("bbbb");
  }

  //1.
  @Override
  public void rent2(Book book) {
    System.out.println("bbbb");
    bookService.rent(book);
    System.out.println("cccc");
  }

     //2.
  @Override
  public void renturnBook(Book book) {
    System.out.println("aaaa");
    bookService.renturnBook(book);
    System.out.println("bbbb");
  }
}

부가적인 기능은 다르나 서브젝트에 위임하는 작업이 중복된다.
부가적인 기능은 동일한데 메소드 호출하는 부분이 달라 부가적인 기능들이 중복으로 발생할 수 있다.

이를 방지하기 위해 매번 프록시에 해당하는 클래스를 만들지 않고, 동적으로 런타임에 생성하는 방법인 다이나믹 프록시를 활용한다.