Spring data + mongoDB

Bueno vamos a hacer otro ejemplo con Spring data y mongoDB. La idea seria que tengo un usuario y debo guardarlo en una base NoSQL como MongoDB.

Antes de empezar es necesario instalar mongoDB y levantar la base como lo indica el siguiente tutorial:

http://emanuelpeg.blogspot.com/2012/02/instalar-mongodb-en-linux.html

Vamos hacer el proyecto con maven:

mvn archetype:generate

Creamos el proyecto comunacho de maven, con los nombres de paquetes que deseen. Vamos a agregar al pom las dependencias necesarias:

		
			org.springframework.data
			spring-data-mongodb
			1.0.1.RELEASE
		
		
		
			org.springframework
			spring-core
			${spring.version}
		

		
			org.springframework
			spring-context
			${spring.version}
		

		
			org.springframework
			spring-aop
			${spring.version}
		

		
			org.springframework
			spring-aspects
			${spring.version}
		

		
			org.springframework
			spring-tx
			${spring.version}
		

		
			junit
			junit
			4.10
			test
		

		
			org.springframework
			spring-test
			${spring.version}
			test
		

donde:

	3.1.0.RELEASE

Además agregamos el repositorio:

	
		
			spring-release
			Spring Maven Release Repository
			http://repo.springsource.org/libs-release
		
	

Hacemos maven para agregar las dependencias:

mvn clean install
mvn eclipse:eclipse

Ahora importamos el proyecto a eclipse o su IDE favorita, la mía es eclipse.

Creamos la clase User, vamos a hacer antes una clase padre que contenga las particularidades generales de las clases del modelo que van a hacer persistidas:

public abstract class PersistentEntity {
	@Id
	private Long id;

	public Long getId() {
		return id;
	}

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


}

Ahora hacemos la clase User:

@Document
public class User extends PersistentEntity {

	private String userName;
	
	private String password;
	
	private List emails = new ArrayList();
	
	public User() {
	}
	
	public User(String userName, String password) {
		super();
		this.userName = userName;
		this.password = password;
	}

	public User(String userName, String password, List emails) {
		this(userName, password);
		this.emails = emails;
	}

	//getters and setters

} 

Vamos a escribir un DAO para ello vamos hacer lo siguiente vamos a generar una clase genérica que contenga métodos genéricos de acceso a datos y vamos a heredar de esta clase; a la vez cada clase va a tener su interfaz que la describa.

La interfaz del genericDAO:

package org.assembly.edda.repository;

import java.io.Serializable;
import java.util.List;

import org.assembly.edda.model.PersistentEntity;

public interface GenericDAO {
	
	T get(ID id);
	
	T save(T object);
	
	void delete(T object);
	
	List findAll();
} 

Su implementación:

package org.assembly.edda.dao;

import java.io.Serializable;
import java.util.List;

import org.assembly.edda.model.PersistentEntity;
import org.assembly.edda.model.User.User;
import org.assembly.edda.repository.GenericDAO;
import org.springframework.data.mongodb.core.MongoTemplate;

/**
 * @author emanuel
 *
 */
public abstract class GenericDAOImpl implements GenericDAO {

	private MongoTemplate mongoTemplate;
	
	public void setMongoTemplate(MongoTemplate mongoTemplate) {
		this.mongoTemplate = mongoTemplate;
	}
	
	protected abstract Class getEntityClass();
	
	public T get(ID id) {
		return (T) mongoTemplate.findById(id, getEntityClass());
	}

	public T save(T objectToSave) {
		mongoTemplate.save(objectToSave);
		return objectToSave;
	}

	public void delete(T objectToDelete) {
		mongoTemplate.remove(objectToDelete);
	}
	
	public List findAll() {
		return mongoTemplate.findAll(getEntityClass());
	}

}

Ahora la interfaz de UserDAO:

package org.assembly.edda.repository.user;

import org.assembly.edda.model.User.User;
import org.assembly.edda.repository.GenericDAO;

public interface UserDAO extends GenericDAO{

}

y su implementación:

package org.assembly.edda.dao.user;

import org.assembly.edda.dao.GenericDAOImpl;
import org.assembly.edda.model.User.User;
import org.assembly.edda.repository.user.UserDAO;

/**
 * @author emanuel
 *
 */
public class UserDAOImpl extends GenericDAOImpl implements UserDAO{

	
	@Override
	protected Class getEntityClass() {
		return User.class;
	}

}

Ahora vamos a escribir el ApplicationContext.xml de spring:

Bueno con esto estamos, solo debemos testar para ver si funciona. Creamos un test; ojo tener levantada la base cuando se lo corre. Para testear esto lo voy hacer más difícil voy a generar una clase padre generica y luego el test concreto (solo para ver como queda)

package org.assembly.edda.dao;

import static org.junit.Assert.*;
import java.util.List;

import org.assembly.edda.model.PersistentEntity;
import org.assembly.edda.repository.GenericDAO;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;


/**
 * @author emanuel
 *
 */
@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
@Transactional
public abstract class GenericDAOTest> {
	
	protected abstract DAO getDAO();
	protected abstract T createObject();
	protected abstract T createOtherObject();
	protected abstract void assertEqualsObject(T object, T objectSaved);
	
	@Test
	public void find() {
		T object = createObject();
		getDAO().save(object);
		
		T objectSaved = getDAO().get(object.getId());
		assertEqualsObject(object, objectSaved);
	}

	
	@Test
	public void findAll() {
		T object = createObject();
		getDAO().save(object);
		
		T otherObject = createOtherObject();
		getDAO().save(otherObject);
		
		List all = getDAO().findAll();
		
		assertEquals(2, all.size());
	}

}

Y la implementación del test:

package org.assembly.edda.dao.user;

import static org.junit.Assert.*;

import javax.annotation.Resource;

import org.assembly.edda.dao.GenericDAOTest;
import org.assembly.edda.model.User.User;



public class UserDAOTest extends GenericDAOTest {

	@Resource
	private UserDAOImpl dao;
	
	public void setDao(UserDAOImpl dao) {
		this.dao = dao;
	}
	
	@Override
	protected UserDAOImpl getDAO() {
		return dao;
	}

	@Override
	protected User createObject() {
		User user = new User("Pepe", "0303456yalalala");
		user.setId(4l);
		return user;
	}

	@Override
	protected User createOtherObject() {
		User user = new User("Pepe", "0303456yalalala");
		user.setId(5l);
		return user;
	}
	
	@Override
	protected void assertEqualsObject(User object, User objectSaved) {
		assertEquals(object.getId(), objectSaved.getId());
		assertEquals(object.getUserName(), objectSaved.getUserName());
		assertEquals(object.getEmails(), objectSaved.getEmails());
		assertEquals(object.getPassword(), objectSaved.getPassword());
	}


}

Eso es todo amigos!!