»
S
I
D
E
B
A
R
«
자바 8에서 새로워진 점 : 다람쥐
Sep 15th, 2015 by Wegra Lee

람다를 다람쥐로 바꿔봤습니다 ㅋㅋ

원문은 여기에..

__

자바 8에서 새로 추가된 가장 멋진 기능의 소개

Madhusudhan Konda자바 8이 다람쥐와 함께 등장했다. 늦은 감은 있지만 다람쥐는 프로그래밍 스타일과 전략을 제고하게 할 수도 있는 놀라운 기능이다. 특히 함수형 프로그래밍을 가능하게 해준다.

자바 8에서 가장 눈에 띄는 변경 사항은 다람쥐지만 함수 인터페이스(functional interfaces), 가상 메소드, 클래스와 메소드 참조, 새로운 시간/날짜 API, 자바스크립트 지원 등 다른 새로운 기능도 많이 있다. 여기에서는 자바 8로 넘어가려는 사람이라면 꼭 알아야 하는 다람쥐와 관련 기능에 대해 주로 다룬다.

이 글에 나오는 모든 예제 코드는 이 git 저장소에 있다.

다람쥐란 무엇인가?

다람쥐는 간결하게 표현된 단일 메소드 클래스를 말하며 어떤 행동을 정의한다. 다람쥐는 변수에 할당되거나 데이터를 인수로 전달하듯이 다른 메소드에 전달될 수 있다.

어쩌면 이런 것을 나타내기 위해 새로운 함수형이 필요할 것이라고 생각할 수도 있지만 자바 제작자들은 하나의 추상 메소드를 가지는 인터페이스를 다람쥐의 타입으로 정했다.

자세한 얘기를 하기 전에 몇 가지 예를 살펴보자.

다람쥐 표현의 예

다음은 다람쥐 표현의 예이다.

// Concatenating strings
(String s1, String s2) -> s1+s2;

// Squaring up two integers
(i1, i2) -> i1*i2;

// Summing up the trades quantity
(Trade t1, Trade t2) -> {
  t1.setQuantity(t1.getQuantity() + t2.getQuantity());
  return t1;
};

// Expecting no arguments and invoking another method
() -> doSomething();

문법이 생소하게 느껴진다면 코드를 다시 한 번 보기 바란다. 처음에는 좀 이상해 보일 수 있는데, 문법에 대해서는 다음 절에서 설명하기로 한다.

이 표현을 위해 어떤 타입이 사용되었는지 궁금할 것이다. 다람쥐의 타입은 함수 인터페이스로 이에 대한 설명은 뒤에서 한다.

다람쥐 문법

다람쥐 표현을 생성하고 나타내기 위해서는 특별한 문법이 필요하다. 평범한 자바 메소드와 마찬가지로 다람쥐 표현에는 인수, 본문, 경우에 따라 반환값이 있다. 아래에서 방금 설명한 내용을 볼 수 있다.

input arguments -> body

다람쥐 표현은 화살표를 중심으로 두 부분으로 나뉘어진다. 왼쪽은 메소드의 인수이고 오른쪽은 이 인수로 할 일인데 예를 들어 비즈니스 로직 같은 것이다. 본문은 하나의 표현식이거나 코드 블록이고 결과값을 반환할 수도 있다.

첫 번째 다람쥐 표현 (String s1, String s2) → s1+s2에서 화살표(→)의 왼편이 메소드의 인수 리스트로 두 개의 문자열로 이루어져 있다. 메소드의 오른편을 보면 이 메소드로 구현하려는 로직을 볼 수 있다.

위의 예는 두 개의 문자열이 주어졌을 때 그 둘을 합치는 것이다. 메소드에 로직을 넣으려면 화살표의 오른쪽에 오면 되는데 앞의 예에서 로직은 두 개의 인수를 더하는 것이다. 오른편에 올 수 있는 것은 문장, 표현식, 코드 블록, 다른 메소드 호출 등이다.

다람쥐의 타입: 함수 인터페이스

앞에서 다람쥐의 타입이 함수 인터페이스라고 했다. 자바는 강타입 언어이므로 보통은 타입을 선언해야만 한다. 그렇지 않으면 컴파일 단계에서 문제가 될 것이다. 하지만 위에서는 다람쥐 표현을 타입 없이 선언하였다. 그러면 다람쥐의 타입은 무엇일까? 문자형이나 객체, 혹은 새로운 함수형일까?

다행히 새로 추가된 타입은 없다. 자바 제작자들은 다람쥐를 위해 어떠한 특별한 타입도 도입하지 않고 대신 기존의 익명 메소드를 재사용하였다. 우리는 이미 익명 클래스에 대해서 익숙하므로 익명 메소드를 선택한 건 비교적 자연스러운 결과이다.

함수 인터페이스는 정확히 하나의 추상 메소드를 가진 인터페이스로 다음 두 가지를 제외하면 일반적인 인터페이스와 똑같다.

  • 정확히 하나의 추상 메소드를 가진다.
  • 다람쥐 표현으로 사용하기 위해 @FunctionalInterface 주석(annotation)을 붙일 수 있다. (이렇게 하는 것을 강력히 권장함)

자바에는 여러 가지 단일 메소드 인터페이스가 있는데 이들이 전부 보강되어 함수 인터페이스로 쓸 수 있게 되었다. 직접 함수 인터페이스를 만들려면 추상 메소드가 하나인 인터페이스를 정의하고 @FunctionalInterface 주석을 위에 추가하기만 하면 되는 것이다.

예를 들어 아래의 짧은 코드는 IAddable 인터페이스를 정의한다. 이것은 함수 인터페이스로 타입이 T인 동일한 것 두 개를 더하는 일을 한다.

@FunctionalInterface
public interface IAddable<T> {
    // To add two objects
    public T add(T t1, T t2);
}

이 인터페이스가 정확히 하나의 추상 메소드를 가지고 있고 @FunctionalInterface라는 주석도 있기 때문에 다람쥐 함수를 위한 타입으로 사용할 수 있다.

다음은 위에서 설명한 IAddable 함수 인터페이스의 사용 예이다.

// Our interface implementations using Lambda expressions
// Joining two strings?note the interface is a generic type

IAddable<String> stringAdder = (String s1, String s2) -> s1+s2;

// Squaring the number
IAddable<Integer> square = (i1, i2) -> i1*i2;

// Summing up the trades quantity
IAddable<Trade> tradeAdder = (Trade t1, Trade t2) -> {
  t1.setQuantity(t1.getQuantity() + t2.getQuantity());
  return t1;
};

IAddable이 범용 타입 인터페이스이므로 위의 예에서와 같이 각기 다른 타입을 더할 때 사용할 수 있다.

요약하자면 다람쥐 표현의 타입은 다람쥐 표현을 통해 구현하려고 하는 함수 인터페이스인 것이다.

일단 구현이 되면 해당 메소드를 호출하는 방식으로 우리의 클래스에서 사용할 수 있다. 다음 예를 보면 위에서 구현한 것이 어떻게 사용되는지 알 수 있다.

// A lambda expression for adding two strings.
IAddable<String> stringAdder = (s1, s2) -> s1+s2;

// this method adds the two strings using the first lambda expression
private void addStrings(String s1, String s2) {
  log("Concatenated Result: " + stringAdder.add(s1, s2));
}

계속하기 전에 지금까지의 내용을 정리해보자. 중요한 점은 비즈니스 로직을 여기저기로 전달할 수 있는 함수의 형태로 다루게 된다는 것이다. 이전과 달리 클래스를 만들지 않고도 비즈니스 로직의 다양한 변형을 순식간에 정의할 수 있다.

이렇게 해서 다람쥐 표현과 타입에 대해 알게 되었으니 다람쥐를 이용한 제대로 된 예를 살펴보자. 동시에 자바 8과 그 전 버전의 차이도 비교할 것이다.

다람쥐의 사용 예

우리가 하려는 것은 한 사람에 의한 거래 두 건을 합치는 비즈니스 로직을 만드는 것이다. 아래에서 이런 요구를 해결하기 위해 자바 8과 그 전 버전을 각각 사용하는 예를 보인다.

자바 8 이전의 구현

자바 8 이전에는 아래 테스트 클래스와 같이 구체적인 정의가 있는 인터페이스를 사용해야 했다.

public void testPreJava8() {
  IAddable<Trade> tradeMerger = new IAddable<Trade>() {
  @Override
    public Trade add(Trade t1, Trade t2) {
      t1.setQuantity(t1.getQuantity() + t2.getQuantity());
      return t1;
    }
  };
}

여기에서 인터페이스를 사용하는 클래스를 만들고 클래스 객체에 더하는 메소드를 적용하였다.

거래를 합치는 것이 핵심적인 비즈니스 로직이지만 인터페이스를 사용하거나 추상 메소드 오버라이딩, 객체 만들기와 그 객체로 뭔가 하는 것과 같이 추가적인 일을 해야 한다. 이런 “초과 수하물”은 항상 비판을 불러 일으키고 개발자들을 힘들게 한다. 비즈니스 로직 하나를 위해 틀에 박힌 코드와 의미 없는 구현을 하게 만드는 것이다.

클래스의 객체를 얻고 나면 해당 메소드를 호출하는 일반적인 절차를 아래에서 볼 수 있다:

IAddable addable = ....;

Trade t1 = new Trade(1, "GOOG", 12000, "NEW");
Trade t2 = new Trade(2, "GOOG", 24000, "NEW");

// using the conventional anonymous class..
Trade mergedTrade = tradeMerger.add(t1,t2);

비즈니스 로직은 기술적인 목적의 세부 사항들과 얽혀있고 핵심 로직은 클래스 구현과 밀접하게 연관되어 있다. 예를 들어 위에서 합쳐진 거래를 반환하는 대신 두 거래 중 큰 건을 반환해야 한다면 한숨을 한 번 쉬고 커피를 한 모금 마시고, 끙 소리도 낸 후 팔을 걷어 부치고 코드를 다시 쓸 준비를 해야 할 것이다.

또 로직을 바꾸고 나면 기존의 시험 코드가 돌지 않음은 물론이다.

게다가 이런 경우가 한 다스쯤 있다면 어쩔 것인가? 아마 기존 메소드에 조건문 등을 추가해서 고치거나 아예 새로 클래스를 만들어야 할 것이다. 비즈니스 로직과 클래스 구현이 밀접하게 연결되어 있는 것은 골치 아픈 일이다. 특히 변덕스러운 경영 분석가와 프로젝트 관리자가 있을 경우에는 말이다. 분명 뭔가 더 좋은 방법이 있을 것이다.

자바 8에서의 구현

익명 클래스를 이용해서 여러가지 일을 하는 것도 가능하지만 최선은 아니다. 다양한 작업을 하는 다람쥐를 써서 이 문제를 간단히 해결할 수 있다. 예를 들어 거래액을 합하거나 더 큰 거래를 반환하거나 거래 정보를 암호화하는 다람쥐 표현을 작성할 수 있다. 우리는 각각의 경우에 맞는 다람쥐 표현을 만들고 필요로 하는 클래스에 이 다람쥐 표현을 건네주기만 하면 된다.

예를 들어 우리의 경우를 위한 다람쥐 표현을 살펴보자.

// Summing up the trades quantity
IAddable<Trade> aggregatedQty = (t1, t2) -> {
  t1.setQuantity(t1.getQuantity() + t2.getQuantity());
  return t1;
};

// Return a large trade
IAddable<Trade> largeTrade = (t1, t2) -> {
 if (t1.getQuantity() > 1000000)
   return t1;
 else
   return t2;
};

// Encrypting the trades (Lambda uses an existing method)
IAddable<Trade> encryptTrade = (t1, t2) -> encrypt(t1,t2);

여기를 보면 각각의 함수에 대해 다람쥐를 선언하였고 메소드는 다음과 같이 다람쥐에 맞도록 만들어졌다.

//A generic method with an expected lambda
public void applyBehaviour(IAddable addable, Trade t1, Trade t2){
  addable.add(t1, t2);
}

메소드는 충분히 범용적이라 주어진 다람쥐 표현(IAddable 인터페이스)을 써서 임의의 두 거래에 적용할 수 있다.

이제 클라이언트는 행동을 담당하고 그것을 사용하기 위해 원격 서버에 전달한다. 이런 방법으로 클라이언트는 무엇을 할 지를 고민하고 서버는 어떻게 할 지를 담당한다. 인터페이스가 다람쥐 표현을 받아들이도록 만들어지는 한, 클라이언트는 다수의 이런 다람쥐를 생성하고 메소드를 호출할 수 있다.

마무리를 하기 전에 다람쥐를 지원하는 Runnable 인터페이스가 어떻게 사용되는지 알아보자.

Runnable 함수 인터페이스

가장 인기있는 Runnable 인터페이스는 인수도 없고 반환값도 없는 메소드 하나를 가진 형태이다. 이유는 속도 향상을 위해 로직을 별도의 쓰레드에서 실행하기 위함이라고 할 수 있다.

Runnable 인터페이스의 새로운 정의와 익명 클래스를 이용한 구현 예시는 다음과 같다:

// The functional interface
@FunctionalInterface
public interface Runnable {
  public void run();
}

// example implementation
new Thread(new Runnable() {
  @Override
  public void run() {
    sendAnEmail();
  }
}).start();

보면 알겠지만 이런 방식의 익명 클래스 생성과 사용은 매우 장황하고 보기에 안 좋다. 위의 메소드에서 sendAnEmail()를 제외하면 나머지는 반복적이고 틀에 박힌 코드이다.

같은 Runnable이 이번에는 다람쥐 표현을 위해 다시 작성될 수 있음을 아래에서 볼 수 있다:

// The constructor now takes in a lambda
new Thread( () -> sendAnEmail() ).start();

위에서 강조된 다람쥐 표현 () → sendAnEmail()은 쓰레드의 생성자로 넘겨진다. 이 표현식은 (새 쓰레드에서 항상 이메일을 보내는 등의) 어떤 행동을 전달하는 실제 코드 (Runnable의 인스턴스)임에 주의하자.

표현식을 보면 다람쥐의 타입을 추정할 수 있는데 이 경우 Runnable이다. 왜냐하면 쓰레드의 생성자가 Runnable을 받는다는 것이 잘 알려져 있기 때문이다. 새로 정의한 인터페이스 정의를 눈치챘다면 Runnable은 함수 인터페이스이므로 @FunctionalInterface로 태그되었다. 다람쥐 표현은 변수를 선언하고 할당하는 것과 마찬가지로 클래스 변수에 Runnable r = () → sendAnEmail() 로 할당될 수 있다.

이것이 다람쥐의 강점이다. 다람쥐는 데이터를 담는 인수를 전달할 때와 같이 행동을 메소드에 전달할 수 있게 한다.

유일한 목적이 서로 다른 쓰레드에서 요청 사항을 실행하는 서버측 클래스(AsyncManager)가 있다고 가정해보자. 이것은 다음과 같이 Runnable을 받는 단일 메소드 runAsync를 가진다.

public class AsyncManager{
  public void runAsync(Runnable r) {
    new Thread(r);
  }
}

클라이언트는 요구 사항에 맞춰 많은 다람쥐 표현을 만들어낼 수 있다. 예를 들어 다음과 같이 서버측 클래스에 전달될 수 있는 다양한 다람쥐 표현이 있다.

manager.runAsync(() -> System.out.println("Running in Async mode"));
manager.runAsync(() -> sendAnEmail());
manager.runAsync(() -> {
  persistToDatabase();
  goToMoon();
  returnFromMars();
  sendAnEmail();
});

요약

이번 글에서 자바 역사상 가장 큰 변화에 대해 설명하였다. 다람쥐는 자바의 나아갈 방향을 제시하고 다양한 개발자 커뮤니티를 자바로 끌어들일 것이다. 2부에서는 함수 인터페이스에 대해 다룬다.

단일 책임 원칙: 그 단순함과 복잡함
Feb 10th, 2014 by Wegra Lee

(원문) SRP: Simplicity and Complexity

Effective Unit Testing의7.1.2절에서 인용한 블로그 글이다.

단일 책임 원칙: 그 단순함과 복잡함

단순한 것이 차차 복잡해지는 것이 아니다. 오히려 그 반대다. – 알랜 퍼리스(Alan Perlis)

SOLID 원칙 중 하나인 “단일 책임 원칙(SRP, The Single Responsibility Principle)”은 내가 가장 좋아하는 객체지향 설계 원칙 중 하나다. 나는 이로부터 단순함과 복잡함을 동시에 발견할 수 있었다. 이 원칙을 알게 된 게 수 년 전이고, 직접 관련 글을 써본 지도 일 년이 넘었다. 하지만 이를 실무에 적용하기란 여전히 쉽지만은 않다. 수년간 여러 개발자에 이 원칙을 전파하면서 흥미로운 사실을 발견했다. 모두가 이 원칙의 의미는 이해하고 있지만, 막상 코딩할 때에는 까맣게 잊어버리거나 적용하는 법을 몰라 헤매는 것이다. 그래서 이 문제를 바라보는 나의 관점과 지금껏 겪어왔던 경험을 이야기해보려 한다.

외적 측면 (참고: 책에서는 ‘외면’이라 번역함)

모든 클래스와 메서드는 단 하나의 역할만 수행해야 한다.

이것은 내가 “외적 측면”이라 부르는 것으로, 이름이 중요한 상황이다.

외적 측면은 새로운 코드를 작성할 때 주로 고려된다. 무엇을 하는 코드인지 생각해본 후, 클래스나 메서드를 작성하고, 새 코드가 하는 일을 잘 표현하는 이름을 지어준다. 코드를 읽을 때도 외적 측면이 작용한다. 이름만 봐도 클래스나 메서드가 무슨 일을 하는지 바로 알 수 있어야 한다.

여기까지 이해하는 데 아무런 무리가 없으리라 믿는다.

그렇다면 이처럼 이해하기 쉬운데도, 사람들은 왜 이를 잘 지키지 않을까? 왜 적절한 클래스와 메서드를 찾으려 수천 줄의 코드 속에서 헤매고 있는 걸까? 그럴싸한 이유가 몇 개 떠오른다. 아마도 우리는 작명에 소질이 없나 보다. 혹은 너무 일반적이거나 광의적인 이름을 써서 너무 많은 일을 한꺼번에 처리하고 있을지도 모른다. 그것도 아니면 그냥 신경 쓰지 않는 것일 지도.

내적 측면 (참고: 책에서는 ‘내면’이라 번역함)

클래스와 메서드를 수정해야 하는 이유는 오직 하나뿐이어야 한다.

이는 내가 “내적 측면”이라 칭하는 것으로, 단일 책임 원칙의 또 하나의 (자주 잊히는) 측면이다.

내적 측면은 기존 코드를 변경하거나 새로운 코드를 집어넣으려 할 때 고려된다. 다시 말해, 각 클래스와 메서드가 무슨 일을 하는지 파악해야 하는 상황이다. 이때 분석해야 할 코드량이 예상보다 훨씬 많아 좌절할 때가 많은데, 주원인은 클래스나 메서드가 원래 해야 할 일보다 훨씬 많은 것을 처리하고 있기 때문이다.

하지만 외적 측면보다 내적 측면에 집중하면 단일 책임 원칙을 적용하기가 한결 쉬워진다. 즉, 역할에만 신경 쓰지 말고, 클래스나 메서드를 변경해야 할 이유가 몇 가지나 되는가를 항시 고민하자.

그렇다면, 언제 어디서 일이 틀어지는 것일까?

노트: 대게 개발자가 TDD와 리팩토링을 하지 않는 조직일수록 단일 책임 원칙에 어긋나는 사례가 많다.

생각해보자. 경험상 단일 책임 원칙에 어긋나는 사례 대부분은 시스템 인터페이스에 가까운 클래스와 메서드에서 발견되었다. 예를 들면, 웹 애플리케이션의 거대한 컨트롤러나 액션 클래스, 스윙 애플리케이션의 거대 이벤트 핸들러, 이벤트 기반 시스템에서 메시지 처리를 담당하는 거대한 메서드 등이 있다.

이는 시스템 인터페이스에 가까운 클래스와 메서드는 더 광범위하고 일반적인 역할을 담당하기 때문이다. 이런 메서드는 수많은 비즈니스 규칙이나 복잡한 워크플로우를 관장하는 경우가 제법 많다.

거래 정보를 담은 거대한 XML 파일을 입력받는 시스템을 상상해보자. 그리고 이를 처리하는 첫 메서드는 TradeService 클래스의 “processTrade(tradeXML)”라고 해보자. 이 메서드의 역할이 무엇인가? 바로 거래를 처리하는 것이다. 그렇다면 이름은 적절한가? 이 시스템은 입력받은 거래(trade)를 처리(process)하길 원하니 첫 메서드의 이름으로 processTrade는 적절해 보인다.

다른 예를 보자. 인터넷 쇼핑 사이트에서 고객이 상품 몇 개를 장바구니에 담고, 지불 정보를 입력하고, “주문” 버튼을 클릭했다. 그렇다면 뒷단에서는 주문 발주를 위해 대략 placeOrder(order) 정도의 메서드를 호출할 것이다. 나쁘지 않다.

생각 발전시키기

일반적으로, 시스템 인터페이스에 가까운 코드일수록 더 폭넓고 일반적인 역할을 담당하는 경향이 있다. 반면, 시스템 인터페이스에서 멀어질수록 더 좁고 특수한 역할을 담당하게 된다.

앞의 두 예에서, processTrade와 placeOrder 메서드는 단 하나의 역할만 수행한다고 주장할 수 있다. 전자는 입력받은 거래를 처리하고 후자는 고객의 주문을 발주한다. 그래서 단일 책임 원칙의 외적 측만을 고려하는 개발자라면 거리낌 없이 관련된 코드 모두를 그 메서드 안에 욱여넣을 것이다.

문제는 거래 처리와 주문 발주가 심히 복잡한 작업이라는 데 있다. 복잡한 과정을 거쳐야 하고, 수많은 비즈니스 규칙과 요구사항을 만족하게 하기 위한 수백 수천 줄의 코드를 작성해야 할 것이다. 그러니 이 많은 코드를 한 메서드에 욱여넣는 것은 단일 책임 원칙을 명백히 위반할 뿐 아니라, 어리석기까지 한 일이다.

단일 책임 원칙을 만족하는 코드를 만들려면, 변경 사유가 오직 하나뿐이어야 한다. 이는 다음과 같이 발전된 생각을 이끌어내 준다.

일반적으로, 시스템 인터페이스에 가까운 클래스일수록 더 많은 것을 위임(delegation)한다. 반면, 시스템 인터페이스에서 멀리 떨어진 클래스일수록 위임할 것이 적어진다.

전통적인 자바 웹 애플리케이션의 컨트롤러가 좋은 예다. 사용자 인터페이스와 가까운 컨트롤러는 폭넓은 역할을 담당하며 비즈니스 로직은 모두 다른 객체에 위임한다. 컨트롤러는 단순히 흐름만 제어할 뿐이다. 정 반대로, 매우 특수하고 제한된 역할만 수행하는 DAO(Data Access Object)는 일거리를 다른 클래스에 위임하는 경우가 거의 없다. 그 중간에 위치하는 서비스는 자신의 비즈니스 로직을 처리하지만, 종종 다른 협력 객체에 작업을 위임하기도 한다. 서비스는 컨트롤러보다는 좁고 DAO보다는 광범위한 역할을 처리하는 게 보통이다. 어쨌든, 각 클래스와 메서드는 단일 역할만을 담당한다.

다르게 질문하기

다른 개발자에게 맨토링해주거나 함께 짝(pair) 프로그래밍을 하며 한 메서드 안의 코드량이나 클래스 안의 메서드 수를 가지고 논쟁을 벌일 때가 많다. 단일 책임 원칙의 외적 측면만을 근거로 내세운다면 코드가 하는 일이 너무 많다는 걸 잘 인정하지 못하는 개발자가 많을 것이다. 그래서 내적 측면이 중요하다는 걸 깨달았다. 이제는 메서드나 클래스가 맡은 역할이 몇 개인가를 묻는 대신, 수정해야 하는 이유가 몇 가지나 되느냐고 묻기 시작했다.

Effective Unit Testing 번역서 출간
Feb 6th, 2014 by Wegra Lee

Effective Unit Testing : 클린 코드와 좋은 설계를 이끄는 단위 테스트

두 번째 번역서..

사실, 출간된 지는 몇 달 지났다.

첫 번역서인 JUnit in Action은 다양한 개발 환경에서 JUnit 기반 프레임워크를 활용하는 방법을 보여주는 활용서 성격이 강했다.

반면, 이번 책은 품질 향상을 넘어 설계 개선이라는 테스트를 통해 얻을 수 있는 한 차원 높은 가치를 잘 설명하고 있다.

그래서 전문 테스터보다는 개발자를 꿈꾸는 모든 이들이 한 번쯤 꼭 봐둘 만한 책이다.

평소 저자와 같은 사상을 가지고 있었고 고민도 많이 했던 분야인 만큼,

책의 단순 오류뿐 아니라 관련 논쟁까지도 기꺼이 수용할 용의가 있다. (연락은 ‘wegra.eut at G메일’로..)

Java 코딩 규약 관리 방법
May 30th, 2011 by Wegra Lee

오랫만에 글을 적는 계기는, 얼마전 팀에 배포된 100페이지짜리 자바 코딩 가이드라인 때문이다.

나는 이미 약 9년 전에 나만의 코딩 가이드라인 문서를 만들어 다수 프로젝트에 적용했었다. 당시엔 나름 자부심을 주는 산출물 중 하나였지만, 얼마 지나지 않아 이것은 구시대적 산물이 되었음을 깨닫게 되었다.

코딩 규약 자체는 분명 필요하다. 이것이 없는 조직은 아직 굉장히 미숙한 개발 문화를 갖고 있을 확률이 높다. 문제는 이를 정적인 문서(워드나 파워포인트 형태)로 작성/관리한다는데 있다. 문서 방식의 대표적인 한계는 이러하다.

  • 내용이 풍부해질 수록 배우고 실무에 적용하기 어려워진다.
  • 언어 명세에 추가되는 새로운 문법에 빠르게 대응하지 못한다.
  • 항목 A의 예제 코드가 항목 B를 따르지 못하는 경우가 흔히 발생한다.
  • 몇몇 예제만으로 실 제품의 수십만/수백만 라인의 다양한 코드와 매칭시키게 하기에는 한계가 있다.

과거 시절에는 저런 한계를 안고서라도 문서가 필요했지만, 더이상은 아니다. 개발 도구들이 이미 충분히, 아니 비교할 수 없을 만큼 성숙되어 있기 때문이다.

Eclipse의 Code Formatter

가장 대표적인 자바 IDE 중 하나인 Eclipse를 보자. Eclipse의 Preferences > Java > Code Style 메뉴를 보면 다음의 메뉴들을 볼 수 있다.

  • Clean Up: 불필요한 코드나, 명백히 잘못된 코드 설정
  • Code Templates: 정형화된 코드 파일/클래스/메서드 등의 템플릿 설정
  • Formatter: 코드 포맷 설정
  • Organize Imports: import 문 구성 규칙 설정

위의 기능들은 개발 중 언제나 간단한 메뉴 조작이나 단축키로 바로바로 적용할 수 있다. 즉, 새로 합류한 팀원이 아무리 대충 짜놓은 코드라도, 즉시 베테랑 선임 개발자가 짠 코드처럼 바꿀 수 있다는 것이다. (기본 로직이나 단어 선택 등은 논외)

C/C++ 언어의 유사 툴을 사용해본 사람이라면 시큰둥할 수도 있다. 하지만 직접 저 메뉴들을 찾아들어가 잠시만 살펴본다면 그 막강한 표현력에 혀를 내두르고, 실제 프로젝트에 적용해보면 그 정확성에 감탄을 금치 못할 것이다.

더욱이 편집한 설정을 import/export 할 수 있으니, 기본 설정이 맘에 들지 않는다면 수정하여 팀 전체가 쉽게 공유할 수 있다. 소스 컨트롤 툴에 저장/관리한다면 금상첨화일 것이다.

하지만 코딩 규약은 단순 문법만 다루는 것은 아니다. 잠재적 결함을 예방하기 위한 올바른 코딩 패턴과 개발자들아 자수 실수하는 잘못된 패턴에 대한 예방 차원의 항목도 다수 포함된다. 위의 설정만으론 분명 부족함이 있다. 이에 대한 해결책으로는 두 가지 툴을 추천한다.

FindBugs

FindBugs라는 이름에서부터 너무도 명백하게 자신의 용도를 광고중인 이 툴은, 자바 코드에서 문제의 소지가 있는 다양한 버그 패턴을 찾고 그 이유를 설명해준다. 자신이 짠 코드에서 직접 짚어준다는 점에서 초간단 예제 몇 개만 달랑 던져주는 문서와는 천지차이다.

IDE와 통합은 기본이고 무료다. 또한 이 툴이 헛짚은 경우는 아직까지 겪어보지 못했을 정도의 정확성을 뽑낸다. 물론 ‘우리의 사용 환경에서는 절대 이런 일이 발생할 수 없어’라며 무시할 수는 있지만, 사용 환경이 언제까지건 변함 없고, 그 코드가 다른 프로젝트에 가져다 쓰일 확률이 zero 라고 확신하지 않는다면, 툴이 제안하는 예방 조치를 따라두는 것이 나쁠 것 없다.

CodePro Analytix

과거에는 PMDCheckStyle을 추천하며 CodePro Analytix는 소개 정도만 시켜주었는데, 이제는 상황이 바뀌었다. 구글이 이 툴을 사더니 무료로 뿌려버린 것이다. 더이상 상용 툴을 아쉬워하면 꿩 대신 닥으로 PMD나 CheckStyle을 사용할 필요가 없어졌다. 물론 이 둘을 무시하는 것은 아니지만, 개인적으로는 CodePro Analytix를 훨씬 높게 평가한다.

유사 코드 찾기종속성 분석 등 다른 기능도 많지만, 이번 주제와 밀접한 관련이 있는 기능은 바로 코드 검사 기능이다. CodePro Analytix는 Effective Java, Security, Internal API 등등 업계에서 많이 통용되고 있는 다수의 가이드라인에 맞는 수백가지의 검사 규칙을 제공한다. 각 규칙들은 세밀한 설정도 가능하고, 원하는 항목만 조합하여 팀만의 룰셋을 정의할 수도 있다. 이렇게 정한 규칙은 당연히 import/export 하여 공유할 수 있다.

Eclipse에 설치하려면 다음 주소를 참고하자.

http://code.google.com/intl/ko-KR/javadevtools/download-codepro.html

CheckStyle

CodePro Analytix로 천하통일할 수 있을 줄 알았으나, 확인 결과 CodePro는 Ant 태스크나 Maven 플러그인을 제공하지 않아, 지속적 통합 시스템에 넣기에 적합하지 않다. 하여 PMD와 CheckStyle 중 하나를 여전히 추천하지 않을 수 없는 상황이다. 둘 중 하나를 고르자면, 나는 CheckStyle을 추천한다. 이유는 간단하다. PMD가 2009년 이후 업데이트가 이뤄지지 않고 있는데 반해, CheckStyle은 지속적으로 업데이트 중이기 때문이다.

툴의 기능은 CodePro Analytix와 유사하나 지속적 통합 시스템에 바로 적용할 수 있도록 Ant 태스크와 Maven 플로그인을 제공한다. 물론 Eclipse와 같은 IDE용 플러그인 품질도 뛰어나 개발자 편의성도 좋다.

Summary

지금까지 살펴본 바와 같이, 자바 코딩 규약에 대해서는 이미 훌륭한 툴들이 갖추어져 있다. 문서로 힘들게 정리하고 교육하는 것보다는 이들을 활용하는 것이 백배는 효율적이다. 그 이유는 이들 툴 모두는 다음과 같은 장점을 제공한다.

  • IDE와 밀접히 통합되어 있어, 개발자들이 자신의 코드를 대상으로 언제든 쉽게 적용할 수 있다.
  • 무료이다.
  • 설정 편집 및 import/export 기능으로 팀원간 공유가 쉽다.
  • 강력하고 정확하다 (C/C++ 툴들과 비교를 거부한다).
  • Ant 태스크(FindBugs, CodePro) 혹은 명령행 수행 기능(Eclipse Code Formatter)을 제공하여 원한다면 지속적 빌드(continuous integration/build) 환경에 통합할 수 있다.

이 글을 읽는 사람이 자바 개발팀에 속해 있고 팀 내에 코딩 규약이 없거나 문서로만 관리되고 있다면, 지금이라도 늦지 않았으니 새로운 세상을 경험해보길 바란다.

»  Substance: WordPress   »  Style: Ahren Ahimsa