Funções de retorno de chamada em Java

Existe uma maneira de passar uma função de retorno de chamada em um método Java?

O comportamento que estou tentando imitar é um .Net Delegate sendo passado para uma função.

Eu já vi pessoas sugerindo a criação de um objeto separado, mas isso parece exagero, no entanto, estou ciente de que, às vezes, exagero é a única maneira de fazer as coisas.

Se você quer dizer algo como o delegado anônimo do .NET, acho que a classe anônima do Java também pode ser usada.

public class Main {

    public interface Visitor{
        int doJob(int a, int b);
    }


    public static void main(String[] args) {
        Visitor adder = new Visitor(){
            public int doJob(int a, int b) {
                return a + b;
            }
        };

        Visitor multiplier = new Visitor(){
            public int doJob(int a, int b) {
                return a*b;
            }
        };

        System.out.println(adder.doJob(10, 20));
        System.out.println(multiplier.doJob(10, 20));

    }
}

Desde o Java 8, existem referências lambda e método:

• Oracle Docs: Expressões Lambda
• Oracle Docs: referências de método

Por exemplo, se você deseja uma interface funcional A -> Bcomo:

import java.util.function.Function;

public MyClass {
    public static String applyFunction(String name, Function<String,String> function){
        return function.apply(name);
    }
}

então você pode chamar assim

MyClass.applyFunction("42", str -> "the answer is: " + str);
// returns "the answer is: 42"

Além disso, você pode passar o método de classe. Digamos que você tenha:

@Value // lombok
public class PrefixAppender {
    private String prefix;

    public String addPrefix(String suffix){
        return prefix +":"+suffix;
    }
}

Então você pode fazer:

PrefixAppender prefixAppender= new PrefixAppender("prefix");
MyClass.applyFunction("some text", prefixAppender::addPrefix);
// returns "prefix:some text"

Nota :

Aqui eu usei a interface funcional Function<A,B>, mas há muitas outras no pacote java.util.function. Os mais notáveis ​​são

• Supplier: void -> A
• Consumer: A -> void
• BiConsumer: (A,B) -> void
• Function: A -> B
• BiFunction: (A,B) -> C

e muitos outros que se especializam em alguns tipos de entrada / saída. Então, se ele não fornecer o necessário, você poderá criar sua própria interface funcional da seguinte maneira:

@FunctionalInterface
interface Function3<In1, In2, In3, Out> { // (In1,In2,In3) -> Out
    public Out apply(In1 in1, In2 in2, In3 in3);
}

Exemplo de uso:

String computeAnswer(Function3<String, Integer, Integer, String> f){
    return f.apply("6x9=", 6, 9);
}

computeAnswer((question, a, b) -> question + "42");
// "6*9=42"

Para simplificar, você pode usar um Runnable :

private void runCallback(Runnable callback)
{
    // Run callback
    callback.run();
}

Uso:

runCallback(new Runnable()
{
    @Override
    public void run()
    {
        // Running callback
    }
});

Um pouco de nitpicking:

Eu pareço pessoas sugerindo a criação de um objeto separado, mas isso parece um exagero

A passagem de um retorno de chamada inclui a criação de um objeto separado em praticamente qualquer linguagem OO, portanto, dificilmente pode ser considerado um exagero. O que você provavelmente quer dizer é que, em Java, é necessário criar uma classe separada, que é mais detalhada (e consome mais recursos) do que nas linguagens com funções ou fechamentos explícitos de primeira classe. No entanto, classes anônimas pelo menos reduzem a verbosidade e podem ser usadas em linha.

no entanto, vejo que há a maneira mais preferida, que era o que eu estava procurando ... é basicamente derivado dessas respostas, mas eu tive que manipulá-lo para mais redundante e eficiente .. e acho que todo mundo procurando o que eu acho

Ao ponto::

primeiro faça uma interface tão simples

public interface myCallback {
    void onSuccess();
    void onError(String err);
}

Agora, para fazer com que esse retorno de chamada seja executado sempre que desejar, para lidar com os resultados - mais provavelmente após uma chamada assíncrona e você deseja executar algumas coisas que dependem dessas reutilizações

// import the Interface class here

public class App {

    public static void main(String[] args) {
        // call your method
        doSomething("list your Params", new myCallback(){
            @Override
            public void onSuccess() {
                // no errors
                System.out.println("Done");
            }

            @Override
            public void onError(String err) {
                // error happen
                System.out.println(err);
            }
        });
    }

    private void doSomething(String param, // some params..
                             myCallback callback) {
        // now call onSuccess whenever you want if results are ready
        if(results_success)
            callback.onSuccess();
        else
            callback.onError(someError);
    }

}

doSomething é a função que leva algum tempo em que você deseja adicionar um retorno de chamada para notificá-lo quando os resultados vierem, adicione a interface de retorno de chamada como parâmetro a esse método

espero que meu ponto seja claro, aproveite;)

Isso é muito fácil no Java 8 com lambdas.

public interface Callback {
    void callback();
}

public class Main {
    public static void main(String[] args) {
        methodThatExpectsACallback(() -> System.out.println("I am the callback."));
    }
    private static void methodThatExpectsACallback(Callback callback){
        System.out.println("I am the method.");
        callback.callback();
    }
}

Achei interessante a ideia de implementar usando a biblioteca reflect e cheguei a isso que acho que funciona muito bem. O único lado negativo é perder a verificação do tempo de compilação de que você está passando parâmetros válidos.

public class CallBack {
    private String methodName;
    private Object scope;

    public CallBack(Object scope, String methodName) {
        this.methodName = methodName;
        this.scope = scope;
    }

    public Object invoke(Object... parameters) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Method method = scope.getClass().getMethod(methodName, getParameterClasses(parameters));
        return method.invoke(scope, parameters);
    }

    private Class[] getParameterClasses(Object... parameters) {
        Class[] classes = new Class[parameters.length];
        for (int i=0; i < classes.length; i++) {
            classes[i] = parameters[i].getClass();
        }
        return classes;
    }
}

Você usa assim

public class CallBackTest {
    @Test
    public void testCallBack() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        TestClass testClass = new TestClass();
        CallBack callBack = new CallBack(testClass, "hello");
        callBack.invoke();
        callBack.invoke("Fred");
    }

    public class TestClass {
        public void hello() {
            System.out.println("Hello World");
        }

        public void hello(String name) {
            System.out.println("Hello " + name);
        }
    }
}

Um método ainda não é um objeto de primeira classe em Java; você não pode passar um ponteiro de função como retorno de chamada. Em vez disso, crie um objeto (que geralmente implementa uma interface) que contém o método necessário e passe-o.

Propostas de fechamento em Java - que forneceriam o comportamento que você procura - foram feitas, mas nenhuma será incluída na próxima versão do Java 7.

Quando preciso desse tipo de funcionalidade em Java, geralmente uso o padrão Observer . Isso implica em um objeto extra, mas acho que é um caminho limpo, e é um padrão amplamente compreendido, que ajuda na legibilidade do código.

Verifique os fechamentos como eles foram implementados na biblioteca lambdaj. Na verdade, eles têm um comportamento muito semelhante aos delegados em C #:

http://code.google.com/p/lambdaj/wiki/Closures

Eu tentei usar java.lang.reflect para implementar 'callback', aqui está um exemplo:

package StackOverflowQ443708_JavaCallBackTest;

import java.lang.reflect.*;
import java.util.concurrent.*;

class MyTimer
{
    ExecutorService EXE =
        //Executors.newCachedThreadPool ();
        Executors.newSingleThreadExecutor ();

    public static void PrintLine ()
    {
        System.out.println ("--------------------------------------------------------------------------------");
    }

    public void SetTimer (final int timeout, final Object obj, final String methodName, final Object... args)
    {
        SetTimer (timeout, obj, false, methodName, args);
    }
    public void SetTimer (final int timeout, final Object obj, final boolean isStatic, final String methodName, final Object... args)
    {
        Class<?>[] argTypes = null;
        if (args != null)
        {
            argTypes = new Class<?> [args.length];
            for (int i=0; i<args.length; i++)
            {
                argTypes[i] = args[i].getClass ();
            }
        }

        SetTimer (timeout, obj, isStatic, methodName, argTypes, args);
    }
    public void SetTimer (final int timeout, final Object obj, final String methodName, final Class<?>[] argTypes, final Object... args)
    {
        SetTimer (timeout, obj, false, methodName, argTypes, args);
    }
    public void SetTimer (final int timeout, final Object obj, final boolean isStatic, final String methodName, final Class<?>[] argTypes, final Object... args)
    {
        EXE.execute (
            new Runnable()
            {
                public void run ()
                {
                    Class<?> c;
                    Method method;
                    try
                    {
                        if (isStatic) c = (Class<?>)obj;
                        else c = obj.getClass ();

                        System.out.println ("Wait for " + timeout + " seconds to invoke " + c.getSimpleName () + "::[" + methodName + "]");
                        TimeUnit.SECONDS.sleep (timeout);
                        System.out.println ();
                        System.out.println ("invoking " + c.getSimpleName () + "::[" + methodName + "]...");
                        PrintLine ();
                        method = c.getDeclaredMethod (methodName, argTypes);
                        method.invoke (obj, args);
                    }
                    catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                    finally
                    {
                        PrintLine ();
                    }
                }
            }
        );
    }
    public void ShutdownTimer ()
    {
        EXE.shutdown ();
    }
}

public class CallBackTest
{
    public void onUserTimeout ()
    {
        System.out.println ("onUserTimeout");
    }
    public void onTestEnd ()
    {
        System.out.println ("onTestEnd");
    }
    public void NullParameterTest (String sParam, int iParam)
    {
        System.out.println ("NullParameterTest: String parameter=" + sParam + ", int parameter=" + iParam);
    }
    public static void main (String[] args)
    {
        CallBackTest test = new CallBackTest ();
        MyTimer timer = new MyTimer ();

        timer.SetTimer ((int)(Math.random ()*10), test, "onUserTimeout");
        timer.SetTimer ((int)(Math.random ()*10), test, "onTestEnd");
        timer.SetTimer ((int)(Math.random ()*10), test, "A-Method-Which-Is-Not-Exists");    // java.lang.NoSuchMethodException

        timer.SetTimer ((int)(Math.random ()*10), System.out, "println", "this is an argument of System.out.println() which is called by timer");
        timer.SetTimer ((int)(Math.random ()*10), System.class, true, "currentTimeMillis");
        timer.SetTimer ((int)(Math.random ()*10), System.class, true, "currentTimeMillis", "Should-Not-Pass-Arguments");    // java.lang.NoSuchMethodException

        timer.SetTimer ((int)(Math.random ()*10), String.class, true, "format", "%d %X", 100, 200); // java.lang.NoSuchMethodException
        timer.SetTimer ((int)(Math.random ()*10), String.class, true, "format", "%d %X", new Object[]{100, 200});

        timer.SetTimer ((int)(Math.random ()*10), test, "NullParameterTest", new Class<?>[]{String.class, int.class}, null, 888);

        timer.ShutdownTimer ();
    }
}

Você também pode fazer o Callbackuso do Delegatepadrão:

Callback.java

public interface Callback {
    void onItemSelected(int position);
}

PagerActivity.java

public class PagerActivity implements Callback {

    CustomPagerAdapter mPagerAdapter;

    public PagerActivity() {
        mPagerAdapter = new CustomPagerAdapter(this);
    }

    @Override
    public void onItemSelected(int position) {
        // Do something
        System.out.println("Item " + postion + " selected")
    }
}

CustomPagerAdapter.java

public class CustomPagerAdapter {
    private static final int DEFAULT_POSITION = 1;
    public CustomPagerAdapter(Callback callback) {
        callback.onItemSelected(DEFAULT_POSITION);
    }
}

Recentemente, comecei a fazer algo assim:

public class Main {
    @FunctionalInterface
    public interface NotDotNetDelegate {
        int doSomething(int a, int b);
    }

    public static void main(String[] args) {
        // in java 8 (lambdas):
        System.out.println(functionThatTakesDelegate((a, b) -> {return a*b;} , 10, 20));

    }

    public static int functionThatTakesDelegate(NotDotNetDelegate del, int a, int b) {
        // ...
        return del.doSomething(a, b);
    }
}

é um pouco antigo, mas, no entanto ... achei a resposta de Peter Wilkinson agradável, exceto pelo fato de que não funciona para tipos primitivos como int / Integer. O problema é .getClass()for parameters[i], que retorna por exemplo java.lang.Integer, que por outro lado não será corretamente interpretado por getMethod(methodName,parameters[])(falha de Java) ...

Combinei-o com a sugestão de Daniel Spiewak ( em sua resposta a isso ); os passos para o sucesso incluíam: pegar NoSuchMethodException-> getMethods()-> procurar o correspondente por method.getName()-> e, em seguida, percorrer explicitamente a lista de parâmetros e aplicar a solução Daniels, como identificar as correspondências de tipo e de assinatura.

Eu acho que usar uma classe abstrata é mais elegante, assim:

// Something.java

public abstract class Something {   
    public abstract void test();        
    public void usingCallback() {
        System.out.println("This is before callback method");
        test();
        System.out.println("This is after callback method");
    }
}

// CallbackTest.java

public class CallbackTest extends Something {
    @Override
    public void test() {
        System.out.println("This is inside CallbackTest!");
    }

    public static void main(String[] args) {
        CallbackTest myTest = new CallbackTest();
        myTest.usingCallback();
    }    
}

/*
Output:
This is before callback method
This is inside CallbackTest!
This is after callback method
*/

public class HelloWorldAnonymousClasses {

    //this is an interface with only one method
    interface HelloWorld {
        public void printSomething(String something);
    }

    //this is a simple function called from main()
    public void sayHello() {

    //this is an object with interface reference followed by the definition of the interface itself

        new HelloWorld() {
            public void printSomething(String something) {
                System.out.println("Hello " + something);
            }
        }.printSomething("Abhi");

     //imagine this as an object which is calling the function'printSomething()"
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp =
                new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}
//Output is "Hello Abhi"

Basicamente, se você deseja criar o objeto de uma interface, isso não é possível, porque a interface não pode ter objetos.

A opção é permitir que alguma classe implemente a interface e depois chame essa função usando o objeto dessa classe. Mas essa abordagem é realmente detalhada.

Como alternativa, escreva new HelloWorld () (* observe que essa é uma interface, não uma classe) e siga-a com a definição dos métodos da interface. (* Esta definição é na realidade a classe anônima). Então você obtém a referência do objeto através da qual você pode chamar o próprio método.

Crie uma interface e crie a mesma propriedade de interface na classe de retorno de chamada.

interface dataFetchDelegate {
    void didFetchdata(String data);
}
//callback class
public class BackendManager{
   public dataFetchDelegate Delegate;

   public void getData() {
       //Do something, Http calls/ Any other work
       Delegate.didFetchdata("this is callbackdata");
   }

}

Agora na classe em que você deseja ser chamado de volta, implemente a Interface criada acima. e também passe "este" Objeto / Referência da sua classe para ser chamado de volta.

public class Main implements dataFetchDelegate
{       
    public static void main( String[] args )
    {
        new Main().getDatafromBackend();
    }

    public void getDatafromBackend() {
        BackendManager inc = new BackendManager();
        //Pass this object as reference.in this Scenario this is Main Object            
        inc.Delegate = this;
        //make call
        inc.getData();
    }

    //This method is called after task/Code Completion
    public void didFetchdata(String callbackData) {
        // TODO Auto-generated method stub
        System.out.println(callbackData);
    }
}