How to design communication from a backend server to the frontend using JavaEE (EJB, JSF, PrimeFaces) - jsf

Question

Normally, a frontend such as a web application (e.g. JSF) is used to retrieve data from a system and display it. User interaction is required: a user pulls up a website and e.g. clicks a button which in turn triggers a whole round trip process (view calls controller, controller informs model, model updates and notifies view via controller again).
In my setup I don't have any user interaction because my webapp is a view only. No user can do any CRUD actions (except Read). The "user interaction" comes so to speak from my backend: This system runs the entirety of business logic and receives user interactions through other channels than the webapp.
However, all changes within the backend need to be somehow pushed into the webapp frontend.
I am using JavaEE, more precisely EJB 3.2, JSF 2.2 and PrimeFaces 5.1 (as well as JMS 2.x, WildFly 8.2, OmniFaces 2.0)
My backend communicates changes via JMS. I defined a MessageListener within my webapp that listens to all incoming changes. These changes are pushed into the model (EJBs).
As far as my knowledge goes should a model never know anything about it's view: the model is completely agnostic to the view. In JavaEE terms this means that my EJBs (model) should not inject any ManagedBeans (controller).
Now here is my question: How should the model inform the controller/view about changes, so that they get reflected within the view?
Am I forced to use something like CDI Events?
Or in case of PrimeFaces, should I use PrimeFaces Push (WebSocket implementation using Atmosphere) that kinda simulates a user interaction? In other words, should my JMS MessageListener directly push the changes to all clients (browsers) via WebSocket and then use AJAX to simulate an user interaction (which in turn does nothing else than what a "normal" user would trigger in the webapp)?
Or how about the old fashioned way according to Observer Pattern: Every managed bean that needs to be notified I add as listener to the EJB with help of #PostConstruct and also make sure that the listener gets removed with #PreDestroy?

Answer 1

We found a solution doing it in a "hybrid" mode. Here is what we came up with:
Observer Pattern
We used the classic Observer Pattern: A managed bean adds itself as listener to an EJB, which in turn is updated by the JMS message listener. Therefore, we made use of the #PostConstruct to add a listener as well as #PreDestroy to remove listener respectively whenever the managed bean gets created/destroyed.
In other words, whenever the model gets updated, it informs its listeners, which are the managed beans (controller). But this doesn't yet update the view. Here comes the hybrid mode into play:
PrimeFaces Push
Once the model (EJB) is updated it has to push a notification to it's web clients via PrimeFaces Push. This way all clients know they have to go grab the changes:
#ManagedBean(name = "notifier")
#ApplicationScoped
public class MarketDataPushNotifier implements Serializable {
private final Logger log = LoggerFactory.getLogger(MarketDataPushNotifier.class);
public final static String CHANNEL = "/notify";
private final EventBus eventBus = EventBusFactory.getDefault().eventBus();
public MarketDataPushNotifier() {
// bean instantiation only
}
public void notifyListeners() {
log.info("Sending UI update notification...");
eventBus.publish(CHANNEL, true);
}
}
Of course one can design the notify channel more fine grained. In the view (facelet) do:
<p:remoteCommand name="updateTable" actionListener="#{bean.onUpdate}" update="table" process="#this" />
<!--table snippet ommitted-->
<p:socket onMessage="handleMessage" channel="/notify" autoConnect="true"/>
<script type="text/javascript">
function handleMessage(update) {
if (update) {
updateTable();
}
}
</script>
Hope that helps...