Actualmente, las bases de datos NoSQL están ganando mucha importancia. Desde el Centro Experto de Oracle ADF nos hemos planteado realizar un estudio que nos permita conocer las posibilidades de integración de Oracle ADF con MongoDB.

La forma más habitual de construir aplicaciones ADF es utilizando Business Components en la capa de servicios de negocio. Para su generación es necesario conectarse a una base de datos relacional con un esquema de datos fijo. Sin embargo, en MongoDB los esquemas de datos son dinámicos.

No obstante, Oracle ADF también nos permite apoyar la capa de modelo sobre clases Java. Así pues, siguiendo el estilo más tradicional de Java EE, podríamos utilizar Java Beans para representar a las entidades de nuestro modelo y a continuación construir un DAO (Data Access Object) en el que definir los métodos para manipularlas.

El correspondiente Data Control se apoyará sobre los métodos definidos en el DAO para exponer sus colecciones de datos y operaciones a la capa de la vista. En la siguiente imagen resaltamos los puntos de la arquitectura en los que vamos a centrar nuestra estrategia.

En el siguiente fragmento hemos definido una interfaz con los métodos que debe implementar el DAO:

public interface PersonasDAO {  
    public Persona buscarPersona(String id);
    public void insertarPersona(Persona p);
    public void modificarPersona(Persona p);
    public void eliminarPersona(String id);
    public List<Persona> obtenerPersonas();
}

A continuación, los métodos de la clase que implementa dicha interfaz se apoyarán sobre una plantilla de Spring Data MongoDB para manipular las entidades:

public class PersonasDAOImpl implements PersonasDAO {

    private org.springframework.data.mongodb.core.MongoTemplate mongoTemplate;

    public PersonasDAOImpl() {
    }

    @Override
    public void insertarPersona(Persona p) {
        mongoTemplate.insert(p);
    }

    @Override
    public void eliminarPersona(String id) {
        Persona p = mongoTemplate.findById(id, Persona.class);
        mongoTemplate.remove(p);
    }

    @Override
    public List<Persona> obtenerPersonas() {
        return mongoTemplate.findAll(Persona.class);
    }

    // ...
    // Implementación del resto de métodos ...
    // ...

    //Getters y Setters

    public void setMongoTemplate(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    public MongoTemplate getMongoTemplate() {
        return mongoTemplate;
    }
}

Sobre el fichero de contexto de spring (spring.xml) definiremos los parámetros de conexión a la base de datos, así como las propiedades de la plantilla y su inyección en el DAO:

<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mongo="http://www.springframework.org/schema/data/mongo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.8.xsd">

    <!-- Conexion a MongoDB -->

    <mongo:mongo id="conexion" host="localhost" port="27017" />

    <!-- Mongo Template -->

    <bean id="mongoTemplate"  
          class="org.springframework.data.mongodb.core.MongoTemplate">
       <constructor-arg ref="conexion"/>
       <constructor-arg name="databaseName" value="adfMongoDB" />
    </bean>

    <!-- Data Access Object (DAO) -->

    <bean id="personasDAO" 
          class="com.atsistemas.pocs.springdatamongodb.model.dao.PersonasDAOImpl">
       <property name="mongoTemplate" ref="mongoTemplate" />
    </bean>

</beans>  

Para hacerlo accesible a la vista, crearemos una clase Java que consumirá los métodos del DAO y la publicaremos como Data Control. Cada operación del Data Control obtendrá el DAO instanciado en el contexto de aplicación de Spring y delegará en él la invocación al método correspondiente:

public class PersonasDC {

    public void insertarPersona(Persona p) {
        this.getPersonasDAO().insertarPersona(p);
    }

    //...
    //Resto de métodos...
    //... 

    public List<Persona> getPersonas() {
        return this.getPersonasDAO().obtenerPersonas();
    }

    private PersonasDAOImpl getPersonasDAO() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        return (context.getBean("personasDAO", PersonasDAOImpl.class));
    }
}

La estructura final del proyecto sería la siguiente:

Y el resultado de esta prueba de conceptos:

Como hemos visto, gracias a la versatilidad de Oracle ADF hemos conseguido integrar este framework con librerías de otros frameworks (Spring Data MongoDB) así como con una base de datos NoSQL.

Si te ha gustado ¡Sigue a “En mi local funciona” en Twitter!