채팅방 목록 조회 기능 성능 개선

[kwonyj1022]

상황

1. 도메인 구조

@Entity
public class ChatRoom extends BaseCreateTimeEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "auction_id")
    private Auction auction;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "buyer_id")
    private User buyer;
    
}

@Entity
public class Message extends BaseCreateTimeEntity {  
  
	@Id  
	@GeneratedValue(strategy = GenerationType.IDENTITY)  
	private Long id;  
  
	@ManyToOne(fetch = FetchType.LAZY)  
	@JoinColumn(name = "chat_room_id")  
	private ChatRoom chatRoom;  
  
	@ManyToOne(fetch = FetchType.LAZY)  
	@JoinColumn(name = "writer_id")  
	private User writer;  
  
	@ManyToOne(fetch = FetchType.LAZY)  
	@JoinColumn(name = "receiver_id")  
	private User receiver;  
  
	@Column(nullable = false, length = 20_000)  
	private String contents;
	
}

2. 채팅방 목록 조회 정책

• 채팅방에 마지막으로 전송된 메시지가 최근인 순으로 정렬
• 도메인 객체 상에서 채팅방(ChatRoom)은 메시지(Message)를 갖고 있지 않음
• 채팅방 생성 시간과 마지막 메시지 시간은 다를 수 있음
  (B 채팅방이 최근에 생성되었더라도 B 채팅방보다 과거에 만든 A 채팅방에서 가장 최근에 대화를 나눴다면 A 채팅방이 우선순위가 더 높음)

---

처음 구현했을 때

도메인 구조 상 채팅방이 메시지를 갖고 있지 않기 때문에 채팅방을 조회할 때 어떻게 해야할 지 막막했다.

1. 조회를 요청한 사용자가 참여한 모든 채팅방을 select 하고
2. 모든 메시지 중에 사용자가 참여한 채팅방에 해당하는 메시지들 중
3. 가장 마지막 메시지를 선별하고
4. 그 마지막 메시지들이 최신인 순으로 채팅방을 정렬한다.
   위의 과정을 하나의 쿼리로 하기 어렵다고 판단했다.

따라서 차선책으로

1. ChatRoomRepository에서 사용자가 참여한 채팅방을 조회한다.
2. 사용자가 참여한 채팅방 리스트를 순회하면서 MessageRepository에서 마지막 메시지를 조회해서 dto 리스트를 만든다.
3. 만들어진 dto 리스트를 순회하면서 마지막 메시지가 최신은 순으로 정렬한다.

이런 복잡한 과정을 거쳤다.
(아래 코드는 코드를 단순하게 하기 위해 fetch join 과정을 생락했다.)

@Repository
public class QuerydslChatRoomRepositoryImpl implements QuerydslChatRoomRepository {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<ChatRoom> findAllByUserId(final Long userId) {
        return queryFactory.selectFrom(chatRoom)
							.where(isSellerOrWinner(userId))
                            .orderBy(chatRoom.id.desc())
    }

    private BooleanExpression isSellerOrWinner(final Long userId) {
        return (auction.seller.id.eq(userId))
                .or(chatRoom.buyer.id.eq(userId));
    }
}

@Service
public class ChatRoomService {

    private final JpaChatRoomRepository chatRoomRepository;
    private final JpaMessageRepository messageRepository;
    
    public List<ReadChatRoomWithLastMessageDto> readAllByUserId(final Long userId) {
        final List<ChatRoom> chatRooms = chatRoomRepository.findAllByUserId(userId);

        return processAndSort(chatRooms);
    }

    private List<ReadChatRoomWithLastMessageDto> processAndSort(
            final List<ChatRoom> chatRooms
    ) {
        final List<ReadChatRoomWithLastMessageDto> chatRoomDtos = new ArrayList<>();
        for (final ChatRoom chatRoom : chatRooms) {
            messageRepository.findLastMessageByChatRoomId(chatRoom.getId())
                             .ifPresent(message ->
                                     chatRoomDtos.add(ReadChatRoomWithLastMessageDto.of(chatRoom, message))
                             );
        }

        return chatRoomDtos.stream()
                           .sorted(comparing((ReadChatRoomWithLastMessageDto dto) -> dto.lastMessageDto().createdTime())
                                   .reversed())
                           .toList();
    }
}

• ChatRoomRepository에서 채팅방 목록을 가져오고
• dto를 만들기 위해서는 마지막 메시지가 필요하기 때문에, 채팅방 목록의 개수만큼 MessageRepository에 여러 번 접근한다.
• 게다가 서비스 레이어 내부에서 또 정렬을 위해 연산을 한다.

---

첫 번째 개선

ChatRoomRepository에서 채팅방 목록을 조회해 올 때 마지막 메시지가 최근인 순으로 List<ChatRoom>을 가져오도록 개선하였다.

@Repository
public class QuerydslChatRoomRepositoryImpl implements QuerydslChatRoomRepository {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<ChatRoom> findAllByUserId(final Long userId) {
        return queryFactory
                .selectFrom(chatRoom)
                .where(isSellerOrWinner(userId))
                .orderBy(message.id.max().desc())
		        .leftJoin(message).on(message.chatRoom.id.eq(chatRoom.id))
                .groupBy(chatRoom.id)
                .fetch();
    }

    private BooleanExpression isSellerOrWinner(final Long userId) {
        return (auction.seller.id.eq(userId))
                .or(chatRoom.buyer.id.eq(userId));
    }
}

@Service
public class ChatRoomService {

    private final JpaChatRoomRepository chatRoomRepository;
    private final JpaMessageRepository messageRepository;
    
    public List<ReadChatRoomWithLastMessageDto> readAllByUserId(final Long userId) {
        final List<ChatRoom> chatRooms = chatRoomRepository.findAllByUserId(userId);

        return chatRooms.stream()
                        .map(chatRoom -> processDtoWithLastMessage(chatRoom))
                        .filter(Optional::isPresent)
                        .map(Optional::get)
                        .toList();
    }

    private Optional<ReadChatRoomWithLastMessageDto> processDtoWithLastMessage(
            final ChatRoom chatRoom
    ) {
        return messageRepository.findLastMessageByChatRoomId(chatRoom.getId())
                                .map(message -> ReadChatRoomWithLastMessageDto.of(chatRoom, message));
    }
}

• 채팅방 목록을 가져올 때 정렬된 상태로 가져온다.
• dto를 만들기 위해서는 마지막 메시지도 필요하기 때문에 이 코드 역시 MessageRepository에 채팅방의 개수만큼 접근해야 한다.
• 서비스 레이어에서의 정렬 연산이 없어졌지만 여전히 MessageRepository에 여러 번 접근하므로 비효율적이다.

---

두 번째 개선

지금까지는 QueryDsl을 사용할 때 Projection 대상은 1개였다.

• Projection: select할 대상을 지정하는 일
• 지금까지는 ChatRoom, Message 등 하나의 엔티티에 대해서만 select 해왔다.

프로젝션 대상을 2개 이상 지정할 수 있다고 한다.
크게는 Tuple을 사용하는 방법과 별도의 Dto를 사용하는 방법이 있다.

1. Tuple을 사용하는 방법

@Repository  
public class QuerydslExampleRepositoryImpl implements QuerydslExampleRepository {

	public List<Tuple> findAllByUserId(final Long userId) {  
		return queryFactory.select(target1, target2)  
							.from(entity)
							.~
	}
}

@Service   
public class ExampleService {

	private final QuerydslExampleRepositoryImpl exampleRepository

	public List<ReadChatRoomWithLastMessageDto> readAllByUserId(final Long userId) {

    final List<Tuple> result = exampleRepository.findAllByUserId(userId);

    for (final Tuple tuple : result) {
        final Target1 target1 = tuple.get(QTarget1.target1);
        final Target2 target2 = tuple.get(QTarget2.target2);
        ...
    }
    ...
}

• Service 레이어에서 QueryDsl 전용으로 사용되는 Tuple과 Q파일을 사용하게 된다.
• 따라서 QueryDsl에 대한 의존성을 Service에서까지 갖게 되기 때문에 사용하지 않기로 했다.

별도의 Dto를 사용하는 방법

총 4가지의 방법이 있는데, ChatRoom 뿐만 아니라, QMessage까지 접근해서 Message도 가져와야 했기 때문에 조회 쿼리가 잘못되었는지 확인하기 위해 임시로 제일 위에 있던 방법인 프로퍼티 접근 방식을 사용해서 테스트하려고 했다.

이 과정에서 예상치 못한 문제가 발생해서 관련 내용을 함께 설명해보려고 한다.

팀 컨벤션 상 dto는 record를 사용하기로 했기 때문에 처음에는 record로 만들었다.

public record ChatRoomWithLastMessageDto(ChatRoom chatRoom, Message message) {

}

1. 프로퍼티 접근

Projections.bean(해당Dto.class, 적용할 필드...) 사용

@Repository
public class QuerydslChatRoomRepositoryImpl implements QuerydslChatRoomRepository {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<ChatRoomWithLastMessageDto> findAllChatRoomInfoByUserIdOrderByLastMessage(final Long userId) {
        return queryFactory
                .select(Projections.bean(ChatRoomWithLastMessageDto.class, chatRoom, message))
                .from(chatRoom)
                .~
                .fetch();

이렇게 했더니 ExpressionException이 발생했다.
처음에는 쿼리에 문제가 있는 줄 알고 쿼리를 이것 저것 바꿔보다가 시간이 많이 지체됐다.

결과적으로 문제의 원인은 record를 사용했다는 것에 있었다.
record로 작성했던 dto를 class로 바꾸고, 기본 생성자와 getter(), setter()를 모두 추가해준 후 어느 메서드가 실행되는지 알기 위해 각 메서드 실행 시 콘솔에 출력하도록 했다.

public class ChatRoomWithLastMessageDto {
        private ChatRoom chatRoom;
        private Message message;

        public ChatRoomWithLastMessageDto() {
                System.out.println("ChatRoomWithLastMessegeDto() 기본 생성자 실행");
        }

        public ChatRoomWithLastMessageDto(final ChatRoom chatRoom, final Message message) {
                System.out.println("ChatRoomWithLastMessegeDto(chatRoom, message) 생성자 실행");
                this.chatRoom = chatRoom;
                this.message = message;
        }

        public void setChatRoom(final ChatRoom chatRoom) {
                System.out.println("setChatRoom() 실행");
                this.chatRoom = chatRoom;
        }

        public void setMessage(final Message message) {
                System.out.println("setMessage() 실행");
                this.message = message;
        }

        public ChatRoom getChatRoom() {
                System.out.println("getChatRoom() 실행");
                return chatRoom;
        }

        public Message getMessage() {
                System.out.println("getMessage() 실행");
                return message;
        }
}

출력된 내용

find 시작
ChatRoomWithLastMessegeDto() 기본 생성자 실행
setChatRoom() 실행
setMessage() 실행
ChatRoomWithLastMessegeDto() 기본 생성자 실행
setChatRoom() 실행
setMessage() 실행
find 끝

출력된 내용을 보면 알 수 있듯이
프로퍼티 접근 방식은 기본 빈 생성자와 setter를 통해 dto를 생성한다.

record에는 빈 생성자도, setter도 없기 때문에 dto에 값을 할당해줄 수 없어서 예외가 발생한 것이다.

2. 필드 직접 접근

Projections.fields(해당Dto.class, 적용할 필드...) 사용

@Repository
public class QuerydslChatRoomRepositoryImpl implements QuerydslChatRoomRepository {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<ChatRoomWithLastMessageDto> findAllChatRoomInfoByUserIdOrderByLastMessage(final Long userId) {
        return queryFactory
                .select(Projections.fields(ChatRoomWithLastMessageDto.class, chatRoom, message))
                .from(chatRoom)
                .~
                .fetch();

이 방식도 마찬가지로 ExpressionException이 발생했다.
이것도 record를 사용했기 때문에 발생한 문제였다.

똑같이 record를 class로 바꾸고 생성자와 getter, setter 메서드를 만들고, 각 메서드마다 콘솔에 출력하도록 한 후 테스트를 실행해 보았다.

출력된 내용

find 시작
ChatRoomWithLastMessegeDto() 기본 생성자 실행
ChatRoomWithLastMessegeDto() 기본 생성자 실행
find 끝

출력된 내용을 보면 알 수 있듯이
필드 직접 접근 방식은 기본 빈 생성자만 사용한다.
setter를 제거하고 실행해도 정상적으로 동작한다.

하지만 record에는 빈 생성자가 없기 때문에 예외가 발생한다.

3. 생성자 사용

Projections.constructor(해당Dto.class, 적용할 필드...) 사용

@Repository
public class QuerydslChatRoomRepositoryImpl implements QuerydslChatRoomRepository {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<ChatRoomWithLastMessageDto> findAllChatRoomInfoByUserIdOrderByLastMessage(final Long userId) {
        return queryFactory
                .select(Projections.constructor(ChatRoomWithLastMessageDto.class, chatRoom, message))
                .from(chatRoom)
                .~
                .fetch();

출력된 내용

find 시작
ChatRoomWithLastMessegeDto(chatRoom, message) 생성자 실행
ChatRoomWithLastMessegeDto(chatRoom, message) 생성자 실행
find 끝

출력된 내용을 보면 알 수 있듯이
생성자 사용 방식은 매개변수가 있는 생성자만을 사용한다.

따라서 record를 사용해도 예외가 발생하지 않는다.

4. @QueryProjection 사용

사용할 dto의 생성자에 @QueryProjection 어노테이션을 붙여준다.
new QDto() 형식으로 사용할 수 있다.

@Repository
public class QuerydslChatRoomRepositoryImpl implements QuerydslChatRoomRepository {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<ChatRoomWithLastMessageDto> findAllChatRoomInfoByUserIdOrderByLastMessage(final Long userId) {
        return queryFactory
                .select(new QChatRoomWithLastMessageDto(chatRoom, message))
                .from(chatRoom)
                .~
                .fetch();

• 장점
  • 컴파일 타임에 오류를 발견할 수 있으므로 안전하다.
  • 예를 들어 위의 다른 방법(프로퍼티 접근, 필드 직접 접근, 생성자 사용)을 사용했다면
    • 만약 dto의 필드는 2개인데 사용할 인자를 3개 이상 넣게 되었을 때, 실행 타임에 예외가 발생한다.
    • 하지만 이 방식은 Q도메인 생성자를 사용하기 때문에 인자를 3개 이상 넣게 되면 컴파일 타임에 오류를 발견할 수 있다
• 단점
  • dto에 QueryDsl용 어노테이션이 사용된다.
  • 빌드해서 Q파일을 생성해야 한다는 불편함이 있다.

[BDawg3327]

hi

[BDawg3327]

my name is javon