Books
클린코드 10장
채마스
2022. 4. 30. 11:17
개요
- 이번 장에서는 클래스를 깨끗하게 짜는 방법을 공부한다.
클래스 체계
- 클래스를 정의하는 표준 자바 관례에 따르면, 아래와 같은 순서로 클래스를 정의한다.
정적 공개 상수(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장