이 포스팅은 모던 자바 인 액션 책에 나와있는 내용을 바탕으로 작성하였습니다.

 

이미 어느 정도 익숙하고, 많이 사용해왔던 모던 자바의 기법이지만 언제나 그렇듯 기본과 원리가 중요하다는 사실을

인지하면서 프로젝트가 마무리 되는 이 시점에 한 번 더 정리해보려고 한다.

기존에는 책을 대충 훑고 난 다음 사용했기 때문에 이번에는 좀 정독을 하면서 중요 부분은 포스팅해보려고 한다. 

 

람다란 무엇인가?

  • 메서드로 전달할 수 있는 익명함수를 단순화한 것 (이름없음)
  • 기본 문법
    • (parameters) -> expression
    • (parameters) -> { statements; } 

 

어디에 어떻게 람다를 사용할까?

  • 함수형 인터페이스를 인수로 받는 메서드에 람다 표현식을 사용할 수 있다. 
    • 함수형 인터페이스는 정확히 하나의 추상 메서드를 지정하는 인터페이스이다. 
  • 람다 표현식으로 함수형 인터페이스의 추상 메서드 구현을 직접 전달할 수 있으므로 전체 표현식을 함수형 인터페이스의 인스턴스로 취급
// 함수형 인터페이스 예시
public interface Predicate<T> {
	boolean test(T t);
}

public interface Comparator<T> {
	int compare(T o1, T o2);
}
public interface Runnable {
	void run();
}

public void execute(Runnable r) {
	r.run();
}

execute(() -> {});

 

람다를 어떻게 활용할 수 있을까?

  • 실행어라운드 패턴에 활용할 수 있다. 
    • 예를 들어 데이터베이스의 파일 처리를 보면 자원 열고 처리하고 자원 닫는 순서로 이루어 진다. 이 때 실제 자원을 처리하는 코드를 설정과 정리 두 과정이 둘러싸는 형태를 갖는데 이런 형태를 바로 실행 어라운드 패턴이라고 부른다. 
    • 초기화/준비 코드
      작업 A
      정리/마무리 코드
    • 초기화/준비 코드
      작업 B
      정리/마무리 코드
    • 중복되는 준비 코드와 정리 코드가 작업 A와 작업 B를 감싸고 있다. 
// 한 줄씩 읽는 기존 코드
public String work() throws IOException {
	try (BufferedReader br = new BufferedReader(new FileReader("hi.txt"))) {
    	return br.readLine();
    }
}

// 근데 상황에 따라 두 줄을 읽어야 된다는 요구사항이 들어왔다.
// 따라서 br.readLine(); 이 부분의 동작을 함수형 인터페이스를 사용하는 것으로 바꾼다.
public interface BufferedReaderProcessor {
	String process(BufferedReader b) throws IOException;
}

public String work(BufferedReaderProcessor p) throws IOException {
	try (BufferedReader br = new BufferedReader(new FileReader("hi.txt"))) {
    	return p.process(br);
    }
}

String result = work((BufferedReader br) -> br.readLine());
String result2 = work((BufferedReader br) -> br.readLine() + br.readLine());

 

함수형 인터페이스와 람다의 활용

  • 다양한 람다 표현식을 사용하려면 공통의 함수 디스크립터를 기술하는 함수형 인터페이스 집합이 필요하다. 
    • 함수형 인터페이스의 추상 메서드 시그니처를 함수 디스크립터(fuction descriptor)라고 한다. 
  • 자바 API는 Comparable, Runnable, Callable, Predicate, Consumer, Function 등의 함수형 인터페이스를 제공하고 있고, 이 인터페이스에 대한 자세한 설명은 이 포스팅에서 생략하도록 한다. (이와 관련된 포스팅은 따로 있음)
@FunctionalInterface
public interface Consumer<T> {
	void accept(T t);
}

@FunctionalInterface
public interface Function<T,R> {
	R apply (T t);
}

@FunctionalInterface
public interface Predicate<T> {
	boolean test(T t);
}
// Predicate 활용 예시
Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List<String> nonEmpty = filter(listOfString, nonEmptyStringPredicate);

// Consumer 활용 예시
public <T> void forEach(List<T> list, Consumer<T> c) {
	for (T t: list) {
    	c.accept(t);
    }
}

forEach(Arrays.asList(1,2,3,4,5), (Integer i) -> System.out.println(i));
@FunctionalInterface
public interface Function<T> {
	R apply (T t);
}

public <T,R> List<R> map(List<T> list, Function<T,R> f) {
	List<R> result = new ArrayList<>();
    for (T t: list) {
    	result.add(f.apply(t));
    }
    return result;
}

List<Integer> list = map(Arrays.asList("lamdas", "in", "action"),
							(String s) -> s.length()
                            );

 

기본형 특화

자바의 모든 형식은 참조형(Object, Integer, List) 아니면 기본형(int, double, byte, char)가 있다.

제네릭 파라미터 Consumer<T> 의 T 같은 데에는 참조형만 사용할 수 있다는

제네릭의 내부 구현 방식으로 인해 자바에서는 기본형을 참조형으로 박싱하는 기능을 제공한다. 

 

그리고 박싱과 언박싱이 자동으로 이뤄지는 오토박싱 기능도 제공하는데 (int가 Integer로)

이러한 변화과정은 비용이 소모된다. 박싱한 값은 기본형을 감싸는 Wrapper이며 이것은 Heap에 저장된다. 

따라서 박싱한 값이 메모리를 더 소비하기 때문에 기본형을 가져올 때에도 메모리를 탐색해야 하는 과정을 거친다

 

이런 이유로 오토박싱 동작을 피할 수 있도록 특별한 함수형 인터페이스를 제공한다. 

Predicate<Integer> -> IntPredicate 이 외 DoublePredicate, IntConsumer, LongBinaryOperator, IntFuntion가 있다. 

public interface IntPredicate {
	boolean test(int i);
}

 

형식 추론

자바 컴파일러는 람다 표현식이 사용된 콘텍스트를 이용해서 관련된 함수형 인터페이스를 추론해낸다!

그리고 이런 추론은 개발자가 람다 문법에서 파라미터 형식을 생략하더라도 추론이 가능하기 때문에 

아래와 같이 두 가지 형태로 사용이 가능하며 개발자 스스로 어떤 코드가 가독성을 향상 시킬 수 있는지 결정해야 한다.

Comparator<Apple> c = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
Comparator<Apple> c = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

 

람다 캡처링

람다 표현식은 인수를 자신의 바디 안에서만 사용했다. 하지만 자유변수(외부에서 정의된 변수)를 활용할 수 있고,

이것을 람다캡처링(capturing lambda)라고 부른다. 

int portNumber = 8289;
Runnable r = () -> System.out.println(portNumber);

하지만 이에는 제약사항이 있는데

지역 변수가 명시적으로 final로 선언되거나, final은 아니지만 실제론 final처럼 사용되어야 한다는 것이다. 

위에서 portNumber가 다시 portNumber=8080으로 두 번 값을 할당하면 컴파일 에러가 발생하게 될 것이다. 

 

왜 이런 제약사항이 있는가?

인스턴스 변수는 힙에 저장되고, 지역 변수는 스택에 위치하는데 람다가 만약 스레드에서 실행된다고 하면 변수를 할당한 스레드가 사라져서 변수 할당이 해제되었는데도 람다를 실행하는 스레드는 해당 변수에 접근하려 할 것이다. 따라서 자바 구현에서는 원래 변수에 접근을 허용하지 않고, 자유 지역 변수의 복사본을 제공하게 되었고 이 복사본의 값이 바뀌지 않아야 하므로 지역변수에는 값을 한 번만 할당해야 하는 것이다. (병렬화에도 관련이 있음)

 

클로저

함수의 비지역 변수를 자유롭게 참조할 수 있는 함수의 인스턴스

람다와 익명 클래스 모두 메서드의 인수로 전달될 수 있으며 자신의 외부 영역의 변수에 접근할 수 있다. 다만 람다와 익명클래스는 람다가 정의된 메서드의 지역 변수의 값은 바꿀 수 없다. 

 

메서드 참조

메서드를 어떻게 호출해야 하는지 설명을 참조하기 보다는 메서드명을 직접 참조해서 가독성을 높인다. 예를 들어 Apple::getWeight는 Apple클래스에 정의된 getWeight의 메서드 참조이다. 결과적으로 메서드 참조는 람다 표현식 
(Apple a) -> a.getWeight()을 축약한 것이다. 

 

방법

1. 정적 메서드 참조 -> Integer::parseInt

2. 다양한 형식의 인스턴스 메서드 참조 -> String::length

3. 기존 객체의 인스턴스 메서드 참조 -> t::getValue (Transaction 객체를 할당받은 t 지역변수의 getValue 메서드)

 

예시

ToIntFuntion<String> stringToInt = (String s) -> Integer.parseInt(s);

  ->  Funtion<String, Integer> stringToInteger = Integer::parseInt;

BiPredicate<List<String>, String> contains = (list, element) -> list.contains(element);

  ->   Predicate<List<String>, String> contains = List::contains;

Predicate<String> startsWithNumber = (String string) -> this.startsWithNumber(string);

  ->   Predicate<String> startsWithNumber = this::startsWithNumber;

 

생성자 참조

ClassName::new처럼 클래스명과 new 키워드를 이용해 기존 생성자의 참조를 만들 수 있다. 

Supplier의 () -> Apple과 같은 시그니처를 갖는 생성자가 있다고 가정하면 아래와 같이 사용 가능하다. 

Supplier<Apple> c1 = Apple::new;
Apple a1 = c1.get();

Function을 이용하면 아래와 같이 사용할 수 있다.

Function<Integer, Apple> c2 = Apple::new;
Apple a1 = c2.apply(110);

인스턴스화하지 않고도 생성자에 접근할 수 있는 기능을 다양한 상황에 응용할 수 있다. 

static Map<String, Function<Integer, Fruit>> map = new HashMap<>();
static {
	map.put("apple", Apple::new);
    map.put("orange", Orange::new));
}

public static Fruit giveMeFruit(String fruit, Integer weight) {
	return map.get(fruit).apply(weight);
}

 

람다 표현식을 조합할 수 있는 유용한 메서드

자바 8 API의 몇몇 함수형 인터페이스는 디폴트 메서드를 활용해 다양한 유틸리티 메서드를 제공하고 있다. 

 

Comparator

역정렬 reversed(), 두번째 비교자 thenComparing 이 있다.

inventory.sort(comparing(Apple::getWeight)
		 .reversed()
		 .thenComparing(Apple::getCountry));

Prediacte 

negate, and, or 세가지 메서드 제공한다. 

negate는 특정 프레디케이트를 반전시킬 때 예를 들어 '빨간색이 아닌 사과' 같은..

Predicate<Apple> notRedApple = redApple.negate();

and와 or은 말그대로이다.

Predicate<Apple> redAndHeavyAppleOrGreen = 
	redApple.and(apple -> apple.getWeight() > 150)
    		.or(apple -> GREEN.equals(a.getColor()));

Function

Function인터페이스를 반환하는 andThen, compose 두 가지 디폴트 메서드를 제공한다. 

andThen은 주어진 함수를 먼저 적용한 결과를 다음 함수의 입력으로, compose메서드는 인수로 주어진 함수를 먼저 실행한 다음에 그 결과를 외부함수의 인수로 제공한다. 즉, f.andThen(g)에서 andThen 대신에 compose를 사용하면 g(f(x))가 아니라 f(g(x))라는 수식이 된다. 

Funtion<Integer, Integer> f = x -> x + 1;
Funtion<Integer, Integer> g = x -> x * 2;
Funtion<Integer, Integer> h = f.componse(g);
int result = h.apply(1); // 3을 반환한다.

' > 모던자바인액션' 카테고리의 다른 글

Java 함수형 프로그래밍에 대해 알아보자.  (0) 2022.06.16

 

출처 

https://www.baeldung.com/java-functional-programming

책 - 모던자바인액션 

 

1. 소개

 

이 튜토리얼에서 우리는 함수형 프로그래밍 패러다임의 핵심 원칙과 자바 프로그래밍 언어에서 이를 실행하는 방법을 이해하고, 고급 함수형 프로그래밍 기술 중 일부를 다뤄볼 것입니다.

 

2. 함수형 프로그래밍이란?

 

함수형 프로그래밍은 기본적으로 수학의 함수처럼 컴퓨터 프로그램을 작성하는 스타일을 말합니다. 그렇다면 수학에서 함수란 무엇일까요? 함수는 입력 집합을 출력 집합에 연결하는 표현식인데, 여기서 중요한 것은 함수의 출력은 입력에만 의존한다는 것입니다. 



from 모던자바인액션 책


  • 함수란 수학적인 함수와 같다. 즉, 함수는 0개 이상의 인수를 가지며, 한 개 이상의 결과를 반환하지만 부작용이 없다.
  • 함수나 메서드는 지역 변수만을 변경해야 함수형이라 할 수 있다. 그러나 함수나 메서드에서 참조하는 객체가 있다면 그 객체는 불변 객체여야 한다. 즉, 객체의 모든 필드가 final이어야 한다는 것.
  • 함수형은 함수나 메서드가 어떤 예외도 일으키지 않아야 한다. 예외가 발생하면 return으로 결과를 반환할 수 없게 되는데 수학적 함수는 함수값에 대응하는 하나의 결과를 반환해야 한다. 
  • 선언적 프로그래밍과 함수형 프로그래밍의 비교하자면 선언적 프로그래밍은 '어떻게(how)에 집중하는 반편 함수형은 '무엇을'에 집중한다. 스트림 API를 이용해 구현 방법은 라이브러리가 결정한다. 

 

//선억적 프로그래밍

Transaction mostExpensive = transaction.get(0);

if (mostExpensive == null

throw new IllegalArgumentException("Empty list of trancsactions")

    

for (Transaction t : transactions.subList(1, transactions.size())) {

if (t.getValue() > mostExpensive.getValue()) {

     mostExpensive = t;

    }

}

 

//함수형 프로그래밍

Optional<Transaction> mostExpensive = transactions.stream().max(comparing(Transaction::getValue));


2.1. 프로그래밍 패러다임의 분류

 

대체로 프로그래밍 스타일은 명령형 프로그래밍 패러다임과 선언적 프로그래밍 패러다임으로 분류할 수 있습니다. 명령형 접근 방식은 프로그램을 최종 상태에 도달할 때까지 프로그램의 상태를 변경하는 일련의 명령문으로 정의합니다. 절차적 프로그래밍은 절차나 서브루틴을 사용하여 프로그램을 구성하는 명령형 프로그래밍의 한 유형입니다. 객체 지향 프로그래밍(OOP)으로 알려진 인기 있는 프로그래밍 패러다임 중 하나는 절차적 프로그래밍 개념을 확장한 것입니다. 대조적으로, 선언적 접근 방식은 일련의 명령문으로 제어 흐름을 설명하지 않고 계산 논리를 표현합니다. 간단히 말해서, 선언적 접근 방식의 초점은 프로그램이 달성해야 하는 방법보다는 프로그램이 달성해야 하는 것을 정의하는 것입니다. 함수형 프로그래밍은 선언적 프로그래밍 언어의 하위 집합입니다. 오늘날 인기 있는 프로그래밍 언어의 대부분은 범용 언어이므로 여러 프로그래밍 패러다임을 지원하는 경향이 있다는 것을 이해하는 것이 중요합니다.

 

3. 기본 원칙 및 개념

 

이 섹션에서는 함수형 프로그래밍의 몇 가지 기본 원칙과 이를 Java에 적용하는 방법을 다룹니다. 우리가 사용할 많은 기능이 항상 Java의 일부가 아니어서 함수형 프로그래밍을 효과적으로 실행하기 위해선 Java 8 이상을 사용하는 게 좋습니다.

 

3.1. 일급 및 고차 함수

 

프로그래밍 언어는 함수를 일급 시민(first-citizen)으로 취급하는 경우 일급 함수를 갖는다고 합니다. 함수를 변수에 할당하고, 다른 함수에 인수로 전달하고, 다른 함수의 값으로 반환하는 것이 포함됩니다. 이 속성을 사용하면 함수형 프로그래밍에서 고차 함수를 정의할 수 있습니다. 고차 함수는 함수를 인수로 받고 결과로 함수를 반환할 수 있습니다. 이를 통해 함수 구성 및 커링과 같은 함수 프로그래밍의 여러 기술을 추가로 사용할 수 있습니다.

  • 함수를 마치 일반값처럼 사용해서 인수로 전달하거나, 결과로 반환받거나, 자료구조에 저장할 수 있음을 의미
  • 자바 8이 이전 버전과 구별되는 특징 중 하나가 일급 함수를 지원한다는 점인데 :: 연산자로 메서드 참조를 만들거나 (int x) -> x + 1 같은 람다 표현식으로 직접 함숫값을 표현해서 메서드를 함숫값으로 사용할 수 있습니다. 

Collections.sort 메서드에 사용자 지정 비교기를 제공해야 한다고 가정해 보겠습니다. 아래의 코드는 우리가 볼 수 있듯이 이것은 지루하고 장황한 기술입니다. 

Collections.sort(numbers, new Comparator<Integer>() {

    @Override

    public int compare(Integer n1, Integer n2) {

        return n1.compareTo(n2);

    }

});

Collections.sort(numbers, (n1, n2) -> n1.compareTo(n2));

Java는 람다식을 Object로 취급하는데 이건 사실 Java의 진정한 1급 시민입니다. 

 

 

3.2. 순수 함수

 

순수 함수는 오직 argument만을 기반으로 값을 반환해야 하며 side-effect가 없는것을 강조합니다. 이것은 Java의 모든 best practice와 상당히 반대되는 것처럼 들릴 수 있습니다.

객체 지향 언어인 Java는 핵심 프로그래밍 방식으로 캡슐화를 권장합니다. 개체의 내부 상태를 숨기고 액세스 및 수정에 필요한 메서드만 노출되는 것을 권장합니다. 따라서 이러한 메서드는 엄격하게 순수한 함수는 아닙니다.

 

물론 캡슐화 및 기타 객체 지향 원칙은 권장 사항일 뿐 Java에서 바인딩되지 않습니다. 사실, 개발자들은 최근에 불변 상태 정의의 가치와 side-effect가 없는 메소드의 가치를 깨닫기 시작했습니다. 

Integer sum(List<Integer> numbers) {

    return numbers.stream().collect(Collectors.summingInt(Integer::intValue));

}

이제 이 방법은 받는 인수에만 의존하며 어떠한 부작용도 일으키지 않습니다.

부작용은 메서드의 의도된 동작을 제외하고 무엇이든 될 수 있습니다. 예를 들어, 부작용은 값을 반환하기 이전에 local 또는 global 상태를 업데이트하거나 데이터베이스에 저장하는 것을 말할 수 있습니다. 순수주의자들은 또한 로깅도 부작용으로 취급하지만 우리 모두는 우리 만의 룰이 있습니다. 하지만 실제로 결과를 데이터베이스에 저장해야 할 수도 있습니다. 함수형 프로그래밍에는 순수한 함수를 유지하면서 부작용을 처리하는 기술이 있습니다. 

 

 

3.3. 불변성

 

불변성은 함수형 프로그래밍의 핵심 원리 중 하나로, 엔터티를 인스턴스화한 후에는 수정할 수 없는 속성을 말합니다. 함수형 프로그래밍 언어에서는 이는 언어 수준(Language level)에서 지원되는데 자바에서는 변경할 수 없는 데이터 구조를 만들기 위해 스스로 결정해야 합니다. 

 

Java 자체는 String과 같은 몇 가지 기본 제공 불변 유형을 제공합니다. 이것은 주로 보안상의 이유입니다. 클래스 로딩에서 String을 많이 사용하고 해시 기반 데이터 구조에서 키로 사용하기 때문입니다. 기본 래퍼(primitive wrapper) 및 수학 유형과 같은 몇 가지 다른 기본 제공 불변 유형이 있습니다.

 

그러나 우리가 Java에서 생성하는 데이터 구조는 어떻습니까? 물론, 그것들은 기본적으로 변하지 않고,, 불변성을 달성하기 위해 몇 가지를 변경해야 합니다. final 키워드의 사용은 그 중 하나이지만 여기서 그치지 않습니다.

 

public class ImmutableData {

    private final String someData;

    private final AnotherImmutableData anotherImmutableData;

    public ImmutableData(final String someData, final AnotherImmutableData anotherImmutableData) {

        this.someData = someData;

        this.anotherImmutableData = anotherImmutableData;

    }

    public String getSomeData() {

        return someData;

    }

    public AnotherImmutableData getAnotherImmutableData() {

        return anotherImmutableData;

    }

}

 

public class AnotherImmutableData {

    private final Integer someOtherData;

    public AnotherImmutableData(final Integer someData) {

        this.someOtherData = someData;

    }

    public Integer getSomeOtherData() {

        return someOtherData;

    }

}

  1. 불변 데이터 구조의 모든 필드는 불변이어야 합니다.
  2. 이것은 모든 중첩 유형과 컬렉션 (컬렉션에 포함한 것들까지)에도 적용되야 합니다.
  3. 초기화를 위한 하나 이상의 생성자가 있어야 합니다.
  4. 부작용 없는 접근자 메서드만 있어야 합니다.

항상 정확하게 원칙을 고수하긴 어렵다. 특히 데이터 구조가 복잡해지면 복잡해질수록.. 그러나 여러 외부 라이브러리를 사용하면 Java에서 immutable data를 더 쉽게 사용할 수 있습니다. 예를 들면 Immutables 및 Project Lombok은 Java에서 변경할 수 없는 데이터 구조를 정의하기 위해 도움을 줍니다.

 

 

3.4. 참조 투명성

 

참조 투명성은 아마 이해하기 어려운 함수형 프로그래밍 원칙 중 하나일 것입니다. 그러나 개념은 매우 간단합니다. 함수 외부의 영향을 받지 않는 것입니다.  (= 함수의 결과는 입력 파라미터에만 의존하고, 함수 외 DB, 파일시스템, 원격 URL 등에서 데이터를 읽어 오지 않음 = 외부와 의존적이지 않은 코드 = 동일한 매개변수에 대해서는 항상 동일한 결과 = 예외가 없음) 이를 통해 고차 함수 및 지연 평가와 같은 함수형 프로그래밍에서의 몇 가지 강력한 기술을 사용할 수 있습니다. 이것을 더 잘 이해하기 위해 예를 들어 보겠습니다.

 

public class SimpleData {

    private Logger logger = Logger.getGlobal();

    private String data;

    public String getData() {

        logger.log(Level.INFO, "Get data called for SimpleData");

        return data;

    }

    public SimpleData setData(String data) {

        logger.log(Level.INFO, "Set data called for SimpleData");

        this.data = data;

        return this;

    }

}

이것은 Java의 일반적인 POJO 클래스이지만 이것이 참조 투명성을 제공하는지 확인하는 데 관심이 있습니다. 다음 진술을 관찰합시다.

String data = new SimpleData().setData("Baeldung").getData();

logger.log(Level.INFO, new SimpleData().setData("Baeldung").getData());

logger.log(Level.INFO, data);

logger.log(Level.INFO, "Baeldung");

logger에 대한 세 번의 호출은 의미상 동일하지만 참조적으로 투명하지 않습니다. 첫 번째 호출은 부작용을 생성하므로 참조적으로 투명하지 않습니다. 이 호출을 세 번째 호출에서와 같이 해당 값으로 바꾸면 로그가 누락됩니다.

 

두 번째 호출도 SimpleData가 변경 가능하므로 참조적으로 투명하지 않습니다. 프로그램의 어느 곳에서나 data.setData를 호출하면 해당 값으로 대체되기가 어렵습니다.

따라서 기본적으로 참조 투명성을 위해서는 순수하고 변경할 수 없는 함수가 필요합니다. 이것은 우리가 이미 앞에서 논의한 두 가지 전제 조건입니다. 참조 투명성의 흥미로운 결과로써 우리는 컨텍스트가 없는 코드를 생산합니다. 다시 말해서, 우리는 해당 코드를 어떤 순서와 컨텍스트로든 실행할 수 있으며, 이는 다른 최적화 가능성으로 이어지게 됩니다.

 

 

4. 함수형 프로그래밍 기법

 

앞에서 논의한 함수형 프로그래밍 원칙을 통해 함수형 프로그래밍의 이점을 얻기 위한 여러 기술을 사용할 수 있습니다. 이 섹션에서는 이런 인기 기술 중 일부를 다루고 이를 Java에서 구현하는 방법을 이해해 보겠습니다.

 

4.1. 기능 구성

 

Function Composition은 단순한 함수를 결합하여 복잡한 함수를 구성하는 것을 말합니다. 이것은 실제로 자바의 funcional 인터페이스를 통해 달성됩니다. 

 

일반적으로 단일 추상 메서드가 있는 모든 인터페이스는 functional 인터페이스로 사용할 수 있습니다. 그러므로 우리는 functional 인터페이스를 꽤나 쉽게 정의할 수 있지만 Java 8은 기본적으로 java.util.function 패키지에서 다양한 사용 사례에 대해 많은 기능적 인터페이스를 제공하고 있습니다.

 

이것을 더 잘 이해하기 위해 Function 인터페이스를 예로 들어보면 Function은 하나의 인수를 받아들이고 결과를 생성하는 간단하고 일반적인 기능의 인터페이스입니다.

 

또한 함수 구성에 도움이 되는 두 가지 기본 메서드인 compose 및 andThen을 제공합니다.

 

Function<Double, Double> log = (value) -> Math.log(value);

Function<Double, Double> sqrt = (value) -> Math.sqrt(value);

Function<Double, Double> logThenSqrt = sqrt.compose(log);

logger.log(Level.INFO, String.valueOf(logThenSqrt.apply(3.14)));

// Output: 1.06

Function<Double, Double> sqrtThenLog = sqrt.andThen(log);

logger.log(Level.INFO, String.valueOf(sqrtThenLog.apply(3.14)));

// Output: 0.57

이 두 가지 방법 모두 여러 함수를 단일 함수로 구성할 수 있게 하지만 다른 의미를 제공합니다. compose는 인수에 전달된 함수를 먼저 적용한 다음 호출된 함수를 적용하고 andThen은 역으로 동일한 작업을 수행합니다. 

 

여러 다른 함수형 인터페이스도 funcion composition에 사용될 여러 흥미로운 메소드를 가지고 있는데 Predicate 인터페이스의 기본 페소드 and, or, negate가 있습니다. 이러한 기능적 인터페이스는 단일 인수를 허용하지만 BiFunction 및 BiPredicate와 같은 2개의 인수도 가능하게 합니다. 

 

4.2. 모나드 (추가 리서치 필요 - 이해 X)

 

공식적으로 모나드는 일반적으로 프로그램을 구조화할 수 있는 추상화입니다. 따라서 기본적으로 모나드는 값을 래핑하고, 일련의 변환을 적용하고, 모든 변환이 적용된 값을 돌려 받을 수 있게 합니다. (a monad allows us to wrap a value, apply a set of transformations, and get the value back with all transformations applied.)물론 모든 모나드가 따라야 하는 세 가지 법칙(왼쪽 항등, 오른쪽 항등, 연관성)이 있지만 자세한 내용은 다루지 않겠습니다.

 

Java에는 Optional 및 Stream과 같이 자주 사용하는 몇 가지 모나드가 있습니다.

Optional.of(2).flatMap(f -> Optional.of(3).flatMap(s -> Optional.of(f + s)))

Optional 을 모나드라고 부르는 이유는 무엇일까요? 여기에서 Optional을 사용하면 of를 사용해 값을 래핑하고 flatMap 메서드를 사용하여 다른 래핑된 값을 추가하는 변환을 적용하고 있습니다

 

원한다면 Optional이 모나드의 세 가지 법칙을 따른다는 것을 보여줄 수 있습니다. 그러나 비평가들은 Optional이 어떤 상황에선 모나드 법칙을 어긴다고 지적할 것입니다. 그러나 대부분의 실제 상황에서는 이 정도면 충분합니다.

 

모나드의 기본 사항을 이해한다면 Stream 및 CompletableFuture와 같은 Java에 다른 많은 예제도 있음을 깨닫게 될 것입니다.  우리는 로그(log) 모나드, 보고(report) 모나드 또는 감사(audit) 모나드와 같은 다양한 목표를 달성하기 위해 Java에서 자체 모나드 유형을 정의할 수 있습니다. 함수형 프로그래밍에서 부작용 처리(side-effect)에 대해 논의한 것을 기억하십니까? 모나드는 그것을 달성하기 위한 함수형 프로그래밍 기술 중 하나인 것처럼 보이네요.

 

4.3. 커링 (Currying)

 

Currying은 여러 인수를 취하는 함수를 단일 인수를 취하는 일련의 함수로 변환하는 수학적 기술입니다. 우리는 왜 함수형 프로그래밍에서 이 기술이 필요할까요? 모든 인수를 이용해 함수를 호출할 필요가 없는, 강력한 구성 기술을 제공하기 때문입니다.

 

게다가 커링 함수는 모든 인수를 받을 때까지 그 효과를 깨닫지 못합니다.

Haskell과 같은 순수 함수형 프로그래밍 언어에서는 커링이 잘 지원됩니다. 사실, 모든 함수는 기본적으로 커링이 됩니다. 그러나 Java에서는 그렇게 간단하지 않습니다.

 

Function<Double, Function<Double, Double>> weight = mass -> gravity -> mass * gravity;

 

Function<Double, Double> weightOnEarth = weight.apply(9.81);

logger.log(Level.INFO, "My weight on Earth: " + weightOnEarth.apply(60.0));

 

Function<Double, Double> weightOnMars = weight.apply(3.75);

logger.log(Level.INFO, "My weight on Mars: " + weightOnMars.apply(60.0));

위 코드는 우리는 행성에서 우리의 무게를 계산하는 함수를 정의한 것입니다. 우리의 질량은 동일하게 유지되지만 중력은 우리가 있는 행성에 따라 다릅니다. 특정 행성에 대한 함수를 정의하기 위해 중력만 전달하여 함수를 부분적으로 적용할 수 있습니다. 또한 이 부분적으로 적용된 함수를 임의의 구성에 대한 인수 또는 반환 값으로 전달할 수 있습니다.

 

Currying은 람다 식과 클로저라는 두 가지 기본 기능에 기초를 둡니다. 람다 표현식은 코드를 데이터로 취급하는 데 도움이 되는 익명 함수입니다. 우리는 이전에 기능적 인터페이스를 사용하여 구현하는 방법을 보았습니다.

 

이제 람다 식은 우리가 클로저로 정의하는 어휘 범위에서 닫힐 수 있습니다. 예를 들어 보겠습니다.

private static Function<Double, Double> weightOnEarth() {

    final double gravity = 9.81;

    return mass -> mass * gravity;

}

위의 메서드에서 반환하는 람다 식이 어떻게 우리가 클로저라고 부르는 둘러싸는 변수에 의존하는지 주목하십시오. 다른 함수형 프로그래밍 언어와 달리 Java는 둘러싸는 범위가 최종적이거나 사실상 최종적이어야 한다는 제한이 있습니다.

흥미로운 결과로, 커링을 사용하면 Java에서 임의의 arity의 기능적 인터페이스를 만들 수도 있습니다.

 

from 모던자바인액션


예를 들어, 섭씨를 화씨로 변환하는 공식이 있다고 치자.

CtoF(x) = x*9/5 + 32

 

이것을 메서드로 표현하면

 

static double converter(double x, double f, double b) {

return x * f + b;

}

x는 변환하려는 값, f는 변환요소, b는 기준치 조정 요서인데 온도뿐 아니라 킬로미터와 마일 등의 단위도 변환해야 할 것이다. 기존 로직을 커링이라는 개념을 활용해서 한 개의 인수를 갖는 변환 함수를 생산하는 '팩토리'를 정의해보자

 

static DoubleUnaryOperator curriedConverter(double f, double b) {

return (double x) -> x * f + b;

}

DoubleUnaryOperator converterCtoF = curriedConverter(9.0/5, 32);

DoubleUnaryOperator convertUSDtoGBP = curriedCOnverter(0.6, 0);

DoubleUnaryOperator convertKmtoMi = curriedConverter(0.6214, 0);

double gbp = convertUSDtoGBP.applyAsDouble(1000);

기존의 변환 로직을 재활용하는 유연한 코드를 얻었다. 

참고로, DoubleUnaryOperator는 applyAsDouble 이라는 메서드를 정의한다.


4.4. 재귀

 

재귀는 문제를 작게 나누는데 도움을 주는 좋은 기술입니다. 재귀의 주요 이점은 side-effect를 제거하는 데도 도움됩니다. 

from 모던자바인액션


순수 함수형 프로그래밍 언어에서는 while, for 같은 반복문을 포함하지 않는다. 그런 함수형 프로그래밍의 장점이 분명히 있지만 무조건 반복보다는 재귀가 좋다고 주장은 옳지 않다. 왜냐하면 반복 코드보다 재귀 코드가 더 비싸기 때문, 재귀함수를 호출할 때마다 호출 스택에 각 호출시 생성되는 정보를 저장할 새로운 스택 프레임이 만들어진다. 즉, 재귀 팩토리얼의 입력값에 비례해서 메모리 사용량이 증가한다. 그러면 어떡할까? 함수형 언어에서는 '꼬리 호출 최적화' 라는 해결책을 제공한다. 

 

// 일반 재귀 방식의 팩토리얼

static long factorialRecursive(long n) {

return n == 1 ? 1 : n * factorialRecursive(n-1);

}

// 꼬리 재귀 팩토리얼

static long factorialTailRecursive(long n) {

return factorialHelper(1, n);

}

 

static long factorialHelper(long acc, long n) {

return n == 1 ? acc : factorialHelper(acc * n, n-1);

}

컴파일러가 하나의 스택 프레임을 재활용할 가능성이 생긴다. 재귀 호출 이후 추가적인 연산을 요구하지 않도록 구현하는 것이 핵심이다. 아쉽게도 자바는 이와 같은 최적화를 재공하지 않는다, 하지만 여러 컴파일러 최적화 여지를 남겨둘 수 있는 꼬리재귀를 이용하는 것이 좋다. 


 

5. 함수형 프로그래밍이 왜 중요한가?

 

Java를 포함한 모든 언어에서 함수형 프로그래밍을 채택할 때의 가장 큰 이점은 순수 함수와 불변 상태입니다. 돌이켜 생각해보면 대부분의 프로그래밍 문제는 부작용과 변경 가능한 상태가 원인이 되고 있습니다. 따라서 그것들을 제거하기만 하면 우리 프로그램을 더 쉽게 읽고, 추론하고, 테스트하고, 유지 관리할 수 있습니다.

 

선언적 프로그래밍의 하위 집합인 함수형 프로그래밍은 고차 함수, 함수 구성 및 함수 연결과 같은 여러 구문을 제공합니다. Stream API가 데이터 조작을 처리하기 위해 Java 8에 가져온 이점을 생각해 보십시오.

 

함수형 프로그래밍을 사용하기 시작하기 전에 우리는 프로그램에 대해 함수 측면에서 생각하도록 훈련해야 합니다.

 

 

6. 자바는 함수형 프로그래밍에 적합 할까요?

 

Java에 진정한 함수 타입이 없다는 것은 함수형 프로그래밍의 기본 원칙에 위배됩니다. lamda expression으로 위장한 기능적 인터페이스는 적어도 구문적으로는 대부분 이를 보완하긴 하지만 Java가 기본적으로 mutable하고, immutable 타입으로 변경하려면 너무나도 많은 상용구를 작성해야 하는 것도 사실입니다. 

Java에서 arguments에 대한 기본 전략은 eager이지만 lazy evalauation은 더 효과적이고 함수형 프로그래밍에서 추천되는 전략입니다. 우리는 연산자 단락 및 기능 인터페이스를 사용하여 Java에서 지연 평가를 달성할 수 있지만 더 복잡합니다.

type-erasure, 꼬리호출 최적화 등등이 완성된 형태가 아니기 때문에 Java는 함수형 프로그래밍에서 처음부터 프로그램을 시작하는 데 적합하지는 않습니다.

그러나 이미 Java로 작성된 기존 프로그램이 있는 경우(아마도 객체 지향 프로그래밍으로) 어떻게 될까요? 특히 Java 8에서 함수형 프로그래밍의 이점을 취하는 데에는 문제가 없겠습니다. 

함수형 프로그래밍의 대부분의 이점은 Java 개발자에게 달려있습니다. 객체 지향 프로그래밍과 함수형 프로그래밍의 이점을 결합하면 먼 길도 쉽게 갈 수 있을 것입니다. 

 

 

7. 결론

 

이 튜토리얼에서는 함수형 프로그래밍의 기초를 살펴보았습니다. 우리는 기본 원칙과 Java에서 이를 채택하는 방법을 다루었습니다. 또한 Java의 예제를 사용하여 함수형 프로그래밍에서 몇 가지 인기 있는 기술에 대해 논의했습니다.

마지막으로, 우리는 함수형 프로그래밍을 채택할 때의 이점 중 일부를 다루었고 Java가 이에 적합한지 답했습니다.

 

 

 

출처 : 책 자바 성능 튜닝이야기 -'왜 자꾸 String을 쓰지 말라는거야' 편

 

이 책에 나온 초보 개발자 나초보는 서비스를 개발하고 나서 보니 GC가 많이 발생된단 사실을 알게 되었고

성능을 올리기 위해 GC에 영향을 끼치고 있던 String 부분을 개선해보기로 하였다. 

 

문제를 일으키던 부분은

String a = "test"; / for문을 통해 a += "XXX";

이런식으로 String에다 계속 값을 더하는 부분이었다.

String을 이렇게 사용하면 성능 적인 부분에서 문제를 일으킬 수 있다.

 

for문이 100,1000번 이상 돌아간다 가정해보면 메모리 사용률이 올라가고, 응답속도는 낮아질 것이다. 

 

그렇다면 어떻게 해야 할까?

  • StringBuffer 클래스와 StringBuilder 클래스를 사용하여야 한다. 
    • append() 메서드를 활용

 

StringBuffer 클래스와 StringBuilder 클래스의 차이는 

StringBuffer 클래스는 스레드에 안전하게 설계되어 있으므로 여러 개의 스레드에서 하나의 StringBuffer객체를 처리해도 전혀 문제가 되지 않는다. 반면 StringBuilder 클래스는 단일 스레드에서의 안정성만을 보장한다. 

 

String a = new String();
StringBuffer b = new StringBuffer();
StringBuilder c = new StringBuilder();

for(int loop = 0 ; loop < 10000; loop++) {
	a += "abcde";
}

for(int loop = 0 ; loop < 10000; loop++) {
	b.append("abcde");
}
String tempB = b.toString();

for(int loop = 0 ; loop < 10000; loop++) {
	c.append("abcde");
}
String tempC = c.toString();

이런 소스가 실행된다면 결과가 어떻게 될까? 어느 것이 가장 빠르고 메모리를 적게 사용할까? 

 

  응답시간 생성된 임시 객체수 메모리 사용량
a (String) 95초 4,000,000 약 95Gb
tempB (StringBuffer) 0.24초 1400 약 37.5Mb
tempC (StringBuilder) 0.17초 1400 약 37.5Mb

그렇다, 응답시간과 메모리 사용량에서 엄청난 차이가 보인다

응답시간과 메모리 사용량에서 가장 좋은 성능을 보인건 StringBuilder이다. 

 

왜 이럴까?

새로이 더해진 문자열은 새로운 주소를 갖는 객체가 생성이 되기 때문이다. 

a에 "abcde"를 더하면 새로운 String클래스의 객체가 만들어지고, 이전에 있던 a객체는 필요 없는 쓰레기 값이 되어 GC대상이 된다. 이러한 작업이 반복 수행되면서 메모리를 많이 사용하게 되고, 응답 속도에도 많은 영향을 미치게 된다. GC를 하면 할수록 시스템의 CPU를 사용하게 되고 시간도 많이 소요된다. 그래서 프로그래밍을 할 때 메모리 사용을 최소화하는 것은 당연한 일이다. 

 

Wrap-up

  • String은 짧은 문자열을 더할 경우 사용한다.
  • StringBuffer는 스레드에 안전한 프로그램이 필요할 때나, 개발 중인 시스템의 부분이 스레드에 안전한지 모를 경우 사용하면 좋다. (클래스에 static으로 선언한 문자열을 변경하거나, singleton으로 선언된 클래스에 선언된 문자)
  • StringBuilder는 스레드에 안전한지의 여부와 전혀 관계 없는 프로그램을 개발할 때 사용하면 좋다. 메서드 내에 변수를 선언하는 경우가 이에 해당되겠다.
  • WAS나 시스템이 JDK5.0 이상을 사용한다면, 컴파일러에서 자동으로 StringBuilder로 변환해 주긴 한다. 하지만 반복 루프를 사용해서 문자열을 더할 때는 객체를 계속 추가한다는 사실에 변함이 없으므로 StringBuilder, StringBuffer사용을 권장한다. 

 

http://www.corej2eepatterns.com/SessionFacade.htm

 

자바 성능 튜닝 이야기 책에서 말한 핵심 디자인 패턴을 정리해보려고 한다. 

 

Business Delegate

Business Delegate를 사용하여 비즈니스 서비스에 대한 액세스를 캡슐화. Business Delegate는 조회 및 액세스 메커니즘과 같은 비즈니스 서비스의 구현 세부 정보를 숨깁니다.

 

Problem

비즈니스 서비스 구성 요소와의 원격 통신의 복잡성으로부터 클라이언트를 숨기고 싶습니다.

Forces

  1. 장치, 웹 서비스 및 리치 클라이언트와 같은 프레젠테이션 계층 구성 요소 및 클라이언트에서 비즈니스 계층 구성 요소에 액세스하려고 합니다.
  2. 클라이언트와 비즈니스 서비스 간의 결합을 최소화하여 조회 및 액세스와 같은 서비스의 기본 구현 세부 정보를 숨기려고 합니다.
  3. 원격 서비스의 불필요한 호출을 피하려고 합니다.
  4. 네트워크 예외를 애플리케이션 또는 사용자 예외로 변환하려고 합니다.
  5. 클라이언트에서 서비스 생성, 재구성 및 호출 재시도에 대한 세부 정보를 숨기려고 합니다.

Consequences

커플링 감소, 유지보수성 향상, 비즈니스 서비스 예외 번역, 가용성 향상, 비즈니스 계층에 더 간단하고 균일한 인터페이스를 제공, 성능 향상, 추가 레이어 도입

구현 방법

https://www.tutorialspoint.com/design_pattern/business_delegate_pattern.htm


Session Facade

비즈니스 계층 구성 요소를 캡슐화하고 거친 서비스를 원격 클라이언트에 노출합니다. 클라이언트는 비즈니스 구성 요소에 직접 액세스하는 대신 Session Facade에 액세스합니다.

 

Problem

비즈니스 구성 요소 및 서비스를 원격 클라이언트에 노출하려고 합니다.
Forces

 

  1. 클라이언트와의 긴밀한 결합을 방지하기 위해 클라이언트가 비즈니스 계층 구성 요소에 직접 액세스할 수 없도록 하고 싶습니다.
  2. Business Objects 및 기타 비즈니스 계층 구성 요소에 원격 액세스 계층을 제공하려고 합니다.
  3. 애플리케이션 서비스 및 기타 서비스를 집계하여 원격 클라이언트에 노출하려고 합니다.
  4. 원격 클라이언트에 노출되어야 하는 모든 비즈니스 논리를 중앙 집중화하고 집계하려고 합니다.
  5. 비즈니스 구성 요소와 서비스 간의 복잡한 상호 작용 및 상호 종속성을 숨겨서 관리 용이성을 높이고 논리를 중앙 집중화하고 유연성을 높이고 변경 사항에 대처하는 능력을 개선하려고 합니다.

Consequences

원격 클라이언트에 서비스를 제공하는 계층 도입, 계층 간의 결합 감소, 레이어링을 촉진하고 유연성과 유지보수성을 높입니다, 성능 향상, 세분화된 원격 방법 감소, 중앙 집중식 보안 관리, 트랜잭션 제어 중앙 집중화, 클라이언트에 더 적은 수의 원격 인터페이스 노출

구현 방법

https://www.tutorialspoint.com/design_pattern/facade_pattern.htm

 


Data Access Object

데이터 액세스 개체를 사용하여 영구 저장소에 대한 모든 액세스를 추상화하고 캡슐화합니다. 데이터 액세스 개체는 데이터를 가져오고 저장하기 위해 데이터 원본과의 연결을 관리합니다.

Problem

데이터 액세스 및 조작을 별도의 레이어에 캡슐화하려고 합니다.

Forces

  1. 영구 저장소의 데이터에 액세스하고 조작하기 위해 데이터 액세스 메커니즘을 구현하려고 합니다.
  2. 애플리케이션의 나머지 부분에서 영구 저장소 구현을 decouple하려고 합니다.
  3. RDBMS, LDAP, OODB, XML 리포지토리, 플랫 파일 등과 같은 다양한 유형의 데이터 소스에 대한 영구 메커니즘에 대한 균일한 데이터 액세스 API를 제공하려고 합니다.
  4. 데이터 액세스 논리를 구성하고 독점 기능을 캡슐화하여 유지 관리 및 이식성을 용이하게 하려고 합니다.

Consequences

중앙 집중식 제어, 투명한 사용성, 객체 지향 보기를 제공하고 데이터베이스 스키마를 캡슐화, 마이그레이션 용이, 모든 데이터 액세스 코드를 별도의 레이어로 구성

구현 방법

https://www.tutorialspoint.com/design_pattern/data_access_object_pattern.htm


Service Locator

서비스 로케이터를 사용하여 서비스 및 구성 요소 조회를 구현하고 캡슐화합니다. 서비스 로케이터는 조회 메커니즘의 구현 세부 정보를 숨기고 관련 종속성을 캡슐화합니다.

Problem

균일한 방식으로 비즈니스 구성 요소와 서비스를 투명하게 찾고자 합니다.

Forces

  1. JNDI API를 사용하여 엔터프라이즈 Bean 및 JMS 구성요소와 같은 비즈니스 구성요소와 데이터 소스와 같은 서비스를 조회하고 사용하려고 합니다.
  2. J2EE 애플리케이션 클라이언트에 대한 조회 메커니즘 구현을 중앙 집중화하고 재사용하려고 합니다.
  3. 레지스트리 구현에 대한 공급업체 종속성을 캡슐화하고 클라이언트로부터 종속성과 복잡성을 숨기려고 합니다.
  4. 초기 컨텍스트 생성 및 서비스 조회와 관련된 성능 오버헤드를 피하려고 합니다.
  5. 핸들 오브젝트를 사용하여 이전에 액세스한 엔터프라이즈 Bean 인스턴스에 대한 연결을 재설정하려고 합니다.

+ JNDI는 Java Naming and Directory Interface API의 머리글자입니다. 디렉터리 서비스에서 제공하는 데이터 및 객체를 발견(discover)하고 참고(lookup) 하기 위한 자바 API.

 

Consequences

추상화된 복잡성, 클라이언트에게 균일한 서비스 액세스 제공, EJB 비즈니스 구성 요소 추가 촉진, 네트워크 성능 향상, 캐싱을 통해 클라이언트 성능 향상

구현 방법

https://www.tutorialspoint.com/design_pattern/service_locator_pattern.htm


Transfer Object

전송 개체를 사용하여 계층 전체에 여러 데이터 요소를 전달합니다.

Problem

계층을 통해 여러 데이터 요소를 전송하려고 합니다.

Forces

  1. 클라이언트가 다른 계층의 구성 요소에 액세스하여 데이터를 검색하고 업데이트하도록 하려고 합니다.
  2. 네트워크를 통한 원격 요청을 줄이려고 합니다.
  3. 높은 네트워크 트래픽이 있는 응용 프로그램으로 인한 네트워크 성능 저하를 방지하려고 합니다.

Consequences

네트워크 트래픽 감소, 원격 개체 및 원격 인터페이스 단순화, 더 적은 수의 원격 호출로 더 많은 데이터 전송, 코드 중복 감소

 

구현 방법

 

출처 : 자바 ORM 표준 JPA 프로그래밍 (김영한 지음)

 

JPA는 자바 진영의 ORM 기술 표준으로 애플리케이션과 JDBC 사이에서 동작하며 JPA를 구현한 대표 ORM 프레임워크는 하이버네이트이다. 

 

 

JPA는 지루하고 반복적인 CRUD SQL을 알아서 처리해줄 뿐만 아니라 객체 모델링과 관계형 데이터베이스 사이의 차이점도 해결해준다. CRUD SQL을 작성할 필요가 없고, 조회된 결과를 객체로 매핑하는 작업도 대부분 자동으로 처리해주다보니 코드의 양을 많이 줄일 수 있게 된다. 가장 중요한 것은 애플리케이션을 SQL이 아닌 객체 중심으로 개발하니 생산성과 유지보수가 확연이 좋아지고 테스트를 작성하기도 편리해진 점이다.

 

JPA를 사용했을 때의 이점은?

  • 반복적인 CRUD SQL을 작성하지 않아도 된다.
  • 조회된 결과 객체 매핑 자동으로 처리해준다.
  • 객체중심의 개발을 통해 생산성을 증가시킨다. 
  • 성능 최적화가 가능하다. (같은 트랜잭션 안에 같은 회원 2번 조회시 한번의 쿼리만 날라감)
  • 벤더독립성 (다른 DB사용해도 이를 JPA에 알려주기만 하면 된다)

 

SQL을 직접 다루게 되면 발생하는 문제점은?

자바로 작성한 애플리케이션은 JDBC API 를 사용해서 SQL을 DB에 전달하는데, 문제는 객체를 DB에 CRUD하려면 너무 많은 SQL과 JDBC API를 코드로 작성해야 한다는 점.

String sql = "SELECT ~~";
ResultSet rs = stmt.executeQuery(sql);
String id = rs.getString("MEMBER_ID");
String name = rs.getString("NAME");

Member member = new Member();
member.setMemeberId(id);
member.setName(name);

그리고 SQL에 의존적인 개발을 하게 되는데 예를 들어 회원 정보에 연락처(TEL)필드가 추가되었다고 가정해보자. 그렇게 되면 조회, 저장, 수정 등등의 쿼리를 일일이 수정해야 하는데 이처럼 SQL에 모든 것을 의존하는 상황에서는 개발자들이 엔티티를 신뢰하고 사용할 수 없다. 논리적으로 엔티티와 강한 의존관계를 지니게 되는 것은 진정한 의미의 계층 분할이라고 볼 수 없으며 SQL에 굉장히 의존적인 개발이라고 볼 수 있다. 

 

 

JPA를 사용하면 객체를 데이터베이스에 저장하고 관리할 때, 개발자가 직접 SQL을 작성하는 것이 아니라 JPA가 제공하는 API를 사용하면 된다. 그러면 JPA가 개발자 대신에 적절한 SQL을 생성해서 데이터베이스에 전달한다. 

 

패러다임의 불일치 해결

관계형 데이터베이스와 객체 지향 프로그래밍 사이엔 패러다임의 불일치 문제가 존재한다. 객체지향 프로그래밍은 추상화, 캡슐화, 정보은닉, 상속, 다형성 등 시스템의 복잡성을 제어할 수 있는 다양한 장치들을 제공한다. 하지만 관계형 데이터베이스는 데이터 중심으로 구조화되어 있고, 집합적인 사고를 요구하며 추상화, 상속, 다형성 같은 개념이 없다. 문제는 이 패러다임의 차이를 극복하려고 개발자가 너무 많은 시간과 코드를 소비한다는 점이다. 결국, 객체 모델링은 힘을 잃고 점점 데이터 중심의 모델로 변해가게 되는 것이다. 자바 진영에서는 오랜 기간 이 문제에 대한 숙제를 안고 있었고, 이 문제를 해결하기 위해 JPA라는 결과물을 만들어냈다. 

  • 상속
    • JPA를 사용하여 Item이란 테이블을 상속한 Album 객체를 저장해보자.
    • .persist(album) 이라고 입력하면 JPA는 Item과 Album 테이블에 INSERT 쿼리를 알아서 각각 날려준다.
    • 또, Item에 저장된 id로 검색한다고 하면 Album album = jpa.find(Album.class, id); 를 통해 JPA는 Item과 Album 두 테이블을 조인해서 필요한 데이터를 알아서 조회해준다. 
  • 연관관계
    • member.setTeam(team); // 회원과 팀 연관관계 설정
    • jpa.persist(member); // 회원과 연관관계 함께 저장
    • Team team = member.getTeat(); // 객체를 조회할 때 외래 키를 참조로 변환하는 일도 알아서 처리 
  • 객체 그래프 탐색
    • 지연로딩을 사용히야 객체를 불러오는 시점에 jpa는 데이터베이스에 테이블을 조회한다. 
    • . 으로 계속 연관된 객체들을 탐색해 나갈 수 있다. 

 

+통계 쿼리 처럼 복잡한 SQL은 어떻게 하나요?

JPA는 실시간 처리용 쿼리에 더욱 최적화되어 있기 때문에 복잡한 통계 쿼리는 SQL을 직접 작성하는 것이 더 쉬운 경우가 많다. 그래서 JPA가 제공하는 네이티브 SQL을 사용하거나 마이바티스나 스프링의 JdbcTemplate과 같은 SQL 매퍼 형태의 프레임워크를 사용하는 것이 좋다. 

 

+ Recent posts