Um toque de programação funcional em Java

Com as closures do Java 8 previstas apenas para meados de 2012, surgem outras possibilidades para trabalhar um pouco mais funcionalmente. Enquanto isso não acontece, como podemos fazer para que os conceitos de programação funcional ajudem a escrever o nosso código?

Consideremos o caso de calcular a média ponderada de uma List<Prova>, onde Prova tem nota e peso. Em java teríamos um laço como:

public double mediaPonderada(List<Prova> provas) {
     double somaNotas = 0.0;
     double somaPesos = 0.0;
     for (Prova prova : provas) {
          somaNotas += prova.getNota() * prova.getPeso();
          somaPesos += prova.getPeso();
     }
     return  somaNotas / somaPesos;
}

Mas gostaríamos de algo mais genérico, para poder tirar média ponderada de qualquer objeto. A abordagem padrão em java é extrair uma interface com os getters para o valor da nota e para o peso, e fazer com que Prova implemente essa interface:

public interface Ponderavel {
    double getValor();
    double getPeso();
}
public class Prova implements Ponderavel {...}

Assim a implementação do mediaPonderada ficaria:

public double mediaPonderada(List<Ponderavel> ponderaveis) {
     double soma = 0.0;
     double somaPesos = 0.0;
     for (Ponderavel ponderavel : ponderaveis) {
          soma += ponderavel.getValor() * ponderavel.getPeso();
          somaPesos += ponderavel.getPeso();
     }
     return  soma / somaPesos;
}

E o que acontece se não pudermos (ou não quisermos) implementar a interface só pra chamar o método mediaPonderada? Teríamos que usar, então, a mesma abordagem que o Collections.sort, e criar uma outra interface para poder calcular a média ponderada de uma lista qualquer:

public interface Ponderante<T> {
    double valorDe(T t);
    double pesoDe(T t);
}

assim a chamada do método ficaria:

List<Prova> provas = ...;
double media = mediaPonderada(provas, new Ponderante<Prova>() {
     public double valorDe(Prova prova) {
          return prova.getNota();
     }
     public double pesoDe(Prova prova) {
          return prova.getPeso();
     }
});

Isso resolve o problema de uma forma geral, mas prejudica bastante a leitura da chamada do método com a criação da classe anônima. Para quem já programou em Scala ou em alguma outra linguagem funcional, a abordagem natural seria passar os métodos a serem chamados nos objetos da lista como argumentos do método mediaPonderada. Por exemplo, o código em Scala seria:

var media = mediaPonderada(provas, _.nota, _.peso)
...

Nesse código chamaremos os métodos nota e peso (os equivalentes aos getters de java) em cada elemento da lista provas, usando-os como valor e peso. Mas será que conseguimos fazer algo parecido com isso no java que temos hoje em dia? A resposta é sim, basta deixarmos de lado alguns dos nossos preconceitos e usarmos a criatividade.

A primeira coisa que precisamos é receber os métodos que serem chamados como parâmetro do mediaPonderada. Poderíamos usar o java.lang.Method para isso, mas para evitar a grande quantidade de exceptions que deveriam ser tratadas e a programação orientada a string, usaremos a Function do Google Guava:

public <T> double mediaPonderada(List<T> lista, Function<T, Double> valor, Function<T, Double> peso) {
     double soma = 0.0;
     double somaPesos = 0.0;
     for (T t : lista) {
          soma += valor.apply(t) * peso.apply(t);
          somaPesos += peso.apply(t);
     }
     return  soma / somaPesos;
}

A princípio a chamada do método não melhorou muito:

double media = mediaPonderada(provas, new Function<Prova, Double>() {
          public Double apply(Prova p) {
               return p.getNota();
          }
      }, new Function<Prova, Double>() {
          public Double apply(Prova p) {
               return p.getPeso();
          }
      });

Agora precisamos criar uma forma de capturar uma chamada de método e transformá-la numa Function. Para capturar a chamada, podemos usar um proxy, que é uma classe filha de uma interface ou classe em que podemos controlar o seu comportamento através de um MethodInterceptor, que intercepta todas as chamadas de métodos. O VRaptor já possui um criador de proxies pronto, o ObjenesisProxifier, que torna bem simples o processo de criar um proxy.

Vamos, então, criar uma classe e um método para poder criar esse proxy facilmente e guardar o método capturado num um pouco deselagante ThreadLocal (para possibilitar uma maior flexibilidade, deveríamos guardar uma pilha de métodos e argumentos):

public class Funcional {
   private static final ThreadLocal<Method> method = new ThreadLocal<Method>();
   private static final ThreadLocal<Object[]> args = new ThreadLocal<Object[]>();
   public static <T> T of(Class<T> type) {
        return new ObjenesisProxifier().proxify(type, new MethodInvocation<T>() {
            public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) {
                 Funcional.method.set(method);
                 Funcional.args.set(args);
                 return null;
            }
        });
   }
}

Estamos usando métodos estáticos para poder usar o import static e deixar o código um pouco mais legível, e precisamos do ThreadLocal para podermos armazenar o método chamado sem se preocupar com problemas de concorrência. Agora precisamos de um outro método que transforma o método capturado numa Function:

   public static <T,F> Function<T,F> function() {
       final Method method = method.get();
       final Object[] args = args.get();
       return new Function<T,F>() {
            public T apply(F f) {
                return (T) new Mirror().on(f).invoke()
                    .method(method).withArgs(args);
            }
       };
   }

Usamos aqui o Mirror, que permite invocar o método via reflexão envelopando as checked exceptions da API de reflection em exceções de runtime. Assim, para conseguir criar a Function só precisaríamos chamar o método of antes:

of(Prova.class).getNota();
Function<Prova, Double> getNota = function();
of(Prova.class).getPeso();
Function<Prova, Double> getPeso = function();
double media = mediaPonderada(provas, getNota, getPeso);

E se tirarmos vantagem da ordem de chamada dos métodos em java podemos fazer com que o método function receba um parâmetro, que será ignorado:

public <F,T> Function<F,T> function(T ignorado) {...}

Assim podemos invocar:

Function<Prova, Double> getNota = function(of(Prova.class).getNota());
Function<Prova, Double> getPeso = function(of(Prova.class).getPeso());
double media = mediaPonderada(provas, getNota, getPeso);

Ou ainda (com um pequeno truque por causa da inferência de tipos genéricos do java):

double media = mediaPonderada(provas, function(of(Prova.class).getNota()), function(of(Prova.class).getPeso()));
...
public <T> Function<Prova,T> function(T ignorado) {
    return Funcional.function(ignorado);
}

Extraindo o of(Prova.class) para uma constante chamada _, chegamos em algo bem próximo à sintaxe do Scala:

private static Prova _ = of(Prova.class);
...
double media = mediaPonderada
    (provas, function( _.getNota()), function( _.getPeso()));
...

Aqui trocamos a complexidade da implementação – e até um pouco de performance – pela legibilidade e extensibilidade do uso desse código (poderíamos usar essa function em várias das classes do Guava, por exemplo), mesmo abusando de recursos e estruturas polêmicas – como ThreadLocal e métodos estáticos. E essa é uma abordagem que vem sendo usada em várias bibliotecas, como JUnit, Hamcrest e Mockito. É importante notar também que muitas das idéias desse código final vieram do Scala, e de outras linguagens funcionais, reforçando a importância de aprender várias linguagens de programação.

Esse é um exemplo do malabarismo que podemos fazer com java e proxies, e o resultado ainda é um pouco difícil de ler. A abordagem do Java 8 vai ajudar a divulgar essas técnicas, com uma sintaxe muito mais adequada. O código completo pode ser visualizado aqui. Para quem gostou desse tipo de manipulação, existe o projeto LambdaJ que adiciona várias características funcionais ao java, deixando alguns códigos, como o que vimos acima, mais concisos e legíveis.

10 Comentários

  1. Rdorigo Urubatan 23/02/2011 at 10:45 #

    É bom saber que isto é possível em java, eu nunca tinha pensado em nada parecido 😀
    mas eu ainda prefiro usar Scala para este tipo de código 😀

  2. Frankyston Lins 24/02/2011 at 12:26 #

    bem interessante, é um forma bem util de programar, e nunca tinha pensando dessa maneira, parabens pelo artigo, e obrigado por disponibilizar tal conhecimento 😀

  3. Paulo "JCranky" Siqueira 25/02/2011 at 17:04 #

    Posso estar falando besteira, mas a maneira como ficou isso em Java, com classe Function e talz, me parece com o que Scala faz internamente.

    Eu não tinha parado para pensar em aplicar isso em Java “puro”… interessante. Pode ser útil para quem estiver trabalhando em um ambiente restrito, que não permita o uso de Scala hehehe

  4. Bruno Palaoro 11/03/2011 at 11:39 #

    O nome da matéria deveria ser como matar uma formiga com um canhão.

  5. Yuri 26/03/2011 at 12:25 #

    Concordo com o Bruno.

  6. Renato 02/04/2011 at 01:54 #

    Eu acho que é matando a formiga com o canhão que se aprende a matar coisas maiores depois. Muito bom o artigo, obrigado por compartilhar. Abrazzz!

  7. Pedro 21/07/2012 at 16:19 #

    Não achei exagero, mas nesse caso eu acho que o uso da interface Ponderavel parece mais certo, provavelmente por conta de tanta gambiarra, espero que o Java torne-se mais agressivo e traga Orientação a Aspectos e Programação Funcional nativos. Quem sabe ate mesmo um trato no sistema de tipagem. Tornaria Java não somente a linguagem do momento mais também a mais poderosa.

  8. Grécio 24/11/2012 at 13:54 #

    Eh, em relação a funcional, c# ainda na frente. =(

  9. Paulo Silveira 26/11/2012 at 12:58 #

    e mesmo com Java 8, c# continuara muito na frente. mas o objetivo nao é ser uma disputa.

Deixe uma resposta