Question

Dependency injection is a useful technique but what approach is recommended when faced with runtime dependencies?

e.g. Say you want to glue an event to an event processor depending on the type of the event and the user who initiated the request.

public interface Event {}

public interface EventProcessor {
    public void handleEvent(Event e);
}

class EventProcessorFactory {
    private final User u;
    private final Event e;

    public EventProcessorFactory(User u, Event e) {
        this.u = u;
        this.e = e;
    }

    public EventProcessor get() {
        EventProcessor ep;
        if(e instanceof LocalEvent) {
            ep = new LocalEventProcessor();
        }
        else if(e instanceof RemoteTriggeredEvent && u instanceof AdminUser) { 
            //has static dependencies
            ep = new RemoteEventProcessor(u);
        }
        else {
            ep = new DefaultEventProcessor();
        }
    }
}

Now the complexity is encapsulated in the factory, but how else could I achieve the same result, without too much boilerplate code?

Answer 1

You could use something like

public interface EventProcessor {
    public boolean supports(Event event, User user);
    public void handleEvent(Event event);
}

class EventProcessorFactory {
    public void setEventProcessors(List<EventProcessor> processors) {
        this.processors = processors;
    }
    public EventProcessor get(Event event, User user) {
        for (EventProcessor processor : processors) {
            if (processor.supports(event, user)
                return processor;
        }
    }
}

class LocalEventProcessor implements EventProcessor {
   public boolean supports(Event event, User user) {
        return (event instanceof LocalEvent);
   }
   // etc
}

class RemoteEventProcessor implements EventProcessor {
    public boolean supports(Event event, User user) {
        return (event instanceof RemoteTriggeredEvent) &&
               (user instanceof AdminUser);
    }
    // etc
}

If your processors have some sort of natural ordering, you can implement Comparable to ensure they are tested in the correct order, otherwise you’ll can rely on them being injected into the factory in the required order, thus making it configurable.