How do I perform a JAVA callback between classes?

Question

I am coming from JavaScript, in which callbacks are pretty easy. I am trying to implement them into JAVA, without success.

I have a Parent class:

import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Server {
    ExecutorService workers = Executors.newFixedThreadPool(10);
    private ServerConnections serverConnectionHandler;

    public Server(int _address) {
        System.out.println("Starting Server...");
        serverConnectionHandler = new ServerConnections(_address);

        serverConnectionHandler.newConnection = function(Socket _socket) {
            System.out.println("A function of my child class was called.");
        };

        workers.execute(serverConnectionHandler);

        System.out.println("Do something else...");
    }
}

Then I have a child class, that is called from the parent:

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ServerConnections implements Runnable {
    private int serverPort;
    private ServerSocket mainSocket;

    public ServerConnections(int _serverPort) {
        serverPort = _serverPort;
    }

    @Override
    public void run() {
        System.out.println("Starting Server Thread...");

        try {
            mainSocket = new ServerSocket(serverPort);

            while (true) {
                newConnection(mainSocket.accept());
            }
        } catch (IOException ex) {
            Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void newConnection(Socket _socket) {

    }
}

What is the right way of implementing the

serverConnectionHandler.newConnection = function(Socket _socket) {
    System.out.println("A function of my child class was called.");
};

part, in the Parent class, which is clearly not correct?

See: http://stackoverflow.com/a/4685606/483588 – Ujjwal Singh Jan 14 '16 at 16:17 — Ujjwal Singh, Jan 14 '16 at 16:17

score 139 · Accepted Answer · edited Jul 13 '21 at 08:23

Define an interface, and implement it in the class that will receive the callback.

Have attention to the multi-threading in your case.

Code example from http://cleancodedevelopment-qualityseal.blogspot.com.br/2012/10/understanding-callbacks-with-java.html

interface CallBack {                   

//declare an interface with the callback methods, 
//so you can use on more than one class and just 
//refer to the interface

    void methodToCallBack();
}

class CallBackImpl implements CallBack {          

//class that implements the method to callback defined 
//in the interface

    public void methodToCallBack() {
        System.out.println("I've been called back");
    }
}

class Caller {

    public void register(CallBack callback) {
        callback.methodToCallBack();
    }

    public static void main(String[] args) {
        Caller caller = new Caller();
        CallBack callBack = new CallBackImpl();       

//because of the interface, the type is Callback even 
//thought the new instance is the CallBackImpl class. 
//This alows to pass different types of classes that have 
//the implementation of CallBack interface

        caller.register(callBack);
    }
}

In your case, apart from multi-threading you could do like this:

interface ServerInterface {
    void newSeverConnection(Socket socket);
}

public class Server implements ServerInterface {

    public Server(int _address) {
        System.out.println("Starting Server...");
        serverConnectionHandler = new ServerConnections(_address, this);
        workers.execute(serverConnectionHandler);
        System.out.println("Do something else...");
    }

    void newServerConnection(Socket socket) {
        System.out.println("A function of my child class was called.");
    }

}

public class ServerConnections implements Runnable {

    private ServerInterface serverInterface;
    
    public ServerConnections(int _serverPort, ServerInterface _serverInterface) {
      serverPort = _serverPort;
      serverInterface = _serverInterface;
    }

    @Override
    public void run() {
        System.out.println("Starting Server Thread...");

        if (serverInterface == null) {
            System.out.println("Server Thread error: callback null");
        }

        try {
            mainSocket = new ServerSocket(serverPort);

            while (true) {
                serverInterface.newServerConnection(mainSocket.accept());
            }
        } catch (IOException ex) {
            Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Multi-threading

Remember this does not handle multi-threading, this is another topic and can have various solutions depending on the project.

The observer-pattern

The observer-pattern does nearly this, the major difference is the use of an ArrayList for adding more than one listener. Where this is not needed, you get better performance with one reference.

What's the point of the interface? Why can't `CallBackImpl` just be a class on its own, without implementing an interface? — CodyBugstein, Oct 01 '15 at 17:43
@Imray By using interface you get the flexibility to register any class which implements CallBack with the Caller. It doesn't have to be just CallBackImpl. — crysis, Nov 05 '15 at 12:31
Isn't this gonna be single thread and blocking? What would be an example for callbacks from different thread? — Weishi Z, Apr 22 '16 at 07:16
@WeishiZeng yes, this is single thread. Multi-threading is not direct related to callback, and the solution will depend on the application. — Diego C Nascimento, Jan 14 '18 at 13:26
@crysis - Thanks a lot of new comers have the question which you answered! — Skynet, Apr 19 '18 at 14:07

William Morrison · Answer 2 · 2017-07-15T15:35:30.897

69

Use the observer pattern. It works like this:

interface MyListener{
    void somethingHappened();
}

public class MyForm implements MyListener{
    MyClass myClass;
    public MyForm(){
        this.myClass = new MyClass();
        myClass.addListener(this);
    }
    public void somethingHappened(){
       System.out.println("Called me!");
    }
}
public class MyClass{
    private List<MyListener> listeners = new ArrayList<MyListener>();

    public void addListener(MyListener listener) {
        listeners.add(listener);
    }
    void notifySomethingHappened(){
        for(MyListener listener : listeners){
            listener.somethingHappened();
        }
    }
}

You create an interface which has one or more methods to be called when some event happens. Then, any class which needs to be notified when events occur implements this interface.

This allows more flexibility, as the producer is only aware of the listener interface, not a particular implementation of the listener interface.

In my example:

MyClass is the producer here as its notifying a list of listeners.

MyListener is the interface.

MyForm is interested in when somethingHappened, so it is implementing MyListener and registering itself with MyClass. Now MyClass can inform MyForm about events without directly referencing MyForm. This is the strength of the observer pattern, it reduces dependency and increases reusability.

edited Jul 15 '17 at 15:35

answered Aug 16 '13 at 18:05

William Morrison

10,953
2
31
48

3

nice explanation, out of all the answers and that basic example that is all over the internet , i understood the use of callbacks from your explanation.. great answer (Y) – Bawa Jun 22 '16 at 11:10
I am not understanding one thing why you are creating instance of MyClass inside constructor of MyForm, because when any body creates the instance of MyClass in some other third class and call the addListener he will create instance of MyForm or any other class derived from MyListener. – Rahul Sonone Jul 16 '16 at 05:45
No. CalLing addListener on an instance of MyClass in other classes will not cause an instance of MyForm to be instantiated. I do agree it may have been better for MyClass to be injected in MyForm's constructor, but I was trying to keep the example simple, and focused on *just* the observer pattern. – William Morrison Jul 17 '16 at 18:38
Well explained, thanks. – Yucel Bayram Jan 14 '19 at 06:01
clean Java code, as straightforward as one could expect. Awesome. – ether_joe Apr 03 '19 at 15:06

score 7 · Answer 3 · answered Aug 16 '13 at 17:52

7

IMO, you should have a look at the Observer Pattern, and this is how most of the listeners work

answered Aug 16 '13 at 17:52

sanbhat

17,522
6
48
64

score 4 · Answer 4 · answered Aug 16 '13 at 18:08

I don't know if this is what you are looking for, but you can achieve this by passing a callback to the child class.

first define a generic callback:

public interface ITypedCallback<T> {
    void execute(T type);
}

create a new ITypedCallback instance on ServerConnections instantiation:

public Server(int _address) {
    serverConnectionHandler = new ServerConnections(new ITypedCallback<Socket>() {
        @Override
        public void execute(Socket socket) {
            // do something with your socket here
        }
    });
}

call the execute methode on the callback object.

public class ServerConnections implements Runnable {

    private ITypedCallback<Socket> callback;

    public ServerConnections(ITypedCallback<Socket> _callback) {
        callback = _callback;
    }

    @Override
    public void run() {   
        try {
            mainSocket = new ServerSocket(serverPort);
            while (true) {
                callback.execute(mainSocket.accept());
            }
        } catch (IOException ex) {
            Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

btw: I didn't check if it's 100% correct, directly coded it here.

How's that if it can implement the default semantic with methods of the interface declared so the code will be more readable, and easy to maintain? — Diego C Nascimento, Aug 16 '13 at 18:57
sorry, but I don't get your question. do you mean, declaring an callback implementation instead of directly instantiating the callback interface? — pichsenmeister, Aug 16 '13 at 19:08

score 1 · Answer 5 · answered Aug 16 '13 at 18:12

In this particular case, the following should work:

serverConnectionHandler = new ServerConnections(_address) {
    public void newConnection(Socket _socket) {
        System.out.println("A function of my child class was called.");
    }
};

It's an anonymous subclass.

How do I perform a JAVA callback between classes?

5 Answers5

Linked