Errai: The browser as a platform

Tuesday, June 21, 2011

Pervasive CDI: Errai at the JBoss World Keynote


JBoss World kicked off with a real cool keynote presentation which represented a confluence of JBoss’s cutting-edge technology.

The demo brought together JBoss AS, Infinispan, HibernateOGM, CDI and Errai.

Of course, our little part of the presentation was the demonstration of Errai powering a real-time tag cloud which really brought home the concept of the "real-time web"; most certainly not something which hasn’t been done before, but it was how we did it that makes it interesting.

I'm not going to rehash too much of what has already been said in the aforementioned blog posts, and I highly recommend you click the hyperlinks and check them out. Instead, I'm going to talk about CDI and Errai.

CDI is a technology we’re pushing really aggressively at JBoss, and Errai is no exception. In fact, we’re relatively sure that we’re the one and only in-browser CDI engine.

It was only natural we’d want to show this off at JBoss World. And that we did.

The demo involved bringing in a live tweet stream from Twitter and then producing real-time information based on what hashtags were most popular. The key was to have a fully dynamic tag cloud which would be updated the instant that the information was available. And as such, we used Errai’s push technology to display the information to every browser simultaneously and in real time.

CDI in the Browser

So what does CDI in the browser look like? Well, this might come as a shock: it looks exactly as it does in your server-side code. Consider the following server code:

@ApplicationScoped
public class MyService {
    @Inject @Updated
    private <>Event updatedTagEvent; 

    ... 

}

And now consider the following client GWT code:

public void onTagUpdated(@Observes @Updated Tag tag) {
    System.out.println("Tag was updated: " + tag)
}

In the former code snipped we setup a CDI event consumer, and in the latter, we setup a CDI event observer. Believe it or not, that’s pretty much everything you need to know about push messaging with Errai CDI.

In fact, this is exactly how our tag cloud was updated. Using our transparent push mechanism, serialization and bus framework, all of the boilerplate associated with doing “push” is eliminated.

Yes, it’s that cool. I’m not going to show you a bunch of XML , property or boilerplate class files because, well, there are none.

As a developer you simply want to think about your logic and your data. Utilizing Errai and CDI to build your rich web applications allows you to do just that.

How does it work?

Errai is very much a compile-time framework. In order to provide the runtime infrastructure to transparently communicate between browser code (written in GWT) and the server, we provide a significant amount of code generation to support functionality based on declarative configuration.

For instance, we provide a straight forward annotation, @ExposeEntity which effectively instructs Errai to produce marshaller and demarshaller wrappers -- ultimately compiled down to JavaScript -- for the entity.

The other aspect of Errai is a powerful messaging bus which, consistently with Errai’s “pervasive” theme, runs concurrently in the browser and on the server. As opposed to thinking about client vs server, we have aggressively pursued a flat architecture where the client and server APIs are common and shared. So there isn’t one way to write server code for Errai and another way to write client code.

This also provides the underlying application with transport agnosticism. That is to say, this only contract is between the bus APIs and the client code for all client-server communication. Or even more high-level in the case of Errai CDI, between the application and the CDI eventing system. This means the method of communication, be it WebSockets or COMET is invisible to the application. Developers no longer need to worry about the particularities of working with those technologies.

The future?

We think the future of the web is rich applications. But not only that pervasive applications. And the demo we showed at JBoss World which can be viewed here at about 35 minutes into the presentation is merely a taste of how powerful pervasive computing can be.

Thursday, April 21, 2011

Latest enhancements to the Errai CDI integration module

CDI event qualifiers
The Errai CDI integration module (see a previous blog post) has support for event qualifiers now, both for event producers and observers. Multiple qualifiers can be specified for an event and of course custom qualifiers can be used.
CDI conversations
The simple use of @Conversational allows a server to directly address a single client in response to an event.
BusReadyEvent
Clients can observe a BusReadyEvent to be notified when the CDI event system has been initialized and the message bus is ready to be used.

The example code below shows how to use these new features. Notice again the use of a uniform API on both the client and server.  For more details on Errai's CDI support see the online documentation. Any feedback is appreciated!

@EntryPoint
public class SimpleDocumentClient extends LayoutPanel {

    @Inject
    private Event<DocumentSubscription> documentSubscriptionEvent;

    @Inject @Published
    private Event<Document> publishedDocumentEvent;

    public void buildUI(@Observes BusReadyEvent busReadyEvent) {
        documentSubscriptionEvent.fire(new DocumentSubscription());
        // ...
        new Button().addClickHandler(new ClickHandler() {
            public void onClick(ClickEvent event) {
                publishedDocumentEvent.fire(new Document());
            }
        });
    }

    public void onDocumentsReceived(@Observes Documents document) {
        // this event is received as a direct response to the subscription event
        // ...
    }

    public void onDocumentCreated(@Observes @New Document document) {
       // ...
    }

    public void onDocumentUpdated(@Observes @Updated Document document) {
       // ...
    }

    public void onDocumentDeleted(@Observes @Deleted Document document) {
       // ...
    }
}

@ApplicationScoped
public class SimpleDocumentService {

    @Inject
    private Event<Documents> subscriptionResponseEvent;
    @Inject @New
    private Event<Document> documentCreatedEvent;

    @Inject @Updated
    private Event<Document> documentUpdatedEvent;

    @Inject @Deleted
    private Event<Document> documentDeletedEvent;
   
    @Conversational
    public void onDocumentSubscription(@Observes DocumentSubscription subscription) {
        Documents documents = new Documents();
        //...
        // respond to the client directly
        subscriptionResponseEvent.fire(documents);
    }

    public void onDocumentPublished(@Observes @Published Document document) {
        // receive document published events from the clients
        //...
    }
    private void createDocument(Document document) {
        // ...
        documentCreatedEvent.fire(document);
    }
    private void updateDocument(Document document) {
        // ...
        documentUpdatedEvent.fire(document);
    }
    private void deleteDocument(Document document) {
        // ...
        documentDeletedEvent.fire(document);
    }
}

Thursday, March 24, 2011

Errai 1.2 released.

I am pleased to announce the public release of Errai 1.2. This is a maintenance release on Errai, with big fixes, better support for CDI integration and so on.

Existing users of Errai 1.1 should be able to directly upgrade to 1.2.

We have recently expanded our team and we plan on aggressively pushing the project in new and exciting directions going forward. So please check this space often. There's a lot in the offing.

Tuesday, October 19, 2010

Community Asylum Podcast

This time we got Heiko and Pete talking with us about JUDCon Berlin and Heiko's work on the Errai project.

As usual we also cover short news from the JBoss Community, but if you've wondered what Errai actually is and what it brings to the table then take a listen from about 30 minutes in, Heiko outlines it all in this episode.

Get it here

Saturday, October 16, 2010

Slides from JUDCon Berlin

"Errai offers a set of components for building rich web applications using The Google Web Toolkit. The framework provides a unified federation and RPC infrastructure with true, uniform, asynchronous messaging across the client and server.

It extends the Google Web Toolkit in two distinct areas:

- True asynchronous bi-directional communication between GWT clients and backend systems
- Integration with enterprise component models and technologies.


In this session we'll look at CDI integration module. It offers seamless integration of CDI backend components with GWT client applications. Build as an extension to the Errai core framework, it allows you to transparently access CDI beans while harnessing the power of the core framework.

Beans that are deployed to a CDI container (i.e. JBoss 6) will automatically be registered with Errai and exposed to your GWT client application. Communication between GWT client components and CDI beans can be done in several ways:

- RPC style invocations on beans through a typed interface
- Access beans in a publish/subscribe manner
- Wiring up your GWT application with the CDI event subsystem


After this session you should have a good idea about the core framework capabilities and CDI integration in particular."