
<div align="center">
<img src="https://user-images.githubusercontent.com/45007556/134035096-80c16de9-e250-4745-b6e0-9fe03a4d0c95.png" width="300" height="350">
</div>

사실 Vue.js에 관심은 있었지만, React를 깔짝대고 있었기 때문에 굳이 손댈 필요성은 못 느꼈었지만, 감사하게도 호기심에 지원했던 서평단에 당첨되어 서평을 남겨 보려고 한다.

# 목차

큰 목차만 나열하면 아래와 같다.

- Vue.js에 대한 소개
- Vue 환경 설치
- Vue 3 기초
- TodoList 애플리케이션 개발
- 웹 애플리케이션 프로젝트 준비
- Vue 3 추가 라이브러리 사용
- 프로젝트 업그레이드
- AWS를 이용한 프로젝트 배포

# 후기

이 책은 Vue 3에 대한 책이지만, Vue 2를 경험해 보지 못했더라도 한번 훑어볼 수 있을 정도로 Vue 2와 Vue 3 버전의 차이점도 명확하게 짚어주고, 여러 예시로 2 버전과 호환될 수 있도록 두 가지 버전을 다뤄주면서 Vue 2로 개발해오던 개발자들과 Vue 3으로 Vue에 입문하는 입문자들을 위한 배려가 잘 되어 있는 것 같다.

Vue의 개념만으로는 바로 개발하기에는 조금 부족한 면이 있는데, 이를 위해 토이 프로젝트 TodoList, Blog 프로젝트 등 2개나 진행하기 때문에 구성에서도 알차며 설명도 매우 친절한 편인 것 같다. 마지막으로 직접 개발한 토이 프로젝트를 AWS를 통해 배포까지 해볼 수 있기 때문에 Vue.js에 입문하려는 개발자나 기존 개발자 모두에게 괜찮은 책이 될 것 같다.


한 권으로 배우는 Vue.js 3 서평단 리뷰


# SOLID란?

객체지향 설계는 긴 세월과 수많은 시행착오를 거치며 5가지 원칙이 정리되었다. 이것은 객체지향 설계의 5원칙이라고 하며, 앞글자를 따서 SOLID라고 한다.

- SPR(Single Responsibility Principle) : 단일 책임 원칙
- OCP(Open Closed Principle) : 개방 폐쇄 원칙
- LSP(Liskov Substitution Principle) : 리스코프 치환 원칙
- ISP(Interface Segregation Principle) : 인터페이스 분리 원칙
- DIP(Dependency Inversion Principle) : 의존 역전 원칙

이 원칙들은 응집도는 높이고 결합도는 낮추자는 고전 원칙을 객체 지향의 관점에서 재정립한 것으로 볼 수 있다.

# SRP(단일 책임 원칙)

- 하나의 클래스는 하나의 책임만 가져야한다.
- 하나의 클래스가 변경되는 이유는 하나여야 한다.
- 하나의 모듈은 오직 하나의 액터에 대해서만 책임져야 한다

# OCP(개방 폐쇄 원칙)

- 확장에는 열려 있어야 한다.
- 변경에는 닫혀 있어야 한다.

# LSP(리스코프 치환 원칙)

- 자식 클래스는 언제나 자신의 부모 클래스를 대체할 수 있어야 한다.

# ISP(인터페이스 분리 원칙)

- 한 클래스는 자신이 사용하지 않는 인터페이스는 구현하지 말아야 한다.
- 하나의 일반적인 인터페이스보다는, 여러 개의 구체적인 인터페이스가 낫다.

# DIP(의존관계 역전 원칙)

- 구체적이고 불안정한 저수준의 클래스에 의존해서는 안된다.


SOLID(객체지향 설계 원칙) 5가지 정리


리눅스에서 텍스트 편집을 할 때면 그나마 접근성이 좋았던 nano 에디터를 이용해왔는데, nano는 별도로 설치해야 사용할 때도 있고, Vim 에디터 기능이 더 좋은 것 같아 Vim 에디터 명령어를 정리해 보려고 한다.

# 에디터 모드

- 명령 모드 (command mode) - 다양한 명령을 내리는 모드이다
- 입력 모드 (insert mode) - 텍스트를 자유롭게 편집하는 모드이다
- EX 모드 (ex mode) - vi의 특별한 명령어를 실행하기 위한 모드이다
- ~~비쥬얼 모드 (visual mode) - 이런 게 있다곤 하지만 잘 모르겠고, 몰라도 될 것 같다~~

# 명령 모드에서 입력 모드로 전환

Vim 에디터를 실행하면 처음엔 명령 모드이므로 아래 키워드 중 하나를 입력하면 입력 모드로 전환이 가능하다.

- a : 커서 다음(오른쪽)에 입력
- A : 행 마지막 부분에 입력
- i : 커서 앞(왼쪽)에 입력
- I : 행 처음 부분에 입력
- o : 커서 밑에 빈 행을 추가하여 입력
- O : 커서 위에 빈 행을 추가하여 입력
- s : 커서에 있는 글자를 지우고 입력

# 입력 모드에서 명령 모드로 전환

명령 모드에서 입력 모드로 들어왔으니 반대로 &#60;ESC&#62; 키를 통해 나가는 것이 가능하다.

아래 명령어는 명령 모드에서 사용할 수 있는 명령어들이다.

## 커서 이동

- h, j, k, l : 좌, 하, 상, 우 커서 이동하기 (방향 키가 없는 키보드에서 사용)
- w : 다음 단어의 첫 글자로 이동하기
- b : 이전 단어의 첫 글자로 이동하기
- G : 마지막 행으로 가기
- :숫자 : 지정한 숫자 행으로 이동하기

## 삭제

삭제된 내용은 버퍼에 저장되어 붙여넣기가 가능하다.

- x : 커서에 있는 글자 삭제하기
- X : 커서 앞에 있는 글자 삭제하기
- dw : 커서를 기준으로 뒤에 있는 단어 글자 삭제하기 (커서 포함) (ex: 5dw)
- db : 커서를 기준으로 앞에 있는 단어 글자 삭제하기 (ex: 7db)
- dd : 커서가 있는 라인(줄) 삭제하기 (ex: 9dd)

## 복사

- yw : 커서를 기준으로 뒤에 있는 단어 글자 복사하기 (커서 포함)
- yb : 커서를 기준으로 앞에 있는 단어 글자 복사하기
- yy : 커서가 있는 라인(줄) 복사하기

명령 앞에 복사할 숫자를 지정할 수 있다. ex) 3yw, 2yb, 4yy

## 붙여넣기 (복사, 삭제된 내용을 붙여 넣는다)

- p : 커서 다음에 붙여넣기
- P : 커서 이전에 붙여넣기

## 찾기

- /문자열 : 앞에서부터 문자열을 찾기
- ?문자열 : 뒤에서부터 문자열을 찾기
- n : 뒤로 검색
- N : 앞으로 검색

## 바꾸기

- :%s/old/new - 각 행의 처음 나오는 old를 찾아 new로 바꾸기
- :%s/old/new/g - 모든 old를 찾아 new로 바꾸기
- :%s/old/new/gc - 모든 old를 찾아 new로 바꾸기 전에 물어본다

## 되돌리기(Undo), 다시 실행(Redo)

- u : 이전으로 되돌리기
- Ctrl + r : 되돌리기 한 것은 다시 실행하기

# EX 모드

명령 모드 상태에서 :(콜론)을 입력한 명령어를 지원한다.

## 저장, 나가기

- :q - 종료하기
- :q! - 저장하지 않고 그냥 강제로 종료하기
- :w - 저장하기
- :w 파일명 - 현재 편집 중인 내용을 지정한 파일명으로 저장하기
- :w >> 파일명 - 현재 편집 중인 내용을 지정한 파일의 내용에 추가하기
- :w! - 강제로 내용을 저장하기
- :wq - 저장하고 종료하기
- :wq! - 강제로 저장하고 종료하기
- :x - 파일 내용이 변경된 경우 저장 후 종료하기
- ZZ - 저장하고 종료하기 (:wq와 동일)

## 유용한 기능들

- :set number, :set nu - 행번호를 출력하기
- :set nonumber, :set nonu - 행번호를 숨기기
- :cd - 현재 디렉토리를 출력하기

# 참고

[https://blog.lael.be/post/7321](https://blog.lael.be/post/7321)  
[https://dololak.tistory.com/379](https://dololak.tistory.com/379)


Vim 에디터 명령어 정리


GoDaddy에서 구매해서 1년간 잘 써오던 블로그 도메인이 10월 만료가 다가오면서 갱신을 해야 하는 시점이 왔다. 그런데 처음 무료로 제공해 줬던 SSL 인증서가 별도로 76000원가량의 개별 요금을 받게 되면서 마침 도메인 업체도 바꾸려고 했던 차에 NameCheap으로 이전하게 되면 더욱 저렴하다고 생각해서 NameCheap으로 이전하게 되었다.

# 도메인 이전 방법

이전하는데 불과 5분도 채 걸리지 않을 정도로 간단했는데, 우선 GoDaddy에서 도메인 설정에서 "GoDaddy에서 도메인 전출 이전"이라는 것을 눌러 이전 신청을 해주면 되는데 그럼 아래와 같은 화면이 표출된다. 이 화면에서 발급해 주는 승인 코드라는 것만 복사하면 된다.
![image](https://user-images.githubusercontent.com/45007556/133927755-09b60dd3-d096-43e6-8d62-446888da2d0a.png)

이제 GoDaddy에서 도메인 이전 승인코드를 복사했으면, NameCheap에서 "Transfer to Us" 메뉴로 들어가 이전할 도메인을 입력해 주면 아래와 같은 화면이 나오는데, 여기 승인 코드 입력란에 GoDaddy에서 발급해 준 승인 코드를 넣어주고, 결제만 해주면 성공적으로 GoDaddy에서 NameCheap로 이전 신청이 완료되게 된다.
![image](https://user-images.githubusercontent.com/45007556/133927766-731f6448-e766-44f4-9a09-810f3f00b405.png)


블로그 도메인 GoDaddy에서 NameCheap으로 이전


코드를 작성하면서 'Naming'은 간과하기 쉽지만 중요하면서도 잘 짓기가 어려운 것 같다. 하지만 커밋을 할 때의 커밋 메시지의 중요성은 대수롭지 않게 생각을 했었는데, 커밋 컨벤션을 한번 정해보고, 좋은 커밋 메시지를 작성하기 위해 커밋 메시지 컨벤션에 대해서 정리해본다.

# 커밋 메시지 구조

```
type:Subject

body

footer
```

## 커밋 유형(Commit Type)

- add - 단순 파일 추가
- feat - 새로운 기능 추가
- fix - 버그 수정
- design - CSS 등 사용자 UI 디자인 변경
- style - 코드 포맷 변경, 세미 콜론 누락, 코드 수정 X
- refactor - 프로덕션 코드 리팩토링
- comment - 필요한 주석 추가 및 변경
- docs - 문서를 수정
- test - 테스트 추가, 테스트 리팩토링(프로덕션 코드 변경 X)
- rename - 파일 혹은 폴더명을 수정하거나 옮기는 작업
- remove - 파일을 삭제하는 작업만 수행
- build - 빌드 시스템에 변화가 있거나 외부 라이브러리 추가
- ci - CI 관련 설정 수정
- chore - 위의 커밋 유형 이외, 빌드 테스크 업데이트, 패키지 매니저를 설정하는 경우(프로덕션 코드 변경 X) 등

## 제목(Subject)

1. 제목과 본문을 한 줄 띄워 분리하기
2. 제목은 영문 기준 50자 이내로 작성하기
3. 제목 첫글자를 대문자로 작성하기
4. 제목 끝에 "." 붙이지 않기
5. 제목은 명령조로 작성하기

## 본문(Body)

1. 선택 사항이므로 작성하지 않아도 무방하다
2. 부연 설명이 필요하거나 커밋의 이유를 전달해야 할 경우 작성한다
3. 본문은 어떻게 보다 무엇을, 왜에 맞춰 작성하기
4. 한 줄이 72자를 넘기지 않도록 줄을 바꿔준다

## 푸터(Footer)

1. 선택 사항이므로 작성하지 않아도 무방하다
2. 주로 이슈 트래커 아이디 참조로 사용된다

# 예시

```
feat: Summarize changes in around 50 characters or less

More detailed explanatory text, if necessary. Wrap it to about 72
characters or so. In some contexts, the first line is treated as the
subject of the commit and the rest of the text as the body. The
blank line separating the summary from the body is critical (unless
you omit the body entirely); various tools like `log`, `shortlog`
and `rebase` can get confused if you run the two together.

Explain the problem that this commit is solving. Focus on why you
are making this change as opposed to how (the code explains that).
Are there side effects or other unintuitive consequenses of this
change? Here's the place to explain them.

Further paragraphs come after blank lines.

 - Bullet points are okay, too

 - Typically a hyphen or asterisk is used for the bullet, preceded
   by a single space, with blank lines in between, but conventions
   vary here

If you use an issue tracker, put references to them at the bottom,
like this:

Resolves: #123
See also: #456, #789
```

## 직접 써본 예시

```
fix: 도라에몽이 쥐를 무서워하는 버그 수정

도라에몽이 쥐를 잡아야 하지만, 쥐를 무서워하여 작동이 멈추는 버그가 있어 쥐를 무서워하지 않도록 버그를 수정

Resolves: #123
See also: #456, #789
```

# 참고

[https://meetup.toast.com/posts/106](https://meetup.toast.com/posts/106)  
[https://webruden.tistory.com/486](https://webruden.tistory.com/486)


좋은 커밋 메시지를 위한 컨벤션


요즘 많은 개발자들이 TDD에 대해 얘기하면서 개발자들의 관심을 많이 받고 있는 TDD에 대해 간단 정리해 보려고 한다.

# 테스트 주도 개발(Test Driven Development)

소프트웨어 개발 방법론 중의 하나로, *개발->테스트 방식*이 아닌 *테스트->개발하는 방식*의 프로그래밍 방법을 말한다.  
짧은 개발 주기의 반복에 의존하는 개발 프로세스이며, 애자일 방법론 중 하나인 eXtream Programming(XP)의 ‘Test-First’ 개념에 기반을 둔 단순한 설계를 중요시한다.

# TDD 장점

- 소프트웨어 설계의 모듈화
- 유지보수가 쉬운 코드
- 코드 리팩토링의 원활화
- 코드의 문서화
- 디버깅 용이
- 장기적으로 프로젝트 비용의 감소

# TDD 단점

- 생산성 저하
- TDD 접근법은 배우기 어려움
- 테스트 코드 유지 관리의 어려움

# TDD의 효과

- 피드백
  - 테스트를 통해 작업의 성공 & 실패 유무를 결정하고 이에 따라 피드백을 얻을 수 있다.
- 협력
  1. TDD는 기록을 남긴다.
  2. 기록으로 남은 테스트 코드를 남들에게 보여줄 수 있고, 남들은 테스트 코드를 직접 실행해 볼 수 있다.
  3. 다른 사람의 코드에 쉽게 접근이 가능하고, 이해가 빨라지며 다른 사람의 코드 의도를 쉽게 확인할 수 있다.
  4. 그렇게 되면 쉽게 협력을 이끌어낼 수 있다.

# TDD 개발 주기

<div align="center">
    <img src="https://user-images.githubusercontent.com/45007556/132956654-ce6707e2-51d4-4485-8fc6-20f709573c93.png" width="500">
</div>

1. &#60;<span style="color:red;">Red</span>&#62; - 실패하는 테스트 코드를 먼저 작성한다.
2. &#60;<span style="color:green;">Green</span>&#62; - 테스트 코드를 성공시키기 위한 실제 코드를 작성한다.
3. &#60;<span style="color:blue;">Blue</span>&#62; - 중복 코드 제거, 일반화 등의 리팩토링을 수행한다.

개발 주기를 조금 더 풀어서 쓰면

1. 존재하지도 않는 메소드를 호출하는 테스트 코드를 먼저 만든다. (이때는 빨간 줄 범벅으로 테스트 실행이 안됨)
2. 테스트 실행만 되도록 메소드 껍질만 만들어서 실행시킨다.
3. jUnit의 빨간 막대가 나타난다. (구현이 안 된 껍데기만 있기 때문에 테스트 실행은 되지만 실패한다)
4. 2번에서 만들어둔 메소드의 내부 구현을 완성하여 똑같은 코드를 다시 실행시킨다.
5. 빨간 막대 대신 성공을 알리는 녹색 막대가 나타난다. (끝)
6. 리팩토링


테스트 주도 개발(TDD)이란?


[JUnit5로 스프링 프로젝트 효과적으로 테스트하기](https://www.gunlog.dev/spring-project-test)에서 JUnit를 통해 전반적으로 테스트를 해보는 방법에 대해서 작성했는데, 사실 이 테스트 방법은 그리 좋은 방법은 아니다. 왜냐하면 [Unit Test 원칙](https://medium.com/@tasdikrahman/f-i-r-s-t-principles-of-testing-1a497acda8d6)을 제대로 준수하지 않았고, 사실상 단위 테스트가 아니라 통합 테스트이기 때문이다. 이번에는 Slice Test와 Mocking 기법을 적용하여 지난번에 작성한 테스트를 좋은 단위 테스트로 바꿔보려고 한다. [예제 코드](https://github.com/gunkims/spring-example/tree/master/project-slice-test)

# Spring Boot 슬라이스 테스트

## 슬라이스 테스트란?

테스트를 위해 생성된 ApplicationContext를 분할해서 테스트를 하는 것을 말한다.

## 슬라이스 테스트를 하는 이유

@SpringBootTest 어노테이션을 사용하게 되면 실제 구동되는 애플리케이션의 설정, 모든 Bean을 로드하기 때문에 시간이 오래 걸리고 무거다. 그리고 테스트 단위가 크기 때문에 정작 테스트하려는 코드가 아닌 다른 곳에서 오류가 날 수 있어 디버깅이 어려운 편이다.
결과적으로 웹을 실행시키지 않고 테스트 코드를 통해 빠른 피드백을 받을 수 있다는 장점이 희석된다.

따라서 단위 테스트에 있어서 @SpringBootTest를 사용하를 하게 될 경우 자연스럽게 통합 테스트가 되게 된다.

## 슬라이스 테스트를 위한 어노테이션들

슬라이스 테스트를 위한 많은 어노테이션을 지원하니 알아뒀다가 사용하면 될 것 같다.

- @DataCassandraTest
- @DataJdbcTest
- @DataJpaTest
- @DataLdapTest
- @DataMongoTest
- @DataNeo4jTest
- @DataR2dbcTest
- @DataRedisTest
- @JdbcTest
- @JooqTest
- @JsonTest
- @RestClientTest
- @WebFluxTest
- @WebMvcTest
- @WebServiceClientTest

# Mocking 관련 어노테이션 및 메서드

## @Mock VS @MockBean

이번 예제에서는 스프링 컨테이너에 등록해야 하기 때문에 @MockBean을 사용해 테스트를 진행한다.

@Mock - 목 객체가 스프링 컨테이너에 등록되지 않아도 될 경우 사용

@MockBean - 목 객체를 스프링 컨테이너에 등록해야 할 경우 사용

## org.mockito.Mockito.when()

특정 메서드가 실행될 경우 특정 값을 반환하게 하고 싶을 경우 사용한다. Mocking 객체는 껍데기만 있는 것이기 때문에 실질적인 구현을 여기다가 한다고 보면 된다.

# Repository 테스트

```java
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByName(String name);
}
```

```java
@ExtendWith(SpringExtension.class)
@DataJpaTest
public class UserRepositoryTests {
    @Autowired
    private UserRepository userRepository;

    @Test
    @DisplayName("이름으로 유저 정보 조회 테스트")
    public void findByNameTest() {
        String name = "gunkim";
        int age = 22;
        userRepository.save(User.builder()
                .name(name)
                .age(age)
                .build());

        User user = userRepository.findByName(name).get();

        assertThat(user.getName(), is(equalTo(name)));
        assertThat(user.getAge(), is(equalTo(age)));
    }
}
```

Repository에서 개인적으로 findAll(), findById() 등 기본적으로 제공하는 메서드를 제외한 커스텀 메서드를 테스트하면 된다. 이전 코드와 다른 점은 @SpringBootTest -> @DataJpaTest 로 변경해서 Jpa 관련 Bean들만 스프링 컨텍스트에 로드하여 Slice Test를 하게 되므로 테스트 속도 실행 속도가 빠르게 된다.

# Service 테스트

```java
@RequiredArgsConstructor
@Service
public class UserServiceImpl implements UserService {
    private final UserRepository userRepository;

    @Override
    public UserInfoResponseDto selectUserInfo(String name) throws IllegalArgumentException {
        User user = userRepository.findByName(name)
                .orElseThrow(() -> new IllegalArgumentException(name+": 유저를 찾지 못했습니다."));
        return new UserInfoResponseDto(user);
    }
}
```

```java
@ExtendWith(SpringExtension.class)
public class UserServiceTests {
    private UserService userService;
    @MockBean
    private UserRepository userRepository;

    @BeforeEach
    public void setup() {
        this.userService = new UserServiceImpl(userRepository);
    }

    @Test
    @DisplayName("이름으로 유저 정보 조회 테스트, entity -> dto 변환")
    public void selectUserInfo() {
        String name = "gunkim";
        int age = 22;
        when(userRepository.findByName(any(String.class))).thenReturn(Optional.of(User.builder()
                .name(name)
                .age(age)
                .build()));

        UserInfoResponseDto dto = userService.selectUserInfo(name);
        assertThat(dto.getName(), is(equalTo(name)));
        assertThat(dto.getAge(), is(equalTo(age)));
    }
}
```

@SpringBootTest 어노테이션을 제거하고, Mock객체(가짜 객체)를 주입하여 Service 객체를 테스트한다. 이렇게 되면 불필요한 Spring Bean들을 로드하지 않게 되어 실행 속도도 빨라지고 Service가 의존하고 있는 Repository 객체를 가짜 객체로 Mocking하여 Service 로직만을 온전히 테스트할 수 있게 된다.

# Controller 테스트

```java
@RequiredArgsConstructor
@RestController
@RequestMapping("/api/user")
public class UserController {
    private final UserService userService;

    @GetMapping
    public ResponseEntity<UserInfoResponseDto> getUserInfo(@RequestParam("username") String name) throws IllegalArgumentException {
        return ResponseEntity.ok(userService.selectUserInfo(name));
    }
}
```

```java
@ExtendWith(SpringExtension.class)
@WebMvcTest(UserController.class)
public class UserControllerTests {
    @Autowired
    private MockMvc mockMvc;
    @Autowired
    private ObjectMapper objectMapper;

    @MockBean
    private UserService userService;

    @Test
    @DisplayName("/api/user 테스트")
    public void getUserInfoApiTest() throws Exception {
        String name = "gunkim";
        int age = 22;
        when(userService.selectUserInfo(any(String.class))).thenReturn(UserInfoResponseDto.builder()
                .name(name)
                .age(age)
                .build());

        MvcResult result = mockMvc.perform(MockMvcRequestBuilders.get("/api/user")
                .param("username", name))
                .andExpect(status().isOk())
                .andDo(print())
                .andReturn();

        UserInfoResponseDto dto = objectMapper.readValue(result.getResponse().getContentAsString(), UserInfoResponseDto.class);
        assertThat(dto.getName()).isEqualTo(name);
        assertThat(dto.getAge()).isEqualTo(age);
    }
}
```

Service 테스트와 다를 게 없다. 다만 @SpringBootTest -> @WebMvcTest(UserController.class)로 변경되었다.

# 마지막으로

통합 테스트가 필요한 경우가 아니라면 슬라이스 테스트를 하도록 하자


[Spring] JUnit5로 Mocking 및 슬라이스 테스트하기


<div align="center">
    <img src="https://user-images.githubusercontent.com/45007556/132622531-bd6075f6-2edb-48a7-888d-77e70323fdd3.png" width="300" height="350">
</div>

이 책은 군대 훈련소에서 오랜만에 재밌게 완독한 책 중 하나인데, 그냥 독후감 겸 리뷰를 한번 써보려고 한다.

# 목차
- 01 | 협력하는 객체들의 공동체
- 02 | 이상한 나라의 객체
- 03 | 타입과 추상화
- 04 | 역할, 책임, 협력
- 05 | 책임과 메시지
- 06 | 객체 지도
- 07 | 함께 모으기
- 부록 A | 추상화 기법
- 부록 B | 참고 문헌

```java
객체지향의 목표는 실세계를 모방하는 것이 아니다.
오히려 새로운 세계를 창조하는 것이다.
```

이 책은 객체지향에 대해 개발자들이 가지고 있는 편견이나 오해들을 단번에 시원하게 깨트려주는 책이다. 객체지향이라는 개념을 처음 배울 때부터 객체지향이 뭔가요? 하면 돌아오는 대답은 객체를 지향하는 것이고, 현실 세계 모든 것은 객체이며 그런 것들을 지향하는 것이다~라는 다소 추상(?)적인 이야기를 들어왔고, 조금 의문은 남지만 그렇게 모호한 개념을 탑재한 채 개발을 해왔다.

# 건물의 방화벽과 네트워크의 방화벽
이 이야기는 책에서 나온 비유를 인용한 것이다. 

- 건물의 방화벽은 말 그대로 건물 내에 불이 번지는 것을 막기 위한 방화벽이다.
- 네트워크의 방화벽은 네트워크 침입을 막는 것이다.

일단, 의미적 거리만큼이나 소프트웨어 객체와 실세계 사물 사이에 존재하는 연관성은 희미하다.

그렇다면 객체지향은 무엇일까?

→ **객체지향의 목표는 실세계를 모방하는 것이 아니다! 오히려 새로운 세계를 창조하는 것이다.**

내가 이 책을 읽고 감명 깊었던 부분에 대해 설명을 하자면 현실 세계에서 **나**라는 객체가 **음료수**를 마시는 행위를 한다고 했을 때 음료수의 양(곧 상태 값)을 조절하는 주체는 **나**이지만, 객체지향 세계에서 **나**라는 객체가 **음료수**를 마시는 행위를 할 때 음료수의 양은 곧 상태 값으로 이 값을 줄이는 주체는 **음료수** 자신이어야 한다는 것이다. 그러면 음료수는 **나**라는 객체가 음료수 마시는 행위를 했을 때 음료수의 양을 줄이는 행위를 해야 하는데 객체지향 세계에서는 오직 한 가지의 의사소통만이 존재한다 바로 "메시지"인데, **나**라는 객체가 음료수 객체에게 "메시지"를 전송하면, **음료수** 객체는 메시지를 수신하여 메시지를 처리한다. 

곧 객체는 시스템 행위를 구현하기 위해 다른 객체와 협력하며, 각 객체는 협력 내에서 정해진 역할을 수행하고, 역할은 관련된 책임의 집합이라고 볼 수 있다.

그렇기 떄문에 객체는 충분히 협력적이어야 하며, 자율적(스스로의 원칙에 따라 어떤 일을 하거나 자기 스스로를 통제하여 절제하는 것)이어야 한다는 점에서 현실 세계의 객체와 차이점이 있다.

=> 곧 객체지향 프로그래밍에서 중요한 것은 클래스의 구조, 메서드가 아니라 객체의 역할, 책임, 협력에 집중해야 한다는 것이다.

이 책은 객체지향을 역할,책임,협력 관점에서 잘 설명하고 있어 객체지향 프로그래밍을 하는 개발자라면 꼭 한번 읽어보길 추천한다.

객체지향의 사실과 오해 리뷰


이번엔 JPA를 사용하면서 가장 편하다고 생각하는 Auditing라는 기능의 사용 방법에 대해서 정리해보려고 한다.
[예제 프로젝트](https://github.com/gunkims/spring-example/tree/master/jpa-auditing)

# 주요 어노테이션

자동화할 수 있는 요소는 생성시간, 수정시간, 생성한 사람, 수정한 사람에 대한 정보인데 관련 어노테이션을 먼저 알아보면.

- @MappedSuperclass - JPA Entity 클래스들이 해당 추상 클래스를 상속할 경우 추상 클래스 필드를 컬럼으로 인식하도록 함.
- @EntityListeners(AuditingEntityListener.class - 해당 클래스에 Auditing 기능을 포함
- @CreatedDate - Entity가 생성되어 저장될 때 시간이 자동 저장
- @LastModifiedDate - 조회한 Entity의 값을 변경할 때 시간이 자동 저장
- @EnableJpaAuditing - Auditing 활성화

# Auditing란?

도메인을 디자인하다 보면 꼭 공통되는 요소들이 있는데 바로 누가 언제 했는지 등에 대한 기록을 남기는 컬럼들이 있다. 이러한 컬럼들은 도메인마다 어쩔 수 없이 중복이 될 수밖에 없는데, Auditing 기능을 사용하게 되면 이 컬럼들을 자동화시킬 수 있게 된다.

# Auditing가 값을 채워주는 시점

```java
@Configurable
public class AuditingEntityListener {
	private @Nullable ObjectFactory<AuditingHandler> handler;

	public void setAuditingHandler(ObjectFactory<AuditingHandler> auditingHandler) {

		Assert.notNull(auditingHandler, "AuditingHandler must not be null!");
		this.handler = auditingHandler;
	}
	@PrePersist
	public void touchForCreate(Object target) {

		Assert.notNull(target, "Entity must not be null!");

		if (handler != null) {

			AuditingHandler object = handler.getObject();
			if (object != null) {
				object.markCreated(target);
			}
		}
	}
	@PreUpdate
	public void touchForUpdate(Object target) {

		Assert.notNull(target, "Entity must not be null!");

		if (handler != null) {

			AuditingHandler object = handler.getObject();
			if (object != null) {
				object.markModified(target);
			}
		}
	}
}
```

Auditing는 값을 언제 채워주는 걸까? 라는 궁금증에 찾아보았는데 AuditingEntityListener라는 녀석을 살펴보면 알 수 있다.
AuditingEntityListener는 Spring Data Jpa가 구현한 EntityListener로 `@PrePersist` `@PreUpdate` 어노테이션을 통해 저장, 수정 등을 엔티티가 영속화되기 전에 값을 채워준다.

# build.gradle 의존성 추가

```gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.h2database:h2'
}
```

# 생성시간, 수정시간 자동화

## BaseEntity.java

```java
@Getter
@ToString
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public class BaseEntity {
    @CreatedDate
    private LocalDateTime createdDate;
    @LastModifiedDate
    private LocalDateTime modifiedDate;
}
```

해당 필드들이 컬럼으로 인식될 수 있도록 `@MappedSuperclass`와 Auditing 적용을 위한 `@EntityListeners`을 작성해 주었고, 각각 생성시간, 수정시간 필드에 `@CreatedDate`, `@LastModifiedDate` 어노테이션을 붙여주었다.

## Posts.java

```java
@Getter
@ToString(callSuper = true)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class Posts extends BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotNull
    private String title;

    @NotNull
    private String contents;

    @Builder
    public Posts(Long id, @NotNull String title, @NotNull String contents) {
        this.id = id;
        this.title = title;
        this.contents = contents;
    }
}
```

Auditing 테스트를 위한 엔티티를 작성해 주었다. 만들었던 BaseEntity를 상속만 받아주면 Posts 엔티티에서는 Auditing를 사용할 준비는 끝이다.

## Application.java

```java
@EnableJpaAuditing
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

마지막으로 Application에 `@EnableJpaAuditing` 어노테이션을 붙여주어 Auditing를 활성화해주게 되면 간단하게 설정이 끝난다.

## 테스트 코드 작성

```java
@Slf4j
@ExtendWith(SpringExtension.class)
@SpringBootTest
public class PostsRepositoryTests {
    @Autowired
    private PostsRepository postsRepository;
    @Autowired
    private MemberRepository memberRepository;

    private static final String USERNAME = "gunkim";

    @Test
    @DisplayName("게시글 입력 테스트")
    public void saveTest() {
        postsRepository.save(Posts.builder()
                .title("첫 게시글입니다.")
                .contents("게시글 내용입니다.")
                .build());

        Posts posts = postsRepository.findAll().get(0);
        log.info("POSTS : "+posts);

        assertThat(posts.getTitle()).isEqualTo("첫 게시글입니다.");
        assertThat(posts.getContents()).isEqualTo("게시글 내용입니다.");
    }
}
```

## 확인

![image](https://user-images.githubusercontent.com/45007556/127148456-00a754a7-2a06-4115-8ef1-478ef42a1f8f.png)
테스트 코드를 실행하면 테스트가 성공하는 것과 생성일자, 수정일자가 자동으로 채워진 것을 확인할 수 있다.

# 생성자, 수정자 자동화

보통 생성자, 수정자는 DB에 insert나 update를 하는 사람의 아이디를 넣는 경우가 많은데, 스프링의 경우 시큐리티를 통해 아이디를 가져오는 식으로 구현한다. 그래서 이 부분도 자동화가 가능한데 그 방법에 대해 알아보려고 한다.

## build.gradle

```gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
    testImplementation 'org.springframework.security:spring-security-test'
}
```

스프링 시큐리티 환경에서 테스트를 위한 시큐리티 의존성을 추가해 준다.

## BaseEntity.java

```java
@Getter
@ToString
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public class BaseEntity {
    @CreatedDate
    private LocalDateTime createdDate;
    @LastModifiedDate
    private LocalDateTime modifiedDate;
    @CreatedBy
    @ManyToOne
    private Member createdMember;
    @LastModifiedBy
    @ManyToOne
    private Member modifiedMember;
}
```

아까 만들었던 BaseEntity에서 다대일의 연관관계를 맺는 createdMember, modifiedMember 엔티티를 추가해 주었다. `@CreatedBy`, `@LastModifiedBy` 어노테이션에 의해 값이 들어가게 될 것이다.

## Member.java

```java
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@ToString
public class Member extends BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @NotNull
    private String username;
    @NotNull
    private String password;
    @NotNull
    private Integer age;

    @Builder
    public Member(Long id, @NotNull String username, @NotNull String password, @NotNull Integer age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }
}
```

이번엔 테스트를 위해 유저 엔티티가 필요하기 때문에 정의해 주었다.

## UserAwareAudit.java

```java
@Component
@RequiredArgsConstructor
public class UserAwareAudit implements AuditorAware<Member> {
    private final MemberRepository memberRepository;

    @NotNull
    @Override
    public Optional<Member> getCurrentAuditor() {
        Authentication authentication = Optional.ofNullable(SecurityContextHolder.getContext().getAuthentication())
                .orElseThrow(() -> new BadCredentialsException("로그인되지 않았습니다."));
        if (!authentication.isAuthenticated()) {
            return Optional.empty();
        }

        User user = (User) authentication.getPrincipal();
        return memberRepository.findByUsername(user.getUsername());
    }
}
```

시간의 경우 아무런 커스텀 없이 자동으로 해주었지만, 이번에는 값 매핑을 위한 클래스를 작성해 주어야 한다. UserAwareAudit는 스프링 시큐리티에서 인증 정보를 꺼내어 멤버 엔티티를 조회 후 리턴해주게 되는데 이 값이 createdMember, modifiedMember에 들어가게 된다.
이 부분은 자유롭게 커스텀이 가능하기 때문에 커스텀 해서 사용해도 된다.

## 테스트 코드 작성

```java
@Slf4j
@ExtendWith(SpringExtension.class)
@SpringBootTest
public class PostsRepositoryTests {
    @Autowired
    private PostsRepository postsRepository;
    @Autowired
    private MemberRepository memberRepository;

    private static final String USERNAME = "gunkim";

    @BeforeEach
    public void createUser() {
        memberRepository.save(Member.builder()
                .username(USERNAME)
                .password("gunkim")
                .age(22)
                .build());
    }

    @Test
    @DisplayName("게시글 입력 테스트")
    @WithMockUser(username = USERNAME)
    public void saveTest() {
        postsRepository.save(Posts.builder()
                .title("첫 게시글입니다.")
                .contents("게시글 내용입니다.")
                .build());

        Posts posts = postsRepository.findAll().get(0);
        log.info("POSTS : "+posts);

        assertThat(posts.getTitle()).isEqualTo("첫 게시글입니다.");
        assertThat(posts.getContents()).isEqualTo("게시글 내용입니다.");
        assertThat(posts.getCreatedMember().getUsername()).isEqualTo(USERNAME);
        assertThat(posts.getModifiedMember().getUsername()).isEqualTo(USERNAME);
    }
}
```

아까 작성했던 테스트 코드에 Member 엔티티 입력과 시큐리티 테스트를 위한 `@WithMockUser` 어노테이션, 그리고 마지막으로 검증을 하는 코드를 추가해 주었다. `@WithMockUser` 어노테이션은 시큐리티 로그인한 것과 같은 상태에서 테스트를 하게 해준다.

## 확인

![image](https://user-images.githubusercontent.com/45007556/127164870-21e6c42e-0984-4bf6-9b4d-b394d6b56520.png)
정상적으로 생성한 회원, 수정한 회원의 정보가 자동으로 들어가는 것을 확인할 수 있다.


JPA Auditing 적용하기(공통 요소 자동화하기)


# Key Promoter X
[Key Promoter X](https://plugins.jetbrains.com/plugin/9792-key-promoter-x)
![](https://plugins.jetbrains.com/files/9792/screenshot_17105.png)
마우스로 단축키가 지정되어 있는 탭 같은 곳을 클릭했을 때 그 단축키를 팝업으로 알려주는 플러그인. 솔직히 뜨는 게 신경 쓰이긴 하지만 자주 쓰는 키를 모두 외운 후 삭제하면 되므로 추천한다.

# Lombok
[Lombok](https://plugins.jetbrains.com/plugin/6317-lombok/)    
사람들이 Java를 기피하게 만든 원인. 매번 필수적으로 작성하는 getter, setter 등을 작성하지 않도록 지원해 준다. 이 플러그인은 요즘엔 인텔리제이를 깔면 자동으로 깔려있을 정도로 필수라고 볼 수 있다.

# Rainbow Brackets
[Rainbow Brackets](https://plugins.jetbrains.com/plugin/10080-rainbow-brackets)
![이미지](https://plugins.jetbrains.com/files/10080/screenshot_17373.png) 괄호, 중괄호별로 색깔을 다르게 주어 구분하기 편하게 도와준다.

# Advanced Java Folding
[Advanced Java Folding](https://plugins.jetbrains.com/plugin/9320-advanced-java-folding)
![image](https://user-images.githubusercontent.com/45007556/124851144-ebfda580-dfdc-11eb-80ed-ef261b28f784.png) 자바의 장황함을 개선한 최신 JVM언어(코틀린, 스칼라)들이 있다. 이 플러그인을 쓴다면 그 언어들과 비슷하게 간결하게 보여주어 조금 더 집중해야 할 곳에 집중할 수 있게 만들어준다.(실제 코드가 수정되지 않음)

# .ignore
[.ignore](https://plugins.jetbrains.com/plugin/7495--ignore)
![](https://plugins.jetbrains.com/files/7495/screenshot_14958.png) 보통 git과 같은 곳에 올라가지 말아야 할 파일이 있을 때 ignore를 직접 생성하여 작성해 준다. 허나 이 플러그인을 쓰게 되면 쉽게 ignore를 작성할 수 있다.

# Translator
[Translator](https://plugins.jetbrains.com/plugin/9690-translator)
![](https://plugins.jetbrains.com/files/9690/screenshot_17011.png)
가끔 메소드나 변수 이름을 지을 때 영단어가 생각이 안 날 때가 있다. 이 플러그인은 그런 상황에서 매우 혁신적이다..!

# CodeGlance2
[CodeGlance2](https://plugins.jetbrains.com/plugin/15562-codeglance2)
<img width="400" src="https://user-images.githubusercontent.com/45007556/124854589-82809580-dfe2-11eb-921b-4a321677d9c3.png"/>
인텔리제이에서 vscode처럼 우측에 코드 미니맵을 표시해 준다.

# Prettier
[Prettier](https://plugins.jetbrains.com/plugin/10456-prettier)  
이 플러그인은 JS 기반 프론트 개발할 때 유용한 플러그인인데, 정해진 코딩 스타일에 맞게 코드를 자동으로 변환해 준다. 만약 프론트 개발을 인텔리제이로 한다면 필수라고 생각한다.

# 디자인 플러그인
## Atom Material Icons
[Atom Material Icons](https://plugins.jetbrains.com/plugin/10044-atom-material-icons)  
밋밋한 인텔리제이 아이콘을 이쁘게 만들어준다.

## One Dark theme
[One Dark theme](https://plugins.jetbrains.com/plugin/11938-one-dark-theme)  
![](https://plugins.jetbrains.com/files/11938/screenshot_19494.png)
개인적으로 선호하는 테마로 아이콘 팩과 같이 쓰면 더욱 이쁘다.

인텔리제이(IntelliJ) 플러그인 추천


<div align="center">
<img src="https://user-images.githubusercontent.com/45007556/123545996-dba42a00-d795-11eb-932c-9ea66160fd8d.jpeg" width="300" height="350">
</div>
메인 언어를 Java를 써왔는데, Node.js를 그동안은 그냥 필요할 때나 찾아 쓰는 정도였는데, 조금 더 잘 사용해보고 싶은 생각을 평소에 가지고 있었다. 그러던 중 영진닷컴에서 서평단 모집을 한다기에 신청을 해보았는데 당첨되어 이 리뷰를 (기한 다 채워서) 작성하게 되었다.(조금 늦어서 죄송합니다...)

솔직히 바이블이라는 이름은 그냥 듣기에는 약간 오만(?) 하다는 생각이 들 수도 있다. 그런데 책 내용을 보니 인정하지 않을 수가 없었는데 놀랍게도 생성, 구조, 행위 패턴부터 Node.js에서 자주 사용하는 여러 비동기-콜백, 패턴 등 이 책 한 권에 이 모든 걸 갖췄다는 점에서 조금 놀라웠다.(책 두께만 봐도 놀람)

대게 많은 바이블이라고 불리는 책들이 그렇 듯이 이 책 또한 Node.js의 철학부터 이야기한다. 어떠한 언어가 추구하는 가치, 철학은 매우 중요한데 이는 언어를 배우면서 이해를 더욱 용이하게 만들어 준다.
이 책에서 소개하는 Node.js의 철학은

- 작은 것이 아름답다.
- 각 프로그램은 한 가지 역할만 잘하도록 만드는 것

으로 요약할 수 있을 것 같다. 프로그램을 작게 쪼개고, 한 가지 역할만 하게 만드는 것은 솔직히 개발하면서 느낀 것이지만 정말 어려운 가치이지만 이 책을 정독하면 이러한 철학을 직접 코드에 녹여낼 수 있을 것 같다고 느꼈고, 무엇보다 자바스크립트를 조금 사용해본 사람들은 `콜백지옥`이라는 이야기를 많이 들어봤듯이 콜백과 비동기 이벤트에 대한 패턴들도 자세히 다루고 있으니 Node.js를 보다 깊이 사용하고 싶은 사람이라면 구매해보는 것을 추천한다. 대신 이 책은 초보자들이 읽기에는 조금 장벽이 있는 것 같으니 그 점 감안하면 될 것 같다.


Node.js 디자인 패턴 바이블 서평단 책 후기


<div align="center">
<img src="https://user-images.githubusercontent.com/45007556/121104992-23dac700-c83e-11eb-97e9-6037e694ed3e.png" width="300" height="350">
</div>

사실 내가 서점에 갈 때마다 살펴봤던 도서인데, 이번에 운 좋게 길벗 출판사에서 이 책이 Node 14 버전으로 개정판이 나오면서 서평단에 선정되어 책을 제공받아 리뷰를 작성해보려고 한다. [yes24](http://www.yes24.com/Product/Goods/91860680)

일단 내가 책을 고르는 기준으로는

- 책이 흐물거리지 않는 재질인가
- 그립감이 괜찮은가
- 가독성이 좋은가
- 책 표지 재질이 튼튼한가
- 기승전결이 괜찮은가(목차 구성)

기준들을 보면 재질이나 그립감 가독성 등을 중요하게 생각하는데 은근히 이런 것들이 좋은 책들이 좋은 책인 경우가 더 많았고 한 번이라도 더 읽게 되기 때문이다. 그런 점에서 이 책은 내 기준에서는 충분히 합격점이라고 볼 수 있다.

# 기본부터 시작하는 설명

보통 예제 중심의 입문서의 경우 바로 프레임워크 사용부터 들어가는 경우가 많은데, 이 책은 js(es6)와 Node.js 기초부터 해서 http 모듈을 경험해보고, Express에 대한 내용 전개가 들어간다.
그래서 초보자의 입장에서 express가 왜 편한 건지, 이 라이브러리는 어떤 점을 개선한 것인지 등에 대한 이해도를 더 깊게 가져갈 수 있을 것 같아서 좋았다.

# 실무 위주의 토이 프로젝트

개념 위주로만 되어 있다면 이 기술을 배워서 어디다가 쓰는지 의문점이 들 수도 있을 것 같은데, 이 책은 실무 지식까지 놓치지 않는다. No-sql부터 rds, 클라우드 배포까지 설명과 함께 따라 할 수 있는 프로젝트가 있으니 직접 만들어가면서 흥미를 유지할 수 있어서 좋았던 것 같다.

# 백엔드 중심

나는 그동안 Node.js는 프론트엔드 프레임워크를 사용할 때만 사용해왔었는데, 이번 백엔드 위주의 Node.js를 설명하는 책을 보면서 매우 재미있었다. 왜냐하면 자주 쓰는 자바 스프링에 비해 작성하는 코드가 매우 적어서 좋았는데, 대신 Rest Api에 대한 내용이 조금 부족한 것 같아서 아쉬웠다. 근데 어쩔 수 없는 것이 Rest Api까지 다루게 되면 프론트엔드까지 필연적으로 설명이 들어가야 하기 때문에 불필요한 내용이 들어가게 된다. 이 부분은 책을 완독한 사람이라면 독자적으로 인터넷을 통해 추가 공부할 수 있을 거라고 생각한다.

# 총평

이 책은 충분히 입문자가 보기에 충분한 책이고, Node.js(Express)로 구현하는 실무 위주의 코드와 함께 설명을 제공하는 좋은 책임에 틀림이 없는 것 같다. 그리고 Node.js 책의 경우 선택지가 많이 없기도 하다🤣

책에 대한 자세한 설명은 다른 분들이 많이 해놓기도 했고, 책 소개로도 충분히 짐작이 가능하기 때문에 전체적인 느낌 위주로 한번 작성해보았다. 당연히 Node.js 책이기 때문에 JavaScript를 잘 모르는 사람의 경우 조금 어려울 수 있지만, 기존에 JavaScript를 조금 다뤄본 사람이라면 충분히 재미있게 읽으며 ⭐️ 5개를 줄 수 있을 것 같다.


Node.js 교과서 서평단 책 후기


오늘은 평소 운영하는 개발자 단톡방을 보고 있다가 JUnit으로 테스트하는 방법을 잘 모르는 사람이 생각보다 엄청 많은 것 같아서 JUnit5로 테스트하는 과정을 한번 포스팅해보려고 한다. [예제 프로젝트](https://github.com/gunkims/spring-example/tree/master/project-test)

# 전통적(?)인 테스트 방법

주변에 개발자들을 둘러보면 일상처럼 이런 방법으로 테스트를 하는데, 예를 들어 DAO를 작성하고 이를 테스트하기 위해 아래와 같은 방법으로 진행한다.

> DAO를 작성 > Service 인터페이스 작성 > Impl 클래스 생성 > 컨트롤러 생성 > 톰캣 서비스 구동 > 웹페이지에 url을 쳐보고 오류가 나는지 확인

어차피 개발자 입장에서는 결국에는 모두 작성해야 하는 코드들이지만, 이 방법은 DAO 하나를 테스트해보기 위해 쓸데없이 여러 클래스를 작성해야 하고, 매번 서비스를 올려서 직접 수동으로 테스트를 하기 때문에 시간이 오래 걸리는 데다 오류가 나더라도 그게 DAO 자체의 문제인지 아니면 컨트롤러, 서비스 클래스들을 생성하다가 실수를 한 것인지 확인해야 하기 때문에 DAO를 온전히 테스트를 하기 어렵다. 혹시나 자신은 이러한 방법으로 테스트를 하고 있진 않은지 생각해 보도록 하자.

# JUnit5로 테스트하기

지금부터는 사용자 테스트 방법이 아닌 개발자답게 JUnit5를 통한 단위 테스트하는 방법에 대해 알아보겠다.

아래와 같은 요구 사항이 있을 때는 나는 작은 단위부터 만들어서 큰 단위로 결합해나가는 식으로 개발을 한다. 보통 `DAO > Service > Controller` 정도로 이해하면 될 것 같다.

> 요구사항 : api 작성 : username을 받아 해당 유저 정보를 조회하는 API를 만들어라

## Repository(DAO) 테스트

```java
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByName(String name);
}
```

간단하게 이름을 받아 유저 엔티티를 조회하는 메소드를 작성해주었다. 이제 이를 테스트해보겠다.

```java
@ExtendWith(SpringExtension.class)
@SpringBootTest
public class UserRepositoryTests {
    @Autowired
    private UserRepository userRepository;

    @Test
    @DisplayName("이름으로 유저 정보 조회 테스트")
    public void findByNameTest() {
        //준비
        String name = "gunkim";
        int age = 22;
        userRepository.save(User.builder()
                .name(name)
                .age(age)
                .build());

        //실행
        User user = userRepository.findByName(name).get();

        //단언
        assertThat(user.getName(), is(equalTo(name)));
        assertThat(user.getAge(), is(equalTo(age)));
    }
}
```

JUnit으로 테스트를 준비(Arrange)-실행(Act)-단언(Assert) AAA 패턴이라고 불리는 형태로 작성을 한다. 이 방법은 테스트를 가시적이고 일관성 유지하기 용이하도록 해준다.
준비 단계에서는 테스트를 위한 값을 준비해 주었고, 실행 단계에서는 직접 테스트가 필요한 메소드를 실행해 주고, 단언 단계에서는 실제 실행되어 메소드로부터 반환된 값을 검증하게 된다. 만약 이 단계에서 반환값이 예상되는 값과 다를 경우 테스트가 실패하게 된다.

## Service 테스트

```java
@RequiredArgsConstructor
@Service
public class UserServiceImpl implements UserService {
    private final UserRepository userRepository;

    @Override
    public UserInfoResponseDto selectUserInfo(String name) throws IllegalArgumentException {
        User user = userRepository.findByName(name)
                .orElseThrow(() -> new IllegalArgumentException(name+": 유저를 찾지 못했습니다."));
        return new UserInfoResponseDto(user);
    }
}
```

JPA에서 엔티티는 테이블 그 자체라고 볼 수 있기 때문에 서비스 밖으로 가져갈 경우 어디서 변경이 될지 모르기 때문에 dto로 값만을 내보내 주도록 구현해 주었다.
Java 8 버전부터 지원해 주는 Optional을 잘 사용해 주면 깔끔한 코드와 Null 처리가 가능해진다.

```java
@ExtendWith(SpringExtension.class)
@SpringBootTest
public class UserServiceTests {
    @Autowired
    private UserService userService;
    @Autowired
    private UserRepository userRepository;

    @Test
    @DisplayName("이름으로 유저 정보 조회 테스트, entity -> dto 변환")
    public void selectUserInfo() {
        //준비
        String name = "gunkim";
        int age = 22;
        userRepository.save(User.builder()
                .name(name)
                .age(age)
                .build());

        //실행
        UserInfoResponseDto dto = userService.selectUserInfo(name);

        //단언
        assertThat(dto.getName(), is(equalTo(name)));
        assertThat(dto.getAge(), is(equalTo(age)));
    }
}
```

이전에 했던 Repository 테스트와 동일하게 테스트해주면 된다.

## Controller 테스트

```java
@RequiredArgsConstructor
@RestController
@RequestMapping("/api/user")
public class UserController {
    private final UserService userService;

    @GetMapping
    public ResponseEntity<UserInfoResponseDto> getUserInfo(@RequestParam("username") String name) throws IllegalArgumentException {
        return ResponseEntity.ok(userService.selectUserInfo(name));
    }
}
```

이제 마지막으로 username을 파라미터로 받아서 해당 유저 정보를 반환하는 api를 작성해주었다.

```java
@ExtendWith(SpringExtension.class)
@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTests {
    @Autowired
    private MockMvc mockMvc;
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private ObjectMapper objectMapper;

    @Test
    @DisplayName("/api/user 테스트")
    public void getUserInfoApiTest() throws Exception {
        //준비
        String name = "gunkim";
        int age = 22;
        userRepository.save(User.builder()
                .name(name)
                .age(age)
                .build());

        //실행
        MvcResult result = mockMvc.perform(MockMvcRequestBuilders.get("/api/user")
                .param("username", name))
                .andExpect(status().isOk())
                .andDo(print())
                .andReturn();

        //단언
        UserInfoResponseDto dto = objectMapper.readValue(result.getResponse().getContentAsString(), UserInfoResponseDto.class);
        assertThat(dto.getName(), is(equalTo(name)));
        assertThat(dto.getAge(), is(equalTo(age)));
    }
}
```

mockMvc에서 지원해주는 andExpect메소드를 통해서 body값을 검증하는 방법도 있긴 하지만 일관성을 위해 Assert메소드를 통해 검증해주었다. 이렇게 해서 api 테스트까지 완료됐다.

# 끝으로

JUnit으로 여러가지 테스트 케이스를 작성해두게 되면 빌드 시에 미리 문제를 인지하고 수정할 수 있게 되어 오류 방지 측면에서 좋고, 개발 시에는 단위들을 테스트하여 그냥 개발하는 방법보다 더 빠르게 개발이 가능해지니 JUnit은 필수로 익혀두었으면 좋겠다.


JUnit5로 스프링 프로젝트 효과적으로 테스트하기


젠킨스는 소프트웨어 개발 시 지속적으로 통합 서비스를 제공하는 툴로 CI(Continuous Integration) 툴 이라고 한다. 오늘은 젠킨스가 필요하게 되어 설치 방법에 대해서 정리해보려고 한다.

# 환경

- ubuntu 20.04.2
- openjdk 11.0.11

# JDK 설치

```bash
apt install openjdk-11-jre-headless
```

# 저장소 키 설정

[Stack Overflow 답변](https://serverfault.com/questions/1034893/installing-jenkins-on-ubuntu-tells-me-package-jenkins-has-no-installation-can)을 보니 2020년 4월 부터 Jenkins 저장소 키가 변경되어 아래와 같이 해주면 된다고 한다.

```bash
wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
```

# Jenkins 설치

```bash
sudo apt-get install jenkins
```

# Jenkins 설정

Jenkins 포트 같은 설정들은 아래에 파일에서 할 수 있다.

```bash
sudo vi /etc/default/jenkins
```

# Jenkins 서비스 재시작

```bash
sudo service jenkins restart
```

서비스 정상 실행 여부 확인

```bash
sudo systemctl status jenkins
```

# 초기 패스워드 확인

```bash
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```

# Jenkins 접속

포트 번호를 변경하지 않은 경우 [http://localhost:8080](http://localhost:8080)으로 접속하면 아래 화면이 표출되니 비밀번호는 앞에서 확인한 초기 패스워드를 입력해주면 된다.
![1](https://user-images.githubusercontent.com/45007556/119257892-5069ce80-bc02-11eb-8edc-2fbaa8194037.png)

## 플러그인 설치

Jenkins는 여러 플러그인을 지원해주는데, 플러그인 권장 설치 및 아니면 필요한 플러그인을 개별 선택해서 설치가 가능하다.
![스크린샷 2021-05-23 오후 6 14 19](https://user-images.githubusercontent.com/45007556/119257922-75f6d800-bc02-11eb-8a8e-d96e9763dfd6.png)
![스크린샷 2021-05-23 오후 6 14 51](https://user-images.githubusercontent.com/45007556/119257924-77280500-bc02-11eb-8e93-4c535f0489bf.png)

# 설치 완료

플러그인 설치가 끝나면 이제 Jenkins 사용이 가능해진다.
<img width="1215" alt="스크린샷 2021-05-23 오후 7 54 56" src="https://user-images.githubusercontent.com/45007556/119257941-8c049880-bc02-11eb-955a-58c3759827d5.png">


Ubuntu(20.04) Jenkins 설치하기


그동안 간간히 Querydsl을 설정할 일이 있을 때마다 인터넷을 찾아보곤 했는데 매번 찾아보기 번거로워서 이번 기회에 Spring Boot+Jpa+Gradle 프로젝트에서 Querydsl 설정하는 방법을 정리해보려고 한다.

해당 게시글의 설정 방법은 Gradle 5.0 이상, IntelliJ 2020.x 이상을 기준으로 한다. 이 포스팅에서 사용되는 소스는 [여기](https://github.com/gunkims/spring-example/tree/master/jpa-querydsl-setting)에서 볼 수 있다.

# 환경

- Spring Boot 2.4.5
- Gradle 6.8.3
- IntelliJ 2021.1.1

# build.gradle 작성

## 빌드 스크립트 의존성 추가

최상단에 buildscript를 아래와 같이 작성해 준다.

- buildscript란? gradle로 task를 수행할 때에 사용되는 소스의 컴파일과 무관한 설정이다. Gradle 빌드 스크립트 자체를 위한 의존성이나 변수, Task, Plugin 등을 지정하기 위해 사용한다.

```java
buildscript {
    ext {
        springBootVersion = '2.4.5'
        querydslPluginVersion = '1.0.10'
    }
    repositories {
        mavenCentral()
        maven { url "https://plugins.gradle.org/m2/" }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath("gradle.plugin.com.ewerk.gradle.plugins:querydsl-plugin:${querydslPluginVersion}")
    }
}
```

## 플러그인 추가

기본적인 플러그인들을 추가해준다.

```java
plugins{
	id 'org.springframework.boot' version '2.4.5' apply true
	id 'io.spring.dependency-management' version '1.0.10.RELEASE'
  id 'java'
  id 'eclipse'
}
```

## 의존성 추가

아래의 의존성들을 추가해준 dependencies 안에 추가해준다.

```java
dependencies {
	implementation group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa'
	compile group: 'com.querydsl', name: 'querydsl-core'
	compile group: 'com.querydsl', name: 'querydsl-jpa'
	annotationProcessor group: 'com.querydsl', name: 'querydsl-apt', version: "${dependencyManagement.importedProperties['querydsl.version']}", classifier: 'jpa'
	annotationProcessor group: 'jakarta.persistence', name: 'jakarta.persistence-api'
	annotationProcessor group: 'jakarta.annotation', name: 'jakarta.annotation-api'
}
```

## Q클래스 생성 경로 설정

```java
def generated = "src/main/generated"

sourceSets {
    main.java.srcDirs += [ generated ]
}

tasks.withType(JavaCompile) {
    options.annotationProcessorGeneratedSourcesDirectory = file(generated)
}

clean.doLast {
    file(generated).deleteDir()
}
```

## Gradle 프로젝트 리로드

위에 설정이 모두 끝났으면 Gradle 프로젝트를 리로드 해주면 설정은 끝난다.

![Untitled](https://user-images.githubusercontent.com/45007556/118149202-4c90bc00-b44c-11eb-9cda-b0ddad6dbb28.png)

# Q클래스 생성

JPA 엔티티 클래스가 Querydsl에 대응하도록 QClass를 생성해 주어야 한다.

Gradle 탭>Tasks>other>compileJava 를 더블클릭해주게 되면 QClass가 build.gradle에 설정한 경로에 생성되게 된다.(기존에 JPA 엔티티를 생성되어 있어야 Q 클래스가 생성됨)

<img width="536" alt="이미지2" src="https://user-images.githubusercontent.com/45007556/117846103-17556400-b2bc-11eb-956f-238aab69a167.png">
<br/>
<img width="316" alt="이미지3" src="https://user-images.githubusercontent.com/45007556/117846111-19b7be00-b2bc-11eb-8224-77ce3ab9768f.png">

# Querydsl 설정

Querydsl 사용을 위한 설정 코드를 작성해준다.

```java
@Configuration
public class QuerydslConfig {
    @PersistenceContext
    private EntityManager entityManager;

    @Bean
    public JPAQueryFactory jpaQueryFactory() {
        return new JPAQueryFactory(entityManager);
    }
}
```

# 참고

[https://jojoldu.tistory.com/372](https://jojoldu.tistory.com/372)


스프링 부트 Jpa Querydsl 설정 방법 정리


![image](https://user-images.githubusercontent.com/45007556/117680421-1d7c0f80-b1ec-11eb-9bb4-72865c215308.png)

M1 맥북을 산지 어느새 3달이 지났다. 그러다 문뜩 설치된 프로그램을 보는데 자주 쓰는 IDE인 파이참과 인텔리제이가 Intel로 표기가 된 걸 보고 찾아보니 Universal 및 Apple Silicon으로 설치가 되어 있어야 적절하게 최적화가 이루어지고, Intel 버전일 경우 로제타로 인한 가상 환경에서 돌아가기 때문에 그만큼 M1의 빠릿함을 느끼지 못한다고 한다. 기존에 설치할 때 모르고 인텔 버전을 설치해버렸던 것 같다...

![image](https://user-images.githubusercontent.com/45007556/117680644-51efcb80-b1ec-11eb-84b8-886969a07c50.png)

결국 인텔리제이와 파이참을 공홈에 가서 실리콘 맥 버전으로 재설치한 결과는 매우 놀라웠는데, 원래 프로젝트 로딩에 2~3초 걸리고, 스크롤 시에도 버벅거리던 원인을 3달이 지나고서야 알았다... 그냥 당연히 M1이라도 인텔리 제이는 버벅대는구나라고 생각한 게 매우 후회스럽다 ㅠ 이제라도 알게 되어 다행이고 더 빠른 환경에서 열심히 코딩해야겠다.


M1 맥북의 성능을 제대로 발휘하지 못하고 있었다...


21년 1회 필기에 이어서 이번 4월 25일 일요일에는 정보처리기사 실기를 보고 왔다. 시험을 보기 전에 20년 1회 합격률이 5%대를 찍을 정도로 개정 후에 악명이 높아서 살짝 겁먹고 있었던 데다가 책은 1,2권으로 나눠져 있으나 842쪽이라는 압도적인 두께로 인해서 공부를 미루고 있었다...

시험 2주 전?부터 조금 조금씩 보다가 시험이 일주일이 다가오자 다급함이 몰려와서 1회 완독을 서둘러서 하고, 1주일 동안은 책 저자분들이 운영하시는 네이버 카페가 있어서 거기서 제공해 주는 문제들을 풀어보고, 약술형이 나온다 하니 일주일 동안 약술 형만 100개를 넘게 외우고 시험을 보러 갔다.

그 결과... 아직 나오지는 않았지만, 가채점 결과 80점으로 커트라인 위로 넉넉하게 합격할 수 있을 것 같다. 정처기가 아무리 개정이 돼서 어렵다고 해도 전공자 입장에서는 전공 지식이 있기 때문에 그렇게 어렵진 않은 것 같다. 프로그래밍이나 SQL 문제 같은 경우는 따로 공부를 안 해도 되고, 약술형+단답형만 잘 챙기면 될 것 같다.(문제는 그게 분량이 엄청나다는 것...) 카페를 보니 3수를 하신 분들도 계시다 보니 지레 겁을 먹고 포기하고 2회차를 볼까 고민을 했었다. 하지만 포기하지 않고, 도전했기 때문에 붙을 수 있었던 것 같다. 역시 무엇이든 해보지도 않고, 포기한다면 그 무엇도 해낼 수 없다는 말이 사실인 것 같다.

# 마지막으로...

시험을 포기할까 생각하던 중 우연히 유튜브에서 가희의 팩트 폭행 영상을 보았는데 이 영상을 보고 많은 깨달음을 얻었다. 솔직히 준비 기간이 많았음에도, 미루다가 결국 다가오자 공부가 덜 된 자신을 보면서 포기하고, 좀 더 여유 기간을 가지고 2회차를 보려고 생각을 했었는데, 이 정도 마음가짐으로는 결국 2회차 시험 일자가 다가와도 똑같은 핑계를 댈 것 같았기 때문이었다.
이번 1회차는 오랜만에 마음가짐을 정돈하는 기회가 된 것 같다.

![image](https://user-images.githubusercontent.com/45007556/116359087-5655d500-a839-11eb-9267-6d70b046bdeb.png)


2021년 1회 정보처리기사 실기 후기


이번에 사내 소스를 살펴보던 중 매우 나쁜 냄새가 나는 소스가 있어서 개선 방법을 생각해 보았다.

# 문제의 소스

이런 식으로 사용자 아이디가 필요한 곳마다 같은 소스가 꼭 들어가 있는 것을 확인할 수 있었다.

```java
@RestController
public class HomeController {
    @GetMapping("/")
    public void home(Authentication auth){
        UserVO vo = (UserVO) auth.getPrincipal();
        String userId = vo.getUserId();
        //...
    }
    @GetMapping("/posts")
    public void posts(Authentication auth){
        UserVO vo = (UserVO) auth.getPrincipal();
        String userId = vo.getUserId();
        //...
    }
    @GetMapping("/notice")
    public void home(Authentication auth){
        UserVO vo = (UserVO) auth.getPrincipal();
        String userId = vo.getUserId();
        //...
    }
}
```

# 개선해보기

어떻게 고치면 좋을까 생각을 하던 중 예전에 이동욱 님이 소개하셨던 커스텀 어노테이션 작성하는 법이 생각나서 한번 어노테이션을 만드는 방법으로 시도해보았다.

## @LoginUser 어노테이션 선언

```java
package com.awa.ai.biz.common.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser {
}
```

해당 어노테이션은 매개변수에 런타임 시에 적용할 수 있도록 선언해 주었다. 지금은 어노테이션만 선언해 준 것이고, 아직 원하는 기능은 하지 못한다.

### @Target - 적용 대상 명시

- ElementType.PACKAGE : 패키지
- ElementType.TYPE : 타입 선언
- ElementType.ANNOTATION_TYPE : 어노테이션
- ElementType.CONSTRUCTOR : 생성자
- ElementType.FIELD : 멤버 변수
- ElementType.LOCAL_VARIABLE : 지역 변수
- ElementType.METHOD : 메서드
- ElementType.PARAMETER : 매개변수
- ElementType.TYPE_PARAMETER : 매개변수 타입
- ElementType.TYPE_USE : 타입

### @Retention - 어노테이션 적용 범위

- RetentionPolicy.RUNTIME 컴파일 전까지 유효
- RetentionPolicy.CLASS 컴파일러가 클래스를 참조할 때까지 유효
- RetentionPolicy.SOURCE 컴파일 이후에도 JVM 에 의해서 계속 참조 가능

## LoginUserArgumentResolver 선언

```java
@Component
@Qualifier("LoginUserArgumentResolver")
public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter methodParameter) {
        // 해당 매개변수에 @LoginUser 어노테이션이 붙어있는지 확인
        boolean isLoginUserAnnotation = methodParameter.getParameterAnnotation(LoginUser.class) != null;
        //어노테이션이 붙은 변수 타입이 String 타입인지 확인
        boolean isUserClass = String.class.equals(methodParameter.getParameterType());

        //두가지 모두 만족할 경우 적용
        return isLoginUserAnnotation && isUserClass;
    }

    @Override
    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        UserVO userVO = (UserVO) authentication.getPrincipal();
        return userVO.getUserId();
    }
}
```

이제 실질적인 기능을 작성해 주었다. supportsParameter 메소드는 적용 대상이 맞는지 검증, resolveArgument 메소드는 실제로 값을 바인딩 해준다.

## LoginUserArgumentResolver를 등록하기

```java
@RequiredArgsConstructor
@EnableWebMvc
@Configuration
public class WebMvcConfigurers implements WebMvcConfigurer {
	//....
    @Qualifier("LoginUserArgumentResolver")
	private final HandlerMethodArgumentResolver loginUserArgumentResolver;

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(loginUserArgumentResolver);
    }
}
```

# 개선한 코드

```java
@RestController
public class HomeController {
    @GetMapping("/")
    public void home(@LoginUser String userId){
        //...
    }
    @GetMapping("/posts")
    public void posts(@LoginUser String userId){
        //...
    }
    @GetMapping("/notice")
    public void home(@LoginUser String userId){
        //...
    }
}
```

소스가 매우 간결해지고, 코드의 가독성이 좋아진 것을 확인할 수 있다.

# 커스텀 어노테이션 적용의 주의할 점?

싱글벙글하면서 커스텀 어노테이션을 적용해놓고, 관련 글을 찾아보던 중
[시의적절한 커스텀 어노테이션](https://woowabros.github.io/experience/2020/06/26/custom-annotation.html)이라는 글을 보게 되었다. 어노테이션을 쓰면 코드가 간결해지지만, 어노테이션의 의도는 숨겨져 있기 때문에 남발할 경우 좋지 않을 수 있다는 것이다. 나도 이번에 적용해보고, 어? 전부 어노테이션으로 바꿔버리면 좋...지 않을...까?라고 잠깐 생각했었던 터라 매우 공감하면서 읽었다. 이 문제는 커스텀 어노테이션으로 해결했지만, 커스텀 어노테이션을 적용할 경우 한 번쯤은 깊게 고민해 보고 최대한 지양하는 것이 좋지 않을까 생각한다.


스프링 커스텀 어노테이션으로 소스를 간결하게 하자


Hadoop은 여러 대의 컴퓨터 클러스터에서 대규모 데이터 세트를 분산 처리할 수 있게 해주는 프레임워크이다. 주로 분산 처리가 많이 필요한 빅데이터 개발에 많이 쓰인다고 한다. 나도 같은 이유로 하둡 개발 환경을 세팅해야 하는 상황이라 하둡 설치 방법에 대해서 정리해보려고 한다.

# 설치 환경

- Ubuntu 18.04
- Hadoop 3.1.4
- Openjdk 1.8

# apt 업데이트

```bash
sudo apt-get update
```

# jdk 설치 및 환경변수 설정

## 설치

```bash
sudo apt-get install openjdk-8-jdk
```

## 환경변수 설정

환경변수 설정창으로 진입

```bash
sudo nano ~/.bashrc
```

자바 환경변수 설정

```bash
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```

환경변수 적용

```bash
source ~/.bashrc
```

## 확인

```bash
gun@gun:~$ java -version
openjdk version "11.0.10" 2021-01-19
OpenJDK Runtime Environment (build 11.0.10+9-Ubuntu-0ubuntu1.18.04)
OpenJDK 64-Bit Server VM (build 11.0.10+9-Ubuntu-0ubuntu1.18.04, mixed mode, sharing)
```

# apt 업그레이드

```bash
sudo apt-get upgrade
```

# 그룹 및 사용자 생성

하둡을 따로 관리하기 위한 사용자 및 그룹 생성

```bash
sudo addgroup hadoop
sudo adduser --ingroup hadoop hduser
```

```bash
gun@gun:~$ sudo addgroup hadoop
그룹 `hadoop' (GID 1003) 추가 ...
완료.`
hduser@csle1:~$ sudo adduser --ingroup hadoop hduser
'hduser' 사용자를 추가 중...
새 사용자 'hduser' (1003) 을(를) 그룹 'hadoop' (으)로 추가 ...
'/home/hduser' 홈 디렉터리를 생성하는 중...
'/etc/skel'에서 파일들을 복사하는 중...
새 UNIX 암호 입력:
새 UNIX 암호 재입력:
passwd: 암호를 성공적으로 업데이트했습니다
hduser의 사용자의 정보를 바꿉니다
새로운 값을 넣거나, 기본값을 원하시면 엔터를 치세요
	이름 []:
	방 번호 []:
	직장 전화번호 []:
	집 전화번호 []:
	기타 []:
정보가 올바릅니까? [Y/n] y
```

## hduser계정의 루트권한 사용을 위한 설정

```bash
sudo nano /etc/sudoers
```

맨 아랫줄에 해당 내용 추가

```bash
hduser ALL=(ALL) NOPASSWD: ALL
```

# Openssl Server 설치

```bash
sudo apt-get install openssh-server
```

# ssh 키 생성

## 1. hduser로 사용자 전환

```bash
sudo su hduser
```

## 2. home 디렉토리 이동

```bash
cd
```

## 3. ssh키 생성

```bash
ssh-keygen -t rsa -P ""
```

후 아무것도 입력하지 않고 엔터

## 4. ssh키 비밀번호 해제

```bash
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
```

## 5. sysctl.conf 수정

```bash
sudo nano /etc/sysctl.conf
```

```bash
l.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable)ipv6 = 1
```

맨 아랫줄에 해당 내용 추가

5. 재시작

```bash
sudo reboot
```

# 하둡(Hadoop) 설치

## 사용자 전환

```bash
sudo su hduser
cd
```

## 다운로드

[하둡 다운로드](https://downloads.apache.org/hadoop/common/)에서 원하는 버전 선택 후 .tar.gz 파일의 링크 주소 복사

![Untitled](https://user-images.githubusercontent.com/45007556/113102332-dab43880-9238-11eb-9f5d-50a304e4c22c.png)

나는 3.1.4버전을 설치할 것이기 때문에 해당 주소를 다운 받았다.

```bash
wget https://downloads.apache.org/hadoop/common/hadoop-3.1.4/hadoop-3.1.4.tar.gz
```

## 압축풀기

```bash
tar -zxf hadoop-3.1.3.tar.gz
```

## 이동

압축 풀어서 나온 hadoop-3.1.4 폴더를 /usr/local 경로에 hadoop이라는 폴더명으로 변경해서 이동

```bash
sudo mv hadoop-3.1.4 /usr/local/hadoop
```

## 권한 수정

```bash
sudo chown hduser:hadoop -R /usr/local/hadoop
sudo mkdir -p /usr/local/hadoop_tmp/hdfs/namenode
sudo mkdir -p /usr/local/hadoop_tmp/hdfs/datanode
sudo chown hduser:hadoop -R /usr/local/hadoop_tmp/
```

## 환경변수 추가

```bash
sudo nano ~/.bashrc
```

```bash
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
export PDSH_RCMD_TYPE=ssh
export HADOOP_HOME=/usr/local/hadoop
export PATH=$PATH:$HADOOP_HOME/bin
export PATH=$PATH:$HADOOP_HOME/sbin
export PATH=$PATH:$JAVA_HOME/bin
export HADOOP_MAPRED_HOME=$HADOOP_HOME
export HADOOP_COMMON_HOME=$HADOOP_HOME
export HADOOP_HDFS_HOME=$HADOOP_HOME
export YARN_HOME=$HADOOP_HOME
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native
export HADOOP_OPTS="-Djava.library.path=$HADOOP_HOME/lib"
export PATH=$PATH:/usr/local/hadoop/bin/
```

아까 자바 환경변수 설정한 곳 아래에 이어서 작성

## 하둡 관련 파일들 수정

```bash
cd /usr/local/hadoop/etc/hadoop
```

```bash
sudo nano hadoop-env.sh
```

```bash
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
   or
export JAVA_HOME=${JAVA_HOME}
```

기본값으로 주석되어 있는 것을 풀어주고, 자신의 jdk 경로 기입.

```bash
sudo nano core-site.xml
```

```bash
<configuration>
	<property>
		<name>fs.default.name</name>
		<value>hdfs://localhost:54310</value>
	</property>
</configuration>
```

```bash
sudo nano hdfs-site.xml
```

```bash
<configuration>
	<property>
		<name>dfs.replication</name>
		<value>1</value>
	</property>
	<property>
		<name>dfs.namenode.name.dir</name>
		<value>file:/usr/local/hadoop_tmp/hdfs/namenode</value>
	</property>
	<property>
		<name>dfs.datanode.data.dir</name>
		<value>file:/usr/local/hadoop_tmp/hdfs/datanode</value>
	</property>
</configuration>
```

```bash
sudo nano yarn-site.xml
```

```bash
<configuration>
	<property>
		<name>yarn.nodemanager.aux-services</name>
		<value>mapreduce_shuffle</value>
	</property>
	<property>
		<name>yarn.nodemanager.aux-services.mapreduce.shuffle.class</name>
		<value>org.apache.hadoop.mapred.shuffleHandler</value>
	</property>
</configuration>
```

## 적용

```bash
cd
source ~/.bashrc
```

# 하둡 실행

```bash
cd /usr/local/hadoop_tmp/hdfs
hadoop namenode -format
cd /usr/local/hadoop/sbin
./start-dfs.sh
./start-yarn.sh
```

- ./start-dfs.sh 시에 권한 오류가 날 경우 환경변수 PDSH_RCMD_TYPE가 제대로 되어 있는지 체크

# 최종 확인

```bash
hduser@gun:/usr/local/hadoop/etc/hadoop$ jps
32610 NodeManager
32229 ResourceManager
31401 NameNode
31625 DataNode
31913 SecondaryNameNode
6494 Jps
```


Ubuntu 18.0.4 하둡(Hadoop) 설치하기


세션 로그인 같은 경우 매번 요청이 있을 때마다 세션 시간이 자동 갱신이 되기 때문에 필요가 없지만, JWT 같은 경우 토큰의 유효기간이 이미 발급과 동시에 정해지게 된다. 그래서 만약 JWT 토큰을 연장하기 위한 방법은 다시 재발급을 하는 방법밖에 없는데, 그렇게 되면 기존에 방식대로면 사용자가 직접 로그인을 한 번 더 해주어야 한다. 사이트를 이용하다 30분마다 로그인을 다시 해야 한다니 조금 번거롭지 않은가?

# Access Token, Refresh Token

JWT 진영에서 이 문제를 해결하기 위한 방법이 토큰 2개를 발급한다. 하나는 유효기간이 짧은 `Access Token(보통 30분)`, 다른 하나는 유효기간이 긴 `Refresh Token(보통 2주)`을 발급하는 것이다. 그래서 인증을 할 때 클라이언트는 서버에 요청을 할 때마다 `Access Token`을 서버로 보내면서 사용하다가 어느새 `Access Token`이 만료가 되어 서버로부터 `401 Unauthorized`에러를 받게 되면 `Refresh Token`을 서버로 보내 다시 `Access Token`을 발급받는다. 이 과정은 아래에 이미지를 보면 이해가 빠르다. [이미지 출처](http://blog.logicwind.com/jwt-refresh-token-implementation-in-node-js/)
![image](https://user-images.githubusercontent.com/45007556/112577366-8889a680-8e37-11eb-873c-14545bb84cfa.png)

# 왜?

궁금증이 많은 나는 "`Refresh Token`을 탈취해서 똑같이 `Access Token`을 발급해서 악용할 수 있는데 결국 `Access Token` 유효기간을 길게 잡는 것과 뭐가 달라?"라는 생각이 들었다.

# Refresh Token을 적용할 경우에 이점

내 궁금증을 해결해 줄 수 있는 답을 찾기 위해 [참고1](https://stackoverflow.com/questions/3487991/why-does-oauth-v2-have-both-access-and-refresh-tokens), [참고2](https://stackoverflow.com/questions/10703532/whats-the-point-of-refresh-token), [참고3](https://stackoverflow.com/questions/53324540/why-use-jwt-refresh-token) 스택오버플로에서 나와 비슷한 고민을 한 사람들이 남긴 질문에 달린 답변들을 살펴보았다. 여러 질문들을 살펴본 결과 가장 납득이 가는 답변을 정리해보겠다.

# 서버의 방어수단

서버 입장에서 한번 살펴보자면 JWT는 Session을 사용하지 않는 Session-less 방식이다. 그렇다면 `Access Token`의 유효기간을 길게 설정한다면 이 토큰이 해커에게 탈취되어 부정하게 사용되어도 서버 입장에서는 이 사용자를 차단할 방법이 없다. 서버 쪽에서는 결국 정상적으로 발급된 토큰이기 때문에 `Access Token`이 만료될 때까지 그저 손가락 빨고 기다리는 수밖에 없다.

그에 비해 `Refresh Token`을 사용하게 되면 `Access Token`이 탈취되더라도 유효기간이 30분이라고 하면 30분 동안의 해킹 시도는 유효기간을 길게 설정한 경우에 비해 적을 것이다. 게다가 `Refresh Token`까지 탈취된다고 해도 `Refresh Token`을 무효화시켜서 `Access Token`을 발급하지 못하게 할 수 있다.
결국 `Refresh Token`을 사용하는 이유는 서버 입장에서 하나의 방어수단이라고 할 수 있다.

# 정리

정리하자면 로그인 유지를 위해서 `Access Token`의 유효기간을 길게 설정하자니 탈취될 경우 서버 입장에선 무력화 수단이 없기 때문에 `Refresh Token`을 두는 수고를 들이더라도 사용해야 하는 메리트는 있다.라고 볼 수 있을 것 같다. 참고로 비슷한 인증 방식인 OAuth2 제공자 중에서 github, foursquare는 `Refresh Token`을 사용하지 않는다고 한다. 아무래도 필수는 아니니 선택의 문제인 것 같다.


JWT Refresh Token을 정말 사용해야 할까?


지금까지 스프링으로 개발을 하면서 @Requestbody와 @Modelattribute의 차이점에 대해 잘 모르고 사용해왔다. @Requestbody로 써보고 안되면, @Modelattribute로 바꿔보는 식으로 했던 것을 반성해보면서 이번 기회에 한번 짚고 넘어가려고 한다. 더 자세한 내용은 참조를 확인하면 될 것 같다.

# @ModelAttribute

HTTP 클라이언트가 보내온 요청에서 Parameter 값들을 VO의 Setter를 통해 바인딩 해준다.

# @RequestBody

HTTP 클라이언트가 보내온 요청에서 Body 값들을 ObjectMapper를 통해 변환해서 VO에 값들을 매핑해준다.

# 어떻게 구분해서 사용할까?

값을 파라미터로 넘기냐, Body에 담아서 넘기냐에 따라서 선택하면 될 것 같다.

# 직접 테스트해보기

```java
@Setter
@Getter
@ToString
public class PersonRequestDto {
    private String name;
    private int age;
}
```

```java
    @PostMapping("")
    public void rb(@RequestBody PersonRequestDto dto){
        System.out.println("TEST :: "+dto.toString());
    }
    @GetMapping("")
    public void ma(@ModelAttribute PersonRequestDto dto){
        System.out.println("TEST :: "+dto.toString());
    }
```

## @RequestBody에 Parameter 테스트

```java
    @Test
    public void requestBodyParameterTest() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/api/rb")
                .contentType(MediaType.APPLICATION_JSON)
                .characterEncoding("UTF-8")
                .param("name", "kan")
                .param("age", "13")
        ).andExpect(status().isOk()).andDo(print());
    }
```

![image](https://user-images.githubusercontent.com/45007556/112264757-b1356300-8cb4-11eb-86f6-4ee9bdab6b6f.png)

예상했던 대로 매핑이 되지 않는 것을 확인할 수 있었다. 해당 오류는 @ReuqestBody로 선언되어 있는데, Body에 값이 담겨있지 않기 때문에 오류가 난 것이다.

## @RequestBody에 Body 테스트

이번에는 Setter가 없어도 되어야 하기 때문에 Setter를 빼고 테스트를 해보았다.

```java
@Getter
@ToString
public class PersonRequestDto {
    private String name;
    private int age;
}
```

```java
    @Test
    public void requestBodyBodyTest() throws Exception {
        String json = "{ \"name\":\"kan\", \"age\":\"13\" }";
        mockMvc.perform(MockMvcRequestBuilders.post("/api/rb")
                .contentType(MediaType.APPLICATION_JSON)
                .characterEncoding("UTF-8")
                .content(json)
        ).andExpect(status().isOk()).andDo(print());
    }
```

![image](https://user-images.githubusercontent.com/45007556/112264877-dcb84d80-8cb4-11eb-8ea9-68feb367f0d2.png)

Body에 값을 담았더니 Setter가 없는데도 정상적으로 매핑이 되는 것을 확인할 수 있었다.

## @ModelAttribute에 Parameter 테스트

```java
    @Test
    public void modelAttributeParameterTest() throws Exception {
        String json = "{ \"name\":\"kan\", \"age\":\"13\" }";
        mockMvc.perform(MockMvcRequestBuilders.get("/api/ma")
                .contentType(MediaType.APPLICATION_JSON)
                .characterEncoding("UTF-8")
                .param("name", "kan")
                .param("age", "13")
        ).andExpect(status().isOk()).andDo(print());
    }
```

![image](https://user-images.githubusercontent.com/45007556/112265784-64eb2280-8cb6-11eb-9f2f-6f71feda6492.png)

역시나 성공하는 것을 확인할 수 있었다.

## @ModelAttribute POST방식 테스트

이번에는 Body에 값을 넣어도 매핑이 되는지 확인해보기 위해 POST 방식으로 바꾸어서 테스트해보았다.

```java
    @PostMapping("")
    public void ma(@ModelAttribute PersonRequestDto dto){
        System.out.println("TEST :: "+dto.toString());
    }
```

```java
    @Test
    public void modelAttributeBodyTest() throws Exception {
        String json = "{ \"name\":\"kan\", \"age\":\"13\" }";
        mockMvc.perform(MockMvcRequestBuilders.post("/api/ma")
                .contentType(MediaType.APPLICATION_JSON)
                .characterEncoding("UTF-8")
                .content(json)
        ).andExpect(status().isOk()).andDo(print());
    }
```

![image](https://user-images.githubusercontent.com/45007556/112265944-b2678f80-8cb6-11eb-9d0e-c61aab10b392.png)

@RequestBody와는 다르게 Body에 값이 있어 매핑이 안되는 상황이지만, 오류는 나지 않고 null 및 0으로 값이 들어간 것을 확인할 수 있었다.

# 참고

[https://mangkyu.tistory.com/72](https://mangkyu.tistory.com/72)  
[https://jojoldu.tistory.com/407](https://jojoldu.tistory.com/407)


@RequestBody vs @ModelAttribute 언제 사용해야 할까?


[Java에서 Byte로 문자열 자르기](/Java-Byte-String)에서 한번 소개했던 적은 있는데, 이번엔 JS에서 해야 하는 상황이 발생했다.
![image](https://user-images.githubusercontent.com/45007556/112081265-b7e5ac80-8bc6-11eb-8078-8d173f4f1e58.png)

블로그 목록 표출 시 제목이 너무 긴 게시물들이 있어서 20글자로 제한하려고 했는데, 영어로 된 게시물들의 경우 20글자로 자르게 되면 한글보다 엄청 짧아지는 경향이 있기 때문이었다.

그래서 한글은 20글자, 영어는 40글자 정도로 제한하는 게 어떨까 해서 생각해 본 방법 중 Byte로 제한하는 방법이 떠오르게 되어서 찾아보게 되었다. 그런데 JS에서 공식적으로 지원해 주는 함수는 없어서, 직접 만들어서 해결했다. 오늘은 그 방법에 대해 작성해보려고 한다.

# 예제

```js
const targetStr = "Hello World!";
let buffer = 0;
let idx = 0;
while (true) {
  const unicode = targetStr.charCodeAt(idx);
  buffer += unicode > 127 ? 2 : 1;

  if (buffer > 4) break;
  idx++;
}
let result = targetStr.substring(0, idx);
console.log(result); //Hell
```

해당 예제는 "Hello World!"라는 문자열을 앞에서부터 4Byte 만큼 자르는 예제이다.
생각보다 쉽게 구현했는데, 한 글자씩 유니코드가 127을 넘는지 확인 후 넘을 경우 2byte, 안 넘을 경우 1byte로 판단해 buffer 변수에 쌓아주었다. 그리고 계속 반복하다 buffer 변수의 값이 4를 넘어설 경우 해당 idx까지 문자열에서 잘라주었다.

# 함수로 만들기

```js
function substrToByte(targetStr, maxByte) {
  let buffer = 0;
  let idx = 0;
  while (true) {
    const unicode = targetStr.charCodeAt(idx);
    buffer += unicode > 127 ? 2 : 1;

    if (buffer > maxByte) break;
    idx++;
  }
  return targetStr.substring(0, idx);
}
console.log(substrToByte("Hello", 2)); //He
```

재활용이 가능하도록 함수로 만들어보았다. 필요할 때 사용하면 될 것 같다.


JavaScript에서 Byte로 문자열 자르기


이번에 Gatsby.js 블로그 소스가 어느 정도 정리가 되고, Gitalk로 댓글을 적용하려고 코드를 작성하고 `Gatsby build`를 했더니 아래와 같은 에러가 발생했다.

```bash
 ERROR #95312
cn
"window" is not available during server side rendering.

See our docs page for more info on this error: https://gatsby.dev/debug-html


  10015 |
  10016 |     _this.options = (0, _assign2.default)({}, {
> 10017 |       id: window.location.href,
        | ^
  10018 |       number: -1,
  10019 |       labels: ['Gitalk'],
  10020 |       title: window.document.title,


  WebpackError: ReferenceError: window is not defined

  - gitalk-component.js:10017
    node_modules/gitalk/dist/gitalk-component.js:10017:1
```

오류의 내용을 통해 추측해보면, window 객체를 SSR 시에 사용할 수 없다고 한다. window 객체는 그냥 사용이 가능한 것이 아니었나? 하고 해당 내용들을 검색해보았다.

# 원인

Gatsby.js로 개발할 때는 사용 가능한 브라우저를 통해 컴파일을 하지만, 빌드 중에는 서버에서 Webpack을 사용해서 컴파일이 되기 때문에 window 객체에 접근하지 못한다는 것이었다. 그래서 실제로 `Gatsby develop`은 정상적으로 실행이 되는 것을 확인할 수 있었다.

# 방법 탐색

그래서 찾아본 결과 [Gatsby.js 공식 홈페이지](https://www.gatsbyjs.com/docs/debugging-html-builds/#how-to-check-if-code-classlanguage-textwindowcode-is-defined)에서 크게 3가지 방법을 찾을 수 있었다.

1. typeof를 통해 window 객체를 감추기
2. useEffect를 통해 해당 구문 감싸기
3. `@loadable/component` 라이브러리를 사용하기

우선 첫 번째 방법은 typeof를 통해 window 객체를 검사해서 window 객체가 없을 경우 undefined를 뱉게 하는 방법이고,
두 번째 방법은 useEffect 함수는 렌더링이 완료된 이후에 실행이 되니 문제가 되는 부분을 useEffect 함수 안으로 옮겨서 해결하는 방법이다.

그런데 위에 두 가지 방법은 문제가 있었는데, 내가 작성한 코드일 경우에는 적용이 가능하지만, 문제는 외부 라이브러리 Gitalk 소스코드에 있었기 때문에 직접 수정하는 방법은 사용할 수 없었다. 그래서 찾은 방법인 3번째 `@loadable/component` 라이브러리를 사용한 방법을 소개해보려고 한다. 앞에 2가지 방법은 위에 주소에서 확인할 수 있다.

# @loadable/component 라이브러리를 사용하기

## 라이브러리 다운로드

```bash
npm i --save @loadable/component
```

## 적용 전

```js
import GitalkComponent from 'gitalk/dist/gitalk-component'
```

## 적용 후

아래와 같이 적용하게 되면 문제가 되는 라이브러리가 렌더링 후에 불러와지기 때문에 문제가 발생하지 않을 것이다. 때문에 렌더링 시 외부 라이브러리를 사용할 때 발생하는 여러 문제들을 해결할 수 있다.

```js
import loadable from '@loadable/component'
const GitalkComponent = loadable(() => import('gitalk/dist/gitalk-component'))
```


Gatsby.js - SSR 오류 해결


Vue 공부를 하기 위해서 Nuxt.js로 화면을 만들고, 평소와 같이 Spring으로 만든 API 서버와 프록시 설정을 하려고 하다가 삽질해서 해결한 내용에 대해서 작성하려고 한다.

# nuxt.config.js

```js
export default {
  //...
  axios: {
    proxy: true, //default - "false",
  },
  proxy: {
    "/api/": "http://localhost:8080",
  },
};
```

이제 이렇게 설정해주면 "/api/"로 시작하는 URL은 모두 프록시 연결이 된다.

## 하위 URL을 제외하고 싶은 경우

```js
proxy: {
  '/api/': { target: 'http://api.example.com', pathRewrite: {'^/api/': ''} }
}
```

# 참고

[https://axios.nuxtjs.org/options/](https://axios.nuxtjs.org/options/)


Nuxt.js Proxy 설정하기


약 2년이 넘도록 블로그를 이곳저곳 떠돌다 이번에 완전 Gatsby.js + Nelify에 정착하게 되어서 그동안의 여행기를 정리해보려고 한다.

# 블로그 플랫폼 선택에서의 고민

블로그가 참 많다 보니 블로그를 처음 시작하는 입장에서는 블로그만 이곳저곳 장단점만 비교하다가 지쳐서 그냥 블로그를 포기하게 되는 것 같다. (내 경우가 그랬다.) 그래서 내가 실질적으로 느낀 장점과 단점에 대해서 적어보겠다.

## Naver

### 장점

- 네이버 검색 노출이 잘 된다.
- 준수한 블로그 테마
- 우리나라 독보적 1위 포털 사이트의 힘
- 게시물에 코드를 삽입하기 불편함
- 이웃들과 소통 가능

### 단점

- 구글 검색 노출이 잘되지 않음
- 커스텀에 제한이 있음

## Tistory

### 장점

- 구글 검색 노출이 잘 된다.
- 방문자 수 집계 등 여러 통계 기능 지원
- 커스텀에 어느 정도 자유로움
- 코드 삽입 지원이 잘 됨
- Markdown 지원
- 이쁜 테마들이 꽤 많음

### 단점

- 상관없는 유저의 블로그를 차단하는 등 이슈가 있음
- 블로그 글 백업 기능이 삭제됨

## Github Page

### 장점

- 뭔가 개발자 블로그 같다
- Tistory보다는 아니지만 준수한 구글 검색 노출
- 게시글에 코드를 첨부하기 편함
- 커스텀이 100% 자유로움
- Markdown 지원
- 글 쓰거나 블로그를 수정해도 잔디가 심어짐
- 직접 모든 기능이나 디자인을 만들어야 하기 때문에 개발자스러움

### 단점

- 마지막 장점이 곧 단점

일반 사용자 입장에서는 구글보다 네이버가 더 유리한 측면이 있다. 하지만 개발자에게 구글 검색 노출은 치명적이기 때문에 제외하고, 티스토리와 깃허브 페이지를 비교했을 때 귀찮으면 티스토리가 좋고, 깃허브에 익숙해지면서 직접 만들어나가고 싶다고 하면 깃허브 페이지가 좋다. 정도로 정리할 수 있을 것 같다.

# 블로그 플랫폼에서의 고민

![image](https://user-images.githubusercontent.com/45007556/111280159-da377180-867e-11eb-8d1f-0ce2fc90e86a.png)

결국 고민 끝에 Github Pages Jekyll 테마를 이용해서 쭉 운영해오고 있었다. 그런데 문제가 있었는데, 무엇보다 마음에 쏙 드는 디자인과 기능 모두를 만족하는 테마는 찾을 수가 없었다. Jekyll 테마의 경우 외국인들이 만든 테마가 대부분이어서 부가적인 요소이지만, 네이버 블로그나 티스토리같이 사이드바를 통한 카테고리 블로그를 이용해오던 나로서는 심리적인 불편함을 호소하게 되었는데... 그 후로 테마를 몇 번이나 뒤집어엎으면서 삽질을 하다 보니 블로그의 순기능인 글쓰기는 뒷전이고, 코드만 수정하는 나날이 계속되었다.

## 그러던 중 Gatsby Theme로 이동

그러던 중 내가 공부하던 React.js도 호스팅할 수 있다는 것을 알게 되어서 이번엔 Gatsby Starter에서 쓸만한 테마를 탐방했다.
![image](https://user-images.githubusercontent.com/45007556/111281667-8a59aa00-8680-11eb-84ae-c333ac5639ff.png)

## 호스팅 플랫폼 선택

Github Pages에서 Gatsby.js를 호스팅 하려면 크나큰 문제가 있었는데, 그것은 바로 Github Pages는 js를 빌드 해주지 못해, push 할 때 빌드 된 파일들을 올려주어야 정상적으로 호스팅이 된다. 그런데 그렇게 되면 내 레포지토리에 쓸데없는 파일들로 인해 지저분해지고, 유지 보수 측면에서도 매우 불리해진다고 생각해 다른 방법을 모색해 보았다.
그렇게 선택한 것이 Nelify이다. 직접 빌드 및 호스팅까지 모두 자동으로 해주게 되어 편리하고, Github Pages에 비해 지원도 잘해주어 결국 호스팅 플랫폼을 이사하게 되었다. 호스팅 플랫폼이 달라져서 블로그 주소가 달라진다는 문제점이 있었지만, 어차피 나는 개인 도메인을 사용했기 때문에 도메인만 옮겨주면 되는 문제라 안 넘어갈 이유가 없었다.
![image](https://user-images.githubusercontent.com/45007556/111283605-a5c5b480-8682-11eb-955c-fef3ec5a5613.png)

## 블로그 완성

최종적으로 선택한 테마는 gatsby-starter-bee 테마로 해당 테마를 조금 커스텀하여 지금의 블로그 모습이 되었다.
![image](https://user-images.githubusercontent.com/45007556/111282078-ee7c6e00-8680-11eb-8924-8360decdefa2.png)

# 총평

Gatsby 블로그의 장점은 React.js 기반으로 html 요소들을 컴포넌트로 관리할 수 있어 유지 보수가 편하고, 각종 라이브러리들을 쉽게 npm을 통해 지원받을 수 있다는 것이 넘사벽급 장점인 것 같다. 게다가 리액트 공부도 되니 일석이조가 아닐 수 없다. 이 장점을 공유하는 Next.js와 비교도 해보았지만, Gatsby.js를 우선 사용해보려고 한다. 결국 내가 원하는 디자인 및 기능들을 모두 만족하려면 그냥 직접 만드는 게 빠르다는 것을 느꼈다. 나중에 시간이 나면 직접 만들어서 출시해봐야 겠다.
위에 서술한 내용들로 인해 한동안 블로그 활동이 뜸했는데, 이상하게 조회 수는 계속 올라가는 걸 보고 이제부터라도 열심히 글을 써보아야겠다는 생각도 들면서 반성을 해보기도 한다.
![image](https://user-images.githubusercontent.com/45007556/111284646-aad73380-8683-11eb-942f-b153be47e123.png)


2년 동안의 블로그 플랫폼 여행기, 그리고 정착


이번에 군사교육소집으로 인해서 훈련소로 들어가게 되었다. 그런데 4주인 줄 알고 있었는데, 갑자기 3주로 줄었다고 해서 찾아보니 훈련 기간이 장소별로 3주, 4주로 제각각이어서 병무청이 2021년 부터 형평성 보장을 위해서 3주로 통일하게 되었다고 한다. 손흥민도 3주 다녀오고 바뀌어서 손흥민 효과라고 하기도 하더라...

그래서 훈련소를 가기 전에 내가 준비하게 된 과정을 공유하려고 한다.

# 대굴빡 밀기

일단 3주를 가더라도 대굴빡은 밀어야 하기 때문에 아무 미용실이나 들어가서 뚜껑 12mm, 옆머리 3mm를 밀어주자. 혹시 쫄리면 뚜껑을 9mm로 밀어도 된다. 이제 이 때 미용실에서 떨어져 나가는 머리털을 보다 보면 이제부터 본격적으로 실감이 나기 시작한다.

# 논산 육군 훈련소에 가는 법

어차피 3주 밖에 되지 않으니 혼자 갔다가 혼자 오는 방법에 대해서 찾아 보았는데, 경기권이다 보니 그냥 가까운 시외버스 터미널을 통해서 가려고 했다. 그런데 한번에 가는 방법은 없고, 시외버스를 한번 갈아타야 하는 상황이라 내가 선택한 방법은 아래와 같다. 찾아본 결과 경기권이나 서울권이면 이 방법이 가장 좋은 방법인 것 같다.

_집->센트럴시티터미널→연무대고속버스터미널→연무대육군훈련소_

![이미지](https://user-images.githubusercontent.com/45007556/105508996-62009f80-5d10-11eb-8588-a094cefdafcc.png){: width="300" height="500"}

일단 방법은 위와 같지만, 가장 좋은 방법은 부모님이 태워주시는 차를 타고 가는 방법이 가장 베스트이다...😭

# 챙겨야 할 준비물

나도 뭐 살면서 악명으로만 듣던 육군훈련소에 들어가는 것은 처음이다 보니 뭘 챙겨야 할 지는 잘 알지 못한다. 그런데 인터넷 서핑을 통해 정보를 모았는데, 내가 준비한 물품은 이 정도가 되었다.

# 기본 보급품

![living_living-img_uni16_2_n](https://user-images.githubusercontent.com/45007556/105511750-9a55ad00-5d13-11eb-91be-97f1b5b60fe1.png)

## 필수

신분증, 나라사랑카드

## 준비물

- 휴지(휴지를 적게 지급받기 때문에 휴지가 부족하다고 한다)
- 물티슈(있으면 좋을 것 같다)
- 마스크(코로나 시대에 마스크는 필수이다)
- 라이트 기능이 있는 손목시계(야간에도 시간 확인이 가능한 라이트가 있는 것을 택해야 한다)
- 라이트 펜(밤에 불이 꺼진 상태에서 편지를 쓸 수 있어야 하기 때문에 필요하다)
- 네임펜(장비나 이름을 써야할 상황에 필요하다)
- 사제 위장크림(기본 지급이 되지만 피부가 민감하다면 챙겨야 한다. 이니스프리, 네이처 리퍼블릭, 아리따움 등에서 판매)
- 밴드(잔 상처에 의무실을 가기 어렵기 때문에 상처 밴드가 필요하다)
- 우표&편지 봉투&편지지(편지지는 자유롭게, 편지 봉투는 일반규격 편지 봉투, 우표는 선납등기, 일반우편 2종류를 준비해주자)
- 여분의 안경(만약 안경이 부서질 경우를 대비해 필요하다)
- 수첩(메모 용도로 써야 하기 때문에 필요하다)
- 세면도구(칫솔, 치약, 폼클렌징, 샴푸 등)
- 썬크림(자외선 차단용)
- 이어플러그(사격 소음 방지, 동기의 코골이 방지용으로 보급품으로 지급되지만 여분을 준비하자)
- 올인원 로션(이것저것 바를 시간 없다)
- 견출지(훈련소에서는 도난이 많이 발생되기 때문에 가지고 가는 소지품에는 모두 견출지를 붙여주자)
- 사제 팬티, 사제 양말(원칙적으로 불가능하지만 일단 챙기는 게 좋다고 한다)
- 사진(여자친구가 있다면... 필요하다)
- 큰 가방(훈련소 퇴소 시 짐을 담아야 하기 때문에 큰 가방을 하나 챙기는 것이 좋다고 한다)
- 읽을 책(교양서적이나 소설책 등을 챙기자. ex)클린코드,객체지향의 사실과 오해, 실용주의 프로그래머, 자격증 책 등 )

# 마지막으로

이 글을 내가 읽다보니 ~카더라 식으로 많이 작성하게 되었는데, 그 이유는 나도 아직 가본 적이 없다보니 들은 얘기를 정리해서 적는 방법 밖에 없었던 것 같다... 그래서 이번에 2021년 훈련소를 가보고 들은 것과 얼마나 다른 지 확인해보고 기회가 되면 후기도 적어보도록 하겠다.

2월달에 만나요~🧑🏻🤚🏻


훈련소 3주를 대비하는 방법


2020년은 짧고도 길었고, 코로나로 인해서 많은 추억은 쌓지 못했던 한 해이지만, 2020년을 거름 삼아 2021년에는 더 나은 내가 되기 위해 이슈들을 다뤄보고 반성해보는 시간을 가져보려고 한다.

# 2020년에는 무슨 일이 있었나?

## 운전면허

원래 운전면허 필기랑 기능 시험은 작년에 따두었지만, 도로주행은 계속 시간이 없어서 미루고 있었다. 그러던 중 더 이상 미루면 안되겠다고 생각이 들어서 도로주행을 응시한 끝에 여러 이슈가 터져 3번 만에 합격했다. 3번만에 붙게 된 이유는 너무 자신감에 넘쳐 있어서 사소한 것들을 놓치게 되었다. 역시 모든 일에는 자신감도 중요하지만, 기본을 놓쳐서는 안되는 것 같다.

## 학교

원래 학점에 대해서는 크게 신경을 쓰지 않는 편이었는데, 이번 연도에는 이상하게 학점이 잘 나와서 모든 학기 학점 4점대를 기록하였다. 그런데 일단 학점을 이렇게 받아보니 조금씩 욕심이 생기기 시작했다. 그냥 해도 이 정도인데, 진짜 열심히 했으면 4.5도 가능했을 거라는 아쉬움이 조금은 남는다. 다음 학기에는 더 열심히 해야겠다는 생각이 든다.

![image](https://user-images.githubusercontent.com/45007556/103433978-a8953980-4c3d-11eb-9625-20358e4d7a82.png)

## 깃허브 활동

8월 28일부터 일일 커밋을 시도해보자고 마음을 먹고 2020년 마지막 날까지 일일 커밋을 기록하였다. 하지만 커밋을 채우는데에 급급해서 질 좋은 코드를 많이 올리지는 못했다. 그리고 커밋할 시간은 한정되어 있기 때문에 결국 그 짧은 시간 안에 할 수 있는 작업만 하게 되고, 또 커밋이 끝나면 노트북을 덮게 되는 모습도 발견하게 되었다. 일일커밋에 의미를 두기 보다 질 좋은 코드를 올릴 수 있도록 더욱 분발해야 겠다.

![image](https://user-images.githubusercontent.com/45007556/103433980-b054de00-4c3d-11eb-99ab-2221e7fafb38.png)

co-duck은 깃허브 활동 장려를 위해 깃허브 활동을 수치화해 주는 서비스인데, 이 서비스에서 일일 커밋을 하면서 10시즌 11시즌을 거쳐왔었는데, 랭킹 20위에서 항상 시즌이 끝이 났었다. 그런데 12시즌에는 감격스럽게도 랭킹 10으로 시즌을 마치게 되었다.

![image](https://user-images.githubusercontent.com/45007556/103433983-b6e35580-4c3d-11eb-87cd-9d27ca4ac1f0.png)

## 블로그 활동

깃허브 일일 커밋 활동과 더불어 블로그 활동을 하기로 마음먹고, 깃허브 블로그를 구축하고, 총 40개 이상의 포스팅을 작성하였다. 되돌아 보면 건설적인 포스팅은 적은 것 같고, 내가 공부한 내용을 대충 정리해서 올린 글이 많아서 그런지 글들의 퀄리티가 떨어진다. 2021년에는 퀄리티 높은 건설적인 포스팅을 작성할 수 있도록 노력해봐야 겠다.

![image](https://user-images.githubusercontent.com/45007556/103433989-ce224300-4c3d-11eb-8be5-1eda14de0576.png)

## 회사

DB가 빽섭되거나 여러 개발 이슈가 있었는데, 우선 DB가 빽섭됐던 건은 DB 이중화 과정에서 문제가 생겨서 스토리지가 아예 날아갔다고 하는데, 우리가 잘못한 것도 아닌데 데이터 복구를 맡게 되었다. DB 쪽에는 아무것도 기대를 못하는 상황에서 다행히 DB 입력 시 WAS에 남기는 로그를 추적하여 log 파일을 내가 가장 자신 있는 언어인 Java로 전부 읽어들여서 엑셀 형태로 데이터 추출하는 방법으로 어느 정도 복구를 진행하였다. 그리고 자주 하는 업무에 대해서 Java를 통해 자동화를 하였고, 말년에는 Python을 통해서도 어느 정도 자동화 작업을 하였다. 역시 Java에 비해 Python의 문법이 간결해서 매우 큰 도움이 되었다. 덕분에 하반기에는 매우 업무가 편해질 수 있었다 :)

## 알고리즘/자료구조 공부

알고리즘이나 자료구조에 대해서 기초를 닦으려고 노력을 했는데, 깃허브 활동과 맞물려 도움이 된 것 같다. 깃허브에 push할 내용이 없을 경우 알고리즘 문제를 풀거나, 자료구조에 대해서 블로그에 포스팅하기도 했지만 아직은 매우 부족한 상태인 것 같다. 2021년에는 알고리즘이나 자료구조에 대해 이해를 높이고, 코딩테스트 문제도 열심히 풀어봐야 겠다.

## 디자인 패턴

싱글톤, 스트레티지, 데코레이터, 팩토리, 옵저버, 템플릿 등 여러 디자인 패턴들을 적용해서 Java로 로그 분석 프로그램을 개발해보았는데, 매우 좋은 경험이 된 것 같다. 그래서 이때 공부한 기억을 되새겨 블로그에 정리해보려고 생각해 보고 있다.

## 독서

2020년은 가장 많은 독서를 한 해인 것 같다. 여러 개발 서적들을 구매해서 읽었고, 시간이 날 때는 소설책도 틈틈이 읽었다. 하지만 너무 많은 책들을 산 게 독이 되어 오히려 완독한 책이 별로 되지 않는다. 2021년에는 한 권이라도 더 완독할 수 있도록 노력해야 할 것 같다.

## 사이드 프로젝트

공부해서 머리에만 집어넣는 것은 진짜 공부가 아닌 것 같아 UI는 간단하게 구성해서 SNS를 만들어 보려고 했는데 Kotlin, TypeScript, React, Redux-saga, Jpa, Jwt, Spring Security 등 몇 개는 많이 써온 기술이지만 생소한 기술들을 도입해서 같이 공부하자는 의욕이 오히려 독이 되어 완성이 되지 못했다... 사이드 프로젝트를 여러 개 진행해보면서 느낀 점은 시작은 쉬우나 끝까지 완성하기는 매우 어렵다는 점이었다. 2021년에는 완성되지 못한 사이드 프로젝트들을 다듬어 완성시켜야겠다. 그리고 사이드 프로젝트를 시작할 땐 익숙하지 않은 기술을 들이부어서는 안된다는 것을 느꼈다.(개발은 뒷전이고 공부만 죽어라 할 수 있다)

## 첫 컨퍼런스 참여

이름을 알만한 기업들은 연말에 개발자를 위한 컨퍼런스를 개최한다. 그런데 인터넷 서핑을 하던 중 2020우아콘을 온라인으로 진행한다는 광고를 보고, 생애 첫 컨퍼런스에 참여하게 되었다. 우아한 형제들이 해온 도전들과 그 노하우를 엿볼 수 있는 좋은 기회가 되었다.

![image](https://user-images.githubusercontent.com/45007556/103433993-daa69b80-4c3d-11eb-98a8-b512fc654906.png)

# 2021년 목표

2021년 목표는 다소 추상적인 목표로 정해 보았다.

1. 개발 서적 열심히 읽기/최소 3권 완독하기

2. 오픈소스 활동하기

3. 알고리즘 및 자료구조 공부하기

4. 디자인 패턴 공부하기

5. 클라우드 & DevOps 공부하기

6. 사이드 프로젝트 하기/완성하기

# 끝으로

2021년에는 꼭 게으른 나를 채찍질 하면서 더욱 치열하게 살아야 겠다.

그리고 2021년에는 꼭 목표했던 바를 이루고 자아성찰도 하면서 더 나은 내가 되도록 노력하려고 한다.


2020년 회고


문뜩 책장을 보다가 예전에 책을 사놓고 읽을 시간이 없다는 핑계로 읽지 않은 많은 책들이 눈에 들어왔다. 꼭 읽어야 하긴 한데 읽기는 귀찮고... 하기도 해서 새해에는 꼭 읽을 책들을 정리해보려고 한다. 보다 보니 책 욕심은 끝이 없는 것 같다.

# Clean Code

로버트 C 마틴이라는 소프트웨어 쪽에서 유명한 사람이 쓴 책인데, 제목대로 클린 한 코드를 작성하는 방법에 대한 책이다. 중간까지 매우 재밌게 읽다가 아이패드를 구매한 후부터 안 보기 시작했던 책이다.

<img src="https://user-images.githubusercontent.com/45007556/103358598-4c290180-4af9-11eb-900d-5f86aeaeb9eb.png" width="300" height="400" />

# 실용주의 프로그래머

이 책은 친구의 사수가 추천했다고 해서 생각하고 있다가, 알라딘에서 중고로 반값에 팔길래 샀던 책인데, 클린 코드 책을 읽고 있었기 때문에 뒤로 미루다가 어느새 기억 속에서 잊혔다. 책이 세로로 좀 더 긴 형태라 클린 코드보다 그립감이 좋다.

<img src="https://user-images.githubusercontent.com/45007556/103358591-459a8a00-4af9-11eb-9cb5-4a7fec3a7c3d.png" width="300" height="400" />

# 토비의 스프링

이 책은 ebook으로 소장하고 있는 책이다. 총 페이지 1720페이지나 되는 스프링의 바이블이라고 할 수 있는 책이다. 스프링 프레임워크를 쓰는 사람들은 꼭 필수로 읽어볼 필요가 있는 것 같다. 늘 도입부 부분만 읽다가 포기했는데 그 이유는 너무 두껍다 보니;; 부담스러워서 읽기 어려웠다. 꼭 한번 읽어봐야겠다.

<img src="https://user-images.githubusercontent.com/45007556/103358578-3e737c00-4af9-11eb-8408-4937ee7ddafd.png" width="300" height="400" />

# 자바 ORM 표준 JPA 프로그래밍

이 책은 JPA를 쓰기 전에 꼭 한번 읽어보는 게 좋을 것 같다. 김영한이라는 분이 쓰신 책인데, 현재는 인프런에서 JPA나 스프링 강의를 열심히 하고 계신 것 같다. 알차게 핵심 내용들이 다 들어있고, 두께는 토비 스프링 1권 정도 분량이다.

<img src="https://user-images.githubusercontent.com/45007556/103358561-3582aa80-4af9-11eb-9b60-b1693364abf0.png" width="300" height="400" />

# 객체지향의 사실과 오해

이 책은 객체지향에 대해 관심이 조금이라도 있는 개발자들은 들어는 봤을 것 같다. 이 책도 초반까지 읽다가 시간이 없다는 핑계로 읽다 만 책 중에 하나다. 저자가 내가 가지고 있던 객체지향에 대해서 가지고 있던 오해들을 짚어주고, 또한 사실에 대해서도 쏙쏙 짚어준다. 책 내용 중에서 이상한 나라의 엘리스라는 영화 내용에 빗대서 객체지향에 대해서 설명하는데 재밌게 읽었던 것 같다. 꼭 마지막까지 읽어봐야겠다.

<img src="https://user-images.githubusercontent.com/45007556/103358540-2bf94280-4af9-11eb-8568-c6e3d171ae1b.png" width="300" height="400" />

<hr/>
여기부터는 내가 가지고 있지 않은 책들이다.

# DDD START!

이 책은 도메인에 대한 책을 찾던 중 최범균님이 번역하신 책이라, 읽어봐야겠다 하고 선정하게 되었다. 무엇보다 예제 코드를 보았는데, 예제 코드만 보았을 때 꽤 내용이 괜찮을 듯싶었다.

<img src="https://user-images.githubusercontent.com/45007556/103358531-23a10780-4af9-11eb-8c83-ad0ba06ca85f.png" width="300" height="400" />

# 도메인 주도 설계 철저 입문

이 책은 책 표지가 심플하면서 이쁘고, 목차를 보았을 때 구성이 알차게 되어 있는 것 같아서 읽어봐야겠다 생각했다. 그리고 SNS에서도 많이 홍보를 하는 것 같아서 도메인에 대한 지식이 많이 부족한 나에게 알맞을 것 같다.

<img src="https://user-images.githubusercontent.com/45007556/103358514-1ab03600-4af9-11eb-98c2-2df0c9ab36f4.png" width="300" height="400" />

# 스프링으로 하는 마이크로서비스 구축

마이크로 서비스에 대해서 그동안 관심이 있어 왔는데 스프링으로 마이크로 서비스를 구축해볼 수 있다는 것이 맘에 들었고, 가장 최근에 나온 책이라 이슈도 적을 것 같아서 이건 꼭 한번 읽어봐야겠다.

<img src="https://user-images.githubusercontent.com/45007556/103358500-1126ce00-4af9-11eb-8185-47c21c1fc68b.png" width="300" height="400" />

# 마이크로서비스 패턴

이 책은 서점에 갈 때마다 맨날 보던 책이고, yes24 리뷰도 가장 많다. 이 책도 꼭 한번 읽어봐야겠다.

<img src="https://user-images.githubusercontent.com/45007556/103358483-05d3a280-4af9-11eb-9a46-ca29289bcbb8.png" width="300" height="400" />

# 테스트 주도 개발로 배우는 객체 지향 설계와 실천

테스트 주도 개발에 대해서 관심이 많은데 거기에 더해서 테스트를 통해 객체 지향 설계와 실천? 제목부터 흥미를 끄는 제목이다. 테스트 주도 개발을 통해서 어떤 식으로 객체 지향 설계를 하게 될지 궁금해지는 책이다.

<img src="https://user-images.githubusercontent.com/45007556/103358194-55fe3500-4af8-11eb-91b5-f319671b005d.png" width="300" height="400" />

# 테스트 주도 개발

이 책도 클린 코드 책을 냈던 출판사여서 믿고 한번 읽어봐야겠다 생각했던 책이다. 목차에 패턴에 대한 내용이 많은 것을 보면 꽤 알찬 내용이 담겨 있을 것 같아 기대가 된다.

<img src="https://user-images.githubusercontent.com/45007556/103358151-4121a180-4af8-11eb-874d-11b603697b26.png" width="300" height="400" />

# 시작하세요! 도커/쿠버네티스

지금껏 개발을 해오면서 언어나 프레임워크, 라이브러리 등을 배우는 데에는 거부감이 없었는데, 내가 잘 알지 못하는 개념이 가득한 인프라 관리나 클라우드에 관한 것에 대해서는 무지했었는데 이 책은 홍보도 많이 하고, 도커 같은 경우는 평소에 자주 써와서 한번 읽어봐야겠다고 생각했다.

<img src="https://user-images.githubusercontent.com/45007556/103358031-facc4280-4af7-11eb-9167-f1b70cf23a83.png" width="300" height="400" />

# 대규모 서비스를 지탱하는 기술

2020 우아콘에서 이동욱님이 추천하신 책 중에 하나인데, 대규모 서비스 개발하려는 사람들을 위한 입문서인 것 같다. OS나 컴퓨터 동작원리, DB 동작원리나 분산 방법 등 알찬 내용이 많이 포함되어 있어서 꼭 한번 읽어봐야겠다.

<img src="https://user-images.githubusercontent.com/45007556/103357981-d7a19300-4af7-11eb-921e-3e1c37002aec.png" width="300" height="400" />

# Real MySQL

이 책도 마찬가지로 2020 우아콘에서 이동욱님이 추천하신 책인데, MySQL에 대한 내용을 깊게 다루고 있어서 MySQL 공부를 위해서 꼭 한번 읽어봐야겠다.

<img src="https://user-images.githubusercontent.com/45007556/103357867-94dfbb00-4af7-11eb-8287-6c9783db8cd1.png" width="300" height="400" />


개발자인 내가 2021년에 읽어야 할 책들


apt-get을 통해 설치한 Gradle 버전이 4.4.1 버전이라 5버전 이상의 최신버전이 필요했기에 Gradle 최신 버전으로 설치하는 방법을 적어보려 한다.

# Jdk SE 8 이상 버전을 설치해주자

Gradle을 사용하려면 Jdk SE 8 이상 버전이 필요하기 때문에 jdk를 설치한다.

## Jdk 설치

```bash
sudo apt update
sudo apt install default-jdk
```

## 버전 확인

```bash
pi@raspberrypi:~ $ java -version
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Raspbian-1deb10u2)
OpenJDK Server VM (build 11.0.9.1+1-post-Raspbian-1deb10u2, mixed mode)
```

# Gradle 다운로드

## 다운로드 받기

/tmp 디렉토리에 gradle 압축파일을 다운로드 받는다.

```bash
wget https://services.gradle.org/distributions/gradle-6.7.1-all.zip -P /tmp
```

## 압축해제

다운로드 받은 압축파일을 압축해제한다.

```bash
sudo unzip -d /opt/gradle /tmp/gradle-*.zip
```

# 환경변수 설정

이제 다운로드 받았으니 gradle 사용이 가능하다. 하지만 어디에서나 사용하기 위해서는 환경변수를 설정해야 한다.

## gradle.sh 생성

/etc/profile.d 디렉토리 내에 gradle.sh 새 파일을 만들고 내용을 채워주면 된다.

```bash
sudo nano /etc/profile.d/gradle.sh
```

```sh
export GRADLE_HOME=/opt/gradle/gradle-6.7.1
export PATH=${GRADLE_HOME}/bin:${PATH}
```

## 스크립트 실행 가능하도록 설정

chmod 명령어는 Change Mode의 약자로 파일의 사용권한을 변경하는 명령어이다. 여기서 +x 옵션으로 모든 사용자가 실행할 수 있도록 사용 권한을 변경해주었다.

```bash
sudo chmod +x /etc/profile.d/gradle.sh
```

## 환경변수 로드

작성한 쉘 스크립트를 환경변수에 로드해준다

```bash
source /etc/profile.d/gradle.sh
```

# 최종 확인

그래들 버전을 확인했을 때 설치한 6.7.1 버전이 맞다면 성공이다.

```bash
pi@raspberrypi:~ $ gradle -v

------------------------------------------------------------
Gradle 6.7.1
------------------------------------------------------------

Build time:   2020-11-16 17:09:24 UTC
Revision:     2972ff02f3210d2ceed2f1ea880f026acfbab5c0

Kotlin:       1.3.72
Groovy:       2.5.12
Ant:          Apache Ant(TM) version 1.10.8 compiled on May 10 2020
JVM:          11.0.9.1 (Raspbian 11.0.9.1+1-post-Raspbian-1deb10u2)
OS:           Linux 5.4.79-v7+ arm
```

# 참고

[https://linuxize.com/post/how-to-install-gradle-on-debian-10](https://linuxize.com/post/how-to-install-gradle-on-debian-10)


Debian Linux Gradle 최신 버전 설치하기

스프링 부트에 마이바티스를 설정하면서 로그를 이쁘게 찍으려고 logback 설정했던 방법에 대해서 정리하려고 한다.

# 예제 프로젝트 다운로드

git bash가 깔려 있다면 아래 명령어를 사용해 logback 설정해볼 [예제 프로젝트](https://github.com/gunkim0318/SpringBoot-Mysql-MyBatis-Logback-Sample/tree/mysql-mybatis)를 받아주자. 만약 이미 프로젝트가 있다면 생략해도 된다.

```bash
git clone -b mysql-mybatis --single-branch https://github.com/gunkim0318/SpringBoot-Mysql-MyBatis-Logback-Sample.git
```

# 의존성 추가하기

logback 설정을 위한 의존성을 추가해주어야 한다. 예제 프로젝트를 받았다면 Gradle프로젝트이기 때문에 Gradle 의존성을 추가해주자.

## Maven

```xml
<dependency>
    <groupId>org.bgee.log4jdbc-log4j2</groupId>
    <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
    <version>1.16</version>
</dependency>
```

## Gradle

```java
implementation group: 'org.bgee.log4jdbc-log4j2', name: 'log4jdbc-log4j2-jdbc4.1', version: '1.16'
```

# 파일 생성하기

**/src/main/resources/** 경로에 파일 두개를 생성해주자.

## _log4jdbc.log4j2.properties_

```properties
log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator
log4jdbc.dump.sql.maxlinelength=0
```

## _logback-spring.xml_

```xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    
    <property name="LOGS_PATH" value="./logs"/>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <Pattern>%d{HH:mm} %-5level %logger{36} - %msg%n</Pattern>
        </layout>
    </appender>
    <appender name="DAILY_ROLLING_FILE_APPENDER" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOGS_PATH}/logback.log</file>
        <encoder>
            <pattern>[%d{yyyy-MM-dd HH:mm:ss}:%-3relative][%thread] %-5level %logger{35} - %msg%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOGS_PATH}/logback.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                
                <maxFileSize>5MB</maxFileSize>
                
            </timeBasedFileNamingAndTriggeringPolicy>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
    </appender>

    <logger name="com.nextday.gateway" level="INFO">
        <appender-ref ref="DAILY_ROLLING_FILE_APPENDER" />
    </logger>
    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>

    <logger name="jdbc" level="OFF"/>
    <logger name="jdbc.sqlonly" level="OFF"/>
    <logger name="jdbc.sqltiming" level="DEBUG"/>
    <logger name="jdbc.audit" level="OFF"/>
    <logger name="jdbc.resultset" level="OFF"/>
    <logger name="jdbc.resultsettable" level="DEBUG"/>
    <logger name="jdbc.connection" level="OFF"/>
</configuration>
```

# logback 관련 설정하기

```yml
spring:
  datasource:
    url: jdbc:log4jdbc:mariadb://{주소}:{포트}/{디비명}
    driver-class-name: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
    username: # 아이디
    password: # 비밀번호
```

url을 `jdbc:log4jdbc~`로 변경해주고, 드라이버 이름을 `net.sf.log4jdbc.sql.jdbcapi.DriverSpy`로 변경해주면 된다.

# 결과 확인하기

해당 테스트를 실행해보면 쿼리 결과가 보기 좋게 콘솔에 찍히는 것을 확인할 수 있다.
**_/src/test/com/sample/app/dao/TestDaoTest.java_**

```java
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestDaoTest {
    @Autowired
    private TestDao dao;

    @Test
    public void dao_테스트(){
        log.info(dao.selectTest());
    }
}
```

![이미지](https://user-images.githubusercontent.com/45007556/103171389-32848180-488f-11eb-85c5-e0144ebf6a28.png)

스프링 부트에서 logback 설정하기


한동안 JPA만 사용해오다가 오랜만에 MyBatis를 사용할 일이 생겨서 설정했던 설정 방법에 대해서 정리해보려고 한다. 그런데 스프링 부트는 워낙 설정이 간편해서 MyBatis 같은 경우는 설정이 정말 매우 간단하다. [예제 프로젝트](https://github.com/gunkim0318/SpringBoot-Mysql-MyBatis-Logback-Sample/tree/mysql-mybatis)

# 의존성을 추가하기

Maven을 사용할 경우 pom.xml에 Gradle을 사용할 경우 build.gradle에 의존성을 추가해주면 된다.

## Maven

```xml
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.22</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>
```

## Gradle

```java
implementation group: 'org.mybatis.spring.boot', name: 'mybatis-spring-boot-starter', version: '2.1.4'
implementation group: 'mysql', name: 'mysql-connector-java', version: '8.0.22'
```

# Mysql 설정 및 테스트

## 설정하기

프로젝트를 방금 생성했으면 application.yml이 없고, application.properties가 있을텐데 이 파일 확장자를 yml로 바꿔주자. 아니면 아래 내용을 properties형식으로 변환해서 작성해줘도 된다.
스키마명에는 본인의 스키마명을 적거나 없을 경우 빼도 상관 없다.  
**_main/resources/application.yml에 작성하기_**

```yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/{스키마명}?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false
    username: # 계정명
    password: # 패스워드
```

## 테스트코드 작성하기

**_/src/test/com/sample/app/db/ConnectionTests.java_**

```java
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ConnectionTests {
    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Test
    public void 커넥션_테스트(){
        try(Connection con = sqlSessionFactory.openSession().getConnection()){
            log.info("커넥션 성공!");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
```

해당 테스트가 성공하면 mysql 설정에 이상이 없는 것이고, 오류가 날 경우 설정을 확인해주자.
_@Slf4j어노테이션은 Lombok 설정이 안돼있을 경우 제외해주자. log.info는 System.out.println()으로 바꾸어 주어야 함_

## 테스트 결과

![image](https://user-images.githubusercontent.com/45007556/103111732-80cd3100-4693-11eb-8020-271e64545afd.png)

# MyBatis 설정 및 테스트

## 설정하기

**_/src/main/com/sample/app/config/MyBatisConfig.java_**

```java
@RequiredArgsConstructor
@Configuration
public class MyBatisConfig {
    private final ApplicationContext appCtx;

    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(appCtx.getResources("classpath:/mapper/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}
```

## 테스트를 위한 XML을 생성하기

classpath 경로에 mapper 폴더 생성 후 test.xml 파일을 만들어 준다.
**_/src/main/resources/mapper/test.xml_**

```xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "mybatis-3-mapper.dtd">

<mapper namespace="test">
    <select id="selectTest" resultType="string">
        SELECT now()
        FROM dual
    </select>
</mapper>
```

## 테스트하기

**_/src/test/com/sample/app/db/ConnectionTests.java_**

```java
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ConnectionTests {
    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    //...
    @Test
    public void 매퍼_테스트(){
        try(SqlSession sqlSession = sqlSessionFactory.openSession()){
            String sysdate = sqlSession.selectOne("test.selectTest");
            log.info(sysdate);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
```

# 마지막으로 DAO를 만들어 보기

위에서 테스트를 모두 마쳤기 때문에 한번 마지막으로 DAO를 만들어 보자.  
**_/src/main/com/sample/app/dao/TestDao.java_**

```java
@RequiredArgsConstructor
@Repository
public class TestDao {
    private final static String NAMESPACE = "test";

    private final SqlSession sqlSession;

    public String selectTest(){
        return sqlSession.selectOne(NAMESPACE+".selectTest");
    }
}
```

## 테스트하기

```java
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestDaoTest {
    @Autowired
    private TestDao dao;

    @Test
    public void dao_테스트(){
        log.info(dao.selectTest());
    }
}
```


스프링 부트에서 Mysql 및 마이바티스를 설정하는 법


코틀린으로 스프링 기반 백엔드 개발을 할 때 Lombok을 통한 빌더 패턴을 사용하지 못해서 이것만 해결되면 진짜 좋을텐데... 하면서 사용하다가 코틀린에서는 굳이 빌더 패턴을 사용하지 않더라도 비슷하게 개발이 가능하단 것을 알게 되어서 정리해보려고 한다.

# 자바에서

```java
@ToString
@Getter
@Setter
public class User{
    private String name;
    private String email;
    private Integer age;

    @Builder
    public User(String name, String email, Integer age){
        this.name = name;
        this.email = email;
        this.age = age;
    }
}
```

```java
User user1 = User.builder()
    .name("gunkim")
    .email("gunkim0318@gmail.com")
    .age(10)
    .build();
User user2 = User.builder()
    .name("gunkim")
    .age(10)
    .build();
```

그 동안 자바에서 객체를 생성할 때 Lombok을 통해 자동으로 생성해주는 Builder를 통해 객체를 생성해왔었다.

# 코틀린에서

```java
class User(
    var name: String,
    var email: String?,
    var age: Int
)
```

```java
val user = User(
    name="gunkim",
    email="gunkim0318@gmail.com",
    age=10
)
```

위의 자바 코드를 코틀린 코드로 바꿔보면 이렇게 된다. 그런데 빌더 패턴을 사용하는 이유는 크게 두가지 때문이다.

1. 인자가 많을 경우 해당 인자가 어떤 것을 의미하는 지 확인하기 힘듦
2. 특정 인자만으로 생성해야 할 때가 있음(불필요 인자는 null 할당)

그런데 위의 코드로는 1번은 만족하지만, 2번은 만족하지 않는데 그건 아래와 같이 해결이 가능하다.

```java
class User(
    var name: String,
    var email: String?=null,
    var age: Int
)
```

```java
val user = User(
    name="gunkim",
    age=10
)
```

해당 컬럼에 기본값을 주게 되면 그 인자는 값을 할당해주지 않더라도 기본값이 들어가므로 생성 할 수 있게 된다.

# 끝으로

코틀린은 자바의 단점들을 거의다 해결해주는 것 같다. 무엇보다 크게 느끼는 점은 자바에 비해 코드가 짧다는 것인데, 이미 많은 알만한 기업들은 코틀린으로 개발을 많이 한다고 하지만, 아직은 자바가 많이 쓰이는 추세이다. 하지만 근미래에는 코틀린으로 모두 옮겨지지 않을까 생각한다.


코틀린에서 빌더 패턴이 필요없는 이유


Hashtable과 HashMap이 무슨 차이야?라는 질문을 우연히 듣고 궁금해서 추적해본 내용을 포스팅해보려고 한다.

# Map이랑 똑같다?

어떤 차이점이 있는지 한번 사용해보았을 때, Hashtable 또한 Map처럼 key와 value를 통해 사용 가능하다는 것을 확인했다.

```java
import java.util.HashMap;
import java.util.Hashtable;
public class Main {
    public static void main(String[] args) {
        Hashtable<String, String> table = new Hashtable<>();
        table.put("name", "gun");

        HashMap<String, String> map = new HashMap<>();
        map.put("name", "gun");

        System.out.println(table.get("name"));
        System.out.println(map.get("name"));
    }
}
```

# Hashtable과 HashMap은 형제다

어째서 HashMap이랑 똑같을까? 의문을 풀기 위해서 찾아봤는데 이 둘은 동일하게 Map을 구현하고 있는 녀석이라는 것을 알아냈다. 그렇기 때문에 Map을 구현하고 있는 만큼 기능은 동일하다는 것을 유추할 수 있다.
![이미지](https://user-images.githubusercontent.com/45007556/102892298-0342ce80-44a3-11eb-97cc-981365354e3a.png)

# 그럼 뭐가 다를까?

_Hashtable.java_

```java
public synchronized V put(K key, V value) {
    if (value == null) {
        throw new NullPointerException();
    }
    //...
}
public synchronized V get(Object key) {
    //...
}
```

_HashMap.java_

```java
public V put(K key, V value) {
    //...
}
public V get(Object key) {
    //...
}
```

소스를 뒤져봤는데, 두가지 차이를 알 수 있었다.

1. Hashtable은 value의 null값을 허용하지 않음
2. Hashtable은 동기화 기능을 지원해줌

Hashtable이 동기화를 지원해주는 이유는 메소드에 붙은 synchronized 키워드 때문인데, 해당 키워드는 쓰레드 간 동기화 락을 통해 멀티 쓰레드 환경에서 데이터의 무결성을 보장해준다. 대신 Hashtable은 동기화 락 때문에 HashMap에 비해 속도가 느리다.

# HashMap과 Hashtable 어떨 때 사용할까?

동기화 처리가 필요할 경우 Hashtable, 동기화 처리가 필요 없을 경우 HashMap을 사용하면 될 것 같다.


Hashtable과 HashMap는 무슨 차이일까?


이번에 우연히 광고를 통해 알게 되어서 태어나서 처음으로 테크 콘서트를 참여할 수 있게 되었다. 코로나 시국이라 비대면으로 진행하게 돼어 어떻게 보면 나에게는 기회가 되었는데, 라인업을 보면 쟁쟁하신 분들이 많아서 보는 내내 나도 모르게 설레었다. 그래서 12월 18일까지 진행했던 우아콘에서 들었던 내용들을 정리해보면서 느낀점 등을 적어보려고 한다.[우아콘 오프닝 영상](https://www.youtube.com/watch?v=icY23VLRs7M&list=PLgXGHBqgT2TuFNlBkBRqf57__Z5IKfo8U&index=2)

# 송재하님 세션(지난 4년간의 Key Milestones)

가장 첫번째 세션이었고, 4분 정도 분량이었지만 이번 우아콘을 통해 전하고 싶은 핵심들을 전달하는 세션이 아니었을까 싶다. 우아콘의 취지 설명과 함께 우아한 형제들의 시스템이 어떻게 변화해왔는 지를 간략하게 설명하는 시간이었다. ASP기반의 스토어드 프로시저로 덮혀있던 시스템을 모두 JPA기반으로 자바 스프링 전환한 이야기, 스토어드 프로시저를 모두 걷어내어 MSA 형태로 모두 옮기고, 이어서는 모든 시스템을 AWS로 옮기고 최근에는 ERP마저 클라우드로 전향하였고, 클라우드 상에서 전자금융 시스템을 실제로 구축한 사례도 만들면서 우아한 형제들은 내외부 모두 클라우드 네이티브 환경으로 운영된다고 한다. 첫번째였던 만큼 가장 짧고 굵으면서 발표자분의 자신감이 엿보이는 세션이었던 것 같다.

# 김영한님 세션(배민 마이크로서비스 여행기)

이 세션은 배달의 민족이 마이크로서비스를 도입하면서 겪었던 비하인드 스토리? 같은 것들의 내용과 함께 마이크로서비스를 도입하면서 겪었던 이야기들을 설명해주셨다. 가장 재미있게 들은 내용은 쿠폰 시스템에 대한 내용이었는데, 쿠폰을 뿌리게 되면 잠시 동안 사용자가 엄청 몰리게 되어 부하를 견디지 못해 죽는 서버 문제를 해결하기 위해 긴급하게 장비 수급은 어려워서 AWS는 빠르게 증설이 가능하기 때문에 AWS에 모든 서비스를 올리게 되고, 몇 일만에 성공하게 되고 개발자들이 모두 엄청 기뻐했다는 이야기였는데, 나도 모르게 공감하게 되면서 재미있게 본 세션이었다.

# 권용근님 세션(배민 프론트 서버의 사실과 오해)

이 세션은 권용근님이 배민에 오기 전까지 혹은 프론트서버를 맡기 전까지 가지고 있던 프론트 서버의 오해에 대해서 다루는 세션이었다. 프론트 서버라고 하면 리액트를 돌릴 때 사용하는 그런 프론트서버를 말하는 줄 알았는데, 여기서 프론트 서버는 사용자와 가장 가깝게 맞닿아있는 서버를 말한다고 한다.

## 첫번째 오해-프론트 서버는 단순하다

처음에는 단순히 Spring+MVC+Redis 정도의 구조일거라 생각했지만 프론트 서버에는 두가지 특징이 있었으니...

- 수 많은 외부 서비스의 실시간 상태가 필요
  - 동시 요청+많은 트래픽+좋은 사용자 경험을 위해 비동기+논블로킹 I/O 기술을 지원하는 SpringWebFlux 도입
- MSA의 최전방
  - 각종 요구사항에 맞는 디비들을 적재적소에 배치 + 서비스 간 결합을 제거하여 정확성을 높임(MSA+CQRS)

### 결론

프론트 서버는 결코 단순하지 않다.

## 두번째 오해-프론트 서버는 객체, 도메인 중심적인 개발할 수 없다.

레이어 관점에서 Repository단의 데이터는 내 데이터가 아니기 때문에 Service를 통해 데이터를 조합해서 사용자에게 전달될 수 밖에 없기 때문에 객체지향적이나 도메인적으로 풀어나갈 수 없지 않나?라는 생각을 가지셨다고 한다. 여기 두번째 오해에 대해서 들으면서 점점 정신이 멍해졌는데.. 정리하자면 Service-Repository 간에서는 도메인, 객체지향 형태의 개발이 어렵기 때문에 안정된 의존 관계 원칙(SDP), 안정된 추상화 원칙(SAP), 의존 역전 원칙(DIP) 등을 적용해서 중간에 Domain을 추상화해 껴넣음으로써 도메인, 객체지향 형태로 개발할 수 있도록 했다는 내용이었다.

이 세션을 들으면서 클린 아키텍처라는 책은 꼭 한번 읽어봐야 겠다는 생각이 들었다. 클린 아키텍처를 읽고 해당 세션의 내용을 다시 한번 되새겨봐야 겠다.

# 이동욱님 세션(수십억건에서 Querydsl 사용하기)

다른 분들은 직접적인 코드가 아닌 어떤 노하우나 경험, 아키텍처 등에 대해서 말씀해주셨다면, 이동욱님은 직접적인 코드를 통한 경험을 전수해주셨다. 이 파트는 워낙 관심 가졌던 주제라 열심히 정리해보았다.

## Querydsl을 설정 팁

1. 상속과 구현을 통한 방법
2. Support를 상속받고, Supper 생성자에 Entity를 등록하는 방법

위의 두가지 방법은 매번 상속구현, Support상속-엔티티 등록 해야 하는 번거로운 문제가 있었는데, [JPAQueryFactory](https://jojoldu.tistory.com/372)만 빈을 주입해도 Querydsl 사용이 가능하다.

## 동적 쿼리 팁

일반적으로 **Boolean Builder**를 통해 동적쿼리를 사용하는데, **Boolean Builder**를 사용할 경우 조건문이 너무 늘어남에 따라 가독성이 안 좋기 때문에 어떤 쿼리인지 예상이 어려운 문제가 있었다.

이를 해결하기 위해 [Boolean Expression](https://jojoldu.tistory.com/394)을 사용하는데, 메소드 형태로 만들어서 해당 값이 null 반환이 될 경우 자동으로 조건이 제거되도록 처리를 해주면 된다.

## Querydsl에서 exists는 직접 구현해서 사용하자

### SQL에서 exists와 count의 성능 차이

exists는 첫번째 값이 발생되면 검색을 멈추는데, count은 첫번째 값이 발생하더라도 마지막까지 모든 조건을 체크하기 때문에 스캔 대상이 앞에 있을수록 더 심한 성능차이 발생한다.

### exists를 개선?

Querydsl의 exists는 SQL.count를 사용한다. 그리고 Querydsl는 from절의 서브쿼리가 지원되지 않기 떄문에 개선할 수도 없다. 왜냐하면 exists는 where절에서만 사용 가능하다.

### 그럼 exists를 만들어서 쓰자

#### 구현 조건

조건에 해당하는 row 1개만 찾으면 쿼리 종료

#### 구현 방법

limit 1로 조회를 제한, 이 때 조회 결과가 없으면 null이 반환되기 때문에 null인지를 체크해주자. [자세한 내용](https://jojoldu.tistory.com/516)

### 결과는?

실제 SQL.exists와 성능 차이가 거의 나지 않는다.

## Cross Join을 회피하자

### 왜 안좋은가?

일부 DB에서는 어느정도 최적화가 지원되지만, 나올 수 있는 모든 경우에 대해서 조인되기 때문에 DB에 기대하지 말고 왠만하면 회피하는 것이 좋다.

### 회피 방법

묵시적 Join을 사용할 경우 Cross Join이 발생하기 떄문에 명시적 Join을 사용하여 Inner Join이 발생하도록 하면 된다.

## Entity보다 Dto를 이용할 경우의 최적화 방법

[자세한 내용](https://jojoldu.tistory.com/518)

### 엔티티 조회 시 문제점

단순 조회 기능에서는 성능 이슈가 많은데,

1. 하이버네이트 캐시 문제(1차 캐시, 2차 캐시 등)
2. 불필요한 컬럼 조회
3. OneToOne 연관관계에서의 N+1 발생

### 조회 컬럼 최소화하기

이미 알고 있는 값에 대해서 as 표현식으로 대체하자(select에서 제외됨)

### Select절에 컬럼 엔티티 자제하기

Select절에 엔티티를 사용할 경우 문제점

1. 사용하지도 않는 컬럼임에도 굳이 조회가 발생
2. OneToOne 연관관계가 맺어져 있을 경우 Lazy Loading이 안되기 때문에 무조건 N+1 무조건 발생
3. 엔티티 컬럼 전체가 Distinct 대상이 되어 distinct를 위한 임시 테이블 공간과 시간이 더 필요하기 때문에 기존 대비 성능 많이 떨어짐

### 결론

진짜 필요한 엔티티가 아니라면 Querydsl과 Dto를 통해 필요한 항목들만 조회하고 업데이트 한다.

## Group by 최적화 방법

일반적으로 Mysql은 Group by 진행 시 filesort가 필수적으로 발생함. 이 경우는 해당 쿼리가 인덱스를 타지 않았을 경우인데, 모든 쿼리가 인덱스를 탄다는 보장은 없기 때문에 filesort가 발생하지 않도록 하자. mysql에서는 order by null을 사용할 경우 filesort가 제거된다.

### 문제

Querydsl에서는 order by null 문법을 지원하지 않음.

### 해결 방법

order by null 기능을 구현해서 사용. 이동욱님은 OrderByNull이라는 클래스를 구현해서 해당 클래스를 OrderBy 문법에 넣어주는 방법으로 order by null이 발생하도록 하셨다고 한다. [자세히보기](https://jojoldu.tistory.com/477)

### 팁

정렬이 필요하더라도 조회 결과가 100건 이하라면 WAS에서 정렬하는 것을 추천한다. 왜냐하면 DB보다 WAS쪽 자원이 여유롭기 때문. 하지만 페이징을 이용한다면 order by null 사용이 불가함.

## Querydsl에서 커버링 인덱스를 사용하는 방법

### 커버링 인덱스란?

쿼리를 충족시키는데 필요한 모든 컬럼을 갖고 있는 인덱스.

### 쓰는 이유

NoOffset방식과 더불어 페이징 조회 성능을 향상시키는 가장 보편적인 방법

### Querydsl에서는 사용 불가

왜냐하면 from절 서브쿼리를 지원하지 않기 때문에 사용 불가

### 우회한 방법으로 구현

클로저 키(PK)를 커버링 인덱스로 빠르게 조회하고, 조회한 Key로 Select 컬럼들을 후속 조회한다.
결국, 하나의 쿼리로 할 수 있는 것을 두번으로 나눠서 조회하라는 내용이다.[자세히보기](https://jojoldu.tistory.com/476)

### 효과

기존 커버링 인덱스와 거의 비슷한 성능을 보여준다.

## 업데이트 최적화 방법

일반적으로 객체지향을 핑계로 더티 체킹 방식으로 모든 값이 업데이트 되는 것이 아니더라도, 모든 컬럼을 조회 후 업데이트를 치게 된다.

### 더티체킹의 문제를 일괄 업데이트를 통해 해결하는 방법

Querydsl.update를 통해 한번에 업데이트를 치는게 좋음.[자세히 보기](https://jojoldu.tistory.com/415)

### 효과

1만건 기준으로 2000배 정도 차이가 남.

### 일괄 업데이트의 단점은?

하이버네이트 캐시는 일괄 업데이트 시 캐시 갱신이 안됨. 이럴 경우 업데이트 대상들에 대한 Cache Eviction이 필요

### 용도에 구분해서 사용하자

- 더티 체킹 - 실시간 비즈니스 처리, 실시간 단건 처리 시 효율적
- Querydsl.update - 대량의 데이터를 일괄로 Update 처리 시 효율적

하이버네이트 캐시 갱신이 필요없는 서비스에서만 Querydsl.update를 고려하는게 좋음.

## Bulk Insert는 자제하자

### 이유

JDBC에는 rewriteBatchedStatements를 사용하는데 Insert합치기 옵션을 넣어도, JPA는 auto_increment일 때 insert 합치기가 적용되지 않는다.

### JdbcTemplate를 사용한 개선 방법

JPA를 쓰기보다, JdbcTemplate으로 처리하면 됨. 하지만 컴파일 체크, 코드-테이블 간 불일치 체크 등 Type Safe한 개발이 어려운 단점이 있음.

### JdbcTemplate의 단점을 보완한 방법

지금까진 Querydsl-JPA를 사용한 방법인데, Querydsl-JPA는 Querydsl의 하위 프로젝트로, 다른 Querydsl-SQL 프로젝트 통한 엔티티QL을 사용한 방법인데, JPA엔티티 기반으로 Querydls-SQL QClass 생성하고, 엔티티QL로 만들어진 Querydsl-SQL의 QClass를 사용하면 BulkInsert가 가능해진다.

### 결과

1. 단일 엔티티 1만건 insert 시 135배의 차이가 발생.
2. OneToMany 같은 경우에도 약 6배 정도 발생

### 하지만...엔티티QL의 단점은 꽤 많았으니..

1. Gradle 5 이상 필요(플러그인이 gradle 5 이상에서만 작동)
2. 어노테이션에 (name="") 필수
   1. @Column의 name값으로 QClass 필드가 선언되기 때문
   2. @Table의 name값으로 테이블을 찾을 수 있다.
3. primitive type 사용 불가
   1. 기본형 int, double, boolean 등 사용 불가.
   2. 모든 컬럼은 Wrapper Class로 선언해야 한다.
4. Querydsl-sql이 개선되지 못해 불편한 설정 많음
5. @Embedde 미지원
   1. @Embedded 어노테이션을 통합 컬럼 인식 불가
   2. @JoinColumn 미지원
6. Querydsl-SQL의 미지원으로 insert쿼리를 @Column의 name으로 만들 수 없음(컬럼명과 필드명이 일치해야 하는 BeanMapper만 지원) 즉 @Column용 Mapper가 별도로 필요
7. Querydsl-SQL 설치의 번거로움
   1. 로컬 PC에 DB 설치 후 실행
   2. Gradle/Maven에 로컬 DB 정보 등록 후 flyway로 테이블 생성
   3. Querydsl-SQL 플러그인으로 테이블 Scan해서 QClass 생성

이렇다 보니 이동욱님도 권장한다기 보다 최악이 아닌 차악을 고른다는 마음으로 사용하신 기술이라고 하셨음. 그만큼 JdbcTemplate를 사용한 방법이 최악이라는 것..

## 마지막으로

1. 상황에 따라 ORM / 전통적 쿼리 방식을 골라 사용
2. JPA / Querydsl로 발생하는 쿼리 한번더 확인하기
3. 두권의 책(JPA, 리얼 Mysql) 추천

# 느낀점

이렇게 개발자들을 위한 콘서트를 참가해본 건 이번 우아콘이 처음이었는데, JVM 기반 언어로 개발하면서 우아한 형제들이 업계에 끼치는 영향은 무시할 수 없는 수준인 것 같다. 이번 우아콘을 들으면서 우아한 형제들에서 그 동안 엄청 많은 도전을 해왔고, 그 도전들이 긍정적이든 부정적이든 많은 개발자들에게 영감을 주고, 한편으로는 강한 동기부여를 해주었던 것 같다. 가장 기억에 남는 문구는 이동욱님이 말씀하신 마지막 말씀인데, **"상황에 따라 기술을 골라 사용할 것"**인데 당연한 말 같으면서도 나도 모르게 간과하고 있던 사실인 것 같다. 어떤 기술을 하나 파게 되면, 나도 모르게 그 기술을 맹신하게 되는 경우가 있는데 어떤 기술이든 장단점이 있고, 적재적소에 맞는 기술을 적용하는 것은 개발자에게 매우 중요한 역량이 아닐까 싶다. 이번 우아콘을 들으면서 나 자신에게 또 다시 동기부여를 하게 만드는 귀중한 시간이었던 것 같다.


우아한테크콘서트 2020 후기


[일일커밋 시작하기](/일일커밋-시작하기)를 작성하고, 일일커밋 115일가 되었다. 100일도 아니고 애매하게 115일에 회고를 하는 이유는 내가 그 동안 게을렀던 것도 있지만, 회고를 해본 적이 없다보니 두려움도 있었던 것 같다. 더 미루기 전에 나에 대해 돌아 보면서 반성해보는 시간을 가지려고 한다.

# 무엇이 바뀌었나?

일일 커밋을 시작하고 매일매일 집에 와서 컴퓨터 앞에 앉아 코드를 작성하는 내 모습을 볼 수 있었다는 점이다. 일일 커밋을 하기 전에도 꾸준히 개발 서적을 읽거나, 공부는 해왔지만 실질적인 코드를 작성 안 하게 되는 날이 더 많았다. 하지만 일일 커밋을 진행하면서 사이드 프로젝트를 진행했고, 커밋 할 작업이 없는 날에는 기존에 작성한 코드를 리팩토링 하거나, 알고리즘 문제를 풀어서 커밋을 진행하였다. 하루 종일 어떤 코드를 작성할까? 어떻게 적용해볼까? 하는 등의 고민을 하면서 코드를 작성할 생각에 설레는 나 자신도 볼 수 있었다.

![image](https://user-images.githubusercontent.com/45007556/102243148-2f5bce00-3f3e-11eb-8b82-30d93ed791d7.png)

# 어떤 것이 힘들었나?

![image](https://user-images.githubusercontent.com/45007556/102315321-4ab6ef80-3fb7-11eb-93b0-f8a7b17235ca.png)

## 압박감

매일매일 커밋을 해야 한다는 압박감이 가장 힘들었던 것 같다. 집에 와서 피곤할 때나 늦게 들어오는 날에도 어김없이 컴퓨터를 붙잡고 커밋할 작업을 찾고, 12시가 지나기 전에 커밋을 해야 한다는 사실이 은근히 부담감으로 다가오기 시작했다. 저녁에 약속이 있는 날에는 오전에 짬을 내서라도 작업을 해놓는데, 피곤한 날에는 그마저도 안해놔서 집에 와서 잠깐 눈을 붙이고 시계를 봐가면서 작업을 했던 것 같다.

## 부족한 시간

집에 오면 8시 정도가 평균인데, 자취를 하기 때문에 집에 와서 컴퓨터 앞에만 앉아 있을 순 없다. 밥도 해야 하고, 빨래도 해야 하고, 강아지도 키우기 때문에 산책도 다녀오게 되면 시간은 더욱 부족해진다. 거기에 추가로 어떻게 개발해야 하지? 하고 고민하는 시간이 길어질 수록 더더욱 작업할 시간이 부족해진다. 그래서 커밋에 쫓기는 경향이 강했던 것 같다.

## 커밋을 위한 커밋

여러 일일커밋에 대한 회고를 보았는데, 공통적으로 이 점에 대해서 많은 분들이 나와 같이 느낀 것 같다. 시간이 부족하기 때문에 그 시간 안에 할 수 있는 작업은 한정적이어서, 짧은 시간 안에 코딩할 분량 정도만 코딩을 하게 된 것 같다.

# 그리고 지켜지지 않는 규칙

## 커밋 규칙

1. 의미있는 코드 커밋
2. 명확한 커밋 로그 작성
3. 블로그 포스팅은 커밋에서 제외

시작할 때 위와 같이 간단한 규칙 3가지를 정했는데, 시간이 부족하고, 커밋할 게 없다는 핑계로 때때로 지켜지지 못했다. 진짜 없을 때는 간단하게 css나 디자인 정도만 수정하고 커밋하는 일도 있었다. 규칙이 잘 지켜지지 않은 점을 반성하고, 앞으로는 규칙이 잘 지켜질 수 있도록 노력해야 겠다.

# 어떤 것을 느꼈나?

이건 일일커밋에 대한 것보다 사이드 프로젝트([SNS 프로젝트](https://github.com/gunkim0318/springboot-kotlin-react-sns))를 진행하면서 느낀 점인데, 사이드 프로젝트를 진행할 때 너무 욕심을 내면 안되는 것 같다. 단순하게 (자바+스프링+마이바티스)은 많이 써봤으니 이번엔 리액트로 화면을 만들어 보자! 까지는 괜찮았는데 이것저것 해보자 하고 두마리 토끼를 다 잡으려다가 두마리 모두를 놓친 것 같다. 최종적으로 이 프로젝트에 써보지 않거나 익숙하지 않은 리액트,타입스크립트,코틀린,리덕스 사가,JPA,코틀린 등 까지 모두 추가되다 보니 각각 공부할 시간도 매우 부족한데 코드를 작성할 시간은 더 부족하게 되니까 이런 것들이 나비 효과를 일으켜 힘듦(압박감+부족한 시간+커밋을 위한 커밋)을 불러온 것 같다. 그래서 사이드 프로젝트를 진행할 때는 요구사항을 먼저 정리하고, 어떤 기술을 사용할 것인지 정하고, 어느 기간 안에 완료할 것인지를 초반에 견적내는 능력이 중요하다는 것을 115일 동안 크게 깨닫게 된었다. 이것 하나만으로도 엄청 중요한 것을 배웠고, 너무 처음부터 완벽한 코드에 대한 집착을 가지는 것이 일일커밋에 독이 된다는 사실도 알았다. 나중에 리팩토링을 하더라도 머릿 속에 있는 지식을 끄집어 내도록 하자.


일일커밋 115일 회고


오래된 지킬 테마를 다운 받고, 실행 시켰더니 처음 보는 종류의 빌드 오류가 발생해서 해당 내용 정리하려고 한다.

# 문제 상황

```bash
PS C:\Users\gunkim\workspace\git\gunkim0318.github.io> jekyll server
Configuration file: C:/Users/gunkim/workspace/git/gunkim0318.github.io/_config.yml
       Deprecation: You appear to have pagination turned on, but you haven't included the `jekyll-paginate` gem. Ensure you have `plugins: [jekyll-paginate]` in your configuration file.
            Source: C:/Users/gunkim/workspace/git/gunkim0318.github.io
       Destination: C:/Users/gunkim/workspace/git/gunkim0318.github.io/_site
 Incremental build: disabled. Enable with --incremental
      Generating...
Markdown processor: "redcarpet" is not a valid Markdown processor.
                    Available processors are: kramdown

  Liquid Exception: Invalid Markdown processor given: redcarpet in about.html
             ERROR: YOUR SITE COULD NOT BE BUILT:
                    ------------------------------------
                    Invalid Markdown processor given: redcarpet
                    ------------------------------------------------
      Jekyll 4.1.1   Please append `--trace` to the `serve` command
                     for any additional information or backtrace.
                    ------------------------------------------------
```

# 해결 방법

> redcarpet -> kramdown

구버전 Jekyll 3.0 미만 테마들에 한해서 redcarpet 마크다운 프로세서를 사용할 경우 오류가 나는 상황이 발생해서 \_config.yml의 markdown 항목의 **redcarpet**를 **kramdown**으로 변경해서 해결해주었음.


Jekyll 'Invalid Markdown processor given: redcarpet' 에러


지킬 테마를 다운 받아서 실행할 때 간혹 지킬 버전 호환성 때문에 오류가 날 때가 있는데, 그럴 때마다 찾아보기 귀찮아서 정리해놓음.

# 문제 상황

```bash
gimgeon-ui-MacBook-Pro:kross-jekyll-master gunkim$ jekyll server
Traceback (most recent call last):
	12: from /usr/local/bin/jekyll:23:in `<main>'
	11: from /usr/local/bin/jekyll:23:in `load'
	10: from /Users/gunkim/.gem/ruby/2.7.0/gems/jekyll-4.1.1/exe/jekyll:11:in `<top (required)>'
	 9: from /Users/gunkim/.gem/ruby/2.7.0/gems/jekyll-4.1.1/lib/jekyll/plugin_manager.rb:52:in `require_from_bundler'
	 8: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler.rb:149:in `setup'
	 7: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/runtime.rb:20:in `setup'
	 6: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/runtime.rb:101:in `block in definition_method'
	 5: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/definition.rb:226:in `requested_specs'
	 4: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/definition.rb:237:in `specs_for'
	 3: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/definition.rb:170:in `specs'
	 2: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/spec_set.rb:80:in `materialize'
	 1: from /Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/spec_set.rb:80:in `map!'
/Users/gunkim/.gem/ruby/2.7.0/gems/bundler-2.1.4/lib/bundler/spec_set.rb:86:in `block in materialize': Could not find public_suffix-4.0.5 in any of the sources (Bundler::GemNotFound)
```

# 해결 방법

1. 지킬 프로젝트 내 Gemfile.lock 파일 삭제
2. 터미널에서 **bundle install** 명령어 실행


Jekyll 하위 버전 실행 시 오류


플라스크를 깊게 사용은 안해보더라도, 나중에 플라스크를 써야할 때 내가 다시 찾아보려고 정리해놓으려고 한다.

# 플라스크(Flask)란?

![image](https://user-images.githubusercontent.com/45007556/112269831-3d975400-8cbc-11eb-88ea-e9934d534fbb.png)

파이썬에서 웹 개발을 도와주는 프레임워크인데, 사람들이 흔히 '마이크로 웹 프레임워크'라고 한다. 이유는 파이썬 파일 한개만 있어도 웹 프로그램 작성이 가능하다. ~~ㄷㄷㄷ~~
마이크로 웹 프로젝트 답게 매우 경량화되어 있어서 직접 라이브러리를 설치하고 개발환경 셋팅하면서 파이썬에 더 익숙해지기 좋을 것 같다. ~~이게 싫으면 장고로 가자~~

# Hello World! 출력하기

## Flask 설치하기

> pip install flask

터미널에서 이 명령어만 쳐주게 되면 손쉽게 Flask가 설치된다.

## 코드 작성하기

```py
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1>Hello! World!</h1>"

if __name__ == "__main__":
    app.run()
```

## 플라스크 실행하기

> Flask run

해당 파이썬 경로에서 이 명령어를 쳐주면 손쉽게 실행이 된다.
![image](https://user-images.githubusercontent.com/45007556/99931839-6e608e80-2d99-11eb-98bd-721dff6bef54.png)

## 확인하기

> localhost:5000

해당 경로에 들어가서 Hello World! 메시지를 확인할 수 있다.
![image](https://user-images.githubusercontent.com/45007556/99931902-9f40c380-2d99-11eb-9c4d-1637fba6e0e8.png)

# REST API로 Hello World! 출력하기

## Flask-RESTful 설치하기

> pip install flask-restful

Flask는 이미 설치가 되어 있으니 Flask-RESTful만 추가로 설치해주면 된다.

## 코드 작성하기

```py
from flask import Flask
from flask_restful import Resource, reqparse, Api

class HelloWorld(Resource):
    def get(self):
        list = [ "Hello!", "World!" ]
        return list

app = Flask('My First App')
api = Api(app)

api.add_resource(HelloWorld, '/sayHello')

if __name__ == '__main__':
    app.run()
```

HelloWorld라는 클래스를 만들어주었는데, 이 때 메소드명을 get, post, put, delete 등으로 지어주면 자동으로 해당 요청 메소드로 매핑된다.

## 플라스크 실행하기

> flask run

해당 파이썬 경로에서 이 명령어를 쳐주면 손쉽게 실행이 된다.
![image](https://user-images.githubusercontent.com/45007556/99932130-7d940c00-2d9a-11eb-922e-65e404897d78.png)

## 확인하기

> localhost:5000/sayHello

![image](https://user-images.githubusercontent.com/45007556/99932243-d82d6800-2d9a-11eb-8c07-8406bcec48c0.png)

# 마지막으로

파이썬을 써보면서 너무 간편하고, 빠르게 여러 라이브러리를 사용해서 개발할 수 있다는 것에 매력을 느꼈는데, 플라스크는 그런 파이썬을 언어로 해서 가볍게 웹 개발을 할 수 있다는 점에서 매우 매력 있는 것 같다. 나중에 플라스크로 토이 프로젝트라도 해봐야 겠다.


Flask 웹 프레임워크를 이용한 Hello World! 출력하기


자바스크립트를 사용하면서 es5, es6 문법들을 사용하면서 대충 자바스크립트 버전 아니야? 라고 생각하고 사용했었는데, 어떻게 보면 맞다고 할 수도 있는데 어떻게 보면 아니라고 할 수 있다. 문득 궁금해져서 간략하게 나마 정리하려고 한다.

# ES(ECMAScript)가 뭐야?

**ES? 자바스크립트 버전 아니었어? 뜬금없이 ECMAScript가 뭐야?** 생각이 들 수도 있다.
![image](https://user-images.githubusercontent.com/45007556/99825837-e7de5e00-2b9a-11eb-86cd-3fb684123ec0.png)

ECMAScript는 쉽게 말하면 ECMA라는 비영리 단체가 자기네들이 만든 ECMA-262라는 기술 규격에 따라서 정의한 표준화된 스크립트 언어다. ES5, ES6 등은 ECMAScript의 버전5, 버전6 같은 개념으로 받아들이면 된다.

# 그럼 JS(JavaScript)랑은 뭐가 달라?

![image](https://user-images.githubusercontent.com/45007556/99826279-7c48c080-2b9b-11eb-8cce-3c92f971c803.png)
ECMAScript와 JavaScript는 완전 다른 것은 아니고, JavaScript의 표준화를 위해 만들어진 게 ECMAScript이고, JavaScript는 ECMAScript의 사양을 표준으로 따르는 언어다.

# ES버전별로 뭐가 달라?

가장 대표적인 ES5, ES6 위주로 대략적인 것만 정리해 보려고 한다.

- **ES3**
  - 흔히 말하는 자바스크립트
- **ES5**
  - 배열에 **forEach, map, filter, reduce, some**과 같은 메소드 지원
  - Object에 **getter, setter** 지원
  - JSON 지원
- **ES6(ES 2015)**
  - **let, const** 키워드 추가 - 변수를 선언할 때 함수 스코프를 가진 var키워드를 대체하기 위해 여타 언어와 똑같이 **블럭 스코프**를 가진 **let, const** 키워드 추가
  - arrow 문법 지원 - 편하고 간결하고 this 바인딩을 하지 않는 화살표 문법 추가
  - **iterator, generator** 추가
  - module **import, export** 키워드 추가 - 모듈을 임포트 받거나, 모듈을 내보낼 수 있도록 **import, export** 키워드 추가
  - **Promise** 추가-그 동안 콜백지옥에서 고통받던 개발자들을 위해 **비동기 처리하는 객체** 추가
- **ES8(ECMA 2017)**
  - **async - await** 도입 - Promise와 같이 비동기 처리를 위한 키워드로, **Promise보다 간결하고 직관적**이다.
- **ES7(ES2016)**
- **ES8(ES2017)**
- **ES9(ES2018)**
- **ES10(2019)**

# 브라우저마다 지원하는 ECMAScript가 다르다?

![image](https://user-images.githubusercontent.com/45007556/99863269-b6888100-2be0-11eb-94d4-1613cf98b5eb.png)

처음에는 ES를 단순 버전 정도로 생각해서 ES가 없데이트 되면 자동으로 모든 브라우저에서 새로 추가된 ES문법들을 지원할거라고 생각했다.
그런데 이는 브라우저마다 다른데, 왜냐하면 브라우저 회사마다 각각의 자바스크립트 엔진이 있어서 그렇다.
그래서 만약 ES6 문법으로 개발하면 익스플로러 같은 경우 es6를 지원하지 않아서 익스플로러에서는 제대로 작동하지 않을 수 있다.
~~이래서 자바에서는 JVM을 만들었나 보다~~

## 자바스크립트 엔진들

- **Rhino** - 모질라
- **SpiderMonkey** - 파이어폭스
- **V8** - 구글, 오페라
- **JavascriptCore** - 사파리
- **Chakra** - 익스플로러, 마이크로소프트 엣지

# 호환성 문제의 해결

es6를 지원하지 않으면 es6 이하 버전 문법들만을 사용해서 개발하는 방법도 방법이다. 하지만 그러기에는 너무 생산성이 좋지 않다.

## 바벨(Babel)을 이용한 방법

![1_DGJT51DxMSbsRNuF6J_c6Q](https://user-images.githubusercontent.com/45007556/99864982-e5572500-2be9-11eb-8d57-06e5cccaae37.jpeg)

그래서 이를 해결하기 위해 나온 방법이 컴파일러 및 트랜스파일러의 역할을 하는 바벨(Babel)을 이용해서 es6로 작성된 코드를 es5로 변환해서 배포하는 방법이다.


ECMAScript? ES? 그게 뭘까?


보통 문자열을 자릿수로 자를 때는 String클래스에서 지원해주는 substring() 메소드를 사용해서 자르는데, 이번에는 특별하게 문자열을 바이트로 잘라야 하는 경우가 발생해서 해당 방법을 정리해보려고 한다.

# String -> Byte

```java
String name = "gunkim";
byte[] nameBytes = name.getBytes();
```

# Byte -> String

```java
byte[] nameBytes = "gunkim".getBytes();

String name = new String(nameBytes);
```

# 바이트 자르기

```java
String name = "gunkim";
byte[] nameBytes = name.getBytes();

String cutName = new String(nameBytes, 0, 3); //result - gun
```

위의 예제에서는 0바이트 부터 3바이트까지 잘랐다. 바이트를 문자열로 변환할 때와 똑같은데, 뒤에 인자를 두개 더 주면 된다.

## 알고있어야 할 점

```java
String name = "한국";
byte[] nameBytes = name.getBytes();

String cutName = new String(nameBytes, 0, 4); //result - 한�
```

영어나 숫자는 1바이트라서 그냥 잘라도 예상하던 결과가 나오겠지만, 한글의 경우 한 글자당 3바이트라서 3바이트를 온전히 자르지 않을 경우 문자열로 변환했을 때 한글이 깨질 수 있다.


Java Byte<->String 변환 방법 및 바이트로 자르기


영속성 전이와 관련되어서 크게 삽질한 내용이 있어서 정리할 겸 같이 작성해보려고 한다.

# 영속성 전이란?

영속 상태의 엔티티 객체에 수행되는 작업이 연관된 자식 엔티티까지 전파되는 것이다.

## 전파되면 뭐가 좋은데?

아래 예제 코드를 보면서 영속성 전이가 어떤건지 살펴보도록 하겠다.

_User.java_

```java
@Entity
public class User{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long id;
    @Column(nullable = false)
    String name;
    String email;
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    List<Posts> postsList = ArrayList<Posts>();
}
```

_Posts.java_

```java
@Entity
class Posts{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long id;
    @Column(nullable = false)
    String contents;
    @ManyToOne
    @JoinColumn(name="user_id")
    User user;
}
```

```java
User user = new User();
user.name = "gunkim";
user.email = "gunkim0318@gmail.com";

userRepository.save(user); //persist

Posts posts = new Posts();
posts.contents = "게시글 내용";
posts.user = user;

postsRepository.save(posts); //persist
```

해당 예제코드는 Posts엔티티를 저장(persist)하기 위한 소스이다. Posts 엔티티를 입력하기 위해서 User 엔티티를 입력하고, Posts엔티티를 입력한다.
이를 위해서 번거롭게 저장(persist)하는 코드를 두번 작성해야 하는 번거로움이 있다.

_User.java_

```java
@Entity
public class User{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long id;
    @Column(nullable = false)
    String name;
    String email;
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.PERSIST)
    List<Posts> postsList = ArrayList<Posts>();
}
```

```java
User user = new User();
user.name = "gunkim";
user.email = "gunkim0318@gmail.com";

Posts posts = new Posts();
posts.contents = "게시글 내용";
posts.user = user;

user.postsList.add(posts);
userRepository.save(user); //user, posts persist
```

영속성 전이를 이용한다면 이렇게 부모 엔티티인 User 엔티티를 저장(persist)하면서 같이 자식인 Posts 엔티티도 같이 저장(persist)되게끔 할 수 있다.  
영속성 전이를 잘 활용하면 자식의 생명주기도 관리할 수 있게 되어 편리하지만, 잘못 사용하면 예상치 못한 결과가 발생할 수 있으니 주의가 필요하다.

# 영속성 전이 옵션

위의 예제에서 이용한 CascadeType.PERSIST 옵션 말고도 JPA에서는 여러 옵션들을 추가로 지원해주는데 아래와 같다.

- **CascadeType.ALL** - 모든 Cascade 옵션 적용
- **CascadeType.PERSIST** - 부모 엔티티를 영속화할 때 자식 엔티티도 영속(persist)화 시킨다.
- **CascadeType.MERGE** - 부모 엔티티를 병합할 때 자식 엔티티도 병합(merge)한다.
- **CascadeType.REFRESH** - 부모 엔티티를 읽어들일 때 자식 엔티티도 다시 읽어들인다(refresh).
- **CascadeType.REMOVE** - 부모 엔티티를 삭제할 때 자식 엔티티도 삭제(remove)한다.
- **CascadeType.DETACH** - 부모 엔티티를 준영속(detach)화 할 때 자식 엔티티도 준영속(detach)화 한다.

# 고아(orphan) 객체

부모 엔티티와 관계가 끊어진 자식 엔티티를 **고아 객체**라고 한다.

## **orphanRemoval=true**옵션

```java
@Entity
public class User{
    //...
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, orphanRemoval=true)
    List<Posts> postsList = ArrayList<Posts>();
}
```

만약 부모 엔티티와의 관계가 끊어진 고아 객체가 자동으로 삭제되게 하고 싶을 때 사용하는 옵션인데 **orphanRemoval=true**만 추가해주면 자동으로 고아 객체를 삭제해준다.

## CascadeType.REMOVE vs orphanRemoval=true

영속성 전이 REMOVE 옵션은 부모 엔티티가 삭제되었을 때 자식 엔티티를 삭제하는데, 대충 설명을 읽어보면 고아객체 삭제 옵션이랑 유사하다.

### 공통점

**부모 엔티티를 삭제한다 -> 자식 엔티티를 삭제한다.**

### 차이점

#### CascadeType.REMOVE

부모 엔티티가 삭제될 경우 **자식 엔티티**를 삭제해라

#### orphanRemoval=true

부모 엔티티가 삭제될 경우를 관계가 끊어진 **고아 객체**를 삭제해라

### 결론

결국 어떻게 보면 영속성 전이 REMOVE 옵션은 고아 객체 삭제 옵션의 부분집합이라고도 볼 수 있을 것 같다.

## 고아 객체를 만드는 방법

```java
User user = userRepository.findAll().get(0);
user.postsList.clear();
```

User(부모)엔티티에서 Posts(자식) 엔티티와의 관계를 끊어 주었다. 이렇게 자연히 Posts(자식) 엔티티는 고아 객체가 되어 자동으로 삭제(delete)된다. 추가로 User(부모) 엔티티가 삭제될 경우에도 관계가 끊어진다.

## +**orphanRemoval=true**를 사용하려면 CascadeType.REMOVE를 같이 사용해야 한다?

원래는 **orphanRemoval=true**옵션만 추가하게 되면 작동이 되어야 하는 게 맞을텐데, 작동이 안되어서 구글링해본 결과 **CascadeType.REMOVE**와 같이 사용해야 작동한다는 답변을 발견했다. 아마 원인은 하이버네이트 쪽 문제가 아닌가 하는 의견이 있어서 첨부한다.[참고](https://github.com/mjung1798/Jyami-Java-Lab/issues/1)


JPA 영속성 전이와 고아 객체(orphan)


깃에 커밋하다가 메시지가 잘못 올라간 게 있어서 수정하는 방법에 대해서 알아본 것에 대해서 정리하려고 한다.

# 가장 최신인 마지막 커밋의 메세지를 수정하고 싶다!

가장 최신인 마지막 커밋에 대한 커밋 메세지를 수정하는 방법

```bash
git commit --amend -m "수정할 메세지"
git push -f
```

git commit에 **--amend** 옵션을 적용하여 최신 커밋에 덮어씌운 후 git push에 **-f** 옵션을 통해 원격 저장소에 강제로 푸쉬해주면 된다.

# 최신인 직전 커밋 메세지 말고도 다른 커밋도 수정하고 싶다!

예시로 직전 커밋부터 최근 5개의 커밋을 수정하고 싶다면 아래 처럼 pick으로 되어 있는 부분을 edit로 변경하고, 뒤에 메시지를 수정해주면 된다. 수정이 끝나면 **!wq**명령어로 저장해주면 된다.

```bash
git bash rebase -i HEAD~5
```

```
pick 584661a 소스 수정
pick 55492ca 소스 입력
pick 57692ca 소스 입력
edit fae85ea 오~ 수정이 되네?
edit 38531e6 수정 테스트

# ...
```

마지막으로 아래 명령어를 입력해주면 끝난다.

```bash
git commit --amend
git rebase --continue
git push -f
```


Git 커밋 메세지를 수정하는 방법


JPA를 그동안 사용하면서 잘 알지 못하고 사용해왔는데, JPA에 대해서 제대로 알기 위해서 가장 중요한 개념인 영속성(Persistence)에 대해서 정리해보려고 한다.

# 영속성 컨텍스트(Persistence Context) 의미

> 엔티티가 영구 지속되는 환경.

눈에 보이거나 하는 것은 아니기 때문에 논리적인 개념이라고 표현한다.

## 국어사전을 뒤져 보았다.

그냥 내가 단어의 뜻이 궁금해서 한번 찾아 보았는데, 말이 되도록 끼워 맞춰보면 **(무언가가) 오래도록 지속되는 환경** 정도로 해석할 수 있을 것 같다.

![image](https://user-images.githubusercontent.com/45007556/97259424-1861ff00-185e-11eb-9606-4f08e10670d5.png)
![image](https://user-images.githubusercontent.com/45007556/97259448-1ef07680-185e-11eb-8fe5-d680e4fcb6e9.png)

# 영속성 컨텍스트의 구조

> _1차 캐시 저장소_, *SQL 저장소*로 나뉘어 진다.

![image](https://user-images.githubusercontent.com/45007556/97259497-3e879f00-185e-11eb-9fe2-688c9012a85b.png)

## _1차 캐시 저장소_

> 엔티티를 조회하거나 저장할 경우 해당 엔티티는 1차 캐시에 저장된다.

1차 캐시는 Map형태(Key-Value)로 보관이 되는데 식별자값(Key)을 통해서 엔티티를 조회해서 1차 캐시에 없을 경우 DB 조회 후 생성해서 넣고, 있을 경우 1차 캐시에 엔티티를 반환해준다. 그래서 Map을 통해 같은 엔티티를 반환하기에 a==b같은 동일성을 보장해준다.

### 1차 캐시의 동작 순서

1. 최초 조회할 때는 1차 캐시에 엔티티가 없다.
2. DB에서 엔티티를 조회한다.
3. 엔티티를 1차 캐시에 보관한다. 이 때 최초 값을 따로 저장해두는 데, 이 값을 **스냅샷**이라고 한다.
4. 1차 캐시에 보관된 결과를 반환한다.
5. 이후 같은 식별자를 통해 엔티티를 조회하면 DB 조회없이 1차 캐시에 엔티티를 그대로 반환한다.

## _SQL 저장소_

여러 SQL을 저장했다가 트랜잭션을 commit할 때 한번에 처리한다. 이를 통해 DB 접근 횟수를 최소화하고 성능상 이점을 얻을 수 있다.

# 엔티티 매니저(Entity Manager)와 엔티티 매니저 공장(Entity Manager Factory)

> 영속성 컨텍스트를 위해 일하는 녀석과 그런 녀석을 만드는 녀석.

## Entity Manager

엔티티(Enitty)를 영속성 컨텍스트에 저장(persist)하고, 조회(find)할 때 영속성 컨텍스트에 보관하고 관리하는 역할을 하는 녀석이다. 그리고 엔티티 매니저는 특정 시점까지 DB 커넥션을 얻지 않고, 스레드 간 공유 시 동시성 문제가 발생할 수 있다.

## Entity Manager Factory

엔티티 매니저 공장은 생성 비용이 크기 때문에 보통 하나의 DB를 사용할 경우 하나만 생성해서 사용한다. 대신 엔티티 매니저는 공장을 통해서 요청마다 엔티티 매니저가 만들어져 나오기 때문에 여러 개가 존재할 수 있다. 그리고 엔티티 매니저 공장은 스레드 간 공유해도 안전하다.
![image](https://user-images.githubusercontent.com/45007556/97259469-2b74cf00-185e-11eb-8172-6f78deb632df.png)

# 엔티티(Entity)의 생명 주기(Life Cycle)

영속성에 대해서 이해하기 위해서는 우선 엔티티의 생명주기를 알아야 한다.
![image](https://user-images.githubusercontent.com/45007556/97259485-3465a080-185e-11eb-8532-49a64c5de7a8.png)

## 비영속(new/transient)

엔티티를 생성만 하고, 아무것도 하지 않은 상태. 아직은 영속성 컨텍스트와 전혀 관계가 없다.

```java
Member member = new Member();
```

## 영속(managed)

> 영속성 컨텍스트에 엔티티가 저장된 상태.

이때부터 엔티티가 영속성 컨텍스트에 의해 관리된다. 영속화 한다고 바로 DB에 저장이 되는 것은 아니고, 트랜잭션 commit 시점에 영속성 컨텍스트에 있는 정보들이 이 때 SQL이 실행되어 DB에 저장이 된다.

```java
em.persist(member);
```

## 준영속(detached)

> 영속성 컨텍스트에 엔티티가 저장되었다가 분리된 상태.

### 준영속 상태를 만드는 방법

영속 상태인 엔티티를 준영속 상태로 바꾸는 방법은 영속성 컨텍스트에서 분리하거나, 엔티티 매니저를 초기화 및 종료하여 엔티티가 관리되지 않게 하는 방법이 있다.

```java
//1. 해당 엔티티를 준영속 상태로 변경
em.detach(member)
//2. 영속성 컨텍스트 초기화
em.clear()
//3. 영속성 컨텍스트 종료
em.close()
```

### 그럼 준영속 상태에서 영속 상태로 바꾸는 방법은?

병합(merge)을 사용하면 된다 merge메소드는 준영속 상태의 엔티티를 받아서 영속 상태의 엔티티를 반환하게 된다.
병합은 해당 엔티티로 모든 값을 교체하기 때문에 엔티티의 값이 없으면 null을 업데이트할 위험이 있다. 준영속 전환이 아닌 엔티티 변경이 목적일 경우 병합 대신 변경 감지를 이용하는 것이 좋다.

#### 전환 순서

1. 파라미터로 넘어온 준영속 엔티티의 식별자 값으로 1차 캐시에서 엔티티를 조회
2. 만약 1차 캐시에 엔티티가 없으면 데이터베이스에서 엔티티를 조회하고 1차 캐시에 저장
3. 조회한 영속 엔티티에 파라미터로 넘어온 비영속 엔티티의 값을 채워 넣는다.
4. 새로운 영속 엔티티를 반환

```java
em.merge(member)
```

### 비영속과의 차이점?

엔티티 매니저를 통한 영속성 컨텍스트의 지원을 하나도 받지 못한다는 건 동일한데, 영속 상태가 되었었기 때문에 준영속 상태는 식별자 값이 존재한다는 차이가 있다.

## 삭제(removed)

> 영속성 컨텍스트에서 엔티티가 삭제된 상태.

엔티티가 삭제되면 DB에서도 삭제된다.

```java
em.remove(member);
```

# 플러시(flush)

> 영속성 컨텍스트의 변경 내용을 DB에 반영하는 것

## 플러시의 동작 순서

1. **변경 감지** 동작 실행.
2. SQL저장소의 SQL들을 DB에 전송(SELECT, UPDATE... 등 쿼리 실행).

## 변경 감지

JPA에서 Update를 하려고 하면 수정을 지원하는 메소드가 없다. 그 이유는 바로 변경 감지를 지원하기 때문인데, 엔티티를 스냅샷과 비교해서 바뀐 것이 있으면 수정 쿼리를 생성해서 SQL저장소에 등록한다. flush는 플러시할 때에만 동작한다.

### JPA UPDATE 전략

필드가 몇개가 바뀌든 그냥 전체 필드를 업데이트 친다. 그렇기 때문에 쿼리가 항상 동일하고, 이전에 업데이트 친 경우가 있을 경우 이전 쿼리를 재사용 한다.

## 플러시 방법

총 3가지 방법이 있는데, 보통 트랜잭션을 커밋해서 플러시가 자동으로 호출되도록 하고, flush메소드를 직접 호출하는 경우는 테스트할 때를 제외하고는 거의 없다.

1. em.flush() 직접 호출.
2. 트랜잭션 커밋 시 플러시가 자동 호출.
3. JPQL쿼리 실행시 플러시가 자동 호출.

# 참고

자바 ORM 표준 JPA 프로그래밍 책


JPA 영속성(Persistence) 정리


원래 그 동안 기본 도메인인 gunkim0318.github.io를 이용해오다가 아이디를 생일이랑 이름으로 만들어놔서 별로 안 이쁘기도 하고, 마침 개발자답게 dev 도메인이 탐나기도 해서 알아보던 중 GoDaddy를 통해 구입하고 연동한 방법 등에 대해서 정리하려고 한다.

# 도메인을 구매하자

우선 깃허브 페이지에 도메인을 연동하기 위해서는 당연하게도 도메인이 일단 필요하다. 여러 도메인 호스팅 업체가 있지만 나는 여러 업체를 비교해본 결과 GoDaddy가 믿을만하다고 생각해서 여기로 결정했다.  
[GoDaddy KR](https://kr.godaddy.com/offers/domains/godaddy-b)에 들어가서 검색창에 원하는 도메인을 입력 후 구매하면 된다(예: gunlog.dev). 우선 준비물은 해외결제가 가능한 카드가 필요하다. ~~이것 때문에 부랴부랴 은행가서 비자카드 발급함~~
![image](https://user-images.githubusercontent.com/45007556/96098192-cd1a2900-0f0c-11eb-943f-df3646c9a897.png)

# 도메인 DNS 등록

GoDaddy에서 제공하는 DNS 관리자 페이지에서 해당 정보들을 등록해주면 된다.
깃허브 페이지 IP가 4개가 있는데 하나만 등록해도 된다고 하지만 안전하게 4개 전부 등록해주도록 하자.

- _TTL_ : 서버가 DNS 레코드에 대한 정보를 캐시하는 시간
- _CNAME_ : Canonical Name의 줄임말, 하나의 도메인에 다른 이름을 부여하는 방식
- _A RECORD_ : 도메인(domain) name에 IP Address를 매핑하는 방식

![image](https://user-images.githubusercontent.com/45007556/96098157-c390c100-0f0c-11eb-8c57-41d98fb4cdbe.png)

# 깃허브 페이지 커스텀 도메인 등록

이제 도메인 DNS를 등록하고 깃허브 페이지 설정 페이지를 가게 되면 Custom domain을 입력하는 곳이랑 Enforce HTTPS 체크하는 곳이 있는데 구매한 도메인 주소를 입력 후 체크해주게 되면 도메인 연동이 끝나게 된다. 만약 Enforce HTTPS가 비활성화되어 있다면 도메인 DNS가 적용되는데 시간이 조금 걸리니 기다려 보자. 기다려도 활성화가 안되면 DNS 등록이 제대로 되었는 지 확인해보는 것을 추천한다.
![image](https://user-images.githubusercontent.com/45007556/96119248-ad442e80-0f27-11eb-90c7-ab586bf4535a.png)
![image](https://user-images.githubusercontent.com/45007556/96119375-d95faf80-0f27-11eb-982a-6eb803f353e7.png)


GoDaddy를 통한 도메인 구매 및 깃허브 페이지 연동하기


요즘 리액트에 관심이 생겨서 이것저것 해보는데 문뜩 고민이 생겼다. **컴포넌트는 재사용이 가능해야 하고, 독립적이어야 하고 작게 쪼개져야 한다**고 한다. 그런데 내가 짜논 코드를 문뜩 보니 재사용은 고사하고 그냥 jsp 코딩을 옮겨논 것 같아 리액트의 장점을 못 살리고 있다는 기분이 들었다.
찾아보던 중 솔루션이 있었는데 일단은 크게 만들고(이미 한 것), 그 다음 눈에 보이는 것을 쪼개는 방법(쪼개야 할 것이 안 보임)을 추천한다는 글을 보았다. 결과 크게 도움이 되진 않았다...

> 이럴꺼면 리액트를 왜 써? jsp를 쓰지?

그래서 리액트의 장점을 극대화할 수 있는 코딩 스타일에 대해서 찾아보았다. 그런데 리액트는 라이브러리라는 말에 맞게 사람들마다 폴더 구조를 어떻게 하고, 어떤 식으로 코딩을 하고 등에 대해서
다 제각각이었다. **(자유로운건 좋은데 내가 잘 짜고 있는게 맞냐구:예상 답변-개발에는 정답이 없읍니다..나쁜코드만 있을 뿐..)**
일단 그렇게 찾아보고, 직접 적용해보거나 의향이 있는 디자인 패턴에 대해서 정리해보려고 한다.

# Container + Presenter 패턴

![image](https://user-images.githubusercontent.com/45007556/95151526-d6491e80-07c5-11eb-9388-5fd48280d712.png)

컴포넌트를 **Container컴포넌트**와 **Presenter컴포넌트**로 나눠서 코딩하는 디자인 패턴인데,
**Presenter컴포넌트**는 로직이나 api처리 없이 Prop를 통해 전달받은 데이터를 화면에 표출시켜주기 위한 컴포넌트이고 마크업, 스타일시트 등이 포함되어 있다.
**Container컴포넌트**는 리덕스나 State, Api호출 등 디스패치나 로직 처리 등을 담당하고, 그 값을 Prop를 통해 **Presenter컴포넌트**에게 전달한다.  
처음 봤을 때 느낀 점은 보통 말하는 MVC패턴에서 Container컴포넌트를 MC로 Presenter컴포넌트를 V로 분리해놓은 듯한 모양새에서 익숙해서 반가웠던 것 같다.

마지막으로 예제 코드로 살펴보려고 한다.

_/components/List.js_

```javascript
const List = () => {
  const { loading, error, data: todoList } = useSelector(
    (state) => state.todos
  );
  const dispatch = useDispatch();

  useEffect(() => {
    dispatch(getTodos());
  }, [dispatch]);

  if (loading) {
    return <div>목록을 불러오는 중...</div>;
  }
  if (error) {
    return <div>오류입니다... 잠시 후 다시시도해주세요.</div>;
  }
  return (
    <div>
      {todoList.map((todo) => (
        <Item key={todo.id} id={todo.id} text={todo.text} check={todo.check} />
      ))}
    </div>
  );
};
```

위 코드는 부끄럽지만 나름대로 예전에 코딩해놓은 투두리스트 목록을 뿌려주는 컴포넌트 전체 코드이다. 이 코드를 나름 이해한 방식으로 Container와Presenter로 분리해보려고 한다.

_/container/ListContainer.js_

```javascript
const ListContainer = () => {
  const { loading, error, data: todoList } = useSelector(
    (state) => state.todos
  );
  const dispatch = useDispatch();

  useEffect(() => {
    dispatch(getTodos());
  }, [dispatch]);

  return <List list={todoList} loading={loading} error={error} />;
};
export default ListContainer;
```

_/components/List.js_

```javascript
const List = ({ list, loading, error }) => {
  if (loading) {
    return <div>목록을 불러오는 중...</div>;
  }
  if (error) {
    return <div>오류입니다... 잠시 후 다시시도해주세요.</div>;
  }
  return (
    <>
      {list.map((todo) => (
        <Item key={todo.id} id={todo.id} text={todo.text} check={todo.check} />
      ))}
    </>
  );
};
List.defaultProps = {
  list: [],
  loading: false,
  error: true,
};

export default List;
```

자 이렇게 리덕스를 통해 state를 받아오거나, 디스패치하는 로직은 Container컴포넌트로 분리하고, state값을 Props를 통해 Presenter컴포넌트로 전달하도록 컴포넌트를 분리해보았다.

# Atomic 패턴

> 그냥 처음부터 쪼개진 상태로 개발하는 방법은 없을까?

위와 같은 생각으로 찾아본 패턴인데, 이름처럼 작은 원자들을 합쳐서 하나의 큰 덩어리를 만드는 개발 방법이다. 간단하게 가장 작은 원자들을 모아 분자를 만들고, 분자들을 모아 유기체를 만들어 실제 화면에 보여준다고 보면 된다.

리액트를 공부하면서 남들 따라 컴포넌트를 만들어왔는데, 어느 정도 나도 모르게 이 패턴대로 작은 컴포넌트들을 조합해서 Templates를 만들고 Pages를 만들고 하는 식으로 코딩은 했었던 것 같다.

> 그럼 이미 적용 중인거 아냐?

그런데 이 패턴에서 중요한건 크기가 커질수록 재사용성이 떨어지기 마련이다. 그러면 원소들을 얼마 만큼 재사용 가능하게 만드느냐가 이 패턴의 중점인 것 같다. 흉내만 냈다고 보는 게 맞을 것이다.

> 이름이 원자 패턴 답게 먼저 각 단위에 대한 이해가 필요하다.

![image](https://user-images.githubusercontent.com/45007556/95158784-70fe2900-07d7-11eb-9383-61f830bd261f.png)

- **Atoms**: 가장 작은 단위의 컴포넌트. 대표적인 form요소인 Label, Input, CheckBox, Select 등이 위치한 가장 하위 요소. 재사용이 가능하게끔 특정 기능을 구현하는 것이 아니라 일반적인 사용이 가능하도록 만들고, 기능을 수행하더라도 Props를 통해 함수를 주입 받아서 수행하도록 만든다.
- **Molecules**: 2개 이상의 원자로 구성된 컴포넌트. 단순한 UI 컴포넌트들 Label+Input 등의 단순한 조합.
- **Organisms**: 하나의 인터페이스를 형성하는 컴포넌트. Header, Navigation 등이 여기에 속한다.
- **Templates**: 인터페이스들을 모아 레이아웃을 형성하는 컴포넌트. 컴포넌트들을 주입받아 로직이 아닌 스타일링에 집중한다.
  ![image](https://user-images.githubusercontent.com/45007556/95160850-90e41b80-07dc-11eb-9cb3-0734d4084813.png)

- **Pages**: 실제 페이지를 구성하는 컴포넌트. Template에 컴포넌트 및 데이터들을 주입해주어서 레이아웃을 구성할 수 있게 해준다. 사용자가 직접적으로 보는 화면과 동일하다.

## 고민

state를 props를 통해 내리고 내리고 하는 점 때문에 redux및 상태관리 라이브러리를 사용하는데, 최상위인 Pages에서 state 및 함수 등을 Props를 통해 내려줘야 한다. 그러면 상태관리 라이브러리를 도입한 메리트가 없어지는 건 아닌가 하는 고민을 하게 된다. 그리고 보통 사람들이 Top-Down(크게 만들어서 쪼갠다) 방식을 선호하는 데에 비해 Down-Top(작게 만들어서 크게 만든다)방식이라서 개발 전에 설계 시간이 오래 걸릴 것 같다. 일단 개발을 해보면서 느껴봐야 할 것 같다.

# 마지막으로

리액트는 정말 자유로운 라이브러리인 것 같다. 하지만 너무 자유롭다 보니 프레임워크 위주로 무언가 틀 안에서 코딩을 해왔다면 자유롭게 코딩하라고 시키면 나처럼 헤매는 경우도 많을 것 같다. 그리고 코딩을 하기 전에 폴더 구조는 어떻게 해야 하고, 컴포넌트는 어떻게 만들어야 하고, 고민하다 보면 코드 작성은 뒷전이고 고민만 하게 된다. 그런 점에서 많은 사람들이 택한 디자인 패턴들을 공부하다 보면 패턴 속에 녹아 있는 리액트의 개발 철학들을 흡수할 수 있게 되어 좋은 것 같다.


리액트 초보의 컴포넌트에 대한 고민(feat.디자인 패턴)


양방향 연관관계에 대해서 다룰 일이 있었는데, 양방향인데 저장할 때 어느쪽에다가 저장을 해야 하는지, 양쪽 다 해야 하는지 등이 헷갈려서 정리해보았다.
다대일을 기준으로 포스팅해보려고 한다.

# 양방향 연관관계

양방향 연관관계라고 표현은 했지만, 실질적으로는 단방향 연관관계가 양쪽에 하나씩, 총 2개라고 보면 된다.

아래 그림은 단방향 연관관계에 대한 그림이다.  
학교에서는 학생에 대한 참조가 없어서 학교에서는 속해있는 학생을 알 수 없지만,
학생은 학교에 대한 참조가 있어서 속해있는 학교에 대해서 알 수 있다.  
해당 연관관계는 단방향 1:N관계라고 볼 수 있다.
![image](https://user-images.githubusercontent.com/45007556/94286367-de1bee00-ff8f-11ea-92a1-b1afe192b5bf.png)

그래서 이제 학교에서 학교에 속해있는 학생을 알기 위해서 참조를 추가해주게 되면 학교에서도 학생을 알 수 있고,
학생도 학교에 대해서 알 수 있다.  
해당 연관관계를 양방향 1:N 연관관계라고 볼 수 있다.
_그림에서는 학교쪽에도 외래키가 있지만, 실제로 외래키는 학생쪽에서 관리함. 이유는 후술_

![image](https://user-images.githubusercontent.com/45007556/94286453-fb50bc80-ff8f-11ea-80e6-6cc4755934d8.png)

위의 관계를 코드로 작성해보면 아래와 같다.

```java
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class School {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(nullable = false)
    private String name;

    @OneToMany(mappedBy = "school")
    @Column(nullable = true)
    private List<Student> students = new ArrayList<Student>();

    @Builder
    public School(long id, String name, List<Student> students){
        this.id = id;
        this.name = name;
        this.students = students;
    }
}
```

```java
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private int age;

    @ManyToOne
    @JoinColumn(name="school_id", nullable = false)
    private School school;

    @Builder
    public Student(long id, String name, int age, School school){
        this.id = id;
        this.name = name;
        this.age = age;
        this.school = school;
    }
}
```

# 연관관계의 주인

외래키를 관리하는 쪽을 연관관계 주인이라고 한다. 양방향 연관관계를 매핑해주기 위해서는 꼭 **연관관계의 주인**을 설정해주어야 하는데,
양방향은 단방향 연관관계가 2개라고 했다. 그런데 아래의 코드를 보면 School에도 Student가 있고, Student에도 School가 있다.
그럼 School엔티티에서 Student를 등록, 수정, 삭제 등을 해도 반영이 될까? 그 답은 아니다.  
양방향 연관관계에서는 연관관계에 대해서 **연관관계의 주인**만이 등록, 수정, 삭제가 가능하다.

## 설정 방법

주인인 쪽은 @JoinColumn을 사용하고, 주인이 아닌 쪽은 mappedBy를 사용해준다.
다대일 연관관계에서는 주로 @ManyToOne쪽을 주인으로 설정한다.

@ManyToOne에는 mappedBy속성이 없고, @OneToMany쪽을 주인으로 설정하는 방법도 있지만 다루진 않겠다.

# 저장 방법

## DB만을 고려한 연관관계 저장

그냥 간단히 아래와 같이 입력하면 된다.
그런데 여기서 내가 가장 헷갈렸던 부분인데, 해당 코드를 보면 Student엔티티에 School엔티티를 넣는 부분은 있는데, School엔티티에 Student를 넣어주는 부분은 없다.
하지만 연관관계의 주인이 외래키를 관리하기 때문에 주인이 아닌 쪽은 따로 넣어주지 않아도 DB를 조회해보면 값이 확인된다.

```java
School school = School.builder()
        .name("어느학교")
        .build();
schoolRepository.save(school);

Student student = Student.builder()
        .name("gunkim")
        .age(21)
        .school(school)
        .build();
studentRepository.save(student);
```

이제 그럼 School엔티티에 List<Student>의 size와 Student엔티티를 조회해보았다. 그런데 결과는 양방향 연관관계를 통해 예상했던 결과가 아니다.
DB에는 연관관계가 등록됐을 지 모르지만 객체 형태로 조회했을 때는 제대로 값이 확인되지 않는 것을 알 수 있다.

```java
System.out.println("학생 정보 :: "+studentRepository.findAll().get(0));
System.out.println("어느학교 학생 수 :: "+schoolRepository.findAll().get(0).getStudents().size());
```

![image](https://user-images.githubusercontent.com/45007556/94325848-74293600-ffdb-11ea-9262-01947fbbadf8.png)

## DB 및 객체까지 고려한 연관관계 저장

내가 의도한 바는 School엔티티에서도 가지고 있는 Student를 조회하고,
Student에서도 가지고 있는 School에 대해 조회하는 것이기 때문에 아래와 같이 처리해주면 된다.

```java
School school = School.builder()
        .name("어느학교")
        .build();
schoolRepository.save(school);

Student student = Student.builder()
        .name("gunkim")
        .age(21)
        .school(school)
        .build();
school.getStudents().add(student);
studentRepository.save(student);
```

## 개선해보기

그런데 우리는 이 양방향 연관관계를 어느쪽을 조회하든 조회가 가능하게 하고 싶다. 하지만 만약 까먹고 Student엔티티에는 넣고, School에는 안 넣게 되는 등의 문제를 방지하기 위해
이런 식으로 수정해보았다. 이제 Student엔티티에만 School엔티티를 넣게 되면 자동으로 매핑을 해줄 것이다.

```java
@ToString
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private int age;

    @ManyToOne
    @JoinColumn(name="school_id", nullable = false)
    private School school;

    @Builder
    public Student(long id, String name, int age, School school){
        school.getStudents().add(this);

        this.id = id;
        this.name = name;
        this.age = age;
        this.school = school;
    }
}
```

```java
School school = School.builder()
        .name("어느학교")
        .build();
schoolRepository.save(school);

Student student = Student.builder()
        .name("gunkim")
        .age(21)
        .school(school)
        .build();
studentRepository.save(student);

System.out.println("어느학교 학생 수 :: "+schoolRepository.findAll().get(0).getStudents().size());
```

![image](https://user-images.githubusercontent.com/45007556/94326298-09c5c500-ffde-11ea-9597-fe383c93a69b.png)

# 헷갈리지 말아야 할 점 **(중요)**

연관관계 주인만이 연관관계에 대한 입력, 수정, 삭제가 가능하다고 했다.
그래서 수정할 때 School에만 입력, 수정, 삭제해도 반영이 되지 않는다.
만약 반영되지 않는다면 다시 한번 확인해볼 필요가 있을 것 같다.


JPA 양방향 연관관계 나름 정리


우리나라에서 가장 대표적인 플랫폼인 카카오, 구글, 페이스북, 네이버 외 깃허브에 대한 클라이언트 ID, 암호키 발급 방법을 정리해보려고 한다.

# 카카오

[카카오 개발자 페이지](https://developers.kakao.com/)로 이동

## 1. 애플리케이션 추가

내 앱>애플리케이션 추가에 해당 화면에서 앱 이름, 회사 이름을 간단히 입력하여 저장
![image](https://user-images.githubusercontent.com/45007556/91691565-cde83d00-eba2-11ea-9170-3f80328dcc36.png)

## 2. 플랫폼 등록

플랫폼 카테고리>웹 플랫폼 등록에서 사이트 도메인 입력 후 저장
![image](https://user-images.githubusercontent.com/45007556/91691948-844c2200-eba3-11ea-9bfa-ecb2c59f3665.png)

## 3. 카카오 로그인 활성화

카카오 로그인 카테고리 이동 후 카카오 로그인 활성화 버튼 클릭
![image](https://user-images.githubusercontent.com/45007556/91691696-08ea7080-eba3-11ea-8ed3-1af0c854d91b.png)

## 4. 카카오 로그인 리다이렉션 설정

![image](https://user-images.githubusercontent.com/45007556/91799695-8de88f00-ec62-11ea-842f-944057eaa882.png)

## 5. OAuth 인증 정보 확인

앱 설정>요약 정보에서 REST API키가 클라이언트 ID이다.
![image](https://user-images.githubusercontent.com/45007556/91869283-aa131d00-ecb0-11ea-8092-967af0095ccf.png)

제품 설정>카카오 로그인>보안에서 암호키를 확인할 수 있다.
![image](https://user-images.githubusercontent.com/45007556/91869211-8fd93f00-ecb0-11ea-8e44-db923bf62bb0.png)

# 구글

[구글 API 페이지](https://console.developers.google.com/projectcreate?previousPage=%2Fprojectselector2%2Fapis%2Fdashboard%3ForganizationId%3D0%26supportedpurview%3Dproject&project=&folder=&organizationId=0&supportedpurview=project)로 이동

## 1. 새 프로젝트 생성

프로젝트 이름을 입력 후 만들기 클릭
![image](https://user-images.githubusercontent.com/45007556/91689928-063a4c00-eba0-11ea-9d5c-05e881758380.png)

## 2. 동의화면 만들기

![image](https://user-images.githubusercontent.com/45007556/91690260-9a0c1800-eba0-11ea-94e5-47b18a39c60f.png)

## 3. 동의화면 작성

애플리케이션 이름, 지원 이메일을 작성 후 최하단 작성 버튼 클릭
![image](https://user-images.githubusercontent.com/45007556/91688638-67145500-eb9d-11ea-9351-92820ffa95bc.png)

## 4. 클라이언트 ID 생성으로 이동

사용자 인증 정보 만들기>OAuth 클라이언트 ID 선택
![image](https://user-images.githubusercontent.com/45007556/91690365-c758c600-eba0-11ea-9290-ede988df72fe.png)

## 5. 클라이언트 ID 생성

유형을 웹 애플리케이션 선택 후 자유롭게 이름을 입력해주고, 승인된 자바스크립트 출처 입력.

![image](https://user-images.githubusercontent.com/45007556/91869032-5b658300-ecb0-11ea-8375-200107e22a08.png)

## 6. OAuth 인증 정보 확인

OAuth2 인증을 위한 클라이언트 ID, 보안 비밀번호 확인
![image](https://user-images.githubusercontent.com/45007556/91690967-ca07eb00-eba1-11ea-9adf-f7cb1ad46be9.png)

# 페이스북

[페이스북 개발자 페이지](https://developers.facebook.com/?no_redirect=1)로 이동

## 1. 앱 생성

내 앱 > 새 앱 추가에서 기타를 선택
![image](https://user-images.githubusercontent.com/45007556/91686286-d38c5580-eb97-11ea-8900-eaa6ecce9d1f.png)

앱 이름, 연락처 작성 후 앱 ID 만들기 버튼 클릭
![image](https://user-images.githubusercontent.com/45007556/91686344-fcace600-eb97-11ea-9d73-ff2c5e66b4c8.png)

## 2. Facebook 로그인 설정

사이드바 제품 카테고리에서 Facebook 로그인 설정을 선택.

페이스북에서는 개발 중 localhost에 대한 리디렉션을 기본으로 지원하니 유효한 OAuth 리디렉션 URI는 설정 안해주어도 됨
![image](https://user-images.githubusercontent.com/45007556/91687321-6a5a1180-eb9a-11ea-8879-9b7611ab19cd.png)

## 3. OAuth 인증 정보 확인

OAuth2 인증을 위한 앱 ID, 앱 시크릿 코드(보기 클릭)를 확인
![image](https://user-images.githubusercontent.com/45007556/91869378-c6af5500-ecb0-11ea-82d7-f4a03330e0f4.png)

# 네이버

[네이버 개발자 페이지](https://developers.naver.com/apps/#/list)로 이동

## 1. Application 등록

내 앱>Application 등록 이동 시 해당 화면으로 이동하여 앱 이름을 입력해주고, 사용 API는 네아로(네이버 아이디로 로그인) 선택 후
서비스 URL 및 Callback URL 작성 후 등록하기 버튼 클릭
![image](https://user-images.githubusercontent.com/45007556/91824267-7666d180-ec75-11ea-97b7-a991b80f9c27.png)

## 2. OAuth 인증 정보 확인

![image](https://user-images.githubusercontent.com/45007556/91693248-b3fc2980-eba5-11ea-91c0-a9d2ea0e72e5.png)

# 깃허브

[깃허브 설정 페이지](https://github.com/settings/developers)로 이동

## 1. 애플리케이션 생성

OAuth Apps>Register a new application을 클릭
![image](https://user-images.githubusercontent.com/45007556/91824849-63a0cc80-ec76-11ea-90e8-016eb786547e.png)

필요 정보를 입력 후 생성
![image](https://user-images.githubusercontent.com/45007556/91825106-c2664600-ec76-11ea-9354-517e8a6fde71.png)

## 2. OAuth 인증 정보 확인

![image](https://user-images.githubusercontent.com/45007556/91825349-1a9d4800-ec77-11ea-9a60-6ad638120210.png)

# 끝

이렇게 카카오, 구글, 페이스북, 네이버, 깃허브의 앱ID(클라이언트ID), 암호키(SECRETKEY)가 준비되었다.
이제 이 정보들을 가지고 코드를 구현해보려고 한다.


OAuth2 연동을 위한 카카오, 구글, 페이스북, 네이버, 깃허브 클라이언트 ID 및 암호키 발급 방법 정리


카카오의 서버사이드 코틀린을 보고나서 그 동안 코틀린은 그저 안드로이드만을 위한 언어인 줄 알았는데, 자바와 매우 호환이 잘 되고, 무려 스프링도 지원한다는 것을 알았다. 그리고 자바로 개발할 때보다 소스량이 훨씬 적어진다는 것이 매우 메리트가 있는 것 같아서, 나중에 코틀린으로 프로젝트를 해봐야 겠다 생각해서 미리 코틀린을 자바와 비교해서 정리해 놓으려고 한다.

# Hello World!

그 동안 자바에서 Hello World!를 찍으려고 하면 손가락 아프게 public class~ 부터 해서 System.out.println까지 작성해왔다. 겨우 Hello World! 하나 출력하는데 5줄이나 작성을 했다. 물론 라인 수가 적다고 해서 무조건 좋은 건 아니지만 손가락이 부담 되는 건 사실이다.

```java
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
```

그러나 코틀린에서는 함수형 프로그래밍을 지원하기 때문에 메소드만이 아니라 함수 선언도 가능하다. 이제 Hello World! 출력을 위해서 쓸데 없는 class를 작성하지 않아도 된다.
그리고 자바에서는 System.out.println까지 쳐야 하지만 코틀린에서는 함수 선언과 함께 println만 치면 된다!

```kotlin
fun main(args:Array<String>){
    println("Hello World!");
}
```

# 변수, 상수 선언

자바에서는 변수를 선언할 때는 int, String, long, boolean 등 타입을 지정해주어야 하고, 상수 선언 시 final을 붙여줘야 한다.

```java
int a = 3;
String str = "msg";
List<String> list = null;
final int b = 18;
```

코틀린에서는 타입 추론을 지원해주기 때문에 변수를 선언할 때 var로 선언해주면 되고, 상수 선언 시 val로 선언하면 된다.

```kotlin
var a = 3
val b = 18
```

만약 코틀린에서 타입을 지정해주고 싶으면 아래처럼 해주면 된다

```kotlin
var a: Int = 1
var a: String = "msg"
```

# 배열 선언

자바에서는 배열을 선언할 때 이런 식으로 선언하게 된다.

```java
int[] arr1 = {1,2,3};
int[] arr2 = new int[3];
```

코틀린에서는 아래와 같이 선언한다.

```kotlin
val arr1 = arrayOf(1, 2, 3) // [1,2,3]
val arr2 = arrayOfNulls<Int>(3) //[null, null, null]
val arr3 = Array(5, {i->i}) //[0, 1, 2, 3, 4]
```

# For문

자바에서는 보통 아래와 같이 for문을 사용한다.

```java
String[] students = {"gunkim", "human", "dog"};

for(int i = 0; i < 10; i++){
    System.out.println(i);
}
for(int i = 0; i < students.length; i++){
    System.out.println(students[i]);
}
for(String student : students){
    System.out.println(student);
}
```

코틀린에서는 이런 식으로 사용한다.

```kotlin
val students = arrayOf("gunkim", "human", "dog")

for(i in 1..10){
    println(i)
}
for(i in 0..students.size-1){
    println(students[i])
}
for(student in students){
    println(student)
}
```

```kotlin
//10부터 1까지
for(i in 10 downTo 1){
    println(i)
}
//10부터 1까지 2씩 하락
for(i in 10 downTo 1 step 2){
    println(i)
}
//1부터 9까지
for(i in 1 until 10){
    println(i)
}
//1부터 9까지 2씩 상승
for(i in 1 until 10 step 2){
    println(i)
}
```

# 메소드 선언

자바에서 메소드를 선언할 때면 접근제어자 리턴타입 메소드명 매개변수 순으로 선언한다.

```java
public String getName(){
    return "gunkim";
}
public void sayHello(){
    System.out.println("Hello");
}
public int sum(int a, int b){
    return a + b;
}
```

코틀린에서는 접근제어자 fun 메소드명 매개변수 리턴타입 순으로 작성한다. 리턴할 게 없는 경우 리턴 타입은 생략이 가능하다.

```kotlin
fun getName():String{
    return "gunkim"
}
fun sayHello(){
    println("Hello")
}
fun sum(a:Int, b:Int):Int{
    return a + b
}
```

# 문자열 처리

## 문자열 템플릿

보통 자바에서 문자열에 특정 값을 치환하기 위해서는 String.format()을 사용하거나, 문자열 붙이기를 통해서 처리를 했었다.

```java
int a = 1;
int b = 3;
System.out.println(String.format("%d + %d = %d", a, b, a+b));
System.out.println(a+" + "+b+" = "+(a+b));
```

하지만 코틀린에서는 문자열 템플릿을 지원해주기 때문에 아래와 같이 변수명 앞에 \$을 붙여서 문자열 안에 삽입을 해주게 되면 자동으로 값이 치환된다. 심지어 함수까지 호출이 가능하다.

```kotlin
var a = 1
var b = 3

var result = a + b;
println("$a + $b = $result")
```

```kotlin
fun main(args:Array<String>){
    var a = 1
    var b = 3

    var result = a + b;
    println("$a + $b = ${sum(a,b)}")
}
fun sum(a:Int, b:Int): Int {
    return a+b
}
```

## 여러 줄로 구성된 문자열 선언

자바에서 보통 문자열을 여러 줄의 문자열 처리를 할 때 단순하게 아래처럼 문자열을 붙이거나 StringBuilder나 StringBuffer를 통해 붙였다.

```java
String menu = "메뉴판==\n";
menu += "햄버거 : 5000\n";
menu += "밥 : 7000\n";
menu += "음료 : 3000\n";
menu += "세팅비 : 30000\n";
```

```java
StringBuffer sb = new StringBuffer();
sb.append("메뉴판==\n");
sb.append("햄버거 : 5000\n");
sb.append("밥 : 7000\n");
sb.append("음료 : 3000\n");
sb.append("세팅비 : 30000\n");
String menu = sb.toString();
```

코틀린에서는 아래와 같이 처리가 가능하다. 시작하는 부분에 """로 시작하고 """로 닫아주고 그 사이에 문자열을 넣으면 된다.

```kotlin
var a = """
    메뉴판==
    햄버거 : 5000
    밥 : 7000
    음료 : 3000
    세팅비 : 30000
"""
```

그런데 위와 같이 처리를 하게 되면 우리의 예상과 다르게 아래와 같이 공백 문자열이 앞에 들어가는 것을 확인할 수 있다. 이는 가독성을 위해 탭을 한 부분도 문자열로 인식이 되었기 때문이다.

![image](https://user-images.githubusercontent.com/45007556/91549698-47ddb380-e962-11ea-9889-75a68bf1c3f2.png)

아래와 같이 해당 문자열에 대해 trimMargin() 메소드를 호출해주고, 해당 라인의 문자열이 시작하는 부분에 구분자를 주게 되면 원하던 결과를 확인할 수 있다.

```kotlin
var a = """
    |메뉴판==
    |햄버거 : 5000
    |밥 : 7000
    |음료 : 3000
    |세팅비 : 30000
""".trimMargin()
```

![image](https://user-images.githubusercontent.com/45007556/91549899-a86cf080-e962-11ea-8c55-48d218805037.png)

# 접근제어자

자바의 접근제어자는 public, protected, default, private 이렇게 4종류가 있다.  
코틀린에서도 자바랑 비슷하지만 public, protected, private, internal 이렇게 4종류가 있다.

차이점은 자바에서 접근제어자를 선언하지 않으면 default 접근제어자를 가지지만 코틀린에서는 접근제어자를 선언하지 않을 경우 public 접근제어자를 가지게 된다.

## 코틀린의 internal

internal로 선언되면 같은 모듈 내에서만 접근이 가능하다.
코틀린에서는 default 접근제어자가 빠지고, internal 접근제어자가 새로 생겼다. 이는 외부에 있는 코드에 의해 모듈의 캡슐화가 깨지는 것을 방지하기 위함이다.

### internal 접근제어자에 접근 가능한 범위

- IntelliJ IDEA 모듈
- Maven / Gradle 프로젝트
- 하나의 Ant 태스크 내에서 함께 컴파일되는 파일들

# 코틀린의 생성자

보통 자바에서 클래스를 선언하고, 멤버변수를 작성하고, 생성자를 작성하는 일반적인 코드다.

```java
public Human{
    String name;
    int age;
    public Human(String name, int age){
        this.name = name;
        this.age = age;
    }
}
```

## 코틀린의 주 생성자

코틀린에서는 위의 코드를 이런 식으로 간편하게 선언과 함께 초기화를 할 수 있다. 이를 주 생성자라고 한다. 주 생성자에는 어떠한 초기화 로직도 포함할 수 없다. 클래스 옆에 constructor 키워드는 생략이 가능하다.

```kotlin
class Human constructor(val name: String, val age: Int)
```

```kotlin
class Human(val name: String, val age: Int)
```

## 코틀린의 부 생성자

부 생성자를 이용할 경우 주 생성자에서와 다르게 초기화 로직을 작성할 수 있는데, 이렇게 자바에서와 똑같이 코드를 작성할 수 있다. 주 생성자에서는 constructor 키워드를 생략할 수 있었지만, 부 생성자에서는 생략이 불가능하다. 부생성자가 있는 주된 이유는 자바와의 호환성때문이기도 하고, 주 생성자만으로는 처리가 어려운 상황이 있기 때문이다.

```kotlin
class Human{
    var name:String
    var age:Int
    constructor(name:String, age:Int){
        this.name = name
        this.age = age
    }
}
```

## 만약 주 생성자와 부 생성자를 같이 사용한다면?

주 생성자와 부 생성자가 같이 쓰일 경우 주 생성자에게 해당 변수에 대한 초기화를 위임해야 한다.

```kotlin
class Human(var name:String){
    var age:Int = 0
    constructor(name:String, age:Int):this(name){
        this.age = age
    }
}
```

## init 블럭

init 블럭은 한개를 작성할 수도 여러 개를 작성할 수도 있다. 아래 코드는 인스턴스가 생성될 때 인자로 받은 값을 콘솔에 출력하고, 안녕하세요를 출력하는 코드다. init 블럭이 여러 개일 경우 위에서 아래 순서로 실행된다.

```kotlin
class Human(var name:String, var age: Int){
    init {
        println("$name, $age")
    }
    init {
        println("안녕하세요")
    }
}
```

## 주 생성자, 부 생성자, init 블럭 실행 순서

**주 생성자 -> init 블록 -> 부 생성자**

## 빌더패턴처럼 사용할 수 있다

생성자 변수 주입 시 변수명을 지정해줄 수 있다. 이렇게 사용하면 빌더 패턴을 사용하는 것과 같은 효과를 볼 수 있다.

```java
class User(
    var name: String,
    var email: String?,
    var age: Int
)
```

```java
val user = User(
    name="gunkim",
    email="gunkim0318@gmail.com",
    age=10
)
```

# Getter, Setter 생성

자바에서는 Getter, Setter을 아래와 같이 생성한다.

```java
public static void main(String[] args) {
    Human human = new Human("gunkim", 21);

    System.out.println(human.getName()+", "+human.getAge()); //gunkim, 21
    human.setName("kimgun");
    human.setAge(18);
    System.out.println(human.getName()+", "+human.getAge()); //kimgun, 18
}
```

```java
public class Human {
    private String name;
    private int age;

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
}
```

코틀린에서는 사실 자동으로 Setter와 Getter를 생성해준다. 아래와 같이 프로퍼티에 접근 하듯이 내부적으로 가져올 땐 getter를 호출하고, 값을 지정할 땐 setter를 호출하게 된다.

```kotlin
fun main(args:Array<String>){
    var human = Human("gunkim", 21)

    println("${human.name}, ${human.age}") //gunkim, 21
    human.name = "kimgun"
    human.age = 18
    println("${human.name}, ${human.age}") //kimgun, 18
}

class Human constructor(var name: String, var age: Int)
```

## Getter, Setter를 직접 작성하기

아래와 같이 getter,setter를 생성할 필드변수에 들여쓰기를 통해 선언해주면 된다.
field라는 변수를 사용하는 이는 setter, getter를 생성할 해당 변수 주소값이 바인딩된다. 즉 여기서 field는 this.name이라고 보면 된다.

```kotlin
class Exam {
    var name: String = ""
        get() = if (field.length > 0) field else "name"
        set (value) {
            if (value.length > 0) field = value else ""
        }
}
```

# 인스턴스 생성

자바에서는 인스턴스를 생성할 때는 아래와 같이 new를 통해 생성한다.

```java
List<String> list = new ArrayList<>();
```

코틀린에서는 아래와 같이 new 키워드 없이 인스턴스를 생성한다.

```kotlin
var list = ArrayList<String>()
```

# 상속

자바에서는 상속을 아래와 같이 구현한다.

```java
class Human{
    public void sayHello(){
        System.out.println("Hello!");
    }
}
class gun extends Human{
    @Override
    public void sayHello(){
        System.out.println("Hi!");
    }
}
```

자바에서는 extends 키워드를 통해 상속을 받지만, 코틀린에서는 콜론(:)으로 상속을 받는다. 그리고 부모가 되는 클래스는 상속이 가능하도록 open 키워드를 붙여 상속이 가능하도록 해주어야 하고, 재정의(Override)를 할 메소드에도 open 키워드를 붙여 주어야 한다. 붙이지 않으면 Override가 불가능하다.
그리고 재정의(Override)를 할 때 자바에서는 @Override 어노테이션을 붙이지만 코틀린에서는 간단하게 fun 앞에 override 키워드를 붙여주면 된다.

```kotlin
class gunkim : Human() {
    override fun sayHello() {
        println("Hi!")
    }
}
open class Human{
    open fun sayHello(){
        println("Hello!")
    }
}
```

## 그럼 interface를 implements 받을 땐 어떻게 해야하나?

동일하게 콜론(:)을 사용하여 받을 수 있다.
지금 해당 예제는 Human클래스를 상속받고, Animal이라는 인터페이스를 implements받고 있다.
extends와 implements를 구분하는 방법은 생성자 호출 여부로 알 수 있다.
Human은 클래스이기 때문에 부모 클래스의 생성자 호출을 위해 ()을 열어주었지만, Animal은 인터페이스이기 때문에 부모 생성자를 호출하지 않는다.
그리고 class가 상속이 가능하게 하고, 메소드가 재정의되게 하기 위해 open키워드를 붙여줬던 반면 interface는 open 키워드를 붙여주지 않아도 된다.

```kotlin
interface Animal{
    fun eat()
}
class gunkim : Human(), Animal {
    override fun sayHello() {
        println("Hi!")
    }
}
```

# 자바와 다른 점

## 코틀린에서는 세미콜론이 필요없다?

실제로 코틀린에서는 세미콜론을 사용하지 않는다. 그래도 세미콜론을 붙인다고 컴파일 에러가 나진 않는다.
대신 한 줄에 여러 문장을 적는 경우는 세미콜론을 사용해야 한다.

![image](https://user-images.githubusercontent.com/45007556/91540311-946ec200-e955-11ea-8391-9b781654bc17.png)

## 함수도 값이다

코틀린에서는 일반적인 함수형 프로그래밍 언어에서 처럼 함수도 일급 객체로 취급되어 변수에 할당해서 값처럼 사용할 수 있다. 자바스크립트를 생각하면 이해하기 쉽다.

```kotlin
fun main(args:Array<String>){
    getFunc()();
}
fun getFunc(): () -> Unit {
    return fun(){
        println("Hello World!")
    }
}
```

## Null 안정성 지원

자바에서는 변수에 Null을 못 넣게하려면 사용할 수 있는 어노테이션 등 몇개 있지만 문법적으로 지원해주는 것은 없다.

하지만 코틀린에서는 Nullable 타입과 Non-Nullable 타입을 지정할 수 있는데 방법은 어렵지 않다. 변수명과 타입을 지정해주고 뒤에 ?를 붙이면 Null이 허용되는 Nullable타입이고, 붙이지 않으면 Null이 허용되지 않는 Non-Nullable 타입이다.

```kotlin
var name1:String? = "Nullable"
var name2:String = "Non-Nullable"
```

```
name1 = null //Nullable타입이기 때문에 컴파일 에러가 발생하지 않음
name2 = null //Non-Nullable타입이기 때문에 컴파일 에러가 발생함
```

# 자바의 System.out.println과 코틀린의 println은 무슨 차이일까?

이것은 내가 개인적으로 궁금해서 찾아본 부분이다. System.out.println를 먼저 살펴보면
System 클래스 안에 out객체가 static으로 선언이 되어 있고, out이라는 이름의 PrintStream 클래스를 살펴보면 println이라는 이름의 메소드가 선언이 되어 있는 것을 확인할 수 있다. static으로 선언이 되어 있기 때문에 사용할 때 인스턴스 생성을 해주지 않아도 되었던 것이다.
![image](https://user-images.githubusercontent.com/45007556/91521103-dd148400-e931-11ea-87f6-f44ce6bea287.png)
![image](https://user-images.githubusercontent.com/45007556/91521578-f23de280-e932-11ea-8542-341f81f787a2.png)

그리고 코틀린의 println을 살펴보면 함수로 선언이 되어 있고, 내부적으로는 System.out.println을 사용하고 있는 것을 확인할 수 있다.
결국 코틀린의 println과 자바의 System.out.println은 결국 동일하다고 볼 수 있다. 그렇기 때문에 코틀린에서도 System.out.println을 사용이 가능하다. 하지만 굳이 사용할 이유는 없는 것 같다.
![image](https://user-images.githubusercontent.com/45007556/91521649-1699bf00-e933-11ea-8407-ebbd0e0c6d4d.png)

# 마지막으로

코틀린을 이번에 한번 쭉 훑어보면서 느낀 점은 정말 지금까지 자바를 사용하면서 느꼈던 답답함이 한번에 해소되는 느낌이 들었다. 아직 그리 깊게는 써보지 않았는데도 정말정말 재미 있었고, 코틀린이 왜 자바의 대체재라고 불리는 지 크게 깨닫게 되었다. 다음에 사이드 프로젝트를 할 때 코틀린으로 한번 진행을 해보려고 생각중이다.


코틀린과 자바 비교해보면서 훑어보기


일일커밋을 시작해보기 전에 시작하기에 앞서 하기로 마음 먹은 이유와 규칙 등을 정리해보려고 한다.

# 하려고 하는 이유?

그 동안 공부를 해오면서 느꼈던 게 코드를 작성해서 결과물을 눈으로 확인하는 것 외에는 눈에 보이는 지표가 없으니 사이드 프로젝트 등을 해서 결과물을 내지 않고서는 뭔가를 해냈다는 성취감 같은 게 적었던 것 같다. 그러던 중 배달의 민족의 이동욱님 블로그 글 [일일커밋의 효용성](https://jojoldu.tistory.com/402)이라는 글을 보고 나도 무언가 지표를 찾아야 겠다 생각했다.

# 일일커밋

![image](https://user-images.githubusercontent.com/45007556/91475545-b412d580-e8d6-11ea-8834-0dce3354058c.png)
![image](https://user-images.githubusercontent.com/45007556/91475632-ce4cb380-e8d6-11ea-936b-78409ff769ee.png)
![image](https://user-images.githubusercontent.com/45007556/91475667-df95c000-e8d6-11ea-9df3-45cda0465051.png)
그렇게 선택한 것이 일일커밋. 깃허브에 잔디를 가득 심기로 한 것이다.
깃허브에 가입한 것은 고등학교 때인 2018년에 처음 가입해서 3년 간의 기록은 위와 같다.
그간 꾸준히 코딩을 하고 커밋을 하기도 했지만, 부끄러운 코드를 private로 돌리고 삭제하고를 반복하고.. 그렇게 비게된 곳도 상당하다.
일일커밋에 집착하는 것은 물론 안되겠지만, 꾸준히 무언가를 지속적으로 하면서 꾸준함을 기르고, 코딩하는 습관을 기를 수 있을 것 같아 지금 내 기준에서 단점보다는 장점이 훨씬 많은 것 같다. 그리고 매일매일 코딩하다 코딩할 게 별로 없을 때는 부끄러워 private로 돌려버린 프로젝트나 아니면 사이드 프로젝트를 진행하다 흐지부지 되어진 것들을 다시 진행해보고, 리팩토링을 해보려고 한다.
더는 부끄러운 코드를 감추지 않고, 도망가지 않으려고 한다.

# 나만의 규칙

이제 일일커밋을 위한 나만의 규칙을 세우기 위해 찾아본 [아웃사이더님 블로그](https://blog.outsider.ne.kr/1141)를 참고했다.

1. **의미없는 커밋은 하지 않기** 줄바꿈이나 버전업 등 의미없는 커밋은 하지 않고, 의미있는 코드만을 커밋할 것이다.
2. **커밋 로그를 명확히 작성하기** 보통 지금까지 코드를 커밋할 때는 ~를 수정함 등으로 작성했었는데, 어떤 걸 수정했는 지 정도는 좀 더 명확히 작성하려고 한다.
3. **깃허브 블로그에 대한 커밋은 제외하기** 물론 깃허브에 포스팅을 하는 것도 잔디가 심어지겠지만, 그렇게 되면 의도와는 다르기 때문에 제외한다.


일일커밋 시작하기


항상 스프링 부트+리액트 개발할 때 스프링 부트 서버(8080) 실행하고, 리액트 서버(3000)을 실행해서 프록시 설정을 통해 통신을 했었는데, 항상 두번씩 실행해야 해서 번거롭기도 해서 한번에 빌드하는 방법을 정리해보려고 한다. [예제 프로젝트](https://github.com/gunkim0318/springboot-react-example)

# 개발 환경

> Java 1.8  
> Spring Boot 2.2.4  
> NodeJs 14.2.0  
> React 16.13.1

# 사전 준비

해당 이미지와 같이 스프링 부트 프로젝트를 생성하고 root 디렉토리에 frontend폴더를 만들어서 my-app이라는 이름의 리액트 프로젝트를 생성해주자.

![image](https://user-images.githubusercontent.com/45007556/91056894-7d805500-e661-11ea-994d-e8a0f3cb16b9.png)

# 그래들(Gradle) build.gradle 수정해주기

## 전체 스크립트

```java
buildscript {
    ext {
        springBootVersion = '2.2.4.RELEASE'
        dependencyManagementVersion = '1.0.10.RELEASE'
        mooworkNodeVersion = "1.3.1"
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
plugins {
    id "com.moowork.node" version "${mooworkNodeVersion}"
    id "java"
    id "org.springframework.boot" version "${springBootVersion}"
    id "io.spring.dependency-management" version "${dependencyManagementVersion}"
}
group = 'com.gun'
version = '0.0.1'
sourceCompatibility = '1.8'

repositories {
    mavenCentral()
}

dependencies {
    testImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-test'
    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web'
}

test {
    useJUnitPlatform()
}
//리액트 프로젝트 경로
//$projectDir은 스프링 부트 root 경로
def webappDir = "$projectDir/frontend/my-app"

task appNpmInstall(type: NpmTask) {
    workingDir = file("${webappDir}")
    args = ["run", "build"]
}
task copyWebApp(type: Copy) {
    from 'frontend/my-app/build'
    into "build/resources/main/static"
}
copyWebApp.dependsOn(appNpmInstall)
compileJava.dependsOn(copyWebApp)
```

## 주요 스크립트

gradle에서 Node 빌드를 하기 위한 플러그인 "com.moowork.node"을 추가해주었다.

그리고 gradle 빌드 시 리액트 프로젝트 경로에서 "npm run bulid" 명령어가 실행되어 리액트 프로젝트가 빌드되도록 하고, 해당 빌드된 내용을 gradle빌드 된 스프링 부트 정적 콘텐츠 영역에 포함시켰다.

```java
plugins {
    id "com.moowork.node" version "${mooworkNodeVersion}"
}

//리액트 프로젝트 경로
//$projectDir은 스프링 부트 root 경로
def webappDir = "$projectDir/frontend/my-app"

task appNpmInstall(type: NpmTask) {
    workingDir = file("${webappDir}")
    args = ["run", "build"]
}
task copyWebApp(type: Copy) {
    from 'frontend/my-app/build'
    into "build/resources/main/static"
}
copyWebApp.dependsOn(appNpmInstall)
compileJava.dependsOn(copyWebApp)
```

# 그래들(Gradle) 빌드

스프링 부트 루트 경로에서 아래 명령어를 실행해주게 되면 그래들 빌드가 되게 된다.

> gradle clean build

빌드된 내용을 보면 appNpmInstall이 실행되면서 리액트 프로젝트가 빌드되는 것을 확인할 수 있다.

BUILD SUCCESSFUL 메시지가 확인되면 성공이다.

```
PS C:\Users\gunkim\workspace\java\springboot-react-example> gradle clean build

> Task :appNpmInstall

> my-app@0.1.0 build C:\Users\gunkim\workspace\java\springboot-react-example\frontend\my-app
> react-scripts build

Creating an optimized production build...
Compiled successfully.

File sizes after gzip:

  46.61 KB  build\static\js\2.298dc5ad.chunk.js
  772 B     build\static\js\runtime-main.83c3e0c4.js
  706 B     build\static\js\main.63a4bfce.chunk.js

The project was built assuming it is hosted at /.
You can control this with the homepage field in your package.json.

The build folder is ready to be deployed.
You may serve it with a static server:

  yarn global add serve
  serve -s build

Find out more about deployment here:

  bit.ly/CRA-deploy


> Task :test
2020-08-19 01:11:55.968  INFO 6600 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'

BUILD SUCCESSFUL in 10s
8 actionable tasks: 8 executed

```

# 빌드 파일 실행

빌드가 되면 스프링 부트 root디렉토리 build폴더와 함께 libs안에 빌드된 jar파일이 있는데 이것을 실행해주면 된다. 해당 경로로 이동해서 아래 명령어 실행

> java -jar springboot-react-example-0.0.1.jar

![image](https://user-images.githubusercontent.com/45007556/91056971-938e1580-e661-11ea-92fd-35fc69ad0607.png)

# 확인

아래 경로에 접속하게 되면 아래와 같이 제대로 연동된 것을 확인할 수 있다.

> localhost:8080

![image](https://user-images.githubusercontent.com/45007556/91056985-9ab52380-e661-11ea-8727-6ce068f6362a.png)

# 참고

[https://blog.indrek.io/articles/serving-react-apps-from-spring-boot/](https://blog.indrek.io/articles/serving-react-apps-from-spring-boot/)


스프링 부트(Spring Boot)+리액트(React) 함께 빌드하기

[Spring Boot] Spring Security + JWT 구현


그 동안 스프링 시큐리티를 잘 알지 못하고 사용했었는데, 스프링 시큐리티에 대한 이해도를 높일 겸 정리해보려고 한다.

# 스프링 시큐리티(Spring Security)란?

![image](https://user-images.githubusercontent.com/45007556/91024296-b6550580-e632-11ea-874f-8618094b21e5.png)
스프링 기반의 어플리케이션의 보안(인증과 권한, 인가 등)을 담당하는 스프링 하위 프레임워크이다.

# 용어 정리

- **접근 주체(Principal)**: 보호된 리소스에 접근하는 대상
- **인증(Authentication)**: 보호된 리소스에 접근한 대상에 대해 이 유저가 누구인지, 애플리케이션의 작업을 수행해도 되는 주체인지 확인하는 과정
- **인가(Authorize)**: 해당 리소스에 대해 접근 가능한 권한을 가지고 있는지 확인하는 과정
- **권한**: 인가 과정에서 해당 리소스에 대한 제한된 최소한의 권한을 가졌는지 확인한다.

# 주요 특징

스프링 시큐리티 [레퍼런스 문서](https://docs.spring.io/spring-security/site/docs/5.4.0-RC1/reference/html5/#features)에 나와 있는 특징 중 중요해보이는 것만 정리해보았음.

## 입증

Spring Security는 인증에 대한 포괄적인 지원을 제공한다.
사용자를 인증하는 일반적인 방법은 사용자에게 사용자 이름과 비밀번호를 입력하는 Credential방식을 사용한다.

## 비밀번호 저장

PasswordEncoder 인터페이스를 통해 패스워드 암호화를 지원함.
PasswordEncoder 인터페이스는 안전하게 저장하기 위해 패스워드의 단방향 변환 방식을 사용함.
추후에 로그인 시 비밀번호를 비교해야 할 때 암호화했던 비밀번호를 복호화 후 비교하는 것이 아닌 일치하는 지 여부만 알려주는 방식을 사용.

## CSRF 공격 보호 지원

### CSRF 공격이란?

만약 이런 간단한 form에 보낼 금액, 받는 사람 계좌번호, 아이디를 입력하면 입금할 수 있는 은행 프로그램이 있을 때 요청 시 정상적으로 처리가 될 것이다.

```html
<form method="post" action="/transfer">
  <input type="text" name="amount" />
  <input type="text" name="routingNumber" />
  <input type="text" name="account" />
  <input type="submit" value="Transfer" />
</form>
```

```
POST /transfer HTTP/1.1
Host: bank.example.com
Cookie: JSESSIONID=randomid
Content-Type: application/x-www-form-urlencoded

amount=100.00&routingNumber=1234&account=9876
```

그런데 만약 아래와 같이 해커가 다른 사이트에 똑같은 형식으로 요청하는 스크립트를 작성해서 다른 사람이 버튼 클릭 시 자기 계좌에 입금하도록 한다면? 게다가 이게 자동화가 되어 버튼을 누를 필요도 없다면? 큰 문제가 생길 것이다.

일단 서버에서는 해당 요청에 문제가 없고, 올바른 요청인지 아닌지 알 수 없기 때문에 정상적으로 처리가 될 것이다.

```html
<form method="post" action="https://bank.example.com/transfer">
  <input type="hidden" name="amount" value="100.00" />
  <input type="hidden" name="routingNumber" value="evilsRoutingNumber" />
  <input type="hidden" name="account" value="evilsAccountNumber" />
  <input type="submit" value="Win Money!" />
</form>
```

### 스프링 시큐리티에서는 어떻게 해결했는지?

same-origin, 동기화 토큰 패턴 등 여러 방법이 있지만 스프링 시큐리티에서는 동기화 토큰 패턴을 사용한다. 아래처럼 서버에서 발급한 csrf토큰을 form에 삽입하여 요청 시 매개변수에 포함되도록 한다. 그래서 서버에서는 발급한 csrf토큰과 이 토큰값을 비교하여 다를 경우 요청이 실패되도록 한다.

```html
<form method="post" action="/transfer">
  <input type="hidden" name="_csrf" value="4bfd1575-3ad1-4d21-96c7-4ef2d9f86721" />
  <input type="text" name="amount" />
  <input type="text" name="routingNumber" />
  <input type="hidden" name="account" />
  <input type="submit" value="Transfer" />
</form>
```

```
POST /transfer HTTP/1.1
Host: bank.example.com
Cookie: JSESSIONID=randomid
Content-Type: application/x-www-form-urlencoded

amount=100.00&routingNumber=1234&account=9876&\_csrf=4bfd1575-3ad1-4d21-96c7-4ef2d9f86721
```

# 주요 객체

- **Authentication** - 요청 시 입력 받은 사용자 ID, 패스워드와 같은 인증 요청 정보를 가지고 있다.
- **AuthenticationFilter** - 시큐리티 관련 전처리를 위한 필터
- **AuthenticaitonManager** - 사용자 비밀번호를 인증하는 역할을 담당한다.
- **AuthenticationProvider** - AuthenticationManager에게 비밀번호 인증 기능을 제공한다.
- **UserDetailsService** - UserDetails를 반환함
- **UserDetails** - DB에서 가져온 사용자 정보(이름, 이메일, 전화번호)를 저장하기 위함.
- **SecurityContext** - Authentication를 보관함

# 시큐리티 인증 흐름

![image](https://user-images.githubusercontent.com/45007556/91036976-37b49400-e643-11ea-809d-841e6d4befd3.png)

1. **UsernamePasswordAuthenticationFilter(AuthenticationFilter)** 는 **HttpServletRequest**에서 사용자가 전송한 아이디와 패스워드를 가로챈다.
2. **AuthenticationFilter**는 인증용 객체 **Authentication**을 생성한다.
3. **AuthenticationFilter**는 인증을 위해 **AuthenticationManager**에게 **Authentication**을 전달한다.
4. **AuthenticationManager**는 실제 인증 기능이 수행을 위해 **AuthenticationProvider**에게 다시 **Authentication**을 전달한다.
5. **AuthenticationProvider**는 **UserDetailsService**에게 조회할 username을 전달하여 인증을 위한 **UserDetails**(DB 사용자 정보) 객체를 요청한다.
6. **UserDetailsService**는 **AuthenticationProvider**에게 전달 받은 username을 통해 **UserDetails**(DB 사용자 정보)를 찾는다.
7. **UserDetailsService**는 username을 통해 찾은 **UserDetails**(DB 사용자 정보)를 반환한다.
8. **AuthenticationProvider**는 **Authentication**과 **UserDetails**를 가지고 인증을 수행하여 인증에 성공 시 **Authentication**을 반환한다. (반환할 **Authentication**에는 부여된 권한, 인증 여부가 포함됨)
9. **AuthenticationManager**는 **AuthenticationProvider**을 통해 인증에 성공할 경우 전달 **AuthenticationProvider**을 통해 전달받은 **Authentication**을 반환한다.
10. 인증이 최종적으로 완료되면 **Authentication**객체를 **SecurityContextHolder**에 담은 후 성공 시 **AuthenticationSuccessHandler**, 실패 시 **AuthenticationFailureHandler**를 실행한다.

# 스프링 시큐리티 필터 체인

![image](https://user-images.githubusercontent.com/45007556/91037118-70ed0400-e643-11ea-8280-acf4aaa34245.png)
위에서 시큐리티 인증 흐름을 설명할 때 2번에서 form 기반 인증 흐름을 설명하기 위해 **UsernamePasswordAuthenticationFilter(AuthenticationFilter)** 에 대해서 설명했었다. 그런데 시큐리티에서 지원하는 필터는 이것 하나만이 아니라 아래와 같은 순서로 여러 필터가 실행이 되는데 그 중 하나인 것이다. 전부 외워둘 필요는 없지만 훑어놨다가 나중에 커스텀할 일이 생겼을 때 다시 찾아보면 될 듯 하다.

1. **WebAsyncManagerIntegrationFilter** - ThreadLocal기반으로 같은 쓰레드 내에서만 SecurityContext가 공유됨. SpringSecurityContextHolder를 비동기(Async)와 관련된 기능을 쓸 때에도 SecurityContext를 사용할 수 있도록 만들어줌.
2. **SecurityContextPersistenceFilter** - SecurityContext가 없으면 생성하고, 있을 경우 불러오는 기능을 함.
3. **HeaderWriterFilter** - 응답(Response)에 Security와 관련된 헤더 값을 설정함.
4. **CsrfFilter** - CSRF 공격을 방어함.
5. **LogoutFilter** - 로그아웃 URL로 들어오는 요청을 감시하여 해당 사용자를 로그아웃 시킴.
6. **UsernamePasswordAuthenticationFilter** - 사용자 ID, 패스워드를 쓰는 form기반 인증을 처리함.
7. **RequestCacheAwareFilter** - 인증 후, 원래 Request 정보로 재구성함.
8. **SecurityContextHolderAwareRequestFilter** - HttpServletRequestWrapper를 상속한 SecurityContextHolderAwareRequestWapper 객체로 HttpServletRequest 정보를 감싼다. 해당 Wrapper객체는 필터 체인상의 다음 필터들에게 부가정보를 제공함.
9. **AnonymousAuthenticationFilter** - 이 필터에 올 때까지 앞에서 사용자 정보가 인증되지 않았다면, 해당 요청은 익명의 사용자가 보낸 것으로 판단하고 처리하고. **AnonymousAuthenticationToken**(**Authentication**)객체를 새로 생성함.
10. **SessionManagementFilter** - 인증된 사용자와 관련된 모든 세션을 추적함.(세션 변조 공격 방지, 유효하지 않은 세션으로 접근 시 URL 핸들링, 하나의 세션 아이디로 접속하는 세션 최대 수 설정, 세션 생성 전략 설정 등)
11. **ExceptionTranslationFilter** - 이전 필터들에서 인증 예외(AuthenticationException) 또는 인가 예외(AccessDeniedException)가 발생한 경우, 해당 예외를 캐치하여 처리함.
12. **FilterSecurityInterceptor** - 인가(Authorization)를 결정하는 AccessDecisionManager에게 접근 권한이 있는지 확인하고 처리함.

# Authentication와 UserDetails

**Authentication**은 사용자 요청 정보, 입력한 아이디, 비밀번호가 될 것이고,
**UserDetails**는 사용자 DB 정보, DB에 저장된 아이디, 비밀번호가 될 것이다.
그래서 모든 접근 주체는 **Authentication**을 생성하게 되고, 인증을 위해서는 **UserDetails**를 불러오게 된다.
여기서는 중요하다고 생각한 이 두 객체의 주요 메서드에 대해서 정리해놓는다.

## **Authentication**의 메소드

|               리턴 타입                |                 메소드명                  |                                               설명                                               |
| :------------------------------------: | :---------------------------------------: | :----------------------------------------------------------------------------------------------: |
| Collection<? extends GrantedAuthority> |             getAuthorities()              |                          저장소에 의해 인증된 사용자의 권한 목록을 반환                          |
|                 Object                 |             getCredentials()              |                       주체의 비밀번호(꼭 비밀번호가 아닐 수도 있음)을 반환                       |
|                boolean                 |             isAuthenticated()             | 인증 여부, AuthebnticationManager에 토큰을 제공할 지를 판단. 성공할 경우 불변의 인증 토큰을 반환 |
|                  void                  | setAuthenticated(boolean isAuthenticated) |                                         인증 여부를 설정                                         |

## **UserDetails**의 메소드

| 리턴 타입                              | 메소드명                  | 설명                                        |
| -------------------------------------- | ------------------------- | ------------------------------------------- |
| String                                 | getUsername()             | 계정 아이디를 반환                          |
| String                                 | getPassword()             | 계정 비밀번호를 반환                        |
| boolean                                | isAccountNonExpired()     | 계정 만료되지 않았는지를 반환               |
| boolean                                | isAccountNonLocked()      | 계정이 잠금 되어있지 않은 지를 반환         |
| boolean                                | isCredentialsNonExpired() | 계정의 패스워드가 만료되지 않았는 지를 반환 |
| boolean                                | isEnabled()               | 사용 가능 계정인지를 반환                   |
| Collection<? extends GrantedAuthority> | getAuthorities()          | 계정이 갖고 있는 권한 목록을 반환           |

두 객체의 메소드를 살펴보면 뭔가 매칭이 되는 메소드가 보인다. 알고 쓰는 것도 좋을 것 같다.

# AuthenticationManager

![image](https://user-images.githubusercontent.com/45007556/91037952-e3aaaf00-e644-11ea-8bdf-57e159a5ea3d.png)

인증 흐름에서 설명했듯이 이 그림과 함께 주요 흐름을 보강 설명하겠다.

1.  필터가 **Authentication**을 **AuthenticationManager**에 전달하여 인증 요청을 한다.
2.  **AuthenticationManager**는 **AuthenticationProvider**에게 **Authentication**를 전달하여 다시 인증 요청을 한다.
3.  **AuthenticationProvider**는 인증이 성공할 경우 **Authentication**의 멤버 변수 isAuthenticated를 true로 설정한다.

# 비밀번호 암호화 시 사용되는 PasswordEncoder

## [스프링 공식 홈페이지](https://docs.spring.io/spring-security/site/docs/5.1.1.RELEASE/reference/htmlsingle/#pe-dpe)에서 설명하고 있는 **PasswordEncoder**를 사용했을 때의 장점

- 현재 비밀번호 저장 권장 사항을 사용하여 비밀번호가 인코딩되도록 보장
- 최신 및 레거시 형식의 비밀번호 유효성 검사 허용
- 향후 인코딩 업그레이드 허용

## 주요 메소드

| 리턴 타입 | 메소드명                                                  | 설명                                                 |
| --------- | --------------------------------------------------------- | ---------------------------------------------------- |
| String    | encode(CharSequence rawPassword)                          | 비밀번호를 받아 암호화된 비밀번호를 반환             |
| boolean   | matches(CharSequence rawPassword, String encodedPassword) | 비밀번호와 암호화된 비밀번호를 받아 일치 여부를 반환 |

## 암호화 알고리즘

**PasswordEncoder**는 bcrypt, noop, pbkdf2, scrypt, sha256 등 여러가지 암호화 알고리즘을 지원하여 개발할 때 사용하고 싶은 암호화 방식을 선택하여 해당하는 구현체를 쓸 수 있다.
![image](https://user-images.githubusercontent.com/45007556/91037979-ed341700-e644-11ea-9248-e09471bc4b7b.png)

## 암호화 결과물

encode 메소드를 통해 비밀번호를 암호화를 해서 반환 받은 문자열을 살펴보면 아래와 같이 앞에 접두사로 {암호화 방식}이 붙는다. bcrypt로 암호화를 했기 때문에 {bcrypt}가 붙었다.

> {bcrypt}$2a$10\$g1PWM7YhvhhA3PUtnSh.mOZVQFQe7fTO0C2na2Xpbrit.bwYlQdPe

# 참고

[https://jeong-pro.tistory.com/205](https://jeong-pro.tistory.com/205)  
[https://springsource.tistory.com/80](https://springsource.tistory.com/80)  
[https://coding-start.tistory.com/153](https://coding-start.tistory.com/153)


스프링 시큐리티 정리


API서버를 개발하다 보면, API에 대한 문서를 만드는 것도 일이고, API가 수정될 때마다 문서를 업데이트하는 것도 일인데, 이를 위해서 스웨거(Swagger)를 사용한다. 그래서 스웨거 설정 방법에 대해서 정리해보려고 한다.

# Swagger란?

![image](https://user-images.githubusercontent.com/45007556/91055366-86702700-e65f-11ea-828c-795ba0452b3e.png)

API 스펙을 명세, 관리할 수 있게 해주는 프로젝트이다.

매번 API가 수정될 때마다 문서를 수정하거나, 개발이 완료된 프로젝트를 스펙을 정리하고, 명세화하는 경우가 많다. 이런 어려움을 해결해주는 녀석이다.

# 의존성 추가

## gradle

```java
implementation group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.9.2'
implementation group: 'io.springfox', name: 'springfox-swagger2', version: '2.9.2'
```

## maven

```xml
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
```

# 설정 클래스 작성

```java
package com.gun.app.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * 스웨거 설정을 위한 클래스
 * @author gunkim
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    /**
     * 스웨거 API 문서 생성
     * @author gunkim
     * @return Docket
     */
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(this.swaggerInfo()) //api 정보 등록
                .select()
                .apis(RequestHandlerSelectors.any())
                .build()
                .useDefaultResponseMessages(true);
    }

    /**
     * 스웨거 정보
     * @author gunkim
     * @return ApiInfo
     */
    private ApiInfo swaggerInfo(){
        return new ApiInfoBuilder()
                .title("할 일 리스트 API 문서") //문서 제목
                .description("할 일 리스트 프로젝트입니다.") //문서 설명
                .version("1.0.0") //버전
                .build();
    }
}
```

이런 식으로 API문서 설명을 적을 수도 있고, 컨트롤러마다 그룹을 지정하여 컨트롤러마다 설명을 기술해줄 수도 있다.

# 확인

[http://localhost:8080/swagger-ui.html](http://localhost:8080/swagger-ui.html)

해당 경로에 들어가서 확인하면 이렇게 멋진 API 문서가 만들어져 있다. _설정에 따라 포트가 8080이 아닌 경우가 있음. 그런 경우는 알아서_

![image](https://user-images.githubusercontent.com/45007556/91055540-c0d9c400-e65f-11ea-8717-889157a001c3.png)

# 추가 작성하기

```java
package com.gun.app.web;

import com.gun.app.dto.TodoRequestDTO;
import com.gun.app.dto.TodoResponseDTO;
import com.gun.app.service.TodoService;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 할 일 API 컨트롤러
 * @author gunkim
 */
@Slf4j
@RequestMapping("/api/todo")
@RestController
@RequiredArgsConstructor
public class TodoController {
	//... 생략

    /**
     * 할 일 등록
     * @author gunkim
     * @param dto
     * @return resultMsg
     */
    @ApiOperation("할 일 등록")
    @ApiImplicitParams({
            @ApiImplicitParam(name="text", value="내용", dataType = "string"),
            @ApiImplicitParam(name="isCheck", value="체크여부", dataType = "boolean")
    })
    @PostMapping("")
    public ResponseEntity<String> createTodo(@RequestBody TodoRequestDTO dto){
        try{
            todoService.createTodo(dto);
        }catch(IllegalArgumentException e){
            return new ResponseEntity<>("FAILURE", HttpStatus.BAD_REQUEST);
        }
        return new ResponseEntity<>("SUCCESS", HttpStatus.OK);
    }
}
```

주요 어노테이션

- @ApiImplicitParam - 파라미터 정보를 기술할 수 있다.
- @ApiImplicitParams - 파라미터가 여러개일 경우 감싸주면 된다.
- @ApiOperation - 해당 API 설명을 기술해주면 된다.
- @ApiModelProperty - 필드 변수에 대한 설명을 기술할 경우 사용한다.
- @ApiResponse - 응답 코드에 대한 설명을 기술할 경우 사용한다.
- @ApiModelProperty - Model 프로퍼티 설명을 기술할 경우 사용한다.

## 추가 작성 내용 확인

![image](https://user-images.githubusercontent.com/45007556/91055574-cdf6b300-e65f-11ea-80ea-6ceca6e0bd05.png)

# 스웨거를 이용한 API 테스트

![image](https://user-images.githubusercontent.com/45007556/91055593-d6e78480-e65f-11ea-82e4-10c259161360.png)
![image](https://user-images.githubusercontent.com/45007556/91055600-d9e27500-e65f-11ea-9bbd-4bf1fa8def1d.png)
![image](https://user-images.githubusercontent.com/45007556/91055603-dc44cf00-e65f-11ea-9cfc-fd8acfb0b48c.png)

Try it out 버튼을 클릭 후 나타나는 Execute버튼을 클릭하여 테스트 실행 후 결과 확인


스프링 부트 스웨거(Swagger)를 이용하여 REST API문서 자동화하기


간혹 이렇게 비밀번호 입력 후 다시 한번 맞게 입력한건지 확인 비밀번호를 입력하는 경우가 있다. 이런 경우 기본적으로 지원하는 Validation 어노테이션으로는 단일 필드에 대한 유효성 검증만 처리가 가능하기 때문에 Validator을 커스텀해주어야 한다. 그 방법에 대해서 작성해보려고 한다.

# DTO클래스

```java
package application.web.dto;

import application.jpa.enums.Gender;
import application.jpa.domain.Member;
import application.jpa.enums.Role;
import lombok.*;

import javax.validation.constraints.*;

/**
 * 회원 Service 요청을 위한 DTO
 */
@Getter
@Setter
@ToString
@NoArgsConstructor
public class MemberRequestDTO {
    @Email
    @NotBlank
    private String email;
    @NotBlank
    //최소 8글자, 최대 12글자, 특수문자 포함하도록
    @Pattern(regexp="([a-zA-Z0-9].*[!,@,#,$,%,^,&,*,?,_,~])|([!,@,#,$,%,^,&,*,?,_,~].*[a-zA-Z0-9]){8,12}" ,message="숫자 영문자 특수 문자를 포함한 8 ~ 12 자를 입력하세요. ")
    private String password;
    @NotBlank
    //최소 8글자, 최대 12글자, 특수문자 포함하도록
    @Pattern(regexp="([a-zA-Z0-9].*[!,@,#,$,%,^,&,*,?,_,~])|([!,@,#,$,%,^,&,*,?,_,~].*[a-zA-Z0-9]){8,12}" ,message="숫자 영문자 특수 문자를 포함한 8 ~ 12 자를 입력하세요. ")
    private String passwordChk;
    @Size(min=2, max=10)
    @NotBlank
    private String nickname;
    @NotBlank
    private String gender;

    @Builder
    public MemberRequestDTO(String email, String password, String passwordChk, String nickname, String gender){
        this.email = email;
        this.password = password;
        this.passwordChk = passwordChk;
        this.nickname = nickname;
        this.gender = gender;
    }

    /**
     * 비밀번호와 확인 비밀번호 일치하지 않는지 확인.
     * @return
     */
    public boolean isPwNotEquals(){
        return !password.equals(passwordChk);
    }

    public Member toEntity(){
        return Member.builder()
                .email(this.email)
                .password(this.password)
                .nickname(this.nickname)
                .gender(Gender.valueOf(gender))
                .role(Role.USER)
                .build();
    }
}
```

그냥 평범한 DTO클래스이다. 비밀번호와 확인 비밀번호가 맞는 지 확인하기 위한 메소드를 추가해주었음.

# Validator을 구현한 AbstractValidator 클래스 작성

```java
package application.validator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;

/**
 * 커스텀 유효성 검증을 위해 Validator을 구현한 클래스
 * @param <T>
 */
@Slf4j
public abstract class AbstractValidator<T> implements Validator {
    @Override
    public boolean supports(Class<?> clazz) {
        return true;
    }
    @SuppressWarnings("unchecked")
    @Override
    public void validate(Object target, Errors errors) {
        try{
            doValidate((T) target, errors);
        }catch(RuntimeException e){
            log.error("유효성 검증 에러", e);
            throw e;
        }
    }

    /**
     * 유효성 검증 로직이 들어감
     * @param form
     * @param errors
     */
    protected abstract void doValidate(final T form, final Errors errors);
}
```

validate를 구현해주었고, 검증로직이 들어갈 부분을 doValidate로 따로 빼주었음.

- @SuppressWarnings("unchecked") - 컴파일러에서 경고하지 않도록 하기 위해 사용

# PasswordCheckValidator 클래스 작성

```java
package application.validator;

import application.web.dto.MemberRequestDTO;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;

/**
 * 비밀번호 확인 유효성 검증을 위한 커스텀 Validator클래스
 */
@Component
public class PasswordCheckValidator extends AbstractValidator<MemberRequestDTO> {
    @Override
    protected void doValidate(MemberRequestDTO form, Errors errors) {
        if(form.isPwNotEquals()){
            errors.rejectValue("passwordChk", "확인 비밀번호 불일치 오류", "비밀번호와 확인 비밀번호가 일치하지 않습니다.");
        }
    }
}
```

doValidate를 구현하여 검증로직을 작성하였고, bean으로 등록될 수 있도록 @Component 어노테이션을 붙여주었음.

# Controller에 메소드 추가

```java
package application.web;

import application.service.MemberService;
import application.util.ErrorsTransUtil;
import application.validator.PasswordCheckValidator;
import application.web.dto.MemberRequestDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

/**
 * 회원 Controller
 */
@Slf4j
@RequiredArgsConstructor
@Controller
public class MemberController {
    private final MemberService memberService;
    private final PasswordCheckValidator passwordCheckValidator;

    /**
     * 커스텀 유효성 검증을 위해 추가
     * @param binder
     */
    @InitBinder
    public void validatorBinder(WebDataBinder binder){
        binder.addValidators(passwordCheckValidator);
    }

    /**
     * 회원가입 페이지 이동
     */
    @GetMapping("/member/signUp")
    public void signUp(){}

    /**
     * 회원가입 처리
     * @param dto
     * @param errors
     * @param model
     * @param rttr
     * @return
     */
    @PostMapping("/member/signUp")
    public String signUp(@Validated MemberRequestDTO dto, BindingResult errors, Model model, RedirectAttributes rttr) {
        if(errors.hasErrors()){
            ErrorsTransUtil errorUtil = new ErrorsTransUtil(errors);
            boolean isFemale = dto.getGender().equals("F");
            model.addAttribute("member", dto);
            model.addAttribute("isFemale", isFemale);
            model.addAttribute("errors", errorUtil.getMap());
            return "/member/signUp";
        }
        rttr.addFlashAttribute("msg", "회원가입에 성공했습니다!");
        memberService.signUp(dto);
        return "redirect:/";
    }
    /**
     * 로그인 페이지 이동
     */
    @GetMapping("/member/signIn")
    public void signIn(){}
}
```

validatorBinder메소드를 작성하여 추가 검증할 Validator을 추가하여 주었음.

메소드명은 자유롭게 작성해도 상관없다.

- @InitBinder - 특정 컨트롤러에서 바인딩 또는 검증 설정을 변경하고 싶을 때 사용

- WebData Binder - HTTP 요청 정보를 컨트롤러 메소드의 파라미터나 모델에 바인딩할 때 사용되는 바인딩 객체

## 정리

Validation을 커스텀하기 위해서는 Validator을 구현해주어 검증 로직을 작성해주면 되고,

해당 Validator 사용을 위해서는 Controller에 @InitBinder이 붙은 WebDataBinder을 인자로 받는 메소드를 작성하여 추가해주어야 한다.


스프링 부트 유효성 검증(Validation)을 커스텀하여 여러가지 항목에 대해 상호 검증하기


{% raw %}
Mustache를 더 잘쓰고 싶어서 Mustache 관련 사이트를 뒤지던 중 원하던 기능을 발견해서 정리해보려고 한다.

우선 Mustache에서 이렇게 사용할 때만약 값이 없을 경우 아래처럼 메소드 또는 필드가 없다는 에러가 발생한다.

```
{{member}}
```

```
com.samskivert.mustache.MustacheException$Context: No method or field with name 'member' on line 9 at com.samskivert.mustache.Template.checkForMissing(Template.java:344) ~\[jmustache-1.15.jar:na\] at com.samskivert.mustache.Template.getValue(Template.java:247) ~\[jmustache-1.15.jar:na\] at com.samskivert.mustache.Template.getCompoundValue(Template.java:260) ~\[jmustache-1.15.jar:na\] at com.samskivert.mustache.Template.getValue(Template.java:244) ~\[jmustache-1.15.jar:na\] at com.samskivert.mustache.Template.getValueOrDefault(Template.java:292) ~\[jmustache-1.15.jar:na\] at com.samskivert.mustache.Mustache$VariableSegment.execute(Mustache.java:872) ~\[jmustache-1.15.jar:na\] at com.samskivert.mustache.Template.executeSegs(Template.java:170) ~\[jmustache-1.15.jar:na\] at com.samskivert.mustache.Template.execute(Template.java:137) ~\[jmustache-1.15.jar:na\]
```

그래서 항상 Mustache를 사용할 때는 해당 상황에 대한 처리를 위해 아래처럼 없을 경우에 대비해주었다.

```java
{{#member}}{{member}}{{/member}}
```

- {{#변수}} - 해당 값이 존재할 경우 true로 안에 내용을 처리한다.

# 해결법

아래와 같이 값이 없을 경우에 대비한 기본 값을 지정해주면 된다.
값이 없을 경우 오류만 안 나게 해야겠다 싶어서 기본값을 ""로 주었다.

```java
@Configuration
public class MustacheConfig {
    @Bean
    public Mustache.Compiler mustacheCompiler(Mustache.TemplateLoader templateLoader, Environment environment) {
        String defaultValue = "";

        MustacheEnvironmentCollector collector = new MustacheEnvironmentCollector();
        collector.setEnvironment(environment);

        return Mustache.compiler()
                .defaultValue(defaultValue)
                .withLoader(templateLoader)
                .withCollector(collector);
    }
}
```

{% endraw %}

# 참고

[www.baeldung.com](https://www.baeldung.com/spring-boot-mustache)


스프링 부트 - Mustache 기본 값 지정하기

{% raw %}
이 콧수염 아저씨를 쓸때마다 느끼는거지만 Logic-Less라지만 너무 아무것도 없어서 불편할 때가 많다.(물론 사용 방법을 잘 몰라서 그럴 수도 있음) 검색 능력이 부족한건지 아무리 찾아봐도 머스테치에서 Validation를 사용하는 방법에 대해서는 나오지 않아서 개인적으로 연구해본 방법.

다른 좋은 방법이 있다면 리플 바람.

# DTO

```java
package application.web.dto;

import application.jpa.enums.Gender;
import application.jpa.domain.Member;
import application.jpa.enums.Role;
import lombok.*;

import javax.validation.constraints.*;

/**
 * 회원 요청을 위한 DTO
 */
@Getter
@Setter
@ToString
@NoArgsConstructor
public class MemberRequestDTO {
    @Email
    @NotBlank
    private String email;
    @NotBlank
    @Pattern(regexp="([a-zA-Z0-9].*[!,@,#,$,%,^,&,*,?,_,~])|([!,@,#,$,%,^,&,*,?,_,~].*[a-zA-Z0-9]){8,12}" ,message="숫자 영문자 특수 문자를 포함한 8 ~ 12 자를 입력하세요. ")
    private String password;
    @NotBlank
    @Pattern(regexp="([a-zA-Z0-9].*[!,@,#,$,%,^,&,*,?,_,~])|([!,@,#,$,%,^,&,*,?,_,~].*[a-zA-Z0-9]){8,12}" ,message="숫자 영문자 특수 문자를 포함한 8 ~ 12 자를 입력하세요. ")
    private String passwordChk;
    @Size(min=2, max=10)
    @NotBlank
    private String nickname;
    @NotBlank
    private String gender;

    @Builder
    public MemberRequestDTO(String email, String password, String passwordChk, String nickname, String gender){
        this.email = email;
        this.password = password;
        this.passwordChk = passwordChk;
        this.nickname = nickname;
        this.gender = gender;
    }
    //비밀번호와 확인 비밀번호가 일치하는지 확인
    public boolean isPwEqualToCheckPw(){
        return password.equals(passwordChk);
    }

    public Member toEntity(){
        return Member.builder()
                .email(this.email)
                .password(this.password)
                .nickname(this.nickname)
                .gender(Gender.valueOf(gender))
                .role(Role.USER)
                .build();
    }
}
```

# 컨트롤러

```java
package application.web;

import application.service.MemberService;
import application.web.dto.MemberRequestDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

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

/**
 * 회원 Controller
 */
@Slf4j
@RequiredArgsConstructor
@Controller
public class MemberController {
    private final MemberService memberService;

    /**
     * 회원가입 페이지 이동
     */
    @GetMapping("/member/signUp")
    public void signUp(){}

    /**
     * 회원가입 처리
     * @param dto
     * @return
     */
    @PostMapping("/member/signUp")
    public String signUp(@Validated MemberRequestDTO dto, BindingResult errors, Model model, RedirectAttributes rttr) {
        if(errors.hasErrors() || !dto.isPwEqualToCheckPw()){
            Map<String, String> errorMap = new HashMap<String, String>();
            errors.getFieldErrors().stream().forEach(fieldError -> {
                String fieldName = fieldError.getField();
                String errorMsg = fieldError.getDefaultMessage();

                errorMap.put(fieldName, errorMsg);
            });
            if(!dto.isPwEqualToCheckPw()){
                errorMap.put("passwordChk", "비밀번호가 일치하지 않습니다.");
            }
            boolean isFemale = dto.getGender().equals("F");
            model.addAttribute("member", dto);
            model.addAttribute("isFemale", isFemale);
            model.addAttribute("error", errorMap);
            return "/member/signUp";
        }

        rttr.addFlashAttribute("msg", "회원가입에 성공했습니다!");
        memberService.signUp(dto);
        return "redirect:/";
    }
}
```

- Validation 사용을 위해 MemberRequestDTO 앞에 @Validated 어노테이션을 붙여주었음.
- 그냥 타임리프로 사용할 때는 그냥 errors를 그냥 넘겨서 뷰단에서 처리가 가능했는데, 나의 무지 때문인지 머스테치로는 그 방법을 알지 못해서 약간 꼼수로 error를 Map으로 바꿔서 필드 이름을 키, 에러 메세지를 값으로 만들어서 그 Map을 "error"이라는 애트리뷰트 이름으로 넘겨줌.
- "비밀번호"와 "비밀번호 확인" 일치 여부를 확인하기 위해서 Validated를 사용해서 해결하고 싶었는데, 그런 방법이 떠오르지 않아 정말 안타깝지만 if문으로 비교해주었음. <- 이 부분은 해결했음. [포스트 보러가기](https://gunkim0318.github.io/spring/2020/07/18/Spring-Boot-Validations/)

# signUp.mustache

```html
{{>layout/header}}

<link rel="stylesheet" href="/css/member/signUp.css" />
<div
  class="col-xs-12 col-sm-12 col-md-4 col-lg-4 text-center"
  style="float:none; margin: 0 auto;"
>
  <h1>회원가입</h1>
  <form action="/member/signUp" method="post">
    <input name="_csrf" type="hidden" value="{{_csrf.token}}" />
    <span class="valid-msg"
      >{{#error.email}}{{error.email}}{{/error.email}}</span
    >
    <div class="input-group input-group-lg">
      <span class="input-group-addon" id="sizing-addon1"
        ><span class="glyphicon glyphicon-envelope"></span
      ></span>
      <input
        name="email"
        type="text"
        class="form-control"
        value="{{#member}}{{member.email}}{{/member}}"
        placeholder="메일을 입력해주세요"
      />
    </div>
    <span class="valid-msg"
      >{{#error.password}}{{error.password}}{{/error.password}}</span
    >
    <div class="input-group input-group-lg">
      <span class="input-group-addon" id="sizing-addon1"
        ><span class="glyphicon glyphicon-eye-close"></span
      ></span>
      <input
        name="password"
        type="password"
        class="form-control"
        value="{{#member}}{{member.password}}{{/member}}"
        placeholder="비밀번호를 입력해주세요"
      />
    </div>
    <span class="valid-msg"
      >{{#error.passwordChk}}{{error.passwordChk}}{{/error.passwordChk}}</span
    >
    <div class="input-group input-group-lg">
      <span class="input-group-addon" id="sizing-addon1"
        ><span class="glyphicon glyphicon-eye-close"></span
      ></span>
      <input
        name="passwordChk"
        type="password"
        class="form-control"
        value="{{#member}}{{member.passwordChk}}{{/member}}"
        placeholder="비밀번호 확인을 입력해주세요"
      />
    </div>
    <span class="valid-msg"
      >{{#error.nickname}}{{error.nickname}}{{/error.nickname}}</span
    >
    <div class="input-group input-group-lg">
      <span class="input-group-addon" id="sizing-addon1"
        ><span class="glyphicon glyphicon-user"></span
      ></span>
      <input
        name="nickname"
        type="text"
        class="form-control"
        value="{{#member}}{{member.nickname}}{{/member}}"
        placeholder="닉네임을 입력해주세요"
      />
    </div>
    <span class="valid-msg"
      >{{#error.gender}}{{error.gender}}{{/error.gender}}</span
    >
    <div>
      <label><input name="gender" type="radio" value="M" checked /> 남성</label>
      <label
        ><input name="gender" type="radio" value="F"
        {{#isFemale}}checked{{/isFemale}}> 여성</label
      >
    </div>
    <div>
      <button type="submit" id="signUpBtn" class="btn btn-primary col-lg-12">
        입력
      </button>
      <hr />
      <button id="backBtn" class="btn btn-default col-lg-12">취소</button>
    </div>
  </form>
</div>
{{>layout/footer}}

<script src="/js/member/signUp.js"></script>
```

error에 해당 메세지가 존재할 경우 출력해주고, 값 유지를 위해서도 동일하게 처리해주었음.

# 추가

## MemberController.java

```java
package application.web;

import application.service.MemberService;
import application.web.dto.MemberRequestDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

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

/**
 * 회원 Controller
 */
@Slf4j
@RequiredArgsConstructor
@Controller
public class MemberController {
    private final MemberService memberService;

    /**
     * 회원가입 페이지 이동
     */
    @GetMapping("/member/signUp")
    public void signUp(){}

    /**
     * 회원가입 처리
     * @param dto
     * @return
     */
    @PostMapping("/member/signUp")
    public String signUp(@Validated MemberRequestDTO dto, BindingResult errors, Model model, RedirectAttributes rttr) {
        if(errors.hasErrors() || !dto.isPwEqualToCheckPw()){
            Map<String, String> errorMap = new HashMap<String, String>();
            errors.getFieldErrors().stream().forEach(fieldError -> {
                String fieldName = fieldError.getField();
                String errorMsg = fieldError.getDefaultMessage();

                errorMap.put(fieldName, errorMsg);
            });
            if(!dto.isPwEqualToCheckPw()){
                errorMap.put("passwordChk", "비밀번호가 일치하지 않습니다.");
            }
            boolean isFemale = dto.getGender().equals("F");
            model.addAttribute("member", dto);
            model.addAttribute("isFemale", isFemale);
            model.addAttribute("error", errorMap);
            return "/member/signUp";
        }

        rttr.addFlashAttribute("msg", "회원가입에 성공했습니다!");
        memberService.signUp(dto);
        return "redirect:/";
    }
}
```

작성하다 보니 Errors 객체를 Map으로 변환하는 경우가 꽤 있어서 이 부분을 유틸로 바꾸어 보았음.

## ErrorsTransUtil.java

```java
package application.util;

import org.springframework.validation.Errors;

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

/**
 * Errors객체를 Map으로 변환함
 */
public class ErrorsTransUtil {
    private final Map<String, String> errorMap;

    /**
     * TODO Errors객체를 받아서 변환하는 작업
     * @param errors
     */
    public ErrorsTransUtil(Errors errors){
        Map<String, String> errorMap = new HashMap<String, String>();
        errors.getFieldErrors().stream().forEach(fieldError -> {
            String fieldName = fieldError.getField();
            String errorMsg = fieldError.getDefaultMessage();

            errorMap.put(fieldName, errorMsg);
        });
        this.errorMap = errorMap;
    }

    /**
     * 커스텀 에러 메시지 추가
     * @param fieldName
     * @param errorMsg
     */
    public void addCustomErrorMsg(String fieldName, String errorMsg){
        this.errorMap.put(fieldName, errorMsg);
    }
    /**
     * 생성자를 통해 변환된 Map을 반환함.
     * @return
     */
    public Map<String, String> getMap(){
        return this.errorMap;
    }
}
```

생성자를 통해 받아서 변환하고, getter를 통해 해당 Map을 반환하는 형태로 작성하였음.

변환하는 부분에 대해서 좀 더 깔끔한 방법이 있었던 것 같은데 일단 스탠타드하게 작성해보았다.

## MemberController.java

```java
package application.web;

import application.service.MemberService;
import application.util.ErrorsTransUtil;
import application.web.dto.MemberRequestDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

/**
 * 회원 Controller
 */
@Slf4j
@RequiredArgsConstructor
@Controller
public class MemberController {
    private final MemberService memberService;
    /**
     * 회원가입 페이지 이동
     */
    @GetMapping("/member/signUp")
    public void signUp(){}

    /**
     * 회원가입 처리
     * @param dto
     * @return
     */
    @PostMapping("/member/signUp")
    public String signUp(@Validated MemberRequestDTO dto, BindingResult errors, Model model, RedirectAttributes rttr) {
        if(errors.hasErrors() || !dto.isPwEqualToCheckPw()){
            ErrorsTransUtil errorUtil = new ErrorsTransUtil(errors);
            if(!dto.isPwEqualToCheckPw()){
                errorUtil.addCustomErrorMsg("passwordChk", "비밀번호가 일치하지 않습니다.");
            }
            boolean isFemale = dto.getGender().equals("F");
            model.addAttribute("member", dto);
            model.addAttribute("isFemale", isFemale);
            model.addAttribute("errors", errorUtil.getMap());
            return "/member/signUp";
        }
        rttr.addFlashAttribute("msg", "회원가입에 성공했습니다!");
        memberService.signUp(dto);
        return "redirect:/";
    }
    /**
     * 로그인 페이지 이동
     */
    @GetMapping("/member/signIn")
    public void signIn(){}
}
```

Map으로 변환하는 소스가 줄어들면서 그나마 보기 좋아졌다. 이제 Validation는 문제 없을 것 같다.
{% endraw %}

스프링 부트 Mustache에서 유효성 검사하기(Validation)


ajax를 통해 비동기 처리를 했을 때 200 상태코드를 반환하는데도 success 함수가 무슨 짓을 해도 호출이 되지 않아서 삽질한 내용에 대한 해결 방법.

# 문제

```js
$.ajax({
  url: "/reply/api/",
  type: "POST",
  contentType: "application/json",
  data: JSON.stringify({
    postsId: postsId,
    content: replyContent,
  }),
  dataType: "json",
  success: function () {
    alert("댓글 입력");
  },
});
```

# 해결 방법

```js
$.ajax({
  url: "/reply/api/",
  type: "POST",
  contentType: "application/json",
  data: JSON.stringify({
    postsId: postsId,
    content: replyContent,
  }),
  success: function () {
    alert("댓글 입력");
  },
});
```

> dataType: 'json' 을 삭제해주면 된다.

일단 이렇게 해결은 했으나 원인은 서버에서 넘어오는 데이터가 json형식이 아닌게 아닌가 추측중이다


ajax 200 성공 반환하는데 success 호출 안되는 문제


스프링에서는 유효성 검증을 위한 Validation기능을 제공해주고 있다. 그래서 Validation기능 사용하는 방법에 대해서 포스팅해보려고 한다.

# Bean Validation(Hibernate)

Bean Validation이라는 이름으로 Java에서 유효성(Validation) 데이터 검증을 위한 메타데이터로 사용하는 방법을 제시하고 있다.(Bean Validation 2.0 JSR-380까지 나와있음)

이 글에서 이것에 대한 구현체인 Hibernate Validator를 사용한 유효성 검증해보는 방법을 정리해보려고 한다. [예제 프로젝트](https://github.com/gunkim0318/springboot-validated)

# 유효성 검증 어노테이션 정리

| 어노테이션                      | 설명                                                                         |
| ------------------------------- | ---------------------------------------------------------------------------- |
| @Null                           | null인지 확인                                                                |
| @NotNull                        | null이 아닌지 확인                                                           |
| @NotEmpty                       | null, 공백이 아닌지 확인                                                     |
| @NotBlank                       | null, 공백, trim된 문자열 길이가 0이 아닌지 확인                             |
| @Email                          | 이메일 형식인지 확인                                                         |
| @AssertTrue                     | 참인지 검사                                                                  |
| @AssertFalse                    | 거짓인지 검사                                                                |
| @Size(min=, max=)               | 크기가 min, max 사이에 있는지 확인                                           |
| @Future                         | 미래 날짜인지 확인                                                           |
| @Past                           | 과거날짜인지 확인                                                            |
| @FutureOrPresent                | 현재 또는 미래 날짜인지 확인                                                 |
| @PastOrPresent                  | 과거 또는 현재인지 확인                                                      |
| @Positive                       | 양수인지 확인                                                                |
| @Negative                       | 음수인지 확인                                                                |
| @PositiveOrZero                 | 양수이거나 0인지 확인                                                        |
| @NegativeOrZero                 | 음수이거나 0인지 확인                                                        |
| @Max(value=)                    | 지정된 최대값 이하인지 확인                                                  |
| @Min(value=)                    | 지정된 최소값 이상인지 확인                                                  |
| @Pattern(regex=, flags=)        | 주어진 플래그 매치를 고려하여 값이 정규식 regex와 일치하는지 검사            |
| @Digits(integer=, fraction=)    | 값이 integer와 fraction에 의해 지정된 자리수의 숫자인지 확인                 |
| @DecimalMax(value=, inclusive=) | inclusive가 true이면 value 이하인지 확인, false이면 value보다 미만인지 확인  |
| @DecimalMin(value=, inclusive=) | inclusive가 true이면 value 초과인지 확인, false일 때 value보다 이상인지 확인 |
| @URL                            | URL형식인지 확인                                                             |

# 한번 직접 사용해보기

## build.gradle

```java
buildscript {
    ext {
        springBootVersion = '2.2.4.RELEASE'
    }
    repositories {
        mavenCentral()
        jcenter()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

group = 'com.gun'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
    mavenCentral()
    jcenter()
}

dependencies {
    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
    implementation group:'org.springframework.boot', name: 'spring-boot-starter-validation'
    implementation group:'org.springframework.boot', name: 'spring-boot-starter-web'
    compileOnly group:'org.projectlombok', name: 'lombok'
    annotationProcessor group:'org.projectlombok', name: 'lombok'
    testImplementation group:'org.springframework.boot', name: 'spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

```

validation 어노테이션을 사용하기 위해 spring-boot-starter-validation 의존성을 주입해주었음.

만약, JPA를 사용할 경우 JPA 의존성에 포함이 되어 있기 때문에 해당 의존성을 주입하지 않아도 됨.

### Member.java

```java
package com.gun.app.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.hibernate.validator.constraints.URL;

import javax.validation.constraints.*;

@Getter
@Setter
@ToString
public class Member {
    @NotBlank
    private String userId;
    private String password;
    @NotBlank
    @Size(max=3)
    private String userName;
    @Email
    @NotEmpty
    private String email;
    private String gender;
}
```

### MemberController.java

```java
package com.gun.app.web;

import com.gun.app.domain.Member;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class MemberController {
    @GetMapping("/registerForm")
    public void registerForm(Model model){
        model.addAttribute("member", new Member());
    }
    @PostMapping("/register")
    public String register(@Validated Member member, BindingResult result, Model model){
        if(result.hasErrors()){
            return "registerForm";
        }
        return "success";
    }
}
```

@Validated는 유효성 검증을 하기 위해 사용했음.

BindingResult는 Errors를 상속하는 객체로 유효성 검증 결과를 담고 있음.

### registerForm.html

```html
<!DOCTYPE html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
  <head>
    <meta charset="UTF-8" />
    <title>회원가입</title>
  </head>
  <body>
    <h1>회원가입</h1>
    <form th:action="@{/register}" th:object="${member}" method="POST">
      <table>
        <tr>
          <td>ID</td>
          <td>
            <input type="text" th:field="*{userId}" />
            <font color="red">
              <span
                th:if="${#fields.hasErrors('userId')}"
                th:errors="*{userId}"
              ></span>
            </font>
          </td>
        </tr>
        <tr>
          <td>비밀번호</td>
          <td>
            <input type="password" th:field="*{password}" />
            <font color="red">
              <span
                th:if="${#fields.hasErrors('password')}"
                th:errors="*{password}"
              ></span>
            </font>
          </td>
        </tr>
        <tr>
          <td>이름</td>
          <td>
            <input type="text" name="userName" th:field="*{userName}" />
            <font color="red">
              <span
                th:if="${#fields.hasErrors('userName')}"
                th:errors="*{userName}"
              ></span>
            </font>
          </td>
        </tr>
        <tr>
          <td>email</td>
          <td>
            <input type="text" name="email" th:field="*{email}" />
            <font color="red">
              <span
                th:if="${#fields.hasErrors('email')}"
                th:errors="*{email}"
              ></span>
            </font>
          </td>
        </tr>
        <tr>
          <td>성별</td>
          <td>
            <input type="radio" id="Male" th:field="*{gender}" value="M" />
            <label for="Male">남자</label>
            <br />
            <input type="radio" id="Female" th:field="*{gender}" value="F" />
            <label for="Female">여자</label>
          </td>
        </tr>
      </table>

      <button type="submit">등록</button>
    </form>
  </body>
</html>
```

## success.html

```html
<!DOCTYPE html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
  <head>
    <meta charset="UTF-8" />
    <title>성공</title>
  </head>
  <body>
    <h1>회원 정보 입력 성공!</h1>
  </body>
</html>
```

## 결과

![image](https://user-images.githubusercontent.com/45007556/91046950-435c8680-e654-11ea-8669-f74bb7091e3b.png)
![image](https://user-images.githubusercontent.com/45007556/91046978-4eafb200-e654-11ea-8e38-87ee967e9654.png)

# 메시지 커스텀하기

## member.java

```
package com.gun.app.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.hibernate.validator.constraints.URL;

import javax.validation.constraints.*;

@Getter
@Setter
@ToString
public class Member {
    @NotBlank(message = "아이디를 입력해주시기 바랍니다.")
    private String userId;
    private String password;
    @NotBlank(message = "이름을 입력해주시기 바랍니다.")
    @Size(max=3, message = "이름은 세글자까지 허용됩니다.")
    private String userName;
    @Email(message = "이메일 주소를 입력해 주셔야 합니다.")
    @NotEmpty(message = "이메일을 입력해주시기 바랍니다.")
    private String email;
    private String gender;
}
```

## 확인

![image](https://user-images.githubusercontent.com/45007556/91046865-21630400-e654-11ea-93c7-d767a8de959d.png)
![image](https://user-images.githubusercontent.com/45007556/91046886-2b850280-e654-11ea-90a0-d8791b80e12b.png)


스프링 부트 유효성(Validation) 검증하기


개발이나 테스트할 때 앱 실행 시 초기 데이터가 필요하거나 실행해야 하는 코드가 있는 경우가 있다.
그럴 때 CommandLineRunner로 가능하다. CommandLineRunner를 사용하는 방법 중 Bean을 이용한 방법으로 작성해보려 한다.

# Bean을 이용한 방법

```java
package application;

import application.jpa.domain.Member;
import application.jpa.domain.Posts;
import application.jpa.enums.Gender;
import application.jpa.enums.Role;
import application.jpa.repository.MemberRepository;
import application.jpa.repository.PostsRepository;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

import java.sql.SQLException;
import java.util.stream.IntStream;

@EnableJpaAuditing
@SpringBootApplication
public class Application {
    public static void main(String[] args){
        SpringApplication.run(Application.class, args);
    }
    @Bean
    public CommandLineRunner runner(MemberRepository memberRepository, PostsRepository postsRepository) throws SQLException {
        return (args) -> {
            Member userMember = memberRepository.save(Member.builder()
                    .email("gunkim@gmail.com")
                    .password("test")
                    .nickname("gun")
                    .gender(Gender.F)
                    .role(Role.USER)
                    .build());

            IntStream.rangeClosed(1, 200).forEach(i -> {
                  postsRepository.save(Posts.builder()
                  .title(i+"번째 게시글입니다")
                  .content("게시글 내용입니다."+i)
                  .member(userMember)
                  .hit(0l)
                  .build());
            });
        };
    }
}

```

위의 코드처럼 CommandLineRunner를 리턴하는 빈을 등록해주면 되고, 빈으로 등록되어 있는 객체들을 파라미터로 받을 수 있다. 또한 CommandLineRunner는 여러개를 구현할 수 있다.


스프링 부트 실행 시 특정 코드 실행하기(테스트 데이터 넣기)

![image](https://user-images.githubusercontent.com/45007556/91046271-122f8680-e653-11ea-8474-59cfaed336aa.png)
스프링 부트에서는 에러가 발생 시 톰캣 에러 페이지가 아니라 해당 화면과 같이 **화이트라벨**이라고 불리는 화면을 통해 에러 화면이 나온다. 그래서 이 화면을 커스텀하는 방법에 대해서 정리해보려고 한다.

# 화이트라벨 페이지 비활성화(꼭 안해도 됨)

## application.yml에 추가

```
server:
  error:
    whitelabel:
      enabled: false
```

## 확인

![image](https://user-images.githubusercontent.com/45007556/91046288-1b205800-e653-11ea-9093-159f2549b87d.png)

설정을 완료하게 되면 이렇게 톰캣 에러 페이지가 나온다.

# 공통 에러 페이지 커스텀

```java
package application.web;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * 공통 에러 페이지 표출을 위한 Controller
 */
@Controller
@Slf4j
public class CustomErrorController implements ErrorController {
    private static final String ERROR_PATH = "/error";

    @RequestMapping("/error")
    public String handleError(HttpServletRequest request, Model model) {
        Object status = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
        HttpStatus httpStatus = HttpStatus.valueOf(Integer.valueOf(status.toString()));

        model.addAttribute("code", status.toString());
        model.addAttribute("msg", httpStatus.getReasonPhrase());
        model.addAttribute("timestamp", new Date());
        return ERROR_PATH+"/error";
    }

    @Override
    public String getErrorPath() {
        return ERROR_PATH;
    }
}
```

> **getErrorPath **에서 리턴하는 문자열에 매핑된 URL이 error 페이지가 된다.

이렇게 ErrorController를 상속하여 구현해주면 된다.

# 공통 에러 페이지 준비

{% raw %}

```html
{{>layout/header}}

<div style="width: 80%;" class="uk-margin-auto">
  <h1>에러 페이지</h1>
  에러코드 : <span>{{code}}</span><br />
  에러메시지 : <span>{{msg}}</span><br />
  시간 : <span>{{timestamp}}</span>
</div>
{{>layout/footer}}
```

{% endraw %}

나는 머스테치를 사용하기 때문에 이렇게 구성했다.

# 결과

![image](https://user-images.githubusercontent.com/45007556/91046409-53279b00-e653-11ea-9918-a1ee4e4d7f6f.png)

# 에러 코드별 페이지 다르게 하기

```java
package application.web;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * 공통 에러 페이지 표출을 위한 Controller
 */
@Controller
@Slf4j
public class CustomErrorController implements ErrorController {
    private static final String ERROR_PATH = "/error";

    @RequestMapping("/error")
    public String handleError(HttpServletRequest request, Model model) {
        Object status = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);

        if (status != null) {
            Integer statusCode = Integer.valueOf(status.toString());

            if (statusCode == HttpStatus.NOT_FOUND.value()) {
                return ERROR_PATH+"/error-404";
            } else if (statusCode == HttpStatus.INTERNAL_SERVER_ERROR.value()) {
                return ERROR_PATH+"/error-500";
            }
        }
        return ERROR_PATH+"/error";
    }

    @Override
    public String getErrorPath() {
        return ERROR_PATH;
    }
}
```

# 참고

[StackOverFlow](https://www.baeldung.com/spring-boot-custom-error-page)

스프링 부트 에러 페이지 적용하기


일반적으로 스프링 시큐리티를 사용할 때 간단하게 커스텀해서 사용하는 방법에 대해서 포스팅하려고 한다.

# 스프링 시큐리티 흐름

![image](https://user-images.githubusercontent.com/45007556/91045190-76e9e180-e651-11ea-9bea-7a4aa69564c8.png)

# 스프링 시큐리티 커스터마이징

보통 커스터마이징을 할 때 AuthenticationProvider나 UserDetailsService를 커스터마이징하게 된다.

- **UserDetails** - 유저 vo라고 보면 됨(만약 memberVO와 같이 별도로 사용하는 vo가 있을 경우 변환해주는 작업이 필요함)
- **UserDetailsService** - 유저 정보를 가져옴
- **AuthenticationProvider** - Service에서 가져온 유저 정보를 가지고 로그인한 비밀번호와 가져온 유저 정보의 비밀번호가 일치하는 지 확인.

해당 부분 중 내가 커스터마이징한 부분은 UserDetailsService. 이 포스트에서는 위에서 말한대로 원래 사용하던 Member 객체를 UserDetails 객체로 변환하는 내용을 UserDetailsService을 작성하여 시큐리티를 적용하는 방법에 대해 작성하려고 한다.

# 스프링 시큐리티를 의존성 주입하기

## gradle:

```java
implementation group: 'org.springframework.boot', name: 'spring-boot-starter-security'
```

## maven:

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>
```

# 비밀번호 암호화를 위한 PasswordEncoder 빈 설정

```java
package application.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class WebMvcConfig {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
}
```

**PasswordEncoder** 인터페이스는 여러개의 구현체가 있는데, PasswordEncoderFactories.createDelegatingPasswordEncoder() 를 통해 생성한 구현체는 기본적으로 **BCryptPasswordEncoder**을 사용하게 된다.

앞에 "BCrypt"는 암호화 방식이며, 다른 암호화 방식을 사용하고 싶다면 자유롭게 바꿔줄 수 있다.

주요 메소드

- **PasswordEncoder.encode(CharSequence rawPassword) -** 해당 메소드에 암호화할 패스워드를 넘겨주게 되면 암호화된 비밀번호를 생성하여 준다.

- **PasswordEncoder.matches(CharSequence rawPassword, String encodedPassword\*\***)\*\* - 암호화되지 않은 비밀번호, 암호화된 비밀번호 를 넘겨주면 둘이 일치하는 지를 boolean으로 반환해줌.

> encode 메소드를 통해 비밀번호를 암호화를 하게 되면 아래와 같이 암호화가 되는데,  
> 앞에 {} 안에 어떤 암호화 방식을 통하여 암호화를 하였는 지를 담고있다.  
> {bcrypt}$2a$10\$g1PWM7YhvhhA3PUtnSh.mOZVQFQe7fTO0C2na2Xpbrit.bwYlQdPe

**PasswordEncoder**를 사용했을 때의 장점은 [스프링 공식 홈페이지](https://docs.spring.io/spring-security/site/docs/5.1.1.RELEASE/reference/htmlsingle/#pe-dpe)에서는 이렇게 설명하고 있다.

- 현재 비밀번호 저장 권장 사항을 사용하여 비밀번호가 인코딩되도록 보장
- 최신 및 레거시 형식의 비밀번호 유효성 검사 허용
- 향후 인코딩 업그레이드 허용

# 준비

```java
package application.domain;

import lombok.*;

import javax.persistence.*;

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString
@Getter
@Entity
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 30, unique = true)
    private String email;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false, length = 20)
    private String nickname;

    @Column(nullable = false)
    @Enumerated(EnumType.STRING)
    private Gender gender;

    @Column(nullable = false)
    @Enumerated(EnumType.STRING)
    private Role role;

    @Builder
    public Member(Long id, String email, String password, String nickname, Gender gender, Role role){
        this.id = id;
        this.email = email;
        this.password = password;
        this.nickname = nickname;
        this.gender = gender;
        this.role = role;
    }
}
```

```java
package application.domain;

import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public enum Gender {
    M("남성"),
    F("여성");

    private String title;
}

```

```java
package application.domain;

import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public enum Role {
    ADMIN("관리자", "ROLE_ADMIN"),
    USER("사용자", "ROLE_USER");

    private String title;
    private String value;
}
```

```java
package application.domain;

import org.springframework.data.jpa.repository.JpaRepository;

public interface MemberRepository extends JpaRepository<Member, Long> {
    Member findByEmail(String email);
}
```

```java
package application.dto;

import application.domain.Gender;
import application.domain.Member;
import application.domain.Role;
import lombok.*;

@Getter
@Setter
@ToString
@NoArgsConstructor
public class MemberRequestDTO {
    private String email;
    private String password;
    private String nickname;
    private String gender;

    @Builder
    public MemberRequestDTO(String email, String password, String nickname, String gender){
        this.email = email;
        this.password = password;
        this.nickname = nickname;
        this.gender = gender;
    }
    public Member toEntity(){
        return Member.builder()
                .email(this.email)
                .password(this.password)
                .nickname(this.nickname)
                .gender(Gender.valueOf(gender))
                .role(Role.USER)
                .build();
    }
}
```

# UserDetailsService 커스터마이징

```java
package application.config;

import application.domain.Member;
import application.domain.MemberRepository;
import application.dto.MemberRequestDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import sun.security.util.Password;

import java.util.ArrayList;
import java.util.Collection;

@Service
@Slf4j
@RequiredArgsConstructor
public class CustomUserDetailService implements UserDetailsService {
    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;
    @Override
    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
        Member member = memberRepository.findByEmail(email);

        if(member == null){
            throw new UsernameNotFoundException("해당 "+email+"(email)의 유저가 없습니다.");
        }

        Collection<SimpleGrantedAuthority> roles = new ArrayList<SimpleGrantedAuthority>();

        roles.add(new SimpleGrantedAuthority(member.getRole().getValue()));

        return new User(email, member.getPassword(), roles);
    }
    public void signUp(MemberRequestDTO dto){
        dto.setPassword(passwordEncoder.encode(dto.getPassword()));
        memberRepository.save(dto.toEntity());
    }
}
```

encode메소드는 같은 문자열이라도 실행할 때마다 암호화된 패스워드 값이 달라지므로 패스워드가 같은 지를 확인해야 할 경우 equals가 아닌 matches메소드를 사용하면 됨.

**UserDetailsService**는 유저 정보를 반환하는 역할을 하는데, 여기를 커스터마이징 해서 **Member**를 **User**로 변환할 수 있도록 해주었다.

# 스프링 시큐리티 설정해주기

```java
package application.config;

import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.header.writers.frameoptions.WhiteListedAllowFromStrategy;
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import java.util.Arrays;

@RequiredArgsConstructor
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    private final CustomUserDetailService customUserDetailService;

    private final PasswordEncoder passwordEncoder;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                // 페이지 권한 설정
                .antMatchers("/api/**").hasRole("USER")
                .antMatchers("/post/add").hasRole("USER")
                .antMatchers("/post/modify").hasRole("USER")
                .antMatchers("/").permitAll()
                .antMatchers("/member/signUp").permitAll()
                .and()//로그인 설정
                    .formLogin()
                    .loginPage("/member/signIn")
                    .loginProcessingUrl("/member/signIn")
                    .usernameParameter("email")
                    .defaultSuccessUrl("/")
                    .permitAll()
                .and()//로그아웃 설정
                    .logout()
                    .logoutRequestMatcher(new AntPathRequestMatcher("/member/logout"))
                    .logoutSuccessUrl("/")
                    .invalidateHttpSession(true);
    }
    @Override
    public void configure(WebSecurity web) throws Exception
    {
        // static 디렉터리의 하위 파일 목록은 인증 무시 ( = 항상통과 )
        web.ignoring().antMatchers("/css/**", "/js/**", "/img/**", "/lib/**");
    }
    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(customUserDetailService).passwordEncoder(passwordEncoder);
    }
}
```

configure(HttpSecurity http) 간단 설명

- **antMatchers("/post/add").hasRole("USER")** - ROLE_USER만 /post/add 접근 가능
- **antMatchers("/").permitAll()** - 모두 / 에 접근 가능
- **loginPage("/member/signIn")** - 커스텀할 로그인 페이지, 설정 안하면 기본으로 제공하는 로그인 페이지가 나옴
- **usernameParameter("email")** - 기본적으로 form에 아이디를 의미하는 파라미터 이름은 username이 기본인데, email을 아이디로 사용하고 싶어서 email을 username으로 인식할 수 있도록 설정
- **loginProcessingUrl("/member/signIn")** - 로그인 처리할 URL
- **defaultSuccessUrl("/")** - 로그인이 성공할 경우 이동할 페이지
- **logoutRequestMatcher(new AntPathRequestMatcher("/member/logout"))** - 로그아웃을 실행할 주소. /member/logout 을 호출 시 로그아웃이 된다

주요하게 볼 내용은 configure(AuthenticationManagerBuilder auth) 메소드를 오버라이드해서  
기본적인 **UserDetailService**가 아닌 커스터마이징한 **UserDetailService**와 **passwordEncoder**를 사용할 수 있도록 주입해주었다.

# 설정 완료

해당 포스트에서는 로그인 URL을 "/member/signIn"으로 설정하였기 때문에 해당 URL에 로그인 페이지를 만들어서 email, password 파라미터를 loginProcessingUrl에서 설정한 "/member/signIn" 에 POST로 넘겨주게 되면 로그인 처리가 될 것이다.


스프링 부트 - 스프링 시큐리티 간단 커스텀


스프링 시큐리티는 form 전송 시 csrf 토큰을 함께 전송해주어야 하는데, 타임리프나 다른 템플릿 엔진 같은 경우는 지원해주는 데 비해 로직 less인 머스테치의 경우는 지원해주지 않아 찾아본 방법

# 방법1. 컨트롤러에서 CsrfToken을 발급하여 model로 전달 

```java
@GetMapping("/signIn")
public String signIn(CsrfToken csrfToken, Model model) {
    model.addAttribute("_csrf", csrfToken);
    //...
}
```

---

# 다른 방법. 인터셉터를 통한 방법

위에 컨트롤러를 통해 하는 방법은 매번 저렇게 해줘야 하는 번거롭기 때문에 인터셉터를 통해서도 처리가 가능하다.

# 인터셉터 작성

```java
public class CsrfTokenInterceptor implements HandlerInterceptor {
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        if (modelAndView != null) {
            CsrfToken csrfToken = (CsrfToken) request.getAttribute("_csrf");
            modelAndView.addObject("_csrf", csrfToken);
        }
    }
}
```

컨트롤러 호출 후에 해당 메소드가 실행되어서 model에 등록해준다.

# 빈 등록

```java
@Configuration
public class Config {
    @Bean
    public CsrfTokenInterceptor csrfTokenInterceptor() {
        return new CsrfTokenInterceptor();
    }
}
```

# 인터셉터 등록

```java
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Autowired
    CsrfTokenInterceptor csrfTokenInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(csrfTokenInterceptor);
    }
}
```

---

# 화면에서의 처리

```html
<input name="_csrf" type="hidden" value="{{_csrf.token}}" />
```

화면단에서는 위와 같이 태그를 삽입해주면 된다.

# 참고

[StackOverFlow](https://stackoverflow.com/questions/26397168/how-to-use-spring-security-with-mustache)


스프링 부트 머스테치 - 시큐리티 form 전송 시 403 에러 해결법


# 문제

프로젝트 생성 과정에서 원인을 알 수 없는 에러. 아래는 에러 내용.

```
Multiple markers at this line
org.apache.log4j cannot be resolved to a type
org.apache.log4j.Logger cannot be resolved to a type
```

![image](https://user-images.githubusercontent.com/45007556/91044098-b31c4280-e64f-11ea-9d85-4c4c7366a3a9.png)

# 해결 방법

pom.xml 내에 log4j에 대한 해당 의존성을 변경해주게 되면 해결된다.

## **_변경 전_**

```xml
<dependency>
	<groupId>log4j</groupId>
	<artifactId>log4j</artifactId>
	<version>1.2.16</version>
	<exclusions>
		<exclusion>
			<groupId>javax.mail</groupId>
			<artifactId>mail</artifactId>
		</exclusion>
		<exclusion>
			<groupId>javax.jms</groupId>
			<artifactId>jms</artifactId>
		</exclusion>
		<exclusion>
			<groupId>com.sun.jdmk</groupId>
			<artifactId>jmxtools</artifactId>
		</exclusion>
		<exclusion>
			<groupId>com.sun.jmx</groupId>
			<artifactId>jmxri</artifactId>
		</exclusion>
	</exclusions>
	<scope>runtime</scope>
</dependency>
```

## _**변경 후**_

```xml
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
```


스프링 메이븐에서 @Log4j 사용 시 오류


스프링을 그 동안 xml위주로 설정하다가 스프링 부트처럼 java기반으로 설정하는 방법에 대해서 포스팅해보려고 한다.

# 설정을 자바로 하게 되면 좋은 점

클래스 기반이기 때문에 알아보기 편해서 가독성이 좋고, 자동완성이 되고, 디버깅하기 좋다는 장점이 있다.

# 설정 방법

## 필요없는 설정 파일을 삭제한다.

web.xml, servlet-context.xml, root-context.xml 설정을 자바로 대체할 것이기 때문에 이 세가지 파일을 삭제한다.

## pom.xml 수정

### 서블릿 api 의존성을 3.0 이상으로 변경한다.

```xml
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.0.1</version>
  <scope>provided</scope>
</dependency>
```

### 플러그인을 추가한다(xml을 사용하지 않겠다 설정)

```xml
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-war-plugin</artifactId>
  <version>2.3</version>
  <configuration>
    <failOnMissingWebXml>false</failOnMissingWebXml>
  </configuration>
</plugin>
```

## 클래스 생성

```java
package com.gun.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class WebConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
	@Override
	protected Class<?>[] getRootConfigClasses() {
		// TODO Auto-generated method stub
		return new Class[] {RootConfig.class};
	}

	@Override
	protected Class<?>[] getServletConfigClasses() {
		// TODO Auto-generated method stub
		return new Class[] {ServletConfig.class};
	}

	@Override
	protected String[] getServletMappings() {
		// TODO Auto-generated method stub
		return new String[] { "/" };
	}
}
```

```java
package com.gun.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

@EnableWebMvc
public class ServletConfig implements WebMvcConfigurer{
	@Override
	public void configureViewResolvers(ViewResolverRegistry registry) {
		InternalResourceViewResolver bean = new InternalResourceViewResolver();
		bean.setViewClass(JstlView.class);
		bean.setPrefix("/WEB-INF/views/");
		bean.setSuffix(".jsp");
		registry.viewResolver(bean);
	}

	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
		registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
	}
}
```

```java
package com.gun.config;

import org.springframework.context.annotation.Configuration;

@Configuration
public class RootConfig {

}
```


스프링을 자바로 설정하기


커넥션풀은 커넥션을 미리 만들어놨다가, 가져다 쓰기 위해 사용하는 녀석이다. 커넥션 풀 사용하는 방법에 대해서 포스팅하려고 한다.

# 커넥션 풀이란?

커넥션을 미리 만들어놨다가 필요할 때 저장해놨던 pool에서 꺼내서 쓰고, 다시 반납하는 기법을 말한다. 미리 만들어놨다가 사용하기 때문에 매번 사용자가 요청할 때마다 커넥션을 만들지 않아도 돼서 DB의 부하를 줄일 수 있다.

# 그럼 HikariCP란?

커넥션 풀 중에서 가장 유명하고 널리 쓰이며 가볍고, 빠르고, 신뢰성이 높다고 한다. 자세한 내용은 [여기](https://github.com/brettwooldridge/HikariCP)

# 설정 방법

## 의존성 주입

### maven

```xml
<dependency>
  <groupId>com.zaxxer</groupId>
  <artifactId>HikariCP</artifactId>
  <version>3.4.1</version>
</dependency>
```

### gradle

```java
compile group: 'com.zaxxer', name: 'HikariCP', version: '3.4.1'
```

maven과 gradle은 해당 의존성을 추가해주면 된다. 최신 버전은 [여기](https://mvnrepository.com/artifact/com.zaxxer/HikariCP)서 확인.

## 설정

### xml 설정 시

```xml
<bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig">
  <property name="driverClassName" value="jdbc설정"/>
  <property name="jdbcUrl" value="db주소"/>
  <property name="username" valu="아이디"/>
  <property name="password" value="비밀번호"/>
</bean>
<bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
    <constructor-arg ref="hikariConfig"/>
</bean>
```

### java 설정 시

```java
@Bean
public DataSource dataSource(){
  HikariConfig config = new HikariConfig();
  config.setDriverClassName("jdbc설정");
  config.setJdbcUrl("db주소");
  config.setUsername("아이디");
  config.setPassword("비밀번호");

  HikariDataSource dataSource = new HikariDataSource(config);

  return dataSource;
}
```


스프링 HikariCP를 이용한 커넥션 풀 사용하기


# 문제

```
error: cannot find symbol
        log.info("Test");
        ^
symbol:   variable log
location: class HomeController

```

# 해결 방법

## Annotation Processors > Enable annotation processing 체크

![image](https://user-images.githubusercontent.com/45007556/91044839-e7443300-e650-11ea-8fab-4558843075ed.png)

## 의존성 주입

```java
annotationProcessor("org.projectlombok:lombok")
compileOnly("org.projectlombok:lombok")
```

어노테이션의 전처리가 가능하도록 설정을 해주어야 한다고 한다.[참고](https://stackoverflow.com/questions/52547965/gradle-build-fails-from-terminal-for-lombok-annotation-in-spring-boot-applicatio)

그러기 위해 annotationProcessor를 선언하여 스캔 처리를 할 수 있도록 추가해주었다.
