GeoBack. Un sencillo ejemplo. 1ª Parte

En este post vamos a mostraros un ejemplo de uso de GeoBack. Simplemente, haremos un CRUD Controller con Spring Boot, el cual nos permitirá manipular capas como objetos de tipo Layer que contienen un documento GeoJson y una serie de metadatos.

Esta será nuestra clase Layer, que es un sencillo POJO (Plain Old Java Object) con alguna peculiaridad:

@Document(collection = "layers")
public class Layer extends AbstractDomainObject{

    private String token;
    private String name;
    private String series;
    private String description;
    private FeatureCollection geoData;

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSeries() {
        return series;
    }

    public void setSeries(String series) {
        this.series = series;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public FeatureCollection getGeoData() {
        return geoData;
    }

    public void setGeoData(FeatureCollection geoData) {
        this.geoData = geoData;
    }
}

Como vemos, al añadir la etiqueta @Document, diremos a Spring que se trata de una clase que representa el tipo de documento que almacenaremos en la base de datos. Cabe destacar, que en el atributo geoData se almacenan el GeoJson con los datos georeferenciados en un FeatureCollection.

Como queremos hacer las cosas un poco ordenadas,  usamos un patrón Service Layer. Con Spring Data necesitamos tres capas diferenciadas en el código:

  • La capa de modelo, que en este caso se completaría con un Spring Data Repository.
  • La capa de servicio, que utilizamos para dotar de mayor abstracción al sistema.
  • La capa de controller, que es donde aparece REST y nos dará la puerta de acceso de nuestra Api.

 

Capa de modelo.

Sólo necesitamos definir un interface que herede de MongoRepository.

public interface LayerCRUDRepository extends MongoRepository<Layer,String> 
{
// Aqui definiriamos los demas metodos.
}

Tenemos que indicar a los genéricos de MongoRepository, que nuestro documento a almacenar es de tipo Layer y que su Id es de tipo String. No hay que añadir ningún método a la clase, ya que estamos desarrollando un CRUD y nos sobra con los métodos definidos en la clase padre (MongoRepository).

Capa Servicio.

En el servicio definimos qué es lo que podemos hacer con nuestros Layer. De momento, sólo tenemos los 4 métodos del CRUD (crear, leer, actualizar y eliminar un Layer), pero podemos añadir otras, como por ejemplo buscar todos los Layer con un token determinado, o un listado de Layer de una serie determinada.

Consta de un interface:

public interface LayerCRUDService {

    // C
    Layer create(Layer layer);
    // R
    Layer read(String id);
    // U
    Layer update(Layer layer);
    // D
    void delete(String id);
}

y su implementación:

@Service
public class LayerCRUDServiceImpl implements LayerCRUDService{

    private LayerCRUDRepository layerCRUDRepository;

    @Autowired
    public void setLayerCRUDRepository(LayerCRUDRepository layerCRUDRepository) {
        this.layerCRUDRepository = layerCRUDRepository;
    }

    @Override
    public Layer create(Layer layer) {
        return layerCRUDRepository.save(layer);
    }

    @Override
    public Layer read(String id) {
        return layerCRUDRepository.findOne(id);
    }

    @Override
    public Layer update(Layer layer) {
        return layerCRUDRepository.save(layer);
    }

    @Override
    public void delete(String id) {
        layerCRUDRepository.delete(id);
    }
}

En la implementación, únicamente tenemos que definir el repository que vamos a utilizar, y luego emplear los métodos que hereda de MongoRepository.

Capa Rest controller.

A continuación, se muestra el Controller con los cuatro métodos de acceso al Api con sus respectivos protocolos:

@RestController
@RequestMapping("/layer/crud")
public class LayerCRUDController {

    private LayerCRUDService layerCRUDService;

    @Autowired
    public void setLayerCRUDService(LayerCRUDService layerCRUDService) {
        this.layerCRUDService = layerCRUDService;
    }

    // C
    @RequestMapping(value = "/",method = RequestMethod.POST)
    public Layer create(@RequestBody Layer layer){
        return layerCRUDService.create(layer);
    }

    // R
    @RequestMapping(value = "/{id}",method = RequestMethod.GET)
    public Layer read(@PathVariable("id") String id){
        return layerCRUDService.read(id);
    }

    // U
    @RequestMapping(value = "/",method = RequestMethod.PUT)
    public Layer update(@RequestBody Layer layer){
        return layerCRUDService.update(layer);
    }

    // D
    @RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    public void delete(@PathVariable("id") String id){
        layerCRUDService.delete(id);
    }
}

Tenemos que inyectar nuestro LayerCRUDService para poder utilizar sus métodos. La etiqueta @RestController nos indica que los métodos de esta clase serán accesibles a través de un servicio Rest, en la ruta definida en @RequestMapping.

También vemos que cada método tiene definidos una ruta propia (que se añade a la anterior), y un RequestMethod que tendremos que utilizar en nuestras llamadas al Api.

En la segunda parte del post, os enseñaremos cómo utilizamos JWT para dotar de seguridad al Api, configurando una autorización en los request. También haremos pruebas con la herramienta Postman.

Todo el código esta en esta rama de Github.

Administrando datos georeferenciados con GeoBack

GeoBack es una herramienta de código abierto para almacenar datos georeferenciados conforme al estándar GeoJSON. Es un proyecto de código abierto y es totalmente libre de uso.

Está implementado en lenguaje Java sobre Spring Boot, con Spring Data y MongoDB. Los accesos al Api están securizados con JWT. Incluye un Spring Converter  y un módulo Jackson para usar los objetos de dominio propios de Spring Data Mongo.

GeoBack

A lo largo de este post, vamos a entrar un poco en detalle expliando cómo está desarrollado.

Utiliza estándar GeoJSON para guardar los datos

GeoJSON es un formato estándar abierto, diseñado para representar elementos geográficos sencillos junto con sus atributos no espaciales, basado en JSON. El formato es ampliamente utilizado en aplicaciones de cartografía en entornos web, al permitir el intercambio de datos de manera rápida, ligera y sencilla.

Gracias a ser un formato estándar, muchas de las tecnologías Web relacionadas con mapas lo utilizan (Google Maps Api, Leaflet y Openlayers, así como CartoDB o Mapbox).

Spring Boot

El proyecto está implementado con Spring Boot, lo que nos permite aprovechar todas sus ventajas, que son:

  • Es ideal para una arquitectura de micro-servicios ya que permite una gran abstracción.
  • Fácil de escalar. Permite ser integrado con Docker u otros sistemas de contenedores.
  • Ecosistema Spring.
  • No necesitamos ningún servidor de aplicaciones en nuestra máquina, ya que viene embebido y pre-configurado.
  • Automatización de la configuración, haciéndola muy sencilla.

Spring Data y MongoDB

Las bases de datos no relacionales se antojan ideales a la hora de almacenar datos georeferenciados. Por ello, GeoBack está preparado para funcionar sobre MongoDB.

Existen otras bases de datos, como MySQLPostgreSQL, con características especiales para trabajar con datos georeferenciados. Podríamos hacer unos sencillos cambios en el código para poder utilizar cualquiera de estas bases de datos, gracias a la potencia de Spring Data y a que utilizamos el estándar GeoJSON.

Desde hace un tiempo, MongoDB incluye los índices 2dsphere. Estos índices permiten hacer consultas que calculan geometrías en una esfera similar a la de la Tierra. El índice 2dsphere admite todas las consultas geoespaciales de MongoDB (inclusión, intersección y proximidad), lo que nos permite realzar complicados cálculos de forma sencilla y a gran velocidad.

Api REST y Seguridad

Al incluir las capacidades Web de Srping Boot, el proyecto viene preparado para funcionar como una Api REST, para ello debemos implementar los controladores que serán nuestro enlace con la base de datos. Las principales ventajas de utilizar este sistema son su gran versatilidad a la hora de encajar en cualquier sistema (no dependemos de ningún lenguaje o plataforma específica), su fiabilidad y su fácil escalabilidad. Por poner un ejemplo, podemos tener varios geovisores con fines distintos que trabajen con la misma base de datos.

Pero estos sistemas tan “abiertos” podrían ser accesibles por cualquiera, es por ello que es necesario protegerlos. El ecosistema Spring tiene a Spring Security, el cual nos evita implementar la mayoría de mecanismos para poder proteger estos sistemas. 

En este caso, hemos añadido Json Web Tokens (JWT)  implementada sobre Spring Security. Esto nos permite securizar todos los accesos a la Api mediante autorización. De esta forma, podemos identificar y contabilizar los accesos a nuestro Api mediante el uso de tokens pre-generados.

 Qué es eso de Spring Converter y Jackson

GeoBack tiene la peculiaridad de utilizar los objetos de dominio propios de Spring Data para poder integrarlo de forma sencilla. Para poder utilizar estos objetos necesitamos que nuestra Api sea capaz de aceptar un documento en formato JSON y serializarlo en un objeto java (en este caso de una clase que implemente el interface GeoJson). Para este fin, se ha implementado un módulo Jackson con un serializer y un deserializer como se puede ver en este código.

Con este módulo Jackson podemos codificar y descodificar correctamente entre formato GeoJson y POJOs independientemente de su complejidad.

Un Spring Converter se encarga sencillamente de “transferir” los atributos de un objeto de una clase java a otra. Esto nos permitirá crear un Controller que acepte cualquier tipo de geometría, ya que el propio backend será el encargado de decodificarla y almacenarla correctamente por muy compleja que sea. Ademas lo hará de manera estándar, para que pueda ser entendido por un sistema completamente independiente de GeoBack.

Aquí podéis ver en detalle el código fuente de este converter.

Open source

Este proyecto está totalmente libre de uso. Lo podéis modificar y utilizarlo a vuestro antojo. Pronto publicaremos En este enlace tenéis un ejemplo de uso implementando un controlador, con su correspondiente servicio, que nos permita administrar layers en una base de datos.

– En este enlace se encuentra el repositorio GitHub.