Guia Prático sobre Proxies Dinâmicos em Java

Por Gaspar Barancelli Junior em 16 de maio de 2024

Dynamic Proxies são uma funcionalidade poderosa e flexível da Java Virtual Machine (JVM) que permite a criação de objetos proxy em tempo de execução. Esses proxies podem interceptar e manipular chamadas de métodos, oferecendo uma maneira eficiente de implementar padrões de design como o Proxy e Decorator. Neste post, vamos explorar em detalhes o conceito de Dynamic Proxies, seus usos práticos e como implementá-los em Java.

O que são Dynamic Proxies?

Dynamic Proxies permitem que você crie um objeto que implemente uma ou mais interfaces em tempo de execução. Este objeto pode interceptar chamadas de método feitas para ele, delegando a lógica de execução para um manipulador de invocação (InvocationHandler). Isso é particularmente útil para adicionar comportamento adicional, como logging, autenticação, e transações, sem modificar o código original.

Como funcionam?

A criação de um Dynamic Proxy em Java envolve três componentes principais:

Interfaces: O proxy deve implementar uma ou mais interfaces.
InvocationHandler: Define a lógica que será executada quando um método do proxy for chamado.
Proxy Class: Gera dinamicamente a classe proxy em tempo de execução.

Exemplo Prático: Logging com Dynamic Proxies

Vamos começar com um exemplo simples onde utilizamos Dynamic Proxies para adicionar funcionalidades de logging a um serviço.

import java.lang.reflect.*;

interface Servico {
    void executar();
}

class ServicoReal implements Servico {
    public void executar() {
        System.out.println("Executando serviço real...");
    }
}

class LoggingInvocationHandler implements InvocationHandler {
    private Object realObject;

    public LoggingInvocationHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Iniciando método: " + method.getName());
        Object result = method.invoke(realObject, args);
        System.out.println("Método finalizado: " + method.getName());
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Servico servicoReal = new ServicoReal();
        Servico servicoProxy = (Servico) Proxy.newProxyInstance(
                servicoReal.getClass().getClassLoader(),
                new Class[]{Servico.class},
                new LoggingInvocationHandler(servicoReal)
        );

        servicoProxy.executar();
    }
}

Neste exemplo, criamos um proxy para o ServicoReal que adiciona logs antes e depois da execução do método executar.

Iniciando método: executar
Executando serviço real...
Método finalizado: executar

Exemplo Prático: Autorização com Dynamic Proxies

Agora, vamos ver um exemplo onde utilizamos Dynamic Proxies para adicionar uma camada de autorização antes da execução de um método.

import java.lang.reflect.*;

interface Recurso {
    void acessar();
}

class RecursoReal implements Recurso {
    public void acessar() {
        System.out.println("Acessando recurso...");
    }
}

class AuthorizationInvocationHandler implements InvocationHandler {
    private Object realObject;

    public AuthorizationInvocationHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (checkAuthorization()) {
            return method.invoke(realObject, args);
        } else {
            throw new SecurityException("Acesso negado!");
        }
    }

    private boolean checkAuthorization() {
        // Lógica de autorização
        return true; // Supondo que a autorização foi concedida
    }
}

public class Main {
    public static void main(String[] args) {
        Recurso recursoReal = new RecursoReal();
        Recurso recursoProxy = (Recurso) Proxy.newProxyInstance(
                recursoReal.getClass().getClassLoader(),
                new Class[]{Recurso.class},
                new AuthorizationInvocationHandler(recursoReal)
        );

        recursoProxy.acessar();
    }
}

Neste exemplo, o proxy adiciona uma verificação de autorização antes de permitir o acesso ao método acessar.

Vantagens dos Dynamic Proxies

Flexibilidade: Permite adicionar funcionalidades transversais como logging, segurança e transações sem modificar o código original.
Redução de código duplicado: Ao encapsular lógica transversal em proxies, você evita duplicação de código.
Modularidade: Facilita a separação de preocupações, tornando o código mais modular e fácil de manter.

Desvantagens

Complexidade: Pode adicionar complexidade ao código, especialmente para desenvolvedores iniciantes.
Performance: Pode introduzir uma pequena sobrecarga de desempenho devido à reflexão.
Limitações: Só pode ser usado com interfaces, não com classes concretas diretamente.

Conclusão

Dynamic Proxies são uma ferramenta poderosa na JVM para implementar lógica transversal de forma elegante e modular. Eles permitem adicionar comportamento adicional a objetos existentes sem alterar seu código, facilitando a manutenção e a evolução do software. Embora introduzam um pouco de complexidade e sobrecarga de desempenho, seus benefícios em termos de flexibilidade e redução de código duplicado muitas vezes superam essas desvantagens. Com os exemplos apresentados, você agora tem uma base sólida para começar a explorar e utilizar Dynamic Proxies em seus próprios projetos Java.