2
respostas

Atualização do valor do orçamento

Me deu a impressão que nessa implementação do proxy se vc alterar o valor do orcamento entre as chamadas do proxy.getValor() o valor do proxy continuaria no R$ 700 sem alterar. Estou correto?

2 respostas

Sim, eu pensei a mesma coisa e fui fazer um teste na classe TestesComposicao, código dele:

        Orcamento antigo = new Orcamento();
        antigo.adicionarItens(new ItemOrcamento(new BigDecimal("200")));
        antigo.reprovar();
        Orcamento novo = new Orcamento();
        novo.adicionarItens(new ItemOrcamento(new BigDecimal("500")));
        novo.adicionarItens(antigo);
        OrcamentoProxy proxy = new OrcamentoProxy(novo);
        System.out.println(proxy.getValor());
        System.out.println(proxy.getValor());
        novo.adicionarItens(new ItemOrcamento(new BigDecimal("300")));
        System.out.println(proxy.getValor());

E no meu console apareceu assim:

700
700
700

O certo era o valor ser 1000 no ultimo System.out.println(proxy.getValor());, pois adicionamos mais 300. O ideal era ter um método que busca ver se o valor armazenado na classe de Orçamento não foi alterado, eu tinha pensando em soluções, mas ela fere o principio do proxy. Se puderem oferecer uma solução, agradeço (e se eu pensar em uma solução, eu volto aqui).

Olá, Ricardo!

Na implementação do proxy, quando você altera o valor do orçamento entre as chamadas do proxy.getValor(), o valor do proxy continuará o mesmo, ou seja, R$ 700. Isso acontece porque o proxy armazena em cache o valor do orçamento na primeira vez que o método getValor() é chamado. Nas chamadas subsequentes, o proxy retorna o valor armazenado em cache, sem precisar acessar novamente o objeto original.

Essa é a ideia do padrão de projeto Proxy: criar um intermediário que intercepta as chamadas ao objeto original e realiza algum tratamento ou otimização. No caso desse exemplo, o proxy simula um cache para evitar acessos repetidos ao objeto original, melhorando a performance.

Um exemplo prático desse padrão é quando você utiliza a JPA (Java Persistence API) para acessar o banco de dados. O Hibernate, por exemplo, utiliza proxies para carregar relacionamentos lazy. Quando você acessa um relacionamento de uma entidade, o Hibernate dispara uma consulta no banco de dados apenas quando você chama o método get do relacionamento. Isso é possível graças ao uso de proxies.

Espero ter ajudado e bons estudos!