IT 개발자들의 울타리

Java - 람다식

jddng — Sun, 10 Apr 2022 21:28:24 +0900

람다식 사용법
함수형 인터페이스
Variable Capture
메서드, 생성자 레퍼런스

람다식이란?

람다식은 JDK 1.8부터 추가된 것으로 메서드를 하나의 '식(expression)'으로 표현한 것이다. 람다식을 사용함으로써 코드가 간결해지고 또한 가독성이 증가되는 여러 이점등이 있다. 메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로 람다식을 익명함수(anonymous function)라고도 한다.

람다식의 특징

익명
- 보통의 메서드와 달리 이름이 없으므로 익명이라 표현한다.
- 구현해야 할 코드에 대한 걱정거리가 줄어듬
함수
- 람다는 메서드처럼 특정 클래스에 종속되지 않으므로 함수라고 불린다.
- 메서드처럼 파라미터 리스트, 바디, 반환형식, 가능한 예외 리스트를 포함한다.
전달
- 람다 표현식을 메서드 인수로 전달하거나 변수로 저장 할 수 있다.
간결성
- 익명 클래스처럼 많은 자질구레한 코드를 구현할 필요가 없다.

//람다식을 적용하기 전 코드
Comparator<String> s = new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
}

//람다식을 적용
Comparator<String> s = (String s1, String s2) -> s1.compareTo(s2));

람다식 사용법

// 메서드
반환타입 메서드이름(매개변수 선언){
	문장들
}
// ex
int max(int a, int b){
	return a> b ? a: b;
}


// 람다식
(매개변수 선언) -> {
	문장들
}
// ex
(int a, int b) -> { return a > b ? a: b; }

람다식 표현 방법

1. 반환값이 있는 메서드의 경우, return문 대식 '식(expression)'으로 대신 할 수 있다. 식의 연산결과가 자동적으로 반환 값이 되며 '문장(statement)'이 아닌 식이므로 끝에 세미콜론(;)을 붙이지 않는다.

(int a, int b) -> { return a > b ? a : b; } // return문
(int a, int b) -> a > b ? a : b             // 식(expression)

2. 람다식에 선언된 매개변수의 타입은 추론이 가능한 경우에 생략이 가능하다. 대부분의 경우 생략이 가능하며 람다식에 람다식에 반환타입이 없는 이유도 항상 추론이 가능하기 때문이다. 단, 두 매개변수 중 어느 하나의 타입만 생략하는 것은 허용되지 않는다.

(int a, int b) -> a > b ? a : b
(a, b) -> a > b ? a : b   // 매개변수의 타입 생략

3. 선언된 매개변수가 하나뿐인 경우에는 괄호()를 생략할 수 있다. 단, 매개변수의 타입이 있으면 생략할 수 없다.

a -> a * a      // Ok.
int a -> a * a  // error.
(int a) -> a * a // Ok.

4. 괄호{} 안의 문장이 하나일 때는 역시 괄호{}를 생략할 수 있다. 이 때 문장의 끝에 세미콜론(;)를 붙이지 않아야 한다

(String name, int i) -> {
    System.out.println(name + " = " + i);
}

(String name, int i) ->
    System.out.println(name + " = " + i)

5. 괄호{} 안의 문장이 return문일 경우 괄호{}를 생략할 수 없다.

(int a, int b) -> { return a > b ? a : b; } // return문 Ok.
(int a, int b) ->   return a > b ? a : b    // return문 error.
(int a, int b) ->   a > b ? a : b           // 식(expression)

함수형 인터페이스

함수형 인터페이스란 오직 하나의 추상 메서드만 가지는 인터페이스를 말한다. 람다식을 처음 접하면 메서드와 동등한 것으로 생각하게 되지만 사실 람다식은 익명 클래스의 객체와 동등하다.

람다식으로 정의된 익명 객체의 메서드

1. 함수형 인터페이스 구현

interface MyFunction{
	public abstract int max(int a, int b);
}

2. 위에서 구현한 인터페이스를 익명 클래스의 객체로 생성

MyFunction f = new MyFunction(){
	public int max(int a, int b){
		return a > b ? a: b;
	}
}

int big = f.max(5, 3);

3. 익명 객체를 람다식으로 대체

MyFunction f = (int a, int b) -> a > b ? a : b;
int big = f.max(5, 3);


// 다양한 익명 객체의 메서드 사용 방법
MyFunction add = (int a, int b) -> {return a + b; };
MyFunction add1 = (int a, int b) -> a + b;
MyFunction add2 = Integer::sum;

이처럼 MyFunction 인터페이스를 구현한 익명 객체를 람다식으로 대체 가능한 이유는 람다식도 실제로는 익명 객체이고 MyFunction 인터페이스를 구현한 익명 객체의 메서드 max()와 람다식의 매개변수의 타입과 개수 그리고 반환값이 일치하기 때문에 가능하다.

하나의 메서드가 선언된 인터페이스를 정의하여 람다식을 다루면 기존의 자바 규칙을 어기지 않으면서 자연스럽게 다룰 수 있다. 그래서 인터페이스를 통해 람다식을 다루기로 결정했고, 람다식을 다루기 위한 인터페이스를 ‘함수형 인터페이스(functional interface)’라고 부른다.

참고
@FunctionalInterface

람다식과 인터페이스의 메서드가 1:1로 연결될 수 있기 떄문에 함수형 인터페이스는 오직 하나의 추상 메서드만 정의되어 있어야 한다는 제약이 있다. 이러한 제약조건을 잘 지켰는지 컴파일러가 확인하도록 @Functionalinterface를 사용하는 것이 좋다. (static 메서드와 default 메서드의 개수는 제약이 없다.)

Variable Capture

람다식에서 외부 지역변수를 참조하는 행위를 Lambda Capturing이라고 한다. 람다에서 접근가능한 변수는 아래와 같이 세가지 종류가 있다.

지역 변수
static 변수
인스턴스 변수

람다식에서 외부 지역변수를 참조할 때 위에서 지역변수만 변경이 불가능하고 나머지 변수들은 읽기 및 쓰기가 가능하다. 람다는 지역 변수가 존재하는 스택에 직접 접근하지 않고, 지역 변수를 자신의 스택에 복사한다. 따라서 각각의 쓰레드마다 고유한 스택을 갖고 있어서 지역 변수가 존재하는 쓰레드가 사라져도 람다는 복사된 값을 참조하면서 에러가 발생하지 않는다.

하지만 멀티 쓰레드 환경에서는 문제가 발생한다. 여러 개의 쓰레드에서 람다식을 사용하면서 람다 캡처링이 계속 발생하는데 이 때 외부 변수 값의 불변성을 보장하지 못하면서 동기화(sync) 문제가 발생한다. 이러한 문제로 인해 지역변수는 final, Effectively Final 제약조건을 갖게 된다.

인스턴스 변수나 static 변수는 스택 영역이 아닌 힙 영역에 위치하고, 힙 영역은 모든 쓰레드가 공유하는 메모리 영역이기 때문에 값의 쓰기가 발생하여도 별 문제가 없게 된다.

메서드, 생성자 레퍼런스

메서드 레퍼런스

람다식으로 메서드를 간결하게 표현할 수 있는데, 놀랍게도 람다식을 더욱 간결하게 표현할 수 있는 방법이 있다. 람다식이 하나의 메서드만 호출하는 경우에 ‘메서드 참조(method reference)’라는 방법으로 간략히 할 수 있다.

메서드 참조하는 방법

스태틱 메소드 참조 → 타입::스태틱 메소드
특정 객체의 인스턴스 메소드 참조 → 객체 래퍼런스::인스턴스 메소드
임의 객체의 인스턴스 메소드 참조 → 타입::인스턴스 메소드
생성자 참조 → 타입::new

BiFunction<String, String, Boolean> f = (s1, s2) -> s1.equals(s2);

위 람다식을 메서드 참조로 변경하면 다음과 같다.

BiFunction<String, String, Boolean> f = String::equals;

s1과 s2를 생략하고나면 equals만 남는데, 두 개의 String을 받아서 Boolean으로 반환하는 equals라는 이름의 메서드는 다른 클래스에도 존재할 수 있기 때문에 equals 앞에 클래스 이름이 반드시 필요하다.

static 메서드 참조

메서드 참조는 static 메서드를 직접적으로 가리킬 수 있다.

클래스이름::메서드이름
(매개변수) -> Class.staticMethod(매개변수)

String::valueOf
str -> String.valueOf(str)

인스턴스 메서드 참조

클래스이름::메서드이름
(obj, 매개변수) -> obj.instanceMethod(매개변수)

String::length
(value) -> value.length();

특정 객체 인스턴스 메서드 참조

특정 인스턴스의 메서드를 참조, 클래스 이름이 아닌 인스턴스 명을 넣는다

obj::instanceMethod
(매개변수) -> obj.instanceMethod(매개변수)

object::toString
() -> object.toString()

생성자의 메서드 참조

생성자를 호출하는 람다식도 메서드 참조로 변환할 수 있다.

Supplier<MyClass> s = () -> new MyClass();
Supplier<MyClass> s = MyClass::new;

매개변수가 필요한 생성자라면, 매개변수의 개수에 따라 알맞은 함수형 인터페이스를 사용하면 된다. 필요에 따라 함수형 인터페이스를 새로 정의해야 한다.

Function<Integer, MyClass> f = (i) -> new MyClass(i);
Function<Integer, MyClass> f2 = MyClass::new;

Java - 제네릭(Generics)

jddng — Sun, 3 Apr 2022 22:26:15 +0900

제네릭(Generics)

제네릭 사용법
제네릭 - 바운디드 타입
제네릭 - 와일드카드
제네릭 메서드

제네릭(Generics)란?

지네릭스는 다양한 타입의 객체를 다루는 메서드나 컬렉션 클래스에 컴파일 시의 타입 체크를 해주는 기능이다. 객체의 타입을 컴파일 시에 체크하기 때문에 객체의 타입 안정성을 높이고 형 변환의 번거로움을 줄일 수 있다.

- 타입 안정성

의도하지 않은 타입의 객체가 저장되는 것을 막고, 저장된 객체를 꺼내올 때 원래의 타입과 다른 타입으로 잘못 형 변환되어 발생할 수 있는 오류를 줄여준다.

- 제네릭을 사용하는 이유

제네릭 타입을 사용함으로써 잘못된 타입이 사용될 수 있는 문제를 컴파일 과정에서 제거할 수 있기 때문
자바 컴파일러는 코드에서 잘못 사용된 타입 때문에 발생하는 문제점을 제거하기 위해 제네릭 코드에 대해 강한 타입 체크를 한다.
실행 시 타입 에러가 나는 것보다 컴파일 시에 미리 타입을 강하게 체크하여 에러를 사전에 방지할 수 있다.
제네릭 코드를 사용하면 타입을 국한하기 때문에 요소를 찾아올 때 타입 변환을 할 필요가 없어 프로그램 성능이 향상되는 효과를 얻을 수 있다.

제네릭 사용법

- 제네릭 클래스 선언

public class Box<T> {

    private T type;
    
    public void set(T type) { this.type = type }
    public T get() { return type; }
}

T를 타입 변수(Type variable) 이라 한다.
타입 변수는 상황에 맞는 의미 있는 문자를 선택하여 사용할 수 있다.
- T : Type, E : Element, K : Key, V : Value
과거에는 Object로 다양한 종류의 타입을 다룰 때 사용했지만 타입 체크 시 문제가 발생했다.

- 제네릭 클래스 사용

Box<String> box = new Box();
// 타입 변수에 String을 전달하였으므로 아래와 같다.
public class Box {

    private String type;
    
    public void set(String type) { this.type = type }
    public String get() { return type; }
}

Box<int> box = new box();
// 타입 변수에 int를 전달하였으므로 아래와 같다.
public class Box {

    private int type;
    
    public void set(int type) { this.type = type }
    public int get() { return type; }
}

- 지네릭스의 제한

모든 객체에 대해 동일하게 동작해야 하는 static멤버에 타입 변수 T를 사용할 수 없다.
지네릭 타입의 배열을 생성할 수 없다.(컴파일러가 컴파일 시점에 타입 T 가 무엇인지 알아야 하기 때문)

제네릭 주요 개념 - 바운디드 타입(Bounded Type)

바운디드 타입은 특정 타입의 서브 타입으로 제한한다.
클래스나 인터페이스 설계할 때 가장 흔하게 사용할 정도로 많이 볼 수 있는 개념이다.

public class Box<T extends S> {

	...
}

타입 변수 T는 S의 서브 타입만 허용한다.

제네릭 주요 개념 - 와일드카드(WildCard)

- Unbounded WildCard

? 와 같은 형태로 물음표만 가지고 정의한다.( ex. List<?> )
내부적으로 Object로 정의되어 있기 때문에 모든 타입의 인자를 받을 수 있다.
타입 파라미터에 의존하지 않는 메서드만을 사용하거나 Object 메서드에서 제공하는 기능으로
충분한 경우 사용한다.
Object 클래스에서 제공되는 기능을 이용하여 구현하는 메서드에서 사용
타입 파라미터에 의존적이지 않는 일반 클래스의 메서드를 사용하는 경우에 사용
ex) List, clear, List, size 등

- Upper Bounded Wildcard

특정 클래스의 자식 클래스만을 인자로 받을 때 사용한다.
사용할 수 있는 기능은 특정 클래스에서 정의된 기능만 사용할 수 있다.
ex) List<? extends Skill>

- Lower Bounded Wildcard

특정 클래스의 부모 클래스만을 인자로 받을 수 있다.
ex) List<? supper Skill>

지네릭 메서드

메서드 선언부에 지네릭 타입이 선언된 메서드를 지네릭 메서드라 한다.
static 멤버에는 타입 매개변수를 사용할 수 없지만, 메서드에는 사용이 가능하다.
지네릭 타입의 선언 위치는 반환 타입 바로 앞이다.

static <T> void sort(List<T> list, Comparator<? super T> c)

제네릭 클래스에 정의된 타입 매개변수와 제네릭 메서드에 정의된 타입 매개변수는
서로 다른 타입 변수다.(같은 타입 문자 T를 사용해도 같은 타입 변수가 아니다)

class FruitBox<T>{
	...
	static <T> void sort(List<T> list, Compatrator<? super T> c){
		...
	}
}

예시

public static void printAll(
			ArrayList<? extends Product> list,
			ArrayList<? extends Product> list2){
    
	for(Unit u : list){
		System.out.println(u);
	}
}


// 지네릭 메서드로 변경

public static void printAll(
			ArrayList<? extends Product> list,
			ArrayList<? extends Product> list2){
            
	for(Unit u : list){
		System.out.println(u);
	}
}

Java - Input과 Output(I/O)

jddng — Sun, 27 Mar 2022 23:13:29 +0900

Input과 Output

스트림(Stream) / 버퍼(Buffer) / 채널(Channel) 기반의 I/O
InputStream과 OutputStream
Byte와 Character 스트림
표준 스트림(System.in, System.out, System.err)
파일 읽고 쓰기

I/O(Input/Output)

I/O 란?

I/O란 Input과 Output의 약자로 입력과 출력, 간단히 입출력이라 한다. I/O를 이용하여 시스템은 컴퓨터 내부 또는 외부 장치와 프로그램간의 데이터를 주고 받는 것을 말한다.

스트림(stream)

스트림이란 데이터를 운반하는데 사용되는 연결 통로이다.
자바에서 데이터를 전달하고자 할 때, 두 대상을 연결하고 데이터를 전송할 수 있는
통로가 필요한데 이것을 스트림(stream)이라 한다.
람다와 스트림에서 얘기하는 스트림과 같은 용어를 사용하지만, 다른 개념이다.
스트림은 단방향통신만 가능하다.
하나의 스트림으로 입력과 출력을 동시에 처리할 수 없다.
(입력을 위한 입력 스트림, 출력을 위한 출력 스트림 2개가 필요)
Queue와 같은 FIFO 구조로 되어있다.

버퍼(Buffer)

데이터를 임시 저장하는 공간을 의미
바이트 배열을 사용하여 일정량의 데이터 크기만큼 모아서 전송
시스템 콜의 횟수가 줄어들어 성능상 이점이 있다.

채널(Channel)

채널은 스트림과 달리 양방향으로 입력과 출력이 가능하다.
비동기적으로 입출력이 가능

InputStream과 OutputStream

바이트 기반 스트림의 최상위 클래스인 추상 클래스
모든 byteStrean의 조상

표준 입출력

System.in : 표준 입력 스트림, InputStream
System.out : 표준 출력 스트림, PrintStream
System.err : 표준 오류 스트림, PrintStream

참고 사이트

I/O (notion.so)

I/O

WhiteShip Java Study 시즌 1

www.notion.so

Querydsl - Spring Data JPA에서 제공하는 페이징 활용

jddng — Sat, 26 Mar 2022 22:10:33 +0900

Spring Data JPA에서 제공하는 페이징 활용

QueryDSl에서 페이징 사용
Count 쿼리 최적화
Controller 개발

QueryDSL에서 페이징 사용

1. 커스텀 인터페이스에 메서드 추가

public interface MemberRepositoryCustom {
    List<MemberTeamDto> search(MemberSearchCondition condition);
    Page<MemberTeamDto> searchPage(MemberSearchCondition condition, Pageable pageable);	// (1)
}

(1) : Pageable 페이징에 필요한 정보 전달(offset, limit)

2. 커스텀 인터페이스 구현체에서 메서드 구현

@Override
public Page<MemberTeamDto> searchPage(MemberSearchCondition condition, Pageable pageable) {
    List<MemberTeamDto> content = queryFactory	// (1)
            .select(new QMemberTeamDto(
                    member.id,
                    member.username,
                    member.age,
                    team.id,
                    team.name))
            .from(member)
            .leftJoin(member.team, team)
            .where(
                    usernameEq(condition.getUsername()),
                    teamNameEq(condition.getTeamName()),
                    ageGoe(condition.getAgeGoe()),
                    ageLoe(condition.getAgeLoe())
            )
            .offset(pageable.getOffset())   // (2) 페이지 번호
            .limit(pageable.getPageSize())  // (3) 페이지 사이즈
            .fetch();

    Long count = queryFactory		// (4) 
            .select(member.count())
            .from(member)
//                .leftJoin(member.team, team)		(5) 검색조건 최적화
            .where(
                    usernameEq(condition.getUsername()),
                    teamNameEq(condition.getTeamName()),
                    ageGoe(condition.getAgeGoe()),
                    ageLoe(condition.getAgeLoe())
            )
            .fetchOne();

    return new PageImpl<>(content, pageable, count);	// (6) PageImpl 반환
}

(1) : 페이징을 사용한 데이터 조회
(2) : 페이지 offset(0부터 시작)
(3) : 페이지 limit(페이지 사이즈)
(4) : count 조회
(5) : 검색조건 최적화(성능 최적화), count에 필요없는 leftJoin 제거 후 count
(6) : 페이징과 관련된 정보 반환

3. 코드 최적화

@Override
public Page<MemberTeamDto> searchPageComplex(MemberSearchCondition condition, Pageable pageable) {
    List<MemberTeamDto> content = getMemberTeamDtos(condition, pageable);

    Long count = getCount(condition);

    return new PageImpl<>(content, pageable, count);
}

private Long getCount(MemberSearchCondition condition) {
    Long count = queryFactory
            .select(member.count())
            .from(member)
//                .leftJoin(member.team, team)
            .where(
                    usernameEq(condition.getUsername()),
                    teamNameEq(condition.getTeamName()),
                    ageGoe(condition.getAgeGoe()),
                    ageLoe(condition.getAgeLoe())
            )
            .fetchOne();
    return count;
}

private List<MemberTeamDto> getMemberTeamDtos(MemberSearchCondition condition, Pageable pageable) {
    List<MemberTeamDto> content = queryFactory
            .select(new QMemberTeamDto(
                    member.id,
                    member.username,
                    member.age,
                    team.id,
                    team.name))
            .from(member)
            .leftJoin(member.team, team)
            .where(
                    usernameEq(condition.getUsername()),
                    teamNameEq(condition.getTeamName()),
                    ageGoe(condition.getAgeGoe()),
                    ageLoe(condition.getAgeLoe())
            )
            .offset(pageable.getOffset())   // 페이지 번호
            .limit(pageable.getPageSize())  // 페이지 사이즈
            .fetch();
    return content;
}

참고로 fetchResult를 사용하면 페이징 처리한 데이터와 count를 같이 조회할 수 있다. 하지만 fetchResult를 사용하면 count 쿼리 부분에서 문제가 된다. count에 상관없는 테이블을 조회하는 등의 문제로 성능 이슈가 발생한다. 따라서 현재 Querydsl에서는 fetchResult를 사용하지 않도록 deprecate 된 상태이므로 위에서 작성한 예시 코드처럼 페이징으로 데이터 조회하는 쿼리와 count를 구하는 쿼리를 따로 작성하는 것을 권장한다.

4. 테스트 코드

@Test
@DisplayName("Page 테스트")
public void searchWithPage2() {
    Team teamA = new Team("teamA");
    Team teamB = new Team("teamB");

    em.persist(teamA);
    em.persist(teamB);

    Member member1 = new Member("member1", 10, teamA);
    Member member2 = new Member("member2", 20, teamA);
    Member member3 = new Member("member3", 30, teamB);
    Member member4 = new Member("member4", 40, teamB);

    em.persist(member1);
    em.persist(member2);
    em.persist(member3);
    em.persist(member4);

    MemberSearchCondition condition = new MemberSearchCondition();
    PageRequest pageRequest = PageRequest.of(0, 3);		// (1)


    Page<MemberTeamDto> results = memberRepository.searchPageComplex(condition, pageRequest);	// (2)

    assertThat(results.getSize()).isEqualTo(3);
    assertThat(results.getContent()).extracting("username").containsExactly("member1", "member2", "member3");

}

(1) : 페이징에 사용할 page, size 데이터를 갖는 PageRequest 생성
(2) : 페이징 결과 반환

Count 쿼리 최적화

PageableExecutionUtils를 사용하면 Count 쿼리 최적화할 수 있다.
내부적으로 Count 쿼리가 필요없으면 조회해오지 않는다
조건 : 페이지 시작이면서 컨텐츠 사이즈가 페이지 사이즈보다 작을 때
마지막 페이지 일 때(offset + 컨텐츠 사이즈를 더해서 전체 사이즈를 구함)

@Override
public Page<MemberTeamDto> searchPageComplex(MemberSearchCondition condition, Pageable pageable) {
    List<MemberTeamDto> content = getMemberTeamDtos(condition, pageable);

    JPAQuery<Long> countQuery = getCount(condition);

    return PageableExecutionUtils.getPage(content, pageable, () -> countQuery.fetchOne()); // (1)
//        return new PageImpl<>(content, pageable, count);
}

private JPAQuery<Long> getCount(MemberSearchCondition condition) {
    JPAQuery<Long> countQuery = queryFactory
            .select(member.count())
            .from(member)
//                .leftJoin(member.team, team)
            .where(
                    usernameEq(condition.getUsername()),
                    teamNameEq(condition.getTeamName()),
                    ageGoe(condition.getAgeGoe()),
                    ageLoe(condition.getAgeLoe())
            );
    return countQuery;	// (2)
}

(1) : PageableExecutionUtils가 내부적으로 count 쿼리가 필요없으면 조회해오지 않는다.
(2) : JPQL 쿼리 리턴

Controller 개발

1. 페이징처리를 위한 컨트롤러 구현

@GetMapping("/v2/members")
public Page<MemberTeamDto> searchMemberV2(MemberSearchCondition condition, Pageable pageable) {
    return memberRepository.searchPageComplex(condition, pageable); // 바인딩 된다 page, size, sort
}

2. Postman 요청

참고로 파라미터 없이 요청하면 기본 설정으로 Pageable에 page와 size가 바인딩된다.(page=0, size=20)

http://localhost:8080/v2/members

    /* select
        member1.id,
        member1.username,
        member1.age,
        team.id,
        team.name 
    from
        Member member1   
    left join
        member1.team as team */ select
            member0_.member_id as col_0_0_,
            member0_.username as col_1_0_,
            member0_.age as col_2_0_,
            team1_.team_id as col_3_0_,
            team1_.name as col_4_0_ 
        from
            member member0_ 
        left outer join
            team team1_ 
                on member0_.team_id=team1_.team_id fetch first ? rows only

...

    /* select
        count(member1) 
    from
        Member member1 */ select
            count(member0_.member_id) as col_0_0_ 
        from
            member member0_

http://localhost:8080/v2/members?page=1&size=5

    /* select
        member1.id,
        member1.username,
        member1.age,
        team.id,
        team.name 
    from
        Member member1   
    left join
        member1.team as team */ select
            member0_.member_id as col_0_0_,
            member0_.username as col_1_0_,
            member0_.age as col_2_0_,
            team1_.team_id as col_3_0_,
            team1_.name as col_4_0_ 
        from
            member member0_ 
        left outer join
            team team1_ 
                on member0_.team_id=team1_.team_id offset ? rows fetch next ? rows only
    
...
    
    
    /* select
        count(member1) 
    from
        Member member1 */ select
            count(member0_.member_id) as col_0_0_ 
        from
            member member0_

http://localhost:8080/v2/members?page=0&size=200

    /* select
        member1.id,
        member1.username,
        member1.age,
        team.id,
        team.name 
    from
        Member member1   
    left join
        member1.team as team */ select
            member0_.member_id as col_0_0_,
            member0_.username as col_1_0_,
            member0_.age as col_2_0_,
            team1_.team_id as col_3_0_,
            team1_.name as col_4_0_ 
        from
            member member0_ 
        left outer join
            team team1_ 
                on member0_.team_id=team1_.team_id fetch first ? rows only

count 쿼리로 조회해오지 않는다.

Querydsl - Spring Data JPA와 QueryDSL

jddng — Sat, 26 Mar 2022 21:10:09 +0900

Spring Data JPA와 QueryDSL

Spring Data JPA를 사용할 때 QueryDSL을 사용하기 위해선 사용자 정의 리포지토리와 구현체를 만들어 상속받아야 한다.

QueryDSL을 사용하기 위한 순서

JpaRepository를 상속받는 인터페이스 생성

Spring Data JPA에서 제공하는 JpaRepository 인터페이스를 상속받는 인터페이스 생성한다.

public interface MemberRepository extends JpaRepository<Member, Long> {

}

사용자 정의 인터페이스 생성

QueryDSL을 사용하기 위해 필요한 인터페이스 생성

public interface MemberRepositoryCustom {
    List<MemberTeamDto> search(MemberSearchCondition condition);	// (1)
}

(1) : QueryDSL로 구현할 메서드 작성

사용자 정의 인터페이스 구현체 생성

사용자 정의 인터페이스의 메서드를 오버라이딩하여 QueryDSL 사용

@RequiredArgsConstructor
public class MemberRepositoryImpl implements MemberRepositoryCustom{

    private final JPAQueryFactory queryFactory;	// (1)

    @Override
    public List<MemberTeamDto> search(MemberSearchCondition condition) {	// (2)
        return queryFactory
                .select(new QMemberTeamDto(
                        member.id,
                        member.username,
                        member.age,
                        team.id,
                        team.name))
                .from(member)
                .leftJoin(member.team, team)
                .where(
                        usernameEq(condition.getUsername()),
                        teamNameEq(condition.getTeamName()),
                        ageGoe(condition.getAgeGoe()),
                        ageLoe(condition.getAgeLoe())
                )
                .fetch();
    }

    private BooleanExpression usernameEq(String username) {
        return StringUtils.hasText(username) ? member.username.eq(username) : null;
    }

    private BooleanExpression teamNameEq(String teamName) {
        return StringUtils.hasText(teamName) ? team.name.eq(teamName) : null;
    }

    private BooleanExpression ageGoe(Integer ageGoe) {
        return ageGoe != null ? member.age.goe(ageGoe) : null;
    }

    private BooleanExpression ageLoe(Integer ageLoe) {
        return ageLoe != null ? member.age.loe(ageLoe) : null;
    }
}

(1) : QueryDSL을 사용하기위한 팩토리 클래스 주입
(2) : 인터페이스 메서드를 오버라이드하여 동적 쿼리 구현

Spring Data Repository에 사용자 정의 인터페이스 상속

public interface MemberRepository extends JpaRepository<Member, Long>, MemberRepositoryCustom {

}

사용자 정의 리포지토리 동작 테스트

@Autowired
EntityManager em;

@Autowired
MemberRepository memberRepository;

@Test
@DisplayName("사용자 정의 리포지토리 테스트")
public void searchTest2() {
    Team teamA = new Team("teamA");
    Team teamB = new Team("teamB");

    em.persist(teamA);
    em.persist(teamB);

    Member member1 = new Member("member1", 10, teamA);
    Member member2 = new Member("member2", 20, teamA);
    Member member3 = new Member("member3", 30, teamB);
    Member member4 = new Member("member4", 40, teamB);

    em.persist(member1);
    em.persist(member2);
    em.persist(member3);
    em.persist(member4);

    MemberSearchCondition condition = new MemberSearchCondition();
    condition.setAgeGoe(35);
    condition.setAgeLoe(40);
    condition.setTeamName("teamB");

    List<MemberTeamDto> results = memberRepository.search(condition);	// (1)

    assertThat(results).extracting("username").containsExactly("member4");

}

사용자 정의 리포지토리 메서드 사용

Querydsl - where절을 이용한 동적 쿼리와 성능 최적화

jddng — Sat, 26 Mar 2022 18:19:05 +0900

where절을 이용한 동적 쿼리와 성능 최적화

Member와 Team을 동적 쿼리를 이용하여 해당 조건에 맞는 데이터를 가져와 보자

1. 성능 최적화를 위해 DB에서 필요한 데이터만 가져올 수 있는 DTO를 생성한다.

@Data
public class MemberTeamDto {

    private Long memberId;
    private String username;
    private int age;
    private Long teamId;
    private String teamName;

    public MemberTeamDto() {
    }

    @QueryProjection	// (1)
    public MemberTeamDto(Long memberId, String username, int age, Long teamId, String teamName) {
        this.memberId = memberId;
        this.username = username;
        this.age = age;
        this.teamId = teamId;
        this.teamName = teamName;
    }
}

(1) : Q-Type을 만들기위한 어노테이션

2. 동적 쿼리에 사용할 검색 조건 클래스 생성

@Data
public class MemberSearchCondition {

    // 회원명, 팀명, 나이(ageGoe, ageLoe)

    private String username;
    private String teamName;
    private Integer ageGoe;
    private Integer ageLoe;
}

3. Repository에 Where절을 이용한 동적 쿼리 메서드 구현

public List<MemberTeamDto> searchByWhere(MemberSearchCondition condition) {
    return queryFactory
            .select(new QMemberTeamDto(
                    member.id,
                    member.username,
                    member.age,
                    team.id,
                    team.name))
            .from(member)
            .leftJoin(member.team, team)
            .where(
                    usernameEq(condition.getUsername()),	// (1)
                    teamNameEq(condition.getTeamName()),
                    ageGoe(condition.getAgeGoe()),
                    ageLoe(condition.getAgeLoe())
            )
            .fetch();
}
//  BooleanExpression은 and, or 을 조합해서 새로운 BooleanExpression을 만들 수 있다.
//  또한, 결과 값이 null일 경우 무시하기 때문에 npe를 방지할 수 있다
private BooleanExpression usernameEq(String username) {	// (2)
    return StringUtils.hasText(username) ? member.username.eq(username) : null;
}

private BooleanExpression teamNameEq(String teamName) {	// (3)
    return StringUtils.hasText(teamName) ? team.name.eq(teamName) : null;
}

private BooleanExpression ageGoe(Integer ageGoe) {	// (4)
    return ageGoe != null ? member.age.goe(ageGoe) : null;
}

private BooleanExpression ageLoe(Integer ageLoe) {	// (5)
    return ageLoe != null ? member.age.loe(ageLoe) : null;
}

(1) : where절의 특징으로 콤마(,)를 사용하면 and 조건으로 처리 된다. 만약 null이면 해당 조건은 제외 된다.
(2) : username의 값이 존재하면 조건 추가, null or 빈문자("")일 경우 null 반환
(3) : teamName의 값이 존재하면 조건 추가, null or 빈문자("")일 경우 null 반환
(4) : ageGoe의 값이 존재하면 조건 추가, null 일 경우 null 반환
(5) : ageLoe의 값이 존재하면 조건 추가, null 일 경우 null 반환

(2), (3), (4), (5)을 보면 반환 타입을 BooleanExpression을 사용한 것을 볼 수 있는데 Predicate를 사용하지 않은 이유는 BooleanExpression은 and, or을 조합하여 새로운 BooleanExpression을 만들 때 결과 값이 null일 경우 해당 조건은 제외시켜 NullPointrException을 방지할 수 있기 때문에 BooleanExpression을 사용한다.

4. 조회 테스트

@Test
public void searchTest2() {
    Team teamA = new Team("teamA");
    Team teamB = new Team("teamB");

    em.persist(teamA);
    em.persist(teamB);

    Member member1 = new Member("member1", 10, teamA);
    Member member2 = new Member("member2", 20, teamA);
    Member member3 = new Member("member3", 30, teamB);
    Member member4 = new Member("member4", 40, teamB);

    em.persist(member1);
    em.persist(member2);
    em.persist(member3);
    em.persist(member4);

    MemberSearchCondition condition = new MemberSearchCondition();
    condition.setAgeGoe(35);
    condition.setAgeLoe(40);
    condition.setTeamName("teamB");

    List<MemberTeamDto> results = memberQuerydslRepository.searchByWhere(condition);


}

Querydsl 쿼리와 JPQL 쿼리

    /* select
        member1.id,
        member1.username,
        member1.age,
        team.id,
        team.name 
    from
        Member member1   
    left join
        member1.team as team 
    where
        team.name = ?1 
        and member1.age >= ?2 
        and member1.age <= ?3 */ select
            member0_.member_id as col_0_0_,
            member0_.username as col_1_0_,
            member0_.age as col_2_0_,
            team1_.team_id as col_3_0_,
            team1_.name as col_4_0_ 
        from
            member member0_ 
        left outer join
            team team1_ 
                on member0_.team_id=team1_.team_id 
        where
            team1_.name=? 
            and member0_.age>=? 
            and member0_.age<=?

위 쿼리를 보면 MemberSearchCondition의 username값이 null이므로 검색조건에 제외된 것을 볼 수 있다. 이렇듯 null

값이면 검색조건에 제외, null이 아닌 데이터 값이 있을 경우 검색 조건에 추가되는 동적 쿼리를 사용할 수 있다.

조회 API 컨트롤러 예시

@RestController
@RequiredArgsConstructor
public class MemberController {

    private final MemberQuerydslRepository memberQuerydslRepository;
    
    @GetMapping("/v1/members")
    public List<MemberTeamDto> searchMemberV1(MemberSearchCondition condition){
        return memberJpaRepository.search(condition);
    }
}

요청 예시

localhost:8080/v1/members?teamName=team&ageGoe=31&ageLoe=35

파라미터로 검색조건을 넘겨주면 된다.

참고
BooleanBuilder와 BooleanExpression

[Querydsl] 다이나믹 쿼리 사용하기 (tistory.com)

Querydsl - BooleanBuilder를 사용한 동적 쿼리와 성능 최적화

jddng — Sat, 26 Mar 2022 17:16:13 +0900

BooleanBuilder를 사용한 동적 쿼리와 성능 최적화

Member와 Team을 동적 쿼리를 이용하여 해당 조건에 맞는 데이터를 가져와 보자.

1. 성능 최적화를 위해 DB에서 필요한 데이터만 가져올 수 있는 DTO를 생성한다.

@Data
public class MemberTeamDto {

    private Long memberId;
    private String username;
    private int age;
    private Long teamId;
    private String teamName;

    public MemberTeamDto() {
    }

    @QueryProjection	// (1)
    public MemberTeamDto(Long memberId, String username, int age, Long teamId, String teamName) {
        this.memberId = memberId;
        this.username = username;
        this.age = age;
        this.teamId = teamId;
        this.teamName = teamName;
    }
}

(1) : Q-Type을 만들기위한 어노테이션

2. 동적 쿼리에 사용할 검색 조건 클래스 생성

@Data
public class MemberSearchCondition {

    // 회원명, 팀명, 나이(ageGoe, ageLoe)

    private String username;
    private String teamName;
    private Integer ageGoe;
    private Integer ageLoe;
}

3. Repository에 Builder를 이용한 동적 쿼리 메서드 구현

public List<MemberTeamDto> searchByBuilder(MemberSearchCondition condition) {

    BooleanBuilder builder = new BooleanBuilder();
    if (StringUtils.hasText(condition.getUsername())) {	// (1)
        builder.and(member.username.eq(condition.getUsername()));
    }
    if (StringUtils.hasText(condition.getTeamName())) {	// (2)
        builder.and(team.name.eq(condition.getTeamName()));
    }
    if (condition.getAgeGoe() != null) {	// (3)
        builder.and(member.age.goe(condition.getAgeGoe()));
    }
    if (condition.getAgeLoe() != null) {	// (4)
        builder.and(member.age.loe(condition.getAgeLoe()));
    }


    return queryFactory
            .select(new QMemberTeamDto(
                    member.id.as("memberId"),
                    member.username,
                    member.age,
                    team.id.as("teamID"),
                    team.name.as("teamName")))
            .from(member)
            .leftJoin(member.team, team)
            .where(builder)		//(5)
            .fetch();
}

(1) : StringUtils.hasText를 이용하여 null과 빈문자("") 체크 (null or "" 이면 false)
(2) : StringUtils.hasText를 이용하여 null과 빈문자("") 체크 (null or "" 이면 false)
(3) : ageGoe이 null인지 체크
(4) : ageLoe이 null 인지 체크
(1), (2), (3), (4) : true 일 경우 builder에 and조건 추가
(5) : where문에 builder 적용

4. 조회 테스트

@Test
public void searchTest() {
    Team teamA = new Team("teamA");
    Team teamB = new Team("teamB");

    em.persist(teamA);
    em.persist(teamB);

    Member member1 = new Member("member1", 10, teamA);
    Member member2 = new Member("member2", 20, teamA);
    Member member3 = new Member("member3", 30, teamB);
    Member member4 = new Member("member4", 40, teamB);

    em.persist(member1);
    em.persist(member2);
    em.persist(member3);
    em.persist(member4);

    MemberSearchCondition condition = new MemberSearchCondition();
    condition.setAgeGoe(35);
    condition.setAgeLoe(40);
    condition.setTeamName("teamB");

    List<MemberTeamDto> results = memberQuerydslRepository.searchByBuilder(condition);

    assertThat(results).extracting("username").containsExactly("member4");

}

Querydsl 쿼리와 JPQL 쿼리

    /* select
        member1.id as memberId,
        member1.username,
        member1.age,
        team.id as teamID,
        team.name as teamName 
    from
        Member member1   
    left join
        member1.team as team 
    where
        team.name = ?1 
        and member1.age >= ?2 
        and member1.age <= ?3 */ select
            member0_.member_id as col_0_0_,
            member0_.username as col_1_0_,
            member0_.age as col_2_0_,
            team1_.team_id as col_3_0_,
            team1_.name as col_4_0_ 
        from
            member member0_ 
        left outer join
            team team1_ 
                on member0_.team_id=team1_.team_id 
        where
            team1_.name=? 
            and member0_.age>=? 
            and member0_.age<=?

위 쿼리를 보면 MemberSearchCondition의 username값이 null이므로 검색조건에 제외된 것을 볼 수 있다. 이렇듯 null

값이면 검색조건에 제외, null이 아닌 데이터 값이 있을 경우 검색 조건에 추가되는 동적 쿼리를 사용할 수 있다.

만약 MemberSearchCondition의 모든 필드가 null일 경우 해당 Querydsl의 쿼리와 JPQL 쿼리는 다음과 같다.

    /* select
        member1.id as memberId,
        member1.username,
        member1.age,
        team.id as teamID,
        team.name as teamName 
    from
        Member member1   
    left join
        member1.team as team */ select
            member0_.member_id as col_0_0_,
            member0_.username as col_1_0_,
            member0_.age as col_2_0_,
            team1_.team_id as col_3_0_,
            team1_.name as col_4_0_ 
        from
            member member0_ 
        left outer join
            team team1_ 
                on member0_.team_id=team1_.team_id

위 쿼리를 보면 알수있듯이 MemberSearchCondition의 모든 필드가 null이므로 검색 조건이 모두 제외된 것을 볼 수 있다.

Querydsl - Repository에서 Querydsl 사용하기

jddng — Sat, 26 Mar 2022 16:21:14 +0900

Repository에서 Querydsl 사용하기

Querydsl을 사용하기 위해서는 JPAQueryFactory가 필요한데 Qeurydsl을 사용하는 Repository에서 주입받을려면 불편하다. 따라서 Config를 생성하여 JPAQueryFactory를 bean으로 등록하고 사용할 Repository에서 생성자 주입받는 것을 추천한다.

@Configuration
public class JpaConfig {

    @Bean
    JPAQueryFactory jpaQueryFactory(EntityManager em) {
        return new JPAQueryFactory(em);
    }
}

참고로 동시성 문제는 문제가 없다. 스프링이 주입해주는 EntityManager는 실제 동작 시점에 진짜 EntityManager를 찾아주는 proxy용 EntityManager이다. 실제 사용 시점에서 트랜잭션 단위에 있는 EntityManager를 주입받아 영속성 컨텍스트를 사용하기 때문에 동시성 문제는 발생하지 않는다.

Querydsl 사용하기

@Repository
@RequiredArgsConstructor
public class MemberQuerydslRepository {

    private final JPAQueryFactory queryFactory;	// (1)

    public List<Member> findAll() {
        return queryFactory
                .selectFrom(member)
                .fetch();
    }

    public List<Member> findByUsername(String username) {
        return queryFactory
                .selectFrom(member)
                .where(member.username.eq(username))
                .fetch();
    }
}

(1) : Qeurydsl을 사용하기 위해 필요한 JPAQueryFactory 생성자 주입

순수 JPA Repository와 비교

순수 JPA Repository findAll 메서드

public List<Member> findAll() {
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
}

Querydsl Repository findAll 메서드

public List<Member> findAll() {
    return queryFactory
            .selectFrom(member)
            .fetch();
}

순수 JPA Repository findByUsername 메서드

public List<Member> findByUsername(String username) {
        return em.createQuery("select m from Member m where m.username=:username", Member.class)
                .setParameter("username", username)
                .getResultList();
}

Querydsl Repository findByUsername 메서드

public List<Member> findByUsername(String username) {
    return queryFactory
            .selectFrom(member)
            .where(member.username.eq(username))
            .fetch();
}

Querydsl - 수정, 삭제 벌크 연산

jddng — Fri, 25 Mar 2022 15:25:38 +0900

수정, 삭제 벌크 연산

여러개 수정, 삭제를 하면 데이터 수만큼 쿼리가 나가지만 벌크 연산을 사용하면 쿼리가 1번만 나간다. 따라서 여러개 수정, 삭제를 할 때는 벌크 연산을 사용하면 성능이 최적화된다.

@Test
@DisplayName("벌크 연산")
public void bulkUpdate() {
    long count = queryFactory
            .update(member)
            .set(member.username, "비회원")
            .where(member.age.lt(28))
            .execute();

    assertThat(count).isEqualTo(2);
}

count : 업데이트가 수행된 수
execute() : 벌크 연산 수행

    /* update
        Member member1 
    set
        member1.username = ?1 
    where
        member1.age < ?2 */ update
            member 
        set
            username=? 
        where
            age<?

참고로 해당 쿼리가 실행된 이후에는 해당 쿼리로 DB에는 값이 변경되지만 영속성 컨텍스트에는 값이 변경되지 않는다. 따라서 벌크 연산이 수행된 이후 같은 트랙잭션에서 변경된 값을 DB에서 가져오면 이미 영속성 컨텍스트에 해당 데이터가 이미 있기 때문에 영속성 컨텍스트 안에 변경되지 않은 데이터 값을 가져오는 문제가 발생한다.

따라서 벌크 연산 이후 같은 트랜잭션에서 다시 조회할 경우에는 em.flush()와 em.clear()를 해줘야 한다.

em.flush()와 em.clear()를 해줘야 하는 이유

벌크 연산 수행 전

memberDto = MemberDto(username=member1, age=10)
memberDto = MemberDto(username=member2, age=20)

memberDto = MemberDto(username=member3, age=30)

memberDto = MemberDto(username=member4, age=40)

벌크 연산 수행 후(영속성 컨텍스트)

memberDto = MemberDto(username=member1, age=10)
memberDto = MemberDto(username=member2, age=20)

memberDto = MemberDto(username=member3, age=30)

memberDto = MemberDto(username=member4, age=40)

벌크 연산 수행 후(DB)

memberDto = MemberDto(username=비회원, age=10)
memberDto = MemberDto(username=비회원, age=20)

memberDto = MemberDto(username=member3, age=30)

memberDto = MemberDto(username=member4, age=40)

Member PK 1,2 조회

memberDto = MemberDto(username=member1, age=10)
memberDto = MemberDto(username=member2, age=20)

→ DB에 가져오기 이전에 이미 영속성 컨텍스트에 해당 member가 있기 때문에 업데이트 된

member 값이 아닌 영속성 컨텍스트에 있는 업데이트가 실행 안된 값을 가져오게 된다.

Querydsl - where절을 이용한 동적 쿼리

jddng — Fri, 25 Mar 2022 14:36:45 +0900

where절을 이용한 동적 쿼리

where절을 이용하여 동적 쿼리를 처리할 수 있다. where 조건에서 null 값이 들어오면 값은 무시되고 쿼리가 생성된다. 이러한 특성 때문에 다른 쿼리에서도 재활용이 가능한 장점이 있고, 또한 쿼리 자체의 가독성이 높아진다. BooleanBuilder보다 사용하기 편하므로 이 방법을 권장한다.

@Test
public void dynamicQuery_WhereParam() {
    String usernameParam = "member1";
    Integer ageParam = 10;

    List<Member> result = searchMember2(usernameParam, ageParam);
    assertThat(result.size()).isEqualTo(1);
}

private List<Member> searchMember2(String usernameCond, Integer ageCond) {
    return queryFactory
            .selectFrom(member)
            .where(usernameEq(usernameCond), ageEq(ageCond))
            .fetch();
}

private Predicate usernameEq(String usernameCond) {
    return usernameCond != null ? member.username.eq(usernameCond) : null;
}

private Predicate ageEq(Integer ageCond) {
    return ageCond != null ? member.age.eq(ageCond) : null;
}

    /* select
        member1 
    from
        Member member1 
    where
        member1.username = ?1 
        and member1.age = ?2 */ select
            member0_.member_id as member_id1_1_,
            member0_.age as age2_1_,
            member0_.team_id as team_id4_1_,
            member0_.username as username3_1_ 
        from
            member member0_ 
        where
            member0_.username=? 
            and member0_.age=?

위에서 코드를 보면 usernameEq과 ageEq 메서드를 이용하였다. 이 메서드들은 충분히 다른 쿼리에서도 충분히 쓸 수 있기 때문에 재사용성이 높아진다. 또한 생성한 메서드를 이용한 메서드를 만들 수 있다. 다음 예시를 보자.

private BooleanExpression allEq(String usernameCond, Integer ageCond) {
    return usernameEq(usernameCond).and(ageEq(ageCond));
}

이처럼 usernameEq 메서드와 ageEq 메서드를 다음과 같이 재사용하여 하나의 다른 메서드를 생성할 수 있다.

참고
위에 allEq 메서드는 null 체크를 하지 않았지만
필수적으로 null 체크를 해줘야 한다.

@DataJpaTest
public class DynamicQueryTest {

    JPAQueryFactory queryFactory;
    @Autowired
    EntityManager em;

    @BeforeEach
    void init() {
        queryFactory = new JPAQueryFactory(em);

        em.persist(new Member("userA", 10, "ROLE_MASTER"));
        em.persist(new Member("userB", 20, "ROLE_ADMIN"));
        em.persist(new Member("userC", 30, "ROLE_USER"));
    }

    @Test
    void dynamicQuery() {

//        Integer age = 10;
//        String role = "ROLE_MASTER";
        Integer age = null;
        String role = null;

        List<Member> result = queryFactory
                .selectFrom(member)
                .where(ageAndRoleEq(age, role))
                .fetch();

        System.out.println("result = " + result);

    }

    private BooleanBuilder ageAndRoleEq(Integer age, String role) {
        return ageEq(age).and(roleEq(role));
    }

    private BooleanBuilder ageEq(Integer age) {
        if (age == null) {
            return new BooleanBuilder();
        } else {
            return new BooleanBuilder(member.age.eq(age));
        }
    }

    private BooleanBuilder roleEq(String roleName) {
        if (roleName == null) {
            return new BooleanBuilder();
        }
        return new BooleanBuilder(member.roleName.eq(roleName));
    }

}

자바 8을 이용하면 코드를 줄여줄 수 있다.

private BooleanBuilder ageEq(Integer age) {
    return nullSafeBuilder(() -> member.age.eq(age));
}

private BooleanBuilder roleEq(String roleName) {
    return nullSafeBuilder(() -> member.roleName.eq(roleName));
}

public static BooleanBuilder nullSafeBuilder(Supplier<BooleanExpression> f) {
    try {
        return new BooleanBuilder(f.get());
    } catch (IllegalArgumentException e) {
        return new BooleanBuilder();
    }
}