A real systemwithjms-rest-protobuf-mongodb

Integrando Sistemas reales con
REST, JMS, Protobuf y MongoDB
Andrés Perez
Indra
David Gómez
Extrema Sistemas

lunes 26 de marzo de 12

David G ómez
iner
ect & Tra
Sw Archit om
ema-sistemas.c
dgomez@extr
zg
@dgome

Andrés Pérez y David Gómez 2
Indra y Extrema Sistemas


és Pérez
Andr itect David G ómez
iner
Sw Arch ect & Tra
Sw Archit om
z@indra.
es ema-sistemas.c
apere dgomez@extr
zg
@dgome



Hablaremos de

• El caso real.
• La arquitectura propuesta
– Interfaz REST entre GUI y Server
– Protobuf entre Dispositivos y Server/GUI
– JMS para comunicación asíncrona Server -> GUI
– MongoDB para persistencia



El caso real.
Control de tráfico marítimo



El caso real.

Emisor AIX
3-5 min



El caso real.
Receptor GPS
Radar (3 s)
Goniometro

Emisor AIX
Estación Meteo, 3-5 min
Cámaras,
...


El Problema:
La escalabilidad



El Problema:
La escalabilidad
Por cada barco:
Recepción y procesamiento de señales (nº)
Transacciones,
Cálculo de alarmas
Gestión de Históricos



El Problema:
La escalabilidad
Señales (1 AIS x 3 min + 1 radar x 3 seg) x 100 barcos
Alarmas
Persistencia de Líneas de Varada: (10.000+ ptos x 100+ líneas)
40 Alarmas
Zonas, Elementos Navegación
Persistencia: Total: 87 tablas + históricos(x2)



El problema:
la escablabilidad



La arquitectura

Speaker’s Name 11
Speaker mail – company or community


REST Cameras
GUI 1

JMS Server Protobuf
JMS
Radar

REST Spring Data
GUI 2

DB Gonio

Speaker’s Name 12


REST
Comunicación síncrona entre GUI y Servidor

Speaker’s Name 13


¿Qué es REST?

• REpresentational State Transfer
• HTTP como protocolo de comunicación
– No sólo como transporte
• La sesión es responsabilidad del cliente
– Escalable



¿Qué es REST?

• URIs representan recursos (no acciones)
• Acciones indicadas en el método HTTP
• Formato especificado en cabeceras HTTP
– Accept:
– ContentType:
• No todas las respuestas contienen datos
• Error o Resultado con HTTPStatus



Comparación



Comparación

GET http://server:port/zones/
POST http://server:port/zones/388
GET http://server:port/zones/388
PUT http://server:port/zones/388



Comparación

GET http://server:port/zones/
POST http://server:port/zones/388
GET http://server:port/zones/388
PUT http://server:port/zones/388

http://server:port/listZones
http://server:port/createNewZone
http://server:port/getZone?id=388
http://server:port/updateZone?id=388



(Spring) REST en el servidor



(Spring) REST en el servidor
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>3.0.6.RELEASE</version>
</dependency>

<dependency>
<artifactId>spring-webmvc</artifactId>
</dependency>

<dependency>
<artifactId>spring-oxm</artifactId>
</dependency>



¿Por qué REST con Spring?

• Simplifica
– la gestión de serialización
– La gestión de códigos de error
– Mapping de URLs a métodos
• En cliente tenemos el RestTemplate



Un Controlador de Zona (I)



Un Controlador de Zona (I)
@Controller
public
class
ZoneController
{

@Inject

private
ZoneService
service;

//
getZoneList
-‐>
GET

@RequestMapping(value="/zones",
method=RequestMethod.GET)

public
@ResponseBody
List<Zone>
getZones(){

return
service.findAll();

}

//
newZone
-‐>
POST

@RequestMapping(value
=
"/zones",
method
=
RequestMethod.POST)

@ResponseStatus(HttpStatus.CREATED)

public
void
newZone(@RequestBody
Zone
z,

HttpServletRequest
request,
HttpServletResponse
response)
{

service.save(z);

response.addHeader("Location",

getLocationForChildResource(request,
order.getId()));

}
}


Un Controlador de Zona (II)



Un Controlador de Zona (II)
@Controller
public
class
ZoneController
{

//
newZone
-‐>
POST

@RequestMapping(value
=
"/zones",
method
=
RequestMethod.POST)

@ResponseStatus(HttpStatus.CREATED)

public
void
newZone(@RequestBody
Zone
zone,

HttpServletRequest
request,
HttpServletResponse
response)
{

service.save(zone);

response.addHeader("Location",

getLocationForChildResource(request,
zone.getId()));

}

private
String
getLocationForNewResource(HttpServletRequest
request,

Object
identifier)
{

StringBuffer
url
=
request.getRequestURL();

UriTemplate
template
=
new
UriTemplate(url.append("/{zoneId}").toString());

return
template.expand(identifier).toASCIIString();

}
}



Un Controlador de Zona (III)



Un Controlador de Zona (III)
@Controller
public
class
ZoneController
{

//
getZone
-‐>
GET

@RequestMapping(value="/zones/{id}",
method=RequestMethod.GET)

public
@ResponseBody
Zone
getZone(@PathVariable("id")
String
id)
{

return
service.findById(id);

}

//
updateZone
-‐>
PUT

method=RequestMethod.PUT)

@ResponseStatus(HttpStatus.NO_CONTENT)

public
void
updateZone(@RequestBody
Zone
z)
{

service.save(z);

}

//
delete
-‐>
DELETE

method=RequestMethod.DELETE)

@ResponseStatus(HttpStatus.NO_CONTENT)

public
void
deleteZone(@PathVariable("id")
String
id){

service.removeById(id);

}

}



Configuración



Configuración

<?xml
version="1.0"
encoding="UTF-‐8"?>
<beans
xmlns="http://www.springframework.org/schema/beans">

<context:component-‐scan
base-‐package="com.vts.server"/>

<bean
id="xstreamMarshaller"

class="org.springframework.oxm.xstream.XStreamMarshaller"/>

<mvc:annotation-‐driven/>

</beans>



RestTemplate

• Invocar servicios REST desde los GUI



RestTemplate

• Invocar servicios REST desde los GUI
@Component
public
class
RestZoneServiceInvoker
implements
ZoneServiceInvoker
{

/*
"http://"
+
serverHostName
+
"/vts-‐server/vts/zones"
*/

private
String
baseURI;

private
RestTemplate
restTemplate;

@Inject

public
RestZoneServiceInvoker(RestTemplate
restTemplate)
{

this.restTemplate
=
restTemplate;

}

@Override

public
void
createNew(Zone
z)
{

URI
uri
=
restTemplate.postForLocation(baseURI,
z);

}
}



RestTemplate
• RestTemplate implements RestOperations



RestTemplate
• RestTemplate implements RestOperations
public
interface
RestOperations
{

<T>
T
getForObject(String
url,
Class<T>
responseType,

Object...
uriVariables)
throws
RestClientException;

HttpHeaders
headForHeaders(String
url,
Object...
uriVariables)

throws

URI
postForLocation(String
url,
Object
request,
Object...
uriVariables)

throws

<T>
T
postForObject(String
url,
Object
request,

Class<T>
responseType,
Map<String,
?>
uriVariables)

void
put(String
url,
Object
request,
Object...
uriVariables)

throws

void
delete(String
url,
Object...
uriVariables)

throws
...
}


Protobuf
Comunicación entre dispositivos y servidor/GUI
.Net/C++/Java

Speaker’s Name 25


Protobuf. 2011-05-01.
v 2.4.1
Necesidades en la integración de módulos

• Soluciones analizadas en la integración de
módulos

• Funcionamiento de la solución



¿qué necesitamos?

• Sencillez
• Alto rendimiento
• Adaptabilidad
• Compatibilidad con las distintas tecnologías de desarrollo
– Controladores de dispositivos en C++
– Servidor central y clientes en Java
– Otros componentes sw (Servidores de video) en .Net



¿REST?

REST, XML (Servidor java <-> Cliente java)
• Pros:
– Sencillez. Ampliamente extendido
– Compatible con las tecnologías propuestas
– Adaptabilidad
• Contras:
– rendimiento insuficiente para dispositivos



Protocolos ‘ad hoc’
• Pros:
– Adaptabilidad:
• Modificaciones en código para cada actualización.
• Existen protocolos básados en bytes de especificación,
categorias ASTERIX de EUROCONTROL
– Rendimiento
• Contras
– Dificultad, desarrollo de analizadores por tecnología.
– Tiempo



Protobuf
Mecanismos automáticos de serialización de
estructuras de datos.

• Alto rendimiento,
• sencillez,
• adaptabilidad (campos optional),
• compatible con las tecnologías planteadas



¿Cómo funciona?

• Definición de mensajes (estructuras de datos)
• Generación de las clases de acceso a las
estructuras de datos
• Incorporación de las clases generadas al
modelo



Definición de Mensajes

• Archivos .proto (pares clave/valor)
– clave: identificador del campo del mensaje
– valor: de tipo
• Números
• Booleanos
• bytes
• mensaje anidado
– Marcados como opcionales, obligatorios o repetidos



Definición de Mensajes

• Archivos .proto (pares clave/valor)
– clave: identificador del campo del mensaje
– valor: de tipo
• Números
• Booleanos
• bytes
• mensaje anidado
– Marcados como opcionales, obligatorios o repetidos
http://code.google.com/intl/es-ES/apis/protocolbuffers/docs/proto.html



Fichero .proto



Fichero .proto
package
Controllers;
option
java_package
=
"com.vts.controller";
message
ControllerMessage
{

enum
CommandType
{

INFO
=
0;

CMD_1
=
1;

CMD_2
=
2;

CMD_3
=
3;

CMD_4
=
4;

CMD_N
=
5;

}

enum
ControllerType
{

UNKNOWN
=
0;

CONTROLLER_1
=
1;

CONTROLLER_2
=
2;

CONTROLLER_3=
3;

CONTROLLER_N
=
4;

}

message
CommandValueDouble{

required
CommandType
commandType
=
1;

required
double
commandValue
=
2;

}

message
CommandValueBool{

required
CommandType
commandType
=
1;

required
bool
commandValue
=
2;

}

message
CommandValueString{

required
CommandType
commandType
=
1;

required
string
commandValue
=
2;

}

message
CommandValueInt32{

required
CommandType
commandType
=
1;

required
int32
commandValue
=
2;

}

required
string
idController
=
2;

required
ControllerType
controllerType
=
3;

repeated
CommandValueDouble
commandValueDouble
=
4;

repeated
CommandValueBool
commandValueBool
=
5;

repeated
CommandValueString
commandValueString
=
6;

repeated
CommandValueInt32
commandValueInt32
=
7;



Generación de las clases



Incorporación de clases
a modelos
• Posibilidades:
– almacenamiento: de/a ficheros, BD, ...
– comunicación: sockets.

• Nuevos campos no rompen la compatibilidad



Serialización a archivo en
C++



Serialización a archivo en
C++

ControllerMessage
controllerMessage;
controllerMessage.set_idController("123456");
controllerMessage.set_controllerType(controllers::ControllerMessage_ControllerType_CONTROLLER_1);

controllers::ControllerMessage_CommandValueString*
propiedad
=

controllerMessage.add_CommandValueString();

controllerMessage-‐>set_commandType(controllers::ControllerMessage_CommandType_CMD_2);
controllerMessage-‐>set_commandValue("VALOR_COMANDO");

fstream
output("fichero.out",
ios::out
|
ios::binary);
controllerMessage.SerializeToOstream(&output);



Envío por Socket
C++



Envío por Socket
C++
ControllerMessage
controllerMessage;
controllerMessage.set_commandType(controllers::ControllerMessage_CommandType_CMD_2);
int
bufLength
=
controllerMessage.ByteSize();
char*
buffer
=
new
char[bufLength];

google::protobuf::io::ArrayOutputStream
arrayOutput(buffer,
bufLength);
google::protobuf::io::CodedOutputStream
codedOutput(&arrayOutput);

//Enviamos
primero
el
tamaño
del
mensaje
como
varInt32
codedOutput.WriteVarint32(controllerMessage.ByteSize());

//Y
luego
el
mensaje
en
sí
controllerMessage.SerializeToCodedStream(&codedOutput);

//codedOutput.ByteCount()
nos
dará
el
tamaño
del
búffer
más

//le
varint
que
indica
el
tamaño
del
mensaje
iBufSize
=
codedOutput.ByteCount();
socket-‐>Send(buffer,
iBufSize);



.Net



.Net

//Lectura
desde
stream
TcpClient
cliente
=
new
TcpClient("192.168.250.50",
12345);
ControllerMessage
newController;
NetworkStream
stream
=
client.GetStream();
newPerson
=

Serializer.DeserializeWithLengthPrefix<Person>(stream,
PrefixStyle.Fixed32);
<TRATAMIENTO
DE
LOS
CAMPOS>

//Escritura
hacia
stream
ControllerMessage
controller
=
newControllerMessage
Person
();
controller.IdController
=
“132465”;
<ASIGNACION
DE
TODOS
LOS
VALORES
DESEADOS>
Serializer.Serialize(client,
controller);



Java



Java

private
ObjectOutputStream
salida;

private
ObjectInputStream
entrada;

private
ServerSocket
servidor;

private
Socket
conexion;

public
void
readAndWriteMessage()
{

ControllerMessage
controllerMessage
=
null;

servidor
=
new
ServerSocket(
12345,
100
);

conexion
=
servidor.accept();

salida
=
new
ObjectOutputStream(
conexion.getOutputStream()
);

entrada
=
new
ObjectInputStream(
conexion.getInputStream()
);

controllerMessage
=
ControllerMessage.parseDelimitedFrom(entrada);

/*
TRATAMOS
LOS
CAMPOS
OPORTUNOS
*/

controllerMessage.writeDelimitedTo(salida);

}



JMS
Comunicación del Servidor a GUI

Speaker’s Name 41


El uso

• El servidor envía avisos a los puestos:
– Creación de zonas
– Alarmas
– Actualizaciones de posición de barcos

• ¿y si pregunto cada cierto tiempo? (Polling)
– La escalabilidad se resiente.



JMS

• JMS es la forma en enviar mensajes en Java

Consumer
Destination Topic/ Destination Producer
Queue



JMS


Consumer
Queue
Consumer



JMS


Consumer
Queue
Consumer

Topic/
Queue



JMS


Consumer
Queue
Consumer

Consumer Topic/
Queue



¿JMS a pelo?

• Demasiado código para enviar un mensaje:
• Creación de conexiónes, serialización, gestión deerrores, liberación de
recursos



¿JMS a pelo?

Connection
conn
=
connectionFactory.createConnection();

Session
session
=
conn.createSession(transactional,
ackMode);

ObjectMessage
message
=
session.createObjectMessage(myMessageObject);

Message
Producer
producer
=
session.createProducer(topicName);

producer.send(message);

• Demasiado código para enviar un mensaje:
• Creación de conexiónes, serialización, gestión deerrores, liberación de
recursos



JMS con Spring
JMSTemplate
• Se encarga de:
– Obtención de la conexión,
– Serialización del mensaje
– Envío al tópico/Cola
– Gestión de errores
• Se apoya en
– MessageConverter
– DestinationResolver



Dependencias



Dependencias

<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-core</artifactId>
<version>5.5.0</version>
</dependency>

<dependency>
<artifactId>spring-jms</artifactId>
</dependency>



Configuracion



Configuracion

<?xml
version="1.0"
<beans>

<bean
name="jmsTemplate"
class="org.springframework.jms.core.JmsTemplate">

<property
name="connectionFactory"
ref="jmsConnectionFactory"
/>

<property
name="defaultDestinationName"
value="#{globalTopic.topicName}"/>

<property
name="defaultDestination"
ref="globalTopic"/>

<property
name="receiveTimeout"
value="1"
/>

<property
name="pubSubDomain"
value="true"/>

<property
name="messageConverter"
ref="jmsMessageConverter"/>

</bean>

<bean
name="jmsMessageConverter"

class="org.springframework.jms.support.converter.MarshallingMessageConverter">

<property
name="marshaller"
ref="xstreamMarshaller"/>

<property
name="unmarshaller"
ref="xstreamMarshaller"/>

</bean>

<bean
name="jmsEventEmitter"
class="com.vts.jms.JmsEventEmitter"/>

</beans>



EventEmitter



EventEmitter
public
class
JmsEventEmitter

implements
CameraEventListener,
TrafficEventListener,
...
{

private
JmsTemplate
jmsTemplate;

private
List<ResponsibilityArea>
areas
=
new
ArrayList<ResponsibilityArea>();

private
void
sendJmsEvent(Locatable
event)
{

if
(event.getGeoPoint()
==
null)
{

//events
with
no
location
should
be
sent
to
the
defaultDestination

jmsTemplate.convertAndSend(event);

}
else
{

sendToApplicableAreas(event);

}

}

@Override

public
void
onTrafficEvent(TrafficEvent
event)
{

sendJmsEvent(event);

}

}



Para recibir en el cliente




public
class
JmsAreaListener
{

public
void
receiveMessage(Object
o)
{

if
(o
instanceof
AisTrackPoint)
{

trackPointEventSupport.fire((AisTrackPoint)o);

}
else
if
(o
instanceof
StaticAisMessage)
{

staticAisMessageEventSupport.fire((StaticAisMessage)o);

}

}

}



¡Cuidado con las conexiones!

• JMSTemplate abre y cierra nuevas conexiones
por cada envío
• Solución: PoolConnectionFactory



¡Cuidado con las conexiones!

• JMSTemplate abre y cierra nuevas conexiones
por cada envío
• Solución: PoolConnectionFactory

<bean
id="jmsConnectionFactory"

class="org.springframework.jms.connection.CachingConnectionFactory">

<property
name="targetConnectionFactory">

<bean
class="org.apache.activemq.ActiveMQConnectionFactory">

<property
name="brokerURL"

value="tcp://#{systemProperties['jmsHost']?:'localhost'}:61616"/>

</bean>

</property>
</bean>



MongoDB

Speaker’s Name 53


¿Por qué NoSQL?
Teorema CAP (Eric Brewer)

Source: Nathan Hurst’s Blog



¿Por qué NoSQL?
Consistency

C




¿Por qué NoSQL?
Consistency Availability

C A




¿Por qué NoSQL?

C A

P
Partition Tolerance



¿Por qué NoSQL?

C A
Sólo
2

P
Partition Tolerance



¿Por qué NoSQL?

A
Oracle, MySQL,
C
Sólo
2

P
Partition Tolerance



¿Por qué NoSQL?

A
Oracle, MySQL,
C
M Hyp is, M
on er em Sólo
2
go Ta c
Re

DB ble ac
d

, D , H heD
at Ba B
aS se
to
re
,

P
Partition Tolerance



¿Por qué NoSQL?

A
Oracle, MySQL,
C
M Hyp is, M Sólo

,
on er em

uc ra, ort
2

aK
go Ta c

Co nd m
Re

Ri
DB ble ac

B, a de
d

B,
D ass ol
, D , H heD

hD
ple C o,V
at Ba B

am
aS se
to

yn
re

D
RDBMS
,

Orientadas a documento
P

Sim
orientadas a columna
Key-Value
Partition Tolerance



Tipos

orientadas a Columna orientadas a Documento

Key-value orientadas a Grafos



¿Por qué MongoDB?

• Orientada a Documentos
– heterogéneos
– Representados en formato JSON (o BSON)
• Almacenados en Colecciones (no tablas)
• Un poco de SQL:
– queries, índices, Referencias externas
• Optimizada para escrituras

(cc) Photo by Ampersand Duck - http://www.ﬂickr.com/photos/ampersandduck/4941185476



Documentos JSON
Identificados por un _id
Heterogeneos: Identificamos el tipo con _class



Documentos JSON
Identificados por un _id
Heterogeneos: Identificamos el tipo con _class

{ "_id" : "224000999",
"_class" : "com.vts.model.Vessel",
"flag" : "ALBANIA",
"name" : "Sample NOT_AVAILABLE Vessel 224000999",
"callsign" : "SV224000999",
"toBow" : 25,
"toStern" : 5,
"toPort" : 5,
"toStarboard" : 5,
"comments" : "Sample vessel created automatically for test purposes"
}



Consola JS



Consola JS
beleriand:bin dgomez$ ./mongo
MongoDB shell version: 1.8.1
connecting to: test
>



Consola JS
connecting to: test
> use vts
switched to db vts
>



Consola JS
connecting to: test
> use vts
switched to db vts
> show collections
>
Event
WeatherData
system.indexes
vessel
>



Consola JS
connecting to: test
> use vts
switched to db vts
> show collections
>
Event
WeatherData
system.indexes
vessel
> db.Event.find()
>
{ "_id" : ObjectId("4e0b5b211446446f6be3bb1a"), "_class" :
"com.vts.model.events.SystemEvent", "timestamp" :
ISODate("2011-06-29T17:04:33.039Z") }
{ "_id" : ObjectId("4e0b5b3d144676f49946443f"), "_class" :
"com.vts.model.events.SystemEvent", "timestamp" :
ISODate("2011-06-29T17:05:01.394Z") }
>



SpringData y MongoDB

XML namespace para conﬁgurar driver Mongo
MongoTemplate
Conversión de excepciones automática
Conversión Conﬁgurable
JMX monitoring



Importando Spring Data




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




<repository>
<id>spring-release</id>
<name>Spring Maven Release Repository</name>
<dependency>
<url>http://repo.springsource.org/libs-release</url>
</repository> <groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</
<dependency> artifactId>
<version>2.7.0-rc1</version>
<groupId>org.springframework.data</groupId>
</dependency>
<artifactId>spring-data-mongodb</artifactId>
</dependency>



Configuración.
Spring Namespace



Configuración.
Spring Namespace
<?xml
version="1.0"
<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"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

http://www.springframework.org/schema/data/mongo

http://www.springframework.org/schema/data/mongo/spring-‐mongo-‐1.0.xsd

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

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

</beans>



Configuración.
Spring Namespace
<?xml
version="1.0"
<beans










<mongo:db-‐factory
dbname="vts"/>

</beans>



Configuración.
Spring Namespace
<?xml
version="1.0"
<beans










<mongo:db-‐factory
dbname="vts"/>

<bean
id="mongoTemplate"
class="org.springframework.data.mongodb.core.MongoTemplate">

<constructor-‐arg
name="mongoDbFactory"
ref="mongoDbFactory"
/>

</bean>

</beans>



Spring’s MongoTemplate

<bean
id="mongoTemplate"
class="org.springframework.data.mongodb.core.MongoTemplate">

<constructor-‐arg
name="mongoDbFactory"
ref="mongoDbFactory"
/>
</bean>

Identiﬁca la colección
Convierte query a JSON
Convierte respuesta (“_class”)
Gestiona las conexiones y cursores
Convierte las excepciones


Consultas
RDBMS: SELECT * FROM VESSEL WHERE FLAG = “ALBANIA”;

63

Andrés Pérez y David Gómez


Consultas

{ “flag” : “ALBANIA” }
Mongo:

63



Consultas

Mongo:

Mongo DBCollection vessels = db.getCollection("vessel");

DBObject query = new BasicDBObject();
Driver: query.put("flag", "ALBANIA");

DBCursor albanianShips = vessels.find(query);
while (albanianShips.hasNext()) {
DBObject result = albanianShips.next();
// Create Vessel object from DBObject
}

63



Consultas

Mongo:

Spring
Query query = new Query(Criteria.where("flag").is("ALBANIA");
Mongo
List<Vessel> vessels = mongoTemplate.find(query, Vessel.class);

Template:
63



Consultas

Mongo:
Utilizado para
Identiﬁcación de la colección
Serialización JSON
Spring
Query query = new Query(Criteria.where("flag").is("ALBANIA");
Mongo
List<Vessel> vessels = mongoTemplate.find(query, Vessel.class);

Template:
63



Consultas complejas
RDBMS:



Consultas complejas
SELECT * FROM VESSELS WHERE length < 90 AND length > 30
RDBMS: ORDER BY lastUpdate;

Mongo:



Consultas complejas

Mongo: {
“length” : { $lt : 90, $gt : 30}
}
Mongo
Driver:



Consultas complejas

Mongo: {
“length” : { $lt : 90, $gt : 30}
}
Mongo DBObject query = new BasicDBObject();
DBObject condition = new BasicDBObject("$lt",90);
Driver: condition.put("$gt",30);
query.put("length", condition);

DBObject [] flags = {
new BasicDBObject("flag", "ALBANIA"),
new BasicDBObject("flag", "SAN MARINO")
};
query.put("$or", flags);

vessels.find(query);



Consultas complejas

Mongo: {
“length” : { $lt : 90, $gt : 30}
}



Consultas complejas

Mongo: {
“length” : { $lt : 90, $gt : 30}
}

Criteria criteria = Criteria.where("length");
criteria.gte(from);
Spring criteria.lte(to);

Mongo Query query = new Query(criteria);
query.sort().on("lastUpdate", Order.ASCENDING);

Template: List<Vessel> vessels = mongoTemplate.find(query, Vessel.class);



Inserciones



Inserciones

public class MongoTemplate implements MongoOperations, ApplicationContextAware {

public void save(Object objectToSave)

public void save(Object objectToSave, String collectionName)

}



AbstractRepository



AbstractRepository

public abstract class AbstractMongoRepository<T> {

@Inject
protected MongoTemplate mongoTemplate;

/** Clase que utiliza Mongo para identificar el nombre de la coleccion */
private Class<T> persistentClass;

protected AbstractService(Class<T> persistentClass) {
this.persistentClass = persistentClass;
}

public String determineCollection() {
return persistentClass.getSimpleName();
}
}



AbstractRepository (II)



AbstractRepository (II)
public abstract class AbstractMongoRepository<T> {

public void save(T e) {
mongoTemplate.save(e, determineCollection());
}

public void removeById(String id) {
Object e = findById(id);
if (e != null) {
mongoTemplate.remove(e, determineCollection());
}
}

public T findById(String id) {
T t = mongoTemplate.findById(id, persistentClass);
if (t == null) {
throw new ObjectNotFoundException(persistentClass, id);
}
return t;
}
} Indra y Extrema Sistemas
67


VesselRepository



VesselRepository

public class VesselRepository extends AbstractMongoRepository<Vessel> {

public VesselRepository() {
super(Vessel.class);
}

}



A tener en cuenta

• Cuidado con los campos transient
– La serializacion object <-> JSON se hace por
reflexión
– Registrar un custom Converter
• Queries con multiples valores



A tener en cuenta

reflexión
Query query = new Query(
Criteria
.where("length").gte(20)
.and("length").lt(60));



A tener en cuenta

reflexión
Query query = new Query(
Criteria
.where("length").gte(20).lte(60));



Q&A

Speaker’s Name 70


A real systemwithjms-rest-protobuf-mongodb

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (12)

Más de David Gómez García

Más de David Gómez García (20)

Último

Último (20)

A real systemwithjms-rest-protobuf-mongodb