Merge pull request #17 from theintrance/hyunwook/2024-11-06

Hyunwook/2024-11-06

Author: BayernMuller

chapter6/6_7_이_모든_것을_테스트로_해결할_수는_없는가.mdx

@@ -0,0 +1,15 @@
+---
+title: '이 모든 것을 테스트로 해결할 수는 없는가?'
+author: 'hyunwok'
+---
+
+- 테스트가 모든 문제를 잡아낼 것이기 떄문에 코드 품질 향상 노력은 시간 낭비라는 주장을 하는 개발자들이 가끔 있다.
+- 필자의 경험으로는, 이것은 현실에서는 별로 효과가 없는 다소 이상주의적인 주장이다.
+- 코드를 작성할 때는 모든 테스트 케이스를 다 처리하고 테스트 관련 지식이 풍부하며 코드에 대한 모든 올바른 행동과 가정을 확인하는, 거의 완벽한 테스트 코드를 작성할 수 있다
+    - 어떤 개발자들은 테스트에 대해 그다지 부지런하지 않을 수도 있다
+        - 가정한 것이 틀렸다는 것을 드러내기 위한 충분한 시나리오나 코너 케이스를 테스트하지 않는다.
+    - 테스트가 항상 실제 상황을 정확하게 시뮬레이션하는 것은 아니다.
+        - 코드를 테스트할 때는 Mock 객체를 통해 테스트할 때도 있는데, Mock 객체의 행동의 가정과 예측을 벗어나는 동작을 개발자가 깨닫지 못한다면 버그를 찾아내기 힘들다.
+    - 어떤 것들은 테스트하기가 매우 어렵다.
+- 아무리 많은 코드 구조화나 코드 계약에 대한 걱정도 고품질의 철저한 테스트를 대체할 수 없기에 매우 중요하다.
+- 그 반대로, 직관적이지 않거나 예상을 벗어나는 코드에 숨어 있는 오류를 테스트만으로는 방지하기 어렵다.

chapter7/7_1_불변_객체로_만드는_것을_고려하라.mdx

@@ -0,0 +1,223 @@
+---
+title: '불변 객체로 만드는 것을 고려하라'
+author: 'hyunwok'
+---
+
+- 객체가 생성된 후에 상태를 바꿀 수 없다면 이 객체는 불변(불가변)이고, 그 반대는 가변이다.
+- 가변 객체의 문제점들
+    - 가변 객체는 추론하기 어렵다.
+        - 가변 객체는 변질 방지 봉인이 없는 상자이기에, 객체를 여기저기 전달하면 변경됐거나 무언가 추가되지 않았다는 확신을 할 수 없다.
+    - 가변 객체는 다중 스레드에서 문제가 발생할 수 있다.
+        - 6장에서 보았던 것처럼, 객체가 가변적이라면 해당 객체를 사용하는 다중 슬레드 코드가 특히 취약할 수 있다.
+- 가변 객체가 필요한 경우도 존재하지만, 코드의 복잡성을 늘리고 문제를 일으킬 수 있기에 필요한 곳에서만 가변적이 되도록 하는 것이 바람직하다.
+
+### 7.1.1 가변 클래스는 오용하기 쉽다. 
+- 클래스를 가변적으로 만드는 가장 일반적인 방법은 세터 함수를 제공하는 것이다.
+
+```java
+class TextOptions {
+    private Font font;
+    private Double fontSize;
+
+    TextOptions(Font font, Double fontSize) {
+        this.font = font;
+        this.fontSize = fontSize;
+    }
+
+    void setFont(Font font) { // 폰트는 이 함수를 호출하여 언제든지 변경가능
+        this.font = font;
+    }
+
+    void setFontSize(Double fontSize) { // 폰트 사이즈 또한 언제든지 변경가능
+        this.fontSize = fontSize;
+    }
+
+    Font getFont() {
+        return font;
+    }
+
+    Double getFontSize() {
+        return fontSize;
+    }
+}
+```
+
+```java incorrect
+class UserDisplay { 
+    private final MessageBox messageBox;
+    
+    void sayHello() {
+        TextOptions defaultStyle = new TextOptions(Font.ARIAL, 12.0); // 폰트 사이즈를 12로 설정 후 인스턴스 생성
+        messageBox.renderTitle("Important message", defaultStyle);
+        messageBox.renderMessage("Hello", defaultStyle);
+    }
+}
+
+class MessageBox {
+    private final TextField titleField;
+    private final TextField messageField;
+
+    void renderTitle(String title, TextOptions baseStyle) {
+        baseStyle.setFontSize(18.0); // 18로 폰트 사이즈를 변경함
+        titleField.display(title, baseStyle);
+    }
+
+    void renderMessage(String message, TextOptions style) {
+        messageField.display(message, style);
+    }
+}
+```
+
+### 7.1.2 해결책: 객체를 생성할 때만 값을 할당하라
+- 모든 값이 객체의 생성 시에 제공되고 그 이후로는 변경할 수 없도록 함으로써 클래스를 불변적으로 만들 수 있고 오용도 방지할 수 있다.
+- 클래스 내에서 변수를 정의할 떄 클래스 내에서도 변수의 값이 변경되지 않도록 할 수 있다.
+    - 언어에 따라 const, final, readonly등이 있다.
+
+```java correct
+class TextOptions {
+    private final Font font;
+    private final Double fontSize;
+
+    TextOptions(Font font, Double fontSize) {
+        this.font = font;
+        this.fontSize = fontSize;
+    }
+
+    Font getFont() {
+        return font;
+    }
+
+    Double getFontSize() {
+        return fontSize;
+    }
+}
+```
+
+- 여기에 추가적으로 TextOptions 객체애 대해서 글꼴 크기만 재정의할 수 있는 방법이 필요한데 이것을 위해 쓰기 시 복사 패턴을 사용할 수 있다.
+```java correct
+class MessageBox {
+    private final TextField titleField;
+    private final TextField messageField;
+
+    void renderTitle(String title, TextOptions baseStyle) {
+        titleField.display(title, baseStyle.withFontSize(18.0));
+    }
+}
+```
+
+### 7.1.3 해결책: 불변성에 대한 디자인 패턴을 사용하라 
+- 세터 함수 제거, 멤버 변수를 파이널로 표시하면 클래스가 불변적으로 되지만 별로 쓸모없어질 수 있다.
+- 일부값이 반드시 필요하지 않거나 불변적인 클래스의 가변적 버전을 만들어야 하는 경우, 클래스를 두 가지 유용한 디자인 패턴을 통해 다용도로 구현할 수 있다.
+    - 빌터 패턴
+    - 쓰기 시 복사 패턴
+
+#### 빌더패턴
+- 클래스를 구성할 수 있는 일부 값이 선택 사항인 경우 생성자를 통해 해당 값을 모두 설정하는 것은 상당히 까다롭기에, 이 경우 세터 함수보단 빌더 패턴이 낫다.
+- 빌더 패턴은 한 클래스를 두 개로 나누는 효과를 갖는다
+    - 값을 하나씩 설정할 수 있는 빌더 클래스
+    - 빌더에 의해 작성된 불변적인 읽기 전용 클래스
+
+```java
+class TextOptions {
+    private final Font font;
+    private final Double fontSize;
+
+    TextOptions(Font font, Double fontSize) {
+        this.font = font;
+        this.fontSize = fontSize;
+    }
+
+    Font getFont() { // 게터 함수만 갖음
+        return font;
+    }
+
+    Double getFontSize() {
+        return fontSize;
+    }
+}
+
+class TextOptionsBuilder {
+    private final Font font;
+    private Double fontSize;
+
+    TextOptionsBuilder(Font font) { // 생성자를 통해 필수 값 전달 받음
+        this.font = font;
+    }
+
+    TextOptionsBuilder setFontSize(Double fontSize) { // 세터 함수를 통해 필수적이지 않은 값 받음
+        this.fontSize = fontSize;
+        return this;
+    }
+
+    TextOptions build() { // 다 정해진 후 호출쪽에서 build 호출
+        return new TextOptions(font, fontSize);
+    }
+}
+```
+
+- 인스턴스를 생성하는 예시
+
+```java correct
+// 폰트 사이즈 설정 O
+TextOptions getDefaultTextOptions() {
+    return new TextOptionsBuilder(Font.ARIAL)
+        .setFontSize(12.0) 
+        .build();
+}
+
+// 폰트 사이즈 설정 X
+TextOptions getDefaultTextOptions() {
+    return new TextOptionsBuilder(Font.ARIAL)
+        .build();
+}
+```
+
+#### 쓰기 시 복사 패턴
+- 클래스의 인스턴스를 변경해야 하는 경우에 유용한 방법이 쓰기 시 복사 패턴이다
+```java 
+class TextOptions {
+    private final Font font;
+    private final Double fontSize;
+
+    TextOptions(Font font) { // 필수 값 받는 퍼블릭 생성자
+        this(font, null); // 프라이빗 생성자 호출
+    }
+
+    private TextOptions(Font font, Double fontSize) { // 모든값 받는 프라이빗 생성자
+        this.font = font;
+        this.fontSize = fontSize;
+    }
+
+    Font getFont() {
+        return font;
+    }
+
+    Double getFontSize() {
+        return fontSize;
+    }
+
+    TextOptions withFont(Font newFont) {
+        return new TextOptions(newFont, fontSize); // 폰트만 변경된 새 객체 반환
+    }
+
+    TextOptions withFontSize(Double newFontSize) {
+        return new TextOptions(font, newFontSize); // 폰트 사이즈만 변경된 새 객체 반환
+    }
+}
+```
+
+- 인스턴스 생성 예시
+```java correct
+TextOptions getDefaultTextOptions() {
+    return new TextOptions(Font.ARIAL)
+        .withFontSize(12.0);
+}
+
+// 전에 보았던 문제 있던 코드를 수정
+void renderTitle(String title, TextOptions baseStyle) {
+    titleField.display(
+        title,
+        baseStyle.withFontSize(18.0) // 새 인스턴스 생성 
+    );
+}
+```

chapter7/7_2_객체를_깊은_수준까지_불변적으로_만드는_것을_고려하라.mdx

@@ -0,0 +1,115 @@
+---
+title: '객체를 깊은 수준까지 불변적으로 만드는 것을 고려하라'
+author: 'hyunwok'
+---
+
+- 클래스가 실수로 가변적으로 될 수 있는 일반적인 경우는 깊은 가변성 때문이다
+- 무심코 가변적으로 될 수 있는 좀 더 미묘한 경우를 간과하기 쉽다.
+
+### 7.2.1 깊은 가변성은 오용을 초래할 수 있다.
+```java incorrect
+class TextOptions {
+    private final List<Font> fontFamily; // 여러 폰트를 갖고 있는 리스트
+    private final Double fontSize;
+
+    TextOptions(List<Font> fontFamily, Double fontSize) {
+        this.fontFamily = fontFamily;
+        this.fontSize = fontSize;
+    }
+
+    List<Font> getFontFamily() {
+        return fontFamily;
+    }
+
+    Double getFontSize() {
+        return fontSize;
+    }
+}
+```
+
+- 위 예제는 글꼴 리스트를 완전히 제어할 수 없기에 무의식중에 가변적으로 될 수 있다.
+- 위 클래스는 글꼴 목록을 갖고 있는 것이 아닌 글꼴 목록에 대한 참조를 갖고 있다는 점을 기억해야 한다.
+    - 참조를 갖고 있는 상태에서, 글꼴 목록이 변경되면 동일한 리스트를 참조하기 때문에 영향을 미친다.
+
+#### 시나리오 A 코드 예제
+- 클래스를 생성하는 코드가 글꼴 목록에 대한 참조를 유지하고 나중에 변경할 수 있다.
+
+```java incorrect
+List<Font> fontFamily = [Font.ARIAL, Font.VERDANA];
+
+TextOptions textOptions = 
+    new TextOptions(fontFamily, 12.0); // 새 인스턴스에 리스트 참조가 전달됨
+
+fontFamily.clear(); // 참조로 인해 아까 만든 새 인스턴스의 값 또한 사라지게 됨
+fontFamily.add(Font.COMIC_SANS);
+```
+
+#### 시나리오 B 코드 예제
+- getFontFamily()를 호출할 때 글꼴 목록에 대한 참조를 받고, 이걸 사용하여 목록의 내용을 수정할 수 있다.
+
+```java incorrect
+TextOptions textOptions = 
+    new TextOptions([Font.ARIAL, Font.VERDANA], 12.0);
+
+List<Font> fontFamily = textOptions.getFontFamily(); //  새 인스턴스의 리스트에 대한 참조를 가져옴
+fontFamily.clear(); // 새 리스트 뿐만 아니라 새 인스턴스 내부의 리스트 또한 사라짐
+fontFamily.add(Font.COMIC_SANS);
+```
+
+- 이런 방식으로 코드를 변경할 수 있게 되면 코드를 오용하기 쉬워지고, 추후에는 수정하는 게 안전한지 추적하기 또한 쉽지 않아진다.
+
+### 7.2.2 해결책: 방어적으로 복사하라
+- 객체의 복사본을 만들어서 반환하여 위의 문제를 해결할 수 있다.
+- 최선의 해결책은 아니지만, 깊은 불변성을 담보하기 위해 효과가 있는 간단한 방법이다.
+
+```java correct
+class TextOptions {
+    private final List<Font> fontFamily;
+    private final Double fontSize;
+
+    TextOptions(List<Font> fontFamily, Double fontSize) {
+        this.fontFamily = List.copyOf(fontFamily);
+        this.fontSize = fontSize;
+    }
+
+    List<Font> getFontFamily() {
+        return List.copyOf(fontFamily);
+    }
+
+    Double getFontSize() {
+        return fontSize;
+    }
+}
+```
+
+- 이런 방식이 꽤 효과적일 수 있지만, 다음과 같은 단점도 명확하다.
+    - 복사하는데 비용이 많이 들 수 있다, 만약 수백개의 폰트가 존재한다면 성능 문제가 발생할 수 있다.
+    - 클래스 내부에서 발생하는 변경을 막아주지 못하는 경우가 많다, final을 사용한다 해도 클래스 내에서는 똑같은 문제가 발생할 수 있다.
+
+### 7.2.3 해결책: 불변적 자료구조를 사용하라
+- 객체를 불변적으로 만드는 것은 널리 받아들여지고 있는 좋은 관행이며, 그 결과 많은 유틸리티가 공통 유형이나 자료구조에 대해 불변적인 버전을 제공한다.
+    - Java : 구아바 라이브러리의 ImmutableList 클래스
+    - C# : System.Collections.Immutable의 ImmutableList 클래스
+    - JS 기반 언어 
+        - Immutable.js 모듈의 리스트 클래스
+        - JS 배열이지만 Immer 모듈을 사용하여 불변적으로 만들어진 JS의 배열
+
+```java correct
+class TextOptions {
+    private final ImmutableList<Font> fontFamily;
+    private final Double fontSize;
+
+    TextOptions(ImmutableList<Font> fontFamily, Double fontSize) {
+        this.fontFamily = fontFamily;
+        this.fontSize = fontSize;
+    }
+
+    ImmutableList<Font> getFontFamily() {
+        return fontFamily;
+    }
+
+    Double getFontSize() {
+        return fontSize;
+    }
+}
+```