Lazy loading

Origem: Wikipédia, a enciclopédia livre.
Saltar para a navegação Saltar para a pesquisa

Lazy loading é um padrão de projeto de software, comumente utilizado em linguagens de programação, para adiar a inicialização de um objeto até o ponto em que ele é necessário. Isso pode contribuir para a eficiência no funcionamento de um programa, se utilizado adequadamente[1]. O oposto do carregamento lento (lazy) é o carregamento imediato (eager). Os ganhos de desempenho são especialmente significativos quando inicializar um objeto é custoso, como no caso de acesso a serviços de rede e a listas de objetos de banco de dados (ver JPA e Hibernate). Isso o torna ideal em casos onde o conteúdo é acessado em um servidor de rede, como no caso de sistemas Web[2].

Implementações[editar | editar código-fonte]

Existem quatro formas comuns de aplicação do padrão lazy loading: a inicialização lenta; um proxy virtual; um fantasma; e uma interface value holder.[3][4] Cada uma tem suas vantagens e desvantagens.

A inicialização lenta[editar | editar código-fonte]

Com a inicialização lenta, o objeto a ser carregado de modo lazy é originalmente definido como nulo, e todos os pedidos para o objeto verificam antes se ele está nulo e o criam "on the fly" antes de retorná-lo, como no seguinte exemplo em C#:

private int myWidgetID;
private Widget myWidget = null;
 
public Widget MyWidget 
{
    get 
    {
        if (myWidget == null) 
        {
            myWidget = Widget.Load(myWidgetID);
        }
        
        return myWidget;
    }
}

Outro exemplo:

private int myWidgetID;
private Widget myWidget = null;

public Widget MyWidget 
{
   get { return myWidget = myWidget ?? Widget.Load(myWidgetID);  }
}

Este método é o mais simples de implementar, embora se o valor nulo é um valor legítimo de retorno, pode ser necessário o uso de um objeto reservado para sinalizar que o objeto principal não foi inicializado.

Proxy virtual[editar | editar código-fonte]

Proxy Virtual é um objeto com a mesma interface que o objeto real. A primeira vez que um de seus métodos é chamado ele carrega o objeto real, que é, em seguida, delegado.

Fantasma[editar | editar código-fonte]

Um "fantasma" é um objeto que será carregado em um estado parcial. Ele pode conter apenas o identificador do objeto, mas carrega seus próprios dados na primeira vez que uma de suas propriedades é acessada. Por exemplo, considere que um usuário está prestes a solicitar um conteúdo através de um formulário on-line. No momento da criação, tudo que sabemos é que o conteúdo será acessado, mas qual ação ou conteúdo será utilizado é desconhecido. Exemplo em PHP:

$userData = array (
    "UID" = > uniqid(),
    "requestTime" => microtime( true ),
    "dataType" => "",
    "request" => ""
);

if (isset( $_POST['data'] ) && $userData) {
    //...

}

Interface value holder[editar | editar código-fonte]

É uma interface (genérica) utilizada na manipulação do carregamento lento, fazendo as vezes do objeto:

private ValueHolder<Widget> valueHolder;
 
public Widget MyWidget 
{
    get
    {
        return valueHolder.GetValue();
    }
}

Veja também[editar | editar código-fonte]

Referências

  1. «O que é Lazy Loading e Eager Loading?». pt.stackoverflow.com. Consultado em 23 de fevereiro de 2018 
  2. «Lazy Loading». webpack.js.org. Consultado em 23 de fevereiro de 2018 
  3. Martin Fowler, Patterns of Enterprise Application Architecture, Addison-Wesley, 2003, pp.200-214. ISBN 0-321-12742-0.
  4. «How to: Use Lazy Loading to Load Related Objects». msdn.microsoft.com. Consultado em 23 de fevereiro de 2018 
Ícone de esboço Este artigo sobre programação de computadores é um esboço. Você pode ajudar a Wikipédia expandindo-o.