1. Concurrent Programming

Concurrent 소프트웨어는 동시에 여러 작업을 할 수 있는 소프트웨어를 의미한다. 예를 들면, 크롬으로 음악을 틀어두고 문서 작업을 할 수 있는 것처럼..~

자바에서 지원하는 Concurrent 프로그래밍에는 멀티 프로세싱과 멀티스레드가 있는데, CompletableFuture는 멀티스레드와 관련있으므로 이번에는 멀티스레드에 대해서만 정리하였다. (cf 스프링 프레임워크는 자바의 멀티쓰레드를 사용한다.)

1-1. Thread

Thread를 상속하면 새로운 Thread 클래스를 새롭게 정의할 수 있다.

public class Main {
    public static void main(String[] args) {
        YourThread yourThread = new YourThread();
        yourThread.start();

        MyThread myThread = new MyThread();
        myThread.start();

        System.out.println("메인 쓰레드 : " + Thread.currentThread().getName());
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("마이 쓰레드 : " + Thread.currentThread().getName());
        }
    }

    static class YourThread extends Thread {
        @Override
        public void run() {
            System.out.println("유어 쓰레드 : " + Thread.currentThread().getName());
        }
    }
}

메인 쓰레드 : main
마이 쓰레드 : Thread-1
유어 쓰레드 : Thread-0

Process finished with exit code 0

여러 개의 Thread를 정의할 수 있다. 또한, Thread는 순서가 보장되지 않는다. 코드에서는 YourThread -> MyThread -> main Thread 순으로 호출했지만, 결과는 예상한대로 나오지 않았다. 실행을 할 때마다 매번 호출 순서가 바뀌어 출력된다.

1-2. Runnable

Thread 클래스를 따로 정의하지 않아도, Runnable 이라는 익명 객체를 통해 새로운 Thread 객체를 사용할 수 있다.

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("뉴 쓰레드 : " + Thread.currentThread().getName());
            }
        });
        thread.start();

        System.out.println("메인 쓰레드 : " + Thread.currentThread().getName());
    }
}

Thread를 상속하는 방법보다 간단하긴 하다. 자바8부터는 람다식을 사용하여 위의 코드를 간추릴 수 있다.

        Thread thread = new Thread(() -> {
            System.out.println("뉴 쓰레드 : " + Thread.currentThread().getName())
        });
        thread.start();

2. Executor

Thread, Runnable과 같은 low level API를 프로그래머가 직접 다루는 것은 현실적으로 어렵다. (수십,수백 개 쓰레드의 자원을 관리하려면..머리가 꽤 아플 것이다.) 그래서 쓰레드를 만들고 관리하는 작업을 애플리케이션에서 분리하여 high level API인 'Executor'에 위임하였다.

주요 인터페이스로는, 1) Executor, 2) ExecutorService, 3) ScheduledExecutorService 가 있다.

2-1. Executor

Executor executor = Executors.newSingleThreadExecutor(); // single thread
executor.execute(() -> System.out.println("Thread: " + Thread.currentThread().getName()));

Executor는 쓰레드를 생성하고 처리하는 인터페이스이다. execute()라는 메서드만을 가지고 있는데, 쓰레드를 처리할 수는 있지만 종료할 수는 없다. ide에서 실행시켜보면 강제종료하기 전까지 계속 실행되는 것을 확인할 수 있다.

2-2. ExecutorService

ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.execute(() -> System.out.println("Thread : " + Thread.currentThread().getName()));
executorService.shutdown();


ExecutorService executorService2 = Executors.newSingleThreadExecutor();
executorService2.submit(() -> {
    try {
        Thread.sleep(30000);
        System.out.println("Thread2 : " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
              System.out.println("Call shutdownNow!");
              e.printStackTrace();
        }
    });
executorService2.shutdownNow();

ExecutorService는 Executor를 상속 받은 인터페이스이다. 쓰레드를 생성하고 처리하고 종료하는 등의 작업을 할 수 있다. submit()을 사용하면 작업을 ExecutorService가 만든 쓰레드풀에서 처리하고, shutdown()으로 쓰레드 풀을 종료할 수 있다. shutdown()을 사용하면 작업이 다 종료될 때까지 기다리고 종료하지만, 작업이 끝나든 말든 지금 당장 종료하고 싶다면 shutdownNow()를 사용하면 된다.

ExecutorService는 Executor를 상속 받았기 때문에 execute()와 submit() 모두 호출이 가능하다. 다만, 두 메서드는 받을 수 있는 인자 타입에 차이가 있다. execute()는 Runnable 인터페이스만 인자로 받을 수 있지만, submit()은 Runnable과 Callable 인터페이스 모두 인자로 받을 수 있다. 또한, 두 메서드는 리턴 타입도 다르다. execute()는 반환 값이 없는 반면, submit()은 Future 객체를 반환한다.

출처 https://www.geeksforgeeks.org/difference-between-executorservice-execute-and-submit-method-in-java/

2-3. ScheduledExecutorService

ScheduledExecutorService는 ExecutorService를 상속 받은 인터페이스로 특정 시간 이후에 또는 주기적으로 작업을 실행할 수 있다.

ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
scheduledExecutorService.schedule(() -> System.out.println("After 3 seconds..."), 3, TimeUnit.SECONDS);
scheduledExecutorService.shutdown();

ScheduledExecutorService scheduledExecutorService2 = Executors.newSingleThreadScheduledExecutor();
scheduledExecutorService2.scheduleAtFixedRate(() -> System.out.println("Period is 2 seconds..."), 3, 2, TimeUnit.SECONDS);
Thread.sleep(5000);
scheduledExecutorService2.shutdown();

3. Callable

Runnable은 반환 값이 void 이기 때문에, 작업을 처리하는 것 뿐 작업 결과를 리턴할 수 없었다. Callable은 Runnable과 유사하지만, 작업의 결과(Future 객체)를 받을 수 있다는 차이가 있다.

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Callable<String> hello = () -> {
          Thread.sleep(2000);
          return "hello";
        };

        Future<String> result = executorService.submit(hello);

        System.out.println("Started!");
        result.get(); // 블로킹
        System.out.println("End!");
        executorService.shutdown();
    }
}

Future의 get()은 작업 결과를 리턴하는 함수인데, 블로킹 콜이라 리턴될 때까지 리소스를 잡고 있는다. 결과를 최대한으로 기다릴 시간(타임아웃)을 설정할 수 있다.

Future의 isDone()함수로는 작업 상태를 확인할 수 있다. 작업이 완료되었으면 true, 아니면 false를 리턴한다.

future.isDone();

Future의 cancel()함수를 사용하면 해당 스레드의 작업을 취소할 수 있다. 인자로는 true/false를 줄 수 있다. true는 현재 진행중인 작업을 interrupt하면서 종료하는 것이고, false는 현재 진행중인 작업이 끝날때까지 기다렸다가 종료하는 것이다. false를 줬다고 해서 결과를 얻을 수 있는건 아니다. 단지 작업을 기다려주는 것 뿐이다.

future.cancel(true);

executorService.invokeAll()을 사용하면 여러 작업을 Collections으로 넘겨 동시에 실행할 수 있다. 다만, 동시에 실행한 작업 중 제일 오래 걸리는 작업 만큼 시간이 걸린다. Thread pool에 있는 Callable 동작들을 각 Thread가 처리하고 모든 작업이 끝나면, 즉 마지막 작업까지 종료된 4초 뒤에야 작업의 결과를 가져올 수 있다.

public class StudyCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Callable<String> hello = () -> {
          Thread.sleep(2000);
          return "hello";
        };

        Callable<String> so = () -> {
            Thread.sleep(3000);
            return "so";
        };

        Callable<String> bye = () -> {
            Thread.sleep(4000);
            return "bye";
        };

        List<Future<String>> futures = executorService.invokeAll(Arrays.asList(hello, so, bye));
        for (Future<String> f : futures) {
            System.out.println(f.get());
        }

        executorService.shutdown();
    }

4. CompletableFuture

Future를 사용해서도 비동기 프로그래밍이 가능했지만, Future만으로 힘든 작업들도 많았다.

• Future는 취소하거나 get()에 타임아웃을 설정할 수는 있지만, 외부에서 완료시킬 수는 없다.
• 블로킹 코드(get())를 사용하지 않고는 작업이 끝났을 때 콜백을 실행할 수 없다.
• 여러 Future를 조합할 수 없다. (ex. 유튜브 영상 정보를 가져오고 해당 영상의 댓글 목록 가져오기)
• 예외 처리용 API를 제공하지 않는다.

CompletableFuture는 Future만으로는 힘들었던 비동기 작업을 가능하게 하는 인터페이스이다. CompletableFuture를 사용하면 ExecutorService 객체와 Future 객체를 따로 만들지 않아도 된다.

CompletableFuture를 사용하여 비동기 작업을 실행해보자. Runnable처럼 리턴값 없이 사용할 때는 runAsync()를 사용한다.

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> System.out.println("No Return"));

리턴값이 있는 경우에는 supplyAsync()를 사용한다.

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Return");
            return "ParamReturn";
});
System.out.println(future.get()); // 결과 가져오기

CompletableFuture를 사용하여 Asynchronous하게 콜백을 실행시킬수도 있다. 리턴값을 받아서 다른 값으로 바꾸는 콜백을 구현하기 위해 thenApply()를 사용할 수 있다.

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Return: " + Thread.currentThread().getName());
            return "ParamReturn";
        }).thenApply((s) -> {
            System.out.println("CallBack: " + Thread.currentThread().getName());
            return s.toUpperCase();
        });
        System.out.println(future.get()); // 결과 가져오기
    }
}

thenApply() 말고도 콜백을 구현할 수 있는 함수들이 있다. thenAccept()을 사용하면 리턴값을 받아 리턴 없이 또 다른 작업을 처리하는 콜백을 구현할 수 있고, thenRun()을 사용하면 리턴값을 받지 않고 또 다른 작업을 처리하는 콜백을 구현할 수 있다.

Executor를 해당 스레드에서 사용하게 할 수도 있다. runAsync() OR supplyAsync()의 두 번째 인자로 ExecutorService를 주면 해당 스레드 풀 내에서 작업을 할당해서 처리한다.

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Hello: " + Thread.currentThread().getName());
            return "HelloReturn";
        }, executorService).thenAccept((s) -> {
            System.out.println("HelloCallBack: " + Thread.currentThread().getName());
            System.out.println(s.toUpperCase());
        });

        future.get();
        executorService.shutdown();
    }
}

스레드의 콜백작업을 또 다른 스레드에서 처리할 수 있는데! then() 에 Async를 붙인 thenAsync()함수를 사용하고 두 번째 인자로 ExecutorService를 주면 된다.

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Bye: " + Thread.currentThread().getName());
            return "ByeReturn";
        }, executorService).thenAcceptAsync((s) -> {
            System.out.println("ByeCallBack: " + Thread.currentThread().getName());
            System.out.println(s.toUpperCase());
        }, executorService);

        future.get();
        executorService.shutdown();
    }
}

업무 중 엔진을 패치하는 작업을 하게 되면, 자바 언어 자체의 기본적인 내용을 모르면 이해하지 못하는 경우가 종종 있었다... 그럴때마다 자바에 대한 기초적인 구조부터 공부할 필요가 있다고 생각하여 정리하는 시간을 가져보고자 한다!

JVM (Java Virtual Machine)

JVM은 자바 바이트 코드(.class 파일)를 OS에 특화된 코드로 변환하여 실행하는 역할을 한다.

public class HelloWorld {
    public static void main(String[] args) {
       System.out.println("Hello, World!");
    }
}

위의 자바 코드를 컴파일을 하면 클래스 파일이 나오는데, 클래스 파일을 보면 바이트 코드로 변환된 것을 확인할 수 있다.

Compiled from "HelloWorld.java"
public class HelloWorld {
  public HelloWorld();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String Hello, World!
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

그리고 '인터프리터와 JIT(Just In Time) 컴파일러'가 native OS에 맞춰서 바이트 코드(.class)를 실행해준다. 현재 나의 컴퓨터는 Mac OS를 사용하고 있으므로, Mac에 맞춰 machine 코드로 변경한 다음, machine이 이해할 수 있는 코드로 변환하여 실행해준다.

즉, JVM은 바이트 코드를 어떻게 실행할 수 있는지에 대한 스펙이라고 할 수 있다. 또한, JVM은 machine 코드로 바꿔서 실행해야 하는데 machine 코드라는게 OS에 맞춰서 실행해야 하기 때문에 특정 플랫폼에 종속적이라는 특징을 가지고 있다.

JRE (Java Runtime Environment)

JVM은 홀로 제공되지 않고, 최소한의 배포 단위가 JRE이다. JRE는 JVM과 함께 라이브러리를 제공하는 형태인데, 자바 어플리케이션을 실행하는데 필요한 것들만 들어있다. 자바 바이트 코드를 실행해야하므로 JVM이 들어있고, 자바의 핵심 라이브러리 및 자바 런타임 환경에서 사용하는 프로퍼티 세팅이나 리소스 파일을 가지고 있다.

즉, JRE는 자바 어플리케이션이 실행될 수 있도록 구성되어 있는 배포판이라고 생각하면 된다. 하지만 자바를 개발하는 도구는 포함되어 있지 않다! (jre를 다운받아보면 java는 들어있지만, 자바를 컴파일할 때 사용하는 javac는 들어있지 않다)

JDK (Java Development Kit)

JDK는 JRE와 함께 자바 개발에 필요한 툴을 제공하는 형태이다. 우리같은 개발자들은 JRE를 설치하여 사용할 일보다 JDK를 설치할 일이 많다 !

하지만, 자바 11부터는 JRE를 따로 제공하지 않으며 JDK만 제공하고 있다. 그러므로 더 이상 헷갈릴 일은 없지만 ! 업무에서 사용하고 있는 자바 버전이 11보다 낮을 수도 있기 때문에 ^^.. ㅜ 잘 구분해두도록 하자. (엔진 패치 작업을 진행할 때, 'JDK가 어쩌고 저쩌고~' 하는데 JRE랑 헷갈려서 머리가 어질어질했던 경험이 있다 ㅋ_ㅋ)

JVM 구조

참고: https://www.geeksforgeeks.org/jvm-works-jvm-architecture/

JVM의 구조 크게 4가지 요소로 구성되어 있다. 공부할 때마다 매번 헷갈려 하는 개념이기 때문에(개념이 너무 생소하고 어렵다 ;_;) 정리해보고자 한다.

1. 클래스 로더

클래스 로더는 .class 파일에서 바이트 코드를 읽고 메모리에 적절하게 배치하는 역할을 한다. 클래스 로더는 크게 3가지 과정으로 나눌 수 있다.

• 로딩: 클래스 파일에서 바이트 코드를 읽어오는 과정
• 링크: 그 안의 레퍼런스를 연결하는 과정
• 초기화: static 값들 초기화 및 변수 할당

2. 메모리

메모리는 크게 5가지 영역으로 나누어져 있다. '힙, 메소드' 영역은 전체 쓰레드가 참조할 수 있도록 공유되는 영역이다. 반면, '스택, PC, 네이티브 메소드 스택' 영역은 쓰레드 별로 공유되는 영역이다.

• 스택

  • 쓰레드마다 런타임 스택을 만들고, 그 안에 메소드 호출을 '스택 프레임'이라는 블럭으로 쌓는다. (스택 프레임 = 메소드 call)
  • 그래서, 쓰레드가 종료되면 런타임 스택도 함께 사라진다.

• PC(Program Counter): 쓰레드마다 쓰레드 내 현재 실행할 명령어의 위치를 가리키는 포인터

• 네이티브 메소드 스택: 자바 이외의 언어로 작성된 native 코드를 실행할 때 할당되는 영역이며, 타 언어의 스택 정보를 바이트 코드로 저장한다.

• 힙: 객체를 저장하는 영역

• 메소드: 클래스 수준의 정보를 저장하고 있는 영역 (클래스 수준의 정보? 클래스 이름, 부모 클래스 이름, 메소드, 변수)

3. 실행 엔진

바이트 코드를 이해하는 영역이다.

• 인터프리터: 바이트 코드를 native 코드로 바꿔서 machine이 이해할 수 있도록 한다. 한줄 씩 실행하면서 컴파일하기 때문에 효율적이지는 않다.

• JIT(Just In Time) 컴파일러: 인터프리터의 효율을 높이기 위해, 인터프리터가 반복되는 바이트 코드를 발견하면 JIT 컴파일러로 반복되는 바이트 코드를 모두 native 코드로 바꿔둔다. 그 다음부터 인터프리터는 native 코드로 컴파일된 코드를 바로 사용한다.

• GC(Garbage Collector): 메모리 최적화를 위해, 더 이상 참조되지 않는 객체를 모아서 정리한다.

4. JNI (Java Native Interface)

자바 어플리케이션에서 자바 언어가 아닌 C, C++, 어셈블리 등으로 작성된 함수를 사용할 수 있는 방법을 제공하는 인터페이스를 말한다. native 키워드를 사용한 메소드를 호출한다. ex) Thread의 currentThread() 메소드 - C로 구현되어 있으며, 소스코드를 확인하면 native키워드가 붙어있다.

5. 네이티브 메소드 라이브러리

C, C++로 작성된 라이브러리이다. 해당 라이브러리는 꼭 JNI를 통해서 사용되어야 한다.

클래스 로더

실제로 우리가 개발을 하게 되면 클래스 로더와 관련되어 있는 라이브러리와 툴을 경험할 기회가 많다. 그렇기에 클래스 로더 시스템에 구체적인 동작 방식에 대해 정리해보게 되었다.

클래스 로더는 로딩, 링크, 초기화 순으로 진행된다.

1. 로딩

로딩 단계에서는 클래스 로더가 바이트 코드를 읽고 그 내용에 따라 적절한 바이너리 데이터를 만든다. 그리고 클래스 정보를 '메소드' 메모리 영역에 저장한다.

이때, 메소드 영역에 저장되는 데이터는 다음과 같다.

1) FQCN(Fully Qualified Class Name): 클래스가 속한 패키지명을 모두 포함한 이름 정보 -> 패키지 경로, 클래스 이름 2) 클래스인지/인터페이스인지/enum인지 구분하는 정보 3) 메소드와 변수 정보

로딩이 끝난 클래스는 해당 클래스 타입의 Class 객체를 생성하여 '힙' 메모리 영역에 저장한다.

클래스 로더는 계층 구조로 이뤄져 있으며 기본적으로 3가지 클래스 로더가 제공되고 있다.

• Bootstrap 클래스 로더 : 최상위 우선순위를 가진 클래스 로더로써, JAVA_HOME₩lib 에 있는 코어 자바 API를 제공한다.
• Platform(Extension) 클래스 로더 : JAVA_HOME₩lib₩ext 폴더 또는 java.ext.dirs 시스템 변수에 해당하는 위치에 있는 클래스를 읽는다.
• Application 클래스 로더 : 어플리케이션 클래스패스(어플리케이션을 실행할 때 주는 -classpath 옵션 또는 java.class.path 환경 변수의 값에 해당하는 위치)에서 클래스를 읽는다.

로딩을 할 때, 최상위 부모 클래스 로더(Bootstrap)부터 바이트 코드를 읽어오려고 한다. 만약 부모 클래스 로더가 코드를 읽어오지 못하면, 자식 클래스 로드로 내려가면서 계층적으로 클래스 파일을 읽어오려고 한다. 만약 Application 클래스 로더까지 읽어오지 못한다면 Class Not Found Exception이 발생하게 된다.

2. 링크

링크 단계에서는 크게 3가지 단계로 나누어져 있다.

• Verify : .class 파일 형식이 유효한지 체크하는 단계이다. 유효하지 않으면, 에러가 나고 JVM 단에서 에러를 발생시켜 자바 어플리케이션이 죽게 된다.
• Prepare : 메모리를 준비하는 단계이다. 클래스 변수(static 변수)와 기본 값에 필요한 메모리를 준비한다.
• Resolve (Optional) : 심볼릭 메모리 레퍼런스를 메소드 영역에 있는 실제 레퍼런스로 교체하는 단계이다. 나중에 레퍼런스를 실제로 사용할 때, 해당 단계가 발생할 수도 있다.

3. 초기화

마지막 단계인 초기화 단계에서, Prepare 단계에서 준비해둔 메모리 영역에 Static 변수의 값을 할당하게 된다. static 블럭은 이 단계에서 실행되게 된다.

이 포스팅은 백기선님의 더 자바, "코드를 조작하는 다양한 방법"을 수강하고 정리한 내용입니다.

이제까지 자바와 스프링으로 개발을 해왔지만, 한번도 의존성 주입이 어떻게 이루어지는지 궁금해하지 않고 당연한 것처럼 써왔다. 이번 기회를 통해, 스프링 내부 동작 방식에 대해 공부해보려고 한다.

DI 내부 동작방식 ?

스프링으로 개발을 할 때, 우리는 기본적으로 Service와 Repository라는 컴포넌트를 만들고 Service에 @Autowired 라는 어노테이션을 통해 Repository를 주입시킨다.

이러한 과정을 DI(Dependency Injection) 즉, 의존성 주입이라고 한다.

실제로 테스트 클래스를 만들어보면,

package com.example.demo;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class BookServiceTest {

    @Autowired
    BookService bookService;

    @Test
    public void di() {
        // 스프링이 bookRepository를 생성하여, bookService에 DI 해줌
        Assert.assertNotNull(bookService);
        Assert.assertNotNull(bookService.bookRepository);
    }
}

테스트가 정상 통과가 되고, bookService와 bookRepository가 null이 아님을 알 수 있다.

그렇다면, 스프링은 DI를 어떻게 하는 것일까?

리플렉션(Reflection)

1) 구체적인 클래스 타입을 알지 못해도 그 클래스의 메소드, 타입, 변수들을 접근할 수 있도록 해주는 자바 API 이며, 2) 컴파일 시간이 아닌 실행 시간에 동적으로 특정 클래스의 정보를 추출해낼 수 있는 프로그램 기법 이다.

자바는 컴파일 시점에 타입을 결정하는 정적 언어인데, 동적으로 클래스를 사용해야 할 때 리플렉션이 사용된다. 즉, 작성 시점에는 어떤 클래스를 사용해야 할지 모르지만 런타임 시점에서 클래스를 실행해야 할 경우 사용된다.

대표적인 예시로, 스프링이 리플렉션을 이용하여 런타임 시에 개발자가 등록한 빈을 어플리케이션에서 가져와 사용할 수 있도록 한다.

• 스프링 프레임워크: DI에 사용
• MVC: View에서 넘어오는 데이터를 객체에 바인딩할 때 사용
• Hibernate: @Entity 클래스에 setter가 없으면 해당 필드에 값을 바로 주입
• JUnit: 아예 ReflectionUtils 라는 클래스를 내부적으로 정의하여 사용

그렇다면 이제 리플렉션 사용법에 대해 알아보자!

리플렉션 API 1 : 클래스 정보 조회

자바에서 리플렉션은 Class<?> 인스턴스로 접근이 가능하다. (리플렉션이 제공하는 API) https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html

아래의 예제를 통해, 리플렉션을 어떻게 사용하는지 알아보자.

public class Book {

    private static String a = "aBOOK";

    private static final String b = "bBOOK";

    private String c = "cBOOK";

    public String d = "dBOOK";

    protected String e = "eBOOK";

    public Book() {
    }

    public Book(String c) {
        this.c = c;
    }

    public Book(String c, String d, String e) {
        this.c = c;
        this.d = d;
        this.e = e;
    }

    private void privateMethod() {
        System.out.println("privateVoidMethod");
    }

    public void publicMethod() {
        System.out.println("publicVoidMethod");
    }

    public int sum(int l, int r) {
        return l + r;
    }
}

• 리플렉션을 사용하여, 클래스가 가지고 있는 '필드, 메서드, 생성자, 접근 지시자'와 같은 다양한 정보들에 접근할 수 있다.

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        // 생성한 객체에 접근하려면, class가 필요하다. 클래스 인스턴스에 접근하는 방법은 3가지다.

        // 1) 타입을 통해 클래스 객체를 가져오는 방법
        // 클래스 로딩이 끝나면, 클래스 타입의 인스턴스를 만들어서 heap에 저장하므로 인스턴스를 가져올 수 있음
        Class<Book> bookClass = Book.class;

        // 2) 인스턴스를 통해 클래스 객체를 가져오는 방법
        // 인스턴스가 이미 만들어져있는 경우, getClass() 를 사용하여 가져올 수 있음
        Book book = new Book();
        Class<? extends Book> aClass = book.getClass();

        // 3) 경로를 통해 클래스 객체를 가져오는 방법
        // 클래스가 없으면 ClassNotFoundException 이 발생함
        Class<?> aClass1 = Class.forName("com.example.demo.Book");

        ////////////////////////////////////////////////////////////////////////////////////
        // 필드 목록 가져오기
        System.out.println("-----모든 필드 목록 가져오기-----");
        Arrays.stream(bookClass.getDeclaredFields()).forEach(System.out::println);
        System.out.println();

        System.out.println("-----public 필드 목록만 가져오기-----");
        Arrays.stream(bookClass.getFields()).forEach(System.out::println);
        System.out.println();

        System.out.println("-----특정 이름을 가진 필드 목록만 가져오기-----");
        // 필드가 없으면 NoSuchFieldException 이 발생함
        Arrays.stream(new Field[]{bookClass.getDeclaredField("b")}).forEach(System.out::println);
        System.out.println();

        System.out.println("-----필드가 가지고 있는 값 목록 가져오기 (값을 가져올 때는 객체가 있어야함)-----");
        Arrays.stream(bookClass.getDeclaredFields()).forEach(f -> {
            try {
                f.setAccessible(true); // reflection으로는 이렇게 접근 지시자를 무시할 수 있음
                System.out.printf("%s %s \n", f, f.get(book));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        });
        System.out.println();

        // 메서드 목록 가져오기
        System.out.println("-----모든 메서드 목록 가져오기-----");
        // 직접 정의한 public 메서드 외에도, Object로부터 상속받은 메서드도 출력됨
        // private 메서드도 출력하려면 getDeclaredMethods() 
        Arrays.stream(bookClass.getMethods()).forEach(System.out::println); 
        System.out.println();

        // 생성자 목록 가져오기
        System.out.println("-----모든 생성자 목록 가져오기-----");
        Arrays.stream(bookClass.getDeclaredConstructors()).forEach(System.out::println);
        System.out.println();

        // 접근 지시자 확인하기
        System.out.println("-----접근 지시자 확인하기-----");
        Arrays.stream(bookClass.getDeclaredFields()).forEach(f -> {
            int modifiers = f.getModifiers();
            System.out.print(f + "-> ");
            System.out.print("private? " + Modifier.isPrivate(modifiers));
            System.out.println(", static? " + Modifier.isStatic(modifiers));
        });
    }
}

-----모든 필드 목록 가져오기-----
private static java.lang.String com.example.demo.Book.a
private static final java.lang.String com.example.demo.Book.b
private java.lang.String com.example.demo.Book.c
public java.lang.String com.example.demo.Book.d
protected java.lang.String com.example.demo.Book.e

-----public 필드 목록만 가져오기-----
public java.lang.String com.example.demo.Book.d

-----특정 이름을 가진 필드 목록만 가져오기-----
private static final java.lang.String com.example.demo.Book.b

-----필드가 가지고 있는 값 목록 가져오기 (값을 가져올 때는 객체가 있어야함)-----
private static java.lang.String com.example.demo.Book.a aBOOK 
private static final java.lang.String com.example.demo.Book.b bBOOK 
private java.lang.String com.example.demo.Book.c cBOOK 
public java.lang.String com.example.demo.Book.d dBOOK 
protected java.lang.String com.example.demo.Book.e eBOOK 

-----모든 메서드 목록 가져오기-----
public int com.example.demo.Book.sum(int,int)
public void com.example.demo.Book.publicMethod()
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

-----모든 생성자 목록 가져오기-----
public com.example.demo.Book(java.lang.String,java.lang.String,java.lang.String)
public com.example.demo.Book(java.lang.String)
public com.example.demo.Book()

-----접근 지시자 확인하기-----
private static java.lang.String com.example.demo.Book.a-> private? true, static? true
private static final java.lang.String com.example.demo.Book.b-> private? true, static? true
private java.lang.String com.example.demo.Book.c-> private? true, static? false
public java.lang.String com.example.demo.Book.d-> private? false, static? false
protected java.lang.String com.example.demo.Book.e-> private? false, static? false

• 또한, 리플렉션으로 클래스가 가지고 있는 '부모 클래스, 인터페이스'와 같은 다양한 정보들에도 접근할 수 있다.

public interface MyInterface {}
public interface BookInterface {}

public class MyBook extends Book implements MyInterface, BookInterface {}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {

        Class<MyBook> myBookClass = MyBook.class;

        // 상위 클래스 목록 가져오기
        System.out.println("-----부모클래스 목록 가져오기-----");
        System.out.println(myBookClass.getSuperclass());
        System.out.println();

        // 인터페이스 목록 가져오기
        System.out.println("-----모든 인터페이스 목록 가져오기-----");
        Arrays.stream(myBookClass.getInterfaces()).forEach(System.out::println);
        System.out.println();
    }
}

-----부모클래스 목록 가져오기-----
class com.example.demo.Book

-----모든 인터페이스 목록 가져오기-----
interface com.example.demo.MyInterface
interface com.example.demo.BookInterface

Reflection 과 Annotation

• 리플렉션으로 클래스가 가지고 있는 '어노테이션' 정보 또한 확인할 수 있다.

하지만 Book 클래스가 가지고 있는 어노테이션 정보를 확인하였을 때, 실제 결과는 아무것도 출력되지 않는다. (?_?)

public @interface MyAnnotation {}

@MyAnnotation
public class Book {}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 어노테이션 목록 가져오기
        System.out.println("-----모든 어노테이션 목록 가져오기-----");
        Arrays.stream(Book.class.getAnnotations()).forEach(System.out::println);
        System.out.println();

    }
}

-----모든 어노테이션 목록 가져오기-----

어노테이션은 근본적으로 주석과 같은 취급을 받기 때문에, 어노테이션 정보가 클래스, 소스까지는 남지만 바이트 코드를 로딩할 때 메모리 상에 남지 않게 된다. (즉, 어노테이션 정보는 빼고 읽어오게 된다.)

@Retention

그래서 런타임까지 어노테이션 정보를 유지하고 싶다면, @Retention 어노테이션을 사용하면 된다.

• 바이트 코드에 어노테이션 정보가 있는지 확인하고 싶다면, java -c -v 클래스_절대경로.class 를 사용하면 된다.

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

// Retention 기본값은 RetentionPolicy.CLASS
@Retention(RetentionPolicy.RUNTIME) // 런타임까지 어노테이션을 유지한다.
public @interface MyAnnotation {
}

-----모든 어노테이션 목록 가져오기-----
@com.example.demo.MyAnnotation()

@Target

어노테이션을 적용할 수 있는 범위를 설정할 수도 있다.

아래 예제에서 MyAnnotation을 생성자나 메서드에 적용하려고 하면, 에러가 발생한다.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.FIELD}) // 어노테이션을 사용할 수 있는 곳은 클래스와 필드
@Retention(RetentionPolicy.RUNTIME) // 런타임까지 어노테이션을 유지한다.
public @interface MyAnnotation {
}

@Inherited

어노테이션을 하위 클래스까지 전달할 것인지, 상속 여부를 결정할 수도 있다.

아래 예제를 보면, Book 클래스는 MyAnnotation이 적용되어 있으며, MyBook 클래스는 BookAnnotation이 적용되어 있음과 동시에 Book 클래스를 상속받고 있다.

import java.lang.annotation.*;

@Inherited // 상속이 가능하도록 한다.
@Target({ElementType.TYPE, ElementType.FIELD}) // 어노테이션을 사용할 수 있는 곳은 클래스와 필드
@Retention(RetentionPolicy.RUNTIME) // 런타임까지 어노테이션을 유지한다.
public @interface MyAnnotation {
}

@Retention(RetentionPolicy.RUNTIME) // 런타임까지 어노테이션을 유지한다.
public @interface BookAnnotation {
}

@MyAnnotation
public class Book {}

@BookAnnotation
public class MyBook extends Book implements MyInterface, BookInterface {}

이 상태에서 MyBook 클래스의 어노테이션 목록을 출력하면, Book 클래스에 적용된 MyAnnotation 도 같이 하위 클래스인 MyBook 클래스에 적용되어 출력되게 된다. 부모 클래스가 아닌, 해당(자식) 클래스에 명시된 어노테이션 목록만 따로 출력할 수도 있다.

import java.util.Arrays;

public class Main {
        System.out.println("----모든 어노테이션 목록 가져오기-----");
        Arrays.stream(MyBook.class.getAnnotations()).forEach(System.out::println);
        System.out.println();

        System.out.println("----명시된 어노테이션 목록 가져오기-----");
        Arrays.stream(MyBook.class.getDeclaredAnnotations()).forEach(System.out::println);
        System.out.println();
    }
}

----모든 어노테이션 목록 가져오기-----
@com.example.demo.MyAnnotation()
@com.example.demo.BookAnnotation()

----명시된 어노테이션 목록 가져오기-----
@com.example.demo.BookAnnotation()

리플렉션 API 2 : 클래스 정보 수정 및 실행

리플렉션으로 클래스의 정보를 가져오는 것 뿐만 아니라,

1) 생성자로 인스턴스를 만들 수 있고 2) 필드 값을 가져오거나 수정할 수 있으며 3) 메소드를 실행할 수 있다.

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
            InstantiationException, IllegalAccessException, NoSuchFieldException {

        Class<?> bookClass = Class.forName("com.example.demo.Book");

        // 1) 생성자를 사용하여 인스턴스 생성하기 Constructor.newInstance(params)
        Constructor<?> constructor = bookClass.getConstructor(null); // 기본 생성자를 사용하여 인스턴스를 만들겠다.
        Book book = (Book) constructor.newInstance();
        System.out.println(book);

        // 2) static 필드 값 가져오기 Field.get(object)
        Field a = Book.class.getDeclaredField("a");
        a.setAccessible(true); // private scope 이기 때문에 접근 지시자를 무시하도록 설정해줘야 함
        System.out.println(a.get(null)); // static 변수이므로, 특정 인스턴스를 넘겨줄 것이 없다. 그러므로 null을 넘긴다.

        // 2) static 필드 값 수정하기 Field.set(object, value)
        a.set(null, "abook");
        System.out.println(a.get(null));

        // 2) 필드 값 가져오기 Field.get(object)
        // 특정 인스턴스가 가지고 있는 값을 가져오는 것이기 때문에, 인스턴스가 미리 만들어져 있어야한다.
        Field d = Book.class.getDeclaredField("d");
        System.out.println(d.get(book)); // 미리 만들어져 있던 Book 클래스 객체(book)를 사용하여 해당 객체의 필드 값을 가져옴

        // 2) 필드 값 수정하기 Field.set(object, value)
        d.set(book, "dbook");
        System.out.println(d.get(book));

        // 3) 메소드 실행하기 Method.invoke(object, params)
        Method privateMethod = Book.class.getDeclaredMethod("privateMethod");
        privateMethod.setAccessible(true);
        privateMethod.invoke(book);

        // 3) 파라미터와 리턴 값이 있는 메서드 실행하기 Method.invoke(object, params)
        Method sum = Book.class.getDeclaredMethod("sum", int.class, int.class);
        int result = (int) sum.invoke(book, 10, 20);
        System.out.println(result);
    }
}

com.example.demo.Book@3f0ee7cb
aBOOK
abook
dBOOK
dbook
privateVoidMethod
30

리플렉션을 사용하여 DI 프레임워크 만들기

• test/java

  package com.example.di;
  

public class BookRepository {}

public class BookService { @Inject // 필드(BookRepository) 주입 BookRepository bookRepository;

BookRepository bookRepositoryWithOutInject;

}

```java
package com.example.di;

import org.junit.Test;

import static org.junit.Assert.assertNotNull;

public class ContainerServiceTest {

    @Test
    public void getObject_BookRepository() {
        // @Inject 를 적용하지 않은 객체
        BookRepository bookRepository = ContainerService.getObject(BookRepository.class);
        assertNotNull(bookRepository);
    }

    @Test
    public void getObject_BookService() {
        // @Inject 를 적용하여 객체를 주입한 객체
        BookService bookService = ContainerService.getObject(BookService.class);
        assertNotNull(bookService);
        assertNotNull(bookService.bookRepository);
        assertNotNull(bookService.bookRepositoryWithOutInject); // FAIL 
    }
}

• src/main/java 1) @Inject 필드 주입에 사용되는 객체인지 확인하기 위해, @Inject 라는 어노테이션을 만든다. 런타임 시 참조해야하므로 @Retention 어노테이션도 적용해준다.

  package com.example.di;
  

import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME) public @interface Inject { }

2) ContainerService
`getObject`  메서드를 통해 classType 에 해당하는 타입의 객체를 만들어준다.
단, 해당 객체의 필드 중에 `@Inject` 어노테이션이 있다면 해당 필드도 같이 만들어 제공한다.
```java
package com.example.di;

import java.util.Arrays;

public class ContainerService {

    // 클래스 타입이 들어오면, 해당 클래스의 인스턴스를 리턴하도록 Generic 타입으로 정의함
    public static <T> T getObject(Class<T> classType) {
        T instance = createInstance(classType); // 리플렉션을 이용하여 인스턴스를 생성한다.
        Arrays.stream(classType.getDeclaredFields()).forEach(f -> { // 클래스 타입의 필드들을 확인하면서,
            if (f.getAnnotation(Inject.class) != null) { // 필드에 적용된 어노테이션이 @Inject 이면
                Object fieldInstance = createInstance(f.getType()); // 필드 타입에 맞는 클래스 인스턴스를 생성하고
                f.setAccessible(true); // 접근 지시자를 무시하도록 설정하고
                try {
                    f.set(instance, fieldInstance); // 해당 필드에 객체를 주입한다.
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        return instance;
    }

    private static <T> T createInstance(Class<T> classType) { // 리플렉션 이용-> 생성자를 만들어 리턴해준다.
        try {
            return classType.getConstructor(null).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

위의 예제는 예외 처리, 캐싱과 같은 최적화를 위한 기법이 들어가지 않아 효율적인 IOC 컨테이너는 아니다. 실제로 스프링이 DI를 할 때는 훨씬 복잡하고 정교하게 이루어져 있다.

하지만, 스프링이 DI를 수행하는 방법은 위와 같은 리플렉션을 활용한 객체 생성 및 주입임을 기억하고 가자.

정리

리플렉션은 강력한 기능인 만큼, 지나치게 사용하거나 잘못 사용한 경우에는 성능 이슈를 야기할 수 있다.

• 인스턴스는 이미 생성되어 있고 그걸 계속 활용할 수 있으면, 리플렉션으로 접근하는 방법은 불필요하다. (리플렉션을 계속 사용하면, 새로운 객체를 계속 생성하는 것이기 때문에 비효율적임)
• 컴파일 시 확인하지 않고 런타임 시에만 발생하는 문제가 발생할 수 있다.
• 접근 지시자를 무시할 수 있다. (캡슐화를 무시하게 됨)

하지만 잘못 사용했을 때 성능 이슈가 발생한다는 것이지, 잘만 사용한다면 리플렉션은 강력한 기능이다. 남발하지 말고 적재적소에 사용하도록 하자 ! (생각하는 개발자가 되자 @_ㅠ; )

이 포스팅은 백기선님의 더 자바, "코드를 조작하는 다양한 방법"을 수강하고 정리한 내용입니다.

> 값이 있을 수도 없을 수도 있는 컨테이너

• null이 리턴되어 발생하는 NullPonterException을 방지하고자 나오게 된 개념

  String str = null;
  System.out.println(str.indexOf("a")); // NullPointerExecption 발생

• Method에서 작업 중 반환 값이 제대로 들어오지 않았을 때, 주로 3가지 처리 방법을 사용한다.

  String str = null;
  

// 방법1. 예외를 던진다 → 에러가 발생하면, stackTrace를 찍는다. 즉, 리소스 낭비이다 if(str == null) { throw new IllegalStateException(); // 에러 처리를 강제하게 됨 } System.out.println(str.indexOf("a"));

// 방법2. 클라이언트 코드에서 null을 확인한다 → 이는 클라이언트에서 놓친다면 에러가 발생할 수 있다 if(str != null) { System.out.println(str.indexOf("a")); }

// 방법3. Optional을 리턴한다 (자바 8부터) → 빈 값이 들어올수도 있음을 클라이언트에게 명시 후, 빈 값인 경우에 대한 처리를 강제한다. Optional strOptinal = Optional.ofNullable(str);

## 1. 주의할 점
### 1-1) 리턴 값으로만 사용하는 것을 권장한다.
#### [1] 파라미터로 Optional을 사용하지 않는다.
→ Optional을 써서 얻는 메리트가 사라짐!

- 파라미터로 Optional을 사용해도 문법적인 오류는 없다.
- 하지만, 파라미터 값으로 들어온 null에 ifPresent 함수를 호출하려고 하면 NullPointerException이 발생한다.
- 결국 Optional 객체 안에 null 이 아닌 값이 들어있는지 확인하는 코드가 필요하다.

```java
public void setParameter(Optional<Object> param){
    if(param != null) // NullPointerException 가능성 존재하므로 null 체크를 해줘야함
        param.ifPresent(p -> this.param = p); 
}

[2] Map의 Key 타입으로 Optional을 사용하지 않는다.

• Map 인터페이스의 가장 큰 특징: "Null 값을 Key 값으로 쓰지 않는다"
• Optional을 Key 값으로 사용하여 null이 들어올 수 있다는 것이 Map의 특성을 깨버리는 것이 되버린다.

[3] 인스턴스 필드 타입으로 Optional을 사용하지 않는다.

• 이는 도메인 클래스의 설계 문제이다.
• 차라리 상위/하위 클래스로 쪼개거나, delegation 사용을 권장한다.

// Optional<Node> node; // 이렇게 사용하지 않는다.

/////////////////////////////////////////
// delegation을 사용한다.
// 참조 객체를 통해 메서드를 호출하는 방식을 사용한다.
Node node = node.getNode();

/////////////////////////////////////////

// Node 클래스에 정의되어 있는 메서드
public Optional<Node> getNode() {
    return Optional.empty();
}

1-2) primitive type의 Optional은 따로 존재한다.

Optional.of(10); // 내부에서 (un)boxing이 이루어진다 → 성능에 좋지 않다.
OptionalInt.of(10); // 각 primitive 타입에 맞는 클래스를 제공하므로 이를 사용하는 것을 권장한다.

1-3) Optional을 리턴한다면 null을 반환하지 않는다.

• Optional.empty() 로 리턴한다.

  public Optional<Object> getParam() {
    // return null; // 이렇게 사용하지 않는다. → getParam 이후 ifPresent() 실행 시, NullPointerException 발생 가능성이 있음
    return Optional.empty(); // null을 담고 있는 Optional 객체를 반환하자.
  }

1-4) Collection, Map, Stream Array, Optional은 Optinal로 감싸지 않는다.

• 컨테이너 성격의 객체들은 이미 "값이 비어있을 수 있다"는 의미를 포함하고 있다.
• 해당 객체들을 Optional로 감싸면 Optional을 2번 감싸는 형태가 되므로, 무의미하다

2. Optional API

2-1) Optional 만들기

• Optional.of()
  • 인자로서 null 값을 받지 않는 Optional 객체를 만든다.
  • null 값을 of의 입력으로 받을 시, NullPointerException이 발생한다.
• Optional.ofNullable()
  • 인자로서 null 값을 허용하는 Optional 객체를 만든다.
• Optional.empty()
  • null을 가지고 있는 비어있는 Optional 객체를 만든다.

2-2) Optional 값 여부 확인하기

• boolean isPresent()
• boolean isEmpty() : Java 11부터 제공

2-3) Optional 값 가져오기

• get()
  • 값이 null일 경우 NoSuchElementException 발생
  • 가급적 사용하지 않는 것을 추천
• ifPresent(Consumer)
  • 값이 있으면 그 값을 가지고 ~를 해라
  • 값이 있는 경우만 함수가 동작한다
• orElse(T)
  • 값이 있으면 가져오고 없는 경우에 ~를 리턴해라
  • 값이 있든 없든 orElse안에 T는 실행됨
  • 값이 없을 때, 가져오는 객체가 이미 만들어져 있는 객체인 경우 적합
• orElseGet(Supplier)
  • 값이 있으면 가져오고 없는 경우에 ~를 해라
  • 값이 있으면 orElseGet 안에 Supplier가 실행되지 않음
  • 값이 없을 때, 동적으로 새로운 객체를 생성해 실행해야 하는 경우 적합
• orElseThrow()
  • 값이 있으면 가져오고 없는 경우에 에러를 던져라
  • 기본적으로는 NoSuchElementException을 던진다
  • Supplier로 원하는 에러를 던지게 설정할 수 있다

2-4) Optional 필터

• Optional filter(Predicate)
  • Optional에 들어있는 값을 조건에 따라 걸러라
  • 값이 있다는 가정하에 동작
  • 값이 없으면, 빈 optional 객체를 반환한다

2-5) Optional 변환

• Optional map(Function)
  • Optional에 들어있는 값을 변환해라
  • optional이 담고 있는 타입이 달라진다
• Optional flatMap(Function)
  • Optional 안에 들어있는 인스턴스가 Optional인 경우 사용하면 유용

    // map을 사용한 경우
    Optional<Optional<String>> str = optionalOnlineClass.map(OnlineClass::getOptionalString);
    Optional<String> optionalString = str.orElse(Optional.empty());
    

// flatMap을 사용한 경우 Optional optionalStringByFlatMap = optionalOnlineClass.flatMatp(OnlineClass::getOptionalString);

```

이 포스팅은 백기선님의 더 자바, Java 8을 수강하고 정리한 내용입니다.

> 컬렉션이 데이터를 가지고 있는 저장소라면,
스트림은 이 데이터를 가지고 원하는 방식으로 처리해주는 컨베이어 벨트라고 할 수 있다.

• sequence of elements supporting sequential and parallel aggregate operations

• Stream은 연속된 데이터를 처리하는 오퍼레이션들의 모임이다.

• 무제한으로 데이터가 들어와도 처리가 가능하다.

  • Short Circuit 메소드를 사용하여 들어오는 데이터를 제한할 수 있다.
    

• Functional in nature, 스트림이 처리하는 데이터 소스는 변경하지 않는다. (원본 변경 x)

• 즉, 스트림으로 전달받은 데이터 자체를 변경하지 않는다.

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");

// list에 저장된 데이터를 대문자로 바꾸는 처리를 하는 stream
Stream<String> stringStream = list.stream()
                                .map(String::toUpperCase); // stream을 리턴

// list 객체 안의 기존 데이터는 변경되지 않음
list.forEach(System.out::println); // apple banana

1. Stream pipeline

• 오퍼레이션들의 집합
• 0 또는 다수의 중개 오퍼레이션과 1개의 종료 오퍼레이션으로 구성되어 있다.
• 중개 오퍼레이션은 종료 오퍼레이션을만나지 않으면 실행되지 않는다.
  • 반드시 하나의 종료 오퍼레이션이 있어야 한다.

1-1) Intermediate operation (중개 오퍼레이션)

• Stream을 리턴한다.
• 연산을 마치고 처리를 위한 다음 연산을 진행할 수 있다.
• 근본적으로 lazy하다.
  • lazy? 종료 오퍼레이션과 만나기 전까지 실행하지 않는다.
• ex) filter, map, limit, sorted ...

// 종료 오퍼레이션을 만나지 못했으므로, 코드가 실행되지 않음
// 단순히 스트림을 정의한 것뿐 실행은 안됨

list.stream().map((s) -> {
        System.out.println(s); // 출력되지 않음
        return s.toUpperCase();
});

1-2) Terminal operation (종료 오퍼레이션)

• Stream을 리턴하지 않는다.
• 연산을 마치고 해당 처리를 종료한다.
• ex) collect, count, forEach, min, max ...

List<String> collect = list.stream().map((s) -> {
        System.out.println(s); // 소문자로 출력됨
        return s.toUpperCase(); // 대문자로 변경됨
}).collect(Collectors.toList()); // list 객체로 반환됨

collect.forEach(System.out::println); // 대문자로 출력됨

2. parallelStream

• 스트림은 병렬처리를 쉽게 할 수 있다.
• 병렬처리가 항상 좋은 경우는 아니다.
  • thread 생성 비용, 병렬처리 후 수집 비용, 컨텍스트 스위칭 비용 등등 ...
• 데이터가 방대하게 큰 경우 사용하면 유용하다.
• 직접 성능을 측정해보고 결정하는 것이 좋다!

List<String> parallelCollect = list.parallelStream().map((s) -> {
            System.out.println(s + " , <Thread name> " + Thread.currentThread().getName());
            return s.toUpperCase();
        }).collect(Collectors.toList());

        parallelCollect.forEach(System.out::println);

3. Stream API

3-1) 걸러내기

• Filter(Predicate)
• 스트림에서 특정 조건을 만족하는 데이터만 걸러서 만든 새로운 스트림으로 반환한다.
• 중개 오퍼레이션
• ex) 수업 이름에 java가 들어가는 데이터만 스트림으로 만들기

3-2) 변경하기

• Map(Function) , FlatMap(Function)
• 하나의 데이터 안에서 특정 값만 꺼내거나 변경하여 새로운 스트림으로 반환한다.
• flatMap은 여러 개의 값으로 감싸져있는 데이터(Array, List)를 세분화하여 하나로 합친 새로운 스트림을 생성한다.
• 하나의 input에 여러 개의 output이 나올 때, flatMap을 사용한다.
• 중개 오퍼레이션
• ex) 수업 이름을 의미하는 String 객체만을 갖는 스트림으로 만들기

3-3) 생성하기

• generate(Supplier) , Iterator(T seed, UnaryOperator)
• seed로부터 UnaryOperator를 무제한으로 반복하는 스트림으로 반환한다.
• 중개 오퍼레이션
• ex) 10부터 1씩 증가하는 무제한 스트림 만들기

3-4) 제한하기

• limit(long) , skip(long)
• 중개 오퍼레이션
• ex) 최대 10개의 데이터가 담긴 스트림 만들기
• ex) 앞 5개를 제외한 나머지 데이터가 담긴 스트림 만들기

3-5) 스트림에 있는 데이터가 특정 조건을 만족하는지 확인

• anyMatch() , allMatch() , nonMatch()
• 스트림의 데이터들을 돌며 특정 조건을 만족하는지 확인한다.
• 종료 오퍼레이션
• ex) 스트림에 있는 모든 데이터들이 5보다 큰지 확인한다. (boolean 값으로 반환된다.)

3-6) 개수 세기

• count()
• 종료 오퍼레이션
• ex) 10보다 큰 데이터의 개수를 반환한다.

3-7) 스트림을 데이터 하나로 뭉치기

• reduce(identity, ByFunction) , collect() , sum() , min() , max()
• 종료 오퍼레이션
• ex) 모든 숫자의 합 구하기
• ex) 모든 데이터를 하나의 리스트 혹은 Set에 옮겨 담기

예제

// setter, getter, 생성자는 만들어져있다고 가정
public class OnlineClass {
    private Integer id;
    private String title;
    private boolean closed;
}

public class App {

    public static void main(String[] args) {
        List<OnlineClass> springClasses = new ArrayList<>();
        springClasses.add(new OnlineClass(1, "spring boot", true));
        springClasses.add(new OnlineClass(2, "spring data jpa", true));
        springClasses.add(new OnlineClass(3, "spring mvc", false));
        springClasses.add(new OnlineClass(4, "spring core", false));
        springClasses.add(new OnlineClass(5, "rest api development", false));

        List<OnlineClass> javaClasses = new ArrayList<>();
        javaClasses.add(new OnlineClass(6, "The Java, Test", true));
        javaClasses.add(new OnlineClass(7, "The Java, Code manipulation", true));
        javaClasses.add(new OnlineClass(8, "The Java, 8 to 11", false));

        List<List<OnlineClass>> events = new ArrayList<>();
        events.add(springClasses);
        events.add(javaClasses);

        System.out.println("spring 으로 시작하는 수업");
        springClasses.stream()
                .filter(onlineClass -> onlineClass.getTitle().startsWith("spring")) // 중개 오퍼레이션
                .forEach(onlineClass -> System.out.println(onlineClass.getTitle())); // 종료 오퍼레이션

        System.out.println("close 되지 않은 수업");
        springClasses.stream()
                .filter(onlineClass -> !onlineClass.isClosed()) // 중개 오퍼레이션
                .forEach(onlineClass -> System.out.println(onlineClass.getTitle())); // 종료 오퍼레이션

        System.out.println("수업 이름만 모아서 스트림 만들기");
        springClasses.stream()
                .map(OnlineClass::getTitle) // 중개 오퍼레이션 (OnlineClass -> String)
                .forEach(System.out::println); // 종료 오퍼레이션 (String 출력)

        System.out.println("두 수업 목록에 들어있는 모든 수업 아이디 출력");
        events.stream()
                .flatMap(Collection::stream) // 스트림 input으로 들어온 List를 flatten시켜 OnlineClass 객체로 만든다.
                .forEach(onlineClass -> System.out.println(onlineClass.getId())); // 종료 오퍼레이션

        System.out.println("10부터 1씩 증가하는 무제한 스트림 중에서 앞에 10개 빼고 최대 10개 까지만");
        Stream.iterate(10, i -> i+1) // 증가 스트림 생성
                .skip(10) // 앞에 10개 제외
                .limit(10) // 최대 10개
                .forEach(System.out::println); // 종료 오퍼레이션

        System.out.println("자바 수업 중에 Test가 들어있는 수업이 있는지 확인");
        boolean result = javaClasses.stream()
                .anyMatch(onlineClass -> onlineClass.getTitle().contains("Test")); // boolean으로 반환
        System.out.println(result);

        System.out.println("스프링 수업 중에 제목에 spring이 들어간 것만 모아서 List로 만들기");
        List<String> list = springClasses.stream()
                .map(OnlineClass::getTitle) // 제목만 모아서 새로운 stream 객체를 생성
                .filter(title -> title.contains("spring")) // 조건에 맞게 거름
                .collect(Collectors.toList()); // 처리한 스트림을 List 객체로 반환
        list.forEach(System.out::println);

    }
}

이 포스팅은 백기선님의 더 자바, Java 8을 수강하고 정리한 내용입니다.