With just being released a couple of weeks ago, the project makes yet another important step to fulfill the specification requirements: integration with . In this blog post we are going to look on a couple of examples of how and work together.
Starting from version 3.0, includes a new module, named cxf-integration-cdi which could be added easily to your POM file:
1.2. org.apache.cxf 3.cxf-integration-cdi 4.3.0.0 5.
This new module brings just two components (in fact, a bit more but those are the key ones):
- CXFCdiServlet: the servlet to bootstrap application, serving the same purpose asCXFServlet and CXFNonSpringJaxrsServlet, ...
- JAXRSCdiResourceExtension: portable extension where all the magic happens
When run in -enabled environment, the portable extensions are discovered by container and initialized using life-cycle events. And that is literally all what you need! Let us see the real application in action.
We are going to build a very simple application to manage people using and, the reference implementation. The Person class we are going to use for a person representation is just a simple Java bean:
01.package com.example.model;02. 03.public class Person{04.private String email;05.private String firstName;06.private String lastName;07.public Person(){08.}09.public Person(final String email, final String firstName, final StringlastName){10.this.email = email;11.this.firstName = firstName;12.this.lastName = lastName;13.}14.//getters and setters are ommited15.//... As it is quite common now, we are going to run our application inside embedded container and ourStarter class does exactly that:
Please notice the presence of CXFCdiServlet and two mandatory listeners which were added to the context:
- org.jboss.weld.environment.servlet.Listener is responsible for injections
- org.jboss.weld.environment.servlet.BeanManagerResourceBindingListener binds the reference to the to JNDI location java:comp/env/BeanManager to make it accessible anywhere from the application
With that, the full power of is at your disposal. Let us introduce the PeopleService class annotated with @Named annotation and with an initialization method declared and annotated with @PostConstruct just to create one person.
Up to now we have said nothing about configuring applications and resources in enviroment. The reason for that is very simple: depending on the application, you may go with zero-effort configuration or fully customizable one. Let us go through both approaches.
With zero-effort configuration, you may define an empty application and any number of resources: implicitly will wire them together by associating each resource class with this application. Here is an example of application:
And here is a resource PeopleRestService which injects the PeopleService managed bean:
01.package com.example.rs;02. 03.import java.util.Collection;04. 05.import javax.inject.Inject;06.import javax.ws.rs.DELETE;07.import javax.ws.rs.DefaultValue;08.import javax.ws.rs.FormParam;09.import javax.ws.rs.GET;10.import javax.ws.rs.POST;11.import javax.ws.rs.PUT;12.import javax.ws.rs.Path;13.import javax.ws.rs.PathParam;14.import javax.ws.rs.Produces;15.import javax.ws.rs.QueryParam;16.import javax.ws.rs.core.Context;17.import javax.ws.rs.core.MediaType;18.import javax.ws.rs.core.Response;19.import javax.ws.rs.core.UriInfo;20. 21.import com.example.model.Person;22.import com.example.services.PeopleService;23. 24.@Path( "/people" )25.public class PeopleRestService {26.@Inject private PeopleService peopleService;27. 28.@Produces( { MediaType.APPLICATION_JSON } )29.@GET30.public Collection< Person > getPeople( @QueryParam( "page")@DefaultValue( "1" ) final int page ) {31.// ...32.}33. 34.@Produces( { MediaType.APPLICATION_JSON } )35.@Path( "/{email}" )36.@GET37.public Person getPerson( @PathParam( "email" ) final String email ) {38.// ...39.}40. 41.@Produces( { MediaType.APPLICATION_JSON } )42.@POST43.public Response addPerson( @Context final UriInfo uriInfo,44.@FormParam( "email" ) final String email,45.@FormParam( "firstName" ) final String firstName,46.@FormParam( "lastName" ) final String lastName ) {47.// ...48.}49. 50.// More HTTP methods here51.// ...52.}
Nothing else is required: application could be run like that and be fully functional. The complete source code of the sample project is available on . Please keep in mind that if you are following this style, only single empty application should be declared.
With customizable approach more options are available but a bit more work have to be done. Each application should provide non-empty getClasses() or/and getSingletons() collections implementation. However, resource classes stay unchanged. Here is an example (which basically leads to the same application configuration we have seen before):
01.package com.example.rs;02. 03.import java.util.Arrays;04.import java.util.HashSet;05.import java.util.Set;06. 07.import javax.enterprise.inject.Produces;08.import javax.inject.Inject;09.import javax.ws.rs.ApplicationPath;10.import javax.ws.rs.core.Application;11. 12.import com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider;13. 14.@ApplicationPath( "api" )15.public class JaxRsApiApplication extends Application {16.@Inject private PeopleRestService peopleRestService;17.@Produces private JacksonJsonProvider jacksonJsonProvider = newJacksonJsonProvider(); 18. 19.@Override20.public Set< Object > getSingletons() {21.return new HashSet<>(22.Arrays.asList(23.peopleRestService,24.jacksonJsonProvider25.)26.);27.}28.} Please notice, that JAXRSCdiResourceExtension portable extension automatically creates managed beans for each applications (the ones extending Application) and resources (annotated with@Path). As such, those are immediately available for injection (as for example PeopleRestService in the snippet above). The class JacksonJsonProvider is annotated with @Provider annotation and as such will be treated as provider. There are no limit on applications which could be defined in this way. The complete source code of the sample project using this appoarch is available on
No matter which approach you have chosen, our sample application is going to work the same. Let us build it and run:
1. > mvn clean package 2. > java -jar target/jax-rs-2.0-cdi-0.0.1-SNAPSHOT.jar Calling the couple of implemented APIs confirms that application is functioning and configured properly. Let us issue the GET command to ensure that the method of PeopleService annotated with @PostConstructhas been called upon managed bean creation.
And here is the example of POST command:
In this blog post we have just scratched the surface of what is possible now with and integration. Just to mention that embedded 7.x / 8.x as well as WAR-based deployments of with are possible on most JEE application servers and servlet containers.
Please take a look on and give it a try!
The complete source code is available on .
reference :http://java.dzone.com/articles/apache-cxf-30-cdi-11-support