DotNet
데이터베이스
데이터베이스 설계 원칙
Lazy Load

Lazy Load

Lazy Load 패턴이란?

Lazy Load 패턴은 필요한 시점에만 데이터를 로드하는 기법입니다. 즉, 데이터가 필요하지 않으면 초기에는 로드하지 않고, 실제로 데이터에 접근할 때 비로소 로드하는 방식입니다. 이는 성능을 최적화하고, 불필요한 데이터베이스 접근을 줄이는 데 유용합니다. 이 패턴은 대규모 데이터 또는 비용이 많이 드는 데이터 요청에서 주로 사용됩니다.

Lazy Load 패턴의 특징

지연된 데이터 로딩
데이터가 즉시 필요하지 않은 경우, 처음부터 모든 데이터를 로드하지 않고 실제 접근할 때 로딩을 지연시킵니다. 성능 최적화
필요한 데이터만 로드하여, 애플리케이션의 성능을 최적화하고 메모리 사용을 줄일 수 있습니다. 메모리 효율성
처리되지 않은 대규모 데이터를 메모리에 미리 로드하는 대신, 필요한 시점에만 데이터를 메모리에 로드하므로, 메모리 자원을 효율적으로 사용할 수 있습니다.

Lazy Load 패턴 적용

Lazy Load 패턴의 필요성

애플리케이션이 대규모 데이터를 다루거나 데이터베이스와 자주 상호작용하는 경우, 모든 데이터를 한 번에 불러오는 것은 성능 문제를 일으킬 수 있습니다. Lazy Load 패턴은 데이터를 지연 로드하여 성능을 개선하고, 불필요한 데이터 접근을 줄일 수 있습니다.

잘못된 처리 

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public Author Author { get; set; } // 즉시 로딩됨
}
public class BookRepository
{
    public Book GetBookById(int id)
    {
        // 책과 저자를 즉시 로드
        return _context.Books.Include(b => b.Author).FirstOrDefault(b => b.Id == id);
    }
}

문제점

즉시 로딩으로 인한 성능 저하
위 코드에서는 Book 객체와 연관된 Author 객체가 즉시 로드됩니다. 모든 요청에서 관련 데이터를 미리 로드하면 성능에 부하가 걸리고, 불필요한 데이터베이스 접근이 발생할 수 있습니다.

Lazy Load 패턴 적용 예시 

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    private Author _author;
    public Author Author
    {
        get
        {
            if (_author == null)
            {
                // Author 데이터가 필요할 때만 로드
                _author = AuthorRepository.GetAuthorByBookId(Id);
            }
            return _author;
        }
    }
}
public class BookRepository
{
    public Book GetBookById(int id)
    {
        // 책만 먼저 로드, 저자는 나중에 필요할 때 로드
        return _context.Books.FirstOrDefault(b => b.Id == id);
    }
}

개선사항

데이터베이스 호출 최적화
잘못된 처리에서는 연관 데이터를 즉시 로드하여 성능 저하가 발생했지만, Lazy Load 패턴을 적용하면 연관 데이터를 필요할 때만 로드하여 데이터베이스 접근 횟수를 줄이고 성능을 최적화할 수 있습니다. 메모리 효율성
Lazy Load는 필요하지 않은 데이터를 미리 로드하지 않으므로 메모리 사용을 줄여, 애플리케이션의 메모리 효율성을 높입니다.

Lazy Load 패턴 구성 요소

지연된 데이터 로딩 메커니즘
데이터를 즉시 로드하지 않고, 데이터 접근 시점에서 로딩이 이루어집니다. 객체에 접근할 때 조건을 확인하여 데이터를 로드할지 결정하는 로직이 필요합니다. Repository
데이터베이스에 직접 접근하여 필요한 데이터를 로드하는 역할을 합니다. Lazy Load 패턴에서는 데이터베이스 요청을 최소화하기 위한 로직을 구현합니다. Service Layer
Lazy Load 패턴을 통해 데이터가 필요한 시점에 로드되도록 비즈니스 로직을 처리합니다.

장점

성능 최적화
실제 필요한 데이터만 로드하므로, 대규모 데이터셋을 처리할 때 성능을 크게 개선할 수 있습니다. 불필요한 데이터베이스 접근 감소
데이터가 필요한 시점에만 데이터베이스에 접근하므로, 데이터베이스 트래픽을 줄이고 성능을 최적화할 수 있습니다. 메모리 사용 감소
모든 데이터를 메모리에 로드하지 않으므로, 메모리 사용량을 최소화할 수 있습니다.

단점

데이터 접근 지연
필요한 데이터를 나중에 로드하기 때문에, 실제로 데이터에 접근하는 시점에서 지연이 발생할 수 있습니다. 특히, 네트워크나 데이터베이스 연결이 느린 경우 문제가 될 수 있습니다. 코드 복잡성 증가
Lazy Load 패턴을 적용하면 객체의 상태를 추적하고 필요한 데이터를 로드하는 로직이 추가되므로, 코드가 복잡해질 수 있습니다.

맺음말

Lazy Load 패턴은 애플리케이션에서 성능을 최적화하고 메모리 사용을 줄이는 데 매우 유용한 패턴입니다. 이를 통해 불필요한 데이터베이스 호출을 줄이고, 필요한 시점에 데이터를 효율적으로 로드하여 리소스를 절약할 수 있습니다. 그러나 지연된 데이터 접근으로 인한 성능 저하와 코드 복잡성 증가에 유의해야 하며, 상황에 따라 적절히 적용해야 합니다.

심화 학습

Lazy Load와 Eager Load의 조합

Lazy Load 패턴과 Eager Load 패턴은 서로 상반된 로딩 전략을 가지고 있으며, 두 가지를 조합하여 적절하게 사용할 수 있습니다. Lazy Load는 필요할 때 데이터를 로드하고, Eager Load는 데이터를 미리 로드하는 방식입니다. 이 두 패턴을 상황에 맞게 적절히 조합하면 성능 최적화와 데이터 접근의 효율성을 동시에 확보할 수 있습니다.

예시: Lazy Load와 Eager Load의 조합 

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    private Author _author;
    public Author Author
    {
        get
        {
            if (_author == null)
            {
                _author = AuthorRepository.GetAuthorByBookId(Id); // Lazy Load
            }
            return _author;
        }
    }
}
public class BookRepository
{
    public Book GetBookWithReviews(int id)
    {
        // Eager Load: Book과 관련된 Reviews 데이터를 미리 로드
        return _context.Books.Include(b => b.Reviews).FirstOrDefault(b => b.Id == id);
    }
}

위 코드에서는 Book 객체의 저자는 Lazy Load로 필요할 때 로드되며, 리뷰와 같은 관련 데이터는 Eager Load로 미리 로드됩니다. 이 방식은 성능을 최적화하면서도 관련 데이터를 적시에 처리할 수 있습니다.

Proxy 패턴과의 결합

Lazy Load 패턴은 종종 Proxy 패턴과 함께 사용됩니다. Proxy 패턴은 원래 객체에 접근하기 전에 대리 객체(Proxy)를 통해 접근을 제어하는 패턴으로, Lazy Load에서 실제 객체 로딩을 지연시키는 데 유용합니다. Proxy를 통해 객체에 처음 접근할 때만 데이터를 로드하고, 그 이후에는 캐시된 데이터를 반환할 수 있습니다.

예시: Proxy 패턴을 사용한 Lazy Load 

public class BookProxy : Book
{
    private Book _book;
    private readonly int _bookId;
    public BookProxy(int bookId)
    {
        _bookId = bookId;
    }
    public override string Title
    {
        get
        {
            if (_book == null)
            {
                _book = BookRepository.GetBookById(_bookId); // 처음 접근 시 로드
            }
            return _book.Title;
        }
    }
}

이 예시에서는 BookProxy가 원본 객체 대신 동작하며, Title 속성에 처음 접근할 때만 실제로 데이터를 로드합니다. 이후에는 이미 로드된 데이터를 사용하므로 데이터베이스 호출이 불필요합니다.

캐싱 전략과의 결합

Lazy Load 패턴은 캐싱 전략과 결합하여 성능을 더 향상시킬 수 있습니다. 메모리에 캐싱된 데이터를 필요할 때 로드하고, 캐시가 만료되거나 갱신되면 데이터를 다시 로드하는 방식으로 동작할 수 있습니다. 이를 통해 성능 최적화와 일관성을 유지할 수 있습니다.

예시: Lazy Load와 캐싱의 결합 

public class CachedBookRepository
{
    private readonly Dictionary<int, Book> _bookCache = new Dictionary<int, Book>();
    public Book GetBookById(int id)
    {
        if (!_bookCache.ContainsKey(id))
        {
            var book = BookRepository.GetBookById(id);
            _bookCache[id] = book;
        }
        return _bookCache[id];
    }
}

위 예시에서는 Book 객체를 캐시하여, 이미 조회된 데이터는 캐시에서 바로 반환하고, 캐시되지 않은 데이터만 데이터베이스에서 로드합니다. 이는 데이터베이스 접근을 줄여 성능을 크게 향상시킬 수 있습니다.

테스트 주도 개발(TDD)에서의 Lazy Load

Lazy Load 패턴은 테스트 주도 개발(TDD)에서도 중요한 역할을 합니다. 실제 데이터베이스에 의존하지 않고, Mock 객체를 사용해 지연 로딩을 테스트할 수 있습니다. 이를 통해 데이터베이스와 무관하게 비즈니스 로직을 검증할 수 있습니다.

예시: Lazy Load를 사용한 TDD 

public class MockBookRepository : IBookRepository
{
    public Book GetBookById(int id)
    {
        // Mock 데이터 반환
        return new Book { Id = id, Title = "Mock Book" };
    }
}
[TestMethod]
public void TestLazyLoadAuthor()
{
    // Arrange
    var mockBookRepo = new MockBookRepository();
    var book = mockBookRepo.GetBookById(1);
    // Act
    var author = book.Author; // Lazy Load로 Author를 로드
    // Assert
    Assert.IsNotNull(author);
}

이 테스트 예시에서는 Mock 객체를 사용하여 데이터베이스 없이 Lazy Load 로직을 검증합니다. 이를 통해 실제 데이터베이스에 의존하지 않고도 비즈니스 로직의 동작을 확인할 수 있습니다.

Lazy Load의 성능 문제와 해결책

Lazy Load 패턴은 성능 최적화에 큰 도움이 되지만, 잘못된 사용으로 인해 성능 문제가 발생할 수 있습니다. 예를 들어, N+1 문제는 Lazy Load에서 자주 발생하는 문제로, 한 번의 쿼리로 여러 개의 데이터를 로드할 때 발생합니다. N+1 문제 해결책

  • Eager Loading으로 필요한 데이터를 미리 로드하거나,
  • Batch Loading을 사용하여 한 번의 쿼리로 여러 데이터를 가져오는 방식으로 해결할 수 있습니다.

예시: N+1 문제 해결 

public class BookRepository
{
    public IEnumerable<Book> GetBooksWithAuthors()
    {
        // Eager Loading을 사용하여 한 번에 Author를 로드
        return _context.Books.Include(b => b.Author).ToList();
    }
}

이 방식은 N+1 문제를 해결하고, 불필요한 데이터베이스 접근을 줄여 성능을 개선할 수 있습니다.

Buy me a coffee Buy me a coffee
Query Object