Spring Data MongoDB

The Spring Data MongoDB project provides integration with the MongoDB document database.


The maven dependencies:

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb</artifactId>
            <version>1.5.2.RELEASE</version>
        </dependency>

Activating Spring Data repository support using Java Config:

import java.util.Arrays;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.WriteConcern;


@Configuration
@ComponentScan
@EnableMongoRepositories
public class Application extends AbstractMongoConfiguration{

    @Override
    protected String getDatabaseName() {
        return "tuto";
    }

    @Override
    public Mongo mongo() throws Exception {
        ServerAddress serverAdress = new ServerAddress("localhost", 27017);        MongoCredential credential = MongoCredential.createMongoCRCredential("moez","tuto","secret".toCharArray());
        //Do not use new Mongo(), is deprecated.
        Mongo mongo = new MongoClient(serverAdress,Arrays.asList(credential));
        mongo.setWriteConcern(WriteConcern.SAFE);
        return mongo;
    }

  
    @Override
    @Bean(name="template")
    public MongoTemplate mongoTemplate() throws Exception {
        return new MongoTemplate(mongo(), getDatabaseName());
    }

}

Note: Do not use

new Mongo()

because is deprecated.

Here is a basic example of using the save operation and retrieving its contents.

import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Criteria.query;

…

Person p = new Person("Bob", 33);
mongoTemplate.insert(p);

Person qp = mongoTemplate.findOne(query(where("age").is(33)), Person.class);

RESTful Services using Apache CXF

In this article I will detail how to create a REST based web services using Apache CXF without using Spring.
Cf. CXF docs:
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 style.
CXF 3.0.0 completely implements JAX-RS 2.0 including new Client API and has been fully tested against the first JAX-RS 2.0 TCK

Tools:
- Java 7
- Maven 3
- Apache CXF 3.0.0
- JAX-RS 2.0

Add the following maven dependencies :

      <dependency>
        <groupId>org.apache.cxf</groupId><artifactId>cxf-rt-frontend-jaxrs</artifactId>
        <version>3.0.0-milestone1</version>
      </dependency>
      <dependency>
        <groupId>javax.ws.rs</groupId><artifactId>javax.ws.rs-api</artifactId>
        <version>2.0</version>
      </dependency>
      <dependency>
        <groupId>org.apache.cxf</groupId><artifactId>cxf-rt-rs-client</artifactId>
        <version>3.0.0-milestone1</version>

      </dependency>
      <dependency>
        <groupId>org.apache.cxf</groupId><artifactId>cxf-rt-transports-http-hc</artifactId>
        <version>3.0.0-milestone1</version>

      </dependency>

Let's start with creating a bean class as response of the webservice. Will be annotated @XmlRootElement, to be used as xml/json response:

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class PersonResponse {
    private String id;
    private String name;
    private String age;
    //...
    //getters, setters
    //...

}

Following code returns a Person object that is marshaled to XML or JSON format:

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

@Path("/api/service")
@Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
public class PersonService {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    @Path("/person//id/{id}/")
    public Response getPerson(@PathParam("id")String personId) throws Exception{
        PersonResponse response = new PersonResponse();
        // some code here
        return Response.ok().build();
    }

}

In the cas of error use the following:

return Response.status(Response.Status.FORBIDDEN);

This will return a HTTP 403 default message. If we would a customized one, try this:

        ErrorMessageResponse error = new ErrorMessageResponse();
        error.setErrorMessage("your message here");
        return Response.status(Response.Status.FORBIDDEN).type(MediaType.APPLICATION_JSON).entity(error).build();

ErrorMessage Response is a simple bean annotated with @XmlRootElement

Now use tomcat for deploying the webservice, so our servlet declaration in the web.xml will be :

<servlet>
    <servlet-name>CXFServlet</servlet-name>
    <servlet-class>

org.apache.cxf.jaxrs.servlet.CXFNonSpringJaxrsServlet

</servlet-class>
    <init-param>
      <param-name>jaxrs.serviceClasses</param-name>

<param-value>com.mypackage.PersonService</param-value>

</init-param>
    <init-param>
      <param-name>jaxrs.address</param-name>

<param-value>/rest</param-value> 

</init-param> 
</servlet>
<servlet-mapping>
   <servlet-name>CXFServlet</servlet-name>
   <url-pattern>/*</url-pattern>
</servlet-mapping>

You can test your web service, with unit test or soapui.