• MongoJack to get List of Pojo from Mongo DB.
• Apache CXF JSONProvider based on Jettison to serialize the Pojo Log to JSON stream.

With Pojo Mapper MongoJack, the LogsService looks like this:

@GET
@Path("/all")
@Produces(MediaType.APPLICATION_JSON)
public List<Log> findAll() {
	DB db = MongoHolder.connect().getDB("websites");
	DBCollection dbColl = db.getCollection("logs");
	JacksonDBCollection<Log, String> coll = JacksonDBCollection.wrap(
          dbColl, Log.class, String.class);
	return coll.find().toArray();
}

When I have studied how to use Mongo in JEE Application with JAX-RS, I have read the great article Modern Web Apps using JAX-RS, MongoDB, JSON, and jQuery. After reading this article, I told me "why we need to use a Pojo Mapper with JAX-RS although Mongo manages their data with BSON representation?", on other words why we could not develop our JAX-RS service like this :

@GET
@Path("/all")
@Produces(MediaType.APPLICATION_JSON)
public DBCursor findAll() {
	DB db = MongoHolder.connect().getDB("websites");
	DBCollection coll = db.getCollection("logs");
	return coll.find();
}

Using DBCursor avoids to create a Pojo and avoids to serialize the Pojo to JSON. So I have decided to create Mongo JEE project. In this article we will modify our JAX-RS LogsService to use Mongo DBCursor in the service by using the JAX-RS provider of the Mongo JEE.

Download

You can download step6.zip which hosts the Eclipse Project which contains the explained sources in this article. To use it, unzip it and import this project in your Eclipse workspace. As soon as you will do that, your workspace will look like this :

This Eclipse project contains:

• LogService is JAX-RS service which returns Mongo DBCursor.
• MyJaxrsApplication is JAX-RS application which register the JAX-RS LogsService and Mongo JEE JAX-RS providers.
• web.xml declares the Apache CXF JAX-RS implementation and set MyJaxrsApplication as JAX-RS Application

Download JARs with maven

This project contains the same dependencies than step4 (no need to use MongoJack and Apache CXF JSONProvider).

LogsService – DBCursor

Modify org.samples.mongodb.services.LogsService like this:

package org.samples.mongodb.services;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.jee.MongoHolder;

@Path("/logs")
public class LogsService {

	@GET
	@Path("/all")
	@Produces(MediaType.APPLICATION_JSON)
	public DBCursor findAll() {
		DB db = MongoHolder.connect().getDB("websites");
		DBCollection coll = db.getCollection("logs");
		return coll.find();
	}

}

Without Mongo JEE

In this step we will not use Mongo JEE to manage DBCursor with JAX-RS. We will see the problem without JAX-RS provider and we will fix it by developping our own JAX-RS provider.

MyJaxrsApplication – with problems

At this step we will use the MyJaxrsApplication of the previous article [step5] :

package org.samples.mongodb.jaxrs;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import org.samples.mongodb.services.LogsService;

public class MyJaxrsApplication extends Application {

	private final Set<Object> singletons;

	public MyJaxrsApplication() {
		singletons = new HashSet<Object>();
		addSingleton(new LogsService());
	}

	protected void addSingleton(Object singleton) {
		singletons.add(singleton);
	}

	@Override
	public Set<Object> getSingletons() {
		return singletons;
	}
}

Test LogsService – with problem

• run the StartServer class to start the server.
• access with your webbrowser to the URL http://localhost:8081/mongo/jaxrs/logs/all/ and you will see the following error :

  No message body writer has been found for response class DBCursor.

This error occurs because Apache CXF doesn’t find JAX-RS provider to serialize the DBCursor to JSON. Mongo JEE provides those JAX-RS provider but before using it, it can be interesting to develop it (with simply mean).

MyDBCursorProvider

To fix the previous problem, create JAX-RS provider org.samples.mongodb.jaxrs.MyDBCursorProvider to serialize DBCursor to JSON like this:

package org.samples.mongodb.jaxrs;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;

import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;

import com.mongodb.DBCursor;
import com.mongodb.jee.util.JSON;

@Provider
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class MyDBCursorProvider implements MessageBodyWriter<DBCursor> {

	@Override
	public boolean isWriteable(Class<?> atype, Type genericType,
			Annotation[] annotations, MediaType mediaType) {
		if (DBCursor.class.isAssignableFrom(atype)) {
			// the given class type is DBCursor
			return true;
		}
		return false;
	}

	public void writeTo(DBCursor cursor, Class<?> type, Type genericType,
			Annotation[] annotations, MediaType mediaType,
			MultivaluedMap<String, Object> httpHeaders,
			OutputStream entityStream) throws IOException,
			WebApplicationException {

		// Write the DBCursor as JSON array stream.
		JSON.serialize(cursor, entityStream);
	}

	@Override
	public long getSize(DBCursor t, Class<?> type, Type genericType,
			Annotation[] annotations, MediaType mediaType) {
		// Return -1 if the content length cannot be determined
		return -1;
	}

}

To use our JAX-RS provider, we need to register it in the JAX-RS Application. To do that modify org.samples.mongodb.jaxrs.MyJaxrsApplication like this:

package org.samples.mongodb.jaxrs;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import org.samples.mongodb.services.LogsService;

public class MyJaxrsApplication extends Application {

	private final Set<Class<?>> classes;
	private final Set<Object> singletons;

	public MyJaxrsApplication() {
		classes = new HashSet<Class<?>>();
		addClass(MyDBCursorProvider.class);
		 
		singletons = new HashSet<Object>();
		addSingleton(new LogsService());
	}

	@Override
	public Set<Class<?>> getClasses() {
		return classes;
	}

	protected void addClass(Class<?> clazz) {
		classes.add(clazz);
	}

	protected void addSingleton(Object singleton) {
		singletons.add(singleton);
	}

	@Override
	public Set<Object> getSingletons() {
		return singletons;
	}
}

Test LogsService – MyDBCursorProvider

Now we can test our JAX-RS provider :

• run the StartServer class to start the server.
• access with your webbrowser to the URL http://localhost:8081/mongo/jaxrs/logs/all/ to see the JSON array of logs and see the "application/json" of the content type :
  

You can check that the JSON array is the same than the Mongo JSON array like (see [step4]).

With Mongo JEE

Mongo JEE provides several JAX-RS providers for Mongo and provides too a JAX-RS Application JaxrsMongoApplication which registers Mongo JAX-RS providers.

MyJaxrsApplication – JaxrsMongoApplication

Modify MyJaxrsApplication to extend JaxrsMongoApplication like this:

package org.samples.mongodb.jaxrs;

import org.samples.mongodb.services.LogsService;

import com.mongodb.jee.jaxrs.JaxrsMongoApplication;

public class MyJaxrsApplication extends JaxrsMongoApplication {

	public MyJaxrsApplication() {
		super.addSingleton(new LogsService());
	}

}

Run the StartServer class to start the server and check that service works again.

Remove _id

The returned JSON stream to the browser, contains the "_id" key. But it’s possible to remove "_id" property .

Modify LogsService like this:

package org.samples.mongodb.services;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.jee.MongoHolder;

@Path("/logs")
public class LogsService {

	@GET
	@Path("/all")
	@Produces(MediaType.APPLICATION_JSON)
	public DBCursor findAll() {
		DB db = MongoHolder.connect().getDB("websites");
		DBCollection coll = db.getCollection("logs");
		BasicDBObject fieldsToIgnore = new BasicDBObject("_id", false);
		return coll.find(null, fieldsToIgnore);
	}

}

Restart the server and test it to check that every thing is working again.

Conclusion

In this article we have seen how to manage Mongo structure with JAX-RS service by using Mongo JEE.

In the next article [step7] we will add a new method service to return paginated logs list.

@Path("/logs")
public class LogsService {

  @Path("/all")
  public Response findAll() {
    ...
  }
}

It’s very difficult to use this service in other context than JAX-RS (like using the service in fat client, using the service in a JUnit etc). Imagine you wish to write some JUnits which tests that our LogsService service returns some logs. With our current logs service, it’s hard to write that :

@Test
public void testNotEmptyLogs() {
  LogsService service = new LogsService();
  Response jaxrsResponse = service.findAll();
  // How to get the list of logs to test that logs are not empty?
}

When you develop a service, the best mean is that you don’t link it to a framework. For instance :

• if your service returns list of Pojo :

  @Path("/logs")
  public class LogsService {
  
    @Path("/all")
    public List<Log> findAll() {
      ...
    }
  }
  

  you can write this test :

  @Test
  public void testNotEmptyLogs() {
    LogsService service = new LogsService();
    List<Pojo> pojoList = service.findAll();
    Assert.assertFalse(pojoList.isEmpty());
  }
  

• if your service returns a Mongo DBCursor :

  @Path("/logs")
  public class LogsService {
  
    @Path("/all")
    public DBCursor findAll() {
      ...
    }
  }
  

  you can write this test :

  @Test
  public void testNotEmptyLogs() {
    LogsService service = new LogsService();
    DBCursor cursor= service.findAll();
    Assert.assertFalse(cursor.toArray().isEmpty());
  }
  

With JAX-RS you can write services which returns anything (List of Pojo, Mongo DBCursor), but it’s not magic and you need JAX-RS provider to serialize (in our case) List of Pojo, DBCursor etc into JSON stream :

• in this article we will see how to manage JAX-RS service with Pojo. We will use MongoJack to get list of Log Pojo from Mongo DB and the Apache CXF JSONProvider, the JAX-RS provider to serialize Pojo to a JSON stream.
• in the next article [step6] we will see how to manage JAX-RS service with Mongo DBCursor by using the Mongo JEE JAX-RS providers.

Download

You can download step5.zip which hosts the Eclipse Project which contains the explained sources in this article. To use it, unzip it and import this project in your Eclipse workspace. As soon as you will do that, your workspace will look like this :

This Eclipse project contains:

• LogService is JAX-RS service which returns list of Pojo by using MongoJack.
• MyJaxrsApplication is JAX-RS application which register the JAX-RS LogsService.
• web.xml declares the Apache CXF JAX-RS implementation and set MyJaxrsApplication as JAX-RS Application

Download JARs with maven

This project contains the same dependencies than step4, and additional dependencies :

• in our case we need org.apache.cxf.jaxrs.provider.json.JSONProvider, the JAX-RS provider of Apache CXF used to serialize/deserialize Pojo (which are annotated with JAXB annotations) to JSON stream :

  <dependency>
  	<groupId>org.apache.cxf</groupId>
  	<artifactId>cxf-rt-rs-extension-providers</artifactId>
  	<version>2.7.4</version>
  </dependency>
  

• JSONProvider of Apache CXF uses jettison to manage JSON read/write :

  <dependency>
  	<groupId>org.codehaus.jettison</groupId>
  	<artifactId>jettison</artifactId>
  	<version>1.3.3</version>
  </dependency>
  

• Pojo Mapper MongoJack is used to get Pojo from Mongo DB like we have explained in the step1:

  <dependency>
  	<groupId>org.mongojack</groupId>
  	<artifactId>mongojack</artifactId>
  	<version>2.0.0-RC5</version>
  </dependency>

What is JAX-RS provider?

I suggest you to read What does Provider in JAX-RS mean? In our case we will need Entity Providers

These providers control the mapping of data representations (like XML, JSON, CSV) to their Java object equivalents.

We will use Apache CXF org.apache.cxf.jaxrs.provider.json.JSONProvider which uses jettison.

Pojo Log

Create a Pojo Log like we have explained in the [step1] and add the JAXB @XmlRootElement annotation :

package org.samples.mongodb.services;

import java.util.Date;

import javax.persistence.Id;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Log {

	@Id
	private String id;

	private String url;
	private Date created;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public Date getCreated() {
		return created;
	}

	public void setCreated(Date created) {
		this.created = created;
	}

}

LogsService

Create the org.samples.mongodb.services.LogsService which uses MongoJack and returns list of Pojo Log like this :

package org.samples.mongodb.services;

import java.util.List;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import org.mongojack.JacksonDBCollection;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.jee.MongoHolder;

@Path("/logs")
public class LogsService {

	@GET
	@Path("/all")
	@Produces(MediaType.APPLICATION_JSON)
	public List<Log> findAll() {

		DB db = MongoHolder.connect().getDB("websites");
		DBCollection dbColl = db.getCollection("logs");

		JacksonDBCollection<Log, String> coll = JacksonDBCollection.wrap(
				dbColl, Log.class, String.class);
		return coll.find().toArray();
	}

}

Test LogsService

• run the StartServer class to start the server.
• access with your webbrowser to the URL http://localhost:8081/mongo/jaxrs/logs/all/ to see the JSON array of logs and see the "application/json" of the content type :
  

You can check that the JSON array is not the same than the Mongo JSON array like (see [step4]) :

{"log":
  [{"created":"2013-05-10T16:17:37.515+02:00",
    "id":"518d01813bfe01bef797d031",
    "url":"http:\/\/www.mongodb.org\/"}
  ...
  ]
}

JSONProvider Troubleshooting

When I have tried to develop this article, I have spent a long time to use correctly JSONProvider. I had every time the error :

No message body writer has been found for response class ArrayList.

Here the 3 rules to respect, when your service returns a List of Pojo, to avoid this error :

1. check org.apache.cxf.jaxrs.provider.json.JSONProvideris in the classpath. Since 2.6.x, this JAX-RS provider is hosted in the cxf-rt-rs-extension-providers*.jar.
2. check that Jettison*.jar is in the classpath. JSONProvider uses Jettison to read/write JSON.
3. check that your Pojo is annotated with JAXB @XmlRootElement annotation.

Conclusion

In this article we have modified our LogsService to return a List of Pojo getted from the Mongo DB with MongoJack. Apache CXF JSONProvider is used in this case to serialize list of Pojo to a JSON array. Using Pojo witth Mongo and JAX-RS works great but :

• you need to create a Pojo.
• you need to annotate the Pojo with JAXB annotation.
• you need to serialize the Pojo to a JSON stream.

Mongo stores their data with BSON representation (looks like JSON), so .., why we could not to use this stream instead of creating a Pojo? In the next article [step6], we will modify our LogsService to use Mongo DBCuror instead of List of Pojo.


]]> http://angelozerr.wordpress.com/2013/05/14/mongo_jee_step5/feed/ 2 akrogen http://angelozerr.wordpress.com/2013/05/14/mongo_jee_step4/ http://angelozerr.wordpress.com/2013/05/14/mongo_jee_step4/#comments Tue, 14 May 2013 13:16:48 +0000 angelozerr http://angelozerr.wordpress.com/?p=7291 ]]> In [step3] we have improved our LogsServlet by using Mongo JEE. Servlet works well but it’s an old school mean.

Using servlet in this case will causes problem when you will wish to manage several operations (find all logs, find paginated logs, insert logs, etc). To manage that, you will have to create a servlet per operations or manage this dispatch at hand (for instance with a HTTP request dispatch parameter) like this :

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  DBCursor cursor = null;
  String dispatch = request.getParameter("dispatch");
  if ("all".equals(dispatch) {
	DB db = mongo.getDB("websites");
	DBCollection coll = db.getCollection("logs");

	DBCursor cursor = coll.find();
	ServletHelper.writeJson(cursor, response);
  } else if ("page".equals(dispatch) {
     ...
  }
}

It exists a lot of Java Web Framwework (Spring MVC, GWT, Wicket, Play!, JSF, Struts2, etc) which provides a controller framework which fix this problem. JAX-RS provides too an elegant mean to fix that : you develop a service class and you create a method for each operations. Here a JAX-RS sample :

@Path("/logs")
public class LogsService {

	@Path("/all")
	public Response findAll() {
	...
	}
	
	@Path("/page")
	public Response findPage() {
	...
	}
	
}

Once this JAX-RS service will be deployed, you will able to call :

• http://localhost:8081/mongo/jaxrs/logs/all to returns list of logs.
• http://localhost:8081/mongo/jaxrs/logs/page to returns list of paginated logs.

In this article we will transform our LogsServlet with JAX-RS LogsService. We will use Apache CXF as JAX-RS implementation.

Download

You can download step4.zip which hosts the Eclipse Project which contains the explained sources in this article. To use it, unzip it and import this project in your Eclipse workspace. As soon as you will do that, your workspace will look like this :



This Eclipse project contains:

• LogService is JAX-RS service which uses JAX-RS StreamingOutput.
• MyJaxrsApplication is JAX-RS application which register the JAX-RS LogsService.
• web.xml declares the Apache CXF JAX-RS implementation and set MyJaxrsApplication as JAX-RS Application

Download JARs with maven

This project contains the same dependencies than step3, and additional dependencies :

• Apache CXF as JAX-RS implementation. To do that I use this maven dependency :

  <dependency>
  	<groupId>org.apache.cxf</groupId>
  	<artifactId>cxf-rt-frontend-jaxrs</artifactId>
  	<version>2.7.4</version>
  </dependency>

The project contains the JARs in the lib, but if you wish to download it with maven , see Download JARs with maven [step1].

JAX-RS Overview

JAX-RS: Java API for RESTful Web Services is a Java programming language API that provides support in creating web services according to the Representational State Transfer (REST) architectural pattern. JAX-RS uses annotations, introduced in Java SE 5, to simplify the development and deployment of web service clients and endpoints.

It exists several JAX-RS implementation like :

• Apache CXF.
• Jersey.
• RESTeasy.
• Restlet.

In this article we will use Apache CXF but the code of our JAX-RS service is not linked to Apache CXF and other JAX-RS implementation could be used.

JAX-RS LogsService

Create org.samples.mongodb.services.LogsService like this:

package org.samples.mongodb.services;

import java.io.IOException;
import java.io.OutputStream;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.StreamingOutput;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.jee.MongoHolder;

@Path("/logs")
public class LogsService {

	@GET
	@Path("/all")
	@Produces(MediaType.APPLICATION_JSON)
	public Response findAll() {
		DB db = MongoHolder.connect().getDB("websites");
		DBCollection coll = db.getCollection("logs");
		final DBCursor cursor = coll.find();

		StreamingOutput output = new StreamingOutput() {
			public void write(OutputStream out) throws IOException,
					WebApplicationException {
				com.mongodb.jee.util.JSON.serialize(cursor, out);
			}
		};
		return Response.ok(output).build();
	}

}

Here some explanation about this code :

• To tell that a service should be deployed as JAX-RS service, the class must be annoted with javax.ws.rs.@Path.
  Here we use /logs :

  @Path("/logs")
  public class LogsService...
  

  It means that the URL which will consumes the service will starts with http://localhost:8080/jaxrs/logs/. If we declare with empty quote @Path(""), the URL will start with http://localhost:8080/jaxrs.

• The method findAll is annotated with @GET, it means that our service will be available with HTTP GET method.
• The method findAll is annotated with @Path("/all"), it means that the service will be available with the following URL http://localhost:8080/jaxrs/logs/all
• The method findAll is annotated with @Produces(MediaType.APPLICATION_JSON), it means that our service will update the HTTP response content type with "application/json".
• javax.ws.rs.core.StreamingOutput#write is called when service must write some content in the HTTP response OutputStream. In our case
  we implement it like this to write the mongo cursor as JSON array :

    
  StreamingOutput output = new StreamingOutput() {
  	public void write(OutputStream out) throws IOException,
  			WebApplicationException {
  		com.mongodb.jee.util.JSON.serialize(cursor, out);
  	}
  };
  

MyJaxrsApplication – getClasses

At this step we have defined our JAX-RS LogsService. Now we must indicate to the JAX-RS processor that it must deploy the service. To do that, there are several means (according the JAX-RS processor implementation). A generic mean which works with any JAX-RS processor is to extend the javax.ws.rs.core.Application which provides :

• getClasses() which must return a Set of classes of JAX-RS services (and providers : we will see this notion of JAX-RS provider in the next article [step5]). The whole JAX-RS services classes which are included in the Set will be instantiated for each request (as soon as the service is called).
• getSingletons() which must return a Set of instance which must be singleton. The whole JAX-RS services classes which are included in the Set will be instantiated just one time.

Here we start using getClasses. Create Java class org.samples.mongodb.jaxrs.MyJaxrsApplication like this:

package org.samples.mongodb.jaxrs;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import org.samples.mongodb.services.LogsService;

public class MyJaxrsApplication extends Application {

	private final Set<Class<?>> classes;

	public MyJaxrsApplication() {
		classes = new HashSet<Class<?>>();
		addClass(LogsService.class);
	}

	@Override
	public Set<Class<?>> getClasses() {
		return classes;
	}

	protected void addClass(Class<?> clazz) {
		classes.add(clazz);
	}
}

In our case we override Application#getClasses() to add our LogsService class.

web.xml

At this step we have created our JAX-RS LogsService and registered it in our JAX-RS Application MyJaxrsApplication. Now we must configure the web.xml to declare the Apache CXF servlet which manages JAX-RS :

• we should declare the Apache CXF servlet by setting our JAX-RS Application :

  <servlet>
  	<servlet-name>CXFServlet</servlet-name>
  	<servlet-class>org.apache.cxf.jaxrs.servlet.CXFNonSpringJaxrsServlet</servlet-class>
  	<init-param>
  		<param-name>javax.ws.rs.Application</param-name>
  		<param-value>
  			org.samples.mongodb.jaxrs.MyJaxrsApplication
  		</param-value>
  	</init-param>
  </servlet>
  

• In our case we wish to deploy our JAX-RS service with URL which starts with /jaxrs/* :

  <servlet-mapping>
  	<servlet-name>CXFServlet</servlet-name>
  	<url-pattern>/jaxrs/*</url-pattern>
  </servlet-mapping>
  

Here the full code of web.xml :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	<display-name>Mongo JEE</display-name>

	<servlet>
		<servlet-name>CXFServlet</servlet-name>
		<servlet-class>org.apache.cxf.jaxrs.servlet.CXFNonSpringJaxrsServlet</servlet-class>
		<init-param>
			<param-name>javax.ws.rs.Application</param-name>
			<param-value>
				org.samples.mongodb.jaxrs.MyJaxrsApplication
			</param-value>
		</init-param>
	</servlet>

	<servlet-mapping>
		<servlet-name>CXFServlet</servlet-name>
		<url-pattern>/jaxrs/*</url-pattern>
	</servlet-mapping>

	<listener>
		<listener-class>com.mongodb.jee.servlet.MongoServletContextListener</listener-class>
	</listener>

	<context-param>
		<param-name>mongoURI</param-name>
		<param-value>mongodb://localhost:27017</param-value>
	</context-param>

</web-app>

Test LogsService

• run the StartServer class to start the server.
• access with your webbrowser to the URL http://localhost:8081/mongo/jaxrs/logs/all/ to see the JSON array of logs and see the "application/json" of the content type :
  

LogsService – MongoStreamingOutput

Mongo JEE provides the com.mongodb.jee.jaxrs.MongoStreamingOutput classes. So you can replace this code :

StreamingOutput output = new StreamingOutput() {
	public void write(OutputStream out) throws IOException, WebApplicationException {
		com.mongodb.jee.util.JSON.serialize(cursor, out);
	}
};

with MongoStreamingOutput :

StreamingOutput output = new MongoStreamingOutput(cursor);

MyJaxrsApplication – getSingletons

At this step, our logs service is instantiated as soon as is called. To test that, you can add a counter in the LogsService constructor :

private static int i = 0;

  public LogsService() {
    System.err.println(i++);
}

You will see on the console that each time you call http://localhost:8081/mongo/jaxrs/logs/all, the i variable is incremented, it means that LogsService is instanciated for each request.

In our case it’s not interesting, and LogsService can be a singleton. To do that, Application#getSingletons() should be override to return an instance of LogsService.

Modify the JAX-RS Application MyJaxrsApplication like this :

package org.samples.mongodb.jaxrs;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import org.samples.mongodb.services.LogsService;

public class MyJaxrsApplication extends Application {

	private final Set<Object> singletons;

	public MyJaxrsApplication() {
		singletons = new HashSet<Object>();
		addSingleton(new LogsService());
	}

	protected void addSingleton(Object singleton) {
		singletons.add(singleton);
	}

	@Override
	public Set<Object> getSingletons() {
		return singletons;
	}
}

Restart the server to check that counter is called just one time.

Conclusion

In this article we have seen how to transform our LogsServlet with a JAX-RS LogsService which uses StreamingOutput. Our LogsService is more elegant than LogServlet but code is linked to the JAX-RS API because it returns javax.ws.rs.core.Response. So it’s difficult to test the result of the LogService with a simple JUnit.

In the next article [step5] we will fix this problem by changing the signature of the findAll method to return a Pojo Log instead of returning a JAX-RS Response.


]]> http://angelozerr.wordpress.com/2013/05/14/mongo_jee_step4/feed/ 3 akrogen http://angelozerr.wordpress.com/2013/05/12/mongo_jee_step3/ http://angelozerr.wordpress.com/2013/05/12/mongo_jee_step3/#comments Sun, 12 May 2013 11:21:53 +0000 angelozerr http://angelozerr.wordpress.com/?p=7289 ]]> In [step2] we have used mongo in a servlet to return the JSON array of the logs collection. In this article we will use Mongo JEE to improve it :
• use com.mongodb.jee.MongoHolder#connect() to avoid hard coding the mongo URI in the servlet.
• use com.mongodb.jee.util.JSON to manage JSON streaming when mongo cusor is serialized as JSON and is written in the HTTP response.
• use com.mongodb.jee.servlet.ServletHelper to simplify the code which set response as JSON and write the JSON stream in the HTTP response.

Download

You can download step3.zip which hosts the Eclipse Project which contains the explained sources in this article. To use it, unzip it and import this project in your Eclipse workspace. As soon as you will do that, your workspace will look like this :



Download JARs with maven

In this article we use :

1. the Mongo Java Driver. To do that I use this maven dependency :

   <dependency>
   	<groupId>org.mongodb</groupId>
   	<artifactId>mongo-java-driver</artifactId>
   	<version>2.11.1</version>
   </dependency>
   

2. the Embedded Jetty as server. To do that I use this maven dependency :

   <dependency>
   	<groupId>org.eclipse.jetty</groupId>
   	<artifactId>jetty-webapp</artifactId>
   	<version>8.1.10.v20130312</version>
   	<scope>test</scope>
   </dependency>
   

3. Mongo JEE. To do that I use this maven dependency :

   <dependency>
   	<groupId>fr.opensagres.mongodb</groupId>
   	<artifactId>mongo-jee</artifactId>
   	<version>1.0.0</version>
   </dependency>
   

The project contains the JARs in the lib, but if you wish to download it with maven , see Download JARs with maven [step1].

MongoHolder#connect()

In [step2]:

1. the mongo client is created on the init of logs servlet:

   private MongoClient mongo = null;
   
   @Override
   public void init() throws ServletException {
   	super.init();
   
   	// Connect to Mongo DB
   	MongoClientURI mongoURI = new MongoClientURI(
   			"mongodb://localhost:27017");
   	try {
   		mongo = new MongoClient(mongoURI);
   	} catch (UnknownHostException e) {
   		throw new ServletException(e);
   	}
   }
   

2. the mongo client is closed on the destroy of logs servlet:

   @Override
   public void destroy() {
   	super.destroy();
   	if (mongo != null) {
   		mongo.close();
   	}
   }
   

This code works, but there are some problems :

• the mongo URI is hard coded. If you wish to change the mongo URI, you must recompile the servlet.
• if you wish to add a new servlet like logs servlet, it’s not possible to use the mongo pool of the logs servlet. A best design is to delegate the mongo lyfecycle (create and close) in other classes than logs servlet.

Mongo JEE resolves this 2 problems with the MongoHolder. To use it, you must

1. configure the default mongo URI of the MongoHolder :

   MongoClientURI mongoURI = ...;
   boolean defaultMongo = true;
   MongoHolder.connect(mongoURI, defaultMongo);
   

   You can configure it in your web.xml with the JEE ServletContextListener com.mongodb.jee.servlet.MongoServletContextListener like this :

   <listener>
   	<listener-class>com.mongodb.jee.servlet.MongoServletContextListener</listener-class>
   </listener>
   
   <context-param>
   	<param-name>mongoURI</param-name>
   	<param-value>mongodb://localhost:27017</param-value>
   </context-param>
   

   • on ServletContextListener#contextInitialized, MongoHolder is initialized with default mongoURI declared in the web.xml.
   • on ServletContextListener#contextDestroyed, all instance of Mongo registered in the MongoHolder are closed.
2. after having configurated the default mongo URI, you can do that :

   Mongo mongo = MongoHolder.connect();
   

web.xml

Modify the web.xml to declare com.mongodb.jee.servlet.MongoServletContextListener and the default mongo URI like this :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	<display-name>Mongo JEE</display-name>

	<servlet>
		<servlet-name>LogsServlet</servlet-name>
		<servlet-class>org.samples.mongodb.servlet.LogsServlet</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>LogsServlet</servlet-name>
		<url-pattern>/servlet/logs/*</url-pattern>
	</servlet-mapping>

	<listener>
		<listener-class>com.mongodb.jee.servlet.MongoServletContextListener</listener-class>
	</listener>

	<context-param>
		<param-name>mongoURI</param-name>
		<param-value>mongodb://localhost:27017</param-value>
	</context-param>

</web-app>

LogsServlet – MongoHolder

Modify org.samples.mongodb.servlet.LogsServlet to use MongoHolder#connect() like this :

package org.samples.mongodb.servlet;

import java.io.IOException;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.Mongo;
import com.mongodb.jee.MongoHolder;
import com.mongodb.util.JSON;

public class LogsServlet extends HttpServlet {

	@Override
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		Mongo mongo = MongoHolder.connect();
		// Get DB collection
		DB db = mongo.getDB("websites");
		DBCollection coll = db.getCollection("logs");

		DBCursor cursor = coll.find();

		// HTTP response is JSON
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json");

		// Loop for DB cursor and write each DB document in the HTTP writer
		Writer writer = response.getWriter();

		StringBuilder buf = new StringBuilder();
		JSON.serialize(cursor, buf);
		writer.write(buf.toString());

		writer.flush();

	}

}

Restart the server to check the servlet logs works again.

com.mongodb.jee.util.JSON

In [step2] the mongo cursor is serialized (by using StringBuilder) as JSON in the HTTP response like this:

Writer writer = response.getWriter();

StringBuilder buf = new StringBuilder();
com.mongodb.util.JSON.serialize(cursor, buf);
writer.write(buf.toString());

Problem with this code is that you must create a StringBuilder instance before writing in the HTTP response. To avoid this problem, you can use Mongo JEE which provides the same JSON helper but with Writer as parameter. So you can do that :

Writer writer = response.getWriter();

com.mongodb.jee.util.JSON.serialize(cursor, writer);

LogsServlet – JSON

Modify org.samples.mongodb.servlet.LogsServlet to use com.mongodb.jee.util.JSON like this :

package org.samples.mongodb.servlet;

import java.io.IOException;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.Mongo;
import com.mongodb.jee.MongoHolder;
import com.mongodb.util.JSON;

public class LogsServlet extends HttpServlet {

	@Override
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		Mongo mongo = MongoHolder.connect();
		// Get DB collection
		DB db = mongo.getDB("websites");
		DBCollection coll = db.getCollection("logs");

		DBCursor cursor = coll.find();

		// HTTP response is JSON
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json");

		// Loop for DB cursor and write each DB document in the HTTP writer
		Writer writer = response.getWriter();

		//StringBuilder buf = new StringBuilder();
		com.mongodb.jee.util.JSON.serialize(cursor, writer);
		//writer.write(buf.toString());

		writer.flush();
	}

}

Restart the server to check the servlet logs works again.

ServletHelper

You can notice that the code :

// HTTP response is JSON
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json");

// Loop for DB cursor and write each DB document in the HTTP writer
Writer writer = response.getWriter();

//StringBuilder buf = new StringBuilder();
com.mongodb.jee.util.JSON.serialize(cursor, writer);
//writer.write(buf.toString());

writer.flush();

is generic. You can do the same thing with the Mongo JEE com.mongodb.jee.servlet.ServletHelper :

// Write in the HHTP response the JSON array of the cursor.
ServletHelper.writeJson(cursor, response);

LogsServlet – ServletHelper

Modify org.samples.mongodb.servlet.LogsServlet to use com.mongodb.jee.servlet.ServletHelper like this :

package org.samples.mongodb.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.Mongo;
import com.mongodb.jee.MongoHolder;
import com.mongodb.jee.servlet.ServletHelper;

public class LogsServlet extends HttpServlet {

	@Override
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		Mongo mongo = MongoHolder.connect();
		// Get DB collection
		DB db = mongo.getDB("websites");
		DBCollection coll = db.getCollection("logs");

		DBCursor cursor = coll.find();

		// Write in the HHTP response the JSON array of the cursor.
		ServletHelper.writeJson(cursor, response);
	}

}

Restart the server to check the servlet logs works again.

Conclusion

In this article we have seen how to Mongo JEE can improve code with servlet which uses Mongo. In the next article [step4], we will replace our logs servlet with a JAX-RS logs service by using javax.ws.rs.core.StreamingOutput.


]]> http://angelozerr.wordpress.com/2013/05/12/mongo_jee_step3/feed/ 2 akrogen http://angelozerr.wordpress.com/2013/05/11/mongo_jee_step2/ http://angelozerr.wordpress.com/2013/05/11/mongo_jee_step2/#comments Sat, 11 May 2013 23:16:01 +0000 angelozerr http://angelozerr.wordpress.com/?p=7254 ]]> In [step1] we have seen how to execute mongo operations (find, insert, remove) with Java code by using Mongo Java Driver and the Pojo Mapper MongoJack. In this article we will create a WebApp application composed with a Servlet which connects to the Mongo DB and returns the JSON stream array of the logs collection in the HTTP response, on other words when the following URL will be called :

http://localhost:8081/mongo/servlet/logs/ the servlet will return the JSON stream array :

[ 
{ "_id" : { "$oid" : "518d01813bfe01bef797d031"} , 
  "url" : "http://www.mongodb.org/" , 
  "created" : { "$date" : "2013-05-10T14:17:37.515Z"}} , 
{ "_id" : { "$oid" : "518d01813bfe01bef797d032"} , 
  "url" : "http://www.mongodb.org/" , 
  "created" : { "$date" : "2013-05-10T14:17:37.515Z"}} ,
...]

To do that, we will :

• use Embedded Jetty as HTTP server to start the WebApp with simple Java main.
• use Mongo Java Driver.
• create the LogsServlet, the servlet which returns the JSON stream array of the logs.

Download

You can download step2.zip which hosts the Eclipse Project which contains the explained sources in this article. To use it, unzip it and import this project in your Eclipse workspace. As soon as you will do that, your workspace will look like this :



• org.samples.mongodb.servlet.LogsServlet is the logs servlet which returns the JSON array.
• web.xml declares the logs servlet.
• org.samples.mongodb.server.StartServer starts the embedding Jetty which hosts the WebApp.

Download JARs with maven

In this article we use the Mongo Java Driver. To do that I use this maven dependency :

<dependency>
	<groupId>org.mongodb</groupId>
	<artifactId>mongo-java-driver</artifactId>
	<version>2.11.1</version>
</dependency>

and the Embedded Jetty as server. To do that I use this maven dependency :

<dependency>
	<groupId>org.eclipse.jetty</groupId>
	<artifactId>jetty-webapp</artifactId>
	<version>8.1.10.v20130312</version>
	<scope>test</scope>
</dependency>

The project contains the JARs in the lib, but if you wish to download it with maven , see Download JARs with maven [step1].

WebApp

LogsServlet

Create the org.samples.mongodb.servlet.LogsServlet servlet like this:

package org.samples.mongodb.servlet;

import java.io.IOException;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.util.JSON;

public class LogsServlet extends HttpServlet {

	@Override
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection coll = db.getCollection("logs");

			// Find all DB object from the DB collection
			DBCursor cursor = coll.find();

			// HTTP response is JSON
			response.setCharacterEncoding("UTF-8");
			response.setContentType("application/json");

			// Write in the HTTP response, the JSON array of the cursor.
			Writer writer = response.getWriter();
			StringBuilder buf = new StringBuilder();
			JSON.serialize(cursor, buf);
			writer.write(buf.toString());
			writer.flush();

		} finally {
			mongo.close();
		}
	}
}

web.xml

Declare the servlet in the src/main/webapp/WEB-INF/web.xml like this :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	<display-name>Mongo JEE</display-name>

	<servlet>
		<servlet-name>LogsServlet</servlet-name>
		<servlet-class>org.samples.mongodb.servlet.LogsServlet
		</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>LogsServlet</servlet-name>
		<url-pattern>/servlet/logs/*</url-pattern>
	</servlet-mapping>

</web-app>

Server

StartServer

Create the Java main org.samples.mongodb.server.StartServer which starts the embedding Jetty which hosts the WebApp :

package org.samples.mongodb.server;

import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.ContextHandlerCollection;
import org.eclipse.jetty.server.handler.DefaultHandler;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.webapp.WebAppContext;

public class StartServer {

	public static void main(String[] args) throws Exception {
		Server server = new Server(8081);

		WebAppContext webappcontext = new WebAppContext("src/main/webapp",
				"/mongo");

		ContextHandlerCollection servlet_contexts = new ContextHandlerCollection();
		webappcontext.setClassLoader(Thread.currentThread()
				.getContextClassLoader());
		HandlerCollection handlers = new HandlerCollection();
		handlers.setHandlers(new Handler[] { servlet_contexts, webappcontext,
				new DefaultHandler() });
		server.setHandler(handlers);

		server.start();
		server.join();
	}
}

This Java main starts an embedding Jetty on the 8081 port and configures a WebApp where sources are hosted in the src/main/webapp folder (where web.xml is hosted).

Test LogsServlet

• run the StartServer class to start the server.
• access with your webbrowser to the URL http://localhost:8081/mongo/servlet/logs/ to see the JSON array of logs:
  

LogsServlet – Mongo pool

According the Getting Started with Java Driver article :

Note The MongoClient instance actually represents a pool of connections to the database; you will only need one instance of class MongoClient even with multiple threads. See the concurrency doc page for more information.

In our current code of LogsServlet we create a MongoClient instance and close it for each HTTP request. We can improve that by creating a MongoClient and close it just one time (not for each HTTP request). Modify the LogsServlet like this :

package org.samples.mongodb.servlet;

import java.io.IOException;
import java.io.Writer;
import java.net.UnknownHostException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.util.JSON;

public class LogsServlet extends HttpServlet {

	private MongoClient mongo = null;

	@Override
	public void init() throws ServletException {
		super.init();

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		try {
			mongo = new MongoClient(mongoURI);
		} catch (UnknownHostException e) {
			throw new ServletException(e);
		}
	}

	@Override
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		// Get "logs" collection from the "websites" DB.
		DB db = mongo.getDB("websites");
		DBCollection coll = db.getCollection("logs");

		// Find all DB object from the DB collection
		DBCursor cursor = coll.find();

		// HTTP response is JSON
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json");

		// Write in the HTTP response, the JSON array of the cursor.
		Writer writer = response.getWriter();
		StringBuilder buf = new StringBuilder();
		JSON.serialize(cursor, buf);
		writer.write(buf.toString());
		writer.flush();

	}

	@Override
	public void destroy() {
		super.destroy();
		if (mongo != null) {
			mongo.close();
		}
	}

}

Conclusion

In this article we have seen how to use Mongo in a JEE Servlet. In the next article [step3] we will see how to we can improve this LogsServlet with Mongo JEE.


]]> http://angelozerr.wordpress.com/2013/05/11/mongo_jee_step2/feed/ 2 akrogen http://angelozerr.wordpress.com/2013/05/10/mongo_jee_step1/ http://angelozerr.wordpress.com/2013/05/10/mongo_jee_step1/#comments Fri, 10 May 2013 15:56:27 +0000 angelozerr http://angelozerr.wordpress.com/?p=7215 ]]> In [step0] we have introduced Mongo JEE articles, install and initialize Mongo DB websites database with Mongo Shell scripts. In this article we will do the same thing with Java code by using :
• the Mongo Java Driver.
• the Pojo Mapper MongoJack.

Download

You can download step1.zip which hosts the Eclipse Project which contains the explained sources in this article. To use it, unzip it and import this project in your Eclipse workspace. As soon as you will do that, your workspace will look like this :



• scripts folder contains the Javascript mongo operation (insert, remove etc) with Mongo Shell explained in the [step0].
• the Java package org.samples.mongodb.operations.javadriver contains the same Java mongo operations with Java Mongo Driver.
• the Java package org.samples.mongodb.operations.pojomapper.mongojack contains the same Java mongo operations with Pojo Mapper MongoJack.

Download JARs with maven

Each step*. project that I will provide use JARs. I could download at hand the JARs (awfull work), but I prefer using maven to manage dependencies.

So each step* project contains a pom.xml.

But as maven is not used by the whole people, the step* project contains the lib folder which hosts JARs and classpath of the eclipse project uses those JARs.

If you wish to download the JARs, you can do it with the command :

mvn process-resources

This command download the JARs from the central maven repository, and copy them in the lib folder.

Mongo Operations

Mongo Java Driver

In this section we use the Mongo Java Driver. I suggest you to read the Getting Started with Java Driver article which list the basic features of the driver.

Download driver

The driver is managed with the lib/mongo-java-driver-2.11.1.jar. To download it, I have used this maven dependency :

<dependency>
	<groupId>org.mongodb</groupId>
	<artifactId>mongo-java-driver</artifactId>
	<version>2.11.1</version>
</dependency>

Here the full pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.samples.mongodb</groupId>
	<artifactId>step1</artifactId>
	<packaging>pom</packaging>
	<version>0.0.1-SNAPSHOT</version>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>2.1</version>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>process-resources</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>lib</outputDirectory>
							<overWriteReleases>true</overWriteReleases>
							<overWriteSnapshots>true</overWriteSnapshots>
							<overWriteIfNewer>true</overWriteIfNewer>
							<excludeTypes>libd</excludeTypes>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>

	<dependencies>

		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>2.11.1</version>
		</dependency>
		
	</dependencies>

</project>

InsertLogsWithMongoJavaDriver.java

In the [step0], we have inserted logs with the following Javascript Mongo Shell :

for ( var i = 0; i < 100; i++) {
    db.logs.insert({
        "url" : "http://www.mongodb.org/",
        "created" : new Date()
    })
}

Here the same code with Java Mongo Driver :

package org.samples.mongodb.operations.javadriver;

import java.net.UnknownHostException;
import java.util.Calendar;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;

public class InsertLogsWithMongoJavaDriver {

	public static void main(String[] args) throws UnknownHostException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection coll = db.getCollection("logs");

			// Insert logs with DB object
			DBObject log = null;
			for (int i = 0; i < 100; i++) {
				log = new BasicDBObject();
				log.put("url", "https://github.com/angelozerr/mongo-jee");
				log.put("created", Calendar.getInstance().getTime());
				coll.insert(log);
			}

		} finally {
			mongo.close();
		}

	}
}

An interesting test to do, is to start this Java main without starting the Mongo DB. The following exception is thrown :

ATTENTION: Exception executing isMaster command on localhost/127.0.0.1:27017
java.net.ConnectException: Connection refused: connect
	at java.net.PlainSocketImpl.socketConnect(Native Method)

by the line code :

coll.insert(log);

So getting connection and getting DB collection code doesn’t throw exception even if DB is not started.

FindLogsWithMongoJavaDriver.java

In the [step0], we have displayed the total logs with the following Javascript Mongo Shell :

db.logs.find()

Here the same code with Java Mongo Driver :

package org.samples.mongodb.operations.javadriver;

import java.net.UnknownHostException;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;

public class FindLogsWithMongoJavaDriver_0 {

	public static void main(String[] args) throws UnknownHostException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection coll = db.getCollection("logs");

			// Find all DB object from the DB collection
			DBObject log = null;
			DBCursor cursor = coll.find();
			
			// Loop for each db object of the cursor.
			while (cursor.hasNext()) {
				log = cursor.next();
				System.err.println(log.toString());
			}
		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

If you execute it, you will see in the console the following JSON stream :

{ "_id" : { "$oid" : "518d01813bfe01bef797d031"} , 
  "url" : "http://www.mongodb.org/" , 
  "created" : { "$date" : "2013-05-10T14:17:37.515Z"}}
{ "_id" : { "$oid" : "518d01813bfe01bef797d032"} , 
  "url" : "http://www.mongodb.org/" , 
  "created" : { "$date" : "2013-05-10T14:17:37.515Z"}}
...

You can notice a little difference JSON representation with Mongo Shell :

{ "_id" : ObjectId("518d01813bfe01bef797d031"), 
  "url" : "http://www.mongodb.org/", 
  "created" : ISODate("2013-05-10T14:17:37.515Z") }
{ "_id" : ObjectId("518d01813bfe01bef797d032"), 
  "url" : "http://www.mongodb.org/", 
  "created" : ISODate("2013-05-10T14:17:37.515Z") }

It’s just the JSON representation which changes. For more information, please read MongoDB Extended JSON.

The Java JSON stream is not a valid JSON array (it miss the [] characters and , character between each JSON log.) The driver provides the com.mongodb.util.JSON helper which is used to serialize object as JSON. To generate a JSON array, replace the following code:

while (cursor.hasNext()) {
	log = cursor.next();
	System.err.println(log.toString());
}

with :

StringBuilder buf = new StringBuilder();
JSON.serialize(cursor, buf);
System.err.println(buf.toString());

Here the full Java code :

package org.samples.mongodb.operations.javadriver;

import java.net.UnknownHostException;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.util.JSON;

public class FindLogsWithMongoJavaDriver {

	public static void main(String[] args) throws UnknownHostException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection coll = db.getCollection("logs");

			// Find all DB object from the DB collection
			DBCursor cursor = coll.find();

			// Generate JSON array of the cursor.
			StringBuilder buf = new StringBuilder();
			JSON.serialize(cursor, buf);
			System.err.println(buf.toString());

		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

If you execute this class, you will see the following JSON array stream, on the console :

[ 
{ "_id" : { "$oid" : "518d01813bfe01bef797d031"} , 
  "url" : "http://www.mongodb.org/" , 
  "created" : { "$date" : "2013-05-10T14:17:37.515Z"}} , 
{ "_id" : { "$oid" : "518d01813bfe01bef797d032"} , 
  "url" : "http://www.mongodb.org/" , 
  "created" : { "$date" : "2013-05-10T14:17:37.515Z"}} ,
...]

RemoveLogsWithMongoJavaDriver.java

In the [step0], we have removed all logs with the following Javascript Mongo Shell :

db.logs.remove()

Here the same code with Java Mongo Driver :

package org.samples.mongodb.operations.javadriver;

import java.net.UnknownHostException;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;

public class RemoveLogsWithMongoJavaDriver {

	public static void main(String[] args) throws UnknownHostException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection coll = db.getCollection("logs");

			// remove all logs
			coll.remove(new BasicDBObject());

		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

FindPaginatedLogsWithMongoJavaDriver.java

In the [step0], we have displayed paginated logs with the following Javascript Mongo Shell :

var pageIndex = 0;
var pageSize = 5;
db.logs.find().skip(pageIndex).limit(pageSize);

Here the same code with Java Mongo Driver :

package org.samples.mongodb.operations.javadriver;

import java.net.UnknownHostException;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.util.JSON;

public class FindPaginatedLogsWithMongoJavaDriver {

	public static void main(String[] args) throws UnknownHostException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection coll = db.getCollection("logs");

			// Find paginated DB object from the DB collection
			int pageIndex = 0;
			int pageSize = 5;
			DBCursor cursor = coll.find().skip(pageIndex).limit(pageSize);

			// Generate JSON array of the cursor.
			StringBuilder buf = new StringBuilder();
			JSON.serialize(cursor, buf);
			System.err.println(buf.toString());

		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

Pojo Mapper MongoJack

Pojo Mapper gives you the capability to use Pojo instead of using Mongo DBObject. It follows the same idea than JPA.

It exists several Pojo Mapper that you can see here.

There are not a specification for Pojo Mapper Mongo (compared to JPA), so each Pojo Mapper provides their annotations to map the Pojo fields with Mongo JSON properties.

The whole Pojo Mappers uses the Mongo Java Driver.

I have choosen to use MongoJack as Pojo Mapper in my article because I think it’s the more fast than other Pojo Mappers. Indeed, it implements their own com.mongodb.DBDecoder (see org.mongojack.internal.stream.JacksonDBDecoder).

The other Pojo Mapper that I have studied uses the default DBDecoder of the driver : the pojo mapper uses this decoder to get DBObject and build a Pojo from this DBObject. With Mongojack, the JacksonDBDecoder creates directly the Pojo without creating an instance of DBObject.

Download MongoJack

To download MongoJack, I have used this maven dependency :

<dependency>
	<groupId>org.mongojack</groupId>
	<artifactId>mongojack</artifactId>
	<version>2.0.0-RC5</version>
</dependency>

Pojo Log

To use the Pojo Mapper Mongojack, we need to create a Pojo Log like this:

package org.samples.mongodb.operations.pojomapper.mongojack;

import java.util.Date;

import javax.persistence.Id;

public class Log {

	@Id
	private String id;

	private String url;
	private Date created;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public Date getCreated() {
		return created;
	}

	public void setCreated(Date created) {
		this.created = created;
	}

}

You can notice that the annotation javax.persistence.Id is used to map it with ObjectId.

InsertLogsWithMongoJack

Here the code to insert logs with Pojo Mapper Mongojack :

package org.samples.mongodb.operations.pojomapper.mongojack;

import java.net.UnknownHostException;
import java.util.Calendar;

import org.mongojack.JacksonDBCollection;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;

public class InsertLogsWithMongoJack {

	public static void main(String[] args) throws UnknownHostException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection dbColl = db.getCollection("logs");

			// Use Pojo Mapper MongoJack
			JacksonDBCollection<Log, String> coll = JacksonDBCollection.wrap(
					dbColl, Log.class, String.class);

			// Insert logs with Pojo Log
			Log log = null;
			for (int i = 0; i < 100; i++) {
				log = new Log();
				log.setUrl("http://mongojack.org/");
				log.setCreated(Calendar.getInstance().getTime());
				coll.insert(log);
			}

		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

FindLogsWithMongoJack

Here the code to find total logs with Pojo Mapper Mongojack :

package org.samples.mongodb.operations.pojomapper.mongojack;

import java.io.IOException;

import org.mongojack.DBCursor;
import org.mongojack.JacksonDBCollection;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;

public class FindLogsWithMongoJack {

	public static void main(String[] args) throws JsonGenerationException,
			JsonMappingException, IOException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection dbColl = db.getCollection("logs");

			// Use Pojo Mapper MongoJack
			JacksonDBCollection<Log, String> coll = JacksonDBCollection.wrap(
					dbColl, Log.class, String.class);

			// Find all Pojo Log from the MongoJack collection
			DBCursor<Log> cursor = coll.find();

			// Serialize list of Log as JSON
			ObjectMapper om = new ObjectMapper();
			om.writer().writeValue(System.err, cursor.toArray());

		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

RemoveLogsWithMongoJack

Here the code to remove total logs with Pojo Mapper Mongojack :

package org.samples.mongodb.operations.pojomapper.mongojack;

import java.net.UnknownHostException;

import org.mongojack.JacksonDBCollection;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;

public class RemoveLogsWithMongoJack {

	public static void main(String[] args) throws UnknownHostException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection dbColl = db.getCollection("logs");

			// Use Pojo Mapper MongoJack
			JacksonDBCollection<Log, String> coll = JacksonDBCollection.wrap(
					dbColl, Log.class, String.class);

			// remove all logs
			coll.remove(new BasicDBObject());

		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

FindPaginatedLogsWithMongoJack

Here the code to return paginated logs with Pojo Mapper Mongojack :

package org.samples.mongodb.operations.pojomapper.mongojack;

import java.io.IOException;

import org.mongojack.DBCursor;
import org.mongojack.JacksonDBCollection;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;

public class FindPaginatedLogsWithMongoJack {

	public static void main(String[] args) throws JsonGenerationException,
			JsonMappingException, IOException {

		// Connect to Mongo DB
		MongoClientURI mongoURI = new MongoClientURI(
				"mongodb://localhost:27017");
		MongoClient mongo = new MongoClient(mongoURI);
		try {

			// Get "logs" collection from the "websites" DB.
			DB db = mongo.getDB("websites");
			DBCollection dbColl = db.getCollection("logs");

			// Use Pojo Mapper MongoJack
			JacksonDBCollection<Log, String> coll = JacksonDBCollection.wrap(
					dbColl, Log.class, String.class);

			// Find paginated Pojo Log from the MongoJack collection
			int pageIndex = 0;
			int pageSize = 5;
			DBCursor<Log> cursor = coll.find().skip(pageIndex).limit(pageSize);

			// Serialize list of Log as JSON
			ObjectMapper om = new ObjectMapper();
			om.writer().writeValue(System.err, cursor.toArray());

		} finally {
			// close mongo connection
			mongo.close();
		}

	}
}

Conclusion

In this article we have seen how to manage with Java code basic mongo operations (insert, remove etc) with Mongo Java Driver and Pojo Mapper. Pojo Mapper requires to create a Pojo.

In the next article [step2], we will use Mongo in a JEE Servlet.


]]> http://angelozerr.wordpress.com/2013/05/10/mongo_jee_step1/feed/ 5 akrogen http://angelozerr.wordpress.com/2013/05/10/mongo_jee_step0/ http://angelozerr.wordpress.com/2013/05/10/mongo_jee_step0/#comments Fri, 10 May 2013 09:09:19 +0000 angelozerr http://angelozerr.wordpress.com/?p=7243 ]]> Several months ago, I have studied how to use Mongo DB in a JEE Application. I read the great article Modern Web Apps using JAX-RS, MongoDB, JSON, and jQuery which explains how to develop modern Web Apps :
• on client side, AJAX with jQuery is used to consume JSON by calling a REST service.
• on server side, REST service managed with JAX-RS produces JSON stream coming from MongoDB. The REST service calls MongoDB with mongo-jackson-mapper which gets JSON stream from MongoDB (which stores their data with BSON format which looks like JSON) and serializes the JSON to build a Pojo. The REST service returns the Pojo and JAX-RS implementation deserializes the Pojo to produce JSON for the jQuery client.

On other words, the server produces JSON and not the whole HTML page and the client consumes JSON to refresh the UI.

I like this architecture, but I tell me why we could to use directly the JSON stream from MongoDB instead of serialize/deserialize a Pojo. That’s why I have created Mongo JEE project which helps you to use Mongo in a JEE Application.

I have decided to write Mongo JEE articles which shows in action the feature of Mongo JEE. Those articles will explain step by step how to develop a Dojo Grid with pagination which consumes a JAX-RS REST service which produces JSON coming directly from the MongoDB with Java Driver and not with Pojo-Mapper. At the end of those articles we will have a paginated grid populated with logs data :



• step [1] : the user call the index.htm page.
• step [2] : the server returns the content of the index.htm page which contains the code of the Dojo grid (without the data).
• step [3] : once the dojo grid is built, it calls the REST service to populate the grid by sending on the HTTP Header the "Range" parameter (ex : items=0-9). This Range parameter tells to the server the from and to item index that grid needs to populate data.
• step [4] : the REST service request the MongoDB and returns the JSON coming from the MongoDB to the Web client. The dojo grid receives the JSON and populate the grid. When page link is clicked, the step [3] and [4] are re-played.

In this article, we will install and initialize MongoDB by creating a websites database which contains logs collection. A logs is just composed with date created and url.

MongoDB Install

Choose the mongo distribution

MongoDB Install is very easy, you must just download the well distribution according your OS. In my case, I have Windows XP, and since 2.2, MongoDB doesn’t support Windows XP.

So if you use Windows XP, the last version of MongoDB that you can use is the 2.0.8 that you can download mongodb-win32-i386-2.0.8.zip.

Unzip mongo distribution

Unzip mongodb-win32-i386-2.0.8.zip in any folder of your hard disk. In my case I have unzipped it in the D:/MongoDB :



Create data folder

MongoDB needs a folder to store data of the database. By default it search the data in the /data/db folder. In my case as I have installed my Mongo in D: folder, so I must create the data folder D:\data\db :



Start mongo

At this step, MongoDB is installed and now we can start it. To do that open a DOS command prompt and go at bin folder of the Mongo

In my case :

D:
cd D:\MongoDB\mongodb-win32-i386-2.0.8\bin

And after start the Mongo process by typing :

mongod



This process starts the MongoDB and listen by default to the 27017 port :



If you see the data folder, you will notice that a mongod.lock file is created with 1Ko:



It means that Mongo DB lock the files of the data folder.

When you stop the Mongo DB (with Ctrl+C) :



The mongod.lock file is updated with 0Ko:



I have noticed that if MongoDB is not stopped with clean mean (eg : Mongo DB crashes), the mongod.lock file can have 1Ko and it’s impossible to restart the Mongo.
To fix this problem, you must remove at hand this file before trying to restart it.

Initialize DB

Just for information, Mongo DB is composed with :

• several databases
• each database contains several collections (it’s like Table for SQL).
• each collection contains several document (or object) which are structured with JSON format (BSON) (it’s like record for SQL).

At this step we can initialize the DB by creating a websites database which contains BSON document log in the logs collection. To do that we can do it with several means (in a Java world) :

• Mongo Shell scripts
• Java code which uses Mongo Java Driver
• Pojo Mapper. You can compare Pojo Mapper to JPA. Pojo Mapper uses the Mongo Java Driver to connect to the Mongo and create a Pojo. Each Pojo Mapper provides their own annotations to manage the mapping between getter/setter of the Pojo and the BSON document property.

In this article we will use Mongo Shell scripts and in the next article [step1] Mongo Java Driver, and a Pojo Mapper.

Mongo Shell scripts

The mongo shell is an interactive JavaScript shell for MongoDB, and is part of all MongoDB distributions.

To use it, open a DOS command prompt and go at bin folder of the Mongo

In my case :

D:
cd D:\MongoDB\mongodb-win32-i386-2.0.8\bin

And after start the Mongo shell by typing :

mongo



This command open the Mongo Shell and connect it to "test" database. It doesn’t exists some commands to create a database. The database is created as soon as a first document is created.
In our case we wish to have websites database which contains logs collection. To do that, type this command :

use websites



If you see the data folder, you will notice that websites files is not created.

InsertLogsWithMongoShell.js

To insert logs with Mongo shell copy/paste this javascript in the shell :

for ( var i = 0; i < 100; i++) {
	db.logs.insert({
		"url" : "http://www.mongodb.org/",
		"created" : new Date()
	})
}

Key "Enter" to execute this script.



You can notice that there are no commit, because Mongo DB is not transactional.

If you see the data folder you will notice that websites* files which contains data are created :



FindLogsWithMongoShell.js

To check that our logs was inserted correctly, copy/paste this script :

db.logs.find()

Key "Enter" to execute this script and you will see the data logs as JSON format :



You can notice that there are "_id" property (that we have not filled). Each JSON document have an unique "_id" (that you can fill it if you wish).

RemoveLogsWithMongoShell.js

Here a script which removes logs:

db.logs.remove()

FindPaginatedLogsWithMongoShell.js

In your case we will need pagination logs. Here the script which manage pagination for logs collection :

var pageIndex = 0;
var pageSize = 5;
db.logs.find().skip(pageIndex).limit(pageSize);

Conclusion

In this step we have introduce Mongo JEE articles, install and initialize Mongo DB websites database with Mongo Shell scripts. In the next article [step1], we will use Java Mongo Driver and a Pojo Mapper to do the same thing.


]]> http://angelozerr.wordpress.com/2013/05/10/mongo_jee_step0/feed/ 1 akrogen http://angelozerr.wordpress.com/2012/12/06/how-to-convert-docxodt-to-pdfhtml-with-java/ http://angelozerr.wordpress.com/2012/12/06/how-to-convert-docxodt-to-pdfhtml-with-java/#comments Thu, 06 Dec 2012 12:26:25 +0000 angelozerr http://angelozerr.wordpress.com/?p=7020 ]]> How to convert docx/odt to pdf/html with Java? This question comes up all the time in any forum like stackoverflow. So I decided to write an article about this topic to enumerate the Java (open source) frameworks which manages that.

Here some paid product which manages docx/odt to pdf/html converters :

• Aspose.Words for Java which manages only docx converter.
• Docmosis which manages docx and odt converters.
• Muhimbi PDF Converter Services.

To be honest with you, I have not tried those solution because it’s not free. I will not speak about them in this article.

Here some open source product which manages docx/odt to pdf/html converters :

• JODConverter : JODConverter automates conversions between office document formats using OpenOffice.org or LibreOffice. Supported formats include OpenDocument, PDF, RTF, HTML, Word, Excel, PowerPoint, and Flash. It can be used as a Java library, a command line tool, or a web application.
• docx4j: docx4j is a Java library for creating and manipulating Microsoft Open XML (Word docx, Powerpoint pptx, and Excel xlsx) files. It is similar to Microsoft’s OpenXML SDK, but for Java. docx4j uses JAXB to create the in-memory object representation.
• XDocReport which provides:
  • docx converters which works with Apache POI XWPF and iText 2.3.7 for PDF.
  • odt converters which works with ODFDOM and iText 2.3.7 for PDF.

Here criteria that I think which are important for converters :

• best renderer : the converter must not loose some formatting information.
• fast : the converter must be the more fast.
• less memory intensive to avoid OutOfMemory problem.
• streaming: use InputStream/OutputStream instead of File. Using streaming instead of File, avoids some problems (hard disk is not used, no need to have write right on the hard disk)
• easy to install: no need to install OpenOffice/LibreOffice, MS Word on the server to manage converter.

In this article I will introduce those 3 Java frameworks converters and I will compare it to give Pros/Cons for each framework and try to be more frankly because I’m one of XDocReport developer.

If you want to compare result of conversion, performance, etc of docx4j and XDocReport quickly, you can play with our live demo which provides a JAX-RS REST converter service.

Sorry with my English!

Before starting to read this article, I would like to apologize me with my bad English. I don’t want to say "XDocReport is the best" and I don’t want to have some offence with JODConverter, docx4j, FOP guys. Goal of this article is to introduce those 3 frameworks converters and share my skills about odt and docx converters to PDF.

Download

You can download samples of docx/odt converters explained in this article :

• org.samples.docxconverters.jodconverter.zip : samples of conversion docx to PDF/HTML with JODConverter.
• org.samples.docxconverters.docx4j.zip samples of conversion docx to PDF/HTML with docx4j.
• org.samples.docxconverters.xdocreport.zip samples of conversion docx to PDF/HTML with XDocReport (Apache POI XWPF).

How to manage PDF with Java?

Here the 3 best famous Java PDF libraries:

• Apache FOP: Apache FOP (Formatting Objects Processor) is a print formatter driven by XSL formatting objects (XSL-FO) and an output independent formatter. It is a Java application that reads a formatting object (FO) tree and renders the resulting pages to a specified output. Output formats currently supported include PDF, PS, PCL, AFP, XML (area tree representation), Print, AWT and PNG, and to a lesser extent, RTF and TXT. The primary output target is PDF.
• Apache PDFBox: The Apache PDFBox library is an open source Java tool for working with PDF documents. This project allows creation of new PDF documents, manipulation of existing documents and the ability to extract content from documents. Apache PDFBox also includes several command line utilities. Apache PDFBox is published under the Apache License v2.0
• iText: iText is a library that allows you to create and manipulate PDF documents. It enables developers looking to enhance web- and other applications with dynamic PDF document generation and/or manipulation.

  With iText, there are 2 versions:

  • 2.3.x which is MPL License.
  • 5.x which is AGPL License.

How to convert docx/odt to pdf/html with Java?

Just for information, docx and odt files are a zip which is composed with:

• several xml entries like word/document.xml (docx), content.xml (odt) which describes with XML the content of the document, styles.xml which describes used styles, etc.
• binary data for image.

To compare performance between JODConverter, docx4j, XDocReport framework converters, tests must follow 2 rules:

• logs must be disabled to ignore time of generated log (ex: docx4j generates a lot of logs which degrade the performance).
• convert twice the docx/odt to html/pdf, to ignore time of the initialization of the framework converter (ex: ignore time of connection to LibreOffice with JODConverter, ignore time of the load of JAXB classes of docx4j, etc). To compare our converters frameworks, we will convert twice the docx and will retain the last elapsed time.

To compare the result quality of the conversion, I have tried to use on each samples converters project, several docx which are designed with Table (border, rows/cols span), Header/Footer, images etc. In this article we will just study simple docx HelloWorld.docx :



But you can launch the other docx of each Java Eclipse Project to see the result of html and pdf conversion.

JODConverter with docx

To test and use JODConverter, you need to install OpenOffice or LibreOffice. In my case I have installed LibreOffice 3.5 on Windows.

org.samples.docxconverters.jodconverter Eclipse project that you can download here is sample of docx converter with JODConverter. This project contains:

• docx folder which contains several docx to convert. Those docx comes from the XDocReport Git that we use to test our converter.
• pdf and html folders where docx will be converted.
• lib folder whith JODConverter and dependencies JARs.



Download JARs

To download JODConverter JARs, download the zip jodconverter-core-3.0-beta-4-dist.zip, unzip it and copy paste the lib folder of the zip to your Eclipse Java project. Add those JARs in your classpath.

My test was done with LibreOffice 3.5 and the official distribution doesn’t work with LibreOffice 3.5 (see issue 103).
To fix this problem, I have replaced the official JARs jodconverter-core-3.0-beta-4.jar with jodconverter-core-3.0-beta-4-jahia2.jar.

HTML converter

Here the JODConverter Java code which converts twice the "docx/HelloWorld.docx" to "html/HelloWorld.html":

 
package org.samples.docxconverters.jodconverter.html;

import java.io.File;

import org.artofsolving.jodconverter.OfficeDocumentConverter;
import org.artofsolving.jodconverter.office.DefaultOfficeManagerConfiguration;
import org.artofsolving.jodconverter.office.OfficeManager;

public class HelloWorldToHTML {

	public static void main(String[] args) {

		// 1) Start LibreOffice in headless mode.
		OfficeManager officeManager = null;
		try {
			officeManager = new DefaultOfficeManagerConfiguration()
					.setOfficeHome(new File("C:/Program Files/LibreOffice 3.5"))
					.buildOfficeManager();
			officeManager.start();

			// 2) Create JODConverter converter
			OfficeDocumentConverter converter = new OfficeDocumentConverter(
					officeManager);

			// 3) Create HTML
			createHTML(converter);
			createHTML(converter);

		} finally {
			// 4) Stop LibreOffice in headless mode.
			if (officeManager != null) {
				officeManager.stop();
			}
		}
	}

	private static void createHTML(OfficeDocumentConverter converter) {
		try {
			long start = System.currentTimeMillis();
			converter.convert(new File("docx/HelloWorld.docx"), new File(
					"html/HelloWorld.html"));
			System.err.println("Generate html/HelloWorld.html with "
					+ (System.currentTimeMillis() - start) + "ms");
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
}

You can notice that code uses java.io.File for docx input and html output because JODConverter cannot work with Streaming.

After running this class, you will see on the console few JODConverter logs and the elapsed time of the conversion :

Generate html/HelloWorld.html with 12109ms
Generate html/HelloWorld.html with 391ms

JODConverter converts a simple HelloWorld.docx to HTML with 391ms. The quality of the conversion is perfect.

Note that, in my case the connection to LibreOffice takes a long time (5219ms) and disconnection too.

PDF converter

Here the JODConverter Java code which converts twice the "docx/HelloWorld.docx" to "pdf/HelloWorld.pdf":

package org.samples.docxconverters.jodconverter.pdf;

import java.io.File;

import org.artofsolving.jodconverter.OfficeDocumentConverter;
import org.artofsolving.jodconverter.office.DefaultOfficeManagerConfiguration;
import org.artofsolving.jodconverter.office.OfficeManager;

public class HelloWorldToPDF {

	public static void main(String[] args) {

		// 1) Start LibreOffice in headless mode.
		OfficeManager officeManager = null;
		try {
			officeManager = new DefaultOfficeManagerConfiguration()
					.setOfficeHome(new File("C:/Program Files/LibreOffice 3.5"))
					.buildOfficeManager();
			officeManager.start();

			// 2) Create JODConverter converter
			OfficeDocumentConverter converter = new OfficeDocumentConverter(
					officeManager);

			// 3) Create PDF
			createPDF(converter);
			createPDF(converter);

		} finally {
			// 4) Stop LibreOffice in headless mode.
			if (officeManager != null) {
				officeManager.stop();
			}
		}
	}

	private static void createPDF(OfficeDocumentConverter converter) {
		try {
			long start = System.currentTimeMillis();
			converter.convert(new File("docx/HelloWorld.docx"), new File(
					"pdf/HelloWorld.pdf"));
			System.err.println("Generate pdf/HelloWorld.pdf with "
					+ (System.currentTimeMillis() - start) + "ms");
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
}

After running this class, you will see on the console few JODConverter logs and the elapsed time of the conversion :

Generate pdf/HelloWorld.pdf with 3172ms
Generate pdf/HelloWorld.pdf with 468ms

JODConverter converts a simple HelloWorld.docx to PDF with 468ms. The quality of the conversion is perfect.

docx4j

dox4j provides several docx converters :

• docx to HTML converter.
• docx to PDF converter based on XSL-FO and FOP.

org.samples.docxconverters.docx4j Eclipse project that you can download here is sample of docx converter with docx4j. This project contains:

• docx folder which contains several docx to convert. Those docx comes from the XDocReport Git that we use to test our converter.
• pdf and html folders where docx will be converted.
• lib folder whit docx4j and dependencies JARs.



For docx4j, logs must be disabled because it generates a lot of logs which degrade the performance. To do that :

• create src/docx4j.properties like this :

  docx4j.Log4j.Configurator.disabled=true

• create src/log4j.properties like this :

  log4j.rootLogger=ERROR

Donload

with maven

To download docx4j and their dependencies JARS, the best mean is to use maven with this pom:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.samples.docxconverters.docx4j</groupId>
	<artifactId>org.samples.docxconverters.docx4j</artifactId>
	<packaging>pom</packaging>
	<version>0.0.1-SNAPSHOT</version>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>2.1</version>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>process-resources</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>lib</outputDirectory>
							<overWriteReleases>true</overWriteReleases>
							<overWriteSnapshots>true</overWriteSnapshots>
							<overWriteIfNewer>true</overWriteIfNewer>
							<excludeTypes>libd</excludeTypes>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>

	<dependencies>

		<dependency>
			<groupId>org.docx4j</groupId>
			<artifactId>docx4j</artifactId>
			<version>2.8.1</version>
		</dependency>

	</dependencies>

</project>

After you can do :

mvn process-resources

and it will download the well JARs and will copy it to the lib folder.

without maven

Go at docx4j downloads.

HTML converter

Here the docx4j Java code which converts twice the "docx/HelloWorld.docx" to "html/HelloWorld.html":

 
package org.samples.docxconverters.docx4j.html;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import javax.xml.transform.stream.StreamResult;

import org.docx4j.convert.out.html.AbstractHtmlExporter;
import org.docx4j.convert.out.html.AbstractHtmlExporter.HtmlSettings;
import org.docx4j.convert.out.html.HtmlExporterNG2;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;

public class HelloWorldToHTML {

	public static void main(String[] args) {
		createHTML();
		createHTML();
	}

	private static void createHTML() {
		try {
			long start = System.currentTimeMillis();

			// 1) Load DOCX into WordprocessingMLPackage
			InputStream is = new FileInputStream(new File(
					"docx/HelloWorld.docx"));
			WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage
					.load(is);

			// 2) Prepare HTML settings
			HtmlSettings htmlSettings = new HtmlSettings();

			// 3) Convert WordprocessingMLPackage to HTML
			OutputStream out = new FileOutputStream(new File(
					"html/HelloWorld.html"));
			AbstractHtmlExporter exporter = new HtmlExporterNG2();
			StreamResult result = new StreamResult(out);
			exporter.html(wordMLPackage, result, htmlSettings);

			System.err.println("Generate html/HelloWorld.html with "
					+ (System.currentTimeMillis() - start) + "ms");

		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

}

You can notice that code uses InputStream/OutputStream (Streaming) for docx input and html output.

After running this class, you will see on the console the elapsed time of the conversion :

Generate html/HelloWorld.html with 5109ms
Generate html/HelloWorld.html with 47ms

docx4j converts a simple HelloWorld.docx to HTML with 47ms. The quality of the conversion is perfect.

PDF converter

Here the docx4j Java code which converts twice the "docx/HelloWorld.docx" to "pdf/HelloWorld.pdf":

 
package org.samples.docxconverters.docx4j.pdf;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import org.docx4j.convert.out.pdf.PdfConversion;
import org.docx4j.convert.out.pdf.viaXSLFO.PdfSettings;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;

public class HelloWorld2PDF {

	public static void main(String[] args) {
		createPDF();
		createPDF();
	}

	private static void createPDF() {
		try {
			long start = System.currentTimeMillis();

			// 1) Load DOCX into WordprocessingMLPackage
			InputStream is = new FileInputStream(new File(
					"docx/HelloWorld.docx"));
			WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage
					.load(is);

			// 2) Prepare Pdf settings
			PdfSettings pdfSettings = new PdfSettings();

			// 3) Convert WordprocessingMLPackage to Pdf
			OutputStream out = new FileOutputStream(new File(
					"pdf/HelloWorld.pdf"));
			PdfConversion converter = new org.docx4j.convert.out.pdf.viaXSLFO.Conversion(
					wordMLPackage);
			converter.output(out, pdfSettings);

			System.err.println("Generate pdf/HelloWorld.pdf with "
					+ (System.currentTimeMillis() - start) + "ms");

		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

}

You can notice that code uses InputStream/OutputStream (Streaming) for docx input and pdf output.

After running this class, you will see on the console the elapsed time of the conversion :

Generate pdf/HelloWorld.pdf with 16156ms
Generate pdf/HelloWorld.pdf with 219ms

docx4j converts a simple HelloWorld.docx to PDF with 219ms. The quality of the conversion is perfect.

XDocReport (Apache POI XWPF)

XDocReport provides docx converters based on Apache POI XWPF:

• docx to html converter based on SAX (and not DOM).
• docx to pdf converter based on iText 2.3.7.

Pay attention, this converter works only with docx and not with doc format. If you wish convert doc format, please see the official converter of Apache POI.

The basic idea with XDocReport (Apache POI XWPF) is to

1. load docx with XWPFDocument Apache POI XWPF.
2. loop for each XWPF Java structures (XWPFParagraph, XWPFTable etc) of the loaded XWPFDocument to
   • generate HTML with SAX for html converter.
   • generate PDF with iText structure (Paragraph, table etc).

org.samples.docxconverters.xdocreport Eclipse project that you can download here is sample of docx converter with XDocReport (Apache POI XWPF). This project contains:

• docx folder which contains several docx to convert. Those docx comes from the XDocReport Git that we use to test our converter.
• pdf and html folders where docx will be converted.
• lib folder whit XDocReport and dependencies JARs.



Donload

with maven

To download XDocReport (Apache POI XWPF) and their JARs dependencies the best mean is to use maven with this pom:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.samples.docxconverters.xdocreport</groupId>
	<artifactId>org.samples.docxconverters.xdocreport</artifactId>
	<packaging>pom</packaging>
	<version>0.0.1-SNAPSHOT</version>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>2.1</version>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>process-resources</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>lib</outputDirectory>
							<overWriteReleases>true</overWriteReleases>
							<overWriteSnapshots>true</overWriteSnapshots>
							<overWriteIfNewer>true</overWriteIfNewer>
							<excludeTypes>libd</excludeTypes>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<dependency>
			<groupId>fr.opensagres.xdocreport</groupId>
			<artifactId>org.apache.poi.xwpf.converter.xhtml</artifactId>
			<version>1.0.0</version>
		</dependency>
		<dependency>
			<groupId>fr.opensagres.xdocreport</groupId>
			<artifactId>org.apache.poi.xwpf.converter.pdf</artifactId>
			<version>1.0.0</version>
		</dependency>
	</dependencies>

</project>

After you can do :

mvn process-resources

and it will download the well JARs and will copy it to the lib folder.

without maven

You can download docx.converters-xxx-sample.zip which contains the well JARs.

HTML converter

Here the XDocReport (Apache POI XWPF) Java code which converts twice the "docx/HelloWorld.docx" to "html/HelloWorld.html":

 
package org.samples.docxconverters.xdocreport.html;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.poi.xwpf.converter.xhtml.XHTMLConverter;
import org.apache.poi.xwpf.converter.xhtml.XHTMLOptions;
import org.apache.poi.xwpf.usermodel.XWPFDocument;

public class HelloWorldToHTML {

	public static void main(String[] args) {
		createHTML();
		createHTML();
	}

	private static void createHTML() {
		try {
			long start = System.currentTimeMillis();

			// 1) Load DOCX into XWPFDocument
			InputStream is = new FileInputStream(new File(
					"docx/HelloWorld.docx"));
			XWPFDocument document = new XWPFDocument(is);

			// 2) Prepare Html options
			XHTMLOptions options = XHTMLOptions.create();

			// 3) Convert XWPFDocument to HTML
			OutputStream out = new FileOutputStream(new File(
					"html/HelloWorld.html"));
			XHTMLConverter.getInstance().convert(document, out, options);

			System.err.println("Generate html/HelloWorld.html with "
					+ (System.currentTimeMillis() - start) + "ms");

		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
}

You can notice that code uses InputStream/OutputStream (Streaming) for docx input and html output.

After running this class, you will see on the console the elapsed time of the conversion :

Generate html/HelloWorld.html with 828ms
Generate html/HelloWorld.html with 32ms

XDocReport (Apache POI XWPF) converts a simple HelloWorld.docx to HTML with 32ms. The quality of the conversion is perfect.

PDF converter

Here the XDocReport (Apache POI XWPF) Java code which converts twice the "docx/HelloWorld.docx" to "pdf/HelloWorld.pdf":

 
package org.samples.docxconverters.xdocreport.pdf;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.poi.xwpf.converter.pdf.PdfConverter;
import org.apache.poi.xwpf.converter.pdf.PdfOptions;
import org.apache.poi.xwpf.usermodel.XWPFDocument;

public class HelloWorldToPDF {

	public static void main(String[] args) {
		createPDF();
		createPDF();
	}

	private static void createPDF() {
		try {
			long start = System.currentTimeMillis();

			// 1) Load DOCX into XWPFDocument
			InputStream is = new FileInputStream(new File(
					"docx/HelloWorld.docx"));
			XWPFDocument document = new XWPFDocument(is);

			// 2) Prepare Pdf options
			PdfOptions options = PdfOptions.create();

			// 3) Convert XWPFDocument to Pdf
			OutputStream out = new FileOutputStream(new File(
					"pdf/HelloWorld.pdf"));
			PdfConverter.getInstance().convert(document, out, options);
			
			System.err.println("Generate pdf/HelloWorld.pdf with "
					+ (System.currentTimeMillis() - start) + "ms");
			
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
}

You can notice that code uses InputStream/OutputStream (Streaming) for docx input and pdf output.

After running this class, you will see on the console the elapsed time of the conversion :

Generate pdf/HelloWorld.pdf with 1375ms
Generate pdf/HelloWorld.pdf with 63ms

XDocReport (Apache POI XWPF) converts a simple HelloWorld.docx to PDF with 63ms. The quality of the conversion is perfect.

Comparison

docx converters with HelloWorld

Framework	Fast for HTML?	Fast for PDF?	Less memory intensive	Streaming	Easy to install?
JODConverter	391ms	468ms	Don’t know how to test that?	No	No because it requires installation of OpenOffice/LibreOffice
docx4j	47ms	219ms	OutOffMemory when memory is not enough	Yes	Yes
XDocReport	32ms	63ms	Yes	Yes	Yes

what about with complex docx conversion?

At this step we have seen how to convert a simple docx to html and pdf with JODConverter, docx4j and XDocReport (Apache POI XWPF).

But docx can be more complex like table, paragraph, header footer, image etc. To compare the result of html and pdf conversion, you can start the other classes *ToHTML and *ToPDF inluded in the 3 projects.

It’s difficult to tell which framework converter is the best : it depends of the content of docx :

• JODConverter doesn’t manage correctly border table (see FormattingTests.docx).
• docx4j have problems with table border styled for first/end row (see AdvancedTable.docx).
• XDocReport has problems with bulleted list (see Resume.docx)

If you have problem with XDocReport, please create an issuse with your attached docx or odt by explaining your problem.

Conclusion

JODConverter

The Pros with JODConverter is that it is based on OpenOffice/LibreOffice which is a powerfull software to manage the write and convert document. The quality of the conversion is very good.

However, in my case with LibreOffice 3.5, I have several problems with docx conversion to pdf with table borders (see FormattingTests.docx), rows/cols spans (see TableWithRowsColsSpanToPDF).

The Cons with JODConverter is:

• you must install OpenOffice/LibreOffice on your server side
• you must have write rights on your server side, because it doesn’t manage Streaming.
• performance is not very good.

docx4j

Pros for docx4j is a great library to manage docx (merge several docx, compare it, etc). It provides several implemention for Conversion to PDF like FOP and iText which manages streaming and are easy to install (no need to install MS Word or OpenOffice/LibreOffice). But iText version is not official and have not a good renderer. Conversion with FOP have a good renderer.

The Cons with docx converter with FOP is:

• FOP is more slow than iText.
• with FOP you can have problems with OutOfMemory. In our case we needed to add memory on the Tomcat Server on Cloudbee for our live demo to avoid OutOfMemory.

More it uses some XSLT (for XSL-FO). I’m not a big fan with XSL : debugging XSL is very hard (debugging Java is easy). I think docx4j should switch to iText conversion implementation instead of FOP. FOP is very powerfull, but in the case of odt/docx converter I think it’s better to use iText.

I think FOP should provide the capability to create PDF with Java model like iText and not only with FO. I have posted my suggestion on FOP forum but I had had none answer.

XDocReport

Since XDocReport 1.0.0, odt/docx converters was improved a lot. There are fast, uses less memory intensive, manage streaming and are easy to install (no need to install MS Word or OpenOffice/LobreOffice).

The quality of the renderer manage a lot of cases, but it’s not magic and there are again problems like with table border, bullet-ed/numbered list shapes which are not managed.

HTML converters should be more improved (manage table border, bullet-ed/numbered list etc).

Note that XDocReport provides a REST Converter services (you can use XDocReport (Apache POI XWPF) or docx4j). With this feature you can use those converter with any technologies like PHP, C#, Python, etc by developping a REST client.

What about with odt converter?

To convert odt to PDF or HTML, you can use :

• JODConverter.
• XDocReport (ODFDOM) converter for convert odt to PDF or HTML. To test those converter you can :
  • play with our live demo.
  • download XDocReport (ODFDOM) converter samples in the odt.converters-xxx-sample.zip.

]]> http://angelozerr.wordpress.com/2012/12/06/how-to-convert-docxodt-to-pdfhtml-with-java/feed/ 15 akrogen http://angelozerr.wordpress.com/2012/06/18/eclipse_spring_dosgi_step4/ http://angelozerr.wordpress.com/2012/06/18/eclipse_spring_dosgi_step4/#comments Mon, 18 Jun 2012 07:30:33 +0000 angelozerr http://angelozerr.wordpress.com/?p=6732 ]]> In [step3] we have managed our UserService on Client and Server side with JAX-RS and Apache CXF DOSGi.

Embedding an HTTP server in Equinox

At this step the server side works with the HTTP Server Jetty which is an OSGi bundles. This mode is called Embedding an HTTP server in OSGi container : it means that HTTP server and WEB application are OSGi bundles. The OSGi container starts the HTTP server bundle. Embedding an HTTP server in Equinox explains how this mean is done with Equinox.

You can resume "embedding an HTTP server in OSGi container" like this :

OSGi container -> HTTP Server (bundle) -> WEB Application (bundle).

Equinox in a Servlet Container (ServletBridge)

It works great but sometimes you have not the luck to have an HTTP Server which supports OSGi like Apache Tomcat. For instance in our case, when we wished to deploy our XDocReport RAP Application on CloudBees, whish provides an Non OSGI HTTP Server Apache Tomcat.

Fortunatly, Server-Side Equinox provides Embedding OSGi container in a servlet container mode : it means that it’s a WEB Application which contains the OSGi container (and another bundles) which start the OSGi container. Equinox in a Servlet Container explains how this mean is done with Equinox.
You can resume "embedding OSGi container in a servlet container" like this :

HTTP Server -> WEB Application -> OSGi container.

To manage this mode you must create a classic WAR which hosts your OSGi plugins and ServletBridge. In this article we will explain how to create a WAR with our UserService on server side with the Eclipse Plug-In Libra WAR Product which was created for creating WAR from RAP Application launches. But it can be used too with OSGi launches (like we need in this article).

To create a WAR of CXF DOSGi application (server side), you must :

• register your JAX-RS service with HttpService :

  <!-- HttpService -->
  <entry key="org.apache.cxf.rs.httpservice.context" value="/UserService" />
  

• create a WAR which hosts OSGi bundles and ServletBridge. WAR Product gives you the capability to create a *.warproduct file from a launch (RAP, RCP, OSGi lanches, etc). This *.warproduct file is used to export it into a WAR to generate WAR.

At the end of this article we will create the the cxf-dosgi-jpa.war WAR. I have deployed this WAR on the CloudBees to see it on action. You can test for instance go at http://cxf-dosgi-war.opensagres.cloudbees.net/UserService/user/findAll to see JSON of the all users.

Download

WAR

You can download the following WAR that we will create in this article:

• cxf-dosgi-jpa.war

Bundles

You can download eclipse_spring_dosgi_step4.zip which contains the bundles and JARs explained in this article.

To use this zip, unzip it :

1. import those projects in a workspace.
2. open the TargetPlatform/eclipsespring.target file and click on Set as Target Platform. If you have problem with Target Definition, please read Problem with Install with Nebula (Incubation) P2.
3. select TargetPlatform/launch/Server Remoting – JAXRS DOSGi – JPA Dao.launch to test the Remoting UserService JAX-RS with Mock Dao and Run it.
4. select TargetPlatform/launch/Server Remoting – JAXRS DOSGi – JPA Dao.launch to test the Remoting UserService JAX-RS with JPA Dao and Run it.
5. select TargetPlatform/launch/Client Remoting – JAXRS DOSGi – Simple OSGi Client.launch to test the Client Remoting UserService JAX-RS and Run it.

Prerequisite

Install WAR Product Plug-in

To follow this article you must install Eclipse Plug-In Libra WAR Product. To do that, please read Install WAR Product article.

Install RAP Target Platform.

To create a WAR from a WAR Product created by an OSGi launches, we need ServletBridge. The more easy mean is to install RAP Target Platform. To do that, open the TargetPlatform/eclipsespring_rap.target file and click on Set as Target Platform. If you have problem with Target Definition, please read Problem with Install with Nebula (Incubation) P2 :



Server Remoting – JAXRS DOSGi – JPA Dao [RAP TP]

The launch works with with Embedding an HTTP server in OSGi container mode, on other words the HTTP Server (Jetty) is an OSGi bundle. The OSGi container (Equinox) starts the HTTP Server which is a n OSGi bundle.

The Server Remoting – JAXRS DOSGi – JPA Dao launch was created when RCP Target Platform was activated. Now we have activated RAP Target Platform, so we need adjust a little this launch. To do that duplicate Server Remoting – JAXRS DOSGi – JPA Dao to Server Remoting – JAXRS DOSGi – JPA Dao [RAP TP].

After that, you must modify the launch, by selecting:

• javax.servlet.

and selecting:

• org.eclipse.equinox.console.
• org.apache.felix.gogo.shell.
• org.apache.felix.gogo.runtime.

to avoid having this error :

!MESSAGE Could not find bundle: org.eclipse.equinox.console
!STACK 0
org.osgi.framework.BundleException: Could not find bundle: org.eclipse.equinox.console
	at org.eclipse.osgi.framework.internal.core.ConsoleManager.checkForConsoleBundle(ConsoleManager.java:211)
fr.opensagres.dao.jpa.eclipselink

Run the launch, open a WEB Browser and go at http://127.0.0.1:9000/fr/opensagres/services/UserService/user/findAll , you will see JSON content :



{"user":[{"firstName":"Angelo","lastName":"Zerr"},{"firstName":"Pascal","lastName":"Leclercq"},{"firstName":"Amine","lastName":"Bousta"},{"firstName":"Mickael","lastName":"Baron"},{"firstName":"Jawher","lastName":"Moussa"},{"firstName":"Arnaud","lastName":"Cogoluegnes"},{"firstName":"Lars","lastName":"Vogel"},{"firstName":"Olivier","lastName":"Gierke"},{"firstName":"Tom","lastName":"Schindl"},{"firstName":"Wim","lastName":"Jongman"}]}

Server Remoting – JAXRS DOSGi – Mock Dao [RAP TP]

You can do the same thing for the Mock Dao by creating the Server Remoting – JAXRS DOSGi – Mock Dao [RAP TP] by duplicating the Server Remoting – JAXRS DOSGi – Mock Dao launch.

Modify fr.opensagres.dao.jpa.eclipselink

Remove the .qualifier used in the OSGi Fragment fr.opensagres.dao.jpa.eclipselink for Hosts:



to avoid having this error



when WAR will be generated. For more information please read Create a WAR from RAP Application with Libra WAR Product [step3].

HttpService

ServletBridge works with "Equinox in a Servlet Container (ServletBridge)" mode, it means that it’s classic WEB Application with web.xml which declares ServletBridge servlet. This servlet starts the OSGi container Equinox. This ServletBridge provides too an implementation of HttpService which is registered in the OSGi services registry. The HttpService gives the capability to register/unregister a Servlet.

To use ServletBridge with CXF DOSGi, the JAX-RS service must be registered in the HttpService.

Manage ONLY Equinox in a Servlet Container (ServletBridge)

The section Service Provider properties For Configuring RESTful JAXRS-based endpoints and consumers shows you that it’s possible to do that with the org.apache.cxf.rs.httpservice.context property.

In our case we will do that:

<!-- HttpService -->
<entry key="org.apache.cxf.rs.httpservice.context" value="/UserService" />

and our service will be available with /UserService path like http://cxf-dosgi-war.opensagres.cloudbees.net/UserService?_wadl whish shows you the WADL of the UserService on the CloudBees.

Modify the META-INF/spring/module-osgi-context.xml of the fr.opensagres.remoting.exporter.dosgi.jaxrs bundle like this:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:osgi="http://www.springframework.org/schema/osgi"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                      http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi.xsd">

	<osgi:reference id="userService" interface="fr.opensagres.services.UserService" />

	<osgi:service interface="fr.opensagres.services.UserService">
		<osgi:service-properties>
			<entry key="service.exported.interfaces" value="*" />
			<entry key="service.exported.configs" value="org.apache.cxf.rs" />
			<entry key="service.exported.intents" value="HTTP" />
			<entry key="org.apache.cxf.rs.databinding" value="jaxb" />
			<!-- Logs -->
			<entry key="org.apache.cxf.rs.in.interceptors" value="org.apache.cxf.interceptor.LoggingInInterceptor" />
			<entry key="org.apache.cxf.rs.out.interceptors" value="org.apache.cxf.interceptor.LoggingOutInterceptor" />
			<!-- JAXB Context -->
			<entry key="org.apache.cxf.rs.provider">
				<array>
					<ref bean="jsonProvider" />
				</array>
			</entry>
			<!-- HttpService -->
			<entry key="org.apache.cxf.rs.httpservice.context" value="/UserService" />
		</osgi:service-properties>
		<ref bean="userService" />
	</osgi:service>

	<bean id="jsonProvider" class="org.apache.cxf.jaxrs.provider.JSONProvider">
		<property name="singleJaxbContext" value="true" />
		<property name="extraClass">
			<list>
				<value>fr.opensagres.domain.User</value>
			</list>
		</property>
	</bean>

</beans>

At this step we can create a WAR Product to export after the WAR, but we will do that after.

Manage "Embedding an HTTP server in OSGi container" and "Equinox in a Servlet Container (ServletBridge)" both

At this step, our JAX-RS UserService works with HttpService. If you start the launch Server Remoting – JAXRS DOSGi – JPA Dao [RAP TP] you will see this error :

INFO: ListenerHookImpl: skipping import request for excluded classs [org.osgi.service.http.HttpService]
6094 [pool-1-thread-1] INFO  org.apache.cxf.dosgi.dsw.service.RemoteServiceAdminCore  - found handler for fr.opensagres.services.UserService  -> org.apache.cxf.dosgi.dsw.handlers.JaxRSHttpServiceConfigurationTypeHandler@d3199e
Exception in thread "pool-1-thread-1" org.osgi.framework.ServiceException: CXF DOSGi: No HTTP Service could be found to publish CXF endpoint in.
	at org.apache.cxf.dosgi.dsw.handlers.HttpServiceConfigurationTypeHandler.getHttpService(HttpServiceConfigurationTypeHandler.java:235)
...

This error comes from that there is none HttpService registered because we are in Embedding an HTTP server in OSGi container mode. It’s possible to manage the both mode by setting the property org.apache.cxf.rs.httpservice.context with dynamic mean:

<!-- HttpService -->
<entry key="${httpservice-config.key}" value="/UserService" />

The (optional) ${httpservice-config.key} value :

• for Embedding an HTTP server in OSGi container mode: is not defined. It means that you will do that :

  <!-- HttpService -->
  <entry key="${httpservice-config.key}" value="/UserService" />
  

  and HttpService for CXF DOSGi will be disabled.

• for Equinox in a Servlet Container (ServletBridge) mode : it comes from a property file httpservice-config.properties which is hosted by the fr.opensagres.remoting.exporter.dosgi.jaxrs-httpservice fragment linked to the fr.opensagres.remoting.exporter.dosgi.jaxrs bundle with this content :

  httpservice-config.key=org.apache.cxf.rs.httpservice.context
  

  It means that you will do that :

  <!-- HttpService -->
  <entry key="org.apache.cxf.rs.httpservice.context" value="/UserService" />
  

  and HttpService will be used to register our UserService with CXF DOSGi with /UserService path.

Use ${httpservice-config.key}

To use optional ${httpservice-config.key} we need to define a property-placeholder like this:

<context:property-placeholder location="classpath:httpservice-config.properties"
		ignore-resource-not-found="true" ignore-unresolvable="true" />

The attribute :

• ignore-resource-not-found="true" means that if httpservice-config.properties field is not found, Spring doesn’t throw an error (in the case of Embedding an HTTP server in OSGi container mode.
• ignore-unresolvable="true" means that the use of ${httpservice-config.key} will not throw an error if it doesn’t found (in the case of Embedding an HTTP server in OSGi container mode.

Modify the META-INF/spring/module-osgi-context.xml of the fr.opensagres.remoting.exporter.dosgi.jaxrs bundle like this:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:osgi="http://www.springframework.org/schema/osgi"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/osgi  

http://www.springframework.org/schema/osgi/spring-osgi-1.0.xsd


http://www.springframework.org/schema/beans


http://www.springframework.org/schema/beans/spring-beans.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context.xsd">

	<context:property-placeholder location="classpath:httpservice-config.properties"
		ignore-resource-not-found="true" ignore-unresolvable="true" />
		
	<osgi:reference id="userService" interface="fr.opensagres.services.UserService" />

	<osgi:service interface="fr.opensagres.services.UserService">
		<osgi:service-properties>
			<entry key="service.exported.interfaces" value="*" />
			<entry key="service.exported.configs" value="org.apache.cxf.rs" />
			<entry key="service.exported.intents" value="HTTP" />
			<entry key="org.apache.cxf.rs.databinding" value="jaxb" />
			<!-- Logs -->
			<entry key="org.apache.cxf.rs.in.interceptors" value="org.apache.cxf.interceptor.LoggingInInterceptor" />
			<entry key="org.apache.cxf.rs.out.interceptors" value="org.apache.cxf.interceptor.LoggingOutInterceptor" />
			<!-- JAXB Context -->
			<entry key="org.apache.cxf.rs.provider">
				<array>
					<ref bean="jsonProvider" />
				</array>
			</entry>
			<!-- HttpService -->
			<entry key="${httpservice-config.key}" value="/UserService" />
		</osgi:service-properties>
		<ref bean="userService" />
	</osgi:service>

	<bean id="jsonProvider" class="org.apache.cxf.jaxrs.provider.JSONProvider">
		<property name="singleJaxbContext" value="true" />
		<property name="extraClass">
			<list>
				<value>fr.opensagres.domain.User</value>
			</list>
		</property>
	</bean>

</beans>

If you start the launch Server Remoting – JAXRS DOSGi – JPA Dao [RAP TP] you will see that it’s work.

fr.opensagres.remoting.exporter.dosgi.jaxrs-httpservice

Create the OSGI fragment fr.opensagres.remoting.exporter.dosgi.jaxrs-httpservice linked to the fr.opensagres.remoting.exporter.dosgi.jaxrs OSGi bundle.

In this fragment, create the src/httpservice-config.properties with this content:

httpservice-config.key=org.apache.cxf.rs.httpservice.context

Create WAR Product

In this section we will create WAR Product from the OSGi Server Remoting – JAXRS DOSGi – JPA Dao [RAP TP] launch like explained in the Create WAR Product article. Once the WAR Product will be created, we will add the fragment fr.opensagres.remoting.exporter.dosgi.jaxrs-httpservice to the WAR Product Configuration.

Create the TargetPlatform/warproducts/cxf-dosgi-jpa folder which will hosts the cxf-dosgi-jpa.warproduct :



Go to the File/New/Other… menu item, select Plug-in Development/WAR Product Configuration and click on Next button:



The New WAR Product Configuration wizard is displayed:



1. Select the TargetPlatform/warproducts/cxf-dosgi-jpa folder.
2. fill File name field with cxf-dosgi-jpa.warproduct.
3. select the Server Remoting – JAXRS DOSGi – JPA Dao [RAP TP] launch because we will create a WAR Product from this launch.

Click on Finish button to generate the WAR Product:



With the WAR Product Editor, Add the fr.opensagres.remoting.exporter.dosgi.jaxrs-httpservice fragment (to register the UserService with HttpService) with the Add button :



Create WAR

At this step we can generate the WAR by following the Create a WAR from RAP Application with Libra WAR Product [step3] article.

Validate WAR product

Before creating WAR, click on Validate WAR product menu item to check you have not problem with Plug-Ins/Fragments of the WAR Product:



Export WAR product

If you have none errors, we can start exporting the WAR. To do that, click on Export WAR product menu item:



This action opens the Export dialog :



• choose the file name of the generated WAR (here we will export WAR to generate the C:\cxf-dosgi-jpa.war).
• select the "Allow for binary cycles in target platform" checkbox.

Click on Finish button which starts the export of the WAR.

Test WAR cxf-dosgi-jpa.war

At this step we can test our WAR. In my case, I have tested the WAR with Apache Tomcat and follow thoses steps:

• Install Apache Tomcat.
• Copy/paste the cxf-dosgi-jpa.war in the webapps folder of the root of the Tomcat.
• Start the Tomcat on the 8080 port by using the bin/startup.bat (or startup.sh).

Web Browser

Once the HTTP Server has deployed the war, tries to go to the URL http://127.0.0.1:8080/cxf-dosgi-jpa/UserService/user/findAll and you will see the JSON of the user list :

{"user":[{"firstName":"Angelo","lastName":"Zerr"},{"firstName":"Pascal","lastName":"Leclercq"},{"firstName":"Amine","lastName":"Bousta"},{"firstName":"Mickael","lastName":"Baron"},{"firstName":"Jawher","lastName":"Moussa"},{"firstName":"Arnaud","lastName":"Cogoluegnes"},{"firstName":"Lars","lastName":"Vogel"},{"firstName":"Olivier","lastName":"Gierke"},{"firstName":"Tom","lastName":"Schindl"},{"firstName":"Wim","lastName":"Jongman"}]}

Our CXF DOSGi application works now with a WAR!

JAX-RS Clients

Now we will test our WAR with our OSGI, RCP and RAP launches. To do that we need just modify the module-osgi-context.xml of the fr.opensagres.remoting.importer.dosgi.jaxrs bundle :

<jaxrs:client id="jaxrsUserService"
	address="${jaxrs-config.base-url}/fr/opensagres/services/UserService"

with this new content :

<jaxrs:client id="jaxrsUserService"
	address="${jaxrs-config.base-url}/UserService"

Equinox in a Servlet Container (ServletBridge) – Localhost

To test with your Local Apache Tomcat, modify the base-url like this :

jaxrs-config.base-url=http://127.0.0.1:8080/cxf-dosgi-jpa/

Start the Client Remoting – JAXRS DOSGi – Simple OSGi Client or (Client Remoting – JAXRS DOSGi – Simple OSGi Client [RAP TP] if you have RAP Target Platform activated) launch, to check it works. You can test too RCP (Client Remoting – JAXRS DOSGI – RCP Client) and RAP (Client Remoting – JAXRS DOSGI – RAP Client) launches.

Cloudbees

The cxf-dosgi-jpa.war was deployed on CloudBees. You can test URLs with Web Browser like:

• http://cxf-dosgi-war.opensagres.cloudbees.net/UserService?_wadl to displays the WADL of the UserService.
• http://cxf-dosgi-war.opensagres.cloudbees.net/UserService/user/findAll to display the user list as JSON format.

To test with WAR deployed on CloudBees, modify the base-url like this :

jaxrs-config.base-url=http://cxf-dosgi-war.opensagres.cloudbees.net

Start the Client Remoting – JAXRS DOSGi – Simple OSGi Client or (Client Remoting – JAXRS DOSGi – Simple OSGi Client [RAP TP] if you have RAP Target Platform activated) launch, to check it works. You can test too RCP (Client Remoting – JAXRS DOSGI – RCP Client) and RAP (Client Remoting – JAXRS DOSGI – RAP Client) launches.

Embedding an HTTP server in Equinox – Localhost with Jetty

To test with OSGI Jetty (launch Server Remoting – JAXRS DOSGi – JPA Dao [RAP TP]), modify the base-url like this :

jaxrs-config.base-url=http://127.0.0.1:9000/fr/opensagres/services

Start the Client Remoting – JAXRS DOSGi – Simple OSGi Client or (Client Remoting – JAXRS DOSGi – Simple OSGi Client [RAP TP] if you have RAP Target Platform activated) launch, to check it works. You can test too RCP (Client Remoting – JAXRS DOSGI – RCP Client) and RAP (Client Remoting – JAXRS DOSGI – RAP Client) launches.

Conclusion

In this article we have seen how to create a WAR for a CXF DOSGi Application by using WAR Product which is created from OSGi launches and give you the capability to export a WAR with ServletBridge.


]]> http://angelozerr.wordpress.com/2012/06/18/eclipse_spring_dosgi_step4/feed/ 5 akrogen http://angelozerr.wordpress.com/2012/06/13/warproduct_step3/ http://angelozerr.wordpress.com/2012/06/13/warproduct_step3/#comments Wed, 13 Jun 2012 07:27:45 +0000 angelozerr http://angelozerr.wordpress.com/?p=6875 ]]> In [step2] we have created WAR Product files from RAP launches. In this article we will generate WAR by using the export WAR feature of the WAR Product to generates two WARs:
• rap-jpa.war that you can download here.
• rap-mock.war that you can download here.

We will deploy generated WARs in a non OSGi HTTP Server Apache Tomcat. You can see the online demo of the rap-jpa.war created with WAR Product deployed on CloudBees which provides an Apache Tomcat at http://rap-war.opensagres.cloudbees.net/eclipsespring.

We will see in this article that projects of eclipsespring_step10.zip contains 2 problems when WAR will be exported and deployed:

• .qualifier must not used in the Host of fragments.
• pay attention with build.properties of Plug-in /Fragments which must include the whole files (META-INF, fragment.xml, plugin.xml, etc).

Those 2 errors are interesting because it works with RAP launch but not with WAR Product.

Download

WAR Products

You can download eclipse_spring_warproduct.zip which contains the two WAR Products created in this article.

WARs

• rap-mock.war
• rap-jpa.war

Create WAR rap-jpa.war of "RAP Client – JPA Dao"

In this section we use the features of WAR Product Editor to create the rap-jpa.war WAR. To do that Open the rap-jpa.warproduct with the WAR Product Editor.

Validate WAR product

Before creating WAR, click on Validate WAR product menu item to check you have not problem with Plug-Ins/Fragments of the WAR Product:



Export WAR product

If you have none errors, we can start exporting the WAR. To do that, click on Export WAR product menu item:



This action opens the Export dialog :



• choose the file name of the generated WAR (here we will export WAR to generate the C:\rap-jpa.war).
• select the "Allow for binary cycles in target platform" checkbox.

NOTE: here My WAR Product is used and display a checkbox "Allow for binary cycles in target platform" which is required to fix problem with cycle that we have with Spring.

Click on Finish button which starts the export of the WAR, but it fails with this error:



This error is interesting because this problem doesn’t occur when RAP launch is used. The problem comes from the OSGi Fragment fr.opensagres.dao.jpa.eclipselink
linked to OSGI bundle fr.opensagres.dao.jpa which defines version with .qualifier. The OSGi Fragment fr.opensagres.dao.jpa.eclipselink
uses the .qualifier at this step:



Remove the .qualifier used in the OSGi Fragment fr.opensagres.dao.jpa.eclipselink for Hosts:



Export the WAR, and you will see that rap-jpa.war will be generated with success.

Test WAR rap-jpa.war

At this step we can test our WAR. In my case, I have tested the WAR with Apache Tomcat and follow thoses steps:

• Install Tomcat.
• Copy/paste the rap-jpa.war in the webapps folder of the root of the Tomcat.
• Start the Tomcat on the 8080 port by using the bin/startup.bat (or startup.sh).

build.propertries problem

Once the HTTP Server has deployed the war, tries to go to the URL http://127.0.0.1:8080/rap-jpa/eclipsespring, but you will have this 404 error:



But if you go at http://127.0.0.1:8080/rap-jpa/rap?startup=fr.opensagres.richclient.application it works:



It means that the eclipsespring servlet that we have defined in the fragment.xml of the bundle fr.opensagres.richclient.config.rap is not used:

<extension
      point="org.eclipse.rap.ui.branding">
   <branding
         servletName="eclipsespring"
         themeId="org.eclipse.rap.design.example.business.theme"
         defaultEntrypointId="fr.opensagres.richclient.application"
         title="RAP Application"
         id="fr.opensagres.richclient.branding">
   </branding>
</extension>

If you unzip the JAR of the rap-jpa/WEB-INF/plugins/fr.opensagres.richclient.config.rap you will see that fragment.xml doesn’t exists. The reason of that
is that build.properties of the fr.opensagres.richclient.config.rap bundle, doesn’t include the fragment.xml.

To resolve this problem, open the MANIFEST-MF of this bundle, go to the Build tab and select fragment.xml :



Rebuild the WAR and deploy it.

URL and branding

As we use the org.eclipse.rap.design.example Plug-In in the WAR Product, we can benefit from branding features of RAP which provides several themes.

Custom branding

Now if you go to the URL http://127.0.0.1:8080/rap-jpa/eclipsespring, you will see:



You can test that with online demo at http://rap-war.opensagres.cloudbees.net/eclipsespring.

RAP branding

if you go to the URL http://127.0.0.1:8080/rap-jpa/rap?startup=fr.opensagres.richclient.application, you will see:



You can test that with online demo at http://rap-war.opensagres.cloudbees.net/rap?startup=fr.opensagres.richclient.application.

Fancy branding

if you go to the URL http://127.0.0.1:8080/rap-jpa/fancy?startup=fr.opensagres.richclient.application, you will see:



You can test that with online demo at http://rap-war.opensagres.cloudbees.net/fancy?startup=fr.opensagres.richclient.application.

Business branding

if you go to the URL http://127.0.0.1:8080/rap-jpa/business?startup=fr.opensagres.richclient.application, you will see:



You can test that with online demo at http://rap-war.opensagres.cloudbees.net/business?startup=fr.opensagres.richclient.application.

Create WAR rap-mock.war of "RAP Client – Mock Dao"

You can generate the rap-mock.war with the rap-mock.warproduct by exporting the WAR like explained below.

OSGi console

With WAR Product, HTTP Server starts the OSGi container. Is it possible to access to the OSGi console? The answer is yes. You must just configure web.xml to tell to the ServletBridge servlet which starts the OSGi container that OSGi console must be available by adding -console in the commandline.

<init-param>
      <param-name>commandline</param-name>
      <param-value>-registryMultiLanguage -console -ws rap</param-value>     
    </init-param>

When you will start the bin/startup.bat, you will see some Tomcat logs and OSGi console will be launched too.

Conclusion

In this article we have exported the WAR from WAR Product to generate WAR. We have seen how it’s very easy to generate WAR from RAP launches.


]]> http://angelozerr.wordpress.com/2012/06/13/warproduct_step3/feed/ 2 akrogen