This Hibernate (or JPA 2) Persistence Annotations Tutorial contains overview of all important annotations which you may need while annotating your java POJOs to make them act as persistent JPA entities.
CDI events are one of the shiniest feature in the CDI specification. They are a easy to understand and use and are a straight forward implementation of the Observer Design Pattern.
The rules are (from memory): Bean has a @LocalBean annotation -> bean has a no-interface view Bean has a @Local annotation -> bean has a local view Bean has a @Remote annotation -> bean has a remote view Bean has no view annotations, but directly implements an interface which has a @Local annotatio
Now, in another (background) thread, the onMessage method handle the message and fires a new event (which wraps the received event) now annotated with @InBackground qualifier:
* dispatches the message received from the queue and fires a new event (now with the @InBackground qualifier)
*
* @param message
*/
publicvoidonMessage(Message message){
if(!(message instanceofObjectMessage)){
thrownewRuntimeException("Invalid message type received");
}
ObjectMessage msg=(ObjectMessage)message;
try{
Serializable eventObject=msg.getObject();
if(!(eventObject instanceofBaseEvent)){
thrownewRuntimeException("Unknown event type received");
}
BaseEvent evt=(BaseEvent)eventObject;
this.event.fire(evt);
}catch(JMSException ex){
thrownewRuntimeException(ex.getMessage(),ex);
}
}
}
And finally, if you have a method that consumes events annotated with @InBackground qualifier, then you receive the event and process it accordingly to your business needs.
En esta entrada explicaremos como crear un Web Server que sirva una API RESTful usando para ello la tecnología de Node.js y todo el JavaScript que podamos, incluyendo la base de datos (MongoDB) y el plugin para conectarnos a ella y mapear los modelos (Mongoose).
In this post I will show you how to produce a CDI event and how to handle it even if it is deployed in another application.
The Event class
1
2
3
4
5
6
7
8
9
10
11
publicclassLoggerEvent{
privateStringmessage;
publicLoggerEvent(Stringmessage){
this.message=message;
}
publicStringgetMessage(){
returnmessage;
}
}
A simple JSF Page
XHTML
1
2
3
4
5
6
7
8
9
10
11
<?xml version='1.0'encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
<title>CDI Event Example</title>
</h:head>
<h:body>
<h1>#{controller.message}</h1>
</h:body>
</html>
This page only shows a simple message from the backing bean (the call to the bean produces the bean’s initialization).
Backing Bean
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import javax.annotation.PostConstruct;
import javax.enterprise.context.RequestScoped;
import javax.enterprise.event.Event;
import javax.inject.Inject;
import javax.inject.Named;
@Named
@RequestScoped
publicclassController{
@Inject
privateEvent<LoggerEvent>event;
privateStringmessage="CDI Events Example";
@PostConstruct
publicvoidinit(){
event.fire(newLoggerEvent("Hello from CDI events"));
}
publicStringgetMessage(){
returnmessage;
}
}
Here we Inject an event (LoggerEvent) via CDI Inject annotation. Then inside the init method annotated with PostConstruct we fire the event with a new instance of the event. This is the simplest way to fire a CDI event. No matter who are listening to this event will be notified.
This class will listen for events annotated with the keyword @Observes. Because of this, it will execute the method. In this case it will print to the console a log message passed to the constructor of the event instance when it was created: Hello from CDI events as you can see in the next picture.
Result (console result) cdi events
AS you can see, it’s just that simple to create a CDi event and listen to it. This technique uses the Observer design pattern here with the help of @Observes annotation.
Feel free to comment. Download the souce code CDIEvents.
