Query Object

Query Object 패턴이란?

Query Object 패턴은 복잡한 데이터베이스 쿼리 로직을 캡슐화하여, 비즈니스 로직에서 데이터 접근 로직을 분리하는 디자인 패턴입니다. 이 패턴을 사용하면, 쿼리 로직을 객체로 표현하여 데이터베이스 질의를 보다 유연하고 가독성 있게 만들 수 있습니다. 이는 주로 복잡한 쿼리를 반복적으로 사용할 때, 쿼리의 재사용성을 높이고 코드의 유지보수성을 향상시킵니다.

Query Object 패턴의 특징

복잡한 쿼리 캡슐화
Query Object는 복잡한 SQL 쿼리 또는 데이터베이스 질의를 하나의 객체로 캡슐화합니다. 이를 통해 비즈니스 로직에서는 쿼리의 구체적인 내용에 신경 쓰지 않고, 필요한 데이터를 객체를 통해 쉽게 가져올 수 있습니다. 쿼리 재사용성
쿼리 로직을 객체로 분리하면, 동일하거나 유사한 쿼리를 여러 곳에서 재사용할 수 있습니다. 이는 쿼리 중복을 줄이고, 수정이 필요할 때 한 곳에서만 변경하면 됩니다. 비즈니스 로직과 데이터 접근 로직 분리
데이터 접근 로직을 Query Object로 분리하여, 비즈니스 로직이 데이터베이스 쿼리와 결합되는 것을 방지할 수 있습니다. 이를 통해 코드의 가독성과 유지보수성이 향상됩니다.

Query Object 패턴 적용

Query Object 패턴의 필요성

복잡한 쿼리가 자주 사용되거나, 비즈니스 로직에서 다양한 필터나 정렬 조건을 사용하여 데이터를 가져와야 하는 경우, 이 패턴을 적용하면 쿼리 로직을 명확하고 재사용 가능하게 만들 수 있습니다. Query Object 패턴을 사용하면 SQL 또는 데이터 접근 코드가 비즈니스 로직에 흩어져 있는 것을 방지할 수 있습니다.

잘못된 처리

public class BookService
{
    private readonly IBookRepository _bookRepository;
    public BookService(IBookRepository bookRepository)
    {
        _bookRepository = bookRepository;
    }
    public IEnumerable<Book> GetBooksByAuthor(string author)
    {
        return _bookRepository.GetAllBooks()
                               .Where(b => b.Author == author)
                               .OrderBy(b => b.Title);
    }
}

문제점

쿼리 중복
비슷한 쿼리가 여러 서비스 또는 메서드에서 중복될 가능성이 있습니다. 필터링 조건이나 정렬 로직이 변경되면 여러 곳에서 수정이 필요해, 유지보수가 어렵습니다. 비즈니스 로직과 데이터 접근 결합
데이터 필터링 및 정렬 로직이 비즈니스 로직과 함께 구현되어 있어, 코드가 복잡하고 가독성이 떨어집니다.

Query Object 패턴 적용 예시

// Query Object
public class BookQueryObject
{
    private IQueryable<Book> _query;
    public BookQueryObject(IQueryable<Book> query)
    {
        _query = query;
    }
    public IQueryable<Book> FilterByAuthor(string author)
    {
        return _query.Where(b => b.Author == author);
    }
    public IQueryable<Book> SortByTitle()
    {
        return _query.OrderBy(b => b.Title);
    }
    public IEnumerable<Book> Execute()
    {
        return _query.ToList();
    }
}
// Repository Interface
public interface IBookRepository
{
    IQueryable<Book> GetBooksQuery();
}
// Service Layer : Query Object 패턴 적용
public class BookService
{
    private readonly IBookRepository _bookRepository;
    public BookService(IBookRepository bookRepository)
    {
        _bookRepository = bookRepository;
    }
    public IEnumerable<Book> GetBooksByAuthor(string author)
    {
        var queryObject = new BookQueryObject(_bookRepository.GetBooksQuery());
        var filteredBooks = queryObject.FilterByAuthor(author).SortByTitle();
        return filteredBooks.Execute();
    }
}

개선사항

쿼리 로직의 재사용성 향상
잘못된 처리에서는 데이터 필터링과 정렬 로직이 비즈니스 로직에 포함되어 있었습니다. Query Object 패턴을 적용하면 쿼리 로직을 객체로 분리하여, 코드 중복을 줄이고 다양한 곳에서 재사용할 수 있습니다. 비즈니스 로직과 데이터 접근 로직 분리
쿼리 로직이 Query Object로 분리되어, 비즈니스 로직은 데이터 접근 방식에 신경 쓰지 않고 필요한 데이터만 사용할 수 있습니다. 이를 통해 코드 가독성 및 유지보수성이 향상됩니다.

Query Object 패턴 구성 요소

Query Object
쿼리 로직을 캡슐화한 객체로, 복잡한 데이터베이스 질의를 객체 내부에서 처리하며, 비즈니스 로직에 전달된 필터나 정렬 조건에 따라 데이터를 반환합니다. Repository Interface
데이터베이스에 접근하여 쿼리를 실행할 수 있는 인터페이스입니다. Query Object는 이 인터페이스를 통해 데이터를 가져오고, 이후의 로직을 처리합니다. Service Layer
비즈니스 로직을 처리하며, Query Object를 사용하여 필요한 데이터를 효율적으로 가져오고, 로직에 맞는 처리를 수행합니다.

장점

쿼리 재사용성 증가
쿼리 로직을 객체로 분리하여 여러 곳에서 동일한 로직을 재사용할 수 있으므로, 코드 중복이 줄어들고 유지보수가 용이해집니다. 쿼리 가독성 향상
복잡한 SQL 쿼리 또는 데이터 필터링/정렬 로직을 객체 내에서 처리하므로, 코드의 가독성이 향상됩니다. 비즈니스 로직과 데이터 접근 로직 분리
데이터베이스 쿼리 로직을 비즈니스 로직과 분리하여, 유지보수성과 확장성이 높아집니다.

단점

간단한 쿼리에는 과도한 복잡성
쿼리가 매우 단순한 경우, 쿼리 객체로 감싸는 것이 불필요한 복잡성을 추가할 수 있습니다. 객체 생성을 통한 성능 저하 가능성
복잡한 쿼리 로직을 객체로 캡슐화하는 과정에서 객체 생성에 따른 오버헤드가 발생할 수 있습니다.

맺음말

`Query Object` 패턴은 복잡한 데이터 쿼리를 캡슐화하고 재사용 가능하게 만들어, 데이터 접근 로직을 효율적으로 관리할 수 있습니다. 이를 통해 코드의 유지보수성과 가독성을 높일 수 있지만, 너무 단순한 쿼리에는 적용할 필요가 없으며, 시스템의 요구 사항에 맞게 적절히 선택하는 것이 중요합니다.

심화 학습

`Specification` 패턴 결합

Query Object 패턴은 Specification 패턴과 함께 사용하여 복잡한 필터링 로직을 더욱 세밀하게 정의하고 조합할 수 있습니다. Specification 패턴은 특정 조건을 정의하고, 이 조건을 여러 쿼리에 재사용할 수 있게 해주는 패턴입니다. 두 패턴을 결합하면, 재사용 가능한 필터 조건을 만들고, 이를 다양한 쿼리와 쉽게 결합할 수 있습니다.

예시: `Specification` 패턴과의 결합

// Specification Interface
public interface ISpecification<T>
{
    bool IsSatisfiedBy(T entity);
}
// AuthorSpecification
public class AuthorSpecification : ISpecification<Book>
{
    private readonly string _author;
    public AuthorSpecification(string author)
    {
        _author = author;
    }
    public bool IsSatisfiedBy(Book book)
    {
        return book.Author == _author;
    }
}
// Query Object
public class BookQueryObject
{
    private IQueryable<Book> _query;
    public BookQueryObject(IQueryable<Book> query)
    {
        _query = query;
    }
    public IQueryable<Book> FilterBySpecification(ISpecification<Book> spec)
    {
        return _query.Where(b => spec.IsSatisfiedBy(b));
    }
    public IEnumerable<Book> Execute()
    {
        return _query.ToList();
    }
}

위 코드는 Specification 패턴을 사용하여 Book 엔터티에 대한 저자 필터를 정의하고, Query Object와 결합하여 더욱 유연한 필터링 로직을 구현한 예시입니다. 이를 통해 여러 조건을 조합하여 복잡한 쿼리를 구성할 수 있습니다.

성능 최적화: 데이터 캐싱과의 결합

Query Object 패턴은 자주 사용하는 데이터를 캐싱하여 성능을 극대화할 수 있습니다. 특히, 동일한 쿼리가 반복적으로 사용되는 경우 캐싱을 통해 데이터베이스 접근을 줄이고 응답 시간을 크게 단축할 수 있습니다. 이를 위해 MemoryCache나 Redis와 같은 캐싱 기술을 활용할 수 있습니다.

예시: 캐싱과의 결합

public class CachedBookQueryObject : BookQueryObject
{
    private readonly IMemoryCache _cache;
    public CachedBookQueryObject(IQueryable<Book> query, IMemoryCache cache) 
        : base(query)
    {
        _cache = cache;
    }
    public new IEnumerable<Book> Execute()
    {
        string cacheKey = "book_cache";
        if (!_cache.TryGetValue(cacheKey, out IEnumerable<Book> cachedBooks))
        {
            cachedBooks = base.Execute();
            _cache.Set(cacheKey, cachedBooks, TimeSpan.FromMinutes(10));
        }
        return cachedBooks;
    }
}

위 코드는 쿼리 결과를 캐싱하여 동일한 쿼리에 대해 데이터베이스에 반복적으로 접근하지 않고, 캐싱된 데이터를 반환하는 방법을 보여줍니다. 이는 대규모 데이터 처리 애플리케이션에서 성능을 크게 개선할 수 있습니다.

`CQRS` 패턴과의 결합

Query Object 패턴은 CQRS(Command Query Responsibility Segregation) 패턴과 결합할 수 있습니다. CQRS 패턴은 읽기 작업과 쓰기 작업을 분리하여 각각을 최적화하는 방식으로, 복잡한 애플리케이션에서 성능을 극대화할 수 있습니다. Query Object는 CQRS에서 읽기 작업에 특화된 쿼리로 활용될 수 있습니다.

예시: `CQRS`와의 결합

// Query Object for reading
public class BookReadQueryObject
{
    private IQueryable<Book> _query;
    public BookReadQueryObject(IQueryable<Book> query)
    {
        _query = query;
    }
    public IEnumerable<Book> GetBooksByTitle(string title)
    {
        return _query.Where(b => b.Title.Contains(title)).ToList();
    }
}
// Command Object for writing
public class BookCommandService
{
    private readonly IBookRepository _bookRepository;
    public BookCommandService(IBookRepository bookRepository)
    {
        _bookRepository = bookRepository;
    }
    public void AddBook(Book book)
    {
        _bookRepository.AddBook(book);
    }
    public void RemoveBook(int id)
    {
        _bookRepository.RemoveBook(id);
    }
}

위 코드는 읽기와 쓰기 작업을 분리한 CQRS 패턴을 Query Object 패턴과 결합하여 적용한 예시입니다. 읽기 작업은 BookReadQueryObject에서 처리되고, 쓰기 작업은 BookCommandService에서 처리됩니다.

복잡한 쿼리 성능 최적화를 위한 페이징 처리

대규모 데이터셋을 처리할 때 성능을 최적화하려면 페이징(paging) 기법을 사용하는 것이 중요합니다. Query Object 패턴을 통해 페이징 로직을 쉽게 추가할 수 있습니다. 페이징은 데이터베이스에서 필요한 데이터만 가져와 메모리 사용량과 처리 시간을 줄여줍니다.

예시: 페이징 처리 추가

public class PagedBookQueryObject : BookQueryObject
{
    private int _pageNumber;
    private int _pageSize;
    public PagedBookQueryObject(IQueryable<Book> query, int pageNumber, int pageSize)
        : base(query)
    {
        _pageNumber = pageNumber;
        _pageSize = pageSize;
    }
    public IQueryable<Book> ApplyPaging()
    {
        return _query.Skip((_pageNumber - 1) * _pageSize).Take(_pageSize);
    }
}

페이징을 적용하면 필요한 만큼의 데이터만 조회하여 메모리 사용량을 줄이고, 데이터베이스 부하를 최소화할 수 있습니다.

복잡한 필터 조건 관리

Query Object 패턴을 사용하면, 여러 필터 조건을 동적으로 조합하여 복잡한 쿼리 로직을 처리할 수 있습니다. 다양한 비즈니스 요구사항에 맞춰 필터 조건을 조합하여 최적의 쿼리를 생성할 수 있으며, 이를 통해 비즈니스 로직을 더욱 유연하게 관리할 수 있습니다.

예시: 동적 필터 조건

public class DynamicBookQueryObject
{
    private IQueryable<Book> _query;
    public DynamicBookQueryObject(IQueryable<Book> query)
    {
        _query = query;
    }
    public IQueryable<Book> ApplyFilters(List<Func<IQueryable<Book>, IQueryable<Book>>> filters)
    {
        foreach (var filter in filters)
        {
            _query = filter(_query);
        }
        return _query;
    }
}

위 코드는 여러 필터 조건을 동적으로 적용할 수 있는 방식으로 구현되었습니다. 이를 통해 비즈니스 요구사항에 따라 유연하게 쿼리 조건을 관리할 수 있습니다.

Query Object 패턴의 한계와 해결 방안

Query Object 패턴은 복잡한 쿼리 로직을 효율적으로 관리할 수 있지만, 성능 저하나 복잡성이 증가할 수 있는 한계도 존재합니다. 이러한 문제를 해결하기 위해 쿼리 최적화, 캐싱, 페이징 등의 기술과 결합하여 성능을 개선할 수 있습니다.

쿼리 성능 최적화: 쿼리를 최적화하여 불필요한 데이터 로드를 최소화하고, 적절한 인덱스를 사용하여 쿼리 성능을 향상시킬 수 있습니다.
페이징과 캐싱 적용: 페이징을 사용하여 대량의 데이터를 처리하고, 캐싱을 통해 동일한 쿼리에 대한 데이터베이스 호출을 줄일 수 있습니다.
CQRS와 결합: Query Object를 CQRS와 결합하여 읽기 작업과 쓰기 작업을 분리하고, 각 작업에 맞는 최적화를 적용할 수 있습니다. Query Object 패턴은 다양한 패턴 및 기술과 결합하여 유연하고 성능 최적화된 데이터 접근 로직을 구현할 수 있습니다.

Buy me a coffee

Identity Map Lazy Load