수학과의 개발자 도전기

요약

리플렉션은 복잡한 특수 시스템을 개발할 때 필요한 강력한 기능이지만, 단점이 많기에 신중하게 사용해야 한다.

컴파일타임에는 알 수 없는 클래스를 사용하는 프로그램을 작성할 때는 리플렉션 사용을 권장한다.

하지만 되도록이면 객체 생성에만 사용하는 것이 좋고, 인스턴스 생성 후에는 적절한 인터페이스나 컴파일타임에 알 수 있는 상위 클래스로 형변환 후 사용을 권장한다.

→ 런타임에 리플렉션을 사용해야하는 경우가 있고, 리플렉션으로 생성한 객체는 인터페이스로 받아서(컴파일타입 체크가능) 사용하자!(리플렉션 장점 + 인터페이스 장점)

→ 객체 생성은 리플렉션으로, 객체 사용은 인터페이스로

리플렉션

리플렉션 기능(java.lang.reflect)을 이용하면 다음 기능을 사용할 수 있다.

1. 임의의 클래스에 접근이 가능하다
2. 클래스의 생성자/메서드/필드의 인스턴스를 가져올 수 있다
3. 인스턴스를 이용해 각각에 연결된 실제 생성자/메서드/필드 조작이 가능하다
   1. 클래스 인스턴스 생성 or 메서드 호출 or 필드 접근이 가능하다는 것을 의미한다
4. 주의해야할 점은 리플렉션은 아주 제한된 형태로만 사용해야 그 단점을 피하고 이점만 취할 수 있다
   1. 리플렉션은 인스턴스 생성에만 사용하고,
   2. 생성한 인스턴스는 인터페이스나 상위클래스로 참조해 사용하는 것을 권장한다

리플렉션

장점

1. 복잡한 애플리케이션에서 사용 가능
   1. 코드 분석 도구
   2. 의존관계 주입 프레임워크
2. 런타임에 존재하지 않을 수도 있는 다른 클래스, 메서드, 필드와의 의존성을 관리할 때 적합하다
   1. 예시로, 버전이 여러 개인 외부 패키지를 다룰 때 유용
   2. 주로 가장 오래된 버전만을 지원하도록 컴파일한 후, 이후 버전의 클래스와 메서드 등은 리플렉션으로 접근하는 방식
   3. 이러기 위해선 접근하려는 새로운 클래스나 메서드가 런타임에 존재하지 않을 수 있다는 사실을 반드시 감안해야 한다

단점

리플렉션의 단점은 다음과 같다.

1. 컴파일 타입 검사가 주는 이점을 하나도 누릴 수 없다
2. 코드가 지저분하고 장황해진다
3. 성능이 떨어진다
   1. 리플렉션을 통한 메서드 호출은 일반 메서드 호출보다 훨씬 느리다.

예시

아래 코드는 다음과 같은 형식으로 진행된다.

• 리플렉션으로 Set<String> 인터페이스의 인스턴스를 생성한다
• 정확한 클래스는 명령줄의 첫 번째 인수로 확정한다
• 그 다음에는 생성한 집합에 두 번째 이후의 인수들을 추가후 화면에 출력한다
  • 출력은 인수 중복 제거 후 진행된다
  • 첫번째 인수로 지정한 클래스가 무엇이냐에 따라 인수 출력 순서가 달라진다
  • HashSet인 경우 무작위로 출력되고, TreeSet인 경우 알파벳 순서로 출력된다

// 리플렉션으로 인스턴스를 생성하고 인터페이스로 참조해 활용한다.
public static void main(String[] args) {
    
    // 클래스 이름을 Class 객체로 변환
    Class<? extends Set<String>> cl = null;
    try {
        cl = (Class<? extends Set<String>>) Class.forName(args[0]);
    } catch (ClassNotFoundException e) {
        fatalError("클래스를 찾을 수 없습니다.");
    }
    
    // 생성자를 얻는다.
    Constructor<? extends Set<String>> cons = null;
    try {
        cons = cl.getDeclaredConstructor();
    } catch (NoSuchMethodException e) {
        fatalError("매개변수 없는 생성자를 칮을 수 없습니다.");
    }
    
    // 집합의 인스턴스를 만든다.
    Set<String> s = null;
    try {
        s = cons.newInstance();
    } catch (IllegalAccessException e) {
        fatalError("생성자에 접근할 수 없습니다.");
    } catch (InstantiationException e) {
        fatalError("클래스를 인스턴스화할 수 없습니다.");
    } catch (InvocationTargetException e) {
        fatalError("생성자가 예외를 던졌습니다 : " + e.getCause());
    } catch (ClassCastException e) {
        fatalError("Set을 구현하지 않은 클래스입니다.");
    }
    
    // 생성한 집합을 사용한다
    s.addAll(Arrays.asList(args).subList(1, args.length));
    System.out.println(s);
}

    private static void fatalError(String msg) {
        System.err.println(msg);
        System.exit(1);
    }

위의 예시에서 리플렉션의 단점이 2가지 있다.

1. 총 6개의 런타임 예외 발생가능
2. 쓸데없이 너무 긴 코드
   1. 클래스 이름으로 인스턴스를 생성하기 위해 총 25줄의 코드를 작성해야한다
   2. 리플렉션을 사용하지 않는다면 생성자 호출 1줄 코드로 완료할 수 있다

요약

지역변수의 범위 최소화하는 법

1. 지역변수는 가장 처음 쓰일 때 선언해라
2. 거의 모든 지역변수는 선언과 동시에 초기화해라
3. 메서드를 기능별로 쪼개 작게 유지하고 한 가지 기능에 집중하게 설계해라

지역변수의 유효 범위를 최소로 줄였을 때의 이점

• 코드 가독성과 유지보수성이 높아진다
• 오류 가능성이 낮아진다

1. 지역변수는 가장 처음 쓰일 때 선언해라

지역변수를 미리 선언해두면 다음과 같은 문제가 발생할 수 있다.

• 코드가 어수선해져 가독성 저하
• 변수를 실제 사용하는 시점에 타입/초깃값 중복 확인
• 변수를 다 사용한 뒤에도 변수가 살아있어 다른 곳에서 사용될 수 있고, 그로인한 부작용 발생 가능성이 있다

2. 거의 모든 지역변수는 선언과 동시에 초기화해야 한다

만약 초기화에 필요한 정보가 충분하지 않다면 충분해질 때까지 선언을 미뤄야 한다.

반복문

for 문이나 for-each 문 같은 반복문의 경우에는 반복 변수의 범위가 반복문 괄호와 몸체에 제한되기 때문에 변수의 범위를 최소화할 수 있다. 반복 변수의 값을 반복문이 종료된 뒤에도 써야하는 상황이 아니라면 while문 보다 for 문을 사용하는 것이 더 낫다.

• 예시1 : 컬렉션이나 배열을 순회하는 권장 관용구

public static void main1(String[] args) {
    ArrayList<String> elements = new ArrayList<>();
        for (String element : elements) {
             // element 를 사용한 로직
        }
}

• 예시2 : while + 복붙 사용시 발생할 수 있는 문제

// 예시 2-2 : while 문 사용시 주의해야할 점 - 복사 붙여넣기

ArrayList<Element> elements = new ArrayList<>();
Iterator<Element> i = elements.iterator();
while (i.hasNext()) {
    // i.next() 를 사용한 로직
}

// 만약 i 를 i2로 변경하지 않더라도 컴파일 오류가 발생하지 않지만,
// 추후 다른 문제 발생 가능성이 있다
ArrayList<Element> elements2 = new ArrayList<>();
Iterator<Element> i2 = elements2.iterator();
while (i.hasNext()) {
    // i2.next() 를 사용한 로직
}

• 예시3 : for 문

ArrayList<Element> elements = new ArrayList<>();
for (Iterator<Element> i = elements.iterator(); i.hasNext();) {
    Element e = i.next();
    // e 와 i 를 사용한 로직
}

ArrayList<Element> elements2 = new ArrayList<>();
// 변수 이름 잘못 입력해도 컴파일 오류로 잡을 수 있다
for (Iterator<Element> i2 = elements2.iterator(); i.hasNext();) { // 컴파일 오류 발생
    Element e = i2.next();
    // e 와 i 를 사용한 로직
}

for문 사용의 이점

1. 반복자 사용 가능
2. 복사 붙여넣기 시 오류 예방 가능
   1. 복붙 오류를 컴파일 타임에 잡아준다
   2. 변수 유효 범위가 for 문 범위와 일치해 똑같은 이름의 변수를 여러 반복문에서 써도 서로 영향을 주지 않는다
3. while문보다 짧아서 가독성이 좋다

3. 메서드를 작게 유지하고 한 가지 기능에 집중해라

한 메서드에서 여러 가지 기능을 처리한다면 그 중 기능과만 관련된 지역변수라도 다른 기능을 수행하는 코드에서 접근할 수 있을 것이다. 따라서 메서드를 기능별로 쪼개면 위 상황을 예방할 수 있다.

요약

인수 개수가 일정하지 않은 메서드를 정의해야 한다면 가변인수를 사용하라

가변인수 사용은 성능 문제에 영향을 미치므로 신중히 사용하자

가변인수 메서드란?

고정된 매개변수의 수를 받는 것이 아닌 명시한 타입의 인수를 0개 이상으로 가변적으로 인수를 받을 수 있는 메서드이다. 인수 개수가 정해지지 않은 경우에 가변인수는 유용하게 사용할 수 있다.

가변인수 메서드 동작 순서

1. 인수의 개수와 길이가 같은 배열을 생성한다.
2. 인수들을 배열에 저장한다.
3. 배열을 가변인수 메서드에 전달한다.

예시

static int sum(int... args) {
	int sum = 0;
	for (int arg : args) {
	  sum += arg;
	}
	return sum;
}

// sum(1,2,3)은 6을 반환하고, sum()은 0을 반환한다

예외

인수가 무조건 1개 이상이어야 할 때도 있는데, 최솟값을 찾는 메서드가 해당된다. 참고로 인수개수는 런타임에 자동 생성된 배열의 길이로 알 수 있다.

1) 문제되는 코드

static int min(int... args) {
    if (args.length == 0) {
        throw new IllegalArgumentException("인수가 1개 이상 필요합니다.");
    }

    int min = args[0];
    for (int i = 1; i < args.length; i++) {
        if (args[i] < min) {
            min = args[i];
        }
    }
    return min;
}

• 위 코드로 인수가 0개인 상황을 확인할 수 있지만, 2가지 문제점이 있다.
  • 인수가 0개일 때 유효성 검사가 컴파일 타임이 아닌 런타임 실패인 것
  • 코드가 지저분한 것
    • 매개변수 유효성 검사가 명시적이고, for-each문을 사용하기가 어렵다.

2) 더 나은 코드

static int min(int firstArg, int... remainingArgs) {
    int min = firstArg;
    for (int remainingArg : remainingArgs) {
        if (remainingArg < min) {
            min = remainingArg;
        }
    }
    return min;
}

• 첫 번째로는 일반 매개변수(가변인수에서 첫번째 인수)를 받고, 두번째로 가변인수를 받으면 이전의 문제가 사라진 깔끔한 코드를 작성할 수 있다.

성능

가변인수 메서드는 호출될 때마다 배열을 새로 하나 할당하고 초기화하기 때문에 성능에 민감한 상황에서는 걸림돌이 될 수 있다. 만약 가변인수의 유연성이 필요하지만 비용을 감당하기가 어려울 때 사용할 수 있는 방법이 있다.

예시 - 다중정의

해당 메서드 호출의 95%가 인수를 3개 이하로 사용한다고 가정하면, 다음과 같이 메서드 다중정의를 할 수 있다.이 방법은 혹시나 4개 이상의 인수를 받아야할 상황에 도움이 될 수 있다.

예시로 EnumSet이 있는데, EnumSet은 비트필드를 대체하면서 성능까지 유지해야 하므로 이 기법으로 정적 팩터리를 생성하면 열거 타입 집합 생성 비용을 최소화한다.

주의) 가변인수는 메서드 파라미터 마지막에 위치해야한다.

public void foo() { }
public void foo(int a1) { }
public void foo(int a1, int a2) { }
public void foo(int a1, int a2, int a3) { }
public void foo(int a1, int a2, int a3, int... rest) { } // 5%만 적용

요약

메서드 매개변수 수가 같을 때는 다중정의(overloading)는 되도록 하지 말자
(사용자 입장에서 어느 메서드를 사용하는지 혼란을 줄 수 있기 때문이다).

만약 다중정의를 해야한다면
1)형변환을 하거나
2) 인수 포워드 등을
통해 같은 객체를 받는 다중 정의 메서드들이 모두 동일하게 동작하도록 만들어야 한다.

1. 다중정의의 오류

1-1. 다중정의 메서드는 정적 선택

public class CollectionClassifier {

    public static String classify(Set<?> c) {
        return "집합";
    }

    public static String classify(List<?> c) {
        return "리스트";
    }

    public static String classify(Collection<?> c) {
        return "그 외";
    }

    public static void main(String[] args) {
        Collection<?>[] collections = {
                new HashSet<String>(),
                new ArrayList<BigInteger>(),
                new HashMap<String, String>().values()
        };

        for (Collection<?> c : collections) {
            System.out.println(classify(c));
        }
    }
}

위 코드 main()을 실행하면 ’집합’, ‘리스트’, ‘그 외’가 출력될 것이라 예상하지만 실제로는 ’그 외’, ‘그 외’, ‘그 외’가 출력된다. 그 이유는 다중정의 메서드 중 어떤 메서드를 호출할지가 컴파일 타임에, 매개변수의 컴파일타임 타입에 의해서만 정해지기 때문이다. 컴파일타임에는 for 문 안의 c는 항상 Collection<?> 타입이다. 그렇기에 세번째 classify()가 호출되어 모두 ‘그 외’가 출력이 되는 것이다.

1-2. 해결책

위 코드를 의도한대로 출력하게 하기 위해서는 모든 classify 메서드를 하나로 합친 후, instanceof로 명시적으로 검사하면 해결된다.

public static String classify(Collection<?> c) {
    return c instanceof Set ? "집합":
           c instanceof List ? "리스트" : "그 외";
}

1-3. 재정의 메서드는 동적 선택

class Wine {
    String name() { return "포도주"; }
}

class SparklingWine extends Wine {
    @Override String name() { return "발포성 포도주"; }
}

class Champagne extends SparklingWine {
    @Override String name() { return "샴페인"; }
}

public class Overriding {
    public static void main(String[] args) {
        List<Wine> windList = List.of(
                new Wine(), new SparklingWine(), new Champagne());

        for (Wine wine : windList) {
            System.out.println(wine.name());
        }
    }
}

반면 재정의(override) 메서드는 런타임에서 동적으로 선택되기 때문에 위 예시에서는 “포도주”, “발포성 포도주”, “샴페인”으로 예상한 값과 동일하게 출력된다.

2. 다중정의 사용법

위의 내용으로 다중정의 메서드 작성 시 헷갈릴 수 있는 코드는 작성하지 않는 게 좋다.

특히 오픈 API라면 더욱 신경 써야 한다. API 사용자가 매개변수를 넘기면서 어떤 다중정의 메서드가 호출될지를 모른다면 프로그램이 오작동하기 쉬워 런타임에 이상하게 행동해 API 사용자로 하여금 혼란을 줄 수 있다.

2-1. 가이드라인

안전하고 보수적으로 가려면 다음과 같은 가이드라인을 따르는 것을 권장한다.

• 매개변수 수가 같은 다중정의는 만들지 말자
• 가변인수(varargs)를 사용하는 메서드라면 다중정의를 아예 하지 말아야 한다
• 되도록이면 다중정의 대신 메서드 이름을 다르게 짓는 것도 방법이 될 수 있다
  • 예시로는 ObjectOutputStream이 있다. write 메서드의 매개변수에 따라 writeBoolean(boolean), writeInt(int), readBoolean(), readInt() 형식으로 메서드를 구분한다.

2-2. 생성자

생성자 같은 경우는 이름을 다르게 지을 수 없으니 두 번째 생성자부터는 무조건 다중정의가 된다.

이 문제는 1)정적팩터리를 사용하거나 2) 매개변수간 형변환을 할 수 없는 다중정의 메서드(예시로 ArrayList에는 ArrayList(int) 생성자와 ArrayList(<Collection>) 생성자가 있다. int와 Collection은 완전히 다르므로 메서드 호출에 혼동이 생길 일은 없다)를 만들어서 해결할 수 있다.

2-3. 인수 포워드

인수 포워드는 상대적으로 더 특수한 다중정의 메서드에서 더 일반적인 다중정의 메서드로 일을 넘겨버리는 것(forward)을 의미한다.

public boolean contentEquals(StringBuffer sb) {
	return contentEquals((CharSequence) sb);
}

3. 자바5 버전 이후 다중 정의 문제

3-1. 제네릭, 오토박싱 으로 인한 문제

public class SetList {

    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        List<Integer> list = new ArrayList<>();

				// -3 ~ 2 까지 정수 삽입
        for (int i = -3; i < 3; i++) {
            set.add(i); 
            list.add(i);
        }

        for (int i = 0; i < 3; i++) {
            set.remove(i);
            list.remove(i);
        }

        System.out.println(set + " " + list);
    }
}

// 예상 출력 결과
[-3, -2, -1] [-3,-2,-1]

// 실제 출력 결과
[-3, -2, -1] [-2, 0, 2]

예상과 다른 출력이 발생한 이유는 list.remove()의 다중정의 때문이다. set.remove(i)의 시그니처는 remove(Object)인 반면, list.remove(i)의 시그니처는 다중정의된 remove(int index)(List<E> 인터페이스는 remove(Object)와 remove(int)를 다중정의 함)를 선택한다. 따라서 list의 경우 각 단계마다 0번째, 1번째, 2번째의 원소를 제거한다. 따라서 [-3, -2, -1] 이 아닌 [-2, 0, 2]가 출력된다.

• 해결

  for (int i = 0; i < 3; i++) {
  	set.remove(i);
  	list.remove((Integer) i); // 혹은 list.remove(Integer.valueOf(i))
  }
  

• 위 문제 해결은 list.remove()에서 int를 Integer로 형변환하면 된다.

3-2. 람다, 메서드 참조로 인한 문제

// 1번. Thread 생성자 호출
new Thread(System.out::println).start();

// 2번. ExecutorService의 submit 메서드 호출
ExecutorService exec = Executors.newCachedThreadPool();
exec.submit(System.out::println);

// 결과 : 1번은 정상작동 하지만, 2번은 정상 작동하지 않는다.

각 함수에 넘겨진 인수는 System.out::println으로 동일하고, 양쪽 모두 Runnable을 받는 형제 메서드를 다중정의하고 있다. 그런데 왜 2번만 실패하는 것일까? 이유는 submit도 다중정의(submit 다중 메서드 중에는 Callable<T>를 받는 메서드가 있기 때문)되어 있고, println도 다중정의(적절한 다중정의 메서드를 찾는 알고리즘) 되어 있기에 다중정의 해소 알고리즘이 우리의 기대(println은 void를 반환하니, 반환값이 있는 Callable과 헷갈리지 않을 것이기에 정상동작할 것이다.)처럼 동작하지 않기 때문이다.

→ 다중정의된 메서드(혹은 생성자)들이 함수형 인터페이스를 인수로 받을 때, 비록 서로 다른 함수형 인터페이스라도 인수 위치가 같으면 혼란이 생긴다는 것이다.

→ 따라서, 서로 다른 함수형 인터페이스라도 같은 위치의 인수로 받아서는 안 된다.(서로 다른 함수형 인터페이스라도 서로 근본적으로 다르지 않다는 뜻)

4. 예외

다중정의된 메서드라도 같은 동작을 하면 상관없지만, 예외가 있는데 String 클래스의 valueOf(char[])과 valueOf(Object)는 같은 객체를 건네더라도 전혀 다른 일을 수행한다.