Funzioni di callback in Java

Question

Esiste un modo per passare una funzione di richiamata in un metodo Java?

Il comportamento che sto cercando di imitare è un delegato .Net che viene passato a una funzione.

Ho visto persone che suggerivano di creare un oggetto separato ma sembra eccessivo, tuttavia sono consapevole che a volte l'eccesso è l'unico modo per fare le cose.

Answer 1

Se intendi qualcosa come un delegato anonimo .NET, penso che anche la classe anonima Java possa essere utilizzata.

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));

    }
}

Answer 2

Da Java 8, ci sono riferimenti lambda e metodo:

• Oracle Docs: Lambda Expressions
• Oracle Docs: Riferimenti ai metodi

Ad esempio, definiamo:

public class FirstClass {
    String prefix;
    public FirstClass(String prefix){
        this.prefix = prefix;
    }
    public String addPrefix(String suffix){
        return prefix +":"+suffix;
    }
}

e

import java.util.function.Function;

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

Quindi puoi fare:

FirstClass first = new FirstClass("first");
SecondClass second = new SecondClass();
System.out.println(second.applyFunction("second",first::addPrefix));

Puoi trovare un esempio su github, qui: julien-diener / MethodReference .

Answer 3

Per semplicità, puoi utilizzare un eseguibile :

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

Utilizzo:

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

Answer 4

Un po 'di nitpicking:

  

Sembro persone che suggeriscono di creare un   oggetto separato ma sembra   eccessivo

Il passaggio di un callback include la creazione di un oggetto separato in quasi tutti i linguaggi OO, quindi difficilmente può essere considerato eccessivo. Ciò che probabilmente intendi è che in Java, ti richiede di creare una classe separata, che è più dettagliata (e più dispendiosa in termini di risorse) rispetto ai linguaggi con funzioni o chiusure esplicite di prima classe. Tuttavia, le classi anonime riducono almeno la verbosità e possono essere utilizzate in linea.

Answer 5

eppure vedo che c'è il modo più preferito che era quello che stavo cercando .. è fondamentalmente derivato da queste risposte ma ho dovuto manipolarlo per renderlo più ridondante ed efficiente .. e penso che tutti stiano cercando mi viene in mente

Al punto ::

prima rendi un'interfaccia così semplice

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

ora per eseguire questo callback ogni volta che vuoi fare per gestire i risultati - più probabilmente dopo la chiamata asincrona e vuoi eseguire alcune cose che dipendono da questi riusci

// 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 è la funzione che richiede del tempo per aggiungere un callback ad esso per avvisare quando arrivano i risultati, aggiungere l'interfaccia di callback come parametro a questo metodo

spero che il mio punto sia chiaro, divertiti;)

Answer 6

Questo è molto semplice in Java 8 con 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();
    }
}

Answer 7

Ho trovato interessante l'idea di implementare usando la libreria refl e ho trovato questo che penso funzioni abbastanza bene. L'unico lato negativo è perdere il controllo del tempo di compilazione che stai passando parametri validi.

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;
    }
}

Lo usi in questo modo

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);
        }
    }
}

Answer 8

Un metodo non è (ancora) un oggetto di prima classe in Java; non è possibile passare un puntatore a funzione come callback. Invece, crea un oggetto (che di solito implementa un'interfaccia) che contenga il metodo che ti serve e passalo.

Sono state fatte proposte di chiusure in Java & # 8212; che fornirebbero il comportamento che stai cercando & # 8212; ma nessuna sarà inclusa nella prossima versione di Java 7.

Answer 9

Quando ho bisogno di questo tipo di funzionalità in Java, di solito utilizzo modello di osservatore . Implica un oggetto in più, ma penso che sia un modo pulito di procedere, ed è un modello ampiamente compreso, che aiuta con la leggibilità del codice.

Answer 10

Controlla le chiusure su come sono state implementate nella libreria lambdaj. In realtà hanno un comportamento molto simile ai delegati C #:

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

Answer 11

Ho provato a usare java.lang.reflect per implementare 'callback', ecco un esempio:

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 ();
    }
}

Answer 12

Puoi anche eseguire il Callback usando il modello Delegate :

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);
    }
}

Answer 13

Di recente ho iniziato a fare qualcosa del genere:

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);
    }
}

Answer 14

è un po 'vecchio, ma comunque ... Ho trovato piacevole la risposta di Peter Wilkinson, tranne per il fatto che non funziona per tipi primitivi come int / Integer. Il problema è il .getClass () per i parametri [i] , che restituisce ad esempio java.lang.Integer , che dall'altro la mano non verrà interpretata correttamente da getMethod (methodName, parametri []) (errore di Java) ...

L'ho combinato con il suggerimento di Daniel Spiewak ( nella sua risposta a questo ); passi per il successo inclusi: cattura NoSuchMethodException - > getMethods () - > cercando quello corrispondente per method.getName () - > e quindi scorrere esplicitamente l'elenco dei parametri e applicare la soluzione Daniels, identificando tali corrispondenze di tipo e corrispondenze di firma.

Answer 15

Penso che usare una classe astratta sia più elegante, in questo modo:

// 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
*/

Answer 16

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"

Fondamentalmente se vuoi creare l'oggetto di un'interfaccia lo è impossibile, perché l'interfaccia non può avere oggetti.

L'opzione è di permettere a qualche classe di implementare l'interfaccia e quindi chiamare quella funzione usando l'oggetto di quella classe. Ma questo approccio è davvero dettagliato.

In alternativa, scrivi il nuovo HelloWorld () (* osserva che questa è un'interfaccia non una classe) e poi seguila con la definizione dei metodi di interfaccia stessi. (* Questa definizione è in realtà la classe anonima). Quindi ottieni il riferimento all'oggetto attraverso il quale puoi chiamare il metodo stesso.

Answer 17

Crea un'interfaccia e crea la stessa proprietà dell'interfaccia nella classe di callback.

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");
   }

}

Ora nella classe in cui vuoi essere richiamato, implementa l'interfaccia creata sopra. e passa anche " questo " Oggetto / Riferimento della tua classe da richiamare.

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);
    }
}