클린코드 10장

개요

• 이번 장에서는 클래스를 깨끗하게 짜는 방법을 공부한다.

 

클래스 체계

• 클래스를 정의하는 표준 자바 관례에 따르면, 아래와 같은 순서로 클래스를 정의한다.
  • 정적 공개 상수(static public final)
  • 정적 비공개 상수(static private final)
  • 정적 비공개 변수(static private)
  • 비공개 인스턴스 변수(private)
  • 공개 함수(public method)
• 즉, 추상화 단계가 순차적으로 내려간다.

 

캡슐화

• 변수와 유틸리티 함수는 가능한 공개하지 않는 편이 낫다.
• 때때로 테스트를 위해서 private method나 변수를 protected로 공개해야 할 경우가 있다.
• 하지만 그 전에 비공개 상태를 유자할 방법을 강구해야한다.
• 캡슐화를 풀는것은 언제나 최후의 수단이다.

 

클래스는 작아야 한다.

• 클래스는 작아야 한다.
• 클래스를 설계할 때도, 함수와 마찬가지로 '작게'가 기본 규칙이다.

 

단일 책임의 원칙

• SRP는 클래스나 모듈을 변경할 이유가 하나, 단 하나뿐이어야 한다 는 원칙이다.
• 아래의 코드는 바람직한 클래스라고 볼 수 있는가?

public class SuperDashboard extends JFrame implements MetaDataUser {
    public Component getLastFocusedComponent()
    public void setLastFocused(Component lastFocused)
    public int getMajorVersionNumber()
    public int getMinorVersionNumber()
    public int getBuildNumber() 
}

• 바람직 하지 못하다. -> 책임(변경할 이유)이 너무 많기 때문이다.
  • 첫 번째 책임: 소프트웨어 버전이 바뀔 경우 변경이 필요하다.
  • 두 번째 책임: Swing의 버전도 관리해야 한다.
• 클래스 이름은 해당 클래스의 책임을 기술 해야한다.
• Processor, Manager, Super 와 같은 애매한 단어가 클래스 이름이 들어간다는 것은 많은 책임을 포함할 확률이 높다.
• 클래스 설명은 if, and, or, but을 사용하지 않고 25단어 이내로 설명이 가능해야 한다.
• 위의 코드를 아래와 같이 바꾸면 어떨까?

public class Version {
    public int getMajorVersionNumber()
    public int getMinorVersionNumber()
    public int getBuildNumber()
}

• 이전 코드에 비해서 훨씬 깨끗한 코드라고 할 수 있다.
• 위와 같이 책임을 분리하게 되면, 다른 책임에 의해서 값을 변경할 일이 없어지고, 클래스의 책임에 더욱 집중할 수 있게 된다.
• 이것은 응집도(Cohesion)가 높아 진다는 말과 같다.
• 많은 개발자들이 단일 책임 클래스가 많아지면 큰 그림을 이해하기 어려워진다고 우려합니다.
• 하지만 작은 클래스가 많은 시스템이든 큰 클래스가 몇개 뿐인 시스템이든 돌아가는 부품의 수는 비슷합니다.
• 오히려 큰 다목적의 클래스는 당장 알 필요가 없는 사실까지 이해해야 한다.
• 결국 클래스가 많아지더라고 작은 클래스 여러개를 보는것이 큰 클래스 하나를 보는것 보다 효율적이다.
• 정리하면 작은 클래스는 각자 맡은 책임이 하나며, 변경할 이유가 하나며, 다른 작은 클래스와 협력해 시스템에 필요한 동작을 수행합니다.

 

응집도

• 클래스는 인스턴스 변수 수가 작아야 한다.
• 각 클래스 메서드는 클래스 인스턴스 변수를 하나 이상 사용해야 한다.
• 일반적으로 메서드가 변수를 더 많이 사용할수록 메서드와 클래스는 응집도가 더 높다.
• 모든 인스턴스 변수를 메서드마다 사용하는 클래스는 응집도가 가장 높다.
• 응집도가 높다는 말은 클래스에 속한 메서드와 변수가 서로 의존하며 논리적인 단위로 묶인다는 의미기 때문이다.
• 아래의 코드를 보자

public class Stack( {
   private int topOfStack = 0;
   List<Integer> elements = new LinkedList<Integer>();

   public int size() {
      return topOfStack;
   }

   public void push(int element) {
      topOfStack++;
      elements.add(element);
   }

   public int pop() throws PoppedWhenEmpty {
      if (topOfStack == 0)
         throw new PoppedWhenEmpty();
      int element = elements.get(--topOfStack);
      elements.remove(topOfStack);
      return element;
   }
}

• 위의 코드는 응집도가 아주 높다.
• size()를 제외한 다른 두 메서드는 두 변수를 모두 사용한다.

 

응집도를 유지하면 작은 클래스 여럿이 나온다.

• '함수를 작게, 매개변수 목록을 짧게' 라는 전략을 따르다 보면, 때때로 몇몇 메서드만이 사용하는 인스턴스 변수가 아주 많아진다.
• 이는 십중팔구 새로운 클래스로 쪼개야 한다는 신호다.
• 예를들어, 변수가 아주 많은 큰 함수 하나가 있다. 큰 함수 일부를 작은 함수 하나로 빼내고 싶은데, 빼내려는 코드가 큰 함수에 정의된 변수 넷을 사용한다. 그렇다면 변수 네 개를 새 함수에 인수로 넘겨야 옳을까?
• 아니다! -> 클래스로 빼는 것이 좋다. -> 네 변수를 클래스 인스턴스 변수로 승격한다면 새 함수는 인수가 필요없다. 그만큼 함수를 쪼개기 쉬워진다.
• 몇몇 함수만 사용하는 인스턴스가 늘어나면 응집력을 잃는다. -> 그렇기 때문에 응집력을 잃은 클래스를 쪼개는 것이 좋다.
• 아래 코드를 보자.

public class PrintPrimes {
    public static void main(String[] args) {
        final int M = 1000; 
        final int RR = 50;
        final int CC = 4;
        final int WW = 10;
        final int ORDMAX = 30; 
        int P[] = new int[M + 1]; 
        int PAGENUMBER;
        int PAGEOFFSET; 
        int ROWOFFSET; 
        int C;
        int J;
        int K;
        boolean JPRIME;
        int ORD;
        int SQUARE;
        int N;
        int MULT[] = new int[ORDMAX + 1];

        J = 1;
        K = 1; 
        P[1] = 2; 
        ORD = 2; 
        SQUARE = 9;

        while (K < M) { 
            do {
                J = J + 2;
                if (J == SQUARE) {
                    ORD = ORD + 1;
                    SQUARE = P[ORD] * P[ORD]; 
                    MULT[ORD - 1] = J;
                }
                N = 2;
                JPRIME = true;
                while (N < ORD && JPRIME) {
                    while (MULT[N] < J)
                        MULT[N] = MULT[N] + P[N] + P[N];
                    if (MULT[N] == J) 
                        JPRIME = false;
                    N = N + 1; 
                }
            } while (!JPRIME); 
            K = K + 1;
            P[K] = J;
        } 
        {
            PAGENUMBER = 1; 
            PAGEOFFSET = 1;
            while (PAGEOFFSET <= M) {
                System.out.println("The First " + M + " Prime Numbers --- Page " + PAGENUMBER);
                System.out.println("");
                for (ROWOFFSET = PAGEOFFSET; ROWOFFSET < PAGEOFFSET + RR; ROWOFFSET++) {
                    for (C = 0; C < CC;C++)
                        if (ROWOFFSET + C * RR <= M)
                            System.out.format("%10d", P[ROWOFFSET + C * RR]); 
                    System.out.println("");
                }
                System.out.println("\f"); PAGENUMBER = PAGENUMBER + 1; PAGEOFFSET = PAGEOFFSET + RR * CC;
            }
        }
    }
}

• 보다싶이 아주 엉망진창이다.
• 위의 코드를 여러 작은 함수와 클래스로 나눈 후 함수와 클래스와 변수에 의미 있는 이름을 부여하면 아래와 같습니다.

public class PrimePrinter {
    public static void main(String[] args) {
        final int NUMBER_OF_PRIMES = 1000;
        int[] primes = PrimeGenerator.generate(NUMBER_OF_PRIMES);

        final int ROWS_PER_PAGE = 50; 
        final int COLUMNS_PER_PAGE = 4; 
        RowColumnPagePrinter tablePrinter = 
            new RowColumnPagePrinter(ROWS_PER_PAGE, 
                        COLUMNS_PER_PAGE, 
                        "The First " + NUMBER_OF_PRIMES + " Prime Numbers");
        tablePrinter.print(primes); 
    }
}

• main 함수 하나를 포함하며 실행 환경을 책임진다.

public class RowColumnPagePrinter { 
    private int rowsPerPage;
    private int columnsPerPage; 
    private int numbersPerPage; 
    private String pageHeader; 
    private PrintStream printStream;

    public RowColumnPagePrinter(int rowsPerPage, int columnsPerPage, String pageHeader) { 
        this.rowsPerPage = rowsPerPage;
        this.columnsPerPage = columnsPerPage; 
        this.pageHeader = pageHeader;
        numbersPerPage = rowsPerPage * columnsPerPage; 
        printStream = System.out;
    }

    public void print(int data[]) { 
        int pageNumber = 1;
        for (int firstIndexOnPage = 0 ; 
            firstIndexOnPage < data.length ; 
            firstIndexOnPage += numbersPerPage) { 
            int lastIndexOnPage =  Math.min(firstIndexOnPage + numbersPerPage - 1, data.length - 1);
            printPageHeader(pageHeader, pageNumber); 
            printPage(firstIndexOnPage, lastIndexOnPage, data); 
            printStream.println("\f");
            pageNumber++;
        } 
    }

    private void printPage(int firstIndexOnPage, int lastIndexOnPage, int[] data) { 
        int firstIndexOfLastRowOnPage =
        firstIndexOnPage + rowsPerPage - 1;
        for (int firstIndexInRow = firstIndexOnPage ; 
            firstIndexInRow <= firstIndexOfLastRowOnPage ;
            firstIndexInRow++) { 
            printRow(firstIndexInRow, lastIndexOnPage, data); 
            printStream.println("");
        } 
    }

    private void printRow(int firstIndexInRow, int lastIndexOnPage, int[] data) {
        for (int column = 0; column < columnsPerPage; column++) {
            int index = firstIndexInRow + column * rowsPerPage; 
            if (index <= lastIndexOnPage)
                printStream.format("%10d", data[index]); 
        }
    }

    private void printPageHeader(String pageHeader, int pageNumber) {
        printStream.println(pageHeader + " --- Page " + pageNumber);
        printStream.println(""); 
    }

    public void setOutput(PrintStream printStream) { 
        this.printStream = printStream;
    } 
}

• 숫자 목록을 주어진 행과 열에 맞춰 페이지에 출력하는 책임을 진다.

public class PrimeGenerator {
    private static int[] primes;
    private static ArrayList<Integer> multiplesOfPrimeFactors;

    protected static int[] generate(int n) {
        primes = new int[n];
        multiplesOfPrimeFactors = new ArrayList<Integer>(); 
        set2AsFirstPrime(); 
        checkOddNumbersForSubsequentPrimes();
        return primes; 
    }

    private static void set2AsFirstPrime() { 
        primes[0] = 2; 
        multiplesOfPrimeFactors.add(2);
    }

    private static void checkOddNumbersForSubsequentPrimes() { 
        int primeIndex = 1;
        for (int candidate = 3 ; primeIndex < primes.length ; candidate += 2) { 
            if (isPrime(candidate))
                primes[primeIndex++] = candidate; 
        }
    }

    private static boolean isPrime(int candidate) {
        if (isLeastRelevantMultipleOfNextLargerPrimeFactor(candidate)) {
            multiplesOfPrimeFactors.add(candidate);
            return false; 
        }
        return isNotMultipleOfAnyPreviousPrimeFactor(candidate); 
    }

    private static boolean isLeastRelevantMultipleOfNextLargerPrimeFactor(int candidate) {
        int nextLargerPrimeFactor = primes[multiplesOfPrimeFactors.size()];
        int leastRelevantMultiple = nextLargerPrimeFactor * nextLargerPrimeFactor; 
        return candidate == leastRelevantMultiple;
    }

    private static boolean isNotMultipleOfAnyPreviousPrimeFactor(int candidate) {
        for (int n = 1; n < multiplesOfPrimeFactors.size(); n++) {
            if (isMultipleOfNthPrimeFactor(candidate, n)) 
                return false;
        }
        return true; 
    }

    private static boolean isMultipleOfNthPrimeFactor(int candidate, int n) {
        return candidate == smallestOddNthMultipleNotLessThanCandidate(candidate, n);
    }

    private static int smallestOddNthMultipleNotLessThanCandidate(int candidate, int n) {
        int multiple = multiplesOfPrimeFactors.get(n); 
        while (multiple < candidate)
            multiple += 2 * primes[n]; 
        multiplesOfPrimeFactors.set(n, multiple); 
        return multiple;
    } 
}

• 소수 목록을 생성하는 책임을 진다.
• 기능은 돌일하지만 책임을 분리함으로써, 응집도를 높이고, 좀더 이해하기 쉽고 관리하기 쉬운 코드가 되었다.
• 다시한번 강조하면, 하나의 거대한 함수보단 하나의 책임을 가진 여러 클래스로 쪼개는 것이 좋다.

 

변경하기 쉬운 클래스

• 시스템은 지속적이 변경된다.
• 그렇기 때문에 클래스를 체계적으로 정리해서 변경에 수반하는 위험을 낮추는 것이 중요하다.
• 아래의 코드를 보자.

public class Sql {
    public Sql(String table, Column[] columns)
    public String create()
    public String insert(Object[] fields)
    public String selectAll()
    public String findByKey(String keyColumn, String keyValue)
    public String select(Column column, String pattern)
    public String select(Criteria criteria)
    public String preparedInsert()
    private String columnList(Column[] columns)
    private String valuesList(Object[] fields, final Column[] columns) 
    private String selectWithCriteria(String criteria)
    private String placeholderList(Column[] columns)
}

• 위의 코드의 문제는 새로운 SQL 문을 지원하거나 기존의 SQL문을 수정하려면 Sql 클래스를 손대야한다.
• 그 이유는 SRP 를 위반했기 때문이다.
• 이런 경우, 공개 인터페이스를 각각 SQL 클래스에서 파생하는 클래스로 만들 수 있다.

abstract public class Sql {
    public Sql(String table, Column[] columns) 
    abstract public String generate();
}

public class CreateSql extends Sql {
    public CreateSql(String table, Column[] columns) 
    @Override public String generate()
}

public class SelectSql extends Sql {
    public SelectSql(String table, Column[] columns) 
    @Override public String generate()
}

public class InsertSql extends Sql {
    public InsertSql(String table, Column[] columns, Object[] fields) 
    @Override public String generate()
    private String valuesList(Object[] fields, final Column[] columns)
}

public class SelectWithCriteriaSql extends Sql { 
    public SelectWithCriteriaSql(
    String table, Column[] columns, Criteria criteria) 
    @Override public String generate()
}

// ...

• 클래스가 서로 분리되었기 때문에 클래스가 단순하고 코드는 순식간에 이해할 수 있게 변했다.
• 또한, 함수 하나를 수정했다고 다른 함수가 망가질 위험도 사라졌다.
  • Update 문을 추가할 때는 기존 클래스를 변경하지 않고 SQL 클래스를 상속받아서 새로운 클래스 UpdateSql를 구현하면 된다.
• 그렇기 때문에 OCP 를 지원한다고 할 수 있다.
  • 확장에는 개방적이고 수정에는 폐쇄적이기 때문이다.
• 정리하면 이상적인 시스템은 새 기능을 추가할 때 시스템을 확장할 뿐 기존 코드를 변경하지 않는다.

 

변경으로부터 격리

• 객체지향 프로그래밍에는 Concrete 클래스(구현)와 Abstract 클래스(개념)가 있다.
• 상세한 구현에 의존하는 클라이언트 클래스는 구현이 바뀔때 위험에 빠진다.
• 그렇기 때문에 항상 인터페이스와 추상 클래스를 사용해 구현이 미치는 영향을 격리함으로써 코드의 변경에 대응해야한다.
• 이렇게 하면 DIP(Dependency Inversion Prinicple) 를 준수한다고 할 수 있다.
  • 클래스가 상세한 구현이 아니라 추상화에 의존해야 한다는 원칙이다.
• 아래의 코드를 보자

public interface StockExchange {
  Money currentPrice(String symbol);
}

public Portfolio {
    private StockExchange exchange;
    public Portfolio(StockExchange exchange) {
        this.exchange = exchange;
    }
    // ...
}

• Portfolio의 생성자에서 StockExchange를 인수로 받도록 한다.
• 이렇게 되면 상세한 구현에 의존하는 것이아니라 주식 가격을 반환한다는 추상적인 개념에 의존하게 된다.

public class FixedStockExchangeStub extends StockExchange {
    //... 생략
}

• StockExchange 를 상속받아 FixedStockExchangeStub 를 정의한다.
• 인터페이스를 굳이 안두고 바로 FixedStockExchangeStub에 currentPrice 메서드를 정의해서 구현하면 안될까?
  • 위에서 언급했듯 추상화에 의존해야 변경에 대응할 수 있다.
• 이제 아래와 같이 테스트할 수 있다.

public class PortfolioTest {
    private FixedStockExchangeStub exchange;
    private Portfolio portfolio;

    @Before
    protected void setUp() throws Exception {
        exchange = new FixedStockExchangeStub();
        exchange.fix("MSFT", 100);
        portfolio = new Portfolio(exchange);
    }

    @Test
    public void GivenFiveMSFTTotalShouldBe500() throws Exception {
        portfolio.add(5, "MSFT");
        Assert.assertEquals(500, portfolio.value());
    }
}

• 위와 같이 테스트가 가능할 정도로 시스템의 결합도를 낮추면 유연성과 재사용성도 더욱 높아진다.
• 결합도가 낮다는 의미는 변경으로부터 잘 격리되어 있다는 것이다.
• 정리하면 상세한 구현이 아니라 추상화에 의존하면 자연스레 DIP를 따르는 클래스를 구현할 수 있다.
• 이와 같이 추상화로 실제로 주가를 얻어오는 출처나 방식과 같은 구체적인 사실은 모두 숨길 수 있다.

REFERENCES

• 클린코드 10장