{"componentChunkName":"component---src-pages-search-jsx","path":"/search/","result":{"data":{"allMarkdownRemark":{"nodes":[{"excerpt":"🧷 이상(Anomaly) 이상은 테이블 설계 시 잘못된 설계로 인해 데이터를 삽입, 삭제, 수정할 때 논리적으로 생기는 오류를 말한다. 🪚 삽입 이상 튜플 삽입 시, 특정 속성에 해당하는 값이 없어 NULL을 입력해야 하는 이상이다. 이는 엔티티 무결성 제약조건을 위반할 수 있다. 🪚 삭제 이상 튜플 삭제 시, 같이 저장된 다른 정보까지 연쇄적으로 삭제되…","fields":{"slug":"/[DB]Normalization/"},"frontmatter":{"date":"August 21, 2022","title":"🛢 Normalization","tags":["DB","Normalization"]},"rawMarkdownBody":"\n## 🧷 이상(Anomaly)\n**이상**은 테이블 설계 시 잘못된 설계로 인해 데이터를 삽입, 삭제, 수정할 때 논리적으로 생기는 오류를 말한다.\n\n### 🪚 삽입 이상\n튜플 삽입 시, 특정 속성에 해당하는 값이 없어 NULL을 입력해야 하는 이상이다.\n\n이는 **엔티티 무결성 제약조건을 위반**할 수 있다.\n\n### 🪚 삭제 이상\n튜플 삭제 시, 같이 저장된 다른 정보까지 연쇄적으로 삭제되는 이상이다.\n\n이는 2개의 다른 정보들이 함께 저장되어 발생하는 문제이다. 이를 분리하여 관리한다면, 해결할 수 있을 것이다.\n\n### 🪚 수정 이상\n중복된 데이터 중 일부만 수정되어 데이터 모순이 발생하는 이상으로, 갱신 이상이라고도 불린다.\n\n데이터의 일관성 유지를 위해 모든 중복된 값을 갱신하지 않는다면 발생할 것이다.\n\n---\n\n## 🧷 함수 종속성(Functional Dependency)\nDB의 attributes sets간의 제약조건과 특성을 나타내는 것으로, **어떤 속성 A의 값을 알면, 다른 속성 B의 값이 유일하게 정해지는 관계**를 종속성이 있다고 한다.\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/998028335A2A344318\" width=\"80%\">\n\n- 위 표에서, 학생번호와 학생이름은 의존성이 존재한다. 학생 번호를 알면, 학생 이름을 유일하게 알 수 있기 때문이다. ({학생 번호} -> {학생 이름})\n- 또한, 특정 속성의 집합이 특정 속성을 유일하게 식별할 수도 있다. (ex. {학생 번호, 학생 이름} -> {학과})\n\n그리고 이러한 **FD 제약조건은 모든 relation instance에서 지켜져야 한다.**\n- K라는 속성이 Relation R의 Key라면, K는 R의 모든 속성을 유일하게 식별해야 한다.\n- X -> Y 라고 해도, 반드시 Y -> X인 것은 아니다.\n\n---\n\n## 🧷 정규화(Normalization)\n이상현상이 발생하는 relation을 분해하여 더 작은 relation으로 만들어 **이상현상을 없애고**, **중복을 최소화**하기 위한 과정을 의미한다.\n\n> 이에 반대되는 개념으로 비정규화(Denormalization)가 있다.\n> - 때로는 성능상의 이유로, 작은 정규형에 있는 relation을 base relation으로 사용하기도 한다.\n> - 정규화가 무조건으로 좋은 것은 아니라는 보여준다.\n\n### 🪚 Normal Form\ndegree를 사용해 정규화의 정도를 나타낼 수 있는데, 이를 정규형이라 한다.\n\n정규형의 레벨은 다음과 같다.\n- 1NF\n- 2NF\n- 3NF\n- Boyce-Codd NF(BCNF)\n\n정규형의 레벨은 증가할수록, 정규화의 정도가 엄격해진다. \n- 그리고 이는 성능과 타협하여 조절한다.\n\n### 🪚 First Normal Form(1NF)\n가장 flat한 relational model이다. 모든 속성 값이 원자값(더이상 나눠지지 않는 값)을 갖는 경우이다.\n\n해당 정규형에서 허용하지 않는 것은 다음과 같다.\n- Composite Attributes\n- Multi-valued Attributes\n- Nested relations\n  - 각 튜플의 속성값이 non-atomic(분해 가능)한 경우\n  - Relations 안의 relations\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/99217D335A2A472147\" width=\"80%\">\n\n### 🪚 Second Normal Form(2NF)\n2NF에 대해 배우기 전에 아래 개념을 먼저 다루고 넘어가도록 한다.\n\n**(Non) Prime Attributes**\n- Prime Attribute란, Key Attribute에 포함되는 속성을 의미하고, Non Prime Attribute란, 그렇지 않은 속성을 의미한다.\n- 여기서 Key Attribute는 모든 candidate key를 의미한다.\n\n**2NF**는 relation이 1NF을 만족하고, 완전한 PK 집합만으로 relation의 non-prime attribute가 결정되는 형태이다.\n- 이를 Full Functional Dependency를 만족한다고 한다.\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/998E99335A2A47B114\" width=\"80%\">\n\n- 위에서, {학생 번호, 강좌 이름}의 복합 키를 가지고 있다고 가정한다.\n- 학생 번호와 강좌 이름이 있어야 성적이라는 non-prime attribute를 결정한다.\n- 하지만 강의실의 경우는 학생 번호가 없어도 결정할 수 있다. -> 이는 Full dependency가 아닌 Partial dependency를 가진다. (모든 PK를 사용해 결정되는 것이 아니므로)\n\n따라서, 아래와 같은 형태로 분리하여 Full Dependency를 만족하도록 할 수 있다.\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/99E5FD335A2A4ED622\" width=\"80%\">\n\n### 🪚 Third Normal Form(3NF)\n3NF에 대해 배우기 전에 아래 개념을 먼저 다루고 넘어가도록 한다.\n\n**Transitive Functional Dependency**\n- X -> Z라는 FD가 X -> Y, Y -> Z로 나눠질 수 있을 때, Y는 candidate key도 아니고, Key에 포함되지 않아야 한다.\n  - 즉, Y가 Non prime attribute여야 한다.\n- 이때 Transitive Functional Dependency가 있다고 한다.\n\n2NF를 만족하고, **Transitive Functional Dependency**가 없는 경우이다.\n- `Prime Attr -> Non prime Attr -> Non prime Attr` 여야 Transitive Functional Dependency가 존재하기에, 3NF를 만족하기 위해서는 `Prime Attr -> Prime Attr -> Non prime Attr` 여야 한다.\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/9913AA335A2A4F5F18\" width=\"80%\">\n\n- 위 그림에서는 {학생 번호}, {강좌 이름}을 저장하는 relation과, {강좌 이름}, {수강료}를 저장하는 relation으로 나누어 3NF를 만족시킬 수 있다.\n\n3NF는 **2가지 유형의 violation을 감지**할 수 있다.\n\n1. **2NF 위반 감지**\n\nPrime attribute가 functionally하게 Non-prime attribute를 결정하는 경우, Partial Functional Dependency로 인해 2NF의 위반을 감지할 수 있다.\n\n2. **3NF 위반 감지**\n\n2NF로 인해 모든 Non prime attribute는 Prime attribute에 의존한다.\n\nNon prime attribute가 Non prime attribute를 결정하는 경우, Prime attribute -> Non prime attribute -> Non prime attribute의 형태를 가지기에, Transitive Dependency로 인해 3NF의 위반을 감지할 수 있다.\n\nrelation R의 **모든 Non prime attribute가 아래 두 경우를 만족**하는 경우 3NF를 만족한다.\n- a. R의 모든 primary key에 fully functionally dependent\n- b. R의 모든 candidate key에 non-transitively dependent\n\n어떤 relation이 3NF를 만족한다면, a. 특성으로 인해 2NF도 자동으로 만족한다.\n\n하지만 **b. 특성은 3NF를 만족하게 하지만, BCNF를 만족하지 못하도록 하는 조건**이다.\n- BCNF는 candidate key에 의해 발생하는 transitive property 또한 없애는 정규화이다.\n\n### 🪚 Boyce-Codd Normal Form(BCNF)\nrelation R에서 X -> A라는 FD가 있을 때, X가 R의 super key인 경우이다.\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/994937355A31375128\" width=\"80%\">\n\n- 기본 키는 {학생 번호, 특강 이름} 이고, 교수는 이에 대해 완전히 종속하고 있다.\n- 교수도 특강 이름을 결정하며, 결정자의 역할을 수행한다.\n- 하지만 교수는 candidate key가 아닌 Non prime attribute이다.\n\n따라서, 3NF는 만족하지만, BCNF는 만족하지 않아 아래와 같이 변경해야 한다.\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/99A86B335A2A5A4716\" width=\"80%\">\n\n### 🪚 무손실 분해\n이상현상을 해결하기 위해 정규화를 통해 relation을 분해해야 한다. 하지만 분해 이후, 분해 전과 결과가 달라지면 손실이 발생하는 것이므로, 손실이 없는 분해를 수행해야 한다.\n\n이때, **손실이 없는 분해를 무손실 분해**(Lossless join decomposition)라고 한다.\n\n따라서, relation 분해 시 non-additive(lossless) join property와 functional dependency preservation property를 만족하는 분해를 수행해야 한다.\n- 그리고 이 두 조건 중에서는 lossless join property가 우선순위를 가져, 절대 희생되어선 안된다.\n\n---\n\n## 📕 참고\n- [[Database] 7. 정규화(Normalization)](https://mangkyu.tistory.com/28)"},{"excerpt":"가상 메모리는 물리 메모리 크기의 한계를 극복하기 위해 나온 기술이다. 따라서, 물리 메모리보다 큰 프로세스를 수행하기 위해 가상 메모리를 사용한다. 🧷 Demanding Paging 현재 필요한(요구되는) 페이지만 메모리에 올리는 것을 말한다. 접근되지 않는 페이지는 절대 로드되지 않는다. swap in이 발생할 때, pager가 어떤 page가 사용될…","fields":{"slug":"/[OS]VirtualMemory/"},"frontmatter":{"date":"August 20, 2022","title":"🧩 Virtual Memory","tags":["OS","Virtual Memory"]},"rawMarkdownBody":"\n가상 메모리는 물리 메모리 크기의 한계를 극복하기 위해 나온 기술이다. 따라서, 물리 메모리보다 큰 프로세스를 수행하기 위해 가상 메모리를 사용한다.\n\n## 🧷 Demanding Paging\n**현재 필요한(요구되는) 페이지만** 메모리에 올리는 것을 말한다.\n- 접근되지 않는 페이지는 절대 로드되지 않는다.\n\n<img src=\"https://user-images.githubusercontent.com/37871541/78536382-b80b6180-7828-11ea-9117-f86dfd77f2e1.png\" width=\"80%\">\n\n- swap in이 발생할 때, pager가 어떤 page가 사용될 것인지를 추측하여 로드한다.\n  - 로드된 페이지와 그렇지 않은 페이지를 `valid-invalid bit` 로 구분한다.\n\n---\n\n## 🧷 Page Fault\n이는 CPU가 요구하는 페이지가 메모리에 로드되어 있지 않은 경우로, 위에서 언급한 `valid-invalid bit` 의 값이 `i` 인 경우다.\n\n아래는 이를 처리하는 방법이다.\n\n<img src=\"https://user-images.githubusercontent.com/37871541/78536519-f012a480-7828-11ea-9b4e-1fd1c7e3c7c4.png\" width=\"80%\">\n\n1. CPU가 page table에서 사용할 페이지에 접근한다.\n2. 메모리에 로드되지 않은 상태라면, interrupt를 발생시킨다.\n3. Disk에서 페이지를 찾는다.\n4. 이를 메모리에 올려 Frame화한다.\n5. page table을 갱신하고, CPU에게 다시 수행하라고 명령한다.\n\n### 🪚 Pure Demanding Paging\n프로세스가 최초로 실행될 때 어떤 페이지가 필요한지 알 수 없어, 아무 페이지도 올리지 않는다.\n- 따라서 프로그램 실행과 동시에 Page fault가 발생한다.\n- 즉, 순수하게 필요한 페이지만 올리는 것을 Pure Demanding Paging이라고 한다.\n\n**메모리를 최대한 효율적으로 사용할 수 있다**는 장점이 있지만, **시작부터 Page fault가 발생해 속도면에서는 느리다**는 단점이 있다.\n\n### 🪚 Prepaging\nPure Demanding Paging과는 반대되는 개념으로, 프로그램 실행 시 필요할 것이라 판단되는 페이지를 미리 올리는 것이다.\n\n**Page fault가 발생할 확률이 적어** 속도면에서는 빠르지만, **미리 올라간 페이지를 사용하지 않는다면 메모리가 낭비**된다.\n\n### 🪚 Swapping vs. Demanding Paging\n둘 다 메모리와 backing store 사이를 오고 가는 기능을 수행하지만, **Swapping은 프로세스 단위**로 이동하고, **Demanding Paging은 페이지 단위**로 이동한다는 차이가 있다.\n\n---\n\n## 🧷 Page Replacement\nDemanding Paging은 요구되는 페이지만 backing store에서 가져온다. 하지만 프로그램들이 계속 실행되면서, 요구되는 페이지는 늘어나고 메모리는 유한하기에 언젠가는 가득 차게 되어 더 이상 새로운 페이지를 담을 수 없게 될 것이다.\n- 그렇다면, **이미 있는 페이지 중 하나를 다시 backing store로 내보내고**, **새로운 페이지를 메모리에 올려야 하는데**, 이를 Page Replacement라 한다.\n- backing store로 내보내는 것을 page-out, 그 반대를 page-in이라 한다.\n- 그리고 page-out된 페이지를 **victim page**라 한다.\n\n<img src=\"https://user-images.githubusercontent.com/37871541/78538479-066e2f80-782c-11ea-97e6-94ed4e8ee699.png\" width=\"80%\">\n\n### 🪚 Victim Page\n희생양 페이지는 어떤 페이지로 선택하는 것이 좋을까.\n\n이미 로드된 페이지 중 CPU에 수정(modify)되지 않은 페이지를 고르는 것이 효율적이다. 이는 곧 읽기만 하는 페이지를 의미한다. 이러한 페이지는 page-out이 될 때 backing store에 쓰기 연산을 할 필요가 없기 때문이다.\n\n그렇다면, 해당 페이지가 수정되었는지 안되었는지를 구분할 정보가 필요한데, 이때 `modify bit = dirty bit` 를 사용한다.\n\n<img src=\"https://user-images.githubusercontent.com/37871541/78538693-5c42d780-782c-11ea-9f59-09c204d9de90.png\" width=\"80%\">\n\n위 그림과 같이 수정되지 않은 페이지를 나타내고 이 중 선택한다.\n- 이때, 여러 개의 수정되지 않은 페이지가 있다면 어떤 페이지를 골라야 할까\n\n### 🪚 Page Replacement - FIFO\n가장 먼저 메모리에 올라온, 수정되지 않은 페이지를 희생양 페이지로 선택하는 방식이다.\n- 최적의 알고리즘은 아니지만, 정확성에는 영향을 미치지 않는다.\n- 이전에 page-out한 페이지를 그 다음 바로 page-in하려 한다면 다시 page fault가 발생해 비효율적이다.\n\n**Belady's Anomaly**\n- 프레임 수가 증가하면(= 메모리 용량이 증가하면) page fault 수가 줄어드는 것이 이상적이다.\n\n<img src=\"https://user-images.githubusercontent.com/37871541/78566093-b73ef380-7859-11ea-8256-1b3cf6722f03.png\" width=\"50%\"><img src=\"https://user-images.githubusercontent.com/37871541/78566141-c160f200-7859-11ea-9513-bfddb0216a14.png\" width=\"50%\">\n\n- 하지만 FIFO를 사용하면, 위와 같이 특정 지점에서 프레임 수가 증가해도, page fault 수가 오히려 증가하는 이상 현상이 발생한다. 이를 Belady's Anomaly라 한다.\n\n### 🪚 Page Replacement - Optimal\n말그대로, 효율적인 알고리즘으로, 가장 오랫동안 사용되지 않을 페이지를 선택하는 방식이다.\n- 미리 미래 정보를 안다는 가정 하에, 오랫동안 사용하지 않는 Page를 선택하여 out한다.\n- 이론적으로는 Page fault 발생을 줄일 수 있지만, 현실적으로 구현이 불가능하다.\n\n### 🪚 Page Replacement - LRU\nLeast Recently Used의 약자로, **최근에 사용되지 않으면 나중에도 사용되지 않을 것**이라는 개념을 사용하는 방식이다.\n- 가장 오랫동안 사용하지 않은 페이지를 희생양 페이지로 선택한다.\n- OPT보다는 Page fault가 많이 발생하지만, FIFO보다는 적게 일어난다.\n- 많은 운영체제가 사용하는 알고리즘이다.\n\n### 🪚 Page Replacement - LFU\nLeast Frequently Used의 약자로, 참조횟수가 가장 적은 페이지를 교체하는 알고리즘이다.\n- 교체 대상이 여러 개라면 가장 오랫동안 사용하지 않은 페이지를 교체한다.\n- 하지만 참조될 가능성이 많음에도 불구하고, 횟수에 의존하기에 최근에 사용된 프로그램을 교체시킬 가능성이 있다.\n\n### 🪚 Page Replacement - MFU\nMost Frequently Used의 약자로, LFU와 반대로 참조 횟수가 가장 많은 페이지를 교체하는 알고리즘이다.\n\n---\n\n## 🧷 Thrashing\n메모리 영역에 접근하게 될 때, 메모리에 **Page fault율이 높은 것**을 의미한다. 그리고 이는 성능 저하의 원인이 된다.\n\n### 🪚 Page-Fault Frequency\n**높은 PFF**는 프로세스에 프레임 수가 충분히 많지 않은 경우에 발생하고, **낮은 PFF**는 프로세스에 프레임 수가 너무 많은 경우에 발생한다.\n\n<img src=\"http://blog.skby.net/blog/wp-content/uploads/2019/04/1-38.png\" width=\"80%\">\n\n- 프레임 수를 관리함으로써 PFF를 조절할 수 있다.\n\n---\n\n## 📕 참고\n- [16: 가상 메모리 (Virtual Memory)](https://wansook0316.github.io/cs/os/2020/04/06/%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C-%EC%A0%95%EB%A6%AC-16-%EA%B0%80%EC%83%81%EB%A9%94%EB%AA%A8%EB%A6%AC.html)\n- [17: 페이지 교체 알고리즘](https://wansook0316.github.io/cs/os/2020/04/06/%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C-%EC%A0%95%EB%A6%AC-17-%ED%8E%98%EC%9D%B4%EC%A7%80-%EA%B5%90%EC%B2%B4-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98.html)\n- [PFF (Page Fault Frequency)](http://blog.skby.net/pff-page-fault-frequency/)"},{"excerpt":"⚽️ 배포 이전 글에서 다루었듯, GCP 환경에서 lighthouse 기능을 사용할 수 있었다. 따라서 스프링 부트 배포 또한 GCP 환경에 수행해야 했다. 이전에 몇 번 서버 배포 시에는, AWS를 사용했어서 꽤나 능숙하게 배포할 수 있었지만 이번엔 처음으로 GCP를 사용해서 엄청 많이 헤맸다 ... 아래의 참고 사이트들을 통해 해결할 수 있었고, 전체적…","fields":{"slug":"/[OpenSW]2.GCP배포와SpringRESTDocs적용/"},"frontmatter":{"date":"August 18, 2022","title":"🥊 2. GCP 배포와 Spring REST Docs 적용","tags":["Spring","MockMvc"]},"rawMarkdownBody":"\n## ⚽️ 배포\n이전 글에서 다루었듯, GCP 환경에서 lighthouse 기능을 사용할 수 있었다. 따라서 스프링 부트 배포 또한 GCP 환경에 수행해야 했다.\n\n이전에 몇 번 서버 배포 시에는, AWS를 사용했어서 꽤나 능숙하게 배포할 수 있었지만 이번엔 처음으로 GCP를 사용해서 엄청 많이 헤맸다 ...\n\n아래의 참고 사이트들을 통해 해결할 수 있었고, 전체적인 틀은 거의 유사했다.\n- 다만, ssh을 브라우저를 통해 연결할 수 있었고\n- 프로젝트 빌드 후 만들어진 jar 파일을 브라우저 ssh에서 다운받아 구동할 수 있다는 점이 달랐다.\n\n> 이전 AWS를 사용했을 때는 ssh에서 프로젝트 깃 주소를 clone 받아 직접 빌드하고 동작시켰었다.\n\n어찌저찌 인스턴스를 만들고 SQL도 생성하여, 아직까지는 아무것도 만들어지지 않은 프로젝트를 빌드하여 jar 파일을 동작시켰고, 정상적으로 작동하는 것을 확인했다.\n\n> 다만, 아직 mysql이 제대로 연결되었는지는 잘 모르겠다 ... 일단 IntelliJ에서 Database 연결은 되었으나, 추후 DB 접근 로직을 구현한 후 다시 확인해야 할 것 같다.\n\n---\n\n## ⚽️ Spring REST Docs 적용\n아직 설계과정이 더 구체화되어야 하기에, 우선 **사용할 API를 정의**하고, **간단한 반환**을 하도록 구현했다. \n\n사실 이를 한 이유는 **Spring REST docs**를 적용할 것이기 때문이다. 간단하게 코드를 구현해두고, 이에 대한 테스트 코드를 작성해 Spring REST docs를 적용해 프론트엔드단에서 개발 시 참고할 문서를 빠르게 만들 것이다.\n\n이전에는 **Swagger ui**를 사용했었는데, 사실 **Spring REST docs**라는 것이 있는지 몰랐다는 이유가 컸다. Spring REST docs가 적용이 어렵다는 단점이 있긴 하지만, 최근 테스트 코드를 잘 작성하는 개발자가 되고자 하는 생각을 가지며, 앞으로의 프로젝트에서는 무조건 테스트 코드를 작성하자! 라는 결심을 했기에 테스트 코드 작성을 강제화하는 Spring REST docs를 사용해보고자 했다.\n\n이제 테스트 코드를 작성하려는데, 처음 보는 **Spring MockMvc**를 사용해 테스트 코드를 작성해야 한다고 한다. 참고를 확인하니, \"Spring REST Docs는 Spring MVC의 테스트 프레임 워크 또는 Rest Assured 3로 작성된 테스트 코드에서 생성된 Snippet을 사용한다.\" 라는 이유가 있었다.\n\n> 그렇다면, Rest Assured 3를 사용하는 테스트 코드 작성이 아니라 왜 Spring MockMvc를 사용할까?\n\n**MockMvc**는 브라우저에서의 요청과 응답을 의미하는 객체로 Controller 테스트를 용이하게 해주는 라이브러리로 **Controller 레이어만 테스트**하기에 속도가 빠르지만, **Rest Assured**의 경우 **전체 컨텍스트를 로드하고 빈을 주입**하기 때문에 속도가 느리다.\n\n이러한 이유로 인해 Spring MockMvc를 많이 사용하는 것 같다!\n\n### 🏓 MockMvc\n웹 어플리케이션을 애플리케이션 서버에 배포하지 않고 테스트용 MVC 환경을 만들어 요청 및 전송, 응답기능을 제공해주는 유틸리티 클래스로, 컨트롤러를 테스트하고 싶을 때 실제 서버에 애플리케이션을 동작시키는 것이 아니라, 가짜 시뮬레이션을 통해 MVC가 되도록 도와주는 클래스이다.\n\n```java\npackage com.example.QCA.QualityControlAutomation.home;\n\nimport static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.get;\nimport static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.post;\nimport static org.springframework.restdocs.payload.PayloadDocumentation.fieldWithPath;\nimport static org.springframework.restdocs.payload.PayloadDocumentation.responseFields;\nimport static org.springframework.restdocs.request.RequestDocumentation.parameterWithName;\nimport static org.springframework.restdocs.request.RequestDocumentation.pathParameters;\nimport static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;\nimport static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;\n\n@WebMvcTest\n@AutoConfigureMockMvc\n// Spring REST docs 자동 설정을 위함\n@AutoConfigureRestDocs\nclass HomeControllerTest {\n\n    // MockMvc 객체 생성\n    @Autowired\n    private MockMvc mockMvc;\n\n    @Autowired\n    private ObjectMapper objectMapper;\n\n    @DisplayName(\"Top 5 리스트 반환 테스트\")\n    @Test\n    void listTest() throws Exception {\n        mockMvc.perform(\n                // 요청에 대한 정보 입력\n                get(\"/api/list\")\n                        .contentType(MediaType.APPLICATION_JSON)\n        )\n                // 응답이 ok인지 테스트\n                .andExpect(status().isOk())\n                // 응답이 JSON인지 테스트\n                .andExpect(content().contentType(MediaType.APPLICATION_JSON))\n                .andDo(\n                        // 어느 디렉토리에 저장할 것인지 명시\n                        document(\n                                \"list-get\",\n\n                            responseFields(\n                                    fieldWithPath(\"status\").description(\"상태 코드\"),\n                                    fieldWithPath(\"message\").description(\"반환 메세지\"),\n                                    fieldWithPath(\"data\").type(JsonFieldType.ARRAY).description(\"결과\"),\n                                    fieldWithPath(\"data[].label\").type(JsonFieldType.STRING).description(\"웹사이트 명\"),\n                                    fieldWithPath(\"data[].homepage\").type(JsonFieldType.STRING).description(\"웹사이트 주소\"),\n                                    fieldWithPath(\"data[].totalScore\").type(JsonFieldType.NUMBER).description(\"웹사이트의 결과 총합\")\n                                )\n                    )\n                )\n        ;\n    }\n}\n```\n\n1. `MockMvc` 객체를 생성한다. \n2. `MockMvc` 객체에 요청에 대한 정보를 전달한다.\n3. 응답값을 `.andExpect()` 를 통해 검증한다.\n   1. `.andExpect()` 는 여러 개가 올 수 있고, 모두 통과한다면 테스트 통과\n4. `.andDo()` 를 이용해 테스트 성공 후 수행할 행동을 명시한다.\n5. `responseFields` 에 문서에 적힐 반환 형태와 설명을 명시한다.\n\n이때 어노테이션 중 `@WebMvcTest` 를 확인할 수 있는데, 처음에는 `@SpringBootTest` 어노테이션을 사용했었다. 하지만 여기서는 Controller에 대한 테스트만 수행할 예정이므로, 당연히 `@WebMvcTest` 를 사용하는 것으로 수정했다.\n\n간단한 구현 코드여서 테스트도 간단하게 성공했다. 이제 REST docs를 적용하러 가보자.\n\n### 🏓 Spring REST Docs 적용\n아래 참고를 보고, `build.gradle` 에 다음과 같이 코드를 추가했다.\n\n```Groovy\nplugins {\n\tid 'org.springframework.boot' version '2.7.2'\n\tid 'io.spring.dependency-management' version '1.0.12.RELEASE'\n\tid \"org.asciidoctor.jvm.convert\" version \"3.3.2\"\n\tid 'java'\n}\n\ngroup = 'com.example.QCA'\nversion = '0.0.1-SNAPSHOT'\nsourceCompatibility = '11'\n\next {\n\tset('snippetsDir', file(\"build/generated-snippets\"))\n}\n\nconfigurations {\n\tasciidoctorExtensions\n\tcompileOnly {\n\t\textendsFrom annotationProcessor\n\t}\n}\n\nrepositories {\n\tmavenCentral()\n}\n\ndependencies {\n\timplementation 'org.springframework.boot:spring-boot-starter-data-jpa'\n\timplementation 'org.springframework.boot:spring-boot-starter-web'\n\timplementation 'org.springframework.boot:spring-boot-starter-validation'\n\tcompileOnly 'org.projectlombok:lombok'\n\tdevelopmentOnly 'org.springframework.boot:spring-boot-devtools'\n\truntimeOnly 'mysql:mysql-connector-java'\n\tannotationProcessor 'org.projectlombok:lombok'\n\ttestImplementation 'org.springframework.boot:spring-boot-starter-test'\n\n\t// Spring REST docs\n\ttestImplementation 'org.springframework.restdocs:spring-restdocs-mockmvc'\n\tasciidoctorExtensions 'org.springframework.restdocs:spring-restdocs-asciidoctor'\n}\n\ntest {\n\toutputs.dir snippetsDir\n\tuseJUnitPlatform()\n}\n\nasciidoctor { // asciidoctor 작업 구성\n\tdependsOn test // test 작업 이후에 작동하도록 하는 설정\n\tconfigurations 'asciidoctorExtensions' // 위에서 작성한 configuration 적용\n\tinputs.dir snippetsDir // snippetsDir 를 입력으로 구성\n\n\t// source가 없으면 .adoc파일을 전부 html로 만들어버림\n\t// source 지정시 특정 adoc만 HTML로 만든다.\n\tsources{\n\t\tinclude(\"**/index.adoc\",\"**/common/*.adoc\")\n\t}\n\n\t// 특정 .adoc에 다른 adoc 파일을 가져와서(include) 사용하고 싶을 경우 경로를 baseDir로 맞춰주는 설정\n\t// 개별 adoc으로 운영한다면 필요 없는 옵션\n\tbaseDirFollowsSourceFile()\n}\n\n// static/docs 폴더 비우기\nasciidoctor.doFirst {\n\tdelete file('src/main/resources/static/docs')\n}\n\n// asccidoctor 작업 이후 생성된 HTML 파일을 static/docs 로 copy\ntask copyDocument(type: Copy) {\n\tdependsOn asciidoctor\n\tfrom file(\"build/docs/asciidoc\")\n\tinto file(\"src/main/resources/static/docs\")\n}\n\n// build 의 의존작업 명시\nbuild {\n\tdependsOn copyDocument\n}\n```\n\ngradle을 빌드한 후, 프로젝트를 빌드하면 `build/generated-snippets` 폴더에 아래와 같이 `snippets` 가 생성되는 것을 확인할 수 있다.\n\n<img src=\"../../images/2022OpenSW/restDocs.png\" width=\"30\">\n\n이제 만들어진 코드 조각을 이용해 문서를 만들 차례이다. 이를 위해 `main/resources/static/docs` 디렉토리를 만든다.\n- `gradle` 설정에 의해 이 디렉토리로 `html` 파일이 복사되어 옮겨진다.\n\n그리고 `src/docs/asciidoc` 디렉토리를 만들고 안에 `index.adoc` 파일을 생성한다.\n\n```asciidoc\n= API 문서\n:doctype: book\n:icons: font\n// 문서에 표기되는 코드들의 하이라이팅\n:source-highlighter: highlightjs\n// toc (Table Of Contents) 위치 지정\n:toc: left \n:toclevels: 2\n:sectlinks:\n\n[[List-API]]\n== List API\n특정 정보 반환\n\n// 어떤 스니펫들을 사용할 것인지 명시\noperation::list-get[snippets='http-request,http-response,response-fields']\n```\n\n- [Asciidocs문법](https://narusas.github.io/2018/03/21/Asciidoc-basic.html)에서 더 자세한 사용법을 확인할 수 있다.\n- 이제 빌드를 하면, 아까 지정한 디렉토리에 `index.html` 이 만들어지고, 서버를 동작해 `../docs/index.html` 에서 확인할 수 있다.\n\n추가적인 최적화와 커스텀은 추후 수행할 예정이다.\n\n---\n\n> ❗️ 구현 코드는 [Github](https://github.com/bsonCrew/QCA_Server)에서 확인할 수 있습니다 ....\n\n---\n\n## ⚽️ 참고\nGCP 사용\n- [[GCP]GCP 기초_Cloud SQL 만들기](https://spacek82.tistory.com/66)\n- [Spring Boot와 Google Cloud SQL연결 및 GCP(Google Cloud Platform) 서버 배포#2](https://coding-is-fun.tistory.com/10)\n\nSpring REST Docs, MockMvc\n- [Spring REST Docs 적용](https://young-bin.tistory.com/92)\n- [스프링 MockMvc를 이용한 get, post, patch, delete 테스트](https://ip99202.github.io/posts/%EC%8A%A4%ED%94%84%EB%A7%81-MockMvc-%ED%85%8C%EC%8A%A4%ED%8A%B8/)\n- [Spring REST Docs 적용 및 최적화 하기](https://backtony.github.io/spring/2021-10-15-spring-test-3/#buildgradle-%EC%A0%84%EC%B2%B4-%EC%BD%94%EB%93%9C)"},{"excerpt":"⚽️ DB 설계 ⚽️ 비상사태 - HTTPS GCP에 테스트 코드를 포함한 프로젝트 빌드 파일을 실행시키고 접속했더니  가 뜨고, 로그에서는 다음과 같은 오류가 발생했다고 알려주고 있었다. 찾아보니, HTTPS 통신 설정이 되어 있지 않아 발생하는 오류였다. 저번 프로젝트 때도 HTTPS 통신 오류가 발생했어서 애를 먹었던 기억이 있는데 시간 관계로 인해 해…","fields":{"slug":"/[OpenSW]3.DB설계와HTTPS/"},"frontmatter":{"date":"August 18, 2022","title":"🥊 3. DB 설계와 HTTPS","tags":["Spring","HTTPS","SSL"]},"rawMarkdownBody":"\n## ⚽️ DB 설계\n\n\n---\n\n## ⚽️ 비상사태 - HTTPS\nGCP에 테스트 코드를 포함한 프로젝트 빌드 파일을 실행시키고 접속했더니 `ERR_SSL_PROTOCOL_ERROR` 가 뜨고, 로그에서는 다음과 같은 오류가 발생했다고 알려주고 있었다.\n\n```\nError parsing HTTP request header Note: further occurrences of HTTP request parsing errors will be logged at DEBUG level.\n```\n\n찾아보니, HTTPS 통신 설정이 되어 있지 않아 발생하는 오류였다. 저번 프로젝트 때도 HTTPS 통신 오류가 발생했어서 애를 먹었던 기억이 있는데 시간 관계로 인해 해결하지 못했었다. 그래서 이번에는 무조건 이를 해결하고 넘어가야 한다!\n\nSpring 프로젝트에 무료 SSL 인증서를 적용하여 이를 해결해보고자 한다. \n\n> 그럼 로컬에서 SSL 인증서를 적용하고 이를 빌드하면, GCP에서 해당 빌드 파일을 받아 실행해도 HTTPS 통신이 정상적으로 동작할까 .. ?\n\n우선 Certbot을 설치하기 위해 [공식 문서](https://certbot.eff.org/instructions?ws=apache&os=debianbuster)를 참고했다. GCP는 Debian 환경이었기에 Debian 환경에 맞게 설치했다. \n\nCertbot을 적용하기 위해서는 IP 주소가 아니라, 도메인이 필요하다고 한다.\n\n후 .. 이번엔 도메인이 필요하다. Github Pro를 학교 계정으로 사용하고 있어 [namecheap for education](https://nc.me/)을 통해 무료 도메인을 하나 얻을 수 있었다. 이제 얻은 도메인을 GCP IP 주소와 연결하는 과정이 필요하다.\n\n참고의 링크를 통해 GCP Cloud DNS API를 이용하는 것을 알았다. DNS 영역을 생성하여 만들어진 nameserver를 namecheap의 커스텀 DNS에 추가했다.\n\n---\n\n> ❗️ 구현 코드는 [Github](https://github.com/bsonCrew/QCA_Server)에서 확인할 수 있습니다 ....\n\n---\n\n## ⚽️ 참고\nHTTPS 설정\n- [SpringBoot 무료 SSL 인증서 적용하기 (Certbot)](https://subbak2.com/m/110)\n\n무료 도메인 사용, GCP와 연결\n- [GCP와 도메인 매핑하기](https://medium.com/@seohee.sophie.kwon/gcp%EC%99%80-%EB%8F%84%EB%A9%94%EC%9D%B8-%EB%A7%A4%ED%95%91%ED%95%98%EA%B8%B0-67e209da93ef)"},{"excerpt":"🧷 Memory Access 프로그램은 실행을 위해 메모리로 로드되어야 한다. CPU는 레지스터와 메인 메모리에만 접근할 수 있다. 레지스터: 접근하는데 보통 1 clock cycle이 소모된다. 메모리: 몇 cycles이 소모된다. (메모리 버스와의 트랜잭션이 CPU stall을 발생시킨다.) 메모리 unit은 메모리 주소들의 스트림만을 확인할 수 있다…","fields":{"slug":"/[OS]MemoryManagement/"},"frontmatter":{"date":"August 14, 2022","title":"🧩 Memory Management","tags":["OS","Memory"]},"rawMarkdownBody":"\n## 🧷 Memory Access\n프로그램은 실행을 위해 메모리로 로드되어야 한다.\n- CPU는 레지스터와 메인 메모리에만 접근할 수 있다.\n  - 레지스터: 접근하는데 보통 1 clock cycle이 소모된다.\n  - 메모리: 몇 cycles이 소모된다. (메모리 버스와의 트랜잭션이 CPU stall을 발생시킨다.)\n- 메모리 unit은 메모리 주소들의 스트림만을 확인할 수 있다.\n  - Context oblivious -> Context를 알지 못한다.\n    - 즉, 어떻게 생성되고, 어떤 데이터가 있는지 알 수 없다.\n\n---\n\n## 🧷 Address Binding\n프로세스의 주소는 **논리적 주소**와 **물리적 주소**로 나뉜다.\n- 논리적 주소는 가상 주소라고도 하며, CPU가 생성하는 주소이다.\n  - 프로세스마다 독립적으로 가지는 주소 공간이므로, 프로세스의 내부에서 사용하고, 각 프로세스마다 0부터 시작한다.\n- 물리적 주소는 프로세스가 실행되기 위해 실제로 메로리에 올라가는 위치이다.\n\n**Address Binding**이란, 어떤 프로그램이 메모리의 어느 위치에, 즉 어떤 물리적 주소에 로드될지를 결정하는 과정이다.\n- 그리고 이는 Binding하는 시점에 따라 분류되고, 아래는 해당 3가지 시점이다.\n\n### 🪚 Compile time\n: 컴파일 때에 정해진다. 프로세스가 메모리의 어느 위치에 들어갈지 미리 알고 있다면, 컴파일러가 절대 주소(Absolute address), 즉 고정된 주소를 생성한다.\n- 만약 위치가 변경된다면 재컴파일을 해야 한다.\n- 이는 프로세스 내부에서 사용하는 논리적 주소와 물리적 주소가 동일하다.\n- 문제점은 고정된 주소를 사용하기에 메모리 상에 빈 공간이 많이 발생할 수 있어 비효율적이고, 로드하려는 위치에 이미 다른 프로세스가 존재할 수 있다.\n\n### 🪚 Load time\n: 프로세스가 메모리의 어느 위치에 들어갈지 미리 알 수 없다면, 컴파일러는 Relocatable Code를 생성해야 한다. 이는 메모리의 어느 위치에서나 수행될 수 있는 기계 언어 코드이다.\n- Loader가 프로세스를 메모리에 로드하는 시점에 물리적 주소를 결정한다.\n- 이는 논리적 주소와 물리적 주소가 다르다.\n- 문제점은, 프로세스 내에 메모리를 참조하는 명령어들이 많아 이들의 주소를 다 바꿔줘야 하기에 로딩할 때의 시간이 매우 커질 수 있다.\n\n> 컴파일 타임과 로드 타임 주소 할당은 잘 쓰이지 않는다.\n\n### 🪚 Execution time\n: 프로세스가 동작하는 동안 메모리 주소를 바꾸는 방법이다. 즉 실행 도중 물리적 주소가 결정되며 실행 도중에 주소가 바뀔 수도 있다.\n- MMU(Memory Management Unit)라는 하드웨어 장치를 사용해 논리적 주소를 물리적 주소로 바꿔준다. (주소 재배치가 빈번하게 일어나기에 하드웨어적 도움이 효율적이다.)\n- 프로세스가 CPU에서 수행되면서 생성해내는 모든 주소값에 대해 base register 값(접근할 수 있는 물리적 주소의 최솟값)을 더해 물리적 주소를 생성한다.\n  - base register는 하나이므로 프로세스 간 공유한다.\n- 논리적 주소와 물리적 주소가 다르다.\n\n---\n\n## 🧷 Dynamic Linking\nLinking이란 여러 객체가 하나의 실행을 위해 결합하는 것을 의미하고, Static과 Dynamic이 있다.\n\n### 🪚 Static vs. Dynamic\n- Static한 방식은, 모든 시스템 라이브러리들이 이진 프로그램에 결합된다. (Loader에 의해 결합)\n- Dynamic한 방식은, 실행 전까지 결합이 연기된다. (메인 함수만 결합)\n\n### 🪚 Dynamic Linking\nStub이라는 작은 코드 조각이 binary(code)에 존재하여 라이브러리 참조시에 사용된다.\n- 라이브러리가 업데이트되어도, 모든 프로그램이 relinking하는 것을 막는다. (동적으로 참조하기 때문에)\n\n---\n\n## 🧷 Swapping\n<img src=\"../../images/OS/swapping.jpeg\" width=\"60%\">\n\n이는 실행되지 않은 프로세스를 뺐다가 그 자리에 실행될 프로세스를 넣는 방식이다. \n- 제한된 메모리에서 많은 응용 프로그램들을 실행시키기 위해서 필요하다.\n- 우선순위에 따라 어떤 프로세스를 in/out할 지 결정하고 일반적으로 중기 스케줄러에 의해 선정한다.\n- backing store: 모든 메모리 복사본을 수용하기에 충분히 큰 빠른 디스크로, 메모리에 직접 접근이 가능한 공간이다.\n- swap in, out: 메인 메모리에 들어갈 때와 나올 때를 의미한다.\n\n만약, Compile time이나 Load time binding인 경우 **원래 메모리 위치**로 swap in해야 하고, Execution time binding인 경우 **빈 메모리 영역 아무 곳**에나 swap in할 수 있다.\n\n### 🪚 Context Switch Time Including Swapping\nswap time의 주된 시간은 전송 시간으로, swap된 메모리의 양에 비례한다.\n\n**Swapping constraints**\n- Pending I/O: I/O Completion을 대기하는 프로세스는 swap out할 수 없다. (결과를 받을 프로세스가 없어지면 안되므로)\n\n---\n\n## 🧷 Contiguous Allocation\n메모리는 일반적으로 커널 영역과 사용자 프로세스 영역으로 나뉜다. 그 중 사용자 프로세스 영역의 할당 방법으로는 **Contiguous Allocation(연속적 할당)**, **Noncontiguous Allocation(비연속적 할당)** 이 있다.\n\nContiguous Allocation는 각 프로세스들이 연속적인 메모리 공간을 차지하게 되는 것이다.\n- 각 프로세스를 메모리에 담기 위해 메모리는 미리 공간을 분할해두는데, 이 또한 고정된 크기로 나누는 **고정 분할 방식**과 프로세스 크기에 따라 나누는 **가변 분할 방식**이 있다.\n\n고정 분할 방식은 분할의 크기가 모두 동일하거나 다를 수 있다. 1 분할 당 1 개의 프로세스가 할당되기에 동시에 메모리에 로드되는 프로세스의 수가 고정된다. 또 수행 가능한 프로세스의 최대 크기가 제한된다.\n\n가변 분할 방식은 프로세스의 크기를 고려하기에 분할의 크기나 개수가 동적으로 변한다. 관리 기법이 필요하다.\n\nContiguous Allocation에서 메모리를 분할하는 단위는 Block이고, 프로세스가 사용할 수 있는 Block을 **Hole**이라고 한다.\n- 다양한 크기의 Hole들이 메모리에 흩어져 있고, 프로세스가 도착하면 수용 가능한 Hole을 할당시켜준다.\n- 가변 분할 방식에서 가장 적절한 Hole을 찾는 문제를 Dynamic Storage-Allocation Problem이라하고, 세 종류의 해결법이 있다.\n  - First-fit\n    - 크기가 n 이상인 Hole 중 최초로 발견한 Hole에 할당하는 방법\n  - Best-fit\n    - 크기가 n 이상인 가장 작은 Hole을 찾아 할당한다. Hole이 크기 순 정렬되지 않은 경우 모든 Hole을 탐색해야 한다. \n  - Wort-fit\n    - 가장 큰 Hole에 할당한다. 마찬가지로 모든 Hole을 탐색해야 한다.\n\n---\n\n## 🧷 Fragmentation\n프로세스들이 메모리에 적재되고 제거되는 일이 반복되면 프로세스들이 차지하는 메모리 틈 사이에 **사용하지 못할 만큼의 작은 공간들이 늘어나게 되는 현상**을 말한다.\n- 외부 단편화(External)와 내부 단편화(Internal)로 나뉜다.\n\n외부 단편화는 총 공간을 계산했을 때, **프로세스가 들어갈 수 있는 메모리가 있음에도 불구하고 공간들이 연속하지 않아 사용할 수 없는 경우**를 말한다.\n- 프로세스들이 할당받은 공간 사이에 남는 공간\n\n내부 단편화는 **프로세스가 사용하는 메모리 공간보다 분할된 공간이 더 커서 메모리가 남는 경우**를 말한다.\n- 프로세스가 할당받은 공간에서 사용되지 않은 공간\n\n> First fit 방식은 N blocks를 할당하는 경우 0.5N blocks는 외부 단편화로 잃는다.\n\n고정 분할 방식은 외부 단편화와 내부 단편화 모두 발생할 수 있고, 가변 분할은 외부 단편화가 발생할 수 있다.\n- 가변 분할은 프로세스 크기를 고려한 방식이므로 내부 단편화는 발생하지 않지만, 외부 단편화는 고려되지 않아 발생할 수 있다.\n\n외부 단편화를 해결하기 위한 방법으로 **Compaction(압축)** 이 있다. \n- 이는 프로세스가 사용하는 공간들을 한쪽으로 몰아 공간을 확보하는 방법이다.\n- 하지만 이는 **메모리 이동을 요구**해 비용이 많이 드는 작업이다.\n\n---\n\n## 🧷 Paging\nNoncontiguous Allocation 방식으로, 외부 단편화의 압축 작업의 비효율성을 해결하기 위한 방법이다.\n- 메모리는 프레임(Frame), 프로세스는 페이지(Page)라 불리는 고정 크기의 블록(Block)으로 분리된다.\n\n> 한 프로세스가 사용하는 공간은 여러 Page로 나뉘어 관리되고, 각각의 Page는 순서와 관계없이 메모리의 Frame에 매핑되어 저장된다.\n\n**프로세스가 순서대로 메모리에 저장되지 않기에** 프로세스를 실행하기 위해선 page가 어느 frame에 들어있는지를 알아야 한다. 이에 대한 정보가 **page table**에 저장되어 있고, 이를 사용해 논리적 주소를 물리적 주소로 변환한다.\n\n<img src=\"../../images/OS/paging.jpeg\" width=\"80%\">\n\n장점으로는,\n- page들이 연속할 필요가 없어 외부 단편화를 해결할 수 있다.\n- 할당과 해제가 빠르다.\n- swap out이 간단하다.\n- 코드를 쉽게 공유할 수 있다.\n\n단점으로는,\n- 내부 단편화를 해결하지 못한다.\n- page table을 저장할 메모리가 추가로 사용된다.\n- page table이 메모리에 상주하기에 메모리에 접근하는 연산은 2번의 메모리 접근이 필요하게 되어 속도가 느리다. (page table에 접근 + 실제 연산)\n\n> 따라서 속도 향상을 위해 하드웨어적 도움이 필요하고, 이를 위해 TLB(Translation Look-aside Buffer)를 사용한다.\n\nCPU에 의해 만들어진 논리적 주소는 **Page number와 Page offset**으로 나뉜다.\n- Page number는 page table의 인덱스로서, page table 접근시에 사용된다.\n- Page offset은 물리적 주소를 얻을 때 사용되고, page table의 base address에 Page offset을 더하면 물리적 주소를 구할 수 있다.\n- 논리적 주소 공간의 크기가 $2^m$, Page size가 $2^n$인 경우, Page number는 `m-n bits` , Page offset은 `n bits` 이다.\n\n<img src=\"../../images/OS/pagingHW.jpeg\" width=\"80%\">\n\n> 이때, Page offset에 대한 확인이 필요한가?\n> - 필요하지 않다. Page offset의 limit는 이미 Page size에 대해 고정되어 있기 때문이다.\n\nPage table은 프로세스마다 존재하며, 메인 메모리에 상주한다. 대부분이 매우 큰 크기를 갖기 때문에 이를 구현하기 위해 비싼 레지스터를 사용하는 것은 비효율적이기 때문이다.\n- 따라서 메인 메모리에 이를 저장하고, PTBR(Page-Table Base Register)라는 레지스터가 이를 가리키도록 한다.\n  - Context Switch가 발생하는 경우 이 레지스터의 내용만 변경하면 된다.\n\n### 🪚 Fragmentation in Paging\nPaging은 외부 단편화를 해결할 수 있다. 하지만 내부 단편화는 여전히 해결하지 못하고 있다.\n- Page size를 작게하여 낭비를 줄일 수 있다.\n- 하지만 Page size를 작게 하면, 더 많은 page table entry가 발생하고, 오버헤드를 발생시킨다.\n- 큰 Page size는 disk I/O를 효율적이게 할 수 있다.\n\n### 🪚 Page Protection\nPage table에 Protection bit와 Valid-invalid bit를 추가한다.\n- Protection bit: Page에 대한 접근 권한 (read/write/read-only)\n- Valid-invalid bit: valid는 해당 주소의 frame에 그 프로세스를 구성하는 유효한 내용이 있음을 의미한다.\n\n메모리 할당이 연속적인 경우, Limit만 비교해도 메모리를 보호할 수 있었지만, **Paging은 Noncontiguous(비연속적)** 하기에 Valid-invalid bit를 이용해 Page 접근 권한을 관리한다.\n\n### 🪚 Structure of the Page Table\nPage table 공간의 효율적인 구성을 위한 몇 가지 방법이 있다.\n\n1. Multi-level Paging\n\n논리적 주소 공간을 여러 단계의 Page table로 분할하여 오직 사용되는 page의 Page table만 할당하는 기법이다. \n- 사용되는 Page table만 로드하기에 모든 Page를 로드해야 하는 부담을 줄일 수 있다.\n\n32bit 논리적 주소 공간이라면, 20bits는 Page number, 12bits는 Page offset을 나타냈다. Two-level인 경우, Page number는 **10bits의 Page number와 10bits의 Page offset**으로 또 나뉘게 된다.\n\n1. Hashed Page Table\n\nHash table을 이용하여 Page table을 관리하는 기법이다. 주소 공간이 32bit보다 커지면 계층 Paging이 비효율적이므로 이 방식을 사용한다.\n- virtual page number를 해싱하여 Page table을 참조하는데 사용한다. \n- 연결리스트를 따라가면서 Page number를 비교하고 일치하면 대응되는 Frame number를 얻는다.\n- 연결리스트가 길어지면 다른 Page에 저장될 수 있어 더 많은 메모리 접근을 유발할 가능성이 있다.\n\n3. Inverted Page Table\n\n지금까지는 Page table이 각 Page마다 하나의 항목을 가졌다. 반대로 이는 메모리의 Frame마다 한 항목씩 할당하는데, 그럼 물리적 Frame에 대응하는 항목만 저장하면 되기에 메모리를 훨씬 적게 사용한다.\n- 각 Page table entry는 각 메모리의 frame이 담고 있는 내용(PID, 논리적 주소)를 표시한다.\n- 다만 테이블 전체 탐색의 문제로 인해 대부분 Hashed page table과 결합하여 사용한다.\n- 공유 페이지를 구현하기 어렵다. (하나의 entry가 하나의 owner만 가리킬 수 있다.)\n\n---\n\n## 🧷 TLB\nTranslation Look-aside Buffer는 메모리 주소 변환을 위한 별도의 캐시 메모리로, Page table에서 빈번히 참조되는 일부 entry를 캐싱하고 있다.\n- entry는 `<key, value>` 쌍을 가지고, key에는 Page number, value에는 Frame number를 저장한다.\n\nCPU는 **Page table보다 TLB를 먼저 참조**하여, 원하는 page가 있는 경우 바로 frame number를 얻고, 그렇지 않은 경우 메인 메모리까지 접근하여 얻는다.\n- 원하는 page가 있는지 확인하기 위해 전체 탐색을 수행해야 하지만, Parallel Search가 가능해 탐색 시간은 적다.\n\nContext Switch가 발생하는 경우는 어떻게 처리될까?\n- 매 Switch마다 TLB 전체를 비우는 방법이 있다. \n  - 당연히 비용이 많이 드는 작업이다.\n- TLB의 각 entry가 어느 프로세스를 위한 것인지 추적하여 이용되지 않는 entry만 비우는 것이 좋다.\n  - 이를 위해 ASID(Address Space Identifier)를 이용한다.\n  - PID와 유사하지만, 8bit로 32bit인 PID보다 저렴하다. \n  - 동일한 ASID를 갖는 프로세스끼리는 TLB를 공유할 수 있어 TLB를 비우는 오버헤드를 줄일 수 있다.\n\nTLB는 캐시 메모리이므로, miss가 발생한 경우 HW와 OS가 모두 관여한다.\n- HW가 Page table에서 유효한 entry가 있는지 확인한다. 없다면 Page fault를 발생시키고, OS가 처리하도록 한다.\n- OS가 새로운 Page number를 TLB에 추가한다.\n- 또한, 자주 사용하기에 TLB에 유지하고 싶은 entry의 경우는 고정시킬 수 있다. -> **Wired Down**\n\n---\n\n## 🧷 Segmentation\n의미 단위로 하나의 프로세스를 나누는 것을 말한다. 작게는 프로그램을 구성하는 함수 하나하나를, 크게는 프로그램 전체를 segment의 단위로 정의할 수 있다.\n- 일반적으로는 stack, code, data 부분이 하나의 segment로 정의된다.\n\n<img src=\"../../images/OS/segmentation.jpeg\" width=\"30%\">\n\nSegmentation의 논리적 주소는 `<segment number, offset>` 으로 구성되며, 각각의 segment는 base, limit, protection bit를 가지고 있다.\n- 모든 segment의 시작은 0이다.\n- 논리적 주소 공간은 정렬되어 있지 않다.\n\n> 흔히 아는 Segment fault는 다른 segment에 접근하려는 경우 발생한다.\n\n장점으로는,\n- Paging과 마찬가지로 segment들이 연속적으로 할당될 필요없다. \n- stack과 heap이 독립적으로 커질 수 있다. (Overflow가 발생하지 않는다?)\n- segment마다 protection을 따로 수행할 수 있다.\n\n단점으로는,\n- 각각의 segment는 반드시 연속적으로 할당되어야 한다.\n\n---\n\n## 📕 참고\n- [운영체제(OS) - 8. Memory Management](https://velog.io/@doyuni/%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9COS-8.-Memory-Management)\n- [[운영체제(OS)] 8. 메모리 관리(Memory Management)\n출처: https://rebro.kr/178 [Rebro의 코딩 일기장:티스토리]](https://rebro.kr/178)"},{"excerpt":"문제 Programmers - 공 이동 시뮬레이션 📍 Logic 쿼리를 역추적하면서 방향에 따라 그 반대 방향으로 공의 범위를 구하는 함수 이때 행과 열을 분리하여 범위를 구하고, 최종적으로 행의 범위와 열의 범위에 있는 공들이 도달할 수 있다는 의미이므로, 범위의 곱이 공의 개수가 된다. 📄 CODE ✏️ Review n과 m이 까지이므로 모든 시작점을 …","fields":{"slug":"/[Programmers]87391/"},"frontmatter":{"date":"August 13, 2022","title":"👩‍💻 87391. 공 이동 시뮬레이션","tags":["시뮬레이션"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 공 이동 시뮬레이션](https://programmers.co.kr/learn/courses/30/lessons/87391)\n\n### 📍 **Logic**\n\n```java\nswitch(d) {\n    case 0:\n        ...\n        break;\n    case 1:\n        ...\n        break;\n    case 2:\n        ...\n        break;\n    case 3:\n        ...\n        break;\n}\n```\n\n- 쿼리를 역추적하면서 방향에 따라 그 반대 방향으로 공의 범위를 구하는 함수\n  - 이때 행과 열을 분리하여 범위를 구하고, 최종적으로 행의 범위와 열의 범위에 있는 공들이 도달할 수 있다는 의미이므로, 범위의 곱이 공의 개수가 된다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        public long solution(int n, int m, int x, int y, int[][] queries) {\n            long rowS = x, rowE = x;\n            long colS = y, colE = y;\n            \n            for (int i = queries.length - 1; i >= 0; i--) {\n                int d = queries[i][0];\n                int dx = queries[i][1];\n                \n                switch(d) {\n                    // 기존 0: 열이 감소하는 방향, 즉 열을 증가시켜야 함\n                    case 0: \n                        // 이미 끝이라면 갱신 X\n                        if (colS != 0) colS += dx;\n                        colE += dx;\n                        \n                        // 범위를 벗어나는 경우 제일 끝으로\n                        if (colE > m - 1) colE = m - 1;\n                        break;\n                    // 기존 1: 열이 증가하는 방향, 즉 열을 감소시켜야 함\n                    case 1:\n                        colS -= dx;\n                        // 범위를 벗어나는 경우 제일 끝으로\n                        if(colS < 0) colS = 0;\n\n                        // 이미 끝이라면 갱신 X\n                        if(colE != m - 1) colE -= dx;\n                        break;\n                    // 기존 2: 행이 감소하는 방향, 즉 행을 증가시켜야 함\n                    case 2:\n                        // 이미 끝이라면 갱신 X\n                        if (rowS != 0) rowS += dx;\n                        rowE += dx;\n                        \n                        // 범위를 벗어나는 경우 제일 끝으로\n                        if (rowE > n - 1) rowE = n - 1;\n                        break;\n                    // 기존 3: 행이 증가하는 방향, 즉 행을 감소시켜야 함\n                    case 3:\n                        rowS -= dx;\n                        // 범위를 벗어나는 경우 제일 끝으로\n                        if(rowS < 0) rowS = 0;\n\n                        // 이미 끝이라면 갱신 X\n                        if(rowE != n - 1) rowE -= dx;\n                        break;\n                }\n                \n                // 주어진 쿼리만으로 도착하지 못하는 경우는 바로 0을 반환\n                if (rowS > n - 1 || rowE < 0 || colS > m - 1 || colE < 0) return 0;\n            }\n            \n            // 행의 범위와 열의 범위를 곱한 것이 도달할 수 있는 공의 개수\n            return (rowE - rowS + 1) * (colE - colS + 1);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- n과 m이 $10^9$까지이므로 모든 시작점을 탐색해보는 것은 무조건 시간초과가 날 것 같았다.\n- 방법이 생각나지 않아서 .. 질문하기를 보니 **역추적**이라는 방식을 사용하더라.\n- 호오 ... 발상의 전환;"},{"excerpt":"문제 Programmers - 아이템 줍기 📍 Logic 주어진 사각형 좌표를 2배하여 저장한다.  자형 만났을 때 점프하지 않도록 하기 위함이다... 그저 BFS, 다만 테두리인 녀석들만 골라 탐색한다. 아이템을 주워도 더 빨리 가는 방법이 있을 수 있으니 계속 탐색한다. 📄 CODE ✏️ Review 처음에는 큰  에 각 직사각형 좌표들을 추가하면서, …","fields":{"slug":"/[Programmers]87694/"},"frontmatter":{"date":"August 12, 2022","title":"👩‍💻 87694. 아이템 줍기","tags":["BFS"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 아이템 줍기](https://programmers.co.kr/learn/courses/30/lessons/87694)\n\n### 📍 **Logic**\n\n```java\n// 주어진 사각형 정보를 이용해 테두리와 내부 정보를 map에 표시\nprivate void fillMap(int[] rect) {\n    int x1 = rect[0] * 2;\n    int y1 = rect[1] * 2;\n    int x2 = rect[2] * 2;\n    int y2 = rect[3] * 2;\n    \n    // 내부 색칠\n    // -1 : 내부\n    // 1 : 테두리\n    for (int i = x1; i <= x2; i++) {\n        for (int j = y1; j <= y2; j++) {\n            if (map[i][j] == -1) continue;\n            map[i][j] = -1;\n            if (i == x1 || i == x2 || j == y1 || j == y2) map[i][j] = 1;\n        }\n    }       \n}\n```\n\n- 주어진 사각형 좌표를 2배하여 저장한다. `ㄷ` 자형 만났을 때 점프하지 않도록 하기 위함이다...\n\n```java\nprivate void bfs(int cX, int cY, int iX, int iY) {\n    int[][] dir = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};\n    boolean[][] visited = new boolean[101][101];\n    Queue<Coor> queue = new LinkedList<>();\n    queue.add(new Coor(cX, cY));\n    \n    while(!queue.isEmpty()) {\n        Coor c = queue.poll();\n        int curX = c.x;\n        int curY = c.y;\n        \n        for (int[] d : dir) {\n            int nX = curX + d[0];\n            int nY = curY + d[1];\n            \n            if (!isValid(nX, nY)) continue;\n            if (map[nX][nY] != 1 || visited[nX][nY]) continue;\n            \n            // map에 비용 저장\n            map[nX][nY] = map[curX][curY] + 1;\n            if (nX == iX && nY == iY) {\n                // 이미 저장된 값이 있다면, 더 최소 값을 저장\n                answer = Math.min(answer, map[nX][nY]);\n                continue;\n            }\n            \n            visited[nX][nY] = true;\n            queue.add(new Coor(nX, nY));\n        }\n    }\n}\n```\n\n- 그저 BFS, 다만 테두리인 녀석들만 골라 탐색한다. 아이템을 주워도 더 빨리 가는 방법이 있을 수 있으니 계속 탐색한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Coor {\n        int x;\n        int y;\n        \n        public Coor(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Solution {\n        private static int[][] map = new int[101][101];\n        private static int answer = Integer.MAX_VALUE;\n        \n        public int solution(int[][] rectangle, int characterX, int characterY, int itemX, int itemY) {\n            for (int[] rect : rectangle)\n                fillMap(rect);\n            \n            bfs(characterX * 2, characterY * 2, itemX * 2, itemY * 2);\n            return answer/2;\n        }\n        \n        // 주어진 사각형 정보를 이용해 테두리와 내부 정보를 map에 표시\n        private void fillMap(int[] rect) {\n            int x1 = rect[0] * 2;\n            int y1 = rect[1] * 2;\n            int x2 = rect[2] * 2;\n            int y2 = rect[3] * 2;\n            \n            // 내부 색칠\n            // -1 : 내부\n            // 1 : 테두리\n            for (int i = x1; i <= x2; i++) {\n                for (int j = y1; j <= y2; j++) {\n                    if (map[i][j] == -1) continue;\n                    map[i][j] = -1;\n                    if (i == x1 || i == x2 || j == y1 || j == y2) map[i][j] = 1;\n                }\n            }       \n        }\n        \n        private void bfs(int cX, int cY, int iX, int iY) {\n            int[][] dir = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};\n            boolean[][] visited = new boolean[101][101];\n            Queue<Coor> queue = new LinkedList<>();\n            queue.add(new Coor(cX, cY));\n            \n            while(!queue.isEmpty()) {\n                Coor c = queue.poll();\n                int curX = c.x;\n                int curY = c.y;\n                \n                for (int[] d : dir) {\n                    int nX = curX + d[0];\n                    int nY = curY + d[1];\n                    \n                    if (!isValid(nX, nY)) continue;\n                    if (map[nX][nY] != 1 || visited[nX][nY]) continue;\n                    \n                    // map에 비용 저장\n                    map[nX][nY] = map[curX][curY] + 1;\n                    if (nX == iX && nY == iY) {\n                        // 이미 저장된 값이 있다면, 더 최소 값을 저장\n                        answer = Math.min(answer, map[nX][nY]);\n                        continue;\n                    }\n                    \n                    visited[nX][nY] = true;\n                    queue.add(new Coor(nX, nY));\n                }\n            }\n        }\n        \n        private boolean isValid(int i, int j) {\n            return i >= 0 && i < 101 && j >= 0 && j < 101;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 큰 `map` 에 각 직사각형 좌표들을 추가하면서, 테두리는 `1` , 내부는 `-1` 로 표현하여 전체 테두리는 결국 `1` 로만 이루어지게 했다. 이후 `1` 인 좌표들을 따라가게 했는데, 반례로 인해 잘못됨을 알았다.\n  - 사실 2배로 확장한다는 풀이를 얼핏 봤지만 아무리 생각해도 더 효율적으로 짤 수 있을 것 같아서 테두리마다의 방향을 저장하고 탐색 시에 사용하는 방법도 생각했지만 가만히 생각해보니 `ㄷ` 형태에서 무조건 목표대로 동작하지 않을 것 같았다.\n- 그냥 졌다. 멍청이"},{"excerpt":"🧷 Deadlock 데드락이란, 프로세스가 자원을 얻지 못해 다음 처리를 하지 못하는 상태로, \"교착 상태\" 라고도 하며 시스템적으로 한정된 자원을 여러 곳에서 사용하려 할 때 발생한다. 시스템은 유한한 자원을 가진다. (CPU cycles, Files, I/O devices, locks) 그리고 그렇기 때문에 데드락이 발생할 수 있는 것이다. Deadl…","fields":{"slug":"/[OS]DeadLock/"},"frontmatter":{"date":"August 11, 2022","title":"🧩 Deadlock","tags":["OS","Deadlock"]},"rawMarkdownBody":"\n## 🧷 Deadlock\n데드락이란, 프로세스가 자원을 얻지 못해 다음 처리를 하지 못하는 상태로, **\"교착 상태\"** 라고도 하며 시스템적으로 한정된 자원을 여러 곳에서 사용하려 할 때 발생한다.\n- 시스템은 유한한 자원을 가진다. (CPU cycles, Files, I/O devices, locks) 그리고 그렇기 때문에 데드락이 발생할 수 있는 것이다.\n- **Deadlocked**는 모든 프로세스가 다른 프로세스에 의해 발생될 수 있는 이벤트를 기다리고 있는 상태라고도 할 수 있다.\n\n### 🪚 발생 조건\n데드락은 언제 발생할 수 있을까? 아래의 네 가지 조건이 **동시에 성립**할 때 발생한다. 하나라도 성립하지 않도록 하면, 교착 상태를 피할 수 있는 것이다.\n\n**상호 배제(Mutual Exclusion)**\n- 자원은 한 번에 한 프로세스만이 사용할 수 있어야 한다. 적어도 하나의 자원은 공유되지 않아야 한다.\n\n**점유 대기(Hold and Wait)**\n- 적어도 하나의 자원을 할당하고 있어야 하고, 다른 프로세스들에 잡혀있는 자원을 점유하기 위해 대기하는 프로세스가 있어야 한다.\n\n**비선점(No Preemption)**\n- 다른 프로세스에 할당된 자원은 사용이 끝날 때까지 강제로 선점할 수 없어야 한다.\n\n**순환 대기(Circular Wait)**\n- 프로세스 집합에서 P0은 P1이 점유한 자원을 대기하고, P1은 P2가 점유한 자원을 대기, 이가 반복되어 Circle을 생성한다. \n- 이는 점유 대기로 인해 발생할 수 있다.\n\n> 자원 할당 그래프를 그려보았을 때, **사이클이 생성된다면 데드락이 존재할 수도 있다.** 이는 그저 가능성이 있음을 의미하기에 데드락이 존재하지 않을 수도 있다.\n> - 하지만 사이클이 없다면, 데드락이 발생하지 않는다는 것을 보장한다.\n\n---\n\n## 🧷 Deadlock 처리\n다음과 같은 전략이 있다.\n\n**데드락을 방지하거나 피하기 위한 프로토콜을 사용**\n- 시스템이 절대로 데드락에 들어가지 않도록 보장한다.\n- Deadlock prevention과 Deadlock avoidance가 있다.\n  - avoidance를 위해서는 추가적인 정보가 필요하다.\n\n**시스템이 데드락에 들어가는 것을 허용하되, 이를 감지하고 복구**\n> 데드락의 발생을 왜 처리하지 않는가?\n대부분의 시스템은 데드락이 잘 발생하지 않으며, 데드락 예방, 회피, 탐지 및 복구하는 것은 비용이 많이 든다.\n\n**데드락 무시**\n- 가장 많이 사용하는 방법\n\n### 🪚 Deadlock Prevention\n데드락은 발생 조건 4가지가 모두 성립되어야 발생한다. 따라서 한 가지 조건만 성립되지 않더라도 발생하지 않는다. 데드락 예방은 적어도 한 가지 조건이 성립하지 않는다고 보장한다.\n- 각 4가지 조건에 대한 부정을 통해 데드락을 예방하도록 하는 방법이다.\n\n**Mutual Exclusion - 상호 배제**\n- **멀티 프로세스가 자원을 공유**하도록 하여 상호 배제를 부정할 수 있다.\n- 자원을 공유가 가능하도록 만든다. (ex. read-only file : 여러 프로세스가 읽기 가능하다.)\n- 하지만, **자원을 공유가 가능하도록 만드는 것이 어렵다.**\n\n**Hold and Wait - 점유 대기**\n- 상호 배제를 부정하는 것보다는 쉬운 방법으로, 두 가지 방법이 있다.\n  - 모든 프로세스가 실행 전에 필요한 자원을 모두 요청하여 할당받도록 하는 것이다. 하지만 이는 **낮은 자원 활용도**가 문제가 된다.\n  - 모든 프로세스가 자원을 하나도 가지고 있지 않은 경우에만 자원을 요청하도록 한다. (자원을 얻고, 사용하고 해제, 또 얻고 사용하고 해제, 이를 반복) 하지만 이는 **Starvation**이 문제가 된다.\n\n**No Preemption - 비선점**\n- 자원을 점유하고 있는 프로세스가 다른 자원을 요구할 때, 점유하고 있는 모든 자원을 반납하고, 요구한 자원을 사용하기 위해 기다리게 한다.\n- 자원이 선점 가능한 경우에만 가능하다.\n\n**Circular Wait - 순환 대기**\n- 모든 자원의 순서를 정하고, 프로세스가 이 순서에 맞게 자원을 요청하도록 한다.\n\n> 데드락 예방은 자원의 낭비가 심하다는 단점이 있다.\n\n### 🪚 Deadlock Avoidance\n데드락이 발생하면 이를 피하는 방법이다.\n- 자원이 어떻게 요청되는지에 대한 추가 정보가 필요하다.\n- 각 요청마다, 요청이 받아들여질지, 대기할지를 결정한다.\n- 정보의 양과 유형에 따라 다양한 알고리즘이 적용될 수 있다.\n\n**Safe state**\n- 이 상태에서는, 시스템은 각 프로세스에 자원을 할당할 수 있고, 데드락을 피할 수 있다.\n  - 모든 요청을 만족할 수 있는 Safe sequence(프로세스의 순서)가 있는 경우에만 가능하다.\n\n**Unsafe state**\n- safe하지 않은 상태로, 무조건 데드락을 의미하는 것은 아니다.\n- 하지만 데드락이 발생할 수 있는 상태이다.\n\n**Resource-Allocation-Graph 알고리즘**\n- 자원 할당 그래프가 사이클을 생성하는 여부를 파악해야 한다.\n- 해당 알고리즘을 위해서는 Claim edge와 Request edge를 사용한다.\n  - Claim edge는 특정 프로세스가 특정 자원을 미래에 요청할 것임을 나타낸다.\n  - Request edge는 특정 프로세스가 특정 자원을 요청함을 나타낸다.\n- Claim edge는 실제로 해당 요청이 발생했을 때 Request edge로 변경된다. 그리고 해당 자원을 해제하면 다시 Claim edge로 변경된다.\n- 해당 edge들이 사이클을 형성한다면 자원의 할당이 불가능하도록 한다.\n\n**Banker's 알고리즘**\n- Resource-Allocation-Graph 알고리즘은 **multi-resource 문제에서 적용 불가능**하다. \n  - 사이클이 존재하더라도, multiple instance를 가진다면 데드락이 무조건 발생하는 것이 아니기 때문이다.\n- Banker's 알고리즘은 데드락 방지를 위해 할당 순서를 확인한다.\n  - 새로운 프로세스가 들어오면, 각 자원 유형의 인스턴스의 최대 수를 명시해야 한다.\n  - 요청 생성 시, 요청된 할당을 safe state에 있는 시스템에 할당할지 대기시킬지 결정한다.\n- 프로세스가 자원을 요구할 때 시스템은 자원을 할당한 후에도 Safe state로 남아있게 되는지를 사전에 검사하여 데드락을 회피하는 방법이다.\n  - 검사하여 Safe state에 있다면 자원을 할당하고, 그렇지 않다면 다른 프로세스들이 자원을 해제할 때까지 대기한다.\n\n---\n\n## 📕 참고\n- [Deadlock 개념이란? 그에 대한 해결책/회피책](https://jwprogramming.tistory.com/12)"},{"excerpt":"문제 Programmers - 예상 대진표 📍 Logic 쉬프트 연산을 사용해 다음 대진 번호를 정한다. 📄 CODE ✏️ Review 쉬운 문제였다. 다음 대진 번호를 정하는 반복의 종료 조건을 찾는데 시간이 좀 걸린 게 문제였다.","fields":{"slug":"/[Programmers]12985/"},"frontmatter":{"date":"August 09, 2022","title":"👩‍💻 12985. 예상 대진표","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 예상 대진표](https://programmers.co.kr/learn/courses/30/lessons/12985)\n\n### 📍 **Logic**\n\n```java\nwhile (nA != nB) {\n    nA = (nA + 1) >> 1;\n    nB = (nB + 1) >> 1;\n    answer++;\n}\n```\n- 쉬프트 연산을 사용해 다음 대진 번호를 정한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    class Solution {\n        public int solution(int n, int a, int b) {\n            int answer = 0;\n            int nA = (a + 1) >> 1;\n            int nB = (b + 1) >> 1;\n            \n            while (nA != nB) {\n                nA = (nA + 1) >> 1;\n                nB = (nB + 1) >> 1;\n                answer++;\n            }\n\n            return answer + 1;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 쉬운 문제였다. 다음 대진 번호를 정하는 반복의 종료 조건을 찾는데 시간이 좀 걸린 게 문제였다."},{"excerpt":"문제 Programmers - 괄호 회전하기 📍 Logic 시작 인덱스와 끝 인덱스를 인자로 받아, 해당 인덱스 사이의 문자열이 올바른지 확인하는 함수 스택을 사용해 괄호 문자의 쌍이 맞다면 스택에서 제거하고, 그렇지 않고 닫힌 괄호라면 올바르지 않음을 반환한다. 📄 CODE ✏️ Review 괄호는 항상 짝이 맞는지에 대한 로직이 필요하고, 이를 구현하기…","fields":{"slug":"/[Programmers]76502/"},"frontmatter":{"date":"August 09, 2022","title":"👩‍💻 76502. 괄호 회전하기","tags":["스택"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 괄호 회전하기](https://programmers.co.kr/learn/courses/30/lessons/76502)\n\n### 📍 **Logic**\n\n```java\n// 주어진 인덱스 사이의 문자열이 올바른 문자열인지 판단\nprivate boolean isValid(int s, int e) {\n    if (s == e) return true;\n\n    for (int i = s; i < e; i++) {\n        char ch = str.charAt(i);\n        \n        if (stack.isEmpty()) {\n            if (isCloseCh(ch)) return false;\n            stack.add(ch);\n        } else {\n            char stCh = stack.peek();\n\n            if (isPair(stCh, ch)) stack.pop();\n            else if (isCloseCh(ch)) return false;\n            else stack.add(ch);\n        }\n    }\n    \n    return true;\n}\n```\n\n- 시작 인덱스와 끝 인덱스를 인자로 받아, 해당 인덱스 사이의 문자열이 올바른지 확인하는 함수\n- 스택을 사용해 괄호 문자의 쌍이 맞다면 스택에서 제거하고, 그렇지 않고 닫힌 괄호라면 올바르지 않음을 반환한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        private String str;\n        private Stack<Character> stack;\n        \n        public int solution(String s) {\n            this.str = s;\n            int len = s.length();\n            \n            int answer = 0;\n            \n            if (len % 2 == 1) return answer;\n            \n            for (int i = 0; i < len; i++) {\n                stack = new Stack<>();\n                // i부터 문자열 길이까지가 올바르다면, 0부터 i까지 올바른지 확인\n                if (isValid(i, len))\n                    answer += isValid(0, i) ? 1 : 0;\n            }\n            \n            return answer;\n        }\n        \n        // 주어진 인덱스 사이의 문자열이 올바른 문자열인지 판단\n        private boolean isValid(int s, int e) {\n            if (s == e) return true;\n\n            for (int i = s; i < e; i++) {\n                char ch = str.charAt(i);\n                \n                if (stack.isEmpty()) {\n                    if (isCloseCh(ch)) return false;\n                    stack.add(ch);\n                } else {\n                    char stCh = stack.peek();\n\n                    if (isPair(stCh, ch)) stack.pop();\n                    else if (isCloseCh(ch)) return false;\n                    else stack.add(ch);\n                }\n            }\n            \n            return true;\n        }\n        \n        private boolean isCloseCh(char ch) {\n            return ch == '}' || ch == ']' || ch == ')';\n        }\n        \n        private boolean isPair(char stCh, char ch) {\n            return (stCh == '(' && ch == ')') || (stCh == '{' && ch == '}') || (stCh == '[' && ch == ']');\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 괄호는 항상 짝이 맞는지에 대한 로직이 필요하고, 이를 구현하기 위해서는 스택이 제격이라 생각했다.\n- 금방 풀린 문제"},{"excerpt":"문제 Programmers - 110 옮기기 📍 Logic 스택을 사용해 주어진 문자열에 있는 모든 110의 개수를 카운트한다. 📄 CODE ✏️ Review 처음 아이디어는 110 을 제거하고, 남은 문자열의 모든 인덱스에 110을 붙여보면서 사전 순 빠른 문자열을 찾으려 했다. 이 아이디어에서, 110이 여러 개 있을 수 있다는 것을 간과했다. 110이…","fields":{"slug":"/[Programmers]77886/"},"frontmatter":{"date":"August 07, 2022","title":"👩‍💻 77886. 110 옮기기","tags":["문자열","스택"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 110 옮기기](https://programmers.co.kr/learn/courses/30/lessons/77886)\n\n### 📍 **Logic**\n\n```java\n// 모든 110 개수 카운트\nfor(int i = 0; i < str.length(); i++) {\n    stack.push(str.charAt(i));\n\n    if (stack.size() < 3) continue;\n    \n    char first = stack.pop();\n    if(first != '0') {\n        stack.push(first);\n        continue;\n    }\n    char second = stack.pop();\n    if(second != '1') {\n        stack.push(second);\n        stack.push(first);\n        continue;\n    }\n    char third = stack.pop();\n    if(third != '1') {\n        stack.push(third);\n        stack.push(second);\n        stack.push(first);\n        continue;\n    }\n    strCount++;\n}\n```\n\n- 스택을 사용해 주어진 문자열에 있는 모든 110의 개수를 카운트한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Solution {\n        public String[] solution(String[] s) {\n            int len = s.length;\n            \n            String[] answer = new String[len];\n            \n            for (int i = 0; i < len; i++)\n                answer[i] = findFirst(s[i]);\n            \n            return answer;\n        }\n        \n        private String findFirst(String s) {\n            String ooz = \"110\";\n            \n            Stack<Character> stack = new Stack<>();\n            String str = s;\n            int strCount = 0;\n\n            // 모든 110 개수 카운트\n            for(int i = 0; i < str.length(); i++) {\n                stack.push(str.charAt(i));\n\n                if (stack.size() < 3) continue;\n                \n                char first = stack.pop();\n                if(first != '0') {\n                    stack.push(first);\n                    continue;\n                }\n                char second = stack.pop();\n                if(second != '1') {\n                    stack.push(second);\n                    stack.push(first);\n                    continue;\n                }\n                char third = stack.pop();\n                if(third != '1') {\n                    stack.push(third);\n                    stack.push(second);\n                    stack.push(first);\n                    continue;\n                }\n                strCount++;\n            }\n            \n            StringBuilder sb = new StringBuilder();\n            int index = -1, size = stack.size() - 1;\n            \n            // 스택 값을 sb 맨 앞에 추가\n            // 0을 만나면 index 증가\n            while(!stack.isEmpty()) {\n                char value = stack.pop();\n                sb.insert(0, value);\n                \n                if(index == -1 && value == '0')\n                    index = size;\n                size--;\n            }\n            \n            // 남은 strCount만큼 추가\n            // index == -1이라면, 남은 문자열에 0이 없다는 의미로, 맨 앞에 110을 붙여야 함\n            // 그렇지 않다면, index + 1부터 110을 붙여야 함\n            int offset = index == -1 ? 0 : ++index;\n            while(strCount-- > 0)\n                sb.insert(offset, ooz);\n            \n            return sb.toString();\n        }\n    }\n\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음 아이디어는 110 을 제거하고, 남은 문자열의 모든 인덱스에 110을 붙여보면서 사전 순 빠른 문자열을 찾으려 했다.\n  - 이 아이디어에서, 110이 여러 개 있을 수 있다는 것을 간과했다.\n- 110이 여러 개 존재하는 경우와, 0의 뒤에만 110을 붙인다는 조건 하에 구현하다가 시간초과가 나서, 아마 문자열을 붙이는 연산과 110을 찾는 연산때문인 것 같아 다른 방법을 찾아보다가 스택을 함께 사용하는 방법을 택했다.\n  - 근데 이 방법은 메모리를 적게 쓰고 시간은 더 쓰는 방법이네 .. ? (스택 pop, push 연산 때문인 것 같다.)\n- 시간초과가 발생하는 코드를 줄이기 위해 각 메소드의 시간복잡도를 생각하는 습관을 길러야겠다."},{"excerpt":"문제 Programmers - 쿠키 구입 📍 Logic 가장 중요한 함수 ... 주어진 기준점()을 이용해 첫째와 둘째의 쿠키 수를 조건에 따라 구한다. 📄 CODE ✏️ Review 처음 아이디어는 각 인덱스를  으로 두고, 첫째 아들과 둘째 아들에게 줄 쿠키 개수를 각각 구해보는 것이었다. 처음으로 두 아들에게 줄 쿠키의 개수가 같아진다면, 해당  을 …","fields":{"slug":"/[Programmers]49995/"},"frontmatter":{"date":"August 07, 2022","title":"👩‍💻 49995. 쿠키 구입","tags":["투 포인터"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 쿠키 구입](https://programmers.co.kr/learn/courses/30/lessons/49995)\n\n### 📍 **Logic**\n\n```java\nprivate void getCookie(int m) {\n    int fIdx = m;\n    int sIdx = m + 1;\n    \n    int first = cookie[fIdx];\n    int second = cookie[sIdx];\n    \n    while (true) {\n        // 둘의 쿠키 개수가 같고, 이전에 구한 최댓값보다 크면 갱신\n        if (first == second && answer < first) answer = first;\n        // 둘째의 쿠키가 더 많거나 같고, 아직 첫째에게 사줄 쿠키가 있다면 누적!\n        else if (first <= second && fIdx != 0) first += cookie[--fIdx];\n        // 첫째의 쿠키가 더 많거나 같고, 아직 둘째에게 사줄 쿠키가 있다면 누적!\n        else if (first >= second && sIdx != len - 1) second += cookie[++sIdx];\n        else break;\n    }\n}\n```\n\n- 가장 중요한 함수 ...\n- 주어진 기준점(`m`)을 이용해 첫째와 둘째의 쿠키 수를 조건에 따라 구한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        private int len;\n        private int[] cookie;\n        private int answer = 0;\n        \n        public int solution(int[] cookie) { \n            len = cookie.length;\n            this.cookie = cookie;\n            \n            // m이 첫째와 둘째 구분!\n            for (int m = 0; m < len - 1; m++)\n                // m을 기준으로 첫째와 둘째가 가지는 쿠키를 계산\n                getCookie(m);\n            \n            return answer;\n        }\n        \n        private void getCookie(int m) {\n            int fIdx = m;\n            int sIdx = m + 1;\n            \n            int first = cookie[fIdx];\n            int second = cookie[sIdx];\n            \n            while (true) {\n                // 둘의 쿠키 개수가 같고, 이전에 구한 최댓값보다 크면 갱신\n                if (first == second && answer < first) answer = first;\n                // 둘째의 쿠키가 더 많거나 같고, 아직 첫째에게 사줄 쿠키가 있다면 누적!\n                else if (first <= second && fIdx != 0) first += cookie[--fIdx];\n                // 첫째의 쿠키가 더 많거나 같고, 아직 둘째에게 사줄 쿠키가 있다면 누적!\n                else if (first >= second && sIdx != len - 1) second += cookie[++sIdx];\n                else break;\n            }\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음 아이디어는 각 인덱스를 `m` 으로 두고, 첫째 아들과 둘째 아들에게 줄 쿠키 개수를 각각 구해보는 것이었다.\n  - 처음으로 두 아들에게 줄 쿠키의 개수가 같아진다면, 해당 `m` 을 기준으로 줄 수 있는 최대의 동일한 쿠키 개수가 될 것이라 판단했다.\n  - 하지만, 테케 3개만 맞은 걸 보니 구현에서 뭔가 빠트린 게 있는 것 같다.\n- 결국 다른 풀이를 조금 참고했고, 큰 틀에서는 맞았으나 세부 조건을 구현하는 데서 실수가 있었던 것을 발견했다 ..."},{"excerpt":"알고리즘 문제를 풀다가 똑같은 로직에서,  과  의 차이로 인해 시간복잡도가 높아져서 해결하지 못한 경우가 있었고, 따라서 차이를 찾아보게 되었다. 📍 For loop 일반적인  의 경우는,  반복의 가장 일반적인 방법이다.  반복적으로 수행해야 할 동작들에 대해 사용할 수 있다. 📝 특징 초기화, 조건 확인, 증감 부분으로 나눠진다. 일반적인 반복에서,…","fields":{"slug":"/[Java지식]forLoop/"},"frontmatter":{"date":"August 05, 2022","title":"📃 for loop vs. enhanced for loop","tags":["Java"]},"rawMarkdownBody":"\n<em>알고리즘 문제를 풀다가 똑같은 로직에서, `for loop` 과 `enhanced for loop` 의 차이로 인해 시간복잡도가 높아져서 해결하지 못한 경우가 있었고, 따라서 차이를 찾아보게 되었다.</em>\n\n## 📍 For loop\n일반적인 `for loop` 의 경우는, `for` 반복의 가장 일반적인 방법이다. \n- 반복적으로 수행해야 할 동작들에 대해 사용할 수 있다.\n\n### 📝 특징\n- 초기화, 조건 확인, 증감 부분으로 나눠진다.\n- 일반적인 반복에서, `counter` 를 원하는 만큼 증감시킬 수 있다.\n- 특정 인덱스에 접근하는 방식이므로, 값의 대체도 가능하다.\n- 특정 배열의 원소를 출력하는 것과 같은 경우, 정방향과 역방향 모두 가능하다.\n\n---\n\n## 📍 Enhanced For loop\n`for loop` 의 특별한 버전으로, `Iterable` 인터페이스를 구현하고 있는 어떤 객체거나, 배열이라면 사용 가능하다.\n- 아는 배열이나 컬렉션을 순차적으로 접근하는 일반적인 `for loop` 를 생성하는 것을 막기 위해 만들어졌다.\n\n### 📝 특징\n- `counter` 를 사용할 필요도 없고, 시작점과 끝점을 지정할 필요도 없다. \n- 또한, boundary를 생각할 필요도 없어서 `IndexOutOfBoundsException` 을 걱정할 필요가 없다. \n\n---\n\n## 📍 For loop vs. Enhanced For loop\n그렇다면, 도대체 같은 객체에 대한 반복임에도 불구하고 시간 차이가 발생했던 것일까?\n\n대부분들의 글에서, 사실 이 둘은 성능상 조금의 차이가 나긴 하지만, 이걸 쓰는 대신 다른 걸 쓴다한들 큰 차이가 없다고 한다.\n- 따져보면 **Enhanced for loop**이 성능상 조금의 이점이 있다고 한다..\n\n**하지만** 이러한 언급을 몇 번이나 본 적이 있어서 **Enhanced For loop**를 사용했었고, 오히려 시간이 더 걸려 문제가 됐었다.\n\n그래서 내가 생각해본 바로는 ...\n- `For loop` 의 경우 대부분 조건 확인부에서 반복 횟수에 대한 조건을 명시한다.\n- 하지만 `Enhanced For loop` 의 경우는 반복 횟수에 대한 조건을 명시하지 않고, 해당 순서의 값이 배열이나 컬렉션의 마지막 원소인 경우까지 반복한다.\n- 그렇다면 ... 매번 이게 마지막 원소인지 확인하는 조건이 내부적으로 동작하기 때문이 아닐까 !?!!?\n\n해당 질문에 대한 답을 찾기 위해 직접 코드로 실행해봤다. 단순히 조건문을 추가하고 말고의 차이가 이게 정답일리는 없지만 어느 정도 내 논리가 틀리지 않았음을 보여주지 않을까.\n\n**정답 코드**\n```java\nArrayList<Integer>[] adjList;\n\n...\n\nfor (int i = 0; i < adjList[node].size(); i++) {\n    int cur = adjList[node].get(i);\n    if (!visited[cur])\n        values[node] += dfs(cur);\n}\n```\n\n```\n테스트 6 〉\t통과 (10.41ms, 155MB)\n테스트 7 〉\t통과 (1127.97ms, 227MB)\n테스트 8 〉\t통과 (903.20ms, 236MB)\n```\n\n**테스트 코드**\n```java\nArrayList<Integer>[] adjList;\n\n...\n\nfor (int i = 0; ; i++) {\n    if (i == adjList[node].size()) break;\n    int cur = adjList[node].get(i);\n    if (!visited[cur])\n        values[node] += dfs(cur);\n}\n```\n\n```\n테스트 6 〉\t통과 (12.09ms, 149MB)\n테스트 7 〉\t실패 (런타임 에러)\n테스트 8 〉\t통과 (958.53ms, 222MB)\n```\n\n- 테스트 코드의 시간 복잡도가 더 커진 것을 확인할 수 있고, 심지어 테스트 7에 대해서는 런타임 에러가 발생했다...\n- 따라서 **어느 정도는 일리가 있는 논리가 아닐까...?**\n\n> 여기서 또 궁금증은, 시간 복잡도는 증가했으나, 메모리 사용량은 오히려 줄어들었다. 이는 또 어떤 차이일까 ...\n\n> 해당 글은 [Programmers - 모두 0으로 만들기](https://school.programmers.co.kr/learn/courses/30/lessons/76503)를 풀면서 생긴 궁금증이고, 질문하기 게시판을 참고하면, 해당 문제에 대한 시간 복잡도 테스트의 신뢰성이 낮다는 점을 확인할 수 있습니다...\n\n## 📕 참고\n- [Difference Between for loop and Enhanced for loop in Java](https://www.geeksforgeeks.org/difference-between-for-loop-and-enhanced-for-loop-in-java/)\n- [Java Flow Control: for and for-each Loops](https://stackabuse.com/java-flow-control-for-and-for-each-loops/)"},{"excerpt":"문제 Programmers - 모두 0으로 만들기 📍 Logic 리프 노드부터 0으로 만든다. 📄 CODE ✏️ Review 트리를 그려두고 리프 노드부터 보다보니 아이디어는 쉽게 잡을 수 있었다. 계속 6, 7, 8에서 런타임 에러가 발생했다 .... Enhanced for문 사용으로 인한 런타임 에러였다는 걸 알게 됐고.. 정리해야겠다.","fields":{"slug":"/[Programmers]76503/"},"frontmatter":{"date":"August 04, 2022","title":"👩‍💻 76503. 모두 0으로 만들기","tags":["DFS"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 모두 0으로 만들기](https://programmers.co.kr/learn/courses/30/lessons/76503)\n\n### 📍 **Logic**\n\n```java\nprivate long dfs(int node) {\n    visited[node] = true;\n    \n    // 방문하지 않은 자식 노드가 있다면 탐색\n    for (int i = 0; i < adjList[node].size(); i++) {\n        int cur = adjList[node].get(i);\n        if (!visited[cur])\n            values[node] += dfs(cur);\n    }\n    \n    // 런타임 에러 원인\n    // for (int n : adjList[node])\n    //     if (!visited[n]) \n    //         values[node] += dfs(n);\n\n    long value = values[node];\n    answer += Math.abs(value);\n\n    return value;\n}\n```\n\n- 리프 노드부터 0으로 만든다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        private ArrayList<Integer>[] adjList;\n        private int size;\n        private long answer = 0;\n        private long[] values;\n        private boolean[] visited;\n        \n        public long solution(int[] a, int[][] edges) {\n            size = a.length;\n            \n            values = new long[size];\n            visited = new boolean[size];\n            adjList = new ArrayList[size];\n            \n            if (init(a) != 0) return -1;\n            \n            for (int[] edge : edges) {\n                int n1 = edge[0];\n                int n2 = edge[1];\n                \n                adjList[n1].add(n2);\n                adjList[n2].add(n1);\n            }\n            \n            dfs(0);\n            \n            return answer;\n        }\n        \n        private int init(int[] a) {\n            int sum = 0;\n            \n            for (int i = 0; i < size; i++) {\n                sum += a[i];\n                values[i] = a[i];\n                adjList[i] = new ArrayList<>();\n            }\n            \n            return sum;\n        }\n        \n        private long dfs(int node) {\n            visited[node] = true;\n            \n            // 방문하지 않은 자식 노드가 있다면 탐색\n            for (int i = 0; i < adjList[node].size(); i++) {\n                int cur = adjList[node].get(i);\n                if (!visited[cur])\n                    values[node] += dfs(cur);\n            }\n            \n            // 런타임 에러 원인\n            // for (int n : adjList[node])\n            //     if (!visited[n]) \n            //         values[node] += dfs(n);\n\n            long value = values[node];\n            answer += Math.abs(value);\n\n            return value;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 트리를 그려두고 리프 노드부터 보다보니 아이디어는 쉽게 잡을 수 있었다.\n- 계속 6, 7, 8에서 런타임 에러가 발생했다 ....\n  - Enhanced for문 사용으로 인한 런타임 에러였다는 걸 알게 됐고.. 정리해야겠다."},{"excerpt":"문제 Programmers - 빛의 경로 사이클 📍 Logic 방향에 따라 빛을 계속 이동시킨다. 해당 격자에 해당 방향에 방문 기록이 없는 경우 종료한다. 📄 CODE ✏️ Review 문제 자체가 잘 이해가 안되어서 질문하기의 설명을 참고했다. 단순 구현은 가끔 문제가 이해 안될 때가 있는 것 같다...","fields":{"slug":"/[Programmers]86052/"},"frontmatter":{"date":"August 04, 2022","title":"👩‍💻 86052. 빛의 경로 사이클","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 빛의 경로 사이클](https://programmers.co.kr/learn/courses/30/lessons/86052)\n\n### 📍 **Logic**\n\n```java\nprivate int go(int x, int y, int d) {\n    // 이동 거리\n    int cnt = 0;\n\n    while (!visited[x][y][d]) {\n        cnt++;\n        visited[x][y][d] = true;\n\n        if (grid[x].charAt(y) == 'L')\n            d = d == 0 ? 3 : d - 1; // 좌회전\n        else if (grid[x].charAt(y) == 'R')\n            d = d == 3 ? 0 : d + 1; // 우회전\n        \n        // 다음 좌표 계산\n        x = (x + dir[d][0] + m) % m;\n        y = (y + dir[d][1] + n) % n;\n    }\n\n    return cnt;\n}\n```\n\n- 방향에 따라 빛을 계속 이동시킨다.\n- 해당 격자에 해당 방향에 방문 기록이 없는 경우 종료한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        private int m;\n        private int n;\n        private boolean[][][] visited;\n        private String[] grid;\n        // 0: 아래, 1: 왼, 2: 위, 3: 오른\n        private int[][] dir = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};\n            \n        public int[] solution(String[] grid) {\n            m = grid.length;\n            n = grid[0].length();\n            visited = new boolean[m][n][4];\n            this.grid = grid;\n            \n            ArrayList<Integer> answer = new ArrayList<>();\n            \n            // 모든 격자에서 4방향으로 다 방문\n            for (int i = 0; i < m; i++)\n                for (int j = 0; j < n; j++)\n                    for (int d = 0; d < 4; d++)\n                        if (!visited[i][j][d])\n                            answer.add(go(i, j, d));\n            \n            return answer.stream().sorted().mapToInt(i -> i).toArray();\n        }\n        \n        private int go(int x, int y, int d) {\n            // 이동 거리\n            int cnt = 0;\n    \n            while (!visited[x][y][d]) {\n                cnt++;\n                visited[x][y][d] = true;\n    \n                if (grid[x].charAt(y) == 'L')\n                    d = d == 0 ? 3 : d - 1; // 좌회전\n                else if (grid[x].charAt(y) == 'R')\n                    d = d == 3 ? 0 : d + 1; // 우회전\n                \n                // 다음 좌표 계산\n                x = (x + dir[d][0] + m) % m;\n                y = (y + dir[d][1] + n) % n;\n            }\n    \n            return cnt;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 문제 자체가 잘 이해가 안되어서 질문하기의 설명을 참고했다.\n- 단순 구현은 가끔 문제가 이해 안될 때가 있는 것 같다..."},{"excerpt":"\"Do it! 자바 완전 정복\" 책을 바탕으로 정리하는 포스트입니다. 📍 연산자의 종류 연산 결과가 특정 값이 나오는 산술, 증감, 비트, 시프트 연산자 연산 결과가 참 또는 거짓 중 하나의 값으로만 나타나는 비교, 논리 연산자 값을 반환하는 것이 아닌 값을 대입하는 의미를 가진 대입, 삼항 연산자 연산자: 연산을 수행하는 기호 📝 연산자의 연산법 - 산…","fields":{"slug":"/[Java지식]Doit!3.연산자/"},"frontmatter":{"date":"August 01, 2022","title":"📃 [Do it!] 3. 연산자","tags":["Java"]},"rawMarkdownBody":"\n<em>\"Do it! 자바 완전 정복\" 책을 바탕으로 정리하는 포스트입니다.</em>\n\n## 📍 연산자의 종류\n- **연산 결과가 특정 값이 나오는** 산술, 증감, 비트, 시프트 연산자\n- **연산 결과가 참 또는 거짓 중 하나의 값으로만 나타나는** 비교, 논리 연산자\n- **값을 반환하는 것이 아닌 값을 대입하는 의미를 가진** 대입, 삼항 연산자\n\n> 연산자: 연산을 수행하는 기호\n\n### 📝 연산자의 연산법 - 산술, 증감\n산술 연산자와 증감 연산자는 매우 간단하기에 생략한다.\n\n### 📝 연산자의 연산법 - 비트\n비트 단위의 연산자로, AND(&), OR(|), XOR(^), NOT(~)이 있다. 진리표는 생략한다.\n\n비트 단위의 연산을 직접 계산하기 위해서는 10진수를 비트 단위의 표현 방식인 2진수로 바꿔 표기할 수 있어야 한다.\n\n> 자바 코드 상에서 10진수를 2진수, 8진수, 16진수로 변환하는 메소드(`Integer.toBinaryString()`, `Integer.toOctalString()`, `Integer.toHexString()`)를 제공한다.\n\n주어진 두 정수를 2진수로 변환한 후, AND, OR, XOR 연산을 수행한다. 실제 비트 연산을 수행할 때의 최소 단위는 `int` 이므로 4byte, 즉 32bits로 표현된다.\n\nNOT 연산을 위해서는 양숫값과 음숫값을 읽는 방법부터 알아야 한다. **값의 첫 번째 비트는 부호 비트로, 숫자의 부호를 결정**한다.\n- 0: 양수\n- 1: 음수\n\n이후, 비트를 읽을 때는 양수의 경우 1을 기준으로 값을 읽고, 음수의 경우 0을 기준으로 값을 읽고 1을 더한 값이 절대값이다.\n\nNOT 연산자는 0과 1을 반전시키는 연산이기에 매번 부호가 바뀌게 된다.\n\n> 음수 값을 읽을 때 0을 기준으로 읽은 후 왜 항상 1을 더할까?\n> - 만약 1을 더하지 않으면 음수에서 양수로 넘어가는 과정에서 `10진수 0` 을 나타내는 표현이 2개 존재하게 된다.\n\n### 📝 연산자의 연산법 - 시프트\n시프트 연산은 비트의 위치를 좌우로 이동시키는 연산으로, 산술 시프트와 논리 시프트가 있다.\n\n**산술 시프트**\n- 숫자의 부호 비트는 유지하면서 나머지 비트를 왼쪽(`<<`) 또는 오른쪽(`>>`)으로 이동하는 연산이다.\n- `<<` 연산을 수행하면, 1bit 이동마다 `*2` 의 효과가 있다. 빈 칸은 0으로 채운다.\n- 반면 `>>` 연산을 수행하면, 1bit 이동마다 `/2` 의 효과가 있다. 부호 비트는 항상 고정이고, 빈 칸은 부호 비트값과 동일한 값으로 채운다.\n\n**논리 시프트**\n- 부호 비트를 포함해 전체 비트를 오른쪽으로 이동시키는 연산(`>>>`)이다.\n- 빈 칸은 모두 0으로 채운다.\n- 부호 비트가 1인 음수일 때, 연산 이후 값이 양수로 변할 것이다.\n\n이러한 논리 시프트는 \"각 비트 위치에서의 값만이 의미가 있을 때 주로 사용하는 연산\"이므로 숫자의 크기나 부호는 의미가 없다.\n\n### 📝 연산자의 연산법 - 비교\n비교 연산자는 크기 비교와 등가 비교로 나뉜다. 크기 비교는 `>` , `<` , `>=` , `<=` 이고 등가 비교는 `==` , `!=` 이다.\n\n등가 비교에서 가장 중요한 것은 비교 대상이 무엇이냐는 것이다. 등가 비교는 **비교를 위해 스택 메모리의 값을 비교**한다.\n- 이것이 중요한 이유는 스택 메모리의 값이 기본 자료형일 때와 참조 자료형일 때 서로 다르기 때문이다. ([앞 장 참고](https://subbblog.netlify.app/[Java%EC%A7%80%EC%8B%9D]Doit!2.%EC%9E%90%EB%A3%8C%ED%98%95/))\n- \n\n---\n\n## 📍 자료형의 종류\n자바의 자료형은 크게 \"기본 자료형(Primitive Type)\"과 \"참조 자료형(Reference Type)\"이 있다.\n- 8가지 기본 자료형이 있으며, 이외의 모든 자료형은 참조 자료형이다.\n- 또한 참조 자료형은 개발자가 직접 정의할 수도 있다.\n\n**❗️ 자료형을 구분하는 이유**\n- 자료형을 이와 같이 구분하는 이유는 **기본 자료형과 참조 자료형의 값 저장 방식이 서로 다르기 때문**이다.\n\n> 자료형의 구분을 이해하기 위해 먼저 메모리의 구조를 알아야 한다. 메모리는 목적에 따라 크게 3가지 영역으로 나뉜다.\n> 1. 클래스 영역, 정적 영역, 상수 영역, 메소드 영역\n> 2. 스택 영역 (변수들이 저장되는 영역)\n> 3. 힙 영역 (객체들이 저장되는 영역)\n\n### 📝 기본 자료형과 참조 자료형의 차이\n**1. 자료형의 이름 규칙**\n- 기본 자료형 8개의 이름은 모두 **소문자**(`int` , `long` , `float` , `double` , ...) 로 시작한다.\n- 참조 자료형의 이름은 모두 **대문자**(`String` , `System` , ...)로 시작한다.\n  - 권장사항이므로 지켜지지 않아도 오류가 발생하지는 않지만, 개발자 사이의 무언의 약속이므로 지키는 것이 좋다.\n\n**2. 실제 데이터값의 저장 위치**\n- 기본 자료형과 참조 자료형 모두 변수의 공간이 **스택 메모리에 생성**되지만 그 공간에 저장되는 값의 의미가 서로 다르다.\n- 기본 자료형은 **스택 메모리에 생성된 공간에 실제 변숫값이 저장**된다.\n- 참조 자료형은 **실제 데이터값은 힙 메모리에 저장**되고, **스택 메모리의 변수 공간에는 실제 변숫값이 저장된 힙 메모리의 위치값을 저장**한다.\n\n### 📝 기본 자료형의 종류\n기본 자료형에는 총 8가지로, 다음과 같다.\n- 참, 거짓을 저장하는 `boolean`\n- 정수를 저장하는 `byte` , `int` , `short` , `long`\n- 실수를 저장하는 `float` , `double`\n- 문자(정수)를 저장하는 `char`\n\n> **똑같은 정수를 처리하는데 왜 자료형이 4개나 있을까?**\n> - 이는 메모리의 효율성을 위해서이다. \n> - 큰 공간을 가진 자료형만 사용한다면, 작은 공간을 필요로 하는 변수 저장 시 공간 낭비가 발생할 것이다.\n> - 반대로 작은 공간을 가진 자료형만 사용한다면, 큰 공간을 필요로 하는 변수 저장 시 공간이 부족할 것이다.\n> - 여러 종류의 공간을 가진 자료형을 두어 효율적인 메모리 사용을 가능하도록 하기 위함이다.\n\n`char` 에 대해서, **문자(정수)**라고 표기했다. 이와 같이 적은 이유는 다음과 같다.\n- 메모리에 문자를 기록할 수 없다.\n  - 메모리는 2진수 값만 저장할 수 있는 공간이기 때문이다.\n- 그래서 `char` 은 모든 문자를 특정 정숫값으로 바꿔 저장한다. 그리고 특정 정숫값을 유니코드라고 한다.\n\n---\n\n## 📍 기본 자료형 간의 타입 변환\n`boolean` 을 제외한 기본 자료형 7개는 서로 자료형 변환이 가능하고 이를 타입 변환(Type casting)이라 한다.\n- 타입 변환은 단순히 변환 대상 앞에 `(자료형)`만 표기하면 된다.\n\n> 중요한 것은 타입 변환 시, 저장할 수 있는 값의 범위나 종류가 달라지므로 **값이 변할 수 있다**는 점이다.\n\n### 📝 자동 타입 변환과 수동 타입 변환\n타입 변환에는 2가지 종류가 있다.\n- 컴파일러가 자동으로 수행하는 **\"자동 타입 변환\"**\n- 개발자가 직접 타입 변환을 명시하는 **\"수동 타입 변환\"**\n\n크기가 작은 자료형을 큰 자료형에 대입하게 되면, 어떠한 데이터 손실도 발생하지 않는다. \n- 따라서 타입 변환을 명시하지 않더라도 컴파일러가 자동으로 타입 변환을 실행하는데, 이를 **업캐스팅(upcasting)** 이라 한다.\n\n반대로, 큰 자료형을 작은 자료형에 대입하면, 데이터 손실이 발생할 것이다. \n- 데이터 손실이 발생하기에 컴파일러에 따른 자동 타입 변환은 일어나지 않고, 이를 **다운캐스팅(downcasting)** 이라 한다.\n- 개발자가 직접 타입 변환을 명시해야 한다.\n\n---\n\n## 📕 참고\n- **Do it! 자바 완전 정복** - 이지스 퍼블리싱"},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 빈 스코프란? 지금까지 우리는 스프링 빈이 스프링 컨테이너의 시작과 함께 생성되어서 스프링 컨테이너가 종료될 때까지 유지된다고 학습했다. 이것은 스프링 빈이 기본적으로 싱글톤 스코프로 생성되기 때문이다. 스코프는 번역 그대로 빈이 존재할 수 있는 범위를 뜻한다. 스프링은 다음과 같은 다양한…","fields":{"slug":"/[스프링핵심원리_기본편]9.빈스코프/"},"frontmatter":{"date":"August 01, 2022","title":"📟 9. 빈 스코프","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 빈 스코프란?\n지금까지 우리는 **스프링 빈이 스프링 컨테이너의 시작과 함께 생성되어서 스프링 컨테이너가 종료될 때까지 유지**된다고 학습했다. 이것은 **스프링 빈이 기본적으로 싱글톤 스코프로 생성**되기 때문이다. 스코프는 번역 그대로 빈이 존재할 수 있는 범위를 뜻한다.\n\n스프링은 다음과 같은 다양한 스코프를 지원한다.\n- **싱글톤**: 기본 스코프, 스프링 컨테이너의 시작과 종료까지 유지되는 **가장 넓은 범위의 스코프**이다. \n- **프로토타입**: 스프링 컨테이너는 프로토타입 빈의 생성과 의존관계 주입까지만 관여하고 더는 관리하지 않는 **매우 짧은 범위의 스코프**이다.\n- **웹 관련 스코프** : 스프링 웹과 관련된 기능이 들어가야 사용할 수 있는 스코프이다.\n  - **request**: 웹 요청이 들어오고 나갈때 까지 유지되는 스코프이다. \n  - **session**: 웹 세션이 생성되고 종료될 때 까지 유지되는 스코프이다.\n  - **application**: 웹의 서블릿 컨텍스트와 같은 범위로 유지되는 스코프이다.\n\n빈 스코프는 다음과 같이 지정할 수 있다.\n\n**컴포넌트 스캔 자동 등록**\n```java\n@Scope(\"prototype\")\n@Component\npublic class HelloBean {}\n```\n\n**수동 등록**\n```java\n@Scope(\"prototype\")\n@Bean\nPrototypeBean HelloBean() {\n    return new HelloBean();\n}\n```\n\n---\n\n## 🎯 프로토타입 스코프\n싱글톤 스코프의 빈을 조회하면 스프링 컨테이너는 **항상 같은 인스턴스의 스프링 빈을 반환**한다. 반면에 프로토타입 스코프를 스프링 컨테이너에 조회하면 스프링 컨테이너는 **항상 새로운 인스턴스를 생성해서 반환**한다.\n\n**싱글톤 빈 요청**\n<img src=\"../../images/스프링핵심원리-기본편/싱글톤빈요청.png\" width=\"80%\">\n\n1. 싱글톤 스코프의 빈을 스프링 컨테이너에 요청한다.\n2. 스프링 컨테이너는 본인이 관리하는 스프링 빈을 반환한다.\n3. 이후 스프링 컨테이너에 같은 요청이 와도 같은 객체 인스턴스의 스프링 빈을 반환한다.\n\n**프로토타입 빈 요청1**\n<img src=\"../../images/스프링핵심원리-기본편/프로토타입1.png\" width=\"80%\">\n\n1. 프로토타입 스코프의 빈을 스프링 컨테이너에 요청한다.\n2. 스프링 컨테이너는 이 시점에 프로토타입 빈을 생성하고, 필요한 의존관계를 주입한다.\n\n**프로토타입 빈 요청2**\n<img src=\"../../images/스프링핵심원리-기본편/프로토타입2.png\" width=\"80%\">\n\n3. 스프링 컨테이너는 생성한 프로토타입 빈을 클라이언트에 반환한다.\n4. 이후 스프링 컨테이너에 같은 요청이 오면 항상 새로운 프로토타입 빈을 생성해서 반환한다.\n\n**정리**\n- 스프링 컨테이너는 **프로토타입 빈을 생성하고, 의존관계 주입, 초기화까지만 처리**한다.\n- 클라이언트에 빈을 반환하고, 생성된 프로토타입 빈을 관리하지 않는다. 빈에 대한 책임은 프로토타입 빈을 받은 클라이언트에 있다.\n- 따라서, **`@PreDestroy` 같은 종료 메소드가 호출되지 않는다.** (클라이언트가 필요하다면, 이를 호출해야 한다.)\n\n**싱글톤 스코프 빈 테스트**\n```java\npackage hello.core.scope;\n\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Scope;\n\nimport javax.annotation.PostConstruct;\nimport javax.annotation.PreDestroy;\n\nimport static org.assertj.core.api.Assertions.*;\n\npublic class SingletonTest {\n\n    @Test\n    void singletonBeanFind() {\n        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SingletonBean.class);\n        SingletonBean singletonBean1 = ac.getBean(SingletonBean.class);\n        SingletonBean singletonBean2 = ac.getBean(SingletonBean.class);\n\n        System.out.println(\"singletonBean1 = \" + singletonBean1);\n        System.out.println(\"singletonBean2 = \" + singletonBean2);\n\n        assertThat(singletonBean1).isSameAs(singletonBean2);\n\n        ac.close();\n    }\n\n    @Scope(\"singleton\")\n    static class SingletonBean {\n        @PostConstruct\n        public void init() {\n            System.out.println(\"SingletonBean.init\");\n        }\n\n        @PreDestroy\n        public void destroy() {\n            System.out.println(\"SingletonBean.destroy\");\n        }\n    }\n}\n```\n\n```\nSingletonBean.init\nsingletonBean1 = hello.core.scope.SingletonTest$SingletonBean@6fa51cd4\nsingletonBean2 = hello.core.scope.SingletonTest$SingletonBean@6fa51cd4\n17:04:42.261 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@3c130745, started on Mon Aug 01 17:04:42 KST 2022\nSingletonBean.destroy\n```\n\n- `init()` 과 `destroy()` 가 모두 호출된 것을 확인할 수 있다.\n\n**프로토타입 스코프 빈 테스트**\n```java\npackage hello.core.scope;\n\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Scope;\n\nimport javax.annotation.PostConstruct;\nimport javax.annotation.PreDestroy;\n\nimport static org.assertj.core.api.Assertions.*;\n\npublic class PrototypeTest {\n\n    @Test\n    void prototypeBeanFind() {\n        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);\n        System.out.println(\"find prototypeBean1\");\n        PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);\n        System.out.println(\"find prototypeBean2\");\n        PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);\n\n        System.out.println(\"prototypeBean1 = \" + prototypeBean1);\n        System.out.println(\"prototypeBean2 = \" + prototypeBean2);\n\n        assertThat(prototypeBean1).isNotSameAs(prototypeBean2);\n\n        ac.close();\n    }\n\n    @Scope(\"prototype\")\n    static class PrototypeBean {\n        @PostConstruct\n        public void init() {\n            System.out.println(\"PrototypeBean.init\");\n        }\n\n        @PreDestroy\n        public void destroy() {\n            System.out.println(\"PrototypeBean.destroy\");\n        }\n    }\n}\n```\n\n```\nfind prototypeBean1\nPrototypeBean.init\nfind prototypeBean2\nPrototypeBean.init\nprototypeBean1 = hello.core.scope.PrototypeTest$PrototypeBean@6fa51cd4\nprototypeBean2 = hello.core.scope.PrototypeTest$PrototypeBean@2767e23c\n17:12:05.791 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@3c130745, started on Mon Aug 01 17:12:05 KST 2022\n```\n\n- 프로토타입 스코프인 경우는 매번 요청마다 새로운 인스턴스를 생성하기에 조회된 두 인스턴스가 다름을 검증해야 한다.\n- 요청이 발생했을 때, 초기화 함수가 호출되는 것을 확인할 수 있고, 종료 메소드는 호출되지 않는다.\n  - 싱글톤 빈의 경우는 스프링 컨테이너가 관리하는 책임을 가지기에, 컨테이너 종료 시에 종료 메소드가 호출된다.\n  - 따라서, 종료 메소드를 호출할 필요가 있다면, 스프링 컨테이너가 종료되기 전에 명시적으로 종료 메소드를 호출해야 한다.\n- 또한 두 인스턴스가 서로 다른 참조값을 가지는 것을 확인할 수 있다.\n\n### 🪔 프로토타입 빈의 특징 정리\n- 스프링 컨테이너에 요청할 때마다 새로 생성된다.\n- 스프링 컨테이너는 프로토타입 빈의 생성과 의존관계 주입 그리고 초기화까지만 관여한다.\n- 종료 메서드가 호출되지 않는다.\n- 그래서 프로토타입 빈은 프로토타입 빈을 조회한 클라이언트가 관리해야 한다. 종료 메서드에 대한 호출도 클라이언트가 직접 해야한다.\n\n---\n\n## 🎯 프로토타입 스코프 - 싱글톤 빈과 함께 사용 시 문제점\n스프링 컨테이너에 프로토타입 스코프의 빈을 요청하면 항상 새로운 객체 인스턴스를 생성해서 반환한다.\n  \n하지만 싱글톤 빈과 함께 사용할 때는 의도한 대로 잘 동작하지 않으므로 주의해야 한다.\n\n### 🪔 스프링 컨테이너에서 프로토타입 빈 직접 요청 1\n<img src=\"../../images/스프링핵심원리-기본편/프로토타입요청1.png\" width=\"80%\">\n\n1. 클라이언트A는 스프링 컨테이너에 프로토타입 빈을 요청한다.\n2. 스프링 컨테이너는 프로토타입 빈을 새로 생성해서 반환(x01)한다. 해당 빈의 count 필드 값은 0이다. \n3. 클라이언트는 조회한 프로토타입 빈에 `addCount()` 를 호출하면서 count 필드를 +1 한다. 결과적으로 프로토타입 빈(x01)의 count는 1이 된다.\n\n### 🪔 스프링 컨테이너에서 프로토타입 빈 직접 요청 2\n<img src=\"../../images/스프링핵심원리-기본편/프로토타입요청2.png\" width=\"80%\">\n\n1. 클라이언트B는 스프링 컨테이너에 프로토타입 빈을 요청한다.\n2. 스프링 컨테이너는 프로토타입 빈을 새로 생성해서 반환(x02)한다. 해당 빈의 count 필드 값은 0이다. \n3. 클라이언트는 조회한 프로토타입 빈에 `addCount()` 를 호출하면서 count 필드를 +1 한다. 결과적으로 프로토타입 빈(x02)의 count는 1이 된다.\n\n```java\npackage hello.core.scope;\n\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Scope;\n\nimport javax.annotation.PostConstruct;\nimport javax.annotation.PreDestroy;\n\nimport static org.assertj.core.api.Assertions.*;\n\npublic class SingletonWithPrototypeTest1 {\n\n    @Test\n    void prototypeFind() {\n        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);\n        PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);\n        prototypeBean1.addCount();\n        assertThat(prototypeBean1.getCount()).isEqualTo(1);\n\n        PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);\n        prototypeBean2.addCount();\n        assertThat(prototypeBean2.getCount()).isEqualTo(1);\n    }\n\n    @Scope(\"prototype\")\n    static class PrototypeBean {\n        private int count = 0;\n\n        public void addCount() {\n            count++;\n        }\n\n        public int getCount() {\n            return count;\n        }\n\n        @PostConstruct\n        public void init() {\n            System.out.println(\"PrototypeBean.init\" + this);\n        }\n\n        // 호출되지 않을 것!\n        @PreDestroy\n        public void destroy() {\n            System.out.println(\"PrototypeBean.destroy\" );\n        }\n    }\n}\n```\n\n- 두 인스턴스의 `count` 모두 `1` 인 것을 확인할 수 있다.\n\n### 🪔 싱글톤 빈에서 프로토타입 빈 사용\n`clientBean` 이라는 싱글톤 빈이 의존관계 주입을 통해서 프로토타입 빈을 주입받아서 사용하는 예를 보자.\n\n**싱글톤에서 프로토타입 빈 사용1**\n<img src=\"../../images/스프링핵심원리-기본편/프로토타입사용1.png\" width=\"80%\">\n\n`clientBean` 은 싱글톤이므로, 보통 스프링 컨테이너 생성 시점에 함께 생성되고, 의존관계 주입도 발생한다.\n1. `clientBean` 은 의존관계 자동 주입을 사용한다. 주입 시점에 스프링 컨테이너에 프로토타입 빈을 요청한다.\n2. 스프링 컨테이너는 프로토타입 빈을 생성해서 `clientBean` 에 반환한다. 프로토타입 빈의 `count` 필드 값은 0이다. (프로토타입 빈의 책임이 싱글톤 빈으로 전가!)\n\n이제 `clientBean` 은 프로토타입 빈을 내부 필드에 보관한다. (정확히는 **참조값을 보관**한다.)\n\n**싱글톤에서 프로토타입 빈 사용2**\n<img src=\"../../images/스프링핵심원리-기본편/프로토타입사용2.png\" width=\"80%\">\n\n클라이언트 A는 `clientBean` 을 스프링 컨테이너에 요청해서 받는다. 싱글톤이므로 항상 같은 `clientBean` 이 반환된다.\n3. 클라이언트 A는 `clientBean.logic()` 을 호출한다.\n4. `clientBean` 은 `prototypeBean` 의 `addCount()` 를 호출해서 프로토타입 빈의 `count` 를 증가한다. count값이 1이 된다.\n\n**싱글톤에서 프로토타입 빈 사용3**\n<img src=\"../../images/스프링핵심원리-기본편/프로토타입사용3.png\" width=\"80%\">\n\n클라이언트 B는 `clientBean` 을 스프링 컨테이너에 요청해서 받는다.싱글톤이므로 항상 같은 `clientBean` 이 반환된다.\n\n**여기서 중요한 점이 있는데, clientBean이 내부에 가지고 있는 프로토타입 빈은 이미 과거에 주입이 끝난 빈이다. 주입 시점에 스프링 컨테이너에 요청해서 프로토타입 빈이 새로 생성이 된 것이지, 사용 할 때마다 새로 생성되는 것이 아니다!**\n5. 클라이언트 B는 `clientBean.logic()` 을 호출한다.\n6. `clientBean` 은 `prototypeBean` 의 `addCount()` 를 호출해서 프로토타입 빈의 `count` 를 증가한다. 원래 `count` 값이 1이었으므로 2가 된다.\n\n**테스트 코드**\n```java\npackage hello.core.scope;\n\npublic class SingletonWithPrototypeTest1 {\n\n    ...\n\n    @Test\n    void singletonClientUserPrototype() {\n        // ClientBean에 대한 의존관계 자동 주입을 위해 등록\n        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(ClientBean.class, PrototypeBean.class);\n\n        ClientBean clientBean1 = ac.getBean(ClientBean.class);\n        int count1 = clientBean1.logic();\n        assertThat(count1).isEqualTo(1);\n\n        ClientBean clientBean2 = ac.getBean(ClientBean.class);\n        int count2 = clientBean2.logic();\n        assertThat(count2).isEqualTo(2);\n    }\n\n    // 싱글톤 빈\n    @Scope(\"singleton\")\n    static class ClientBean {\n        private final PrototypeBean prototypeBean;\n\n        // 생성자 의존관계 주입 수행\n        // PrototypeBean을 컨테이너로부터 요청하여 주입받음!\n        // 이제 PrototypeBean은 ClientBean이 관리!\n        public ClientBean(PrototypeBean prototypeBean) {\n            this.prototypeBean = prototypeBean;\n        }\n\n        public int logic() {\n            prototypeBean.addCount();\n            return prototypeBean.getCount();\n        }\n    }\n\n    @Scope(\"prototype\")\n    static class PrototypeBean {\n        private int count = 0;\n\n        public void addCount() {\n            count++;\n        }\n\n        public int getCount() {\n            return count;\n        }\n\n        @PostConstruct\n        public void init() {\n            System.out.println(\"PrototypeBean.init\" + this);\n        }\n\n        // 호출되지 않을 것!\n        @PreDestroy\n        public void destroy() {\n            System.out.println(\"PrototypeBean.destroy\" );\n        }\n    }\n}\n```\n\n- 스프링은 일반적으로 싱글톤 빈을 사용하므로, 싱글톤 빈이 프로토타입 빈을 사용하게 된다.\n- 그런데 싱글톤 빈은 생성 시점에만 의존관계 주입을 받기 때문에, 프로토타입 빈이 새로 생성되기는 하지만, 싱글톤 빈과 함께 계속 유지되는 것이 문제다.\n\n아마 원하는 것이 이런 것은 아닐 것이다. 프로토타입 빈을 주입 시점에만 새로 생성하는게 아니라, **사용할 때마다 새로 생성해서 사용하는 것을 원할 것이다.** -> 프로토타입이 그런 의미로 사용되는 것이기 때문에!\n\n---\n\n## 🎯 프로토타입 스코프 - 싱글톤 빈과 함께 사용 시 Provider로 문제 해결\n싱글톤 빈과 프로토타입 빈을 함께 사용할 때, 어떻게 새로운 사용마다 새로운 프로토타입 빈을 생성할 수 있을까?\n\n### 🪔 스프링 컨테이너에 요청\n가장 간단한 방법으로, 싱글톤 빈이 프로토타입을 사용할 때마다 스프링 컨테이너에 새로 요청하는 것이다.\n\n```java\npackage hello.core.scope;\n\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Scope;\n\nimport javax.annotation.PostConstruct;\nimport javax.annotation.PreDestroy;\n\nimport static org.assertj.core.api.Assertions.assertThat;\n\npublic class PrototypeProviderTest {\n\n    @Test\n    void providerTest() {\n        AnnotationConfigApplicationContext ac = new\n                AnnotationConfigApplicationContext(ClientBean.class, ClientBean.PrototypeBean.class);\n        ClientBean clientBean1 = ac.getBean(ClientBean.class);\n        int count1 = clientBean1.logic();\n        assertThat(count1).isEqualTo(1);\n        ClientBean clientBean2 = ac.getBean(ClientBean.class);\n        int count2 = clientBean2.logic();\n        assertThat(count2).isEqualTo(1);\n    }\n\n    static class ClientBean {\n        @Autowired\n        private ApplicationContext ac;\n\n        public int logic() {\n            PrototypeBean prototypeBean = ac.getBean(PrototypeBean.class);\n            prototypeBean.addCount();\n            int count = prototypeBean.getCount();\n            return count;\n        }\n\n        @Scope(\"prototype\")\n        static class PrototypeBean {\n            private int count = 0;\n\n            public void addCount() {\n                count++;\n            }\n\n            public int getCount() {\n                return count;\n            }\n\n            @PostConstruct\n            public void init() {\n                System.out.println(\"PrototypeBean.init \" + this);\n            }\n\n            @PreDestroy\n            public void destroy() {\n                System.out.println(\"PrototypeBean.destroy\");\n            }\n        }\n    }\n}\n```\n\n- 실행해보면 `ac.getBean()` 을 통해서 항상 새로운 프로토타입 빈이 생성되는 것을 확인할 수 있다. \n- 의존관계를 외부에서 주입(DI) 받는게 아니라 이렇게 직접 필요한 의존관계를 찾는 것을 **Dependency Lookup (DL) 의존관계 조회(탐색)** 이라 한다.\n- 그런데 이렇게 스프링의 애플리케이션 컨텍스트 전체를 주입받게 되면, 스프링 컨테이너에 종속적인 코드가 되고, 단위 테스트도 어려워진다.\n- 지금 필요한 기능은 지정한 프로토타입 빈을 컨테이너에서 대신 찾아주는 **DL 정도의 기능만 제공하는 무언가**가 있으면 된다.\n\n### 🪔 ObjectFactory, ObjectProvider\n지정한 빈을 컨테이너에서 찾아주는 DL 서비스를 제공하는 것이 `ObjectProvider` 이다.\n- 과거에는 `ObjectFactory` 가 있었는데, 여러 편의 기능을 추가해 `ObjectProvider` 가 탄생했다.\n\n```java\npublic class SingletonWithPrototypeTest1 {\n\n    @Test\n    void prototypeFind() {\n        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);\n        PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);\n        prototypeBean1.addCount();\n        assertThat(prototypeBean1.getCount()).isEqualTo(1);\n\n        PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);\n        prototypeBean2.addCount();\n        assertThat(prototypeBean2.getCount()).isEqualTo(1);\n    }\n\n    @Scope(\"singleton\")\n    static class ClientBean {\n\n        @Autowired\n        private ObjectProvider<PrototypeBean> prototypeBeanProvider;\n\n        public int logic() {\n            PrototypeBean prototypeBean = prototypeBeanProvider.getObject();\n            prototypeBean.addCount();\n            return prototypeBean.getCount();\n        }\n    }\n\n    @Scope(\"prototype\")\n    static class PrototypeBean {\n        private int count = 0;\n\n        public void addCount() {\n            count++;\n        }\n\n        public int getCount() {\n            return count;\n        }\n\n        @PostConstruct\n        public void init() {\n            System.out.println(\"PrototypeBean.init\" + this);\n        }\n\n        // 호출되지 않을 것!\n        @PreDestroy\n        public void destroy() {\n            System.out.println(\"PrototypeBean.destroy\" );\n        }\n    }\n}\n```\n\n```\nPrototypeBean.init hello.core.scope.SingletonWithPrototypeTest1$PrototypeBean@5032714f\nPrototypeBean.init hello.core.scope.SingletonWithPrototypeTest1$PrototypeBean@769a1df5\n```\n\n- 출력 결과를 보면, 프로토타입 빈이 2개 생성된 것을 확인할 수 있다.\n- `prototypeBeanProvider.getObject();` 를 통해 스프링 컨테이너에서 빈을 찾아서 반환해준다. -> Dependency Lookup\n  - 스프링 컨테이너에서 찾을때, 프로토타입이므로 그때 새로 만들어서 반환한다.\n- 단위테스트를 만들거나 Mock 코드를 만들기 쉬워진다.\n\n> `ObjectFactory` 로 바꿔 수행해도 동작한다.\n> - `ObjectProvider` 는 `ObjectFactory` 를 상속받아 구현한다.\n\n**특징**\n- `ObjectFactory` : 기능이 단순, 별도의 라이브러리가 필요없고 스프링에 의존한다.\n- `ObjectProvider` : ObjectFactory를 상속받고, 옵션, 스트림 처리 등 편의 기능이 많고, 별도의 라이브러리가 필요없고 스프링에 의존한다.\n\n### 🪔 JSR-330 Provider\n`javax.inject.Provider` 라는 JSR-330 자바 표준을 사용하는 방법이다. 이를 위해서는 `javax.inject:javax.inject:1` 라이브러리를 gradle에 추가해야 한다.\n\n```Groovy\n// JSR-330 Provider 라이브러리 설정\nimplementation 'javax.inject:javax.inject:1'\n```\n\n```java\npublic interface Provider<T> {\n    T get();\n}\n```\n\n```java\n@Scope(\"singleton\")\nstatic class ClientBean {\n\n    @Autowired\n    private Provider<PrototypeBean> provider;\n\n    public int logic() {\n        PrototypeBean prototypeBean = provider.get();\n        prototypeBean.addCount();\n        return prototypeBean.getCount();\n    }\n}\n```\n\n- `provider.get()` 을 통해 항상 새로운 프로토타입 빈이 생성되는 것을 확인할 수 있다.\n  - 이 또한 스프링 컨테이너에서 빈을 찾아 반환해주는 역할을 수행한다. -> DL\n- 자바 표준이고, 기능이 단순해 단위 테스트를 만들거나 mock 코드를 만들기 쉽다.\n\n**특징**\n- `get()` 메소드 하나로 기능이 매우 단순하다.\n- 별도의 라이브러리가 필요하다.\n- 자바 표준이므로 스프링에 종속적이지 않다.\n\n> 프로토타입 빈은 매 사용마다 의존관계 주입이 완료된 새로운 객체가 필요할 때 사용하지만, 실무에서는 싱글톤 빈으로 대부분 문제를 해결하기에 직접적으로 사용할 일은 드물다.\n\n---\n\n## 🎯 웹 스코프\n\n---\n\n## 🎯 request 스코프 예제 만들기\n\n---\n\n## 🎯 스코프와 Provider\n\n---\n\n## 🎯 스코프와 프록시\n\n## 📌 중요한 개념\n\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"문제 Programmers - 지형 이동 📍 Logic BFS를 수행해서 지형별로 번호를 매긴다. 수행하면서, 높이 차가 큰 지형을 우선순위 큐에 넣어준다. 이후, 높이차를 기준으로 오름차순 정렬된 우선순위 큐에 있는 지역을 합쳐주면서 크루스칼 알고리즘을 이용해 MST를 구하면서 사다리의 총합을 구한다. 📄 CODE ✏️ Review 지역을 나누고, 서로 …","fields":{"slug":"/[Programmers]62050/"},"frontmatter":{"date":"July 31, 2022","title":"👩‍💻 62050. 지형 이동","tags":["BFS","크루스칼 알고리즘"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 지형 이동](https://programmers.co.kr/learn/courses/30/lessons/62050)\n\n### 📍 **Logic**\n\n```java\nprivate void bfs(int x, int y) {}\nprivate int find(int n) {}\nprivate void merge(int n1, int n2) {}\n```\n- BFS를 수행해서 지형별로 번호를 매긴다.\n  - 수행하면서, 높이 차가 큰 지형을 우선순위 큐에 넣어준다.\n- 이후, 높이차를 기준으로 오름차순 정렬된 우선순위 큐에 있는 지역을 합쳐주면서 크루스칼 알고리즘을 이용해 MST를 구하면서 사다리의 총합을 구한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Node {\n        int x;\n        int y;\n        \n        public Node(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Square implements Comparable<Square> {\n        int from;\n        int to;\n        int diffDist;\n        \n        public Square(int from, int to, int diffDist) {\n            this.from = from;\n            this.to = to;\n            this.diffDist = diffDist;\n        }\n        \n        @Override\n        public int compareTo(Square s) {\n            return Integer.compare(this.diffDist, s.diffDist);\n        }\n    }\n\n    class Solution {\n        private static int N;\n        private static int[] parent;\n        private static Queue<Square> pq = new PriorityQueue<>();\n        private static int[][] visited;\n        private static int[][] land;\n        private static int height;\n        private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n        private static int areaN;\n        \n        public int solution(int[][] land, int height) {\n            this.N = land.length;\n            this.height = height;\n            this.land = land;\n            \n            this.visited = new int[N][N];\n            \n            for (int i = 0; i < N; i++) \n                for (int j = 0; j < N; j++)\n                    if (visited[i][j] == 0) {\n                        areaN++;\n                        bfs(i, j);\n                    }\n            \n            this.parent = new int[areaN + 1];\n            for (int i = 0; i <= areaN; i++) parent[i] = i;\n            \n            int answer = 0;\n            while(!pq.isEmpty()) {\n                Square s = pq.poll();\n                int f = s.from;\n                int t = s.to;\n                int d = s.diffDist;\n                \n                // 같은 부모, 즉 사이클을 형성하거나, 혹은 방문한 적 없는 지형이라면 패스\n                if (find(f) == find(t) || (f == 0 || t == 0)) continue;\n                else {\n                    // 부모를 같게, 즉 사다리를 놓고 이동했음을 의미!\n                    merge(f, t);\n                    answer += d;\n                }\n            }\n            \n            return answer;\n        }\n        \n        // 이동 가능한 지형에 번호 매기기\n        private void bfs(int x, int y) {\n            visited[x][y] = areaN;\n            Queue<Node> queue = new LinkedList<>();\n            queue.offer(new Node(x, y));\n            \n            while(!queue.isEmpty()) {\n                Node node = queue.poll();\n                int tmpX = node.x;\n                int tmpY = node.y;\n                \n                for (int[] d : dir) {\n                    int nx = tmpX + d[0];\n                    int ny = tmpY + d[1];\n                    \n                    if (!isIn(nx, ny)) continue;\n                    \n                    int diff = Math.abs(land[tmpX][tmpY] - land[nx][ny]);\n                    // 지형 간의 차가 높이보다 크고, 이미 방문한 지역이라면 사다리를 놓아야 할 수도 있다.\n                    if (diff > height) {\n                        if (visited[nx][ny] != 0) \n                            pq.offer(new Square(visited[tmpX][tmpY], visited[nx][ny], diff));\n                        continue;\n                    }\n                    \n                    // 지형 간의 차가 높이보다 크지 않은 경우,\n                    // 방문한 지형이라면 패스\n                    if (visited[nx][ny] != 0) continue;\n                    // 방문한 적 없는 지형인 경우 번호 매기기\n                    else {\n                        visited[nx][ny] = areaN;\n                        queue.offer(new Node(nx, ny));\n                    }\n                }\n            }\n        }\n        \n        private boolean isIn(int x, int y) {\n            return x >= 0 && x < N && y >= 0 && y < N;\n        }\n        \n        // 재귀를 이용해 부모 지형 번호 찾기\n        private int find(int n) {\n            if (parent[n] == n) return n;\n            else return parent[n] = find(parent[n]);\n        }\n        \n        private void merge(int n1, int n2) {\n            n1 = find(n1);\n            n2 = find(n2);\n            \n            if (n1 == n2) return;\n            \n            if (n1 > n2) parent[n1] = n2;\n            else parent[n2] = n1;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 지역을 나누고, 서로 다른 지역이 맞닿는 곳을 후보로 저장해두고 이것들을 가지고 사다리 비용을 계산해봐야겠다는 생각은 했지만 어떻게 해야할지 감이 안 잡혔다.\n- 게시판을 참고하니 MST를 구하는 것이 관건인 문제였고, 참고를 통해 해결할 수 있었다 ..."},{"excerpt":"⚽️ 대회 주제 대회 주제를 찾아보다가, 행정안전부에서 제공하는 전자정부 웹사이트 품질관리 가이드라는 것을 발견했다. 가이드를 보니 사람이 하나하나 확인해야 하는 작업이었고, 웹 접근성, 호환성, 편의성 등 종류도 많았다. 문득, 이걸 자동화할 수 있는 서비스가 있다면 엄청 편리하겠다..! 라는 생각이 들었고, 이를 주제로 잡았다. ⚽️ 프로젝트 흐름 프로젝…","fields":{"slug":"/[OpenSW]1.스프링이할일/"},"frontmatter":{"date":"July 31, 2022","title":"🥊 1. 스프링이 할 일","tags":["Spring","GCP"]},"rawMarkdownBody":"\n## ⚽️ 대회 주제\n대회 주제를 찾아보다가, [행정안전부에서 제공하는 전자정부 웹사이트 품질관리 가이드](https://www.mois.go.kr/frt/bbs/type013/commonSelectBoardArticle.do?bbsId=BBSMSTR_000000000006&nttId=93477)라는 것을 발견했다. 가이드를 보니 사람이 하나하나 확인해야 하는 작업이었고, 웹 접근성, 호환성, 편의성 등 종류도 많았다.\n\n> 문득, 이걸 자동화할 수 있는 서비스가 있다면 엄청 편리하겠다..!\n\n라는 생각이 들었고, 이를 주제로 잡았다.\n\n---\n\n## ⚽️ 프로젝트 흐름\n**프로젝트는,**\n- 사용자로부터 진단 받기를 원하는 웹사이트 주소를 받는다.\n- 해당 웹사이트에 대한 정보를 보여주고, 진단 받기 버튼으로 진단을 수행할 수 있다.\n- 진단 결과를 대시보드를 통해 제공하고, 진단에 대한 피드백 또한 제공한다.\n\n위와 같은 흐름으로 진행될 것이다.\n\n이를 위해서는 품질 진단 항목과 항목별 진단 절차가 구체화되어야하고, 웹 사이트의 주소와 소스 코드를 필요로 한다.\n\n품질 진단에 대한 자료를 찾아보던 중, 구글에서 제공하는 `Lighthouse` 라는 기능을 알게 되었다.\n\n### 🏓 Lighthouse\n이는 웹페이지 품질을 측정하기 위한 자동화된 오픈 소스로, 웹 페이지의 성능, 접근성, 검색 엔진 최적화, PWA 여부 등을 측정한다.\n\n각 항목별 진단과, 결과에 대한 피드백을 제공하고 있어 개발하려는 서비스와 매우 유사한 기능을 제공하고 있었다. 그래서 이러한 기능을 가져와 함께 사용할 수 있다면 사용자에게 더 좋은 결과를 제공할 수 있을 것 같았다.\n\nlighthouse에 대해 더 자세히 알아보기 위해 [Github](https://github.com/GoogleChrome/lighthouse)를 참고하니, `node` 환경에서의 사용법만 명시되어 있었다. 어디에서도 스프링 환경에서의 사용은 찾아볼 수 없어 **node 서버**와 **스프링 서버**를 두고 사용해야 할 지에 대한 고민이 생겼다.\n\n> 하지만 이러한 방식은 비효율적인 방식으로 보일 수 밖에 없고, node 서버만을 사용하지 않고 왜 굳이 스프링 서버를 함께 운용하냐는 질문 공격을 받을 수 밖에 없어 보였다.\n\n그러던 중, 좋은 생각이 떠올랐다. \n- 어쨌든 AWS를 사용하게 되면 ssh 환경을 사용할 것이고, \n- ssh 환경에 `node` 환경을 세팅하여 shell script로서 lighthouse를 실행할 수 있다면,\n  - lighthouse는 진단 결과를 json으로 저장해주는 옵션이 있었다.\n- 그리고 스프링에서 이 shell script를 인자와 함께 실행하고 json 결과를 파싱할 수 있다면,\n\n> 굳이 node 서버는 필요가 없어지는 것이고, 스프링 서버만으로도 운용이 가능하게 되는 것이다!\n\n또한 [lighthouse-chromium](https://www.npmjs.com/package/lighthouse-chromium)을 참고하니, node-cli 환경에서도 사용이 가능했다.\n\n이를 테스트해보기 위해 AWS EC2에 스프링 서버를 배포하고, ssh 환경에 `node` , `lighthouse-chromium` 를 설치하고 사용해봤지만, 구글 크롬 브라우저를 사용해야 한다는 기본 전제에 막혀 실행이 되지 않았다...\n\n따라서 다른 방법을 강구해보다가, GCP(Google Cloud Platform) 환경에서 테스트를 성공할 수 있었다.\n- AWS EC2의 우분투 환경과 GCP의 데비안 환경의 차이때문인걸까..\n\n일단 프로젝트 진행에 있어 중요한 부분인 `lighthouse` 의 활용이 가능해졌으니 이제 스프링 서버를 세팅해보자.\n\n---\n\n## ⚽️ 스프링 서버 세팅\n> 스프링을 사용한 이유?\n> - 자바에 대한 공부를 꾸준히 하고 있다고 생각하기에 자바를 이용한 서버 프레임워크인 스프링을 사용하고자 한다.\n\n[start.spring.io](https://start.spring.io/)를 사용해 스프링부트 프로젝트를 다음과 같이 생성한다.\n\n<img src=\"../../images/2022OpenSW/서버세팅.png\" width=\"80%\">\n\n- 개발자들의 편의제공을 위한 `롬복`, `Spring Boot DevTools`\n- Spring MVC를 이용한 RESTful 서비스 개발을 위한 `Spring Web`\n- JPA 사용을 위한 `Spring Data JPA`\n- 데이터베이스로 mysql을 사용하기 위해 `MySQL Driver`\n- 또한 구현 코드에 대한 신뢰성 보장과 테스트 코드 작성, API 문서화를 위해 `Spring REST Docs`\n\n---\n\n> ❗️ 구현 코드는 [Github](https://github.com/bsonCrew/QCA_Server)에서 확인할 수 있습니다 ...."},{"excerpt":"문제 Programmers - 금과 은 운반하기 📍 Logic 운반 가능한 금, 은, 금과 은의 총 무게를 계산한다. 운반 가능한 금, 은, 금과 은의 양을 통해 광물을 모두 옮길 수 있는지 판단한다. 주어진 시간 내에 금과 은에 대해서는 운반한다해도, 총 필요한 광물 양을 만족하지 못하는 경우는 운반할 수 없으므로, 이에 대한 확인이 필요하다. 📄 CO…","fields":{"slug":"/[Programmers]86053/"},"frontmatter":{"date":"July 30, 2022","title":"👩‍💻 86053. 금과 은 운반하기","tags":["이분탐색"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 금과 은 운반하기](https://programmers.co.kr/learn/courses/30/lessons/86053)\n\n### 📍 **Logic**\n\n```java\nfor (i = 0; i < n; i++) {\n    // 초기화\n    gCur = g[i];\n    sCur = s[i];\n    wCur = w[i];\n    tCur = t[i];\n    gsCur = gCur + sCur;\n    \n    // 왕복 횟수\n    roundCnt = (long) Math.ceil((double) (T / tCur) / 2);\n    // 총 광물 무게 = 왕복 횟수 * 한 번에 운반 가능한 광물 무게\n    wAll = roundCnt * wCur;\n    \n    // 각 도시에서 운반한 금의 무게\n    gMax += Math.min(gCur, wAll);\n    // 각 도시에서 운반한 은의 무게\n    sMax += Math.min(sCur, wAll);\n    // 각 도시에서 운반한 금과 은의 무게\n    gsMax += Math.min(gsCur, wAll);\n}\n```\n\n- 운반 가능한 금, 은, 금과 은의 총 무게를 계산한다.\n\n```java\nif (a <= gMax && b <= sMax && ab <= gsMax) {\n    right = T - 1;\n    answer = T;\n} else left = T + 1;\n```\n\n- 운반 가능한 금, 은, 금과 은의 양을 통해 광물을 모두 옮길 수 있는지 판단한다.\n- 주어진 시간 내에 금과 은에 대해서는 운반한다해도, 총 필요한 광물 양을 만족하지 못하는 경우는 운반할 수 없으므로, 이에 대한 확인이 필요하다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        public long solution(int a, int b, int[] g, int[] s, int[] w, int[] t) {\n            long max = (long) (1e9 * 2 * 1e5 * 2);\n            long left = 0, right = max, T;\n            int n = g.length, i;\n            long answer = max;\n            \n            long gMax, sMax, gsMax;\n            long gCur, sCur, wCur, tCur, gsCur;\n            long roundCnt, wAll, ab = a + b;\n            \n            while (left <= right) {\n                T = (left + right) / 2;\n                gMax = sMax = gsMax = 0;\n                \n                for (i = 0; i < n; i++) {\n                    // 초기화\n                    gCur = g[i];\n                    sCur = s[i];\n                    wCur = w[i];\n                    tCur = t[i];\n                    gsCur = gCur + sCur;\n                    \n                    // 왕복 횟수\n                    roundCnt = (long) Math.ceil((double) (T / tCur) / 2);\n                    // 총 광물 무게 = 왕복 횟수 * 한 번에 운반 가능한 광물 무게\n                    wAll = roundCnt * wCur;\n                    \n                    // 각 도시에서 운반한 금의 무게\n                    gMax += Math.min(gCur, wAll);\n                    // 각 도시에서 운반한 은의 무게\n                    sMax += Math.min(sCur, wAll);\n                    // 각 도시에서 운반한 금과 은의 무게\n                    gsMax += Math.min(gsCur, wAll);\n                }\n                \n                // 운반이 가능한 경우, 더 짧은 시간을 탐색\n                if (a <= gMax && b <= sMax && ab <= gsMax) {\n                    right = T - 1;\n                    answer = T;\n                } else left = T + 1;\n            }\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 진짜 몇번을 봐도 풀이가 어렵다. 잘 이해가 안된다 ..."},{"excerpt":"문제 Programmers - 다단계 칫솔 판매 📍 Logic 자기 자신의 부모를 찾아 이익을 분배하는 함수 최종 보스를 만나거나, 더 이상 분배할 이익이 없을 때까지 수행한다. 📄 CODE ✏️ Review 고문해 시간에 이와 비슷한 개념을 배웠던 것 같아 아이디어 잡는데는 오래 걸리지 않았다. 다만 반복을 시작하는 순서를 고민하다가 시간을 많이 날렸다.","fields":{"slug":"/[Programmers]77486/"},"frontmatter":{"date":"July 29, 2022","title":"👩‍💻 77486. 다단계 칫솔 판매","tags":["Disjoint set"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 다단계 칫솔 판매](https://programmers.co.kr/learn/courses/30/lessons/77486)\n\n### 📍 **Logic**\n\n```java\nprivate void updateSellerMoney(String p, int money) {\n    while(true) {\n        if (p.equals(\"-\") || money == 0) break;\n        \n        int dist = money / 10;\n        sellerMoney.put(p, money - dist + sellerMoney.getOrDefault(p, 0));     \n        p = parent.get(p);\n        money = dist;\n    }\n}\n```\n\n- 자기 자신의 부모를 찾아 이익을 분배하는 함수\n- 최종 보스를 만나거나, 더 이상 분배할 이익이 없을 때까지 수행한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        private Map<String, Integer> sellerMoney = new HashMap<>();\n        private Map<String, String> parent = new HashMap<>();\n        private int len;\n\n        public int[] solution(String[] enroll, String[] referral, String[] seller, int[] amount) {\n            len = enroll.length;\n            initParent(enroll, referral);\n            \n            for (int i = 0; i < seller.length; i++)\n                updateSellerMoney(seller[i], 100 * amount[i]);\n\n            int[] answer = new int[len];\n            for (int i = 0; i < len; i++)\n                answer[i] = sellerMoney.getOrDefault(enroll[i], 0);\n            \n            return answer;\n        }\n\n        private void updateSellerMoney(String p, int money) {\n            while(true) {\n                if (p.equals(\"-\") || money == 0) break;\n                \n                int dist = money / 10;\n                sellerMoney.put(p, money - dist + sellerMoney.getOrDefault(p, 0));     \n                p = parent.get(p);\n                money = dist;\n            }\n        }\n\n        private void initParent(String[] enroll, String[] referral) {\n            for (int i = 0; i < len; i++)\n                parent.put(enroll[i], referral[i]);\n        }\n    }\n\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 고문해 시간에 이와 비슷한 개념을 배웠던 것 같아 아이디어 잡는데는 오래 걸리지 않았다.\n- 다만 반복을 시작하는 순서를 고민하다가 시간을 많이 날렸다."},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 빈 생명주기 콜백 DB 커넥션 풀이나, 네트워크 소켓처럼 애플리케이션 시작 지점에 필요한 연결을 미리 해두고, 애플리케이션 종료 시점에 연결을 모두 종료하는 작업을 진행하려면, 객체의 초기화와 종료 작업이 필요하다. 이를 스프링을 통해 진행하는지 알아본다. 외부 네트워크에 미리 연결하는 객…","fields":{"slug":"/[스프링핵심원리_기본편]8.빈생명주기콜백/"},"frontmatter":{"date":"July 29, 2022","title":"📟 8. 빈 생명주기 콜백","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 빈 생명주기 콜백\nDB 커넥션 풀이나, 네트워크 소켓처럼 애플리케이션 시작 지점에 필요한 연결을 미리 해두고, 애플리케이션 종료 시점에 연결을 모두 종료하는 작업을 진행하려면, 객체의 초기화와 종료 작업이 필요하다.\n- 이를 스프링을 통해 진행하는지 알아본다.\n\n외부 네트워크에 미리 연결하는 객체를 하나 생성한다고 가정해보자. 실제로 네트워크에 연결하는 것은 아니고, 단순히 문자만 출력하도록 했다. \n- 이 `NetworkClient` 는 애플리케이션 시작 시점에 `connect()` 를 호출해서 연결을 맺어두어야 하고, 애플리케이션이 종료되면 `disConnect()` 를 호출해서 연결을 끊어야 한다.\n\n```java\npackage hello.core.lifecycle;\n\npublic class NetworkClient {\n\n    private String url;\n\n    public NetworkClient() {\n        System.out.println(\"생성자 호출, url = \" + url);\n        connect();\n        call(\"초기화 연결 메세지\");\n\n    }\n\n    public void setUrl(String url) {\n        this.url = url;\n    }\n\n    // 서비스 시작 시 호출\n    public void connect() {\n        System.out.println(\"connect: \" + url);\n    }\n\n    public void call(String message) {\n        System.out.println(\"call: \" + url + \" message = \" + message);\n    }\n\n    // 서비스 종료 시 호출\n    public void disconnect() {\n        System.out.println(\"close \" + url);\n    }\n}\n```\n\n```java\npackage hello.core.lifecycle;\n\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.ConfigurableApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\npublic class BeanLifeCycleTest {\n\n    @Test\n    public void lifeCycleTest() {\n        ConfigurableApplicationContext ac = new\n                AnnotationConfigApplicationContext(LifeCycleConfig.class);\n        NetworkClient client = ac.getBean(NetworkClient.class);\n        ac.close(); \n    }\n\n    @Configuration\n    static class LifeCycleConfig {\n        @Bean\n        public NetworkClient networkClient() {\n            NetworkClient networkClient = new NetworkClient();\n            networkClient.setUrl(\"http://hello-spring.dev\");\n            return networkClient;\n        }\n    }\n}\n```\n\n- `ac.close()` 를 이용해 `ConfigurableApplicationContext` 를 닫아줘야 한다.\n  - `ApplicationContext` -> 자식 -> `ConfigurableApplicationContext` -> 자식 -> `AnnotationConfigApplicationContext` \n\n```\n생성자 호출, url = null\nconnect: null\ncall: null message = 초기화 연결 메세지\n```\n\n- 생성자 부분을 보면 `url` 정보 없이 connect가 호출되는 것을 확인할 수 있다.\n- 당연하게도 객체를 생성하는 단계에는 `url` 이 없고, 객체를 생성한 다음에 외부에서 수정자 주입을 통해서 `setUrl()` 이 호출되어야 `url` 이 존재하게 된다.\n\n스프링 빈은 다음과 같은 라이프사이클을 가진다.\n- **객체 생성** -> **의존관계 주입**\n\n스프링 빈은 객체를 생성하고, 의존관계 주입이 다 끝난 다음에야 필요한 데이터를 사용할 수 있는 준비가 완료된다. 따라서 **초기화 작업은 의존관계 주입이 모두 완료되고 난 다음에 호출해야 한다.** 그런데 개발자가 의존관계 주입이 모두 완료된 시점을 어떻게 알 수 있을까?\n\n**스프링은 의존관계 주입이 완료되면 스프링 빈에게 콜백 메서드를 통해서 초기화 시점을 알려주는 다양한 기능을 제공**한다. 또한 **스프링은 스프링 컨테이너가 종료되기 직전에 소멸 콜백**을 준다. 따라서 안전하게 종료 작업을 진행할 수 있다.\n\n**스프링 빈의 이벤트 라이프사이클**\n- 스프링 컨테이너 생성 -> 스프링 빈 생성 -> 의존관계 주입 -> 초기화 콜백 -> 사용 -> 소멸 전 콜백 -> 스프링 종료\n\n> 생성자 주입 시에는 스프링 빈 생성 시에 의존관계 주입이 어느 정도 발생한다.\n\n> **객체의 생성과 초기화를 분리하자!!!**\n> - 생성자는 필수 정보를 받고, 메모리를 할당해서 객체를 생성하는 책임을 가진다.\n> - 초기화는 이렇게 생성된 값들을 활용해 외부 커넥션을 연결하는 등 무거운 동작을 수행한다.\n> \n> 따라서, 이 둘을 분리하는 것이 유지보수 관점에서 좋다.\n\n스프링은 다양한 방식으로 생명주기 콜백을 지원한다.\n- 인터페이스(InitializingBean, DisposableBean) \n- 설정 정보에 초기화 메서드, 종료 메서드 지정 \n- @PostConstruct, @PreDestroy 애노테이션 지원\n\n---\n\n## 🎯 인터페이스 InitializingBean, DisposableBean\n\n```java\npackage hello.core.lifecycle;\n\nimport org.springframework.beans.factory.DisposableBean;\nimport org.springframework.beans.factory.InitializingBean;\n\npublic class NetworkClient implements InitializingBean, DisposableBean {\n\n    private String url;\n\n    public NetworkClient() {\n        System.out.println(\"생성자 호출, url = \" + url);\n    }\n\n    public void setUrl(String url) {\n        this.url = url;\n    }\n\n    // 서비스 시작 시 호출\n    public void connect() {\n        System.out.println(\"connect: \" + url);\n    }\n\n    public void call(String message) {\n        System.out.println(\"call: \" + url + \" message = \" + message);\n    }\n\n    // 서비스 종료 시 호출\n    public void disconnect() {\n        System.out.println(\"close \" + url);\n    }\n\n    @Override\n    public void afterPropertiesSet() throws Exception {\n        connect();\n        call(\"초기화 연결 메세지\");\n    }\n\n    @Override\n    public void destroy() throws Exception {\n        disconnect();\n    }\n}\n```\n\n- `InitializingBean` 클래스의 `afterPropertiesSet()` 는 의존관계 주입이 끝나면 호출할 함수이다.\n- `DisposableBean` 클래스의 `destroy()` 는 반대로 소멸 시에 사용한다.\n\n```\n생성자 호출, url = null\nconnect: http://hello-spring.dev\ncall: http://hello-spring.dev message = 초기화 연결 메세지\n10:38:33.502 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@cd3fee8, started on Sun Jul 31 10:38:33 KST 2022\nclose http://hello-spring.dev\n```\n\n- 출력 결과를 보면 **초기화 메소드가 주입 완료 후에 적절하게 호출**된 것을 확인할 수 있다.\n- 그리고 스프링 컨테이너의 종료가 호출되자 **소멸 메소드가 호출**된 것도 확인할 수 있다.\n\n### 🪔 초기화, 소멸 인터페이스 단점\n- 이 인터페이스는 스프링 전용 인터페이스다. 해당 코드가 스프링 전용 인터페이스에 의존한다. \n- 초기화, 소멸 메서드의 이름을 변경할 수 없다.\n- 내가 코드를 고칠 수 없는 외부 라이브러리에 적용할 수 없다.\n\n> 이렇게 인터페이스를 사용하는 방법은 초창기의 방법이다. 최근에는 더 개선한 방법을 사용한다.\n\n---\n\n## 🎯 빈 등록 초기화, 소멸 메소드\n설정 정보에 `@Bean(initMethod=\"init', destroyMethod=\"close\")` 처럼 초기화, 소멸 메소드를 지정할 수 있다.\n\n```java\npackage hello.core.lifecycle;\n\nimport org.springframework.beans.factory.DisposableBean;\nimport org.springframework.beans.factory.InitializingBean;\n\npublic class NetworkClient {\n\n    private String url;\n\n    public NetworkClient() {\n        System.out.println(\"생성자 호출, url = \" + url);\n    }\n\n    public void setUrl(String url) {\n        this.url = url;\n    }\n\n    // 서비스 시작 시 호출\n    public void connect() {\n        System.out.println(\"connect: \" + url);\n    }\n\n    public void call(String message) {\n        System.out.println(\"call: \" + url + \" message = \" + message);\n    }\n\n    // 서비스 종료 시 호출\n    public void disconnect() {\n        System.out.println(\"close \" + url);\n    }\n\n    public void init() {\n        connect();\n        call(\"초기화 연결 메세지\");\n    }\n\n    public void close() {\n        disconnect();\n    }\n}\n```\n\n```java\npackage hello.core.lifecycle;\n\npublic class BeanLifeCycleTest {\n\n    ...\n\n    @Configuration\n    static class LifeCycleConfig {\n        @Bean(initMethod = \"init\", destroyMethod = \"close\")\n        public NetworkClient networkClient() {\n            NetworkClient networkClient = new NetworkClient();\n            networkClient.setUrl(\"http://hello-spring.dev\");\n            return networkClient;\n        }\n    }\n}\n```\n\n- 정상적으로 적용이 된 것을 확인할 수 있다.\n\n### 🪔 설정 정보 사용 특징\n- 메소드 이름을 자유롭게 가질 수 있다.\n- 스프링 빈이 스프링 코드에 의존하지 않는다.\n- 코드가 아니라 설정 정보를 사용하여 코드를 고칠 수 없는 외부 라이브러리에도 초기화, 종료 메소드를 적용할 수 있다.\n\n### 🪔 종료 메소드 추론\n- `@Bean` 의 `destroyMethod` 속성에는 아주 특별한 기능이 있다.\n- 라이브러리는 대부분 `close` , `shutdown` 이라는 이름의 종료 메서드를 사용한다.\n- `@Bean` 의 `destroyMethod` 는 기본값이 `(inferred)` (추론)으로 등록되어 있다.\n- 이 추론 기능은 `close` , `shutdown` 라는 이름의 메서드를 자동으로 호출해준다. 이름 그대로 종료 메서드를 추론해서 호출해준다.\n- 따라서 직접 스프링 빈으로 등록하면 종료 메서드는 따로 적어주지 않아도 잘 동작한다.\n- 추론 기능을 사용하기 싫으면 `destroyMethod=\"\"` 처럼 빈 공백을 지정하면 된다.\n\n---\n\n## 🎯 어노테이션 @PostConstructor, @PreDestroy\n```java\npackage hello.core.lifecycle;\n\nimport org.springframework.beans.factory.DisposableBean;\nimport org.springframework.beans.factory.InitializingBean;\n\nimport javax.annotation.PostConstruct;\nimport javax.annotation.PreDestroy;\n\npublic class NetworkClient {\n\n    private String url;\n\n    public NetworkClient() {\n        System.out.println(\"생성자 호출, url = \" + url);\n    }\n\n    ...\n\n    @PostConstruct\n    public void init() {\n        connect();\n        call(\"초기화 연결 메세지\");\n    }\n\n    @PreDestroy\n    public void close() {\n        disconnect();\n    }\n}\n```\n\n- `javax.annotation` 패키지의 `PostConstruct` 와 `PreDestroy` 어노테이션을 사용한다.\n  - 자바 진영에서 공식적으로 지원하는 패키지이므로 스프링이 아닌 다른 컨테이너를 사용해도 적용이 가능하다.\n\n### 🪔 @PostConstructor, @PreDestroy 특징\n- 최신 스프링에서 권장하는 방법으로, 어노테이션 하나만 붙이면 되기에 매우 편리하다.\n- 스프링에 종속적인 기술이 아닌 JSR-250라는 자바 표준이다.\n- 컴포넌트 스캔과 잘 어울린다.\n- 유일한 단점은 외부 라이브러리에는 적용하지 못한다는 것이다. 외부 라이브러리를 초기화, 종료 해야 하면 `@Bean` 의 기능을 사용하자.\n\n## 📌 중요한 개념\n빈 생명 주기, 스프링 빈의 이벤트 라이프사이클\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"🧷 Process 프로세스는 실행 중인 프로그램이다. (프로세스는 active하고, 프로그램은 passive하다.) 하나의 프로그램 안에는 여러 개의 프로세스가 존재할 수 있다. 🪚 Process Memory Layout 프로세스를 메모리 공간을 어떻게 사용할까? 32bit라고 가정하여 각 프로세스에는 위와 같은 형태의 가상 메모리가 4GB( = 4GB)…","fields":{"slug":"/[OS]Process&Thread/"},"frontmatter":{"date":"July 26, 2022","title":"🧩 Process & Thread","tags":["OS","Process"]},"rawMarkdownBody":"\n## 🧷 Process\n프로세스는 실행 중인 프로그램이다. (프로세스는 active하고, 프로그램은 passive하다.)\n\n> 하나의 프로그램 안에는 여러 개의 프로세스가 존재할 수 있다.\n\n### 🪚 Process Memory Layout\n프로세스를 메모리 공간을 어떻게 사용할까?\n\n<img src=\"../../images/OS/processMemoryLayout.jpeg\" width=\"30%\">\n\n- 32bit라고 가정하여 각 프로세스에는 위와 같은 형태의 가상 메모리가 4GB($2^{32}$ = 4GB) 할당된다.\n- 먼저, 프로세스의 메모리는 크게 **User space**와 **Kernel space**로 나뉜다.\n  - Kernel space는 **모든 프로세스가 공유하는 공간**으로, 시스템콜이 필요한 경우 이 영역을 거쳐 커널에 작업을 요청한다.\n  - User space는 공유되지 않는 공간으로, 시스템콜(Kernel space)을 거치지 않고, 직접 접근하게 되면 Segmentation fault가 발생한다.\n- Kernel space에는 1GB, User space에는 3GB가 할당된다.\n\n**Kernel Stack**\n- 각 프로세스에 할당되는 스택으로, 시스템콜을 호출하여 Kernel로 이동했을 때, 파라미터, 반환 값을 저장하기 위한 영역으로 사용된다.\n\n**Stack area**\n- 호출되는 함수의 파라미터, 지역 변수, 반환 값을 저장하는 영역이다.\n- max를 기준으로 사용될 때마다 아래로 공간이 사용된다.\n\n**Heap area**\n- 동적 할당 메모리를 처리하는 영역이다.\n- 스택과 반대방향으로 공간이 사용된다.\n\n> Stack과 Heap은 오버플로우 발생 시 서로의 영역을 침범할 수도 있다.\n\n**Data segment**\n- 전역 변수가 저장되는 영역이다.\n- 매우 작은 공간을 가진다.\n\n**Text segment**\n- 프로그램 code(Binary)가 위치하는 영역이다.\n  - 소스 코드를 실행하면 이 영역으로 복사된다.\n- Program Counter는 이 영역 안에서 이동한다.\n\n### 🪚 Process State\nProcess Life Cycle이라고도 한다. 프로세스는 아래의 5가지 상태를 가질 수 있다.\n\n<img src=\"../../images/OS/processStates.jpeg\" width=\"60%\">\n\n**new**\n- 새로운 프로세스가 생성됨, 하지만 아직 Process Pool로의 진입이 허용되지 않은 프로세스\n\n**ready**\n- ready queue(process pool)에서 프로세서에 할당되기를 대기하는 상태\n\n**running**\n- ready queue에서 OS가 특정 알고리즘에 의해 한 프로세스를 동작\n- single core의 경우 어느 한 시점에서나 항상 1개의 프로세스만을 실행\n\n**waiting**\n- 이벤트의 발생을 기다리는 프로세스, wait queue에서 대기\n- 특히 I/O completion을 기다리는 프로세스가 위치\n\n**terminated**\n- 종료(중단)된 프로세스\n\n**preempted**\n- 한 프로세스가 일정 시간 이상 CPU를 사용하여 다른 프로세스의 동작을 위해 다시 ready queue로 이동\n\n### 🪚 Process Control Block\nPCB: 프로세스를 표현하는 커널 안의 자료구조이다.\n- 주요 역할은 수행 프로세스를 인터럽트한 후 나중에 그 인터럽트가 발생되지 않은 것처럼 프로세스 수행을 재개할 수 있도록 충분한 정보를 유지하는 것이다.\n- 따라서, 스위칭이 되어도 그 전 상태를 기억하고 재개할 수 있다.\n\n<img src=\"../../images/OS/PCB.jpeg\" width=\"40%\"> \n\n**process state**\n- 위에서 다룬 프로세스의 상태\n\n**PID**\n- 유일한 프로세스 식별자\n\n**PC**\n- 프로그램에서 다음 수행할 명령어의 주소\n\n**Registers**\n- CPU 레지스터, 범용 레지스터 등의 정보\n\n**CPU Scheduling info**\n- 스케줄링 및 프로세스 우선 순위\n\n**Accounting info**\n- CPU time usage, Job와 같이 계속 추적하며 저장하는 정보\n\n### 🪚 Process Switch\n**두 프로세스 간의 스위칭**\n<img src=\"../../images/OS/PS.jpeg\" width=\"80%\">\n\n- 프로세스 0이 실행되다가, 시스템 콜 또는 인터럽트가 발생하면, 프로세스 0이 잠시 OS를 대신하여 PCB 0에 현재 프로세스의 상태를 저장하고, PCB 1에 저장된 프로세스 1의 상태를 불러온다.\n- 이후, 프로세스 1이 실행되고, 프로세스 0은 idle한 상태가 된다.\n\n> CPU는 쉬지 않고 프로세스를 동작시킨다.\n\n**시스템 콜의 핸들링**\n<img src=\"../../images/OS/syscallHand.jpeg\" width=\"80%\">\n\n- 프로세스 0이 실행되다가 시스템 콜 호출로 인해 kernel mode로 진입했다가 다시 돌아온다.\n- 시스템 콜 핸들링 이후, 마지막에 어느 프로세스로 반환할 지 결정하는 것이 스케줄링이다.\n\n### 🪚 Context Switch = Process Switch\nContext는 PCB에 저장되어 있는 프로세스의 상태를 의미하고, 이는 곧 프로세스의 현재 상태를 의미한다.\n\n**Context Switch는 Saving과 Restoring을 수행한다.**\n- 현 프로세스의 상태를 저장하고, 다른 프로세스의 상태를 불러온다.\n- 실행 중인 애플리케이션 입장에서, 도움이 되는 행위가 아니라 관리 행위에 불과하기에, **무조건적으로 빠르게 실행되어야 한다.**\n\n**HW support로 스위칭 타임 감소**\n- CPU에 multiple register set이 존재한다면, 원래 메모리에 프로세스의 register 값을 모두 저장하는 방식에서 단순히 포인터를 바꾸는 것으로 대체 가능하다.\n- 하지만 이러한 방식은 set 수에 의존적이므로, 프로세스의 수가 추가되고, 레지스터 set의 수가 한정적이라면 memory copy는 막을 수 없다.\n\n### 🪚 Dispatcher\n프로세스 스케줄링을 통해 선택된 프로세스에 CPU의 제어를 전해주는 컴포넌트이다. \n- 프로그램이 실행되다 중단되고, 다음 프로그램을 실행하게 해주는 프로그램이라 할 수 있다.\n- `ready` -> `running` 단계에서, 스케줄러 또는 디스패처가 준비상태에 있는 프로세스 중 하나를 선택해 실행하게 한다.\n\n**Dispatch Latency**\n- 하나의 프로세스를 중단시키고, 다른 프로세스를 실행하도록 하기 위해 걸리는 시간을 의미한다.\n- 이는 그저 동작을 위한 관리 차원의 오버헤드이므로 최대한 짧게 이뤄져야 한다.\n\n### 🪚 Process 동작\n프로세스는 부모와 자식 프로세스로 나눌 수 있다.\n- 부모 프로세스가 `fork()` 함수를 이용해 자식 프로세스를 생성할 수 있다.\n  - 자식 프로세스는 부모 프로세스가 다른 일 처리를 시키기 위해 생성한다.\n  - 부모 프로세스와 자식 프로세스는 병렬적으로 동작하고, 부모 프로세스는 자식 프로세스의 종료를 기다려야 한다.\n- 이때, 생성된 자식 프로세스 또한 메모리가 필요한데, 2가지 방식이 있다.\n  - **새로운 메모리 할당**\n    - 프로세스 간 메모리 밸런스가 맞지 않는 문제가 발생할 수 있다.\n  - **부모 프로세스의 자원을 공유**\n    - 부모 프로세스의 한정적 자원에 제한적이다. 즉, 제한적인 자식 프로세스의 생성으로 인해 성능의 저하를 유발할 수 있다.\n\n### 🪚 Process 종료\n프로세스는 종료를 위해 `exit()` 시스템 함수를 호출해야 한다.\n- 이때 자식 프로세스의 경우는 부모 프로세스에게 상태 값을 반환한다. (0인 경우 성공적인 종료, 그 외의 값은 에러를 의미)\n- 종료 시, 프로세스의 자원이 해제된다.\n\n**부모 프로세스가 자식 프로세스를 종료시키는 경우**\n- 자식 프로세스가 더 이상 필요없는 경우 (원하는 작업이 다 수행된 경우)\n- 자식 프로세스가 너무 많은 자원을 사용하는 경우\n- 부모 프로세스가 종료해야 하는 경우\n  - 부모 프로세스가 종료되기 전, 모든 자식 프로세스가 종료되어야 한다.\n\n부모 프로세스는 `wait()` 시스템 함수를 사용해 자식 프로세스가 종료하는 것을 기다릴 수 있다. 자식의 상태 값을 반환받는다. 하지만 부모 프로세스가 `wait()` 를 호출하지 않아 자식 프로세스의 상태 값이 전달되지 않는다면 어떻게 될까?\n\n### 🪚 좀비 프로세스\n종료가 되었지만, 부모 프로세스가 아직 `wait()` 를 호출하지 않은 프로세스를 좀비 프로세스라고 한다.\n- 부모 프로세스가 `wait()` 를 호출하기 전까지 OS가 자식 프로세스의 상태 값을 저장하고 있다.\n- 만약 계속 `wait()` 가 호출되지 않는다면, 좀비 프로세스의 수는 증가할 것이고, OS에 계속 상태 값이 저장될 것이다.\n- 이를 방지하기 위해, 제일 첫번째로 실행되는 프로세스인 `init` 이 주기적으로 `wait()` 를 호출하여 좀비 프로세스를 제거한다.\n\n### 🪚 고아 프로세스\n좀비 프로세스와 비슷한 개념으로, 부모 프로세스가 `wait()` 를 호출하는 대신에 그냥 종료를 해버린 경우이다.\n- 이 경우, 고아 프로세스의 새로운 부모 프로세스로 `init` 프로세스를 지정한다.\n- 위에서 언급했듯 주기적인 `wait()` 호출을 통해 정상적인 종료가 가능하도록 한다.\n\n### 🪚 IPC\nInter Process Communication으로, 프로세스들끼리 서로 데이터를 주고 받는 행위 또는 그 방법을 말한다.\n- 프로세스는 **완전히 독립된 실행객체**이다. 이는 다른 프로세스의 영향을 받지 않는다는 장점이 있다.\n- 그렇기에, 서로 간의 통신이 어렵다는 문제가 있다.\n\n이를 위해 커널 영역에서 IPC라는 내부 프로세스 간 통신을 제공한다. IPC의 종류로는 2가지가 있다.\n\n**메세지 전달(Message Passing)**\n- 커널이 제공하는 API를 이용해 커널 공간을 통해 통신한다. **메세지 큐**를 사용해 송신 프로세스는 큐에 insert하고, 수신 프로세스에서 pop하여 상호 간의 통신을 수행한다. 메세지 큐는 커널에서 관리한다.\n- 이는 구현이 비교적 쉽다는 장점이 있지만, 시스템 함수 사용으로 인한 오버헤드가 발생한다.\n  - 파이프 (한쪽에서는 쓰기만 가능하고, 한쪽에서는 읽기만 가능, 주로 부모-자식 간 단방향 통신에서 사용)\n  - 소켓 (클라이언트-서버 구조로 통신, 원격에서 프로세스 간 데이터 공유 시 사용)\n\n**메모리 공유(Shared Memory)**\n- 프로세스끼리 특정 공통의 메모리 영역을 공유하며 상호 간 통신하는 방법이다.\n- 데이터 자체를 공유하도록 하며, 한 프로세스에서 변경한 메모리 공간의 내용을 다른 프로세스에서 접근할 수 있다.\n- 공유 메모리 또한 커널에서 관리된다.\n- 커널 의존도가 낮아 속도가 빠르고 통신이 자유롭다는 장점이 있지만, 자원과 데이터를 공유하기에 동기화 이슈가 발생한다.\n\n---\n\n## 🧷 Thread\n프로세스 내에서 실행되는 여러 흐름의 단위다.\n- 각 쓰레드는 서로 다른 PC 값을 가지고, register 값과 stack area도 공유하지 않는다.\n- 프로세스 내 주소 공간이나 힙 공간 등은 쓰레드끼리 공유하여 사용한다.\n- 하나의 프로세스는 하나 이상의 쓰레드를 가질 수 있다.\n\n> 모든 쓰레드는 서로 다른 코드와 함수를 실행한다.\n\n<img src=\"../../images/OS/thread.jpeg\" width=\"80%\">\n\n**왜 쓰레드를 사용할까?**\n- 병렬처리로 인한 성능 증가\n  - 하나의 작업에 하나의 프로세스를 할당하면, 작업이 증가할수록 프로세스 수도 증가하게 되고 이는 많은 시간을 소모한다.\n  - 쓰레드는 일종의 가벼운 프로세스라고 할 수 있다.\n  - 프로세스보다 생성에 대한 오버헤드가 덜 발생한다.\n    - `clone()` 시스템 함수 사용으로 memory copy가 발생하지 않아 더 빠르다.\n- 자원을 효율적으로 사용할 수 있다.\n  - 프로세스는 생성부터 많은 자원을 사용한다.\n- 데이터의 공유가 쉽다.\n  - 프로세스의 경우는 IPC를 통해서만 프로세스 간 통신이 가능하고 데이터의 공유가 가능하다.\n  - 쓰레드는 데이터의 공유가 프로세스보단 쉽지만, 제어가 필요하다. (동기화 문제) 또한 race condition이 발생할 수 있다.\n\n### 🪚 Concurrency vs. Parallelism\n**Parallelism** -> timing\n<img src=\"../../images/OS/parallel.jpeg\" width=\"40%\">\n\n- 한 시점에 두 개가 동시에 동작\n\n**Concurrency** -> timing X\n<img src=\"../../images/OS/concur.jpeg\" width=\"50%\">\n\n- 작업의 순서가 존재, 단계를 돌면서 작업을 수행한다.\n\n> Concurrent하면 Parallel할 수 없고, Parallel하면 Concurrent할 수 있다.\n\n### 🪚 Parallelism 종류\n**Data Parallelism** -> 데이터를 분할하여 같은 task를 수행\n- ex. sum\n  - single core: sum[0] ~ sum[N - 1] => 순차적인 수행\n  - dual core: sum[0] ~ sum[N/2 - 1], sum[N/2] ~ sum[N - 1] => 병렬 수행\n\n**Task Parallelism** -> 여러 task를 병렬 수행\n- ex. Avg, sum\n  - core 1 : avg 수행\n  - core 2 : sum 수행\n\n### 🪚 Multithreading models\n**User-level Thread**\n- TCB와 명령들이 user level library에 의해 관리된다.\n- OS Kernel은 user threads가 얼마나 동작되는지 알 수 없다.\n- OS의 개입이 없기 때문에 OS의 스케줄링 또한 제공받지 못한다.\n\n**Kernel-level Thread**\n- 시스템 함수를 이용해서만 가능하다.\n- OS Kernel이 thread가 어느 프로세스에서 동작하는지 확인할 수 있다.\n- OS의 스케줄링을 제공받을 수 있다.\n\n> 누가 Thread table을 관리하느냐가 주된 차이!\n\n### 🪚 Multiplexing User Threads\n여러 user threads 중 1개를 CPU로 전달한다.\n\n<img src=\"../../images/OS/multiplexing.jpeg\" width=\"80%\">\n\n- N-to-one model : user thread가 CPU로 접근 X -> 이로 인한 장점과 단점 발생\n- 1-1 model : kernel의 도움으로 user thread를 생성\n- Many-to-many model : 가작 최적의 threads 사용, user thread - kernel thread 간 매핑은 OS가 관리 (계속 변화)\n\n### 🪚 Thread Library\n쓰레드 생성과 관리를 위한 API\n\n**implement**\n- in user space (= user thread)\n  - kernel의 도움이 없다. 즉 시스템 함수의 호출이 없다.\n- kernel-level library (= kernel thread)\n  - API 호출이 시스템 함수를 호출한다.\n\n**main thread libraries**\n- POSIX pthread : none windows 환경에서 유일하게 사용 가능한 라이브러리\n  - kernel-level 사용\n- Windows thread API\n  - kernel-level 사용\n- Java thread API\n  - 다른 라이브러리보다 상위 라이브러리\n  - OS 위에 JVM을 두고 동작히기에, 리눅스 환경에서 Java API는 pthread API를 호출한다.\n\n### 🪚 Thread Pool\n매번 요청이 있을 때마다, 새로운 쓰레드를 생성하고 사용하고, 소멸시키는 것은 많은 요청이 발생하는 경우 오버헤드로 작용한다.\n- 물론 프로세스의 경우보다는 덜 발생한다.\n\n따라서, 컴퓨터 또는 프로그램의 시작부에서, 고정된 수의 쓰레드들을 생성하여 관리하는 **Thread Pool**이 발생했다.\n- 새로운 요청이 들어오면, pool에서 동작하지 않는 쓰레드를 선택하여 요청을 처리한다.\n- 요청 처리가 완료되면, 해당 쓰레드를 다시 pool로 반환한다.\n  - 만약 pool에 가능한 쓰레드가 없다면 대기한다.\n- 요청이 많은 경우, 요청 처리에 대한 지연이 문제가 될 수 있다.\n\n---\n\n## 🧷 MultiProcess vs. MultiThread\n### 🪚 MultiProcess\n하나의 응용 프로그램을 여러 개의 프로세스로 구성하여 각 프로세스가 하나의 작업을 처리하도록 하는 것이다.\n\n- 장점\n  - 여러 자식 프로세스 중 하나에 문제가 발생하면 해당 프로세스만 소멸시키는 것으로 영향의 확산을 방지할 수 있다.\n- 단점\n  - Context Switching에서의 오버헤드\n    - 메모리 복사, 초기화 등 시간이 소모되는 작업으로 인한 오버헤드가 발생한다.\n  - 복잡하고 어려운 IPC\n    - 프로세스는 독립적이다. 하지만 이러한 독립성으로 인해 데이터의 공유가 어렵다.\n\n### 🪚 MultiThread\n하나의 응용 프로그램을 여러 개의 쓰레드로 구성하고 각 쓰레드가 하나의 작업을 처리하도록 하는 것이다.\n\n- 장점\n  - 시스템 자원의 효율성 증대\n    - 프로세스를 생성하여 자원을 할당하는 시스템 함수가 줄어 효율적인 자원 관리가 가능하다.\n  - 시스템 처리량 증가\n    - 쓰레드 간 데이터의 공유가 쉽고, 자원 소모가 감소한다.\n    - Context Switching이 빠르다.\n- 단점\n  - 프로세스 밖에서 쓰레드를 제어할 수 없다.\n  - 멀티 쓰레드의 경우, 자원 공유에 대한 제어가 필요하다 (동기화 문제)\n  - 하나의 쓰레드에 문제가 발생하면 전체 프로세스가 영향을 받는다.\n\n---\n\n## 🧷 Process Scheduling\n스케줄링을 하는 이유는 CPU의 사용을 최대화하기 위함이다.\n- **Multi-programming**: 여러 프로그램을 메모리에 올려두고 실행하는 것으로, CPU 사용 최대화를 위함이다.\n- **Time-sharing**: CPU의 시간을 잘게 나눠 여러 사용자가 사용할 수 있도록 하는 것으로, 여러 프로그램을 빠르게 스위칭하면서 동작한다. 이는 스케줄링을 하기 위함이다.\n  - 병렬적으로 동작하는 것이 아니라, 병렬적인 것처럼 보이게 매우 빠르게 동작한다.\n\n> 프로세스 스케줄링이란, 프로세서에서 실행할 다음 프로세스를 선택하는 것이다.\n\n**스케줄링 큐**\n- 메모리에 저장되는 큐로, 3가지 종류가 있다.\n- Job Queue: Ready Queue 전에 프로세스가 로드되는 큐이다. 즉, 모든 프로세스가 저장될 수 있다.\n- Ready Queue: 실행 준비가 된 프로세스를 저장하는 큐이다. PCB들의 연결리스트로 구현된다.\n- Device Queue: Wait Queue 또는 I/O Queue로도 불리는 큐로, I/O device를 대기하는 프로세스가 저장되는 큐이다.\n  - 각각의 디바이스들은 모두 각자의 Device Queue를 가지고, 작업이 완료되면 다시 Ready QUeue로 돌아간다.\n\n> 프로세스는 3가지 종류의 큐를 이동하면서 동작한다.\n\n**Queuing Diagram**\n<img src=\"../../images/OS/queuingDiag.jpeg\" width=\"80%\">\n\n- 프로세스가 Ready Q로 전달된다. \n  - Ready Q에서는 특정 알고리즘에 의해 CPU에서 동작시킬 프로세스를 결정하여 CPU로 전달한다.\n- CPU에서는,\n  - 프로세스가 작업을 모두 완료하고 종료된다.\n  - I/O 이슈로 인해 I/O Q로 전달되어 block되었다가, 작업을 완료한 후 다시 Ready Q로 프로세스를 전달한다.\n  - 특정 프로세스가 일정 시간 이상 CPU를 사용하여 다시 Ready Q로 전달한다. (OS가 타이머를 동작시켜 인터럽트를 발생시킨다.)\n\n### 🪚 Scheduler\n일종의 함수로, 다음 실행할 프로세스를 선택한다.\n- 정책에 의해 Queue로부터 프로세스를 선택한다.\n\n> **디스패처와 스케줄러의 차이?**\n> - 스케줄러는 다음에 실행할 프로세스를 선택하는 작업을 처리하고, 디스패처는 실제로 CPU를 프로세스에 할당하는 작업을 처리한다.\n\n**Long-term scheduler**\n= Job scheduler\n- 많은 job 중 일부를 선택하여 Ready Q에 push한다.\n  - job = 모든 processes\n\n**Short-term scheduler**\n= CPU scheduler\n- Ready Q에 있는 프로세스를 선택하여 CPU에 전달한다.\n  - 이때 특정 알고리즘이 필요하다.\n\n**Process type**\n- I/O bound -> I/O 작업 처리 시간이 더 긴 프로세스\n- CPU bound -> CPU 작업 처리 시간이 더 긴 프로세스\n- Long-term scheduler는 I/O bound와 CPU bound의 균형이 좋은 job을 선택해야 한다.\n  - 균형이 맞지 않다면 CPU나 I/O device 중 하나가 idle한 경우가 발생하게 될 테고, CPU는 항상 최대한 사용량을 높이는 것을 목표로 하기에 올바르지 않은 사용이 된다.\n\n**스케줄링 Criteria(Metric)**\n- CPU 활용성\n  - 사용률을 100%로 요구하지만, 실제로는 불가능하다. 100%에 근접하게 되면 다른 criteria를 해치게 된다.\n- 처리량\n  - 하나의 unit time에 처리하는 작업의 수를 최대화해야 한다.\n- 처리 시간\n  - 프로세스의 작업이 끝날 때까지 걸리는 시간을 의미하고, 처리량과 반비례 관계이다.\n- 평균 대기 시간\n  - Ready Queue에서 프로세스가 대기하는 드는 시간의 합\n- 응답 시간\n  - 프로세스의 첫번째 응답이 전해질 때까지의 시간\n  - 프로세스는 계속 동작 중인 상태이고, 작업의 시간이 얼마나 걸리는 지는 고려하지 않고, 첫번째 응답만 고려한다.\n- 공정함\n  - 각 프로세스가 CPU를 공평하게 분배받는 것\n\n> 처리 시간, 대기 시간, 응답 시간은 최소화할 수록 좋다.\n\n### 🪚 CPU - I/O Burst Cycle\n프로세스의 동작에서, CPU execution과 I/O Wait의 alternative cycle이 발생한다.\n- CPU burst -> I/O burst -> CPU burst -> I/O burst -> 반복\n\n<img src=\"\" width=\"80%\">\n\n> I/O: Input/Output으로, CPU 밖에서 처리되는 모든 작업을 의미한다.\n\n### 🪚 선점 스케줄링\n**선점 스케줄링**이란 CPU 사용권을 선점하는 스케줄링이다. 특정 조건에 따라 각 프로세스의 요청이 있을 때 프로세스에게 분배하는 방식이다. \n- 상황에 따라 **강제로 CPU 사용권을 회수**할 수도 있다.\n\n선점 스케줄링에는 다음과 같은 이슈사항이 있다.\n- **Race Condition의 잠재적 원인**\n  - 데이터를 업데이트하는 도중 선점이 발생하면, 해당 데이터에 대한 업데이트가 정상적으로 수행되지 않는 문제가 발생한다.\n  - ex. P1이 실행 중 Lock으로 데이터를 보호하고 있다. 이때 선점이 발생해 Unlock되지 않은 채로 프로세스가 해제된다. 이떄 다른 프로세스가 해당 데이터에 접근하려 하지만, Unlock되어 있기에 접근이 불가능하다.\n- **Kernel 디자인의 복잡도**\n  - 시스템 콜 호출 중에 선점이 발생하면, kernel의 자료구조에 문제가 발생한다.\n  - 따라서, 프로세스가 kernel mode에 있는 경우, 해제되지 않도록 한다.\n    - 하지만, real-time computing의 경우, 빨리 처리해야 하는 프로세스가 다른 프로세스의 시스템 콜 사용으로 인해 선점되지 못한다면 문제가 발생할 수 있다.\n\n선점 스케줄링에는 다음과 같은 종류가 있다.\n\n**라운드 로빈 스케줄링(Round-Robin/RR)**\n- time-sharing 시스템을 위해 디자인된 기법으로, FCFS(First-Come, First-Served) 스케줄링을 기반으로 하여 CPU를 할당하되, 각 프로세스는 **한 번에 쓸 수 있는 CPU 할당량**이 초과되면 인터럽트에 의해 CPU를 뺏기게 된다.\n  - 즉, **Preemption이 추가**되었다.\n- FIFO ready Queue를 사용한다.\n- 프로세스 하나가 CPU를 독점하는 상황은 방지하지만, Context Switch가 많이 발생하는 오버헤드를 감수해야 한다.\n\n동작방식은 다음과 같다.\n- Ready Queue의 첫 번째 프로세스를 선택하여 time quantum만큼 실행한다.\n- time quantum동안 해당 프로세스가 작업을 모두 마치지 않았다면, Ready Queue의 맨 뒤로 보낸다.\n- 이를 반복한다.\n\n> Time quantum가 짧을 수록, Context Switch는 많이 발생한다.\n\n**Multi-level Queue 스케줄링**\n- 프로세스들의 우선순위 개수만큼 큐가 필요하다. \n- 프로세스들은 자신의 우선순위 값에 해당하는 큐에 들어가게 되며, 우선순위가 낮은 하위 단계 큐의 작업은 실행 중이더라고 상위 단계 큐에 프로세스가 도착하면 CPU를 뺏긴다.\n  - 프로세스는 다른 Queue로 이동할 수 없다.\n  - 따라서 하위 단계 큐에 있는 프로세스들은 **starvation**이 발생할 수 있다.\n\n**Multi-level Feedback Queue 스케줄링**\n- Multi-level Queue 스케줄링의 문제를 해결하는 스케줄링 기법으로, **Aging이 추가**되었다. \n  - 모든 프로세스들은 동일한 Queue로 들어온다.\n  - 첫번째 Queue는 라운드-로빈 스케줄링을 통해 time quantum을 사용한다.\n  - 해당 time quantum동안 처리되지 못한 프로세스들은 다음 Queue로 이동한다. 다음 Queue는 이전 Queue의 2배에 해당하는 time quantum을 가진다.\n  - 마지막 Queue는 대개 FCFS로 처리된다.\n- 프로세스는 **다른 Queue로의 이동이 가능**하다.\n- 이전 단계의 Queue가 empty한 경우에만 현재 단계의 Queue의 프로세스들이 작업에 들어갈 수 있다.\n\n### 🪚 비선점 스케줄링\n**비선점 스케줄링**이란 선점과 반대로, 이미 할당된 CPU를 다른 프로세스가 강제로 빼앗아 사용할 수 없는 스케줄링이다.\n- 프로세스가 스스로 종료되거나 CPU에서 해재되지 않는 이상 계속 CPU를 사용할 수 있다.\n\n비선점 기법은 다음과 같은 종류들이 있다.\n\n**FCFS 스케줄링(First-Come First-Served)**\n- 가장 간단한 방식으로, CPU를 먼저 요청한 프로세스가 먼저 배정받는 기법이다.\n- 하지만 우선순위가 높은 프로세스가 후순위에 배치된다면, 긴 대기 시간을 가지게 되고, 평균 대기 시간이 크다는 단점이 있다.\n  - 그리고 이와 같이 다른 모든 프로세스들이 처리시간이 긴 프로세스가 끝날 때까지 계속 기다리는 현상을 **Convey effect**라 한다.\n  - 이는 CPU와 device들의 사용률을 낮추기에 지양해야 한다.\n\n**SJF 스케줄링(Shortest-Job-First)**\n- Ready Queue에 있는 프로세스 중 가장 CPU 사용량이 적은 프로세스(shortest-burst time job)를 먼저 선택하는 방식이다.\n- 평균 대기 시간을 최소화할 수 있으나, 실행 시간이 긴 프로세스가 CPU를 할당받지 못하고 계속해서 대기하는 무한 대기 현상이 발생할 수 있다.\n- 또한, CPU burst time은 프로세스를 실행해보기 전에는 알기 매우 어렵다.\n  - 과거 정보를 사용해 예측하기도 하지만, 같은 프로그램이라도 다양한 burst time을 가질 수 있다.\n\n> **SJF 스케줄링(Shortest-Job-First): Preemptive or Nonpreemtive**\n> - Preemptive하다면, 현재 실행 중인 프로세스보다 더 짧은 burst time을 가지는 프로세스가 들어온 경우, 현재 프로세스가 중단되고, 해당 프로세스를 선택할 것이다.\n\n### 🪚 우선순위 스케줄링\n높은 우선순위를 가지는 프로세스를 선택하는 스케줄링으로, 여기서 우선순위는 정의하기 나름이다.\n\n이와 같은 관점으로 보았을 때,\n- SJF도 일종의 우선순위 스케줄링 -> 프로세스의 remaining time이 우선순위\n- FCFS도 일종의 우선순위 스케줄링 -> 프로세스가 Ready Queue에 도착하는 시간이 우선순위\n\n그리고 우선순위는 두 가지 종류가 있다.\n- Internally defined (컴퓨터 내부 정의)\n  - 우선순위 계산을 위해 측정 가능한 기준을 사용한다.\n  - ex. time limits, memory requirements, # of open files 등등\n- Externally defined (컴퓨터 외부 정의)\n  - OS 바깥의 특정 기준을 사용한다.\n  - ex. 프로세스의 중요성(사람이 정의) 등\n\n선점 스케줄링과 비선점 스케줄링을 우선순위 스케줄링 관점에서 본다면,\n- 선점 스케줄링 -> 우선순위가 높은 프로세스를 선택하고, 현재 프로세스를 중단시킨다.\n- 비선점 스케줄링 -> 우선순위가 높은 프로세스를 선택하고, 이를 Ready Queue의 가장 앞에 위치시킨다.\n\n### 🪚 Starvation Problem\nMulti-level Queue 스케줄링에서 언급되었던 문제로, 특정 프로세스가 언제 스케줄링될 지 알 수 없고, 아예 스케줄링되지 않을 수도 있는 문제이다.\n\n이를 해결하기 위해서 **Aging**이 적용된다.\n- 프로세스의 우선순위를 점점 증가시켜, 낮은 우선순위를 가진 프로세스가 점점 높은 우선순위를 가질 수 있도록 한다.\n\n---\n\n## 🧷 Synchronization\n> Race Condition\n- 두 개 이상의 프로세스가 공통 자원을 병행적으로 읽거나 쓰는 동작을 할 때, 공용 데이터에 대한 접근이 어떤 순서에 따라 이뤄졌는지에 따라 그 실행 결과가 같지 않고 달라지는 상황\n- 이를 예방하기 위해 동기화 과정이 필요하고, Semaphore와 Mutex를 사용할 수 있다.\n\nRace Condition은 어떤 상황에 발생할까\n\n**Multi-threaded application**\n- 쓰레드는 프로세스 안에서 stack을 제외한 메모리를 공유한다.\n- 공유되는 변수에 대한 제어가 없다면, 문제가 발생할 가능성이 있다.\n  - data corruption(읽기, 쓰기, 저장, 전송, 처리 중 의도하지 않은 변경으로 인해 데이터의 에러가 발생한 것)\n\n> 세마포어와 뮤텍스\n- 세마포어는 여러 개의 프로세스가 접근 가능한 공유자원을 관리하는 방식이고, 뮤텍스가 될 수 있지만, 뮤텍스는 한 번에 한 개의 프로세스만 접근 가능하도록 관리하는 방식이다. 따라서 뮤텍스는 세마포어가 될 수 없다.\n- 또, 세마포어는 다른 프로세스가 세마포어를 해제할 수 있지만, 뮤텍스는 락을 획득한 프로세스만 락을 반환할 수 있다.\n\n---\n\n## 📕 참고\n- [[OS 운영체제] 프로세스(Process)란?](https://iingang.github.io/posts/OS-process/)\n- [[OS] 프로세스와 스레드의 차이](https://gmlwjd9405.github.io/2018/09/14/process-vs-thread.html)\n- [좀비 프로세스와 고아 프로세스](https://dongwooklee96.github.io/post/2021/04/03/%EC%A2%80%EB%B9%84-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%EC%99%80-%EA%B3%A0%EC%95%84-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4/)\n- [[OS/운영체제] IPC란? - 정의, 종류, 방법](https://velog.io/@yanghl98/OS%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C-IPC%EB%9E%80)\n- [프로세스 스케줄링, 그리고 기법](https://velog.io/@hax0r/%EC%84%A0%EC%A0%90%EB%B9%84%EC%84%A0%EC%A0%90-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81)"},{"excerpt":"\"Do it! 자바 완전 정복\" 책을 바탕으로 정리하는 포스트입니다. 📍 변수와 자료형 변수는 메모리 공간에 부여하는 이름이고, 자료형은 데이터를 저장하기 위해 생성하고 목적에 따라 크기와 특징이 다른 메모리 공간이라 할 수 있다. 📝 자료형 선언 C, 자바와 같은 컴파일 언어는 변수를 사용하기 전에 반드시 자료형을 선언해야 한다.  변수의 생존 기간 변…","fields":{"slug":"/[Java지식]Doit!2.자료형/"},"frontmatter":{"date":"July 25, 2022","title":"📃 [Do it!] 2. 자료형","tags":["Java"]},"rawMarkdownBody":"\n<em>\"Do it! 자바 완전 정복\" 책을 바탕으로 정리하는 포스트입니다.</em>\n\n## 📍 변수와 자료형\n**변수**는 메모리 공간에 부여하는 이름이고, **자료형**은 데이터를 저장하기 위해 생성하고 목적에 따라 크기와 특징이 다른 메모리 공간이라 할 수 있다.\n\n### 📝 자료형 선언\nC, 자바와 같은 컴파일 언어는 변수를 사용하기 전에 **반드시 자료형을 선언**해야 한다. \n\n> **변수의 생존 기간**\n> - 변수는 개발자에 의해 생성된다. 하지만 메모리에서 변수를 삭제하는 작업은 개발자가 아닌, 자바 가상 머신(JVM)이 수행한다. 이는 후에 자세히 살펴본다.\n\n---\n\n## 📍 자료형의 종류\n자바의 자료형은 크게 \"기본 자료형(Primitive Type)\"과 \"참조 자료형(Reference Type)\"이 있다.\n- 8가지 기본 자료형이 있으며, 이외의 모든 자료형은 참조 자료형이다.\n- 또한 참조 자료형은 개발자가 직접 정의할 수도 있다.\n\n**❗️ 자료형을 구분하는 이유**\n- 자료형을 이와 같이 구분하는 이유는 **기본 자료형과 참조 자료형의 값 저장 방식이 서로 다르기 때문**이다.\n\n> 자료형의 구분을 이해하기 위해 먼저 메모리의 구조를 알아야 한다. 메모리는 목적에 따라 크게 3가지 영역으로 나뉜다.\n> 1. 클래스 영역, 정적 영역, 상수 영역, 메소드 영역\n> 2. 스택 영역 (변수들이 저장되는 영역)\n> 3. 힙 영역 (객체들이 저장되는 영역)\n\n### 📝 기본 자료형과 참조 자료형의 차이\n**1. 자료형의 이름 규칙**\n- 기본 자료형 8개의 이름은 모두 **소문자**(`int` , `long` , `float` , `double` , ...) 로 시작한다.\n- 참조 자료형의 이름은 모두 **대문자**(`String` , `System` , ...)로 시작한다.\n  - 권장사항이므로 지켜지지 않아도 오류가 발생하지는 않지만, 개발자 사이의 무언의 약속이므로 지키는 것이 좋다.\n\n**2. 실제 데이터값의 저장 위치**\n- 기본 자료형과 참조 자료형 모두 변수의 공간이 **스택 메모리에 생성**되지만 그 공간에 저장되는 값의 의미가 서로 다르다.\n- 기본 자료형은 **스택 메모리에 생성된 공간에 실제 변숫값이 저장**된다.\n- 참조 자료형은 **실제 데이터값은 힙 메모리에 저장**되고, **스택 메모리의 변수 공간에는 실제 변숫값이 저장된 힙 메모리의 위치값을 저장**한다.\n\n### 📝 기본 자료형의 종류\n기본 자료형에는 총 8가지로, 다음과 같다.\n- 참, 거짓을 저장하는 `boolean`\n- 정수를 저장하는 `byte` , `int` , `short` , `long`\n- 실수를 저장하는 `float` , `double`\n- 문자(정수)를 저장하는 `char`\n\n> **똑같은 정수를 처리하는데 왜 자료형이 4개나 있을까?**\n> - 이는 메모리의 효율성을 위해서이다. \n> - 큰 공간을 가진 자료형만 사용한다면, 작은 공간을 필요로 하는 변수 저장 시 공간 낭비가 발생할 것이다.\n> - 반대로 작은 공간을 가진 자료형만 사용한다면, 큰 공간을 필요로 하는 변수 저장 시 공간이 부족할 것이다.\n> - 여러 종류의 공간을 가진 자료형을 두어 효율적인 메모리 사용을 가능하도록 하기 위함이다.\n\n`char` 에 대해서, **문자(정수)**라고 표기했다. 이와 같이 적은 이유는 다음과 같다.\n- 메모리에 문자를 기록할 수 없다.\n  - 메모리는 2진수 값만 저장할 수 있는 공간이기 때문이다.\n- 그래서 `char` 은 모든 문자를 특정 정숫값으로 바꿔 저장한다. 그리고 특정 정숫값을 유니코드라고 한다.\n\n---\n\n## 📍 기본 자료형 간의 타입 변환\n`boolean` 을 제외한 기본 자료형 7개는 서로 자료형 변환이 가능하고 이를 타입 변환(Type casting)이라 한다.\n- 타입 변환은 단순히 변환 대상 앞에 `(자료형)`만 표기하면 된다.\n\n> 중요한 것은 타입 변환 시, 저장할 수 있는 값의 범위나 종류가 달라지므로 **값이 변할 수 있다**는 점이다.\n\n### 📝 자동 타입 변환과 수동 타입 변환\n타입 변환에는 2가지 종류가 있다.\n- 컴파일러가 자동으로 수행하는 **\"자동 타입 변환\"**\n- 개발자가 직접 타입 변환을 명시하는 **\"수동 타입 변환\"**\n\n크기가 작은 자료형을 큰 자료형에 대입하게 되면, 어떠한 데이터 손실도 발생하지 않는다. \n- 따라서 타입 변환을 명시하지 않더라도 컴파일러가 자동으로 타입 변환을 실행하는데, 이를 **업캐스팅(upcasting)** 이라 한다.\n\n반대로, 큰 자료형을 작은 자료형에 대입하면, 데이터 손실이 발생할 것이다. \n- 데이터 손실이 발생하기에 컴파일러에 따른 자동 타입 변환은 일어나지 않고, 이를 **다운캐스팅(downcasting)** 이라 한다.\n- 개발자가 직접 타입 변환을 명시해야 한다.\n\n---\n\n## 📕 참고\n- **Do it! 자바 완전 정복** - 이지스 퍼블리싱"},{"excerpt":"문제 Programmers - 124 나라의 숫자 📍 Logic n이 자연수인 경우만, 나머지 연산으로 맨 끝자리 숫자를 계산하여 124 나라의 숫자로 변환해나간다. 📄 CODE ✏️ Review 아이디어는 쉽게 생각했으나, 처음에는 Bottom Up 방식으로 배열에 메모이제이션을 수행해서 진행했다.  효율성 테스트에서 터져 아이디어가 틀린 건가 싶어서 게…","fields":{"slug":"/[Programmers]12899/"},"frontmatter":{"date":"July 24, 2022","title":"👩‍💻 12899. 124 나라의 숫자","tags":["DP"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 124 나라의 숫자](https://programmers.co.kr/learn/courses/30/lessons/12899)\n\n### 📍 **Logic**\n\n```java\nwhile (n > 0) {\n    int remain = n % 3;\n    \n    if (remain == 0) remain = 4;\n    sb.append(remain);\n    \n    n = (n - 1) / 3;\n}\n```\n- n이 자연수인 경우만, 나머지 연산으로 맨 끝자리 숫자를 계산하여 124 나라의 숫자로 변환해나간다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        public String solution(int n) {\n            StringBuilder sb = new StringBuilder();\n            \n            while (n > 0) {\n                int remain = n % 3;\n                \n                if (remain == 0) remain = 4;\n                sb.append(remain);\n                \n                n = (n - 1) / 3;\n            }\n            \n            return sb.reverse().toString();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 아이디어는 쉽게 생각했으나, 처음에는 **Bottom Up** 방식으로 배열에 메모이제이션을 수행해서 진행했다. \n  - 효율성 테스트에서 터져 아이디어가 틀린 건가 싶어서 게시판을 보니 **Top Down** 방식으로 하면 바로 해결이었다."},{"excerpt":"문제 Programmers - 짝지어 제거하기 📍 Logic 같은 문자를 만날 떄까지 스택에 문자를 넣는다. 같은 문자가 나오면 pop하고 그렇지 않으면 stack에 남기 때문에, 최종적으로 스택이 비어있지 않다면 짝지어 제거할 수 없다. 📄 CODE ✏️ Review 처음에는 정규표현식으로 같은 문자가 2번 반복될 때, 이를 제거한다. 이를 반복하다가 최…","fields":{"slug":"/[Programmers]12973/"},"frontmatter":{"date":"July 24, 2022","title":"👩‍💻 12973. 짝지어 제거하기","tags":["스택"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 짝지어 제거하기](https://programmers.co.kr/learn/courses/30/lessons/12973)\n\n### 📍 **Logic**\n\n```java\nfor (int i = 0; i < len; i++) {\n    char ch = s.charAt(i);\n    char stackCh = ' ';\n    \n    if (!stack.isEmpty()) stackCh = stack.peek();\n    \n    if (ch == stackCh) stack.pop();\n    else stack.push(ch);\n}\n```\n- 같은 문자를 만날 떄까지 스택에 문자를 넣는다.\n- 같은 문자가 나오면 pop하고 그렇지 않으면 stack에 남기 때문에, 최종적으로 스택이 비어있지 않다면 짝지어 제거할 수 없다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Solution {\n        public int solution(String s) {\n            Stack<Character> stack = new Stack<>();\n            int len = s.length();\n            \n            for (int i = 0; i < len; i++) {\n                char ch = s.charAt(i);\n                char stackCh = ' ';\n                \n                if (!stack.isEmpty()) stackCh = stack.peek();\n                \n                if (ch == stackCh) stack.pop();\n                else stack.push(ch);\n            }\n            \n            return stack.isEmpty() ? 1 : 0;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 정규표현식으로 같은 문자가 2번 반복될 때, 이를 제거한다. 이를 반복하다가 최종적으로는 문자열의 길이가 0이 되는지에 따라 반환하는 방식으로 구현했다.\n  - 하지만 몇몇 테케에서 시간초과가 발생했다.\n- 문득 전에 문자열 폭발이라는 문제를 풀다가 못 풀었던 기억이 났는데 그 때 스택을 사용해야 했다는 점이 떠올랐다."},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 다양한 의존관계 주입 방법 의존관계 주입은 크게 4가지 방법이 있다. 생성자 주입 수정자 주입 (setter 주입) 필드 주입 일반 메소드 주입 🪔 생성자 주입 이름 그대로 생성자를 통해 의존 관계를 주입 받는 방법이다. (지금까지 했던 방법!) 특징 생성자 호출 시점에 딱 1번만 호출되는…","fields":{"slug":"/[스프링핵심원리_기본편]7.의존관계자동주입/"},"frontmatter":{"date":"July 24, 2022","title":"📟 7. 의존관계 자동 주입","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 다양한 의존관계 주입 방법\n의존관계 주입은 크게 4가지 방법이 있다.\n- 생성자 주입\n- 수정자 주입 (setter 주입)\n- 필드 주입\n- 일반 메소드 주입\n\n### 🪔 생성자 주입\n이름 그대로 생성자를 통해 의존 관계를 주입 받는 방법이다. (지금까지 했던 방법!)\n\n**특징**\n- 생성자 호출 시점에 딱 1번만 호출되는 것이 보장된다.\n- **불변, 필수 의존관계**에 사용한다.\n\n```java\n@Component\npublic class OrderServiceImpl implements OrderService {\n\n    private final MemberRepository memberRepository;\n    private final DiscountPolicy discountPolicy;\n\n    @Autowired\n    public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy discountPolicy) {\n        this.memberRepository = memberRepository;\n        this.discountPolicy = discountPolicy;\n    }\n}\n```\n\n- `@Component` 어노테이션으로 인해 컴포넌트 스캔되어 스프링 빈에 등록이 될 때, 생성자를 호출한다.\n- 이때, `@Autowired` 어노테이션으로 인해 `MemberRepository` 와 `DiscountPolicy` 빈을 컨테이너에서 꺼내 의존관계를 주입해준다.\n\n> **생성자가 딱 1개**만 있으면, `@Autowired` 를 생략해도 자동 주입된다. (스프링 빈에만 해당)\n\n### 🪔 수정자 주입(setter 주입) \nsetter라 불리는 필드의 값을 변경하는 수정자 메소드를 통해서 의존관계를 주입하는 방법이다.\n\n**특징**\n- **선택, 변경 가능성이 있는 의존관계**에 사용한다.\n- 자바 빈 프로퍼티 규약의 수정자 메소드 방식을 사용하는 방법이다.\n\n```java\n@Component\npublic class OrderServiceImpl implements OrderService {\n    private MemberRepository memberRepository;\n    private DiscountPolicy discountPolicy;\n\n    @Autowired\n    public void setMemberRepository(MemberRepository memberRepository) {\n        this.memberRepository = memberRepository;\n    }\n    @Autowired\n    public void setDiscountPolicy(DiscountPolicy discountPolicy) {\n        this.discountPolicy = discountPolicy;\n    }\n}\n```\n\n- setter에 `@Autowired` 를 붙여 호출하게 한다.\n\n> `@Autowired` 의 기본 동작은 주입할 대상이 없으면 오류가 발생한다. 주입할 대상이 없어도 동작하게 하려면 `@Autowired(required = false)` 로 지정하면 된다.\n\n> **자바 빈 프로퍼티**\n> - 자바에서는 과거부터 필드의 값을 직접 변경하지 않고, setter & getter 메소드를 통해 값을 읽거나 수정하는 규칙을 만들었다. 이것이 **자바 빈 프로퍼티 규약**이다.\n\n### 🪔 필드 주입\n이름 그대로 필드에 바로 주입하는 방법이다.\n\n**특징**\n- 코드가 간결해서 많은 개발자들을 유혹하지만 외부에서 변경이 불가능해서 테스트 하기 힘들다는 치명적인 단점이 있다.\n  - 순수한 테스트 코드를 작성해 실행하면, 필드에 객체를 넣어줄 방법이 없어 테스트가 불가능하다. (결국 setter 메소드를 생성해 호출해야 한다.)\n- DI 프레임워크가 없으면 아무것도 할 수 없다.\n- **사용하지 말자!**\n  - 애플리케이션의 실제 코드와 관계 없는 테스트 코드에서는 사용할 수 있다. (`@SpringBootTest` 어노테이션을 사용한 경우)\n  - 스프링 설정을 목적으로 하는 @Configuration 같은 곳에서만 특별한 용도로 사용\n\n```java\n@Component\npublic class OrderServiceImpl implements OrderService {\n    @Autowired\n    private MemberRepository memberRepository;\n    @Autowired\n    private DiscountPolicy discountPolicy;\n}\n```\n\n> 순수한 자바 테스트 코드에는 당연히 `@Autowired` 가 동작하지 않는다. 스프링 컨테이너에서 관리하는 빈에 대해 사용 가능하다.\n\n> 다음 코드와 같이 `@Bean` 에서 파라미터에 의존관계는 자동 주입된다. 수동 등록 시 자동 등록된 빈의 의존관계가 필요할 때 문제를 해결할 수 있다.\n\n```java\n@Bean\nOrderService orderService(MemberRepository memberRepoisitory, DiscountPolicy discountPolicy) {\n    new OrderServiceImpl(memberRepository, discountPolicy)\n}\n```\n\n### 🪔 일반 메소드 주입\n일반 메소드를 통해 주입받을 수 있다.\n\n**특징**\n- 한 번에 여러 필드를 주입 받을 수 있다.\n- 일반적으로 잘 사용하지 않는다.\n\n```java\n@Component\npublic class OrderServiceImpl implements OrderService {\n    private MemberRepository memberRepository;\n    private DiscountPolicy discountPolicy;\n\n    @Autowired\n    public void init(MemberRepository memberRepository, DiscountPolicy\ndiscountPolicy) {\n        this.memberRepository = memberRepository;\n        this.discountPolicy = discountPolicy;\n    }\n}\n```\n\n> 당연하게도, 의존관계 자동 주입은 스프링 컨테이너가 관리하는 스프링 빈이어야 동작한다. 스프링 빈이 아닌 `Member` 같은 클래스에서 `@Autowired` 어노테이션을 적용해도 아무 것도 동작하지 않는다.\n\n---\n\n## 🎯 옵션 처리\n주입할 스프링 빈이 없어도 동작해야 할 때가 있다. 하지만 `@Autowired` 만 사용하면 `required` 옵션의 기본 값이 `true` 여서 자동 주입 대상이 없으면 오류가 발생한다.\n\n자동 주입 대상을 옵션으로 처리하는 방법은 다음과 같다.\n- `@Autowired(required = false)` : 자동 주입할 대상이 없으면 수정자 메소드 자체가 호출되지 않음\n- `org.springframework.lang.@Nullable` : 자동 주입할 대상이 없으면 null이 입력된다.\n- `Optional<>` : 자동 주입할 대상이 없으면 `Optional.empty` 가 입력된다.\n\n```java\npackage hello.core.autowired;\n\nimport hello.core.member.Member;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.lang.Nullable;\n\nimport java.util.Optional;\n\npublic class AutowiredTest {\n\n    @Test\n    void autowiredOption() {\n        ApplicationContext ac = new AnnotationConfigApplicationContext(TestBean.class);\n\n    }\n\n    static class TestBean {\n\n        @Autowired(required = false)\n        public void setNoBean1(Member member) {\n            System.out.println(\"member = \" + member);\n        }\n\n        @Autowired\n        public void setNoBean2(@Nullable Member member) {\n            System.out.println(\"member = \" + member);\n        }\n        \n        @Autowired\n        public void setNoBean3(Optional<Member> member) {\n            System.out.println(\"member = \" + member);\n        }\n    }\n\n}\n\n// 출력 결과\n(호출 안됨)\nmember = null\nmember = Optional.empty\n```\n\n- **`Member` 는 스프링 빈이 아니다.**\n\n> `@Nullable` , `Optional` 은 스프링 전반에 결쳐 지원된다. 생성자 자동 주입에서 특정 필드에만 사용해도 된다.\n\n---\n\n## 🎯 생성자 주입을 선택해라!\n과거에는 수정자 주입과 필드 주입을 많이 했다. 하지만 최근에는 스프링 뿐 아니라 다른 DI 프레임워크 또한 생성자 주입을 권장한다. 그 이유는 다음과 같다.\n\n### 🪔 불변\n- 대부분의 의존관계 주입은 한 번 일어나면, 애플리케이션 종료시점까지 변경할 일이 없다. 오히려 변경되어선 안된다.\n- 수정자 주입을 사용하면, setter 메소드를 `public` 으로 열어둬야 한다.\n  - 이는 누군가 실수로 변경할 우려도 있고, 변경하면 안되는 메소드를 열어두는 것은 좋은 설계 방법이 아니다.\n- 생성자 주입은 객체를 생성할 때 딱 1번만 호출되기에 불변하게 설계할 수 있다!\n\n### 🪔 누락\n- 프레임워크 없이 순수한 자바 코드를 단위 테스트하는 경우, 다음과 같인 수정자 의존관계인 경우가 있다고 가정한다.\n\n```java\npublic class OrderServiceImpl implements OrderService {\n\n    private MemberRepository memberRepository;\n    private DiscountPolicy discountPolicy;\n\n    @Autowired\n    public void setMemberRepository(MemberRepository memberRepository) {\n        this.memberRepository = memberRepository;\n    }\n\n    @Autowired\n    public void setDiscountPolicy(DiscountPolicy discountPolicy) {\n        this.discountPolicy = discountPolicy;\n    }\n\n}\n```\n\n```java\n@Test\nvoid createOrder() {\n    OrderServiceImpl orderService = new OrderServiceImpl();\n    orderService.createOrder(1L, \"itemA\", 10000);\n}\n```\n\n- 실행하면, `NullPointerException` 이 발생한다.\n  - 이유는 `memberRepository` 와 `discountPolicy` 에 대한 의존관계 주입이 누락되었기 때문이다. (프레임워크 없이 테스트하게 되면 의존관계 자동 주입이 수행되지 않음!)\n\n생성자 주입을 사용하면 주입 데이터를 누락했을 때 **컴파일 오류**가 발생한다. \n\n### 🪔 final 키워드\n\n> `final` : 초기화 후 값이 변하지 않는다.\n\n생성자 주입을 사용하면 필드에 `final` 키워드를 사용할 수 있다. 그래서 생성자에서 혹시라도 값이 설정되지 않는 오류를 컴파일 시점에 막아준다.\n\n```java\n@Component\npublic class OrderServiceImpl implements OrderService {\n\n    private final MemberRepository memberRepository;\n    private final DiscountPolicy discountPolicy;\n@Autowired\n    public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy\ndiscountPolicy) {\n        this.memberRepository = memberRepository;\n    }\n\n    //...\n}\n```\n\n- 필수 필드인 `discountPolicy` 에 값을 설정해야 하는데, 이 부분이 누락되었다. 자바는 컴파일 시점에 `final` 키워드가 붙어있는 `discountPolicy` 에 대해 다음 오류를 발생시킨다.\n  - `java: variable discountPolicy might not have been initialized`\n\n> 수정자 주입을 포함한 나머지 주입 방식은 모두 생성자 이후에 호출되기에, 필드에 `final` 키워드를 사용할 수 없다. 오직 생성자 주입 방식만 `final` 키워드를 사용할 수 있다.\n\n---\n\n## 🎯 롬복과 최신 트렌드\n실제 개발을 해보면, 대부분이 다 불변이고, 그래서 다음과 같이 생성자에 `final` 키워드를 사용하게 된다. 그런데 생성자도 만들고 주입 받은 값을 대입하는 코드도 만들고, 조금 과정이 귀찮은 듯하다.\n- 필드 주입처럼 좀 편리하게 사용하는 방법은 없을까?\n\n**기본 코드**\n```java\n@Component\n    public class OrderServiceImpl implements OrderService {\n        private final MemberRepository memberRepository;\n        private final DiscountPolicy discountPolicy;\n        \n        @Autowired\n        public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy\n    discountPolicy) {\n            this.memberRepository = memberRepository;\n            this.discountPolicy = discountPolicy;\n        }\n}\n```\n\n- 생성자가 1개라면, `@Autowired` 를 생략할 수 있다.\n- 이후 **롬복**이라는 라이브러리를 적용해보자!\n\n```java\nplugins {\n\tid 'org.springframework.boot' version '2.7.1'\n\tid 'io.spring.dependency-management' version '1.0.11.RELEASE'\n\tid 'java'\n}\n\ngroup = 'hello'\nversion = '0.0.1-SNAPSHOT'\nsourceCompatibility = '11'\n\n//lombok 설정 추가 시작\nconfigurations {\n\tcompileOnly {\n\t\textendsFrom annotationProcessor\n\t}\n}\n//lombok 설정 추가 끝\n\nrepositories {\n\tmavenCentral()\n}\n\ndependencies {\n\timplementation 'org.springframework.boot:spring-boot-starter'\n\ttestImplementation 'org.springframework.boot:spring-boot-starter-test'\n\t//lombok 라이브러리 추가 시작\n\tcompileOnly 'org.projectlombok:lombok'\n\tannotationProcessor 'org.projectlombok:lombok'\n\ttestCompileOnly 'org.projectlombok:lombok'\n\ttestAnnotationProcessor 'org.projectlombok:lombok'\n\t//lombok 라이브러리 추가 끝\n\n}\n\ntasks.named('test') {\n\tuseJUnitPlatform()\n}\n```\n\n- 롬복 라이브러리를 사용하기 위해 의존성을 추가해준다.\n- 롬복의 대표적인 기능은 어노테이션을 통해 getter & setter 자동 생성, 생성자 관련 지원 기능이 있다.\n\n이제 롬복을 적용하여, `@RequiredArgsConstructor` 어노테이션을 사용해 `final` 키워드가 붙은 필드에 대한 생성자를 만들어주도록 한다.\n\n```java\npackage hello.core.order;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.member.Member;\nimport hello.core.member.MemberRepository;\nimport lombok.RequiredArgsConstructor;\nimport org.springframework.stereotype.Component;\n\n@RequiredArgsConstructor\n@Component\npublic class OrderServiceImpl implements OrderService {\n\n    // 회원을 찾기 위해 필요\n    private final MemberRepository memberRepository;\n    // 할인 정책 사용을 위해 필요\n    private final DiscountPolicy discountPolicy;\n\n    @Override\n    public Order createOrder(Long memberId, String itemName, int itemPrice) {\n        Member member = memberRepository.findById(memberId);\n        // 할인에 대해서는 createOrder는 아예 알지 못함, 단일 책임 원칙을 잘 지킨 예\n        int discountPrice = discountPolicy.discount(member, itemPrice);\n\n        return new Order(memberId, itemName, itemPrice, discountPrice);\n    }\n}\n```\n\n- 이전의 코드와 최종 코드는 완전히 동일하다. 롬복이 자바의 **Annotation processor**r라는 기능을 이용해 **컴파일 시점**에 생성자 코드를 자동으로 생성해준다.\n\n--- \n\n## 🎯 조회 빈이 2개 이상 - 문제\n`@Autowired` 는 타입으로 조회한다.\n- 따라서 다음 코드와 유사하게 동작한다. (실제로는 더 많은 기능을 제공!)\n  - `ac.getBean(DiscountPolicy.class)`\n\n스프링 빈 조회에서 배웠듯, 타입으로 조회 시 선택된 빈이 2개 이상이면 문제가 발생한다.\n- `NoUniqueBeanDefinitionException` 예외 발생\n- 이를 해결하기 위해, 하위 타입으로 지정하여 특정 빈만을 조회할 수는 있지만 이는 DIP를 위배하고 유연성을 떨어뜨리는 행위다.\n- 또한 이름만 다르고, 완전히 동일한 타입의 스프링 빈이 2개 있을 때 해결되지 않는다.\n\n> 스프링 빈을 수동 등록하여 문제를 해결할 수도 있지만, 의존관계 자동 주입에서 해결하는 여러 방법도 있다. 이는 아래에서 다룬다.\n\n--- \n\n## 🎯 @Autowired 필드 명, @Qualifier, @Primary\n조회 대상 빈이 2개 이상 일 떄 해결방법을 하나씩 알아본다. \n- `@Autowired` 필드 명 매칭\n- `@Qualifier` -> `@Qualifier` 끼리 매칭 -> 빈 이름 매칭\n- `@Primary` 사용\n\n### 🪔 @Autowired 필드 명 매칭\n`@Autowired` 는 타입 매칭을 시도하고, 이때 여러 빈이 있으면 필드 이름(파라미터 이름)으로 빈 이름을 추가 매칭한다.\n\n**기존 코드(필드 주입)**\n```java\n@Autowired\nprivate final DiscountPolicy discountPolicy;\n```\n\n**필드 명을 빈 이름으로 변경**\n```java\n@Autowired\nprivate final DiscountPolicy rateDiscountPolicy;\n```\n\n- 필드 명이 `rateDiscountPolicy` 이므로 정상 주입된다.\n\n> 필드 명 매칭은 먼저 타입 매칭을 시도하고, 그 결과에 여러 빈이 있을 때 추가로 동작하는 기능이다.\n\n### 🪔 @Qualifier 사용\n`@Qualifier` 는 추가 구분자를 붙여주는 방법이다. 주입 시 추가적인 방법을 제공하는 것이지, 빈 이름을 변경하는 것은 아니다.\n\n**빈 등록시 @Qualifierㄹ르 붙여준다.**\n```java\n@Component\n@Qualifier(\"mainDiscountPolicy\")\npublic class RateDiscountPolicy implements DiscountPolicy {\n    ...\n}\n```\n\n```java\n@Component\n@Qualifier(\"fixDiscountPolicy\")\npublic class FixDiscountPolicy implements DiscountPolicy {\n    ...\n}\n```\n\n**이후 주입 시에 @Qualifier를 붙여주고 등록한 이름을 적는다.**\n```java\n@Autowired\npublic OrderServiceImpl(MemberRepository memberRepository,\n                        @Qualifier(\"mainDiscountPolicy\") DiscountPolicy\ndiscountPolicy) {\n    this.memberRepository = memberRepository;\n    this.discountPolicy = discountPolicy;\n}\n```\n\n`@Qualifier` 로 주입할 때, `@Qualifier(\"mainDiscountPolicy\")` 를 못 찾으면 어떻게 될까?\n- 그러면 `mainDiscountPolicy` 라는 이름의 스프링 빈을 추가로 찾는다.\n  - 하지만 이는 경험상 좋은 사용은 아니다.\n\n또한 직접 빈 등록 시에도 `@Qualifier` 를 동일하게 사용할 수 있다.\n```java\n@Bean\n@Qualifier(\"mainDiscountPolicy\")\npublic DiscountPolicy discountPolicy() {\n    ...\n}\n```\n\n### 🪔 @Primary 사용\n이는 우선순위를 정하는 방법이다. 여러 빈이 매칭되면 `@Primary` 가 우선권을 가진다.\n\n**rateDiscountPolicy가 우선권**\n```java\n@Component\n@Primary\npublic class RateDiscountPolicy implements DiscountPolicy {}\n\n@Component \npublic class FixDiscountPolicy implements DiscountPolicy {}\n```\n\n`@Qualifier` 의 단점은 주입 받을 때 모든 코드에 `@Qualifier` 를 붙여줘야 한다는 점이다. 반면에 `@Primary` 를 사용하면 우선순위를 가질 클래스에만 이를 붙여주면 된다.\n\n**@Primary와 @Qualifier의 우선순위**\n- `@Primary` 는 기본값처럼 동작하고, `@Qualifier` 는 매우 상세하게 동작한다.\n- 스프링은 자동보다는 수동이, 넓은 범위의 선택권보다는 좁은 범위의 선택권이 우선 순위가 높다.\n  - 즉, `@Qualifier` 의 우선순위가 더 높다.\n\n--- \n\n## 🎯 어노테이션 직접 만들기\n`@Qualifier(\"mainDiscountPolicy\")` 이렇게 **문자를 적으면 컴파일시 타입 체크가 안된다.**\n- 이는 어노테이션을 만들어 해결할 수 있다.\n\n```java\npackage hello.core.annotation;\n\nimport org.springframework.beans.factory.annotation.Qualifier;\n\nimport java.lang.annotation.*;\n\n@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})\n@Retention(RetentionPolicy.RUNTIME)\n@Inherited\n@Documented\n@Qualifier(\"mainDiscountPolicy\")\npublic @interface MainDiscountPolicy {\n}\n```\n\n```java\npackage hello.core.discount;\n\nimport hello.core.annotation.MainDiscountPolicy;\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport org.springframework.stereotype.Component;\n\n@Component\n@MainDiscountPolicy\npublic class RateDiscountPolicy implements DiscountPolicy {\n\n    private int discountPercent = 10;\n    @Override\n    public int discount(Member member, int price) {\n        if (member.getGrade() == Grade.VIP)\n            return price * discountPercent / 100;\n        return 0;\n    }\n}\n```\n\n이후 사용할 때도 해당 어노테이션을 명시한다.\n\n```java\npackage hello.core.order;\n\n@Component\npublic class OrderServiceImpl implements OrderService {\n\n    // 회원을 찾기 위해 필요\n    private final MemberRepository memberRepository;\n    // 할인 정책 사용을 위해 필요\n    private final DiscountPolicy discountPolicy;\n\n    @Autowired\n    public OrderServiceImpl(MemberRepository memberRepository, @MainDiscountPolicy DiscountPolicy discountPolicy) {\n        this.memberRepository = memberRepository;\n        this.discountPolicy = discountPolicy;\n    }\n\n    ...\n}\n```\n\n**어노테이션에는 상속이라는 개념이 없다.** 이렇게 어노테이션을 모아서 사용하는 기능은 스프링이 지원해주는 기능이다.\n\n--- \n\n## 🎯 조회한 빈이 모두 필요할 때, List, Map\n의도적으로 해당 타입의 모든 스프링 빈이 필요한 경우가 있다. \n- 할인 서비스를 제공하는데, 클라이언트가 할인의 종류(fix, rate)를 선택할 수 있는 경우가 있을 수 있다.\n\n```java\npackage hello.core.autowired;\n\nimport hello.core.discount.DiscountPolicy;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\nimport java.util.List;\nimport java.util.Map;\n\npublic class AllBeanTest {\n\n    @Test\n    void findAllBean() {\n        ApplicationContext ac = new AnnotationConfigApplicationContext(DiscountService.class);\n    }\n\n    static class DiscountService {\n        private final Map<String, DiscountPolicy> policyMap;\n        private final List<DiscountPolicy> policies;\n\n        @Autowired\n        public DiscountService(Map<String, DiscountPolicy> policyMap, List<DiscountPolicy> policies) {\n            this.policyMap = policyMap;\n            this.policies = policies;\n\n            System.out.println(\"policyMap = \" + policyMap);\n            System.out.println(\"policies = \" + policies);\n        }\n    }\n}\n```\n\n- 테스트를 실행하면 맵과 리스트에 아무 값도 들어가있지 않은 것을 확인할 수 있다.\n  - `DiscountService` 만 빈으로 등록했기 때문이다!\n\n`ApplicationContext ac = new AnnotationConfigApplicationContext(AutoAppConfig.class, DiscountService.class);` 와 같이 설정 정보도 함께 등록한다.\n- 이제 의존관계 자동 주입 시, `@Autowired` 에 의해 컴포넌트 스캔을 수행하고, `Fix~` 와 `Rate~` 에 대한 주입이 수행된다.\n\n```java\npackage hello.core.autowired;\n\npublic class AllBeanTest {\n\n    @Test\n    void findAllBean() {\n        ApplicationContext ac = new AnnotationConfigApplicationContext(AutoAppConfig.class, DiscountService.class);\n\n        DiscountService discountService = ac.getBean(DiscountService.class);\n        Member member = new Member(1L, \"memberA\", Grade.VIP);\n        int discountPrice = discountService.discount(member, 10000, \"fixDiscountPolicy\");\n\n        assertThat(discountService).isInstanceOf(DiscountService.class);\n        assertThat(discountPrice).isEqualTo(1000);\n\n        int rateDiscountPrice = discountService.discount(member, 20000, \"rateDiscountPolicy\");\n\n        assertThat(rateDiscountPrice).isEqualTo(2000);\n    }\n\n    static class DiscountService {\n        private final Map<String, DiscountPolicy> policyMap;\n        private final List<DiscountPolicy> policies;\n\n        @Autowired\n        public DiscountService(Map<String, DiscountPolicy> policyMap, List<DiscountPolicy> policies) {\n            this.policyMap = policyMap;\n            this.policies = policies;\n\n            System.out.println(\"policyMap = \" + policyMap);\n            System.out.println(\"policies = \" + policies);\n        }\n\n        public int discount(Member member, int price, String discountCode) {\n            DiscountPolicy discountPolicy = policyMap.get(discountCode);\n\n            return discountPolicy.discount(member, price);\n        }\n    }\n}\n```\n\n**로직 분석**\n- `DiscountService` 는 Map으로 만든 `DiscountPolicy` 를 주입 받는다. 이때 `fixDiscountPolicy` , `rateDiscountPolicy` 가 주입된다.\n- `discount()` 메소드는 `discountCode` 로 `\"fixDiscountPolicy\"` 가 넘어오면 map에서 `fixDiscountPolicy` 빈을 찾아 실행한다.\n\n**주입 분석**\n- `Map<String, DiscountPolicy>` : map의 키에 스프링 빈의 이름을 넣어주고, 그 값으로 `DiscountPolicy` 타입으로 조회한 모든 스프링 빈을 담는다.\n- `List<DiscountPolicy>` : `DiscountPolicy` 타입으로 조회한 모든 스프링 빈을 담아준다.\n- 만약 해당하는 타입의 빈이 없다면, 빈 컬렉션이나 Map을 주입한다.\n \n--- \n\n## 🎯 자동, 수동의 올바른 실무 운영 기준\n**편리란 자동 기능을 기본으로 사용하자!**\n- 어떤 경우에 컴포넌트 스캔과 자동 주입을 사용하고, 어떤 경우에 설정 정볼르 통해 수동으로 빈을 등록하고 의존관계도 수동으로 주입해야 할까?\n\n결론부터 이야기하면, 스프링이 나오고 시간이 갈 수록 점점 자동을 선호하는 추세다. 스프링은 `@Component` 뿐만 아니라 `@Controller` , `@Service` , `@Repository` 처럼 계층에 맞추어 일반적인 애플리케이션 로직을 자동으로 스캔할 수 있도록 지원한다. 거기에 더해서 최근 스프링 부트는 컴포넌트 스캔을 기본으로 사용하고, 스프링 부트의 다양한 스프링 빈들도 조건이 맞으면 자동으로 등록하도록 설계했다.\n\n설정 정보를 기반으로 애플리케이션을 구성하는 부분과 실제 동작하는 부분을 명확하게 나누는 것이 이상적이지만, 개발자 입장에서 스프링 빈을 하나 등록할 때 `@Component` 만 넣어주면 끝나는 일을 `@Configuration` 설정 정보에 가서 `@Bean` 을 적고, 객체를 생성하고, 주입할 대상을 일일이 적어주는 과정은 상당히 번거롭다.\n\n또 관리할 빈이 많아서 설정 정보가 커지면 설정 정보를 관리하는 것 자체가 부담이 된다. 그리고 결정적으로 자동 빈 등록을 사용해도 OCP, DIP를 지킬 수 있다.\n\n**그러면 수동 빈 등록은 언제 사용하면 좋을까?**\n애플리케이션은 크게 업무 로직과 기술 지원 로직으로 나눌 수 있다.\n- **업무 로직 빈**: 웹을 지원하는 컨트롤러, 핵심 비즈니스 로직이 있는 서비스, 데이터 계층의 로직을 처리하는 리포지토리등이 모두 업무 로직이다. 보통 비즈니스 요구사항을 개발할 때 추가되거나 변경된다.\n- **기술 지원 빈**: 기술적인 문제나 공통 관심사(AOP)를 처리할 때 주로 사용된다. 데이터베이스 연결이나, 공통 로그 처리 처럼 업무 로직을 지원하기 위한 하부 기술이나 공통 기술들이다.\n\n업무 로직은 숫자도 매우 많고, 한번 개발해야 하면 컨트롤러, 서비스, 리포지토리 처럼 어느정도 유사한 패턴이 있다. 이런 경우 자동 기능을 적극 사용하는 것이 좋다. 보통 문제가 발생해도 어떤 곳에서 문제가 발생했는지 명확하게 파악하기 쉽다.\n\n기술 지원 로직은 업무 로직과 비교해서 그 수가 매우 적고, 보통 애플리케이션 전반에 걸쳐서 광범위하게 영향을 미친다. 그리고 업무 로직은 문제가 발생했을 때 어디가 문제인지 명확하게 잘 드러나지만, 기술 지원 로직은 적용이 잘 되고 있는지 아닌지 조차 파악하기 어려운 경우가 많다. 그래서 이런 기술 지원 로직들은 가급적 수동 빈 등록을 사용해서 명확하게 드러내는 것이 좋다.\n\n> 애플리케이션에 광범위하게 영향을 미치는 기술 지원 객체는 수동 빈으로 등록해서 딱! 설정 정보에 바로 나타나게 하는 것이 유지보수 하기 좋다.\n\n**비즈니스 로직 중에서 다형성을 적극 활용할 때**\n의존관계 자동 주입 - 조회한 빈이 모두 필요할 때, List, Map을 다시 보자.\n- `DiscountService` 가 의존관계 자동 주입으로 `Map<String, DiscountPolicy>` 에 주입을 받는 상황을 생각해보자. 여기에 어떤 빈들이 주입될 지, 각 빈들의 이름은 무엇일지 코드만 보고 한번에 쉽게 파악할 수 있을까? 내가 개발했으니 크게 관계가 없지만, 만약 이 코드를 다른 개발자가 개발해서 나에게 준 것이라면 어떨까?\n- 자동 등록을 사용하고 있기 때문에 파악하려면 여러 코드를 찾아봐야 한다.\n- 이런 경우 수동 빈으로 등록하거나 또는 자동으로하면 특정 패키지에 같이 묶어두는게 좋다! 핵심은 딱 보고 이해가 되어야 한다!\n\n이 부분을 별도의 설정 정보로 만들고 수동으로 등록하면 다음과 같다.\n```java\n@Configuration\npublic class DiscountPolicyConfig {\n    @Bean\n    public DiscountPolicy rateDiscountPolicy() {\n        return new RateDiscountPolicy();\n    }\n    @Bean\n    public DiscountPolicy fixDiscountPolicy() {\n        return new FixDiscountPolicy();\n    }\n}\n```\n\n이 설정 정보만 봐도 한눈에 빈의 이름은 물론이고, 어떤 빈들이 주입될지 파악할 수 있다. 그래도 빈 자동 등록을 사용하고 싶으면 파악하기 좋게 `DiscountPolicy` 의 구현 빈들만 따로 모아서 특정 패키지에 모아두자.\n\n참고로 스프링과 스프링 부트가 자동으로 등록하는 수 많은 빈들은 예외다. 이런 부분들은 스프링 자체를 잘 이해하고 스프링의 의도대로 잘 사용하는게 중요하다. 스프링 부트의 경우 `DataSource` 같은 데이터베이스 연결에 사용하는 기술 지원 로직까지 내부에서 자동으로 등록하는데, 이런 부분은 메뉴얼을 잘 참고해서 스프링 부트가 의도한 대로 편리하게 사용하면 된다. 반면에 스프링 부트가 아니라 내가 직접 기술 지원 객체를 스프링 빈으로 등록한다면 수동으로 등록해서 명확하게 드러내는 것이 좋다.\n\n## 📌 중요한 개념\n의존관계 주입, 주입 방법 4가지\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"\"Do it! 자바 완전 정복\" 책을 바탕으로 정리하는 포스트입니다. 📍 프로그래밍 언어 프로그래밍 언어는 컴퓨터가 이해할 수 있는 명령을 작성하기 위한 도구를 말한다. (자바, C, C++이 해당) 그리고 이런 프로그래밍 언어들은 기계어로 바뀌어 컴퓨터에 전달된다. 자바, C, C++과 같은 고급 언어를 사용해 컴퓨터에게 명령을 전달하기 위해서는 \"번역…","fields":{"slug":"/[Java지식]Doit!1.자바시작하기/"},"frontmatter":{"date":"July 23, 2022","title":"📃 [Do it!] 1. 자바 시작하기","tags":["Java"]},"rawMarkdownBody":"\n<em>\"Do it! 자바 완전 정복\" 책을 바탕으로 정리하는 포스트입니다.</em>\n\n## 📍 프로그래밍 언어\n프로그래밍 언어는 컴퓨터가 이해할 수 있는 명령을 작성하기 위한 도구를 말한다. (자바, C, C++이 해당) 그리고 이런 프로그래밍 언어들은 기계어로 바뀌어 컴퓨터에 전달된다.\n- 자바, C, C++과 같은 고급 언어를 사용해 컴퓨터에게 명령을 전달하기 위해서는 \"번역\"이라는 과정이 필요하고, 이를 수행하는 것이 **컴파일러**다.\n\n> **모든 컴퓨터가 똑같은 기계어를 사용할까?**\n> - 그렇지 않다. 윈도우 컴퓨터와 맥 컴퓨터는 서로 다른 기계어를 사용한다.\n\n---\n\n## 📍 자바\n제임스 고슬링과 다른 연구원들이 개발한 객체 지향적 프로그래밍 언어다.\n\n> 자바의 좌우명은 \"Write Once, Run Anywhere(한 번 작성하면 어느 플랫폼에서나 실행)\"\n\n### 📝 자바의 플랫폼 독립성\n자바는, 아래의 특징을 지닌 프로그래밍 언어다.\n- 플랫폼 독립성\n- 객체 지향 언어\n- 함수형 코딩 지원\n- 분산 처리 지원\n- 멀티 쓰레드 지원\n\n그중 플랫폼 독립성에 대해 알아본다. 그전에 이와 반대되는 개념인 **플랫폼 종속성**에 대해 먼저 알아본다.\n- 플랫폼 종속성의 대표적인 예로는 윈도우, 맥, 리눅스 운영체제의 대표적인 실행파일(.exe, .app, .sh)이 있다.\n\n실행 파일은 **일종의 기계어 집합**이다.\n- 기계어는 컴퓨터가 이해할 수 있는 명령어들의 집합이고, 당연히 서로 다른 플랫폼을 사용하는 컴퓨터는 서로 다른 기계어를 사용한다.\n- 이와 같이 \"하나의 실행 파일의 하나의 특정 플랫폼에서만 실행할 수 있는 특징\"을 **플랫폼 종속성**이라 한다.\n\n그렇다면, 플랫폼 독립성은 하나의 프로그램(실행 파일)이 모든 플랫폼에서 실행 가능하다는 것이다.\n- 자바는 이러한 특성을 가지고 있다는데, 도대체 어떻게 가능한 것일까?\n\n여기서 자바의 가상 머신인 **Java Virtual Machine**이 등장한다.\n- 머저 다양한 플랫폼 위에 JVM이라는 도구를 설치한다.\n- 윈도우를 예로 들면, `.exe` 만 실행할 수 있는 윈도우에 자바에서 만든 `.class` 또한 실행할 수 있는 가상 컴퓨터를 올려놓는다는 의미다.\n- 다양한 플랫폼별로 이러한 가상 머신의 모양은 다르지만, 오라클에서는 이를 제공하고 있다.\n\n### 📝 자바 개발 도구와 자바 실행 환경\n**자바 개발 도구(Java Development Kit)** 는 자바를 이용해 프로그램을 개발하는 데 필요한 도구를 모아둔 집합이다.\n- 레고로 비유하면, 레고 조각들을 넣어둔 상자가 JDK이고, 레고로 만든 자동차, 건물 등이 자바 프로그램이다.\n\n**자바 실행 환경(Java Runtime Environment)**는 완성된 프로그램을 실행하는데 필요한 환경이다.\n- JDK를 가져와 프로그램을 완성하고, JRE 위에서 실행하면 프로그램이 동작한다.\n\n이처럼 자바 개발을 위해서는 이 두 가지가 필수적인데, JDK의 내부에는 JRE가 포함되어 있다.\n- 또한 자바 프로그램(실행 파일, `.class`)은 자바 가상 머신 위에서만 실행할 수 있어, 자바 실행 환경 제공을 위해서는 자바 가상 머신(JVM)을 설치해야 한다.\n  - 즉, JRE 내부에 자바 가상 머신이 포함되어야 한다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2Fc00klf%2FbtqAjMzLyF2%2F6sU1VGp5vqAYIPLsXpakpK%2Fimg.png\" width=\"80%\">\n\n---\n\n## 📍 자바 프로그램의 기본 구조\n자바 소스 코드의 실행 과정은 다음과 같다.\n- 소스 파일(.java) 작성\n- 컴파일 수행\n- 바이트 코드(.class) 생성\n- 바이트 코드 실행\n  - 이때 JVM은 운영체제에서 메모리를 할당 받아 자바 프로그램 실행\n\n> **JVM이 할당한 메모리 영역은?**\n> - JVM은 효율적인 메모리 관리를 위해 메모리를 **메소드 영역**, **스택 영역**, **힙 영역**으로 나눠 사용한다.\n>    - 메소드 영역은 클래스, 정적, 상수 영역으로도 불린다.\n> - 메모리 할당 이후 실행 파일인 바이트 코드는 메모리의 메소드 영역에 할당되며, 클래스 내에 포함되어 있는 `main()` 메소드를 실행하는 것이 JVM의 역할이다.\n\n---\n\n## 📕 참고\n- **Do it! 자바 완전 정복** - 이지스 퍼블리싱"},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 컴포넌트 스캔과 의존관계 자동 주입 시작하기 지금까지는 스프링 빈 등록 시, 자바 코드의  이나 XML의  을 통해 설정 정보에 직접 등록할 스프링 빈을 명시했다. 하지만 등록해야 할 스프링 빈의 수가 많아지게 되면, 이러한 과정은 매우 비효율적이다. 스프링은 설정 정보가 없어도 자동으로 …","fields":{"slug":"/[스프링핵심원리_기본편]6.컴포넌트스캔/"},"frontmatter":{"date":"July 23, 2022","title":"📟 6. 컴포넌트 스캔","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 컴포넌트 스캔과 의존관계 자동 주입 시작하기\n지금까지는 스프링 빈 등록 시, 자바 코드의 `@Bean` 이나 XML의 `<bean></bean>` 을 통해 설정 정보에 직접 등록할 스프링 빈을 명시했다.\n- 하지만 등록해야 할 스프링 빈의 수가 많아지게 되면, 이러한 과정은 매우 비효율적이다.\n\n스프링은 **설정 정보가 없어도 자동으로 스프링 빈을 등록**하는 **컴포넌트 스캔**이라는 기능을 제공한다!\n- 또한 의존관계도 자동으로 주입하는 **`@Autowired`** 라는 기능도 제공한다.\n\n먼저 코드로 알아보기 위해, 새로운 `AutoAppConfig.java` 를 생성한다.\n```java\npackage hello.core;\n\nimport org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.context.annotation.FilterType;\n\n@Configuration\n@ComponentScan(\n        excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Configuration.class)\n)\npublic class AutoAppConfig {\n\n}\n```\n\n- `@ComponentScan` 이 추가되었다. 이는 스프링 빈을 다 읽어 자동으로 등록하기 위해 필요한 어노테이션이다.\n  - 이는 `@Component` 어노테이션이 붙은 클래스를 찾아 자동으로 스프링 빈으로 등록해준다.\n  - `excludeFilters` 는 이때 제외할 클래스를 의미한다.\n  - 현재 예제에서는 이전에 생성했던 `AppConfig` 에 `@Configuration` 어노테이션이 붙어있고, 이를 삭제하지 않기에 이를 제외한다.\n- 기존의 `AppConfig` 와 다르게 `@Bean` 으로 등록한 클래스가 하나도 없다!\n\n이제 각 클래스가 컴포넌트 스캔의 대상이 되도록 `@Component` 어노테이션을 붙여준다.\n\n**MemoryMemberRepository @Component 추가**, **RateDiscountPolicy @Component 추가**\n\n**MemberServiceImpl @Component, @Autowired 추가**\n```java\npackage hello.core.member;\n\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.stereotype.Component;\n\n@Component\npublic class MemberServiceImpl implements MemberService {\n\n    private final MemberRepository memberRepository;\n\n    @Autowired\n    public MemberServiceImpl(MemberRepository memberRepository) {\n        this.memberRepository = memberRepository;\n    }\n\n    @Override\n    public void join(Member member) {\n        memberRepository.save(member);\n    }\n\n    @Override\n    public Member findMember(Long memberId) {\n        return memberRepository.findById(memberId);\n    }\n}\n```\n\n- 이전 `AppConfig` 에서는 `@Bean` 으로 직접 설정 정보를 작성했고, 의존관계도 직접 명시했다.\n- 하지만 이제는 컴포넌트 스캔으로 자동 등록하기에 의존관계 주입 또한 해당 클래스 내에서 처리해야 한다.\n  - 이때 사용하는 것이 `@Autowired` 어노테이션이다. 이는 의존관계를 자동으로 주입해준다.\n\n**OrderServiceImpl @Component, @Autowired 추가**\n```java\npackage hello.core.order;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.discount.RateDiscountPolicy;\nimport hello.core.member.Member;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemoryMemberRepository;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.stereotype.Component;\n\n@Component\npublic class OrderServiceImpl implements OrderService {\n\n    // 회원을 찾기 위해 필요\n    private final MemberRepository memberRepository;\n    // 할인 정책 사용을 위해 필요\n//    private final DiscountPolicy discountPolicy = new FixDiscountPolicy();\n    private final DiscountPolicy discountPolicy;\n\n    @Autowired\n    public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy discountPolicy) {\n        this.memberRepository = memberRepository;\n        this.discountPolicy = discountPolicy;\n    }\n\n    @Override\n    public Order createOrder(Long memberId, String itemName, int itemPrice) {\n        Member member = memberRepository.findById(memberId);\n        // 할인에 대해서는 createOrder는 아예 알지 못함, 단일 책임 원칙을 잘 지킨 예\n        int discountPrice = discountPolicy.discount(member, itemPrice);\n\n        return new Order(memberId, itemName, itemPrice, discountPrice);\n    }\n}\n```\n\n- `@Autowired` 를 사용하면 생성자에서 여러 의존관계도 한 번에 주입받을 수 있다.\n\n이제 생성한 설정 정보로 스프링 빈 등록이 정상 수행되는지 확인하는 테스트 코드를 작성한다.\n\n**AutoAppConfigTest.java**\n```java\npackage hello.core.scan;\n\nimport hello.core.AutoAppConfig;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\nimport static org.assertj.core.api.Assertions.*;\n\npublic class AutoAppConfigTest {\n\n    @Test\n    void basicScan() {\n        ApplicationContext ac = new AnnotationConfigApplicationContext(AutoAppConfig.class);\n        MemberService memberService = ac.getBean(MemberService.class);\n        assertThat(memberService).isInstanceOf(MemberService.class);\n    }\n}\n```\n\n- 설정 정보로 방금 생성한 `AutoAppConfig` 를 넘겨준다.\n\n### 🪔 컴포넌트 스캔과 자동 의존관계 주입 동작 과정\n1. `@ComponentScan`\n<img src=\"../../images/스프링핵심원리-기본편/컴포스캔.png\" width=\"80%\">\n\n- `@ComponentScan` 은 `@Component` 가 붙은 모든 클래스를 스프링 빈으로 등록한다. (스프링 컨테이너가 모든 클래스를 확인!, 싱글톤으로 등록)\n- 이때 스프링 빈의 기본 이름은 클래스명을 사용하되, 맨 앞글자만 소문자를 사용한다.\n  - 만약 빈 이름을 지정하고 싶으면 `@Component(\"memberService2\")` 와 같이 부여하면 된다.\n\n2. `@Autowired` 의존관계 자동 주입\n<img src=\"../../images/스프링핵심원리-기본편/오토.png\" width=\"80%\">\n\n- 생성자에 `@Autowired` 를 지정하면, 스프링 컨테이너가 자동으로 해당 스프링 빈을 찾아서 주입한다.\n- 이때 기본 조회 전략은 **타입이 같은 빈**을 찾아 주입한다.\n  - `getBean(MemberRepository.class)` 와 동일하다고 이해하면 쉽다.\n  - 타입이 같은 빈이 여러 개인 경우는 뒤에서 ...\n\n<img src=\"../../images/스프링핵심원리-기본편/의존관계자동주입.png\" width=\"80%\">\n\n- 생성자에 파라미터가 많아도, 다 찾아서 자동으로 주입한다.\n\n---\n\n## 🎯 탐색 위치와 기본 스캔 대상\n### 🪔 탐색할 패키지의 시작 위치 지정\n컴포넌트 스캔 시, 모든 자바 클래스를 확인하면 시간이 오래 걸린다. 그래서 필요한 위치부터 탐색하도록 시작 위치를 지정할 수 있다.\n\n```java\npackage hello.core;\n\nimport org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.context.annotation.FilterType;\n\n@Configuration\n@ComponentScan(\n        excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Configuration.class),\n        basePackages = \"hello.core\"\n)\npublic class AutoAppConfig {\n\n}\n```\n\n- `basePackages` : 탐색할 패키지의 시작 위치를 지정한다. 이 패키지를 포함한 하위 패키지를 모두 탐색한다. 여러 시작 위치도 지정 가능하다.\n- `basePackageClasses` : 지정한 클래스의 패키지를 탐색 시작 위치로 지정한다.\n- 지정하지 않는다면, `@ComponentScan` 이 붙은 설정 정보 클래스의 패키지가 시작 위치가 된다.\n\n**권장하는 방법**\n- 패키지 위치를 지정하지 않고, 설정 정보 클래스의 위치를 프로젝트 최상단에 두는 것이다.\n- 최근 스프링 부트도 이 방법을 기본으로 제공한다.\n  - 스프링 부트를 사용하면 스프링 부트의 대표 시작 정보인 `@SpringBootApplication` 어노테이션을 프로젝트 시작 루트 위치에 두는 것이 관례이고, 이 설정 안에 `@ComponentScan` 어노테이션이 들어있다.\n\n### 🪔 컴포넌트 스캔 기본 대상\n컴포넌트 스캔은 다음과 같은 어노테이션도 추가로 대상에 포함한다.\n- `@Component` : 컴포넌트 스캔에서 사용\n- `@Controller` : 스프링 MVC 컨트롤러에서 사용\n- `@Service` : 스프링 비즈니스 로직에서 사용\n- `@Repository` : 스프링 데이터 접근 계층에서 사용\n- `@Configuration` : 스프링 설정 정보에서 사용\n\n> 위 클래스의 소스 코드를 보면 모두 `@Component` 를 포함하고 있는 것을 확인할 수 있다.\n\n> 사실 어노테이션은 상속 관계라는 것이 없다. 그래서 어노테이션이 특정 어노테이션을 들고 있는 것을 인식하는 것은 자바 제공 기능이 아닌, 스프링 제공 기능이다.\n\n컴포넌트 스캔의 용도 뿐 아니라 다음 어노테이션이 있다면 스프링은 부가 기능을 수행한다.\n- `@Controller` : 스프링 MVC 컨트롤러로 인식\n- `@Repository` : 스프링 데이터 접근 계층으로 인식하고, 데이터 계층의 예외를 스프링 예외로 변환해준다.\n  - DB가 변경되었을 때, 예외도 변경되어 다른 계층의 코드 또한 변경되어야 하는 문제를 방지한다.\n- `@Configuration` : 스프링 설정 정보로 인식하고, 스프링 빈이 싱글톤을 유지하도록 추가 처리를 한다.\n- `@Service` : 특별한 처리를 하지 않는다. 비즈니스 계층을 개발자들이 인식하는데 도움을 준다.\n\n> `useDefaultFilters` 옵션은 기본으로 켜져있다. 이 옵션을 끄면 기본 스캔 대상들이 제외된다.\n\n---\n\n## 🎯 필터\n- `includeFilters` : 컴포넌트 스캔 대상을 추가로 지정한다.\n- `excludeFilters` : 컴포넌트 스캔에서 제외할 대상을 지정한다.\n\n**컴포넌트 스캔 대상에 추가할 어노테이션**\n```java\npackage hello.core.scan.filter;\n\nimport java.lang.annotation.*;\n\n@Target(ElementType.TYPE)\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\npublic @interface MyIncludeComponent {\n    \n}\n\n//\n\npackage hello.core.scan.filter;\n\n@MyIncludeComponent\npublic class BeanA {\n}\n```\n\n- `TYPE` : 클래스 레벨에 붙는 어노테이션\n- `MyIncludeComponent` 어노테이션이 붙은 클래스(위에서는 `BeanA`)는 컴포넌트 스캔에 추가할 것이다!!!\n\n**컴포넌트 스캔 대상에서 제외할 어노테이션**\n```java\npackage hello.core.scan.filter;\n\nimport java.lang.annotation.*;\n\n@Target(ElementType.TYPE)\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\npublic @interface MyExcludeComponent {\n\n}\n\n//\n\npackage hello.core.scan.filter;\n\n@MyExcludeComponent\npublic class BeanB {\n}\n```\n\n- `MyExcludeComponent` 어노테이션이 붙은 클래스(위에서는 `BeanB`)는 컴포넌트 스캔에서 제외할 것이다!!!\n\n**설정 정보와 테스트 코드**\n```java\npackage hello.core.scan.filter;\n\nimport org.junit.jupiter.api.Assertions;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.NoSuchBeanDefinitionException;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.context.annotation.FilterType;\n\nimport static org.assertj.core.api.Assertions.*;\nimport static org.springframework.context.annotation.ComponentScan.*;\n\npublic class ComponentFilterAppConfigTest {\n\n    @Test\n    void filterScan() {\n        ApplicationContext ac = new AnnotationConfigApplicationContext(ComponentFilterAppConfig.class);\n        BeanA beanA = ac.getBean(\"beanA\", BeanA.class);\n        assertThat(beanA).isNotNull();\n\n        Assertions.assertThrows(\n                NoSuchBeanDefinitionException.class,\n                () -> ac.getBean(\"beanB\", BeanB.class)\n        );\n    }\n\n    @Configuration\n    @ComponentScan(\n            includeFilters = @Filter(type = FilterType.ANNOTATION, classes = MyIncludeComponent.class),\n            excludeFilters = @Filter(type = FilterType.ANNOTATION, classes = MyExcludeComponent.class)\n    )\n    static class ComponentFilterAppConfig {\n    }\n}\n```\n\n- `ComponentFilterAppConfig` 설정 정보는 컴포넌트 스캔을 수행하는데, `MyIncludeComponent` 어노테이션이 붙은 클래스는 컴포넌트 스캔 대상에 포함하고, `MyExcludeComponent` 어노테이션이 붙은 클래스는 포함하지 않는다.\n\n### 🪔 FilterType 옵션\n5가지 옵션이 있다.\n\n- `ANNOTATION` : 기본값, 어노테이션을 인식해서 동작한다. (생략 가능)\n  - ex. `org.example.SomeAnnotation`\n- `ASSIGNABLE_TYPE` : 지정한 타입과 자식 타입을 인식해서 동작한다.\n  - ex. `org.example.SomeClass`\n- `ASPECTJ` : AspectJ 패턴 사용\n  - ex. `org.example..*Service+`\n- `REGEX` : 정규 표현식\n  - ex. `org\\.example\\.Default.*`\n- `CUSTOM` : `TypeFilter` 라는 인터페이스를 구현해서 처리\n  - ex. `org.example.MyTypeFilter`\n\n예를 들어 `BeanA` 클래스도 컴포넌트 스캔에서 제외하고 싶다면,\n\n```java\n@Configuration\n@ComponentScan(\n        includeFilters = @Filter(type = FilterType.ANNOTATION, classes = MyIncludeComponent.class),\n        excludeFilters = {\n            @Filter(type = FilterType.ANNOTATION, classes = MyExcludeComponent.class)\n            @Filter(type = FilterType.ASSIGNABLE_TYPE, classes = BeanA.class)\n        }\n)\n```\n\n> `includeFilters` 를 거의 사용할 일은 없다! `@Component` 면 충분하다...\n\n---\n\n## 🎯 중복 등록과 충돌\n컴포넌트 스캔에서 같은 빈 이름을 등록하면 어떻게 될까? 다음과 같은 두 가지 상황이 있다.\n- 자동 빈 등록 vs. 자동 빈 등록\n- 수동 빈 등록 vs. 자동 빈 등록\n\n### 🪔 자동 빈 등록 vs. 자동 빈 등록\n컴포넌트 스캔에 의해 자동으로 스프링 빈이 등록되는데, 그 이름이 같은 경우 스프링은 오류를 발생시킨다.\n- `ConflictingBeanDefinitionException` 예외 발생!\n\n### 🪔 수동 빈 등록 vs. 자동 빈 등록\n\n```java\n@Component\npublic class MemoryMemberRepository implements MemberRepository {}\n```\n\n- 자동 빈 등록\n\n```java\n@Configuration\n@ComponentScan(\n        excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Configuration.class),\n        basePackages = \"hello.core\"\n)\npublic class AutoAppConfig {\n    \n    // 빈 등록 시, 맨 앞 글자는 소문자로!\n    @Bean(name = \"memoryMemberRepository\")\n    public MemberRepository memberRepository() {\n        return new MemoryMemberRepository();\n    }\n}\n```\n\n- 수동 빈 등록\n- 그리고 이렇게 수동 빈 등록과 자동 빈 등록이 충돌되는 경우, **수동 빈 등록이 우선권**을 가져 수동 빈이 자동 빈을 오버라이딩해버린다.\n\n**수동 빈 등록 시 남는 로그**\n```shell\nOverriding bean definition for bean 'memoryMemberRepository' with a different definition: replacing\n```\n\n- 최근 스프링 부트에서는 수동 빈 등록과 자동 빈 등록이 충돌나면, 오류가 발생하도록 기본 값을 바꿨다. (스프링 부트인 `CoreApplication` 을 실행해보면 오류를 확인할 수 있다.)\n\n>> 항상 잡기 어려운 버그는 애매한 버그다!\n\n## 📌 중요한 개념\n컴포넌트 스캔, 어노테이션\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"🧷 Security 네트워크 보안은 아래와 같은 것을 보장해야 한다. confidentiality: 명시된 수신자와 송신자만이 주고 받는 메세지의 내용을 이해할 수 있어야 한다.  송신자: 메세지를 암호화 수신자: 메세지를 복호화 authentication: 수신자와 송신자는 서로의 정체를 확인해야 한다. message integrity: 수신자와 송신자…","fields":{"slug":"/[Network]Security/"},"frontmatter":{"date":"July 19, 2022","title":"📡 Security","tags":["Network","OSI","Security"]},"rawMarkdownBody":"\n## 🧷 Security\n네트워크 보안은 아래와 같은 것을 보장해야 한다.\n- confidentiality: 명시된 수신자와 송신자만이 주고 받는 메세지의 내용을 이해할 수 있어야 한다. \n  - 송신자: 메세지를 암호화\n  - 수신자: 메세지를 복호화\n- authentication: 수신자와 송신자는 서로의 정체를 확인해야 한다.\n- message integrity: 수신자와 송신자는 메세지가 변경되지 않았다는 것을 보장받기를 원한다.\n\n그리고, 두 네트워크 개체 사이의 특정 공격자는 아래와 같은 행위들을 통해 네트워크 보안을 해칠 수 있다.\n- eavesdrop: 메세지 인터셉트\n  - 메세지에 대한 암호화가 필요\n- 연결 중간에 메세지 삽입\n- impersonation: 패킷의 목적 주소 또는 패킷의 특정 필드를 변경시켜버림\n- hijacking: 송신자 또는 수신자를 본인으로 대체하여 연결을 수행\n- denial of service: 서버에 많은 양의 요청을 의도적으로 가해, 다른 처리를 수행하지 못하도록 만드는 것\n\n### 🪚 암호\n<img src=\"../../images/Network/암호화기본.jpeg\" width=\"80%\">\n\n- plain text: 암호화하기 전의 데이터\n- $K_A$: A의 키로 특정한 비트 수로 이뤄진 값, 암호화 알고리즘에 사용된다.\n- cipher text: 평문과 암호키로 수학적 연산을 수행해 암호화된 데이터\n- $K_B$: B의 키로, 암호화된 데이터를 복호화하는 데 사용된다.\n\n---\n\n## 🧷 대칭키 암호 방식\n암호화와 복호화에 같은 암호키(symmetric key)를 사용하는 방식\n- 공통적 암호 방식이나 비밀키 암호 방식으로도 불린다.\n- 미리 송/수신 측이 암호키를 공유하고 있어야 한다.\n- 암호키의 공유가 어렵다.\n- 주 알고리즘으로 AES가 있다.\n\n<img src=\"https://blog.kakaocdn.net/dn/cfdhnA/btrfU2Qzxiw/IfF1D3DpPNVjkxaPAKcMm1/img.png\" width=\"80%\">\n\n### 🪚 암호화 방식\n**간단한 encryption scheme**\n- substitution cipher\n  - 1 문자를 다른 1문자로 대체\n  - Encryption key는 26개의 영어 문자를 다른 26개의 영어 문자로 대체하는 map을 가지고 변환\n\n**정교한 encryption scheme**\n- n개의 substitution ciphers (M1, M2, M3, ...)\n- cycling pattern: n = 4 / M1, M3, M4, M3, M2 ... 와 같이 여러 패턴을 사용하여 하나의 패턴이 뚫리는 경우를 보완한다.\n\n### 🪚 대칭키 crypto: DES\nData Encryption Standard\n- 56 bit의 대칭키와, 64 bit의 입력 평문으로 구성된다.\n- 복호화는 암호화의 역순이다.\n- 현재는 56 bit를 사용하는 대칭키의 안전성이 떨어진다. (빨라진 계산 덕에 하루면 해독이 가능해져버렸다..)\n- Feistel 구조\n\n### 🪚 대칭키 crypto: AES\nAdvanced Encryption Standard\n- DES를 대체한 암호 알고리즘으로, 암호화와 복호화 과정에서 동일한 키를 사용하는 대칭 키 알고리즘이다.\n- DES에 비해 키 사이즈가 자유로워, 가변 길이의 블록과 가변 길이의 키 사용이 가능하다. (128 bit, 192 bit, 256 bit)\n- 속도와 코드 효율성 면에서 효율적이다.\n- SPN 구조\n\n### 🪚 Feistel 구조와 SPN 구조\n**Feistel 구조**는 암복호화 과정에서 역함수가 필요없다는 장점이 있지만, 구현 시 스왑 단계 때문에 연산량이 많이 소요되며 암호에 사용되는 라운드 함수를 안전하게 설계해야 한다는 단점이 있다.\n\n**SPN 구조**는 암복호화 과정에서 역함수가 필요하도록 설계되어야 한다는 단점이 있지만, 중간에 비트의 이동없이 한번에 암복호화가 가능하기에 Feistel 구조에 비해 효율적인 설계가 가능하다.\n\n---\n\n## 🧷 공개키 암호 방식\n<img src=\"../../images/Network/공개키.jpeg\" width=\"80%\">\n\n- 비대칭키 암호 방식이라고도 불린다.\n- 공개키와 비밀키에는 수학적 연관성이 있다. (공개키로 비밀키를 추론하는 것이 불가능해야 한다.)\n- 수신자와 송신자는 비밀키는 공유하지 않는다.\n  - 송신자가 공개된 수신측의 공개키로 암호화\n  - 수신자가 송신측이 보내온 데이터를 비밀키로 복호화\n- 비밀키로 암호화하는 경우\n  - 비밀키로 암호화하는 경우, 공개키로 복호화할 수 있다.\n  - 송신자 A가 비밀키로 데이터를 암호화\n  - 수신자 B가 송신자의 공개키로 데이터 복호화를 수행, 성공 시 송신자가 A임을 확인\n\n### 🪚 RSA 알고리즘\nRivest, Shamir, Adelson 알고리즘으로, 공개키 암호 알고리즘 중 하나이다.\n- 인수분해 문제 해결의 높은 난이도를 이용한 가장 대표적인 공개키 암호 알고리즘으로, 암호화뿐 아니라 전자서명의 용도로도 사용된다.\n- SSL 프로토콜을 가진 많은 웹 브라우저, 공개키 암호 시스템을 사용하는 정부 시스템 등이 사용한다.\n- 모두에게 공개하는 공개키와 개인키(비밀키)로 구성된다.\n  - 공개키는 암호화, 개인키는 복호화에 사용된다.\n\n**방식**\n1. A가 B에게 정보를 안전하게 보내려 한다. 이때 RSA 알고리즘을 사용하려 한다.\n2. B가 공개키와 개인키를 만들어 A에게 공개키를 보낸다. (개인키는 B만 가지고 있다.)\n3. A가 B로부터 받은 공개키를 이요해 보낼 정보를 암호화한다.\n4. A가 암호화된 정보를 B에게 보낸다.\n5. B가 암호화된 정보를 받고 개인키를 이용해 암호를 복호화한다.\n\n> DES는 RSA보다 최소 100배 빠르다. symmetric session key의 교환을 위해 RSA를 사용한다.\n\n---\n\n## 🧷 인증\n인증의 궁극적인 목표는 A와 B가 서로를 prove하는 것이다.\n\n**ap 1.0**\n<img src=\"../../images/Network/인증.jpeg\" width=\"50%\">\n\n하지만 중간에 공격자가 이러한 인증과정에 끼어들 수 있다.\n- 중간 공격자가 자신이 A라고 거짓으로 말하여 인증과정에 끼어들 수 있다.\n\n**ap 2.0**\n이를 방지하고자, A가 자신의 IP 주소와 자신이 A라는 패킷을 생성해 보낼 수 있다.\n<img src=\"../../images/Network/스푸핑.jpeg\" width=\"80%\">\n\n- 하지만 이또한, 중간 공격자가 A인척 A의 IP 주소와 해당 메세지를 담은 패킷을 생성해 보내는 \"**스푸핑**\"으로 끼어들 수 있다.\n\n**ap 3.0**\n이 또한 A가 본인의 비밀 키를 패킷에 함께 담아 보내는 방식으로 방지할 수 있을 듯하다.\n<img src=\"../../images/Network/플레이백.jpeg\" width=\"80%\">\n\n- 중간 공격자가 A의 패킷을 기록하고 있다가, 이를 다시 B에게 보내는 방식으로 뚫릴 수 있다. 그리고 이는 \"**playback attack**\"이라 한다.\n- 그리고 A의 비밀 키를 암호화하여 보낸다해도, playback attack은 여전히 유효하다.\n\n**ap 4.0**\nPlayback attack을 피하기 위해, `nonce` 라는 개념을 사용한다.\n- `nonce` : 생애 한 번만 사용되는 숫자\n\n<img src=\"../../images/Network/nonce.jpeg\" width=\"80%\">\n\n- A는 B에게 A임을 알린다.\n- B는 A에게 `nonce` 를 전달한다.\n- 그리고 A만 알고 있는 키로 `nonce` 를 암호화하여 B에게 전달한다.\n- 이를 수신한 B는 A임을 인증한다.\n\n**ap 5.0**\n위 방식은 공유되는 대칭 키가 필요하다. 그렇다면 공개키로 이러한 인증을 수행할 수는 없을까?\n\n<img src=\"../../images/Network/ap5.0.jpeg\" width=\"80%\">\n\n- A는 B에게 A임을 알린다.\n- B는 A에게 `nonce` 를 전달한다.\n- A의 비밀키로 `nonce` 를 암호화하여 B에게 전달한다.\n- B는 A의 공개키를 요구하고, A는 공개키로 암호화한 `nonce` 를 전달한다.\n\n하지만 이러한 방식 또한, **man in the middle attack** 위험이 있다.\n- 공격자가 두 사용자 사이에서, 데이터 송수신을 엿듣거나 가로채는 공격이다.\n- 공격자는 A 또는 B인 것처럼 행동하여 데이터를 가로챈다.\n\n---\n\n## 🧷 디지털 서명\n데이터 송신처와 데이터 변조 여부를 확인하기 위한 인증 장치로, 데이터의 해시 값을 비밀키로 암호화한다.\n\n1. 송신자 A가 보낼 데이터에서 해시값 생성, 송신자의 비밀키로 암호화하여 서명 값을 첨부한다.\n2. 수신자 B는 데이터와 서명 값을 받고, A의 공개키로 서명을 복호화한다. 성공 시 A가 맞음을 증명한다.\n3. 수신한 데이터로부터 해시 값을 생성하여 복호화된 서명의 해시 값과 비교해 데이터 변조를 판별한다.\n\n### 🪚 Message digests\n공개 키로 긴 메세지를 암호화하면 오버헤드가 발생할 수 있다. 따라서 해시 함수를 사용해 짧은 메세지로 변환한다.\n\n해시 함수는 다음과 같은 특성이 있다.\n- many-to-1\n- 고정된 크기의 메세지를 생성한다.\n- 주어진 메세지 x에 대해, $x = H(m)$ 을 만족하는 $m$ 을 찾기 어렵다.\n\n> 이전에 다룬 Internet checksum 또한 해시 함수와 같은 특성을 가지지만, 주어진 해시 값에 대해 같은 해시 값을 가지는 $m$ 을 찾는 게 쉽다는 특성이 있다.\n\n### 🪚 디지털 서명 = 서명된 메세지 다이제스트\n위에서 설명한 디지털 서명의 방식을 그림으로 나타낸다.\n\n<img src=\"../../images/Network/밥전송.jpeg\" width=\"60%\">\n\n- 송신자는 긴 메세지 m과 이를 디지털 서명 적용한 message digest를 함께 전송한다.\n\n<img src=\"../../images/Network/앨리스수신.jpeg\" width=\"60%\">\n\n- 수신자는 긴 메세지 m을 해시 함수 적용한 값과 디지털 서명한 값을 송신자의 공개키로 복호화한 값을 비교하여 데이터의 변조 여부를 확인한다.\n\n### 🪚 해시 함수 알고리즘\n**MD5**\n- 가장 널리 사용되고 있는 알고리즘\n- 128bit message digest를 계산한다.\n\n**SHA-1**\n- 160 bit message digest\n\n### 🪚 공개 키 CA\nCA(Certification Authority): 공개 키를 인증해주는 제 3의 기관이다. 디지털 인증서를 발급해주고, 이는 서버에 설치하여 사용한다.\n\n<img src=\"../../images/Network/CA.jpeg\" width=\"80%\">\n\n1. 사용자는 공개키와 비밀키를 생성해 비밀키를 안전하게 보관한다.\n2. 공개키와 사용자 정보를 CA에 보내 인증서 발행을 신청한다. (CSR: Certificate Signaling Request, 인증서 발행 신청)\n3. CA는 요청을 확인하고 심사하여 인증서를 생성하고 회신한다. (인증기관의 비밀키로 서명)\n4. 발행된 인증서를 사용자 서버에 설치하여 사용한다.\n\n---\n\n## 🧷 Secure Email\n### 🪚 e-mail: Confidentiality\nMessage integrity와 authentication은 제공하지 않는다.\n\n<img src=\"../../images/Network/emailConfiden.jpeg\" width=\"80%\">\n\n송신자는,\n- 메세지와 symmetric key를 전송한다.\n- 메세지는 대칭키로 암호화하여 전송하고, 대칭키는 수신자의 공개 키로 암호화하여 전송한다.\n\n수신자는,\n- 암호화된 대칭키를 자신의 비밀키로 복호화하여 추출한다.\n- 추출한 대칭키를 이용해 메세지를 복호화하여 추출한다.\n\n### 🪚 e-mail: integrity, authentication\n<img src=\"../../images/Network/emailInte.jpeg\" width=\"80%\">\n\n송신자는,\n- 메세지와, 메세지를 해시 함수에 적용하고 본인의 비밀키로 암호화한 것을 전송한다.\n\n수신자는,\n- 수신한 메세지를 해시 함수에 적용한 것과,\n- 수신한 암호화된 데이터를 송신자의 공개키로 복호화한 것을 비교하여 사용한다.\n\n> confidentiality, integrity, authentication 모두 제공하기 위해, integrity, authentication을 제공하는 방법으로 데이터를 생성하고, 생성한 데이터와 대칭키를 사용해 confidentiality를 제공할 수 있다.\n\n---\n\n## 🧷 TLS\nTransport-layer security로, 아래와 같은 것을 제공한다.\n- Confidentiality: 대칭키 암호화를 통해 제공\n- Integrity: 해싱을 통해 제공\n- Authentication: 공개키 암호화를 통해 제공\n\nTLS를 위해서는 아래와 같은 것들이 필요하다.\n- handshake: 두 사용자가 서로의 인증서를 주고 받으며 존재를 인증해야 하기에!\n- key derivation: 두 사용자는 secret을 공유하면서 키를 파생시켜야 한다.\n- data transfer: 한 번의 트랜잭션이 아닌 연속적인 데이터의 공유가 필요하다.\n- connection closure\n\n<img src=\"../../images/Network/tlsInitial.jpeg\" width=\"40%\">\n\n- handshaking 과정을 통해 연결을 수행한다. 이후 공개키 인증으로 B를 확인한다.\n- A는 Master secret key(MS)를 전송하고, 이를 이용해 key derivation을 수행한다.\n\n---\n\n## 🧷 IP Sec\nDatagram(Packet) level에서 security(encryption, authentication, integrity)를 제공하기 위해 사용한다. 그리고 이에는 두 가지 모드가 있다.\n\n**Transport mode**\n<img src=\"../../images/Network/tranport.jpeg\" width=\"60%\">\n\n- datagram payload만 암호화하고, 인증한다.\n\n**Tunnel mode**\n<img src=\"../../images/Network/tunnel.jpeg\" width=\"60%\">\n\n- datagram 전체 다 암호화하고, 인증한다.\n- IP header가 더해져 새로운 datagram으로 캡슐화된다.\n\n### 🪚 두 가지 IP Sec 프로토콜\n**Authentication Header protocol**\n- 출발지 인증과 data integrity는 보장하지만, confidentiality는 제공하지 않는다.\n\n**Encapsulation Security protocol**\n- 출발지 인증과 data integrity, confidentiality 모두 제공하고, 많이 사용된다.\n\n---\n\n## 🧷 Firewall\n외부로부터 내부 네트워크를 보호하고, 반대로 내부에서 허용되지 않는 데이터 전송을 막을 수 있다. \n- DoS(Denial of Service)를 막는다.\n  - SYN flooding: 공격자가 매우 많은 TCP 연결을 수행해, 실제 필요한 연결에서 사용할 자원이 없도록 만든다.\n- illegal modification / access of internal data를 막는다.\n\n방화벽에는 3가지 종류가 있다.\n- stateless packet filters: 상태 관리를 하지 않고 패킷 하나하나에 대해 모두 검사한다.\n- stateful packet filters: 패킷에 대해 이미 허용된 연결에서 온 패킷인지 확인하고, 그렇지 않은 경우 drop\n- application gateways\n\n---\n\n## 📕 참고\n- [기술면접을 위한 Network 개념정리 08 - 네트워크 보안](https://8iggy.tistory.com/224)\n- [AES 암호 알고리즘(Advanced Encryption Standard)](https://www.crocus.co.kr/1230)\n- [[암호학] 비대치킹 암호 - RSA(공개키 암호시스템)](https://yjshin.tistory.com/entry/%EC%95%94%ED%98%B8%ED%95%99-%EB%B9%84%EB%8C%80%EC%B9%AD%ED%82%A4-%EC%95%94%ED%98%B8-RSA-%EC%95%94%ED%98%B8%EC%8B%9C%EC%8A%A4%ED%85%9C?category=738196)"},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 웹 애플리케이션과 싱글톤 대부분의 스프링 애플리케이션은 웹 애플리케이션이다. (물론 웹이 아닌 애플리케이션 개발도 얼마든지 개발 가능하다.) 웹 애플리케이션은 보통 여러 고객이 동시에 요청을 한다. 새로운 클라이언트가 요청할 때마다 인스턴스를 새로 생성하여 반환한다.  따라서, 매 요청마다…","fields":{"slug":"/[스프링핵심원리_기본편]5.싱글톤컨테이너/"},"frontmatter":{"date":"July 19, 2022","title":"📟 5. 싱글톤 컨테이너","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 웹 애플리케이션과 싱글톤\n대부분의 스프링 애플리케이션은 웹 애플리케이션이다. (물론 웹이 아닌 애플리케이션 개발도 얼마든지 개발 가능하다.)\n- 웹 애플리케이션은 보통 여러 고객이 동시에 요청을 한다.\n\n<img src=\"../../images/스프링핵심원리-기본편/클라이언트와DI컨테이너.png\" width=\"80%\">\n\n- 새로운 클라이언트가 요청할 때마다 인스턴스를 새로 생성하여 반환한다. \n- 따라서, 매 요청마다 새로운 인스턴스를 생성하여 요청 수만큼 생성된다.\n  - 이전에 수행했던 `AppConfig` 를 이용한 방식이 이와 같다.\n\n**스프링 없는 순수한 DI 컨테이너 테스트**\n```java\npackage hello.core.singleton;\n\nimport hello.core.AppConfig;\nimport hello.core.member.MemberService;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\n\nimport static org.assertj.core.api.Assertions.*;\n\npublic class SingletonTest {\n\n    @Test\n    @DisplayName(\"스프링 없는 순수한 DI 컨테이너\")\n    void pureContainer() {\n        AppConfig appConfig = new AppConfig();\n\n        // 1. 조회: 호출할 때마다 객체를 생성\n        MemberService memberService1 = appConfig.memberService();\n\n        // 2. 조회: 호출할 때마다 객체를 생성\n        MemberService memberService2 = appConfig.memberService();\n\n        // 참조값이 다른지 확인\n        System.out.println(\"memberService1 = \" + memberService1);\n        System.out.println(\"memberService2 = \" + memberService2);\n\n        assertThat(memberService1).isNotSameAs(memberService2);\n    }\n} \n```\n\n- 이전에 만든 스프링 없는 순수한 DI 컨테이너인 `AppConfig` 는 요청마다 객체를 새로 생성한다.\n- 고객 트래픽이 초당 100이라고 가정하면, 초당 100개의 객체를 생성하고 소멸한다. 이는 심각한 메모리 낭비를 초래한다.\n\n> 이에 대한 해결방안으로 **해당 객체가 딱 1개만 생성되고, 이를 공유하도록 설계한다. -> 싱글톤 패턴**\n\n---\n\n## 🎯 싱글톤 패턴\n**클래스의 인스턴스가 딱 1개만 생성되는 것을 보장하는 디자인 패턴**이다.\n- 객체 인스턴스를 2개 이상 생성하지 못하도록 막아야 한다!\n  - `private` 생성자를 이용해 외부에서 임의로 `new` 키워드를 사용하지 못하도록 막아야 한다.\n\n```java\npackage hello.core.singleton;\n\npublic class SingletonService {\n\n    // 자기 자신을 내부에 private으로 가짐\n    // 이때 static으로 가지기에 클래스 레벨에 딱 1개만 생성된다.\n    private static final SingletonService instance = new SingletonService();\n\n    public static SingletonService getInstance() {\n        // 내부적으로 new SingletonService를 실행해 참조값을 넣어놓은 instance를 반환\n        return instance;\n    }\n}\n```\n- 위와 같이 `getInstance()` 를 통해 생성해놓은 `SingletonService` 를 반환받을 수 있도록 구현한다.\n- 하지만 외부에서 임의로 `new SingletonService()` 를 호출한다면, 여러 개의 인스턴스를 생성하게 된다.\n\n```java\npackage hello.core.singleton;\n\npublic class SingletonService {\n\n    // 자기 자신을 내부에 private으로 가짐\n    // 이때 static으로 가지기에 클래스 레벨에 딱 1개만 생성된다.\n    private static final SingletonService instance = new SingletonService();\n\n    public static SingletonService getInstance() {\n        // 내부적으로 new SingletonService를 실행해 참조값을 넣어놓은 instance를 반환\n        return instance;\n    }\n\n    private SingletonService() {\n\n    }\n\n    public void logic() {\n        System.out.println(\"싱글톤 객체 로직 호출\");\n    }\n}\n```\n\n1. `static` 영역에 객체 `instance` 를 미리 하나 생성해 올려둔다.\n2. 이 객체 인스턴스가 필요하면 오직 `getInstance()` 메소드를 통해서만 조회할 수 있다. 이 메소드는 항상 같은 인스턴스를 반환한다.\n3. 딱 1개의 객체 인스턴스만 존재해야 하므로, 생성자를 `private` 으로 막아 혹시라도 외부에서 `new` 키워드로 객체 인스턴스가 생성되는 것을 막는다.\n\n**싱글톤 패턴을 사용하는 테스트 코드**\n```java\n@Test\n@DisplayName(\"싱글톤 패턴을 적용한 객체 사용\")\nvoid singletonServiceTest() {\n    SingletonService singletonService1 = SingletonService.getInstance();\n    SingletonService singletonService2 = SingletonService.getInstance();\n\n    System.out.println(\"singletonService1 = \" + singletonService1);\n    System.out.println(\"singletonService2 = \" + singletonService2);\n\n    assertThat(singletonService1).isSameAs(singletonService2);\n    // same ==\n    // equal \n}\n```\n\n- `private` 으로 `new` 키워드를 막아두었다.\n- **호출마다 같은 객체 인스턴스를 반환**하는 것을 확인할 수 있다.\n\n> 싱글톤 패턴을 구현하는 방법은 매우 많다. 여기서는 객체를 미리 생성해두는 가장 단순하고 안전한 방법을 구현했다.\n\n이미 만들어진 객체를 공유해서 효율적으로 사용할 수 있지만, **싱글톤 패턴은 다음과 같은 문제점들**을 가지고 있다.\n- 싱글톤 패턴을 구현하는 코드 자체가 많이 들어간다.\n- 의존관계상 클라이언트가 구체 클래스에 의존한다. -> DIP 위반!!!\n- 클라이언트가 구체 클래스에 의존해서 OCP 원칙을 위반할 가능성이 높다.\n- 테스트가 어렵다.\n- 내부 속성을 변경하거나 초기화하기 어렵다.\n- `private` 생성자로 인해 자식 클래스를 만들기 어렵다.\n- 결론적으로 유연성이 떨어진다. (DI의 적용을 어렵게 함)\n- 안티 패턴으로 불리기도 한다.\n\n---\n\n## 🎯 싱글톤 컨테이너\n스프링 컨테이너는 **싱글톤 패턴의 문제점을 해결**하면서, **객체 인스턴스를 싱글톤(1개만 생성)으로 관리**한다.\n- 지금까지 배운 스프링 빈이 바로 싱글톤으로 관리되는 빈이다!\n\n### 🪔 싱글톤 컨테이너\n- 스프링 컨테이너는 싱글톤 패턴을 적용하지 않아도, 객체 인스턴스를 싱글톤으로 관리한다.\n  - 이전에 다룬 컨테이너 생성 과정을 자세히 보면, **컨테이너는 객체를 하나만 생성해서 관리**한다.\n- 스프링 컨테이너는 싱글톤 컨테이너 역할을 한다. 이렇게 싱글톤 객체를 생성하고 관리하는 기능을 싱글톤 레지스트리라 한다.\n- 스프링 컨테이너의 이런 기능덕에 싱글톤 패턴의 모든 단점을 해결하면서 객체를 싱글톤으로 유지할 수 있다.\n  - 지저분한 코드가 들어가지 않아도 된다.\n  - DIP, OCP, 테스트, `private` 생성자로부터 자유롭게 싱글톤을 사용할 수 있다.\n\n**스프링 컨테이너를 사용하는 테스트 코드**\n```java\n@Test\n@DisplayName(\"스프링 컨테이너와 싱글톤\")\nvoid springContainer() {\n//        AppConfig appConfig = new AppConfig();\n    ApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n    // 1. 조회: 호출할 때마다 객체를 생성\n//        MemberService memberService1 = appConfig.memberService();\n    MemberService memberService1 = ac.getBean(\"memberService\", MemberService.class);\n\n    // 2. 조회: 호출할 때마다 객체를 생성\n    MemberService memberService2 = ac.getBean(\"memberService\", MemberService.class);\n//        MemberService memberService2 = appConfig.memberService();\n\n    // 참조값이 같은지 확인\n    System.out.println(\"memberService1 = \" + memberService1);\n    System.out.println(\"memberService2 = \" + memberService2);\n\n    assertThat(memberService1).isSameAs(memberService2);\n}\n```\n\n- 스프링 컨테이너에 등록한 빈이 계속 조회되어 같은 참조값을 가지는 것을 확인할 수 있다.\n  - 그리고 `MemberService` 코드를 확인해보아도, **싱글톤과 관련된 코드는 하나도 없는 것을 확인할 수 있다.**\n\n**싱글톤 컨테이너 적용 후**\n<img src=\"../../images/스프링핵심원리-기본편/싱글톤컨테이너적용후.png\" width=\"80%\">\n\n- 스프링 컨테이너 덕분에 고객의 요청마다 객체를 생성하는 것이 아닌 **이미 만들어진 객체를 공유해서 효율적인 재사용이 가능**해졌다.\n\n> 스프링의 기본 빈 등록 방식은 싱글톤이지만, 싱글톤 방식만 지원하는 것은 아니다. \n> - 요청마다 새로운 객체를 생성해서 반환하는 기능도 제공하긴 한다!\n\n---\n\n## 🎯 싱글톤 방식의 주의점\n싱글톤 패턴이든, 스프링과 같은 싱글톤 컨테이너를 사용하든, 객체 인스턴스를 하나만 생성해서 공유하는 싱글톤 방식은 여러 클라이언트가 하나의 같은 객체 인스턴스를 공유하기에, **싱글톤 객체는 상태를 유지하게 설계하면 안된다!**\n- 즉, **무상태(stateless)로 설계**해야 한다!\n  - 특정 클라이언트에 의존적인 필드가 있으면 안된다! (특정 클라이언트가 값을 바꾸게 두면 안된다!)\n  - 특정 클라이언트가 값을 변경할 수 있는 필드가 있으면 안된다!\n  - 가급적 읽기만 가능해야 한다. (값의 수정이 없도록 해야 한다.)\n  - 필드 대신에 자바에서 공유되지 않는, 지역변수, 파라미터, ThreadLocal 등을 사용해야 한다.\n- 스프링 빈의 필드에 공유 값을 설정하면 정말 큰 장애가 발생할 수 있다..!\n\n**상태를 유지할 경우 발생하는 문제점 예시**\n```java\npackage hello.core.singleton;\n\npublic class StatefulService {\n    // 상태를 유지하는 필드\n    private int price;\n    \n    public void order(String name, int price) {\n        System.out.println(\"name = \" + name + \" price = \" + price);\n        \n        // 여기가 문제!!!\n        this.price = price;\n    }\n    \n    public int getPrice() {\n        return price;\n    }\n}\n\n//\n\npackage hello.core.singleton;\n\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Bean;\nimport static org.assertj.core.api.Assertions.*;\n\nclass StatefulServiceTest {\n\n    @Test\n    void statefulServiceSingleton() {\n        // TestConfig로 ac 생성\n        ApplicationContext ac = new AnnotationConfigApplicationContext(TestConfig.class);\n        StatefulService statefulService1 = ac.getBean(StatefulService.class);\n        StatefulService statefulService2 = ac.getBean(StatefulService.class);\n\n        // ThreadA: A 사용자가 10000원 주문\n        statefulService1.order(\"userA\", 10000);\n        // ThreadB: B 사용자가 20000원 주문\n        statefulService2.order(\"userB\", 20000);\n\n        // ThreadA: A 사용자가 주문 금액 조회 -> 과연 얼마가 나올까?\n        int price = statefulService1.getPrice();\n\n        System.out.println(\"price = \" + price);\n\n        assertThat(statefulService1.getPrice()).isEqualTo(20000);\n    }\n\n    static class TestConfig {\n\n        @Bean\n        public StatefulService statefulService() {\n            return new StatefulService();\n        }\n    }\n}\n```\n\n- `StatefulServiceTest` 의 출력문에서 기대한 값은 10000원이다.\n  - 사용자 A가 주문한 금액이 10000원이고, 이를 다시 조회한 것이므로 10000원을 기대했다.\n  - 하지만, 중간에 사용자 B의 주문이 끼어들어 기대와 다른 값이 출력되었다. (사용자 B의 주문이 `StatefulService` 의 `price` 필드를 20000으로 변경!!!)\n  - 그리고, `statefulService1` 과 `statefulService2` 로 다른 인스턴스를 사용했다해도, 사실 둘은 같은 참조값을 갖는 인스턴스이기에 동일하다.\n- 이를 해결하기 위해 `order` 를 `int` 형으로 변환하고, `price` 필드 제거, `price` 를 반환하는 형태로 바꿀 수 있다.\n\n---\n\n## 🎯 @Configuration과 싱글톤\n> `@Configuration` 은 싱글톤을 위해 존재한다.\n\n`AppConfig` 를 보면 이상한 점이 있다.\n\n```java\npackage hello.core;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.discount.RateDiscountPolicy;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.member.MemoryMemberRepository;\nimport hello.core.order.OrderService;\nimport hello.core.order.OrderServiceImpl;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\n@Configuration\npublic class AppConfig {\n    \n    // @Bean memberService -> new MemoryMemberRepository()\n    \n    // @Bean orderService -> new MemoryMemberRepository()\n\n    @Bean\n    public MemberService memberService() {\n        return new MemberServiceImpl(memberRepository());\n    }\n\n    @Bean\n    public MemberRepository memberRepository() {\n        return new MemoryMemberRepository();\n    }\n\n    @Bean\n    public OrderService orderService() {\n        return new OrderServiceImpl(\n                memberRepository(),\n                discountPolicy()\n        );\n    }\n    \n    ...\n}\n```\n\n- `memberService` 빈을 만드는 코드를 보면, `memberRepository()` 를 호출한다.\n  - 이때 `new MemoryMemberRepository()` 를 호출한다.\n- `orderService` 빈을 만드는 코드를 보면, 동일하게 `memberRepository()` 를 호출한다.\n  - 이때 `new MemoryMemberRepository()` 를 호출한다.\n\n결과적으로 각각 다른 2개의 `MemoryMemberRepository` 가 생성되면서 싱글톤이 깨지는 것처럼 보인다!!!\n- 스프링 컨테이너는 이를 어떻게 해결할까?\n\n**검증 용도의 테스트 코드 추가**\n- `memberService` 와 `orderService` 에서 생성하는 `memberRepository` 의 구체 클래스가 같은 것처럼 보인다.\n- 따라서 두 구현 클래스에서 테스트 용으로 `MemberRepository` 를 조회할 수 있는 메소드를 추가한다.\n\n```java\npackage hello.core.member;\n\npublic class MemberServiceImpl implements MemberService {\n\n    private final MemberRepository memberRepository;\n\n    // 테스트 용도\n    public MemberRepository getMemberRepository() {\n        return memberRepository;\n    }\n}\n\n//\n\npackage hello.core.order;\n\npublic class OrderServiceImpl implements OrderService {\n\n    // 회원을 찾기 위해 필요\n    private final MemberRepository memberRepository;\n    \n    // 테스트 용도\n    public MemberRepository getMemberRepository() {\n        return memberRepository;\n    }\n}\n```\n\n**테스트 코드**\n```java\npackage hello.core.singleton;\n\nimport hello.core.AppConfig;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.order.OrderServiceImpl;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\npublic class ConfigurationSingletonTest {\n\n    @Test\n    void configurationTest() {\n        ApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n        MemberServiceImpl memberService = ac.getBean(MemberServiceImpl.class);\n        OrderServiceImpl orderService = ac.getBean(OrderServiceImpl.class);\n        MemberRepository memberRepository = ac.getBean(\"memberRepository\", MemberRepository.class);\n\n        MemberRepository memberRepository1 = memberService.getMemberRepository();\n        MemberRepository memberRepository2 = orderService.getMemberRepository();\n        \n        // 모두 같은 인스턴스를 참조하고 있다.\n        System.out.println(\"memberService -> memberRepository = \" + memberRepository1);\n        System.out.println(\"orderService -> memberRepository = \" + memberRepository2);\n        System.out.println(\"memberRepository = \" + memberRepository);\n    }\n}\n```\n- 모두 같은 인스턴스를 참조하고 있는 것을 확인할 수 있다.\n- 각각 서로 `new MemoryMemberRepository()` 를 호출했는데 어떻게 가능한 것일까..?\n  - `memberService()` , `@Bean` 으로 인한 빈 등록 시 호출, `orderService()` 로 총 3번의 호출이 될텐데 .. ?!\n  - `AppConfig` 에서 호출마다 출력문을 작성해 실행하면 출력 결과는 모두 1번만 호출되어 총 3개의 출력문을 확인할 수 있다.\n  - `memberService() -> memberRepository()`\n  - `memberRepository()`\n  - `orderService() -> memberRepository()`\n  - 총 출력문이 5개가 나와야 하는데 ..?\n\n> 스프링 컨테이너는 어떻게든 싱글톤 방식을 보장하는구나..!\n\n---\n\n## 🎯 @Configuration과 바이트코드 조작의 마법\n스프링 컨테이너는 **싱글톤 레지스트리**다. 따라서 스프링 빈이 싱글톤이 되도록 보장해야 한다!\n- 하지만 스프링이 자바 코드까지 어떻게 할 수는 없다. \n  - 위에서 저 자바 코드만 봤을때, 분명 `memberRepository()` 는 3번 호출되어야 하는 것이 맞다.\n- 그래서 스프링은 클래스의 바이트코드를 조작하는 라이브러리를 사용한다.\n- `@Configuration` 을 적용한 `AppConfig` 를 확인한다.\n\n```java\n@Test\nvoid configurationDeep() {\n    // AppConfig 또한 빈으로 등록됨!!!\n    ApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n    AppConfig bean = ac.getBean(AppConfig.class);\n\n    System.out.println(\"bean = \" + bean.getClass());\n    // 출력: bean = class hello.core.AppConfig$$EnhancerBySpringCGLIB$$79b7202a\n}\n```\n\n- 빈으로 등록된 `AppConfig` 의 클래스 타입을 출력하면, `EnhancerBySpringCGLIB` 이라는 정보가 출력되는 것을 확인할 수 있다.\n  - 순수한 클래스라면, `class hello.core.AppConfig` 가 출력되어야 한다.\n- 이는 내가 만든 클래스가 아니라, 스프링이 `CGLIB` 라는 바이트코드 조작 라이브러리를 사용해 `AppConfig` 클래스를 상속받은 임의의 다른 클래스를 만들고, 이를 스프링 빈으로 등록한 것이다!!!\n\n<img src=\"../../images/스프링핵심원리-기본편/CGLIB.png\" width=\"80%\">\n\n- 그리고 이 임의의 클래스가 싱글톤이 보장되도록 한다.\n- 그리고 이 과정은 `@Configuration` 어노테이션을 통해 수행된다.\n\n**AppConfig@CGLIB 예상 코드**\n```java\n@Bean\npublic MemberRepository memberRepository() {\n    \n    if (memoryMemberRepository가 이미 스프링 컨테이너에 등록되어 있으면?) { \n        return 스프링 컨테이너에서 찾아서 반환;\n    } else { //스프링 컨테이너에 없으면\n        기존 로직을 호출해서 MemoryMemberRepository를 생성하고 스프링 컨테이너에 등록 \n        return 반환\n    } \n}\n```\n\n- `@Bean` 이 붙은 메소드마다 이미 스프링 빈이 존재하면, 존재하는 빈을 반환하고, 없다면 생성해서 스프링 빈으로 등록하고 반환하는 코드가 동적으로 만들어진다.\n  - 이 덕분에 싱글톤이 보장된다.\n\n> `AppConfig@CGLIB` 는 `AppConfig` 의 자식 타입이다. 따라서 부모 타입인 `AppConfig` 타입으로 조회가 가능했던 것이다.\n\n### 🪔 @Configuration 없이 @Bean만 적용하면 어떻게 될까?\n`@Configuration` 을 붙여 바이트코드를 조작하는 CGLIB 기술을 사용해서 싱글톤을 보장하지만, `@Bean` 만 적용하면 어떻게 될까?\n- `@Configuration` 삭제 후, 다시 출력을 보면 `bean = class hello.core.AppConfig` 와 같이 순수한 `AppConfig` 로 스프링 빈에 등록된 것을 확인할 수 있다.\n\n하지만! 싱글톤이 보장되지 않아, 빈 등록 시 호출되는 출력문이 총 5번 출력되는 것을 확인할 수 있다. (`MemberRepository` 가 총 3번 모두 호출됨)\n- **당연히 모두 다른 인스턴스로 생성**될 것이다!!!\n\n> 스프링 설정 정보는 항상 `@Configuration` 을 명시하여 싱글톤을 보장하도록 하자.\n\n## 📌 중요한 개념\n싱글톤 패턴, 무상태 설계, `@Configuration`\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"문제 Programmers - 파괴되지 않은 건물 📍 Logic 주어진 범위의 누적합 계산을 위해 범위 내의 배열 값을 누적합하는 함수 📄 CODE ✏️ Review 처음에는  값을 다 읽고 최종적으로  에 증감할 값을 만들어두고 0보다 큰 경우의 개수를 세는 방식으로 구현했는데 당연히도 시간 초과가 났다. 여기서 더 이상 시간을 줄일 방법을 모르겠어서 카…","fields":{"slug":"/[Programmers]92344/"},"frontmatter":{"date":"July 17, 2022","title":"👩‍💻 92344. 파괴되지 않은 건물","tags":["누적합"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 파괴되지 않은 건물](https://programmers.co.kr/learn/courses/30/lessons/92344)\n\n### 📍 **Logic**\n\n```java\nprivate void fill(int r1, int c1, int r2, int c2, int deg) {\n    attackOrHeal[r1][c1] += deg;\n    if (c2 + 1 < cSize) attackOrHeal[r1][c2 + 1] += -deg;\n    if (r2 + 1 < rSize) attackOrHeal[r2 + 1][c1] += -deg;\n    if (r2 + 1 < rSize && c2 + 1 < cSize) attackOrHeal[r2 + 1][c2 + 1] += deg;\n}\n```\n\n- 주어진 범위의 누적합 계산을 위해 범위 내의 배열 값을 누적합하는 함수\n \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        static int[][] attackOrHeal;\n        static int[][] board;\n        static int rSize;\n        static int cSize;\n        \n        public int solution(int[][] board, int[][] skill) {\n            this.board = board;\n            this.rSize = board.length;\n            this.cSize = board[0].length;\n            attackOrHeal = new int[rSize][cSize];\n            \n            for (int[] sk : skill) {\n                boolean attack = sk[0] == 1;\n                int r1 = sk[1];\n                int c1 = sk[2];\n                int r2 = sk[3];\n                int c2 = sk[4];\n                int deg = sk[5];\n\n                if (attack) fill(r1, c1, r2, c2, -deg);\n                else fill(r1, c1, r2, c2, deg);\n            }\n            \n            accumulate();\n            \n            return countUndestroyedBuildings();\n        }\n        \n        // 각 열별 오른쪽 누적합, 각 행별 아래쪽 누적합 계산\n        private void accumulate() {\n            for (int i = 0; i < rSize; i++)\n                for (int j = 1; j < cSize; j++)\n                    attackOrHeal[i][j] += attackOrHeal[i][j - 1];\n            \n            for (int i = 1; i < rSize; i++)\n                for (int j = 0; j < cSize; j++)\n                    attackOrHeal[i][j] += attackOrHeal[i - 1][j];\n        }\n        \n        // 누적합 배열과 board를 계산하여 내구도가 0보다 큰 건물 카운트\n        private int countUndestroyedBuildings() {\n            int count = 0;\n            \n            for (int i = 0; i < rSize; i++) \n                for (int j = 0; j < cSize; j++) \n                    if (board[i][j] + attackOrHeal[i][j] > 0) count++;\n            \n            return count;\n        }\n        \n        // 시간 복잡도를 줄이기 위해 누적합을 사용하는데, 이를 위해 필요한 배열 범위의 값 채우기\n        private void fill(int r1, int c1, int r2, int c2, int deg) {\n            attackOrHeal[r1][c1] += deg;\n            if (c2 + 1 < cSize) attackOrHeal[r1][c2 + 1] += -deg;\n            if (r2 + 1 < rSize) attackOrHeal[r2 + 1][c1] += -deg;\n            if (r2 + 1 < rSize && c2 + 1 < cSize) attackOrHeal[r2 + 1][c2 + 1] += deg;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 `skill` 값을 다 읽고 최종적으로 `board` 에 증감할 값을 만들어두고 0보다 큰 경우의 개수를 세는 방식으로 구현했는데 당연히도 시간 초과가 났다.\n- 여기서 더 이상 시간을 줄일 방법을 모르겠어서 카카오 풀이를 참고했다. 뭔가 비슷한 느낌이긴 한데, 누적합 배열을 사용해 시간복잡도를 줄일 수 있었다..\n  - 그치만 이런 풀이는 누적합 문제를 가지고 놀 정도가 되어야 떠오를 것 같다...."},{"excerpt":"문제 Programmers - 사라지는 발판 📍 Logic A가 움직일 차례와, B가 움직일 차례를 나누어 생각한다. DFS방식으로 움직이면서, 이기는 경우와 지는 경우의 이동횟수를 갱신한다. 📄 CODE ✏️ Review 이길 수 있는 플레이어는 최대한 빨리 승리하고, 질 수밖에 없는 플레이어는 최대한 오래 버틴다라는 조건에 있어 조금 독특한 문제가 아니…","fields":{"slug":"/[Programmers]92345/"},"frontmatter":{"date":"July 17, 2022","title":"👩‍💻 92345. 사라지는 발판","tags":["DFS","완전 탐색"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 사라지는 발판](https://programmers.co.kr/learn/courses/30/lessons/92345)\n\n### 📍 **Logic**\n\n```java\nprivate Result dfs(int aX, int aY, int bX, int bY, int moveA, int moveB) {\n    boolean win = false;\n    int minCount = 5 * 5;\n    int maxCount = moveA + moveB;\n    \n    if (moveA == moveB && board[aX][aY] == 1) {\n        // a가 움직일 차례\n        for (int[] d : dir) {\n            int naX = aX + d[0];\n            int naY = aY + d[1];\n\n            if (!checkBoundary(naX, naY)) continue;\n            \n            board[aX][aY] = 0;\n            Result r = dfs(naX, naY, bX, bY, moveA + 1, moveB);\n            win |= !r.win;\n            if (!r.win) minCount = Math.min(minCount, r.count);\n            else maxCount = Math.max(maxCount, r.count);\n\n            board[aX][aY] = 1;\n        }\n    } else if (moveA > moveB && board[bX][bY] == 1) {\n        // b가 움직일 차례\n        for (int[] d : dir) {\n            int nbX = bX + d[0];\n            int nbY = bY + d[1];\n\n            if (!checkBoundary(nbX, nbY)) continue;\n            \n            board[bX][bY] = 0;\n            // dfs의 결과는 본인이 아닌 다른 사람의 결과이므로, 승패가 반대이다.\n            // 또한 r.win = true인 경우가 하나라도 있을 경우 win은 true가 되어야 하므로 or연산을 수행한다.\n            Result r = dfs(aX, aY, nbX, nbY, moveA, moveB + 1);\n            win |= !r.win;\n\n            // 본인이 이기는 경우라면 최대한 빨리 이길 때의 이동횟수를 갱신한다.\n            if (!r.win) minCount = Math.min(minCount, r.count);\n            // 본인이 지는 경우라면 최대한 오래 버틸 때의 이동횟수를 갱신한다.\n            else maxCount = Math.max(maxCount, r.count);\n\n            board[bX][bY] = 1;\n        }\n    }\n    \n    return new Result(win, win ? minCount : maxCount);\n}\n```\n\n- A가 움직일 차례와, B가 움직일 차례를 나누어 생각한다.\n- DFS방식으로 움직이면서, 이기는 경우와 지는 경우의 이동횟수를 갱신한다.\n \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Result {\n        boolean win;\n        int count;\n        \n        public Result(boolean win, int count) {\n            this.win = win;\n            this.count = count;\n        }\n    }\n\n    class Solution {\n        static int[][] dir = {{ -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 }};\n        static int[][] board;\n        static int N;\n        static int M;\n        \n        public int solution(int[][] board, int[] aloc, int[] bloc) {\n            this.board = board;\n            this.N = board.length;\n            this.M = board[0].length;\n            \n            return dfs(aloc[0], aloc[1], bloc[0], bloc[1], 0, 0).count;\n        }\n        \n        private Result dfs(int aX, int aY, int bX, int bY, int moveA, int moveB) {\n            boolean win = false;\n            int minCount = 5 * 5;\n            int maxCount = moveA + moveB;\n            \n            if (moveA == moveB && board[aX][aY] == 1) {\n                // a가 움직일 차례\n                for (int[] d : dir) {\n                    int naX = aX + d[0];\n                    int naY = aY + d[1];\n\n                    if (!checkBoundary(naX, naY)) continue;\n                    \n                    board[aX][aY] = 0;\n                    Result r = dfs(naX, naY, bX, bY, moveA + 1, moveB);\n                    win |= !r.win;\n                    if (!r.win) minCount = Math.min(minCount, r.count);\n                    else maxCount = Math.max(maxCount, r.count);\n\n                    board[aX][aY] = 1;\n                }\n            } else if (moveA > moveB && board[bX][bY] == 1) {\n                // b가 움직일 차례\n                for (int[] d : dir) {\n                    int nbX = bX + d[0];\n                    int nbY = bY + d[1];\n\n                    if (!checkBoundary(nbX, nbY)) continue;\n                    \n                    board[bX][bY] = 0;\n                    // dfs의 결과는 본인이 아닌 다른 사람의 결과이므로, 승패가 반대이다.\n                    // 또한 r.win = true인 경우가 하나라도 있을 경우 win은 true가 되어야 하므로 or연산을 수행한다.\n                    Result r = dfs(aX, aY, nbX, nbY, moveA, moveB + 1);\n                    win |= !r.win;\n\n                    // 본인이 이기는 경우라면 최대한 빨리 이길 때의 이동횟수를 갱신한다.\n                    if (!r.win) minCount = Math.min(minCount, r.count);\n                    // 본인이 지는 경우라면 최대한 오래 버틸 때의 이동횟수를 갱신한다.\n                    else maxCount = Math.max(maxCount, r.count);\n\n                    board[bX][bY] = 1;\n                }\n            }\n            \n            return new Result(win, win ? minCount : maxCount);\n        }\n        \n        private boolean checkBoundary(int x, int y) {\n            return (x >= 0 && x < N && y >= 0 && y < M && board[x][y] != 0) ;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 이길 수 있는 플레이어는 최대한 빨리 승리하고, 질 수밖에 없는 플레이어는 최대한 오래 버틴다라는 조건에 있어 조금 독특한 문제가 아니었나싶다.\n- 중복되는 로직을 떼내어야 할 것 같다.\n- 역시 마지막 문제는 어렵다 ..."},{"excerpt":"문제 Programmers - 양과 늑대 📍 Logic 현 노드에서 갈 수 있는 노드 리스트를 생성하는 함수 연결된 자식 노드로만 이동할 수 있는 게 아니라, 지나왔던 노드 또한 재방문 가능하기에 두 번째 반복문에서 이를 처리한다. 📄 CODE ✏️ Review 처음에는 DFS로 해결해야 하나 생각해보다가, 뭔가 BFS로 풀어보고 싶었고, 양의 수와 늑대의…","fields":{"slug":"/[Programmers]92343/"},"frontmatter":{"date":"July 14, 2022","title":"👩‍💻 92343. 양과 늑대","tags":["BFS"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 양과 늑대](https://programmers.co.kr/learn/courses/30/lessons/92343)\n\n### 📍 **Logic**\n\n```java\nprivate ArrayList<Integer> makeList(ArrayList<Integer> nowNodeList, int nowN, int nextNode) {\n    // 이동할 수 있는 노드를 저장할 리스트\n    ArrayList<Integer> nextList = new ArrayList<>();\n\n    // 다음 노드에서 갈 수 있는 노드를 저장, 연결된 자식 노드에 대해서만!\n    for (int fromNextNode : infoList.get(nextNode)) nextList.add(fromNextNode);\n\n    // 현 노드까지 오는데 방문했던 노드들 중 현 노드와 직전에 방문한 노드를 제외하고 저장, DFS로 따지면 백트래킹하는 느낌..\n    for (int checkNode : nowNodeList) \n        if (checkNode != nowN && checkNode != nextNode)\n            nextList.add(checkNode);\n    \n    return nextList;\n}\n```\n\n- 현 노드에서 갈 수 있는 노드 리스트를 생성하는 함수\n- 연결된 자식 노드로만 이동할 수 있는 게 아니라, 지나왔던 노드 또한 재방문 가능하기에 두 번째 반복문에서 이를 처리한다.\n \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Node {\n        int num;\n        int sheepCount;\n        int wolfCount;\n        // 갈 수 있는 노드를 저장하는 리스트!\n        ArrayList<Integer> list;\n        \n        public Node(int num, int sheepCount, int wolfCount, ArrayList<Integer> list) {\n            this.num = num;\n            this.sheepCount = sheepCount;\n            this.wolfCount = wolfCount;\n            this.list = list;\n        }\n    }\n\n    class Solution {\n        static ArrayList<ArrayList<Integer>> infoList;\n        static int[] info;\n        \n        public int solution(int[] info, int[][] edges) {\n            init(info.length, edges);\n            this.info = info;\n            \n            return bfs();\n        }\n        \n        private void init(int length, int[][] edges) {\n            infoList = new ArrayList<>();\n            \n            for (int i = 0; i < length; i++)\n                infoList.add(new ArrayList<>());\n            \n            for (int[] edge : edges) {\n                int n1 = edge[0];\n                int n2 = edge[1];\n                \n                infoList.get(n1).add(n2);\n            }\n        }\n        \n        private int bfs() {\n            Queue<Node> queue = new LinkedList<>();\n            queue.add(new Node(0, 1, 0, infoList.get(0)));\n            int max = 0;\n            \n            while(!queue.isEmpty()) {\n                Node now = queue.poll();\n                int nowN = now.num;\n                int sheepCount = now.sheepCount;\n                int wolfCount = now.wolfCount;\n                ArrayList<Integer> nowNodeList = now.list;\n                \n                if (max < sheepCount)\n                    max = sheepCount;\n                \n                // 현 노드에서 갈 수 있는 노드에 대해 확인\n                // nowN = 0, nextNode = {1, 8}, fromNextNode = {{2, 4}, {7, 9}}\n                for (int nextNode : nowNodeList) {\n                    // 양이거나, 늑대의 수가 양의 수보다 적은 경우\n                    if (info[nextNode] == 0)\n                        queue.add(new Node(nextNode, sheepCount + 1, wolfCount, makeList(nowNodeList, nowN, nextNode)));\n                    else\n                        if (wolfCount + 1 < sheepCount)\n                            queue.add(new Node(nextNode, sheepCount, wolfCount + 1, makeList(nowNodeList, nowN, nextNode)));\n                }\n            }\n            \n            return max;\n        }\n        \n        private ArrayList<Integer> makeList(ArrayList<Integer> nowNodeList, int nowN, int nextNode) {\n            // 이동할 수 있는 노드를 저장할 리스트\n            ArrayList<Integer> nextList = new ArrayList<>();\n\n            // 다음 노드에서 갈 수 있는 노드를 저장, 연결된 자식 노드에 대해서만!\n            for (int fromNextNode : infoList.get(nextNode)) nextList.add(fromNextNode);\n\n            // 현 노드까지 오는데 방문했던 노드들 중 현 노드와 직전에 방문한 노드를 제외하고 저장, DFS로 따지면 백트래킹하는 느낌..\n            for (int checkNode : nowNodeList) \n                if (checkNode != nowN && checkNode != nextNode)\n                    nextList.add(checkNode);\n            \n            return nextList;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 DFS로 해결해야 하나 생각해보다가, 뭔가 BFS로 풀어보고 싶었고, 양의 수와 늑대의 수에 따라 원래는 못 갔던 노드라도 다시 갈 수 있는 경우가 발생하기에 일종의 백트래킹 구현이 필요했다.\n  - 아이디어는 잡을 수 있었으나, 다시 방문해야 하는 경우에 대한 구현에 있어서는 참고가 필요했다...\n  - 참고를 보고 나서, 이런 응용 문제를 시간 안에 풀어야 박살낼 수 있지 않을까 .. 하는 생각 ..."},{"excerpt":"문제 Programmers - 양궁대회 📍 Logic DFS로 라이언이 어피치보다 화살을 많이 쏘지 않은 경우에 대해 화살을 쏜다. 1부터 n+1까지 진행하면서, 라이언과 어피치의 점수를 계산하고, 점수 차가 큰 경우를  에 갱신하면서 라이언의 과녁 점수를 갱신한다. 이때  랑 같은 경우여도 갱신하도록 하여, 점수 차가 같은 경우 가장 낮은 점수를 많이 …","fields":{"slug":"/[Programmers]92342/"},"frontmatter":{"date":"July 13, 2022","title":"👩‍💻 92342. 양궁대회","tags":["DFS"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 양궁대회](https://programmers.co.kr/learn/courses/30/lessons/92342)\n\n### 📍 **Logic**\n\n```java\nprivate static void dfs(int cnt) {\n    if (cnt == n + 1) {\n        // 점수 계산\n        int ryanScore = 0;\n        int apeachScore = 0;\n        \n        for (int i = 0; i <= 10; i++) {\n            if (info[i] == 0 && ryan[i] == 0) continue;\n            \n            if (info[i] < ryan[i]) ryanScore += 10 - i;\n            else apeachScore += 10 - i;\n        }\n        \n        if (ryanScore > apeachScore && ryanScore - apeachScore >= max) {\n            max = ryanScore - apeachScore;\n            answer = ryan.clone();\n        }\n        \n        return;\n    }\n    // ryan이 쏜 화살이 info보다 크면 진행할 필요 없음\n    for (int i = 0; i <= 10 && ryan[i] <= info[i]; i++) {\n        ryan[i]++;\n        dfs(cnt + 1);\n        ryan[i]--;\n    }\n}\n```\n\n- DFS로 라이언이 어피치보다 화살을 많이 쏘지 않은 경우에 대해 화살을 쏜다.\n- 1부터 n+1까지 진행하면서, 라이언과 어피치의 점수를 계산하고, 점수 차가 큰 경우를 `max` 에 갱신하면서 라이언의 과녁 점수를 갱신한다.\n  - 이때 `max` 랑 같은 경우여도 갱신하도록 하여, 점수 차가 같은 경우 가장 낮은 점수를 많이 쏜 경우로 과녁 점수를 갱신할 수 있도록 한다.\n \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        static int n;\n        static int[] info;\n        static int[] ryan;\n        static int[] answer = new int[]{ -1 };\n        static int max = 0;\n        \n        public int[] solution(int n, int[] info) {\n            this.n = n;\n            this.info = info;\n            this.ryan = new int[11];\n            \n            dfs(1);\n            \n            return answer;\n        }\n        \n        private static void dfs(int cnt) {\n            if (cnt == n + 1) {\n                // 점수 계산\n                int ryanScore = 0;\n                int apeachScore = 0;\n                \n                for (int i = 0; i <= 10; i++) {\n                    if (info[i] == 0 && ryan[i] == 0) continue;\n                    \n                    if (info[i] < ryan[i]) ryanScore += 10 - i;\n                    else apeachScore += 10 - i;\n                }\n                \n                if (ryanScore > apeachScore && ryanScore - apeachScore >= max) {\n                    max = ryanScore - apeachScore;\n                    answer = ryan.clone();\n                }\n                \n                return;\n            }\n            // ryan이 쏜 화살이 info보다 크면 진행할 필요 없음\n            for (int i = 0; i <= 10 && ryan[i] <= info[i]; i++) {\n                ryan[i]++;\n                dfs(cnt + 1);\n                ryan[i]--;\n            }\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 재귀적인 방식으로 높은 점수부터 화살을 쏴보면서 진행해야 하는 문제임은 쉽게 알 수 있었다.\n- 자잘한 구현에서 막혀 풀이를 참고했다."},{"excerpt":"💡 정적 페이지와 동적 페이지 먼저 정적 페이지와 동적 페이지에 대해 정리한다. 😇 정적 페이지 (Static Pages) 바뀌지 않는 페이지 서버에 미리 저장된 파일이 그대로 전달되는 웹 페이지로, 서버는 사용자의 요청에 해당하는 저장된 웹 페이지를 응답한다. 따라서 사용자는 서버에 저장된 데이터가 변경되지 않는 한 고정된 웹 페이지를 보게 된다. 장점…","fields":{"slug":"/[Backend]WebServer&WAS/"},"frontmatter":{"date":"July 11, 2022","title":"💻 Web Server와 WAS","tags":["WebServer","WAS"]},"rawMarkdownBody":"\n## 💡 정적 페이지와 동적 페이지\n<img src=\"https://gmlwjd9405.github.io/images/web/static-vs-dynamic.png\" width=\"80%\">\n\n먼저 정적 페이지와 동적 페이지에 대해 정리한다.\n\n### 😇 정적 페이지 (Static Pages)\n> 바뀌지 않는 페이지\n\n서버에 미리 저장된 파일이 그대로 전달되는 웹 페이지로, 서버는 사용자의 요청에 해당하는 저장된 웹 페이지를 응답한다.\n- 따라서 사용자는 서버에 저장된 데이터가 변경되지 않는 한 고정된 웹 페이지를 보게 된다.\n\n**장점으로는,**\n- 요청에 대한 파일만 전송하면 되기에 빠르다.\n- 웹 서버의 구축만 필요로 하므로 비용이 적다.\n\n**단점으로는,**\n- 저장된 정보만 보여줄 수 있으므로 서비스가 한정적이다.\n- 추가, 수정, 삭제 등의 작업이 모두 수동적이므로 관리가 어렵다.\n\n### 😇 동적 페이지 (Dynamic Pages)\n> 요청에 따라 바뀌는 페이지\n\n서버는 사용자의 요청에 맞게 동적인 응답을 반환한다. 서버에 의해 실행되는 프로그램을 통해 만들어지는 결과물을 확인할 수 있다.\n- 요청에 따라 다양한 웹 페이지를 볼 수 있다.\n\n**장점으로는,**\n- 다양한 정보를 조합해 동적으로 생성하여 제공하므로 다양한 서비스가 가능하다.\n- 추가, 수정, 삭제 등의 작업이 용이하므로 관리가 쉽다.\n\n**단점으로는,**\n- 사용자에게 웹 페이지를 전달하기 전 처리 작업이 필요하기에 상대적으로 느리다.\n- 웹 서버외에 추가적 처리를 위한 Web Application Server가 필요하기에 추가 비용이 발생한다.\n\n---\n\n<img src=\"https://gmlwjd9405.github.io/images/web/webserver-vs-was1.png\" width=\"80%\">\n\n## 💡 Web Server란?\n웹 서버는 HTTP 프로토콜을 기반으로, 클라이언트의 요청을 서비스하는 기능을 담당한다.\n- 소프트웨어: 웹 브라우저 클라이언트로부터 HTTP 요청을 받아들이고, 정적인 컨텐츠(HTML, CSS 등)를 제공하는 프로그램\n- 하드웨어: Web 서버가 설치되어 있는 컴퓨터\n\n### 😇 기능\n요청에 맞게 두 가지 기능 중 선택해 제공한다.\n- 정적 컨텐츠 제공: WAS를 거치지 않고 바로 자원을 제공한다.\n- 동적 컨텐츠 제공을 위한 요청 전달: 클라이언트의 요청을 WAS로 보내고, WAS의 결과를 클라이언트에게 전달한다.\n\n### 😇 종류\nApache, Nginx, IIS 등이 있다.\n\n---\n\n## 💡 Web Application Server란?\n위 그림에서 볼 수 있듯, Web Server + Web Container가 합쳐진 개념으로, DB 조회 및 다양한 로직 처리 요구 시 동적인 컨텐츠를 제공하기 위해 만들어진 애플리케이션 서버이다.\n- HTTP를 통해 애플리케이션을 수행해주는 미들웨어다.\n\n> **컨테이너**\n> - JSP, Servlet을 실행시킬 수 있는 소프트웨어\n\n### 😇 기능\n- 프로그램 실행 환경 및 DB 접속 기능 제공\n- 여러 트랜잭션 관리 기능\n- 비즈니스 로직 수행\n\n### 😇 종류\nTomcat, JBoss 등이 있다.\n\n---\n\n## 💡 Web Server와 WAS를 구분하는 이유?\n각각이 필요한 이유가 있기 때문에 구분한다.\n\n### 😇 Web Server가 필요한 이유\n웹 서버에서는 정적 컨텐츠만을 처리하도록 기능 분배를 하여 서버의 부담을 줄일 수 있다.\n\n클라이언트가 이미지 파일(정적 컨텐츠)을 보낸다고 가정하자.\n- 웹 문서(HTML 문서)가 클라이언트로 보내질 때 이미지 파일과 같은 정적 파일은 함께 보내지지 않는다.\n  - 먼저 HTML 문서를 받고, 이에 필요한 이미지 파일들을 다시 서버로 요청해서 받아온다.\n- 따라서, **웹 서버를 통해 정적인 파일을 애플리케이션 서버까지 가지 않고 앞단에 빠르게 보낼 수 있다.**\n\n### 😇 WAS가 필요한 이유\n요청에 맞는 데이터를 DB에서 가져와 비즈니스 로직에 맞게 그때마다의 결과를 만들고 제공하면서 자원의 효율적인 사용이 가능해진다.\n\n동적인 컨텐츠를 제공해야 하는 상황\n- 웹 서버만으로는 사용자가 원하는 요청에 대한 결과값을 모두 미리 만들어놓고 제공하기에 자원이 절대적으로 부족하다.\n- 따라서, **WAS를 통해 요청이 들어올 때마다 DB와 비즈니스 로직을 통해 결과물을 만들어 제공한다.**\n\n> 만약 WAS가 정적 컨텐츠 요청까지 모두 처리한다면, 서버의 부하가 커지고, 동적 컨텐츠 처리가 지연되어 수행 속도가 느려진다.\n> - 따라서 **기능을 분리시켜 서버 부하를 방지하고자 나누었다.**\n\n### 😇 가장 효율적인 방법\n> 웹 서버를 WAS 앞에 두고, 필요한 WAS들을 웹 서버에 플러그인 혀앹로 설정하여 효율적인 분산 처리가 가능하게 한다.\n\n<img src=\"https://gmlwjd9405.github.io/images/web/web-service-architecture.png\" width=\"80%\">\n\n- 클라이언트의 요청을 먼저 웹 서버가 받은 다음, WAS에 보내 관련된 Servlet을 메모리에 올린다.\n- WAS는 `web.xml` 을 참조해 해당 Servlet에 대한 쓰레드를 생성한다. (Thread pool을 사용)\n  - 쓰레드를 사용하는 이유는, 클라이언트의 요청이 순차적으로 이어지지 않을 확률이 높고, 수많은 요청이 한 번에 일어나는 경우가 많기에 쓰레드를 생성하여 요청을 처리한다.\n- 이때, 컨테이너는 `HttpServletRequest` 와 `HttpServletResponse` 객체를 생성해 Servlet에게 전달한다.\n  - 쓰레드는 Servlet의 `service()` 메소드를 호출하고, 해당 메소드는 요청에 맞게 `doGet()` 이나 `doPost()` 메소드를 호출한다.\n- 요청에 맞게 생성된 동적 페이지를 `Response` 객체에 담아 WAS에 전달한다.\n- WAS는 `Response` 객체를 `HttpServletResponse` 형태로 바꿔 웹 서버로 전달한다.\n- 생성된 쓰레드를 종료하고, `HttpServletRequest` 와 `HttpServletResponse` 객체를 제거한다.\n\n---\n\n## 📕 참고\n- [정적인 페이지와 동적인 페이지의 차이점이란?](https://titus94.tistory.com/4)\n- [Web Server와 WAS의 차이](https://gyoogle.dev/blog/web-knowledge/Web%20Server%EC%99%80%20WAS%EC%9D%98%20%EC%B0%A8%EC%9D%B4.html)\n- [[기본] WEB과 WAS 차이](https://helloworld-88.tistory.com/71)\n- [[WAS] Web Application Server 구현하기](https://webfirewood.tistory.com/category/language/Servlet%26JSP)"},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 스프링 컨테이너 생성 스프링 컨테이너가 생성되는 과정을 알아본다.  를 스프링 컨테이너라 한다. 그리고 이는 인터페이스이다. ( 는 구체 클래스) 스프링 컨테이너는 XML을 기반으로 만들 수 있고, 어노테이션 기반의 자바 설정 클래스로 만들 수 있다. (이전에 다룬  를 사용한 방식이 어노…","fields":{"slug":"/[스프링핵심원리_기본편]4.스프링컨테이너와스프링빈/"},"frontmatter":{"date":"July 11, 2022","title":"📟 4. 스프링 컨테이너와 스프링 빈","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 스프링 컨테이너 생성\n스프링 컨테이너가 생성되는 과정을 알아본다.\n\n```java\nApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);\n```\n\n- `ApplicationContext` 를 스프링 컨테이너라 한다. 그리고 이는 인터페이스이다. (`AnnotationConfigApplicationContext` 는 구체 클래스)\n- 스프링 컨테이너는 XML을 기반으로 만들 수 있고, 어노테이션 기반의 자바 설정 클래스로 만들 수 있다. (이전에 다룬 `AppConfig` 를 사용한 방식이 어노테이션 기반의 자바 설정 클래스로 만든 예)\n\n### 🪔 1. 스프링 컨테이너 생성\n<img src=\"../../images/스프링핵심원리-기본편/스프링컨테이너등록.png\" width=\"80%\">\n\n- `new AnnotationConfigApplicationContext(AppConfig.class)` 를 통해 스프링 컨테이너가 생성된다. 이때 구성 정보를 넘겨줘야 하기에 `AppConfig.class` 를 지정했다.\n- 스프링 컨테이너 내부에는 이름 - 객체 쌍으로 이뤄진 빈 정보를 저장하기 위한 스프링 빈 저장소가 있다.\n\n### 🪔 2. 스프링 빈 등록\n<img src=\"../../images/스프링핵심원리-기본편/스프링빈등록.png\" width=\"80%\">\n\n- 스프링 컨테이너는 파라미터로 넘어온 설정 클래스 정보를 사용해 스프링 빈을 등록한다. (`@Bean` 이 붙은 메소드를 모두 호출)\n\n**빈 이름**\n- 메소드 이름을 사용한다.\n- 직접 부여할 수도 있다. (`@Bean(name=\"???\")`)\n\n> 빈 이름은 항상 고유해야 한다. 다른 빈이 무시되거나 기존 빈을 덮어버리는 오류가 발생할 수 있다.\n\n### 🪔 3. 스프링 빈 의존관계 설정 - 준비\n<img src=\"../../images/스프링핵심원리-기본편/의존관계설정준비.png\" width=\"80%\">\n\n### 🪔 4. 스프링 빈 의존관계 설정 - 완료\n<img src=\"../../images/스프링핵심원리-기본편/의존관계설정완료.png\" width=\"80%\">\n\n- 스프링 컨테이너는 설정 정보를 참고해 의존관계를 주입(DI)한다.\n- 단순히 자바 코드를 호출하는 것과는 차이가 있다. 이는 싱글톤 컨테이너에서 설명한다.\n\n> 스프링은 빈을 생성하는 단계와 의존관계를 주입하는 단계가 나눠져 있다. 그런데 자바 코드로 스프링 빈을 등록하면, 생성자를 호출하면서 의존관계 주입도 한 번에 처리된다.\n\n---\n\n## 🎯 컨테이너에 등록된 모든 빈 조회\n스프링 컨테이너에 실제 스프링 빈들이 잘 등록되었는지 확인한다.\n\n```java\npackage hello.core.beanFind;\n\nimport hello.core.AppConfig;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\npublic class ApplicationContextInfoTest {\n    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n    @Test\n    @DisplayName(\"모든 빈 출력하기\")\n    void findAllBean() {\n        String[] beanDefinitionNames = ac.getBeanDefinitionNames();\n\n        for (String beanDefinitionName : beanDefinitionNames) {\n            Object bean = ac.getBean(beanDefinitionName);\n            System.out.println(\"name = \" + beanDefinitionName + \" object = \" + bean);\n        }\n    }\n}\n```\n\n- 위와 같은 테스트 코드로 현재 스프링 컨테이너에 등록된 모든 빈들을 확인할 수 있다.\n  - `getBeanDefinitionNames()` 로 스프링에 등록된 모든 빈 이름을 조회할 수 있고, `getBean()` 메소드에 빈 이름을 전달함으로써 빈 객체(인스턴스)를 조회할 수 있다.\n- 하지만 이와 같이 확인하게 되면, 내가 만들지 않고 자동으로 등록된 빈들 또한 출력되기에, 역할에 따라 빈들을 출력해보자.\n\n```java\npackage hello.core.beanFind;\n\nimport hello.core.AppConfig;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.config.BeanDefinition;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\npublic class ApplicationContextInfoTest {\n    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n    ...\n\n    @Test\n    @DisplayName(\"애플리케이션 빈 출력하기\")\n    void findApplicationBean() {\n        String[] beanDefinitionNames = ac.getBeanDefinitionNames();\n\n        for (String beanDefinitionName : beanDefinitionNames) {\n            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);\n\n            if (beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {\n                Object bean = ac.getBean(beanDefinitionName);\n                System.out.println(\"name = \" + beanDefinitionName + \" object = \" + bean);\n            }\n        }\n    }\n}\n```\n\n- `getBeanDefinition` 을 통해 해당 빈에 대한 정보를 얻을 수 있다. \n  - 해당 빈의 역할이 직접 등록한 애플리케이션 빈(`ROLE_APPLICATION`) 또는 스프링이 내부에서 사용하는 빈(`ROLE_INFRASTRUCTURE`)이냐에 따라 나눌 수 있다.\n\n---\n\n## 🎯 스프링 빈 조회 - 기본\n스프링 컨테이너에서 스프링 빈을 찾는 가장 기본적인 조회 방법\n- `getBean(빈 이름, 타입)` , `getBean(타입)`\n- 조회 대상 스프링 빈이 없으면 예외가 발생한다.\n  - `NoSuchBeanDefinitionException: No bean named 'xxxxx' available`\n\n```java\npackage hello.core.beanFind;\n\nimport hello.core.AppConfig;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.config.BeanDefinition;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\nimport static org.assertj.core.api.Assertions.*;\n\nclass ApplicationContextBasicFindTest {\n    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n    @Test\n    @DisplayName(\"빈 이름으로 조회\")\n    void ifnBeanByName() {\n        MemberService memberService = ac.getBean(\"memberService\", MemberService.class);\n\n        assertThat(memberService).isInstanceOf(MemberServiceImpl.class);\n    }\n}\n```\n\n- 빈 이름으로 등록된 빈을 조회했고, 조회한 빈이 `MemberServiceImpl` 의 인스턴스인지 확인하는 테스트 코드를 작성한다.\n\n```java\npackage hello.core.beanFind;\n\nimport hello.core.AppConfig;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.config.BeanDefinition;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\nimport static org.assertj.core.api.Assertions.*;\n\nclass ApplicationContextBasicFindTest {\n    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n    ...\n\n    @Test\n    @DisplayName(\"이름 없이 타입으로만 조회\")\n    void findBeanByType() {\n        MemberService memberService = ac.getBean(MemberService.class);\n\n        assertThat(memberService).isInstanceOf(MemberServiceImpl.class);\n    }\n}\n```\n\n- 타입으로만 조회도 가능하다. 하지만 같은 타입을 가지는 빈이 여러 개인 경우도 고려해야 한다.\n\n> 현재 두 조회 모두 **인터페이스**로 조회하고 있다. 이를 구체 클래스로 조회해도 가능은 하지만, 이는 역할이 아닌 구현에 의존하는 코드이고, 변경 시 유연성이 떨어지는 단점이 있다.\n\n이제 실패한 경우의 테스트 코드 또한 작성해야 한다.\n\n```java\npackage hello.core.beanFind;\n\nimport hello.core.AppConfig;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.NoSuchBeanDefinitionException;\nimport org.springframework.beans.factory.config.BeanDefinition;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\nimport static org.assertj.core.api.Assertions.*;\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass ApplicationContextBasicFindTest {\n    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);\n\n    ...\n\n    @Test\n    @DisplayName(\"빈 이름으로 조회 X\")\n    void findBeanByNameX() {\n        \n        assertThrows(NoSuchBeanDefinitionException.class, \n                () -> ac.getBean(\"xxxxx\", MemberService.class));   \n    }\n}\n```\n\n- `assertThrows` 는 `() -> ` 뒤의 로직을 실행했을 때, 앞에 명시한 예외가 발생해야 테스트가 성공함을 assert한다.\n\n---\n\n## 🎯 스프링 빈 조회 - 동일한 타입이 둘 이상\n타입으로 조회 시 같은 타입의 스프링 빈이 둘 이상이면 오류가 발생한다. 이때는 빈 이름을 지정한다.\n- `getBeanOfType()` 을 사용하면 해당 타입의 모든 빈을 조회할 수 있다.\n\n```java\npackage hello.core.beanFind;\n\nimport hello.core.AppConfig;\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.member.MemoryMemberRepository;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.NoSuchBeanDefinitionException;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\nimport static org.assertj.core.api.Assertions.assertThat;\nimport static org.junit.jupiter.api.Assertions.assertThrows;\n\npublic class ApplicationContextSameBeanFindTest {\n    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SameBeanConfig.class);\n\n    @Test\n    @DisplayName(\"타입으로 조회 시 같은 타입이 둘 이상 있으면, 중복 오류가 발생한다.\")\n    void findBeanByTypeDuplicate() {\n        MemberRepository memberRepository = ac.getBean(MemberRepository.class);\n    }\n\n    // 동일 타입의 빈을 생성하기 위해 내부에서 생성한 클래스\n    @Configuration\n    static class SameBeanConfig {\n\n        @Bean\n        public MemberRepository memberRepository1() {\n            return new MemoryMemberRepository();\n        }\n\n        @Bean\n        public MemberRepository memberRepository2() {\n            return new MemoryMemberRepository();\n        }\n    }\n}\n```\n\n- 기존의 `AppConfig` 를 수정하지 않고 동일한 타입의 빈을 생성하기 위해 `SameBeanConfig` 클래스를 내부에서 생성하고, 이를 이용해 `ApplicationContext` 를 생성하도록 한다.\n  - 따라서, 스프링 컨테이너는 `MemberRepository` 타입의 빈을 2개 생성한다.\n- 그리고 타입으로 빈을 조회하게 되면, `NoUniqueBeanDefinitionException` 예외가 발생한다.\n\n```java\n@Test\n  @DisplayName(\"타입으로 조회 시 같은 타입이 둘 이상 있으면, 중복 오류가 발생한다.\")\n  void findBeanByTypeDuplicate() {\n      assertThrows(NoUniqueBeanDefinitionException.class,\n              () -> ac.getBean(MemberRepository.class));\n  }\n```\n\n- 위와 같이 예외가 발생함을 assert한다.\n\n```java\n@Test\n@DisplayName(\"타입으로 조회 시 같은 타입이 둘 이상 있으면, 빈 이름을 지정하면 된다.\")\nvoid findBeanByName() {\n    MemberRepository memberRepository = ac.getBean(\"memberRepository1\", MemberRepository.class);\n    assertThat(memberRepository).isInstanceOf(MemberRepository.class);\n}\n```\n\n- 이전에 한 것과 같이, 빈 이름을 지정하여 특정 빈만 조회할 수 있다.\n\n```java\n@Test\n@DisplayName(\"특정 타입을 모두 조회하기\")\nvoid findAllBeanByType() {\n    Map<String, MemberRepository> beansOfType = ac.getBeansOfType(MemberRepository.class);\n    for (String key : beansOfType.keySet()) {\n        System.out.println(\"key = \" + key + \" value = \" + beansOfType.get(key));\n    }\n\n    assertThat(beansOfType.size()).isEqualTo(2);\n}\n```\n\n- 또는 특정 타입의 빈을 모두 조회하는 방법도 있다.\n  - 이때 `getBeansOfType()` 의 반환형은 `Map` 이다.\n\n---\n\n## 🎯 스프링 빈 조회 - 상속 관계\n\"부모 타입으로 조회하면, 자식 타입도 함께 조회한다.\"\n- 그래서 모든 자바 객체의 최고 부모인 `Object` 타입으로 조회하면, 모든 스프링 빈을 조회한다. \n\n```java\npackage hello.core.beanFind;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.discount.RateDiscountPolicy;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.NoUniqueBeanDefinitionException;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\nimport static org.assertj.core.api.Assertions.assertThat;\nimport static org.junit.jupiter.api.Assertions.assertThrows;\n\nclass ApplicationContextExtendsFindTest {\n    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(TestConfig.class);\n\n    @Test\n    @DisplayName(\"부모 타입으로 조회 시, 자식이 둘 이상 있으면 중복 오류가 발생한다.\")\n    void findBeanByParentTypeDuplicate() {\n\n        assertThrows(NoUniqueBeanDefinitionException.class,\n                () -> ac.getBean(DiscountPolicy.class));\n    }\n\n    @Test\n    @DisplayName(\"부모 타입으로 조회 시, 자식이 둘 이상 있으면 빈 이름을 지정하면 된다.\")\n    void findBeanByParentTypeBeanName() {\n        DiscountPolicy rateDiscountPolicy = ac.getBean(\"rateDiscountPolicy\", DiscountPolicy.class);\n\n        assertThat(rateDiscountPolicy).isInstanceOf(RateDiscountPolicy.class);\n    }\n\n    @Configuration\n    static class TestConfig {\n        @Bean\n        public DiscountPolicy rateDiscountPolicy() {\n            return new RateDiscountPolicy();\n        }\n\n        @Bean\n        public DiscountPolicy fixDiscountPolicy() {\n            return new FixDiscountPolicy();\n        }\n    }\n}\n```\n\n- 부모 타입으로 조회 시, 모든 자식 타입도 조회된다. 이때 자식이 둘 이상 있으면 중복 오류가 발생할 것이고, 빈 이름을 지정함으로써 이를 해결할 수 있다.\n\n```java\n@Test\n@DisplayName(\"부모 타입으로 모두 조회하기\")\nvoid findAllBeanByParentType() {\n    Map<String, DiscountPolicy> beansOfType = ac.getBeansOfType(DiscountPolicy.class);\n    for (String key : beansOfType.keySet()) {\n        System.out.println(\"key = \" + key + \" value=\" + beansOfType.get(key));\n    }\n    assertThat(beansOfType.size()).isEqualTo(2);\n}\n\n@Test\n@DisplayName(\"부모 타입으로 모두 조회하기 - Object\")\nvoid findAllBeanByObjectType() {\n    Map<String, Object> beansOfType = ac.getBeansOfType(Object.class);\n    for (String key : beansOfType.keySet()) {\n        System.out.println(\"key = \" + key + \" value=\" +\n                beansOfType.get(key));\n    } \n}\n```\n\n- 최고 부모 타입인 `Object` 로 조회하면, 등록된 모든 빈들을 조회할 수 있다.\n  - 자바의 객체는 모두 `Object` 이기 때문이다.\n\n---\n\n## 🎯 BeanFactory와 ApplicationContext\n<img src=\"../../images/스프링핵심원리-기본편/BF&AC.png\" width=\"80%\">\n\n**BeanFactory**\n- 스프링 컨테이너의 최상위 인터페이스\n- 스프링 빈을 관리하고 조회하는 역할을 담당한다.\n  - `getBean()` 제공\n- 지금까지 사용했던 대부분의 기능을 제공한다. 하지만 `BeanFactory` 를 직접 사용할 일은 거의 없고, 아래의 `ApplicationContext` 를 사용한다.\n\n**ApplicationContext**\n- `BeanFactory` 를 상속받기에, 해당 기능에 부가 기능을 추가하고 있다.\n- 빈을 관리하고 검색하는 기능을 `BeanFactory` 가 제공하고 있는데, 어떤 차이가 있을까?\n- 애플리케이션 개발 시 빈을 관리하고 조회하는 기능 뿐 아니라 수많은 부가 기능이 필요하다. 아래는 `ApplicationContext` 가 제공하는 부가 기능이다.\n\n**ApplicationContext가 제공하는 부가 기능**\n<img src=\"../../images/스프링핵심원리-기본편/AC부가기능.png\" width=\"80%\">\n\n- `MessageSource` 를 활용한 국제화 기능\n  - 한국에서 들어오면 한국어로, 영어권에서 들어오면 영어로 출력\n- `EnvironmentCapable` 환경 변수\n  - 로컬, 개발, 운영 등을 구분해서 처리\n- `ApplicationEventPublisher`\n  - 이벤트를 발행하고 구독하는 모델을 편리하게 지원\n- `ResourceLoader` 편리한 리소스 조회\n  - 파일, 클래스패스, 외부 등에서 리소스를 편리하게 조회\n\n> `BeanFactory` 나 `ApplicationContext` 를 **스프링 컨테이너**라 한다.\n\n---\n\n## 🎯 다양한 설정 형식 지원 - 자바 코드, XML\n스프링 컨테이너는 다양한 형식의 설정 정보를 지원하도록 설계되어 있다.\n- 자바 코드, XML, Groovy 등\n\n<img src=\"../../images/스프링핵심원리-기본편/다양한설정.png\" width=\"80%\">\n\n**어노테이션 기반 자바 코드 설정 사용**\n- `new AnnotationConfigApplicationContext(AppConfig.class)`\n- `AnnotationConfigApplicationContext` 클래스를 사용하면서 자바 코드로 된 설정 정보를 넘겨 사용한다.\n\n**XML 설정 사용**\n- 최근에는 많이 사용하진 않지만, 아직 많은 프로젝트들이 XML로 되어 있다.\n- 이를 사용하면 컴파일 없이 빈 설정 정보를 변경할 수 있는 장점이 있다.\n- `GenericXmlApplicationContext` 를 사용하면서 `xml` 설정 파일을 넘겨 사용한다.\n\n**`XmlAppConfig` 사용 자바 코드**\n```java\npackage hello.core.xml;\n\nimport hello.core.member.MemberService;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.support.GenericXmlApplicationContext;\n\nimport static org.assertj.core.api.Assertions.assertThat;\n\npublic class XmlAppContext {\n\n    @Test\n    void xmlAppContext() {\n        ApplicationContext ac = new GenericXmlApplicationContext(\"appConfig.xml\");\n        MemberService memberService = ac.getBean(\"memberService\", MemberService.class);\n\n        assertThat(memberService).isInstanceOf(MemberService.class);\n    }\n}\n```\n\n**xml 기반의 스프링 빈 설정 정보**\n```xml\n<!-- src/main/resources/appConfig.xml -->\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n       xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n       xsi:schemaLocation=\"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd\">\n    <bean id=\"memberService\" class=\"hello.core.member.MemberServiceImpl\">\n        <constructor-arg name=\"memberRepository\" ref=\"memberRepository\" />\n    </bean>\n    \n    <bean id=\"memberRepository\" class=\"hello.core.member.MemoryMemberRepository\" />\n\n    <bean id=\"orderService\" class=\"hello.core.order.OrderServiceImpl\">\n          <constructor-arg name=\"memberRepository\" ref=\"memberRepository\" />\n          <constructor-arg name=\"discountPolicy\" ref=\"discountPolicy\" />\n    </bean>\n    <bean id=\"discountPolicy\" class=\"hello.core.discount.RateDiscountPolicy\" />\n</beans>\n```\n\n- xml 기반의 스프링 설정 정보와 자바 코드로 된 설정 정보를 비교하면 거의 비슷하다.\n\n---\n\n## 🎯 스프링 빈 설정 메타 정보 - BeanDefinition\n스프링이 다양한 설정 형식을 지원할 수 있는 중심에 `BeanDefinition` 이라는 추상화가 있다.\n- **역할과 구현을 개념적으로 나누었다.**\n  - XML을 읽어 `BeanDefinition` 을 만든다.\n  - 자바 코드를 읽어 `BeanDefinition` 을 만든다.\n  - **스프링 컨테이너는 오직 만들어진 `BeanDefinition` 만 필요**로 한다.\n- `BeanDefinition` 을 **빈 설정 메타 정보**라 한다.\n  - `@Bean` , `<bean></bean>` 당 각각 하나씩의 메타 정보가 생성된다.\n- 그리고 스프링 컨테이너는 이 메타 정보를 기반으로 스프링 빈을 생성한다.\n\n<img src=\"../../images/스프링핵심원리-기본편/beandefinition.png\" width=\"80%\">\n\n**코드 레벨**\n<img src=\"../../images/스프링핵심원리-기본편/코드레벨.png\" width=\"80%\">\n\n- `AnnotationConfigApplicationContext` 는 `AnnotatedBeanDefinitionReader` 를 사용해서 `AppConfig.class` 를 읽고 `BeanDefinition` 을 생성한다.\n- `GenericXmlApplicationContext` 는 `XmlBeanDefinitionReader` 를 사용해서 `appConfig.xml` 설정 정보를 읽고 `BeanDefinition` 을 생성한다.\n- 새로운 형식의 설정 정보가 추가되면, `XxxBeanDefinitionReader를` 만들어서 `BeanDefinition` 을 생성하면 된다.\n\n### 🪔 BeanDefinition 살펴보기\n**BeanDefinition** 정보\n- `BeanClassName`: 생성할 빈의 클래스 명(자바 설정 처럼 팩토리 역할의 빈을 사용하면 없음) \n- `factoryBeanName`: 팩토리 역할의 빈을 사용할 경우 이름, 예) appConfig \n- `factoryMethodName`: 빈을 생성할 팩토리 메서드 지정, 예) memberService\n- `Scope`: 싱글톤(기본값)\n- `lazyInit`: 스프링 컨테이너를 생성할 때 빈을 생성하는 것이 아니라, 실제 빈을 사용할 때 까지 최대한 생성을 지연처리 하는지 여부\n- `InitMethodName`: 빈을 생성하고, 의존관계를 적용한 뒤에 호출되는 초기화 메서드 명 \n- `DestroyMethodName`: 빈의 생명주기가 끝나서 제거하기 직전에 호출되는 메서드 명 \n- `Constructor arguments`, `Properties`: 의존관계 주입에서 사용한다. (자바 설정 처럼 팩토리 역할의\n빈을 사용하면 없음)\n\n## 📌 중요한 개념\n스프링 컨테이너, 빈\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"문제 Programmers - 매출 하락 최소화 📍 Logic 해당 직원이 워크숍에 참여한 경우와 하지 않은 경우에 대한 비용을 계산한다. 부모 노드에서는 자식 노드의 비용 정보를 이용해 경우에 따른 비용을 계산한다. 이때, 팀장과 팀원 모두 참여하지 않는 경우에 대한 추가 비용을 계산한다. 📄 CODE ✏️ Review 접근법을 몰라 헤매다가, 풀이 영상…","fields":{"slug":"/[Programmers]72416/"},"frontmatter":{"date":"July 10, 2022","title":"👩‍💻 72416. 매출 하락 최소화","tags":["DFS","DP"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 매출 하락 최소화](https://programmers.co.kr/learn/courses/30/lessons/72416)\n\n### 📍 **Logic**\n\n```java\nprivate static void traversal(int node) {\n    // 해당 직원이 워크숍에 참여하지 않는 경우\n    costs[node][0] = 0;\n    // 해당 직원이 워크숍에 참여한 경우 -> 해당 직원 매출을 저장\n    costs[node][1] = sales[node];\n    \n    // 리프 노드라면, 상위로 최소 비용을 전달해야 함\n    if (adjList.get(node).isEmpty()) return;\n    \n    int extraCost = 10001;\n    for (int child : adjList.get(node)) {\n        traversal(child);\n        \n        // 최소 비용을 부모 노드(팀장)에 누적\n        if (costs[child][0] < costs[child][1]) {\n            costs[node][0] += costs[child][0];\n            costs[node][1] += costs[child][0];\n            // 팀장과 팀원 모두 참여하지 않으면 안되기에 필요한 추가 비용 계산\n            extraCost = Math.min(extraCost, costs[child][1] - costs[child][0]);\n        } else {\n            costs[node][0] += costs[child][1];\n            costs[node][1] += costs[child][1];    \n            // 둘 중 한 명이라도 참여했다면 추가 비용은 필요 없음\n            extraCost = 0;\n        }\n    }\n    \n    costs[node][0] += extraCost;\n}\n```\n- 해당 직원이 워크숍에 참여한 경우와 하지 않은 경우에 대한 비용을 계산한다.\n- 부모 노드에서는 자식 노드의 비용 정보를 이용해 경우에 따른 비용을 계산한다.\n  - 이때, 팀장과 팀원 모두 참여하지 않는 경우에 대한 추가 비용을 계산한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Solution {\n        // 직원별 워크숍에 참여했을 때의 매출과 참여하지 않았을 때의 매출, 0: 참여 X, 1: 참여 O\n        static int[][] costs;\n        static ArrayList<ArrayList<Integer>> adjList = new ArrayList<>();\n        static int[] sales;\n        \n        public int solution(int[] sales, int[][] links) {\n            this.sales = sales;\n            init();\n            \n            makeAdjList(links);\n            \n            traversal(0);\n            \n            return Math.min(costs[0][0], costs[0][1]);\n        }\n        \n        private static void init() {\n            costs = new int[sales.length][2];\n            \n            for (int i = 0; i < sales.length; i++) \n                adjList.add(new ArrayList<>());\n        }\n        \n        private static void makeAdjList(int[][] links) {\n            for (int[] link : links)\n                adjList.get(link[0] - 1).add(link[1] - 1);\n        }\n        \n        private static void traversal(int node) {\n            // 해당 직원이 워크숍에 참여하지 않는 경우\n            costs[node][0] = 0;\n            // 해당 직원이 워크숍에 참여한 경우 -> 해당 직원 매출을 저장\n            costs[node][1] = sales[node];\n            \n            // 리프 노드라면, 상위로 최소 비용을 전달해야 함\n            if (adjList.get(node).isEmpty()) return;\n            \n            int extraCost = 10001;\n            for (int child : adjList.get(node)) {\n                traversal(child);\n                \n                // 최소 비용을 부모 노드(팀장)에 누적\n                if (costs[child][0] < costs[child][1]) {\n                    costs[node][0] += costs[child][0];\n                    costs[node][1] += costs[child][0];\n                    // 팀장과 팀원 모두 참여하지 않으면 안되기에 필요한 추가 비용 계산\n                    extraCost = Math.min(extraCost, costs[child][1] - costs[child][0]);\n                } else {\n                    costs[node][0] += costs[child][1];\n                    costs[node][1] += costs[child][1];    \n                    // 둘 중 한 명이라도 참여했다면 추가 비용은 필요 없음\n                    extraCost = 0;\n                }\n            }\n            \n            costs[node][0] += extraCost;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 접근법을 몰라 헤매다가, 풀이 영상을 참고했다. 풀이 영상을 보니 이전에도 비슷한 문제를 풀었던 것 같다. (자식 노드의 정보를 상위로 넘겨주면서 최소 비용을 구하는 ...?)"},{"excerpt":"문제 Programmers - 카드 짝 맞추기 📍 Logic 재귀를 수행하면서, 모든 카드 뒤집기 순서를 진행하면서 최소 비용을 계산한다. 카드와 카드 간 이동 시 최소 조작 횟수를 구하기 위해 BFS를 수행한다. 📄 CODE ✏️ Review 처음에 구현하려한 아이디어는,  에 카드 번호별로 카드 위치를 저장하고, 현재 커서에서 가장 가까이 있는 카드를 …","fields":{"slug":"/[Programmers]72415/"},"frontmatter":{"date":"July 07, 2022","title":"👩‍💻 72415. 카드 짝 맞추기","tags":["BFS","완전 탐색","순열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 카드 짝 맞추기](https://programmers.co.kr/learn/courses/30/lessons/72415)\n\n### 📍 **Logic**\n\n```java\nprivate static int permutate(Card src) {\n    int ret = Integer.MAX_VALUE;\n    \n    // 1부터 6까지의 카드가 존재할 수 있다.\n    for (int n = 1; n <= 6; n++) {\n        // n에 해당하는 카드를 저장하는 리스트\n        ArrayList<Card> cards = findNCard(n);\n        \n        // 선택한 카드들이 없는 경우, 패스\n        if (cards.isEmpty()) continue;\n        \n        // 현재 위치부터 선택한 카드까지 가기 위한 거리를 계산\n        int one = bfs(src, cards.get(0)) + bfs(cards.get(0), cards.get(1)) + 2;\n        // one의 역순으로 진행\n        int two = bfs(src, cards.get(1)) + bfs(cards.get(1), cards.get(0)) + 2;\n        \n        // 뒤집은 카드를 보드에서 제거\n        removeCards(cards);\n        \n        // 재귀 호출 수행\n        // one으로 수행한 카드 뒤집기 이후, 커서가 card.get(1)에 있을 때 남은 카드들에 대한 뒤집기 수행\n        ret = Math.min(ret, one + permutate(cards.get(1)));\n        // two로 수행한 카드 뒤집기 이후, 커서가 card.get(0)에 있을 때 남은 카드들에 대한 뒤집기 수행 \n        ret = Math.min(ret, two + permutate(cards.get(0)));\n        \n        // 1번 카드에 대한 뒤집기 수행 후, 2번 카드에 대한 뒤집기 진행 시에는 1번 카드 뒤집기에 대한 복원이 필요하다.\n        restoreCards(cards, n);\n    }\n    \n    if (ret == Integer.MAX_VALUE) return 0;\n    \n    return ret;\n}\n```\n- 재귀를 수행하면서, 모든 카드 뒤집기 순서를 진행하면서 최소 비용을 계산한다.\n- 카드와 카드 간 이동 시 최소 조작 횟수를 구하기 위해 BFS를 수행한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Card {\n        // 행, 열, 이동하기 위해 필요한 조작 횟수\n        int r;\n        int c;\n        int count;\n        \n        public Card(int r, int c, int count) {\n            this.r = r;\n            this.c = c;\n            this.count = count;\n        }\n    }\n\n    class Solution {\n        static int[][] board;\n        static int[][] range = {{ -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 }};\n        \n        public int solution(int[][] board, int r, int c) {\n            this.board = board;\n            \n            return permutate(new Card(r, c, 0));\n        }\n        \n        private static int permutate(Card src) {\n            int ret = Integer.MAX_VALUE;\n            \n            // 1부터 6까지의 카드가 존재할 수 있다.\n            for (int n = 1; n <= 6; n++) {\n                // n에 해당하는 카드를 저장하는 리스트\n                ArrayList<Card> cards = findNCard(n);\n                \n                // 선택한 카드들이 없는 경우, 패스\n                if (cards.isEmpty()) continue;\n                \n                // 현재 위치부터 선택한 카드까지 가기 위한 거리를 계산\n                int one = bfs(src, cards.get(0)) + bfs(cards.get(0), cards.get(1)) + 2;\n                // one의 역순으로 진행\n                int two = bfs(src, cards.get(1)) + bfs(cards.get(1), cards.get(0)) + 2;\n                \n                // 뒤집은 카드를 보드에서 제거\n                removeCards(cards);\n                \n                // 재귀 호출 수행\n                // one으로 수행한 카드 뒤집기 이후, 커서가 card.get(1)에 있을 때 남은 카드들에 대한 뒤집기 수행\n                ret = Math.min(ret, one + permutate(cards.get(1)));\n                // two로 수행한 카드 뒤집기 이후, 커서가 card.get(0)에 있을 때 남은 카드들에 대한 뒤집기 수행 \n                ret = Math.min(ret, two + permutate(cards.get(0)));\n                \n                // 1번 카드에 대한 뒤집기 수행 후, 2번 카드에 대한 뒤집기 진행 시에는 1번 카드 뒤집기에 대한 복원이 필요하다.\n                restoreCards(cards, n);\n            }\n            \n            if (ret == Integer.MAX_VALUE) return 0;\n            \n            return ret;\n        }\n        \n        private static int bfs(Card src, Card dest) {\n            boolean[][] visited = new boolean[4][4];\n            Queue<Card> queue = new LinkedList<>();\n            queue.add(src);\n            \n            while(!queue.isEmpty()) {\n                Card now = queue.poll();\n                \n                // 목적지에 도착한 경우, 조작 횟수를 반환\n                if (now.r == dest.r && now.c == dest.c) return now.count;\n                \n                for (int i = 0; i < 4; i++) {\n                    int nr = now.r + range[i][0], nc = now.c + range[i][1];\n                    \n                    if (!isInBoundary(nr, nc)) continue;\n                    \n                    // 방문하지 않은 경우 조작 횟수 갱신\n                    if (!visited[nr][nc]) {\n                        visited[nr][nc] = true;\n                        queue.add(new Card(nr, nc, now.count + 1));\n                    }\n                    \n                    // ctrl을 이용해 조작 가능한 경우\n                    for (int j = 0; j < 2; j++) {\n                        // 뒤집어진 카드가 아닌 경우 종료\n                        if (board[nr][nc] != 0) break;\n                        // 한 번 더 해당 방향으로 진행했을 때 경계를 벗어나는 경우도 종료\n                        if (!isInBoundary(nr + range[i][0], nc + range[i][1])) break;\n                        \n                        nr += range[i][0];\n                        nc += range[i][1];\n                    }\n                    \n                    // nr, nc는 이제 한 번에 이동할 수 있는 위치\n                    if (visited[nr][nc]) continue;\n                    visited[nr][nc] = true;\n                    queue.add(new Card(nr, nc, now.count + 1));\n                }\n            }\n            \n            return Integer.MAX_VALUE;\n        }\n        \n        private static boolean isInBoundary(int r, int c) {\n            return r >= 0 && r < 4 && c >= 0 && c < 4;\n        }\n        \n        private static ArrayList<Card> findNCard(int num) {\n            ArrayList<Card> cards = new ArrayList<>();\n            \n            for (int i = 0; i < 4; i++)\n                for (int j = 0; j < 4; j++)\n                    if (board[i][j] == num)\n                        cards.add(new Card(i, j, 0));\n            \n            return cards;\n        }\n        \n        private static void removeCards(ArrayList<Card> cards) {\n            for (Card card : cards)\n                board[card.r][card.c] = 0;\n        }\n        \n        private static void restoreCards(ArrayList<Card> cards, int num) {\n            for (Card card : cards)\n                board[card.r][card.c] = num;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에 구현하려한 아이디어는, `map` 에 카드 번호별로 카드 위치를 저장하고, 현재 커서에서 가장 가까이 있는 카드를 뒤집고, 해당 카드 짝을 찾아 커서를 이동한 후 뒤집고를 반복하는 방식이었다.\n  - 생각해보니 카드 순서가 중요할 수 있겠다라는 걸 깨달았고, 구현을 어떻게 해야 할 지 모르겠어서 ... 풀이 영상을 참고했다."},{"excerpt":"문제 Programmers - k진수에서 소수 개수 구하기 📍 Logic 소수인지 아닌지 판별하는 함수 📄 CODE ✏️ Review 소수를 구하는 알고리즘이 중요했다. 뭔가 0에 대해서 막 조건 설명을 늘어놓길래 .. 아 0으로  하면 되겠구나 싶었다.","fields":{"slug":"/[Programmers]92335/"},"frontmatter":{"date":"July 07, 2022","title":"👩‍💻 92335. k진수에서 소수 개수 구하기","tags":["소수 구하기"]},"rawMarkdownBody":"\n## 문제\n[Programmers - k진수에서 소수 개수 구하기](https://programmers.co.kr/learn/courses/30/lessons/92335)\n\n### 📍 **Logic**\n\n```java\nprivate static boolean isPrime(long n) {\n    // 소수는 1과 자기 자신만으로 나누어지는 수\n    // 따라서 2부터 루트 n까지의 수로 나누어보고, 나눠진다면 소수가 아니다.\n    // (int) Math.sqrt(n) : 소수점 버림\n    for (int i = 2; i <= (int) Math.sqrt(n); i++)\n        if (n % i == 0)\n            return false;\n\n    return true;\n}\n```\n\n- 소수인지 아닌지 판별하는 함수\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        public int solution(int n, int k) {\n            int answer = 0;\n            \n            String[] nums = convertToK(n, k).split(\"0\");\n            \n            for (String num : nums) {\n                if (num.equals(\"\") || num.equals(\"1\")) continue;\n                if (isPrime(Long.parseLong(num))) answer++;\n            }\n            \n            return answer;\n        }\n        \n        private static String convertToK(int num, int k) {\n            StringBuilder sb = new StringBuilder();\n\n            while(num > 0) {\n                sb.append(num % k);\n                num /= k;\n            }\n\n            return sb.reverse().toString();\n        }\n\n        private static boolean isPrime(long n) {\n            // 소수는 1과 자기 자신만으로 나누어지는 수\n            // 따라서 2부터 루트 n까지의 수로 나누어보고, 나눠진다면 소수가 아니다.\n            // (int) Math.sqrt(n) : 소수점 버림\n            for (int i = 2; i <= (int) Math.sqrt(n); i++)\n                if (n % i == 0)\n                    return false;\n\n            return true;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 소수를 구하는 알고리즘이 중요했다.\n- 뭔가 0에 대해서 막 조건 설명을 늘어놓길래 .. 아 0으로 `split` 하면 되겠구나 싶었다."},{"excerpt":"문제 Programmers - 주차 요금 계산 📍 Logic 차 번호별 입차 시간을 저장하는 map을 사용해, 입차 시에는 map에 추가하고, 출차 시에는 입차 시간과 비교하여 주차 시간을 구한다. 차 번호별 누적 주차 시간을 저장하는 map을 사용해 차 번호별 주차 시간을 누적합한다.  는 주차 기록을 읽으면서 차 번호별 주차 시간을 계산한다.  에서는…","fields":{"slug":"/[Programmers]92341/"},"frontmatter":{"date":"July 06, 2022","title":"👩‍💻 92341. 주차 요금 계산","tags":["Map","구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 주차 요금 계산](https://programmers.co.kr/learn/courses/30/lessons/92341)\n\n### 📍 **Logic**\n\n```java\n// 차 번호별 입차 시간을 저장하는 map\nstatic Map<String, Integer> carTimeMap = new HashMap<>();\n// 차 번호별 누적 주차 시간을 저장하는 map\nstatic Map<String, Integer> accumCarMap = new HashMap<>();\n```\n\n- 차 번호별 입차 시간을 저장하는 map을 사용해, 입차 시에는 map에 추가하고, 출차 시에는 입차 시간과 비교하여 주차 시간을 구한다.\n- 차 번호별 누적 주차 시간을 저장하는 map을 사용해 차 번호별 주차 시간을 누적합한다.\n\n```java\nreadRecords(records);\n\nprocessRemainingCars();\n\ncalculateFees();\n```\n\n- `readRecords()` 는 주차 기록을 읽으면서 차 번호별 주차 시간을 계산한다.\n- `processRemainingCars()` 에서는 출차 기록이 없는 차에 대한 처리를 수행한다.\n- `calculateFees()` 에서는 차 번호별 주차 요금을 계산하고 반환할 배열에 담는다.\n \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        \n        static int basicTime;\n        static int basicFee;\n        static int unitTime;\n        static int unitFee;\n        \n        // 차 번호별 입차 시간을 저장하는 map\n        static Map<String, Integer> carTimeMap = new HashMap<>();\n        // 차 번호별 누적 주차 시간을 저장하는 map\n        static Map<String, Integer> accumCarMap = new HashMap<>();\n        \n        public int[] solution(int[] fees, String[] records) {\n            init(fees);\n\n            readRecords(records);\n\n            processRemainingCars();\n\n            return calculateFees();\n        }\n\n        private static void init(int[] fees) {\n            basicTime = fees[0];\n            basicFee = fees[1];\n            unitTime = fees[2];\n            unitFee = fees[3];\n        }\n\n        private static void readRecords(String[] records) {\n            for (String record : records) {\n                String[] info = record.split(\" \");\n                int time = timeToInt(info[0]);\n                String carN = info[1];\n                boolean in = Objects.equals(info[2], \"IN\");\n\n                // 입차한 경우\n                if (in) carTimeMap.put(carN, time);\n                // 출차한 경우\n                else {\n                    // 입차 시간 가져옴\n                    int inTime = carTimeMap.get(carN);\n                    // 주차 시간 계산\n                    time -= inTime;\n                    \n                    accumCarMap.put(carN, accumCarMap.getOrDefault(carN, 0) + time);\n                    carTimeMap.remove(carN);\n                }\n            }\n        }\n\n        private static int timeToInt(String info) {\n            String[] line = info.split(\":\");\n            int hour = Integer.parseInt(line[0]) * 60;\n            int min = Integer.parseInt(line[1]);\n\n            return hour + min;\n        }\n\n        // 출차 기록이 없는 차 처리\n        private static void processRemainingCars() {\n            for (Map.Entry<String, Integer> entry : carTimeMap.entrySet()) {\n                String carN = entry.getKey();\n                int time = 1439 - entry.getValue();\n                \n                accumCarMap.put(carN, accumCarMap.getOrDefault(carN, 0) + time);\n            }\n        }\n\n        // 차 번호별 누적 주차 시간을 이용해 주차 요금 계산\n        private static int[] calculateFees() {\n            // 차 번호 오름차순으로 정렬\n            Object[] keys = accumCarMap.keySet().toArray();\n\n            Arrays.sort(keys);\n            \n            int[] answer = new int[accumCarMap.size()];\n            int idx = 0;\n            \n            // 정렬된 차 번호 순으로 누적 요금 계산\n            for (Object key : keys) {\n                int time = accumCarMap.get(key.toString());\n                int fee = basicFee;\n                \n                if (time > basicTime) {\n                    time = (int) Math.ceil((double) (time - basicTime) / unitTime);\n                    fee += (time * unitFee);\n                }\n                \n                answer[idx] = fee;\n                idx++;\n            }\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 하라는 대로 하면 되는 문제였으나, 자꾸 37.5점이 나오길래 `map` 에 접근하는 코드들을 다 뜯어보다가 어이없는 실수를 한 것을 확인했다.\n\n```java\n// 출차 기록이 없는 차 처리\nprivate static void processRemainingCars() {\n    int time = 1439;\n\n    for (Map.Entry<String, Integer> entry : carTimeMap.entrySet()) {\n        String carN = entry.getKey();\n        time = time - entry.getValue();\n        \n        accumCarMap.put(carN, accumCarMap.getOrDefault(carN, 0) + time);\n    }\n}\n\n\n// 출차 기록이 없는 차 처리\nprivate static void processRemainingCars() {\n    for (Map.Entry<String, Integer> entry : carTimeMap.entrySet()) {\n        String carN = entry.getKey();\n        int time = 1439 - entry.getValue();\n        \n        accumCarMap.put(carN, accumCarMap.getOrDefault(carN, 0) + time);\n    }\n}\n```\n\n- `time` 값은 1439로 고정되어 있어야 했는데, 반복문을 돌면서 자꾸 감소하도록 구현해놓아서 틀렸던 것이다..."},{"excerpt":"🧷 Link Layer 이전에 다룬 Transport Layer의 바로 하단에 위치하는 계층이다. 이 계층에서는 1계층인 물리 계층에서 발생할 수 있는 오류를 감지하고 수정하는 기능(Error Detection & Correction)을 수행한다. 대표적인 프로토콜로  이 존재한다. Correction -> 재전송, Forward Error 그리고 링크 …","fields":{"slug":"/[Network]LinkLayer/"},"frontmatter":{"date":"July 05, 2022","title":"📡 Link Layer","tags":["Network","OSI","Link"]},"rawMarkdownBody":"\n## 🧷 Link Layer\n이전에 다룬 Transport Layer의 바로 하단에 위치하는 계층이다. 이 계층에서는 1계층인 물리 계층에서 발생할 수 있는 오류를 감지하고 수정하는 기능(**Error Detection & Correction**)을 수행한다.\n- 대표적인 프로토콜로 `Ethernet` 이 존재한다.\n- Correction -> 재전송, Forward Error\n- 그리고 링크 계층의 주소는 물리적 주소이므로 변경이 불가능하다. (IP 주소는 논리적 주소이므로 변경이 가능했다.)\n\n링크 계층은 통신에 참여하는 장비인 node들이 존재한다. link는 이 node들을 연결한다.\n- link는 wired, wireless, LANs가 있다.\n- 그리고 이 계층에서는 패킷을 frame이라 한다. 물리적으로 인접한 node에게 link를 통해 전달된다.\n\n또한 링크 계층은 2개의 부 계층으로 구성된다.\n\n<img src=\"../../images/Network/MacLlc.png\" width=\"80%\">\n\n하나는 **MAC**, 물리적 부분으로 매체간의 연결 방식을 제어하고 1계층과 연결되어 있다. \n- 48-bit (6byte)로 구성되어 있고, 각 바이트마다 16진수로 표현된다.\n  - 그 중 앞 3자리는 OUI(Organization Unique Identifier)로 제조사 식별 코드가 있고, \n\n### 🪚 Services\n**Framing, link access**\n<img src=\"../../images/Network/framing.png\" width=\"80%\"> \n\n- 네트워크 계층에서 받아온 데이터그램을 프레임이라는 단위로 만들고, header와 trailer를 추가한다.\n- header: 목적지, 출발지 주소(MAC 주소), 데이터 내용에 대한 정의\n- trailer: 비트 에러 감지\n\n**Reliable delivery**\n- 비트 에러 감지를 통한 전송 보장\n- 왜 링크 계층과 엔드-엔드 모두 reliability를 따질까?\n  - 모든 링크 레벨에서 reliable한 것이 아니고, 엔드 포인트만이 얼마만큼의 reliability가 요구되는지 알기 때문이다.\n\n**Flow control**\n- 수신측의 overflow를 방지하기 하기 위함\n- Stop & Wait 방식이라고도 한다.\n\n**Error detection & correction**\n- 신호적 감쇄나 잡음으로 인해 프레임에 에러가 발생할 수 있다.\n- 수신자는 에러를 감지하고, 재전송을 요구하거나 해당 프레임을 드롭한다.\n- 또는 재전송 없이 비트 에러를 수정한다.\n\n<img src=\"../../images/Network/linklayer통신.jpeg\" width=\"80%\">\n\n- 전체적인 통신 흐름이다.\n- 송신측은 데이터그램을 framing하여 물리 계층으로 전달하고, 수신측에서는 데이터그램을 추출하여 상위 계층으로 전달한다.\n\n---\n\n## 🧷 Error Detection, Correction\n### 🪚 Error Detection\n에러의 감지를 위해 EDC를 사용한다. \n- EDC: Error Detection and Correction bits로, 전체 Frame의 정보가 유효한지 판단하는 기준이 된다.\n- 하지만 **EDC 또한 전송 과정에서 변형될 수 있어 100% 정확한 것은 아니다.**\n\n### 🪚 Error Detection - Parity Checking\n첫 번째로 정확성을 확인하는 방법으로 **Parity checking**이 있다.\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2Fbq1KyF%2Fbtq6rmcF5l3%2FK7SDERn1kWWhRTDms3c7F0%2Fimg.png\" width=\"80%\">\n\n- 전송되는 비트 수가 `d` bits라고 하자. **짝수 Parity checking**은 `d + 1` bits를 보낼 때, 1의 개수가 짝수가 되도록 추가적인 비트를 붙인다.\n  - 마찬가지로 홀수는 홀수가 되도록 추가 비트를 붙인다. \n- 하지만 이는 **하나의 비트가 변형되는 오류는 검출할 수 있지만, 짝수 개의 오류는 검출할 수 없다**는 특징이 있다.\n\n그리고 이를 보완한 방법으로 **Two-dimensional bit parity**가 있다. 이는 보내는 비트를 행렬로 표현한 뒤, 각각의 행과 열마다의 Parity checking을 수행한다.\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FcsmQCb%2Fbtq6q1Ubz1x%2FDs9H7vkyMw76aIpXhIIcT0%2Fimg.png\" width=\"80%\">\n\n- 하지만 이 또한, 같은 행과 열에 오류가 발생하는 것은 검출하지 못한다.\n\n### 🪚 Error Detection - Internet Checksum\n이전에도 다룬 적이 있는 **Checksum**이다.\n- UDP 세그먼트를 16bit의 정수로 변환한 뒤, 이들의 합을 구한다.\n- 합의 1의 보수 형태가 checksum이 된다.\n\n### 🪚 Error Detection - Cyclic Redundancy Check (CRC)\nParity Checking보다 더 성능이 향상되었고, 회로 구현이 쉽다는 장점이 있는 CRC이다.\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FtDUrj%2Fbtq6zWFuY5w%2FnCldkhFZJJxv04aTFJOJEK%2Fimg.png\" width=\"80%\">\n\n- 전송하려는 D(Data bits)를 $2^{송수신측\\ 모두가\\ 알고\\ 있는\\ Divisor의\\ 자릿수\\ -\\ 1}$만큼 곱한다.\n- D(Data bits)를 Divisor로 나눈다. \n- 나눈 후 나머지(r bits)를 D 뒤에 붙여 D + (r + 1) bits를 전송한다. \n- 수신측에서는, 받은 D를 알고 있는 Divisor로 나눈다.\n- 이때 나머지가 0이라면, 수신한 데이터에 오류가 없다는 의미이고, 데이터에서 나머지 부분을 제외하고 수용한다.\n- 나머지가 0이 아니라면, 오류가 있는 데이터라고 판단하고 드롭한다.\n\n> 하지만 CRC 또한, 실제 보낸 데이터가 `10010` 이고, 붙여진 CRC가 `000` 인데, `10010000` 이 `10011001` 로 오류가 발생한 채로 전송되었다면, 이또한 나머지가 0이기 때문에 오류 검출을 하지 못하는 경우가 발생할 수 있다.\n\n---\n\n## 🧷 Multiple Access Protocols\nLink의 종류에는 Point-to-Point와 Broadcast로 2가지가 있다. 그 중 Broadcast는 공유된 자원을 사용하는 방식이기에, media(자원) access에 대한 제어가 필요하다.\n\n**Multiple Access Protocols이 필요한 이유**는 여러 명의 사람이 대화를 하는데, 다 같이 동시에 말하면 각자의 말이 다 섞여 알아듣기 어렵다. 이를 네트워크에서는 **Collision**이라 하는데, 이를 해결하기 위해 Multiple Access Protocol이 등장했다.\n- 노드가 채널을 어떻게 나눠 가질지 결정하는 분산 알고리즘이다.\n  - 즉, 언제 노드가 전송할 지 결정하는 알고리즘이다.\n  - 매체를 여러 노드가 사용할 수 있도록 접근 제어, 순서 제어를 해주는 프로토콜이다.\n\n> **분산 알고리즘**\n> - 중앙 판단이 아닌 각각의 노드가 자율적으로 판단하는 알고리즘\n\n예를 들어, 어떤 매체(broadcast channel)에 Rbps만큼 보낼 수 있다고 가정하자. 이때 필요한 특징으로는 다음과 같다.\n- 노드가 하나뿐이라면, R만큼을 다 사용할 수 있다.\n- 만약 M개의 노드가 있다면, 가능한 한 각각 평균 R/M만큼 사용할 수 있어야 한다.\n- 중앙 집중화가 있어선 안되므로, 전송을 관리하는 노드가 있어서는 안된다.\n- 보내는 타이밍을 관리하는 clock이나 slot이 있으면 안된다.\n\n그리고 이를 이루기 위해 필요한 것이 MAC protocol이다. 이는 Media Access Control의 약자로, 크게 3 종류로 나뉜다.\n- **Channel Partitioning** : 채널을 여러 작은 조각들(time slots, frequency, code)로 나눠 분배한다. 즉 각 노드마다 독점 사용을 위해 할당하는 것이다.\n- **Random Access** : 채널을 나누지 않고, 원할 때마다 보내는 것이다. 당연히 Collision이 발생할테고, 이를 수용해 그냥 다시 보낸다. 채널에 속한 노드의 수가 적을 때 택할 수 있다.\n- **Taking turns** : 돌아가면서 보낼 수 있도록 한다. 동일한 시간을 분배해주는 것이 아니라 보낼 데이터가 많은 노드의 경우 더 많은 시간을 사용할 수 있다. token을 사용해, token이 있는 경우만 전송이 가능하도록 하여 충돌을 방지한다.\n\n### 🪚 Channel Partitioning - TDMA\nTDMA(Time Division Multiple Access)의 약자로, 이름 그대로 time slot으로 분할하여 각 time slot에 보낼 노드가 할당되는 방식이다. \n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FbSSigN%2Fbtq6AsYaMh9%2Fo5WD15Ua32fk5ehZ6oIGKk%2Fimg.png\" width=\"80%\">\n\n- 하지만 이러한 방식은 할당량에 비해 실 사용량이 적어 비효율적일 수 있다.\n\n### 🪚 Channel Partitioning - FDMA\nFDMA(Frequency Division Multiple Access)의 약자로, 주파수 대역을 다르게 하여 전송하는 방식이다.\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FdqF3SE%2Fbtq6A9Rmn8m%2FLs1tsHlIgkIDX9k9inl9eK%2Fimg.png\" width=\"80%\">\n\n- 동일한 시간대에 여러 노드가 보낼 수 있다는 장점이 있긴 하지만, 쓰이지 않는 주파수 대역이 있다면, 즉 사용하는 노드의 수가 적다면 이 또한 비효율적일 수 있다.\n\n> 따라서 Channel Partitioning 방식은 네트워크에 있는 노드의 수가 정해져 있고, 각각 처리량이 많을 때 유용하다고 할 수 있다.\n\n### 🪚 Random Access Protocol\n이는 결국 랜덤하게 자원 접근을 허용하는 방식이다. 따라서 Collision이 발생할 수 밖에 없고, 이를 **어떻게 발견하고 복구할 것인가**에 대한 처리가 필요하다.\n\n### 🪚 Random Access Protocol - ALOHA\n섬 간 통신을 위해 개발된 ALOHA는 다른 말로는 unslotted ALOHA, pure ALOHA라고도 한다. 이는 보내고 싶을 때 보내기 때문에, Collision 발생이 잦다.\n- 한 프레임을 거의 다 보냈을 때에 다른 프레임을 전송하려 하면, Collision이 발생하기에 매우 비효율적이었다.\n\n### 🪚 Random Access Protocol - Slotted ALOHA\nALOHA의 문제를 해결하기 위해, 시간을 slot으로 나누어, 하나의 data는 무조건 하나의 slot을 통해 전송되도록 강제했다.\n- 두 개 이상의 노드가 전송한 경우, 모든 단말은 Collision을 인지한다.\n- 노드가 프레임을 전송할 때, 충돌이 발생하지 않았다면 다음 slot에 프레임을 더 전송하고, 충돌이 발생했다면 각 노드가 측정한 성공확률에 따라 다음 slot에 프레임을 전송할 지 결정했다.\n\npure ALOHA보다는 일정한 규칙을 성립해 충돌로 인한 데이터 전송 실패를 해결해 성능이 좋다는 이점이 있었다. 하지만 여전히 **충돌은 존재했고, 낭비되는 slot**이 많고, **충돌 감지 신호가 도착했음에도 전송 중지가 되지 않았으며 clock synchronization이 정확하지 않았다.**\n\n### 🪚 Random Access Protocol - CSMA\nSlotted ALOHA의 문제를 해결하기 위해 CSMA(Carrier Sense Multiple Access)는 계속해서 채널의 상태를 확인하면서, \n- 채널이 idle하다면, 전송을 수행했고\n- 채널이 busy하다면, 전송을 연기시켰다.\n\n> CSMA 프로토콜은 충돌이 발생하기 전, 채널의 상태를 확인함으로써 충돌을 피하는 반면, ALOHA는 충돌이 발생한 후에만 채널이 사용 중임을 감지한다.\n\n이렇게 채널을 미리 감지함으로써 CSMA는 충돌이 발생하지 않을 것 같지만, Propagation Delay(전달 지연)로 인해 충돌이 발생할 수 있다.\n- 노드가 다른 노드의 전송을 감지하지 못했을 수도 있다는 것이다. 예로는 눈치 게임 시에 아무도 1을 외치지 않아 여러 명이 동시에 1을 외치는 상황과 비슷하다.\n- CSMA에서는 이와 같이 충돌이 발생할 수 있는 시간을 `Vulnerable time` 이라 한다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FnoWOK%2Fbtq6zRYrCWc%2Fc90M72nZI9Egxt2wRIfVu0%2Fimg.png\" width=\"80%\">\n\n- A가 t1의 시점에 전송한다고 신호를 보냈을 때, D가 이를 감지하는 시점은 t1 + tp이다. 이때 tp가 `propagation delay` 를 의미하고, 노란색 부분이 `Vulnerable time` 이다.\n  - 이때 B, C, D 중 누구라도 신호를 보내면, 충돌이 발생한다.\n\n### 🪚 Random Access Protocol - CSMA/CD\nCSMA/CD는 CSMA에서의 충돌을 방지하기 위해 만들어졌다. 이때 CD는 Collision Detection을 의미한다. \n- 이는 신호의 세기를 측정하고, 전송된 신호와 수신된 신호를 비교함으로써 충돌이 발생했는지를 판단한다. 하지만 이러한 판단 특성 때문에 무선 환경에서는 충돌 감지가 쉽지 않고, 이를 보완하고자 CSMA/CA가 만들어졌다.\n\nEthernet CSMA/CD 알고리즘을 살펴보면 다음과 같다.\n- 먼저 이더넷 카드(NIC)가 네트워크 계층으로부터 데이터그램을 받아 프레임을 생성한다.\n- NIC가 채널을 감지했을 때, idle하면 프레임 전송을 시작하고, 그렇지 않으면 채널이 idle할 때까지 대기한 후 전송을 시작한다.\n- 만약 NIC가 충돌 없이 프레임 전체를 전송했다면, 제대로 전송했다는 의미고 다음 프레임 전송을 준비한다.\n  - 프레임을 전송하자마자 바로 신호를 수신한다. 수신한 신호가 보낸 것과 다르다면, 충돌이 발생했다고 감지한다.\n- 충돌이 감지되었다면, 전송을 중단하고, jam signal을 전송한다.\n  - jam signal : 다른 노드들에게 충돌이 발생했음을 알리기 위한 신호\n- 중단 이후, NIC는 **binary (exponential) backoff**를 수행한다.\n  - m번째 충돌 이후, NIC는 {0,1,2,3, ... , $2^{m - 1}$} 중 랜덤한 k를 선택하고, k * 512bit times를 대기한 후 다시 채널 sensing을 수행한다.\n  - m이 커질 수록, (충돌 횟수가 많아질수록) 같은 k를 고를 확률이 감소하기에 충돌 확률이 줄어든다.\n\n### 🪚 Taking turns MAC protocols\nTaking turns 방식은 channel partitioning의 \"채널을 효율적이고 공평하게 분배\"한다는 장점과 random access의 \"load가 낮을 때의 효율성\"이라는 장점을 모두 갖춘 방식이다.\n\n### 🪚 Taking turns MAC protocols - polling\n<img src=\"../../images/Network/polling.jpeg\" width=\"80%\">\n\n- 마스터 노드가 다른 노드들에게 전송을 돌아가면서 시키는 것이다.\n- 마스터 노드가 모든 노드들에게 전송할 것인지 물어보는 delay(polling delay)와, 각 노드들은 자기 차례를 위해서는 한 바퀴를 기다려야 하는 delay가 있다.\n\n### 🪚 Taking turns MAC protocols - token passing\n<img src=\"../../images/Network/tokenPassing.jpeg\" width=\"80%\">\n\n- 한 노드가 다음 순서의 노드에게 token을 전달하고, token을 받은 노드가 전송을 수행한다.\n- token을 주고받는 데 드는 overhead와, 자기 차례를 기다려야 하는 latency, token 또한 한 메시지의 일종이므로 손실 발생이 가능하다는 특징이 있다.\n\n---\n\n## 🧷 ARP: Address Resolution Protocol\n이는 논리적 주소인 IP를 물리적 주소인 MAC으로 변환하는 프로토콜이다. 그렇다면 RARP는 물리적 주소를 논리적 주소로 변환하는 프로토콜이 되겠다.\n\n그리고 이 변환을 위해 필요한 것이 ARP Table이다. 이는 IP 주소에 해당하는 MAC 주소를 관리하는 테이블로, `<IP address; MAC address; TTL>` 의 형태로 저장하고 있고, TTL이 지난 이후는 해당 정보는 드롭된다.\n- 따라서 테이블에 없다면, ARP 과정을 거쳐 다시 테이블에 저장된다.\n\n### 🪚 ARP protocol in action\nA가 B에게 데이터그램을 전송하려 한다. 하지만 A의 ARP Table에는 B의 MAC 주소에 대한 정보가 없다. 이때 ARP를 사용해 B의 MAC 주소를 얻는다.\n- A는 B의 IP 주소를 포함한 ARP query를 broadcast한다.\n- 이때 B는 본인에게 해당하는 IP 주소이므로, 본인의 MAC 주소를 포함한 response를 A에게 전송하고, 이를 수신한 A는 ARP Table을 완성한다.\n\n---\n\n## 🧷 Ethernet\n데이터 링크 계층에서 사용하는 프로토콜 중 하나로, CSMA/CD 방식을 이용하여 여러 개의 컴퓨터가 공유 매체를 사용할 수 있도록 제어하며, 스위치에서 MAC 주소를 이용해 데이터를 필요로 하는 컴퓨터에게만 전달할 수 있도록 한다.\n\n### 🪚 Ethernet frame structure\n<img src=\"../../images/Network/ethernetFrame.jpeg\" width=\"80%\">\n\n- `preamble` : 이더넷 프레임의 동기화와 시작을 알리는 신호\n- `type` : 어떤 유형의 프로토콜인지를 명시 (IPv4, IPv6, ARP, RARP, SNMP over Ethernet)\n- `CRC` : 프레임의 에러 체크\n\n### 🪚 Ethernet: unreliable, connectionless\n`Connectionless` : 연결이 없기 때문에, handshaking 과정 또한 없다.\n\n`unreliable` : ACK이나 NAK을 전송하지 않는다. 에러 체크로 에러를 감지하면, 해당 데이터는 버린다.\n\nEthernet의 MAC protocol은 **unslotted CSMA/CD**를 사용하고, **binary backoff**를 수행한다.\n\n---\n\n## 🧷 Switches & Routers\n<img src=\"../../images/Network/switches&routers.jpeg\" width=\"40%\">\n\n- **둘 다 store-and-forward를 수행한다.**\n  - routers: 네트워크 계층의 장비에 대한 처리, data gram을 저장\n  - switches: 링크 계층의 장비에 대한 처리, frame을 저장\n- **둘 다 forwarding table을 가진다.**\n  - routers: routing algorithm을 통해 테이블을 계산하고, IP 주소에 대해 처리한다.\n  - switches: flooding, learning을 통해 테이블을 학습하고, MAC 주소에 대해 처리한다.\n\n---\n\n## 🧷 VLANs(Virtual LANs)\n<img src=\"../../images/Network/vlan.jpeg\" width=\"80%\">\n\n- 위 그림에서 여러 PC들이 연결되어 있는 구역을 LAN이라 한다.\n- 만약 LAN 간 host의 이동이 발생한다면, 물리적으로는 이동하지만, 논리적으로는 이동하지 않은 것처럼 행동해야 하고, 이를 위해 VLAN이 필요하다.\n\n### 🪚 VLANs spanning multiple switches\n<img src=\"../../images/Network/vlanSwitches.jpeg\" width=\"80%\">\n\n- multiple physical switches에 정의된 VLANs간 프레임을 주고 받음으로써 논리적 이동을 수행한다.\n  - 이때, VLAN ID 정보를 주고 받는다.\n\n---\n\n## 🧷 MPLS(Multiprotocol label switching)\nIP routing의 경우, 목적지 주소 정보만을 가지고 routing을 진행하기에 **매번 상위 계층까지 이동해 주소를 확인해야 하는 과정**이 필요해 느리다. 따라서 **추가적인 고정된 크기의 label 정보**를 이용해 바로바로 routing을 수행할 수 있는 MPLS가 등장했다.\n- IP routing은 목적지로 가는 경로는 목적지 주소 하나만으로 결정된다.\n- MPLS routing은 출발지 주소와 목적지 주소를 기반으로 경로가 결정된다.\n  - fast reroute: 링크 failure를 대비해 backup routes를 미리 계산한다.\n\n---\n\n## 📕 참고\n- [[네트워크] 데이터 링크 계층(Data Link Layer) - 역할과 기능](https://velog.io/@redgem92/%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EB%A7%81%ED%81%AC-%EA%B3%84%EC%B8%B5Data-Link-Layer-1)\n- [컴퓨터 네트워크_34_ Link layer protocol(Error Detection)](https://team00csduck.tistory.com/156)\n- [컴퓨터 네트워크_35_ Multiple access protocols](https://team00csduck.tistory.com/157?category=846437)"},{"excerpt":"문제 Programmers - 신고 결과 받기 📍 Logic 유저별로, 신고당한 횟수와 신고한 유저 리스트, 그리고 정지 기준을 넘은 유저를 신고한 횟수를 저장하는 map을 사용한다. 📄 CODE ✏️ Review 간단한 구현 문제였으나, 비효율적으로 구현한 것 같다.","fields":{"slug":"/[Programmers]92334/"},"frontmatter":{"date":"July 04, 2022","title":"👩‍💻 92334. 신고 결과 받기","tags":["Map"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 신고 결과 받기](https://programmers.co.kr/learn/courses/30/lessons/92334)\n\n### 📍 **Logic**\n\n```java\n// 유저별 신고당한 횟수 저장 map\nMap<String, Integer> reportMap = new HashMap<>();\n// 유저별 신고한 유저 저장 map\nMap<String, ArrayList<String>> userReportMap = new HashMap<>();\n// 유저별 메일 받을 횟수 저장 map\nMap<String, Integer> mailMap = new HashMap<>();\n```\n\n- 유저별로, 신고당한 횟수와 신고한 유저 리스트, 그리고 정지 기준을 넘은 유저를 신고한 횟수를 저장하는 map을 사용한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        \n        // 유저별 신고당한 횟수 저장 map\n        Map<String, Integer> reportMap = new HashMap<>();\n        // 유저별 신고한 유저 저장 map\n        Map<String, ArrayList<String>> userReportMap = new HashMap<>();\n        // 유저별 메일 받을 횟수 저장 map\n        Map<String, Integer> mailMap = new HashMap<>();\n        \n        public int[] solution(String[] id_list, String[] report, int k) {\n            for (String rep : report) {\n                String[] line = rep.split(\" \");\n                String id = line[0];\n                String bannedId = line[1];\n\n                ArrayList<String> list = null;\n                // 유저별 신고한 유저 저장\n                if (userReportMap.containsKey(id)) {\n                    list = userReportMap.get(id);\n                    if (!list.contains(bannedId)) {\n                        list.add(bannedId);\n                        reportMap.put(bannedId, reportMap.getOrDefault(bannedId, 0) + 1);\n                    }\n                } else {\n                    list = new ArrayList<>();\n                    list.add(bannedId); \n                    reportMap.put(bannedId, reportMap.getOrDefault(bannedId, 0) + 1);\n                }\n                userReportMap.put(id, list);\n            }\n            \n            // 유저별 신고한 유저가 정지 기준을 넘은 횟수를 mailMap에 저장\n            for (Map.Entry<String, ArrayList<String>> entry : userReportMap.entrySet()) {\n                ArrayList<String> list = entry.getValue();\n                for (String id : list)\n                    if (reportMap.get(id) >= k)\n                        mailMap.put(entry.getKey(), mailMap.getOrDefault(entry.getKey(), 0) + 1);\n            }\n            \n            int[] answer = new int[id_list.length];\n            for (int i = 0; i < id_list.length; i++)\n                answer[i] = mailMap.getOrDefault(id_list[i], 0);\n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 간단한 구현 문제였으나, 비효율적으로 구현한 것 같다."},{"excerpt":"문제 Programmers - 광고 삽입 📍 Logic 광고 시간만큼 앞에서부터 구간 합을 구한다. 이를 초기값으로 설정해, 이후부터 슬라이딩 윈도우 방식으로 광고 시간 크기만큼 구간 합을 갱신하면서, 최대가 되는 경우의 시작시간을 구한다. 📄 CODE ✏️ Review  을  형으로 변환해 초 단위로 저장하는 것은 바로 생각했고, 처음에는 시작시간과 종료…","fields":{"slug":"/[Programmers]72414/"},"frontmatter":{"date":"July 03, 2022","title":"👩‍💻 72414. 광고 삽입","tags":["구간 합","슬라이딩 윈도우"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 광고 삽입](https://programmers.co.kr/learn/courses/30/lessons/72414)\n\n### 📍 **Logic**\n\n```java\n// 초기값 설정 !\n// adT만큼의 구간 합을 구하고 이보다 큰 구간 합을 찾기 위해서\nlong sum = 0;\nfor (int i = 0; i < adT; i++)\n    sum += viewerCount[i];\nlong maxSum = sum;\n\nint startT = 0;\nfor (int i = adT; i < playT; i++) {\n    // adT 만큼의 구간을 확인하기 위해 제일 앞 값을 빼고, 더한다.\n    int front = i - adT;\n    sum -= viewerCount[front];\n    sum += viewerCount[i];\n\n    // 구간 합이 가장 큰 경우, 갱신\n    if (sum > maxSum) {\n        maxSum = sum;\n        // front는 현재 포함되지 않는 시간이므로 + 1 해야 시작 시간\n        startT = front + 1;\n    }\n}\n```\n- 광고 시간만큼 앞에서부터 구간 합을 구한다.\n- 이를 초기값으로 설정해, 이후부터 슬라이딩 윈도우 방식으로 광고 시간 크기만큼 구간 합을 갱신하면서, 최대가 되는 경우의 시작시간을 구한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Solution {\n        static int[] viewerCount;\n        \n        public String solution(String play_time, String adv_time, String[] logs) {\n            int playT = stringToTime(play_time);\n            int adT = stringToTime(adv_time);\n\n            viewerCount = new int[playT];\n\n            for (String log : logs) {\n                String[] line = log.split(\"-\");\n                int startT = stringToTime(line[0]);\n                int endT = stringToTime(line[1]);\n\n                // 이상, 미만!\n                // 각 구간별 초 단위 뷰어를 카운트\n                for (int i = startT; i < endT; i++) \n                    viewerCount[i]++;\n            }\n\n            // 초기값 설정 !\n            // adT만큼의 구간 합을 구하고 이보다 큰 구간 합을 찾기 위해서\n            long sum = 0;\n            for (int i = 0; i < adT; i++)\n                sum += viewerCount[i];\n            long maxSum = sum;\n\n            int startT = 0;\n            for (int i = adT; i < playT; i++) {\n                // adT 만큼의 구간을 확인하기 위해 제일 앞 값을 빼고, 더한다.\n                int front = i - adT;\n                sum -= viewerCount[front];\n                sum += viewerCount[i];\n\n                // 구간 합이 가장 큰 경우, 갱신\n                if (sum > maxSum) {\n                    maxSum = sum;\n                    startT = front + 1;\n                }\n            }\n            \n            return timeToString(startT);\n        }\n        \n        private static int stringToTime(String string) {\n            String[] line = string.split(\":\");\n            int time = 0;\n\n            time += Integer.parseInt(line[0]) * 3600;\n            time += Integer.parseInt(line[1]) * 60;\n            time += Integer.parseInt(line[2]);\n\n            return time;\n        }\n\n        private static String timeToString(int time) {\n            StringBuilder sb = new StringBuilder();\n\n            int h = time / 3600;\n            if (h < 10) sb.append(\"0\");\n            sb.append(h).append(\":\");\n            time %= 3600;\n\n            int m = time / 60;\n            if (m < 10) sb.append(\"0\");\n            sb.append(m).append(\":\");\n            time %= 60;\n\n            if (time < 10) sb.append(\"0\");\n            return sb.append(time).toString();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- `String` 을 `int` 형으로 변환해 초 단위로 저장하는 것은 바로 생각했고, 처음에는 시작시간과 종료시간, 러닝 타임을 기준으로 정렬하고 이를 다시 탐색하면서 각 구간별 뷰어를 구하려 했다.\n- 구현에서 막히고, 좀 더 효율적인 방법이 없을까해서 다른 풀이를 확인했더니 구간 합과 슬라이딩 윈도우를 활용하는 문제였다는 것을 알았다."},{"excerpt":"문제 Programmers - 합승 택시 요금 📍 Logic 다익스트라 알고리즘을 사용해 주어진 기점을 기준으로 각 지점까지의 최소 비용을 구하고, 이를 반환한다. 📄 CODE ✏️ Review source가 주어지고, 각 지점까지의 최소 비용을 구하는 Single Source Shortest Path 문제라는 것은 쉽게 알 수 있었고, 다익스트라 알고리즘…","fields":{"slug":"/[Programmers]72413/"},"frontmatter":{"date":"July 02, 2022","title":"👩‍💻 72413. 합승 택시 요금","tags":["다익스트라"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 합승 택시 요금](https://programmers.co.kr/learn/courses/30/lessons/72413)\n\n### 📍 **Logic**\n\n```java\nprivate static int[] dijkstra(int start) {\n    int[] costs = new int[n + 1];\n    Arrays.fill(costs, Integer.MAX_VALUE);\n\n    Queue<Edge> queue = new PriorityQueue<>();\n    queue.add(new Edge(start, 0));\n    costs[start] = 0;\n\n    while(!queue.isEmpty()) {\n        Edge node = queue.poll();\n        int now = node.dest;\n        int weight = node.weight;\n\n        // 현재 비용보다 더 큰 경우는 패스\n        if (weight > costs[now]) continue;\n\n        // 현재 정점에서 갈 수 있는 엣지 리스트\n        ArrayList<Edge> edges = adjList[now];\n        for (Edge e : edges) {\n            // 현재(now) 정점까지의 비용과 다음으로 이동할 엣지의 비용의 합\n            int cost = costs[now] + e.weight;\n\n            // 이전 비용보다 새로운 비용이 더 작은 경우 갱신\n            if (cost < costs[e.dest]) {\n                costs[e.dest] = cost;\n                queue.add(new Edge(e.dest, cost));\n            }\n        }\n    }\n\n    return costs;\n}\n```\n- 다익스트라 알고리즘을 사용해 주어진 기점을 기준으로 각 지점까지의 최소 비용을 구하고, 이를 반환한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Edge implements Comparable<Edge> {\n        int dest;\n        int weight;\n\n        public Edge(int dest, int weight) {\n            this.dest = dest;\n            this.weight = weight;\n        }\n        \n        // 다익스트라 알고리즘 사용을 위해 비용 기준 오름차순 정렬\n        @Override\n        public int compareTo(Edge n) {\n            return this.weight - n.weight;\n        }\n    }\n\n    // 각 지점까지의 최소 거리를 구한다.\n    // 이후 1 ~ N까지의 지점을 합승 지점으로 두고, 최소 비용을 구한다.\n    class Solution {\n        static ArrayList<Edge>[] adjList;\n        static int n;\n        \n        public int solution(int n, int s, int a, int b, int[][] fares) {\n            this.n = n;\n            init(fares);\n\n            // S를 기점으로 최소 비용 계산\n            int[] startFromSrc = dijkstra(s);\n            // A를 기점으로 최소 비용 계산\n            int[] startFromA = dijkstra(a);\n            // B를 기점으로 최소 비용 계산\n            int[] startFromB = dijkstra(b);\n\n            int answer = Integer.MAX_VALUE;\n\n            for (int i = 1; i <= n; i++)\n                // i는 합승 지점\n                // src로부터 i까지의 최소 비용 + i로부터 a까지의 최소 비용 + i로부터 b까지의 최소 비용\n                answer = Math.min(answer, startFromSrc[i] + startFromA[i] + startFromB[i]);\n            return answer;\n        }\n        \n        // 인접 리스트 생성 및 초기화\n        private static void init(int[][] fares) {\n            adjList = new ArrayList[n + 1];\n\n            for (int i = 1; i < n + 1; i++)\n                adjList[i] = new ArrayList<>();\n\n            for (int[] fare : fares) {\n                adjList[fare[0]].add(new Edge(fare[1], fare[2]));\n                adjList[fare[1]].add(new Edge(fare[0], fare[2]));\n            }\n        }\n        \n        private static int[] dijkstra(int start) {\n            int[] costs = new int[n + 1];\n            Arrays.fill(costs, Integer.MAX_VALUE);\n\n            Queue<Edge> queue = new PriorityQueue<>();\n            queue.add(new Edge(start, 0));\n            costs[start] = 0;\n\n            while(!queue.isEmpty()) {\n                Edge node = queue.poll();\n                int now = node.dest;\n                int weight = node.weight;\n\n                // 현재 비용보다 더 큰 경우는 패스\n                if (weight > costs[now]) continue;\n\n                // 현재 정점에서 갈 수 있는 엣지 리스트\n                ArrayList<Edge> edges = adjList[now];\n                for (Edge e : edges) {\n                    // 현재(now) 정점까지의 비용과 다음으로 이동할 엣지의 비용의 합\n                    int cost = costs[now] + e.weight;\n\n                    // 이전 비용보다 새로운 비용이 더 작은 경우 갱신\n                    if (cost < costs[e.dest]) {\n                        costs[e.dest] = cost;\n                        queue.add(new Edge(e.dest, cost));\n                    }\n                }\n            }\n\n            return costs;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- source가 주어지고, 각 지점까지의 최소 비용을 구하는 **Single Source Shortest Path** 문제라는 것은 쉽게 알 수 있었고, 다익스트라 알고리즘을 사용했다.\n- 다만, 합승 지점이라는 조건에 대해 막혔다. \n  - **`S -> X`, `X -> A`, `X -> B` 에서 X가 1 ~ N 지점이 가능**하다는 아이디어가 주요했다."},{"excerpt":"문제 Programmers - 행렬 테두리 회전하기 📍 Logic 주어진 두 좌표를 기준으로, 왼쪽 줄, 아랫 줄, 오른쪽 줄, 윗 줄 순으로 행렬을 회전시키면서, 최솟값을 찾는 함수 📄 CODE ✏️ Review 문제 자체는 쉬우나, 인덱스 보다가 눈알 빠져버리는 문제","fields":{"slug":"/[Programmers]77485/"},"frontmatter":{"date":"July 02, 2022","title":"👩‍💻 77485. 행렬 테두리 회전하기","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 행렬 테두리 회전하기](https://programmers.co.kr/learn/courses/30/lessons/77485)\n\n### 📍 **Logic**\n\n```java\nprivate int rotation(int x1, int y1, int x2, int y2) {...}\n```\n\n- 주어진 두 좌표를 기준으로, 왼쪽 줄, 아랫 줄, 오른쪽 줄, 윗 줄 순으로 행렬을 회전시키면서, 최솟값을 찾는 함수\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n    \n        static int[][] map;\n        \n        public int[] solution(int rows, int columns, int[][] queries) {\n            int[] answer = new int[queries.length];\n            int idx = 0;\n            \n            init(rows, columns);\n            \n            for (int[] query : queries)\n                answer[idx++] = rotation(query[0] - 1, query[1] - 1, query[2] - 1, query[3] - 1);\n            \n            return answer;\n        }\n        \n        private void init(int rows, int columns) {\n            map = new int[rows][columns];\n            int num = 1;\n            \n            for (int i = 0; i < rows; i++)\n                for (int j = 0; j < columns; j++)\n                    map[i][j] = num++;\n        }\n        \n        private int rotation(int x1, int y1, int x2, int y2) {\n            int w = y2 - y1;\n            int h = x2 - x1;\n            int value = map[x1][y1];\n            int min = value;\n            \n            // 왼쪽 줄 이동\n            for (int i = x1 + 1; i <= x1 + h; i++) {\n                int moveN = map[i][y1];\n                if (min > moveN) min = moveN;\n                map[i - 1][y1] = moveN;\n            }\n            \n            // 아랫 줄 이동\n            for (int j = y1 + 1; j <= y1 + w; j++) {\n                int moveN = map[x2][j];\n                if (min > moveN) min = moveN;\n                map[x2][j - 1] = moveN;\n            }\n            \n            // 오른쪽 줄 이동\n            for (int i = x2 - 1; i >= x1; i--) {\n                int moveN = map[i][y2];\n                if (min > moveN) min = moveN;\n                map[i + 1][y2] = moveN;\n            }\n            \n            // 윗 줄 이동\n            for (int j = y2 - 1; j > y1; j--) {\n                int moveN = map[x1][j];\n                if (min > moveN) min = moveN;\n                map[x1][j + 1] = moveN;\n            }\n            \n            map[x1][y1 + 1] = value;\n            \n            return min;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 문제 자체는 쉬우나, 인덱스 보다가 눈알 빠져버리는 문제"},{"excerpt":"문제 Programmers - 로또의 최고 순위와 최저 순위 📍 Logic 숫자의 당첨 유무 확인 📄 CODE ✏️ Review 쉬운 문제","fields":{"slug":"/[Programmers]77484/"},"frontmatter":{"date":"July 02, 2022","title":"👩‍💻 77484. 로또의 최고 순위와 최저 순위","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 로또의 최고 순위와 최저 순위](https://programmers.co.kr/learn/courses/30/lessons/77484)\n\n### 📍 **Logic**\n\n```java\nfor (int lotto : lottos) {\n    if (lotto == 0) zeroCount++;\n    else nums[lotto] = true;\n}\n\nfor (int win : win_nums)\n    if (nums[win]) correctCount++;\n```\n\n- 숫자의 당첨 유무 확인\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        public int[] solution(int[] lottos, int[] win_nums) {\n            boolean[] nums = new boolean[46];\n            int correctCount = 0;\n            int zeroCount = 0;\n            \n            for (int lotto : lottos) {\n                if (lotto == 0) zeroCount++;\n                else nums[lotto] = true;\n            }\n            \n            for (int win : win_nums)\n                if (nums[win]) correctCount++;\n            \n            int max = getRanking(correctCount + zeroCount);\n            int min = getRanking(correctCount);\n            \n            return new int[]{max, min};\n        }\n        \n        private int getRanking(int count) {\n            if (count <= 1) return 6;\n            return 7 - count;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 쉬운 문제"},{"excerpt":"🧷 Network Layer 이전에 다룬 Transport Layer의 바로 하단에 위치하는 계층으로, 컴퓨터 네트워크의 핵심이라고 할 수 있다. 🪚 네트워크 계층의 핵심 기능 Forwarding data plane이 담당한다. 패킷이 들어왔을 때, 이를 내보내는 기능을 수행한다. Routing control plane이 담당한다. 들어온 패킷을 어디로 …","fields":{"slug":"/[Network]NetworkLayer/"},"frontmatter":{"date":"July 01, 2022","title":"📡 Network Layer","tags":["Network","OSI"]},"rawMarkdownBody":"\n## 🧷 Network Layer\n이전에 다룬 Transport Layer의 바로 하단에 위치하는 계층으로, 컴퓨터 네트워크의 핵심이라고 할 수 있다.\n\n### 🪚 네트워크 계층의 핵심 기능\n**Forwarding**\n- data plane이 담당한다.\n- 패킷이 들어왔을 때, 이를 내보내는 기능을 수행한다.\n\n**Routing**\n- control plane이 담당한다.\n- 들어온 패킷을 어디로 내보낼 지 판단하는 기능을 수행한다.\n\n### 🪚 Data plane & Control plane\n**Data plane**\n- 라우터 내부 local로 범위가 한정되고, 각각의 라우터마다 동작한다.\n- **들어온 패킷이 어떻게 forwarding**될 지 결정한다.\n\n**Control plane**\n- 네트워크 전체에 대한 범위를 가진다.\n- forwarding table(라우터들이 사용하는 표)를 이용해 결정하는 **전통적인 방식**과, 중앙 서버를 활용하는 **SDN 방식**이 존재한다.\n  - 전통 방식은 라우터들끼리 라우팅 프로토콜에 의해 정보를 주고받으며 생성하는 방식\n  - SDN 방식은 중앙 서버 (Remote Controller) 에서 RT를 생성한 후, 이를 라우터들에게 전달해주는 방식\n\n> **네트워크 서비스 모델**\n> - 개별 패킷에 대한 서비스 요구가 가능해야 한다.\n> - 연속적으로 패킷을 전송할 수 있어야 한다.\n\n---\n\n## 🧷 라우터 내부 구조\n<img src=\"../../images/Network/라우터구조.jpeg\" width=\"80%\">\n\n- 라우터는 두 개 이상의 네트워크를 연결하는 디바이스로, `source` 로부터 `destination` 으로 정보(패킷)를 전송하는 데 사용된다. \n- 라우팅을 담당하고 관리하는 SW형태의 routing processor와, Forwarding을 담당하는 HW형태의 high-speed switching fabric이 존재한다.\n- routing processor는 패킷의 목적지 주소를 가지고 RT를 참고한다. 이후 다음 라우터를 결정한다.\n- 패킷은 router input ports에서 목적지 주소를 확인하고, 버퍼링된다. \n- 또한 **Forwarding은 2가지 방식**이 존재한다.\n  - destination-based forwarding: 목적지 주소에 기반한 forwarding\n    - longest prefix matching: 목적 주소와 일치하는 address prefix 중 가장 긴 것과 매칭시키는 것, TCAMs를 이용한다.\n  - generalized forwarding: header fields 값에 기반한 forwarding\n\n> **TCAMs** (Ternary Content Addressable Memories)\n> : 메모리에 모두 로드한 후 매칭하는 방식\n> - Content-addressable: TCAMs에 의해 테이블 크기에 상관없이 금방 결과를 찾을 수 있게 된다.\n\n### 🪚 Switching fabrics\n패킷을 input ports에서 적절한 output port로 이동시키는 기술이다. 아래와 같은 방식들이 있다.\n\n**Switching via a memory**\n<img src=\"../../images/Network/switchingmemory.jpeg\" width=\"60%\">\n\n- 이동수단으로서 **메모리를 이용**하는 방식이다.\n- 패킷이 특정 메모리에 복사되고, 이를 특정 output port에서 읽어 이동시킨다.\n- **메모리에 load하고, access하는 시간**으로 인해 느리다는 단점이 있다.\n  - memory bandwidth만큼으로 제한된다.\n\n**Switching via a bus**\n<img src=\"../../images/Network/switchingbus.jpeg\" width=\"60%\">\n\n- 이동수단으로서 **bus**를 이용하는 방식이다.\n- **버스 사용에 대한 관리가 필요**하다.\n  - 동시에 버스를 사용하려는 경우 등\n\n**Switching via a Interconnection Network**\n<img src=\"../../images/Network/swtichinginter.jpeg\" width=\"60%\">\n\n- 그림처럼, 상호 연결된 네트워크 망을 사용한다.\n  - 망이 접하는 점은 `crossbar point` 라고 한다.\n- 철도길처럼, 패킷은 crossbar point에서 switching하면서 이동이 가능하다.\n- 하지만 **네트워크가 증가할수록, point도 증가한다**는 문제가 있다.\n\n**Switching via a multistage switch**\n<img src=\"../../images/Network/swtichingmulti.jpeg\" width=\"60%\">\n\n- Interconnection network를 사용했을때의 point가 증가하는 문제를 해결하는 방식이다.\n- 패킷(datagram)을 **고정된 길이의 셀 단위로 나누고**, 이를 fabric을 통해 전달한 다음, 목적지에서 이를 **결합하여 사용**한다.\n- multistage인 이유는, 각 switch가 n x n crossbar 구조이기 때문이다.\n\n### 🪚 Input port Queuing\nQueuing이란 버퍼에 패킷이 저장되는 것을 의미한다. 당연히 버퍼가 가득 차게 된다면 버퍼 오버플로우가 발생한다. 버퍼가 가득 차게 되면, 후에 들어오는 패킷들은 손실될 수 있다.\n\nQueuing delay는 버퍼에 패킷이 저장되면서 발생하는 대기시간을 의미한다. 오버플로우가 발생하게 된다면 Queuing delay가 발생하고, 전송 속도가 저하된다. \n\n**Head-Of-Line blocking**\n<img src=\"../../images/Network/headoflineBlocking.jpeg\" width=\"80%\">\n\n- input port의 버퍼에 패킷들이 대기하고 있다. \n- 3번째 input port의 빨간색 패킷이 1번째 output port로 가기 위해 대기하고 있다고 가정하자.\n  - 이때, 그 뒤에 있는 초록색 패킷은 빨간색 패킷과 목적지 output port가 다름에도 불구하고, 빨간색 패킷의 처리를 기다려야 한다.\n\n이를 **Head-Of-Line Blocking** 이라고 한다.\n\n### 🪚 Output port Queuing\ninput port와 마찬가지로, output port 또한 Queuing을 수행한다.\n- switching fabric에서 패킷이 전달되는 속도보다, output port에서 패킷을 내보내는 속도가 느릴 경우 Queuing을 수행하고, 버퍼 오버플로우가 발생할 수 있다.\n\n버퍼 오버플로우가 발생한다면, 저장하고 있던 패킷이 아닌 새로 들어오는 패킷은 무조건 손실될 것이다.\n- 이에 대한 처리를 위해, Drop Policy를 정의하여 버퍼 오버플로우 발생 시 어떤 패킷을 drop할 지 정해야 한다.\n  - 새로 들어오는 패킷을 drop하거나, 우선순위에 따라 drop하는 방식이 있을 수 있다.\n\n**버퍼링**과 함께 중요한 기능 중 하나로 **스케줄링**이 있다.\n- 이는 패킷들이 버퍼링되어있을 때, 어떤 패킷을 먼저 내보낼 지에 대한 정의이다.\n- 스케줄링 방식에는 아래와 같은 것들이 있다.\n\n1. FIFO 스케줄링\n: 기본적인 방식으로, 먼저 들어온 패킷을 먼저 내보낸다.\n\n2. Priority 스케줄링\n: 가장 높은 우선순위를 가진 큐에 담긴 패킷부터 먼저 내보낸다. 순위가 낮은 큐는 순위가 높은 큐가 모두 비어야 내보낼 수 있다.\n- 이는 계속 우선순위가 높은 큐가 차는 경우, 낮은 우선순위를 가지는 큐의 패킷들은 내보내지지 않는 문제가 발생할 수 있다.\n\n3. Round Robin 스케줄링\n: 다수의 큐들이 돌아가면서 각각의 패킷들을 내보낸다.\n\n4. Weighted Fair Queuing\n: RR 스케줄링과 유사하나, 각 큐마다 대기 시간이 있다는 차이가 있다. 각 큐는 돌아가면서 패킷을 내보내지만, 전송되는 시간 간격이 정해져 있다. 그리고 이는 가중치에 따라 달라진다.\n\n---\n\n## 🧷 IP: the Internet Protocol\n네트워크 계층에서 사용하는 프로토콜 중 하나이다. 네트워크 계층은 아래와 같이 구성되어 있다.\n\n<img src=\"../../images/Network/networkLayer.jpeg\" width=\"80%\">\n\n아래는 IP Datagram의 형식이다.\n\n<img src=\"http://www.cs.umd.edu/~shankar/417-F01/Slides/chapter4b-aus/img001.gif\" width=\"80%\">\n\n패킷은 IP를 거쳐 **TCP, UDP, ICMP로 전달**된다. \n- 이때, 패킷 헤더의 dest IP를 확인한 후, 본인 주소에 해당한다면 `Upper layer` 정보에 따라 해당 상위 계층으로 전달한다.\n\n또한 Header checksum이라는 정보를 확인할 수 있는데, 이는 header에 대한 checksum이지, data에 대한 checksum은 아니므로 에러가 있는 data가 전달될 수 있다.\n- 이는 TCP/UDP에서 detect한다.\n\n**MTU**\n- 16bit identifier, flags, fragment offset 필드는 fragmentation을 위해 사용된다.\n  - fragmentation: 패킷을 더 작은 단위로 나누는 것\n- 이때, fragmentation을 통해 나눈 패킷들을 식별하고 순서를 보장하기 위해 사용되는 정보이다.\n- 그리고, 나누는 기준이 되는 것이 MTU(Maximum Transmission Unit)이고, 이는 네트워크에 따라 다르다.\n  - 16bit identifier는 나누어진 패킷(fragment)들을 목적지에서 결합할 때, 같은 패킷이었는지를 식별하는 데 사용된다.\n  - flags는 나누어진 패킷들이 더 존재하는지, 혹은 더 이상 없는지를 알려준다.\n  - fragment offset은 같은 패킷이었던 fragment들의 순서를 알려준다.\n\n### 🪚 Subnet\n<img src=\"../../images/Network/subnet.jpeg\" width=\"80%\">\n\n라우터는 여러 개의 인터페이스를 가지고, 인터페이스마다 파란색으로 영역이 나누어진다.\n- 이렇게 나누어진 파란색 영역들을 Subnet이라 한다. 쉽게 말해 네트워크 내의 네트워크!\n- Subnet이 같은 호스트들은 라우터의 개입 없이 정보를 주고 받을 수 있다.\n\nIP주소는 subnet part와 host part로 나뉜다.\n- 여기서 223.1.1.1이라는 IP가 있을 때, \n  - subnet part는 223.1.1 (subnet을 식별)\n  - host part는 1 (host를 식별)\n\n> IP주소는 class단위로 부여된다.\n> - class A : 1 Network ID + 3 Host ID = $2^8$ + $3 * 2^8$\n> - class B : 2 Network ID + 2 Host ID = $2 * 2^8$ + $2 * 2^8$\n> - class C : 3 Network ID + 1 Host ID = $3 * 2^8$ + $1 * 2^8$\n\nIP대역에서는 어디까지가 Subnet part이고, host part인지 구분하기 위해 **Subnet mask**라는 것을 사용한다.\n- **Subnet mask : /24** , **223.1.1.0/24** 라고 한다면, \n  - 전체 32비트 중, 앞부분 24비트가 Subnet에 해당된다는 의미이다. \n  - 즉, 25 ~ 32 번째 비트까지 값을 쓸 수 있으며(Host로서) 256까지의 경우가 나온다. (총 256개의 호스트를 가질 수 있다.)\n\n### 🪚 CIDR\nCIDR(Classless InterDomain Routing)은, 기존의 Class 단위로 할당하여 발생하는 공간 낭비 문제를 해결한다.\n- 기존의 방식은 $2^8$, $2^{16}$, $2^{24}$ 중 하나를 선택해야 했기에, 너무 많거나 너무 적은 문제가 발생할 수 있었다.\n- CIDR 방식으로, 임의로 subnet mask를 정해 공간 낭비를 막는다.\n\n### 🪚 DHCP\n이전에는 시스템 관리자에 의해 IP 주소를 할당받았다. 하지만 사용자가 많아질수록 매우 비효율적인 방법이기에, 현재는 DHCP(Dynamic Host Configuration Protocol) 방식을 사용해 동적으로 IP 주소를 할당받는다.\n- 서버의 address pool로부터 IP 주소를 받아온다.\n\n**DHCP client-server**\n<img src=\"../../images/Network/DHCP.jpeg\" width=\"80%\">\n\n1. DHCP discover : 클라이언트는 Subnet에 도착하면, 브로드캐스트 방식으로 DHCP 서버가 있는지 확인한다.\n2. DHCP offer : DHCP 서버가 클라이언트에게 사용할 수 있는 IP를 제공한다.\n3. DHCP request : 클라이언트가 서버에게 해당 IP주소를 사용하겠다고 알린다.\n4. DHCP ACK : DHCP 서버가 알겠다는 확인 메세지를 보낸다.\n\nDHCP ACK에는 IP 주소뿐만 아니라 다른 정보(first hop of router, DNS server의 이름과 IP 주소 등)도 보낼 수 있다.\n\n> 통신 간에는 모두 255.255.255.255로 브로드캐스트 방식을 사용한다.\n\n### 🪚 NAT(Network Address Translation)\n<img src=\"../../images/Network/NAT.jpeg\" width=\"80%\">\n\n모든 IP 주소는 고유해야 식별이 가능하다. 하지만 모든 컴퓨터에 고유한 IP 주소를 할당하는 것은 부족하기에, `private IP` 를 사용한다.\n- 그래서 위 그림에서 볼 수 있듯, 외부로 나갈 때는 `global` 한 IP 주소를 사용하고, 내부에서는 `private` 한 IP 주소를 사용한다.\n- 그리고 이를 가능하게 하는 것이 NAT이다.\n\n**NAT 동작 방식**\n<img src=\"../../images/Network/NAT동작방식.jpeg\" width=\"80%\">\n\n1. Host(10.0.0.1)는 현재 128.119.40.186, 80으로 패킷을 보내려 한다. 이때, host IP에 임의의 포트 번호(3345)를 지정하여 NAT로 전달한다.\n2. NAT는 NAT Table을 이용해 10.0.0.1, 3345를 138.76.29.7, 5001로 변경하여 패킷을 목적지로 전송한다.\n3. 패킷을 받은 서버(128.119.40.186, 80)는 다시 138.76.29.7, 5001로 패킷을 전송한다.\n4. 패킷을 받은 NAT 라우터는 NAT Table에 기록된 LAN side addr를 보고 해당 주소로 패킷을 전송한다.\n\n**Issues**\n- router는 3계층까지만 다뤄야 한다.\n- 주소 부족 문제\n- end-to-end 방식을 해친다. (Port #은 네트워크 계층 디바이스에서 관리한다.)\n- NAT traversal: 클라이언트가 NAT 안의 서버에 요청하는 경우, NAT 내부는 외부에서 알 수가 없다.\n\n### 🪚 IPv4 vs IPv6\n지금까지 설명한 IP는 IPv4였다. 이는 32비트 IP 주소 체계를 가지고 사용자에게 제공한다. 하지만 사용자가 증가하면서 주소 부족 문제가 발생했고, private IP를 부여함으로써 해결된 줄 알았지만, 여전히 IP가 부족한 문제가 발생하고 있다.\n\n따라서, IPv4가 아닌 IPv6가 탄생했다. 이는 IP address(32bits)의 4배인 128bits 주소를 가진다.\n- processing과 forwarding의 속도가 증가했다.\n- `flow` 라는 것을 이용한다.\n\n**IPv6 datagram format**\n<img src=\"../../images/Network/IPv6format.jpeg\" width=\"80%\">\n\n- header의 크기가 40byte로 고정\n- flow label : datagram이 같은 flow에 있는지 식별해주는 정보\n- next hdr : 추가적인 헤더 정보, options field 제거\n- header checksum의 부재 : 라우터에서의 processing 속도 향상을 위해 제거했다.\n  - IPv4에서는 라우터간 이동 시 TTL값이 계속 변하기에 라우터에서 header checksum을 계속 계산해야 했기에 processing 속도에 영향을 주었다.\n  - 하지만 link의 향상으로, bit error rate이 매우 감소했기에, checksum이 필요없어졌다. (그리고 어차피 end point에서 error check을 수행한다!)\n\n이렇게 효율적인 IPv6를 만들었다고 해도, 한 번에 모두 변경시키는 것은 불가능하다. 따라서 `Tunneling` 이라는 기법이 만들었다.\n\n**Tunneling**\n<img src=\"../../images/Network/tunneling.jpeg\" width=\"80%\">\n\n- IPv6 datagram을 IPv4 datagram의 payload로 사용하는 것이다. \n\n**Tunneling & encapsulation**\n<img src=\"../../images/Network/tunnel&encap.jpeg\" width=\"80%\">\n\n- A - F를 연결하는데, 기존 IPv4 망을 사용한다.\n- 이를 위해서는 중간에 있는 라우터가 IPv6와 IPv4 프로토콜 모두를 다룰 수 있어야 한다.\n  - 그리고 이 사이의 네트워크 망에서는 Tunneling이 수행된다.\n- A로부터 받은 IPv6 패킷을 B에서 encapsulation 과정을 거쳐 IPv4 패킷으로 만든다.\n- IPv4 Network 망을 거쳐 E로 전달된 IPv4 패킷은 decapsulation 과정을 거쳐 IPv6 패킷으로 만들어져 F로 전달된다.\n\n--- \n\n## 🧷 SDN\nSDN 방식은 이전에도 언급했듯 Control plane의 remote controller에서 flow table(routing table)을 만들고, 라우터들에게 이를 전달해주어 라우팅에 사용하도록 하는 방식이다.\n\nflow table을 생성할 때, 다음과 같은 사항들을 고려하여 생성한다.\n1. pattern: header fields의 패턴과 받은 패턴을 매칭시킨다.\n2. action: 받은 패턴에 따라 drop, forward, modify 등의 동작을 수행한다.\n3. priority: 패턴이 여러 개라면 우선순위가 높은 순으로 처리한다.\n4. counters: 지금까지 받은 패킷의 바이트 수는 몇 개인지 기록한다.\n\nex)\n- src = 1.2.\\*.\\*, dest = 3.4.5.\\* -> drop\n- src = \\*.\\*.\\*.\\* , dest = 3.4.\\*.\\* -> forward(2)\n- src = 10.1.2.3, dest = \\*.\\*.\\*.\\* -> send to controller\n\n이렇게 각 라우터들은 들어온 IP 주소 패턴에 대해 어떤 동작을 수행할지에 대한 flow table을 가지고 있고, 이 동작들을 정의함에 따라 **하나의 SDN 라우터는 Router, Switch, Firewall, NAT와 같은 역할을 수행**할 수 있게 된다.\n\n---\n\n## 🧷 Control Plane\nrouting table을 생성하는 방식에 따라 control plane의 역할이 달라진다.\n\n**Per-router control plane 방식에서의 역할**\n- 현재 사용되는 방식으로 라우터들끼리 상호작용해서 forwarding table을 생성한다.\n\n**SDN(Software Defined Networking)에서의 역할**\n- control plane의 Remote controller와 라우터의 control agent가 상호작욤함으로써 적합한 forwarding table을 생성하고, 이를 data plane으로 전달한다.\n\n### 🪚 Routing protocols\nrouting protocol의 목표는 호스트로부터 다른 호스트까지 최적의 경로를 정하는 것이다.\n- 최적의 경로는 최소의 비용을 고려해 가장 빠르게 목적지까지 도달하는 경로\n- 그리고 이 경로를 찾기위해 2가지 알고리즘 방식이 사용된다.\n- 각 도메인마다(intra-AS) 내부적으로 사용하는 알고리즘 방식(LS or DV)은 달라도 되지만, 도메인간(inter-AS) 사용하는 알고리즘 방식(LS or DV)은 같아야 한다. \n\n**Link State**\n- 모든 라우터들이 다른 link 비용에 대한 정보를 모두 알고 있는 경우이다.\n- global한 정보를 알고 알고리즘을 짜기에, 모든 라우터들이 동일한 RT를 가지게 된다.\n- 다익스트라 알고리즘을 사용하기에 Table의 값이 바뀔 수 있다.\n  - link costs가 네트워크 트래픽 양에 의존한다면, 트래픽 양이 변함에 따라 RT가 변경될 수 있다.\n- 자신의 link 정보를 흘려보낸다. 이를 수신한 다른 모든 라우터들이 link 정보를 저장한다.\n\n**Distance Vector**\n- Link state와 반대로, 전체적인 정보를 모르는 상태에서 시작한다. 물리적으로 연결된 이웃에 대해서만 알고 있다.\n- 반복적인 연산을 통해 정보를 얻게 되며, 전체적인 정보는 벨만 포드 알고리즘을 사용하여 구한다.\n- 주변의 RT를 가지고 새로운 RT를 생성하고, 이를 주변 라우터들에게 전달하여 반복한다.\n\n**Link cost의 변동**\n1. 노드가 로컬 link cost의 변동을 감지한다.\n2. 라우팅 정보를 업데이트하고 local Distance Vector를 다시 계산한다.\n3. DV에 변동이 생기면 이를 이웃들에게 알린다.\n\nlink costs가 감소하면, 라우터 간 이동이 빨리지는 장점이 있지만, link costs가 증가하면, 이동이 느려지게 되고, count-to-infinity 문제가 발생한다.\n\n### 🪚 Count-to-Infinity\n네트워크에 변화가 생겼을 때 모든 RT를 네트워크에 맞게 갱신하는데 오래 걸리는 문제\n- 각 라우터들이 어떤 목적지까지 가는 길에 대해, 다음 라우터는 알지만 그 다음을 알지 못해 그 사이에 사이클이 발생하는 경우 문제가 된다.\n- hop count에 도달해서야 더 이상 갈 수 없음을 판단하게 되버리는 경우가 발생한다.\n\n**Count-to-Infinity의 해결책**\n1. Poisoned reverse\n갈 수 없는 라우터에 대해서 비용을 무한대로 표시하여 다른 라우터로 전달한다.\n\n2. Split horizon\n갈 수 없는 라우터에 대해서 아예 RT에서 제외시킨 후 전달한다.\n\n3. Triggered update\n경로가 끊어짐을 감지하자마자 이를 바로 전달한다.\n\n### 🪚 OSPF(Open Shortest Path First)\n- intra AS routing protocol로, AS 내 모든 정보를 교환한다.\n- link state 방식을 사용한다.\n\n계층적인 OSPF는 다음과 같다.\n<img src=\"../../images/Network/ospf.jpeg\" width=\"80%\">\n\n- 크게 local area와 backbone으로 이뤄지고, link state는 local area에서만 사용된다.\n- local area와 backbone을 연결하고 있는 area border routers는 자신의 local area의 distance 정보를 요약해서 주위 라우터에게 전달한다.\n- backbone router는 자기들끼리의 라우팅을 위해 OSPF를 사용한다.\n- 이후 다른 AS와 라우팅을 위해 backbone 끝에 있는 boundary router를 사용한다.\n\n### 🪚 BGP(Border Gateway Protocol)\n- ISP 간 라우팅을 하는 프로토콜이다.\n- 외부 AS의 라우터와도 정보를 공유할 수 있다.\n- eBGP: 주위의 다른 AS로부터 정보를 얻을 때 사용하는 프로토콜\n- iBGP: AS 내부의 라우터들에게 정보를 알려줄 때 사용하는 프로토콜\n\n### 🪚 Hot Potato Routing\n<img src=\"../../images/Network/hotpotato.jpeg\" width=\"80%\">\n\n- 2d에서 x까지 가야하는 상황이 있다.\n- 이때 2d는 2amㄹㄹ 선택해서 갈 수도 있고, 2c를 선택해서 갈 수도 있다.\n- 이 경우, hot potato routing protocol이 사용되며, **원하는 목적지까지 가기 위해 최소 비용을 가지는 경로를 선택**한다.\n\n---\n\n## 🧷 The SDN Control Plane\n기존에 사용한 방식은 각각의 라우터에 접근해 테이블을 생성하는 방식으로 네트워크 관리에 어려움이 있었다.\n\n하지만 SDN 방식의 도입으로 logically centralized하여 네트워크 관리를 쉽게 한다.\n- 이때 table-based forwarding(open flow api)을 이용해 table 프로그래밍을 쉽게 할 수 있다.\n- 또한 Traffic engineering(정해진 경로가 아닌 원하는 경로 사용), load balancing도 가능하게 되었다.\n- 이를 통해 Data Plane은 전달받은 RT를 보고 시키는 대로 동작만 하면 된다.\n\n### 🪚 OpenFlow Protocol\ncontroller와 switch 사이에서 동작하는 프로토콜로, TCP를 이용하여 메세지를 주고 받는다.\n\n주고 받는 메세지는 다음과 같은 종류가 있다.\n1. controller-to-switch messages\n\n- features: 스위치의 상태 조회\n- configure: 스위치의 configuration 세팅에 대해 알아내는 메세지\n- modify-state: OpenFlow Table의 entry를 추가, 삭제, 수정하는 과정\n- packet-out: 패킷을 스위치로 보냄\n\n2. switch-to-controller messages\n\n- packet-in: 패킷을 컨트롤러로 보냄\n- flow-removed: Flow Table에서 지워진 entry를 알림\n- port statue: 연결이 잘 되어 있는지 컨트롤러에게 변화를 알림\n\n---\n\n## 🧷 ICMP\nInternet Control Message Protocol의 약자로, 호스트와 라우터들이 정보를 주고 받을 때 사용하는 프로토콜이다.\n\n아래와 같은 Type과 Code 정보에 따라 사용되는 ICMP 유형이 결정된다.\n<img src=\"../../images/Network/icmp.jpeg\" width=\"80%\">\n\n- 대표적으로, 서버가 살아있는지 판단할 때 사용하는 ping이 있다.\n\n### 🪚 Traceroute\n자신의 시스템으로부터 목적지까지 경유하는 시스템의 정보와 round trip time을 확인하는 Traceroute 또한 ICMP를 사용한다.\n1. source 지점부터 destination지점까지 UDP segment를 전송한다. 이때 TTL을 통해 RTT를 측정한다.\n2. 첫번째 set에서는 TTL = 1인 패킷을 세 번 보내 RTT의 평균을 측정한다.\n3. 다음 set에서는 TTL = 2인 경우를 세 번 보내고, destination에 도착할 때까지 이를 반복한다.\n4. 패킷이 destination에 도착했을 때 수신자는 ICMP 메세지를 반환하지 않기에 송신자는 수신자가 수용할 수 없게 port unreachable를 세팅해서 전송한다.\n5. destination은 port #을 수용하지 못하고, ICMP 메세지를 송신자에게 보낸다.\n\n---\n\n## 🧷 SNMP\nSimple Network Management Protocol의 약자로, 네트워크 장치 간의 구성 및 정보 교환에 사용되는 프로토콜이다. \n- 스위치, 허브, 라우터, 프린터, 서버와 같은 네트워크 장치 구성 시 사용한다.\n- UDP 기반 프로토콜이다.\n\n---\n\n## 📕 참고\n- [Network layer 개요](https://ddongwon.tistory.com/88)\n- [네트워크: Network Layer 정리2(IPv4, DHCP, NAT, SDN...)](https://seungjuitmemo.tistory.com/97)\n- [네트워크: Network layer 정리3(routing algorithm, link state, distance vector)](https://seungjuitmemo.tistory.com/98?category=925884)"},{"excerpt":"문제 Programmers - 순위 검색 📍 Logic -를 붙이면서 가능한 정보를 만드는 함수 DFS 방식으로 기존의 정보를 사용하거나, -를 붙이거나 하여 생성한다. 📄 CODE ✏️ Review -가 포함된 경우를 위해 가능한 모든 정보를 만들어두고 이를 사용하는 아이디어를 사용했다. 이진 탐색을 사용해 빠르게 인원을 구하는 아이디어가 주요했던 것 같…","fields":{"slug":"/[Programmers]72412/"},"frontmatter":{"date":"July 01, 2022","title":"👩‍💻 72412. 순위 검색","tags":["DFS"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 순위 검색](https://programmers.co.kr/learn/courses/30/lessons/72412)\n\n### 📍 **Logic**\n\n```java\n// -를 붙이면서 가능한 조합을 생성하여 map에 추가한다.\nprivate static void makeComb(int length) {\n    if (length == 4) {\n        String key = String.join(\"\", combStr);\n        scoreMap.putIfAbsent(key, new ArrayList<>());\n        scoreMap.get(key).add(infoScore);\n    } else {\n        // -가 아닌 경우와 -인 경우로 나눠 가능한 조합 생성\n        combStr[length] = infoLine[length];\n        makeComb(length + 1);\n        combStr[length] = \"-\";\n        makeComb(length + 1);\n    }\n}\n```\n- -를 붙이면서 가능한 정보를 만드는 함수\n- DFS 방식으로 기존의 정보를 사용하거나, -를 붙이거나 하여 생성한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        \n        // 언어, 직군, 경력, 소울푸드를 key로 가지고, 점수 리스트를 값으로 가지는 map 선언\n        static Map<String, ArrayList<Integer>> scoreMap = new HashMap<>();\n\n        // 조합 생성을 위해 사용할 배열, 코테 점수, 지원자의 정보 배열\n        static String[] combStr;\n        static int infoScore;\n        static String[] infoLine;\n        \n        public int[] solution(String[] info, String[] query) {\n            int[] answer = new int[query.length];\n\n            // 주어진 info 배열을 가지고 scoreMap 초기화\n            // -를 포함한 모든 조합을 생성하여 map의 key로 추가\n            initScoreMap(info);\n\n            // 이진탐색을 위해 점수 리스트를 오름차순으로 정렬\n            for (String key : scoreMap.keySet())\n                Collections.sort(scoreMap.get(key));\n\n            for (int i = 0; i < query.length; i++) {\n                String[] line = query[i].split(\" and | \");\n                StringBuilder sb = new StringBuilder(line[0] + line[1] + line[2] + line[3]);\n                String key = sb.toString();\n                int score = Integer.parseInt(line[4]);\n\n                if (scoreMap.containsKey(key)) {\n                    ArrayList<Integer> list = scoreMap.get(key);\n                    answer[i] = list.size() - findLower(list, score);\n                }\n            }\n            \n            return answer;\n        }\n        \n        private static void initScoreMap(String[] info) {\n            for (String i : info) {\n                combStr = new String[4];\n                infoLine = i.split(\" \");\n                infoScore = Integer.parseInt(infoLine[4]);\n                makeComb(0);\n            }\n        }\n\n        // -를 붙이면서 가능한 조합을 생성하여 map에 추가한다.\n        private static void makeComb(int length) {\n            if (length == 4) {\n                String key = String.join(\"\", combStr);\n                scoreMap.putIfAbsent(key, new ArrayList<>());\n                scoreMap.get(key).add(infoScore);\n            } else {\n                // -가 아닌 경우와 -인 경우로 나눠 가능한 조합 생성\n                combStr[length] = infoLine[length];\n                makeComb(length + 1);\n                combStr[length] = \"-\";\n                makeComb(length + 1);\n            }\n        }\n\n        private static int findLower(ArrayList<Integer> list, int value) {\n            int left = 0;\n            int right = list.size() - 1;\n\n            while (left <= right) {\n                int mid = (left + right) / 2;\n                int v = list.get(mid);\n\n                if (v < value) left = mid + 1;\n                else right = mid - 1;\n            }\n\n            return left;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- -가 포함된 경우를 위해 가능한 모든 정보를 만들어두고 이를 사용하는 아이디어를 사용했다.\n- 이진 탐색을 사용해 빠르게 인원을 구하는 아이디어가 주요했던 것 같다."},{"excerpt":"문제 Programmers - 신규 아이디 추천 📍 Logic 메소드화하여 역할을 분리했다. 📄 CODE ✏️ Review 매우 쉬운 문제였다!","fields":{"slug":"/[Programmers]72410/"},"frontmatter":{"date":"June 29, 2022","title":"👩‍💻 72410. 신규 아이디 추천","tags":["문자열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 신규 아이디 추천](https://programmers.co.kr/learn/courses/30/lessons/72410)\n\n### 📍 **Logic**\n\n```java\nprivate static String replaceStart(String newId, int idx) {\n    if (newId.charAt(idx) == '.') return newId.substring(idx + 1);\n    return newId;\n}\n\nprivate static String replaceEnd(String newId, int idx) {\n    if (idx < 0) return newId;\n    if (newId.charAt(idx) == '.') return newId.substring(0, idx);\n    return newId;\n}\n```\n- 메소드화하여 역할을 분리했다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\tclass Solution {\n        public String solution(String new_id) {\n            StringBuilder newId = new StringBuilder(new_id);\n\n            // 1단계\n            newId = new StringBuilder(newId.toString().toLowerCase());\n\n            // newId\n            newId = new StringBuilder(newId.toString().replaceAll(\"[^a-z0-9-_.]\", \"\"));\n\n            // 3단계\n            newId = new StringBuilder(newId.toString().replaceAll(\"[.]+\", \".\"));\n\n            // 4단계\n            newId = new StringBuilder(replaceStart(newId.toString(), 0));\n            newId = new StringBuilder(replaceEnd(newId.toString(), newId.length() - 1));\n\n            // 5단계\n            if (\"\".equals(newId.toString())) newId = new StringBuilder(\"a\");\n\n            // 6단계\n            if (newId.length() > 15) {\n                newId = new StringBuilder(newId.substring(0, 15));\n                newId = new StringBuilder(replaceEnd(newId.toString(), newId.length() - 1));\n            }\n\n            // 7단계\n            String str = String.valueOf(newId.charAt(newId.length() - 1));\n            while(newId.length() < 3)\n                newId.append(str);\n            \n            return newId.toString();\n        }\n        \n        private static String replaceStart(String newId, int idx) {\n            if (newId.charAt(idx) == '.') return newId.substring(idx + 1);\n            return newId;\n        }\n\n        private static String replaceEnd(String newId, int idx) {\n            if (idx < 0) return newId;\n            if (newId.charAt(idx) == '.') return newId.substring(0, idx);\n            return newId;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 매우 쉬운 문제였다!\n"},{"excerpt":"문제 Programmers - 메뉴 리뉴얼 📍 Logic 메뉴 구성 길이별 최대 빈도수를 저장하는  을 최신화하는 과정 📄 CODE ✏️ Review 가능한 모든 조합을 구하는 것이 가장 관건이었다. 이후 구현은 정렬을 잘 활용하면 되는 문제였다. 처음에는 조합을 만들고, 각 코스 요리별 메뉴 수의 최대 빈도를 구하고, 그 빈도를 가지는 메뉴 구성을 출력하…","fields":{"slug":"/[Programmers]72411/"},"frontmatter":{"date":"June 29, 2022","title":"👩‍💻 72411. 메뉴 리뉴얼","tags":["조합","정렬"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 메뉴 리뉴얼](https://programmers.co.kr/learn/courses/30/lessons/72411)\n\n### 📍 **Logic**\n\n```java\n// map에 해당 조합이 있다면, count는 그 조합의 빈도 수, 그렇지 않다면 0\nint count = 0;\nif (menuComb.containsKey(str))\n    count = menuComb.get(str);\n\n// 현재 해당 조합을 추가할 것이므로 count를 증가\ncount++;\n// 해당 조합이 이미 있었고, 해당 조합(메뉴 구성)이 속한 코스 중 최대 빈도보다 빈도가 크다면 최신화\nif (count != 1 && courseMaxCount.get(str.length()) < count)\n    courseMaxCount.put(str.length(), count);\n\nmenuComb.put(str, count);\n```\n- 메뉴 구성 길이별 최대 빈도수를 저장하는 `map` 을 최신화하는 과정\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        // 모든 메뉴 조합을 저장\n        static Map<String, Integer> menuComb = new HashMap<>();\n        // 각 course별 최대 메뉴 수를 저장\n        static Map<Integer, Integer> courseMaxCount = new HashMap<>();\n        // 최소 코스 요리 수 = course[0]\n        static int minCombCount;\n        \n        public String[] solution(String[] orders, int[] course) {\n            // 각 코스별 요리 수에 대한 최댓값을 저장할 map 초기화\n            for (int c : course) courseMaxCount.put(c, 0);\n            minCombCount = course[0];\n\n            // 가능한 모든 조합을 생성해서 menuComb에 추가\n            for (String order : orders) {\n                boolean[] visited = new boolean[order.length()];\n                for (int c : course)\n                    if (order.length() >= c)\n                        makeComb(order, visited, 0, order.length(), c);\n            }\n\n            ArrayList<String> answer = new ArrayList<>();\n            for (Map.Entry<Integer, Integer> entry : courseMaxCount.entrySet())\n                // 최대 빈도를 가지는 메뉴 result에 추가\n                for (Map.Entry<String, Integer> menu : menuComb.entrySet())\n                    if (entry.getKey() == menu.getKey().length() && entry.getValue() == menu.getValue())\n                        answer.add(menu.getKey());\n            \n            Collections.sort(answer);\n            \n            return answer.toArray(String[]::new);\n        }\n        \n        private static void makeComb(String order, boolean[] visited, int start, int n, int r) {\n            // 주어진 요리 수만큼의 조합이 만들어진 경우, map에 추가\n            if (r == 0) {\n                put(order, visited, n);\n                return;\n            }\n\n            for (int i = start; i < n; i++) {\n                visited[i] = true;\n                makeComb(order, visited, i + 1, n, r - 1);\n                visited[i] = false;\n            }\n        }\n\n        private static void put(String order, boolean[] visited, int n) {\n            // Map에 넣을 메뉴 조합 생성\n            StringBuilder sb = new StringBuilder();\n            for (int i = 0; i < order.length(); i++)\n                if (visited[i]) sb.append(order.charAt(i));\n\n            // 최소 코스 요리 수보다 작은 경우는 패스\n            if (sb.length() < minCombCount) return;\n\n            // 메뉴 조합 사전순 정렬, AB와 BA는 같은 메뉴 조합이므로\n            char[] chars = sb.toString().toCharArray();\n            Arrays.sort(chars);\n            String str = new String(chars);\n\n            // map에 해당 조합이 있다면, count는 그 조합의 빈도 수, 그렇지 않다면 0\n            int count = 0;\n            if (menuComb.containsKey(str))\n                count = menuComb.get(str);\n\n            // 현재 해당 조합을 추가할 것이므로 count를 증가\n            count++;\n            // 해당 조합이 이미 있었고, 해당 조합(메뉴 구성)이 속한 코스 중 최대 빈도보다 빈도가 크다면 최신화\n            if (count != 1 && courseMaxCount.get(str.length()) < count)\n                courseMaxCount.put(str.length(), count);\n            \n            menuComb.put(str, count);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 가능한 모든 조합을 구하는 것이 가장 관건이었다. 이후 구현은 정렬을 잘 활용하면 되는 문제였다.\n- 처음에는 조합을 만들고, 각 코스 요리별 메뉴 수의 최대 빈도를 구하고, 그 빈도를 가지는 메뉴 구성을 출력하도록 했다가, 조합을 만들고 `map` 에 추가할 때, 메뉴 구성 길이별 최대 빈도를 저장하는 `map` 을 두어 이를 사용하도록 변경해보았다."},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 프로젝트 생성 start.io 사용 🎯 비즈니스 요구사항과 설계 🪔 회원 회원을 가입하고 조회할 수 있다. 회원은 일반과 VIP 두 가지 등급이 있다. 회원 데이터는 자체 DB를 구축할 수 있고, 외부 시스템과 연동할 수 있다. (미확정) 🪔 주문과 할인 정책 회원은 상품을 주문할 수 있다…","fields":{"slug":"/[스프링핵심원리_기본편]2.스프링핵심원리이해1-예제만들기/"},"frontmatter":{"date":"June 29, 2022","title":"📟 2. 스프링 핵심 원리 이해 1 - 예제 만들기","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 프로젝트 생성\n[start.io](https://start.spring.io/) 사용\n\n<img src=\"../../images/스프링핵심원리-기본편/springSetting.png\">\n\n---\n\n## 🎯 비즈니스 요구사항과 설계\n### 🪔 회원\n- 회원을 가입하고 조회할 수 있다.\n- 회원은 일반과 VIP 두 가지 등급이 있다.\n- 회원 데이터는 자체 DB를 구축할 수 있고, 외부 시스템과 연동할 수 있다. (미확정)\n\n### 🪔 주문과 할인 정책\n- 회원은 상품을 주문할 수 있다.\n- 회원 등급에 따라 할인 정책을 적용할 수 있다.\n- 할인 정책은 모든 VIP는 1000원을 할인해주는 고정 금액 할인을 적용해달라. (나중에 변경 될 수 있다.)\n- 할인 정책은 변경 가능성이 높다. 회사의 기본 할인 정책을 아직 정하지 못했고, 오픈 직전까지 고민을 미루고 싶다. 최악의 경우 할인을 적용하지 않을 수 도 있다. (미확정)\n\n> 현재는 스프링 없이 순수 자바로만 개발을 진행한다. 프로젝트 환경설정을 위해 start.io를 사용했다.\n\n---\n\n## 🎯 회원 도메인 설계\n### 🪔 회원 도메인 협력 관계\n<img src=\"../../images/스프링핵심원리-기본편/회원도메인협력관계.png\" width=\"80%\">\n\n- 회원 서비스에서는 회원 가입과 회원 조회 기능이 있다.\n- 회원 데이터에 접근하는 계층을 따로 생성한다.\n  - 회원 저장소라는 인터페이스를 생성해 미확정된 구현체에 대해 맞출 수 있다.\n\n### 🪔 회원 클래스 다이어그램 (정적)\n<img src=\"../../images/스프링핵심원리-기본편/회원클래스다이어그램.png\" width=\"80%\">\n\n- `MemberService` 라는 인터페이스를 만들고 이에 대한 구현체인 `MemberServiceImpl` 클래스를 생성한다.\n  - 이 역할은 `MemberRepository` 에 접근하는 로직을 수행한다.\n\n### 🪔 회원 객체 다이어그램 (동적)\n<img src=\"../../images/스프링핵심원리-기본편/회원객체다이어그램.png\" width=\"80%\">\n\n- 객체간 참조 관계를 표현하고 있다.\n- 클래스가 실제 사용하는 인스턴스끼리의 참조 관계이다.\n\n---\n\n## 🎯 회원 도메인 개발\n### 🪔 회원 엔티티\n회원 엔티티 개발을 위해 `member` 라는 패키지를 생성한다.\n\n**회원 등급**\n회원 등급 정보를 관리할 `Grade` 클래스를 만드는데, 이는 `Enum` 클래스로 생성한다.\n\n```java\npackage hello.core.member;\n\npublic enum Grade {\n    BASIC,\n    VIP\n}\n```\n\n- 회원 등급은 일반과, VIP가 있다.\n\n**회원 엔티티**\n회원 엔티티 클래스를 생성한다.\n\n```java\npackage hello.core.member;\n\npublic class Member {\n    private long id;\n    private String name;\n    private Grade grade;\n\n    public Member(long id, String name, Grade grade) {\n        this.id = id;\n        this.name = name;\n        this.grade = grade;\n    }\n\n    public long getId() {\n        return id;\n    }\n\n    public String getName() {\n        return name;\n    }\n\n    public Grade getGrade() {\n        return grade;\n    }\n\n    public void setId(long id) {\n        this.id = id;\n    }\n\n    public void setName(String name) {\n        this.name = name;\n    }\n\n    public void setGrade(Grade grade) {\n        this.grade = grade;\n    }\n}\n```\n\n- 생성자와 Getter & Setter를 생성한다.\n\n### 🪔 회원 저장소\n회원 저장소를 담당할 인터페이스와 구현 클래스를 생성한다.\n- 아직 데이터베이스가 확정되지 않아 우선 메모리 회원 저장소를 사용한다.\n\n**회원 저장소 인터페이스**\n\n```java\npackage hello.core.member;\n\npublic interface MemberRepository {\n\n    void save(Member member);\n\n    Member findById(Long memberId);\n}\n```\n\n**메모리 회원 저장소 구현체**\n\n```java\npackage hello.core.member;\n\nimport java.util.HashMap;\nimport java.util.Map;\nimport java.util.concurrent.ConcurrentHashMap;\n\npublic class MemoryMemberRepository implements MemberRepository {\n\n    private static Map<Long, Member> store = new ConcurrentHashMap<>();\n\n    @Override\n    public void save(Member member) {\n        store.put(member.getId(), member);\n    }\n\n    @Override\n    public Member findById(Long memberId) {\n        return store.get(memberId);\n    }\n}\n```\n\n- `HashMap` 은 동시성 이슈가 발생할 수 있어, `ConcurrentHashMap` 을 사용해야 한다.\n\n### 🪔 회원 서비스\n이제 회원 가입과 회원 조회 기능을 구현할 회원 서비스를 생성한다.\n- 회원 서비스 인터페이스와 이를 구현할 회원 서비스 구현체를 생성한다.\n\n**회원 서비스 인터페이스**\n\n```java\npackage hello.core.member;\n\npublic interface MemberService {\n    \n    void join(Member member);\n    \n    Member findMember(Long memberId);\n}\n```\n\n**회원 서비스 구현체**\n\n```java\npackage hello.core.member;\n\npublic class MemberServiceImpl implements MemberService {\n    \n    private final MemberRepository memberRepository = new MemoryMemberRepository();\n    \n    @Override\n    public void join(Member member) {\n        memberRepository.save(member);\n    }\n\n    @Override\n    public Member findMember(Long memberId) {\n        return memberRepository.findById(memberId);\n    }\n}\n```\n\n- 위에서 생성한 메모리 회원 저장소에 접근해 회원 가입 및 조회가 가능하기에 `MemberRepository` 인터페이스가 필요하다.\n- 그리고 이에 대한 구현체는 `MemoryMemberRepository` 가 담당하고 있다.\n\n---\n\n## 🎯 회원 도메인 실행과 테스트\n### 🪔 회원 도메인 - 회원 가입 main\n회원 가입 기능의 확인을 위해 `MemberApp` 클래스를 생성한다.\n\n```java\npackage hello.core;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\n\npublic class MemberApp {\n    public static void main(String[] args) {\n        MemberService memberService = new MemberServiceImpl();\n\n        Member member = new Member(1L, \"memberA\", Grade.VIP);\n        memberService.join(member);\n\n        Member findMember = memberService.findMember(1L);\n        System.out.println(\"new Member = \" + member.getName());\n        System.out.println(\"findMember = \" + findMember.getName());\n    }\n}\n```\n\n- 실행 결과는 동일한 `Member` 의 이름이 나올 것이다.\n\n### 🪔 회원 도메인 - 회원 가입 test\n기능에 대한 테스트를 위와 같은 방식으로 하는 것은 비효율적이고, 이를 위해 **JUnit**이라는 테스트 프레임워크를 사용한다.\n\n```java\npackage hello.core.member;\n\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\n\npublic class MemberServiceTest {\n\n    MemberService memberService = new MemberServiceImpl();\n\n    @Test\n    void join() {\n        // given\n        Member member = new Member(1L, \"memberA\", Grade.VIP);\n\n        // when\n        memberService.join(member);\n        Member findMember = memberService.findMember(1L);\n\n        // then\n        Assertions.assertThat(member).isEqualTo(findMember);\n    }\n}\n```\n\n### 🪔 회원 도메인 설계의 문제점\n- 다른 저장소로 변경 시 OCP 원칙을 잘 준수하는가?\n- DIP를 잘 지키고 있는가?\n- 의존관계가 인터페이스 뿐만 아니라 구현까지 모두 의존하는 문제점이 있다.\n  - `MemberServiceImpl.class` 에서 `private final MemberRepository memberRepository = new MemoryMemberRepository();`\n  - 주문까지 만들고나서 문제점과 해결 방안을 설명\n\n---\n\n## 🎯 주문과 할인 도메인 설계\n### 🪔 주문과 할인 정책\n- 회원은 상품을 주문할 수 있다.\n- 회원 등급에 따라 할인 정책을 적용할 수 있다.\n- 할인 정책은 모든 VIP는 1000원을 할인해주는 고정 금액 할인을 적용해달라. (나중에 변경 될 수 있다.)\n- 할인 정책은 변경 가능성이 높다. 회사의 기본 할인 정책을 아직 정하지 못했고, 오픈 직전까지 고민을 미루고 싶다. 최악의 경우 할인을 적용하지 않을 수 도 있다. (미확정)\n\n**주문 도메인 협력, 역할, 책임**\n<img src=\"../../images/스프링핵심원리-기본편/주문도메인협력역할책임.png\" width=\"80%\">\n\n1. **주문 생성**: 클라이언트는 주문 서비스에 주문 생성을 요청한다.\n2. **회원 조회**: 할인을 위해서는 회원 등급이 필요하다. 그래서 주문 서비스는 회원 저장소에서 회원을 조회한다.\n3. **할인 적용**: 주문 서비스는 회원 등급에 따른 할인 여부를 할인 정책에 위임한다.\n4. **주문 결과 반환**: 주문 서비스는 할인 결과를 포함한 주문 결과를 반환한다.\n\n**주문 도메인 전체**\n<img src=\"../../images/스프링핵심원리-기본편/주문도메인전체.png\" width=\"80%\">\n\n- **역할과 구현을 분리**하여 구현 객체를 자유롭게 조립할 수 있도록 했다.\n  - 회원 저장소와 할인 정책의 유연한 변경이 가능하다.\n\n**주문 도메인 클래스 다이어그램**\n<img src=\"../images/../../images/스프링핵심원리-기본편/주문도메인클래스다이어그램.png\" width=\"80%\">\n\n**주문 도메인 객체 다이어그램 1**\n<img src=\"../images/../../images/스프링핵심원리-기본편/주문도메인객체다이어그램1.png\" width=\"80%\">\n\n- 회원을 **메모리에서 조회**하고, **정액 할인 정책(고정 금액)**을 지원해도 주문 서비스를 변경하지 않아도 된다. \n- **역할들의 협력 관계를 그대로 재사용**할 수 있다.\n\n**주문 도메인 객체 다이어그램 2**\n<img src=\"../images/../../images/스프링핵심원리-기본편/주문도메인객체다이어그램2.png\" width=\"80%\">\n\n- 회원을 메모리가 아닌 **실제 DB에서 조회**하고, **정률 할인 정책(주문 금액에 따라 % 할인)**을 지원해도 주문 서비스를 변경하지 않아도 된다.\n- **협력 관계를 그대로 재사용**할 수 있다.\n\n---\n\n## 🎯 주문과 할인 도메인 개발\n### 🪔 할인 정책 인터페이스\n```java\npackage hello.core.discount;\n\nimport hello.core.member.Member;\n\npublic interface DiscountPolicy {\n\n    // @return 할인 대상 금액\n    int discount(Member member, int price);\n}\n```\n\n- 이제 이를 구현할 정액 할인 정책과 정률 할인 정책 클래스를 생성해야 한다.\n\n### 🪔 정액 할인 정책 구현체\n```java\npackage hello.core.discount;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\n\npublic class FixDiscountPolicy implements DiscountPolicy {\n    \n    // 1000원 할인\n    private int discountFixAmount = 1000;\n    \n    @Override\n    public int discount(Member member, int price) {\n        if (member.getGrade() == Grade.VIP) return discountFixAmount;\n        return 0;\n    }\n}\n```\n\n### 🪔 주문 엔티티\n\n```java\npackage hello.core.order;\n\npublic class Order {\n\n    private Long memberId;\n    private String itemName;\n    private int itemPrice;\n    private int discountPrice;\n\n    public Order(Long memberId, String itemName, int itemPrice, int discountPrice) {\n        this.memberId = memberId;\n        this.itemName = itemName;\n        this.itemPrice = itemPrice;\n        this.discountPrice = discountPrice;\n    }\n\n    public int calculatePrice() {\n        return itemPrice - discountPrice;\n    }\n\n    public Long getMemberId() {\n        return memberId;\n    }\n\n    public void setMemberId(Long memberId) {\n        this.memberId = memberId;\n    }\n\n    public String getItemName() {\n        return itemName;\n    }\n\n    public void setItemName(String itemName) {\n        this.itemName = itemName;\n    }\n\n    public int getItemPrice() {\n        return itemPrice;\n    }\n\n    public void setItemPrice(int itemPrice) {\n        this.itemPrice = itemPrice;\n    }\n\n    public int getDiscountPrice() {\n        return discountPrice;\n    }\n\n    public void setDiscountPrice(int discountPrice) {\n        this.discountPrice = discountPrice;\n    }\n\n    @Override\n    public String toString() {\n        return \"Order{\" +\n                \"memberId=\" + memberId +\n                \", itemName='\" + itemName + '\\'' +\n                \", itemPrice=\" + itemPrice +\n                \", discountPrice=\" + discountPrice +\n                '}';\n    }\n}\n```\n\n- `System.out.println(\"Order : \" + order)` 로 `Order` 객체를 출력해보면, 사실은 `Order` 객체의 `toString()` 이 호출된다!\n\n### 🪔 주문 서비스 인터페이스\n```java\npackage hello.core.order;\n\npublic interface OrderService {\n    Order createOrder(Long memberId, String itemName, int itemPrice);\n}\n```\n\n### 🪔 주문 서비스 구현체\n```java\npackage hello.core.order;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.member.Member;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemoryMemberRepository;\n\npublic class OrderServiceImpl implements OrderService {\n\n    // 회원을 찾기 위해 필요\n    private final MemberRepository memberRepository = new MemoryMemberRepository();\n\n    // 할인 정책 사용을 위해 필요\n    private final DiscountPolicy discountPolicy = new FixDiscountPolicy();\n\n    @Override\n    public Order createOrder(Long memberId, String itemName, int itemPrice) {\n        Member member = memberRepository.findById(memberId);\n        // 할인에 대해서는 createOrder는 아예 알지 못함, 단일 책임 원칙을 잘 지킨 예\n        int discountPrice = discountPolicy.discount(member, itemPrice);\n        \n        return new Order(memberId, itemName, itemPrice, discountPrice);\n    }\n}\n```\n\n- 주문 생성을 위해, 회원을 찾아야 하고, 할인 정책을 사용해야 한다.\n  - 따라서 `MemberRepository` 와 `DiscountPolicy` 가 필요하다.\n- `createOrder` 메소드에서, \n  - 회원 정보를 조회하고,\n  - 할인 정책을 적용한 다음,\n  - 주문 객체를 생성해 반환한다.\n- 이때 할인에 대해서는 `createOrder` 는 알지 못하고, `discountPolicy` 에서 이를 책임진다. \n  - 이는 **단일 책임 원칙 (Single Responsibility Principle)** 이 잘 지켜진 예다.\n\n---\n\n## 🎯 주문과 할인 도메인 실행과 테스트\n### 🪔 주문과 할인 정책 실행\n```java\npackage hello.core;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.order.Order;\nimport hello.core.order.OrderService;\nimport hello.core.order.OrderServiceImpl;\n\npublic class OrderApp {\n\n    public static void main(String[] args) {\n        MemberService memberService = new MemberServiceImpl();\n        OrderService orderService = new OrderServiceImpl();\n\n        Long memberId = 1L;\n        Member member = new Member(memberId, \"memberA\", Grade.VIP);\n        memberService.join(member);\n\n        Order order = orderService.createOrder(memberId, \"itmeA\", 10000);\n\n        System.out.println(\"Order = \" + order);\n    }\n}\n```\n\n```java\n// 결과는 다음과 같다.\nOrder = Order{memberId=1, itemName='itmeA', itemPrice=10000, discountPrice=1000}\n```\n\n### 🪔 주문과 할인 정책 테스트\nJUnit 프레임워크를 사용해 테스트한다.\n\n```java\npackage hello.core.order;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.Test;\n\npublic class OrderServiceTest {\n\n    MemberService memberService = new MemberServiceImpl();\n    OrderService orderService = new OrderServiceImpl();\n\n    @Test\n    void createOrder() {\n        Long memberId = 1L;\n        Member member = new Member(memberId, \"memberA\", Grade.VIP);\n        memberService.join(member);\n\n        Order order = orderService.createOrder(memberId, \"itmeA\", 10000);\n\n        Assertions.assertThat(order.getDiscountPrice()).isEqualTo(1000);\n    }\n}\n```\n\n## 📌 중요한 개념\n설계, 객체 지향을 위한 원칙 준수, 테스트\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 새로운 할인 정책을 개발하는 것을 요구받았다. 하지만 이를 개발하게 되면서 DIP, OCP 원칙을 깨트리게 된다. 이 문제를 해결하면서 스프링으로의 전환이 이루어지게 될 것이다! 🎯 새로운 할인 정책 개발 악덕 기획자: 서비스 오픈 직전에 할인 정책을 지금처럼 고정 금액 할인이 아니라 좀 더 …","fields":{"slug":"/[스프링핵심원리_기본편]3.스프링핵심원리이해2-객체지향원리적용/"},"frontmatter":{"date":"June 29, 2022","title":"📟 3. 스프링 핵심 원리 이해 2 - 객체 지향 원리 적용","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n새로운 할인 정책을 개발하는 것을 요구받았다. 하지만 이를 개발하게 되면서 DIP, OCP 원칙을 깨트리게 된다.\n- 이 문제를 해결하면서 스프링으로의 전환이 이루어지게 될 것이다!\n\n## 🎯 새로운 할인 정책 개발\n**악덕 기획자**: 서비스 오픈 직전에 할인 정책을 지금처럼 고정 금액 할인이 아니라 좀 더 합리적인 주문 금액당 할인하는 정률% 할인으로 변경하고 싶어요. 예를 들어서 기존 정책은 VIP가 10000원을 주문하든 20000원을 주문하든 항상 1000원을 할인했는데, 이번에 새로 나온 정책은 10%로 지정해두면 고객이 10000원 주문시 1000원을 할인해주고, 20000원 주문시에 2000원을 할인해주는 거에요!\n\n**순진 개발자**: 제가 처음부터 고정 금액 할인은 아니라고 했잖아요.\n\n**악덕 기획자**: 애자일 소프트웨어 개발 선언 몰라요? “계획을 따르기보다 변화에 대응하기를”\n\n**순진 개발자**: ... \n\n새로운 정률 할인 정책을 추가하자!\n\n### 🪔 RateDiscountPolicy 추가\n<img src=\"../../images/스프링핵심원리-기본편/ratediscountpolicy.png\" width=\"80%\">\n\n- 새로운 정률 할인 정책 추가를 위해서, `DiscountPolicy` 인터페이스를 구현할 `RateDiscountPolicy` 클래스를 추가로 개발하면 된다!\n\n```java\npackage hello.core.discount;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\n\npublic class RateDiscountPolicy implements DiscountPolicy {\n\n    private int discountPercent = 10;\n    @Override\n    public int discount(Member member, int price) {\n        if (member.getGrade() == Grade.VIP)\n            return price * discountPercent / 100;\n        return 0;\n    }\n}\n```\n\n- `FixDiscountPolicy` 처럼 만들었다. VIP인 경우에 반환하는 로직은 쉽긴 하지만, 확실한 개발을 위해서는 테스트가 필요할 것 같다.\n- 따라서 `command + shift + T` 로 바로 테스트 코드를 작성한다.\n\n```java\npackage hello.core.discount;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport org.assertj.core.api.Assertions;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\n\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass RateDiscountPolicyTest {\n    RateDiscountPolicy rateDiscountPolicy = new RateDiscountPolicy();\n\n    @Test\n    @DisplayName(\"VIP는 10% 할인이 적용되어야 한다.\")\n    void vipO() {\n        // given\n        Member member = new Member(1L, \"memberVIP\", Grade.VIP);\n\n        // when\n        int discount = rateDiscountPolicy.discount(member, 10000);\n\n        // then\n        Assertions.assertThat(discount).isEqualTo(1000);\n    }\n}\n```\n\n- 위 테스트 코드로 VIP인 경우 10000원에 대한 할인 금액이 1000원이 제대로 반환되는지 확인한다.\n\n이제 실패 예시에 대한 코드 또한 필요하다.\n\n```java\n...\n@Test\n@DisplayName(\"VIP가 아니면 할인이 적용되지 않아야 한다.\")\nvoid vipX() {\n    // given\n    Member member = new Member(2L, \"memberVIP\", Grade.BASIC);\n\n    // when\n    int discount = rateDiscountPolicy.discount(member, 10000);\n\n    // then\n    Assertions.assertThat(discount).isEqualTo(0);\n}\n```\n\n- 일반등급인 경우, 할인 금액이 0원인 것을 확인할 수 있다.\n\n---\n\n## 🎯 새로운 할인 정책 적용과 문제점\n새로운 할인 정책(정률 할인)을 적용해보자.\n\n### 🪔 할인 정책 적용\n할인 정책의 변경을 위해 클라이언트인 `OrderServiceImpl` 코드를 변경해야 한다.\n\n```java\npublic class OrderServiceImpl implements OrderService {\n\n    ...\n\n    // private final DiscountPolicy discountPolicy = new FixDiscountPolicy();\n    private final DiscountPolicy discountPolicy = new RateDiscountPolicy();\n\n    ...\n}\n```\n\n### 🪔 문제점\n- [x] 역할과 구현을 충실하게 분리했다!\n- [x] 다형성도 활용하고 인터페이스와 구현 객체를 분리했다!\n- [ ] OCP, DIP와 같은 객체 지향 설계 원칙을 준수했다...?\n\n사실은 준수하지 못하고 있다!\n- **DIP**: 주문 서비스 클라이언트(`OrderServiceImpl`) 는 `DiscountPolicy` 인터페이스에 의존하면서 DIP를 지킨 것 같아 보이지만, 사실은 **구현 클래스에도 의존**하고 있다.\n  - 위에서 **정책의 변경을 위해 구현체 변경 코드가 필요**했으니...!\n- **OCP**: 변경하지 않고 확장할 수 있어야 한다.\n  - 지금 코드는 기능을 확장해서 변경하면, 클라이언트 코드(`OrderServiceImpl`)에 영향을 주고 있다. \n  - 따라서 OCP 또한 위반하고 있다.\n\n### 🪔 클래스 다이어그램으로 확인\n**기대했던 의존관계**\n<img src=\"../../images/스프링핵심원리-기본편/ratediscountpolicy.png\" width=\"80%\">\n\n- 그림과 같이 `DiscountPolicy` 인터페이스에만 의존하고 있다고 생각하고 구현했다.\n\n**실제 의존관계**\n<img src=\"../../images/스프링핵심원리-기본편/실제의존관계.png\" width=\"80%\">\n\n- 하지만 실제로는 인터페이스 뿐 아니라 구현 클래스에도 의존하고 있다.\n- 따라서 **DIP를 위반**하게 된다.\n\n**정책 변경**\n<img src=\"../../images/스프링핵심원리-기본편/정책변경.png\" width=\"80%\">\n\n- 구현 클래스를 변경하게 되면, `OrderServiceImpl` 의 소스 코드도 함께 변경해야 한다.\n- 따라서 **OCP를 위반**하게 된다.\n\n**문제 해결**\n- 클라이언트 코드인 `OrderServiceImpl` 가 인터페이스뿐만 아니라 구체 클래스도 의존해서 생기는 문제이므로, 클라이언트 코드가 인터페이스에만 의존하도록 설계를 변경한다!\n\n<img src=\"../../images/스프링핵심원리-기본편/할인정책적용문제해결.png\" width=\"80%\">\n\n인터페이스에만 의존하도록 코드를 다음과 같이 변경한다.\n\n```java\npublic class OrderServiceImpl implements OrderService {\n    //private final DiscountPolicy discountPolicy = new RateDiscountPolicy();\n    private DiscountPolicy discountPolicy;\n}\n```\n\n- 하지만 구현체가 없는데 어떻게 코드를 실행할 수 있을까?\n  - 실행을 해보면, `NullPointerException` 이 발생한다.\n\n이를 해결하기 위해서는 **누군가가 클라이언트인 `OrderServiceImpl` 에 `DiscountPolicy` 의 구현 객체를 대신 생성하고 주입**해줘야 한다!!!\n \n---\n\n## 🎯 관심사의 분리\n- 애플리케이션을 하나의 공연이라 생각해보자. 각각의 인터페이스를 배역(배우 역할)이라 생각하자. 그런데! 실제 배역 맞는 배우를 선택하는 것은 **누가 하는가?**\n- 로미오와 줄리엣 공연을 하면 로미오 역할을 누가 할지 줄리엣 역할을 누가 할지는 배우들이 정하는게 아니다. 이전 코드는 마치 로미오 역할(인터페이스)을 하는 레오나르도 디카프리오(구현체, 배우)가 줄리엣 역할(인터페이스)을 하는 여자 주인공(구현체, 배우)을 직접 초빙하는 것과 같다. 디카프리오는 공연도 해야하고 동시에 여자 주인공도 공연에 직접 초빙해야 하는 다양한 책임을 가지고 있다.\n  - `OrderServiceImpl` 은 `OrderService` 와 관련된 로직만을 수행해야 하는데, `DiscountPolicy` 에 대한 객체 생성과 선택까지 수행하고 있는 것이다.\n\n> 각자 할 역할이 정해져 있다 !!!\n\n**관심사를 분리하자**\n- 배우는 본인의 역할인 배역을 수행하는 것에만 집중해야 한다.\n- 디카프리오는 어떤 여자 주인공이 선택되더라도 똑같이 공연을 할 수 있어야 한다.\n- 공연을 구성하고, 담당 배우를 섭외하고, 역할에 맞는 배우를 지정하는 책임을 담당하는 별도의 **공연 기획자가 나올 시점**이다.\n- 공연 기획자를 만들고, 배우와 공연 기획자의 책임을 확실히 분리하자.\n\n### 🪔 AppConfig 등장\n애플리케이션의 전체 동작 방식을 구성(Config)하기 위해, **구현 객체를 생성하고 연결하는 책임**을 가지는 **별도의 설정 클래스**를 만든다.\n\n```java\npackage hello.core;\n\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.member.MemoryMemberRepository;\nimport hello.core.order.OrderService;\nimport hello.core.order.OrderServiceImpl;\n\npublic class AppConfig {\n\n    public MemberService memberService() {\n        return new MemberServiceImpl(new MemoryMemberRepository());\n    }\n\n    public OrderService orderService() {\n        return new OrderServiceImpl(new MemoryMemberRepository(), new FixDiscountPolicy());\n    }\n}\n\npackage hello.core.order;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.discount.RateDiscountPolicy;\nimport hello.core.member.Member;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemoryMemberRepository;\n\npublic class OrderServiceImpl implements OrderService {\n\n    // 회원을 찾기 위해 필요\n    private final MemberRepository memberRepository;\n    // 할인 정책 사용을 위해 필요\n    // private final DiscountPolicy discountPolicy = new FixDiscountPolicy();\n    private final DiscountPolicy discountPolicy;\n\n    public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy discountPolicy) {\n        this.memberRepository = memberRepository;\n        this.discountPolicy = discountPolicy;\n    }\n\n    @Override\n    public Order createOrder(Long memberId, String itemName, int itemPrice) {\n        Member member = memberRepository.findById(memberId);\n        // 할인에 대해서는 createOrder는 아예 알지 못함, 단일 책임 원칙을 잘 지킨 예\n        int discountPrice = discountPolicy.discount(member, itemPrice);\n\n        return new Order(memberId, itemName, itemPrice, discountPrice);\n    }\n}\n```\n\n- 이전에는 어떤 인터페이스와 어떤 구현체를 사용할 지를 `MemberService` 내에서 직접 선언했었다. (배우가 직접 상대 배역을 지정하는 것과 동일)\n- `MemberServiceImpl` 는 `MemoryMemberRepository` 를 사용하고 있으므로, 이 구현체 선언부를 지우고, **생성자를 만든다.**\n- 이렇게 되면, `MemberRepository` 인터페이스에 어떤 구체 클래스를 사용할지가 생성자를 통해서 지정된다.\n  - 그리고, `MemberServiceImpl` 에서 `MemoryMemberRepository` 라는 구체 클래스에 대한 코드는 없어진다.\n- `OrderServiceImpl` 은 사용하는 field가 2개이므로, 생성자 주입을 위해 2개의 구체 클래스를 인자로 넘겨준다.\n\n어디선가 `AppConfig` 의 메소드를 호출하면, `MemberServiceImpl` 과 `OrderServiceImpl` 이 생성되고, 생성한 객체 인스턴스의 참조를 생성자를 통해 주입해준다.\n- `MemberServiceImpl` -> `MemoryMemberRepository`\n- `OrderServiceImpl` -> `MemoryMemberRepository` , `FixDiscountPolicy`\n\n이로써, **인터페이스에만 의존**하게 되어 DIP를 위반하지 않게 되었다.\n- `MemberServiceImpl` 입장에서, 생성자를 통해 어떤 구현 객체가 들어올 지(주입될 지)는 전혀 알 수 없다.\n  - 이는 클래스 내부가 아니라, 외부(`AppConfig`)에서 결정된다.\n- **의존관계에 대한 고민은 외부로 넘기고, 실행에만 집중**하도록 한다!\n\n**클래스 다이어그램**\n<img src=\"../../images/스프링핵심원리-기본편/appconfig클래스다이어그램.png\" width=\"80%\">\n\n- 객체의 생성과 연결은 `AppConfig` 가 담당한다.\n- **DIP 완성** : `MemberServiceImpl` 은 `MemberRepository` 인 추상 인터페이스에만 의존하면 된다. 구체 클래스는 몰라도 된다!\n- **관심사의 분리** : 객체를 생성하고 연결하는 역할과(`AppConfig`), 실행하는 역할이(`MemberServiceImpl` , `OrderServiceImpl`) 명확히 분리되었다.\n\n**회원 객체 인스턴스 다이어그램**\n<img src=\"../../images/스프링핵심원리-기본편/appconfig회원객체인스턴스다이어그램.png\" width=\"80%\">\n\n- `appConfig` 객체는 `memoryMemberRepository` 객체를 생성하고, 그 참조값을 `memberServiceImpl` 을 생성하면서 생성자로 전달한다.\n- 클라이언트(`memberServiceImpl`) 입장에서는 의존관계를 마치 외부에서 주입해주는 것과 같아 **DI(Dependency Injection), 의존관계 주입, 의존성 주입**이라 한다.\n\n### 🪔 AppConfig 실행\n**사용 클래스 - `MemberApp`**\n```java\npackage hello.core;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\n\npublic class MemberApp {\n    public static void main(String[] args) {\n        AppConfig appConfig = new AppConfig();\n        MemberService memberService = appConfig.memberService();\n\n        Member member = new Member(1L, \"memberA\", Grade.VIP);\n        memberService.join(member);\n\n        Member findMember = memberService.findMember(1L);\n        System.out.println(\"new Member = \" + member.getName());\n        System.out.println(\"findMember = \" + findMember.getName());\n    }\n}\n```\n\n**사용 클래스 - `OrderApp`**\n```java\npackage hello.core;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport hello.core.member.MemberService;\n\npublic class MemberApp {\n    public static void main(String[] args) {\n        AppConfig appConfig = new AppConfig();\n        MemberService memberService = appConfig.memberService();\n\n        Member member = new Member(1L, \"memberA\", Grade.VIP);\n        memberService.join(member);\n\n        Member findMember = memberService.findMember(1L);\n        System.out.println(\"new Member = \" + member.getName());\n        System.out.println(\"findMember = \" + findMember.getName());\n    }\n}\n```\n\n**테스트 코드 수정**\n\n```java\nMemberService memberService;\nOrderService orderService;\n\n@BeforeEach\npublic void beforeEach() {\n    AppConfig appConfig = new AppConfig();\n    memberService = appConfig.memberService();\n    orderService = appConfig.orderService();\n}\n```\n- `@BeforeEach` 를 사용해 각 테스트를 실행하기 전에 호출되도록 수정한다.\n\n---\n\n## 🎯 AppConfig 리팩토링\n현재의 `AppConfig` 에 중복이 있고, 역할에 따른 구현이 잘 보이지 않아 리팩토링을 수행한다.\n\n**기대하는 그림**\n<img src=\"../../images/스프링핵심원리-기본편/appconfig리팩토링.png\" width=\"80%\">\n\n```java\npackage hello.core;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.member.MemoryMemberRepository;\nimport hello.core.order.OrderService;\nimport hello.core.order.OrderServiceImpl;\n\npublic class AppConfig {\n\n    public MemberService memberService() {\n        return new MemberServiceImpl(memberRepository());\n    }\n\n    private MemberRepository memberRepository() {\n        return new MemoryMemberRepository();\n    }\n\n    public OrderService orderService() {\n        return new OrderServiceImpl(\n                memberRepository(),\n                discountPolicy()\n        );\n    }\n\n    public DiscountPolicy discountPolicy() {\n        return new FixDiscountPolicy();\n    }\n}\n```\n\n- 역할과 구현 클래스가 한눈에 보기 쉽다. 애플리케이션 전체 구성이 어떻게 되어 있는지 빠른 파악이 가능해졌다.\n- 구현체의 변경 시에는 세부 메소드의 한 부분만 변경하면 된다.\n\n---\n\n## 🎯 새로운 구조와 할인 정책 적용\n- 정액 할인 정책을 정률 할인 정책으로 변경한다.\n  - 이제 AppConfig만 수정하면 된다.\n\n\"AppConfig의 등장으로 애플리케이션이 크게 사용 영역과 객체를 생성하고 구성하는 영역으로 분리되었다!\"\n\n**사용, 구성의 분리**\n<img src=\"../../images/스프링핵심원리-기본편/사용구성의분리.png\" width=\"80%\">\n\n**할인 정책의 변경**\n<img src=\"../../images/스프링핵심원리-기본편/할인정책의변경.png\" width=\"80%\">\n\n- 구성 영역에만 영향을 받고, 사용 영역은 전혀 구애받지 않는다.\n\n**할인 정책 변경 구성 코드**\n```java\npackage hello.core;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.discount.RateDiscountPolicy;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.member.MemoryMemberRepository;\nimport hello.core.order.OrderService;\nimport hello.core.order.OrderServiceImpl;\n\npublic class AppConfig {\n\n    ...\n\n    public DiscountPolicy discountPolicy() {\n//        return new FixDiscountPolicy();\n        return new RateDiscountPolicy();\n    }\n}\n```\n\n- 할인 정책 역할을 담당하는 구현을 `RateDiscountPolicy` 객체로 변경했다.\n\n---\n\n## 🎯 좋은 객체 지향 설계의 5가지 원칙의 적용\n크게 3가지 SRP, DIP, OCP 원칙이 적용되었다.\n\n### 🪔 SRP 단일 책임 원칙\n**한 클래스는 하나의 책임만 가져야 한다.**\n- 관심사의 분리를 통해, \n  - 구현 객체를 생성하고 연결하는 책임은 `AppConfig` 가 담당\n  - 실행하는 책임은 클라이언트 객체가 담당\n\n### 🪔 DIP 의존관계 역전 원칙\n**추상화에 의존해야지, 구체화에 의존하면 안된다.**\n- 새로운 할인 정책 개발 후 적용하려 할 때 클라이언트 코드의 변경을 요구했다.\n  - 이는 구체 클래스에 함께 의존하고 있었기 때문이었다.\n- 따라서 추상화 인터페이스에만 의존하도록 코드를 변경했다.\n  - 클라이언트 코드는 인터페이스만으로 아무것도 실행할 수 없기에, `AppConfig` 를 통해 객체를 생성하고, 의존관계를 주입했다.\n\n### 🪔 OCP 개방 폐쇄 원칙\n**소프트웨어 요소는 확장에는 열려 있으나 변경에는 닫혀 있어야 한다.**\n- 다형성을 사용하고 클라이언트가 DIP를 지키게 되면, OCP 원칙이 적용될 가능성이 열린다.\n- 애플리케이션을 사용 영역과 구성 영역으로 나눈다.\n- 변경이 일어나도, 클라이언트 코드를 변경할 필요가 없게 되었으므로, 사용 영역에 대한 변경은 완전히 닫혀 있게 되었다.\n\n---\n\n## 🎯 IoC, DI, 그리고 컨테이너\n### 🪔 제어의 역전 (Inversion of Control)\n기존 프로그램은 클라이언트 구현 객체가 스스로 필요한 서버 구현 객체를 생성하고, 연결하고, 실행했다. 한마디로 \"구현 객체가 프로그램의 제어 흐름을 스스로 조종\"했다. 개발자 입장에서는 자연스러운 흐름이다.\n\n반면에 `AppConfig` 가 등장한 이후에 **구현 객체는 자신의 로직을 실행하는 역할만 담당**한다. 프로그램의 제어 흐름은 이제 `AppConfig` 가 가져간다. 예를 들어서 `OrderServiceImpl` 은 필요한 인터페이스들을 호출하지만 어떤 구현 객체들이 실행될지 모른다.\n\n프로그램에 대한 제어 흐름에 대한 권한은 모두 `AppConfig` 가 가지고 있다. 심지어 `OrderServiceImpl` 도 AppConfig가 생성한다. 그리고 `AppConfig` 는 `OrderServiceImpl` 이 아닌 `OrderService` 인터페이스의 다른 구현 객체를 생성하고 실행할 수 도 있다. 그런 사실도 모른체 `OrderServiceImpl` 은 묵묵히 자신의 로직을 실행할 뿐이다.\n\n이렇듯 **프로그램의 제어 흐름을 직접 제어하는 것이 아니라 외부에서 관리하는 것을 제어의 역전(IoC)**이라 한다.\n\n> **프레임워크 vs. 라이브러리**\n> - 프레임워크가 내가 작성한 코드를 제어하고, 대신 실행하면 그것은 프레임워크가 맞다. (JUnit)\n> - 반면에 내가 작성한 코드가 직접 제어의 흐름을 담당한다면 그것은 프레임워크가 아니라 라이브러리다.\n\n### 🪔 의존관계 주입(Dependency Injection)\n`OrderServiceImpl` 은 `DiscountPolicy` 인터페이스에 의존한다. 실제 어떤 구현 객체가 사용될지는 모른다.\n\n의존관계는 **정적인 클래스 의존 관계**와, **실행 시점에 결정되는 동적인 객체(인스턴스) 의존 관계** 둘을 분리해서 생각해야 한다.\n\n**정적인 클래스 의존관계**\n- **클래스가 사용하는 `import` 코드만 보고 의존관계를 쉽게 판단**할 수 있다. 정적인 의존관계는 애플리케이션을 실행하지 않아도 분석할 수 있다. 클래스 다이어그램을 보자\n- `OrderServiceImpl` 은 `MemberRepository` , `DiscountPolicy` 에 의존한다는 것을 알 수 있다.\n- 그런데 이러한 클래스 의존관계 만으로는 실제 어떤 객체가 `OrderServiceImpl` 에 주입 될지 알 수 없다.\n\n<img src=\"../../images/스프링핵심원리-기본편/DI클래스다이어그램.png\" width=\"80%\">\n\n**동적인 객체 인스턴스 의존 관계**\n- 애플리케이션 실행 시점에 실제 생성된 객체 인스턴스의 참조가 연결된 의존 관계다.\n\n**객체 다이어그램**\n<img src=\"../../images/스프링핵심원리-기본편/DI객체다이어그램.png\" width=\"80%\">\n\n- 애플리케이션 **실행 시점(런타임)**에 외부에서 실제 구현 객체를 생성하고 클라이언트에 전달해서 클라이언트와 서버의 실제 의존관계가 연결되는 것을 **의존관계 주입**이라 한다.\n- 객체 인스턴스를 생성하고, 그 참조값을 전달해서 연결된다.\n- 의존관계 주입을 사용하면 클라이언트 코드를 변경하지 않고, 클라이언트가 호출하는 대상의 타입 인스턴스를 변경할 수 있다.\n- 의존관계 주입을 사용하면 정적인 클래스 의존관계를 변경하지 않고, 동적인 객체 인스턴스 의존관계를 쉽게 변경할 수 있다.\n\n### 🪔 IoC 컨테이너, DI 컨테이너\n`AppConfig` 처럼 객체를 생성하고 관리하면서 의존관계를 연결해 주는 것을 IoC 컨테이너 또는 DI 컨테이너라 한다.\n\n의존관계 주입에 초점을 맞추어 최근에는 주로 DI 컨테이너라 한다. 또는 어샘블러, 오브젝트 팩토리 등으로 불리기도 한다.\n\n---\n\n## 🎯 스프링으로 전환하기\n이제 스프링을 사용한 코드로 변경한다.\n\n```java\npackage hello.core;\n\nimport hello.core.discount.DiscountPolicy;\nimport hello.core.discount.FixDiscountPolicy;\nimport hello.core.discount.RateDiscountPolicy;\nimport hello.core.member.MemberRepository;\nimport hello.core.member.MemberService;\nimport hello.core.member.MemberServiceImpl;\nimport hello.core.member.MemoryMemberRepository;\nimport hello.core.order.OrderService;\nimport hello.core.order.OrderServiceImpl;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\n@Configuration\npublic class AppConfig {\n\n    @Bean\n    public MemberService memberService() {\n        return new MemberServiceImpl(memberRepository());\n    }\n\n    @Bean\n    public MemberRepository memberRepository() {\n        return new MemoryMemberRepository();\n    }\n\n    @Bean\n    public OrderService orderService() {\n        return new OrderServiceImpl(\n                memberRepository(),\n                discountPolicy()\n        );\n    }\n\n    @Bean\n    public DiscountPolicy discountPolicy() {\n//        return new FixDiscountPolicy();\n        return new RateDiscountPolicy();\n    }\n}\n```\n\n- `@Configuration` : 애플리케이션의 구성 정보를 담당하는 클래스에 사용한다.\n- `@Bean` : 스프링 컨테이너에 등록하기 위해 사용한다.\n\n```java\npackage hello.core;\n\nimport hello.core.member.Grade;\nimport hello.core.member.Member;\nimport hello.core.member.MemberService;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\npublic class MemberApp {\n    public static void main(String[] args) {\n//        AppConfig appConfig = new AppConfig();\n//        MemberService memberService = appConfig.memberService();\n\n        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);\n        MemberService memberService = applicationContext.getBean(\"memberService\", MemberService.class);\n\n        Member member = new Member(1L, \"memberA\", Grade.VIP);\n        memberService.join(member);\n\n        Member findMember = memberService.findMember(1L);\n        System.out.println(\"new Member = \" + member.getName());\n        System.out.println(\"findMember = \" + findMember.getName());\n    }\n}\n```\n\n- `ApplicationContext` : 스프링 컨테이너를 의미한다고 봐도 된다. 등록된 객체들을 관리한다.\n- `AnnotationConfigApplicationContext` : annotation 기반으로 configuration을 한 구성 정보를 가지고 만든 애플리케이션의 context를 가져온다.\n- `getBean(String name = \"\", Class<T> requiredType)` : 컨테이너에 등록된 빈 중 `name` 에 해당되는 객체를 가져온다.\n\n**스프링 컨테이너**\n- `ApplicationContext` 를 스프링 컨테이너라 한다.\n- 기존에는 개발자가 `AppConfig` 를 사용해서 직접 객체를 생성하고 DI를 했지만, 이제부터는 스프링 컨테이너를 통해서 사용한다.\n- 스프링 컨테이너는 `@Configuration` 이 붙은 `AppConfig` 를 설정(구성) 정보로 사용한다. 여기서 `@Bean` 이라 적힌 메서드를 모두 호출해서 반환된 객체를 스프링 컨테이너에 등록한다. 이렇게 스프링 컨테이너에 등록된 객체를 스프링 빈이라 한다.\n- 스프링 빈은 `@Bean` 이 붙은 메서드의 명을 스프링 빈의 이름으로 사용한다. ( `memberService` , `orderService` )\n- 이전에는 개발자가 필요한 객체를 `AppConfig` 를 사용해서 직접 조회했지만, 이제부터는 스프링 컨테이너를 통해서 필요한 스프링 빈(객체)를 찾아야 한다. 스프링 빈은 `applicationContext.getBean()` 메서드를 사용해서 찾을 수 있다.\n- 기존에는 개발자가 직접 자바코드로 모든 것을 했다면 이제부터는 스프링 컨테이너에 객체를 스프링 빈으로 등록하고, 스프링 컨테이너에서 스프링 빈을 찾아서 사용하도록 변경되었다.\n\n## 📌 중요한 개념\nDIP, OCP, IoC, DI, 스프링 컨테이너와 빈\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"문제 Programmers - 블록 이동하기 📍 Logic BFS 방식으로  탐색하는 함수로, 총 3번의  문이 존재한다. 첫번째는 주어진 좌표로부터 이동 가능한 상하좌우 좌표를 queue에 추가 두번째와 세번재는 로봇의 좌표 중 하나를 기준으로 90도 회전하여 갈 수 있는 좌표를 queue에 추가 📄 CODE ✏️ Review BFS를 사용해 목적지까지 …","fields":{"slug":"/[Programmers]60063/"},"frontmatter":{"date":"June 26, 2022","title":"👩‍💻 60063. 블록 이동하기","tags":["BFS","구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 블록 이동하기](https://programmers.co.kr/learn/courses/30/lessons/60063)\n\n### 📍 **Logic**\n\n```java\nprivate void moveRobot() {\n    ...\n}\n```\n- BFS 방식으로 `board` 탐색하는 함수로, 총 3번의 `for` 문이 존재한다.\n  - 첫번째는 주어진 좌표로부터 이동 가능한 상하좌우 좌표를 queue에 추가\n  - 두번째와 세번재는 로봇의 좌표 중 하나를 기준으로 90도 회전하여 갈 수 있는 좌표를 queue에 추가\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Robot {\n        int x1;\n        int y1;\n        int dir;\n        int cost;\n        \n        public Robot(int x1, int y1, int dir, int cost) {\n            this.x1 = x1;\n            this.y1 = y1;\n            this.dir = dir;\n            this.cost = cost;\n        }\n    }\n\n    class Solution {\n        static int[][] board;\n        static int size;\n        static int answer = 0;\n        \n        public int solution(int[][] board) {\n            this.board = board;\n            this.size = board.length;\n            \n            moveRobot();\n                \n            return answer;\n        }\n        \n        private void moveRobot() {\n            int[] xRange = {0, 1, 0, -1};\n            int[] yRange = {1, 0, -1, 0};\n            // 회전 시에 사용할 범위 배열\n            int[] rxRange = {-1, 1, 1, -1};\n            int[] ryRange = {1, 1, -1, -1};\n            boolean[][][] visited = new boolean[size][size][4];\n            \n            // Queue에는 왼쪽 좌표만 추가\n            Queue<Robot> queue = new LinkedList<>();\n        \n            int x1, y1, x2, y2, dir, cost;\n            int nx1, ny1, nx2, ny2, ndir;\n            \n            queue.add(new Robot(0, 0, 0, 0));\n            visited[0][0][0] = true;\n            \n            while (!queue.isEmpty()) {\n                Robot robot = queue.poll();\n                x1 = robot.x1;\n                y1 = robot.y1;\n                dir = robot.dir;\n                cost = robot.cost;\n                x2 = x1 + xRange[dir];\n                y2 = y1 + yRange[dir];\n                \n                // 종료\n                if (isFinish(x1, y1) || isFinish(x2, y2)) {\n                    answer = cost;\n                    return;\n                }\n                \n                // 상하좌우로 로봇 이동\n                for (int r = 0; r < 4; r++) {\n                    nx1 = x1 + xRange[r];\n                    ny1 = y1 + yRange[r];\n                    nx2 = x2 + xRange[r];\n                    ny2 = y2 + yRange[r];\n                    \n                    if (!checkBoundary(nx1, ny1) || !checkBoundary(nx2, ny2)) continue;\n                    if (board[nx1][ny1] == 1 || board[nx2][ny2] == 1) continue;\n                    if (visited[nx1][ny1][dir]) continue;\n                    \n                    visited[nx1][ny1][dir] = true;\n                    \n                    queue.add(new Robot(nx1, ny1, dir, cost + 1));\n                }\n                \n                int rx, ry, tempDir;\n                \n                // x1, y1를 기준으로 90도 회전\n                // ndir은 0(오른쪽 대각선 위), 1(오른쪽 대각선 아래), 2(왼쪽 대각선 아래), 3(왼쪽 대각선 위) 중 하나\n                for (int i = 1; i < 4; i += 2) { \n                    ndir = computeDir(dir, i);\n                    nx2 = x1 + xRange[ndir];\n                    ny2 = y1 + yRange[ndir];\n\n                    tempDir = (i == 1) ? ndir : dir;\n                    rx = x1 + rxRange[tempDir];\n                    ry = y1 + ryRange[tempDir];\n\n                    if (!checkBoundary(nx2, ny2) || !checkBoundary(rx, ry)) continue;\n                    if (board[nx2][ny2] == 1 || board[rx][ry] == 1) continue;\n                    if (visited[x1][y1][ndir]) continue;\n\n                    visited[x1][y1][ndir] = true;\n                    \n                    queue.add(new Robot(x1, y1, ndir, cost + 1));\n                }\n                \n                // 반대 방향 처리\n                // x2, y2를 기준으로 90도 회전\n                dir = computeDir(dir, 2);\n                for (int i = 1; i < 4; i += 2) { \n                    ndir = computeDir(dir, i);\n                    nx1 = x2 + xRange[ndir];\n                    ny1 = y2 + yRange[ndir];\n\n                    tempDir = (i == 1) ? ndir : dir;\n                    rx = x2 + rxRange[tempDir];\n                    ry = y2 + ryRange[tempDir];\n\n                    ndir = (ndir + 2) % 4;\n                    if (!checkBoundary(nx1, ny1) || !checkBoundary(rx, ry)) continue;\n                    if (board[nx1][ny1] == 1 || board[rx][ry] == 1) continue;\n                    if (visited[nx1][ny1][ndir]) continue;\n\n                    visited[nx1][ny1][ndir] = true;\n                    \n                    queue.add(new Robot(nx1, ny1, ndir, cost + 1));\n                }\n            }\n        }\n        \n        private boolean checkBoundary(int x, int y) {\n            return x >= 0 && x < size && y >= 0 && y < size;\n        }\n        \n        private boolean isFinish(int x, int y) {\n            return x == size - 1 && y == size - 1;\n        }\n        \n        private int computeDir(int dir, int i) {\n            return (dir + i) % 4;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- BFS를 사용해 목적지까지 최소 비용을 구하는 문제라 판단했다. 그래프 탐색 시에는 DFS, BFS가 가능한데, BFS가 최소 거리를 구하는데 더 효율적인 알고리즘이라는 것을 배웠던 기억이 나 BFS를 사용했다.\n- 아이디어 자체는 쉽게 떠올렸다만, 로봇의 좌표가 2개인 점과 이에 대한 회전 구현에 있어 어려웠다 .."},{"excerpt":"네이버 D2를 보다가, 스프링과 관련된 재밌는 주제를 발견해서 읽으며 느낀 점을 기록하는 POST입니다. 🧷 생각해본 것들 & 알게 된 것들 & 찾아봐야 할 것들 (찾) 역직렬화가 뭘까 -> 직렬화와 역직렬화 정리 (알) 네이버 페이에서는 Rest API 통신 시 각종 타입 정보에 대해 Enum을 적극 활용한다. (생) 네이버 페이 통신 방식에서, API…","fields":{"slug":"/[읽을거리]Jackson의확장구조/"},"frontmatter":{"date":"June 26, 2022","title":"📰 [Naver D2] Jackson의 확장 구조를 파헤쳐 보자","tags":["읽을거리"]},"rawMarkdownBody":"\n네이버 D2를 보다가, 스프링과 관련된 재밌는 주제를 발견해서 읽으며 느낀 점을 기록하는 POST입니다.\n\n## 🧷 생각해본 것들 & 알게 된 것들 & 찾아봐야 할 것들\n1. (찾) 역직렬화가 뭘까 -> [직렬화와 역직렬화 정리](https://subbblog.netlify.app/[Java%EC%A7%80%EC%8B%9D]%EC%A7%81%EB%A0%AC%ED%99%94&%EC%97%AD%EC%A7%81%EB%A0%AC%ED%99%94/)\n2. (알) 네이버 페이에서는 Rest API 통신 시 각종 타입 정보에 대해 Enum을 적극 활용한다.\n3. (생) 네이버 페이 통신 방식에서, API Client에서 하던 Convert Code to Enum 작업을 API Server로 옮기는 것으로 보이는데, 처음부터 이런 방식을 사용했으면 되지 않을까?\n4. (알) 객체의 역직렬화를 위해서는 `@JsonDeserialize` annotation을 사용해 deserializer 등록이 가능하다. 이 방법은 특정 필드나 클래스에 한해 deserializer 등록 시 용이하다.\n\n## 🧷 느낀 점\n- \n\n## 📕 참고\n- [Jackson의 확장 구조를 파헤쳐 보자](https://d2.naver.com/helloworld/0473330)\n- [Getting Started with Custom Deserialization in Jackson](https://www.baeldung.com/jackson-deserialization)"},{"excerpt":"문제 Programmers - 외벽 점검 📍 Logic 만들어진 점검 인원을 이용해 점검이 가능한지 확인한다. 취약 지점 간 거리를 탐색하면서, 모두 점검이 가능하다면  는  로 업데이트되고, 종료를 위해  를 업데이트해 순열 만드는 것을 종료한다. 점검 인원을 모두 동원해도 점검이 불가능하다면, 더이상 탐색을 종료하고, 다음 점검 인원 순열을 만든다. …","fields":{"slug":"/[Programmers]60062/"},"frontmatter":{"date":"June 25, 2022","title":"👩‍💻 60062. 외벽 점검","tags":["완전 탐색","순열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 외벽 점검](https://programmers.co.kr/learn/courses/30/lessons/60062)\n\n### 📍 **Logic**\n\n```java\nprivate void canCheck(int[] friends) {\n    for (int i = 0; i < weak.length; i++) {\n        int start = i;\n        boolean canCheck = true;\n\n        for (int idx = 0; idx < friends.length; idx++) {\n            for (int j = i; j < i + weak.length; j++) {\n                // 두 지점 간 거리가 friends로 뽑힌 친구가 점검 가능한 거리보다 큰 경우는 점검 불가능\n                // 따라서 현재 지점을 시작점으로 지정\n                if (unrolledWeak[j] - unrolledWeak[start] > friends[idx]) {\n                    start = j;\n                    idx++;\n\n                    // 현재 지점을 점검할 수 없는데, 더 점검할 친구가 없다면, 종료\n                    if (idx == friends.length) {\n                        canCheck = false;\n                        break;\n                    }\n                }\n            }\n\n            // 점검 완료라면, 더 이상 점검할 필요가 없다. 따라서 flag를 true 지정\n            if (canCheck) {\n                answer = idx + 1;\n                isFinish = true;\n                return;\n            }\n        }\n    }\n}\n```\n- 만들어진 점검 인원을 이용해 점검이 가능한지 확인한다.\n- 취약 지점 간 거리를 탐색하면서, 모두 점검이 가능하다면 `answer` 는 `idx + 1` 로 업데이트되고, 종료를 위해 `isFinish` 를 업데이트해 순열 만드는 것을 종료한다.\n- 점검 인원을 모두 동원해도 점검이 불가능하다면, 더이상 탐색을 종료하고, 다음 점검 인원 순열을 만든다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    class Solution {\n        static int[] unrolledWeak;\n        static boolean isFinish;\n        static int[] weak;\n        static int[] dist;\n        static int answer = Integer.MAX_VALUE;\n        \n        public int solution(int n, int[] weak, int[] dist) {\n            this.weak = weak;\n            this.dist = dist;\n            this.isFinish = false;\n            int distLen = dist.length;\n\n            unrollWeak(n, weak);\n\n            // i개의 순열 만들기\n            for (int i = 1; i <= distLen; i++)\n                makeDistPerm(0, i, new boolean[distLen], new int[i]);\n            \n            return answer == Integer.MAX_VALUE ? -1 : answer;\n        }\n        \n        private void makeDistPerm(int depth, int count, boolean[] visited, int[] friends) {\n            if (isFinish) return;\n\n            if (depth == count) {\n                canCheck(friends);\n                return;\n            }\n\n            for (int i = 0; i < dist.length; i++) {\n                if (!visited[i]) {\n                    friends[depth] = dist[i];\n                    visited[i] = true;\n                    makeDistPerm(depth + 1, count, visited, friends);\n                    visited[i] = false;\n                }\n            }\n        }\n\n        private void canCheck(int[] friends) {\n            for (int i = 0; i < weak.length; i++) {\n                int start = i;\n                boolean canCheck = true;\n\n                for (int idx = 0; idx < friends.length; idx++) {\n                    for (int j = i; j < i + weak.length; j++) {\n                        // 두 지점 간 거리가 friends로 뽑힌 친구가 점검 가능한 거리보다 큰 경우는 점검 불가능\n                        // 따라서 현재 지점을 시작점으로 지정\n                        if (unrolledWeak[j] - unrolledWeak[start] > friends[idx]) {\n                            start = j;\n                            idx++;\n\n                            // 현재 지점을 점검할 수 없는데, 더 점검할 친구가 없다면, 종료\n                            if (idx == friends.length) {\n                                canCheck = false;\n                                break;\n                            }\n                        }\n                    }\n\n                    // 점검 완료라면, 더 이상 점검할 필요가 없다. 따라서 flag를 true 지정\n                    if (canCheck) {\n                        answer = idx + 1;\n                        isFinish = true;\n                        return;\n                    }\n                }\n            }\n        }\n\n        // weak를 1차원으로 펼침\n        private void unrollWeak(int n, int[] weak) {\n            int len = weak.length;\n            unrolledWeak = new int[len * 2 - 1];\n\n            System.arraycopy(weak, 0, unrolledWeak, 0, len);\n\n            for (int i = 0; i < len - 1; i++)\n                unrolledWeak[i + len] = weak[i] + n;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 순열을 사용해서 1, 2, ... n명으로 가능한지 확인해보는 방식인 것은 쉽게 알았다!\n  - 하지만 주어진 인원으로 외벽 점검이 가능한지 확인하는 로직 구현에서 좀 막혔다...\n- 구현 연습을 많이 해야겠다."},{"excerpt":"문제 Programmers - 가사 검색 📍 Logic 트라이를 정방향, 뒷방향으로 2개 생성한다. 접두사가 ?인 경우는 탐색해야 하는 경우가 많고 이때문에 시간 초과 발생하기 때문에 이와 같이 나누어 생성한다. 트라이 구조를 나누어 저장하기에, 접두사에 따라 탐색하는 트라이 구조를 바꿔가며 count를 계산한다. 📄 CODE ✏️ Review 처음에는 정…","fields":{"slug":"/[Programmers]60060/"},"frontmatter":{"date":"June 24, 2022","title":"👩‍💻 60060. 가사 검색","tags":["Trie"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 가사 검색](https://programmers.co.kr/learn/courses/30/lessons/60060)\n\n### 📍 **Logic**\n\n```java\nclass Trie {\n    private TrieNode forward;\n    private TrieNode backward;\n\n    ...\n}\n```\n\n- 트라이를 정방향, 뒷방향으로 2개 생성한다.\n  - 접두사가 ?인 경우는 탐색해야 하는 경우가 많고 이때문에 시간 초과 발생하기 때문에 이와 같이 나누어 생성한다.\n- 트라이 구조를 나누어 저장하기에, 접두사에 따라 탐색하는 트라이 구조를 바꿔가며 count를 계산한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class TrieNode {\n        private Map<Character, TrieNode> childNodes = new HashMap<>();\n        int count;\n\n        // 자식 노드 맵 Getter\n        public Map<Character, TrieNode> getChildNodes() {\n            return this.childNodes;\n        }\n    }\n\n    class Trie {\n        // 트라이를 정방향, 뒷방향으로 2개 생성\n        // 접두사가 ?인 경우는 탐색해야 하는 경우가 많고 이때문에 시간 초과 발생...\n        private TrieNode forward;\n        private TrieNode backward;\n\n        public Trie() {\n            forward = new TrieNode();\n            backward = new TrieNode();\n        }\n\n        public void insert(String word) {\n            insertBackward(word);\n            insertForward(word);\n        }\n\n        // 주어진 문자의 뒷부분부터 Trie 구조 생성, count 계산\n        private void insertBackward(String word) {\n            TrieNode node = backward;\n\n            for (int i = word.length() - 1; i >= 0; i--) {\n                node.count++;\n                char ch = word.charAt(i);\n                Map<Character, TrieNode> childNodes = node.getChildNodes();\n                childNodes.putIfAbsent(ch, new TrieNode());\n                node = childNodes.get(ch);\n            }\n        }\n\n        // 주어진 문자의 앞부분부터 Trie 구조 생성, count 계산\n        private void insertForward(String word) {\n            TrieNode node = forward;\n\n            for (int i = 0; i < word.length(); i++) {\n                node.count++;\n                char ch = word.charAt(i);\n                Map<Character, TrieNode> childNodes = node.getChildNodes();\n                childNodes.putIfAbsent(ch, new TrieNode());\n                node = childNodes.get(ch);\n            }\n        }\n\n        // 접두사가 ?라면 뒷방향 Trie로부터 count\n        // 그렇지 않다면 정방향 Trie로부터 count\n        public int getCount(String query) {\n            return query.charAt(0) == '?' ? getCountBackward(query) : getCountFarward(query);\n        }\n\n        private int getCountBackward(String query) {\n            TrieNode node = backward;\n\n            for (int i = query.length() - 1; i >= 0; i--) {\n                char ch = query.charAt(i);\n                if (ch == '?') return node.count;\n                Map<Character, TrieNode> childNodes = node.getChildNodes();\n                if (!childNodes.containsKey(ch)) return 0;\n                node = childNodes.get(ch);\n            }\n\n            return node.count;\n        }\n\n        private int getCountFarward(String query) {\n            TrieNode node = forward;\n\n            for (int i = 0; i < query.length(); i++) {\n                char ch = query.charAt(i);\n                if (ch == '?') return node.count;\n                Map<Character, TrieNode> childNodes = node.getChildNodes();\n                if (!childNodes.containsKey(ch)) return 0;\n                node = childNodes.get(ch);\n            }\n\n            return node.count;\n        }\n    }\n\n    class Solution {\n        public int[] solution(String[] words, String[] queries) {\n            // 문자열 길이를 인덱스로 하는 Trie 배열 선언\n            Trie[] trie = new Trie[100001];\n            int[] answer = new int[queries.length];\n            \n            // 문자열 길이를 기준으로 배열 초기화 후, trie 생성\n            for (String word : words) {\n                int len = word.length();\n                if (trie[len] == null) trie[len] = new Trie();\n                trie[len].insert(word);\n            }\n\n            // query 길이에 해당하는 trie 배열 값이 없다면 해당하는 문자가 없다는 의미,\n            // 있다면 개수 count\n            for (int i = 0; i < queries.length; i++) {\n                int len = queries[i].length();\n                if (trie[len] == null) answer[i] = 0;\n                else answer[i] = trie[len].getCount(queries[i]);\n            }\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 정규식을 이용해야하나 했지만, 효율성 테스트가 있는 것으로 보아 이 방식은 아닌 듯 했고, 곧바로 `Trie` 를 사용해야겠다는 생각이 들었다.\n- 모든 문자가 ?인 경우에 대한 시간 초과를 해결하지 못해 풀이를 참고했다..."},{"excerpt":"문제 Programmers - 기둥과 보 설치 📍 Logic  와  는 각각 기둥과 보가 설치가능한지를 확인하는 함수이다. 주어진 조건에 따라 이를 확인한다.  는 기둥과 보를 주어진 명령대로 삭제했을 때, 주어진 조건을 불만족하는 좌표가 없는지 확인한다. 📄 CODE ✏️ Review 처음 구현 시, 기둥과 보의 삭제 조건 확인때문에 애를 먹었고,  하나…","fields":{"slug":"/[Programmers]60061/"},"frontmatter":{"date":"June 23, 2022","title":"👩‍💻 60061. 기둥과 보 설치","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 기둥과 보 설치](https://programmers.co.kr/learn/courses/30/lessons/60061)\n\n### 📍 **Logic**\n\n```java\nprivate static boolean checkPillar(int x, int y) {\n  // 바닥 설치\n  if (y == 0) return true;\n  // 아래에 기둥이 있는 경우\n  else if (y > 0 && pillars[x][y - 1]) return true;\n  // 한쪽에 보가 있는 경우\n  else return x > 0 && covers[x - 1][y] || covers[x][y];\n}\n\nprivate static boolean checkCover(int x, int y) {\n  // 한쪽 끝에 기둥이 있는 경우\n  if (y > 0 && pillars[x][y - 1] || pillars[x + 1][y - 1]) return true;\n  // 양쪽 끝이 모두 보와 연결된 경우\n  else return x > 0 && covers[x - 1][y] && covers[x + 1][y];\n}\n\nprivate static boolean canDelete(int n) {\n  for (int i = 0; i <= n; i++)\n      for (int j = 0; j <= n; j++)\n          // 기둥이 해당 위치에 있을 수 없거나, 보가 해당 위치에 있을 수 없는 경우 false\n          if ((pillars[i][j] && !checkPillar(i, j)) || (covers[i][j] && !checkCover(i, j))) return false;\n  return true;\n}\n```\n- `checkPillar` 와 `checkCover` 는 각각 기둥과 보가 설치가능한지를 확인하는 함수이다.\n  - 주어진 조건에 따라 이를 확인한다.\n- `canDelete` 는 기둥과 보를 주어진 명령대로 삭제했을 때, 주어진 조건을 불만족하는 좌표가 없는지 확인한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Solution {\n        static boolean[][] pillars;\n        static boolean[][] covers;\n        \n        public int[][] solution(int n, int[][] build_frame) {\n            pillars = new boolean[n + 1][n + 1];\n            covers = new boolean[n + 1][n + 1];\n            int count = 0;\n\n            for (int[] bf : build_frame) {\n                int x = bf[0];\n                int y = bf[1];\n                int struct = bf[2];\n                int command = bf[3];\n\n                // 기둥\n                if (struct == 0) {\n                    // 삭제\n                    if (command == 0) {\n                        pillars[x][y] = false;\n                        if (!canDelete(n)) pillars[x][y] = true;\n                        else count--;\n                    }\n                    // 설치\n                    else {\n                        if (!checkPillar(x, y)) continue;\n                        pillars[x][y] = true;\n                        count++;\n                    }\n                }\n                // 보\n                else {\n                    // 삭제\n                    if (command == 0) {\n                        covers[x][y] = false;\n                        if (!canDelete(n)) covers[x][y] = true;\n                        else count--;\n                    }\n                    // 설치\n                    else {\n                        if (!checkCover(x, y)) continue;\n                        covers[x][y] = true;\n                        count++;\n                    }\n                }\n            }\n\n            int[][] answer = new int[count][3];\n            int idx = 0;\n            for (int i = 0; i <= n; i++) {\n                for (int j = 0; j <= n; j++) {\n                    if (pillars[i][j])\n                        answer[idx++] = new int[]{i, j, 0};\n                    if (covers[i][j])\n                        answer[idx++] = new int[]{i, j, 1};\n                }\n            }\n            \n            return answer;\n        }\n        \n        private static boolean checkPillar(int x, int y) {\n            // 바닥 설치\n            if (y == 0) return true;\n            // 아래에 기둥이 있는 경우\n            else if (y > 0 && pillars[x][y - 1]) return true;\n            // 한쪽에 보가 있는 경우\n            else return x > 0 && covers[x - 1][y] || covers[x][y];\n        }\n        \n        private static boolean checkCover(int x, int y) {\n            // 한쪽 끝에 기둥이 있는 경우\n            if (y > 0 && pillars[x][y - 1] || pillars[x + 1][y - 1]) return true;\n            // 양쪽 끝이 모두 보와 연결된 경우\n            else return x > 0 && covers[x - 1][y] && covers[x + 1][y];\n        }\n\n        private static boolean canDelete(int n) {\n            for (int i = 0; i <= n; i++)\n                for (int j = 0; j <= n; j++)\n                    // 기둥이 해당 위치에 있을 수 없거나, 보가 해당 위치에 있을 수 없는 경우 false\n                    if ((pillars[i][j] && !checkPillar(i, j)) || (covers[i][j] && !checkCover(i, j))) return false;\n            return true;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음 구현 시, 기둥과 보의 삭제 조건 확인때문에 애를 먹었고, `map` 하나에 기둥 여부와 보 여부를 함께 저장했었는데, 생각해보니 기둥과 보가 한 좌표에 함께 존재할 수 있었던 것을 간과했었다.\n- 또한, 설치와 삭제하는 구조물에 대한 `ArrayList` 를 만들어서 관리할 구조물의 범위를 줄이려 했는데 구현에서 조금 막혔다 ...\n  - 새 객체를 만들어서 이미 있는 `Map` 에서 값을 조회하려하니 아예 다른 객체로 판단을 해서 조회가 불가능했다."},{"excerpt":"🧷 Transport Layer 이전에 다룬 Application Layer의 바로 하단에 위치하는 계층이다. 🪚 전송 계층의 역할 전송 계층의 역할은 크게 2가지로 나뉜다. 출발지로부터 도착지까지 패킷이 정상적으로 전송될 수 있도록 한다. 응용 계층에서 만든 데이터를 일정한 크기로 분할한다. 그리고 전송 계층은 대표적으로 2가지의 프로토콜이 있다. 하나…","fields":{"slug":"/[Network]TransportLayer/"},"frontmatter":{"date":"June 20, 2022","title":"📡 Transport Layer","tags":["Network","OSI","Transport"]},"rawMarkdownBody":"\n## 🧷 Transport Layer\n이전에 다룬 Application Layer의 바로 하단에 위치하는 계층이다.\n\n### 🪚 전송 계층의 역할\n전송 계층의 역할은 크게 2가지로 나뉜다.\n1. **출발지로부터 도착지까지 패킷이 정상적으로 전송될 수 있도록 한다.**\n2. **응용 계층에서 만든 데이터를 일정한 크기로 분할한다.**\n\n그리고 전송 계층은 대표적으로 2가지의 프로토콜이 있다. 하나는 TCP이고, 다른 하나는 UDP이다.\n\n### 🪚 Multiplexing & Demultiplexing\n애플리케이션들이 전송 계층의 프로토콜을 위해서는 프로세스마다 **Socket을 사용**해야 한다. \n- 컴퓨터에서는 여러 개의 애플리케이션들이 돌아가고, 각 애플리케이션들은 하나 이상의 Socket을 생성할 수 있다.\n- 그렇다면 전송 계층 입장에서는 여러 개의 Socket들로부터 데이터가 쏟아지는 형태가 된다.\n\n이때, 여러 애플리케이션의 Socket들이 데이터를 송, 수신하기 위해 필요한 개념이 Multiplexing과 Demultiplexing이다.\n\n**Multiplexing**\n- 여러 애플리케이션의 Socket들로부터 들어오는 데이터를 수집해 패킷으로 만들어 하위 계층으로 전달하는 것이다.\n- 이때 Transport Header를 붙인다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2F5pC0M%2FbtqVFBFjjhG%2FOKHjhKxCUplbHtDeGirJTK%2Fimg.png\" width=\"80%\">\n\n**Demultiplexing**\n- 하위 계층으로부터 수신된 패킷을 올바른 Socket으로 전송해 올바른 애플리케이션으로 전달하는 것이다.\n- 이때 애플리케이션의 식별을 위해 **Port #을 이용**한다.\n  - 패킷 헤더에 src port #와 dest port #가 존재한다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2Fb4daRi%2FbtqVIb7pDsM%2FRAZic4YT5w6sBXrXB4Vtak%2Fimg.png\" width=\"80%\">\n\n이때, TCP와 UDP는 Socket 식별을 위해 사용하는 정보에 차이가 있다.\n\n**TCP**는 식별 시에 **4-tuple**을 사용한다.\n- src IP address\n- src port #\n- dest IP address\n- dest port #\n\nIP 주소는 컴퓨터 정보, port #는 응용 계층에 대한 정보이다. 하나라도 다르다면, 다른 연결로 인식하게 된다.\n\n**UDP**는 식별 시 **dest port #만을 사용**한다.\n\n---\n\n## 🧷 TCP\nTransmission Control Protocol, 이름 그대로 전송을 제어하는 프로토콜이라고 생각할 수 있다.\n- 일반적으로 TCP와 IP를 함께 사용하는데, IP가 데이터의 배달을 처리한다면, TCP는 패킷을 추적 및 관리한다.\n- **Reliable**하다.\n- `3-way handshake` 를 통해 초기 연결을 설정한다.\n- **Flow control(흐름 제어)**: 수신측의 상태를 확인하면서 전송을 이어간다.\n  - 수신 데이터를 담는 `Buffer` 는 유한한 자원이므로, **Overflow**가 발생할 수 있다.\n  - 따라서 수신측의 `Buffer` 가 수용 가능한 만큼을 전송한다.\n- **Congesting control(혼잡 제어)**: 네트워크 상태를 확인하면서 전송을 이어간다.\n  - 네트워크가 혼잡하다면, 보내는 패킷 양을 제어하여 전송한다.\n\n> 이러한 제어과정때문에 **UDP보다 전송 속도가 느리다**는 단점이 있다.\n\n- Timing, Security, Minimum Throughput guarantee를 제공하지 않는다.\n- **Connection-Oriented**: 물리적 연결이 아닌 논리적 연결로, **순서에 맞게 손실 없이 데이터를 전송**하는 연결 지향형 프로토콜이다.\n- 주로 **웹 HTTP 통신, 이메일, 파일 전송**에 사용된다.\n\n<img src=\"https://evan-moon.github.io/static/08849868fcdd6a15a88abb391dccacf7/ee604/thumbnail.png\" width=\"80%\">\n\n> **패킷(Packet)**\n> : 인터넷 내에서 데이터를 보내기 위한 경로 배정(라우팅)을 효율적으로 하기 위해 데이터를 여러 개의 조각으로 나누어 전송을 하는데, 이때 각 조각을 패킷이라 한다. \n\n모든 TCP 연결은 `Full-duplex`, `Point to Point` 방식이다.\n- `Full-duplex` 는 전송이 양방향으로 동시에 일어날 수 있음을 의미하고,\n- `Point to Point` 는 각 연결이 정확히 2개의 목적 포인트를 가짐을 의미한다.\n  - 따라서 **TCP는 멀티캐스팅이나 브로드캐스팅을 지원하지 않는다.**\n\n> ❓ **TCP에서는 패킷을 추척 및 관리한다**고 한다. 그렇다면 이는 어떻게 이루어지는 것일까\n\n한 줄로 서야 하는 A, B, C라는 사람(패킷)이 서울(출발지, 송신측)에서 출발해 부산(목적지, 수신측)으로 가야한다고 가정한다.\n- A, B, C가 순차적으로 가는 상황에서 B가 길을 잘못 들어 분실되었다.\n- 하지만 목적지에서는 A, B, C 모두가 필요한지 모르고 A, C만 보고 모든 사람(패킷)이 왔다고 판단할 수 있다.\n- 이를 방지하고자 A, B, C라는 패킷에 **1, 2, 3과 같은 번호를 부여**해 **패킷의 분실 확인 처리를 수행**한다.\n  - 이후 **목적지에서는 이를 가지고 패킷을 재조립**한다.\n\n### 🪚 Flow Control\n송신측과 수신측 사이의 데이터 처리 속도 차이(흐름)을 해결하기 위한 기법이다. 만약 **송신측의 전송량보다 수신측의 처리량이 적을 경우**, 전송된 패킷은 수신측의 큐(버퍼)를 넘어 **손실**될 수 있기에 송신측의 패킷 전송량을 제어한다.\n\n1. **Stop & Wait(정지 - 대기)**\n매번 전송한 패킷에 대한 **확인 응답**을 받고, 그 다음 패킷을 전송한다.\n- 이 대기 시간은 RTT를 기준으로 지정한다.\n- 수신측과 송신측 간 이용할 데이터의 경로를 만들어두었지만, **대기하는 과정때문에 이에 대한 활용도가 떨어져 비효율적**이다.\n\n<img src=\"../../images/Network/stop&wait.jpg\" width=\"80%\">\n\n효율성을 계산해보면, 실제로 **송신측과 수신측을 왔다갔다하는 동안 겨우 1개의 패킷만을 전송**하는 것을 확인할 수 있다.\n\n2. **Sliding Window(슬라이딩 윈도우)** (or Pipelining)\nStop & Wait 방식의 비효율성을 개선한 기법이다. 수신측에서 설정한 **윈도우** 크기만큼 송신측에서 확인 응답 없이 패킷을 전송할 수 있도록 하여 **데이터의 흐름을 동적으로 조절**하는 기법이다.\n\n> **윈도우**\n> : 송신, 수신 양쪽에서 만든 버퍼의 크기\n> - 윈도우에 있는 데이터는 응용 계층에서 사용하기 전까지 계속 남아있다.\n\n<img src=\"../../images/Network/slidingWindow.jpg\" width=\"80%\">\n\n해당 기법에서 패킷은 다음과 같이 분류된다.\n- 송신측에서는 ACK을 수신하지 않더라도 여러 개의 패킷을 연속적으로 전송할 수 있다.\n- 수신측으로부터 ACK을 수신하게 되면, 해당 seq #에 해당하는 만큼 송신측의 윈도우가 오른쪽으로 이동하게 된다.\n\n### 🪚 Error Control\nTCP에서는 오류에 대한 제어를 하는데, 총 3가지의 제어가 존재한다.\n- 오류 검출과 패킷 재전송을 포함한다.\n- **ARQ(Automatic Repeat Request) 기법**을 사용해 패킷이 손상되었거나 손실되었을 경우, **재전송을 통해 오류를 복구**한다.\n- ARQ 기법은 흐름 제어와 관련이 있다.\n\n1. Stop & Wait ARQ\n송신측에서 1개의 패킷을 송신하고, 수신측에서 수신된 패킷의 에러 유무 판단에 따라 **ACK or NAK**을 보내는 방식이다.\n- 식별을 위해 데이터 패킷과 ACK은 각각 **번호 0, 1을 번갈아가며** 부여한다.\n- 수신측이 데이터를 받지 못한 경우 NAK을 보내고, NAK을 받은 송신측은 패킷을 재전송한다.\n- 만약 **데이터 패킷이나 ACK이 분실된 경우를 대비**해 송신측에서는 일정 간격의 시간동안 **Waiting**하다가, **타임아웃이 되면 패킷을 재전송**한다.\n\n2. Go-Back-n ARQ (슬라이딩 윈도우)\n전송된 패킷이 손상되거나 분실된 경우, ACK의 손실로 인한 TIME OUT이 발생한 경우, 확인된 마지막 패킷 이후의 모든 패킷을 재전송하는 방식이다.\n- 슬라이딩 윈도우는 연속적인 패킷 전송 기법으로, **송신측은 송신한 모든 패킷의 복사본을 가지고 있어야 하며, ACK과 NAK 모두 각각 구별**해야 한다.\n  - ACK: 다음 패킷 전송\n  - NAK: 손상된 패킷 자체 번호를 반환\n\n### 🪚 Congestion Control\n\n---\n\n## 🧷 UDP\nUser Datagram Protocol\n- **Unreliable**하다.\n  - Network 계층의 data를 응용 계층으로 바로 전달하기에 매우 단순한 구조이다.\n- **Connection-Less** (비연결형 프로토콜)\n- IP 데이터그램을 **캡슐화**하여 보내는 방법과, **연결 설정 없이** 보내는 방법을 제공한다.\n- **빠른 데이터 처리**를 요구하는 경우 사용할 수 있다.\n- TCP에서 필요했던 초기 연결 설정 메세지보다 적은 메세지를 요구한다.\n\n> 인터넷은 기본적으로 **Best-Effort Service**로, IP(Network)에서 제공되는 서비스를 그대로 이용하기에 신뢰성을 보장하지 않는다.\n> - 따라서 UDP segment는 손실 혹은 순서가 맞지 않을 수 있다. (**lost or out-of-order delivery**)\n\n> **사용하는 이유?**\n> - 데이터의 안전한 전송보다 **속도가 중요한 경우**를 위해 사용한다.\n> - streaming multimedia applications에 사용한다.\n>   - **loss에는 관대**하지만, **rate에 민감**한 애플리케이션의 경우\n> - SNMP는 네트워크 상태에 대한 query를 보내고, 이에 대한 응답을 받는다.\n\n### 🪚 UDP checksum\n<img src=\"http://lh6.ggpht.com/_Os5qf5urx_A/S1B1EpS_XnI/AAAAAAAABBQ/UsVTN1y5qzU/s400/udp_header.png\" width=\"80%\">\n\nUDP 패킷의 헤더를 보면, `checksum` 이라는 정보가 있다. 이는 패킷에 **error의 유무를 저장하는 정보**로, 에러가 있는 경우 해당 패킷을 삭제할 수 있도록 한다.\n- **UDP에서 왜 error를 확인할까?**: 이는 전송하려는 Data 자체의 error인지, 전달해주려는 port #의 error인지 모르기 때문에 error에 대한 확인을 수행한다.\n\n그렇다면 이 `checksum` 은 어떻게 계산할까?\n- **송신측**에서는 UDP segment(header와 data 모두)의 내용물을 모두 16-bit integer의 연속으로 취급하여 모두 더한다.\n  - 이후 **결과에 대한 1의 보수**를 취한 것이 `checksum` 이 된다.\n  - 결과에 올림이 발생한다면 이 또한 더한다.\n- **수신측**에서는 송신측과 동일하게 받은 segment에 대한 `checksum` 을 계산한다.\n  - 받은 segment의 checksum과 다르다면, error가 감지된 것이고, 해당 segment를 삭제한다.\n  - 같다면, 해당 segment를 수용한다.\n\n### 🪚 3-way handshake & 4-way handshake\n**연결 성립**\n\n<img src=\"https://velog.velcdn.com/images%2Fxx0hn%2Fpost%2Fb8c269b8-760a-4d5a-9b87-ba0dbe9d0c62%2Fwhat-is-a-tcp-3-way-handshake-process-three-way-handshaking-establishing-connection-6a724e77ba96e241.jpeg\" width=\"80%\">\n\n1. 클라이언트는 서버에 접속을 요청하는 `SYN` 패킷을 전송한다. (그리고 해당 패킷의 `seq #` 는 M이라 한다.)\n2. 서버는 `SYN` 패킷을 받아 클라이언트에게 요청을 수락한다는 의미의 `ACK(M + 1)` 패킷과, `SYN(N)` 을 전송한다.\n3. `ACK(M + 1)` 을 받은 클라이언트는 서버에게 `ACK(N + 1)` 패킷을 보냄으로써 연결이 성립된다.\n\n**연결 해제**\n<img src=\"https://velog.velcdn.com/images%2Fxx0hn%2Fpost%2F536dfd93-2252-4dce-bc11-b9f6c44fa2dd%2F99229C485C1D90C038.png\" width=\"80%\">\n\n1. 클라이언트가 연결을 종료하겠다는 `FIN` 플래그를 전송한다.\n2. 서버는 클라이언트의 연결 종료 요청 (`FIN`)을 받고, 확인용으로 `ACK` 를 전송한다.\n   1. 이후 남은 데이터를 모두 보낼 때까지 잠깐 **TIME OUT**된다.\n3. 데이터를 모두 보내고, 통신이 끝났다면 연결이 종료되었다고 클라이언트에게 `FIN` 플래그를 전송한다.\n4. 클라이언트는 `FIN` 메세지를 확인했다는 `ACK` 을 전송한다.\n5. 클라이언트의 `ACK` 을 받은 서버는 소켓 연결을 종료한다.\n6. 클라이언트는 아직 서버로부터 받지 못한 데이터가 있을 것을 대비해 일정 시간 동안 잉여 패킷을 기다린다. (**WAITING TIME**)\n\n---\n\n## 📕 참고\n- [Transport Layer 개요 (Multiplexing, Demultiplexing)](https://ddongwon.tistory.com/79)\n- [[TCP] 3-way-handshake & 4-way-handshake](https://asfirstalways.tistory.com/356)\n- [TCP와 UDP](https://github.com/WooVictory/Ready-For-Tech-Interview/blob/master/Network/)\n- [TCP 패킷](https://evan-moon.github.io/2019/11/10/header-of-tcp/)\n- [UDP 소개](https://www.joinc.co.kr/w/Site/TCP_IP/IntroUDP)"},{"excerpt":"네이버 D2 블로그를 읽던 중 역직렬화라는 개념을 발견했다. 그래서 자바의 직렬화와 역직렬화가 무엇인지에 대해 정리하려 한다. 📍 직렬화와 역직렬화 📝 직렬화 \"객체를 직렬화하여 전송 가능한 형태(byte)로 만드는 것\"을 의미한다. 객체들의 데이터를 연속적인 데이터로 변형하여 스트림을 통해 데이터를 읽도록 해준다. 주로 객체들을 통째로 파일로 저장하거나…","fields":{"slug":"/[Java지식]직렬화&역직렬화/"},"frontmatter":{"date":"June 19, 2022","title":"📃 직렬화(Serialization)와 역직렬화(Deserialization)","tags":["Java"]},"rawMarkdownBody":"\n네이버 D2 블로그를 읽던 중 역직렬화라는 개념을 발견했다. 그래서 자바의 직렬화와 역직렬화가 무엇인지에 대해 정리하려 한다.\n\n## 📍 직렬화와 역직렬화\n### 📝 직렬화\n\"객체를 직렬화하여 전송 가능한 형태(byte)로 만드는 것\"을 의미한다. 객체들의 데이터를 연속적인 데이터로 변형하여 스트림을 통해 데이터를 읽도록 해준다.\n- 주로 객체들을 통째로 파일로 저장하거나 전송할 때 사용한다.\n- 또한 JVM의 메모리에 상주(힙 또는 스택)되어 있는 객체 데이터를 바이트 형태로 변환하는 기술이라고도 한다.\n\n### 📝 역직렬화\n\"직렬화된 파일 등을 역으로 직렬화하여 다시 객체의 형태로 만드는 것\"을 의미한다. 저장된 파일을 읽거나 전송된 스트림 데이터를 읽어 원래 객체의 형태로 복원한다.\n\n---\n\n## 📍 직렬화 가능한 클래스\n직렬화를 하기 위해서는 전제조건이 있다. 바로 **\"직렬화가 가능한 클래스를 먼저 만드는 것\"** 이다.\n- 그리고 이는 `Serializable` 을 통해 정할 수 있다.\n\n```java\npublic class A {\n\n}\n\n// 이러한 형태라면\n\npublic class A implements Serializable {\n\n}\n```\n\n- 위와 같이 직렬화가 가능한 클래스 A에 **`Serializable` 인터페이스를 implements**하면 된다.\n  - 하지만 단순히 인터페이스를 구현한다고 해서 직렬화 대상이 되는 것은 아니다.\n  - 여러 상황에 따라 직렬화 가능한 클래스와 데이터가 결정된다.\n\n### 📝 Serializable 인터페이스를 implements\n이는 위 예시와 같이 `Serializable` 인터페이스를 구현하는 클래스로 만드는 것이다.\n\n### 📝 Serializable 없는 경우\n보통의 경우는 직렬화가 불가능하다. 하지만 클래스들간의 관계를 고려해보면, 가능한 경우도 있다. \n- 바로 **`Serializable` 인터페이스를 구현한 클래스를 상속받은 경우**이다.\n\n<img src=\"../../images/직렬화1.jpeg\" width=\"40%\">\n\n- 클래스 A는 `Serializable` 인터페이스를 구현하고 있고, 클래스 B는 이를 상속받고 있다.\n- **클래스 B는 직렬화 가능한 클래스가 된다.**\n\n### 📝 transient를 이용하여 직렬화 대상에서 제외하기\n보통 클래스의 멤버변수 전부 직렬화 대상에 해당된다. 하지만 보안 등의 이유로 일부 변수를 제외해야 할 경우가 있다.\n- 이때, `transient` 를 통해 이를 지정할 수 있다.\n\n```java\npublic class User implements Serializable {\n  private String id;\n  private String password;\n  private String email;\n\n  ...\n}\n\n// 비밀번호는 중요한 정보이므로 직렬화에서 제외하고 싶다.\n\npublic class User implements Serializable {\n  private String id;\n  private transient String password;\n  private String email;\n\n  ...\n}\n```\n\n### 📝 다른 객체를 멤버 변수로 가지고 있는 경우\n`int`, `long`, `String` 등 기본 자료형 뿐 아니라 다른 객체를 멤버 변수로 사용하는 경우가 많다. 이런 경우는 어떨까\n\n```java\npublic class User implements Serializable {\n  private String id;\n  private transient String password;\n  private String email;\n\n  ItemInfo itemInfo;\n  Calendar regDate;\n\n  ...\n}\n```\n- 아이템정보를 가지고 있는 `ItemInfo` 클래스와 가입일자를 나타내는 `Calendar` 클래스의 멤버 변수를 가지고 있다.\n- 이때 두 클래스들 중 **`Serializable` 인터페이스를 구현한 클래스가 하나라도 없다면 직렬화할 수 없다.**\n\n> `Calendar` 클래스는 `java.util` 의 기본 제공 클래스로, `Serializable` 를 구현한 클래스이다. 따라서 `User` 클래스는 직렬화가 가능하다.\n\n---\n\n## 📍 직렬화 구현\n**사용할 클래스**\n```java\npublic class User implements Serializable{\n    private String name;\n    private transient String password;\n    private String email;\n    private int age;\n    \n    public User(String name, String password, String email, int age) {\n        this.name = name;\n        this.password = password;\n        this.email = email;\n        this.age = age;\n    }\n    \n    public String toString() {\n        return \"(\" + name + \", \" + password + \", \" + email + \", \" + age + \")\";\n    }\n}\n```\n\n**직렬화와 역직렬화**\n- `ObjectOutputStream` 객체와 `ObjectInputStream` 객체를 사용한다.\n\n```java\npublic class Main {\n  private static final String USERINFO_SER = \"user.ser\";\n\n  public static void main(String[] args) {\n    conductSerializing();\n    conductDeserializing();\n  }\n\n  private static void conductSerializing() {\n      try (FileOutputStream fos = new FileOutputStream(USERINFO_SER);\n            BufferedOutputStream bos = new BufferedOutputStream(fos);\n            ObjectOutputStream out = new ObjectOutputStream(bos)) {\n          User u1 = new User(\"신짱구\", \"1234\", \"jjanggu@abc.com\", 5);\n          User u2 = new User(\"봉미선\", \"5678\", \"misun@abc.com\", 27);\n\n          ArrayList<User> list = new ArrayList<>();\n          list.add(u1);\n          list.add(u2);\n\n          out.writeObject(u1);\n          out.writeObject(u2);\n          out.writeObject(list);\n          System.out.println(\"직렬화 완료\");\n      } catch (Exception e) {\n          e.printStackTrace();\n      }\n  }\n\n  private static void conductDeserializing() {\n      try (FileInputStream fis = new FileInputStream(USERINFO_SER);\n              BufferedInputStream bis = new BufferedInputStream(fis);\n              ObjectInputStream in = new ObjectInputStream(bis)) {\n          User u1 = (User) in.readObject();\n          User u2 = (User) in.readObject();\n          ArrayList<User> list = (ArrayList<User>) in.readObject();\n\n          System.out.println(u1.toString());\n          System.out.println(u2.toString());\n          System.out.println(list.toString());\n      } catch (Exception e) {\n          e.printStackTrace();\n      }\n  }\n}\n```\n\n결과는 다음과 같다.\n\n<img src=\"../../images/직렬화,역직렬화결과.png\" width=\"60%\">\n\n- `conductSerializing()` 에서 직렬화를 수행하여 `user.ser` 파일을 생성하고, 이를 읽어서 바로 역직렬화를 수행한다.\n  - 역직렬화 결과를 보면, 직렬화한 순서가 그대로 출력되고 있다. **즉, 직렬화와 역직렬화는 순서를 보장한다.**\n  - 순서가 맞지 않다면, 역직렬화에 실패한다.\n\n---\n\n## 📍 SerialVersionUID, 클래스의 버전관리\n직렬화를 수행하면, 내부에서 자동으로 `SerialVersionUID` 라는 고유의 번호를 생성하여 관리한다. \n- 이는 직렬화와 역직렬화 시 중요한 역할을 수행한다.\n- 이 값이 맞는지 확인한 후 처리를 수행하기 때문이다. 일치하지 않다면 `java.io.InvalidClassException` 예외가 발생한다.\n\n소스 상에서 UID를 선언하지 않아도 내부에서 자동으로 생성하여 관리한다. 하지만 생성 당시의 UID와 변경한 이후의 UID가 맞지 않아 예외가 발생하는데, 서비스 배포 후 객체의 변경은 수도 없이 발생할 것이고, 그때마다 컴파일하고 배포한다면, 매우 불편할 것이다!\n\n따라서 Java에서는 **`SerialVersionUID` 를 직접 선언하고 관리하는 방식을 적극 권장**한다.\n\n### 📝 SerialVersionUID를 추가\n```java\nclass User implements Serializable {\n  private static final long serialVersionUid = 1L;\n\n  private String name;\n  private transient String password;\n  private String email;\n  private int age;\n\n  public User(String name, String password, String email, int age) {\n      this.name = name;\n      this.password = password;\n      this.email = email;\n      this.age = age;\n  }\n\n  public String toString() {\n      return \"(\" + name + \", \" + password + \", \" + email + \", \" + age + \")\";\n  }\n}\n```\n- `1L` 은 각자 변경하면 되고, 이렇게 선언한다면 추후 `User` 클래스에 변경이 생길지라도 UID가 여전히 1이므로 역직렬화를 성공적으로 할 수 있다.\n \n---\n\n## 📍 직렬화를 주로 어디에 사용하는가\nJVM의 메모리에만 상주되어 있는 객체 데이터를 그대로 **영속화(persist)** 할 때 사용한다.\n- 시스템이 종료되어도 없어지지 않는 장점을 가지며 영속화된 데이터이기 때문에 네트워크로 전송도 가능하다.\n- 필요할 때 직렬화된 객체 데이터를 가져와서 역직렬화하여 객체를 바로 사용할 수 있게 된다.\n\n**서블릿 세션**\n- 서블릿 세션은 대부분 세션의 Java 직렬화를 지원하고 있다. \n- 단순히 세션을 서블릿 메모리 위에서 운용한다면 직렬화가 필요없지만, 파일로 저장하거나 세션 클러스터링, DB를 저장하는 옵션 등을 선택하게 되면 세션 자체가 직렬화된 채로 저장되어 전달된다.\n\n**캐시**\n- 주로 DB를 조회한 후 가져온 데이터 객체 같은 경우 실시간 형태로 요구하는 데이터가 아니라면 저장소를 이용해 데이터 객체를 저장한 후 동일한 요청이 오면 DB를 다시 요청하는 것이 아니라 저장된 객체를 찾아 응답하게 하는 형태를 캐시를 사용한다고 한다.\n- 캐시를 이용하면 DB 리소스를 절약할 수 있어 자주 활용되고, 이렇게 캐시할 부분을 자바 직렬화된 데이터를 저장해서 사용된다.\n \n## 📕 참고\n- [Java 객체 직렬화(Serialization) 와 역직렬화(Deserialization)](https://flowarc.tistory.com/entry/Java-%EA%B0%9D%EC%B2%B4-%EC%A7%81%EB%A0%AC%ED%99%94Serialization-%EC%99%80-%EC%97%AD%EC%A7%81%EB%A0%AC%ED%99%94Deserialization)\n- [Java 직렬화를 하는 이유가 무엇일까?](https://velog.io/@sa1341/Java-%EC%A7%81%EB%A0%AC%ED%99%94%EB%A5%BC-%ED%95%98%EB%8A%94-%EC%9D%B4%EC%9C%A0%EA%B0%80-%EB%AC%B4%EC%97%87%EC%9D%BC%EA%B9%8C)"},{"excerpt":"스프링 핵심 원리 - 기본편을 들으며 정리하는 POST입니다. 🎯 EJB? 옛날에는 자바 진영의 표준 기술인 Enterprise Java Beans라는 기술을 많이 사용했다. 그래서 당시에는 기술 영업 시에 이를 가지고 많이 했다. 자바 표준 기술이니까! 하지만, EJB는 매우 어렵고, 복잡하고, 느리다는 문제가 있었다.  EJB를 사용하기 위해서는 인터…","fields":{"slug":"/[스프링핵심원리_기본편]1.객체지향설계와스프링/"},"frontmatter":{"date":"June 18, 2022","title":"📟 1. 객체 지향 설계와 스프링","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)을 들으며 정리하는 POST입니다.</strong></em>\n\n## 🎯 EJB?\n옛날에는 자바 진영의 표준 기술인 **Enterprise Java Beans**라는 기술을 많이 사용했다. 그래서 당시에는 기술 영업 시에 이를 가지고 많이 했다.\n- 자바 표준 기술이니까!\n\n하지만, EJB는 **매우 어렵고, 복잡하고, 느리다**는 문제가 있었다. \n- EJB를 사용하기 위해서는 인터페이스 구현, 의존적인 구현이 필요했다. (EJB 지옥이라는 말이..)\n\n그래서, 원초적으로 돌아가자, \"오래된 방식의 간단한 자바를 사용하자\"는 측면에서 **POJO(Plain Old Java Object)** 라는 용어도 등장했다.\n\nEJB의 단점으로 인해, 두 명의 개발자가 오픈 소스 프로젝트를 시작했고,\n- 그것이 바로 **스프링 프레임워크와 하이버네이트**의 시초가 되었다.\n- **스프링 프레임워크는 EJB 컨테이너를 대체**하고, **하이버네이트는 EJB Entity Bean 기술을 대체**했다. \n  - 하이버네이트를 이용해 **현재의 JPA라는 표준 인터페이스를 만들었다.** (인터페이스의 구현을 하이버네이트, EclipseLink와 같은 구현체들이 담당)\n\n---\n\n## 🎯 스프링의 역사\n2002년 Rod Johnson이 EJB의 문제점을 지적하는 책을 출간했고, 이 책이 스프링의 시초가 되었다.\n- EJB 없이도 고품질의 애플리케이션 개발이 가능함을 보이고,\n- 지금의 스프링의 핵심 개념과 코드들을 다루었다.\n- 또한, `BeanFactory` , `ApplicationContext` , `POJO` , `IoC` , `DI` 에 대해서도 다루었다.\n\n### 🪔 스프링이란?\n스프링은 단순히 한 기술을 말하는 것이 아닌, 여러 기술의 복합체라고 할 수 있다.\n- 스프링 프레임워크, 스프링 부트\n- 스프링 데이터, 세션, 시큐리티, Rest Docs, 배치, 클라우드 등\n\n### 🪔 스프링 프레임워크\n스프링 프레임워크는 또한 아래와 같은 기술들로 구성된다.\n- **핵심 기술**: 스프링 DI 컨테이너, AOP, 이벤트, 기타\n- 웹 기술: 스프링 MVC, 스프링 WebFlux\n- 데이터 접근 기술: 트랜잭션, JDBC, ORM, XML 지원\n- 기술 통합: 캐시, 이메일, 원격접근, 스케줄링\n- 테스트: 스프링 기반 테스트 지원\n- 언어: 코틀린, 그루비\n\n### 🪔 스프링 부트\n스프링을 굉장히 편리하게 사용할 수 있도록 돕는 기술이다.\n- 단독으로 실행할 수 있는 스프링 애플리케이션을 쉽게 생성\n- 톰캣 같은 웹 서버를 내장해 별도의 웹 서버 설치가 필요없음\n- 손쉬운 빌드 구성을 위해 starter 종속성 제공\n- 스프링과 써드 파티 라이브러리 자동 구성\n- 메트릭, 상태 확인, 외부 구성 같은 프로덕션 준비 기능 제공\n- 관례에 의한 간결한 설정\n\n### 🪔 스프링을 만든 이유?\n**스프링의 핵심 개념**\n- 자바 언어 기반의 프레임워크\n  - 가장 큰 특징 - **객체 지향 언어**\n- 스프링은 이 특징을 살려내는 프레임워크\n\n\"**좋은 객체 지향 애플리케이션을 개발할 수 있도록 도와주는 프레임워크**\"\n\n> \"EJB는 객체 지향의 장점을 살리지 못하는 기술이었다!\"\n\n---\n\n## 🎯 객체 지향의 특징\n추상화, 캡슐화, 상속, **다형성** \n\n객체 지향 프로그래밍은 컴퓨터 프로그램을 **객체들의 모임**으로 보기에, **프로그램을 유연하고 변경이 용이**하게 만들 수 있다.\n\n---\n\n## 🎯 다형성의 실세계 비유\n세상을 **역할과 구현**으로 구분한다!\n\n### 🪔 운전자 - 자동차\n<img src=\"../../images/스프링핵심원리-기본편/운전자-자동차.png\" width=\"60%\">\n\n자동차의 **역할**을 서로 다른 3개의 모델이 **구현**을 하고 있다.\n- 운전자는 K3를 타다가, 아반떼로 갈아타도 운전이라는 **역할을 수행**할 수 있다.\n  - 단지 **구현이 변경**된 것뿐이고, 운전자에게는 영향이 없다.\n\n이는 **자동차의 역할의 인터페이스를 따라 각 모델이 구현**했기 때문이다.\n- 운전자는 자동차의 역할에 대해서만 인지하고 있다.\n- 그리고 이는 운전자(클라이언트)를 위함이다.\n  - 운전자는 내부 구현의 변경은 영향이 없고, 알 필요가 없다.\n- 따라서 이러한 다형성을 통해 **클라이언트에 영향을 주지 않고 새로운 기능(자동차)을 제공할 수 있게 된다.**\n\n### 🪔 역할과 구현을 분리\n역할과 구현으로 구분하면 세상이 **단순**해지고, **유연**해지며 **변경**도 편리해진다.\n\n**장점**\n- 클라이언트는 대상의 역할(인터페이스)만 알면 된다.\n- 클라이언트는 구현 대상의 **내부 구조를 몰라도** 된다.\n- 클라이언트는 구현 대상의 **내부 구조가 변경되어도 영향을 받지 않는다.**\n- 클라이언트는 **구현 대상 자체를 변경**해도 영향을 받지 않는다. (테슬라 -> K3)\n\n### 🪔 자바에서의 다형성 차용\n- 자바 언어의 다형성 활용\n  - 역할 = 인터페이스\n  - 구현 = 구현 클래스(객체)\n- 객체 설계 시 **역할과 구현을 명확히 분리**\n- 객체 설계 시 **역할(인터페이스)을 먼저 부여**하고, 해당 역할을 수행하는 구현 객체 생성 (역할이 더 중요하다!)\n\n**오버라이딩**\n- 오버라이딩은 자바 기본 문법으로 오버라이딩된 메소드가 실행된다.\n- 다형성으로 인터페이스를 구현한 객체를 실행 시점에 유연하게 변경할 수 있다.\n- 클래스 상속 관계도 다형성, 오버라이딩 적용이 가능하다.\n\n### 🪔 다형성의 본질\n- 인터페이스를 구현한 객체 인스턴스를 **실행 시점**에 **유연하게 변경**할 수 있다.\n- 협력이라는 객체 사이의 관계가 주요한 개념이다.\n- **클라이언트를 변경하지 않고, 서버의 구현 기능을 유연하게 변경할 수 있다!**\n\n### 🪔 한계점\n- 역할(인터페이스) 자체가 변경되면, 클라이언트와 서버 모두 큰 변경이 발생한다.\n\n> 그래서 더더욱 **안정적인 인터페이스이 설계가 중요**하다.\n\n---\n\n## 🎯 스프링과 객체 지향\n- 다형성이 가장 중요하다.\n- 스프링은 다형성을 극대화해서 이용할 수 있게 도와준다.\n- 스프링에서 다루는 IoC, DI는 다형성을 활용해서 역할과 구현을 편리하게 다룰 수 있도록 지원한다.\n\n> 따라서 스프링을 통해 구현을 편리하게 변경할 수 있다.\n\n---\n\n## 🎯 좋은 객체 지향 설계의 5가지 원칙 - SOLID\nSOLID: 좋은 객체 지향 설계의 5가지 원칙\n\n### 🪔 SRP\nSingle Responsibility Principle, 단일 책임 원칙\n\n- 한 클래스는 하나의 책임만 가져야 한다.\n- 하나의 책임이라는 것은 모호하다. \n  - 클 수 있고, 작을 수 있다.\n  - 문맥과 상황에 따라 다르다.\n- **중요한 기준은 변경**이다. 변경이 있을 때 파급 효과가 적다면, 단일 책임 원칙을 잘 따른 것이다.\n  - ex. UI 변경, 객체의 생성과 사용을 분리\n\n### 🪔 OCP\nOpen/Closed Principle, 개방-폐쇄 원칙, 가장 중요한 원칙\n\n- **SW요소는 확장에는 열려 있으나 변경에는 닫혀 있어야 한다.**\n- **다형성**을 생각해보자.\n- 인터페이스를 구현한 새로운 클래스를 하나 만들어서 새로운 기능을 구현\n  - 역할과 구현의 분리를 떠올리자!\n  - 이는 기존 코드의 변경을 유발하지 않는다!!!\n\n**문제점**\n- `MemberService` 클라이언트가 직접 구현 클래스를 선택한다.\n\n```java\nMemberRepository m = new MemoryMemberRepository(); // 기존 코드\nMemberRepository m = new JdbcMemberRepository(); // 변경 코드\n```\n\n- **구현 객체를 변경하기 위해서는 위와 같이 클라이언트 코드를 변경**해야 한다!\n  - 이는 **다형성을 사용**했지만, **OCP 원칙을 지킬 수 없게 되었다.** (변경이 발생했으므로)\n  \n> 문제 해결을 위해, **객체를 생성하고, 연관관계를 맺어주는 별도의 조립, 설정자가 필요**하다.\n> - 그리고 이는 **스프링 컨테이너**가 해준다.\n\n### 🪔 LSP\nLiskov Substitution Principle, 리스코프 치환 원칙\n\n- 프로그램 객체는 프로그램의 정확성을 깨뜨리지 않으면서 하위 타입의 인스턴스로 바꿀 수 있어야 한다.\n- 다형성에서 하위 클래스는 인터페이스 규약을 다 지켜야 한다는 것, 다형성을 지원하기 위한 원칙, 인터페이스를 구현한 구현체는 믿고 사용하려면, 이 원칙이 필요하다.\n- 컴파일에 성공하는 것을 넘어서는 원칙\n- ex. 자동차 인터페이스의 엑셀은 앞으로 가라는 기능이다. \n  - 만약 뒤로 가게 구현한다면 이는 LSP를 위반한 것이다.\n  - 느리더라도 앞으로 가야 한다.\n\n### 🪔 ISP\nInterface Segregation Principle, 인터페이스 분리 원칙\n\n- 특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나보다 낫다.\n- 자동차 인터페이스 -> 운전 인터페이스, 정비 인터페이스로 분리\n- 사용자 인터페이스 -> 운전자 클라이언트, 정비사 클라이언트로 분리\n- 분리하면 정비 인터페이스 자체가 변해도 운전자 클라이언트에 영향을 주지 않는다!\n- **인터페이스가 명확해지고, 대체 가능성이 높아진다.**\n\n### 🪔 DIP\nDependency Inversion Principle, 의존관계 역전 원칙, 가장 중요한 원칙\n\n- \"추상화에 의존해야지, 구체화에 의존하면 안된다.\" 의존성 주입은 이 원칙을 따르는 방법 중 하나다.\n- **구현 클래스에 의존하지 말고, 인터페이스에 의존하라**는 의미다.\n- **역할(Role)에 의존하게 해야 한다**는 것과 같은 말이다. 구현체에 의존하게 되면, 변경이 아주 어려워진다.\n\nOCP에서 설명한 `MemberService` 는 **인터페이스에 의존하지만, 구현 클래스에도 동시에 의존**한다.\n- `MemberService` 클라이언트가 구현 클래스를 직접 선택하기 때문이다.\n  - `MemberRepository m = new MemoryMemberRepository();`\n- **DIP를 위반하고 있다.**\n\n> **다형성은 객체 지향의 핵심**이지만, **이것만으로는 OCP, DIP를 지킬 수 없다.**\n\n---\n\n## 🎯 객체 지향 설계와 스프링\n스프링은 다음 기술로 **다형성 + OCP, DIP를 가능하게 지원**한다!\n- DI(Dependency Injection): 의존관계, 의존성 주입\n- DI 컨테이너 제공\n\n이를 통해 **클라이언트 코드의 변경없이 기능을 확장**시킬 수 있게 된다.\n\n### 🪔 정리 - 실무 고민\n- 인터페이스를 도입하면 추상화라는 비용이 발생한다.\n- 기능을 확장할 가능성이 없다면, 구체 클래스를 직접 사용하고, 향후 꼭 필요할 때 **리팩토링**을 통해 인터페이스를 도입하는 것도 방법이다.\n\n## 📌 중요한 개념\n객체지향, 다형성\n\n## 📕 참고\n- [스프링 핵심 원리 - 기본편](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard)"},{"excerpt":"해당 포스트를 읽으면서 느낀 점, 생각한 것들을 자유롭게 적는 POST입니다. 🧷 생각해본 것들 & 알게 된 것들 & 찾아봐야 할 것들 (생) 미디어 플랫폼의 특성 상 Spring 프레임워크에서 제공하는 Mock MVC와 같은 테스트 도구를 사용하지 못했다고 하는데, 그렇다면 테스트가 완벽하게 진행되긴 어려웠을텐데, 어떤 식으로 테스트를 진행한 것일까 (…","fields":{"slug":"/[읽을거리]테스트자동화/"},"frontmatter":{"date":"June 18, 2022","title":"📰 테스트 자동화","tags":["읽을거리","테스트","자동화"]},"rawMarkdownBody":"\n해당 포스트를 읽으면서 느낀 점, 생각한 것들을 자유롭게 적는 POST입니다.\n\n## 🧷 생각해본 것들 & 알게 된 것들 & 찾아봐야 할 것들\n1. (생) 미디어 플랫폼의 특성 상 Spring 프레임워크에서 제공하는 Mock MVC와 같은 테스트 도구를 사용하지 못했다고 하는데, 그렇다면 테스트가 완벽하게 진행되긴 어려웠을텐데, 어떤 식으로 테스트를 진행한 것일까\n\n2. (알) Maven 빌드 도구에서는 특정 단위 테스트만 진행할 수 있도록 하는 기능을 제공한다.\n\n3. (알) Jenkins의 'GitHub pull request builder'라는 플러그인을 통해 코드 리뷰 단계에서 배포 가능 여부를 판단할 수 있다.\n\n4. (찾) 일반 API 트래픽과 미디어 스트림 트래픽의 차이가 뭘까\n\n5. (찾) 병목 현상이 뭘까\n\n6. \n\n## 🧷 느낀 점\n- 테스트는 매우매우 중요하다. 그만큼 테스트 케이스도 중요하지만 비용이 많이 든다. 나도 테스트 자동화라는 것을 경험해보고 싶다.\n\n\n\n## 📕 참고\n- [서버 사이드 테스트 자동화 여정 - 1. 테스트 자동화를 시작한 계기와 그 첫 발걸음](https://engineering.linecorp.com/ko/blog/server-side-test-automation-journey-1/)\n- [서버 사이드 테스트 자동화 여정 - 2. 통합 테스트 수준의 회귀 테스트 환경 구축 및 Docker 활용](https://engineering.linecorp.com/ko/blog/server-side-test-automation-journey-2)"},{"excerpt":"OSI 7 계층은 왜 나누는 것일까? OSI 7계층은 네트워크 통신을 구성하는 요소를 7개의 계층으로 표준화한 것으로, 이를 통해 통신이 일어나는 과정을 단계별로 파악할 수 있고, 문제 발생 시 해당 문제를 파악하고 해결하기 용이해진다. OSI 7계층과 TCP/IP 5계층 OSI 7계층 중  &  계층은 TCP/IP의  계층에 속한다. OSI 7계층이 표…","fields":{"slug":"/[Network]ApplicationLayer/"},"frontmatter":{"date":"June 13, 2022","title":"📡 Application Layer","tags":["Network","OSI","Application"]},"rawMarkdownBody":"\n> **OSI 7 계층은 왜 나누는 것일까?**\n> - OSI 7계층은 네트워크 통신을 구성하는 요소를 7개의 계층으로 표준화한 것으로, 이를 통해 통신이 일어나는 과정을 단계별로 파악할 수 있고, 문제 발생 시 해당 문제를 파악하고 해결하기 용이해진다.\n\n> **OSI 7계층과 TCP/IP 5계층**\n> - OSI 7계층 중 `Presentation` & `Session` 계층은 TCP/IP의 `Application` 계층에 속한다.\n> - OSI 7계층이 표준이 되기는 하지만, 실질적인 통신은 TCP/IP 5계층을 사용한다!\n\n## 🧷 Application Layer\nTCP/IP 네트워크 프로토콜 스택에서 가장 상위 계층을 담당하고 있다. 이름대로, **여러 End System에게 여러 서비스를 제공하거나 받는 부분**을 책임진다. **응용 계층**이라고도 한다.\n\n> **\"이메일, 웹 서핑 등과 같은 서비스를 제공하고 받기 위해 어떤 형식으로 메시지를 주고 받아야 하는지의 프로토콜들이 정의되어 있는 계층\"**\n\n### 🪚 구조\n대부분의 응용 계층들은 **\"Client - Server\" 구조**로 이루어져 있다.\n- **Client**는 서비스를 제공받는 호스트를 의미한다.\n  - `Dynamic IP 주소` 를 가질 수 있으며, Client끼리는 직접 통신이 불가능하다.\n- **Server**는 서비스를 제공해주는 호스트를 의미한다.\n  - `always-on host` 로, Client의 요청을 대기한다.\n  - `Permanent IP 주소` 를 가져야 한다. (항상 할당되어있어야 함)\n\n\"Client - Server\" 구조 외에, **P2P 구조**도 있다. 이는 임의의 `End System` 끼리 통신하는 방식이다.\n- Client, Server의 구분이 없다.\n- Peer는 다른 Peer에게 서비스를 요청한다.\n- `No always-on Server`\n- P2P File sharing이 이 방식을 이용한다.\n\n### 🪚 Process Communicating\n프로그램과 프로그램 간의 통신은 사실 해당 프로그램들의 **프로세스의 통신**이다.\n- 같은 호스트에서 두 프로세스는 **IPC(Inter-process Communication) 방식**을 이용하여 통신이 가능하다.\n- 서로 다른 호스트에서는 **message**를 통해 통신이 가능하다.\n  - 여기서도 Client, Server를 구분할 수 있는데,\n    - Client process: Communication 시작\n    - Server process: Client의 요청 대기\n\n### 🪚 Sockets\nTCP/IP 프로토콜 스택에서는 총 5개의 계층이 존재하고, 이들간의 패킷(데이터) 송수신이 이뤄진다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FbQz6ga%2FbtqT02qo7Z6%2FqYgs2gKVdUP6yEkzWhw7mk%2Fimg.png\" width=\"80%\">\n\nApplication 계층을 제외한 **나머지 4계층은 모두 OS에 구현**되어 있다.\n- 개발자에겐 보여지지 않는 부분이고, 내부적으로 알아서 패킷을 생성하고 주고 받는다.\n- 그렇다면, Application 계층과 나머지 4계층의 제일 윗단인 Transport 계층은 어떻게 메세지를 주고 받을 수 있을까?\n\n이때, **Socket**이라는 일종의 통로를 사용한다. \n- 이는 Application 계층과 Transport 계층 사이에 위치하여 Application 계층의 process에게 **Socket API나 함수를 제공**하여 메세지를 송수신할 수 있도록 돕는다.\n\n### 🪚 Addressing Processes\n메세지를 주고 받는 방법은 알았다. 하지만, 여러 Program이 있고, 그만큼 여러 Process가 존재할텐데, 어떤 Process가 메세지를 보냈는지 알아야 한다.\n- 이를 위해서는 Process를 식별할 수 있는 **식별자**가 필요하다.\n- 그리고 하나의 호스트에는 많은 process가 동작 가능하기에, **IP 주소만으로는 식별이 불가능**하다.\n\n따라서 **IP 주소 + Port #** 을 식별자로서 사용한다.\n- Port #은 아래와 같이 대표적으로 사용되는 예가 있다.\n  - HTTP server: 80\n  - HTTPS server: 443\n  - Mail server: 25\n  - Well Known Port #: 0 ~ 1024\n\n### 🪚 Application Layer Protocol Defines\n응용 계층 프로토콜의 규정이다. 아래에 대한 규정이 있어야 한다.\n\n1. Types of message exchange\n: message는 **요청** 또는 **응답**일 수 있다. (request or response)\n\n2. Message Syntax\n: message의 어느 field가 어떻게 기술되어야 하고, 각각의 field는 어떻게 구분되는지에 대한 정보\n\n3. Message Semantics\n: 각 field에 담긴 정보의 의미\n\n4. Rules\n: 언제, 어떻게 process들이 요청하고 응답해야 하는지에 대한 정보\n\n### 🪚 Transport Layer가 제공하는 Service\n응용 계층은 전송 계층과 통신한다. 전송 계층은 2가지 종류의 서비스를 제공할 수 있는데, 아래와 같다.\n- **Reliable한 Service**\n  - 데이터의 Write와 Read가 동일하게 발생하여 Sync가 맞다.\n  - ex. File transfer\n- **Unreliable한 Service**\n  - 데이터를 바로바로 전송하여 딜레이가 적다.\n  - ex. Audio\n\n### 🪚 Application Layer Protocols\n인터넷은 응용 계층에 2개의 전송 프로토콜을 제공한다. TCP(Transmission Control Protocol)과 UDP(User Datagram Protocol)이다.\n- 이는 응용 계층이 아니라 전송 계층의 프로토콜이다!\n\n---\n\n## 🧷 HTTP\nHTTP (Hyper Text Transfer Protocol)\n: 웹의 응용 계층 프로토콜이다.\n\n- 이는 클라이언트 프로그램과 서버 프로그램으로 구현된다.\n- 서로 다른 end system에서 수행되는 클라이언트와 서버 프로그램은 **HTTP 메세지를 통해 통신**한다.\n  - 기본적으로, 클라이언트는 **어떠한 자원(object)을 요청**하고, 서버는 이를 찾아 **응답**하는 형태이다.\n- 그리고 이는 신뢰성을 필요로 하므로, **TCP 프로토콜을 사용**한다.\n  - 통신은 \"연결 초기화(클라이언트) -> 연결 수락(서버) -> HTTP 메세지 교환 -> 연결 종료\"\n- HTTP는 **State-less**하다. 따라서, 과거 정보에 대한 관리를 하지 않는다.\n\n이러한 HTTP 연결에는 **두 가지 타입**이 존재하는데, 아래와 같다.\n\n**Non-persistent HTTP**\n- 이름 그대로, 영구적이지 않다. \n- 여러 객체의 교환을 위해서는 여러 개의 연결을 필요로 한다. (일회성 연결을 여러 번 사용)\n\n**Persistent HTTP**\n- 동일한 서버와 여러 번 통신하는 경우, 불필요하게 일회성 연결을 반복하는 것을 막고자 한다.\n- 연결 하나를 고정적으로 열어두고 사용한다.\n\nHTTP 프로토콜을 사용한 통신의 `response time` 을 구하기 위해 간단한 `Non-persistent HTTP` 에 대한 예제를 살펴본다.\n\n<img src=\"https://velog.velcdn.com/images%2Fkms9887%2Fpost%2F2d2d7518-b78c-47d2-89ec-00b9805aa03d%2Fimage.png\" width=\"50%\">\n\n- RTT(Round Trip Time): 클라이언트와 서버 간 패킷이 갔다 오는데 걸리는 시간\n- 그림에서 볼 수 있듯, 연결을 초기화하고, 자원 요청한 후 이를 받는데 걸리는 시간은 **2RTT + file transmission rate**이다.\n\n### 🪚 HTTP methods\nHTTP는 요청 메소드를 정의하여 주어진 자원에 수행하길 원하는 행동을 나타낸다. 주요 메소드는 아래와 같다.\n\n**GET**\n: 특정 자원의 표시를 요청한다. 이를 사용하는 요청은 오직 데이터를 받기만 한다.\n\n**HEAD**\n: GET 요청과 동일한 응답을 요청하지만, 응답 본문을 포함하지 않는다.\n\n**POST**\n: 특정 자원에 객체(엔티티)를 제출할 때 사용된다. 이는 서버의 상태 변화를 일으킬 수 있다.\n\n**PUT**\n: 요청 payload를 사용해 새로운 자원을 생성하거나, 기존의 자원을 수정하는 데 사용된다.\n\n**PATCH**\n: PUT은 자원 자체의 교체를 요구하지만, PATCH는 자원의 부분적인 수정만을 요청할 때 사용된다.\n\n### 🪚 GET & POST?\n두 메소드 모두 서버에 무엇인가를 요청할 때 사용하는 메소드이다. 하지만 HTTP 메소드의 목적은 특정 자원에 수행하길 원하는 행동을 명시하는 것이므로, 혼용되어서는 안된다. 따라서 두 메소드의 차이점을 알아본다.\n\n**GET**\n- 요청하는 데이터가 `HTTP Request Message` 의 `Header` 부분에 담겨서 전송된다. \n  - 때문에 `url` 상에서 `?` 뒤에 데이터가 붙어 요청을 보내게 되는 것이다. \n  - 이러한 방식은 `url` 에 요청하는 데이터가 담겨가기 때문에 **전송할 수 있는 데이터의 크기가 제한적**이다. \n  - 또한 **보안**이 필요한 데이터에 대해서는 데이터가 **그대로 노출되므로 적절하지 않다.** (ex. 비밀번호)\n- GET 요청은 캐싱될 수 있고, 브라우저 히스토리에 남는다.\n- 아스키 코드만 전송할 수 있다.\n\n**POST**\n- 요청하는 데이터가 `HTTP Request Message` 의 `Body` 부분에 담겨서 전송된다.\n  - **전송할 수 있는 데이터의 크기가 GET 방식보다 크고, 보안면에서 조금 더 낫다.** (하지만 암호화를 하지 않는다면, 언제든 노출될 수 있다.)\n- POST 요청은 캐싱될 수 없고, 브라우저 히스토리에 남지 않는다.\n- 데이터 타입에 구애받지 않는다. **이진 데이터 또한 가능**하다.\n\nGET은 **데이터를 가져와서 보여주는 용도**로 사용한다. 즉, **서버에 어떤 변경사항을 발생시키지 않는다.** 하지만 POST는 **서버의 값이나 상태를 변경하기 위해 사용**한다.\n\n또한, GET 요청은 캐싱될 수 있다고 했다. 그러므로, 기존에 캐싱되었던 데이터가 또다시 응답될 가능성이 있다. POST 방식으로 요청해야 할 데이터를 크기가 작다는 이유로 GET 방식으로 요청한다면, 목적에 맞지 않는 응답을 받을 가능성이 있다!\n\n### 🪚 HTTP response status code\nHTTP 응답 상태 코드는 특정 HTTP 요청(위에서 다룬 요청들)이 성공적으로 완료되었는지, 혹은 어떠한 문제가 발생했는지 알려준다. 응답은 총 5개의 그룹으로 나눠진다.\n- 정보를 제공하는 응답(1xx)\n- 성공적인 응답(2xx)\n- 리다이렉트(3xx)\n- 클라이언트 에러(4xx)\n- 서버 에러(5xx)\n\n그리고 흔하게 볼 수 있는 코드는 다음과 같다.\n\n**200**: 요청이 성공적으로 처리되었다. 그리고 이 성공이라는 의미는 HTTP 메소드에 따라 다르다.\n- GET: 자원을 불러와서 message body에 전송되었다.\n- HEAD: header가 message body에 있다.\n- PUT or POST: 수행 결과에 대한 자원이 message body에 전송되었다.\n\n**400**: 이 응답은 잘못된 문법으로 인해 서버가 요청을 이해할 수 없음을 의미한다.\n\n**401**: 비인증을 의미한다. 클라이언트는 요청한 응답을 받기 위해 스스로를 인증해야 한다.\n\n**404**: 서버는 요청받은 자원을 찾을 수 없다. \n- 서버들은 비인증 클라이언트로부터 자원을 숨기기 위해 이 응답을 403 대신에 전송할 수도 있다.\n\n**418**: 서버는 커피를 찻 주전자에 끓이는 것을 거절한다.\n\n**500**: Internal Server Error, 서버가 처리 방법을 모르는 상황이 발생했음을 의미한다.\n- 서버 개발자라면 가장 많이 볼 수 있을 코드이다...\n\n---\n\n## 🧷 HTTP/2\n이전까지 언급한 HTTP/1.1은 Persistent HTTP로, TCP 통신 1개당 요청 1개를 고정적으로 처리해야 하는 구조였다.\n- 하지만 여러 요청이 있고, 제일 먼저 처리되는 요청의 요청량이 매우 많은 경우, 뒤의 요청들은 대기해야 한다.\n  - 이를 **Head-Of-Line Blocking 문제**라 한다. 그리고 이는 HTTP/2에서 해결하고 있다.\n\n### 🪚 HTTP/2: HOL blocking 해결\n<img src=\"../../images/Network/HOLblocking.jpeg\" width=\"80%\">\n\n요청에 대한 응답을 **frame이라는 단위로 쪼개어 전송**한다.\n- 위 그림에서, 비교적 요청량이 적은 O2, O3, O4의 응답 속도는 빨라지고, O1은 비교적 느리게 응답받을 것이다.\n\n---\n\n## 🧷 HTTP/3\nHTTP/2는 HOL blocking 문제를 해결한 듯하다. 하지만, TCP 프로토콜을 사용하는 이상, TCP 패킷이 네트워크 경로상에서 손실된다면 입력 스트림에 공백이 생겨 그 다음에 오는 데이터(바이트)도 **재전송**으로 인해 지연이 발생한다. (TCP는 전송 제어 프로토콜이므로, 재전송을 수행)\n- 특히, HTTP/2는 **여러 개의 HTTP 스트림을 하나의 TCP 연결로 처리**하기에 손실에 대해 더 크게 영향을 받는다.\n\n따라서, HTTP/3가 등장하게 되었고, 이는 TCP가 아닌 **UDP를 사용**한다.\n- 정확하게는 **QUIC**라는 프로토콜 위에서 돌아가는 HTTP이다.\n  - QUIC(Quick UDP Internet Connection)\n\nTCP는 3-way-handshake, 연결 종료 시 사용하는 4-way-handshake 등 오버헤드와 HOL blocking 문제를 피할 수 없다. 하지만 **QUIC는 TCP handshake 과정을 최적화하는 것에 초점을 맞춰 설계**되었다.\n- 기본적으로 UDP는 데이터그램 방식을 사용하기에 각 패킷 간의 순서가 존재하지 않는 **독립적인 패킷**이다.\n\n아래는 각 HTTP 버전에 대한 간략한 그림이다.\n\n<img src=\"../../images/Network/HTTP1,2,3.jpeg\" width=\"80%\">\n\n---\n\n## 🧷 HTTP & HTTPS\n<img src=\"https://www.cloudflare.com/img/learning/security/glossary/what-is-ssl/http-vs-https.svg\" width=\"70%\">\n\n### 🪚 HTTP의 문제점\n- HTTP는 평문 통신이므로 도청이 가능하다.\n- 통신 상대를 확인하지 않아 위장이 가능하다.\n- 완전성을 증명할 수 없어 변조가 가능하다.\n\n> 위의 문제들은 암호화를 사용하지 않는 모든 프로토콜에도 적용되는 문제점이다.\n\n각 문제점을 하나하나 살펴보면,\n\n❗️**TCP/IP는 도청 가능한 네트워크다.**\n- TCP/IP 구조의 통신은 전부 통신 경로 상에서 엿볼 수 있다. 패킷을 수집하는 것만으로도 도청이 가능하다. 따라서 **암호화**의 과정이 필요하다.\n\n> 보완방법\n1. 통신 자체를 암호화 `SSL(Secure Socket Layer)` 또는 `TLS(Transport Layer Security)` 프로토콜과 조합함으로써 HTTP의 통신 내용을 암호화할 수 있다. \n   1. SSL을 조합한 HTTP를 **HTTPS(HTTP Secure)** 또는 **HTTP over SSL**이라 한다.\n2. 콘텐츠를 암호화한다. 말 그대로 HTTP를 사용해서 운반하는 내용인 **HTTP message에 포함되는 콘텐츠만 암호화**한다. 수신측에서는 이를 **복호화하는 과정이 필요**하다.\n\n❗️**통신 상대를 확인하지 않아 위장이 가능하다.**\n- HTTP에 의한 통신은 상대방을 확인하는 처리가 없어 누구든지 요청을 보낼 수 있다. IP 주소나 포트 등에서 그 웹 서버에 접근 제한이 없는 경우, 요청이 오면 무조건 응답을 반환해야 한다. 그렇기에 아래와 같은 문제점을 유발한다.\n\n1. 요청을 보낸 곳의 웹 서버가 원래 의도한 응답을 보내야 하는 웹 서버인지 확인 불가능하다.\n2. 응답을 반환한 곳의 클라이언트가 원래 의도한 요청을 보낸 클라이언트인지 확인 불가능하다.\n3. 통신하고 있는 상대가 접근이 허가된 상대인지 확인 불가능하다.\n4. 어디에서 누가 요청을 보낸 것인지 확인 불가능하다.\n5. 의미없는 요청 또한 수신하여 DoS 공격을 방지할 수 없다.\n\n> 보완 방법\n1. 위에서 언급한 `SSL` 은 상대를 확인하는 수단으로 **증명서**를 제공한다. 증명서는 신뢰할 수 있는 **제 3의 기관에 의해 발행**되는 것이기에 서버나 클라이언트를 증명할 수 있다. 그리고 이를 이용해 통신 상대가 내가 통신하고자 하는 서버임을 나타낼 수 있고, 이용자는 개인 정보 누설 등의 위험성이 줄어들게 된다. (또한 클라이언트는 이 증명성를 이용해 본인 확인을 하고, 웹 사이트 인증에서도 사용할 수 있다.)\n\n> **DoS(Denial-of-Service) Attack**\n> : 시스템을 악의적으로 공격해 해당 시스템의 자원을 부족하게 하여 원래 의도된 용도로 사용하지 못하게 하는 공격이다.\n> - 대량의 패킷을 통신망으로 보내고, 특정 서버에 수많은 접속 시도를 하는 등으로 정상적인 서비스 제공을 하지 못하게 한다. \n> - **통신 상대를 확인하지 않는 HTTP 통신의 특성상 이를 방지할 수 없다.**\n\n❗️**완전성을 증명할 수 없어 변조가 가능하다.**\n- 완전성은 정보의 정확성을 의미한다. \"서버 또는 클라이언트에서 수신한 내용이 송신측에서 보낸 내용과 일치한다는 것을 보장할 수 없다\"는 것이다. \n- 요청이나 응답이 발신된 후, 상대가 수신하기 전까지 누군가에 의해 변조되더라도 이 사실을 알 수 없다. 이와 같이 공격자가 요청이나 응답을 가로채 변조하는 공격을 **중간자 공격, Man in the middle**이라 한다.\n\n> 보완 방법\n1. `MD5`, `SHA-1` 등의 해시 값을 확인하는 방법과 디지털 서명을 확인하는 방법이 존재하지만, 이는 확실한 방법은 아니다. \n2. 확실한 방지를 위해서는 **HTTPS**를 사용해야 한다. 왜냐면, `SSL` 에는 인증이나 암호화, 메세지 다이제스트(해시) 기능을 제공하고 있기 때문이다.\n\n> **메세지 다이제스트**\n> : **메세지(데이터)의 해시값**(다이제스트 값)을 계산하여 데이터와 함께 전송한다. 중간자 공격이 발생하더라도, 다이제스트 값을 확인함으로써 데이터의 변조 사실을 확인할 수 있다.\n> - 데이터의 무결성을 보장해주는 방법이다.\n\n> **SSL과 TLS**\n> : SSL은 TLS은 이전 버전의 프로토콜이다. 혼합되어 많이 사용한다.\n\n### 🪚 HTTPS\n이는 HTTP에 암호화와 인증, 그리고 완전성 보호를 더한 것이다. \n\nHTTPS는 **SSL을 덮어쓴 HTTP**라고 할 수 있다. 새로운 응용 계층의 프로토콜은 아니다.\n- HTTP 통신하는 소켓 부분을 `SSL(Secure Socket Layer)` 또는 `TLS(Transport Layer Security)` 라는 프로토콜로 대체한 것이다.\n- HTTP는 TCP와 직접 통신했지만, **HTTPS에서는 HTTP는 SSL과 통신하고, SSL이 TCP와 통신**하게 된다.\n\n❓**모든 웹 사이트에서 HTTPS를 사용해도 될까?**\n- 당연하게도, 평문 통신에 비해 암호화된 통신은 더 많은 자원을 요구한다. 통신마다 이러한 추가 자원 소비는 서버 한 대당 평균 요청 처리량을 감소시킨다.\n- 하지만 최근에는 하드웨어의 발달로 HTTPS 통신에서의 속도 저하가 거의 일어나지 않으며, 새로운 표준인 HTTP 2.0을 함께 이용하면 오히려 HTTP보다 더 빠르게 동작한다.\n- 따라서 현재는 모든 웹 페이지에서 HTTPS를 적용하는 방향으로 바뀌어 가고 있다.\n\n> **HTTPS와 구글**\n> - 구글은 2014년, 모든 웹 사이트에 HTTPS를 요구했고, SSL 보안 사이트에 대해 높은 검색 순위로 보상했다. \n> - 이후 2018년에는 검색 순위 보상이 아닌, SSL 인증서가 없는 사이트에 대한 불이익을 가했다. (해당 사이트는 Chrome 브라우저에 \"안전하지 않음\"이라 표시된다.)\n\n---\n\n## 🧷 SMTP\nSimple Mail Transfer Protocol의 약자로, 인터넷에서 이메일을 보내기 위해 사용되는 프로토콜이다.\n- Port #은 25\n- TCP를 사용하여, 송신측의 내용과 수신측의 내용이 같아야 한다.\n\n### 🪚 SMTP & HTTP\n**HTTP**\n- 요청을 하면 데이터를 전송한다. (pull)\n- 아스키 코드를 사용한 요청과 응답, 상태 코드 존재\n- content type이 한 type으로만 전송 가능하다.\n\n**SMTP**\n- 요청과 상관없이 데이터를 전송한다. (push)\n- 아스키 코드를 사용한 요청과 응답, 상태 코드 존재\n- content type이 한 가지로 제한되지 않고, 여러 type으로 전송 가능하다.\n\n### 🪚 Mail Access Protocols\n<img src=\"../images/../../images/Network/mailaccessprotocol.jpeg\" width=\"80%\">\n\nMail Access Protocol: 사용자 요청에 대한 응답을 처리하기 위해 메일 서버가 사용하는 프로토콜로, IMAP, POP3가 있다.\n\n1. 발신자가 메일 전송을 요청하면, SMTP를 이용해 발신자의 메일 서버에 메일을 push한다.\n2. 발신자의 메일 서버에서 수신자의 메일 서버로 해당 메일을 다시 push한다.\n3. 수신자의 메일 서버에서는 이를 가지고 있다가, 수신자가 메일 확인을 요청하면, IMAP or POP3와 같은 Mail Access Protocol을 사용해 응답을 보낸다.\n\n---\n\n## 🧷 DNS\nDomain Name System의 약자로, 응용 계층의 프로토콜이다. **여러 Name Server의 계층 구조로 구현된 분산 데이터베이스**이다. \n- IP 주소와 그에 해당하는 Name을 매핑시키기 위해 DB에 이를 저장하는데, 1개의 DB로는 많은 요청에 대한 처리가 불가능하기에 분산 DB를 사용한다.\n\n### 🪚 DNS Services\n- Host Name -> Name 변환\n- Host Aliasing\n- Mail Server Aliasing\n- Load Distribution(하나의 이름을 가진 여러 IP 주소가 가능하게 함으로써, 한 서버로 요청이 몰리지 않게 분산)\n\n### 🪚 DNS Round Robin 방식\n**문제점**\n1. 서버의 수만큼 공인 IP 주소가 필요하다. \n   1. 서버 부하의 분산을 위해 서버의 수를 늘리기 위해서는 그만큼의 공인 IP가 필요하다.\n2. 균등하게 분산되지 않는다. \n   1. 모바일 사이트와 같은 경우, 스마트폰의 접속은 \"캐리어 게이트웨이\"라는 프록시 서버를 경유한다. 프록시 서버에서는 이름 변환 결과가 일정 시간동안 캐싱되어, 같은 프록시 서버를 경유하는 접속은 캐싱이 남아있는 동안 같은 서버로 접속된다.\n   2. 또한, PC용 웹 브라우저도 DNS 질의 결과를 캐싱하기에 균등한 부하 분산이 제대로 이루어지지 않는다. \n3. 서버가 다운되어 확인이 불가하다.\n   1. DNS 서버는 웹 서버의 부하나 접속 수 등의 상황에 따라 질의결과를 제어할 수 없다. 즉, 웹 서버의 부하가 높아 응답이 느려지거나, 접속 수가 가득 차서 접속을 처리할 수 없는 상황이어도 이를 감지하지 못한다. \n   2. 이는 사용자들에게 다운된 서버로 연결시키기도 한다.\n\n따라서 Round Robin 방식을 기반으로 다른 SW와 조합해서 관리해야 한다. 아래는 그러한 **DNS 스케줄링 알고리즘**이다.\n\n- **Weighted Round Robin(WRR)**\n  - 각각의 웹 서버에 가중치를 부여하여 분산 비율을 변경한다. 물론 가중치가 큰 서버일수록 빈번하게 선택되므로 처리능력이 높은 서버는 가중치를 높게 설정하는 것이 좋을 것이다.\n- **Least Connection**\n  - 접속 클라이언트 수가 가장 적은 서버를 선택한다. 로드밸런서에서 실시간으로 connection 수를 관리하거나 각 서버에서 주기적으로 알려주는 것이 필요하다.\n   \n---\n\n## 🧷 웹 통신의 큰 흐름\n### 🪚 주소창에 특정 URL 값을 입력시키면 어떤 일이 일어날까?\n\n**브라우저**\n1. URL에 입력된 값을 브라우저 내부에서 파싱한다. (프로토콜, URL, Port #)\n   1. Port #를 명시하지 않아도 브라우저에 설정된 기본값으로 지정한다.(HTTP: 80, HTTPS: 443)\n2. 조사된 의미에 따라 HTTP 요청 메세지를 만든다.\n3. 만들어진 메세지를 웹 서버로 전송한다.\n\n이때 만들어진 메세지 전송은 브라우저가 하는 것이 아닌 OS에 의뢰하여 전송한다. (브라우저는 메세지를 네트워크에 송출하는 기능이 없다.)\n- 단, OS에 의뢰할 떄는 도메인명이 아닌 **IP 주소**로 메세지를 받을 상대를 지정해야 하는데, 이 과정에서 **DNS 서버를 조회**한다.\n\n**프로토콜 스택, LAN 어댑터**\n1. 프로토콜 스택이 브라우저로부터 메세지를 받는다.\n2. 브라우저로부터 받은 메세지를 패킷 속에 저장한다.\n3. 수신처 주소 등의 제어 정보를 덧붙여 패킷을 LAN 어댑터에 넘긴다.\n4. LAN 어댑터는 다음 Hop의 MAC 주소를 붙인 프레임을 전기 신호로 변환한다.\n5. 신호를 LAN 케이블에 송출한다.\n\n프로토콜 스택은 통신 중 오류가 발생했을 때, 이 제어 정보를 사용해 고쳐 보내거나, 각종 상황을 조절하는 등 다양한 역할을 하게 된다.\n\n**허브, 스위치, 라우터**\n1. LAN 어댑터가 송신한 프레임은 스위칭 허브를 경유해 인터넷 접속용 라우터에 도착한다.\n2. 라우터는 패킷을 프로바이더(통신사)에게 전달한다.\n3. 인터넷으로 접속한다.\n\n**액세스 회선, 프로바이더**\n1. 패킷은 인터넷의 입구에 있는 액세스 회선(통신 회선)에 의해 POP(Point of Presence)까지 운반된다.\n2. POP를 거쳐 인터넷의 핵심부로 들어간다.\n3. 수 많은 고속 라우터들 사이로 패킷이 목적지로 흘러간다.\n\n**방화벽, 캐시서버**\n1. 패킷은 인터넷을 통과하여 웹 서버측의 LAN에 도착한다.\n2. 기다리고 있던 방화벽이 도착한 패킷을 검사한다.\n3. 패킷이 웹 서버까지 가야하는지 가지 않아도 되는지를 판단하는 캐시 서버가 존재한다.\n\n굳이 서버까지 가지 않아도 되는 경우는 다음과 같다. 액세스한 페이지의 데이터가 캐시서버에 있으면 웹 서버에 의뢰하지 않고 바로 그 값을 읽을 수 있다. 페이지 데이터 중 다시 이용할 수 있는 것이 있으면 이는 캐시 서버에 저장된다.\n\n**웹 서버**\n1. 패킷이 물리적인 웹 서버에 도착하면 웹 서버의 프로토콜 스택은 패킷을 추출해 메세지를 복원하고, 웹 서버 애플리케이션에 넘긴다.\n2. 메세지를 받은 웹 서버 애플리케이션은 요청 메세지에 따른 데이터를 응답 메세지에 넣어 클라이언트로 전송한다.\n3. 왔던 방식의 반대로 응답 메세지가 클라이언트에 전달된다.\n\n> ❓ **주소창에 http 나 https와 같은 프로토콜을 명시하지 않아도 자동으로 해당 프로토콜이 붙는 이유?**\n> - 브라우저에서 제공하는 기능으로, 도메인만 입력받은 경우 브라우저는 **기본값으로 HTTP 프로토콜**을 사용해 접속을 시도한다. (Port #: 80)\n> - HTTPS가 적용된 페이지라면, HTTP 접속 시도 시 301, 302 상태 코드를 반환해 **리다이렉트하라는 메세지**를 브라우저로 보낸다. 이를 받은 브라우저는 HTTPS로 다시 접속하게 된다.\n> - 한 번이라도 HTTPS로 접속한 적이 있다면, HTTP를 허용하지 않고 HTTPS를 사용하는 연결만 허용하는 기능인 **HSTS(HTTP Strict Transport Security)** 목록에 저장된다. 이후 접속 시에는 곧바로 HTTPS 요청을 하게 된다.\n\n---\n\n## 📕 참고\n- [OSI 7 Layer vs TCP/IP 5 Layer](https://velog.io/@osk3856/TCP-Updated-Model)\n- [Application Layer 개요](https://ddongwon.tistory.com/71)\n- [Part 1-3 Network](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Network)\n- [HTTP 요청 메서드](https://developer.mozilla.org/ko/docs/Web/HTTP/Methods)\n- [HTTP 2, HTTP 3](https://woojinger.tistory.com/85)\n- [서비스 거부 공격](https://ko.wikipedia.org/wiki/%EC%84%9C%EB%B9%84%EC%8A%A4_%EA%B1%B0%EB%B6%80_%EA%B3%B5%EA%B2%A9)\n- [SSL이란 무엇인가요?](https://www.cloudflare.com/ko-kr/learning/ssl/what-is-ssl/)\n- [브라우저에 URL을 입력했을 때 발생하는 일들](https://deveric.tistory.com/97)"},{"excerpt":"문제 Programmers - 자물쇠와 열쇠 📍 Logic 전체 흐름은,  자물쇠와 키를 둘 수 있는 큰 2차원 배열을 선언하고,  자물쇠를 중앙에 둔 채로, 키를 돌려가면서 맞춰보고, 잠금 해제가 가능한지 확인한다. 📄 CODE ✏️ Review 이번 주차 문제 중에서 제일 어려웠던 문제 구현이 깔끔하게 이뤄지지 않아 풀이 영상을 보니, 아래와 같은 신기…","fields":{"slug":"/[Programmers]60059/"},"frontmatter":{"date":"June 12, 2022","title":"👩‍💻 60059. 자물쇠와 열쇠","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 자물쇠와 열쇠](https://programmers.co.kr/learn/courses/30/lessons/60059)\n\n### 📍 **Logic**\n\n```java\nfor (int r = 0; r < M - 1 + N; r++) {\n    for (int c = 0; c < M - 1 + N; c++) {\n        for (int rotate = 0; rotate < 4; rotate++) {\n            // 자물쇠를 중앙에 두고, 키를 돌려가면서 확인할 큰 배열 선언\n            bigMap = new int[N + (M - 1) * 2][N + (M - 1) * 2];\n\n            // 자물쇠를 중앙에 배치\n            for (int i = 0; i < N; i++)\n                System.arraycopy(lock[i], 0, bigMap[M - 1 + i], M - 1, N);\n\n            // bigMap에 키를 더해 자물쇠에 맞는지 확인할 것\n            match(key, r, c);\n            if (canUnlock()) return true;\n        }\n    }\n}\n```\n\n- 전체 흐름은, \n  - 자물쇠와 키를 둘 수 있는 큰 2차원 배열을 선언하고, \n  - 자물쇠를 중앙에 둔 채로, 키를 돌려가면서 맞춰보고, 잠금 해제가 가능한지 확인한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        static int M;\n        static int N;\n        static int[][] bigMap;\n        \n        public boolean solution(int[][] key, int[][] lock) {  \n            M = key.length;\n            N = lock.length;\n            \n            for (int r = 0; r < M - 1 + N; r++) {\n                for (int c = 0; c < M - 1 + N; c++) {\n                    for (int rotate = 0; rotate < 4; rotate++) {\n                        // 자물쇠를 중앙에 두고, 키를 돌려가면서 확인할 큰 배열 선언\n                        bigMap = new int[N + (M - 1) * 2][N + (M - 1) * 2];\n\n                        // 자물쇠를 중앙에 배치\n                        for (int i = 0; i < N; i++)\n                            System.arraycopy(lock[i], 0, bigMap[M - 1 + i], M - 1, N);\n\n                        // bigMap에 키를 더해 자물쇠에 맞는지 확인할 것\n                        match(key, r, c);\n                        if (canUnlock()) return true;\n                    }\n                }\n            }\n            \n            return false;\n        }\n        \n        // bigMap이 1로만 이루어지는지 확인\n        static private boolean canUnlock() {\n            for (int i = 0; i < N; i++)\n                for (int j = 0; j < N; j++)\n                    if (bigMap[M - 1 + i][M - 1 + j] != 1) return false;\n            return true;\n        }\n\n        // 키와 자물쇠를 더하는 함수\n        static private void match(int[][] key, int r, int c) {\n            key = rotatingKey(key);\n\n            for (int i = 0; i < M; i++)\n                for (int j = 0; j < M; j++)\n                    bigMap[i + r][j + c] += key[i][j];\n        }\n        \n        // 키를 시계방향으로 90도 돌리는 함수\n        static private int[][] rotatingKey(int[][] key) {\n            for (int i = 0; i < M / 2; i++) {\n                int[] tmp = Arrays.copyOf(key[M - i - 1], M);\n                key[M - i - 1] = key[i];\n                key[i] = tmp;\n            }\n\n            for (int i = 0; i < M; i++) {\n                for (int j = i; j < M; j++) {\n                    int temp = key[i][j];\n                    key[i][j] = key[j][i];\n                    key[j][i] = temp;\n                }\n            }\n\n            return key;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 이번 주차 문제 중에서 제일 어려웠던 문제\n- 구현이 깔끔하게 이뤄지지 않아 풀이 영상을 보니, 아래와 같은 신기한 풀이를 볼 수 있었다.\n  - 키를 돌리지 않고 인덱스 접근으로 구현\n  - 자물쇠를 중앙에 두고, 키를 여러 방면에서 더해볼 수 있는 큰 배열 선언\n- 이런 구현 문제는 머리를 좀 잘 굴릴 줄 알아야 할 것 같다..."},{"excerpt":"문제 Programmers - 문자열 압축 📍 Logic 문자열은 1부터 주어진 문자열 길이의 절반까지만큼 자르는 것을 반복한다. 정한 길이만큼 문자열을 비교하고 개수와 정한 길이만큼을  에 더해, 최종적으로  를 최신화한다. 📄 CODE ✏️ Review 제일 먼저 그리디한 방법을 떠올리긴 했으나, 시간 초과가 나지 않을까 생각했다. 문자열을 길이가 최대…","fields":{"slug":"/[Programmers]60057/"},"frontmatter":{"date":"June 11, 2022","title":"👩‍💻 60057. 문자열 압축","tags":["문자열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 문자열 압축](https://programmers.co.kr/learn/courses/30/lessons/60057)\n\n### 📍 **Logic**\n\n```java\n// 전체 반복은 s 길이의 절반까지만\nfor (int len = 1; len <= inputLength / 2; len++) {\n    int length = 0;\n    int idx = 0;\n\n    // 자를 word가 s의 범위 안에 있는 경우까지 반복\n    while(idx + len <= inputLength) {\n        String word = getWord(idx, len);\n        int count = 0;\n        \n        // 확인할 문자열이 s의 범위 안에 있고, 그 문자열이 word와 동일한 경우\n        // 그 문자열의 개수를 구한다.\n        while (idx + len <= inputLength && word.equals(getWord(idx, len))) {\n            idx += len;\n            count++;\n        }\n        // count가 1이면 문자열 길이만 더하고, 1보다 큰 경우에는 그 길이도 함께 더한다.\n        length += word.length() + (count > 1 ? String.valueOf(count).length() : 0);\n    }\n    // 남은 문자열 붙이기\n    length += inputLength - idx;\n    minLength = Math.min(minLength, length);\n}\n```\n\n- 문자열은 **1부터 주어진 문자열 길이의 절반**까지만큼 자르는 것을 반복한다.\n- 정한 길이만큼 문자열을 비교하고 개수와 정한 길이만큼을 `length` 에 더해, 최종적으로 `minLength` 를 최신화한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        static String inputString;\n        \n        public int solution(String s) {\n            if (s.length() == 1) return 1;\n\n            inputString = s;\n            int inputLength = s.length();\n            int minLength = Integer.MAX_VALUE;\n\n            // 전체 반복은 s 길이의 절반까지만\n            for (int len = 1; len <= inputLength / 2; len++) {\n                int length = 0;\n                int idx = 0;\n\n                // 자를 word가 s의 범위 안에 있는 경우까지 반복\n                while(idx + len <= inputLength) {\n                    String word = getWord(idx, len);\n                    int count = 0;\n                    \n                    // 확인할 문자열이 s의 범위 안에 있고, 그 문자열이 word와 동일한 경우\n                    // 그 문자열의 개수를 구한다.\n                    while (idx + len <= inputLength && word.equals(getWord(idx, len))) {\n                        idx += len;\n                        count++;\n                    }\n                    // count가 1이면 문자열 길이만 더하고, 1보다 큰 경우에는 그 길이도 함께 더한다.\n                    length += word.length() + (count > 1 ? String.valueOf(count).length() : 0);\n                }\n                // 남은 문자열 붙이기\n                length += inputLength - idx;\n                minLength = Math.min(minLength, length);\n            }\n            \n            return minLength;\n        }\n        \n        private String getWord(int start, int len) {\n            return inputString.substring(start, start + len);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 제일 먼저 그리디한 방법을 떠올리긴 했으나, 시간 초과가 나지 않을까 생각했다.\n- 문자열을 길이가 최대 1000이었고, 어차피 문자열 비교를 위해 절반 길이까지만 자를 것이므로 괜찮을 것 같았다."},{"excerpt":"문제 Programmers - 괄호 변환 📍 Logic 주어진 \"균형잡힌 괄호 문자열\"을 \"올바른 괄호 문자열\"로 변환하는 함수 📄 CODE ✏️ Review 하라는 대로만 구현하면 쉽게 풀리는 문제! 어떤 함수를 필요로 하는지 나누어 생각하고 구현해보는 연습하기에 좋은 문제였다.","fields":{"slug":"/[Programmers]60058/"},"frontmatter":{"date":"June 11, 2022","title":"👩‍💻 60058. 괄호 변환","tags":["문자열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 괄호 변환](https://programmers.co.kr/learn/courses/30/lessons/60058)\n\n### 📍 **Logic**\n\n```java\nprivate String recursive(String p) {\n    // 빈 문자열인 경우 반환\n    if (Objects.equals(p, \"\")) return p;\n    \n    // u와 v로 분리\n    String[] uv = splitString(p);\n    String u = uv[0];\n    String v = uv[1];\n    \n    // u가 올바르다면, v에 대해 recurvie()한 결과를 붙여 반환\n    if (isProper(u)) return u + recursive(v);\n    \n    // u가 올바르지 않은 경우\n    StringBuilder sb = new StringBuilder(\"(\");\n    sb.append(recursive(v)).append(\")\").append(reverseBracket(u.substring(1, u.length() - 1)));\n    return sb.toString();\n}\n```\n\n- 주어진 \"균형잡힌 괄호 문자열\"을 \"올바른 괄호 문자열\"로 변환하는 함수\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        public String solution(String p) {\n            // 이미 올바른 경우 반환\n            if (isProper(p)) return p;\n            \n            // 올바르지 않은 경우\n            return recursive(p);\n        }\n        \n        private String recursive(String p) {\n            // 빈 문자열인 경우 반환\n            if (Objects.equals(p, \"\")) return p;\n            \n            // u와 v로 분리\n            String[] uv = splitString(p);\n            String u = uv[0];\n            String v = uv[1];\n            \n            // u가 올바르다면, v에 대해 recurvie()한 결과를 붙여 반환\n            if (isProper(u)) return u + recursive(v);\n            \n            // u가 올바르지 않은 경우\n            StringBuilder sb = new StringBuilder(\"(\");\n            sb.append(recursive(v)).append(\")\").append(reverseBracket(u.substring(1, u.length() - 1)));\n            return sb.toString();\n        }\n        \n        // 올바른 괄호 문자열인지 확인하는 함수, Stack 사용\n        private boolean isProper(String p) {\n            Stack<Character> stack = new Stack<>();\n            int idx = 0;\n            \n            while (idx < p.length()) {\n                char ch = p.charAt(idx);\n                if (ch == '(')\n                    stack.push(ch);\n                else\n                    if (stack.size() > 0)\n                        stack.pop(); \n                \n                idx++;\n            }\n            \n            return stack.isEmpty();\n        }\n        \n        // 분리하는 함수, (의 개수와 )의 개수가 같은 경우까지가 u, 나머지는 v\n        private String[] splitString(String p) {\n            String u = \"\";\n            String v = \"\";\n            int lcount = 0;\n            int rcount = 0;\n            int idx = 0;\n            \n            while(idx < p.length()) {\n                if (p.charAt(idx) == '(') lcount++;\n                else rcount++;\n                idx++;\n                \n                if (lcount == rcount) {\n                    u = p.substring(0, idx);\n                    v = p.substring(idx);\n                    break;\n                }\n            }\n            \n            return new String[] {u, v};\n        }\n        \n        // 주어진 문자열의 첫번째와 마지막 문자를 제거하고, 나머지 문자를 뒤집는 함수\n        private String reverseBracket(String str) {\n            StringBuilder sb = new StringBuilder();\n            \n            for (int i = 0; i < str.length(); i++)\n                sb.append(str.charAt(i) == '(' ? \")\" : \"(\");\n            \n            return sb.toString();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 하라는 대로만 구현하면 쉽게 풀리는 문제!\n- 어떤 함수를 필요로 하는지 나누어 생각하고 구현해보는 연습하기에 좋은 문제였다."},{"excerpt":"문제 Programmers - 오픈채팅방(https://programmers.co.kr/learn/courses/30/lessons/42888 📍 Logic  에는 유저아이디, 닉네임 쌍을 저장한다.  에는 사용자의 입, 퇴장 여부와 해당하는 유저아이디를 저장한다. 입, 퇴장이 모두 끝난 후, 순서와 유저아이디에 따라 닉네임을 출력한다. 📄 CODE ✏️ …","fields":{"slug":"/[Programmers]42888/"},"frontmatter":{"date":"June 10, 2022","title":"👩‍💻 42888. 오픈채팅방","tags":["Map"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 오픈채팅방](https://programmers.co.kr/learn/courses/30/lessons/42888\n\n### 📍 **Logic**\n\n```java\nMap<String, String> user = new LinkedHashMap<>();\nArrayList<Pair> inOut = new ArrayList<>();\n\nfor (String rec : record) {\n    String[] info = rec.split(\" \");\n    char word = rec.charAt(0);\n    \n    if (word == 'E') {\n        user.put(info[1], info[2]);\n        inOut.add(new Pair(word, info[1]));\n    } else if (word == 'L') {\n        inOut.add(new Pair(word, info[1]));\n    } else {\n        user.put(info[1], info[2]);\n    }\n}\n```\n\n- `Map` 에는 유저아이디, 닉네임 쌍을 저장한다.\n- `ArrayList<Pair>` 에는 사용자의 입, 퇴장 여부와 해당하는 유저아이디를 저장한다.\n- 입, 퇴장이 모두 끝난 후, 순서와 유저아이디에 따라 닉네임을 출력한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Pair {\n        char command;\n        String name;\n        \n        public Pair(char command, String name) {\n            this.command = command;\n            this.name = name;\n        }\n    }\n\n    class Solution {\n        static String in = \"님이 들어왔습니다.\";\n        static String out = \"님이 나갔습니다.\";\n        \n        public String[] solution(String[] record) {\n            // user는 유저아이디와 해당하는 닉네임을 저장\n            // inOut은 사용자의 입장, 퇴장 여부와 해당하는 유저아이디를 저장\n            Map<String, String> user = new LinkedHashMap<>();\n            ArrayList<Pair> inOut = new ArrayList<>();\n            \n            for (String rec : record) {\n                String[] info = rec.split(\" \");\n                char word = rec.charAt(0);\n                \n                if (word == 'E') {\n                    user.put(info[1], info[2]);\n                    inOut.add(new Pair(word, info[1]));\n                } else if (word == 'L') {\n                    inOut.add(new Pair(word, info[1]));\n                } else {\n                    user.put(info[1], info[2]);\n                }\n            }\n            \n            String[] answer = new String[inOut.size()];\n            int idx = 0;\n            for (Pair p : inOut) {\n                StringBuilder sb = new StringBuilder(user.get(p.name));\n                \n                sb.append(p.command == 'E' ? in : out);\n                \n                answer[idx] = sb.toString();\n                idx++;\n            }\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 쉬운 문제였다!"},{"excerpt":"문제 Programmers - 실패율 📍 Logic  를 사용해 도달한 인원 수와 실패율을 저장 난이도별 도달 인원 수를 0으로 초기화한 후, 실패율 계산을 위한 도달했지만 클리어하지 못한 인원 수를 계산 앞 난이도부터, 클리어하지 못한 인원 수 / 전체 인원로 실패율을 계산한다. 이후 전체 인원은 해당 난이도에 도달했지만 클리어하지 못한 인원 수만큼 차…","fields":{"slug":"/[Programmers]42889/"},"frontmatter":{"date":"June 07, 2022","title":"👩‍💻 42889. 실패율","tags":["정렬"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 실패율](https://programmers.co.kr/learn/courses/30/lessons/42889)\n\n### 📍 **Logic**\n\n```java\nfor (int i = 0; i < N; i++)\n    userStage.add(new Stage(i + 1));\n\nfor (int s : stages) {\n    if (s > N) continue;\n    userStage.get(s - 1).incFail();\n}\n\nfor (Stage s : userStage) {\n    if (users == 0) break;\n    double tmp = s.fail / users;\n    users -= s.fail;\n    s.setFail(tmp);\n}\n```\n\n- `ArrayList<Stage>` 를 사용해 도달한 인원 수와 실패율을 저장\n- 난이도별 도달 인원 수를 0으로 초기화한 후, 실패율 계산을 위한 도달했지만 클리어하지 못한 인원 수를 계산\n- 앞 난이도부터, **클리어하지 못한 인원 수 / 전체 인원**로 실패율을 계산한다.\n  - 이후 전체 인원은 해당 난이도에 도달했지만 클리어하지 못한 인원 수만큼 차감한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Stage implements Comparable<Stage> {\n        int user;\n        double fail;\n\n        public Stage(int user) {\n            this.user = user;\n            this.fail = 0;\n        }\n\n        public void incFail() {\n            this.fail += 1;\n        }\n\n        public void setFail(double fail) {\n            this.fail = fail;\n        }\n\n        @Override\n        public int compareTo(Stage o) {\n            if (o.fail == this.fail) return this.user - o.user;\n            if (o.fail > this.fail) return 1;\n            return -1;\n        }\n    }\n\n    class Solution {\n        public int[] solution(int N, int[] stages) {\n            double users = stages.length;\n            ArrayList<Stage> userStage = new ArrayList<>();\n\n            for (int i = 0; i < N; i++)\n                userStage.add(new Stage(i + 1));\n\n            for (int s : stages) {\n                if (s > N) continue;\n                userStage.get(s - 1).incFail();\n            }\n\n            for (Stage s : userStage) {\n                if (users == 0) break;\n                double tmp = s.fail / users;\n                users -= s.fail;\n                s.setFail(tmp);\n            }\n\n            Collections.sort(userStage);\n\n            int[] answer = new int[N];\n            for (int i = 0; i < N; i++)\n                answer[i] = userStage.get(i).user;\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 쉬운 문제였으나 좀 더 효율적인 자료구조를 빠른 시간 내에 떠올리지 못한 게 문제였다."},{"excerpt":"문제 Programmers - 매칭 점수 📍 Logic  클래스의 ,  ,  로 각  에 대해 기본 점수와 외부 링크 수, 링크 점수를 계산한다. 해당 웹 페이지로 링크가 걸린 다른 웹 페이지의 링크 점수(기본 점수 / 외부 링크 수)의 총합을 구해 해당 웹 페이지의 매칭 점수를 계산한다.  📄 CODE ✏️ Review 문제 자체는 매우 간단했지만 구현이…","fields":{"slug":"/[Programmers]42893/"},"frontmatter":{"date":"June 05, 2022","title":"👩‍💻 42893. 매칭 점수","tags":["문자열","정규표현식"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 매칭 점수](https://programmers.co.kr/learn/courses/30/lessons/42893)\n\n### 📍 **Logic**\n\n```java\nfor (String page : pages) {\n    Page p = new Page(word, page);\n    // url을 키로 하여 맵 추가\n    pageInfo.put(p.url, p);\n}\n```\n\n- `Page` 클래스의 `setScore()`, `setExtPages()` , `setLinkScore()` 로 각 `page` 에 대해 기본 점수와 외부 링크 수, 링크 점수를 계산한다.\n\n```java\nfor (Page p : pageInfo.values()) {\n    for (String extPage : p.extPages) {\n        if (pageInfo.containsKey(extPage))\n            pageInfo.get(extPage).addScore(p.getLinkScore());\n    }\n}\n```\n\n- 해당 웹 페이지로 링크가 걸린 다른 웹 페이지의 링크 점수(기본 점수 / 외부 링크 수)의 총합을 구해 해당 웹 페이지의 매칭 점수를 계산한다. \n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n    import java.util.regex.Matcher;\n    import java.util.regex.Pattern;\n\n    class Page {\n        String url;\n        double score = 0;\n        double linkScore = 0;\n        ArrayList<String> extPages;\n\n        public Page(String word, String page) {\n            this.url = getUrl(page);\n            extPages = new ArrayList<>();\n\n            setScore(page, word);\n            setExtPages(page);\n            setLinkScore();\n        }\n\n        private String getUrl(String page) {\n            Pattern pattern = Pattern.compile(\"<meta property=\\\"og:url\\\" content=\\\"(\\\\S*)\\\"\");\n            Matcher matcher = pattern.matcher(page);\n\n            if (matcher.find())\n                return matcher.group().split(\"=\")[2].replaceAll(\"\\\"\", \"\");\n            return \"\";\n        }\n        \n        public void addScore(double score) {\n            this.score += score;\n        }\n        \n        public double getScore() {\n            return score;\n        }\n\n        private void setScore(String page, String word) {\n            // body 태그 내 모든 숫자들을 공백으로 replace하여, word를 찾기 쉽도록 함\n            String body = page.split(\"<body>\")[1].split(\"</body>\")[0].replaceAll(\"\\\\d\", \" \");\n            Pattern pattern = Pattern.compile(\"\\\\b(?i)\" + word + \"\\\\b\");\n            Matcher matcher = pattern.matcher(body);\n\n            while(matcher.find())\n                score++;\n        }\n\n        private void setExtPages(String page) {\n            Pattern pattern = Pattern.compile(\"<a href=\\\"https://(\\\\S*)\\\"\");\n            Matcher matcher = pattern.matcher(page);\n\n            while(matcher.find())\n                extPages.add(matcher.group().split(\"\\\"\")[1]);\n        }\n        \n        public double getLinkScore() {\n            return linkScore;\n        }5\n\n        private void setLinkScore() {\n            this.linkScore = this.score / extPages.size();\n        }\n    }\n\n    class Solution {\n        public int solution(String word, String[] pages) {\n            word = word.toLowerCase();\n\n            Map<String, Page> pageInfo = new LinkedHashMap<>();\n\n            for (String page : pages) {\n                Page p = new Page(word, page);\n                // url을 키로 하여 맵 추가\n                pageInfo.put(p.url, p);\n            }\n\n            for (Page p : pageInfo.values()) {\n                for (String extPage : p.extPages) {\n                    if (pageInfo.containsKey(extPage))\n                        pageInfo.get(extPage).addScore(p.getLinkScore());\n                }\n            }\n\n            double maxScore = 0;\n            int maxIdx = 0;\n            int idx = 0;\n            for (Map.Entry<String, Page> entry : pageInfo.entrySet()) {\n                double score = entry.getValue().getScore();\n                if (score > maxScore) {\n                    maxScore = score;\n                    maxIdx = idx;\n                }\n                idx++;\n            }\n            \n            return maxIdx;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 문제 자체는 매우 간단했지만 구현이 진짜 더러웠던 문제 ... 정규 표현식을 제대로 이해하지 않으면 절대 그냥 못 풀 듯 하다..\n- 문제 이해를 잘못해서, **해당 웹 페이지로 링크가 걸린 다른 웹페이지의 기본 점수 / 외부 링크의 수의 총합**을 해당 웹 페이지로 링크가 걸린 다른 웹 페이지의 기본 점수와 현재 페이지의 링크의 수에 대한 계산으로 착각해서 시간을 더 날렸다."},{"excerpt":"문제 Programmers - 블록 게임 📍 Logic 이중 for문으로 보드를 확인하면서, 2x3 범위와 3x2 범위를 확인하여 검정 블록 2개로 삭제할 수 있는 블록의 수를 카운트한다. 현재 위치와 가로, 세로 범위를 가지고 해당 범위 내의 빈 공간의 개수와 빈 공간이 아닌 블록의 번호를 저장한다. 빈 공간의 개수가 3개 이상일 경우 종료한다. 빈 공…","fields":{"slug":"/[Programmers]42894/"},"frontmatter":{"date":"June 05, 2022","title":"👩‍💻 42894. 블록 게임","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 블록 게임](https://programmers.co.kr/learn/courses/30/lessons/42894)\n\n### 📍 **Logic**\n\n```java\npublic void findRemovableBlock() {\n    int count;\n    \n    // 더 이상 삭제 가능한 블록이 없을 때까지 진행\n    do {\n        count = 0;\n        for (int i = 0; i < N; i++) {\n            for (int j = 0; j < N; j++) {\n                // 가로 또는 세로 범위의 직사각형 블록 여부 확인\n                if ((i <= N - 2 && j <= N - 3 && find(i, j, 2, 3)) || (i <= N - 3 && j <= N - 2 && find(i, j, 3, 2)))\n                    count++;\n            }\n        }\n        removableBlocks += count;\n    } while(count != 0);\n}\n```\n\n- 이중 for문으로 보드를 확인하면서, 2x3 범위와 3x2 범위를 확인하여 검정 블록 2개로 삭제할 수 있는 블록의 수를 카운트한다.\n\n```java\nprivate boolean find(int x, int y, int h, int w) {\n    // 빈 공간을 카운트, 빈 공간은 2개까지만 가능하다. 블록 범위의 크기는 6이고 블록의 크기는 4이기 때문\n    int emptyCount = 0;\n    // 빈 공간이 아닌 블록 번호를 저장, 빈 공간이 아닌 경우에는 이 값과 모두 동일해야 함\n    int lastNum = -1;\n    \n    for (int i = x; i < x + h; i++) {\n        for (int j = y; j < y + w; j++) {\n            // 빈 공간인 경우\n            if (board[i][j] == 0) {\n                if (!canFill(i, j)) return false;\n                if (++emptyCount > 2) return false;\n            } else {\n                // 빈 공간이 아닌 블록 번호가 있고, 현재 영역과 다른 번호라면 같은 블록이 아니므로 종료\n                if (lastNum != -1 && lastNum != board[i][j]) return false;\n                lastNum = board[i][j];\n            }\n        }\n    }\n    \n    removeBlock(x, y, h, w);\n    \n    return true;\n}\n```\n\n- 현재 위치와 가로, 세로 범위를 가지고 해당 범위 내의 빈 공간의 개수와 빈 공간이 아닌 블록의 번호를 저장한다.\n  - 빈 공간의 개수가 **3개 이상**일 경우 종료한다.\n  - 빈 공간이 아닌 블록 번호와 같지 않은 블록 번호가 나온 경우, 동일한 블록이 아니므로 종료한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Board {\n        int N;\n        int[][] board;\n        // 지울 수 있는 블록의 수\n        int removableBlocks = 0;\n        \n        public Board(int[][] board) {\n            this.N = board.length;\n            this.board = board;\n        }\n        \n        public void findRemovableBlock() {\n            int count;\n            \n            // 더 이상 삭제 가능한 블록이 없을 때까지 진행\n            do {\n                count = 0;\n                for (int i = 0; i < N; i++) {\n                    for (int j = 0; j < N; j++) {\n                        // 가로 또는 세로 범위의 직사각형 블록 여부 확인\n                        if ((i <= N - 2 && j <= N - 3 && find(i, j, 2, 3)) || (i <= N - 3 && j <= N - 2 && find(i, j, 3, 2)))\n                            count++;\n                    }\n                }\n                removableBlocks += count;\n            } while(count != 0);\n        }\n        \n        private boolean find(int x, int y, int h, int w) {\n            // 빈 공간을 카운트, 빈 공간은 2개까지만 가능하다. 블록 범위의 크기는 6이고 블록의 크기는 4이기 때문\n            int emptyCount = 0;\n            // 빈 공간이 아닌 블록 번호를 저장, 빈 공간이 아닌 경우에는 이 값과 모두 동일해야 함\n            int lastNum = -1;\n            \n            for (int i = x; i < x + h; i++) {\n                for (int j = y; j < y + w; j++) {\n                    // 빈 공간인 경우\n                    if (board[i][j] == 0) {\n                        if (!canFill(i, j)) return false;\n                        if (++emptyCount > 2) return false;\n                    } else {\n                        // 빈 공간이 아닌 블록 번호가 있고, 현재 영역과 다른 번호라면 같은 블록이 아니므로 종료\n                        if (lastNum != -1 && lastNum != board[i][j]) return false;\n                        lastNum = board[i][j];\n                    }\n                }\n            }\n            \n            removeBlock(x, y, h, w);\n            \n            return true;\n        }\n        \n        // 해당 공간을 채울 수 있는지 확인하는 함수, 해당 행의 윗 행까지가 비어있는지 확인\n        private boolean canFill(int x, int y) {\n            for (int i = 0; i < x; i++)\n                if (board[i][y] != 0) return false;\n            \n            return true;\n        }\n        \n        // 블록 삭제\n        private void removeBlock(int x, int y, int h, int w) {\n            for (int i = x; i < x + h; i++)\n                for (int j = y; j < y + w; j++)\n                    board[i][j] = 0;\n        }\n        \n        public int getCount() {\n            return removableBlocks;\n        }\n    }\n\n    class Solution {\n        public int solution(int[][] board) {\n            Board b = new Board(board);\n            \n            b.findRemovableBlock();\n            \n            return b.getCount();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 문제 자체 이해는 어렵지 않았지만, 구현이 좀 빡셌다.\n- 삭제가 가능한지 아닌지 확인하는 로직이 중요했다."},{"excerpt":"문제 Programmers - 무지의 먹방 라이브 📍 Logic 현재 음식을 먹을 수 있다면,  에서 제외하고 전체 음식 먹은 시간을 증가시킨다. 현재 음식을 먹을 수 없는 경우까지 이를 반복하고, 이후  과 남은 음식 개수  을 이용하여 방송 중단 이후 먹을 음식을 찾는다. 📄 CODE ✏️ Review 처음엔  와 음식 개수를 이용해 각 음식이  초 이…","fields":{"slug":"/[Programmers]42891/"},"frontmatter":{"date":"June 04, 2022","title":"👩‍💻 42891. 무지의 먹방 라이브","tags":["우선순위 큐"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 무지의 먹방 라이브](https://programmers.co.kr/learn/courses/30/lessons/42891)\n\n### 📍 **Logic**\n\n```java\nwhile (totalTime + ((pq.peek().time - prevTime) * len) <= k) {\n    int now = pq.poll().time;\n    totalTime += (now - prevTime) * len;\n    len -= 1;\n    prevTime = now;\n}\n```\n\n- 현재 음식을 먹을 수 있다면, `Queue` 에서 제외하고 전체 음식 먹은 시간을 증가시킨다.\n- 현재 음식을 먹을 수 없는 경우까지 이를 반복하고, 이후 `totalTime` 과 남은 음식 개수 `len` 을 이용하여 방송 중단 이후 먹을 음식을 찾는다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Food implements Comparable<Food> {\n        int time;\n        int idx;\n        \n        public Food(int time, int idx) {\n            this.time = time;\n            this.idx = idx;\n        }\n        \n        @Override\n        public int compareTo(Food f) {\n            return this.time - f.time;\n        }\n    }\n\n    class Solution {\n        public int solution(int[] food_times, long k) {\n            Queue<Food> pq = new PriorityQueue<>();\n            // 모든 음식을 먹는데 걸리는 총 시간\n            long foodSum = 0;\n            int len = food_times.length;\n            \n            for (int i = 0; i < len; i++) {\n                pq.add(new Food(food_times[i], i));\n                foodSum += food_times[i];\n            }\n        \n            // 음식을 다 섭취했는데 아직 K초가 되지 않았다면 -1 반환\n            if (foodSum <= k) return -1;\n            \n            // 먹는데 사용한 시간\n            long totalTime = 0;\n            // 직전에 다 먹은 음식 시간\n            long prevTime = 0;\n            \n            // 현재 음식을 먹을 수 있는 경우, totalTime을 증가\n            while (totalTime + ((pq.peek().time - prevTime) * len) <= k) {\n                int now = pq.poll().time;\n                totalTime += (now - prevTime) * len;\n                len -= 1;\n                prevTime = now;\n            }\n            \n            ArrayList<Food> remainFoods = new ArrayList<>();\n            \n            while (!pq.isEmpty()) remainFoods.add(pq.poll());\n            \n            // idx를 기준으로 오름차순 정렬\n            remainFoods.sort(Comparator.comparingInt(o -> o.idx));\n            \n            return remainFoods.get((int) ((k - totalTime) % len)).idx + 1;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음엔 `K` 와 음식 개수를 이용해 각 음식이 `K` 초 이후 남아있는 양을 계산하여 몇 번째 음식을 먹을지 결정하는 방식을 택했는데, 잘못된 접근법이었다.\n- 참고를 하니 \"음식량이 적은 것을 다 먹게 된다면 어차피 그 보다 음식량이 큰 것들도 이미 다 먹은 음식만큼 먹게 되는 점\"을 이용한 접근법을 사용했었다. \n  - 이 말이 잘 이해되지 않아 시간이 걸렸다."},{"excerpt":"문제 Programmers - 후보키 📍 Logic 후보키를 생성하는 함수 유일성과 최소성을 만족하는 후보키를  에 추가한다. 만든 후보키에 해당하는 속성값으로  을 만들었을때, 중복없이  수만큼 만들어진다면 이를 만족하는 후보키이다. 📄 CODE ✏️ Review 조합과 집합에 대한 문제임은 바로 떠올릴 수 있었지만 \"유일성\" 과 \"최소성\" 을 만족하는 …","fields":{"slug":"/[Programmers]42890/"},"frontmatter":{"date":"June 02, 2022","title":"👩‍💻 42890. 후보키","tags":["조합","집합"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 후보키](https://programmers.co.kr/learn/courses/30/lessons/42890)\n\n### 📍 **Logic**\n\n```java\nprivate void combination(int idx, int start, int keySize, HashSet<Integer> keys, int n, String[][] relation) {\n    if (idx == keySize) {\n        // 이미 뽑은 후보키라면 제외(유일성, 최소성 검사), keys에 key가 포함된다면 최소성 만족 X\n        for (HashSet<Integer> key : candidateKeys)\n            if (keys.containsAll(key)) return;\n\n        // 뽑은 후보키의 인덱스를 확인하여 유일성을 확인할 set\n        HashSet<String> spareKeys = new HashSet<>();\n\n        for (String[] rel : relation) {\n            StringBuilder sb = new StringBuilder();\n\n            // 선택(keys에 추가)한 속성 체크\n            for (int k : keys)\n                sb.append(rel[k]);\n\n            spareKeys.add(sb.toString());\n        }\n\n        // map의 크기와 relation의 길이가 같다면 모든 튜플에 대해서 중복된 값이 없다는 의미이므로 후보키가 될 수 있음\n        if (spareKeys.size() == relation.length)\n            candidateKeys.add(keys);\n    } else {\n        for (int i = start; i < n; i++) {\n            HashSet<Integer> selectedKeys = new HashSet<>(keys);\n            selectedKeys.add(i);\n            combination(idx + 1, i + 1, keySize, selectedKeys, n, relation);\n        }\n    }\n}\n```\n\n- 후보키를 생성하는 함수\n- 유일성과 최소성을 만족하는 후보키를 `candidateKeys` 에 추가한다.\n  - 만든 후보키에 해당하는 속성값으로 `Map` 을 만들었을때, 중복없이 `relation` 수만큼 만들어진다면 이를 만족하는 후보키이다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        // 후보키들을 저장할 ArrayList\n        static ArrayList<HashSet<Integer>> candidateKeys = new ArrayList<>();\n        \n        public int solution(String[][] relation) {\n            int n = relation[0].length;\n            \n            // 1개부터 n개까지의 후보키 생성 시도\n            for (int i = 0; i < n; i++)\n                combination(0, 0, i + 1, new HashSet<>(), n, relation);\n            \n            return candidateKeys.size();\n        }\n        \n        private void combination(int idx, int start, int keySize, HashSet<Integer> keys, int n, String[][] relation) {\n            if (idx == keySize) {\n                // 이미 뽑은 후보키라면 제외(유일성, 최소성 검사), keys에 key가 포함된다면 최소성 만족 X\n                for (HashSet<Integer> key : candidateKeys)\n                    if (keys.containsAll(key)) return;\n\n                // 뽑은 후보키의 인덱스를 확인하여 유일성을 확인할 set\n                HashSet<String> spareKeys = new HashSet<>();\n\n                for (String[] rel : relation) {\n                    StringBuilder sb = new StringBuilder();\n\n                    // 선택(keys에 추가)한 속성 체크\n                    for (int k : keys)\n                        sb.append(rel[k]);\n\n                    spareKeys.add(sb.toString());\n                }\n\n                // map의 크기와 relation의 길이가 같다면 모든 튜플에 대해서 중복된 값이 없다는 의미이므로 후보키가 될 수 있음\n                if (spareKeys.size() == relation.length)\n                    candidateKeys.add(keys);\n            } else {\n                for (int i = start; i < n; i++) {\n                    HashSet<Integer> selectedKeys = new HashSet<>(keys);\n                    selectedKeys.add(i);\n                    combination(idx + 1, i + 1, keySize, selectedKeys, n, relation);\n                }\n            }\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 조합과 집합에 대한 문제임은 바로 떠올릴 수 있었지만 \"유일성\" 과 \"최소성\" 을 만족하는 후보키를 구현하는데에서 막혔다 .."},{"excerpt":"문제 Programmers - 길 찾기 게임 📍 Logic 트리를 생성하는 함수 노드의  좌표를 기준으로 왼쪽 또는 오른쪽 자식 여부가 결정된다. 📄 CODE ✏️ Review 고문해시간에 BFS 형식으로 입력받아 이를 preorder, postorder로 출력했던 과제가 생각나 아이디어는 쉽게 잡을 수 있었다. x값 좌표에 따른 왼쪽, 오른쪽 자식 여부에…","fields":{"slug":"/[Programmers]42892/"},"frontmatter":{"date":"May 31, 2022","title":"👩‍💻 42892. 길 찾기 게임","tags":["그래프"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 길 찾기 게임](https://programmers.co.kr/learn/courses/30/lessons/42892)\n\n### 📍 **Logic**\n\n```java\npublic void insert(Node input) {\n    // root가 없다면 root 지정, root가 있다면, 자식 노드 탐색하여 저장\n    if (root == null) root = input;\n    else insert(input, root);\n}\n\nprivate void insert(Node input, Node root) {\n    // 부모보다 x값이 작은 경우에는 left를 탐색, 그렇지 않으면 right 탐색\n    if (input.data.x < root.data.x) {\n        if (root.left == null) root.left = input;\n        else insert(input, root.left);\n    } else {\n        if (root.right == null) root.right = input;\n        else insert(input, root.right);\n    }\n}\n```\n\n- 트리를 생성하는 함수\n- 노드의 `x` 좌표를 기준으로 왼쪽 또는 오른쪽 자식 여부가 결정된다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Loc {\n        int x;\n        int y;\n        int value;\n\n        public Loc(int x, int y, int value) {\n            this.x = x;\n            this.y = y;\n            this.value = value;\n        }\n    }\n\n    class Node {\n        Loc data;\n        Node left;\n        Node right;\n\n        public Node(Loc data) {\n            this.data = data;\n            this.left = null;\n            this.right = null;\n        }\n    }\n\n    class Tree {\n        Node root;\n        int[] list;\n        int size;\n        int idx;\n\n        public Tree(int size) {\n            this.root = null;\n            this.size = size;\n        }\n\n        public void insert(Node input) {\n            // root가 없다면 root 지정, root가 있다면, 자식 노드 탐색하여 저장\n            if (root == null) root = input;\n            else insert(input, root);\n        }\n\n        private void insert(Node input, Node root) {\n            // 부모보다 x값이 작은 경우에는 left를 탐색, 그렇지 않으면 right 탐색\n            if (input.data.x < root.data.x) {\n                if (root.left == null) root.left = input;\n                else insert(input, root.left);\n            } else {\n                if (root.right == null) root.right = input;\n                else insert(input, root.right);\n            }\n        }\n\n        public int[] preOrder() {\n            list = new int[size];\n            idx = 0;\n            preOrderTraversal(root);\n\n            return list;\n        }\n\n        private void preOrderTraversal(Node n) {\n            if (n == null) return;\n\n            list[idx++] = n.data.value;\n            preOrderTraversal(n.left);\n            preOrderTraversal(n.right);\n        }\n\n        public int[] postOrder() {\n            list = new int[size];\n            idx = 0;\n            postOrderTraversal(root);\n\n            return list;\n        }\n\n        private void postOrderTraversal(Node n) {\n            if (n == null) return;\n\n            postOrderTraversal(n.left);\n            postOrderTraversal(n.right);\n            list[idx++] = n.data.value;\n        }\n    }\n\n    class Solution {\n        public int[][] solution(int[][] nodeinfo) {\n            ArrayList<Loc> locs = new ArrayList<>();\n            int size = nodeinfo.length;\n\n            for (int i = 0; i < size; i++)\n                locs.add(new Loc(nodeinfo[i][0], nodeinfo[i][1], i + 1));\n\n            // x값은 오름차순, y값은 내림차순으로 정렬하여 BFS 형식으로 변환\n            locs.sort(((o1, o2) -> {\n                if (o1.y == o2.y) return o1.x - o2.x;\n                return o2.y - o1.y;\n            }));\n\n            Tree t = new Tree(size);\n\n            for (Loc l : locs) \n                t.insert(new Node(l));\n            \n            return new int[][] {t.preOrder(), t.postOrder()};\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 고문해시간에 BFS 형식으로 입력받아 이를 preorder, postorder로 출력했던 과제가 생각나 아이디어는 쉽게 잡을 수 있었다.\n- x값 좌표에 따른 왼쪽, 오른쪽 자식 여부에 대한 고려를 통해 트리를 생성해야 하는 생각이 키 포인트였지 않을까 ..\n  - `insert()` 를 오버로딩하는 방식을 사용해보았다!"},{"excerpt":"이진 트리는 하나의 부모가 두 개의 자식밖에 가지지 못하고, 편향된다면 탐색 효율이 선형 탐색급으로 떨어진다. 하지만 이진 트리 구조의 간결함과 균형만 맞다면 탐색, 삽입, 삭제 모두 의 성능을 보이는 장점이 있다. 🧷 B Tree 데이터베이스, 파일 시스템에서 널리 사용되는 트리 자료구조의 일종이다. 이진 트리를 확장하여 더 많은 수의 자식을 가질 수 …","fields":{"slug":"/[CS]BTree&B+Tree/"},"frontmatter":{"date":"May 30, 2022","title":"📂 B Tree & B+ Tree","tags":["Java","BTree","B+Tree"]},"rawMarkdownBody":"\n> **이진 트리**는 하나의 부모가 두 개의 자식밖에 가지지 못하고, 편향된다면 탐색 효율이 선형 탐색급으로 떨어진다. 하지만 이진 트리 구조의 간결함과 균형만 맞다면 탐색, 삽입, 삭제 모두 $O(logN)$의 성능을 보이는 장점이 있다.\n\n## 🧷 B Tree\n데이터베이스, 파일 시스템에서 널리 사용되는 트리 자료구조의 일종이다. 이진 트리를 확장하여 **더 많은 수의 자식**을 가질 수 있게 일반화시킨 트리 자료구조이다. (**이진 트리는 아니다!**)\n- 자식 수에 대한 일반화를 진행하면서, 하나의 레벨에 더 저장할 수 있는 것뿐 아니라 트리의 균형을 자동으로 맞춰주는 로직 또한 갖추었다.\n  - 따라서, **균형 트리**의 장점과 **효율적인 데이터 로드**의 장점을 갖추었다.\n\n> **레벨에 더 많은 저장이 가능하다는 것의 장점**\n> \n> 대량의 데이터 처리 시, 검색 구조의 경우 하나의 노드에 많은 데이터를 가질 수 있다는 것은 큰 장점이다. 대량의 데이터는 메모리보다 블럭 단위로 입출력하는 HDD or SSD에 저장해야 하기 때문이다.\n> - ex. 한 블럭이 1024바이트면, 2바이트를 읽으나 1024바이트를 읽으나 똑같은 입출력 비용이 발생한다. 따라서 하나의 노드를 모두 1024바이트로 꽉 채워서 조절할 수 있다면 효율적일 것이다.\n>\n> B Tree는 이러한 장점을 토대로 많은 DB 시스템의 인덱스 저장 방법으로 애용하고 있다.\n\n### 🪚 규칙\n- 노드의 자료수가 N개이면, 자식 수는 N + 1이어야 한다.\n- 각 노드의 자료는 정렬된 상태여야 한다.\n- 루트 노드는 적어도 2개 이상의 자식을 가져야 한다.\n- 루트 노드를 제외한 모든 노드는 적어도 M/2개의 자료를 가지고 있어야 한다.\n- 외부 노드로 가는 경로의 길이는 모두 같다.\n- 입력 자료는 중복이 없어야 한다.\n\n---\n\n## 🧷 B+ Tree\n\n<img src=\"../../images/B+Tree.jpeg\" width=\"80%\">\n\n데이터의 빠른 접근을 위한 **인덱스 역할만 하는 비단말 노드가 추가로 있는** 트리 자료구조이다. 기존의 B Tree와 데이터의 연결리스트로 구현된 색인 구조이다.\n- B Tree의 변형 구조로, index 부분과 leaf 노드로 구성된 순차 데이터 부분으로 이루어진다. 인덱스 부분의 key 값은 leaf에 있는 key 값을 직접 찾아가는데 사용한다.\n- `p` (fanout) 이라는 값으로 한 node에 몇 개의 entry가 채워져야 하는지를 나타낸다.\n\n### 🪚 장점\n- 블록 사이즈를 더 많이 사용할 수 있다. (key 값에 대한 HDD 접근 주소가 없기 때문이다.)\n- leaf 노드끼리 연결 리스트로 연결되어 범위 탐색에 매우 유리하다.\n\n### 🪚 단점\n- B Tree의 경우 최상 케이스에서는 루트에서 끝날 수 있지만, B+ Tree는 무조건 leaf 노드까지 내려가봐야 한다.\n  - **탐색 비용이 트리의 높이에 비례**하게 된다!\n\n### 🪚 삽입\n- 삽입하려는 entry가 위치할 곳을 찾는다.\n- 해당 node가 충분한 공간이 있다면 삽입하고 종료한다.\n- 그렇지 않은 경우, **해당 node를 분리**한다.\n  - node의 엔트리들을 분배하고, `middle key` 를 **COPY UP**한다.\n\n> PUSH UP하면, `middle key` 에 대한 Data pointer가 손실되기 때문이다.\n\n### 🪚 삽입 이후 ...\n\n<img src=\"../../images/AfterInsertionB+Tree.jpeg\" width=\"80%\">\n\nB+ Tree에 node를 삽입한 이후 트리의 높이가 증가하지 않을 수도 있고, 증가할 수도 있다.\n- B+ Tree의 탐색 비용은 트리의 높이에 비례한다.\n- **트리를 재분배**함으로써, 높이를 낮출 수 있다!\n\n> 재분배를 통해 탐색 비용을 낮출 수는 있지만, 평균 I/O 바용을 증가시킨다.\n\n### 🪚 삭제\n- 루트부터, 해당 entry가 존재하는 leaf node를 찾는다.\n- 해당 node에서 entry를 지워도 채워져야 하는 `p` 를 만족한다면 그대로 삭제한다.\n- 지운 후 node의 entry 수가 `p - 1` 이라면, 주변 leaf node(같은 부모를 가지는 주변 node)로부터 entry를 빌려와 `p` 를 만족시킨다.\n  - 이는 `middle key` 의 변경을 유발한다.\n  - 만약 주변 leaf node로부터 빌려올 수 없다면, 그 **leaf node와 결합**한다.\n    - 결합이 발생하면, **둘 중 한 node는 제거**한다.\n    - 결합을 통해 **트리의 높이가 감소**할 수도 있다.\n\n---\n\n## 🧷 B Tree와 B+ Tree 비교\n- B Tree는 각 노드에 데이터가 저장된다.\n- B+ Tree는 index 노드와 leaf 노드로 분리되어 저장된다. (또한 leaf 노드는 서로 연결되어 있어 임의 접근이나 순차 접근 모두 성능이 좋다.)\n\n- B Tree는 각 노드에서 key와 data 모두 들어갈 수 있고, data는 disk block으로 포인터가 될 수 있다.\n- B+ Tree는 각 노드에서 key만 들어갈 수 있다. 따라서 data는 모두 leaf 노드에만 존재한다.\n  - B+ Tree의 삽입과 삭제는 모두 leaf 노드에서만 발생한다.\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/B%20Tree%20&%20B+%20Tree.html)"},{"excerpt":"포스트와 관련된 모든 코드들은 참고 URL에서 확인할 수 있습니다. 🧷 HashMap Java Collections Framework에 속한 구현체 클래스이다. 🪚 HashMap과 HashTable 이 둘은 Java의 API 이름이다.  또한  인터페이스를 구현하고 있어  과 제공하는 기능은 같다. 하지만  은 보조 해시 함수(2차 해시 함수)를 사용하여…","fields":{"slug":"/[CS]HashMap동작방식/"},"frontmatter":{"date":"May 29, 2022","title":"📂 HashMap 동작방식","tags":["Java","HashMap"]},"rawMarkdownBody":"\n<em>포스트와 관련된 모든 코드들은 참고 URL에서 확인할 수 있습니다.</em>\n\n## 🧷 HashMap\n**Java Collections Framework**에 속한 구현체 클래스이다.\n\n### 🪚 HashMap과 HashTable\n이 둘은 Java의 API 이름이다. `HashTable` 또한 `Map` 인터페이스를 구현하고 있어 `HashMap` 과 제공하는 기능은 같다.\n- 하지만 `HashMap` 은 보조 해시 함수(2차 해시 함수)를 사용하여 보조 해시 함수를 사용하지 않는 `HashTable` 에 비해 해시 충돌이 덜 발생할 수 있어 상대적인 성능상 이점이 있다.\n- 또한, `HashTable` 구현은 거의 변화가 없지만, `HashMap` 은 지속적으로 개선되고 있다.\n\n> HashTable은 JDK 1.0부터 있던 API이고, HashMap은 Java 2에서 처음 선보인 Java Collections Framework에 속한 API다.\n\n이 둘을 **정의**한다면, \"키에 대한 해시 값을 사용하여 값을 저장하고 조회하며, 키-값 쌍의 개수에 따라 동적으로 크기가 증가하는 associate array\"라고 할 수 있다.\n- `map` 은 원래 대응 관계를 지칭하는 용어로, `HashMap` 은 키 집합인 정의역과 값 집합인 공역의 대응에 해시 함수를 이용한다.\n\n> associate array를 지칭하는 다른 용어로는 `Map` , `Dictionary` , `Symbol Table` 등이 있다.\n\n이 둘의 **선언부**를 보면, associate array를 지칭하기 위해 `HashTable` 은 `Dictionary` 라는 이름을 사용하고, `HashMap` 은 이름 그대로 `Map` 이라는 용어를 사용한다.\n\n```java\npublic class 8ccce55530bc3477c678dd9921b60f3e.gifHashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { ... }\n\npublic class 928b3cc3fe40d69cd06cbe7f5f3767f8.gifHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { ... }\n```\n\n### 🪚 해시 분포와 해시 충돌\n동일하지 않은 어떤 객체 X와 Y가 있을 때, `X.equals(Y)` 가 거짓일 때 `X.hashCode() != Y.hashCode()` 이라면, 이때 사용하는 해시 함수는 **완전한 해시 함수**라고 한다.\n\n`Boolean` 같이 서로 구별되는 객체의 종류가 적거나, `Integer` , `Long` , `Double` 같은 `Number` 객체는 객체가 나타내려는 값 자체를 해시 값으로 사용할 수 있기 때문에 완전한 해시 함수 대상으로 삼을 수 있다.\n- 하지만 `String` 이나 `POJO(Plain Old Java Object)` 에 대하여 완전한 해시 함수를 제작하는 것은 사실상 불가능하다.\n\n<details>\n  <summary><strong>POJO(Plain Old Java Object) 💫</strong></summary>\n    <div markdown=\"1\">\n\n  말 그대로 오래된 방식의 간단한 자바 객체라는 말로, 중량 프레임워크들을 사용하게 되면서 해당 프레임워크에 종속된 \"무거운\" 객체를 만들게 된 것에 반발해서 사용하게 된 용어이다.\n  - 해당 용어는 이후 특정 자바 모델이나 기능, 프레임워크 등을 따르지 않은 자바 객체를 지칭하는 말로 사용되었고, 대표적으로 **스프링 프레임워크**가 POJO 방식의 프레임워크다.\n  - 이상적으로는 자바 언어 사양 외에 어떠한 제한에도 묶이지 않은 자바 객체이므로, **미리 정의된 클래스의 확장**, **미리 정의된 인터페이스의 구현**, **미리 정의된 어노테이션을 포함**하는 행동을 해서는 안된다.\n  - 하지만, 대부분 실제 정상 동작을 위해 미리 정의된 어노테이션의 사용을 요구한다.\n    </div>\n</details>\n\n적은 연산만으로 빠르게 동작할 수 있는 완전한 해시 함수가 있더라도, 이를 `HashMap` 에서 사용할 수 있는 것은 아니다.\n- `HashMap` 은 기본적으로 각 객체의 `hashCode()` 가 반환하는 값을 사용하고, 결과의 자료형은 `int` 다. 그리고 **32비트 정수 자료형으로는 완전 자료 해시 함수를 만들 수 없다.**\n  - 논리적으로, 생성 가능한 객체의 수가 $2^{32}$보다 많을 수 있고\n  - 모든 `HashMap` 객체에서 $O(1)$을 보장하기 위해 임의 접근이 가능하게 하려면 원소가 $2^{32}$인 배열을 모든 `HashMap` 이 가지고 있어야 하기 때문이다.\n\n**따라서** `HashMap` 을 비롯한 많은 해시 함수를 이용하는 associate array 구현체에서는 메모리를 절약하기 위해 실제 해시 함수의 표현 정수 범위 $|N|$보다 작은 M개의 원소가 있는 배열만을 사용한다.\n- 그리고 객체에 대한 해시 코드의 나머지 값을 해시 버킷 인덱스 값으로 사용한다.\n\n```java\nint index = X.hashCode() % M;\n```\n\n이러한 방식은, 서로 다른 해시 코드를 가지는 **서로 다른 객체**가 1/M의 확률로 **같은 해시 버킷을 사용**하게 된다.\n- 이는 또 다른 종류의 해시 충돌이고, 이를 해결하기 위해 키-값 쌍 데이터를 잘 저장하고 조회할 수 있게 하는 방식은 아래 2가지가 있다. 아래 두 방식에 대한 설명은 [POST](https://subbblog.netlify.app/[Algorithm]HashTable/)에서 확인할 수 있다.\n  - Open Addressing\n  - Separate Chaining\n\n### 🪚 Java 8 HashMap에서의 Separate Chaining\nJava `HashMap` 에서 사용하는 방식은 Separate Chaining이다. 그리고 위에서 언급했듯, `HashMap` 은 지속적으로 개선되고 있다.\n- Java 2 ~ 7까지는 코드는 달라도 구현 알고리즘 자체는 같았고, 해시 함수의 값이 균등 분포 상태라는 가정 하에, `get()` 의 호출 기댓값은 $E(\\frac{N}{M})$ 이다.\n- 하지만 Java 8에서는 이전까지 사용했던 **연결 리스트 방식에서 트리 방식으로 변경**하여, 호출 기댓값이 $E(log\\frac{N}{M})$ 을 보장하여 성능상의 이점이 있다.\n\n> 연결 리스트를 사용할 것인가, 트리를 사용할 것인가를 결정하는 요인은 하나의 해시 버킷에 할당된 키-값 쌍의 개수이고, 이 또한 [POST](https://subbblog.netlify.app/[Algorithm]HashTable/)에서 다루었다.\n\nJava 8 `HashMap` 은 `Entry` 클래스 대신 `Node` 클래스를 사용한다. 이 클래스에는 Java 7 `HashMap` 과 달리 트리를 사용할 수 있도록 하위 클래스에 `TreeNode` 를 포함하고 있다.\n- 이때 `Red-Black Tree` 를 사용하고, 트리 순회 시 사용하는 대소 판단 기준은 **해시 함수 값**이다.\n\n### 🪚 해시 버킷 동적 확장\n해시 버킷의 개수가 적다면, 메모리 사용을 아낄 수 있지만 해시 충돌로 인해 성능상 손실이 발생한다.\n- 따라서 `HashMap` 은 일정 개수 이상의 데이터가 있다면, 해시 버킷의 개수를 **2배로 늘린다.**\n- 해시 버킷의 개수를 늘림으로써, 값도 작아져 해시 충돌로 인한 성능 손실 문제를 어느 정도 해결할 수 있다.\n\n해시 버킷의 개수의 기본값은 `16` 이고, 임계점에 이를 때마다 두 배씩 증가시킨다.\n- 버킷의 최대 개수는 $2^{30}$개다.\n- 임계점은 **현재의 데이터 개수가 \"load factor * 현재의 해시 버킷 개수\"에 이를 때**이다. (`load factor` 는 0.75, 즉 3/4이다.)\n\n하지만 두 배로 증가할 때마다, 모든 키-값 쌍을 읽어 새로운 Separate Chaining을 구성해야 하는 문제가 발생한다.\n- `HashMap` 생성자의 인자로 초기 해시 버킷 개수를 지정할 수 있으므로, 해당 `HashMap` 객체에 저장될 데이터의 개수가 어느 정도인지 예측 가능한 경우에는 이를 생성자의 인자로 지정하면 불필요한 Separate Chaining의 재구성을 피할 수 있다.\n\n또다른 문제로, 해시 버킷의 개수 m이 $2^a$ 형태가 되기에, `index = X.hashCode() % M` 계산 시 `X.hashCode()` 의 하위 a개의 비트만 사용하게 된다.\n- 즉 해시 함수가 32비트 영역을 고르게 사용하도록 만들었더라도 해시 값을 2의 승수로 나누면 해시 충돌이 쉽게 발생할 수 있다. \n\n> 따라서 **보조 해시 함수**가 필요하다.\n\n### 🪚 보조 해시 함수\n`index = X.hashCode() % M` 계산 시에는 M이 소수일 때 `index` 값의 분포가 가장 균등할 수 있다.\n- 하지만 소수가 아니기 때문에 별도의 보조 해시 함수를 사용하여 균등 분포를 돕는다.\n\n보조 해시 함수의 목적은 **'키'의 해시 값을 변형하여, 해시 충돌 가능성을 줄이는 것**이다.\n- Java 5 ~ 7까지는 동일한 방식의 보조 해시 함수를 사용했는데, **Java 8부터는 좀 더 단순한 형태로 변경**되었다.\n- 단순하게 상위 16비트 값을 XOR 연산하는 방식으로 변경되었는데, 아래 2가지 이유가 있다.\n  - Java 8에서는 해시 충돌이 많이 발생하면 연결 리스트 대신 트리를 사용함으로써 성능 문제를 많이 완화했기 때문이다.\n  - 최근의 해시 함수는 균등 분포를 잘 만드는 경향이 있어 보조 해시 함수의 효과가 크지 않기 때문이다.\n\n### 🪚 String 객체에 대한 해시 함수\nString 객체에 대한 해시 함수 수행 시간은 문자열 길이에 비례한다. \n- JDK 1.1에서는 더 빠른 해시 함수 수행을 위해 **일정 간격의 문자에 대한 해시를 누적한 값**을 String에 대한 해시 함수로 사용했다.\n\n하지만 이러한 방식은 다음과 같은 문제를 야기했다.\n- 웹상의 URL은 길이가 수십 글자에 이르면서 앞 부분은 동일하게 구성되는 경우가 많다.\n- 이 경우 서로 다른 URL의 해시 값이 같아지는 빈도가 매우 높아질 수 있다.\n\n> 따라서 Horner's method를 구현한 방식을 사용하고 있다.\n\nString 객체 해시 함수에서 31을 사용하는데, \n- 31은 소수이며, 어떤 수에 31을 곱하는 것은 빠르게 계산할 수 있다.\n  - `31N = 32N - N = (N << 5) - N`\n- 즉, 성능 향상을 도모한다!\n\n---\n\n## 📕 참고\n- [Java HashMap은 어떻게 동작하는가?](https://d2.naver.com/helloworld/831311)\n- [Plain Old Java Object](https://ko.wikipedia.org/wiki/Plain_Old_Java_Object)"},{"excerpt":"문제 BOJ - 겹치는 건 싫어 📍 Logic  을 이용해 해당 숫자가 문자열에 나타난 횟수를 저장한다. 이미  개가 문자열에 들어있다면,  지점에 있는 숫자부터 1개씩 줄여나간다.  에서 -1하고,  를 1씩 증가시킨다. 아직  개가 문자열에 들어있지 않다면, 나타난 횟수를 1씩 증가시킨다. 아직 문자열에 들어있지 않은 경우와  개가 문자열에 들어있지 …","fields":{"slug":"/[BOJ]20922/"},"frontmatter":{"date":"May 28, 2022","title":"👩‍💻 20922. 겹치는 건 싫어","tags":["투 포인터"]},"rawMarkdownBody":"\n## 문제\n[BOJ - 겹치는 건 싫어](https://www.acmicpc.net/problem/20922)\n\n### 📍 **Logic**\n\n```java\nwhile(s <= e) {\n    if (e == numbers.length) {\n        max = Math.max(max, e - s);\n        break;\n    }\n    int n = numbers[e];\n\n    if (numMap.containsKey(n)) {\n        if (numMap.get(n) == K) {\n            max = Math.max(max, e - s);\n            int count = numMap.get(numbers[s]) - 1;\n            if (count == 0) numMap.remove(numbers[s]);\n            else numMap.put(numbers[s], count);\n            s++;\n        } else {\n            numMap.put(n, numMap.getOrDefault(n, 0) + 1);\n            e++;\n        }\n    } else {\n        numMap.put(n, 1);\n        e++;\n    }\n}\n```\n- `Map` 을 이용해 해당 숫자가 문자열에 나타난 횟수를 저장한다.\n- 이미 `K` 개가 문자열에 들어있다면, `s` 지점에 있는 숫자부터 1개씩 줄여나간다.\n  - `Map` 에서 -1하고, `s` 를 1씩 증가시킨다.\n- 아직 `K` 개가 문자열에 들어있지 않다면, 나타난 횟수를 1씩 증가시킨다.\n- 아직 문자열에 들어있지 않은 경우와 `K` 개가 문자열에 들어있지 않은 경우만 `e` 를 증가시켜 다음 숫자를 확인할 수 있도록 한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.lang.reflect.Array;\n    import java.util.*;\n    import java.util.regex.Matcher;\n    import java.util.regex.Pattern;\n\n\n    class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int[] info = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n            int N = info[0];\n            int K = info[1];\n            int s = 0;\n            int e = 0;\n            int max = 0;\n            Map<Integer, Integer> numMap = new HashMap<>();\n\n            int[] numbers = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\n            while(s <= e) {\n                if (e == numbers.length) {\n                    max = Math.max(max, e - s);\n                    break;\n                }\n                int n = numbers[e];\n\n                if (numMap.containsKey(n)) {\n                    if (numMap.get(n) == K) {\n                        max = Math.max(max, e - s);\n                        int count = numMap.get(numbers[s]) - 1;\n                        if (count == 0) numMap.remove(numbers[s]);\n                        else numMap.put(numbers[s], count);\n                        s++;\n                    } else {\n                        numMap.put(n, numMap.getOrDefault(n, 0) + 1);\n                        e++;\n                    }\n                } else {\n                    numMap.put(n, 1);\n                    e++;\n                }\n            }\n\n            System.out.println(max);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 투 포인터를 사용하는 문제 중 그나마 쉬워보여서 푼 문제\n- `s` 와 `e` 에 대한 착각으로 시간이 좀 걸렸다...\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/17779"},{"excerpt":"🧷 이진 탐색 트리 이진 탐색 + 연결 리스트 이진 탐색 : 탐색에 소요되는 시간복잡도는 , 하지만 삽입, 삭제가 불가능 연결 리스트 : 삽입, 삭제의 시간복잡도는, 탐색하는 시간복잡도가  이 두 가지를 합하여 장점을 모두 얻어 효율적인 탐색 능력과 자료의 삽입, 삭제도 가능하게 하는 이진 탐색 트리 🪚 특징 노드에 저장된 키는 유일 (중복이 없어야 함)…","fields":{"slug":"/[CS]이진탐색트리/"},"frontmatter":{"date":"May 28, 2022","title":"📂 이진탐색트리(Binary Search Tree)","tags":["개발상식","Java","BST"]},"rawMarkdownBody":"\n## 🧷 이진 탐색 트리\n> 이진 탐색 + 연결 리스트\n\n- **이진 탐색** : 탐색에 소요되는 시간복잡도는 $O(logN)$, 하지만 삽입, 삭제가 불가능\n- **연결 리스트** : 삽입, 삭제의 시간복잡도는$O(1)$, 탐색하는 시간복잡도가 $O(N)$\n\n이 두 가지를 합하여 장점을 모두 얻어 효율적인 탐색 능력과 자료의 삽입, 삭제도 가능하게 하는 **이진 탐색 트리**\n\n### 🪚 특징\n- 노드에 저장된 키는 유일 (중복이 없어야 함)\n- 각 노드의 자식이 2개 이하\n- 각 노드의 왼쪽 자식은 부모보다 작고, 오른쪽 자식은 부모보다 큼\n- 왼쪽과 오른쪽 서브 트리도 이진 탐색 트리\n\n> **중복이 없어야 하는 이유**\n> \n> : 검색 목적 자료구조인데, 굳이 중복이 많은 경우에 트리를 사용하여 검색 속도를 느리게 할 필요가 없다.\n\n이진 탐색 트리의 순회는 **\"중위 순회(inorder)\"** 방식으로, 정렬된 순서로 읽을 수 있다.\n\n### 🪚 BST 핵심 연산\n- 검색\n- 삽입\n- 삭제\n- 트리 생성, 삭제\n\n### 🪚 시간 복잡도\n노드 개수가 N개일 때,\n- 균등 트리: $O(logN)$\n- 편향 트리: $O(N)$\n\n> 삽입, 검색, 삭제 시간복잡도는 **트리의 Depth**에 비례\n\n**삭제의 3가지 경우**\n1. 자식이 없는 리프 노드일 때 -> 그냥 삭제!\n2. 자식이 1개인 노드일 때 -> 자식 노드와 교환 후, 삭제\n3. 자식이 2개인 노드일 때 -> 오른쪽 자식 노드에서 가장 작은 값 또는 왼쪽 자식 노드에서 가장 큰 값과 교환 후, 삭제\n\n편향된 트리는 시간복잡도가 $O(N)$이므로 트리를 사용할 이유가 없다!\n- 이를 바로 잡도록 `Rebalancing` 하는 개선방안이 **AVL Tree**, **RedBlack Tree**\n\n```java\nclass BinarySearchTree {\n  public class Node {\n    int data;\n    Node left;\n    Node right;\n\n    public Node(int data) {\n      this.data = data;\n      this.left = null;\n      this.right = null;\n    }\n  }\n\n  public Node root;\n  public BinarySearchTree() {\n    this.root = null;\n  }\n\n  public boolean find(int id) {\n    Node cur = root;\n\n    while(cur != null) {\n      if (cur.data == id) return true;\n      else if(cur.data > id) cur = cur.left;\n      else cur = cur.right;\n    }\n\n    return false;\n  }\n\n  public boolean delete(int id) {\n    Node parent = root;\n    Node cur = root;\n    boolean isLeftChild = false;\n\n    while(cur.data != id) {\n      parent = cur;\n      if (cur.data > id) {\n        isLeftChild = true;\n        cur = cur.left;\n      } else {\n        isLeftChild = false;\n        cur = cur.right;\n      }\n      if (cur == null) return false;\n    }\n\n    // case1. 자식 노드가 없는 경우 -> 그냥 삭제\n    if (cur.left == null && cur.right == null) {\n      if (cur == root) root = null;\n      if (isLeftChild == true) parent.left = null;\n      else parent.right = null;\n    } \n    // case2. 자식 노드가 1개인 경우 -> 교환 후 삭제\n    else if (cur.right == null) {\n      if (cur == root) root = cur.left;\n      else if (isLeftChild) parent.left = cur.left;\n      else parent.right = cur.left;\n    } else if (cur.left == null) {\n      if (cur == root) root = cur.left;\n      else if (isLeftChild) parent.left = cur.right;\n      else parent.right = cur.right;\n    }\n    // case3. 자식 노드가 2개인 경우 -> 오른쪽 자식 노드 중 최솟값과 교환 후 삭제\n    else if (cur.left != null && cur.right != null) {\n      Node minNode = getMin(cur);\n      if (cur == root) root = minNode;\n      else if (isLeftChild) parent.left = minNode;\n      else parent.right = minNode;\n      minNode.left = cur.left;\n    }\n\n    return true;\n  }\n\n  // 오른쪽 서브 트리에서 최솟값을 반환\n  public Node getMin(Node deleteNode) {\n    Node minNode = null;\n    Node minNodeParent = null;\n    Node cur = deleleNode.right;\n\n\t\twhile(cur != null) {\n\t\t\tminNodeParent = minNode;\n\t\t\tminNode = cur;\n\t\t\tcur = cur.left;\n\t\t}\n\n\t\tif (minNode != deleleNode.right) {\n\t\t\tminNodeParent.left = minNode.right;\n\t\t\tminNode.right = deleleNode.right;\n\t\t}\n\n\t\treturn minNode;\n  }\n\n  public void insert(int id) {\n    Node newNode = new Ndoe(id);\n    if (root == null) {\n      root = newNode;\n      return;\n    }\n\n    Node cur = root;\n    Node parent = null;\n\n    while(true) {\n      parent = cur;\n\n      if (id < cur.date) {\n        cur = cur.left;\n        if (cur == null) {\n          parent.left = newNode;\n          return;\n        }\n      } else {\n        cur = cur.right;\n        if (cur == null) {\n          parent.right = newNode;\n          return;\n        }\n      }\n    }\n  }\n\n  public void print(Node root) {\n    if (root != null) {\n      print(root.left);\n      System.out.println(\" \" + root.date);\n      print(root.right);\n    }\n  }\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Tree.html)\n- [BST (Binary Search Tree)](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/DataStructure#bst-binary-search-tree)"},{"excerpt":"문제 BOJ - 나는 친구가 적다(Large) 📍 Logic 📄 CODE ✏️ Review 정규표현식으로 접근했다가 엄청난 시간초과를 맞닥뜨려 무슨 알고리즘을 쓰는지 봤다. KMP 알고리즘은 잘 이해하지 못해서 후에 다시 이해한 후에 로직을 적어봐야 할 것 같다.","fields":{"slug":"/[BOJ]16172/"},"frontmatter":{"date":"May 28, 2022","title":"👩‍💻 16172. 나는 친구가 적다(Large)","tags":["문자열","KMP"]},"rawMarkdownBody":"\n## 문제\n[BOJ - 나는 친구가 적다(Large)](https://www.acmicpc.net/problem/16172)\n\n### 📍 **Logic**\n\n```java\n\n```\n- \n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.*;\n    import java.util.Stack;\n    import java.util.regex.Matcher;\n    import java.util.regex.Pattern;\n\n    class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\n            String book = br.readLine().replaceAll(\"\\\\d\", \"\");\n            String keyword = br.readLine();\n\n            System.out.println(KMP(book, keyword) ? 1 : 0);\n        }\n\n        public static int[] computeTable(String book) {\n            int n = book.length();\n            int[] table = new int[n];\n\n            int idx = 0;\n            for (int i = 1; i < n; i++) {\n                // 문자가 일치하면, 연속적으로 일치할 때까지 탐색\n                // 일치하지 않는 경우 이전 idx의 table값을 idx로\n                while (idx > 0 && book.charAt(i) != book.charAt(idx))\n                    idx = table[idx - 1];\n\n                if (book.charAt(i) == book.charAt(idx)) {\n                    idx += 1;\n                    table[i] = idx;\n                }\n            }\n            return table;\n        }\n\n        public static boolean KMP(String book, String keyword) {\n            int n1 = book.length();\n            int n2 = keyword.length();\n\n            int[] table = computeTable(book);\n\n            boolean found = false;\n\n            int idx = 0; // 현재 대응되는 글자 수\n            for(int i = 0; i < n1; i++) {\n                // 키워드의 idx번 글자와 교과서의 해당 글자가 불일치할 경우,\n                // 현재 대응된 글자의 수를 table[idx-1]번으로 줄인다.\n                while (idx > 0 && book.charAt(i) != keyword.charAt(idx))\n                    idx = table[idx - 1];\n\n                // 글자가 대응될 경우\n                if (book.charAt(i) == keyword.charAt(idx)) {\n                    if (idx == n2 - 1) {\n                        found = true;\n                        break;\n                    } else\n                        idx += 1;\n                }\n            }\n\n            return found;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 정규표현식으로 접근했다가 엄청난 시간초과를 맞닥뜨려 무슨 알고리즘을 쓰는지 봤다.\n- KMP 알고리즘은 잘 이해하지 못해서 후에 다시 이해한 후에 로직을 적어봐야 할 것 같다."},{"excerpt":"🧷 트리 값을 가진 노드(Node)와 이 노드들을 이어주는 간선(Edge)로 이루어진 자료구조이다. 트리라는 이름이 나온 이유? : 실제 나무를 거꾸로 세워놓은 듯한 모양을 보이기 때문이다. 그림에서, 데이터 1을 가진 노드가 루트 노드이다. 모든 노드들은 0개 이상의 자식 노드를 가지고 있으며, \"부모-자식 관계\"로 불린다. 선형 자료구조에서 배열이나 …","fields":{"slug":"/[CS]Tree/"},"frontmatter":{"date":"May 27, 2022","title":"📂 Tree(트리)","tags":["개발상식","Java","Tree"]},"rawMarkdownBody":"\n## 🧷 트리\n값을 가진 노드(Node)와 이 노드들을 이어주는 간선(Edge)로 이루어진 자료구조이다.\n\n> **트리라는 이름이 나온 이유?**\n> \n> : 실제 나무를 거꾸로 세워놓은 듯한 모양을 보이기 때문이다.\n\n<img src=\"https://www.geeksforgeeks.org/wp-content/uploads/binary-tree-to-DLL.png\" width=\"50%\">\n\n- 그림에서, 데이터 1을 가진 노드가 **루트 노드**이다.\n- 모든 노드들은 0개 이상의 자식 노드를 가지고 있으며, \"부모-자식 관계\"로 불린다.\n\n선형 자료구조에서 배열이나 리스트 등도 존재하지만, 트리가 나온 이유는 뭘까?\n- 일반 배열에서 삽입이나 삭제를 하는데 $O(N)$의 시간이 걸린다. \n  - 배열의 첫번째 원소에 삽입하는 경우 나머지 모든 요소들을 한 칸씩 뒤로 미뤄야 하므로 최악의 경우, $O(N)$의 시간 복잡도가 나온다.\n- 하지만 트리는 편향 트리가 아닌 이상, $O(logN)$ 정도의 시간으로 줄여진다.\n\n### 🪚 특징\n- Stack이나 Queue와 같은 선형 구조가 아닌 **비선형 자료구조**이다.\n- 계층적 관계를 표현한다.\n- 루트 노드를 제외한 모든 노드는 **단 하나의 부모 노드**만을 갖는다.\n- **트리에는 사이클이 존재할 수 없다.** (만약 사이클이 만들어진다면, 그래프이다.)\n- 모든 노드는 자료형으로 표현이 가능하다.\n- 루트에서 한 노드로 가는 경로는 유일한 경로뿐이다.\n- 노드의 개수가 **N**개면, 간선은 **N-1**개를 가진다.\n\n### 🪚 트리 순회 방식\n트리의 루트를 기준으로 총 4가지의 순회 방식이 있다. 트리는 위 그림을 사용한다.\n\n1. **전위 순회(pre-order)**\n   - 각 루트를 순차적으로 먼저 방문하는 방식이다. (Root -> 왼쪽 자식 -> 오른쪽 자식)\n   - `1 -> 2 -> 4 -> 8 -> 9 -> 5 -> 10 -> 11 -> 3 -> 6 -> 13 -> 7 -> 14`\n\n2. **중위 순회(in-order)**\n   - 왼쪽 하위 트리를 방문한 후 루트를 방문하는 방식이다. (왼쪽 자식 -> Root -> 오른쪽 자식)\n   - `8 -> 4 -> 9 -> 2 -> 10 -> 5 -> 11 -> 1 -> 6 -> 13 -> 3 -> 14 -> 7`\n\n3. **후위 순회(post-order)**\n   - 왼쪽 하위 트리부터 하위를 모두 방문한 후 루트를 방문하는 방식이다. (왼쪽 자식 -> 오른쪽 자식 -> Root)\n   - `8 -> 9 -> 4 -> 10 -> 11 -> 5 -> 2 -> 13 -> 6 -> 14 -> 7 -> 3 -> 1`\n\n4. **레벨 순회(level-order)**\n   - 루트부터 계층별로 방문하는 방식이다.\n   - `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13 -> 14`\n\n### 🪚 구현\n트리의 구현을 위해서는 아래의 정보들이 필요하다.\n1. 데이터와 연결 상태를 저장할 클래스 공간(=노드) 생성\n2. 각각의 노드들에 값 저장\n3. 노드 간 연결 상태 정의\n\n```java\nclass Node {\n  Node left;\n  Node right;\n  String value;\n\n  public Node(String value) {\n    this.left = null;\n    this.right = null;\n    this.value = value;\n  }\n}\n```\n- 각 노드들은 값과, 왼쪽, 오른쪽 자식 노드를 가진다.\n\n```java\nclass Tree {\n  Node root;\n  int size = 0;\n}\n```\n- 트리는 루트 노드와, 그 크기 정보를 가진다.\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Tree.html)\n- [Tree](https://github.com/WooVictory/Ready-For-Tech-Interview/blob/master/Data%20Structure/%5BData%20Structure%5D%20Tree.md)\n- [[자료구조, Java] 트리(Tree) 개념 정리 및 구현](https://readerr.tistory.com/35)"},{"excerpt":"문제 Programmers - 파일명 정렬 📍 Logic  가 동일한 경우와 동일하지 않은 경우에 대한 정렬 조건 명시 📄 CODE ✏️ Review  와  에 대한 정렬 조건만 세운다면 해결되는 문제!","fields":{"slug":"/[Programmers]17686/"},"frontmatter":{"date":"May 27, 2022","title":"👩‍💻 17686. 파일명 정렬","tags":["문자열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 파일명 정렬](https://programmers.co.kr/learn/courses/30/lessons/17686)\n\n### 📍 **Logic**\n\n```java\nfileList.sort(((o1, o2) -> {\n    // head가 동일하다면, number 기준 오름차순 정렬\n    if (o1.head.compareTo(o2.head) == 0) return o1.number - o2.number;\n    // head 기준 사전순 정렬\n    return o1.head.compareTo(o2.head);\n}));\n```\n- `head` 가 동일한 경우와 동일하지 않은 경우에 대한 정렬 조건 명시\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n    import java.util.regex.Matcher;\n    import java.util.regex.Pattern;\n\n    class File {\n        // 변환하지 않은 원본 파일명\n        String file;\n        String head;\n        int number;\n\n        public File(String file) {\n            this.file = file;\n            file = file.toLowerCase();\n\n            // 숫자가 연속이거나, 숫자가 아닌 문자가 연속인 경우 찾기\n            Pattern p = Pattern.compile(\"\\\\d+|\\\\D+\");\n            Matcher matcher = p.matcher(file);\n\n            matcher.find();\n            this.head = matcher.group(0);\n            matcher.find();\n            this.number = Integer.parseInt(matcher.group(0));\n        }\n    }\n\n    class Solution {\n        public String[] solution(String[] files) {\n            ArrayList<File> fileList = new ArrayList<>();\n\n            for (String file : files)\n                fileList.add(new File(file));\n\n            fileList.sort(((o1, o2) -> {\n                // head가 동일하다면, number 기준 오름차순 정렬\n                if (o1.head.compareTo(o2.head) == 0) return o1.number - o2.number;\n                // head 기준 사전순 정렬\n                return o1.head.compareTo(o2.head);\n            }));\n            \n            String[] answer = new String[files.length];\n            \n            for (int i = 0; i < fileList.size(); i++) \n                answer[i] = fileList.get(i).file;\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- `head` 와 `number` 에 대한 정렬 조건만 세운다면 해결되는 문제!"},{"excerpt":"문제 Programmers - n진수 게임 📍 Logic  은 0부터 1씩 증가하는 수를 주어진  진법에 따라 변환한 문자열이다. 해당 문자열의 각 단어를 탐색하는데, 이때  가  와 동일하다면, 즉 튜브의 순서가 되었다면 해당 단어를  에 추가한다. 📄 CODE ✏️ Review 간단한 문제였다. 처음에는 n진수를 일일이 구하는 방법을 구현했는데,  메소…","fields":{"slug":"/[Programmers]17687/"},"frontmatter":{"date":"May 27, 2022","title":"👩‍💻 17687. n진수 게임","tags":["문자열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - n진수 게임](https://programmers.co.kr/learn/courses/30/lessons/17687)\n\n### 📍 **Logic**\n\n```java\nwhile (idx != t) {\n    String strNum = Integer.toString(num, n);\n\n    for (int i = 0; i < strNum.length() && idx != t; i++) {\n        if (order == p) answer[idx++] = String.valueOf(strNum.charAt(i)).toUpperCase();\n        order++;\n        if (order == m + 1) order = 1;\n    }\n    num++;\n}\n```\n- `strNum` 은 0부터 1씩 증가하는 수를 주어진 `n` 진법에 따라 변환한 문자열이다.\n- 해당 문자열의 각 단어를 탐색하는데, 이때 `order` 가 `p` 와 동일하다면, 즉 튜브의 순서가 되었다면 해당 단어를 `answer` 에 추가한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Solution {\n        public String solution(int n, int t, int m, int p) {\n            String[] answer = new String[t];\n            int num = 0;\n            int idx = 0;\n            int order = 1;\n\n            while (idx != t) {\n                String strNum = Integer.toString(num, n);\n\n                for (int i = 0; i < strNum.length() && idx != t; i++) {\n                    if (order == p) answer[idx++] = String.valueOf(strNum.charAt(i)).toUpperCase();\n                    order++;\n                    if (order == m + 1) order = 1;\n                }\n                num++;\n            }\n            \n            return String.join(\"\", answer);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 간단한 문제였다.\n- 처음에는 n진수를 일일이 구하는 방법을 구현했는데, `Integer.toString(int n, int radix)` 메소드로 쉽게 n진수를 구할 수 있어 이를 적용했다."},{"excerpt":"문제 Programmers - 자동완성 📍 Logic 단어를 한 글자씩  에 추가한다. 이때 람다식을 이용하여 추가하도록 한다. 추가할 때마다, 해당 단어가 사용되는 횟수를 증가시킨다. ( 의 경우,  의  는 3이다.) 주어진 단어의  를 탐색하면서,  가 1인 경우까지  를 증가시킨다.  가 1이라는 것은 결국 해당 문자를 사용하는 단어가 1개인 경우…","fields":{"slug":"/[Programmers]17685/"},"frontmatter":{"date":"May 27, 2022","title":"👩‍💻 17685. 자동완성","tags":["트라이"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 자동완성](https://programmers.co.kr/learn/courses/30/lessons/17685)\n\n### 📍 **Logic**\n\n```java\npublic void insert(String word) {\n    TrieNode thisNode = this.rootNode;\n\n    for (int i = 0; i < word.length(); i++) {\n        thisNode = thisNode.getChildNodes().computeIfAbsent(word.charAt(i), c -> new TrieNode());\n        thisNode.size++;\n    }\n}\n```\n- 단어를 한 글자씩 `Trie` 에 추가한다.\n  - 이때 람다식을 이용하여 추가하도록 한다.\n- 추가할 때마다, 해당 단어가 사용되는 횟수를 증가시킨다. (`go, gone, guild` 의 경우, `g` 의 `size` 는 3이다.)\n\n```java\npublic int findCount(String word) {\n    TrieNode thisNode = this.rootNode;\n    int count = 0;\n\n    for (int i = 0; i < word.length(); i++) {\n        char c = word.charAt(i);\n        TrieNode node = thisNode.getChildNodes().get(c);\n        count++;\n\n        if (node.size == 1) break;\n\n        thisNode = node;\n    }\n\n    return count;\n}\n```\n- 주어진 단어의 `Trie` 를 탐색하면서, `size` 가 1인 경우까지 `count` 를 증가시킨다.\n  - `size` 가 1이라는 것은 결국 해당 문자를 사용하는 단어가 1개인 경우이고, 해당 문자까지 입력한다면 그 단어를 **자동완성**시킬 수 있다!\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class TrieNode {\n        private Map<Character, TrieNode> childNodes = new HashMap<>();\n        int size;\n\n        public Map<Character, TrieNode> getChildNodes() {\n            return this.childNodes;\n        }\n    }\n\n    class Trie {\n        private TrieNode rootNode;\n\n        public Trie() {\n            rootNode = new TrieNode();\n        }\n\n        public void insert(String word) {\n            TrieNode thisNode = this.rootNode;\n\n            for (int i = 0; i < word.length(); i++) {\n                thisNode = thisNode.getChildNodes().computeIfAbsent(word.charAt(i), c -> new TrieNode());\n                thisNode.size++;\n            }\n        }\n\n        public int findCount(String word) {\n            TrieNode thisNode = this.rootNode;\n            int count = 0;\n\n            for (int i = 0; i < word.length(); i++) {\n                char c = word.charAt(i);\n                TrieNode node = thisNode.getChildNodes().get(c);\n                count++;\n\n                if (node.size == 1) break;\n\n                thisNode = node;\n            }\n\n            return count;\n        }\n    }\n\n    class Solution {\n        public int solution(String[] words) {\n            Trie t = new Trie();\n            \n            for (String word : words)\n                t.insert(word);\n            \n            int answer = 0;\n            for (String word : words) \n                answer += t.findCount(word);\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음 보는 `Trie` 문제여서, 이 자료 구조를 이해하는 데 집중했다. 마침 이번 주 CS 스터디 내용 중 `Trie` 가 있어서 먼저 정리한 후 구현해보았다.\n- 생각보다 많이 어려운 내용은 아니었던 것 같지만, 응용해서 문제를 푸는 데는 좀 걸렸다."},{"excerpt":"🧷 트라이 효율적인 문자열 저장 및 탐색이 가능한 자료구조이다. 원래는  로 불렸었다. 하지만 말로 할 때  와 구분되지 않는 경향이 있어  로 불리기 시작했다. 수 많은 문자열을 저장하였는데 입력으로 어떤 문자열이 주어졌을 때, 내가 저장한 문자열에 포함된 문자열인지 알 수 있는 방법은 아래와 같은 방식들이 있을 것이다. 단순 비교 단순하게 전체 문자열…","fields":{"slug":"/[CS]Trie/"},"frontmatter":{"date":"May 25, 2022","title":"📂 Trie(트라이)","tags":["개발상식","Java","Trie"]},"rawMarkdownBody":"\n## 🧷 트라이\n효율적인 문자열 저장 및 탐색이 가능한 자료구조이다.\n\n> 원래는 `Tri` 로 불렸었다. 하지만 말로 할 때 `Tree` 와 구분되지 않는 경향이 있어 `Trie(트라이)` 로 불리기 시작했다.\n\n수 많은 문자열을 저장하였는데 입력으로 어떤 문자열이 주어졌을 때, 내가 저장한 문자열에 포함된 문자열인지 알 수 있는 방법은 아래와 같은 방식들이 있을 것이다.\n\n1. **단순 비교**\n   - 단순하게 전체 문자열의 처음부터 끝까지 개별 문자를 비교하는 방식\n   - 최대 문자열 길이 `m`, 전체 문자 개수 `n` 개일 경우, 시간복잡도: $O(nm)$\n\n2. **이진 탐색 기법**\n   - 전체 문자열을 사전 순으로 배열 저장 후, 중간 값과 비교해 사전적으로 이전이면 좌측의 반 / 이후면 우측의 반으로 비교 반복 방식\n   - 최대 문자열 길이 `m`, 전체 문자 개수 `n` 개일 경우, 시간복잡도: 정렬: $O(nmlogn)$ / 탐색: $O(mlogn)$ 즉, $O(nmlogn)$\n\n3. **트라이(`Trie`)**\n   - K-진 트리 구조를 통해 문자열을 저장하는 방식\n   - `game` 이라는 단어를 찾는다면, `g` 를 찾고 순서대로 `a`, `m`, `e` 를 찾는데, 이를 트리형식으로 구현한 것\n   - 맨 앞의 접두어(prefix)부터 시작하여 단어 전체를 찾아가는 과정이므로 접두사 트리(Prefix-Tree)라고도 한다.\n   - 문자열 저장을 위한 공간을 많이 쓰지만 탐색에 매우 효율적이라는 특성을 갖는다.\n   - 최대 문자열 길이 `m` 일 때 문자의 개수와 무관하게 시간복잡도: $O(m)$\n       - 문자열 길이가 너무 커서 `Map` 등을 이용해 동적 할당을 해야 하는 경우 $O(mlogn)$만큼 소요할 수 있다.\n\n```java\n{\"bar\", \"bag\", \"bark\", \"dog\", \"do\", \"door\"}\n```\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FHUT56%2FbtqLElE8hac%2FJkLnmHIMelPA74KhdBS5D1%2Fimg.png\" width=\"50%\">\n\n### 🪚 장단점\n트라이는 해시 테이블을 대체하는 데 사용될 수 있다.\n\n**장점**\n- 불완전한 해시 함수를 사용하는 해시테이블과 비교할 때, 자료에 접근할 때 최악의 경우 더 유리한 시간복잡도를 갖는다. \n  - m이 탐색할 문자열의 길이일 때 시간복잡도는 $O(m)$이다. \n  - 보통 해시테이블은 탐색 시간이 $O(1)$이고 해시 함수 평가 시간이 $O(m)$이지만, 불완전한 해시 테이블은 키 충돌이 일어날 수 있으므로, $O(N)$이 될 수 있다.\n- 트라이에서는 키 충돌이 일어나지 않는다.\n- 여러 값이 하나의 키와 연관되어 있지 않는 한 버킷이 필요 없다.\n- 해시 함수가 없어도 된다. 키가 늘어날 때 해시 함수를 변경할 필요도 없다.\n- 모든 항목이 키에 따라 사전순으로 정렬되어 있다.\n\n**단점**\n- 조회는 해시 테이블보다 느릴 수 있다. \n  - 특히 주 메모리에 비해 임의 접근 비용이 큰 하드 디스크 드라이브와 같은 보조 기억장치에서 직접 읽는다면 더욱 그렇다.\n- 부동소수점과 같이 문자열로 장황하게 표시되는 자료의 경우 무의미하게 길게 늘어진 접두사와 노드를 가질 수 있다. \n- 트라이가 메모리를 더 소비할 수 있다. \n  - 대부분의 해시 테이블에서는 전체 항목을 하나의 메모리 청크에 올리곤 하지만, 트라이에서는 검색 문자열의 각 문자마다 메모리가 할당될 수 있다.\n\n### 🪚 구현\n> 트리 구조의 각 노드에는 **각 문자열의 일부를 포함**하며, **자신과 연결되는 문자열의 일부**를 가지고 있어야 한다는 점을 명심!\n\n**생성자/클래스 정의**\n- 루트 노드는 아무런 문자열도 포함하지 않고 모든 문자열의 접두사들을 자식 배열로 갖고 있어야 한다.\n- `Node` 클래스는 각 `Node` 의 정보를 정의한 클래스로, 자신의 문자, 연결되는 문자들의 정보를 갖고 있고 문자열이 완성되는가 여부 또한 저장하고 있다.\n\n```java\nclass Trie {\n  Node root;\n  static final int ALPHABET_SIZE = 26; // 알파벳 개수: 26\n\n  public Trie() {\n    this.root = new Node();\n    this.root.val = ' ';\n  }\n\n  public static class Node {\n    Node[] child = new Node[ALPHABET_SIZE]; // 뒤로 연결되는 문자열을 index화하여 저장하는 배열\n    boolean isTerminal = false; // 현재 노드가 문자열의 마지막인지 여부\n    int childNum = 0; // 현재 노드에 연결된 문자열 개수\n    char val; // 현재 노드의 값\n  }\n}\n```\n\n**문자열 삽입(insert, charToInt)**\n- `charToInt()` 메소드는 각 문자열의 1개 단어를 `int` 형 숫자로 변환해주는 메소드다.\n- `insert()` 메소드는 전체 문자열을 쪼개서 각 노드(`Node`)에 저장하는 메소드다.\n\n```java\nprivate int charToInt(char c) {\n  return c - 'a'; // 소문자만 취급한다는 가정하에 `a`를 뺀다.\n}\n\npublic void insert(String str) {\n  int len = str.length();\n  Node cur = this.root; \n\n  for (int i = 0; i < len; i++) {\n    char c = str.charAt(i);\n    int num = this.charToInt(c);\n\n    if (cur.child[num] == null) { // 기존에 null이면 연결 문자열로 처음 추가되는 것\n      cur.child[num] = new Node();\n      cur.child[num].val = c;\n      cur.childNum++;\n    }\n\n    cur = cur.child[num];\n  }\n  cur.isTerminal = true;\n}\n```\n\n**찾기(find)**\n- 단어를 저장했으면 저장되어 있는지 확인할 수 있어야 한다. \n\n```java\npublic boolean find(String str) {\n  int len = str.length();\n  Node cur = this.root;\n\n  for (int i = 0; i < len; i++) {\n    char c = str.charAt(i);\n    int num = this.charToInt(c);\n\n    if (cur.child[num] == null) return false;\n    cur = cur.child[num];\n  }\n\n  return cur != null && cur.isTerminal;\n}\n```\n\n**전체 저장된 문자열 내역 출력**\n- 모든 저장된 단어의 내역을 알기 쉽게 출력할 수 있도록 하는 메소드를 구현해볼 수 있다.\n\n```java\nprivate char intToChar(int i) {\n  return (char) (i + (int) 'a');\n}\n\n// 사용자가 간편히 호출만 하면 되는 함수\npublic void printTrie() {\n  this.printTrie(this.root, 0, new StringBuilder());\n}\n\n// 내부에서 재귀적으로 순환하여 노드에 저장된 값들 추출해 출력\nprivate void printTrie(Node node, int idx, StringBuilder sb) {\n  Node cur = node;\n  Node[] child = cur.child;\n  StringBuilder builder = new StringBuilder(sb);\n\n  // 루트 노드에는 저장된 것이 없으므로 그 외의 경우에만 append\n  if (!cur.equals(this.root)) builder.append(intToChar(idx));\n\n  // 완성 노드라면 출력\n  if (cur.isTerminal) System.out.println(builder);\n\n  // 연결된 노드들을 순환하기 위해 반복문 사용\n  for (int i = 0; i < ALPHABET_SIZE; i++) {\n    // null이라면 저장된 것이 없으므로 패스\n    if (cur.child[i] == null) continue;\n\n    printTrie(child[i], i, builder);\n  }\n}\n```\n\n**삭제**\n- 삭제는 재귀적으로 **bottom-up** 방식으로 진행되고, 3가지 경우가 있다.\n\n1. 삭제할 문자가 다른 문자의 접두사인 경우 - `isTerminal` 을 `false` 변경\n   1. `Do` 는 `Door` 의 접두사가 된다. 따라서, `Do` 를 삭제한다면 `D` , `o` 에서 `o` 에 `isTerminal` 만 `false` 로 변경한다.\n   2. 단순히 삭제하면 `Door` 또한 사라지게 된다.\n2. 삭제할 문자가 고유하여 다른 문자와 연관이 없는 경우 - 관련 모든 노드 삭제\n3. 삭제할 문자의 일부가 전체 삭제 문자의 접두사인 경우 - 다른 문자에 영항가지 않는 곳까지만 삭제\n   1. `Door` 를 삭제하려고 한다면 `Do` 가 있기에, 전체 삭제를 할 수 없고 `Door` 에서 뒤의 `o` , `r` 만 삭제한다.\n\n```java\npublic void delete(String str) {\n  delete(this.root, str, 0);\n}\n\nprivate void delete(Node cur, String str, int idx) {\n  int len = str.length();\n\n  if ((cur.childNum == 0 && idx != len) || (idx == len && !cur.isTerminal)) {\n    throw new NoSuchElementException(\"Value\" + str + \" does not exist in Trie!\");\n  }\n\n  if (idx == len) {\n    cur.isTerminal = false;\n\n    if (cur.childNum == 0) cur = null;\n    else {\n      char c = str.charAt(idx);\n      int num = charToInt(c);\n\n      delete(cur.child[num], str, idx + 1);\n\n      if (cur.child[num] == null) cur.childNum--;\n\n      if (cur.childNum == 0 && !cur.isTerminal) cur = null;\n    }\n  }\n}\n```\n\n> 실제로는 `HashMap` 을 사용해 구현하는 것이 더 효율적이다. 아래는 이를 사용한 구현이다.\n\n**클래스 생성**\n- `TrieNode` 는 자식노드 맵과 `isLastChar` 를 가지고 있다.\n- `isLastChar` 는 'DEV'라는 단어에서 [D], [E]는 마지막 글자가 아니지만 [V]는 마지막 글자로, 한 단어가 완성되는 시점임을 알 수 있도록 하는 값이다.\n\n```java\npublic class TrieNode {\n\tprivate Map<Character, TrieNode> childNodes = new HashMap<>();\n\t// 마지막 글자 여부\n\tprivate boolean isLastChar;\n\n\t// 자식 노드 맵 Getter\n\tMap<Character, TrieNode> getChildNodes() {\n\t\treturn this.childNodes;\n\t}\n\n\t// 마지막 글자인지 여부 Getter\n\tboolean isLastChar() {\n\t\treturn this.isLastChar;\n\t}\n\n\t// 마지막 글자인지 여부 Setter\n\tvoid setIsLastChar(boolean isLastChar) {\n\t\tthis.isLastChar = isLastChar;\n\t}\n}\n```\n\n- Trie는 기본적으로 **빈 문자열을 가지는 루트 노드**만 가지고 있다.\n- 이 후에 나올 `insert()` 를 통해 단어를 넣어 그에 맞게 자식 노드가 생성된다.\n\n```java\npublic class Trie {\n\tprivate TrieNode rootNode;\n\n\tpublic Trie() {\n\t\trootNode = new TrieNode();\n\t}\n}\n```\n\n**insert**\n- 입력받은 단어의 각 알파벳을 계층구조의 자식 노드로 만들어 넣는다.\n  - 이미 같은 알파벳이 존재하면 공통 접두어까지는 생성하지 않는다.\n- 즉, 해당 계층 문자의 자식 노드가 존재하지 않을 때만 자식 노드를 생성해준다.\n- 이후 마지막 글자에는 \"여기까지를 끝으로 하는 단어가 존재한다\"는 표시를 위해 `isLastChar` 를 `true` 로 해준다.\n\n```java\nvoid insert(String word) {\n\tTrieNode thisNode = this.rootNode;\n\n\tfor (int i = 0; i < word.length(); i++) {\n\t\tthisNode = thisNode.getChildNodes().computeIfAbsent(word.charAt(i), c -> new TrieNode());\n\t}\n\tthisNode.setIsLastChar(true);\n}\n```\n\n**contains**\n- 특정 단어가 Trie에 존재하는지를 확인하기 위해서는 아래 2가지 조건을 만족해야 한다.\n  - 루트 노드부터 순서대로 알파벳이 일치하는 자식 노드들이 존재할 것\n  - 해당 단어의 마지막 글자에 해당하는 노드의 `isLastChar` 가 `true` 일 것\n\n```java\nboolean contains(String word) {\n\tTrieNode thisNode = this.rootNode;\n\n\tfor (int i = 0; i < word.length(); i++) {\n\t\tchar character = word.charAt(i);\n\t\tTrieNode node = thisNode.getChildNodes().get(character);\n\n\t\tif (node == null) return false;\n\n\t\tthisNode = node;\n\t}\n\n\treturn thisNode.isLastChar();\n}\n```\n\n**delete**\n- Trie에 넣었던 단어를 삭제하는 과정이다.\n- `contains()` 처럼 주어진 단어를 찾아 하위 노드로 단어 길이만큼 내려간다.\n- 단, 노드들이 부모 노드의 정보를 가지고 있지 않기에, 하위 노드로 내려가며 삭제 대상 단어를 탐색하고 다시 올라오면서 삭제하는 과정이 **콜백**형식으로 구현되어야 한다는 것이다.\n\n그리고 아래의 삭제 조건들을 확인해야 한다.\n1. 자식 노드를 가지고 있지 않아야 한다.\n2. 삭제를 시작하는 첫 노드는 `isLastChar == true` 여야 한다.\n3. 삭제를 진행하는 중에는 `isLastChar == false` 여야 한다.\n\n```java\nvoid delete(String word) {\n\tdelete(this.rootNode, word, 0);\n}\n\t\nprivate void delete(TrieNode thisNode, String word, int index) {\n    char character = word.charAt(index);\n    \n    // Trie에 없는 단어인 경우 에러 출력\n    if(!thisNode.getChildNodes().containsKey(character))\n        throw new Error(\"There is no [\" + word + \"] in this Trie.\");\n              \n    TrieNode childNode = thisNode.getChildNodes().get(character);\n    index++;\n      \n    // 단어의 길이만큼 하위 노드로 재귀\n    if(index == word.length()) {\n      // 삭제조건 2번 항목\n      // PO와 같이 노드는 존재하지만 insert한 단어가 아닌 경우 에러 출력\n      if (!childNode.isLastChar()) \n          throw new Error(\"There is no [\" + word + \"] in this Trie.\");\n        \n      childNode.setIsLastChar(false);\n      // 삭제조건 1번 항목\n      // 삭제 대상 단어의 제일 끝으로써 자식 노드가 없으면(이 단어를 포함하는 더 긴 단어가 없으면) 삭제 시작\n      if (childNode.getChildNodes().isEmpty())\n          thisNode.getChildNodes().remove(character);\n    } else {\n      delete(childNode, word, index); // 콜백함수부분\n      // 삭제조건 1,3번 항목\n      // 삭제 중, 자식 노드가 없고 현재 노드로 끝나는 다른 단어가 없는 경우 이 노드 삭제\n      if(!childNode.isLastChar() && childNode.getChildNodes().isEmpty())\n          thisNode.getChildNodes().remove(character);\n    }\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Trie.html)\n- [자료구조-트라이(Trie)](https://hongjw1938.tistory.com/24)\n- [트라이](https://ko.wikipedia.org/wiki/%ED%8A%B8%EB%9D%BC%EC%9D%B4_(%EC%BB%B4%ED%93%A8%ED%8C%85)#%EC%97%AD%EC%82%AC%EC%99%80_%EC%96%B4%EC%9B%90)\n- [[자료구조] Trie(트라이)-2 : 자바로 구현하기](https://the-dev.tistory.com/3)"},{"excerpt":"문제 Programmers - 압축 📍 Logic 사전에 포함되지 않은 단어를 찾을 때까지, 색인을 계속 업데이트하면서 문자를 붙인다. 반복문이 종료되었을 때는, 사전에 포함된 가장 긴 단어의 색인과, 사전에 포함되지 않은 가장 긴 단어를 구할 수 있다. 📄 CODE ✏️ Review 사전이라는 단어를 보았을 때 바로  을 사용해야겠다고 생각했다. 쉬운 문…","fields":{"slug":"/[Programmers]17684/"},"frontmatter":{"date":"May 25, 2022","title":"👩‍💻 17684. 압축","tags":["문자열","Map"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 압축](https://programmers.co.kr/learn/courses/30/lessons/17684)\n\n### 📍 **Logic**\n\n```java\nprivate int findWord(String[] msg, int i) {\n    StringBuilder w = new StringBuilder(msg[i]);\n    int idx = -1;\n\n    // 사전에 포함되지 않는 단어를 찾을 때까지 문자를 계속 붙임\n    while (dic.containsKey(w.toString())) {\n        idx = dic.get(w.toString());\n        i++;\n        if (i == msg.length) break;\n        w.append(msg[i]);\n    }\n    // 붙인 단어를 사전에 추가하고, 이미 찾은 색인을 배열에 추가\n    dic.put(w.toString(), max++);\n    index.add(idx);\n\n    // i++ 된 이후로 반복문을 나오기 때문에 -1한 값을 반환\n    return i - 1;\n}\n```\n- 사전에 포함되지 않은 단어를 찾을 때까지, 색인을 계속 업데이트하면서 문자를 붙인다.\n- 반복문이 종료되었을 때는,\n  - 사전에 포함된 가장 긴 단어의 색인과,\n  - 사전에 포함되지 않은 가장 긴 단어를 구할 수 있다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Dic {\n        Map<String, Integer> dic;\n        ArrayList<Integer> index;\n        int max = 27;\n        String[] alpha = {\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\"};\n\n        public Dic() {\n            dic = new HashMap<>();\n            index = new ArrayList<>();\n            initDic();\n        }\n\n        // 사전 초기화\n        private void initDic() {\n            for (int i = 0; i < 26; i++)\n                dic.put(alpha[i], i + 1);\n        }\n\n        public int[] compress(String[] msg) {\n            for (int i = 0; i < msg.length; i++) \n                i = findWord(msg, i);\n\n            return index.stream().mapToInt(i -> i).toArray();\n        }\n\n        // i번째부터 사전에 포함되지 않은 단어를 찾는다.\n        private int findWord(String[] msg, int i) {\n            StringBuilder w = new StringBuilder(msg[i]);\n            int idx = -1;\n\n            // 사전에 포함되지 않는 단어를 찾을 때까지 문자를 계속 붙임\n            while (dic.containsKey(w.toString())) {\n                idx = dic.get(w.toString());\n                i++;\n                if (i == msg.length) break;\n                w.append(msg[i]);\n            }\n            // 붙인 단어를 사전에 추가하고, 이미 찾은 색인을 배열에 추가\n            dic.put(w.toString(), max++);\n            index.add(idx);\n\n            // i++ 된 이후로 반복문을 나오기 때문에 -1한 값을 반환\n            return i - 1;\n        }\n    }\n\n    class Solution {\n        public int[] solution(String msg) {\n            Dic d = new Dic();\n            return d.compress(msg.split(\"\"));\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 사전이라는 단어를 보았을 때 바로 `Map` 을 사용해야겠다고 생각했다.\n- 쉬운 문제.."},{"excerpt":"문제 Programmers - 방금그곡 📍 Logic  이 들어가는 경우  로 포함 여부 확인 시 추가 조건이 필요해서 치환하는 방식을 사용했다.  에 들어있는 악보를 기억하고 있는 멜로디와 비교하면서, 해당 멜로드를 포함하고, 재생 시간이 제일 긴 음악인지를 판단하여 노래 제목을 저장한다. 📄 CODE ✏️ Review 재생 시간 조건을 고려했어야 하는 …","fields":{"slug":"/[Programmers]17683/"},"frontmatter":{"date":"May 24, 2022","title":"👩‍💻 17683. 방금그곡","tags":["문자열","Map"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 방금그곡](https://programmers.co.kr/learn/courses/30/lessons/17683)\n\n### 📍 **Logic**\n\n```java\n// #이 들어가는 음 치환\nprivate String convert(String s) {\n    return s.replace(\"C#\", \"c\").replace(\"D#\", \"d\").replace(\"F#\", \"f\").replace(\"G#\", \"g\").replace(\"A#\", \"a\");\n}\n```\n- `#` 이 들어가는 경우 `contains()` 로 포함 여부 확인 시 추가 조건이 필요해서 치환하는 방식을 사용했다.\n\n```java\nString answer = \"\";\nfor (Map.Entry<String, String> entry : music.entrySet()) {\n    String score = entry.getValue();\n    int playTime = score.length();\n    \n    // 기억한 멜로디를 포함하고, 재생 시간이 제일 긴 음악인 경우 answer에 해당 제목 저장\n    if (score.contains(m) && playTime > maxPlayTime) {\n        answer = entry.getKey();\n        maxPlayTime = playTime;\n    }\n}\n```\n- `LinkedHashMap` 에 들어있는 악보를 기억하고 있는 멜로디와 비교하면서,\n  - 해당 멜로드를 포함하고,\n  - 재생 시간이 제일 긴 음악인지를 판단하여 노래 제목을 저장한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class JustNowMusic {\n        // Map의 순서 보장을 위해 LinkedHashMap 사용\n        LinkedHashMap<String, String> music;\n\n        public JustNowMusic(String[] musicinfos) {\n            music = new LinkedHashMap<>();\n\n            for (String mi : musicinfos) initMusic(mi);\n        }\n\n        private void initMusic(String mi) {\n            String[] info = mi.split(\",\");\n\n            int runTime = parsing(info[0], info[1]);\n\n            StringBuilder score = new StringBuilder();\n\n            info[3] = convert(info[3]);\n            \n            // 재생 시간만큼 악보 반복\n            for (int i = 0, idx = 0; i < runTime; i++) {\n                if (i % info[3].length() == 0) idx = 0;\n                score.append(info[3].charAt(idx));\n                idx++;\n            }\n\n            // 제목과 악보를 Map에 저장\n            music.put(info[2], score.toString());\n        }\n        \n        // #이 들어가는 음 치환\n        private String convert(String s) {\n            return s.replace(\"C#\", \"c\").replace(\"D#\", \"d\").replace(\"F#\", \"f\").replace(\"G#\", \"g\").replace(\"A#\", \"a\");\n        }\n\n        private int parsing(String info1, String info2) {\n            int startTime = getTime(info1);\n            int endTime = getTime(info2);\n\n            return endTime - startTime;\n        }\n\n        private int getTime(String info) {\n            String[] time = info.split(\":\");\n            int hour = Integer.parseInt(time[0]);\n            int min = Integer.parseInt(time[1]);\n            \n            return hour * 60 + min;\n        }\n\n        public String findMusic(String m) {\n            m = convert(m);\n            int maxPlayTime = -1;\n            \n            String answer = \"\";\n            for (Map.Entry<String, String> entry : music.entrySet()) {\n                String score = entry.getValue();\n                int playTime = score.length();\n                \n                // 기억한 멜로디를 포함하고, 재생 시간이 제일 긴 음악인 경우 answer에 해당 제목 저장\n                if (score.contains(m) && playTime > maxPlayTime) {\n                    answer = entry.getKey();\n                    maxPlayTime = playTime;\n                }\n            }\n\n            return maxPlayTime == -1? \"(None)\" : answer;\n        }\n    }\n\n    class Solution {\n        public String solution(String m, String[] musicinfos) {\n            JustNowMusic jnm = new JustNowMusic(musicinfos);\n            \n            return jnm.findMusic(m);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 재생 시간 조건을 고려했어야 하는 문제였고, 구현해나가던 중 계속 발생하는 실패때문에 질문 게시판을 확인했는데, `Map` 을 `for` 문으로 탐색하게 되면 순서가 보장되지 않는다는 점을 깨달았다. `LinkedHashMap` 을 정리해놓고 적용해보지 못한 사례였다."},{"excerpt":"문제 Programmers - 프렌즈4블록 📍 Logic 흐름은, 보드에 4블록이 있는지 확인하고, 있다면 없앨 수 있는 블록 수를 계산하고, 보드를 최신화한다. 사라질 블록이 아니고, 4개의 블록쌍을 이룬다면, 해당 좌표들의  를  로 바꿔 후에 사라질 것임을 저장한다. 📄 CODE ✏️ Review 시키는 대로 하면 되는 문제였다.","fields":{"slug":"/[Programmers]17679/"},"frontmatter":{"date":"May 22, 2022","title":"👩‍💻 17679. 프렌즈4블록","tags":["구현"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 프렌즈4블록](https://programmers.co.kr/learn/courses/30/lessons/17679)\n\n### 📍 **Logic**\n\n```java\nwhile (f.checkBlocks()) {\n    answer += f.countBlocks();\n    f.dropBlocks();\n}\n```\n\n- 흐름은,\n  - 보드에 4블록이 있는지 확인하고,\n  - 있다면 없앨 수 있는 블록 수를 계산하고,\n  - 보드를 최신화한다.\n\n```java\npublic boolean checkBlocks() {\n    check = new boolean[m][n];\n    boolean has = false;\n\n    for (int i = 0; i < m - 1; i++)\n        for (int j = 0; j < n - 1; j++)\n            if (blocks[i][j] != '-' && has4Blocks(i,j)) {\n                check[i][j] = true;\n                check[i][j + 1] = true;\n                check[i + 1][j] = true;\n                check[i + 1][j + 1] = true;\n                has = true;\n            }\n\n    return has;\n}\n```\n- 사라질 블록이 아니고, 4개의 블록쌍을 이룬다면, 해당 좌표들의 `check` 를 `true` 로 바꿔 후에 사라질 것임을 저장한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    import java.util.*;\n\n    class Friends {\n        char[][] blocks;\n        boolean[][] check;\n        int m;\n        int n;\n\n        public Friends(int m, int n, String[] board) {\n            this.m = m;\n            this.n = n;\n            blocks = new char[m][n];\n            initBlocks(board);\n        }\n\n        private void initBlocks(String[] board) {\n            for (int i = 0; i < m; i++)\n                for (int j = 0; j < n; j++)\n                    blocks[i][j] = board[i].charAt(j);\n        }\n\n        public boolean checkBlocks() {\n            check = new boolean[m][n];\n            boolean has = false;\n\n            for (int i = 0; i < m - 1; i++)\n                for (int j = 0; j < n - 1; j++)\n                    if (blocks[i][j] != '-' && has4Blocks(i,j)) {\n                        check[i][j] = true;\n                        check[i][j + 1] = true;\n                        check[i + 1][j] = true;\n                        check[i + 1][j + 1] = true;\n                        has = true;\n                    }\n\n            return has;\n        }\n\n        private boolean has4Blocks(int x, int y) {\n            return blocks[x][y] == blocks[x][y + 1] && blocks[x][y] == blocks[x + 1][y] && blocks[x][y] == blocks[x + 1][y + 1];\n        }\n\n        public int countBlocks() {\n            int count = 0;\n            \n            for (int i = 0; i < m; i++)\n                for (int j = 0; j < n; j++) {\n                    if (!check[i][j]) continue;\n                    count++;\n                    blocks[i][j] = '-';\n                }\n            \n            return count;\n        }\n\n        public void dropBlocks() {\n            for (int i = m - 1; i >= 0; i--)\n                for (int j = 0; j < n; j++)\n                    if (blocks[i][j] == '-') pullBlocks(i, j);\n        }\n\n        private void pullBlocks(int x, int y) {\n            for (int k = x - 1; k >= 0; k--) {\n                if (blocks[k][y] != '-') {\n                    blocks[x][y] = blocks[k][y];\n                    blocks[k][y] = '-';\n                    break;\n                }\n            }\n        }\n    }\n\n    class Solution {\n        public int solution(int m, int n, String[] board) {\n            Friends f = new Friends(m, n, board);\n\n            int answer = 0;\n            \n            while (f.checkBlocks()) {\n                answer += f.countBlocks();\n                f.dropBlocks();\n            }\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 시키는 대로 하면 되는 문제였다."},{"excerpt":"🧷 힙(Heap) 우선순위 큐를 위해 만들어진 자료구조이다. 삽입과 삭제 모두 으로 해결할 수 있다. 완전 이진 트리의 일종이다. 여러 값 중, 최댓값과 최솟값을 빠르게 찾아내도록 만들어진 자료구조 반 정렬 상태 (무조건 정렬되어 있을 필요가 없다.) 힙 트리는 중복된 값 허용 (이진 탐색 트리는 중복값을 허용하지 않음) 우선순위 큐?\n: 우선순위의 개념…","fields":{"slug":"/[CS]Heap/"},"frontmatter":{"date":"May 21, 2022","title":"📂 Heap","tags":["개발상식","Java","힙"]},"rawMarkdownBody":"\n## 🧷 힙(Heap)\n우선순위 큐를 위해 만들어진 자료구조이다.\n- 삽입과 삭제 모두 $O(logN)$으로 해결할 수 있다.\n- 완전 이진 트리의 일종이다.\n  - 여러 값 중, 최댓값과 최솟값을 빠르게 찾아내도록 만들어진 자료구조\n- 반 정렬 상태 (무조건 정렬되어 있을 필요가 없다.)\n- 힙 트리는 중복된 값 허용 (이진 탐색 트리는 중복값을 허용하지 않음)\n\n> **우선순위 큐?**\n> : 우선순위의 개념을 큐에 도입한 자료구조로, 데이터들이 우선순위를 가지고 있고 이에 따라 우선순위가 높은 데이터가 먼저 나가게 되는 구조이다.\n> - 우선순위 큐는 배열, 연결리스트, 힙으로 구현할 수 있는데, 그 중 힙이 가장 효율적이다.\n\n> **완전 이진 트리?**\n> : 노드를 삽입할 때, 왼쪽부터 차례대로 삽입하는 트리이다.\n\n### 🪚 종류\n**최대 힙(Max Heap)**\n- 부모 노드의 키 값이 자식 노드의 키 값보다 크거나 같은 완전 이진 트리\n\n**최소 힙(Min Heap)**\n- 부모 노드의 키 값이 자식 노드의 키 값보다 작거나 같은 완전 이진 트리\n\n### 🪚 구현\n힙을 저장하는 표준적 자료구조는 `배열` 이다.\n- 구현을 쉽게 하기 위해 배열의 첫 번째 인덱스인 0은 사용되지 않는다.\n- 특정 위치의 노드 번호는 새로운 노드가 추가되어도 변하지 않는다.\n\n**부모 노드와 자식 노드의 관계**\n```java\n왼쪽 자식 index = (부모 index) * 2\n오른쪽 자식 index = (부모 index) * 2 + 1\n부모 index = (자식 index) / 2\n```\n\n**삽입**\n1. 힙에 새로운 요소가 들어오면, 일단 새로운 노드를 힙의 마지막 노드에 삽입\n2. 새로운 노드를 부모 노드들과 교환\n\n```java\n// 최대 힙의 삽입 구현\n\nvoid insertMaxHeap(int x) {\n  // 힙 크기를 증가시키고, 마지막 노드에 삽입\n  maxHeap[++heapSize] = x;\n\n  for (int i = heapSize; i > 1; i/=2) {\n    // 마지막 노드가 자신의 부모 노드보다 크면 swap\n    if (maxHeap[i/2] < maxHeap[i]) swap(i/2, i);\n    else break;\n  }\n}\n```\n\n**삭제**\n1. 최대 힙에서 최댓값은 루트 노드이므로 루트 노드가 삭제됨\n2. 삭제된 루트 노드에는 힙의 마지막 노드를 가져옴\n3. 힙을 재구성(`heapify`)\n\n```java\n// 최대 힙 삭제 구현\n\nint deleteMaxHeap() {\n  if (heapSize == 0) return 0;\n\n  // 루트 노드의 값을 저장하고, 마지막 노드 값을 루트로 이동한 후 힙 크기를 줄여 마지막 노드를 0으로 초기화\n  int item = maxHeap[1];\n  maxHeap[1] = maxHeap[heapSize];\n  maxHeap[heapSize--] = 0;\n\n  for (int i = 1; i*2 <= heapSize;) {\n    // 마지막 노드가 왼쪽 노드와 오른쪽 노드보다 크면 최대 힙이므로 종료\n    if (maxHeap[i] > maxHeap[i*2] && maxHeap[i] > maxHeap[i*2+1]) break;\n    // 자식 노드가 더 큰 경우, 교환한 후, i를 변경\n    else if (maxHeap[i*2] > maxHeap[i*2+1]) {\n      swap(i, i*2);\n      i *= 2;\n    } else {\n      swap(i, i*2+1);\n      i = i*2+1;\n    }\n  }\n\n  return item;\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Heap.html)"},{"excerpt":"🧷 스택 입력과 출력이 한 방향으로 제한되는 LIFO(Last in First out, 후입선출) 형태의 선형 자료구조이다. 나중에 들어간 원소가 가장 먼저 나오는 것이 가장 큰 특징이다. 시스템 해킹에서 BufferOverflow 취약점을 이용한 공격 시 스택 메모리의 영역에서 수행한다. 🪚 사용시기 함수의 Call Stack 문자열 역순 출력 연산자 …","fields":{"slug":"/[CS]Stack&Queue/"},"frontmatter":{"date":"May 20, 2022","title":"📂 Stack & Queue","tags":["개발상식","Java","스택","큐"]},"rawMarkdownBody":"\n## 🧷 스택\n입력과 출력이 한 방향으로 제한되는 **LIFO**(Last in First out, 후입선출) 형태의 선형 자료구조이다.\n- 나중에 들어간 원소가 가장 먼저 나오는 것이 가장 큰 특징이다.\n- 시스템 해킹에서 BufferOverflow 취약점을 이용한 공격 시 스택 메모리의 영역에서 수행한다.\n\n### 🪚 사용시기\n- 함수의 Call Stack\n- 문자열 역순 출력\n- 연산자 후위표기법\n- DFS\n- 재귀 함수\n\n---\n\n## 🧷 큐\n입력과 출력이 한 쪽 끝(front, rear)으로 제한되는 FIFO(First in First out, 선입선출) 형태의 선형 자료구조이다.\n- 가장 먼저 들어온 원소가 가장 먼저 나오는 것이 가장 큰 특징이다.\n- 큐의 가장 첫 원소를 `front`, 끝 원소를 `rear` 라고 한다.\n  - 큐에 데이터가 들어올 때(삽입 연산)는 `rear` 로 들어오고,\n  - 데이터가 나갈 때(삭제 연산)는 `front` 로 나간다.\n- Java Collection에서 `Queue` 는 인터페이스이다. 이를 구현하고 있는 `PriorityQueue` 등을 사용할 수 있다.\n  - 인터페이스이므로, 큐 타입의 객체를 생성할 수는 없다. \n  - `Queue<Obj> queue = new PriorityQueue<>();` 로 type-safe 큐를 생성할 수 있다.\n\n<img src=\"https://media.geeksforgeeks.org/wp-content/cdn-uploads/20200903183026/Queue-Deque-PriorityQueue-In-Java.png\" width=\"70%\">\n\n### 🪚 사용시기\n- 버퍼\n- BFS\n\n### 🪚 개선\n크기가 정해진 일반 큐는 큐에 빈 메모리가 있어도, 꽉 차있는 것으로 판단할 수 있다는 단점이 있다. (`rear` 가 끝에 도달했을 때, 이전에 `pop` 된 공간은 비어있지만 접근이 불가능하다.)\n- 이를 \"**원형 큐**\"를 이용해 개선할 수 있다.\n- 논리적으로 배열의 처음과 끝이 연결되어 있는 것으로 간주한다.\n\n원형 큐는 초기 공백 상태일 때 `front` 와 `rear` 가 0이다. 공백, 포화 상태를 쉽게 구분하기 위해 **자리 하나를 항상 비워둔다.**\n\n```java\n(index + 1) % size로 순환시킨다.\n```\n\n**단점**\n- 메모리 공간의 활용도는 올라가지만, 배열로 구현되어 있어 큐의 크기가 제한된다.\n\n### 🪚 두번째 개선\n연결리스트 큐를 사용해 이를 개선한다.\n- 크기가 제한이 없고,\n- 삽입 및 삭제 연산이 편리하다.\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Stack%20&%20Queue.html)\n- [JaeYeopHan/Interview_Question_for_Beginner](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/DataStructure#stack-and-queue)\n- [Queue Interface in Java](https://www.geeksforgeeks.org/queue-interface-java/)"},{"excerpt":"문제 Programmers - 셔틀버스 📍 Logic  로 버스 출발 시각을 세팅하고, 우선순위 큐에 저장된 크루들의 대기열 도착 시간을 하나씩 비교하며 탑승할 수 있는 경우 큐에서 제외한다. 이때 마지막으로 탑승한 인원의 대기열 도착 시간을 알아야 하기에  에 저장한다. (이때 -1한 값을 저장) 콘은 마지막 버스에만 타면 되므로, 마지막 버스가 만석인…","fields":{"slug":"/[Programmers]17678/"},"frontmatter":{"date":"May 20, 2022","title":"👩‍💻 17678. 셔틀버스","tags":["문자열","우선순위큐"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 셔틀버스](https://programmers.co.kr/learn/courses/30/lessons/17678)\n\n### 📍 **Logic**\n\n```java\npublic int rideBus() {\n    int departBus = 540;\n\n    for (int i = 0; i < n; i++) {\n        while(!crueTimes.isEmpty()) {\n            int crue = crueTimes.peek();\n\n            if (departBus >= crue && busTimes.get(i).size() < m) {\n                crueTimes.poll();\n                busTimes.get(i).add(crue);\n                lastCrue = crue - 1;\n            } else break;\n        }\n        departBus += t;\n    }\n    \n    if (busTimes.get(n - 1).size() < m) \n        lastCrue = departBus - t;\n    \n    return lastCrue;\n}\n```\n- `departBus` 로 버스 출발 시각을 세팅하고, 우선순위 큐에 저장된 크루들의 대기열 도착 시간을 하나씩 비교하며 탑승할 수 있는 경우 큐에서 제외한다.\n- 이때 마지막으로 탑승한 인원의 대기열 도착 시간을 알아야 하기에 `lastCrue` 에 저장한다. (이때 -1한 값을 저장)\n- 콘은 마지막 버스에만 타면 되므로, 마지막 버스가 만석인지 확인하여\n  - 만석인 경우, `lastCrue` 를 반환하고,\n  - 만석이 아닌 경우, 해당 버스의 출발 시각을 반환한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Shuttle {\n        Queue<Integer> crueTimes;\n        ArrayList<ArrayList<Integer>> busTimes;\n        int n;\n        int t;\n        int m;\n        int lastCrue;\n\n        public Shuttle(int n, int t, int m) {\n            this.n = n;\n            this.t = t;\n            this.m = m;\n            busTimes = new ArrayList<>();\n            crueTimes = new PriorityQueue<>();\n            initBusTimes();\n        }\n\n        private void initBusTimes() {\n            for (int i = 0; i < n; i++)\n                busTimes.add(new ArrayList<>());\n        }\n\n        public void fillCrue(String[] timetable) {\n            for (String tt : timetable) {\n                String[] tmp = tt.split(\":\");\n                crueTimes.add(Integer.parseInt(tmp[0]) * 60 + Integer.parseInt(tmp[1]));\n            }\n        }\n\n        public int rideBus() {\n            int departBus = 540;\n\n            for (int i = 0; i < n; i++) {\n                while(!crueTimes.isEmpty()) {\n                    int crue = crueTimes.peek();\n\n                    if (departBus >= crue && busTimes.get(i).size() < m) {\n                        crueTimes.poll();\n                        busTimes.get(i).add(crue);\n                        lastCrue = crue - 1;\n                    } else break;\n                }\n                departBus += t;\n            }\n            \n            if (busTimes.get(n - 1).size() < m) \n                lastCrue = departBus - t;\n            \n            return lastCrue;\n        } \n    }\n\n    class Solution {\n        public String solution(int n, int t, int m, String[] timetable) {\n            Shuttle st = new Shuttle(n, t, m);\n\n            st.fillCrue(timetable);\n\n            StringBuilder answer = new StringBuilder();\n            int time = st.rideBus();\n            \n            int hour = time/60;\n            int min = time%60;\n            \n            if (hour < 10) answer.append(\"0\");\n            answer.append(hour).append(\":\");\n            if (min < 10) answer.append(\"0\");\n            answer.append(min);\n            \n            return answer.toString();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 버스마다 탈 수 있는 인원을 모두 채워놓고, 맨 마지막 버스에 대해서만 확인하여 제일 늦은 시각을 구하려고 했는데, 테케 14 ~ 16번이 죽어도 실패였다.\n- 생각나는 테케는 다 만들어서 해봐도 도저히 뭐가 안 맞는 건지 모르겠어서 다른 풀이를 봤다.\n- 누가 좀 속시원하게 알려줬으면 좋겠다 ..."},{"excerpt":"🧷 Overloading 이름은 같지만, 파라미터 수, 타입은 다른 메소드를 중복으로 선언하는 것을 말한다. 같은 메소드라도 매개변수만 다르다면 얼마든지 정의하고 사용할 수 있다. 🗝 특징 메소드 이름이 같아야 한다. 반환형이 같아도 되고, 달라도 된다. 파라미터의 개수가 달라야 한다. 파라미터의 개수가 같을 경우, 데이터 타입이 달라야 한다. 🧷 Ove…","fields":{"slug":"/[면접]Overloading&Overriding/"},"frontmatter":{"date":"May 20, 2022","title":"💬 Overloading vs. Overriding","tags":["개발상식","Java","오버로딩","오버라이딩"]},"rawMarkdownBody":"\n## 🧷 Overloading\n이름은 같지만, 파라미터 수, 타입은 다른 메소드를 중복으로 선언하는 것을 말한다.\n- 같은 메소드라도 매개변수만 다르다면 얼마든지 정의하고 사용할 수 있다.\n\n### 🗝 특징\n1. 메소드 이름이 같아야 한다.\n2. 반환형이 같아도 되고, 달라도 된다.\n3. 파라미터의 개수가 달라야 한다.\n4. 파라미터의 개수가 같을 경우, 데이터 타입이 달라야 한다.\n\n```java\npublic class OverloadingTest {\n  void test() {\n    System.out.println(\"매개변수 없음\");\n  }\n\n  void test(int a, int b) {\n    System.out.println(\"매개변수 \" + a + \"와 \" + b);\n  }\n\n  void test(double d) {\n    System.out.println(\"매개변수\" + d);\n  }\n}\n\npublic class OverloadingExample {\n  public static void main(String[] args) {\n    OverloadingTest ob = new OverloadingTest();\n\n    // 매개변수 없음\n    ob.test();\n\n    // 매개변수 10와 20\n    ob.test(10, 20);\n\n    // 매개변수 50.0\n    ob.test(50);\n\n    // 매개변수 123.4\n    ob.test(123.4);\n  }\n}\n```\n\n---\n\n## 🧷 Overriding\n부모 클래스의 메소드의 동작 방법을 재정의하여 우선적으로 사용하는 것을 말한다.\n- 상속 관계에 있는 클래스 간에 같은 이름의 메소드를 정의하는 기술이다.\n- 자식 클래스가 부모 클래스에서 선언된 것과 같은 메소드를 가질 때, 메소드 오버라이딩이라 한다.\n- 하나의 코드로 여러 객체를 처리할 수 있다.\n\n### 🗝 특징\n1. 오버라이드하고자 하는 메소드가 상위 클래스에 존재해야 한다.\n2. 메소드 이름이 같아야 한다.\n3. 메소드의 파라미터 개수, 데이터 타입이 같아야 한다.\n4. 메소드의 반환형이 같아야 한다.\n5. 상위 메소드와 동일하거나 내용이 추가되어야 한다.\n\n```java\npublic class People {\n  public String name;\n  public int age;\n\n  public void print() {\n    System.out.println(\"이름은 \" + this.name + \"이고, 나이는 \" + this.age + \"입니다.\");\n  }\n}\n\npublic class Student extends People {\n  String job;\n\n  public void print() {\n    System.out.println(\"이름은 \" + this.name + \"이고, 나이는 \" + this.age + \"입니다.\");\n    System.out.println(this.name + \"은 \" + this.job + \"입니다.\");\n  }\n}\n\npublic class OverridingExample {\n  public static void main(String[] args) {\n    Student st = new Student();\n\n    st.name = \"BAEK\";\n    st.age = 25;\n    st.job = \"취준생\";\n\n    st.print();\n    // 이름은 BAEK이고, 나이는 25입니다.\n    // BAEK은 취준생입니다.\n  }\n}\n```\n\n> **Overloading**은 한 클래스 내에, 여러 개의 같은 이름의 메소드를 정의하는 것으로, 메소드의 이름을 동일하게 만들어 프로그램의 가독성을 증가시킬 수 있다.<br/>\n> **Overriding**은 부모로부터 받은 메소드의 로직을 변경시키는 것으로, 객체지향 언어의 특징인 다형성 중 하나이다.\n\n## 📕 참고\n- [overloading vs. overriding](https://brunch.co.kr/@kimkm4726/2)"},{"excerpt":"🧷 세 자료 구조  : index로 빠르게 값을 찾는 것이 가능  : 데이터의 삽입 및 삭제가 빠름  : 데이터를 찾는 것은 빠르지만, 삽입 및 삭제가 느림 🪚 더 자세한 비교 Array 선언할 때 크기와 데이터 타입을 지정해야 한다. 메모리 공간에 사용할 사이즈를 미리 할당해두고 사용하는 자료구조다. 따라서 계속 데이터가 늘어날 경우, 최대 사이즈를 알…","fields":{"slug":"/[CS]Array&ArrayList&LinkedList/"},"frontmatter":{"date":"May 19, 2022","title":"📂 Array vs. ArrayList vs. LinkedList","tags":["개발상식","Java","배열","ArrayList","연결리스트"]},"rawMarkdownBody":"\n## 🧷 세 자료 구조\n- `Array` : index로 빠르게 값을 찾는 것이 가능\n- `LinkedList` : 데이터의 삽입 및 삭제가 빠름\n- `ArrayList` : 데이터를 찾는 것은 빠르지만, 삽입 및 삭제가 느림\n\n### 🪚 더 자세한 비교\n**Array**\n- 선언할 때 **크기와 데이터 타입을 지정**해야 한다.\n- 메모리 공간에 사용할 사이즈를 미리 할당해두고 사용하는 자료구조다.\n  - 따라서 계속 데이터가 늘어날 경우, 최대 사이즈를 알 수 없을 때 사용하기는 부적합하다.\n  - 또한 중간에 데이터를 삽입 및 삭제하는 것도 매우 비효율적이다. (접근하여 삭제한 뒤, 나머지 뒷 데이터들을 `shift` 해주는 비용으로 인해 최악의 경우 $O(N)$)\n  - 대신, `index` 를 통해 검색을 $O(1)$에 수행할 수 있다는 장점이 있다.\n\n**List**\n- `Array` 처럼 크기를 지정하지 않아도 된다.\n- 하지만 `Array` 에서 `index` 가 중요했던 것처럼, `List` 에서는 순서가 중요하다.\n  - 크기가 정해져있지 않아 중간에 데이터의 삽입이나 삭제가 발생해도 `Array` 보다는 덜 비효율적이다.\n  - 또한 `index` 를 가지고 있기에 검색 또한 빠르다.\n  - 하지만 중간에 데이터의 삽입 및 삭제 시 시간이 오래 걸리는 단점이 있다. (삽입 및 삭제 시 줄줄이 당겨지거나, 밀려날 때 수행되는 연산이 추가되고, 메모리 또한 낭비된다.)\n\n**LinkedList**\n- 연결리스트에는 단일, 다중 등이 존재한다. 무슨 종류든, **한 노드에 연결될 노드의 포인터 위치를 가리키는 방식**이다.\n\n> 단일은 뒷 노드만 가리키고, 다중은 앞뒤 노드를 모두 가리킨다.\n\n- 데이터의 삽입 및 삭제를 하더라도, 전체를 돌지 않고 이전 값과 다음 값이 가르키고 있던 주소 값만 수정해 연결시킴으로써 빠른 수행이 가능하다.\n- 하지만, `k` 번째 값을 찾는 문제에서는 비효율적이다.\n  - 연결리스트에서는 `index` 가 없기 때문에, 순차 검색을 수행하므로 시간이 더 걸린다.\n- 결과적으로, 검색과 삽입 및 삭제에 대해서 $O(N)$의 시간 복잡도를 가진다.\n  - 하지만, `Tree` 구조의 근간이 되는 자료구조로, `Tree` 에서 사용되었을 때 유용하다.\n\n> 상황에 맞게 자료구조를 잘 선택하는 능력이 중요하다.\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Array%20vs%20ArrayList%20vs%20LinkedList.html)\n- [JaeYeopHan/Interview_Question_for_Beginner](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/DataStructure#array-vs-linked-list)"},{"excerpt":"🧷 배열 (Array) 동일한 자료형의 데이터를 연속된 공간에 저장하기 위한 자료구조이다. 연관된 데이터를 그룹화하여 묶어준다. 🪚 장점 연관된 데이터를 저장하기 위한 변수의 선언을 줄여준다. 반복문 등을 이용하여 계산 과정을 쉽게 처리할 수 있다. 🪚 배열 회전 프로그램 기본적인 회전 알고리즘  에 첫 번째 인덱스의 값을 저장하고, 나머지 값들을 한 칸…","fields":{"slug":"/[CS]배열/"},"frontmatter":{"date":"May 18, 2022","title":"📂 배열 (Array)","tags":["개발상식","Java","배열"]},"rawMarkdownBody":"\n## 🧷 배열 (Array)\n동일한 자료형의 데이터를 연속된 공간에 저장하기 위한 자료구조이다. **연관된 데이터를 그룹화하여 묶어준다.**\n\n### 🪚 장점\n- 연관된 데이터를 저장하기 위한 변수의 선언을 줄여준다.\n- 반복문 등을 이용하여 계산 과정을 쉽게 처리할 수 있다.\n\n```java\nint[] array = { 1,2,3,4,5,6 };\nint arraySize = array.length;\n```\n\n### 🪚 배열 회전 프로그램\n<img src=\"https://t1.daumcdn.net/cfile/tistory/99AFA23F5BE8F31B0C\" width=\"70%\">\n\n**기본적인 회전 알고리즘**\n- `tmp` 에 첫 번째 인덱스의 값을 저장하고, 나머지 값들을 한 칸씩 앞으로 땡겨서 저장한다.\n- 이후 `array[n]` 에 `tmp` 값을 저장한다.\n\n**저글링 알고리즘**\n- 최대공약수 gcd를 이용해 집합을 나누어 여러 요소를 한꺼번에 이동시킨다.\n\n<img src=\"https://cdncontribute.geeksforgeeks.org/wp-content/uploads/arra.jpg\" width=\"80%\">\n\n- 주어진 배열이 `int[] array = {1,2,3,4,5,6,7,8,9,10,11,12}` 라면, `1,2,3` 을 뒤로 옮길 때, 인덱스를 3개씩 묶고 회전시키는 방법이다.\n\n1. `[]arrary` -> `{4,2,3,7,5,6,10,8,9,1,11,12}`\n2. `[]arrary` -> `{4,5,3,7,8,6,10,11,9,1,2,12}`\n3. `[]arrary` -> `{4,5,6,7,8,9,10,11,12,1,2,3}`\n\n**역전 알고리즘**\n- 회전시키는 수에 대해 구간을 나눠 **reverse**로 구현한다.\n  \n`d=2` 이면, 구간을 1,2 / 3,4,5,6,7 로 나눈다.\n- 첫 번째 구간 `reverse` -> 2,1\n- 두 번째 구간 `reverse` - > 7,6,5,4,3\n- 합치기 -> 2,1,7,6,5,4,3\n- 합친 배열을 `reverse` -> 3,4,5,6,7,1,2\n\n```java\nvoid reverseArr(int[] array, int start, int end) {\n  while (start < end) {\n    int temp = array[start];\n    array[start] = array[end];\n    array[end] = temp;\n\n    start++;\n    end--;\n  }\n}\n\nvoid rotateLeft(int[] array, int d, int n) {\n  reverseArr(array, 0, d - 1);\n  reverseArr(array, d, n - 1);\n  reverseArr(array, 0, n - 1);\n}\n```\n\n### 🪚 배열의 특정 최대 합 구하기\n`array[i]` 가 있을 때, `i * array[i]` 의 합이 가장 클 때 그 값을 출력하기\n- 이를 회전을 통해 찾을 수 있다.\n\n```java\n// Input\narray = { 1, 20, 2, 10 }\n// Output\n72\n\n2번 회전했을 때 아래와 같이 최댓값이 나온다.\n{ 2, 10, 1, 20 }\n20 * 3 + 1 * 2 + 10 * 1 + 20 * 0 = 72\n```\n\n**접근법**\n- `array[i]` 의 전체 합과 `i * array[i]` 의 전체 합을 저장할 변수 선언\n- 최종 가장 큰 `sum` 값을 저장할 변수 선언\n- 배열을 회전시키면서 `i * array[i]` 의 합 중 최댓값을 저장한다.\n\n**해결법**\n- 회전 없이 `i * array[i]` 의 sum을 저장한 값 = `R0`\n- 1번 회전하고 `i * array[i]` 의 sum을 저장한 값 = `R1`\n- 이 두 개를 빼면 `R1 - R0 = array[0] + array[1] + ... array[n - 2] - (n - 1) * array[n - 1]`\n- 이를 계속 반복하다보면, `Rj - R(j-1) = arrSum - n * array[n - j]` 라는 규칙을 얻을 수 있다.\n\n```java\nint arrSum = 배열의 총 합\nint maxSum = 회전없이 구한 i * array[i]의 sum;\n    \nfor (int j = 1; j < n; j++){\n  curSum = curSum + arrSum - n*arr[n-j];\n  \n  if ( curSum > maxSum )\n    maxSum = curSum;\n}\n\nreturn maxSum;\n```\n\n### 🪚 특정 배열을 `array[i] = i` 로 재배열\n주어진 배열에서 `array[i] = i` 가 가능한 것만 재배열시키기 (`array[i] = i` 가 없으면 -1로 채운다.)\n\n```java\n// Input\narray = { -1, -1, 6, 1, 9, 3, 2, -1, 4, -1 }\n// Output\n{ -1, 1, 2, 3, 4, -1, 6, -1, -1, 9 }\n```\n\n**접근법**\n- `array[i] != -1` && `array[i] != i` 가 우선 조건\n- 해당 값을 저장(`x`)해두고, 이 값이 `x` 일때 `array[x]` 를 탐색\n- `array[x]` 값을 저장(`y`)해두고, `array[x]` 가 -1이 아니면서 `array[x]` 가 `x` 가 아닌 동안을 탐색\n- `array[x]` 를 `x` 값으로 저장해주고, 기존의 `x` 를 `y` 로 수정\n\n```java\nint fix(int[] array, int len) {\n  for (int i = 0; i < len; i++) {\n    if (array[i] != -1 && array[i] != i) {\n      int x = array[i];\n\n      while (array[x] != -1 && array[x] != x) {\n        int y = array[x];\n        array[x] = x;\n        x = y;\n      }\n      array[x] = x;\n\n      if (array[i] != i) array[i] = -1;\n    }\n  }\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Array.html)\n- [JaeYeopHan/Interview_Question_for_Beginner](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/DataStructure#array-vs-linked-list)"},{"excerpt":"🧷 연결 리스트 (Linked List) 연속적인 메모리 위치에 저장되지 않는 선형 데이터 구조로, 포인터를 사용해 연결된다. 각 노드는 데이터 필드와 다음 노드에 대한 참조를 포함하는 노드로 구성된다. 🪚 왜 사용하나? 배열은 비슷한 유형의 선형 데이터를 저장하는데 사용할 수 있지만 제한 사항이 있다. 배열의 크기는 고정적이기에 미리 저장될 요소의 수에…","fields":{"slug":"/[CS]연결리스트/"},"frontmatter":{"date":"May 18, 2022","title":"📂 연결 리스트 (Linked List)","tags":["개발상식","Java","연결리스트"]},"rawMarkdownBody":"\n## 🧷 연결 리스트 (Linked List)\n<img src=\"https://www.geeksforgeeks.org/wp-content/uploads/gq/2013/03/Linkedlist.png\" width=\"80%\">\n\n연속적인 메모리 위치에 저장되지 않는 **선형 데이터 구조**로, 포인터를 사용해 연결된다. 각 노드는 **데이터 필드**와 **다음 노드에 대한 참조**를 포함하는 노드로 구성된다.\n\n### 🪚 왜 사용하나?\n배열은 비슷한 유형의 선형 데이터를 저장하는데 사용할 수 있지만 제한 사항이 있다.\n- 배열의 크기는 고정적이기에 미리 저장될 요소의 수에 대한 정보가 필요하다.\n- 새로운 요소를 삽입하는 것은 비용이 많이 발생한다. (공간을 할당하고, 기존 요소를 전부 이동)\n\n### 🪚 장점\n- 크기가 동적이다.\n- 삽입, 삭제가 용이하다.\n\n### 🪚 단점\n- 임의로 액세스를 허용할 수 없다, 즉 첫 번째 노드부터 순차적으로 요소에 접근해야 한다. (이진 탐색 불가능)\n- 포인터의 여분의 메로리 공간이 목록의 각 요소마다 필요하다.\n\n### 🪚 Single Linked List\n```java\nimport java.util.*;\n\nclass Node {\n  int data;\n  Node next;\n\n  Node(int data) {\n    this.data = data;\n    next = null;\n  }\n}\n\nclass LinkedList {\n  Node head;\n\n  public void printList() {\n    Node n = head;\n\n    while (n != null) {\n      System.out.println(n.data + \" \");\n      n = n.next;\n    }\n  }\n\n  // 노드 추가\n  public void push(Node n) {\n    Node h = head;\n\n    if (head == null) {\n      head = n;\n      return;\n    }\n\n    while (h.next != null) {\n      h = h.next;\n    }\n\n    h.next = n;\n  }\n\n  // 특정 노드 뒤에 노드 추가\n  public void push(Node n, int insertAt) {\n    Node h = head;\n\n    if (head == null) {\n      head = n;\n      return;\n    }\n\n    while (h.data != insertAt) {\n      h = h.next;\n    }\n\n    Node tmp = null;\n    h.next = tmp;\n    h.next = n;\n    n.next = tmp;\n  }\n}\n\nclass Main {\n  public static void main(String[] args) {\n    LinkedList ll = new LinkedList();\n\n    for (int i = 1; i < 4; i++) {\n      ll.push(new Node(i));\n    }\n\n    ll.printList();\n  }\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/computer-science/data-structure/Linked%20List.html)\n- [JaeYeopHan/Interview_Question_for_Beginner](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/DataStructure#array-vs-linked-list)"},{"excerpt":"문제 Programmers - 추석 트래픽 📍 Logic 문자열을 파싱하여 시, 분, 초 단위로 변환 후 이를 정수로 변환 주어진 시간은 로그의 시작 시간 또는 종료 시간 해당 시간으로부터 1초 내에 다른 로그가 존재한다면  를 증가 📄 CODE ✏️ Review 문자열 파싱하는 과정부터 마음에 들지 않은 문제였고, 애매한 설명때문에 이해가 더 가지 않았다…","fields":{"slug":"/[Programmers]17676/"},"frontmatter":{"date":"May 18, 2022","title":"👩‍💻 17676. 추석 트래픽","tags":["문자열"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 추석 트래픽](https://programmers.co.kr/learn/courses/30/lessons/17676)\n\n### 📍 **Logic**\n\n```java\nprivate void getTime(String[] doneTime, int procTime) {\n    int hour = Integer.parseInt(doneTime[0]);\n    int min = Integer.parseInt(doneTime[1]);\n    int sec = (int) (Double.parseDouble(doneTime[2]) * 1000);\n\n    int endSec = hour * 1000 * 60 * 60 + min * 1000 * 60 + sec;\n    int startSec = endSec - procTime + 1;\n\n    times.add(new Time(startSec, endSec));\n}\n```\n- 문자열을 파싱하여 시, 분, 초 단위로 변환 후 이를 정수로 변환\n\n```java\nprivate int findMaxRequest(int startTime) {\n    int count = 0;\n    // start ~ end 사이에 있다면 count + 1;\n    int endTime = startTime + 1000;\n\n    for (Time time : times) {\n        if (startTime <= time.startSec && time.startSec < endTime) {\n            count++;\n        } else if (startTime <= time.endSec && time.endSec < endTime) {\n            count++;\n        } else if (endTime <= time.endSec && time.startSec <= startTime) {\n            count++;\n        }\n    }\n\n    return count;\n}\n```\n- 주어진 시간은 로그의 시작 시간 또는 종료 시간\n  - 해당 시간으로부터 1초 내에 다른 로그가 존재한다면 `count` 를 증가\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Time {\n        int startSec;\n        int endSec;\n\n        public Time(int startSec, int endSec) {\n            this.startSec = startSec;\n            this.endSec = endSec;\n        }\n    }\n\n    class Solution {\n        ArrayList<Time> times = new ArrayList<>();\n        \n        public int solution(String[] lines) {\n            // 로그 개수가 1개면 무조건 1 반환\n            if (lines.length == 1) return 1;\n            \n            for (String line : lines) {\n                String[] times = line.substring(11).split(\" \");\n                String[] doneTime = times[0].split(\":\");\n                int procTime = (int) (Double.parseDouble(times[1].replace(\"s\", \"\")) * 1000);\n                getTime(doneTime, procTime);\n            }\n\n            int max = 0;\n            // 시작점이 걸쳐있는 경우와 끝점이 걸쳐있는 경우, time의 start와 end를 기점으로 1초 안에 몇개의 요청이 처리되는지 카운트\n            for (Time time : times)\n                max = Math.max(max, Math.max(findMaxRequest(time.startSec), findMaxRequest(time.endSec)));\n\n            return max;\n        }\n        \n        // 시작 시간과 종료 시간을 구해서 ArrayList에 추가\n        private void getTime(String[] doneTime, int procTime) {\n            int hour = Integer.parseInt(doneTime[0]);\n            int min = Integer.parseInt(doneTime[1]);\n            int sec = (int) (Double.parseDouble(doneTime[2]) * 1000);\n\n            int endSec = hour * 1000 * 60 * 60 + min * 1000 * 60 + sec;\n            int startSec = endSec - procTime + 1;\n\n            times.add(new Time(startSec, endSec));\n        }\n\n        private int findMaxRequest(int startTime) {\n            int count = 0;\n            // start ~ end 사이에 있다면 count + 1;\n            int endTime = startTime + 1000;\n\n            for (Time time : times) {\n                if (startTime <= time.startSec && time.startSec < endTime) {\n                    count++;\n                } else if (startTime <= time.endSec && time.endSec < endTime) {\n                    count++;\n                } else if (endTime <= time.endSec && time.startSec <= startTime) {\n                    count++;\n                }\n            }\n\n            return count;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 문자열 파싱하는 과정부터 마음에 들지 않은 문제였고, 애매한 설명때문에 이해가 더 가지 않았다.\n- 처음에는 초 단위의 정보만을 가지고 문제를 해결하려다가 아차 싶었다.\n- 데이터 형 변환 또한 좀 더 꼼꼼히 확인하는 습관을 가져야겠다."},{"excerpt":"문제 Programmers - 뉴스 클러스터링 📍 Logic  으로 단어와 그 빈도 수를 저장한다. 두 맵에 모두 존재하는 원소라면, 두 맵 중 더 작은 빈도 수를 교집합의 크기에 더한다. 📄 CODE ✏️ Review 자카드 유사도를 이해하는데 너무 오래 걸렸다.  \"원소의 중복을 허용하는 다중집합\" 이라는 조건에서 시간이 많이 뺏겼다. 항상 테케를 잘 …","fields":{"slug":"/[Programmers]17677/"},"frontmatter":{"date":"May 17, 2022","title":"👩‍💻 17677. 뉴스 클러스터링","tags":["문자열","Map"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 뉴스 클러스터링](https://programmers.co.kr/learn/courses/30/lessons/17677)\n\n### 📍 **Logic**\n\n```java\n// 단어와 빈도 수 초기화\nfor (int i = 0; i < str1.length() - 1; i++) {\n    String str = parsing(str1, i);\n    if (str.length() != 2) continue;\n\n    size1++;\n    if (map1.containsKey(str)) map1.put(str, map1.get(str) + 1);\n    else map1.put(str, 1);\n}\n\nfor (int i = 0; i < str2.length() - 1; i++) {\n    String str = parsing(str2, i);\n    if (str.length() != 2) continue;\n\n    size2++;\n    if (map2.containsKey(str)) map2.put(str, map2.get(str) + 1);\n    else map2.put(str, 1);\n}\n```\n- `Map` 으로 단어와 그 빈도 수를 저장한다.\n\n```java\n// 교집합 구하기, 두 빈도 수 중 작은 값을 교집합의 크기로 지정\nint inter = 0;\nfor (String key : map1.keySet())\n    if (map2.containsKey(key))\n        inter += map1.get(key) > map2.get(key) ? map2.get(key) : map1.get(key);\n```\n- 두 맵에 모두 존재하는 원소라면, 두 맵 중 **더 작은 빈도 수**를 교집합의 크기에 더한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        public int solution(String str1, String str2) {\n            Map<String, Integer> map1 = new HashMap<>();\n            Map<String, Integer> map2 = new HashMap<>();\n            \n            str1 = str1.toLowerCase();\n            str2 = str2.toLowerCase();\n\n            int size1 = 0;\n            int size2 = 0;\n\n            // 단어와 빈도 수 초기화\n            for (int i = 0; i < str1.length() - 1; i++) {\n                String str = parsing(str1, i);\n                if (str.length() != 2) continue;\n\n                size1++;\n                if (map1.containsKey(str)) map1.put(str, map1.get(str) + 1);\n                else map1.put(str, 1);\n            }\n\n            for (int i = 0; i < str2.length() - 1; i++) {\n                String str = parsing(str2, i);\n                if (str.length() != 2) continue;\n\n                size2++;\n                if (map2.containsKey(str)) map2.put(str, map2.get(str) + 1);\n                else map2.put(str, 1);\n            }\n\n            // 교집합 구하기, 두 빈도 수 중 작은 값을 교집합의 크기로 지정\n            int inter = 0;\n            for (String key : map1.keySet())\n                if (map2.containsKey(key))\n                    inter += map1.get(key) > map2.get(key) ? map2.get(key) : map1.get(key);\n            \n            // 두 집합이 모두 공집합인 경우 J = 1\n            if (map1.size() == 0 && map2.size() == 0) return 65536;\n            \n            float j = (float) inter / (float) (size1 + size2 - inter);\n\n            int answer = (int) (j * 65536);\n\n            return answer;\n        }\n\n        private String parsing(String str, int i) {\n            return str.substring(i, i+2).replaceAll(\"[^a-zA-Z]\",\"\");\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 자카드 유사도를 이해하는데 너무 오래 걸렸다. \n  - \"원소의 중복을 허용하는 다중집합\" 이라는 조건에서 시간이 많이 뺏겼다.\n- 항상 테케를 잘 확인해야겠다."},{"excerpt":"🧷 비트마스크 현대의 모든 CPU는 이진수를 이용해 모든 자료를 표현하고, 이는 이진법 관련 연산을 아주 빨리 처리할 수 있다는 장점이 있다. 이와 같은 특성을 이용해 정수의 이진수 표현을 자료 구조로 쓰는 기법을 말한다. 집합의 요소들의 구성 여부를 표현할 때 유용한 알고리즘이다. 🪚 장점 더 빠른 수행 시간 비트 마스크 연산은  에 구현되는 것이 많아…","fields":{"slug":"/[Algorithm]비트마스크/"},"frontmatter":{"date":"May 16, 2022","title":"💡 비트마스크(BitMask)","tags":["개발상식","Java","비트마스크"]},"rawMarkdownBody":"\n## 🧷 비트마스크\n현대의 모든 CPU는 이진수를 이용해 모든 자료를 표현하고, 이는 이진법 관련 연산을 아주 빨리 처리할 수 있다는 장점이 있다. 이와 같은 특성을 이용해 정수의 이진수 표현을 자료 구조로 쓰는 기법을 말한다.\n\n> 집합의 요소들의 구성 여부를 표현할 때 유용한 알고리즘이다.\n\n### 🪚 장점\n**더 빠른 수행 시간**\n- 비트 마스크 연산은 $O(1)$ 에 구현되는 것이 많아 다른 자료 구조보다 훨씬 빨리 동작한다.\n- 물론 비트마스크를 사용할 수 있다는 말은 원소의 수가 많지 않다는 의미이므로, 엄청나게 큰 속도 향상은 아니다.\n\n**간결한 코드**\n- 다양한 집합 연산들을 반복문 없이 한 줄에 쓸 수 있어 짧은 코드를 작성할 수 있다.\n\n**더 작은 메모리 사용량**\n- 같은 데이터를 더 적은 메모리를 사용해 표현할 수 있다.\n- 이로 인해 더 많은 데이터를 미리 계산해서 저장해 둘 수 있게 된다.\n\n**연관 배열을 배열로 대체**\n- 집합을 배열의 인덱스로 표현할 수 있다.\n\n**DP나 순열 등 배열 활용만으로 해결할 수 없는 문제 해결**\n\n### 🪚 비트마스킹 활용\n> 0과 1로 flag 활용하기\n\n`[1,2,3,4,5]` 라는 집합이 있다고 가정한다. 여기서 임의로 몇 개를 골라 뽑아 확인해야 하는 상황이 주어졌다. (부분 집합을 의미)\n\n```java\n{1}, {2}, ... , {1,2}, {1,2,5}, {1,2,3,4,5}\n```\n\n비트마스킹을 통해, 각 요소를 인덱스처럼 표현하여 효율적인 접근을 할 수 있다.\n\n```java\n[1,2,3,4,5] -> 11111\n[2,3,4,5]   -> 11110\n[1,2,5]     -> 10011\n[3]         -> 00100\n```\n이러한 2진수를 10진수로 변환하여 부분집합을 정수를 통해 나타내는 것도 가능하다.\n\n> `11111` -> 10진수 변환 -> `31`\n\n이로써, 해당 부분집합에 `i` 를 추가하고 싶다면 `i` 번째 비트를 1로 바꿔주어 표현할 수 있다. 그리고 이때 **비트 연산**을 사용한다.\n\n### 🪚 비트 연산\n- `AND(&)` : 대응하는 두 비트가 모두 1일때만 1을 반환\n- `OR(|)` : 대응하는 두 비트 중 하나라도 1일때 1을 반환\n- `XOR(^)` : 대응하는 두 비트가 서로 다를 때만 1을 반환\n- `NOT(~)` : 비트 값을 반전하여 반환\n- `SHIFT(>>, <<)` : 왼쪽 혹은 오른쪽으로 비트를 옮겨 반환\n  - 왼쪽 SHIFT (`A << B`) : `A * 2^B`\n  - 오른쪽 SHIFT (`A >> B`) : `A / 2^B`\n\n```java\n[왼쪽]   0001 → 0010 → 0100 → 1000 : 1 → 2 → 4 → 8\n[오른쪽] 1000 → 0100 → 0010 → 0001 : 8 → 4 → 2 → 1\n```\n\n### 🪚 예제를 통한 구현\n피자집이 있다. 여기에는 0부터 19까지의 번호를 갖는 스무 가지의 토핑이 있고, 주문 시 토핑을 넣거나 뺄 수 있다.\n- 그렇다면 한 피자의 정보는 스무 종류의 원소만을 가지는 집합으로 표현할 수 있다.\n- 이를 `boolean[]` 으로 표현할 수도 있지만, 비트마스킹을 사용한다.\n\n**공집합과 꽉 찬 집합**\n- 토핑을 올리지 않은 피자와 모든 토핑을 올린 피자를 표현하려면 아래와 같이 할 수 있다.\n\n```java\n// 토핑이 없는 피자\nint emptyPizza = 0;\n// 스무 개의 토핑을 모두 올린 피자\nint fullPizza = (1 << 20) - 1;\n```\n- `1 << 20` 은 1뒤에 20개의 0이 있는 정수이므로, 여기서 1을 빼면 20개의 비트가 모두 켜진 정수를 얻을 수 있다.\n\n**원소 추가**\n- 집합의 가장 기본적인 연산은 원소를 추가하고 삭제하는 것이다.\n- 비트마스크를 사용한 집합에서 원소를 추가한다는 것은 해당 비트를 킨다는 의미이다.\n\n```java\n// 토핑 목록에 p번 토핑을 추가하고 싶은 경우\ntoppings |= (1 << p);\n```\n- `1 << p` 는 p번째 비트만 켜진 정수이다.\n- 이미 `toppings` 에 p번 토핑이 추가된 경우 값은 변하지 않는다.\n\n**원소 삭제**\n```java\n// 토핑 목록에서 p번 토핑을 삭제하고 싶은 경우 (토핑 목록에 p번 토핑이 있어야 함)\ntoppings -= (1 << p);\n\n// 토핑이 없을 때도 정상적으로 동작하는 삭제\ntoppings &= ~(1 << p);\n```\n\n**원소 포함 여부 확인**\n- 토핑 목록에 원하는 토핑이 잘 추가되었는지 확인한다.\n\n```java\nif ((toppings & (1 << p)) == (1 << p))\n  System.out.println(\"Topping is in!\");\n```\n- `&` 연산의 결과값은 0 또는 `1 << p` 이다.\n\n**원소의 토글**\n- 해당 비트가 켜져 있으면 끄고, 꺼져 있다면 킨다.\n- `XOR` 연산을 사용한다.\n\n```java\ntoppings ^= (1 << p);\n```\n\n**집합의 크기 구하기**\n- 가장 간단한 방법은 각 비트를 순회하면서 켜져 있는 비트의 수를 직접 세는 방법이다.\n- 하지만 JAVA에서는 이와 관련된 내장 명령어를 제공한다.\n\n```java\nSystem.out.println(Integer.bitCount(toppings));\n```\n\n**최소 원소 지우기**\n- 최소 원소가 무엇인지 상관없이 지우는 연산이 필요할 때 유용하다.\n\n```java\ntoppings &= (toppings - 1);\n```\n\n`toppings - 1` 의 이진수 표현을 생각해보면, 이는 `toppings` 에서 켜져 있는 최하위 비트를 끄고, 그 밑의 비트들을 전부 킨 컷이다.\n- 따라서 두 값을 AND 연산하면 최하위 비트와 그 이하의 비트들은 전부 0이 된다.\n- 40(10 1000)과 39(10 0111)을 AND 연산하면 32(10 0000)로 최하위 비트가 꺼진 것을 확인할 수 있다.\n\n**모든 부분 집합 순회**\n- 주어진 집합의 모든 부분 집합을 순회할 경우도 유용하다.\n\n```java\nfor (int subset = pizza; subset; subset = ((subset - 1) & pizza)) {\n  // subset은 pizza의 부분 집합\n}\n```\n- `(subset - 1) & pizza` 에서, `subset - 1` 로 켜져 있던 최하위 비트가 꺼지고, 그 밑의 비트들은 전부 켜지게 된다. 이 결과와 `pizza` 의 교집합을 구하면 그 중 `pizza` 에 속하지 않는 비트들은 모두 꺼지게 된다.\n- 이 연산을 반복하여 모든 부분 집합을 순회할 수 있다. 하지만 `subset = 0` 인 시점에 종료되기에 공집합은 순회하지 않는다.\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog)\n- [**프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략**] 구종만"},{"excerpt":"문제 Programmers - 캐시 📍 Logic  를 사용해 들어온 도시순으로 캐싱한다.  이 발생한다면, 해당 도시를 지우고 다시 맨 뒤에 추가한다. 📄 CODE ✏️ Review 매우 쉬운 문제였지만, LRU 알고리즘을 대충 생각하고 풀었다가 시간 날려버렸다. 이런...","fields":{"slug":"/[Programmers]17680/"},"frontmatter":{"date":"May 16, 2022","title":"👩‍💻 17680. 캐시","tags":["큐"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 캐시](https://programmers.co.kr/learn/courses/30/lessons/17680)\n\n### 📍 **Logic**\n\n```java\nfor (String city : cities) {\n    city = city.toLowerCase();\n    // 이미 캐시에 있다면\n    if (cache.contains(city)) {\n        cache.remove(city);\n        time++;\n    } else {\n        // 캐시에 없는데, 더 이상 캐시 공간도 없는 경우, 처음 들어온 값을 삭제\n        if (cache.size() >= cacheSize) cache.poll();\n        time += 5;\n    }\n    cache.add(city);\n}\n```\n- `Queue` 를 사용해 들어온 도시순으로 캐싱한다.\n- `Hit` 이 발생한다면, 해당 도시를 지우고 다시 맨 뒤에 추가한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        // 도시 이름이 들어온 순서를 저장하기 위한 큐\n        Queue<String> cache = new LinkedList<>();\n\n        public int solution(int cacheSize, String[] cities) {\n            int time = 0;\n            \n            // cacheSize가 0이면 캐시 힛이 발생하지 않음\n            if (cacheSize == 0) return cities.length * 5;\n            \n            for (String city : cities) {\n                city = city.toLowerCase();\n                // 이미 캐시에 있다면\n                if (cache.contains(city)) {\n                    cache.remove(city);\n                    time++;\n                } else {\n                    // 캐시에 없는데, 더 이상 캐시 공간도 없는 경우, 처음 들어온 값을 삭제\n                    if (cache.size() >= cacheSize) cache.poll();\n                    time += 5;\n                }\n                cache.add(city);\n            }\n            \n            return time;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 매우 쉬운 문제였지만, LRU 알고리즘을 대충 생각하고 풀었다가 시간 날려버렸다. 이런..."},{"excerpt":"문제 BOJ - 소트 📍 Logic  가 0이 되면 종료되는 반복문  는 스왑이 가능한 범위를 의미하고, 이 범위 내의 최댓값을 찾고, 그까지 스왑을 반복한다. 범위 내의 최댓값을 찾아 그 위치를 반환한다. 📄 CODE ✏️ Review 문제 자체는 쉬웠으나, 계속  가 떠서 틀렸다. 입력 범위를 확인해보니  보다  가 클 수 있어 당연하게도 범위를 넘어가…","fields":{"slug":"/[BOJ]1083/"},"frontmatter":{"date":"May 15, 2022","title":"👩‍💻 1083. 소트","tags":["그리디","정렬"]},"rawMarkdownBody":"\n## 문제\n[BOJ - 소트](https://www.acmicpc.net/problem/1083)\n\n### 📍 **Logic**\n\n```java\nfor (int i = 0; i < N; i++) {\n    if (S == 0) break;\n\n    int maxIdx = findMax(i, i + S);\n\n    for (int j = maxIdx; j > i; j--) {\n        swap(j - 1, j);\n        S--;\n    }\n}\n```\n\n- `S` 가 0이 되면 종료되는 반복문\n- `S` 는 스왑이 가능한 범위를 의미하고, 이 범위 내의 최댓값을 찾고, 그까지 스왑을 반복한다.\n\n```java\nprivate static int findMax(int s, int e) {\n    int maxIdx = 0;\n    int max = 0;\n\n    for (int i = s; i <= e && i < numbers.length; i++) {\n        if (max < numbers[i]) {\n            maxIdx = i;\n            max = numbers[i];\n        }\n    }\n\n    return maxIdx;\n}\n```\n\n- 범위 내의 최댓값을 찾아 그 위치를 반환한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.*;\n\n    public class Main {\n        static int[] numbers;\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int N = Integer.parseInt(br.readLine());\n            numbers = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n            int S = Integer.parseInt(br.readLine());\n\n            for (int i = 0; i < N; i++) {\n                if (S == 0) break;\n\n                int maxIdx = findMax(i, i + S);\n\n                for (int j = maxIdx; j > i; j--) {\n                    swap(j - 1, j);\n                    S--;\n                }\n            }\n\n            for (int n : numbers)\n                System.out.print(n + \" \");\n        }\n\n        private static int findMax(int s, int e) {\n            int maxIdx = 0;\n            int max = 0;\n\n            for (int i = s; i <= e && i < numbers.length; i++) {\n                if (max < numbers[i]) {\n                    maxIdx = i;\n                    max = numbers[i];\n                }\n            }\n\n            return maxIdx;\n        }\n\n        private static void swap(int i1, int i2) {\n            int tmp = numbers[i1];\n            numbers[i1] = numbers[i2];\n            numbers[i2] = tmp;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 문제 자체는 쉬웠으나, 계속 `ArrayIndexOutOfBounds` 가 떠서 틀렸다.\n- 입력 범위를 확인해보니 `N` 보다 `S` 가 클 수 있어 당연하게도 범위를 넘어가는 경우가 발생할 수 있었다."},{"excerpt":"문제 Programmers - 호텔 방 배정 📍 Logic 재귀 호출을 통해 빈 방을 찾아  에 갱신해준다. 이를 통해 한 번에 빈 방을 배정해줄 수 있다. 📄 CODE ✏️ Review  을 사용해 방 번호와 배정 가능한 방 번호를 저장하여 두 값이 같아질 때까지 탐색하면서 배정 가능한 방을 배정해주는 방식으로 구현하였지만, 시간초과가 발생했다. 단축을 …","fields":{"slug":"/[Programmers]64063/"},"frontmatter":{"date":"May 15, 2022","title":"👩‍💻 64063. 호텔 방 배정","tags":["Union & Find"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 호텔 방 배정](https://programmers.co.kr/learn/courses/30/lessons/64063)\n\n### 📍 **Logic**\n\n```java\nprivate long getRoom(long room) {\n    // 해당 방이 아직 배정 받지 않은 경우\n    if (!roomMap.containsKey(room)) {\n        roomMap.put(room, room + 1);\n        return room;\n    }\n\n    // 해당 방이 이미 배정된 경우, 재귀 호출을 통해 빈 방을 찾는다.\n    long emptyRoom = getRoom(roomMap.get(room));\n    roomMap.put(room, emptyRoom);\n    \n    return emptyRoom;\n}\n```\n- 재귀 호출을 통해 빈 방을 찾아 `roomMap` 에 갱신해준다.\n- 이를 통해 한 번에 빈 방을 배정해줄 수 있다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        Map<Long, Long> roomMap = new HashMap<>();\n        \n        public long[] solution(long k, long[] room_number) {\n            long[] answer = new long[room_number.length];\n\n            for (int i = 0; i < room_number.length; i++)\n                answer[i] = getRoom(room_number[i]);\n            \n            return answer;\n        }\n        \n        private long getRoom(long room) {\n            // 해당 방이 아직 배정 받지 않은 경우\n            if (!roomMap.containsKey(room)) {\n                roomMap.put(room, room + 1);\n                return room;\n            }\n\n            // 해당 방이 이미 배정된 경우, 재귀 호출을 통해 빈 방을 찾는다.\n            long emptyRoom = getRoom(roomMap.get(room));\n            roomMap.put(room, emptyRoom);\n            \n            return emptyRoom;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- `Map` 을 사용해 방 번호와 배정 가능한 방 번호를 저장하여 두 값이 같아질 때까지 탐색하면서 배정 가능한 방을 배정해주는 방식으로 구현하였지만, 시간초과가 발생했다.\n- 단축을 위해서는 `1 -> 2 -> 3 -> 4 -> 5` 가 아니라 `1 -> 5` 로 방 배정을 바로 받을 수 있도록 해주어야 했다."},{"excerpt":"문제 고양이는 너무 귀엽다. 사람들은 고양이를 너무 귀여워했고, 결국 고양이와 더욱 가까워지고 싶어 고양이와의 소통을 위한 고양이 말 번역기를 발명하기로 했다. 이 번역기는 사람의 언어를 고양이의 언어로, 고양이의 언어를 사람의 언어로 바꾸어 주는 희대의 발명품이 될 것이다. 현재 고양이말 번역기의 베타버전이 나왔다. 그러나 이 베타버전은 완전 엉망진창이…","fields":{"slug":"/[BOJ]16472/"},"frontmatter":{"date":"May 14, 2022","title":"👩‍💻 16472. 고냥이","tags":["투 포인터"]},"rawMarkdownBody":"\n## 문제\n고양이는 너무 귀엽다. 사람들은 고양이를 너무 귀여워했고, 결국 고양이와 더욱 가까워지고 싶어 고양이와의 소통을 위한 고양이 말 번역기를 발명하기로 했다. 이 번역기는 사람의 언어를 고양이의 언어로, 고양이의 언어를 사람의 언어로 바꾸어 주는 희대의 발명품이 될 것이다.\n\n현재 고양이말 번역기의 베타버전이 나왔다. 그러나 이 베타버전은 완전 엉망진창이다. 베타버전의 번역기는 문자열을 주면 그 중에서 최대 N개의 종류의 알파벳을 가진 연속된 문자열밖에 인식하지 못한다. 굉장히 별로지만 그나마 이게 최선이라고 사람들은 생각했다. 그리고 문자열이 주어졌을 때 이 번역기가 인식할 수 있는 최대 문자열의 길이는 얼마인지가 궁금해졌다.\n\n고양이와 소통할 수 있도록 우리도 함께 노력해보자.\n\n## 입, 출력\n\n입력\n- 첫째 줄에는 인식할 수 있는 알파벳의 종류의 최대 개수 N이 입력된다. (1 < N ≤ 26)\n- 둘째 줄에는 문자열이 주어진다. (1 ≤ 문자열의 길이 ≤ 100,000) 단, 문자열에는 알파벳 소문자만이 포함된다.\n\n출력\n- 첫째 줄에 번역기가 인식할 수 있는 문자열의 최대길이를 출력한다.\n\n### 📍 **Logic**\n\n```java\nwhile(left <= right) {\n    // 범위 벗어나면 종료, 기본적으로 right가 먼저 움직임\n    if (right >= str.length()) break;\n\n    char rightCh = str.charAt(right);\n\n    if ((left != right || right == 0) && prev == left)\n        wordIndexMap.put(rightCh, wordIndexMap.getOrDefault(rightCh, 0) + 1);\n\n    // 아직 N개 이하인 경우, 계속 length를 늘림\n    if (wordIndexMap.size() <= N) {\n        maxLength = Math.max(maxLength, right - left + 1);\n        right++;\n        prev = left;\n    } else {\n        // N개가 채워져 기존의 종류를 하나 제외하는 경우\n        char leftCh = str.charAt(left);\n        int num = wordIndexMap.get(leftCh) - 1;\n        if(num == 0)\n            wordIndexMap.remove(leftCh);\n        else\n            wordIndexMap.put(leftCh, num);\n        left++;\n    }\n}\n```\n\n- `Map` 으로 알파벳 종류와 빈도 수를 저장한다.\n- `Map` 이 `N` size가 된 경우와 그렇지 않은 경우로 나눠, `right` 를 늘리면서 길이를 증가시키거나 `Map` 에서 기존 알파벳 하나를 지운다.\n  - 이때, `left` 에 위치한 문자열에 대해 `Map` 에서 조회해보고, `left` 를 증가시킨다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.HashMap;\n    import java.util.HashSet;\n    import java.util.Map;\n    import java.util.Set;\n\n    class Cat {\n        int maxLength = 0;\n        public Cat() {}\n\n        public void translate(int N, String str) {\n            Map<Character, Integer> wordIndexMap = new HashMap<>();\n            int left = 0;\n            int right = 0;\n            int prev = left;\n\n            while(left <= right) {\n                // 범위 벗어나면 종료, 기본적으로 right가 먼저 움직임\n                if (right >= str.length()) break;\n\n                char rightCh = str.charAt(right);\n\n                if ((left != right || right == 0) && prev == left)\n                    wordIndexMap.put(rightCh, wordIndexMap.getOrDefault(rightCh, 0) + 1);\n\n                // 아직 N개 이하인 경우, 계속 length를 늘림\n                if (wordIndexMap.size() <= N) {\n                    maxLength = Math.max(maxLength, right - left + 1);\n                    right++;\n                    prev = left;\n                } else {\n                    // N개가 채워져 기존의 종류를 하나 제외하는 경우\n                    char leftCh = str.charAt(left);\n                    int num = wordIndexMap.get(leftCh) - 1;\n                    if(num == 0)\n                        wordIndexMap.remove(leftCh);\n                    else\n                        wordIndexMap.put(leftCh, num);\n                    left++;\n                }\n            }\n        }\n\n        public int getMaxLength() {\n            return maxLength;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int N = Integer.parseInt(br.readLine());\n            String str = br.readLine();\n\n            Cat cat = new Cat();\n\n            cat.translate(N, str);\n\n            System.out.println(cat.getMaxLength());\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 투 포인터 알고리즘을 알게 되어 아이디어는 쉽게 잡을 수 있었으나 구현에서 조금 막혔다.\n- `right` 를 늘리면서 `prev` 를 확인해주는 과정이 필요했다.\n\n### 📕 출처\n- Baekjoon : https://www.acmicpc.net/problem/16472"},{"excerpt":"🧷 동적 계획법 (DP) 복잡한 문제를 간단한 여러 개의 문제로 나눠 푸는 방법으로, 큰 의미에서 분할 정복과 같은 접근 방식을 의미한다. 한 가지 문제에 대해, 단 한 번만 풀도록 만들어주는 알고리즘으로, 동일한 연산을 반복하지 않는다. 실행 시간을 줄이기 위해 많이 이용되는 알고리즘 (최적화 알고리즘) 효율성 테스트가 있는 경우, DP나 이진 탐색을 …","fields":{"slug":"/[Algorithm]DynamicProgramming/"},"frontmatter":{"date":"May 13, 2022","title":"💡 DP (Dynamic Programming)","tags":["개발상식","Java","DP"]},"rawMarkdownBody":"\n## 🧷 동적 계획법 (DP)\n> 복잡한 문제를 간단한 여러 개의 문제로 나눠 푸는 방법으로, 큰 의미에서 분할 정복과 같은 접근 방식을 의미한다.\n\n한 가지 문제에 대해, 단 한 번만 풀도록 만들어주는 알고리즘으로, 동일한 연산을 반복하지 않는다.\n- 실행 시간을 줄이기 위해 많이 이용되는 알고리즘 (최적화 알고리즘)\n  - > 효율성 테스트가 있는 경우, DP나 이진 탐색을 많이 사용한다고들 한다...\n- **Optimal Substructure**에서 효과를 발휘한다.\n  - > Optimal Substructure: 답을 구하기 위해 이미 했던 동일한 연산을 반복하는 구조로, 최적화 문제의 모든 하위 솔루션은 최적의 솔루션이다. (Principle of Optimality)\n\n> **분할 정복과 DP의 차이점?**\n> : 문제를 나누는 방식에 있어 차이가 있다. 동적 계획법에서, 어떤 부분 문제는 두 개 이상의 문제를 푸는 데 사용될 수 있어 이 문제의 답을 여러 번 계산하지 않고 한 번만 계산한 후 결과를 재사용하는 방식을 취한다.\n\n### 🪚 조건\n- 작은 문제에서 반복이 발생\n- 같은 문제는 항상 같은 정답\n\n위 두 가지 조건을 충족한다면, 동적 계획법을 사용해 문제를 풀 수 있다. 그리고 한 번 계산한 결과를 저장하기 위해 **Memoization**을 사용한다.\n\n> **Memoization**\n> : 한 번 계산한 문제는 다시 계산하지 않도록 저장해두고 재사용하는 방식\n\n### 🪚 예제\n가장 유명한 예 중 하나는 이항 계수(binomial coefficient)의 계산이다. 이항 계수$(\\begin{matrix}n\\\\r\\\\ \\end{matrix})$는 n개의 서로 다른 원소 중 r개의 원소를 순서없이 골라내는 방법의 수를 나타낸다.\n- 그리고 이 점화식을 재귀 호출을 이용하여 구현하면 아래와 같다.\n\n```java\nint bino(int n, int r) {\n  if (r == 0 || n == r) return 1;\n  return bino(n - 1, r - 1) + bino(n - 1, r);\n}\n```\n- 재귀 호출을 수행하는 과정에서, **동일한 연산이 중복적으로 호출**된다. 그리고 이러한 중복 계산은 n이 증가할 때마다 기하급수적으로 연산량이 증가하도록 만든다.\n- 따라서, 각 n,r 조합에 대해 답을 저장하는 **배열**을 만들어, 각 입력에 대한 반환 값을 저장하도록 변경한다.\n  - 이미 저장된 값이 있다면 이를 재사용하고, 그렇지 않다면 직접 계산한 후 배열에 값을 저장한다.\n  - 즉, **Memoization을 사용해 최적화**를 수행한다.\n\n```java\n// -1로 초기화\nint[][] cache = new int[30][30];\nint bino2(int n, int r) {\n  if (r == 0 || n == r) return 1;\n  if (cache[n][r] != -1) return cache[n][r];\n  return cache[n][r] = bino2(n - 1, r - 1) + bino2(n - 1, r);\n}\n```\n\n### 🪚 구현 방식\n동적 계획법을 구현하는 방식에 있어 2가지가 가능하다.\n- **Bottom-up**: 작은 문제들부터 해결하면서 전체 답을 구하는 방식\n  - 흔히 반복문을 사용해 구현하고, 재귀 호출을 사용하지 않아 시간과 메모리 사용량을 줄일 수 있다는 장점이 있다.\n- **Top-down**: 가장 큰 문제를 방문 후 작은 문제를 호출해 답을 구하는 방식\n  - 흔히 재귀 호출을 사용해 구현하고, 점화식을 직관적으로 이해하기 쉽다는 장점이 있다.\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog)\n- [Top-down(탑다운) vs Bottom-up(바텀업)](https://semaph.tistory.com/16)\n- [**프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략**] 구종만"},{"excerpt":"🧷 최소 공통 조상 Lowest Common Ancestor 알고리즘으로, 트리에서 두 정점이 만나는 최초 부모 정점을 찾는 알고리즘이다. 트리 문제에서 공통 조상을 찾아야 하거나, 정점과 정점 사이의 이동거리 또는 방문경로를 저장해야 할 경우 사용할 수 있다. 🪚 과정 해당 정점의  와  를 저장하는 방식이다. 위 그림에서의  와  는 아래와 같다. 하…","fields":{"slug":"/[Algorithm]최소공통조상(LCA)/"},"frontmatter":{"date":"May 13, 2022","title":"💡 최소 공통 조상(LCA)","tags":["개발상식","Java","LCA"]},"rawMarkdownBody":"\n## 🧷 최소 공통 조상\nLowest Common Ancestor 알고리즘으로, 트리에서 두 정점이 만나는 **최초 부모 정점**을 찾는 알고리즘이다.\n- 트리 문제에서 공통 조상을 찾아야 하거나, 정점과 정점 사이의 이동거리 또는 방문경로를 저장해야 할 경우 사용할 수 있다.\n\n<img src=\"https://media.geeksforgeeks.org/wp-content/cdn-uploads/lca.png\" width=\"70%\">\n\n### 🪚 과정\n해당 정점의 `depth` 와 `parent` 를 저장하는 방식이다. 위 그림에서의 `depth` 와 `parent` 는 아래와 같다.\n\n```\n[depth : 정점]\n0 -> 1\n1 -> 2, 3\n2 -> 4, 5, 6, 7\n\nint[] parent = {0, 1, 1, 2, 2, 3, 3};\n```\n\n```java\nclass Main {\n  // 정점 번호가 0부터 시작한다고 가정\n  // depth와 parent 초기화\n  static int[] depth = {0,1,1,2,2,2,2};\n  static int[] parent = {0,1,1,2,2,3,3};\n\n  public static void main(String[] args) {\n    int node1 = 3;\n    int node2 = 4;\n    int LCA = 0;\n\n    while(true){\n      if(depth[node1] == depth[node2]) {\n        // depth가 같은 경우\n        if(parent[node1] == parent[node2]) {\n          // 부모가 같은 경우, LCA를 찾음\n          LCA = parent[node1];\n          break;\n        } else {\n          // 부모가 다르기에 상위 정점으로 이동\n          node1 = parent[node1];\n          node2 = parent[node2];\n        }\n      } else {\n        // depth가 다른 경우. 더 작은 depth의 정점을 상위로 이동\n        if (depth[node1] > depth[node2]) {\n          node1 = parent[node1];\n        } else {\n          node2 = parent[node2];\n        }\n      }\n    }\n\n    System.out.println(\"LCA is: \" + LCA);\n  }\n} \n```\n\n하지만 위 방식은 1세대 부모만을 반복해서 찾아 올라가기 때문에 $O(N)$ 의 시간복잡도를 가지게 된다. 이를 개선하기 위해 \"1, 2, 4, 8, ... 칸 떨어진 부모가 누군지도 기록\"하여 사용한다. 이는 $O(logN)$ 의 시간복잡도를 가진다.\n\n### 🪚 개선 과정\n1차원 `parent` 배열을, $2^0, 2^1, 2^2, ...$ 부모의 정보도 저장하기 위해 2차원 `parent` 배열로 변경한다.\n- `parent[n][k]` (n = Tree의 정점 수, k = log(n)의 올림)\n\n먼저 주어진 tree와 root를 가지고, DFS를 수행하면서 각 정점과 연결된 **1세대 부모**와, **깊이 정보**를 구한다.\n\n```java\nint[][] parent = new int[n][k];\nint[] depth = new int[n];\nArrays.fill(depth, -1);\n\nvoid dfs(int cur) {\n  for (int next : adj[cur]) {\n    if (depth[next] == -1) {\n      parent[next][0] = cur;\n      depth[next] = depth[cur] + 1;\n      dfs(next);\n    }\n  }\n  return;\n}\n```\n\n이제 구한 1세대 부모 정보를 이용해, $2^1, 2^2, ...$ 부모의 정보를 구해야 한다.\n- 현재를 기준으로 2($2^1$)칸 떨어진 부모는 \"현재의 1($2^0$)칸 떨어진 부모의 1($2^0$)칸 떨어진 부모\"이다.\n- 현재를 기준으로 4($2^2$)칸 떨어진 부모는 \"현재의 2($2^1$)칸 떨어진 부모의 2($2^1$)칸 떨어진 부모\"이다.\n- 즉, **현재를 기준으로 $2^k$칸 떨어진 부모는 현재의 $2^{k-1}$칸 떨어진 부모의 $2^{k-1}$칸 떨어진 부모이다.**\n\n```java\n// max = logN의 올림\nvoid connectParents() {\n  for (int k = 1; k < max; k++) {\n    for (int cur = 1; cur <= n; cur++) {\n      parent[cur][k] = parent[parent[cur][k-1]][k-1];\n    }\n  }\n}\n```\n\n완성된 정보를 이용하여, 아래의 과정으로 LCA를 찾는다.\n- 두 정점의 `depth` 를 같도록 한다.\n- 부모가 같은 정점에 도달할 때까지 위로 점프한다.\n\n먼저 두 정점의 `depth` 가 같도록 하기 위해, 두 정점 간의 `depth` 차이를 구한다.\n- `depth` 의 차가 `3` 이라고 가정하면, 점프를 2의 지수로 하기에, `3` 을 2진수로 변환한다.\n  - `3` -> `11(2)` 으로 나타낼 수 있고, 이는 $2^0$칸짜리 1번, $2^1$칸짜리 1번 점프를 의미한다.\n  - 만약 차가 `11` 이라면, `1011(2)` 로 나타낼 수 있고, 이는 $2^0$칸짜리 1번, $2^1$칸짜리 1번, $2^3$칸짜리 1번 점프를 의미한다.\n\n```java\nint getLCA(int u, int v) {\n  // u를 더 깊은 정점으로!\n  if (depth[u] < depth[v]) swap(u, v);\n\n  int diffDist = depth[u] - depth[v];\n\n  for (int i = 0; diffDist != 0; i++) {\n    if (diffDist % 2 == 1) u = parent[u][i];\n    diffDist /= 2;\n  }\n}\n```\n\n이제 `depth` 가 같아졌고, 부모가 같은 정점에 도달할 때까지 두 정점을 함께 점프할 것이다.\n- $2^{log(트리의\\ 정점\\ 수\\ n)의\\ 올림}$ 만큼 부모를 가지기에, 트리의 정점 수보다 더 큰 범위의 부모 정보를 가질 수 있다. 이는 -1로 저장되도록 한다. (메모리의 낭비를 막기 위해 최적화가 가능할 것)\n- 큰 범위의 부모부터 내림차순으로 (16, 8, 4, 2, 1) 부모 정보를 확인하면서 점프한다.\n- 위에서 `diffDist` 만큼 이동했던 것과 비슷한 방식으로 수행하는데, **도착지는 LCA 바로 밑의 자식이라고 가정**한다.\n  - 점프했는데, 두 정점의 부모가 동일하다면, 도착지를 넘어버린 경우이고,\n  - 부모의 값이 -1이라면 트리의 범위를 벗어난 경우이다.\n\n```java\nint getLCA(int u, int v) {\n  ...\n\n  if (u != v) {\n    // 점프 가능한 최대부터 시작\n    for (int i = max - 1; i >= 0; i--) {\n      // -1이라면 트리의 범위 밖, 두 부모가 같다면 LCA가 아님(도착지를 넘어버린 경우)\n      // 그렇지 않은 경우에 대해 점프를 수행, LCA의 바로 밑 정점으로 점프\n      if (parent[u][i] != -1 && parent[u][i] != parent[v][i]) {\n        u = parent[u][i];\n        v = parent[v][i];\n      }\n    }\n    // LCA 바로 밑 정점으로 점프했기에, 1칸 위가 LCA\n    u = parent[u][0];\n  }\n  return u;\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog)\n- [최소 공통 조상(LCA, Lowest Common Ancestor)(C/C++)](https://kibbomi.tistory.com/201)"},{"excerpt":"🧷 다익스트라(Dijkstra) 알고리즘 DP를 활용한 최단 경로 탐색 알고리즘으로, 시작 정점  에서부터 다른 정점들까지의 최단 거리를 계산한다. DP가 적용되는 이유는, 굳이 한 번 최단 거리를 구한 곳은 다시 구할 필요가 없기 때문이다. 그리고 이를 활용해 정점에서 정점까지 간선을 따라 이동할 때 최단 거리를 효율적으로 구할 수 있다. 간선의 값이 …","fields":{"slug":"/[Algorithm]다익스트라알고리즘/"},"frontmatter":{"date":"May 13, 2022","title":"💡 다익스트라(Dijkstra) 알고리즘","tags":["개발상식","Java","Dijkstra"]},"rawMarkdownBody":"\n## 🧷 다익스트라(Dijkstra) 알고리즘\nDP를 활용한 최단 경로 탐색 알고리즘으로, 시작 정점 `s` 에서부터 다른 정점들까지의 최단 거리를 계산한다.\n- DP가 적용되는 이유는, 굳이 한 번 최단 거리를 구한 곳은 다시 구할 필요가 없기 때문이다.\n- 그리고 이를 활용해 정점에서 정점까지 간선을 따라 이동할 때 최단 거리를 효율적으로 구할 수 있다.\n\n> 간선의 값이 양수인 경우만 알고리즘을 사용할 수 있다.\n\n> **음수 간선이 존재하면 안되는 이유?**\n> <img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2Fc3lSDe%2Fbtrhn3zNgfu%2FctA1FRLMWNuzRvvssYPIkk%2Fimg.png\" width=\"30%\">\n> - 위 경우, A에서 출발하여 `dist[B] = 10` , `dist[C] = 4` 로 업데이트한 후,\n> - 가장 비용이 작은 C로 이동할 것이다. 그렇게 되면, 더 이상 C의 거리가 갱신될 일이 없어 -90이 아닌 4로 종료된다.\n> \n> 하지만, 우선순위 큐를 사용해 방문한 정점에 대해서 재방문하여 최소 비용을 저장한다면 음수 가중치에 대한 계산이 가능하다. 이는 아래에서 구현한다.\n\n<img src=\"https://upload.wikimedia.org/wikipedia/commons/5/57/Dijkstra_Animation.gif\" width=\"70%\">\n\n다익스트라 알고리즘의 구현을 위해 2가지를 저장해야 한다.\n- 해당 정점까지의 최단 거리\n- 정점 방문 여부\n\n### 🪚 과정\n1. 최단 거리 값은 무한대 값으로 초기화\n2. 시작 정점의 최단 거리는 0이다. (방문 처리)\n3. 시작 정점과 연결된 정점들의 최단 거리 값을 갱신\n4. 방문하지 않은 정점 중 최단 거리가 최소인 정점을 탐색\n5. 찾은 정점을 방문 체크하고, 해당 정점과 연결된 미방문 정점의 최단 거리 값을 갱신\n6. 모든 정점을 방문할 때까지 4~5번 반복\n\n### 🪚 시간 복잡도\n- 인접 행렬 구현 시: $O(N^2)$\n- 인접 리스트 구현 시: $O(NlogN)$\n\n### 🪚 일종의 개선?\n**우선순위 큐**를 사용해 거리가 가장 가까운 정점부터 방문할 수 있도록 한다.\n- 우선순위 큐에 정점의 번호와 지금까지 찾아낸 해당 정점까지의 최단 거리를 쌍으로 저장한다.\n- 아직 방문하지 않은 정점 중 시작점으로부터의 거리가 가장 가까운 점을 찾는 과정을 간단하게 해준다.\n\n우선순위 큐를 사용한따는 점을 제외하면, BFS와 비슷한 구조의 알고리즘이다.\n- 각 정점까지의 최단 거리를 저장하는 배열을 유지하며,\n- 정점 방문마다 인접한 정점을 모두 검사한다.\n\n```java\nclass Pair implements Comparable<Node> {\n  int num;\n  int weight;\n\n  public Pair(int num, int weight) {\n    this.num = num;\n    this.weight = weight;\n  }\n\n  @Override\n  public int compareTo(Node n) {\n      return this.weight - n.weight;\n  }\n}\n\nint V;\nArrayList<ArrayList<Pair>> adjList = new ArrayList<>();\n\nint[] dijkstra(int src) {\n  int[] dist = new int[V];\n  Arrays.fill(dist, Integer.MAX_VALUE);\n  dist[src] = 0;\n\n  Queue<Pair> queue = new PriorityQueue<>();\n  queue.add(new Pair(src, 0));\n\n  while(!queue.isEmpty()) {\n    Pair p = queue.poll();\n    int here = p.num;\n    int cost = p.weight;\n\n    if (dist[here] < cost) continue;\n\n    for (int i = 0; i < adjList.get(here).size(); i++) {\n      int there = adjList.get(here).get(i).num;\n      int nextDist = cost + adjList.get(here).get(i).weight;\n\n      if (dist[there] > nextDist) {\n        dist[there] = nextDist;\n        queue.add(new Pair(there, nextDist));\n      }\n    }\n  }\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog)\n- [[Algorithm] 다익스트라 알고리즘 : 음수 간선이 있으면 안 되는 이유](https://kangworld.tistory.com/76)\n- [**프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략**] 구종만"},{"excerpt":"문제 Programmers - 징검다리 건너기 📍 Logic  에서 최솟값, 최댓값을 찾아 이분탐색  로  명이 건널 수 있는지 확인 건널 수 있다면  을 update 건널 수 없다면  를 update 📄 CODE ✏️ Review 0이  개 연속이라면, 더 이상 건널 수 없다는 큰 조건을 쉽게 알 수 있었으나, 효율성 테스트가 있는 것으로 보았을 때, 어…","fields":{"slug":"/[Programmers]64062/"},"frontmatter":{"date":"May 12, 2022","title":"👩‍💻 64062. 징검다리 건너기","tags":["이분 탐색"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 징검다리 건너기](https://programmers.co.kr/learn/courses/30/lessons/64062)\n\n### 📍 **Logic**\n\n```java\npublic int crossBridge(int[] stones, int k) {\n    int friends = 0;\n    int min = Integer.MAX_VALUE;\n    int max = 0;\n\n    // min과 max 사이에 건널 수 있는 최대 인원 수가 있음\n    for (int stone : stones) {\n        if (stone < min) min = stone;\n        if (stone > max) max = stone;\n    }\n\n    while (min <= max) {\n        int mid = (min + max)/2;\n\n        // 건널 수 있다면, min을 1 증가시키고 반복\n        if (canCrossOver(stones, k, mid)) {\n            min = mid + 1;\n            friends = mid;\n        } else {\n            max = mid - 1;\n        }\n    }\n\n    return friends;\n}\n```\n- `stones` 에서 최솟값, 최댓값을 찾아 이분탐색\n- `canCrossOver()` 로 `mid` 명이 건널 수 있는지 확인\n    - 건널 수 있다면 `min` 을 update\n    - 건널 수 없다면 `max` 를 update\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class StoneBridge {\n        public StoneBridge() {\n        }\n\n        public int crossBridge(int[] stones, int k) {\n            int friends = 0;\n            int min = Integer.MAX_VALUE;\n            int max = 0;\n\n            // min과 max 사이에 건널 수 있는 최대 인원 수가 있음\n            for (int stone : stones) {\n                if (stone < min) min = stone;\n                if (stone > max) max = stone;\n            }\n\n            while (min <= max) {\n                int mid = (min + max)/2;\n\n                // 건널 수 있다면, min을 1 증가시키고 반복\n                if (canCrossOver(stones, k, mid)) {\n                    min = mid + 1;\n                    friends = mid;\n                } else {\n                    max = mid - 1;\n                }\n            }\n\n            return friends;\n        }\n\n        private boolean canCrossOver(int[] stones, int k, int n) {\n            int cantOver = 0;\n\n            for (int stone : stones) {\n                // 건널 수 없는 돌\n                if (stone < n) {\n                    cantOver++;\n                } else cantOver = 0;\n\n                // 건널 수 없는 돌다리가 k개 연속이라면 건널 수 없음!\n                if (cantOver == k) return false;\n            }\n\n            return true;\n        }\n    }\n\n    class Solution {\n        public int solution(int[] stones, int k) {\n            StoneBridge sb = new StoneBridge();\n            \n            return sb.crossBridge(stones, k);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 0이 `K` 개 연속이라면, 더 이상 건널 수 없다는 큰 조건을 쉽게 알 수 있었으나, 효율성 테스트가 있는 것으로 보았을 때, 어떤 알고리즘을 사용해야 하는지 감이 오지 않았다.\n- 게시판에서 이분 탐색을 사용한다는 것을 보았고, 코드를 대강 참고하였다. 보고 나니 왜 이분 탐색을 사용해야 하는지를 이해할 수 있었다."},{"excerpt":"문제 Programmers - 불량 사용자 📍 Logic DFS 방식으로 제재 아이디  을 생성하고, 이를 중복이 없도록 하기 위해  에 저장한다. 📄 CODE ✏️ Review 정규 표현식만으로 해결하려고 했지만, DFS 방식으로 중복을 확인하는 과정이 필요했다. 이런 유형의 DFS, BFS 방식의 문제도 있을 수 있다는 것을 알게 되었다.","fields":{"slug":"/[Programmers]64064/"},"frontmatter":{"date":"May 12, 2022","title":"👩‍💻 64064. 불량 사용자","tags":["문자열","DFS"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 불량 사용자](https://programmers.co.kr/learn/courses/30/lessons/64064)\n\n### 📍 **Logic**\n\n```java\npublic void findBadUser(HashSet<String> set, int size) {\n    if (size == bannedIdList.size()) {\n        banSet.add(new HashSet<>(set));\n        return;\n    }\n\n    // list번째 제재 아이디를 set에 추가\n    for (String id : bannedIdList.get(size)) {\n        if (set.contains(id)) continue;\n        set.add(id);\n        findBadUser(set, size + 1);\n        set.remove(id);\n    }\n}\n```\n- DFS 방식으로 제재 아이디 `set` 을 생성하고, 이를 중복이 없도록 하기 위해 `HashSet` 에 저장한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n    import java.util.regex.Pattern;\n\n    class Ban {\n        HashSet<HashSet<String>> banSet;\n        ArrayList<ArrayList<String>> bannedIdList;\n\n        public Ban() {\n            banSet = new HashSet<>();\n            bannedIdList = new ArrayList<>();\n        }\n\n        public void makeSet(String banned_id, String[] user_id) {\n            // 정규표현식 사용을 위해 변환\n            String regex = banned_id.replace('*', '.');\n            ArrayList<String> tmpList = new ArrayList<>();\n\n            for (String user : user_id) {\n                boolean isMatch = Pattern.matches(regex, user);\n                if (isMatch) tmpList.add(user);\n            }\n            bannedIdList.add(tmpList);\n        }\n\n        public void findBadUser(HashSet<String> set, int size) {\n            if (size == bannedIdList.size()) {\n                banSet.add(new HashSet<>(set));\n                return;\n            }\n\n            // list번째 제재 아이디를 set에 추가\n            for (String id : bannedIdList.get(size)) {\n                if (set.contains(id)) continue;\n                set.add(id);\n                findBadUser(set, size + 1);\n                set.remove(id);\n            }\n        }\n\n        public int getCount() {\n            return banSet.size();\n        }\n    }\n\n    class Solution {\n        public int solution(String[] user_id, String[] banned_id) {\n            Ban b = new Ban();\n\n            for (String ban : banned_id)\n                b.makeSet(ban, user_id);\n\n            b.findBadUser(new HashSet<>(), 0);\n\n            return b.getCount();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 정규 표현식만으로 해결하려고 했지만, DFS 방식으로 중복을 확인하는 과정이 필요했다.\n- 이런 유형의 DFS, BFS 방식의 문제도 있을 수 있다는 것을 알게 되었다."},{"excerpt":"🧷 최장 증가 수열 가장 긴 증가하는 부분 수열(Longest Increasing Sequence)로, 일반적으로는 DP를 이용해 해결한다. 🪚 DP를 활용한 구현 및 시간 복잡도 하지만 위와 같이 DP를 활용하는 방식의 시간 복잡도는 이다. 이를 줄이는 좋은 방법은 이분 탐색을 활용하는 것이다. 🪚 이분 탐색을 활용한 구현 및 시간 복잡도 LIS를 구성…","fields":{"slug":"/[Algorithm]최장증가수열(LIS)/"},"frontmatter":{"date":"May 09, 2022","title":"💡 최장 증가 수열(LIS)","tags":["개발상식","Java","LIS"]},"rawMarkdownBody":"\n## 🧷 최장 증가 수열\n가장 긴 증가하는 부분 수열(Longest Increasing Sequence)로, 일반적으로는 DP를 이용해 해결한다.\n\n```\n{7, 2, 3, 8, 4, 5} -> LIS -> {2, 3, 4, 5}\n```\n\n### 🪚 DP를 활용한 구현 및 시간 복잡도\n```java\nint[] arr = {7, 2, 3, 8, 4, 5};\nint[] dp = new int[arr.length]; // LIS 저장 배열\nint max = 0;\n\nfor (int i = 1; i < dp.length; i++) {\n  for (int j = i - 1; j >= 0; j--) {\n    if (arr[i] > arr[j]) {\n      dp[i] = (dp[i] < dp[j] + 1) ? dp[j] + 1 : dp[i];\n      if (max < dp[i]) max = dp[i];\n    }\n  }\n}\n\nint[] answer = new int[max + 1];\nint check = dp[dp.length - 1];\nfor (int i = dp.length - 1; i >= 0; i--) {\n  if (dp[i] == check) {\n    answer[check] = arr[i];\n    check--;\n  }\n}\n\n// DP에 저장된 값 중 최댓값 + 1이 LIS의 길이\nSystem.out.println(Arrays.toString(answer));\n```\n\n> 하지만 위와 같이 **DP를 활용하는 방식의 시간 복잡도**는 $O(N^2)$이다.\n\n이를 줄이는 좋은 방법은 **이분 탐색**을 활용하는 것이다.\n\n### 🪚 이분 탐색을 활용한 구현 및 시간 복잡도\nLIS를 구성할 때 이분 탐색을 활용한다. \n- LIS의 형태를 유지하기 위해 주어진 배열의 인덱스를 하나씩 살펴본다.\n- 해당 숫자가 들어갈 위치를 이분 탐색으로 탐색해 삽입한다.\n\n> 일반적으로 이분 탐색의 시간 복잡도는 $O(logN)$이다. 따라서 이를 이용해 시간 복잡도를 **$O(NlogN)$** 으로 줄일 수 있다.\n\n<img src=\"https://i.imgur.com/tPAmqre.png\" width=\"80%\">\n\n```java\nstatic int[] arr = {7, 2, 3, 8, 4, 5};\nstatic ArrayList<Integer> lis = new ArrayList<>();\n\npublic static void main(String[] args) {\n  lis.add(arr[0]);\n  int idx = 1;\n  int j = 0;\n\n  while(idx < arr.length) {\n    if (lis.get(j) < arr[idx]) {\n      lis.add(arr[idx]);\n      j++;\n    } else {\n      lis.remove(j);\n      lis.add(binarySearch(j, arr[idx]), arr[idx]);\n    }\n    idx++;\n  }\n\n  System.out.println(j + 1);\n  System.out.println(lis);\n}\n\nprivate static int binarySearch(int right, int target) {\n  // 항상 left는 시작점\n  int left = 0;\n  int mid;\n\n  while(left < right) {\n    mid = (left + right) / 2;\n\n    if (lis.get(left) < target) left = mid + 1;\n    else right = mid;\n  }\n\n  return right;\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog)\n- [알고리즘 - 최장 증가 부분 수열(LIS) 알고리즘](https://chanhuiseok.github.io/posts/algo-49/)"},{"excerpt":"🧷 해시 테이블 완전 탐색으로는 시간초과에 빠지게 되는 문제에서는 해시를 적용시켜 탐색 시간을 줄일 수 있다.  는 내부적으로 배열을 사용하여 데이터를 저장하여 작은 메모리로도 프로세스 관리가 가능해지고, 빠른 검색 속도를 갖는다. 고유의  로 접근하여 특정 값을 탐색하기에 평균적으로 이 된다. 충돌 현상으로 인해 \"평균적\"으로 이다. 문제는 이  로 저…","fields":{"slug":"/[Algorithm]HashTable/"},"frontmatter":{"date":"May 06, 2022","title":"💡 해시 테이블 (Hash Table)","tags":["개발상식","Java","Hash"]},"rawMarkdownBody":"\n## 🧷 해시 테이블\n> 완전 탐색으로는 시간초과에 빠지게 되는 문제에서는 해시를 적용시켜 탐색 시간을 줄일 수 있다.\n\n`Hash` 는 내부적으로 **배열**을 사용하여 데이터를 저장하여 작은 메모리로도 프로세스 관리가 가능해지고, 빠른 검색 속도를 갖는다. 고유의 `index` 로 접근하여 특정 값을 탐색하기에 평균적으로 $O(1)$이 된다.\n- **충돌 현상**으로 인해 \"평균적\"으로 $O(1)$이다.\n- 문제는 이 `index` 로 저장되는 `key` 값이 **불규칙**하다는 점이다.\n\n> **충돌 현상**\n> : 서로 다른 두 개의 `Key` 가 같은 `index` 로 해싱되어 같은 곳에 저장하려는 현상\n\n그래서 \"특별한 알고리즘\"을 사용하여 **저장할 데이터와 연관된 고유한 숫자**를 만들어 이를 `index` 로 사용한다.\n- `index` 는 그 데이터만의 고유한 위치이므로, 삽입이나 삭제 연산 시 추가적인 비용이 발생하지 않는다.\n- 여기서 특별한 알고리즘은 `Hash Method` or `Hash Function` 이라고 하고, 이 함수에 의해 반환된 데이터의 고유 숫자 값을 `Hash Code` 라고 한다.\n- 하지만, 잘못된 `Hash Function` 을 통해 충돌 현상이 발생하게 될 수 있다.\n  - 충돌 현상이 많아질수록, 탐색에 필요한 시간 복잡도는 $O(N)$에 가까워지게 된다.\n\n좋은 `Hash Function` 은 일반적으로, `Key` 의 일부분을 참조하여 해시 값을 만들지 않고, `Key` 전체를 참조하여 해시 값을 만든다.\n- 하지만 이는 `Key` 의 특성에 따라 달라지게 된다.\n\n`Hash Function` 을 무조건 1:1 매칭으로 만드는 것보다, **충돌 현상을 최소화하는 방향으로 이를 어떻게 대응할 것인가**가 더 중요하다.\n- 1:1 대응이 되도록 만드는 것은 거의 불가능하고, 가능하다해도 이는 곧 배열과 같기에 메모리 사용이 많아진다.\n\n### 🪚 충돌 현상 해결 방법\n아래 2가지 방법이 있고, 두 방법 모두 최악의 경우 $O(M)$의 시간 복잡도를 가진다.\n\n1. **Open Address 방식 (개방 주소법)**\n: 충돌 현상이 발생하면, (즉, 이미 해당 해시 버킷이 사용 중인 경우) **다른 해시 버킷에 삽입하려는 데이터를 삽입**하는 방식이다.\n   - 이때, 데이터를 저장하기 위해 비어 있는 다른 해시 버킷을 찾아 헤맨다. \n   - 최악의 경우, 비어 있는 해시 버킷을 찾지 못해 다시 탐색을 시작한 위치로 돌아올 수 있다. 이때 탐색하는 데도 아래 3가지 방법이 있다.\n     - **Linear Probing**: 순차적으로 탐색하는 방식\n       - Primary Clustering에 취약하다.\n     - **Quadratic Probing**: 2차 함수를 이용해 탐색할 위치를 찾는다. ($1^2$, $2^2$, $3^2$, ... 으로 탐색위치 증가)\n        - Secondary Clustering에 취약하다.\n     - **Double Hashing Probing**: 하나의 해시 함수에서 충돌이 발생하면 2차 해시 함수를 사용해 탐사 이동폭을 얻어 다른 버킷을 탐색한다.\n        - 두 취약점을 해결하지만, 가장 많은 연산을 요구한다.\n\n> **해시 버킷**?\n> : 데이터를 저장하기 위한 공간\n\n2. **Separate Chaining 방식 (분리 연결법)**\n: 일반적으로 Open Address방식은 Separate Chaining보다 느리다. Open Address의 경우 해시 버킷을 채운 밀도가 높아질수록 최악의 경우가 발생할 빈도가 높아지기 때문이다. 반면, Separate Chaining 방식은 보조 해시 함수를 사용해 잘 조정한다면 최악의 경우에 가까워지는 빈도를 줄일 수 있다. Separate Chaining 방식은 2가지 구현 방식이 있다.\n\n   - 연결 리스트를 사용하는 방식 (`Linked List`)\n       - 각각의 버킷을 연결 리스트로 만들어 충돌이 발생하면 해당 버킷의 list에 추가하는 방식이다.\n       - 연결 리스트의 장, 단점을 그대로 이어 받아, 삭제 또는 삽입이 간단하지만, 작은 데이터들을 저장할 때 연결 리스트 자체의 오버헤드가 발생한다.\n       - 버킷을 계속해서 사용하는 Open Address 방식에 비해 테이블의 확장을 늦출 수 있다는 특징이 있다.\n   - Tree를 사용하는 방식 (`Red-Black Tree`)\n       - 연결 리스트 대신 트리를 사용하는 방식으로, 연결 리스트를 사용할지, 트리를 사용할지 결정하는 기준은 하나의 해시 버킷에 할당된 `key-value` 쌍의 개수이다. \n       - 트리의 기본적인 메모리 사용량이 많기 때문에, 데이터의 개수가 적다면 연결 리스트를 사용하는 것이 효율적이다.\n         - 데이터의 개수가 적을 때, 성능상의 차이는 거의 없기에 메모리적으로 효율적인 연결 리스트를 사용하는 것이 좋다.\n\n> **Java 7에서는 Separate Chaining 방식을 사용해 `HashMap` 을 구현한다.**\n> - Open Addressing은 데이터 삭제 시, `remove()` 의 빈번한 호출로 인해 처리가 효율적이기 어렵다. \n> - 또한, 저장된 키-값 쌍의 개수가 일정 이상이면, Worst Case 발생 빈도가 더 높아져 Separate Chaining 방식보다 느리다.\n\n> **데이터가 적다는 것의 의미**\n> : 기준은 위에서 언급했듯 하나의 해시 버킷에 할당된 `key-value` 쌍의 개수이다. 연결 리스트의 기준과 트리의 기준은 6개와 8개로 나뉜다.\n> - 7이 없는 이유는, **자료구조를 변경하는 데 소모되는 비용을 줄이기 위함**이다.\n\n해시 버킷에 6개의 `key-value` 쌍이 있다고 가정해보자. 이때 하나의 값이 추가되어 총 쌍의 개수가 7개가 되었다. 만약, 기준이 6, 7이었다면, 값이 추가되면서 자료구조를 트리로 변경해야 한다. 그리고 다시 하나의 값이 삭제된다면, 다시 트리에서 연결 리스트로 자료구조를 변경해야 한다. \n- 즉, 기준이 1 차이가 난다면, 자료구조를 변경하는 `Switching` 비용이 너무 많이 필요하게 된다. \n- 따라서, 기준을 2만큼의 차이를 두었다.\n- 결과적으로, 쌍의 개수가 6개 -> 7개로 변경된다면 연결 리스트 구조를 유지할 것이고, 8개 -> 7개로 변경된다면 트리 구조를 유지할 것이다.\n\n> **보조 해시 함수**\n> : `key` 의 해시 값을 변형하여 해시 충돌 가능성을 줄이기 위해 사용한다. Separate Chaining 방식 사용 시, 함께 사용되며 최악의 경우에 가까워지지 않도록 한다.\n\n### 🪚 해시 버킷 동적 확장 (Resize)\n해시 버킷의 개수가 적다면 메모리 사용을 아낄 수 있지만 해시 충돌로 인해 성능 상 손실이 발생한다.\n- 그래서 `HashMap` 은 `key-value` 쌍의 개수가 일정 이상이 되면, 해시 버킷의 개수를 두 배로 늘린다. 개수를 늘림으로써, 충돌로 인한 성능 손실 문제를 어느 정도 해결할 수 있다.\n  - 여기서 일정 이상의 의미는 현재 데이터의 개수가 해시 버킷의 개수의 **75%** 가 될 때이다. \n  - `0.75` 라는 숫자는 **load factor**로 불린다.\n\n### 🪚 예제 문제\n[문제 링크](https://codeforces.com/contest/4/problem/C?f0a28=1)\n\nN(1 ~ 100000)의 값만큼 문자열이 입력된다. 처음 입력되는 문자열은 \"OK\", 들어온 적이 있던 문자열은 \"문자열 + index\"로 출력한다.\n\n```java\n// input\n5\nabcd\nbac\nabcd\nabcd\nab\n\n// output\nOK\nOK\nabcd1\nabcd2\nOK\n```\n\n- N값은 최대 10만이므로, 이를 완전 탐색으로 해결한다면 $O(N^2)$의 시간복잡도를 가져, 100억번의 연산이 필요하다. 이는 곧바로 시간초과로 이어질 것이다.\n- 따라서 **해시 테이블**을 이용해 해결해야 한다. \n  - 입력된 문자열 값을 해시 키로 변환시켜 저장하면서 진행한다.\n\n```java\npublic class Solution {\n  static final int HASH_SIZE = 1000;\n  static final int HASH_LEN = 400;\n  static final int HASH_VAL = 17; // 소수로 할 것, 주로 17, 19, 23\n  static String str;\n  static int N;\n\t\n  static int[][] data = new int[HASH_SIZE][HASH_LEN];\n  static int[] length = new int[HASH_SIZE];\n  static String[][] s_data = new String[HASH_SIZE][HASH_LEN];\n\n  public static void main(String[] args) throws Exception {\n    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n    StringBuilder sb = new StringBuilder();\n\t\t\n    N = Integer.parseInt(br.readLine()); // 입력 수 (1 ~ 100000)\n\t\t\n    for (int i = 0; i < N; i++) {\n      str = br.readLine();\n\t\t\t\n      // 입력 문자열로부터 키 값을 생성\n      int key = getHashKey(str);\n\n      // 해당 키 값이 이미 존재하는지 확인\n      int cnt = checking(key);\n\n      // 이미 들어왔던 문자열\n      if(cnt != -1)\tsb.append(str).append(cnt).append(\"\\n\");\n      else sb.append(\"OK\").append(\"\\n\");\n      }\n\t\t\n    System.out.println(sb.toString());\n  }\n  \n  public static int getHashKey(String str) {\t\t\n    int key = 0;\n\t\t\n    // 키 값 생성 (HASH_VAL 사용)\n    for (int i = 0; i < str.length(); i++)\n      key = (key * HASH_VAL) + str.charAt(i) + HASH_VAL;\n\n    // 키 값 양수로 변환\n    if(key < 0) key = -key; \n\t\t\n    return key % HASH_SIZE;\t\n  }\n\n  public static int checking(int key) {\t\n    // 현재 키에 담긴 수\n    int len = length[key]; \n\n    // 이미 들어온 적 있음\n    if(len != 0) {\n      // 이미 들어온 문자열이 해당 키 배열에 있는지 확인\n      for (int i = 0; i < len; i++) { \n        if(str.equals(s_data[key][i])) {\n          // 있다면 들어온 수를 반환\n          data[key][i]++;\n          return data[key][i];\n        }\n      }\n    }\n    \n    // 들어온 적이 없었으면 해당 키 배열에 문자열을 저장하고 길이 1 늘리기\n    s_data[key][length[key]++] = str;\n    \n    // 들어온 적 없었다면 -1 반환\n    return -1;\n  }\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/algorithm/Bubble%20Sort.html)\n- [JaeYeopHan/Interview_Question_for_Beginner](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/DataStructure#hash-table)\n- [해싱, 해시함수, 해시테이블](https://ratsgo.github.io/data%20structure&algorithm/2017/10/25/hash/)"},{"excerpt":"문제 Programmers - 미로 탈출 📍 Logic 최소 비용을 구하기 위해 우선순위 큐를 사용하는데, 가중치를 기준으로 오름차순 정렬을 위해  를 오버라이딩한다. 다익스트라 알고리즘을 사용하여 트랩 여부에 따라  를 지정하고, 정방향 탐색과 역방향 탐색을 수행한다. 정방향 탐색의 경우,  다음 방문할 노드의 트랩 여부를 확인하고,   트랩인 경우, …","fields":{"slug":"/[Programmers]81304/"},"frontmatter":{"date":"May 06, 2022","title":"👩‍💻 81304. 미로 탈출","tags":["다익스트라","우선순위큐","비트마스킹"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 미로 탈출](https://programmers.co.kr/learn/courses/30/lessons/81304)\n\n### 📍 **Logic**\n\n```java\nclass Node implements Comparable<Node> {\n    int to;\n    int weight;\n    int status;\n\n    public Node(int to, int weight, int status) {\n        this.to = to;\n        this.weight = weight;\n        this.status = status;\n    }\n\n    // 오름차순 정렬을 위함, 여러 경로 중 최소 비용을 먼저 탐색하기 위함\n    @Override\n    public int compareTo(Node n) {\n        return this.weight - n.weight;\n    }\n}\n```\n\n- 최소 비용을 구하기 위해 **우선순위 큐**를 사용하는데, 가중치를 기준으로 오름차순 정렬을 위해 `compareTo()` 를 오버라이딩한다.\n\n```java\nprivate void dijkstra(int s, int e) {\n    queue = new PriorityQueue<>();\n    dist[s][0] = 0;\n    queue.add(new Node(s, 0, 0));\n\n    while(!queue.isEmpty()) {\n        Node node = queue.poll();\n        int to = node.to;\n        int weight = node.weight;\n        int status = node.status;\n\n        if (to == e) return;\n\n        // 이동하려는 노드가 트랩인지 확인하고, 트랩이라면 이미 밟은 트랩인지 확인\n        // f = 0, 밟지 않은 트랩이거나 일반 노드 / f = 1, 이미 밟은 트랩\n        int f = 0;\n        if (trapMap.containsKey(to)) {\n            if ((status & trapMap.get(to)) != 0)\n                f = 1;\n        }\n\n        forward(to, weight, status, f);\n        backward(to, weight, status, f);\n    }\n}\n```\n\n- 다익스트라 알고리즘을 사용하여 트랩 여부에 따라 `f` 를 지정하고, 정방향 탐색과 역방향 탐색을 수행한다.\n\n```java\nprivate void forward(int to, int weight, int status, int f) {\n    for (Node next : orgList[to]) {\n        canForward = f;\n        int nStatus = status;\n        if (trapMap.containsKey(next.to)) {\n            if ((status & trapMap.get(next.to)) != 0)\n                canForward ^= 1;\n            nStatus ^= trapMap.get(next.to);\n        }\n\n        if (canForward != 0) continue;\n        if (dist[next.to][status] > weight + next.weight) {\n            dist[next.to][status] = weight + next.weight;\n            queue.add(new Node(next.to, dist[next.to][status], nStatus));\n        }\n    }\n}\n```\n\n- 정방향 탐색의 경우, \n  - 다음 방문할 노드의 트랩 여부를 확인하고,  \n  - 트랩인 경우, 트랩의 발동 여부를 확인한다.\n  - `canForward` 가 `0` 인 경우(즉, 트랩이지만 활성화 되지 않았거나 일반 노드인 경우)만 `queue` 에 해당 지점을 추가한다.\n  - 0인 경우: (f:canForward = 0:0 or 1:1)\n- 역방향은 반대\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Node implements Comparable<Node> {\n        int to;\n        int weight;\n        int status;\n\n        public Node(int to, int weight, int status) {\n            this.to = to;\n            this.weight = weight;\n            this.status = status;\n        }\n\n        // 오름차순 정렬을 위함, 여러 경로 중 최소 비용을 먼저 탐색하기 위함\n        @Override\n        public int compareTo(Node n) {\n            return this.weight - n.weight;\n        }\n    }\n\n    class Maze {\n        List<Node>[] orgList;\n        List<Node>[] reverseList;\n        Map<Integer, Integer> trapMap;\n        Queue<Node> queue;\n        int[][] dist;\n        int canForward = 0;\n\n        public Maze(int n, int[][] roads, int[] traps) {\n            // List 초기화\n            orgList = new ArrayList[n + 1];\n            reverseList = new ArrayList[n + 1];\n            initList(n);\n            fillList(roads);\n\n            // 트랩 초기화(좌표 압축을 통해 2,5,10 -> 1,2,3으로 저장)\n            trapMap = new HashMap<>();\n            initTrap(traps);\n\n            dist = new int[n+1][1<<trapMap.size()+1];\n            initDist(n);\n        }\n\n        private void initList(int n) {\n            for (int i = 0; i < n + 1; i++) {\n                orgList[i] = new ArrayList<>();\n                reverseList[i] =new ArrayList<>();\n            }\n        }\n\n        // 초기 경로와, 트랩으로 인해 반대로 전환되는 경로를 저장\n        private void fillList(int[][] roads) {\n            for (int[] road : roads) {\n                int from = road[0];\n                int to = road[1];\n                int weight = road[2];\n\n                orgList[from].add(new Node(to, weight, 0));\n                reverseList[to].add(new Node(from, weight, 0));\n            }\n        }\n\n        // 좌표 압축\n        private void initTrap(int[] traps) {\n            for (int i = 0; i < traps.length; i++)\n                trapMap.put(traps[i], 1 << (i + 1));\n        }\n\n        private void initDist(int n) {\n            for (int i = 0; i < n + 1; i++) Arrays.fill(dist[i], Integer.MAX_VALUE);\n        }\n\n        public int solution(int start, int end) {\n            dijkstra(start, end);\n\n            int minCost = Integer.MAX_VALUE;\n            for (int d : dist[end])\n                minCost = Math.min(minCost, d);\n\n            return minCost;\n        }\n\n        private void dijkstra(int s, int e) {\n            queue = new PriorityQueue<>();\n            dist[s][0] = 0;\n            queue.add(new Node(s, 0, 0));\n\n            while(!queue.isEmpty()) {\n                Node node = queue.poll();\n                int to = node.to;\n                int weight = node.weight;\n                int status = node.status;\n\n                if (to == e) return;\n\n                // 이동하려는 노드가 트랩인지 확인하고, 트랩이라면 이미 밟은 트랩인지 확인\n                // f = 0, 밟지 않은 트랩이거나 일반 노드 / f = 1, 이미 밟은 트랩\n                int f = 0;\n                if (trapMap.containsKey(to)) {\n                    if ((status & trapMap.get(to)) != 0)\n                        f = 1;\n                }\n\n                forward(to, weight, status, f);\n                backward(to, weight, status, f);\n            }\n        }\n\n        // orgList = 정방향에 대한 탐색\n        private void forward(int to, int weight, int status, int f) {\n            for (Node next : orgList[to]) {\n                canForward = f;\n                int nStatus = status;\n                if (trapMap.containsKey(next.to)) {\n                    if ((status & trapMap.get(next.to)) != 0)\n                        canForward ^= 1;\n                    nStatus ^= trapMap.get(next.to);\n                }\n\n                if (canForward != 0) continue;\n                if (dist[next.to][status] > weight + next.weight) {\n                    dist[next.to][status] = weight + next.weight;\n                    queue.add(new Node(next.to, dist[next.to][status], nStatus));\n                }\n            }\n        }\n\n        // reverseList = 역방향에 대한 탐색\n        private void backward(int to, int weight, int status, int f) {\n            for (Node next : reverseList[to]) {\n                canForward = f;\n                int nStatus = status;\n                if (trapMap.containsKey(next.to)) {\n                    if ((status & trapMap.get(next.to)) != 0)\n                        canForward ^= 1;\n                    nStatus ^= trapMap.get(next.to);\n                }\n\n                if (canForward != 1) continue;\n                if (dist[next.to][status] > weight + next.weight) {\n                    dist[next.to][status] = weight + next.weight;\n                    queue.add(new Node(next.to, dist[next.to][status], nStatus));\n                }\n            }\n        }\n    }\n\n    class Solution {\n        public int solution(int n, int start, int end, int[][] roads, int[] traps) {\n            Maze m = new Maze(n, roads, traps);\n\n            return m.solution(start, end);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 시작지점부터 종료지점까지의 탐색을 위한 그래프 탐색 알고리즘과, 트랩을 방문한 경우 연결된 길을 `Switching` 해주는 알고리즘이 필요했다.\n- 그래프 탐색은 DFS나 BFS를 사용할 수 있지만, 연결된 길에 대한 `Switching` 은 어떻게 해야할 지 감이 오지 않았다. 길의 비용은 고정적이지만, 방향만 바꿔줘야 했다.\n- 참고 블로그를 보면서 이해하는데, \"기본적인 로직은 최단 경로를 찾는 것이다. 또한 조건상 두 지점 간 여러 길이 존재할 수 있고, 길마다의 가중치가 있기에, 그래서 똑같은 경로라 하더라도 작은 가중치를 가진 간선을 위주로 탐색을 해야하므로 우선순위 큐를 사용한 다익스트라가 문제의 본질임을 알아낼 수 있다.\" 이러한 생각을 할 수 있도록 노력해야 겠다.\n- 비트마스킹을 사용한 풀이를 참고했는데, 코드를 보고 봐도 이해가 어려운 것 같다. 자주 사용해보지 않은 알고리즘이이서 그런 것 같다. 비트마스킹을 사용하는 기본 예제를 풀어봐야겠다.\n\n### 📕 **참고**\n[[프로그래머스] 2021 카카오 인턴 #4 미로 탈출 (Java)](https://loosie.tistory.com/341)"},{"excerpt":"문제 Programmers - 시험장 나누기 📍 Logic 주어진 트리에서 각 그룹의 수를 x명으로 제한할 때 필요한 그룹의 수를 계산해야 한다. 각 그룹의 수를 x명으로 제한할 때 필요한 그룹의 수를 계산하기 위해 그리디를 사용하여 최대한 그룹 생성을 미루면서 위로 올려보낸다. 부모 노드에서 자식 노드를 더 이상 감당할 수 없는 경우, 값이 더 작은 노…","fields":{"slug":"/[Programmers]81305/"},"frontmatter":{"date":"May 06, 2022","title":"👩‍💻 81305. 시험장 나누기","tags":["ParametricSearch","DFS","이분탐색"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 시험장 나누기](https://programmers.co.kr/learn/courses/30/lessons/81305)\n\n### 📍 **Logic**\n\n```java\nprivate int dfs(int cur, int limit) {\n    // 왼쪽과 오른쪽 자식 트리에서 넘어오는 인원 수\n    int leftValue = 0, rightValue = 0;\n    if (left[cur] != -1) leftValue = dfs(left[cur], limit);\n    if (right[cur] != -1) rightValue = dfs(right[cur], limit);\n    \n    // 두 자식 트리에서 넘어오는 인원을 모두 감당할 수 있는 경우, 그룹 수는 증가하지 않음\n    if (x[cur] + leftValue + rightValue <= limit) \n        return x[cur] + leftValue + rightValue;\n    \n    // 두 자식 트리 중 작은 값을 합쳐야 감당할 수 있는 경우, 즉 자식 노드 하나를 끊는 경우로 그룹이 1개 추가\n    if (x[cur] + Math.min(leftValue, rightValue) <= limit) {\n        count++;\n        return x[cur] + Math.min(leftValue, rightValue);\n    }\n    \n    // 두 자식 트리 모두 감당할 수 없어서 둘 다 끊는 경우, 그룹이 2개 추가\n    count += 2;\n    return x[cur];\n}\n```\n\n- 주어진 트리에서 각 그룹의 수를 x명으로 제한할 때 필요한 그룹의 수를 계산해야 한다.\n- 각 그룹의 수를 x명으로 제한할 때 필요한 그룹의 수를 계산하기 위해 그리디를 사용하여 최대한 그룹 생성을 미루면서 위로 올려보낸다.\n  - 부모 노드에서 자식 노드를 더 이상 감당할 수 없는 경우, 값이 더 작은 노드를 챙기고 다른 노드를 잘라낸다.\n- 그룹으로 나눌 때 아래 3가지 경우가 존재한다.\n  - 부모 노드가 자식 노드 모두 챙기기 : 그룹 + 0, 세 노드의 합을 더 부모 노드로 전달\n  - 자식 노드 중 1개와 부모 노드를 챙기기 : 그룹 + 1, 자식 노드 중 최솟값 + 부모 노드의 값을 더 부모 노드로 전달\n  - 자식 노드를 하나도 챙기지 않기 : 그룹 + 2, 부모 노드의 값만 더 부모 노드로 전달\n- DFS를 통해 리프 노드부터 값을 위로 올려보내는 작업을 반복한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class ExamRoom {\n        int n;\n        int root;\n        int count = 0;\n        int[] left;\n        int[] right;\n        int[] x; // 시험장의 응시 인원\n        int[] parent;\n        \n        public ExamRoom(int[] num, int[][] links) {\n            this.n = num.length;\n            parent = new int[n];\n            left = new int[n];\n            right = new int[n];\n            x = new int[n];\n            Arrays.fill(parent, -1);\n            \n            init(num, links);\n            setRoot();\n        }\n        \n        private void init(int[] num, int[][] links) {\n            for (int i = 0; i < n; i++) {\n                int l1 = links[i][0];\n                int l2 = links[i][1];\n                \n                // 자식 지정\n                left[i] = l1;\n                right[i] = l2;\n                x[i] = num[i];\n                \n                // 부모 지정\n                if (l1 != -1) parent[left[i]] = i;\n                if (l2 != -1) parent[right[i]] = i;\n            }\n        }\n        \n        // parent[i]가 -1이라면 root\n        private void setRoot() {\n            for (int i = 0; i < n; i++) {\n                if (parent[i] == -1) {\n                    root = i;\n                    return;\n                }\n            }\n        }\n        \n        public int getAnswer(int k) {\n            // start는 num의 최댓값\n            int start = x[0];\n            for (int i : x)\n                start = Math.max(start, i);\n\n            // end는 num의 최댓값 * num의 길이\n            int end = start * n;\n            while(start < end) {\n                int mid = (start + end) / 2;\n                if (solve(mid) <= k) end = mid;\n                else start = mid + 1;\n            }\n            \n            return start;\n        }\n        \n        private int solve(int limit) {\n            count = 0;\n            dfs(root, limit);\n            // 맨 마지막에 남은 인원들에 대한 그룹 하나 추가\n            return count + 1;\n        }\n        \n        private int dfs(int cur, int limit) {\n            // 왼쪽과 오른쪽 자식 트리에서 넘어오는 인원 수\n            int leftValue = 0, rightValue = 0;\n            if (left[cur] != -1) leftValue = dfs(left[cur], limit);\n            if (right[cur] != -1) rightValue = dfs(right[cur], limit);\n            \n            // 두 자식 트리에서 넘어오는 인원을 모두 감당할 수 있는 경우, 그룹 수는 증가하지 않음\n            if (x[cur] + leftValue + rightValue <= limit) \n                return x[cur] + leftValue + rightValue;\n            \n            // 두 자식 트리 중 작은 값을 합쳐야 감당할 수 있는 경우, 즉 자식 노드 하나를 끊는 경우로 그룹이 1개 추가\n            if (x[cur] + Math.min(leftValue, rightValue) <= limit) {\n                count++;\n                return x[cur] + Math.min(leftValue, rightValue);\n            }\n            \n            // 두 자식 트리 모두 감당할 수 없어서 둘 다 끊는 경우, 그룹이 2개 추가\n            count += 2;\n            return x[cur];\n        }\n    }\n\n    class Solution {\n        public int solution(int k, int[] num, int[][] links) {\n            ExamRoom er = new ExamRoom(num, links);\n            \n            return er.getAnswer(k);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음 보는 알고리즘을 사용하는 문제여서 참고를 찬찬히 읽어보면서 이해하려고 했다.\n- 각 그룹의 수를 x명으로 제한할 떄 그룹의 수가 k개 이하인지를 판단하는 결정 문제 즉, **Parametric Search**를 사용하는 문제를 처음 접한 것 같다... 문제를 다양하게 풀어볼 수 있어야 겠다.\n\n### 📕 **참고**\n[[프로그래머스] 시험장 나누기 / 2021 카카오 채용연계형 인턴십 - JAVA](https://blog.encrypted.gg/1003)"},{"excerpt":"🧷 이분 탐색 탐색 범위를 두 부분으로 분할하면서 찾는 방식 처음부터 끝까지 탐색하는 것보다 더 빠른 시간 복잡도를 가지는 방식 🪚 과정 가장 핵심은 정렬이 되어 있어야 한다는 점이다.  와  를 사용해  를 설정한다.  와 구하고자 하는 값을 비교한다. 구하고자 하는 값이 더 큰 경우,  더 작은 경우,   가 될 때까지 반복 탐색할 배열의 범위를 벗어…","fields":{"slug":"/[Algorithm]이분 탐색/"},"frontmatter":{"date":"May 05, 2022","title":"💡 이분 탐색(Binary Search)","tags":["개발상식","Java","이분탐색"]},"rawMarkdownBody":"\n## 🧷 이분 탐색\n탐색 범위를 두 부분으로 분할하면서 찾는 방식\n- 처음부터 끝까지 탐색하는 것보다 더 빠른 시간 복잡도를 가지는 방식\n\n```\n**시간 복잡도**\n전체 탐색: O(N)\n이분 탐색: O(logN)\n```\n\n### 🪚 과정\n가장 핵심은 **정렬이 되어 있어야 한다**는 점이다.\n- `left` 와 `right` 를 사용해 `mid` 를 설정한다.\n- `mid` 와 구하고자 하는 값을 비교한다.\n  - 구하고자 하는 값이 더 큰 경우, `left = mid + 1`\n  - 더 작은 경우, `right = mid - 1`\n- `left > right` 가 될 때까지 반복\n- 탐색할 배열의 범위를 벗어난다면, 구하고자 하는 값이 배열에 없음을 판단할 수 있다.\n\n```java\nint binarySearch(int[] numbers, int M) {\n  Arrays.sort(numbers);\n\n  int left = 0;\n  int right = numbers.length - 1;\n  int mid; \n\n  while (left < right) {\n    mid = (left + right) / 2;\n\n    if (numbers[mid] == M)\n      return mid;\n    else if (numbers[mid] < M) \n      left = mid + 1;\n    else \n      right = mid - 1;\n  }\n}\n```\n\n### 🪚 추가 예제\n이분 탐색은 정렬된 데이터에서 특정 값을 찾고자 할 때 빠른 시간 복잡도로 탐색이 가능하다는 장점이 있다. 이를 이용해 정수 N이 주어졌을 때, N의 제곱근을 구하는 코드를 작성해본다.\n- 1부터 주어진 정수까지의 단순 반복 및 확인으로 구할 수는 있지만 이는 $O(N)$의 시간 복잡도를 가진다. \n\n이를 이분 탐색을 사용하여 \"0부터 N까지의 자연수 중 N의 제곱근이 있는지 없는지\" 확인하는 코드로 변경한다. 즉, **0부터 N까지의 정렬된 자연수 중에서 특정 값을 찾고 있는 것**이다.\n\n```java\nint squareRootSearch(int M) {\n  int left = 0;\n  int right = M;\n  int num, squareNum; \n\n  while (left < right) {\n    num = (left + right) / 2;\n    squareNum = num * num;\n\n    if (squareNum == M)\n      return num;\n    else if (squareNum < M) \n      left = num + 1;\n    else \n      right = num - 1;\n  }\n}\n```\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/algorithm/Bubble%20Sort.html)\n- [이진 탐색(Binary Search) 알고리즘 개념 이해 및 추가 예제](https://cjh5414.github.io/binary-search/)"},{"excerpt":"문제 Programmers - 표 편집 📍 Logic 현재 node의 이전과 이후 node를 저장하기 위한 배열을 초기화한다.  과  으로  를 계속 최신화하고, 삭제 및 복구 시에는  와  배열을 업데이트하는 방식을 사용한다. 📄 CODE ✏️ Review 처음 구현은  와  을 이용했다. 실패한 테케가 너무 많았고, 효율성은 아예 돌아가지도 않았다. 요…","fields":{"slug":"/[Programmers]81303/"},"frontmatter":{"date":"May 04, 2022","title":"👩‍💻 81303. 표 편집","tags":["Stack","LinkedList"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 표 편집](https://programmers.co.kr/learn/courses/30/lessons/81303)\n\n### 📍 **Logic**\n\n```java\nprivate void init() {\n    for (int i = 0; i < n; i++) {\n        pre[i] = i - 1;\n        next[i] = i + 1;\n    }\n    next[n - 1] = -1;\n}\n```\n\n- 현재 node의 이전과 이후 node를 저장하기 위한 배열을 초기화한다.\n\n```java\npublic void delete() {\n    trash.push(new Node(now, pre[now], next[now]));\n    \n    // now의 pre와 next를 update함으로써 해당 node를 제거\n    if (pre[now] != -1) next[pre[now]] = next[now];\n    if (next[now] != -1) pre[next[now]] = pre[now];\n    \n    // 해당 위치는 원본과 달라지므로 X로 변경\n    sb.setCharAt(now, 'X');\n    \n    // now 이동\n    if(next[now] != -1) now = next[now];\n    else now = pre[now];\n}\n\npublic void undo() {\n    Node insert = trash.pop();\n    \n    // 다시 추가할 insert node의 pre와 next를 update함으로써 해당 node를 추가\n    if (insert.before != -1) next[insert.before] = insert.cur;\n    if (insert.after != -1) pre[insert.after] = insert.cur;\n    \n    // 원상복구\n    sb.setCharAt(insert.cur, 'O');\n}\n```\n\n- `goUp()` 과 `goDown()` 으로 `now` 를 계속 최신화하고, 삭제 및 복구 시에는 `pre` 와 `next` 배열을 업데이트하는 방식을 사용한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Node {\n        int cur;\n        int before;\n        int after;\n\n        public Node(int cur, int before, int after) {\n            this.cur = cur;\n            this.before = before;\n            this.after = after;\n        }\n    }\n    class Table {\n        StringBuilder sb;\n        Stack<Node> trash = new Stack<>();\n\n        // 현재 node의 이전과 이후 node를 저장할 배열\n        int[] pre;\n        int[] next;\n        int n;\n        int now;\n\n        public Table(int n, int now) {\n            this.n = n;\n            this.now = now;\n            pre = new int[n];\n            next = new int[n];\n            sb = new StringBuilder(\"O\".repeat(n));\n\n            init();\n        }\n\n        private void init() {\n            for (int i = 0; i < n; i++) {\n                pre[i] = i - 1;\n                next[i] = i + 1;\n            }\n            next[n - 1] = -1;\n        }\n\n        // 중간에 삭제된 node가 있을 수 있기에 n만큼 반복하면서 now 이동\n        public void goUp(int n) {\n            while(n-- > 0) now = pre[now];\n        }\n\n        public void goDown(int n) {\n            while(n-- > 0) now = next[now];\n        }\n\n        public void delete() {\n            trash.push(new Node(now, pre[now], next[now]));\n            \n            // now의 pre와 next를 update함으로써 해당 node를 제거\n            if (pre[now] != -1) next[pre[now]] = next[now];\n            if (next[now] != -1) pre[next[now]] = pre[now];\n            \n            // 해당 위치는 원본과 달라지므로 X로 변경\n            sb.setCharAt(now, 'X');\n            \n            // now 이동\n            if(next[now] != -1) now = next[now];\n            else now = pre[now];\n        }\n\n        public void undo() {\n            Node insert = trash.pop();\n            \n            // 다시 추가할 insert node의 pre와 next를 update함으로써 해당 node를 추가\n            if (insert.before != -1) next[insert.before] = insert.cur;\n            if (insert.after != -1) pre[insert.after] = insert.cur;\n            \n            // 원상복구\n            sb.setCharAt(insert.cur, 'O');\n        }\n\n        public String print() {\n            return sb.toString();\n        }\n    }\n\n    class Solution {\n        public String solution(int n, int k, String[] cmd) {\n            Table t = new Table(n, k);\n\n            for (String c : cmd) {\n                switch (c.charAt(0)) {\n                    case 'U' -> t.goUp(Integer.parseInt(c.substring(2)));\n                    case 'D' -> t.goDown(Integer.parseInt(c.substring(2)));\n                    case 'C' -> t.delete();\n                    case 'Z' -> t.undo();\n                }\n            }\n\n            // 최종적으로 표를 비교하여 answer를 완성하는 method\n            return t.print();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음 구현은 `List` 와 `Stack` 을 이용했다. 실패한 테케가 너무 많았고, 효율성은 아예 돌아가지도 않았다.\n- 요소의 삽입과 삭제가 자주 일어나기에, 이에 적합한 자료구조가 필요한 것 같았다. 이에는 `LinkedList` 가 적합해보였다.\n- 생각보다 쉬워보였으나, 구현할수록 꼼꼼히 생각해야 할 구현부들이 생겨나, [참고](https://moonsbeen.tistory.com/294)가 필요했다..."},{"excerpt":"문제 Programmers - 거리두기 확인하기 📍 Logic 응시자의 위치부터 BFS를 시작한다. 다음 방문할 지점이 이미 방문했거나, 범위를 벗어난 경우는 다음 지점을 탐색하고, 거리가 2보다 큰 경우는 더 이상 확인하지 않아도 거리두기가 지켜진 경우이므로, 다음 지점을 탐색하고, 2 이하의 거리에 다른 응시자가 있다면, 거리두기가 지켜지지 않은 것으…","fields":{"slug":"/[Programmers]81302/"},"frontmatter":{"date":"May 03, 2022","title":"👩‍💻 81302. 거리두기 확인하기","tags":["BFS"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 거리두기 확인하기](https://programmers.co.kr/learn/courses/30/lessons/81302)\n\n### 📍 **Logic**\n\n```java\nprivate int bfs(int x, int y) {\n    Queue<Loc> queue = new LinkedList<>();\n    boolean[][] visited = new boolean[5][5];\n    int keep = 1;\n    visited[x][y] = true;\n    queue.add(new Loc(x, y, 0));\n\n    while(!queue.isEmpty()) {\n        Loc now = queue.poll();\n\n        for (int i = 0; i < 4; i++) {\n            int nx = now.x + rangeX[i];\n            int ny = now.y + rangeY[i];\n            if (!isIn(nx, ny)) continue;\n            if (visited[nx][ny]) continue;\n            \n            int nDist = now.dist + 1;\n            if (nDist > 2) continue;\n\n            char nP = place[nx].charAt(ny);\n            if (nP == 'P') return 0;\n            if (nP == 'X') continue;\n\n            visited[nx][ny] = true;\n            queue.add(new Loc(nx, ny, nDist));\n        }\n    }\n\n    return keep;\n}\n```\n\n- 응시자의 위치부터 BFS를 시작한다.\n  - 다음 방문할 지점이 이미 방문했거나, 범위를 벗어난 경우는 다음 지점을 탐색하고,\n  - 거리가 2보다 큰 경우는 더 이상 확인하지 않아도 거리두기가 지켜진 경우이므로, 다음 지점을 탐색하고,\n  - 2 이하의 거리에 다른 응시자가 있다면, 거리두기가 지켜지지 않은 것으로, 바로 반환한다.\n  - 또한 파티션이 존재한다면, 더 이상 확인하지 않아도 거리두기가 지켜진 경우이므로, 다음 지점을 탐색한다.\n  - 그렇지 않은 경우에만 해당 지점의 방문 여부를 update하고 큐에 넣는다. 이때, 거리를 1씩 증가한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Loc {\n        int x;\n        int y;\n        int dist;\n        \n        public Loc(int x, int y, int dist) {\n            this.x = x;\n            this.y = y;\n            this.dist = dist;\n        }\n    }\n\n    class WaitingRoom {\n        String[] place;\n        int[] rangeX = { 0, 1, 0, -1 };\n        int[] rangeY = { 1, 0, -1, 0 };\n        \n        public WaitingRoom(String[] place) {\n            this.place = place;\n        }\n        \n        public int checkKeepingDistance() {\n            for (int i = 0; i < 5; i++) {\n                for (int j = 0; j < 5; j++) {\n                    char p = place[i].charAt(j);\n                    if (p == 'P') \n                        if (bfs(i, j) == 0) \n                            return 0;\n                }\n            }\n            return 1;\n        }\n        \n        private int bfs(int x, int y) {\n            Queue<Loc> queue = new LinkedList<>();\n            boolean[][] visited = new boolean[5][5];\n            int keep = 1;\n            visited[x][y] = true;\n            queue.add(new Loc(x, y, 0));\n\n            while(!queue.isEmpty()) {\n                Loc now = queue.poll();\n\n                for (int i = 0; i < 4; i++) {\n                    int nx = now.x + rangeX[i];\n                    int ny = now.y + rangeY[i];\n                    if (!isIn(nx, ny)) continue;\n                    if (visited[nx][ny]) continue;\n                    \n                    int nDist = now.dist + 1;\n                    if (nDist > 2) continue;\n\n                    char nP = place[nx].charAt(ny);\n                    if (nP == 'P') return 0;\n                    if (nP == 'X') continue;\n\n                    visited[nx][ny] = true;\n                    queue.add(new Loc(nx, ny, nDist));\n                }\n            }\n\n            return keep;\n        }\n        \n        private boolean isIn(int x, int y) {\n            return (x < 5 && x >= 0 && y < 5 && y >= 0);\n        }\n    }\n\n    class Solution {\n        public int[] solution(String[][] places) {\n            int[] answer = new int[5];\n            int T = 0;\n            \n            while (T < 5) {\n                WaitingRoom wr = new WaitingRoom(places[T]);\n                answer[T++] = wr.checkKeepingDistance();\n            }\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 DFS 방식으로 구현했으나, 몇몇 테케에서 틀렸고, 단순히 탐색 방식의 차이니까 BFS로 구현해도 동일할 것이라 생각했다.\n  - 그래프 탐색 방식의 문제가 아닌, 반환 값의 반환 조건에 대한 문제였다.\n- 다음 방문 지점에 대해 맨해튼 거리를 구해보고, 2 이하인지 확인하는 방식에서 현재 지점에서 다음 지점으로 이동할 때마다 `dist` 를 1씩 증가시키고 그 값을 함께 전달해주는 방식으로 변경하여 시간을 줄일 수 있었다.\n"},{"excerpt":"문제 Programmers - 동굴 탐험 📍 Logic Stack을 이용한 DFS를 수행한다. 0번 방에서 갈 수 있는 방들을 stack에 넣는다. 방문하지 않은 방에 대해,  우선 방문해야 하는 방을 방문하지 않은 경우, 이후 방문해야 하는 방들을 저장하는  에 현재 방을 저장한다. 방문한 경우, 현재 방의 방문 여부를 최신화하고, 현재 방에서 갈 수 …","fields":{"slug":"/[Programmers]67260/"},"frontmatter":{"date":"April 30, 2022","title":"👩‍💻 67260. 동굴 탐험","tags":["DFS","Stack"]},"rawMarkdownBody":"\n## 문제\n[Programmers - 동굴 탐험](https://programmers.co.kr/learn/courses/30/lessons/67260)\n\n### 📍 **Logic**\n\n```java\nprivate void dfs() {\n    Stack<Integer> stack = new Stack<>();\n    stack.push(0);\n    visited[0] = true;\n\n    for (int next : adjList.get(0)) stack.push(next);\n    \n    while(!stack.empty()) {\n        int now = stack.pop();\n        if (visited[now]) continue;\n        \n        // before 정보를 업데이트하지 않는 방들은 모두 0번 방이 우선 방문되는 경우\n        if (!visited[before[now]]) {\n            after[before[now]] = now;\n            continue;\n        }\n        \n        visited[now] = true;\n        \n        for (int next : adjList.get(now))\n            if (!visited[next]) stack.push(next);\n\n        stack.push(after[now]);\n    }\n}\n```\n\n- Stack을 이용한 DFS를 수행한다.\n- 0번 방에서 갈 수 있는 방들을 stack에 넣는다.\n- 방문하지 않은 방에 대해, \n  - 우선 방문해야 하는 방을 방문하지 않은 경우, 이후 방문해야 하는 방들을 저장하는 `after` 에 현재 방을 저장한다.\n  - 방문한 경우, 현재 방의 방문 여부를 최신화하고, 현재 방에서 갈 수 있는 방들을 stack에 넣는다.\n- 이후 현재 방 이후에 방문해야 하는 방(`after[now]`)을 stack에 넣고, 반복한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        boolean[] visited;\n        int[] before;\n        int[] after;\n        ArrayList<ArrayList<Integer>> adjList = new ArrayList<>();\n        \n        public boolean solution(int n, int[][] path, int[][] order) {\n            visited = new boolean[n];\n            before = new int[n];\n            after = new int[n];\n            \n            // 방문 우선순위 저장\n            for (int[] or : order) before[or[1]] = or[0];\n            \n            for (int i = 0; i < n; i++) adjList.add(new ArrayList<>());\n            \n            // 인접 리스트 생성\n            for (int[] p : path) {\n                adjList.get(p[0]).add(p[1]);\n                adjList.get(p[1]).add(p[0]);\n            }\n            \n            // 0보다 먼저 방문해야 하는 방이 있다면 바로 false\n            if (before[0] != 0) return false;\n            \n            dfs();\n            \n            // 모든 방문 후, 방문하지 않은 방이 있다면 false\n            for (int i = 0; i < n; i++)\n                if (!visited[i]) return false;\n            return true;\n        }\n        \n        private void dfs() {\n            Stack<Integer> stack = new Stack<>();\n            stack.push(0);\n            visited[0] = true;\n\n            for (int next : adjList.get(0)) stack.push(next);\n            \n            while(!stack.empty()) {\n                int now = stack.pop();\n                if (visited[now]) continue;\n                \n                if (!visited[before[now]]) {\n                    after[before[now]] = now;\n                    continue;\n                }\n                \n                visited[now] = true;\n                \n                for (int next : adjList.get(now))\n                    if (!visited[next]) stack.push(next);\n\n                stack.push(after[now]);\n            }\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 위상 정렬 알고리즘을 떠올렸었는데, 방문했던 방도 다시 방문해야하는 경우가 있을 수 있어, 의미가 없다고 판단했다.\n- 역시나 마지막 문제답게, 난이도가 높았다. 인턴 코테 5솔은 그림의 떡이라는 생각이 들었다 ..\n"},{"excerpt":"문제 건설회사의 설계사인 죠르디는 고객사로부터 자동차 경주로 건설에 필요한 견적을 의뢰받았습니다.\n제공된 경주로 설계 도면에 따르면 경주로 부지는 N x N 크기의 정사각형 격자 형태이며 각 격자는 1 x 1 크기입니다.\n설계 도면에는 각 격자의 칸은 0 또는 1 로 채워져 있으며, 0은 칸이 비어 있음을 1은 해당 칸이 벽으로 채워져 있음을 나타냅니다.…","fields":{"slug":"/[Programmers]67259/"},"frontmatter":{"date":"April 30, 2022","title":"👩‍💻 67259. 경주로 건설","tags":["DFS"]},"rawMarkdownBody":"\n## 문제\n건설회사의 설계사인 죠르디는 고객사로부터 자동차 경주로 건설에 필요한 견적을 의뢰받았습니다.\n제공된 경주로 설계 도면에 따르면 경주로 부지는 N x N 크기의 정사각형 격자 형태이며 각 격자는 1 x 1 크기입니다.\n설계 도면에는 각 격자의 칸은 0 또는 1 로 채워져 있으며, 0은 칸이 비어 있음을 1은 해당 칸이 벽으로 채워져 있음을 나타냅니다.\n경주로의 출발점은 (0, 0) 칸(좌측 상단)이며, 도착점은 (N-1, N-1) 칸(우측 하단)입니다. 죠르디는 출발점인 (0, 0) 칸에서 출발한 자동차가 도착점인 (N-1, N-1) 칸까지 무사히 도달할 수 있게 중간에 끊기지 않도록 경주로를 건설해야 합니다.\n경주로는 상, 하, 좌, 우로 인접한 두 빈 칸을 연결하여 건설할 수 있으며, 벽이 있는 칸에는 경주로를 건설할 수 없습니다.\n이때, 인접한 두 빈 칸을 상하 또는 좌우로 연결한 경주로를 직선 도로 라고 합니다.\n또한 두 직선 도로가 서로 직각으로 만나는 지점을 코너 라고 부릅니다.\n건설 비용을 계산해 보니 직선 도로 하나를 만들 때는 100원이 소요되며, 코너를 하나 만들 때는 500원이 추가로 듭니다.\n죠르디는 견적서 작성을 위해 경주로를 건설하는 데 필요한 최소 비용을 계산해야 합니다.\n\n예를 들어, 아래 그림은 직선 도로 6개와 코너 4개로 구성된 임의의 경주로 예시이며, 건설 비용은 6 x 100 + 4 x 500 = 2600원 입니다.\n\n<img src=\"https://grepp-programmers.s3.ap-northeast-2.amazonaws.com/files/production/0e0911e8-f88e-44fe-8bdc-6856a56df8e0/kakao_road2.png\" width=\"60%\">\n\n또 다른 예로, 아래 그림은 직선 도로 4개와 코너 1개로 구성된 경주로이며, 건설 비용은 4 x 100 + 1 x 500 = 900원 입니다.\n\n<img src=\"https://grepp-programmers.s3.ap-northeast-2.amazonaws.com/files/production/3f5d9c5e-d7d9-4248-b111-140a0847e741/kakao_road3.png\" width=\"60%\">\n\n도면의 상태(0은 비어 있음, 1은 벽)을 나타내는 2차원 배열 board가 매개변수로 주어질 때, 경주로를 건설하는데 필요한 최소 비용을 return 하도록 solution 함수를 완성해주세요.\n\n### 제한사항\n- board는 2차원 정사각 배열로 배열의 크기는 3 이상 25 이하입니다.\n- board 배열의 각 원소의 값은 0 또는 1 입니다.\n  - 도면의 가장 왼쪽 상단 좌표는 (0, 0)이며, 가장 우측 하단 좌표는 (N-1, N-1) 입니다.\n  - 원소의 값 0은 칸이 비어 있어 도로 연결이 가능함을 1은 칸이 벽으로 채워져 있어 도로 연결이 불가능함을 나타냅니다.\n- board는 항상 출발점에서 도착점까지 경주로를 건설할 수 있는 형태로 주어집니다.\n- 출발점과 도착점 칸의 원소의 값은 항상 0으로 주어집니다.\n\n### 입출력 예\n|board|result|\n|:---:|:---:|\n|[0,0,0],[0,0,0],[0,0,0]|900|\n|[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,1,0,0,0],[0,0,0,1,0,0,0,1],[0,0,1,0,0,0,1,0],[0,1,0,0,0,1,0,0],[1,0,0,0,0,0,0,0]|3800|\n|[0,0,1,0],[0,0,0,0],[0,1,0,1],[1,0,0,0]|2100|\n|[0,0,0,0,0,0],[0,1,1,1,1,0],[0,0,1,0,0,0],[1,0,0,1,0,1],[0,1,0,0,0,1],[0,0,0,0,0,0]|3200|\n\n\n\n### 📍 **Logic**\n\n```java\nprivate void dfs(int[][] board, int prevDir, int x, int y) {\n    if (x == n - 1 && y == n - 1) {\n        minCost = Math.min(costs[x][y], minCost);\n        return;\n    }\n    \n    for (int i = 0; i < 4; i++) {\n        int nx = x + xDir[i];\n        int ny = y + yDir[i];\n        \n        if (nx == 0 && ny == 0) continue;\n        if (!checkBoundary(nx, ny)) continue;\n        if (board[nx][ny] == 1) continue;\n        \n        int tmp = costs[x][y];\n        if (prevDir != -1 && Math.abs(prevDir - i) % 2 == 1) \n            tmp += 500;\n        tmp += 100;\n            \n        if ((costs[nx][ny] != 0 && costs[nx][ny] >= tmp) || costs[nx][ny] == 0) {\n            costs[nx][ny] = tmp;\n            dfs(board, i, nx, ny);\n        }\n    }\n}\n```\n\n- `prevDir` 을 사용해 이전 방향을 저장하고, 직선인지 코너인지 판단한다.\n- 탐색 방향에 우선순위를 두고, 먼저 탐색한다.\n  - 비용이 더 작은 경우의 건설만을 update하도록 한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        int[] xDir = { 0, 1, 0, -1 };\n        int[] yDir = { 1, 0, -1, 0 };\n        int[][] costs;\n        int n;\n        int minCost = Integer.MAX_VALUE;\n        \n        public int solution(int[][] board) {\n            costs = new int[board.length][board.length];\n            n = board.length;\n            \n            dfs(board, -1, 0, 0);\n            \n            return minCost;\n        }\n        \n        private void dfs(int[][] board, int prevDir, int x, int y) {\n            if (x == n - 1 && y == n - 1) {\n                minCost = Math.min(costs[x][y], minCost);\n                return;\n            }\n            \n            for (int i = 0; i < 4; i++) {\n                int nx = x + xDir[i];\n                int ny = y + yDir[i];\n                \n                if (nx == 0 && ny == 0) continue;\n                if (!checkBoundary(nx, ny)) continue;\n                if (board[nx][ny] == 1) continue;\n                \n                int tmp = costs[x][y];\n                if (prevDir != -1 && Math.abs(prevDir - i) % 2 == 1) \n                    tmp += 500;\n                tmp += 100;\n                    \n                if ((costs[nx][ny] != 0 && costs[nx][ny] >= tmp) || costs[nx][ny] == 0) {\n                    costs[nx][ny] = tmp;\n                    dfs(board, i, nx, ny);\n                }\n            }\n        }\n        \n        private boolean checkBoundary(int x, int y) {\n            return (x < n && x >= 0 && y < n && y >= 0);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 생각 외로, 간단한 `DFS` 문제였다. 이전 방향을 DFS의 인자로 전달해주는 것이 중요했던 것 같다.\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/67259"},{"excerpt":"문제 개발자 출신으로 세계 최고의 갑부가 된 어피치는 스트레스를 받을 때면 이를 풀기 위해 오프라인 매장에 쇼핑을 하러 가곤 합니다.\n어피치는 쇼핑을 할 때면 매장 진열대의 특정 범위의 물건들을 모두 싹쓸이 구매하는 습관이 있습니다.\n어느 날 스트레스를 풀기 위해 보석 매장에 쇼핑을 하러 간 어피치는 이전처럼 진열대의 특정 범위의 보석을 모두 구매하되 특…","fields":{"slug":"/[Programmers]67258/"},"frontmatter":{"date":"April 29, 2022","title":"👩‍💻 67258. 보석 쇼핑","tags":["투 포인터"]},"rawMarkdownBody":"\n## 문제\n개발자 출신으로 세계 최고의 갑부가 된 어피치는 스트레스를 받을 때면 이를 풀기 위해 오프라인 매장에 쇼핑을 하러 가곤 합니다.\n어피치는 쇼핑을 할 때면 매장 진열대의 특정 범위의 물건들을 모두 싹쓸이 구매하는 습관이 있습니다.\n어느 날 스트레스를 풀기 위해 보석 매장에 쇼핑을 하러 간 어피치는 이전처럼 진열대의 특정 범위의 보석을 모두 구매하되 특별히 아래 목적을 달성하고 싶었습니다.\n진열된 모든 종류의 보석을 적어도 1개 이상 포함하는 가장 짧은 구간을 찾아서 구매\n\n예를 들어 아래 진열대는 4종류의 보석(RUBY, DIA, EMERALD, SAPPHIRE) 8개가 진열된 예시입니다.\n\n|진열대 번호|1|2|3|4|5|6|7|8|\n|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|\n|보석 이름|DIA|RUBY|RUBY|DIA|DIA|EMERALD|SAPPHIRE|DIA|\n\n진열대의 3번부터 7번까지 5개의 보석을 구매하면 모든 종류의 보석을 적어도 하나 이상씩 포함하게 됩니다.\n\n진열대의 3, 4, 6, 7번의 보석만 구매하는 것은 중간에 특정 구간(5번)이 빠지게 되므로 어피치의 쇼핑 습관에 맞지 않습니다.\n\n진열대 번호 순서대로 보석들의 이름이 저장된 배열 gems가 매개변수로 주어집니다. 이때 모든 보석을 하나 이상 포함하는 가장 짧은 구간을 찾아서 return 하도록 solution 함수를 완성해주세요.\n가장 짧은 구간의 시작 진열대 번호와 끝 진열대 번호를 차례대로 배열에 담아서 return 하도록 하며, 만약 가장 짧은 구간이 여러 개라면 시작 진열대 번호가 가장 작은 구간을 return 합니다.\n\n### 제한사항\n- gems 배열의 크기는 1 이상 100,000 이하입니다.\n  - gems 배열의 각 원소는 진열대에 나열된 보석을 나타냅니다.\n  - gems 배열에는 1번 진열대부터 진열대 번호 순서대로 보석이름이 차례대로 저장되어 있습니다.\n  - gems 배열의 각 원소는 길이가 1 이상 10 이하인 알파벳 대문자로만 구성된 문자열입니다.\n\n### 입출력 예\n|gems|return|\n|:---:|:---:|:---:|\n|[\"DIA\", \"RUBY\", \"RUBY\", \"DIA\", \"DIA\", \"EMERALD\", \"SAPPHIRE\", \"DIA\"]|[3, 7]|\n|[\"AA\", \"AB\", \"AC\", \"AA\", \"AC\"]|[1, 3]|\n|[\"XYZ\", \"XYZ\", \"XYZ\"]|[1, 1]|\n|[\"ZZZ\", \"YYY\", \"NNNN\", \"YYY\", \"BBB\"]|[1, 5]|\n\n\n\n### 📍 **Logic**\n\n```java\nwhile (true) {\n    // 아직 종류가 다 안 채워진 경우\n    if (gemTypes != gemMap.size()) {\n        if (right == gems.length) break;\n        else {\n            // 보석을 구매하는 경우로, Map에 개수를 증가시키면서 보석을 저장\n            gemMap.put(gems[right], gemMap.getOrDefault(gems[right], 0) + 1);\n            right++;\n        }\n    }\n\n    // 종류가 다 채워진 경우\n    if (gemTypes == gemMap.size()) {\n        // 이전까지 구한 구간의 길이와 비교하여 작다면 update\n        if (right - left < distance) {\n            distance = right - left;\n            start = left;\n            end = right;\n        }\n\n        // 구간 줄이기 위해 제일 앞 보석 1개 삭제\n        gemMap.put(gems[left], gemMap.get(gems[left]) - 1);\n\n        // 보석 개수가 0개이면 map에서 삭제\n        if (gemMap.get(gems[left]) == 0) gemMap.remove(gems[left]);\n\n        left++;\n    }\n}\n```\n\n- `left` , `right` 라는 포인터를 사용하여 보석 진열대를 탐색한다.\n- 보석 진열대에 놓인 모든 종류의 보석을 하나 이상 구매한 경우와, 그렇지 않은 경우로 나눈다.\n  - 다 채워지지 않은 경우는 구매한 보석의 개수 정보를 업데이트하면서 `Map` 에 저장하고,\n  - 다 채워진 경우는 최소 구간인지 확인하고 시작점부터 보석 개수를 하나씩 줄인다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        public int[] solution(String[] gems) {\n            // 보석의 위치를 저장할 Map\n            Map<String, Integer> gemMap = new HashMap<>();\n            // 진열대에 있는 보석을 중복 없이 저장한 Set\n            Set<String> gemSet = new HashSet<>(Arrays.asList(gems));\n\n            // 보석의 종류를 구하기 위해 Set 사용\n            int gemTypes = gemSet.size();\n\n            int distance = Integer.MAX_VALUE;\n            int start = 0, end = 0, left = 0, right = 0;\n\n            while (true) {\n                // 아직 종류가 다 안 채워진 경우\n                if (gemTypes != gemMap.size()) {\n                    if (right == gems.length) break;\n                    else {\n                        // 보석을 구매하는 경우로, Map에 개수를 증가시키면서 보석을 저장\n                        gemMap.put(gems[right], gemMap.getOrDefault(gems[right], 0) + 1);\n                        right++;\n                    }\n                }\n\n                // 종류가 다 채워진 경우\n                if (gemTypes == gemMap.size()) {\n                    // 이전까지 구한 구간의 길이와 비교하여 작다면 update\n                    if (right - left < distance) {\n                        distance = right - left;\n                        start = left;\n                        end = right;\n                    }\n\n                    // 구간 줄이기 위해 제일 앞 보석 1개 삭제\n                    gemMap.put(gems[left], gemMap.get(gems[left]) - 1);\n\n                    // 보석 개수가 0개이면 map에서 삭제\n                    if (gemMap.get(gems[left]) == 0) gemMap.remove(gems[left]);\n\n                    left++;\n                }\n            }\n            \n            return new int[] {start + 1, end};\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 투 포인터를 사용해야 하는 문제임은 바로 알 수 있었지만, 투 포인터를 사용하지 않고 각 보석들의 위치를 저장하고 이 위치 정보만을 사용해서 풀 방법은 없을까를 고민해보았다.\n- 투 포인터 알고리즘을 사용하는 가장 흔한 예가 부분 배열 합을 구하는 문제였는데, 이를 여기에 어떻게 접목시키는지 의문이었다.\n- 투 포인터 알고리즘이 고냥이 문제에도 사용되던데, 한 번 혼자 풀어봐야겠다...\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/67258"},{"excerpt":"😁 인적성 검사 및 코딩 테스트 합격 ..? 와 이거 뭐지 .. ??? 내가 합격이라고 ? 필기 전형을 붙어버렸다 ... 올해 첫 정식 지원에 바로 면접까지 갈 줄은 정말 꿈에도 몰랐다. 너무 기쁘기도 하지만, 예상치 못한 합격에 이제 발등에 불 떨어졌다. 남은 1주일 안에 면접 준비를 해야 한다 ... !! 😁 면접 후기 후 ... 첫 면접이 끝났다. …","fields":{"slug":"/[LGCNS] 1차 면접 후기/"},"frontmatter":{"date":"April 28, 2022","title":"💭 [LG CNS 신입_학사] IT Leadership Academy : 22년 상반기 신입 채용 1차 면접 후기","tags":["면접","후기"]},"rawMarkdownBody":"\n## 😁 인적성 검사 및 코딩 테스트 합격 ..?\n<img src=\"../../images/LGCNS/코테합격.png\" width=\"60%\">\n\n와 이거 뭐지 .. ???\n\n내가 합격이라고 ?\n\n필기 전형을 붙어버렸다 ... 올해 첫 정식 지원에 바로 면접까지 갈 줄은 정말 꿈에도 몰랐다. 너무 기쁘기도 하지만, 예상치 못한 합격에 이제 발등에 불 떨어졌다. 남은 1주일 안에 면접 준비를 해야 한다 ... !!\n\n## 😁 면접 후기\n후 ... 첫 면접이 끝났다.\n\n10시 40분부터 접속해서 대기하고 있다가 한 50분 넘어서 입장했다. 면접관 3분이 앉아계셨고, 생각했던 것보다는 좀 덜 딱딱해보이는 분위기였다.\n\n지원자는 나 포함 2명이었고, 간단한 자기소개부터 시작했다. 상당히 떨려서 생각한 소개말이 조금 꼬였던 것 같다. \n\n질문들은 자소서에서 기반해서 많이 나왔던 같고, 제출한 자소서를 보고 예상 질문을 많이 생각해봤어서 크게 예상을 벗어난 질문들은 없었던 것 같다. 하지만 한 2개 정도 생각도 못해본 질문들을 받아, 순간의 대처로 대답을 하긴 했지만, 만족스러운 대답이 되진 못했던 것 같다.\n\n또한, 같이 면접을 본 다른 지원자분이 스펙만 따졌을 때는 나보다는 경험이 많은 것 같아 처음에는 조금 비교당하지 않을까 했는데, 내가 생각한 면접에서는 해서 좋을 것 없어보이는 말들을 .. 좀 하시는 것 같아 시간이 지날수록 긴장이 많이 풀렸던 것 같다 .. ㅋㅋㅋ\n\n다시 생각해보면 아쉬운 것들도 좀 있었지만, 처음 치고는 매우 잘했다고 생각한다. 물론 그렇다고 합격할 것 같다 ! 는 절대 아니지만 ㅎㅎ.. 기대를 안해야 실망도 안하니까 기대하지 않을 것이다.\n\n1차 면접이 합격해야 인턴십과 2차 면접으로 이어지는 아직 확실히 모르겠다. 아마 다른 지원자들에 대한 면접이 모두 끝나고 나면 연락이 오지 않을까 .. 그때까지는 잊고 살아야겠다 ! ㅋㅋ\n\n혹시나 또 좋은 소식이 온다면, 다음 포스트에서 후기를 이어나갈 것이다. 일단은 화이팅 !"},{"excerpt":"문제 IT 벤처 회사를 운영하고 있는 라이언은 매년 사내 해커톤 대회를 개최하여 우승자에게 상금을 지급하고 있습니다.\n이번 대회에서는 우승자에게 지급되는 상금을 이전 대회와는 다르게 다음과 같은 방식으로 결정하려고 합니다.\n해커톤 대회에 참가하는 모든 참가자들에게는 숫자들과 3가지의 연산문자(+, -, ) 만으로 이루어진 연산 수식이 전달되며, 참가자의 …","fields":{"slug":"/[Programmers]67257/"},"frontmatter":{"date":"April 28, 2022","title":"👩‍💻 67257. 수식 최대화","tags":["순열"]},"rawMarkdownBody":"\n## 문제\nIT 벤처 회사를 운영하고 있는 라이언은 매년 사내 해커톤 대회를 개최하여 우승자에게 상금을 지급하고 있습니다.\n이번 대회에서는 우승자에게 지급되는 상금을 이전 대회와는 다르게 다음과 같은 방식으로 결정하려고 합니다.\n해커톤 대회에 참가하는 모든 참가자들에게는 숫자들과 3가지의 연산문자(+, -, *) 만으로 이루어진 연산 수식이 전달되며, 참가자의 미션은 전달받은 수식에 포함된 연산자의 우선순위를 자유롭게 재정의하여 만들 수 있는 가장 큰 숫자를 제출하는 것입니다.\n단, 연산자의 우선순위를 새로 정의할 때, 같은 순위의 연산자는 없어야 합니다. 즉, + > - > * 또는 - > * > + 등과 같이 연산자 우선순위를 정의할 수 있으나 +,* > - 또는 * > +,-처럼 2개 이상의 연산자가 동일한 순위를 가지도록 연산자 우선순위를 정의할 수는 없습니다. 수식에 포함된 연산자가 2개라면 정의할 수 있는 연산자 우선순위 조합은 2! = 2가지이며, 연산자가 3개라면 3! = 6가지 조합이 가능합니다.\n만약 계산된 결과가 음수라면 해당 숫자의 절댓값으로 변환하여 제출하며 제출한 숫자가 가장 큰 참가자를 우승자로 선정하며, 우승자가 제출한 숫자를 우승상금으로 지급하게 됩니다.\n\n예를 들어, 참가자 중 네오가 아래와 같은 수식을 전달받았다고 가정합니다.\n\n\"100-200*300-500+20\"\n\n일반적으로 수학 및 전산학에서 약속된 연산자 우선순위에 따르면 더하기와 빼기는 서로 동등하며 곱하기는 더하기, 빼기에 비해 우선순위가 높아 * > +,- 로 우선순위가 정의되어 있습니다.\n대회 규칙에 따라 + > - > * 또는 - > * > + 등과 같이 연산자 우선순위를 정의할 수 있으나 +,* > - 또는 * > +,- 처럼 2개 이상의 연산자가 동일한 순위를 가지도록 연산자 우선순위를 정의할 수는 없습니다.\n수식에 연산자가 3개 주어졌으므로 가능한 연산자 우선순위 조합은 3! = 6가지이며, 그 중 + > - > * 로 연산자 우선순위를 정한다면 결괏값은 22,000원이 됩니다.\n반면에 * > + > - 로 연산자 우선순위를 정한다면 수식의 결괏값은 -60,420 이지만, 규칙에 따라 우승 시 상금은 절댓값인 60,420원이 됩니다.\n\n참가자에게 주어진 연산 수식이 담긴 문자열 expression이 매개변수로 주어질 때, 우승 시 받을 수 있는 가장 큰 상금 금액을 return 하도록 solution 함수를 완성해주세요.\n\n### 제한사항\n- expression은 길이가 3 이상 100 이하인 문자열입니다.\n- expression은 공백문자, 괄호문자 없이 오로지 숫자와 3가지의 연산자(+, -, *) 만으로 이루어진 올바른 중위표기법(연산의 두 대상 사이에 연산기호를 사용하는 방식)으로 표현된 연산식입니다. 잘못된 연산식은 입력으로 주어지지 않습니다.\n  - 즉, \"402+-561*\"처럼 잘못된 수식은 올바른 중위표기법이 아니므로 주어지지 않습니다.\n- expression의 피연산자(operand)는 0 이상 999 이하의 숫자입니다.\n  - 즉, \"100-2145*458+12\"처럼 999를 초과하는 피연산자가 포함된 수식은 입력으로 주어지지 않습니다.\n  - \"-56+100\"처럼 피연산자가 음수인 수식도 입력으로 주어지지 않습니다.\n- expression은 적어도 1개 이상의 연산자를 포함하고 있습니다.\n- 연산자 우선순위를 어떻게 적용하더라도, expression의 중간 계산값과 최종 결괏값은 절댓값이 263 - 1 이하가 되도록 입력이 주어집니다.\n- 같은 연산자끼리는 앞에 있는 것의 우선순위가 더 높습니다.\n\n### 입출력 예\n|expression|return|\n|:---:|:---:|:---:|\n|\"100-200*300-500+20\"|60420|\n|\"50\\*6-3\\*2\"|300|\n\n### 📍 **Logic**\n\n```java\nprivate void compute(int n) {\n    ArrayList<Long> numbers = new ArrayList<>(nums);\n    StringBuilder tmpOps = new StringBuilder(operands);\n\n    for (char p : perm) {\n        int idx = tmpOps.indexOf(String.valueOf(p));\n        while(idx != -1) {\n            long n1 = numbers.get(idx);\n            long n2 = numbers.get(idx+1);\n\n            numbers.set(idx, calculator(n1,n2,p));\n            numbers.remove(idx+1);\n            tmpOps.deleteCharAt(idx);\n\n            idx = tmpOps.indexOf(String.valueOf(p));\n        }\n    }\n\n    long sum = Math.abs(numbers.get(0));\n    if (answer < sum) answer = sum;\n}\n```\n\n- 수식의 숫자들을 저장하고 있는 `nums` 을 복사한 `numbers` 와 연산자들을 순서대로 저장하는 `operands` 를 복사한 `tmpOps` 를 사용한다.\n  - 이후 계산 시 숫자와 연산자를 배열에서 삭제하기 위해 임시 저장소를 사용한다.\n- 우선 순위대로 연산자를 저장한 `perm` 을 탐색하면서, 해당 연산자의 위치를 기준으로 숫자들을 계산하고, 대치한 후, 삭제한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        long answer = 0;\n        ArrayList<Long> nums = new ArrayList<>();\n        ArrayList<Character> perm = new ArrayList<>();\n        StringBuilder operands = new StringBuilder();\n        \n        public long solution(String expression) {\n            StringBuilder tmp = new StringBuilder();\n            \n            for (int i = 0; i < expression.length(); i++) {\n                char ch = expression.charAt(i);\n                if (48 <= ch && ch <= 57) tmp.append(ch); \n                else {\n                    nums.add((long) Integer.parseInt(String.valueOf(tmp)));\n                    if (!perm.contains(ch)) perm.add(ch);\n                    operands.append(ch);\n                    tmp.delete(0, tmp.length());\n                }\n            }\n            nums.add((long) Integer.parseInt(String.valueOf(tmp)));\n            \n            // 순열 생성\n            makePerm(0, perm.size(), perm.size());\n            \n            return answer;\n        }\n        \n        private void makePerm(int depth, int n, int r) {\n            if (depth == r) {\n                compute(n);\n                return;\n            }\n\n            for (int i = depth; i < n; i++) {\n                Collections.swap(perm, depth, i);\n                makePerm(depth + 1, n, r);\n                Collections.swap(perm, depth, i);\n            }\n        }\n        \n        private void compute(int n) {\n            ArrayList<Long> numbers = new ArrayList<>(nums);\n            // 연산자 임시 배열이 필요\n            // string은 각 문자별 위치 조회가 가능하지만, 요소 삭제가 안됨\n            // arrayList는 요소 삭제가 용이하지만, 위치 조회가 안됨\n            StringBuilder tmpOps = new StringBuilder(operands);\n\n            for (char p : perm) {\n                int idx = tmpOps.indexOf(String.valueOf(p));\n                while(idx != -1) {\n                    long n1 = numbers.get(idx);\n                    long n2 = numbers.get(idx+1);\n\n                    numbers.set(idx, calculator(n1,n2,p));\n                    numbers.remove(idx+1);\n                    tmpOps.deleteCharAt(idx);\n\n                    idx = tmpOps.indexOf(String.valueOf(p));\n                }\n            }\n\n            long sum = Math.abs(numbers.get(0));\n            if (answer < sum) answer = sum;\n        }\n        \n        private long calculator(long n1, long n2, char op) {\n            return switch (op) {\n                case '-' -> n1 - n2;\n                case '+' -> n1 + n2;\n                case '*' -> n1 * n2;\n                default -> 0;\n            };\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 연산자에 대한 순열이 필요하다는 점은 쉽게 알았지만, 이후 계산을 구현하는데 시간을 너무 많이 썼다.\n- 아직 자바에 대한 공부가 더 필요할 것 같다. (`String`, `StringBuilder`, `ArrayList<String>` 에서 사용하는 메소드)\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/67257"},{"excerpt":"🧷 IoC Inversion of Controller의 약자로, 제어의 역전이라는 의미이다. 일반적인 제어는 객체의 생명주기(생성 - 설정 - 초기화 - 소멸)를 개발자가 주체가 되어 담당하는 것이다. 그렇다면 제어의 역전은 그 반대로 스프링 프레임워크가 주체가 되어 객체의 생명주기를 담당하는 것이다. (정확하게는 스프링 내부에 존재하는 IoC 컨테이너에…","fields":{"slug":"/IoC와 DI/"},"frontmatter":{"date":"April 27, 2022","title":"💬 IoC와 DI","tags":["개발상식","Java","IoC","DI"]},"rawMarkdownBody":"\n## 🧷 IoC\nInversion of Controller의 약자로, **제어의 역전**이라는 의미이다.\n\n일반적인 제어는 객체의 생명주기(생성 - 설정 - 초기화 - 소멸)를 개발자가 주체가 되어 담당하는 것이다. 그렇다면 **제어의 역전**은 그 반대로 **스프링 프레임워크가 주체가 되어 객체의 생명주기를 담당**하는 것이다. (정확하게는 스프링 내부에 존재하는 IoC 컨테이너에서 담당한다.)\n\n제어가 역전되었을 때, 나오는 상황들은 다음과 같다.\n- 단순 자바를 사용하다가 스프링을 사용하게 될 경우, 객체 생성 시 `new` 라느느 키워드를 더 이상 사용할 필요가 없다.\n  - 해당 키워드가 없어도 스프링에서 객체를 생성할 수 있도록 도와주기 때문이다.\n\n> 즉, 개발자들이 해야 할 잡일들을 스프링이 대신하여 개발자가 개발에 더 집중할 수 있는 환경을 조성해준다.\n\n---\n\n## 🧷 DI\nDependency Injection의 약자로, **의존성 주입**이라는 의미이다.\n\n보통 객체를 생성할 때는 클래스 내부에서 값을 넣어주는데, 내부에서 값을 넣어주는 것이 아닌 **외부에서 넣어주는 것**이다.\n\n> 이해를 돕기 위한 예제로, 케이크 전문점에서 케잌 맞춤 제작을 한다고 가정한다..\n> - 여기서 케잌 전문점은 IoC 컨테이너라고 비유할 수 있다.\n>   - 기본적인 구조를 기반으로 케이크 주문자의 명세서에 맞게 맞춤 제작을 해주고 보관까지 하고 있다가 주문자가 찾으러 오면 완성품을 제공하기 때문이다.\n> - 그렇다면 DI는 케잌 주문자가 아닌 외부(케잌 전문점)에서 주문 명세서에 맞게 맞춤 제작하는 것을 비유할 수 있다. \n\n의존성 주입을 하는 이유는 \"**객체들간의 의존성을 낮추며 유연성을 높이기 위함**\"이다. 시스템의 규모가 커지더라도 객체들간의 의존성을 낮춰 코드를 수정하는데 들이는 시간을 줄일 수 있다.\n\n> 의존성 주입은 어느 프레임워크에서든 가능하다. 하지만 의존성이 많아지면 그만큼 관리 코드도 많아지게 된다. 그래서 이를 편리하게 해주는 DI 프레임워크 중 Spring, Dagger 등을 사용한다.\n\n### 🗝 의존성 주입 방법\n총 4가지 방법이 있다.\n#### 🔧 생성자 주입 (constructor injection)\n\n#### 🔧 세터 주입 (setter injection)\n\n#### 🔧 메서드 주입 (method call injection)\n\n#### 🔧 인터페이스 주입 (interface injection)\n---\n\n## 📕 참고\n- [[Spring] 제어의 역전(IoC), 의존성 주입(DI)](https://jforj.tistory.com/50)\n- [의존성 주입(DI, Dependency Injection)이란?](https://umbum.dev/873)\n- [의존성 주입, Dependency Injection에 관한 고찰🔎 With OOP](https://hue-dev.site/springframework/2021/05/03/Dependency-Injection-%EC%9D%B4-%EB%AD%90%EC%97%90%EC%9A%94.html)"},{"excerpt":"🧷 🗝 📕 참고 MSA란?","fields":{"slug":"/MSA/"},"frontmatter":{"date":"April 27, 2022","title":"💬 Micro Service Architecture","tags":["개발상식","MSA"]},"rawMarkdownBody":"\n## 🧷 \n\n### 🗝 \n\n## 📕 참고\n- [MSA란?](https://mydream72.tistory.com/entry/%EC%95%8C%EA%B3%A0%EB%B3%B4%EB%8B%88-MSA%EB%9E%80)"},{"excerpt":"🧷 들어가며 C/C++ 프로그래밍 시에는 메모리 누수(Memory Leak)발생를 위해 사용하지 않는 객체의 메모리를 개발자가 직접 해제해야 했다. 하지만 Java에서는 JVM이 구성된 JRE를 제공하고, 그 구성 요소 중 하나인 GC(Garbage Collection)이 자동으로 사용하지 않는 객체를 파괴한다. GC에 대해 알아보기 전에,  라는 용어를…","fields":{"slug":"/[면접]Garbage Collection/"},"frontmatter":{"date":"April 25, 2022","title":"💬 Garbage Collection","tags":["개발상식","Java","GC"]},"rawMarkdownBody":"\n## 🧷 들어가며\nC/C++ 프로그래밍 시에는 메모리 누수(Memory Leak)발생를 위해 사용하지 않는 객체의 메모리를 개발자가 직접 해제해야 했다. 하지만 Java에서는 JVM이 구성된 JRE를 제공하고, 그 구성 요소 중 하나인 **GC(Garbage Collection)이 자동으로 사용하지 않는 객체를 파괴**한다.\n\nGC에 대해 알아보기 전에, **`stop-the-world`** 라는 용어를 먼저 알아야 한다. 이는 GC의 동작을 위해 **JVM이 애플리케이션 실행을 멈추는 것**이다. 어떤 GC 알고리즘을 사용하더라도 `stop-the-world` 는 발생하고, 대개 이 시간을 줄이는 방향으로 GC 튜닝이 이루어진다.\n\n또한 GC를 해도 더 이상 사용 가능한 메모리 영역이 없는 경우가 있다. 이때 메모리 할당을 요구하면, **`OutOfMemoryError`** 가 발생하여 WAS(Web Application Server)가 다운될 수 있다. 이를 행(Hang) 즉, **서버가 요청을 처리 못하고 있는 상태**라고 한다.\n\n---\n\n## 🧷 Garbage Collection\nJava는 개발자가 직접 메모리 해제를 명시적으로 하지 않아도 된다. 이는 Java의 장점 중 하나라고 할 수 있다. \n- 사용하지 않는 객체를 메모리에서 제거하는 작업을 GC(Garbage Collection)라고 하며, 이는 JVM(Java Virtual Machine)에서 수행한다.\n\n기본적으로 JVM의 메모리는 **5개의 영역**으로 나누어지고, **GC는 Heap 메모리 영역만을 다룬다.**\n- Class\n- Stack\n- Heap\n- Native method\n- PC\n\n그리고 사용하지 않는 객체의 조건은 다음과 같다. 즉, 아래의 조건을 충족한다면 GC의 대상이 된다.\n- 객체가 `NULL` 인 경우 (ex. `String str = null`)\n- 블럭 실행 종료 후, 블럭 안에서 생성된 객체\n- 부모 객체가 `NULL` 인 경우, 포함하는 자식 객체\n\n---\n\n## 🧷 GC의 메모리 해제 과정\n\n### 1. Marking\n<img src=\"https://github.com/GimunLee/tech-refrigerator/raw/master/Language/JAVA/resources/java-gc-001.png\" width=\"50%\">\n\n- 프로세스는 마킹을 호출한다. 이는 메모리가 사용되는지 아닌지를 찾아낸다. 참조되는 객체는 파란색으로, 참조되지 않는 객체(Garbage)는 주황색으로 보여진다. \n- 모든 객체는 마킹 단계에서 참조 여부 확인을 위해 스캔된다. 따라서 매우 많은 시간이 소모된다.\n\n### 2. Normal Deletion\n<img src=\"https://github.com/GimunLee/tech-refrigerator/raw/master/Language/JAVA/resources/java-gc-002.png\" width=\"50%\">\n\n- 참조되지 않는 객체를 제거하고, 메모리를 반환한다. **Memory Allocator**는 반환되어 비어진 블록의 참조 위치를 저장해두었다가, 새로운 객체가 선언되면 그 위치에 할당한다.\n\n### 3. Compacting\n<img src=\"https://github.com/GimunLee/tech-refrigerator/raw/master/Language/JAVA/resources/java-gc-003.png\" width=\"50%\">\n\n- 성능 향상을 위해, 참조되지 않는 객체를 제거하고 또한 남은 참조되어지는 객체들을 묶는다. 이들을 묶어 생기는 공간에 새로운 객체를 할당함으로써 더 쉽고 빠른 진행이 가능하다.\n\n---\n\n## 🧷 Generational GC 배경\n위와 같이 모든 객체를 `Marking & Compacting` 하는 것은 너무 비효율적이다. 시간이 갈수록, 적은 객체만이 남는다.\n\n가장 간단한 형태의 GC 알고리즘은 접근 가능한 모든 객체를 순회하는 것이다. 순회가 끝난 후 남아있는 객체를 쓰레기 객체로 판단해 메모리를 해제한다.\n- 하지만 이 방식은 살아있는 객체의 수에 순회 시간이 비례하므로, 수많은 라이브 데이터를 관리하는 대규모 애플리케이션에서는 절대 사용해선 안되는 방식이다.\n- GC는 쓰레기 객체를 처리하는 데 필요한 작업량을 최소화하기 위해 **약한 세대 가설**을 사용한다. 이는 객체 대부분이 아주 짧은 시간동안만 살아남는다는 가설이다.\n\n> GC는 **Weak Generation Hypothesis**(약한 세대 가설)에 기반한다.\n\n### 🗝 Weak Generation Hypothesis\n```\n                      <---- Tenured(Old) ---->\n+----------+----+----+-----------+------------+---------------------+\n|   Eden   | S0 | S1 |           |   Virtual  |      Permanent      |\n+----------+----+----+-----------+------------+---------------------+\n<------ Young ------>                          <---- Permanent ---->\n\nS: Survivor\n```\n\nJVM의 메모리는 아래와 같은 Generation 구조를 가진다. 각 세대가 모두 채워질 때 GC가 발생한다.\n- 대부분의 객체는 `Young generation` 에서 할당되고, 죽게 된다.\n- 해당 Generation이 가득 차면 `Young generation` 만을 대상으로 하는 **Minor Collection**이 발생한다. 이때, 다른 세대의 Garbage는 처리되지 않는다.\n  - 즉, \"**Minor Collection**은 **약한 세대 가설**을 전제로 최적화\"된 것이다.\n  - 컬렉션의 비용은 수집되는 살아있는 객체의 수에 비례하므로, 죽은 객체들로만 가득찬 `Young generation` 은 매우 빠르게 수집되기 때문이다.\n- `Young generation` 에서 살아남은 객체들 중 일부는 각각의 **Minor Collection** 동안 점점 오른쪽으로 이동하여 `Tenured generation` 으로 옮겨진다.\n- `Tenured generation` 도 가득 차게 되면, 컬렉션의 대상이 되어 Heap 전체를 수집하는 **Major Collection**이 발생한다.\n  - **Major Collection**은 **Minor Collection**보다 더 많은 객체가 관련되어 있어 오래 걸린다.\n  - 시간이 오래 걸리고, 실행 중인 프로세스가 정지된다. 이를 `stop-the-world` 라고 한다.\n  - GC를 실행하는 스레드를 제외한 나머지 모든 스레드는 작업을 멈추고 대기했다가, GC 작업이 완료된 이후 작업을 재개한다.\n- `Permanent` 영역은 **Method Area**라고도 한다. \n  - JVM이 클래스들과 메소드들을 설명하기 위해 필요한 메타데이터들을 포함하고 있다.\n\n### 🗝 GC가 소멸시킬 객체를 선정하는 방식\n알고리즘에 따라 동작 방식이 다양하지만 아래와 같은 공통적인 원리가 있다.\n- 객체가 Garbage인지 아닌지 판단하기 위해 **reachability**라는 개념을 사용한다.\n  - 어떤 힙 영역에 할당된 객체가 유효한 참조가 있으면 **reachability**, 없다면 **unreachability**로 판단한다. (여기서 유효한 참조란, 바로 밑에서 설명할 `Root Set` 과의 참조 관계를 가지는 참조이다.)\n- 하나의 객체는 다른 객체를 참조하고, 이것이 반복되어 **참조 사슬**이 형성될 수 있다.\n  - 이 참조 사슬 중 최초에 참조한 것을 `Root Set` 이라 한다.\n  - 힙 영역에 있는 객체들은 아래 4가지 경우에 대한 참조를 하게 된다.\n\n1. 힙 내의 다른 객체에 의한 참조\n2. Java 스택, 즉 Java 메소드 실행 시 사용하는 지역변수와 파라미터들에 의한 참조\n3. 네이티브 스택(Java Native Interface)에 의해 생성된 객체에 대한 참조\n4. 메소드 영역의 정적 변수에 의한 참조\n\n여기서 2,3,4는 **Root Set**이다. 즉, 참조 사슬 중 최초에 참조한 객체이다.\n- 1의 경우는 힙 내에서 자기들끼리 서로 참조하고 있어 Unreachable Objects, 즉 **Garbage**이다.\n\n### 🗝 Generational GC 과정\n1. 어떤 새로운 객체가 들어오면 `Eden Space` 에 할당한다.\n2. `Eden Space` 가 가득 차면, **Minor GC**가 시작된다.\n3. 참조되는 객체들은 첫 번째 `Survivor` 인 `S0` 로 이동하고, 참조되지 않는 객체들은 `Eden Space` 가 **Clear**될 때 반환된다.\n4. 다음 **Minor GC** 때도 동일한 작업이 반복되는데, 이때는 참조되는 객체들은 두 번째 `Survivor` 인 `S1` 로 이동한다. 또한, 최근 **Minor GC**에서 `S0` 로 이동한 객체들도 **age**가 증가하고, `S1` 로 이동한다.\n   1. 모든 살아남은 객체들이 `S1` 로 이동하게 되면, `S0` 과 `Eden Space` 는 **Clear** 된다.\n   2. 이제 다른 **aged 객체들**은 `S1` 공간에 존재하게 된다.\n5. 다음 **Minor GC** 때 같은 과정이 반복된다. 그러나 이번 반복에서는 `Survivor` 들이 **switch**된다.\n   1. 참조되는 객체들은 결과적으로 `S0` 로 이동하고, `Eden Space` 와 `S1` 는 **clear**된다.\n6. **Minor GC** 이후, 객체들이 일정한 **age threshold**를 넘게 되면, `Young generation` 에서 `Old generation` 으로 **Promotion**한다.\n7. `Old generation` 또한, 점점 채워져 가득차게 되면, **Major GC**가 시행되어 `Old generation` 은 **Clear**되고, 공간이 **Compact**된다.\n\n---\n\n## 📕 참고\n- [Garbage Collection](https://gyoogle.dev/blog/computer-language/Java/Garbage%20Collection.html)\n- [JVM 메모리 구조와 GC](https://johngrib.github.io/wiki/jvm-memory/#generation-%EA%B5%AC%EC%A1%B0-%EC%9A%94%EC%95%BD)"},{"excerpt":"Sorting 알고리즘은 크게 Comparisons 방식과 Non-Comparisons 방식으로 나눌 수 있다. 🧷 Comparisons 방식 알고리즘 , , , , ,  🧷 Non-Comparisons 방식 알고리즘 ,  Stable sort\n: 중복된 키를 순서대로 정렬하는 정렬 방식이다. 즉, 값이 같은 원소가 있어도 정렬 시 그 순서를 보장하는 방…","fields":{"slug":"/[Algorithm]Sorting 알고리즘/"},"frontmatter":{"date":"April 24, 2022","title":"💡 Sorting 알고리즘","tags":["개발상식","Java","정렬"]},"rawMarkdownBody":"\n> Sorting 알고리즘은 크게 **Comparisons** 방식과 **Non-Comparisons** 방식으로 나눌 수 있다.\n\n## 🧷 Comparisons 방식 알고리즘\n`Bubble Sort`, `Selection Sort`, `Insertion Sort`, `Quick Sort`, `Merge Sort`, `Heap Sort`\n\n## 🧷 Non-Comparisons 방식 알고리즘\n`Counting Sort`, `Radix Sort`\n\n> **Stable sort**\n> : 중복된 키를 순서대로 정렬하는 정렬 방식이다. 즉, 값이 같은 원소가 있어도 정렬 시 그 순서를 보장하는 방식이다.\n> \n> **In-place sort**\n> : 원소들의 개수에 비해 충분히 무시할만한, 거의 추가적인 메모리 공간을 사용하지 않는 정렬 방식이다.\n\n---\n\n## 🧷 거품 정렬 (Bubble Sort)\n서로 인접한 두 원소의 대소를 비교하고, 조건에 맞지 않다면 자리를 교환하며 정렬하는 알고리즘이다.\n- 각 회전마다, 첫 번째 원소와 두 번째 원소를 비교하고, 두 번째 원소와 세 번째 원소를 비교하고 교체하는 방식으로 전체 배열을 한 번 순회한다.\n  - 1회전의 결과로 가장 큰 값이 맨 뒤로 이동한다.\n- 다음 회전부터는 맨 끝 원소는 제외하고 이를 반복한다.\n\n```java\nvoid bubbleSort(int[] numbers) {\n  int tmp = 0;\n  for (int i = 0; i < numbers.length; i++) {\n    for (int j = 1; j < numbers.length - i; j++) {\n      if (numbers[j - 1] > numbers[j]) {\n        tmp = numbers[j - 1];\n        numbers[j - 1] = numbers[j];\n        numbers[j] = tmp;\n      }\n    }\n  }\n}\n```\n\n### 🪚 장점\n- 간단한 구현과 직관적인 코드\n- In-place sort\n- Stable sort\n\n### 🪚 단점\n- 정렬되어 있던, 안되어 있던, 2개의 원소를 비교하기 때문에 최선, 평균, 최악의 경우 모두 시간 복잡도가 $O(N^2)$ 으로 동일하다.\n- 교환이 많이 발생한다.\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(N^2)$|$O(1)$|\n\n> ❓\n> - `>=` 연산을 수행한다면 unstable 할까?\n>   - 그렇지 않을까?\n> - 개선을 위해서는 어떻게 해야 하는가?\n>   - 비교를 수행하지 않은 회전이 있다면 바로 정렬을 종료!\n>   - 정렬 범위를 계속 업데이트하는 방식\n>   - 양방향 버블 정렬\n\n### 🪚 양방향 버블 정렬\n정렬 범위를 계속 업데이트하는 개선 방식에 패스의 스캔 방향을 교대로 바꾸는 방식을 더한다. 이를 통해 점점 스캔하는 범위가 줄어들게 된다.\n\n```java\nvoid cocktailSort(int[] numbers) {\n  int left = 0;\n  int right = numbers.length - 1;\n  int last = right;\n\n  while(left < right) {\n    int i;\n    int tmp = 0;\n\n    // 가장 작은 원소가 맨 앞에 위치!\n    for (i = right; i > left; i--) {\n      if (numbers[i - 1] > numbers[i]) {\n        tmp = numbers[i - 1];\n        numbers[i - 1] = numbers[i];\n        numbers[i] = tmp;\n        last = i;\n      }\n    }\n    // 마지막으로 교환이 일어난 위치\n    left = last;\n\n    // 가장 큰 원소가 맨 뒤에 위치\n    for (i = left; i < right; i++) {\n      if (numbers[i] > numbers[i + 1]) {\n        tmp = numbers[i + 1];\n        numbers[i + 1] = numbers[i];\n        numbers[i] = tmp;\n        last = i;\n      }\n    }\n    // 마지막으로 교환이 일어난 위치\n    right = last;\n  }\n}\n```\n\n---\n\n## 🧷 선택 정렬 (Selection Sort)\n버블 정렬과 유사한 알고리즘으로, 해당 회전에 원소를 넣을 위치는 이미 정해져 있고, 어떤 원소를 넣을지 선택하는 알고리즘이다.\n- 각 회전마다, 배열에서 최솟값을 찾는다.\n- 그 값을 맨 앞에 위치한 원소와 교체한다.\n- 이후 회전부터는 맨 앞 원소를 제외하고 반복한다.\n\n> Insertion sort와 다른 점은, 배열에서 해당 자리를 선택하고, 그 자리에 올 값을 배열에서 선택하여 위치시키는 방식이다.\n\n```java\nvoid selectionSort(int[] numbers) {\n  int tmp = 0;\n  for (int i = 0; i < numbers.length - 1; i++) {\n    // 정렬될 원소를 넣을 위치 지정, 왼쪽에서부터 차례대로 수행\n    int minIndex = i;\n    // 최소값을 가지는 인덱스 탐색\n    for (int j = i + 1; j < numbers.length; j++) {\n      if (numbers[j] < numbers[minIndex])\n        minIndex = j;\n    }\n    tmp = numbers[minIndex];\n    numbers[minIndex] = numbers[i];\n    numbers[i] = tmp;\n  }\n}\n```\n\n### 🪚 장점\n- 간단한 구현\n- 정렬을 위한 비교 횟수는 많지만, 버블 정렬에 비해 실제로 교환하는 횟수는 적다.\n- In-place sort\n\n### 🪚 단점\n- 매 회전마다, 정렬된 원소를 제외하고 모든 원소에 대해 비교를 수행해야 한다. 최선, 평균, 최악의 경우 모두 시간 복잡도가 $O(N^2)$ 으로 동일하다.\n- Unstable sort\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(N^2)$|$O(1)$|\n\n> ❓ \n> - stable하게 하는 방법은?\n>   - 최솟값과의 교환이 아닌, 나머지 원소들을 한 자리씩 뒤로 미는 방식으로 stable하게 할 수 있다.\n\n---\n\n## 🧷 삽입 정렬 (Insertion Sort)\n선택 정렬과 유사하지만, 좀 더 효율적인 방식이다. `i` 번째를 정렬할 순서라고 가정하면, `0` 부터 `i - 1` 번째 원소들은 정렬되어있다는 가정하에, `i` 번째 원소와 `i - 1` 번째 원소부터 `0` 번째 원소까지 비교하면서 큰 경우에만 교환한다.\n- 2번째 위치의 값을 `tmp` 에 저장한다. (1번째 원소는 정렬되었다고 가정)\n- `tmp` 와 이전에 있는 원소들과 비교하며 삽입해나간다. 이전의 원소들보다 `tmp` 에 있는 값이 작은 경우 교환한다.\n  - 한 회전이 끝나고 나면, `tmp` 애 있는 값을 위치시킨다.\n- 다음 위치의 값(2번째 이후)을 `tmp` 에 저장하고 이를 반복한다.\n\n```java\nvoid insertionSort(int[] numbers) {\n  for (int i = 1; i < numbers.length; i++) {\n    int tmp = numbers[i];\n    int prev = i - 1;\n    // 이전 위치까지의 원소들 중 현재 삽입할 값보다 작은 값이 나올 떄까지 인덱스를 옮김\n    while(prev >= 0 && numbers[prev] > tmp) {\n      numbers[prev + 1] = numbers[prev];\n      prev--;\n    }\n    numbers[prev + 1] = tmp;\n  }\n}\n```\n\n### 🪚 장점\n- 단순한 알고리즘\n- 대부분의 원소가 이미 정렬된 상태라면, 매우 효율적일 수 있다.\n- In-place sort\n- Stable sort\n- 최선의 경우(모두 정렬된 경우, 1번씩만 비교를 수행) $O(N)$의 시간 복잡도를 가지기에, 선택 정렬이나 버블 정렬보다는 상대적으로 빠르다.\n- Online 알고리즘\n\n> **Online alg**\n> : 시작하는 시점에 모든 정보를 가지고 있지 않고, 입력을 차례로 받으면서 처리하는 알고리즘\n\n### 🪚 단점\n- 평균과 최악의 시간복잡도가 $O(N^2)$이다.\n- 배열의 길이가 길어질수록 비효율적이다.\n\n> **선택 정렬과의 비교**\n> - k번째 반복 이후, 첫 번째 k 요소가 정렬된 순서로 온다는 점에서 유사하지만, 선택 정렬은 k + 1번째 요소를 찾기 위해 나머지 모든 요소를 탐색해야 한다.\n> - 삽입 정렬이 더 효율적인 이유이다.\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(N^2)$|$O(1)$|\n\n---\n\n## 🧷 퀵 정렬 (Quick Sort)\n분할 정복을 통해 주어진 배열을 정렬하는 방식이다.\n- 배열 가운데서 하나의 원소를 선택한다. (Pivot이라 칭한다.)\n- 피봇 앞에는 피봇보다 값이 작은 모든 원소들이 위치하고, 피봇 뒤에는 피봇보다 값이 큰 모든 원소들이 위치하도록 피봇을 기준으로 배열을 둘로 분할한다. \n  - 분할을 마친 뒤 피봇은 더 이상 움직이지 않는다.\n- 분할된 두 개의 작은 배열에 대해 재귀적으로 위 과정을 반복한다.\n\n> **분할 정복(Divide & Conquer)**\n> : 문제를 작은 2개의 겹치지 않는 문제로 분리하여 각각을 해결한 다음, 결과를 모아서 원래의 문제를 해결하는 전략\n\n```java\n// 부분 배열을 정렬한다. 부분 배열의 크기가 충분히 작지 않은 경우 순환 호출하여 분할 정복한다.\nvoid quickSort(int[] numbers, int left, int right) {\n  if (left >= right) return;\n\n  int pivot = partition(numbers, left, right);\n\n  quickSort(numbers, left, pivot - 1);\n  quickSort(numbers, pivot, right);\n}\n\n// 배열을 피봇 기준으로 비균등하게 2개의 부분 배열로 분할한다.\nint partition(int[] numbers, int left, int right) {\n  int pivot = numbers[left];\n  int i = left, j = right;\n  int tmp = 0;\n\n  while(i < j) {\n    while(pivot < numbers[j]) j--;\n    while(i < j && pivot >= numbers[i]) i++;\n    tmp = numbers[i];\n    numbers[i] = numbers[j];\n    numbers[j] = tmp;\n  }\n  numbers[left] = numbers[i];\n  numbers[i] = pivot;\n\n  return i;\n}\n```\n\n### 🪚 개선\n`partition()` 함수에서 피봇 값이 최소나 최대값으로 지정되어 부분 배열로 나눠지지 않았을 때, $O(N^2)$ 의 시간 복잡도를 가진다.\n- 즉, 이미 배열이 정렬된 경우 최악의 시간 복잡도를 가진다.\n- 배열에서 가장 앞에 있는 값과 중간값을 교환해준다면, 시간 복잡도를 $O(NlogN)$ 으로 개선할 수 있다.(최악의 시간 복잡도가 되는 것은 아님!)\n\n### 🪚 장점\n- 최선의 경우(매 피봇이 정확하게 두 부분 배열로 분할하는 경우), 시간 복잡도가 $O(NlogN)$ 이다. (각 순환 호출 단계의 비교 연산은 `N` 번, 총 비교 횟수는 `logN` 번)\n- 불필요한 데이터의 이동을 줄이고, 먼 거리의 데이터를 교환할 뿐만 아니라, 한 번 결정된 피봇들이 추후 연산에서 제외되는 특성으로, 시간 복잡도가 $O(NlogN)$ 인 알고리즘 중 가장 빠른 정렬 알고리즘이다.\n- In-place sort\n\n### 🪚 단점\n- 최악의 경우(이미 배열이 정렬된 경우), 시간 복잡도가 $O(N^2)$ 이다.\n- Unstable sort\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(NlogN)$|$O(1)$|\n\n> Java의 `Arrays.sort()` 는 내부적으로 Dual Pivot Quick Sort를 사용한다.\n> - 삽입 정렬과 퀵 정렬을 합친 개념이다.\n> - 말 그대로 피봇을 2개 사용하고, 총 3개의 구역으로 분할하여 정렬한다.\n\n---\n\n## 🧷 병합 정렬 (Merge Sort)\n합병 정렬이라고도 하며, 이 또한 분할 정복 알고리즘을 사용한다.\n- 영역을 쪼갤 수 있을 만큼 쪼갠 후, 합병시키면서 정렬해나간다.\n\n```java\nvoid mergeSort(int[] numbers, int left, int right) {\n  if (left < right) {\n    int mid = (left + right) / 2;\n\n    // mergeSort()를 재귀적으로 계속 호출함으로써, 쪼개질 때까지 계속 쪼갬\n    mergeSort(numbers, left, mid);\n    mergeSort(numbers, mid + 1, right);\n    merge(numbers, left, mid, right);\n  }\n}\n\n// 정렬된 두 부분 배열을 순차적으로 비교하면서 병합\nvoid merge(int[] numbers, int left, int mid, int right) {\n  int[] L = Arrays.copyOfRange(numbers, left, mid + 1);\n  int[] R = Arrays.copyOfRange(numbers, mid + 1, right + 1);\n\n  int i = 0, j = 0, k = left;\n  int lenL = L.length, lenR = R.length;\n\n  while(i < lenL && j < lenR) {\n    if (L[i] <= R[j]) numbers[k] = L[i++];\n    else numbers[k] = R[j++];\n    k++;\n  }\n\n  while(i < lenL) numbers[k++] = L[i++];\n  while(j < lenR) numbers[k++] = R[j++];\n}\n```\n\n> 순차적인 비교를 통해 정렬을 수행하기 때문에 `LinkedList` 의 정렬이 필요할 때 효율적이다.\n> - 퀵 정렬은 임의 접근이기 때문에 `LinkedList` 에 대해서는 성능이 좋지 않다.\n\n> **퀵 정렬과 병합 정렬의 차이점**\n> - 퀵 정렬: 우선 피봇을 통해 정렬한 후 영역을 쪼갬\n> - 병합 정렬: 영역을 쪼갤 수 있을 만큼 쪼갠 후 정렬\n\n### 🪚 장점\n- 최선, 최악, 평균의 경우 모두 시간 복잡도가 $O(NlogN)$ 이다.\n- Stable sort\n\n### 🪚 단점\n- 추가적인 메모리 공간이 더 필요하다.\n  - In-place sort이 아니다.\n  - `LinkedList` 를 사용하면 In-place 하게 할 수 있다.\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(NlogN)$|$O(N)$|\n\n---\n\n## 🧷 힙 정렬 (Heap Sort)\n완전 이진 트리를 기반으로 하는 힙을(`Binary Heap`) 기반으로 하는 정렬 방식\n- `Binary Heap` 을 활용한 정렬 방식은 2가지가 있다.\n  - 정렬 대상인 데이터들을 힙에 넣었다가, 꺼내는 원리로 정렬 (inplace sort X)\n  - 기존 배열을 `heapify`(`heap` 으로 만드는 과정)을 거쳐 꺼내는 원리로 정렬 (inplace sort O)\n- **최대 힙**을 구성한다.\n- 즉, 현재 힙의 루트에는 최댓값이 존재하게 된다. 루트의 값을 마지막 노드와 바꾼 후, 힙 사이즈를 1 줄인다.\n- 힙의 사이즈가 1보다 큰 경우에 대해 위 과정을 반복한다.\n- 매 과정마다 최댓값을 맨 뒤에 위치시키면서 정렬한다.\n\n> **완전 이진 트리?**\n> : 삽입할 때 왼쪽부터 차례대로 추가하는 이진 트리로, 마지막 레벨을 제외한 모든 레벨은 채워져 있어야 한다.\n\n> **최대 힙, 최소 힙**\n> - 최대 힙 : 각 노드의 값이 해당 `children` 의 값보다 크거나 같은 완전 이진 트리\n> - 최소 힙 : 각 노드의 값이 해당 `children` 의 값보다 작거나 같은 완전 이진 트리\n\n```java\nvoid heapSort(int[] array) {\n  int n = array.length;\n  \n  // 최대 힙 구성\n  for (int i = n / 2 - 1; i >= 0; i--)\n    heapify(array, n, i);\n  \n  // 최대 값 추출 후, 다시 최대 힙 구성 반복\n  for (int i = n - 1; i > 0; i--) {\n    swap(array, 0, i);\n    heapify(array, i, 0);\n  }\n}\n\nvoid heapify(int[] array, int n, int i) {\n  int p = i;\n  // 부모 노드 기준으로, 왼쪽 자식 노드와 오른쪽 자식 노드 idx 지정\n  int l = i * 2 + 1;\n  int r = i * 2 + 2;\n  \n  // 왼쪽 자식노드\n  if (l < n && array[p] < array[l])\n    p = l;\n\n  // 오른쪽 자식노드\n  if (r < n && array[p] < array[r])\n    p = r;\n  \n  // 부모노드 < 자식노드\n  if(i != p) {\n    swap(array, p, i);\n    heapify(array, n, p);\n  }\n}\n```\n\n### 🪚 장점\n- 최선, 최악, 평균의 경우 모두 시간 복잡도가 $O(NlogN)$이다.\n  - `heap` 에 데이터를 저장하는 시간 복잡도: $O(logN)$\n  - `heap` 에서 데이터를 삭제하는 시간 복잡도: $O(logN)$\n- 가장 크거나 가장 작은 값을 구할 때, 최대 k 만큼 떨어진 요소들을 정렬할 때 활용한다면 효율적이다.\n  - 최소 힙 or 최대 힙의 루트 값이기 때문에 **한 번의 힙 구성**을 통해 구하는 것이 가능하고, 삽입 정렬보다 더욱 개선된 결과를 얻어낼 수 있기 때문이다.\n\n### 🪚 단점\n- Unstable sort\n- 데이터의 상태에 따라 같은 시간 복잡도를 가지는 다른 정렬 알고리즘에 비해 느리다.\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(NlogN)$|$O(N)$|\n\n---\n\n> 아래 2가지의 정렬 알고리즘은 비교를 수행하지 않는 **`non-Comparisons Sorting Algorithm`** 이다.\n\n## 🧷 기수 정렬 (Radix Sort)\n데이터를 구성하는 기본 요소(기수: Radix)를 이용하는 정렬 방식\n- 낮은 자릿수부터 비교하여 하나의 버킷을 생성해 분류하고, 그 다음 자릿수를 기준으로 이를 반복한다.\n- **LSD(Least Significant Digit) 방식**과 **MSD(Most Significant Digit) 방식**이 있다.\n  - LSD 방식은 덜 중요한 숫자부터 정렬하는 방식으로, 일의 자리부터 정렬한다.\n  - MSD 방식은 중요한 숫자부터 정렬하는 방식으로, 가장 큰 자릿수부터 정렬한다.\n\n> ❓ **낮은 자릿수부터 정렬하는 이유 (MSD와 LSD의 비교)**\n> - LSD는 중간에 정렬 결과를 볼 수 없다. 일의 자리부터 백의 자리까지 정렬을 마친 후 결과를 알 수 있다.\n> - MSD는 중간에 정렬 결과를 확인할 수 있다. 따라서 정렬하는데 걸리는 시간을 단축시킬 수 있다.\n>   - 하지만 이때, 정렬이 완료되었는지 확인하는 과정이 필요하고, 이때 메모리를 더 사용하게 된다.\n> \n> 결론적으로, **LSD가 MSD보다 더 일관된 알고리즘**이므로, 대개 **기수 정렬을 논할 때는 LSD를 논한다.**\n\n> 입력 데이터의 최댓값에 따라 정렬하는 `Counting Sort` 의 비효율성을 개선하기 위해 사용 가능하다.\n> - 자릿수의 값 별로 정렬을 하기에 나올 수 있는 값의 최대 사이즈는 0 ~ 9(10)이다.\n\n<img src=\"https://blog.kakaocdn.net/dn/DWH0S/btqFOYnIbCu/Q7HOAOzzvlD4xW279LqTLK/img.gif\" width=\"80%\">\n\n```java\nvoid radixSort(int[] arr, int n) {\n  // 최댓값 찾기\n  int m = Arrays.stream(arr).max().getAsInt();\n  \n  // 최댓값을 나눴을 때, 0이 나오면 모든 숫자가 exp의 아래\n  for (int exp = 1; m / exp > 0; exp *= 10)\n    countSort(arr, n, exp);\n}\n\nvoid countSort(int[] arr, int n, int exp) {\n  int[] buffer = new int[n];\n  int[] count = new int[10];\n  int i = 0;\n  \n  // exp의 자릿수에 해당하는 count 증가\n  for (i = 0; i < n; i++) {\n    count[(arr[i] / exp) % 10]++;\n  }\n\n  // 누적합 구하기\n  for (i = 1; i < 10; i++) {\n    count[i] += count[i - 1];\n  }\n\n  // 일반적인 Counting sort 과정\n  for (i = n - 1; i >= 0; i--) {\n    int idx = (arr[i] / exp) % 10;\n    buffer[count[idx] - 1] = arr[i];\n    count[idx]--;\n  }\n\n  for (i = 0; i < n; i++) {\n    arr[i] = buffer[i];\n  }\n}\n```\n\n### 🪚 장점\n- 문자열과 정수의 정렬이 가능하다.\n- Stable sort\n\n### 🪚 단점\n- 자릿수가 없는 데이터에 대한 정렬은 불가능하다. (ex. 부동 소숫점)\n- 중간 결과를 저장할 추가적인 메모리 공간이 필요하다.\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(N)$|$O(N)$|\n\n---\n\n## 🧷 계수 정렬 (Counting Sort)\n말 그대로, 몇 개인지 개수를 세어 정렬하는 방식이다.\n- 주어진 데이터 중 가장 큰 값을 size로 하는 배열을 생성한다.\n- 배열을 탐색하며, 데이터의 등장 횟수를 해당 index에 저장한다.\n- 이후 완성된 등장 횟수 배열을 누적합으로 변경한다.\n- 주어진 데이터 배열을 뒤에서부터 탐색하며, `등장 횟수 배열[주어진 데이터 배열의 값]` 에 해당 숫자를 위치시킨다.\n  - 그리고 누적합 배열의 값을 1씩 감소시킨다.\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/22538A4D56D2FFBA2E\" width=\"80%\">\n\n<img src=\"https://t1.daumcdn.net/cfile/tistory/23057D4956D2FFE314\" width=\"80%\">\n\n```java\nvoid countingSort(int[] numbers) {\n  int[] sortedArr = new int[numbers.length];\n  int[] counting = new int[Arrays.stream(numbers).max().getAsInt() + 1];\n\n  // 등장 횟수 계산\n  for (int num : numbers)\n    counting[num]++;\n\n  // 누적합 계산\n  for (int i = 1; i < counting.length; i++)\n    counting[i] += counting[i - 1];\n\n  // 누적합 배열과 주어진 데이터를 이용해 정렬 수행\n  for (int i = numbers.length - 1; i >= 0; i--) {\n    sortedArr[counting[numbers[i]] - 1] = numbers[i];\n    counting[numbers[i]]--;\n  }\n\n  System.out.println(Arrays.toString(sortedArr));\n}\n```\n\n### 🪚 장점\n- 최선의 경우 $O(N)$의 시간 복잡도를 가져, 가장 빠른 정렬 알고리즘이다.\n- Stable sort\n- 정렬할 데이터가 특정한 범위 안에 있는 경우 자주 사용한다.\n  - 대표적으로는 26개의 알파벳으로 이루어진 문자열에서 `Suffix Array` 를 얻는 경우이다.\n\n### 🪚 단점\n- 데이터의 최댓값에 해당하는 만큼의 추가적인 메모리 공간이 필요하기에(누적합 배열에 접근하는 시간을 $O(1)$로 하기 위해) 대부분의 경우 엄청난 **메모리 낭비**를 야기할 수 있다.\n  - 만약 주어진 데이터의 값 범위가 너무 큰 경우, 사용하지 않는 메모리 공간의 낭비도 발생하게 된다.\n\n|Time Complexity|Space Complexity|\n|:---:|:---:|\n|$O(N)$|$O(N)$|\n\n---\n\n## 📕 참고\n- [Tech Interview for developer](https://gyoogle.dev/blog/algorithm/Bubble%20Sort.html)\n- [JaeYeopHan/Interview_Question_for_Beginner](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Algorithm)\n- [[알고리즘 개념] Stable Sort &Inplace](https://velog.io/@cookncoding/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EA%B0%9C%EB%85%90-Stable-Sort-Inplace)\n- [양방향 버블 정렬](https://hevton.tistory.com/192)\n- [[Dual-Pivot Quick Sort] 두 개의 피봇으로 퀵 정렬](https://cs-vegemeal.tistory.com/53)\n- [Counting Sort : 계수 정렬](https://bowbowbow.tistory.com/8)\n- [기수 정렬-Radix Sort](https://herong.tistory.com/entry/%EA%B8%B0%EC%88%98%EC%A0%95%EB%A0%ACRidix-Sort?category=818669)"},{"excerpt":"문제 스마트폰 전화 키패드의 각 칸에 숫자들이 적혀 있습니다. 이 전화 키패드에서 왼손과 오른손의 엄지손가락만을 이용해서 숫자만을 입력하려고 합니다.\n맨 처음 왼손 엄지손가락은 * 키패드에 오른손 엄지손가락은 # 키패드 위치에서 시작하며, 엄지손가락을 사용하는 규칙은 다음과 같습니다. 엄지손가락은 상하좌우 4가지 방향으로만 이동할 수 있으며 키패드 이동 …","fields":{"slug":"/[Programmers]67256/"},"frontmatter":{"date":"April 24, 2022","title":"👩‍💻 67256. 키패드 누르기","tags":["수학"]},"rawMarkdownBody":"\n## 문제\n스마트폰 전화 키패드의 각 칸에 숫자들이 적혀 있습니다.\n\n이 전화 키패드에서 왼손과 오른손의 엄지손가락만을 이용해서 숫자만을 입력하려고 합니다.\n맨 처음 왼손 엄지손가락은 * 키패드에 오른손 엄지손가락은 # 키패드 위치에서 시작하며, 엄지손가락을 사용하는 규칙은 다음과 같습니다.\n\n- 엄지손가락은 상하좌우 4가지 방향으로만 이동할 수 있으며 키패드 이동 한 칸은 거리로 1에 해당합니다.\n- 왼쪽 열의 3개의 숫자 1, 4, 7을 입력할 때는 왼손 엄지손가락을 사용합니다.\n- 오른쪽 열의 3개의 숫자 3, 6, 9를 입력할 때는 오른손 엄지손가락을 사용합니다.\n- 가운데 열의 4개의 숫자 2, 5, 8, 0을 입력할 때는 두 엄지손가락의 현재 키패드의 위치에서 더 가까운 엄지손가락을 사용합니다.\n  - 만약 두 엄지손가락의 거리가 같다면, 오른손잡이는 오른손 엄지손가락, 왼손잡이는 왼손 엄지손가락을 사용합니다.\n\n순서대로 누를 번호가 담긴 배열 numbers, 왼손잡이인지 오른손잡이인지를 나타내는 문자열 hand가 매개변수로 주어질 때, 각 번호를 누른 엄지손가락이 왼손인지 오른손인지를 나타내는 연속된 문자열 형태로 return 하도록 solution 함수를 완성해주세요.\n\n### 제한사항\n- numbers 배열의 크기는 1 이상 1,000 이하입니다.\n- numbers 배열 원소의 값은 0 이상 9 이하인 정수입니다.\n- hand는 \"left\" 또는 \"right\" 입니다.\n- \"left\"는 왼손잡이, \"right\"는 오른손잡이를 의미합니다.\n- 왼손 엄지손가락을 사용한 경우는 L, 오른손 엄지손가락을 사용한 경우는 R을 순서대로 이어붙여 문자열 형태로 return 해주세요.\n\n### 입출력 예\n|numbers|hand|return|\n|:---:|:---:|:---:|\n|[1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5]|\"right\"|\"LRLLLRLLRRL\"|\n|[7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2]|\"left\"|\"LRLLRRLLLRR\"|\n|[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]|\"right\"|\"LLRLLRLLRL\"|\n\n### 📍 **Logic**\n\n```java\nint leftDist = Math.abs(number.x - left.x) + Math.abs(number.y - left.y);\nint rightDist = Math.abs(number.x - right.x) + Math.abs(number.y - right.y);\n```\n\n- 각 엄지손가락과 누를 번호의 거리를 계산한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Pair {\n        int x;\n        int y;\n        \n        public Pair(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Solution {\n        // 각 엄지 위치\n        Pair left = new Pair(3, 0);\n        Pair right = new Pair(3, 2);\n        // 누를 번호 위치\n        Pair number = new Pair(0, 0);\n        \n        public String solution(int[] numbers, String hand) {\n            StringBuilder answer = new StringBuilder();\n            \n            for (int n : numbers) {\n                if (n == 1 || n == 4 || n == 7) {\n                    answer.append(\"L\");\n                    left.x = n/3;\n                    left.y = 0;\n                }\n                else if (n == 3 || n == 6 || n == 9) {\n                    answer.append(\"R\");\n                    right.x = n/3 - 1;\n                    right.y = 2;\n                }\n                else answer.append(thumb(hand, n));\n            }\n            \n            return answer.toString();\n        }\n        \n        // 2, 5, 8, 0에 대해서는 거리 계산과 잡이 정보가 필요\n        private String thumb(String hand, int n) {\n            if (n == 0) n = 11;\n            \n            // 현재 눌러야 하는 번호의 위치\n            number.x = (n - 1)/3;\n            number.y = (n - 1)%3;\n\n            // 가까운 엄지를 찾기 위해 거리 계산\n            int leftDist = Math.abs(number.x - left.x) + Math.abs(number.y - left.y);\n            int rightDist = Math.abs(number.x - right.x) + Math.abs(number.y - right.y);\n            \n            // 차이가 같은 경우, 잡이 정보에 따라 반환\n            if (leftDist == rightDist) {\n                if (hand.equals(\"left\")) {\n                    updateThumb(left);\n                    return \"L\";\n                }\n                updateThumb(right);\n                return \"R\";\n            } else {\n                // 차이가 다른 경우\n                if (leftDist < rightDist) {\n                    updateThumb(left);\n                    return \"L\";\n                }\n                updateThumb(right);\n                return \"R\";\n            }\n        }\n        \n        private void updateThumb(Pair thumb) {\n            thumb.x = number.x;\n            thumb.y = number.y;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 무작정으로 구현했으나, 번호 간 거리를 구하는 깔끔한 방법이 있을 것 같아서 고민하다가 피타고라스에서 세 점 간 거리 구하듯 거리를 구하면 될 것 같아 구현해보았다.\n- 처음에는 2차원 배열에 각 키패드 번호들을 저장해두고 좌표를 사용할까 했는데, 주어진 번호로부터 좌표를 바로 얻어낼 수 있을 것 같아 배열을 지웠다.\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/67256"},{"excerpt":"문제 상근이는 문자열에 폭발 문자열을 심어 놓았다. 폭발 문자열이 폭발하면 그 문자는 문자열에서 사라지며, 남은 문자열은 합쳐지게 된다. 폭발은 다음과 같은 과정으로 진행된다. 문자열이 폭발 문자열을 포함하고 있는 경우에, 모든 폭발 문자열이 폭발하게 된다. 남은 문자열을 순서대로 이어 붙여 새로운 문자열을 만든다. 새로 생긴 문자열에 폭발 문자열이 포함…","fields":{"slug":"/[BOJ]9935/"},"frontmatter":{"date":"April 20, 2022","title":"👩‍💻 9935. 문자열 폭발","tags":["문자열","자료구조","스택"]},"rawMarkdownBody":"\n## 문제\n\n상근이는 문자열에 폭발 문자열을 심어 놓았다. 폭발 문자열이 폭발하면 그 문자는 문자열에서 사라지며, 남은 문자열은 합쳐지게 된다.\n\n폭발은 다음과 같은 과정으로 진행된다.\n\n- 문자열이 폭발 문자열을 포함하고 있는 경우에, 모든 폭발 문자열이 폭발하게 된다. 남은 문자열을 순서대로 이어 붙여 새로운 문자열을 만든다.\n- 새로 생긴 문자열에 폭발 문자열이 포함되어 있을 수도 있다.\n- 폭발은 폭발 문자열이 문자열에 없을 때까지 계속된다.\n\n상근이는 모든 폭발이 끝난 후에 어떤 문자열이 남는지 구해보려고 한다. 남아있는 문자가 없는 경우가 있다. 이때는 \"FRULA\"를 출력한다.\n\n폭발 문자열은 같은 문자를 두 개 이상 포함하지 않는다.\n\n### 입력\n- 첫째 줄에 문자열이 주어진다. 문자열의 길이는 1보다 크거나 같고, 1,000,000보다 작거나 같다.\n- 둘째 줄에 폭발 문자열이 주어진다. 길이는 1보다 크거나 같고, 36보다 작거나 같다.\n- 두 문자열은 모두 알파벳 소문자와 대문자, 숫자 0, 1, ..., 9로만 이루어져 있다.\n\n### 출력\n- 첫째 줄에 모든 폭발이 끝난 후 남은 문자열을 출력한다.\n\n## 📍 **Logic**\n\n```java\n\n```\n\n- \n  \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Graph {\n        final int[] graph;\n        int[] discovered;\n        boolean[] fin;\n        int answer = 0;\n        int graph_size;\n\n        public Graph(int size) {\n            graph_size = size + 1;\n            this.graph = new int[graph_size];\n            discovered = new int[graph_size];\n            fin = new boolean[graph_size];\n        }\n\n        public void AddElement(int x, int y) {\n            graph[x] = y;\n        }\n\n        public int solution() {\n            for (int i=1; i < graph_size; i++) this.search(i);\n            return graph_size - 1 - this.answer;\n        }\n\n        public void search(int node) {\n            if (discovered[node] == 1) return;\n\n            discovered[node] = 1;\n            int next = graph[node];\n\n            if (discovered[next] == 0) search(graph[node]);\n            else {\n                if (!fin[next]) {\n                    // 다음 갈 정점이 방문은 했으나 아직 끝나지 않은, 즉 사이클이 생성되지 않은 상태\n                    answer++;\n                    for (int i=next; i!=node; i=graph[i]) {\n                        answer++;\n                    }\n                }\n            }\n            fin[node] = true;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) {\n            Scanner sc = new Scanner(System.in);\n            int T = sc.nextInt();\n\n            while (T > 0) {\n                int size = sc.nextInt();\n\n                Graph g = new Graph(size);\n\n                for (int i = 1; i <= size; i++) {\n                    int tmp = sc.nextInt();\n                    g.AddElement(i, tmp);\n                }\n\n                System.out.println(g.solution());\n                T-=1;\n            }\n            sc.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 `replaceAll()` 함수를 사용해서 매우 간단한 코드로 구현했으나, 47%에서 메모리 초과가 떴다.\n  - 당연히 이렇게 쉬울 리는 없다고 생각했고, 게시판을 보니 `replace()` 함수가 메모리를 많이 사용하는 메소드라는 것을 알았다.\n- \n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/9935"},{"excerpt":"문제 점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없…","fields":{"slug":"/[Programmers]42862/"},"frontmatter":{"date":"April 20, 2022","title":"👩‍💻 42862. 체육복","tags":["그리디"]},"rawMarkdownBody":"\n## 문제\n점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.\n\n전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- 전체 학생의 수는 2명 이상 30명 이하입니다.\n- 체육복을 도난당한 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.\n- 여벌의 체육복을 가져온 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.\n- 여벌 체육복이 있는 학생만 다른 학생에게 체육복을 빌려줄 수 있습니다.\n- 여벌 체육복을 가져온 학생이 체육복을 도난당했을 수 있습니다. 이때 이 학생은 체육복을 하나만 도난당했다고 가정하며, 남은 체육복이 하나이기에 다른 학생에게는 체육복을 빌려줄 수 없습니다.\n\n\n### 입출력 예\n|n|lost|reserve|return|\n|:---:|:---:|:---:|:---:|\n|5|[2, 4]|[1, 3, 5]|5|\n|5|[2, 4]|[3]|4|\n|3|[3]|[1]|2|\n\n### 📍 **Logic**\n\n```java\nfor (int l : lost) {\n  if (map.containsKey(l)) map.computeIfPresent(l, (k, v) -> v - 1);\n  else lostMap.put(l, 0);\n}\n\nfor (int l : lostMap.keySet()) {\n  if (map.containsKey(l - 1) && map.get(l - 1) > 0) {\n    map.computeIfPresent(l - 1, (k, v) -> v - 1);\n    map.put(l, 0);\n  } else if (map.containsKey(l + 1) && map.get(l + 1) > 0) {\n    map.computeIfPresent(l + 1, (k, v) -> v - 1);\n    map.put(l, 0);\n  } else map.put(l, -1);\n}\n```\n\n- 학생과 체육복 개수 정보를 `Map` 으로 저장한다.\n  - `reserve` 에 있는 학생들은 모두 체육복 수를 1개로 지정한다.\n- 먼저 `lost` 와 `reserve` 둘 다에 있는 학생의 경우는 자기 체육복을 자기가 써야 하므로, 체육복을 도난당한 학생 목록인 `lostMap` 에 넣지 않고, 해당 학생의 체육복 수는 0으로 update한다.\n- `lostMap` 에는 이제 체육복을 빌려야 하는 학생들만 존재한다.\n  - 앞 번호의 학생들에게 빌릴 수 있는지 확인하고, 체육복 개수 정보를 수정한다.\n- 최종적으로 체육복 개수가 0 이상인 학생들의 수를 센다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\t  import java.util.*;\n\n    class Solution {\n        int[] possible;\n        \n        public int solution(int n, int[] lost, int[] reserve) {\n            Arrays.sort(lost);\n            Arrays.sort(reserve);\n            \n            Map<Integer, Integer> map = new HashMap<>();\n            Map<Integer, Integer> lostMap = new HashMap<>();\n\n            for (int r : reserve)\n                map.put(r, 1);\n            \n            for (int l : lost) {\n                if (map.containsKey(l)) map.computeIfPresent(l, (k, v) -> v - 1);\n                else lostMap.put(l, 0);\n            }\n            \n            for (int l : lostMap.keySet()) {\n                if (map.containsKey(l - 1) && map.get(l - 1) > 0) {\n                    map.computeIfPresent(l - 1, (k, v) -> v - 1);\n                    map.put(l, 0);\n                } else if (map.containsKey(l + 1) && map.get(l + 1) > 0) {\n                    map.computeIfPresent(l + 1, (k, v) -> v - 1);\n                    map.put(l, 0);\n                } else map.put(l, -1);\n            }\n                \n            int answer = 0;\n            for (int i = 1; i <= n; i++) {\n                if (map.containsKey(i) && map.get(i) < 0) continue;\n                answer++;\n            }\n            \n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 그리디는 이해도 안되고, 코드도 안 이쁜 것 같다.\n- 존재 여부를 확인하기 위한 `Map` 은 유용한 것 같다.\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/42862"},{"excerpt":"🔧 Docker란 🔧 스프링 서버 배포해보기 ✂️ 스프링 서버 준비 우선, 배포할 스프링 서버가 필요하다. start.io 를 이용하여 생성한다. 생성한 이후, 프로젝트가 정상적으로 동작하는지 한 번 실행해보도록 한다. 이제 Docker에서 사용할  파일을 빌드해본다.  파일을 열어 파일의 빌드명을 지정해준다. 위 경우는  이라는 이름으로  파일이 생성된다…","fields":{"slug":"/[BackEnd]Docker배포/"},"frontmatter":{"date":"April 18, 2022","title":"💻 Docker를 이용한 Springboot 배포","tags":["Docker","SpringBoot"]},"rawMarkdownBody":"\n## 🔧 Docker란\n\n## 🔧 스프링 서버 배포해보기\n### ✂️ 스프링 서버 준비\n우선, 배포할 스프링 서버가 필요하다. [start.io](https://start.spring.io/) 를 이용하여 생성한다.\n\n<img src=\"../../images/Docker/springServer.png\" width=\"80%\">\n\n생성한 이후, 프로젝트가 정상적으로 동작하는지 한 번 실행해보도록 한다.\n\n이제 Docker에서 사용할 `jar` 파일을 빌드해본다. `build.gradle` 파일을 열어 파일의 빌드명을 지정해준다.\n\n<img src=\"../../images/Docker/jarName.png\" width=\"40%\">\n\n- 위 경우는 `tabooDrug-0.0.1-SNAPSHOT.jar` 이라는 이름으로 `jar` 파일이 생성된다.\n\n이후 화면 오른쪽의 `Gradle` -> `Tasks` -> `build` -> `build.sh` 을 실행하여 프로젝트를 빌드한다.\n\n<img src=\"../../images/Docker/gradleBuild.png\" width=\"70%\">\n\n- 빌드가 완료됨을 터미널에서 확인한 후, `build` -> `libs` 디렉토리를 확인하면 `jar` 파일이 생성된 것을 확인할 수 있다.\n\n빌드된 `jar` 파일은 터미널에서 바로 실행할 수 있다. \n- `java -jar tabooDrug-0.0.1-SNAPSHOT.jar` 명령어를 이용하여 실행해본다.\n\n<img src=\"../../images/Docker/executeJar.png\">\n\n이제 이 애플리케이션을 배포할 준비는 끝났고, Docker 컨테이너로 배포하기 위한 설정이 필요하다.\n\n### ✂️ Docker 준비\n우선 `Dockerfile` 이 필요하다. \n- 이는 컨테이너 내부 환경을 정의하고, \n- `docker build` 를 통해 **docker image**를 생성하고,\n- 생성된 **docker image**를 통해 항상 같은 환경에서의 컨테이너를 구성한다.\n\n<img src=\"../../images/Docker/createDockerfile.png\">\n\n- `openjdk:11` 은 `openjdk11` 이 설치된 기본 OS 환경을 의미하고,\n- `EXPOSE 8080` 는 Host OS와 연결할 포트를 의미하고,\n- `ADD` 에 정의한 파일을 이미지 `build` 시 추가한다의 의미이다.\n- `ENTRYPOINT` 는 컨테이너가 실행될 때 먼저 실행할 명령어를 배열 형태로 정의한다.\n\n이제 사용할 Docker를 환경에 맞게 설치한다. (설치 과정은 생략!) \n\nDocker를 백그라운드에서 실행시킨 이후(Docker Desktop 실행), `Dockerfile` 이 위치한 경로로 이동하여 정의한 설정을 이미지로 build 하도록 아래의 명령어를 실행한다.\n\n```shell\ndocker build -t '로컬 레포지토리명' .\n```\n\n<img src=\"../../images/Docker/dockerBuild.png\">\n\n성공적으로 빌드가 되었다면, `docker images` 로 이미지 목록을 확인하는 명령어로 확인할 수 있다.\n\n<img src=\"../../images/Docker/dockerImage.png\" width=\"60%\">\n\n해당 이미지를 Docker 컨테이너에 올려본다.\n- 이제는 애플리케이션이 구동되는 환경이 Host OS가 아닌, Docker 엔진 위에 올라간 컨테이너이다.\n\n<img src=\"../../images/Docker/onContainer.png\">\n\n### ✂️ Docker Hub 사용하기\ngithub처럼, Docker hub도 존재한다. hub에 생성한 이미지를 올려 다른 팀원들도 사용할 수 있도록 한다.\n\ndocker hub 홈페이지를 이용하는 방법도 있지만, IntelliJ에서 제공하는 Docker plugin을 이용하면 손쉽게 hub에 push가 가능하다.\n\n1. 먼저 docker plugin을 설치한다.\n2. 이후, IntelliJ 아래쪽의 `Service` -> `Docker` 를 우클릭하여 `Connect` 한다. 로그인한 계정과 연결할 수 있다.\n3. 이후, `Docker` -> `Images` 에서 금방 생성한 image를 확인할 수 있는데, 이를 우클릭하여 `Push Image...` 를 클릭한다.\n4. `Registry` , `Namespace` , `Repository` , `Tag` 를 입력하는데, `Registry` 를 생성하지 않았다면 생성한다. 모두 입력한 후 PUSH를 누르고, 잠시 기다린 후 Docker hub 홈페이지를 확인하면, 해당 `Registry` 에 올라간 것을 확인할 수 있다.\n\n<img src=\"../../images/Docker/dockerRegistry.png\">\n\n이제 내가 올린 Docker image를 `docker pull` 명령어를 사용해 다운받아 사용할 수 있을 것이다.\n\n## 📕 참고\n- [스프링부트 어플리케이션을 도커컨테이너에 배포 해보자](https://parkjangwon.github.io/springboot/java/docker/2020/11/14/%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8-%EC%96%B4%ED%94%8C%EB%A6%AC%EC%BC%80%EC%9D%B4%EC%85%98%EC%9D%84-%EB%8F%84%EC%BB%A4%EC%BB%A8%ED%85%8C%EC%9D%B4%EB%84%88%EC%97%90-%EB%B0%B0%ED%8F%AC-%ED%95%B4%EB%B3%B4%EC%9E%90.html)\n- [dockerfile 역할과 활용 정리](https://lejewk.github.io/docker-dockerfile/)"},{"excerpt":"문제 H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 를 구하려고 합니다. 위키백과에 따르면, H-Index는 다음과 같이 구합니다. 어떤 과학자가 발표한 논문 편 중, 번 이상 인용된 논문이 편 이상이고 나머지 논문이 번 이하 인용되었다면 의 최댓값이 이 과학자의 H-Index입니다. 어떤 과…","fields":{"slug":"/[Programmers]42747/"},"frontmatter":{"date":"April 15, 2022","title":"👩‍💻 42747. H-Index","tags":["정렬"]},"rawMarkdownBody":"\n## 문제\nH-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 `h`를 구하려고 합니다. 위키백과에 따르면, H-Index는 다음과 같이 구합니다.\n\n어떤 과학자가 발표한 논문 `n`편 중, `h`번 이상 인용된 논문이 `h`편 이상이고 나머지 논문이 `h`번 이하 인용되었다면 `h`의 최댓값이 이 과학자의 H-Index입니다.\n\n어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 citations가 매개변수로 주어질 때, 이 과학자의 H-Index를 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- 과학자가 발표한 논문의 수는 1편 이상 1,000편 이하입니다.\n- 논문별 인용 횟수는 0회 이상 10,000회 이하입니다.\n\n### 입출력 예\n|citations|return|\n|:---:|:---:|\n|[3, 0, 6, 1, 5]|3|\n\n### 📍 **Logic**\n\n```java\nprivate boolean isHindex(int[] citations, int H) {\n  int s = 0, l = 0;\n  for (int i = 0; i < citations.length; i++) {\n    if (citations[i] >= H) l++;\n    if (citations[i] <= H) s++;\n  }\n  \n  if (l >= H && s <= H) return true;\n  return false;\n}\n```\n\n- `H` 가 주어진 H-index 조건을 만족하는지 확인하는 함수\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\t  import java.util.*;\n\n    class Solution {\n        public int solution(int[] citations) {\n            int n = citations.length;\n            int answer = 0;\n            \n            Arrays.sort(citations);\n            \n            for (int i = citations[n - 1]; i >= 0; i--) {\n                if (isHindex(citations, i)) {\n                    answer = i;\n                    break;\n                }\n            }\n            \n            return answer;\n        }\n        \n        private boolean isHindex(int[] citations, int H) {\n            int s = 0, l = 0;\n            for (int i = 0; i < citations.length; i++) {\n                if (citations[i] >= H) l++;\n                if (citations[i] <= H) s++;\n            }\n            \n            if (l >= H && s <= H) return true;\n            return false;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- H-index가 주어진 `citations` 배열에 없을 수도 있다는 생각을 못하고, 주어진 배열 내에서만 H-index를 찾으려다가 테케 1개 빼고 다 실패했다...\n- 주어진 배열에 없을 수도 있다는 가정하에 구현하니 바로 해결했다.\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/42747"},{"excerpt":"문제 수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다. 1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...\n2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, …","fields":{"slug":"/[Programmers]42840/"},"frontmatter":{"date":"April 15, 2022","title":"👩‍💻 42840. 모의고사","tags":["완전 탐색"]},"rawMarkdownBody":"\n## 문제\n수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.\n\n1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...\n2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...\n3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...\n\n1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- 시험은 최대 10,000 문제로 구성되어있습니다.\n- 문제의 정답은 1, 2, 3, 4, 5중 하나입니다.\n- 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.\n\n### 입출력 예\n|answers|return|\n|:---:|:---:|\n|[1,2,3,4,5]|[1]|\n|[1,3,2,4,2]|[1,2,3]|\n\n### 📍 **Logic**\n\n```java\nprivate int countScore(int[] answers, int[] std) {\n    int score = 0;\n    for (int i = 0, idx = 0; i < answers.length; i++) {\n        if (idx >= std.length)\n            idx = idx % std.length;\n        if (std[idx++] == answers[i])\n            score++;\n    }\n    return score;\n}\n```\n\n- 주어진 학생의 정답 배열을 가지고 점수를 매긴다.\n- 다만 주어진 정답 배열의 범위를 벗어나는 경우 (문제 수가 더 많은 경우) 접근 index 값을 `%` 을 사용해 변경한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        public int[] solution(int[] answers) {\n            \n            int[] std1 = {1,2,3,4,5};\n            int[] std2 = {2,1,2,3,2,4,2,5};\n            int[] std3 = {3,3,1,1,2,2,4,4,5,5};\n            \n            int[] scores = new int[3];\n            \n            scores[0] = countScore(answers, std1);\n            scores[1] = countScore(answers, std2);\n            scores[2] = countScore(answers, std3);\n            \n            int max = Arrays.stream(scores).max().getAsInt();\n            \n            ArrayList<Integer> answer = new ArrayList<>();\n            \n            for (int i = 0; i < 3; i++) {\n                if (scores[i] == max)\n                    answer.add(i + 1);\n            }\n            \n            return answer.stream().mapToInt(i -> i).toArray();\n        }\n        \n        private int countScore(int[] answers, int[] std) {\n            int score = 0;\n            for (int i = 0, idx = 0; i < answers.length; i++) {\n                if (idx >= std.length) idx = idx % std.length;\n                if (std[idx++] == answers[i])\n                    score++;\n            }\n            return score;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 완전 탐색 알고리즘답게 단순히 다 돌려보면 되는 문제였다.\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/42840"},{"excerpt":"😁 서류 전형 합격! 작년말까지만 해도 알고리즘 문제 풀이를 정말 한~참을 미뤄뒀었다. 거의 반쯤은 손을 놓고 있었다. 4학년이 된 올해는 ... 더 이상 놓고 있으면 취업을 안하겠다는 말이니까 .. (사실 이전부터 하는 게 백번 맞다는 건 알지만) 슬슬 밀린 알고리즘 문제를 풀고 있었다. 그러면서 프로그래머스를 통해 신청만 하면 응시할 수 있는 코딩 테…","fields":{"slug":"/[LGCNS] 코테 후기/"},"frontmatter":{"date":"April 14, 2022","title":"💭 [LG CNS 신입_학사] IT Leadership Academy : 22년 상반기 신입 채용 코딩 테스트 후기","tags":["코딩테스트","후기"]},"rawMarkdownBody":"\n## 😁 서류 전형 합격!\n작년말까지만 해도 알고리즘 문제 풀이를 정말 한~참을 미뤄뒀었다. 거의 반쯤은 손을 놓고 있었다.\n\n4학년이 된 올해는 ... 더 이상 놓고 있으면 취업을 안하겠다는 말이니까 .. (사실 이전부터 하는 게 백번 맞다는 건 알지만) 슬슬 밀린 알고리즘 문제를 풀고 있었다. 그러면서 프로그래머스를 통해 신청만 하면 응시할 수 있는 코딩 테스트를 한 2-3개 경험했었다. 물론 붙을 거란 생각은 당연히 하지도 않고 그저 경험해보자는 의미에서 도전했었다.\n\n하지만 결과는 뭐 말할 것도 없었고, 간단해보이는 문제를 푸는 데도 한 세월을 보내는 자신을 보면서 현타가 많이 왔다. 지금부터라도 정신을 붙잡고 알고에 매달려야겠다!\n\n그러던 중, LG CNS 채용 공고가 올라온 것을 확인했다. 이전부터 LG CNS에 대해서는 주변에 취업한 선배 및 동기를 통해 알고 있었고, 학교를 통해 참여했던 2021 하계 인도 인턴십에서 LGSI와 협업하며 좋은 기억이 있었기에 (상도 수상하고 ㅎ) 지원하게 되었다. 자기 소개 및 가진 역량과 노력했던 점 등을 서술하여 지원했고, 운이 좋게도 서류 전형에 합격했다! (첫 합격 ...)\n\n그래서 다가오는 16일에 인적성 검사 및 코딩 테스트를 진행할 예정이다. 물론 알고리즘을 많이 풀지 않아 나에게는 많이 어려울테지만 이또한 경험이 될 것은 확실하기에, 긴장되지만 최대한 열심히 부딪혀보고 코딩 테스트 후기를 남겨볼 것이다!\n\n이번뿐만 아니라 앞으로도 계속 경험한 것들에 대한 후기를 남겨 나중에 어떤 마음가짐으로 임했는지, 어떤 것을 느꼈는지 확인하고자 한다. 일단 이번 코테부터 화이팅...\n\n## 😁 코딩 테스트 후기\n하 .... 코테가 끝났다. 10시부터 인적성검사를 시작한다고 해서 긴장하면서 들어갔는데, 신분증 검사하고 주변 환경 확인한 후 한 10시 40분까지 가만히 대기만 했다. 조금 피곤해서 잠들 뻔 했다 ㅎ..\n\n적성 검사를 먼저 했는데 수능 이후로 그런 문제를 풀어본 적이 없어 시간에 쫓겨 제대로 못 푼 것 같다. 어쩌면 적성에서 떨어질 수도 있겠단 생각이 들었다 ...\n\n적성 검사 이후 인성 검사는 정답이 없고 그냥 내 인성을 보여주는 것이니까 부담감 없이 MBTI 검사하듯 편하게 했다. 물론 일관성 있게 수행하고 혹시라도 나중에 임원 면접을 가게 되면, 인성 검사 기준으로 질문한다고 해서 체크하는 이유에 대해 잠깐씩 생각해보면서 수행했다.\n\n이후 점심을 먹고 13시 30분부터 코딩 테스트를 시작했다. 문제는 총 3문제였고, 3시간이 주어졌다. 나는 JAVA로 풀었고 3문제 중 2문제를 풀고 1문제는 거의 손도 못 댔다..\n\n1, 2번은 단순 구현과 그래프 .. 정도였던 것 같다. 학교 알고리즘 강의 수강 시 배웠던 내용이 떠올라 적용해봤고 테케는 맞았으나 효율성은 잘 모르겠다.\n\n3번은 백준 테트로미노 문제랑 비슷했던 것 같다. 접근법을 도저히 못 떠올려서 30분 정도 남기고 그냥 제출했다ㅜ\n\n1, 2번 난이도는 생각한 것보다 좀 쉬웠던 것 같다. (물론 맞진 않을 수도 있겠지만 ... ㅎ) 3번 또한 문제를 더 많이 풀어봤었더라면 맞췄을 지도 모르겠단 생각이 들어 너무 아쉽고 화가 났다. 아마 3솔이어야 합격할 것 같다 ㅜ\n\n처음으로 제대로 원서 내고 합격해서 쳐 본 코딩 테스트였는데, 아쉬움이 더 많이 남는 것 같다. 알고리즘은 역시 하는 만큼 나오는 것 같다. 그래도 좋은 경험이었다고 생각할란다!\n\n> 정~말 혹시라도 붙게 된다면 1차 면접 후기로 돌아올지도 ..."},{"excerpt":"문자열 알고리즘을 풀 때, 생각보다 유용하게 사용된다고 하는 정규표현식에 대해 간단히 정리해보는 POST 📍 정규표현식 컴퓨터 과학의 정규언어로부터 유래한 것으로, 특정한 규칙을 가진 문자열의 집합을 표현하기 위해 쓰이는 형식언어이다. 주로 정해져 있는 입력 형식에 맞는지 검증하기 위해 사용한다. 📍 작성 방법 JAVA API  패키지를 사용해야 한다. …","fields":{"slug":"/[Java지식]정규표현식/"},"frontmatter":{"date":"April 14, 2022","title":"📃 정규표현식","tags":["Java"]},"rawMarkdownBody":"\n<em>문자열 알고리즘을 풀 때, 생각보다 유용하게 사용된다고 하는 정규표현식에 대해 간단히 정리해보는 POST</em>\n\n## 📍 정규표현식\n컴퓨터 과학의 정규언어로부터 유래한 것으로, 특정한 규칙을 가진 문자열의 집합을 표현하기 위해 쓰이는 형식언어이다.\n- 주로 정해져 있는 입력 형식에 맞는지 검증하기 위해 사용한다.\n\n---\n\n## 📍 작성 방법\nJAVA API `java.util.regex` 패키지를 사용해야 한다. 해당 패키지에 있는 `Pattern` 클래스와 `Matcher` 클래스를 주로 사용한다.\n\n### 📝 Pattern 클래스\n정규 표현식에 대상 문자열을 검증하는 기능은 `Pattern` 클래스의 `matches()` 메소드를 활용해 검증할 수 있다.\n- 첫 번째 인자는 정규 표현식이고, 두 번째 인자는 검증 대상 문자열이다.\n- 검증 후 정규 표현식과 일치하면 `true` 를 반환한다.\n\n```java\nimport java.util.regex.Pattern;\n\npublic class Example {\n  public static void main(String[] args) {\n    String pattern = \"^[0-9]*$\"; // 숫자만\n    String val = \"123456789\";\n\n    boolean regex = Pattern.matches(pattern, val);\n    System.out.println(regex);\n    // true 출력\n  }\n}\n```\n\n**📌 Pattern 클래스 주요 메소드**\n- `compile(String regex)` : 주어진 정규 표현식으로부터 패턴을 생성한다.\n- `matcher(CharSequence input)` : 대상 문자열이 패턴과 일치할 경우 `true` 를 반환한다.\n- `asPredicate()` : 문자열을 일치시키는데 사용할 수 있는 술어를 작성한다.\n- `pattern()` : 컴파일된 정규 표현식을 `String` 형태로 반환한다.\n- `split(CharSequence input)` : 문자열을 주어진 인자값 `CharSequence` 패턴에 따라 분리한다.\n\n### 📝 Matcher 클래스\n대상 문자열의 패턴을 해석하고 주어진 패턴과 일치하는지 판별할 때 사용한다.\n- 입력값으로는 `CharSequence` 라는 인터페이스를 사용하는데, 이를 통해 다양한 형태의 입력 데이터로부터 문자 단위의 매칭 기능을 지원할 수 있다.\n- `Matcher` 객체는 `Pattern` 객체의 `matcher()` 메소드를 호출하여 받아올 수 있다.\n\n```java\nimport java.util.regex.Pattern;\nimport java.util.regex.Matcher;\n\npublic class Main {\n    public static void main(String[] args){\n        Pattern pattern = Pattern.compile(\"^[a-zA-Z]*$\"); // 영문자만\n        String val = \"abcdef\";\n        Matcher matcher = pattern.matcher(val);\n        \n        System.out.println(matcher.find());\n        // true 출력\n    }\n}\n```\n\n**📌 Matcher 클래스 주요 메소드**\n- `matches()` : 대상 문자열과 패턴이 일치할 경우 `true` 를 반환한다.\n- `find()` : 대상 문자열과 패턴이 일치하는 경우 `true` 를 반환하고, 그 위치로 이동한다.\n- `find(int start)` : `start` 위치 이후부터 매칭 검색을 수행한다.\n- `start()` : 매칭되는 문자열 시작 위치를 반환한다.\n- `start(int group)` : 지정된 그룹이 매칭되는 시작 위치를 반환한다.\n- `end()` : 매칭되는 문자열 끝 다음 문자 위치를 반환한다.\n- `end(int group)` : 지정된 그룹이 매칭되는 끝 다음 문자 위치를 반환한다.\n- `group()` : 매칭된 부분을 반환한다.\n- `group(int group)` : 매칭된 부분 중 `group` 번 그룹핑 매칭 부분을 반환한다.\n- `groupCount()` : 패턴 내 그룹핑한 전체 갯수를 반환한다.\n\n### 📝 숫자\n위 예제에서는 `[0-9]` 로 표현했지만, 정규 표현식 문법을 사용하면 `\\\\d` 라는 숫자를 대표하는 정규 표현식으로 표현할 수 있다. (d = digit)\n\n```java\nimport java.util.regex.Pattern;\nimport java.util.regex.Matcher;\n\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"\\\\d\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 글자\n`a, b, c, 가, 나, 다, 1, 2, 3` 과 같은 알파벳과 숫자를 포함한 글자를 대표하는 정규 표현식은 `\\\\w` 이다.\n- 특수 문자는 포함하지 않지만, `_` 는 포함한다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"\\\\w\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 하나 이상\n`\\\\d` 는 숫자를 한 글자만 찾는다. 하지만 전화번호와 같이 붙어있는 경우에 대해서는 어떻게 해야 할까?\n- \"하나 혹은 그 이상 연결된\" 이라는 의미를 가진 `+` 를 사용하여 연결된 숫자에 대해 찾는다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"\\\\d+\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 0개 이상\n정규 표현식으로 010, 123, 456 중 자연수를 찾으려면 어떻게 해야 할까?\n- 0으로 시작하지 않으니 자연수의 첫 자리는 반드시 1 ~ 9 중 하나여야 한다.\n- 그 다음 자리부터는 0 ~ 9 사이의 숫자가 나올 수도 있고, 그렇지 않을 수도 있다.\n\n정리하자면 자연수는,\n1. 처음에 1 ~ 9 중 하나의 숫자가 나온 다음\n2. 그 뒤에는 숫자가 0개 이상 나오면 된다.\n\n`*` 는 \"0개 이상\" 이라는 의미이다. 따라서, `\\\\d*` 는 \"숫자가 0개 이상이다\" 를 의미한다.\n- 이를 통해 자연수는 `[1-9]\\\\d*` 로 표현할 수 있다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"[1-9]\\\\d*\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 있거나 없거나(1)\n전화번호는 \"-\" 를 포함하거나, 포함하지 않을 수 있다. \n- 따라서 전화번호는 연속되는 숫자 3 ~ 4개 사이에 `-` 가 있거나 없다고 표현할 수 있다.\n\n`?` 는 \"있거나 없거나\" 를 의미한다. \n- `-?` 는 \"-가 있거나 없거나\" 를 의미한다.\n- `\\\\d+-?\\\\d+-?\\\\d+` 로 전화번호를 찾는 정규 표현식을 생성할 수 있다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"\\\\d+-?\\\\d+-?\\\\d+\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 있거나 없거나(2)\n위의 예제는 전화번호 사이에 공백이 포함된 경우를 찾을 수 없다. (출력 결과를 보면 다른 전화번호로 인식)\n- 즉, \"- 또는 공백이 있거나 없거나\" 는 조건을 써야 한다.\n\n`[- ]?` 로 \"`-` 또는 ` `(공백)이 있거나 없거나\" 를 표현한다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"\\\\d+[- ]?\\\\d+[- ]?\\\\d+\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 n번(1)\n위에서 다룬 `\\\\d+[- ]?\\\\d+[- ]?\\\\d+` 정규 표현식은 \"0030589-5-95826\" 과 같이 연결된 숫자가 너무 많은 문자열도 전화번호로 인식한다.\n\n### 📝 n번(2)\n`{숫자}` 는 \"`{숫자}` 번 반복한다\" 는 의미이다. \n- `\\\\d{2}` 는 숫자가 연속 2번 나온다는 의미이다.\n\n`\\\\d{2}[- ]?\\\\d{3}[- ]?\\\\d{4}` 는 **숫자가 2번, - 또는 공백, 숫자가 3번, - 또는 공백, 숫자가 4번 나온다**는 표현이다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"\\\\d{2}[- ]?\\\\d{3}[- ]?\\\\d{4}\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 n~m번\n`\\\\d{2}` 로 전화번호의 첫 부분을 찾으려고 하여, 첫 부분에 숫자가 3번 나오는 경우(010 2454 3457)를 인식하지 못한다.\n- `{숫자1, 숫자2}` 는 \"숫자1부터 숫자2까지 반복한다\" 는 의미로, `\\\\d{2,3}` 정규 표현식은 숫자가 2~3개 반복된다는 의미이다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"\\\\d{2,3}[- ]?\\\\d{3,4}[- ]?\\\\d{4}\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 몇 개 중에 고르기\n특정 알파벳만 고르고 싶은 경우, `[]` 안에 특정 알파벳을 명시하면 된다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"[aeiou]\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 범위에서 고르기(1)\n소문자 알파벳만 고르고 싶은 경우, 위 예제처럼 `[abcd ... xyz]` 라고 명시하면 되겠지만 뭔가 찜찜하다.\n- 간단하게 `[a-z]` 라고 명시하여 소문자 알파벳을 찾을 수 있다.\n\n### 📝 범위에서 고르기(2)\n소문자 알파벳을 고르는데, 이들 중 연속된 소문자 알파벳을 고르고 싶은 경우는 어떻게 해야 할까?\n- 지금까지 배운 정규 표현식들을 활용하면, 소문자 알파벳을 의미하는 `[a-z]` 에 반복을 의미하는 `+` 를 붙여 찾을 수 있겠다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"[a-z]+\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 한글 고르기\n한글을 어떻게 찾아야 할까 ? \n- 한글의 첫 번째 글자는 `가` 이고, 마지막 글자는 `힣` 이다. \n- 따라서, `[가-힣]` 으로 모든 한글을 찾을 수 있을 것이다.\n- 연속된 한글을 찾으려면, `[가-힣]+` 를 사용한다.\n\n```java\npublic class Main {\n    public static void main(String[] args){\n        String searchTarget = \"Luke Skywarker 02-123-4567 luke@daum.net\\n다스베이더 070-9999-9999 darth_vader@gmail.com\\nprincess leia 010 2454 3457 leia@gmail.com\";\n\n        Pattern pattern = Pattern.compile(\"[가-힣]+\");\n        Matcher matcher = pattern.matcher(searchTarget);\n\n        while(matcher.find()) {\n            System.out.println(matcher.group(0));\n        }\n    }\n}\n```\n\n### 📝 기타 대표문자\n숫자를 의미하는 `\\\\d` 나 글자를 의미하는 `\\\\w` 말고 다음과 같은 대표 문자들이 있다.\n- `\\\\s` : 공백 문자(스페이스. 탭, 뉴라인)\n- `\\\\S` : 공백 문자를 제외한 문자\n- `\\\\D` : 숫자를 제외한 모든 문자\n- `\\\\W` : 글자를 제외한 모든 문자\n\n### 📝 정규 표현식을 사용해 풀어본 문제\n[Programmers - 튜플](https://programmers.co.kr/learn/courses/30/lessons/64065)\n\n```java\nimport java.util.*;\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\nclass Solution {\n    // 개수로 정렬하고, 첫번째 요소의 값을 튜플의 첫 요소로 삽입,\n    // 이후 정렬된 배열을 순차적으로 돌면서, 이미 튜플에 넣은 값이 아닌 값이 나오면 튜플에 삽입, 반복\n    public int[] solution(String s) {\n        Map<Integer, Integer> map = new HashMap<>();\n\n        Pattern pattern = Pattern.compile(\"\\\\d+\");\n        Matcher matcher = pattern.matcher(s);\n\n        while(matcher.find()) {\n            int num = Integer.parseInt(matcher.group(0));\n            map.put(num, map.getOrDefault(num, 0) + 1);\n        }\n\n        ArrayList<Integer> tuple = new ArrayList<>(map.keySet());\n        tuple.sort((value1, value2) -> (map.get(value2).compareTo(map.get(value1))));\n\n        return tuple.stream().mapToInt(i -> i).toArray();\n    }\n}\n```\n\n- 원래는 문자열을 하나하나 파싱하고, 튜플을 저장한 배열에 값이 있는지 없는지 확인해가면서 구현했었다.\n- 코드가 너무 지저분한 것 같고, 좀 더 효율적인 방법이 없을까 고심하다가 배운 정규 표현식이 떠올라 사용해봤고, 간결한 코드와 효율적인 메모리 사용으로 해결할 수 있었다.\n\n## 📕 참고\n- [프로그래머스](https://programmers.co.kr/learn/courses/11)\n- [[Java] 자바 정규 표현식 (Pattern, Matcher) 사용법 & 예제](https://coding-factory.tistory.com/529)"},{"excerpt":"문제 0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요. 예를 들어, 주어진 정수가 6, 10, 2라면 6102, 6210, 1062, 1026, 2610, 2106를 만들 수 있고, 이중 가장 큰 수는 6210입니다. 0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 …","fields":{"slug":"/[Programmers]42746/"},"frontmatter":{"date":"April 14, 2022","title":"👩‍💻 42746. 가장 큰 수","tags":["정렬"]},"rawMarkdownBody":"\n## 문제\n0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.\n\n예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.\n\n0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- numbers의 길이는 1 이상 100,000 이하입니다.\n- numbers의 원소는 0 이상 1,000 이하입니다.\n- 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.\n\n### 입출력 예\n|numbers|return|\n|:---:|:---:|\n|[6, 10, 2]|\"6210\"|\n|[3, 30, 34, 5, 9]|\"9534330\"|\n\n### 📍 **Logic**\n\n```java\nArrays.sort(strNumbers, new Comparator<String>() {\n    public int compare(String obj1, String obj2) {\n        return (obj2 + obj1).compareTo(obj1 + obj2);\n    }\n});\n```\n\n- 숫자를 저장할 `strNumbers` 배열에 `compareTo()` 를 이용해 작은 숫자를 앞으로 정렬시킨다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\t  import java.util.*;\n\n    class Solution {\n        public String solution(int[] numbers) {\n            String[] strNumbers = new String[numbers.length];\n            String answer = \"\";\n            \n            for (int i = 0; i < numbers.length; i++) {\n                strNumbers[i] = Integer.toString(numbers[i]);\n            }\n            \n            Arrays.sort(strNumbers, new Comparator<String>() {\n                public int compare(String obj1, String obj2) {\n                    return (obj2 + obj1).compareTo(obj1 + obj2);\n                }\n            });\n            \n            if (strNumbers[0].equals(\"0\")) {\n                answer = \"0\";\n            } else {\n                for (String strNumber : strNumbers) {\n                    answer += strNumber;\n                }\n            }\n            \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 주어진 수들 중 가장 큰 수를 찾아 그 자릿수만큼 다른 수들의 자릿수를 변환한 다음, 정렬하여 변환한 수의 경우는 다시 원래 수로 바꿔 `answer` 에 붙이고, 변환하지 않은 수는 그대로 `answer` 에 붙이는 방식으로 구현했다.\n  - \"0, 0, 0\" 인 경우와, 여러 반례에 막혔다..\n- 결국 참고 블로그를 통해 `compareTo()` 를 사용하는 방식을 사용했다.\n  - 숫자를 비교하는 경우와, 문자를 비교하는 경우마다 반환하는 `int` 값이 달랐고, 이를 잘 활용한 풀이인 것 같다.\n- `compareTo()`\n  - 숫자의 경우\n    - 기준값보다 비교대상이 큰 경우 : -1 반환\n    - 기준값보다 비교대상이 작은 경우 : 1 반환\n  - 문자의 경우\n    - 기준값에 비교대상이 포함되어 있는 경우 : 서로의 문자열 길이의 차이값 반환\n    - 기준값과 전혀 다른 문자열인 경우 : 비교가 불가능한 지점 문자의 아스키 코드 값 차이 반환\n  - 둘 다 같은 경우는 0 반환\n\n### 📕 출처\n- Programmers : https://programmers.co.kr/learn/courses/30/lessons/42746\n- [참고 블로그](https://hannamnote.tistory.com/82)\n- [compareTo()](https://mine-it-record.tistory.com/133)"},{"excerpt":"문제 스파이들은 매일 다른 옷을 조합하여 입어 자신을 위장합니다. 예를 들어 스파이가 가진 옷이 아래와 같고 오늘 스파이가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야 합니다. 종류\t이름\n얼굴\t동그란 안경, 검정 선글라스\n상의\t파란색 티셔츠\n하의\t청바지\n겉옷\t긴 코트 …","fields":{"slug":"/[Programmers]42578/"},"frontmatter":{"date":"April 13, 2022","title":"👩‍💻 42578. 위장","tags":["해시"]},"rawMarkdownBody":"\n## 문제\n스파이들은 매일 다른 옷을 조합하여 입어 자신을 위장합니다.\n\n예를 들어 스파이가 가진 옷이 아래와 같고 오늘 스파이가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야 합니다.\n\n종류\t이름\n얼굴\t동그란 안경, 검정 선글라스\n상의\t파란색 티셔츠\n하의\t청바지\n겉옷\t긴 코트\n\n스파이가 가진 의상들이 담긴 2차원 배열 `clothes` 가 주어질 때 서로 다른 옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- `clothes` 의 각 행은 [의상의 이름, 의상의 종류]로 이루어져 있습니다.\n- 스파이가 가진 의상의 수는 1개 이상 30개 이하입니다.\n- 같은 이름을 가진 의상은 존재하지 않습니다.\n- `clothes` 의 모든 원소는 문자열로 이루어져 있습니다.\n- 모든 문자열의 길이는 1 이상 20 이하인 자연수이고 알파벳 소문자 또는 '_' 로만 이루어져 있습니다.\n- 스파이는 하루에 최소 한 개의 의상은 입습니다.\n\n### 입출력 예\n|clothes|return|\n|:---:|:---:|\n|[[\"yellowhat\", \"headgear\"], [\"bluesunglasses\", \"eyewear\"], [\"green_turban\", \"headgear\"]]|5|\n|[[\"crowmask\", \"face\"], [\"bluesunglasses\", \"face\"], [\"smoky_makeup\", \"face\"]]|3|\n\n### 📍 **Logic**\n\n```java\nfor (String[] cloth : clothes) {\n    if (map.containsKey(cloth[1]))\n        map.put(cloth[1], map.get(cloth[1]) + 1);\n    else\n        map.put(cloth[1], 1);\n}\n```\n\n- 의상 종류를 `Key` 로, 해당 종류에 몇 가지의 의상이 존재하는지를 `value` 로 저장한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        public int solution(String[][] clothes) {\n            HashMap<String, Integer> map = new HashMap<>();\n            \n            for (String[] cloth : clothes) {\n                if (map.containsKey(cloth[1]))\n                    map.put(cloth[1], map.get(cloth[1]) + 1);\n                else\n                    map.put(cloth[1], 1);\n            }\n            \n            int answer = 1;\n            for (Map.Entry<String, Integer> entry : map.entrySet())\n                answer *= (entry.getValue() + 1);\n            \n            return answer - 1;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- `HashMap` 의 `Key` 와 `Value` 를 어떻게 활용할지는 떠올렸지만, 정답 도출을 위한 식을 모르겠어서 질문 게시판을 참고했다.\n- 단순한 조합식이긴 한데... 기억이 안 났다;\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/42578"},{"excerpt":"문제 수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다. 마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요. 제한사항 마라톤…","fields":{"slug":"/[Programmers]42576/"},"frontmatter":{"date":"April 13, 2022","title":"👩‍💻 42576. 완주하지 못한 선수","tags":["해시"]},"rawMarkdownBody":"\n## 문제\n수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.\n\n마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- 마라톤 경기에 참여한 선수의 수는 1명 이상 100,000명 이하입니다.\n- completion의 길이는 participant의 길이보다 1 작습니다.\n- 참가자의 이름은 1개 이상 20개 이하의 알파벳 소문자로 이루어져 있습니다.\n- 참가자 중에는 동명이인이 있을 수 있습니다.\n\n### 입출력 예\n|participant|completion|return|\n|:---:|:---:|:---:|:---:|\n|\"leo\", \"kiki\", \"eden\"|\"eden\", \"kiki\"|\"leo\"|\n|\"marina\", \"josipa\", \"nikola\", \"vinko\", \"filipa\"|\"josipa\", \"filipa\", \"marina\", \"nikola\"|\"vinko\"|\n|\"mislav\", \"stanko\", \"mislav\", \"ana\"|\"stanko\", \"ana\", \"mislav\"|\"mislav\"|\n\n### 📍 **Logic**\n\n```java\nfor (String p : participant)\n    map.put(p, map.getOrDefault(p, 0) + 1);\n\nfor (String c : completion)\n    map.put(c, map.get(c) - 1);\n\nfor (Map.Entry<String, Integer> entry : map.entrySet())\n    if (entry.getValue() != 0) answer = entry.getKey();\n```\n\n- 먼저 `participant` 에 있는 이름을 `HashMap` 에 `put` 하는데, `getOrDefault()` 메소드로 해당 이름이 이미 있는지 확인하여 있다면, 그 이름에 해당하는 `value` 에 + 1 하여 저장한다.\n- 이후 `completion` 에 있는 이름으로 다시 `HashMap` 을 수정하는데, 이미 있는 이름에 - 1 한 값으로 업데이트한다.\n- 최종적으로 `value` 가 0이 아닌 이름이 완주하지 못한 선수가 된다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        public String solution(String[] participant, String[] completion) {\n            HashMap<String, Integer> map = new HashMap<>();\n            String answer = \"\";\n            \n            for (String p : participant)\n                map.put(p, map.getOrDefault(p, 0) + 1);\n            \n            for (String c : completion)\n                map.put(c, map.get(c) - 1);\n            \n            for (Map.Entry<String, Integer> entry : map.entrySet())\n                if (entry.getValue() != 0) answer = entry.getKey();\n    \n            return answer;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- `HashMap` 을 사용하여 `completion` 에 없는 이름을 출력해야 한다는 것은 알았지만, 해시 알고리즘을 처음 풀어봐서 어떻게 해야 효율적으로 구현할 수 있을지가 헷갈렸다.\n- 어떻게 했나 싶어서 블로그를 참고했는데 한 `HashMap` 에다가 넣으면서 value를 줄여주는 방법이 진짜 신기했다. \n\n### 📕 출처\n- Programmers : https://programmers.co.kr/learn/courses/30/lessons/42576\n- [참고 블로그](https://coding-grandpa.tistory.com/entry/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EC%99%84%EC%A3%BC%ED%95%98%EC%A7%80-%EB%AA%BB%ED%95%9C-%EC%84%A0%EC%88%98-%ED%95%B4%EC%8B%9C-Lv-1)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 💫 트랜잭션과 락 ➰ 트랜잭션과 격리 수준 트랜잭션은 ACID라 하는 원자성, 일관성, 격리성, 지속성을 보장해야 한다. 원자성(Atomicity): 트랜잭션 내에서 실행한 작업들은 하나의 작업인 것처럼 모두 성공하든가 실패해야 한다. 일관성(Consistency): …","fields":{"slug":"/[JPA]16/"},"frontmatter":{"date":"April 12, 2022","title":"📚 16. 트랜잭션과 락, 2차 캐시","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n## 💫 트랜잭션과 락\n### ➰ 트랜잭션과 격리 수준\n트랜잭션은 ACID라 하는 원자성, 일관성, 격리성, 지속성을 보장해야 한다.\n- **원자성**(Atomicity): 트랜잭션 내에서 실행한 작업들은 하나의 작업인 것처럼 모두 성공하든가 실패해야 한다.\n- **일관성**(Consistency): 모든 트랜잭션은 일관성있는 데이터베이스 상태를 유지해야 한다.\n- **격리성**(Isolation): 동시에 실행되는 트랜잭션들이 서로에게 영향을 미치지 않도록 격리한다. 격리성은 동시성과 관련된 성능 이슈로 인해 격리 수준을 선택할 수 있다.\n- **지속성**(Durability): 트랜잭션을 성공적으로 끝내면 그 결과가 항상 기록되어야 한다. 시스템에 문제가 발생해도 데이터베이스 로그 등을 사용해 성공한 트랜잭션 내용을 복구해야 한다.\n\n트랜잭션 간 격리성의 완벽 보장을 위해서는, 트랜잭션을 거의 차례대로 실행해야 한다.\n- 하지만 이렇게 하면 동시성 처리 성능이 매우 나빠진다. 따라서 트랜잭션 표준을 4단계로 나눠 정의한다.\n\n**📌 트랜잭션 격리 수준**<br/>\n- READ UNCOMMITED(커밋되지 않은 읽기)\n- READ COMMITTED(커밋된 읽기)\n- REPEATABLE READ(반복 가능한 읽기)\n- SERIALIZABLE(직렬화 가능)\n\n순서대로 격리 수준이 높아진다. 낮을 수록 동시성은 증가하지만, 아래와 같은 문제점이 있다.\n\n|격리 수준|DIRTY READ|NON-REPEATABLE READ|PHANTOM READ|\n|:---:|:---:|:---:|:---:|\n|READ UNCOMMITED|O|O|O|\n|READ COMMITTED||O|O|\n|REPEATABLE READ|||O|\n|SERIALIZABLE||||\n\n**READ UNCOMMITED**\n- 커밋하지 않은 데이터를 읽을 수 있다. ex. 트랜잭션1이 데이터를 수정하고 있을 때, 커밋하지 않아도 트랜잭션2가 수정 중인 데이터를 조회할 수 있다.\n  - 이를 **DIRTY READ**라 한다.\n- 트랜잭션2가 DIRTY READ한 데이터를 사용하는데 트랜잭션1을 롤백하면 데이터 정합성에 심각한 문제가 발생할 수 있다.\n\n> DIRTY READ를 허용하는 격리 수준\n\n**READ COMMITTED**\n- 커밋한 데이터만 읽을 수 있다. 따라서 DIRTY READ는 발생하지 않는다.\n  - 하지만 NON-REPEATABLE READ는 발생할 수 있다. ex. 트랜잭션1이 회원 A를 조회 중인데, 갑자기 트랜잭션2가 회원 A를 수정하고 커밋하면 트랜잭션1이 다시 회원 A를 조회했을 때 수정된 데이터가 조회된다.\n  - 이처럼 반복해서 같은 데이터를 읽을 수 없는 상태를 **NON-REPEATABLE READ**라 한다.\n\n> DIRTY READ는 허용하지 않지만, NON-REPEATABLE READ는 허용하는 격리 수준\n\n**REPEATABLE READ**\n- 한 번 조회한 데이터를 반복해서 조회해도 같은 데이터가 조회된다. \n  - 하지만 PHANTOM READ는 발생할 수 있다. ex. 트랜잭션1이 10살 이하의 회원을 조회했는데 트랜잭션2가 5살 회원을 추가하고 커밋하면 트랜잭션1이 다시 10살 이하의 회원을 조회했을 때 회원 하나가 추가된 상태로 조회된다.\n  - 이처럼 반복 조회 시 결과 집합이 달라지는 것을 **PHANTOM READ**라 한다. (의도치 않게 예상한 결과와 다른 결과를 도출시킴)\n\n> NON-REPEATABLE READ는 허용하지 않지만, PHANTOM READ는 허용하는 격리 수준\n\n**SERIALIZABLE**\n- 가장 엄격한 트랜잭션 격리 수준이다. \n- PHANTOM READ는 발생하지 않지만, 동시성 처리 성능이 급격히 떨어질 수 있다.\n\n대부분의 애플리케이션들은 동시성 처리를 중요시하므로, 보통 **READ COMMITTED 격리 수준을 기본으로 사용**한다.\n\n### ➰ 낙관적 락과 비관적 락 기초\nJPA의 영속성 컨텍스트(1차 캐시)를 적절히 활용하여 데이터베이스 트랜잭션이 READ COMMITTED 격리 수준이어도 REPEATABLE READ가 가능하다.\n- 물론 엔티티가 아닌 스칼라 값을 직접 조회하면 영속성 컨텍스트의 관리를 받지 못하므로 불가능하다.\n\nJPA는 격리 수준을 READ COMMITTED로 가정한다. 더 높은 격리 수준이 필요한 경우 낙관적 락과 비관적 락 중 하나를 사용한다.\n\n**낙관적 락**\n- 트랜잭션 대부분은 충돌이 발생하지 않는다고 가정하는 방법이다.\n- 데이터베이스가 제공하는 락 기능을 사용하는 것이 아니라 JPA가 제공하는 버전 관리 기능을 사용한다.\n\n> 애플리케이션이 제공하는 락, 트랜잭션을 커밋하기 전까지는 트랜잭션의 충돌을 알 수 없다.\n\n**비관적 락**\n- 트랜잭션의 충돌이 발생한다고 가정하고 우선 락을 걸고 보는 방법이다.\n\n> 데이터베이스가 제공하는 락, `select for update` 가 대표적\n\n추가로 데이터베이스 트랜잭션 범위를 넘어서는 문제도 있다. \n- ex. 사용자 두 명이 동시에 제목이 같은 공지사항을 수정한다고 가정한다. 첫 번째 사용자가 먼저 수정완료 버튼을 누르고 두 번째 사용자가 수정완료 버튼을 누르면, 결과적으로 두 번째 수정사항만이 남게 된다.\n  - 이를 **두 번의 갱신 분실 문제**(second lost updates problem)라 한다.\n  - 이는 데이터베이스 트랜잭션의 범위를 넘어서므로, 트랜잭션만으로는 해결할 수 없어 아래 3가지 방법 중 선택해야 한다.\n\n1. **마지막 커밋만 인정하기**: 첫 번째 사용자의 내용은 무시하고, 마지막에 커밋한 사용자의 내용만을 인정한다.\n2. **최초 커밋만 인정하기**: 첫 번째 사용자가 이미 수정완료했으므로, 두 번째 사용자가 수정완료할 때 오류가 발생한다.\n3. **충돌하는 갱신 내용 병합하기**: 두 사용자의 수정사항을 병합한다.\n\n기본은 \"마지막 커밋만 인정하기\"이다.\n- JPA가 제공하는 버전 관리 기능을 사용하면 손쉽게 최초 커밋만 인정하기를 구현할 수 있다.\n\n### ➰ @Version\nJPA가 제공하는 낙관적 락을 사용하기 위해 `@Version` annotation을 사용해 버전 관리 기능을 추가해야 한다. `@Version` 적용 가능 타입은 아래와 같다.\n- `Long (long)`\n- `Integer (int)`\n- `Short (short)`\n- `Timestamp`\n\n엔티티에 버전 관리용 필드를 추가하고 해당 annotation을 붙여, 엔티티를 수정할 때마다 버전이 하나씩 자동으로 증가하게 된다.\n- 엔티티를 수정할 때, 조회 시점의 버전과 수정 시점의 버전이 다르면 예외가 발생한다.\n\n> 버전 정보를 사용하면 **최초 커밋만 인정하기**가 적용된다.\n\n**📌 버전 정보 비교 방법**<br/>\n엔티티를 수정하고 트랜잭션을 커밋하면 영속성 컨텍스트를 플러시하면서 UPDATE 쿼리를 실행한다.\n- 이때 버전을 사용하는 엔티티면 검색 조건에 엔티티의 버전 정보를 추가한다.\n- 데이터베이스 버전과 엔티티 버전이 같으면, 데이터를 수정하면서 동시에 버전도 하나 증가시킨다.\n  - 버전이 다르다면, 예외 발생!\n- **버전은 엔티티의 값을 변경하면 증가한다.**\n  - 그리고 값 타입인 임베디드 타입과 값 타입 컬렉션은 개념상 엔티티의 값이므로 이 또한 버전이 증가한다.\n  - 단 연관관계 필드는 외래 키를 관리하는 **연관관계의 주인 필드를 수정할 때만 버전이 증가**한다.\n\n> 벌크 연산은 버전을 무시한다. 버전 증가를 위해서는 버전 필드를 강제로 증가시켜야 한다.\n\n### ➰ JPA 락 사용\n> JPA 추천 전략은 READ COMMITTED 격리 수준 + 낙관적 버전 관리(두 번의 갱신 내역 분실 문제 예방)\n\n락은 다음 위치에 적용할 수 있다.\n- `EntityManager.lock()` , `EntityManager.find()` , `EntityManager.refresh()`\n- `Query.setLockMode()` (`TypedQuery`)\n- `@NamedQuery`\n- 조회하면서 즉시 락을 걸 수도 있고, 필요할 때 락을 걸 수 있다.\n\n> JPA가 제공하는 락 옵션은 `javax.persistence.LockModeType` 에 정의되어 있다.\n\n### ➰ JPA 낙관적 락\nJPA가 제공하는 낙관적 락은 버전(`@Version`)을 사용한다.\n- 낙관적 락은 트랜잭션을 커밋하는 시점에 충돌을 알 수 있다는 특징이 있다.\n- 발생하는 예외는 다음과 같다.\n  - `javax.persistence.OptimisticLockException` (JPA 예외)\n  - `org.hibernate.StaleObjectStateException` (Hibernate 예외)\n  - `org.springframework.orm.ObjectOptimisticLockingFailureException` (스프링 예외 추상화)\n\n> 락 옵션 없이 `@Version` 만 있어도 낙관적 락이 적용된다.\n\n**📌 NONE**<br/>\n락 옵션을 적용하지 않아도 엔티티에 `@Version` 이 적용된 필드만 있으면 낙관적 락이 적용된다.\n- 용도: 조회한 엔티티를 수정할 때 다른 트랜잭션에 의해 변경(삭제)되지 않아야 한다. 조회 시점부터 수정 시점까지를 보장한다.\n- 동작: 엔티티를 수정할 때 버전을 체크하면서 버전을 증가한다. 이때 버전이 다르면 예외가 발생한다.\n- 이점: 두 번의 갱신 분실 문제를 예방한다.\n\n**📌 OPTIMISTIC**<br/>\n`@Version` 만 적용하면 엔티티를 수정해야 버전을 체크하지만, 이 옵션을 추가하면 엔티티를 조회만 해도 버전을 체크한다.\n- 한 번 조회한 엔티티는 트랜잭션을 종료할 때까지 다른 트랜잭션에서 변경하지 않음을 보장한다.\n- 용도: 조회한 엔티티는 트랜잭션이 끝날 때까지 다른 트랜잭션에 의해 변경되지 않아야 한다. 조회 시점부터 트랜잭션 종료 시점까지 엔티티가 변경되지 않음을 보장한다.\n- 동작: 트랜잭션을 커밋할 때 버전 정보를 조회해서 현재 엔티티의 버전과 같은지 검증한다. 버전이 다르면 예외가 발생한다.\n- 이점: 해당 옵션은 DIRTY READ와 NON-REPEATABLE READ를 방지한다.\n\n**📌 OPTIMISTIC_FORCE_INCREMENT**<br/>\n낙관적 락을 사용하면서 버전 정보를 강제로 증가한다.\n- 용도: 논리적인 단위의 엔티티 묶음을 관리할 수 있다. 연관관계로 묶인 엔티티들에 대한 버전의 강제 증가를 수행한다.\n- 동작: 엔티티를 수정하지 않아도 트랜잭션을 커밋할 때 UPDATE 쿼리를 사용해서 버전 정보를 강제로 증가시킨다. 이때 버전이 다르면 예외가 발생한다.\n  - 추가로, 엔티티를 수정하면 버전 UPDATE가 발생하여, 총 2번의 버전 증가가 나타날 수 있다.\n- 이점: 논리적인 단위의 엔티티 묶음을 관리할 수 있다.\n\n### ➰ JPA 비관적 락\n데이터베이스 트랜잭션 락 메커니즘에 의존하는 방법이다.\n- 주로 SQL 쿼리에 `select for update` 구문을 사용하면서 시작하고, 버전 정보는 사용하지 않는다.\n- 주로 `PESSIMISTIC_WRITE` 모드를 사용한다.\n- 엔티티가 아닌 스칼라 타입 조회 시에도 사용할 수 있고, 데이터를 수정하는 즉시 트랜잭션 충돌을 감지할 수 있다.\n- 발생하는 예외는 다음과 같다.\n  - `javax.persistence.PessimisticLockException` (JPA 예외)\n  - `org.springframework.dao.PessimisticLockingFailureException` (스프링 예외 추상화)\n\n**📌 PESSIMISTIC_WRITE**<br/>\n일반적인 옵션으로 데이터베이스에 쓰기 락을 걸 때 사용한다.\n- 용도: 데이터베이스에 쓰기 락을 건다.\n- 동작: `select for update` 를 사용해서 락을 건다.\n- 이점: NON-REPEATABLE READ를 방지한다. 락이 걸린 로우는 다른 트랜잭션이 수정할 수 없다.\n\n**📌 PESSIMISTIC_READ**<br/>\n데이터를 반복 읽기만 하고 수정하는 않는 용도로 락을 걸 때 사용한다. \n- 데이터베이스 대부분은 방언에 의해 `PESSIMISTIC_WRITE` 로 동작한다.\n- MySQL: `lock in share mode`\n- PostgreSQL: `for share`\n\n**📌 PESSIMISTIC_FORCE_INCREMENT**<br/>\n유일하게 버전 정보를 사용한다. 버전 정보를 강제로 증가시킨다.\n- Hibernate는 `nowait` 를 지원하는 데이터베이스에 대해서 `for update nowait` 옵션을 적용한다.\n- `nowait` 를 지원하지 않으면 `for update` 가 사용된다.\n\n### ➰ 비관적 락과 타임아웃\n비관적 락을 사용하면 락을 획득할 때까지 트랜잭션이 대기한다.\n- 무한정 기다리지 않기 위해 타임아웃 시간을 줄 수 있다.\n- 타임아웃 시간동안 응답이 없으면 `javax.persistence.LockTimeoutException` 예외가 발생한다.\n\n---\n\n## 💫 2차 캐시\n### ➰ 1차 캐시와 2차 캐시\n조회한 데이터를 메모리에 캐시해서 데이터베이스 접근 횟수를 줄여 애플리케이션 성능을 획기적으로 개선할 수 있다. 영속성 컨텍스트 내부에는 **1차 캐시**가 있다. 많은 이점이 있지만, 일반적인 웹 애플리케이션 환경은 트랜잭션을 시작하고 종료할 때까지만 1차 캐시가 유효하다.\n- OSIV를 사용해도 클라이언트의 요청이 들어올 때부터 끝날 때까지만 유효하다.\n- 즉, 애플리케이션 전체로 봤을 때, 획기적이지 못하다.\n\nHibernate를 포함한 대부분의 JPA 구현체들은 애플리케이션 범위의 캐시를 지원하는데, 이를 **공유 캐시 또는 2차 캐시**라 한다.\n- 1차 캐시와 2차 캐시를 함께 사용한다.\n- 1차 캐시에 없으면 2차 캐시, 2차 캐시에 없으면 데이터베이스 조회하는 순이다.\n\n**📌 1차 캐시**<br/>\n영속성 컨텍스트 내부에 존재하는 캐시로, 엔티티 매니저로 조회하거나 변경하는 모든 엔티티는 1차 캐시에 저장된다. 트랜잭션을 커밋하거나 플러시를 호출하면 1차 캐시에 있는 엔티티의 변경 내역을 데이터베이스에 동기화한다.\n\n> 영속성 컨텍스트 자체가 사실상 1차 캐시다!\n\n다음은 1차 캐시의 동작 방식이다.\n1. 최초 조회할 때는 1차 캐시에 엔티티가 없으므로\n2. 데이터베이스에 엔티티를 조회해서\n3. 1차 캐시에 보관하고\n4. 1차 캐시에 보관한 결과를 반환한다.\n5. 이후 같은 엔티티를 조회하면 1차 캐시에 있는 엔티티를 그대로 반환한다.\n\n**1차 캐시의 특징**\n- 같은 엔티티가 있으면 해당 엔티티를 그대로 반환한다. 즉, 객체 동일성(`a==b`)을 보장한다.\n- 영속성 컨텍스트 범위의 캐시다.\n\n**📌 2차 캐시**<br/>\n애플리케이션 범위의 캐시다. 따라서 애플리케이션을 종료할 때까지 캐시가 유지된다.\n\n다음은 2차 캐시의 동작 방식이다.\n1. 영속성 컨텍스트는 엔티티가 필요하면 2차 캐시를 조회한다.\n2. 2차 캐시에 엔티티가 없으면 데이터베이스를 조회해서\n3. 결과를 2차 캐시에 보관한다.\n4. 2차 캐시는 자신이 보관하고 있는 엔티티를 복사해서 반환한다.\n5. 2차 캐시에 저장되어 있는 엔티티를 조회하면 복사본을 만들어 반환한다.\n\n2차 캐시는 동시성을 극대화하려고 캐시한 객체를 직접 반환하지 않고 복사본을 만들어 반환한다.\n- 캐시한 객체를 그대로 반환하면 여러 곳에서 같은 객체를 동시에 수정하는 문제가 발생할 수 있다. (이를 위해 락을 걸면 동시성 저하)\n\n**2차 캐시의 특징**\n- 영속성 유닛 범위의 캐시\n- 조회한 객체를 그대로 반환하지 않고 복사본을 반환\n- 데이터베이스 기본 키를 기준으로 캐시하지만 영속성 컨텍스트가 다르면 객체 동일성(`a==b`)을 보장하지 않는다.\n\n### ➰ JPA 2차 캐시 기능\n**📌 캐시 모드 설정**<br/>\n2차 캐시를 사용하려면 엔티티에 `javax.persistence.Cacheable` annotation을 사용한다. 이후, `persistence.xml` 에 `shared-cache-mode` 를 설정해 애플리케이션 전체에 캐시를 어떻게 적용할지 옵션을 설정해야 한다.\n\n```xml\n<bean id=\"entityManagerFactory\" class=\"org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean\">\n  <property name=\"sharedCacheMode\" value=\"ENABLE_SELECTIVE\" />\n  ...\n\n```\n\n**`SharedCacheMode` 캐시 모드 설정**\n|캐시 모드|설명|\n|:---:|:---:|\n|ALL|모든 엔티티를 캐시한다.|\n|NONE|캐시를 사용하지 않는다.|\n|**ENABLE_SELECTIVE**|**Cacheable(true)로 설정된 엔티티만 캐시를 적용한다.**|\n|DISABLE_SELECTIVE|모든 엔티티를 캐시하는데 Cacheable(false)로 명시된 엔티티는 캐시하지 않는다.|\n|UNSPECIFIED|JPA 구현체가 정의한 설정을 따른다.|\n\n**📌 캐시 조회, 저장 방식 설정**<br/>\n캐시를 무시하고 데이터베이스를 직접 조회하거나 캐시를 갱신하려면 캐시 조회 모드와 캐시 보관 모드를 사용하면 된다.\n\n```java\nem.setProperty(\"javax.persistence.cache.retrieveMode\", CacheRetrieveMode.BYPASS);\n```\n\n캐시 조회 모드나 보관 모드에 따라 사용할 프로퍼티와 옵션이 다르다.\n- `javax.persistence.cache.retrieveMode` : 캐시 조회 모드 프로퍼티 이름\n- `javax.persistence.cache.storeMode` : 캐시 보관 모드 프로퍼티 이름\n- `javax.persistence.cache.CacheRetrieveMode` : 캐시 조회 모드 설정 옵션 (USE, BYPASS)\n- `javax.persistence.cache.CacheStoreMode` : 캐시 보관 모드 설정 옵션 (USE, BYPASS, REFRESH)\n\n**캐시 조회 모드 옵션**\n- USE : 캐시에서 조회, 기본 값\n- BYPASS : 캐시를 무시하고 데이터베이스에 직접 접근\n\n**캐시 보관 모드 옵션**\n- USE : 조회한 데이터를 캐시에 저장, 이미 존재한다면 갱신하지 않는다. 트랜잭션을 커밋하면 등록 수정한 엔티티도 캐시에 저장, 기본 값\n- BYPASS : 캐시에 저장하지 않는다.\n- REFRESH : USE 전략에 추가로 데이터베이스에서 조회한 엔티티를 최신 상태로 다시 캐시\n\n**📌 JPA 캐시 관리 API**<br/>\nJPA는 캐시를 관리하기 위한 `Cache` interface를 제공한다.\n\n```java\nCache cache = emf.getCache();\nboolean contains = cache.contains(TestEntity.class, testEntity.getId());\nSystem.out.println(\"contains = \" + contains);\n```\n\n### ➰ Hibernate와 EHCACHE 적용\nHibernate가 지원하는 캐시는 크게 3가지가 있다.\n\n1. **엔티티 캐시** : 엔티티 단위로 캐시한다. 식별자로 엔티티를 조회하거나 컬렉션이 아닌 연관된 엔티티를 로딩할 때 사용한다.\n2. **컬렉션 캐시** : 엔티티와 연관된 컬렉션을 캐시한다. **컬렉션이 엔티티를 담고 있으면 식별자 값만 캐시한다.**\n3. **쿼리 캐시** : 쿼리와 파라미터 정보를 키로 사용해서 캐시한다. **결과가 엔티티면 식별자 값만 캐시한다.**\n\n**📌 환경 설정**<br/>\nHibernate에서 EHCACHE를 사용하려면 `pom.xml` 에 `hibernate-ehcache` 라이브러리를 추가한다.\n- 이를 추가하면 `net.sf.ehcache-core` 라이브러리도 추가된다.\n- EHCACHE는 `ehcache.xml` 을 설정 파일로 사용한다.\n- 이후 Hibernate에 캐시 사용정보를 설정하기 위해 `persistence.xml` 에 캐시 정보를 추가한다.\n\n**📌 엔티티 캐시와 컬렉션 캐시**<br/>\n- `javax.persistence.Cacheable` : 엔티티를 캐시하려면 해당 annotation을 적용한다.\n- `org.hibernate.annotations.Cache` : 해당 annotation은 Hibernate 전용이다. `usage` 속성을 이용해 캐시와 관련된 더 세밀한 설정을 할 때 사용한다.\n\n**📌 @Cache**<br/>\n세밀한 캐시 설정을 위해 사용한다.\n- usage : CacheConcurrencyStrategy를 사용해 캐시 동시성 전략을 설정한다.\n- region : 캐시 지역 설정\n- include : 연관 객체를 캐시에 포함할지 선택한다. all, non-lazy 옵션을 선택할 수 있다. (기본 값 all)\n\n가장 중요한 것은 캐시 동시성 전략을 설정하는 `usage` 속성이다.\n- NONE\n- READ_ONLY\n- NONSTRICT_READ_WRITE\n- READ_WRITE\n- TRANSACTIONAL\n\n**📌 캐시 영역**<br/>\n캐시를 적용한 코드는 아래 캐시 영역에 저장된다.\n- 엔티티 캐시 영역\n- 컬렉션 캐시 영역\n\n엔티티 캐시 영역은 기본값으로 [패키지 명 + 클래스 명]을 사용하고, 컬렉션 캐시 영역은 엔티티 캐시 영역 이름에 캐시한 컬렉션의 필드 명이 추가된다.\n- 영역별 세부 설정이 가능하다. `ehcache.xml` 에서 설정할 수 있다.\n\n**📌 쿼리 캐시**<br/>\n쿼리 캐시는 쿼리와 파라미터 정보를 키로 사용해 쿼리 결과를 캐시하는 방법이다.\n- 적용하기 위해 영속성 유닛을 설정에 `hibernate.cache.use_query_cache` 옵션을 꼭 `true` 로 설정해야 한다.\n- 이후 쿼리 캐시를 적용할 쿼리에 `org.hibernate.cacheable` 을 `true` 로 설정하는 힌트를 준다.\n\n**📌 쿼리 캐시 영역**<br/>\n쿼리 캐시를 활성화하면 다음 두 캐시 영역이 추가된다.\n- `org.hibernate.cache.internal.StandardQueryCache` : 쿼리 캐시를 저장하는 영역이다. 쿼리, 쿼리 결과 집합, 쿼리를 실행한 시점의 타임스탬프를 보관한다.\n- `org.hibernate.cache.spi.UpdateTimestampsCache` : 쿼리 캐시가 유효한지 확인하기 위해 쿼리 대상 테이블의 가장 최근 변경 시간을 저장하는 영역이다. 테이블 명과 해당 테이블의 최근 변경된 타임스탬프를 보관한다.\n\n쿼리 캐시를 적용하고 난 후 쿼리 캐시가 사용하는 테이블에 조금이라도 변경이 있으면 데이터베이스에서 데이터를 읽어와 쿼리 결과를 다시 캐시한다. 이를 잘 활용하면 극적인 성능 향상이 있지만, 빈번히 변경이 발생하는 테이블에는 적절하지 않다.\n\n**📌 쿼리 캐시와 컬렉션 캐시의 주의점**<br/>\n쿼리 캐시와 컬렉션 캐시는 집합의 식별자 값만을 캐시한다.\n- 쿼리 캐시나 컬렉션 캐시만 사용하고 대상 엔티티에 엔티티 캐시를 적용하지 않으면 성능상 문제가 발생할 수 있다.\n\n1. `select m from Member m` 쿼리를 실행했는데 쿼리 캐시가 적용되어 있다. 결과 집합은 100건이다.\n2. 결과 집합에는 식별자만 있으므로 한 건씩 엔티티 캐시 영역에서 조회한다.\n3. `Member` 엔티티는 엔티티 캐시를 사용하지 않으므로 한 건씩 데이터베이스에서 조회한다.\n4. 결국 100건의 SQL이 실행된다.\n\n결과적으로 최악의 경우 결과 집합 수만큼의 SQL을 실행하게 된다.\n\n> **쿼리 캐시나 컬렉션 캐시를 사용하면 결과 대상 엔티티에는 꼭 엔티티 캐시를 적용해야 한다.**\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"문제 두 개의 단어 begin, target과 단어의 집합 words가 있습니다. 아래와 같은 규칙을 이용하여 begin에서 target으로 변환하는 가장 짧은 변환 과정을 찾으려고 합니다. 한 번에 한 개의 알파벳만 바꿀 수 있습니다. words에 있는 단어로만 변환할 수 있습니다. 예를 들어 begin이 \"hit\", target가 \"cog\", word…","fields":{"slug":"/[Programmers]43163/"},"frontmatter":{"date":"April 12, 2022","title":"👩‍💻 43163. 단어 변환","tags":["DFS","BFS"]},"rawMarkdownBody":"\n## 문제\n두 개의 단어 begin, target과 단어의 집합 words가 있습니다. 아래와 같은 규칙을 이용하여 begin에서 target으로 변환하는 가장 짧은 변환 과정을 찾으려고 합니다.\n\n1. 한 번에 한 개의 알파벳만 바꿀 수 있습니다.\n2. words에 있는 단어로만 변환할 수 있습니다.\n\n예를 들어 begin이 \"hit\", target가 \"cog\", words가 [\"hot\",\"dot\",\"dog\",\"lot\",\"log\",\"cog\"]라면 \"hit\" -> \"hot\" -> \"dot\" -> \"dog\" -> \"cog\"와 같이 4단계를 거쳐 변환할 수 있습니다.\n\n두 개의 단어 begin, target과 단어의 집합 words가 매개변수로 주어질 때, 최소 몇 단계의 과정을 거쳐 begin을 target으로 변환할 수 있는지 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- 각 단어는 알파벳 소문자로만 이루어져 있습니다.\n- 각 단어의 길이는 3 이상 10 이하이며 모든 단어의 길이는 같습니다.\n- words에는 3개 이상 50개 이하의 단어가 있으며 중복되는 단어는 없습니다.\n- begin과 target은 같지 않습니다.\n- 변환할 수 없는 경우에는 0를 return 합니다.\n\n### 입출력 예\n|begin|target|words|return|\n|:---:|:---:|:---:|:---:|\n|\"hit\"|\"cog\"|[\"hot\", \"dot\", \"dog\", \"lot\", \"log\", \"cog\"]|4|\n|\"hit\"|\"cog\"|[\"hot\", \"dot\", \"dog\", \"lot\", \"log\"]|0|\n\n### 📍 **Logic**\n\n```java\nprivate int dfs(String begin, String target, String[] words, boolean[] visited, int count, int idx) {\n    if (begin.equals(target) || visited[idx]) return count;\n    \n    visited[idx] = true;\n    int ans = 0;\n    \n    for (int i = 0; i < words.length; i++) {\n        if (idx != i && !visited[i] && isOneCharDiff(begin, words[i]))\n            ans = dfs(words[i], target, words, visited, count + 1, i);\n    }\n    \n    return ans;\n}\n```\n\n- 재귀적인 DFS를 이용해 현재 단어와 한 문자만 다른 단어로 변환을 수행한다.\n  - 이때 지금까지의 변환된 수(`count`)를 함께 전달한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        public int solution(String begin, String target, String[] words) {\n            boolean[] visited;\n            int answer = words.length + 1;\n            \n            for (int i = 0; i < words.length; i++) {\n                visited = new boolean[words.length];\n                if (isOneCharDiff(begin, words[i]))\n                    answer = Math.min(answer, dfs(words[i], target, words, visited, 1, i));\n            }\n            \n            if (answer == words.length + 1) return 0;\n                \n            return answer;\n        }\n        \n        private int dfs(String begin, String target, String[] words, boolean[] visited, int count, int idx) {\n            if (begin.equals(target) || visited[idx]) return count;\n            \n            visited[idx] = true;\n            int ans = 0;\n            \n            for (int i = 0; i < words.length; i++) {\n                if (idx != i && !visited[i] && isOneCharDiff(begin, words[i]))\n                    ans = dfs(words[i], target, words, visited, count + 1, i);\n            }\n            \n            return ans;\n        }\n        \n        private boolean isOneCharDiff(String str1, String str2) {\n            int count = 0;\n            \n            for (int i = 0; i < str1.length() && count < 2; i++)\n                if (str1.charAt(i) != str2.charAt(i)) count++;\n            \n            return count == 1;\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 단어별 다른 문자 수를 그래프 형태로 변환해 저장하고 이를 BFS 방식으로 접근하도록 구현했는데, 방법 자체가 잘못 된 것 같았다.\n- 한 문자만 다른 단어로 변환할 수 있기에 굳이 단어별 다른 문자 수를 구할 필요가 없었고 DFS를 이용하는 방법을 참고했다.\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/43163"},{"excerpt":"문제 n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 1, 1, 1, 1, 1로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다. -1+1+1+1+1 = 3\n+1-1+1+1+1 = 3\n+1+1-1+1+1 = 3\n+1+1+1-1+1 = 3\n+1+1+1+1-1 = 3 사…","fields":{"slug":"/[Programmers]43165/"},"frontmatter":{"date":"April 11, 2022","title":"👩‍💻 43165. 타겟 넘버","tags":["DFS","BFS"]},"rawMarkdownBody":"\n## 문제\nn개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.\n\n-1+1+1+1+1 = 3\n+1-1+1+1+1 = 3\n+1+1-1+1+1 = 3\n+1+1+1-1+1 = 3\n+1+1+1+1-1 = 3\n\n사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.\n\n### 제한사항\n- 주어지는 숫자의 개수는 2개 이상 20개 이하입니다.\n- 각 숫자는 1 이상 50 이하인 자연수입니다.\n- 타겟 넘버는 1 이상 1000 이하인 자연수입니다.\n\n### 입출력 예\n|numbers|target|return|\n|:---:|:---:|:---:|\n|[1, 1, 1, 1, 1]|3|5|\n|[4, 1, 2, 1]|4|2|\n\n### 📍 **Logic**\n\n```java\nprivate void dfs(int[] numbers, int idx, int target, int sum) {\n    if (idx + 1 == numbers.length) {\n        if (sum == target) answer++;\n        return;\n    }\n    dfs(numbers, idx + 1, target, sum + numbers[idx + 1]);\n    dfs(numbers, idx + 1, target, sum - numbers[idx + 1]);\n}\n```\n\n- 재귀적인 DFS를 이용해 다음 number를 더하거나 빼면서 맨 마지막 값이 타겟 넘버와 같은 경우 answer를 증가한다.\n- 첫 번째 숫자가 양수인 경우와 음수인 경우 두 가지에 대해 dfs를 호출한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Solution {\n        static int answer = 0;\n        \n        public int solution(int[] numbers, int target) {\n            dfs(numbers, 0, target, numbers[0]);\n            return answer;\n        }\n        \n        private void dfs(int[] numbers, int idx, int target, int sum) {\n            if (idx + 1 == numbers.length) {\n                if (sum == target) answer++;\n                return;\n            }\n            dfs(numbers, idx + 1, target, sum + numbers[idx + 1]);\n            dfs(numbers, idx + 1, target, sum - numbers[idx + 1]);\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 트리를 만들어서 맨 마지막 리프 노드가 타겟 넘버랑 같은 경우의 수를 체크해야하나 생각했다.\n- 이전에 DFS 문제를 풀 때 뭔가 재귀 호출을 이용한 DFS로 비슷한 문제를 풀었던 것이 생각나 구현해보니 정답이었다.\n- 쓸데없이 트리를 구현할 뻔 했다.\n\n### 📕 출처\nProgrammers : https://programmers.co.kr/learn/courses/30/lessons/43165"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 💫 예외 처리 ➰ JPA 표준 예외 정리 JPA 표준 예외들은  의 자식 클래스다. 그리고 이 예외 클래스는  의 자식이다. 따라서 JPA 예외는 모두 언체크 예외다. (명시적으로 예외 처리를 강제하지 않는 예외) JPA 표준 예외는 크게 2가지로 나눌 수 있다. 트랜…","fields":{"slug":"/[JPA]15/"},"frontmatter":{"date":"April 10, 2022","title":"📚 15. 고급 주제와 성능 최적화","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n## 💫 예외 처리\n### ➰ JPA 표준 예외 정리\nJPA 표준 예외들은 `javax.persistence.PersistenceException` 의 자식 클래스다. 그리고 이 예외 클래스는 `RuntimeException` 의 자식이다.\n- 따라서 JPA 예외는 모두 **언체크 예외**다. (명시적으로 예외 처리를 강제하지 않는 예외)\n\nJPA 표준 예외는 크게 2가지로 나눌 수 있다.\n- **트랜잭션 롤백을 표시하는 예외**\n  - 심각한 예외로, 복구해선 안된다.\n  - 트랜잭션을 강제로 커밋해도 수행되지 않고, `RollbackException` 예외가 발생한다.\n\n|트랜잭션 롤백을 표시하는 예외|\n|:---:|\n|`javax.persistence.EntityExistsException`|\n|`javax.persistence.EntityNotFoundException`|\n|`javax.persistence.OptimisticLockException`|\n|`javax.persistence.PessimisticLockException`|\n|`javax.persistence.RollbackException`|\n|`javax.persistence.TransactionRequiredException`|\n\n- **트랜잭션 롤백을 표시하지 않는 예외**\n  - 심각하지 않은 예외로, 개발자에게 트랜잭션 커밋 여부가 달려있다.\n\n|트랜잭션 롤백을 표시하지 않는 예외|\n|:---:|\n|`javax.persistence.NoResultException`|\n|`javax.persistence.NonUniqueResultException`|\n|`javax.persistence.LockTimeoutException`|\n|`javax.persistence.QueryTimeoutException`|\n\n### ➰ 스프링 프레임워크의 JPA 예외 변환\n\"서비스 계층에서 데이터 접근 계층의 구현 기술에 직접 의존하는 것은 좋은 설계라 할 수 없다.\"\n- 예외 또한 마찬가지이다. \n- 스프링 프레임워크는 데이터 접근 계층에 대한 예외를 추상화해서 개발자에게 제공한다.\n\n|JPA 예외|스프링 변환 예외|\n|`javax.persistence.PersistenceException`|`org.springframework.orm.jpa.JpaSystemException`|\n|`javax.persistence.NoResultException`|`org.springframework.dao.EmptyResultDataAccessException`|\n|`javax.persistence.NonUniqueResultException`|`org.springframework.dao.IncorrectResultSizeDataAccessException`|\n|`javax.persistence.LockTimeoutException`|`org.springframework.dao.CannotAcquireLockException`|\n|`javax.persistence.QueryTimeoutException`|`org.springframework.dao.QueryTimeoutException`|\n|`javax.persistence.EntityExistsException`|`org.springframework.dao.DataIntegrityViolationException`|\n|`javax.persistence.EntityNotFoundException`|`org.springframework.orm.jpa.JpaObjectRetrievalFailureException`|\n|`javax.persistence.OptimisticLockException`|`org.springframework.orm.jpa.JpaOptimisticLockingFailureException`|\n|`javax.persistence.PessimisticLockException`|`org.springframework.dao.PessimisticLockingFailureException`|\n|`javax.persistence.TransactionRequiredException`|`org.springframework.dao.InvalidDataAccessApiUsageException`|\n|`javax.persistence.RollbackException`|`org.springframework.transaction.TranscationSystemException`|\n\n### ➰ 스프링 프레임워크에 JPA 예외 변환기 적용\n추상화된 예외로의 변경을 위해서는 `PersistenceExceptionTranslationPostProcessor` 를 스프링 빈으로 등록해야 한다.\n- `@Repository` annotation이 사용된 곳에 예외 변환 AOP를 적용해서 JPA 예외를 스프링 프레임워크가 추상화한 예외로 변환해준다.\n\n`getSingleResult()` 메소드를 사용하는 `@Repository` 클래스가 있다고 가정하자.\n- 이 메소드는 조회된 결과가 없으면 `javax.persistence.NoResultException` 이 발생한다.\n- 이 예외가 `getSingleResult()` 를 사용하는 메소드를 빠져 나갈 때, **등록한 AOP 인터셉터가 동작해 해당 예외를 변환해서 반환**한다.\n  - 따라서, 요청자는 스프링 프레임워크가 추상화한 예외를 받게 된다.\n- 만약 변환하고 싶지 않다면, `throws` 절에 그대로 반환할 JPA 예외나, JPA 예외의 부모 클래스를 직접 명시한다.\n\n### ➰ 트랜잭션 롤백 시 주의사항\n트랜잭션을 롤백하는 것은 데이터베이스의 반영사항만 롤백하는 것이지 수정한 자바 객체까지 원상태로 복구해주지는 않는다.\n- 즉, 객체는 수정된 채로 영속성 컨텍스트에 남아 있다. 트랜잭션이 롤백된 영속성 컨텍스트를 그대로 사용하는 것은 위험하다!\n\n> 새로운 영속성 컨텍스트를 생성해서 사용하거나, `em.clear()` 를 호출해 영속성 컨텍스트를 초기화한 후 사용해야 한다!\n\n스프링 프레임워크의 영속성 컨텍스트 기존 전략인 트랜잭션당 영속성 컨텍스트 전략은 문제가 발생하면 트랜잭션 AOP 종료 시점에 트랜잭션을 롤백하면서 영속성 컨텍스트로 함께 종료하여 문제가 발생하지 않는다.\n\n문제는 OSIV처럼 영속성 컨텍스트의 범위가 더 넓어 **여러 트랜잭션이 하나의 영속성 컨텍스트를 사용할 때 발생**한다.\n- 트랜잭션을 롤백해서 영속성 컨텍스트에 이상이 발생해도 다른 트랜잭션에서 해당 영속성 컨텍스트를 그대로 사용하기 때문이다.\n- 스프링 프레임워크는 영속성 컨텍스트의 범위를 트랜잭션의 범위보다 넓게 설정하면 트랜잭션 롤백 시 영속성 컨텍스트를 초기화(`em.clear()`)해서 잘못된 영속성 컨텍스트를 사용하지 않도록 방지한다.\n\n---\n\n## 💫 엔티티 비교\n영속성 컨텍스트 내부에는 엔티티 인스턴스를 보관하기 위한 1차 캐시가 있다. 이는 영속성 컨텍스트와 생명주기를 같이 한다.\n- 이 1차 캐시를 이용해 변경 감지 기능도 동작하고, 데이터베이스를 통하지 않고 데이터를 바로 조회할 수도 있다.\n- 가장 큰 장점으로는 **애플리케이션 수준의 반복 가능한 읽기**가 있다.\n  - 같은 영속성 컨텍스트에서 엔티티를 조회하면 항상 같은 엔티티 인스턴스를 반환한다.\n  - 이는 단순한 동등성 비교 수준이 아닌 정말 **주소값이 같은 인스턴스를 반환**한다.\n\n### ➰ 영속성 컨텍스트가 같을 때 엔티티 비교\n회원가입 테스트 케이스를 예로 사용해보자. \n- 먼저, 해당 테스트는 `@Transcational` annotation을 사용해 트랜잭션 안에서 테스트를 시작하여 테스트의 범위와 트랜잭션의 범위가 같다. 따라서, 테스트 전체에서 동일한 영속성 컨텍스트에 접근한다.\n  - 회원을 생성하고, 영속성 컨텍스트에 저장한다.\n  - 그리고 저장된 회원을 찾아서 저장한 회원과 비교한다.\n  - **이 둘은 완전히 같은 인스턴스**이다. \n\n> 같은 트랜잭션 범위에 있어 같은 영속성 컨텍스트를 사용하기 때문이다.\n\n영속성 컨텍스트가 같으면, 엔티티를 비교할 때 다음 3가지 조건을 모두 만족한다.\n- 동일성(`identical`) : == 비교가 같다.\n- 동등성(`equinalent`) : `equals()` 비교가 같다.\n- 데이터베이스 동등성 : `@Id` 인 데이터베이스 식별자가 같다.\n\n> 테스트에도 `@Transcational` 이 있고, 서비스에도 `@Transcational` 가 있다. 기본 전략은 먼저 시작된 트랜잭션이 있으면 그대로 이어 받아 사용하고, 없으면 새로 시작하는 것이다. <br/>\n> 다른 전략을 사용하려면 `@Transcational(propagation = Propagation.***)` 으로 변경하면 된다.\n\n> 테스트 클래스에 `@Transcational` 를 적용하면 테스트가 끝날 때 트랜잭션 커밋없이 강제로 롤백한다. 데이터베이스에 영향 없이 테스트를 반복적으로 수행하기 위함이다. \n> - 문제는 롤백 시 영속성 컨텍스트를 플러시하지 않아 플러시 시점에 어떤 SQL이 실행되는지 로그를 확인할 수 없다는 것이다. 이를 위해서는 테스트 마지막에 `em.flush()` 로 영속성 컨텍스트를 강제로 플러시하면 된다.\n\n### ➰ 영속성 컨텍스트가 다를 때 엔티티 비교\n테스트 클래스에 `@Transactional` 이 없고, 서비스에만 있다면 서비스와 레포지토리에서만 트랜잭션과 영속성 컨텍스트가 살아있다.\n- 즉, 테스트에서는 준영속 상태이다!\n- 테스트는 실패하게 된다!\n\n1. 테스트 코드에서 서비스 계층의 메소드를 호출해 회원가입 기능을 시도하면, 서비스 계층에서 트랜잭션이 시작되고, \"영속성 컨텍스트 1\"이 생성된다.\n2. 레포지토리에서 `em.persist()` 를 호출해서 `member` 엔티티를 영속화한다.\n3. 서비스 계층이 끝날 때 트랜잭션이 커밋되면서 영속성 컨텍스트가 플러시된다. 이때 트랜잭션과 영속성 컨텍스트 1이 종료된다. 따라서 `member` 엔티티 인스턴스는 준영속 상태가 된다.\n4. 테스트 코드에서 레포지토리의 메소드를 호출해 저장한 엔티티를 조회하면 레포지토리 계층에서 새로운 트랜잭션이 시작되면서 새로운 \"영속성 컨텍스트 2\"가 생성된다.\n5. 저장된 회원을 조회하지만, 새로 생성된 영속성 컨텍스트 2에는 찾는 회원이 존재하지 않는다. 따라서 데이터베이스에서 회원을 찾아온다.\n6. 데이터베이스에서 조회된 회원 엔티티를 영속성 컨텍스트에 보관하고 반환한다.\n7. 호출한 메소드가 종료되면서 트랜잭션이 종료되고 영속성 컨텍스트 2가 종료된다.\n\n각각 다른 영속성 컨텍스트에서 관리되었기 때문에 등록하고, 조회한 엔티티들은 서로 다른 인스턴스이다!\n- 즉 `assertTrue(member == findMember)` 는 실패한다.\n- 인스턴스는 다르지만 사실 같은 데이터베이스 로우를 가르키고 있어 같은 엔티티로 보아야 한다.\n\n동일성 비교가 아닌 동등성 비교를 수행해보자.\n\n```java\nmember.getId().equals(findMember.getId())\n```\n\n하지만 동등성 비교는 엔티티를 영속화해야 식별자를 얻을 수 있다는 문제가 있다. \n- 엔티티를 영속화하기 전에는 식별자 값이 `null` 이므로 정확한 비교를 할 수 없다. \n- 물론 식별자 값을 직접 부여하는 방식을 사용할 때는 데이터베이스 식별자 비교도 가능하다. 하지만 항상 식별자를 먼저 부여하는 것을 보장하기는 쉽지 않다.\n\n**\"엔티티를 비교할 때는 비즈니스 키를 활용한 동등성 비교를 권장한다.\"**\n- `equals()` 메소드를 오버라이딩하여 비즈니스 키가 되는 필드들을 선택한다. \n\n---\n\n## 💫 프록시 심화 주제\n프록시는 원본 엔티티를 상속받아 만들어지므로 엔티티를 사용하는 클라이언트 입장에는 이를 구분하지 않고 사용할 수 있다.\n\n### ➰ 영속성 컨텍스트와 프록시\n영속성 컨텍스트는 자신이 관리하는 영속 엔티티의 동일성을 보장한다. \n- 프록시 엔티티와 원본 엔티티를 조회하면 둘은 서로 다른 인스턴스로 생각할 수 있지만, 이렇게 되면 영속성 컨텍스트가 영속 엔티티의 동일성을 보장하지 못하는 문제가 발생한다.\n\n따라서 영속성 컨텍스트는 프록시로 조회된 엔티티에 대해서 같은 엔티티를 찾는 요청이 오면, 원본 엔티티가 아닌 처음 조회된 프록시를 반환한다. 이를 통해 영속 엔티티의 동일성을 보장한다.\n- 반대로 원본 엔티티를 먼저 조회하면, 프록시를 반환할 이유 없이 원본을 반환한다.\n\n### ➰ 프록시 타입 비교\n프록시로 조회한 엔티티의 타입을 비교할 때는 `==` 비교가 아닌 `instanceof` 를 사용해야 한다.\n- 프록시는 원본 엔티티의 자식 타입이므로 `instanceof` 연산을 사용하면 된다.\n\n### ➰ 프록시 동등성 비교\n엔티티의 동등성을 비교하려면 비즈니스 키를 사용해 `equals()` 메소드를 오버라이딩하고 비교하면 된다.\n- 하지만 IDE나 외부 라이브러리를 사용해서 구현한 `equals()` 메소드로 엔티티를 비교할 때, 비교 대상이 원본 엔티티면 문제가 없지만, 프록시면 문제가 발생할 수 있다.\n\n프록시와 `equals()` 비교를 할 때는 몇 가지 주의점이 있다.\n- 프록시의 멤버변수에 직접 접근하는 경우, `equals()` 메소드를 구현할 때는 일반적으로 멤버변수를 직접 비교하는데, 프록시의 경우는 문제가 된다.\n  - 왜냐면 프록시는 실제 데이터를 가지고 있지 않기 때문에 아무 값도 조회할 수 없는 것이다.\n- 멤버변수를 `private` 으로 선언해 일반적인 상황에서는 프록시의 멤버변수에 직접 접근하는 문제가 발생하진 않지만, `equals()` 메소드는 자신을 비교하기 때문에 `private` 멤버변수에도 접근할 수 있다.\n\n\"프록시의 데이터를 조회할 때는 접근자(Getter)를 사용해야 한다.\"\n\n> - 프록시 타입 비교는 `==` 비교 대신, `instanceof` 를 사용해야 한다.\n> - 프록시의 멤버변수에 직접 접근하면 안되고, 접근자 메소드를 사용해야 한다.\n\n### ➰ 상속관계와 프록시\n상속관계를 프록시로 조회할 때 발생할 수 있는 문제점으로, **프록시를 부모 타입으로 조회하면 문제가 발생**한다.\n\n```java\n@Test\npublic void 부모타입으로_프록시조회() {\n\t//테스트 데이터 준비\n\tBook saveBook = new Book();\n\tsaveBook.setName(\"jpaBook\");\n\tsaveBook.setAuthor(\"kim\");\n\tem.persist(saveBook);\n\n\tem.flush();\n\tem.clear();\n\n\t//테스트 시작\n\tItem proxyItem = em.getReference(Item.class, saveBook.getId());\n\tSystem.out.println(\"proxyItem = \" + proxyItem.getClass());\n\n\tif (proxyItem instanceof Book) {\n\t\tSystem.out.println(\"proxyItem instanceof Book\");\n\t\tBook book = (Book) proxyItem;\n\t\tSystem.out.println(\"책 저자 = \" + book.getAuthor());\n\t}\n\n  //결과 검증\n  Assert.assertFalse(proxyItem.getClass() == Book.class);\n  Assert.assertFalse(proxyItem instanceof Book);\n  Assert.assertTrue(proxyItem instanceof Item);\n}\n```\n- 엔티티를 프록시로 조회하면, 실제 조회된 엔티티는 해당 부모 엔티티이므로, 부모 엔티티 타입 기반 원본 엔티티 인스턴스가 생성된다.\n- 프록시는 자식 엔티티(조회하려는 엔티티)를 기반으로 만들어진다.\n\n따라서 프록시와 부모 타입은 관계가 없어 결과 검증이 실패한다.\n\n또한 **`instanceof` 연산을 사용할 수 없고**, **하위 타입으로 다운캐스팅을 할 수 없다**는 문제가 있다.\n\n**📌 JPQL로 대상 직접 조회**<br/>\n가장 간단한 방법은 처음부터 자식 타입을 직접 조회해서 필요한 연산을 하는 것이다.\n- 이 방법을 사용하면 다형성을 활용할 수 없다.\n\n**📌 프록시 벗기기**<br/>\nHibernate가 제공하는 기능을 사용해 프록시에서 원본 엔티티를 가져온다.\n\n```java\n  ...\n\n  Item item = orderItem.getItem();\n  Item unProxyItem = unProxy(item);\n\n  if (unProxyItem instanceof Book) {\n    System.out.println(\"proxyItem instanceof Book\");\n    Book book = (Book) unProxyItem;\n    System.out.println(\"책 저자 = \" + book.getAuthor());\n  }\n\n  Assert.assertTrue(item != unProxyItem);\n}\n\n// Hibernate가 제공하는 프록시에서 원본 엔티티를 찾는 기능을 사용하는 메소드\npublic static <T> T unProxy(Object entity) {\n  if (entity instanceof HibernateProxy) {\n    entity = ((HibernateProxy) entity)\n              .getHibernateLazyInitializer()\n              .getImplementation();\n  }\n\n  return (T) entity;\n}\n```\n- 영속성 컨텍스트는 한 번 프록시로 노출한 엔티티는 계속 프록시로 노출한다. (영속 엔티티의 동일성 보장, 클라이언트는 프록시인지 아닌지 구분하지 않고 사용 가능)\n- 이 방법은 프록시에서 원본 엔티티를 직접 꺼내 **프록시와 원본 엔티티의 동일성 비교가 실패**한다는 문제점이 있다.\n\n**📌 기능을 위한 별도의 인터페이스 제공**<br/>\n<img src=\"https://leejaedoo.github.io/assets/img/proxy3.jpeg\" width=\"40%\">\n```java\npublic interface TitleView {\n  String getTitle();\n}\n```\n- 특정 기능을 제공하는 인터페이스를 정의한다.\n- 자식 클래스들은 인터페이스의 `getTitle()` 메소드를 각각 구현한다.\n  - 구현체에 따라 각각 다른 `getTitle()` 메소드가 호출될 것이다.\n\n이는 다형성을 활용하는 좋은 방법이다. 또한, 클라이언트가 대상 객체가 프록시인지 아닌지 구분하지 않아도 된다.\n\n**📌 비지터 패턴 사용**<br/>\n<img src=\"https://leejaedoo.github.io/assets/img/visitor.jpg\" width=\"40%\">\n\n- 비지터 패턴은 `Visitor` 와 이를 받아들이는 대상 클래스로 구분된다.\n  - 여기서 `Item` 은 비지터를 받아들이기만 하고, 실제 로직은 비지터가 처리한다.\n- `Visitor` 에는 `visit()` 라는 메소드를 정의하고, 모든 대상 클래스를 받아들이도록 작성한다.\n- 대상 클래스는 `accept(visitor)` 메소드를 추가해 비지터를 받아들일 수 있도록 한다. \n  - 단순히 파라미터로 넘어온 `Visitor` 의 `visit(this)` 메소드를 호출해 자신을 파라미터로 넘긴다. \n  - 따라서 **실제 로직 처리를 비지터에 위임**한다.\n\n비지터 패턴을 사용하면 \n- 프록시에 대한 걱정 없이 안전하게 원본 엔티티에 접근할 수 있고,\n- `instanceof` 나 타입 캐스팅 없이 코드를 구현할 수 있다.\n- 알고리즘과 객체 구조를 분리해 구조를 수정하지 않고 새로운 동작을 추가할 수 있다.\n\n하지만 단점으로는\n- 너무 복잡하고 더블 디스패치를 사용하기에 이해가 어렵다.\n- 객체 구조가 변경되면 모든 `Visitor` 를 수정해야 한다.\n\n> **더블 디스패치**는 다중 디스패치의 특수한 형태로, 호출에 관련된 두 객체의 런타임 유형에 따라 다른 구체적인 함수에 함수 호출을 보내는 메커니즘이다.\n\n---\n\n## 💫 성능 최적화\n### ➰ N + 1 문제\nJPA 개발 시 성능상 가장 주의해야 하는 문제이다.\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @OneToMany(mappedBy = \"member\", fetch = FetchType.EAGER)\n  private List<Order> orders = new ArrayList<>();\n  ...\n\n}\n```\n\n```java\n@Entity\n@Table(name = \"ORDERS\")\npublic class Order {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @ManyToOne\n  private Member member;\n  ...\n\n}\n```\n\n- 회원과 주문 정보는 1:N, N:1 양방향 연관관계다. 그리고 회원이 참조하는 주문정보를 즉시 로딩으로 설정했다.\n\n**📌 즉시 로딩과 N + 1**<br/>\n특정 회원 하나를 조회하면 즉시 로딩으로 설정한 주문 정보도 함께 조회한다.\n- SQL을 두 번 실행하는 것이 아닌 **조인을 사용해 한 번의 SQL**로 함께 조회한다.\n- 하지만 JPQL을 사용하게 되면, JPA는 이를 분석해 SQL을 생성한다. 이때는 즉시 로딩과 지연 로딩에 대해 고려하지 않고 오직 JPQL만 사용해 SQL을 생성한다. \n  - SQL의 결과로 먼저 회원 엔티티를 애플리케이션에 로딩한다.\n  - 이와 연관된 주문 컬렉션이 즉시 로딩이므로 JPA는 즉시 로딩을 위해 `ORDERS` 에 대한 SQL을 추가로 실행한다.\n  - 총 2번의 SQL을 실행하는데, 만약 조회된 회원이 여러 명인 경우 각 회원에 대해 2번씩 실행하게 된다. 이러한 문제를 **N + 1 문제**라 한다.\n\n**📌 지연 로딩과 N + 1**<br/>\n지연 로딩으로 설정하게 되면, JPQL에서는 N + 1 문제가 발생하지 않는다.\n- 문제는 모든 회원에 대해 연관된 엔티티를 사용할 때 발생한다.\n  - 연관된 엔티티를 초기화하는 수만큼 SQL이 실행될 수 있다. 결국 N + 1 문제가 발생하게 되고, 즉시 로딩과 지연 로딩 모두 발생할 수 있다.\n\n**📌 페치 조인 사용**<br/>\nN + 1 문제를 해결하는 가장 일반적인 방법이다. \n- SQL 조인을 사용해 연관된 엔티티를 함께 조회해 문제가 발생하지 않는다.\n\n**📌 Hibernate @BatchSize**<br/>\n`@BatchSize` annotation을 사용해 연관된 엔티티를 조회할 때 지정한 `size` 만큼 SQL의 IN 절을 사용해서 조회한다.\n- 만약 조회한 회원이 10명인데, `size=5` 로 지정하면 2번의 SQL만 추가로 실행한다.\n- 즉시 로딩의 경우, 조회 시점에 SQL이 2번 실행되고\n- 지연 로딩의 경우, 엔티티 최초 사용 시점에 1번의 SQL을 실행해 5건의 데이터를 로딩하고, 6번째 데이터 사용 시 1번의 SQL을 추가로 실행한다.\n\n**📌 Hibernate @Fetch(FetchMode.SUBSELECT)**<br/>\n`@Fetch` annotation에 `FetchMode` 를 `SUBSELECT` 로 사용하여 연관된 데이터를 조회할 때 서브 쿼리를 사용해 N + 1 문제를 해결할 수 있다.\n\n**📌 N + 1 정리**<br/>\n즉시 로딩이 아닌 지연 로딩을 사용하는 것을 추천한다. 성능 최적화가 필요한 곳에는 JPQL 페치 조인을 사용한다.\n\nJPA의 글로벌 페치 전략 기본값은 다음과 같다.\n- `@OneToOne` , `@ManyToOne` : 즉시 로딩\n- `@OneToMany` , `@ManyToMany` : 지연 로딩\n\n### ➰ 읽기 전용 쿼리의 성능 최적화\n엔티티가 영속성 컨텍스트에 관리되어 1차 캐시부터 변경 감지까지 여러 장점들이 있지만, 결국 더 많은 메모리를 사용한다는 단점이 있다.\n- 전체 구매 내용을 출력하는 단순한 조회 화면이 있다고 가정한다.\n  - 조회한 엔티티를 다시 조회할 일도 없고, 수정할 일도 없이 딱 1번만 읽어서 화면에 출력하면 된다.\n  - 읽기 전용으로 엔티티를 조회해 메모리 사용량을 최적화할 수 있다.\n\n다음 JPQL 쿼리를 최적화해보자.\n```sql\nselect o from Order o\n```\n\n**📌 스칼라 타입으로 조회**<br/>\n엔티티가 아닌 스칼라 타입으로 모든 필드를 조회하는 것이다.\n- 스칼라 타입은 영속성 컨텍스트가 결과를 관리하지 않는다.\n\n```sql\nselect o.id, o.name, o.price from Order p\n```\n\n**📌 읽기 전용 쿼리 힌트 사용**<br/>\nHibernate 전용 힌트인 `readOnly` 를 사용해 엔티티를 읽기 전용으로 조회한다.\n- 영속성 컨텍스트는 스냅샷을 보관하지 않아 메모리 사용량 최적화가 가능하다.\n- 단, 스냅샷이 없어지므로 변경 감지는 제공되지 않는다.\n\n```java\nTypedQuery<Order> query = em.createQuery(\"select o from Order o\", Order.class);\nquery.setHint(\"org.hibernate.readOnly\", true);\n```\n\n**📌 읽기 전용 트랜잭션 사용**<br/>\n트랜잭션에 `readOnly = true` 옵션을 사용해 Hibernate 세션의 플러시 모드를 MANUAL로 설정한다.\n- 강제로 플러시를 호출하지 않는 한 플러시가 발생하지 않는다.\n- 즉, 트랜잭션 커밋해도 영속성 컨텍스트를 플러시하지 않는다.\n\n**📌 트랜잭션 밖에서 읽기**<br/>\n트랜잭션 없이 엔티티를 조회한다는 의미이다. 물론 JPA에서 데이터를 변경하려면 트랜잭션은 필수다. \n- 조회가 목적일 때만 사용해야 한다.\n- 트랜잭션이 없으므로 플러시가 일어나지 않아 조회 성능을 향상시킬 수 있다.\n\n> 기본적으로 플러시 모드는 AUTO로 설정되어 있다. 따라서 트랜잭션을 커밋하거나 쿼리를 실행하면 플러시가 작동한다. \n> - 트랜잭션 자체가 없어지면 커밋할 일이 없다.\n> - 또한 JPQL 쿼리도 트랜잭션 없이 실행하면 플러시를 호출하지 않는다.\n\n> **읽기 전용 트랜잭션과 읽기 전용 쿼리 힌트를 동시에 사용하는 것이 가장 효과적이다!**\n\n### ➰ 배치 처리\n수 백만 건의 더ㅔ이터를 배치 처리해야 하는 상황에는 적절한 단위로 영속성 컨텍스트를 초기화해야 메모리 부족 오류가 발생하지 않을 것이다.\n\n**📌 JPA 등록 배치**<br/>\n반복문을 이용해 특정 개수의 엔티티 저장을 처리할 때마다 플러시를 호출하고, 영속성 컨텍스트를 초기화한다.\n\n수정 배치 처리는 2가지 방법을 주로 사용한다.\n- **페이징 처리**: 데이터베이스 페이징 기능을 사용한다.\n- **커서**: 데이터베이스가 지원하는 커서 기능을 사용한다.\n\n**📌 JPA 페이징 배치 처리**<br/>\n한 번에 특정 개수만큼의 데이터를 페이징 쿼리로 조회하면서 특정 필드의 값을 수정한다.\n- 페이지 단위마다 영속성 컨텍스트를 플러시하고 초기화한다.\n\nJPA는 JDBC 커서를 지원하지 않는다.\n- 따라서 **Hibernate 세션**을 사용해 커서를 사용해야 한다.\n\n> **커서**: 일련의 데이터에 순차적으로 액세스할 때 검색 및 \"현재 위치\"를 포함하는 데이터 요소\n\n**📌 Hibernate scroll 사용**<br/>\nHibernate는 `scroll` 이라는 이름으로 JDBC 커서를 지원한다.\n- 먼저 `em.unwrap()` 메소드로 Hibernate 세션을 구한다.\n- 쿼리를 조회하면서 `scroll()` 메소드로 `ScrollableResults` 객체를 반환받는다.\n  - 이 객체의 `next()` 메소드를 호출하면 엔티티를 하나씩 조회할 수 있다.\n\n**📌 Hibernate 무상태 세션 사용**<br/>\n무상태 세션은 영속성 컨텍스트를 만들지 않고 심지어 2차 캐시도 사용하지 않는다.\n- 엔티티를 수정하려면 무상태 세션이 제공하는 **`update()` 메소드를 직접 호출**해야 한다.\n\n### ➰ SQL 쿼리 힌트 사용\nJPA는 데이터베이스 SQL 힌트 기능을 제공하지 않는다. SQL 힌트를 사용하려면 Hibernate를 직접 사용해야 한다.\n- SQL 힌트는 Hibernate 쿼리가 제공하는 `addQueryHint()` 메소드를 사용한다.\n\n### ➰ 트랜잭션을 지원하는 쓰기 지연과 성능 최적화\n**📌 트랜잭션을 지원하는 쓰기 지연과 JDBC 배치**<br/>\n네트워크 호출 한 번은 단순한 메소드를 수만 번 호출하는 것보다 더 많은 비용이 든다.\n- JDBC가 제공하는 SQL 배치 기능을 사용하면 SQL을 모아서 데이터베이스에 한 번에 보낼 수 있다.\n  - 하지만 이는 코드의 많은 수정을 요구한다.\n  - 그래서 보통 수백 수천 건 이상의 데이터를 변경하는 특수한 상황에 이를 사용한다.\n- `hibernate.jdbc.batch_size` 속성의 값을 변경시켜 SQL 배치 실행 시 모을 데이터의 수를 지정할 수 있다.\n  - SQL 배치는 같은 SQL일 때만 유효하다.\n\n> 엔티티를 데이터베이스에 저장해야 식별자를 구할 수 있는 IDENTITY 식별자 생성 전략은 쓰기 지연을 활용한 성능 최적화를 할 수 없다.\n\n**📌 트랜잭션을 지원하는 쓰기 지연과 애플리케이션 확장성**<br/>\n트랜잭션을 지원하는 쓰기 지연과 변경 감지 기능 덕에 **데이터베이스 테이블 로우에 락이 걸리는 시간을 최소화**할 수 있다.\n- 트랜잭션을 커밋해서 영속성 컨텍스트를 플러시하기 전까지는 데이터베이스에 데이터를 등록, 수정, 삭제하지 않는다.\n- 따라서 커밋 직전까지 데이터베이스 로우에 락을 걸지 않는다.\n\nJPA는 커밋을 해야 플러시를 호출하고 데이터베이스에 수정 쿼리를 보낸다.\n- 쿼리를 보내고 바로 트랜잭션을 커밋하므로 결과적으로 데이터베이스에 락이 걸리는 시간을 최소화한다.\n  - 동시에 더 많은 트랜잭션을 처리할 수 있게 하는 장점이다.\n\n## 📕 출처\n- **자바 ORM 표준 JPA 프로그래밍** - 김영한\n- [자바 ORM 표준 JPA 프로그래밍](https://leejaedoo.github.io/performance/)\n- [더블 디스패치](https://en.wikipedia.org/wiki/Double_dispatch)\n- [커서](https://ko.wikipedia.org/wiki/%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4_%EC%BB%A4%EC%84%9C)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 컬렉션: 다양한 컬렉션과 특징을 설명한다.\n컨버터: 엔티티의 데이터를 변환해서 데이터베이스에 저장한다.\n리스너: 엔티티에서 발생한 이벤트를 처리한다.\n엔티티 그래프: 엔티티를 조회할 때 연관된 엔티티들을 선택해서 함께 조회한다. 💫 컬렉션 JPA는 자바에서 기본으로 제…","fields":{"slug":"/[JPA]14/"},"frontmatter":{"date":"April 05, 2022","title":"📚 14. 컬렉션과 부가 기능","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> **컬렉션**: 다양한 컬렉션과 특징을 설명한다.\n> **컨버터**: 엔티티의 데이터를 변환해서 데이터베이스에 저장한다.\n> **리스너**: 엔티티에서 발생한 이벤트를 처리한다.\n> **엔티티** 그래프: 엔티티를 조회할 때 연관된 엔티티들을 선택해서 함께 조회한다.\n\n## 💫 컬렉션\nJPA는 자바에서 기본으로 제공하는 `Collection` , `List` , `Set` , `Map` 컬렉션을 지원한다. 그리고 다음 경우에 사용할 수 있다.\n- `@OneToMany` , `@ManyToMany` 를 사용해서 일대다나 다대다 엔티티 관계 매핑 시\n- `@ElementCollection` 을 사용해 값 타입을 하나 이상 보관할 때\n\n자바 컬렉션 인터페이스의 특징\n- `Colleciton` : 자바가 제공하는 최상위 컬렉션, Hibernate는 중복을 허용하고 순서를 보장하지 않는다고 가정한다.\n- `Set` : 중복을 허용하지 않는 컬렉션, 순서를 보장하지 않는다.\n- `List` : 순서가 있는 컬렉션, 순서를 보장하고 중복을 허용한다.\n- `Map` : `Key` & `Value` 구조로 되어 있는 특수한 컬렉션\n\n### ➰ JPA와 컬렉션\nHibernate는 엔티티를 영속 상태로 만들 때 컬렉션 필드를 **준비한 컬렉션으로 감싸서 허용**한다.\n\n```java\n@Entity\npublic class Team {\n\n  @Id\n  private String id;\n\n  @OneToMany\n  @JoinColumn\n  private Collection<Member> members = new ArrayList<>();\n  ...\n\n}\n```\n\n`members` 컬렉션을 필드로 가지고 있는 엔티티를 영속 상태로 만들어 본다 (`em.persist`). `persist` 전과 후의 클래스 정보를 출력해보면,\n- 원래 **`ArrayList` 타입**이었던 컬렉션이 Hibernate가 제공하는 **`PersistentBag` 타입**으로 변경되는 것을 확인할 수 있다.\n  - 이는 Hibernate가 컬렉션의 효율적인 관리를 위해 원본 컬렉션을 감싸는 내장 컬렉션(또는 Wrapper 컬렉션)을 생성해 이 내장 컬렉션을 사용하도록 참조를 변경하는 것이다.\n- 이러한 특징때문에 위 예제처럼 컬렉션 사용 시에는 즉시 초기화하여 사용하는 것을 권장한다.\n\n**📌 컬렉션 인터페이스에 따른 Hibernate 내장 컬렉션과 특징**\n|**컬렉션 인터페이스**|**내장 컬렉션**|**중복 허용**|**순서 보관**|\n|:---:|:---:|:---:|:---:|\n|Collection, List|PersistentBag|O|X|\n|Set|PersistentSet|X|X|\n|List + @OrderColumn|PersistentList|O|O|\n\n### ➰ Collection, List\n중복을 허용하므로, 객체를 추가하는 `add()` 메소드는 내부에서 어떤 비교도 하지 않고 항상 `true` 를 반환한다.\n- 같은 엔티티가 있는지 찾거나 삭제할 때는 `equals()` 메소드를 사용한다.\n\n> 엔티티를 추가할 때 중복된 엔티티가 있는지 비교하지 않고 단순히 저장만 수행한다. 따라서 엔티티를 추가해도 지연 로딩된 컬렉션을 초기화하지 않는다.\n\n### ➰ Set\n`HashSet` 으로 초기화한다. 중복을 허용하지 않아 `add()` 메소드로 객체를 추가할 때마다 `equals()` 메소드로 같은 객체가 있는지 비교한다.\n- 같은 객체가 없으면 객체를 추가하고 `true` 를 반환하고, \n- 같은 객체가 이미 있어 추가에 실패하면 `false` 를 반환한다.\n- 참고로 `HashSet` 은 **해시 알고리즘**을 사용해 `hashcode()` 도 함께 사용해서 비교한다.\n\n> 엔티티를 추가할 때 중복된 엔티티에 대한 비교를 수행한다. 따라서 엔티티를 추가할 때 지연 로딩된 컬렉션을 초기화한다.\n\n### ➰ List + @OrderColumn\n`List` 인터페이스에 `@OrderColumn` 을 추가하면 순서가 있는 특수한 컬렉션으로 인식한다.\n- 순서가 있다는 의미는 \"**데이터베이스에 순서 값을 저장해서 조회할 때 사용한다**\"는 의미이다.\n- `@OrderColumn` 의 `name` 속성으로 `List` 의 위치 값을 보관할 컬럼을 지정할 수 있다.\n  - 일대다 관계의 특성상 위치 값은 다쪽에 저장된다.\n\n> 실무에서 사용하기에는 단점이 많다. `@OrderBy` 나 직접 위치 값 관리하는 것을 추천\n\n**📌 @OrderColumn의 단점**\n- 매핑하는 엔티티와 실제 저장되는 엔티티의 위치가 달라 추가적인 UPDATE SQL이 필요하다.\n- `List` 를 변경하면 연관된 많은 위치 값을 변경해야 한다. 중간에 있는 위치 값을 삭제하면, 그 이후에 있는 모든 값들에 대한 UPDATE SQL이 실행되어야 한다.\n  - 만약 UPDATE SQL을 수행하지 않아, 중간에 위치 값이 없으면 조회한 `List` 에는 `null` 이 보관된다. (위치 값이 삭제된 `List`)\n  - 컬렉션 순회 시 `NullPointerException` 발생\n\n### ➰ @OrderBy\n`@OrderColumn` 이 데이터베이스에 순서용 컬럼을 매핑해 관리했다면, `@OrderBy` 는 데이터베이스의 `ORDER BY` 절을 사용해서 컬렉션을 정렬한다.\n- 즉, 순서용 컬럼을 매핑할 필요가 없다.\n- 모든 컬렉션에 사용할 수 있다. \n- 엔티티의 필드를 대상으로 하고, `@OrderBy(\"username desc, id asc\")` 와 같이 사용한다.\n\n---\n\n## 💫 @Converter\n엔티티의 데이터를 변환해서 데이터베이스에 저장할 때 사용한다.\n- 회원의 VIP 여부를 자바의 `boolean` 타입을 사용하고 싶다는 가정이 있다. \n  - JPA를 사용하면 자바의 `boolean` 타입은 방언에 따라 다르지만 데이터베이스에 저장될 때 0 또는 1인 숫자로 저장된다.\n  - 그런데 데이터베이스에 이 숫자 대신 문자 Y 또는 N으로 저장하고 싶다면 컨버터를 사용한다.\n\n```java\n@Entity\npublic class Member {\n\n  ...\n\n  @Convert(converter = BooleanToYNConverter.class)\n  private boolean vip;\n  ..\n\n}\n```\n- `@Convert` 를 적용해 데이터베이스에 저장되기 직전에 `BooleanToYNConverter` 컨버터가 동작하도록 작성했다.\n\n```java\n@Converter\npublic class BooleanToYNConverter implements AttributeConverter<Boolean, String> {\n\n  @Override\n  public String converToDatabaseColumn(Boolean attribute) {\n    return (attribute != null && attribute) ? \"Y\" : \"N\";\n  }\n\n  @Override\n  public Boolean convertToEntityAttribute(String dbData) {\n    return \"Y\".equals(dbData);\n  }\n}\n```\n- 컨버터 클래스는 `@Converter` annotation을 사용하고, `AttributeConverter` 인터페이스를 구현해야 한다.\n- 또한 제네릭에 현재 타입과 변환할 타입을 지정한다.\n\n**구현해야 할 메소드**\n- `converToDatabaseColumn()` : 엔티티의 데이터를 데이터베이스 컬럼에 저장할 데이터로 변환한다. \n- `convertToEntityAttribute()` : 데이터베이스에서 조회한 컬럼 데이터를 엔티티의 데이터로 변환한다.\n\n또한 클래스 레벨에도 설정할 수 있다. 이때는 `attributeName` 속성으로 컨버터를 적용할 필드를 명시해야 한다.\n\n### ➰ 글로벌 설정\n모든 `Boolean` 타입에 컨버터를 적용하기 위해 컨버터 클래스에 `@Converter(autoApply = true)` 옵션을 적용하면 된다. 이제 `@Convert` 를 적용하지 않아도 자동으로 적용된다.\n\n|**속성**|**기능**|**기본 값**|\n|:---:|:---:|:---:|\n|converter|사용할 컨버터를 지정한다.||\n|attributeName|컨버터를 적용할 필드를 지정한다.||\n|disableConversion|글로벌 컨버터나 상속 받은 컨버터를 사용하지 않는다.|`false`|\n\n---\n\n## 💫 리스너\nJPA 리스너 기능을 사용해 엔티티의 생명주기에 따른 이벤트를 처리할 수 있다.\n\n### ➰ 이벤트 종류\n아래는 이벤트의 종류와 발생 시점이다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2Fdn1cwM%2FbtriRZvMBaA%2FgkP85jPClmov7R6wGXmNa0%2Fimg.png\" width=\"70%\">\n\n1. **PostLoad** : 엔티티가 영속성 컨텍스트에 조회된 직후 또는 `refresh` 를 호출한 후 (2차 캐시에 저장되어 있어도 호출)\n2. **PrePersist** : `persist()` 메소드를 호출해서 엔티티를 영속성 컨텍스트에 관리하기 직전에 호출된다. 식별자 생성 전략을 사용한 경우 엔티티에 식별자는 아직 존재하기 전이다. 새로운 인스턴스를 `merge` 할 때도 수행\n3. **PreUpdate** : `flush` 나 `commit` 을 호출해서 엔티티를 데이터베이스에 수정하기 직전에 호출\n4. **PreRemove** : `remove()` 메소드를 호출해서 엔티티를 영속성 컨텍스트에서 삭제하기 직전에 호출된다. 또한 삭제 명령어로 영속성 전이가 일어날 때도 호출 (`orphanRemoval` 에 대해서는 `flush` 나 `commit` 시 호출)\n5. **PostPersist** : `flush` 나 `commit` 을 호출해서 엔티티를 데이터베이스에 저장한 직후 호출된다. (식별자가 항상 존재) \n6. **PostUpdate** : `flush` 나 `commit` 을 호출해서 엔티티를 수정한 직후 호출\n7. **PostRemove** : `flush` 나 `commit` 을 호출해서 엔티티를 삭제한 직후 호출\n\n### ➰ 이벤트 적용 위치\n이벤트는 엔티티에서 직접 받거나 별도의 리스너를 등록해서 받을 수 있다.\n\n**📌 엔티티에 직접 적용**<br/>\n엔티티에 이벤트가 발생할 때마다 annotation으로 지정한 메소드가 실행되도록 한다. \n- 엔티티 클래스에 이벤트들에 대한 메소드를 구현하는 형태다.\n\n**📌 별도의 리스너 등록**<br/>\n리스너는 대상 엔티티를 파라미터로 받을 수 있다. 반환 타입은 `void` 로 설정해야 한다.\n- 엔티티 클래스에 `@EntityListeners(별도의 리스너.class)`\n\n**📌 기본 리스너 사용**<br/>\n모든 엔티티의 이벤트를 처리하려면 `META-INF/orm.xml` 에 기본 리스너로 등록하면 된다.\n\n여러 리스너를 등록했을 때 이벤트 호출 순서는 다음과 같다.\n1. 기본 리스너\n2. 부모 클래스 리스너\n3. 리스너\n4. 엔티티\n\n**📌 더 세밀한 설정**<br/>\n더 세밀한 설정을 위해서는 아래 annotation을 사용할 수 있다.\n- `javax.persistence.ExcludeDefaultListeners` : 기본 리스너 무시\n- `javax.persistence.ExcludeSuperclassListeners` 상위 클래스 이벤트 리스너 무시\n\n---\n\n## 💫 엔티티 그래프\n글로벌 `fetch` 옵션은 애플리케이션 전체에 영향을 주고, 변경할 수 없다는 단점이 있다. 그래서 일반적으로 **글로벌 `fetch` 옵션은 `FetchType.LAZY`** 를 사용하고, 엔티티 조회 시 연관된 엔티티를 함께 조회해야 한다면 **JPQL 페치 조인을 사용**한다.\n- 그런데 페치 조인을 사용하면, 같은 JPQL을 중복해서 작성하는 경우가 많다.\n- 이는 JPQL이 데이터를 조회하는 기능뿐 아니라 연관된 엔티티를 함께 조회하는 기능도 제공하기 때문에 발생하는 문제이다.\n\nJPA 2.1에 추가된 **엔티티 그래프 기능**을 사용해 엔티티를 조회하는 시점에 **함께 조회할 연관된 엔티티를 선택**할 수 있다.\n- 따라서 JPQL은 데이터를 조회하는 기능만을 수행하여 위 문제는 발생하지 않는다.\n- 엔티티 그래프는 정적으로 정의하는 Named 엔티티 그래프와 동적으로 정의하는 엔티티 그래프가 있다.\n\n### ➰ Named 엔티티 그래프\n`@NamedEntityGraph` 로 정의한다. \n- `name` : 엔티티 그래프의 이름을 정의\n- `attributeNodes` : 함께 조회할 속성을 선택\n\n### ➰ em.find()에서 엔티티 그래프 사용\nNamed 엔티티 그래프를 사용하려면 정의한 엔티티 그래프를 `em.getEntityGraph(\"정의한 엔티티 그래프 이름\")` 을 통해서 찾아오면 된다.\n\n### ➰ subgraph\n`subgraph` 를 사용해 관리하지 않는 연관된 엔티티의 필드까지 조회할 수 있다.\n- 관리할 수 있는 객체 그래프가 아니더라도 `subgraphs` 속성을 정의하여 `@NamedSubgraph` 를 사용해 서브 그래프를 정의할 수 있다.\n\n### ➰ JPQL에서 엔티티 그래프 사용\n`em.find()` 와 동일하게 힌트만 추가하여 사용할 수 있다.\n\n> `em.find()` 에서 엔티티 그래프를 사용하면 Hibernate는 필수 관계를 고려해 SQL 내부 조인을 사용하지만, JPQL에서 엔티티 그래프를 사용할 때는 항상 SQL 외부 조인을 사용한다.\n> - 내부 조인을 사용하려면 이를 명시해야 한다.\n\n### ➰ 동적 엔티티 그래프\n`em.createEntityGraph()` 메소드를 사용해 동적으로 엔티티 그래프를 생성할 수 있다.\n\n```java\npublic <T> EntityGraph<T> createEntityGraph(Class<T> rootType);\n```\n- `addAttributeNodes(\"필드\")` 를 사용해 엔티티의 필드 속성을 엔티티 그래프에 포함할 수 있다.\n- 또한 `addSubgraph()` 메소드로 서브 그래프를 추가할 수 있다.\n\n## 📕 출처\n- **자바 ORM 표준 JPA 프로그래밍** - 김영한\n- [[자바 ORM 표준 JPA 프로그래밍] 14.3 리스너](https://milenote.tistory.com/150)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 컨테이너 환경에서 JPA가 동작하는 내부 동작 방식에 대해 이해하는 장이다. 💫 트랜잭션 범위의 영속성 컨텍스트 순수한 J2SE 환경에서 JPA를 사용하면, 개발자가 직접 엔티티 매니저를 생성하고 트랜잭션도 관리해야 한다.  하지만 스프링이나 J2EE 컨테이너 환경에서…","fields":{"slug":"/[JPA]13/"},"frontmatter":{"date":"April 03, 2022","title":"📚 13. 웹 애플리케이션과 영속성 관리","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 컨테이너 환경에서 JPA가 동작하는 내부 동작 방식에 대해 이해하는 장이다.\n\n## 💫 트랜잭션 범위의 영속성 컨텍스트\n순수한 J2SE 환경에서 JPA를 사용하면, 개발자가 직접 엔티티 매니저를 생성하고 트랜잭션도 관리해야 한다. \n- 하지만 스프링이나 J2EE 컨테이너 환경에서 JPA를 사용하면 컨테이너가 제공하는 전략을 따라야 한다.\n\n### ➰ 스프링 컨테이너의 기본 전략\n**트랜잭션 범위의 영속성 컨텍스트 전략**이 기본이다.\n- 트랜잭션의 범위와 영속성 컨텍스트의 생존 범위가 같다는 의미이다. (트랜잭션을 시작할 때 영속성 컨텍스트를 생성하고, 트랜잭션이 끝날 때 영속성 컨텍스트를 종료한다.)\n- 한 트랜잭션 안에서는 항상 같은 영속성 컨텍스트에 접근한다.\n\n<img src=\"https://user-images.githubusercontent.com/45073750/141610903-843ccefe-e8c7-41da-8948-0c2e4d5f6cb6.png\" width=\"\n60%\">\n\n- 스프링 프레임워크에서는 보통 비즈니스 로직을 시작하는 서비스 계층에 `@Transactional` annotation을 선언해 트랜잭션을 시작한다. \n  - 호출한 메소드를 실행하기 직전에 **스프링 트랜잭션 AOP**가 먼저 동작한다.\n- 스프링 트랜잭션 AOP는 대상 메소드를 호출하기 직전에 트랜잭션을 시작하고, 메소드가 정상 종료되면 트랜잭션을 커밋하면서 종료한다.\n  - 트랜잭션을 커밋하면 JPA는 먼저 **영속성 컨텍스트를 플러시**해서 변경 내용을 데이터베이스에 반영한 후 **데이터베이스 트랜잭션을 커밋**한다. (영속성 컨텍스트의 변경 내용이 반영)\n- 예외 발생 시, 트랜잭션 롤백 후 종료한다. (플러시 호출 X)\n\n> `javax.persistence.PersistenceContext` annotation을 사용하면, 스프링 컨테이너가 엔티티 매니저를 주입해준다.\n\n컨트롤러가 호출한 서비스의 메소드를 사용하는 예시이다.\n1. `Service.logic()` 메소드에 `@Transactional` 을 선언해서 메소드 호출 시 트랜잭션을 먼저 시작한다.\n2. `logic()` 에서 사용하는 `repository.findMember()` 를 통해 조회한 `member` 엔티티는 트랜잭션 범위 안에 있어 영속성 컨텍스트의 관리를 받는다. (즉 영속 상태)\n3. `@Transactional` 을 선언한 메소드가 정상 종료되면 트랜잭션을 커밋하는데, 이때 영속성 컨텍스트도 종료한다. (즉 조회한 엔티티는 이제 준영속 상태)\n4. 서비스 메소드가 끝나면서 트랜잭션과 영속성 컨텍스트가 종료, 따라서 컨트롤러에 반환된 엔티티는 준영속 상태이다.\n\n**📌 트랜잭션 범위의 영속성 컨텍스트 전략**\n- \"트랜잭션이 같으면 같은 영속성 컨텍스트를 사용한다.\"\n  - 다양한 위치에서 엔티티 매니저를 주입받아 사용해도 트랜잭션이 같다면 항상 같은 영속성 컨텍스틀 사용한다. \n- \"트랜잭션이 다르면 다른 영속성 컨텍스트를 사용한다.\"\n  - 여러 스레드에서 동시에 요청이 와서 같은 엔티티 매니저를 사용해도 트랜잭션에 따라 접근하는 영속성 컨텍스트가 다르다.\n    - 스프링 컨테이너가 스레드마다 각각 다른 트랜잭션을 할당하기 때문이다.\n\n---\n\n## 💫 준영속 상태와 지연 로딩\n트랜잭션 범위의 영속성 컨텍스트 전략을 사용하기에, 조회한 엔티티가 서비스와 레포지토리 계층에서는 영속성 컨텍스트에 관리되면서 영속 상태를 유지하지만 컨트롤러나 뷰 같은 프레젠테이션 계층에서는 준영속 상태가 된다.\n- 따라서 프레젠테이션 계층에서는 엔티티에 대한 변경 감지와 지연 로딩이 동작하지 않는다. (컨트롤러에서 엔티티에 대한 지연 로딩 시점에 예외 발생)\n\n**📌 준영속 상태와 변경 감지**<br/>\n변경 감지 기능은 영속상태의 엔티티에 대해서만 가능하고, 보통 서비스 계층에서 비즈니스 로직을 수행하면서 발생한다.\n- 단순히 보여주기만 하는 프레젠테이션 계층에서 데이터를 수정할 일은 거의 없고, 오히려 변경 감지가 동작한다면 애플리케이션의 유지보수에 어려움을 더한다.\n\n> 변경 감지 기능이 프레젠테이션 계층에서 동작하지 않는 것은 서로의 책임을 확실히 하는데 당연한 것이다.\n\n- `spring-data-jpa`\n\n**📌 준영속 상태와 지연 로딩**<br/>\n준영속 상태의 가장 문제는 지연 로딩 기능이 동작하지 않는다는 것이다.\n- 뷰 렌더링 시, 연관된 엔티티도 함께 사용해야 하는데 연관된 엔티티를 지연 로딩으로 설정해서 프록시 객체로 조회했다고 가정한다.\n  - 아직 초기화하지 않는 프록시 객체를 사용하면 실제 데이터를 불러오기 위해 초기화를 시도한다.\n  - 하지만 준영속 상태에서는 지연 로딩을 할 수 없어 시도하게 되면 문제가 발생한다. (Hibernate의 경우 `LazyInitializationException` 예외 발생)\n\n이에 대한 해결책은 2가지가 있다.\n- 뷰가 필요한 엔티티를 미리 로딩해두는 방법\n- OSIV를 사용해 엔티티를 항상 영속 상태로 유지하는 방법\n\n첫 번째 방법은 이름 그대로 영속성 컨텍스트가 살아 있을 때 뷰에 필요한 엔티티들을 미리 다 로딩하거나 초기화해서 반환하는 방법이다.\n- 엔티티가 준영속 상태로 변해도 연관된 엔티티를 이미 다 로딩해 둔 상태이므로 지연 로딩이 필요하지 않다.\n- 어디서 미리 로딩하느냐에 따라 3가지 방법으로 나뉜다.\n  - 글로벌 페치 전략 수정\n  - JPQL 페치 조인\n  - 강제로 초기화\n\n### ➰ 글로벌 페치 전략 수정\n글로벌 페치 전략을 지연 로딩에서 즉시 로딩(`FetchType.EAGER`)으로 변경하면 된다.\n- 엔티티에 있는 페치 타입을 변경하여 애플리케이션 전체에서 이 엔티티를 로딩할 때마다 해당 전략을 사용하도록 한다. (글로벌 페치 전략)\n\n**📌 글로벌 페치 전략에 즉시 로딩 사용 시 단점**<br/>\n- 사용하지 않는 엔티티를 로딩한다.\n- N + 1 문제가 발생한다.\n  - 즉시 로딩인 경우 엔티티 조회 시 데이터베이스에 JOIN 쿼리를 사용해 한 번에 연관된 엔티티까지 조회한다.\n  - 문제는 JPQL 사용 시 발생한다. 즉시 로딩으로 설정하고 JPQL로 조회하면, **JPA가 JPQL을 분석해 SQL을 생성할 떄는 글로벌 페치 전략을 참고하지 않고, 오직 JPQL 자체만 사용한다.**\n  - 조회한 엔티티가 10개이면, 이와 연관된 엔티티를 조회하는 SQL도 10번 실행한다.\n    - 이처럼 처음 조회한 데이터 수만큼 다시 SQL을 사용해 조회하는 것을 N + 1 문제라 한다.\n\n> N + 1이 발생하면 SQL이 많이 호출되어 조회 성능에 치명적이다. 이는 **JPQL 페치 조인으로 해결**할 수 있다. \n\n### ➰ JPQL 페치 조인\nJPQL을 호출하는 시점에 함께 로딩할 엔티티를 선택할 수 있는 페치 조인이다.\n\n```java\n// 페치 조인 사용 전\nJPQL: select o from Order o\nSQL: select * from Order\n```\n```java\n// 페치 조인 사용 후\nJPQL: select o.*, m.*\n      from Order o\n      join fetch o.member\nSQL: select o.*, m.*\n     from Order o\n     join Member m on o.MEMBER_ID = m.MEMBER_ID\n```\n- 페치 조인을 사용하면 SQL JOIN을 사용해서 페치 조인 대상까지 함께 조회하므로, N + 1 문제가 발생하지 않는다.\n\n**📌 JPQL 페치 조인의 단점**<br/>\n현실적인 대안이지만, 무분별하게 사용하면 화면에 맞춘 레포지토리 메소드가 증가할 수 있다. (프레젠테이션 계층이 알게 모르게 데이터 접근 계층을 침범하는 것이다.)\n- 화면 A는 특정 엔티티만 필요하고, 화면 B는 특정 엔티티와 연관된 엔티티 둘 다 필요한 경우, 두 화면을 모두 최적화하기 위해 둘을 지연 로딩으로 설정하고 레포지토리에 각 화면에 맞춘 메소드를 생성한다.\n  - 각 화면들은 필요한 메소드를 호출하면 된다. 이렇게 최적화는 가능하지만, **뷰와 레포지토리 간 논리적인 의존관계가 발생**하게 된다.\n\n> 무분별한 최적화로 논리적인 의존관계를 증가시키지 않고 적절하게 타협하는 것이 합리적이다.\n\n### ➰ 강제로 초기화\n영속성 컨텍스트가 살아있을 때 프레젠테이션 계층이 필요한 엔티티를 강제로 초기화해서 반환하는 방법이다.\n\n```java\nclass OrderService {\n\n  @Transactional\n  public Order findOrder(Long id) {\n    Order order = orderRepository.findOrder(id);\n    order.getMember().getName(); // 프록시 객체를 강제로 초기화한다.\n    return order;\n  }\n}\n```\n- 글로벌 페치 전략을 지연 로딩으로 설정한다. 연관된 엔티티를 실제 엔티티가 아닌 프록시 객체로 조회하게 된다. \n  - **프록시 객체는 실제 사용하는 시점에 초기화**된다. \n  - 그런데 위 예시처럼, 프레젠테이션 계층에서 필요한 프록시 객체를 **영속성 컨텍스트가 살아있을 때 강제로 초기화해서 반환**하면, 이미 초기화되었기에 **준영속 상태에서도 사용**할 수 있게 된다.\n\n예제처럼 프록시 초기화를 서비스 계층이 담당하면, 뷰가 필요한 엔티티에 따라 서비스 계층의 로직을 변경해야 한다.\n- **프레젠테이션 계층이 서비스 계층을 침범하게 된다.**\n- 프록시 초기화 역할을 분리해야 하는데, FACADE 계층이 그 역할을 담당한다.\n\n### ➰ FACADE 계층 추가\n프레젠테이션 계층과 서비스 계층 사이에 추가한다. 이제 뷰를 위한 프록시 초기화는 이 계층에서 담당한다. (논리적인 의존성을 제거!)\n- 프록시 초기화를 위해서는 영속성 컨텍스트가 필요하므로, FACADE에서 트랜잭션을 시작해야 한다.\n\n**📌 FACADE 계층의 역할과 특징**<br/>\n- 프레젠테이션 계층에서 필요한 프록시 객체를 초기화한다.\n  - 프레젠테이션 계층과 도메인 모델 계층 간의 논리적 의존성을 분리해준다.\n- 서비스 계층을 호출해서 비즈니스 로직을 실행한다.\n- 레포지토리를 직접 호출해서 뷰가 요구하는 엔티티를 찾는다.\n\n실용적인 관점에서 보면, **중간에 계층이 하나 더 끼어든다**는 단점이 있다.\n- 더 많은 코드를 작성하게 한다.\n- 그리고 FACADE에는 단순히 서비스 계층을 호출만 하는 위임 코드가 상당히 많을 것이다.\n\n### ➰ 준영속 상태와 지연 로딩의 문제점\n뷰를 개발할 때 필요한 엔티티를 미리 초기화하는 방법은 생각보다 오류가 발생할 가능성이 높다.\n- 엔티티 클래스를 보고 개발하지 더 세세하게 다른 클래스를 확인하는 것은 번거롭고 놓치기 쉽기 때문이다.\n\n그리고 애플리케이션 로직과 뷰가 물리적으로는 나누어져 있지만 논리적으로 서로 의존한다는 문제가 있다. (FACADE 계층을 사용해서 해결할 수는 있지만 번거로움)\n\n> 결국 모든 문제는 **엔티티가 프레젠테이션 계층에서 준영속 상태이기 때문에 발생**한다. 영속성 컨텍스트를 뷰까지 살아있도록 열어두어 지연 로딩을 사용할 수 있게 하자. 이것이 OSIV다.\n\n---\n\n## 💫 OSIV\nOSIV(Open Session In View)는 영속성 컨텍스트를 뷰까지 열어둔다는 뜻이다. 즉, 뷰에서도 지연 로딩을 사용할 수 있다.\n\n### ➰ 과거 OSIV: 요청 당 트랜잭션\n가장 단순한 구현 방법은 클라이언트의 요청이 들어오자마자 서블릿 필터나 스프링 인터셉터에서 트랜잭션을 시작하고 요청이 끝날 떄 트랜잭션도 끝내는 것이다.\n- 영속성 컨텍스트가 처음부터 끝까지 살아있으므로 조회한 엔티티도 영속 상태를 유지한다.\n- 뷰에서도 지연 로딩을 할 수 있다.\n\n**📌 요청 당 트랜잭션 방식의 OSIV 문제점**<br/>\n\"컨트롤러나 뷰 같은 프레젠테이션 계층이 엔티티를 변경할 수 있다\"는 점이다.\n- 뷰에 노출할 때만 엔티티의 값을 변경하고자 하고, 실제 데이터베이스의 값은 변경하기 원치 않는 경우가 있다.\n- 하지만 이 방식은 뷰를 렌더링한 후 트랜잭션을 커밋한다.\n  - 당연히 영속성 컨텍스트를 플러시하게 되고, 변경 감지 기능으로 인해 데이터베이스에 변경 사항이 반영되어 버린다.\n\n프레젠테이션 계층에서 이렇게 데이터를 변경해 반영해버리면, 애플리케이션의 유지보수를 매우 어렵게 한다.\n- 그렇다면 엔티티를 수정하지 못하게 막으면 되는데, 아래 3가지 방법이 있다.\n\n1. 엔티티를 읽기 전용 인터페이스로 제공\n2. 엔티티 Wrapping\n3. DTO만 반환\n\n**📌 엔티티를 읽기 전용 인터페이스로 제공**<br/>\n엔티티를 직접 노출하는 대신에 읽기 전용 메소드만 제공하는 인터페이스를 프레젠테이션 계층에 제공하는 방법이다.\n- 프레젠테이션 계층은 읽기 전용 메소드만 있는 인터페이스를 사용해 엔티티를 수정할 수 없다!\n\n**📌 엔티티 Wrapping**<br/>\n엔티티의 읽기 전용 메소드만 가지고 있는 엔티티를 감싼 객체를 만들고 이를 프레젠테이션 계층에 반환하는 방법이다.\n\n```java\nclass MemberWrapper {\n\n  private Member member;\n\n  public MemberWrapper(Member member) {\n    this.member = member;\n  }\n\n  public String getName() {\n    member.getName();\n  }\n}\n```\n\n**📌 DTO만 반환**<br/>\n프레젠테이션 계층에 엔티티 대신에 단순히 데이터만 전달하는 객체인 DTO(Data Transfer Object)를 생성해서 반환하는 것이다.\n- OSIV를 사용하는 장점을 살릴 수 없고, 엔티티를 거의 복사한 듯한 DTO 클래스도 하나 더 만들어야 한다.\n\n> 모두 코드량이 상당히 증가한다는 단점이 있는 방법들이다. 최근에는 비즈니스 계층에서만 트랜잭션을 유지하는 방식의 OSIV를 사용한다. \n\n### ➰ 스프링 OSIV: 비즈니스 계층 트랜잭션\n스프링 프레임워크가 제공하는 OSIV다.\n\n**📌 스프링 프레임워크가 제공하는 OSIV 라이브러리**<br/>\n`spring-orm.jar` 는 다양한 OSIV 클래스를 제공한다. OSIV를 서블릿 필터에서 적용할지 인터셉터에서 적용할지에 따라 원하는 클래스를 선택해서 사용하면 된다.\n\n- Hibernate OSIV 서블릿 필터: `org.springframework.orm.hibernate4.support.OpenSessionInViewFilter`\n- Hibernate OSIV 스프링 인터셉터: `org.springframework.orm.hibernate4.support.OpenSessionInViewInterceptor`\n- JPA OEIV 서블릿 필터: `org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter`\n- JPA OEIV 스프링 인터셉터: `org.springframework.orm.jpa.support.OpenEntityManagerInViewInterceptor`\n\n**📌 스프링 OSIV 분석**<br/>\n요청 당 트랜잭션 방식은 프레젠테이션 계층에서 데이터를 변경할 수 있다는 문제가 있다. (당연히 스프링 OSIV에서는 이러한 문제를 어느정도 해결)\n\n\"비즈니스 계층에서 트랜잭션을 사용하는 OSIV다!\" (OSIV를 사용하기는 하지만 트랜잭션은 비즈니스 계층에서만 사용)\n\n<img src=\"https://media.vlpt.us/images/agugu95/post/e8220dcf-3d4a-4657-9fb7-b1895c4e5606/image.png\" width=\"60%\">\n\n1. 클라이언트의 요청이 들어오면, 서블릿 필터나 인터셉터에서 영속성 컨텍스트를 생성한다. (트랜잭션은 아직 시작하지 않는다.)\n2. 서비스 계층에서 `@Transactional` 로 트랜잭션을 시작할 때 1번에서 미리 생성해둔 영속성 컨텍스트를 찾아와서 트랜잭션을 시작한다.\n3. 서비스 계층이 끝나면 트랜잭션을 커밋하고, 영속성 컨텍스트를 플러시한다. (트랜잭션은 끝내지만, 영속성 컨텍스트는 종료하지 않는다.)\n4. 컨트롤러와 뷰까지 영속성 컨텍스트가 유지되므로 조회한 엔티티는 영속 상태를 유지한다.\n5. 서블릿 필터나, 인터셉터로 요청이 돌아오면 영속성 컨텍스트를 종료한다. 플러시를 호출하지 않고 바로 종료한다.\n\n**📌 트랜잭션 없이 읽기**<br/>\n\"영속성 컨텍스틀 통한 모든 변경은 트랜잭션 안에서 이뤄져야 한다.\" (그렇지 않다면 `TransactionRequiredException` 예외 발생)\n- 변경 없이 **단순한 조회 시에는 트랜잭션이 필요없는데**, 이를 트랜잭션 없이 읽기(Nontranscational reads)라 한다. \n- 프록시를 초기화하는 지연 로딩도 조회 기능이므로 이것이 가능하다.\n\n스프링이 제공하는 OSIV를 사용하면 프레젠테이션 계층에서는 트랜잭션이 없으므로, 엔티티를 수정할 수 없다. \n- 따라서 프레젠테이션 계층에서 엔티티를 수정할 수 있는 기존 OSIV의 단점을 보완했다.\n- 그리고, 트랜잭션 없이 읽기를 사용해 프레젠테이션 계층에서 지연 로딩 기능을 사용할 수 있다.\n\n스프링이 제공하는 비즈니스 계층 트랜잭션 OSIV의 특징은 다음과 같다.\n- 영속성 컨텍스트를 프레젠테이션 계층까지 유지한다.\n- 프레젠테이션 계층에는 트랜잭션이 없으므로 엔티티를 수정할 수 없다.\n- 프레젠테이션 계층에는 트랜잭션이 없지만 트랜잭션 없이 읽기를 사용해서 지연 로딩을 할 수 있다.\n\n프레젠테이션 계층에는 영속성 컨텍스트가 유지된다. 프레젠테이션 계층에서 영속성 컨텍스트를 플러시하면, 변경 감지가 동작해 데이터베이스에 변경 사항이 반영될 수 있다. 하지만 다음 2가지 이유로 플러시가 동작하지 않는다.\n- 트랜잭션을 사용하는 서비스 계층이 끝날 때 트랜잭션이 커밋되면서 이미 플러시했다. 그리고 요청이 끝나면 플러시 호출 없이 종료한다고 했으므로, 플러시는 발생하지 않는다.\n- 강제로 `em.flush()` 해도 트랜잭션 범위 밖이기에 데이터를 수정할 수 없다는 예외가 발생할 것이다.\n\n**📌 스프링 OSIV 주의사항**<br/>\n프레젠테이션 계층에서 엔티티를 수정한 직후에 트랜잭션을 시작하는 서비스 계층을 호출하면 문제가 발생한다.\n\n1. 컨트롤러에서 회원 엔티티를 조회하고 이름을 수정했다.\n2. 컨트롤러에서 트랜잭션이 있는 비즈니스 로직을 실행했다.\n3. 트랜잭션 AOP가 동작하면서 영속성 컨텍스트에 트랜잭션을 시작한다. 이후 2번의 메소드를 실행한다.\n4. 메소드가 끝나면 트랜잭션 AOP가 트랜잭션을 커밋하고 영속성 컨텍스트를 플러시한다. 이때 동작하는 변경 감지로 인해 1번의 수정 사항을 데이터베이스에 반영한다.\n\n> 컨트롤러에서 엔티티 수정 후 뷰를 호출하지 않고 트랜잭션이 동작하는 비즈니스 로직을 호출했으므로 문제가 발생한다.\n\n문제 해결을 위한 단순한 방법은 트랜잭션이 있는 비즈니스 로직을 모두 호출하고 나서 엔티티를 변경하면 된다.\n- 보통 컨트롤러는 비즈니스 로직을 먼저 호출하고, 그 결과를 조회하는 순서로 실행하므로 이러한 문제는 거의 발생하지 않는다.\n\n또한, 스프링 OSIV는 **같은 영속성 컨텍스트를 여러 트랜잭션이 공유**할 수 있어 이런 문제가 발생한다.\n- OSIV를 사용하지 않는 트랜잭션 범위의 영속성 컨텍스트 전략은 트랜잭션의 생명주기와 영속성 컨텍스트의 생명주기가 같아 이런 문제가 발생하지 않는다.\n\n---\n\n## 💫 너무 엄격한 계층\n상품을 구매한 후에 구매 결과 엔티티를 조회하려고 컨트롤러에서 레포지토리를 직접 접근한다.\n\n```java\nclass OrderController {\n\n  @Autowired OrderService orderService;\n  @Autowired OrderRepository orderRepository;\n\n  public String orderRequest(Order order, Model model) {\n    long Id = orderService.order(order); // 상품 구매\n\n    // 레포지토리 직접 접근\n    Order orderResult = orderRepository.findOne(Id);\n    model.addAttribute(\"order\", orderResult);\n    ...\n\n  }\n}\n```\n```java\n@Transactional\nclass OrderService {\n\n  @Autowired OrderRepository orderRepository;\n\n  public Long order(Order order) {\n    ... // 비즈니스 로직\n    return orderRepository.save(order);\n  }\n\n}\n```\n```java\nclass OrderRepository {\n  @PersistenceContext EntityManager em;\n\n  public Order findOne(Long id) {\n    return em.find(Order.class, id);\n  }\n}\n```\n- OSIV를 사용하기 전엔 프레젠테이션 계층에서 사용할 지연 로딩된 엔티티를 **미리 초기화**해야 했다. 그리고 이는 **영속성 컨텍스트가 살아있는** 서비스 계층이나 FACADE 계층이 담당했다.\n- OSIV를 사용하면 영속성 컨텍스트의 생명주기를 늘렸기에 이럴 필요가 없다.\n\n> 따라서 단순한 엔티티 조회는 컨트롤러에서 레포지토리를 직접 호출해도 아무런 문제가 없다.\n\n## 📕 출처\n- **자바 ORM 표준 JPA 프로그래밍** - 김영한\n- [[JPA] OSIV와 Spring Framework에서의 OSIV에 대해서](https://bepoz-study-diary.tistory.com/400)\n- [[JPA] 트랜잭션 범위와 영속성 컨텍스트, FASCADE 계층](https://willseungh0.tistory.com/73)"},{"excerpt":"문제 미세먼지를 제거하기 위해 구사과는 공기청정기를 설치하려고 한다. 공기청정기의 성능을 테스트하기 위해 구사과는 집을 크기가 R×C인 격자판으로 나타냈고, 1×1 크기의 칸으로 나눴다. 구사과는 뛰어난 코딩 실력을 이용해 각 칸 (r, c)에 있는 미세먼지의 양을 실시간으로 모니터링하는 시스템을 개발했다. (r, c)는 r행 c열을 의미한다. 공기청정기…","fields":{"slug":"/[BOJ]17144/"},"frontmatter":{"date":"April 01, 2022","title":"👩‍💻 17144. 미세먼지 안녕!","tags":["구현","시뮬레이션"]},"rawMarkdownBody":"\n## 문제\n미세먼지를 제거하기 위해 구사과는 공기청정기를 설치하려고 한다. 공기청정기의 성능을 테스트하기 위해 구사과는 집을 크기가 R×C인 격자판으로 나타냈고, 1×1 크기의 칸으로 나눴다. 구사과는 뛰어난 코딩 실력을 이용해 각 칸 (r, c)에 있는 미세먼지의 양을 실시간으로 모니터링하는 시스템을 개발했다. (r, c)는 r행 c열을 의미한다.\n\n<img src=\"https://upload.acmicpc.net/75d322ad-5a89-4301-b3a7-403fce0ff966/-/preview/\" width=\"50%\">\n\n공기청정기는 항상 1번 열에 설치되어 있고, 크기는 두 행을 차지한다. 공기청정기가 설치되어 있지 않은 칸에는 미세먼지가 있고, (r, c)에 있는 미세먼지의 양은 Ar,c이다.\n\n1초 동안 아래 적힌 일이 순서대로 일어난다.\n\n1. 미세먼지가 확산된다. 확산은 미세먼지가 있는 모든 칸에서 동시에 일어난다.\n     - (r, c)에 있는 미세먼지는 인접한 네 방향으로 확산된다.\n     - 인접한 방향에 공기청정기가 있거나, 칸이 없으면 그 방향으로는 확산이 일어나지 않는다.\n     - 확산되는 양은 Ar,c/5이고 소수점은 버린다.\n     - (r, c)에 남은 미세먼지의 양은 Ar,c - (Ar,c/5)×(확산된 방향의 개수) 이다.\n2. 공기청정기가 작동한다.\n    - 공기청정기에서는 바람이 나온다.\n    - 위쪽 공기청정기의 바람은 반시계방향으로 순환하고, 아래쪽 공기청정기의 바람은 시계방향으로 순환한다.\n    - 바람이 불면 미세먼지가 바람의 방향대로 모두 한 칸씩 이동한다.\n    - 공기청정기에서 부는 바람은 미세먼지가 없는 바람이고, 공기청정기로 들어간 미세먼지는 모두 정화된다.\n  \n다음은 확산의 예시이다.\n\n<img src=\"https://upload.acmicpc.net/7b0d9d57-1296-44cd-8951-4135d27f9446/-/preview/\" width=\"30%\">\n\n- 왼쪽과 오른쪽에 칸이 없기 때문에, 두 방향으로만 확산이 일어났다.\n\n<img src=\"https://upload.acmicpc.net/cebebfa9-0056-45f1-b705-75b035888085/-/preview/\" width=\"30%\">\n\n- 인접한 네 방향으로 모두 확산이 일어난다.\n\n<img src=\"https://upload.acmicpc.net/1ed0d2e9-9767-4b94-bbde-0e1d6a2d52ff/-/preview/\" width=\"30%\">\n\n- 공기청정기가 있는 칸으로는 확산이 일어나지 않는다.\n\n공기청정기의 바람은 다음과 같은 방향으로 순환한다.\n\n<img src=\"https://upload.acmicpc.net/94466937-96c7-4f25-9804-530ebd554a59/-/preview/\" width=\"50%\">\n\n방의 정보가 주어졌을 때, T초가 지난 후 구사과의 방에 남아있는 미세먼지의 양을 구해보자.\n\n## 입, 출력\n\n입력\n- 첫째 줄에 R, C, T (6 ≤ R, C ≤ 50, 1 ≤ T ≤ 1,000) 가 주어진다.\n- 둘째 줄부터 R개의 줄에 Ar,c (-1 ≤ Ar,c ≤ 1,000)가 주어진다. 공기청정기가 설치된 곳은 Ar,c가 -1이고, 나머지 값은 미세먼지의 양이다. -1은 2번 위아래로 붙어져 있고, 가장 윗 행, 아랫 행과 두 칸이상 떨어져 있다.\n\n출력\n- 첫째 줄에 T초가 지난 후 구사과 방에 남아있는 미세먼지의 양을 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Room {\n    Queue<Pair> dustQueue = new LinkedList<>();\n    int[][] room;\n    int[] rangeX = { -1, 0, 1, 0 };\n    int[] rangeY = { 0, 1, 0, -1 };\n    int R, C;\n    int cleaner1X, cleaner2X;\n    ...\n\n}\n```\n\n- 미세 먼지와 공기청정기 정보를 저장하는 클래스\n\n```java\npublic int goodByeFineDust(int time) {\n    while(time > 0) {\n        spreadDust();\n        runCleaner();\n        time--;\n    }\n    return countDust();\n}\n```\n\n- 코드는 먼지를 확산시키고, 공기청정기를 동작시킨다. 정해진 시간이 경과한 후, 전체 미세 먼지를 반환한다.\n\n```java\nprivate void spreadDust() {...}\n```\n\n- `Queue` 에 저장하고 있는 미세 먼지 좌표를 이용해 미세 먼지를 확산시킨다. \n- 이때 업데이트할 미세 먼지 정보를 `int[][] tmp` 에 저장하고, 확산이 끝난 이후 `room` 을 업데이트한다.\n\n```java\nprivate void runCleaner() {...}\n```\n\n- 공기 청정기의 바람 방향을 따라 순차적으로 미세 먼지를 이동시킨다. \n- 공기 청정기 바로 앞 좌표는 항상 `0` 으로 업데이트한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.Arrays;\n    import java.util.LinkedList;\n    import java.util.Queue;\n\n    class Pair {\n        int x;\n        int y;\n\n        public Pair(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Room {\n        Queue<Pair> dustQueue = new LinkedList<>();\n        int[][] room;\n        int[] rangeX = { -1, 0, 1, 0 };\n        int[] rangeY = { 0, 1, 0, -1 };\n        int R, C;\n        int cleaner1X, cleaner2X;\n\n        public Room (int R, int C) {\n            this.R = R;\n            this.C = C;\n            room = new int[R][C];\n        }\n\n        public int goodByeFineDust(int time) {\n            while(time > 0) {\n                spreadDust();\n                runCleaner();\n                time--;\n            }\n            return countDust();\n        }\n\n        private void spreadDust() {\n            int[][] tmp = new int[R][C];\n\n            while(!dustQueue.isEmpty()) {\n                Pair dust = dustQueue.poll();\n                int divDust = room[dust.x][dust.y] / 5;\n                int checkSpread = 0;\n\n                for (int i = 0; i < 4; i++) {\n                    int nx = dust.x + rangeX[i];\n                    int ny = dust.y + rangeY[i];\n\n                    if (nx < 0 || nx > R - 1 || ny < 0 || ny > C - 1) continue;\n                    if (room[nx][ny] == -1) continue;\n\n                    tmp[nx][ny] += divDust;\n                    checkSpread++;\n                }\n                tmp[dust.x][dust.y] = tmp[dust.x][dust.y] + room[dust.x][dust.y] - (divDust * checkSpread);\n            }\n\n            for (int i = 0; i < R; i++) {\n                for (int j = 0; j < C; j++) {\n                    if (room[i][j] == -1) continue;\n                    room[i][j] = tmp[i][j];\n                }\n            }\n        }\n\n        private void runCleaner() {\n            int i = 0;\n            for (i = cleaner1X - 2; i >= 0; i--) {\n                room[i + 1][0] = room[i][0];\n            }\n            for (i = 1; i < C; i++) {\n                room[0][i - 1] = room[0][i];\n            }\n            for (i = 1; i <= cleaner1X; i++) {\n                room[i - 1][C - 1] = room[i][C - 1];\n            }\n            for (i = C - 2; i > 0; i--) {\n                room[cleaner1X][i + 1] = room[cleaner1X][i];\n            }\n\n            for (i = cleaner2X + 2; i < R; i++) {\n                room[i - 1][0] = room[i][0];\n            }\n            for (i = 1; i < C; i++) {\n                room[R - 1][i - 1] = room[R - 1][i];\n            }\n            for (i = R - 2; i >= cleaner2X; i--) {\n                room[i + 1][C - 1] = room[i][C - 1];\n            }\n            for (i = C - 2; i > 0; i--) {\n                room[cleaner2X][i + 1] = room[cleaner2X][i];\n            }\n\n            room[cleaner1X][1] = room[cleaner2X][1] = 0;\n\n            for (i = 0; i < R; i++) {\n                for (int j = 0; j < C; j++) {\n                    if (room[i][j] > 0) dustQueue.add(new Pair(i, j));\n                }\n            }\n        }\n\n        private int countDust() {\n            int count = 0;\n\n            for (int i = 0; i < R; i++) {\n                for (int j = 0; j < C; j++) {\n                    if (room[i][j] > 0) count += room[i][j];\n                }\n            }\n            return count;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\n            int[] line = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n            int R = line[0], C = line[1], T = line[2];\n\n            Room dirtyRoom = new Room(R, C);\n\n            for (int i = 0; i < R; i++) {\n                dirtyRoom.room[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n                if (dirtyRoom.room[i][0] == -1 && dirtyRoom.cleaner1X == 0) {\n                    dirtyRoom.cleaner1X = i;\n                    dirtyRoom.cleaner2X = i+1;\n                }\n                for (int j = 0; j < C; j++) {\n                    if (dirtyRoom.room[i][j] > 0) dirtyRoom.dustQueue.add(new Pair(i, j));\n                }\n            }\n            br.close();\n\n            System.out.println(dirtyRoom.goodByeFineDust(T));\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 미세먼지를 확산시키는 방법에서 시간을 많이 뺏겼다. 결론적으로는 추가적인 배열을 두고, 미세먼지 확산 정보를 저장해두고, `room` 에 업데이트하는 방식이 필요했다.\n- 시뮬레이션은 단순한 듯 하면서 많은 코드량을 요구하는 것 같다...\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/17144"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 두 레포지토리가 비슷한 기능을 한다면, 제네릭과 상속을 적절히 사용해 공통 부분을 처리하는 부모 클래스를 만들 수 있다. 이를 보통  라 한다. 하지만 이 방법은 공통 기능을 구현한 부모 클래스에 너무 종속되고 구현 클래스 상속이 가지는 단점에 노출된다. 💫 스프링 데…","fields":{"slug":"/[JPA]12/"},"frontmatter":{"date":"April 01, 2022","title":"📚 12. 스프링 데이터 JPA","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 두 레포지토리가 비슷한 기능을 한다면, 제네릭과 상속을 적절히 사용해 공통 부분을 처리하는 부모 클래스를 만들 수 있다.\n> - 이를 보통 `GenenricDAO` 라 한다.\n> - 하지만 이 방법은 공통 기능을 구현한 부모 클래스에 너무 종속되고 구현 클래스 상속이 가지는 단점에 노출된다.\n\n## 💫 스프링 데이터 JPA 소개\n스프링 프레임워크에서 JPA를 편하게 사용할 수 있도록 지원하는 프로젝트다. \n- CRUD를 처리하기 위한 공통 인터페이스(`org.springframework.data.jpa.repository.JpaRepository`)를 제공한다.\n  - 레포지토리 개발 시 인터페이스만 작성하면 실행 시점에 스프링 데이터 JPA가 구현 객체를 동적으로 생성해 주입해준다.\n\n> 데이터 접근 계층을 개발할 때, **구현 클래스 없이 인터페이스만 작성해도 개발을 완료**할 수 있다.\n\n일반적인 CRUD 메소드는 제공하기에 문제가 없지만, 직접 작성한 공통으로 처리할 수 없는 메소드의 경우는 스프링 데이터 JPA가 메소드 이름을 분석해 적절한 JPQL을 실행한다.\n\n### ➰ 스프링 데이터 프로젝트\n스프링 데이터 프로젝트는 JPA, 몽고 DB, NEO4J, REDIS, HADOOP, GEMFIRE 같은 다양한 데이터 저장소에 대한 접근을 추상화하여 개발자 편의를 제공하고, 지루하게 반복하는 데이터 접근 코드를 줄여준다.\n- 여기서 스프링 데이터 JPA 프로젝트는 JPA에 특화된 기능을 제공한다.\n\n---\n\n## 💫 스프링 데이터 JPA 설정\n**📌 필요 라이브러리**<br/>\n- `spring-data-jpa`\n\n**📌 환경설정**<br/>\n스프링 설정에 `base-package` 를 명시하고, `EnableJpaRepositories` annotation의 `basePackages` 에 레포지토리를 검색할 패키지 위치를 적음으로써, 스프링 데이터 JPA는 애플리케이션 실행 시 `basePackages` 에 있는 레포지토리 인터페이스들을 찾아 해당 인터페이스를 구현한 클래스를 동적으로 생성한 다음 스프링 빈으로 등록한다.\n- 따라서 직접 구현 클래스를 구현하지 않아도 되는 것이다.\n\n---\n\n## 💫 공통 인터페이스 기능\n스프링 데이터 JPA를 사용하는 가장 단순한 방법은 `JpaRepository` 인터페이스를 상속받는 것이다.\n- 그리고 제네릭에 엔티티 클래스와 엔티티 클래스가 사용하는 식별자 타입을 지정한다.\n\n```java\npublic interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {...}\n\npublic interface MemberRepository extends JpaRepository<Member, Long> {...}\n```\n\n**📌 JpaRepository 인터페이스의 계층구조**<br/>\n스프링 데이터 모듈이 있고, 그 안에 `Repository` , `CrudRepository` , `PagingAndSortingRepository` 가 있다. 이들은 스프링 데이터 프로젝트가 공통으로 사용하는 인터페이스다.\n- 스프링 데이터 JPA가 제공하는 `JpaRepository` 인터페이스는 여기에 추가로 JPA에 특화된 기능을 제공한다.\n\n아래는 `JpaRepository` 인터페이스의 주요 메소드이다.\n- `save(S)` , `delete(T)` , `findOne(ID)` , `getOne(ID)` , `findAll(...)` (T: 엔티티, ID: 엔티티의 식별자 타입, S: 엔티티와 그 자식 타입)\n- `save(S)` 는 엔티티에 식별자 값이 없으면(`null`이면) 새로운 엔티티로 판단해서 `em.persist()` 를 호출하고, 식별자 값이 있으면 이미 있는 엔티티로 판단해 `em.merge()` 를 호출한다.\n\n---\n\n## 💫 쿼리 메소드 기능\n메소드 이름만으로 쿼리를 생성하는 등 매우 편리한 기능이다. 스프링 데이터 JPA가 제공하는 쿼리 메소드 기능은 크게 아래 3가지가 있다.\n- 메소드 이름으로 쿼리 생성\n- 메소드 이름으로 JPA NamedQuery 호출\n- `@Query` annotation을 사용해 레포지토리 인터페이스에 쿼리 직접 정의\n\n### ➰ 메소드 이름으로 쿼리 생성\n인터페이스에 정의한 `findByEmailAndName(...)` 메소드를 실행하면, 스프링 데이터 JPA는 메소드 이름을 분석해 JPQL을 생성하고 실행한다.\n- 물론 이를 위해서는 정해진 규칙에 따라 메소드 이름을 지어야 한다. (스프링 데이터 JPA 공식 문서 참고)\n- **엔티티의 필드명이 변경되면, 인터페이스에 정의한 메소드 이름도 함께 변경**해야 한다.\n\n### ➰ JPA NamedQuery\nJPA Named 쿼리는 이름 그대로 쿼리에 이름을 부여해 사용하는 방법인데, annotation이나 XML에 쿼리를 정의할 수 있다. 이전에 다룬 NamedQuery와 동일하다. 또한, Named 네이티브 쿼리도 지원한다.\n- 스프링 데이터 JPA를 사용하면 메소드 이름만으로 Named 쿼리를 호출할 수 있다.\n- 선언한 \"도메인 클래스 + . + 메소드 이름\" 으로 Named 쿼리를 찾아서 실행한다.\n  - 만약 실행할 Named 쿼리가 없다면 메소드 이름으로 쿼리 생성 전략을 사용한다.\n\n### ➰ @Query, 레포지토리 메소드에 쿼리 정의\n`Query` annotation을 사용해 레포지토리 메소드에 직접 쿼리를 정의할 수 있다.\n- 실행할 메소드에 정적 쿼리를 직접 작성하기에 이름없는 Named 쿼리라 할 수 있다.\n- 또한 애플리케이션 실행 시점에 문법 오류를 발견할 수 있다는 장점이 있다.\n\n```java\npublic interface MemberRepository extends JpaRepository<Member, Long> {\n\n  @Query(\"select m from Member m where m.username = ?1\")\n  Member findByUsername(String username);\n\n}\n```\n\n네이티브 SQL을 사용하려면 `@Query` annotation에 `nativeQuery = true` 를 설정한다.\n- 참고로 스프링 데이터 JPA가 지원하는 파라미터 바인딩을 사용하면 **JPQL은 위치 기반 파라미터를 1부터 시작**하지만 **네이티브 SQL은 0부터 시작**한다.\n\n### ➰ 파라미터 바인딩\n위치 기반 파라미터 바인딩과 이름 기반 파라미터 바인딩을 지원한다. (기본 값은 위치 기반, 파라미터 순서로 바인딩)\n- 이름 기반 파라미터 바인딩 사용을 위해서는 `Param` annotation을 사용한다. (ex. `@Param(\"name\")`)\n\n### ➰ 벌크성 수정 쿼리\n`executeUpdate()` 메소드로 벌크 연산을 수행할 수 있다.\n\n```java\n@Modifying\n@Query(\"update Product p set p.price = p.price * 1.1 where p.stockAmount < :stockAmount\")\nint bulkPriceUp(@Param(\"stockAmount\") String stockAmount);\n```\n- 스프링 데이터 JPA에서 벌크성 수정, 삭제 쿼리는 `Modifying` annotation을 사용하면 된다.\n- 벌크성 쿼리 실행 후 영속성 컨텍스트를 초기화하려면 `Modifying` annotation의 `clearAutomatically` 속성을 `true` 로 설정하면 된다. (기본 값 : `false`)\n\n### ➰ 반환 타입\n스프링 데이터 JPA는 유연한 반환 타입을 지원한다.\n- **결과가 한 건 이상이면 컬렉션 인터페이스**\n- **단건이면 반환 타입을 지정**\n\n조회 결과가 없다면, 컬렉션은 빈 컬렉션, 단건은 `null` 을 반환한다.\n- 단건을 기대하고 반환 타입을 지정했는데 2건 이상 조회되면 `NonUniqueResultException` 예외가 발생한다.\n\n> 스프링 데이터 JPA는 단건 조회 시 JPQL의 `Query.getSingleResult()` 호출로 인해 발생할 수 있는 `NoResultException` 예외가 발생하게 되면, 이를 무시하고 `null` 을 반환한다.\n\n### ➰ 페이징과 정렬\n페이징과 정렬 기능을 위한 2가지 파라미터를 제공한다.\n- `org.springframework.data.domain.Sort` : 정렬 기능\n- `org.springframework.data.domain.Pageable` : 페이징 기능(내부에 Sort 포함)\n\n파라미터에 `Pageable` 을 사용하면 반환 타입으로 `List` 나 `org.springframework.data.domain.Page` 를 사용할 수 있다.\n- 반환 타입으로 `Page` 를 사용하면 스프링 데이터 JPA는 페이징 기능을 제공하기 위해 검색된 전체 데이터 건수를 조회하는 `count` 쿼리를 추가로 호출한다.\n\n---\n\n## 💫 명세\n책 도메인 주도 설계(Domain Driven Design)는 명세(SPECIFICATION)라는 개념을 소개한다. 스프링 데이터 JPA는 JPA Criteria로 이 개념을 사용할 수 있도록 지원한다. 이를 이해하기 위한 핵심 단어는 술어(predicate)인데 이는 단순히 참이나 거짓으로 평가된다.\n- 그리고 이는 AND, OR 같은 연산자로 조합할 수 있다.\n- ex. 데이터를 검색하기 위한 제약 조건 하나하나를 술어라 할 수 있다.\n- 이 술어를 스프링 데이터 JPA는 `org.springframework.data.jpa.domain.Specification` 클래스로 정의했다.\n\n`Specification` 은 컴포지트 패턴(Composite pattern)으로 구성되어 있어 여러 `Specification` 을 조합할 수 있다.\n- 레포지토리에서 `org.springframework.data.jpa.repository.JpaSpecificationExecutor` 인터페이스를 상속받아 명세 기능을 사용할 수 있다.\n- 명세를 정의하려면, 상속받은 인터페이스를 구현하면 된다.\n  - 명세 정의 시에는 `toPredicate(...)` 메소드만 구현하면 되는데, JPA Criteria의 `Root` , `CriteriaQuery` , `CriteriaBuilder` 클래스가 모두 파라미터로 주어진다.\n\n---\n\n## 💫 사용자 정의 레포지토리 구현\n다양한 이유로, 상속받은 인터페이스에 대한 구현이 필요할 때가 있다. 그렇다고 해서 레포지토리를 직접 구현하면 공통 인터페이스가 제공하는 기능까지 구현해야 한다. \n- 스프링 데이터 JPA는 이런 문제를 우회해서 필요한 메소드만 구현할 수 있는 방법을 제공한다.\n\n1. 직접 구현할 메소드를 위한 사용자 정의 인터페이스를 작성해야 한다.\n2. 사용자 정의 인터페이스를 구현한 클래스를 작성해야 한다. \n    - 레포지토리 인터페이스 이름 + `Impl` 로 지어야 스프링 데이터 JPA가 사용자 정의 구현 클래스로 인식한다.\n3. 레포지토리 인터페이스에서 사용자 정의 인터페이스를 상속받으면 된다. (레포지토리 인터페이스는 결과적으로 `JpaRepository` 와 사용자 정의 인터페이스를 상속받음)\n\n---\n\n## 💫 Web 확장\n스프링 데이터 프로젝트는 스프링 MVC에서 사용할 수 있는 편리한 기능을 제공한다. 식별자로 도메인 클래스를 바로 바인딩해주는 도메인 클래스 컨버터 기능과 페이징, 정렬 기능에 대해 알아보자.\n\n### ➰ 설정\n`org.springframework.data.web.config.SpringDataWebConfiguration` 을 스프링 빈으로 등록하면 Web 확장 기능을 사용할 수 있다. \n- JavaConfig를 사용하면 `EnableSpringDataWebSupport` annotation을 `WebAppConfig.java` 에 사용하면 된다.\n\n### ➰ 도메인 클래스 컨버터 기능\nHTTP 파라미터로 넘어온 엔티티의 아이디로 엔티티 객체를 찾아서 바인딩해주는 기능이다. \n- 특정 회원을 수정하는 화면을 보여주려면 컨트롤러는 HTTP 요청으로 넘어온 회원의 아이디를 사용해 레포지토리를 통해 회원 엔티티를 먼저 조회해야 한다.\n- 이후 찾아온 회원 엔티티를 `model` 을 사용해서 뷰에 넘겨준다.\n\n```java\n// 도메인 클래스 컨버터를 적용\n@Controller\npublic class MemberController {\n\n  @RequestMapping(\"member/memberUpdateForm\")\n  public String memberUpdateForm(@RequestParam(\"id\") Member member, Model model) {\n    model.addAttribute(\"member\", member);\n    return \"member/memberSaveForm\";\n  }\n}\n```\n- `@RequestParam(\"id\") Member member` 를 보면 HTTP 요청으로 회원 아이디(`id`)를 받지만 도메인 클래스 컨버터가 중간에 동작해 아이디를 회원 엔티티 객체로 변환해서 넘겨준다.\n  - 따라서 컨트롤러를 단순하게 사용할 수 있다.\n\n> 도메인 클래스 컨버터는 해당 엔티티와 관련된 레포지토리를 사용해서 엔티티를 찾는다. 넘어온 엔티티를 컨트롤러에서 직접 수정해도 실제 데이터베이스에는 반영되지 않는다. \n\n### ➰ 페이징과 정렬 기능\n스프링 MVC에서 페이징과 정렬 기능을 편리하게 사용하기 위해 `HandlerMethodArgumentResolver` 를 제공한다.\n- 페이징 기능: `PageableHandlerMethodArgumentResolver`\n- 정렬 기능: `SortHandlerMethodArgumentResolver`\n\n파라미터로 `Pageable` 을 받고, 이는 다음 요청 파라미터 정보로 만들어진다.\n- `page` : 현재 페이지, 0부터 시작\n- `size` : 한 페이지에 노출할 데이터 건수\n- `sort` : 정렬 조건 정의\n\n**📌 접두사**<br/>\n사용해야 할 페이징 정보가 둘 이상이면 접두사를 사용해 구분할 수 있다. 접두사는 스프링 프레임워크가 제공하는 `@Qualifier` annotation을 사용한다.\n\n**📌 기본값**<br/>\n`Pageable` 의 기본 값은 `page = 0` , `size = 20` 이다. 이를 변경하려면 `@PageableDefault` annotation을 사용한다.\n\n---\n\n## 💫 스프링 데이터 JPA가 사용하는 구현체\n스프링 데이터가 JPA가 제공하는 공통 인터페이스는 `org.springframework.data.jpa.repository.support.SimpleJpaRepository` 클래스가 구현한다. 해당 클래스 코드의 일부를 분석해보면 다음과 같다.\n\n- `@Repository` 적용 : JPA 예외를 스프링이 추상화한 예외로 변환한다.\n- `@Transactional` 트랜잭션 적용 : **JPA의 모든 변경은 트랜잭션 안에서 이뤄져야 한다.** 스프링 데이터 JPA가 제공하는 공통 인터페이스를 사용하면 데이터를 변경(등록, 수정, 삭제)하는 메소드에 `@Transactional` 로 트랜잭션 처리가 되어 있다.\n  - 따라서 서비스 계층에서 트랜잭션을 시작하지 않으면 레포지토리에서 트랜잭션을 시작한다. 서비스 계층에서 시작했다면 레포지토리도 이를 받아 사용한다.\n- `@Transactional(readOnly=true)` : 데이터를 조회하는 메소드에는 해당 옵션이 적용되어 있다. 데이터를 변경하지 않는 트랜잭션에서 해당 옵션을 사용하면 플러시를 생략할 수 있어 약간의 성능 향상을 얻을 수 있다.\n- `save()` 메소드 : 저장할 엔티티가 새로운 엔티티면 저장(`persist`)하고, 이미 있는 엔티티면 병합(`merge`)한다.\n\n> 새로운 엔티티를 판단하는 기본 전략은 엔티티의 식별자를 사용한다. 식별자가 객체일 때 `null` , 자바 기본 타입일 때 숫자 0값이면 새로운 엔티티로 판단한다.\n\n---\n\n## 💫 JPA 샵에 적용\n### ➰ 환경 설정\n`pom.xml` 에 `spring-data-jpa` 라이브러리를 추가한다. 그리고 `appConfig.xml` 에 `<jpa:repositories>` 를 추가하고, `base-package` 속성에 레포지토리 위치를 지정한다.\n\n### ➰ 레포지토리 리팩토링\n**📌 회원 레포지토리 리팩토링**\n- 클래스를 인터페이스로 변경하고, 스프링 데이터 JPA가 제공하는 `JpaRepository` 를 상속받는다. \n  - 이때 제네릭 타입을 `<Member, Long>` 으로 지정해 회원 레포지토리가 관리하는 회원 엔티티 타입의 식별자 타입을 정의한다.\n- 상속받은 `JpaRepository` 가 모두 제공하는 기본 메소드들을 제거한다. 남은 `findByName()` 메소드는 스프링 데이터 JPA가 해당 메소드의 이름을 분석해 적절한 쿼리를 실행해 줄 것이다.\n\n**📌 상품 레포지토리 리팩토링**\n- 모든 기능은 스프링 데이터 JPA가 제공하는 공통 인터페이스로 충분해 메소드를 모두 제거한다.\n\n**📌 주문 레포지토리 리팩토링**\n- \"검색\"이라는 복잡한 로직이 있다. 명세 기능을 사용해 검색을 구현해보도록 한다.\n  - 공통 인터페이스로 가능한 메소드들은 모두 제거하고, `JpaSpecificationExecutor` 를 추가로 상속받는다.\n\n### ➰ 명세 적용\n명세를 작성하기 위한 클래스를 추가한다. \n\n```java\npublic static Specification<Order> memberNameLike(final String memberName) {\n  return new Specificaiton<Order>() {\n    public Predicate toPredicate(Root<Order> root, CriteriaQuery<?> query, CriteriaBuilder builder) {\n      if (StringUtils.isEmpty(memberName)) return null;\n\n      Join<Order, Member> m = root.join(\"member\", JoinType.INNER);\n      return builder.like(m.<String>get(\"name\"), \"%\" + memberName + \"%\");\n    }\n  };\n}\n\npublic static Specification<Order> orderStatusEq(final OrderStatus orderStatus) {\n  return new Specification<Order>() {\n    public Predicate toPredicate(Root<Order> root, CriteriaQuery<?> query, CriteriaBuilder builder) {\n      if (orderStatus == null) return null;\n\n      return builder.equal(root.get(\"status\"), orderStatus);\n    }\n  };\n}\n```\n- 검색조건을 가지고 있는 `OrderSearch` 객체에 자신이 가진 검색조건으로 `Specification` 을 생성하도록 코드를 추가한다.\n- 그리고, 레포지토리의 검색 코드가 명세를 파라미터로 넘기도록 변경한다.\n\n---\n\n## 💫 스프링 데이터 JPA와 QueryDSL 통합\n스프링 데이터 JPA는 2가지 방법으로 QueryDSL을 지원한다.\n- `org.springframework.data.querydsl.QueryDslPredicateExecutor`\n- `org.springframework.data.querydsl.QueryDslRepositorySupport`\n\n### ➰ QueryDslPredicateExecutor 사용\n첫 번째 방법은 레포지토리에서 `QueryDslPredicateExecutor` 를 상속받으면 된다.\n\n```java\npublic interface ItemRepository extends JpaRepository<Item, Long>, QueryDslPredicateExecutor<Item> {}\n```\n- QueryDSL을 검색조건으로 사용하면서 스프링 데이터 JPA가 제공하는 페이징과 정렬 기능도 함께 사용할 수 있다.\n- 다만, `join` , `fetch` 를 사용할 수 없다는 한계가 있다.\n  - 따라서 QueryDSL이 제공하는 다양한 기능을 사용하려면 `JPAQuery` 를 직접 사용하거나 스프링 데이터 JPA가 제공하는 `QueryDslRepositorySupport` 를 사용해야 한다.\n\n### ➰ QueryDslRepositorySupport 사용\nQueryDSL의 모든 기능을 사용하려면 `JPAQuery` 객체를 직접 생성해서 사용해야 한다.\n- 이때 스프링 데이터 JPA가 제공하는 `QueryDslRepositorySupport` 를 상속받아 사용할 수 있다.\n\n스프링 데이터 JPA가 제공하는 공통 인터페이스는 직접 구현할 수 없기 때문에 사용자 정의 레포지토리를 만들어야 한다.\n- `QueryDslRepositorySupport` 를 사용해 QueryDSL로 검색 조건에 따라 동적으로 쿼리를 생성한다.\n  - 참고로 생성자에서 `QueryDslRepositorySupport` 에 엔티티 클래스 정보를 넘겨줘야 한다.\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 스프링 프레임워크 스프링 프레임워크와 JPA를 함께 사용한다는 것은 스프링 컨테이너 위에서 JPA를 사용한다는 의미다.  따라서 스프링 컨테이너가 제공하는 데이터베이스 커넥션과 트랜잭션 처리 기능을 사용할 수 있다. 💫 프로젝트 환경설정 📌 프로젝트 환경설정 진행 순서…","fields":{"slug":"/[JPA]11/"},"frontmatter":{"date":"March 31, 2022","title":"📚 11. 웹 애플리케이션 제작","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 스프링 프레임워크\n> - 스프링 프레임워크와 JPA를 함께 사용한다는 것은 스프링 컨테이너 위에서 JPA를 사용한다는 의미다. \n> - 따라서 스프링 컨테이너가 제공하는 데이터베이스 커넥션과 트랜잭션 처리 기능을 사용할 수 있다.\n\n## 💫 프로젝트 환경설정\n**📌 프로젝트 환경설정 진행 순서**<br/>\n1. 프로젝트 구조 분석\n2. 메이븐과 라이브러리 설정\n3. 스프링 프레임워크 설정\n\n웹 애플리케이션을 구현하기 위해 웹 서버를 실행해야 하는데 **메이븐의 톰캣 플러그인**을 사용한다.\n\n### ➰ 프로젝트 구조\n```java\njpashop (프로젝트 루트)\n- src (소스 폴더)\n  - main (실행 코드)\n    - java (자바 소스 코드)\n    - resources (리소스)\n    - webapp (웹 폴더)\n  - test (테스트 코드)\n- target (빌드 결과)\n- pom.xml (메이븐 설정 파일)\n```\n\n### ➰ 메이븐과 사용 라이브러리 관리\n`pom.xml` 에서 프로젝트 정보와 사용할 라이브러리를 지정 및 관리할 수 있다.\n- `<modelVersion>` : POM 모델 버전, 그대로 사용한다.\n- `<groupId>` : 프로젝트 그룹 명\n- `<artifactId>` : 프로젝트를 식별하는 아이디\n- `<version>` : 프로젝트 버전\n- `<name>` : 프로젝트 이름\n- `<packaging>` : 빌드 패키징 방법을 지정한다. 웹 애플리케이션은 `war` , 자바 라이브러리는 `jar` 로 설정한다.\n- `<dependencies>` : 사용할 라이브러리를 지정한다.\n- `<build>` : 빌드 관련 정보를 설정한다.\n\n수많은 라이브러리들이 있고, 이들 간 충돌을 피하기 위해 `groupId` + `artifactId` 는 유일해야 한다.\n\n`<dependencies>` 에는 사용할 라이브러리를지정한다. 명시한 라이브러리는 메이븐 공식 저장소에서 자동으로 내려받아 라이브러리에 추가된다.\n- 핵심 라이브러리\n  - 스프링 MVC : 스프링 MVC 라이브러리\n  - 스프링 ORM : 스프링 프레임워크와 JPA를 연동하기 위한 라이브러리\n  - JPA, Hibernate : JPA 표준과 Hibernate를 포함하는 라이브러리, hibernate-entitymanager를 라이브러리로 지정하면 다음 중요 라이브러리도 함께 내려받는다.\n    - `hibernate-core` , `hibernate-jpa-2.1-api`\n- 기타 라이브러리\n  - H2 데이터베이스 : 아주 작은 데이터베이스다. 별도의 설치 없이 JVM 메모리 안에서 동작하는 기능도 있다.\n  - 커넥션 풀 : `tomcat-jdbc` 커넥션 풀을 사용한다.\n  - WEB : 서블릿, JSP와 관련된 라이브러리\n  - 로깅 SLF4J & LogBack : 로그와 관련된 라이브러리\n  - 테스트 : 테스트용 라이브러리, `spring-test` 는 스프링 프레임워크와 통합 테스트를 지원한다.\n\n> **메이븐 `<dependency>` 의 `<scope>` 설정**\n> - compile(default) : 컴파일 시 라이브러리를 사용한다.\n> - runtime : 실행 시 라이브러리를 사용한다.\n> - provided : 외부에서 라이브러리가 제공된다. 컴파일 시 사용하지만 빌드에 포함하지 않는다. 보통 JSP, 서블릿 라이브러리들에 사용한다.\n> - test : 테스트 코드에만 사용한다.\n\n> **의존성 전이(Transitive dependency)**\n> - spring-mvc 라이브러리를 사용하려면 spring-core 라이브러리가 필요하다. 이를 \"spring-mvc는 spring-core에 의존한다\"고 표현한다. \n> - 메이븐은 의존관계가 있는 라이브러리도 함께 내려받아 라이브러리에 자동으로 추가하는데, 이를 의존성 전이라고 한다.\n\n### ➰ 스프링 프레임워크 설정\n```java\njpashop (프로젝트 루트)\n- src (소스 폴더)\n  - main (실행 코드)\n    - java (자바 소스 코드)\n      - jpabook\n        - jpashop\n          - domain\n          - repository\n          - service\n          - web\n    - resources (리소스)\n      - appConfig.xml (스프링 애플리케이션 관련 설정 파일)\n      - webAppConfig.xml (스프링 웹 관련 설정 파일)\n    - webapp (웹 폴더)\n      - WEB-INF\n        - web.xml (웹 애플리케이션 환경설정 파일)\n```\n- `web.xml` : 웹 애플리케이션 환경설정 파일, 웹 애플리케이션에서 스프링 프레임워크를 구동하기 위한 설정이 대부분이다.\n  - `appConfig.xml` 을 설정하는 부분과 `webAppConfig.xml` 을 설정하는 부분으로 나뉘고, 스프링 프레임워크를 설정할 때 보통 웹 계층과 비즈니스 도메인 계층을 나누어 관리한다.\n  - `webAppConfig.xml` : 스프링 MVC 설정을 포함해 웹 계층을 담당\n  - `appConfig.xml` : 비즈니스 로직, 도메인 계층, 서비스 계층, 데이터 저장 계층을 담당\n- `webAppConfig.xml` : 스프링 웹 관련 환경설정 파일\n  - `<mvc:annotation-driven>` : 스프링 MVC 기능을 활성화\n  - `<context:component-scan>` : `basePackages` 를 포함한 하위 패키지를 검색해 `@Component` , `@Service` , `@Repository` , `@Controller` annotation이 있는 클래스들을 스프링 빈으로 자동 등록\n  - `<bean>` : 스프링 빈을 등록\n- `appConfig.xml` : 스프링 애플리케이션 관련 환경설정 파일\n  - `<tx:annotation-driven/>` : 스프링 프레임워크가 제공하는 annotation 기반의 트랜잭션 관리자를 활성화, `@Transactional` 이 붙은 곳에 트랜잭션을 적용\n  - H2 데이터베이스 접속 URL을 `jdbc:h2:mem:...` 으로 설정해 JVM 안에서 동작하는 **인 메모리 데이터베이스**로 사용하도록 설정 (별도의 데이터베이스 서버의 실행을 요구하지 않는 모드, 애플리케이션의 생명주기에 종속적)\n  - JPA를 사용하기 위해 `org.springframework.orm.jpa.JpaTransactionManager` 를 트랜잭션 관리자로 등록\n  - `@Repository` annotation이 붙어 있는 스프링 빈에 예외 변환 AOP를 적용하기 위해 `PersistenceExceptionTranslationPostProcessor` 를 설정(이 AOP는 JPA 예외를 스프링 프레임워크가 추상화한 예외로 변환)\n  - JPA를 사용하려면 또한 스프링 프레임워크가 제공하는 `LocalContainerEntityManagerFactoryBean` 을 스프링 빈으로 등록\n    - `LocalContainerEntityManagerFactoryBean` : JPA를 스프링 컨테이너에서 사용할 수 있도록 스프링 프레임워크가 제공하는 기능 (`spring-orm` 라이브러리가 제공)\n    - `dataSource` : 사용할 데이터소스를 등록\n    - `packageToScan` : `@Entity` 가 붙은 클래스를 자동으로 검색하기 위한 시작점 지정\n    - `persistenceUnitName` : 영속성 유닛 이름을 지정 (설정하지 않으면 `default` 이름으로 영속성 유닛 생성)\n    - `jpaVendorAdapter` : 사용할 JPA 벤더를 지정\n\n**📌 Hibernate 속성 설정**<br/>\n`jpaProperties` 를 이용해 Hibernate의 구현체 속성을 설정할 수 있다.\n- `hibernate.dialect` : 사용할 데이터베이스 방언 설정\n- `hibernate.show_sql` : 실행하는 SQL을 콘솔에 출력\n- `hibernate.format_sql` : SQL을 보기 좋게 정리해서 출력\n- `hibernate.use_sql_comments` : SQL을 출력할 때 어떻게 실행된 것인지 또는 사용자가 설정한 코멘트를 남김\n- `hibernate.id.new_generator_mappings` : JPA에 맞춘 새로운 ID 생성 방법을 사용, Hibernate 레거시를 운영하는 것이 아니면 항상 `true` 설정\n- `hibernate.hbm2ddl.auto` : 애플리케이션이 시작될 때 테이블과 기타 DDL을 자동으로 생성\n  - `create` : 기존 제거, 새로 생성\n  - `create-drop` : `create` 와 동일하지만 애플리케이션 종료 시 생성한 DDL 제거\n  - `update` : 현재 데이터베이스 DDL과 비교해 변경사항만 수정\n  - `validate` : 현재 엔티티 매핑 정보와 데이터베이스 스키마가 같은지 비교, 다르면 경고를 남기고 애플리케이션을 실행하지 않음. (DDL은 변경하지 않는 옵션)\n\n---\n\n## 💫 도메인 모델과 테이블 설계\n### ➰ 요구사항 분석\n\n### ➰ 도메인 모델 설계\n\n### ➰ 테이블 설계\n\n### ➰ 연관관계 정리\n\n### ➰ 엔티티 클래스\n\n---\n\n## 💫 애플리케이션 구현\n\n### ➰ 개발 방법\n\n### ➰ 회원 기능\n\n### ➰ 상품 기능\n\n### ➰ 주문 기능\n\n### ➰ 웹 계층 구현\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"문제 드래곤 커브는 다음과 같은 세 가지 속성으로 이루어져 있으며, 이차원 좌표 평면 위에서 정의된다. 좌표 평면의 x축은 → 방향, y축은 ↓ 방향이다. 시작 점 시작 방향 세대 0세대 드래곤 커브는 아래 그림과 같은 길이가 1인 선분이다. 아래 그림은 (0, 0)에서 시작하고, 시작 방향은 오른쪽인 0세대 드래곤 커브이다. 1세대 드래곤 커브는 0세대…","fields":{"slug":"/[BOJ]15685/"},"frontmatter":{"date":"March 30, 2022","title":"👩‍💻 15685. 드래곤 커브","tags":["구현","시뮬레이션"]},"rawMarkdownBody":"\n## 문제\n드래곤 커브는 다음과 같은 세 가지 속성으로 이루어져 있으며, 이차원 좌표 평면 위에서 정의된다. 좌표 평면의 x축은 → 방향, y축은 ↓ 방향이다.\n1. 시작 점\n2. 시작 방향\n3. 세대\n\n0세대 드래곤 커브는 아래 그림과 같은 길이가 1인 선분이다. 아래 그림은 (0, 0)에서 시작하고, 시작 방향은 오른쪽인 0세대 드래곤 커브이다.\n\n<img src=\"http://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/problem/15685/1.png\" width=\"30%\">\n\n1세대 드래곤 커브는 0세대 드래곤 커브를 끝 점을 기준으로 시계 방향으로 90도 회전시킨 다음 0세대 드래곤 커브의 끝 점에 붙인 것이다. 끝 점이란 시작 점에서 선분을 타고 이동했을 때, 가장 먼 거리에 있는 점을 의미한다.\n\n<img src=\"https://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/problem/15685/2.png\" width=\"30%\">\n\n2세대 드래곤 커브도 1세대를 만든 방법을 이용해서 만들 수 있다. (파란색 선분은 새로 추가된 선분을 나타낸다)\n\n<img src=\"https://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/problem/15685/3.png\" width=\"30%\">\n\n3세대 드래곤 커브도 2세대 드래곤 커브를 이용해 만들 수 있다. 아래 그림은 3세대 드래곤 커브이다.\n\n<img src=\"https://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/problem/15685/4.png\" width=\"30%\">\n\n즉, K(K > 1)세대 드래곤 커브는 K-1세대 드래곤 커브를 끝 점을 기준으로 90도 시계 방향 회전 시킨 다음, 그것을 끝 점에 붙인 것이다.\n\n크기가 100×100인 격자 위에 드래곤 커브가 N개 있다. 이때, 크기가 1×1인 정사각형의 네 꼭짓점이 모두 드래곤 커브의 일부인 정사각형의 개수를 구하는 프로그램을 작성하시오. 격자의 좌표는 (x, y)로 나타내며, 0 ≤ x ≤ 100, 0 ≤ y ≤ 100만 유효한 좌표이다.\n\n## 입, 출력\n\n입력\n- 첫째 줄에 드래곤 커브의 개수 N(1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 드래곤 커브의 정보가 주어진다. 드래곤 커브의 정보는 네 정수 x, y, d, g로 이루어져 있다. x와 y는 드래곤 커브의 시작 점, d는 시작 방향, g는 세대이다. (0 ≤ x, y ≤ 100, 0 ≤ d ≤ 3, 0 ≤ g ≤ 10)\n- 입력으로 주어지는 드래곤 커브는 격자 밖으로 벗어나지 않는다. 드래곤 커브는 서로 겹칠 수 있다.\n- 방향은 0, 1, 2, 3 중 하나이고, 다음을 의미한다.\n  - 0: x좌표가 증가하는 방향 (→)\n  - 1: y좌표가 감소하는 방향 (↑)\n  - 2: x좌표가 감소하는 방향 (←)\n  - 3: y좌표가 증가하는 방향 (↓)\n\n출력\n- 첫째 줄에 크기가 1×1인 정사각형의 네 꼭짓점이 모두 드래곤 커브의 일부인 것의 개수를 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass DragonMap {\n    int[][] map = new int[101][101];\n    int[] rangeX = { 1, 0, -1, 0 };\n    int[] rangeY = { 0, -1, 0, 1 };\n    ...\n\n}\n```\n\n- 드래곤 커브를 그리기 위한 `map` 과 방향에 따른 이동을 위해 사용하는 범위 정보를 저장하는 클래스\n\n```java\npublic void drawDragonCurves(int x, int y, int d, int g) {\n    List<Integer> dirList = new ArrayList<>();\n    dirList.add(d);\n\n    for (int i = 0; i < g; i++) {\n        for (int j = dirList.size() - 1; j >= 0; j--) {\n            dirList.add(getCountClockDir(dirList.get(j)));\n        }\n    }\n\n    map[x][y] = 1;\n    for (Integer dir : dirList) {\n        x += rangeX[dir];\n        y += rangeY[dir];\n        map[x][y] = 1;\n    }\n}\n```\n\n- 리스트에 방향 정보를 저장하고, 마지막에 저장한 방향 정보부터 차례로 반시계 방향으로 돌린 방향 정보를 저장한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.ArrayList;\n    import java.util.Arrays;\n    import java.util.List;\n\n    class DragonMap {\n        int[][] map = new int[101][101];\n        int[] rangeX = { 1, 0, -1, 0 };\n        int[] rangeY = { 0, -1, 0, 1 };\n\n        public void drawDragonCurves(int x, int y, int d, int g) {\n            List<Integer> dirList = new ArrayList<>();\n            dirList.add(d);\n\n            for (int i = 0; i < g; i++) {\n                for (int j = dirList.size() - 1; j >= 0; j--) {\n                    dirList.add(getCountClockDir(dirList.get(j)));\n                }\n            }\n\n            map[x][y] = 1;\n            for (Integer dir : dirList) {\n                x += rangeX[dir];\n                y += rangeY[dir];\n                map[x][y] = 1;\n            }\n        }\n\n        public int countSquares() {\n            int counts = 0;\n\n            for (int i = 0; i < 100; i++) {\n                for (int j = 0; j < 100; j++) {\n                    if (map[i][j] == 1 && map[i][j + 1] == 1 && map[i + 1][j] == 1 && map[i + 1][j + 1] == 1) {\n                        counts++;\n                    }\n                }\n            }\n\n            return counts;\n        }\n\n        private int getCountClockDir(int dir) {\n            return (dir + 1) % 4;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\n            int N = Integer.parseInt(br.readLine());\n\n            DragonMap dragons = new DragonMap();\n\n            for (int i = 0; i < N; i++) {\n                int[] info = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n                dragons.drawDragonCurves(info[0], info[1], info[2], info[3]);\n            }\n            br.close();\n\n            System.out.println(dragons.countSquares());\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 매 세대마다 방향이 바뀌는 것에 대해, 이를 리스트에 저장하고 계속 업데이트해주는 방식은 생각했지만, 왜인지 리스트도 큐처럼 `push` , `pop` 을 해야 하니까 비효율적이지 않나 ... 하는 생각에 사로잡혀 혼자 꽉 막혀버렸다.\n- 다른 방법은 뭐가 있나 싶어 한 블로그를 봤는데, 생각한 그대로를 구현한 글을 발견해서 나의 무지함을 깨달았다.\n\n### 📕 출처\n- Baekjoon : https://www.acmicpc.net/problem/15685\n- [15685](https://velog.io/@hammii/%EB%B0%B1%EC%A4%80-15685-%EB%93%9C%EB%9E%98%EA%B3%A4-%EC%BB%A4%EB%B8%8C-java)"},{"excerpt":"🧷 자바 코드의 실행과정 먼저, 아래의 그림으로 자바 코드가 JVM에 전달되는 과정을 살펴볼 수 있다.\n 작성한 자바 코드 파일()을 자바 컴파일러()가 자바 바이트 코드()로 컴파일한다. 컴파일된 코드를 JVM의 클래스 로더(Class Loader)에 전달한다. 클래스 로더는 동적 로딩을 통해 필요한 클래스들을 로딩 및 링크하여 런타임 데이터 영역 즉,…","fields":{"slug":"/[면접]JVM 동작원리/"},"frontmatter":{"date":"March 30, 2022","title":"💬 JVM 동작원리","tags":["개발상식","Java","JVM"]},"rawMarkdownBody":"\n## 🧷 자바 코드의 실행과정\n먼저, 아래의 그림으로 자바 코드가 JVM에 전달되는 과정을 살펴볼 수 있다.\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Ft1.daumcdn.net%2Fcfile%2Ftistory%2F99A840415B739DF119\" width=\"80%\">\n1. 작성한 자바 코드 파일(`.java`)을 자바 컴파일러(`javac`)가 자바 바이트 코드(`.class`)로 컴파일한다.\n2. 컴파일된 코드를 JVM의 클래스 로더(Class Loader)에 전달한다.\n3. 클래스 로더는 동적 로딩을 통해 필요한 클래스들을 로딩 및 링크하여 런타임 데이터 영역 즉, JVM의 메모리에 올린다.\n4. 실행 엔진(Execution Engine)은 JVM 메모리에 올라온 바이트 코드들을 명령어 단위로 실행한다.\n\n## 🧷 JVM이란\nJava Virtual Machine의 약자인 JVM은 자바 가상 머신이다.\n- 다르게 말하면, 컴파일된 코드(바이트 코드)를 실행하는 가상의 컴퓨터라고 할 수 있다.\n- 자바와 운영체제 사이에서 중개자 역할을 수행하여 운영체제에 구애받지 않고 프로그램을 실행할 수 있도록 돕는다. \n  - **플랫폼 독립성**을 보장한다.\n  - > **플랫폼 독립성**이란?\n    > - 자바의 실행 파일(`.class`)는 특정 플랫폼만 이해할 수 있는 기계어의 집합이다.\n    > - 각 플랫폼마다의 JVM을 설치하여, 하나의 프로그램이 모든 플랫폼에서 동작할 수 있게 한다.\n- 가비지 컬렉터를 사용한 메모리 관리를 수행한다.\n- 레지스터 기반이 아닌 스택 기반으로 동작한다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Ft1.daumcdn.net%2Fcfile%2Ftistory%2F990BF73B5B73A02817\" width=\"80%\">\n- JRE : Java Runtime Environment의 약자로, 자바를 이용해 프로그램을 개발하는데 필요한 도구를 모아 둔 집합인 JDK(Java Development Kit)를 사용해 완성된 자바 프로그램을 실행시키는데 필요한 환경이다. \n\n### 🗝 클래스 로더\n자바 클래스들은 메모리에 한 번에 로드되지 않고, 필요할 때에 애플리케이션에 의해 로드된다. 이때, JRE의 일부인 클래스 로더는 자바 클래스들을 동적으로 JVM의 메모리에 로드한다.\n\n**📌 클래스 로더의 타입**\n모든 자바 클래스들이 하나의 클래스 로더에 의해 로드되는 것은 아니다. **클래스 로더의 타입에 따라 특정 자바 클래스들을 로드**한다.<br/>\n또한, 모든 자바 클래스들은 그들의 클래스명에 의해 로드되고, 없는 경우에는 `NoClassDefFoundError` 또는 `ClassNotFoundException` 를 반환한다.\n\n> 클래스를 로드하는 클래스 로더를 확인하기 위해서는 `getClassLoader()` 메소드를 사용할 수 있다.\n\n자바 클래스 로더의 타입은 아래 3가지가 있다.\n1. Bootstrap Class Loader\n      - JVM 시작 시 최초로 실행되는 클래스 로더다. \n      - 자바 클래스를 로드하는 것이 아닌 자바 클래스들을 로드할 수 있는 자바 자체의 클래스 로더와 최소한의 자바 클래스(자바 런타임 코어 클래스)만을 로드한다.\n      - 상위 클래스 로더가 없기에, Primodial ClassLoader라고도 한다.\n2. Extension Class Loader\n      - Bootstrap Class Loader의 자식 클래스 로더로서, 확장 자바 클래스들을 로드한다. \n      - `jre/lib/ext` 디렉토리나, `java.ext.dirs` 환경변수에 설정된 디렉토리로부터 클래스들을 로드한다.\n3. System Class Loader\n      - Application Class Loader라고도 한다.\n      - 자바 프로그램 실행 시 지정한 CLASSPATH에 있는 클래스 파일 또는 Jar에 속한 클래스들을 로드한다.\n      - Extension Class Loader의 자식 클래스이다.\n\n**📌 클래스 로더의 원칙**<br/>\n아래는 자바 클래스 로더들의 동작 구조를 보여준다. 클래스 로더는 지켜야 할 **3가지 원칙**이 있다.\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Ft1.daumcdn.net%2Fcfile%2Ftistory%2F99B467465B73D15111\" width=\"80%\">\n\n**📌 Delegation Principle (위임 법칙)**\n- JVM과 자바 클래스 로더들은 **Delegation Hierarchy Algorithm**라는 알고리즘을 사용해서 자바 클래스를 자바 파일에 로드한다.\n- 위임 법칙은 **클래스 로딩이 필요한 경우 부모 클래스로더 방향으로 클래스 로딩을 위임**하는 것이다.\n  - 새로운 클래스를 로드해야할 때, 다음 방식으로 수행한다.\n  1. JVM의 Method area에 클래스가 로드되어 있는지 확인하고, 로드되어 있다면 해당 클래스를 사용한다. 그렇지 않다면 Application Class Loader에 클래스 로드를 요청한다.\n  2. Application Class Loader는 Extension Class Loader에 클래스 로드를 요청한다.\n  3. Extension Class Loader는 Bootstrap Class Loader에 클래스 로드를 요청한다.\n  4. Bootstrap Class Loader는 Bootstrap CLASSPATH(JDK, JRE, LIB)에 해당 클래스가 있는지 확인한다. 클래스가 존재하지 않는 경우, Extension Class Loader가 요청을 수행하도록 한다.\n  5. Extension Class Loader 또한 Extension CLASSPATH(JDK, JRE, LIB, EXT)를 확인하고, 존재하지 않는 경우, Application Class Loader가 요청을 수행하도록 한다.\n  6. Application Class Loader 또한 Application CLASSPATH를 확인하고 존재하지 않는 경우, `ClassNotFoundException` 을 발생시킨다.\n  <img src=\"https://media.geeksforgeeks.org/wp-content/uploads/20190417144207/java_classloader-1024x311.png\" width=\"80%\">\n\n  > 중요한 것은 Bootstrap Class Loader까지 요청하는 와중에 해당 클래스를 발견하더라도, Bootstrap Class Loader까지 이동한 후에 Bootstrap Class Loader에 해당 클래스가 있다면 Bootstrap Class Loader에 있는 클래스를 로드한다는 점이다.\n\n**📌 Visibility Principle (가시범위 원칙)**\n- 하위 클래스 로더는 상위 클래스 로더가 로드한 클래스를 확인할 수 있지만, 반대로는 불가능하다는 원칙이다.\n- `java.lang.Object` 클래스 등 상위 클래스 로더에서 로드한 클래스도 하위 클래스 로더에서 사용할 수 있는 것이다. \n\n**📌 Uniqueness Property (유일성 원칙)**<br/>\n- 하위 클래스 로더가 상위 클래스 로더에서 로드한 클래스를 다시 로드하지 않아야 한다는 원칙이다.\n- JVM에 동일한 클래스가 2개 이상 로드되는 상황을 방지하기 위해 필요하다.\n\n**📌 언로드 불가**<br/>\n- 클래스 로더는 클래스를 로드하는 것은 가능하지만, 언로드하는 것은 불가능하다.\n\n**📌 Name space (이름 공간)**<br/>\n- 각 클래스 로더들이 가지고 있는 공간으로, 로드된 클래스를 보관하는 공간이다.\n- 클래스를 로드할 때 위임 법칙을 통해 상위 클래스 로더를 확인하는데, 그때 확인하는 공간이다.\n- Name space가 다르면, 서로 다른 클래스로 간주한다.\n\n### 🗝 런타임 데이터 영역\nJVM이 OS 위에서 실행되면서 할당받는 메모리 영역이다. 크게 5가지, 세분화하면 6가지로 나눌 수 있다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Ft1.daumcdn.net%2Fcfile%2Ftistory%2F99B467465B73D15111\" width=\"60%\">\n\n**📌 PC Register**<br/>\n현재 수행 중인 명령의 주소를 가지며 스레드가 시작될 때 생성되며 각 스레드마다 하나씩 존재한다.\n\n**📌 JVM Stack**<br/>\n스택 프레임이라는 구조체를 저장하는 스택이다. \n- 예외 발생 시 `printStackTrace()` 메소드로 출력하는 Stack Trace의 각 라인 하나가 스택 프레임을 표현한다. \n- 스레드가 시작될 때 생성되며 각 스레드마다 하나씩 존재한다.\n\n**📌 Native Method Stack**<br/>\nJAVA 외의 언어로 작성된 Native 코드를 위한 스택이다. \n- JNI(Java Native Interface)를 통해 호출하는 코드를 수행하기 위한 스택으로, 언어에 맞게 스택이 생성된다.\n- 스레드가 시작될 때 생성되며 각 스레드마다 하나씩 존재한다.\n\n**📌 Heap**<br/>\n인스턴스 또는 객체를 저장하는 공간으로, Garbage Collection의 대상이다.\n- 모든 스레드가 공유하는 공간이다.\n\n**📌 Method Area**<br/>\nJVM이 시작될 때 생성되는 공간으로, JVM이 읽어들인 각각의 클래스와 인터페이스에 대한 Runtime Constant Pool, 필드와 메소드에 대한 정보, Static 변수, 메소드의 바이트 코드 등을 보관한다.\n- 모든 스레드가 공유하는 공간이다.\n\n**📌 Runtime Constant Pool**<br/>\nJVM 동작에서 가장 핵심적인 역할을 수행하는 공간으로, 각 클래스와 인터페이스의 상수 뿐만 아니라 메소드와 필드에 대한 모든 레퍼런스까지 담고 있는 테이블이다.\n- 어떤 필드나 메소드를 참조할 때, JVM은 이를 참고하여 참조한다.\n\n### 🗝 실행 엔진\n클래스 로더를 통해 런타임 데이터 영역에 배치된 바이트 코드를 명령어 단위로 읽어서 실행한다. \n\n> 바이트 코드의 각 명령어는 1바이트 크기의 Operation Code와 추가 피연산자로 이뤄져 있다. \n\n실행 엔진은 하나의 Operation Code를 가져와 피연산자와 작업을 수행한 다음, 그 다음 Operation Code를 수행하는 방식으로 동작한다. 이 수행 과정에서 실행 엔진은 바이트 코드를 기계가 실행할 수 있는 형태로 변환하는데, 다음 두 가지 방식으로 변경한다.\n- **인터프리터** : 바이트 코드 명령어를 하나씩 읽어서 해석하고 실행한다. 하나하나의 실행은 빠르지만 전체적인 실행 속도는 느리다. 기본 동작 방식이다.\n- **JIT(Just-In-Time) 컴파일러** : 인터프리터의 단점을 보완하기 위해 바이트 코드 전체를 컴파일하여 네이티브 코드로 변경하고 이후에는 해당 메소드를 더 이상 인터프리팅하지 않고 네이티브 코드로 직접 실행하는 방식이다. 따라서 전체적인 실행 속도는 인터프리터보다 빠르다.\n\n## 🧷 JVM 메모리 구조\n\n## 🧷 JVM 동작 원리\n\n## 📕 참고\n- [[JAVA] JVM 동작원리 및 기본개념](https://steady-snail.tistory.com/67)\n- [JVM 메모리 구조란? (JAVA)](https://steady-coding.tistory.com/305)\n- [자바의 클래스로더 알아보기](https://leeyh0216.github.io/posts/java_class_loader/)\n- [클래스 로더](https://www.geeksforgeeks.org/classloader-in-java/)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. JPQL은 가장 중요한 객체지향 쿼리 언어이다. 💫 객체지향 쿼리 소개  메소드를 사용해 식별자로 엔티티 하나를 조회할 수 있다. 이렇게 조회한 엔티티에 객체 그래프 탐색을 사용하면 연관된 엔티티들을 찾을 수 있고, 아래는 가장 단순한 검색 방법이다. 식별자로 조회 -…","fields":{"slug":"/[JPA]10/"},"frontmatter":{"date":"March 29, 2022","title":"📚 10. 객체지향 쿼리 언어","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> JPQL은 가장 중요한 객체지향 쿼리 언어이다.\n\n## 💫 객체지향 쿼리 소개\n`em.find()` 메소드를 사용해 식별자로 엔티티 하나를 조회할 수 있다. 이렇게 조회한 엔티티에 객체 그래프 탐색을 사용하면 연관된 엔티티들을 찾을 수 있고, 아래는 가장 단순한 검색 방법이다.\n- 식별자로 조회 - `em.find()`\n- 객체 그래프 탐색 - `a.getB().getC()`\n\nORM을 사용하면 데이터베이스 테이블이 아닌 엔티티 객체를 대상으로 개발하므로 검색도 테이블이 아닌 엔티티 객체를 대상으로 하는 방법이 필요하다. JPQL은 이런 문제를 해결하기 위해 만들어져서 아래의 특징이 있다.\n- 테이블이 아닌 객체를 대상으로 검색하는 객체지향 쿼리다.\n- SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.\n\n> SQL이 \"데이터베이스 테이블을 대상으로 하는 데이터 중심의 쿼리\"라면, JPQL은 \"엔티티 객체를 대상으로 하는 객체지향 쿼리\"다. JPQL을 사용하면 JPA는 이 JPQL을 분석한 다음 적절한 SQL을 만들어 데이터베이스를 조회하고, 조회한 결과로 엔티티 객체를 생성해서 반환한다. \n\nJPA는 JPQL뿐만 아니라 다양한 검색 방법을 제공하고, 아래는 JPA가 공식 지원하는 기능이다.\n- JPQL(Java Persistence Query Language)\n- Criteria 쿼리: JPQL을 편하게 작성하도록 도와주는 API, 빌더 클래스 모음이다.\n- 네이티브 SQL: JPA에서 JPQL 대신 직접 SQL을 사용할 수 있다.\n\n### ➰ JPQL 소개\nJPQL은 **엔티티 객체를 조회하는 객체지향 쿼리**다. SQL을 추상화해서 특정 데이터베이스에 의존하지 않는다. \n- 문법은 SQL과 비슷하고 ANSI 표준 SQL이 제공하는 기능을 유사하게 지원한다.\n- 데이터베이스 방언만 변경하면 JPQL을 수정하지 않아도 자연스럽게 데이터베이스를 변경할 수 있다. \n- SQL보다 간결하다. 엔티티 직접 조회, 묵시적 조인, 다형성 지원으로 코드가 간결하다.\n\n```java\n//쿼리 생성\nString jpql = \"select m from Member as m where m.username = 'kim'\";\nList<Member> resultList = em.createQuery(jpql, Member.class).getResultList();\n```\n\n### ➰ Criteria 쿼리 소개\nJPQL을 생성하는 빌더 클래스다. \n- 문자가 아닌 `query.select(m).where(...)` 처럼 프로그래밍 코드로 JPQL을 작성할 수 있다는 장점이 있다.\n- 오타가 있어도 컴파일은 성공하고 서버에 배포할 수 있지만, 해당 쿼리가 실행되는 런타임 시점에 오류가 발생한다.\n- 컴파일 시점에 오류를 발견할 수 있다.\n- IDE를 사용하면 코드 자동완성을 지원한다.\n- 동적 쿼리를 작성하기 편하다.\n- 하지만 복잡하고 장황하다. 따라서 사용하기 불편할뿐더러, 가독성 또한 좋지 않다.\n\n```java\n//Criteria 사용준비\nCriteriaBuilder cb = em.getCriteriaBuilder();\nCriteriaQuery<Member> query = cb.createQuery(Member.class);\n\n//루트 클래스 (조회를 시작할 클래스)\nRoot<Member> m = query.from(Member.class);\n\n//쿼리 생성\nCriteriaQuery<Member> cq =  query.select(m).where(cb.equal(m.get(\"usernamen\", \"kim\"));\n\nList<Member> resultList = em.createQuery(cq).getResultList();\n```\n- 필드명을 문자로 작성하지 않고 코드로 작성하고 싶다면 **메타 모델**을 사용하면 된다. \n\n### ➰ QueryDSL 소개\nJPQL 빌더 역할을 한다.\n- 코드 기반이면서 단순하고 사용하기 쉽다.\n- 작성한 코드도 JPQL과 비슷해서 가독성이 좋다.\n\n> JPA 표준은 아니고, 오픈소스 프로젝트이다.\n\n```java\n//준비\nJPAQuery query = new JPAQuery(em);\nQMember member = QMember.member;\n\n//쿼리, 결과조회\nList<Member> members = \n    query.from(member)\n    .where(member.username.eq(\"kim\"))\n    .list(member);\n```\n- annotation 프로세서를 사용해 쿼리 전용 클래스를 만들어야 한다. \n  - `QMember` 는 `Member` 엔티티 클래스를 기반으로 생성한 QueryDSL 쿼리 전용 클래스이다.\n\n### ➰ 네이티브 SQL 소개\nSQL을 직접 사용할 수 있는 기능이다. 아래의 경우에 대해 네이티브 SQL을 사용할 수 있다.\n- JPQL을 사용해도 특정 데이터베이스에 의존하는 기능을 사용해야 할 때가 있다. (오라클 데이터베이스의 `CONNECT BY`, 특정 데이터베이스에서만 동작하는 SQL 힌트)\n- 또한 SQL은 지원하지만 JPQL이 지원하지 않는 기능을 사용해야 할 때도 있다.\n\n단점으로는 **특정 데이터베이스에 의존하는 SQL을 작성**해야 한다는 것이다.\n- 데이터베이스의 변경은 네이티브 SQL의 수정을 요구한다.\n\n```java\nString sql = \"SELECT ID, AGE, TEAM_ID, NAME FROM MEMBER WHERE NAME = 'kim'\";\nList<Member> resultList =  em.createNativeQuery(sql, Member.class).getResultList();\n```\n\n### ➰ JDBC 직접 사용, Mybatis 같은 SQL 매퍼 프레임워크 사용\nJDBC 커넥션에 직접 접근하고 싶으면 JPA는 JDBC 커넥션을 획득하는 API를 제공하지 않으므로 JPA 구현체가 제공하는 방법을 사용해야 한다.\n\n```java\nSession session = entityManager.unwrap(Session.class);\nsession.doWork(new Work() {\n\n  @Override\n  public void execute(Connection connection) throws SQLException {\n    // work...\n  }\n});\n```\n- 먼저 Hibernate `Session` 을 구하고, `Session` 의 `doWork()` 메소드를 호출하면 된다.\n- JDBC나 마이바티스를 JPA와 함께 사용하면 영속성 컨텍스트를 적절한 시점에 **강제로 플러시**해야 한다.\n  - JDBC를 직접 사용하든, SQL 매퍼와 사용하든 모두 JPA를 우회해서 데이터베이스에 접근하는데, 문제는 JPA를 우회하는 SQL에 대해서는 JPA가 전혀 인식하지 못한다는 것이다. \n  - 최악의 경우, 영속성 컨텍스트와 데이터베이스를 불일치 상태로 만들어 **데이터 무결성을 훼손**할 수도 있다.\n\nJPA를 우회해서 SQL을 실행하기 직전에 영속성 컨텍스트를 수동으로 플러시해서 데이터베이스와 영속성 컨텍스트를 동기화하면 이러한 이슈를 해결할 수 있다.\n\n---\n\n## 💫 JPQL\nJPQL의 특징이다.\n- JPQL은 객체지향 쿼리 언어이다. 따라서 테이블을 대상으로 쿼리하는 것이 아니라 엔티티 객체를 대상으로 쿼리한다.\n- JPQL은 SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.\n- JPQL은 결국 SQL로 변환된다.\n\n### ➰ 기본 문법과 쿼리 API\nJPQL도 SQL과 비슷하게 SELECT, UPDATE, DELETE 문을 사용할 수 있다. (엔티티를 저장할 때는 `em.persist()`를 사용하면 되므로 INSERT문은 없다.)\n- 전체 구조는 SQL과 비슷하다.\n\n**SELECT 문**\n```sql\nSELECT m FROM Member AS m where m.username = 'Hello'\n```\n- **대소문자 구분** : 엔티티와 속성은 대소문자를 구분한다. 하지만 JPQL 키워드는 대소문자를 구분하지 않는다.\n- **엔티티 이름** : JPQL에서 사용하는 객체는 클래스 명이 아니라 엔티티 명이고 `@Entity(name=”XXX”)` 로 지정할 수 있다. 지정하지 않으면 클래스 명을 기본값으로 사용한다.\n- **별칭은 필수** : JPQL은 별칭을 필수로 사용해야 한다. 별칭 없이 작성하면 잘못된 문법이라는 오류가 발생한다.\n\n**TypeQuery, Query**<br/>\n작성한 JPQL을 실행하려면 쿼리 객체를 만들어야 한다. 쿼리 객체에는 `TypeQuery` 와 `Query` 가 있고 반환 타입 지정에 따라 나뉜다.\n- 반환할 타입을 명확하게 지정할 수 있으면 `TypeQuery` 객체를 사용한다.\n- 반환 타입을 명확하게 지정할 수 없으면 `Query` 객체를 사용한다.\n\n```java\nTypedQuery<Member> query = em.createQuery(\"SELECT m FROM Member m\", Member.class);\n\nList<Member> resultList = query.getResultList();\nfor (Member member : resultList) {\n  System.out.println(\"member = \" + member);\n}\n```\n- `em.createQuery()` 의 두 번째 파라미터에 반환할 타입을 지정하면 `TypeQuery` 를 반환하고 지정하지 않으면 `Query` 를 반환한다. \n- 이때는 조회 대상이 `Member` 엔티티이므로 조회 대상 타입이 명확해 `TypeQuery` 를 사용할 수 있다. 명확하지 않다면 `Query` 로 변경하면 된다.\n\n`Query` 객체는 SELECT 절의 조회 대상이 둘 이상이면 `Object[]` 를 반환하고, 조회 대상이 하나면 `Object` 를 반환한다. 타입을 변환할 필요가 없는 `TypeQuery` 를 사용하는 것이 더 편리하다.\n\n**결과 조회**<br/>\n다음 메소드들을 호출하면 실제 쿼리를 실행해서 데이터베이스를 조회한다.\n- `query.getResultList()` : 결과를 예제로 반환한다. 결과가 없으면 빈 컬렉션을 반환한다.\n- `query.getSingleResult()` : 결과가 **정확히 하나**일 때 사용한다.\n  - 결과가 없으면 `NoResultException` 발생한다.\n  - 1개보다 많으면 `NonUniqueResultException` 발생한다.\n\n### ➰ 파라미터 바인딩\nJDBC는 위치 기준 파라미터 바인딩만 지원하지만 JPQL은 이름 기준 파라미터 바인딩도 지원한다.\n\n**이름 기준 파라미터**<br/>\n파라미터를 이름으로 구분하는 방법으로, 앞에 `:` 를 사용\n```java\nString usernameParam = \"User1\";\n\nTypedQuery<Member> query = em.createQuery(\"SELECT m FROM Member m where m.username = :username\", Member.class);\n\nquery.setParameter(\"username\", usernameParam);\nList<Member> resultList = query.getResultList();\n```\n\n> 참고로 JPQL API는 대부분 메소드 체인 방식으로 설계되어 연속하여 작성이 가능하다.\n\n**위치 기준 파라미터**<br/>\n`?` 다음에 위치 값을 주어 사용한다. \n\n```java\nString usernameParam = \"User1\";\n\nquery.setParameter(\"username\", usernameParam);\nList<Member> resultList = \n    em.createQuery(\"SELECT m FROM Member m where m.username = ?1\", Member.class)\n      .setParameter(1, usernameParam)\n      .getResultList();\n```\n- 위치 기준 파라미터 방식보다는 **이름 기준 파라미터 바인딩 방식**을 사용하는 것이 더 명확하다.\n\n> 파라미터 바인딩 방식은 선택이 아닌 필수이다.\n\n### ➰ 프로젝션\nSELECT 절에 조회할 대상을 지정하는 것이다. 프로젝션 대상에는 **엔티티**, **임베디드 타입**, **스칼라 타입**(숫자, 문자 등 기본 데이터 타입)이 있다.\n\n**엔티티 프로젝션**<br/>\n```sql\nSELECT m FROM Member m      // 회원\nSELECT m.team FROM Member m // 팀\n```\n- 쉽게 생각하면, 원하는 객체를 바로 조회한 것이다.\n- 컬럼을 하나하나 나열해서 조회해야하는 SQL과는 차이가 있다.\n- **조회한 엔티티는 영속성 컨텍스트에서 관리**된다.\n\n**임베디드 타입 프로젝션**<br/>\n- JPQL에서 임베디드 타입은 엔티티와 거의 비슷하게 사용된다. 임베디드 타입은 조회의 시작점이 될 수 없다는 제약이 있다.\n\n> **임베디드 타입은 엔티티 타입이 아닌 값 타입이기 때문에 직접 조회한 임베디드 타입은 영속성 컨텍스트에서 관리되지 않는다.**\n\n**스칼라 타입 프로젝션**<br/>\n숫자, 문자, 날짜와 같은 기본 데이터 타입들을 스칼라 타입이라 한다. \n- 통계 쿼리도 주로 스칼라 타입으로 조회한다.\n\n**여러 값 조회**<br/>\n엔티티를 대상으로 조회하면 편리하겠지만, 꼭 필요한 데이터들만 선택해서 조회해야 할 때도 있다. \n- 이때는 프로젝션에 `Query` 를 사용한다.\n- 역시나 조회한 엔티티는 영속성 컨텍스트에서 관리된다.\n\n**NEW 명령어**<br/>\n- 실제 애플리케이션 개발시에는 `Object[]` 를 직접 사용하지 않고 의미있는 객체로 변환해서 사용한다.\n- SELECT 다음에 `NEW` 명령어를 사용해 반환받을 클래스를 지정할 수 있다. 클래스의 생성자에 JPQL 조회 결과를 넘겨줄 수 있다.\n\n`NEW` 명령어 사용 시 다음과 같은 주의사항이 있다.\n- 패키지 명을 포함한 전체 클래스명을 입력해야 한다.\n- 순서와 타입이 일치하는 생성자가 필요하다.\n\n### ➰ 페이징 API\n페이징 처리용 SQL을 작성하는 일은 지루하고 반복적이다. 더 큰 문제는 데이터베이스마다 페이징을 처리하는 SQL 문법이 다르다는 것이다.\n\nJPA는 페이징을 다음 두 API로 추상화했다.\n- `setFirstResult(int startPosition)` : 조회 시작 위치(0부터 시작한다)\n- `setMaxResults(int maxResult)` : 조회할 데이터 수\n\n```java\nTypedQuery<Member> query =\n    em.createQuery(\"SELECT m FROM Member m ORDER BY m.username DESC\", Member.class);\n\nquery.setFirstResult(10);\nquery.setMaxResults(20);\nquery.getResultList();\n```\n- `setFirstResult(10)` 으로, 11번째부터 시작해서 총 20건(`setMaxResults(20)`)의 데이터를 조회한다.\n\n데이터베이스마다 다른 페이징 처리를 같은 API로 처리할 수 있는 것은 이전에 다룬 **데이터베이스 방언** 덕분이다.\n\n### ➰ 집합과 정렬\n집합은 집합 함수와 함께 통계 정보를 구할 때 사용한다.\n\n**집합 함수**<br/>\n|함수|설명|\n|:---:|:---:|\n|COUNT|결과 수를 구한다. 반환 타입: `Long`|\n|MAX, MIN|최대, 최소 값을 구한다. 문자, 숫자, 날짜 등에 사용한다.|\n|AVG|평균값을 구한다. 숫자타입만 사용할 수 있다. 반환 타입: `Double`|\n|SUM|합을 구한다. 숫자타입만 사용할 수 있다. 반환 타입: 정수합 `Long`, 소수합: `Double`, `BigInteger` 합: `BigInteger`, `BigDecimal` 합: `BigDecimal`|\n\n**참고사항**\n- `NULL` 값은 무시하므로 통계에 잡히지 않는다.\n- 만약 값이 없는데 집합 함수를 사용하면 `NULL` 값이 된다. 단 `COUNT` 는 0이 된다.\n- `DISTINCT` 를 집합 함수 안에 사용해서 중복된 값을 제거하고 나서 집합을 구할 수 있다.\n- `DISTINCT` 를 `COUNT` 에서 사용할 때 임베디드 타입은 지원하지 않는다.\n\n**GROUP BY, HAVING**\n- `GROUP BY` 는 통계 데이터를 구할 때 특정 그룹끼리 묶어준다.\n- `HAVING` 은 그룹화한 통계 데이터를 기준으로 필터링한다.\n\n### ➰ JPQL 조인\nSQL 조인과 기능은 같고 문법만 약간 다르다.\n\n**내부 조인**<br/>\n`INNER JOIN` 을 사용한다. 여기서 `INNER` 는 생략 가능하다.\n\n```java\nSELECT m FROM Member m INNER JOIN m.team t WHERE t.name = :teamName\n```\n\nJPQL 내부 조인 구문을 보면, SQL의 조인과 약간 다르다. JPQL의 가장 큰 특징은 **연관 필드를 사용**한다는 것이다. 이는 다른 엔티티와 연관관계를 가지기 위해 사용하는 필드이다.\n- `FROM Member m` : 회원을 선택하고 `m` 이라는 별칭을 주었다.\n- `Member m JOIN m.team t` : 회원이 가지고 있는 연관 필드로 팀과 조인한다.\n\n**외부 조인**<br/>\n```java\nSELECT m FROM Member m LEFT [OUTER] JOIN m.team t\n```\n- 기능상 SQL의 외부 조인과 같다. `OUTER` 는 생략 가능해서 보통 `LEFT JOIN` 으로 많이 사용한다.\n\n**컬렉션 조인**<br/>\n일대다 관계나 다대다 관계처럼 컬렉션을 사용하는 곳에 조인하는 것이다.\n- [회원 -> 팀] 으로의 조인은 다대일 조인이면서 단일 값 연관 필드(`m.team`)를 사용한다.\n- [팀 -> 회원] 으로의 조인은 반대로 일대다 조인이면서 컬렉션 값 연관 필드(`m.members`)를 사용한다.\n\n**세타 조인**<br/>\n`WHERE` 절을 사용해서 세타 조인을 사용할 수 있다. 이는 **내부 조인만 지원**하는 조인이다.\n- 전혀 관계없는 엔티티도 조인할 수 있다.\n\n**JOIN ON 절**<br/>\n`ON` 절을 사용하면 조인 대상을 필터링하고 조인할 수 있다. \n- 내부 조인의 `ON` 절은 `WHERE` 절을 사용하는 것과 결과가 같아, 보통 `ON` 절은 외부 조인에서만 사용한다.\n\n### ➰ 페치 조인\nSQL에서 다루는 조인의 종류는 아니지만 JPQL에서 성능 최적화를 위해 제공하는 기능이다. \n- 연관된 엔티티나 컬렉션을 한 번에 같이 조회하는 기능으로, `join fetch` 명령어로 사용할 수 있다.\n\n```java\n페치 조인 ::= [ LEFT [OUTER] | INNER ] JOIN FETCH 조인경로\n```\n\n**엔티티 페치 조인**<br/>\n연관된 엔티티나 컬렉션을 함께 조회한다.\n- 별칭을 사용할 수 없다.\n\n> Hibernate는 별칭을 허용한다.\n\n```java\nString jpql = \"select m from Member m join fetch m.team\";\nList<Member> members = em.createQuery(jpql, Member.class).getResultList();\nfor (Member member : members) {\n  //페치 조인으로 회원과 팀을 함께 조회해서 지연 로딩 발생 안 함\n  Systern.out.printin(\"username = \" + member.getUsername () + \", \" +\n    \"teamname = \" + member.getTeam().name());\n}\n```\n- 회원과 팀을 지연 로딩으로 설정했다고 가정하면,\n  - 회원 조회 시 페치 조인을 사용해 팀도 함께 조회했으므로 연관된 팀 엔티티는 프록시가 아닌 실제 엔티티다.\n  - 즉, **지연 로딩이 발생하지 않는다.**\n\n**컬렉션 페치 조인**<br/>\n일대다 관계인 컬렉션을 페치 조인한다. \n- 팀(일)을 조회하면서 페치 조인을 사용해 연관된 회원 컬렉션(다)도 함께 조회한다.\n\n> 일대다 조인은 결과가 증가할 수 있지만 일대일, 다대일 조인의 결과는 증가하지 않는다.\n\n```java\nString jpql = \"select t from Team t join fetch t.members where t.name = '팀A'\";\nList<Member> teams = em.createQuery(jpql, Team.class).getResultList();\n\nfor (Team team : teams) {\n\n  System.out.println(\"teamname = \" + team.getName() + \", team = \" + team);\n\n  for (Member member : team.getMembers()) {\n    //페치 조인으로 팀과 회원을 함께 조회해서 지연 로딩 발생 안 함\n    Systern.out.printin(\"->username = \" + member.getUsername () + \", member = \" + member);\n  }\n}\n```\n\n**페치 조인과 DISTINCT**<br/>\n- SQL의 `DISTINCT` 는 중복된 결과를 제거하는 명령어이다.\n- JPQL의 `DISTINCT` 명령어는 SQL에 `DISTINCT` 를 추가하는 것은 물론이고 애플리케이션에서 한 번 더 중복을 제거한다.\n\n**페치 조인과 일반 조인의 차이**<br/>\n```java\n// 내부 조인 JPQL\nselect t\nfrom Team t join t.members m\nwhere t.name = '팀A'\n```\n\n```sql\n-- 실행된 SQL\nSELECT  T.*\nFROM TEAM TINNER JOIN MEMBER M \nON T.ID=M.TEAM_ID\nWHERE T.NAME = '팀A*'\n```\n\n**JPQL은 결과를 반환할 때 연관관계까지 고려하지 않는다.** 단지 SELECT 절에 지정한 엔티티만 조회할 뿐이다.\n- 따라서, 팀과 회원 컬렉션을 일반 조인하면 팀 엔티티만 조회하고 연관된 회원 컬렉션은 조회하지 않는다.\n- 반면 페치 조인을 사용하면 연관된 엔티티도 함께 조회한다.\n\n**페치 조인의 특징**<br/>\n페치 조인을 사용하면 SQL 한 번으로 연관된 엔티티들을 함께 조회할 수 있어서 SQL 호출 횟수를 줄여 성능을 최적화할 수 있다.\n\n다음처럼 엔티티에 직접 적용하는 로딩 전략은 애플리케이션 전체에 영향을 미치므로 **글로벌 로딩 전략**이라고 한다. \n- `@OneToMany(fetch = FetchType.LAZY)`\n- 페치 조인은 글로벌 로딩 전략보다 우선한다. 즉, 지연 로딩을 글로벌로 설정해도 JPQL에서 페치 조인을 사용하면 페치 조인을 적용한다.\n- **글로벌 로딩 전략은 지연 로딩을 사용하고 최적화가 필요하면 페치 조인을 적용**하는 것이 성능면에서 효과적이다.\n\n또한, 페치 조인을 사용하면 연관된 엔티티를 쿼리 시점에 조회하므로 지연 로딩이 발생하지 않는다.\n- 즉, **준영속 상태에서도 객체 그래프를 탐색**할 수 있다.\n\n**페치 조인의 한계**<br/>\n- 페치 조인 대상에는 별칭을 줄 수 없다.\n  - 별칭을 잘못 사용하면 연관된 데이터 수가 달라져서 데이터 무결성이 깨질 수 있으므로 조심해서 사용해야 한다.\n  - 특히 2차 캐시와 함께 사용할 때 조심해야 하는데, 연관된 데이터 수가 달라진 상태에서 2차 캐시에 저장되면 다른 곳에서 조회할 때도 연관된 데이터 수가 달라지는 문제가 발생할 수 있다.\n- 둘 이상의 컬렉션을 페치할 수 없다.\n  - 구현체에 따라 되기도 하는데 컬렉션 * 컬렉션 카테시안 곱이 만들어 지므로 주의해야 한다.\n- 컬렉션을 페치 조인하면 페이징 API(`setFirstResult`, `setMaxResults`)를 사용할 수 없다.\n  - 하이버네이트에서 컬렉션을 페치 조인하고 페이징 API를 사용하면 경고 로그를 남기면서 메모리에서 페이징 처리를 하는데, 데이터가 적으면 상관없겠지만 데이터가 많으면 성능 이슈와 메모리 초과 예외가 발생할 수 있어서 위험하다.\n\n> 페치 조인은 객체 그래프를 유지할 때 사용하면 효과적이다. 반면에 여러 테이블을 조인해서 엔티티가 가진 모양이 아닌 전혀 다른 결과를 내야 한다면 억지로 페치 조인을 사용하기 보다는 여러 테이블에서 필요한 필드들만 조회해서 **DTO**로 반환하는 것이 더 효과적일 수 있다.\n\n### ➰ 경로 표현식\n.(점)을 찍어 객체 그래프를 탐색하는 것이다.\n\n```sql\nselect m.username -- 경로 표현식\nfrom Member m\n    join m.team t -- 경로 표현식\n    join m.orders o -- 경로 표현식\nwhere t.name = '팀A' -- 경로 표현식\n```\n\n**용어 정리**\n- 상태 필드(state field) : 단순히 값을 저장하기 위한 필드(필드 또는 프로퍼티)\n- 연관 필드(association field) : 연관관계를 위한 필드, 임베디드 타입 포함(필드 또는 프로퍼티)\n  - 단일 값 연관 필드 : `@ManyToOne` , `@OneToOne` , 대상이 엔티티\n  - 컬렉션 값 연관 필드 : `@OneToMany` , `@ManyToMany` , 대상이 컬렉션\n\n```java\n@Entity\npublic class Member {\n\n    @Id @GeneratedValue\n    private Long id;\n\t\t\n    @Column(name=\"name\")\n    private String username; // 상태 필드\n    private Integer age; // 상태 필드\n\t\n    @ManyToOne(..)\n    private Team team; // 연관 필드(단일 값 연관 필드)\n\n    @OneToMany(..)\n    private List<Order> orders; // 연관 필드(컬렉션 값 연관 필드)\n    ...\n\n}\n```\n- 상태 필드 : `t.username`, `t.age`\n- 단일 값 연관 필드 : `m.team`\n- 컬렉션 값 연관 필드 : `m.orders`\n\n**경로 표현식과 특징**<br/>\n경로 표현식을 사용해 경로 탐색을 위해서는 다음 3가지 경로에 따라 어떤 특징이 있는지 알아야 한다.\n- 상태 필드 경로 : 경로 탐색의 끝이다. 더는 탐색 불가능하다.\n- 단일 값 연관 경로 : **묵시적으로 내부 조인**이 일어난다. 단일 값 연관 경로는 계속 탐색할 수 있다.\n- 컬렉션 값 연관 경로 : **묵시적으로 내부 조인**이 일어난다. 더는 탐색할 수 없다. 단 FROM 절에서 조인을 통해 별칭을 얻으면 별칭으로 탐색할 수 있다.\n\n> 명시적 조인은 `JOIN` 을 직접 명시하는 것이고, 묵시적 조인은 경로 표현식에 의해 묵시적으로 조인이 일어나는 것으로, 내부 조인(`INNER JOIN`)만 할 수 있다.\n\n**컬렉션 값 연관 경로 탐색**<br/>\nJPQL을 다루면서 많이 하는 실수 중 하나는 컬렉션 값에서 경로 탐색을 시도하는 것이다.\n\n```sql\nselect t.members from Team t -- 성공\nselect t.members.username from Team t -- 실패\n```\n- 컬렉션까지는 경로 탐색이 가능하다. \n- 하지만 컬렉션에서 경로 탐색을 시작하는 두 번째 예는 허락되지 않는다. 이를 위해서는 조인을 사용해 새로운 별칭을 획득해야 한다.\n\n**경로 탐색을 사용한 묵시적 조인 시 주의사항**<br/>\n경로 탐색을 사용하면 묵시적 조인이 발생해 SQL에서 내부 조인이 일어날 수 있다. 이때 주의사항은 다음과 같다.\n- **항상 내부 조인**이다.\n- **컬렉션은 경로 탐색의 끝**이다. 컬렉션에서 경로 탐색을 하려면 명시적으로 조인해서 별칭을 얻어야 한다.\n- 경로 탐색은 주로 SELECT, WHERE 절(다른 곳에서도 사용됨)에서 사용하지만 묵시적 조인으로 인해 SQL의 FROM 절에 영향을 준다.\n\n> 성능이 주용하면 분석하기 쉽도록 묵시적 조인보다는 **명시적 조인을 사용**하자.\n\n### ➰ 서브 쿼리\nJPQL도 SQL처럼 서브 쿼리를 지원한다. 다음과 같은 제약사항이 존재한다.\n- 서브 쿼리를 WHERE, HAVING 절에서만 사용할 수 있고,\n- SELECT, FROM 절에서는 사용할 수 없다.\n\n> Hibernate의 HQL은 SELECT 절의 서브 쿼리도 허용한다.\n\n```sql\nselect m from Member m where m.age > (select avg(m2.age) from Member m2)\n```\n- 평균보다 나이가 많은 회원을 찾는다.\n\n**서브 쿼리 함수**<br/>\n- [NOT] EXISTS (subquery)\n- { ALL | ANY | SOME } (subquery)\n- [NOT] IN (subquery)\n\n**EXISTS**\n- 서브 쿼리에 결과가 존재하면 참이다. NOT은 반대\n\n**{ ALL | ANY | SOME }**\n- 비교 연산자와 같이 사용한다.\n- ALL: 조건을 모두 만족하면 참이다.\n- ANY 혹은 SOME: 둘은 같은 의미이다. 조건을 하나라도 만족하면 참이다.\n\n**IN**\n- 서브 쿼리의 결과 중 하나라도 같은 것이 있으면 참이다. 서브 쿼리가 아닌 곳에서도 사용한다.\n\n### ➰ 조건식\n**타입 표현**\nJPQL에서 사용하는 타입은 아래와 같이 표시하고, 대소문자는 구분하지 않는다.\n\n|종류|설명|예제|\n|:---:|:---:|:---:|\n|문자|작은 따옴표 사이에 표현|'HELLO', 'She''s'|\n|숫자|L(Long), D(Double), F(Float)|10L, 10D, 10F|\n|날짜|Date{d 'yyyy-dd-dd'}<br/>TIME{t 'hh-mm-ss'}<br/>DATETIME{ts 'yyyy-dd-dd hh:mm:ss.f'}|{d '2012-03-24'}|\n|Boolean|TRUE, FALSE||\n|Enum|패키지명을 포함한 전체 이름을 사용해야 한다.|jpabook.MemberType.Admin|\n|엔티티 타입|엔티티의 타입을 표현한다. 주로 상속과 관련해서 사용한다.|TYPE(m) = Member|\n\n**연산자 우선 순위**\n1. 경로 탐색 연산(.)\n2. 수학 연산\n3. 비교 연산\n4. 논리 연산\n\n**컬렉션 식**<br/>\n컬렉션에만 사용하는 특별한 기능이다. 컬렉션은 컬렉션 식 이외에 다른 식은 사용할 수 없다.\n- 빈 컬렉션 비교 식\n  - { 컬렉션 값 연관 경로 } IS [NOT] EMPTY\n  - 컬렉션에 값이 비었으면 참\n- 컬렉션의 멤버 식\n  - { 엔티티나 값 } [NOT] MEMBER [OF] { 컬렉션 값 연관 경로 }\n  - 엔티티나 값이 컬렉션에 포함되어 있으면 참\n\n**스칼라 식**<br/>\n숫자, 문자, 날짜, case, 엔티티 타입 같은 가장 기본적인 타입들을 스칼라라고 한다.\n- 수학 식\n  - 단항 연산자, 사칙연산\n- 문자함수\n  - CONCAT, SUBSTRING, TRIM, LOWER, UPPER, LENGTH, LOCATE\n- 수학 함수\n  - ABS, SQRT, MOD, SIZE, INDEX\n- 날짜 함수\n  - 데이터베이스의 현재 시간을 조회한다.\n  - CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP\n\n**CASE 식**<br/>\n특정 조건에 따라 분기할 때 CASE 식을 사용한다.\n- 기본 CASE\n  - ```sql\n    CASE {WHEN <조건식> THEN <스칼라식>} + \n      ELSE <스칼라식>\n    END\n    ```\n- 심플 CASE\n  - 조건식을 사용할 수 없지만, 문법이 단순하다.\n  - ```sql\n    CASE <조건대상> + {WHEN <스칼라식1> THEN <스칼라식2>} +\n      ELSE <스칼라식>\n    END\n    ```\n- COALESCE\n  - 스칼라식을 차례대로 조회해서 `null` 이 아니면 반환한다.\n  - `COALESCE(<스칼라식> {,<스칼라식>}+)`\n- NULLIF\n  - 두 값이 같으면 `null` 을 반환하고 다르면 첫 번째 값을 반환한다.\n  - 집합 함수는 `null` 을 포함하지 않아 보통 집합 함수와 함께 사용한다.\n  - `NULLIF(<스칼라식>, <스칼라식>)`\n\n### ➰ 다형성 쿼리\nJPQL로 부모 엔티티를 조회하면 그 자식 엔티티도 함께 조회한다.\n- `Item` 의 자식 엔티티로 `Book` , `Album` , `Movie` 가 있다고 가정한다.\n- `Item` 을 조회하면 그 자식도 함께 조회한다.\n\n**TYPE**<br/>\n엔티티의 상속 구조에서 조회 대상을 특정 자식 타입으로 한정할 때 사용한다.\n\n```java\n// Item 중 Book, Movie를 조회하라.\n\n// JPQL\nselect i from Item i\nwhere type(i) IN (Book, Movie)\n\n// SQL\nSELECT i FROM Item i\nWHERE i.DTYPE in ('B', 'M')\n```\n\n**TREAT**<br/>\nJPA 2.1에 추가된 기능으로, 자바의 타입 캐스팅과 비슷하다. 상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용한다.\n```java\n// JPQL \nselect i from Item i where treat(i as Book).author = 'kim'\n```\n- 부모 타입인 `Item` 을 자식 타입인 `Book` 으로 다뤄 `author` 필드에 접근할 수 있다.\n\n### ➰ 사용자 정의 함수 호출(JPA 2.1)\n`function_invocation::= FUNCTION(function_name {, function_arg})`\n- Hibernate 구현체를 사용하면 **방언 클래스를 상속**해서 구현하고 사용할 데이터베이스 함수를 미리 등록해야 한다.\n- 그리고 `hibernate.dialect` 에 해당 방언을 등록해야 한다.\n\n### ➰ 기타 정리\n- `enum` 은 = 비교 연산만 지원한다.\n- 임베디드 타입은 비교를 지원하지 않는다.\n\n**EMPTY STRING**<br/>\nJPA 표준은 ''을 길이 0인 Empty String으로 정했지만, 데이터베이스에 따라 `NULL` 로 사용하는 데이터베이스도 있어 확인이 필요하다.\n\n**NULL 정의**\n- 조건을 만족하는 데이터가 하나도 없는 경우\n- `NULL` 은 알 수 없는 값이다. `NULL` 과의 모든 수학적 계산 결과는 `NULL` 이다.\n- `Null == Null` 은 알 수 없는 값이다.\n- `Null is Null` 은 참이다.\n\n### ➰ 엔티티 직접 사용\n**기본 키 값**<br/>\n객체 인스턴스는 참조 값으로 식별하고, 테이블 로우는 기본 키 값으로 식별한다.\n- 따라서 **JPQL에서 엔티티 객체를 직접 사용**하면 **SQL에서는 해당 엔티티의 기본 키 값을 사용**한다.\n\n**외래 키 값**<br/>\n특정 팀에 소속된 회원을 찾는 예제로 확인한다.\n```java\nTeam team = em.find(Team.class, 1L);\n\nString qlString = \"select m from Member m where m.team = :team\";\nList resultList = em.createQuery(qlString)\n    .setParameter(\"team\", team);\n    .getResultList();\n```\n- 기본 키 값이 1L인 팀 엔티티를 파라미터로 사용하고 있다.\n- `m.team` 은 현재 `team_id` 라는 외래 키와 매핑되어 있다.\n\n```sql\nselect m.* from Member m where m.team_id = ?\n```\n\n엔티티 대신 식별자 값을 직접 사용할 수 있다.\n```java\nString qlString = \"select m from Member m where m.team.id = :teamId\";\nList resultList = em.createQuery(qlString)\n    .setParameter(\"teamId\", 1L);\n    .getResultList();\n```\n- `m.team.id` 를 보면 `Member` 와 `Team` 간 묵시적 조인이 발생할 것 같지만, `MEMBER` 테이블이 외래 키를 가지고 있어 발생하지 않는다.\n\n> `m.team` 을 사용하든, `m.team.id` 를 사용하든 생성되는 SQL은 같다.\n\n### ➰ Named 쿼리: 정적 쿼리\nJPQL은 크게 동적 쿼리와 정적 쿼리로 나눌 수 있다.\n- **동적 쿼리**\n  - JPQL을 문자로 완성해서 직접 넘기는 것\n  - 런타임에 특정 조건에 따라 동적으로 구성할 수 있다.\n- **정적 쿼리**\n  - 미리 정의한 쿼리에 이름을 부여해 필요할 때 사용하는 것, Named 쿼리라 한다.\n  - 한 번 정의하면 변경할 수 없다.\n\nNamed 쿼리는 애플리케이션 로딩 시점에 JPQL 문법 체크 후 미리 파싱해둔다.\n- 오류를 빨리 확인할 수 있고, 사용하는 시점에는 파싱된 결과를 재사용하여 성능상 이점도 있다.\n- 정적 SQL을 생성하므로, 데이터베이스의 조회 성능 최적화에도 도움이 된다.\n\n**Named 쿼리를 어노테이션에 정의**<br/>\n`@NamedQuery` annotation을 사용한다.\n```java\n@Entity\n@NamedQuery (\n  name = \"Member.findByUsername\",\n  query = \"select m from Member m where m.username = :username\")\npublic class Member {\n  ...\n\n}\n```\n- `name` 에 이름을 부여하고, `query` 에 사용할 쿼리를 입력한다.\n- 사용 시에는 `em.createNamedQuery()` 메소드에 Named 쿼리 이름을 입력하여 사용한다.\n- 여러 개의 쿼리를 사용하기 위해서는 `@NamedQueries` annotation을 사용할 수 있다.\n\n> 엔티티 이름을 쿼리 이름 앞에 붙여 영속성 유닛 단위로 관리되는 Named 쿼리의 충돌을 방지한다.\n\n`@NamedQuery` annotation\n- `lockMode` : 쿼리 실행 시 락을 건다. (default: NONE)\n- `hints` : SQL 힌트가 아니라 JPA 구현체에게 제공하는 힌트다. \n\n**Named 쿼리를 XML에 정의**<br/>\nJPA에서 annotation으로 작성할 수 있는 것은 XML로도 작성할 수 있다. \n- 자바에서 멀티라인 문자를 다루는 것은 상당히 귀찮은데, XML을 사용하는 것이 현실적인 대안이 될 수 있다.\n\n```xml\n<!-- META-INF/ormMember.xml -->\n<named-query name=\"Member.findByUsername\">\n  <query><CDATA[\n    select m\n    from Member m\n    where m.username = :username\n  ]></query>\n</named-query>\n\n<named-query name=\"Member.count\">\n  <query>select count(m) from Member m</query>\n</named-query>\n```\n\n작성한 xml을 인식하도록 코드를 추가한다.\n\n```xml\n<!-- META-INF/persistence.xml -->\n<persistence-unit name=\"jpabook\">\n  <mapping-file>META-INF/ormMember.xml</mapping-file>\n  ...\n\n```\n\n> `META-INF/orm.xml` 은 기본 매핑 파일로 인식한다.\n\n**환경에 따른 설정**<br/>\nXML과 annotation에 같은 설정이 있다면 **XML이 우선권**을 가진다.\n\n---\n\n## 💫 Criteria\nJPQL을 자바 코드로 작성하도록 도와주는 빌더 클래스 API이다.\n- 문자가 아닌 코드로 JPQL을 작성해 문법 오류를 컴파일 단계에서 확인할 수 있다.\n- 문자 기반의 JPQL보다 동적 쿼리를 안전하게 생성할 수 있다.\n- 코드가 복잡하고 장황해서 직관적인 이해가 어렵다는 단점이 있다.\n\n### ➰ Criteria 기초\nCriteria API는 `javax.persistence.criteria` 패키지에 있다.\n\n```java\nCriteriaBuilder cb = em.getCriteriaBuilder();\n\nCriteriaQuery<Member> cq = cb.createQuery(Member.class); // 반환타입 지정\n\nRoot<Member> m = cq.from(Member.class); // FROM 절\ncq.select(m);\n\nTypedQuery<Member> query = em.createQuery(cq);\nList<Member> members = query.getResultList();\n```\n- Criteria 쿼리 생성을 위해서는 Criteria 빌더를 얻어야 한다. EntityManager나 EntityManagerFactory에서 얻을 수 있다.\n- Criteria 쿼리 빌더에서 Criteria 쿼리를 생성한다. 이때 반환 타입을 지정할 수 있다.\n- FROM 절을 생성한다. 반환된 값은 별칭이고, 이를 조회의 시작점으로 잡는다.\n\n검색 조건과 정렬 조건을 추가한다.\n```java\nCriteriaBuilder cb = em.getCriteriaBuilder();\n\nCriteriaQuery<Member> cq = cb.createQuery(Member.class); \n\nRoot<Member> m = cq.from(Member.class); \n\nPredicate usernameEqual = cb.equal(m.get(\"username\"), \"회원1\");\n\njavax.persistence.criteria.Order ageDesc = cb.desc(m.get(\"age\"));\n\ncq.select(m)\n    .where(usernameEqual)\n    .orderBy(ageDesc);\n\nList<Member> resultList = em.createQuery(cq).getResultList();\n```\n\n**쿼리 루트와 별칭**\n- 쿼리 루트는 조회의 시작점이다.\n- 별칭은 엔티티에만 부여할 수 있다.\n\n`m.get(\"age\")` 메소드는 `age` 의 타입 정보를 모르기 때문에 `m.<Integer>get(\"age\")` 와 같이 제네릭으로 반환 타입 정보를 명시해야 한다.(`String` 같은 문자 타입은 지정하지 않아도 된다.)\n\n### ➰ Criteria 쿼리 생성\n`CriteriaBuilder.createQuery()` 메소드로 Criteria 쿼리를 생성해 사용한다.\n- `CriteriaBuilder` interface를 보면, 쿼리 생성 시 파라미터로 쿼리 결과에 대한 반홭 타입을 지정할 수 있다.\n  - 반환 타입을 지정했다면, `em.createQuery()` 에서 반환 타입을 지정하지 않아도 된다.\n- 반환 타입을 지정할 수 없거나, 반환 타입이 둘 이상이면 타입 명시 없이 `Object` 로 반환받는다.\n  - 물론 반환 타입이 둘 이상미녀 `Object[]` 를 사용하는 것이 편리하다.\n\n### ➰ 조회\n`CriteriaQuery` interface 의 `select` , `multiselect` 메소드\n\n**조회 대상을 한 건, 여러 건 지정**\n- `select` 에 조회 대상을 하나만 지정하려면 `cq.select(m)` 과 같이 작성한다.\n- 조회 대상을 여러 건 지정하려면 `cq.multiselect(m.get(\"username\"), m.get(\"age\"));` 과 같이 작성한다.\n  - 여러 건 지정은 `cb.array` 사용도 가능하다.\n\n**DISTINCT**<br/>\n`select` , `multiselect` 다음에 `distinct(true)` 로 사용한다.\n\n**NEW, construct()**<br/>\nJPQL에서 `select new 생성자()` 구문을 Criteria에서는 `cb.construct(클래스 타입, ...)` 로 사용한다.\n\n**튜플**<br/>\nCriteria는 `Map` 과 비슷한 **튜플**이라는 특별한 반환 객체를 제공한다.\n\n```java\nCriteriaQuery<Tuple> cq = cb.createTupleQuery();\n\ncq.multiselect (\n  m.get(\"username\").alias(\"username\"), // 튜플에서 사용할 별칭 지정\n  m.get(\"age\").alias(\"age\")\n);\n\nTypedQuery<Tuple> query = em.createQuery(cq);\nList<Tuple> resultList = query.getResultList();\nfor (Tuple tuple : resultList) {\n  // 튜플 별칭으로 조회\n  String username = tuple.get(\"username\", String.class);\n  Integer age = tuple.age(\"age\", Integer.class);\n}\n```\n- 튜플을 사용하려면 `cb.createTupleQuery` 또는 `cb.createQuery(Tuple.class)` 로 Criteria를 생성한다.\n- 튜플은 튜플의 검색 키로 사용할 **튜플 전용 별칭을 필수로 할당**해야 한다.\n- 선언해둔 튜플 별칭으로 데이터를 조회한다.\n- 튜플은 이름 기반으로, 순서 기반의 `Object[]` 보다 안전하다. \n- `tuple.getElements()` 같은 메소드로 현재 튜플의 별칭과 자바 타입도 조회할 수 있다. \n\n### ➰ 집합\n**GROUP BY**\n```java\ncq.groupBy(m.get(\"team\").get(\"name\"))\n```\n- JPQL의 `group by m.team.name` 과 같다.\n\n**HAVING**\n```java\ncq.multiselect(m.get(\"team\").get(\"name\"), maxAge, minAge)\n    .groupBy(m.get(\"team\").get(\"name\"))\n    .having(cb.gt(minAge, 10));\n```\n- JPQL의 `having min(m.age) > 10` 과 같다.\n\n### ➰ 정렬\n`cb.desc()...` 또는 `cb.asc(...)` 로 생성할 수 있다.\n\n### ➰ 조인\n`join()` 메소드와 `JoinType` 클래스를 사용한다.\n\n```java\npublic enum JoinType {\n\n  INNER, (default)\n  LEFT,\n  RIGHT\n\n}\n```\n```java\nRoot<Member> m = cq.from(Member.class);\nJoin<Member, Team> t = m.join(\"team\", JoinType.INNER); // 내부 조인 설정\n\ncq.multiselect(m, t);\n  .where(cb.equal(t.get(\"name\"), \"팀A\"));\n```\n\nFETCH JOIN은 다음과 같이 설정한다.\n```java\nRoot<Member> m = cq.from(Member.class);\nm.fetch(\"team\", JoinType.LEFT);\n\ncq.select(m);\n```\n\n### ➰ 서브 쿼리\n**간단한 서브 쿼리**<br/>\n메인 쿼리와 서브 쿼리 간 관련이 없는 서브 쿼리를 말한다.\n\n```java\nCriteriaQuery<Member> mainQuery = cb.createQuery(Member.class);\n\nSubquery<Double> subQuery = mainQuery.subquery(Double.class);\nRoot<Member> m2 = subQuery.from(Member.class);\nsubQuery.select(cb.avg(m2.<Integer>get(\"age\")));\n\nRoot<Member> m = mainQuery.from(Member.class);\nmainQuery.select(m)\n  .where(cb.ge(m.<Integer>get(\"age\"), subQuery));\n```\n1. 서브 쿼리는 `mainQuery.subquery()` 로 생성한다.\n2. 메인 쿼리는 `where(..., subQuery)` 에서 생성한 서브 쿼리를 사용한다.\n\n**상호 관련 서브 쿼리**<br/>\n메인 쿼리와 서브 쿼리 간 관련이 있는 경우이다.\n- 서브 쿼리에서 메인 쿼리의 정보를 사용하려면 메인 쿼리에서 사용한 별칭을 얻어야 한다.\n  - 메인 쿼리의 `Root` 나 `Join` 을 통해 생성된 별칭을 받아 사용한다. 이때 `Root<Member> subM = subQuery.correlate(m);` 을 사용해 메인 쿼리의 별칭을 가져올 수 있다.\n\n### ➰ IN 식\nCriteria 빌더에서 `in(...)` 메소드를 사용한다.\n\n### ➰ CASE 식\n`selectCase()` 메소드와 `when()` , `otherwise()` 메소드를 사용한다.\n\n### ➰ 파라미터 정의\nJPQL에서 `:PARAM1` 처럼 파라미터를 정의했듯 정의할 수 있다.\n\n```java\ncq.select(m)\n    .where(cb.equal(m.get(\"username\"), cb.parameter(String.class, \"usernameParam\"))); // 파라미터 정의\n\nList<Member> resultList = em.createQuery(cq)\n    .setParameter(\"usernameParam\", \"회원1\") // 바인딩\n    .getResultList();\n```\n\n### ➰ 네이티브 함수 호출\n네이티브 SQL 함수 호출을 위해서는 `cb.function(...)` 메소드를 사용하면 된다.\n\n### ➰ 동적 쿼리\n다양한 검색 조건에 따라 실행 시점에 쿼리를 생성하는 것을 동적 쿼리라 한다.\n- 코드 기반인 Criteria로 작성하는 것이 편리하다.\n- 공백이나 `where` , `and` 의 위치로 인한 에러가 발생하지는 않는다.\n- 하지만 장황하고 복잡하다는 단점이 크다.\n\n### ➰ 함수 정리\nCriteria는 JPQL 빌더 역할을 해 JPQL 함수를 코드로 지원한다.\n- Expression의 메소드(`isNull()` , `isNotNull()` , `in()`)\n- 조건 함수\n- 스칼라와 기타 함수\n- 집합 함수\n- 분기 함수\n\n### ➰ Criteria 메타 모델 API\n코드 기반의 Criteria는 컴파일 시점에 오류를 발견할 수 있다.\n- 하지만 `m.get(\"age\")` 에서 `age` 는 문자다. 이를 `aggeadf` 라고 적어도 컴파일 시점에 에러를 발견하지 못한다.\n  - 따라서 완전한 코드 기반이라 할 수 없다.\n- 이런 부분까지 코드로 작성하기 위해서는 메타 모델 API를 사용하면 된다. 먼저 메타 모델 클래스를 생성한다.\n\n**메타 모델 API 적용 전**\n```java\ncq.select(m)\n    .where(cb.gt(m.<Integer>get(\"username\"), 20))\n    .orderBy(cb.desc(m.get(\"age\")));\n```\n**메타 모델 API 적용 후**\n```java\ncq.select(m)\n    .where(cb.gt(m.get(Member_.age),20))\n    .orderBy(cb.desc(m.get(Member_.age)));\n```\n- 문자 기반에서 정적인 코드 기반으로 변경되었다. \n  - 이를 위해서는 `Member_` 클래스가 필요한데, 이를 **메타 모델 클래스**라 한다.\n- 메타 모델 클래스는 해당 엔티티를 기반이고, 코드 자동 생성기가 `엔티티명_.java` 모양의 메타 모델 클래스를 생성해준다.\n  - Hibernate 구현체는 `org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor` 를 사용한다.\n\n**코드 생성기 설정**<br/>\n보통 메이븐이나 엔트, 그래들 같은 빌드 도구를 사용해 코드 생성기를 실행한다.\n- 메이븐을 기준으로, `hibernate-jpamodelgen` 과 `maven-compiler-plugin` 설정을 추가한다.\n- `mvn compile` 명령어를 사용해 메타 모델 클래스를 생성한다.\n\n--- \n\n## 💫 QueryDSL\nJPQ Criteria는 문자가 아닌 코드로 JPQL를 작성하여 문법 오류를 컴파일 단계에서 잡을 수 있고, IDE 자동완성 기능의 도움을 받을 수 있는 등 여러 장점이 있지만, 복잡하고 장황하다는 큰 단점이 존재한다. \n\n쿼리를 문자가 아닌 코드로 작성해도, 쉽고 간결하며 그 모양도 쿼리와 비슷하게 개발할 수 있는 프로젝트가 바로 QueryDSL이다.\n- JPQL 빌더 역할을 하는데, JPA Criteria를 대체할 수 있다.\n- 쿼리 즉 데이터를 조회하는데 기능이 특화되어 있다.\n\n### ➰ QueryDSL 설정\ngradle 기준!\n\n**📌 필요 라이브러리**<br/>\n```xml\nimplementation 'org.springframework.boot:spring-boot-starter-data-jpa'\nimplementation 'com.querydsl:querydsl-jpa'\nimplementation 'com.querydsl:querydsl-apt'\n```\n- `querydsl-jpa` : QueryDSL JPA 라이브러리\n- `querydsl-apt` : 쿼리 타입(Q)을 생성할 때 필요한 라이브러리\n\n**📌 환경설정**<br/>\nQueryDSL을 사용하기 위해서는 Criteria의 메타 모델처럼 엔티티를 기반으로 쿼리 타입이라는 쿼리용 클래스를 생성해야 한다. (Q클래스라고도 한다.)\n- `build.gradle` 에 쿼리 타입을 생성할 위치를 지정하고, `Gradle` -> `build` 하면 쿼리 타입이 해당 경로에 생성된다.\n\n```java\n// queryDSL이 생성하는 QClass 경로 설정\ndef querydslDir = \"$buildDir/generated/querydsl\"\n\nquerydsl {\n\tlibrary = \"com.querydsl:querydsl-apt\"\n\tjpa = true\n\tquerydslSourcesDir = querydslDir\n}\n\nsourceSets {\n\tmain.java.srcDir querydslDir\n}\n\nconfigurations {\n\tquerydsl.extendsFrom compileClasspath\n}\n\ncompileQuerydsl {\n\toptions.annotationProcessorPath = configurations.querydsl\n}\n```\n\n```java\nimport com.querydsl.jpa.impl.JPAQueryFactory;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\nimport javax.persistence.EntityManager;\nimport javax.persistence.PersistenceContext;\n\n@Configuration\npublic class QuerydslConfig {\n\n    @PersistenceContext\n    private EntityManager em;\n\n    @Bean\n    public JPAQueryFactory jpaQueryFactory() {\n        return new JPAQueryFactory(em);\n    }\n}\n```\n- 그리고 엔티티 매니저를 주입한 JPAQueryFactory를 Bean으로 등록하여 프로젝트 전역에서 QueryDSL을 작성할 수 있게 한다.\n\n### ➰ 시작\n```java\npublic void queryDSL() {\n\n  ...\n  \n  EntityManager em = emf.createEntityManager();\n\n  JPAQuery query = new JPAQuery(em);\n  QMember qMember = new QMember(\"m\");\n  List<Member> members = \n      query.from(qMember)\n           .where(qMember.name.eq(\"회원1\"))\n           .orderBy(qMember.name.desc())\n           .list(qMember);\n}\n```\n- QueryDSL을 사용하기 위해서는 `JPAQuery` 객체를 생성해야 하는데, 이때 엔티티 매니저를 생성자에 넘겨준다.\n- 그리고 사용할 쿼리 타입을 생성하는데, 생성자에는 별칭을 넘겨준다.\n  - 이 별칭을 JPQL에서 별칭으로 사용한다.\n\n**📌 기본 Q 생성**<br/>\n쿼리 타입은 사용하기 편리하도록 기본 인스턴스를 보관하고 있다.\n- 하지만 같은 엔티티를 조인하거나 같은 엔티티를 서브 쿼리에 사용하면 같은 별칭이 사용되므로, 이때는 별칭을 직접 지정해서 사용해야 한다.\n\n```java\npublic class QMember extends EntityPathBase<Member> {\n\n  public static final QMember member = new QMember(\"member1\");\n  ...\n\n}\n```\n\n```java\nQMember qMember = new QMember(\"m\"); // 직접 지정\nQMember qMember = QMember.member;   // 기본 인스턴스 사용\n```\n- 쿼리 타입은 위와 같이 사용할 수 있다.\n- 기본 인스턴스를 사용하면 `import static` 을 사용해 더 간결한 코드를 작성할 수 있다.\n\n### ➰ 검색 조건 쿼리\n```java\nJPAQuery query = new JPAQuery(em);\nQItem item = QItem.item;\nList<Item> list = query.from(item)\n    .where(item.name.eq(\"좋은 상품\").and(item.price.gt(20000)))\n    .list(item);\n```\n- QueryDSL의 `where` 절에는 `and` 나 `or` 을 사용할 수 있다. 또한 여러 검색 조건을 사용할 수 있다.\n\n### ➰ 결과 조회\n쿼리 작성이 끝나고 결과 조회 메소드를 호출하면 실제 데이터베이스를 조회한다. \n- 보통 `uniqueResult()` 나 `list()` 를 사용하고 파라미터로 프로젝션 대상을 넘겨준다.\n- 결과 조회 API는 `com.mysema.query.Projectable` 에 정의되어 있다.\n\n**`uniqueResult()`**\n- 조회 결과가 한 건일 때 사용한다. \n- 조회 결과가 없으면 `null` 을 반환하고 결과가 하나 이상이면 `NonUniqueResultException` 예외가 발생한다.\n\n**`singleResult()`**\n- `uniqueResult()` 와 같지만 결과가 하나 이상이면 처음 데이터를 반환한다.\n\n**`list()`** \n- 결과가 하나 이상일 때 사용한다.\n- 결과가 없으면 빈 컬렉션을 반환한다.\n\n### ➰ 페이징과 정렬\n```java\nQItem item = QItem.item;\n\nquery.from(item)\n    .where(item.price.gt(20000))\n    .orderBy(item.price.desc(), item.stockQuantity.asc())\n    .offset(10).limit(20)\n    .list(item);\n```\n- 정렬은 `orderBy()` ,`asc()` , `desc()` 을 사용한다.\n- 페이징은 `offset` , `limit` 를 사용한다.\n  - `restrict()` 메소드에 `new QueryModifiers(20L, 10L)` 를 파라미터로 사용해도 된다. \n  - 파라미터의 `20L` 과 `10L` 은 각각 **limit**, **offset**을 의미한다.\n\n실제 페이징 처리를 위해서는 **검색된 전체 데이터 수**를 알아야 한다.\n- 이땐 `list()` 대신 `listResult()` 를 사용한다.\n  - 전체 데이터 조회를 위한 `count` 쿼리를 한 번 더 실행한다.\n  - 그리고 `SearchResults` 를 반환하는데, 이 객체에서 전체 데이터 수(`getTotal()`)를 조회할 수 있다.\n\n### ➰ 그룹\n`groupBy` 를 사용하고 그룹화된 결과를 제한하려면 `having` 을 사용한다.\n\n### ➰ 조인\n`innerJoin(join)` , `leftJoin` , `rightJoin` , `fullJoin` 을 사용할 수 있고, 추가로 JPQL의 `on` 과 성능 최적화를 위한 `fetch` 조인도 사용할 수 있다.\n- 기본 문법은 첫 번째 파라미터에 조인 대상을 지정하고, 두 번째 파라미터에 별칭으로 사용할 쿼리 타입을 지정한다.\n\n```java\n// 가장 기본적인 조인 방법\n\nQOrder order = QOrder.order;\nQMember member = QMember.member;\nQOrderItem orderItem = QOrderItem.orderItem;\n\nquery.from(order)\n    .join(order.member, member)\n    .leftJoin(order.orderItems, orderItem)\n    .list(order);\n```\n\n```java\n// 조인에 on을 사용한 예\n\n...\n\nquery.from(order)\n    .leftJoin(order.orderItems, orderItem)\n    .on(orderItem.count.gt(2))\n    .list(order);\n```\n\n```java\n// 페치 조인을 사용한 예\n\n...\n\nquery.from(order)\n    .innerJoin(order.member, member).fetch()\n    .leftJoin(order.orderItems, orderItem).fetch()\n    .list(order);\n```\n\n```java\n// 세타 조인을 사용한 예\n\nQOrder order = QOrder.order;\nQMember member = QMember.member;\n\nquery.from(order, member)\n    .where(order.member.eq(member))\n    .list(order);\n```\n\n### ➰ 서브 쿼리\n서브 쿼리는 `JPASubQuery` 를 생성해 사용한다.\n- 결과가 하나면 `unique()` , 여러 건이면 `list()` 를 사용한다.\n\n```java\n// 서브 쿼리 - 한 건\nQItem item = QItem.item;\nQItem itemSub = new QItem(\"itemSub\");\n\nquery.from(item)\n    .where(item.price.eq(\n      new JPASubQuery().from(itemSub).unique(itemSub.price.max())\n    ))\n    .list(item);\n```\n\n### ➰ 프로젝션과 결과 반환\n**📌 프로젝션 대상이 하나**\n- 프로젝션 대상이 하나면 해당 타입으로 반환한다.\n\n**📌 여러 컬럼 반환과 튜플**\n- 프로젝션 대상으로 여러 필드를 선택하면, QueryDSL은 기본으로 **Tuple**을 사용한다. \n  - `List<Tuple>` 로 반환받는다.\n  - 조회 결과는 `tuple.get()` 메소드에 조회한 쿼리 타입을 지정하면 된다.\n\n**📌 빈 생성**\n- 쿼리 결과를 엔티티가 아닌 특정 객체로 받고 싶다면, **빈 생성(Bean population) 기능**을 사용한다.\n  - 프로퍼티 접근\n  - 필드 직접 접근\n  - 생성자 사용\n- 원하는 방법 지정을 위해서는 `com.mysema.query.types.Projections` 를 사용하면 된다.\n\n먼저 **프로퍼티 접근(`Setter`) 방식**이다.\n```java\nQItem item = QItem.item;\nList<ItemDTO> result = query.from(item).list(\n  Projections.bean(ItemDTO.class, item.name.as(\"username\"), item.price));\n```\n- `Projections.bean()` 은 수정자(`Setter`)를 사용해 값을 채운다.\n- 쿼리 결과와 매핑할 프로퍼티 이름이 다르다면 `as` 를 사용해서 별칭을 사용하면 된다.\n\n먼저 **필드 직접 접근 방식**이다.\n```java\nQItem item = QItem.item;\nList<ItemDTO> result = query.from(item).list(\n  Projections.fields(ItemDTO.class, item.name.as(\"username\"), item.price));\n```\n- `Projections.fields()` 를 사용해 필드에 직접 접근해 값을 채운다.\n- 필드를 `private` 로 설정해도 동작한다.\n\n먼저 **생성자 방식**이다.\n```java\nQItem item = QItem.item;\nList<ItemDTO> result = query.from(item).list(\n  Projections.constructor(ItemDTO.class, item.name, item.price));\n```\n- `Projections.constructor()` 는 생성자를 사용한다. \n- 지정한 프로젝션과 파라미터 순서가 같은 생성자가 필수적이다.\n\n### ➰ 수정, 삭제 배치 쿼리\nJPQL 배치 쿼리와 같이 **영속성 컨텍스트를 무시하고 데이터베이스를 직접 쿼리**한다는 점을 유의해야 한다.\n- 수정 배치 쿼리는 `com.mysema.query.jpa.impl.JPAUpdateClause` 를 사용하고,\n- 삭제 배치 쿼리는 `com.mysema.query.jpa.impl.JPADeleteClause`\n\n### ➰ 동적 쿼리\n`com.mysema.query.BooleanBuilder` 를 사용하면 특정 조건에 따른 동적 쿼리를 편리하게 생성할 수 있다.\n- `BooleanBuilder.and()` 메소드로 쿼리를 붙여 작성할 수 있다.\n\n### ➰ 메소드 위임\n메소드 위임(Delegate methods) 기능으로 쿼리 타입에 검색 조건을 직접 정의할 수 있다.\n\n```java\npublic class ItemExpression {\n\n  @QueryDelegate(Item.class)\n  public static BooleanExpression isExpensive(QItem item, Integer price) {\n    return item.price.gt(price);\n  }\n}\n```\n- 먼저 정적(`static`) 메소드를 만들고,\n- `@QueryDelegate` annotation에 속성으로 이 기능을 적용할 엔티티를 지정한다.\n\n---\n\n## 💫 네이티브 SQL\nJPQL은 표준 SQL이 지원하는 대부분의 문법과 SQL 함수들을 지원하지만, 특정 데이터베이스에 종속적인 기능은 지원하지 않는다.\n- 특정 데이터베이스만 지원하는 함수, 문법, SQL 쿼리 힌트\n- 인라인 뷰(FROM 절에서 사용하는 서브 쿼리), UNION, INTERSECT\n- Stored procedure\n\n하지만 때로는 특정 데이터베이스에 종속적인 기능이 필요하므로, 아래와 같이 JPA 구현체들은 다양한 방법을 지원한다.(JPA보다 더 다양한 방법 지원)\n- 특정 데이터베이스만 사용하는 함수\n  - JPQL에서 네이티브 SQL 함수를 호출할 수 있다.\n  - Hibernate는 데이터베이스 방언에 각 데이터베이스에 종속적인 함수들을 정의했다. 또한 직접 정의할 수도 있다.\n- 특정 데이터베이스만 지원하는 SQL 쿼리 힌트\n  - Hibernate를 포함한 몇몇 JPA 구현체들이 지원한다.\n- 인라인 뷰(FROM절에서 사용하는 서브 쿼리), UNION, INTERSECT\n  - 일부 JPA 구현체들이 지원한다.\n- Stored procedure\n  - JPQL에서 호출할 수 있다.\n- 특정 데이터베이스만 지원하는 문법\n  - 너무 종속적인 SQL 문법은 지원하지 않아 네이티브 SQL을 사용해야 한다.\n\nJPQL을 사용할 수 없을 때 JPA는 SQL을 직접 사용할 수 있는 기능을 제공하는데 이를 네이티브 SQL이라 한다.\n- JPQL을 사용하면 JPA가 SQL을 생성한다.\n\n**📌 JPA가 지원하는 네이티브 SQL과 JDBC API를 직접 사용하는 것의 차이**\n- 네이티브 SQL을 사용하면 엔티티를 조회할 수 있고,\n- JPA가 지원하는 영속성 컨텍스트의 기능을 그대로 사용할 수 있다.\n\n### ➰ 네이티브 SQL 사용\n네이티브 쿼리 API는 다음 3가지가 있다.\n\n```java\n// 결과 타입 정의\npublic Query createNativeQuery(String sqlString, Class resultClass);\n\n// 결과 타입을 정의할 수 없는 경우\npublic Query createNativeQuery(String sqlString);\n\n// 결과 매핑 사용\npublic Query createNativeQuery(String sqlString, String resultSetMapping);\n```\n\n**📌 엔티티 조회**<br/>\n네이티브 SQL은 `em.createNativeQuery()` 를 사용한다. \n- 첫 번째 파라미터는 네이티브 SQL을 입력하고,\n- 두 번째 파라미터는 조회할 엔티티 클래스의 타입을 입력한다.\n\n> JPQL과 흡사하지만 실제 데이터베이스 SQL을 사용한다는 것과, 위치기반 파라미터만 지원한다는 차이가 있다.\n\n**\"가장 중요한 점은 네이티브 SQL로 SQL만 직접 사용할 뿐이지 나머지는 JPQL을 사용할 떄와 같다. 조회한 엔티티도 영속성 컨텍스트에서 관리된다.\"**\n\n**📌 값 조회**<br/>\n값으로만 조회하는 경우 `em.createNativeQuery()` 의 두 번째 파라미터를 사용하지 않으면 된다.\n- 조회한 값들은 `Object[]` 에 담아서 반환된다.\n- 스칼라 값들을 조회했으므로 영속성 컨텍스트에서 관리되지 않는다.\n\n**📌 결과 매핑 사용**<br/>\n엔티티와 스칼라 값을 함께 조회하는 경우처럼 **매핑이 복잡**해지면, `@SqlResultSetMapping` 을 정의해서 결과 매핑을 사용해야 한다.\n- `em.createNativeQuery()` 의 두 번째 파라미터에 정의한 결과 매핑 정보의 이름을 사용한다.\n\n```java\n// 결과 매핑 정의\n@Entity\n@SqlResultSetMapping(name = \"memberWithOrderCount\",\n    entities = {@EntityResult(entityClass = Member.class)},\n    columns = {@ColumnResult(name = \"ORDER_COUNT\")}\n)\npublic class Member {...}\n```\n- 회원 엔티티와 `ORDER_COUNT` 컬럼을 매핑했다.\n- 여러 엔티티와 컬럼들을 매핑할 수 있다.\n\n**📌 결과 매핑 annotation**<br/>\n- `@SqlResultSetMapping` 속성\n  - name : 결과 매핑 이름\n  - entities : `@EntityResult` 를 사용해서 엔티티를 결과로 매핑한다.\n  - columns : `@ColumnResult` 를 사용해서 컬럼을 결과로 매핑한다.\n- `@EntityResult` 속성\n  - entityClass : 결과로 사용할 엔티티 클래스를 지정한다.\n  - fields : `@FieldResult` 를 사용해서 결과 컬럼을 필드와 매핑한다.\n  - discriminatorColumn : 엔티티의 인스턴스 타입을 구분하는 필드(상속에서 사용)\n- `@FieldResult` 속성\n  - name : 결과를 받을 필드명\n  - column : 결과 컬럼명\n- `@ColumnResult` 속성\n  - name : 결과 컬럼명\n\n### ➰ Named 네이티브 SQL\nJPQL처럼 Named 네이티브 SQL을 사용해서 정적 SQL을 작성할 수 있다.\n- 이때 `@NamedNativeQuery` annotation으로 Named 네이티브 SQL을 등록한다.\n\n```java\nTypedQuery<Member> nativeQuery = \n    em.createNamedQuery(\"Member.memberSQL\", Member.class)\n        .setParameter(1, 20);\n```\n- JPQL Named 쿼리와 같은 `createNamedQuery` 메소드를 사용한다. 따라서 `TypeQuery` 를 사용할 수 있다.\n- 이후 Named 네이티브 쿼리에서 `resultSetMapping` 속성을 사용해서 조회 결과를 매핑할 대상을 지정할 수 있다.\n\n**📌 @NamedNativeQuery**<br/>\n- name : Named 쿼리 이름 (필수)\n- query : SQL 쿼리 (필수)\n- hints : 벤더 종속적인 힌트\n- resultClass : 결과 클래스\n- resultSetMapping : 결과 매핑 사용\n\n### ➰ 네이티브 SQL XML에 정의\nXML에 정의 시, \n1. `<named-native-query>` 를 먼저 정의하고,\n2. `<sql-result-set-mapping>` 을 정의해야 한다.\n\n### ➰ 네이티브 SQL 정리\n네이티브 SQL도 JPQL을 사용할 때와 마찬가지로 `Query` , `TypeQuery`(Named 네이티브 쿼리의 경우만!)를 반환한다.\n- 따라서 **JPQL API를 그대로 사용**할 수 있다.\n\n네이티브 SQL은 JPQL이 자동 생성하는 SQL을 수동으로 직접 정의하는 것이다.\n- 따라서 **JPA가 제공하는 기능 대부분을 그대로 사용**할 수 있다.\n\n### ➰ 스토어드 프로시저\nJPQ 2.1부터 지원한다.\n\n**📌 스토어드 프로시저 사용**<br/>\n입력 값을 두 배로 증가시켜 주는 스토어드 프로시저가 있다.\n- 첫 번째 파라미터로 값을 입력받고, 두 번째 파라미터로 결과를 반환한다.\n\n```sql\nDELIMITER //\n\nCREATE PROCEDURE proc_multiply (INOUT inParam INT, INOUT outParam INT)\nBEGIN\n  SET outParam = inParam * 2;\nEND //\n```\n\nJPA로 이 스토어드 프로시저를 호출하기 위해서는,\n- `em.createStoredProcedureQuery()` 메소드에 사용할 프로시저의 이름을 명시한다.\n- 그리고 `registerStoredProcedureParameter()` 메소드를 사용해 프로시저에서 사용할 파라미터를 순서, 타입, 파라미터 모드 순으로 정의한다.\n  - 순서 대신에 이름을 사용할 수도 있다.\n\n**📌 Named 스토어드 프로시저 사용**<br/>\n스토어드 프로시저 쿼리에 이름을 부여해서 사용하는 것을 말한다.\n- `@NamedStoredProcedureQuery` 로 정의하고, `name` 속성으로 이름을 부여하면 된다.\n- `procedureName` 에 실제 호출할 프로시저의 이름을 명시하고,\n- `@StoredProcedureParameter` 를 사용해 파라미터 정보를 정의하면 된다.\n\n---\n\n## 💫 객체지향 쿼리 심화\n한 번에 여러 데이터를 수정할 수 있는 \"벌크 연산\"과 JPQL과 영속성 컨텍스트에 대해 다룬다. 그리고 JPQL과 플러시 모드를 다룬다.\n\n### ➰ 벌크 연산\n엔티티를 수정하려면 영속성 컨텍스트의 변경 감지 기능이나 병합을 사용하고, 삭제하려면 `em.remove()` 메소드를 사용한다.\n- 하지만 엄청나게 많은 엔티티를 처리하기에는 많은 시간 비용이 든다.\n- 이럴 때 사용하는 것이 **벌크 연산**이다.\n\n```java\n// UPDATE 벌크 연산\nString qlString = \n    \"update Product p \" + \n    \"set p.price = p.price * 1.1 \" +\n    \"where p.stockAmount > :stockAmount\";\n\nint resultCount = em.createQuery(qlString)\n                    .setParameter(\"stockAmount\", 10)\n                    .executeUpdate();\n```\n- 벌크 연산은 `executeUpdate()` 메소드를 사용한다.\n  - 벌크 연산으로 영향 받은 엔티티의 건수를 반환한다.\n- 삭제 또한 같은 메소드를 사용한다.\n\n> JPA 표준은 아니지만 Hibernate는 INSERT 벌크 연산도 지원한다.\n\n**📌 벌크 연산의 주의점**<br/>\n벌크 연산이 **영속성 컨텍스트를 무시**하고 **데이터베이스에 직접 쿼리**한다는 점에 주의해야 한다.\n- 따라서 **영속성 컨텍스트에 있는 값과 데이터베이스에 있는 값이 다를 수 있다.**\n- 아래는 그 해결방법들이다.\n\n**`em.refresh()` 사용**\n- 벌크 연산을 수행한 직후, 정확한 엔티티를 사용해야 한다면, `em.refresh()` 를 사용해 데이터베이스에서 해당 엔티티를 다시 조회하면 된다.\n\n**벌크 연산 먼저 실행**\n- 가장 실용적인 해결책이다. \n- 벌크 연산을 실행하고 난 뒤, 엔티티를 조회하여 두 값이 같도록 해준다.\n\n**벌크 연산 수행 후 영속성 컨텍스트 초기화**\n- 벌크 연산 수행 직후 영속성 컨텍스트를 초기화해서 남아 있는 엔티티를 제거하는 것도 좋은 방법이다.\n- 초기화한 후 엔티티를 조회하게 되면, 벌크 연산이 적용된 데이터베이스에서 엔티티를 조회할 것이다.\n\n### ➰ 영속성 컨텍스트와 JPQL\n**📌 퀴리 후 영속 상태인 것과 아닌 것**<br/>\nJPQL로 엔티티를 조회하면 영속성 컨텍스트에서 관리되지만 그렇지 않은 경우는 관리되지 않는다.\n\n> **조회한 엔티티만 영속성 컨텍스트가 관리하고, 변경 감지가 발생한다.**\n\n**📌 JPQL로 조회한 엔티티와 영속성 컨텍스트**<br/>\n영속성 컨텍스트에 이미 특정 엔티티가 있는 경우에 동일한 엔티티를 JPQL로 조회한다면?\n- 이미 영속성 컨텍스트에 동일한 엔티티가 있는 경우, **JPQL로 데이터베이스에서 조회한 결과를 버리고, 영속성 컨텍스트에 있던 엔티티를 반환**한다.\n  - 이때 **식별자 값을 사용해서 비교**한다.\n\nJPQL로 조회한 새로운 엔티티를 영속성 컨텍스트에 하나 더 추가하거나, 기존 엔티티를 새로 검색한 엔티티로 대체하면 어떤 문제가 발생하는 것일까?\n- 영속성 컨텍스트는 기본 키 값을 기준으로 엔티티를 관리한다.\n  - 따라서 **같은 기본 키 값을 가진 엔티티는 등록이 불가**하다. → \"새로운 엔티티 더 추가 불가능\"\n- **영속성 컨텍스트는 엔티티의 동일성을 보장**한다. \n  - 영속성 컨텍스트에 수정 중인 데이터가 사라질 위험이 존재하는 행위는 불가하다. → \"새로운 엔티티로 대체 불가능\"\n\n> 이러한 이유로 기존 엔티티는 그대로 두고 새로 검색한 엔티티를 버리는 정책을 따른다.\n\n**📌 find() vs. JPQL**<br/>\n`em.find()` 메소드는 엔티티를 **영속성 컨텍스트에서 먼저 찾고, 없다면 데이터베이스에서 조회**한다.\n- 따라서 영속성 컨텍스트에 찾으려는 엔티티가 있다면, 메모리에서 바로 찾으므로 성능상 이점이 있다. (1차 캐시)\n\n하지만 **JPQL은 항상 데이터베이스에 SQL을 실행해서 결과를 조회**한다.\n- 동일한 엔티티를 조회할 때마다 데이터베이스에서 조회하지만, 첫 조회 이후 해당 엔티티가 영속성 컨텍스트에 등록되어 있기 때문에, 위에서 언급한 정책에 따라 데이터베이스에서 조회한 엔티티를 버리고, 기존 엔티티를 반환한다.\n\n### ➰ JPQL과 플러시 모드\n> **플러시**\n> - 영속성 컨텍스트의 변경 내역을 데이터베이스에 동기화하는 것이다.\n> - JPA는 플러시가 일어날 때 영속성 컨텍스트에 등록, 수정, 삭제한 엔티티를 찾아 SQL을 만들고 데이터베이스에 반영한다.\n> - 플러시 호출 메소드가 있지만, 보통 플러시 모드에 따라 커밋 직전이나 쿼리 실행 직전에 자동으로 호출된다.\n\n플러시 모드는 `FlushModeType.AUTO` 가 기본값이다. \n- 따라서 트랜잭션 커밋 직전이나 쿼리 실행 직전에 자동으로 플러시를 호출한다.\n- 다른 옵션으로는 `FlushModeType.COMMIT` 이 있는데, 이는 커밋 시에만 플러시를 호출하고 쿼리 실행 시에는 플러시를 호출하지 않는다.\n  - 이 옵션은 성능 최적화를 위해 꼭 필요할 때만 사용하도록 한다.\n\n**📌 쿼리와 플러시 모드**<br/>\nJPQL은 영속성 컨텍스트에 있는 데이터를 고려하지 않고 데이터베이스에서 조회한다.\n- 따라서 **JPQL을 실행하기 전 영속성 컨텍스트의 내용을 데이터베이스에 반영해야 한다.**\n- 그렇지 않으면(`FlushModeType.COMMIT` 인 경우) 영속성 컨텍스트에는 수정된 엔티티의 내용이 데이터베이스에는 반영되지 않아 원치 않는 결과를 만나게 된다.\n  - `setFlushMode()` 메소드로 플러시 모드를 설정해줄 수 있다.\n\n**📌 플러시 모드와 최적화**<br/>\n그렇다면 `COMMIT` 모드는 왜 사용하는 것일까?\n- 잘못하면 데이터 무결성에 심각한 피해를 줄 수 있는 위험이 있는 모드라 생각된다.\n- 하지만, **플러시를 너무 자주 일으키는 상황**에 이 모드를 사용하면, 쿼리 시 발생하는 **플러시 횟수를 줄여 성능 최적화에 도움**이 될 수 있다.\n\n또한, JPA를 사용하지 않고, JDBC를 직접 사용해서 SQL을 실행할 때도 플러시 모드를 고민해야 한다.\n- JPA를 통하지 않고 직접 쿼리를 실행하면 JPA는 JDBC가 실행한 쿼리를 인식할 방법이 없다.\n  - 따라서 별도의 JDBC 호출은 플러시 모드를 `AUTO` 설정해도 플러시가 발생하지 않는다.\n- 이때, 쿼리 실행 직전에 `em.flush()` 를 호출해 내용을 동기화하는 것이 안전하다.\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략 - 구종만을 읽고 정리한 POST입니다. 💡 개관 어떤 작업이 주어졌을 때 컴퓨터가 이 작업을 해결하는 방법을 알고리즘이라고 한다. 또 다르게는, 같은 일을 하는 여러 가지의 방법이 존재한다. 이때 주어진 문제를 해결하는 한 가지 방법을 명료하게 써놓은 것을 알고리즘이라고 한다. 이러한 측면에서, 주관적…","fields":{"slug":"/[Algorithm]알고리즘분석/"},"frontmatter":{"date":"March 28, 2022","title":"💡 알고리즘 분석","tags":["종만북"]},"rawMarkdownBody":"\n<em>[프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략 - 구종만]을 읽고 정리한 POST입니다.</em>\n\n## 💡 개관\n어떤 작업이 주어졌을 때 컴퓨터가 이 작업을 해결하는 방법을 **알고리즘**이라고 한다. 또 다르게는, 같은 일을 하는 여러 가지의 방법이 존재한다. 이때 주어진 문제를 해결하는 한 가지 방법을 명료하게 써놓은 것을 **알고리즘**이라고 한다.\n\n이러한 측면에서, 주관적이거나 모호한 것은 알고리즘이라고 할 수 없다. \"서울 신촌역에서 춘천에 간다.\" 라는 예시를 들었을 때, 다음은 정당한 알고리즘이라고 할 수 있다.\n\n1. 지하철 2호선을 타고 시청역으로 간다.\n2. 지하철 1호선으로 갈아타고 청량리역으로 간다.\n3. 경춘선을 타고, 춘천역에서 내린다.\n\n하지만 다음의 경우는 매우 주관적이며, 따라서 본질적으로 모호하기에 알고리즘이라고 할 수 없다.\n\n1. 강동구 쪽으로 가는 버스를 탄다.\n2. 동서울 버스 터미널 근처에 온 것 같으면 내린다.\n3. 춘천 쪽으로 가는 버스를 타고, 한참 가다 내린다.\n\n한 문제를 해결하는 데 여러 개의 알고리즘이 있을 수 있다. 그렇다면 어떠한 알고리즘을 만들어야 할까? 알고리즘에 대한 평가 기준은 **\"시간\"과 \"공간\"**이 있다.\n\n- **시간**\n  - 알고리즘이 적은 시간을 사용한다 = 더 빠르게 동작한다\n  - 알고리즘의 수행 속도와 특성을 분석하는 능력을 배양할 필요가 있다.\n- **공간**\n  - 알고리즘이 적은 공간을 사용한다 = 더 적은 용량의 메모리를 사용한다\n  - 이론적으로 아무리 빠르더라도 너무 많은 메모리 공간을 요구한다면 수행할 수 없을 것이다.\n\n두 평가 기준은 서로 상충되어 tradeoff를 발생시키는 경우가 많다. 이후에 나올 알고리즘들에서 다루도록 한다.\n\n---\n\n## 💡 알고리즘의 시간 복잡도 분석\n### 🔍 도입\n좀 더 빠른 알고리즘을 만들기 위해서는 알고리즘의 속도를 어떻게 측정할지에 대한 기준을 정해야 한다. 가장 직관적인 방법은 \"각각을 프로그램으로 구현한 뒤 같은 입력에 대해 두 프로그램의 수행 시간을 측정하는 것\"이다. 실구현 시 사용자가 느끼기에 너무 느리다면 소용이 없기 때문에 현실적으로도 유용한 방법 중 하나이다.\n\n하지만 \"프로그램의 실행 시간은 알고리즘의 속도를 일반적으로 이야기하는 기준이 되기에는 **부적합**\"하다.\n- 프로그램의 수행 시간은 사용한 프로그래밍 언어, 하드웨어는 물론이고 운영체제, 컴파일러까지 **수많은 요소에 의해 바뀔 수 있기 때문**이다.\n- 프로그램의 실제 수행 시간이 다양한 입력에 대한 실행 시간을 반영하지 못하는 문제도 있다.\n  - 알고리즘은 언제나 같은 속도로 동작하는 것이 아니며, 입력의 크기나 특성에 따라 수행 시간이 달라질 수 있다.\n\n**반복문이 지배한다**<br/>\n자동차 2대가 있고, 서울에서 부산까지 가려고 할 때 어느 자동차를 타야 빨리 도착할 수 있을지 알고 싶다. 아래는 자동차에 대한 정보이다.\n\n|항목|자동차A|자동차B|\n|---|---|---|\n|시동 거는데 걸리는 시간|3분|5초|\n|문 열었다 닫는 데 걸리는 시간|1분|0초|\n|운전석 등받이 조절에 걸리는 시간|5분|0초|\n|앞 유리 닦는데 걸리는 시간|4분|0초|\n|최대 시속|200km/h|40km/h|\n\n사실 자동차 B는 자전거이다. 시동 거는데 걸리는 시간을 제외하고는 다른 부가적인 시간들이 필요없지만, 그렇다고 해서 자전거를 타고 서울에서 부산까지 가려는 사람은 별로 없을 것이다. \n- 오래 걸리는 항목들은 사실 출발할 때 한 번만 적용되는 반면, 최대 시속은 달리는 내내 적용되기 때문이다.\n\n이렇게 한 가지 항목이 전체의 대소를 좌지우지하는 것을 \"지배한다(dominate)\"라고 표현한다.\n\n그럼 알고리즘에서 수행 시간을 지배하는 것은 무엇일까? 바로 **반복문**이다.\n- 입력에 상관없이 항상 같은 수행 시간을 갖는 알고리즘도 있지만, 대개 입력 크기에 따라 수행 횟수가 정해지는 반복문이 있기 마련이다.\n  - 입력이 작을 수록 반복 외의 다른 요소들의 비중이 클 수 있지만, **입력이 커질 수록 반복문이 알고리즘의 수행 시간을 지배**하게 된다.\n\n> 따라서, 대개 알고리즘의 수행 시간을 **반복문이 수행되는 횟수**로 측정한다. (입력의 크기에 대한 함수로 표현)\n\n아래는 주어진 배열에서 가장 많이 등장하는 수를 찾는 코드이다. 수행 시간은 배열의 크기 `N` 에 따라서 변한다. `N` 번 수행되는 반복문이 두 개 겹쳐있어 반복문의 가장 안쪽은 항상 `N^2` 번 실행되고, 따라서 이 알고리즘의 수행 시간은 `N^2` 이다.\n\n```java\nprivate static int majority(int[] array) {\n    int N = array.length;\n    int majority = -1, majorityCnt = 0;\n    \n    for (int i = 0; i < N; i++) {\n      // array에 등장하는 요소의 수를 센다.\n      int V = array[i], cnt = 0;\n      for (int j = 0; j < N; j++) {\n        if (V == array[j])\n          cnt++;\n      }\n      \n      // 지금까지의 최대 빈도와 비교 후 최신화\n      if (cnt > majorityCnt) {\n        majorityCnt = cnt;\n        majority = V;\n      }\n    }\n    \n    return majority;\n}\n```\n\n만약 입력으로 주어지는 숫자들의 범위가 작다면, 배열을 이용해 각 숫자가 등장하는 횟수를 쉽게 셀 수 있고, 마지막에 빈도수 배열을 순회하면서 최대치의 위치를 찾으면 된다. 아래 코드가 이를 구현했다. \n\n```java\nprivate static int majority2(int[] array) {\n  int N = array.length;\n  int[] frequency = new int[101];\n  for (int j : array) {\n    frequency[j]++;\n  }\n  \n  int majority = 0;\n  for (int i = 1; i <= 100; i++) {\n    if (frequency[i] > frequency[majority])\n        majority = i;\n  }\n  \n  return majority;\n}\n```\n\n- 반복문이 2개가 있다. 하나는 `N` 번 수행되고, 하나는 100번 수행된다. 고로 전체 수행 횟수는 `N + 100` 이 된다. \n- 그런데 `N` 이 커지면 커질 수록 사실 100번 수행하는 반복문은 수행 시간에서 차지하는 비중이 줄어들게 된다. 따라서 궁극적으로는 이 알고리즘의 수행 시간을 `N` 이라고 쓴다.\n\n### 🔍 선형 시간 알고리즘\n**다이어트 현황 파악: 이동 평균 계산하기**<br/>\n이동 평균(moving average)은 시간에 따라 변화하는 값들을 관찰할 때 유용하게 사용할 수 있는 통계적 기준이다. N개의 측정치가 주어질 때 매달 M달 간의 이동 평균을 계산하는 프로그램은 어떻게 짜야 할까?\n- 각 위치에서 지난 M개 측정치의 합을 구하고, 이를 M으로 나눈다.\n\n```java\n private static double[] movingAverage(double[] A, int M) {\n    int N = A.length;\n    double[] ret = new double[N];\n    int retIdx = 0;\n    for (int i = M-1; i < N; i++) {\n      double partialSum = 0;\n      for (int j = 0; j < M; j++)\n        partialSum += A[i-j];\n      ret[retIdx++] = partialSum/M;\n    }\n    return ret;\n}\n```\n\n- 이는 간단하게 두 개의 for문을 사용하는 코드로 구현할 수 있다.\n  - 즉 두 개의 for문에 의해 지배된다. \n- 이 코드의 수행 시간을 좀 더 줄이는 방법은 없을까?\n\n> 중요한 아이디어는 중복된 계산을 없애는 것이다.\n\n측정치가 M개는 되어야 이동 평균을 계산할 수 있으니, 태어난 이후 M-1일부터 이동 평균을 계산할 수 있다. \n- 아래 표에서 M-1일의 이동 평균과 M일의 이동 평균에 포함되는 숫자들을 찾아본다.\n\n|날짜|0|1|2|3|4|...|M-1|M|M+1|\n|---|---|---|---|---|---|---|---|---|---|\n|몸무게|3.5|3.5|3.5|3.6|3.5|...|80.2|80.1|80.3|\n\n- 0일과 M일의 몸무게를 제외하면 전부 겹친다는 것을 확인할 수 있다.\n- 그렇다면 측정한 몸무게의 합을 일일이 구할 필요 없이 M-1일에 구했던 몸무게의 합에서 0일째에 측정한 몸무게를 빼고 M일째에 측정한 몸무게를 더하면 되지 않을까?\n\n```java\n private static double[] movingAverage2(double[] A, int M) {\n    int N = A.length;\n    double[] ret = new double[N];\n    int retIdx = 0;\n    double partialSum = 0;\n    for (int i = 0; i < M-1; i++) partialSum += A[i];\n    for (int i = M-1; i < N; i++) {\n      partialSum += A[i];\n      ret[retIdx++] = partialSum/M;\n      partialSum -= A[i-M+1];\n    }\n    return ret;\n}\n```\n\n- 하나로 묶여있던 이중 for문을 분리해 반복문의 수행 횟수를 확 줄였다.\n- 수행 시간은 N에 정비례하게 되고, 그래프로 그려보면 정확히 직선이 된다. \n  - 이러한 알고리즘을 **선형 시간(linear time) 알고리즘**이라고 한다. \n  - 이런 알고리즘이 대개 가장 좋은 알고리즘인 경우가 많다. 주어진 입력을 최소한 한 번씩 쳐다보기라도 하려면 선형 시간이 걸릴 수밖에 없기 때문이다!\n\n### 🔍 선형 이하 알고리즘\n**성형 전 사진 찾기**<br/>\n어떤 문제 건 입력된 자료를 모두 한 번 훑는데는 입력의 크기에 비례하는 시간, 즉 선형 시간이 걸린다. 그런데 선형 이하 알고리즘은 그만큼의 시간도 걸리지 않는다는 의미인데, 어떻게 가능할까? 입력으로 주어진 자료에 대해 우리가 미리 알고 있는 지식을 활용할 수 있다면 가능해진다.\n\n예를 들어, 어떤 연예인 A군의 코 성형 전 고등학교 사진이 공개되었다. 남들 몰래 A군의 팬인 저는 A군이 대체 언제 성형을 했는지 알고 싶어 검색엔진으로 A군의 사진 10만 장을 찾아 이들을 촬영 날짜 순으로 정렬했다. 그럼 A군이 언제 성형했는지를 가능한 한 정확하게 알려면 대체 몇 장의 사진을 확인해야 할까?\n- 10만장의 사진을 모두 보는 것은 시간 낭비이므로, **남은 사진들을 항상 절반으로 나눠 가운데 있는 사진을 보는 것**이다.\n  - 먼저 가운데 있는 5만 번째 사진을 확인했을때, 코를 성형하지 않은 상태라면 이 전의 사진은 볼 필요가 없다. 당연히 성형을 하지 않은 상태의 사진들일 것이니까!\n  - 이로서 확인해야 할 사진이 5만장으로 줄었고, 다시 그 중 가운데 사진을 확인해 위의 과정을 동일하게 거친다. \n  - 확인할 때마다 남은 장수가 대략 절반으로 준다면, 총 몇 장의 사진을 확인해야 할까?\n\n|확인한 사진의 수|0|1|2|...|9|10|11|12|13|14|15|16|\n|---|---|---|---|---|---|---|---|---|---|\n|남은 사진|100,000|50,000|25,000|...|195|97|48|24|12|6|3|1|\n\n위 표는 확인하는 사진의 수가 증가함에 따라 남은 사진의 수가 어떻게 줄어드는지를 보여준다. 대략 17장의 사진만 확인하면 성형한 시점을 찾아낼 수 있다.\n- 이를 봐야 하는 사진의 장수 N에 대해 표현하게 되면, 매번 절반씩 나누니 밑이 2인 로그 $log_2$를 사용하면 되고, 따라서 대략 $logN$이 된다.\n- $log$는 굉장히 느리게 증가하는 함수이다. 이와 같이 입력의 크기가 커지는 것보다 수행 시간이 느리게 증가하는 알고리즘들을 **선형 이하 시간(sublinear time) 알고리즘**이라고 한다.\n\n**이진 탐색**<br/>\n방금 전 예제에서 사용한 알고리즘을 이진 탐색(binary search)라고 한다.\n\n> `binsearch(A[],x)` = 오름차순으로 정렬된 배열 `A[]` 와 찾고 싶은 값 `x` 가 주어질 때 `A[i-1] < x <= A[i]` 인 `i` 를 반환한다. 이때 `A[-1] = -∞` , `A[N] = ∞` 로 가정한다.\n\n- 쉽게 생각해서, 배열 `A[]` 에서 `x` 를 삽입할 수 있는 위치 중 가장 앞에 있는 것을 반환하는 함수라고 생각하면 된다. 대개의 배열이나 리스트 구현에서 `i` 번째 위치에 새 원소를 삽입한다 = `i` 번째와 그 이후의 원소들을 뒤로 한 칸씩 밀어내고 들어간다와 동일한 의미이다.\n  - 따라서 `A[]` 에 `x` 가 존재한느 경우 이 함수는 첫 번째 `x` 의 위치를 반환하고, 없는 경우 `x` 보다 큰 첫 번째 원소를 반환한다.\n\n**그래도 선형 시간 아닌가요?**<br/>\n그런데 `binsearch()` 에 입력되는 배열을 만들기 위해서는 결국 모든 사진을 보면서 성형 이전인지 여부를 판단해야 한다. 게다가 그 전엔 모든 사진을 받아 시간 순으로 정렬까지 해야 한다. 따라서 전체는 선형 시간이 걸리는 게 아닌가 하는 의문이 든다. 하지만 이렇게 분석하지 않는 이유는 다음과 같다.\n1. `A[]` 를 실제로 계산해서 가지고 있을 필요가 없다. 사실은 입력 배열을 넘겨준다해도, 이진 탐색 알고리즘 내부에서는 그 중 몇 개 보지도 않을 것이다. 따라서 이들을 미리 계산할 것이 아니라, 가운데 있는 것들에 대해서만 필요할 때 계산(성형 여부를 판단)하면 된다.\n   - `binsearch()` 에 `A[]` 를 인자로 넘기는 것이 아닌 `i` 가 주어질 때 `A[i]` 의 값을 직접 계산하는 콜백 함수를 제공한다거나 하는 방법으로 해결 가능하다.\n2. 사진을 다운받고 정렬하는 과정은 실제로 성형 전 사진을 찾는 작업과는 별개이다. 만약 A군이 코뿐만 아니라 턱까지도 성형을 했다고 하면, 이미 한 번 받아서 정렬해둔 사진이 있으면 다시 17장의 사진만 확인해서 언제 턱 성형을 했는지 알 수 있을 것이다.\n\n**구현**<br/>\n이진 탐색을 정확하게 구현하는 것은 매우 까다롭다. 이는 알고리즘의 정당성을 증명하는 방법을 다룰 때 다시 언급한다.\n\n### 🔍 지수 시간 알고리즘\n**다항 시간 알고리즘**<br/>\n\"반복문의 수행 횟수를 입력 크기의 다항식으로 표현할 수 있는 알고리즘\"들을 다항 시간 알고리즘이라고 한다.\n- 다항 시간이라는 하나의 분류에 포함되는 알고리즘 간에는 엄청나게 큰 시간 차이가 날 수 있다. (다항식의 포함 범주가 매우 크기 때문)\n- 다항 시간보다 더더욱 오랜 시간이 걸리는 알고리즘들이 있어 다항 시간 알고리즘을 묶었다.\n\n**알러지가 심한 친구들**<br/>\n집들이에 N명의 친구를 초대하려고 한다. 할 줄 아는 M가지 음식 중 무엇을 대접해야 할까를 고민하는데, 친구들은 각각 알러지 때문에 못 먹는 음식들이 있다. 만들 줄 아는 음식의 목록과, 해당 음식을 못 먹는 친구들의 목록이 주어질 때, 각 친구가 먹을 수 있는 음식이 최소 하나씩 있으려면 최소 몇 가지의 음식을 해야 할까?\n\n**모든 답 후보를 평가하기**<br/>\n여러 개의 답이 존재할 수 있다. 하지만 최소 개수의 답을 구하려고 할 때, 가장 간단한 방법은 모든 답을 일일이 고려해 보는 것이다.\n- 만들 수 있는 음식의 모든 목록을 만드는 과정은 여러 개의 결정으로 나누면 자연스럽다.\n- 첫 번째 요리를 만들지 말지 결정하고, 두 번째 요리를 만들지 말지를 결정하는 방식이다. 이렇게 점진적으로 결정하다보면, 마지막에는 존재 가능한 모든 목록을 만날 수 있다.\n  - 이제 가장 적은 수의 목록을 찾는다.\n\n이런 알고리즘을 구현하는 가장 쉬운 방법은 **재귀 호출**을 이용하는 것이다.\n- 이때 재귀 함수는 한 상태를 입력받아 이 상태 밑에 달린 모든 후보들을 검사하고 이 중 가장 좋은 답을 반환하는 역할을 한다.\n\n```java\nint INF = 987654321;\nint M;\n\nprivate static boolean canEverybodyEat(Stack<Integer> menu) { ... }\n\nprivate static int selectMenu(Stack<Integer> menu, int food) {\n  if (food == M) {\n    if (canEverybodyEat(menu)) return menu.length;\n    return INF;\n  }\n\n  int ret = selectMenu(menu, food + 1);\n  menu.push(food);\n  ret = Math.min(ret, selectMenu(menu, food + 1));\n  menu.pop();\n  return ret;\n}\n```\n\n**지수 시간 알고리즘**<br/>\n위 프로그램은 모든 답을 한 번씩 다 확인하기에, 전체 걸리는 시간은 만들 수 있는 답의 수에 비례하게 된다.\n- M가지의 음식마다 두 선택지가 있어 만들 수 있는 답은 모두 $2^M$가지이다.\n- 그리고 답을 하나 만들 때마다 `canEverybodyEat()` 를 수행해 이 알고리즘의 수행 시간은 $2^M$에 `canEverybodyEat()` 의 수행 시간을 곱한 것이 된다.\n- $2^M$과 같은 지수 함수는 알고리즘의 전체 수행 시간에 엄청난 영향을 미친다. 이와 같이 N이 하나 증가할 때마다 걸리는 시간이 배로 증가하는 알고리즘들은 **지수 시간(exponential time)에 동작**한다고 한다.\n  - 가장 큰 수행 시간 중 하나이다.\n\n**소인수 분해의 수행 시간**<br/>\n입력으로 주어지는 숫자의 개수가 아니라 그 크기에 따라 수행 시간이 달라지는 알고리즘들 또한 지수 수행 시간을 가질 수 있다.\n- 자연수 N이 주어질 때 N의 소인수 분해 결과를 반환하는 간단한 알고리즘이 있다.\n- 이 알고리즘은 N이 1이 될 때까지 가능한 모든 숫자로 N을 나눠보는데, 주어진 수 N이 소수인 경우 반복문이 가장 많이 실행된다.\n\n> 결과적으로 반복문의 실행 횟수는 N - 1이 되어, **실행 횟수가 대략 N에 비례해 최악의 경우 선형 시간이 걸린다고 생각할 수도 있다.**\n\n이런 불일치를 직관적으로 이해하기 위해 **알고리즘의 수행 시간과 입력이 메모리에서 차지하는 공간의 관계**를 생각해보자.\n- 이진 탐색, 이동 평균 계산 등 지금까지 다룬 알고리즘에서는 입력의 값들이 일정 범위 내에 있다고 어렵지 않게 가정할 수 있다.\n  - 이 경우 **입력의 개수와 메모리에서 차지하는 공간이 직접적으로 비례**한다.\n- 반면, 소인수 분해 문제에서는 입력으로 주어지는 숫자가 알고리즘의 동작에 직접적인 영향을 미쳐, 숫자가 특정 범위 안에 있다고 가정할 수 없다.\n  - 입력의 값이 커질수록 숫자를 저장하는데 필요한 메모리의 공간도 증가할 것이다.\n  - 이때 **입력이 차지하는 비트의 수에 따라 수행 시간이 증가**한다고 생각하면 아까의 불일치를 직관적으로 설명할 수 있다.\n\n### 🔍 시간 복잡도\n\n### 🔍 수행 시간 어림짐작하기\n\n### 🔍 계산 복잡도 클래스: P, NP, NP-완비\n\n## 📕 참고\n**프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략** - 구종만"},{"excerpt":"문제 크기가 N×M인 지도가 존재한다. 지도의 오른쪽은 동쪽, 위쪽은 북쪽이다. 이 지도의 위에 주사위가 하나 놓여져 있으며, 주사위의 전개도는 아래와 같다. 지도의 좌표는 (r, c)로 나타내며, r는 북쪽으로부터 떨어진 칸의 개수, c는 서쪽으로부터 떨어진 칸의 개수이다.    2\n4 1 3\n  5\n  6 주사위는 지도 위에 윗 면이 1이고, 동쪽을 …","fields":{"slug":"/[BOJ]14499/"},"frontmatter":{"date":"March 28, 2022","title":"👩‍💻 14499. 주사위 굴리기","tags":["구현","시뮬레이션"]},"rawMarkdownBody":"\n## 문제\n크기가 N×M인 지도가 존재한다. 지도의 오른쪽은 동쪽, 위쪽은 북쪽이다. 이 지도의 위에 주사위가 하나 놓여져 있으며, 주사위의 전개도는 아래와 같다. 지도의 좌표는 (r, c)로 나타내며, r는 북쪽으로부터 떨어진 칸의 개수, c는 서쪽으로부터 떨어진 칸의 개수이다. \n\n  2\n4 1 3\n  5\n  6\n\n주사위는 지도 위에 윗 면이 1이고, 동쪽을 바라보는 방향이 3인 상태로 놓여져 있으며, 놓여져 있는 곳의 좌표는 (x, y) 이다. 가장 처음에 주사위에는 모든 면에 0이 적혀져 있다.\n\n지도의 각 칸에는 정수가 하나씩 쓰여져 있다. 주사위를 굴렸을 때, 이동한 칸에 쓰여 있는 수가 0이면, 주사위의 바닥면에 쓰여 있는 수가 칸에 복사된다. 0이 아닌 경우에는 칸에 쓰여 있는 수가 주사위의 바닥면으로 복사되며, 칸에 쓰여 있는 수는 0이 된다.\n\n주사위를 놓은 곳의 좌표와 이동시키는 명령이 주어졌을 때, 주사위가 이동했을 때 마다 상단에 쓰여 있는 값을 구하는 프로그램을 작성하시오.\n\n주사위는 지도의 바깥으로 이동시킬 수 없다. 만약 바깥으로 이동시키려고 하는 경우에는 해당 명령을 무시해야 하며, 출력도 하면 안 된다.\n\n## 입, 출력\n\n입력\n- 첫째 줄에 지도의 세로 크기 N, 가로 크기 M (1 ≤ N, M ≤ 20), 주사위를 놓은 곳의 좌표 x, y(0 ≤ x ≤ N-1, 0 ≤ y ≤ M-1), 그리고 명령의 개수 K (1 ≤ K ≤ 1,000)가 주어진다.\n- 둘째 줄부터 N개의 줄에 지도에 쓰여 있는 수가 북쪽부터 남쪽으로, 각 줄은 서쪽부터 동쪽 순서대로 주어진다. 주사위를 놓은 칸에 쓰여 있는 수는 항상 0이다. 지도의 각 칸에 쓰여 있는 수는 10 미만의 자연수 또는 0이다.\n- 마지막 줄에는 이동하는 명령이 순서대로 주어진다. 동쪽은 1, 서쪽은 2, 북쪽은 3, 남쪽은 4로 주어진다.\n\n출력\n- 이동할 때마다 주사위의 윗 면에 쓰여 있는 수를 출력한다. 만약 바깥으로 이동시키려고 하는 경우에는 해당 명령을 무시해야 하며, 출력도 하면 안 된다.\n\n### 📍 **Logic**\n\n```java\nclass Dice {\n    int[][] map;\n    int[] commands;\n    int[] numbers = new int[6];\n    int[] rangeX = { 0, 0, -1, 1 };\n    int[] rangeY = { 1, -1, 0, 0 };\n    int N, M, K;\n    int top = 0, front = 4, east = 2;\n    ...\n\n}\n```\n\n- 주사위와 지도의 정보를 저장하는 클래스\n- top, front, east 정보를 계속 변경하는 방식으로 주사위의 숫자 정보를 추적한다.\n\n```java\npublic void game(int x, int y) {\n    for (int i = 0; i < K; i++) {\n        int nx = x + rangeX[commands[i] - 1];\n        int ny = y + rangeY[commands[i] - 1];\n\n        if (isInTheMap(nx, ny)) continue;\n\n        x = nx;\n        y = ny;\n\n        rollDice(commands[i] - 1);\n\n        if (map[x][y] == 0) {\n            map[x][y] = numbers[5 - top];\n        } else {\n            numbers[5 - top] = map[x][y];\n            map[x][y] = 0;\n        }\n\n        System.out.println(numbers[top]);\n    }\n}\n```\n\n- 명령어에 따라 지도에서의 주사위 위치를 변경시킨다.\n  - 지도 범위 안인 경우만 주사위 정보를 수정하고, 상단의 숫자를 출력한다.\n\n```java\nprivate void rollDice(int command) {\n    int t, e, f;\n    t = top;\n    e = east;\n    f = front;\n    switch (command) {\n        case 0:\n            top = 5 - e;\n            east = t;\n            break;\n        case 1:\n            top = e;\n            east = 5 - t;\n            break;\n        case 2:\n            top = f;\n            front = 5 - t;\n            break;\n        case 3:\n            top = 5 - f;\n            front = t;\n    }\n}\n```\n\n- 주사위의 top, front, east 정보를 업데이트하는 메소드\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.Arrays;\n\n    class Dice {\n        int[][] map;\n        int[] commands;\n        int[] numbers = new int[6];\n        int[] rangeX = { 0, 0, -1, 1 };\n        int[] rangeY = { 1, -1, 0, 0 };\n        int N, M, K;\n        int top = 0, front = 4, east = 2;\n\n        public Dice(int N, int M, int K) {\n            this.N = N;\n            this.M = M;\n            this.K = K;\n            map = new int[N][M];\n            commands = new int[K];\n        }\n\n        public void game(int x, int y) {\n            for (int i = 0; i < K; i++) {\n                int nx = x + rangeX[commands[i] - 1];\n                int ny = y + rangeY[commands[i] - 1];\n\n                if (isInTheMap(nx, ny)) continue;\n\n                x = nx;\n                y = ny;\n\n                rollDice(commands[i] - 1);\n\n                if (map[x][y] == 0) {\n                    map[x][y] = numbers[5 - top];\n                } else {\n                    numbers[5 - top] = map[x][y];\n                    map[x][y] = 0;\n                }\n\n                System.out.println(numbers[top]);\n            }\n        }\n\n        private boolean isInTheMap(int x, int y) {\n            return (x < 0 | x >= N | y < 0 | y >= M);\n        }\n\n        private void rollDice(int command) {\n            int t, e, f;\n            t = top;\n            e = east;\n            f = front;\n            switch (command) {\n                case 0:\n                    top = 5 - e;\n                    east = t;\n                    break;\n                case 1:\n                    top = e;\n                    east = 5 - t;\n                    break;\n                case 2:\n                    top = f;\n                    front = 5 - t;\n                    break;\n                case 3:\n                    top = 5 - f;\n                    front = t;\n            }\n        }\n    }\n\n    public class Main {\n\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int[] line = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n            int N = line[0], M = line[1], x = line[2], y = line[3], K = line[4];\n\n            Dice dice = new Dice(N, M, K);\n\n            for (int i = 0; i < N; i++) dice.map[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\n            dice.commands = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\n            dice.game(x, y);\n\n            br.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 다른 구현은 모두 쉬웠는데, `rollDice()` 구현이 제일 어려웠다.\n  - 원래는 명령어가 주어지면, 전역으로 가지고 있는 bottom의 정보를 업데이트하는 방식을 사용하려 했는데, 아무리 생각해도 안되는 경우가 많은 것 같아 게시판을 참고했다.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/14499"},{"excerpt":"🧷 Spring AOP란 Aspect Oriented Programming의 약자인 AOP는 관점 지향 프로그래밍이라고 한다. 관점 지향이란, 어떤 로직을 기준으로 핵심적인 관점과 부가적인 관점으로 나누어서 보고, 그 관점을 기준으로 각각을 모듈화하는 것이다. 예를 들면 핵심적인 관점은 우리가 적용하고자 하는 핵심 비즈니스 로직이고, 부가적인 관점은 해심…","fields":{"slug":"/[Algorithm]AOP/"},"frontmatter":{"date":"March 25, 2022","title":"💬 AOP","tags":["개발상식","Java","AOP"]},"rawMarkdownBody":"\n## 🧷 Spring AOP란 \n**Aspect Oriented Programming**의 약자인 AOP는 **관점 지향 프로그래밍**이라고 한다. 관점 지향이란, 어떤 로직을 기준으로 핵심적인 관점과 부가적인 관점으로 나누어서 보고, 그 관점을 기준으로 각각을 모듈화하는 것이다.\n- 예를 들면 핵심적인 관점은 우리가 적용하고자 하는 핵심 비즈니스 로직이고, 부가적인 관점은 해심 로직을 실행하기 위해 행해지는 DB 연결, 로깅, 파일 입출력 등이 있다.\n\n코드를 부분적으로 나눠서 모듈화하게 되면, 소스 코드 상에서 다른 부분에 계속 반복적으로 쓰이는 코드들을 발견할 수 있는데, 이를 **흩어진 관심사**(Crosscutting Concerns)라 한다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Ft1.daumcdn.net%2Fcfile%2Ftistory%2F994AA3335C1B8C9D28\" width=\"60%\">\n\n- 위 그림에서 AspectX, Y, Z는 서로 다른 객체에서 반복적으로 사용되고 있는 것을 확인할 수 있다.\n- 이렇게 **흩어진 관심사를 Aspect로 모듈화하고 핵심적인 비즈니스 로직에서 분리하여 재사용**하겠다는 것이 AOP의 목표이다.\n\n### 🗝 AOP 주요 개념\n**Aspect**\n- 흩어진 관심사를 모듈화한 것으로, 주로 부가 기능을 모듈화한다.\n\n**Target**\n- Aspect를 적용하는 곳이다.(클래스, 메소드, ...)\n\n**Advice**\n- 실질적으로 어떤 일을 해야할 지에 대한 것으로, 실질적인 부가 기능을 담은 구현체라고 할 수 있다.\n\n**JoinPoint**\n- Advice가 적용될 위치로, 메소드 진입 시점, 생성자 호출 시점, 필드에서 값을 꺼내올 때 등 다양한 시점에 적용 가능하다.\n\n**PointCut**\n- JoinPoint의 상세한 스펙을 정의한 것으로, 'A란 메소드의 진입 시점에 호출할 것'과 같이 더 구체적으로 Advice가 실행될 지점을 정할 수 있다.\n\n### 🗝 Spring AOP 특징\n- 프록시 패턴 기반의 AOP 구현체, 프록시 객체(대리 객체, 가짜 객체)를 쓰는 이유는 접근 제어 및 부가 기능의 추가를 위해서이다. \n- 스프링 빈에만 AOP를 적용 가능하다.\n- 모든 AOP 기능을 제공하는 것이 아닌 스프링 IoC(Inversion Of Control)와 연동하여 엔터프라이즈 애플리케이션에서 가장 흔한 문제(중복 코드, 프록시 클래스 작성의 번거로움, 객체들 간 관계 복잡도 증가, ...)에 대한 해결책을 지원하는 것이 목적이다.\n\n> **스프링 IoC(Inversion Of Control)**\n> - 제어의 역전이라는 의미로, 메소드나 객체의 호출 작업을 개발자가 결정하는 것이 아닌 외부에서 결정되는 것을 의미한다.\n>> 추후에 DI와 함께 정리해야겠다.\n\n### 🗝 @AOP\n`@AOP` 를 사용하기 위해서는 아래 의존성의 추가가 필요하다,\n```xml\nimplementation 'org.springframework.boot:spring-boot-starter-aop'\n```\n\n## 📕 참고\n- [스프링 AOP ( Aspect Oriented Programming )](https://engkimbs.tistory.com/746)"},{"excerpt":"🧷 TDD란 무엇인가 Test-Driven Development는 매우 짧은 개발 사이클의 반복에 의존하는 소프트웨어 개발 프로세스이다.  개발자는 요구되는 기능에 대한 자동화된 테스트 케이스를 작성하고, 해당 테스트를 통과하는 가장 간단한 코드를 작성한다.  테스트를 통과하는 코드를 작성하고 상황에 맞게 리팩토링하는 과정을 거친다.  \"말 그대로 테스트…","fields":{"slug":"/[면접]TDD/"},"frontmatter":{"date":"March 25, 2022","title":"💬 Test-Driven Development","tags":["개발상식","TDD"]},"rawMarkdownBody":"\n## 🧷 TDD란 무엇인가\nTest-Driven Development는 **매우 짧은 개발 사이클의 반복에 의존하는 소프트웨어 개발 프로세스**이다. \n- 개발자는 요구되는 기능에 대한 자동화된 테스트 케이스를 작성하고, 해당 테스트를 통과하는 **가장 간단한 코드를 작성**한다. \n- 테스트를 통과하는 코드를 작성하고 상황에 맞게 **리팩토링**하는 과정을 거친다. \n- **\"말 그대로 테스트가 코드 작성을 주도하는 개발방식\"** 이다.\n\n처음 이 개념을 접한 것은 \"소프트웨어 설계\"라는 강의에서이다. 이때는 \"개발\"에 대해 많이 생각해보지도 않았고, 큰 프로젝트 또한 진행해보지 않아 그냥 그런 개념이 있나보다 싶었다. 점차 프로젝트를 진행하면서, 개발 프로세스에는 어떤 것이 있고 실무에서는 어떠한 방식으로 협업을 진행하는가에 대해 알게 되면서 TDD를 다시 생각해보게 되었다.\n\n## TDD 개발 주기\n<img src=\"https://i0.wp.com/hanamon.kr/wp-content/uploads/2021/04/TDD-%E1%84%80%E1%85%A2%E1%84%87%E1%85%A1%E1%86%AF%E1%84%8C%E1%85%AE%E1%84%80%E1%85%B5.png?w=1024&ssl=1\" width=\"60%\">\n\n1. RED : 실패하는 테스트 코드를 먼저 작성한다.\n2. GREEN : 테스트 코드를 성공시키기 위한 실제 코드를 작성한다.\n3. BLUE : 중복 코드 제거, 일반화 등의 리팩토링을 수행한다.\n\n## 🧷 Test 추가\nTDD(테스트 주도형 개발)에서는 새로운 기능을 추가하기 전 \"테스트를 먼저 작성\"한다. 테스트의 작성을 위해서는 해당 기능의 요구사항과 명세에 대한 분명한 이해가 수반되어야 한다. \n- 이는 개발자가 코드를 작성하기 전에 보다 요구사항에 집중할 수 있도록 돕는다. → **테스트 주도 개발이 주는 이점**\n\n## 🧷 Run all tests and see if new one fails\n어떤 기능을 추가하면 잘 작덩하던 기존 기능이 제대로 동작하지 않는 경우가 발생할 수 있다. 하지만 더 위험한 것은 개발자가 이를 인지하지 못하는 경우다. \n- 이것이 테스트 코드를 작성하는 이유다.\n- 기능 추가마다 테스트 코드를 작성함으로써, 새 기능이 제대로 동작함과 동시에, 기존 기능들이 정상 동작하는지 확인할 수 있다.\n\n## 🧷 Refactor code\n'좋은 코드' 를 작성하는 것은 쉽지 않다. 고려해야 할 사항이 너무 많기 때문이다.\n- 가독성을 위한 코딩 컨벤션\n- 네이밍 컨벤션\n- 확장성 고려\n- 비즈니스 로직 고려\n- 예외 처리\n등이 있다.\n물론 코드량이 적다면 모두 신경쓰며 작성하는 것이 가능하지만 많은 버그들을 디버깅하는 과정에서 코드는 점차 더러워지게 된다.\n\n이러한 이유로 코드량이 방대해지면서, **리팩토링**이 필요해지게 된다. 그리고 이때, 테스트 코드가 그 중심을 잡아줄 수 있다.\n- 코드량이 많은 함수를 여러 함수로 나누는 과정에서 해당 기능이 오작동하는지 간단히 테스트를 돌려봄으로써, 정상동작한다는 근거를 얻을 수 있다.\n- 결과적으로 **리팩토링 속도를 증가**시키고 **코드의 퀄리티 또한 향상**시킬 수 있다.\n  - 보다 객체지향적이고, 확장성이 좋은 코드, 재설계의 시간을 단축시킬 수 있는 코드, 디버깅 시간이 단축되는 코드를 탄생시킬 수 있다.\n\n이렇게 보면, TDD를 왜 사용하지 않는가에 대해 의문을 품을 수 있다.\n\n### 🗝 코드 생산성에 문제가 있지는 않나?\n분명 코드량이 늘어나긴 한다. 비즈니스 로직, 각종 코드 디자인에도 많은 시간이 소요되는데, 추가로 테스트 코드까지 작성하기에는, 빠른 생산성이 요구되는 시점에서 큰 걸림돌이 될 수 있다.\n\n### 🗝 테스트 코드를 작성하기가 쉬운가?\n> 프로젝트를 진행하면서 가장 많이 생각했던 질문이다. <br/>\n> 스프링 입문 강의를 보고 따라하면서 작성했을 때는 생각보다 되게 간단하게 구현한 로직을 테스트하는 줄 알았는데, 프로젝트를 진행하면서 테스트 코드를 작성하려 하니 어디서부터 어떻게 시작해야 할 지도 감이 잡히지 않았고, 내가 구현한 로직의 어떤 것을 최종적으로 확인해야 하는지 파악하는 것이 너무 어려웠다.\n\n이 또한 큰 걸림돌이 된다. 진입 장벽이 존재한다는 것이다. 어떠한 부분을 테스트해야할 지, 어떻게 테스트해야할 지, 여러 테스트 프레임워크 중 어떤 것이 우리의 서비스와 맞는지 등 여러 부분에 대한 학습이 필요하고 적응하는데 시간이 걸린다.\n\n### 🗝 모든 상황에 대해서 테스트 코드를 작성할 수 있는가? 작성해야 하는가?\n항상 생각지도 못한 예외 케이스는 발생할 수 있다. 만약 테스트를 반드시 해야 하는 부분에 대한 테스트 코드를 작성하는데 어려움이 있다면 주객전도되는 상황이 발생할 수 있다. 즉, 실제 코드가 중심이 되어야 하는데, 테스트를 위해 실제 코드의 구조를 바꿔야 하나 싶은 상황인 것이다.\n\n하지만 모든 코드에 대해 테스트 코드를 작성할 수 없으며, 그럴 필요도 없다. 또한 테스트 코드를 작성한다고 해서, 버그가 발생하지 않는 것도 아니다. \n\n💡 애초에 TDD는 100% coverage와 100% 무결성을 주장하지 않았다.\n\n## 📕 참고\n- [TDD](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Development_common_sense#tdd)\n- [TDD 개발주기](https://hanamon.kr/tdd%EB%9E%80-%ED%85%8C%EC%8A%A4%ED%8A%B8-%EC%A3%BC%EB%8F%84-%EA%B0%9C%EB%B0%9C/)"},{"excerpt":"문제 계단 오르기 게임은 계단 아래 시작점부터 계단 꼭대기에 위치한 도착점까지 가는 게임이다. 아래와 같이 각각의 계단에는 일정한 점수가 쓰여 있는데 계단을 밟으면 그 계단에 쓰여 있는 점수를 얻게 된다. 예를 들어 아래와 같이 시작점에서부터 첫 번째, 두 번째, 네 번째, 여섯 번째 계단을 밟아 도착점에 도달하면 총 점수는 10 + 20 + 25 + 2…","fields":{"slug":"/[BOJ]2579/"},"frontmatter":{"date":"March 24, 2022","title":"👩‍💻 2579. 계단 오르기","tags":["DP"]},"rawMarkdownBody":"\n## 문제\n\n계단 오르기 게임은 계단 아래 시작점부터 계단 꼭대기에 위치한 도착점까지 가는 게임이다. 아래와 같이 각각의 계단에는 일정한 점수가 쓰여 있는데 계단을 밟으면 그 계단에 쓰여 있는 점수를 얻게 된다.\n\n<img src=\"https://upload.acmicpc.net/7177ea45-aa8d-4724-b256-7b84832c9b97/-/preview/\" width=\"50%\">\n\n예를 들어 아래와 같이 시작점에서부터 첫 번째, 두 번째, 네 번째, 여섯 번째 계단을 밟아 도착점에 도달하면 총 점수는 10 + 20 + 25 + 20 = 75점이 된다.\n\n<img src=\"https://upload.acmicpc.net/f00b6121-1c25-492e-9bc0-d96377c586b0/-/preview/\" width=\"50%\">\n\n계단 오르는 데는 다음과 같은 규칙이 있다.\n\n1. 계단은 한 번에 한 계단씩 또는 두 계단씩 오를 수 있다. 즉, 한 계단을 밟으면서 이어서 다음 계단이나, 다음 다음 계단으로 오를 수 있다.\n2. 연속된 세 개의 계단을 모두 밟아서는 안 된다. 단, 시작점은 계단에 포함되지 않는다.\n3. 마지막 도착 계단은 반드시 밟아야 한다.\n\n따라서 첫 번째 계단을 밟고 이어 두 번째 계단이나, 세 번째 계단으로 오를 수 있다. 하지만, 첫 번째 계단을 밟고 이어 네 번째 계단으로 올라가거나, 첫 번째, 두 번째, 세 번째 계단을 연속해서 모두 밟을 수는 없다.\n\n각 계단에 쓰여 있는 점수가 주어질 때 이 게임에서 얻을 수 있는 총 점수의 최댓값을 구하는 프로그램을 작성하시오.\n\n### 입력\n- 입력의 첫째 줄에 계단의 개수가 주어진다.\n- 둘째 줄부터 한 줄에 하나씩 제일 아래에 놓인 계단부터 순서대로 각 계단에 쓰여 있는 점수가 주어진다. 계단의 개수는 300이하의 자연수이고, 계단에 쓰여 있는 점수는 10,000이하의 자연수이다.\n\n### 출력\n- 첫째 줄에 계단 오르기 게임에서 얻을 수 있는 총 점수의 최댓값을 출력한다.\n\n### 📍 **Logic**\n\n```java\nstatic int climbStairs() {...}\n```\n\n- `dp[x][0]` 은 x층 계단까지 가는데 연속된 계단이 1개인 경우의 최대 점수이고, `dp[x][1]` 은 연속된 계단이 2개인 경우의 최대 점수이다.\n- BOTTOM UP방식으로 모든 계단에 대한 최대 점수를 구한 이후, 마지막 계단에서 두 경우 중 최댓값을 반환한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\" data-language=\"java\">\n\n      import java.io.BufferedReader;\n      import java.io.IOException;\n      import java.io.InputStreamReader;\n\n      public class Main {\n          static int[] costs;\n          static int[][] dp;\n          static int N;\n\n          public static void main(String[] args) throws IOException {\n              BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n              N = Integer.parseInt(br.readLine());\n              costs = new int[N];\n              dp = new int[N][2];\n\n              for (int i = 0; i < N; i++) costs[i] = Integer.parseInt(br.readLine());\n\n              System.out.println(climbStairs());\n\n              br.close();\n          }\n\n          static int climbStairs() {\n              if (N == 1) return costs[0];\n\n              dp[0][0] = dp[0][1] = costs[0];\n              dp[1][0] = costs[1];\n              dp[1][1] = dp[0][0] + costs[1];\n\n              for (int i = 2; i < N; i++) {\n                  dp[i][0] = Math.max(dp[i - 2][0], dp[i - 2][1]) + costs[i];\n                  dp[i][1] = Math.max(dp[i - 1][0], dp[i - 2][1]) + costs[i];\n              }\n\n              return Math.max(dp[N - 1][0], dp[N - 1][1]);\n          }\n      }\n  </div>\n</details>\n\n### ✏️ **Review**\n\n- 예전에 C++로 풀려다가 못 풀어서 포기했던 문제였다. 이번 학기 고문해 시간에 DP 과제에서 이 문제보다 조건이 더 적은 문제를 만나서, 과제를 해결한 이후 다시 풀어보았다.\n- \"연속된 세 개의 계단을 밟아선 안된다\"는 조건 때문에 고민했고, `dp[][0]` , `dp[][1]` 을 이용해서 해당 계단까지 연속된 계단이 1개인 경우와 2개인 경우를 나누어 구현했다.\n- DP는 실버인데도 꼬이면 머리가 너무 아프다.\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/2579"},{"excerpt":"🧷 \"00\" 지향 절차 지향 : C언어 객체 지향 : Java, Python, C# 등 아주 틀린 말은 아니다. '지향' 이라는 것은 단순히 하나의 패러다임이지, C언어는 무조건 절차적으로만, Java는 무조건 객체지향으로만 프로그래밍해야한다는 것은 아니다. 사실 어떤 언어건 간에 절차적 프로그래밍이 가능하다. 모든 코드는 '절차적인 틀'이 있어서, 절차…","fields":{"slug":"/[면접]객체 지향과 절차적 프로그래밍/"},"frontmatter":{"date":"March 24, 2022","title":"💬 객체 지향과 절차적 프로그래밍","tags":["개발상식","Java","OOP","PP"]},"rawMarkdownBody":"\n## 🧷 \"00\" 지향\n- 절차 지향 : C언어\n- 객체 지향 : Java, Python, C# 등\n\n아주 틀린 말은 아니다. '지향' 이라는 것은 단순히 하나의 패러다임이지, C언어는 무조건 절차적으로만, Java는 무조건 객체지향으로만 프로그래밍해야한다는 것은 아니다.\n\n사실 어떤 언어건 간에 절차적 프로그래밍이 가능하다. 모든 코드는 '절차적인 틀'이 있어서, 절차지향이 아닌 **절차적 프로그래밍**이라는 말이 더 맞는 말이다.\n\n> 📌 **\"OO\" 지향이란 코딩하는 방식 또는 방법론의 차이이지 특정 언어가 특정 지향만 지원한다는 것은 아니다.**\n\n또한, 객체지향 프로그래밍과 절차적 프로그래밍은 서로 반대 개념이 아닌, 상이한 개념일 뿐이다. \n- 절차적 프로그래밍은 **'데이터를 중심으로 함수'**를 만들어 쓰는 방식이고, \n- 객체 지향 프로그래밍은 **'데이터와 기능(함수)들을 묶어 하나의 객체'**를 만들어 쓰는 방식이다.\n\n그렇다면, 왜 일반적으로 절차적 언어와 객체 지향 언어를 나누어 생각할까? \n- 이는 언어가 지원하는 기능과 특징에 있다. 구분하는 방법은 많지만 대개 아래의 기준을 충족한다면, 객체 지향적 성격이 강하다.\n\n1. **캡슐화, 다형성, 클래스 상속을 지원하는가?**\n2. **데이터 접근 제한을 걸 수 있는가?**\n\n### 🗝 프로그래밍 패러다임의 짧막한 역사\n과거에는 지금과 같은 큰 규모와 소프트웨어가 필요하지 않았다. 따라서, 과거의 프로그래밍 패러다임의 중심에는 컴퓨터가 있었다. 컴퓨터가 사고하는대로 프로그래밍하는 것이다. 하지만 점점 소프트웨어의 발전 속도가 빨라지면서, 코드도 복잡해지기 시작했다. 처음엔 C, 코볼, 포트란과 같은 절차적 언어로 구현되었던 알고리즘이 점점 더 복잡해져 결국 코드가 사람이 읽으면서 로직을 이해할 수 없게 되는 '스파게티 코드' 문제점이 대두되었다.\n- 그래서 이 문제를 해결하기 위해 등장한 패러다임이 **'객체 지향적 프로그래밍'**이다.\n- 이는 인간 중심적 프로그래밍으로, 현실 세계를 프로그래밍으로 옮겨와 프로그래밍하는 것이다. \n\n따라서, **절차적 프로그래밍이 객체 지향적 특징을 가져오게 된다.**\n- 예를 들어 C++이 있다.\n- 이는 C언어 기반에 상속, 캡슐화 등을 지원한다.\n- 하지만 그렇다고 해도, 하나의 패러다임을 따를 뿐 이를 객체 지향적 언어라고는 하지 않는다.\n\n---\n\n## 🧷 절차적 프로그래밍(Procedure Programming)\n단어 그대로 '절차적'으로 코드를 구성한다는 의미이다. \n- 데이터에 대한 순서를 파악하고, 필요한 기능을 함수로 만들어 절차적으로 진행하는 방법이다.\n\n### 🗝 장단점\n**절차적 프로그래밍의 장점**\n- 객체나 클래스의 생성 없이 바로 프로그램을 작성할 수 있다.\n- 필요한 기능을 함수로 만들어 사용하기에 같은 코드를 호출하여 사용할 수 있다.\n- 프로그램의 흐름 이해가 쉽다.\n\n**절차적 프로그래밍의 단점**\n- 코드들이 유기적으로 연결되어 있어, 새로운 기능이나 데이터의 추가가 어렵다.\n- 코드 재사용률이 떨어져 프로젝트 개발 비용과 시간이 늘어날 수 있다.\n- 디버깅이 어렵다.\n\n---\n\n## 🧷 객체 지향 프로그래밍(Object Oriented Programming)\n특정한 개념의 함수와 자료형을 함께 묶어 관리하기 위해 탄생한 개념이다. 기능들을 묶어 하나의 객체로 생성한다. 이때 추상화라는 개념을 이용해 현실 세계의 사물들을 객체라고 보고 그 객체로부터 개발하고자 하는 애플리케이션에 필요한 특징들을 뽑아와 프로그래밍에 사용한다.\n\n### 🗝 객체 지향의 특징\n1. 추상화\n: 필요로 하는 속성이나 행동을 추출하는 작업\n- 추상적인 개념에 의존하여 설계해야 유연함을 갖출 수 있다.\n- 즉, 세부적인 사물들의 공통적인 특징을 파악한 후 하나의 집합으로 만들어내는 것이다.\n\n2. 캡슐화\n: 낮은 결합도를 유지할 수 있도록 설계하는 것\n- 한 곳에서 변화가 일어나도 다른 곳에 미치는 영향을 최소화시키는 것이다. (객체가 내부적으로 어떻게 구현하는지 감춤으로써)\n\n> **결합도**\n> : 어떤 기능을 실행할 때 다른 클래스나 모듈에 얼마나 의존적인가를 나타낸다.\n\n객체들간의 의존도가 높아지게 되면, 굳이 객체 지향으로 설계하는 의미가 없어지게 되므로, 독립적으로 만들어진 객체들 간의 의존도가 최대한 낮게 만들어야 한다.\n\n요구사항 변경에 대처하는 좋은 설계 방법은 객체 안의 모듈 간의 요소가 밀접한 관련이 있는 것으로 구성하여 **응집도를 높이고 결합도를 줄여야 한다.**\n- 이때, 정보 은닉을 사용하여 높은 응집도를 가지면서 낮은 결합도를 가지도록 한다.\n- `private` 접근자를 사용해 외부에서 접근할 필요가 없는 것들의 접근을 제한한다.\n\n3. 상속\n일반화 관계(Generalization)라고도 하며, 여러 개체들이 지닌 공통된 특성을 부각시켜 하나의 개념이나 법칙으로 성립하는 과정이다.\n\n상속은 또 다른 캡슐화다. **자식 클래스를 외부로부터 은닉하는 캡슐화의 일종**이라고 할 수 있다.\n\n상속 관계에서는 단순히 하나의 클래스 안에서 속성 및 연산들의 캡슐화에 한정되지 않는다. \n- 즉, 자식 클래스 자체를 캡슐화하여 외부에 은닉하는 것으로 확장되는 것이다.\n\n이를 통해 외부에선 이러한 클래스들에 영향 받지 않고 개발을 이어갈 수 있다는 장점이 있다.\n\n하지만 **상속을 재사용하는 경우**에는 아래와 같은 단점들이 있다.\n- 상위 클래스(부모 클래스)의 변경이 어려워진다.\n  - 부모 클래스에 의존하는 자식 클래스가 많은 경우, 부모 클래스의 변경은 아래 모든 자식 클래스들의 변경을 요구하게 된다.\n- 불필요한 클래스가 증가할 수 있다.\n  - 유사 기능 확장 시, 필요 이상의 불필요한 클래스를 만들어야 하는 상황이 발생할 수 있다.\n- 상속이 잘못 사용될 수 있다.\n  - 같은 종류가 아닌 클래스의 구현을 재사용하기 위해 상속을 받게 되면, 문제가 발생할 수 있다.\n\n해결책으로는 **객체 조립(Composition)**이 있다.\n- 필드에서 다른 객체를 참조하는 방식으로 구현된다.\n- 상속에 비해 비교적 런타임 구조가 복잡해지고 구현이 어려운 단점이 있지만, 변경 시 유연함을 확보하는 장점이 매우 크다.\n\n> 따라서, 같은 종류가 아닌 클래스를 상속하고 싶은 경우에는 객체 조립을 우선적으로 적용하는 것이 좋다.\n\n상속은 **IS-A 관계가 성립할 때**나 **재사용 관점이 아닌, 기능의 확장 관점일 때** 사용하도록 한다.\n\n4. 다형성(Polymorphism)\n서로 다른 클래스의 객체가 같은 메시지를 받았을 때 각자의 방식으로 동작하는 능력이다. 객체 지향의 핵심과도 같다.\n- 부모 클래스의 메소드를 자식 클래스가 **Overriding**해서 자신의 역할에 맞게 활용하는 것이다.\n\n다형성은 상속과 함께 활용할 때 효율적인데, 코드를 간결하게 해주고, 유연함을 갖추게 해준다.\n- 상속 관계에 있으면, 새로운 자식 클래스가 추가되어도 부모 클래스의 함수만을 참조해오면 되기에 다른 클래스의 영향을 받지 않는다.\n\n### 🗝 장단점\n**객체 지향 프로그래밍의 장점**\n- 모듈화, 캡슐화로 인해 디버깅과 유지보수에 용이하다.\n- 객체 자체가 하나의 프로그램이기 때문에 재사용성이 높다. 자주 사용되는 로직을 라이브러리로 만들어 재사용할 수 있다.\n- 객체 지향적이기 때문에 현실 세계와의 유사성에 의해 코드 이해가 쉽다.\n\n**객체 지향 프로그래밍의 단점**\n- 대부분 많은 양의 메모리를 사용하고, 속도가 느린 경향이 있다.\n- 현실 세계와의 유사성에 의한 코드 이해도를 증가시키기 위해 설계에 많은 시간이 투자된다.\n- 객체가 상태를 갖는다. 변수가 존재하고 이 변수를 통해 객체가 예측할 수 없는 상태를 갖게 되어 애플리케이션 내부에서 버그를 발생시킨다. 이러한 이유로 **함수형 패러다임**이 주목받고 있다.\n\n### 🗝 객체 지향적 설계 원칙\n1. **SRP(Single Responsibility Principle)** : 단일 책임 원칙\n    - 클래스는 단 하나의 책임을 가져야 하며 클래스를 변경하는 이유는 단 하나의 이유이어야 한다.\n\n2. **OCP(Open-Closed Principle)** : 개방-폐쇄 원칙\n    - 확장에는 열려 있어야 하고 변경에는 닫혀 있어야 한다.\n    - 기능을 변경하거나 확장할 수 있으면서, 그 기능을 사용하는 코드는 수정하지 않아야 한다.\n\n3. **LSP(Liskov Substitution Principle)** : 리스코프 치환 원칙\n    - 상위 타입의 객체를 하위 타입의 객체로 치환해도 상위 타입을 사용하는 프로그램은 정상적으로 동작해야 한다.\n    - 상속 관계가 아닌 클래스들을 상속 관계로 설정하면, 이 원칙이 위배된다.\n\n4. **ISP(Interface Segregation Principle)** : 인터페이스 분리 원칙\n    - 인터페이스는 그 인터페이스를 사용하는 클라이언트를 기준으로 분리해야 한다.\n\n5. **DIP(Dependency Inversion Principle)** : 의존 역전 원칙\n    - 고수준 모듈은 저수준 모듈의 구현에 의존해서는 안된다.\n    - 저수준 모듈이 고수준 모듈에서 정의한 추상 타입에 의존해야 하고, 저수준 모듈이 변경되어도 고수준 모듈은 변경할 필요가 없어야 한다.\n\n## 📕 참고\n- [객체지향(OOP)과 절차적 프로그래밍(PP)](https://st-lab.tistory.com/151)\n- [Object Oriented Programming](https://github.com/JaeYeopHan/Interview_Question_for_Beginner/tree/master/Development_common_sense)\n- [객체지향 프로그래밍](https://gyoogle.dev/blog/computer-science/software-engineering/Object-Oriented%20Programming.html)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. JPA의 데이터 타입 분류 - 엔티티 타입 & 값 타입 엔티티 타입 :  로 정의하는 객체 식별자를 통해서 지속 추적이 가능 값 타입 :  ,  ,  처럼 단순히 값으로 사용하는 자바 기본 타입이나 객체 식별자가 없고 숫자나 문자 같은 속성만 존재해 추적이 불가능 기본…","fields":{"slug":"/[JPA]9/"},"frontmatter":{"date":"March 23, 2022","title":"📚 9. 값 타입","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> **JPA의 데이터 타입 분류** - **엔티티 타입 & 값 타입**\n> - **엔티티 타입** : `@Entity` 로 정의하는 객체\n>   - 식별자를 통해서 지속 추적이 가능\n> - **값 타입** : `int` , `Integer` , `String` 처럼 단순히 값으로 사용하는 자바 기본 타입이나 객체\n>   - 식별자가 없고 숫자나 문자 같은 속성만 존재해 추적이 불가능\n>   - 기본값 타입, 임베디드 타입, 컬렉션 값 타입 존재\n\n## 💫 기본값 타입\n`String` , `int` 처럼 자바가 제공하는 기본 데이터 타입이다. \n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  private String name;\n  private int age;\n  ...\n\n}\n```\n- `Member` 에서 `String` , `int` 가 값 타입이다. 해당 엔티티는 `id` 라는 식별자 값도 가지고 생명주기도 있지만, 값 타입인 `name` , `age` 속성은 식별자 값도 없고 생명주기도 회원 엔티티에 의존한다.\n  - 따라서 회원 엔티티 인스턴스를 제거하면 해당 속성들도 제거된다.\n- 값 타입은 공유하면 안된다. 다른 회원의 이름을 변경한다고 해서 나의 이름까지 변경되는 예시를 생각해보면 이해가 빠를 것이다.\n\n---\n\n## 💫 임베디드 타입(복합 값 타입)\nJPA에서 사용자가 직접 정의한 값 타입이다. 중요한 것은 이 타입 또한 `int` , `String` 처럼 값 타입이라는 것이다. \n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  private Long id;\n  private String name;\n\n  // 근무 기간\n  @Temporal (TemporalType.DATE) java.util.Date startDate;\n  @Temporal (TemporalType.DATE) java.util.Date endDate;\n\n  // 집 주소 표현\n  private String city;\n  private String street;\n  private String zipcode;\n  ...\n\n}\n```\n- \"회원 엔티티는 이름, 근무 시작일, 근무 종료일, 주소 도시, 주소 번지, 주소 우편번호를 가진다.\" 라고 이 엔티티를 설명할 수 있다.\n- 이는 단순히 정보를 풀어둔 것이고, 좀 더 명확하게 설명하자면, \"회원 엔티티는 이름, 근무 기간, 집 주소를 가진다.\" 라고 할 수 있다.\n- 회원이 상세한 데이터를 그대로 가지고 있는 것은 **객체지향적이지 않으며, 응집력만 떨어뜨린다.**\n  - 대신, **근무 기간, 주소 같은 타입**이 있다면 더 명확한 코드를 작성할 수 있을 것이다.\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  private Long id;\n  private String name;\n\n  // 근무 기간\n  @Embedded Period workPeriod;\n\n  // 집 주소 표현\n  @Embedded Address homeAddress;\n  ...\n\n}\n```\n\n```java\n@Embeddable\npublic class Period {\n\n  @Temporal (TemporalType.DATE) java.util.Date startDate;\n  @Temporal (TemporalType.DATE) java.util.Date endDate;\n\n  public boolean isWork(Date date) {\n    // ... 값 타입을 위한 메소드 정의\n  }\n}\n```\n\n```java\n@Embeddable\npublic class Address {\n\n  @Column(name = \"city\")\n  private String city;\n  private String street;\n  private String zipcode;\n  ...\n\n}\n```\n- `startDate` , `endDate` 를 합해 `Period`(기간) 클래스를 생성한다.\n- `city` , `street` , `zipcode` 를 합해 `Address`(주소) 클래스를 생성한다.\n- 이렇게 새로 정의한 값 타입들은 **재사용**할 수 있고, **응집도도 아주 높다.** 또한 `Period.isWork()` 처럼 해당 값 타입만 사용하는 의미 있는 메소드도 만들 수 있다.\n\n임베디드 타입의 사용을 위해서는 아래 2가지 annotation가 필요한데, 둘 중 하나는 생략 가능하다.\n- `@Embeddable` : 값 타입을 정의하는 곳에 표시\n- `@Embedded` : 값 타입을 사용하는 곳에 표시\n\n**임베디드 타입은 기본 생성자가 필수**적이다.\n\n> 임베디드 타입을 포함한 모든 값 타입은 **엔티티의 생명주기에 의존**하므로 엔티티와 임베디드 타입의 관계를 UML로 표현하면 **컴포지션 관계**가 된다. (UML에서 임베디드 값 타입은 기본 타입처럼 단순하게 표현)\n  \n### ➰ 임베디드 타입과 테이블 매핑\n임베디드 타입은 엔티티의 값일 뿐이다. 따라서 **값이 속한 엔티티의 테이블에 매핑**한다.\n\n임베디드 타입 덕분에 객체와 테이블을 아주 세밀하게(fine-grained) 매핑하는 것이 가능하다. 잘 설계한 ORM 애플리케이션은 매핑한 테이블의 수보다 클래스의 수가 더 많다. \n\n### ➰ 임베디드 타입과 연관관계\n임베디드 타입은 값 타입을 포함하거나 엔티티를 참조할 수 있다. 아래 예제로 포함 및 참조 관계를 확인할 수 있다.\n\n> 엔티티는 공유될 수 있으므로 참조한다고 표현하고, 값 타입은 특정 주인에 소속되고 논리적인 개념상 공유되지 않으므로 포함한다고 표현한다.\n\n```java\n@Entity\npublic class Member {\n\n  @Embedded Address address; // 임베디드 타입 포함\n  @Embedded PhoneNumber phoneNumber; // 임베디드 타입 포함\n  ...\n\n}\n\n@Embeddable\npublic class Address {\n  String street;\n  String city;\n  String state; \n  @Embedded Zipcode zipcode; // 임베디드 타입 포함\n}\n\n@Embeddable\npublic class Zipcode {\n  String zip;\n  String plusFour;\n}\n\n@Embeddable\npublic class PhoneNumber {\n  String areaCode;\n  String localNumber;\n  @ManyToOne PhoneServiceProvider provider; // 엔티티 참조\n  ...\n\n}\n\n@Entity\npublic class PhoneServiceProvider {\n  @Id String name;\n  ...\n\n}\n```\n\n### ➰ `@AttributeOverride`: 속성 재정의\n임베디드 타입에 정의한 매핑정보를 재정의하려면 엔티티에 `@AttributeOverride` 를 사용하면 된다. 예를 들어 회원에게 주소가 하나 더 필요한 경우는 어떻게 해야 할까?\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  private Long id;\n  private String name;\n\n  @Embedded Address homeAddress;\n  @Embedded Address companyAddress;\n\n}\n```\n- 집 주소에 회사 주소를 하나 더 추가했다. 이렇게 되면, 테이블에 매핑하는 컬럼명이 중복되는 문제가 발생한다. (`city` , `street` , `zipcode` 가 2개씩 생성)\n- 이때 매핑정보 재정의가 필요하다.\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  private Long id;\n  private String name;\n\n  @Embedded Address homeAddress;\n\n  @Embedded \n  @AttributeOverrides({\n    @AttributeOverride(name = \"city\", column = @Column(name = \"COMPANY_CITY\")),\n    @AttrubuteOverride(name = \"street\", column = @Column(name = \"COMPANY_STREET\")),\n    @AttrubuteOverride(name = \"zipcode\", column = @Column(name = \"COMPANY_ZIPCODE\"))\n  })\n  Address companyAddress;\n\n}\n```\n- 테이블 매핑 시 `@Column` 의 `name` 속성에 지정한 값으로 매핑된다.\n\n### ➰ 임베디드 타입과 `null`\n임베디드 타입이 `null` 이면 매핑한 컬럼 값은 모두 `null` 이 된다.\n\n```java\nmember.setAddress(null);\nem.persist(member);\n```\n- 회원 테이블의 주소와 관련된 `CITY` , `STREET` , `ZIPCODE` 컬럼 값은 모두 `null` 이 된다.\n\n---\n\n## 💫 값 타입과 불변 객체\n값 타입은 단순하고 안전하게 다룰 수 있어야 한다.\n\n### ➰ 값 타입 공유 참조\n임베디드 타입 같은 값 타입을 여러 엔티티에서 공유하면 위험하다. 어떤 문제가 있는지 살펴본다.\n\n```java\nmember1.setHomeAddress(new Address(\"OldCity\"));\nAddress address = member1.getHomeAddress();\n\naddress.setCity(\"NewCity\"); // 회원1의 address 값을 공유해서 사용\nmember2.setHomeAddress(address);\n```\n- 회원2에 새로운 주소를 할당하려고 회원1의 주소를 그대로 참조해서 사용한다.\n  - 실행하면, 회원2의 주소만 \"NewCity\"로 변경되지 않고, 회원1의 주소도 함께 변경된다.\n  - 이는 **같은 `address` 인스턴스를 참조하기 때문**이다.\n  - 영속성 컨텍스트는 회원1, 2 모두 `city` 속성이 변경된 것으로 판단해 각각에 대한 UPDATE SQL을 실행한다.\n- 이러한 부작용(side effect)을 막기 위해서는 **값을 복사해서 사용하는 방식**을 취해야 한다.\n\n### ➰ 값 타입 복사\n값 타입의 실제 인스턴스인 값을 공유하는 것은 위험하다. 대신 값(인스턴스)을 복사해서 사용해야 한다.\n\n```java\nmember1.setHomeAddress(new Address(\"OldCity\"));\nAddress address = member1.getHomeAddress();\n\n// 회원1의 address 값을 복사해서 새로운 newAddress 값을 생성\nAddress newAddress = address.clone();\n\nnewAddress.setCity(\"NewCity\");\nmember2.setHomeAddress(newAddress);\n```\n- 회원2에 새로운 주소 할당을 위해 회원1의 `address` 값을 복사한다. 이때 `clone()` 메소드를 사용한다.\n  - 이 메소드는 자신을 복사해서 반환하도록 구현했다.\n  - 영속성 컨텍스트는 회원2의 주소만 변경된 것으로 판단해 회원2에 대한 UPDATE SQL을 실행한다.\n\n항상 값을 복사해서 사용하면 공유 참조로 인한 부작용을 피할 수 있다. \n- 문제는 임베디드 타입처럼 직접 정의한 값 타입은 **자바의 기본 타입이 아니라 객체 타입이라는 것**이다.\n- 자바는 기본 타입에 값을 대입하면 **값을 복사해서 전달**한다.\n\n```java\nAddress a = new Address(\"Old\");\nAddress b = a; // 객체 타입은 항상 참조 값을 전달!\nb.setCity(\"New\");\n```\n- `Address b = a` 에서 **`a` 가 참조하는 인스턴스의 참조 값을 `b` 에 넘겨준다**. 따라서 같은 인스턴스를 공유 참조하게 된다.\n- 따라서 `b.city` 만 변경하려는 코드가 공유 참조의 부작용으로 인해 `a.city` 값도 변경시킨다.\n\n물론 객체 대입마다 인스턴스를 복사, 대입하는 방법을 취하면 공유 참조를 피할 수는 있지만 문제는 **복사하지 않고 원본의 참조 값을 직접 넘기는 것을 막을 방법이 없다**는 것이다.\n- 자바 기본 타입이면 값을 복사해서 넘기고, 객체면 참조를 넘긴다.\n\n**객체의 공유 참조는 피할 수 없다.**\n- 근본적이고 가장 단순한 방법은 객체의 값을 수정하지 못하게 막으면 된다.\n- 예를 들어 **`setter` 를 모두 제거**한다.\n\n### ➰ 불변 객체\n값 타입은 부작용 걱정 없이 사용할 수 있어야 한다. 객체를 불변하게 만들면, **값을 절대 수정할 수 없어 부작용을 원천 차단**할 수 있다.\n- 따라서 **값 타입은 가능한 한 불변 객체(immutable Obejct)로 설계**해야 한다.\n\n불변 객체의 값은 조회할 수는 있지만 수정할 수는 없다. 불변 객체도 결국은 객체이기에, **인스턴스의 참조 값 공유를 피할 수 없다.**\n- 하지만 참조 값을 공유한다한들, 수정이 불가능하므로 부작용은 발생하지 않는다.\n\n불변 객체를 구현하는 가장 간단한 방법은 생성자로만 값을 설정하고, 수정자(`setter`)를 만들지 않으면 된다.\n- 따라서 값을 수정해야 하는 경우는 **새로운 객체를 생성해서 사용**해야 한다.\n\n> **불변이라는 작은 제약으로 부작용이라는 큰 재앙을 막을 수 있다.**\n\n--- \n\n## 💫 값 타입의 비교\n자바가 제공하는 객체 비교는 2가지다.\n- **동일성(identity) 비교**: 인스턴스의 참조 값을 비교, == 사용\n- **동등성(equivalence) 비교**: 인스턴스의 값을 비교, `equals()` 사용\n\n```java\nint a = 10;\nint b = 10;\n\nAddress a = new Address(\"서울시\", \"종로구\", \"1번지\");\nAddress b = new Address(\"서울시\", \"종로구\", \"1번지\");\n```\n\n`Address` 값 타입을 **동일성 비교**\n- 둘은 서로 다른 인스턴스이므로 결과는 거짓\n- 하지만 값 타입은 비록 인스턴스가 달라도 그 안에 값이 같으면 같은 것으로 봐야 한다.\n- 따라서 값 타입 비교 시에는 `a.equals(b)` 로 **동등성 비교**를 해야 한다.\n  - 물론 `Address` 의 `equals()` 메소드를 재정의해야 한다. 보통 모든 필드의 값을 비교하도록 구현한다.\n\n> 자바에서 `equals()` 를 재정의하면 `hashCode()` 도 함께 재정의하는 것이 안전하다. 그렇지 않으면 해시를 사용하는 컬렉션이 정상 동작하지 않는다.\n\n---\n\n## 💫 값 타입 컬렉션\n하나 이상의 값 타입을 저장할 때 사용하는 타입이다.\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @Embedded\n  private Address homeAddress;\n\n  @ElementCollection\n  @CollectionTable(name = \"FAVORITE_FOODS\",\n      joinColumns = @JoinColumn(name = \"MEMBER_ID\"))\n  @Column(name = \"FOOD_NAME\")\n  private Set<String> favoriteFoods = new HashSet<>();\n\n  @ElementCollection\n  @CollectionTable(name = \"ADDRESS\",\n      joinColumns = @JoinColumn(name = \"MEMBER_ID\"))\n  @Column(name = \"FOOD_NAME\")\n  private List<Address> addressHistory = new ArrayList<>();\n  ...\n\n}\n\n@Embeddable\npublic class Address {\n\n  @Column\n  private String city;\n  private String street;\n  private String zipcode;\n  ...\n\n}\n```\n- 값 타입 컬렉션을 사용하는 `favoriteFoods` , `addressHistory` 에 `@ElementCollection` 을 지정했다. \n- `favoriteFoods` 는 기본값 타입인 `String` 을 컬렉션으로 가진다.\n  - 이를 데이터베이스 테이블로 매핑해야 하는데, **관계형 데이터베이스의 테이블은 컬럼 안에 컬렉션을 포함할 수 없다.**\n  - 따라서 별도의 테이블을 추가하고, `@CollectionTable` 을 사용해 추가한 테이블을 매핑해야 한다.\n  - 그리고 `favoriteFoods` 처럼 값으로 사용되는 컬럼이 하나면 `@Column` 을 사용해 컬럼명을 지정할 수 있다.\n- `addressHistory` 는 임베디드 타입인 `Address` 를 컬렉션으로 가진다. \n  - 마찬가지로 별도의 테이블을 사용하고, 테이블 매핑정보는 `@AttributeOverride` 를 사용해서 재정의 가능하다.\n\n> `@CollectionTable` 을 생략하면, 기본값을 사용해서 매핑한다. <br/>\n> 기본값 : {엔티티이름}_{컬렉션 속성 이름}\n\n### ➰ 값 타입 컬렉션 사용\n```java\nMember member = new Member();\n\n// 임베디드 값 타입\nmember.setHomeAddress(new Address(\"통영\", \"몽돌해수욕장\", \"660-123\"));\n\n// 기본값 타입 컬렉션\nmember.getFavoriteFoods().add(\"짬뽕\");\nmember.getFavoriteFoods().add(\"짜장\");\nmember.getFavoriteFoods().add(\"탕수육\");\n\n// 임베디드 값 타입 컬렉션\nmember.getAddressHistory().add(new Address(\"서울\", \"강남\", \"123-123\"));\nmember.getAddressHistory().add(new Address(\"서울\", \"강북\", \"000-000\"));\n\nem.persist(member);\n```\n- 마지막에 `member` 엔티티만 영속화했다.\n  - JPA는 이때 **`member` 엔티티의 값 타입도 함께 저장**한다. 실제 실행되는 INSERT SQL은 총 6번이다.\n    - `member` 1번, `mebmer.homeAddress` (회원 테이블을 저장하는 SQL에 포함) , `member.favoriteFoods` 3번, `member.addressHistory` 2번\n\n> 값 타입 컬렉션은 영속성 전이(CASCADE) + 고아 객체 제거(ORPHAN REMOVE) 기능을 필수로 가진다.\n\n값 타입 컬렉션도 조회할 때 페치 전략을 선택할 수 있는데, `LAZY` 가 기본이다. (이전 장에서 언급, 너무 많은 데이터 로딩)\n- 지연 로딩으로 모두 설정했다는 가정 하에 아래 코드의 실행 결과를 확인한다.\n\n값 타입 컬렉션의 조회 과정이다.\n```java\nMember member = em.find(Member.class, 1L);\n\nAddress homeAddress = member.getHomeAddress();\n\nSet<String> favoriteFoods = member.getFavoriteFoods();\n\nfor (String favoriteFood : favoriteFoods) {\n  System.out.println(\"favoriteFood = \" + favoriteFood);\n}\n\nList<Address> addressHistory = member.getAddressHistory();\n\naddressHistory.get(0);\n```\n1. `member` : 회원만 조회한다. 이때 임베디드 값 타입인 `homeAddress` 도 함께 조회한다. SELECT SQL을 1번 호출한다.\n2. `member.homeAddress` : 1번에서 이미 조회되었다.\n3. `member.favoriteFoods` : `LAZY` 로 설정해서 실제 컬렉션 사용 시에 SELECT SQL을 1번 호출한다.\n4. `member.addressHistory` : `LAZY` 로 설정해서 실제 컬렉션 사용 시에 SELECT SQL을 1번 호출한다.\n\n값 타입 컬렉션의 수정과정이다.\n```java\nMember member = em.find(Member.class, 1L);\n\nmember.setHomeAddress(new Address(\"새로운도시\", \"신도시1\", \"123456\"));\n\nSet<String> favoriteFoods = member.getFavoriteFoods();\nfavoriteFoods.remove(\"탕수육\");\nfavoriteFoods.add(\"치킨\");\n\nList<Address> addressHistory = member.getAddressHistory();\naddressHistory.remove(new Address(\"서울\", \"기존 주소\", \"123-123\"));\naddressHistory.add(new Address(\"새로운도시\", \"새로운 주소\", \"123-456\"));\n```\n1. 임베디드 값 타입 수정 : `homeAddress` 임베디드 값 타입은 `MEMBER` 테이블과 매핑했으므로 테이블만 UPDATE한다. 사실 엔티티를 수정하는 것과 같다.\n2. 기본값 타입 컬렉션 수정 : 자바의 `String` 타입은 수정할 수 없다. 따라서 기존의 값을 삭제하고 새로운 값을 추가한다.\n3. 임베디드 값 타입 컬렉션 수정 : 값 타입은 불변해야 한다. 따라서 컬렉션에서 기존 주소를 삭제하고 새로운 주소를 등록했다. (값 타입은 `equals()` , `hashCode()` 구현 필수)\n\n### ➰ 값 타입 컬렉션의 제약사항\n엔티티와 달리 값 타입은 식별자가 없어 값을 변경해버리면 데이터베이스에서 저장된 원본 데이터를 찾기가 어렵다. 특정 엔티티 하나에 소속된 값 타입은 값이 변경되어도 자신이 소속된 엔티티를 데이터베이스에서 찾고 값을 변경하면 된다.\n- 문제는 값 타입 컬렉션이다. **별도의 테이블에 보관**되어 원본 데이터를 찾기 어렵다.\n\n이런 문제로 인해 JPA 구현체들은 값 타입 컬렉션에 변경이 발생하면, **값 타입 컬렉션이 매핑된 테이블의 연관된 모든 데이터를 삭제**하고, **현재 값 타입 컬렉션 객체에 있는 모든 값을 데이터베이스에 다시 저장**한다.\n\n따라서 실무에서는 값 타입 컬렉션이 매핑된 테이블에 데이터가 많다면 값 타입 컬렉션 대신에 **일대다 관계를 고려**해야 한다! (SQL을 너무 많이 실행)\n- 추가로, 영속성 전이 + 고아 객체 제거 기능을 적용해 값 타입 컬렉션처럼 사용한다.\n\n또다른 제약사항으로는, 값 타입 컬렉션을 매핑하는 테이블은 모든 컬럼을 묶어서 기본 키를 구성해야 한다.\n- 따라서 데이터베이스 기본 키 제약 조건으로 인해 컬럼에 `null` 을 입력할 수 없고, 같은 값을 중복해서 저장할 수 없다는 제약도 따라붙는다.\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 프록시와 즉시로딩, 지연로딩\n: 프록시를 사용하면 연관된 객체를 처음부터 데이터베이스에서 조회하는 것이 아니라, 실제 사용하는 시점에 조회할 수 있다. 영속성 전이와 고아 객체\n: JPA는 연관된 객체를 함께 저장하거나 삭제할 수 있는 영속성 전이와, 고아 객체 제거라…","fields":{"slug":"/[JPA]8/"},"frontmatter":{"date":"March 21, 2022","title":"📚 8. 프록시와 연관관계 관리","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> **프록시와 즉시로딩, 지연로딩**<br/>\n> : 프록시를 사용하면 연관된 객체를 처음부터 데이터베이스에서 조회하는 것이 아니라, 실제 사용하는 시점에 조회할 수 있다.\n> \n> **영속성 전이와 고아 객체**<br/>\n> : JPA는 연관된 객체를 함께 저장하거나 삭제할 수 있는 영속성 전이와, 고아 객체 제거라는 편리한 기능을 제공한다.\n\n## 💫 프록시\n엔티티 조회 시 연관관된 엔티티들이 항상 사용되지는 않는다. 비즈니스 로직에 따라 사용될 때도 있고, 그렇지 않은 때도 존재한다.\n\n```java\n// 회원과 팀 정보를 모두 출력하는 로직\npublic void printUserAndTeam(String memberId) {\n  Member member = em.find(Member.class, memberId);\n  Team team = member.getTeam();\n  System.out.println(\"회원 이름: \" + member.getUsername());\n  System.out.println(\"소속팀 이름: \" + team.getName());\n}\n```\n\n```java\n// 회원 정보만 출력하는 로직\npublic void printUser(String memberId) {\n  Member member = em.find(Member.class, memberId);\n  System.out.println(\"회원 이름: \" + member.getUsername());\n}\n```\n- `Member` 는 `Team` 에 대해 다대일 관계를 가지고 있다. (회원 엔티티에 `Team` 이 저장)\n- `printUser()` 는 회원 엔티티만 사용하기에 `em.find()` 로 회원 엔티티 조회 시 회원과 연관된 팀 엔티티까지 조회하는 것은 효율적이지 않다. (어차피 사용하지 않음)\n  \nJPA는 이런 문제 해결을 위해 엔티티가 실제 사용될 때까지 데이터베이스 조회를 지연하는 방법을 제공하는데, 이를 **지연 로딩**이라 한다.\n- 즉, `team.getTeam()` 처럼 팀 엔티티의 값을 **실제 사용하는 시점에** 데이터베이스에서 팀 엔티티에 필요한 데이터를 조회하는 것이다.\n- 지연 로딩을 위해서는 실제 엔티티 객체 대신에 **데이터베이스 조회를 지연할 수 있는 가짜 객체**가 필요한데, 이를 **프록시 객체**라 한다.\n\n> JPA 표준 명세는 지연 로딩의 구현 방법을 JPA 구현체에 위임했다. 따라서 아래의 내용들은 Hibernate 구현체에 대한 내용이다. Hibernate는 프록시를 사용하는 방법과 바이트코드를 수정하는 2가지 방법으로 지연 로딩을 지원한다.\n\n### ➰ 프록시 기초\nJPA에서 식별자로 엔티티 하나를 조회할 때는 `em.find()` 를 사용한다. 이 메소드는 영속성 컨텍스트에 엔티티가 없으면 데이터베이스를 조회한다. 엔티티를 직접 조회하면, 조회한 엔티티를 **실제 사용하든, 사용하지 않든 데이터베이스를 조회**하게 된다.\n- 엔티티를 실제 사용하는 시점까지 데이터베이스 조회를 미루고 싶다면 `em.getReference()` 메소드를 사용하면 된다.\n\n```java\nMember member = em.getReference(Member.class, \"member1\");\n```\n- 이 메소드를 호출할 때 JPA는 데이터베이스를 조회하지 않고 실제 엔티티 객체도 생성하지 않는다. \n- 대신 **데이터베이스 접근을 위임한 프록시 객체를 반환**한다.\n\n**프록시의 특징**<br/>\n프록시 클래스는 실제 클래스(실제 Entity 클래스)를 상속 받아 만들어지므로 **실제 클래스와 겉 모양이 같다.** 따라서 사용하는 입장에서는 이것이 진짜 객체인지 프록시 객체인지 구분하지 않고 사용하면 된다.\n\n프록시 객체는 실제 객체에 대한 참조(`target`)를 보관한다. 그리고 프록시 객체의 메소드를 호출하면 **프록시 객체는 실제 객체의 메소드를 호출**한다.\n\n**프록시 객체의 초기화**<br/>\n프록시 객체는 `member.getName()` 같이 실제 사용될 때 데이터베이스를 조회해 실제 엔티티 객체를 생성하는데, 이를 프록시 객체의 초기화라 한다. 아래는 프록시 객체의 초기화 과정이다.\n\n```java\n// MemberProxy 반환\nMember member = em.getReference(Member.class, \"id1\");\nmember.getName(); // getName();\n```\n\n```java\nclass MemberProxy extends Member {\n\tMember target = null;\n\n\tpublic String getName() {\n\t\tif (target == null) {\n\n\t\t\t// 초기화 요청\n\t\t\t// DB 조회\n\t\t\t// 실제 엔티티 생성 및 참조 보관\n\t\t\tthis.target = ...;\n\t\t}\n\n\t\t// target.getName();\n\t\treturn target.getName();\n\t}\n}\n```\n1. 프록시 객체에 `member.getName()` 을 호출해 실제 데이터를 조회한다.\n2. 프록시 객체는 실제 엔티티가 생성되어 있지 않으면(`if(target == null)`), 영속성 컨텍스트에 실제 엔티티 생성을 요청하는데 이를 **초기화**라 한다. \n3. 영속성 컨텍스트는 데이터베이스를 조회해 실제 엔티티 객체를 생성한다.\n4. 프록시 객체는 생성된 실제 엔티티 객체의 참조를 `Member target` 멤버변수에 보관한다.\n5. 프록시 객체는 실제 엔티티 객체의 `getName()` 을 호출해 결과를 반환한다.\n\n**프록시의 특징**<br/>\n- 프록시 객체는 첫 사용 시에만 초기화된다.\n- 프록시 객체를 초기화하는 것이 실제 엔티티로 바뀌는 것이 아니다. 프록시 객체가 초기화되면 프록시 객체를 통해 실제 엔티티에 접근할 수 있다.\n- 프록시 객체는 원본 엔티티를 상속받은 객체이므로 타입 체크 시에 주의해서 사용해야 한다.\n- 영속성 컨텍스트에 찾는 엔티티가 이미 있으면 데이터베이스를 조회할 필요가 없기에, `em.getReference()` 를 호출해도 프록시가 아닌 실제 엔티티를 반환한다.\n- 초기화는 영속성 컨텍스트의 도움을 받아야 가능하다. 따라서 준영속 상태의 프록시를 초기화하면 Hibernate는 `org.hibernate.LazyInitializationException` 예외를 발생시킨다.\n\n**준영속 상태와 초기화**<br/>\n준영속 상태와 초기화에 관련된 코드이다.\n```java\nMember member = em.getReference(Member.class, \"id1\");\ntransaction.commit();\nem.close(); // 영속성 컨텍스트 종료\n\nmember.getName(); // 준영속 상태인데 초기화를 시도!\n```\n- 이미 영속성 컨텍스트를 종료해서, `member` 는 준영속 상태이다.\n- `getName()` 을 호출하면 프록시를 초기화해야 하는데 영속성 컨텍스트가 없으므로 실제 엔티티를 조회할 수 없다. 따라서 **예외가 발생**한다.\n\n### ➰ 프록시와 식별자\n엔티티를 프록시로 조회할 때, 식별자 값을 파라미터로 전달하는데 **프록시 객체는 이 식별자 값을 보관**한다.\n\n```java\nTeam team = em.getReference(Team.class, \"team1\"); // 식별자 보관\nteam.getId(); // 초기화되지 않음\n```\n- 프록시 객체는 식별자 값을 이미 가지고 있으므로, 식별자 값을 조회하는 `getId()` 를 호출해도 프록시를 초기화를 하지 않는다.\n  - 단 **엔티티 접근 방식을 `@Access(AccessType.PROPERTY)` 로 설정한 경우에만** 초기화하지 않는다.\n\n> 엔티티 접근 방식을 `@Access(AccessType.FIELD)` 로 설정하면 JPA는 `getId()` 메소드가 `id` 만 조회하는 메소드인지 다른 필드까지 활용해 어떤 일을 하는 메소드인지 알지 못해 프록시 객체를 초기화한다.\n\n> **`@Access`**<br/>\n> : JPA가 엔티티에 접근하는 방식을 지정하는 annotation\n> - 필드 방식\n> \t- 필드에 직접 접근, `private` 이어도 접근\n> - 프로퍼티 방식\n> \t- 접근자(Getter)를 이용해 접근 \n\n프록시는 다음처럼 연관관계를 설정할 때 유용하게 사용할 수 있다.\n\n```java\nMember member = em.find(Member.class, \"member1\");\nTeam team = em.getReference(Team.class, \"team1\"); // SQL을 실행하지 않음\nmember.setTeam(team);\n```\n- 연관관계 설정 시에는 식별자 값만 사용하기에 프록시를 사용하면 데이터베이스 접근 횟수를 줄일 수 있다. (원래 같으면 INSERT하고, UPDATE하는 방식)\n- 참고로 연관관계 설정 시에는 엔티티 접근 방식을 필드로 설정해도 프록시를 초기화하지 않는다.\n\n### ➰ 프록시 확인\nJPA가 제공하는 `PersistenceUnitUtil.isLoaded(Object entity)` 메소드를 사용하면 프록시 인스턴스의 초기화 여부를 확인할 수 있다.\n- 아직 초기화되지 않았다면 `false` 를 반환한다.\n- 이미 초기화되었거나 프록시 인스턴스가 아니면 `true` 를 반환한다.\n\n```java\nboolean isLoad = em.getEntityManagerFactory()\n\t\t\t\t\t.getPersistenceUnitUtil().isLoaded(entity);\n// or, boolean isLoad = emf.getPersistenceUnitUtil().isLoaded(entity);\nSystem.out.println(\"isLoad = \" + isLoad); // 초기화 여부 확인\n```\n\n조회한 엔티티가 진짜 엔티티인지 프록시로 조회한 것인지 확인하려면 **클래스명을 직접 출력**해보면 된다. 출력된 클래스명 뒤에 `...javassist...` 라 되어있다면 프록시이다. (`member.getClass().getName()`)\n\n> **프록시 강제 초기화**<br/>\n> hibernate의 `initialize()` 메소드로 강제 초기화가 가능하다.\n> ```java\n> org.hibernate.Hibernate.initialize(order.getMember());\n> ```\n\n---\n\n## 💫 즉시 로딩과 지연 로딩\n프록시 객체는 **주로 연관된 데이터를 지연 로딩할 때 사용**한다.\n\n회원 엔티티를 조회할 때, 연관된 팀 엔티티도 함께 데이터베이스에서 조회하는 것이 좋을까? 아니면 팀 엔티티는 실제 사용하는 시점에 데이터베이스에서 조회하는 것이 좋을까?\n- JPA는 개발자가 연관된 엔티티의 조회 시점을 선택할 수 있도록 아래 두 가지 방법을 제공한다.\n- 즉시 로딩 : 엔티티를 조회할 때 연관된 엔티티도 함께 조회한다.\n  - `em.find()` 호출 시 연관된 엔티티도 함께 조회한다.\n  - 설정 방법: **`@ManyToOne(fetch = FetchType.EAGER)`**\n- 지연 로딩 : 연관된 엔티티를 실제 사용할 때 조회한다.\n  - `member.getTeam().getName()` 처럼 연관된 엔티티를 실제 사용하는 시점에 JPA가 SQL을 호출해서 조회한다.\n  - 설정 방법 : **`@ManyToOne(fetch = FetchType.LAZY)`**\n\n### ➰ 즉시 로딩\n```java\n@Entity\npublic class Member {\n\n  //...\n  @ManyToOe(fetch = FetchType.EAGER)\n  @JoinColumn(name = \"TEAM_ID\")\n  private Team team;\n  // ...\n}\n```\n\n```java\nMember member = em.find(Member.class, \"member1\");\nTeam team = member.getTeam(); // 객체그래프 탐색\n```\n- 즉시 로딩을 실행하는 코드이다. 회원을 조회할 때 팀 정보도 즉시 로딩한다.\n- 회원과 팀 두 테이블을 조회해야 하므로, 쿼리를 2번 실행할 것 같지만, 대부분의 JPA 구현체는 **즉시 로딩 최적화를 위해 가등하면 조인 쿼리를 사용**한다.\n  - 즉 위 예제에서는 회원과 팀을 조인해서 쿼리 한 번으로 두 엔티티를 모두 조회한다.\n\n> **NULL 제약 조건과 JPA 조인 전략**<br/>\n> 즉시 로딩 실행 SQL에서 외부 조인(LEFT OUTER JOIN)을 사용했다. 외래 키에 `NULL` 값을 허용해서 팀에 소속되지 않은 회원이 있을 수 있게 했다. 이 경우에는 팀에 소속되지 않은 회원과 팀의 내부 조인이 불가능하다. \n> \n> 내부 조인보다는 외부 조인이 성능과 최적화에서 유리한데, 내부 조인을 사용하려면 어떻게 해야 할까? \n> - 외래 키에 NOT NULL 제약 조건을 설정하면 값이 있는 것을 보장한다. 즉 내부 조인이 가능해진다.\n> - JPA에도 이런 사실을 알려주기 위해 `@JoinColumn(nullable = false)` 를 설정해 이 외래 키는 NULL 값을 허용하지 않는다는 것을 명시한다. 이를 통해 JPA는 외부 조인 대신 내부 조인을 사용한다.\n> 정리! <br/>\n> JPA는 선택적 관계면 외부 조인을 사용하고, 필수 관계면 내부 조인을 사용한다.\n\n### ➰ 지연 로딩\n```java\n@Entity\npublic class Member {\n  // ...\n  @ManyToOne(fetch = FetchType.LAZY)\n  @JoinColumn(name = \"TEAM_ID\")\n  private Team team;\n  // ...\n}\n```\n\n```java\nMember member = em.find(Member.class, \"member1\");\nTeam team = member.getTeam(); // 객체그래프 탐색\nteam.getName(); // 팀 객체 실제 사용\n```\n- 지연 로딩 설정으로, `em.find()` 호출 시 회원만 조회하고 팀은 조회하지 않는다. \n- 대신 조회한 회원의 `team` 멤버 변수에 프록시 객체를 넣어둔다. (`Team team = member.getTeam()`)\n- 반환된 팀 객체는 프록시 객체다. 이는 실 사용때까지 데이터 로딩을 미루기에 지연 로딩이라 한다. 그리고 실제 데이터가 필요한 순간 데이터베이스를 조회해서 프록시 객체를 초기화한다.\n\n> 조회 대상이 영속성 컨텍스트에 이미 있으면 프록시 객체를 사용할 이유가 없다. 곧바로 실 객체를 사용한다.\n\n### ➰ 즉시 로딩, 지연 로딩 정리\n사실 상황에 따라 너무 다르다. \n- 지연 로딩 : 연관된 엔티티를 프록시로 조회한다. 프록시를 실제 사용할 때 초기화하면서 데이터베이스를 조회한다.\n- 즉시 로딩 : 연관된 엔티티를 즉시 조회한다. Hibernate는 가능하면 SQL 조인을 사용해 한 번에 조회한다.\n\n---\n\n## 💫 지연 로딩 활용\n지연 로딩을 활용하는 예시이다. 아래와 같은 요구사항이 있다.\n- 회원은 팀 하나에만 소속할 수 있다. (N:1)\n- 회원은 여러 주문내역을 가진다. (1:N)\n- 주문내역은 상품정보를 가진다. (N:1)\n\n그리고 이를 분석하면 다음과 같은 결과를 얻을 수 있다.\n- 회원과 연관된 팀은 자주 함께 사용되었다. 따라서 이를 **즉시 로딩**으로 설정했다.\n- 회원과 연관된 주문내역은 가끔 사용되었다. 따라서 **지연 로딩**으로 설정했다.\n- 주문내역과 연관된 상품정보는 자주 함께 사용되었다. 따라서 **즉시 로딩**으로 설정했다.\n\n```java\n@Entity\npublic class Member {\n\n  @Id\n  private String id;\n  private String username;\n  private Integer age;\n\n  @ManyToOne(fetch = FetchType.EAGER)\n  private Team team;\n\n  @OneToMany(mappedBy = \"member\", fetch = FetchType.LAZY)\n  private List<Order> orders;\n}\n```\n\n### ➰ 프록시와 컬렉션 래퍼\n지연 로딩으로 설정하면 실제 엔티티 대신 프록시 객체를 사용한다. 프록시 객체는 실제 자신이 사용될 때까지 데이터베이스를 조회하지 않는다. Hibernate는 엔티티를 영속 상태로 만들 때 엔티티에 컬렉션이 있으면 컬렉션을 추적하고 관리할 목적으로 원본 컬렉션을 Hibernate가 제공하는 내장 컬렉션으로 변경하는데, 이를 **컬렉션 래퍼**라 한다. \n- 출력 결과에서 컬랙션 래퍼인 `org.hibernate.collection.internal.PersistentBag` 이 반환되는 것을 확인할 수 있다.\n\n엔티티를 지연 로딩하면, 프록시 객체를 사용해 지연 로딩을 수행하지만 주문내역과 같은 **컬렉션은 컬렉션 래퍼가 지연 로딩을 처리**해준다. 컬렉션은 컬렉션에서 실제 데이터를 조회할 때 데이터베이스를 조회해서 초기화한다.\n\n### ➰ JPA 기본 페치 전략\n`fetch` 속성의 기본 설정값은 다음과 같다.\n- `@ManyToOne` , `@OneToOne` :  즉시 로딩\n- `@OneToMany` , `@ManyToMany` : 지연 로딩\n\nJPA의 기본 페치 전략은, 연관된 엔티티가 하나면 즉시 로딩, 컬렉션이면 지연 로딩을 사용한다.\n- 컬렉션을 로딩하는 것은 비용이 많이 들고 잘못하면 너무 많은 데이터를 로딩할 수 있기 때문이다. \n\n> 모든 연관관계에 지연 로딩을 사용하는 것을 추천한다. 개발이 어느 정도 완료되었다면 필요한 곳에만 즉시 로딩을 사용하도록 최적화한다. (SQL을 직접 사용하게 되면 이러한 유연성을 가지기 어렵다.)\n\n### ➰ 컬렉션에 FetchType.EAGER 사용 시 주의점\n즉시 로딩사용 시의 주의점이다.\n- **컬렉션을 하나 이상 즉시 로딩하는 것은 권장하지 않는다.**\n  - 컬렉션과 조인한다는 것은 데이터베이스 테이블로 본다면 일대다 조인이다. 이는 결과 데이터가 다 쪽에 있는 수만큼 증가하게 된다.\n  - 문제는 서로 다른 컬렉션을 2개 이상 조인할 때 발생하는데, 결과 데이터가 너무 많아져 애플리케이션의 성능 저하를 발생시킬 수 있다. JPA는 이렇게 조회된 결과를 메모리에서 필터링해 반환한다. \n- **컬렉션 즉시 로딩은 항상 외부 조인을 사용한다.**\n  - 다대일 관계인 회원 테이블과 팀 테이블 조인 시 회원 테이블의 외래 키에 `not null` 제약조건을 걸어두면 모든 회원은 팀에 소속되어 항상 내부 조인을 사용해도 된다.\n  - 반대로 팀 테이블에서 회원 테이블로 일대다 관계를 조인할 때 회원이 한 명도 없는 팀을 내부 조인하면 팀까지 조회되지 않는 문제가 발생하고 이는 제약조건으로 막을 수 없는 문제이므로 외부 조인을 사용해야 한다.\n\n> `FetchType.EAGER` 설정과 조인 전략\n> - `@ManyToOne` , `@OneToOne`\n>   - `(optional = false)` : 내부 조인\n>   - `(optional = true)` : 외부 조인\n> - `@OneToMany` , `@ManyToMany`\n>   - `(optional = false)` : 외부 조인\n>   - `(optional = true)` : 외부 조인\n\n--- \n\n## 💫 영속성 전이: CASCADE\n**특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶으면** 영속성 전이 기능(Transitive Persistence)을 사용하면 된다.\n- JPA는 `CASCADE` 옵션으로 이를 제공한다.\n- 영속성 전이를 사용해 부모 엔티티를 저장할 때 자식 엔티티도 함께 저장할 수 있다.\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @OneToMany(mappedBy = \"parent\")\n  private List<Child> children = new ArrayList<>();\n  ...\n\n}\n```\n\n```java\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @ManyToOne\n  private Parent parent;\n  ...\n  \n}\n```\n- 부모 엔티티가 여러 자식 엔티티를 가지고 있고, 부모 1명에 자식 2명을 저장한다면 아래와 같은 코드를 작성할 수 있다.\n\n```java\nprivate static void saveNoCascade(EntityManager em) {\n\n  // 부모 저장\n  Parent parent = new Parent;\n  em.persist(parent);\n\n  // 1번 자식 저장\n  Child child1 = new Child();\n  child1.setParent(parent);\n  parent.getChildren().add(child1);\n  em.persist(child1);\n\n  // 2번 자식 저장\n  Child child2 = new Child();\n  child2.setParent(parent);\n  parent.getChildren().add(child2);\n  em.persist(child2);\n}\n```\n- **JPA에서 엔티티를 저장할 때 연관된 모든 엔티티는 영속 상태**여야 한다. 위 예제에서도 부모 엔티티를 먼저 영속 상태로 만들고, 이후 자식 엔티티들을 영속 상태로 만든다.\n- 이런 경우 영속성 전이를 사용해 부모만 영속 상태로 만들면, 연관된 자식까지 한 번에 영속 상태로 만들 수 있다.\n\n### ➰ 영속성 전이: 저장\n영속성 전이를 활성화하는 `CASCADE` 옵션을 적용해보자.\n```java\n@Entity\npublic class Parent {\n  ...\n  @OneToMany(mappedBy = \"parent\", cascade = CascadeType.PERSIST)\n  private List<Child> children = new ArrayList<>();\n  ...\n\n}\n```\n- 부모를 영속화할 때 연관된 자식들도 함께 영속화하라는 옵션을 설정했다.\n\n```java\nprivate static void saveNoCascade(EntityManager em) {\n\n  Child child1 = new Child();\n  Child child2 = new Child();\n\n  // 부모 저장\n  Parent parent = new Parent;\n  child1.setParent(parent);\n  child2.setParent(parent);\n  parent.getChildren().add(child1);\n  parent.getChildren().add(child2);\n\n  em.persist(parent);\n}\n```\n- 간편하게 부모와 자식 엔티티를 한 번에 영속화하는 것을 확인할 수 있다.\n\n> 영속성 전이는 연관관계를 매핑하는 것과는 관련이 없고, 단지 **엔티티를 영속화할 때 연관된 엔티티도 같이 영속화하는 편리한 기능**일 뿐이다.\n\n### ➰ 영속성 전이: 삭제\n영속화한 부모 자식 엔티티를 모두 제거하려면 각각의 엔티티를 하나씩 제거해야 한다.\n\n```java\nParent findParent = em.find(Parent.class, 1L);\nChild findChild1 = em.find(Child.class, 1L);\nChild findChild2 = em.find(Child.class, 2L);\n\nem.remove(findChild1);\nem.remove(findChild2);\nem.remove(findParent);\n```\n\n영속성 전이는 엔티티 삭제 시에도 사용할 수 있다. `CascadeType.REMOVE` 로 설정하고 부모 엔티티만 삭제하면 연관된 자식 엔티티도 함께 삭제된다.\n- 모든 엔티티 제거를 위한 DELETE SQL을 실행하고, 삭제 순서는 외래 키 제약조건을 고려해 자식 먼저 삭제한 다음 부모를 삭제한다.\n- 만약 위 설정 없이 부모 엔티티만 삭제하면, 자식 엔티티는 제거되지 않았지만 외래 키 제약조건으로 인해, 데이터베이스에서 외래 키 무결성 제약조건이 깨지는 예외가 발생한다.\n\n### ➰ CASCADE의 종류\n```java\npublic enum CascadeType {\n  ALL, \n  PERSIST,\n  MERGE,\n  REMOVE,\n  REFRESH,\n  DETACH\n}\n```\n\n> 참고로 `PERSIST` , `REMOVE` 는 `em.persist()` , `em.remove()` 실행 즉시 전이가 발생하는 것이 아니라 플러시 호출 시 전이가 발생한다.\n\n---\n\n## 💫 고아 객체\nJPA는 **부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제**하는 기능을 제공하는데 이를 고아 객체(ORPHAN) 제거라 한다. \n- 이 기능으로 부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거해 자식 엔티티가 자동으로 삭제되도록 해보자.\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @OneToMany(mappedBy = \"parent\", orphanRemoval = true)\n  private List<Child> Children = new ArrayList<>();\n  ...\n\n}\n```\n- 고아 객체 제거 기능 활성화를 명시하는 설정을 추가했다. 이제 컬렉션에서 제거한 엔티티는 자동으로 삭제된다.\n- 컬렉션에서 첫 번째 자식을 제거하면, DELETE SQL을 실행하여 데이터베이스의 데이터 또한 삭제한다.\n- 이 기능은 영속성 컨텍스트를 플러시할 때 적용되므로 플러시 시점에 DELETE SQL이 실행된다.\n  - 모든 자식 엔티티 제거를 위해서는 컬렉션을 비우기만 하면 된다.\n\n고아 객체 제거는 **참조가 제거된 엔티티는 다른 곳에서 참조하지 않는 고아 객체로 보고, 삭제하는 기능**이다.\n- 따라서 참조하는 곳이 하나일때만 사용해야 한다! (즉, 특정 엔티티가 개인 소유하는 엔티티만 사용)\n- 따라서 `orphanRemoval` 속성은 `@OneToOne` , `@OneToMany` 로 일대~인 경우만 사용할 수 있다.\n- 추가 기능이 있는데, 부모를 제거하면 자식은 자연스레 고아가 된다. 따라서 **부모를 제거하면 자식도 함께 제거하는 기능**이 있다. 이는 `CascadeType.REMOVE` 를 설정한 것과 동일하다.\n---\n\n## 💫 영속성 전이 + 고아 객체, 생명주기\n`CascadeType.ALL` + `orphanRemoval = true` 를 동시에 사용하면 어떻게 될까? \n- 일반적으로 엔티티는 `em.persist()` 를 통해 영속화되고, `em.remove()` 를 통해 제거된다. 이는 엔티티 스스로 생명주기를 관리한다는 뜻이다. \n- 그런데 두 옵션을 모두 설정하면 부모 엔티티를 통해 자식의 생명주기를 관리할 수 있다.\n\n```java\n// 자식을 저장하려면 부모에 등록만 하면 된다. (CASCADE)\nParent parent = em.find(Parent.class, parentId);\nparent.setChild(child1);\n```\n\n```java\n// 자식을 삭제하려면 부모에서 제겅하면 된다. (orphanRemoval)\nParent parent = em.find(Parent.class, parentId);\nparent.getChildren().remove(removeObject);\n```\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"문제 재현시의 시장 구재현은 지난 몇 년간 게리맨더링을 통해서 자신의 당에게 유리하게 선거구를 획정했다. 견제할 권력이 없어진 구재현은 권력을 매우 부당하게 행사했고, 심지어는 시의 이름도 재현시로 변경했다. 이번 선거에서는 최대한 공평하게 선거구를 획정하려고 한다. 재현시는 크기가 N×N인 격자로 나타낼 수 있다. 격자의 각 칸은 구역을 의미하고, r행…","fields":{"slug":"/[BOJ]17779/"},"frontmatter":{"date":"March 20, 2022","title":"👩‍💻 17779. 게리맨더링 2","tags":["구현","브루트포스","시뮬레이션"]},"rawMarkdownBody":"\n## 문제\n재현시의 시장 구재현은 지난 몇 년간 게리맨더링을 통해서 자신의 당에게 유리하게 선거구를 획정했다. 견제할 권력이 없어진 구재현은 권력을 매우 부당하게 행사했고, 심지어는 시의 이름도 재현시로 변경했다. 이번 선거에서는 최대한 공평하게 선거구를 획정하려고 한다.\n\n재현시는 크기가 N×N인 격자로 나타낼 수 있다. 격자의 각 칸은 구역을 의미하고, r행 c열에 있는 구역은 (r, c)로 나타낼 수 있다. 구역을 다섯 개의 선거구로 나눠야 하고, 각 구역은 다섯 선거구 중 하나에 포함되어야 한다. 선거구는 구역을 적어도 하나 포함해야 하고, 한 선거구에 포함되어 있는 구역은 모두 연결되어 있어야 한다. 구역 A에서 인접한 구역을 통해서 구역 B로 갈 수 있을 때, 두 구역은 연결되어 있다고 한다. 중간에 통하는 인접한 구역은 0개 이상이어야 하고, 모두 같은 선거구에 포함된 구역이어야 한다.\n\n선거구를 나누는 방법은 다음과 같다.\n\n1. 기준점 (x, y)와 경계의 길이 d1, d2를 정한다. (d1, d2 ≥ 1, 1 ≤ x < x+d1+d2 ≤ N, 1 ≤ y-d1 < y < y+d2 ≤ N)\n2. 다음 칸은 경계선이다.\n   1. (x, y), (x+1, y-1), ..., (x+d1, y-d1)\n   2. (x, y), (x+1, y+1), ..., (x+d2, y+d2)\n   3. (x+d1, y-d1), (x+d1+1, y-d1+1), ... (x+d1+d2, y-d1+d2)\n   4. (x+d2, y+d2), (x+d2+1, y+d2-1), ..., (x+d2+d1, y+d2-d1)\n3. 경계선과 경계선의 안에 포함되어있는 곳은 5번 선거구이다.\n4. 5번 선거구에 포함되지 않은 구역 (r, c)의 선거구 번호는 다음 기준을 따른다.\n   1. 1번 선거구: 1 ≤ r < x+d1, 1 ≤ c ≤ y\n   2. 2번 선거구: 1 ≤ r ≤ x+d2, y < c ≤ N\n   3. 3번 선거구: x+d1 ≤ r ≤ N, 1 ≤ c < y-d1+d2\n   4. 4번 선거구: x+d2 < r ≤ N, y-d1+d2 ≤ c ≤ N\n\n아래는 크기가 7×7인 재현시를 다섯 개의 선거구로 나눈 방법의 예시이다.\n\n<img src=\"https://upload.acmicpc.net/813c38e0-3197-4589-bc96-17d96eb9ed14/-/preview/\" width=\"80%\">\n\n구역 (r, c)의 인구는 A[r][c]이고, 선거구의 인구는 선거구에 포함된 구역의 인구를 모두 합한 값이다. 선거구를 나누는 방법 중에서, 인구가 가장 많은 선거구와 가장 적은 선거구의 인구 차이의 최솟값을 구해보자.\n\n### 입력\n- 첫째 줄에 재현시의 크기 N이 주어진다.\n- 둘째 줄부터 N개의 줄에 N개의 정수가 주어진다. r행 c열의 정수는 A[r][c]를 의미한다.\n\n### 출력\n- 첫째 줄에 인구가 가장 많은 선거구와 가장 적은 선거구의 인구 차이의 최솟값을 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Dosi {\n    int N;\n    int minDiff = Integer.MAX_VALUE;\n    int[][] map;\n    int[][] copyMap;\n    int[] rangeX = { -1, 0, 1, 0 };\n    int[] rangeY = { 0, 1, 0, -1 };\n    ...\n\n}\n```\n\n- 선거구의 정보를 담당하는 클래스이다.\n\n```java\npublic int vote() {...}\n```\n\n- 주어진 기준에 따라 선거구를 나누고, 인구 수를 합산하는 로직을 실행하는 메소드이다.\n\n```java\nprivate void setLine(int x, int y, int d1, int d2) {...}\n```\n\n- 5번 선거구의 가장자리를 긋고, 내부 영역을 탐색하는 `isConnected` 를 실행하는 메소드이다.\n\n```java\nprivate void isConnected(int x, int y) {...}\n```\n\n- 재귀적으로 5번 선거구의 내부를 탐색한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.*;\n\n    class Dosi {\n        int N;\n        int minDiff = Integer.MAX_VALUE;\n        int[][] map;\n        int[][] copyMap;\n        int[] rangeX = { -1, 0, 1, 0 };\n        int[] rangeY = { 0, 1, 0, -1 };\n\n        public Dosi(int N) {\n            this.N = N;\n            map = new int[N + 1][N + 1];\n        }\n\n        public int vote() {\n            for (int d1 = 1; d1 <= N; d1++) {\n                for (int d2 = 1; d2 <= N; d2++) {\n                    for (int x = 1; x <= N; x++) {\n                        for (int y = 1; y <= N; y++) {\n                            if (!(x + d1 + d2 <= N && y - d1 >= 1 && y + d2 <= N)) continue;\n                            copyMap = new int[N + 1][N + 1];\n                            popSum1(x, y, d1);\n                            popSum2(x, y ,d2);\n                            popSum3(x, y, d1, d2);\n                            popSum4(x, y, d1, d2);\n                            setLine(x, y, d1, d2);\n                            sum();\n                        }\n                    }\n                }\n            }\n            return minDiff;\n        }\n\n        private void sum() {\n            int max = 0;\n            int min = Integer.MAX_VALUE;\n            int[] popSum = new int[6];\n            for(int i=1; i<=N; i++) {\n                for(int j=1; j<=N; j++) {\n                    popSum[copyMap[i][j]]+=map[i][j];\n                }\n            }\n            for(int i=1; i<=5; i++) {\n                max = Math.max(max, popSum[i]);\n                min = Math.min(min, popSum[i]);\n            }\n            minDiff = Math.min(minDiff, max-min);\n        }\n\n        private void setLine(int x, int y, int d1, int d2) {\n            for(int i = 0; i <= d1; i++) {\n                copyMap[x+i][y-i] = 5;\n            }\n            for(int i = 0; i <= d2; i++) {\n                copyMap[x+i][y+i] = 5;\n            }\n            for(int i = 0; i <= d2; i++) {\n                copyMap[x+d1+i][y-d1+i] = 5;\n            }\n            for(int i = 0; i <= d1; i++) {\n                copyMap[x+d2+i][y+d2-i] = 5;\n            }\n            for(int alpha = 0; alpha < d1; alpha++) {\n                isConnected(x+alpha+1, y-alpha);\n            }\n            for(int alpha = 0; alpha < d2; alpha++) {\n                isConnected(x+alpha+1, y+alpha);\n            }\n        }\n\n        private void isConnected(int x, int y) {\n            copyMap[x][y] = 5;\n\n            for(int i=0; i<4; i++) {\n                int nx = x + rangeX[i];\n                int ny = y + rangeY[i];\n                if (nx < 1 || nx > N || ny < 1 || ny > N) continue;\n                if (copyMap[nx][ny] != 5) isConnected(nx,ny);\n            }\n        }\n\n        private void popSum1(int x, int y, int d1) {\n            for (int i = 1; i < x + d1; i++) {\n                for (int j = 1; j <= y; j++) {\n                    copyMap[i][j] = 1;\n                }\n            }\n        }\n\n        private void popSum2(int x, int y, int d2) {\n            for (int i = 1; i <= x + d2; i++) {\n                for (int j = y + 1; j <= N; j++) {\n                    copyMap[i][j] = 2;\n                }\n            }\n        }\n\n        private void popSum3(int x, int y, int d1, int d2) {\n            for (int i = x + d1; i <= N; i++) {\n                for (int j = 1; j < y - d1 + d2; j++) {\n                    copyMap[i][j] = 3;\n                }\n            }\n        }\n\n        private void popSum4(int x, int y, int d1, int d2) {\n            for (int i = x + d2 + 1; i <= N; i++) {\n                for (int j = y - d1 + d2; j <= N; j++) {\n                    copyMap[i][j] = 4;\n                }\n            }\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int N = Integer.parseInt(br.readLine());\n\n            Dosi dosi = new Dosi(N);\n            String[] line;\n\n            for (int i = 1; i <= N; i++) {\n                line = br.readLine().split(\" \");\n                for (int j = 1; j <= N; j++) {\n                    dosi.map[i][j] = Integer.parseInt(line[j - 1]);\n                }\n            }\n\n            System.out.println(dosi.vote());\n\n            br.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 처음에는 게리맨더링이랑 비슷한 줄 알았는데 조금은 달라서 생각해보는데 시간이 좀 걸렸다. \n- 선거구를 나누는 로직을 구현하는데 시간이 걸렸고, 게시판을 참고해서 나름대로 풀어봤는데, 최종적으로 인구수를 합산해 차이의 최소를 구하는 로직이 자꾸 틀렸다.\n  - 어차피 나눠진 선거구의 인구 수를 나눌 때마다 합산하고 선거구를 다 나눈 뒤 (즉, 인구 수 합산까지 완료된 상태) 차이를 구하고 이를 업데이트하는 방식은 왜 틀리는지 모르겠다.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/17779"},{"excerpt":"프로젝트를 진행하면서, Key와 Value를 쌍으로 저장하는 클래스인  를 자주 사용하고 있다. 검색에 있어서 많은 이점이 있기 때문인데, 오늘 이 포스트를 작성하게 된 이유는  종류 중 하나인  을 사용해 값을 저장하고 정렬하던 중, 정렬된 값들이 순서대로 저장되지 않는 문제를 발견했기 때문이다.  이를 해결하기 위해  클래스를 사용한다는 것을 확인했고…","fields":{"slug":"/[Java지식]HashMap&LinkedHashMap/"},"frontmatter":{"date":"March 20, 2022","title":"📃 HashMap과 LinkedHashMap","tags":["Java"]},"rawMarkdownBody":"\n프로젝트를 진행하면서, Key와 Value를 쌍으로 저장하는 클래스인 `Map` 를 자주 사용하고 있다. 검색에 있어서 많은 이점이 있기 때문인데, 오늘 이 포스트를 작성하게 된 이유는 `Map` 종류 중 하나인 `HashMap` 을 사용해 값을 저장하고 정렬하던 중, 정렬된 값들이 순서대로 저장되지 않는 문제를 발견했기 때문이다. \n\n이를 해결하기 위해 `LinkedHashMap` 클래스를 사용한다는 것을 확인했고, 둘의 차이점에 대해 정리하고자 한다.\n\n## 📍 `HashMap` 이란\n정의 형태는 아래와 같다.\n\n```java\npublic class HashMap<K,V>\nextends AbstractMap<K,V>\nimplements Map<K,V>, Cloneable, Serializable\n```\n\n`Map` 인터페이스 구현에 기반한 해시 테이블이다.\n- K : map에서 각각을 식별하기 위한 key의 타입\n- V : 매핑된 값의 타입\n- 모든 map 연산을 제공하고, `null` values와 keys를 허용한다. \n- map의 순서를 보장하지 않는다. \n- `get` 과 `put` 에 대해 일정한 시간 성능을 보여준다. (hash function 사용)\n- 하위 클래스로는 `LinkedHashMap` , `PrinterStateReasons` 가 있다.\n\n> rough하게 보면 `HashTable` 와 동일하지만, `HashMap` 은 unsynchronized하고, `null` 을 허용한다는 특징이 있다.\n\n## 📍 `LinkedHashMap` 이란\n정의 형태는 아래와 같다.\n```java\npublic class LinkedHashMap<K,V>\nextends HashMap<K,V>\nimplements Map<K,V>\n```\n\n`Map` 인터페이스 구현에 기반한 해시 테이블이자 링크드 리스트이다.\n- K : map에서 각각을 식별하기 위한 key의 타입\n- V : 매핑된 값의 타입\n- 이중 링크드 리스트를 모든 entries에 대해 유지하여 각각의 삽입 순서를 보장한다.\n  - 동일한 key에 대해 `map.put()` 이 호출되어도 삽입 순서에는 영향을 미치지 않고, 이미 있던 value가 대체된다.\n\n## 📍 공통점과 차이점\n### 📝 공통점\n둘 다 기본적으로 `Map` 인터페이스를 기반에 둔다. (`Map` -> `HashMap` -> `LinkedHashMap`) 따라서, 기본적으로 사용하는 메소드들도 동일하다.\n- `get()` : 매핑한 key의 value값을 가져온다.\n- `isEmpty()` : map안의 데이터의 존재 여부를 반환한다. 비어있다면 `true` 를 반환한다.\n- `containsKey()` : map안에 인자로 전달된 key가 존재하는지를 반환한다.\n- `size()` : map의 크기를 반환한다.\n\n### 📝 차이점\n가장 큰 차이라고 함은 내가 사용했던 이유이기도 한, **Key & Value 삽입 순서의 보장**이다.\n\n\"**`HashMap`** 은 삽입 순서대로 저장되지 않지만, **`LinkedHashMap`** 은 삽입 순서대로 저장된다.\"\n\n나는 `HashMap` 에 Key & Value로 저장된 데이터들을 특정 기준으로 정렬하고 이를 정렬된 순서대로 저장되는 것을 원했기에 `LinkedHashMap` 을 사용했다. 그렇다면 `HashMap` 은 왜 삽입 순서대로 저장되지 않는 걸까 ?\n\n### 📝 `HashMap` 의 순서\n`HashMap` 의 API를 보면, 아래와 같다.\n\n```java\npublic V put(K key, V value) {\n  return putVal(hash(key), key, value, false, true);\n}\n\nstatic final int hash(Object key) {\n  int h;\n  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n- `put` 을 할 때, `hash()` 메소드를 사용해 `hash` 된 key을 이용해 저장하고 있다.\n- `hash()` 메소드에서 사용하는 `key.hashCode()` 가 어떤 값을 리턴할 지 알 수 없기에 `HashMap` 은 순서를 보장해주지 못한다.\n- 하지만 `LinkedHashMap` 은 내부적으로 **Doubly-Linked List**를 유지하기에 순서를 보장할 수 있다.\n\n## 📕 참고\n- [Class HashMap](https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html)\n- [JAVA HashMap VS LinkedHashMap (차이점, 성능차이, 사용방법)](https://web-inf.tistory.com/44)\n- [JAVA) HashMap에서의 순서](https://surhommejk.tistory.com/223)"},{"excerpt":"문제 인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다.\n연구소는 크기가 N×M인 직사각형으로 나타낼 수 있으며, 직사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는 빈 칸, 벽으로 이루어져 있으며, 벽은 칸 하나를 가득 차지한…","fields":{"slug":"/[BOJ]14502/"},"frontmatter":{"date":"March 19, 2022","title":"👩‍💻 14502. 연구소","tags":["그래프이론","그래프탐색","BFS","브루트포스"]},"rawMarkdownBody":"\n## 문제\n인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다.\n연구소는 크기가 N×M인 직사각형으로 나타낼 수 있으며, 직사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는 빈 칸, 벽으로 이루어져 있으며, 벽은 칸 하나를 가득 차지한다. \n일부 칸은 바이러스가 존재하며, 이 바이러스는 상하좌우로 인접한 빈 칸으로 모두 퍼져나갈 수 있다. 새로 세울 수 있는 벽의 개수는 3개이며, 꼭 3개를 세워야 한다.\n예를 들어, 아래와 같이 연구소가 생긴 경우를 살펴보자.\n\n```\n2 0 0 0 1 1 0\n0 0 1 0 1 2 0\n0 1 1 0 1 0 0\n0 1 0 0 0 0 0\n0 0 0 0 0 1 1\n0 1 0 0 0 0 0\n0 1 0 0 0 0 0\n```\n\n이때, 0은 빈 칸, 1은 벽, 2는 바이러스가 있는 곳이다. 아무런 벽을 세우지 않는다면, 바이러스는 모든 빈 칸으로 퍼져나갈 수 있다. 2행 1열, 1행 2열, 4행 6열에 벽을 세운다면 지도의 모양은 아래와 같아지게 된다.\n\n```\n2 1 0 0 1 1 0\n1 0 1 0 1 2 0\n0 1 1 0 1 0 0\n0 1 0 0 0 1 0\n0 0 0 0 0 1 1\n0 1 0 0 0 0 0\n0 1 0 0 0 0 0\n```\n\n바이러스가 퍼진 뒤의 모습은 아래와 같아진다.\n\n```\n2 1 0 0 1 1 2\n1 0 1 0 1 2 2\n0 1 1 0 1 2 2\n0 1 0 0 0 1 2\n0 0 0 0 0 1 1\n0 1 0 0 0 0 0\n0 1 0 0 0 0 0\n```\n\n벽을 3개 세운 뒤, 바이러스가 퍼질 수 없는 곳을 안전 영역이라고 한다. 위의 지도에서 안전 영역의 크기는 27이다. 연구소의 지도가 주어졌을 때 얻을 수 있는 안전 영역 크기의 최댓값을 구하는 프로그램을 작성하시오.\n\n## 입, 출력\n\n입력\n- 첫째 줄에 지도의 세로 크기 N과 가로 크기 M이 주어진다. (3 ≤ N, M ≤ 8)\n- 둘째 줄부터 N개의 줄에 지도의 모양이 주어진다. 0은 빈 칸, 1은 벽, 2는 바이러스가 있는 위치이다. 2의 개수는 2보다 크거나 같고, 10보다 작거나 같은 자연수이다.\n- 빈 칸의 개수는 3개 이상이다.\n\n출력\n- 첫째 줄에 얻을 수 있는 안전 영역의 최대 크기를 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Lab {\n    Queue<Loc> locQueue;\n    int N, M;\n    int safeArea = 0;\n    int[][] map;\n    int[][] copyMap;\n    int[] rangeX = { -1, 0, 1, 0 };\n    int[] rangeY = { 0, 1, 0, -1 };\n\n    Loc[] orgSafe;\n    int idx0 = 0;\n    ...\n        \n}\n```\n\n- 연구소의 정보를 관리하는 클래스\n- 원본 연구소 정보를 저장하는 `map` 과 바이러스를 실제로 퍼뜨릴 `copyMap` 을 사용한다.\n- 또한 벽을 세울 공간들을 저장하는 `orgSafe` 배열을 사용한다.\n- `setWall()` 재귀 호출로 벽을 세우고, 벽을 다 세운 다음, `spreadVirus()` 에서 BFS 방식으로 바이러스를 퍼뜨린다.\n- 이후, `countAndReset()` 으로 바이러스가 퍼진 이후의 안전 영역을 카운트하고, `map` 을 이용해 `copyMap` 을 바이러스가 퍼지기 전 상태로 돌려놓는다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.Arrays;\n    import java.util.LinkedList;\n    import java.util.Queue;\n\n    class Loc {\n        int x, y;\n\n        public Loc(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Lab {\n        Queue<Loc> locQueue;\n        int N, M;\n        int safeArea = 0;\n        int[][] map;\n        int[][] copyMap;\n        int[] rangeX = { -1, 0, 1, 0 };\n        int[] rangeY = { 0, 1, 0, -1 };\n\n        Loc[] orgSafe;\n        int idx0 = 0;\n\n        public Lab (int N, int M) {\n            this.N = N;\n            this.M = M;\n            map = new int[N][M];\n            copyMap = new int[N][M];\n            orgSafe = new Loc[N*M];\n            locQueue = new LinkedList<>();\n        }\n\n        public int findMaxSafeArea() {\n            setWall(0,3);\n            return safeArea;\n        }\n\n        private void setWall(int idx, int count) {\n            if (count == 0) {\n                spreadVirus();\n                int result = countAndReset();\n                if (safeArea < result) safeArea = result;\n            } else {\n                count--;\n                for (int i = idx; i < idx0; i++) {\n                    copyMap[orgSafe[i].x][orgSafe[i].y] = 1;\n                    setWall(i + 1, count);\n                    copyMap[orgSafe[i].x][orgSafe[i].y] = 0;\n                }\n            }\n        }\n\n        private void spreadVirus() {\n            for (int i = 0; i < locQueue.size(); i++) {\n                Loc tmpLoc = locQueue.poll();\n                bfs(tmpLoc.x, tmpLoc.y);\n                locQueue.add(tmpLoc);\n            }\n        }\n\n        private void bfs(int x, int y) {\n            Queue<Loc> queue = new LinkedList<>();\n            queue.add(new Loc(x, y));\n\n            while (!queue.isEmpty()){\n                Loc tmp = queue.poll();\n                for (int i = 0; i < 4; i++) {\n                    int nx = tmp.x + rangeX[i], ny = tmp.y + rangeY[i];\n                    if (nx < 0 || nx >= N || ny < 0 || ny >= M) continue;\n                    if (copyMap[nx][ny] == 0) {\n                        queue.add(new Loc(nx, ny));\n                        copyMap[nx][ny] = 2;\n                    }\n                }\n            }\n        }\n\n        private int countAndReset() {\n            int count = 0;\n            for (int i = 0; i < N; i++) {\n                for (int j = 0; j < M; j++) {\n                    if (copyMap[i][j] == 0) count++;\n                    if (copyMap[i][j] == 2) {\n                        if (locQueue.contains(new Loc(i, j))) continue;\n                        copyMap[i][j] = map[i][j];\n                    }\n                }\n            }\n            return count;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\n            String[] line = br.readLine().split(\" \");\n            int N = Integer.parseInt(line[0]);\n            int M = Integer.parseInt(line[1]);\n\n            Lab lab = new Lab(N, M);\n\n            for (int i = 0; i < N; i++) {\n                lab.map[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n                for (int j = 0; j < M; j++) {\n                    if (lab.map[i][j] == 2)\n                        lab.locQueue.add(new Loc(i, j));\n                    else if (lab.map[i][j] == 0)\n                        lab.orgSafe[lab.idx0++] = new Loc(i, j);\n                    lab.copyMap[i][j] = lab.map[i][j];\n                }\n            }\n\n            br.close();\n\n            System.out.println(lab.findMaxSafeArea());\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 원래의 연구소 정보를 간직하기 위해 `map` 과 `copyMap` 배열을 두고 진행했는데, 계속 두 배열이 동기화된 것마냥 값이 같이 변경되고 있었다. 아무래도 `lab.map[i] = lab.copyMap[i];` 이 코드 때문에 인스턴스의 주소 공유나 참조의 문제일거라 생각해 검색해보니 아니나 다를까 \"얕은 복사와 깊은 복사\" 문제였다. 한 번 정리해야겠다.\n- 바이러스가 퍼진 이후 다시 원상복구할때, 세운 벽까지 없애버리는 초기화 과정떄문에 값이 계속 잘못 나왔다. 초기화 과정은 항상 잘 확인하자.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/14502"},{"excerpt":"이전에 BOJ_연구소를 풀다가, 배열 두 개를 사용하여 값을 변경하고 초기화하는 작업을 하던 중 의도와 다르게 두 배열의 값이 동기화된 것처럼 같이 변경되는 문제를 확인했다.  그래서 \"얕은 복사와 깊은 복사\"에 대해 정리하려 한다. 내가 맞닥뜨린 문제이므로 정리하고 이해하고 넘어가고자 한다. 📍 자바의 객체 복사 자바에서는 객체를 복사하는 유형으로 얕은…","fields":{"slug":"/[Java지식]얕은복사&깊은복사/"},"frontmatter":{"date":"March 19, 2022","title":"📃 얕은 복사와 깊은 복사","tags":["Java"]},"rawMarkdownBody":"\n이전에 [BOJ_연구소](https://subbblog.netlify.app/BOJ-14502/)를 풀다가, 배열 두 개를 사용하여 값을 변경하고 초기화하는 작업을 하던 중 의도와 다르게 두 배열의 값이 동기화된 것처럼 같이 변경되는 문제를 확인했다. \n\n그래서 **\"얕은 복사와 깊은 복사\"**에 대해 정리하려 한다. 내가 맞닥뜨린 문제이므로 정리하고 이해하고 넘어가고자 한다.\n\n## 📍 자바의 객체 복사\n자바에서는 객체를 복사하는 유형으로 **얕은 복사**와 **깊은 복사**가 있다.\n\n### 📝 얕은 복사 (Shallow Copy)\n단순히 객체의 주소 값만을 복사하는 방식이다.\n- **여러 객체가 같은 주소를 참조**해 하나의 값을 변경하면 다른 대상의 값 또한 바뀐다.\n  - 즉, 객체는 여러 개이지만,그 객체 각각이 가리키는 값은 동일한 주소 값이다. 그렇기에 대개 복사가 아닌 **같이 사용한다-**정도의 개념이 알맞다.\n- 메모리 측면에서는 한 객체로 가능하다면 이 방식을 사용하는 것이 효율적이다.\n\n### 📝 깊은 복사 (Deep Copy)\n객체의 실제값을 새로운 객체로 복사하는 방식이다.\n- 실제로 대상이 여러 개가 생기므로, **각 값이 모두 개별적**이다.\n- 하지만 쓸데없이 여러 객체를 생성한다면 메모리 측면에서는 효율적이지 못하다.\n\n> 우선 내가 원한 로직은 `copyMap` 의 값을 변경하고 이를 다시 되돌리기 위해 `map` 을 이용하려 했다. 얕은 복사와 깊은 복사를 내가 풀었던 코드에 대입하여 표현하면 아래와 같다.\n\n```java\nclass Lab {\n\tint[][] map;\n\tint[][] copyMap;\n\n\tpublic Lab (int N, int M) {\n\t\tmap = new int[N][M];\n\t\tcopyMap = new int[N][M];\n\t}\n}\n```\n- `Lab` 클래스를 생성하고, 두 배열(`map` , `copyMap`)을 생성한다. \n\n```java\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\t// N, M이 입력되었다고 가정\n\t\tint N, M;\n\n\t\t// 생성자로 map, copyMap을 생성\n\t\tLab lab = new Lab(N, M);\n\n\t\t// lab.map에 먼저 값을 대입하고, 이를 copyMap에 동일하게 대입\n\t\tfor (int i = 0; i < N; i++) {\n\t\t\tlab.map[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\t\t\t// 얕은 복사\n\t\t\tlab.copyMap[i] = lab.map[i];\n\t\t}\n\t}\n}\n```\n- 이후 배열을 초기화하는데, `=` 연산자를 사용해서 `copyMap` 을 초기화했다.\n\n여기서 `=` 연산자는 **주소를 이어준다**는 의미를 가진다. 즉, `lab.copyMap[i]` 와 `lab.map[i]` 의 주소를 이어, 깊은 복사가 아닌 얕은 복사가 수행되고 두 배열의 값이 함께 수정되어버린다.\n\n> 이를 깊은 복사로 변경한다. 깊은 복사는 여러 가지 방법이 있다. 나는 우선 간단한 for문으로 깊은 복사를 수행했다.\n\n```java\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\t// N, M이 입력되었다고 가정\n\t\tint N, M;\n\n\t\t// 생성자로 map, copyMap을 생성\n\t\tLab lab = new Lab(N, M);\n\n\t\t// lab.map에 먼저 값을 대입하고, 이를 copyMap에 동일하게 대입\n\t\tfor (int i = 0; i < N; i++) {\n\t\t\tlab.map[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\t\t\t// 깊은 복사\n\t\t\tfor (int j = 0; j < M; j++) {\n\t\t\t\tlab.copyMap[i][j] = lab.map[i][j];\n\t\t\t}\n\t\t}\n\t}\n}\n```\n- 간단한 반복문으로 배열의 원소를 하나하나 대입하였다.\n\n### 📝 깊은 복사 메소드\n아래는 모두 1차원 배열에 대해 가능한 깊은 복사 메소드이다. 2차원 배열에 대해서는 이와 같이 불가능한데, 다음과 같은 이유에서이다.\n- 2차원 배열의 구조(`map[x][y]`)에서 배열을 복사하는 메소드를 사용하면, `y` 좌표를 가리키는 주소값만 있는 `map[x]` 부분만 깊은 복사가 되고, 값이 있는 `map[x][y]` 는 깊은 복사가 수행되지 않는다.\n- 따라서, 이중 for문을 활용하거나, 가장 마지막에 있는 `System.arraycopy` 를 활용해야 한다.\n\n**`Object.clone()`**\n```java\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\tint[] map = { 0, 1, 2, 3 };\n\t\tint[] copyMap = map.clone(); \n\t}\n}\n```\n- 가장 보편적인 깊은 복사 방법이다.\n\n**`Arrays.copyOf()`**\n```java\nimport java.util.Arrays;\n\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\tint[] map = { 0, 1, 2, 3 };\n\t\tint[] copyMap = Arrays.copyOf(map, map.length);\n\t}\n}\n```\n- `Arrays` 클래스는 배열을 다루는 메소드를 가진 클래스이다. 이 클래스의 `copyOf()` 를 사용하면 배열의 시작점부터 원하는 `length` 까지 깊은 복사를 수행할 수 있다.\n\n**`Arrays.copyOfRange()`**\n```java\nimport java.util.Arrays;\n\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\tint[] map = { 0, 1, 2, 3 };\n\t\tint[] copyMap = Arrays.copyOfRange(map, 1, 3);\n\t}\n}\n```\n- `Arrays.copyOf()` 는 배열의 시작점부터 원하는 `length` 까지 복사하는 메소드였다면, `copyOfRange()` 는 복사할 시작점 또한 지정 가능하다. (0행부터 시작)\n\n**`System.arraycopy()`**\n```java\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\tint[] map = { 0, 1, 2, 3 };\n\t\tint[] copyMap = new int[map.length];\n\t\tSystem.arraycopy(map, 0, copyMap, 0, map.length);\n\t}\n}\n```\n- 1차원 배열에 대해 지정한 배열을 대상 배열의 지정한 위치에 `length` 만큼 복사한다.\n\n```java\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\t// N, M이 입력되었다고 가정\n\t\tint N, M;\n\n\t\t// 생성자로 map, copyMap을 생성\n\t\tLab lab = new Lab(N, M);\n\n\t\t// lab.map에 먼저 값을 대입하고, 이를 copyMap에 동일하게 대입\n\t\tfor (int i = 0; i < N; i++) {\n\t\t\tlab.map[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\t\t\tSystem.arraycopy(lab.map[i], 0, lab.copyMap[i], 0, lab.map[i].length);\n\t\t}\n\t}\n}\n```\n- 2차원 배열에 대해 복사한다.\n\n## 📕 참고\n- [[Java] 자바 배열을 복사하는 다양한 방법 (깊은복사, 얕은복사)](https://coding-factory.tistory.com/548)"},{"excerpt":"문제 'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임은 NxN 정사각 보드위에서 진행되고, 몇몇 칸에는 사과가 놓여져 있다. 보드의 상하좌우 끝에 벽이 있다. 게임이 시작할때 뱀은 맨위 맨좌측에 위치하고 뱀의 …","fields":{"slug":"/[BOJ]3190/"},"frontmatter":{"date":"March 18, 2022","title":"👩‍💻 3190. 뱀","tags":["구현","시뮬레이션","자료구조","덱","큐"]},"rawMarkdownBody":"\n## 문제\n'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다.\n\n게임은 NxN 정사각 보드위에서 진행되고, 몇몇 칸에는 사과가 놓여져 있다. 보드의 상하좌우 끝에 벽이 있다. 게임이 시작할때 뱀은 맨위 맨좌측에 위치하고 뱀의 길이는 1 이다. 뱀은 처음에 오른쪽을 향한다.\n\n뱀은 매 초마다 이동을 하는데 다음과 같은 규칙을 따른다.\n\n- 먼저 뱀은 몸길이를 늘려 머리를 다음칸에 위치시킨다.\n- 만약 이동한 칸에 사과가 있다면, 그 칸에 있던 사과가 없어지고 꼬리는 움직이지 않는다.\n- 만약 이동한 칸에 사과가 없다면, 몸길이를 줄여서 꼬리가 위치한 칸을 비워준다. 즉, 몸길이는 변하지 않는다.\n\n사과의 위치와 뱀의 이동경로가 주어질 때 이 게임이 몇 초에 끝나는지 계산하라.\n\n## 입, 출력\n\n입력\n- 첫째 줄에 보드의 크기 N이 주어진다. (2 ≤ N ≤ 100) 다음 줄에 사과의 개수 K가 주어진다. (0 ≤ K ≤ 100)\n- 다음 K개의 줄에는 사과의 위치가 주어지는데, 첫 번째 정수는 행, 두 번째 정수는 열 위치를 의미한다. 사과의 위치는 모두 다르며, 맨 위 맨 좌측 (1행 1열) 에는 사과가 없다.\n- 다음 줄에는 뱀의 방향 변환 횟수 L 이 주어진다. (1 ≤ L ≤ 100)\n- 다음 L개의 줄에는 뱀의 방향 변환 정보가 주어지는데,  정수 X와 문자 C로 이루어져 있으며. 게임 시작 시간으로부터 X초가 끝난 뒤에 왼쪽(C가 'L') 또는 오른쪽(C가 'D')로 90도 방향을 회전시킨다는 뜻이다. X는 10,000 이하의 양의 정수이며, 방향 전환 정보는 X가 증가하는 순으로 주어진다.\n\n출력\n- 첫째 줄에 게임이 몇 초에 끝나는지 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Info {\n    int second;\n    char direction;\n\n    public Info (int second, char direction) {\n        this.second = second;\n        this.direction = direction;\n    }\n}\n```\n\n- 뱀의 방향 전환 정보를 저장하는 클래스\n\n```java\nclass Dummy {\n    Info[] infos;\n    Queue<Pair> queue = new LinkedList<>();\n    int[][] map;\n    int[] rangeX = { -1, 0, 1, 0 };\n    int[] rangeY = { 0, 1, 0, -1 };\n    int mapSize;\n    int directionChanges;\n    int count = 0;\n    int infoIdx = 0;\n    int snakeDir;\n    ...\n\n}\n```\n\n- Dummy 게임에 필요한 로직을 구현하는 클래스\n- `map` 에서 1은 뱀의 위치, 2는 사과의 위치를 나타낸다.\n\n```java\nprivate void moveSnake(int x, int y) { ... }\n```\n\n- `Queue` 를 이용해서 뱀의 꼬리 정보를 저장하고, 필요에 따라 먼저 들어온 좌표를 out한다.\n- 뱀의 방향 전환을 위해 `snakeDir` 변수로 뱀의 현재 방향을 저장한다. (0, 1, 2, 3 - 북, 동, 남, 서)\n- 시간에 따라 `infos` 에서 방향 전환 정보를 확인한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.LinkedList;\n    import java.util.Queue;\n\n    class Pair {\n        int x;\n        int y;\n\n        public Pair(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Info {\n        int second;\n        char direction;\n\n        public Info (int second, char direction) {\n            this.second = second;\n            this.direction = direction;\n        }\n    }\n\n    class Dummy {\n        Info[] infos;\n        Queue<Pair> queue = new LinkedList<>();\n        int[][] map;\n        int[] rangeX = { -1, 0, 1, 0 };\n        int[] rangeY = { 0, 1, 0, -1 };\n        int mapSize;\n        int directionChanges;\n        int count = 0;\n        int infoIdx = 0;\n        int snakeDir;\n\n        public Dummy (int N) {\n            mapSize = N;\n            map = new int[N][N];\n        }\n\n        public int game(int directionChanges) {\n            snakeDir = 1;\n            this.directionChanges = directionChanges;\n            moveSnake(0, 0);\n            return count;\n        }\n\n        private void moveSnake(int x, int y) {\n            queue.add(new Pair(x, y));\n            map[x][y] = 1;\n\n            if (infoIdx < directionChanges) accessInfo();\n\n            x += rangeX[snakeDir];\n            y += rangeY[snakeDir];\n            count++;\n\n            if (checkBoundary(x, y)) return;\n            if (map[x][y] == 1) return;\n            if (map[x][y] != 2) cutTail();\n\n            moveSnake(x, y);\n        }\n\n        private void accessInfo() {\n            if (infos[infoIdx].second == count) {\n                updateDir();\n                infoIdx++;\n            }\n        }\n\n        private void updateDir() {\n            if (infos[infoIdx].direction == 'L') {\n                snakeDir = (snakeDir + 3) % 4;\n            } else {\n                snakeDir = (snakeDir + 1) % 4;\n            }\n        }\n\n        private void cutTail() {\n            if (!queue.isEmpty()) {\n                Pair out = queue.poll();\n                map[out.x][out.y] = 0;\n            }\n        }\n\n        private boolean checkBoundary(int x, int y) {\n            return (x < 0 || x >= mapSize || y < 0 || y >= mapSize);\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int N = Integer.parseInt(br.readLine());\n\n            Dummy dummy = new Dummy(N);\n\n            int appleCount = Integer.parseInt(br.readLine());\n\n            String[] line;\n            for (int i = 0; i < appleCount; i++) {\n                line = br.readLine().split(\" \");\n                dummy.map[Integer.parseInt(line[0])-1][Integer.parseInt(line[1])-1] = 2;\n            }\n\n            int directionChanges = Integer.parseInt(br.readLine());\n            dummy.infos = new Info[directionChanges];\n            for (int i = 0; i < directionChanges; i++) {\n                line = br.readLine().split(\" \");\n                dummy.infos[i] = new Info(Integer.parseInt(line[0]), line[1].charAt(0));\n            }\n            br.close();\n\n            System.out.println(dummy.game(directionChanges));\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 웹 백엔드 기능을 구현하는 것처럼, 요구사항 하나하나에 해당하는 기능 덩어리를 만들어보자는 생각으로 접근했다. 시뮬레이션은 주어진 로직 그대로 구현만 하면 되는 것 같다.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/3190"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 상속 관계 매핑: 객체의 상속 관계를 데이터베이스에 어떻게 매핑하는가?\n: 등록일, 수정일 같이 여러 엔티티에서 공통으로 사용하는 매핑 정보만 상속받고 싶으면 이 기능을 사용\n복합 키와 식별 관계 매핑: 데이터베이스의 식별자가 하나 이상일 때 매핑하는 방법\n조인 테이블…","fields":{"slug":"/[JPA]7/"},"frontmatter":{"date":"March 17, 2022","title":"📚 7. 고급 매핑","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 상속 관계 매핑: 객체의 상속 관계를 데이터베이스에 어떻게 매핑하는가?\n> `@MappedSuperclass`: 등록일, 수정일 같이 여러 엔티티에서 공통으로 사용하는 매핑 정보만 상속받고 싶으면 이 기능을 사용\n> 복합 키와 식별 관계 매핑: 데이터베이스의 식별자가 하나 이상일 때 매핑하는 방법\n> 조인 테이블: 테이블은 외래 키 하나로 연관관계가 가능하지만 연관관계를 관리하는 연결 테이블을 두는 방법도 존재\n> 엔티티 하나에 여러 테이블 매핑: 엔티티 하나에 테이블 하나를 매핑하지 않고 엔티티 하나에 여러 테이블을 매핑\n\n## 💫 상속 관계 매핑\n관계형 데이터베이스에는 객체지향 언어에서 다루는 상속이라는 개념이 없다. 그 대신 슈퍼타입 관계(Super-Type Sub-Type Relationship)라는 모델링 기법이 유사한 기능을 한다. **ORM에서 다루는 상속 관계 매핑**은 **객체의 상속 구조와 데이터베이스의 슈퍼타입 서브타입 관계를 매핑**하는 것이다.\n\n슈퍼타입 서브타입 논리 모델을 실제 물리 모델인 테이블로 구현하는 방법\n- 각각의 테이블로 변환\n  - 각각을 모두 테이블로 만들고 조회할 때 조인을 사용 = 조인 전략\n- 통합 테이블로 변환\n  - 테이블을 하나만 사용해 통합 = 단일 테이블 전략\n- 서브타입 테이블로 변환\n  - 서브 타입마다 하나의 테이블을 생성 = 구현 클래스마다 테이블 전략\n\n### ➰ 조인 전략\n엔티티 **각각을 모두 테이블**로 만들고 자식 테이블이 부모 테이블의 기본 키를 받아 **기본 키 + 외래 키**로 사용하는 전략\n- 조회 시 조인을 사용\n- 객체는 **타입 구분이 가능**하지만, 테이블은 타입 개념이 없어 **타입을 구분하는 컬럼의 추가가 필요**\n\n```java\n@Entity\n@Inheritance(strategy = InheritanceType.JOINED)\n@DiscriminatorColumn(name = \"DTYPE\")\npublic abstract class Item {\n\n  @Id @GeneratedValue\n  @Column(name = \"ITEM_ID\")\n  private Long id;\n\n  private String name;\n  private int price;\n  ...\n\n}\n\n@Entity\n@DiscriminatorValue(\"A\")\npublic class Album extends Item {\n  \n  private String artist;\n  ...\n\n}\n\n@Entity\n@DiscriminatorValue(\"M\")\npublic class Movie extends Item {\n\n  private String director;\n  private String actor;\n  ...\n\n}\n```\n- `@Inheritance(strategy = InheritanceType.JOINED)`\n  - 상속 매핑은 부모 클래스에 이 annotation을 사용해야 한다.\n  - 그리고 매핑 전략은 조인 전략을 사용한다는 것을 명시한다.\n- `@DiscriminatorColumn(name = \"DTYPE\")`\n  - 부모 클래스에 구분 컬럼을 지정한다.\n  - 이 컬럼으로 저장된 자식 테이블을 구분한다.\n- `@DiscriminatorValue(\"A\")`\n  - 엔티티를 저장할 떄 구분 컬럼에 입력할 값을 지정한다.\n\n**장점**\n- 테이블이 정규화된다.\n- 외래 키 참조 무결성 제약조건을 활용할 수 있다.\n- 저장공간을 효율적으로 사용한다.\n\n**단점**\n- 조인을 많이 사용하여 조회 쿼리가 복잡하고, 성능이 저하될 수 있다.\n- 데이터를 등록할 INSERT SQL을 두 번 실행한다.\n\n**특징**\n- JPA 표준 명세는 구분 컬럼을 사용하도록 하지만, 몇몇 구현체는 생략해도 동작한다.\n\n### ➰ 단일 테이블 전략\n테이블을 하나만 사용한다. 그리고 구분 컬럼으로 어떤 자식 데이터가 저장되었는지 확인하고, 단일 테이블이므로 조인을 사용하지 않아 일반적으로 가장 빠르다.\n\n**주의점**\n- 자식 엔티티가 매핑한 컬럼은 모두 `null` 을 허용해야 한다. (`NOT NULL` X)\n- 특정 자식 엔티티를 저장할 때, 다른 자식 엔티티와 매핑된 컬럼들은 사용하지 않아 `null` 이 입력되기 때문이다.\n\n```java\n@Entity\n@Inheritance(strategy = InheritanceType.SINGLE_TABLE)\n@DiscriminatorColumn(name = \"DTYPE\")\npublic abstract class Item {\n\n  @Id @GeneratedValue\n  @Column(name = \"ITEM_ID\")\n  private Long id;\n\n  private String name;\n  private int price;\n  ...\n\n}\n\n@Entity\n@DiscriminatorValue(\"A\")\npublic class Album extends Item {...}\n\n@Entity\n@DiscriminatorValue(\"M\")\npublic class Movie extends Item {...}\n\n@Entity\n@DiscriminatorValue(\"B\")\npublic class Book extends Item {...}\n```\n- 단일 테이블 전략임을 명시한다.\n- 테이블 하나에 모든 것을 통합하기에 **구분 컬럼이 필수적**이다.\n\n**장점**\n- 조인이 필요없어 일반적으로 조회 성능이 빠르다.\n- 조회 쿼리가 단순하다.\n\n**단점**\n- 자식 엔티티가 매핑한 컬럼은 모두 `null` 을 허용해야 한다.\n- 단일 테이블에 모든 것을 저장해 오히려 테이블이 커질 수 있다. 즉, 조회 성능이 느려질 수 있다.\n\n**특징**\n- 구분 컬럼이 필수다. (`@DiscriminatorColumn`)\n- `@DiscriminatorValue` 를 지정하지 않으면 기본으로 엔티티 이름을 사용한다.\n\n### ➰ 구현 클래스마다 테이블 전략\n자식 엔티티마다 테이블을 생성한다. 그리고 자식 테이블 각각에 필요한 컬럼이 모두 있다.\n\n```java\n@Entity\n@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)\npublic abstract class Item {\n\n  @Id @GeneratedValue\n  @Column(name = \"ITEM_ID\")\n  private Long id;\n\n  private String name;\n  private int price;\n  ...\n\n}\n\n@Entity\npublic class Album extends Item {...}\n\n@Entity\npublic class Movie extends Item {...}\n\n@Entity\npublic class Book extends Item {...}\n```\n- 구현 클래스마다 테이블 전략을 사용함을 명시한다.\n- 자식 엔티티마다 테이블을 생성한다.\n\n**장점**\n- 서브 타입을 구분해 처리 시 효과적이다.\n- `NOT NULL` 제약조건을 사용할 수 있다.\n\n**단점**\n- 여러 자식 테이블을 함께 조회할 때 성능이 느리다. (UNION 사용)\n- 자식 테이블을 통합해서 쿼리하기 어렵다.\n\n**특징**\n- 구분 컬럼을 사용하지 않는다.\n\n> 추천하지 않는 전략이다. 조인이나 단일 테이블 전략을 사용하자.\n\n---\n\n## 💫 @MappedSuperclass\n부모 클래스는 테이블과 매핑하지 않고 부모 클래스를 상속받는 자식 클래스에게 매핑 정보만 제공하고 싶다면 `@MappedSuperclass` 를 사용하면 된다.\n- 이는 추상 클래스와 비슷한데, `@Entity` 는 실제 테이블과 매핑되지만, 이는 실제 테이블과는 매핑되지 않는다.\n- 단순히 **매핑 정보를 상속할 목적으로만 사용**된다.\n\n**서로 관계가 없는 테이블**(`Member` & `Seller`)이지만, **공통 속성**을 가지는 두 객체 모델을 부모 클래스로 모으고 **객체 상속 관계**로 만들어보자.\n\n```java\n@MappedSuperclass\npublic abstract class BaseEntity {\n\n  @Id @GeneratedValue\n  private Long id;\n  private String name;\n  ...\n\n}\n\n@Entity\npublic class Member extends BaseEntity {\n\n  // ID 상속\n  // NAME 상속\n  private String email;\n  ...\n\n}\n\n@Entity\npublic class Seller extends BaseEntity {\n  \n  // ID 상속\n  // NAME 상속\n  private String shopName;\n  ...\n\n}\n```\n- `BaseEntity` 에는 객체들이 주로 사용하는 공통 매핑 정보를 정의했다. 자식 엔티티들은 이를 상속해 사용한다.\n- 여기서 `BaseEntity` 는 테이블과 매핑할 필요가 없고 자식 엔티티들에게 공통으로 사용되는 매핑 정보만 제공하고 있다.\n- 상속받은 매핑 정보(여기서는 `id` , `name`)를 재정의하기 위해서는 `@AttributeOverrides` 나 `@AttributeOverride` 를 사용하고, 연관관계를 재정의하기 위해서는 `@AssociationOverrides` 나 `@AssociationOverride` 를 사용한다.\n\n**특징**\n- 테이블과 매핑되지 않고, 자식 클래스에 엔티티의 매핑 정보를 상속하기 위해 사용한다.\n- `@MappedSuperclass` 로 지정한 클래스는 엔티티가 아니므로 `em.find()` 나 JPQL에서 사용할 수 없다.\n- 이 클래스를 직접 생성해 사용할 일은 거의 없어 추상 클래스로 만드는 것을 권장한다.\n\n> 엔티티(`@Entity`)는 엔티티(`@Entity`)이거나 `@MappedSuperclass` 로 지정한 클래스만 상속받을 수 있다.\n\n---\n\n## 💫 복합 키와 식별 관계 매핑\n복합 키를 매핑하는 방법과 식별 관계, 비식별 관계를 매핑하는 방법에 대해 다룬다.\n\n### ➰ 식별 관계 vs 비식별 관계\n이를 구분하는 것은 **외래 키가 기본 키에 포함되는지** 여부이다.\n\n**식별관계**<br/>\n부모 테이블의 기본 키를 내려받아서 자식 테이블의 기본 키 + 외래 키로 사용하는 관계\n\n**비식별 관계**<br/>\n부모 테이블의 기본 키를 받아 자식 테이블의 외래 키로만 사용하는 관계\n\n비식별 관계는 외래 키에 `NULL` 을 허용하는지에 따라 필수적 비식별 관계와 선택적 비식별 관계로 나뉜다.\n- 필수적 비식별 관계(Mandatory) : 외래 키에 `NULL` 을 허용하지 않는다. 연관관계를 필수적으로 맺어야 한다.\n- 선택적 비식별 관계(Optional) : 외래 키에 `NULL` 을 허용한다. 선택적으로 연관관계를 맺는다.\n\n> 최근에는 비식별 관계를 주로 사용하고, 꼭 필요한 곳에만 식별 관계를 사용하는 추세이다. JPA는 두 관계를 모두 지원한다.\n\n### ➰ 복합 키: 비식별 관계 매핑\n기본 키를 구성하는 컬럼이 하나면 단순하게 `@Id` 를 사용해 매핑한다.\n\n```java\n@Entity\npublic class Hello {\n  @Id\n  private String id;\n}\n```\n\n둘 이상의 컬럼으로 구성된 복합 기본 키는 `@Id` 를 각 컬럼에 사용하는 것이 아니라 **별도의 식별자 클래스**가 필요하다.\n\nJPA는 영속성 컨텍스트에 엔티티를 보관할 때 엔티티의 식별자를 키로 사용한다. 그리고 식별자를 구분하기 위해 `equals` 와 `hashCode` 를 사용해 동등성 비교를 한다.\n- 식별자 필드가 하나일 때는 보통 자바의 기본 타입을 사용해 문제가 없다.\n- 2개 이상인 경우 별도의 식별자 클래스를 만들고, `equals` 와 `hashCode` 를 구현해야 한다.\n- JPA는 복합 키 지원을 위해 `@IdClass` 와 `@EmbeddedId` 2가지 방법을 제공한다.\n  - 전자는 관계형 데이터베이스에 가까운 방법이고,\n  - 후자는 객체지향에 좀 더 가까운 방법이다.\n\n**`@IdClass`**<br/>\n비식별 관계의 복합 키 테이블이 있고, `PARENT` 테이블은 복합 기본 키를 사용한다. \n- 기본 키를 `PARENT_ID1` , `PARENT_ID2` 로 묶은 복합 키로 구성했다.\n- 따라서 별도의 식별자 클래스를 사용해 매핑해야 한다.\n\n```java\n@Entity\n@IdClass(ParentId.class)\npublic class Parent {\n\n  @Id\n  @Column(name = \"PARENT_ID1\")\n  private String id1;\n\n  @Id\n  @Column(name = \"PARENT_ID2\")\n  private String id2;\n\n  private String name;\n  ...\n\n}\n```\n- 각각의 기본 키 컬럼을 `@Id` 로 매핑했다. 그리고 `@IdClass` 를 사용해 `ParentId` 클래스를 식별자 클래스로 지정했다.\n\n```java\npublic class ParentId implements Serializable {\n\n  private String id1;\n  private String id2;\n\n  public ParentId() {\n  }\n\n  public ParentId(String id1, String id2) {\n    this.id1 = id1;\n    this.id2 = id2;\n  }\n\n  @Override \n  public boolean equals(Object o) {...}\n\n  @Override\n  public int hashCode() {...}\n}\n```\n\n`@IdClass` 를 사용할 때 식별자 클래스가 만족해야 하는 조건이 있다.\n- 식별자 클래스의 속성명과 엔티티에서 사용하는 식별자의 속성명이 같아야 한다.\n- `Serializable` 인터페이스를 구현해야 한다.\n- `equals` , `hashCode` 를 구현해야 한다.\n- 기본 생성자가 있어야 한다.\n- 식별자 클래스는 `public` 이어야 한다.\n\n실사용 예시이다. 복합 키를 사용하는 엔티티를 저장한다.\n\n```java\nParent parent = new Parent();\nparent.setId1(\"myId1\");\nparent.setId2(\"myId2\");\nparent.setName(\"parentName\");\nem.persist(parent);\n```\n- 식별자 클래스인 `ParentId` 가 보이지 않는다. \n  - `em.persist()` 를 호출하면 영속성 컨텍스트에 엔티티를 등록하기 전 내부에서 `Parent.id1` , `Parent.id2` 값을 사용해 `ParentId` 를 생성하고 영속성 컨텍스트의 키로 사용한다.\n\n복합 키로 조회하는 예시이다.\n\n```java\nParentId parentId = new ParentId(\"myId1\", \"myId2\");\nParent parent = em.find(Parent.class, parentId);\n```\n- 식별자 클래스를 사용해 엔티티를 조회한다.\n\n이제 자식 클래스를 추가한다.\n\n```java\n@Entity\npublic class Child {\n\n  @Id\n  private String id;\n\n  @ManyToOne\n  @JoinColumns({\n          @JoinColumn(name = \"PARENT_ID1\",\n              referencedColumnName = \"PARENT_ID1\"),\n          @JoinColumn(name = \"PARENT_ID2\",\n              referencedColumnName = \"PARENT_ID2\")\n  })\n  private Parent parent;\n}\n```\n- \"부모 테이블의 기본 키 컬럼이 복합 키\"이므로 \"자식 테이블의 외래 키도 복합 키\"다.\n- 따라서 외래 키 매핑 시 여러 컬럼을 매핑해야 하므로 `@JoinColumns` 를 사용하고 각각의 외래 키 컬럼을 `@JoinColumn` 으로 매핑했다.\n\n> `@JoinColumn` 의 `name` 속성과 `referencedColumnName` 속성의 값이 같다면 `referencedColumnName` 은 생략 가능하다.\n\n**`@EmbeddedId`**<br/>\n좀 더 객체지향적인 방법이다.\n\n```java\n@Entity\npublic class Parent {\n\n  @EmbeddedId\n  private ParentId id;\n\n  private String name;\n  ...\n\n}\n```\n- `Parent` 엔티티에서 식별자 클래스를 직접 사용하고, `@EmbeddedId` 을 사용한다.\n\n```java\n@Embeddable\npublic class ParentId implements Serializable {\n\n  @Column(name = \"PARENT_ID1\")\n  private String id1;\n  @Column(name = \"PARENT_ID2\")\n  private String id2;\n\n  // equals, hashCode 구현\n  ...\n\n}\n```\n- **식별자 클래스에 기본 키를 직접 매핑**한다.\n\n`@EmbeddedId` 를 사용할 때 식별자 클래스가 만족해야 하는 조건이 있다.\n- `@Embeddable` annotation을 붙여야 한다.\n- `Serializable` 인터페이스를 구현해야 한다.\n- `equals` , `hashCode` 를 구현해야 한다.\n- 기본 생성자가 있어야 한다.\n- 식별자 클래스는 `public` 이어야 한다.\n\n`@EmbeddedId` 를 사용해 엔티티를 저장한다.\n\n```java\nParent parent = new Parent();\nParentId parentId = new ParentId(\"myId1\", \"myId2\");\nparent.setId(parentId);\nparent.setName(\"parentName\");\nem.persist(parent);\n```\n\n- 식별자 클래스를 직접 생성해 사용한다.\n\n엔티티를 조회하는 예시이다. 조회 역시 식별자 클래스를 직접 사용한다.\n\n```java\nParentId parentId = new ParentId(\"myId1\", \"myId2\");\nParent parent = em.find(Parent.class, parentId);\n```\n\n**복합 키와 `equals()` , `hashCode()`**<br/>\n복합 키는 해당 메소드들을 필수로 구현해야 한다.\n\n```java\nParentId id1 = new ParentId();\nid1.setId1(\"myId1\");\nid1.setId2(\"myId2\");\n\nParentId id2 = new ParentId();\nid2.setId1(\"myId1\");\nid2.setId2(\"myId2\");\n\nid1.equals(id2) -> ???\n```\n- 생성한 두 인스턴스 모두 같은 값을 가지고 있지만, 인스턴스 자체는 다르다.\n- 따라서 `equals()` 를 적절히 오버라이딩하지 않았다면 결과는 거짓이다.\n  - 자바의 모든 클래스는 기본으로 `Object` 클래스를 상속받는데, 이 클래스가 제공하는 **기본 `equals()` 는 인스턴스 참조 값 비교인 == 비교(동일성 비교)를 하기 때문**이다.\n- 영속성 컨텍스트는 엔티티의 식별자를 키로 사용해 엔티티를 관리한다. 그리고 식별자 비교에 `equals()` 와 `hashCode()` 를 사용한다.\n  - 따라서 식별자 객체의 동등성이 지켜지지 않으면 엔티티 관리에 문제가 발생하고, 이것이 위 메소드들의 필수적인 구현이 필요한 이유이다.\n\n**`@IdClass` vs `@EmbeddedId`**<br/>\n둘 다 장단점이 있어 취향껏 사용하면 된다.\n\n> 복합 키를 구성하는 여러 컬럼 중 어느 하나에도 `@GeneratedValue` 를 사용할 수 없다.\n\n### ➰ 복합 키: 식별 관계 매핑\n부모, 자식, 손자까지 계속 기본 키를 전달하는 식별 관계가 있을 시, 식별 관계에서 자식 테이블은 부모 테이블의 기본 키를 포함해 복합 키를 구성해야 해서 `@IdClass` , `@EmbeddedId` 중 하나를 사용해 식별자를 매핑해야 한다.\n\n**`@IdClass` 와 식별 관계**<br/>\n```java\n@Entity\npublic class Parent {\n\n  @Id @Column(name = \"PARENT_ID\")\n  private String id;\n  private String name;\n  ...\n\n}\n\n@Entity\n@IdClass(ChildId.class)\npublic class Child {\n\n  @Id\n  @ManyToOne\n  @JoinColumn(name = \"PARENT_ID\")\n  public Parent parent;\n\n  @Id @Column(name = \"CHILD_ID\")\n  private String childId;\n\n  private String name;\n  ...\n\n}\n\n// 자식 ID\npublic class ChildId implements Serializable {\n\n  private String parent;\n  private String childId;\n\n  // equals, hashCode\n  ...\n\n}\n\n@Entity\n@IdClass(GrandChildId.class)\npublic class GrandChild {\n\n  @Id\n  @ManyToOne\n  @JoinColumns({\n          @JoinColumn(name = \"PARENT_ID\"),\n          @JoinColumn(name = \"CHILD_ID\")\n  })\n  private Child child;\n\n  @Id @Column(name = \"GRANDCHILD_ID\")\n  private String id;\n\n  private String name;\n  ...\n\n}\n\n// 손자 ID\npublic class GrandChildId implements Serializable {\n\n  private ChildId child;\n  private String id;\n\n  // equals, hashCode\n  ... \n\n}\n```\n- 식별 관계는 기본 키와 외래 키를 같이 매핑해야 한다. 따라서 식별자 매핑인 `@Id` 와 연관관계 매핑인 `@ManyToOne` 을 같이 사용한다.\n- `Child` 엔티티의 `parent` 필드에서 이를 구현하고 있다.\n\n**`@EmbeddedId` 와 식별 관계**<br/>\n`@MapsId` 를 사용해야 한다.\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @Column(name = \"PARENT_ID\")\n  private String id;\n\n  private String name;\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @EmbeddedId\n  private String childId;\n\n  @MapsId(\"parentId\")\n  @ManyToOne\n  @JoinColumn(name = \"PARENT_ID\")\n  public Parent parent;\n\n  private String name;\n  ...\n\n}\n\n// 자식 ID\n@Embeddable\npublic class ChildId implements Serializable {\n\n  private String parentId;\n\n  @Column(name = \"CHILD_ID\")\n  private String id;\n\n  // equals, hashCode\n  ...\n\n}\n\n@Entity\npublic class GrandChild {\n\n  @EmbeddedId\n  private GrandChildId id;\n\n  @MapsId(\"childId\")\n  @ManyToOne\n  @JoinColumns({\n          @JoinColumn(name = \"PARENT_ID\"),\n          @JoinColumn(name = \"CHILD_ID\")\n  })\n  private Child child;\n\n  private String name;\n  ...\n\n}\n\n// 손자 ID\n@Embeddable\npublic class GrandChildId implements Serializable {\n\n  private ChildId childId;\n\n  @Column(name = \"GRANDCHILD_ID\")\n  private String id;\n\n  // equals, hashCode\n  ... \n\n}\n```\n- `@EmbeddedId` 는 식별 관계로 사용할 연관관계의 속성에 `@MapsId` 를 사용하면 된다. `Child` 엔티티의 `parent` 필드에서 이를 구현하고 있다.\n\n> `@IdClass` 와 다른 점은 `@Id` 대신 `@MapsId` 를 사용했다는 것이다. 이는 외래 키와 매핑한 연관관계를 기본 키에도 매핑하겠다는 뜻이다. 해당 annotation의 속성 값은 `@EmbeddedId` 를 사용한 식별자 클래스의 기본 키 필드를 지정하면 된다.\n\n### ➰ 비식별 관계로 구현\n위에서 예로 들었던 식별 관계 테이블을 비식별 관계로 변경해보자.\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @GeneratedValue \n  @Column(name = \"PARENT_ID\")\n  private Long id;\n  private String name;\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = \"CHILD_ID\")\n  private Long id;\n  private String name;\n\n  @ManyToOne\n  @JoinColumn(name = \"PARENT_ID\")\n  private Parent parent;\n  ...\n\n}\n\n@Entity\npublic class GrandChild {\n\n  @Id @GeneratedValue\n  @Column(name = \"GRANDCHILD_ID\")\n  private Long id;\n  private String name;\n\n  @ManyToOne\n  @JoinColumn(name = \"CHILD_ID\")\n  private Child child;\n  ...\n\n}\n```\n- 식별 관계보다 매핑도 쉽고 단순하다. 그리고 복합 키가 없어 복합 키 클래스를 만들지 않아도 된다.\n\n### ➰ 일대일 식별 관계\n이는 자식 테이블의 기본 키 값으로 **부모 테이블의 기본 키 값만 사용**한다. \n- 부모 테이블의 기본 키가 복합 키가 아니라면, 자식 테이블의 기본 키는 복합 키로 구성하지 않아도 된다.\n\n```java\n// 부모\n@Entity\npublic class Board {\n\n  @Id @GeneratedValue\n  @Column(name = \"BOARD_ID\")\n  private Long id;\n\n  private String title;\n\n  @OneToOne(mappedBy = \"board\")\n  private BoardDetail boardDetail;\n  ...\n\n}\n\n// 자식\n@Entity\npublic class BoardDetail {\n\n  @Id\n  private Long boardId;\n\n  @MapsId\n  @OneToOne\n  @JoinColumn(name = \"BOARD_ID\")\n  private Board board;\n\n  private String content;\n  ...\n\n}\n```\n- 위 자식 엔티티처럼 식별자가 단순히 컬럼 하나면, `@MapsId` 를 사용하고 속성 값은 비워두면 된다.\n  - 이때 `@MapsId` 는 `@Id` 를 사용해 식별자로 지정한 `BoardDetail.boardId` 와 매핑된다.\n\n### ➰ 식별, 비식별 관계의 장단점\n아래와 같은 이유로 데이터베이스 설계 관점에서 식별 관계보다는 비식별 관계를 선호한다.\n\n- 식별 관계는 부모 테이블의 기본 키를 자식 테이블로 전파하면서 자식 테이블의 기본 키 컬럼이 점점 늘어나게 한다.\n  - 이는 결국 조인 시의 SQL을 복잡하게 만들고, 기본 키 인덱스가 불필요하게 커질 수 있도록 한다.\n- 식별 관계는 2개 이상의 컬럼을 합해 복합 기본 키를 만들어야 하는 경우가 많다.\n- 식별 관계를 사용할 때, 기본 키로 비즈니스 의미가 있는 자연 키 컬럼을 조합하는 경우가 많다. 반면 비식별 관계의 기본 키는 비즈니스와 전혀 관계없는 대리 키를 주로 사용한다.\n  - 비즈니스 요구사항은 시간이 지남에 따라 언젠가는 변하기에 식별 관계의 자연 키 컬럼들이 많이 전파될수록 변경이 어렵다.\n- 식별관계는 부모 테이블의 기본 키를 자식 테이블의 기본 키로 사용해 테이블 구조가 유연하지 못하다.\n\n객체 관계 매핑 관점에서는 다음 이유로 비식별 관계를 선호한다.\n- 일대일 관계를 제외하고 식별 관계는 2개 이상의 컬럼을 묶은 복합 기본 키를 사용한다. JPA에서 복합 키는 별도의 복합 키 클래스를 만들어 사용해야 한다.\n  - 따라서 컬럼이 하나인 기본 키를 매핑하는 것보다 많은 노력이 필요하다.\n- 비식별 관계의 기본 키는 주로 대리 키를 사용하는데, JPA는 `@GeneratedValue` 와 같은 편리한 방법을 제공한다.\n\n물론 식별 관계의 장점도 있다.\n- 기본 키 인덱스의 활용성이 좋고,\n- 상위 테이블들의 기본 키 컬럼을 자식, 손자 테이블들이 가지고 있어 특정 상황에 조인 없이 하위 테이블만으로 검색을 완료할 수 있다.\n\n> ORM 신규 프로젝트 진행 시 추천하는 방법은 가능한 **비식별 관계를 사용하고 기본 키는 `Long` 타입의 대리 키를 사용하는 것**이다.\n\n---\n\n## 💫 조인 테이블\n데이터베이스 테이블의 연관관계를 설계하는 방법은 크게 2가지다.\n- 조인 컬럼 사용(외래 키)\n- 조인 테이블 사용(테이블 사용)\n\n**조인 컬럼 사용**<br/>\n테이블 간에 관계는 주로 조인 컬럼이라 부르는 외래 키 컬럼을 사용해서 관리한다. \n\n예를 들어 회원과 사물함이 있다. \n- 회원이 원할 때 사물함을 선택할 수 있다는 가정이 있다면, 회원이 사물함을 사용하기 전까진 둘 사이에 관계가 없어 `MEMBER` 테이블의 `LOCKER_ID` 외래 키에는 `null` 값을 입력해야 한다.\n  - 이렇게 외래 키에 `null` 을 허용하는 관계를 이전에 **선택적 비식별 관계**라 했다.\n\n선택적 비식별 관계는 이러한 특성으로 조인 시 **외부 조인(OUTER JOIN)**을 사용해야 한다.\n\n**조인 테이블 사용**<br/>\n별도의 테이블을 사용해서 연관관계를 관리하는 방법이다.\n\n조인 컬럼을 사용하는 방법은 단순히 외래 키 컬럼만 추가해 연관관계를 맺지만, 조인 테이블을 사용하는 방법은 연관관계를 관리하는 조인 테이블을 추가하고, 여기서 두 테이블의 외래 키를 가지고 연관관계를 관리한다.\n- 따라서, **두 테이블에는 연관관계 관리를 위한 외래 키 컬럼이 없다.**\n\n추가적인 테이블을 생성해야 한다는 것이 가장 큰 단점이다.\n- 관리해야 할 테이블이 늘어나고, 두 테이블의 조인을 위해 총 3개의 테이블이 조인되어야 한다. \n\n> 객체와 테이블을 매핑할 때 조인 컬럼 -> `@JoinColumn` , 조인 테이블 -> `@JoinTable` 로 매핑한다.\n\n### ➰ 일대일 조인 테이블\n(두 테이블의) 일대일 관계를 관리하기 위해서는 조인 테이블의 외래 키 컬럼 각각에 총 2개의 유니크 제약조건을 걸어야 한다. (`PARENT` - `PARENT_CHILD` , `CHILD`)\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = \"PARENT_ID\")\n  private Long id;\n  private String name;\n\n  @OneToOne\n  @JoinTable(name = \"PARENT_CHILD\",\n          joinColumns = @JoinColumn(name = \"PARENT_ID\"),\n          inverserJoinColumns = @JoinColumn(name = \"CHILD_ID\")\n  )\n  private Child child;\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = \"CHLID_ID\")\n  private Long id;\n  private String name;\n  ...\n\n}\n```\n- 부모 엔티티는 `@JoinTable` 을 사용하고 있다.\n  - `name` : 매핑할 조인 테이블 이름\n  - `joinColumns` : 현재 엔티티를 참조하는 외래 키\n  - `inverseJoinColumns` : 반대방향 엔티티를 참조하는 외래 키\n\n> 양방향 매핑을 위해서는 자식 엔티티에 `parent` 필드를 생성하고, `@OneToOne` annotation을 사용하면 된다.\n\n### ➰ 일대다 조인 테이블\n일대다 관계를 만들려면 조인 테이블의 컬럼 중 **다(N)와 관련된 컬럼에 유니크 제약조건**을 걸어야 한다.\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = \"PARENT_ID\")\n  private Long id;\n  private String name;\n\n  @OneToMany\n  @JoinTable(name = \"PARENT_CHILD\",\n          joinColumns = @JoinColumn(name = \"PARENT_ID\"),\n          inverserJoinColumns = @JoinColumn(name = \"CHILD_ID\")\n  )\n  private List<Child> child = new ArrayList<>();\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = \"CHLID_ID\")\n  private Long id;\n  private String name;\n  ...\n\n}\n```\n\n### ➰ 다대일 조인 테이블\n일대다에서 방향만 반대이다!\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = \"PARENT_ID\")\n  private Long id;\n  private String name;\n\n  @OneToMany(mappedBy = \"parent\")\n  private List<Child> child = new ArrayList<>();\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = \"CHLID_ID\")\n  private Long id;\n  private String name;\n\n  @ManyToOne(optional = false)\n  @JoinTable(name = \"PARENT_CHILD\",\n          joinColumns = @JoinColumn(name = \"CHILD_ID\"),\n          inverserJoinColumns = @JoinColumn(name = \"PARENT_ID\")\n  )\n  private Parent parent;\n  ...\n\n}\n```\n\n### ➰ 다대다 조인 테이블\n다대다 관계를 만들기 위해서는 조인 테이블의 두 컬럼을 합해 하나의 복합 유니크 제약조건을 걸어야 한다.\n\n```java\n@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = \"PARENT_ID\")\n  private Long id;\n  private String name;\n\n  @ManyToMany\n  @JoinTable(name = \"PARENT_CHILD\",\n          joinColumns = @JoinColumn(name = \"PARENT_ID\"),\n          inverserJoinColumns = @JoinColumn(name = \"CHILD_ID\")\n  )\n  private List<Child> child = new ArrayList<>();\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = \"CHLID_ID\")\n  private Long id;\n  private String name;\n  ...\n\n}\n```\n\n> 조인 테이블에 컬럼을 추가하면 `@JoinTable` 전략을 사용할 수 없다. 대신 새로운 엔티티를 만들어 조인 테이블과 매핑해야 한다.\n\n---\n\n## 💫 엔티티 하나에 여러 테이블 매핑\n잘 사용하지는 않지만 `@SecondaryTable` 을 사용하면 한 엔티티에 여러 테이블을 매핑할 수 있다.\n\n```java\n@Entity\n@Table(name = \"BOARD\")\n@SecondaryTable(name = \"BOARD_DETAIL\",\n    pkJoinColumns = @PrimaryKeyJoinColumn(name = \"BOARD_DETAIL_ID\"))\npublic class Board {\n\n  @Id @GeneratedValue\n  @Column(name = \"BOARD_ID\")\n  private Long id;\n\n  private String title;\n\n  @Column(table = \"BOARD_DETAIL\")\n  private String content;\n  ...\n\n}\n```\n- `Board` 엔티티는 `@Table` 로 `BOARD` 테이블과 매핑했고, 추가로 `@SecondaryTable` 를 사용해 `BOARD_DETAIL` 테이블과 매핑했다.\n  - `@SecondaryTable.name` : 매핑할 다른 테이블의 이름\n  - `@SecondaryTable. pkJoinColumns` : 매핑할 다른 테이블의 기본 키 컬럼 속성\n- `@SecondaryTables` 에 `@SecondaryTable` 를 여러 개 사용하여 추가로 테이블들과 매핑할 수도 있다.\n\n> 하나의 엔티티에 여러 테이블을 매핑하는 것은 항상 두 테이블을 조회하기에 최적화가 어렵다. 따라서 테이블당 엔티티를 생성해 일대일 매핑하는 것을 권장한다.\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 다중성과 단방향, 양방향을 고려한 가능한 모든 연관관계를 하나씩 알아본다. 다대일 : 단방향, 양방향 일대다 : 단방향, 양방향 일대일 : 주 테이블 단방향, 양방향 일대일 : 대상 테이블 단방향, 양방향 다대다 : 단방향, 양방향 💫 다대일 다대일 관계의 반대 방향 …","fields":{"slug":"/[JPA]6/"},"frontmatter":{"date":"March 16, 2022","title":"📚 6. 다양한 연관관계 매핑","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 다중성과 단방향, 양방향을 고려한 가능한 모든 연관관계를 하나씩 알아본다.\n> - 다대일 : 단방향, 양방향\n> - 일대다 : 단방향, 양방향\n> - 일대일 : 주 테이블 단방향, 양방향\n> - 일대일 : 대상 테이블 단방향, 양방향\n> - 다대다 : 단방향, 양방향\n\n## 💫 다대일\n다대일 관계의 반대 방향 = 일대다 관계, 역 또한 성립한다. 데이터베이스 테이블의 일(1), 다(N) 관계에서 외래 키는 항상 **다쪽에** 있다. 따라서 객체 양방향 관계에서 연관관계의 주인은 항상 다쪽이다.\n\n### ➰ 다대일 단방향[N:1]\n\n```java\n@Entity\npublic class Member {\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private Long id;\n\n  private String username;\n\n  @ManyToOne\n  @JoinColumn(name = \"TEAM_ID\")\n  private Team team; \n  ...\n\n}\n```\n\n```java\n@Entity\npublic class Team {\n\n  @Id @GeneratedValue\n  @Column(name = \"TEAM_ID\")\n  private Long id;\n\n  private String name;\n  ...\n\n}\n```\n\n회원은 `Member.team` 으로 팀 엔티티를 참조할 수 있지만 팀에는 회원을 참조하는 필드가 없다 (**회원과 팀은 다대일 단방향 연관관계**)\n\n### ➰ 다대일 양방향[N:1, 1:N]\n아래 예시 연관관계의 주인은 `Member.team` 이고 `Team.members` 는 주인이 아니다.\n\n```java\n@Entity\npublic class Member {\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private Long id;\n\n  private String username;\n\n  @ManyToOne\n  @JoinColumn(name = \"TEAM_ID\")\n  private Team team; \n  \n  public void setTeam(Team team) {\n    this.team = team;\n\n    if (!team.getMembers().contains(this)) {\n      team.getMembers().add(this);\n    }\n  }\n}\n```\n\n```java\n@Entity\npublic class Team {\n\n  @Id @GeneratedValue\n  @Column(name = \"TEAM_ID\")\n  private Long id;\n\n  private String name;\n  \n  @OneToMany(mappedBy = \"team\")\n  private List<Member> members = new ArrayList<Member>();\n\n  public void addMember(Member member) {\n    this.members.add(member);\n    if (member.getTeam() != this) {\n      member.setTeam(this);\n    }\n  }\n  ...\n\n}\n```\n\n**양방향은 외래 키가 있는 쪽이 연관관계의 주인이다.**<br/>\n일대다와 다대일 연관관계는 항상 다쪽에 외래 키가 있다. 따라서 다쪽이 연관관계의 주인이다. JPA는 외래 키를 관리할 때 연관관계의 주인만 사용하고, 주인이 아닌 필드는 조회를 위한 JPQL이나 객체 그래프 탐색 시에 사용한다.\n\n**양방향 연관관계는 항상 서로를 참조해야 한다.**<br/>\n어느 한 쪽만 참조하면 양방향 연관관계가 성립하지 않는다. 항상 서로를 참조하기 위해서는 연관관계 편의 메소드를 작성하는 것이 좋다. (이전 장 확인) 양쪽에 모두 작성하더라도 무한 루프에 빠지지 않도록 주의해야 한다.\n\n---\n\n## 💫 일대다\n다대일 관계의 반대 방향이다. 이 관계는 엔티티를 하나 이상 참조할 수 있으므로 자바 컬렉션 중 하나를 사용해야 한다.\n\n### ➰ 일대다 단방향 [1:N]\n\"하나의 팀이 여러 회원을 참조한다.\" 와 같은 관계를 일대다 관계라 한다. 그리고 팀은 회원들을 참조하지만 회원은 팀을 참조하지 않으면 단방향 관계이다. \n\n일대다 단방향 관계는 자신이 매핑한 테이블의 외래 키를 관리하지 않고, 반대쪽 테이블에 있는 외래 키를 관리한다. \n- 일대다 관계에서 외래 키는 항상 다쪽 테이블에 있다. \n- 하지만 다쪽 엔티티에는 외래 키를 매핑할 수 있는 참조 필드가 없다. 대신 반대쪽 엔티티에만 참조 필드가 있다.\n\n```java\n@Entity\npublic class Team {\n\n  @Id @GeneratedValue\n  @Column(name = \"TEAM_ID\")\n  private Long id;\n\n  private String name;\n  \n  @OneToMany\n  @JoinColumn(name = \"TEAM_ID\") // MEMBER 테이블의 TEAM_ID (FK)\n  private List<Member> members = new ArrayList<>();\n  ...\n\n}\n```\n\n```java\n@Entity\npublic class Member {\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private Long id;\n\n  private String username;\n  ...\n\n}\n```\n\n일대다 단방향 관계 매핑 시에는 `@JoinColumn` 을 명시해야 한다. 그렇지 않은 경우 JPA는 연결 테이블을 중간에 두고 연관관계를 관리하는 조인 테이블 전략을 기본으로 사용해 매핑한다.\n\n**일대다 단방향 매핑의 단점**<br/>\n매핑한 객체가 관리하는 외래 키가 다른 테이블에 존재한다는 것이다. \n- 본인 테이블에 있는 경우 INSERT SQL 한 번으로 끝낼 엔티티의 저장과 연관관계 처리가, 추가적인 UPDATE SQL이 필요해졌다.\n\n```java\npublic void testSave() {\n  Member member1 = new Member(\"member1\");\n  Member member2 = new Member(\"member2\");\n\n  Team team1 = new Team(\"team1\");\n  team1.getMembers().add(member1);\n  team1.getMembers().add(member2);\n\n  em.persist(member1);\n  em.persist(member2);\n  em.persist(team1);\n\n  transaction.commit();\n}\n```\n\n- `Member` 엔티티는 `Team` 엔티티를 모른다. 그리고 연관관계에 대한 정보는 `Team` 엔티티의 `members` 가 관리한다. \n- 따라서 `Member` 엔티티를 저장할 땐 `MEMBER` 테이블의 `TEAM_ID` 외래 키에 아무 값도 저장되지 않는다. \n- 대신 `Team` 엔티티 저장 시 참조 값을 확인해 `MEMBER` 테이블을 업데이트하게 된다.\n\n**일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자**<br/>\n위 단점에 따라 성능 문제도 있지만 관리도 부담스럽다. 문제 해결을 위해 다대일 양방향 매핑을 대신 사용한다.\n- 다대일 양방향 매핑은 관리해야 하는 외래 키가 본인 테이블에 있다.\n- 두 매핑의 테이블 모양은 완전히 동일하므로 약간의 엔티티 수정으로 구현가능하다.\n\n### ➰ 일대다 양방향 [1:N, N:1]\n일대다 양방향 매핑은 존재하지 않는다. 대신 다대일 양방향 매핑을 사용해야 한다. (여기서는 왼쪽을 연관관계의 주인으로 가정)\n- 더 정확히는 양방향 매핑에서 `@OneToMany` 는 연관관계의 주인이 될 수 없다. \n  - 왜냐면 관계형 데이터베이스의 특성상 일대다, 다대일 관계는 항상 다쪽에 외래 키가 있다.\n  - 따라서, 둘 중 연관관계의 주인은 항상 다쪽인 `@ManyToOne` 을 사용한 곳이다. \n  - 이러한 이유로 `@ManyToOne` 에는 `mappedBy` 속성이 없다.\n\n하지만 일대다 단방향 매핑 반대편에 같은 외래 키를 사용하는 다대일 단방향 매핑을 읽기 전용으로 추가해 일대다 양방향 매핑이 가능하다.\n\n```java\n@Entity\npublic class Team {\n\n  @Id @GeneratedValue\n  @Column(name = \"TEAM_ID\")\n  private Long id;\n\n  private String name;\n  \n  @OneToMany\n  @JoinColumn(name = \"TEAM_ID\")\n  private List<Member> members = new ArrayList<>();\n  ...\n\n}\n```\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private Long id;\n\n  private String username;\n\n  @ManyToOne\n  @JoinColumn(name = \"TEAM_ID\", insertable = false, updatable = false)\n  private Team team;\n  ...\n\n}\n```\n\n반대쪽 엔티티에 같은 외래 키를 사용하는 다대일 단방향 매핑을 추가했다. 그리고 `insertable` , `updatable` 속성을 `false` 로 설정해 읽기만 가능하게 했다.\n- 일대다 양방향 매핑이라기보단 일대다 단방향 매핑 반대편에 다대일 단방향 매핑을 읽기 전용으로 추가해 일대다 양방향처럼 보이게 한 것이다.\n- 따라서 일대다 단방향 매핑이 가지는 단점을 그대로 가진다.\n\n---\n\n## 💫 일대일[1:1]\n양쪽이 서로 하나의 관계만 가진다.\n- 일대일 관계는 그 반대도 일대일 관계다.\n- 테이블 관계에서 일대다, 다대일은 항상 다쪽이 외래 키를 가지는데, 일대일 관계는 주 테이블이나 대상 테이블 둘 중 어느 곳이나 외래 키를 가질 수 있다.\n  - 양쪽으로 조회가 가능하다.\n\n**주 테이블에 외래 키**<br/>\n주 객체가 대상 객체를 참조하는 것처럼 대상 테이블을 참조한다. 외래 키를 객체 참조와 비슷하게 사용할 수 있고, 주 테이블만 확인해도 대상 테이블과 연관관계가 있는지 알 수 있다.\n\n**대상 테이블에 외래 키**<br/>\n테이블 관계를 일대일에서 일대다로 변경할 떄 테이블 구조를 그대로 유지할 수 있다는 장점이 있다.\n\n### ➰ 주 테이블에 외래 키\nJPA도 주 테이블에 외래 키가 있으면 좀 더 편리하게 매핑할 수 있다. (객체지향 개발자들은 이를 선호)\n\n**단방향**\n- `MEMBER` 가 주 테이블, `LOCKER` 가 대상 테이블\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private Long id;\n\n  private String username;\n\n  @OneToOne\n  @JoinColumn(name = \"LOCKER_ID\")\n  private Locker locker;\n  ...\n\n}\n\n@Entity\npublic class Locker {\n\n  @Id @GeneratedValue\n  @Column(name = \"LOCKER_ID\")\n  private Long id;\n\n  private String name;\n  ...\n\n}\n```\n\n**양방향**<br/>\n단방향에 반대 방향을 추가해 구현 가능하다.\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private Long id;\n\n  private String username;\n\n  @OneToOne\n  @JoinColumn(name = \"LOCKER_ID\")\n  private Locker locker;\n  ...\n\n}\n\n@Entity\npublic class Locker {\n\n  @Id @GeneratedValue\n  @Column(name = \"LOCKER_ID\")\n  private Long id;\n\n  private String name;\n  \n  @OneToOne(mappedBy = \"locker\")\n  private Member member;\n  ...\n\n}\n```\n- 양방향이므로 연관관계의 주인을 정할 필요가 있다. 외래 키를 가지고 있는 `Member` 엔티티의 `locker` 가 연관관계의 주인이다.\n  - 따라서 `mappedBy` 속성 설정!\n\n### ➰ 대상 테이블에 외래 키\n**단뱡항**<br/>\n일대일 관계 중 대상 테이블에 외래 키가 있는 단방향 관계는 JPA에서 지원하지 않는다. 그리고 매핑할 방법도 없다. \n- 단방향 관계의 방향을 수정하거나, 양방향 관계로 만들고 연관관계의 주인을 수정해야 한다.\n\n**양방향**<br/>\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private Long id;\n\n  private String username;\n\n  @OneToOne\n  @JoinColumn(name = \"member\")\n  private Locker locker;\n  ...\n\n}\n\n@Entity\npublic class Locker {\n\n  @Id @GeneratedValue\n  @Column(name = \"LOCKER_ID\")\n  private Long id;\n\n  private String name;\n  \n  @OneToOne(mappedBy = \"MEMBER_ID\")\n  private Member member;\n  ...\n\n}\n```\n\n일대일 매핑에서 대상 테이블에 외래 키를 두고 싶다면 위와 같이 양방향 매핑해야 한다. \n- 대상 엔티티인 `Locker` 를 연관관계의 주인으로 만들고,\n- `LOCKER` 테이블의 외래 키를 관리하도록 했다.\n\n---\n\n## 💫 다대다\n관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다. \n- 그래서 보통 다대다 관계를 일대다, 다대일 관계로 풀어내는 **연결 테이블을 사용**한다.\n\n하지만 객체는 테이블과 달리 객체 2개로 다대다 관계 표현이 가능하다. \n- 컬렉션을 사용해 상대 엔티티를 참조할 수 있다.\n- `@ManyToMany` 사용\n\n### ➰ 다대다: 단방향\n다대다 단방향 관계인 회원과 상품 엔티티 예제\n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private String id;\n\n  private String username;\n\n  @ManyToMany\n  @JoinTable(name = \"MEMBER_PRODUCT\", joinColumns = @JoinColumn(name = \"MEMBER_ID\"), inverseJoinColumns = @JoinColumn(name = \"PRODUCT_ID\"))\n  private List<Product> products = new ArrayList<>();\n  ...\n\n}\n```\n\n```java\n@Entity\npublic class Product {\n\n  @Id @GeneratedValue\n  @Column(name = \"PRODUCT_ID\")\n  private String id;\n\n  private String name;\n}\n```\n\n두 엔티티를 `@ManyToMany` 로 매핑했다. 중요한 점은 **`@ManyToMany` 와 `@JoinTable` 을 사용해 연결 테이블을 바로 매핑**한 것이다.\n- `@JoinTable.name` : 연결 테이블 지정\n- `@JoinTable.joinColumns` : 현재 방향인 회원과 매핑할 조인 컬럼 정보를 지정\n- `@JoinTable.inverseJoinColumns` : 반대 방향인 상품과 매핑할 조인 컬럼 정보 지정\n\n다음은 다대다 관계를 저장하는 예제이다.\n\n```java\npublic void save() {\n\n  Product productA = new Product();\n  productA.setId(\"productA\");\n  productA.setName(\"상품A\");\n  em.persist(productA);\n\n  Member member1 = new Member();\n  member1.setId(\"member1\");\n  member1.setUsername(\"회원1\");\n  member1.getProducts().add(productA); // 연관관계 설정\n  em.persist(member1);\n}\n```\n\n두 엔티티 간 연관관계를 지정했으므로, `회원1`을 저장할 때 연결 테이블에도 값이 저장된다. \n- 따라서 `PRODUCT` , `MEMBER` , `MEMBER_PRODUCT` 테이블 모두에 대한 INSERT SQL이 전달된다.\n\n`member.getProducts()` 를 호출해 상품 이름 조회 시, 연결 테이블인 `MEMBER_PRODUCT` 와 상품 테이블을 조인해 객체 그래프 탐색을 수행한다.\n\n**연관관계의 주인만이 데이터베이스 연관관계와 매핑되고, 외래 키를 관리(등록, 수정, 삭제)할 수 있다. 반면에 주인이 아닌 쪽은 읽기만 가능하다.**\n\n### ➰ 다대다: 양방향\n양방향을 만들기 위해 다대다 매핑이므로 역방향도 `@ManyToMany` 를 사용한다. 그리고 원하는 곳에 `mappedBy` 로 연관관계의 주인을 지정한다. (`mappedBy` 가 없는 곳이 주인!)\n\n```java\n@Entity\npublic class Product {\n\n  @Id\n  private String id;\n\n  @ManyToMany(mappedBy = \"products\")\n  private List<Member> members;\n  ...\n\n}\n```\n\n다대다의 양방향 연관관계는 다음처럼 설정한다.\n\n```java\nmember.getProducts().add(product);\nproduct.getMembers().add(member);\n```\n\n> 그리고 양방향 연관관계는 **연관관계 편의 메소드를 추가**해 관리하는 것이 편리하다.\n\n양방향 연관관계를 만들었으므로, `product.getMembers()` 를 사용해 역방향으로 객체 그래프 탐색이 가능해졌다.\n\n### ➰ 다대다: 매핑의 한계와 극복, 연결 엔티티 사용\n다대다 annotation을 통해 자동 연결 테이블을 처리해 도메인 모델이 단순해지고 여러 가지로 편리해졌다. \n- 하지만 실사용에는 한계가 있다. \n  - 회원이 상품을 주문하면 연결 테이블에 단순히 주문한 회원 아이디와 상품 아이디만 담고 끝나지 않는다. 보통은 연결 테이블에 주문 수량 컬럼이나 주문한 날짜 같은 컬럼이 더 필요하다.\n  - 그렇다고 해서, 연결 테이블에 컬럼들을 추가하게 되면, 더는 `@ManyToMany` 를 사용할 수 없다.\n  - > 주문 엔티티나 상품 엔티티에는 추가한 컬럼들을 매핑할 수 없기 때문이다!\n- 따라서 연결 테이블을 매핑하는 연결 엔티티를 만들고 이곳에 추가한 컬럼들을 매핑해야 한다. \n- 또한 엔티티 간의 관계도 테이블 관계처럼 다대다에서 일대다, 다대일로 풀어야 한다. \n\n```java\n@Entity\npublic class Member {\n\n  @Id @GeneratedValue\n  @Column(name = \"MEMBER_ID\")\n  private String id;\n\n  private String username;\n\n  @OneToMany (mappedBy = \"member\")\n  private List<MemberProduct> memberProducts;\n  ...\n\n}\n```\n\n회원과 회원상품을 양방향 관계로 만들었다. \n- 회원상품 엔티티쪽이 외래 키를 가지므로 연관관계의 주인이다. (따라서 `mappedBy` 사용)\n\n```java\n@Entity\npublic class Product {\n\n  @Id @Column(name = \"PRODUCT_ID\")\n  private String id;\n\n  private String name;\n  ...\n\n}\n```\n\n상품 엔티티에서 회원상품 엔티티로 객체 그래프 탐색 기능이 필요하지 않아 연관관계 미생성\n\n```java\n@Entity\n@IdClass(MemberProductId.class)\npublic class MemberProduct {\n\n  @Id \n  @ManyToOne\n  @JoinColumn(name = \"MEMBER_ID\")\n  private Member member;\n\n  @Id \n  @ManyToOne\n  @JoinColumn(name = \"PRODUCT_ID\")\n  private Product product;\n\n  private int orderAmount;\n  ...\n\n}\n```\n\n```java\npublic class MemberProductId implements Serializable {\n  private String member;\n  private String product;\n\n  @Override\n  public boolean equals(Object o) {...}\n\n  @Override\n  public int hashCode() {...}\n}\n```\n\n회원상품 엔티티를 보면, 기본 키를 매핑하는 `@Id` 와 외래 키를 매핑하는 `@JoinColumn` 을 동시에 사용해 기본 키 + 외래 키를 한번에 매핑했다. 그리고 `@IdClass` 를 사용해 복합 기본 키를 매핑했다.\n\n**복합 기본 키**<br/>\n회원상품 엔티티는 기본 키가 `MEMBER_ID` , `PRODUCT_ID` 로 이루어진 복합 기본 키이다. JPA에서 이를 사용하려면 **별도의 식별자 클래스가 필요**하다. 그리고 엔티티에 `@IdClass` 를 사용해 식별자 클래스를 지정하면 된다. (예제에서는 `MemberProductId` 클래스)\n\n복합 기본 키를 위한 식별자 클래스의 특징\n- 복합 키는 별도의 식별자 클래스로 만들어야 한다.\n- `Serializable` 을 구현해야 한다.\n- `equals` , `hashCode` 메소드를 구현해야 한다.\n- 기본 생성자가 있어야 한다.\n- 식별자 클래스는 `public` 이어야 한다.\n- `@IdClass` 를 사용하는 방법 외에 `@EmbeddedId` 를 사용하는 방법도 있다.\n\n**식별 관계**<br/>\n회원상품은 회원과 상품의 기본 키를 받아 자신의 기본 키로 사용한다. 이렇게 \"부모 테이블의 기본 키를 받아 자신의 기본 키 + 외래 키로 사용\"하는 것을 식별 관계(Identifying Relationship)이라 한다.\n\n> 회원상품은 **회원의 기본 키**를 받아 **자신의 기본 키**로 사용함과 동시에 **회원과의 관계를 위한 외래 키**로 사용한다. (상품의 기본 키도 동일하게 사용)\n> 또한 식별자 클래스로 두 기본 키를 묶어 **복합 기본 키로 사용**한다.\n\n저장 시에는, \n- 연결 엔티티를 만들면서 연관된 엔티티를 설정한다.\n- 연결 엔티티는 데이터베이스에 저장될 때 연관된 엔티티의 식별자를 가져와서 자신의 기본 키 값으로 사용한다.\n\n조회 시에는,\n- 생성한 식별자 클래스로 엔티티를 조회한다.\n\n> 복합 기본 키를 사용하는 방법은 복잡하다. 식별자 클래스 생성, `@IdClass` 또는 `@EmbeddedId` 사용, 식별자 클래스 메소드 구현과 같은 과정이 필요하다. 다음은 복합 기본 키를 사용하지 않고 간단히 다대다 관계를 구성하는 방법에 대해 알아본다.\n\n### ➰ 다대다: 새로운 기본 키 사용\n**데이터베이스에서 자동으로 생성해주는 대리 키를 `Long` 값으로 사용하는 것**이다. \n- 간편하고,\n- 거의 영구히 쓸 수 있으며,\n- 비즈니스에 의존하지 않는다.\n- ORM 매핑 시 복합 기본 키를 만들지 않아도 된다.\n\n`MemberProduct` 를 `ORDER` 로 수정하고, `ORDER_ID` 라는 새 기본 키를 만들고, `MEMBER_ID` & `PRODUCT_ID` 컬럼은 외래 키로만 사용한다.\n\n```java\n@Entity\npublic class Order {\n\n  @Id @GeneratedValue\n  @Column(name = \"ORDER_ID\")\n  private Long id;\n\n  @ManyToOne\n  @JoinColumn(name = \"MEMBER_ID\")\n  private Member member;\n\n  @ManyToOne\n  @JoinColumn(name = \"PRODUCT_ID\")\n  private Product product;\n\n  private int orderAmount;\n  ...\n\n}\n```\n\n대리 키를 사용함으로써 이전에 보았던 식별 관계에 복합 기본 키를 사용하는 것보다 매핑이 단순하고 직관적이다. \n\n저장 시에는,\n- 회원과 상품 엔티티를 생성해 저장하고, \n- 주문 엔티티에서 연관된 엔티티와 연관관계 설정(`set연관된엔티티`)하고 저장한다.\n\n조회 시에는,\n- 주문 엔티티로 조회하고, 연관된 엔티티들을 `get연관된엔티티` 하여 조회한다.\n\n### ➰ 다대다 연관관계 정리\n다대다 관계를 일대다 + 다대일 관계로 풀어내기 위해 연결 테이블을 만들 때 식별자를 어떻게 구성할지 선택해야 한다.\n\n- **식별 관계** : 받아온 식별자를 기본 키 + 외래 키로 사용한다.\n- **비식별 관계** : 받아온 식별자는 외래 키로만 사용하고 새로운 식별자를 추가한다.\n\n객체 입장에서는, **비식별 관계를 사용**하는 것이 복합 기본 키를 위한 식별자 클래스를 생성하지 않아도 되어 더 단순하고 편리한 ORM 매핑을 가능케 한다.\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"문제 로봇 청소기가 주어졌을 때, 청소하는 영역의 개수를 구하는 프로그램을 작성하시오. 로봇 청소기가 있는 장소는 N×M 크기의 직사각형으로 나타낼 수 있으며, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 벽 또는 빈 칸이다. 청소기는 바라보는 방향이 있으며, 이 방향은 동, 서, 남, 북중 하나이다. 지도의 각 칸은 (r, c)로 나타낼 수…","fields":{"slug":"/[BOJ]14503/"},"frontmatter":{"date":"March 15, 2022","title":"👩‍💻 14503. 로봇 청소기","tags":["구현","시뮬레이션"]},"rawMarkdownBody":"\n## 문제\n로봇 청소기가 주어졌을 때, 청소하는 영역의 개수를 구하는 프로그램을 작성하시오.\n\n로봇 청소기가 있는 장소는 N×M 크기의 직사각형으로 나타낼 수 있으며, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 벽 또는 빈 칸이다. 청소기는 바라보는 방향이 있으며, 이 방향은 동, 서, 남, 북중 하나이다. 지도의 각 칸은 (r, c)로 나타낼 수 있고, r은 북쪽으로부터 떨어진 칸의 개수, c는 서쪽으로 부터 떨어진 칸의 개수이다.\n\n로봇 청소기는 다음과 같이 작동한다.\n\n1. 현재 위치를 청소한다.\n2. 현재 위치에서 현재 방향을 기준으로 왼쪽 방향부터 차례대로 인접한 칸을 탐색한다.\n   a. 왼쪽 방향에 아직 청소하지 않은 공간이 존재한다면, 그 방향으로 회전한 다음 한 칸을 전진하고 1번부터 진행한다.\n   b. 왼쪽 방향에 청소할 공간이 없다면, 그 방향으로 회전하고 2번으로 돌아간다.\n   c. 네 방향 모두 청소가 이미 되어있거나 벽인 경우에는, 바라보는 방향을 유지한 채로 한 칸 후진을 하고 2번으로 돌아간다.\n   d. 네 방향 모두 청소가 이미 되어있거나 벽이면서, 뒤쪽 방향이 벽이라 후진도 할 수 없는 경우에는 작동을 멈춘다.\n\n로봇 청소기는 이미 청소되어있는 칸을 또 청소하지 않으며, 벽을 통과할 수 없다.\n\n## 입, 출력\n\n입력\n- 첫째 줄에 세로 크기 N과 가로 크기 M이 주어진다. (3 ≤ N, M ≤ 50)\n- 둘째 줄에 로봇 청소기가 있는 칸의 좌표 (r, c)와 바라보는 방향 d가 주어진다. d가 0인 경우에는 북쪽을, 1인 경우에는 동쪽을, 2인 경우에는 남쪽을, 3인 경우에는 서쪽을 바라보고 있는 것이다.\n- 셋째 줄부터 N개의 줄에 장소의 상태가 북쪽부터 남쪽 순서대로, 각 줄은 서쪽부터 동쪽 순서대로 주어진다. 빈 칸은 0, 벽은 1로 주어진다. 지도의 첫 행, 마지막 행, 첫 열, 마지막 열에 있는 모든 칸은 벽이다.\n- 로봇 청소기가 있는 칸의 상태는 항상 빈 칸이다.\n\n출력\n- 로봇 청소기가 청소하는 칸의 개수를 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Robot {\n    int x;\n    int y;\n    int dir;\n\n    public Robot(int x, int y, int dir) {\n        this.x = x;\n        this.y = y;\n        this.dir = dir;\n    }\n}\n```\n\n- 로봇 청소기의 위치를 저장하는 클래스\n\n```java\npublic int cleanRoom(int r, int c, int d) {\n    int cleanCount = 0;\n    queue.add(new Robot(r, c, d));\n\n    while(!queue.isEmpty()) {\n        Robot robot = queue.poll();\n\n        if (map[robot.x][robot.y] == 0) {\n            map[robot.x][robot.y] = 2;\n            cleanCount++;\n        }\n\n        if (!checkWallMethod(robot)) {\n            moveBack(robot);\n        }\n    }\n    return cleanCount;\n}\n```\n\n- 문제에서 주어진 작동 로직을 구현한 메소드\n- Queue를 이용한 BFS방식으로 청소할 영역을 탐색한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.*;\n    import java.util.*;\n\n    class Robot {\n        int x;\n        int y;\n        int dir;\n\n        public Robot(int x, int y, int dir) {\n            this.x = x;\n            this.y = y;\n            this.dir = dir;\n        }\n    }\n\n    class Directions {\n        int x;\n        int y;\n\n        public Directions(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Room {\n        int[][] map;\n        int N, M;\n        Queue<Robot> queue = new LinkedList<>();\n        Directions[] directions = {new Directions(-1, 0), new Directions(0, 1), new Directions(1, 0), new Directions(0, -1)};\n\n        public Room (int n, int m) {\n            N = n;\n            M = m;\n            map = new int[n][m];\n        }\n\n        public int cleanRoom(int r, int c, int d) {\n            int cleanCount = 0;\n            queue.add(new Robot(r, c, d));\n\n            while(!queue.isEmpty()) {\n                Robot robot = queue.poll();\n\n                if (map[robot.x][robot.y] == 0) {\n                    map[robot.x][robot.y] = 2;\n                    cleanCount++;\n                }\n\n                if (!checkWallMethod(robot)) {\n                    moveBack(robot);\n                }\n            }\n            return cleanCount;\n        }\n\n        private void moveBack(Robot robot) {\n            int backDir = turnBack(robot.dir);\n            int backX = robot.x + directions[backDir].x;\n            int backY = robot.y + directions[backDir].y;\n\n            if (!checkBoundary(backX, backY)) {\n                if (map[backX][backY] != 1) {\n                    queue.add(new Robot(backX, backY, robot.dir));\n                }\n            }\n        }\n\n        private boolean checkWallMethod(Robot robot) {\n            for (int i = 0; i < 4; i++) {\n                int nextDir = turnLeft(robot.dir);\n                int nextX = robot.x + directions[nextDir].x;\n                int nextY = robot.y + directions[nextDir].y;\n\n                robot.dir = nextDir;\n\n                if (checkBoundary(nextX, nextY)) continue;\n\n                if (map[nextX][nextY] == 0) {\n                    queue.add(new Robot(nextX, nextY, nextDir));\n                    return true;\n                }\n            }\n            return false;\n        }\n\n        private boolean checkBoundary(int r, int c) {\n            return r < 0 || r >= N || c < 0 || c >= M;\n        }\n\n        private int turnLeft(int d) {\n            return (d + 3) % 4;\n        }\n\n        private int turnBack(int d) {\n            return (d + 2) % 4;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            String[] line = br.readLine().split(\" \");\n            int N = Integer.parseInt(line[0]);\n            int M = Integer.parseInt(line[1]);\n\n            Room room = new Room(N, M);\n\n            line = br.readLine().split(\" \");\n\n            int r = Integer.parseInt(line[0]);\n            int c = Integer.parseInt(line[1]);\n            int d = Integer.parseInt(line[2]);\n\n            for (int i = 0; i < N; i++) room.map[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\n            System.out.println(room.cleanRoom(r, c, d));\n\n            br.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 시뮬레이션 문제는 주어진 조건에 따라 로직을 구현하는 방식으로 이해해, 로봇청소기의 작동원리마다의 메소드를 구현하려 했다.\n- 최대한 객체 지향적으로 들여쓰기 횟수도 고려하면서 메소드 추출을 수행했다.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/14503"},{"excerpt":"GongDon 프로젝트를 진행하면서 알게 된 Interceptor의 개념에 대해 정리하는 POST다. 🔦 Interceptor란 컨트롤러에 들어오는 요청(HttpRequest)와 컨트롤러가 응답하는 HttpResponse를 가로채는 역할을 수행한다. 인증 작업이나 필요한 로직을 수행한 후 컨트롤러로 보내주는 모듈이다.  위 그림을 보면, intercept…","fields":{"slug":"/[BackEnd]Interceptor/"},"frontmatter":{"date":"March 15, 2022","title":"💻 Interceptor","tags":["Java","SpringBoot","interceptor","filter"]},"rawMarkdownBody":"\n<em>GongDon 프로젝트를 진행하면서 알게 된 Interceptor의 개념에 대해 정리하는 POST다.</em>\n\n## 🔦 Interceptor란\n컨트롤러에 들어오는 **요청**(HttpRequest)와 컨트롤러가 응답하는 **HttpResponse**를 가로채는 역할을 수행한다. 인증 작업이나 필요한 로직을 수행한 후 컨트롤러로 보내주는 모듈이다. \n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=http%3A%2F%2Fcfile10.uf.tistory.com%2Fimage%2F992590395ABF406F180F86\" width=\"80%\">\n\n위 그림을 보면, interceptor는 `DispatcherServlet` 의 앞, 뒤에서 요청과 응답을 가로챈다. 언뜻 보면 filter와 비슷해보이는데, 분명한 차이점이 있다.\n\n1. 호출 시점\n   - 그림만 보더라도, 확연히 호출 시점이 다른 것을 알 수 있다.\n   - filter의 경우, `DispatcherServlet` 이 실행되기 전에 호출된다.\n   - interceptor의 경우, `DispatcherServlet` 이 실행된 이후에 호출된다.\n\n2. 설정 위치\n   - filter는 `web.xml` 에 설정하지만, interceptor는 `spring-boot-starter-web` dependency 설정과 interceptor 등록을 위한 config가 필요하다.\n\n3. 구현 방식\n   - filter는 설정 이후, 바로 구현이 가능하다.\n   - interceptor는 등록과 등록한 빈을 사용하는 메소드 구현이 필요하다.\n\nInterceptor에 대해 더 자세하게 보면, 아래 그림과 같다.\n\n<img src=\"https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FdnFaBP%2Fbtq3hasvPj5%2F7QAPXDlu5nGShwf2aEOQSK%2Fimg.png\" width=\"80%\">\n\n- 위 그림처럼 Interceptor는 Controller(Handler)로 가기전에 요청을 가로채는 `preHandle` , Controller 처리 후 `postHandle` , 전체 요청이 끝난 후 처리되는 `afterCompletion` 으로 이루어져있다.\n- Handler 역할을 하는 Controller로 가기전에 가로채기 때문에 정식 명칭은 `HandlerInterceptor` 이다.\n\n---\n\n## 🔦 Interceptor 설정\nInterceptor 사용을 위해서는,\n- `spring-boot-starter-web` dependency 설정\n- Interceptor 생성\n- Interceptor 등록을 위한 Config\n\n가 필요하다.\n\n### 🔧 Interceptor 생성\n\n먼저 Interceptor의 생성을 위해서는, 아래 두 가지 방법이 있다.\n- Spring Web에서 제공하는 `HandlerInterceptor` Interface를 구현하는 방법 (`preHandle` , `postHandle` , `afterCompletion` 오버라이딩 필요)\n- 추상 클래스인 `HandlerInterceptorAdapter` 를 상속하는 방법\n\n후자를 택하게 되면, `@Deprecated` annotation에 대한 고민이 필요하다. 여기서는 전자에 대해서 다룬다.\n\n> `@Deprecated` \n> - 클래스나 메소드 등을 더 이상 사용 권장하지 않는 경우에 사용하는 annotation\n> - 사용이 불가능한 것은 아니지만, 차후에 없어질 수도 있다는 것을 의미한다.\n\n`MyInterceptor.java`\n```java\n@Log4j2\n@Component\npublic class PostInterceptor implements HandlerInterceptor {\n\n    @Override\n    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object obj) throws Exception {\n        log.info(\"url : {}\", request.getRequestURI());\n        return true;\n    }\n\n    @Override\n    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object obj, ModelAndView mav) throws Exception {\n        log.info(\"response status: {}\", response.getStatus());\n    }\n\n    @Override\n    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object obj, Exception e) throws Exception {\n    }\n}\n```\n\n- `preHandle` : 실제 Controller(Handler)가 실행되기 전에 실행되며, `boolean` 타입의 값을 반환한다.\n  - true : 요청한 handler를 처리\n  - false : 처리하지 않음\n- `postHandle` : handler가 실행된 후 실행\n- `afterCompletion` : 전체 요청이 끝나고 난 후 마지막에 실행\n\n> 필요한 기능에 따라 각 메소드에 구현하면 된다.\n\n### 🔧 Interceptor 등록\n위에서 생성한 Interceptor는 아직 정상적으로 등록되지 않았기 때문에, 해당 코드는 실행되지 않는다. Spring MVC에 등록 요청을 수행하는 Config가 필요하다.\n\n`WebConfig.java`\n```java\n@Configuration\n@RequiredArgsConstructor\npublic class WebConfig implements WebMvcConfigurer {\n\n    private final PostInterceptor postInterceptor;\n\n    @Override\n    public void addInterceptors(InterceptorRegistry registry) {\n        registry.addInterceptor(postInterceptor)\n                .addPathPatterns(\"/api/post/**\");\n    }\n}\n```\n\n- Interceptor 등록을 위한 설정 파일이다. \n- `@Component` annotation으로 Bean으로 등록된 Interceptor를 가져와 registry에 등록한다.\n  - `addPathPatterns` : interceptor를 적용할 patterns를 명시\n  - `excludePathPatterns` : 제외할 patterns를 명시\n    - 각 Controller의 메소드에 대해 annotation을 이용해 권한을 확인하는 방식으로 모든 patterns에 대해 개방해둘 수 있다.\n    - 나는 여기서 `PostController` 에 대한 Interceptor를 생성하기 위해 `/api/post/**` 로 명시했다.\n\nannotation 방식을 활용하여 Interceptor에서 수행할 권한 확인을 처리할 수 있다. 아래는 \n`MyAnnotation.java`\n```java\n@Retention(RetentionPolicy.RUNTIME)\n@Target(ElementType.METHOD)\npublic @interface MyAnnotation {\n  // 권한을 확인할 로직, 예를 들면 관리자인지 아닌지를 확인\n  UserType userType() default UserType.STUDENT;\n}\n```\n\n- handlerMethod에 annotation을 활용한 권한 확인을 위해 추가한 annotation이다.\n\n> Spring Security에 비슷한 기능을 하는 `@Secured` annotation이 있다.\n\n최종적으로 Controller의 Methods에 `MyAnnotation` annotation을 추가해 적절히 수행되는지 확인한다.\n\n## 🔦 AOP 사용\nAOP에 대해서는 다음 포스트에서 정리하도록 한다. 여기서는 위에서 생성한 annotation에 대한 실행 시간 측정을 위해서 사용해보도록 한다.\n\n먼저 AOP 사용을 위해 의존성을 추가한다.\n```xml\nimplementation 'org.springframework.boot:spring-boot-starter-aop'\n```\n\n```java\n@Component\n@Aspect // Aspect 를 꼭 명시!\n@Log4j2\nclass LogAspect {\n\n    @Around(\"@annotation(MyAnnotation)\") // 해당 어노테이션에 대해서 \n    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {\n        StopWatch stopWatch = new StopWatch();\n        stopWatch.start();\n\n        Object proceed = joinPoint.proceed();\n\n        stopWatch.stop();\n        log.info(stopWatch.prettyPrint());\n        return proceed;\n    }\n}\n```\n\n- `MyAnnotation` 이 붙게 되면, 실행 시간을 측정하고 이를 로그에 남기도록 한다.\n  - `Aspect` 로, 이 클래스가 Aspect를 나타내는 클래스라는 것을 명시한다.\n  - `joinPoint` 를 가져와서, 해당 Point에서 동작되는 시간을 측정한다.\n\n실행 시간을 측정할 Controller method에 `MyAnnotation` 을 붙여 결과를 확인한다.\n\n## 📕 참고\n- [[Spring] Interceptor (1) - 개념 및 예제](https://victorydntmd.tistory.com/176)\n- [[SpringMVC] 인터셉터(interceptor) 적용 - session](https://hyeonic.tistory.com/201)\n- [@Deprecated](https://araikuma.tistory.com/659)\n- [Spring Boot 에서 log를 남기는 방법 - Spring log 남기기](https://huisam.tistory.com/entry/springlogging)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 엔티티들은 대부분 다른 엔티티와 연관관계가 있다. 그런데 객체는 참조(주소)를 사용하고, 테이블은 외래 키를 사용해 관계를 맺는다. 이 둘은 완전히 다른 특징을 가지므로, 객체 관계 매핑에서 가장 어려운 부분이라고 할 수 있다. \n이 장에서는 객체의 참조와 테이블의 외…","fields":{"slug":"/[JPA]5/"},"frontmatter":{"date":"March 13, 2022","title":"📚 5. 연관관계 매핑 기초","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 엔티티들은 대부분 다른 엔티티와 **연관관계**가 있다. 그런데 객체는 참조(주소)를 사용하고, 테이블은 외래 키를 사용해 관계를 맺는다. 이 둘은 완전히 다른 특징을 가지므로, 객체 관계 매핑에서 가장 어려운 부분이라고 할 수 있다. <br/>\n> 이 장에서는 **객체의 참조와 테이블의 외래 키를 매핑하는 것**을 목표로 한다.\n> - **방향**\n>   - 단방향, 양방향이 있다. 객체관계에만 방향이 존재하고, 테이블에서는 항상 양방향이다.\n> - **다중성**\n>   - N:1, 1:N, 1:1, N:M 다중성이 있다.\n> - **연관관계의 주인**\n>   - 객체를 양방향 연관관계로 만들면 연관관계의 주인을 정해야 한다.\n\n## 💫 단방향 연관관계\n연관관계 중에선 다대일(N:1) 단방향 관계를 가장 먼저 이해해야 한다. \n- 회원과 팀이 있다.\n- 회원은 하나의 팀에만 소속될 수 있다.\n- 회원과 팀은 **다대일 관계**이다.\n\n**객체 연관관계**<br/>\n- 회원 객체는 `Member.team` 필드 (멤버변수)로 팀 객체와 연관관계를 맺는다.\n- 회원 객체와 팀 객체는 **단방향 관계**다. 회원은 팀을 알 수 있지만, 반대로 팀은 회원을 알 수 없다. (팀에서 접근하는 필드가 없기 때문)\n\n**테이블 연관관계**<br/>\n- 회원 테이블은 `TEAM_ID` 외래 키로 팀 테이블과 연관관계를 맺는다.\n- 회원 테이블과 팀 테이블은 **양방향 관계**다. 조인을 통해 서로서로에 접근할 수 있다. \n\n외래 키 하나로 어떻게 양방향 조인이 가능할까?\n```sql\nSELECT * FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID\n\nSELECT * FROM TEAM T JOIN MEMBER M ON T.TEAM_ID = M.TEAM_ID\n```\n\n**객체 연관관계와 테이블 연관관계의 가장 큰 차이**<br/>\n참조를 통한 연관관계는 항상 **단방향**이다. 객체 간 연관관계를 양방향으로 만들고 싶으면 반대쪽에도 필드를 추가해 참조를 보관해야 한다. (즉 연관관계를 하나 더 생성) 이는 정확하게는 **양방향 관계가 아닌 서로 다른 단방향 관계 2개**가 되는 셈이다.\n\n반면에 테이블은 **외래 키 하나로 양방향 조인이 가능**하다.\n\n**객체 연관관계 vs. 테이블 연관관계 정리**<br/>\n- 객체는 참조(주소)로 연관관계를 맺는다.\n  - 단방향 연관관계다.\n  - 양방향이 되기 위해서는 단방향 연관관계를 1개 더 만들어야 한다.\n- 테이블은 외래 키로 연관관계를 맺는다.\n  - 양방향 연관관계다.\n\n연관된 데이터를 조회할 때 객체는 `a.getB().getC()` 를 사용하지만 테이블은 조인을 사용한다.\n\n### ➰ 순수한 객체 연관관계\n순수하게 객체만 사용한 연관관계 코드이다.\n\n```java\npublic class Member {\n  private String id;\n  private String username;\n\n  private Team team; // 팀 참조 보관\n\n  public void setTeam(Team team) {\n    this.team = team;\n  }\n\n  ...\n\n\n}\n\npublic class Team {\n  private String id;\n  private String name;\n\n  ...\n\n}\n```\n\n아래 코드로 회원1과 2를 팀1에 소속시킨다.\n\n```java\npublic static void main(String[] args) {\n  Member member1 = new Member(\"member1\", \"회원1\");\n  Member member2 = new Member(\"member2\", \"회원2\");\n  Team team1 = new Team(\"team1\", \"팀1\");\n\n  member1.setTeam(team1);\n  member2.setTeam(team1);\n\n  Team findTeam = member1.getTeam();\n}\n```\n\n이처럼 객체는 참조를 사용해 연관관계를 탐색할 수 있는데, 이를 **객체 그래프 탐색**이라 한다.\n\n### ➰ 테이블 연관관계\n데이터베이스 테이블의 회원과 팀의 관계를 살펴본다. 두 테이블은 모두 `TEAM_ID` 를 가지고, 회원 테이블의 `TEAM_ID` 에 외래 키 제약조건을 설정했다.\n- INSERT SQL로 회원1과 2를 팀1에 소속시킨다.\n- SELECT SQL로 회원1이 소속된 팀을 조회한다.\n  - 이때 `TEAM_ID` 에 대한 `JOIN` 을 사용한다.\n\n이처럼 데이터베이스는 외래 키를 사용해 연관관계를 탐색할 수 있는데, 이를 **조인**이라 한다.\n\n### ➰ 객체 관계 매핑\n지금까지 다룬 객체, 테이블 연관관계를 JPA를 사용한 매핑으로 바꿔본다.\n- 객체 연관관계: 회원 객체의 `Member.team` 필드 사용\n- 테이블 연관관계: 회원 테이블의 `MEMBER.TEAM_ID` 외래 키 컬럼 사용\n\n```java\n@Entity\npublic class Member {\n  @Id\n  @Column(name = \"MEMBER_ID\")\n  private String id;\n\n  private String username;\n\n  @ManyToOne\n  @JoinColumn(name = \"TEAM_ID\")\n  private Team team;\n\n  public void setTeam(Team team) {\n    this.team = team;\n  }\n\n  ...\n\n}\n```\n\n```java\n@Entity\npublic class Team {\n  @Id\n  @Column(name = \"TEAM_ID\")\n  private String id;\n\n  private String name;\n\n  ...\n\n}\n```\n\n- `Member.team` 과 `MEMBER.TEAM_ID` 를 매핑하는 것이 연관관계 매핑이다. 이를 위해 사용한 annotation을 분석한다.\n- `@ManyToOne`\n  - 이름 그대로 다대일 관계라는 매핑 정보를 의미한다. 연관관계 매핑 시에는 이렇게 다중성을 나타내는 annotation을 필수로 사용해야 한다.\n- `JoinColumn(name = \"TEAM_ID\")`\n  - 외래 키를 매핑할 때 사용한다. `name` 속성으로 매핑할 외래 키 이름을 지정한다. 생략가능한 annotation이다.\n  - 이를 생략하면, 외래 키를 찾을 때 기본 전략을 사용한다.\n  - > **기본 전략** : 필드명 + _ + 참조하는 테이블의 컬럼명\n  > - ex. 필드명(team) + _ + 참조하는 테이블의 컬럼명(TEAM_ID) = team_TEAM_ID 외래 키\n\n---\n\n## 💫 연관관계 사용\n연관관계를 등록, 수정, 삭제, 조회하는 예제를 통해 알아본다.\n\n### ➰ 저장\n```java\npublic void testSave() {\n  Team team1 = new Team(\"team1\", \"팀1\");\n  em.persist(team1);\n\n  Member member1 = new Member(\"member1\", \"회원1\");\n  member1.setTeam(team1);\n  em.persist(member1);\n\n  Member member2 = new Member(\"member2\", \"회원2\");\n  member2.setTeam(team1);\n  em.persist(member2);\n}\n```\n\n> JPA에서 엔티티 저장할 때 연관된 모든 엔티티는 영속 상태여야 한다.\n\n회원 엔티티는 팀 엔티티를 참조(`setTeam`)하고 저장(`persist`)했다. JPA는 참조한 팀의 식별자(`Team.id`)를 외래 키로 사용해 적절한 **등록 쿼리를 생성**할 것이다.\n\n### ➰ 조회\n연관관계가 있는 엔티티를 조회하는 방법은 2가지이다.\n- 객체 그래프 탐색(객체 연관관계를 사용한 조회)\n- 객체지향 쿼리 사용(JPQL)\n\n**객체 그래프 탐색**<br/>\n`member.getTeam()` 을 사용해 회원과 연관된 팀 엔티티를 조회할 수 있다.\n\n```java\nmember member = em.find(Member.class, \"member1\");\nTeam team = member.getTeam();\n```\n\n**객체지향 쿼리 사용**<br/>\n예를 들어 회원을 대상으로 조회하는데 팀1에 소속된 회원만 조회하려면 회원과 연관된 팀 엔티티를 검색 조건으로 사용해야 한다. SQL은 연관된 테이블을 조인해서 검색조건을 사용하면 된다. JPQL도 조인을 지원한다.\n\n```java\nprivate static void queryLogicJoin(EntityManager em) {\n  String jpql = \"select m from Member m join m.team t where \" + \"t.name=:teamName\";\n\n  List<Member> resultList = em.createQuery(jpql, Member.class)\n      .setParameter(\"teamName\", \"팀1\")\n      .getResultList();\n\n  for (Member member : resultList) {\n    System.out.println(\"[query] member.username=\" + member.getUsername());\n  }\n}\n```\n\n회원이 팀과 관계를 가지고 있는 필드(`m.team`)을 통해 회원과 팀 엔티티를 조인했다. 그리고 `where` 절에서 조인한 `t.name` 을 검색조건으로 사용해 원하는 회원만 검색했다.\n\n> `:teamName` 과 같이 :로 시작하는 것은 파라미터를 바인딩받는 문법이다.\n\n### ➰ 수정\n팀1 소속이던 회원을 새로운 팀2에 소속하도록 수정한다.\n\n```java\nprivate static void updateRelation(Entitymanager em) {\n  Team team2 = new Team(\"team2\", \"팀2\");\n  em.persist(team2);\n\n  Member member = em.find(Member.class, \"member1\");\n  member.setTeam(team2);\n}\n```\n- JPA는 UPDATE SQL을 생성해 자동으로 처리한다.\n\n### ➰ 연관관계 제거\n회원1을 팀에 소속하지 않도록 변경한다.\n\n```java\nprivate static void deleteRelation(Entitymanager em) {\n  Member member = em.find(Member.class, \"member1\");\n  member.setTeam(null);\n}\n```\n- 연관관계를 `null` 로 설정했다. 이때는 다음과 같은 SQL이 생성된다.\n\n```sql\nUPDATE MEMBER SET TEAM_ID=null, ... WHERE ID='member1'\n```\n\n### ➰ 연관된 엔티티 삭제\n삭제를 위해서는 기존 연관관계를 먼저 제거하고 삭제해야 한다.\n- 그렇지 않으면 **외래 키 제약조건**으로 인해 데이터베이스에서 오류가 발생한다.\n\n```java\nmember1.setTeam(null);\nmember2.setTeam(null);\nem.remove(team);\n```\n\n---\n\n## 💫 양방향 연관관계\n이제 회원에서 팀으로 접근하고 반대 방향인 팀에서도 회원으로 접근할 수 있도록 양방향 연관관계로 매핑해본다.\n- 회원과 팀은 다대일 관계다. 반대로 팀에서 회원은 일대다 관계다.\n  - 일대다 관계는 여러 건과 연관관계를 맺을 수 있어 컬렉션을 사용해야 한다. `Team.members` 를 `List` 컬렉션으로 추가했다.\n\n> 회원 → 팀 (`Member.team`) <br/>\n> 팀 → 회원 (`Team.members`)\n\n데이터베이스의 테이블은 **외래 키 하나로 양방향으로 조회**할 수 있다. 따라서 데이터베이스에서는 추가할 내용이 전혀 없다.\n\n### ➰ 양방향 연관관계 매핑\n회원 엔티티에서는 변경할 부분이 없다. 팀 엔티티를 보자.\n\n```java\n@Entity\npublic class Team {\n  @Id\n  @Column(name = \"TEAM_ID\")\n  private String id;\n\n  private String name;\n\n  @OneToMany(mappedBy = \"team\")\n  private List<Member> members = new ArrayList();\n\n  ...\n\n}\n```\n- 팀과 회원은 일대다 관계다. 따라서 팀 엔티티에 컬렉션인 `List<Member> members` 를 추가했다.\n- 또한 일대다 관계 매핑을 위한 annotation을 사용했다. \n- `mappedBy` 속성은 양방향 매핑일 때 반대쪽 매핑의 필드 이름을 값으로 지정한다. (반대쪽 매핑이 `Member.team`)\n\n### ➰ 일대다 컬렉션 조회\n팀에서 회원 컬렉션으로 객체 그래프 탐색을 사용해 특정 팀에 소속된 회원들을 조회할 수 있다.\n\n```java\npublic void biDirection() {\n  Team team = em.find(Team.class, \"team1\");\n  List<Member> members = team.getMembers();\n\n  for (Member member : members) {\n    System.out.println(\"member.username = \" + member.getUsername());\n  }\n}\n```\n\n---\n\n## 💫 연관관계의 주인\n`@OneToMany` annotation 사용 시 `mappedBy` 는 왜 필요할까? \n- 객체에는 양방향 연관관계라는 것이 없다. 서로 다른 단방향 연관관계가 2개일 뿐이다. \n  - 반면, 데이터베이스는 외래 키 하나로 양쪽이 서로 조인하기에 양방향 연관관계를 맺을 수 있다.\n- 엔티티를 단방향으로 매핑하면 참조를 하나만 사용해 이 참조로 외래 키를 관리하면 된다.\n  - 하지만 양방향으로 매핑하면 \"회원 → 팀\" , \"팀 → 회원\" 으로 두 곳에서 서로를 참조한다. \n  - 즉, **객체의 연관관계를 관리하는 포인트가 2곳으로 늘어나게 되고,** 참조는 둘인데 외래 키는 하나여서 차이가 발생한다.\n    - 이때 JPA에서는 두 객체 연관관계 중 하나를 정해 테이블의 외래 키를 관리해야 하는데 이때 정해진 하나가 **연관관계의 주인**이 된다.\n\n### ➰ 양방향 매핑의 규칙: 연관관계의 주인\n**연관관계의 주인만이 데이터베이스 연관관계와 매핑되고, 외래 키를 관리(등록, 수정, 삭제)할 수 있다. 반면에 주인이 아닌 쪽은 읽기만 가능하다.**\n- 주인은 `mappedBy` 속성을 사용하지 않는다.\n- 주인이 아니면 `mappedBy` 속성을 사용해 속성의 값으로 연관관계의 주인을 지정한다.\n\n연관관계의 주인을 어떻게 정해야 할까? 이는 곧 **외래 키 관리자를 선택하는 것**이다.\n- 회원과 팀의 예에서는 회원 테이블에 있는 `TEAM_ID` 외래 키를 관리할 관리자를 선택하는 것이다. \n  - 만약 회원 엔티티에 있는 `Member.team` 을 주인으로 선택하면 자기 테이블에 있는 외래 키를 관리하면 된다. \n  - 하지만 팀 엔티티에 있는 `Team.members` 를 주인으로 선택하면 물리적으로 전혀 다른 테이블의 외래 키를 관리해야 한다.\n\n### ➰ 연관관계의 주인은 외래 키가 있는 곳\n\"연관관계의 주인은 테이블에 외래 키가 있는 곳으로 정해야 한다.\" 위의 예에서는 `Member.team` 이 주인이 된다. \n- 주인이 아닌 `Team.members` 에는 `mappedBy=\"team\"` 속성을 사용해 주인이 아님을 설정하고. 속성 값으로는 연관관계의 주인(`team`)을 명시한다.\n\n이로서 연관관계의 주인만 데이터베이스 연관관계와 매핑되고 외래 키를 관리할 수 있다. 주인이 아닌 반대편은 읽기만 가능하고 외래 키를 변경하지는 못한다.\n\n> 데이터베이스 테이블의 다대일, 일대다 관계에서는 항상 다 쪽이 외래 키를 가진다. 따라서 `@ManyToOne` 에는 `mappedBy` 속성이 없다.\n\n---\n\n## 💫 양방향 연관관계 저장\n```java\npublic void testSave() {\n  Team team1 = new Team(\"team1\", \"팀1\");\n  em.persist(team1);\n\n  Member member1 = new Member(\"member1\", \"회원1\");\n  member1.setTeam(team1);\n  em.persist(member1);\n\n  Member member2 = new Member(\"member2\", \"회원2\");\n  member2.setTeam(team1);\n  em.persist(member2);\n}\n```\n- 회원에 연관관계의 주인인 `Member.team` 필드를 이용해 회원과 팀의 연관관계를 설정하고 저장했다. 이는 **단방향 연관관계에서 사렾본 회원과 팀을 저장하는 코드와 동일**하다.\n- 연관관계의 주인이 아닌 방향은 값을 설정하지 않아도 데이터베이스에 외래 키 값이 정상 입력되고, 설령 입력한다고 해도 이는 **무시**되어 영향을 주지 않는다.\n\n---\n\n## 💫 양방향 연관관계의 주의점\n가장 흔히 하는 실수는 **연관관계의 주인에는 값을 입력하지 않고, 주인이 아닌 곳에만 값을 입력**하는 것이다. 이는 방금 언급했듯 무시되어 영향을 주지 않는 동작이기에 데이터베이스에 외래 키 값이 정상적으로 저장되지 않으면 이부터 확인해야 한다.\n\n> **\"연관관계의 주인만이 외래 키의 값을 변경할 수 있다.\"**\n\n### ➰ 순수한 객체까지 고려한 양방향 연관관계\n그렇다면 연관관계의 주인에만 값을 저장하고 주인이 아닌 곳에는 값을 저장하지 않아도 될까?\n- 사실 **객체 관점에서는 양쪽 방향에 모두 값을 입력해주는 것이 가장 안전하다.** \n- 양쪽 방향 모두 값을 입력하지 않으면 JPA를 사용하지 않는 순수한 객체 상태에서 심각한 문제가 발생할 수 있다.\n\n```java\n// ex.JPA를 사용하지 않고 엔티티에 대한 테스트 코드를 작성하는 경우\npublic void test순수한객체_양방향() {\n  Team team1 = new Team(\"team1\", \"팀1\");\n  Member member1 = new Member(\"member1\", \"회원1\");\n  Member member2 = new Member(\"member2\", \"회원2\");\n  member1.setTeam(team1);\n  member2.setTeam(team1);\n  \n  List<Member> members = team1.getMembers();\n  System.out.println(\"members.size = \" + members.size());\n}\n```\n- JPA를 사용하지 않는 순수한 객체다. `Member.team` 에만 연관관계를 설정했기에 **팀에 소속된 회원이 하나도 없다.**\n- 양방향은 양쪽 모두 관계를 설정해야 한다. 즉 반대방향으로도 설정이 이뤄져야 한다.\n  - 이로서 순수한 객체 상태에서도 동작하며, 테이블의 외래 키도 정상 입력된다. (외래 키 값은 연관관계의 주인인 `Member.team` 값을 사용한다.)\n\n```java\nmember1.setTeam(team1); // 주인, 외래 키 관리\nteam1.getMembers().add(member1); // 주인 X, 저장 시 사용되지 않음\n```\n\n> 결론 : 객체의 양방향 연관관계는 양쪽 모두 관계를 맺어주자.\n\n### ➰ 연관관계 편의 메소드\n양방향 연관관계는 결국 양쪽 모두 신경 써야 한다. 실수로 두 설정 메소드 중 하나만 호출해 양방향이 깨지는 경우가 발생할 수도 있다.\n- 따라서 두 코드를 하나인 것처럼 사용하는 것이 안전하다. `Member` 클래스의 `setTeam()` 메소드를 리팩토링한다.\n\n```java\npublic class Member {\n  private Team team;\n\n  public void setTeam(Team team) {\n    this.team = team;\n    team.getMembers().add(this);\n  }\n  ...\n\n}\n```\n- `setTeam` 메소드에서 양방향 관계를 모두 설정하도록 수정했다. 이렇게 한 번에 양방향 관계를 설정하는 메소드를 **연관관계 편의 메소드**라 한다.\n\n### ➰ 연관관계 편의 메소드 작성 시 주의사항\n사실 위와 같은 편의 메소드에는 버그가 있다. **`setTeam()` 을 호출한 직후에도 이전의 관계가 제거되지 않는 것**이다.\n- 연관관계 변경 시에는 기존 팀이 있으면 그 관계를 삭제하고 새로운 관계를 맺는 코드로 바꿔야 한다.\n\n```java\npublic void setTeam(Team team) {\n  if (this.team != null) this.team.getMembers().remove(this);\n  this.team = team;\n  team.getMembers().add(this);\n} \n```\n\n---\n\n## 💫 정리\n단방향 매핑과 비교해서 양방향 매핑은 복잡하다.\n- 연관관계의 주인 지정\n- 두 개의 단방향 연관관계를 양방향으로 만들기 위해 로직 관리\n\n> 연관관계가 하나인 **단방향 매핑** → 언제나 연관관계의 주인 <br/>\n> **양방향 매핑** → 단방향 + 주인이 아닌 연관관계를 하나 추가 <br/>\n> 양방향의 장점은 **반대방향으로 객체 그래프 탐색 기능이 추가**된 것뿐!\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"프로젝트를 수행하면서 객체 지향 생활 체조 9가지 원칙에 대해 알게 되었다. 각각을 예시를 통해 이해하고자 정리한다. 💡 1. 메소드당 들여쓰기는 한 번만 사용한다. 한 메소드안에 들여쓰기가 여러 번 되어 있다면, 해당 메소드는 여러 가지 일을 하고 있다고 봐도 무방하다. 메소드는 가능한 작게 쪼개어 역할을 분담하는 것이 재사용성도 높고 디버깅에 용이하기…","fields":{"slug":"/[BackEnd]객체지향생활체조/"},"frontmatter":{"date":"March 11, 2022","title":"💻 객체지향 생활체조","tags":["Java","객체지향"]},"rawMarkdownBody":"\n<em>프로젝트를 수행하면서 객체 지향 생활 체조 9가지 원칙에 대해 알게 되었다. 각각을 예시를 통해 이해하고자 정리한다.</em>\n\n## 💡 1. 메소드당 들여쓰기는 한 번만 사용한다.\n한 메소드안에 들여쓰기가 여러 번 되어 있다면, 해당 메소드는 여러 가지 일을 하고 있다고 봐도 무방하다. 메소드는 가능한 작게 쪼개어 역할을 분담하는 것이 재사용성도 높고 디버깅에 용이하기에, 메소드 안의 들여쓰기를 최소한으로 하고, 여러 개의 메소드로 추출해 나누는 것이 좀 더 효율적인 프로그래밍이 될 것이다.\n\n```java\npublic class Example {\n  String makeString() {\n    int N = 5;\n    int M = 3;\n    StringBuilder sb = new StringBuilder();\n\n    for (int i = 0; i < N; i++) {\n      for (int j = 0; j < M; j++) {\n        sb.append(\"Something append\");\n        sb.append(\"!!!\");\n      }\n      sb.append(\"\\n\");\n    }\n\n    return sb.toString();\n  }\n}\n```\n\n위와 같이 들여쓰기가 두 번 이상 들어간 코드를 아래와 같이 메소드로 추출하여 좀 더 직관적이게 변경할 수 있다.\n\n```java\npublic class Example {\n  String makeString() {\n    int N = 5;\n    int M = 3;\n    StringBuilder sb = new StringBuilder();\n\n    newLineAppend(sb, N, M);\n\n    return sb.toString();\n  }\n\n  private void newLineAppend(StringBuilder sb, int N, int M) {\n    for (int i = 0; i < N; i++) {\n      somethingAppend(sb, M);\n      sb.append(\"\\n\");\n    }\n  }\n\n  private void somethingAppend(StringBuilder sb, int M) {\n    for (int j = 0; j < M; j++) {\n      sb.append(\"Something append\");\n      sb.append(\"!!!\");\n    }\n  }\n}\n```\n\n> 사실 위의 예제는 뭔가 어거지로 한 거 같아서 ... 다음에 프로젝트 코드 리팩토링을 하게 되면 참고해야겠다.\n\n## 💡 2. else 키워드를 쓰지 않는다.\n이 내용은 [자바 웹 프로그래밍 Next Step - 박재성]을 읽으면서 한 번 접했던 내용이다. 조건문은 복제의 원인이 되기도 하고 가독성도 좋지 못하다. 객체지향 언어는 다형성을 이용해 복잡한 조건문을 처리할 수 있고, 간단한 경우라면 조기 반환(early return)과 보호절(guard clause)을 사용해 처리할 수 있다.\n\n> 해당 원칙을 접하기 전에는 `else` 키워드를 사용하는 코드에 대해 별다른 생각이 없었던 것 같다. '해당 조건이 아닌 경우는 다 이걸로 처리해야지' 하고 사용했던 것 같다.\n\n```java\npublic class Example {\n  String exampleStatus(int score, boolean check) {\n    String result = \"\";\n    if (score > 10) {\n      result = \"YES!\";\n    } else {\n      if (check) {\n        result = \"SOSO\";\n      } else {\n        result = \"BAD...\";\n      }\n    }\n    return result;\n  }\n}\n```\n\n```java\npublic class Example {\n  String exampleStatus(int score, boolean check) {\n    if (score > 10) {\n      return \"YES!\";\n    }\n    return check ? \"SOSO\" : \"BAD...\";\n  }\n}\n```\n\n## 💡 3. 모든 원시값과 문자열을 Wrap한다.\n일반적으로 프로그래밍에서 사용되는 원시값들은 값의 정의만 가질 뿐 다른 의미를 지니지는 못한다. 이때 Wrap을 통해 이름을 가질 수 있게 하여, 어떤 것을 표현하고, 왜 쓰이는지에 대한 정보를 전달할 수 있게끔 한다.\n\n```java\nString say = \"Hello\";\n```\n\n```java\npublic class SeongUk {\n  String say = \"Hello\";\n}\n```\n\n위와 같이 클래스를 사용해 `String` 타입의 원시값을 감싸서 표현했다. 첫 코드보다는 좀 더 명확한 의미를 가지고 있다.\n\n> 처음에는 이게 무슨 의미인가..를 고민했는데, 예시를 보고 바로 와닿았다. \n\n## 💡 4. 한 줄에 점을 한 번만 사용한다.\n이 원칙은 디미터의 법칙 - \"Don't talk to stranger\", 즉 친구하고만 말하라는 의미를 가진다. 한 줄에 점이 하나 이상인 경우는 한 가지 이상의 일을 하고 있다는 의미이다. 단순히 여러 일을 한다는 것일 수 있지만, 연쇄적으로 호출되는 형태인 경우 **강한 결합도**를 가지고 있다는 것을 뜻하게 된다.\n\n```java\npublic class Post {\n  ...\n\n  User user;\n}\n\npublic class User {\n  ...\n\n  String name;\n}\n\npublic class PostViewer {\n  ...\n\n  String postPrintUserName() {\n    StringBuffer sb = new StringBuffer();\n\n    for (Post post : posts) {\n      sb.append(post.user.name);\n    }\n    \n    return sb.toString();\n  }\n}\n```\n\n강한 결합도를 가진 예시이다. `PostViewer` 는 `Post` 를 통해야지만 `User` 에 접근해 `name` 을 사용할 수 있다.\n\n```java\npublic class Post {\n  ...\n\n  User user;\n\n  void addTo(StringBuffer sb) {\n    user.addTo(sb);\n  }\n}\n\npublic class User {\n  ...\n\n  public String name;\n\n  void addTo(StringBuffer sb) {\n    sb.append(name);\n  }\n}\n\npublic class PostViewer {\n  ...\n\n  String postPrintUserName() {\n    StringBuffer sb = new StringBuffer();\n\n    for (Post post : posts) {\n      post.addTo(sb);\n    }\n    \n    return sb.toString();\n  }\n}\n```\n\n이처럼 자신이 알고 있는 객체하고만 소통하게 만듦으로써,\n- 한 객체가 알아야 하는 다른 객체의 수를 최소화하고\n- 결합도를 약하게 만들어 종속성을 최소화한다.\n\n> 어떻게 보면, 1번 원칙과 비슷한 흐름인 것 같다. \n\n## 💡 5. 줄여쓰지 않는다.\n보통 프로그래밍하면서 변수 이름이나 메소드 이름을 축약해서 적는 경우가 많았다. 자주 쓰는 `cnt` , `num` 과 같은 변수명들은 금방 의미를 파악할 수 있지만, 어떻게 네이밍을 해야 하나 고민하는데 시간을 들이는 경우도 종종 있었다.\n\n이 원칙이 줄여쓰지 말라하는 이유는 내가 종종 고민했던 경우들을 피하기 위함이다. 즉, **줄여써서 이름을 짓는 방법은 혼돈을 야기시키기에 사용하지 말라**는 의미이다.\n\n의미전달뿐 아니라, 이름이 길어진다는 것은 **객체가 가져야 할 책임의 소재가 잘못 전가되었다거나 상황에 알맞은 객체의 부재**를 나타낼 수도 있다. \n\n> 이 원칙은 지금 당장에도 적용시킬 수 있을만큼 중요한 것 같다.\n\n## 💡 6. 모든 Entity를 작게 유지한다.\n이 원칙은 **50줄 이상 되는 클래스와 10개 이상의 파일들을 가지는 패키지는 없어야 한다**는 의미이다. 그말인즉슨, 한 객체가 한 가지 이상의 일을 하지 못하게끔 하라는 의미인 것 같다. 작게 유지하려 할 수록, 한 가지의 목표만을 가지게 할 수 있기 때문이다.\n\n> 하지만 실제 개발을 하다보면, 이 원칙을 적용하지 못하는 경우가 종종 발생할 것 같다.\n\n## 💡 7. 2개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.\n대부분의 클래스가 하나의 상태 변수를 처리하는 일을 맡는 것이 마땅하지만 몇몇 경우 두 개 이상이 필요할 때가 있다. 이를 위해 새로운 인스턴스 변수를 추가하는 것은 **클래스의 응집도를 떨어뜨리는 일**이다.\n\n새로운 인스턴스 변수를 추가하는 것이 아닌 협력 객체의 계층구조로 분해해 더 직접적으로 효율적인 객체 모델을 구현할 수 있도록 한다.\n\n> 하나의 객체는 한 가지의 책임만을 수행한다와 3번 원칙이 합쳐진 개념인 것 같다.\n\n## 💡 8. 1급 컬렉션을 사용한다.\n먼저 1급 컬렉션이란, `Collection` 을 Wrapping하면서 그 외 다른 멤버 변수가 없는 상태를 일컫는다. 아래의 예시를 통해 감을 잡을 수 있을 것이다.\n\n```java\nMap<String, String> map = new HashMap<>();\nmap.put(\"1\", \"A\");\nmap.put(\"2\", \"B\");\nmap.put(\"3\", \"C\");\n\n// wrapping\n\npublic class Ranking {\n  private Map<String, String> ranks;\n\n  public Ranking(Map<String, String> ranks) {\n    this.ranks = ranks;\n  }\n}\n```\n\n그리고 이 원칙은 **컬렉션을 포함한 클래스는 반드시 다른 멤버 변수가 없어야 한다**는 원칙이다. 각 컬렉션은 그 자체로 포장되어 있기에 컬렉션과 관련된 동작의 근거지가 마련된 것이다. \n\n> 이 원칙은 잘 이해가 되지 않는다...\n\n## 💡 9. getter/setter/property를 쓰지 않는다.\n이 원칙은 \"묻지 말고 말을 해(Tell, don't ask)\"로 대변된다. 즉, 객체의 상태를 가져오는 접근자를 사용하는 것은 허용되지만, 객체 외부에서 그 결과값을 사용해 객체에 대한 결정을 내리는 것은 안된다는 의미이다. (한 객체의 상태에 대한 결정은 반드시 그 객체 내부에서만 이뤄져야 한다.)\n- 그래서 getter/setter가 이를 위배하게 하고, 이는 곧 **개방폐쇄 원칙을 위배**하게 된다.\n\n> 쉽게 말해, 객체 외부에서 객체 내부의 값을 변경하도록 하는 것이 아닌, 객체 외부에서는 \"이 값 좀 이걸로 수정해줘\" 라고 말하고, 객체 내부에서는 그 요청에 대한 처리를 수행하면 될 것 같다.\n> - `setter` 로 외부에서 값을 수정하지 말고, `updateValue()` 와 같은 메소드를 생성해 수정할 값을 넘겨주는 방식!\n\n## 📕 참고\n- [객체지향 생활 체조 원칙 9가지(from 소트웍스 앤솔러지)](https://jamie95.tistory.com/99)\n- [객체지향 생활 체조](https://developerfarm.wordpress.com/2012/01/27/object_calisthenics_3/)\n- [객체지향 생활 체조](https://7942yongdae.tistory.com)\n- [1급 컬렉션](https://jojoldu.tistory.com/412)\n- [9번째 원칙](https://devwooks.tistory.com/59)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. JPA를 사용하는 데 가장 중요한 일은 \"엔티티와 테이블을 정확히 매핑하는 것\"이다. 이를 위해서는 매핑 annotation을 숙지하고 사용해야 한다. 아래는 대표 annotation들이다. 객체와 테이블 매핑 :  ,  기본 키 매핑 :  필드와 컬럼 매핑 :  연관…","fields":{"slug":"/[JPA]4/"},"frontmatter":{"date":"March 11, 2022","title":"📚 4. 엔티티 매핑","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> JPA를 사용하는 데 가장 중요한 일은 **\"엔티티와 테이블을 정확히 매핑하는 것\"**이다. 이를 위해서는 매핑 annotation을 숙지하고 사용해야 한다. 아래는 대표 annotation들이다.\n> - 객체와 테이블 매핑 : `@Entity` , `@Table`\n> - 기본 키 매핑 : `@Id`\n> - 필드와 컬럼 매핑 : `@Column`\n> - 연관관계 매핑 : `@ManyToOne` , `@JoinColumn`\n\n## 💫 @Entity\nJPA를 사용해 테이블과 매핑할 클래스는 해당 annotation을 필수로 붙여야 한다. 이 annotation이 붙은 클래스는 JPA가 관리하는 것으로, 엔티티라 부른다. \n\n> **속성 정리**\n> - **name**\n>   - JPA에서 사용할 엔티티 이름을 지정한다. 보통 기본값인 클래스 이름을 사용한다. \n\n`@Entity` 적용 시 아래와 같은 주의사항이 있다.\n- 기본 생성자는 필수다(파라미터가 없는 `public` 또는 `protected` 생성자)\n  - JPA가 엔티티 객체를 생성할 때 기본 생성자를 사용하기 때문이다.\n- `final` 클래스, `enum`, `interface`, `inner` 클래스에는 사용할 수 없다.\n- 저장할 필드에 `final` 을 사용하면 안된다.\n\n자바는 생성자가 하나도 없으면 기본 생성자를 자동으로 생성한다. 문제는 생성자를 하나 이상 만들 경우 자바는 기본 생성자를 자동으로 생성하지 않는다. 따라서 기본 생성자를 직접 만들어야 한다.\n\n```java\npublic Member() {} // 기본 생성자\n\npublic Member(String name) { // 임의의 생성자\n  this.name = name;\n}\n```\n\n## 💫 @Table\n엔티티와 매핑할 테이블을 지정하는 annotation으로 생략하는 경우 매핑한 엔티티 이름을 테이블 이름으로 사용한다.\n\n> **속성 정리**\n> - **name**\n>   - 매핑할 테이블 이름으로, 기본값은 엔티티 이름이다.\n> - **catalog**\n>   - catalog 기능이 있는 데이터베이스에서 catalog를 매핑한다.\n>   - catalog: 데이터베이스의 개체들에 대한 정의를 담고 있는 일종의 메타데이터들로 구성된 인스턴스\n> - **schema**\n>   - schema 기능이 있는 데이터베이스에서 schema를 매핑한다.\n> - **uniqueConstraints(DDL)**\n>   - DDL 생성 시 유니크 제약 조건을 만든다. 2개 이상의 복합 유니크 제약조건도 가능하다.\n>   - 스키마 자동 생성 기능을 사용해서 DDL을 만들 때만 사용된다.\n\n---\n\n## 💫 다양한 매핑 사용\n이전 장에서 개발하던 회원 관리 프로그램에 다음 요구사항이 추가되었다.\n1. 회원은 일반 회원과 관리자로 구분해야 한다.\n2. 회원 가입일과 수정일이 있어야 한다.\n3. 회원을 설명할 수 있는 필드가 있어야 한다. 이 필드는 길이 제한이 없다.\n\n기능 구현을 위해 회원 엔티티 코드를 추가한다.\n\n```java\n@Entity\n@Table(name=\"MEMBER\")\npublic class Member {\n  ...\n\n  @Enumerated(EnumType.STRING)\n  private RoleType roleType;\n\n  @Temporal(TemporalType.TIMESTAMP)\n  private Date createdDate;\n\n  @Temporal(TemporalType.TIMESTAMP)\n  private Date lastModifiedDate;\n\n  @Lob\n  private String description;\n\n  ...\n\n}\n```\n\n위 코드를 분석해보면,\n- `roleType` : 자바의 `enum` 을 사용해 회원의 타입을 구분했다. \n  - 이처럼 `enum` 을 사용하려면 `@Enumerated` annotation으로 매핑해야 한다. \n- `createdDate` , `lastModifiedDate` : 자바의 날짜 타입은 `@Temporal` 을 사용해서 매핑한다.\n- `description` : 회원을 설명하는 필드로서 길이 제한이 없어야 한다. 따라서 데이터베이스의 `VARCHAR` 타입 대신 `CLOB` 타입으로 저장해야 한다.\n\n---\n\n## 💫 데이터베이스 스키마 자동 생성\nJPA는 **데이터베이스 스키마를 자동으로 생성하는 기능**이 있다. 클래스의 매핑 정보를 보고 어떤 테이블에 어떤 컬럼을 사용하는지 알 수 있어 이를 통해 데이터베이스 스키마를 생성한다.\n\n먼저 `persistence.xml` 에 속성을 추가하여 애플리케이션 실행 시점에 데이터베이스 테이블을 자동으로 생성하도록 한다.\n\n```xml\n<property name=\"hibernate.hbm2ddl.auto\" value=\"create\" />\n```\n\n`show_sql` 속성으로 실행 결과를 보면, 기존 테이블을 삭제하고 새로 생성하는 것을 확인할 수 있고, 아래와 같이 매핑되어 생성되는 것을 확인할 수 있다.\n- `roleType` → `VARCHAR` , `createdDate` , `lastModifiedDate` → `TIMESTAMP` , `description` → `CLOB` 타입\n\n> 자동 생성되는 DDL은 지정한 데이터베이스 방언에 따라 달라진다.\n\n이 기능을 사용해 개발자가 테이블을 직접 생성하는 수고를 덜었다. 하지만 이 DDL이 완벽한 것은 아니기에 참고하는 정도로만 사용하는 것이 좋다.\n\n> **`hibernate.hbm2ddl.auto` 속성 정리**\n> - create : 기존 테이블 삭제 + 새로 생성 (DROP + CREATE)\n> - create-drop : create 속성에 추가로 애플리케이션 종료 시 생성한 DDL을 제거 (DROP + CREATE + DROP)\n> - update : 데이터베이스 테이블과 엔티티 매핑 정보를 비교해 변경 사항만 수정 (JPA 2.1부터는 지원 X)\n> - validate : 데이터베이스 테이블과 엔티티 매핑 정보를 비교해 차이가 있으면 경고를 남기고 실행하지 않음 (DDL을 수정하지 않는 설정, JPA 2.1부터는 지원 X)\n> - none : 자동 생성 기능을 사용하지 않음\n\n---\n\n## 💫 DDL 생성 기능\n회원 이름은 필수 입력 값이고, 10자를 초과하면 안된다는 제약조건이 추가되었다. 스키마 자동 생성을 통해 만들어지는 DDL에 이 제약조건을 추가한다.\n\n```java\n@Column(name = \"NAME\", nullable = false, length = 10)\nprivate String username;\n```\n\n- `@Column` 의 `nullable` 속성 값으로 자동 생성되는 DDL에 `not null` 제약조건을 추가할 수 있다.\n- 또한, `length` 속성 값으로 문자의 크기도 지정할 수 있다.\n\n이번에는 유니크 제약조건을 만들어 주는 `@Table` 의 `uniqueConstraints` 속성을 사용해본다.\n\n```java\n@Entity\n@Table(name=\"MEMBER\", uniqueConstraints = {@UniqueConstraint(\n        name = \"NAME_AGE_UNIQUE\",\n        columnNames = {\"NAME\", \"AGE\"})})\npublic class Member {\n  ...\n\n}\n```\n\n위의 속성들은 단지 **DDL 자동 생성 시에만 사용되고 JPA의 실행 로직에는 영향을 주지 않는다.**\n\n---\n\n## 💫 기본 키 매핑\n지금까지는 `@Id` annotation만 사용해 회원의 기본 키를 애플리케이션에서 직접 할당했다. \n- 기본 키를 애플리케이션에서 직접 할당하는 방식이 아닌 데이터베이스가 생성해주는 값으로 사용하려면 어떻게 매핑해야 할까?\n  - MySQL의 `AUTO_INCREMENT` 같은 기능\n- 데이터베이스마다 기본 키를 생성하는 방식이 달라 해결하기는 쉽지 않다.\n\nJPA는 데이터베이스 기본 키 생성 전략이 다음과 같다.\n- **직접 할당** : 기본 키를 애플리케이션에서 직접 할당한다.\n- **자동 생성** : 대리 키 사용 방식\n  - IDENTITY : 기본 키 생성을 데이터베이스에 위임한다.\n  - SEQUENCE : 데이터베이스 시퀸스를 사용해 기본 키를 할당한다.\n  - TABLE : 키 생성 테이블을 사용한다.\n\n자동 생성 전략이 다양한 이유는 데이터베이스마다 지원 방식이 서로 다르기 때문이다. SEQUENCE나 IDENTITY 방식은 사용하는 데이터베이스에 의존하고, TABLE 방식은 테이블을 활용하기에 모든 데이터베이스에서 사용할 수 있다.\n\n자동 생성 전략을 사용하기 위해서는 `@Id` 에 `@GeneratedValue` 를 추가하고 원하는 생성 전략을 선택하면 된다.\n\n> 키 생성 전략 사용 시 `hibernate.id.new_generator_mappings=true` 속성이 필수적이다.\n\n### ➰ 기본 키 직접 할당 전략\n`@Id` 로 매핑하면 되고, 적용 가능한 자바 타입은 다음과 같다.\n- 자바 기본형\n- 자바 Wrapper형\n- `String`\n- `java.util.Date`\n- `java.sql.Date`\n- `java.math.BigDecimal`\n- `java.math.BigInteger`\n\n이 전략은 `em.persist()` 로 엔티티를 저장하기 전에 애플리케이션에서 기본 키를 직접 할당하는 방법이다.\n\n```java\nBoard board = new Board();\nboard.setId(\"id1\");\nem.persist(board);\n```\n\n> 이 전략에서 식별자 값 없이 저장하면 예외가 발생한다. \n> JPA 표준에 정의되어 있진 않지만 hibernate를 구현체로 사용하면 JPA 최상위 예외인 `javax.persistence.PersistenceException` 이 발생하고 이는 내부에 hibernate 예외인 `org.hibernate.id.IdentifierGenerationException` 을 포함하고 있다.\n\n### ➰ IDENTITY 전략\n기본 키 생성을 데이터베이스에 위임하는 전략이다. 주로 MySQL, PostgreSQL, SQL Server, DB2에서 사용된다. 예를 들어 MySQL의 `AUTO_INCREMENT` 기능을 수행하는 예제를 보면,\n\n```sql\nCREATE TABLE BOARD (\n  ID INT NOT NULL AUTO_INCREMENT PRIMARY KEY,\n  DATA VARCHAR(255)\n);\n\nINSERT INTO BOARD(DATA) VALUES('A');\nINSERT INTO BOARD(DATA) VALUES('B');\n```\n\n- 테이블 생성 시 기본 키 컬럼에 `AUTO_INCREMENT` 를 추가해 데이터베이스에 값을 저장할 때 `ID` 컬럼을 비워두면 자동으로 순서대로 값을 채워준다.\n\nIDENTITY 전략은 이처럼 \"데이터베이스에 값을 저장하고 나서야 기본 키 값을 구할 수 있을 때\" 사용한다.\n\n개발자가 엔티티에 직접 식별자를 할당하면 `@Id` annotation만 있으면 되지만 지금처럼 생성되는 경우에는 `@GeneratedValue` annotation을 사용해 식별자 생성 전략을 선택해야 한다. \n-  이때 JPA는 기본 키 값을 얻어오기 위해 데이터베이스를 추가로 조회한다.\n\n```java\n@Id\n@GeneratedValue(strategy = GenerationType.IDENTITY)\n@Column(name = \"ID\")\nprivate Long id;\n```\n\n> 해당 전략은 데이터베이스에 INSERT한 후에 기본 키 값을 조회할 수 있다. 따라서 엔티티에 식별자 값을 할당하기 위해서는 추가적인 조회가 필요했다. JDBC3에 추가된 `Statement.getGeneratedKeys()` 를 사용하면 데이터 저장과 동시에 생성된 기본 키 값도 얻어올 수 있다. hibernate는 이 메소드를 사용해 데이터베이스와 **한 번만 통신**한다.\n\n> 엔티티가 영속 상태가 되려면 식별자가 반드시 필요하다. 하지만 이 전략은 데이터베이스에 엔티티를 저장해야 식별자를 구할 수 있어 트랜잭션을 지원하는 쓰기 지연이 동작하지 않는다.\n\n### ➰ SEQUENCE 전략\n데이터베이스 시퀸스는 유일한 값을 순서대로 생성하는 특별한 데이터베이스 오브젝트다. **SEQUENCE 전략은 시퀸스를 사용해 기본 키를 생성**한다. 당연히 시퀸스를 지원하는 오라클, PostgreSQL, DB2, H2 데이터베이스에서만 사용할 수 있다.\n\n```sql\nCREATE TABLE BOARD (\n  ID BIGINT NOT NULL PRIMARY KEY,\n  DATA VARCHAR(255)\n)\n\n-- 시퀸스 생성\nCREATE SEQUENCE BOARD_SEQ START WITH 1 INCREMENT BY 1;\n```\n\n- 시퀸스의 사용을 위해서는 **시퀸스를 생성**해야 한다.\n\n```java\n@Entity\n@SequenceGenerator(\n  name=\"BOARD_SEQ_GENERATOR\", \n  sequenceName = \"BOARD_SEQ\", // 매핑할 데이터베이스 시퀸스 이름\n  initialValue = 1, allocationSize = 1)\npublic class Member {\n\n  @Id\n  @GeneratedValue(strategy = GenerationType.SEQUENCE,\n                  generator = \"BOARD_SEQ_GENERATOR\")\n  private Long id;\n  ...\n\n}\n```\n\n- 이후 사용할 **데이터베이스 시퀸스를 매핑**해야 한다. 위 예제에서는 `@SequenceGenerator` 를 사용해 `BOARD_SEQ_GENERATOR` 라는 시퀸스 생성기를 등록했다.\n- `sequenceName` 속성의 이름으로 `BOARD_SEQ` 를 지정하여 JPA가 이 시퀸스 생성기를 실제 데이터베이스의 `BOARD_SEQ` 시퀸스와 매핑하도록 한다.\n- 키 생성 전략을 설정하고 생성기를 등록한 시퀸스 생성기로 선택하여 `id` 식별자 값은 `BOARD_SEQ_GENERATOR` 시퀸스 생성기가 할당한다. \n\n시퀸스 사용코드는 IDENTITY 전략과 같지만 내부 동작 방식은 다르다. \n- 이 전략은 `em.persist()` 호출 시 먼저 데이터베이스 시퀸스를 사용해서 **식별자를 조회**한다. 그리고 조회한 식별자를 엔티티에 할당한 후에 엔티티를 영속성 컨텍스트에 저장한다.\n- 이후 트랜잭션을 커밋해서 플러시가 일어나면 엔티티를 데이터베이스에 저장한다.\n\n> IDENTITY 전략과는 조금 반대의 느낌\n\n> **@SequenceGenerator 속성 정리**<br/>\n> - **name**\n>   - 식별자 생성기 이름 (필수 값)\n> - **sequenceName**\n>   - 데이터베이스에 등록되어 있는 시퀸스 이름\n> - **initialValue**\n>   - DDL 생성 시에만 사용됨. 시퀸스 DDL을 생성할 때 처음 시작하는 수를 지정\n> - **allocationSize**\n>   - 시퀸스 한 번 호출에 증가하는 수 (성능 최적화를 위해 기본 값이 50)\n> - **catalog, schema**\n>   - 데이터베이스 catalog, schema 이름\n\n> **SEQUENCE 전략과 최적화**<br/>\n> 해당 전략은 데이터베이스 시퀸스를 통해 식별자를 조회하는 추가 작업이 필요해 **데이터베이스와 2번 통신**한다.\n> <br/>\n> 1. 식별자를 구하려고 데이터베이스 시퀸스를 조회한다.\n> 2. 조회한 시퀸스를 기본 키 값으로 사용해 데이터베이스에 저장한다.\n> \n> JPA는 시퀸스에 접근하는 횟수를 줄이기 위해 `allocationSize` 속성을 사용한다. 설정한 값만큼 한 번에 시퀸스 값을 증가시키고 그만큼 메모리에 시퀸스 값을 할당한다. \n> \n> 이러한 방법으로 시퀸스 값을 선점해 여러 JVM이 동시에 동작해도 기본 키 값이 충돌하지 않는다는 장점이 있다. \n\n### ➰ TABLE 전략\n**키 생성 전용 테이블을 하나 만들고** 여기에 이름과 값으로 사용할 컬럼을 만들어 데이터베이스 시퀸스를 흉내내는 전략이다. 모든 데이터베이스에 적용할 수 있는 전략이다.\n\n```sql\ncreate table MY_SEQUENCES (\n  sequence_name varchar(255) not null,\n  next_val bigint,\n  primary key (sequence_name)\n)\n```\n- 먼저 키 생성용 테이블을 생성한다.\n\n```java\n@Entity\n@TableGenerator(\n  name=\"BOARD_SEQ_GENERATOR\", \n  table = \"MY_SEQUENCES\", // 매핑할 데이터베이스 시퀸스 이름\n  pkColumnValue = \"BOARD_SEQ\", allocationSize = 1)\npublic class Member {\n\n  @Id\n  @GeneratedValue(strategy = GenerationType.TABLE,\n                  generator = \"BOARD_SEQ_GENERATOR\")\n  private Long id;\n  ...\n\n}\n```\n\n- `@TableGenerator` 로 테이블 키 생성기를 등록하고, 생성한 `MY_SEQUENCES` 테이블을 키 생성용 테이블로 매핑한다.\n- TABLE 전략을 선택하고, 방금 등록한 테이블 키 생성기를 지정한다.\n- 시퀸스 대신 테이블을 사용한다는 것만 제외하면 SEQUENCE 전략과 내부 동작방식이 동일하다.\n\n> **@TableGenerator 속성 정리**<br/>\n> - **name**\n>   - 식별자 생성기 이름 (필수 값)\n> - **table**\n>   - 키 생성 테이블명\n> - **pkColumnName**\n>   - 시퀀스 컬럼명\n> - **valueColumnName**\n>   - 시퀀스 값 컬럼명\n> - **pkColumnValue**\n>   - 키로 사용할 값 이름\n> - **initialValue**\n>   - 초기값, 마지막으로 생성된 값이 기준이고, 기본값은 0\n> - **allocationSize**\n>   - 시퀸스 한 번 호출에 증가하는 수 (성능 최적화를 위해 기본 값이 50)\n> - **catalog, schema**\n>   - 데이터베이스 catalog, schema 이름\n> - **uniqueConstraints**\n>   - 유니크 제약 조건 지정\n\n> **TABLE 전략과 최적화**<br/>\n> 값을 조회하면서 SELECT 쿼리를 사용하고, 다음 값으로 증가시키기 위해 UPDATE 쿼리를 사용하여 **SEQUENCE 전략에 비해 1번 더 데이터베이스와 통신**한다.\n> \n> 이또한 SEQUENCE 전략과 동일하게 `allocationSize` 을 사용해 최적화할 수 있다.\n\n### ➰ AUTO 전략\n해당 전략은 선택한 데이터베이스 방언에 따라 위에서 다룬 **전략들 중 하나를 자동으로 선택**한다. (Oracle - SEQUENCE, MySQL - IDENTITY)\n\n```java\n@Entity\npublic class Member {\n\n  @Id\n  @GeneratedValue(strategy = GenerationType.AUTO)\n  private Long id;\n  ...\n\n}\n```\n\n- `@GeneratedValue.strategy` 의 기본값은 AUTO다. 따라서 굳이 명시하지 않은 것과 동일하다.\n- 장점은 데이터베이스를 변경해도 코드는 수정하지 않아도 된다는 점이다. 개발 초기 단계나 프로토타입 개발 시 편리하게 사용할 수 있다.\n- SEQUENCE나 TABLE 전략이 선택되면 이를 위한 시퀸스나 테이블이 생성되어 있어야 하는데, 스키마 자동 생성 기능을 사용한다면 Hibernate가 알아서 생성해줄 것이다.\n\n### ➰ 기본 키 매핑 정리\n영속성 컨텍스트는 엔티티를 식별자 값으로 구분하기에 엔티티를 영속 상태로 만들려면 식별자 값이 반드시 필요하다. `em.persist()` 호출 직후 식별자 할당 전략별 발생하는 일을 정리하면 아래와 같다.\n\n- 직접 할당 : 애플리케이션에서 직접 식별자 값을 미리 할당해야 한다.\n- SEQUENCE : 데이터베이스 시퀸스에서 식별자 값을 획득한 후 영속성 컨텍스트에 저장한다.\n- TABLE : 데이터베이스 시퀸스 생성용 테이블에서 식별자 값을 획득한 후 영속성 컨텍스트에 저장한다.\n- IDENTITY : 데이터베이스에 엔티티를 저장해서 식별자 값을 획득한 후 영속성 컨텍스트에 저장한다.\n\n---\n\n## 💫 필드와 컬럼 매핑 분류\nJPA가 제공하는 필드와 컬럼 매핑용 annotation들을 간단히 정리했다.\n\n|분류|매핑 annotation|설명|\n|---|---|---|\n|필드와 컬럼 매핑|`@Column`|컬럼 매핑|\n||`@Enumerated`|자바의 enum 타입 매핑|\n||`@Temporal`|날짜 타입 매핑|\n||`@Lob`|BLOB, CLOB 타입 매핑|\n||`@Transient`|특정 필드를 데이터베이스에 매핑하지 않음|\n|기타|`@Access`|JPA가 엔티티에 접근하는 방식 지정|\n\n## 📕 출처\n- **자바 ORM 표준 JPA 프로그래밍** - 김영한\n- [엔티티의 생명주기](https://ultrakain.gitbooks.io/jpa/content/chapter3/chapter3.3.html)\n- [데이터베이스 catalog](https://ko.wikipedia.org/wiki/%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4_%EC%B9%B4%ED%83%88%EB%A1%9C%EA%B7%B8)"},{"excerpt":"문제 총 8개의 톱니를 가지고 있는 톱니바퀴 4개가 아래 그림과 같이 일렬로 놓여져 있다. 또, 톱니는 N극 또는 S극 중 하나를 나타내고 있다. 톱니바퀴에는 번호가 매겨져 있는데, 가장 왼쪽 톱니바퀴가 1번, 그 오른쪽은 2번, 그 오른쪽은 3번, 가장 오른쪽 톱니바퀴는 4번이다. 이때, 톱니바퀴를 총 K번 회전시키려고 한다. 톱니바퀴의 회전은 한 칸을…","fields":{"slug":"/[BOJ]14891/"},"frontmatter":{"date":"March 06, 2022","title":"👩‍💻 14891. 톱니바퀴","tags":["구현","시뮬레이션"]},"rawMarkdownBody":"\n## 문제\n총 8개의 톱니를 가지고 있는 톱니바퀴 4개가 아래 그림과 같이 일렬로 놓여져 있다. 또, 톱니는 N극 또는 S극 중 하나를 나타내고 있다. 톱니바퀴에는 번호가 매겨져 있는데, 가장 왼쪽 톱니바퀴가 1번, 그 오른쪽은 2번, 그 오른쪽은 3번, 가장 오른쪽 톱니바퀴는 4번이다.\n\n이때, 톱니바퀴를 총 K번 회전시키려고 한다. 톱니바퀴의 회전은 한 칸을 기준으로 한다. 회전은 시계 방향과 반시계 방향이 있다.\n\n톱니바퀴를 회전시키려면, 회전시킬 톱니바퀴와 회전시킬 방향을 결정해야 한다. 톱니바퀴가 회전할 때, 서로 맞닿은 극에 따라서 옆에 있는 톱니바퀴를 회전시킬 수도 있고, 회전시키지 않을 수도 있다. 톱니바퀴 A를 회전할 때, 그 옆에 있는 톱니바퀴 B와 서로 맞닿은 톱니의 극이 다르다면, B는 A가 회전한 방향과 반대방향으로 회전하게 된다. 예를 들어, 아래와 같은 경우를 살펴보자.\n\n<img src=\"https://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/problem/14891/4.png\" width=\"80%\">\n\n두 톱니바퀴의 맞닿은 부분은 초록색 점선으로 묶여있는 부분이다. 여기서, 3번 톱니바퀴를 반시계 방향으로 회전했다면, 4번 톱니바퀴는 시계 방향으로 회전하게 된다. 2번 톱니바퀴는 맞닿은 부분이 S극으로 서로 같기 때문에, 회전하지 않게 되고, 1번 톱니바퀴는 2번이 회전하지 않았기 때문에, 회전하지 않게 된다. 따라서, 아래 그림과 같은 모양을 만들게 된다.\n\n<img src=\"https://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/problem/14891/5.png\" width=\"80%\">\n\n1번 톱니바퀴를 시계 방향으로 회전시키면, 2번 톱니바퀴가 반시계 방향으로 회전하게 되고, 2번이 회전하기 때문에, 3번도 동시에 시계 방향으로 회전하게 된다. 4번은 3번이 회전하지만, 맞닿은 극이 같기 때문에 회전하지 않는다. 따라서, 아래와 같은 상태가 된다.\n\n<img src=\"https://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/problem/14891/6.png\" width=\"80%\">\n\n톱니바퀴의 초기 상태와 톱니바퀴를 회전시킨 방법이 주어졌을 때, 최종 톱니바퀴의 상태를 구하는 프로그램을 작성하시오.\n\n## 입, 출력\n\n입력\n- 첫째 줄에 1번 톱니바퀴의 상태, 둘째 줄에 2번 톱니바퀴의 상태, 셋째 줄에 3번 톱니바퀴의 상태, 넷째 줄에 4번 톱니바퀴의 상태가 주어진다. 상태는 8개의 정수로 이루어져 있고, 12시방향부터 시계방향 순서대로 주어진다. N극은 0, S극은 1로 나타나있다.\n- 다섯째 줄에는 회전 횟수 K(1 ≤ K ≤ 100)가 주어진다. 다음 K개 줄에는 회전시킨 방법이 순서대로 주어진다. 각 방법은 두 개의 정수로 이루어져 있고, 첫 번째 정수는 회전시킨 톱니바퀴의 번호, 두 번째 정수는 방향이다. 방향이 1인 경우는 시계 방향이고, -1인 경우는 반시계 방향이다.\n\n출력\n- 총 K번 회전시킨 이후에 네 톱니바퀴의 점수의 합을 출력한다. 점수란 다음과 같이 계산한다.\n  - 1번 톱니바퀴의 12시방향이 N극이면 0점, S극이면 1점\n  - 2번 톱니바퀴의 12시방향이 N극이면 0점, S극이면 2점\n  - 3번 톱니바퀴의 12시방향이 N극이면 0점, S극이면 4점\n  - 4번 톱니바퀴의 12시방향이 N극이면 0점, S극이면 8점\n\n### 📍 **Logic**\n\n```java\nclass Gear {\n    int[] tooth;\n    boolean spinStatus;\n    int spinDir;\n\n    public Gear() {\n        tooth = new int[8];\n        spinStatus = false;\n        spinDir = 0;\n    }\n\n    public void clockWise() {\n        int tmp = tooth[7];\n        System.arraycopy(tooth, 0, tooth, 1, 7);\n        tooth[0] = tmp;\n    }\n\n    public void counterClockWise() {\n        int tmp = tooth[0];\n        System.arraycopy(tooth, 1, tooth, 0, 7);\n        tooth[7] = tmp;\n    }\n}\n```\n\n- 톱니바퀴의 정보를 저장하는 클래스이다.\n- `clockWise()` 는 톱니를 시계방향으로 돌렸을 때 상태 업데이트를 수행하고, `counterClockWise()` 는 반시계방향에 대한 업데이트를 수행한다.\n\n```java\nfor (int i = 0; i < N; i++) {\n    spins[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n    int centerG = spins[i][0] - 1;\n    gears[centerG].spinStatus = true;\n    gears[centerG].spinDir = spins[i][1];\n\n    for (int j = centerG - 1; j >= 0; j--) {\n        if (gears[j + 1].spinStatus) {\n            if (gears[j].tooth[2] != gears[j + 1].tooth[6]) {\n                gears[j].spinStatus = true;\n                gears[j].spinDir = gears[j + 1].spinDir * -1;\n            }\n        }\n    }\n\n    for (int j = centerG + 1; j < 4; j++) {\n        if (gears[j - 1].spinStatus) {\n            if (gears[j].tooth[6] != gears[j - 1].tooth[2]) {\n                gears[j].spinStatus = true;\n                gears[j].spinDir = gears[j - 1].spinDir * -1;\n            }\n        }\n    }\n\n    for (int j = 0; j < 4; j++) {\n        if (gears[j].spinDir == -1) gears[j].counterClockWise();\n        else if (gears[j].spinDir == 1) gears[j].clockWise();\n        gears[j].spinDir = 0;\n        gears[j].spinStatus = false;\n    }\n}\n```\n\n- 중심 구현부는 크게 3개로 나눌 수 있다.\n  - 회전하는 톱니의 왼쪽 톱니에 대해 회전여부를 판단하고 수행하는 for문\n  - 회전하는 톱니의 오른쪽 톱니에 대해 회전여부를 판단하고 수행하는 for문\n  - 주어진 1회전이 끝난 후 톱니의 정보를 업데이트하는 for문\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.*;\n\n    class Gear {\n        int[] tooth;\n        boolean spinStatus;\n        int spinDir;\n\n        public Gear() {\n            tooth = new int[8];\n            spinStatus = false;\n            spinDir = 0;\n        }\n\n        public void clockWise() {\n            int tmp = tooth[7];\n            System.arraycopy(tooth, 0, tooth, 1, 7);\n            tooth[0] = tmp;\n        }\n\n        public void counterClockWise() {\n            int tmp = tooth[0];\n            System.arraycopy(tooth, 1, tooth, 0, 7);\n            tooth[7] = tmp;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            Gear[] gears = new Gear[4];\n\n            for (int i = 0; i < 4; i++) {\n                gears[i] = new Gear();\n                gears[i].tooth = Arrays.stream(br.readLine().split(\"\")).mapToInt(Integer::parseInt).toArray();\n            }\n\n            int N = Integer.parseInt(br.readLine());\n            int[][] spins = new int[N][2];\n\n            for (int i = 0; i < N; i++) {\n                spins[i] = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n                int centerG = spins[i][0] - 1;\n                gears[centerG].spinStatus = true;\n                gears[centerG].spinDir = spins[i][1];\n\n                for (int j = centerG - 1; j >= 0; j--) {\n                    if (gears[j + 1].spinStatus) {\n                        if (gears[j].tooth[2] != gears[j + 1].tooth[6]) {\n                            gears[j].spinStatus = true;\n                            gears[j].spinDir = gears[j + 1].spinDir * -1;\n                        }\n                    }\n                }\n\n                for (int j = centerG + 1; j < 4; j++) {\n                    if (gears[j - 1].spinStatus) {\n                        if (gears[j].tooth[6] != gears[j - 1].tooth[2]) {\n                            gears[j].spinStatus = true;\n                            gears[j].spinDir = gears[j - 1].spinDir * -1;\n                        }\n                    }\n                }\n\n                for (int j = 0; j < 4; j++) {\n                    if (gears[j].spinDir == -1) gears[j].counterClockWise();\n                    else if (gears[j].spinDir == 1) gears[j].clockWise();\n                    gears[j].spinDir = 0;\n                    gears[j].spinStatus = false;\n                }\n            }\n\n            N = 0;\n            for (int i = 0; i < 4; i++) N += gears[i].tooth[0] * Math.pow(2,i);\n\n            System.out.println(N);\n\n            br.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 정말 오랜만에 1트만에 성공했다. 난이도 높은 문제는 아니었지만 ...\n- 문제 풀이를 구상하면서, 어떤 메소드를 구현해야하며, 어떤 메소드를 객체에 둬야 하는지에 대해 좀 더 공부해봐야겠다.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/14891"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. JPA가 제공하는 기능은 크게 \"엔티티와 테이블을 매핑하는 설계\"와 \"매핑한 엔티티를 실제 사용하는 부분\"으로 나눌 수 있다.\n이 장에서는 매핑한 엔티티를 엔티티 매니저를 통해 어떻게 사용하는지 알아본다. 엔티티 매니저는 엔티티를 저장하고, 수정하고, 삭제하고, 조회하…","fields":{"slug":"/[JPA]3/"},"frontmatter":{"date":"March 06, 2022","title":"📚 3. 영속성 관리","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> JPA가 제공하는 기능은 크게 \"엔티티와 테이블을 매핑하는 설계\"와 \"매핑한 엔티티를 실제 사용하는 부분\"으로 나눌 수 있다.\n> 이 장에서는 매핑한 엔티티를 엔티티 매니저를 통해 어떻게 사용하는지 알아본다.\n\n엔티티 매니저는 **엔티티를 저장**하고, **수정**하고, **삭제**하고, **조회**하는 등 엔티티와 관련된 모든 일을 처리한다. 이전 장에서도 언급했듯, 개발자는 이를 **가상의 데이터베이스**라고 생각해도 무방하다.\n\n## 💫 엔티티 매니저 팩토리와 엔티티 매니저\n이전 장에서 언급했듯, 데이터베이스를 하나만 사용하는 애플리케이션은 일반적으로 `EntityManagerFactory` 를 하나만 생성하고, 이 작업은 비용이 많이 들기에 생성한 팩토리를 재사용(또는 공유)하는 방식으로 사용된다.\n\n그리고 생성한 팩토리를 이용해 필요할 때마다 엔티티에 관련된 작업을 처리할 엔티티 매니저를 생성한다. 이 작업에 대한 비용은 거의 들지 않는다. 엔티티 매니저 팩토리와 엔티티 매니저를 비교하면 다음과 같다.\n\n**엔티티 매니저 팩토리**\n- 여러 스레드가 동시에 접근해도 안전하므로 서로 다른 스레드 간 공유가 가능\n\n**엔티티 매니저**\n- 여러 스레드가 동시에 접근하면 동시성 문제가 발생해 공유가 불가능\n\n하나의 `EntityManagerFactory` 에서 다수의 엔티티 매니저를 생성한다. 엔티티 매니저는 **데이터베이스 연결이 꼭 필요한 시점까지 데이터베이스 커넥션을 얻지 않는다.** \n- 예를 들어, 트랜잭션을 시작할 때 커넥션을 획득해 데이터베이스와 연결해 작업을 처리한다.\n\nHibernate를 포함한 JPA 구현체들은 `EntityManagerFactory` 생성 시 커넥션 풀도 만드는데(`persistence.xml` 을 보면 데이터베이스 접속 정보가 있다.), 이는 J2SE 환경에서 사용하는 방법이다.\n- JPA를 J2EE 환경(스프링 프레임워크 포함)에서 사용하면 해당 컨테이너가 제공하는 데이터소스를 사용한다.\n\n## 💫 영속성 컨텍스트란?\nPersistence Context, JPA를 이해하는데 가장 중요한 용어이다. 해석하자면, **\"엔티티를 영구 저장하는 환경\"**이라는 뜻이다. 엔티티 매니저로 엔티티를 저장하거나 조회하면 엔티티 매니저는 **영속성 컨텍스트에 엔티티를 보관하고 관리**한다.\n\n```java\nem.persist(member);\n```\n- 지금까지는 위 코드를 **단순히 회원 엔티티를 저장**한다고 표현했다.\n- 정확히는 위 메소드는 **엔티티 매니저를 사용해서 회원 엔티티를 영속성 컨텍스트에 저장**한다.\n\n영속성 컨텍스트는 논리적인 개념에 가깝고 눈에 보이지도 않아 직접 본 적은 없을 것이다. \n- 이는 엔티티 매니저를 생성할 때 하나 만들어지고, **매니저를 통해 접근하거나 관리**할 수 있다.\n\n> 여러 엔티티 매니저가 동일한 영속성 컨텍스트에 접근할 수도 있다.\n\n---\n\n## 💫 엔티티의 생명주기\n엔티티에는 4가지 상태가 존재한다.\n- 비영속(new/transient) : 영속성 컨텍스트와 전혀 관계가 없는 상태\n- 영속(managed) : 영속성 컨텍스트에 저장된 상태\n- 준영속(detached) : 영속성 컨텍스트에 저장되었다가 분리된 상태\n- 삭제(removed) : 삭제된 상태\n\n<img src=\"https://ultrakain.gitbooks.io/jpa/content/chapter3/images/JPA_3_2.png\" width=\"80%\">\n\n**비영속**<br/>\n엔티티 객체를 생성했다. 순수한 객체 상태이며 아직 저장하지는 않아서 영속성 컨텍스트나 데이터베이스와는 전혀 관련이 없다. 이를 **비영속 상태**라 한다.\n\n```java\nMember member = new Member();\nmember.setId(\"member1\");\nmemeber.setUsername(\"회원1\");\n```\n\n**영속**<br/>\n엔티티 매니저를 통해 영속성 컨텍스트에 저장했다. 이렇게 **영속성 컨텍스트가 관리하는 엔티티를 영속 상태**라 한다. 이제 엔티티의 상태가 비영속 → 영속 상태로 변경되었다. \n\n> 즉, 영속 상태라는 것은 **영속성 컨텍스트에 의해 관리된다는 뜻**이다.\n\n그리고 `em.find()` 나 JPQL을 사용해서 조회한 엔티티도 영속성 컨텍스트가 관리하는 영속 상태이다.\n\n```java\nem.persist(member);\n```\n\n**준영속**<br/>\n영속성 컨텍스트가 관리하던 **영속 상태의 엔티티를 영속성 컨텍스트가 관리하지 않으면 준영속 상태**가 된다. `em.detach()` 를 호출하여 준영속 상태로 만들 수 있다. `em.close()` 를 호출해서 영속성 컨텍스트를 닫거나, `em.clear()` 를 호출해 영속성 컨텍스트를 초기화해도 준영속 상태가 된다.\n\n**삭제**<br/>\n엔티티를 영속성 컨텍스트와 데이터베이스에서 삭제한다.\n\n```java\nem.remove(member);\n```\n\n---\n\n## 💫 영속성 컨텍스트의 특징\n**영속성 컨텍스트와 식별자 값**<br/>\n영속성 컨텍스트는 엔티티를 식별자 값(`@Id` 로 테이블의 기본 키와 매핑한 값)으로 구분한다. 따라서, **영속 상태는 식별자 값이 반드시 있어야 한다.** 식별자 값이 없다면 **예외**가 발생한다.\n\n**영속성 컨텍스트와 데이터베이스 저장**<br/>\n영속성 컨텍스트에 엔티티를 저장하면 이 엔티티는 언제 데이터베이스에 저장될까? JPA는 보통 **트랜잭션을 커밋하는 순간** 영속성 컨텍스트에 새로 저장된 엔티티를 데이터베이스에 반영한다. 이를 **플러시(flush)**라고 한다.\n\n**영속성 컨텍스트가 엔티티를 관리하면 다음과 같은 장점이 있다.**<br/>\n- 1차 캐시\n- 동일성 보장\n- 트랜잭션을 지원하는 쓰기 지연\n- 변경 감지\n- 지연 로딩\n\n### ➰ 엔티티 조회\n영속성 컨텍스트는 내부에 캐시를 가지고 있는데 이것을 **1차 캐시**라 한다. 영속 상태의 엔티티는 모두 이곳에 저장된다. \n\n> 쉽게 말해, 영속성 컨텍스트 내부에 **`Map`** 이 하나 있는데 키는 **`@Id` 로 매핑한 식별자**고 값은 **엔티티 인스턴스**다.\n\n```java\n// 엔티티를 생성한 상태(비영속)\nMember member = new Member();\nmember.setId(\"member1\");\nmember.setUsername(\"회원1\");\n\n// 엔티티 영속\nem.persist(member);\n```\n- 위 코드를 실행하면 1차 캐시에 회원 엔티티를 저장한다. 이는 아직 데이터베이스에는 저장되지 않은 상태이다.\n\n1차 캐시의 키는 **식별자 값**이다. 그리고 이는 **데이터베이스 기본 키와 매핑**되어 있다. 따라서 영속성 컨텍스트에 데이터를 저장하고 조회하는 모든 기준은 데이터베이스 기본 값이다. \n\n이를 바탕으로, 엔티티를 조회해본다.\n\n```java\nMember member = em.find(Member.class, \"member1\");\n```\n- `find()` 메소드를 보면, 첫 번째 파라미터는 엔티티 클래스의 타입이고, 두 번째는 조회할 엔티티의 식별자 값이다.\n\n```java\n//EntityManager.find() 메소드의 정의\npublic <T> T find(Class<T> entityClass, Object primaryKey);\n```\n- `em.find()` 를 호출하면 먼저 1차 캐시에서 엔티티를 찾고 만약 없다면 데이터베이스에서 조회한다.\n\n**1차 캐시에서 조회**<br/>\n`em.find()` 를 호출하면 우선 1차 캐시에서 식별자 값으로 엔티티를 찾는다. 만약 있다면, 메모리에 있는 1차 캐시에서 엔티티를 조회한다.\n\n다음은 1차 캐시에 있는 엔티티를 조회하는 코드이다.\n```java\nMember member = new Member();\nmember.setId(\"member1\");\nmember.setUsername(\"회원1\");\n\n// 1차 캐시에 저장됨\nem.persist(member);\n\n// 1차 캐시에서 조회\nMember findMember = em.find(Member.class, \"member1\");\n```\n\n**데이터베이스에서 조회**<br/>\n`em.find()` 를 호출했는데 엔티티가 1차 캐시에 없으면 **엔티티 매니저는 데이터베이스를 조회해서 엔티티를 생성**한다. 그리고 **1차 캐시에 저장한 후 영속 상태의 엔티티를 반환**한다.\n\n```java\nMember findMember2 = em.find(Member.class, \"member2\");\n```\n\n1. `em.find(Member.class, \"member2\")` 를 실행한다.\n2. `member2` 가 1차 캐시에 없으므로 데이터베이스에서 조회한다.\n3. 조회한 데이터로 `member2` 엔티티를 생성해서 1차 캐시에 저장한다.(영속 상태)\n4. 조회한 엔티티를 반환한다.\n\n`member1` , `member2` 엔티티 인스턴스는 1차 캐시에 있다. 따라서 이 엔티티들을 조회하면 메모리에 있는 1차 캐시에서 바로 불러온다. 이렇게 캐시를 통한 성능상의 이점을 얻을 수 있다.\n\n**영속 엔티티의 동일성 보장**<br/>\n아래는 식별자가 같은 엔티티 인스턴스를 조회하여 비교하는 코드이다.\n\n```java\nMember a = em.find(Member.class, \"member1\");\nMember b = em.find(Member.class, \"member1\");\n\nSystem.out.println(a == b); // 동일성 비교\n```\n- `em.find(Member.class, \"member1\")` 를 반복해 호출해도 영속성 컨텍스트는 **1차 캐시에 있는 같은 엔티티 인스턴스를 반환**한다. 따라서 둘은 같은 인스턴스이므로 동일하다. 따라서 **영속성 컨텍스트는 성능상 이점과 엔티티의 동일성을 보장한다.**\n\n> **동일성과 동등성**\n> - 동일성(identity) : 실제 인스턴스가 같다. 따라서 참조 값을 비교하는 == 비교의 값이 같다.\n> - 동등성(equality) : 실제 인스턴스는 다를 수 있지만 인스턴스가 가지고 있는 값이 같다. 자바에서 동등성 비교는 `equals()` 메소드를 구현해야 한다.\n\n### ➰ 엔티티 등록\n엔티티 매니저를 사용해 엔티티를 영속성 컨텍스트에 등록한다.\n\n```java\nEntityManager em = emf.createEntityManager();\nEntityTransaction transaction = em.getTransaction();\n// 엔티티 매니저는 데이터 변경 시 트랜잭션을 시작해야 한다.\ntransaction.begin();\n\nem.persist(memberA);\nem.persist(memberB);\n// 1차 캐시에 엔티티 저장\n// 여기까지 INSERT SQL을 데이터베이스에 보내지 않는다.\n\n// 커밋하는 순간 데이터베이스에 INSERT SQL을 보낸다.\ntransaction.commit();\n```\n- 엔티티 매니저는 트랜잭션 커밋 직전까지 엔티티를 저장하지 않고, 내부 쿼리 저장소에 INSERT SQL들을 모아둔다. 그리고 커밋 시에 모아둔 쿼리를 데이터베이스로 보낸다.\n  - 이를 **트랜잭션을 지원하는 쓰기 지연(Transactional write-behind)**이라 한다.\n- 순서를 보면, 먼저 `memberA` 를 영속화했다. 영속성 컨텍스트는 **1차 캐시에 회원 엔티티를 저장**하면서 동시에 **회원 엔티티 정보로 등록 쿼리를 생성**한다.\n- 그리고 만들어진 **등록 쿼리를 쓰기 지연 SQL 저장소에 보관**한다.\n- 다음으로 `memberB` 를 영속화하면서, **쓰기 지연 SQL 저장소에는 등록 쿼리가 2건 저장**되었다.\n- 마지막으로 **트랜잭션을 커밋**했다. \n  - 먼저 엔티티 매니저는 영속성 컨텍스트를 플러시한다.\n  - 이는 영속성 컨텍스트의 변경 내용을 데이터베이스에 동기화하는 작업으로 이때, 엔티티들의 변경 사항을 데이터베이스에 반영한다.\n  - 다른 말로는 쓰기 지연 SQL 저장소에 모인 쿼리들을 데이터베이스로 전달한다.\n  - 플러시(동기화)를 마친 이후 실제 데이터베이스 트랜잭션을 커밋한다.\n\n**트랜잭션을 지원하는 쓰기 지연이 가능한 이유**<br/>\n로직을 2가지 경우로 생각해본다.\n\n```java\nbegin(); // 트랜잭션 시작\n\nsave(A);\nsvae(B);\nsave(C);\n\ncommit(); // 트랜잭션 커밋\n```\n1. 데이터를 저장하는 즉시 등록 쿼리를 데이터베이스에 보낸다. `save()` 메소드를 호출할 때마다 즉시 데이터베이스에 등록 쿼리를 보내고 마지막에 트랜잭션을 커밋한다.\n2. 데이터를 저장하면 등록 쿼리를 즉시 보내지 않고, 메모리에 모아둔다. 이후 트랜잭션 커밋 시에 모아둔 쿼리들을 데이터베이스에 보낸 후 커밋한다.\n\n트랜잭션 범위 안에서 실행되기에 두 로직의 결과는 같다. 어떻게든 커밋 직전에만 데이터베이스에 SQL을 전달하면 되기에 트랜잭션을 지원하는 쓰기 지연이 가능한 이유이다.\n\n### ➰ 엔티티 수정\n**SQL 수정 쿼리의 문제점**<br/>\nSQL을 사용하면 수정 쿼리를 직접 작성해야 한다. 프로젝트에 대한 요구사항이 늘어나게 되면, 수정 쿼리도 점점 추가된다. 아래는 회원의 이름과 나이를 변경하는 쿼리이다.\n\n```sql\nUPDATE MEMBER SET NAME=?, AGE=? WHERE id=?\n```\n- 회원의 이름과 나이를 변경하는 기능을 개발했는데 회원의 등급을 변경하는 기능이 추가되면 회원의 등급을 변경하는 다음 수정 쿼리를 추가로 작성한다.\n\n```sql\nUPDATE MEMBER SET GRADE=? WHERE id=?\n```\n- 이렇게 하거나, 둘을 합쳐 하나의 수정 쿼리만 사용해도 된다.\n- 하지만 합친 쿼리를 사용해서 정보 변경 시 이름과 나이를 변경하는데 등급 정보를 미입력하거나, 등급을 변경하는데 실수로 이름과 나이를 미입력할 수도 있다. 결국 이런 상황을 피하기 위해 수정 쿼리를 상황에 따라 계속해서 추가한다.\n\n> 이런 개발 방식의 문제점은 **수정 쿼리가 많아지는 것**은 물론이고 **비즈니스 로직을 분석하기 위해 SQL을 계속 확인**해야 한다. 결국 직접적이든 간접적이든 **비즈니스 로직이 SQL에 의존**하게 된다.\n\n**변경 감지**<br/>\nJPA는 엔티티를 어떻게 수정하는지 확인해본다.\n\n```java\nEntityManager em = emf.createEntityManager();\nEntityTransactiont transaction = em.getTransaction();\ntransaction.begin();\n\nMember memberA = em.find(Member.class, \"memberA\");\n\nmemberA.setUsername(\"hi\");\nmemberA.setAge(10);\n\n// em.update(member) 이런 코드가 없다!!!\n\ntransaction.commit();\n```\n- JPA로 엔티티를 수정할 때는 단순히 **엔티티를 조회해서 데이터만 변경**하면 된다.\n  - 데이터만 변경했는데 어떻게 데이터베이스에 반영이 되는 걸까?\n  - 이렇게 \"엔티티의 변경사항을 데이터베이스에 자동으로 반영\"하는 기능을 **변경 감지(dirty checking)**라 한다.\n\nJPA는 엔티티를 영속성 컨텍스트에 보관할 때, 최초 상태를 복사해서 저장해두는데 이를 **스냅샷**이라 한다. 그리고 플러시 시점에 스냅샷과 엔티티를 비교해 변경된 엔티티를 찾는다. 이를 순서대로 분석해보면,\n\n1. 트랜잭션을 커밋하면 엔티티 매니저 내부에서 먼저 플러시(`flush()`)가 호출된다.\n2. 엔티티와 스냅샷을 비교해 변경된 엔티티를 찾는다.\n3. 변경된 엔티티가 있으면 수정 쿼리를 생성해 쓰기 지연 SQL 저장소에 보낸다.\n4. 쓰기 지연 저장소의 SQL을 데이터베이스에 보낸다.\n5. 데이터베이스 트랜잭션을 커밋한다.\n\n> 변경 감지는 **영속성 컨텍스트가 관리하는 영속 상태의 엔티티에만 적용**된다. 비영속, 준영속 엔티티는 값을 변경한다한들 반영되지 않는다.\n\n이번에는 변경 감지로 인해 실행된 UPDATE SQL을 자세히 알아본다. 위 예제처럼 회원의 이름과 나이만 수정하면 변경된 부분만 사용해 동적으로 수정 쿼리가 생성될 것으로 예상할 수 있다.\n\n```sql\nUPDATE MEMBER SET NAME=?, AGE=? WHERE id=?\n```\n\n하지만 **\"JPA의 기본 전략은 엔티티의 모든 필드를 업데이트\"**한다.\n\n```sql\nUPDATE MEMBER SET NAME=?, AGE=?, GRADE=?, ... WHERE id=?\n```\n- 데이터베이스에 보내는 데이터 전송량이 증가하는 단점이 있지만, 다음과 같은 장점이 있어 모든 필드를 업데이트하는 방식을 따른다.\n  - 모든 필드를 사용하면 **수정 쿼리가 항상 같다.** (물론 바인딩되는 데이터는 다르다.) 따라서 애플리케이션 로딩 시점에 수정 쿼리를 미리 생성해두고 **재사용**할 수 있다.\n  - 데이터베이스에 동일한 쿼리를 보내면 데이터베이스는 **이전에 한 번 파싱된 쿼리를 재사용**할 수 있다.\n- 필드가 많거나 저장되는 내용이 너무 크면 수정된 데이터만 사용해 동적으로 UPDATE SQL을 생성하는 전략을 선택하면 된다. 단 이때는 Hibernate 확장 기능을 사용해야 한다.\n  - `@org.hibernate.annotations.DynamicUpdate` annotation을 사용하면 수정된 데이터만 사용해 동적으로 UPDATE SQL을 생성한다.\n  - 참고로 데이터를 저장할 때 데이터가 존재하는(`null`이 아닌) 필드만으로 INSERT SQL을 동적으로 생성하는 `@DynamicInsert` 도 있다.\n\n> 상황에 따라 다르지만 컬럼이 대략 30개 이상이 되면 기본 방법보다 `@DynamicUpdate` 를 사용한 동적 수정 쿼리가 빠르다고 한다. 그치만 한 테이블에 컬럼이 30개 이상 된다는 것은 테이블 설계상 책임이 적절히 분리되지 않았을 가능성이 높다.\n\n### ➰ 엔티티 삭제\n엔티티를 삭제하려면 먼저 삭제 대상 엔티티를 조회해야 한다.\n```java\nMember memeberA = em.find(Member.class, \"memberA\");\nem.remove(memberA);\n```\n- `em.remove()` 에 삭제 대상 엔티티를 넘겨주기만 하면 된다.\n  - 물론 엔티티를 즉시 삭제하는 것이 아닌 등록과 비슷하게 **삭제 쿼리를 쓰기 지연 SQL 저장소에 등록**한다.\n  - 이후 트랜잭션 커밋해 플러시 호출 시 데이터베이스에 삭제 쿼리를 전달한다.\n\n> 참고로, `em.remove(memberA)` 를 호출하는 순간 영속성 컨텍스트에서는 바로 제거된다. 이렇게 삭제된 엔티티는 재사용하지 말고 자연스럽게 가비지 컬렉션의 대상이 되도록 두는 것이 좋다.\n \n---\n\n## 💫 플러시\n**플러시(`flush()`)는 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영**한다. 구체적으로는 다음과 같은 흐름이다.\n1. 변경 감지가 동작해 영속성 컨텍스트에 있는 모든 엔티티를 스냅샷과 비교해서 수정된 엔티티를 찾는다. 수정된 엔티티는 수정 쿼리를 만들어 쓰기 지연 SQL 저장소에 등록한다.\n2. 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전달한다.(등록, 수정, 삭제 쿼리)\n\n영속성 컨텍스트를 플러시하는 방법은 3가지다.\n1. `em.flush()` 를 직접 호출한다.\n2. 트랜잭션 커밋 시 플러시가 자동 호출된다.\n3. JPQL 쿼리 실행 시 플러시가 자동 호출된다.\n\n**직접 호출**<br/>\n엔티티 매니저의 `flush()` 메소드를 직접 호출하여 강제로 플러시한다. 테스트나 다른 프레임워크와 JPA를 함께 사용할 때를 제외하고 거의 사용하지 않는다.\n\n**트랜잭션 커밋 시 플러시 자동 호출**<br/>\n데이터베이스에 변경 내용을 SQL로 전달하지 않고 트랜잭션만 커밋하면 어떤 데이터도 데이터베이스에 반영되지 않는다. 따라서 트랜잭션 커밋 전 플러시 호출은 필수적이다. \n- JPA는 이런 문제를 예방하고자 트랜잭션 커밋 시 자동으로 플러시를 호출한다.\n\n**JPQL 쿼리 실행 시 플러시 자동 호출**<br/>\nJPQL이나 Criteria 같은 객체지향 쿼리를 호출할 때도 플러시가 실행된다. 다음 예제로 이해해보도록 한다.\n\n```java\nem.persist(memberA);\nem.persist(memberB);\nem.persist(memberC);\n\n// JPQL 실행\nquery = em.createQuery(\"select m from Member m\", Member.class);\nList<Member> members = query.getResultList();\n```\n- 먼저 `em.persist()` 를 호출해 엔티티들을 영속 상태로 만들었다. 아직 데이터베이스에는 저장되지 않은 상태이다. \n- 이때 JPQL을 실행하면 JPQL이 SQL로 변환되어 데이터베이스에서 엔티티를 조회한다. \n  - 당연히 영속 상태가 된 엔티티들은 데이터베이스에 저장되지 않았기에 조회되지도 않는다. \n  - 따라서 쿼리를 실행하기 직전에 영속성 컨텍스트를 플러시하여 변경 내용을 반영하도록 한다.\n\n### ➰ 플러시 모드 옵션\n엔티티 매니저에 플러시 모드를 직접 지정하려면 `javax.persistence.FlushModeType` 을 사용하면 된다.\n- `AUTO` : 커밋이나 쿼리를 실행할 때 플러시(default)\n- `COMMIT` : 커밋할 때만 플러시\n\n```java\nem.setFlushMode(FlushModeType.COMMIT) // 플러시 모드 직접 설정\n```\n\n> **플러시라는 이름으로 인해 영속성 컨텍스트에 보관된 엔티티를 지운다고 생각하면 안된다.** 영속성 컨텍스트의 변경 내용을 데이터베이스에 동기화하는 작업인 것이지, 지우는 작업은 아니다.\n\n---\n\n## 💫 준영속\n이번에는 영속 → 준영속의 상태 변화를 알아보도록 한다.\n\n준영속 상태는 영속성 컨텍스트가 관리하는 영속 상태의 엔티티가 영속성 컨텍스트에서 **분리된(detached)** 것을 가리킨다. 따라서 **영속성 컨텍스트가 제공하는 기능을 사용할 수 없는 상태**이다. 준영속 상태로 만드는 방법은 3가지가 있다.\n1. `em.detach(entity)` : 특정 엔티티만 준영속 상태로 전환한다.\n2. `em.clear()` : 영속성 컨텍스트를 완전히 초기화한다.\n3. `em.close()` : 영속성 컨텍스트를 종료한다.\n\n### ➰ 엔티티를 준영속 상태로 전환: `detach()`\n`em.detach()` 메소드는 특정 엔티티를 준영속 상태로 만든다.\n\n```java\npublic void detach(Object entity);\n```\n\n```java\npublic void testDetached() {\n  ...\n  // 회원 엔티티 생성, 비영속 상태\n  Member member = new Member();\n  member.setId(\"memberA\");\n  member.setUsername(\"회원A\");\n\n  // 회원 엔티티 영속 상태\n  em.persist(member);\n\n  // 회원 엔티티를 영속성 컨텍스트에서 분리, 준영속 상태\n  em.detach(member);\n\n  transaction.commit();\n}\n```\n- 회원 엔티티를 생성하고 영속화한 다음 `em.detach(member)` 를 호출했다.\n  - 이는 영속성 컨텍스트에게 더는 해당 엔티티를 관리하지 말라는 의미이다.\n  - 호출하는 순간 1차 캐시부터 쓰기 지연 SQL 저장소까지 해당 엔티티를 관리하기 위한 모든 정보가 제거된다.\n    - 따라서 데이터베이스에 저장되지도 않는다.\n\n영속 상태가 **영속성 컨텍스트로부터 관리되는 상태**라면, 준영속 상태는 **영속성 컨텍스트로부터 분리된 상태**다.\n\n### ➰ 영속성 컨텍스트 초기화: `clear()`\n`em.clear()` 는 영속성 컨텍스트를 초기화하여 해당 영속성 컨텍스트의 모든 엔티티를 준영속 상태로 만든다.\n\n```java\n// 엔티티 조회, 영속 상태\nMember member = em.find(Member.class, \"memberA\");\n\n// 영속성 컨텍스트 초기화\nem.clear();\n\n// 준영속 상태\nmember.setUsername(\"changeName\");\n```\n- 영속성 컨텍스트 초기화는 **영속성 컨텍스트를 제거하고 새로 만든 것**과 같다. 따라서 해당 컨텍스트의 모든 엔티티들은 준영속 상태가 되어 변경 감지는 동작하지 않게 된다.\n  - 위 예제의 `member.setUsername(\"changeName\")` 는 데이터베이스에 반영되지 않는다.\n\n### ➰ 영속성 컨텍스트 종료: `close()`\n영속성 컨텍스트를 종료하면 해당 영속성 컨텍스트가 관리하던 영속 상태의 엔티티가 모두 준영속 상태가 된다.\n\n```java\npublic void closeEntityManager() {\n  EntityManagerFactory emf = Persistence.createEntityManagerFactory(\"jpabook\");\n\n  EntityManager em = emf.createEntityManager();\n  EntityTransaction transaction = em.getTransaction();\n  \n  transcation.begin();\n\n  Member memberA = em.find(Member.class, \"memberA\");\n  Member memberB = em.find(Member.class, \"memberB\");\n\n  transaction.commit();\n\n  em.close(); // 영속성 컨텍스트 닫기(종료)\n}\n```\n- 영속성 컨텍스트가 종료되어 더는 `memberA` , `memberB` 가 관리되지 않는다.\n\n> 영속 상태의 엔티티는 주로 영속성 컨텍스트가 종료되면서 준영속 상태가 된다. 개발자가 직접 준영속 상태로 만드는 일은 드물다.\n\n### ➰ 준영속 상태의 특징\n그럼 준영속 상태인 회원 엔티티는 어떻게 될까?\n- **거의 비영속 상태에 가깝다.**\n  - 영속성 컨텍스트가 관리하지 않아, 영속성 컨텍스트가 제공하는 어떠한 기능도 동작하지 않는다.\n- **식별자 값을 가지고 있다.**\n  - 비영속 상태는 식별자 값이 없을 수도 있지만, 준영속 상태는 이미 한 번 영속 상태였기에 식별자 값을 가지고 있다.\n- **지연 로딩을 할 수 없다.**\n  - 지연 로딩(Lazy Loading)은 실제 객체 대신 프록시 객체를 로딩해두고 해당 객체를 실제 사용할 때 영속성 컨텍스트를 통해 데이터를 불러오는 방법이다.\n  - 준영속 상태는 영속성 컨텍스트의 관리를 받지 않으므로 지연 로딩 시 문제가 발생한다.\n\n### ➰ 병합: `merge()`\n준영속 상태의 엔티티를 다시 영속 상태로 변경하는 메소드이다. **준영속 상태의 엔티티를 받아 그 정보를 바탕으로 새로운 영속 상태의 엔티티를 반환**한다.\n\n```java\npublic <T> T merge(T entity);\n\nMember mergeMember = em.merge(member);\n```\n\n**준영속 병합**<br/>\n준영속 상태의 엔티티를 영속 상태로 변경하는 코드이다.\n\n```java\npublic class ExamMergeMain {\n  static EntityManagerFactory emf = Persistence.createEntityManagerFactory(\"jpabook\");\n\n  public static void main(String args[]) {\n    Member member = createMember(\"memberA\", \"회원1\");\n\n    member.setUsername(\"회원명 변경\");\n\n    mergeMember(member);\n  }\n\n  static Member createMember(String id, String username) {\n    EntityManager em1 = emf.createEntityManager();\n    EntityTransaction tx1 = em1.getTransaction();\n\n    tx1.begin();\n    Member member = new Member();\n    member.setId(id);\n    member.setUsername(username);\n\n    em1.persist(member);\n    tx1.commit();\n\n    em1.close(); // 영속성 컨텍스트 1 종료, member 엔티티는 준영속 상태\n\n    return member;\n  }\n\n  static void mergeMember(Member member) {\n    EntityManager em2 = emf.createEntityManager();\n    EntityTransaction tx2 = em2.getTransaction();\n\n    tx2.begin();\n    Member mergeMember = em2.merge(member);\n    tx2.commit();\n\n    // 준영속 상태\n    System.out.println(\"member = \" + member.getUsername());\n\n    // 영속 상태\n    System.out.println(\"mergeMember = \" + mergeMember.getUsername());\n\n    System.out.println(\"em2 contains member = \" + em2.contains(member));\n    System.out.println(\"em2 contains mergeMember = \" + em2.contains(mergeMember));\n\n    em2.close(); // 영속성 컨텍스트 2 종료, mergeMember 엔티티는 준영속 상태\n  }\n}\n```\n- `createMember()` 메소드는 준영속 상태의 `member` 엔티티를 반환한다.\n- `main()` 메소드에서 `member.setUsername()` 를 호출해 회원 이름을 변경했지만 준영속 상태인 `member` 엔티티를 관리하는 영속성 컨텍스트가 없으므로, 수정 사항은 데이터베이스에 반영되지 않는다.\n- 준영속 상태의 엔티티를 수정하기 위해 `mergeMember()` 메소드에서 병합을 사용한다. \n  - 새로운 영속성 컨텍스트를 생성하여 `member` 엔티티를 영속성 컨텍스트2가 관리하는 영속 상태로 변경했다.\n  - 이제 영속 상태가 되었으므로, 트랜잭션 커밋 시 변경 감지 기능이 동작해 이전에 수정했던 회원 이름이 데이터베이스에 반영된다. (정확하게는 `mergeMember` 라는 새로운 영속 상태의 엔티티가 반환된다.)\n\n**`merge()` 의 동작방식**\n1. `merge()` 를 실행한다.\n2. 파라미터로 넘어온 준영속 엔티티의 식별자 값으로 1차 캐시에서 엔티티를 조회한다.\n   1. 없다면 데이터베이스에서 엔티티를 조회하고 1차 캐시에 저장한다.\n3. 조회한 영속 엔티티에 `member` 엔티티의 값을 채워 넣는다. (`member` 엔티티의 모든 값이 채워지고, `mergeMember` 의 이름이 \"회원명 변경\"으로 변경된다.)\n4. `mergeMember` 를 반환한다.\n\n코드의 출력부를 보면 `em.contains(entity)` 를 사용하고 있다. 이는 **영속성 컨텍스트가 파라미터로 전달된 엔티티를 관리하는지 확인**하는 메소드이다.\n- 준영속 상태인 `member` 엔티티와 영속 상태인 `mergeMember` 엔티티는 서로 다른 인스턴스이고, 준영속 상태인 `member` 는 이제 사용할 필요가 없어, 다음과 같이 준영속 엔티티를 참조하던 변수를 영속 엔티티를 참조하도록 변경하는 것이 안전하다.\n\n```java\n// Member mergeMember = em2.merge(member);\nmember = em2.merge(member);\n```\n\n**비영속 병합**<br/>\n병합은 비영속 엔티티도 영속 상태로 만들 수 있다.\n```java\nMember member = new Member();\nMember newMember = em.merge(member); // 비영속 병합\ntx.commit();\n```\n- 병합은 파라미터로 전달된 엔티티의 식별자 값으로 영속성 컨텍스트를 조회하고 찾는 엔티티가 없으면 데이터베이스에서 조회한다.\n  - 만약 데이터베이스에도 없다면 **새로운 엔티티를 생성해서 병합**한다.\n\n> 병합은 준영속, 비영속을 신경쓰지 않는다. 엔티티를 조회할 수 있으면 불러서 병합하고, 그렇지 않으면 생성해서 병합한다. 따라서 병합은 `save or update` 기능을 수행한다.\n\n## 📕 출처\n- **자바 ORM 표준 JPA 프로그래밍** - 김영한\n- [엔티티의 생명주기](https://ultrakain.gitbooks.io/jpa/content/chapter3/chapter3.3.html)"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 💫 프로젝트 개발 툴 설치와 프로젝트 불러오기 Intellij를 사용하여 간단한 JPA 애플리케이션을 만들 것이다. 그리고 예제 프로젝트는 https://github.com/holyeye/jpabook 에서 다운받을 수 있다. 이 과정은 생략하도록 한다! 그리고  에서…","fields":{"slug":"/[JPA]2/"},"frontmatter":{"date":"March 05, 2022","title":"📚 2. JPA 시작","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n## 💫 프로젝트 개발 툴 설치와 프로젝트 불러오기\nIntellij를 사용하여 간단한 JPA 애플리케이션을 만들 것이다. 그리고 예제 프로젝트는 https://github.com/holyeye/jpabook 에서 다운받을 수 있다. 이 과정은 생략하도록 한다! 그리고 `ch02-jpa-start1` 에서부터 프로젝트를 시작하도록 한다. \n\n또한 설치가 필요없고 용량도 가벼운 H2 데이터베이스를 설치하여 사용하도록 한다. 설치 과정은 생략하고, `bin/h2.sh` 명령어로 H2 데이터베이스를 서버 모드로 실행한다.\n\n> 📌 H2 데이터베이스는 JVM 메모리 안에서 실행되는 **임베디드 모드**와, 실제 데이터베이스처럼 별도의 서버를 띄워 동작하는 **서버 모드**가 있다.\n> - **임베디드 모드**\n>   - application이 종료된다면 저장, 수정된 Data가 손실(휘발)되어 기본적으로는 영속적이지 않은 방식\n>   - 메인 메모리에 띄워놓고 사용하기에 데이터 접근이 매우 빠름\n> - **서버 모드**\n>   - 별도의 프로세스로 DB를 동작시키는 방식\n>   - 모든 데이터의 처리 흐름이 TCP/IP를 통하여 전송되기 때문에 Embedded 모드보다 상대적으로 느림\n\n데이터베이스를 실행한 후 사용할 예제 테이블을 아래의 DDL로 생성한다.\n```sql\nCREATE TABLE MEMBER (\n    ID VARCHAR(255) NOT NULL,\n    NAME VARCHAR(255),\n    AGE INTEGER NOT NULL,\n    PRIMARY KEY(ID)\n)\n```\n\n---\n\n## 💫 라이브러리와 프로젝트 구조\n여기서는 라이브러리 관리 도구로서 메이븐을 사용한다. 그리고 책 전반에 걸쳐서 JPA 구현체로 Hibernate를 사용한다. 핵심 라이브러리로는 `hibernate-core` , `hibernate-entitymanager` , `hibernate-jpa-2.1-api` 를 사용한다.\n\n> `hibernate-entitymanager` 를 라이브러리로 지정하면, 나머지 2개의 라이브러리도 함께 내려받는다.\n\n### ➰ 메이븐과 사용 라이브러리 관리\n> **메이븐**은 라이브러리 관리 기능과 빌드 기능을 제공함으로써, 자바 애플리케이션의 라이브러리를 관리해주는 도구이다.\n> - **라이브러리 관리 기능**\n>   - 자바 애플리케이션 개발에 필요한 jar 라이브러리 파일들을 자동으로 내려받고 관리해주는 기능 \n> - **빌드 기능**\n>   - 애플리케이션을 직접 빌드하는 고된 작업이 아닌 표준화된 방법을 제공한다.\n\n메이븐 설정 파일(`pom.xml`)을 보면, `<dependencies>` 에 사용할 라이브러리를 지정해주고 있다. `groupId + artifactId + version` 만 명시하여 라이브러리(jar 파일)을 내려받아 추가한다.\n\n---\n\n## 💫 객체 매핑 시작\n아까 생성한 테이블을 토대로, 애플리케이션에서 사용할 회원 클래스를 만든다.\n\n```java\npublic class Member {\n\n    private String id;\n\n    private String username;\n\n    private Integer age;\n\n    public String getId() {\n        return id;\n    }\n\n    public void setId(String id) {\n        this.id = id;\n    }\n\n    public String getUsername() {\n        return username;\n    }\n\n    public void setUsername(String username) {\n        this.username = username;\n    }\n\n    public Integer getAge() {\n        return age;\n    }\n\n    public void setAge(Integer age) {\n        this.age = age;\n    }\n}\n```\n\nJPA를 사용하려면 먼저 회원 클래스와 회원 테이블을 매핑해야 한다. (객체와 테이블 간 매핑) 다음 표를 참고해 둘을 비교하면서 매핑을 수행한다.\n\n|매핑 정보|회원 객체|회원 테이블|\n|---|---|---|\n|클래스와 테이블|`Member`|`MEMBER`|\n|기본 키|`id`|`ID`|\n|필드와 컬럼|`username`|`NAME`|\n|필드와 컬럼|`age`|`AGE`|\n\n위 표를 참고해 JPA가 제공하는 매핑 annotation을 적용한다.\n\n```java\nimport javax.persistence.*;\n\n@Entity\n@Table(name=\"MEMBER\")\npublic class Member {\n\n    @Id\n    @Column(name = \"ID\")\n    private String id;\n\n    @Column(name = \"NAME\")\n    private String username;\n\n    private Integer age;\n\n    public String getId() {\n        return id;\n    }\n\n    public void setId(String id) {\n        this.id = id;\n    }\n\n    public String getUsername() {\n        return username;\n    }\n\n    public void setUsername(String username) {\n        this.username = username;\n    }\n\n    public Integer getAge() {\n        return age;\n    }\n\n    public void setAge(Integer age) {\n        this.age = age;\n    }\n}\n```\n\n**`@Entity`**\n- 해당 클래스를 테이블과 매핑한다고 명시한다. 이 클래스를 엔티티 클래스라고 한다.\n\n**`@Table`**\n- 엔티티 클래스에 매핑할 테이블 정보를 알려준다. 위 예시에서는 `name` 속성을 사용해 `Member` entity를 `MEMBER` 테이블에 매핑했다. \n- 해당 annotation이 없다면 클래스 이름을 테이블 이름으로 매핑한다. (정확히는 엔티티 이름을 사용한다.)\n\n**`@Id`**\n- 엔티티 클래스의 필드를 테이블의 기본 키에 매핑한다. 위 예시에서는 엔티티의 `id` 필드를 테이블의 `ID` 기본 키 컬럼에 매핑했다.\n- 이 필드를 식별자 필드라고 한다.\n\n**`@Column`** \n- 필드를 컬럼에 매핑한다. 위 예시에서는 `name` 속성을 사용해 `Member` entity의 `username` 필드를 `MEMBER` 테이블의 `NAME` 컬럼에 매핑했다.\n\n**매핑 정보가 없는 필드**\n- 매핑 annotation을 생략하면 필드명을 사용해 컬럼명으로 매핑한다. 여기서는 데이터베이스가 대소문자를 구분하기 않는다고 가정하여 `age` 필드가 `age` 컬럼으로 매핑된다.\n  - 대소문자를 구분한다면 `@Column(name=\"AGE\")` 로 명시해야 한다.\n\n---\n\n## 💫 `persistence.xml` 설정\nJPA는 `persistence.xml` 을 사용해서 필요한 설정 정보를 관리한다. 이 설정 파일은 `META-INF/persistence.xml` 클래스 패스 경로에 있어야 별도의 설정 없이 JPA가 인식한다.\n\n```xml\n<persistence xmlns=\"http://xmlns.jcp.org/xml/ns/persistence\" version=\"2.1\">\n```\n- 설정 파일은 `persistence` 로 시작한다. 여기에 XML namespace(ns)와 사용할 버전을 지정한다.\n\n```xml\n<persistence-unit name=\"jpabook\">\n```\n- JPA 설정은 영속성 유닛(`persistence-unit`)이라는 것부터 시작하는데, 일반적으로 연결할 데이터베이스당 하나의 영속성 유닛을 등록한다. \n- 그리고 영속성 유닛은 고유한 이름이 필요해 `jpabook` 을 사용했다.\n\n아래에는 JPA 표준 속성과 Hibernate 속성이 차례로 위치한다.\n- 이름이 `javax.persistence` 로 시작하는 JPA 표준 속성은 특정 구현체 종속되지 않는다. \n- 하지만 `hibernate` 로 시작하는 속성은 Hibernate 전용 속성으로 Hibernate에서만 사용할 수 있다.\n  - 가장 중요한 속성은 데이터베이스 방언을 설정하는 `hibernate.dialect` 이다.\n\n### ➰ 데이터베이스 방언\n> JPA는 특정 데이터베이스에 종속적이지 않은 기술이다.\n\n따라서 다른 데이터베이스로 손쉽게 교체할 수 있는데, 각 데이터베이스가 제공하는 문법과 함수가 조금씩 다른 문제가 있다.\n- 데이터 타입 : `VARCHAR` vs. `VARCHAR2`\n- 다른 함수명 : `SUBSTRING()` vs. `SUBSTR()`\n- 페이징 처리 : `LIMIT` vs. `ROWNUM`\n\n이처럼 SQL 표준을 지키지 않거나, 특정 데이터베이스만의 고유한 기능을 JPA에서는 **방언(dialect)**이라 한다.\n- 당연히 이런 경우가 많아지면, 추후 데이터베이스의 변경을 어렵게 한다.\n- 대부분의 JPA 구현체들은 이 문제를 해결하기 위해 다양한 데이터베이스 방언 클래스를 제공한다.\n\n**어떻게 적용이 되느냐?**\n- 개발자는 JPA가 제공하는 표준 문법에 맞춰 JPA를 사용한다.\n- 특정 데이터베이스에 의존적인 SQL은 데이터베이스 방언이 처리한다.\n\n따라서 애플리케이션 코드의 변경이 아닌 데이터베이스 방언의 변경으로 적용된다!\n\nHibernate는 대표적으로 `H2` , `오라클 10g` , `MySQL` 데이터베이스 방언을 제공한다. 여기서 H2 데이터베이스를 사용하기에 `dialect` 속성을 `H2Dialect` 로 설정했다.\n\n---\n\n## 💫 애플리케이션 개발\n`JpaMain` 은 애플리케이션을 시작하는 코드이다.\n\n```java\npublic class JpaMain {\n\n    public static void main(String[] args) {\n\n        //엔티티 매니저 팩토리 생성\n        EntityManagerFactory emf = Persistence.createEntityManagerFactory(\"jpabook\");\n        EntityManager em = emf.createEntityManager(); //엔티티 매니저 생성\n\n        EntityTransaction tx = em.getTransaction(); //트랜잭션 기능 획득\n\n        try {\n            tx.begin(); //트랜잭션 시작\n            logic(em);  //비즈니스 로직\n            tx.commit();//트랜잭션 커밋\n\n        } catch (Exception e) {\n            e.printStackTrace();\n            tx.rollback(); //트랜잭션 롤백\n        } finally {\n            em.close(); //엔티티 매니저 종료\n        }\n\n        emf.close(); //엔티티 매니저 팩토리 종료\n    }\n\n    public static void logic(EntityManager em) {\n\n        String id = \"id1\";\n        Member member = new Member();\n        member.setId(id);\n        member.setUsername(\"지한\");\n        member.setAge(2);\n\n        //등록\n        em.persist(member);\n\n        //수정\n        member.setAge(20);\n\n        //한 건 조회\n        Member findMember = em.find(Member.class, id);\n        System.out.println(\"findMember=\" + findMember.getUsername() + \", age=\" + findMember.getAge());\n\n        //목록 조회\n        List<Member> members = em.createQuery(\"select m from Member m\", Member.class).getResultList();\n        System.out.println(\"members.size=\" + members.size());\n\n        //삭제\n        em.remove(member);\n    }\n}\n```\n\n코드는 크게 3부분으로 나뉜다.\n- 엔티티 매니저 설정\n- 트랜잭션 관리\n- 비즈니스 로직\n\n### ➰ 엔티티 매니저 설정\n흐름은\n1. `Persistence` 가 `META-INF/persistence.xml` 에서 설정 정보를 조회한다.\n2. 조회한 설정 정보를 가지고 `EntityManageFactory` 를 생성한다.\n3. `EntityManagerFactory` 는 `EntityManager` 를 생성한다.\n\n**엔티티 매니저 팩토리 생성**\n- JPA를 시작하려면 `persistence.xml` 의 설정 정보를 사용해 엔티티 매니저 팩토리를 생성해야 한다. 이때 `Persistence` 클래스를 사용한다.\n\n```java\nEntityManagerFactory emf = Persistence.createEntityManagerFactory(\"jpabook\");\n```\n- 설정 파일에서 이름이 `jpabook` 인 영속성 유닛을 찾아 엔티티 매니저 팩토리를 생성한다. \n- 이때 설정 파일의 설정 정보를 읽어 JPA를 동작시키기 위한 기반 객체를 만들고 JPA에 따라서는 데이터베이스 커넥션 풀도 생성하므로 **엔티티 매니저 팩토리를 생성하는 하는 비용은 아주 크다.**\n\n> \"따라서 엔티티 매니저 팩토리는 애플리케이션 전체에서 **딱 1번만 생성**하고, **공유**해서 사용해야 한다.\"\n\n**엔티티 매니저 생성**\n```java\nEntityManager em = emf.createEntityManager();\n```\n- 엔티티 매니저 팩토리에서 엔티티 매니저를 생성한다. JPA이 대부분의 기능은 이 엔티티 매니저가 제공한다.\n- 대표적으로 엔티티를 데이터베이스에 **등록/수정/삭제/조회**하는 기능이 있다.\n- 엔티티 매니저는 내부에 데이터베이스(데이터베이스 커넥션)를 유지하면서 데이터베이스와 통신한다. 따라서 가상의 데이터베이스라고 생각할 수도 있다.\n\n> \"엔티티 매니저는 데이터베이스 커넥션과 밀접한 관계를 가지므로 **스레드 간 공유하거나 재사용해서는 안된다.**\"\n\n**종료**<br/>\n사용이 끝난 엔티티 매니저와, 애플리케이션이 종료될 때 엔티티 매니저 팩토리를 반드시 종료해야 한다.\n\n```java\nem.close();\n...\n\nemf.close();\n```\n\n### ➰ 트랜잭션 관리\nJPA를 사용하면 항상 트랜잭션 안에서 데이터를 변경해야 한다. 그렇지 않으면 데이터베이스의 일관성을 꺠트릴 수 있고 예외가 발생한다.\n- 트랜잭션을 시작하려면 엔티티 매니저(`em`)에서 트랜잭션 API를 받아와야 한다.\n- 비즈니스 로직이 정상 동작하면 트랜잭션을 커밋하고, 예외가 발생하면 롤백한다.\n\n```java\ntry {\n    tx.begin(); //트랜잭션 시작\n    logic(em);  //비즈니스 로직\n    tx.commit();//트랜잭션 커밋\n\n} catch (Exception e) {\n    e.printStackTrace();\n    tx.rollback(); //트랜잭션 롤백\n}\n```\n\n### ➰ 비즈니스 로직\n비즈니스 로직은 회원 엔티티를 하나 생성한 후 엔티티 매니저를 통해 데이터베이스에 등록, 수정, 삭제, 조회한다.\n\n> 모든 기능이 엔티티 매니저를 통해 수행되어 객체를 저장하는 가상의 데이터베이스처럼 보인다.\n\n```java\npublic static void logic(EntityManager em) {\n\n    String id = \"id1\";\n    Member member = new Member();\n    member.setId(id);\n    member.setUsername(\"지한\");\n    member.setAge(2);\n\n    //등록\n    em.persist(member);\n\n    //수정\n    member.setAge(20);\n\n    //한 건 조회\n    Member findMember = em.find(Member.class, id);\n    System.out.println(\"findMember=\" + findMember.getUsername() + \", age=\" + findMember.getAge());\n\n    //목록 조회\n    List<Member> members = em.createQuery(\"select m from Member m\", Member.class).getResultList();\n    System.out.println(\"members.size=\" + members.size());\n\n    //삭제\n    em.remove(member);\n}\n```\n\n**등록**\n- 엔티티의 저장은 `persist()` 메소드에 저장할 엔티티를 넘겨주기만 하면 된다.\n- 이때 JPA는 회원 엔티티의 매핑 정보(annotation)를 분석해 INSERT SQL을 만들어 데이터베이스에 전달한다.\n\n```sql\nINSERT INTO MEMBER (ID, NAME, AGE) VALUES ('id1' , '지한', 2)\n```\n\n**수정**\n- 수정은 조금 이상해보인다. 엔티티 수정 후 수정된 내용을 반영해주는 `em.update()` 같은 메소드가 필요할 것 같은데, 그저 값만 변경하고 말았다.\n- JPA는 어떤 엔티티가 변경되었는지 추적하는 기능이 있다. 따라서 `member.setAge(20)` 처럼 값만 변경하면 UPDATE SQL을 생성해 데이터베이스에 전달한다.\n\n```sql\nUPDATE MEMBER SET AGE=20, NAME='지한' WHERE ID='id1'\n```\n\n**삭제**\n- 엔티티를 삭제하려면 `remove()` 메소드를 사용하면 되고, 이 역시 JPA에서 DELETE SQL을 생성해 데이터베이스에 전달한다.\n\n```sql\nDELETE FROM MEMBER WHERE ID='id1'\n```\n\n**한 건 조회**\n- 한 건 조회를 위해 사용하는 `find()` 메소드는 조회할 엔티티 타입과 `@Id` 로 데이터베이스 테이블의 기본 키와 매핑한 식별자 값으로 엔티티 하나를 조회한다.\n- 역시나 SELECT SQL을 생성하고, 조회한 결과 값으로 엔티티를 생성해 반환한다.\n\n```sql\nSELECT * FROM MEMBER WHERE ID='id1'\n```\n\n### ➰ JPQL\nJPA를 사용하면 개발자는 엔티티 객체 중심으로 개발하고, 데이터베이스에 대한 처리는 JPA가 수행하게 된다. \n\n문제는 **검색 쿼리**다. JPA는 엔티티 객체를 중심으로 개발하므로 검색 시에도 테이블이 아닌 엔티티 객체를 대상으로 검색해야 한다.\n\n그런데 이러한 검색 방식은 데이터베이스의 모든 데이터를 애플리케이션으로 불러와 엔티티 객체로 변경한 다음 검색해야 해서 사실상 불가능하다. 결국 하나 이상의 회원 목록을 조회하는 것과 같은 경우는 검색 조건이 포함된 SQL을 사용해야 한다.\n\n> \"JPA는 **JPQL(Java Persistence Query Language)**이라는 SQL을 추상화한 쿼리 언어로 이런 문제를 해결한다.\"\n- 문법은 SQL과 거의 유사하지만, 가장 큰 차이점은 다음과 같다.\n  - JPQL은 **엔티티 객체를 대상**으로 쿼리한다. 즉 클래스와 필드를 대상으로 쿼리한다.\n  - SQL은 **데이터베이스 테이블을 대상**으로 쿼리한다.\n\n```java\nselect m from Member m\n```\n- 여기서 `from Member` 는 회원 엔티티 객체를 말하는 것이지 데이터베이스의 `MEMBER` 테이블을 말하는 것이 아니다.\n  - **\"JPQL는 데이터베이스 테이블을 전혀 알지 못한다.\"**\n- `em.createQuery(JPQL, 반환 타입)` 메소드를 실행해 퀴리 객체를 생성하고,\n- 쿼리 객체의 `getResultList()` 메소를 호출하여 JPQL을 사용할 수 있다.\n- JPA는 JPQL을 분석해 적절한 SQL을 생성해 데이터베이스에 전달한다.\n\n## 📕 출처\n- **자바 ORM 표준 JPA 프로그래밍** - 김영한\n- [H2 DB 모드](https://lob-dev.tistory.com/entry/H2%EC%9D%98-LocalIn-Memory-%EC%99%80-ServerTCP-%EB%AA%A8%EB%93%9C)"},{"excerpt":"문제 하나의 양팔 저울을 이용하여 물건의 무게를 측정하려고 한다. 이 저울의 양 팔의 끝에는 물건이나 추를 올려놓는 접시가 달려 있고, 양팔의 길이는 같다. 또한, 저울의 한쪽에는 저울추들만 놓을 수 있고, 다른 쪽에는 무게를 측정하려는 물건만 올려놓을 수 있다. 무게가 양의 정수인 N개의 저울추가 주어질 때, 이 추들을 사용하여 측정할 수 없는 양의 정…","fields":{"slug":"/[BOJ]2437/"},"frontmatter":{"date":"March 04, 2022","title":"👩‍💻 2437. 저울","tags":["그리디","정렬"]},"rawMarkdownBody":"\n## 문제\n\n하나의 양팔 저울을 이용하여 물건의 무게를 측정하려고 한다. 이 저울의 양 팔의 끝에는 물건이나 추를 올려놓는 접시가 달려 있고, 양팔의 길이는 같다. 또한, 저울의 한쪽에는 저울추들만 놓을 수 있고, 다른 쪽에는 무게를 측정하려는 물건만 올려놓을 수 있다.\n\n<img src=\"https://upload.acmicpc.net/7d2a2428-a1b0-47f5-9f53-fecd714d1b1b/-/preview/\" width=\"30%\">\n\n무게가 양의 정수인 N개의 저울추가 주어질 때, 이 추들을 사용하여 측정할 수 없는 양의 정수 무게 중 최솟값을 구하는 프로그램을 작성하시오.\n\n예를 들어, 무게가 각각 3, 1, 6, 2, 7, 30, 1인 7개의 저울추가 주어졌을 때, 이 추들로 측정할 수 없는 양의 정수 무게 중 최솟값은 21이다. \n\n### 입력\n- 첫 째 줄에는 저울추의 개수를 나타내는 양의 정수 N이 주어진다. N은 1 이상 1,000 이하이다. 둘째 줄에는 저울추의 무게를 나타내는 N개의 양의 정수가 빈칸을 사이에 두고 주어진다. 각 추의 무게는 1이상 1,000,000 이하이다.\n\n### 출력\n- 첫째 줄에 주어진 추들로 측정할 수 없는 양의 정수 무게 중 최솟값을 출력한다.\n\n### 📍 **Logic**\n\n```java\nArrays.sort(nums);\n```\n\n- 입력된 저울추들을 정렬한다.\n\n```java\nfor (int i = 0; i < N; i++) {\n    if (sum + 1 < nums[i]) break;\n    sum += nums[i];\n}\n```\n\n- 주어진 추들로 측정 가능한 무게를 찾는 반복문\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.Arrays;\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int N = Integer.parseInt(br.readLine());\n            int[] nums = Arrays.stream( br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n            int sum = 0;\n\n            Arrays.sort(nums);\n\n            for (int i = 0; i < N; i++) {\n                if (sum + 1 < nums[i]) break;\n                sum += nums[i];\n            }\n\n            System.out.println(sum + 1);\n\n            br.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- c++로 풀었을 당시 왜 이렇게 풀이가 간단할까를 고심했던 것 같아 Java로 다시 풀어보았다.\n- 측정할 무게는 주어진 저울추로 측정이 가능한 경우, 주어진 저울추의 무게를 더하고, 거기에 +1 한 무게와 다음 저울추의 무게를 비교한다.\n- 다시 봐도 뭔가 명쾌하게 이해는 가지 않아 다음에 다시 풀라고하면 또 헤맬 거 같다..ㅋㅋ\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/2437"},{"excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 💫 SQL을 직접 다룰 때 발생하는 문제점 \"관계형 데이터베이스는 가장 대중적이고 신뢰할 만한 안전한 데이터 저장소이다.\" 자바로 작성한 애플리케이션은 JDBC API를 사용해서 SQL을 DB에 전달해야 한다. SQL을 이용해 DB로부터 결과를 반환받아 애플리케이션에서…","fields":{"slug":"/[JPA]1/"},"frontmatter":{"date":"March 04, 2022","title":"📚 1. JPA 소개","tags":["Java","JPA","SpringBoot"]},"rawMarkdownBody":"\n<em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n## 💫 SQL을 직접 다룰 때 발생하는 문제점\n\"관계형 데이터베이스는 가장 대중적이고 신뢰할 만한 안전한 데이터 저장소이다.\"\n\n자바로 작성한 애플리케이션은 JDBC API를 사용해서 SQL을 DB에 전달해야 한다. SQL을 이용해 DB로부터 결과를 반환받아 애플리케이션에서 알맞게 사용한다.\n\n### ➰ 반복, 반복 그리고 반복\nSQL을 직접 다룰 때의 문제점을 알아봐야 한다. 이를 위해 자바와 관계형 DB를 사용한 회원 관리 기능을 개발해본다.\n\n먼저, 사용할 회원(`Member`) 객체이다.\n\n```java\npublic class Member {\n    private String memberId;\n    private String name;\n    ...\n\n}\n```\n\n회원 객체를 DB에 관리하기 위한 회원용 DAO(Data Access Object)를 만든다.\n\n```java\npublic class MemberDAO {\n    public Member find(String memberId) {\n        ...\n    }\n}\n```\n\n이제 위 메소드를 이용해 회원 조회 기능을 개발하는데, 일반적인 순서는 다음과 같다.\n1. 회원 조회용 SQL을 작성한다.\n   - `SELECT MEMBER_ID, NAME FROM MEMBER M WHERE MEMBER_ID = ?`\n\n2. JDBC API를 사용해서 SQL을 실행한다.\n   - `ResultSet rs = stmt.executeQuery(sql);`\n\n3. DB로부터 반환받은 조회 결과를 `Member` 객체로 매핑한다.\n\n```java\nString memberId = rs.getString(\"MEMBER_ID\");\nString name = rs.getString(\"NAME\");\n\nMember member = new Member();\nmember.setMemberId(memberId);\nmember.setName(name);\n```\n\n회원 조회는 완성했고, 회원 등록 기능은 다음과 같이 구현할 수 있다.\n\n```java\npublic class MemberDAO {\n    public Member find(String memberId) {\n        ...\n    }\n\n    public void save(Member member) {\n        ...\n    }\n}\n```\n\n1. 회원 등록용 SQL을 작성한다.\n   - `String sql = \"INSERT INTO MEMBER(MEMBER_ID, NAME) VALUES(?, ?)\";`\n\n2. 회원 객체의 값을 꺼내 등록 SQL에 전달한다. \n\n```java\npstmt.setString(1, member.getMemberId());\npstmt.setString(2, member.getName());\n```\n\n3. JDBC API를 사용해서 SQL을 실행한다.\n   - `pstmt.executeUpdate(sql);`\n\n다음으로 필요한 기능은 회원 정보를 수정하고 삭제하는 기능일 것이다. 이또한 **SQL을 작성하고 JDBC API를 사용해 이를 실행하는 방식**으로 동일할 것이다.\n\n> 회원 객체를 DB가 아닌 **자바 컬렉션에 보관**한다면 어떻게 될까?\n> - 컬렉션은 `list.add(member);` 한 줄로 객체를 저장할 수 있다.\n\nDB는 객체 구조와는 다른 **데이터 중심의 구조**를 가져 객체를 DB에 직접 저장하거나 조회할 수 없다.\n- 따라서, 개발자가 객체지향 애플리케이션과 DB 중간에서 SQL과 JDBC API를 사용해 **직접 변환**해줘야 한다.\n- 여기서 **문제**가 발생한다.\n  - 이러한 CRUD를 위한 코드 작성은 매우 반복적이고, 귀찮은 작업이다.\n\n### ➰ SQL에 의존적인 개발\n\"회원의 연락처를 함께 저장해달라\"는 새로운 요구사항이 추가된다면 위에서 구현한 회원 객체, INSERT SQL, 회원 조회 코드, 회원 정보 수정 코드가 모두 수정되어야 한다.\n\n#### 등록 코드 변경\n회원의 연락처를 추가하기 위해 회원 객체에 `tel` field를 추가한다.\n\n```java\npublic class Member {\n    private String memberId;\n    private String name;\n    private String tel;\n    ...\n\n}\n```\n\n그리고 DB에 전달할 회원 등록 SQL 또한 연락처도 함께 등록할 수 있도록 수정하고, JDBC API도 이에 맞게 수정한다.\n\n```java\nString sql = \"INSERT INTO MEMBER(MEMBER_ID, NAME, TEL) VALUES(?, ?, ?)\";\n\n...\n\npstmt.setString(3, member.getTel());\n```\n\n#### 조회 코드 변경\n회원 조회 시 연락처 필드 또한 조회 결과로 얻을 수 있도록 SQL을 수정하고, `Member` 객체에 추가 매핑한다.\n\n```java\nString sql = \"SELECT MEMBER_ID, NAME, TEL FROM MEMBER WHERE MEMBER_ID = ?\";\n\n...\n\nString tel = rs.getString(\"TEL\");\nmember.setTel(tel);\n```\n\n#### 수정 코드 변경\n회원 수정 시 연락처 정보도 함께 수정될 수 있도록 UPDATE SQL과 `MemberDAO.update()` 일부를 수정한다.\n\n> 회원 객체를 자바 컬렉션에 보관했다면, 필드가 추가되어도 많은 코드의 수정을 요구하진 않을 것이다.\n> ```java\n> list.add(member); // 등록\n> Member member = list.get(xxx); // 조회\n> member.setTel(\"xxx\"); // 수정\n> ```\n\n#### 연관된 객체\n\"회원은 어떤 한 팀에 필수로 소속되어야 한다\"는 요구사항이 추가된다면 `Member` 객체에 `Team team` 필드가 추가될 것이다. \n- 이때, 회원 정보와 함께 연관된 팀 이름도 출력할 수 있도록 기능을 추가한다.\n\n```java\nclass Team {\n    ...\n    private String teamName;\n    ...\n}\n```\n\n```java\n소속 팀: member.getTeam().getTeamName();\n```\n\n회원과 연관된 팀의 정보를 출력하기 위해서는 다음 SQL로 회원과 연관된 팀을 함께 조회해야 한다.\n```java\nString sql = \"SELECT M.MEMBER_ID, M.NAME, M.TEL, T.TEAM_ID, T.TEAM_NAME FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID\";\n```\n\n> **SQL의 문제점**\n> - `Member` 객체가 연관된 `Team` 객체를 사용할 수 있을지 없을지는 전적으로 사용하는 SQL에 달려 있다. 하지만 이런 방식의 가장 큰 문제점은 데이터 접근 계층을 사용해서 SQL을 숨겨도, 어쩔 수 없이 DAO를 열어 어떤 SQL이 실행되는지 확인해야 한다는 점이다.\n\n물리적으로 SQL과 JDBC API를 데이터 접근 계층에 숨기는데는 성공했을지 몰라도, 지금처럼 논리적으로는 **ENTITY와 아주 강한 의존관계**를 지니고 있어 객체에 대한 새로운 요구사항이 발생할 때마다 매우 큰 보수 비용이 발생하게 된다.\n\n> **애플리케이션에서 SQL을 직접 다룰 때 발생하는 문제점**\n> - 진정한 의미의 계층 분할이 어렵다.\n> - ENTITY를 신뢰할 수 없다.\n> - SQL에 의존적인 개발을 피할 수 없다.\n\n### ➰ JPA와 문제 해결\nJPA를 사용하면 객체를 DB에 저장하고 관리할 때, SQL을 작성하는 것이 아닌 JPA가 제공하는 API를 사용하면 된다. 다음은 JPA가 제공하는 CRUD API들이다.\n\n#### 저장 기능\n```java\njpa.persist(member);\n```\n\n- `persist()` 는 객체를 DB에 저장한다.\n- JPA가 객체와 매핑정보를 보고 적절한 INSERT SQL을 생성해 DB로 전달한다.\n\n#### 조회 기능\n```java\nString memberId = \"ID\";\nMember member = jpa.find(Member.class, memberId);\n```\n\n- `find()` 는 객체 하나를 DB에서 조회한다.\n- 이또한 객체와 매핑정보를 보고 적절한 SELECT SQL을 생성해 DB로 전달하고, 결과를 `Member` 객체를 생성해 반환한다.\n\n#### 수정 기능\n```java\nMember member = jpa.find(Member.class, memberId);\nmember.setName(\"변경된 이름\");\n```\n\n- JPA는 별도의 수정 메소드를 제공하지 않는다.\n- 대신 객체를 조회해 값을 변경하면 트랜잭션을 커밋할 때 DB에 적절한 UPDATE SQL이 전달된다.\n\n#### 연관된 객체 조회\n```java\nMember member = jpa.find(Member.class, memberId);\nTeam team = member.getTeam();\n```\n\n- JPA는 연관된 객체를 사용하는 시점에 적절한 SELECT SQL을 실행한다.\n  - 따라서 연관된 객체를 마음껏 조회할 수 있다.\n\n---\n\n## 💫 패러다임의 불일치\n> 객체지향 프로그래밍은 추상화, 캡슐화, 정보은닉, 상속, 다형성 등 시스템의 복잡성을 제어할 수 있는 다양한 장치들을 제공한다.\n\n비즈니스 요구사항을 정의한 도메인 모델도 객체로 모델링하면 객체지향 언어의 장점들을 활용할 수 있다.\n- 문제는 이 도메인 모델을 저장할 때 발생하는데, 특정 유저가 회원가입하면 회원이라는 객체를 생성한 후 **메모리가 아닌 어딘가에 영구 저장**해야 한다.\n\n객체는 **속성(필드)**과 **기능(메소드)**을 가진다. \n- 기능은 클래스에 정의되어 있어, 저장시에는 객체의 상태인 속성만을 저장하면 된다.\n- 객체가 단순하면 어렵지 않지만, 부모 객체를 상속받았거나, 다른 객체를 참조하고 있다면 저장이 쉽지 않다.\n  - 예를 들어 회원 객체가 팀 객체를 참조하고 있는 경우, 두 객체를 함께 저장해야 한다.\n\n자바는 이런 문제를 고려해 **객체를 파일로 저장하는 직렬화 기능**과 **저장된 파일을 객체로 복구하는 역 직렬화 기능**을 지원한다.\n- 하지만 직렬화된 객체를 검색하기 어려운 문제가 있어 현실성이 없다.\n- 현실적인 대안은 관계형 DB에 객체를 저장하는 것인데, 관계형 DB는 **데이터 중심으로 구조화**되어 있고, **집합적인 사고**를 요구한다. 또한 추상화, 상속, 다형성 같은 개념이 없다.\n\n\"객체와 관계형 DB는 지향하는 목적이 서로 달라 기능과 표현 방법도 다르다. 이를 **객체와 관계형 DB의 패러다임 불일치 문제**라고 한다. 따라서 객체 구조를 테이블 구조에 저장하는 데는 당연히 한계가 존재한다.\"\n- 이러한 패러다임 불일치 문제를 해결하기 위해 중간에 있는 개발자는 너무 많은 시간과 코드를 소비한다.\n- 아래는 이로 인해 발생하는 문제들을 구체적으로 다룬다.\n\n### ➰ 상속\n\"객체는 상속이라는 기능을 가지고 있지만, 테이블은 가지고 있지 않다.\" (일부 DB가 지원하는 상속 기능은 객체의 상속과는 다르다.)\n- DB 모델링에서 다루는 슈퍼타입 서브타입 관계를 사용하여 객체 상속과 유사한 형태로 테이블을 설계할 수는 있다.\n  - 테이블의 특정 컬럼을 사용해서 어떤 자식 테이블과 관계가 있는지 정의하는 방식\n\n객체 모델 코드는 다음과 같다.\n```java\nabstract class Item {\n    Long id;\n    String name;\n    int price;\n}\n\nclass Album extends Item {\n    String artist;\n}\n\nclass Movie extends Item {\n    String director;\n    String actor;\n}\n\nclass Book extends Item {\n    String author;\n    String isbn;\n}\n```\n\n- `Album` 객체를 저장하기 위해서는 객체를 분해해서 두 개의 SQL을 작성해야 한다. (`ITEM` , `ALBUM`)\n- JDBC API를 사용해 부모 객체에서 부모 데이터만 꺼내서 `ITEM` 용 INSERT SQL을 작성하고, 자식 객체에서 자식 데이터만 꺼내서 `ALBUM` 용 INSERT SQL을 작성하는 것은 매우 비효율적이다.\n- 조회하는 것 또한 두 테이블을 조인하고, 결과를 객체로 매핑하는 작업이 필요하다.\n\n> 💨 **모두 패러다임의 불일치를 해결하기 위해 소모되는 비용이다.**\n\n> 만약 **자바 컬렉션**을 사용해 해당 객체들을 보관한다면 부모 자식 관계나 타입에 상관없이 아래와 같은 코드로 가능하다.\n> ```java\n> list.add(album);\n> list.add(movie);\n>\n> Album album = list.get(albumId);\n> ```\n\n#### JPA와 상속\nJPA는 상속과 관련된 패러다임의 불일치 문제를 마치 **자바 컬렉션에 객체를 저장하듯이 JPA에게 객체를 저장하게 함**으로써 해결해준다. \n\n```java\n// Item을 상속한 Album객체를 저장한다.\njpa.persist(album);\n```\n- 이때, JPA는 두 SQL(`ITEM` INSERT, `ALBUM` INSERT)을 실행해 객체를 두 테이블에 나눠 저장한다.\n\n```java\n// Album 객체를 조회한다.\nString albumId = \"id100\";\nAlbum album = jpa.find(Album.class, albumId);\n```\n- JPA는 두 테이블을 조인해서 필요한 결과를 가져와 반환한다.\n\n### ➰ 연관관계\n**객체는 참조**를 사용해 다른 객체와 연관관계를 가지고 이를 통해 연관된 객체를 조회하는 반면, **테이블은 외래 키(Foreign Key)**를 사용해 다른 테이블과 연관관계를 가지고 조인을 사용해 연관된 테이블을 조회한다.\n- 이 둘 간의 패러다임 불일치는 매우 극복이 어렵다.\n\n`Member` 객체는 `Member.team` 필드에 `Team` 객체의 참조를 보관해 연관관계를 가진다. 따라서 `member.getTeam()` 으로 연관된 `Team` 을 조회할 수 있다.\n\n```java\nclass Member {\n    Team team;\n    ...\n\n    Team getTeam() {\n        return team;\n    }\n}\n\nclass Team {\n    ...\n}\n```\n\n`MEMBER` 테이블은 `MEMBER.TEAM_ID` 외래 키 컬럼을 사용해 `TEAM` 테이블과 연관관계를 가진다. 이 키를 사용해 테이블을 조인하여 연관된 `TEAM` 을 조회할 수 있다.\n\n```sql\nSELECT M.*, T.* FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID\n```\n\n여기서, **객체는 참조가 있는 방향으로만 조회가 가능**하다. 즉 `team.getMember()` 는 불가능하다. 하지만 **테이블은 외래 키 하나로 양방향으로 조회가 가능**하다.\n\n#### 객체를 테이블에 맞추어 모델링\n객체와 테이블의 차이를 알아보기 위해 객체를 단순히 테이블에 맞춰 모델링한다.\n\n```java\nclass Member {\n    String id; // MEMBER_ID\n    Long teamId; // TEAM_ID\n    String userName; // USERNAME\n}\n\nclass Team {\n    Long id; // TEAM_ID\n    String name; // NAME\n}\n```\n\n- 위와 같이 객체를 테이블에 맞춰 모델링함으로써 객체를 테이블에 저장하거나 조회하는 것은 편리해졌다.\n- 하지만 외래 키 값을 그대로 보관하는 `teamId` 필드는 문제가 있다.\n  - 관계형 DB의 경우, **\"조인\"** 기능이 있어 외래 키 값을 그대로 보관해도 상관없지만, **객체는 연관된 객체의 참조를 보관**해야 참조를 통해 연관된 객체를 조회할 수 있다.\n\n> **외래 키까지 테이블에 맞춘 모델링 방식을 사용**하게 되면\n> - 결국 참조를 통해 연관된 객체를 조회할 수가 없어지고, \n> - 객체지향의 특징을 잃어버리게 된다.\n\n#### 객체지향 모델링\n위에서 테이블에 맞춘 모델링 방식의 문제점(객체지향의 특징을 소실)을 이해했다. 이제 참조를 통한 연관관계를 가지도록 모델링한다.\n\n```java\nclass Member {\n    String id; // MEMBER_ID\n    Team team; // 참조로 연관관계를 가짐\n    String userName;\n\n    Team getTeam() {\n        return team;\n    }\n}\n\nclass Team {\n    Long id; // TEAM_ID - PK\n    String name; // NAME\n}\n```\n\n- 연관된 `Team` 의 참조를 보관함으로써, `member.getTeam()` 으로 연관된 객체를 조회할 수 있다.\n- 하지만 이런 객체지향 모델링은 객체를 테이블에 저장하거나 조회하는 데에 어려움이 있다. \n  - **객체와 테이블의 연관관계를 맺는 방식의 차이**(필드와 외래 키)때문인데, 이는 결국 개발자가 중간다리역할을 수행해야 해결이 가능했다.\n\n**저장**\n- 객체를 DB에 저장하기 위해 `team` 필드를 `TEAM_ID` 외래 키 값으로 변환한다.\n\n```java\nmember.getId(); // MEMBER_ID - PK에 저장\nmember.getTeam().getId(); // TEAM_ID - FK에 저장, INSERT SQL에 사용\nmember.getUserName(); // USERNAME 컬럼에 저장\n```\n\n**조회**\n- `TEAM_ID` 외래 키 값을 `Member` 객체의 `team` 참조로 변환한다.\n- 먼저 `MEMBER` 와 `TEAM` 을 조회하고, 이 결과로 객체를 생성해 연관관계를 설정하고 반환한다.\n\n```java\npublic Member find(String memberId) {\n    // SQL 실행\n    ...\n    Member member = new Member();\n    ...\n\n    // DB에서 조회한 회원 관련 정보를 모두 입력\n    Team team = new Team();\n    ...\n    // DB에서 조회한 팀 관련 정보를 모두 입력\n\n    // 회원과 팀 관계 설정\n    member.setTeam(team);\n    return member;\n}\n```\n\n> 매번 언급하듯, 자바 컬렉션에 저장한다면 이러한 패러다임 불일치 해결을 위한 비용은 소모되지 않는다.\n\n#### JPA와 연관관계\n\"JPA는 연관관계와 관련된 패러다임의 불일치 문제를 해결해준다.\"\n\n```java\nmember.setTeam(team); // 회원과 팀 관계 설정\njpa.persist(member); // 회원과 연관관계 함께 저장\n```\n\n- 개발자는 그저 관계를 설정하고 객체를 저장하기만 하면 된다.\n- JPA는 위에서의 중간다리역할을 수행해 적절한 SQL을 DB에 전달하고, 적절하게 반환해준다.\n\n### ➰ 객체 그래프 탐색\n객체에서 회원이 소속된 팀 조회 시 참조를 사용하는 것을 **객체 그래프 탐색**이라고 한다. 객체 연관관계가 연속적으로 이어져있는 경우 아래 코드와 같이 마음껏 객체 그래프를 탐색할 수 있어야 한다.\n\n```java\nmember.getOrder().getOrderItem();\n```\n\n하지만 DB를 사용하는 경우, `SELECT M.*, T.* FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID` 를 실행해서 회원과 팀에 대한 데이터는 조회가 가능하지만, 다른 객체 그래프는 데이터가 없어 탐색할 수 없게 된다. (`member.getOrder();` 의 결과는 `null`)\n\n**\"SQL을 직접 다루면 처음 실행하는 SQL에 따라 객체 그래프의 탐색 영역이 제한된다.\"** \n- 이는 비즈니스 로직에 따라 사용하는 객체 그래프가 다른데 언제 끊어질지 모를 객체 그래프를 함부로 탐색할 수는 없기에 객체지향 개발자에겐 매우 큰 제약이다.\n\n```java\nclass MemberService {\n    ...\n    public void process() {\n        Member member = memberDAO.find(memberId);\n        member.getItem(); // member -> team 객체 그래프 탐색이 가능한가?\n        member.getOrder().getDelivery(); // ???\n    }\n}\n```\n\n- 위 예제는 `memberDAO` 를 통해 `member` 객체를 조회했지만, 이 객체와 연관된 객체 방향으로 객체 그래프를 탐색할 수 있을지는 예측할 수 없다.\n  - 탐색 가능 여부의 확인을 위해서는 `DAO` 의 SQL을 직접 확인하는 수밖에 없다.\n  - 이는 이전에도 다룬 \"ENTITY가 SQL에 논리적으로 종속\"되기에 발생하는 문제이다.\n  - 그렇다고 연관된 모든 객체 그래프를 DB에서 조회해서 메모리에 올려두는 것은 현실성이 없기에 `getMemberWithTeam()` , `getMemberWithOrderWithDelivery()` 와 같이 경우에 따른 메소드를 여러 개 만들어 둬야 한다.\n\n#### JPA와 객체 그래프 탐색\nJPA를 사용하면 객체 그래프를 마음껏 탐색할 수 있다.\n\n```java\nmember.getOrder().getOrderItem();\n```\n\n이전에도 언급했듯, **JPA는 연관된 객체를 사용하는 시점에 적절한 SQL을 실행**한다.\n- 즉, 연관된 객체를 신뢰하고 마음껏 조회할 수 있다.\n- 이는 실제 객체를 사용하는 시점까지 DB 조회를 미룬다고 하여 **\"지연 로딩\"**이라고 한다.\n\n**지연 로딩**\n- **JPA는 지연 로딩을 투명(transparent)하게 처리**한다. 즉, JPA와 관련된 어떤 추가적인 코드도 필요하지 않다.\n\n```java\nMember member = jpa.find(Member.class, memberId);\n\nOrder order = member.getOrder();\norder.getOrderDate(); // Order를 사용하는 시점에 SELECT ORDER SQL\n```\n\n- 실제 `Order` 객체를 사용하는 시점에 JPA는 DB에서 테이블을 조회하게 된다.\n\n### ➰ 비교\nDB는 **기본 키의 값**으로 각 행을 구분한다. 하지만 객체는 **동일성 비교**와 **동등성 비교**라는 두 가지 비교 방법이 있다.\n- 동일성 비교는 `==` 비교이다. 객체 인스턴스의 주소 값을 비교한다.\n- 동등성 비교는 `equals()` 메소드를 사용해서 객체 내부의 값을 비교한다.\n\n> 여기서 하고 싶은 말은, 테이블의 행을 구분하는 방법과 객체를 구분하는 방법에는 차이가 있다는 것이다.\n\n```java\nclass MemberDAO {\n    public Member getMember(String memberId) {\n        String sql = \"SELECT * FROM MEMBER WHERE MEMBER_ID = ?\";\n        ...\n\n        // JDBC API, SQL 실행\n\n        return new Member(...);\n    }\n}\n```\n\n```java\nString memberId = \"100\";\nMember member1 = memberDAO.getMember(memberId);\nMember member2 = memberDAO.getMember(memberId);\n\nmember1 == member2; // 다르다!\n```\n\n- 같은 기본 키 값으로 회원 객체를 두 번 조회했다. \n  - 조회한 결과를 동일성 비교하면, `false` 가 반환된다.\n  - 이는 같은 DB 행에서 조회했지만, 객체 측면에서 볼 때, **둘은 서로 다른 인스턴스**이기 때문이다. (`getMember()` 호출 시, `new Member()` 로 인스턴스를 매번 새로 생성)\n- DB에 같은 행을 조회했지만 동일성 비교는 실패한다. 하지만 이 또한 컬렉션에 보관했다면 동일성 비교에 성공했을 것이다.\n\n> 이러한 패러다임의 불일치 문제를 해결하기 위해 DB의 같은 행을 조회할 때마다 같은 인스턴스를 반환되도록 하는 것은 쉽지 않다. 거기에 트랜잭션까지 고려한다면 더 골치가 아프다.\n\n#### JPA와 비교\nJPA는 같은 트랜잭션일 떄 같은 객체가 조회되는 것을 보장한다. 그러므로 위 예제에서 `memberDAO.getMember()` 가 아닌 `jpa.find()` 로 두 인스턴스의 동일성 비교가 성공한다.\n\n### ➰ 정리\nJPA는 객체 모델과 관계형 DB 모델이 각자 지향하는 패러다임의 불일치 문제를 해결해줌으로써, 개발자가 너무 많은 시간과 코드를 소비하지않도록 돕는다.\n\n---\n\n## 💫 JPA란 무엇일까?\nJPA(Java Persistence API)는 자바 진영의 ORM 기술 표준이다. 어는 자바 애플리케이션과 JDBC 사이에서 동작한다.\n\n그럼 ORM은 무엇일까? \n- **Object Relational Mapping**이라는 이름 그대로 객체와 관계형 DB를 매핑한다. \n\nORM 프레임워크는 객체와 테이블을 매핑해 패러다임의 불일치 문제를 해결해준다. 즉 INSERT SQL을 직접 작성하는 것이 아닌 객체를 마치 \"자바 컬렉션에 저장하듯 ORM 프레임워크에 저장\"하면 된다.\n\n`MemberDAO` 에서 `Entity Object` 를 `PERSIST`(저장) 하면 JPA는,\n- 해당 ENTITY를 분석하고\n- INSERT SQL을 생성하고\n- JDBC API를 사용함으로써\n\n**패러다임의 불일치 문제를 해결**한다.\n\n`FIND`(조회)할 때 역시\n- SELECT SQL을 생성하고\n- JDBC API를 사용해\n- 반환된 결과를 ResultSet에 매핑함으로써\n\n**패러다임의 불일치 문제를 해결**한다.\n\n이는 단순히 SQL을 개발자 대신 생성해 DB에 전달하는 것뿐 아닌 다양한 패러다임의 불일치 문제들도 해결해준다. \n- 따라서, 객체 측면에서는 정교한 객체 모델링이 가능해졌고, \n- 관계형 DB는 DB에 맞도록 모델링을 할 수 있다.\n- 그리고 매핑 방법만 ORM 프레임워크에 전달하면 된다.\n\n객체지향 언어에 따라 다양한 ORM 프레임워크들이 존재한다. 그중 Hibernate 프레임워크는 거의 대부분의 패러다임 불일치 문제를 해주는 프레임워크로, 가장 많이 사용된다.\n\n### ➰ JPA 소개\n과거 **엔터프라이즈 자바 빈즈(EJB)**라는 기술 표준이 있었다. 내부에는 엔티티 빈이라는 ORM 기술도 포함되어 있었는데, 너무 복잡하고 기술 성숙도도 떨어졌으며 자바 엔터프라이즈(J2EE) 애플리케이션 서버에서만 동작한다는 단점이 있었다.\n\n이때, Hibernate 오픈소스 ORM 프레임워크가 등장했다. 이는 매우 가볍고 실용적이며 기술 성숙도 또한 높아 이를 기반으로 새로운 자바 ORM 기술 표준을 만들었고, 이것이 바로 JPA이다.\n\n> **JPA는 자바 ORM 기술에 대한 API 표준 명세이다.**\n- 인터페이스를 모아둔 것으로, JPA를 구현한 ORM 프레임워크를 선택해야 JPA를 사용할 수 있다.\n  - 현재 JPA 2.1을 구현한 ORM 프레임워크는 Hibernate, EclipseLink, DataNucleus가 있다.\n\n### ➰ 왜 JPA를 사용해야 하는가?\n여러가지 이유가 있다. 하나씩 살펴보도록 한다.\n\n#### 생산성\n위에서 여러 번 언급했듯, 자바 컬렉션에 객체를 저장하는 것과 같은 코드 간결성을 얻을 수 있다. 지루하고 반복적인 CRUD용 SQL을 개발자가 직접 작성하지 않아도 되고, DDL문 또한 자동으로 생성해주기도 한다.\n\n> DB 설계 중심의 패러다임을 객체 설계 중심으로 역전시킬 수 있다.\n\n#### 유지보수\nSQL을 직접 다루게 되면, 이전에도 언급했듯 ENTITY에 필드를 하나만 추가해도 관련된 SQL과 결과를 매핑하기 위한 JDBC API 코드를 모두 수정해야 한다. 하지만 JPA는 이런 모든 과정을 대신 처리하기에 결과적으로 유지보수해야하는 코드의 수가 줄어드는 이점을 얻을 수 있다.\n\n#### 패러다임의 불일치 해결\nJPA는 지겹도록 언급한 상속, 연관관계, 객체 그래프 탐색, 비교하기와 같은 패러다임의 불일치 문제를 해결해준다.\n\n#### 성능\n애플리케이션과 DB 사이에 계층이 하나 더 있으면 최적화 관점에서 시도해 볼 수 있는 것들이 많다. JPA는 이 중간 계층으로서, 다양한 성능 최적화 기회를 제공한다.\n\n```java\nString memberId = \"helloId\";\nMember member1 = jpa.find(memberId);\nMember member2 = jpa.find(memberId);\n```\n\n- 위 예시는 같은 트랜잭션 안에서 같은 회원을 두 번 조회하는 코드인데, JDBC API를 사용했다면 SELECT SQL을 사용해 **DB와 두 번 통신**했을 것이다.\n- 하지만 JPA를 사용하면, SELECT SQL을 한 번만 DB에 전달하고, 두번째 조회는 **이미 조회한 회원 객체를 재사용**하여 최적화를 제공할 수 있다.\n\n#### 데이터 접근 추상화와 벤더 독립성\n관계형 DB는 같은 기능이라도 벤더마다 사용법이 다른 경우가 많다.\n- 페이징 처리는 DB마다 달라서 사용법을 각각 배워야 한다.\n\n결국, 애플리케이션은 처음 선택한 DB 기술에 종속되고 다른 DB로 변경이 매우 어려워진다.\n\nJPA는 애플리케이션과 DB 사이에 **추상화된 데이터 접근 계층을 제공**해 특정 DB 기술에 종속되지 않도록 한다.\n- DB를 변경하기 위해서는 JPA에게 이를 알려주기만 하면 된다.\n\n#### 표준\nJPA는 자바 진영의 ORM 기술 표준으로서, 이를 사용하면 다른 구현 기술로 손쉽게 변경할 수 있다.\n\n>> \"**JPA가 어려운 근본적인 이유는 ORM이 객체지향과 관계형 DB라는 두 기둥 위에 있기 때문입니다.**\"\n\n## 📕 출처\n**자바 ORM 표준 JPA 프로그래밍** - 김영한"},{"excerpt":"문제 백준시의 시장 최백준은 지난 몇 년간 게리맨더링을 통해서 자신의 당에게 유리하게 선거구를 획정했다. 견제할 권력이 없어진 최백준은 권력을 매우 부당하게 행사했고, 심지어는 시의 이름도 백준시로 변경했다. 이번 선거에서는 최대한 공평하게 선거구를 획정하려고 한다. 백준시는 N개의 구역으로 나누어져 있고, 구역은 1번부터 N번까지 번호가 매겨져 있다. …","fields":{"slug":"/[BOJ]17471/"},"frontmatter":{"date":"March 03, 2022","title":"👩‍💻 17471. 게리맨더링","tags":["그래프이론","그래프탐색","브루트포스","비트마스킹","DFS","BFS"]},"rawMarkdownBody":"\n## 문제\n\n백준시의 시장 최백준은 지난 몇 년간 게리맨더링을 통해서 자신의 당에게 유리하게 선거구를 획정했다. 견제할 권력이 없어진 최백준은 권력을 매우 부당하게 행사했고, 심지어는 시의 이름도 백준시로 변경했다. 이번 선거에서는 최대한 공평하게 선거구를 획정하려고 한다.\n\n백준시는 N개의 구역으로 나누어져 있고, 구역은 1번부터 N번까지 번호가 매겨져 있다. 구역을 두 개의 선거구로 나눠야 하고, 각 구역은 두 선거구 중 하나에 포함되어야 한다. 선거구는 구역을 적어도 하나 포함해야 하고, 한 선거구에 포함되어 있는 구역은 모두 연결되어 있어야 한다. 구역 A에서 인접한 구역을 통해서 구역 B로 갈 수 있을 때, 두 구역은 연결되어 있다고 한다. 중간에 통하는 인접한 구역은 0개 이상이어야 하고, 모두 같은 선거구에 포함된 구역이어야 한다.\n\n아래 그림은 6개의 구역이 있는 것이고, 인접한 구역은 선으로 연결되어 있다.\n\n<img src=\"https://upload.acmicpc.net/08218f4c-2653-4861-a4c1-e7ce808f3a85/-/preview/\" width=\"30%\">\n\n아래는 백준시를 두 선거구로 나눈 4가지 방법이며, 가능한 방법과 불가능한 방법에 대한 예시이다.\n\n<img src=\"https://upload.acmicpc.net/b82fcf21-6f4c-4797-bda6-215e14099d19/-/preview/\" width=\"20%\">가능한 방법: [1, 3, 4]와 [2, 5, 6]으로 나누어져 있다.\n\n<img src=\"https://upload.acmicpc.net/32947e26-4ec4-4b20-99f1-106d8386683d/-/preview/\" width=\"20%\">가능한 방법: [1, 2, 3, 4, 6]과 [5]로 나누어져 있다.\n\n<img src=\"https://upload.acmicpc.net/f5dd6143-c013-46d3-ba4c-dadc48bdf5bc/-/preview/\" width=\"20%\">불가능한 방법: [1, 2, 3, 4]와 [5, 6]으로 나누어져 있는데, 5와 6이 연결되어 있지 않다.\n\n<img src=\"https://upload.acmicpc.net/548b1153-84de-4b85-9697-2561b019a02b/-/preview/\" width=\"20%\">불가능한 방법: 각 선거구는 적어도 하나의 구역을 포함해야 한다.\n\n공평하게 선거구를 나누기 위해 두 선거구에 포함된 인구의 차이를 최소로 하려고 한다. 백준시의 정보가 주어졌을 때, 인구 차이의 최솟값을 구해보자.\n\n### 입력\n- 첫째 줄에 구역의 개수 N이 주어진다. 둘째 줄에 구역의 인구가 1번 구역부터 N번 구역까지 순서대로 주어진다. 인구는 공백으로 구분되어져 있다.\n- 셋째 줄부터 N개의 줄에 각 구역과 인접한 구역의 정보가 주어진다. 각 정보의 첫 번째 정수는 그 구역과 인접한 구역의 수이고, 이후 인접한 구역의 번호가 주어진다. 모든 값은 정수로 구분되어져 있다.\n- 구역 A가 구역 B와 인접하면 구역 B도 구역 A와 인접하다. 인접한 구역이 없을 수도 있다.\n\n### 출력\n- 첫째 줄에 백준시를 두 선거구로 나누었을 때, 두 선거구의 인구 차이의 최솟값을 출력한다. 두 선거구로 나눌 수 없는 경우에는 -1을 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Dosi {\n    ArrayList<Integer>[] dosi;\n    int[] population;\n    int[] area;\n    boolean[] visited;\n    int size;\n    int answer = Integer.MAX_VALUE;\n}\n```\n\n- 선거구의 정보를 담당하는 클래스이다.\n\n```java\npublic int searchDivision();\n```\n\n- 선거구 분할 메소드를 호출하고, 최솟값을 비교해 최종적으로 출력해야 할 값을 반환하는 함수이다.\n\n```java\nprivate void dfs(int n);\n```\n\n- 재귀적으로 호출되면서, 모든 선거구 분할법을 DFS방식으로 완전 탐색하며 선거구가 2개로 분할 가능한 경우에만 인구수 차이를 계속 업데이트하는 메소드이다.\n\n```java\nprivate void bfs(int idx, int areaN);\n```\n\n- 선거구 분할 후, 방문여부를 업데이트하기 위해 BFS 방식으로 수행되는 메소드이다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.*;\n\n    class Dosi {\n        ArrayList<Integer>[] dosi;\n        int[] population;\n        int[] area;\n        boolean[] visited;\n        int size;\n        int answer = Integer.MAX_VALUE;\n\n        public Dosi(int N) {\n            dosi = new ArrayList[N+1];\n            for (int i = 1; i <= N; i++) {\n                dosi[i] = new ArrayList<>();\n            }\n            area = new int[N + 1];\n            size = N;\n        }\n\n        public int searchDivision() {\n            dfs(1);\n            if (answer == Integer.MAX_VALUE) return -1;\n            return answer;\n        }\n\n        private void dfs(int n) {\n            if (n == size + 1) {\n                int pop1=0, pop2=0;\n                for (int i = 1; i <= size; i++) {\n                    if (area[i] == 1) pop1 += population[i-1];\n                    else pop2 += population[i-1];\n                }\n\n                visited = new boolean[size + 1];\n                int cnt = 0;\n                for (int i = 1; i <= size; i++) {\n                    if (!visited[i]) {\n                        bfs(i, area[i]);\n                        cnt++;\n                    }\n                }\n\n                if (cnt == 2) answer = Math.min(answer, Math.abs(pop1 - pop2));\n                return;\n            }\n            area[n] = 1;\n            dfs(n + 1);\n            area[n] = 2;\n            dfs(n + 1);\n        }\n\n        private void bfs(int idx, int areaN) {\n            Queue<Integer> q = new LinkedList<>();\n            visited[idx] = true;\n            q.add(idx);\n\n            while (!q.isEmpty()) {\n                int now = q.poll();\n\n                for(int i = 0; i < dosi[now].size(); i++) {\n                    int next = dosi[now].get(i);\n                    if(area[next] == areaN && !visited[next]) {\n                        q.add(next);\n                        visited[next] = true;\n                    }\n                }\n            }\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            int N = Integer.parseInt(br.readLine());\n            String[] line;\n\n            Dosi d = new Dosi(N);\n            d.population = Arrays.stream(br.readLine().split(\" \")).mapToInt(Integer::parseInt).toArray();\n\n            for (int i = 0; i < N; i++) {\n                line = br.readLine().split(\" \");\n                for (int j = 0; j < Integer.parseInt(line[0]); j++) {\n                    d.dosi[i+1].add(Integer.parseInt(line[j+1]));\n                }\n            }\n\n            System.out.println(d.searchDivision());\n\n            br.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 대략적으로 구상한 방법은,\n  - 분할이 가능한 방법으로 선거구를 두 개로 분할\n  - 분할한 경우 중, 인구 차이를 계속 업데이트하는 방식으로 가장 최소가 되는 분할법을 탐색\n- 그런데 어떻게 선거구를 분할해야하는가가 고민이었다. 그래서 게시판에서 \"0번 구역이 포함된 선거구 vs 0번 구역이 포함되지 않은 선거구\" 라는 아이디어를 발견해 생각해보았다.\n  - 역시나 구현에서 막혀 아래 블로그를 참고했다...\n- 매번 문제를 시작할 때 어떻게 하면 깔끔하게 입력을 받아 저장할 수 있을까를 고민하는데, 이번에는 좀 새로운 문법을 사용해보았다. \n  - `String[] tokens` 에 `split(\" \")` 한 결과를 매번 담았다가 정수로 파싱하여 다시 저장했는데, 이번엔 문자열 한 줄을 받아 공백 기준으로 나누면서 바로 정수형 배열에 저장하는 방식을 사용해보았다.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/17471\n\n### 참고\nhttps://moonsbeen.tistory.com/254"},{"excerpt":"문제 뿌요뿌요의 룰은 다음과 같다. 필드에 여러 가지 색깔의 뿌요를 놓는다. 뿌요는 중력의 영향을 받아 아래에 바닥이나 다른 뿌요가 나올 때까지 아래로 떨어진다.\n뿌요를 놓고 난 후, 같은 색 뿌요가 4개 이상 상하좌우로 연결되어 있으면 연결된 같은 색 뿌요들이 한꺼번에 없어진다. 이때 1연쇄가 시작된다.\n뿌요들이 없어지고 나서 위에 다른 뿌요들이 있다면…","fields":{"slug":"/[BOJ]11559/"},"frontmatter":{"date":"March 02, 2022","title":"👩‍💻 11559. Puyo Puyo","tags":["구현","그래프이론","그래프탐색","시뮬레이션","BFS"]},"rawMarkdownBody":"\n## 문제\n\n뿌요뿌요의 룰은 다음과 같다.\n\n> 필드에 여러 가지 색깔의 뿌요를 놓는다. 뿌요는 중력의 영향을 받아 아래에 바닥이나 다른 뿌요가 나올 때까지 아래로 떨어진다.\n> 뿌요를 놓고 난 후, 같은 색 뿌요가 4개 이상 상하좌우로 연결되어 있으면 연결된 같은 색 뿌요들이 한꺼번에 없어진다. 이때 1연쇄가 시작된다.\n> 뿌요들이 없어지고 나서 위에 다른 뿌요들이 있다면, 역시 중력의 영향을 받아 차례대로 아래로 떨어지게 된다.\n> 아래로 떨어지고 나서 다시 같은 색의 뿌요들이 4개 이상 모이게 되면 또 터지게 되는데, 터진 후 뿌요들이 내려오고 다시 터짐을 반복할 때마다 1연쇄씩 늘어난다.\n> 터질 수 있는 뿌요가 여러 그룹이 있다면 동시에 터져야 하고 여러 그룹이 터지더라도 한번의 연쇄가 추가된다.\n\n남규는 최근 뿌요뿌요 게임에 푹 빠졌다. 이 게임은 1:1로 붙는 대전게임이라 잘 쌓는 것도 중요하지만, 상대방이 터뜨린다면 연쇄가 몇 번이 될지 바로 파악할 수 있는 능력도 필요하다. 하지만 아직 실력이 부족하여 남규는 자기 필드에만 신경 쓰기 바쁘다. 상대방의 필드가 주어졌을 때, 연쇄가 몇 번 연속으로 일어날지 계산하여 남규를 도와주자!\n\n### 입력\n- 총 12개의 줄에 필드의 정보가 주어지며, 각 줄에는 6개의 문자가 있다.\n이때 .은 빈공간이고 .이 아닌것은 각각의 색깔의 뿌요를 나타낸다.\nR은 빨강, G는 초록, B는 파랑, P는 보라, Y는 노랑이다.\n입력으로 주어지는 필드는 뿌요들이 전부 아래로 떨어진 뒤의 상태이다. 즉, 뿌요 아래에 빈 칸이 있는 경우는 없다.\n\n### 출력\n- 현재 주어진 상황에서 몇연쇄가 되는지 출력한다. 하나도 터지지 않는다면 0을 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Puyo {\n    char[][] field = new char[12][6];\n    int[] x_ary = { -1, 0, 1, 0 };\n    int[] y_ary = { 0, 1, 0, -1 };\n    List<Pair> remove;\n    Queue<Pair> queue;\n    int[][] visited;\n\n    ...\n\n}\n```\n- 뿌요의 필드를 관리하기 위한 클래스를 생성한다.\n\n```java\npublic boolean searchChains();\n```\n\n- BFS방식으로 필드에 발생가능한 연쇄가 있는지 탐색한다.\n- 터질 수 있는 뿌요를 `List<Puyo> remove` 에 저장하여, 연쇄 발생 시 해당 뿌요들을 제거할 수 있게 한다.\n\n```java\nprivate void updateField();\n```\n\n- 연쇄 탐색 이후, 발생한 연쇄가 있는 경우에만 필드를 업데이트하기 위해 호출되는 메소드이다.\n  \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.io.BufferedReader;\n    import java.io.IOException;\n    import java.io.InputStreamReader;\n    import java.util.LinkedList;\n    import java.util.List;\n    import java.util.Queue;\n\n    class Pair {\n        int x;\n        int y;\n\n        Pair(int x, int y) {\n            this.x = x;\n            this.y = y;\n        }\n    }\n\n    class Puyo {\n        char[][] field = new char[12][6];\n        int[] x_ary = { -1, 0, 1, 0 };\n        int[] y_ary = { 0, 1, 0, -1 };\n        List<Pair> remove;\n        Queue<Pair> queue;\n        int[][] visited;\n\n        public boolean searchChains() {\n            remove = new LinkedList<>();\n            queue = new LinkedList<>();\n            visited = new int[12][6];\n            boolean pop = false;\n\n            for (int i = 11; i >= 0; i--) {\n                for (int j = 0; j < 6; j++) {\n                    if (field[i][j] == '.') continue;\n                    if (visited[i][j] != 0) continue;\n\n                    char now = field[i][j];\n                    int cnt = 1;\n                    visited[i][j] = cnt++;\n                    queue.add(new Pair(i, j));\n                    remove.add(new Pair(i, j));\n\n                    while(!queue.isEmpty()) {\n                        Pair cur = queue.poll();\n                        int curX = cur.x, curY = cur.y;\n\n                        for (int t = 0; t < 4; t++) {\n                            int ni = curX + x_ary[t], nj = curY + y_ary[t];\n\n                            if (isBoundary(ni, nj)) continue;\n                            if (visited[ni][nj] > 0) continue;\n\n                            if (now == field[ni][nj]) {\n                                visited[ni][nj] = cnt++;\n                                queue.add(new Pair(ni, nj));\n                                remove.add(new Pair(ni, nj));\n                            }\n                        }\n                    }\n                    if (cnt >= 5) {\n                        pop = true;\n                        for (Pair p : remove) {\n                            field[p.x][p.y] = '.';\n                        }\n                    }\n                    remove.clear();\n                }\n            }\n            if (pop) {\n                updateField();\n            }\n            return pop;\n        }\n\n        private void updateField() {\n            for (int i = 0; i < 6; i++) {\n                for (int j = 11; j > 0; j--) {\n                    if (field[j][i] == '.') {\n                        for (int k = j - 1; k >= 0; k--) {\n                            if (field[k][i] != '.') {\n                                field[j][i] = field[k][i];\n                                field[k][i] = '.';\n                                break;\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        private boolean isBoundary(int x, int y) {\n            return x < 0 | x > 11 | y < 0 | y > 5;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) throws IOException {\n            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n            String line;\n            int chains = 0;\n            Puyo puyo = new Puyo();\n\n            for (int i = 0; i < 12; i++) {\n                line = br.readLine();\n                for (int j = 0; j < 6; j++) {\n                    puyo.field[i][j] = line.charAt(j);\n                }\n            }\n\n            while(puyo.searchChains()) {\n                chains++;\n            }\n\n            System.out.println(chains);\n\n            br.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 주어진 상황에서, 먼저 연쇄가 일어날 수 있는지 파악한다. 여러 개의 연쇄가 가능하다면, 어느 우선순위로 연쇄를 발생시킬지를 고민했다.\n  - 생각해보니 연쇄간의 우선순위는 중요하지 않았고, 연쇄 발생 이후 해당 뿌요들을 어떻게 제거하는가가 더 중요했다.\n- 연쇄 발생 가능한 뿌요들을 탐색과 동시에 제거할 방법이 없기에 리스트에 저장하면서 연쇄가 발생하는 경우에만 이를 제거하는 방식을 참고하여 해결했다.\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/11559"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 🚩 필드와 setter 메소드에 @Inject 기능 추가 🔧 요구사항  를 활용해 DI함으로써 빈 간의 의존관계를 쉽게 연결할 수 있다. 하지만 현재는 생성자를 통해서만 DI가 가능하다. 따라서 생성자 이외에 필드,  메소드를 통해서도 DI할 수 있도록 기능을 추가한…","fields":{"slug":"/[NextStep]12/"},"frontmatter":{"date":"February 23, 2022","title":"📖 12장 확장성 있는 DI 프레임워크로 개선","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n## 🚩 필드와 setter 메소드에 @Inject 기능 추가\n### 🔧 요구사항\n`@Inject` 를 활용해 DI함으로써 빈 간의 의존관계를 쉽게 연결할 수 있다. 하지만 현재는 생성자를 통해서만 DI가 가능하다. 따라서 생성자 이외에 **필드, `setter` 메소드**를 통해서도 DI할 수 있도록 기능을 추가한다.\n \n### 🔧 1단계 힌트 - 클래스 설계\n생성자, 필드, `setter` 메소드, 총 3가지의 경우의 수가 있다. 지금까지 여러 경우의 수가 있는 경우 **추상화 과정을 통해 인터페이스를 추가**한 후 각 경우에 대한 구현을 수행했다.\n\n`BeanFactory` 의 역할은 빈을 추가하고, 조회하는 역할만 남기고 생성자를 활용해 DI를 하고 인스턴스 생성은 `ConstructorInjector` 라는 이름으로 분리한다.\n- `Injector` 라는 인터페이스를 추가한다. 이는 생성자, 필드, `setter` 메소드 DI에 대한 추상 메소드로 `inject()` 를 가진다.\n- 생성자, 필드, `setter` 메소드에 대한 DI를 담당하는 클래스를 구현한다. 이는 `Injector` 인터페이스를 구현한다.\n  - 3개의 구현체를 구현하는 과정에서 발생하는 중복 코드들은 `Injector` 인터페이스와 구현체 사이에 `AbstractInjector` 와 같은 추상 클래스로 제거한다.\n\n### 🔧 2단계 힌트\n생성자 구현체(`ConstructorInjector`)는 `@Inject` 가 설정되어 있는 생성자를 가지는 클래스를 찾는다.\n- 생성자의 인자에 해당하는 빈이 `BeanFactory` 에 등록되어 있는지 확인해보고 등록되어 있지 않다면 빈 인스턴스를 생성하여 DI한다.\n\n필드 구현체(`FieldInjector`)와 `setter` 메소드 구현체(`SetterInjector`) 또한 같은 방식으로 구현한다.\n- 필드 구현체의 경우 클래스에 `@Injector`가 설정되어 있는 모든 필드를 찾는다.\n- 필드 타입(클래스)에 해당하는 빈이 등록되어 있는지 확인해보고 등록되어 있지 않다면 빈 인스턴스를 생성하여 DI한다.\n\n### 🔧 중복 제거를 위한 힌트\n`@Injector` 가 설정되어 있는 위치가 다르다는 점을 제외하면, 3개의 구현체의 로직 처리 과정은 동일하다. \n- 이와 같이 로직이 같은 경우 **템플릿 메소드 패턴**을 적용할 수 있다.\n- 부모 클래스인 `AbstractInjector` 는 로직 구현을 담당하고, 3개의 하위 클래스(구현체)는 각 클래스마다 다른 부분만을 구현한다.\n\n---\n\n## 🚩 필드와 setter 메소드 @Inject 구현\n`ConstructorInjector` 는 이전에 구현한 `BeanFactory` 의 `instantiateClass()` , `instantiateConstructor()` 메소드와 같다. \n- 다른 점은 빈을 저장하기 위한 `Map` 을 직접 가지지 않고 `BeanFactory` 를 통해 접근하도록 한다는 것이다.\n- `ConstructorInjector` 의 `instantiateClass()` 는 앞으로 추가할 `FieldInjector` , `SetterInjector` 도 필요하므로, 이들의 중복 제거를 위한 클래스인 `AbstractInjector` 에서 구현하도록 한다.\n\n```java\npublic abstract class AbstractInjector implements Injector {\n    private BeanFactory beanFactory;\n\n    public AbstractInjector(BeanFactory beanFactory) {\n        this.beanFactory = beanFactory;\n    }\n\n    @Override\n    public void inject(Class<?> clazz) {\n        instantiateClass(clazz);\n        Set<?> injectedBeans = getInjectedBeans(clazz);\n        for (Object injectedBean : injectedBeans) {\n            Class<?> beanClass = getBeanClass(injectedBean);\n            inject(injectedBean, instantiateClass(beanClass), beanFactory);\n        }\n    }\n\n    abstract Set<?> getInjectedBeans(Class<?> clazz);\n\n    abstract Class<?> getBeanClass(Object injectedBean);\n\n    abstract void inject(Object injectedBean, Object bean, BeanFactory beanFactory);\n\n    private Object instantiateClass(Class<?> clazz) {\n        Class<?> concreteClass = findBeanClass(clazz, beanFactory.getPreInstanticateBeans());\n        Object bean = beanFactory.getBean(concreteClass);\n        if (bean != null) {\n            return bean;\n        }\n\n        Constructor<?> injectedConstructor = BeanFactoryUtils.getInjectedConstructor(concreteClass);\n\n        if (injectedConstructor == null) {\n            bean = BeanUtils.instantiate(concreteClass);\n            beanFactory.registerBean(concreteClass, bean);\n            return bean;\n        }\n\n        bean = instantiateConstructor(injectedConstructor);\n        beanFactory.registerBean(concreteClass, bean);\n        return bean;\n    }\n\n    private Object instantiateConstructor(Constructor<?> constructor) {\n        Class<?>[] pTypes = constructor.getParameterTypes();\n        List<Object> args = Lists.newArrayList();\n\n        for (Class<?> clazz : pTypes) {\n            Class<?> concreteClazz = BeanFactoryUtils.findConcreteClass(clazz, beanFactory.getPreInstanticateBeans());\n            Object bean = beanFactory.getBean(concreteClazz);\n            if (bean == null) {\n                bean = instantiateClass(concreteClazz);\n            }\n            args.add(bean);\n        }\n        return BeanUtils.instantiateClass(constructor, args.toArray());\n    }\n\n    private Class<?> findBeanClass(Class<?> clazz, Set<Class<?>> preInstanticateBeans) {\n        Class<?> concreteClazz = BeanFactoryUtils.findConcreteClass(clazz, preInstanticateBeans);\n        if (!preInstanticateBeans.contains(concreteClazz)) {\n            throw new IllegalStateException(clazz + \"는 Bean이 아니다.\");\n        }\n        return concreteClazz;\n    }\n}\n```\n\n- `BeanFactory` 의 `private` 자원들에 대한 접근을 위해 `BeanFactory` 에 선언한 `getBean()` , `getPreInstanticateBeans()` , `registerBean()` 메소드를 활용한다.\n\n```java\npublic class ConstructorInjector extends AbstractInjector {\n    public ConstructorInjector(BeanFactory beanFactory) {\n        super(beanFactory);\n    }\n\n    @Override\n    Set<?> getInjectedBeans(Class<?> clazz) {\n        return Sets.newHashSet();\n    }\n\n    @Override\n    Class<?> getBeanClass(Object injectedBean) {\n        return null;\n    }\n\n    @Override\n    void inject(Object injectedBean, Object bean, BeanFactory beanFactory) {\n    }\n}\n```\n\n- `ConstructorInjector` 는 구현 로직이 모두 `AbstractInjector` 로 이동했으므로 간단하다.\n\n```java\npublic class FieldInjector extends AbstractInjector {\n    private static final Logger log = LoggerFactory.getLogger(FieldInjector.class);\n\n    public FieldInjector(BeanFactory beanFactory) {\n        super(beanFactory);\n    }\n\n    @Override\n    Set<?> getInjectedBeans(Class<?> clazz) {\n        return BeanFactoryUtils.getInjectedFields(clazz);\n    }\n\n    @Override\n    Class<?> getBeanClass(Object injectedBean) {\n        Field field = (Field)injectedBean;\n        return field.getType();\n    }\n\n    @Override\n    void inject(Object injectedBean, Object bean, BeanFactory beanFactory) {\n        Field field = (Field) injectedBean;\n        try {\n            field.setAccessible(true);\n            field.set(beanFactory.getBean(field.getDeclaringClass()), bean);\n        } catch (IllegalAccessException | IllegalArgumentException e) {\n            log.error(e.getMessage());\n        }\n    }\n}\n```\n\n```java\npublic class SetterInjector extends AbstractInjector {\n    private static final Logger log = LoggerFactory.getLogger(SetterInjector.class);\n\n    public SetterInjector(BeanFactory beanFactory) {\n        super(beanFactory);\n    }\n\n    @Override\n    Set<?> getInjectedBeans(Class<?> clazz) {\n        return BeanFactoryUtils.getInjectedMethods(clazz);\n    }\n\n    @Override\n    Class<?> getBeanClass(Object injectedBean) {\n        Method method = (Method) injectedBean;\n        Class<?>[] paramTypes = method.getParameterTypes();\n        if (paramTypes.length != 1) {\n            throw new IllegalStateException(\"DI할 메소드 인자는 하나여야 합니다.\");\n        }\n        return paramTypes[0];\n    }\n\n    @Override\n    void inject(Object injectedBean, Object bean, BeanFactory beanFactory) {\n        Method method = (Method) injectedBean;\n        try {\n            method.invoke(beanFactory.getBean(method.getDeclaringClass()), bean);\n        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {\n            log.error(e.getMessage());\n        }\n    }\n}\n```\n\n템플릿 메소드 패턴을 적용해 로직 중복을 제거하여 하위 클래스의 구현이 매우 간단해졌다. 이제 `BeanFactory` 가 방금까지 구현한 3개의 `Injector` 를 사용하도록 리팩토링한다.\n\n```java\npublic class BeanFactory {\n    private static final Logger logger = LoggerFactory.getLogger(BeanFactory.class);\n\n    private Set<Class<?>> preInstanticateBeans;\n\n    private Map<Class<?>, Object> beans = Maps.newHashMap();\n\n    private List<Injector> injectors;\n\n    public BeanFactory(Set<Class<?>> preInstanticateBeans) {\n        this.preInstanticateBeans = preInstanticateBeans;\n\n        injectors = Arrays.asList(\n                new FieldInjector(this),\n                new SetterInjector(this),\n                new ConstructorInjector(this)\n        );\n    }\n\n    public void initialize() {\n        for (Class<?> clazz : preInstanticateBeans) {\n            if (beans.get(clazz) == null) {\n                logger.debug(\"instantiated Class : {}\", clazz);\n                inject(clazz);\n            }\n        }\n    }\n\n    private void inject(Class<?> clazz) {\n        for (Injector injector : injectors) {\n            injector.inject(clazz);\n        }\n    }\n    ...\n\n}\n```\n\n- `BeanFactory` 생성자 호출 시, 구현한 `Injector` 들을 초기화해주고, `initialize()` 메소드 호출로, 초기화한 `Injector` 들에 대한 DI를 수행한다.\n\n---\n\n## 🚩 @Inject 개선\n`BeanFactory` 와 `AbstractInjector` 코드를 보면, 중복을 제거하기는 했지만 소스 코드의 이해도가 떨어진다. 또한, 현재 모든 빈과 관련한 정보는 `BeanFactory` 가 관리하는데, 빈 인스턴스 생성과 주입을 `Injector` 구현 클래스가 담당하는 구조여서 `BeanFactory` 에게 일을 시키는 것이 아닌 **빈 정보 조회**가 계속 발생한다.\n- 즉, `BeanFactory` 객체의 활용도가 떨어지는 구조이다.\n- 활용도를 높이기 위해 빈 인스턴스 생성과 주입 작업은 `BeanFactory` 가, 현재 빈 클래스의 상태 정보를 별도의 클래스로 추상화(`BeanDefinition`)해 관리하게끔 한다.\n- 설정된 annotation에 있는 클래스를 조회하는 역할을 하는 `BeanScanner` 클래스의 이름도 `ClasspathBeanDefinitionScanner` 로 rename한다.\n    - 이는 annotation이 설정된 클래스를 조회한 후 `BeanDefinition` 을 생성해 `BeanFactory` 에 전달한다. 이때, `ClasspathBeanDefinitionScanner` 와 `BeanFactory` 간 강한 의존관계를 가지지 않도록 설계한다. (`BeanDefinition` 을 `BeanFactory` 에 전달하는 부분에서만 발생하도록 구현, `BeanDefinition` 을 저장하는 인터페이스(`BeanDefinitionRegistry`)를 추가하여 의존관계를 느슨하게!)\n    - 즉, `BeanFactory` 는 **`BeanDefinition` 을 저장하는 저장소 역할**과 **`BeanDefinition` 을 활용해 빈 인스턴스 생성, 의존관계 주입을 담당하는 역할**로 나뉜다.\n\n```java\npublic interface BeanDefinitionRegistry {\n    void registerBeanDefinition(Class<?> clazz, BeanDefinition beanDefinition);\n}\n```\n\n```java\npublic class ClasspathBeanDefinitionScanner {\n    private final BeanDefinitionRegistry beanDefinitionRegistry;\n\n    public ClasspathBeanDefinitionScanner(BeanDefinitionRegistry beanDefinitionRegistry) {\n        this.beanDefinitionRegistry = beanDefinitionRegistry;\n    }\n\n    @SuppressWarnings(\"unchecked\")\n    public void doScan(Object... basePackages) {\n        Reflections reflections = new Reflections(basePackages);\n        Set<Class<?>> beanClasses = getTypesAnnotatedWith(reflections, Controller.class, Service.class, Repository.class);\n        for (Class<?> clazz : beanClasses) {\n            beanDefinitionRegistry.registerBeanDefinition(clazz, new BeanDefinition(clazz));\n        }\n    }\n\n    @SuppressWarnings(\"unchecked\")\n    private Set<Class<?>> getTypesAnnotatedWith(Reflections reflections, Class<? extends Annotation>... annotations) {\n        Set<Class<?>> preInstantiatedBeans = Sets.newHashSet();\n        for (Class<? extends Annotation> annotation : annotations) {\n            preInstantiatedBeans.addAll(reflections.getTypesAnnotatedWith(annotation));\n        }\n        return preInstantiatedBeans;\n    }\n}\n```\n\n- 이로써, 각 객체의 역할을 분리했다.\n  - `ClasspathBeanDefinitionScanner` 는 클래스패스에서 빈을 조회(`getTypesAnnotatedWith()`)하는 역할을 담당하고,\n  - 조회한 빈 정보를 `BeanDefinition` 을 생성해 `beanDefinitionRegistry` 에 전달(`beanDefinitionRegistry.registerBeanDefinition(clazz, new BeanDefinition(clazz));`)\n  - `BeanDefinitionRegistry` 구현체가 `BeanDefinition` 의 저장소 역할을 담당한다.\n\n`BeanFactory` 는 빈 인스턴스를 생성하고, 의존관계 주입을 위해서는 `BeanDefinition` 정보가 필요하다. \n- 이는 `BeanFactory` 가 `BeanDefinitionRegistry` 구현체로 `BeanDefinition` 정보를 관리하도록 구현한다.\n\n```java\npublic class BeanFactory implements BeanDefinitionRegistry {\n    private static final Logger logger = LoggerFactory.getLogger(BeanFactory.class);\n    ...\n\n    private Map<Class<?>, BeanDefinition> beanDefinitions = Maps.newHashMap();\n    ...\n\n    public void initialize() {\n        for (Class<?> clazz : getBeanClasses()) {\n            getBean(clazz);\n        }\n    }\n\n    public Set<Class<?>> getBeanClasses() {\n        return beanDefinitions.keySet();\n    }\n\n    @Override\n    public void registerBeanDefinition(Class<?> clazz, BeanDefinition beanDefinition) {\n        logger.debug(\"register bean : {]\", clazz);\n        beanDefinitions.put(clazz, beanDefinition);\n    }\n}\n```\n\n`BeanFactory` 와 `ClasspathBeanDefinitionScanner` 의 의존관계에 대한 연결은 이 두 클래스를 활용하는 곳에서 담당한다. 지금까지는 `AnnotationHandlerMapping` 이 이를 담당한다.\n\n```java\npublic class AnnotationHandlerMapping implements HandlerMapping {\n    private static final Logger logger = LoggerFactory.getLogger(AnnotationHandlerMapping.class);\n\n    private Object[] basePackage;\n\n    private Map<HandlerKey, HandlerExecution> handlerExecutions = Maps.newHashMap();\n\n    public AnnotationHandlerMapping(Object... basePackage) {\n        this.basePackage = basePackage;\n    }\n\n    public void initialize() {\n        BeanFactory beanFactory = new BeanFactory();\n        ClasspathBeanDefinitionScanner scanner = new ClasspathBeanDefinitionScanner(beanFactory);\n        scanner.doScan(basePackage);\n        beanFactory.initialize();\n        ...\n\n    }\n    ...\n\n}\n```\n\n`BeanFactory` 와 `ClasspathBeanDefinitionScanner` 의 의존관계 또한 DI를 활용해 구현하여 유연성을 확보했다. \n- `ClasspathBeanDefinitionScanner` 는 단순히 클래스 패스에서 빈을 조회한 후 `BeanDefinition` 을 생성해 `BeanDefinitionRegistry` 의 `registerBeanDefinition()` 메소드로 전달하는 역할을 담당한다.\n- 하지만, 이 경우 **객체 간의 DI를 담당할 코드가 필요**하다는 단점이 있다. \n  - 객체 간의 의존관계를 연결하지 않은 채로 API를 제공하면, 이를 사용하는 개발자는 일일이 DI를 해줘야 한다.\n- 이러한 단점 보완을 위해 **객체 간의 DI를 담당하는 새로운 객체를 추가**한다. (`ApplicationContext`)\n\n```java\npublic class ApplicationContext {\n    private BeanFactory beanFactory;\n    \n    public ApplicationContext(Object... basePackages) {\n        beanFactory = new BeanFactory();\n        ClasspathBeanDefinitionScanner scanner = new ClasspathBeanDefinitionScanner(beanFactory);\n        scanner.doScan(basePackages);\n        beanFactory.initialize();\n    }\n    \n    public <T> T getBean(Class<T> clazz) {\n        return beanFactory.getBean(clazz);\n    }\n    \n    public Set<Class<?>> getBeanClasses() {\n        return beanFactory.getBeanClasses();\n    }\n} \n```\n\n- `BeanFactory` 초기화 과정을 `ApplicationContext` 로 옮기고, `BeanFactory` 로 직접 접근하던 API를 `ApplicationContext` 를 통해 접근하도록 리팩토링했다.\n  - 이때, `BeanFactory` 가 담당하던 `getControllers()` 메소드의 역할이 적합하지 않아 이를 `AnnotationHandlerMapping` 으로 이동하고 구현을 위해 필요한 기능만 `ApplicationContext` 를 통해 접근하도록 구현했다.\n\n```java\npublic class AnnotationHandlerMapping implements HandlerMapping {\n    ...\n\n    public void initialize() {\n        ApplicationContext ac = new ApplicationContext(basePackage);\n        Map<Class<?>, Object> controllers = getControllers(ac);\n        ...\n\n    }\n\n    private Map<Class<?>, Object> getControllers(ApplicationContext ac) {\n        Map<Class<?>, Object> controllers = Maps.newHashMap();\n        for (Class<?> clazz : ac.getBeanClasses()) {\n            Annotation annotation = clazz.getAnnotation(Controller.class);\n            if (annotation != null) {\n                controllers.put(clazz, ac.getBean(clazz));\n            }\n        }\n        return controllers;\n    }\n}\n```\n\n- 객체 간의 의존관계 연결을 담당하도록 구현하여 더 이상 `BeanFactory` 를 사용하는 개발자가 의존관계때문에 머리 아파하지 않아도 된다.\n- 빈 클래스 정보를 담고 있는 `BeanDefinition` 은 생성자로 전달되는 클래스에서 `@Inject` 가 어떻게 설정되어 있는지에 따라 `InjectType` 을 결정한다. (`enum` 사용)\n  - 이때, `InjectType` 에서는 필드와 `setter` 메소드를 활용한 `@Inject` 는 동일하게 취급하는데, 이는 내부 구현의 차이가 없기 때문이다.\n- 빈 클래스 정보를 활용해 빈 인스턴스를 생성하고 의존관계 주입을 담당하는 `BeanFactory` 는 빈 클래스의 의존관계와 관련한 정보 처리를 모두 `BeanDefinition` 에게 위임하여 담당할 책임이 줄었다.\n\n---\n\n## 🚩 설정 추가를 통한 유연성 확보\n지금까지 구현한 코드를 비판적인 시각으로 분석했을때, 아래와 같은 개선사항들이 보인다.\n- `DispatcherServlet` 의 `init()` 메소드를 보면 `\"next\"` 라는 패키지 이름이 하드 코딩되어 있다. 기본 패키지명을 외부에서 전달할 수 있도록 구현한다.\n- `JdbcTemplate` 이 아직까지 싱글톤 패턴으로 구현되어 있다. 이를 DI 프레임워크의 빈으로 등록해 관리함으로써, 싱글톤 패턴을 제거한다. \n  - 이때, 각 레이어에 명확히 일치하지 않는 빈을 지원하는 annotation을 추가할 필요가 있다.\n- DB Connection을 생성하는 부분도 `static` 으로 구현되어 있다. 또한 DB 설정 정보도 하드 코딩으로 관리되어 특정 DB에 종속되는 구조이다. 이러한 구조를 벗어나고, **Connection Pooling**을 지원하기 위해 `Connection` 대신 `javax.sql.DataSource` 인터페이스에 의존관계를 가지도록 개선한다.\n\n세번째 이슈는 `DataSource` 구현체로 Apache Commons에서 제공하는 DBCP 라이브러리를 활용해 DB 설정한 후 빈으로 등록하면 해결이 가능하다.\n- 지금까지는 모두 직접 구현한 클래스를 빈으로 등록했기에 annotation 설정이 가능했다.\n- 하지만 DBCP 구현체의 경우 외부 라이브러리이기때문에 수정이 불가능하다. 외부 라이브러리 사용을 위해 구현체를 상속해 빈 설정을 하면 해결이 가능하지만, 매번 이러한 과정을 거치는 것은 효율적이지 못하다.\n- 따라서, 첫번째와 두번째 이슈부터 개선하도록 한다.\n\n### 🔧 ServletContainerInitializer를 활용해 web.xml 없이 웹 개발하기\n**첫번째 이슈**<br/>\n: 서블릿에 인자를 전달함으로써 해결이 가능하다.\n\n서블릿 컨테이너의 경우, `web.xml` 설정을 통해 서블릿에 인자를 전달할 수 있다. 하지만 서블릿 3.0 이후 버전에서는 `web.xml` 을 사용하지 않고도 설정이 가능한데, 이는 `ServletContainerInitializer` 인터페이스를 구현함으로써 가능하다.\n\n인터페이스를 구현하려면, 먼저 확장을 위해 자체적으로 사용할 인터페이스를 정의하도록 한다. (`WebApplicationInitializer`)\n\n```java\npublic interface WebApplicationInitializer {\n    void onStartup(ServletContext servletContext) throws ServletException;\n}\n```\n\n위 인터페이스에 대한 구현체를 구현한다. (`MyServletContainerInitializer`)\n\n```java\n@HandlesTypes(WebApplicationInitializer.class)\npublic class MyServletContainerInitializer implements ServletContainerInitializer {\n    @Override\n    public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {\n        List<WebApplicationInitializer> initializers = new LinkedList<>();\n\n        if (webAppInitializerClasses != null) {\n            for (Class<?> waiClass : webAppInitializerClasses) {\n                try {\n                    initializers.add((WebApplicationInitializer) waiClass.newInstance());\n                } catch (Throwable ex) {\n                    throw new ServletException(\"WebApplicationInitializer class를 인스턴스화하는데 실패했습니다.\", ex);\n                }\n            }\n        }\n        \n        if (initializers.isEmpty()) {\n            servletContext.log(\"classpath에서 감지된 Spring WebApplicationInitializer types가 없습니다.\");\n            return;\n        }\n        \n        for(WebApplicationInitializer initializer : initializers) {\n            initializer.onStartup(servletContext);\n        }\n    }\n}\n```\n\n- 서블릿 컨테이너는 클래스패스에 존재하는 클래스 중 `WebApplicationInitializer` 인터페이스를 구현하는 모든 구현체를 찾아 `MyServletContainerInitializer` 의 `onStartup()` 메소드 인자로 전달한다.\n- 해당 메소드는 서블릿 컨테이너에 전달한 `WebApplicationInitializer` 의 `onStartup()` 메소드를 실행한다.\n\n> `WebApplicationInitializer` 인터페이스를 구현함으로써 서블릿 컨테이너의 초기화 과정을 확장할 수 있게 되었다.\n\n`MyServletContainerInitializer` 의 `onStartup()` 메소드 실행을 위해서는 서블릿 컨테이너가 이 클래스를 인식하는 것이 먼저이다. 이를 위한 설정은 클래스패스의 `src/main/resources/META-INF/services` 에 `javax.servlet.ServletContainerInitializer` 파일을 생성해, `core.web.MyServletContainerInitializer` 을 추가한다.\n\n이제 `web.xml` 없이도 개발이 가능한 상태가 되었으니, 하드코딩으로 구현되어 있던 패키지 이름을 `WebApplicationInitializer` 에 대한 구현체를 만들어 구현 가능하다.\n\n```java\npublic class MyWebApplicationInitializer implements WebApplicationInitializer {\n    private static final Logger log = LoggerFactory.getLogger(MyWebApplicationInitializer.class);\n\n    @Override\n    public void onStartup(ServletContext servletContext) throws ServletException {\n        ServletRegistration.Dynamic dispatcher = servletContext.addServlet(\"dispatcher\", new DispatcherServlet(\"next\"));\n        dispatcher.setLoadOnStartup(1);\n        dispatcher.addMapping(\"/\");\n\n        log.info(\"Start MyWebApplication Initializer\");\n    }\n}\n```\n\n- `MyWebApplicationInitializer` 에서 `DispatcherServlet` 을 직접 생성해 등록(`LoadOnStartup` , `Mapping` 속성 또한 등록) `DispatcherServlet` 의 `@WebServlet` annotation 설정은 더이상 필요없다.\n\n```java\npublic class DispatcherServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n    private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);\n\n    private List<HandlerMapping> mappings = Lists.newArrayList();\n    private List<HandlerAdapter> handlerAdapters = Lists.newArrayList();\n    private Object[] basePackages;\n    \n    public DispatcherServlet(Object... basePackages) {\n        this.basePackages = basePackages;\n    }\n    \n    @Override\n    public void init() throws ServletException {\n        AnnotationHandlerMapping ahm = new AnnotationHandlerMapping(basePackages);\n        ahm.initialize();\n        mappings.add(ahm);\n        handlerAdapters.add(new HandlerExecutionHandlerAdapter());\n    }\n    ...\n\n}\n```\n\n- `init()` 메소드에서 `AnnotationHandlerMapping` 과 직접적인 의존관계를 가지는 것을 확인할 수 있다. 이또한 DI를 통해 의존관계를 느슨하게 가지도록 변경해 확장 가능하도록 개선할 수 있다.\n  - 생성자에 `HandlerMapping` 을 인자로 전달할 수 있도록 리팩토링한다.\n\n```java\npublic class DispatcherServlet extends HttpServlet {\n    ...\n\n    private HandlerMapping hm;\n\n    public DispatcherServlet(HandlerMapping hm) {\n        this.hm = hm;\n    }\n\n    @Override\n    public void init() throws ServletException {\n        mappings.add(hm);\n        handlerAdapters.add(new HandlerExecutionHandlerAdapter());\n    }\n    ...\n\n}\n```\n\n- `DispatcherServlet` 이 어느 `HandlerMapping` 구현체와 의존관계를 가질 것인지는 `DispatcherServlet` 를 생성하는 `MyApplicationInitializer` 가 결정한다.\n\n```java\npublic class MyWebApplicationInitializer implements WebApplicationInitializer {\n    private static final Logger log = LoggerFactory.getLogger(MyWebApplicationInitializer.class);\n\n    @Override\n    public void onStartup(ServletContext servletContext) throws ServletException {\n        AnnotationHandlerMapping ahm = new AnnotationHandlerMapping(\"next\");\n        ahm.initialize();\n        ServletRegistration.Dynamic dispatcher = servletContext.addServlet(\"dispatcher\", new DispatcherServlet(ahm));\n        ...\n\n    }\n}\n```\n\n### 🔧 @Component annotation 지원\n**두번째 이슈**<br/>\n: `ClasspathBeanDefinition` 클래스에 `@Component` annotation 설정만 추가하면 해결이 가능하다. \n\n```java\n@Target({ElementType.TYPE})\n@Retention(RetentionPolicy.RUNTIME)\npublic @interface Component {\n    String value() default \"\";\n}\n```\n\n이제 추가한 annotation을 `ClasspathBeanDefinitionScanner` 의 `doScan()` 메소드로 찾을 수 있도록 추가한다.\n\n```java\npublic class ClasspathBeanDefinitionScanner {\n    public void doScan(Object... basePackages) {\n        Reflections reflections = new Reflections(basePackages);\n        Set<Class<?>> beanClasses = getTypesAnnotatedWith(reflections, Controller.class, Service.class, Repository.class, Component.class);\n        for (Class<?> clazz : beanClasses) {\n            beanDefinitionRegistry.registerBeanDefinition(clazz, new BeanDefinition(clazz));\n        }\n    }\n}\n```\n\n이제 추가한 annotation을 활용해 `JdbcTemplate` 을 빈으로 등록 가능하도록 설정 후 각 DAO에서 `JdbcTemplate` 을 DI로 사용하도록 리팩토링한다.\n\n```java\n@Component\npublic class JdbcTemplate {\n    ...\n\n}\n\n@Repository\npublic class JdbcQuestionDao implements QuestionDao {\n    private JdbcTemplate jdbcTemplate;\n    \n    @Inject\n    public JdbcQuestionDao(JdbcTemplate jdbcTemplate) {\n        this.jdbcTemplate = jdbcTemplate;\n    }\n    ...\n\n}\n\n@Repository\npublic class JdbcAnswerDao implements AnswerDao {\n    private JdbcTemplate jdbcTemplate;\n\n    @Inject\n    public JdbcAnswerDao(JdbcTemplate jdbcTemplate) {\n        this.jdbcTemplate = jdbcTemplate;\n    }\n    ...\n\n}\n```\n\n서버를 시작하면 `JdbcTemplate` 이 `\"next\"` 패키지가 아닌 `\"core\"` 패키지 아래에 있어 인식하지 못해 에러가 발생한다.\n- `MyWebApplicationInitializer` 에서 이를 인식하도록 `AnnotationHandlerMapping` 에 `\"core\"` 를 추가해 전달한다.\n\n```java\npublic class MyWebApplicationInitializer implements WebApplicationInitializer {\n    private static final Logger log = LoggerFactory.getLogger(MyWebApplicationInitializer.class);\n\n    @Override\n    public void onStartup(ServletContext servletContext) throws ServletException {\n        AnnotationHandlerMapping ahm = new AnnotationHandlerMapping(\"core\", \"next\");\n        ...\n\n    }\n}\n```\n\n---\n\n## 🚩 외부 라이브러리 클래스를 빈으로 등록하기\n### 🔧 요구사항\n가장 좋은 방법은 개발자가 직접 빈을 생성해 관리할 수 있는 별도의 설정 파일을 만드는 것이다.\n- 예를 들어, 설정 파일에 빈 인스턴스를 생성하는 메소드를 구현해놓고, annotation으로 설정한다.\n- DI 프레임워크는 이 설정 파일을 읽어 `BeanFactory` 에 빈으로 저장할 수 있다면 `ClasspathBeanDefinitionScanner` 를 통해 등록한 빈과 같은 저장소에서 관리할 수 있다.\n\nannotation을 이용해 모든 설정을 관리하고 기본 패키지 설정 또한 생성하는 설정 파일에서 관리하도록 리팩토링한다.\n\n```java\n@Configuration\n@ComponentScan({\"next\", \"core\"})\npublic class MyConfiguration {\n    @Bean\n    public DataSource dataSource() {\n        BasicDataSource ds = new BasicDataSource();\n        ds.setDriverClassName(\"org.h2.Driver\");\n        ds.setUrl(\"jdbc:h2:~/jwp-basic;AUTO_SERVER=TRUE\");\n        ds.setUsername(\"sa\");\n        ds.setPassword(\"\");\n        return ds;\n    }\n\n    @Bean\n    public JdbcTemplate jdbcTemplate(DataSource dataSource) {\n        return new JdbcTemplate(dataSource);\n    }\n}\n```\n\n- 자바 클래스가 \"설정 파일\"이라는 표시는 `@Configuration` annotation을 생성해 사용한다.\n- 각 메소드에서 생성하는 인스턴스가 `BeanFactory` 에 빈으로 등록하라는 설정은 `Bean` annotation을 생성해 사용한다.\n- `ClasspathBeanDefinitionScanner` 에서 사용할 기본 패키지에 대한 설정을 하드 코딩했는데 이를 설정 파일에서 `@ComponentScan` annotation을 사용해 설정하도록 지원한다.\n- `@Configuration` 설정 파일을 통해 등록한 빈과 `ClasspathBeanDefinitionScanner` 를 통해 등록한 빈 간의 DI가 가능해야 한다.\n\n### 🔧 1단계 힌트\n바로 구현을 시작하기보다 요구사항을 테스트할 수 있는 단위 테스트를 먼저 구현한다. \n- 먼저 설정 파일에서 사용할 annotation을 추가한다.\n  - `ComponentScan` 은 배열을 값으로 전달할 수 있도록 `String[]` 필드를 가진다.\n\n```java\n@Target({ElementType.TYPE})\n@Retention(RetentionPolicy.RUNTIME)\npublic @interface ComponentScan {\n    String[] value() default {};\n    String[] basePackages() default {};\n}\n\n@Target({ElementType.TYPE})\n@Retention(RetentionPolicy.RUNTIME)\npublic @interface Configuration {\n}\n\n@Target({ElementType.METHOD})\n@Retention(RetentionPolicy.RUNTIME)\npublic @interface Bean {\n}\n```\n\n이 문제를 해결하려면 `@Configuration` 설정 파일을 읽어 `BeanFactory` 에 `BeanDefinition` 을 등록하는 역할을 수행할 클래스가 필요하다. (`AnnotatedBeanDefinitionReader`)\n- `@Configuration` 설정된 클래스에서 `@Bean` 설정된 메소드를 찾는다.\n- `BeanFactory` 에 등록할 빈은 **`@Bean` 메소드의 반환 값에 해당하는 클래스**이다.\n- 메소드의 반환 클래스에 해당하는 `BeanDefinition` 을 생성한 후 `BeanFactory` 에 등록한다.\n\n> 이때 고려해야 하는 점은 빈 인스턴스 생성을 위해 **`@Bean` 설정된 메소드(리플렉션의 `Method`)의 정보가 필요**하다는 것이다. 따라서, 기존의 `BeanDefinition` 을 상속하는 `AnnotatedBeanDefinition` 을 추가한 후 메소드 정보까지 전달한다. \n\n이후 가장 중요한 `BeanFactory` 의 `getBean()` 메소드를 구현한다.\n- 인자로 전달되는 빈 클래스에 해당하는 `BeanDefinition` 이 `AnnotatedBeanDefinition` 인스턴스일 경우 기존과 다른 방식으로 빈 인스턴스를 생성한다.\n\n마지막으로, `ApplicationContext` 가 `ClasspathBeanDefinitionScanner` 에서 사용할 기본 패키지 정보를 받는 것이 아닌 `@Configuration` 설정된 설정 파일을 인자로 받도록 수정한 후 `@ComponentScan` 값을 구해 패키지 정보를 전달하고, `AnnotatedBeanDefinitionReader` 를 통해 설정 파일에 등록된 `@Bean` 을 `BeanFactory` 에 등록하도록 한다.\n\n### 🔧 2단계 힌트\n**단위 테스트 코드 만들기**<br/>\n먼저 테스트용 설정 파일을 추가한다. (`src/test/java`)\n\n```java\n@Configuration\npublic class ExampleConfig {\n    @Bean\n    public DataSource dataSource() {\n        BasicDataSource ds = new BasicDataSource();\n        ds.setDriverClassName(\"org.h2.Driver\");\n        ds.setUrl(\"jdbc:h2:~/jwp-basic;AUTO_SERVER=TRUE\");\n        ds.setUsername(\"sa\");\n        ds.setPassword(\"\");\n        return ds;\n    }\n}\n```\n\n- 해당 설정 파일을 읽어 `BeanFactory` 에 등록한 후 `getBean()` 을 통해 빈을 찾았을 때 `null` 여부를 판단하는 테스트를 추가한다.\n\n## 📕 출처\n- **자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성\n- [java - Maven을 사용하는 JAR의 \"META-INF/services\"폴더에 설정 파일을 포함시키는 방법](https://code-examples.net/ko/q/10b82e9)"},{"excerpt":"문제 강호는 코딩 교육을 하는 스타트업 스타트링크에 지원했다. 오늘은 강호의 면접날이다. 하지만, 늦잠을 잔 강호는 스타트링크가 있는 건물에 늦게 도착하고 말았다. 스타트링크는 총 F층으로 이루어진 고층 건물에 사무실이 있고, 스타트링크가 있는 곳의 위치는 G층이다. 강호가 지금 있는 곳은 S층이고, 이제 엘리베이터를 타고 G층으로 이동하려고 한다. 보통…","fields":{"slug":"/[BOJ]5014/"},"frontmatter":{"date":"February 21, 2022","title":"👩‍💻 5014. 스타트 링크","tags":["그래프이론","그래프탐색","BFS"]},"rawMarkdownBody":"\n## 문제\n\n강호는 코딩 교육을 하는 스타트업 스타트링크에 지원했다. 오늘은 강호의 면접날이다. 하지만, 늦잠을 잔 강호는 스타트링크가 있는 건물에 늦게 도착하고 말았다.\n\n스타트링크는 총 F층으로 이루어진 고층 건물에 사무실이 있고, 스타트링크가 있는 곳의 위치는 G층이다. 강호가 지금 있는 곳은 S층이고, 이제 엘리베이터를 타고 G층으로 이동하려고 한다.\n\n보통 엘리베이터에는 어떤 층으로 이동할 수 있는 버튼이 있지만, 강호가 탄 엘리베이터는 버튼이 2개밖에 없다. U버튼은 위로 U층을 가는 버튼, D버튼은 아래로 D층을 가는 버튼이다. (만약, U층 위, 또는 D층 아래에 해당하는 층이 없을 때는, 엘리베이터는 움직이지 않는다)\n\n강호가 G층에 도착하려면, 버튼을 적어도 몇 번 눌러야 하는지 구하는 프로그램을 작성하시오. 만약, 엘리베이터를 이용해서 G층에 갈 수 없다면, \"use the stairs\"를 출력한다.\n\n### 입력\n- 첫째 줄에 F, S, G, U, D가 주어진다. (1 ≤ S, G ≤ F ≤ 1000000, 0 ≤ U, D ≤ 1000000) 건물은 1층부터 시작하고, 가장 높은 층은 F층이다.\n\n### 출력\n- 첫째 줄에 강호가 S층에서 G층으로 가기 위해 눌러야 하는 버튼의 수의 최솟값을 출력한다. 만약, 엘리베이터로 이동할 수 없을 때는 \"use the stairs\"를 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Pair {\n    int floor;\n    int cnt;\n\n    public Pair(int floor, int cnt) {\n        this.floor = floor;\n        this.cnt = cnt;\n    }\n}\n```\n- 층 정보와 버튼 누른 횟수를 저장하기 위해 `Pair` **class**를 생성했다.\n\n```java\nQueue<Pair> q = new LinkedList<>();\nq.add(new Pair(S, 0));\nvisited[S] = true;\n\nwhile(!q.isEmpty()) {\n    Pair now = q.poll();\n    int now_floor = now.floor;\n    int now_cnt = now.cnt;\n\n    if (now_floor == G) {\n        System.out.println(now_cnt);\n        return;\n    }\n\n    for (int go : upDown) {\n        int nxFloor = now_floor + go;\n        if (nxFloor <= 0 || nxFloor > F) continue;\n        if (visited[nxFloor]) continue;\n\n        q.add(new Pair(nxFloor, now_cnt + 1));\n        visited[nxFloor] = true;\n    }\n}\n```\n- 현재 층에서 목표 층까지 가기 위해 **BFS**로 이동 가능한 층과 버튼 누른 횟수를 `Queue` 에 저장한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\" data-language=\"java\">\n\n        import java.io.BufferedReader;\n        import java.io.IOException;\n        import java.io.InputStreamReader;\n        import java.util.LinkedList;\n        import java.util.Queue;\n\n        class Pair {\n            int floor;\n            int cnt;\n\n            public Pair(int floor, int cnt) {\n                this.floor = floor;\n                this.cnt = cnt;\n            }\n        }\n\n        public class Main {\n            public static void main(String[] args) throws IOException {\n                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n                String[] line = br.readLine().split(\" \");\n                int F = Integer.parseInt(line[0]), S = Integer.parseInt(line[1]), G = Integer.parseInt(line[2]);\n                int[] upDown = {Integer.parseInt(line[3]), -Integer.parseInt(line[4])};\n                boolean[] visited = new boolean[F + 1];\n\n                Queue<Pair> q = new LinkedList<>();\n                q.add(new Pair(S, 0));\n                visited[S] = true;\n\n                while(!q.isEmpty()) {\n                    Pair now = q.poll();\n                    int now_floor = now.floor;\n                    int now_cnt = now.cnt;\n\n                    if (now_floor == G) {\n                        System.out.println(now_cnt);\n                        return;\n                    }\n\n                    for (int go : upDown) {\n                        int nxFloor = now_floor + go;\n                        if (nxFloor <= 0 || nxFloor > F) continue;\n                        if (visited[nxFloor]) continue;\n\n                        q.add(new Pair(nxFloor, now_cnt + 1));\n                        visited[nxFloor] = true;\n                    }\n                }\n\n                System.out.println(\"use the stairs\");\n\n                br.close();\n            }\n        }\n  </div>\n</details>\n\n### ✏️ **Review**\n- BFS 문제라는 것을 알고 풀어서 아이디어는 금방 잡았던 문제이다. 알고리즘 분류를 안 보고 아이디어를 생각해내는 연습이 필요할 것 같다.\n- 저번과 동일하게 방문 여부를 저장하는 부분에서의 **메모리 초과**를 피할 수 없었다. 좀 더 자세하게 생각해보는 연습이 필요할 것 같다.\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/5014"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 🚩 왜 DI가 필요한가? 먼저 의존관계(dependency)에 대해 생각해보자. 객체에게 의존관계란 무엇이고 어떤 경우에 의존관계가 발생할까? 의존관계\n: 객체 혼자 모든 일을 처리하기 힘들기에 작업을 다른 객체에게 위임하면서 발생한다. 즉, 내가 가진 책임과 역할을…","fields":{"slug":"/[NextStep]11/"},"frontmatter":{"date":"February 21, 2022","title":"📖 11장 의존관계 주입(DI)을 통한 테스트하기 쉬운 코드 만들기","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n## 🚩 왜 DI가 필요한가?\n먼저 의존관계(dependency)에 대해 생각해보자. 객체에게 의존관계란 무엇이고 어떤 경우에 의존관계가 발생할까?\n\n**의존관계**<br/>\n: 객체 혼자 모든 일을 처리하기 힘들기에 작업을 다른 객체에게 위임하면서 발생한다.\n- 즉, **내가 가진 책임과 역할을 다른 객체에게 위임하는 순간 발생**하는 것이다.\n- 예를 들어, `QnaService` 는 질문 삭제 기능 구현을 위해 `QuestionDao` , `AnswerDao` 에게 DB 접근 로직을 위임하고 있다.\n  - 이는 `QnaService` 가 `QuestionDao` 와 `AnswerDao` 에 의존하고 있다는 의미이다.\n\n**DI**는 \"객체 간 의존관계를 어떻게 해결하느냐\"에 따른 새로운 접근 방식이다. \n- 이전까지는 의존관계에 있는 객체를 사용하기 위해 객체를 직접 생성하고, 사용하는 방식으로 구현했다. (`QnaService` 또한 `QuestionDao` 와 `AnswerDao` 사용을 위해 생성하고 사용했다.)\n\n하지만 이같은 방식으로 구현 시 유연한 개발에 한계가 있기에 **인스턴스를 생성하는 책임**과 **사용하는 책임**을 분리하자는 것이 **DI의 핵심**이다.\n- 즉 위 예에서 `QnaService` 는 `QuestionDao` 와 `AnswerDao` 에 대한 생성 없이 사용만 함으로써 유연성을 높이자는 방식이다.\n\n그럼 지금까지의 구현 방식의 문제점을 간단한 예제로 살펴보도록 한다.\n\n```java\npublic class DateMessageProvider {\n    public String getDateMessage() {\n        Calendar now = Calendar.getInstance();\n        int hour = now.get(Calendar.HOUR_OF_DAY);\n\n        if (hour < 12) {\n            return \"오전\";\n        }\n        return \"오후\";\n    }\n}\n```\n\n- 현재 시스템 시간에 따라 오전 또는 오후를 반환하는 클래스이다. 이 클래스의 `getDateMessage()` 에 대한 테스트 클래스는 다음과 같이 구현할 수 있다.\n\n```java\npublic class DateMessageProviderTest {\n    @Test\n    public void 오전() throws Exception {\n        DateMessageProvider provider = new DateMessageProvider();\n        assertEquals(\"오전\", provider.getDateMessage());\n    }\n\n    @Test\n    public void 오후() throws Exception {\n        DateMessageProvider provider = new DateMessageProvider();\n        assertEquals(\"오후\", provider.getDateMessage());\n    }\n}\n```\n\n- 위 테스트를 실행하면, 반드시 하나의 테스트는 실패한다. 요구사항은 이 두 테스트가 모두 성공하도록 리팩토링하는 것이다.\n  - 이를 위해서는 먼저 테스트가 모두 성공하지 못하는 원인을 알아야 할 것이다.\n\n원인은, `DateMessageProvider` 가 `Calendar` 와 의존관계를 가지는데 테스트를 위해 `Calendar` 의 시간을 변경할 수 있는 방법이 없다.\n- **소스코드를 컴파일하는 시점에 `Calendar` 인스턴스가 이미 결정**되어 버리기 때문이다.\n  - 이같은 의존관계를 강하게 결합(**tightly coupling**)되어 있다고 한다.\n- 모든 테스트의 성공을 위해서는 **`Calendar` 에서 반환되는 시간을 변경할 수 있도록 `DateMessageProvider` 를 리팩토링**해야 한다.\n  - 즉, `getDateMessage()` 가 아닌 `DateMessageProvider` 외부에서 `Calendar` 인스턴스 생성 후 전달하는 구조로 바꿔야 한다.\n    - 생성자를 통해 전달하거나, `getDateMessage()` 메소드 인자로 전달할 수 있다. (두번째 방법 사용)\n\n```java\npublic class DateMessageProvider {\n    public String getDateMessage(Calendar now) {\n        int hour = now.get(Calendar.HOUR_OF_DAY);\n\n        if (hour < 12) {\n            return \"오전\";\n        }\n        return \"오후\";\n    }\n}\n```\n\n```java\npublic class DateMessageProviderTest {\n    @Test\n    public void 오전() throws Exception {\n        DateMessageProvider provider = new DateMessageProvider();\n        assertEquals(\"오전\", provider.getDateMessage(createCurrentDate(11)));\n    }\n\n    @Test\n    public void 오후() throws Exception {\n        DateMessageProvider provider = new DateMessageProvider();\n        assertEquals(\"오후\", provider.getDateMessage(createCurrentDate(13)));\n    }\n\n    public Calendar createCurrentDate(int hourOfDay) {\n        Calendar now = Calendar.getInstance();\n        now.set(Calendar.HOUR_OF_DAY, hourOfDay);\n        return now;\n    }\n}\n```\n\n이제 모든 테스트가 성공이다.\n- `DateMessageProvider` 가 의존하고 있는 `Calendar` 인스턴스의 생성을 `DateMessageProvider` 가 결정하지 않고, 외부로부터 전달받음으로써 원하는 시간으로 변경해 모든 테스트를 성공할 수 있었다.\n- 이처럼 DI는 **객체 간의 의존관계에 대한 결정권**을, 의존관계를 가지는 객체(`DateMessageProvider`)가 가지는 것이 아닌 **외부의 누군가가 담당**하도록 맡겨 더 유연한 구조로 개발한다.\n\n---\n\n## 🚩 DI를 적용하면서 쌓이는 불편함 또는 불만\n질문/답변 게시판의 `QnaService` 를 DI기반으로 변경하면서 기존의 방식과 어떻게 다르고, 어떤 불편함이 있는지 살펴본다. \n\n```java\npublic class QnaService {\n    private static QnaService qnaService;\n\n    private QuestionDao questionDao = QuestionDao.getInstance();\n    private AnswerDao answerDao = AnswerDao.getInstance();\n\n    private QnaService() {\n    }\n\n    public static QnaService getInstance() {\n        if (qnaService == null) {\n            qnaService = new QnaService();\n        }\n        return qnaService;\n    }\n    ...\n\n}\n```\n\n- 보이는 것과 같이 `QuestionDao` 와 `AnswerDao` 에 의존관계를 가진다. 이를 DI구조로 변경해본다.\n\n```java\npublic class QnaService {\n    private static QnaService qnaService;\n\n    private QuestionDao questionDao;\n    private AnswerDao answerDao;\n\n    private QnaService(QuestionDao questionDao, AnswerDao answerDao) {\n        this.questionDao = questionDao;\n        this.answerDao = answerDao;\n    }\n\n    public static QnaService getInstance(QuestionDao questionDao, AnswerDao answerDao) {\n        if (qnaService == null) {\n            qnaService = new QnaService(questionDao, answerDao);\n        }\n        return qnaService;\n    }\n    ...\n\n}\n```\n\n- 앞에서 다룬 `DateMessageProvider` 예제에서는 `getDateMessage()` 에서만 발생하는 의존관계를 해결하기 위해 메소드 인자로 전달했다.\n- `QnaService` 의 `QuestionDao` , `AnswerDao` 는 `QnaService` 메소드 전체에서 사용되기에 생성자를 통해 필드로 관리하도록 변경했다.\n  - `getInstance()` 메소드를 변경했기에 이를 사용하는 다른 컨트롤러에서 에러가 발생한다. 이를 `private QnaService qnaService = QnaService.getInstance(QuestionDao.getInstance(), AnswerDao.getInstance());` 와 같이 고쳐준다.\n\n이제 테스트를 수행할텐데, `QuestionDao` 와 `AnswerDao` 가 DB와의 의존관계를 가지기에 이를 가지지 않도록 변경할 수 있어야 DB에 의존하지 않는 테스트가 가능하다.\n- `QuestionDao` 와 `AnswerDao` 를 상속해 메소드를 오버라이딩하여 해결한다.\n  - 먼저 `MockQuestionDao` 클래스를 추가하고 `QuestionDao` 를 상속한다.\n  - 이때, `QuestionDao` 의 기본 생성자가 **싱글톤 패턴의 적용**을 위해 `private` 으로 구현하여 상속할 수 없다.\n\n또 다른 방법으로, 객체 간의 의존관계에 대한 강한 결합(tightly coupling)을 줄이기 위해 DI를 적용하면서 **인터페이스를 사용**한다.\n- `QuestionDao` → `JdbcQuestionDao` renaming\n- `AnswerDao` → `JdbcAnswerDao` renaming\n- 인터페이스 이름을 `QuestionDao` , `AnswerDao` 로 사용\n- `JdbcQuestionDao` , `JdbcAnswerDao` 에 의존하고 있던 `QnaService` 코드를 새로 추가한 인터페이스 각각에 의존하도록 변경\n- `MockQuestionDao` , `MockAnswerDao` 를 구현\n\n```java\npublic class MockAnswerDao implements AnswerDao {\n    private Map<Long, Answer> answers = Maps.newHashMap();\n\n    @Override\n    public Answer insert(Answer answer) {\n        return answers.put(answer.getAnswerId(), answer);\n    }\n\n    @Override\n    public Answer findById(long answerId) {\n        return answers.get(answerId);\n    }\n\n    @Override\n    public List<Answer> findAllByQuestionId(long questionId) {\n        return answers.values().stream()\n                .filter(a -> a.getQuestionId() == questionId)\n                .collect(Collectors.toList());\n    }\n\n    @Override\n    public void delete(Long answerId) {\n        answers.remove(answerId);\n    }\n}\n```\n\n- `MockQuestionDao` 또한 위와 동일하게 간단한 메모리 DB 역할을 하도록 구현했다.\n- 이제 테스트 코드를 추가한다.\n\n```java\npublic class QnaServiceTest {\n    private QnaService qnaService;\n    private MockQuestionDao questionDao;\n    private MockAnswerDao answerDao;\n\n    @Before\n    public void setup() {\n        questionDao = new MockQuestionDao();\n        answerDao = new MockAnswerDao();\n        qnaService = QnaService.getInstance(questionDao, answerDao);\n    }\n\n    @Test(expected = CannotDeleteException.class)\n    public void deleteQuestion_없는_질문() throws Exception {\n        qnaService.deleteQuestion(1L, newUser(\"userId\"));\n    }\n\n    @Test(expected = CannotDeleteException.class)\n    public void deleteQuestion_다른_사용자() throws Exception {\n        Question question = newQuestion(1L, \"javajigi\");\n        questionDao.insert(question);\n        qnaService.deleteQuestion(1L, newUser(\"userId\"));\n    }\n\n    @Test\n    public void deleteQuestion_같은_사용자_답변없음() throws Exception {\n        Question question = newQuestion(1L, \"javajigi\");\n        questionDao.insert(question);\n        qnaService.deleteQuestion(1L, newUser(\"javajigi\"));\n    }\n}\n```\n\n- `newUser` 와 `newQuestion` 메소드는 `model` 의 각 클래스 테스트 코드에 구현한다.\n- 위 테스트에서 `deleteQuestion_같은_사용자_답변없음()` 만 \"존재하지 않는 질문입니다.\" 라는 에러가 발생하는 것을 확인할 수 있다. 분명 질문을 추가했는데도 이러한 에러가 뜬다.\n  - 이는 **`QnaService` 가 싱글톤 인스턴스**이기에 발생하는 에러이다.\n  - 즉, `QnaService` 가 참조하는 `QuestionDao` (처음 인스턴스 생성 시 해당 인스턴스)와 테스트 메소드에서 생성한 인스턴스가 다르다는 것이다.\n  - 이는 테스트 데이터를 초기화하는 작업을 `setup()` 메소드에서만 하도록 변경해 해결할 수 있다.\n\n---\n\n## 🚩 불만 해소하기\n- 싱글톤 패턴을 사용함으로 인해 테스트에 어려움이 있었다. 어떤 형태로든 테스트할 수 있지만 고려해야 할 부분이 많아진다는 것은 반갑지 않다. \n- 테스트를 위해 매번 `Mock` 객체를 만드는 것은 많은 비용이 드는 작업이다.\n\n### 🔧 싱글톤 패턴을 제거한 DI\n이 디자인 패턴은 이해하기도 가장 쉽기에 널리 사용되었다. 하지만 그에 따른 단점도 많다. \n- 싱글톤 패턴으로 구현된 클래스와 의존관계를 가지는 경우 해당 클래스와 강한 의존관계를 가지기 때문에 테스트하기 어렵고,\n- 생성자를 `private` 로 구현해 상속할 수 없다.\n- 또한 객체지향 설계 원칙에 따라 개발하는 것을 저해하는 요인이 된다.\n\n> 싱글톤 패턴을 사용하지 않으면서 인스턴스 하나만 유지하는 방법이 있을까?\n\n- 지금까지 인스턴스 하나만 생성하기 위해 `Service` , `DAO` , `JdbcTemplate` 은 싱글톤 패턴을 적용했다.\n- 하지만 **컨트롤러**는 이를 적용하지 않고도 같은 효과를 낼 수 있었다.\n  - 서블릿 컨테이너가 `DispatcherServlet` 을 초기화하는 시점에 컨트롤러 인스턴스를 생성한 후 재사용 가능하도록 구현했기 때문이다.\n  - 그렇다면, 이 방식으로 다른 클래스도 인스턴스를 관리한다면 문제를 해결할 수 있지 않을까? 그리고 각 인스턴스 간 의존관계는 DI 기반으로 구현한다.\n\n먼저 `QnaService` 의 `QuestionDao` 와 `AnswerDao` 를 이 방법으로 구현하고 테스트를 진행한다.\n- 싱글톤 패턴 코드를 제거하고 생성자를 `public` 으로 변경한다.\n\n```java\npublic class QnaService {\n    private QuestionDao questionDao;\n    private AnswerDao answerDao;\n\n    public QnaService(QuestionDao questionDao, AnswerDao answerDao) {\n        this.questionDao = questionDao;\n        this.answerDao = answerDao;\n    }\n    ...\n\n}\n```\n\n- 위와 같이 수정 후 `getInstance()` 메소드를 제거하고 테스트를 진행하면 정상적으로 동작한다. 이제 `QnaService` 와 의존관계를 가지는 다른 컨트롤러들을 수정한다.\n\n```java\npublic class DeleteQuestionController extends AbstractController {\n    private QnaService qnaService;\n    \n    public DeleteQuestionController(QnaService qnaService) {\n        this.qnaService = qnaService;\n    }\n    ...\n\n}\n```\n\n- 위처럼, `public` 생성자를 만들어 인자로 받은 `QnaService` 인스턴스를 사용하도록 수정한다.\n- 이제 이 컨트롤러들을 생성할 때 `QnaService` 를 DI로 전달해준다.\n\n```java\npublic class LegacyHandlerMapping implements HandlerMapping {\n    private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);\n    private Map<String, Controller> mappings = new HashMap<>();\n\n    public void initMapping() {\n        QnaService qnaService = new QnaService(JdbcQuestionDao.getInstance(), JdbcAnswerDao.getInstance());\n        ...\n\n        mappings.put(\"/qna/delete\", new DeleteQuestionController(qnaService));\n        mappings.put(\"/api/qna/deleteQuestion\", new ApiDeleteQuestionController(qnaService));\n        ...\n\n        logger.info(\"Initialized Request Mapping!\");\n    }\n    ...\n\n}\n```\n\n- 다시 보니, `JdbcQuestionDao` , `JdbcAnswerDao` 는 아직 싱글톤 패턴을 사용하고 있다. 이들도 싱글톤 패턴을 적용하지 않도록 수정한다. 그리고 연이어 발생하는 컨트롤러에서의 컴파일 에러도 모두 수정한다.\n  - `getInstance()` 메소드를 사용하는 코드를 모두 제거하고, `public` 생성자의 인자로 필요한 인스턴스를 받아 사용하도록 수정하고, 매핑 초기화 시 필요한 인스턴스를 모두 전달해주도록 한다.\n\n### 🔧 Mockito를 활용한 테스트\nDB가 없는 상태에서도 테스트가 가능하도록 `QuestionDao` 와 `AnswerDao` 에 대한 가짜(`Mock`) 클래스를 구현했다. 하지만 이런 방식은 테스트 코드 구현도 부담인데 매번 새로운 가짜 클래스를 만들어야 하는 부담이 추가되는 격이다. \n- 이를 위해 `Mock` 클래스 구현 없이도 테스트가 가능하도록 지원하는 `Mock` 테스트 프레임워크를 활용한다.\n\n먼저 메이븐 설정 파일에 의존관계를 추가한다.\n```xml\n<dependency>\n    <groupId>org.mockito</groupId>\n    <artifactId>mockito-core</artifactId>\n    <version>1.10.19</version>\n    <scope>test</scope>\n</dependency>\n```\n\n이제 이를 활용해 `QnaService` 의 `deleteQuestion()` 메소드에 대한 테스트 코드를 수정한다.\n\n```java\n@RunWith(MockitoJUnitRunner.class)\npublic class QnaServiceTest {\n    @Mock\n    private QuestionDao questionDao;\n    @Mock\n    private AnswerDao answerDao;\n\n    private QnaService qnaService;\n\n    @Before\n    public void setup() {\n        qnaService = new QnaService(questionDao, answerDao);\n    }\n\n    @Test(expected = CannotDeleteException.class)\n    public void deleteQuestion_없는_질문() throws Exception {\n        when(questionDao.findById(1L)).thenReturn(null);\n        qnaService.deleteQuestion(1L, newUser(\"userId\"));\n    }\n    ...\n\n    @Test\n    public void deleteQuestion_같은_사용자_답변없음() throws Exception {\n        Question question = newQuestion(1L, \"javajigi\");\n        when(questionDao.findById(1L)).thenReturn(question);\n        when(answerDao.findAllByQuestionId(1L)).thenReturn(Lists.newArrayList());\n        qnaService.deleteQuestion(1L, newUser(\"javajigi\"));\n    }\n}\n```\n\n- `Mock` 클래스 없이 테스트를 성공적으로 완료했다.\n  - **Mockito**는 `Mock` 클래스 대신 `@Mock` annotation으로 설정한 클래스의 메소드를 호출했을 때, 반환 값을 지정할 수 있다.\n  - 또한 해당 annotation을 설정한 클래스의 메소드가 호출되는지 여부를 `verify()` 메소드를 통해 검증하는 작업 또한 가능하다.\n  - 이처럼 다른 클래스와 의존관계를 가지는 클래스를 테스트하는 경우 `Mock` 프레임워크의 사용을 추천한다.\n\n### 🔧 DI보다 우선하는 객체지향 개발\n\"계층형 아키텍처 관점과 객체지향 설계 관점에서 핵심적인 비즈니스 로직을 구현해야 하는 역할은 누가 담당해야할까?\"\n- 먼저 앞에서 구현한 `DateMessageProvider` 코드를 다시 보면서 답에 대해 생각해본다.\n- 이 코드를 위한 테스트 코드는 다음과 같다. \n\n```java\npublic class DateMessageProviderTest {\n    @Test\n    public void 오전() throws Exception {\n        DateMessageProvider provider = new DateMessageProvider();\n        assertEquals(\"오전\", provider.getDateMessage(createCurrentDate(11)));\n    }\n\n    @Test\n    public void 오후() throws Exception {\n        DateMessageProvider provider = new DateMessageProvider();\n        assertEquals(\"오후\", provider.getDateMessage(createCurrentDate(13)));\n    }\n\n    public Calendar createCurrentDate(int hourOfDay) {\n        Calendar now = Calendar.getInstance();\n        now.set(Calendar.HOUR_OF_DAY, hourOfDay);\n        return now;\n    }\n}\n```\n\n- 이처럼 간단한 로직을 구현하는데 좀 더 간단히 테스트할 수 있는 방법은 없을까에 대해 생각해볼 수 있다.\n  - `DateMessageProvider` 의 구조를 개선해 테스트를 더 쉽게 할 수 없을까?\n  - 좀 더 객체지향적인 개발을 수행한다면 해결책을 얻을 수 있을 것이다.\n\n먼저 시간을 추상화하는 `Hour` 클래스를 추가한다.\n\n```java\npublic class Hour {\n    private int hour;\n\n    public Hour(int hour) {\n        this.hour = hour;\n    }\n\n    public String getMessage() {\n        if (hour < 12) {\n            return \"오전\";\n        }\n        return \"오후\";\n    }\n\n    @Override\n    public boolean equals(Object obj) {\n        if (this == obj) {\n            return true;\n        }\n        return false;\n\n        if (getClass() != obj.getClass()) {\n            return false;\n        }\n        Hour other = (Hour) obj;\n        if (hour != obj.hour) {\n            return false;\n        }\n        return true;\n    }\n}\n```\n\n- `Hour` 클래스가 `DateMessageProvider` 가 구현하던 로직을 담당하게 되었다. 테스트 코드는 다음과 같다.\n\n```java\npublic class MyCalendarTest {\n    @Test\n    public void getHour() throws Exception {\n        Calendar now = Calendar.getInstance();\n        now.set(Calendar.HOUR_OF_DAY, 11);\n        MyCalendar calendar = new MyCalendar(now);\n        assertEquals(new Hour(11), calendar.getHour());\n    }\n}\n```\n\n위에서 말한 질문에 대한 답변으로, 대부분 Service layer를 담당하고 있는 `QnaService` 에서 처리해야 한다고 생각한다. 하지만 **핵심적인 비즈니스 로직 구현은 Domain 객체가 담당**하는 것이 맞다.\n- **Service layer**의 핵심 역할은 Domain 객체들이 비즈니스 로직을 구현할 수 있도록 Domain 객체를 조합하거나, 로직 처리 완료 시 상태 값을 DAO를 활용해 DB에 영구 저장하는 등이다.\n\n대부분의 개발자들은 `QnaService` 의 `deleteQuestion()` 메소드와 같이 구현하는 경우가 많다. 이는 대표적인 **절차지향적 개발**이다. \n- 이와 같은 개발은 **Service layer의 복잡도는 점점 더 증가**하고\n- **유지보수와 테스트하기 힘든 상황**을 맞닥뜨리게 된다.\n- 또한 핵심 객체라 할 수 있는 Domain 객체는 사용자가 입력한 데이터를 DAO에 전달하거나 DB 데이터를 뷰에 전달하는 역할만을 수행하게 된다. (핵심적인 역할 수행 X)\n  - 그리하여 Domain 객체가 값을 전달하는 `Getter` & `Setter` 메소드만을 가지는 상황이 발생한다.\n\n이제부터는 Domain 객체에 더 많은 역할을 부여하는 방향으로 구현하도록 한다.\n- `QnaService` 의 `deleteQuestion()` 메소드가 구현하고 있는 로직을 Domain 객체, 즉 `Question` & `Answer` 가 담당하도록 한다.\n- 먼저, 삭제 가능 여부를 `Question` 에 메세지를 보내(`canDelete()`) 확인하는 방식으로 리팩토링한다.\n\n```java\npublic class Question {\n    ...\n\n    public boolean canDelete(User user, List<Answer> answers) throws CannotDeleteException {\n        if (!user.isSameUser(this.writer)) {\n            throw new CannotDeleteException(\"다른 사용자가 작성한 글을 삭제할 수 없습니다.\");\n        }\n        \n        for (Answer answer : answers) {\n            if (!answer.canDelete(user)) {\n                throw new CannotDeleteException(\"다른 사용자가 추가한 댓글이 존재해 삭제할 수 없습니다.\");\n            }\n        }\n        \n        return true;\n    }\n}\n```\n\n- `Question` 은 인자로 전달된 `User` , `Answer` 와 역할을 나눠 삭제 가능 여부를 판단한다.\n  - `User` 에 질문한 사람의 ID를 전달해 사용자가 동일한지 판단하고,\n  - 글쓴이와 로그인 사용자가 같은 경우 각 답변이 삭제 가능한 상태인지 확인한다. (`Answer`)\n\n```java\npublic class User {\n    ...\n\n    public boolean isSameUser(String newUserId) {\n        return userId.equals(newUserId);\n    }\n}\n```\n\n```java\npublic class Answer {\n    ...\n\n    public boolean canDelete(User user) {\n        return user.isSameUser(this.writer);\n    }\n}\n```\n\n이제 이를 활용해 `deleteQuestion()` 을 수정한다.\n\n```java\npublic class QnaService {\n    ...\n\n    public void deleteQuestion(long questionId, User user) throws CannotDeleteException {\n        Question question = questionDao.findById(questionId);\n        if (question == null) {\n            throw new CannotDeleteException(\"존재하지 않는 질문입니다.\");\n        }\n\n        List<Answer> answers = answerDao.findAllByQuestionId(questionId);\n        if (question.canDelete(user, answers)) {\n            questionDao.delete(questionId);\n        }\n    }\n}\n```\n\n- Domain 객체로 로직을 이동시켜 매우 깔끔해졌다. 그렇다고 Domain 객체에 복잡한 로직이 구현된 것은 아니다.\n\n> \"객체지향 개발을 하기 위한 좋은 연습은 상태 값을 가지는 Domain 객체에서 값을 꺼내려고 하지 말고 객체에 메세지를 보내 작업을 위임한다는 생각으로부터 시작한다.\"\n\n객체지향적 개발 시 장점 중 하나는 **테스트하기 쉽다**는 것이다. 아래는 `Question` 의 `canDelete()` 메소드에 대한 테스트 코드이다.\n\n```java\npublic class QuestionTest {\n    public static Question newQuestion(String writer) {\n        return new Question(1L, writer, \"title\", \"contents\", new Date(), 0);\n    }\n\n    public static Question newQuestion(long questionId, String writer) {\n        return new Question(questionId, writer, \"title\", \"contents\", new Date(), 0);\n    }\n\n    @Test(expected = CannotDeleteException.class)\n    public void canDelete_다른_글쓴이() throws Exception {\n        User user = newUser(\"javajigi\");\n        Question question = newQuestion(\"sanjigi\");\n        question.canDelete(user, new ArrayList<Answer>());\n    }\n\n    @Test\n    public void canDelete_글쓴이_같음_답변_없음() throws Exception {\n        User user = newUser(\"javajigi\");\n        Question question = newQuestion(\"javajigi\");\n        assertTrue(question.canDelete(user, new ArrayList<Answer>()));\n    }\n\n    @Test\n    public void canDelete_같은_사용자_답변() throws Exception {\n        User user = newUser(\"javajigi\");\n        Question question = newQuestion(\"javajigi\");\n        List<Answer> answers = Arrays.asList(newAnswer(\"javajigi\"), newAnswer(\"javajigi\"));\n        question.canDelete(user, answers);\n    }\n\n    @Test(expected = CannotDeleteException.class)\n    public void canDelete_다른_사용자_답변() throws Exception {\n        User user = newUser(\"javajigi\");\n        Question question = newQuestion(\"javajigi\");\n        List<Answer> answers = Arrays.asList(newAnswer(\"javajigi\"), newAnswer(\"sanjigi\"));\n        question.canDelete(user, answers);\n    }\n}\n```\n\n- 테스트 코드를 보면, `QuestionDao` , `AnswerDao` 에 대한 의존관계가 없기에 `Mock` 프레임워크를 사용할 필요도 없으며, 구현 또한 간단한 것을 확인할 수 있다.\n\n이제 `QnaService` 에 대한 테스트를 진행한다면 다음과 같이 할 수 있다. 이미 핵심 비즈니스 로직은 `QuestionTest` 에서 모두 끝낸 상태이다. 즉, `QnaServiceTest` 에서는 `QnaService` 로직에 대해서만 테스트를 수행하면 된다.\n\n```java\n@RunWith(MockitoJUnitRunner.class)\npublic class QnaServiceTest {\n    @Mock\n    private QuestionDao questionDao;\n    @Mock\n    private AnswerDao answerDao;\n\n    private QnaService qnaService;\n\n    @Before\n    public void setup() {\n        qnaService = new QnaService(questionDao, answerDao);\n    }\n\n    @Test(expected = CannotDeleteException.class)\n    public void deleteQuestion_없는_질문() throws Exception {\n        when(questionDao.findById(1L)).thenReturn(null);\n        qnaService.deleteQuestion(1L, newUser(\"userId\"));\n    }\n\n    @Test\n    public void deleteQuestion_삭제할수_있음() throws Exception {\n        User user = newUser(\"userId\");\n        Question question = new Question(1L, user.getUserId(), \"title\", \"contents\", new Date(), 0) {\n            public boolean canDelete(User user, List<Answer> answers) throws CannotDeleteException {\n                return true;\n            };\n        };\n        when(questionDao.findById(1L)).thenReturn(question);\n        qnaService.deleteQuestion(1L, newUser(\"userId\"));\n        verify(questionDao).delete(question.getQuestionId());\n    }\n\n    @Test(expected = CannotDeleteException.class)\n    public void deleteQuestion_삭제할수_없음() throws Exception {\n        User user = newUser(\"userId\");\n        Question question = new Question(1L, user.getUserId(), \"title\", \"contents\", new Date(), 0) {\n            public boolean canDelete(User user, List<Answer> answers) throws CannotDeleteException {\n                throw new CannotDeleteException(\"삭제할 수 없음.\");\n            };\n        };\n        when(questionDao.findById(1L)).thenReturn(question);\n        qnaService.deleteQuestion(1L, newUser(\"userId\"));\n    }\n}\n```\n\n관계형 DB를 사용하면서 좀 더 객체지향적인 개발을 위해서는 ORM(Object-Relational Mapping) 프레임워크를 사용할 필요가 있다. 하지만 이를 사용하지 않아도 메소드의 인자로 객체를 전달함으로써 일정 부분 객체지향적인 개발이 가능하다.\n\n---\n\n## 🚩 DI 프레임워크 실습\n### 🔧 요구사항\n질문/답변 기능에 DI를 적용하는 작업은 `LegacyHandlerMapping` 에서 구현했다. DI가 필요할 때마다 매번 직접 인스턴스를 생성해 전달하기 귀찮으므로, 자체적인 DI 프레임워크를 구현해본다.\n\n새로 만든 MVC 프레임워크는 자바 리플렉션을 활용해 `@Controller` annotation이 설정되어 있는 클래스를 찾아 인스턴스를 생성하고, URL 매핑 작업을 자동화했다. 같은 방법으로 각 클래스에 대한 인스턴스 생성 및 의존관계 설정을 자동화한다.\n- 먼저 각 클래스 역할에 맞도록 `@Controller` , `@Service` , `@Repository` annotation을 설정한다.\n  - 3개의 설정으로 생성된 각 인스턴스 간의 의존관계는 `@Inject` annotation을 사용한다.\n- DI 프레임워크로 생성된 인스턴스와 개발자가 `new` 키워드로 생성한 인스턴스를 분리한다.\n  - DI 프레임워크를 통해 생성된 인스턴스는 **빈(Bean)**이라고 한다.\n\n```java\n@Controller\npublic class QnaController extends AbstractController {\n    private MyQnaService qnaService;\n\n    @Inject\n    public QnaController(MyQnaService qnaService) {\n        this.qnaService = qnaService;\n    }\n\n    @RequestMapping(\"/questions\")\n    public ModelAndView list(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        return jspView(\"/qna/list.jsp\");\n    }\n}\n```\n\n```java\n@Service\npublic class MyQnaService {\n    private UserRepository userRepository;\n    private QuestionRepository questionRepository;\n\n    @Inject\n    public MyQnaService(UserRepository userRepository, QuestionRepository questionRepository) {\n        this.userRepository = userRepository;\n        this.questionRepository = questionRepository;\n    }\n    ...\n\n}\n```\n\n```java\n@Repository\npublic class JdbcQuestionRepository implements QuestionRepository {\n\n}\n\n@Repository\npublic class JdbcUserRepository implements UserRepository {\n    \n}\n```\n\n- 제약사항은 빈은 `@Inject` annotation을 가지는 생성자는 하나만 존재하며, 해당 annotation 설정이 되어있지 않으면 인자가 없는 기본 생성자를 제공하는 것으로 한다.\n\n### 🔧 1단계 힌트\n이 문제 해결을 위해서는 **재귀함수**를 사용해 구현할 수 있다. `@Inject` annotation이 설정된 생성자를 통해 빈을 생성해야 한다.\n- 그런데 이 생성자의 인자로 전달할 빈도 다른 빈과 의존관계가 있다. 이처럼 빈 간의 의존관계가 연결되어 있을 수 있는데, 이는 다른 빈과 의존관계를 가지지 않는 빈을 찾아 인스턴스를 생성할 때까지 재귀를 실행하는 방식으로 구현할 수 있다.\n\n재귀를 통해 생성한 빈은 `BeanFactory` 의 `Map<Class<?>, Object>` 에 추가해 관리한다. \n- 인스턴스 생성 전 먼저 `Class<?>` 에 해당하는 빈이 `Map<Class<?>, Object>` 에 존재 여부를 확인한 후 생성하는 방식으로 구현한다.\n- **일반적인 캐시의 동작 원리**와 같은 재사용 방법이다.\n\n### 🔧 2단계 힌트\n빈 인스턴스를 생성하기 위한 재귀 함수 지원을 위해 Class에 대한 빈 인스턴스를 생성하는 메소드와 생성자에 대한 빈 인스턴스를 생성하는 메소드가 필요하다.\n\n```java\nprivate Object instantiateClass(Class<?> clazz) {\n    ...\n    \n    return null;\n}\n\nprivate Object instantiateConstructor(Constructor<?> constructor) {\n    ...\n\n    return null;\n}\n```\n\n- 시작은 `instantiateClass()` 이다. \n- `@Inject` annotation이 설정된 생성자가 존재하면 `instantiateConstructor()` 메소드를 통해 인스턴스를 생성하고, 존재하지 않을 경우 기본 생성자로 인스턴스를 생성한다.\n- `instantiateConstructor()` 메소드는 생성자의 인자로 전달할 빈이 생성되어 `Map<Class<?>, Object>` 에 이미 존재하면 해당 빈을 활용하고, 그렇지 않으면 `instantiateClass()` 을 통해 새로운 빈을 생성한다. \n\n```java\nprivate Object instantiateConstructor(Constructor<?> constructor) {\n    Class<?>[] parameterTypes = constructor.getParameterTypes();\n    List<Object> args = Lists.newArrayList();\n    for (Class<?> clazz : parameterTypes) {\n        ...\n\n        args.add(bean);\n    }\n    return BeanUtils.instantiateClass(constructor, args.toArray());\n}\n```\n\n### 🔧 추가 요구사항 및 힌트\n`@Controller` 가 설정되어 있는 클래스를 찾는 `ControllerScanner` 를 DI 프레임워크가 있는 패키지로 이동해 `@Controller` , `@Service` , `@Repository` 에 대한 지원이 가능하도록 개선한다. 그리고 다른 annotation까지 지원이 가능하게 되므로, `BeanScanner` 로 rename한다.\n- 또한 `AnnotationHandlerMapping` 이 `BeanFactory` 와 `BeanScanner` 를 활용하도록 리팩토링한다.\n\n---\n\n## 🚩 DI 프레임워크 구현\n`BeanFactory` 의 `initialize()` 메소드를 구현한다. \n\n```java\npublic class BeanFactory {\n    private static final Logger logger = LoggerFactory.getLogger(BeanFactory.class);\n\n    private Set<Class<?>> preInstanticateBeans;\n\n    private Map<Class<?>, Object> beans = Maps.newHashMap();\n\n    public BeanFactory(Set<Class<?>> preInstanticateBeans) {\n        this.preInstanticateBeans = preInstanticateBeans;\n    }\n\n    @SuppressWarnings(\"unchecked\")\n    public <T> T getBean(Class<T> requiredType) {\n        return (T) beans.get(requiredType);\n    }\n\n    public void initialize() {\n        for (Class<?> clazz : preInstanticateBeans) {\n            if (beans.get(clazz) == null) {\n                instantiateClass(clazz);\n            }\n        }\n    }\n\n    private Object instantiateClass(Class<?> clazz) {\n        Object bean = beans.get(clazz);\n        if (bean != null) {\n            return bean;\n        }\n\n        Constructor<?> injectedConstructor = BeanFactoryUtils.getInjectedConstructor(clazz);\n        if (injectedConstructor == null) {\n            bean = BeanUtils.instantiate(clazz);\n            beans.put(clazz, bean);\n            return bean;\n        }\n\n        logger.debug(\"Constructor : {}\", injectedConstructor);\n        bean = instantiateConstructor(injectedConstructor);\n        beans.put(clazz, bean);\n        return bean;\n    }\n\n    private Object instantiateConstructor(Constructor<?> constructor) {\n        Class<?>[] parameterTypes = constructor.getParameterTypes();\n        List<Object> args = Lists.newArrayList();\n        for (Class<?> clazz : parameterTypes) {\n            Class<?> concreteClazz = BeanFactoryUtils.findConcreteClass(clazz, preInstanticateBeans);\n            if (!preInstanticateBeans.contains(concreteClazz)) {\n                throw new IllegalStateException(clazz + \"는 Bean이 아닙니다.\");\n            }\n            Object bean = beans.get(concreteClazz);\n            if (bean == null) {\n                bean = instantiateClass(concreteClazz);\n            }\n            args.add(bean);\n        }\n        return BeanUtils.instantiateClass(constructor, args.toArray());\n    }\n}\n```\n\n- `BeanFactory` 에서 핵심 구현 로직은 `instantiateClass()` , `instantiateConstructor()` 메소드이다. 이 두 메소드의 재귀호출을 통해 복잡한 의존관계에 있는 빈을 생성하는 과정을 완료할 수 있다.\n\n이제 `@Controller` , `@Service` , `@Repository` annotation이 설정된 빈을 찾는 `BeanScanner` 를 구현한다.\n\n```java\npublic class BeanScanner {\n    private Reflections reflections;\n\n    public BeanScanner(Object... basePackage) {\n        reflections = new Reflections(basePackage);\n    }\n    \n    public Set<Class<?>> scan() {\n        return getTypeAnnotatedWith(Controller.class, Service.class, Repository.class);\n    }\n\n    private Set<Class<?>> getTypeAnnotatedWith(Class<? extends Annotation>... annotations) {\n        Set<Class<?>> preInstantiatedBeans = Sets.newHashSet();\n        for (Class<? extends Annotation> annotation : annotations) {\n            preInstantiatedBeans.addAll(reflections.getTypesAnnotatedWith(annotation));\n        }\n        return preInstantiatedBeans;\n    }\n}\n```\n\n이제 생성한 `BeanFactory` 를 `AnnotationHandlerMapping` 이 사용하도록 리팩토링한다. 먼저 `@Controller` annotation을 설정한 빈을 조회하는 메소드를 추가한다.\n\n```java\npublic class BeanFactory {\n    ...\n\n    public Map<Class<?>, Object> getControllers() {\n        Map<Class<?>, Object> controllers = Maps.newHashMap();\n        for (Class<?> clazz : preInstanticateBeans) {\n            Annotation annotation = clazz.getAnnotation(Controller.class);\n            if (annotation != null) {\n                controllers.put(clazz, annotation);\n            }\n        }\n        return controllers;\n    }\n}\n```\n\n`AnnotationHandlerMapping` 에서는 `BeanFactory` 를 초기화한 후 `@Controller` 로 설정한 빈을 사용하면 된다.\n\n```java\npublic class AnnotationHandlerMapping implements HandlerMapping {\n    private static final Logger logger = LoggerFactory.getLogger(AnnotationHandlerMapping.class);\n\n    private Object[] basePackage;\n\n    private Map<HandlerKey, HandlerExecution> handlerExecutions = Maps.newHashMap();\n\n    public AnnotationHandlerMapping(Object... basePackage) {\n        this.basePackage = basePackage;\n    }\n\n    public void initialize() {\n        BeanScanner beanScanner = new BeanScanner(basePackage);\n        BeanFactory beanFactory = new BeanFactory(beanScanner.scan());\n        beanFactory.initialize();\n        \n        Map<Class<?>, Object> controllers = beanFactory.getControllers();\n        Set<Method> methods = getRequestMappingMethods(controllers.keySet());\n        for (Method method : methods) {\n            RequestMapping rm = method.getAnnotation(RequestMapping.class);\n            logger.debug(\"register handlerExecution : url is {}, method is {}\", rm.value(), method);\n            handlerExecutions.put(createHandlerKey(rm),\n                    new HandlerExecution(controllers.get(method.getDeclaringClass()), method));\n        }\n\n        logger.info(\"Initialized AnnotationHandlerMapping!\");\n    }\n    ...\n\n}\n```\n\n## 📕 출처\n**자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성"},{"excerpt":"REST의 개념에 대해서 정리하는 POST입니다. 🔧 REST ⚙️ REST의 정의 : \"Representational State Transfer\"의 약자로, 자원을 이름으로 구분하여 자원의 상태정보를 주고 받는 모든 것을 의미한다. HTTP URI를 통해 자원을 명시하고, HTTP Method(POST, GET, PUT, DELETE)를 통해 해당 자원(…","fields":{"slug":"/[BackEnd]REST/"},"frontmatter":{"date":"February 19, 2022","title":"💻 REST","tags":["REST","RESTful","RESTAPI"]},"rawMarkdownBody":"\n<em>REST의 개념에 대해서 정리하는 POST입니다.</em>\n\n### 🔧 REST\n#### ⚙️ REST의 정의\n: \"Representational State Transfer\"의 약자로, 자원을 이름으로 구분하여 자원의 상태정보를 주고 받는 모든 것을 의미한다.\n\n- HTTP URI를 통해 자원을 명시하고,\n- HTTP Method(POST, GET, PUT, DELETE)를 통해 해당 자원(URI)에 대한 CRUD를 적용하는 것이다.\n\n#### 🔩 구성 요소\n- 자원 : HTTP URI의 형태\n- 자원에 대한 행위 : HTTP Method\n- 자원에 대한 행위의 내용 : HTTP Message payload\n\n#### 🔑 특징\n1. Server-Client(서버-클라이언트 구조)\n: REST 서버는 API 제공, 클라이언트는 사용자 인증이나 Context(session, 로그인 정보) 등을 직접 관리하는 구조로, 각각의 역할이 확실히 구분되기 때문에 클라이언트와 서버에서 개발해야 할 내용이 명확해지고 서로 간 의존성이 줄어들게 된다.\n\n2. Stateless(무상태)\n: REST는 상태를 가지지 않는다. 즉 작업을 위한 상태정보를 저장하거나 관리하지 않는다. 위에서 설명했듯, 서버는 session 정보나 쿠키 정보를 별도로 저장하고 관리하지 않기에 단순히 들어오는 요청만을 처리하는 구조이다. 따라서 서비스의 자유도가 높아지고 서버에서의 구현이 단순해진다.\n\n3. Cacheable(캐시 처리 가능)\n: HTTP라는 기존 웹 표준을 그대로 사용하기에, 웹에서 사용하는 기존 인프라를 그대로 활용할 수 있다. 즉, HTTP가 가진 캐싱 기능을 적용할 수 있다. (`Last-Modified` or `E-Tag` 사용)\n\n4. Layered System(계층화)\n: REST 서버는 다중 계층으로 구성될 수 있으며, 보안, load balancing, 암호화 계층을 추가해 유연성을 둘 수 있다. 또한 PROXY, Gateway 같은 네트워크 기반의 중간 매체를 사용할 수 있게 한다.\n\n5. Uniform Interface(인터페이스 일관성)\n: 위에서 언급했듯, HTTP 표준을 따르기에 특정 언어나 기술에 종속되지 않고 모든 플랫폼에 사용할 수 있으며, URI로 지정한 자원에 대한 조작이 가능하다.\n\n#### 🔒 장단점\n##### 장점\n- HTTP 인프라를 그대로 사용하므로 REST API 사용을 위한 별도 인프라 구축이 필요하지 않다.\n  - 또한, HTTP 표준을 최대한 활용하여 여러 추가 장점을 가진다.\n- HTTP 표준을 따르는 모든 플랫폼에서 사용 가능하다. (Uniform Interface)\n- Hypermedia API 내에서, 범용성을 보장한다.\n  - > **Hypermedia API**\n    > : 다른 말로 HATEOAS(Hypermedia As The Engine Of Application State)로, hypermedia를 application의 상태를 관리하기 위한 매커니즘으로 사용한다는 개념이다. REST API 구현의 마지막 단계로, API 관리에 어려움이 있다면 도입을 고려해볼만하다.\n- REST API 메세지가 의도하는 바를 명확하게 나타내기에 의도를 파악하기 쉽다.\n- 서버와 클라이언트의 역할을 명확하게 분리한다.\n\n##### 단점\n- 표준이 존재하지 않아 정의가 필요하고 관리가 쉽지 않다.\n- 사용할 수 있는 메소드가 4가지뿐이다. (HTTP 메소드가 제한적)\n- 안티패턴으로 설계될 가능성이 있다.\n  - > **안티패턴**\n    > : 표준이 없기에 REST API이 특징을 이해하지 못하고 어긋나는 패턴\n    > HTTP 메소드의 잘못된 사용, HTTP Response code의 제한적 활용이 원인이 될 수 있다.\n\n---\n\n### 🔨 REST API\n#### 🧭 REST API의 정의\n: REST를 기반으로 만들어진 API\n\n<img src=\"https://res.cloudinary.com/practicaldev/image/fetch/s--YTDTEgpk--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/ekawmj3rafdtn06hzj79.png\" width=\"70%\">\n\n#### 🔦 특징\n- REST 기반으로 시스템을 분산해 확장성과 재사용성을 높여 유지보수 및 운용이 편리해진다.\n- HTTP 표준을 기반으로 구현해, HTTP를 지원하는 프로그램 언어로 클라이언트와 서버를 구현할 수 있다.\n\n#### 🕯 설계\n##### 기본 규칙\n1. URI는 정보의 자원을 표현한다.\n2. 자원에 대한 행위는 HTTP 메소드로 표현한다.\n\n##### 예시\n|CRUD|HTTP 메소드|Route|\n|:---:|:---:|:---:|\n|자원들의 목록을 표시|GET|`/resource` |\n|자원 하나의 내용을 표시|GET|`/resource/:id` |\n|자원 생성|POST|`/resource` |\n|자원 수정|PUT|`/resource/:id` |\n|자원 삭제|DELETE|`/resource/:id` |\n\n---\n\n### ⛏ RESTful\n#### 💳 RESTful의 정의\n: 일반적으로 REST라는 아키텍처를 구현하는 웹 서비스 (REST API를 제공하는 웹 서비스)\n- RESTful한 API를 구현하는 근본적인 목적은 성능 향상이 아닌 일관적인 컨벤션을 통한 API의 이해도 및 호환성을 높이는 것이다. 따라서 성능이 중요한 경우 굳이 이를 구현할 필요는 없다.\n\n#### 💣 RESTful하지 못한 경우\n- CRUD 기능을 모두 POST로만 처리하는 경우, 즉 HTTP 메소드를 모두 활용하지 않는 경우\n- Route에 resource, id 외의 정보가 들어가는 경우(ex. `/students/updateName`)\n\n### 📕 참고\n- [REST란? REST API란? RESTful이란?](https://gmlwjd9405.github.io/2018/09/21/rest-and-restful.html)\n- [REST API란? REST, RESTful이란?](https://khj93.tistory.com/entry/%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-REST-API%EB%9E%80-REST-RESTful%EC%9D%B4%EB%9E%80)\n- [REST](http://www.incodom.kr/REST)\n- [REST API의 단점 3가지](https://round-round.tistory.com/entry/REST-API%EC%9D%98-%EB%8B%A8%EC%A0%90-3%EA%B0%80%EC%A7%80)"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. \"새로운 애플리케이션을 개발하는 작업은 쉽지 않은 작업이다. 하지만 그보다 더 어려운 작업은 누군가 개발해놓은 애플리케이션을 지속적으로 기능 추가, 개선을 하면서 기술적으로 계속해서 발전시켜 나가는 작업이다.\" 지금까지 구현한 MVC 프레임워크의 문제점을 파악한 후 …","fields":{"slug":"/[NextStep]10/"},"frontmatter":{"date":"February 18, 2022","title":"📖 10장 새로운 MVC 프레임워크 구현을 통한 점진적 개선","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n\"새로운 애플리케이션을 개발하는 작업은 쉽지 않은 작업이다. 하지만 그보다 더 어려운 작업은 누군가 개발해놓은 애플리케이션을 지속적으로 기능 추가, 개선을 하면서 기술적으로 계속해서 발전시켜 나가는 작업이다.\"\n\n> 지금까지 구현한 MVC 프레임워크의 문제점을 파악한 후 새로운 MVC 프레임워크를 구현한다. 이전에 구현한 MVC 프레임워크 기반으로 동작하는 컨트롤러가 정상적으로 동작하는 상태에서 새로운 MVC 프레임워크로 점진적으로 전환해가는 과정에 대해 살펴본다.\n\n## 🚩 MVC 프레임워크 요구사항 3단계\n자바의 리플렉션 API에 대한 활용과 구현해야 할 클래스가 많아져 난이도가 높아진다. \n\n### 🔧 요구사항\n9장 중간 점검의 마지막 문제를 보면, 새로운 컨트롤러 추가마다 매번 `RequestMapping` 클래스에 수정사항이 발생하는 것에 대한 귀찮음을 제기한다. 유지보수 차원에서 컨트롤러의 수가 계속 증가하고 있고, 각 컨트롤러의 `execute()` 메소드를 보면, 10줄 이상인 경우도 거의 없다.\n\n\" 따라서, 새로운 기능이 추가될 때마다 매번 컨트롤러를 추가하는 것이 아닌 **메소드를 추가하는 방식**이면 더 효율적일 듯하다. \"\n\n또 한 가지 아쉬운 점은 **요청 URL 매핑 시, HTTP 메소드 정보도 함께 매핑**되면 좋을 것 같다. URL은 같지만, 다른 기능 수행을 위해 다른 메소드로 매핑하는 것 또한 가능하면 좋을 것 같다.\n\n```java\n@Controller\npublic class MyController {\n    private static final Logger log = LoggerFactory.getLogger(MyController.class);\n\n    @RequestMapping(\"/users\")\n    public ModelAndView list(HttpServletRequest req, HttpServletResponse res) {\n        log.debug(\"users findUserId\");\n        return new ModelAndView(new JspView(\"/users/list.jsp\"));\n    }\n\n    @RequestMapping(value = \"/users/show\", method = RequestMethod.GET)\n    public ModelAndView show(HttpServletRequest req, HttpServletResponse res) {\n        log.debug(\"users findUserId\");\n        return new ModelAndView(new JspView(\"/users/show.jsp\"));\n    }\n\n    @RequestMapping(value = \"/users\", method = RequestMethod.POST)\n    public ModelAndView create(HttpServletRequest req, HttpServletResponse res) {\n        log.debug(\"users create\");\n        return new ModelAndView(new JspView(\"redirect:/users\"));\n    }\n}\n```\n\n- 위 기능을 지원하는 annotation 기반의 새로운 MVC 프레임워크를 구현해야 한다.\n  - 실습을 위해 뼈대가 되는 코드와 테스트 코드가 있고, 해당 테스트 클래스의 3개의 테스트 메소드들이 성공하면 구현이 완료된 것이다.\n\n새로운 MVC 프레임워크를 추가했으니 이전에 구현한 컨트롤러를 **annotation** 기반으로 변경해야 한다. \n- 하지만 새 프레임워크 적용을 위해 한 번에 모든 컨트롤러를 변경하게 되면, 일정 기간 동안 새로운 기능을 추가하거나 변경하는 작업을 중단해야 한다.\n  - 이를 보완하기 위해 **점진적 리팩토링이 가능한 구조로 개발**해야 한다.\n\n**점진적 리팩토링이 가능한 구조**<br/>\n- annotation 기반으로 MVC 프레임워크를 구현한 후 레거시 MVC 프레임워크(8장에서 구현했던 MVC 프레임워크)와 annotation 기반의 새로운 MVC 프레임워크를 통합하는 방식으로 구현해야 한다.\n- ex. 요청 URL과 컨트롤러를 매핑하는 클래스가 레거시 MVC 프레임워크 = `LegacyHandlerMapping` , 새로운 MVC 프레임워크 = `AnnotationHandlerMapping` 이라면 `DispatcherServlet` 에서 이 둘을 통합해 두 형태의 컨트롤러가 모두 동작 가능하도록 구현할 수 있다.\n\n```java\n@WebServlet(name = \"dispatcher\", urlPatterns = \"/\", loadOnStartup = 1)\npublic class DispatcherServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n    private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);\n\n    private LegacyHandlerMapping lhm;\n    private AnnotationHandlerMapping ahm;\n\n    @Override\n    public void init() throws ServletException {\n        lhm = new LegacyHandlerMapping();\n        lhm.initMapping();\n        ahm = new AnnotationHandlerMapping(\"next.controller\");\n        ahm.initialize();\n    }\n\n    @Override\n    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        try {\n            Controller controller = lhm.findController(req.getRequestURI());\n            if (controller != null) {\n                render(req,resp,controller.execute(req, resp));\n            } else {\n                HandlerExecution he = ahm.getHandler(req);\n                if (he == null) {\n                    throw new ServletException(\"유효하지 않은 요청입니다.\");\n                }\n                render(req, resp, he.handle(req, resp));\n            }\n        } catch (Throwable e) {\n            throw new ServletException(e.getMessage());\n        }\n    }\n\n    private void render (HttpServletRequest req, HttpServletResponse resp, ModelAndView mav) throws Exception {\n        View view = mav.getView();\n        view.render(mav.getModel(), req, resp);\n    }\n}\n```\n\n- `HandlerExecution` 은 새로 추가한 MVC 프레임워크의 컨트롤러와 같은 역할을 하는 클래스이다.\n- 위와 같은 구조로 구현한다면 서로 다른 컨트롤러를 같이 서비스하는 것이 가능할 것이다.\n\n실습의 1차 목표는 \"레거시 MVC 프레임워크와 annotation 기반의 새로운 MVC 프레임워크가 동시에 서비스 가능하도록 구현하는 것\"이다.\n- 1차 구현을 완료한 후, 리팩토링할 부분을 찾아보면 2개의 프레임워크가 공존하기에 인터페이스로 추상화하면 좋아보이는 부분이 있을 것이다.\n\n> 이 실습은 클래스패스로 설정되어 있는 클래스 중 `@Controller` annotation이 설정되어 있는 클래스를 찾기 위해 [reflections](https://github.com/ronmamo/reflections) 라이브러리를 활용할 수 있다. 이를 활용해 `@Controller` annotation이 설정된 클래스를 찾은 후 `@RequestMapping` 설정에 따라 요청 URL과 메소드를 연결하도록 구현할 수 있다.\n\n### 🔧 자바 리플렉션\n리플렉션이란\n: 구체적인 클래스 타입을 알지 못해서 그 클래스의 메소드와 타입 그리고 변수들을 접근할 수 있도록 해주는 자바 API이다.\n\n**자바 리플렉션 API 활용해 클래스 정보 출력**<br/>\n`Question` 클래스의 모든 필드, 생성자, 메소드 정보를 출력한다. (`core.ref.ReflectionTest` 의 `showClass()` 메소드 구현)\n\n```java\n@Test\npublic void showClass() {\n    Class<Question> clazz = Question.class;\n    logger.debug(clazz.getName());\n    logger.debug(Arrays.toString(clazz.getDeclaredFields()));\n    logger.debug(Arrays.toString(clazz.getConstructors()));\n    logger.debug(Arrays.toString(clazz.getMethods()));\n}\n```\n\n- `Question` 의 모든 필드가 `private` 이므로 `getDeclaredFields()` 를 사용하고, 생성자와 메소드들은 `public` 이므로 `get...()` 을 사용한다.\n\n**\"test\" 로 시작하는 메소드 실행**<br/>\n`core.ref.Junit3Test` 에서 `test` 로 시작하는 모든 메소드를 실행해야 한다. `core.ref.Junit3TestRunner` 클래스의 `run()` 메소드를 실행했을 때, `Junit3Test` 에서 메소드 이름이 `test` 로 시작하는 모든 메소드를 실행하면 된다.\n\n```java\npublic class Junit3TestRunner {\n    @Test\n    public void run() throws Exception {\n        Class<Junit3Test> clazz = Junit3Test.class;\n        Method[] ary = clazz.getMethods();\n        for (Method str : ary) {\n            if (str.getName().startsWith(\"test\")) {\n                str.invoke(clazz.newInstance());\n            }\n        }\n    }\n}\n```\n\n- `Method` 배열에 `Junit3Test.class` 에 있는 `public` 메소드들을 가져오고, `getName()` 으로 이름을 얻어 `test` 로 시작하는지 확인하고 실행한다.\n\n**@MyTest annotation으로 설정된 메소드 실행**<br/>\n`core.ref.Junit4Test` 에서 `@MyTest` annotation이 설정되어 있는 모든 메소드를 실행한다. 위와 비슷한 방식이다.\n\n```java\npublic class Junit4TestRunner {\n    @Test\n    public void run() throws Exception {\n        Class<Junit4Test> clazz = Junit4Test.class;\n        Method[] ary = clazz.getMethods();\n        for (Method tmp : ary) {\n            if (tmp.isAnnotationPresent(MyTest.class)) {\n                tmp.invoke(clazz.newInstance());\n            }\n        }\n    }\n}\n```\n\n- `isAnnotationPresent` 메소드로 해당 `Method` 가 인자로 넘겨준 annotation이 설정되었는지 확인할 수 있다.\n\n**생성자가 있는 클래스의 인스턴스 생성**<br/>\n`User` 클래스의 인스턴스를 생성한다. 해당 클래스는 기본 생성자가 없으며, 4개의 인자를 가지는 생성자밖에 없다. `core.ref.ReflectionTest` 의 `newInstanceWithConstructorArgs()` 메소드를 구현한다.\n\n```java\n@Test\npublic void newInstanceWithConstructorArgs() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {\n    Class<User> clazz = User.class;\n    logger.debug(clazz.getName());\n    Constructor<?> constructor = clazz.getDeclaredConstructor();\n    constructor.newInstance();\n}\n```\n\n- `getDeclaredConstructors()` 를 통해 인스턴스 생성을 위한 생성자를 먼저 찾으라는데, `NoSuchMethodException` 예외가 발생한다.\n\n**`private` 필드에 접근**<br/>\n리플렉션 API를 통해 인스턴스를 생성하여 클래스의 `private` 필드에 접근해 값을 전달할 수 있다. 다음과 같이 \n2개의 `private` 필드를 가지는 클래스가 있는 경우, 인스턴스를 직접 생성해 값을 전달할 수 없다. 이때 자바 리플렉션 API를 활용해 값을 가지는 인스턴스를 생성할 수 있다.\n\n```java\npackage next.model;\n\npublic class Student {\n    private String name;\n    private int age;\n\n    public String getName() {\n        return name;\n    }\n\n    public int getAge() {\n        return age;\n    }\n}\n```\n\n- `Student` 클래스의 `name` 과 `age` 필드에 값을 할당하고, `getter` 메소드를 통해 값을 확인한다.\n\n```java\n@Test\npublic void privateFieldAccess() throws NoSuchFieldException, IllegalAccessException {\n    Class<Student> clazz = Student.class;\n    logger.debug(clazz.getName());\n\n    next.model.Student student = new next.model.Student();\n\n    Field[] fields = clazz.getDeclaredField(\"name\");\n    for (Field field : fields) {\n        field.setAccessible(true);\n\n        ...\n        \n    }\n\n    logger.debug(student.getName() + student.getAge());\n}\n```\n\n- `Field` 정보를 가져와서 접근 권한을 `true` 로 바꿔준 후 값을 세팅한다.\n\n### 🔧 요구사항 분리 및 힌트\n- `reflections` 라이브러리를 활용해 `@Controller` annotation이 설정되어 있는 모든 클래스를 찾고, 각 클래스에 대한 인스턴스 생성을 담당하는 `ControllerScanner` 클래스를 추가한다.\n- annotation 기반 매핑을 담당할 `AnnotationHandlerMapping` 클래스를 추가한 후 초기화한다.\n- `AnnotationHandlerMapping` 클래스에 클라이언트 요청 정보(`HttpServletRequest`)를 전달하면 요청에 해당하는 `HandlerExecution` 을 반환하는 메소드를 구현한다.\n\nannotation 기반으로 동작하는 새로운 매핑 클래스(`AnnotationHandlerMapping`) 추가를 완료했다. 다음은 기존에 사용하던 MVC 프레임워크의 `RequestMapping` 과 새로 추가한 `AnnotationHandlerMapping` 이 같이 동작하도록 구현하는 단계이다. 이 과정으로 `RequestMapping` , `AnnotationHandlerMapping` 을 통합할 수 있다면, 기존에 구현한 컨트롤러와 새로 추가할 컨트롤러(`@Controller`)를 같이 사용할 수 있겠다.\n\n- `RequestMapping` , `AnnotationHandlerMapping` 은 요청 URL과 실행할 컨트롤러 클래스 또는 메소드를 매핑하는 역할은 같다. 하지만 수동 매핑이냐, annotation 기반 자동 매핑이냐 차이이다. 두 클래스의 중복된 부분을 인터페이스로 추상화한다. (`HandlerMapping` interface)\n- `DispatcherServlet` 의 초기화(`init()` 메소드) 과정에서 `LegacyHandlerMapping` , `AnnotationHandlerMapping` 모두 초기화한다. 두 `HandlerMapping` 을 `List` 로 관리한다.\n- `DispatcherServlet` 의 `service()` 메소드에서는 앞에서 초기화한 2개의 `HandlerMapping` 에서 요청 URL에 해당하는 컨트롤러를 찾아 메소드를 실행한다.\n- 기존 컨트롤러를 새로 추가한 annotation 기반으로 설정하고 테스트한다.\n\n---\n\n## 🚩 MVC 프레임워크 구현 3단계\n### 🔧 @Controller annotation 설정 클래스 스캔\nannotation 기반으로 MVC 프레임워크를 구현하려면 먼저 `@Controller` annotation이 설정된 클래스를 찾아야 한다. 리플렉션을 이용해 해당 클래스들을 찾고, 각 클래스에 대한 인스턴스 목록까지 구현한다.\n\n```java\npublic class ControllerScanner {\n    private static final Logger log = LoggerFactory.getLogger(ControllerScanner.class);\n\n    private Reflections reflections;\n\n    public ControllerScanner(Object... backPackage) {\n        reflections = new Reflections(backPackage);\n    }\n\n    public Map<Class<?>, Object> getControllers() {\n        Set<Class<?>> preInitiatedControllers = reflections.getTypesAnnotatedWith(Controller.class);\n        return instantiateControllers(preInitiatedControllers);\n    }\n\n    Map<Class<?>, Object> instantiateControllers(Set<Class<?>> preInitiatedControllers) {\n        Map<Class<?>, Object> controllers = Maps.newHashMap();\n        try {\n            for (Class<?> clazz : preInitiatedControllers) {\n                controllers.put(clazz, clazz.newInstance());\n            }\n        } catch (InstantiationException | IllegalAccessException e) {\n            e.printStackTrace();\n        }\n        return controllers;\n    }\n}\n```\n\n- 테스트를 위해 `@Controller` annotation을 사용하는 테스트용 컨트롤러를 구현하고, 테스트 코드를 작성한다.\n\n```java\n@Controller\npublic class MyController {\n    private static final Logger log = LoggerFactory.getLogger(MyController.class);\n\n    @RequestMapping(\"/users/findUserId\")\n    public ModelAndView list(HttpServletRequest req, HttpServletResponse res) {\n        log.debug(\"users findUserId\");\n        return new ModelAndView(new JspView(\"/users/list.jsp\"));\n    }\n\n    @RequestMapping(value = \"/users/show\", method = RequestMethod.GET)\n    public ModelAndView show(HttpServletRequest req, HttpServletResponse res) {\n        log.debug(\"users findUserId\");\n        return new ModelAndView(new JspView(\"/users/show.jsp\"));\n    }\n\n    @RequestMapping(value = \"/users\", method = RequestMethod.POST)\n    public ModelAndView create(HttpServletRequest req, HttpServletResponse res) {\n        log.debug(\"users create\");\n        return new ModelAndView(new JspView(\"redirect:/users\"));\n    }\n}\n```\n\n```java\npublic class ControllerScannerTest {\n    private static final Logger log = LoggerFactory.getLogger(ControllerScannerTest.class);\n\n    private ControllerScanner cs;\n\n    @Before\n    public void setup() {\n        cs = new ControllerScanner(\"core.nmvc\");\n    }\n\n    @Test\n    public void getControllers() throws Exception {\n        Map<Class<?>, Object> controllers = cs.getControllers();\n        for (Class<?> controller : controllers.keySet()) {\n            log.debug(\"controller : {}\", controller);\n        }\n    }\n}\n```\n\n- 테스트에서는 컨트롤러를 잘 매핑하여 정보를 가져오는지 출력문으로 확인한다.\n  - 위에서 `@Controller` annotation을 사용한 `MyController` 컨트롤러를 출력하는 것을 확인할 수 있다.\n\n### 🔧 @RequestMapping annotation 설정을 활용한 매핑\n앞에서 찾은 컨트롤러 클래스의 `RequestMapping` annotation 설정을 기반으로 매핑한다. 매핑은 이전 MVC 프레임워크와 같이 `Map` 을 활용한다.\n- 다른 점은 `Map` 의 key로 사용되는 값이 **요청 URL과 HTTP 메소드의 조합**이라는 점이다.\n- 요청 URL과 HTTP 메소드 정보를 가지는 클래스를 `HandleKey` 라는 이름으로 구현한다.\n\n```java\npublic class HandlerKey {\n    private String url;\n    private RequestMethod requestMethod;\n\n    public HandlerKey(String url, RequestMethod requestMethod) {\n        this.url = url;\n        this.requestMethod = requestMethod;\n    }\n\n    @Override\n    public String toString() {\n        return \"HandlerKey [url=\" + url + \", requestMethod=\" + requestMethod + \"]\";\n    }\n\n    @Override\n    public int hashCode() {\n        final int prime = 31;\n        int result = 1;\n        result = prime * result + ((requestMethod == null) ? 0 : requestMethod.hashCode());\n        result = prime * result + ((url == null) ? 0 : url.hashCode());\n        return result;\n    }\n\n    @Override\n    public boolean equals(Object obj) {\n        if (this == obj)\n            return true;\n        if (obj == null)\n            return false;\n        if (getClass() != obj.getClass())\n            return false;\n        HandlerKey other = (HandlerKey) obj;\n        if (requestMethod != other.requestMethod)\n            return false;\n        if (url == null) {\n            if (other.url != null)\n                return false;\n        } else if (!url.equals(other.url))\n            return false;\n        return true;\n    }\n}\n```\n\n- `HashMap` 의 키로 활용하기 위해 `hashCode()` , `equals()` 메소드를 반드시 구현한다.\n- `Map` 의 값은 `@RequestMapping` annotation이 설정되어 있는 메소드 정보이다. \n  - 값에 저장되는 메소드 정보는 자바 리플렉션으로 해당 메소드를 실행할 수 있는 정보여야 한다.\n  - 즉, 메소드가 위치하는 클래스의 인스턴스 정보와 `java.lang.reflect.Method` 정보를 가져야 한다.\n  - 이를 `HandlerExecution` 클래스로 구현한다.\n\n```java\npublic class HandlerExecution {\n    private static final Logger log = LoggerFactory.getLogger(HandlerExecution.class);\n    private Object declaredObject;\n    private Method method;\n\n    public HandlerExecution(Object declaredObject, Method method) {\n        this.declaredObject = declaredObject;\n        this.method = method;\n    }\n\n    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response) throws Exception {\n        try {\n            return (ModelAndView) method.invoke(declaredObject, request, response);\n        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {\n            log.error(\"{} method invoke fail. error message : {}\", method, e.getMessage());\n            throw new RuntimeException(e);\n        }\n    }\n}\n```\n\n이제 `HandleKey` 와 `HandleExecution` 을 연결(mapping)하도록 한다. 매핑 초기화 작업은 `AnnotationHandlerMapping` 클래스에서 구현한다.\n\n```java\npublic class AnnotationHandlerMapping {\n    private static final Logger log = LoggerFactory.getLogger(AnnotationHandlerMapping.class);\n    private Object[] basePackage;\n\n    private Map<HandlerKey, HandlerExecution> handlerExecutions = Maps.newHashMap();\n\n    public AnnotationHandlerMapping(Object... basePackage) {\n        this.basePackage = basePackage;\n    }\n\n    public void initialize() {\n        ControllerScanner controllerScanner = new ControllerScanner(basePackage);\n        Map<Class<?>, Object> controllers = controllerScanner.getControllers();\n        Set<Method> methods = getRequestMappingMethods(controllers.keySet());\n        for (Method method : methods) {\n            RequestMapping rm = method.getAnnotation(RequestMapping.class);\n            log.debug(\"register handlerExecution : url is {}, method is {}\", rm.value(), method);\n            handlerExecutions.put(createHandleKey(rm), new HandlerExecution(controllers.get(method.getDeclaringClass()), method));\n        }\n    }\n\n    private HandlerKey createHandleKey(RequestMapping rm) {\n        return new HandlerKey(rm.value(), rm.method());\n    }\n\n    private Set<Method> getRequestMappingMethods(Set<Class<?>> controllers) {\n        Set<Method> requestMappingMethods = Sets.newHashSet();\n        for (Class<?> clazz : controllers) {\n            requestMappingMethods.addAll(ReflectionUtils.getAllMethods(clazz, ReflectionUtils.withAnnotation(RequestMapping.class)));\n        }\n        return requestMappingMethods;\n    }\n    ...\n\n}\n```\n\n### 🔧 클라이언트 요청에 해당하는 HandlerExecution 반환\n마지막으로 클라이언트 요청에 해당하는 `HandlerExecution` 을 조회하는 메소드이다. `AnnotationHandlerMapping` 을 다음과 같이 구현한다.\n\n```java\npublic class AnnotationHandlerMapping {\n    private static final Logger log = LoggerFactory.getLogger(AnnotationHandlerMapping.class);\n    private Object[] basePackage;\n\n    private Map<HandlerKey, HandlerExecution> handlerExecutions = Maps.newHashMap();\n\n    ...\n\n    public HandlerExecution getHandler(HttpServletRequest request) {\n        String requestUri = request.getRequestURI();\n        RequestMethod rm = RequestMethod.valueOf(request.getMethod().toUpperCase());\n        log.debug(\"requestUri : {}, requestMethod : {}\", requestUri, rm);\n        return handlerExecutions.get(new HandlerKey(requestUri, rm));\n    }\n}\n```\n\n`AnnotationHandlerMappingTest` 로 정상적으로 구현을 완료했는지 판단한다.\n\n### 🔧 DispatcherServlet과 AnnotationHandlerMapping 통합\n이제 `DispatcherServlet` 에서 새로 추가한 `AnnotationHandlerMapping` 을 활용해 서비스할 수 있도록 통합하는 작업을 수행할 차례이다.\n- `DispatcherServlet` 은 `RequestMapping` 과 `AnnotationHandlerMapping` 을 모두 지원해야 한다.\n  - 분리해서 관리할 수도 있지만 둘을 일관된 인터페이스를 구현하도록 통합한 후 관리하는 것이 향후 확장성을 고려했을 때 적절하다고 판단된다.\n  - 먼저 두 `Mapping` 클래스에 대해 추상화한 인터페이스를 `HandlerMapping` 이라는 이름으로 추가한다.\n\n```java\npublic interface HandlerMapping {\n    Object getHandler(HttpServletRequest request);\n}\n```\n\n이제 위 인터페이스를 두 클래스가 구현하도록 한다. `RequestMapping` 클래스를 `LegacyHandlerMapping` 으로 변경하여 구현한다.\n\n```java\npublic class LegacyHandlerMapping implements HandlerMapping {\n    private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);\n    private Map<String, Controller> mappings = new HashMap<>();\n\n    public void initMapping() {\n        ...\n    }\n    ...\n\n    @Override\n    public Object getHandler(HttpServletRequest request) {\n        return mappings.get(request.getRequestURI());\n    }\n}\n```\n\n- 요청의 URI를 가져와 `mappings` 에서 조회해 반환한다.\n\n```java\npublic class AnnotationHandlerMapping implements HandlerMapping {\n    ...\n\n    public HandlerExecution getHandler(HttpServletRequest request) {\n        String requestUri = request.getRequestURI();\n        RequestMethod rm = RequestMethod.valueOf(request.getMethod().toUpperCase());\n        log.debug(\"requestUri : {}, requestMethod : {}\", requestUri, rm);\n        return handlerExecutions.get(new HandlerKey(requestUri, rm));\n    }\n}\n```\n\n- `AnnotationHandlerMapping` 은 이미 `getHandler` 를 구현했기에 추가 구현은 없다.\n\n이제 `DispatcherServlet` 이 두 개의 `HandlerMapping` 이 모두 동작하도록 통합하는 작업을 수행한다.\n- 초기화가 끝난 `HandlerMapping` 을 `List` 로 관리한다.\n- 요청 URL과 HTTP 메소드에 해당하는 컨트롤러를 찾아 작업을 위힘한다.\n\n```java\n@WebServlet(name = \"dispatcher\", urlPatterns = \"/\", loadOnStartup = 1)\npublic class DispatcherServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n    private static final Logger log = LoggerFactory.getLogger(DispatcherServlet.class);\n    private List<HandlerMapping> mappings = Lists.newArrayList();\n\n    private LegacyHandlerMapping lhm;\n    private AnnotationHandlerMapping ahm;\n\n    @Override\n    public void init() throws ServletException {\n        lhm = new LegacyHandlerMapping();\n        lhm.initMapping();\n        ahm = new AnnotationHandlerMapping(\"next.controller\");\n        ahm.initialize();\n\n        mappings.add(lhm);\n        mappings.add(ahm);\n    }\n\n    @Override\n    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        Object handler = getHandler(req);\n        if (handler == null) {\n            throw new IllegalArgumentException(\"존재하지 않는 URL입니다.\");\n        }\n\n        try {\n            ModelAndView mav = execute(handler, req, resp);\n            View view = mav.getView();\n            view.render(mav.getModel(), req, resp);\n        } catch (Throwable e) {\n            log.error(\"Exception : {}\", e);\n            throw new ServletException(e.getMessage());\n        }\n    }\n\n    private Object getHandler(HttpServletRequest req) {\n        for (HandlerMapping handlerMapping : mappings) {\n            Object handler = handlerMapping.getHandler(req);\n            if (handler != null) {\n                return handler;\n            }\n        }\n        return null;\n    }\n\n    private ModelAndView execute(Object handler, HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        if (handler instanceof Controller) {\n            return ((Controller)handler).execute(req, resp);\n        } else {\n            return ((HandlerExecution)handler).handle(req, resp);\n        }\n    }\n}\n```\n\n- 통합을 완료한 후 기존에 구현한 컨트롤러를 새롭게 추가한 컨트롤러 기반으로 변경한다. \n  - 기존 컨트롤러에 대한 지원도 가능하면서 새로 추가한 `AnnotationHandlerMapping` 지원도 가능해 점진적인 리팩토링 작업이 가능하다.\n- 사용자 관리 기능의 일부를 `UserController` 를 추가해 이전 작업하여 정상 동작을 확인한다.\n\n```java\npublic class UserController extends AbstractNewController {\n    private static final Logger log = LoggerFactory.getLogger(UserController.class);\n    private UserDao userDao = UserDao.getInstance();\n\n    @RequestMapping(\"/users\")\n    public ModelAndView list(HttpServletRequest req, HttpServletResponse resp) throws SQLException {\n        if (!UserSessionUtils.isLogined(req.getSession())) {\n            return jspView(\"redirect:/users/loginForm\");\n        }\n\n        ModelAndView mav = jspView(\"/user/list.jsp\");\n        mav.addObject(\"users\", userDao.findAll());\n        return mav;\n    }\n\n    @RequestMapping(\"/users/form\")\n    public ModelAndView form(HttpServletRequest req, HttpServletResponse resp) {\n        return jspView(\"/user/form.jsp\");\n    }\n\n    @RequestMapping(value = \"/users/create\", method = RequestMethod.POST)\n    public ModelAndView create(HttpServletRequest req, HttpServletResponse resp) {\n        User user = new User(\n                req.getParameter(\"userId\"),\n                req.getParameter(\"password\"),\n                req.getParameter(\"name\"),\n                req.getParameter(\"email\")\n        );\n        log.debug(\"User : {}\", user);\n        userDao.insert(user);\n        return jspView(\"redirect:/\");\n    }\n}\n```\n\n이와 같이 컨트롤러 클래스 하나로 통합 작업을 진행하여\n- 관리할 클래스 수도 적어지고,\n- 컨트롤러에서 발생하는 중복도 제거할 수 있다.\n- 또한 점진적인 이전 작업으로 서비스 중단이 없다.\n\n---\n\n## 🚩 인터페이스가 다른 경우 확장성 있는 설계\n기존 컨트롤러와 새로 추가한 컨트롤러 클래스를 보면, 메소드 인자와 반환 값이 같아 통합이 가능하다. `HandlerExecution` 클래스가 `Controller` 인터페이스를 구현하도록 리팩토링하여 `HandlerMapping` 의 `getHandler()` 메소드의 반환 값도 `Object` 가 아닌 `Controller` 로 변경할 수 있다.\n\n이로써, 캐스팅과 같은 작업이 필요없어 **소스코드가 깔끔**해지지만, **확장성이 떨어진다는 단점**이 발생한다.\n- 만약 모든 코드를 프로젝트 내에서 수정할 수 있는 권한이 있다면 하나로 통합해 관리하는 것이 가능하다.\n- 하지만 외부 라이브러리, 프레임워크를 기반으로 컨트롤러를 개발했다면 이 컨트롤러의 인터페이스를 하나로 통합하는 것은 불가능하다.\n\n\"애플리케이션을 개발하다보면, 역할은 같은데 서로 다른 인터페이스를 사용하여 통합하기 힘든 상황이 발생한다. 따라서 더 유연한 구조를 지원하려면 인터페이스 하나로 강제하는 것은 바람직하지 않다.\"\n\n서로 다른 인터페이스 통합 시, `DispatcherServlet` 의 `execute()` 메소드의 구현 코드와 같이 캐스팅을 해야 하는 상황이 종종 발생한다.\n\n```java\npublic class DispatcherServlet extends HttpServlet {\n    ...\n\n    private ModelAndView execute(Object handler, HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        if (handler instanceof Controller) {\n            return ((Controller)handler).execute(req, resp);\n        } else {\n            return ((HandlerExecution)handler).handle(req, resp);\n        }\n    }\n}\n```\n\n위 구조는 새로운 컨트롤러 유형이 추가될 경우, `else if` 절이 추가되는 구조이다. 이를 개선해 서로 간의 영향을 주지 않으면서 확장할 수 있는 방법을 강구한다. (개방 폐쇄의 원칙을 준수?)\n- 서로 다른 인터페이스를 인터페이스 하나로 연결하는 방법이 필요하다.\n  - `Controller` 인터페이스를 추가할 때도 같은 전략\n  - `Controller` 는 프레임워크 내에서 모든 컨트롤러를 추상화한 인터페이스라면, 지금은 여러 개의 프레임워크 컨트롤러를 하나로 통합해야 하는 이슈이다.\n  - 각 컨트롤러의 역할은 동일하기에, **또 하나의 추상화 단계가 필요하다**는 의미이다.\n\n`DispatcherServlet` 의 `execute()` 메소드의 구현 로직은 **컨트롤러의 인스턴스가 무엇인지를 판단하는 부분**과 **해당 컨트롤러로 캐스팅한 후 컨트롤러를 실행하는 부분**으로 나뉜다.\n- 이 부분들을 `HandlerAdapter` 인터페이스로 추상화한 후 각 컨트롤러 구현체가 `DispatcherServlet` 의 `execute()` 로직을 나눠 구현한다.\n\n```java\npublic interface HandlerAdapter {\n    boolean supports(Object handler);\n\n    ModelAndView handle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception;\n}\n```\n\n이제 각 컨트롤러에 대한 `HandlerAdapter` 를 구현한다. `Controller` 와 `HandlerExecution` 인터페이스에 대한 구현체이다.\n\n```java\npublic class ControllerHandlerAdapter implements HandlerAdapter {\n    @Override\n    public boolean supports(Object handler) {\n        return handler instanceof Controller;\n    }\n\n    @Override\n    public ModelAndView handle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {\n        return ((Controller)handler).execute(req, resp);\n    }\n}\n```\n\n```java\npublic class HandlerExecutionHandlerAdapter implements HandlerAdapter {\n    @Override\n    public boolean supports(Object handler) {\n        return handler instanceof Controller;\n    }\n\n    @Override\n    public ModelAndView handle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {\n        return ((HandlerExecution)handler).handle(req, resp);\n    }\n}\n```\n\n이제 `DispatcherServlet` 을 다음과 같이 리팩토링한다.\n\n```java\n@WebServlet(name = \"dispatcher\", urlPatterns = \"/\", loadOnStartup = 1)\npublic class DispatcherServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n    private static final Logger log = LoggerFactory.getLogger(DispatcherServlet.class);\n    private List<HandlerMapping> mappings = Lists.newArrayList();\n    private List<HandlerAdapter> handlerAdapters = Lists.newArrayList();\n\n    private LegacyHandlerMapping lhm;\n    private AnnotationHandlerMapping ahm;\n\n    @Override\n    public void init() throws ServletException {\n        lhm = new LegacyHandlerMapping();\n        lhm.initMapping();\n        ahm = new AnnotationHandlerMapping(\"next.controller\");\n        ahm.initialize();\n\n        mappings.add(lhm);\n        mappings.add(ahm);\n\n        handlerAdapters.add(new ControllerHandlerAdapter());\n        handlerAdapters.add(new HandlerExecutionHandlerAdapter());\n    }\n\n    ...\n\n    private ModelAndView execute(Object handler, HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        for (HandlerAdapter handlerAdapter : handlerAdapters) {\n            if (handlerAdapter.supports(handler)) {\n                return handlerAdapter.handle(req, resp, handler);\n            }\n        }\n        return null;\n    }\n}\n```\n\n- 이제 새로운 컨트롤러 유형이 추가되더라도, `HandlerAdapter` 구현체만 구현(반환형을 새 컨트롤러의 유형으로 수정) 후 `DispatcherServlet` 의 `HandlerAdapter` 목록에 추가하면 된다.\n\n이 같은 구조로 확장하여 다른 `HandlerAdapter` 에 영향을 미치지 않으면서 독립적인 확장이 가능해졌다.\n\n## 📕 출처\n- **자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성\n- [자바 리플렉션 개념 및 사용법 알아보기](https://kingname.tistory.com/164)"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 지금까지 학습한 내용들에 대한 점검해보는 시간이다. 🚩 자체 점검 요구사항 💡 1. 로컬 개발 환경에 톰캣 서버를 시작하면 서블릿 컨테이너의 초기화 과정이 진행된다. 초기화되는 과정에 대해 설명하라. (프로젝트의 초기화 과정) 서블릿 컨테이너는 웹 애플리케이션의 상태…","fields":{"slug":"/[NextStep]9/"},"frontmatter":{"date":"February 16, 2022","title":"📖 9장 두번째 양파 껍질을 벗기기 위한 중간 점검","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 지금까지 학습한 내용들에 대한 점검해보는 시간이다.\n\n## 🚩 자체 점검 요구사항\n💡 1. 로컬 개발 환경에 톰캣 서버를 시작하면 서블릿 컨테이너의 초기화 과정이 진행된다. 초기화되는 과정에 대해 설명하라. (프로젝트의 초기화 과정)\n- 서블릿 컨테이너는 웹 애플리케이션의 상태를 관리하는 `ServletContext` 를 생성한다.\n- `ServletContext` 가 초기화되면, 초기화 이벤트가 발생된다.\n- 등록된 `ServletContextListener` 의 콜백 메소드가 호출된다. \n  - 여기서는 `public class ContextLoaderListener implements ServletContextListener` 로 `ContextLoaderListener` 가 `ServletContextListener` 를 구현하고 있으므로, 해당 구현부의 `contextInitialized()` 가 호출된다.\n\n```java\nResourceDatabasePopulator populator = new ResourceDatabasePopulator();\npopulator.addScript(new ClassPathResource(\"jwp.sql\"));\nDatabasePopulatorUtils.execute(populator, ConnectionManager.getDataSource());\n```\n\n- `contextInitialized()` 메소드로, `jwp.sql` 파일을 실행해 DB 테이블을 초기화한다.\n- 서블릿 컨테이너는 클라이언트의 요청을 받을 `DispatcherServlet` 인스턴스를 생성하는데, `loadOnStartup` 속성에 따라 생성 시점이 결정된다. \n  - 여기서는 `loadOnStartup` 을 설정해서, 서블릿 컨테이너 시작 시점에 인스턴스를 생성한다.\n  - 6장의 설명 참고\n- `DispatcherServlet` 의 `init()` 메소드를 실행하여 `RequestMapping` 객체를 생성한다.\n  - 생성한 `RequestMapping` 의 `initMapping()` 메소드를 호출해 요청 URL과 `Controller` 인스턴스를 매핑한다.\n\n💡 2. 로컬 개발 환경에 톰캣 서버를 시작한 후 `http://localhost:8080` 으로 접근하면 질문 목록을 확인할 수 있다. URL로 접근해서 질문 목록이 보이기까지의 소스코드의 호출 순서 및 흐름을 설명하라.\n- 요청을 처리하기 전, 먼저 `web.filter` 의 `ResourceFilter` 와 `CharacterEncodingFilter` 의 `doFilter()` 메소드가 실행된다. (이 둘은 `Filter` 를 구현)\n- 필터를 거친 후, `urlPatterns=\"/\"` 인 `DispatcherServlet` 으로 요청이 전달되어 `service()` 메소드가 호출된다.\n  - 요청 URL에 대응하는 `Controller` 객체인 `HomeController` 를 반환한다.\n  - 즉, `HomeController` 에게 작업을 위임하여 `HomeController` 의 `execute()` 메소드가 실행된다.\n  - 해당 메소드는 `return jspView(\"home.jsp\").addObject(\"questions\", questionDao.findAll());` 를 반환하고, `DispatcherServlet` 는 이를 받아 `view.render(mav.getModel(), req, resp);` 한다. `JspView` 의 `render()` 는 전달된 모델 데이터를 `home.jsp` 에 전달해 HTML을 생성하고 응답한다.\n\n💡 3. 질문 목록은 정상 동작하지만 질문하기 기능은 동작하지 않는다. 이를 구현한다. 질문 추가 로직은 `QuetionDao` 클래스의 `insert()` 메소드를 활용한다. 질문하기 성공 후 질문 목록 페이지(`\"/\"`)로 이동해야 한다.\n- 먼저, 질문하기 버튼의 `href` 를 보면, `/qna/form` 으로 이동하도록 한다.\n  - 따라서, `/qna/form` 요청을 처리할 컨트롤러를 생성하고, 이를 `RequestMapping` 에 등록한다.\n  - 생성한 컨트롤러는 지금까지와 동일하게 `AbstractController` 를 상속하고, `execute()` 를 구현한다.\n  - 이 컨트롤러에서는 `/qna/form.jsp` 를 반환한다.\n- `form.jsp` 에서 글쓴이, 제목, 내용을 입력한 후, `/qna/create` 로 POST 요청을 보내도록 한다.\n  - 이를 처리할 컨트롤러를 생성하고, 매핑한다.\n  - 해당 컨트롤러에서 사용자 입력 값들(`writer` , `title` , `contents`)을 사용하여 `Question` 객체를 생성한다.\n  - 그리고 생성한 질문 객체를 `QuestionDao` 의 `insert()` 메소드를 통해 DB에 저장한다.\n  - `QuestionDao` 의 `insert()` 메소드는 DB에 인자로 받은 질문 객체를 삽입하는 역할을 수행한다.\n\n```java\npublic Question insert(Question question) {\n  JdbcTemplate jdbcTemplate = new JdbcTemplate();\n  String sql = \"INSERT INTO QUESTIONS (writer, title, contents, createdDate) VALUES (?, ?, ?, ?)\";\n  PreparedStatementCreator psc = new PreparedStatementCreator() {\n    @Override\n    public PreparedStatement createPreparedStatement(Connection con) throws SQLException {\n      PreparedStatement pstmt = con.prepareStatement(sql);\n      pstmt.setString(1, question.getWriter());\n      pstmt.setString(2, question.getTitle());\n      pstmt.setString(3, question.getContents());\n      pstmt.setTimestamp(4, new Timestamp(question.getTimeFromCreateDate()));\n      return pstmt;\n    }\n  };\n\n  KeyHolder keyHolder = new KeyHolder();\n  jdbcTemplate.update(psc, keyHolder);\n  return findById(keyHolder.getId());\n}\n```\n\n💡 4. 로그인하지 않은 사용자도 질문하기가 가능하다. 이를 로그인한 사용자만 질문이 가능하도록 수정한다. 이때 글쓴이를 입력하지 않고 로그인한 사용자 정보를 가져와 글쓴이 이름으로 사용하도록 구현한다.\n- 질문하기 버튼 클릭 시, 먼저 session으로부터 사용자 정보를 가져와 로그인된 사용자인지 확인하고, 그렇지 않은 경우에는 `/users/loginForm` 으로 보낸다.\n- `CreateQuestionController` 에서도 로그인 유무를 확인한 후 사용자가 입력한 글쓴이 정보가 아닌 session으로부터 가져온 `userId` 를 `Question` 객체에 담아 저장한다.\n\n💡 5. 질문 목록에서 제목을 클릭하면 상세보기 화면으로 이동한다. 해당 화면에서 답변 목록이 정적인 HTML로 구현되어 있는데, 이를 DB에 저정되어 있는 답변을 출력하도록 구현한다. 스클립틀릿을 사용하지 않고 JSTL과 EL만으로 구현한다.\n- 이건 뭐지\n\n💡 6. 자바 기반 웹 프로그래밍을 할 경우 한글이 깨진다. 이를 `ServletFilter` 를 활용해 해결할 수 있다. `core.web.filter.CharacterEncodingFilter` 에 annotation 설정을 통해 한글 문제를 해결한다.\n- `@WebFilter(value= {\"/*\"}, initParams=@WebInitParam(name=\"encoding\", value=\"utf-8\"))` annotation을 설정한다.\n- `request.setCharacterEncoding(DEFAULT_ENCODING);` & `response.setCharacterEncoding(DEFAULT_ENCODING);` 으로 request와 response에 대한 한글 인코딩 처리를 수행한다. (`DEFAULT_ENCODING= \"UTF-8\";`)\n- `FilterChain` 객체를 사용하여 `chain.doFilter(request, response);` 메소드를 호출한다. 이는 필터작업(한글처리)의 내용이 서버상의 다음 컴포넌트에게 계속 적용되도록 하기 위해 필요하다.\n\n💡 7. `next.web.qna` 패키지의 `ShowController` 는 멀티스레드 상황에서 문제가 발생할 가능성이 있다. 이를 문제가 발생하지 않도록 수정하고, 문제가 되는 이유를 설명하라.\n- 클래스의 인스턴스를 생성하는 것과 인스턴스를 더 이상 사용하지 않는 경우 **Garbage Collection**을 통해 메모리에서 해제하는 과정 모두 **비용이 발생**한다.\n  - 따라서, 인스턴스를 매번 생성할 필요가 없는 경우, 생성된 인스턴스를 재사용하는 것이 성능 측면에서 더 유리할 수 있다.\n  - 이는 **인스턴스가 상태 값을 유지해야 하는지 여부**에 따라 구분된다.\n  - 예로, `model` 의 `User` , `Question` , `Answer` 의 경우 클라이언트마다 서로 다른 상태 값을 가지기에, 매 요청마다 인스턴스를 생성하여 처리해야 한다.\n  - 하지만, `JdbcTemplate` , 모든 `Dao` , `Controller` 는 매 요청마다 서로 다른 상태 값을 가지지 않아 하나의 인스턴스를 재사용할 수 있다.\n- 서블릿은 서블릿 컨테이너 시작 시 인스턴스 하나를 생성해 재사용한다. `RequestMapping` 과 각 컨트롤러의 인스턴스 또한 모두 하나이다.\n  - 하지만 서블릿 컨테이너는 **멀티스레드 환경**에서 동작한다. **여러 명의 사용자가 인스턴스 하나를 재사용**한다는 의미이므로, 잘못된 구현으로 인해 버그가 발생할 수 있다. (여러 명의 사용자가 동시에 같은 코드를 실행하는 경우 발생)\n\n`ShowController` 는 인스턴스 하나를 여러 개의 스레드가 공유한다. 먼저 메모리에서 어떻게 동작하는지를 살펴본다. \n- JVM은 코드를 실행하기 위해 메모리를 스택과 힙 영역으로 나눠서 관리한다.\n  - 스택 영역은 각 메소드가 실행될 때, 메소드의 인자, 지역 변수 등을 관리하는 영역으로, 각 스레드마다 고유한 영역을 가진다.\n  - 힙 영역은 클래스의 인스턴스 상태 데이터를 관리하는 영역으로, 스레드끼리 공유할 수 있다. \n\n<img src=\"https://user-images.githubusercontent.com/33208303/158941284-62fcb070-c141-4e7f-bf51-0f6de0138806.png\" width=\"80%\">\n\n- JVM은 각 메소드별로 스택 프레임을 생성한다.\n- `ShowController` 의 `execute()` 메소드 실행 시, 해당 메소드에 대한 스택 프레임의 지역 변수 영역의 첫번째 위치에 자기 자신(`this`)에 대한 메모리 위치를 생성한다.\n- `ShowController` 의 인스턴스는 힙에 생성되며, `Question` , `List<Answer>` 필드를 가지므로 힙에 생성된 `Question` 과 `List<Answer>` 인스턴스를 가리키는 구조로 실행된다.\n\n위 구조에서, 2개의 스레드가 `execute()` 메소드를 실행하게 되면,\n- 첫 번째 스레드가 접근했을 때는 문제가 되지 않는다.\n- 하지만, 첫 번째 스레드의 작업이 완료되지 않은 시점에서 두 번째 스레드가 `execute()` 메소드를 실행하게 되면, 메모리 구조가 다음과 같이 변한다.\n\n<img src=\"https://user-images.githubusercontent.com/33208303/158941293-e16abad0-ea28-42e2-88e3-51161d13bea4.png\" width=\"80%\">\n\n- `ShowController` 가 가리키는 필드가 **1번에서 2번으로 변경**되었다. \n- 두 번째 스레드는 정상적으로 질문과 답변을 응답으로 받지만, 첫 번째 스레드는 1번 글을 보기 위한 요청을 보냈음에도 두 번째 스레드가 실행한 `execute()` 로 인해 `ShowController` 가 가리키는 필드가 2번으로 변경되어 **2번 질문과 답변을 응답**으로 받게 된다.\n- 첫 번째 스레드가 새로고침을 하게 되면 정상적인 응답을 받을 수 있어 버그가 고쳐지는 듯 하지만, 이러한 버그가 다른 중요한 기능에도 적용된다면, 큰 피해를 입을 수 있다.\n\n\"멀티스레드에서 웹 애플리케이션 개발 시 구현하고 있는 코드가 어떻게 동작하는지를 이해하는 것은 매우 중요하다.\"\n\n이러한 버그는 `Question` 과 `List<Answer>` 를 `ShowController` 의 필드가 아닌 `execute()` 메소드의 지역 변수로 구현함으로써 해결할 수 있다.\n\n```java\npublic class ShowController extends AbstractController {\n  private QuestionDao questionDao = new QuestionDao();\n  private AnswerDao answerDao = new AnswerDao();\n\n  @Override\n  public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    Long questionId = Long.parseLong(req.getParameter(\"questionId\"));\n\n    Question question = questionDao.findById(questionId);\n    List<Answer> answers = answerDao.findAllByQuestionId(questionId);\n\n    return jspView(\"/qna/show.jsp\").addObject(\"question\", question).addObject(\"answers\", answers);\n  }\n}\n```\n\n<img src=\"https://user-images.githubusercontent.com/33208303/158941298-a5032e02-b27c-4842-bd97-9e45e9760b3e.pngㄷ\" width=\"80%\">\n\n- 이와 같이 구현하면, `ShowController` 가 `Question` 과 `List<Answer>` 인스턴스에 대한 참조를 가지지 않고 `ShowController` `execute()` 메소드의 **스택 프레임의 지역 변수 영역에서 해당 인스턴스에 대한 참조**를 가진다.\n- 2개의 스레드가 접근하더라도, 서로 같은 `ShowController` 인스턴스를 참조하지만 힙 메모리에 생성된 `Question` 과 `List<Answer>` 는 서로 고유한 인스턴스를 참조하게 된다.\n\n> `QuestionDao` 와 `AnswerDao` 는 모두 상태 값을 가지지 않기에 멀티스레드 환경에서도 문제가 되지 않는다.\n\n💡 8. 상세보기 화면에서 답변하기 기능은 정상적으로 동작한다. 단, 답변 추가 시 전체 답변의 수가 증가하지 않는다. 답변을 추가하는 시점에 질문(`QUESTION` 테이블)의 답변 수(`countOfAnswer`)도 1 증가시킨다.\n- 답변을 추가하는 시점에 답변 수를 증가시켜야 하므로, `AddAnswerController` 에서 `answerDao.insert()` 이후 로직이 추가되어야 한다.\n- 먼저, `questionDao` 에 `questionId` 를 인자로 받아 질문에 대한 답변 수를 증가시키는 DB 로직을 구현한다.\n\n```java\npublic void updateCountOfAnswer(long questionId) {\n  JdbcTemplate jdbcTemplate = new JdbcTemplate();\n  String sql = \"UPDATE QUESTIONS SET countOfAnswer=countOfAnswer+1 \"\n          + \"WHERE questionId = ?\";\n\n  jdbcTemplate.update(sql, questionId);\n}\n```\n\n- 구현한 로직을 `AddAnswerController` 에서 사용하도록 한다.\n\n```java\npublic class AddAnswerController extends AbstractController {\n  ...\n\n  private QuestionDao questionDao = new QuestionDao();\n\n  @Override\n  public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    ...\n\n    Answer savedAnswer = answerDao.insert(answer);\n    questionDao.updateCountOfAnswer(savedAnswer.getQuestionId());\n    return jsonView().addObject(\"answer\", savedAnswer);\n  }\n}\n```\n\n💡 9. 해당 서비스는 모바일에서도 서비스할 계획이라 API를 추가해야 한다. `/api/qna/list` URL로 접근 시 질문 목록을 JSON 데이터로 조회할 수 있도록 구현한다.\n- 먼저, 해당 요청 URL을 처리할 컨트롤러를 생성하고, `RequestMapping` 에서 URL과 함께 매핑한다.\n- 생성한 컨트롤러는 `QuestionDao` 의 `findAll()` 결과를 `jsonView()` 로 반환한다.\n\n```java\npublic class ApiListQuestionController extends AbstractController {\n  private QuestionDao questionDao = new QuestionDao();\n\n  @Override\n  public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    return jsonView().addObject(\"question\", questionDao.findAll());\n  }\n}\n```\n\n💡 10. 상세보기 화면의 답변 목록에서 답변을 삭제해야 한다. 답변 삭제 또한 새로고침 없이 구현이 가능하도록 AJAX로 구현한다.\n- `show.jsp` 에서 답변 삭제 버튼 클릭 시 요청을 보낼 URL을 명시하고, 이를 처리할 컨트롤러를 생성한다. (매핑도 수행)\n- `webapp/js/scripts.js` 에서 삭제 버튼 클릭 시 발생시킬 이벤트를 명시하고, AJAX를 사용하여 서버에게 요청을 보낸다.\n\n```js\n$(\".qna-comment\").on(\"click\", \".form-delete\", deleteAnswer);\n\nfunction deleteAnswer(e) {\n  e.preventDefault();\n\n  var deleteBtn = $(this);\n  var queryString = deleteBtn.closest(\"form\").serialize();\n\n  $.ajax({\n    type: 'post',\n    url: \"/api/qna/deleteAnswer\",\n    data: queryString,\n    dataType: 'json',\n    error: function (xhr, status) {\n      alert(\"error\");\n    },\n    success: function (json, status) {\n      var result = json.result;\n      if (result.status) {\n        deleteBtn.closest('article').remove();\n      }\n    }\n  });\n}\n```\n\n- 컨트롤러에서는 요청으로부터 `answerId` 를 꺼내 DB에서 해당 답변을 삭제하고, 결과를 반환한다.\n- 반환받은 결과에 따라, `error` or `success` 부분을 실행하여 답변을 삭제한다.\n\n```java\npublic class DeleteAnswerController extends AbstractController {\n  private AnswerDao answerDao = new AnswerDao();\n\n  @Override\n  public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    Long answerId = Long.parseLong(req.getParameter(\"answerId\"));\n    try {\n        answerDao.delete(answerId);\n        return jsonView().addObject(\"result\", Result.ok());\n    } catch (DataAccessException e) {\n        return jsonView().addObject(\"result\", Result.fail(e.getMessage()));\n    }\n  }\n}\n```\n\n> 답변 삭제 시, `countOfAnswers` 를 -1 해주는 로직이 필요할 것 같다.\n\n💡 11. 질문 수정이 가능해야 한다. 이는 글쓴이와 로그인 사용자가 같은 경우에만 가능해야 한다.\n- 질문 수정 버튼 클릭 시, 요청을 보낼 URL을 명시하고, 질문 수정 양식으로 넘겨줄 컨트롤러 생성 후 `RequestMapping` 에서 매핑한다.\n  - 이때, 해당 질문의 정보를 GET방식으로 URL에 명시하여 전달한다. (`question.questionId`)\n- 컨트롤러에서는 글쓴이와 로그인 사용자가 동일한지 검사한다.\n  - 이때, `Question` 의 `isSameUser()` 메소드를 구현해 사용하도록 한다.\n  - 해당 메소드에는 session으로부터 얻은 로그인 사용자 정보를 인자로 넘겨주고, 이를 받은 메소드는 `writer id`를 가지고, 사용자가 동일한지 검사한다.\n- 동일한 경우에만 질문 수정 컨트롤러로 넘겨준다.\n\n```java\npublic class UpdateFormQuestionController extends AbstractController {\n  private QuestionDao questionDao = new QuestionDao();\n\n  @Override\n  public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    if (!UserSessionUtils.isLogined(req.getSession())) {\n      return jspView(\"redirect:/users/loginForm\");\n    }\n\n    Long questionId = Long.parseLong(req.getParameter(\"questionId\"));\n    Question question = questionDao.findById(questionId);\n\n    if (!question.isSameUser(UserSessionUtils.getUserFromSession(req.getSession()))) {\n      throw new IllegalStateException(\"본인이 작성한 글만 수정할 수 있습니다.\");\n    }\n\n    return jspView(\"/qna/update.jsp\").addObject(\"question\", question);\n  }\n}\n```\n\n- `/qna/update.jsp` 는 질문의 제목과 내용을 수정할 수 있는 `form` 이 있고, `/qna/update` 로 POST 요청을 보낸다.\n- 이를 처리할 컨트롤러 생성 및 매핑을 수행한다.\n- 컨트롤러에서는 `questionId` , `title` , `contents` 를 받아 질문 DB에 UPDATE한다.\n  - 먼저, `Question` 의 `update()` 메소드로 기존 질문 객체의 정보를 변경하고, `QuestionDao` 의 `update()` 메소드로 `QUESTION` DB에 있는 해당 질문을 UPDATE한다.\n\n```java\npublic class UpdateQuestionController extends AbstractController {\n  private QuestionDao questionDao = new QuestionDao();\n\n  @Override\n  public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    if (!UserSessionUtils.isLogined(req.getSession())) {\n      return jspView(\"redirect:/users/loginForm\");\n    }\n\n    long questionId = Long.parseLong(req.getParameter(\"questionId\"));\n    Question question = questionDao.findById(questionId);\n    if (!question.isSameUser(UserSessionUtils.getUserFromSession(req.getSession()))) {\n      throw new IllegalStateException(\"다른 사용자가 쓴 글을 수정할 수 없습니다.\");\n    }\n\n    Question newQuestion = new Question(question.getWriter(), req.getParameter(\"title\"), req.getParameter(\"contents\"));\n    question.update(newQuestion);\n    questionDao.update(question);\n    return jspView(\"redirect:/\");\n  }\n}\n```\n\n\"서버측에서 안전한 애플리케이션이 되도록 먼저 구현한 후 클라이언트는 추후에 고려해도 괜찮다. 그만큼 서버측에서 보안에 대한 처리를 중요하게 해야 한다.\"\n\n💡 12. 컨트롤러에서 접근하는 `QuestionDao` 와 `AnswerDao` 와 같이 DAO에서 DB 접근 로직을 구현할 때 사용하는 `JdbcTemplate` 은 인스턴스를 여러 개 생성할 필요없다. 인스턴스를 하나만 생성하도록 구현한다.\n- 위에서 언급했듯, `Dao` , `Controller` , `JdbcTemplate` 은 매번 인스턴스를 생성하지 않아도 된다. **상태 값을 가지지 않으면서 메소드만 가지는 클래스**이기 때문이다.\n- 따라서 인스턴스 하나만 생성해 재사용하도록 해야하는데, 이러한 디자인 패턴을 **싱글톤(Singleton) 패턴**이라고 한다.\n  - 구현을 위해서는 먼저 클래스의 기본 생성자를 `private` 접근 제어자로 구현하여 클래스 외부에서 인스턴스를 생성할 수 없도록 한다. (`getInstance()` 와 같은 `static` 메소드를 통해서만 생성이 가능하도록 한다.)\n\n```java\npublic class JdbcTemplate {\n  private static JdbcTemplate jdbcTemplate;\n  \n  private JdbcTemplate() {}\n  \n  public static JdbcTemplate getInstance() {\n    if (jdbcTemplate == null) {\n      jdbcTemplate = new JdbcTemplate();\n    }\n    return jdbcTemplate;\n  }\n  ...\n\n}\n```\n\n- 위와 같이 싱글톤 패턴을 구현하는 경우, 멀티스레드 환경에서 동시에 `getInstance()` 메소드를 호출해 인스턴스가 하나 이상 생성되는 문제가 발생할 수 있다. \n  - 문제가 있지만, 뒤에서 다룰 **의존성 주입(DI)**을 설명하기 위해 위와 같이 구현했다.\n\n> **싱글톤 패턴의 장단점**\n> 장점\n> - 고정된 메모리 영역을 얻으면서, 인스턴스를 한 번만 생성하기에 메모리 낭비 방지\n> - 인스턴스가 전역으로 생성되어, 다른 클래스에서의 접근 및 공유가 용이\n> - 이미 생성되어 있는 인스턴스를 사용하여 객체 로딩 시간의 감소\n> \n> 단점\n> - 싱글톤 인스턴스가 너무 많은 작업을 처리하거나, 많은 데이터를 공유하는 경우 다른 클래스의 인스터스들 간의 결합도가 너무 높아져 **“개방 폐쇄 원칙”**을 위배\n> - 이로 인해, 수정 및 유지보수의 비용이 증가하고, 멀티스레드 환경에서 동기화 처리가 없다면 인스턴스가 둘 이상 생성될 수 있는 가능성이 존재\n\n```java\nJdbcTemplate jdbcTemplate = JdbcTemplate.getInstance();\n```\n\n- `JdbcTemplate` 을 사용하는 `Dao` 에서 위와 같이 `JdbcTemplate.getInstance()` 메소드로 인스턴스를 받아 사용한다.\n\n💡 13. 질문 삭제 기능을 구현한다. 삭제가 가능한 경우는 답변이 없는 경우, 질문자와 답변자가 모두 같은 경우이다. 이 기능은 웹과 모바일 앱에서 모두 지원하려고 한다. 웹 브라우저를 통해 접근했을 때는 `JspView` 를 활용해 목록 페이지(`\"redirect:/\"`)로 이동하고, 모바일 앱을 지원하기 위해 `JsonView` 를 활용해 응답 결과를 JSON으로 전송하려고 한다. 이를 지원하려면 두 개의 컨트롤러가 필요하다. 각 컨트롤러를 구현하고, 중복을 제거한다.\n- 먼저, 삭제 버튼 클릭 시 요청을 보낼 URL을 명시하고, 이를 처리할 컨트롤러 생성 및 매핑을 수행한다.\n  - 또한, `question.questionId` 를 요청과 함께 전달하여 이를 사용할 수 있도록 한다.\n\n```java\npublic class DeleteQuestionController extends AbstractController {\n  private QnaService qnaService = QnaService.getInstance();\n\n  @Override\n  public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    if (!UserSessionUtils.isLogined(req.getSession())) {\n      return jspView(\"redirect:/users/loginForm\");\n    }\n\n    long questionId = Long.parseLong(req.getParameter(\"questionId\"));\n    try {\n      qnaService.deleteQuestion(questionId, UserSessionUtils.getUserFromSession(req.getSession()));\n      return jspView(\"redirect:/\");\n    } catch (CannotDeleteException e) {\n      return jspView(\"show.jsp\").addObject(\"question\", qnaService.findById(questionId))\n              .addObject(\"answers\", qnaService.findAllByQuestionId(questionId))\n              .addObject(\"errorMessage\", e.getMessage());\n    }\n  }\n}\n```\n\n```java\npublic class QnaService {\n  private static QnaService qnaService;\n\n  private QuestionDao questionDao = new QuestionDao();\n  private AnswerDao answerDao = new AnswerDao();\n\n  private QnaService() {}\n\n  public static QnaService getInstance() {\n    if (qnaService == null) {\n      qnaService = new QnaService();\n    }\n    return qnaService;\n  }\n\n  public Question findById(long questionId) {\n    return questionDao.findById(questionId);\n  }\n\n  public List<Answer> findAllByQuestionId(long questionId) {\n    return answerDao.findAllByQuestionId(questionId);\n  }\n\n  public void deleteQuestion(long questionId, User user) throws CannotDeleteException {\n    Question question = questionDao.findById(questionId);\n    if (question == null) {\n      throw new CannotDeleteException(\"존재하지 않는 질문입니다.\");\n    }\n\n    if (!question.isSameUser(user)) {\n      throw new CannotDeleteException(\"다른 사용자가 쓴 글을 삭제할 수 없습니다.\");\n    }\n\n    List<Answer> answers = answerDao.findAllByQuestionId(questionId);\n    if (answers.isEmpty()) {\n      questionDao.delete(questionId);\n      return;\n    }\n\n    boolean canDelete = true;\n    for (Answer answer : answers) {\n      String writer = question.getWriter();\n      if (!writer.equals(answer.getWriter())) {\n          canDelete = false;\n          break;\n      }\n    }\n\n    if (!canDelete) {\n      throw new CannotDeleteException(\"다른 사용자가 추가한 댓글이 존재해 삭제할 수 없습니다.\");\n    }\n\n    questionDao.delete(questionId);\n  }\n}\n```\n\n- `QnaService` 서비스를 생성하여 질문과 답변에 대한 처리를 수행한다.\n- 여기서는, `deleteQuestion` 에서\n  - 인자로 받은 `questionId` 에 해당하는 질문을 찾고,\n  - 해당 질문의 작성자와 인자로 받은 `user` 가 동일한지 검사한 후\n  - 해당 질문의 답변이 있는지 없는지를 판단하여 없는 경우에만 질문을 삭제하고 반환된다.\n  - 그렇지 않은 경우, 질문에 대한 답변 작성자가 사용자 본인인지 아닌지 판단하여 `canDelete` 값이 `false` 가 되면, 추가한 `CannotDeleteException` 예외를 던지도록 한다.\n- 추가적으로, 모바일 지원을 위해 `ApiDeleteQuestionController` 를 생성하고, 매핑한다.\n  - 이는 `jspView()` 가 아닌 `jsonView()` 를 반환하도록 한다.\n\n💡 14. 13번 문제를 구현할 때 단위 테스트가 가능하도록 한다. Dao를 사용하는 모든 컨트롤러 클래스는 DB가 설치되어 있어야 하며, 테이블까지 생성되어 있는 상태에서만 테스트가 가능하다. DB가 존재하지 않는 상태에서도 위 로직을 단위 테스트하려고 한다.\n- 13번 문제는 질문 삭제 기능을 웹과 모바일 모두에 제공하기 위해 2개의 `Controller` 구현 시 발생하는 중복을 어떻게 제거할 것인가에 대한 문제이다.\n  - 이 요구사항을 만족하도록 `DeleteQuestionController` , `ApiDeleteQuestionController` 클래스를 구현했다.\n  - 원래 구현대로라면, `questionId` 를 가져와 질문을 먼저 조회하고, 작성자와 수정하려는 사용자가 동일한지 검사하고, 해당 질문에 대한 답변을 조회한 뒤, 답변의 작성자까지 다 확인해야하는 과정 모두 동일하고, 응답할 뷰(`JspView` , `JsonView`)만 다르다. \n  - 이에 대한 중복을 제거해야 한다.\n\n방법은 2가지가 있다. \n- 이 두 클래스에 대한 부모 클래스를 추가해 중복 로직을 부모 클래스로 이동한 후 상속을 통해 중복을 제거한다.\n- 컨트롤러가 DAO와 의존관계를 통해 DB 접근 로직을 제거했듯 새로운 클래스를 추가해 로직 처리를 위임하여 중복을 제거한다. → **\"조합\"(composition)**\n  - 상속의 경우 **부모 클래스에 변경이 발생하면 자식 클래스에도 영향**이 생기기 때문에 상속보다는 조합을 통해 중복을 제거할 것을 추천한다.\n\n자바 진영에서는 이러한 중복 제거와 컨트롤러 역할 분리 등의 목적으로 **Service(또는 Manager)**라는 클래스를 추가해 담당하도록 구현한다. 따라서 위 문제에서는 `QnaService` 라는 클래스를 추가한다.\n\n```java\npublic class QnaService {\n  private static QnaService qnaService;\n\n  private QuestionDao questionDao = new QuestionDao();\n  private AnswerDao answerDao = new AnswerDao();\n\n  private QnaService() {}\n\n  public static QnaService getInstance() {\n    if (qnaService == null) {\n      qnaService = new QnaService();\n    }\n    return qnaService;\n  }\n\n  public Question findById(long questionId) {\n    return questionDao.findById(questionId);\n  }\n\n  public List<Answer> findAllByQuestionId(long questionId) {\n    return answerDao.findAllByQuestionId(questionId);\n  }\n\n  public void deleteQuestion(long questionId, User user) throws CannotDeleteException {\n    Question question = questionDao.findById(questionId);\n    if (question == null) {\n      throw new CannotDeleteException(\"존재하지 않는 질문입니다.\");\n    }\n\n    if (!question.isSameUser(user)) {\n      throw new CannotDeleteException(\"다른 사용자가 쓴 글을 삭제할 수 없습니다.\");\n    }\n\n    List<Answer> answers = answerDao.findAllByQuestionId(questionId);\n    if (answers.isEmpty()) {\n      questionDao.delete(questionId);\n      return;\n    }\n\n    boolean canDelete = true;\n    for (Answer answer : answers) {\n      String writer = question.getWriter();\n      if (!writer.equals(answer.getWriter())) {\n          canDelete = false;\n          break;\n      }\n    }\n\n    if (!canDelete) {\n      throw new CannotDeleteException(\"다른 사용자가 추가한 댓글이 존재해 삭제할 수 없습니다.\");\n    }\n\n    questionDao.delete(questionId);\n  }\n}\n```\n\n- 이 클래스 또한 상태 값을 가지지 않아 **싱글톤 패턴**으로 구현한다.\n- `deleteQuestion()` 가 `DeleteQuestionController` 와 `ApiDeleteQuestionController` 클래스에서의 중복 코드를 구현한 로직이다.\n  - 이렇게 컨트롤러에서의 복잡하고 중복된 로직을 서비스로 위임했기에, 컨트롤러에서는 정상적으로 삭제가 되는 경우와 에러가 발생하는 경우에 따른 처리만 구현할 수 있게 된다.\n  - 이때, `CannotDeleteException` 이라는 컴파일타임 Exception을 `throw` 한다. \n    - 이와 같이 사용자에게 예외처리를 통해 에러 메세지를 전달하거나, 다른 작업을 하도록 유도할 필요가 있는 경우 런타임 Exception보다 컴파일타임 Exception이 적합하다.\n\n> **계층형 아키텍처**\n> : 컨트롤러, 서비스, DAO 구조로 웹 애플리케이션을 개발하는 것\n\n<img src=\"https://user-images.githubusercontent.com/33208303/158941304-9bc2d1cb-4178-41fa-b0e6-911bedbb6ccd.png\" width=\"40%\">\n\n<img src=\"https://user-images.githubusercontent.com/33208303/158941301-a52cd31f-7951-4e7a-91c1-37b5a2b198b1.png\" width=\"40%\">\n\n> 질문 삭제를 담당하는 클래스들을 계층형 아키텍처로 나타내면 오른쪽과 같다.\n> 최근에는 DB 접근 로직을 담당하는 클래스 이름을 DAO 대신 **Repository**로 구현하는 경우가 많아지고 있다. Domain 객체에 해당하는 클래스는 `Question` & `Answer` 이다.\n\n💡 15. `RequestMapping` 코드를 보면, 컨트롤러 추가마다 요청 URL과 컨트롤러를 추가해야 하는 불편함이 있다. 서블릿과 같이 annotation을 활용해 설정을 추가하고 서버가 시작할 때 자동으로 매핑이 되도록 개선한다.\n- `@Controller` 설정을 통한 새로운 MVC는 다음 장에서 구현한다.\n\n## 📕 출처\n- **자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성\n- [Servlet의 한글 인코딩 처리 / Filter](https://hayden-archive.tistory.com/207)\n- [싱글톤 패턴 정리 및 예제 - 생성 패턴](https://devmoony.tistory.com/43)"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 직접 구현한 프레임워크와 라이브러리를 활용해 질문/답변 게시판을 구현해보자. 이때, AJAX 기술을 활용해 답변을 추가, 삭제하는 기능을 구현한다. 이때 서버측은 HTML이 아닌 JSON 데이터로 응답하도록 구현한다. 🚩 AJAX 활용해 답변 추가, 삭제 실습 브라우…","fields":{"slug":"/[NextStep]8/"},"frontmatter":{"date":"February 12, 2022","title":"📖 8장 AJAX를 활용해 새로고침 없이 데이터 갱신하기","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 직접 구현한 프레임워크와 라이브러리를 활용해 질문/답변 게시판을 구현해보자. 이때, AJAX 기술을 활용해 답변을 추가, 삭제하는 기능을 구현한다. 이때 서버측은 HTML이 아닌 JSON 데이터로 응답하도록 구현한다.\n\n## 🚩 AJAX 활용해 답변 추가, 삭제 실습\n**브라우저가 서버에서 HTML 응답을 받아 처리하는 과정**<br/>\n- HTML 응답을 받은 브라우저는 먼저 HTML을 라인 단위로 읽어가면서 서버에 재요청이 필요한 부분(CSS, JS, Image)을 찾아 서버에 재요청한다.\n- 서버에서 자원을 다운로드하면서 HTML DOM 트리를 구성한다.\n- 서버에서 CSS 파일을 다운로드하면 생성한 HTML DOM 트리에 CSS 스타일을 적용한 후 화면에 그린다.\n- 반복\n\n**답변 추가, 삭제 기능의 경우**<br/>\n- 화면 대부분은 변경할 필요없이 답변이 추가되는 부분, 삭제되는 부분만 처리가 필요하다.\n- 즉, 매번 서버에 요청을 보내 위 과정 전체를 실행하는 것은 비효율적이다.\n\n이 같은 단점 보완을 위해 **AJAX(Asynchronous JavaScript and XML)**가 등장했다.\n\n### 🔧 답변하기\n- 사용자가 답변하기 버튼을 클릭\n- 사용자가 입력한 데이터를 서버로 전송\n- 서버는 사용자가 입력한 데이터를 DB에 저장\n- 저장한 데이터를 클라이언트에 JSON 형태로 전송\n- 클라이언트는 서버가 응답한 JSON 데이터를 HTML로 변환해 화면에 출력\n\n먼저 답변하기 버튼 클릭을 위한 HTML 코드를 보면,\n\n```html\n<div class=\"answerWrite\">\n    <form name=\"answer\" method=\"post\">\n        <input type=\"hidden\" name=\"questionId\" value=\"${question.questionId}\">\n        <div class=\"form-group col-lg-4\" style=\"padding-top:10px;\">\n            <input class=\"form-control\" id=\"writer\" name=\"writer\" placeholder=\"이름\">\n        </div>\n        <div class=\"form-group col-lg-12\">\n            <textarea name=\"contents\" id=\"contents\" class=\"form-control\" placeholder=\"\"></textarea>\n        </div>\n        <input class=\"btn btn-success pull-right\" type=\"submit\" value=\"답변하기\" />\n        <div class=\"clearfix\" />\n    </form>\n</div>\n```\n\n- 사용자는 답변 작성 후 답변하기 버튼을 클릭한다.\n- 해당 버튼 클릭 이벤트는 `webapp/js/scripts.js` 에 구현한다.\n\n```js\n$(\".answerWrite input[type=submit]\").click(addAnswer);\n\nfunction addAnswer(e) {\n  e.preventDefault();\n  var queryString = $(\"form[name=answer]\").serialize();\n\n  $.ajax({\n    type : 'post',\n    url : '/api/qna/addAnswer',\n    data : queryString,\n    dataType : 'json',\n    error : onError,\n    success : onSuccess,\n  });\n}\n```\n\n**`addAnswer()`**\n- `submit` 버튼의 기본 동작을 막고, `<form>` 태그에 사용자가 입력한 데이터를 추출하여 `queryString` 에 담는다.\n- 그리고 jQuery의 `ajax()` 함수를 활용해 서버에 요청을 보낸다.\n  - 요청 메소드는 POST\n  - 요청 URL은 `/api/qna/addAnswer`\n  - 응답 데이터 타입은 `Json`\n  - 서버에 응답이 성공하면, `onSuccess()` 함수를 호출하면서 응답 데이터를 전달받는다.\n  - 실패하면, `onError()` 함수를 호출하면서 실패 원인을 전달받는다.\n\n위 구현으로 클라이언트에서 서버에 요청을 보내는 것은 완료했다. 이제 서버가 클라이언트의 요청을 처리해야 한다. 해당 요청을 처리할 클래스를 생성하고, 요청 URL에 대응하도록 `RequestMapping` 에 추가해준다.\n\n```java\nimport com.fasterxml.jackson.databind.ObjectMapper;\n\npublic class AddAnswerController implements Controller {\n    private static final Logger log = LoggerFactory.getLogger(AddAnswerController.class);\n\n    @Override\n    public String execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        Answer answer = new Answer(req.getParameter(\"writer\"), req.getParameter(\"contents\"), Long.parseLong(req.getParameter(\"questionId\")));\n        log.debug(\"answer : {}\", answer);\n        \n        AnswerDao answerDao = new AnswerDao();\n        Answer savedAnswer = answerDao.insert(answer);\n        ObjectMapper mapper = new ObjectMapper();\n        resp.setContentType(\"application/json;charset=UTF-8\");\n        PrintWriter out = resp.getWriter();\n        out.print(mapper.writeValueAsString(savedAnswer));\n        return null;\n    }\n}\n```\n\n- 기존의 Controller들과 달리, 응답 시 HTML이 아닌 **JSON 형태로 데이터만 전달**한다.\n  - 자바 객체의 데이터를 JSON으로 변환하기 위해 [Jackson 라이브러리](https://github.com/FasterXML/jackson)를 사용했다.\n- JSON 데이터 생성 후 바로 응답으로 보내기 때문에 이동할 페이지가 없어 `null` 을 반환한다.\n  - `DispatchServlet` 이 `null` 처리를 하지 않기에 뷰 이름이 `null` 인 경우 페이지 이동을 하지 않도록 `null` 처리를 한다.\n\n```java\npublic class DispatcherServlet extends HttpServlet {\n    ...\n\n    @Override\n    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        String requestUri = req.getRequestURI();\n        logger.debug(\"Method : {}, Request URI : {}\", req.getMethod(), requestUri);\n\n        Controller controller = rm.findController(requestUri);\n        try {\n            String viewName = controller.execute(req, resp);\n            if (viewName != null) {\n                move(viewName, req, resp);\n            }\n        } catch (Throwable e) {\n            logger.error(\"Exception : {}\", e);\n            throw new ServletException(e.getMessage());\n        }\n    }\n}\n```\n\n- 위 코드에서 볼 수 있듯, `viewName` 이 `null` 이 아닌 경우만 `move()` 하는 로직이어서 그런 것 같다.\n\n그래서 구현한 응답 결과는 다음과 같이 클라이언트 JS에 전달된다.\n\n```json\n{\"answerId\":6,\"writer\":\"재성\",\"contents\":\"테스트\",\"createdDate\":1456066690411,\"questionId\":8,\"timeFromCreateDate\":1457066690411}\n```\n\n이제, 서버에서 응답한 이 JSON 데이터를 활용해 HTML을 동적으로 생성한 후 화면에 출력하면 된다. 아까 서버 응답 성공 시, `onSuccess()` 함수가 호출되도록 구현했다. 따라서 동적으로 HTML을 생성하는 부분을 `onSuccess()` 에 구현한다.\n\n```js\nString.prototype.format = function() {\n  var args = arguments;\n  return this.replace(/{(\\d+)}/g, function(match, number) {\n    return typeof args[number] != 'undefined'\n        ? args[number]\n        : match\n        ;\n  });\n};\n...\n\nfunction onSuccess(json, status) {\n  var answerTemplate = $(\"#answerTemplate\").html();\n  var template = answerTemplate.format(json.writer, new Date(json.createdDate), json.contents, json.answerId);\n  $(\".qna-comment-slipp-articles\").prepend(template);\n}\n```\n\n- 간단한 HTML 템플릿과 이 템플릿에 값을 전달하는 `template()` 함수를 `format()` 으로 구현했기에 간단하게 구현할 수 있다.\n- 동적으로 생성한 HTML을 `qna-comment-slipp-articles` class에서 사용할 수 있도록 `prepend` 하여 답변 중 제일 위에 위치하도록 한다.\n- 아래는 HTML 템플릿이다. 템플릿과 `template()` 함수를 활용해 동적인 HTML을 간단하게 생성할 수 있다.\n\n```html\n<script type=\"text/template\" id=\"answerTemplate\">\n\t<article class=\"article\">\n\t\t<div class=\"article-header\">\n\t\t\t<div class=\"article-header-thumb\">\n\t\t\t\t<img src=\"https://graph.facebook.com/v2.3/1324855987/picture\" class=\"article-author-thumb\" alt=\"\">\n\t\t\t</div>\n\t\t\t<div class=\"article-header-text\">\n\t\t\t\t{0}\n\t\t\t\t<div class=\"article-header-time\">{1}</div>\n\t\t\t</div>\n\t\t</div>\n\t\t<div class=\"article-doc comment-doc\">\n\t\t\t{2}\n\t\t</div>\n\t\t<div class=\"article-util\">\n\t\t\t<ul class=\"article-util-list\">\n\t\t\t\t<li>\n\t\t\t\t\t<a class=\"link-modify-article\" href=\"/api/qna/updateAnswer/{3}\">수정</a>\n\t\t\t\t</li>\n\t\t\t\t<li>\n\t\t\t\t\t<form class=\"form-delete\" action=\"/api/qna/deleteAnswer\" method=\"POST\">\n\t\t\t\t\t\t<input type=\"hidden\" name=\"answerId\" value=\"{4}\" />\n\t\t\t\t\t\t<button type=\"submit\" class=\"link-delete-article\">삭제</button>\n\t\t\t\t\t</form>\n\t\t\t\t</li>\n\t\t\t</ul>\n\t\t</div>\n\t</article>\n</script>\n```\n\n### 🔧 답변 삭제하기 실습\n- 사용자가 삭제 버튼을 클릭\n- 해당 답변 삭제 요청을 서버로 전송\n- 서버는 요청에 대해 답변을 삭제\n  - 답변 삭제 성공 시, `next.model.Result` 의 `ok()` 응답\n  - 실패 시, `fail(\"error message\")` 응답\n- 클라이언트는 서버 응답 `status` 값이 `true` 인 경우 HTML에서 해당 답변의 HTML을 삭제\n  - 클릭한 삭제 버튼(`$(this)`)에서 가장 가까이 있는 `article` 태그를 찾아 삭제\n\n```js\n$(\".qna-comment\").click(deleteAnswer);\n\nfunction deleteAnswer(e) {\n  e.preventDefault();\n\n  var deleteBtn = $(this);\n  var deleteId = deleteBtn.closest(\"form\").serialize();\n\n  $.ajax({\n    type : 'post',\n    url : '/api/qna/deleteAnswer',\n    data : deleteId,\n    dataType : 'json',\n    error : onError,\n    success : function (json, status) {\n      if (json.status) {\n        deleteBtn.closest(\"article\").remove();\n      }\n    },\n  });\n}\n```\n\n- 삭제 버튼 클릭 이벤트 처리와 서버에 삭제 요청을 보내는 함수를 구현한다.\n  - `deleteBtn` 으로 클릭된 삭제 버튼을 가져오고, 이와 가장 가까운 `form` 태그의 입력 값을 가져온다. (`deleteId` 에는 `answerId` 정보)\n  - 서버 응답이 성공이면, `deleteBtn` 에서 가장 가까운 `article` 태그를 삭제한다.\n\n```java\npublic void delete(long answerId) {\n    JdbcTemplate jdbcTemplate = new JdbcTemplate();\n    String sql = \"DELETE FROM ANSWERS WHERE answerId = ?\";\n    jdbcTemplate.update(sql, answerId);\n}\n```\n\n- 답변의 삭제를 위해, `AnswerDao` 에 `delete()` 메소드를 추가 구현한다.\n\n```java\npublic class DeleteAnswerController implements Controller {\n    private static final Logger log = LoggerFactory.getLogger(AddAnswerController.class);\n\n    @Override\n    public String execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        Long deleteId = Long.parseLong(req.getParameter(\"answerId\").replaceAll(\"[{}]\", \"\"));\n        log.debug(\"deleteId : {}\", deleteId);\n\n        AnswerDao answerDao = new AnswerDao();\n        answerDao.delete(deleteId);\n\n        ObjectMapper mapper = new ObjectMapper();\n        resp.setContentType(\"application/json;charset=UTF-8\");\n        PrintWriter out = resp.getWriter();\n        out.print(mapper.writeValueAsString(Result.ok()));\n        return null;\n    }\n}\n```\n\n- `AddAnswerController` 와 동일하게 이를 처리할 컨트롤러를 생성하고 mapping한다.\n- 금방 생성한 `delete()` 메소드를 이용해 답변을 삭제하고, `Result.ok()` 메소드를 이용하여 성공적인 JSON 데이터를 응답한다.\n\n> 위와 같이 구현 시, ajax에서 `success` 로 넘어가지지 않아 화면에 JSON이 그대로 출력된다. 왜 안되는 건지 이유를 모르겠다 ...\n\n---\n\n## 🚩 MVC 프레임워크 요구사항 2단계\nMVC 프레임워크 구조에 빈틈이 보인다. `DeleteAnswerController` 코드의 문제점을 찾아보자.\n\n**첫번째 문제점**<br/>\n: JSON으로 응답을 보내는 경우 이동할 JSP 페이지가 없다보니 불필요하게 `null` 을 반환해야 한다. (AJAX에서 사용할 컨트롤러는 반환 값이 굳이 필요없다.)\n\n해당 문제점이 발생한 이뉴는 컨트롤러에서 응답할 뷰가 JSP 하나에서 JSP와 JSON 두 개로 증가했기 때문이다. 뷰가 JSP(또는 서블릿)일 경우 항상 `String` 을 반환해야 했지만, JSON일 경우는 반환 값이 필요없다. \n- 이를 해결하기 위해 `DispatcherServlet` 에서 `execute()` 메소드의 반환 값이 `null` 일 때 아무 처리도 하지 않도록 `if/else` 형태로 구현할 수 있다.\n  - 하지만 또 다른 뷰가 추가된다면, 이에 대한 예외 처리가 필요해진다. 근본적인 해결책이 되지 못한다.\n\n**두번째 문제점**<br/>\n: `AddAnswerController` 와 `DeleteAnswerController` 를 보면, 자바 객체를 JSON으로 변환하고 응답하는 부분에 중복이 발생한다. 이를 제거한다.\n\n- 중복 코드를 별도의 메소드로 분리한 후 `Abstract JsonController` 와 같은 부모 클래스를 만들어 중복을 해결할 수 있다.\n\n### 🔧 요구사항 분리 및 힌트\n- 뷰를 추상화한 인터페이스를 추가한다. (이전에 `Controller` 인터페이스를 추가한 것과 동일)\n  - `View` 라는 이름의 인터페이스를 추가한다.\n- `View` 를 구현하는 `JspView` 와 `JsonView` 를 생성해 각 기능에 맞게 구현한다.\n  - `JspView` 의 생성자는 이동할 URL을 인자로 받는다. 즉, `Controller` 의 `execute()` 메소드의 반환 값을 가진다.\n  - `JsonView` 는 생성자로 인자를 전달하지 않아도 된다.\n  - `JspView` 의 `render()` 메소드는 `DispatcherServlet` 의 `move()` 를 구현한다.\n  - `JsonView` 는 자바 객체를 JSON으로 변환 후 응답을 보내는 기능을 구현한다.\n  - `HttpServletRequest` 를 통해 전달하는 모든 값을 `Map` 에 저장한 후 JSON으로 변환한다.\n- `Controller` 인터페이스의 반환 값을 `String` 에서 `View` 로 변경한다.\n- 각 `Controller` 에서 `String` 대신 새로 생성한 `JspView` 와 `JsonView` 중 하나를 사용하도록 변경한다.\n- `DispatcherServlet` 에서 `String` 대신 `View` 인터페이스를 사용하도록 변경한다.\n\n<img src=\"../../images/classDiagram2.png\" width=\"80%\">\n\n**`HttpServletRequest` 를 사용하면서 발생하는 이슈**\n- `JsonView` 는 `HttpServletRequest` 에 추가되어 있는 모든 데이터를 JSON으로 변경한다.\n- 그런데 `HttpRequestServlet` 의 경우 서블릿 필터, 서블릿의 여러 단계를 거치면서 개발자 모르게 값이 추가될 수도 있다.\n  - 이로 인해 의도치 않은 데이터가 불필요하게 JSON으로 변경되어 클라이언트 응답으로 보내질 수도 있다.\n- `HttpRequestServlet` 를 통해 데이터를 전달하지 않고 개발자가 원하는 데이터만 뷰에 전달할 수 있도록 모델 데이터에 대한 추상화 작업을 진행한다.\n  - 모델 데이터를 `View` 아 같이 전달해야 하므로, `ModelAndView` 와 같은 이름의 클래스를 새로 추가한다.\n  - `ModelAndView` 는 `View` 와 모델 데이터를 `Map<String, Object>` 형태로 관리하도록 구현한다.\n- `View` 의 `render()` 메소드에 모델 데이터를 인자로 추가하고 `JspView` 와 `JsonView` 를 수정한다.\n  - `View` 의 `render()` 메소드 인자에 `Map` 을 추가한다.\n  - `JspView` 의 `render()` 메소드는 모델 데이터를 꺼내 `HttpServletRequest` 에 전달한다.\n  - `JsonView` 의 `render()` 메소드는 `HttpServletRequest` 메소드에서 `Map` 으로 변경하는 부분을 제거한다.\n- `Controller` 의 반환 값을 `View` → `ModelAndView`, 각 `Controller` 구현체는 `HttpServletRequest` → `ModelAndView`, `DispatcherServlet` 에서 `View` → `ModelAndView`\n\n---\n\n## 🚩 MVC 프레임워크 구현 2단계\n### 🔧 View 인터페이스 추가\nJSP와 JSON 뷰를 추상화한 `View` 인터페이스를 추가한다.\n\n```java\npublic interface View {\n    void render(HttpServletRequest req, HttpServletResponse resp) throws Exception;\n}\n```\n\n### 🔧 JspView와 JsonView 추가\nJSP에 대한 페이지 이동 처리를 담당하는 `JspView` 를 추가한다. 이는 이동할 뷰 이름을 생성자로 받은 후 `render()` 메소드 호출 시 해당 페이지로 이동하면 된다. \n- `DispatcherServlet` 의 `move()` 메소드 구현부를 `render()` 메소드에 구현한다.\n\n```java\npublic class JspView implements View {\n    private static final String DEFAULT_REDIRECT_PREFIX = \"redirect:\";\n    \n    private String viewName;\n    \n    public JspView(String viewName) {\n        if (viewName == null) {\n            throw new NullPointerException(\"viewName is null. 이동할 URL을 추가해주세요.\");\n        }\n        this.viewName = viewName;\n    }\n    \n    @Override\n    public void render(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        if (viewName.startsWith(DEFAULT_REDIRECT_PREFIX)) {\n            resp.sendRedirect(viewName.substring(DEFAULT_REDIRECT_PREFIX.length()));\n            return;\n        }\n\n        RequestDispatcher rd = req.getRequestDispatcher(viewName);\n        rd.forward(req, resp);\n    }\n}\n```\n\nJSON 데이터 응답을 담당할 `JsonView` 를 추가한다. 이동할 URL이 없으므로, `render()` 메소드는 `HttpServletRequest` 를 통해 전달되는 자바 객체를 JSON으로 변환한 후 응답하는 기능을 가지도록 구현한다.\n\n```java\npublic class JsonView implements View {\n    @Override\n    public void render(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        ObjectMapper mapper = new ObjectMapper();\n        resp.setContentType(\"application/json; charset=UTF-8\");\n        PrintWriter out = resp.getWriter();\n        out.print(mapper.writeValueAsString(createModel(req)));\n    }\n    \n    private Map<String, Object> createModel(HttpServletRequest req) {\n        Enumeration<String> names = req.getAttributeNames();\n        Map<String, Object> model = new HashMap<>();\n        while(names.hasMoreElements()) {\n            String name = names.nextElement();\n            model.put(name, req.getAttribute(name));\n        }\n        return model;\n    }\n}\n```\n\n### 🔧 Controller 반환 값을 String에서 View로 수정\n이제 `Controller` 가 `String` 을 반환하지 않고, `View` 를 반환하도록 수정한다.\n- `execute()` 의 반환형을 `View` 로 수정한다.\n\n### 🔧 Controller 구현체가 String 대신 View를 반환하도록 수정\n컴파일 에러 해결을 위해 모든 `Controller` 구현체가 `String` 대신 `View` 를 반환하도록 수정하고 반환형에 맞게 `new JspView()` or `new JsonView()` 로 수정한다.\n\n### 🔧 DispatcherServlet이 View에 작업을 위임하도록 수정\n`DispatcherServlet` 에서 `String` 값을 받아 처리하는 작업을 `View` 를 활용하도록 수정한다.\n\n```java\n@WebServlet(name = \"dispatcher\", urlPatterns = \"/\", loadOnStartup = 1)\npublic class DispatcherServlet extends HttpServlet {\n    ...\n\n    @Override\n    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        String requestUri = req.getRequestURI();\n        logger.debug(\"Method : {}, Request URI : {}\", req.getMethod(), requestUri);\n\n        Controller controller = rm.findController(requestUri);\n        try {\n            View view = controller.execute(req, resp);\n            view.render(req, resp);\n        } catch (Throwable e) {\n            logger.error(\"Exception : {}\", e);\n            throw new ServletException(e.getMessage());\n        }\n    }\n}\n```\n\n- `DispatcherServlet` 에서 `move()` 메소드를 이용해 처리하던 페이지 이동 작업을 `JspView` 의 `render()` 메소드로 이동했기에 더 깔끔해졌다.\n\n### 🔧 ModelAndView 추가를 통한 모델 추상화\n뷰를 포함해 모델 데이터에 대한 추상화를 담당하는 `ModelAndView` 를 구현한다.\n\n```java\npublic class ModelAndView {\n    private View view;\n    private Map<String, Object> model = new HashMap<>();\n    \n    public ModelAndView(View view) {\n        this.view = view;\n    }\n    \n    public ModelAndView addObject(String attributeName, Object attributeValue) {\n        model.put(attributeName, attributeValue);\n        return this;\n    }\n    \n    public Map<String, Object> getModel() {\n        return Collections.unmodifiableMap(model);\n    }\n    \n    public View getView() {\n        return view;\n    }\n}\n```\n\n- `View` 의 `render()` 메소드에 모델 데이터를 인자로 전달할 수 있도록 변경한다.\n\n```java\npublic interface View {\n    void render(Map<String, ?> model, HttpServletRequest req, HttpServletResponse resp) throws Exception;\n}\n```\n\n- `View` 인터페이스 변경에 따라 `JspView` 와 `JsonView` 또한 수정한다.\n- `Controller` 인터페이스의 반환 값 또한 `ModelAndView` 로 수정한다.\n\n```java\npublic class JspView implements View {\n  @Override\n  public void render(Map<String, ?> model, HttpServletRequest req, HttpServletResponse resp) throws Exception {\n    if (viewName.startsWith(DEFAULT_REDIRECT_PREFIX)) {\n        resp.sendRedirect(viewName.substring(DEFAULT_REDIRECT_PREFIX.length()));\n        return;\n    }\n    \n    Set<String> keys = model.keySet();\n    for (String key : keys) {\n        req.setAttribute(key, model.get(key));\n    }\n\n    RequestDispatcher rd = req.getRequestDispatcher(viewName);\n    rd.forward(req, resp);\n  }\n}\n\n...\n\npublic class JsonView implements View {\n    @Override\n    public void render(Map<String, ?> model, HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        ObjectMapper mapper = new ObjectMapper();\n        resp.setContentType(\"application/json; charset=UTF-8\");\n        PrintWriter out = resp.getWriter();\n        out.print(mapper.writeValueAsString(model));\n    }\n}\n\n... \n\npublic interface Controller {\n    ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception;\n}\n```\n\n`ModelAndView` 생성을 더 쉽게 도와주기 위해 `AbstractController` 를 추가한 후 아래 두 메소드를 제공한다.\n\n```java\npublic abstract class AbstractController implements Controller {\n    protected ModelAndView jspView(String forwardUrl) {\n        return new ModelAndView(new JspView(forwardUrl));\n    }\n\n    protected ModelAndView jsonView() {\n        return new ModelAndView(new JsonView());\n    }\n}\n```\n\n- `Controller` 구현체가 `View` 가 아닌 `ModelAndView` 를 반환하도록 수정한다.\n- 그리고 지금까지 `HttpServletRequest` 를 통해 전달하던 모델 데이터를 `ModelAndView` 를 통해 전달하도록 수정한다.\n\n```java\npublic class HomeController extends AbstractController {\n    private QuestionDao questionDao = new QuestionDao();\n    \n    @Override\n    public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        return jspView(\"home.jsp\").addObject(\"questions\", questionDao.findAll());\n    }\n}\n\n...\n\npublic class AddAnswerController extends AbstractController {\n    private static final Logger log = LoggerFactory.getLogger(AddAnswerController.class);\n    private AnswerDao answerDao = new AnswerDao();\n\n    @Override\n    public ModelAndView execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        Answer answer = new Answer(req.getParameter(\"writer\"), req.getParameter(\"contents\"),\n                Long.parseLong(req.getParameter(\"questionId\")));\n        log.debug(\"answer : {}\", answer);\n\n        Answer savedAnswer = answerDao.insert(answer);\n        return jsonView().addObject(\"answer\", savedAnswer);\n    }\n}\n```\n\n모든 `Controller` 구현체에 대한 수정이 끝나면, `DispatcherServlet` 이 `View` 가 아닌 `ModelAndView` 를 사용하도록 리팩토링한다.\n\n```java\n@WebServlet(name = \"dispatcher\", urlPatterns = \"/\", loadOnStartup = 1)\npublic class DispatcherServlet extends HttpServlet {\n    ...\n\n    @Override\n    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        ...\n\n        ModelAndView mav;\n        try {\n            mav = controller.execute(req, resp);\n            View view = mav.getView();\n            view.render(mav.getModel(), req, resp);\n        } catch (Throwable e) {\n            logger.error(\"Exception : {}\", e);\n            throw new ServletException(e.getMessage());\n        }\n    }\n}\n```\n\n## 📕 출처\n**자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성"},{"excerpt":"문제 여러 섬으로 이루어진 나라가 있다. 이 나라의 대통령은 섬을 잇는 다리를 만들겠다는 공약으로 인기몰이를 해 당선될 수 있었다. 하지만 막상 대통령에 취임하자, 다리를 놓는다는 것이 아깝다는 생각을 하게 되었다. 그래서 그는, 생색내는 식으로 한 섬과 다른 섬을 잇는 다리 하나만을 만들기로 하였고, 그 또한 다리를 가장 짧게 하여 돈을 아끼려 하였다.…","fields":{"slug":"/[BOJ]2146/"},"frontmatter":{"date":"February 10, 2022","title":"👩‍💻 2146. 다리 만들기","tags":["그래프이론","그래프탐색","BFS"]},"rawMarkdownBody":"\n## 문제\n\n여러 섬으로 이루어진 나라가 있다. 이 나라의 대통령은 섬을 잇는 다리를 만들겠다는 공약으로 인기몰이를 해 당선될 수 있었다. 하지만 막상 대통령에 취임하자, 다리를 놓는다는 것이 아깝다는 생각을 하게 되었다. 그래서 그는, 생색내는 식으로 한 섬과 다른 섬을 잇는 다리 하나만을 만들기로 하였고, 그 또한 다리를 가장 짧게 하여 돈을 아끼려 하였다.\n\n이 나라는 N×N크기의 이차원 평면상에 존재한다. 이 나라는 여러 섬으로 이루어져 있으며, 섬이란 동서남북으로 육지가 붙어있는 덩어리를 말한다.\n\n<img src=\"https://www.acmicpc.net/JudgeOnline/upload/201008/bri.PNG\" width=\"50%\">\n\n그림에서 색이 있는 부분이 육지이고, 색이 없는 부분이 바다이다. 이 바다에 가장 짧은 다리를 놓아 두 대륙을 연결하고자 한다. 가장 짧은 다리란, 다리가 격자에서 차지하는 칸의 수가 가장 작은 다리를 말한다. 다음 그림에서 두 대륙을 연결하는 다리를 볼 수 있다.\n\n<img src=\"https://www.acmicpc.net/JudgeOnline/upload/201008/b2.PNG\" width=\"50%\">\n\n물론 위의 방법 외에도 다리를 놓는 방법이 여러 가지 있으나, 위의 경우가 놓는 다리의 길이가 3으로 가장 짧다(물론 길이가 3인 다른 다리를 놓을 수 있는 방법도 몇 가지 있다). 지도가 주어질 때, 가장 짧은 다리 하나를 놓아 두 대륙을 연결하는 방법을 찾으시오.\n\n### 입력\n- 첫 줄에는 지도의 크기 N(100이하의 자연수)가 주어진다. 그 다음 N줄에는 N개의 숫자가 빈칸을 사이에 두고 주어지며, 0은 바다, 1은 육지를 나타낸다. 항상 두 개 이상의 섬이 있는 데이터만 입력으로 주어진다.\n\n### 출력\n- 첫째 줄에 가장 짧은 다리의 길이를 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Loc {\n  int x;\n  int y;\n  int cnt;\n\n  public Loc(int x, int y, int cnt) {\n      this.x = x;\n      this.y = y;\n      this.cnt = cnt;\n  }\n\n  public int getX() {\n      return x;\n  }\n\n  public int getY() {\n      return y;\n  }\n\n  public int getCnt() {\n      return cnt;\n  }\n}\n```\n\n- 각 정점별 좌표 및 현재 정점까지 오는데 필요한 다리 수를 저장하기 위해 사용하는 클래스\n\n```java\nclass Graph {\n  final int[][] graph;\n  boolean[][] discovered;\n  Queue<Loc> q = new LinkedList<>();\n  int[] w_way = { 1, 0, -1, 0 };\n  int[] y_way = { 0, 1, 0, -1 };\n  int bridge = Integer.MAX_VALUE;\n  int graph_size;\n  ...\n}\n```\n\n- 그래프의 정보를 저장하기 위해 사용하는 클래스\n\n```java\nprivate int buildBridge(int x, int y) {\n  discovered = new boolean[graph_size][graph_size];\n  q = new LinkedList<>();\n  q.add(new Loc(x, y, 0));\n  int cur_land = graph[x][y];\n  discovered[x][y] = true;\n\n  while(!q.isEmpty()) {\n    Loc loc = q.poll();\n    int cur_x = loc.getX();\n    int cur_y = loc.getY();\n    int cnt = loc.getCnt();\n\n    if (graph[cur_x][cur_y] != 0 && graph[cur_x][cur_y] != cur_land) return cnt;\n\n    for (int i = 0; i < 4; i++) {\n      int nextX = cur_x + w_way[i], nextY = cur_y + y_way[i];\n\n      if (nextX < 0 || nextX >= graph_size || nextY < 0 || nextY >= graph_size) continue;\n      if (discovered[nextX][nextY] || graph[nextX][nextY] == cur_land) continue;\n\n      discovered[nextX][nextY] = true;\n      q.add(new Loc(nextX, nextY, cnt+1));\n    }\n  }\n  return -1;\n}\n```\n\n- 구분된 대륙 정보를 가지고, 서로 다른 대륙을 잇는 다리를 놓아보는 메소드\n- `if (graph[cur_x][cur_y] != 0 && graph[cur_x][cur_y] != cur_land) return cnt;` 을 통해 서로 다른 대륙을 이은 경우 사용된 `다리 길이 + 1` 이 반환\n- 방문하지 않은 `0` , 즉 바다의 경우에만 계속 `Queue` 에 추가 \n  \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n    \n      import java.io.BufferedReader;\n      import java.io.IOException;\n      import java.io.InputStreamReader;\n      import java.util.LinkedList;\n      import java.util.Queue;\n\n      class Loc {\n          int x;\n          int y;\n          int cnt;\n\n          public Loc(int x, int y, int cnt) {\n              this.x = x;\n              this.y = y;\n              this.cnt = cnt;\n          }\n\n          public int getX() {\n              return x;\n          }\n\n          public int getY() {\n              return y;\n          }\n\n          public int getCnt() {\n              return cnt;\n          }\n      }\n\n      class Graph {\n          final int[][] graph;\n          boolean[][] discovered;\n          Queue<Loc> q = new LinkedList<>();\n          int[] w_way = { 1, 0, -1, 0 };\n          int[] y_way = { 0, 1, 0, -1 };\n          int bridge = Integer.MAX_VALUE;\n          int graph_size;\n\n          public Graph(int size) {\n              graph_size = size;\n              this.graph = new int[graph_size][graph_size];\n              discovered = new boolean[graph_size][graph_size];\n          }\n\n          public void AddElement(String line, int idx) {\n              String[] tmp = line.split(\" \");\n              for(int i = 0; i < graph_size; i++) {\n                  graph[idx][i] = Integer.parseInt(tmp[i]);\n              }\n          }\n\n          public void identifyLand() {\n              int land = 2;\n              for (int i = 0; i < graph_size; i++) {\n                  for (int j = 0; j < graph_size; j++) {\n                      if (!discovered[i][j] && graph[i][j] == 1) {\n                          fillLand(i, j, land);\n                          land++;\n                      }\n                  }\n              }\n          }\n\n          private void fillLand(int x, int y, int land) {\n              graph[x][y] = land;\n              discovered[x][y] = true;\n              q.add(new Loc(x, y, 0));\n\n              while(!q.isEmpty()) {\n                  Loc loc = q.poll();\n                  int nowX = loc.getX();\n                  int nowY = loc.getY();\n\n                  for (int i = 0; i < 4; i++) {\n                      int nextX = nowX + w_way[i], nextY = nowY + y_way[i];\n\n                      if (nextX < 0 || nextX >= graph_size || nextY < 0 || nextY >= graph_size) continue;\n                      if (discovered[nextX][nextY]) continue;\n\n                      if (graph[nextX][nextY] == 1) {\n                          graph[nextX][nextY] = land;\n                          discovered[nextX][nextY] = true;\n                          q.add(new Loc(nextX, nextY, 0));\n                      }\n                  }\n              }\n          }\n\n          public void solution() {\n              for (int i = 0; i < graph_size; i++) {\n                  for (int j = 0; j < graph_size; j++) {\n                      if (graph[i][j] > 0) {\n                          int cnt = buildBridge(i, j);\n                          if (cnt == -1) continue;\n                          bridge = Math.min(bridge, cnt);\n                      }\n                  }\n              }\n              System.out.println(bridge - 1);\n          }\n\n          private int buildBridge(int x, int y) {\n              discovered = new boolean[graph_size][graph_size];\n              q = new LinkedList<>();\n              q.add(new Loc(x, y, 0));\n              int cur_land = graph[x][y];\n              discovered[x][y] = true;\n\n              while(!q.isEmpty()) {\n                  Loc loc = q.poll();\n                  int cur_x = loc.getX();\n                  int cur_y = loc.getY();\n                  int cnt = loc.getCnt();\n\n                  if (graph[cur_x][cur_y] != 0 && graph[cur_x][cur_y] != cur_land) return cnt;\n\n                  for (int i = 0; i < 4; i++) {\n                      int nextX = cur_x + w_way[i], nextY = cur_y + y_way[i];\n\n                      if (nextX < 0 || nextX >= graph_size || nextY < 0 || nextY >= graph_size) continue;\n                      if (discovered[nextX][nextY] || graph[nextX][nextY] == cur_land) continue;\n\n                      discovered[nextX][nextY] = true;\n                      q.add(new Loc(nextX, nextY, cnt+1));\n                  }\n              }\n              return -1;\n          }\n      }\n\n      public class Main {\n          public static void main(String[] args) throws IOException {\n              BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n              int N = Integer.parseInt(br.readLine());\n\n              Graph g = new Graph(N);\n\n              String line=\"\";\n              for (int idx = 0; idx < N; idx++) {\n                  line = br.readLine();\n                  g.AddElement(line, idx);\n              }\n\n              g.identifyLand();\n\n              g.solution();\n\n              br.close();\n          }\n      }\n\t\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- `Queue` 에 데이터 추가, 삭제, 검색 시 사용하는 메소드들 중 유사한 기능을 하는 메소드들의 차이를 아래 참고 블로그에서 확인할 수 있었다.\n- 섬을 구분하여 저장하고, 이후 다리를 건설할 때 섬의 가장자리부터 탐색을 시작하면 어떨까라는 생각을 했다.\n  - 섬의 가장자리를 구분해 저장해놓고 탐색하려니, 섬의 가장자리를 구분하는 것이 문제였다.\n- 섬의 가장자리를 구분하지 않고, `브루트 포스` 처럼 모든 섬의 좌표에서 탐색하는 방식으로 변경했고, **메모리 초과**가 발생했다.\n\n```java\ngraph[nowX][nowY] = land;\ndiscovered[nowX][nowY] = true;\n\nfor (int i = 0; i < 4; i++) {\n  int nextX = nowX + w_way[i], nextY = nowY + y_way[i];\n  if (nextX >= 0 && nextX < graph_size && nextY >= 0 && nextY < graph_size && graph[nextX][nextY] == 1 && !discovered[nextX][nextY]) {\n      q.add(new Loc(nextX, nextY, 0));\n  }\n}\n\n// 위 코드를 아래와 같이 변경, 메모리 초과가 발생하지 않음\n\nif (nextX < 0 || nextX >= graph_size || nextY < 0 || nextY >= graph_size) continue;\nif (discovered[nextX][nextY]) continue;\n\nif (graph[nextX][nextY] == 1) {\n  graph[nextX][nextY] = land;\n  discovered[nextX][nextY] = true;\n  q.add(new Loc(nextX, nextY, 0));\n}\n```\n\n- 블로그를 참고하여 위의 코드 수정으로 메모리초과를 피할 수 있었는데, 논리적으로 이해가 가지 않는다...\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/2146\n\n### 참고\n- https://goodteacher.tistory.com/112\n- https://loosie.tistory.com/224"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 사용자가 입력한 데이터가 서버를 재시작해도 사라지지 않도록 데이터베이스 서버를 도입해 영구적으로 저장하고 조회하도록 한다. JDBC\n: 자바 진영이 DB와의 통신을 담당하고 지원하도록 사용하는 표준 JDK에서 제공하는  패키지의 JDBC 소스코드를 보면, 구현 코드는…","fields":{"slug":"/[NextStep]7/"},"frontmatter":{"date":"February 10, 2022","title":"📖 7장 DB를 활용해 데이터를 영구적으로 저장하기","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 사용자가 입력한 데이터가 서버를 재시작해도 사라지지 않도록 데이터베이스 서버를 도입해 영구적으로 저장하고 조회하도록 한다.\n\n**JDBC**<br/>\n: 자바 진영이 DB와의 통신을 담당하고 지원하도록 사용하는 표준\n\nJDK에서 제공하는 `java.sql` 패키지의 JDBC 소스코드를 보면, 구현 코드는 거의 없고, 인터페이스만을 정의해 제공한다. 즉 JDBC는 **통신을 위한 규약만 정의**하고, 이에 대한 **구현체는 DB를 만들어 서비스하는 회사가 제공**하도록 한다.\n\n서블릿 또한 인터페이스만 정의하고 서블릿 컨테이너를 만들어 제공하는 회사가 구현체를 제공한다.\n\n> 표준만 정의함으로써, DB에 대한 연결 설정만 변경해 다른 DB를 지원하여 소스코드의 변경을 최소화한다.\n\n## 🚩 회원 데이터를 DB에 저장하기 실습\n경량 데이터베이스 중 하나인 **H2 데이터베이스**를 사용하여 실습을 진행한다.\n(https://github.com/slipp/jwp-basic 의 step2-user-with-mvc-framework)\n\n### 🔧 실습 코드 리뷰 및 JDBC 복습\n서버가 시작하는 시점에 회원 정보를 저장할 테이블을 초기화한다. (`jwp.sql` 파일에 테이블 생성문이 있다.) 해당 sql파일은 톰캣 서버가 시작할 때 초기화하도록 `ContextLoaderListener` 클래스에 구현되어 있다.\n\n```java\n@WebListener\npublic class ContextLoaderListener implements ServletContextListener {\n    private static final Logger logger = LoggerFactory.getLogger(ContextLoaderListener.class);\n\n    @Override\n    public void contextInitialized(ServletContextEvent sce) {\n        ResourceDatabasePopulator populator = new ResourceDatabasePopulator();\n        populator.addScript(new ClassPathResource(\"jwp.sql\"));\n        DatabasePopulatorUtils.execute(populator, ConnectionManager.getDataSource());\n\n        logger.info(\"Completed Load ServletContext!\");\n    }\n\n    @Override\n    public void contextDestroyed(ServletContextEvent sce) {\n    }\n}\n```\n\n- sql 파일을 읽어 DB에 대한 초기화 작업을 위해 스프링 프레임워크에서 제공하는 기능을 활용했다.\n- 톰캣 서버가 시작할 때 `contextInitialized()` 메소드를 호출함으로써 초기화 작업을 수행한다.\n  - `ContextLoaderListener` 가 `ServletContextListener` 인터페이스를 상속받아 구현하고, `@WebListener` annotation이 있기 때문이다.\n  - 서블릿 컨테이너는 시작하는 과정에서 `ServletContextListener` 인터페이스 구현체 중 해당 annotation이 있는 구현체의 `contextInitialized()` 메소드를 호출해 초기화 작업을 진행한다.\n- `ServletContextListener` 에 대한 초기화는 서블릿 초기화보다 먼저 진행된다. 서블릿 초기화가 해당 서블릿과 관련한 초기화를 담당한다면, `ServletContextListener` 초기화는 웹 애플리케이션 전체에 영향을 미치는 초기화가 필요한 경우 활용한다.\n\n`next.dao` 패키지에 `UserDao` 클래스를 통해 DB 접근 로직을 구현한다. 자바 진영은 **DB에 대한 접근 로직 처리를 담당하는 객체를 별도로 분리해 구현**하는 것을 추천하고, 이 객체를 **DAO(Data Access Object)**라고 한다.\n\n현재는 `insert`, `findByUserId` 기능만 구현되어 있다. 기존에 `DataBase` 클래스를 사용하던 코드(ex. `DataBase.addUser`)를 `UserDao` 를 사용하도록 변경한다.\n\n```java\npublic class CreateUserController implements Controller {\n    private static final Logger log = LoggerFactory.getLogger(CreateUserController.class);\n\n    @Override\n    public String execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        User user = new User(req.getParameter(\"userId\"), req.getParameter(\"password\"), req.getParameter(\"name\"),\n                req.getParameter(\"email\"));\n        log.debug(\"User : {}\", user);\n\n        UserDao userDao = new UserDao();\n        try {\n            userDao.insert(user);\n        } catch (SQLException e) {\n            log.error(e.getMessage());\n        }\n\n        return \"redirect:/\";\n    }\n}\n```\n\n- 다른 기능들도 위와 같은 방식으로 변경할 수 있는데, 한 가지 불편한 점이 있다.\n  - `UserDao` 의 모든 메소드가 `SQLException` 을 `throw` 하고 있기에 컴파일 에러 방지를 위해 `try - catch` 구문으로 감싸줘야 한다.\n\n### 🔧 회원 목록 실습\n`UserDao` 는 회원 전체 목록을 조회하는 `findAll()` 메소드를 구현한다.\n\n### 🔧 개인정보 수정 실습\n`UPDATE` SQL문을 활용해 개인정보를 수정할 수 있는 기능을 추가하고 컨트롤러가 추가한 메소드를 사용하도록 리팩토링한다.\n\n---\n\n## 🚩 DAO 리팩토링 실습\n`UserDao` 에는 많은 중복 코드가 발생한다. 아래 중복 작업들을 공통 라이브러리로 만들어 중복을 제거할 수 있다.\n- `Connection` 관리\n- `Statement` 관리\n- `ResultSet` 관리\n- 파라미터 Setting\n- 트랜잭션 관리\n\n**`SQLException` 에 대한 처리**<br/>\n`UserDao` 리팩토링 시 고려해야 할 사항 중 하나이다. 이는 **컴파일타임 Exception** 이므로, 매번 `try - catch` 절을 통해 예외 처리를 수행해야 한다. 하지만 이 예외를 catch해도 로그를 남기는 것외에 별다른 처리가 떠오르지 않는다. \n\n> 자바의 첫 등장 시, 특히 **컴파일타임 Exception**은 예외 처리를 컴파일 시점에 할 수 있다는 장점으로 많이 활용되었다. 하지만 너무 무분별하게 사용되어 불필요하게 `try - catch` 절로 감싸야 하며, 소스코드의 가독성을 떨어뜨리는 주범이 되고 있다. (`expert one-on-one J2EE 설계와 개발` 책에서 컴파일타임, 런타임 Exception에 대한 가이드라인을 제시한다.)\n> 해당 가이드라인을 참고하여, 대부분의 경우 런타임 Exception을 사용하도록 한다.\n\n위 기준으로 판단했을 때, 컴파일타임 Exception을 잘못 사용한 예가 JDBC의 `SQLException` 이다. 따라서 JDBC에 대한 공통 라이브러리를 만드는 과정에서 `SQLException` 을 **런타임 Exception**으로 변환해 소스코드의 가독성을 떨어뜨리지 않도록 한다.\n\n### 🔧 요구사항\nJDBC에 대한 공통 라이브러리를 만들어 개발자가 \"SQL 쿼리, 쿼리에 전달할 인자, SELECT 구문의 경우 조회한 데이터 추출\" 구현에만 집중하도록 한다. 또한 `SQLException` 을 런타임 Exception으로 변환하도록 한다.\n\n### 🔧 요구사항 분리 및 힌트\n- INSERT, UPDATE 쿼리는 비슷하기에 해당 메소드들의 중복 제거 작업을 진행한다.\n  - `setValuesForInsert(User, PreparedStatement)`\n  - `createQueryForInsert()`\n  - `setValuesForUpdate(User, PreparedStatement)`\n  - `createQueryForUpdate()`\n- 분리한 메소드 중 변화가 발생하지 않는 부분(공통 라이브러리로 구현할 코드)을 새로운 클래스로 추가한 후 이동한다.\n  - `insert()` 와 `update()` 메소드별로 `InsertJdbcTemplate`, `UpdateJdbcTemplate` 과 같이 새로운 클래스를 추가한 후 해당 메소드 코드들을 이동한다.\n  - 이동 시, 인자로 `UserDao` 를 전달한다. 앞에서 추출한 메소드가 `private` 접근 제어자라면 `default` 접근 제어자로 리팩토링한다.\n  - `UserDao` 의 `insert()` 가 `InsertJdbcTemplate` 의 `insert()` , `update()` 가 `UpdateJdbcTemplate` 의 `update()` 메소드를 호출하도록 리팩토링한다.\n- `InsertJdbcTemplate` , `UpdateJdbcTemplate` 이 `UserDao` 에 대한 의존관계를 가진다. 이를 제거한다.\n  - 의존관계를 가지는 이유는 `setValueFor...()`, `createQueryFor...())` 때문이다. 이 두 메소드를 추상 메소드로 구현하고 `UserDao` 의 `insert(), update()` 메소드에서 2개의 추상 메소드를 구현한다. 구현은 **익명 클래스로 구현**한다.\n  > **익명 클래스**<br/>\n  > : Inner class로, 이름이 없는 클래스이다. 클래스 정의와 동시에 객체를 생성할 수 있고 인터페이스와 클래스 모두 익명 클래스로 객체를 생성할 수 있다.\n  > 이는 프로그램 내에서 한번만 객체로 만드는데 사용되는 클래스를 굳이 정의할 필요가 없기 때문에 사용하고, `Runnable` 이나 `Event Listener` 객체를 생성하는데 주로 사용된다.\n- `InsertJdbcTemplate` 과 `UpdateJdbcTemplate` 은 구현 부분이 다르지 않다. 하나만 사용하도록 리팩토링한다. \n  - 해당 클래스들의 메소드를 `setValues()` 와 `createQuery()` 로 Rename하고 한 클래스만 사용하도록 리팩토링한다.\n- `JdbcTemplate` 은 아직도 `User` 와 의존관계를 가지므로, 다른 `DAO` 클래스에서 재사용할 수 없다. 따라서 의존관계를 제거한다.\n  - `User` 값은 `UserDao` 에서만 사용되기에 `JdbcTemplate` 의 `update()` 메소드에 굳이 전달할 필요가 없다.\n  - SQL 쿼리와 같이 변경되는 부분을 추상 메소드가 아닌 메소드의 인자로 전달한다.\n- 위와 같은 방식으로 `SelectJdbcTemplate` 을 생성해 반복 코드를 분리한다.\n  - `ResultSet` 데이터를 자바 객체로 변환하는 부분을 추가한다.\n  - `setValues()` 와 `mapRow()` 메소드와 같은 2개의 추상 메소드를 가져야 한다. `mapRow()` 메소드의 반환 값은 `Object` 여야 한다.\n- `JdbcTemplate` 와 `SelectJdbcTemplate` 에 중복 코드가 있어, 한 개의 클래스로 리팩토링해 클래스 하나에서 모든 작업을 하도록 한다.\n- 통합했을 경우, SELECT가 아닌 다른 쿼리들이 불필요한 `mapRow()` 메소드를 반드시 구현해야 한다. `setValues()` , `mapRow()` 2개의 메소드를 분리해 독립적으로 전달할 수 있도록 한다.\n  - 인터페이스를 추가해 인자로 전달하도록 리팩토링한다.\n- `SQLException` 을 런타임 Exception으로 변환해 `throw` 하도록 한다. 그리고 사용한 자원의 반납을 `close()` 메소드가 아닌 `try-with-resources` 구문으로 해결한다.\n  - `RuntimeException` 을 상속하는 커스텀 Exception을 추가하고 `SQLException` 을 새로 추가한 커스텀 Exception을 변환해 `throw` 하도록 구현한다.\n- SELECT 쿼리의 경우 조회한 데이터를 캐스팅하는 부분이 있는데 이를 캐스팅하지 않도록 개선한다.\n  - `RowMapper`(`mapRow()` 의 인터페이스)에 자바 제너릭을 적용해 공통 라이브러리를 개선한다.\n- 각 쿼리에 전달할 인자를 자바의 가변인자를 통해 전달할 수 있는 메소드를 추가한다.\n  - 가변인자 문법으로 인자를 동적으로 전달한다. (`void update(String sql, Object ... values)`)\n  - `PreparedStatement` 에 값 전달 시 `setObject()` 메소드를 활용한다.\n- `PreparedStatementSetter`, `RowMapper` 인터페이스를 구현하는 부분을 **람다 표현식**을 활용하도록 리팩토링한다.\n\n---\n\n## 🚩 DAO 리팩토링 및 설명\n### 🔧 메소드 분리\n중복 코드를 제거하기 위해 **Extract Method 리팩토링**을 통해 메소드를 분리한다. 개발자가 DB 접근 로직을 구현할 때 매번 구현해야 하는 부분과 그렇지 않은 부분을 기준으로 메소드를 분리한다. \n\n먼저 `insert()` 와 `update()` 메소드를 다음과 같이 `setValuesFor...()` & `createQueryFor...()` 로 분리한다.\n\n```java\npublic void setValuesForInsert(User user, PreparedStatement pstmt) throws SQLException {\n    pstmt.setString(1, user.getUserId());\n    pstmt.setString(2, user.getPassword());\n    pstmt.setString(3, user.getName());\n    pstmt.setString(4, user.getEmail());\n}\n\npublic String createQueryForInsert() {\n    return \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n}\n```\n\n### 🔧 클래스 분리\n메소드를 분리하니 공통 라이브러리로 구현할 부분(`insert()` 메소드)과 개발자가 매번 구현해야 할 부분(`createQueryFor...()`, `setValuesFor...()` 메소드)이 나눠지는 것을 확인할 수 있다. 공통 라이브러리로 구현할 부분을 새로운 클래스(`InsertJdbcTemplate`)로 이동한다. 이후, `UserDao` 의 `insert()` 메소드를 새 클래스로 이동한다.\n\n```java\npublic void insert(User user, UserDao userDao) throws SQLException {\n    Connection con = null;\n    PreparedStatement pstmt = null;\n    try {\n        con = ConnectionManager.getConnection();\n        String sql = userDao.createQueryForInsert();\n        pstmt = con.prepareStatement(sql);\n        userDao.setValuesForInsert(user, pstmt);\n\n        pstmt.executeUpdate();\n    } finally {\n        if (pstmt != null) {\n            pstmt.close();\n        }\n\n        if (con != null) {\n            con.close();\n        }\n    }\n}\n```\n\n```java\npublic class UserDao {\n    public void insert(User user) throws SQLException {\n        InsertJdbcTemplate jdbcTemplate = new InsertJdbcTemplate();\n        jdbcTemplate.insert(user, this);\n    }\n\n    public void setValuesForInsert(User user, PreparedStatement pstmt) throws SQLException {\n        pstmt.setString(1, user.getUserId());\n        pstmt.setString(2, user.getPassword());\n        pstmt.setString(3, user.getName());\n        pstmt.setString(4, user.getEmail());\n    }\n\n    public String createQueryForInsert() {\n        return \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n    }\n}\n```\n\n- 새로 생성한 `InsertJdbcTemplate` 에는 `createQueryForInsert()` 와 `setValuesForInsert()` 가 없으므로, 컴파일 에러가 발생한다.\n  - `UserDao` 인스턴스를 인자로 전달해 메소드 호출이 가능하게 한다.\n- `UserDao` 의 `insert()` 메소드가 `InsertJdbcTemplate` 의 `insert()` 메소드를 호출하도록 변경하고, `createQueryForInsert()` , `setValuesForInsert()` 메소드는 `InsertJdbcTemplate` 의 `insert()` 메소드가 접근 가능하도록 `default` 접근 제어자로 변경한다.\n  - `insert()` 호출 시 필요한 `UserDao` 는 현재 자기 자신이므로 `this` 로 전달할 수 있다.\n  - 그런데, `InsertJdbcTemplate` 이 `UserDao` 와 다른 패키지에 존재한다면, 접근 제어자를 `public` 으로 해야한다.\n\n`update()` 메소드도 동일하게 진행한다.\n\n### 🔧 `UserDAO` 와 `InsertJdbcTemplate` 의 의존관계 분리\n새로 추가한 `...JdbcTemplate` 은 `UserDao` 와 의존관계를 가져 `UserDao` 가 아닌 다른 곳에서는 사용할 수 없다. 따라서 의존관계를 제거해야 한다.\n\n이를 위해서는 `createQueryFor...()` 와 `setValuesFor...()` 메소드가 `...JdbcTemplate` 에 존재하도록 해야 한다.\n- 하지만 `...JdbcTemplate` 가 아닌 `UserDao` 가 메소드의 구현을 담당해야 하므로, 두 개의 메소드를 추상 메소드로 구현하고, `...JdbcTemplate` 을 추상 클래스로 변경한다. (이로써, 의존관계를 제거해 컴파일 에러를 방지할 수 있다.)\n\n```java\npublic abstract class InsertJdbcTemplate {\n    public void insert(User user) throws SQLException {\n        Connection con = null;\n        PreparedStatement pstmt = null;\n        try {\n            con = ConnectionManager.getConnection();\n            String sql = createQueryForInsert();\n            pstmt = con.prepareStatement(sql);\n            setValuesForInsert(user, pstmt);\n\n            pstmt.executeUpdate();\n        } finally {\n            if (pstmt != null) {\n                pstmt.close();\n            }\n\n            if (con != null) {\n                con.close();\n            }\n        }\n    }\n\n    public abstract String createQueryForInsert();\n\n    public abstract void setValuesForInsert(User user, PreparedStatement pstmt) throws SQLException;\n}\n```\n\n```java\npublic class UserDao {\n    public void insert(User user) throws SQLException {\n        InsertJdbcTemplate jdbcTemplate = new InsertJdbcTemplate() {\n            public void setValuesForInsert(User user, PreparedStatement pstmt) throws SQLException {\n                pstmt.setString(1, user.getUserId());\n                pstmt.setString(2, user.getPassword());\n                pstmt.setString(3, user.getName());\n                pstmt.setString(4, user.getEmail());\n            }\n\n            public String createQueryForInsert() {\n                return \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n            }\n        };\n        jdbcTemplate.insert(user);\n    }\n}\n```\n\n- 먼저 `...JdbcTemplate` 을 추상 클래스로 구현하고, 사용하는 메소드들을 추상 메소드로 구현하게 되면, `UserDao` 에서는 해당 추상 메소드들에 대한 구현이 없이 `...JdbcTemplate` 인스턴스를 생성할 수 없다.\n  - 추상 메소드를 구현하는 방법은 아래의 방법이 있다.\n    - `...JdbcTemplate` 을 상속하는 새로운 클래스를 추가\n    - 익명 클래스를 추가\n  - `...JdbcTemplate` 인스턴스를 생성할 때만 사용하기에 **익명 클래스를 추가하는 방식**으로 구현한다.\n\n> 반복적으로 발생하는 중복 로직을 상위 클래스가 구현하고 변화가 발생하는 부분만 추상 메소드로 만들어 구현하는 디자인 패턴을 **\"템플릿 메소드 패턴\"** 이라고 한다.\n\n`update()` 메소드도 동일하게 진행한다.\n\n### 🔧 `InsertJdbcTemplate` 과 `UpdateJdbcTemplate` 통합\n공통 라이브러리를 담당할 클래스를 분리하니 `InsertJdbcTemplate` 의 `insert()` 와 `UpdateJdbcTemplate` 의 `update()` 의 구현이 다르지 않음을 확인할 수 있다. 굳이 두 클래스로 분리할 필요가 없다는 의미이므로, `JdbcTemplate` 이라는 클래스로 합치고 `update()` 메소드 하나를 사용하도록 변경한다.\n\n```java\npublic abstract class JdbcTemplate {\n    public void update(User user) throws SQLException {\n        Connection con = null;\n        PreparedStatement pstmt = null;\n\n        try {\n            con = ConnectionManager.getConnection();\n            String sql = createQuery();\n            pstmt = con.prepareStatement(sql);\n            setValues(user, pstmt);\n\n            pstmt.executeUpdate();\n        } finally {\n            if (pstmt != null) {\n                pstmt.close();\n            }\n\n            if (con != null) {\n                con.close();\n            }\n        }\n    }\n\n    public abstract String createQuery();\n\n    public abstract void setValues(User user, PreparedStatement pstmt) throws SQLException;\n}\n```\n\n- `InsertJdbcTemplate` 과 `UpdateJdbcTemplate` 을 하나의 클래스로 합한 후, 메소드 이름 또한 변경한다.\n- 그리고, `UserDao` 의 `insert()` 와 `update()` 가 위 클래스를 사용하도록 변경한다.\n\n```java\npublic void insert(User user) throws SQLException {\n    JdbcTemplate jdbcTemplate = new JdbcTemplate() {\n        public void setValues(User user, PreparedStatement pstmt) throws SQLException {\n            pstmt.setString(1, user.getUserId());\n            pstmt.setString(2, user.getPassword());\n            pstmt.setString(3, user.getName());\n            pstmt.setString(4, user.getEmail());\n        }\n\n        public String createQuery() {\n            return \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n        }\n    };\n    jdbcTemplate.update(user);\n}\n\npublic void update(User user) throws SQLException {\n    JdbcTemplate jdbcTemplate = new JdbcTemplate() {\n        public void setValues(User user, PreparedStatement pstmt) throws SQLException {\n            pstmt.setString(1, user.getPassword());\n            pstmt.setString(2, user.getName());\n            pstmt.setString(3, user.getEmail());\n            pstmt.setString(4, user.getUserId());\n        }\n\n        public String createQuery() {\n            return \"UPDATE USERS SET password=?, name=?, email=? WHERE userId=?\";\n        }\n    };\n    jdbcTemplate.update(user);\n}\n```\n\n### 🔧 `User` 의존관계 제거 및 SQL 쿼리 인자로 전달\n아직도 `JdbcTemplate` 은 `User` 에 대한 의존관계가 남아있다. 이렇게 되면, 위 코드들을 Post나 다른 DB에 접근해 쿼리를 날려야 하는 경우에는 `JdbcTemplate` 을 사용할 수 없다는 것이다. 그런데, `JdbcTemplate` 의 `update()` 를 보면, `setValues()` 메소드를 통해 `User` 인자를 전달하지 않고 `UserDao` 의 `insert()` , `update()` 메소드의 `User` 인스턴스에 직접 접근하도록 리팩토링하여 해당 의존관계를 제거할 수 있을 것 같다.\n- `UserDao` 에서 `User` 객체를 `JdbcTemplate` 으로 전달하고, 이를 다시 `UserDao` 로 전달하여 작업을 처리하고 있는 불필요한 상황이다.\n\n```java\npublic class UserDao {\n    public void insert(User user) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate() {\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n                pstmt.setString(1, user.getUserId());\n                pstmt.setString(2, user.getPassword());\n                pstmt.setString(3, user.getName());\n                pstmt.setString(4, user.getEmail());\n            }\n\n            public String createQuery() {\n                return \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n            }\n        };\n        jdbcTemplate.update();\n    }\n}\n```\n\n```java\npublic abstract class JdbcTemplate {\n    public void update() throws SQLException {\n        ...\n\n        try {\n            ...\n\n            setValues(pstmt);\n            ...\n\n        } finally {\n            ...\n        }\n    }\n    \n    ...\n\n    public abstract void setValues(PreparedStatement pstmt) throws SQLException;\n}\n```\n\n- 이제 `JdbcTemplate` 에서는 `User` 객체를 직접적으로 사용하지 않는다. 이렇게 의존관계를 제거해 다른 경우에도 사용할 수 있게 되었다.\n\n한 단계 더 개선을 위해서, `createQuery()` 를 보면 SQL 쿼리는 굳이 추상 메소드를 생성해 전달하지 않고 `JdbcTemplate` 의 `update()` 메소드 인자로 전달하는 것이 사용성 측면에서 좋아보인다. \n\n> 리팩토링 과정에서 컴파일 에러가 발생하지 않도록 하기 위해 기존 `update()` 메소드는 그대로 두고, 새로운 메소드를 추가한다.\n\n```java\npublic abstract class JdbcTemplate {\n    ...\n    \n    public void update2(String sql) throws SQLException {\n        Connection con = null;\n        PreparedStatement pstmt = null;\n\n        try {\n            con = ConnectionManager.getConnection();\n            pstmt = con.prepareStatement(sql);\n            setValues(pstmt);\n\n            pstmt.executeUpdate();\n        } finally {\n            if (pstmt != null) {\n                pstmt.close();\n            }\n\n            if (con != null) {\n                con.close();\n            }\n        }\n    }\n    ...\n\n}\n```\n\n- 이제 `update2()` 메소드를 사용하도록 변경한다. 이렇게 되면, `createQuery()` 추상 메소드는 이제 사용하지 않으므로 제거할 수 있다.\n- `update2()` 메소드를 사용하도록 모든 변환을 마친 후에, 테스트 또한 정상적으로 수행된다면 `update()` 로 바꾼다.\n\n### 🔧 SELECT 문에 대한 리팩토링\nSELECT에 대해서도 앞의 과정과 유사하게 리팩토링을 진행할 수 있다. 다만, 조회한 데이터를 자바 객체로 변환하는 부분이 필요하다. 이를 `mapRow()` 라는 메소드를 추상 메소드로 추가해 구현한다.\n\n```java\npublic abstract class SelectJdbcTemplate {\n    public List select(String sql) throws SQLException {\n        Connection con = null;\n        PreparedStatement pstmt = null;\n        ResultSet rs = null;\n\n        try {\n            con = ConnectionManager.getConnection();\n            pstmt = con.prepareStatement(sql);\n            setValues(pstmt);\n\n            rs = pstmt.executeQuery();\n\n            List<Object> result = new ArrayList<>();\n            if (rs.next()) {\n                result.add(mapRow(rs));\n            }\n\n            return result;\n        } finally {\n            if (rs != null) {\n                rs.close();\n            }\n            if (pstmt != null) {\n                pstmt.close();\n            }\n            if (con != null) {\n                con.close();\n            }\n        }\n    }\n    \n    public Object selectForObject(String sql) throws SQLException {\n        List result = select(sql);\n        if (result.isEmpty()) {\n            return null;\n        }\n        return result.get(0);\n    }\n\n    public abstract void setValues(PreparedStatement pstmt) throws SQLException;\n    \n    public abstract Object mapRow(ResultSet rs) throws SQLException;\n}\n```\n\n- `select` 는 여러 데이터를 조회한 경우(`UserDao` 의 `findAll()`)에 대한 구현이고, `selectForObject` 는 하나의 데이터를 조회한 경우(`UserDao` 의 `findById()`)에 대한 구현이다.\n  - 하나의 데이터를 조회하는 경우 `select()` 를 활용하여 결과값 중 하나만 가져오는 형태로 구현하였다.\n- `User` 객체에 종속되지 않고 다른 경우에도 사용할 수 있도록 하기 위해 `Object` 객체로 반환하도록 한다.\n\n```java\npublic class UserDao {\n    public List<User> findAll() throws SQLException {\n        SelectJdbcTemplate selectJdbcTemplate = new SelectJdbcTemplate() {\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n            }\n\n            public Object mapRow(ResultSet rs) throws SQLException {\n                return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"), rs.getString(\"email\"));\n            }\n        };\n\n        String sql = \"SELECT userId, password, name, email FROM USERS\";\n        return (List<User>)selectJdbcTemplate.select(sql);\n    }\n\n    public User findByUserId(String userId) throws SQLException {\n        SelectJdbcTemplate selectJdbcTemplate = new SelectJdbcTemplate() {\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n                pstmt.setString(1, userId);\n            }\n\n            public Object mapRow(ResultSet rs) throws SQLException {\n                return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"), rs.getString(\"email\"));\n            }\n        };\n\n        String sql = \"SELECT userId, password, name, email FROM USERS WHERE userid=?\";\n        return (User)selectJdbcTemplate.selectForObject(sql);\n    }\n}\n```\n\n- `findAll()` 의 경우는 쿼리에 전달할 인자가 없으므로 추상 메소드의 구현을 비워두었다.\n\n> 교재에서, `SelectJdbcTemplate` 의 각 메소드에 `@SuppressWarnings(\"rawtypes\")` 라는 annotation이 있다. 없어도 테스트를 정상 수행하지만 알아보자면,\n> **컴파일러가 정적분석을 진행할 때 오류가 아니라고 마킹하는 용도**라고 한다. 쉽게 말해 컴파일 경고를 없애준다. 그리고 `rawtypes` 의 의미는 원시 유형 사용법과 관련된 경고를 억제해주는 역할이라고 한다.\n\n### 🔧 `JdbcTemplate` 과 `SelectJdbcTemplate` 통합\n이제 모든 SQL에 대한 처리를 공통 라이브러리를 활용해 수행할 수 있다. 그런데 개발자 입장에서는 API 사용 시 여러 개의 클래스보다 클래스 하나를 제공하는 것이 더 좋을 것이다. 그래서 중복 코드가 존재하는 `JdbcTemplate` 과 `SelectJdbcTemplate` 을 하나로 통합하도록 한다.\n\n```java\npublic abstract class JdbcTemplate {\n    public void update(String sql) throws SQLException {\n        Connection con = null;\n        PreparedStatement pstmt = null;\n\n        try {\n            con = ConnectionManager.getConnection();\n            pstmt = con.prepareStatement(sql);\n            setValues(pstmt);\n\n            pstmt.executeUpdate();\n        } finally {\n            if (pstmt != null) {\n                pstmt.close();\n            }\n\n            if (con != null) {\n                con.close();\n            }\n        }\n    }\n\n    public List select(String sql) throws SQLException {\n        Connection con = null;\n        PreparedStatement pstmt = null;\n        ResultSet rs = null;\n\n        try {\n            con = ConnectionManager.getConnection();\n            pstmt = con.prepareStatement(sql);\n            setValues(pstmt);\n\n            rs = pstmt.executeQuery();\n\n            List<Object> result = new ArrayList<>();\n            if (rs.next()) {\n                result.add(mapRow(rs));\n            }\n\n            return result;\n        } finally {\n            if (rs != null) {\n                rs.close();\n            }\n            if (pstmt != null) {\n                pstmt.close();\n            }\n            if (con != null) {\n                con.close();\n            }\n        }\n    }\n\n    public Object selectForObject(String sql) throws SQLException {\n        List result = select(sql);\n        if (result.isEmpty()) {\n            return null;\n        }\n        return result.get(0);\n    }\n\n    public abstract void setValues(PreparedStatement pstmt) throws SQLException;\n\n    public abstract Object mapRow(ResultSet rs) throws SQLException;\n}\n```\n\n- `JdbcTemplate` 으로 통합하기 위해, `SelectJdbcTemplate` 의 메소드들을 이동시킨다.\n\n```java\npackage next.dao;\n\nimport java.sql.PreparedStatement;\nimport java.sql.ResultSet;\nimport java.sql.SQLException;\nimport java.util.List;\n\nimport core.jdbc.JdbcTemplate;\nimport next.model.User;\n\npublic class UserDao {\n    public void insert(User user) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate() {\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n                ...\n\n            }\n\n            public Object mapRow(ResultSet rs) throws SQLException {\n                return null;\n            }\n        };\n        String sql = \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n        jdbcTemplate.update(sql);\n    }\n\n    public void update(User user) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate() {\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n                ...\n\n            }\n\n            public Object mapRow(ResultSet rs) throws SQLException {\n                return null;\n            }\n        };\n        String sql = \"UPDATE USERS SET password=?, name=?, email=? WHERE userId=?\";\n        jdbcTemplate.update(sql);\n    }\n\n    public List<User> findAll() throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate() {\n            ...\n\n        };\n\n        String sql = \"SELECT userId, password, name, email FROM USERS\";\n        return (List<User>)jdbcTemplate.select(sql);\n    }\n\n    public User findByUserId(String userId) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate() {\n            ...\n\n        };\n\n        String sql = \"SELECT userId, password, name, email FROM USERS WHERE userid=?\";\n        return (User)jdbcTemplate.selectForObject(sql);\n    }\n}\n```\n\n- `UserDao` 에서, `insert()` 와 `update()` 도 `mapRow()` 에 대한 구현이 필요한데, 일단은 `null` 을 반환하도록 한다.\n\n### 🔧 인터페이스 추가를 통한 문제점 해결\n`UserDao` 의 `insert()` 와 `update()` 는 `mapRow()` 를 사용하지 않는데도, 구현해야 하는 문제가 생겼다. 이러한 원인은 **`JdbcTemplate` 의 추상 메소드의 변화 시점이 항상 같이 변화하도록 의존관계가 생겼기 때문**이다.\n- 이를 해결하기 위해 `setValues()` 와 `mapRow()` 메소드를 분리해 서로간의 의존관계를 제거해야 한다.\n  - 두 개의 추상 메소드를 같은 클래스가 가지도록 하지 않고, 각각의 추상 메소드를 인터페이스를 통해 분리하도록 한다.\n\n```java\npublic interface PreparedStatementSetter {\n    void setValues(PreparedStatement pstmt) throws SQLException;\n}\n```\n\n```java\npublic interface RowMapper {\n    Object mapRow(ResultSet rs) throws SQLException;\n}\n```\n\n```java\npublic class JdbcTemplate {\n    public void update(String sql, PreparedStatementSetter pss) throws SQLException {\n        ...\n\n        try {\n            con = ConnectionManager.getConnection();\n            pstmt = con.prepareStatement(sql);\n            pss.setValues(pstmt);\n\n            pstmt.executeUpdate();\n        } finally {\n            ...\n\n        }\n    }\n\n    public List select(String sql, PreparedStatementSetter pss, RowMapper rowMapper) throws SQLException {\n        ...\n\n        try {\n            con = ConnectionManager.getConnection();\n            pstmt = con.prepareStatement(sql);\n            pss.setValues(pstmt);\n\n            rs = pstmt.executeQuery();\n\n            List<Object> result = new ArrayList<>();\n            if (rs.next()) {\n                result.add(rowMapper.mapRow(rs));\n            }\n\n            return result;\n        } finally {\n            ...\n\n        }\n    }\n\n    public Object selectForObject(String sql, PreparedStatementSetter pss, RowMapper rowMapper) throws SQLException {\n        List result = select(sql, pss, rowMapper);\n        ...\n\n    }\n}\n```\n\n```java\npublic class UserDao {\n    public void insert(User user) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        PreparedStatementSetter pss = new PreparedStatementSetter() {\n            @Override\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n                pstmt.setString(1, user.getUserId());\n                pstmt.setString(2, user.getPassword());\n                pstmt.setString(3, user.getName());\n                pstmt.setString(4, user.getEmail());\n            }\n        };\n\n        String sql = \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n        jdbcTemplate.update(sql, pss);\n    }\n\n    public void update(User user) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        PreparedStatementSetter pss = new PreparedStatementSetter() {\n            @Override\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n                pstmt.setString(1, user.getPassword());\n                pstmt.setString(2, user.getName());\n                pstmt.setString(3, user.getEmail());\n                pstmt.setString(4, user.getUserId());\n            }\n        };\n\n        String sql = \"UPDATE USERS SET password=?, name=?, email=? WHERE userId=?\";\n        jdbcTemplate.update(sql, pss);\n    }\n\n    public List<User> findAll() throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        PreparedStatementSetter pss = new PreparedStatementSetter() {\n            @Override\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n\n            }\n        };\n\n        RowMapper rowMapper = new RowMapper() {\n            @Override\n            public Object mapRow(ResultSet rs) throws SQLException {\n                return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"),\n                        rs.getString(\"email\"));\n            }\n        };\n\n        String sql = \"SELECT userId, password, name, email FROM USERS\";\n        return (List<User>)jdbcTemplate.select(sql, pss, rowMapper);\n    }\n\n    public User findByUserId(String userId) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        PreparedStatementSetter pss = new PreparedStatementSetter() {\n            @Override\n            public void setValues(PreparedStatement pstmt) throws SQLException {\n                pstmt.setString(1, userId);\n            }\n        };\n        RowMapper rowMapper = new RowMapper() {\n            @Override\n            public Object mapRow(ResultSet rs) throws SQLException {\n                return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"),\n                        rs.getString(\"email\"));\n            }\n        };\n\n        String sql = \"SELECT userId, password, name, email FROM USERS WHERE userid=?\";\n        return (User)jdbcTemplate.selectForObject(sql, pss, rowMapper);\n    }\n}\n```\n\n- `setValues()` 와 `mapRow()` 추상 메소드를 인터페이스로 분리해 담당하므로, `JdbcTemplate` 은 더이상 추상 클래스일 필요가 없다.\n- 메소드 하나만 가지는 인터페이스를 생성한 후 필요에 따라 메소드의 인자로 전달해 문제를 해결했다.\n  - 변화 시점이 다른 부분을 서로 다른 인터페이스로 분리했고, 이렇게 사용한 인터페이스를 **콜백 인터페이스**라고 한다.\n\n### 🔧 런타임 Exception 추가 및 AutoCloseable 활용한 자원 반환\n또 다른 문제점 중 하나가 모든 메소드가 컴파일타임 Exception인 `SQLException` 을 `throw` 한다는 것이다. 런타임 Exception을 추가해 이 문제를 해결한다. 이를 위해 `RuntimeException` 을 상속하는 새로운 Exception을 추가한다.\n\n```java\npublic class DataAccessException extends RuntimeException {\n    public DataAccessException() {\n        super();\n    }\n\n    public DataAccessException(String msg, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {\n        super(msg, cause, enableSuppression, writableStackTrace);\n    }\n\n    public DataAccessException(String msg, Throwable cause) {\n        super(msg, cause);\n    }\n\n    public DataAccessException(String msg) {\n        super(msg);\n    }\n\n    public DataAccessException(Throwable cause) {\n        super(cause);\n    }\n}\n```\n\n- 이제 생성한 `DataAccessException` 을 `JdbcTemplate` 에서 사용하게 함으로써, 더 이상 `SQLException` 을 처리하지 않도록 할 수 있다.\n\n```java\npublic class JdbcTemplate {\n    public void update(String sql, PreparedStatementSetter pss) throws DataAccessException {\n        ...\n\n        try {\n            ...\n\n        } catch (SQLException e) {\n            throw new DataAccessException(e);\n        } finally {\n            if (pstmt != null) {\n                try {\n                    pstmt.close();\n                } catch (SQLException e) {\n                    throw new DataAccessException(e);\n                }\n            }\n\n            if (con != null) {\n                try {\n                    con.close();\n                } catch (SQLException e) {\n                    throw new DataAccessException(e);\n                }\n            }\n        }\n    }\n\n    public List select(String sql, PreparedStatementSetter pss, RowMapper rowMapper) throws DataAccessException {\n        ...\n\n        try {\n            ...\n\n        } catch (SQLException e) {\n            throw new DataAccessException(e);\n        } finally {\n            if (rs != null) {\n                try {\n                    rs.close();\n                } catch (SQLException e) {\n                    throw new DataAccessException(e);\n                }\n            }\n            if (pstmt != null) {\n                try {\n                    pstmt.close();\n                } catch (SQLException e) {\n                    throw new DataAccessException(e);\n                }\n            }\n            if (con != null) {\n                try {\n                    con.close();\n                } catch (SQLException e) {\n                    throw new DataAccessException(e);\n                }\n            }\n        }\n    }\n    ...\n\n}\n```\n\n- 런타임 Exception으로 변경했지만, `finally` 절에서 자원 반환의 복잡도가 너무 높다. \n  - 이때 사용하는 `close()` 메소드에 대한 호출은 자바 7 버전부터 제공하는 `java.io.AutoCloseable` 인터페이스를 활용하여 해결할 수 있다.\n  - 해당 인터페이스를 구현하는 클래스는 `try-with-resources` 구문을 활용해 자원을 자동으로 반납할 수 있다.\n\n```java\npublic class JdbcTemplate {\n    public void update(String sql, PreparedStatementSetter pss) throws DataAccessException {\n        try (Connection conn = ConnectionManager.getConnection(); PreparedStatement pstmt = conn.prepareStatement(sql);) {\n            pss.setValues(pstmt);\n\n            pstmt.executeUpdate();\n        } catch (SQLException e) {\n            throw new DataAccessException(e);\n        }\n    }\n\n    public List select(String sql, PreparedStatementSetter pss, RowMapper rowMapper) throws DataAccessException {\n        try (Connection conn = ConnectionManager.getConnection(); PreparedStatement pstmt = conn.prepareStatement(sql);) {\n            ResultSet rs = null;\n            \n            pss.setValues(pstmt);\n            pss.setValues(pstmt);\n\n            rs = pstmt.executeQuery();\n\n            List<Object> result = new ArrayList<>();\n            if (rs.next()) {\n                result.add(rowMapper.mapRow(rs));\n            }\n\n            return result;\n        } catch (SQLException e) {\n            throw new DataAccessException(e);\n        }\n    }\n    ...\n\n}\n```\n\n- 위와 같이 `try` 구문 안에 사용할 자원을 추가하여 구현한다.\n  - `try` 에 명시된 자원들은 코드가 `try` 를 벗어나는 경우 `try-with-resources` 가 `close` 를 호출한다.\n  - 하지만 모든 자원에 대해 호출해주는 것은 아니고, `AutoCloseable` 을 구현하는 자원에 대해서만 가능하다.\n  - 위에서는 `Connection` 과 `PreparedStatement` 가 이를 구현하고 있어 자원의 자동 반납이 가능하다.\n\n```java\npublic interface Connection  extends Wrapper, AutoCloseable {...}\n\npublic interface PreparedStatement extends Statement {...}\n\npublic interface Statement extends Wrapper, AutoCloseable {...}\n```\n\n### 🔧 제너릭(`generic`)을 활용한 개선\n`JdbcTemplate` 을 사용해보니, 데이터 조회 시 매번 캐스팅을 해야 된다. 이를 자바의 제너릭을 적용해 개선한다.\n\n```java\npublic interface RowMapper<T> {\n    T mapRow(ResultSet rs) throws SQLException;\n}\n```\n\n- 자바의 제너릭 문법을 사용하도록 수정 후 `JdbcTemplate` 에도 제너릭 구문을 추가한다.\n\n```java\npublic class JdbcTemplate {\n    ...\n\n    public <T> List<T> select(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper) throws DataAccessException {\n        try (Connection conn = ConnectionManager.getConnection(); PreparedStatement pstmt = conn.prepareStatement(sql);) {\n            ...\n\n            List<T> result = new ArrayList<T>();\n            if (rs.next()) {\n                result.add(rowMapper.mapRow(rs));\n            }\n\n            return result;\n        } catch (SQLException e) {\n            throw new DataAccessException(e);\n        }\n    }\n\n    public <T> T selectForObject(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper) throws SQLException {\n        List<T> result = select(sql, pss, rowMapper);\n        if (result.isEmpty()) {\n            return null;\n        }\n        return result.get(0);\n    }\n}\n```\n\n- 제너릭을 사용하도록 하여 캐스팅 없이 데이터 조회가 가능하도록 한다.\n\n```java\npublic class UserDao {\n    ...\n\n    public List<User> findAll() throws SQLException {\n        ...\n\n        RowMapper<User> rowMapper = new RowMapper<User>() {\n            @Override\n            public User mapRow(ResultSet rs) throws SQLException {\n                return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"),\n                        rs.getString(\"email\"));\n            }\n        };\n        ...\n\n    }\n\n    public User findByUserId(String userId) throws SQLException {\n        ...\n\n        RowMapper<User> rowMapper = new RowMapper<User>() {\n            @Override\n            public User mapRow(ResultSet rs) throws SQLException {\n                return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"),\n                        rs.getString(\"email\"));\n            }\n        };\n        ...\n\n    }\n}\n```\n\n> **제너릭**<br/>\n> 데이터 형식에 의존하지 않고, 하나의 값이 여러 다른 데이터 타입들을 가질 수 있도록 하는 방법으로, 클래스 내부에서 지정하는 것이 아닌 외부에서 사용자에 의해 지정하는 것이다.\n\n### 🔧 가변인자를 활용해 쿼리에 인자 전달하기\n쿼리에 값 전달 시 `PreparedStatementSetter` 를 이용할 수도 있지만, 가변 인자를 활용할 수도 있다. \n\n```java\npublic class JdbcTemplate {\n    public void update(String sql, Object... parameters) throws DataAccessException {\n        try (Connection conn = ConnectionManager.getConnection(); PreparedStatement pstmt = conn.prepareStatement(sql);) {\n            for (int i = 0; i < parameters.length; i++) {\n                pstmt.setObject(i + 1, parameters[i]);\n            }\n\n            pstmt.executeUpdate();\n        } catch (SQLException e) {\n            throw new DataAccessException(e);\n        }\n    }\n}\n```\n\n```java\npublic class UserDao {\n    public void insert(User user) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        String sql = \"INSERT INTO USERS VALUES (?, ?, ?, ?)\";\n        jdbcTemplate.update(sql, user.getUserId(), user.getPassword(), user.getName(), user.getEmail());\n    }\n\n    public void update(User user) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        String sql = \"UPDATE USERS SET password=?, name=?, email=? WHERE userId=?\";\n        jdbcTemplate.update(sql, user.getPassword(), user.getName(), user.getEmail(), user.getUserId());\n    }\n}\n```\n\n- 가변 인자는 말 그대로 인자로 전달할 값의 개수가 동적으로 변경되는 경우 유용하다.\n\n### 🔧 람다를 활용한 구현\n한 단계 더 개선 된 리팩토링을 위해서는 자바 8 버전에서 추가된 **람다 표현식**을 사용할 수 있다. `UserDao` 에서 `RowMapper` 에 대한 익명 클래스를 생성하던 부분을 람다를 활용하여 깔끔하게 구현한다.\n\n```java\npublic class UserDao {\n    public List<User> findAll() throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        String sql = \"SELECT userId, password, name, email FROM USERS\";\n        return (List<User>)jdbcTemplate.select(sql, (ResultSet rs) -> {\n            return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"),\n                    rs.getString(\"email\"));\n        });\n    }\n\n    public User findByUserId(String userId) throws SQLException {\n        JdbcTemplate jdbcTemplate = new JdbcTemplate();\n        String sql = \"SELECT userId, password, name, email FROM USERS WHERE userid=?\";\n        return (User)jdbcTemplate.selectForObject(sql, (ResultSet rs) -> {\n            return new User(rs.getString(\"userId\"), rs.getString(\"password\"), rs.getString(\"name\"), rs.getString(\"email\"));\n        }, userId);\n    }\n}\n```\n\n- 람다 사용 전에는 `RowMapper` 에 대한 익명 클래스를 만들어 전달했지만 람다를 사용할 경우 메소드에 전달할 인자와 메소드 구현부만 구현해 위와 같이 전달한다.\n  - 람다 사용을 위해서는 `RowMapper` 와 같이 인터페이스의 메소드가 하나만 존재해야 한다. (`mapRow()`)\n  - 람다 표현식으로 사용할 인터페이스라고 지정하려면, `@FunctionalInterface` annotation을 추가한다.\n\n```java\n@FunctionalInterface\npublic interface RowMapper<T> {\n    T mapRow(ResultSet rs) throws SQLException;\n}\n```\n\n## 📕 출처\n- **자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성\n- [익명 클래스](https://codechacha.com/ko/java-anonymous-class/)\n- [try-with-resources](https://velog.io/@sa1341/AutoCloseable-%ED%81%B4%EB%9E%98%EC%8A%A4)\n- [제너릭](https://st-lab.tistory.com/153)"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 4장 실습에서 언급했던 쿠키의 문제점에 대해 살펴보고, 이를 해결하기 위한 세션을 직접 구현해보자. 또한 자바 진영뿐 아니라 모든 엉어가 제공하는 웹 프레임워크는 MVC 패턴을 기반으로 하고 있으므로, MVC 패턴 기반으로 프레임워크를 구현해보자. 🚩 서블릿/JSP로…","fields":{"slug":"/[NextStep]6/"},"frontmatter":{"date":"February 09, 2022","title":"📖 6장 서블릿/JSP를 활용해 동적인 웹 애플리케이션 개발하기","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 4장 실습에서 언급했던 쿠키의 문제점에 대해 살펴보고, 이를 해결하기 위한 세션을 직접 구현해보자. 또한 자바 진영뿐 아니라 모든 엉어가 제공하는 웹 프레임워크는 MVC 패턴을 기반으로 하고 있으므로, MVC 패턴 기반으로 프레임워크를 구현해보자.\n\n## 🚩 서블릿/JSP로 회원관리 기능 다시 개발하기\n[Github 저장소 코드](https://github.com/SeongukBaek/jwp-basic.git)를 가져와 실습한다.\n\n### 🔧 서블릿/JSP 복습\n`step0-getting-started` 브랜치 소스코드를 열어보면 이미 회원가입(서블릿)과 사용자 목록(JSP) 기능이 구현되어 있다.\n\n**회원가입**<br/>\n`/user/form.html` 을 그대로 사용한다. 사용자 입력 데이터를 추출한 후 DB에 추가하는 방식이다.\n\n```java\n@WebServlet(\"/user/create\")\npublic class CreateUserServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n    private static final Logger log = LoggerFactory.getLogger(CreateUserServlet.class);\n\n    @Override\n    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        User user = new User(req.getParameter(\"userId\"), req.getParameter(\"password\"), req.getParameter(\"name\"),\n                req.getParameter(\"email\"));\n        log.debug(\"user : {}\", user);\n        DataBase.addUser(user);\n        resp.sendRedirect(\"/user/list\");\n    }\n}\n```\n\n- 회원가입을 완료한 후 사용자 목록 출력을 위해 `\"/user/list\"` 로 리다이렉트한다.\n\n**사용자 목록**<br/>\n회원가입할 때 저장한 사용자 목록을 조회한 후 JSP에 `\"users\"` 라는 이름으로 전달한다. 이전 장에서는 `ListUserController` 에서 동적으로 `StringBuilder` 를 이용하여 HTML을 생성했지만 여기서는 JSP파일로 위임한다.\n\n```java\n@WebServlet(\"/user/list\")\npublic class ListUserServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n\n    @Override\n    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        req.setAttribute(\"users\", DataBase.findAll());\n        RequestDispatcher rd = req.getRequestDispatcher(\"/user/list.jsp\");\n        rd.forward(req, resp);\n    }\n}\n```\n\n- 서블릿도 동적으로 HTML을 생성하기 위해서는 5장의 `ListUserController` 와 같은 방식으로 구현해야 한다.\n- 이와 같은 서블릿의 한계를 극복하기 위해 JSP가 등장했다.\n\n**JSP**<br/>\n정적인 HTML은 그대로 두고, 동적으로 변경되는 부분만을 구현한다. **Java Server Page**라는 이름답게 자바 구문을 그대로 사용할 수 있다. (스크립틀릿(scriptlet)이라고 하는 `<% %>` 내에 사용)\n\n하지만 웹 애플리케이션 요구사항의 복잡도가 증가하면서 많은 로직이 구현되다보니 JSP를 유지보수하기 어려워졌다. 이를 해결하기 위해 **JSTL(JavaServer Pages Standard Tag Library)과 EL(Expression Language)가 등장**했고, JSP의 복잡도를 낮추기 위해 **MVC 패턴을 적용한 프레임워크가 등장**했다.\n\n```java\n<%@ taglib prefix=\"c\" uri=\"http://java.sun.com/jsp/jstl/core\"%>\n\n...\n\n<c:forEach items=\"${users}\" var=\"user\" varStatus=\"status\">\n    <tr>\n        <th scope=\"row\">${status.count}</th>\n        <td>${user.userId}</td>\n        <td>${user.name}</td>\n        <td>${user.email}</td>\n        <td><a href=\"#\" class=\"btn btn-success\" role=\"button\">수정</a>\n        </td>\n    </tr>\n</c:forEach>\n\n...\n\n```\n\n- JSTL과 EL을 활용하면 JSP에서 자바 구문을 완전히 제거할 수 있다.\n  - 사실 이를 위해서는 JSP가 출력할 데이터를 전달해줄 **컨트롤러가 필요**하다. 즉, **MVC 패턴 기반으로 개발**해야 자바 구문을 완전히 제거할 수 있다는 것이다.\n  - 여기서는 사용자 목록 조회 후 JSP에 전달했던 `ListUserServlet` 이 MVC 패턴에서 컨트롤러 역할을 수행한다.\n\n### 🔧 개인정보수정 실습\n개인정보수정 기능에 대한 구현을 시작한다. 수정 화면은 회원가입 화면인 `/user/form.html` 을 재사용한다.\n\n`list.jsp`\n```html\n<li><a href=\"../user/updateForm.jsp\" role=\"button\">개인정보수정</a></li>\n```\n\n- 먼저, 개인정보수정 버튼 클릭 시, `../user/updateForm.jsp` 로 이동\n\n`updateForm.jsp`\n```html\n<div class=\"container\" id=\"main\">\n    <div class=\"col-md-6 col-md-offset-3\">\n        <div class=\"panel panel-default content-main\">\n            <form name=\"question\" method=\"post\" action=\"/user/update\">\n                <input type=\"hidden\" name=\"userId\" value=\"${user.userId}\" />\n                <div class=\"form-group\">\n                    <label>사용자 아이디</label>\n                    ${user.userId}\n                </div>\n                <div class=\"form-group\">\n                    <label for=\"password\">비밀번호</label>\n                    <input type=\"password\" class=\"form-control\" id=\"password\" name=\"password\" placeholder=\"Password\">\n                </div>\n                <div class=\"form-group\">\n                    <label for=\"name\">이름</label>\n                    <input class=\"form-control\" id=\"name\" name=\"name\" placeholder=\"Name\" value=\"${user.name}\">\n                </div>\n                <div class=\"form-group\">\n                    <label for=\"email\">이메일</label>\n                    <input type=\"email\" class=\"form-control\" id=\"email\" name=\"email\" placeholder=\"Email\" value=\"${user.email}\">\n                </div>\n                <button type=\"submit\" class=\"btn btn-success clearfix pull-right\">개인정보수정</button>\n                <div class=\"clearfix\" />\n            </form>\n        </div>\n    </div>\n</div>\n```\n\n- `/user/update` 로 POST 요청을 보내는 `form` 태그 생성\n\n`UpdateUserServlet.java`\n```java\n@WebServlet(value = {\"/user/update\", \"/user/updateForm\"})\npublic class UpdateUserServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n    private static final Logger log = LoggerFactory.getLogger(CreateUserServlet.class);\n\n    @Override\n    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        RequestDispatcher rd = req.getRequestDispatcher(\"/user/updateForm.jsp\");\n        rd.forward(req, resp);\n    }\n\n    @Override\n    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        User user = DataBase.findUserById(req.getParameter(\"userId\"));\n\n        User updateUser = new User(req.getParameter(\"userId\"), req.getParameter(\"password\"), req.getParameter(\"name\"),\n                req.getParameter(\"email\"));\n        log.debug(\"updateUser : {}\", updateUser);\n        user.update(updateUser);\n        resp.sendRedirect(\"/user/list\");\n    }\n}\n```\n\n- `/user/updateForm` 로의 GET 요청과, `/user/update` 로의 POST 요청을 처리하기 위해 `value` 사용\n- `userId` 를 이용해 DB에서 사용자를 조회하고 입력받은 값으로 `user.update` 수행\n\n`model/User.java`\n```java\npublic void update(User updateUser) {\n    this.password = updateUser.password;\n    this.name = updateUser.name;\n    this.email = updateUser.email;\n}\n```\n\n- `userId` 를 제외한 사용자 정보 update를 위한 메소드\n\n### 🔧 로그인/로그아웃 기능 실습\n현재 상태가 로그인 상태이면 상단 메뉴가 **로그아웃**, **개인정보수정**이 나타나야 하며, 로그아웃 상태이면 **로그인**, **회원가입**이 나타나야 한다.\n\n`LoginController.java`\n```java\n@WebServlet(value = { \"/users/login\", \"/users/loginForm\" })\npublic class LoginController extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n\n    @Override\n    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        forward(\"/user/login.jsp\", req, resp);\n    }\n\n    @Override\n    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        String userId = req.getParameter(\"userId\");\n        String password = req.getParameter(\"password\");\n        User user = DataBase.findUserById(userId);\n        if (user == null) {\n            req.setAttribute(\"loginFailed\", true);\n            forward(\"/user/login.jsp\", req, resp);\n            return;\n        }\n\n        if (user.matchPassword(password)) {\n            HttpSession session = req.getSession();\n            session.setAttribute(UserSessionUtils.USER_SESSION_KEY, user);\n            resp.sendRedirect(\"/\");\n        } else {\n            req.setAttribute(\"loginFailed\", true);\n            forward(\"/user/login.jsp\", req, resp);\n        }\n    }\n\n    private void forward(String forwardUrl, HttpServletRequest req, HttpServletResponse resp)\n            throws ServletException, IOException {\n        RequestDispatcher rd = req.getRequestDispatcher(forwardUrl);\n        rd.forward(req, resp);\n    }\n}\n```\n\n- `/user/login`, `/user/loginForm` 에 대한 응답을 처리한다.\n- **GET 요청**의 경우, `/user/login.jsp` 를 반환하고, \n- **POST 요청**의 경우, 입력된 id를 이용해 DB에 존재하는 사용자인지 조회하고, 비밀번호까지 일치하면 `HttpSession` 으로 session에 사용자를 추가한다.\n  - `USER_SESSION_KEY` : 저장하는 `user` 를 식별하기 위한 키\n  - 나중에 암호화를 하게 된다면, \n    - ID를 먼저 조회해서 DB에 저장된 PWD를 가져오고, \n    - 사용자 입력 값을 암호화한 값과의 비교를 수행\n\n`include/~.jspf`\n```java\n<c:if test=\"${not empty sessionScope.user}\">\n    <ul class=\"nav dropdown-menu\">\n        <li><a href=\"/users/profile?userId=${sessionScope.user.userId}\"><i class=\"glyphicon glyphicon-user\" style=\"color:#1111dd;\"></i> Profile</a></li>\n        <li class=\"nav-divider\"></li>\n        <li><a href=\"#\"><i class=\"glyphicon glyphicon-cog\" style=\"color:#dd1111;\"></i> Settings</a></li>\n    </ul>\n</c:if>\n\n<c:choose>\n<c:when test=\"${not empty sessionScope.user}\">\n<li><a href=\"/users/logout\" role=\"button\">로그아웃</a></li>\n<li><a href=\"/users/updateForm?userId=${sessionScope.user.userId}\" role=\"button\">개인정보수정</a></li>\n</c:when>\n<c:otherwise>\n<li><a href=\"/users/loginForm\" role=\"button\">로그인</a></li>\n<li><a href=\"/users/form\" role=\"button\">회원가입</a></li>\n<!--\n<li><a href=\"#loginModal\" role=\"button\" data-toggle=\"modal\">로그인</a></li>\n<li><a href=\"#registerModal\" role=\"button\" data-toggle=\"modal\">회원가입</a></li>\n-->\n</c:otherwise>\n</c:choose>\n```\n\n- JSP에서 session에 로그인한 사용자 여부를 체크하고 JSTL에서 분기문 처리하여 로그인한 사용자와 그렇지 않은 사용자가 사용할 수 있는 기능을 다르게 처리한다.\n\n`LogoutController.java`\n```java\n@WebServlet(\"/users/logout\")\npublic class LogoutController extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n\n    @Override\n    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        HttpSession session = req.getSession();\n        session.removeAttribute(UserSessionUtils.USER_SESSION_KEY);\n        resp.sendRedirect(\"/\");\n    }\n}\n```\n\n- `HttpSession` 을 날려버리는 것으로 로그아웃을 구현한다.\n\n### 🔧 회원 목록 및 개인정보 수정 보안 강화 실습\n로그인한 사용자만이 사용자 목록 조회가 가능해야 하며, 개인정보 수정은 자신의 정보만 수정 가능해야 한다.\n\n`ListUserController.java`\n```java\nif (!UserSessionUtils.isLogined(req.getSession())) {\n    resp.sendRedirect(\"/users/loginForm\");\n    return;\n}\n```\n\n- session에 로그인한 사용자가 있는지 확인한다.\n  - 로그인한 사용자가 없는 경우, `loginForm` 으로 리다이렉션한다.\n\n`UpdateUserController.java`\n```java\nif (!UserSessionUtils.isSameUser(req.getSession(), user)) {\n    throw new IllegalStateException(\"다른 사용자의 정보를 수정할 수 없습니다.\");\n}\n```\n\n- 정보 수정 시, 수정하려는 사용자가 현재 로그인한 본인인지 확인한다.\n\n`UserSessionUtils.java`\n```java\npublic class UserSessionUtils {\n    public static final String USER_SESSION_KEY = \"user\";\n\n    public static User getUserFromSession(HttpSession session) {\n        Object user = session.getAttribute(USER_SESSION_KEY);\n        if (user == null) {\n            return null;\n        }\n        return (User) user;\n    }\n\n    public static boolean isLogined(HttpSession session) {\n        if (getUserFromSession(session) == null) {\n            return false;\n        }\n        return true;\n    }\n\n    public static boolean isSameUser(HttpSession session, User user) {\n        if (!isLogined(session)) {\n            return false;\n        }\n\n        if (user == null) {\n            return false;\n        }\n\n        return user.isSameUser(getUserFromSession(session));\n    }\n}\n```\n\n- `getUserFromSession` : session을 인자로 받아 session으로부터 `user` attribute를 추출한다.\n- `isLogined` : `getUserFromSession` 메소드를 호출하여 그 반환값으로 로그인한 사용자가 있는지 확인한다.\n- `isSameUser` : `isLogined` 메소드 호출로 session에 로그인한 사용자가 있는지와 인자로 받은 `user` 의 `null` 여부를 확인하여 `boolean` 값을 반환한다. ??? (왜 인자가 1개만 넘겨주지)\n\n---\n\n## 🚩 세션(`HttpSession`) 요구사항 및 실습\n이전 장에서 언급했듯 **HTTP는 무상태 프로토콜**이다. 하지만 로그인과 같이 상태를 유지할 필요가 있는 요구사항이 발생한다. 이와 같은 경우 사용할 수 있는 방법이 \"쿠키 헤더를 사용하는 것\"이다.\n\n`\"Set-Cookie\"` 헤더를 통해 쿠키를 생성하면, 이후 발생하는 모든 요청에 `\"Set-Cookie\"` 로 추가한 값을 \"Cookie\" 헤더로 전달하는 방식이다. \n\n하지만 쿠키를 사용하는 데 **보안상 취약하다**는 문제점이 있다. \n왜냐면, 누구나 브라우저 개발자 도구나 HTTP 분석 도구를 활용하여 HTTP 요청 및 응답 헤더를 확인할 수 있기 때문이다. 따라서, **쿠키를 통해 중요한 개인정보를 전달하는 것은 보안상 적합하지 않다.**\n\n**Session의 등장**<br/>\n쿠키의 보안상 단점을 보완하기 위해 **Session**이 등장했다. 이는 상태 값으로 유지하고 싶은 정보를 클라이언트단에 저장하는 것이 아닌 **서버단에 저장**한다.\n- 서버에 저장 후, 각 클라이언트마다 고유한 아이디를 발급해 이 아이디를 `\"Set-Cookie\"` 헤더를 통해 전달한다.\n  - HTTP에서 상태를 유지하는 방법은 **쿠키**밖에 없기에, 결국은 상태 값 유지를 위한 값 전달에는 쿠키를 사용한다.\n\n> \"세션은 HTTP의 쿠키를 기반으로 동작한다.\"\n\n### 🔧 요구사항\n서블릿에서 지원하는 `HttpSession` API의 일부를 지원해야 한다. 구현할 메소드는 `getId()`, `setAttribute(String name, Object value)`, `getAttribute(String name)`, `removeAttribute(String name)`, `invalidate()` 이다.\n\n- `String getId()` : 현재 session에 할당되어 있는 고유한 session id를 반환\n- `void setAttribute(String name, Object value)` : 현재 session에 `value` 인자로 전달되는 객체를 `name` 인자 이름으로 저장\n- `Object getAttribute(String name)` : 현재 session에 `name` 인자로 저장되어 있는 객체 값을 찾아 반환\n- `void removeAttribute(String name)` : 현재 session에 `name` 인자로 저장되어 있는 객체 값을 삭제\n- `void invalidate()` : 현재 session에 저장되어 있는 모든 값을 삭제\n\n### 🔧 요구사항 분리 및 힌트\n- 클라이언트와 서버 간 주고 받을 고유한 아이디를 생성해야 한다. 고유한 아이디는 쉽게 예측할 수 없어야 한다. 그렇지 않다면, 쿠키 값을 조작해 다른 사용자처럼 속일 수 있기 때문이다.\n- 생성한 고유한 아이디를 쿠키를 통해 전달한다. (`”Set-Cookie”` 헤더)\n- 서버 측에서 모든 클라이언트의 session 값을 관리하는 저장소 클래스를 추가한다. (`Map<String, String>`, **Key**는 앞에서 생성한 고유한 아이디)\n- 클라이언트별 session 데이터를 관리할 수 있는 클래스(`HttpSession`)를 추가한다.\n    - 해당 클래스는 위 5개의 메소드를 모두 구현하고, 상태 데이터를 저장할 `Map<String, Object>` 가 필요하다.\n\n---\n\n## 🚩 세션(`HttpSession`) 구현\n### 🔧 고유한 아이디 생성\nsession에서 사용할 고유한 아이디를 생성해 보자. 랜덤으로 임의의 값을 생성할 수 있지만, JDK에서 제공하는 `UUID` 클래스를 활용한다. 먼저 `UUIDTest` 클래스를 추가해 어떤 형태로 생성되는지 확인해본다.\n\n`UUID.randomUUID()` 를 출력해보면 `5736e178-a06e-422b-84be-2309a3741eff` 와 같은 형태로 값이 생성된다.\n\n### 🔧 쿠키를 활용해 아이디 전달\n클라이언트가 처음 접근하는 경우, 해당 클라이언트가 사용할 **session 아이디를 생성**하고 이를 **쿠키로 전달**한다. 이후 요청부터는 상태 값 공유를 위해 전달해준 session 아이디를 사용한다.\n\n`RequestHandler` 클래스에 session 아이디가 존재하는지 여부를 판단한 후 없는 경우 session 아이디를 새로 발급한다. session 아이디는 `JSESSIONID` 로 전달한다.\n\n```java\npublic class RequestHandler extends Thread {\n    ...\n\n    public void run() {\n        log.debug(\"New Client Connect! Connected IP : {}, Port : {}\", connection.getInetAddress(),\n                connection.getPort());\n\n        try (InputStream in = connection.getInputStream(); OutputStream out = connection.getOutputStream()) {\n            HttpRequest request = new HttpRequest(in);\n            HttpResponse response = new HttpResponse(out);\n\n            if (getSessionId(request.getHeader(\"Cookie\")) == null) {\n                response.addHeader(\"Set-Cookie\", \"JSESSIONID=\" + UUID.randomUUID());\n            }\n            \n            ...\n\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n\n    private String getSessionId(String cookieValue) {\n        Map<String, String> cookies = HttpRequestUtils.parseCookies(cookieValue);\n        return cookies.get(\"JSESSIONID\");\n    }\n    ...\n\n}\n```\n\n- `getSessionId` 메소드는 request 헤더의 `Cookie` 값을 파싱하여 `JSESSIONID` 값을 반환한다.\n  - 있으면, `JSESSIONID=5736e178-a06e-422b-84be-2309a3741eff` 같은 형태\n  - session 아이디가 없는 경우, 새로 발급한다.\n\n`ListUserController` 에서 로그인 여부 확인을 위해 `Cookie` 헤더 값을 활용하는 부분이 증가하므로 이를 관리하는 `HttpCookie` 클래스를 추가하는 리팩토링을 실시한다.\n\n```java\npublic class HttpCookie {\n    private Map<String, String> cookies;\n\n    HttpCookie(String cookieValue) {\n        cookies = HttpRequestUtils.parseCookies(cookieValue);\n    }\n\n    public String getCookie(String name) {\n        return cookies.get(name);\n    }\n}\n```\n\n```java\npublic class HttpRequest {\n    ...\n\n    public HttpCookie getCookies() {\n\t\treturn new HttpCookie(getHeader(\"Cookie\"));\n\t}\n}\n```\n\n- 이후 `HttpRequest` 에서 `HttpCookie` 에 접근할 수 있는 메소드를 추가한다.\n\n이제 `RequestHandler` 클래스는 새로 추가한 `HttpCookie` 클래스의 메소드를 사용하도록 변경할 수 있다.\n\n```java\nif (request.getCookies().getCookie(\"JSESSIONID\") == null) {\n    response.addHeader(\"Set-Cookie\", \"JSESSIONID=\" + UUID.randomUUID());\n}\n```\n\n### 🔧 모든 클라이언트의 세션 데이터에 대한 저장소 추가\n서버는 **다수의 클라이언트 session을 지원**해야 한다. 이를 위해서는 session을 관리할 수 있는 **저장소**가 필요하다. \n- 모든 session을 매번 생성하는 것이 아니라 **한 번 생성 후 재사용**해야 한다. (`static` 으로 `Map` 생성해 (id, session)을 쌍으로 저장)\n\n```java\npublic class HttpSessions {\n    private static Map<String, HttpSession> sessions = new HashMap<String, HttpSession>();\n    \n    public static HttpSession getSession(String id) {\n        HttpSession session = sessions.get(id);\n        \n        if (session == null) {\n            session = new HttpSession(id);\n            sessions.put(id, session);\n            return session;\n        }\n        \n        return session;\n    }\n    \n    static void remove (String id) {\n        sessions.remove(id);\n    }\n}\n```\n\n### 🔧 클라이언트별 세션 저장소 추가\n서블릿에서 session 데이터에 접근할 때 사용한 클래스인, 각 클라이언트별 session을 담당할 `HttpSession` 클래스를 추가한다.\n\n```java\npublic class HttpSession {\n    private Map<String, Object> values = new HashMap<String, Object>();\n    \n    private String id;\n    \n    public HttpSession(String id) {\n        this.id = id;\n    }\n    \n    public String getId() {\n        return id;\n    }\n    \n    public void setAttribute(String name, Object value) {\n        values.put(name, value);\n    }\n    \n    public Object getAttribute(String name) {\n        return values.get(name);\n    }\n    \n    public void removeAttribute(String name) {\n        values.remove(name);\n    }\n    \n    public void invalidate() {\n        HttpSessions.remove(id);\n    }\n}\n```\n\n`HttpRequest` 에서 클라이언트에 해당하는 `HttpSession` 에 접근할 수 있도록 메소드를 추가한다.\n\n```java\npublic HttpSession getSession() {\n    return HttpSessions.getSession(getCookies().getCookie(\"JSESSIONID\"));\n}\n```\n\nsession 추가를 완료했으므로, `logined=true` 와 같은 쿠키 값을 추가하는 것이 아닌 `User` 객체를 추가해 로그인 여부를 판단하도록 코드를 변경하자.\n\n```java\npublic class LoginController extends AbstractController {\n    @Override\n    public void doPost(HttpRequest request, HttpResponse response) {\n        User user = DataBase.findUserById(request.getParameter(\"userId\"));\n        if (user != null) {\n            if (user.login(request.getParameter(\"password\"))) {\n                HttpSession session = request.getSession();\n                session.setAttribute(\"user\", user);\n                response.sendRedirect(\"/index.html\");\n            } else {\n                response.sendRedirect(\"/user/login_failed.html\");\n            }\n        } else {\n            response.sendRedirect(\"/user/login_failed.html\");\n        }\n    }\n}\n```\n\nsession에 `User` 객체를 추가했으므로, `ListUserController` 에서 로그인 여부 판단 코드로 변경해줘야 한다.\n\n```java\npublic class ListUserController extends AbstractController {\n    @Override\n    public void doGet(HttpRequest request, HttpResponse response) {\n        if (!isLogined(request.getSession())) {\n            response.sendRedirect(\"/user/login.html\");\n            return;\n        }\n        ...\n\n    }\n\n    private static boolean isLogined(HttpSession session) {\n        Object user = session.getAttribute(\"user\");\n        if (user == null) {\n            return false;\n        }\n        return true;\n    }\n}\n```\n\nsession을 활용하면, 클라이언트와 서버 간 상태 공유를 위해 전달하는 데이터는 session 아이디 뿐이다.\n- 예측할 수 없도록 생성하는 것은 보안측면에서 중요하다.\n\n쿠키는 보안 강화를 위해 \n- `domain` : 쿠키에 접근 가능한 도메인을 지정하는 속성\n- `path` : 웹서버의 특정 URL을 지정하는 속성\n- `max-age` : 쿠키를 얼마나 유지할 것인지를 지정하는 속성 (초 단위)\n- `expires` : max-age와 동일한 역할, 유효한 날짜를 지정하는 속성\n- `secure` : https통신에서만 쿠키에 접근하도록 지정하는 속성\n\n속성을 사용할 수 있다.\n\n> 단순히 session만 사용한다고 해서 보안 문제가 해결되는 것은 아니다.\n\n---\n\n## 🚩 MVC 프레임워크 요구사항 1단계\nMVC 패턴이 사용되기 전, 대부분의 웹 애플리케이션 개발은 JSP에 대부분의 로직을 포함하고 있었다. 하지만 이는 초기 개발 속도는 빠르지만 **유지보수 비용이 증가**하는 문제를 가지고 있었다. 따라서 유지보수 비용을 줄이기 위해 **MVC(Model, View, Controller) 패턴 기반**으로 웹 애플리케이션을 개발하는 방향으로 발전했다.\n- JSP에 집중되었던 로직을 `Model`, `View`, `Controller` 3개의 역할로 분리 개발 (like 삼권분립)\n\n**MVC 패턴 기반 개발 시 요청과 응답 흐름**\n<img src=\"https://user-images.githubusercontent.com/33208303/158940954-8b29b986-3019-4ec8-bcb9-37574c618079.png\" width=\"80%\">\n\n**MVC 패턴 기반 개발 시 요청과 응답 흐름 + 소스코드**\n<img src=\"https://user-images.githubusercontent.com/33208303/158940959-c4ea361a-fe76-40d3-b4b9-c95d9df8bbe7.png\" width=\"80%\">\n\nMVC 패턴을 적용하는 경우 기존과 다른 점은 \"클라이언트 요청이 처음 진입하는 부분이 컨트롤러\"라는 것이다.\n- 기존에는 뷰에 해당하는 JSP가 요청의 첫 진입부였다.\n- MVC 패턴을 적용하면 **대부분의 로직은 컨트롤러와 모델이 담당**하고, 뷰에 해당하는 **JSP**는 **컨트롤러에서 전달한 데이터를 출력하는 로직만**을 포함한다.\n  - 따라서 JSP의 복잡도는 낮아진다.\n\n> 프레임워크는 개발자 간의 역량 차이가 있더라도 MVC 패턴을 적용해 **일관성 있는 코드**를 구현하도록 강제한다. \n\n**프레임워크와 라이브러리**<br/>\n모두 애플리케이션 개발에서 발생하는 중복 코드를 제거해 **재사용성을 높임**으로써 **개발 속도를 빠르게 하기 위한 목적**을 가지지만, 가장 큰 차이로는\n- **프레임워크**는 특정 패턴 기반으로 개발하도록 강제하는 역할이고,\n- **라이브러리**는 강제하는 부분이 없다.\n\n### 🔧 요구사항\n: \"MVC 패턴을 지원하는 프레임워크를 구현하는 것\"\n\nMVC 패턴을 지원하는 기본적인 구조는 **모든 요청을 하나의 서블릿이 받은 후 요청 URL에 따라 분기 처리하는 방식**으로 구현하면 된다.\n\nMVC 패턴은 사용자의 최초 진입 지점이 **컨트롤러**이다. 따라서 JSP(뷰) 직접 접근하지 않도록 해야 한다. 아래는 MVC 프레임워크를 구현했을 때의 클래스 다이어그램이다.\n\n<img src=\"https://user-images.githubusercontent.com/33208303/158940961-e96c2bd1-e0f1-4297-b01a-20f9a10e4770.png\" width=\"80%\">\n\n- 모든 요청은 `DispatcherServlet` 이 받은 후 요청 URL에 따라 해당 컨트롤러에 작업을 위임한다.\n  - `@WebServlet` 으로 URL 매핑 시, `urlPatterns=\"/\"` 와 같이 설정하여 모든 요청 URL이 `DispatcherServlet` 으로 연결되도록 한다.\n- CSS, JS, Image와 같은 정적 자원은 컨트롤러가 필요없다. 하지만 위와 같은 매핑 방식은 정적 자원에 대한 요청까지 `DispatcherServlet` 으로 매핑되어버린다. \n  - 이를 위해 정적 자원을 처리하는 서블릿 필터를 추가한다. (`core.web.filter.ResourceFilter`)\n\n> **서블릿 필터(Servlet Filter)**<br/>\n> 서블릿 실행 전 또는 후에 특정 작업을 하고자 할 때 사용한다. 예로는 인증 필터, 로깅 및 감시 필터, 암호화 필터, 로그 작성 등이 있다.\n\n### 🔧 요구사항 분리 및 힌트\n- 모든 요청을 서블릿 하나(`DispatcherServlet`)가 받을 수 있도록 URL 매핑한다.\n- `Controller` 인터페이스를 추가한다.\n- 서블릿으로 구현된 회원관리 기능을 `Controller` 인터페이스 기반으로 다시 구현한다. \n  - `execute()` 메소드의 반환 값은 리다이렉트 방식으로 이동할 경우 `redirect:` 로 시작하고, 포워드 방식으로 이동할 경우 JSP 경로를 반환한다.\n- `RequestMapping` 클래스를 추가해 요청 URL과 컨트롤러 매핑을 설정한다.\n- 특별한 로직 없이 뷰(JSP)에 대한 이동만을 담당하는 `ForwardController` 를 추가한다. (회원가입 화면(`/user/form.jsp`), 로그인 화면(`/user/login.jsp`))\n- `DispatcherServlet` 에서 요청 URL에 해당하는 `Controller` 를 찾아 `execute()` 메소드를 호출해 실질적인 작업을 위임한다.\n- `Controller` 의 `execute()` 메소드 반환 값 `String` 을 받아 서블릿에서 JSP로 이동할 때의 중복을 제거한다.\n\n---\n\n## 🚩 MVC 프레임워크 구현 1단계\n클라이언트 요청에 대한 처리를 담당하는 부분을 **`Controller` 라는 인터페이스로 추상화**할 수 있다.\n\n```java\npublic interface Controller {\n    String execute(HttpServletRequest req, HttpServletResponse resp)\n        throws Exception;\n}\n```\n\n지금까지 `HttpServlet` 을 상속해 구현한 서블릿 코드들을 `Controller` 인터페이스를 상속해 구현하도록 변경한다.\n\n```java\n@WebServlet(\"/users\")\npublic class ListUserController implements Controller {\n\n    @Override\n    public String execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        if (!UserSessionUtils.isLogined(req.getSession())) {\n            return \"redirect:/users/loginForm\";\n        }\n\n        req.setAttribute(\"users\", DataBase.findAll());\n        return \"/user/list.jsp\";\n    }\n}\n```\n\n- 서블릿에서 JSP로 이동할 때 구현해야 하는 중복 코드가 제거되었다.\n\n특별한 로직 구현이 필요 없이 뷰에 대한 이동만을 담당하는 경우 컨트롤러 생성이 불합리하다고 판단해, 뷰에 대한 이동만을 담당하는 컨트롤러를 생성한다. (`ForwardController`)\n\n```java\npublic class ForwardController implements Controller {\n    private String forwardUrl;\n\n    public ForwardController(String forwardUrl) {\n        this.forwardUrl = forwardUrl;\n        if (forwardUrl == null) {\n            throw new NullPointerException(\"forwardUrl is null. 이동할 URL을 입력하세요.\");\n        }\n    }\n\n    @Override\n    public String execute(HttpServletRequest req, HttpServletResponse resp) throws Exception {\n        return forwardUrl;\n    }\n}\n```\n\n모든 서블릿들이 `Controller` 인터페이스를 상속하도록 구현한 후, 요청 URL과 컨트롤러 매핑을 담당하는 `RequestMapping` 을 생성한다.\n\n```java\npublic class RequestMapping {\n    private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);\n    private Map<String, Controller> mappings = new HashMap<>();\n\n    void initMapping() {\n        mappings.put(\"/\", new HomeController());\n        mappings.put(\"/users/form\", new ForwardController(\"/user/form.jsp\"));\n        mappings.put(\"/users/loginForm\", new ForwardController(\"/user/login.jsp\"));\n        mappings.put(\"/users\", new ListUserController());\n        mappings.put(\"/users/login\", new LoginController());\n        mappings.put(\"/users/profile\", new ProfileController());\n        mappings.put(\"/users/logout\", new LogoutController());\n        mappings.put(\"/users/create\", new CreateUserController());\n        mappings.put(\"/users/updateForm\", new UpdateFormUserController());\n        mappings.put(\"/users/update\", new UpdateUserController());\n\n        logger.info(\"Initialized Request Mapping!\");\n    }\n\n    public Controller findController(String url) {\n        return mappings.get(url);\n    }\n\n    void put(String url, Controller controller) {\n        mappings.put(url, controller);\n    }\n}\n```\n\n- 발생하는 모든 요청 URL과 서비스를 담당할 컨트롤러를 연결하여 `Map` 으로 저장한다.\n\n마지막 작업은 클라이언트의 모든 요청을 받아 URL에 해당하는 컨트롤러로 작업을 위임하고, 실행된 결과 페이지로 이동하는 작업이다. 이는 `DispatcherServlet` 에서 구현한다. (클래스 다이어그램에서 클라이언트의 요청을 받는 지점)\n\n```java\n@WebServlet(name = \"dispatcher\", urlPatterns = \"/\", loadOnStartup = 1)\npublic class DispatcherServlet extends HttpServlet {\n    private static final long serialVersionUID = 1L;\n    private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);\n    private static final String DEFAULT_REDIRECT_PREFIX = \"redirect:\";\n\n    private RequestMapping rm;\n\n    @Override\n    public void init() throws ServletException {\n        rm = new RequestMapping();\n        rm.initMapping();\n    }\n\n    @Override\n    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        String requestUri = req.getRequestURI();\n        logger.debug(\"Method : {}, Request URI : {}\", req.getMethod(), requestUri);\n\n        Controller controller = rm.findController(requestUri);\n        try {\n            String viewName = controller.execute(req, resp);\n            move(viewName, req, resp);\n        } catch (Throwable e) {\n            logger.error(\"Exception : {}\", e);\n            throw new ServletException(e.getMessage());\n        }\n    }\n\n    private void move(String viewName, HttpServletRequest req, HttpServletResponse resp)\n            throws ServletException, IOException {\n        if (viewName.startsWith(DEFAULT_REDIRECT_PREFIX)) {\n            resp.sendRedirect(viewName.substring(DEFAULT_REDIRECT_PREFIX.length()));\n            return;\n        }\n\n        RequestDispatcher rd = req.getRequestDispatcher(viewName);\n        rd.forward(req, resp);\n    }\n}\n```\n\n- `urlPatterns = \"/\"` 로 매핑하여 모든 요청 URL이 `DispatcherServlet` 으로 매핑되도록 한다.\n  - 일반적으로 모든 요청 URL을 매핑한다고 하면 `\"/*\"` 으로 생각할 수도 있다. 틀리진 않았지만, 이렇게 하게 되면 모든 JSP에 대한 요청 또한 매핑되어 JSP에 대한 요청이 정상적으로 처리되지 않는다.\n- `\"/\"` 매핑은 매핑되어 있는 서블릿, JSP 요청이 아닌 JS, CSS, Images와 같은 요청을 처리하도록 설계되었다. 톰캣 서버 기본 설정에서, `\"/\"` 설정은 `\"default\"` 라는 이름을 가지는 서블릿을 매핑해 정적 자원을 처리하도록 구현되어 있다.\n  - 해당 설정을 `DispatcherServlet` 에서 재정의하여 JSP에 대한 요청을 제외한 모든 요청을 담당하도록 구현했다.\n- `\"default\"` 서블릿에서 처리하는 정적 자원에 대한 처리는 `DispatcherServlet` 으로 요청되기 전에 `ResourceFilter` 에서 처리하도록 구현한다.\n\n**주의할 점**\n- `HomeController` 에서 `\"/\"` 로 매핑한 후 `localhost:8080` 요청의 경우, 웹 자원을 관리하는 `webapp` 디렉토리에 `index.jsp` 가 존재하면 `HomeController` 가 아닌 `index.jsp` 로 요청이 처리된다.\n  - 이는 `path` 가 없는 경우 처리를 담당하는 기본 파일이 `index.jsp` 로 설정되어 있기 때문이다.\n  - 이러한 이유로 `HomeController` 에서 이동할 뷰의 이름이 `home.jsp` 이다.\n\n**`loadOnStartup`** 속성\n- 서블릿 인스턴스를 생성하는 시점과 초기화를 담당하는 `init()` 메소드를 어느 시점에 호출할 것인가를 결정하는 설정\n  - **이를 하지 않은 경우** 서블릿 인스턴스 생성과 초기화는 서블릿 컨테이너가 시작을 완료한 후 **클라이언트의 요청이 최초로 발생하는 시점에 진행**된다.\n  - **설정한 경우 서블릿 컨테이너가 시작하는 시점에 서블릿 인스턴스 생성과 초기화가 진행**된다.\n- 설정의 숫자 값으로 서블릿의 초기화 순서를 결정한다. (낮은 순으로 먼저 진행)\n\n**`move()` 메소드**\n- 각 서블릿에서 서블릿과 JSP 사이를 이동하기 위해 구현한 모든 중복 코드를 담당한다.\n\n**프론트 컨트롤러(front controller) 패턴**\n- 각 컨트롤러의 앞에 모든 요청을 받아 각 컨트롤러에 작업을 위임하는 방식으로 구현하는 것\n\n**MVC 프레임워크 기반으로 요청에서 응답까지의 흐름**\n- 클라이언트의 요청 발생\n- `ServletFilter`(`ResourceFilter`) 에서의 선처리\n- `DispatcherServlet` 으로 요청 전달\n- `RequestMapping` 에 url을 전달하고 해당 처리를 맡을 `Controller` 를 반환\n- `Controller` 가 작업을 처리\n- 응답을 보내기 전 `ServletFilter` 에서의 후처리\n- 클라이언트로 응답을 전송\n\n---\n\n## 🚩 쉘 스크립트를 활용한 배포 자동화\n원격 서버에 톰캣 서버를 설치하고, 지금까지 구현한 소스코드를 배포한다. 수동으로 배포하는 작업을 쉘 스크립트를 활용해 자동화하는 과정까지 진행한다.\n\n### 🔧 요구사항\n- 구현한 기능을 개발 서버에 톰캣 서버를 설치한 후 배포한다.\n- 톰캣 로그 파일을 통해 서버의 정상적인 실행을 확인한다.\n- 쉘 스크립트를 만들어 배포를 자동화한다.\n\n## 📕 출처\n- **자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성\n- [서블릿 필터](https://atoz-develop.tistory.com/entry/Servlet-Filter-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B8%B0)"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. \"설계는 한 번의 작업으로 끝내야 하는 것이 아니라 애플리케이션을 개발하고 배포해 운영하는 동안 끊임없이 진행해야 하는 것이 설계이다. 이러한 지속적인 설계와 구현을 잘할 수 있는 방법이 지속적인 리팩토링이다.\" 4장에서 구현한 HTTP 웹 서버를 리팩토링하면서 설계…","fields":{"slug":"/[NextStep]5/"},"frontmatter":{"date":"February 07, 2022","title":"📖 5장 웹 서버 리팩토링, 서블릿 컨테이너와 서블릿의 관계","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n\"설계는 한 번의 작업으로 끝내야 하는 것이 아니라 애플리케이션을 개발하고 배포해 운영하는 동안 끊임없이 진행해야 하는 것이 설계이다. 이러한 지속적인 설계와 구현을 잘할 수 있는 방법이 지속적인 리팩토링이다.\"\n\n> 4장에서 구현한 HTTP 웹 서버를 리팩토링하면서 설계를 개선해보자.\n\n## 🚩 HTTP 웹 서버 리팩토링 실습\n### 🔧 리팩토링할 부분 찾기\n\"리팩토링을 어떻게 하느냐는 능력보다 리팩토링이 필요한 시점과 종료해야 하는 시점을 판단하는 능력이 중요하다.\"\n\n### 🔧 리팩토링 1단계\n**요청 데이터를 처리하는 로직을 별도의 클래스로 분리** (`HttpRequest`)<br/>\n해당 요구사항을 만족시키기 위한 새로운 클래스를 만들고, 요청 데이터를 담고 있는 `Http_GET.txt` 파일을 생성해 테스트 코드를 기반으로 개발한다. 아래와 같은 흐름을 가진다.\n- HTTP 요청 데이터를 저장한 텍스트 파일을 `FileInputStream` 으로 읽는다.\n- 이 `InputStream` 을 새로 생성한 `HttpRequest` 클래스의 생성자로 전달한다.\n\n**GET** 뿐 아니라 **POST**에 대한 테스트 데이터(`Http_POST.txt`)도 추가해 테스트할 수 있다.\n\n```java\npublic class HttpRequestTest {\n    private String testDirectory = \"./src/test/resources/\";\n\n    @Test\n    public void request_GET() throws Exception {\n        InputStream in = new FileInputStream(new File(testDirectory + \"Http_GET.txt\"));\n        HttpRequest request = new HttpRequest(in);\n\n        assertEquals(\"GET\", request.getMethod());\n        assertEquals(\"/user/create\", request.getPath());\n        assertEquals(\"keep-alive\", request.getHeader(\"Connection\"));\n        assertEquals(\"javajigi\", request.getParameter(\"userId\"));\n    }\n\n    @Test\n    public void request_POST() throws Exception {\n        InputStream in = new FileInputStream(new File(testDirectory + \"Http_POST.txt\"));\n        HttpRequest request = new HttpRequest(in);\n\n        assertEquals(\"POST\", request.getMethod());\n        assertEquals(\"/user/create\", request.getPath());\n        assertEquals(\"keep-alive\", request.getHeader(\"Connection\"));\n        assertEquals(\"javajigi\", request.getParameter(\"userId\"));\n    }\n}\n```\n\n**응답 데이터를 처리하는 로직을 별도의 클래스로 분리** (`HttpResponse`)<br/>\n요청 데이터에 대한 처리를 담당하고 있는 `HttpResponse` 가 정상적으로 동작하는지 확인하는 테스트 코드를 작성한다.\n\n```java\n@Test\npublic void responseForward() throws Exception {\n    HttpResponse response = new HttpResponse(createOutputStream(\"Http_Forward.txt\"));\n    response.forward(\"/index.html\");\n}\n\n@Test\npublic void responseRedirect() throws Exception {\n    HttpResponse response = new HttpResponse(createOutputStream(\"Http_Redirect.txt\"));\n    response.sendRedirect(\"/index.html\");\n}\n\n@Test\npublic void responseCookies() throws Exception {\n    HttpResponse response = new HttpResponse(createOutputStream(\"Http_Cookie.txt\"));\n    response.sendRedirect(\"/index.html\");\n}\n\nprivate OutputStream createOutputStream(String filename) throws FileNotFoundException {\n    return new FileOutputStream(new File(testDirectory + filename));\n}\n```\n\n- 해당 테스트 코드는 생성된 응답 데이터를 파일로 생성하여 수동으로 확인하도록 구현되어 있다.\n  - 수동으로 확인하는 것이 번거롭긴 하지만, `HttpResponse` 를 다른 클래스에서 사용하기 전에 정상 동작을 검증할 수 있다.\n\n**다형성을 활용해 클라이언트 요청 URL에 대한 분기 처리를 제거**<br/>\n`RequestHandler` 클래스를 보면, 기능이 추가될 때마다 분기문이 하나씩 추가되는 방식이다. 기능에 비례해 분기문의 수가 증가하기에 **자바의 다형성**을 활용해 분기문을 제거한다.\n\n> **클래스 다이어그램**<br/>\n> : 클래스 간의 관계를 쉽게 파악하기 위한 목적으로 사용하는 UML 중 하나\n> \n> <img src=\"../blog/images/JAVA/classDiagram.png\" width=\"50%\">\n> \n> 1. 인터페이스 구현(implements)는 점선 표시, 상속(extends) 실선 표시\n> 2. 클래스 간 의존관계\n>   - 클래스 의존관계가 클래스의 필드를 통해 연결되는 경우 실선\n>   - 클래스 의존관계가 메소드의 로컬 변수로 연결되는 경우 점선\n>   - 의존관계의 클래스를 해당 클래스의 인스턴스를 직접 생성하는 경우 <\\<create>>\n\n---\n\n## 🚩 웹 서버 리팩토링 구현 및 설명\n`RequestHandler` 클래스에서 각 객체가 하나의 책임을 가지도록 설계를 개선하는 리팩토링을 진행한다.\n\n### 🔧 Map, Set\n리팩토링 전에, 많이 사용할 `Map`, `Set` 개념을 정리한다.\n\n**`Map`**<br/>\n: 사전과 비슷하게, **Key와 Value를 한 쌍**으로 가지는 자료형이다.\n- 리스트나 배열처럼 순차적으로 해당 요소 값을 구하지 않고, **Key 값을 이용해 Value를 탐색**한다.\n- 순서가 없다.(Unordered)\n\n**`put`, `get`**<br/>\n: 각각 Key & Value 쌍을 넣는 메소드, Key 값을 이용해 Value를 얻는 메소드이다.\n\n**`keySet`**<br/>\n: `Map` 의 모든 Key를 모아서 `Set` 자료형으로 반환해주는 메소드이다.\n\n**`Set`**<br/>\n: 집합과 관련된 것을 쉽게 처리하기 위해 만든 자료형이다.\n- 중복을 허용하지 않는다.\n- 순서가 없다.(Unordered)\n\n### 🔧 `HttpRequest`\n클라이언트 요청 데이터에서 요청 라인(request line)을 읽고, 헤더를 읽는 로직을 `HttpRequest` 클래스를 추가해 구현한다.\n\n`HttpRequest` 의 책임\n: 클라이언트 요청 데이터를 읽은 후, 각 데이터를 사용하기 좋은 형태로 분리한다.\n\n분리한 데이터를 사용하는 부분은 `RequestHandler` 가 가진다. 즉, 데이터를 파싱하는 작업(`HttpRequest`)과 사용하는 부분(`RequestHandler`)을 분리한다.\n\n```java\npublic class HttpRequest {\n    private static final Logger log = LoggerFactory.getLogger(HttpRequest.class);\n\n    private String method;\n    private String path;\n    private Map<String, String> headers = new HashMap<String, String>();\n    private Map<String, String> params = new HashMap<String, String>();\n\n    public HttpRequest(InputStream in) {\n        try {\n            BufferedReader br = new BufferedReader(new InputStreamReader(in, \"UTF-8\"));\n            String line = br.readLine();\n            if (line == null) {\n                return;\n            }\n\n            processRequestLine(line);\n\n            line = br.readLine();\n            while(!line.equals(\"\")) {\n                log.debug(\"header : {}\", line);\n                String[] tokens = line.split(\":\");\n                headers.put(tokens[0].trim(), tokens[1].trim());\n                line = br.readLine();\n            }\n\n            if(\"POST\".equals(method)) {\n                String body = IOUtils.readData(br, Integer.parseInt(headers.get(\"Content-Length\")));\n                params = HttpRequestUtils.parseQueryString(body);\n            }\n        } catch (IOException io) {\n            log.error(io.getMessage());\n        }\n    }\n\n    private void processRequestLine(String requestLine) {\n        log.debug(\"request line : {}\", requestLine);\n        String[] tokens = requestLine.split(\" \");\n        method = tokens[0];\n\n        if (\"POST\".equals(method)) {\n            path = tokens[1];\n            return;\n        }\n\n        int index = tokens[1].indexOf(\"?\");\n        if (index == -1) {\n            path = tokens[1];\n        } else {\n            path = tokens[1].substring(0, index);\n            params = HttpRequestUtils.parseQueryString(tokens[1].substring(index+1));\n        }\n    }\n\n    public String getMethod() {\n        return method;\n    }\n\n    public String getPath() {\n        return path;\n    }\n\n    public String getHeader(String name) {\n        return headers.get(name);\n    }\n\n    public String getParameter(String name) {\n        return params.get(name);\n    }\n}\n```\n\n- `HttpRequest` 는 `InputStream` 을 생성하여 인자로 받은 후 `InputStream` 에 담겨있는 데이터를 필요한 형태로 분리한 후 객체의 필드에 저장하는 역할을 수행한다.\n  - 저장한 값에 접근할 수 있는 4 종류의 `get()` 메소드를 제공한다.\n\n**테스트 코드를 기반으로 개발**하는 경우, 아래의 효과를 얻을 수 있다.\n- 클래스에 버그가 있는지를 빨리 찾아 구현할수 있다.\n- 디버깅이 쉬워진다.\n- 테스트 코드가 있기에 마음 놓고 리팩토링을 수행할 수 있다.\n\n이제 테스트 코드가 준비되었으므로, 리팩토링을 진행할 수 있다.\n\n**리팩토링 1단계 `processRequestLine()`**<br/>\n\n`HttpRequest` 의 로직을 보면, 요청 라인을 처리하는 `processRequestLine()` 메소드의 복잡도가 높아보인다. 개발을 진행하다보면, 이와 같이 `private` 메소드인데 로직의 복잡도가 높아 추가적인 테스트가 필요하다고 생각되는 메소드가 발생한다. 그런데, 해당 메소드만 분리하여 테스트하기 어려운 경우에는 두 가지 방법이 있다.\n1. `private` 접근 제어자인 메소드를 `default` 접근 제어자로 수정하고 메소드 처리 결과를 반환하도록 수정해 테스트한다.\n2. 메소드 구현 로직을 새로운 클래스로 분리한다.\n\n> **`default` 접근 제어자**<br/>\n> : 메소드에 아무런 접근 제어자도 추가하지 않을 경우 패키지가 같은 클래스의 경우 접근 가능한 접근 제어자\n> `private` 와 `protected` 의 중간 정도 접근 제어 권한을 가진다.\n\n`processRequestLine()` 의 경우 첫번째 방법을 적용하기엔 메소드 처리 후 반환해야 하는 상태 값이 한 개가 아니라 쉽지 않다. 따라서 두번째 방법을 택한다.\n\n```java\npublic class RequestLine {\n    private static final Logger log = LoggerFactory.getLogger(HttpRequest.class);\n\n    private String method;\n    private String path;\n    private Map<String, String> params = new HashMap<String, String>();\n\n    public RequestLine(String requestLine) {\n        log.debug(\"request line : {}\", requestLine);\n        String[] tokens = requestLine.split(\" \");\n        if (tokens.length !=3) {\n            throw new IllegalArgumentException(requestLine + \"이 형식에 맞지 않습니다.\");\n        }\n        method = tokens[0];\n\n        if (\"POST\".equals(method)) {\n            path = tokens[1];\n            return;\n        }\n\n        int index = tokens[1].indexOf(\"?\");\n        if (index == -1) {\n            path = tokens[1];\n        } else {\n            path = tokens[1].substring(0, index);\n            params = HttpRequestUtils.parseQueryString(tokens[1].substring(index+1));\n        }\n    }\n\n    public String getMethod() {\n        return method;\n    }\n\n    public String getPath() {\n        return path;\n    }\n\n    public String getParameter(String name) {\n        return params.get(name);\n    }\n}\n```\n\n위와 같이 클래스로 분리하여, 클래스에 대한 테스트가 가능해진다.\n\n```java\npublic class RequestLineTest {\n\n    @Test\n    public void create_method() {\n        RequestLine line = new RequestLine(\"GET /index.html HTTP/1.1\");\n        assertEquals(\"GET\", line.getMethod());\n        assertEquals(\"/index.html\", line.getPath());\n\n        line = new RequestLine(\"POST /index.html HTTP/1.1\");\n        assertEquals(\"/index.html\", line.getPath());\n    }\n\n    @Test\n    public void create_path_and_params() {\n        RequestLine line = new RequestLine(\"GET /user/create?userId=javajigi&password=password&name=JaeSung HTTP/1.1\");\n        assertEquals(\"GET\", line.getMethod());\n        assertEquals(\"/user/create\", line.getPath());\n\n        Map<String, String> params = line.getParams();\n        assertEquals(2, params.size());\n    }\n}\n```\n\n이제 앞서 생성했던 `HttpRequest` 클래스가 새로 생성한 `RequestLine` 클래스를 사용하도록 리팩토링하면 다음과 같다.\n\n```java\npublic class HttpRequest {\n    private static final Logger log = LoggerFactory.getLogger(HttpRequest.class);\n\n    private Map<String, String> headers = new HashMap<String, String>();\n    private Map<String, String> params = new HashMap<String, String>();\n    private RequestLine requestLine;\n\n    public HttpRequest(InputStream in) {\n        try {\n            BufferedReader br = new BufferedReader(new InputStreamReader(in, \"UTF-8\"));\n            String line = br.readLine();\n            if (line == null) {\n                return;\n            }\n\n            requestLine = new RequestLine(line);\n\n            line = br.readLine();\n             while((line != null) && !line.isEmpty()) {\n                log.debug(\"header : {}\", line);\n                String[] tokens = line.split(\":\");\n                headers.put(tokens[0].trim(), tokens[1].trim());\n                line = br.readLine();\n            }\n\n            if(\"POST\".equals(getMethod())) {\n                String body = IOUtils.readData(br, Integer.parseInt(headers.get(\"Content-Length\")));\n                params = HttpRequestUtils.parseQueryString(body);\n            } else {\n                params = requestLine.getParams();\n            }\n        } catch (IOException io) {\n            log.error(io.getMessage());\n        }\n    }\n\n    public String getMethod() {\n        return requestLine.getMethod();\n    }\n\n    public String getPath() {\n        return requestLine.getPath();\n    }\n\n    public String getHeader(String name) {\n        return headers.get(name);\n    }\n\n    public String getParameter(String name) {\n        return params.get(name);\n    }\n}\n```\n\n리팩토링 과정을 살펴보면,\n- `RequestLine` 이라는 새로운 클래스를 추가해 `HttpRequest` 에서 요청 라인을 처리하는 책임을 분리했다.\n  - 하지만 `HttpRequest` 메소드 원형은 바뀌지 않았다.\n  - 따라서 기존의 `HttpRequestTest` 도 변경없이 테스트가 가능하다.\n\n`processRequestLine()` 메소드 로직에 대한 테스트를 새로운 클래스를 추가하여 해결했다. 하지만 메소드가 `private` 이고 메소드 처리 후 반환되는 값이 여러 개(`method`, `path`, `params` ?)라고 반드시 새로운 객체를 추가하는 것이 정답은 아니다. \n\n**리팩토링 2단계 `GET, POST`**<br/>\n**GET**, **POST** 문자열이 하드코딩되어 사용되는 부분이 보인다. 상수 값이 서로 연관되어 있는 경우로, 자바의 `enum` 을 쓰기 적합해보인다. (ex. 남자(M), 여자(F) / 동, 서, 남, 북)\n\n```java\npublic enum HttpMethod {\n    GET,\n    POST;\n}\n```\n\n위 `HttpMethod` 를 사용하여 **GET**, **POST**를 사용하는 코드를 수정할 수 있고, 이렇게 되면 이전까지 문자열을 직접 사용하던 코드들 모두 수정해야 한다. (`HttpRequest`, `RequestLineTest`, `HttpRequestTest`, `RequestLine`)\n\n```java\npublic class RequestLine {\n    private HttpMethod method;\n    ...\n\n    public RequestLine(String requestLine) {\n        ...\n        method = HttpMethod.valueOf(tokens[0]);\n\n        if (method == HttpMethod.POST) {\n            path = tokens[1];\n            return;\n        }\n\n        ...\n    }\n\n    public HttpMethod getMethod() {\n        return method;\n    }\n\n    ...\n}\n```\n\n또한 아래의 이용해 **POST** 메소드인지 여부를 판단하던 로직을 `if (method.isPost())` 와 같이 리팩토링할 수 있다.\n\n```java\npublic enum HttpMethod {\n    GET,\n    POST;\n\n    public boolean isPost() {\n        return this == POST;\n    }\n}\n```\n\n\"경험이 많지 않은 상태에서는 일단 새로운 객체를 추가했으면 객체를 최대한 활용하기 위해 노력해 본다.\"\n- 객체에서 값을 꺼낸 후 로직을 구현하려 하지 말고 값을 가지고 있는 객체에 메세지를 보내 일을 시키도록 연습하자.\n\n이제 `HttpRequest` 에 대한 리팩토링을 마쳤으니, `RequestHandler` 에서 `HttpRequest` 를 사용하도록 수정하자.\n\n```java\ntry (InputStream in = connection.getInputStream(); OutputStream out = connection.getOutputStream()) {\n    HttpRequest request = new HttpRequest(in);\n    DataOutputStream dos = new DataOutputStream(out);\n    String path = getDefaultPath(request.getPath());\n\n    if (\"/user/create\".equals(path)) {\n        User user = new User(\n                request.getParameter(\"userId\"),\n                request.getParameter(\"password\"),\n                request.getParameter(\"name\"),\n                request.getParameter(\"email\")\n        );\n\n        if (request.getMethod().isPost()) {\n            DataBase.addUser(user);\n            response302Header(dos, \"/index.html\");\n        }\n    } else if (\"/user/login\".equals(path)) {\n        if (request.getMethod().isPost()) {\n            User user = DataBase.findUserById(request.getParameter(\"userId\"));\n            log.debug(\"User : {}\", user);\n            if (user == null) {\n                responseResource(dos, \"/user/login_failed.html\");\n                return;\n            }\n            if (user.getPassword().equals(request.getParameter(\"password\"))) {\n                response302Logined(dos);\n            } else {\n                responseResource(dos, \"/user/login_failed.html\");\n                return;\n            }\n        }\n    } else if (\"/user/list\".equals(path)) {\n        if (!isLogin(request.getHeader(\"Cookie\"))) {\n            responseResource(out, \"/user/login.html\");\n            return;\n        }\n        Collection<User> users = DataBase.findAll();\n        StringBuilder sb = new StringBuilder();\n        sb.append(\"<h1>회원 목록</h1>\");\n        for (User user : users) {\n            sb.append(\"<p>\" + user.getUserId() + \"</p>\");\n            sb.append(\"<p>\" + user.getName() + \"</p>\");\n            sb.append(\"<p>\" + user.getEmail() + \"</p>\");\n        }\n        sb.append(\"<h2>목록 끝</h2>\");\n        byte[] body = sb.toString().getBytes();\n        response200Header(dos, body.length);\n        responseBody(dos, body);\n    } else if (path.endsWith(\".css\")) {\n        responseCssResource(out, path);\n    } else {\n        responseResource(out, path);\n    }\n} catch (IOException e) {\n    log.error(e.getMessage());\n}\n```\n\n- 크게 각 `path` 별로 분기문을 구분한다.\n- `HttpRequest` 에서 전처리를 수행하므로 코드가 훨씬 간결해졌다.\n\n클라이언트 요청 데이터에 대한 처리를 `HttpRequest` 객체에 추상화하여 구현함으로써, `RequestHandler` 는 요청 데이터를 처리하는 모든 로직을 제거할 수 있게 된다. \n\n추가적으로, `RequestHandler` 의 `isLogin()` 메소드도 `HttpRequest` 에서 쿠키 헤더 값에 대한 처리를 하도록 하는 것이 좋아보인다. \n- `HttpRequest` 에 `public boolean isLogin()` 메소드를 생성해 읽은 `header` 중 `Cookie` 가 존재하는 라인을 가져와 `parseCookies` 로 가지고 있는 값을 반환하도록 한다.\n\n### 🔧 `HttpResponse`\n응답 데이터 처리를 담당할 `HttpResponse` 클래스를 추가한다. 이 클래스의 역할은 응답 데이터의 상태에 따라 적절한 HTTP 헤더를 처리한다.\n\n- HTML, CSS, JS 파일을 읽어 반환하는 부분과 302 상태 코드를 처리하는 부분이 가능해야 한다.\n- 쿠키 추가와 같이 HTTP 헤더에 임의의 값을 추가할 수 있어야 한다.\n\n```java\npublic class HttpResponse {\n    private static final Logger log = LoggerFactory.getLogger(HttpResponse.class);\n    private DataOutputStream dos = null;\n    private Map<String, String> headers = new HashMap<String, String>();\n\n    public HttpResponse(OutputStream out) {\n        dos = new DataOutputStream(out);\n    }\n\n    public void addHeader(String key, String value) {\n        headers.put(key, value);\n    }\n\n    public void forward(String url) {\n        try {\n            byte[] body = Files.readAllBytes(new File(\"./webapp\" + url).toPath());\n            if (url.endsWith(\".css\")) {\n                headers.put(\"Content-Type\", \"text/css\");\n            } else if (url.endsWith(\".js\")) {\n                headers.put(\"Content-Type\", \"application/javascript\");\n            } else {\n                headers.put(\"Content-Type\", \"text/html;charset=utf-8\");\n            }\n            headers.put(\"Content-Length\", body.length + \"\");\n            response200Header(body.length);\n            responseBody(body);\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n\n    public void forwardBody(String body) {\n        byte[] contents = body.getBytes();\n        headers.put(\"Content-Type\", \"text/html;charset=utf-8\");\n        headers.put(\"Content-Length\", contents.length + \"\");\n        response200Header(contents.length);\n        responseBody(contents);\n    }\n\n    public void sendRedirect(String redirectUrl) {\n        try {\n            dos.writeBytes(\"HTTP/1.1 302 Found \\r\\n\");\n            processHeaders();\n            dos.writeBytes(\"Location: \" + redirectUrl + \" \\r\\n\");\n            dos.writeBytes(\"\\r\\n\");\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n\n    private void response200Header(int lengthOfBodyContent) {\n        try {\n            dos.writeBytes(\"HTTP/1.1 200 OK \\r\\n\");\n            processHeaders();\n            dos.writeBytes(\"\\r\\n\");\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n\n    private void responseBody(byte[] body) {\n        try {\n            dos.write(body, 0, body.length);\n            dos.writeBytes(\"\\r\\n\");\n            dos.flush();\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n\n    private void processHeaders() {\n        try {\n            Set<String> keys = headers.keySet();\n            for (String key : keys) {\n                dos.writeBytes(key + \": \" + headers.get(key) + \"\\r\\n\");\n            }\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n}\n```\n\n- 클래스 생성자로 사용할 `DataOutputStream` 을 생성한다.\n- `addHeader()` 는 헤더에 붙일 정보들을 인자로 받아 헤더에 추가한다.\n- `forward()` 는 요청된 파일에 따라 헤더의 `Content-Type` 정보를 다르게 채우는 역할을 수행한다.\n- `forwardBody()` 는 인자로 받은 문자열을 Byte단위로 읽고 header 정보를 채우는 역할을 수행한다.\n- `sendRedirect()` 는 인자로 받은 `redirectUrl` 로의 리다이렉션(302) 응답을 처리한다.\n- `response200Header()` 는 성공(200)을 처리한다.\n- `responseBody()` 는 인자로 받은 `byte[]` 값을 응답하는 역할을 수행한다.\n- `processHeader()` 는 지금까지 `header` 에 더해진 정보들을 꺼내어 응답 헤더에 쓰는 역할을 수행한다.\n\n이제 `RequestHandler` 클래스가 `HttpResponse` 를 사용하도록 리팩토링한다.\n\n```java\ntry (InputStream in = connection.getInputStream(); OutputStream out = connection.getOutputStream()) {\n    HttpRequest request = new HttpRequest(in);\n    HttpResponse response = new HttpResponse(out);\n    \n    ...\n\n    if (\"/user/create\".equals(path)) {\n        User user = new User(\n                request.getParameter(\"userId\"),\n                request.getParameter(\"password\"),\n                request.getParameter(\"name\"),\n                request.getParameter(\"email\")\n        );\n        log.debug(\"user : {}\", user);\n        DataBase.addUser(user);\n        response.sendRedirect(\"/index.html\");\n    } else if (\"/user/login\".equals(path)) {\n        User user = DataBase.findUserById(request.getParameter(\"userId\"));\n        if (user != null) {\n            if (user.login(request.getParameter(\"password\"))) {\n                response.addHeader(\"Set-Cookie\", \"logined=true\");\n                response.sendRedirect(\"/index.html\");\n            } else {\n                response.sendRedirect(\"/user/login_failed.html\");\n            }\n        } else {\n            response.sendRedirect(\"/user/login_failed.html\");\n        }\n    } else if (\"/user/list\".equals(path)) {\n        if (!request.isLogin()) {\n            response.sendRedirect(\"/user/login.html\");\n            return;\n        }\n\n        ...\n\n        response.forwardBody(sb.toString());\n    } else {\n        response.forward(path);\n    }\n} catch (IOException e) {\n    log.error(e.getMessage());\n}\n```\n\n### 🔧 다형성\n리팩토링을 통해 `RequestHandler` 의 복잡도를 많이 낮추었다. 하지만 아직 `run()` 메소드의 복잡도를 완전히 낮추지는 못했다. 가장 큰 문제점은 **기능 추가**마다 **새로운 `else if` 절이 추가**되는 구조의 구현이다. **이러한 구조는 OCP 원칙을 위반하고 있다.**\n\n> **OCP 원칙**\n> 개방폐쇄의 원칙 (Open-Closed Principle)\n> 요구사항의 변경이나 추가사항이 발생하더라도, 기존 구성요소는 수정이 일어나지 말아야 하며, 기존 구성요소를 쉽게 확장해서 재사용할 수 있어야 한다.\n\n**`run()` 메소드 리팩토링**<br/>\n해당 메소드의 복잡도가 높아 먼저 각 분기문 구현을 별도의 메소드로 분리하는 리팩토링(Extract Method 리팩토링)을 진행한다.\n- `createUser`, `login`, `listUser`\n\n메소드로 분리하고 보니, 각 메소드는 `HttpRequest`, `HttpResponse` 만 인자로 받는 것을 확인할 수 있다. 즉, 메소드의 원형이 같기에 자바의 인터페이스(`Interface`)로 추출하는 것이 가능하다.\n\n```java\nimport http.HttpRequest;\nimport http.HttpResponse;\n\npublic interface Controller {\n    void service(HttpRequest request, HttpResponse response);\n}\n```\n\n- 인터페이스를 추가한 후 앞의 분기문에서 분리했던 메소드 구현 코드들을 `Controller` 인터페이스에 대한 구현 클래스로 이동한다. \n- `CreateUserController`, `LoginController`, `ListUserController`\n\n각 분기문에 해당하는 `Controller` 들을 추가했으므로, 이제 각 **요청 URL과 URL에 대응하는 `Controller` 를 연결**해줘야 한다. 이를 위해 `RequestMapping` 이라는 클래스를 생성한다.\n\n```java\npublic class RequestMapping {\n    private static Map<String, Controller> controllers = new HashMap<String, Controller>();\n    \n    static {\n        controllers.put(\"/user/create\", new CreateUserController());\n        controllers.put(\"/user/login\", new LoginController());\n        controllers.put(\"/user/list\", new ListUserController());\n    }\n    \n    public static Controller getController(String requestUrl) {\n        return controllers.get(requestUrl);\n    }\n}\n```\n\n- `Map` 자료형을 사용하여 URL과 `Controller` 를 한 쌍으로 저장함으로써 웹 애플리케이션에서 서비스하는 모든 URL과 `Controller` 를 관리한다.\n- `getController()` 로, 요청 URL에 해당하는 `Controller` 를 반환한다.\n\n```java\npublic class RequestHandler extends Thread {\n    private static final Logger log = LoggerFactory.getLogger(RequestHandler.class);\n\n    private Socket connection;\n\n    public RequestHandler(Socket connectionSocket) {\n        this.connection = connectionSocket;\n    }\n\n    public void run() {\n        log.debug(\"New Client Connect! Connected IP : {}, Port : {}\", connection.getInetAddress(),\n                connection.getPort());\n\n        try (InputStream in = connection.getInputStream(); OutputStream out = connection.getOutputStream()) {\n            HttpRequest request = new HttpRequest(in);\n            HttpResponse response = new HttpResponse(out);\n\n            Controller controller = RequestMapping.getController(request.getPath());\n            if (controller == null) {\n                String path = getDefaultPath(request.getPath());\n                response.forward(path);\n            } else {\n                controller.service(request, response);\n            }\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n    ...\n}\n```\n\n- 이제 `RequestHandler` 에서 요청 URL에 대한 `Controller` 를 찾은 후 모든 작업을 해당 `Controller` 가 처리하도록 한다.\n- 앞으로 다른 기능이 추가된다면, \n  - `Controller` 인터페이스를 구현하는 새로운 클래스를 추가하고, \n  - `RequestMapping` 의 `Map` 에 요청 URL과 `Controller` 클래스를 추가한다.\n- 이렇게 각 클래스 간 어떠한 영향도 없이 기능 구현이 가능해진다.\n\n추가적으로, 각 HTTP 메소드(GET, POST)에 따른 처리를 하도록 추상 클래스를 추가할 수도 있다.\n\n```java\npublic abstract class AbstractController implements Controller {\n    @Override\n    public void service(HttpRequest request, HttpResponse response) {\n        HttpMethod method = request.getMethod();\n\n        if (method.isPost()) {\n            doPost(request, response);\n        } else {\n            doGet(request, response);\n        }\n    }\n\n    protected void doPost(HttpRequest request, HttpResponse response) {\n\n    }\n\n    protected void doGet(HttpRequest request, HttpResponse response) {\n\n    }\n}\n```\n\n- 이제 각 `Controller` 는 `Controller` 인터페이스를 직접 구현하는 것이 아닌 `AbstractController` 를 상속해 각 HTTP 메소드에 맞는 메소드를 `@Override` 하도록 구현할 수 있다.\n\n```java\npublic class CreateUserController extends AbstractController {\n    private static final Logger log = LoggerFactory.getLogger(CreateUserController.class);\n\n    @Override\n    public void doPost(HttpRequest request, HttpResponse response) {\n        User user = new User(request.getParameter(\"userId\"), request.getParameter(\"password\"), request.getParameter(\"name\"), request.getParameter(\"email\"));\n        log.debug(\"user : {}\", user);\n        DataBase.addUser(user);\n        response.sendRedirect(\"/index.html\");\n    }\n}\n```\n\n```java\npublic class ListUserController extends AbstractController{\n    @Override\n    public void doGet(HttpRequest request, HttpResponse response) {\n        if (!request.isLogin()) {\n            response.sendRedirect(\"/user/login.html\");\n            return;\n        }\n        Collection<User> users = DataBase.findAll();\n        StringBuilder sb = new StringBuilder();\n        sb.append(\"<h1>회원 목록</h1>\");\n        for (User user : users) {\n            sb.append(\"<p>\" + user.getUserId() + \"</p>\");\n            sb.append(\"<p>\" + user.getName() + \"</p>\");\n            sb.append(\"<p>\" + user.getEmail() + \"</p>\");\n        }\n        sb.append(\"<h2>목록 끝</h2>\");\n        response.forwardBody(sb.toString());\n    }\n}\n```\n\n```java\npublic class LoginController extends AbstractController {\n    @Override\n    public void doPost(HttpRequest request, HttpResponse response) {\n        User user = DataBase.findUserById(request.getParameter(\"userId\"));\n        if (user != null) {\n            if (user.login(request.getParameter(\"password\"))) {\n                response.addHeader(\"Set-Cookie\", \"logined=true\");\n                response.sendRedirect(\"/index.html\");\n            } else {\n                response.sendRedirect(\"/user/login_failed.html\");\n            }\n        } else {\n            response.sendRedirect(\"/user/login_failed.html\");\n        }\n    }\n}\n```\n\n**위 구현의 장점**은, 요청 URL이 같더라도 HTTP 메소드가 다른 경우, 새로운 `Controller` 클래스 추가없이 **하나의 `Controller` 에서 메소드(`doGet`, `doPost`)만 변경하여 구현이 가능**해진다는 것이다.\n\n### 🔧 HTTP 웹 서버의 문제점\n지금까지 구현한 웹 서버는 다음과 같은 한계를 가진다.\n- HTTP 요청과 응답 헤더, 본문 처리와 같은 데 시간을 투자함으로써 정작 중요한 로직 구현에 투자할 시간이 상대적으로 적다.\n- 동적인 HTML을 지원하는 데 한계가 있다. 이는 많은 코딩량을 필요로 한다.\n- 사용자가 입력한 데이터가 계속 유지되지 않는다.\n\n---\n\n## 🚩 서블릿 컨테이너, 서블릿/JSP를 활용한 문제 해결\n웹서버의 3가지 문제점 중 앞 2가지 문제점의 해결을 위해 자바 진영에서 표준으로 정한 것이 **서블릿 컨테이너**와 **서블릿/JSP**이다.\n\n**서블릿**<br/>\n: 앞에서 구현한 웹 서버의 `Controller`, `HttpRequest`, `HttpResponse` 를 추상화해 인터페이스로 정의해 놓은 표준이다. 즉, HTTP의 클라이언트 요청과 응답에 대한 표준을 정해 놓은 것이다.\n\n**서블릿 컨테이너**<br/>\n: 서블릿 표준에 대한 구현을 담당하고 있으며, 앞에서 구현한 웹 서버가 서블릿 컨테이너 역할과 같다.\n\n앞서 구현한 HTTP 웹 서버는,\n- 서버를 시작하는 시점에 `Controller` 의 인스턴스를 생성하고,\n- 요청 URL과 생성한 `Controller` 인스턴스를 연결시켜 놓는다.\n- 클라이언트에서 요청이 오면 요청 URL에 해당하는 `Controller` 를 찾아 작업을 위임한다.\n\n서블릿 컨테이너와 서블릿의 동작 방식도 동일하다.\n- 서블릿 컨테이너는 서버 시작 시 서블릿 인스턴스를 생성해, 요청 URL과 서블릿 인스턴스를 연결한다.\n- 클라이언트 요청 URL에 해당하는 서블릿을 찾아 작업을 위임한다.\n\n```java\npublic class WebServerLauncher {\n    private static final Logger logger = LoggerFactory.getLogger(WebServerLauncher.class);\n\n    public static void main(String[] args) throws Exception {\n        String webappDirLocation = \"webapp/\";\n        Tomcat tomcat = new Tomcat();\n        String webPort = System.getenv(\"PORT\");\n        if (webPort == null || webPort.isEmpty()) {\n            webPort = \"8080\";\n        }\n\n        tomcat.setPort(Integer.parseInt(webPort));\n        Connector connector = tomcat.getConnector();\n        connector.setURIEncoding(\"UTF-8\");\n        tomcat.addWebapp(\"/\", new File(webappDirLocation).getAbsolutePath());\n        System.out.println(\"configuring app with basedir: \" + new File(\"./\" + webappDirLocation).getAbsolutePath());\n        tomcat.start();\n        tomcat.getServer().await();\n    }\n}\n```\n\n- 위는 톰캣 서버를 생성한 모습이다. \n- 톰캣 서버 시작 시, 포트번호는 8080으로 세팅, 인코딩은 UTF-8로 세팅한다.\n- \"/\" 를 root로 접근할 수 있도록 지정하고, \"/\" 요청 시 해당 root directory를 `webappDirLocation` 으로 지정한다.\n  - `webappDirLocation` 에서 자원을 관리한다.\n  - 현재 서버를 동작시키면 서버에 아무런 자원이 없어 404 응답 코드가 뜬다.\n\n`webapp/index.html` 을 생성하여 `localhost:8080` 으로 접속하면 해당 HTML의 내용이 보여지는 것을 확인할 수 있다.\n- 이는 톰캣 서버가 `index.html` 을 default로 인식하기 때문이다.\n\n이제, 간단한 문구를 출력하는 서블릿을 생성한다.\n\n`src/net.bsu/HeeloWorldServlet.java`\n\n```java\npackage net.bsu;\n\nimport jakarta.servlet.ServletException;\nimport jakarta.servlet.annotation.WebServlet;\nimport jakarta.servlet.http.HttpServlet;\nimport jakarta.servlet.http.HttpServletRequest;\nimport jakarta.servlet.http.HttpServletResponse;\n\nimport java.io.IOException;\nimport java.io.PrintWriter;\n\n@WebServlet(\"/hello\")\npublic class HelloWorldServlet extends HttpServlet {\n\n    @Override\n    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {\n        PrintWriter out = resp.getWriter();\n        out.print(\"Hello World\");\n    }\n}\n```\n\n- 톰캣 서버가 해당 클래스가 서블릿임을 인식하기 위해서는 `HttpServlet` 을 상속해야 한다.\n- 해당 서블릿은 간단한 문구 출력을 위해 GET 메소드에 응답을 보내는 것이므로 `doGet` 메소드를 `@Override` 한다.\n- 해당 서블릿이 응답하기 위해서는 특정 요청 URL과 대응되어야 한다.\n  - URL Mapping을 위해 `@WebServlet` annotation을 사용한다.\n- 서버 실행 후 `/hello` 로 접근해도 404 상태코드를 만나는데, 이는 서블릿 표준 directory의 차이때문이다.\n  - 표준 root directory는 `tomcatServer/webapp` 이고, 클래스 파일이 위치하는 default 위치는 `webapp/WEB-INF/classes/MyPackage/` 이다. \n  - 따라서, `Project Structure - Project Settings - Modules - Paths` 에서 `Use module compile output path` 를 선택 후, `Output path` 를 위 형태에 맞게 변경한다.\n  - 이후 서버를 재시작하여 접근하면 정상적으로 보여지는 것을 확인할 수 있다.\n\n### 🔧 서블릿 컨테이너, 서블릿\n위 서블릿 코드들을 보면 이전의 `Controller` 인터페이스 구현체와 비슷하다는 것을 알 수 있다. 서블릿은 앞서 구현한 `Controller` 와 정확히 같은 역할을 수행하며, 똑같은 방식으로 동작한다.\n- `doGet()` 메소드의 인자로 전달하는 `HttpServletRequest`, `HttpServletResponse` 는 `HttpRequest`, `HttpResponse` 와 같다.\n- 더 정확하게는 `Controller` 인터페이스는 서블릿의 `Servlet` 인터페이스, `AbstractController` 는 `HttpServlet` 과 같다.\n\n서블릿 컨테이너는 서버를 시작할 때\n- 클래스패스에 있는 클래스 중 `HttpServlet` 을 상속하는 클래스를 찾는다.\n- `@WebServlet` annotation의 값을 읽어 요청 URL과 서블릿을 연결하는 `Map` 을 생성한다.\n\n즉, 앞에서 구현한 `RequestMapping` 의 `Map` 에 서블릿을 추가하고, 요청 URL에 대한 서블릿을 찾아 서비스하는 역할을 서블릿 컨테이너가 담당한다.\n\n**서블릿 컨테이너의 중요한 역할**<br/>\n- 서블릿 클래스의 인스턴스 생성\n- 요청 URL과 서블릿 인스턴스 Mapping\n- 클라이언트 요청에 해당하는 서블릿을 찾은 후 서블릿에 작업을 위임\n- 이외에도 서블릿과 관련한 초기화(init)와 소멸(destroy) 작업을 담당\n\n**서블릿 컨테이너가 시작하고 종료할 때의 과정**<br/>\n- 서블릿 컨테이너 시작\n- 클래스패스에 있는 `Servlet` 인터페이스를 구현하는 서블릿 클래스를 찾음\n- `@WebServlet` 설정을 통해 요청 URL과 서블릿 Mapping\n- 서블릿 인스턴스 생성\n- `init()` 메소드를 호출해 초기화\n\n초기화를 완료한 후, 클라이언트 요청이 있을 때까지 **대기상태**로 있다가 요청이 오는 경우 해당 서블릿을 찾아 `service()` 메소드를 호출한다.\n\n서비스를 제공하다 서블릿 컨테이너를 종료하면, 컨테이너가 관리하고 있던 모든 서블릿의 `destroy()` 메소드를 호출해 **소멸작업**을 진행한다.\n\n이와 같이 서블릿 생성, 초기화, 서비스, 소멸을 거치는 전체 과정을 **서블릿의 생명주기(Life Cycle)**라 하고, 서블릿 컨테이너는 서블릿의 생명주기를 관리한다. (외에도, 멀티쓰레딩 지원, 설정 파일을 활용한 보안관리, JSP 지원 등도 있다.)\n\n**컨테이너**<br/>\n개발하면서 많은 컨테이너들을 접하게 된다. 각 컨테니어마다 다른 기능을 지원할 수 있지만 기본적으로 생명주기를 관리하는 기능을 제공한다.\n\n- EJB(Enterprise Java Bean) 컨테이너는 EJB에 대한 생명주기를  관리한다.\n- 스프링 프레임워크의 빈(Bean) 컨테이너는 빈에 대한 생명주기를 관리한다.\n\n**컨테이너가 관리하는 객체의 인스턴스**는 개발자가 직접 생성하는 인스턴스가 아니다. (개발자가 직접 생성한다면, 개발자가 원하는 메소드를 호출해 초기화, 소멸과 같은 작업을 진행)\n- 초기화, 소멸과 같은 작업을 위한 메소드를 인터페이스 규약으로 만들어 놓고 확장할 수 있도록 지원한다.\n  - 2장의 `JUnit` 이 `@Before`, `@Test`, `@After` 와 같이 초기화, 테스트, 소멸 작업을 위해 확장할 부분을 제공한 것처럼 컨테이너도 같은 방식으로 생명주기를 지원한다.\n\n서블릿 컨테이너는 멀티스레드로 동작한다. 동시에 여러 명의 클라이언트가 접속할 수 있도록 지원한다. 그렇다면 서블릿 인스턴스는 몇 개나 생성될까?\n- 새로운 스레드 생성마다 생성할까?\n\n정답은 `HTTP` 웹 서버 실습에서 구현한 `RequestMapping` 의 `Map` 을 보면 된다. \n- 이는 `static` 으로 구현되어 있어 서버가 시작할 때 초기화하고 나면 **더이상의 초기화없이 재사용**된다.\n- 서블릿도 동일하게, **모든 스레드가 같은 인스턴스를 재사용**(공유)한다.\n\n## 📕 출처\n- **자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성\n- [Map 자료형](https://wikidocs.net/208)\n- [Set 자료형](https://wikidocs.net/157108)"},{"excerpt":"프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략 - 구종만을 읽고 정리한 POST입니다. 💡 문제 해결 과정 🔍 파인만 알고리즘 : 현재 인류에게 알려진 가장 강력한 일반적 문제 해결 알고리즘 칠판에 문제를 적는다. 골똘히 생각한다. 칠판에 답안을 적는다. 사실 반쯤은 농담인 이 알고리즘에서, 우리는 아래와 같은 것을 배울 수 있다. 문제 해결 과정을…","fields":{"slug":"/[Algorithm]문제해결개관/"},"frontmatter":{"date":"February 03, 2022","title":"💡 문제해결개관","tags":["종만북"]},"rawMarkdownBody":"\n<em>[프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략 - 구종만]을 읽고 정리한 POST입니다.</em>\n\n## 💡 문제 해결 과정\n### 🔍 파인만 알고리즘\n: 현재 인류에게 알려진 가장 강력한 일반적 문제 해결 알고리즘\n1. 칠판에 문제를 적는다.\n2. 골똘히 생각한다.\n3. 칠판에 답안을 적는다.\n\n사실 반쯤은 농담인 이 알고리즘에서, 우리는 아래와 같은 것을 배울 수 있다.\n- **문제 해결 과정을 단계별로 나누었다.**\n  - 문제를 해결하기 위해 거쳐 가야 하는 과정들을 세분화함으로써, 어디가 부족하고 개선해야 하는지 판단할 수 있게 된다.\n- **문제를 적는 단계가 있다.**\n  - 문제를 다시 적기 위해서는 문제를 읽고 이해한 뒤 자신만의 언어로 재정의해야 하기에 이 단계는 매우 중요하다.\n\n문제 해결 연구의 고전인 **어떻게 문제를 풀 것인가**에서는 다음 네 단계로 문제 해결 과정을 나눈다.\n1. 문제를 이해한다.\n2. 어떻게 풀지 계획을 세운다.\n3. 계획을 수행해서 문제를 해결한다.\n4. 어떻게 풀었는지 돌아보고, 개선할 방법이 있는지 찾아본다.\n\n골똘히 생각하는 단계를 **계획을 세우는 단계**와 **수행하는 단계**로 나누었고, 문제를 해결한 이후에도 개선할 방법을 찾는 **회고 단계**가 추가되었다.\n\n위 두 접근 방법을 합쳐 프로그래밍 대회를 위한 **여섯 단계 알고리즘**을 만들 수 있다.\n1. 문제를 읽고 이해한다.\n2. 문제를 익숙한 용어로 재정의한다.\n3. 어떻게 해결할지 계획을 세운다.\n4. 계획을 검증한다.\n5. 프로그램으로 구현한다.\n6. 어떻게 풀었는지 돌아보고, 개선할 방법이 있는지 찾아본다.\n   \n### 🔍 1단계: 문제를 읽고 이해하기\n처음 참가하는 사람부터 과거의 챔피언까지 모든 대회 참가자들이 공통으로 하는 실수가 있다면 바로 **문제를 잘못 읽는 실수**라고 할 수 있기에, 이 단계의 중요성은 아무리 강조해도 지나치지 않다.\n\n따라서, \"문제 설명을 공격적으로 읽으며 문제가 원하는 바를 완전히 이해하는 과정이 반드시 필요하다.\" \n\n### 🔍 2단계: 재정의와 추상화\n이 단계는 자신이 다루기 쉬운 개념을 이용해서 문제를 자신만의 언어로 풀어 쓰는 것이다. 문제의 요구사항을 직관적으로 이해하기 위해 꼭 필요한 과정이다.\n\n또한 **문제의 추상화**가 여기서 발생한다.\n> **추상화**\n> : 현실 세계의 개념을 우리가 다루기 쉬운 수학적/전산학적 개념으로 옮겨 표현하는 과정\n\n문제의 본질을 어떤 방식으로 재구성하느냐에 따라 같은 프로그램이라도 전혀 다른 문제로 받아들여질 수 있다. 그러므로 \"추상화 과정이 프로그래밍이 나아갈 방향을 결정한다\"고 볼 수 있다. **어떤 부분을 추상화할 것인지를 선택하는 작업**과 **문제를 재정의하는 방법들에 대한 고찰**은 좋은 프로그래머가 되기 위해 필수적인 과정이다.\n\n### 🔍 3단계: 계획 세우기\n문제를 어떤 방식으로 해결할 지 결정하고, 사용할 알고리즘과 자료 구조를 선택한다.\n\n### 🔍 4단계: 계획 검증하기\n구현 시작 전엔 계획을 검증하는 과정이 필요하다. 설계한 알고리즘이 모든 경우에 요구 조건을 정확히 수행하는지를 증명하고, 수행에 걸리는 시간과 사용하는 메모리가 문제의 제한 내에 들어가는지 확인해야 한다.\n\n### 🔍 5단계: 계획 수행하기\n아무리 좋은 알고리즘을 고안했더라도 구현이 부정확하거나 비효율적이면 프로그램은 정확히 동적할 수 없다. 구현 과정 또한 매우 중요한 부분이다.\n\n### 🔍 6단계: 회고하기\n문제 해결에 장기적으로 가장 큰 영향을 미치는 단계이다. 문제를 한 번만 풀어서는 오히려 그 문제에서 배울 수 있는 것들을 다 배우지 못하는 경우가 많다. 두번째로 문제를 풀 때는 더 효율적인 알고리즘을 찾거나 간결한 코드를 작성할 수도 있고, 같은 알고리즘을 유도하는 더 직관적인 방법을 찾을 수도 있다. \n\n효과적인 회고를 수행하는 가장 좋은 방법은 **기록**이다.\n- 문제의 간단한 해법\n- 어떤 방식으로 접근했는지\n- 문제의 해법을 찾는데 결정적으로 작용한 깨달음\n\n반대로, 한 번에 맞추지 못한 경우에는 **오답 원인에 대한 기록** 또한 좋은 회고에 도움이 된다. 대개 같은 실수를 반복하게 되는데, 오답 노트를 적음으로써 자신이 자주 틀리는 부분을 인지하게 되고, 실수를 줄이는 방법이 된다.\n\n회고를 위한 또다른 방법은 **다른 사람의 코드를 보는 것**이다. 같은 문제를 비슷한 알고리즘으로 해결한 사람의 코드도 모두 다르기 마련이다. 코드에 대한 이해는 어렵더라도 다른 방식으로 해결한 것을 보면 **새로운 사고 자극**을 얻을 수도 있다.\n\n---\n\n## 💡 문제 해결 전략\n### 🔍 직관과 체계적인 접근\n문제 해결 전략에서 가장 먼저 강조해야 할 것은 **문제와 답의 구조에 대한 직관의 중요성**이다. 직관은 해당 문제를 해결하는 알고리즘이 대략적으로 어떤 형태를 가질지를 짐작할 수 있게 해준다. 직관을 발달시키기 위해서는 막막한 문제들을 해결하며 경험을 쌓아야 하는데, 막막한 문제들을 해결하기 위해서는 **체계적인 방법**을 선택할 수도 있다. 이는 백지에서부터 시작해 문제를 해결하기 위한 기반을 쌓아올리면서 전진하는 것을 의미한다. 다음부터 소개되는 질문들은 막막한 문제에 접근할 수 있는 여러 방법을 제공한다.\n\n### 🔍 체계적인 접근을 위한 질문들\n**비슷한 문제를 풀어본 적이 있던가?**\n\n형태가 비슷하거나 관련된 문제를 풀어본 적이 있다면 이전에 적용했던 방법과 비슷한 접근 방법을 사용할 거라고 예측할 수 있다. 물론 문제만 많이 푼다고 해서 그것이 다 경험이 되진 않기에, **그 원리를 완전히 이해하고 변형할 수 있어야 한다.**\n\n**예시**\n: 철도망 위에서 두 도시를 잇는 가장 짧은 경로를 찾는 문제, 최단 경로 문제는 잘 알려진 문제이고 수많은 표준 알고리즘이 있다. 하지만 다음의 변형문제들은 조금 다를 수 있다.\n- 한 도시를 두 번 방문하지 않으면서 가장 긴 경로를 찾는 문제\n- 기차를 네 번 이하로 갈아타면서 가장 짧은 경로를 찾는 문제\n- 역 간 운행 거리 중 가장 긴 구간이 가장 짧은 경로를 찾는 문제\n- 역 간 운행 거리 중 가장 짧은 구간이 가장 긴 경로를 찾는 문제\n- 가장 긴 구간과 가장 짧은 구간의 길이 차이가 가장 적은 경로를 찾는 문제\n\n위 변형 문제들 중에는 최단 경로 문제를 응용해 풀 수 있는 것도 있고, 그렇지 않은 것도 있다. 이들을 구분하려면 최단 경로 알고리즘의 동작 과정과 원리를 완전히 이해해야 한다. 꼭 형태가 비슷하지 않더라도 문제의 목표가 같은 경우도 이런 사례에 속한다.\n\n**단순한 방법에서 시작할 수 있을까?**\n\n비슷한 문제를 본 적이 없거나 비슷한 문제의 해법이 곧장 적용되지 않는다면, **시간과 공간 제약을 생각하지 않고 문제를 해결할 수 있는 가장 단순한 알고리즘을 고안**해본다. 이 전략의 1차적인 목표는 \"간단하게 풀 수 있는 문제를 너무 복잡하게 생각해서 어렵게 푸는 실수를 예방하는 것\"이다.\n\n물론 단순한 방법으로 모든 문제가 풀릴리는 없으나 유용한 이유는 **효율적인 알고리즘이라도 단순한 알고리즘을 기반으로 구성된 경우가 많기 때문**이다. 이런 경우 좀 더 효율적인 자료 구조를 사용하거나, 계산 과정에서 같은 정보를 두 번 중복으로 계산하지 않는 등의 최적화를 적용해서 알고리즘을 개선하는 식으로 문제를 풀 수 있다.\n\n**내가 문제를 푸는 과정을 수식화할 수 있을까?**\n\n번뜩이는 영감이 필요한 문제를 만났을 때 시도할 수 있는 방법 하나는 **손으로 여러 간단한 입력을 직접 해결해보는 것**이다. 자신이 문제를 해결한 과정을 공식화해서 답을 만드는 알고리즘을 만들 수 있는 경우가 흔히 있고, 그렇지 않더라도 이 과정을 통해 알고리즘이 어떤 고려사항을 가지는지 인식할 수 있다.\n\n**문제를 단순화할 수 없을까?**\n\n**주어진 문제의 좀 더 쉬운 변형판을 먼저 풀어보는 것** 또한 좋은 문제 해결 도구가 된다.\n- 문제의 제약 조건을 제거\n- 계산해야 하는 변수의 수 감소\n- 문제의 차원을 축소\n와 같은 방법으로, 단순화시킨 문제의 해법이 원래 문제의 해법에 대한 직관을 제공할 수도 있고, 직접적인 해법에 영향을 줄 수도 있다.\n\n**그림으로 그려볼 수 있을까?**\n\n문제의 해법에 대한 직관을 얻을 수 있는 또 다른 방법은 **문제에 관련된 그림을 그려보는 것**이다. 많은 사람들의 사고 체계는 숫자의 나열보다 기하학적 도형을 더 직관적으로 받아들이기 때문이다. 예를 들면, 두 개의 정수 쌍들을 다루는 문제라면 이 정수쌍을 2차원 평면 상의 좌표 또는 직선 상의 구간들로 그려볼 수 있을 것이다.\n\n**수식으로 표현할 수 있을까?**\n\n**평문으로 쓰여있는 문제를 수식으로 표현하는 것**도 도움이 되는 경우가 있다. 수식을 전개하거나 축약하는 등의 순수한 수학적 조작이 문제를 해결하는데 큰 도움을 줄 수도 있기 때문이다. \n\n**문제를 분해할 수 있을까?**\n\n문제를 단순화하는 방법과 비슷하게, **문제의 제약 조건을 분해**하는 방법이 있다. 문제에 주어진 복잡한 조건을 더 단순한 형태를 갖는 조건의 집합으로 분해한다. 한 개의 복잡한 조건보다 여러 개의 단순한 조건이 더 다루기가 쉽기 때문에 종종 유용하게 사용된다.\n\n**뒤에서부터 생각해서 문제를 풀 수 있을까?**\n\n이 기법은 **문제에 내재된 순서를 바꿔보는 기법**이다. 전형적인 예로는 사다리 게임이 있다. 원하는 답에서부터 거꾸로 올라가 선택지를 결정하는 방식으로 해당 기법을 사용할 수 있다. \n\n**순서를 강제할 수 있을까?**\n\n위에서 언급한 순서를 바꿔보는 기법의 연장선으로, 순서가 없는 문제에 순서를 강제해서 문제를 풀 수도 있다. 또한, 이 방법은 경우의 수를 셀 때도 유용하다. 특정 조건을 만족하는 답들의 수를 세는 문제를 흔히 볼 수 있는데 이때 까다로운 것은 한 가지 답을 두 가지 이상의 방법으로 만들 수 있을 때 이 답들을 중복하여 세는 것이다. 답을 만들기 위해 할 수 있는 일들의 순서를 강제하는 것은 좋은 해법이 된다.\n\n**특정 형태의 답만을 고려할 수 있을까?**\n\n순서를 강제하는 기법의 연장선으로, 정규화(Canonicalization) 기법이 있다. 이는 우리가 고려해야 할 답들 중 형태가 다르지만 결과적으로는 똑같은 것들을 그룹으로 묶은 뒤, 각 그룹의 대표들만을 고려하는 방법이다.\n\n## 📕 참고\n**프로그래밍 대회에서 배우는 알고리즘 문제 해결 전략** - 구종만"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 3장에서 요구사항으로 제시한 내용을 직접 구현하면서 HTTP 프로토콜에 대해 이해하는 장이다. 🚩 HTTP 웹 서버 구현 🔧 요구사항 1 - index.html 응답하기 이 요구사항을 구현하기 위해서는 먼저 \"클라이언트가 서버로 전송하는 데이터의 구성\"을 확인해야 한…","fields":{"slug":"/[NextStep]4/"},"frontmatter":{"date":"January 31, 2022","title":"📖 4장 HTTP 웹 서버 구현을 통해 HTTP 이해하기","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 3장에서 요구사항으로 제시한 내용을 직접 구현하면서 HTTP 프로토콜에 대해 이해하는 장이다.\n\n## 🚩 HTTP 웹 서버 구현\n### 🔧 요구사항 1 - index.html 응답하기\n이 요구사항을 구현하기 위해서는 먼저 \"클라이언트가 서버로 전송하는 데이터의 구성\"을 확인해야 한다.\n\n```java\nBufferedReader br = new BufferedReader(new InputStreamReader(in, \"UTF-8\"));\nString line = br.readLine();\nlog.debug(\"request line: {}\", line);\n\nif (line == null) {\n    return;\n}\n\nwhile (!line.equals(\"\")) {\n    line = br.readLine();\n    log.debug(\"header : {}\", line);\n}\n```\n\n- 요청 데이터를 위와 같이 출력한다.\n  - 서버를 동작시키면 `New Client Connect! ... Port : 6217`, `New Client Connect! ... Port : 6218`, `request line : GET /index.html HTTP/1.1`, `header : Host: localhost:8080` ... 등의 정보가 출력되는 것을 확인할 수 있다. \n\n이를 통해 확인할 수 있는 내용은 다음과 같다.\n1. 우선 클라이언트 연결 출력문이 2개다. 이는 2개의 요청이 발생했다는 의미이며 각 요청마다 서로 다른 **Port**로 연결한다.\n   - 이때 서버는 각 요청에 대해 순차적 실행이 아닌 **Thread**를 생성하여 각 요청에 동시에 대응한다. (출력문을 확인해보면 `[Thread-0]` or `[Thread-1]` 과 같이 사용하는 Thread의 정보를 확인할 수 있다.)\n2. 각 요청의 첫번째 라인은 `GET /index.html HTTP/1.1` 과 같은 형태이다. \n3. 첫번째 라인을 제외한 나머지 요청 데이터는 **\"필드 이름: 필드 값\"** 형태로 구성된다.\n4. 각 요청의 마지막은 **빈 문자열(\"\")**이다.\n\n웹 클라이언트는 웹 서버와 데이터를 주고 받기 위해 `HTTP` 라는 통신 규약을 따른다. 통신 규약은 다음과 같다.\n> POST /user/create HTTP/1.1 → **요청 라인**\n> HOST: localhost:8080 <br/>\n> Connection-Length: 59 <br/>\n> Content-Type: application/x-www-form-urlencoded <br/>\n> Accept: \\*/* → 여기까지가 **요청 헤더** <br/>\n> → **헤더와 본문 사이의 빈 공백라인** <br/>\n> userId=javajigi@password=password → **요청 본문**\n\n모든 HTTP 요청에 대해 요청 라인, 요청 헤더, 빈 공백 라인은 필수이고, 요청 본문은 필수가 아니다.\n\n**요청 라인 (Request Line)**<br/>\n: 요청 데이터의 첫 번째 라인\n\n**\"HTTP-메소드 URI HTTP-버전\"** 으로 구성되어 있다.\n- **HTTP 메소드**는 요청의 종류를 나타낸다.\n- **URI**는 클라이언트가 서버에 유일하게 식별할 수 있는 요청 자원의 경로를 의미한다.\n  - 일반적으로 URL과 거의 같은 의미\n- **HTTP-버전**은 현재 요청의 HTTP 버전이다.\n\n**요청 헤더 (Request Headers)**<br/>\n: <필드 이름> : <필드 값> 쌍으로 이루어져 있다. 여러 개의 필드 값을 전달하는 경우 쉼표(,)를 구분자로 전달할 수 있다.\n\n클라이언트의 요청을 받은 서버는 요청에 대한 응답을 한다. HTTP 응답 또한 요청과 같이 **헤더**와 **본문**으로 구성되어 있다. 아래는 응답의 예시이다.\n\n> HTTP/1.1 200 OK → **상태 라인** <br/>\n> Content-Type : text/html;charset=utf-8 <br/>\n> Content-Length: 20 → 여기까지가 **응답 헤더** <br/>\n> → **헤더와 본문 사이의 빈 공백 라인** <br/>\n> \\<h1>Hello World\\</h1> → **응답 본문**\n\n응답 메세지의 첫 번째 라인은 상태 라인(Status), 두 번째 라인부터 빈 공백 문자열 라인까지 응답 헤더(header)이고, 그 다음부터 응답으로 보낼 본문(body) 데이터이다.\n\n> 요청 메세지와 같은 문법이지만, 첫 번째 라인의 형식이 다르다.\n \n**상태 라인 (Status Line)**<br/>\n**\"HTTP-버전 상태코드 응답구문\"** 으로 구성되어 있다. \n- **HTTP-버전**은 HTTP 요청 라인(Request line)의 HTTP-버전과 같은 의미이다.\n- **상태코드**는 응답에 대한 상태를 의미하는 코드 값으로 200은 \"성공\"을 의미한다.\n  - 상태코드는 이외에도 다양한 상태코드가 있다.\n- **응답 구문**은 응답 상태에 대한 설명이다.\n\n이제, 클라이언트가 요청하는 자원이 무엇인지 구분할 필요가 있다. `GET /index.html HTTP/1.1` 에서 `/index.html` 을 분리해 해당 자원을 웹 서버에서 읽은 후 브라우저로 응답을 전송하면 된다.\n\n```java\nString[] tokens = line.split(\"\");\n...\nbyte[] body = Files.readAllBytes(new File(\"./webapp\" + tokens[1]).toPath());\n```\n\n- 요청 메세지 구조 분석이 끝나면, 요청 URI에 해당하는 자원을 읽어 응답으로 보낸다.\n- 분명 `/index.html` 로 요청을 한 번 보냈을 뿐인데 여러 번의 요청이 발생하는 것을 확인할 수 있다.\n  - `GET /css/bootstrap.min.css HTTP/1.1`, `GET /css/style.css HTTP/1.1`, `GET /js/jquery-2.2.0.min.js HTTP/1.1` 와 같은 여러 요청에 대한 Thread가 생성되어 처리된다.\n- 이렇게 여러 개의 요청이 발생하는 이유는 **\"서버가 웹 페이지를 구성하는 모든 자원(HTML, CSS, JS, 이미지 등)을 한 번에 응답으로 보내지 않기 때문\"** 이다.\n  1. 웹 서버는 `/index.html` 요청에 대한 응답에 HTML만 보낸다.\n  2. 응답을 받은 브라우저는 HTML 내용을 분석해 CSS, JS, 이미지 등의 자원이 포함되어 있는지 확인하고, 서버에 해당 자원을 다시 요청한다.\n  3. 결과적으로 여러 번의 요청과 응답이 발생하게 된다.\n\n### 🔧 요구사항 2 - GET 방식으로 회원가입하기\n회원가입을 할 경우 사용자 입력 데이터가 웹 서버에 전달되어야 한다. 요청 메세지를 분석해보면, 첫 번째 라인에 사용자 입력 데이터가 전달되는 것을 확인할 수 있다.\n```bash\nGET /user/create?userId=javajigi&password=password&name=jaesung&email=javajigi%40slipp.net HTTP1/1.1\n```\n\n- 위와 같이 요청이 보내지는 이유는 `user/form.html` 을 확인해보면 알 수 있다.\n  - 요청 라인의 **GET** : `form` 태그에서 사용하는 `method` 가 `get`\n  - 요청 **URI** : `form` 태그의 `action` 이 `user/create`\n\n요청 URI을 더 자세하게 살펴보면,\n- `\"/user/create\"` 는 요청 자원의 위치를 나타내는 경로(path)이고, 물음표 뒤에 전달되는 매개변수를 쿼리 스트링(query string)이다.\n- 회원가입 기능의 구현을 위해서는 **경로와 쿼리 스트링을 분리**하는 것이 먼저이다.\n  - 이를 분리한 후 쿼리 스트링에서 사용자의 입력 값은 **매개변수와 값**으로 분리해 `User` 객체에 저장하는 방식으로 구현해야 한다.\n  - 물음표(?)를 기준으로 경로와 쿼리 스트링으로 분리하는 방법은 `split()`, 정규표현식 사용, 물음표가 위치하는 위치 값(index)을 사용하는 방법 등으로 여러 가지가 있다.\n  - 예제에서는 물음표가 위치하는 값(index)을 사용하여 쿼리 스트링을 매개변수와 값으로 분리해 `Map<String, String>` 에 저장하고 있다.\n\n**GET 방식의 문제점**<br/>\n- 사용자가 입력한 데이터가 브라우저 URL 입력창에 그대로 노출된다.\n  - 회원가입을 하는 경우, 비밀번호까지 URL에 노출되기 때문에 보안 측면에서도 좋지 않다. (로그인의 경우도 동일할 듯하다.)\n- 요청 라인의 길이에 제한이 있다. 즉, 사용자가 입력할 수 있는 데이터 크기에 제한이 있다.\n\n이러한 문제점을 극복하기 위해 HTTP는 **POST 방식**을 지원한다.\n\n### 🔧 요구사항 3 - POST 방식으로 회원가입하기\n요구사항 2에서 사용한 GET 방식의 문제를 해결하기 위해 POST 방식을 사용한다. 이를 위해 `/user/form.html` 의 `form` 태그 `method` 속성을 **post**으로 수정한다.\n\n**POST 방식의 요청 라인**<br/>\n: `POST /user/create HTTP/1.1`\n\n요청 URI에 포함되어 있던 **쿼리 스트링이 없어지고, method가 변경**되었다.\n- 사라진 쿼리 스트링은 **HTTP 요청의 본문(body)을 통해 전달**된다.\n- POST 방식으로 데이터를 전달하면서 헤더에 본문 데이터에 대한 길이가 `Content-Length` 라는 필드 이름으로 전달된다.\n\n**요구 사항 3의 구현**\n1. 헤더에 포함되어 있는 `Content-Length` 의 값을 구해 본문의 길이를 구한다.\n2. 구한 길이만큼 본문을 읽은 후 본문 데이터를 `Map<String, String>` 형태로 변환한다.\n   - `IOUtils.readData()` 를 사용해 본문을 읽고 있다.\n\nHTTP는 사용자의 요청 형태에 따라 여러 개의 메소드를 지원한다. <br/>\n웹 애플리케이션 개발 시 자주 사용하는 메소드는 **GET** & **POST**이다. \n- HTTP가 지원하는 메소드는 HEAD, PUT, DELETE, PATCH, TRACE, OPTIONS가 있다.\n  - [HTTP 메소드](https://developer.mozilla.org/ko/docs/Web/HTTP/Methods)\n- HTML에서 GET, POST 메소드만 사용 가능하도록 지원하고 있지만, 최근 REST API 설계와 AJAX 기반 웹 애플리케이션 개발 경향이 생기면서 PUT, DELETE 메소드까지 활용할 것을 추천한다.\n\nHTML의 모든 `<a>` 태그 링크, CSS, JS, 이미지 요청 모두 **GET** 방식으로 요청을 보낸다. **POST** 방식은 `<form>` 태그를 통해 요청을 보낼 수 있다. (`<form>` 태그가 지원하는 method 속성은 **GET**과 **POST** 뿐이다.)\n- 나머지 메소드는 서버와의 비동기 통신을 담당하는 **AJAX**에서 사용할 수 있다.\n\n> **GET과 POST를 사용하는 기준**<br/>\n> 웹 애플리케이션 개발 시 HTTP method를 사용하는 기준이 필요하다. \n> - **GET**은 서버에 존재하는 데이터(또는 자원)을 가져오는 것이다.\n> - **POST**는 서버에 요청을 보내 데이터 추가, 수정, 삭제와 같은 작업을 실행하도록 하는 것이다.\n> \n> **GET**은 서버에 존재하는 데이터를 조회하는 역할만 하는 것이지 **데이터의 상태를 변경하지 않는다.** \n> 하지만 **POST**는 **데이터의 상태를 변경하는 작업을 담당**한다.\n\n### 🔧 요구사항 4 - 302 status code 적용\n회원가입을 완료한 후 사용자에게 첫 화면(`/index.html`)을 보여주고 싶다. 이를 위해 회원가입 요청(`/user/create`)을 완료한 후 요청 URL 값을 `\"/index.html\"` 로 변경하면 웹 서버는 `/index.html` 파일을 읽어 응답으로 전달한다.\n\n```java\nString url = tokens[1];\nif (\"/user/create\".equals(url)) {\n  ...\n  log.debug(\"User: {}\", user);\n  url = \"/index.html\";\n}\n```\n\n이 구현 방식에는 문제점이 하나 있다. \n-  브라우저에서 **새로고침**하면, 보이는 화면은 `index.html` 이지만, 앞에서 요청한 회원가입 양식이 재전송되는 것을 확인할 수 있다.\n-  이러한 요청이 재발생하는 이유는 **브라우저가 이전 요청 정보를 유지**하고 있기 때문이다.\n   -  **새로고침하면 유지하고 있던 요청을 다시 요청하는 방식으로 동작**하기 때문이다.\n-  이전 요청 정보를 확인하기 위해 브라우저의 URL을 확인하면, 회원가입 완료 후 브라우저 URL은 `/user/create` 이고 보고 있는 화면은 `/index.html` 의 결과 화면이다.\n   -  이 상태에서 새로고침하면 `/index.html` 화면을 보여주기 전에 회원가입 처리를 한 후 `/index.html` 을 응답으로 전송한다.\n   -  즉, **데이터가 증복으로 전송**된다!\n\n이러한 문제를 해결하기 위해서는,\n- 회원가입을 처리하는 `/user/create` 요청과 첫 화면(`/index.html`)을 보여주는 요청을 분리한다.\n- **HTTP의 302 상태 코드**를 활용한다.\n\n```bash\nHTTP/1.1 302 Found\nLocation: /index.html\n```\n\n- 위와 같은 응답으로, 클라이언트는 첫 라인의 상태 코드를 확인한 후 **302**라면 `Location` 의 값을 읽어 서버에 재요청을 보낸다.\n- 클라이언트의 요청은 회원가입 처리를 위한 `/user/create` 요청이 아닌 `/index.html` 요청으로 변경된다.\n- 브라우저 URL도 변경된 것을 확인할 수 있다. (눈으로 확인은 어려움)\n\n**클라이언트와 서버 사이의 요청과 응답 흐름**<br/>\n**302 상태 코드를 사용하기 전**\n1. 회원가입 요청\n2. 회원가입 처리 완료\n3. `index.html` 파일 읽기\n4. `/index.html 200` 응답\n\n→ **클라이언트와 서버 간의 요청과 응답이 한 번만 발생**한다.\n\n**302 상태 코드를 사용한 후**\n1. 회원가입 요청\n2. 회원가입 처리\n3. `/index.html 302` 응답\n4. `/index.html` 요청\n5. `/index.html` 파일 읽기\n6. `/index.html 200` 응답\n\n→ **클라이언트와 서버 간의 요청과 응답이 두 번 발생**한다.\n\n**대표적인 상태 코드**<br/>\n- 2XX : **성공**, 클라이언트가 요청한 동작을 수신하여 이해했고 승낙했으며 성공적으로 처리\n- 3XX : **리다이렉션**, 클라이언트는 요청을 마치기 위해 추가 동작을 수행해야 함\n- 4XX : **요청 오류**, 클라이언트의 요청에 오류가 있음\n- 5XX : **서버 오류**, 서버가 유효한 요청을 정상적으로 수행하지 못함\n\n### 🔧 요구사항 5 - 로그인하기\n\"HTTP는 요청을 보내고 응답을 받으면 클라이언트와 서버 간의 연결을 끊는다.\"\n\n이와 같이 클라이언트와 서버 간의 연결을 끊기 때문에 각 요청 사이에 상태를 공유할 수 없어 **무상태 프로토콜**이라고 한다. 이러한 특성으로 인해 서버는 클라이언트가 누구인지 식별할 방법이 없다는 문제가 발생한다.\n\n로그인과 같이 클라이언트의 행위를 기억하기 위한 무언가가 필요한데, HTTP는 이 목적으로 **쿠키(Cookie)**를 지원한다.\n- 서버에서 로그인 요청을 받으면 로그인 성공/실패 여부에 따라 응답 헤더에 `Set-Cookie` 로 결과 값을 저장한다.\n- 클라이언트는 응답 헤더에 `Set-Cookie` 가 존재할 경우 이 값을 읽어 서버에 보내는 요청 헤더의 **Cookie 값**으로 다시 전송한다.\n\n**즉, HTTP는 헤더를 통해 공유할 데이터를 매번 다시 전송하는 방식으로 각 요청 간의 데이터(상태)를 공유한다.**\n\n- 로그인 기능의 구현을 위해서는 회원가입한 사용자를 DB에 저장하고 있어야 한다. \n- 로그인이 성공하면 응답 헤더에 `Set-Cookie` 헤더의 값으로 `logined=true` 를 전달한다.\n- 로그인이 성공한 이후부터의 요청 헤더를 보면, `Cookie: logined=true` 가 추가되어 전달되는 것을 확인할 수 있다.\n\n이와 같이 모든 요청에 로그인 성공 유무에 대한 정보가 전달되어, 서버가 클라이언트의 상태를 파악할 수 있다.\n\n> **모든 요청에 전달된다**는 특성으로, **쿠키의 크기가 커질수록 서버 트래픽에 부하가 가해질 수 있다**는 단점 또한 존재한다.\n\n### 🔧 요구사항 6 - 사용자 목록 출력\n**Cookie 헤더 값**을 활용해 현재 요청을 보낸 사용자가 로그인한 사용자인지를 판단해야 한다.\n- 로그인을 정상적으로 수행한 사용자라면, 앞의 구현을 통해 `Cookie` 에 `logined=true` 가 저장되어 있을 것이다.\n- `/user/list` 로 요청이 들어온 경우, 요청 헤더를 확인하여 `Cookie` 값이 존재하는지, 그리고 `logined=true` 인지를 확인하여 로그인 유무를 판단한다.\n- 로그인하지 않은 사용자라면 `/user/login.html` 로 보낸다.\n\n> 서버가 전달하는 쿠키 정보는 **클라이언트에 저장해 관리**한다. 이로 인해 **보안 이슈**가 존재한다.\n> 이러한 단점을 보완하기 위해 **세션**이 등장했다. 이 또한 쿠키를 기반으로 하지만 보안 강화를 위해 **상태 데이터를 서버에 저장**한다.\n\n### 🔧 요구사항 7 - CSS 지원하기\n서비스한 HTML 소스코드를 보면,\n- `<link>` 태그에 CSS 파일도 정상적으로 설정\n- 물리적인 CSS 파일도 해당 위치에 존재\n- CSS 파일에 대한 요청도 정상\n\n하지만 CSS 파일이 적용되지 않고 있다.\n\n이는 브라우저는 응답을 받은 후 `Content-Type` 헤더 값을 통해 응답 본문에 포함되어 있는 컨텐츠의 유형을 판단한다. 하지만 현재 응답을 보낼 때, 모든 컨텐츠의 타입을 `text/html` 로 보내기 때문에 브라우저는 CSS 파일도 HTML로 판단하여 정상적으로 적용되지 않았다.\n\n문제 해결을 위해, CSS 파일 요청 시, `Content-Type` 헤더 값을 `text/css` 로 수정한 응답을 보내야 한다.\n- 요청 URL의 확장자가 `css` 인 경우 `text/css` 응답을 보내도록 구현한다.\n\n```java\nelse if (url.endsWith(\".css\")) {\n  byte[] body = Files.readAllBytes(new File(\"./webapp\" + url).toPath());\n  response200CssHeader(dos, body.length);\n  responseBody(dos, body);\n}\n\n...\n\nprivate void response200CssHeader(DataOutputStream dos, int lengthOfBodyContent) {\n  try {\n    dos.writeBytes(\"HTTP/1.1 200 OK \\r\\n\");\n    dos.writeBytes(\"Content-Type: text/css\\r\\n\");\n    dos.writeBytes(\"Content-Length: \" + lengthOfBodyContent + \"\\r\\n\");\n    dos.writeBytes(\"\\r\\n\");\n  } catch (IOException e) {\n    log.error(e.getMessage());\n  }\n}\n```\n\n각 요청과 응답 헤더는 각 요청과 응답이 포함하고 있는 본문 컨텐츠에 대한 정보를 제공한다. 이러한 헤더 정보들을 **메타데이터**라고 한다.\n예로, `Content-Type` , `Content-Length` 헤더 정보는 실제 데이터가 아닌 본문 컨텐츠에 대한 타입과 길이 정보를 포함한다.\n\n## 📕 출처\n**자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. 3장은 로컬에서 웹 애플리케이션을 개발, 버전 관리 시스템에서 소스코드를 관리, 개발한 웹 애플리케이션을 원격 서버에 실제 배포하는 경험을 하고, 구현할 질문/답변 게시판에 대한 서비스 요구사항과 실습 요구사항을 제시한다.\n또한, HTTP 웹 서버를 직접 구현하는 경…","fields":{"slug":"/[NextStep]3/"},"frontmatter":{"date":"January 25, 2022","title":"📖 3장 개발 환경 구축 및 웹 서버 실습 요구사항","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> 3장은 로컬에서 웹 애플리케이션을 개발, 버전 관리 시스템에서 소스코드를 관리, 개발한 웹 애플리케이션을 원격 서버에 실제 배포하는 경험을 하고, 구현할 질문/답변 게시판에 대한 서비스 요구사항과 실습 요구사항을 제시한다.\n> 또한, HTTP 웹 서버를 직접 구현하는 경험을 함으로써 웹 클라이언트와 서버 간 데이터를 어떻게 주고 받는지에 대해 학습한다.\n\n## 🚩 서비스 요구사항\n<em>질문/답변 게시판</em>\n\n### 🔧 질문 목록 화면\n- 회원가입\n- 로그인\n- 로그아웃\n- 개인정보 수정\n- 질문하기\n- 각 질문 제목을 클릭하여 상세보기 화면으로 이동\n  - 답변 추가, 질문과 답변의 수정/삭제\n\n---\n\n## 🚩 로컬 개발 환경 구축\n<em>자바 8버전 & Intellij 통합 개발 환경</em>\n\nhttps://github.com/slipp/web-application-server, https://www.youtube.com/watch?v=5hjYe_PggJI 참고!\n\n---\n\n## 🚩 원격 서버에 배포\n<em>애자일 프로세스의 접근 방식</em>\n: 현 시점에 가장 가치있는, 동작하는 소프트웨어를 만드는 것을 원칙으로 하는 방식이다.\n\n로컬 개발 환경을 구축한 후 바로 실습 단계를 진행할 수 있지만 실습을 진행하기 전에 먼저 HTTP 웹 서버를 원격 서버에 배포해보자. 이러한 경험을 통해 터미널 환경에서 작업하는 것에 익숙해지도록 한다. \nhttps://opentutorials.org/module/1946 참고하여 AWS에 대한 회원가입, 우분투 운영체제 설치, SSH를 통한 접근을 진행할 수 있다.\n\n### 🔧 요구사항\n로컬 개발 환경에 설치한 HTTP 웹 서버를 물리적으로 떨어져 있는 원격 서버에 배포해 정상적으로 동작하는지 테스트한다.\n\n---\n\n## 🚩 웹 서버 실습\n### 🔧 실습 환경 세팅 및 소스코드 분석\n실습으로 진행할 HTTP 웹 서버는 앞의 로컬 개발 환경에서 세팅한 Git 저장소의 **master** 브랜치에서 시작하면 된다.\n\n실습 HTTP 웹 서버의 핵심이 되는 코드는 `webserver` 패키지의 `WebServer`, `RequestHandler` 클래스이다.\n- `WebServer` 클래스는 웹 서버를 시작하고, 사용자의 요청이 있을 때까지 대기 상태에 있다가 사용자 요청이 있을 경우 해당 요청을 `RequestHandler` 클래스에 위임하는 역할을 수행한다.\n\n```java\n// in WebServer.java\ntry (ServerSocket listenSocket = new ServerSocket(port)) {\n  log.info(\"Web Application Server started {} port.\", port);\n\n  // 클라이언트가 연결될때까지 대기한다.\n  Socket connection;\n  while ((connection = listenSocket.accept()) != null) {\n      RequestHandler requestHandler = new RequestHandler(connection);\n      requestHandler.start();\n  }\n}\n```\n\n- 사용자 요청이 발생할 때까지 대기 상태에 있도록 지원하는 역할은 자바에 포함되어 있는 `ServerSocket` 클래스가 담당한다. \n- 사용자 요청이 발생하는 순간 클라이언트와 연결을 담당하는 `Socket` 을 `RequestHandler` 에 전달하면서 새로운 스레드를 실행하는 방식으로 **멀티스레드 프로그래밍**을 지원한다.\n\n```java\n// in RequestHandler.java\npackage webserver;\n\nimport java.io.DataOutputStream;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.io.OutputStream;\nimport java.net.Socket;\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\npublic class RequestHandler extends Thread {\n    private static final Logger log = LoggerFactory.getLogger(RequestHandler.class);\n\n    private Socket connection;\n\n    public RequestHandler(Socket connectionSocket) {\n        this.connection = connectionSocket;\n    }\n\n    public void run() {\n        log.debug(\"New Client Connect! Connected IP : {}, Port : {}\", connection.getInetAddress(),\n                connection.getPort());\n\n        try (InputStream in = connection.getInputStream(); OutputStream out = connection.getOutputStream()) {\n            // TODO 사용자 요청에 대한 처리는 이 곳에 구현하면 된다.\n            DataOutputStream dos = new DataOutputStream(out);\n            byte[] body = \"Hello World\".getBytes();\n            response200Header(dos, body.length);\n            responseBody(dos, body);\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n\n    private void response200Header(DataOutputStream dos, int lengthOfBodyContent) {\n        try {\n            dos.writeBytes(\"HTTP/1.1 200 OK \\r\\n\");\n            dos.writeBytes(\"Content-Type: text/html;charset=utf-8\\r\\n\");\n            dos.writeBytes(\"Content-Length: \" + lengthOfBodyContent + \"\\r\\n\");\n            dos.writeBytes(\"\\r\\n\");\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n\n    private void responseBody(DataOutputStream dos, byte[] body) {\n        try {\n            dos.write(body, 0, body.length);\n            dos.flush();\n        } catch (IOException e) {\n            log.error(e.getMessage());\n        }\n    }\n}\n```\n\n- `RequestHandler` 클래스는 `Thread` 를 상속하고, **사용자의 요청에 대한 처리와 응답에 대한 처리를 담당하는 클래스**이다.\n- 앞으로의 모든 실습은 `RequestHandler` 클래스의 `run()` 메소드에서 구현할 수 있다.\n  - 해당 메소드의 복잡도가 증가하는 경우, 새로운 클래스 또는 메소드로 분리하는 방식으로 리팩토링을 수행할 수 있다.\n- `InputStream` : 클라이언트(웹 브라우저)에서 서버로 요청을 보낼 때 전달되는 데이터를 담당\n- `OutputStream` : 서버에서 클라이언트에 응답을 보낼 때 전달되는 데이터를 담당\n  - 웹 서버 입장에서 이해!\n\n전체적인 흐름은,\n- `브라우저` 와 `WebServer의 RequestHandler` 는 `Socket` 이라는 통로로 통신한다.\n- 해당 통로의 `InputStream` & `OutputStream` 수단을 통해 데이터를 주고 받는다.\n\n> \"프로그래밍 실행 중 발생하는 로그 메세지를 주의 깊게 살펴보는 것은 좋은 습관 중 하나이다.\"\n\n### 🔧 실습 요구사항\n**요구사항 1 - index.html 응답하기**<br/>\n: 현재 HTTP 웹 서버에 접속하면 무조건 \"Hello World\" 라는 문구만 뜬다. 이를 `http://localhost:8080/index.html` 로 접속했을 때, `index.html` 파일을 응답할 수 있도록 한다.\n\n```java\n try (InputStream in = connection.getInputStream(); OutputStream out = connection.getOutputStream()) {\n  // TODO 사용자 요청에 대한 처리는 이 곳에 구현하면 된다.\n  BufferedReader br = new BufferedReader(new InputStreamReader(in));\n\n  String line = br.readLine();\n  if (line == null) {return ;}\n  String[] tokens = line.split(\" \");\n\n  while (!\"\".equals(line)) {\n      line = br.readLine();\n  }\n\n  byte[] body = Files.readAllBytes(new File(\"./webapp\" + tokens[1]).toPath());\n  // byte[] body = \"Hello World\".getBytes();\n\n  DataOutputStream dos = new DataOutputStream(out);\n  response200Header(dos, body.length);\n  responseBody(dos, body);\n} catch (IOException e) {\n  log.error(e.getMessage());\n}\n```\n\n- `InputStream` , 즉 클라이언트가 보내는 요청을 한 줄 단위로 읽기 위해 `BufferedReader` 를 사용한다.\n- `null` 인 경우는 `return`\n- `line` 을 **\" \"** 단위로 잘라 저장하고, `GET /index.html HTTP/1.1` 같은 형식이므로 `token[1]` 에 요청하는 파일의 정보가 담긴다.\n- 해당 파일 데이터를 `byte[]` 로 읽어 `response` 에 전달한다.\n\n**요구사항 2 - GET 방식으로 회원가입하기**<br/>\n: 회원가입 메뉴를 클릭하면 http://localhost:8080/user/form.html 로 이동하면서 회원가입이 가능하다. 회원가입을 수행하면 다음과 같은 형태로 사용자 입력값이 서버에 전달된다.\n\n```bash\n/user/create?userId=javajigi&password=password&name=JaeSung&email=javajigi%40slipp.net\n```\n\nHTML과 URL을 비교하고 사용자 입력 값을 파싱해 `model.User` 클래스에 저장한다.\n\n```java\nif (url.startsWith(\"/user/create\")) {\n    int index = url.indexOf(\"?\");\n    if (index != -1) {\n        Map<String, String> map = HttpRequestUtils.parseQueryString(url.substring(index+1));\n        User user = new User(map.get(\"userId\"), map.get(\"password\"), map.get(\"name\"), map.get(\"email\"));\n        System.out.println(user);\n    }\n}\n```\n\n- URL이 `/user/create` 로 시작하는 경우, 회원가입 요청이다.\n- 쿼리 문자열을 (이름, 값) 과 같은 형태로 분석하는 `parseQueryString` 을 이용하여 파라미터로부터 사용자 입력 값을 파싱한다.\n- 파싱한 값을 `User` 객체에 담는다.\n- 그 다음은 어떻게 ...\n\n**요구사항 3 - POST 방식으로 회원가입하기**<br/>\n: http://localhost:8080/user/form.html 파일의 `form` 태그 메소드를 **`POST`** 로 수정한 후 회원가입을 구현한다.\n\n```java\nelse if (tokens[0].equals(\"POST\")) {\n    while(!line.equals(\"\")) {\n        line = br.readLine();\n        if (line.contains(\"Content-Length\")) {\n            String[] content = line.split(\":\");\n            contLength = Integer.parseInt(content[1].trim());\n        }\n    }\n    String body = IOUtils.readData(br, contLength);\n    Map<String, String> map = HttpRequestUtils.parseQueryString(body);\n    User user = new User(map.get(\"userId\"), map.get(\"password\"), map.get(\"name\"), map.get(\"email\"));\n    System.out.println(user);\n}\n```\n\n- `/user/create` 분기에서 걸러지고, `GET` or `POST` 이므로 한 번 더 분기를 나눈다.\n- HTTP header와 body 사이에 빈 공백이 존재한다고 했으므로, 그 전까지 HTTP 요청을 읽으면서, `Content-Length` 값을 탐색한다.\n  - 이떄, `Content-Length: 55` 와 같은 형식이라 `content[1]` 의 첫번째 자리에 공백이 포함되므로 `trim()` 을 이용해 이를 제거한다.\n- `IOUtils.readData` 에 `reader` 와 `size` 를 주고 데이터를 읽고 `GET` 과 동일하게 사용자 입력 값을 파싱한다.\n\n**요구사항 4 - 302 status code 적용**<br/>\n: 회원가입을 완료한 후 `/index.html` 로 이동하고 싶다.\n\n```java\nresponse302Header(dos, \"/index.html\");\n\n...\n\nprivate void response302Header(DataOutputStream dos, String url) {\n    try {\n        dos.writeBytes(\"HTTP/1.1 302 Redirect \\r\\n\");\n        dos.writeBytes(\"Location: \" + url + \" \\r\\n\");\n        dos.writeBytes(\"\\r\\n\");\n    } catch (IOException e) {\n        log.error(e.getMessage());\n    }\n}\n```\n\n- **302** code는 3XX Redirection 클래스에 속하는 HTTP 상태코드이다.\n  - 클라이언트를 지정된 위치로 이동시키거나 참조하게 하는 등의 동작을 수행한다.\n  - [참고1](https://en.wikipedia.org/wiki/HTTP_302), [참고2](https://nsinc.tistory.com/168)\n\n**요구사항 5 - 로그인하기**<br/>\n: 로그인 메뉴를 클릭하면 `~/user/login.html` 로 이동해 로그인할 수 있다. 성공하면 `/index.html` 로 이동하고, 그렇지 않으면 `/user/login_failed.html` 로 이동해야 한다.\n\n앞에서 회원가입한 사용자로 로그인할 수 있어야 한다. 로그인 성공 시, 쿠키를 활용해 로그인 상태를 유지할 수 있어야 한다. 로그인이 성공할 경우 요청 헤더의 Cookie 헤더 값이 `logined=true`, 실패할 경우 `logined=false` 로 전달되어야 한다.\n\n```java\nelse if (url.equals(\"/user/login\")) {\n    if (tokens[0].equals(\"POST\")) {\n        while(!line.equals(\"\")) {\n            line = br.readLine();\n            log.debug(\"Header : {}\", line);\n            if (line.contains(\"Content-Length\")) {\n                String[] content = line.split(\":\");\n                contLength= Integer.parseInt(content[1].trim());\n            }\n        }\n        String body = IOUtils.readData(br, contLength);\n        Map<String, String> map = HttpRequestUtils.parseQueryString(body);\n        User user = DataBase.findUserById(map.get(\"userId\"));\n        log.debug(\"User : {}\", user);\n        if (user == null) {\n            responseFail(dos, \"/user/login_failed.html\");\n            return;\n        }\n        if (user.getPassword().equals(map.get(\"password\"))) {\n            response302Logined(dos);\n        } else {\n            responseFail(dos, \"/user/login_failed.html\");\n            return;\n        }\n    }\n}\n\nprivate void response302Logined(DataOutputStream dos) {\n    try {\n        dos.writeBytes(\"HTTP/1.1 302 Redirect \\r\\n\");\n        dos.writeBytes(\"Location: /index.html \\r\\n\");\n        dos.writeBytes(\"Set-Cookie: logined=true \\r\\n\");\n        dos.writeBytes(\"\\r\\n\");\n    } catch (IOException e) {\n        log.error(e.getMessage());\n    }\n}\n\nprivate void responseFail(DataOutputStream dos, String url) throws IOException {\n    byte[] body = Files.readAllBytes(new File(\"./webapp\" + url).toPath());\n\n    response200Header(dos, body.length);\n    responseBody(dos, body);\n}\n```\n\n- `/user/login` 에 **POST**를 보내는 경우, HTTP body를 읽어 사용자 입력 값을 추출한다.\n- DB에 저장되어 있는 값과 비교한 후, 각 경우에 맞게 response를 전달한다.\n\n**요구사항 6 - 사용자 목록 출력**<br/>\n: 사용자가 로그인 상태인 경우 `http://localhost:8080/user/list` 로 접근했을 때 사용자 목록을 출력한다. 로그인하지 않은 상태라면 `login.html` 로 이동한다.\n\n```java\nelse if (url.equals(\"/user/list\")) {\n    if (tokens[0].equals(\"GET\")) {\n        while(!line.equals(\"\")) {\n            line = br.readLine();\n            log.debug(\"Header : {}\", line);\n            if (line.contains(\"Cookie\")) {\n                login = isLogin(line);\n            }\n        }\n        if (!login) {\n            responseFail(dos, \"/user/login.html\");\n            return;\n        }\n        Collection<User> users = DataBase.findAll();\n        StringBuilder sb = new StringBuilder();\n        sb.append(\"<h1>회원 목록</h1>\");\n        for (User user : users) {\n            sb.append(\"<p>\" + user.getUserId() + \"</p>\");\n            sb.append(\"<p>\" + user.getName() + \"</p>\");\n            sb.append(\"<p>\" + user.getEmail() + \"</p>\");\n        }\n        sb.append(\"<h2>목록 끝</h2>\");\n        byte[] body = sb.toString().getBytes();\n        response200Header(dos, body.length);\n        responseBody(dos, body);\n    }\n}\n```\n\n- `Cookie` 값을 가져와 로그인한 사용자인지 판단한다.\n  - 로그인하지 않은 경우 `login.html` 을 전달한다.\n  - `Database.findAll()` 로 회원가입된 모든 사용자를 가져온다.\n  - `StringBuilder` 를 이용해 출력할 HTML code를 작성하고, 이를 response한다.\n\n> **String은 불변 객체**이다. 2개의 String 객체가 있을 때, 두 객체를 더하는 연산은 새로운 String을 생성한다. 이 때, **메모리 할당과 해제를 발생**시켜 더하는 연산이 많아질수록 성능적으로 좋지 않다.\n> 따라서, 문자열을 더할 때 새로운 객체를 생성하는 것이 아닌 기존의 데이터에 더하는 방식을 사용하는 **`StringBuilder`** 클래스가 생겨났다.\n\n**요구사항 7 - CSS 지원하기**<br/>\n: CSS 파일을 지원하도록 구현한다.\n\n```java\nelse if (url.endsWith(\".css\")) {\n    byte[] body = Files.readAllBytes(new File(\"./webapp\" + url).toPath());\n    response200CssHeader(dos, body.length);\n    responseBody(dos, body);\n}\n\n...\n\nprivate void response200CssHeader(DataOutputStream dos, int length) {\n    try {\n        dos.writeBytes(\"HTTP/1.1 200 OK \\r\\n\");\n        dos.writeBytes(\"Content-Type: text/css\\r\\n\");\n        dos.writeBytes(\"Content-Length: \" + length + \"\\r\\n\");\n        dos.writeBytes(\"\\r\\n\");\n    } catch (IOException e) {\n        log.error(e.getMessage());\n    }\n}\n```\n\n- HTTP 요청의 header에 `./css/style.css` 와 같이 날라오기에, `endsWith()` 메소드를 사용해 이를 추출한다.\n- `Content-Type` 이 `text/css` 로 달라진 것을 확인할 수 있다.\n\n---\n\n## 🚩 추가 학습 자료\n### 🔧 Git과 Github\n**Git**<br/>\n: 최근에 가장 많이 사용하는 버전 관리 시스템(Version Control System) 의 한 종류, VCS에 대한 기본 기능을 제공하는 도구이다.\n\n**Github**<br/>\n: Git이 제공하는 기능과 더불어 개발자들이 유용하게 사용할 수 있는 추가적인 기능을 제공하는 웹 애플리케이션이다.\n\n참고\n[브랜치 rebase 등을 배우는 실습](http://pcottle.github.io/learnGitBranching)\n[GUI 도구](http://www.sourcetreeapp.com)\n\n### 🔧 빌드 도구 메이븐\n**빌드 도구**<br/>\n: 프로젝트와 관련한 설정을 관리하면서 소스코드(프로덕션, 테스트)에 대한 컴파일, 컴파일을 위해 필요한 라이브러리 관리, 테스트, 배포를 위한 패킹 작업 등의 작업을 자동화할 수 있도록 지원하는 도구\n- 프로젝트 디렉토리 구조와 의존성 라이브러리를 관리하므로, 프로젝트를 통합 개발 도구 프로젝트로 변환하는 것도 가능하다.\n- 웹 애플리케이션 개발에서 발생하는 단순, 반복적인 작업을 자동화할 수 있다.\n- 간단한 배포 작업까지 수행할 수 있다.\n\n**Maven (메이븐)과 Gradle (그래들)**<br/>\n**메이븐**<br/>\n: 자바 진영에서 더 오랫 동안 사용해온 빌드 도구로, 설정 파일을 **XML**로 작성한다.\n- **XML**을 사용하기에 프로젝트의 크기가 커질수록 내용이 길어지고 가독성이 떨어진다.\n\n**그래들**<br/>\n: 최근 인기도가 높아지는 빌드 도구로, `그루비` 라는 언어를 기반으로 설정 파일을 관리하여 설정 파일에 대한 유연성도 높고, 코딩량도 메이븐의 **XML**에 비해 적다.\n- 빌드 속도가 메이븐에 비해 10~100배가량 빠르다.\n- 길이와 가독성 측면에서 효율적이다.\n\n두 빌드 도구의 기본 개념은 비슷한 점이 많아, 하나의 빌드 도구만 익히면 다른 빌드 도구에 대한 학습 비용도 낮다. \n\n### 🔧 디버깅을 위한 로깅(logging)\n개발자는 다음과 같은 목적으로 수많은 메세지를 출력한다.\n- 애플리케이션이 정상적으로 동작하는지 확인하기 위한 목적\n- 애플리케이션에 문제가 발생했을 때 원인을 파악하기 위한 디버깅 목적\n\n이때, 친숙한 `System.out.println()` 으로 출력하는데, 이는 **애플리케이션의 성능을 저하**시키는 원인이다.\n- 이를 이용해 디버깅 메세지를 출력하면 파일로 메세지가 출력하게 되는데, 파일에 메세지를 출력하는 작업은 상당한 비용이 발생한다.\n\n**logging 라이브러리**<br/>\n이와 같은 단점을 보완하기 위해 **logging 라이브러리**가 등장했다. 자바 진영에서 많이 사용하는 로깅 라이브러리는 `Logback` 이다. \n\n자바 진영에는 많은 로깅 라이브러리 구현체가 존재하는데, 더 좋은 구현체가 등장할 때마다 전체 소스코드에서 로깅 라이브러리 구현 부분을 수정하는 어려움이 있다. 이를 해결하기 위해 `SLF4J` 라는 라이브러리를 활용해 로깅 API에 대한 창구를 일원화했다.\n- 즉, 자바 소스코드는 `SLF4J` 라이브러리를 사용해 디버깅 메세지를 남기면 실제로 디버깅 메세지를 출력하는 구현체는 `Log4J`, `Logback` 이 담당하는 방식이다.\n\n```java\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nprivate static final Logger log = LoggerFactory.getLogger(RequestHandler.class);\n```\n\n- 해당 프로젝트는 로깅 구현체로 `Logback` 라이브러리를 사용한다. 하지만 이를 직접 사용하지 않고 `SLF4J` 를 import하고 있다.\n- `Logback` 라이브러리에 대한 구현체는 메이븐 설정 파일인 `pom.xml` 에서 설정하고 있다.\n\n**로그 레벨**<br/>\n로깅 라이브러리는 메세지 출력 여부를 **로그 레벨**을 통해 관리한다.\n- `TRACE` = `log.trace()`, `DEBUG` = `log.debug()`, `INFO` = `log.info()`, `WARN` = `log.warn()`, `ERROR` = `log.error()`\n- TRACE < DEBUG < INFO < WARN < ERROR 순으로 높아진다.\n  - 레벨이 높을 수록 출력되는 메세지는 적어지고, 낮을 수록 더 많은 로깅 레벨이 출력된다.\n- 각 메세지에 대한 로그 레벨은 로깅 메세지를 구현할 때 결정된다.\n\n**로그 메세지 생성**<br/>\n로그 메세지 출력 시 다음과 같은 메세지 구현 방식이 일반적이다.\n```java\nlog.debug(\"New Client Connect! Connected IP : \" + connection.getInetAddress() + \", Port : \" + conneciton.getPort());\n```\n\n- 하지만 위와 같은 방식은 로그 레벨이 `INFO` 나 `WARN` 인 경우 굳이 해당 메소드에 인자 전달을 위해 문자열을 더하는 부분이 실행될 필요가 없다. (아까 위에서 `StringBuilder` 를 사용하는 이유와 동일)\n- `SLF4J` 는 이러한 단점 보완을 위해 동적인 메세지를 구현하는 별도의 메소드를 제공한다.\n\n```java\nlog.debug(\"New Client Connect! Connected IP : {}, Port : {}\", connection.getInetAddress(), conneciton.getPort());\n```\n\n- 위 방식으로 `debug()` 메소드에서 로그 레벨에 따라 메세지를 더할 필요가 있는지의 여부를 판단하게 된다.\n\n`Logback` 의 로그 레벨과 메세지 형식에 대한 설정 파일은 `logback.xml` 이며, 이를 통해 출력되는 로그 메세지의 패턴을 변경할 수 있다.\n\n> Log4j. SLF4J 라이브러리별 템플릿 또한 존재해, 단순 반복적으로 발생하는 코드를 추가하여 개발 생산성을 높이는 데 도움이 될 수 있다.\n\n## 📕 출처\n**자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. \"테스트와 리팩토링은 개발자가 갖추어야 할 중요한 역량이다.\" 🚩 main() 메소드를 활용한 테스트의 문제점 일반적인 테스트 방법은  메소드를 활용해 우리가 의도한 결과 값이 정상적으로 출력되는지를 콘솔을 통해 확인하는 것이다. 🔧 계산기 코드 실제 서비스를 담당하…","fields":{"slug":"/[NextStep]2/"},"frontmatter":{"date":"January 24, 2022","title":"📖 2장 문자열 계산기 구현을 통한 테스트와 리팩토링","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> **\"테스트와 리팩토링은 개발자가 갖추어야 할 중요한 역량이다.\"**\n\n## 🚩 main() 메소드를 활용한 테스트의 문제점\n일반적인 테스트 방법은 `main()` 메소드를 활용해 우리가 의도한 결과 값이 정상적으로 출력되는지를 콘솔을 통해 확인하는 것이다.\n\n```java\npublic class Calculator {\n    int add (int x, int y) {\n        return x + y;\n    }\n    int subtract (int x, int y) {\n        return x - y;\n    }\n    int multiply (int x, int y) {\n        return x * y;\n    }\n    int divide (int x, int y) {\n        return x / y;\n    }\n\n    public static void main(String[] args) {\n        Calculator cal = new Calculator();\n\n        System.out.println(cal.add(3,4));\n        System.out.println(cal.subtract(5,4));\n        System.out.println(cal.multiply(2,6));\n        System.out.println(cal.divide(8,4));\n    }\n}\n```\n\n### 🔧 계산기 코드\n- 실제 서비스를 담당하는 프로덕션 코드(production code)와 이 프로덕션 코드가 정상 동작하는지 확인하는 `main()` 으로 나뉜다.\n  - 일반적으로 `main()` 은 **프로그래밍을 실행하기 위한 목적**과 **프로덕션 코드가 정상 동작하는지 확인하기 위한 목적**으로 나뉜다.\n\n**🧭 코드의 문제점!**\n- 프로덕션 코드와 테스트 코드(`main()` 메소드)가 같은 클래스에 위치하고 있다.\n   - 테스트 코드의 경우 테스트 단계에서만 필요하므로 굳이 서비스하는 시점에 같이 배포할 필요가 없다. \n   - 따라서 문제 해결을 위해 **프로덕션 코드(`Calculator` 클래스)와 테스트 코드(`CalculatorTest`)를 분리**한다.\n\n```java\npublic class CalcultorTest {\n    public static void main(String[] args) {\n        Calculator cal = new Calculator();\n\n        System.out.println(cal.add(3,4));\n        System.out.println(cal.subtract(5,4));\n        System.out.println(cal.multiply(2,6));\n        System.out.println(cal.divide(8,4));\n    }\n}\n```\n\n- 테스트를 담당하는 별도의 클래스를 추가했지만 `main()` 메소드 하나에 프로덕션 코드의 여러 메소드를 동시에 테스트하고 있다.\n  - 프로덕션 코드의 복잡도가 증가할수록, `main()` 메소드의 복잡도도 증가하게 되고, 이는 결과적으로 **`main()` 메소드 유지에 부담**이 된다.\n\n> 함수 유지 보수를 위해 테스트 코드를 각 메소드별 분리\n\n```java\npublic class CalcultorTest {\n    public static void main(String[] args) {\n        // main에서는 함수 호출만 수행\n        Calculator cal = new Calculator();\n\n        add(cal);\n        subtract(cal);\n        multiply(cal);\n        divide(cal);\n    }\n\n    private static void divide(Calculator cal) {\n        System.out.println(cal.divide(8,4));\n    }\n    private static void multiply(Calculator cal) {\n        System.out.println(cal.multiply(2,6));\n    }\n    private static void subtract(Calculator cal) {\n        System.out.println(cal.subtract(5,4));\n    }\n    private static void add(Calculator cal) {\n        System.out.println(cal.add(3,4));\n    }\n}\n```\n\n- 이 또한 개발자가 프로그래밍하는 과정을 살펴보면, 2가지 이유에서 결국 최종적인 해결책이 될 수 없음을 알 수 있다.\n  - 클래스가 가지고 있는 모든 메소드에 관심이 있는 것이 아니라 **현재 내가 구현하는 메소드에만 집중**하고 싶다.\n  - 하지만 위 테스트 코드는 `Calculator` 클래스의 모든 메소드를 테스트할 수 밖에 없다.\n  - 그렇다고 다른 메소드를 주석 처리하는 것 또한 불합리적이다.\n- 또 다른 문제점은, 테스트 결과를 매번 콘솔에 출력되는 값을 통해 **수동으로 확인**해야 한다는 것이다.\n  - 로직이 간단한 경우에는 결과 값을 쉽게 예측할 수 있다.\n  - 하지만 로직의 복잡도가 높은 경우, 후에 결과 값을 예측하는 것은 매우 번거롭고, 시간이 걸리는 작업일 것이다.\n\n`main()` 메소드를 활용한 테스트의 이 같은 문제점을 해결하기 위해 등장한 라이브러리가 **`JUnit`** 이다. \n- 이는 **내가 관심 가지는 메소드에 대한 테스트만 가능**하고 로직 실행 후의 **결과 값 확인을 프로그래밍을 통해 자동화**하는 것이 가능하다.\n\n### 🔧 JUnit을 활용해 main() 메소드 문제점 극복\n[JUnit](http://junit.org)은 단위 테스트 프레임워크 중 하나이다. 사용하기 쉽고 학습 비용이 낮은 라이브러리이다.\n\n**🧭 첫 번째 문제 해결, 한 번에 메소드 하나에만 집중**\n\n```java\nimport org.junit.Test;\n\npublic class CalculatorTest {\n\n    @Test\n    public void add() {\n        Calculator cal = new Calculator();\n        System.out.println(cal.add(6,3));\n    }\n}\n```\n\n- **JUnit**은 테스트 메소드에 `@Test` annotation을 추가한다. (테스트 메소드로 인식하기 위함!)\n- 위와 같은 방법으로 다른 메소드 코드도 작성한다. \n- **JUnit** 기반으로 테스트 코드를 구현하면 `CalculatorTest` 클래스가 가지는 전체 메소드를 한 번에 실행할 수도 있으며, 메소드 각각을 실행할 수도 있다.\n  - 다른 메소드에 영향을 받지 않고 구현 중인 프로덕션 코드에 집중할 수 있다.\n\n> \"**중요한 것은, 테스트 코드는 작성한 순서대로 실행되지 않는다!**\"\n\n**🧭 두 번째 문제 해결, 결과 값을 눈이 아닌 프로그램을 통해 자동화**\n- `main()` 메소드의 두 번째 문제점은 실행 결과를 눈으로 직접 확인해야 한다는 것이다. **JUnit**은 이 문제점 극복을 위해 `assertEquals()` 메소드를 제공한다.\n\n```java\nimport static org.junit.Assert.assertEquals;\nimport org.junit.Test;\n\npublic class CalculatorTest {\n\n    @Test\n    public void add() {\n        Calculator cal = new Calculator();\n        assertEquals(9, cal.add(6,3));\n    }\n\n    @Test\n    public void subtract() {\n        Calculator cal = new Calculator();\n        assertEquals(3, cal.subtract(6,3));\n    }\n}\n```\n\n- `assertEquals` 는 static 메소드이므로 `import static` 으로 메소드를 import하여 사용해야 한다.\n- 메소드의 첫 번째 인자는 **기대하는 결과값(expected)** 이고, 두 번째 인자는 프로덕션 코드의 **메소드를 실행한 결과값(actual)** 이다.\n- `int`, `long`, `String` 등 다양한 데이터 타입을 지원한다.\n- 테스트가 실패한 경우는 아래 상태창에서 실패 원인을 확인할 수 있다.\n\n**JUnit**의 `assertEquals()` 메소드를 활용하면 실행 결과를 자동화하는 것이 가능하다. **JUnit**의 `Assert` 클래스는 이외에도 다음과 같은 메소드를 제공한다.\n- 결과 값의 T/F 유무를 확인하는 `assertTrue()`, `assertFalse()`\n- 결과 값의 null 유무를 판단하는 `assertNull()`, `assertNotNull()`\n- 배열 값이 같은지 검증하는 `assertArrayEquals()`\n\n**🧭 테스트 코드 중복 제거**\n\n> **\"개발자가 가져야 할 좋은 습관 중 하나는 중복 코드를 제거하는 것이다.\"**\n\n앞서 구현한 `CalculatorTest` 클래스에서, `Calculator` 인스턴스를 생성하는 부분에서 중복이 발생한다. 이러한 중복을 다음과 같이 제거할 수 있다.\n\n```java\npublic class CalculatorTest {\n    private Calculator cal = new Calculator();\n\n    @Test\n    public void add() {\n        assertEquals(9, cal.add(6,3));\n    }\n\n    @Test\n    public void subtract() {\n        assertEquals(3, cal.subtract(6,3));\n    }\n}\n```\n\n- 이러한 방식은 자바 문법에 있어 아무런 문제가 되지 않지만, **JUnit**은 테스트를 실행하기 위한 초기화 작업을 이렇게 하지 않고 `@Before` annotation을 활용하는 것을 추천한다.\n\n```java\nimport static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class CalculatorTest {\n    private Calculator cal;\n\n    @Before\n    public void setup() {\n        cal = new Calculator();\n    }\n    @Test\n    public void add() {\n        assertEquals(9, cal.add(6,3));\n    }\n\n    @Test\n    public void subtract() {\n        assertEquals(3, cal.subtract(6,3));\n    }\n}\n```\n\n- 이와 같이 `@Before` annotation을 활용하여도 각 단위 테스트를 실행할 때마다 `Calculator` 인스턴스를 생성하는 것은 같다.\n  - 이렇게 매 테스트마다 `Calculator` 인스턴스를 생성하는 이유는 **특정 테스트 메소드를 실행할 때, `Calculator` 의 상태 값이 변경되어 다음 메소드에 영향을 미칠 수 있기 때문**이다.\n  - 다음 테스트 메소드에 영향을 미치게 되면, 테스트 실행 순서나 `Calculator` 의 상태 값에 따라 테스트의 성공 여부가 달라질 수 있다.\n\n그럼에도 코딩량이 더 많아 구현 비용이 큰 `@Before` annotation을 사용하는 이유는 다음과 같다.\n- **JUnit**에는 `@RunWith`, `@Rule` 같은 annotation을 사용해 기능을 확장할 수 있는데, `@Before` 안이어야만 해당 annotation에서 초기화된 객체 접근할 수 있기 때문이다.\n- 따라서, 가능한 `@Before` annotation을 사용해 테스트 메소드에 대한 초기화 작업을 하는 것이 문제 발생의 가능성을 낮춰준다.\n\n`@Before` annotation과 비슷하게, `@After` annotation으로 메소드 실행이 끝난 후 후처리 작업을 담당하는 annotation도 존재한다.\n\n### 🔧 문자열 계산기 요구사항 및 실습\n**요구사항**: 전달하는 문자를 구분자로 분리한 후 각 숫자의 합을 구해 반환해야 한다.\n- 쉼표 또는 콜론을 구분자로 가지는 문자열을 전달하는 경우 구분자를 기준으로 분리한 각 숫자의 합을 반환\n- 위의 기본 구분자 외에 Custom 구분자를 지정할 수 있다. Custom 구분자는 문자열 앞부분의 \"//\"와 \"\\n\" 사이에 위치하는 문자로 사용\n- 문자열 계산기에 음수를 전달하는 경우 `RuntimeException` 으로 예외 처리\n\n간단해보이지만 구현을 바로 시작하지 않고, 요구사항을 더 작은 단위로 나눠 테스트할 경우의 수를 분리해본다.\n\n**🧭 요구사항 분리 및 각 단계별 힌트**\n- 최대한 힌트 없이 진행 !\n\n**🧭 추가 요구사항**\n- 요구사항을 만족하는 코드를 구현했다고 해서 개발이 완료된 것은 아니다. 구현 완료 이후, **중복 제거 & 읽기 좋은 코드 구현을 위한 리팩토링(구조 변경)**이 이뤄져야 한다.\n\n> **리팩토링**\n> : 소스코드의 가독성을 높이고 유지보수를 편하게 하기 위해 소스코드의 구조를 변경하는 것을 의미한다. 리팩토링을 하더라도 기능상의 결과가 변경되는 것은 아니다.\n\n다음은 **추가적인 요구사항**이다.\n- 메소드가 한 가지 책임만 가지도록 구현한다.\n- indent(들여쓰기) 깊이를 1단계로 유지한다. \n- `else` 를 사용하지 마라.\n  \n위 3가지 원칙을 제시하는 이유는 \"**소스코드를 최대한 깔끔하게 구현할 것을 요구하기 위함**\"이다. 초보 프로그래머의 경우, 구현에 있어 막막한 경우가 많다. 이러한 막막함을 해소하기 위해 위 3가지 원칙을 제시한다. (물론 무조건 위 원칙을 지킬 수는 없지만, 최대한 지키도록 노력하면 좀 더 깔끔한 코드를 작성할 수 있을 것이다.)\n\n### 🔧 테스트와 리팩토링을 통한 문자열 계산기 구현\n요구사항의 복잡도가 높을 수록, 당연히 구현의 복잡도가 증가할 수밖에 없다. 하지만 개발자라면 이러한 복잡도와 평생 부대끼며 살아가야 한다. \n\n그렇다면 이 복잡도를 낮출 수 있는 방법을 찾아야 하지 않겠는가. 그 방법 중 하나가 끊임없는 리팩토링을 통해 소스코드를 깔끔하게 구현하는 연습을 하는 것이다.\n\n**🧭 요구사항을 작은 단위로 나누기**\n- 복잡한 문제를 풀기 위한 첫 번째 작업은 \"**복잡한 문제를 작은 단위로 나눠 좀 더 쉬운 문제로 변형**\"하는 것이다. 하지만 이러한 작업은 쉽지 않기에 다양한 문제를 해결함으로써 연습하는 수밖에 없다.\n\n**🧭 모든 단계의 끝은 리팩토링**\n- 소스코드의 복잡도가 쉽게 증가하는 이유는 \"**하나의 요구사항을 완료한 후 리팩토링을 하지 않은 상태에서 다음 단계로 이동**\"하기 때문이다. 다음 단계로 넘어가기 위한 마지막 작업은 **결과를 확인한 후 리팩토링까지 완료**하는 것이다.\n\n**🧭 문자열 계산기 구현**\n- **빈 문자열 또는 null 값을 입력할 경우 0을 반환해야 한다.** (ex. `\"\"` => `0`, `null` => `0`)\n\n`StringCalculator.java`\n```java\npublic class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        return 0;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}\n```\n\n`StringCalculatorTest.java`\n```java\nimport static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    private StringCalculator cal;\n\n    @Before\n    public void setup() {\n        cal = new StringCalculator();\n    }\n    \n    @Test\n    public void add_null_또는_빈문자() {\n        assertEquals(0, cal.add(null));\n        assertEquals(0, cal.add(\"\"));\n    }\n}\n```\n\n- 구현에 있어 특별한 점은 없지만, 한 가지 눈여겨 볼 것은 테스트 메소드 이름에 **한글**을 사용했다는 것이다. 테스트 메소드의 정확한 의미 전달을 위해 한글로 작성할 수도 있다.\n\n\n**🧭 숫자 하나를 문자열로 입력할 경우 해당 숫자를 반환한다.** (ex. \"1\" => 1)\n\n`StringCalculator.java`\n```java\npublic class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        return Integer.parseInt(text);\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}\n```\n\n`StringCalculatorTest.java`\n```java\nimport static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    ...\n\n    @Test\n    public void add_숫자하나() throws Exception {\n        assertEquals(1, cal.add(\"1\"));\n    }\n}\n```\n\n**🧭 숫자 두 개를 쉼표 구분자로 입력할 경우 두 숫자의 합을 반환한다.** (ex. \"1,2\" => 3)\n\n`StringCalculator.java`\n```java\npublic class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        if (text.contains(\",\")) {\n            String[] values = text.split(\",\");\n            int sum = 0;\n            for (String value : values) {\n                sum += Integer.parseInt(value);\n            }\n            return sum;\n        }\n\n        return Integer.parseInt(text);\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}\n```\n\n`StringCalculatorTest.java`\n```java\nimport static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    ...\n\n    @Test\n    public void add_쉼표구분자() throws Exception {\n        assertEquals(3, cal.add(\"1,2\"));\n    }\n}\n```\n\n- 위와 같은 로직을 구현할 때 보통 `if`, `else if`, `else` 형태로 구현하는 것이 일반적이지만 3가지 원칙 중 하나인 \"else를 가능한 사용하지 말라\"에 따라 `else` 를 사용하지 않고 구현했다.\n\n구현 완료 후 테스트까지 정상적으로 작동했다. 이제는 리팩토링을 할 차례이다. \n- 첫 번째로, \"**숫자가 하나인 경우**와 **쉼표 구분자를 포함하는 경우**를 따로 분기해서 처리해야 한다\"는 점이다.\n- `String` 의 `split()` 메소드에 숫자 하나를 가지는 문자열을 전달했을 때, 숫자 하나가 담긴 `String[]` 을 반환한다면 해당 부분의 `if` 문을 제거할 수 있을 것 같다.\n\n`SplitTest.java`\n```java\nimport static org.junit.Assert.*;\n\nimport org.junit.Test;\n\npublic class SplitTest {\n    @Test\n    public void split() {\n        assertArrayEquals(new String[] {\"1\"}, \"1\".split(\",\"));\n        assertArrayEquals(new String[] {\"1\",\"2\"}, \"1,2\".split(\",\"));\n    }\n}\n```\n\n`StringCalculator.java`\n```java\npublic class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        String[] values = text.split(\",\");\n        int sum = 0;\n        for (String value : values) {\n            sum += Integer.parseInt(value);\n        }\n        return sum;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}\n```\n\n- `SplitTest` 의 테스트 코드가 정상적으로 동작하므로, 위와 같이 리팩토링했다.\n- `if` 절 하나를 제거해 더 깔끔하게 만들었다. \n- 하지만 `add()` 메소드의 복잡도가 증가하고 있어 **숫자의 합을 구하는 부분을 별도의 메소드로 분리**할 수 있을 것 같다.\n\n```java\npublic class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        String[] values = text.split(\",\");\n        return sum(values);\n    }\n\n    private int sum(String[] values) {\n        int sum = 0;\n        for (String value : values) {\n            sum += Integer.parseInt(value);\n        }\n        return sum;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}\n```\n\n- \"각 메소드가 하나의 책임만 수행하고 있는가?\" 질문에 대해 생각해보면, 새로 분리한 `sum()` 메소드가 **문자열 배열을 숫자로 변환하는 작업**과 **숫자 배열의 합을 구하는 작업**을 하고 있음을 알 수 있다.\n- 따라서 다음과 같이 분리한다.\n\n```java\npublic class StringCalculator {\n    public int add(String text) {\n        if (text == null || text.isEmpty()) {\n            return 0;\n        }\n\n        String[] values = text.split(\",\");\n        return sum(toInts(values));\n    }\n\n    private int[] toInts(String[] values) {\n        int[] numbers = new int[values.length];\n        for (int i = 0; i < values.length; i++) {\n            numbers[i] = Integer.parseInt(values[i]);\n        }\n        return numbers;\n    }\n    \n    private int sum(int[] numbers) {\n        int sum = 0;\n        for (int number : numbers) {\n            sum += number;\n        }\n        return sum;\n    }\n\n    public static void main(String[] args) {\n        StringCalculator cal = new StringCalculator();\n    }\n}\n```\n \n- 소스 코드 복잡도가 감소하는 것이 아니라 오히려 복잡해진 느낌이다. 이는 그저 연습이기 때문이다.\n  - 실제 프로젝트에서 모든 소스코드에 대해 이 같은 리팩토링을 진행할 수 없다. 하지만 이런 작은 코드에서 극단적으로 리팩토링을 하는 연습을 통해 실제 프로젝트에서 리팩토링할 부분을 더 쉽게 찾아 수행할 수 있다.\n- 리팩토링한 후 주의 깊게 봐야할 부분은 `private` 로 분리한 메소드가 아닌 `public` 으로 공개하고 있는 `add()` 메소드가 얼마나 읽기 쉽고, 좋은가이다. \n  - 좀 더 극단적으로 리팩토링한다면 `text == null || text.isEmpty()` 또한 다른 메소드로 추출할 수도 있다.\n  - 이와 같이 극단적으로 리팩토링하여 소스코드를 읽을 때 해당 메소드가 어떤 작업을 수행하는지를 최대한 쉽게 파악할 수 있을 것이다. 세부 구현은 `private` 메소드로 분리하고 `add()` 메소드가 무슨 일을 하는 지 글로 표현해보면 \"text 값이 비어 있으면 0을 반환, 비어있지 않으면 구분자로 분리, 숫자로 변환한 다음 이 숫자의 합을 구한다.\" 로 파악할 수 있다.\n\n> \"세부 구현에 집중하도록 하지 않고 논리적인 로직을 쉽게 파악할 수 있도록 구현하는 것이 읽기 좋은 코드라 생각한다.\"\n\n**🧭 구분자를 쉼표 이외에 콜론을 사용할 수 있다.** (ex. \"1,2:3\" => 6)\n\n```java\nimport static org.junit.Assert.assertEquals;\n\nimport org.junit.Before;\nimport org.junit.Test;\n\npublic class StringCalculatorTest {\n    ...\n    \n    @Test\n    public void add_쉼표_또는_콜론_구분자() throws Exception {\n        assertEquals(6, cal.add(\"1,2:3\"));\n    }\n}\n```\n\n```java\npublic class StringCalculator {\n    public int add(String text) {\n        if (isBlank(text))\n            return 0;\n\n        return sum(toInts(split(text)));\n    }\n\n    private String[] split(String text) {\n        return text.split(\",|:\");\n    }\n    ...\n}\n```\n\n- 상당히 작은 부분이 수정되었다.\n\n**🧭 \"//\"와 \"\\n\" 문자 사이에 Custom 구분자를 지정할 수 있다.** ex.\"//;\\n1;2;3\" => 6\n\n```java\n@Test\npublic void add_custom_구분자() throws Exception {\n    assertEquals(6, cal.add(\"//;\\n1;2;3\"));\n}\n```\n\n```java\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\npublic class StringCalculator {\n    public int add(String text) {\n        if (isBlank(text)) {\n            return 0;\n        }\n\n        return sum(toInts(split(text)));\n    }\n\n    private String[] split(String text) {\n        Matcher m = Pattern.compile(\"//(.)\\n(.*)\").matcher(text);\n        if (m.find()) {\n            String customDelimeter = m.group(1);\n            return m.group(2).split(customDelimeter);\n        }\n        \n        return text.split(\",|:\");\n    }\n}\n```\n\n- Custom 구분자는 정규 표현식을 이용해 문자열을 분리하고 있다. 이를 활용해 복잡한 문자열에서 원하는 문자열을 찾거나 특정한 패턴을 찾을 수 있다.\n\n**🧭 문자열 계산기에 음수를 전달하는 경우 RuntimeException 예외를 throw**\n\n```java\n@Test(expected = RuntimeException.class)\npublic void add_negative() throws Exception {\n    cal.add(\"-1,2,3\");\n}\n```\n\n- **JUnit**에서 **기대하는 결과 값이 예외**인 경우 `@Test` annotation의 `expected` 속성에 기대하는 `Exception` 클래스를 전달할 수 있다.\n\n```java\n...\nprivate int[] toInts(String[] values) {\n    int[] numbers = new int[values.length];\n    for (int i = 0; i < values.length; i++) {\n        numbers[i] = toPositive(values[i]);\n    }\n    return numbers;\n}\n\nprivate int toPositive(String value) {\n    int number = Integer.parseInt(value);\n    if (number < 0) {\n        throw new RuntimeException();\n    }\n    return number;\n}\n...\n```\n\n- 요구사항이 변경되면서 메소드의 이름, 변수 이름을 변경하는 것 또한 리팩토링의 중요한 부분이다. \n\n**🧭 각 단계의 개발과정**\n- 구현 => 테스트를 통해 결과 확인 => 리팩토링\n- 개발자들이 소홀히 하는 부분이 리팩토링이다. 하지만 깔끔하고 읽기 좋은 코드를 구현하기 위해 개발자가 갖추어야 할 중요한 역량이므로 꾸준한 연습이 필요하다.\n\n**🧭 3가지 원칙**\n- 가능한 위에서 언급한 3가지 원칙을 지키도록 노력하자.\n- 리팩토링할 부분을 찾기 힘들 때, 3가지 원칙을 생각하면서 찾는다면 약간의 힌트는 얻을 수 있을 것이다.\n\n**🧭 극단적인 리팩토링**\n- 프로덕션 코드를 변경하더라도 바로바로 테스트 코드로 검증이 가능했기에 극단적인 리팩토링이 가능했다. \n- 실제 프로젝트에서도, 리팩토링을 통해 소스코드의 개선을 원한다면, 테스트 코드가 뒷받침되어야 한다.\n\n> **\"테스트와 리팩토링은 분리할 수 없는 동반자 관계이고 같이 연습해야 한다.\"**\n\n## 📕 출처\n**자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성"},{"excerpt":"자바 웹 프로그래밍 Next Step - 박재성을 읽고 인용하고 정리하는 POST입니다. \"양파 껍질을 벗기듯이 학습하라\" 즉, 한 번에 한 가지 지식을 깊이 있게 학습하는 것에 집중하기보다 다양한 분야의 얕은 지식을 학습 후 일정 수준이 되면 다음 단계의 깊은 지식으로 서서히 깊이를 더해가라. 🚩 대한민국 IT 개발자 직군의 종류 과거에는 대다수가 자바…","fields":{"slug":"/[NextStep]1/"},"frontmatter":{"date":"January 23, 2022","title":"📖 1장 첫 번째 양파 껍질 벗기기","tags":["Java","Refactoring","Framework"]},"rawMarkdownBody":"\n<em>[자바 웹 프로그래밍 Next Step - 박재성]을 읽고 인용하고 정리하는 POST입니다.</em>\n\n> **\"양파 껍질을 벗기듯이 학습하라\"**\n\n즉, 한 번에 한 가지 지식을 깊이 있게 학습하는 것에 집중하기보다 다양한 분야의 얕은 지식을 학습 후 일정 수준이 되면 다음 단계의 깊은 지식으로 서서히 깊이를 더해가라.\n\n## 🚩 대한민국 IT 개발자 직군의 종류\n과거에는 대다수가 **자바**를 기반으로 하는 웹 서버 개발자였다.\n\n**웹 백엔드 개발자**<br/>\n: 자바, C#, 루비, 파이썬 등의 언어로 서버 쪽의 로직을 개발한다. 대부분, 데이터베이스도 잘 알아야 한다.\n일부 프론트엔드 개발 작업도 담당하는 경우가 일반적이다.\n\n**웹 프론트엔드 개발자**<br/>\n: HTML/CSS, JS를 주로 사용하며 디자이너와 협업하는 개발자이다. 최근에는 Angular.js, React.js, Vue.js와 같은 라이브러리도 잘 사용해야 하고, node.js를 통해 웹 백엔드 개발까지 가능하다.\n\n**모바일 앱 개발자**<br/>\n: 자바 기반의 안드로이드 개발자와 오브젝브 C(또는 Swift) 기반의 iOS 개발자가 속한다.\n\n**기타**<br/>\n: 시스템 프로그래머, 모바일 게임 개발자, 게임 서버 및 게임 클라이언트 개발자가 속한다.\n\n**비개발자 직군**<br/>\n: DBA(Database Administration), 시스템 엔지니어, 빅데이터 전문가 등이 있다.\n\n---\n\n## 🚩 개발자들에게 유용한 웹 사이트들\n**[stackoverflow.com](http://www.stackoverflow.com)**<br/>\n: 개발자들의 지식인 같은 곳이다.\n\n**[github.com](http://www.github.com)**<br/>\n: 소셜 코딩이라고 부르기도 한다. Git의 사용법과 함께 필수적으로 알아야 한다. 참고로 Git은 소스코드에 대한 버전관리용 도구이고, Github는 Git을 지원하는 웹 서비스이므로 엄연히 다른 것이다.\n\n**[trello.com](http://www.trello.com)**<br/>\n: 칸반이라는 툴을 적용할 수 있는 도구이다. 프로젝트 진행 시 프로젝트 관리를 위한 협업 도구로 유용하다.\n> 참고로 나는 프로젝트 관리 도구로 [Notion](http://www.notion.so)을 사용한다.\n\n**페이스북 그룹, 다양한 온라인 커뮤니티**\n\n**MOOC 사이트**<br/>\n: codecademy, codeschool, khanacademy 등을 통해 학습할 수 있다.\n> 참고로 나는 [인프런](https://www.inflearn.com/)을 애용한다.\n\n---\n\n## 🚩 처음에 배워야 하는 것들\n프로그래밍 언어를 학습하는데 어려움을 느끼기도 하지만, 먼저 컴퓨터를 사용하는 것에 익숙해져야 한다.\n\n\"컴퓨터에 무슨 짓을 하더라도 폭발하지 않는다. 너무 조심조심 다루지 않아도 된다. 언제든지 초기화하고 다시 시작할 수 있다. 겁내지 마라.\"\n\n**맥 / 리눅스 사용법**<br/>\n: 맥 OS를 사용하는 것 자체가 개발자에게 도움이 된다. 더불어 리눅스를 배워야 한다. 아마존 웹 서비스(AWS)와 같은 클라우드 서비스를 통해 무료로 리눅스 서버를 경험할 수도 있다.\n\n**다양한 프로그래밍 언어**<br/>\n: 쉽고 재밌는 프로그래밍 언어를 배우는 것을 추천한다. 웹 개발자라면 시작 언어로 JS와 루비, 모바일 개발자라면 파이썬을 배우면 좋을 것 같다. 실력이 는다면, C와 포인터에 대해 배우는 것을 권장한다. 그리고 모바일 개발자라면 Objective-C, Swift도 공부하는 것을 추천한다.\n\n**내 전문 분야에 대한 방향성 결정**<br/>\n: 웹 개발의 전문 분야는 백엔드와 프론트엔드로 나뉜다.\n사물의 내면이나 돌아가는 원리를 생각해 보는 걸 좋아한다면 백엔드를 권장하고,\n디자인 감각이 있고 꾸미는 걸 좋아하고 반복 작업도 질리지 않고 잘할 수 있다면 프론트엔드일 가능성이 높다.\n\n웹 애플리케이션 개발 학습을 시작하는 단계에서는, 웹 프론트엔드와 백엔드 모두 학습할 것을 추천한다. 웹뿐만 아니라 모든 분야에 해당된다.\n- 자신이 어느 쪽에 더 맞는 성향인지 파악이 어렵기 때문이다.\n- 또한, 같은 작업을 프론트엔드와 백엔드 모두에서 구현할 수 있는데 각 상황에 따라 더 효과적인 방법이 존재할 수 있다. 이와 같이 서로서로에 대한 이해가 있어야 효과적인 해결책을 찾는데 도움이 되기 때문이다.\n\n웹 프론트엔드의 경우, HTML, CSS, JS 학습에 집중하면 된다. 하지만 백엔드의 경우 자바, 루비, 파이썬, JS와 같이 다양한 언어 기반으로 개발이 가능하다. \n국내 대부분의 큰 회사들은 웹 백엔드 언어로 자바를 사용하는 경향이고, 스타트업의 경우 파이썬과 루비를 사용하는 경향이 강하다.\n\n---\n\n## 🚩 일단 시작해 보자\n소프트웨어를 만든다는 거창한 계획을 세우기보다 일단 무엇이라도 만드는 작업을 시작해 보자. 온라인으로도 학습할 수 있는 좋은 컨텐츠들이 많기 때문에 이를 활용하여 시작해보도록 하자. \n\n\"소프트웨어를 학습하는 좋은 방법 중 하나는 일단 무엇인가 만들어보는 경험을 한 후 이론적인 개념을 학습하고, 다시 다음 단계의 경험을 하고 이론적인 개념을 학습하는 과정을 반복하는 것이라 생각한다.\"\n\n---\n\n## 🚩 본격적인 웹 프로그래밍 도전\n### 🔧 온라인 강의를 통한 학습\n- [생활코딩의 작심 40시간 라이브](https://opentutorials.org/course/1688) : 웹 프론트엔드부터 백엔드까지 전체를 경험해 볼 수 있다. 단 서버측 언어는 PHP이다.\n- [웹 애플리케이션 개발 관련 지식 학습](https://www.codecademy.com/catalog)\n- [프론트엔드 지식 학습](https://www.w3schools.com/)\n\n### 🔧 책을 통한 학습\n자신에게 맞는 책을 고르는 것도 능력이고, 연습이 필요하다. 누군가 추천해준 책을 무조건 구매하기보다 자신이 직접 선택할 수 있는 능력을 기를 것을 추천한다.\n\n\"일단 시작하지 않으면 내가 무엇을 모르는지조차 모른다.\"\n\n---\n\n## 🚩 학습 방법\n기초부터 탄탄하게 쌓는 것도 하나의 학습 방법이지만, 경험을 통해 즐거움을 느낀 후 이론적인 학습을 하는 것 또한 좋은 학습 방법 중 하나이다. \n\n사람들은 내가 현재 학습하고 있는 지식이 어느 곳에 활용될 것인지 공감될 때 깊이 있게 몰입할 수 있으며, 체화할 수 있다.\n\n일단 무엇이라도 시작해 프로그래밍, 컴퓨터에 대한 두려움을 깨야 한다. 내가 원하는 무엇인가를 만들어낼 수 있다는 것에 대한 즐거움과 흥분된 경험을 해봐야 한다. 이 즐거움과 흥분이 있어야 앞으로 두 번째, 세 번째 양파 껍질을 벗기면서 경험하게 될 큰 산들을 슬기롭게 넘길 수 있다.\n\n## 📕 출처\n**자바 웹 프로그래밍 Next Step : 하나씩 벗겨가는 양파껍질 학습법** - 박재성"},{"excerpt":"문제 이번 가을학기에 '문제 해결' 강의를 신청한 학생들은 텀 프로젝트를 수행해야 한다. 프로젝트 팀원 수에는 제한이 없다. 심지어 모든 학생들이 동일한 팀의 팀원인 경우와 같이 한 팀만 있을 수도 있다. 프로젝트 팀을 구성하기 위해, 모든 학생들은 프로젝트를 함께하고 싶은 학생을 선택해야 한다. (단, 단 한 명만 선택할 수 있다.) 혼자 하고 싶어하는…","fields":{"slug":"/[BOJ]9466/"},"frontmatter":{"date":"January 22, 2022","title":"👩‍💻 9466. 텀 프로젝트","tags":["그래프이론","그래프탐색","DFS"]},"rawMarkdownBody":"\n## 문제\n\n이번 가을학기에 '문제 해결' 강의를 신청한 학생들은 텀 프로젝트를 수행해야 한다. 프로젝트 팀원 수에는 제한이 없다. 심지어 모든 학생들이 동일한 팀의 팀원인 경우와 같이 한 팀만 있을 수도 있다. 프로젝트 팀을 구성하기 위해, 모든 학생들은 프로젝트를 함께하고 싶은 학생을 선택해야 한다. (단, 단 한 명만 선택할 수 있다.) 혼자 하고 싶어하는 학생은 자기 자신을 선택하는 것도 가능하다.\n\n학생들이(s1, s2, ..., sr)이라 할 때, r=1이고 s1이 s1을 선택하는 경우나, s1이 s2를 선택하고, s2가 s3를 선택하고,..., sr-1이 sr을 선택하고, sr이 s1을 선택하는 경우에만 한 팀이 될 수 있다.\n\n어느 프로젝트 팀에도 속하지 않는 학생들의 수를 계산하는 프로그램을 작성하라.\n\n### 입력\n- 첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스의 첫 줄에는 학생의 수가 정수 n (2 ≤ n ≤ 100,000)으로 주어진다. 각 테스트 케이스의 둘째 줄에는 선택된 학생들의 번호가 주어진다. (모든 학생들은 1부터 n까지 번호가 부여된다.)\n\n### 출력\n- 각 테스트 케이스마다 한 줄에 출력하고, 각 줄에는 프로젝트 팀에 속하지 못한 학생들의 수를 나타내면 된다.\n\n## 📍 **Logic**\n\n```java\nclass Graph {\n    final int[] graph;\n    int[] discovered;\n    boolean[] fin;\n    int answer = 0;\n    int graph_size;\n\n    public Graph(int size) {\n        graph_size = size + 1;\n        this.graph = new int[graph_size];\n        discovered = new int[graph_size];\n        fin = new boolean[graph_size];\n    }\n}\n```\n\n- 그래프의 정보를 저장하기 위한 클래스\n\n```java\npublic void search(int node) {\n    if (discovered[node] == 1) return;\n\n    discovered[node] = 1;\n    int next = graph[node];\n\n    if (discovered[next] == 0) search(graph[node]);\n    else {\n        if (!fin[next]) {\n            answer++;\n            for (int i=next; i!=node; i=graph[i]) {\n                answer++;\n            }\n        }\n    }\n    fin[node] = true;\n}\n```\n\n- 다음 방문할 정점이 방문하지 않은 경우는 `search()` 로 **DFS** 수행\n- 다음 정점을 이미 방문한 경우, `fin[next]` 로 이미 사이클이 형성된 정점인지 확인\n  - 그렇지 않은 경우, 다시 해당 정점으로 돌아오기 전까지 해당 정점과 연결된 정점의 수를 카운트\n  - 카운트의 합이 곧 팀을 이루는 학생들이므로, **전체 학생 - 누적 카운트가 정답**\n  \n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Graph {\n        final int[] graph;\n        int[] discovered;\n        boolean[] fin;\n        int answer = 0;\n        int graph_size;\n\n        public Graph(int size) {\n            graph_size = size + 1;\n            this.graph = new int[graph_size];\n            discovered = new int[graph_size];\n            fin = new boolean[graph_size];\n        }\n\n        public void AddElement(int x, int y) {\n            graph[x] = y;\n        }\n\n        public int solution() {\n            for (int i=1; i < graph_size; i++) this.search(i);\n            return graph_size - 1 - this.answer;\n        }\n\n        public void search(int node) {\n            if (discovered[node] == 1) return;\n\n            discovered[node] = 1;\n            int next = graph[node];\n\n            if (discovered[next] == 0) search(graph[node]);\n            else {\n                if (!fin[next]) {\n                    // 다음 갈 정점이 방문은 했으나 아직 끝나지 않은, 즉 사이클이 생성되지 않은 상태\n                    answer++;\n                    for (int i=next; i!=node; i=graph[i]) {\n                        answer++;\n                    }\n                }\n            }\n            fin[node] = true;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) {\n            Scanner sc = new Scanner(System.in);\n            int T = sc.nextInt();\n\n            while (T > 0) {\n                int size = sc.nextInt();\n\n                Graph g = new Graph(size);\n\n                for (int i = 1; i <= size; i++) {\n                    int tmp = sc.nextInt();\n                    g.AddElement(i, tmp);\n                }\n\n                System.out.println(g.solution());\n                T-=1;\n            }\n            sc.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n- 결국은 \"사이클을 찾아야 한다\" 라는 논리는 맞았지만, 최적화를 해내지 못해 **시간 초과**를 피할 수 없었다.\n- 이제부터는 하루에 1문제는 풀어야하기 때문에 너무 시간을 잡아 먹지 않으려고 풀이를 참고했다.\n\n### 📕 출처\nBaekjoon : https://www.acmicpc.net/problem/9466\n\n### 참고\nhttps://bcp0109.tistory.com/32"},{"excerpt":"동기처리 및 비동기처리에 대해 정리하는 POST입니다. 백엔드 개발을 수행하면서, (사실 이전에 프론트 개발 시에도) 동기처리, 비동기처리라는 용어를 많이 봤지만, 정확하게 이해하고 넘어가진 않았다. 이 POST를 계기로 정확하게 이해하고 앞으로 적용할 수 있도록 한다. \"기본적으로 함수는 선언된 시기가 아닌 호출되는 시기에 동작한다.\" 💡 동기, 비동기…","fields":{"slug":"/[BackEnd]Sync&aSync/"},"frontmatter":{"date":"January 21, 2022","title":"💻 동기 및 비동기 처리","tags":["Callback","Async","Await","Promise"]},"rawMarkdownBody":"\n<em>동기처리 및 비동기처리에 대해 정리하는 POST입니다.</em>\n\n백엔드 개발을 수행하면서, (~~사실 이전에 프론트 개발 시에도~~) **동기처리**, **비동기처리**라는 용어를 많이 봤지만, 정확하게 이해하고 넘어가진 않았다. 이 POST를 계기로 정확하게 이해하고 앞으로 적용할 수 있도록 한다.\n\n\"기본적으로 함수는 선언된 시기가 아닌 **호출되는 시기**에 동작한다.\"\n\n## 💡 동기, 비동기 처리란?\n동기와 비동기는 **\"프로세스의 수행 순서 보장에 대한 매커니즘\"**이다.\n\n### ☺️ 동기 (Synchronous)\n동시에 일어난다는 의미\n즉, **요청과 그 결과가 동시에 일어난다**는 약속인데, 요청을 하면, 시간이 얼마가 걸리던지 요청한 자리에서 바로 결과가 주어져야 하고, 결과를 받은 이후 다음 요청이 가능하다.\n\n코드측면에서 쉽게 이해하자면, **프로그램이 작성된 순서대로 실행되는 것**이라고 할 수 있다.\n\n**예시** : \"은행 계좌의 돈을 송금하는 과정\"\n- A의 계좌에서 돈을 송금, B의 계좌에 입금\n- B의 계좌에 입금이 완료된 경우, A의 계좌에서 출금\n- A의 계좌의 출금과 B의 계좌의 입금이 **동시에 발생**\n\n위의 과정이 동기적으로 일어나야 문제가 발생하지 않는다. 따라서 동기처리가 이뤄져야 한다.\n\n### 😇 비동기 (Asynchronous)\n동기와 반대의미로, 동시에 일어나지 않는다는 의미\n즉 요청과 결과가 동시에 일어나지 않을 거라는 약속이다. 요청을 하면, 그 자리에서 결과가 주어지지 않는다. 따라서, 요청에 대한 결과를 전달받지 않고 다음 요청을 수행할 수 있다.\n\n코드측면에서 쉽게 이해하자면, **프로그램이 작성된 순서대로 실행되지 않고 독자적인 흐름이 생기는 것**이라고 할 수 있다.\n\n**예시** : \"시험치는 학생과 교사\"\n- 학생은 시험지를 풀고 제출\n- 교사는 시험지는 채점하고 학생에게 전달\n\n위의 과정은 동기적으로 이뤄지지 않아도 되기에 비동기처리가 가능하다.\n\n### 🙃 장, 단점\n**동기**\n- 설계가 매우 간단하고 직관적\n- 결과가 주어질 때까지 다른 작업을 수행하지 못하고 대기해야 한다.\n\n**비동기**\n- 동기보다 복잡\n- 결과가 주어지는데 시간이 걸리더라도 그 시간동안 다른 작업을 수행할 수 있으므로 효율적인 자원의 사용이 가능하다.\n\n---\n\n## 💡 Callback\n다른 함수에 인자로서 전달되는 함수로, 호출방식에 의한 구분으로 붙은 이름이다.\n특정 함수에 전달되어, 특정 함수 내에서의 어떠한 조건(또는 Event)에 의해 호출된다.\n\n**특정 함수에 전달**\n\n```javascript\nfunction printFirst() {\n    console.log('hello');\n}\n\nfunction printSecond() {\n    console.log('bye');\n}\n\nfunction sleepAndExec(sleepTime, callback) {\n    sleep(sleepTime);\n    callback();\n}\n\nsleepAndExec(3, printFirst);\nsleepAndExec(5, printSecond);\n```\n\n- `sleepAndExec()` 는 대기 시간과 호출할 함수를 지정하여 사용할 수 있다.\n- `sleepAndExec(3, printFirst);` 에서 `printFirst` 는 `sleepAndExec()` 의 인자로 전달되기에 **Callback 함수**이다.\n\n**어떠한 조건(또는 Event)**\n\n```javascript\nfunction onDetected() {\n    console.log(\"감지!\");\n}\n\nsetOnDetected(onDetected);\n```\n\n- `setOnDetected` 로 설정한 `onDetected` 가, 특정 조건이 감지되었을 때마다 호출되기에 이는 **Callback 함수**이다.\n\n이러한 Callback은 **Non-block**이며, **비동기 (Asynchronous) 방식의 함수**로 사용된다.\n- Callback을 전달하고, 바로 실행되는 것이 아니기 때문에 비동기 방식으로 사용된다.\n\n```javascript\ntmp = function(a, b, callback) {\n    callback(a+b, a-b);\n}\n\ntmp(1, 2, function(x, y) {\n    console.log(x);\n    console.log(y);\n})\n\n// output\n3\n-1\n```\n\n### 🤪 이유\nJavascript는 현재 **비동기식 프로그래밍**을 사용하고 있다.\n이는 모든 요청을 실행하고 결과를 받는 순서대로 다음 요청을 수행하는 방식이므로, 자원의 낭비를 줄인다.\n\n이러한 비동기 프로그래밍을 처리하기 위해 **Callback 함수**가 사용된다.\n\n---\n\n## 💡 Promise\nCallback의 원리를 이용해서 만든 라이브러리로, 비동기 처리에 사용하기 위해 `Promise 객체` 를 생성한다.\n\n> **\"내용은 실행되었지만, 결과는 아직 반환하지 않은 객체\"**\n\n### 🥺 상태\n**Pending** (대기), **Fulfilled** (이행), **Rejected** (실패)\n\n- 비동기 처리가 완료되지 않았다면 → **Pending** \n- 완료되었다면 → **Fulfilled**\n- 실패하거나 오류가 발생했다면 → **Rejected**\n\n```javascript\nconst condition = true;\nconst promise = new Promise((resolve, reject) => {\n  if (condition) {\n    resolve('resolved');\n  } else {\n    reject('rejected');\n  }\n});\n\npromise\n  .then((res) => {\n    console.log(res);\n  })\n  .catch((error) => {\n    console.error(error);\n  });\n```\n\n- `condition` 값에 따라 `promise` 의 반환 값이 결정된다.\n\t\n    - 값이 `참` 인 경우 `resolve` 를 호출하고, `거짓` 인 경우 (또는 에러가 발생한 경우) `reject` 를 호출한다.\n    - 따라서, 한 `Promise 객체` 에 `resolve` 와 `reject` 가 동시에 존재할 수 없다.\n- `then` 을 통해 `resolove` 된 경우의 반환 값을 받을 수 있고, `catch` 를 통해 `reject` 된 경우의 반환 값을 받을 수 있다.\n- `then`, `catch` 의 chaining을 통해 비동기 로직의 성공 여부에 따른 분기 처리가 가능하다.\n\n---\n\n## 💡 async, await\n가장 최근의 비동기 처리 문법으로, 기존의 **Callback** 이나 **Promise**의 단점을 해소하고자 만들어졌다.\n\n기존의 방식의 단점은 꼬리에 꼬리를 무는 chaining 코드가 나올 수 있어 **콜백 지옥**, **`then` 지옥**이 만들어질 수 있다는 점이다.\n\n### 😠 사용 방식\n`await` 를 통해 `Promise` 객체의 반환 값을 받아올 수 있다.\n\n`async/await` 사용 시, **\"`await` 는 `async` 함수 안에서만 동작한다\"**는 점을 인지해야 한다.\n\n**예시**\n\n```javascript\n(async () => {\n  const condition = true;\n  const promise = new Promise((resolve, reject) => {\n    if (condition) {\n      resolve('resolved');\n    } else {\n      reject('rejected');\n    }\n  });\n\n  try {\n    const result = await promise;\n    console.log(result);\n  } catch (err) {\n    console.error(err);\n  }\n})();\n```\n\n- `async` 함수 내의 `await` 를 통해 `Promise` 의 반환 값을 `result` 에 담아 출력한다.\n- 주의할 점으로는 `Promise` 에서의 `then & catch` 와 같은 **Error Handling**이 없어 ` try-catch` 문을 활용해야 한다는 점이다.\n\n---\n\n## 💡 정리\n**Error Handling**\n- `Promise` 는 `then & catch` 문으로 Error Handling이 가능하다.\n- `async & await` 는 이러한 기능이 없어 `try-catch` 문을 활용해야 한다.\n\n**Code 가독성**\n- `Promise` 는 콜백 지옥과 같은 `then` 지옥이 만들어질 수도 있다.\n- `async & await` 는 코드 길이나 가독성 측면에서 효율적이고 흐름을 이해하는 데도 좋다.\n\n---\n\n## 📕 참고\n동기, 비동기 처리란?\n- [동기와 비동기의 개념과 차이](https://private.tistory.com/24)\n- [동기는 정확히 무엇을 의미하는 걸까?](https://evan-moon.github.io/2019/09/19/sync-async-blocking-non-blocking/)\n\nCallback\n- [동기/ 비동기의 이해 - callback함수, promise, async, await](https://lunuloopp.tistory.com/entry/%EB%8F%99%EA%B8%B0-%EB%B9%84%EB%8F%99%EA%B8%B0%EC%9D%98-%EC%9D%B4%ED%95%B4-callback%ED%95%A8%EC%88%98-promise-async-await)\n- [콜백함수의 정확한 의미는 무엇일까?](https://satisfactoryplace.tistory.com/18)\n- [Callback 함수란 무엇인가?](https://dalkomit.tistory.com/65)\n- [콜백 함수 사용 방법](https://koonsland.tistory.com/159)\n\nasync, await\n- [Promise와 async/await 차이점](https://velog.io/@pilyeooong/Promise%EC%99%80-asyncawait-%EC%B0%A8%EC%9D%B4%EC%A0%90)\n\nPromise\n- [Promise와 async/await 차이점](https://velog.io/@pilyeooong/Promise%EC%99%80-asyncawait-%EC%B0%A8%EC%9D%B4%EC%A0%90)"},{"excerpt":"로그인 기능을 제공하기 위해서는 사용자의 정보를 지키는 보안이 필수라고 생각했습니다. \n처음으로 서버를 구현해보면서,  로그인한 사용자의 정보를 Session에는 어떻게 저장할 것인지,  이를 어디서 활용할 것인지,  사용자의 비밀번호는 어떻게 암호화 (복호화도?) 할 것인지 와 같은 고민을 해보았습니다. 💡 jwt = Json Web Token\n클라이언…","fields":{"slug":"/[BackEnd]JWT/"},"frontmatter":{"date":"January 16, 2022","title":"💻 JWT","tags":["jwt","Token","Cookie","Session"]},"rawMarkdownBody":"\n> 로그인 기능을 제공하기 위해서는 사용자의 정보를 지키는 보안이 필수라고 생각했습니다. \n> 처음으로 서버를 구현해보면서, \n> - 로그인한 사용자의 정보를 Session에는 어떻게 저장할 것인지, \n> - 이를 어디서 활용할 것인지, \n> - 사용자의 비밀번호는 어떻게 암호화 (복호화도?) 할 것인지\n> \n> 와 같은 고민을 해보았습니다.\n\n## 💡 jwt\n= Json Web Token\n클라이언트와 서버, 서비스와 서비스 간의 통신 시 Authorization을 위해 사용하는 Token입니다. 이때, Json 포맷을 이용하여 사용자의 속성 정보를 저장한다.\n\n클라이언트와 서버 간 정보를 주고 받을 때, HTTP request header에 JSON Token을 포함한 후 서버는 별도의 인증 과정 없이 Header에 포함된 jwt 정보를 통해 인증을 수행한다.\n\n### 🦈 구조\n<img src=\"https://images.velog.io/images/bsu1209/post/fb8e3c76-9388-44a0-8307-c09b4b88a4dc/springboot-Page-4.drawio.png\" width=\"60%\">\n\njwt는 header, payload, signature 세 파트로 나누어진다.\n\n#### header\n\n```json\n{\n  \"alg\": \"HS256\",\n  \"typ\": \"JWT\"\n}\n```\n\n- jwt를 어떻게 검증하는가에 대한 정보를 가지고 있다.\n- `alg` 는 Signature를 해싱하는 알고리즘 방식을 지정하며, Signature 및 Token 검증에 사용된다.\n- `typ` 은 Token의 타입을 지정한다.\n\n이와 같은 JSON 객체를 문자열로 직렬화하고 `UTF-8` 과 `Base64 URL-safe` 로 인코딩하게 되면 header를 생성할 수 있다.\n\n```json\nBase64URLSafe(UTF-8('{\"alg\": \"HS256\", \"typ\": \"JWT\"}')) → header!\n```\n\n#### payload\n\n```json\n{\n  \"iss\": \"seongukbaek\",\n  \"sub\": \"test\",\n  ...\n}\n```\n\n- Token을 통해 클라이언트와 서버 간 사용할 정보의 조각인 **\"Claim\"**이 저장된다.\n- 이러한 Claim의 모음을 **Claim Set**이라고 한다.\n- Claim은 총 3가지로 나누어지며, Json(Key-Value) 형태로 저장이 가능하다.\n\n##### Registered Claim (등록된 Claim)\nToken 정보를 표현하기 위해 이미 정해진 종류의 데이터\n- 선택적으로 사용 가능하며, 권장되는 claim\n- jwt를 간결하게 하기 위해 key는 모두 길이 3의 String이다.\n- 여기서 subject(sub)로는 고유한 값을 사용하는데, 대체로 사용자의 이메일을 사용한다.\n\n> - iss: 토큰 발급자(issuer)\n> - sub: 토큰 제목(subject)\n> - aud: 토큰 대상자(audience)\n> - exp: 토큰 만료 시간(expiration), NumbericDate 형식이어야 함(ex. 1480849147370) = unix time\n> - nbf: 토큰 활성 날짜(not before), 해당 날짜가 지나기 전의 토큰은 활성화되지 않음\n> - iat: 토큰 발급 시간(issued at), 토큰 발급 이후 경과 시간을 알 수 있음\n> - jti: jwt 토큰 식별자(jwt ID), 중복 방지를 위해 사용하며, 일회용 토큰(Access Token) 등에 사용\n\n##### Public Claim (공개 Claim)\n사용자 정의 Claim\n- 공개용 정보를 위해 사용된다. \n- 충돌 방지를 위해 URI 포맷을 이용한다.\n\n```json\n{ \n  \"https://baeksulog.netlify.app\": true \n}\n```\n\n##### Private Claim (비공개 Claim)\n사용자 정의 Claim\n- 서버와 클라이언트 사이에 임의로 지정한 정보를 저장한다.\n\n```json\n{ \n  \"isLogin\": true \n}\n```\n\n#### signature\nToken을 인코딩하거나 유효성 검증을 할 때 사용하는 고유한 암호화 코드이다. \n- 서명은 위에서 만든 header와 payload의 값을 각각 BASE64 URL-Safe로 인코딩하고, \n- 인코딩한 값을 Secret key를 이용해 header에서 정의한 알고리즘으로 해싱을 하고,\n- 이 값을 다시 BASE64 URL-Safe로 인코딩하여 생성한다.\n\n> **Base64 URL-Safe**\n> - URI에서 parameter로 사용될 수 있도록 \"+\", \"/\", \"=\" 를 제외한 인코딩 방식이다.\n> \n> 점을 구분자로 하여 header, payload, signature를 합치면 **jwt** 가 완성된다.\n\n### 🐢 장, 단점\n#### 장점\n주된 이점은 사용자 인증에 필요한 모든 정보는 **Token** 자체에 포함되어 별도의 인증을 위한 저장공간이 필요하지 않다는 점이다. (서버 기반의 인증 시스템은 별도 저장공간이 필요하다.)\n\n#### 단점\n- Tore Token: Token은 클라이언트 단에 저장되어 DB에서 사용자 정보를 수정하더라도 Token에 직접 적용할 수 없다.\n- Token 길이: 많은 field(Claim)이 추가되면 Token의 길이가 길어질 수 있고, 이는 네트워크의 부하로 작용될 수 있다.\n- Self-contained: Token 자체에 정보를 담고 있으므로 양날의 검이 될 수 있다. \n- payload 인코딩: payload 자체는 암호화된 것이 아니라, BASE64로 인코딩 된 것이다. 중간에 이를 탈취하여 디코딩하면 데이터를 볼 수 있으므로, JWE로 암호화하거나 payload에 중요 데이터를 넣지 않아야 한다. \n- Stateless: JWT는 상태를 저장하지 않기 때문에 한 번 만들어지면 제어가 불가능하다. 즉, Token을 임의로 삭제하는 것이 불가능하므로 Token 만료 시간을 꼭 넣어주어야 한다.\n\t\n    - Logout을 구현 시 어떻게 처리할 것인지에 대한 고민이 필요하다.\n\n### Access Token & Refresh Token\n**jwt** 에 대해 찾아보다보니, `Refresh Token` 이라는 개념에 대해 알게 되었다. \n\n#### Refresh Token이 필요한 이유?\n기본 jwt 방식으로 Access Token을 하나만 두는 경우 **해당 Token이 탈취**되었을 때, 보안의 취약하다는 문제가 발생한다.\n\n- 그렇다면, Access Token의 **유효기간**을 짧게 하여 탈취의 위험성을 낮추는 방법은 어떨까?\n   - 사용자는 그만큼 로그인을 자주 하여 새로운 Token을 발급받아야 해 불편하다.\n\n유효 기간을 길게 하면서, 보안에 덜 취약한 방법이 없을까? 라는 질문에 대한 답으로, **Refresh Token** 이 등장한다.\n아래는 **Access Token, Refresh Token**을 이용한 로그인 기능의 흐름도이다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/7f8cb095-1a4f-4f0f-8590-1de6d4b45a0a/springboot-Page-7.drawio.png\" width=\"80%\">\n\n이러한 방식을 사용하면,\n- 당연히 기존의 방식보다 더 안전하다.\n- 하지만, **Access Token**이 만료될 때마다 새 Token을 발급하는 과정에서 생기는 HTTP 요청 횟수가 많아지고, 이는 곧 **서버의 자원 낭비**로 귀결된다.\n\n### 🐡 저장\n저장위치에 있어 정답은 없는 것 같다.\n그저 개발 환경에 있어 최선책을 사용하는 것이 답인 것 같다.\n먼저, 보안에 있어 문제가 되는 몇 가지를 알고 가야한다.\n\n#### XSS\nCross Site Script의 약자로, 이미 `CSS` 라는 약자가 존재해 `XSS` 로 지어졌다.\n게시판이나 웹 메일 등에 `js` 와 같은 script code를 삽입해 개발자가 의도치 않은 기능이 동작하게 해 치명적인 공격이다.\nXSS에는 `Reflected XSS` , `Stored XSS` , `DOM Based XSS` 가 있다.\n자세한 내용은 참고에서 확인할 수 있다.\n\n#### CSRF\nCross Site Request Forgery의 약자이다.\n정상적인 request를 가로채 피해자인 척 하고 서버에 변조된 request를 보내 악의적인 동작을 수행하는 공격을 의미한다.\n자세한 내용은 참고에서 확인할 수 있다.\n\n> **XSS 예방이 최소한의 조치**\n> js로 의도하지 않은 request를 날린다던가 localStorage, 변수 값 등 모든 것이 탈취 가능하기에 XSS 공격 방지가 웹 보안의 시작이라고 할 수 있다.\n\n**Cookie**, **LocalStorage** 를 이용하면서 위와 같은 보안 문제를 맞닥뜨리게 된다.\n\n#### LocalStorage\n##### 장점\n**CSRF** 공격에는 안전하다.\n- 자동으로 request에 담기는 쿠키와 다르게 js에 의해 헤더에 담기므로 **XSS**를 뚫지 않는 이상 공격자가 정상적인 사용자인 척 request를 보내기가 어렵다.\n\n##### 단점\n**XSS**에 취약하다.\n- 공격자가 **LocalStorage**에 접근하는 js 한 줄만 주입하면 **LocalStorage**를 공격자가 내 집처럼 드나들 수 있다.\n\n#### Cookie\n##### 장점\n**XSS** 공격으로부터 **LocalStorage**에 비해 안전하다.\n- **Cookie**의 `httpOnly` 옵션을 사용하면 js에서 **Cookie**에 접근 자체가 불가능하다.\n- 그래서 **XSS** 공격으로 **Cookie** 정보를 탈취할 수 없다. (`httpOnly` 옵션은 서버에서 설정할 수 있음)\n\n하지만 **XSS** 공격으로부터 완전히 안전한 것은 아니다.\n- `httpOnly` 옵션으로 **Cookie**의 내용을 볼 수 없다 해도 js로 request를 보낼 수 있으므로 자동으로 request에 실리는 **Cookie**의 특성 상 사용자의 컴퓨터에서 요청을 위조할 수 있기 때문이다.\n- 공격자가 귀찮을 뿐이지 **XSS**가 뚫린다면 `httpOnly` **Cookie**도 안전하진 않다.\n\n##### 단점\n**CSRF** 공격에 취약하다.\n- 자동으로 request에 담아서 보내기 때문에 공격자가 request url만 안다면 사용자가 관련 link를 클릭하도록 유도하여 request를 위조하기 쉽다.\n\n#### DB vs. Redis (Refresh token)\n**LocalStorage** & **Cookie** 의 문제점을 피하기 위해 가장 좋은 방법은 서버사이드에 저장하는 것이다.\n\n\"즉, **DB**에 **Refresh Token**을 저장하고 저장되는 **index**를 **Cookie**에 저장한다.\"\n\n이때, 구글링을 통해 **Redis** 또는 일반적인 **DB**에 저장하는 방식을 발견했다.\n이미 사용자의 정보를 `Mysql` 을 사용하여 저장하고 있으므로, **DB**에 저장하는 방식을 사용하긴 할 것이다.\n\n하지만 **Redis**에 대해 알아보자면,\n\n##### Redis\n메모리 기반의 key-value 구조 데이터 관리 시스템으로, 비관계형 데이터베이스이다.\n- 자바 자료구조와 유사한 영속적인 자료구조 제공 (키는 자바에서 참조와 동일한 역할, 즉 객체를 식별)\n- 크게 `String` , `Set` , `Sorted Set` , `Hash` , `List` 데이터 형식 지원\n- 읽기 성능 증대를 위한 서버 측 복제를 지원\n- 쓰기 성능 증대를 위한 클라이언트 측 Sharding 지원\n\n**장점**\n- 리스트, 배열 데이터를 처리하는 데 유용\n- 리스트 형 데이터 입력 & 삭제가 **MySQL**에 비해 10배정도 빠름\n- 영속적인 데이터 보존\n\n이러한 특징이 있고 자세한 내용은 참고에서 확인할 수 있다.\n\n위에서 다룬 사항들을 종합해보았을 때, 아래와 같은 방식으로 구현할 예정이다.\n- **Access Token**, **Refresh Token** 을 사용\n- **Access Token**은 짧은 유효기간으로, **Cookie**에만 저장 (`httpOnly`)\n- **Refresh Token**은 비교적 긴 유효기간으로, **DB**에 저장\n\n### 🐳 필요한 기능\n큰 흐름으로는 아래와 같은 기능들이 필요할 것이라 판단했다.\n- Token이 유효하다 = 로그인된 상태\n- Token이 만료되었다 = 유효 기간이 지난 상태\n\n#### 사용자의 login post 처리\n1. `User` DB에 저장되어 있는 사용자인지 확인\n2. 로그인하는 사용자에 대한 **Access Token & Refresh Token** 생성 (`jwt.sign()`)\n3. **Refresh Token**은 DB에 저장하고, **Access Token** 을 Cookie(httpOnly)에 저장\n\n#### Access Token의 유효성을 검사하는 `middleware`\n1. request의 header에 있는 **Access Token** 을 확인\n2. Token이 없는 경우, `Status 400` return\n3. 그렇지 않은 경우, `jwt.verify()` 로 Token의 유효성 검사\n   - `verify()` 매개변수 3개\n      - client에게서 받은 **Token**, Token 생성 시 사용했던 **secretKey**, 유효성 검사 결과를 처리할 **callback function**\n4. 기간이 지나지 않은 유효한 Access Token이라면, 통과\n5. 기간이 지났고 유효한 Access Token이라면, **재발급** 과정으로 전달\n\n#### Refresh Token을 기반으로 새로운 Access Token 발급\n1. request의 body로부터 사용자의 **Refresh Token** 추출\n2. Token이 없다면, `Status 401` return\n3. **DB**에 저장된 **Refresh Token**와 동일한지 검사, `jwt.verify()` 로 Token의 유효성 검사\n4. 유효하다면, `user의 id` (or else) 를 이용하여 새로운 **Access Token**과 **Refresh Token** 생성\n5. 그렇지 않다면, **DB**에서 **Refresh Token** 삭제하고 재로그인 요청\n\n### 💁‍♂️ 이슈사항\n#### Refresh Token\n- 서버 - 클라이언트 간 Token이 담긴 Cookie을 주고 받으면서 사용하는데, Refresh Token의 안전을 위해 DB에 Refresh Token 저장 시 자동 생성된 Unique한 Token_id 값을 Cookie에 저장해 주고 받는 방식은 어떨까\n\t\n    - Refresh Token Cookie가 탈취되어도, Token이 저장된 DB에 접근하지 못하면 Refresh Token을 보호할 수 있지 않을까\n\n#### Cookie 저장\n- Token 발급 시, 서버에서 이를 Cookie(httpOnly)에 담아 전송할 지 또는 서버는 발급한 Token을 그대로 클라이언트로 전송하여 Front에서 Cookie에 담아 사용할지\n\t\n    - 서버에서 Cookie에 담아 클라이언트로 전송하는 방식이 좀 더 안전해보일 것 같다.\n\n### 📕 참고\n- [[Server] JWT(Json Web Token)란?](https://mangkyu.tistory.com/56)\n- [JWT (JSON Web Token) 이해와 활용](http://www.opennaru.com/opennaru-blog/jwt-json-web-token/)\n- [JWT를 소개합니다.](https://meetup.toast.com/posts/239)\n- [TIL 50 | JWT 원리와 장단점](https://velog.io/@mygomi/TIL-50-JWT%EC%97%90-%EB%8C%80%ED%95%B4-%EB%B0%9C%ED%91%9C%ED%95%B4%EB%B3%B4%EA%B2%A0%EC%8A%B5%EB%8B%88%EB%8B%A4#jwt%EC%9D%98-%EC%9E%A5%EC%A0%90%ED%95%84%EC%9A%94%EC%84%B1)\n- Access Token & Refresh Token\n  - [쉽게 알아보는 서버 인증 2편(Access Token + Refresh Token)](https://tansfil.tistory.com/59)\n- 저장\n  - [XSS](https://4rgos.tistory.com/1)\n  - [CSRF](https://itstory.tk/entry/CSRF-%EA%B3%B5%EA%B2%A9%EC%9D%B4%EB%9E%80-%EA%B7%B8%EB%A6%AC%EA%B3%A0-CSRF-%EB%B0%A9%EC%96%B4-%EB%B0%A9%EB%B2%95)\n\t\n    - [JWT는 어디에 저장해야 할까?](https://velog.io/@0307kwon/JWT%EB%8A%94-%EC%96%B4%EB%94%94%EC%97%90-%EC%A0%80%EC%9E%A5%ED%95%B4%EC%95%BC%ED%95%A0%EA%B9%8C-localStorage-vs-cookie)\n\t\n    - [Redis](https://velog.io/@ayoung0073/database-redis)\n- 필요한 기능\n  - [JWT 사용하기](https://surprisecomputer.tistory.com/39)"},{"excerpt":"문제 세로 두 줄, 가로로 N개의 칸으로 이루어진 표가 있다. 첫째 줄의 각 칸에는 정수 1, 2, …, N이 차례대로 들어 있고 둘째 줄의 각 칸에는 1이상 N이하인 정수가 들어 있다. 첫째 줄에서 숫자를 적절히 뽑으면, 그 뽑힌 정수들이 이루는 집합과, 뽑힌 정수들의 바로 밑의 둘째 줄에 들어있는 정수들이 이루는 집합이 일치한다. 이러한 조건을 만족시…","fields":{"slug":"/[BOJ]2668/"},"frontmatter":{"date":"January 13, 2022","title":"👩‍💻 2668. 숫자 고르기","tags":["그래프이론","그래프탐색","DFS"]},"rawMarkdownBody":"\n## 문제\n\n세로 두 줄, 가로로 N개의 칸으로 이루어진 표가 있다. 첫째 줄의 각 칸에는 정수 1, 2, …, N이 차례대로 들어 있고 둘째 줄의 각 칸에는 1이상 N이하인 정수가 들어 있다. 첫째 줄에서 숫자를 적절히 뽑으면, 그 뽑힌 정수들이 이루는 집합과, 뽑힌 정수들의 바로 밑의 둘째 줄에 들어있는 정수들이 이루는 집합이 일치한다. 이러한 조건을 만족시키도록 정수들을 뽑되, 최대로 많이 뽑는 방법을 찾는 프로그램을 작성하시오. 예를 들어, N=7인 경우 아래와 같이 표가 주어졌다고 하자.\n\n<img src=\"https://www.acmicpc.net/upload/images/u5JZnfExdtFXjmR.png\" width=\"30%\">\n\n이 경우에는 첫째 줄에서 1, 3, 5를 뽑는 것이 답이다. 첫째 줄의 1, 3, 5밑에는 각각 3, 1, 5가 있으며 두 집합은 일치한다. 이때 집합의 크기는 3이다. 만약 첫째 줄에서 1과 3을 뽑으면, 이들 바로 밑에는 정수 3과 1이 있으므로 두 집합이 일치한다. 그러나, 이 경우에 뽑힌 정수의 개수는 최대가 아니므로 답이 될 수 없다.\n\n### 입력\n- 첫째 줄에는 N(1≤N≤100)을 나타내는 정수 하나가 주어진다. 그 다음 줄부터는 표의 둘째 줄에 들어가는 정수들이 순서대로 한 줄에 하나씩 입력된다.\n\n### 출력\n- 첫째 줄에 뽑힌 정수들의 개수를 출력하고, 그 다음 줄부터는 뽑힌 정수들을 작은 수부터 큰 수의 순서로 한 줄에 하나씩 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Graph {\n    int[] graph;\n    int[] visited;\n    PriorityQueue<Integer> path = new PriorityQueue<>();\n}\n```\n\n- 입력되는 숫자들을 저장하는 `graph` 배열, 각 정점의 방문여부를 저장하는 `visited` 배열, 사이클을 이루는 정점들을 저장하는 `path` 우선순위 큐\n\n```java\npublic void solution() {\n    for (int i=1; i<graph.length; i++) {\n        if (dfs(i, i) == 1) {\n            path.add(i);\n        }\n        visited = new int[graph.length];\n    }\n    printList();\n}\n```\n\n- 각 정점을 시작으로 하여, `dfs` 의 리턴값으로 사이클의 존재여부 확인\n- 존재하는 경우, `path` 우선순위 큐에 저장\n- 방문 여부를 저장하는 `visited` 초기화\n\n```java\npublic int dfs (int start, int end) {\n    if (visited[end] == 0) {\n        visited[end] = 1;\n        return dfs(start, graph[end]);\n    }\n    else {\n        return (start == end) ? 1 : 0;\n    }\n}\n```\n\n- 시작점, 시작점에서 이어지는 정점을 인자로 받아, 방문여부를 확인하고 방문 체크\n- 이어지는 정점이 방문한 경우, 시작점과 동일한지 확인\n  - 동일한 경우, **사이클이 존재** → 1 반환\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\" data-language=\"java\">\n\n        import java.util.*;\n\n        class Graph {\n            int[] graph;\n            int[] visited;\n            PriorityQueue<Integer> path = new PriorityQueue<>();\n\n            public Graph(int size) {\n                graph = new int[size+1];\n                visited = new int[size+1];\n            }\n\n            public void AddElement(int idx, int item) {\n                graph[idx] = item;\n            }\n\n            public void solution() {\n                for (int i=1; i<graph.length; i++) {\n                    if (dfs(i, i) == 1) {\n                        path.add(i);\n                    }\n                    visited = new int[graph.length];\n                }\n                printList();\n            }\n\n            public int dfs (int start, int end) {\n                if (visited[end] == 0) {\n                    visited[end] = 1;\n                    return dfs(start, graph[end]);\n                }\n                else {\n                    return (start == end) ? 1 : 0;\n                }\n            }\n\n            public void printList() {\n                System.out.println(path.size());\n                for (int t : path)\n                    System.out.println(t);\n            }\n        }\n\n        public class Main {\n            public static void main(String[] args) {\n                Scanner sc = new Scanner(System.in);\n                int T = sc.nextInt();\n\n                Graph g = new Graph(T);\n\n                for (int i=1; i<=T; i++) {\n                    g.AddElement(i, sc.nextInt());\n                }\n\n                g.solution();\n\n                sc.close();\n            }\n        }\n  </div>\n</details>\n\n### ✏️ **Review**\n- 전에 <strong>C++</strong>로 푼 문제였는데, JAVA로 변환하면서 다시 한 번 아이디어를 생각해보았다.\n- 그래프 문제이기 때문에, 유향이든 무향이든 어쨌든 그래프로의 표현이 가능하다는 의미라고 생각해 정점 간의 인접 정보를 표현하고 이를 그려 아이디어를 생각해보았다.\n- 사이클이 존재하는 경우, 사이클을 형성하는 PATH가 정답이 된다고 생각했다.\n  - 방문한 정점에 다시 방문하는 경우로 구현하려고 했으나, 방문 여부 변경과 확인 시점에서 막혔다.\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/2668"},{"excerpt":"스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 들으며 정리하는 POST입니다. 전체적인 흐름 Spring Project 생성 Spring boot로 웹 서버 실행 회원 도메인 개발 웹 MVC 개발 DB 연동 - JDBC, JPA, Spring data JPA 테스트 케이스 작성 🔍 AOP가 필요한 상황 모든 method의 호출…","fields":{"slug":"/[스프링입문]7/"},"frontmatter":{"date":"January 13, 2022","title":"📺 7. AOP","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)을 들으며 정리하는 POST입니다.</strong></em>\n\n> **전체적인 흐름**\n> - Spring Project 생성\n> - Spring boot로 웹 서버 실행\n> - 회원 도메인 개발\n> - 웹 MVC 개발\n> - DB 연동 - JDBC, JPA, Spring data JPA\n> - 테스트 케이스 작성\n\n## 🔍 AOP가 필요한 상황\n- 모든 method의 호출 시간을 측정하고 싶다면?\n- 공통 관심 사항(cross-cutting concern) vs. 핵심 관심 사항(core concern)\n- 회원 가입 시간, 회원 조회 시간을 측정하고 싶다면?\n\n`service/MemberService.java`\n\n```java\npublic Long join(Member member) {\n\n    long start = System.currentTimeMillis();\n    try {\n        ValidateDuplicateMember(member); // 이름 중복 회원 검증\n        memberRepository.save(member);\n        return member.getId();\n    } finally {\n        long finish = System.currentTimeMillis();\n        long timeMs = finish - start;\n        System.out.println(\"join = \" + timeMs + \"ms\");\n    }\n}\n```\n\n- method가 시작하는 시간과 끝날 때의 시간의 차이를 보여준다.\n- `try - finally` 문을 이용하여 예외가 발생해도 호출 시간을 측정할 수 있도록 한다.\n- 회원가입 Test code를 실행해보면, 호출 시간에 대한 결과가 출력이 되는 것을 확인할 수 있다.\n\n```java\n// 전체 회원 조회\npublic List<Member> findMembers() {\n    long start = System.currentTimeMillis();\n\n    try {\n        return memberRepository.findAll();\n    } finally {\n        long finish = System.currentTimeMillis();\n        long timeMs = finish - start;\n        System.out.println(\"findMembers = \" + timeMs + \"ms\");\n    }\n}\n```\n\n- 회원 목록 기능 시 사용되는 `findMembers` method의 시간 확인을 위해 스프링을 동작시켜 회원 목록을 확인하고자 하면, 아래와 같은 결과를 볼 수 있다.<img src=\"https://images.velog.io/images/bsu1209/post/f924b40d-0f8b-4cea-9a4a-7481a73db05a/image.png\" width=\"100%\">\n- 처음 실행했을 때는 Loading으로 인해 시간이 오래 걸리지만, 몇 번 더 수행해보면 시간이 줄어든다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/00a7f7b8-23d0-4f04-b1e2-6f2fa6320dbd/springboot-Page-5.drawio.png\" width=\"80%\">\n\n<span id=\"prob\"></span>**문제**\n- 위에서 확인한 회원가입, 조회의 시간 측정 기능은 핵심 관심 사항이 아니다.\n- 시간을 측정하는 로직은 공통 관심 사항이다.\n- 시간을 측정하는 로직과 핵심 비즈니스의 로직(=핵심 관심 사항)이 섞여 유지보수가 어렵다.\n- 시간을 측정하는 로직을 별도의 공통 로직으로 만들기 매우 어렵다.\n- 시간을 측정하는 로직을 변경할 때 모든 로직을 찾아가면서 변경해야 한다.\n\n---\n\n## 🔍 AOP 적용\n**Aspect Oriented Programming**\n- 공통 관심 사항(cross-cutting concern)과 핵심 관심 사항(core concern)을 분리\n- 시간 측정 로직을 한 군데에 모아두고, 적용하고자 하는 class를 지정한다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/c5a09499-3a12-4c8e-ade2-24cbac174c4e/springboot-Page-5.drawio%20(1).png\" width=\"80%\">\n\n`aop/TimeTraceAop.java`\n\n```java\npackage hello.hellospring.aop;\n\nimport org.aspectj.lang.ProceedingJoinPoint;\nimport org.aspectj.lang.annotation.Around;\nimport org.aspectj.lang.annotation.Aspect;\nimport org.springframework.stereotype.Component;\n\n@Aspect\n@Component\npublic class TimeTraceAop {\n\n    @Around(\"execution(* hello.hellospring..*(..))\")\n    public Object execute(ProceedingJoinPoint joinPoint) throws Throwable {\n        long start = System.currentTimeMillis();\n        System.out.println(\"START: \" + joinPoint.toString());\n        try {\n            return joinPoint.proceed();\n        } finally {\n            long finish = System.currentTimeMillis();\n            long timeMs = finish - start;\n            System.out.println(\"END: \" + joinPoint.toString() + \" \" + timeMs + \"ms\");\n        }\n    }\n}\n\n```\n\n- Spring에서 AOP를 사용하기 위해서는 `@Aspect` annotation이 필요하다.\n- AOP가 호출될 때마다 `joinPoint` 라는 중간 intercept 지점에 정보가 담긴다. \n- `@Around` annotation으로, 작성한 공통 관심 사항인 `TimeTraceAop` 를 어디 적용시킬 것인지 명시한다.\n\t\n    - `@Around(\"execution(* hello.hellospring..*(..))\")` 는 `hello.hellospring` package 하위에 있는 모든 class에 적용한다는 의미\n- 스프링 컨테이너에 등록해야 하는데, `@Component` annotation을 사용하여 컴포넌트 스캔을 할 수도 있지만, AOP는 특별한 기능이기 때문에 `SpringConfig` 에서 아래와 같이 따로 작성할 수도 있다.\n\n`SpringConfig`\n```java\n@Bean\npublic TimeTraceAop timeTraceAop() {\n    return new TimeTraceAop();\n}\n```\n\n이제 서버를 동작시켜 회원 목록 기능을 작동시키면,\n```bash\nSTART: execution(String hello.hellospring.controller.MemberController.list(Model))\nSTART: execution(List hello.hellospring.service.MemberService.findMembers())\nSTART: execution(List org.springframework.data.jpa.repository.JpaRepository.findAll())\n\nEND: execution(List org.springframework.data.jpa.repository.JpaRepository.findAll()) 64ms\nEND: execution(List hello.hellospring.service.MemberService.findMembers()) 78ms\nEND: execution(String hello.hellospring.controller.MemberController.list(Model)) 89ms\n```\n\n- 동작하는 class들의 method들을 확인할 수 있고, 각각의 동작 시간을 확인할 수 있다.\n- 이를 통해 어느 부분에서 **병목 현상**이 발생하는지 확인할 수 있다.\n\n**<a href=\"#prob\">문제</a> 해결**\n- 회원가입, 회원 조회 등 핵심 관심 사항과 시간을 측정하는 공통 관심 사항을 분리한다. \n- 시간을 측정하는 로직을 별도의 공통 로직으로 만들었다.\n- 핵심 관심 사항을 깔끔하게 유지할 수 있다. (ex. `MemberService.java`)\n- 변경이 필요하면 이 로직만 변경하면 된다.\n- 원하는 적용 대상을 선택할 수 있다.\n\n### ⛏ 스프링의 AOP 동작 방식 설명\n**Dependency Injection이 기반으로 작용하기에 AOP의 동작이 가능하다.**\n\n**AOP 적용 전 의존 관계**<br/>\n<img src=\"https://images.velog.io/images/bsu1209/post/a80949d6-6e05-49da-9e67-1f43589f4b2a/springboot-Page-6.drawio.png\" width=\"80%\">\n\n**AOP 적용 후 의존 관계**<br/>\n<img src=\"https://images.velog.io/images/bsu1209/post/a9da9510-203f-4508-9c54-549861dde64e/springboot-Page-6.drawio%20(1).png\" width=\"80%\">\n\n- AOP가 있으면, 가짜 `memberService` = 프록시 `memberService` 을 생성한다.\n- 가짜 스프링 빈의 AOP가 다 실행되면, `joinPoint.proceed()` 를 통해 실제 `memberService` 를 호출한다.\n- `helloController` 는 실제 `memberService` 가 아닌 프록시 기술로 생성된 가짜 `memberService` 를 호출한다.\n\n**AOP 적용 전 전체 그림**<br/>\n<img src=\"https://images.velog.io/images/bsu1209/post/bffdfb77-ba3a-40f0-b60b-47976f193198/springboot-Page-5.drawio.png\" width=\"80%\">\n\n**AOP 적용 후 전체 그림**<br/>\n<img src=\"https://images.velog.io/images/bsu1209/post/65f216e4-536a-4339-920c-436da5a6a0e7/springboot-Page-5.drawio%20(1).png\" width=\"80%\">\n\n---\n\n## 📌 중요한 개념\nAOP, 프록시 기술\n\n## 📕 참고\n- [스프링 입문-코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)"},{"excerpt":"문제 그래프의 정점의 집합을 둘로 분할하여, 각 집합에 속한 정점끼리는 서로 인접하지 않도록 분할할 수 있을 때, 그러한 그래프를 특별히 이분 그래프 (Bipartite Graph) 라 부른다. 그래프가 입력으로 주어졌을 때, 이 그래프가 이분 그래프인지 아닌지 판별하는 프로그램을 작성하시오. 입력 입력은 여러 개의 테스트 케이스로 구성되어 있는데, 첫째…","fields":{"slug":"/[BOJ]1707/"},"frontmatter":{"date":"January 12, 2022","title":"👩‍💻 1707. 이분그래프","tags":["그래프이론","그래프탐색","BFS","DFS"]},"rawMarkdownBody":"\n## 문제\n\n그래프의 정점의 집합을 둘로 분할하여, 각 집합에 속한 정점끼리는 서로 인접하지 않도록 분할할 수 있을 때, 그러한 그래프를 특별히 이분 그래프 (Bipartite Graph) 라 부른다.\n\n그래프가 입력으로 주어졌을 때, 이 그래프가 이분 그래프인지 아닌지 판별하는 프로그램을 작성하시오.\n\n### 입력\n- 입력은 여러 개의 테스트 케이스로 구성되어 있는데, 첫째 줄에 테스트 케이스의 개수 K가 주어진다. 각 테스트 케이스의 첫째 줄에는 그래프의 정점의 개수 V와 간선의 개수 E가 빈 칸을 사이에 두고 순서대로 주어진다. 각 정점에는 1부터 V까지 차례로 번호가 붙어 있다. 이어서 둘째 줄부터 E개의 줄에 걸쳐 간선에 대한 정보가 주어지는데, 각 줄에 인접한 두 정점의 번호 u, v (u ≠ v)가 빈 칸을 사이에 두고 주어진다. \n\n### 출력\n- K개의 줄에 걸쳐 입력으로 주어진 그래프가 이분 그래프이면 YES, 아니면 NO를 순서대로 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Graph {\n    final List<Integer>[] graph;\n    final int[] Binary = { -1, 1 };\n    int[] discovered;\n    boolean isBinaryGraph = true;\n    int toggle = 0;\n\n    public Graph(int size) {\n        this.graph = new ArrayList[size+1];\n        discovered = new int[size+1];\n\n        for (int i = 0; i <= size; i++) {\n            graph[i] = new ArrayList<>();\n        }\n    }\n}\n```\n\n- 그래프의 정보를 저장하기 위한 클래스\n\n```java\npublic boolean solution() {\n    for (int i=1; i < graph.length; i++) {\n        if (graph[i].size() > 0 & discovered[i] == 0) {\n            isBinaryGraph = this.bfs(i);\n            if (!isBinaryGraph)\n                break;\n        }\n    }\n    return this.isBinaryGraph;\n}\n```\n\n- 인접 정점 정보가 있고, 아직 방문하지 않은 정점에 대해 *BFS* 를 수행\n  - 정점의 방문 여부는 (0: 미방문), (-1: 1그룹), (1: 2그룹)\n- 이분 그래프인지를 저장하는 `isBinaryGraph` 에 `false` 가 나오면 더 이상의 탐색을 종료하고 이를 반환\n- `false` 가 계속 나오지 않으면 이분 그래프이므로 초기값인 `true` 가 반환\n  \n```java\npublic boolean bfs(int parent) {\n    Queue<Integer> q = new LinkedList<>();\n    q.add(parent);\n    while (!q.isEmpty()) {\n        int now = q.poll();\n        if (discovered[now] == 0) { discovered[now] = Binary[toggle]; }\n        toggle = (discovered[now] == -1 ? 1 : 0);\n        for (int tmp : graph[now]) {\n            if (discovered[tmp] == 0) {\n                q.add(tmp);\n                discovered[tmp] = Binary[toggle];\n            } else if (discovered[tmp] == discovered[now])\n                return false;\n        }\n    }\n    return true;\n}\n```\n\n- `Queue` 를 이용하여 **BFS** 수행\n- 방문하지 않은 정점은 방문 여부 값을 가지고 있는 `Binary` 배열과 `toggle` 변수로 **setting**\n- **BFS 단계별 서로 다른 방문 값 저장**\n- 다음 방문할 정점이 **이미 방문**했고, 현재 방문 정점과 **같은 방문 값**을 가진다면 **이분 그래프 불가**\n  \n### 📄 **틀린 CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.ArrayList;\n    import java.util.Scanner;\n\n    class Graph {\n        private final ArrayList<ArrayList<Integer>> graph;\n        private int[] discovered;\n        private boolean oddCycle = false;\n        private int dis;\n\n        public Graph(int size) {\n            this.graph = new ArrayList<>();\n\n            for (int i = 0; i <= size; i++) {\n                graph.add(new ArrayList<>());\n            }\n        }\n\n        public void DoubleAdd(int x, int y) {\n            graph.get(x).add(y);\n            graph.get(y).add(x);\n        }\n\n        public boolean isOddCycle(int s, int n) {\n            discovered = new int[20001];\n            dis = 1;\n            this.dfs(s, n);\n            return this.oddCycle;\n        }\n\n        public void dfs(int parent, int now) {\n            discovered[now] = dis++;\n            int size = graph.get(now).size();\n            if (size == 0) return;\n            for (int i = 0; i < size; i++) {\n                int idx = graph.get(now).get(i);\n                if (discovered[idx] == 0) {\n                    this.dfs(now, idx);\n                }\n                else if (idx != parent && ((discovered[now] - discovered[idx])%2 == 0)) {\n                    this.oddCycle = true;\n                }\n            }\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) {\n            Scanner sc = new Scanner(System.in);\n            int T = sc.nextInt();\n\n            while (T > 0) {\n                int v = sc.nextInt();\n                int e = sc.nextInt();\n                sc.nextLine();\n                boolean isOdd = false;\n\n                Graph g = new Graph(v);\n\n                for (int i = 0; i < e; i++) {\n                    String str = sc.nextLine();\n                    int a = str.charAt(0) - '0';\n                    int b = str.charAt(2) - '0';\n\n                    g.DoubleAdd(a,b);\n                }\n\n                for (int i = 1; i <= v; i++) {\n                    isOdd = g.isOddCycle(i, i);\n                    // odd가 한 번이라도 true면 이분 그래프가 될 수 없다.\n                    if (isOdd)\n                        break;\n                }\n\n                if (!isOdd)\n                    System.out.println(\"YES\");\n                else\n                    System.out.println(\"NO\");\n                T-=1;\n            }\n\n            sc.close();\n        }\n    }\n  \t</div>\n</details>\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n    class Graph {\n        final List<Integer>[] graph;\n        final int[] Binary = { -1, 1 };\n        int[] discovered;\n        boolean isBinaryGraph = true;\n        int toggle = 0;\n\n        public Graph(int size) {\n            this.graph = new ArrayList[size+1];\n            discovered = new int[size+1];\n\n            for (int i = 0; i <= size; i++) {\n                graph[i] = new ArrayList<>();\n            }\n        }\n\n        public void DoubleAdd(int x, int y) {\n            graph[x].add(y);\n            graph[y].add(x);\n        }\n\n        public boolean solution() {\n            for (int i=1; i < graph.length; i++) {\n                if (graph[i].size() > 0 & discovered[i] == 0) {\n                    isBinaryGraph = this.bfs(i);\n                    if (!isBinaryGraph)\n                        break;\n                }\n            }\n            return this.isBinaryGraph;\n        }\n\n        public boolean bfs(int parent) {\n            Queue<Integer> q = new LinkedList<>();\n            q.add(parent);\n            while (!q.isEmpty()) {\n                int now = q.poll();\n                if (discovered[now] == 0) { discovered[now] = Binary[toggle]; }\n                toggle = (discovered[now] == -1 ? 1 : 0);\n                for (int tmp : graph[now]) {\n                    if (discovered[tmp] == 0) {\n                        q.add(tmp);\n                        discovered[tmp] = Binary[toggle];\n                    } else if (discovered[tmp] == discovered[now])\n                        return false;\n                }\n            }\n            return true;\n        }\n    }\n\n    public class Main {\n        public static void main(String[] args) {\n            Scanner sc = new Scanner(System.in);\n            int T = sc.nextInt();\n\n            while (T > 0) {\n                int v = sc.nextInt();\n                int e = sc.nextInt();\n                sc.nextLine();\n\n                Graph g = new Graph(v);\n\n                for (int i = 0; i < e; i++) {\n                    int a = sc.nextInt();\n                    int b = sc.nextInt();\n                    g.DoubleAdd(a,b);\n                }\n\n                if (g.solution())\n                    System.out.println(\"YES\");\n                else\n                    System.out.println(\"NO\");\n                T-=1;\n            }\n            sc.close();\n        }\n    }\n  \t</div>\n</details>\n\n### ✏️ **Review**\n\n- 논리는 \"DFS를 이용해 **홀수개의 정점끼리 사이클**을 이루는 경우 **이분그래프가 될 수 없다**\" 였고, 반례를 통해 확인했을때 얼추 맞는 것 같으나, 계속 `런타임 에러 (IndexOutOfBounds)` 가 떠서 진전이 없었다.\n- 10번 이상의 에러로 정신이 나가버릴 것 같아 BFS를 이용하는 방법으로 바꿔보기로 했다.\n  - BFS를 이용하는 경우, 방문 순서로는 해결할 수 없을 것 같아 다른 방법을 고안해야 했다.\n- DFS, BFS를 확실하게 이해할 수 있었던 것 같다.\n\n```java\nString str = sc.nextLine();\nint a = str.charAt(0) - '0';\nint b = str.charAt(2) - '0';\n```\n\n- 위 방식으로 `1 2` 형식의 숫자를 입력받으니 `10 12` 와 같은 경우 당연히 틀릴 수 밖에 없었다 ...\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/1707"},{"excerpt":"스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 들으며 정리하는 POST입니다. 전체적인 흐름 Spring Project 생성 Spring boot로 웹 서버 실행 회원 도메인 개발 웹 MVC 개발 DB 연동 - JDBC, JPA, Spring data JPA 테스트 케이스 작성 🔍 H2 데이터베이스 설치 메모리 기반의 애플리케…","fields":{"slug":"/[스프링입문]6/"},"frontmatter":{"date":"January 12, 2022","title":"📺 6. 스프링 DB 접근 기술","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)을 들으며 정리하는 POST입니다.</strong></em>\n\n> **전체적인 흐름**\n> - Spring Project 생성\n> - Spring boot로 웹 서버 실행\n> - 회원 도메인 개발\n> - 웹 MVC 개발\n> - DB 연동 - JDBC, JPA, Spring data JPA\n> - 테스트 케이스 작성\n\n## 🔍 H2 데이터베이스 설치\n메모리 기반의 애플리케이션은 실무에서는 사용될 수 없다.\n수 많은 데이터를 기록하고 영구적으로 저장하기 위해서는 Database를 사용하여야 한다.\n\n여기서 사용할 Database는 아주 가볍고 간단한 **\"H2 Database\"** 를 사용할 것이다.\n\n**H2 Database**는 다음과 같은 특징을 가진다.\n- open source, 매우 빠른 JDBC API\n- Embedded and server modes; disk-based or in-memory databases\n- Browser 기반의 Console application\n- 트랜잭션 지원, 동시성 제어 가능\n- Encrypted databases\n- ODBC driver\n\n### ⛏ 설치\n1. [H2 공식 홈페이지](https://www.h2database.com/html/main.html)에 접속하여 'All Platforms' 을 설치한다. (Windows 환경인 경우에는 Windows를 설치하면 된다.)\n2. 압축을 해제하고 `Terminal` 을 열어 `h2/bin` 으로 이동한다.\n3. `chmod 755 h2.sh` 명령어로 `h2.sh` 에 대한 권한을 부여한다. (MAC 유저의 경우)\n4. `./h2.sh` 로 실행\n<img src=\"https://images.velog.io/images/bsu1209/post/4694730f-34c9-4d77-991a-4fc493fe188c/%E1%84%89%E1%85%B3%E1%84%8F%E1%85%B3%E1%84%85%E1%85%B5%E1%86%AB%E1%84%89%E1%85%A3%E1%86%BA%202022-01-07%20%E1%84%8B%E1%85%A9%E1%84%92%E1%85%AE%202.11.15.png\" width=\"80%\">\n\n5. \"Browser 기반의 Console application\"을 확인할 수 있다. 경우에 따라 접속이 되지 않는 경우에는 **도메인 주소만 localhost** 로 변경하여 접속한다. (뒤에는 세션키가 포함되어 있어 수정하면 안된다.)\n6. 최초에는 **\"Database File\"** 을 생성해야 한다. 위 화면에서 `연결` 을 누른다.\n<img src=\"https://images.velog.io/images/bsu1209/post/2263829c-7b5e-4cc9-bb30-5963b85760aa/image.png\" width=\"80%\">\n\n7. 이후, `Terminal` 을 켜서, `home` directory에서 `ls -al`로 `test.mv.db` 가 존재하는지 확인한다.\n8.  `test.mv.db` 의 존재를 확인한 이후, 다음의 접근부터는 이처럼 파일로 접근하는 것이 아니라 `JDBC URL:` 에 `jdbc:h2:tcp://localhost/~/test` 을 입력하여 socket으로 접근하도록 한다. \n> 파일로 접근하게 되면 application과 web console이 동시에 접근했을 때 충돌이 발생할 수 있기 때문이다.\n9. 제대로 동작하지 않는 경우에는 `rm test.mv.db` 로 파일을 지우고, `h2.sh` 을 재시작하여 처음부터 수행한다.\n\n### ⛏ Table 생성\n구현했던 `Member` domain과 동일하게 table을 생성한다.\n\n```sql\ncreate table member (\n    id bigint generated by default as identity,\n    name varchar(255),\n    pwd integer,\n    phone varchar(11),\n    primary key (id)\n);\n```\n<img src=\"https://images.velog.io/images/bsu1209/post/7b6bdc4c-9936-4830-b2a5-274710f13945/image.png\" width=\"30%\">\n\n위와 같이 table이 생성된 것을 확인할 수 있다.\n이를 이전에 생성했던 `domain/Member.java` 의 타입과 비교해보면,\n\n```java\nprivate Long id; == (h2)bigint\nprivate String name; == (h2)varchar\nprivate int pwd; == (h2)integer\nprivate String phone; == (h2)varchar\n```\n\n- 여기서 가장 중요한 것은 `id bigint generated by default as identity` 인데, 이는 값이 설정되지 않은 채로 INSERT 되면, H2 DB가 **자동으로 해당 field의 값을 할당**해준다.\n\n이제 DB에 record를 하나 insert해보자.\n\n```sql\ninsert into member(name) values('spring');\ninsert into member(name, pwd, phone) values('spring2', 12345, '01012341234');\n```\n\n결과는 다음과 같다. <img src=\"https://images.velog.io/images/bsu1209/post/337f3f3f-9233-4f19-99f4-ed2078c89805/image.png\" width=\"30%\">\n- `NOT NULL` 특성을 부여하지 않았기에 `null` 값으로 채워진다.\n- 할당하지 않은 `id` 가 순차적으로 증가하는 것을 확인할 수 있다.\n\nDatabase file에 대한 관리를 하기 위해, \nproject folder에 `sql` directory를 하나 생성한다.\n그리고 `sql/ddl.sql` 파일을 생성해 아래와 같이 sql 문들을 저장하여 관리한다.\n<img src=\"https://images.velog.io/images/bsu1209/post/f19c58a6-43f0-4092-a3a1-4d4979a18b55/image.png\" width=\"80%\">\n\n---\n\n## 🔍 순수 JDBC\n구현한 application에서 H2 Database에 접근하는 방법에 대해 알아보도록 한다.\n\n### ⛏ 환경 설정\n`build.gradle` 파일에 **jdbc, h2 db 관련 라이브러리**를 추가한다.\n\n```java\ndependencies {\n\t...\n\timplementation 'org.springframework.boot:spring-boot-starter-jdbc'\n\truntimeOnly 'com.h2database:h2'\n}\n```\n\n- Java는 기본적으로 DB와의 연동을 위해서는 JDBC driver가 필수적이다.\n- DB와의 연동에서, DB가 제공하는 클라이언트가 필요한데, H2가 그 역할을 한다.\n\n추가적으로 DB에 접속하려면, 접속 정보가 필요하다.\n예전에는 개발자가 일일이 정보를 입력해야 했지만, **Spring** 은 경로 정보만을 이용하여 이를 처리해준다.\n\n`src/main/resources/application.properties`\n\n```java\nspring.datasource.url=jdbc:h2:tcp://localhost/~/test\nspring.datasource.driver-class-name=org.h2.Driver\nspring.datasource.username=sa\n```\n\n- `h2.Driver` 에 에러가 뜰텐데, 아까 수정한 `build.gradle` 의 변경사항이 적용되지 않아 그런 것이므로, `Load Gradle Changes` 를 해주면 된다.\n- 그리고 스프링 2.4부터의 변경사항으로, `spring.datasource.username=sa` 를 명시하지 않으면 `org.h2.jdbc.JdbcSQLInvalidAuthorizationSpecException: Wrong user name or password [28000-200]` 이라는 **에러**가 발생한다.\n\n### ⛏ JDBC Repository 구현\n현재, 회원을 저장, 조회하는 역할은 `MemberRepository` 에서 수행하지만,\n구현은 **Memory** 에 하는 방식이기에 `MemoryMemberRepository` 를 사용했었다.\n하지만 이제 H2 DB와 연동하여 구현하기 위해서 새로운 Class를 생성한다.\n\n`repository/JdbcMemberRepository.java`\n\n**DataSource**<br/>\n먼저, DB와 연동하여 사용하기 위해서 `DataSource` 라는 것이 필요하다.\n그리고, 이를 spring으로부터 **주입**받아야 한다. \n- springboot는 우리가 setting한 접속 정보를 가지고 `DataSource` 를 생성한다. 그리고 이를 주입받는 것이다.\n\n```java\nimport javax.sql.DataSource;\n...\n\nprivate final DataSource dataSource;\n\npublic JdbcMemberRepository(DataSource dataSource) {\n    this.dataSource = dataSource;\n}\n```\n\n### Connection\n```java\nprivate Connection getConnection() {\n    return DataSourceUtils.getConnection(dataSource);\n}\n```\n- 위와 같이 Spring을 통해서 `getConnection` 을 수행한다.\n\t\n    - 이렇게 하는 이유는 계속 새로운 `Connection` 이 생성되는 것을 방지하여 트랜잭션에 대한 처리를 수행하기 위해서이다.\n    - release도 동일하게 수행한다.\n\n**save()**<br/>\n```java\n@Override\npublic Member save(Member member) {\n    String sql = \"insert into member(name, pwd, phone) values(?, ?, ?)\";\n    Connection conn = null;\n    PreparedStatement pstmt = null;\n    ResultSet rs = null;\n    try {\n        conn = getConnection();\n        pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);\n        pstmt.setString(1, member.getName());\n        pstmt.setInt(2, member.getPwd());\n        pstmt.setString(3, member.getPhone());\n        pstmt.executeUpdate();\n        rs = pstmt.getGeneratedKeys();\n        if (rs.next()) {\n            member.setId(rs.getLong(1));\n        } else {\n            throw new SQLException(\"id 조회 실패\");\n        }\n        return member;\n    } catch (Exception e) {\n        throw new IllegalStateException(e);\n    } finally {\n        close(conn, pstmt, rs);\n    }\n}\n```\n\n- `String sql` 은 사용할 query의 format을 담고 있다.\n\t\n    - `PreparedStatement` 를 통해, 인자를 query문에 담아 DB에 전달한다.\n- `ResultSet` 은 결과를 받아오는 객체이다.\n- `Statement.RETURN_GENERATED_KEYS` : DB에 insert할 때, `id` 에 key값을 할당해주기 위해 필요한 옵션\n- `pstmt.setString(1, member.getName());` 로 query에 인자를 추가해주고, `pstmt.executeUpdate();` 로 query를 수행한다.\n- `rs = pstmt.getGeneratedKeys();` 는 위에서 설정한 옵션과 함께 사용되어야 한다. 이는 생성한 `Key` 를 반환한다.\n- `rs.next()` 로 `ResultSet` 에 있는 값을 꺼낼 수 있다.\n- `try - catch` 구문을 사용하여 `exception` 에 대한 처리를 해주고, 마지막에는 사용한 자원들 (`Connection`, `PreparedStatement`, `ResultSet`) 에 대한 **release** 를 해야 한다.\n\n**findById(), findByName(), findByPhone()**<br/>\n> 가만히 생각해보니, `findByPwd()` 라는 method가 필요할까? 라는 생각이 들었다.\n비밀번호를 가지고 회원을 조회하는 일은 본 적이 없는 것 같아 폐기처분한다.\n\n조회 기능은 매우 비슷하기 때문에 `findById()` 만을 설명한다.\n\n```java\n@Override\npublic Optional<Member> findById(Long id) {\n    String sql = \"select * from member where id = ?\";\n    Connection conn = null;\n    PreparedStatement pstmt = null;\n    ResultSet rs = null;\n    try {\n        conn = getConnection();\n        pstmt = conn.prepareStatement(sql);\n        pstmt.setLong(1, id);\n        rs = pstmt.executeQuery();\n        if(rs.next()) {\n            Member member = new Member();\n            member.setId(rs.getLong(\"id\"));\n            member.setName(rs.getString(\"name\"));\n            member.setPwd(rs.getInt(\"pwd\"));\n            member.setPhone(rs.getString(\"phone\"));\n            return Optional.of(member);\n        } else {\n            return Optional.empty();\n        }\n    } catch (Exception e) {\n        throw new IllegalStateException(e);\n    } finally {\n        close(conn, pstmt, rs);\n    }\n}\n```\n\n- 동일하게 `Connection` 을 수행하고, query를 날린다.\n- `save()` 와는 다르게 **SELECT** query이므로 `executeQuery()` 를 사용한다.\n- 반환되는 값이 있는 경우, 새로운 `Member` 객체를 생성하여 이를 반환해준다.\n\n**findAll()**<br/>\n`findAll()` 은 통째로 조회하는 것이므로 조건이 있는 `findBy~()` 보다 단순한 구조이다.\n\n```java\n@Override\npublic List<Member> findAll() {\n    String sql = \"select * from member\";\n    Connection conn = null;\n    PreparedStatement pstmt = null;\n    ResultSet rs = null;\n    try {\n        conn = getConnection();\n        pstmt = conn.prepareStatement(sql);\n        rs = pstmt.executeQuery();\n        List<Member> members = new ArrayList<>();\n        while(rs.next()) {\n            Member member = new Member();\n            member.setId(rs.getLong(\"id\"));\n            member.setName(rs.getString(\"name\"));\n            member.setPwd(rs.getInt(\"pwd\"));\n            member.setPhone(rs.getString(\"phone\"));\n            members.add(member);\n        }\n        return members;\n    } catch (Exception e) {\n        throw new IllegalStateException(e);\n    } finally {\n        close(conn, pstmt, rs);\n    }\n}\n```\n\n- `List<Member>` 형태로 반환받기 때문에, `while()` 을 이용하여 결과 List를 반환한다.\n\n**close()**<br/>\n사용한 자원에 대한 release는 **역순** 으로 진행한다.\n\n```java\nprivate void close(Connection conn, PreparedStatement pstmt, ResultSet rs) {\n\n    try {\n        if (rs != null) {\n            rs.close();\n        }\n    } catch (SQLException e) {\n        e.printStackTrace();\n    }\n\n    try {\n        if (pstmt != null) {\n            pstmt.close();\n        }\n    } catch (SQLException e) {\n        e.printStackTrace();\n    }\n\n    try {\n        if (conn != null) {\n            close(conn);\n        }\n    } catch (SQLException e) {\n        e.printStackTrace();\n    }\n}\n\nprivate void close(Connection conn) throws SQLException {\n    DataSourceUtils.releaseConnection(conn, dataSource);\n}\n```\n\n### ⛏ Configuration\n이전에 `MemoryMemberRepository` 로 구현했을 때, `SpringConfig` file에서 스프링 컨테이너에 `MemoryMemberRepository` 를 등록하는 작업을 거쳤다.\n\n이를 방금 생성한 `JdbcMemberRepository` 를 등록하는 것으로 변경한다.\n그리고 `JdbcMemberRepository` 는 `DataSource dataSource` 를 필요로 한다.\n이는 Spring에서 제공해주는데, 다음과 같은 방법이 있다.\n\n`SpringConfig`\n\n```java\nAutowired DataSource dataSource;\n\nor\n\nprivate DataSource dataSource;\n\n@Autowired\npublic SpringConfig(DataSource dataSource) {\n    this.dataSource = dataSource;\n}\n```\n\n- 위 설정을 통해, Spring이 `DataSource dataSource` 에 대한 Bean을 생성해 의존성 주입을 수행해준다.\n\n**`SpringConfig` 만을 변경시킴으로써, 수정된 코드에 대한 의존성을 수정할 수 있다.**\n\n`./h2.sh` 로 H2 DB를 동작시키고, 스프링을 동작시켜 회원 등록 및 목록 조회를 하면, DB와 연동하여 정상적으로 등록, 조회가 이루어지는 것을 확인할 수 있다.\n\n> **Spring을 사용하는 이유**\n- 다형성의 활용: 인터페이스를 두고, 구현체를 바꿔서 사용할 수 있다. 이는 스프링 컨테이너가 DI를 이용해 지원한다. (memoryRepository → JdbcRepository)\n\n아래는 구현 클래스에 대한 설명을 그림으로 표현한 것이다.\n<img src=\"https://images.velog.io/images/bsu1209/post/5e08e10a-9ded-4a7d-a7e5-fe21049d30e1/springboot-Page-3.drawio.png\" width=\"80%\">\n\n아래는 스프링 컨테이너에서 구현 클래스와의 연결을 표현한 그림이다.\n<img src=\"https://images.velog.io/images/bsu1209/post/9b48be9a-7bb1-4cca-bd94-efabe6dc9d13/springboot-Page-2.drawio%20(3).png\" width=\"80%\">\n\n- 이와 같은 구조를 **개방-폐쇄 원칙(OCP, Open-Close-Principle)** 을 따른다고 한다.\n\t\n    - 확장에는 열려있고, 수정(변경)에는 닫혀있다.\n    - 객체지향의 **다형성**이라는 개념을 잘 활용하면, application의 동작 코드를 변경하지 않고도 변경할 수 있다.\n- 위와 같이 **스프링의 DI**를 사용하여 설정(`SpringConfig`)만으로 구현 클래스를 변경할 수 있다.\n\n---\n\n## 🔍 스프링 통합 테스트\n이전에 작성한 `MemoryMemberRepositoryTest` 의 코드들은 스프링과는 관련없이 순수하게 자바 코드만으로 테스트를 수행한 것이다.\n`test/.../MemberServiceTest.java`\n순수한 자바 코드였기에, JVM 안에서 실행되어 빠르게 실행된다.\n\n이제는 DB까지 연결한 **스프링 통합 테스트**를 수행해보도록 한다.\n\n우선 이전의 `MemberServiceTest.java` 를 복사하여`MemberServiceIntegrationTest.java` 를 생성한다.\n```java\npackage hello.hellospring.service;\n\nimport hello.hellospring.domain.Member;\nimport hello.hellospring.repository.MemberRepository;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.test.context.SpringBootTest;\nimport org.springframework.transaction.annotation.Transactional;\n\nimport static org.assertj.core.api.Assertions.assertThat;\nimport static org.junit.jupiter.api.Assertions.assertThrows;\n\n@SpringBootTest\n@Transactional\nclass MemberServiceIntegrationTest {\n\n    @Autowired MemberService memberService;\n    @Autowired MemberRepository memberRepository;\n\n    @Test\n    void 회원가입() {\n        // given\n        Member member = new Member();\n        member.setName(\"spring\");\n\n        // when\n        Long saveId = memberService.join(member);\n\n        // then\n        Member findMember = memberService.findOne(saveId).get();\n        assertThat(member.getName()).isEqualTo(findMember.getName());\n    }\n\n    @Test\n    public void 중복_회원_예외() {\n        // given\n        Member member1 = new Member();\n        member1.setName(\"spring\");\n\n        Member member2 = new Member();\n        member2.setName(\"spring\");\n\n        // when\n        memberService.join(member1);\n        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));\n\n        assertThat(e.getMessage()).isEqualTo(\"이미 존재하는 회원입니다.\");\n\n        // then\n    }\n}\n```\n\n- `@BeforeEach` annotation을 사용하는 method를 삭제한다.\n\t\n    - 이제는 객체를 직접 생성하는 것이 아닌 스프링 컨테이너로부터 받아와야 하기 때문에 생성자를 이용하여 의존성 주입을 수행해야 한다.\n    - 하지만, **Test** 는 개발의 제일 끝단에 있다고 할 수 있으므로, 가장 간단한 방법을 사용한다. (field기반의 `@Autowired` 를 사용)\n- `MemoryMemberRepository` 가 아니라 `MemberRepository` 를 불러온다.\n\t\n    - `SpringConfig` 를 통해 구현체가 올라왔기 때문이다?\n- Test를 수행하는 동안, 이전 Test method의 영향을 없애기 위해 사용했던 `@AfterEach` method를 삭제한다.\n\t\n    - 이는 **`@Transactional`** 의 존재로 필요가 없어졌다.\n    - `@Transactional` 을 주석 처리하고 회원가입 Test를 수행하면, Test가 끝난 이후에도, DB에 테스트 가입한 회원의 정보가 그대로 남아있다.\n    \t- **Test를 반복 수행**하게 되면, **에러**가 뜨게 된다.\n    - 해결하기 위해서는 DB에 연결하여 `select, insert` 등의 query를 날린 후, `rollback` 하여 DB 수정사항을 되돌리는 로직이 필요하다.\n    - `@Transactional` annotationd을 Test case에 달면, Test 실행 전, **Transaction** 을 실행한 후, Test가 끝날 때 **rollback** 을 수행한다. 따라서, DB는 반복 수행에도 문제가 없는 상태가 된다.\n\nTest를 실행하면, console을 확인하여 **Spring** 이 함께 동작하는 것을 확인할 수 있다. (`@SpringBootTest`)\n- `SpringConfig` 에 작성한 내용도 함께 올라오는 것을 확인할 수 있다.\n> Test를 실행할 때, 이미 DB에 저장되어 있는 정보와 겹쳐 에러가 발생하지 않도록 유의한다.\n\n> 그럼 이전에 구현한 `MemberServiceTest` 는 필요가 없는가?\n>> `MemberServiceTest` 는 **\"단위 테스트\"**,\n `MemberServiceIntegrationTest` 는 **\"통합 테스트\"** 라고 한다.\n- 가급적으로, **단위 테스트가 훨씬 좋은 테스트일 확률이 높다.** 컨테이너까지 올려야 하는 테스트인 경우 테스트 설계가 잘못되었을 확률이 높다.\n\n---\n\n## 🔍 스프링 JdbcTemplate\nJDBC API에서의 반복적인 코드를 제거해준다. 하지만 SQL query는 직접 작성해야 한다.\n\n`repository/JdbcTemplateMemberRepository.java`\n```java\npackage hello.hellospring.repository;\n\nimport hello.hellospring.domain.Member;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.jdbc.core.JdbcTemplate;\n\nimport javax.sql.DataSource;\nimport java.util.List;\nimport java.util.Optional;\n\npublic class JdbcTemplateMemberRepository implements MemberRepository {\n\n    private final JdbcTemplate jdbcTemplate;\n\n    // @Autowired 생략 가능\n    public JdbcTemplateMemberRepository(DataSource dataSource) {\n        this.jdbcTemplate = new JdbcTemplate(dataSource);\n    }\n\n    ...\n}\n```\n\n- `JdbcTemplate` 이 존재하므로, 이를 사용한다. 이는 Injection을 받을 수 있는 것이 아니라 `DataSource` 가 필요하다.\n\t\n    > class의 생성자가 딱 1개인 경우, Spring bean으로 등록 시, `@Autowired` 를 생략할 수 있다.\n    \n### ⛏ `RowMapper` method\n```java\nprivate RowMapper<Member> memberRowMapper() {\n    return (rs, rowNum) -> {\n        Member member = new Member();\n        member.setId(rs.getLong(\"id\"));\n        member.setName(rs.getString(\"name\"));\n        member.setPwd(rs.getInt(\"pwd\"));\n        member.setPhone(rs.getString(\"phone\"));\n        return member;\n    };\n}\n```\n\n- 회원 정보 조회의 결과를 받아오기 위해서 `RowMapper` 라는 것이 필요하다.\n\t\n    - `RowMapper` 는 query의 결과를 객체로 받아온다. 이전에는 `ResultSet` 에 결과를 받고, 이를 객체로 생성해서 반환하는 과정을 거쳤지만 `RowMapper` 는 내부적으로 `ResultSet` 을 사용하여 위 과정을 수행한다.\n   \n### ⛏ 회원 정보 조회\n\n```java\n@Override\npublic Optional<Member> findById(Long id) {\n    List<Member> result = jdbcTemplate.query(\"select * from member where id = ?\", memberRowMapper(), id);\n    return result.stream().findAny();\n}\n```\n\n- 입력받은 `id` 값을 `?` 자리에 치환하고, 결과를 `memberRowMapper()` 를 통해 받아온다.\n- 결과의 반환형이 `List<Member>` 이므로 `result` 에 받고, 결과를 `Optional<>` 로 변환하여 반환한다.\n\n### ⛏ 회원 정보 조회 (`findAll`)\n\n```java\n@Override\npublic List<Member> findAll() {\n    return jdbcTemplate.query(\"select * from member\", memberRowMapper());\n}\n```\n\n### ⛏ 회원가입\n\n```java\n@Override\npublic Member save(Member member) {\n    SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate);\n    jdbcInsert.withTableName(\"member\").usingGeneratedKeyColumns(\"id\");\n    Map<String, Object> parameters = new HashMap<>();\n    parameters.put(\"name\", member.getName());\n    parameters.put(\"pwd\", member.getPwd());\n    parameters.put(\"phone\", member.getPhone());\n    Number key = jdbcInsert.executeAndReturnKey(new MapSqlParameterSource(parameters));\n    member.setId(key.longValue());\n    return member;\n}\n```\n\n- `SimpleJdbcInsert` 를 사용하여 query를 짤 필요 없이 구현이 가능하다.\n\t\n    - TableName, PK, 입력값만 있으면 `insert` 는 구현 가능하기에 사용한다.\n- `executeAndReturnKey` 를 이용해 생성한 회원의 `key` 를 받고 이를 저장한 `Member` 객체를 반환한다.\n\n## `SpringConfig`\n이제 구현한 DB 접근 class를 연결하기 위한 설정을 한다.\n\n```java\n@Bean\npublic MemberRepository memberRepository() {\n    //return new JdbcMemberRepository(dataSource);\n    return new JdbcTemplateMemberRepository(dataSource);\n}\n```\n\n이제는 **스프링 통합 테스트**를 구현했기 때문에 Web Application을 실행할 필요 없이 DB만 접속하고 통합 테스트만 수행하면 된다.\n\n---\n\n## 🔍 JPA\n**JdbcTemplate** 을 사용하여 반복적인 코드를 많이 줄인 것은 맞지만, 여전히 SQL query는 개발자가 직접 작성해야 한다.\n\n이번 장에서는 Interface의 일종인 **JPA** 를 사용하여 query 또한 자동으로 처리하도록 한다. 이를 통해\n- SQL과 Data 중심의 설계 → 객체 중심의 설계 (패러다임의 전환)\n- 개발 생산성의 증대\n\n`build.gradle`\n```java\ndependencies {\n    ...\n    //\timplementation 'org.springframework.boot:spring-boot-starter-jdbc'\n    implementation 'org.springframework.boot:spring-boot-starter-data-jpa' \n    runtimeOnly 'com.h2database:h2'\n    testImplementation('org.springframework.boot:spring-boot-starter-test') {\n        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'\n    }\n}\n```\n\n`application.properties`\n\nJPA와 관련된 설정을 추가한다.\n\n```java\nspring.jpa.show-sql=true\nspring.jpa.hibernate.ddl-auto=none\n```\n\n- `show-sql=true` : JPA가 생성하는 sql을 볼 수 있다.\n- `ddl-auto=none` : JPA는 객체를 확인하고 이에 대한 Table을 생성한다. 하지만 이미 Table을 생성했고, 생성한 Table을 사용할 것이므로, 해당 기능을 `none` 설정한다.\n\n> JPA는 자바 표준의 interface이다. 그래서 구현은 여러 vendor들이 수행한다. 여기서는 `hibernate` library를 중점적으로 사용하여 구현한다.\n\n> JPA는 객체와 ORM이라는 기술을 사용한다. Object Relational Mapping, 여기서 Mapping은 annotation을 사용하여 수행한다.\n\nJPA를 사용하기 위해서는 **Entity Mapping** 이 필요하다.\n\n`domain/Member.java`\n```java\nimport javax.persistence.Entity;\nimport javax.persistence.GeneratedValue;\nimport javax.persistence.GenerationType;\nimport javax.persistence.Id;\n\n@Entity\npublic class Member {\n    \n    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)\n    private Long id;\n    ...\n```\n\n- `@Entity` : JPA가 관리할 Entity임을 명시한다.\n- `@Id` : primary key로 지정한다.\n- `@GeneratedValue(strategy = GenerationType.IDENTITY)` : DB에서 고유하게 값을 자동으로 생성한다. 사용자가 insert하지 않는다.\n- 만약 DB에 저장될 column명을 수정하고 싶다면, 아래와 같은 annotation을 생성한다.\n```java\n@Column(name = \"원하는 column명\")\nprivate String name;\n```\n\n이제 repository를 생성한다.\n\n`repository/JpaMemberRepository.java`\n```java\npublic class JpaMemberRepository implements MemberRepository {\n\n    private final EntityManager em;\n\n    public JpaMemberRepository(EntityManager em) {\n        this.em = em;\n    }\n    \n    ...\n```\n\n- `EntityManager` : JPA는 `EntityManager` 를 통해 모든 것이 동작한다. 위에서 추가한 `data-jpa` dependency를 통해 JPA가 자동으로 현재 DB와 연결된 `EntityManager` 를 생성한다. 따라서 이를 **Injection** 받아 사용하면 된다.\n\n### ⛏ save()\n```java\n@Override\npublic Member save(Member member) {\n    em.persist(member);\n    return member;\n}\n```\n\n- `em.persist(member)` : 객체를 저장하기 위한 query를 내부적으로 작성한다.\n\n### ⛏ findById\n```java\n@Override\npublic Optional<Member> findById(Long id) {\n    Member member = em.find(Member.class, id);\n    return Optional.ofNullable(member);\n}\n```\n\n- `em.find(Member.class, id)` : 조회할 Type과 식별자를 전달하여 조회한다.\n- 반환형이 `Optional` 이므로 이에 맞게 반환한다.\n\n### ⛏ findAll\n**JPQL이라는 객체 지향 쿼리를 사용**한다.\n\n```java\n@Override\npublic List<Member> findAll() {\n    return em.createQuery(\"select m from Member m\", Member.class)\n            .getResultList();\n}\n```\n\n- Table을 대상으로 query를 보내는 것이 아닌, 객체(Entity, ex. `Member`)를 대상으로 query를 보내 사용한다. 이러한 query가 SQL로 번역된다.\n- `select` 의 대상이 특정 attribute가 아닌 **Entity 자체**이다.\n\n### ⛏ findByName\n**JPQL이라는 객체 지향 쿼리를 사용**한다.\n\n```java\n@Override\npublic Optional<Member> findByName(String name) {\n    List<Member> result = em.createQuery(\"select m from Member m where m.name = :name\", Member.class)\n            .setParameter(\"name\", name)\n            .getResultList();\n        \n    return result.stream().findAny();\n}\n```\n\n**PK 기반의 query가 아닌 경우에는 JPQL을 작성해야 한다.**\n\nJPA는 모든 데이터의 변경이 트랜잭션 안에서 이뤄져야 한다. 따라서 JPA를 사용하기 위해서는 **항상 Transactional이 존재**해야 한다.\n\n`service/MemberService.java` 에 `@Transactional` 을 추가하는데,\nclass 자체에 해줘도 되고, 회원 가입 시에만 동시성 제어가 필요하므로 `Long join()` method에만 추가해줘도 된다.\n\n이제 `SpringConfig` 에 설정을 추가해줘야 한다.\n```java\nprivate EntityManager em;\n    \n@Autowired\npublic SpringConfig(EntityManager em) {this.em = em;}\n\n@Bean\npublic MemberRepository memberRepository() {\n    //return new JdbcMemberRepository(dataSource);\n    //return new JdbcTemplateMemberRepository(dataSource);\n    return new JpaMemberRepository(em);\n}\n```\n\n- `JpaMemberRepository` 는 `EntityManager` 만을 필요로 하기에, 기존의 `DataSource` 와 생성자는 삭제한다.\n\n이제 이전에 구현했던 **스프링 통합 Test** 로 정상 동작하는지 확인한다.\n\n자꾸 에러가 난다...\n어딘가 수정이 필요하다.\n\n```bash\nHibernate: select member0_.id as id1_0_, member0_.name as name2_0_, member0_.phone as phone3_0_, member0_.pwd as pwd4_0_ from member member0_ where member0_.name=?\nHibernate: select member0_.id as id1_0_, member0_.name as name2_0_, member0_.phone as phone3_0_, member0_.pwd as pwd4_0_ from member member0_ where member0_.name=?\nHibernate: insert into member (id, name, phone, pwd) values (null, ?, ?, ?)\n2022-01-11 15:51:29.818  WARN 2434 --- [           main] o.h.engine.jdbc.spi.SqlExceptionHelper   : SQL Error: 23502, SQLState: 23502\n2022-01-11 15:51:29.818 ERROR 2434 --- [           main] o.h.engine.jdbc.spi.SqlExceptionHelper   : NULL not allowed for column \"ID\"; SQL statement:\n```\n\nTest method에 `@Commit` annotation을 사용하면, `@Transactional` 이 있어도 rollback되지 않고 DB에 반영된다.\n\n> ✏️ **ERROR 수정**\n> \n> https://www.inflearn.com/questions/389513 해당 링크를 보면서,\n> - h2 DB를 낮은 버전으로 새로 받고, 새 db를 만들어서 table을 생성\n> - 이후 실행했을 때 방금 생성한 `Member` table을 못 찾는다는 에러가 떠서 `application.properties` 에서 `spring.jpa.hibernate.ddl-auto = create` 로 수정\n> - 에러 fix 완료 ...\n\n---\n\n## 🔍 스프링 데이터 JPA\n스프링 데이터 JPA를 이용하면, 이전에 구현한 **Repository에 구현체 없이도 Interface만으로 개발이 가능**하다. (**CRUD** 기능도 제공한다!)\n\n> JPA를 편리하게 사용하도록 해주는 기술이므로 JPA에 대한 이해와 학습이 수반되어야 한다!\n\n`repository/SpringDataJpaRepository.java` (interface!)\n\n```java\npackage hello.hellospring.repository;\n\nimport hello.hellospring.domain.Member;\nimport org.springframework.data.jpa.repository.JpaRepository;\n\npublic interface SpringDataJpaMemberRepository extends JpaRepository<Member, Long>, MemberRepository {\n    @Override\n    Optional<Member> findByName(String name);\n}\n```\n\n- Interface가 Interface를 상속받을 때는 **`extends`** 를 사용하고 **다중 상속**이 가능하다.\n- `JpaRepository<Member, Long>`\n\t\n    - `Member` : 사용하는 Entity\n    - `Long` : Entity의 식별자 (PK, `id`)\n- 스프링 데이터 JPA는 `JpaRepository` 를 상속받아 사용하는 interface를 발견하면, `SpringDataJpaRepository` 가 알아서 구현체를 만들어 스프링 빈에 등록하도록 한다. 그래서 이를 `SpringConfig` 를 통해 가져다 사용하면 된다.\n\n`SpringConfig`\n\n```java\nprivate final MemberRepository memberRepository;\n\npublic SpringConfig(MemberRepository memberRepository) {\n    this.memberRepository = memberRepository;\n}\n\n@Bean\npublic MemberService memberService() {\n    return new MemberService(memberRepository);\n}\n\n//    @Bean\n//    public MemberRepository memberRepository() {\n//        //return new JdbcMemberRepository(dataSource);\n//        //return new JdbcTemplateMemberRepository(dataSource);\n//        //return new JpaMemberRepository(em);\n//    }\n```\n\n- 이로서 스프링 데이터 JPA가 만든 구현체가 등록된다.\n- `MemberService` 에 의존 관계를 설정한다.\n\n`SpringConfig` 생성자로 인해 `MemberRepository` 를 스프링 컨테이너에서 탐색하지만, 사용자가 등록한 것은 없다.\n- 그러나 위에서 생성한 **`JpaRepository` 를 상속받는 interface**를 통해 스프링 데이터 JPA가 구현체를 생성해 스프링 빈으로 등록한다.\n- 이렇게 등록된 `MemberRepository` 를 `MemberService` 에도 그대로 전달해 사용한다.\n\n### ⛏ 원리\n`JpaRepository` 를 까보면,\n<img src=\"https://images.velog.io/images/bsu1209/post/48a56b56-bfc9-4b15-8563-8bf0f9cf72cf/image.png\" width=\"80%\">\n\n- 기본적인 method들이 제공되는 것을 확인할 수 있다.\n- 그리고 `JpaRepository` 가 상속받는 상위 Repository들을 확인해보면, `PagingAndSortingRepository` (Paging 기능), `CrudRepository` 가 있다.\n\t\n    - 즉, **기본적인 단순 조회, CRUD가 이렇게 제공된다는 것을 확인할 수 있다.**\n    - 그래서 이들을 가져다 쓰면 되는 것이다!\n    - 하지만, 이와 같은 공통적으로 제공하는 기능이 아닌 자체적인 기능을 구현하기 위해서는 `Optional<Member> findByName(String name);` 과 같이 interface에 기술해야 한다.\n    \t- 규칙: `findBy{ }And{ }(String { }, Long { })` 과 같은 형태여야 한다.\n\n> 실무에서는 **JPA** 와 **스프링 데이터 JPA** 를 기본으로 사용하고, 복잡한 동적 query는 **Querydsl** 이라는 라이브러리를 사용한다. 이는 자바 코드로 안전하게 query를 작성할 수 있고, 동적 query 또한 편리하게 작성하도록 돕는다. \n\n---\n\n## 📌 중요한 개념\n개방-폐쇄 원칙, 다형성, @Transactional, JPA\n\n## 📕 참고\n- [H2 database 공식문서](https://www.h2database.com/html/main.html)\n- [RowMapper](https://velog.io/@seculoper235/RowMapper%EC%97%90-%EB%8C%80%ED%95%B4)\n- [스프링 입문-코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)"},{"excerpt":"스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 들으며 정리하는 POST입니다. 전체적인 흐름 Spring Project 생성 Spring boot로 웹 서버 실행 회원 도메인 개발 웹 MVC 개발 DB 연동 - JDBC, JPA, Spring data JPA 테스트 케이스 작성 🔍 회원 웹 기능 - 홈 화면 추가 이전 시간에 …","fields":{"slug":"/[스프링입문]5/"},"frontmatter":{"date":"January 06, 2022","title":"📺 5. 웹 MVC 개발","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)을 들으며 정리하는 POST입니다.</strong></em>\n\n> **전체적인 흐름**\n> - Spring Project 생성\n> - Spring boot로 웹 서버 실행\n> - 회원 도메인 개발\n> - 웹 MVC 개발\n> - DB 연동 - JDBC, JPA, Spring data JPA\n> - 테스트 케이스 작성\n\n## 🔍 회원 웹 기능 - 홈 화면 추가\n이전 시간에 구현한 `MemberController` 를 이용하여 회원을 등록하고 조회하는 화면을 구성한다.\n\n### ⛏ `controller/HomeController` 생성\n`controller/HomeController.java`\n\n```java\n@Controller\npublic class HomeController {\n\n    @GetMapping(\"/\")\n    public String home() {\n        return \"home\";\n    }\n}\n```\n\n- `@GetMapping(\"/\")` 으로 맨 처음 도메인으로 들어오게 되면, `String home()` 이 호출되도록 매핑한다.\n- 그리고 `home()` 은 `return \"home\"` 으로 `home.html` 을 호출한다.\n\n`templates/home.html`\n```html\n<!DOCTYPE HTML>\n<html xmlns:th=\"http://www.thymeleaf.org\" lang=\"ko\">\n<body>\n\n<div class=\"container\">\n    <div>\n        <h1>Hello Spring</h1> <p>회원 기능</p>\n        <p>\n            <a href=\"/members/new\">회원 가입</a> <a href=\"/members\">회원 목록</a>\n        </p>\n    </div>\n</div>\n\n</body>\n</html>\n```\n<img src=\"https://images.velog.io/images/bsu1209/post/26e98787-9f8c-4710-9bc9-2f2ddc22b796/image.png\" width=\"80%\">\n\n- 간단하게, 회원 가입을 누르면 `/members/new` 로 이동하고, 회원 목록을 누르면 `/members` 로 이동하도록 구현했다.\n- 실행을 하면, `static/index.html` 가 아닌 `templates/home.html` 이 보여지는데, 이는 이전에 다룬 [정적 컨텐츠](https://velog.io/@bsu1209/Spring-%EB%91%90%EB%B2%88%EC%A7%B8.-%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9B%B9-%EA%B0%9C%EB%B0%9C-%EA%B8%B0%EC%B4%88#spring-boot%EB%8A%94-%EC%A0%95%EC%A0%81-%EC%BB%A8%ED%85%90%EC%B8%A0-%EA%B8%B0%EB%8A%A5-%EC%9E%90%EB%8F%99-%EC%A0%9C%EA%B3%B5) 부분에서, 스프링이 내장 톰캣 서버를 거쳐, 스프링 컨테이너에서 먼저 관련 **Controller**를 찾기 때문이다.\n\n---\n\n## 🔍 회원 웹 기능 - 등록\n`controller/MemberController.java`\n```java\n@GetMapping(\"/members/new\")\npublic String createForm() {\n    return \"members/createMemberForm\";\n}\n```\n\n- `home.html` 에서 회원 가입 버튼을 누르면 `/members/new` 로 이동한다.\n- 해당 url로 이동되었을 때, `/members/createMemberForm.html` 을 전달하기 위해서 다음과 같은 Mapping을 수행한다.\n\n`templates/members/createMemberForm.html`\n```html\n<!DOCTYPE html>\n<html xmlns:th=\"http://www.thymeleaf.org\" lang=\"ko\">\n<head>\n    <meta charset=\"UTF-8\">\n    <title>Title</title>\n</head>\n<body>\n  <div class=\"container\">\n    <form action=\"/members/new\" method=\"post\">\n      <div class=\"form-group\">\n        <label for=\"name\">이름</label>\n        <input type=\"text\" id=\"name\" name=\"name\" placeholder=\"이름을 입력하세요\">\n        <label for=\"name\">비밀번호</label>\n        <input type=\"password\" id=\"pwd\" name=\"pwd\" placeholder=\"비밀번호를 입력하세요\">\n        <label for=\"name\">전화번호</label>\n        <input type=\"text\" id=\"phone\" name=\"phone\" placeholder=\"전화번호를 입력하세요\">\n      </div>\n      <button type=\"submit\">등록</button> </form>\n  </div>\n</body>\n</html>\n```\n\n<img src=\"https://images.velog.io/images/bsu1209/post/e52623f1-62f3-49f2-867b-51b21f9960ad/image.png\" width=\"80%\">\n\n- `form` 태그를 이용하여 `input` 에 이름을 입력하고, `등록` 버튼을 누르면 `name = name`, `value` 는 입력한 값으로 담겨 서버로 `post` 된다. (`name` 은 서버에서 값을 받을 때 **KEY**가 된다.)\n- 아직은 `/members/new` 에서 이를 처리하지 않아 에러가 뜬다.\n\n`controller/MemberForm.java`\n```java\npackage hello.hellospring.controller;\n\npublic class MemberForm {\n    private String name;\n    private int pwd;\n    private String phone;\n\n    public String getName() {\n        return name;\n    }\n\n    public void setName(String name) {\n        this.name = name;\n    }\n\n    public int getPwd() {\n        return pwd;\n    }\n\n    public void setPwd(int pwd) {\n        this.pwd = pwd;\n    }\n\n    public String getPhone() {\n        return phone;\n    }\n\n    public void setPhone(String phone) {\n        this.phone = phone;\n    }\n}\n```\n\n- `private String name` 과 `templates/members/createMemberForm.html` 에서의 `name=name` 이 매칭되어 값이 저장될 것이다.\n- `pwd`, `phone` 도 같은 방식으로 저장된다.\n\n`controller/MemberController.java`\n```java\n@PostMapping(\"/members/new\")\npublic String create(MemberForm form) {\n    Member member = new Member();\n    member.setName(form.getName());\n    member.setPwd(form.getPwd());\n    member.setPhone(form.getPhone());\n        \n    memberService.join(member);\n        \n    return \"redirect:/\";\n}\n```\n\n- 이전과는 다르게 `@PostMapping` 으로 `/members/new` 로 요청된 Post에 대한 처리를 수행한다.\n- 새로운 `Member` 객체를 생성하고, 이 객체의 이름을 post 요청의 name으로 지정하기 위해 `form.getName()` 으로 `setName` 한다. (`pwd`, `phone` 도 동일)\n- 그리고 이전에 구현한 `join(member)` 으로 등록한다.\n- 마지막으로 회원 등록이 된 이후에는 홈 화면으로 돌려보내기 위해 `return redirect:/` 해준다.\n\n실행해서 이름을 입력하고 등록하면, 정상적으로 홈화면으로 돌아오는 것을 확인할 수 있다.\n\n### ⛏ 흐름\n1. `HomeController` 에서 `home.html` 을 뿌려줌\n2. `home.html` 에서 **회원 가입 버튼**을 클릭, `/members/new` 로 이동\n3. `MemberController` 에서 `/members/new` 로 **GET** 요청이 들어오면, `members/createMemberForm.html` 을 뿌려주도록 지정\n4. `createMember.html` 에서 `form` 태그로 이름을 입력받고, 등록 버튼을 클릭하여 `/members/new` 로 **POST** 요청\n5. `MemberController` 에서 `/members/new` 로 들어온 **POST** 요청을 받아 회원 등록을 처리하고, `/` 으로 **redirect** 수행\n\n---\n\n## 🔍 회원 웹 기능 - 조회\n위에서 구현한 등록이 잘 되었는지 확인하기 위해 조회 기능을 구현한다.\n\n`MemberController.java`\n```java\n@GetMapping(\"/members\")\npublic String list(Model model) {\n    List<Member> members = memberService.findMembers();\n    model.addAttribute(\"members\", members);\n    return \"members/memberList\";\n}\n```\n\n- `home.html` 에서, 회원 목록 버튼을 누르면 `/members` 로 이동한다.\n- 따라서, controller에서 `/members` 에 대한 **GET** mapping이 필요하다.\n- `memberService.findMembers()` 로 회원 목록을 `List<>` 형태로 받아온다.\n- 받아온 `members` 를 `model` 의 `attribute` 로 추가하고 `members/memberList.html` 로 전달한다.\n\n`members/memberList.html`\n```html\n<!DOCTYPE HTML>\n<html xmlns:th=\"http://www.thymeleaf.org\" lang=\"ko\">\n<body>\n<div class=\"container\">\n    <div>\n        <table>\n            <thead>\n                <tr>\n                    <th>#</th>\n                    <th>이름</th>\n                    <th>비밀번호</th>\n                    <th>전화번호</th>\n                </tr>\n            </thead>\n            <tbody>\n            <tr th:each=\"member : ${members}\">\n                <td th:text=\"${member.id}\"></td>\n                <td th:text=\"${member.name}\"></td>\n                <td th:text=\"${member.pwd}\"></td>\n                <td th:text=\"${member.phone}\"></td>\n            </tr>\n            </tbody>\n        </table>\n    </div>\n</div>\n</body>\n</html>\n```\n\n<img src=\"https://images.velog.io/images/bsu1209/post/e52623f1-62f3-49f2-867b-51b21f9960ad/image.png\" width=\"80%\">\n\n위와 같이 정보를 입력하여 등록한다.\n\n회원 목록을 클릭하면, 아래와 같이 등록된 회원 정보를 확인할 수 있다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/af8f8496-5bd7-4d8e-984a-808f04bedfc3/image.png\" width=\"80%\">\n\n페이지 소스 보기를 클릭하면\n\n<img src=\"https://images.velog.io/images/bsu1209/post/28657fa6-e067-4421-8bc5-aeedc3aba4a5/image.png\" width=\"50%\">\n\n- `${members}` 는 attribute를 추가했던 `model` 에서부터 값을 가져온다.\n- `th:each=\"member: ${members}\"` 로 loop를 돌면서 `List<Member> members` 의 값을 순차적으로 읽는다.\n- 그리고 `th:text=\"${member.id}\"` 에서, `id` 는 `domain/Member` 에서의 `id` 값을 의미하는데, `private Long id` 이므로, 외부에서는 접근이 불가능하다. 따라서, **`public` 한 `getId()` 에 접근**하여 값을 가져온다.\n\n> **Property 접근 방식** = Getter & Setter 접근 방식\n\n**메모리 Repository를 사용하기 때문에 서버를 재가동하면, 당연히 RESET된다.**\n따라서, file이나 DB에 물리적으로 저장을 해줘야 한다.\n\n---\n\n## 📕 참고\n- [스프링 입문-코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)"},{"excerpt":"⌘ 좋은 코드 ? 좋은 코드라고 하면 과연 어떤 게 좋은 것일까 ? 읽기 쉬운 코드 ? 중복이 없는 코드 ? 테스트가 용이한 코드 ? 읽기 쉬운 코드 읽기 쉬우려면, 작성자에게 익숙한 언어를 사용하면 된다.\n그리고 한국어로 적힌 주석도 적절하게 달아주면 잘 읽히지 않을까. 하지만 주석은 관리가 어렵다는 단점이 있다. 주석은 메타데이터이기에 내용과 함수의 …","fields":{"slug":"/[면접]좋은코드/"},"frontmatter":{"date":"January 05, 2022","title":"💬 좋은 코드","tags":["개발상식"]},"rawMarkdownBody":"\n### ⌘ 좋은 코드 ?\n좋은 코드라고 하면 과연 어떤 게 좋은 것일까 ?\n- 읽기 쉬운 코드 ?\n- 중복이 없는 코드 ?\n- 테스트가 용이한 코드 ?\n\n#### 읽기 쉬운 코드\n읽기 쉬우려면, 작성자에게 익숙한 언어를 사용하면 된다.\n그리고 한국어로 적힌 주석도 적절하게 달아주면 잘 읽히지 않을까.\n\n하지만\n\n##### 주석은 **관리가 어렵다**는 단점이 있다.\n- 주석은 메타데이터이기에 내용과 함수의 실제 동작에 대한 보장이 어렵다.\n- 수시로 발생하는 수정사항에 대해 주석이 동기화되지 않으면, 오히려 더 큰 혼란을 야기할 수 있다.\n\n##### '읽기 쉽다' 라는 말 자체의 모호성 ?\n읽기 쉽다는 것의 기준은 사람마다 너무 다를 것이다. \n변수명 또는 함수명에 대한 네이밍은 사람마다 매우 다르기에, 각자의 배경지식 수준에 따라 기준이 모호하다.\n\n또한, 코드를 작성하는 시점에는 이해도가 100%이지만, 이는 점점 떨어지기 때문에 아무리 코드 작성에 노력을 가해도 한계는 존재할 수밖에 없다.\n\n#### 중복이 없는 코드\n동일한 로직을 수행하는 코드가 줄줄 작성되어 있다면, 대부분은 이를 추출하여 함수화하기를 원할 것이다. (또는 반복문?)\n왜냐하면, 이러한 동일 코드가 여러 군데 널브러져 있는 것은 \"불편하다\"고 느껴지기 때문이다.\n\n이렇게 추출한 코드는 시간이 지나 조금 다른 역할을 수행하기 위해 수정되어져야 할 수 있다.\n이때, 추출되었던 코드를 다시 합치거나 수정해야 하는데 비용이 발생하게 된다.\n\n#### 테스트가 용이한 코드\n테스트는 매우 중요한 역할을 한다. \n작성한 코드에 대한 확실한 증거가 될 수 있다.\n\n하지만 테스트가 용이해야 좋은 코드일까?\n어떻게 하면 테스트가 용이한 코드를 작성할 수 있을까?\n\n---\n\n### ⌘ 좋지 않은 코드가 생산되는 이유 ?\n모두들 좋은 코드를 생성하고 싶지만, 좋지 않은 코드를 생산하는 결과를 맞이하기도 한다.\n그럼 어쩌다가 코드가 좋지 못한 방향으로 생산되게 될까?\n\n#### 우리가 마주하는 상황\n새로운 프로젝트에 대한 개발을 진행하기도 하고,\n이미 존재하는 프로젝트에 대한 리팩토링을 진행하기도 한다.\n\n##### 쓰이지 않는 코드\n여러 번의 수정을 거쳐, 결국엔 쓰이지 않게 된 코드가 있을 것이다.\n이러한 코드의 호출범위에 대한 확신이 없다면, 다른 코드들에 대한 위험요소가 될 수 있다.\n\n**\"깨진 유리창\"** 이라는 표현이 아주 좋은 것 같다. <a href=\"#help\">참고에서 가져온 표현</a>\n\n###### 거리\n코드가 동작하는 곳과 코드가 선언된 곳의 물리적인 거리가 멀면, 파악이 어려워진다.\n선언한 코드의 동작범위를 정확하게 제어할 수 있다면, 이러한 불안감은 해소될 수 있다.\n\n###### 순수하지 않은 함수\n함수의 외부의 특정 값을 기반으로 동작하는 함수는, (외부의 특정 값에 의존하는 함수) 그 **side effect** 를 제어하는 것이 어렵다.\n\n함수의 입출력만으로 함수 내부를 수정할 수 없다면, 순수하지 않은 함수라고 한다.\n\n##### 급하게 수정한 코드\n추가적인 로직을 수행하기 위해, 사용하는 곳에서 수정이 이뤄져야 하는 경우를 종종 볼 수 있다. 이런 경우, side effect가 발생하는 것을 피하고자, 함수에 입력을 추가하거나, 옵션을 변경시켜 당장은 정상적으로 동작하는 것처럼 보이게 해결할 수는 있다.\n\n하지만 이러한 **응급처치**를 여러 번 거친 함수는, 쉽게 알아볼 수 없는 코드로 변하게 된다.\n\n여기서, **기술부채** 라는 표현이 등장한다. <a href=\"#help\">참고에서 가져온 표현</a>\n\n---\n\n### ⌘ 좋지 않은 코드 줄이기\n\"좋은 코드\" 를 정의하는 것은 어렵다.\n그렇다면 반대로, 위에서 다룬 좋지 않은 코드를 줄이는 방법을 택한다.\n\n#### 추출, 추상화\n어원을 살펴보면, 둘 다 -tract(끌어내기)과 결합된 합성어이다. 그렇다면 ex-, ab- 과 결합되어 어떻게 다를까?\n\n##### 추출\nex- 는 '밖으로' 라는 의미를 가진다. 중요한 부분과 관련된 개념들을 끌어내는 것이다.\n\n##### 추상화\nab- 는 '형상적인 모습과는 먼 개념' 이라는 의미를 가진다. 즉, 실체가 없는 추상적인 개념들을 끌어내 자신만의 방식으로 정리한 것이다.\n\n#### 의존성을 드러내기 위한 추상화\n우리가 코드를 추출하는 이유는 재사용의 용이성, 너무 커지는 파일이라고 할 수 있다.\n단순히 중복된 코드 덩어리(chunk)에 대해 추출하면 재사용이 어려워진다. 오히려 함수 간의 의존 관계를 파악하기 위해 추가 비용이 발생하므로, 이는 잘못 추출한 것이다.\n\n함수를 분리할 때는 **함수의 역할을 인지**하고 **하나의 역할만 하도록 정의**해야 한다. 즉 **의존성을 드러내기 위함**이 추출의 목적이 되어야 한다.\n\n한 파일에 여러 로직이 얽혀있을 때 각 코드 조각 중 **서로 의존 관계에 있는 것들을 추출**하여 추상화가 된 함수가 하나의 목적(역할)만을 갖도록 해야 한다.\n\n#### 삭제하기 쉬운 코드와 어려운 코드의 분리\n비즈니스 요구사항을 맞추다보면 어쩔 수 없이 복잡한 코드가 생산될 수 밖에 없다.\n사용하는 라이브러리의 문제일 수도 있고, 여러 브라우저에 대응하기 위해 생산된 코드일 수도 있다.\n\n이러한 코드들은 제 3자의 입장에서는 섣불리 어찌할 수 없기에, 별도로 분리해야 한다. 어렵다면, 제대로 관리, 통제할 수 있도록 격리하여야 한다.\n이 때, 주석과 함께 격리하여 관리하도록 한다.\n\n#### 일관성 있는 코드\n최소한의 코드 가독성을 보장하기 위해서는 개발하는 코드의 일관성을 유지하는 것이다. 합의된 규칙을 사용하여 개개인에게 동일하게 적용되도록 한다.\n\n일관성이 지켜진다면, 코드에 대한 예상도 가능하다. 특정 코드가 어디에 위치될 지 예측이 가능하다는 의미이다.\n\n##### NAMING\n변수의 Naming 뿐 아니라 함수의 Naming에도 합의된 규칙이 존재하면 일관성을 유지할 수 있다.\n\n```javascript\n// Case 1.\n// prefix: handle\n// target: button\n// action: click\nconst handleButtonClick = () => {}\n\n// Case 2.\n// prefix: on\n// action: click\n// target: button\nconst onClickButton = () => {}\n```\n위 예시처럼, `prefix` , `target` , `action` 이 일관된 규칙으로 Naming을 수행하여 함수의 파악을 도울 수 있다.\n\n##### DIRECTORY\n디렉터리는 코드를 어디로 분리할지와 관련이 있다.\n일관된 디렉터리 구조는 전체 구조를 파악하고 코드의 역할을 이해하는데 큰 도움이 된다.\n\n디렉터리 구조는 크게 **역할에 따라**, **페이지(도메인)에 따라** 분리할 수 있다.\n애플리케이션이 커지고 복잡해지면,\n- 전자의 경우, 코드가 정의된 곳과 사용되는 곳이 멀어지는 문제점이 발생한다. 이는 위에서 다룬 거리에 대한 문제로 코드 제어를 어렵게 만들 수 있다.\n- 후자는 Featured Based라고 할 수 있는데 이러한 구조로 거리 문제를 해결할 수 있다. 애플리케이션 전반에서 공통으로 사용되는 것들만 Top Level의 `@shared` 디렉터리에서 관리하고 나머지는 응집도 높게 각각의 디렉터리에서 관리한다.\n\n#### 확장성 있는 코드\n확장성이 없는 코드의 경우, 수정사항에 대한 많은 변경을 요구하며, 자연히 생산성이 떨어지는 요소가 된다. 확장성의 보장을 위해, 기존의 HTML HTML element가 받을 수 있는 attribute를 모두 수용할 수 있도록 구현해야 한다.\n\n---\n\n### 💡 정리\n좋은 코드라는 정의의 답은 없는 것 같다.\n아마 개발자라는 직업을 가지고 사는 이상 평생의 숙제가 아닐까 싶다.\n그래서 좋지 않은 코드를 최대한 만들지 않도록 하는 것이 곧 좋은 코드를 만들어내는 방법이 아닐까 생각한다.\n\n### 🚩 참고<span id=\"help\"></span>\n[좋은 코드](https://jbee.io/etc/what-is-good-code/#%EC%9D%BD%EA%B8%B0-%EC%89%AC%EC%9A%B4-%EC%BD%94%EB%93%9C%EA%B0%80-%EC%A2%8B%EC%9D%80-%EC%BD%94%EB%93%9C) 를 **많이 참고**하여 제 생각을 덧붙여봤습니다."},{"excerpt":"스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 들으며 정리하는 POST입니다. 전체적인 흐름 Spring Project 생성 Spring boot로 웹 서버 실행 회원 도메인 개발 웹 MVC 개발 DB 연동 - JDBC, JPA, Spring data JPA 테스트 케이스 작성 스프링 빈을 등록하는 방법 컴포넌트 스캔과 자동 …","fields":{"slug":"/[스프링입문]4/"},"frontmatter":{"date":"January 05, 2022","title":"📺 4. 스프링 빈과 의존관계","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)을 들으며 정리하는 POST입니다.</strong></em>\n\n> **전체적인 흐름**\n> - Spring Project 생성\n> - Spring boot로 웹 서버 실행\n> - 회원 도메인 개발\n> - 웹 MVC 개발\n> - DB 연동 - JDBC, JPA, Spring data JPA\n> - 테스트 케이스 작성\n\n> **스프링 빈을 등록하는 방법**\n> 1. 컴포넌트 스캔과 자동 의존관계 설정\n> 2. 자바 코드를 이용한 직접 등록\n\n## 🔍 컴포넌트 스캔과 자동 의존관계 설정\n이전 시간까지 생성한 Member가 서비스를 이용하기 위해서는 Service, Controller 간 **의존성이 필요**하다.\n\n### ⛏ `MemberController` 생성\n`controller/MemberController`\n\n```java\nimport org.springframework.stereotype.Controller;\n\n@Controller\npublic class MemberController {\n    \n}\n```\n\n- 이렇게 `@Controller` 를 사용해 아무 코드가 없는 controller를 생성하게 되면, 스프링 컨테이너에 `MemberController` 라는 객체가 생성되어 관리된다.\n\n**= Spring Bean이 관리된다고 표현**, [이곳](https://velog.io/@bsu1209/Spring-%EB%91%90%EB%B2%88%EC%A7%B8.-%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9B%B9-%EA%B0%9C%EB%B0%9C-%EA%B8%B0%EC%B4%88#%ED%85%9C%ED%94%8C%EB%A6%BF-%EC%97%94%EC%A7%84%EC%9D%B4%EB%9E%80)에서 스프링 컨테이너의 구조를 확인할 수 있다.\n\n```java\nprivate final MemberService memberService = new MemberService();\n```\n- Controller에서, `new` 를 이용하여 객체를 생성해 사용할 수도 있지만, 스프링이 관리하기 때문에 컨테이너에 등록하고 이로부터 받아서 사용하도록 바꿔야 한다.\n    - **다른 code에서도 동일 서비스 객체를 여러 번 생성하여 사용하는 것은 불필요**하기 때문이다.\n\n```java\n@Autowired\npublic MemberController(MemberService memberService) {\n    this.memberService = memberService;\n}\n```\n\n- 생성자를 이용하여 스프링 컨테이너에 연결한다.\n\n이때, `@Autowired` 를 이용하는데, 이는 호출된 생성자의 파라미터와 스프링 컨테이너를 연결시켜준다. 위의 예제에서는 스프링 컨테이너에 있는 `MemberService` 와 연결을 수행한다.\n\n실행을 하게 되면\n```shell\nParameter 0 of constructor in hello.hellospring.controller.MemberController required a bean of type 'hello.hellospring.service.MemberService' that could not be found.\n```\n\n위와 같이 **`MemberService` 를 찾을 수 없다는 에러**가 발생한다.\n\n이러한 이유는, 이전에 작성한 **`MemberService` 는 순수한 Java 코드이므로, 스프링이 이를 인식할 방법이 없다.**\n\n```java\n@Service\npublic class MemberService\n```\n\n따라서 스프링 컨테이너가 해당 Service를 인식하고 등록할 수 있도록 **`@Service` annotation**을 사용한다.\n\n또한 전체적으로 보았을때, \nController class - 외부 요청을 받음 - `@Controller`, \nTest class - `@SpringBootTest`, \nRepository class - Data 저장 - `@Repository`, \nService class - 비즈니스 로직 생성 - `@Service` \n\n다음과 같이 각 annotation을 사용하여 스프링이 동작할 때, 컨테이너에 등록하는 것을 확인할 수 있다.\n\n> **정형화된 패턴!**\n\n**의존 관계 주입 (Dependency Injection)**\n: Controller 생성자에 `@Autowired` 를 사용해 연결을 수행\n- controller가 생성될 때, 스프링 빈에 있는 객체를 가져다 연결에 사용\n  = **Dependency Injection(의존성 주입)**\n\n`MemberService.java`\n\n```java\n@Autowired\npublic MemberService(MemberRepository memberRepository) {\n    this.memberRepository = memberRepository;\n}\n```\n\n- `MemberService` 또한 `MemberRepository` 를 사용하는 `@Service` 이므로, `@Autowired` annotation을 이용한다.\n- 이를 통해 스프링 컨테이너로부터 `MemberRepository` 를 주입받는다.\n\n**컴포넌트 스캔인 이유**<br/>\n`@Component` 를 이용하여 의존 관계를 명시하고 등록하는 방식이다.\n하지만 우리가 작성한 class들의 Annotation을 보면, class에 대해 `@Service` , `@Controller` , `@Repository` 등을 사용한다.\n\n그럼 왜 `@Service` 와 같이 `@Component` 라고 명시하지 않아도 사용이 가능할까 ?\n- `@Service` 에 `command + click` 해보면, 아래와 같이 `@Component` 가 명시되어 있는 것을 확인할 수 있다.\n\n```java\n@Target({ElementType.TYPE})\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\n@Component\npublic @interface Service {\n    /**\n    * The value may indicate a suggestion for a logical component name,\n    * to be turned into a Spring bean in case of an autodetected component.\n    * @return the suggested component name, if any (or empty String otherwise)\n    */\n    @AliasFor(annotation = Component.class)\n    String value() default \"\";\n    \n}\n```\n\n아래는 위에서 설명한 **Controller**, **Service**, **Repository** 를 포함하는 스프링 컨테이너의 구조를 간략하게 표현했다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/3301dcf1-f60e-4e23-96e7-df3c0776d454/springboot-Page-2.drawio%20(2).png\" width=\"80%\">\n\n이렇게 `@Component` annotation이 사용된 경우, 스프링이 동작할 때 이들을 모두 **객체** 로 생성하여 **스프링 컨테이너에 자동 등록**된다. (=스프링 빈으로 자동 등록)\n- 위 예시에서는 `helloController` , `memberService` , `memberRepository` 가 객체로 생성되어 등록된다.\n- 그리고, `@Autowired` annotation은 **등록된 객체간의 연관관계**를 의미한다.\n\n> **그럼 아무 class에서 Annotation을 명시하면 스프링 컨테이너에 자동 등록될까 ?**\n> 정답은 기본적으로는 우리가 실행하는 `HelloSpringApplication` 의 `package` 의 위치에 따라 결정된다.\n> - 해당 package와 동일하거나 하위 package에 포함되어 있는 경우, 스프링이 모두 찾아 스프링 빈으로 컴포넌트 스캔을 수행한다.\n\n> **참고**\n> 스프링은 스프링 컨테이너에 스프링 빈을 등록할 때, **싱글톤으로 등록**한다. (default)\n> - 싱글톤: 유일하게 하나만 등록하여 이를 공유한다. 이렇게 되면, 같은 스프링 빈인 경우 모두 같은 instance를 사용하는 것이므로, 메모리를 절약할 수 있다.\n\n---\n\n## 🔍 자바 코드로 직접 스프링 빈 등록하기\n먼저, 직접 코드로 등록하기 위해 위에서 사용했던 컴포넌트 스캔 코드를 삭제한다. \n(이때 `Controller` 는 삭제하지 않고 그대로 둔다.)\n> `Controller` 는 어차피 스프링이 관리하기 때문에 그냥 컴포넌트 스캔 방식을 그대로 사용한다.\n\n이후 실행을 하게 되면, 스프링 빈에 등록된 객체가 없으므로, 에러가 발생한다.\n\n이제 직접 등록을 위해 `HelloSpringApplication` 과 같은 위치에 `SpringConfig` class를 생성한다.\n<img src=\"https://images.velog.io/images/bsu1209/post/a1f4a1f6-2067-4563-8c61-2ed6e3753912/image.png\" width=\"50%\">\n\n```java\n@Configuration\npublic class SpringConfig {\n    \n    @Bean\n    public MemberService memberService() {\n        return new MemberService();\n    }\n}\n```\n- `@Bean` annotation은 스프링 빈을 등록한다는 것을 명시한다.\n- 스프링이 동작할 때, `@Configuration` 을 읽으면\n    - `@Bean` 을 찾아 해당 로직을 호출하여 이를 스프링 빈으로 등록한다.\n- 위의 코드는 에러가 뜨는데, 해결하기 위해서 **생성자에서의 추가**가 필요하다.\n\n```java\n@Bean\npublic MemberService memberService() {\n    return new MemberService(memberRepository());\n}\n\n@Bean\npublic MemberRepository memberRepository() {\n    return new MemoryMemberRepository();\n} \n```\n- `MemberService` 는 `MemberRepository` 가 필요하다.\n- 먼저, `MemberService` 를 스프링 빈에 등록한 것과 동일하게 `MemberRepository` 또한 등록한다.\n- 그리고 등록된 `MemberRepository` 를 `MemberService` 에 전달한다.\n\n실행했을 때 문제 없이 잘 동작한다.\n\n> **DI(Dependency Injection)** 에는 3가지 방법이 있다.\n\n- **Field Injection** : 고정적인 방법, 수정이 불가능\n\n```java\n@Autowired private MemberService memberService;\n```\n- **Setter Injection** : Setter를 통해 주입, 생성 따로 주입 따로, setter가 public하게 노출되어 위험할 수 있다.\n\n```java\nprivate MemberService memberService; // final 제거\n@Autowired\npublic void setMemberService(MemberService memberService) {\n    this.memberService = memberService;\n}\n```\n- **Constructor Injection** : 가장 권장, 의존관계가 실행 중에 동적으로 변경되는 경우는 거의 없기 때문이다.\n\n```java\npublic MemberController(MemberService memberService) {\n    this.memberService = memberService;\n}\n```\n\n⇢ **해당 예제에서는 데이터 저장소가 선정되지 않아 `MemoryMemberRepository` 를 사용하기 때문에, 설정(`SpringConfig`)을 통해 스프링 빈으로 등록해야 한다.**\n\n---\n\n## 📌 중요한 개념\n의존성 주입\n\n## 📕 참고\n- [스프링 입문-코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)"},{"excerpt":"스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 들으며 정리하는 POST입니다. 전체적인 흐름 Spring Project 생성 Spring boot로 웹 서버 실행 회원 도메인 개발 웹 MVC 개발 DB 연동 - JDBC, JPA, Spring data JPA 테스트 케이스 작성 🔍 비즈니스 요구사항 정리 Data: 회원ID, …","fields":{"slug":"/[스프링입문]3/"},"frontmatter":{"date":"January 04, 2022","title":"📺 3. 회원 관리 예제","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)을 들으며 정리하는 POST입니다.</strong></em>\n\n> **전체적인 흐름**\n> - Spring Project 생성\n> - Spring boot로 웹 서버 실행\n> - 회원 도메인 개발\n> - 웹 MVC 개발\n> - DB 연동 - JDBC, JPA, Spring data JPA\n> - 테스트 케이스 작성\n\n## 🔍 비즈니스 요구사항 정리\n- Data: 회원ID, 이름, 비밀번호, 전화번호\n- 기능: 회원 등록, 조회\n\n### ⛏ 일반적인 웹 어플리케이션 계층 구조\n<img src=\"https://images.velog.io/images/bsu1209/post/94fde566-c06f-429c-a30a-f32a22cb71c8/springboot-Page-2.drawio.png\" width=\"80%\">\n\n- 컨트롤러: 웹 MVC의 컨트롤러\n- 서비스: 핵심 비즈니스 logic 구현 (ex. 회원은 중복 가입이 불가, ...)\n- 리포지토리: DB에 접근, 도메인 객체를 DB에 저장하고 관리\n- 도메인: 비즈니스 도메인 객체 (ex. 회원, 주문 등 주로 DB에 저장되고 관리됨)\n\n**클래스 의존 관계**<br/>\n<img src=\"https://images.velog.io/images/bsu1209/post/82163da4-621f-4b46-97d7-ce795b7713b0/springboot-Page-2.drawio%20(1).png\" width=\"80%\">\n\n- 아직 DB storage가 선정되지 않았다는 가정이기에, `interface` 로 구현 클래스를 변경할 수 있도록 설계\n- Memory 기반의 데이터 저장소를 사용하여 매우 단순한 구현 (디스크가 아닌 Main memory에 모든 데이터를 저장하는 방식)\n\n---\n\n## 🔍 회원 domain과 repository 만들기\n### ⛏ 회원 domain 생성\n`src/main/java/hello.hellospring/domain` 라는 새로운 Package 안에,\n`Member` 라는 새로운 Class를 생성한다.\n\n`Member` class에 요구사항에서 명시했던 회원과 관련된 **Data**를 처리하기 위해 \n아래와 같이 변수들을 선언한다. 그리고 각 변수에 대한 **Getter & Setter** 도 생성한다.\n\n> Getter & Setter의 필요성: https://ecsimsw.tistory.com/387\n\n```java\npublic class Member {\n    private Long id;\n    private String name;\n    private int pwd;\n    private String phone;\n}\n```\n\n그리고, `src/main/java/hello.hellospring/repository` 라는 Package로 회원 객체 (= Member Class)를 저장하고 이 안에 `MemberRepository` 라는 **Interface** 를 생성하여 회원과 관련된 **기능**들을 선언한다.\n\n```java\npackage hello.hellospring.repository;\nimport hello.hellospring.domain.Member;\nimport java.util.List;\nimport java.util.Optional;\n\npublic interface MemberRepository {\n    Member save(Member member);\n    Optional<Member> findById(Long id);\n    Optional<Member> findByName(String name);\n    Optional<Member> findByPhone(String phone);\n    Optional<Member> findByPwd(int pwd);\n    List<Member> findAll();\n    Member drop();\n}\n\n```\n\n> <strong>`Optional<>`</strong> 은 뒤에 명시된 API가 가져온 객체가 null일 수도, 아닐 수도 있는데 null인 경우를 대비해 이를 감싸주는 Wrapper 역할을 수행한다. (JAVA 8에 내장된 기능)\n> - 그래서 `get()` method 사용 시, `isPresent()` 를 사용하여 null 여부를 판단한다.\n\n- `save` 로 저장소에 회원 정보가 저장\n- 이후 아래 4개의 기능들로 저장된 회원정보를 조회하고, `findAll` 은 모든 회원정보를 가져오는 기능\n- `drop` 은 회원 정보 삭제용으로 만들었는데, 따라하면서 만들어보려는 기능\n\n이제 구현체를 만들기 위해, `repository` 안에 `MemoryMemberRepository` 라는 Class를 생성한다.\n\n`public class MemoryMemberRepository implements MemberRepository` 한 후, `option + enter(return)` 하여 `implements method -> Ok` 한다.\n그럼 생성한 interface의 method들을 **Override** 할 수 있다.\n\n```java\nimport java.util.Map;\n\nprivate static Map<Long, Member> store = new HashMap<>();\nprivate static long sequence = 0L;\n```\n\n- `id` 를 Key로서 사용하기 위해 `Long` 으로 지정해주고, '0,1,2'와 같이 Key 값을 생성해주는 `sequence` 를 선언한다.\n\n**Map collection class**는 Key와 value를 하나의 쌍으로 저장하는 방식을 사용한다. 이때 Key는 실질적인 value를 찾기 위한 역할을 한다. \n- entry의 저장 순서를 고려하지 않고,\n- Key는 중복이 허용되지 않는다.\n\n`HashMap` 은 Key와 value를 묶어 하나의 entry로 저장한다. 이름 그대로 `Hash` 알고리즘을 사용하기에 데이터의 검색 속도가 빠르다.\n- 역시나 Key는 중복이 불가능하고,\n- value는 null이 가능하다.\n\n> 실무에서는 위와 같은 **공유되는 변수에 대한 동시성 문제**때문에 `ConcurrentHashMap` & `AtomicLong` 등을 사용해야 한다. 동시성 제어와 관련된 참고: https://devlog-wjdrbs96.tistory.com/269\n\n**회원 정보 저장 (save)**<br/>\n```java\npublic Member save(Member member) {\n    member.setId(++sequence);\n    store.put(member.getId(), member);\n    return member;\n}\n```\n- 먼저 해당 `Member` 객체의 `id` 에 `sequence + 1` 한 값을 setting\n\t\n    - 0, 1, 2, ... 순으로 저장\n    - `id` 는 중복이 허용되지 않는 고유한 값이어야 하므로 위와 같이 지정한다.\n- `store` 에 해당 `member` 의 `id` & `member` 를 **Key & value** 쌍으로 저장\n\n**회원 정보 조회 (Id)**<br/>\n```java\npublic Optional<Member> findById(Long id) {\n    return Optional.ofNullable(store.get(id));\n}\n```\n- `store.get(id)` 로 지정한 `id` 를 가지는 `member` 객체를 가져올 수 있다.\n\t\n    - 하지만 지정한 `id` 를 가지는 `member` 가 없는 경우, 즉 `Null` 이 반환될 수 있는데, 이 또한 클라이언트에서 처리할 수 있도록 하기 위한 작업이 필요하다.\n    - 따라서, **`Optional.ofNullable()`** 를 사용하여 반환되는 객체를 감싸준다.\n    \n**회원 정보 조회 (Name)**<br/>\n```java\npublic Optional<Member> findByName(String name) {\n    return store.values().stream()\n            .filter(member -> member.getName().equals(name))\n            .findAny();\n}\n```\n- `store` 에서 파라미터로 전달받은 `name` 과 동일한 `name` 을 가지는 `member` 객체를 하나라도 찾으면 (= `findAny()`) return 하도록 한다.\n\n**회원 정보 조회 (All)**<br/>\n```java\npublic List<Member> findAll() {\n    return new ArrayList<>(store.values());\n}\n```\n- 전체 정보를 조회하기 위해서 `store` 에 있는 모든 값들을 가져와야 한다.\n- 이때, `store.values()` 로 `store` 에 있는 모든 `Member` 들을 가져온다.\n- 근데, return 형이 `List` 이므로 `store` 에 있는 값들을 `ArrayList` 에 담아 반환한다.\n\n## 🔍 회원 repository 테스트 케이스 작성\n위에서 생성한 회원 정보 API의 기능을 테스트하기 위한 Test case를 작성\n\n- 개발한 기능을 테스트할 때 main method를 통해서 실행하거나, 웹 애플리케이션의 Controller를 통해 해당 기능을 실행한다. 이러한 방법은 **준비하고 실행하는데 오래 걸리고, 반복 실행하기 어렵고 여러 테스트를 한번에 실행하기 어렵다**는 단점이 있다. \n- 따라서 이러한 문제를 해결하기 위해, Java는 **JUnit**이라는 framework로 테스트를 실행한다.\n\n`src/test/java/hello.hellospring/repository/MemoryMemberRepositoryTest` 라는 새로운 class를 생성한다.\n\n**save() Test**\n\n```java\npackage hello.hellospring.repository;\nimport hello.hellospring.domain.Member;\nimport org.junit.jupiter.api.Test;\n\nclass MemoryMemberRepositoryTest {\n\n    MemberRepository repository = new MemoryMemberRepository();\n\n    @Test\n    public void save() {\n        Member member = new Member();\n        member.setName(\"spring\");\n\n        repository.save(member);\n\n        Member result = repository.findById(member.getId()).get();\n\n        System.out.println(\"result = \" + (result == member));\n    }\n}\n```\n- `@Test` 를 통해 TEST 코드임을 명시하고, 새로운 `Member` 객체를 만든다.\n- 해당 객체의 Name을 set하고, `save()` 를 수행한다.\n- 이후 금방 `save` 한 `member` 의 `id` 정보를 `findById` 로 찾아내어 `result` 라는 `Member` 객체에 저장한다.\n- 두 객체가 같다면, 그래서 마지막 출력문에 `result = true` 가 출력된다면, **`save` 기능의 테스트는 정상적으로 완료된 것이다.**\n\n하지만, 매번 두 결과가 같은 비교하는 구문으로는 불편함을 느낄 수 있다.\n\n```java\nAssertions.assertEquals(member, result);\n```\n- `org.junit.jupiter.api` 에서 제공하는 `Assertions` 로 expected, 즉 기대하는 `result` 값이, actual, `member` 와 동일한지를 확인하는 코드로 테스트의 결과를 확인할 수 있다.\n\t\n    - 테스트하는 기능이 정상적으로 동작한다면, 아무런 출력문 없이 초록색 체크가 뜨고,\n    - 그렇지 않은 경우, 기댓값과 실제값에 대한 Error log가 출력된다.\n\n또 다른 방법으로는,\n```java\nAssertions.assertThat(member).isEqualTo(result);\n```\n- `org.assertj.core.api` 에서 제공하는 `Assertions` 를 사용하여 위와 같이 결과를 확인하는 방법이 있다.\n\t\n    - 이 역시, 위와 동일한 결과를 보인다.\n    - 추가적으로, `Assertions` 에서 `option + enter(return)` → `static import` 하여 이후에는 `Assertions` 를 명시하지 않고 바로 `assertThat` 를 사용할 수 있다.\n\n**findByName() Test**<br/>\n\n```java\n@Test\npublic void findByName() {\n    Member member1 = new Member();\n    member1.setName(\"spring1\");\n    repository.save(member1);\n\n    Member member2 = new Member();\n    member2.setName(\"spring2\");\n    repository.save(member2);\n\n    Member result = repository.findByName(\"spring1\").get();\n\n    assertThat(result).isEqualTo(member1);\n}\n```\n- `save()` 에 대한 Test와 동일하게 수행한다.\n\n> **Test Class** 자체에 대한 실행으로 전체 `@Test` method들을 한 번에 실행할 수 있다.\n\n**findAll() Test**<br/>\n\n```java\n@Test\npublic void findAll() {\n    Member member1 = new Member();\n    member1.setName(\"spring1\");\n    repository.save(member1);\n\n    Member member2 = new Member();\n    member2.setName(\"spring2\");\n    repository.save(member2);\n\n    Member member3 = new Member();\n    member3.setName(\"spring3\");\n    repository.save(member3);\n\n    List<Member> result = repository.findAll();\n\n    assertThat(result.size()).isEqualTo(3);\n}\n```\n- 동일한 방법으로 Test를 수행하되, `findAll` 이므로 반환형이 `List` 이기 때문에 `result` 의 `size()` 에 대해 비교를 수행한다.\n\n이제 **Class** 전체 Test를 실행하면 에러가 발생하고 아래와 같이 명시한 것과 실행 순서가 달라진 것을 확인할 수 있다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/2f2d4c44-a2dd-4a80-b640-66144e6e3a08/image.png\" width=\"40%\">\n\n- 실행 순서는 보장되지 않기 때문에 `findAll` 에서 이미 `member1` & `member2` 객체를 생성하여 `findByName` 에서 에러가 발생하는 것이다.\n- 따라서, **각 `@Test` 가 끝날 때마다 `repository` 를 비워줘야 한다.**\n\n> **Test는 서로 의존관계 없이 설계되어야 한다!**\n\n`MemoryMemberRepository` 에 store를 비워주는 method를 선언한다.\n\n```java\n@Override\npublic void clearStore() {\n    store.clear();\n}\n```\n이후, Test에서 각 `@Test` 가 끝난 이후 위 method를 수행하기 위해 `@AfterEach` annotation을 이용하는 method를 선언한다.\n\n```java\n@AfterEach\npublic void afterEach() {\n    repository.clearStore();\n}\n```\n- 이후 Class 전체를 실행하면 에러 없이 잘 수행되는 것을 확인할 수 있다.\n\n> **테스트 주도 개발 = TDD**\n위와 같은 테스팅 코드들을 먼저 선언한 후, 개발을 진행하는 방식\n\n---\n\n## 🔍 회원 서비스 개발\n실제 비즈니스 로직을 작성하는 부분, \n서비스 부분에서는 **비즈니스적인 용어**들로 Method를 구현해야 기능 유지 보수 시, 의미와 매칭이 잘 된다. (서비스는 비즈니스를 처리하는 역할!)\n\n`src/main/java/hello.hellospring/service/MemberService`\n\n### ⛏ 회원 가입 기능\n```java\nprivate final MemberRepository memberRepository = new MemoryMemberRepository();\n\n    // 회원 가입\n    public Long join(Member member) {\n        // 같은 이름인 중복회원을 불가능해야 함\n        Optional<Member> result = memberRepository.findByName(member.getName());\n        result.ifPresent(m -> {\n            throw new IllegalStateException(\"이미 존재하는 회원입니다.\");\n        });\n\n        memberRepository.save(member);\n        return member.getId();\n    }\n```\n- 비즈니스 로직에서, 중복된 이름이 존재하는 경우 회원가입이 불가능해야 하기에, 이미 생성한 `findByName` method로 이름의 여부를 확인한다.\n- 이름이 없는 경우에만 `save` method로 회원가입이 가능하게 하고, 해당 회원의 `id` 를 반환한다.\n\n위의 코드를 `Control + T` 단축키를 이용해 리팩토링과 관련된 기능을 사용할 수 있고, `Extract Method` 하여 아래와 같은 형태로 변환할 수 있다.\n\n```java\npublic Long join(Member member) {\n    // 같은 이름인 중복회원을 불가능해야 함\n    ValidateDuplicateMember(member); // 이름 중복 회원 검증\n\n    memberRepository.save(member);\n    return member.getId();\n}\n\nprivate void ValidateDuplicateMember(Member member) {\n    memberRepository.findByName(member.getName())\n        .ifPresent(m -> {\n            throw new IllegalStateException(\"이미 존재하는 회원입니다.\");\n        });\n}\n```\n\n### ⛏ 회원 조회 기능\n```java\n// 전체 회원 조회\npublic List<Member> findMembers() {\n     return memberRepository.findAll();\n}\n    \n// 특정 회원 조회\npublic Optional<Member> findOne(Long memberId) {\n    return memberRepository.findById(memberId);\n}\n```\n\n---\n\n## 🔍 회원 서비스 테스트\n위에서 구현한 회원 서비스에 대한 테스트를 수행, `command + shift + T` 단축키를 이용해 손쉽게 Test를 작성할 수 있다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/a746a9db-6f7a-4409-849d-b7399999460c/image.png\" width=\"70%\">\n\n```java\n@Test\nvoid 회원가입() {\n    // given\n    // when\n    // then\n}\n```\n- Test 코드는 과감하게 한글로 바꿔도 상관이 없다. 실제 build 될 때, 테스트 코드는 포함되지 않기 때문이다.\n- 그리고 Test는 **given, when, then** 이라는 큰 틀로 설계할 수 있다.\n    - given: 주어지는 data\n    - when: 이를 실행했을 때\n    - then: 나와야 하는 결과\n\n```java\n@Test\nvoid 회원가입() {\n    // given\n    Member member = new Member();\n    member.setName(\"hello\");\n\n    // when\n    Long saveId = memberService.join(member);\n\n    // then\n    Member findMember = memberService.findOne(saveId).get();\n    assertThat(member.getName()).isEqualTo(findMember.getName());\n}\n```\n- `then` part 에서, 위에서 `join` 하고 반환된 `id` 를 가지고 `findOne` method를 실행\n- 회원가입이 정상 동작했다면, `member` 객체의 `Name` 과 `findOne` 의 반환 객체인 `findMember` 의 `Name` 이 동일할 것이다.\n\n위의 Test code는 사실상 **반쪽짜리 Test code** 이다.\n- 왜냐하면, **Test는 예외에 대해서도 수행되어야 하기 때문**이다. (그리고 `service` 에 중복회원체크 method도 있기 때문에 해당 Test도 필요하다.)\n\n```java\n@Test\npublic void 중복_회원_예외() {\n    // given\n    Member member1 = new Member();\n    member1.setName(\"spring\");\n\n    Member member2 = new Member();\n    member2.setName(\"spring\");\n\n    // when\n    memberService.join(member1);\n    try {\n        memberService.join(member2);\n        fail();\n    } catch (IllegalStateException e) {\n        assertThat(e.getMessage()).isEqualTo(\"이미 존재하는 회원입니다.\");\n    }\n\n    // then\n}\n```\n- 같은 이름을 가진 두 회원을 생성하고 각각 `join` 을 수행하려 한다.\n- `try - catch` 구문으로, 발생한 Exception의 message를 비교하여 Test를 수행한다.\n\n하지만, 다른 문법으로 더 깔끔하게 Test를 수행할 수 있다.\n\n```java\nassertThrows(IllegalStateException.class, () -> memberService.join(member2));\n```\n\n- **`assertThrows`** 를 이용해 `() -> memberService.join(member2)` 가 수행될 때, `IllegalStateException` 예외가 발생해야 함을 명시한다.\n\n```java\nIllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));\nassertThat(e.getMessage()).isEqualTo(\"이미 존재하는 회원입니다.\");\n```\n\n- `asserThrows` 는 반환이 가능(`command + option + V` 로 반환받을 객체 선언)하기에, Exception message에 대한 검증도 가능하다.\n\n이전의 Test와 동일하게, 실행 순서가 보장되지 않아 에러가 발생할 수 있다.\n이를 위해 이전에는 `@AfterEach` 로 `MemoryMemberRepository` 에서 생성한 `clearStore` method를 사용했었다.\n\n```java\nMemberService memberService = new MemberService();\nMemoryMemberRepository memberRepository = new MemoryMemberRepository();\n    \n@AfterEach\npublic void afterEach() {\n    memberRepository.clearStore();\n}\n```\n\n**`MemberService` 에서도 `MemoryMemberRepository` 객체를 선언하여 사용하는데, 위 코드에서는 한 번 더 해당 객체를 생성하여 사용하고 있다.**\n\n즉, `MemberService` 에서 사용하는 `MemoryMemberRepository` 와 `MemberServiceTest` 에서 사용하는 `MemoryMemberRepository` 는 서로 다른 객체를 생성하여 사용하기에, `MemoryMemberRepository` 에서 `Map<> store` 가 Class에 종속적인 `static` 이 아니라면 객체 생성마다 다른 DB가 되어버려 원하는 결과를 얻을 수 없게 된다.\n\n`MemberService.java`\n```java\nprivate final MemberRepository memberRepository = new MemoryMemberRepository();\n\n↓\n\nprivate final MemberRepository memberRepository;\n\npublic MemberService(MemberRepository memberRepository) {\n    this.memberRepository = memberRepository;\n}\n```\n\n- Contructor를 생성하여 직접 `new` 로 생성하지 않고, **외부에서 전달해주도록 변경**\n\n`MemberServiceTest.java`\n```java\nMemberService memberService;\nMemoryMemberRepository memberRepository;\n\n@BeforeEach\npublic void beforeEach() {\n    memberRepository = new MemoryMemberRepository();\n    memberService = new MemberService(memberRepository);\n}\n```\n\n- `BeforeEach` annotation으로, 각 Test Method가 수행되기 전에 `MemoryMemberRepsotiory` 를 생성하고 이를 `MemberService` 에 전달하여 사용함으로써, 같은 Repository를 사용할 수 있게 한다.\n\n이를 **Dependency Injection (의존성 주입)** 이라고 한다.\n\n---\n\n## 📌 중요한 개념\nOptional, Test, Dependency Injection\n\n## 📕 참고\n- [스프링 입문-코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)"},{"excerpt":"스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 들으며 정리하는 POST입니다. 전체적인 흐름 Spring Project 생성 Spring boot로 웹 서버 실행 회원 도메인 개발 웹 MVC 개발 DB 연동 - JDBC, JPA, Spring data JPA 테스트 케이스 작성 🔍 정적 컨텐츠 ⛏ 정적 컨텐츠란? 서버에 저장되…","fields":{"slug":"/[스프링입문]2/"},"frontmatter":{"date":"January 03, 2022","title":"📺 2. 스프링 웹 개발 기초","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)을 들으며 정리하는 POST입니다.</strong></em>\n\n> **전체적인 흐름**\n> - Spring Project 생성\n> - Spring boot로 웹 서버 실행\n> - 회원 도메인 개발\n> - 웹 MVC 개발\n> - DB 연동 - JDBC, JPA, Spring data JPA\n> - 테스트 케이스 작성\n\n## 🔍 정적 컨텐츠\n### ⛏ 정적 컨텐츠란?\n- 서버에 저장되어 있고 **변화 없이** 브라우저로 뿌려지는 컨텐츠(파일)\n- 요청에 따라 응답만을 수행\n\n**Spring Boot는 정적 컨텐츠 기능 자동 제공**<br/>\n→ https://docs.spring.io/spring-boot/docs/2.3.1.RELEASE/reference/html/spring-boot-features.html#boot-features-spring-mvc-static-content\n- `/static` 폴더에서 정적 컨텐츠를 찾아서 제공한다.\n\n**`/static` 에 `hello-static.html` 을 생성 및 작성해보자.**\n\n<img src=\"https://images.velog.io/images/bsu1209/post/730e0fbd-5aee-4bbc-aeff-2726a8d49a37/image.png\" width=\"25%\"><img src=\"https://images.velog.io/images/bsu1209/post/60f18df8-7d2f-4280-b638-f4d4dd7520f5/image.png\" width=\"50%\">\n\n- 파일 작성 후 서버를 동작시키면, **http://localhost:8080/hello-static.html** 에서 작성한 정적 컨텐츠인 `html` 파일을 확인할 수 있다.\n<img src=\"https://images.velog.io/images/bsu1209/post/3634c932-506e-4040-9f55-33baab3968bb/%E1%84%86%E1%85%AE%E1%84%8C%E1%85%A6.drawio.png\" width=\"80%\">\n\n---\n\n## 🔍 MVC와 템플릿 엔진\n### ⛏ 템플릿 엔진이란?\n- 서버에서 **동적으로** 파일을 바꿔서 브라우저로 뿌려주는 엔진\n- jsp, php 등이 있다.\n- 이를 위해 필요한 **Model, View, Controller**를 합쳐 **MVC**라고 한다.\n- 예전에는 View만으로 개발을 진행했다면, 이제는 **View는 화면을 그리는 데에만 집중**하고, **Model & Controller는 Business logic과 관련있거나, 내부적인 것들을 처리하는데 집중**하기 위해 이를 분리하였다.\n    - **!면접 질문!**\n    \t- 유지보수성\n    \t- 애플리케이션의 확장성\n    \t- 유연성 증가(클라이언트의 새로운 요구사항에 대해 최소한의 비용으로 보다 유연하게 대처)\n    \t- 중복코딩의 문제점 감소\n    - 그렇지 않으면 유지, 보수에 엄청난 시간이 필요할 것이다 ...\n\n> **정적 컨텐츠와 다른 점**\n> 서버에서 뿌려질 컨텐츠에 동적으로 변화를 줄 수 있다.\n\n이번에는 **MVC를 이용하여 Parameter를 받는 Controller**를 생성해보자.\n\n**`controller/HelloController.java`**<br/>\n\n```java\n@GetMapping(\"hello-mvc\")\npublic String helloMvc(@RequestParam (\"name\") String name, Model model) {\n    model.addAttribute(\"name\", name);\n    return \"hello-template\";\n}\n```\n- `@RequestParam` annotation은 HTTP request parameter를 method의 parameter로 전달받을 때 사용한다. `form` 에서의 `input` 의 `name` 과 매칭되어 해당 값을 받아올 수 있다.\n- `String name` 에 해당 값을 담고, `Model model` 을 이용하여 `View` 에서 rendering 시 사용\n- `model.addAttribute` method로 **`key`** 가 **\"name\"** 이고, **`변수이름`** 이 **`name`** 인 값을 가져와서 `View` 로 전달한다.\n\n**`resources/templates/hello-templates.html`**<br/>\n\n```html\n<!DOCTYPE html>\n<html lang=\"en\" xmlns:th=\"http://www.thymeleaf.org\">\n<body>\n    <p th:text=\"'hello' + ${name}\">hello! empty</p>\n</body>\n</html>\n```\n- `xmlns:th=\"~\"` 로 `thymeleaf` 템플릿을 사용함을 명시\n\t\n    - thymeleaf의 장점은, 위와 같이 저장한 파일 자체를 서버없이 열어도 해당 파일의 소스코드를 그대로 확인 가능하다.\n    - 서버가 동작하게 되면, `th:text` 에 있는 값으로 `hello! empty` 가 치환된다.\n\n서버를 동작시켜 http://localhost:8080/hello-mvc 로 접속\n<img src=\"https://images.velog.io/images/bsu1209/post/eb52fa9d-b790-481a-9d82-66e07f3766c3/image.png\" width=\"80%\">\n```bash\nWARN 51004 --- [nio-8080-exec-1] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.web.bind.MissingServletRequestParameterException: Required request parameter 'name' for method parameter type String is not present]\n```\n- 위와 같은 log와 함께 Error page가 나오는 것을 확인할 수 있다. 쉽게 말해 `name` parameter에 아무것도 넘겨주지 않아서 뜨는 에러라고 할 수 있다.\n\n```java\n@GetMapping(\"hello-mvc\")\npublic String helloMvc(@RequestParam (name = \"name\") String name, Model model) {\n    model.addAttribute(\"name\", name);\n    return \"hello-template\";\n}\n```\n- 위와 같이, parameter의 이름을 명시하고, `required` option은 기본값이 `true` 이므로 그대로 둔다.\n\n이제 http://localhost:8080/hello-mvc?name=spring 으로 접속해보자.\n<img src=\"https://images.velog.io/images/bsu1209/post/c32434b5-6b7a-4244-99b8-672dcb8f382c/image.png\" width=\"80%\">\n\n- 동작방식은, \n    1. url에서 받아온 name에 대한 \"spring\" 이라는 값이 `public Stirng helloMvc` 의 `String name` 에 담기고,\n    2. `model.addAttribute` 를 통해 `name` 이 `model` 에 담겨, `hello-template` 으로 return\n    3. `${name}` 으로, `model` 에서 key값이 `name` 인 값을 가져와서 치환!\n\n<img src=\"https://images.velog.io/images/bsu1209/post/218ce6be-9030-4514-82fb-b13bd9f5cb1b/springboot.drawio.png\" width=\"80%\">\n\n---\n\n## 🔍 API\n- `JSON` 이라는 데이터 포맷으로 서버에서 클라이언트로 **데이터를 전송하는 방식**\n\n```java\n@GetMapping(\"hello-string\")\n@ResponseBody\npublic String helloString(@RequestParam(\"name\") String name) {\n    return \"hello\" + name;\n}\n```\n\n- `@ResponseBody` 는, http에서의 body에 해당 내용을 직접 넣겠다는 의미!\n- **Template engine과 다른 점**은 \"view\" 개념 없이 data가 그대로 보여진다.\n\t\n    - 확인하기 위해, http://localhost:8080/hello-string?name=spring 으로 접속하면, 아래와 같은 화면이 보이고, `페이지 소스 보기` 하면, html code 없이 Data만 존재하는 것을 확인할 수 있다.\n  \n  <img src=\"https://images.velog.io/images/bsu1209/post/b865d7e2-4a4e-4894-8629-0b1dfedd010c/image.png\" width=\"40%\" style=\"float: left;\"><img src=\"https://images.velog.io/images/bsu1209/post/f52aee18-4120-4abf-a60f-be8423a6a835/image.png\" width=\"40%\">\n    \n다음 예제는 `Hello` 객체와 `getName` & `setName`, 그리고 객체를 `return` 하는 Api 방식이다.\n\n```java\n@GetMapping(\"hello-api\")\n@ResponseBody\npublic Hello helloApi(@RequestParam(\"name\") String name) {\n    Hello hello = new Hello();\n    hello.setName(name);\n    return hello;\n}\n\nstatic class Hello {\n    private String name;\n\n    public String getName() {\n        return name;\n    }\n\n    public void setName(String name) {\n        this.name = name;\n    }\n}\n```\n- http://localhost:8080/hello-api?name=spring 으로 접속하면 아래 사진에서 보이는 바와 같이 **`Key` & `Value`** 로 이루어진 **JSON** 구조를 확인할 수 있다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/d466fad7-fe76-47f4-9394-f520b4a787e9/image.png\" width=\"40%\">\n\n> mac 기준 `⌘ + n` 으로 Getter와 Setter를 생성할 수 있다.\n`Hello` Class 안에 있는 `String name` 은 `private` 이므로, 해당 변수에 대한 접근은 오직 `public` 한 `getName` or `setName` 으로만 가능하게 한다.\n→ **JavaBeans** 표준 방식\n\n<img src=\"https://images.velog.io/images/bsu1209/post/bd1edf66-e5fb-4123-895d-2ef97cdfa424/springboot.drawio%20(1).png\" width=\"80%\">\n\n- 이와 같이 `@ResponseBody` 를 사용한 동작방식은,\n1. localhost:8080/hello-api로 이동하여 controller가 이를 확인\n2. template engine의 경우, 해당하는 view를 보여주기 위해 viewResolver에게 전달했지만 `@ResponseBody` 를 발견하면 `http` 응답에 해당 Data를 그대로 전달하기 위한 처리를 수행\n3. 이때, 전달하려는 Data가 문자열이 아닌 **객체**이므로 이에 대한 처리가 필요하다.\n\t- Spring의 기본 정책은 객체가 오는 경우, 이를 JSON 방식으로 Http 응답에 반환하는 것\n4. `ViewResolver` 대신 `HttpMessageConverter` 가 동작하여 **String인 경우는 `StringConverter`**, **객체인 경우는 `JsonConverter`** 를 동작시킴\n   - 대표적인 JsonConverter library로는 `MappingJacksonHttpMessageConveter` 와 `GsonHttpMessageConveter` 가 있다.\n   - HttpMessageConverter는 클라이언트가 원하는 response 형태를 header에 명시한 경우, 이에 맞춰 선택된다. 그렇지 않은 경우는 spring이 알아서 선택!\n   - MessageConverter에 대한 자세한 정보는 참고에 있는 **HttpMessageConverter** 를 확인\n5. Converter를 이용해 변환된 결과를 요청측으로 전달\n\n> 예전에는 JSON이 아닌 XML 방식을 사용했었는데, (ex. html code) 이는 열고 닫는 이중의 code가 필요하고, 무겁다는 단점때문에 최근에는 Simple한 JSON 형태를 많이 사용한다.\n\n---\n\n## 📌 중요한 개념\nTemplate engine, API, Annotation, HttpMessageConverter, JavaBeans\n\n## 📕 참고\n- [스프링 입문-코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)\n- [장인개발자를 꿈꾸는 :: 기록하는 공간](https://devbox.tistory.com/entry/Spring-컨트롤러-메서드의-파라미터-타입)\n- [HttpMessageConverter](https://jaimemin.tistory.com/1823)"},{"excerpt":"스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 들으며 정리하는 POST입니다. 전체적인 흐름 Spring Project 생성 Spring boot로 웹 서버 실행 회원 도메인 개발 웹 MVC 개발 DB 연동 - JDBC, JPA, Spring data JPA 테스트 케이스 작성 🔍 프로젝트 생성 ⛏ 사전 준비 JAVA 11 I…","fields":{"slug":"/[스프링입문]1/"},"frontmatter":{"date":"January 02, 2022","title":"📺 1. 프로젝트 환경설정","tags":["Java","SpringBoot"]},"rawMarkdownBody":"\n<em><strong>[스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)을 들으며 정리하는 POST입니다.</strong></em>\n\n> **전체적인 흐름**\n> - Spring Project 생성\n> - Spring boot로 웹 서버 실행\n> - 회원 도메인 개발\n> - 웹 MVC 개발\n> - DB 연동 - JDBC, JPA, Spring data JPA\n> - 테스트 케이스 작성\n\n## 🔍 프로젝트 생성\n### ⛏ 사전 준비\n- JAVA 11\n- IDE: IntelliJ or Eclipse\n\n**Springboot Starter를 사용하여 프로젝트 생성**\n→ https://start.spring.io\n- **Project: 어떤 빌드 관리 도구를 사용할 것인가 ?**\n\t\n    - Maven: 필요한 라이브러리를 땡겨오고 빌드하는 lifecycle까지 관리하는 빌드 관리 도구\n    \t- 라이브러리 수가 많아지면, 빌드 시간이 오래 걸릴 수 밖에 없다.\n    - Gradle: Maven과 다르게, 필요한 라이브러리에 대한 설정 파일(xml파일)의 코드가 매우 간결한 빌드 관리 도구\n      - 최근 많이 사용\n      - 이미 업데이트가 반영된 부분은 다시 빌드하지 않기에 빌드 시간이 maven에 비해 적어지게 된다.\n    > **빌드 관리 도구란 ?**\n    프로젝트에서 작성한 파일들을 JVM이나 WAS에서 인식할 수 있도록 패키징해주는 도구\n- **Project Spring Boot**: 2.5.6\n- **Language**: Java \n- Group: 보통 기업 도메인명\n- Artifact: 빌드되어 나오는 결과물, 프로젝트명\n- **<span id=\"packaging\">Packaging</span>: 어떤 패키징 방식을 사용할 것인가 ?**\n\t\n    - Jar(Java Archieve): Java application이 동작할 수 있도록 패키징하는 방식\n    \t- JRE만 있어도 실행이 가능하다.\n    - War(Web Application Archieve): Web application 전체를 패키징하는 방식\n    \t- 별도의 Web Server 또는 WAS가 필요하다.\n- Java: 11\n- **Dependencies: 어떤 라이브러리를 사용할 것인가 ?**\n\t\n    - Spring Web(Embedded Tomcat 추가를 위함, Web 프로젝트 생성 시 필수)\n    - Thymeleaf(Controller가 전달하는 Data를 이용하여 HTML을 꾸밀 수 있도록 하는 Template Engine)\n    - 추가적으로, lombok(Annotation을 이용해 Compile 시점에 Getter, Setter, 생성자, toString, Builder 등을 자동으로 만들어주는 라이브러리)\n    \n![](https://images.velog.io/images/bsu1209/post/03dcea8e-00c1-4214-b9e0-6ad2806ec2ca/%E1%84%89%E1%85%B3%E1%84%8F%E1%85%B3%E1%84%85%E1%85%B5%E1%86%AB%E1%84%89%E1%85%A3%E1%86%BA%202021-11-05%20%E1%84%8B%E1%85%A9%E1%84%92%E1%85%AE%208.07.23.png)\n이후 ```GENERATE```로 .zip 파일을 다운로드한 후, unzip 한 파일을 ```IntelliJ``` 로 **OPEN**\n\n> Project open시, 외부의 library를 로딩하는 과정이 필요하기 때문에, 시간이 좀 걸릴 수 있다.\n\n### ⛏ 프로젝트 구조\n<p align=\"center\"><img src=\"https://images.velog.io/images/bsu1209/post/dfba1b83-83d3-41f0-a194-f2f761440ae4/image.png\" width=\"50%\" height=\"30%\"></p>\n\n**```src```**\n- ```main```, ```test``` 로 나뉜다.\n\t\n    - ```main/java``` 에 실제 패키지들과 소스 파일이 존재\n    - ```main/resources``` 에는 설정 파일들이 존재, java 파일을 제외한 모든 파일\n    - ```test/java``` 에 test 관련 코드들이 존재\n    \t- 이는 곧 **TEST라는 것이 매우 중요한 존재**임을 알려준다.\n\n**```build.gradle```**\n```java\nplugins {\n\tid 'org.springframework.boot' version '2.5.6' // starter에서 선택한 버전\n\tid 'io.spring.dependency-management' version '1.0.11.RELEASE'\n\tid 'java' // 선택한 언어\n}\n\n// Metadata\ngroup = 'hello'\nversion = '0.0.1-SNAPSHOT'\nsourceCompatibility = '11' // java version\n\n// 아래에 선택한 library를 다운로드받는 곳, 필요하면 특정 사이트 url 지정 가능\nrepositories {\n\tmavenCentral() // \n}\n\n// 선택한 library들\ndependencies {\n\timplementation 'org.springframework.boot:spring-boot-starter-thymeleaf:2.5.6'\n\timplementation 'org.springframework.boot:spring-boot-starter-web:2.5.6'\n\ttestImplementation 'org.springframework.boot:spring-boot-starter-test:2.5.6'\n}\n\ntest {\n\tuseJUnitPlatform()\n}\n```\n\n이제 ```src/main/java/hello.hellospring``` 안에 있는 메인 코드를 실행시켜보자.\n<img src=\"https://images.velog.io/images/bsu1209/post/51434c13-238d-455c-8c8a-8f06c1f87018/image.png\">\n\n실행한 후, http://localhost:8080 으로 접속해보자.\n<img src=\"https://images.velog.io/images/bsu1209/post/6c5ab164-d198-480e-bec1-e89b630b3e2d/image.png\">\n\n아직은 아무런 View를 구성하지 않았기에, 위와 같은 화면이 뜨게 된다.\n\n---\n\n## 🔍 라이브러리 살펴보기\n프로젝트안의 ```build.gradle``` 을 보면, 아래와 같이 스타터로 프로젝트 생성할 때 추가했던 3개의 라이브러리들을 확인할 수 있다.\n```java\ndependencies {\n\timplementation 'org.springframework.boot:spring-boot-starter-thymeleaf:2.5.6'\n    implementation 'org.springframework.boot:spring-boot-starter-web:2.5.6'\n    testImplementation 'org.springframework.boot:spring-boot-starter-test:2.5.6'\n}\n```\n그리고, ```External Libraries``` 에서는 프로젝트 생성 시 땡겨온 라이브러리들을 확인할 수 있는데, 처음에 추가했던 **3개의 라이브러리보다 훨씬 더 많은 수의 라이브러리가 땡겨와진 것을 확인**할 수 있다. \n\n이러한 이유는 우리가 사용하기 위해 추가한 3개의 라이브러리도 동작하기 위해서는 필요한 다른 라이브러리들이 존재한다. **Gradle**은 이러한 **추가적인 라이브러리를 자동으로 ```External Libraries``` 에 추가**해주기 때문에 많은 라이브러리들이 추가되어 있는 것이다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/998b6f57-ec6d-4fd8-9c4b-cb0e7e6144d0/image.png\" width=\"70%\">\n\n위 화면에서 보이듯, **Gradle > hello-spring > Dependencies**에서 라이브러리간의 의존관계를 확인할 수 있다.\n\n여기서 중요한 라이브러리로는 먼저 ```spring-boot-starter-tomcat``` 라이브러리가 있는데, 이는 Spring boot가 톰캣 웹서버를 내장되어 있기 때문에 존재하는 라이브러리이다.\n또한, ```spring-boot-starter-logging``` 이라는 것이 있는데, 이는 서버 개발자들이 어떠한 에러들을 출력하고 한 눈에 모아서 보기 위해 사용하는 것이다. 내부에는 ```logback```, ```slf4j``` 라는 라이브러리가 내장되어 있다.\n\n---\n\n## 🔍 View 환경설정\n현재 서버를 실행하고 http://localhost:8080 으로 접속하면, 아까 위에서 본 <a href=\"#firstP\">화면</a>이 뜬다.\n\n이제 화면 구성을 한 번 해보도록 하자.\n\n### ⛏ Welcome Page\n**resources/static/index.html**<br/>\n을 생성하게 되면, 이를 자동으로 **welcome page**로 설정해준다. 이는 **정적 페이지**로서, 작성한 코드를 그대로 브라우저에 던져주는 것이다.\n\n```html\n<!-- index.html -->\n<!DOCTYPE HTML>\n<html>\n<head>\n    <title>Hello</title>\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n</head>\n<body>\n    Hello\n    <a href=\"/hello\">hello</a>\n</body>\n</html>\n```\n코드를 작성하고 서버를 재시작하면, 아래의 화면을 볼 수 있을 것이다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/85ba87cc-a09b-4643-83cf-052ec6f022f7/image.png\" width=\"80%\">\n\n> Spring은 그 생태계가 어마어마하게 크기 때문에, 머릿속에 모든 것을 다 넣을 수는 없다.\n따라서, 원하는 것을 잘 찾는 능력이 필요하다.\nhttps://docs.spring.io/spring-boot/docs/current/reference/html/\n위 홈페이지에서 관련 문서를 찾아보도록 하자.\n\n위 홈페이지에서, [**Welcome page**에 대한 설명](https://docs.spring.io/spring-boot/docs/current/reference/html/features.html#features.developing-web-applications.spring-mvc.welcome-page)을 찾아보았다.\n설명을 가져오자면, 스프링 부트는 static & templated welcome page 모두 지원한다. 먼저 ```static/index.html``` 을 찾고, 없다면 ```template/index.html``` 을 찾아 **Welcome Page**로서 사용한다.\n\n**resources/templates**<br/>\n```static``` 과 다른 동적 페이지를 구성하는데 사용한다. 여기서 우리는 처음에 추가했던 **thymeleaf** 라는 템플릿 엔진을 사용할 것이다.\n이와 관련된 문서로는 [여기](https://docs.spring.io/spring-boot/docs/current/reference/html/features.html#features.developing-web-applications.spring-mvc.template-engines)를 참고하면 된다.\n스프링 부트는 **FreeMarker, Groovy, Thymeleaf, Mustache**의 총 4개의 템플릿 엔진에 대한 auto-configuration 지원을 한다.\n\n> auto-configuration이란?\n\n이제, 실제로 동작하고, 프로그래밍이 되는 화면을 구현해보도록 하자.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/cb9d6ff7-d0fd-41ec-b791-8b94c0fb17f9/image.png\" width=\"50%\">\n\n먼저, ```src/main/java/hello.hellospring``` 에 ```controller``` 라는 **Package**를 생성한다. 이후 ```HelloController``` 라는 **Class**를 생성한다.\n\n```java\n// HelloController\npackage hello.hellospring.controller;\n\nimport org.springframework.stereotype.Controller;\n\n@Controller\npublic class HelloController {\n    \n}\n```\n이때, ```@Controller``` 라는 **Annotation**이 필요한데, 이는 일종의 메타데이터로서, 컴파일러가 특정 오류를 억제하도록 지시하는 것과 같이 프로그램 코드의 일부가 아닌 프로그램에 관한 데이터를 제공, 코드에 정보를 추가하는데 사용된다. [참고](https://palyoung.tistory.com/72)\n\n```java\n@Controller\npublic class HelloController {\n\n    @GetMapping(\"hello\")\n    public String Hello(Model model) {\n\n    }\n}\n```\n\n클래스 안에 ```@GetMapping(\"hello\")``` 는 Web application에서 \"/hello\"가 들어오면, ```Hello(Model model)``` 을 실행하도록 한다. 여기서 model은 Model, View, Controller의 model이고, Get은 Get or Post method를 의미한다.\n\n```java\n@GetMapping(\"hello\")\npublic String Hello(Model model) {\n    model.addAttribute(\"data\", \"hello!!!\");\n    return \"hello\";\n}\n```\n\n```html\n<!-- resources/templates/hello.html -->\n<!DOCTYPE HTML>\n<html xmlns:th=\"http://www.thymeleaf.org\">\n<head>\n    <title>Hello</title>\n    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n</head>\n<body>\n    <p th:text=\"'안녕하세요. ' + ${data}\" >안녕하세요. 손님</p>\n</body>\n</html>\n```\n를 작성하도록 한다. 일단은 따라서 쳐보도록 하자.\n위 코드에서 ```th``` 라는 것을 볼 수 있는데, 이는 제일 윗 코드에서 선언한 ```xmlns:th=\"http://www.thymeleaf.org\"``` 를 의미하고, 이 선언으로 thymeleaf 문법을 사용할 수 있게 된 것이다.\n\n그리고 ```<p th:text=\"'안녕하세요. ' + ${data}\">안녕하세요. 손님</p>``` 에서 **data**는 아까 위의 ```HelloController``` 에서 작성한 ```model.addAttribute(\"data\", \"hello!!!\");``` 의 **data**를 의미한다. 이 메소드에서 **\"data\"는 attributeName**이고, **\"hello!!!\"는 attributeValue**가 된다. 이후 일단 서버를 재시작해보자.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/4a0e589d-b2e8-461a-840a-922330166e60/image.png\" width=\"70%\">\n위와 같이 /hello로 접속하게 되면, ${data}가 \"hello!!!\"로 치환된 것을 확인할 수 있다.\n\n<img src=\"https://images.velog.io/images/bsu1209/post/1a2948e3-36c9-4b08-9223-b3b00f218255/%E1%84%86%E1%85%AE%E1%84%8C%E1%85%A6.drawio%20(1).png\" width=\"80%\">\n\n- `localhost:8080/hello` 에 `GET` 방식으로 접근하게 되면, 생성한 `HelloController` 안의 statement들을 실행하게 된다.\n\t\n    - 이때, `return hello;` 에서 hello는 `templates/hello.html` 의 hello로 매칭되어 해당 html 파일을 렌더링하라는 의미이다. **(ViewName = hello)**\n    - SpringBoot는 기본적으로 `resources:templates/ + {ViewName} + .html` 파일을 찾는다.\n\n---\n\n## 🔍 빌드하고 실행하기\n**꼭 서버를 종료한 후,**\n\n1. `./gradlew build` → \"필요한 lib들을 다운받고 빌드가 수행\"<img src=\"https://images.velog.io/images/bsu1209/post/48e1f4b1-df00-4c2c-989f-1517a906d4a3/image.png\" width=\"50%\"> 이와 같이 뜨면 빌드가 성공된 것이다.\n2. `cd build/libs` → \"해당 폴더에 빌드된 `jar` 파일이 생성됨\"\n이는 스타터로 설정한 <a href=\"#packaging\">Packaging</a> 방식으로 인해 `jar` 파일이 생성된다.<img src=\"https://images.velog.io/images/bsu1209/post/08360dc5-5146-499b-9910-af1ff9188b35/image.png\" width=\"70%\"> 위와 같이 `hello-spring-0.0.1-SNAPSHOT-plain.jar` 이라는 파일도 같이 생성되는데, 이는 Spring-boot 2.5.0 이상부터 생성되는 듯하다. \n이를 없애려면, `build.gradle` 파일 안에 `jar { enabled = false }` 코드를 추가해주고 build를 수행하면 된다.\n3. `java -jar hello-spring-0.0.1-SNAPSHOT.jar`\n<img src=\"https://images.velog.io/images/bsu1209/post/58a7fe61-93dc-4b38-baa6-e44fe17ca62f/image.png\"> 서버가 가동되는 것을 확인할 수 있다.\n\n이제 빌드된 결과물인 `hello-spring-0.0.1-SNAPSHOT.jar` 만 파일만 실행시키면 서버가 동작할 수 있게 되었다.\n\n> `./gradlew clean`\n> : `build` 폴더가 삭제된다.\n> `./gradlew clean build`\n> : `build` 폴더를 삭제하고 새로 build 수행\n\n---\n\n## 📕 참고\n[스프링 입문-코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술](https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8)\n\n**Spring Boot DevTools**<br/>\n:파일 수정 이후 별도로 서버를 재시작할 필요 없이 변경 사항이 적용되도록 해주는 도구\n<img src=\"https://images.velog.io/images/bsu1209/post/6307ef88-1a2d-45ae-8359-c090b337f5c2/image.png\" width=\"80%\">\n\n```java\n// application.properties\nspring:\n    devtools:\n        restart:\n            enabled: true\n    thymeleaf:\n        cache: false\n        prefix: file:src/main/resources/templates/\n```\n\n`Preferences` → `Build, Execution, Deployment` → `Compiler` → `Build project automatically` check!"},{"excerpt":"문제 그래프를 DFS로 탐색한 결과와 BFS로 탐색한 결과를 출력하는 프로그램을 작성하시오. 단, 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하고, 더 이상 방문할 수 있는 점이 없는 경우 종료한다. 정점 번호는 1번부터 N번까지이다. 입력 첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M …","fields":{"slug":"/[BOJ]1260/"},"frontmatter":{"date":"December 29, 2021","title":"👩‍💻 1260. DFS와 BFS","tags":["그래프이론","그래프탐색","BFS","DFS"]},"rawMarkdownBody":"\n## 문제\n\n그래프를 DFS로 탐색한 결과와 BFS로 탐색한 결과를 출력하는 프로그램을 작성하시오. 단, 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하고, 더 이상 방문할 수 있는 점이 없는 경우 종료한다. 정점 번호는 1번부터 N번까지이다.\n\n### 입력\n- 첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다. 어떤 두 정점 사이에 여러 개의 간선이 있을 수 있다. 입력으로 주어지는 간선은 양방향이다.\n\n### 출력\n- 첫째 줄에 DFS를 수행한 결과를, 그 다음 줄에는 BFS를 수행한 결과를 출력한다. V부터 방문된 점을 순서대로 출력하면 된다.\n\n### 📍 **Logic**\n\n```java\nclass Graph {\n\tpublic ArrayList<ArrayList<Integer>> graph;\n    public boolean[] visited = new boolean[1001];\n    public StringBuilder path = new StringBuilder();\n}\n```\n\n- graph를 저장하기 위한 동적 2차원 배열\n- 정점에 대한 방문 여부 저장을 위한 `boolean` 배열\n- `DFS` 와 `BFS` 의 방문 순서를 저장하는 `stringBuilder`\n\n```java\npublic void dfs(int start) {\n\tif (!visited[start]) {\n\t\tpath.append(start);\n\t\tpath.append(\" \");\n\t\tvisited[start] = true;\n\t\tfor (int i = 0; i < graph.get(start).size(); i++) {\n\t\t\tif (!visited[graph.get(start).get(i)]) {\n\t\t\t\tthis.dfs(graph.get(start).get(i));\n\t\t\t}\n\t\t}\n\t}\n}\n```\n\n- 재귀 호출을 이용한 DFS 구현\n\n```java\npublic void bfs(int start) {\n\tQueue<Integer> q = new LinkedList<>();\n\tq.offer(start);\n\tvisited[start] = true;\n\tpath.append(\"\\n\");\n\tpath.append(start);\n\twhile (!q.isEmpty()) {\n\t\tint cur = q.poll();\n\t\tfor (int i = 0; i < graph.get(cur).size(); i++) {\n\t\t\tif (!visited[graph.get(cur).get(i)]) {\n\t\t\t\tvisited[graph.get(cur).get(i)] = true;\n\t\t\t\tpath.append(\" \");\n\t\t\t\tpath.append(graph.get(cur).get(i));\n\t\t\t\tq.offer(graph.get(cur).get(i));\n\t\t\t}\n\t\t}\n\t}\n}\n```\n\n- Queue를 이용한 BFS 구현\n\n```java\nfor (int i = 1; i <= n; i++) {\n\tCollections.sort(g.graph.get(i));\n}\n```\n\n- 번호가 낮은 정점부터 방문하라는 문제의 조건을 위한 정렬\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n\timport java.util.*;\n\n\tclass Graph {\n\t\tpublic ArrayList<ArrayList<Integer>> graph;\n\t\tpublic boolean[] visited = new boolean[1001];\n\t\tpublic StringBuilder path = new StringBuilder();\n\n\t\tpublic Graph(int size) {\n\t\t\tthis.graph = new ArrayList<ArrayList<Integer>>();\n\n\t\t\tfor (int i = 0; i < size + 1; i++) {\n\t\t\t\tgraph.add(new ArrayList<Integer>());\n\t\t\t}\n\t\t}\n\n\t\tpublic void DoubleAdd(int x, int y) {\n\t\t\tgraph.get(x).add(y);\n\t\t\tgraph.get(y).add(x);\n\t\t}\n\n\t\tpublic void dfs(int start) {\n\t\t\tif (!visited[start]) {\n\t\t\t\tpath.append(start);\n\t\t\t\tpath.append(\" \");\n\t\t\t\tvisited[start] = true;\n\t\t\t\tfor (int i = 0; i < graph.get(start).size(); i++) {\n\t\t\t\t\tif (!visited[graph.get(start).get(i)]) {\n\t\t\t\t\t\tthis.dfs(graph.get(start).get(i));\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpublic void bfs(int start) {\n\t\t\tQueue<Integer> q = new LinkedList<>();\n\t\t\tq.offer(start);\n\t\t\tvisited[start] = true;\n\t\t\tpath.append(\"\\n\");\n\t\t\tpath.append(start);\n\t\t\twhile (!q.isEmpty()) {\n\t\t\t\tint cur = q.poll();\n\t\t\t\tfor (int i = 0; i < graph.get(cur).size(); i++) {\n\t\t\t\t\tif (!visited[graph.get(cur).get(i)]) {\n\t\t\t\t\t\tvisited[graph.get(cur).get(i)] = true;\n\t\t\t\t\t\tpath.append(\" \");\n\t\t\t\t\t\tpath.append(graph.get(cur).get(i));\n\t\t\t\t\t\tq.offer(graph.get(cur).get(i));\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpublic StringBuilder getPath() {\n\t\t\treturn path;\n\t\t}\n\t}\n\n\tpublic class Main {\n\t\tpublic static void main(String[] args) {\n\t\t\tScanner sc = new Scanner(System.in);\n\t\t\tint n = sc.nextInt();\n\t\t\tint m = sc.nextInt();\n\t\t\tint start = sc.nextInt();\n\n\t\t\tGraph g = new Graph(n);\n\n\t\t\tfor (int i = 0; i < m; i++) {\n\t\t\t\tint a = sc.nextInt();\n\t\t\t\tint b = sc.nextInt();\n\n\t\t\t\tg.DoubleAdd(a,b);\n\t\t\t}\n\n\t\t\tfor (int i = 1; i <= n; i++) {\n\t\t\t\tCollections.sort(g.graph.get(i));\n\t\t\t}\n\n\t\t\tArrays.fill(g.visited,false);\n\t\t\tg.dfs(start);\n\n\t\t\tArrays.fill(g.visited,false);\n\t\t\tg.bfs(start);\n\n\t\t\tSystem.out.print(g.getPath().toString());\n\n\t\t\tsc.close();\n\t\t}\n\t}\n  \t</div>\n</details>\n\n### ✏️ **Review**\n\n- 성공했었다가 실패로 재채점되어 이번 기회에 `JAVA` 로 변환하면서 다시 푼 문제\n- `class Graph` 와 같이 클래스를 만드는 방식을 이용해 Graph와 관련된 처리들을 최대한 클래스 내부에서 구현하도록 했다.\n- 처음에는 `int[] path` 를 두 번 사용하여 `DFS` 의 결과를 출력하고, `BFS` 의 결과를 출력하는 방식으로 구현했었는데, 다른 방식을 찾아보다가 `StringBuilder` 클래스라는 것을 발견하여 이를 사용해보았다.\n  - `StringBuilder` : 여러 문자열을 붙이는 연산을 수행하는 경우 효율적인 클래스로, 해당 문제에서는 정점의 방문 순서를 순차적으로 저장하기 위해 사용했다.\n- 구현 방식은 틀린 것이 없어보였는데 자꾸 **틀렸습니다** 가 떠서 화가 날 때 즈음 발견한 한 반례로 디버깅을 해보니, 정렬 시 **반복 횟수가 1번** 모자란 것이었다. \n- 추가로, `visited` 배열을 `int` 로 한 경우와 `boolean` 으로 한 경우 시간과 메모리 차이가 존재했는데, `boolean` 의 메모리가 더 적고 시간이 감소했을거란 예상과는 달리, 메모리가 증가한 것을 확인했다. 아직 이유는 잘 모르겠다 ..\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/1260\n"},{"excerpt":"문제 차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에 효과적인 배추흰지렁이를 구입하기로 결심한다. 이 지렁이는 배추근처에 서식하며 해충을 잡아 먹음으로써 배추를 보호한다. 특히, 어떤 배추에 배추흰지렁이가 한 마리라도 살고 …","fields":{"slug":"/[BOJ]1012/"},"frontmatter":{"date":"December 28, 2021","title":"👩‍💻 1012. 유기농 배추","tags":["그래프이론","그래프탐색","BFS","DFS"]},"rawMarkdownBody":"\n## 문제\n\n차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에 효과적인 배추흰지렁이를 구입하기로 결심한다. 이 지렁이는 배추근처에 서식하며 해충을 잡아 먹음으로써 배추를 보호한다. 특히, 어떤 배추에 배추흰지렁이가 한 마리라도 살고 있으면 이 지렁이는 인접한 다른 배추로 이동할 수 있어, 그 배추들 역시 해충으로부터 보호받을 수 있다. 한 배추의 상하좌우 네 방향에 다른 배추가 위치한 경우에 서로 인접해있는 것이다.\n\n한나가 배추를 재배하는 땅은 고르지 못해서 배추를 군데군데 심어 놓았다. 배추들이 모여있는 곳에는 배추흰지렁이가 한 마리만 있으면 되므로 서로 인접해있는 배추들이 몇 군데에 퍼져있는지 조사하면 총 몇 마리의 지렁이가 필요한지 알 수 있다. 예를 들어 배추밭이 아래와 같이 구성되어 있으면 최소 5마리의 배추흰지렁이가 필요하다. 0은 배추가 심어져 있지 않은 땅이고, 1은 배추가 심어져 있는 땅을 나타낸다.\n\n|||||||||||\n|-|-|-|-|-|-|-|-|-|-|-|\n|1|1|0|0|0|0|0|0|0|0|\n|0|1|0|0|0|0|0|0|0|0|\n|0|0|0|0|1|0|0|0|0|0|\n|0|0|0|0|1|0|0|0|0|0|\n|0|0|1|1|0|0|0|1|1|1|\n|0|0|0|0|1|0|0|1|1|1|\n\n### 입력\n- 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트 케이스에 대해 첫째 줄에는 배추를 심은 배추밭의 가로길이 M(1 ≤ M ≤ 50)과 세로길이 N(1 ≤ N ≤ 50), 그리고 배추가 심어져 있는 위치의 개수 K(1 ≤ K ≤ 2500)이 주어진다. 그 다음 K줄에는 배추의 위치 X(0 ≤ X ≤ M-1), Y(0 ≤ Y ≤ N-1)가 주어진다. 두 배추의 위치가 같은 경우는 없다.\n\n### 출력\n- 각 테스트 케이스에 대해 필요한 최소의 배추흰지렁이 마리 수를 출력한다.\n\n### 📍 **Logic**\n\n```java\nclass Pair {\n    private int first;\n    private int second;\n\n    Pair(int x, int y) {\n        this.first = x;\n        this.second = y;\n    }\n\n    public int getF() {\n        return first;\n    }\n\n    public int getS() {\n        return second;\n    }\n}\n```\n- `Pair` 의 구현을 위해 위와 같은 **class** 를 생성했다.\n\n```java\nfor (int a = 0; a < worm.size(); a++) {\n    int vF = worm.get(a).getF();\n    int vS = worm.get(a).getS();\n    if (visited[vF][vS] == 0) {\n        Queue<Pair> q = new LinkedList<>();\n        q.offer(worm.get(a));\n        visited[vF][vS] = 1;\n        while (!q.isEmpty()) {\n            Pair cur = q.poll();\n            for (int i = 0; i < 4; i++) {\n                int nx = cur.getF() + x_ary[i], ny = cur.getS() + y_ary[i];\n                if (nx >= 0 && ny >= 0 && nx < M && ny < N) {\n                    if (visited[nx][ny] == 0 && map[nx][ny] == 1) {\n                        visited[nx][ny] = 1;\n                        q.offer(new Pair(nx, ny));\n                    }\n                }\n            }\n        }\n        worms++;\n    }\n}\n```\n- 배추의 위치 및 방문 여부를 사용해 배추흰지렁이가 이동할 수 있는 배추의 위치를 `Queue` 에 `DFS` 방식으로 추가한다.\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\">\n\n        import java.util.*;\n\n        public class Main {\n            public static void main(String[] args) {\n                Scanner sc = new Scanner(System.in);\n                int T = sc.nextInt();\n                int[] x_ary = {0, 0, -1, 1};\n                int[] y_ary = {-1, 1, 0, 0};\n                int[][] map = null;\n                int[][] visited = null;\n                visited = new int[50][50];\n\n                while (T > 0) {\n                    int M = sc.nextInt();\n                    int N = sc.nextInt();\n                    int K = sc.nextInt();\n                    int worms = 0;\n\n                    map = new int[M][N];\n                    ArrayList<Pair> worm = new ArrayList<>();\n\n                    for (int[] tmp : visited)\n                        Arrays.fill(tmp, 0);\n\n                    for (int i = 0; i < K; i++) {\n                        int x = sc.nextInt();\n                        int y = sc.nextInt();\n                        map[x][y] = 1;\n                        worm.add(new Pair(x, y));\n                    }\n\n                    for (int a = 0; a < worm.size(); a++) {\n                        int vF = worm.get(a).getF();\n                        int vS = worm.get(a).getS();\n                        if (visited[vF][vS] == 0) {\n                            Queue<Pair> q = new LinkedList<>();\n                            q.offer(worm.get(a));\n                            visited[vF][vS] = 1;\n                            while (!q.isEmpty()) {\n                                Pair cur = q.poll();\n                                for (int i = 0; i < 4; i++) {\n                                    int nx = cur.getF() + x_ary[i], ny = cur.getS() + y_ary[i];\n                                    if (nx >= 0 && ny >= 0 && nx < M && ny < N) {\n                                        if (visited[nx][ny] == 0 && map[nx][ny] == 1) {\n                                            visited[nx][ny] = 1;\n                                            q.offer(new Pair(nx, ny));\n                                        }\n                                    }\n                                }\n                            }\n                            worms++;\n                        }\n                    }\n\n                    System.out.println(worms);\n                    T -= 1;\n                }\n                sc.close();\n            }\n        }\n        class Pair {\n            private int first;\n            private int second;\n\n            Pair(int x, int y) {\n                this.first = x;\n                this.second = y;\n            }\n\n            public int getF() {\n                return first;\n            }\n\n            public int getS() {\n                return second;\n            }\n        }\n  </div>\n</details>\n\n### ✏️ **Review**\n\n- `c++` 로 풀었던 문제를 `java` 로 변환하여 다시 풀어본 문제\n- 논리 자체는 기본적인 DFS를 사용한 문제여서 `java` 문법을 오랜만에 다시 써본 문제였다.\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/1012\n"},{"excerpt":"📖 그래프 계층적인 구조보다 좀 더 일반적이고 강력한 자료 구조, 사물이나 개념 간의 연결 구조\nex. 여러 도시들을 연결하는 도로망, 사람들 간의 지인 관계, 웹 사이트 간의 링크 트리에 있었던 부모 자식 관계에 대한 제약이 없어 좀 더 다양하고 자유로운 구조 표현이 가능하다. 💡 정의 그래프 G(V, E)는 어떤 자료나 개념을 표현하는 정점(verte…","fields":{"slug":"/[Algorithm]graph/"},"frontmatter":{"date":"December 28, 2021","title":"💡 Graph 이론","tags":["종만북","Graph","DFS","BFS"]},"rawMarkdownBody":"\n# 📖 그래프\n\n계층적인 구조보다 좀 더 일반적이고 강력한 자료 구조, 사물이나 개념 간의 연결 구조\nex. 여러 도시들을 연결하는 도로망, 사람들 간의 지인 관계, 웹 사이트 간의 링크\n\n**트리**에 있었던 부모 자식 관계에 대한 제약이 없어 좀 더 다양하고 자유로운 구조 표현이 가능하다.\n\n---\n\n## 💡 정의\n그래프 G(V, E)는 어떤 자료나 개념을 표현하는 정점(vertex)들의 집합 V와 이들을 연결하는 간선(edge)들의 집합 E로 구성된 자료 구조\n\n* 정점의 위치 정보나 간선의 순서 등은 그래프의 정의에 포함되지 않는다.\n\n---\n\n## 💡 종류\n표현하고자 하는 대상에 따라 여러 가지 변형된 형태를 가질 수 있다.\n\n### 방향 그래프(directed graph) or 유향 그래프\n각 간선이 “방향” 이라는 새로운 속성을 가진다. 즉, 방향에 따라 새로운 간선으로 분류된다. \nex. 사람들 간의 짝사랑 관계, 도로에서의 일방 통행 등\n\n> **무향 그래프(undirected graph)**\n> 간선에 방향이 없는 그래프\n\n### 가중치 그래프(weighted graph)\n각 간선에 “가중치” 라는 실수 속성이 추가된다. \nex. 두 도시 사이의 거리, 두 물건 사이의 교환 비율 등\n\n> 최소 스패닝 트리와 최단 경로 문제에서 중요한 개념으로 사용된다!\n\n### 다중 그래프(multigraph)\n두 정점 사이에 두 개 이상의 간선이 있을 수 있는 그래프\n\n### 단순 그래프(simple graph)\n두 정점 사이에 최대 한 개의 간선만 있는 그래프\n\n> 📍 트리 or 루트 없는 트리(unrooted tree)는 부모 자식 관계가 없을 뿐, 간선들의 연결 관계만을 보면 **무향 그래프**이다.\n> 즉, 간선을 통해 두 정점을 잇는 방법이 딱 하나뿐임을 의미한다.\n\n### 이분 그래프(bipartite graph)\n그래프의 정점들을 겹치지 않는 두 개의 그룹으로 나눠서 서로 다른 그룹에 속한 정점들 간에만 간선이 존재하도록 만들 수 있는 그래프 \nex. 하트 시그널과 같은 프로그램에서의 사랑의 작대기\n* 같은 그룹의 정점들 간에는 간선이 없다.\n\n### 사이클 없는 방향 그래프(directed acyclic graph) = DAG\n한 점에서 출발해 다시 자기 자신으로 돌아오는 경로가 없는, 즉 **cycle이 없는** 방향 그래프 \nex. 여러 작업들 간의 상호 의존 관계\n* 간선의 방향을 무시할 경우 cycle이 존재할 수도 있다.\n\n---\n\n## 💡 경로\n끝과 끝이 서로 연결된 간선들을 순서대로 나열한 것\n\n### 단순 경로\n경로 중 한 정점을 최대 한 번만 지나는 경로\n\n### 사이클(cycle)\n시작한 점에서 끝나는 경로\n\n---\n\n## 💡 표현 방법\n여러 객체들이 서로 연결되어 있다는 점은 트리와 큰 차이가 없다.\n\n* 각 정점을 객체로 표현\n* 각 객체가 자신과 간선으로 연결된 정점들에 대한 정보의 목록을 저장\n\n**대다수의 경우, 그래프는 트리에 비해 훨씬 정적인 용도로 사용된다.**\n* 새로운 정점이나 간선을 추가하고 삭제하는 일이 자주 일어나지 않는다는 의미\n* 따라서, 구조의 변경이 어렵더라도 **좀 더 간단하고 메모리를 적게 차지하는 방법으로 구현**한다.\n\n### 간단한 방법\n1. 그래프의 정점들을 객체의 instance로 표현하는 대신 각 정점에 0부터 시작하는 번호를 붙이고,\n2. 배열에 각 정점의 정보를 저장\n3. 간선은 반대쪽 정점의 번호를 저장하는 방식으로 구현\n\n### 인접 리스트\n그래프의 각 정점마다 해당 정점에서 나가는 간선이 목록을 저장하는 방식\n→ **그래프는 각 정점마다 하나의 연결 리스트를 갖는 방식으로 구현**\n\n**`Java`** ⇢ List 내부에 동적 List를 선언하여 처리하고 해당 node와 cost를 List처럼 처리하는 경우가 많기 때문에, 이를 관리하기 위한 Class를 선언하여 사용한다.\n\n```java\nclass Node {\n\tint node;\n\tint cost;\n\t\n\tNode (int node, int cost) {\n\t\tthis.node = node;\n\t\tthis.cost = cost;\n\t}\n}\n```\n\n> **단점**\n> 두 정점이 주어질 때 이 정점이 연결되어 있는지를 알기 위해서는 모든 연결 리스트를 일일이 탐색해야 한다는 것\n> → 이와 같은 연산속도를 높이기 위해 **인접 행렬 (adjacency matrix)** 표현 방식을 사용\n\n### 인접 행렬\n2차원 배열을 이용해 그래프의 간선 정보를 저장 \nex. 1 → 2 ⇢ `graph[1][2] = true or cost`\n→ 가장 간단한 형태의 경우, 2차원 `boolean` 값 배열\n\n### 두 방식의 비교\n두 방식은 정반대의 특징을 가져, 서로의 단점이 서로의 장점이 된다.\n**메모리 공간 측면**과 **탐색 시간 측면**으로 나뉜다.\n\n#### 인접 리스트의 장점\n* |V| 개의 연결 리스트에 실제 간선 수만큼의 원소만 존재하기에 O(|V|+|E|) 크기의 공간만 사용한다.\n#### 인접 리스트의 단점\n* 정점의 번호가 주어진 경우, 두 정점을 잇는 간선의 존재를 알기 위해서는 모든 연결 리스트를 탐색해야 한다.\n#### 인접 행렬의 장점\n* 정점의 번호가 주어진 경우, 두 정점을 잇는 간선의 존재를 한 번의 배열 접근만으로 알 수 있다.\n#### 인접 행렬의 단점\n* 항상 정점 집합 전체를 저장하기 위한 2차원 배열을 사용하기 때문에, 항상 O(|V|^2) 크기의 공간을 사용해야 한다. \n\n> 간선의 수가 |V|^2에 비해 훨씬 적은 그래프: 희소 그래프(sparse graph) ⇢ 인접 리스트\n> 간선의 수가 |V|^2에 거의 비례하는 그래프: 밀집 그래프(dense graph) ⇢ 인접 행렬\n\n---\n\n## 📖 깊이 우선 탐색 (DFS)\n그래프의 모든 정점을 발견하는 가장 단순하고 고전적인 방법으로, 현재 정점에서 다음 가지로 넘어가기 전에, **해당 가지를 모두 탐색하는 방법**이다.\n1. 현재 정점과 인접한 간선들을 하나씩 검사\n2. 아직 방문하지 않은 정점으로 향하는 간선이 있다면 그 간선을 탐색\n3. 더 이상 갈 곳이 없는 경우, 마지막에 따라왔던 간선을 따라 뒤로 돌아감\n\nDFS에서 가장 중요한 특징은 **3번**이다.\n이를 위해서 지금까지 거쳐온 정점들을 저장해야 하는데, **재귀 호출**을 이용하여 간단하게 구현할 수 있다.\n\n> **주의할 점**\n> 그래프의 모든 정점들이 간선으로 연결되지 않은 경우가 있을 수 있다.\n> 이때도 모든 정점들을 볼 수 있는 코드를 작성할 수 있어야 한다.\n\n### 💡 시간 복잡도\n#### 인접 리스트를 사용하는 경우\n* 한 정점마다 `DFS()` 는 한 번씩 호출 → |V| 번\n* O(|V| + |E|)\n\n#### 인접 행렬을 사용하는 경우\n* `DFS()` 의 호출횟수는 인접 리스트와 동일하게 |V| 번\n* 다른 모든 정점을 순회하며 두 정점 사이에 간선이 있는가를 확인하므로 한 번에 O(|V|) 시간이 소모\n* O(|V|^2)\n\n### 💡 위상 정렬\n의존성이 있는 작업들이 주어질 때, 이들을 어떤 순서로 수행해야 하는지 계산\n\n**의존성 그래프(dependency graph)**\n각 작업을 정점으로 표현하고, 작업 간의 의존 관계를 간선으로 표현한 방향 그래프\n→ cycle이 없는 방향 그래프, 즉 DAG\n\n#### 위상 정렬\n의존성 그래프의 모든 의존성이 만족되려면, 모든 간선이 왼쪽에서 오른쪽으로 가야 하는데, 이를 위해 **DAG의 정점을 배열하는 문제**\n\n**직관적인 방법**\n* 들어오는 간선이 하나도 없는 정점을 탐색\n* 정렬 결과에 이어 붙이기\n* 그래프에서 해당 정점을 삭제\n위 과정을 반복\n\n이를 `DFS` 를 이용해 해결할 수 있다.\n* 한 정점에 대한 `DFS()` 가 종료될 때마다 현재 정점의 번호를 기록\n* 모든 탐색이 끝난 후, 정점 번호들을 뒤집으면 위상 정렬 결과\n\n### 💡 이론적 배경과 응용\n#### 깊이 우선 탐색과 간선의 분류\n깊이 우선 탐색을 수행하면 그 과정에서 그래프의 모든 간선을 한 번씩은 만나게 되는데, 일부 간선만이 처음 발견한 정점과 연결되어 있기에 이를 따라가게 된다.\n! 하지만 여기서, 무시되는 간선들을 통해 그래프의 구조에 대한 정보를 알 수 있다.\n\n어떠한 그래프에 대한 깊이 우선 탐색 시, 탐색이 따라가는 일부 간선들만 모아보면 **“트리”** 형태를 띄게 된다.\n→ 이와 같이 얻어진 트리를 **깊이 우선 탐색 스패닝 트리** 혹은 **DFS 스패닝 트리** 라고 한다.\n\n**간선의 분류**\n* 트리 간선(tree edge) : 스패닝 트리에 포함된 간선\n* 순방향 간선(forward edge) : 스패닝 트리의 선조에서 자손으로 연결되었지만 트리 간선이 아닌 간선\n* 역방향 간선(back edge) : 스패닝 트리의 자손에서 선조로 연결되는 간선\n* 교차 간선(cross edge) : 위의 세 간선이 아닌 간선, 선조와 자손 관계가 아닌 정점들 간 연결된 간선\n\n> **어떠한 순서로 정점을 방문하느냐**에 따라 서로 다른 트리가 될 수도 있고, 간선에 대한 분류가 달라질 수도 있다.\n\n**무향 그래프 간선의 분류**\n무향 그래프의 모든 간선은 양방향으로 통행 가능하기 때문에 **교차 간선이 있을 수 없다.**\n또한, 순방향 간선과 역방향 간선의 구분도 존재하지 않는다.\n\n> **사이클 존재 여부 확인**\n> 간선 구분을 이용하여 방향 그래프에서 사이클이 존재하는지 여부를 판단할 수 있다.\n> → 역방향 간선의 존재 여부와 동일한 문제\n\n##### 간선을 구분하는 방법\n가장 구분하기 쉬운 간선은 트리 간선이다.\n간선 (u, v)를 검사했을 때, v가 방문된 적이 없다면 이는 “트리 간선”이 된다.\n하지만 v가 방문된 이후였다면, 부모인지 자손인지 알 수 있는 방법이 없다.\n그래서 추가적인 정보를 저장하고 이를 통해 부모 자손 관계를 파악할 수 있어야 한다.\n* 각 정점을 방문할 때, 이 정점이 방문되었다는 사실 = `visited`\n* 이 정점이 몇번째로 발견되었는지 = `discovered`\n\n**간선 (u, v)에서 u와 v의 방문 순서**\n* 순방향 간선이라면, v는 u의 자손이어야 한다.\n* 역방향 간선이라면, v는 u의 선조여야 한다.\n* 교차 간선이라면, dfs(v)가 종료한 후 dfs(u)가 호출되어야 한다.\n\n위 경우 중, 발견 순서 정보를 토대로 순방향 간선에 대한 구분은 가능하지만, 역방향 간선과 교차 간선에 대한 구분은 여전히 불가능하다.\n그래서, **dfs(v)의 종료 여부** 또한 확인해주어야 한다.\n\n---\n\n## 📖 너비 우선 탐색 (BFS)\n깊이 우선 탐색과 함께 가장 널리 사용되는 그래프 탐색 알고리즘으로, \"다익스트라의 최단 거리 알고리즘\"이나 \"프림의 최소 스패닝 트리 알고리즘\" 등에 사용된다.\n\n**”시작점에서 최소 거리 기준으로 가까운 정점부터 순서대로 방문하는 탐색 알고리즘”으로, 최소 비용을 구할 때 적합하다.**\n\n1. 각 정점을 방문할 때마다 모든 인접 정점들을 검사\n2. 이 중 처음 보는 정점을 발견하면 방문 예정이라고 기록하고 별도의 위치에 저장(`Queue`)\n3. 인접한 정점을 모두 검사하고 나면, 지금까지 저장한 목록에서 다음 정점을 꺼내서 방문\n\n> 너비 우선 탐색의 방문 순서는 **정점의 목록에서 어떤 정점을 먼저 꺼내는지에 의해 결정**\n\n위에서 언급한 **“별도의 위치”** 는 먼저 들어온 정점을 먼저 꺼내야 하는 특성을 가져야 하므로, **`Queue`** 를 사용하여 해당 조건을 만족시킨다.\n\n깊이 우선 탐색과 달리 너비 우선 탐색에서는 발견과 방문이 같지 않다.\n따라서 모든 정점은 \n* 아직 발견되지 않은 상태\n* 발견되었지만 아직 방문되지는 않은 상태 (`Queue` 에 저장된 상태)\n* 방문된 상태\n로 3가지 상태를 가질 수 있다.\n\n깊이 우선 탐색에서처럼, 새 정점을 발견하는 데 사용했던 간선들만을 모은 트리를 **너비 우선 탐색 스패닝 트리(BFS Spanning Tree)**라고 한다.\n\n### 💡 시간 복잡도\n모든 정점을 한 번씩 방문하며, 정점을 방문할 때마다 인접한 모든 간선을 검사하기 때문에, **깊이 우선 탐색과 동일**하다.\n\n### 💡 너비 우선 탐색과 최단 거리\n**그래프에서의 최단 경로 문제를 해결**하는데 주로 사용된다.\n\n너비 우선 탐색 알고리즘을 간단하게 변경해 모든 정점에 대해 시작점으로부터의 거리 `distance[]` 를 계산하도록 할 수 있다.\n* 탐색 과정에서 간선 (u, v)를 통해 정점 v를 처음 발견해 `Queue` 에 넣는다고 가정\n* 시작점으로부터 v까지의 최단 거리 `distance[v]` 는 시작점으로부터 u까지의 최단 거리 `distance[u]` +1\n이는 곧 시작점으로부터 다른 모든 정점까지의 최단 경로를 너비 우선 탐색 스패닝 트리 (BFS Spanning Tree) 에서 찾을 수 있다는 것을 의미한다.\n\n### 💡 양방향 탐색\n두 정점 사이의 최단 경로를 찾을 때 사용할 수 있는 테크닉\n시작 정점에서 시작하는 **정방향 탐색**과 목표 정점에서 시작해 거꾸로 올라오는 **역방향 탐색**을 동시에 하면서, 이 둘이 가운데서 만나면 종료\n\n이를 코드로 구현하려면,\n정방향과 역방향 탐색에서 방문해야 할 정점들을 모두 같은 `Queue` 에 저장하되, 최단 거리를 저장할 때 정방향은 **양수**, 역방향은 **음수**로 저장한다.\n인접한 상태 검사 시, 서로 부호가 다르다면 가운데서 만났음을 파악할 수 있다.\n\n양방향 탐색은 너비 우선 탐색보다 훨씬 적은 정점만을 방문하고도 최단 경로를 찾을 수 있어 **메모리 사용량이 훨씬 적다.**\n하지만 이를 사용할 수 없는 경우나, 목표 정점까지의 최단 거리가 너무 커서 양방향 탐색으로도 최단 경로를 찾을 수 없는 경우는 어떻게 해야 할까?\n\n### 💡 점점 깊어지는 탐색\n= Iteratively Deepening Search = IDS\n\n* 임의의 깊이 제한 l을 정한 후 이 제한보다 짧은 경로가 존재하는지를 **깊이 우선 탐색**으로 확인\n* 답을 찾으면 성공, 이를 반환\n* 답을 찾지 못하면 l을 늘려서 다시 시도\n\n이는 **“조합 탐색”** 과 관련이 깊다.\n\n### 💡 탐색 방법 선택하기\n1. 상태 공간에서의 최단 경로를 찾는 경우,\n**너비 우선 탐색**을 우선적으로 고려 (직관적이고 구현도 간단)\n탐색의 깊이 한계가 정해져 있지 않거나 너무 깊어 메모리 사용량이 너무 크지 않은지에 대한 확인이 필요\n2. 상태 공간에서의 최단 경로를 찾는데, 탐색의 최대 깊이가 정해져 있고 너비 우선 탐색을 하기에는 메모리와 시간이 부족할 경우,\n**양방향 탐색**을 고려\n목표 상태에서 역방향으로 움직이기가 쉬어야 한다.\n3. 두 탐색이 모두 너무 메모리를 많이 사용하거나 너무 느린 경우,\n최적화를 할 거리가 더 많은 **점점 깊어지는 탐색**을 사용\n\n---\n\n### 📕 참고\n* 프로그래밍 대회에서 배우는 알고리즘 문제해결전략_구종만\n* [Java그래프의 표현 :: TH](https://sskl660.tistory.com/60)"},{"excerpt":"문제 0부터 N까지의 정수 K개를 더해서 그 합이 N이 되는 경우의 수를 구하는 프로그램을 작성하시오. 덧셈의 순서가 바뀐 경우는 다른 경우로 센다(1+2와 2+1은 서로 다른 경우). 또한 한 개의 수를 여러 번 쓸 수도 있다. 입력 첫째 줄에 두 정수 N(1 ≤ N ≤ 200), K(1 ≤ K ≤ 200)가 주어진다. 출력 첫째 줄에 답을 1,000,…","fields":{"slug":"/[BOJ]2225/"},"frontmatter":{"date":"December 22, 2021","title":"👩‍💻 2225. 합분해","tags":["DP","수학"]},"rawMarkdownBody":"\n## 문제\n\n0부터 N까지의 정수 K개를 더해서 그 합이 N이 되는 경우의 수를 구하는 프로그램을 작성하시오.\n\n덧셈의 순서가 바뀐 경우는 다른 경우로 센다(1+2와 2+1은 서로 다른 경우). 또한 한 개의 수를 여러 번 쓸 수도 있다.\n\n### 입력\n- 첫째 줄에 두 정수 N(1 ≤ N ≤ 200), K(1 ≤ K ≤ 200)가 주어진다.\n\n### 출력\n- 첫째 줄에 답을 1,000,000,000으로 나눈 나머지를 출력한다.\n\n### 📍 **Logic**\n\n```java\nfor (int i=0; i<201 ;i++) {\n  dp[i][0] = 1;\n  dp[1][i] = 1;\n}\n\nfor (int i=0;i<=N;i++)\n  dp[2][i] = i+1;\n```\n\n- dp 배열 초기화\n- i개의 정수로 j를 만드는 경우의 수가 dp[i][j]에 저장\n\n```java\nfor (int i=3;i<=K;i++) {\n  for (int j=1;j<=N;j++) {\n    for (int k=0;k<=j;k++) {\n        dp[i][j] += dp[i-1][k]%1000000000;\n    }\n  }\n}\n```\n\n- 점화식은 예를 들어, dp[3][1]을 구하는 경우, 즉 3개의 정수로 1을 만들어야 하는 경우의 수는 dp[2][0] + dp[2][1]로, 2개의 정수로 0을 만드는 경우의 수와 2개의 정수로 1을 만드는 경우의 수를 더하면 된다\n- 따라서, dp[i][j] = dp[i-1][0] + ... + dp[i-1][j]가 된다\n\n### 📄 **CODE**\n\n<details>\n  <summary>코드 보기/접기💫</summary>\n    <div markdown=\"1\" data-language=\"java\">\n\n        import java.io.BufferedReader;\n        import java.io.InputStreamReader;\n        import java.util.StringTokenizer;\n\n        public class Main {\n\n            static long dp[][] = new long[201][201];\n\n            public static void main(String[] args) throws Exception {\n                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n                String tc = br.readLine();\n                StringTokenizer st = new StringTokenizer(tc, \" \");\n                int N = Integer.parseInt(st.nextToken());\n                int K = Integer.parseInt(st.nextToken());\n\n                for (int i=0; i<201 ;i++) {\n                    dp[i][0] = 1;\n                    dp[1][i] = 1;\n                }\n                for (int i=0;i<=N;i++)\n                    dp[2][i] = i+1;\n\n                for (int i=3;i<=K;i++) {\n                    for (int j=1;j<=N;j++) {\n                        for (int k=0;k<=j;k++) {\n                            dp[i][j] += dp[i-1][k]%1000000000;\n                        }\n                    }\n                }\n\n                System.out.println(dp[K][N]%1000000000);\n            }\n        }\n  </div>\n</details>\n\n### ✏️ **Review**\n\n- 오랜만에 알고문제를 푸는 터라 아이디어를 잡는데 한참 걸렸던 것 같다\n- 막상 점화식을 도출해내면 쉬운 문제였지만 점화식 도출이 어려웠고, 처음으로 java로 푼 문제여서 블로그를 참고했다\n\n### 📕 출처\nhttps://www.acmicpc.net/problem/2225"}]}},"pageContext":{}},"staticQueryHashes":[]}