Subscription model with generics - implement multiple generic interfaces

Question

So I tried to make a subscription model with generics.. it looked nice, but now I'm running into some issues.

Receiver

public interface Receiver<E> {
    public void receive(E event);
}

Subscription registry

public class ClientRegistry<T> {
    private Set<Receiver<T>> clients = new HashSet<Receiver<T>>();

    public void subscribe(Receiver<T> client) {
        clients.add(client);
    }

    public void unsubscribe(Receiver<T> client) {
        clients.remove(client);
    }

    public void broadcast(T eventObject) {
        for(Receiver<T> client: clients) {
            client.receive(eventObject);
        }       
    }   
}

Sounds good so far, eh?

Now the problems come:

public class Screen implements Receiver<KeyEvent>, Receiver<MouseMoveEvent> {
    @Override
    public void receive(KeyEvent event)
    {
        // work
    }

    @Override
    public void receive(MouseMoveEvent event)
    {
        // work
    }
}

Now this is invalid syntax:

The interface Receiver cannot be implemented more than once
with different arguments: Receiver<MouseMoveEvent> and Receiver<KeyEvent>

How can I alter my system to keep it as generic as possible, but make it work?

As far as I know, even without generics, you cannot implement an interface twice. — Edwin Dalorzo, Mar 29 '14 at 15:13
Yeah, that's why I thought with generics I will be able to. Anyway, how to do it in a better way? — MightyPork, Mar 29 '14 at 15:14
why can't you program directly to the interface? (implements Receiver)? — m09, Mar 29 '14 at 15:14
it actually doesn't matter as long as it is a base class of KeyEvent and MouseMoveEvent — m09, Mar 29 '14 at 15:15
Now I've added the receive methods to the question, so it's cleaner. Do you think this will work if both extend Event? — MightyPork, Mar 29 '14 at 15:17
Actually it won't work, - you won't be able to subscribe such class to a registry. — MightyPork, Mar 29 '14 at 15:18
you'd have to use only the event api to write your receive method and take an Event parameter, so that you can declaire implements Receiver — m09, Mar 29 '14 at 15:22
Yes, but then what? Some `instanceof` jungle to differentiate the events? — MightyPork, Mar 29 '14 at 15:22
no, you'd use the different subclasses of events and virtual methods to achieve different behavior when needed. You should look up a book on OOP — m09, Mar 29 '14 at 15:23
Event holds some data, so I need getters for that. How would your solution deal with that? — MightyPork, Mar 29 '14 at 15:24
well the Event class should model that. As I said you should maybe grab some tutorial on OOP to clear things up before coming up with a messed up design. Those issues are basic OOP stuff. — m09, Mar 29 '14 at 15:25
I don't think "read a tutorial" kind of answer is what I need. — MightyPork, Mar 29 '14 at 15:31

score 2 · Answer 1 · answered Mar 29 '14 at 15:34

Don't make the Screen class itself implement the two Receiver interfaces. Instead, use composition:

public class Screen {
    private Receiver<KeyEvent> keyReceiver = new Receiver<KeyEvent>() {
        ...
    };

    private Receiver<MouseEvent> mouseReceiver = new Receiver<MouseEvent>() {
        ...
    };
}

score 1 · Accepted Answer · answered Mar 29 '14 at 15:36

I would reverse the order, and use a Visitor Pattern:

import java.util.*;

interface Event{
    void receive(Receiver receiver);    
}

class KeyEvent implements Event{
    @Override
    public void receive(Receiver receiver){
        receiver.receive(this);
    }   
}

class MouseEvent implements Event {
    @Override
    public void receive(Receiver receiver){
        receiver.receive(this);
    }   
}

interface Receiver {
    void receive(KeyEvent event);
    void receive(MouseEvent event);
}

class ClientRegistry {
    private Set<Receiver> clients = new HashSet<Receiver>();

    public void subscribe(Receiver client) {
        clients.add(client);
    }

    public void unsubscribe(Receiver client) {
        clients.remove(client);
    }

    public void broadcast(Event eventObject) {
        for(Receiver client: clients) {
            eventObject.receive(client);
        }       
    }   
}

public class Screen implements Receiver {

    public void receive(KeyEvent event) {
        //work
        System.out.println("Processing key event");
    }
    public void receive(MouseEvent event) {
        //work
        System.out.println("Processing mouse event");
    }


    public static void main(String[] args){
        ClientRegistry registry = new ClientRegistry();
        registry.subscribe(new Screen());
        registry.broadcast(new MouseEvent());
    }
}

There is not way to generify the Receiver interface, but it is indeed type safe and as you can see, I reverse the order, since now it is the event the one which chooses the receiver and not otherwise.

Actually, I'm now using a similar pattern, so I'll give you the point. — MightyPork, Mar 29 '14 at 16:02

Subscription model with generics - implement multiple generic interfaces

2 Answers2