Clean Code(클린 코드) | 로버트 C. 마틴 | 인사이트- 교보ebook

애자일 소프트웨어 장인 정신, 나쁜 코드도 돌아는 간다. 하지만 코드가 깨끗하지 못하면 개발 조직은 기어간다. 매년 지저분한 코드로 수많은 시간과 상당한 자원이 낭비된다. 그래야 할 이유

ebook-product.kyobobook.co.kr

코드

https://github.com/rkwhr0010/clean_code/tree/main/src

변경 사항은 git history 참고

 

변수를 private으로 정의하는 이유는 남들이 변수에 의존하지 않게 만들고 싶기 때문이다.

 

이렇게 되면, 언제든 개발자가 변수 타입이나 구현을 변경할 있다. 의존하는 곳이 없으니까!

 

그런데 대부분 변수는 private으로 선언하고, getter, setter public으로 당연히 정의할 ?

 

자료 추상화

//클래스 구조를 외부로 노출하고 있다.
public class Point1 {
  public double x;
  public double y;
}
//구현을 완전히 숨기고 있다.
public interface Point2 {
 double getX();
 double getY();
 void setCartesian(double x, double y);
 double getR();
 double getTheta();
 void setPolar(double r, double theta);
}

 

Point2 자료 구조를 명백하게 표현하고 있다.

뿐만 아니라 메서드로 접근 정책을 강제한다.

x, y 번에 설정해야 한다. 따로 설정할 방법이 없다.

/*
 * 단순히 변수를 private으로 바꾸고
 * 그 사이  게터/세터 메서드를 넣는다고,구현이 감춰지지 않는다.
 * 구현을 감추려면 추상화가 필요하다.
 */
public class Point3 {
  //구현을 그대로 노출하는 것이랑 다를바 없다.
  private double x;
  private double y;
  public double getX() {
    return x;
  }
  public void setX(double x) {
    this.x = x;
  }
  public double getY() {
    return y;
  }
  public void setY(double y) {
    this.y = y;
  }
}

사용자가 구현을 모른 자료의 핵심을 조작할 있어야 한다.

 

 

public interface Vehicle1 {
  double getFuelTankCapacityInGallons();
  double getGallonsOfGasoline();
}

Vehicle1 "구체적인" 값을 알려준다.

단순히 게터/세터를 설정하는 것과 유사하다.

자료 출처를 명확히 있다.

 

public interface Vehicle2 {
 double getPercentFuelRemaining();
}

Vehicle2 남은 연료 퍼센트를 알려준다.

자료를 어디서 읽어와서 퍼센트를 산출하는지 드러나지 않는다.

 

 

자료를 세세하게 공개하기보다는 추상적인 개념으로 표현하는 편이 좋다.

아무 생각없이 게터/세터를 추가하는 것으로 추상화는 이뤄지지 않으며, 가장 나쁘다.

 

자료/객체 비대칭

객체와 자료 구조는 다르다.

예제에서 Point1 자료구조다.

 

객체는 추상화 뒤로 자료를 숨긴 자료를 다루는 함수만 공개한다.

자료 구조는 자료를 그대로 공개하며 별다른 함수는 제공하지 않는다.

 

//절차적 도형 예시
public class Exam01 {
  //자료구조
  public class Point {
    public double x;
    public double y;
  }
  //자료구조
  public class Square {
    public Point topLeft;
    public double side;
  }
  //자료구조
  public class Rectangle {
    public Point topLeft;
    public double height;
    public double width;
  }
  //자료구조
  public class Circle {
    public Point center;
    public double radius;
  }
  //동작 방식 정의
  public class Geometry {
    public final double PI = 3.14159265358979323846;
    public double area(Object shape) throws NoSuchShapeException {
      if(shape instanceof Square) {
        Square s = (Square)shape;
        return s.side * s.side;
      } else if (shape instanceof Rectangle) {
        Rectangle s = (Rectangle)shape;
        return s.height * s.width;
      } else if (shape instanceof Circle) {
        Circle s = (Circle)shape;
        return PI * s.radius * s.radius;
      } else {
        throw new NoSuchShapeException();
      }
    }
  }
  class NoSuchShapeException extends RuntimeException {}
}

 

위는 절차적 코드다. 객체 지향으로 설계하지 않았다.

 

무조건 객체지향으로 설계하는 것이 옳지만은 않다.

예를 들어, 코드에서 둘레 길이를 구하는 perimeter() 메서드를 추가한다고 가정하면,

다른 클래스는 전혀 영향을 받지 않는다.

 

반면에 다른 도형 클래스를 추가하고 싶다면, Geometry 클래스에 속한 메서드를 모두 고쳐야 한다.

 

//다형적인 도형
public class Exam02 {
  interface Shape {
    double area();
  }


  public class Point {
    public double x;
    public double y;
  }


  class Square implements Shape {
    private Point topLeft;
    private double side;
    public double area() {
      return side * side;
    }
  }


  class Rectangle implements Shape {
    private Point topLeft;
    private double height;
    private double width;
    public double area() {
      return height * width;
    }
  }


  class Circle implements Shape {
    private Point center;
    private double radius;
    public final double PI = 3.14159265358979323846;
    public double area() {
      return PI * radius * radius;
    }
  }
}

객제 지향으로 설계한 클래스다.

자료 + 기능 = 객체

 

여기서는 area() 다형 메서드고, 동작 방식을 위한 Geometry 클래스는 필요 없다.

그러므로 새로운 도형 클래스를 추가해도 기존 클래스엔 아무런 영향을 미치지 않는다.

 

 

반면에 Shape 새로운 메서드(기능) 추가 하면, 클래스 전부를 고쳐야 한다.

추가로 상속은 모든 하위 클래스에 영향을 준다. 그래서 상속보단 구성을 사용하는 경우가 많다.

 

자료구조, 객체지향 장단점

장점

자료구조를 사용하는 절차적인 코드는 기존 자료 구조를 변경하지 않으면서 함수를 추가하기 쉽다.

반면, 객체 지향 코드는 기존 함수를 변경하지 않으면서 클래스를 추가하기 쉽다.

 

단점

절차적인 코드는 새로운 자료 구조를 추가하기 어렵다. 그러려면 모든 함수를 고쳐야 한다.

객체 지향 코드는 새로운 함수를 추가하기 어렵다. 그러려면 모든 클래스를 고쳐야 한다.

 

특징\설계 절차지향 객체지향
장점 함수 추가(기존 자료구조 변경 없음) 클래스 추가(상속, 기존 클래스 변경없음)
단점 자료 구조 추가(모든 함수 영향) 함수 추가(모든 클래스 영향)

 

어느 것이 하나가 절대적인 참이 아니다.

잘차지향에서 변경이 쉬운 것은 객체지향에서 어렵다.

반대도 똑같다.

 

디미터 법칙

자신이 조작하는 객체의 속사정을 몰라야 한다는 법칙

 

객체는 자료를 숨기고, 함수를 공개한다.

객체는 조회 함수(게터) 내부 구조를 공개하면 안된다.

 

  class C {
    List<?> list = new ArrayList<>();
    //디미터의 법칙, 다음과 같은 객체의 메서드만 호출해야 한다.
    List<?> f(List<?> list) {
      list.add(null);//인수로 넘어온 객체
      this.list.add(null);//인스턴스 변수에 저장된 객체
      new ArrayList<>().add(null);//메서드 내에서 생성된 객체
      //허용된 메서드가 반환하는 메서드는 호출하면 안된다.
      return new ArrayList<>();
    }
  }

 

 

기차 충돌(trainwreck)

디미터 법칙 어긴 예시

  void exam1() {
    String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath();
  }

아래와 같이 나누는 것이 차라리 좋다.

  void exam2() {
    Options opts = ctxt.getOptions();
    File scratchDir = opts.getScratchDir();
    String outputDir = scratchDir.getAbsolutePath();
  }

코드는 너무 많은 정보를 알고 있어야 한다.

메서드가 객체를 리턴하고, 객체는 객체를 리턴하는 등…

 

예시가 디미터 법칙을 위반했는지는 객체인지, 자료구조인지에 달렸다.

객체는 내부 구조를 숨겨야 하므로, 어긴 것이 된다.

 

자료 구조는 당연히 내부 구조를 노출해야 한다. (디미터 법칙 적용 대상이 아님)

명백한 자료 구조 표현

  void exam3() {
    String outputDir = ctxt.options.scratchDir.absolutePath;
  }

 

실제 현업에선 자바빈 규약이 있어, 변수로 접근하지 못하는 경우가 많다.

 

잡종 구조

객체와 자료 구조가 섞인 구조를 말한다.

일부 필드는 비공개 변수를 단순히 공개 게터/세터로 노출, 중요한 기능을 하는 메서드도 존재

 

구조체 감추기

ctxt, options, scratchDir 객체라면, 줄줄이 사탕 형식으로 엮여서는 된다.

내부 구조를 감춰야 하기 때문이다.

  void exam1(){
    //공개해야하는 메서드가 너무 많다.
    ctxt.getAbsolutePathOfScratchDirectoryOption();
    //getScratchDirectoryOption() 반환하는 값이 자료 구조라고 가정하게 된다.(노출했으니까)
    ctxt.getScratchDirectoryOption().getAbsolutePath();
  }

ctxt 객체라면, 뭔가를 하라고 말해야지 속을 드러내면 안된다. (명령)

결국 절대경로를 리턴하는데, 사용 목적이 없다.

 

  void exam2() {
    String classFileName = "";
    //코드를 분석해서 메서드 이름을 명시적으로 지었다.
    //그리고 무언가를 생성하라고 명령했다. (내부 구조 드러냄 없음, 디미터 법칙 준수)
    BufferedOutputStream bos = ctxt.createScratchFileStream(classFileName);
  }

 

자료 전달 객체(DTO, Data Transfer Object)

보편적인 구조는 public 변수만 존재하고, 메서드는 없는 구조

 

소켓 통신, DB 내외 시스템과 소통 수단으로 유용한 객체다.

 

가장 일반적인 구조는 자바빈(Bean) 규약을 지키는 구조다.

자바빈 규약 간단한 요약

  • 변수 private
  • 모든 변수 게터/세터 존재
  • 기본 생성자 필수

 

public class Address {
  private String street;
  private String streetExtra;
  private String city;
  private String state;
  private String zip;
  public Address(String street, String streetExtra, String city, String state, String zip) {
    this.street = street;
    this.streetExtra = streetExtra;
    this.city = city;
    this.state = state;
    this.zip = zip;
  }
  public String getStreet() {
    return street;
  }
  public String getStreetExtra() {
    return streetExtra;
  }
  public String getCity() {
    return city;
  }
  public String getState() {
    return state;
  }
  public String getZip() {
    return zip;
  }
}

구조는 세터는 없다. , 생성자로 생성과 동시에 즉시 사용할 있음을 보장한다.

 

활성 레코드

DTO 특수한 형태

DTO + 탐색 함수 제공 (find, save)

 

활성 레코드는 자료 구조 취급을 해야한다.

탐색 함수가 있다고, 활성 레코드에 비즈니스 로직을 구현하면 안된다.

 

결론

객체

동작을 공개하고 자료를 숨긴다.

 

이로 인해 기존 동작을 변경하지 않으면서,

객체 타입을 추가하기 쉬워진다.

 

반면에 기존 객체에 동작을 추가하는 것은 어렵다.

 

자료구조

동작이 없이 자료만 노출한다.

 

이로 인해 동작을 추가하기 쉬워진다.

 

반면에 기존 함수에 자료 구조를 추가하기는 어렵다.

 

용도

시스템을 구현할 새로운 자료 타입이 계속 늘어날 같으면, 객체지향이 적합하다

 

시스템을 구현할 새로운 동작을 계속 추가할 같으면, 절차지향이 적합하다.

'IT책, 강의 > 클린코드(Clean Code)' 카테고리의 다른 글

8장 경계  (1) 2024.01.01
7장 오류 처리  (0) 2023.12.25
5장 형식 맞추기  (0) 2023.12.11
4장 주석  (1) 2023.12.04
3장 함수  (1) 2023.11.27

 

https://notepad-plus-plus.org/downloads/v8.6/

 

Download Notepad++ v8.6: 20th-Year Anniversary | Notepad++

Download Notepad++ v8.6: 20th-Year Anniversary Release Date: 2023-11-23 Download 64-bit x64 Download 32-bit x86 Download ARM64 Download source code Download Notepad++ source code of current version and/or check sha-256 digests for binary packages on GitHub

notepad-plus-plus.org

 

 

드디어 다중편집이 완벽히 지원된다.

 

기존 문제점은 키보드로 멀티 커서를 생성하면, 이후 커서를 이동하면 바로 싱글 커서로 변환됐다.

이 문제로 키보드로 커서를 이동하고 싶은 경우  " ctrl + 좌클릭 " 으로 멀티 커서를 생성해야 했다. 그래야만 멀티 커서가 풀리지 않았다.

 

이제 그럴 필요가 없다!!!!

이제 편리하게 다중 편집을 사용할 수 있다.

 

 

Clean Code(클린 코드) | 로버트 C. 마틴 | 인사이트- 교보ebook

애자일 소프트웨어 장인 정신, 나쁜 코드도 돌아는 간다. 하지만 코드가 깨끗하지 못하면 개발 조직은 기어간다. 매년 지저분한 코드로 수많은 시간과 상당한 자원이 낭비된다. 그래야 할 이유

ebook-product.kyobobook.co.kr

코드

https://github.com/rkwhr0010/clean_code/tree/main/src

변경 사항은 git history 참고

 

코든 코드가 깔끔하고, 일관적이며, 꼼꼼해야 한다.

 

누군가 코드를 봤을 전문가가 짰다는 인상을 줘야 한다.

 

프로그래머라면 조직에 코딩 컨벤션에 따라 코드를 작성해야 한다.

코딩 스타일을 맞추기 위해 툴을 사용할 있다면, 사용해야 한다. (예시_ESLint)

 

형식을 맞추는 목적

코드 형식은 의사소통의 일환

의사소통의 중요성은 말할 필요가 없다.

 

'돌아만 가능 코드' 변경에 취약하다.

깨진 창문 효과로 시간이 지남에 따라 더욱 더러워 것이다.

결과 의사소통이 되지 않는 코드가 된다.

 

형식을 엄격하게 맞춰 놓는다면, 시간이 지나도 유지보수 용이성이 그대로 유지된다.

 

개발자는 사라져도 개발자의 스타일과 규율은 사라지지 않는다.

 

적절한 길이를 유지하라

소스 파일 세로 길이

톰캣 같은 경우 500 줄이 넘는 경우도 많다.

Fitnesse 경우 대부분 30 ~ 100 사이에 위치한다.

 

Fitnesse 전체 코드 양은 5 줄이다.

 

이를 보면서 있는 것은, 200 미만은 작은 파일로도 커다란 시스템을 구축할 있다는 것이다.

 

코드가 작으면, 이해하기 쉽다.

 

신문 기사처럼 작성하라

기사는 기본적으로 위에서 아래로 읽게 된다.

그리고 하나의 기사가 면을 차지하는 경우는 거의 없다.

적절한 크기를 가진다.

 

문단은 표제다. 독자는 표제를 읽고, 읽을지 말지를 결정한다.

표제는 자세한 세부사항을 숨기고 커다란 그림을 보여준다.

 

위에서 아래로 읽을 수록 세부사항이 조금씩 드러난다.

 

이를 코드에 대입하면,

소스 파일 부분에는 고차원 개념과 알고리즘을 설명한다.

아래로 수록 세부적인 로직이 설명되며,

마지막엔 가장 저차원 함수가 나온다.

 

개념은 행으로 분리하라

패키지 선언부, import , 함수 사이 등에서 행으로 구분하는 것을 의미한다.

행으로 구분 안하고, 따닥따닥 붙어있다면, 코드 가독성이 현저히 떨어진다.

 

세로 밀집도

바꿈은 개념을 분리한다.

 

세로 밀집도는 연관성을 의미한다.

연관된 코드를 세로로 가까이 있어야 한다.

 

public class ReporterConfig {
  /**
   * 리포터 리스너 클래스 이름
   */
  private String m_className;
  /**
   * 리포터 리스너 속성
   */
  private List<Property> m_properties = new ArrayList<>();
  public void addProperty(Property property) {
    m_properties.add(property);
  }
}
public class ReporterConfig {
  private String m_className;
  private List<Property> m_properties = new ArrayList<>();


  public void addProperty(Property property) {
    m_properties.add(property);
  }
}

번째보다 번째가 눈에 들어온다.

스크롤 필요가 없다.

 

수직 거리

함수 연관 관계와 동작 방식을 이해하려고,

스크롤 하거나, 나아가 조각난 다른 파일로 왔다갔다 뺑뺑이를 있다면,

그것이 끔찍한 경험이라는 것을 것이다.

 

행위가 전부 시간과 노력을 소모한다.

 

서로 미접한 개념은 세로로 가까이 둬야 한다.

특별한 이유가 없다면, 밀접한 개념은 같은 파일에 위치해야 한다.

위와 같은 이유로 protected 접근자를 사용을 피해야 한다.

 

같은 파일 내에 코드는 연관성이 높을 수록 서로 붙어 있어야 한다.

아니면, 소스를 찾느라 스크롤을 많이 해야 한다.

 

변수 선언

변수 선언은 사용하는 위치에 최대한 가까이 선언해야 한다.

클린 코드 룰을 따르면, 함수는 매우 작아 지게 되므로,

함수 앞에 선언하게 된다.

 

 

  void something() {
    for (final Object obj : lists) {
      //좋은 예
      final Object someThing = createInstance();
    }
  }

 

인스턴스 변수

보통 클래스 처음에 선언한다.

변수 세로 거리는 두지 않는다.

 

메서드와 메서드 사이에 변수를 선언하면, 가독성이 떨어진다.

 

종속 함수

함수가 다른 함수를 호출하는 경우를 말한다.

경우 종속 함수는 바로 호출하는 함수 아래에 위치해야 한다.

 

개념적 유사성

종속 함수 같이 직접적인 유사성을 제외하고도

같은 변수를 사용하는 메서드들이나, 비슷한 동작을 수행하는 함수를 말한다.

 

Junit 좋은 예시

개념적 유사성이 매우 높다.

 

새로 순서

고차원 함수가 저차원 함수를 호출한다.

, 가장 고차원 함수가 가장 앞에, 가장 저차원 함수가 가장 아래 위치해야 한다.

 

가로 형식 맞추기

대부분 20 ~ 60 사이에 위치한다.

80 부턴 급격히 적어진다.

 

자료는 옛날 모니터가 좋았던 시절.

현재는 120 이내로 유지하는 것을 권장한다.

 

가로 공백과 밀집도

할당 연산자를 구분하기 위해 띄어쓰기

메서드 인수 구분을 위해 콤마 띄어쓰기

 

연산자 우선순위 강조를 위한 공백

package chap05.ex04;
public class Quadratic {
  public static double root1(double a, double b, double c) {
    double determinant = determinant(a, b, c);
   
    return (-b + Math.sqrt(determinant)) / (2*a);
  }
  public static double root2(int a, int b, int c) {
    double determinant = determinant(a, b, c);
    return (-b - Math.sqrt(determinant)) / (2*a);
  }
  private static double determinant(double a, double b, double c) {
    return b*b - 4*a*c;
  }
}

곱셈이 우선순위가 높아 붙이고, 뺄샘은 띄웠다.

 

IDE 자동 정렬 기능을 사용하면, 모든 연산자에 동일한 간격을 띄워 위와 같은 포멧이 나오진 않는다.

 

현실적으로 우선순위가 맞더라도 소괄호를 치는 것이 좋아보인다.

 

가로 정렬

이렇게 코드를 정렬하면, 좋지 않다.

이렇게 되면, 진짜 목적인 변수 타입을 먼저 읽지 않고, 시선이 변수명으로 먼저 간다.

 

들여쓰기

public class Quadratic { public static double root1(double a, double b, double c) {double determinant = determinant(a, b, c);    return (-b + Math.sqrt(determinant)) / (2*a);} public static double root2(int a, int b, int c) {double determinant = determinant(a, b, c); return (-b - Math.sqrt(determinant)) / (2*a); } private static double determinant(double a, double b, double c) { return b*b - 4*a*c; }}

코드는 기계는 정확히 동작하지만, 결국 사람이 때는 하나도 눈에 안들어 온다.

 

들여쓰기는 코드 구조를 눈에 들어오도록 도움을 준다.

기본 들여쓰기 룰은 지키는 것이 좋다.

 

규칙

중요한 규칙이다. 개인이 선호하는 규칙이 있겠지만, 규칙이 반드시 지켜야 한다.

그래야 소프트웨어가 일관적인 스타일을 유지하게 된다.

'IT책, 강의 > 클린코드(Clean Code)' 카테고리의 다른 글

7장 오류 처리  (0) 2023.12.25
6장 객체와 자료 구조  (1) 2023.12.18
4장 주석  (1) 2023.12.04
3장 함수  (1) 2023.11.27
2장 의미 있는 이름  (1) 2023.11.20

 

 

Clean Code(클린 코드) | 로버트 C. 마틴 | 인사이트- 교보ebook

애자일 소프트웨어 장인 정신, 나쁜 코드도 돌아는 간다. 하지만 코드가 깨끗하지 못하면 개발 조직은 기어간다. 매년 지저분한 코드로 수많은 시간과 상당한 자원이 낭비된다. 그래야 할 이유

ebook-product.kyobobook.co.kr

코드

https://github.com/rkwhr0010/clean_code/tree/main/src

변경 사항은 git history 참고

 

오래된 주석은 거짓 정보를 퍼트린다.

거짓된 주석은 없는 것보다 나쁘다.

 

주석은 순수하게 선하지 않다. 필요악이다.

코드 자체가 표현력이 풍부하다면, 필요하지 않다.

 

따라서 주석을 단다는 것은 자신의 표현력이 부족하는 것이다.

 

좋은 주석이라도 시간이 지나면서, 관리되지 않아 나쁜 주석이 된다. 현실적으로 주석은 관리 되지 않는다.

 

코드만이 거짓을 말하지 않는다. 최대한 주석이 없는 방향으로 개발해야 한다.

 

주석은 나쁜 코드를 보완하지 못한다

주석은 코드 품질이 나쁠 단다. 따라서 주석이 보이면, 코드를 정리해야 한다

 

코드로 의도를 표현하라!

  //어느것이 더 좋은지 비교
  void example() {
    //직원에게 복지 혜택을 받을 자격이 있는지 검사
    if((employee.flags & HOURLY_FLAG) && employee.age > 65) {
      /* ~~~~ */
    }
    if(employee.isEligibleForFullBenefits()) {
      /* ~~~~ */
    }

 

좋은 주석

필수 정보는 주석을 밖에 없다.

 

법적인 주석

코드 상단에 카피라이트에 해당된다.

 

정보를 제공하는 주석

코드로 표현이 도저히 힘든 정규식 같은게 좋은 예다.

    //kk:mm:ss EEE, MMM dd, yyyy 형식
    Pattern timeMatcher = Pattern.compile(
      "\\d*:\\d*:\\d* \\w*, \\w* \\d*, \\d*");

마저도 시간과 날짜를 변환해주는 클래스를 별도로 만들어 옮기면, 주석이 필요하지 않다.

 

의도를 설명하는 주석

  public int compareTo(Object o) {
    if(o instanceof WikiPagePath) {
      WikiPagePath p = (WikiPagePath) o;
      String compressedName = StringUtil.join(names, "");
      String compressedArgumentName = StringUtil.join(p.names, "");
      return compressedName.compareTo(compressedArgumentName);
    }
    return 1; //오른쪽 유형이므로 정렬 순위가 더 높다.
  }
  void testConcurrentAddWidgets() throws Exception {
    WidgetBuilder widgetBuilder = new WidgetBuilder(new Class[]{BoldWidget.class});
    String text = "'''bold text'''";
    ParentWiget parent = new BoldWidget(new MockWidgetRoot(), "'''bold test'''");
    AtomicBoolean failFalg = new AtomicBoolean();
    failFalg.set(false);
    //스레드를 대량 생성하는 방법으로 어떻게든 경쟁 조건을 만들려 시도한다.
    for (int i = 0; i < 25000; i++) {
      WidgetBuilderThread widgetBuilderThread =
          new WidgetBuilderThread(widgetBuilder, text, parent, failFalg);
      Thread thread = new Thread(widgetBuilderThread);
      thread.start();
    }
    assertEquals(false, failFalg.get());
  }

 

의미를 명료하게 밝히는 주석

  void testCompareTo() throws Exception {
    WikiPagePath a = PathParser.parse("PageA");
    WikiPagePath ab = PathParser.parse("PageA.PageB");
    WikiPagePath b = PathParser.parse("PageB");
    WikiPagePath aa = PathParser.parse("PageA.PageA");
    WikiPagePath bb = PathParser.parse("PageB.PageB");
    WikiPagePath ba = PathParser.parse("PageB.PageA");
    //assertTrue 가 라이브러리를 사용한 것이라고 가정
    assertTrue(a.compareTo(a) == 0); // a == a
    assertTrue(a.compareTo(b) != 0); // a != b
    assertTrue(a.compareTo(b) == -1);// a < b
  }

모호한 인수나 반환값을 의미를 좋게 표현하려고 바꾸고 싶지만,

라이브러리를 사용하는 경우 변경이 불가하다. 경우는 주석이 유용하다.

 

물론 주석을 완전히 신뢰할 없다는 문제가 남아있다.

처럼 주석은 다른 방법으로 표현할 방법이 없는 고민 달아야 한다.

 

결과를 경고하는 주석

특정 테스트 케이스가 수행 시간이 오래걸린다면, 이를 위한 경고는 괜찮다.

요즘은 @Ignore 어노테이션 같은 것으로 안에 사유를 적어 주석보다 명시적으로 사용한다.

 

또는 해당 코드가 스레드 세이프하지 않을 경고를 남기기도 한다

 

TODO 주석

요즘 IDE TODO 인식 해서 보여주는 기능이 있다.

 

보통은 현재 구현이 어려운 코드를 TODO 주석으로 남길 것이다.

따라서 이를 주기적으로 체크해 줄여가야 한다.

 

중요성을 강조하는 주석

얼핏 봤을 대수롭지 않게 넘길 만한 코드에 중요한 사실을 경고할

    //trim() 중요하다. 시작에 공백이 들어가 있으면, 다른 문자열로 인식된다.
    String listItemContent = match.group(3).trim();
    new ListItemWidget(this, listItemContent, this.level + 1);
    return buildList(text.substring(match.end()));

 

공개 API에서 Javadocs

Javadocs 만들기로 했으면, 정말 만들어야 한다.

만든 공개 API Javadocs 훌륭하다.

 

 

나쁜 주석

대부분의 주석이 해당된다.

 

주절거리는 주석

무언가를 설명하려고 주석을 생각이면, 최대한 의미있게 자세히 서술해야 한다.

설명이 미흡하면, 결국 주석의 의미는 희미해지고, 코드를 뒤지며 로직을 확인해야 한다.

 

같은 이야기를 중복하는 주석

변수나 함수 이름만으로도 충분한데, 의미 없이 중복된 내용을 주석으로 작성한 것을 말한다.

  /*
   * this.closed true 일 때 반환되는 메서드
   * 타임아웃에 도달하면 예외를 던진다.
   */
  synchronized void waitForClose(final long timeoutMillis) throws Exception {
    if(!closed) {
      wait(timeoutMillis);
      if(!closed) {
        throw new Exception("MockResponseSender Could not be closed");
      }
    }
  }
  /* 로그를 찍기 위한 로거 */
  Logger logger;

 

오해할 여지가 있는 주석

 

의무적으로 다는 주석

자바독 예시

  /**
   * @param title CD 제목
   * @param author CD 저자
   * @param tracks CD 트랙수
   * @param durationInMinutes CD 분 길이
   */
  public void addCd(String title, String author, int tracks, int durationInMinutes) {
  }

오히려 가독성만 저해한다.

 

이력을 기록하는 주석

Git 같은 형상관리 프로그램이 이력을 저장하고 있다.

이제 필요없다.

 

있으나 마나 주석

이런 주석을 자주 접하면, 개발자는 주석을 무시하게 된다.

그러면 정말 중요한 주석인 경우 읽게 된다.

 

위치는 표시하는 주석

// 여기 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

이런 주석이다. 시적으로 혼자만 가끔 사용할 있어도 커밋 시점엔 제거돼야 한다.

 

닫는 괄호에 다는 주석

예전에 IDE 없던 시절에는 함수가 길어지면, 찾기 힘들 었다

현재는 IDE 닫은 괄호를 눈에 띄게 표시해주며, 특히 여는 괄호에서 닫는 괄호로 이동 기능도 제공한다.

 

 

Vscode Ctrl + Shift + P 괄호 이동 단축키다.

 

공로를 돌리거나 저자를 표시하는 주석

형상 관리 프로그램이 관리한다.

 

주석으로 처리한 코드

언젠가 필요할 까봐 주석으로 남기는 코드가 있다.

역시 형상 관리 프로그램으로 과거 코드를 언제든지 접근할 있으므로 제거한다.

 

HTML주석

Javadocs 작성할 주석에 HTML 태그를 사용한다. 이렇게 되면 javadocs 만들지 않는 이상 주석만 보고 파악하기 힘들다.

 

현재 IDE 팝업 같은 형식으로 보기 편하게 지원해서 의미는 없는 듯하다.

 

전역 정보

주석을 단다면 주변 코드 정보만 달아야 한다. 전역 시스템 정보를 달면 안된다.

조금이라도 코드에 변경이 생기면, 전역 주석을 항상 최신화 있는가

 

 

너무 많은 정보

예를 들어 JWT 라이브러리를 사용하는데 라이브러리 주석에 JWT 동작방식이 있다고 생각하면 이해가 쉽다.

 

모호한 관계

코드와 이를 설명하는 주석의 관계가 명확하지 않는 경우를 말한다.

 

비공개 코드에서 Javadocs

공개 API에선 의미가 있지만, 비공개 코드에선 의미가 없다. 오히려 코드를 읽기 힘들게 한다.

 

예제

리팩터링

package chap04.ex07;
/**
 * 이 클래스는 사용자가 지정한 최대 값까지 소수를 생성한다.
 * 사용된 알고리즘은 에라스토테네스의 체다.
 *
 * 에라스토테네스 소개  [의미없는 주석]
 * ~~~~~~~~~~~~~~~~~~
 *
 * 알고리즘 설명
 * ~~~~~~~~~~~~~~~~~~
 *
 * @author 누군가
 * @version 2023.09.01
 */
public class GeneratePrimes {
  /** [의미없는 주석]
   * @param maxValue소수를 찾아낼 최대 값
   */
  //지나지게 거대한 메서드
  public static int[] generatePrimes(int maxValue) {
    if (maxValue > 2) { //유일하게 유효한 경우 [의미없는 주석]
      //선언
      int s = maxValue + 1;
      boolean[] f = new boolean[s];
      int i;
      //배열을 참으로 초기화 [의미없는 주석] 메서드로 뺄 것(메서드 이름을 명시적으로)
      for(i = 0; i < s; i++) {
        f[i] = true;
      }
      //소수가 아닌 알려진 숫자를 제거 [의미없는 주석]
      f[0] = f[1] = false;
      // [의미없는 주석] [의미없는 주석] 메서드로 뺄 것(메서드 이름을 명시적으로)
      int j;
      for (i = 2; i < Math.sqrt(s) + 1; i++) {
        if (f[i]) {
          for (j = 2 * i; j < s; j += i) {
            f[j] = false; //배수는 소수가 아니다.
          }
        }
      }
      //소수 개수는? [의미없는 주석] 메서드로 뺄 것(메서드 이름을 명시적으로)
      int count = 0;
      for (i = 0; i < s; i++) {
        if (f[i]) {
          count++; // 카운트 증가
        }
      }
     
      int[] primes = new int[count];
      // 소수를 결과 배열로 이동한다. [의미없는 주석] 메서드로 뺄 것(메서드 이름을 명시적으로)
      for (i = 0, j = 0; i < s; i++) {
        if (f[i]) {
          primes[j++] = i;
        }
      }
      return primes;
    } else { // maxValue < 2 [의미없는 주석]
      return new int[0]; //입력이 잘못되면 비어 있는 배열을 반환하다. [의미없는 주석]
    }
  }
}

 

리팩터링

package chap04.ex07;
/**
 * 이 클래스는 사용자가 지정한 최대 값까지 소수를 구한다.
 * 알고리즘은 에라스토테네스의 체다.
 * 2에서 시작하는 정수 배열을 대상으로 작업한다.
 * 처음으로 남아 있는 정수를 찾아 배수를 모두 제거한다.
 * 배열에 더 이상 배수가 없을 때까지 반복한다.
 */
public class PrimeGenerator {
  private static boolean[] crossedOut;
  private static int[] result;
  public static int[] generatePrimes(int maxValue) {
    if (maxValue < 2) {
      return new int[0];
    } else {
      uncrossIntegersUpTo(maxValue);
      crossOutMultiples();
      putUncrossedIntegersIntoResult();
      return result;
    }
  }


  private static void uncrossIntegersUpTo(int maxValue) {
    crossedOut = new boolean[maxValue + 1];
    for (int i = 2; i < crossedOut.length; i++) {
      crossedOut[i] = false;
    }
  }
  private static void crossOutMultiples() {
    int limit = determineIterationLimit();
    for (int i = 2; i <= limit; i++) {
      if (notCrossed(i)) {
        crossOutMultiplesOf(i);
      }
    }
  }
  private static int determineIterationLimit() {
    /*
     * 배열에 있는 모든 배수는 배열의 제곱근보다 작은 소수의 인수다.
     * 따라서 이 제곱근보다 더 큰 숫자의 배수는 제거할 필요가 없다.
     */
    double iterationLimit = Math.sqrt(crossedOut.length);
    return (int) iterationLimit;
  }
  private static void crossOutMultiplesOf(int i) {
    for (int multiple = 2 * i;
        multiple < crossedOut.length;
        multiple += i) {
      crossedOut[multiple] = true;
    }
  }
  private static boolean notCrossed(int i) {
    return crossedOut[i] == false;
  }
  private static void putUncrossedIntegersIntoResult() {
    result = new int[numberOfUncrossedIntegers()];
    for(int j = 0, i = 2; i < crossedOut.length; i++) {
      if (notCrossed(i)) {
        result[j++] = i;
      }
    }
  }
  private static int numberOfUncrossedIntegers() {
    int count = 0;
    for (int i =2; i < crossedOut.length; i++) {
      if (notCrossed(i)) {
        count++;
      }
    }
    return count;
  }
}

 

 

 

'IT책, 강의 > 클린코드(Clean Code)' 카테고리의 다른 글

6장 객체와 자료 구조  (1) 2023.12.18
5장 형식 맞추기  (0) 2023.12.11
3장 함수  (1) 2023.11.27
2장 의미 있는 이름  (1) 2023.11.20
1장 깨끗한 코드  (0) 2023.11.13

 

 

자바 ORM 표준 JPA 프로그래밍 | 김영한 | 에이콘출판- 교보ebook

스프링 데이터 예제 프로젝트로 배우는 전자정부 표준 데이터베이스 프레임, <b>★ 이 책에서 다루는 내용 ★</b> ■ JPA 기초 이론과 핵심 원리 ■ JPA로 도메인 모델을 설계하는 과정을 예제 중심

ebook-product.kyobobook.co.kr

소스

https://github.com/rkwhr0010/jpa

 

SQL 직접 다룰 발생하는 문제점

지루한 반복 코드

JDBC API 사용해 DB CRUD 하려면 너무 많은 직접 작성한 유사한 SQL DB 연결을 위한 반복성 코드가 생긴다.

데이터 접근 계층(DAO) 대부분 반복성 코드와 유사한 SQL 많다.

 

SQL 의존적인 개발

비즈니스 요구사항은 언제나 변한다.

public class Member {
        private Long id;
        private String name;
        private String email; // 새로 추가된 컬럼
}

비즈니스 요구사항을 모델링한 객체를 엔티티라 한다.

요구사항의 변경으로 Member 엔티티에서 email 추가로 저장해야 하는 상황이 오면, 모든 관계된 CRUD 코드를 확인하고 SQL 수정해야 한다.

 

JPA 문제 해결

JPA 객체를 DB 저장할 JPA 제공하는 API 사용하면 된다.

JPA 자동으로 SQL 생성해서 DB에게 전달한다.

 

다음은 CRUD 대표적인 메서드들이다

저장

 

 

조회

 

 

수정

수정의 경우 특별하다. find() 조회한 엔티티를 수정하면, 트랜잭션을 커밋할 DB 수정사항이 반영된다.

 

삭제

 

 

페러다임의 불일치

애플리케이션은 발전하면서 복잡성도 증대된다.

개발자는 복잡성을 제어해 유지보수하기 좋은 코드를 만들려 노력한다.

 

객체지향 캡상추다, SOLID, 디자인패턴 등은 복잡성을 제어하기 위한 도구이다.

 

비즈니스 요구사항은 코드로 구현을 해도 결국 산출물로 데이터가 나오고 이는 영구히 저장할 곳이 필요하다. 이때 RDB(관계형 DB) 역할을 한다. 여기서 DB 편의상 RDB 한정한다.

 

런타임에 객체로 존재하는 데이터를 RDB 저장해야 한다.

문제는 객체와 RDB 지향하는 목적이 다르다는 것이다.

RDB에는 객체지향이라는 개념이 존재하지 않는다. 데이터 중심으로 구조화되어 있다.

객체 구조를 테이블 구조에 저장하는 것에 한계가 있다. 이를 패러다임 불일치라 한다.

 

패러다임 불일치를 해소하기 위해 결국 개발자가 많은 노력을 기울여야 한다.

 

상속

객체는 상속이라는 개념이 존재한다.

DB 모델링에는 유사한 개념인 슈퍼타입 서브타입 관계가 존재한다.

비슷해 보이지만, 다르다. 객체는 extends 키워드로 부모의 속성을 상속 받지만, DB 경우 슈퍼타입과 서브타입 KEY 로만 관계를 맺는다.

, 1개의 서브타입 객체를 DB 저장하려면 2개의 INSERT 쿼리가 필요하다.

이게 패러다임 불일치를 해소하기 위한 비용이다.

 

JPA 상속

JPA 마치 자바 컬렉션에 저장하듯 사용하면, 나머지는 JPA 알아서 처리해 준다.

JPA 알아서 2개의 INSERT 쿼리로 처리해줌

 

 

 

package study.jpa.entity;


import jakarta.persistence.Column;
import jakarta.persistence.DiscriminatorColumn;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.Inheritance;
import jakarta.persistence.InheritanceType;


@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name = "DTYPE")
public abstract class Item {
        @Id
        @GeneratedValue
        @Column(name = "ITEM_ID")
        private Long id;
        
        private String name;
        private Integer price;
        
        public Long getId() {
                return id;
        }
        public void setId(Long id) {
                this.id = id;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public Integer getPrice() {
                return price;
        }
        public void setPrice(Integer price) {
                this.price = price;
        }
}


package study.jpa.entity;


import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;


@Entity
@DiscriminatorValue("A")
public class Album extends Item{
        private String artist;


        public String getArtist() {
                return artist;
        }


        public void setArtist(String artist) {
                this.artist = artist;
        }
}
package study.jpa.entity;


import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;


@Entity
@DiscriminatorValue("B")
public class Book extends Item{
        private String author;
        private String isbn;
        public String getAuthor() {
                return author;
        }
        public void setAuthor(String author) {
                this.author = author;
        }
        public String getIsbn() {
                return isbn;
        }
        public void setIsbn(String isbn) {
                this.isbn = isbn;
        }
}

package study.jpa.entity;


import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;


@Entity
@DiscriminatorValue("M")
public class Movie extends Item{
        private String director;
        private String actor;
        
        public String getDirector() {
                return director;
        }
        public void setDirector(String director) {
                this.director = director;
        }
        public String getActor() {
                return actor;
        }
        public void setActor(String actor) {
                this.actor = actor;
        }
}



package study.jpa;


import java.util.function.Consumer;


import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;


import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;
import study.jpa.entity.Album;


public class Main {
        static Logger logger = LogManager.getLogger();
        static EntityManagerFactory emf =
                        Persistence.createEntityManagerFactory("studyjpa");
        
        public static void main(String[] args) {
                createPersistenceContext(em -> {
                        Album album = new Album();
                        album.setName("앨범");
                        album.setArtist("홍길동");
                        album.setPrice(1000);
                        
                        em.persist(album);
                });
        }


        private static void createPersistenceContext(Consumer<EntityManager> consumer) {
                EntityManager em = emf.createEntityManager();
                EntityTransaction tx = em.getTransaction();
                
                try {
                        tx.begin();
                        
                        consumer.accept(em);
                        
                        tx.commit();
                } catch (Exception e) {
                        tx.rollback();
                } finally {
                        em.close();
                }
                emf.close();
        }
}

 

자동으로 2 SQL

 

JPA 자동으로 객체와 테이블 간극을 매핑해준다.

 

 

연관관계

객체는 참조를 통해 해당 객체에 접근한다.

테이블은 외래 키를 통해 조인으로 연관 테이블을 조회한다.

 

객체의 참조와 RDB 외래 사이 패러다임 불일치는 RDB 구조를 객체지향 모델링에 적용 시키는 것이 어렵다.

 

참조의 경우 단방향이다.

 

테이블의 경우 외래 키로 관계를 맺으므로, 방향이라는 것이 없다. 굳이 따지면 양방향이다.

 

 

객체를 테이블에 맞추어 모델링

패러다임 불일치를 가장 크게 체감할 있는 방법은 객체를 테이블에 맞춰서 설계해보는 것이다.

 

위와 같은 설계는 데이터를 DB 저장하기는 편하다.

문제는 RDB 경우 값으로 조인을 관계를 맺어준다.

객체는 값으로 관계를 맺어줄 수가 없다. 참조로 연결해야 연관된 객체를 있다.

 

 

처럼 객체지향에 맞춰서 설계를 하면, DB 데이터를 객체에 맞춰야한다.

과정을 JPA 자동으로 해준다.

, 개발자는 마치 컬렉션에서 객체를 꺼내듯 사용하면, DB에서 엔티티가 조회된다.

 

 

 

 

JPA 알아서 패러다임 불일치를 해결해준다.

 

처럼 객체 참조를 통해 이동하는 것을 객체 그래프 탐색이라고 한다.

 


JPA 비교와 그냥 비교

 

 

객체 비교의 두가지 방법

동일성은 == 비교이다.

동등성 비교는 equals() 비교이다

 

동일성은 참조 변수의 경우 같은 인스턴스인지 확인한다.

동등성은 서로 다른 객체여도 내용이 같은지 확인한다.

 

 

 

여기서 중요한 점은 JPA 조회한 회원 객체이다.

같은 영속성 컨텍스트에서 조회한 멤버는 동일성을 보증한다.

 

정리

객체 모델과 RDB 모델은 지향하는 패러다임이 다르다.

객체지향 어플리케이션을 더욱 객체지향스럽게 디자인 수록

패러다임 불일치가 커진다.

JPA 이런 패러다임 불일치 문제를 해결해준다.

JPA 개발자로 하여금 계속 객체지향 모델링을 유지하도록 도와준다.

 

 

 

JPA 무엇인가

JPA Java Persistence API

자바 진영의 ORM 기술 표준

ORM Object-Relational Mapping

객체와 RDB 매핑한다는

 

JPA 제외하고도 모든 자바 기반 기술은 DB 접속은 JDBC API 사용한다.

 

 

ORM 프레임워크는 객체와 테이블 매핑에서 오는 패러다임 불일치 문제를 해결해준다.

개발자는 자바 코드에서 컬렉션에 객체를 저장하듯 ORM 프레임워크에 저장하면, 나머지는 작업은 ORM 프레임워크가 알아서 해준다.

가장 유명한 ORM 프레임워크는 하이버네이트다.

 

JPA 자바 ORM 기술에 대한 API 표준 명세로, 바꿔 말하면, 인터페이스 묶음이다.

, 실질적인 구현체 하나를 선택해 사용한다.

 

JPA 사용해야 하나

장점으로 생산성, 유지보수성, 패러다임 불일치 해결, 성능, 데이터 접근 추상화(벤더 독립성) 있다.

 

지루하고 반복적인 CRUD SQL SQL 객체 사이 데이터 매핑을 필요가 없다.

엔티티에 필드가 변경되어도 이전 JPA사용하기 전보다 훨씬 적은 양의 코드만 손보면 된다.

JPA 객체 RDB 매핑을 해주기 때문에 개발자는 객체의 참조를 그대로 사용해 객체 그래프 탐색을 있다. 원래라면 개발자가 조인 쿼리를 짜고, 나온 데이터를 전부 객체에 알맞게 매핑해줘야하는 번거로운 일이다. 때문에 과거에는 객체를 테이블에 맞춰 데이터 중심으로 사용했다.

JPA 애플리케이션과 DB 사이에서 동작한다. 사이에서 캐시 역할 등으로 성능 최적화 기회를 얻는다.

데이터 접근이 단계 추상화된 방언(Dialect) 계층이 있다.

따라서 DB 변경이 자유롭다. 알맞은 벤더의 방언으로 교체하기만 하면 방언이 알아서 SQL 변경해준다.

극단적으로 개발은 Mysql 운영은 오라클로 바꿀 있다.

 

 

 

 

'개발 > JPA' 카테고리의 다른 글

06 다양한 연관관계 매핑  (0) 2024.04.14
05 연관관계 매핑 기초  (1) 2024.03.22
04 엔티티 매핑  (1) 2024.02.26
03 영속성 관리  (1) 2024.02.19
01 JPA 환경 설정  (0) 2023.11.23

 

 

Clean Code(클린 코드) | 로버트 C. 마틴 | 인사이트- 교보ebook

애자일 소프트웨어 장인 정신, 나쁜 코드도 돌아는 간다. 하지만 코드가 깨끗하지 못하면 개발 조직은 기어간다. 매년 지저분한 코드로 수많은 시간과 상당한 자원이 낭비된다. 그래야 할 이유

ebook-product.kyobobook.co.kr

코드

https://github.com/rkwhr0010/clean_code/tree/main/src

변경 사항은 git history 참고

 

프로그램의 가장 기본 단위가 함수다. (자바 기준 메서드)

 

원본 코드

public class HtmlUtil {
    public static String testableHtml(PageData pageData, boolean includeSuiteSetup) throws Exception {
        WikiPage wikiPage = pageData.getWikiPage();
        StringBuffer buffer = new StringBuffer();
        if (pageData.hasAttribute("Test")) {
            if(includeSuiteSetup) {
                WikiPage suiteSetup =
                    PageCrawlerImpl.getInheritedPage(SuiteResponder.SUITE_SETUP_NAME, wikiPage);
                if(suiteSetup != null) {
                    WikiPagePath pagePath = suiteSetup.getPageCrawler().getFullPath(suiteSetup);
                    String pagePathName = PathParser.render(pagePath);
                    buffer.append("!include -setup .")
                        .append(pagePathName)
                        .append("\n");
                }
            }
        }
        WikiPage setUp = PageCrawlerImpl.getInheritedPage("SetUp", wikiPage);
        if(setUp != null) {
            WikiPagePath setUpPath = wikiPage.getPageCrawler().getFullPath(setUp);
            String setupPathName = PathParser.render(setUpPath);
            buffer.append("!include -setup .")
                .append(setupPathName)
                .append("\n");
        }
        buffer.append(pageData.getContent());
        if(pageData.hasAttribute("Test")) {
            WikiPage teardown =
                PageCrawlerImpl.getInheritedPage("TearDown", wikiPage);
            if(teardown != null) {
                WikiPagePath tearDownPath = wikiPage.getPageCrawler().getFullPath(teardown);
                String tearDownPathName = PathParser.render(tearDownPath);
                buffer.append("\n")
                    .append("!include -teardown .")
                    .append(tearDownPathName)
                    .append("\n");
            }
            if(includeSuiteSetup) {
                WikiPage suiteTearDown =
                    PageCrawlerImpl.getInheritedPage(SuiteResponder.SUITE_TEARDOWN_NAME, wikiPage);
                if(suiteTearDown != null) {
                    WikiPagePath pagePath = wikiPage.getPageCrawler().getFullPath(teardown);
                    String pagePathName = PathParser.render(pagePath);
                    buffer.append("\n")
                        .append("!include -teardown .")
                        .append(pagePathName)
                        .append("\n");
                }
            }
        }
        pageData.setContent(buffer.toString());
        return pageData.getHtml();
    }
}

 

리팩터링 코드

    public static String renderPageWithSetupsAndTeardowns(
            PageData pageData,
            boolean includeSuiteSetup) throws Exception {
               
        boolean isTestPage = pageData.hasAttribute("Test");
        if (isTestPage) {
            WikiPage wikiPage = pageData.getWikiPage();
            StringBuffer newPageContent = new StringBuffer();
            includeSetupPages(includeSuiteSetup, wikiPage, newPageContent);
            newPageContent.append(pageData.getContent());
            includeTeardownPages(includeSuiteSetup, wikiPage, newPageContent);
            pageData.setContent(newPageContent.toString());
        }
        return pageData.getHtml();
    }

 

 

작게 만들어라!

함수를 만드는 규칙은 하나도 작게, 둘도 작게다.

명확한 근거는 없지만, 저자 경험에서 나온 규칙이다.

 

작은 함수 기준

가로 0 ~ 150

세로 2 ~ 4

들여쓰기 수준 1 ~ 2

 

    public static String renderPageWithSetupsAndTeardowns(
            PageData pageData,
            boolean includeSuiteSetup) throws Exception {
        if (isTestPage(pageData)) {
            includeSetupAndTeardownPages(pageData, includeSuiteSetup);
        }
        return pageData.getHtml();
    }

 

블록과 들여쓰기

제어문과 반복문 속에 들어가는 블록은 원래 줄이어야 한다는 뜻이다.

내부 코드를 함수로 추출하여 이름을 짓는다면, 코드를 이해하기 쉬워ㅣ진다.

 

가지만 해라!

함수는 가지를 해야 한다. 가지를 해야 한다. 가지만을 해야 한다.

 

함수는 함수 이름 아래에서 추상화 수준이 하나인 단계만 수행한다면 함수는 가지 작업만 한다.

함수를 만드는 이유는 개념을 다음 추상화 수준에서 여러 단계로 나누기 위해서다.

 

기존 함수에서 다른 의미를 가지는 함수를 추출할 있다면 함수는 여러 작업을 하는 것이다.

 

함수 섹션

함수에서 섹션이 나눠진다면, 함수는 여러가지 일을 한다는 뜻이다.

가지만 하는 함수는 섹션을 나누기 힘들다.

 

 

함수 추상화 수준은 하나로!

함수가 가지만 잘하려면 모든 문장의 추상화 수준이 동일해야 한다.

 

함수 내에 추상화 수준이 섞이면, 읽는 사람이 헷갈린다.

특히 근본 개념과 세부사항이 섞여있다면, 깨진 창문 처럼 함수는 사람들이 세부사항을 추가하기 시작한다.

 

위에서 아래로 코드 읽기: 내려가기 규칙

좋은 코드는 좋은 책을 읽는 것과 같아야 한다.

높은 추상화 수준 코드에서 점점 낮아지는 추상화 수준으로 코드는 구성돼야 한다.

 

Switch (if-else 포함)

스위치문은 근본적으로 N 가지 일을 처리한다. 그리고 구조적으로 작게 만들기 어렵다.

 

개발 제어문은 사용할 밖에 없다.

 

스위치문은 다형성을 이용해 분리할 있다.

 

예시

  public Money calculatePay(Employee e) throws InvalidEmployeeType{
    switch (e.type) {
      case COMMISSIONED:
        return calculateCommissionedPay(e);
      case HOURLY:
        return calculateHourlyPay(e);
      case SALARIED:
        return calculateSalariedPay(e);
      default:
        throw new InvalidEmployeeType(e.type);
    }
  }

문제점,

함수가 길다.

신규 유형을 추가하기 힘들다.

SRP 위반한다. 코드를 변경할 이유가 하나가 아니다

OCP 위반한다. 신규 유형을 추가 마다 기존 코드가 영향을 받는다.

 

가장 문제

똑같은 유해한 구조가 무한정 반복될 수 있다.

  /*
  * 페이지 48, 가장 큰 문제 예시
  * 똑같은 유해한 구조가 무한정 반복될 수 있다.
  */
  void isPayDay(Employee e, Date date) throws InvalidEmployeeType {
    switch (e.type) {
      case COMMISSIONED:
        /* 뭔가 하는 코드 */
        return ;
      case HOURLY:
        /* 뭔가 하는 코드 */
        return ;
      case SALARIED:
        /* 뭔가 하는 코드 */
        return ;
      default:
        throw new InvalidEmployeeType(e.type);
    }
  }
  void deliverPay(Employee e, Money money) throws InvalidEmployeeType{
    switch (e.type) {
      case COMMISSIONED:
        /* 뭔가 하는 코드 */
        return ;
      case HOURLY:
        /* 뭔가 하는 코드 */
        return ;
      case SALARIED:
        /* 뭔가 하는 코드 */
        return ;
      default:
        throw new InvalidEmployeeType(e.type);
    }
  }

 

개선

public interface EmployeeFactory {
  Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType;
}
public class EmployeeFactoryImpl implements EmployeeFactory {
  @Override
  public Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType {
    switch (r.type) {
      case COMMISSIONED:
        return new CommissionedEmployee(r);
      case HOURLY:
        return new HourlyEmployee(r);
      case SALARIED:
        return new SalariedEmployee(r);
      default:
        throw new InvalidEmployeeType(r.type);
    }
  }
}
public abstract class Employee {
  EmployeeRecord r;
  Employee(EmployeeRecord r) {
    this.r = r;
  }
  public abstract boolean isPayDay() ;
  public abstract Money calculatePay() ;
  public abstract void deliverPay(Money pay) ;
}

추상 팩터리로 객체를 생성하는 switch 문을 외부로 부터 숨긴다.

팩터리 구현체는 switch 문을 구현해 Employee 파생 클래스의 인스턴스를 생성한다.

 

호출자는 Employee라는 인터페이스를 통해 구현부는 모른체 호출하게 된다.

언어 차원에서 다형성으로 인해 실제 파생 클래스 메서드가 호출된다.

 

코드 안에서 다형성을 이용한 switch 문은 번만 사용한다.

 

서술적인 이름을 사용하라!

단편적인 이름은, 함수가 무엇을 하는지 알기 힘들다.

renderHtml()  함수는 무엇을 하는지 정확히 없다.

 

서술적인 이름을 지어 함수가 하는 일을 표현해야 한다.

 

함수 이름이 너무 길거나, 짓기 어렵다면, 함수가 가지 일을 하는지 확인해야 한다.

가지만 하는 함수는 이름을 짓기 쉽다.

 

요즘 IDE 이름 변경이 매우 쉬우니, 좋은 이름이 떠올랐으면 즉시 바꾸자

 

함수 인수

가장 좋은 인수는 0

다음 1

다음 2 항이다. 2 부터는 인수 순서에 의존성이 생긴다.

3 부터는 피하는 좋고,

4 항은 특별한 이유 없이는 사용하면 안된다. (특별한 이유 예시 _ 배열 복사 같은 것은 인수가 많을 밖에 없다)

 

많은 인수는 테스트 코드 작성도 어렵게 한다. 경우의 수가 늘어나기 때문

되도록 인수는 0 ~ 1 유지해야 한다.

 

많이 쓰는 단항 형식

같이 유념하고 개념, 명령과 질의 분리

 

질의와 찾기가 많다

질의

Boolean    isExists("123")

찾기

User         findById("123")

 

자주 사용하지 않지만, 이벤트 형식도 있다.

이벤트 함수는 입력 인수만 있다. 출력 인수는 없다. (명령, command)

함수 호출을 이벤트로 해석해 입력 인수로 시스템 상태를 바꾼다.

passwordAttemptFailedNtimes(int attempts)

 

이벤트 함수는 시스템 상태를 바꾸기에 이름에서 이벤트 함수임을 명확히 해야 한다.

 

경우는 가급적 단항 함수를 피해야 한다.

 

좋은 예시

Void includeSetupPageInto(StringBuffer pageText)

 

StringBuffer includeSetupPageInto(StringBuffer pageText)

항등 함수처럼 자기 자신을 리턴하는 났다.

 

플래그 인수

함수에 Boolean 값을 넣는 것은 좋다.

함수는 여러 가지 일을 하는 함수라는 것을 드러내는 꼴이다.

 

이항 함수, 삼항 함수

이함 함수부터는 인수 순서를 신경써야 한다.

, 고려 사항이 기하급수적으로 증가한다.

 

인수 객체

인수가 2 ~ 3 이상 필요 독자적인 클래스 변수를 고려한다.

  //이것 보다.
  Circle makeCircle(double x, double y, double radius){
    return new Circle(x, y, radius);
  }
  //이것이 더 명료하다. 연관있는 인수를 하나로 묶었기 때문이다.
  Circle makeCircle(Point center, double radius){
    return new Circle(center, radius);
  }

단순한 눈속임처럼 보이지만, 아니다. 서로 연관있는 인수를 하나로 묶었다는 것에서 가치가 있다.

 

인수 목록

가변 인수가 필요한 경우가 있다.

경우는 사실상 이항 함수로 봐야한다.

 

동사와 키워드

함수 의도나 인수의 순서와 의도를 제대로 표현하려면 좋은 함수 이름이 필수다.

 

함수 동사, 인수 명사 이렇게 쌍을 이뤄야 한다.

 

writeField(String name)

경우 누가봐도 이름을 필드에 쓴다는 것을 있다.

 

인수의 순서를 함수 이름에 적시하는 것은 좋은 방법이다.

assertExpectedEqualsActual(expected, actual)

 

부수 효과를 일으키지 마라!

부수 효과는 함수에서 가지를 하겠다고 해놓고 몰래(부수효과) 다른 짓도 하는 행위다.

 

public class UserValidator {
  private Crytograher crytograher;
  public boolean checkPassword(String username, String password) {
    User user = UserGateway.findByName(username);
   
    if(user != User.NULL) {
      String codePhrase = user.getPhraseEncodeByPassword();
      String phrase = crytograher.decrpt(codePhrase, password);
      if("Valid Password".equals(phrase)) {
        Session.initialize();
        return true;
      }
    }
    return false;
  }
}

패스워드가 일치하면 true, 아니면 false 리턴하는 함수다.

 

예시에서 부수효과는 Session.initialize(); 이다

 

함수 이름만 봐선 로그인 성공 세션을 초기화 한다는 것을 없다.

, 사용자가 의도치 않게 인증 세션을 지울 가능성이 있다.

 

또한 시간적 결합이 존재한다.

checkPassword() 함수는 세션을 초기화해도 되는 상황(시간적 결합)에서만 호출 가능하다.

세션을 지울 수도 있기 때문이다.

 

경우 함수 이름에서 이를 명시해 줘야 한다.

checkPasswordAndInitializeSession

 

참고로 함수는 가지 일을 한다

 

명령과 조회를 분리하라!

함수는 뭔가를 수행하거나 뭔가에 답하는 가지 행동만 해야한다.

같이 하면 안된다.

 

  public boolean set(String attrbute, String value) {
    //저장에 성공하면 true를 실패하면 false를 반환한다고 가정
    return false;
  }
  public void doSomething() {
    /* 이상한 코드 형식 */
    if(set("하나", "")) {
    }
  }

명령과 질의를 같이 수행하면 위와 같은 괴상한 코드가 나올 있다.

 

추가로 함수는 이름이 불명확하다.

set() 무슨 동작을 하는지 예상이 안된다.

  //명령
  public void set(String attribute, String value) {
  }
  //질의
  public boolean attributeExists(String string) {
    return false;
  }
  public void doSomething() {
    if(attributeExists("하나")) {
      set("하나", "");
    }
  }

명령과 질의를 분리하고, 이름을 명확히해 주석 같은 정보가 없어도 하는지 있다.

 

오류 코드보다 예외를 사용하라!

명령 함수에서 오류 코드를 반환하는 방식은 명령/조회 분리에 위반한다.

 

오류 코드는 중첩 코드를 야기한다.

반환되는 오류코드를 처리하기 위해 제어문이 필요하기 때문이다.

 

  String something(Page page) {
    if(deletePage(page) == E_OK) {
      if(registry.deleteReference(page.name) == E_OK) {
        if(configKeys.deleteKey(page.name.makeKey()) == E_OK){
          logger.info("page deleted");
        } else {
          logger.info("configKey not deleted");
        }
      } else {
        logger.info("deleteReference from registry failed");
      }
    } else {
      logger.info("delete failed");
      return E_ERROR;
    }
    return E_OK;
  }

오류 코드 대신 예외 사용

  void something(Page page) {
    try {
      deletePage(page);
      registry.deleteReference(page.name);
      configKeys.deleteKey(page.name.makeKey());
    } catch (Exception e) {
      logger.info(e.getMessage());
    }
  }

 

try/catch 블록 뽑기

Try/catch 블록은 구조가 추하다.

정상 처리 코드와 오류 처리 코드를 뒤섞기 때문이다.

여기서 뒤섞인 다는 것은 하나의 함수는 하나만 잘해야 하는데,

오류 처리 코드와 정상 처리 코드가 함께 있다는 것을 의미하는 같다.

 

별도 함수를 뽑아 문제를 제거하는 편이 옳다.

  void delete(Page page) {
    try {
      deletePageAndAllReferences(page);
    } catch (Exception e) {
      logError(e);
    }
  }
  private void logError(Exception e) {
    logger.info(e.getMessage());
  }
  private void deletePageAndAllReferences(Page page) throws Exception {
    deletePage(page);
    registry.deleteReference(page.name);
    configKeys.deleteKey(page.name.makeKey());
  }

 

이렇게 오류 처리 코드와 정상 동작 코드를 분리하면 이해하고 수정하기 쉬워 진다.

 

오류 처리도 가지 작업이다.

오류 처리도 가지 작업이기 때문에 이전 코드에서 별도 함수로 추출해서 정상 코드와 분리한 것이다.

 

Error.java 의존성 자석

에러 코드를 반환한다는 것은 어딘 가에 오류 코드를 반환하기 위한 코드를 정의한 다는 뜻이다.

public enum Error {
    OK,
    INVALID,
    NO_SUCH,
    LOCKED,
    OUT_OF_RESOURCES,
    WATTING_FOR_EVENT;
}
interface OtherError {
  String OK = "OK";
  String INVALID = "INVALID";
  String NO_SUCH = "NO_SUCH";
  String LOCKED = "LOCKED";
  String OUT_OF_RESOURCES = "OUT_OF_RESOURCES";
  String WATTING_FOR_EVENT = "WATTING_FOR_EVENT";
}

 

위와 같은 클래스가 의존성 자석이다.

 

열거형 Error 경우, 새로운 오류를 정의해야 하는 경우 Error 사용하는 모든 클래스를 컴파일 해야 한다.

 

문제로 Error 열거형은 변경이 쉽지 않다.

재컴파일을 피하려고 기존 에러 코드를 재사용하게 된다.

 

오류 코드 대신 예외를 사용하면, 새로운 예외는 Exception 클래스에서 파생되어 기존 코드는 전혀 재컴파일이 필요 없다.

 

반복하지 마라!(Don’t Repeat Yourself : DRY 원칙)

중복의 문제는 변경에 취약하다.

중복이 10 라면 하나의 변경에도 10 수정 해야 한다.

10 번의 수정 과정에서 개발자가 실수를 하지 않는 다는 보장도 없다.

 

현대 소프트웨어에서 가장 문제되는 코드는 중복이다.

그래서 이를 극복하기 위한 다양한 방법들이 존재한다.

 

데이터 베이스도 이런 중복 문제로 정규화를 수행한다.

AOP 중복 제거를 위함이다.

 

구조적 프로그래밍

에츠허르 데이크스트라 구조적 프로그래밍 원칙에 따르면, 모든 함수는 입구와 출구가 하나만 존재해야 한다.

단일입구/단일출구 원칙

 

Break, continue, goto(절대) 사용하면 안된다.

 

규율은 함수가 때만 이익을 제공한다.

작은 함수에선 효과가 없다.

 

작은 함수에선 여러 출구가 오히려 함수 표현에 도움될 때도 있다.

 

함수를 어떻게 짜죠?

글쓰기라 생각하면 된다.

일단 생각한 바를 기록한 다듬고, 다듬는다.

 

이를 함수에 대입하면,

일단 동작을 하는 로직을 만든다. 이땐 들여쓰기가 아무리 많아도 괜찮다.

다만, 초안 작성에도 테스트 코드는 만들면서 진행해야 한다.

 

함수를 쪼개거나 이름을 짓는 , 이후 리팩터링을 한다.

 

결론

대가 프로그래머는 시스템을 구현할 프로그램이 아닌 풀어갈 이야기로 여긴다.

프로그래밍 언어라는 수단을 사용해 표현려기 강한 언어를 만들어 이야기를 풀어간다.

함수가 이를 표현하는 언어에 속한다.

 

좋은 함수는 길이가 짧고, 이름이 좋고, 체계가 잡힌 함수다.

좋은 함수의 궁극적 목표는 시스템 이야기를 풀어가는 것이다.

'IT책, 강의 > 클린코드(Clean Code)' 카테고리의 다른 글

5장 형식 맞추기  (0) 2023.12.11
4장 주석  (1) 2023.12.04
2장 의미 있는 이름  (1) 2023.11.20
1장 깨끗한 코드  (0) 2023.11.13
다시 시작  (0) 2023.11.10

DB 설치

Mysql 진행

나는 도커로 Mysql 설치했으나, 로컬에 설치해도 상관 없음

도커

docker run --name test-mysql -e MYSQL_ROOT_PASSWORD=root -p 55555:3306 -d mysql:8.1

로컬 포트는 55555 사용했다. 도커에서 Mysql 포트 3306 매핑한다.

 

DB 스키마 계정 생성

mysql -u root -p




CREATE DATABASE jpa CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'root' IDENTIFIED BY 'root';
GRANT ALL PRIVILEGES ON jpa.* TO 'root';

 

 

DB 접속 툴은 DBeaver

 

STS(이클립스) 기준

프레임워크 없이 단순 JPA만 실습하기 위한 프로젝트 설

 

 

메이븐 의존성 pom.xml



<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>jpa-basic</groupId>
    <artifactId>jpa-01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <hiberate.version>6.0.0.Final</hiberate.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hiberate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-hikaricp</artifactId>
            <version>${hiberate.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.21.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

영속성 유닛 설정

특이사항으로 이제 jakarta 패키지 명을 사용한다.

 



<?xml version="1.0" encoding="utf-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
    version="3.0">
    <persistence-unit name="studyjpa" transaction-type="RESOURCE_LOCAL">
        <properties>
            <!-- DB 연결 정보 -->
            <property name="jakarta.persistence.jdbc.driver"
                value="com.mysql.cj.jdbc.Driver" />
            <property name="jakarta.persistence.jdbc.url"
                value="jdbc:mysql://localhost:55555/jpa?characterEncoding=utf8" />
            <property name="jakarta.persistence.jdbc.user" value="root" />
            <property name="jakarta.persistence.jdbc.password" value="root" />
            <property name="hibernate.hikari.poolName" value="pool" />
            <property name="hibernate.hikari.maximumPoolSize" value="10" />
            <property name="hibernate.hikari.minimumIdle" value="10" />
            <property name="hibernate.hikari.connectionTimeout" value="1000" />
            <!--  MySql 방언 -->
            <property name="hibernate.dialect"
                value="org.hibernate.dialect.MySQLDialect" />
            <!-- SQL 출력 -->
            <property name="hibernate.show_sql" value="true" />
            <!-- SQL 이쁘게 출력 -->
            <property name="hibernate.format_sql" value="true" />
            <!-- 주석도 함께 출력 -->
            <property name="hibernate.use_sql_comments" value="true" />
            <!-- JPA 표준에 맞춘 새로운 키 생성 전략 사용 -->
            <property name="hibernate.id.new_generator_mappings" value="true" />
            <!-- 실습에서만 사용할 것, @Entity에 따라 DDL 명령을 자동 실행해 준다. -->
            <property name="hibernate.hbm2ddl.auto" value="create" />
        </properties>
    </persistence-unit>
</persistence>

 

logf4.xml



<?xml version="1.0" encoding="UTF-8"?>
<configuration status="debug">


    <Appenders>
        <Console name="console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{DEFAULT} %5p [%c] %m%n"/>
        </Console>
    </Appenders>
   
    <loggers>
        <root level="debug" additivity="true">
            <AppenderRef ref="console"/>
        </root>
    </loggers>


</configuration>

 

테스트



package study.jpa.entity;


import java.time.LocalDateTime;


import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;


@Entity
public class User {
        
        @Id
        @GeneratedValue
        private Long id;
        private String name;
        private LocalDateTime registDate;
        
        public Long getId() {
                return id;
        }
        public void setId(Long id) {
                this.id = id;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public LocalDateTime getRegistDate() {
                return registDate;
        }
        public void setRegistDate(LocalDateTime registDate) {
                this.registDate = registDate;
        }
}



import java.time.LocalDateTime;


import org.apache.logging.log4j.*;


import jakarta.persistence.*;
import study.jpa.entity.User;


public class Main {
        static Logger logger = LogManager.getLogger();
        
        public static void main(String[] args) {
                
                
                EntityManagerFactory emf = Persistence.createEntityManagerFactory("studyjpa");
                EntityManager em = emf.createEntityManager();
                EntityTransaction tx = em.getTransaction();
                
                try {
                        tx.begin();
                        
                        logger.info("#################로그 테스트#################");
                        User user = new User();
                        user.setName("홍길동");
                        user.setRegistDate(LocalDateTime.now());
                        em.persist(user);
                        
                        tx.commit();
                } catch (Exception e) {
                        tx.rollback();
                } finally {
                        em.close();
                }
                emf.close();
        }
}

 

 

 

 

 

 

 

'개발 > JPA' 카테고리의 다른 글

06 다양한 연관관계 매핑  (0) 2024.04.14
05 연관관계 매핑 기초  (1) 2024.03.22
04 엔티티 매핑  (1) 2024.02.26
03 영속성 관리  (1) 2024.02.19
02 JPA 소개  (0) 2023.12.01

 

 

Clean Code(클린 코드) | 로버트 C. 마틴 | 인사이트- 교보ebook

애자일 소프트웨어 장인 정신, 나쁜 코드도 돌아는 간다. 하지만 코드가 깨끗하지 못하면 개발 조직은 기어간다. 매년 지저분한 코드로 수많은 시간과 상당한 자원이 낭비된다. 그래야 할 이유

ebook-product.kyobobook.co.kr

코드

https://github.com/rkwhr0010/clean_code/tree/main/src

변경 사항은 git history 참고

 

의도를 분명히 밝혀라

이름을 짓는데 시간을 투자해야 한다. 좋은 이름으로 절약하는 시간이 크기 때문이다.

 

이름 붙일 대상은 전부다. 패키지, 클래스, 변수

 

주석이 필요한 것은 의도가 명확하지 않은 것이다.

class Ex001 {
    void 의도를분명히밝혀라(){
        /**
         * 주석이 필요하면 의도가 명확하지 않은 것
         */
        Date d; // 도착시간
       
        /**
         * 의도는 명확히
         */
        Date arrivalTime;
    }
}

 

class Ex002 {
    List<int[]> theList = new ArrayList<>();
    public List<int[]> getThem(){
        List<int[]> list1 = new ArrayList<>();
        // theList 내용물이 뭐지?
        theList.stream()
            .filter(intArr -> intArr[0] == 4) // intArr[0] == 4 는 뭐지?
            .forEach(intArr -> list1.add(intArr));
        //반환되는 리스트는 어떻게 사용하지?
        return list1;
    }
}

코드 로직은 쉬우나, 무엇을 하는 코드인지 판단이 안된다.

 

class Ex002_2 {
    //지뢰찾기 게임이라는 것을 알아냈다.
    private static final int FLAGGED = 4;
    private static final int STATUS_VALUE = 0;
    List<int[]> gameBoard = new ArrayList<>();
    public List<int[]> getFlaggedCells(){
        List<int[]> flaggedCells = new ArrayList<>();
        gameBoard.stream()
            .filter(cell -> cell[STATUS_VALUE] == FLAGGED)
            .forEach(flaggedCells::add);
           
        return flaggedCells;
    }
}

 

코드 로직은 변경된게 하나 없이, 좋은 이름만으로 의도가 명확해 졌다.

 

class Ex002_3 {
    List<Cell> gameBoard = new ArrayList<>();
    public List<Cell> getFlaggedCells(){
        List<Cell> flaggedCells = new ArrayList<>();
        gameBoard.stream()
            .filter(Cell::isFlagged)
            .forEach(flaggedCells::add);
           
        return flaggedCells;
    }
    class Cell {
        private int[] status;
        private static final int FLAGGED = 4;
        private static final int STATUS_VALUE = 0;
        public boolean isFlagged() {
            return FLAGGED == status[STATUS_VALUE];
        }
    }
}

나아가 int[] 배열 대신, 별로 클래스를 만들어 로직을 캡슐화 했다.

 

그릇된 정보를 피하라

그릇된 정보는 코드 의미를 흐린다.

축약어 같은 경우 보는 사람 관점에서 서로 다르게 해석될 여지가 있다.

hp 같은 경우 게임을 좋아하는 사람은 health point 노트북을 좋아하는 사람은 hp 회사를 떠올린다.

 

자료구조와 연관된 단어는 신중히 사용한다.

Account 여러 개를 그룹화하는 컨테이너를 만든다고 가정하면 AccountList 같은 이름은 List 구현한 처럼 보이기에 사용하면 안된다.

실제로 컨테이너가 List라도 List이름을 붙이는 것을 지양해야 한다.



class Ex003 {
    class Account {}
    class AccountList{} // 안 좋은 이름 마치 List를 구현한 것 처럼 느껴진다.
    //GOOD
    class AccountGroup{}
    class Accouts{}
}

 

되도록 비슷한 이름을 사용하는 것을 피해야 한다.

인지적으로 찾기 너무 힘들다.

클래스 이름이 만약 앞부분 제외하고, 같아면 크게 상관 없겠지만,

이름 길이도 비슷한데, 중간 부분 철저만 조금 다르면, 다른 점을 찾기가 힘들다.

 



class Ex003_2 {
    void exam(){
        //아무 의미없는 임시 변수명 지양
        int a = 0;
        int b = 1;
        if(a == b) {
            a = 10;
        }
    }
    void exam2(){
        //아무 의미없는 임시 변수명에, 비슷한 철자까지 더 하면 더 끔찍하다.
        int i = 0;
        int l = 1;
        int I = 2;
    }
    void exam3(){
        //보통 기업들 코딩 컨벤션을 보면, 임시 변수는 아래와 같이
        //반복문에 같은 곳에만 허용한다.
        for(int i = 0; i < 10; i++){
        }
    }
}

 

 

의미 있게 구분하라

 



class Ex004 {
    //나쁜 이름
    public static void copyChars(char[] a1, char[] a2){
        for(int i = 0; i < a1.length; i++){
            a2[i] = a1[i];
        }
    }
}
class Ex004_2 {
    //의미가 분명한 좋은 이름
    public static void copyChars(char[] source, char[] destination){
        for(int i = 0; i < source.length; i++){
            destination[i] = source[i];
        }
    }
}

a1, a2 같은 불용어를 쓰면, 어느 배열에서 어느 배열로 복사하는 로직을 봐야지 있다.

, 정보를 제공하지 않는 의미없는 불용어 때문에 메서드 내부 구조를 봐야한다.

 

불용어

문자 의미를 파악하는 기여하는 거의 없는 문자를 불용어라고 한다.

주로 접두나 접미에 많이 위치한다.

My, Info, Data, a, The 같은 것이 불용어다.

 

과거 좋은 IDE 없던 시절엔 유의미한 경우가 있었지만, 지금은 의미가 없다.

예를 들어, strName  String 타입 name 이라는 뜻이지만,

현재는 IDE 명확히 타입을 알려주기에 str 의미가 없는 불용어다.

 

만약, 계좌에 대한 정보를 담은 클래스를 찾아야하는

Account AccontInfo 클래스를 발견했다.

어떤 클래스를 봐야하는 알수가 없다.

 

남이 봤을 명확히 구분되는 이름을 사용해야 한다.

 

발음하기 쉬운 이름을 사용하라

인간의 두뇌는 단어라는 철자 묶음을 처리한다.

대부분의 단어는 발음하기도 쉽다.

따라서 발음하기 쉬운 이름은 단어를 사용하는 것이다.

 

이는 지나친 축약어에서 발견된다.

//발음하기 쉬운 이름을 사용하라
class Ex005 {
    //안 좋은 예
    private Date modymdhms; //y년, m월, d일, h시, m분, s초;
    //좋은 예
    private Date modificationTimestamp;
}

 

검색하기 쉬운 이름을 사용하라

문자 하나를 사용하는 상수는 찾기가 힘들다.

예시 ) 0, 1 , a, i

 

이런 이유로 이름이 검색이 쉬운 것은 당연하다.

 

이름의 길이는 자신이 속한 스코프 범위에 비례해야 한다.

 

예를 들어, 반복문 i 같은 변수는 괜찮다. 그런데 멀리 외부 범위 여기 저기서 읽어오는 변수이름이 i 라면 정말 찾기 힘들다.

class Ex006 {
    void bad() {
        //예시 용 변수
        int s = 0;
        int[] t = null;
        for (int j = 0; j < 34; j++ ) {
            s += (t[j] * 4 ) / 5;
        }
    }
}

s 그나마 누산용 변수인 것을 있다.

34까지 반복하는지 파악이 안된다.

t[] 배열은 무슨 배열이고, 계산식도 어떤 의미인지 파악이 안된다.

 

class Ex006_2 {
    void good() {
        //예시 용 변수
        int[] taskEstimate = null;
        int realDaysPerIdealDay = 4;
        final int WORK_DAYS_PER_WEEK = 5;
        int sum = 0;
        for (int j = 0; j < WORK_DAYS_PER_WEEK; j++ ) {
            int realTaskDays = taskEstimate[j] * realDaysPerIdealDay;
            int realTaskWeeks = (realTaskDays / WORK_DAYS_PER_WEEK);
            sum += realTaskWeeks;
        }
    }
}

의미 있는 이름을 지으면, 메서드가 길어진다.

그래도 무엇을 하는지 있으며, 검색하기 쉽다.

 

인코딩을 피하라

이름에 불필요한 정보를 더하지 말아야한다.

 

헝가리식 표기법

프로그래밍에서 변수 함수 인자 이름 앞에 데이터 타입을 명시하는 표기법

String strName;

 

헝가리식 표기법이 대표적

 

과거에는 자원 문제로 이름 길이가 제한되거나, 컴파일러 기능이 미약해 타입 감지를

해줬다.

 

현재는 상황이 다르다. 필요없다.

 

자신의 기억력을 자랑하지 마라

i, s ,r 같이 한글자로 지어놓고, 기억해놨으니 괜찮다는 식은 안좋다.

아무리 자신의 기억력이 좋아도, 한참 보면 무슨 역할 변수인지 없다.

 

클래스 이름

명사나 명사구가 적합하다. 동사는 사용하지 않는다.

JSONParser, Product

불용어가 들어가게 조심한다.

ProductInfo, ProductData

 

메서드 이름

동사나 동사구가 적합하다.

 

 

기발한 이름은 피하라

코드를 개발한 자신만 있다. 심지어 나중에 자신이 봐도 기억 못할 있다.

무조건 명확한 이름이 좋다.

 

개념에 단어를 사용하라

메서드들을 예시로 들면

찾는 것은 find, 저장은 save, 삭제는 delete 것을 있다.

찾기라는 개념을 fetch, retrieve, search 혼용해서 사용하면 안된다.

말장난을 하지 마라



class Ex007 {
    //다른 곳도, add 어휘 메서드는 무언 가를 더한 값을 리턴한다.
    int add(int left, int right) {
        return left + right;
    }
    //무언가 컨테이너에 값을 더하는 메서드가 필요해서
    //구현하고 이름을 add로 지으면, 기존 add 어휘가 가지는 의미가 두 개가 된다.
    List<Object> list;
    void add(Object obj){
        list.add(obj);
    }
    //add 어휘에 일관성을 지키기 위해 insert라는 이름으로 바꾼다.
    void insert(Object obj){
        list.add(obj);
    }
}

 

해법 영역에서 가져온 이름을 사용하라

디자인 패턴이나, 알고리즘 같은 용어를 사용하는 것이 좋다.

적절한 해법 영역에 용어가 없다면, 문제 영역에서 이름을 가져온다.

 

코드 성격이 문제 영역인지, 해법 영역인지 어느 쪽에 가까운 판단 이름을 지어야 한다.

 

의미 있는 맥락을 추가하라

변수 하나의 이름이 스스로 의미있는 맥락을 가지는 경우는 거의 없다.



class Ex008_2 {
    //addr 라는 접두를 추가해 맥략을 분명히 했다.
    void eaxm() {
        String addrFirstName, addrLastName, addrStreet
            , addRhouseNumber, addrCity, addrState, addrZipcode;
        /*
         * 무언가 하는 코드...
         */
    }
}
class Ex008_3 {
    void eaxm() {
        Address address = new Address();
        /*
         * 무언가 하는 코드...
         */
    }
    //더 좋은 방법은 야에 새로운 클래스로 같은 맥락 변수를 묶는 것이다.
    class Address {
        String firstName, lastName, street, houseNumber, city, state, zipcode;
    }
}

불필요한 맥락을 없애라

미래 백화점 어플리케이션을 만든다고 가정하고,

어플리케이션에 클래스를 만드는데 굳이 불필요하게

Future Department Store 약어로 FDS 접두로 클래스마다 붙이는 것은 의미가 없다.

 

마치면서

우리는 클래스, 메서드 등에 붙은 모든 이름을 외우지 못한다.

좋은 이름을 짓는 것은 매우 중요하다.

 

'IT책, 강의 > 클린코드(Clean Code)' 카테고리의 다른 글

4장 주석  (1) 2023.12.04
3장 함수  (1) 2023.11.27
1장 깨끗한 코드  (0) 2023.11.13
다시 시작  (0) 2023.11.10
마무리  (0) 2022.11.15

 

 

Clean Code(클린 코드) | 로버트 C. 마틴 | 인사이트- 교보ebook

애자일 소프트웨어 장인 정신, 나쁜 코드도 돌아는 간다. 하지만 코드가 깨끗하지 못하면 개발 조직은 기어간다. 매년 지저분한 코드로 수많은 시간과 상당한 자원이 낭비된다. 그래야 할 이유

ebook-product.kyobobook.co.kr

https://github.com/rkwhr0010/clean_code/tree/main/src

 

 

코드란 고객의 요구사항을 표현하는 언어다.

 

나쁜코드

당장의 일정 때문에 빠르게 "구동만 되는" 코드를 만들다보면, 시간이 지남에 따라 결국 코드 때문에 유지보수가 힘들어져 생산성 저하로 이어진다.

 

결과적으로 클린코드는 유지보수 용이성이 상승하여, 생산성 증대를 가져온다.

 

르블랑의 법칙

나중은 결국 오지 않는다. 지금해야 한다.

 

태도

코드 하나를 수정하려고 했는데, 다른 코드까지 수정해야 하는 경험을 해본 있을 것이다.

 

이는 개발자의 핵심이 크다.

 

요구사항이 자주 변경되거나, 일정이 촉박하다고 변명하면 안된다.

의사 선생님에게 간단한 외과 진료를 받는데, 빨리 치료받게 손씻지 말라고, 요구해서 의사가 손을 씻는 것을 본적 있는가?

 

나쁜 코드의 위험을 이해하지 못하는 관리자 말을 그대로 따는 것은 프로 답지 못한 행동이다.

 

난제

나쁜 코드는 업무 속도를 늦추게 되어있다.

하지만, 당장 눈앞에 시간을 맞추려고, 나쁜 코드를 양산하는 유혹에 빠진다.

 

이게 나쁜 것임을 알고 있지만, 앞의 일정을 지키려고, 나쁜 코드를 양산한다.

 

결과적으로 보자, 종국엔 나쁜 코드 때문에 어차피 기한을 맞추지 못할 날이 것이다.

결국, 빨리 가는 유일한 방법은 클린 코드다.

 

깨끗한 코드

클린 코드와 나쁜 코드를 구분할 아는 것과 직접 클린 코드를 작성하는 것은 다르다.

우리 목표는 클린 코드를 작성하는 방법을 채득하는 것이다.

 

비야네 스트롭스트룹
"나는 우아하고 효율적인 코드를 좋아한다. 논리가 간단해야 버그가 숨어들지 못한다. 의존성을 최대한 줄여야 유지보수가 쉬워진다. 오류는 명백한 전략에 의거해 철저히 처리한다. 성능을 최적으로 유지해야 사람들이 원칙 없는 최적화로 코드를 망치려는 유혹에 빠지지 않는다. 깨끗한 코드는 가지를 제대로 한다."

 

깨끗한 코드는 "보기에 즐거운" 코드다.

나쁜 코드는 코드를 고치면서 나쁜 코드를 만들게 한다.

 

깨진 창문 효과

깨진 창문은 관리되지 않는 느낌을 준다. 누구도 깨진다고 신경쓰지 않는다.

나중엔 자신도 창문을 깬다.

, 일단 창문이 깨지면 쇠퇴하게 된다.

 

깨끗한 코드는 세세한 사항까지 처리하는 코드다.(명명법, 메모리 누수 )

 

깨끗한 코드는 가지를 잘한다. 나쁜 코드는 여러 일을 하려다 목적과 의도가 모호해 진다.

 

그래디 부치
"깨끗한 코드는 단순하고 직접적이다. 깨끗한 코드는 문장처럼 읽힌다. 깨끗한 코드는 결코 설계자의 의도를 숨기지 않는다. 오히려 명쾌한 추상화와 단순한 제어문으로 가득하다."

 

깨끗한 코드는 소설과 같이 읽혀야 한다.

기승전결이 명확한 것처럼 클린 코드를 읽을 코드의 목적과 개발자가 의도한 바를 있어야 한다.

 

데이브 토마스
"깨끗한 코드는 작성자가 아닌 사람도 읽기 쉽고 고치기 쉽다. 단위 테스트 케이스와 인수 테스트 케이스가 존재한다. 깨끗한 코드에는 의미 있는 이름이 붙는다. 특정 목적을 달성하는 방법은 여러 가지가 아니라 하나만 제공한다. 의존성은 최소이며 의존성을 명확히 정의한다. API 명확하며 최소로 줄였다. 언어에 따라 필요한 모든 정보를 코드만으로 명확히 표현할 없기에 코드는 문학적으로 표현해야 마땅하다."

 

읽기 쉬운 코드와 고치기 쉬운 코드는 별개다.

 

테스트 케이스가 없는 코드는 아무리 우하한 코드라도 깨끗한 코드가 아니다.

 

코드 보다 작은 코드가 좋다.

 

마이클 페더스
"깨끗한 코드의 특징은 많지만 중에서도 모두를 아우르는 특징이 하나 있다. 깨끗한 코드는 언제나 누군가 주의 깊게 짰다는 느낌을 준다. 고치려고 살펴봐도 딱히 곳이 없다. 작성자가 이미 모든 사항을 고려했으므로, 고칠 궁리는 하다보면 언제나 제자리로 돌아온다. 그리고는 누군가 남겨준 코드, 누군가 주의 깊게 짜놓은 작품에 감사를 느낀다."

 

깨끗한 코드는 누군가 시간을 들여 깔끔하고 단정하게 정리한 코드다.

 

제프리스(요약)
중요도 좋은코드
  • 모든 테스트를 통과한다.
  • 중복이 없다.
  • 시스템 모든 설계 아이디어를 표현한다.
  • 클래스, 메서드, 함수 등을 최대한 줄인다.
표현력이 좋은 코드
  • 이름이 중요하다. 요즘 IDE 이름 변경이 매우 쉬워 좋은 이름으로 변경하기 좋다.
  • 책임이 많은 객체나 메서드를 찾아 여러 개로 나눠야 한다.
 
표현력이 좋은 코드
  • 프로그램에서 유사한 요소 집합이 보이면, 추상화한다.
    다시말해, 추상 클래스나 인터페이스로 실제 구현을 감싼다.
    이렇게 되면, 호출하는 쪽은 인터페이스를 바라보기 때문에 변경에 강한 코드가 된다

작게 추상화, 중복 제거, 기능만

 

 

워드 커닝햄
"코드를 읽으면서 짐작했던 기능을 루틴이 그대로 수행한다면 깨끗한 코드라 불러도 되겠다. 코드가 문제를 풀기 위한 언어처럼 보인다면 아름다운 코드라 불러도 되겠다."

 

깨끗한 코드는 독해를 필요가 없어야 한다. 명백하고 단순하기 때문이다.

 

접근법

의심하지 말고, 빠져서 익혀볼 , 그렇다고 다른 방법론이 거짓이라는 것이 아니다.

충분히 학습 다른 방법론도 익히면서, 견문을 넓일

 

우리는 저자다

실제로 개발을 시작하면, 코드를 읽는 시간이 코드를 짜는 시간보다 훨씬 많다.

따라서 읽기 쉬운 코드를 짜는 것은 중요하다. 그래야 코드를 빠르게 있다.

 

보이스카우트 규칙
"캠프장은 처음 왔을 때보다 깨끗하게 해놓고 떠나라."

체크인 때보다 체크아웃 보다 깨끗한 코드를 만들면 된다.

노력을 기울일 필요 없다.

중요한 것은 지속성이다.

 

 

원칙

SOLID

  • SRP (Single Responsibility Principle)
    클래스는 변경할 , 가지 이유만 존재해야 한다.
  • OCP(Open Closed Principle)
    클래스는 확장엔 열리고, 변경에 닫혀 있어야 한다.
  • LSP(Liskov Substitution Principle)
    상속받은 클래스는 기초 클래스로 대체할 있어야 한다.
  • DIP(Dependency Inversion Principle)
    추상화에만 의존해야 한다. 구체화에 의존하면 안된다.
  • ISP(Interface Segregation Principle)
    클라이언트가 필요한 만큼 인터페이스로 기능을 최소한으로 분리해 제공해야 한다.

'IT책, 강의 > 클린코드(Clean Code)' 카테고리의 다른 글

3장 함수  (1) 2023.11.27
2장 의미 있는 이름  (1) 2023.11.20
다시 시작  (0) 2023.11.10
마무리  (0) 2022.11.15
13장 동시성 - 2  (1) 2022.11.12

이 책은 처음 읽었을 당시는 머리에 남는 것은 좋은 이름 밖에 없었는데

지금 개발을 시작한지 2년이 약간 안되는 시점에 다시 읽어보니 훨씬 더 좋은 책이라는 것을 깨닫고 있다.

 

처음 읽었을 당시 개발을 접한지 1년도 안된 시점이라 잘 이해도 안갔다.

현재는 비교적 수월하게 읽히도 글귀에 숨겨진 의미도 보인다. 당시엔 객체지향 원칙, 디자인 패턴 등을 전혀 몰라서 이 책의 정수를 내것으로 취하지 못했다.

 

이렇게 좋은 책을 다시 읽지 않으면 나만 손해인 것 같아 다시 정리를 시작

 

https://ebook-product.kyobobook.co.kr/dig/epd/ebook/E000003160816

 

Clean Code(클린 코드) | 로버트 C. 마틴 | 인사이트- 교보ebook

애자일 소프트웨어 장인 정신, 나쁜 코드도 돌아는 간다. 하지만 코드가 깨끗하지 못하면 개발 조직은 기어간다. 매년 지저분한 코드로 수많은 시간과 상당한 자원이 낭비된다. 그래야 할 이유

ebook-product.kyobobook.co.kr

 

'IT책, 강의 > 클린코드(Clean Code)' 카테고리의 다른 글

2장 의미 있는 이름  (1) 2023.11.20
1장 깨끗한 코드  (0) 2023.11.13
마무리  (0) 2022.11.15
13장 동시성 - 2  (1) 2022.11.12
13장 동시성 - 1  (0) 2022.11.08

+ Recent posts