Persistencia Groovy liviana

Question

¿Cuáles son algunas opciones livianas para la persistencia en Groovy? He considerado la serialización y el XML hasta ahora, pero quiero algo un poco más robusto que esos, al menos para no tener que volver a escribir todo el archivo cada vez. Idealmente, sería:

• No requieren JAR en la ruta de clase, a partir de uvas en lugar
• no requieren externa procesos, administración, o la autenticación (por lo que todo integrado)
• Soporte de bloqueo

planeo al usarlo para almacenar en caché alguna información entre ejecuciones de una secuencia de comandos Groovy independiente. Imagino que las respuestas se centrarán en las bases de datos SQL y NoSQL. Se apreciarán enlaces a páginas que demuestren este uso. ¡Gracias!

Answer 1

base de datos SQL completa

El h2 en proceso de base de datos SQL es muy fácil de usar. Este es el mismo motor de base de griales usa por defecto, pero es fácil de usar en un guión maravilloso, así:

@GrabConfig(systemClassLoader=true) 
@Grab(group='com.h2database', module='h2', version='1.3.167') 

import groovy.sql.Sql 

def sql = Sql.newInstance("jdbc:h2:hello", "sa", "sa", "org.h2.Driver") 
sql.execute("create table test (id int, value text)") 
sql.execute("insert into test values(:id, :value)", [id: 1, value: 'hello']) 
println sql.rows("select * from test") 

En este caso, la base de datos se guarda en un archivo llamado hello.h2.db.

simples Mapas persistentes

Otra alternativa es jdbm, que proporciona mapas persistentes disco respaldados. Internamente, usa la serialización de Java. La interfaz de programación es mucho más simple, pero también mucho menos poderosa que una base de datos SQL completa. No hay soporte para el acceso simultáneo, pero está sincronizado y es seguro para subprocesos, lo cual puede ser suficiente dependiendo de sus requisitos de bloqueo. Aquí hay un ejemplo simple:

@Grab(group='org.fusesource.jdbm', module='jdbm', version='2.0.1') 

import jdbm.* 

def recMan = RecordManagerFactory.createRecordManager('hello') 
def treeMap = recMan.treeMap("test") 
treeMap[1] = 'hello' 
treeMap[100] = 'goodbye' 
recMan.commit() 
println treeMap 

Esto guardará el mapa en un conjunto de archivos.

Answer 2

simplemente un poco groovy actualización sobre la persistencia simple usando JDBM. El acceso concurrente es compatible ahora. El nombre ha cambiado de JDBM4 a MapDB.

@Grab(group='org.mapdb', module='mapdb', version='0.9.3') 

import java.util.concurrent.ConcurrentNavigableMap 
import org.mapdb.* 

DB db = DBMaker.newFileDB(new File("myDB.file")) 
      .closeOnJvmShutdown() 
      .make() 

ConcurrentNavigableMap<String,String> map = db.getTreeMap("myMap") 

map.put("1", "one") 
map.put("2", "two") 
db.commit() 

println "keySet "+map.keySet() 

assert map.get("1") == "one" 
assert map.get("2") == "two" 

db.close() 

Answer 3

Chronicle Map es una persistido ConcurrentMap aplicación de JVM.

Ejemplo de uso:

ConcurrentMap<String, String> store = ChronicleMap 
    .of(String.class, String.class) 
    .averageKey("cachedKey").averageValue("cachedValue") 
    .entries(10_000) 
    .createPersistedTo(new File("cacheFile")) 

store.put("foo", "bar") 
store.close()