Récemment approuvé en tant que projet EE4J, Jakarta NoSQL est une spécification de Jakarta EE destinée à aider les développeurs à créer des applications d'entreprise utilisant les technologies Java et NoSQL. JNoSQL est l'implémentation de référence de Jakarta NoSQL, fournissant un ensemble d'API et une implémentation standard pour une série de bases de données NoSQL, telles que Cassandra, MongoDB, Neo4J, CouchDB et OrientDB, entre autres.
Jakarta NoSQL consiste en une couche de communication (Diana), qui fournit un ensemble d'API conçues pour définir la communication avec les bases de données NoSQL. Il contient quatre modules en fonction de chaque type de base de données NoSQL : clé-valeur, colonnes, documents et graphe et une couche de mappage (Artemis), qui fournit une série d'API permettant aux développeurs d'intégrer des applications Java à des bases de données NoSQL. La couche de mapping est basée sur les annotations et utilise des technologies telles que CDI et Bean Validation, ce qui en simplifie l'utilisation par les développeurs. Il est possible de comparer la couche de mappage avec JPA / Hibernate dans le monde traditionnel des SGBDR.
(Image tirée de github.com/eclipse-ee4j/nosql )
Approfondissons un peu et explorons comment communiquer avec les bases de données NoSQL de type clé-valeur, colonne, document et Graphe.
La définition d'une entité est relativement similaire à celle de JPA. Vous utilisez essentiellement @Entity
, @Id
, @Column
et ainsi de suite :
@Entity
public class Person {
@Id
private long id;
@Column
private String name;
@Column
private List<string> phones;
}
Les référentiels ressemblent aux référentiels Spring Data, dans lesquels vous étendez un Repository<T, ID>
:
public interface PersonRepository extends Repository<person, long=""> {
List<Person> findByName(String name);
Stream<Person> findByPhones(String phone);
}
Cependant, à partir de ce moment, les choses changent, car les dépendances Maven changent en fonction du type de base de données NoSQL utilisé, ainsi que de la configuration de l'installation et de la façon dont nous injectons le référentiel dans nos services.
Comparons les différences entre les bases de données NoSQL de type colonnes et ocuments :
Colonne
Voici les artefacts Maven :
<dependency>
<groupId>org.jnosql.artemis</groupId>
<artifactId>artemis-column</artifactId>
<version>0.0.9</version>
</dependency>
<dependency>
<groupId>org.jnosql.diana</groupId>
<artifactId>cassandra-driver</artifactId>
<version>0.0.9</version>
</dependency>
Voici un exemple de producteur utilisé pour configurer le ColumnFamilyManager
:
@ApplicationScoped
public class ColumnFamilyManagerProducer {
private static final String KEY_SPACE = "developers";
private ColumnConfiguration<> cassandraConfiguration;
private ColumnFamilyManagerFactory managerFactory;
@PostConstruct
public void init() {
cassandraConfiguration = new CassandraConfiguration();
managerFactory = cassandraConfiguration.get();
}
@Produces
public ColumnFamilyManager getManagerCassandra() {
return managerFactory.get(KEY_SPACE);
}
}
Et enfin, un exemple sur la façon d'exécuter des insertions / requêtes :
Person person = Person.builder()
.withPhones(Arrays.asList("234", "432"))
.withName("Name")
.withId(id)
.build();
//using ColumnTemplate
ColumnTemplate columnTemplate = container.select(CassandraTemplate.class).get();
Person saved = columnTemplate.insert(PERSON);
System.out.println("Person saved" + saved);
ColumnQuery query = select().from("Person").where(eq(Column.of("id", 1L))).build();
Optional<Person> person = columnTemplate.singleResult(query);
System.out.println("Entity found: " + person);
//using PersonRepository
PersonRepository repository = container.select(PersonRepository.class).select(ofColumn()).get();
Person saved = repository.save(PERSON);
System.out.println("Person saved" + saved);
Optional<Person> person = repository.findById(1L);
System.out.println("Entity found: " + person);
Document
Voici les artefacts Maven :
<dependency>
<groupId>org.jnosql.artemis</groupId>
<artifactId>artemis-document</artifactId>
<version>0.0.9</version>
</dependency>
<dependency>
<groupId>org.jnosql.diana</groupId>
<artifactId>mongodb-driver</artifactId>
<version>0.0.9</version>
</dependency>
Voici un exemple de producteur utilisé pour configurer le DocumentCollectionManager
:
@ApplicationScoped
public class DocumentCollectionManagerProducer {
private static final String COLLECTION = "developers";
private DocumentConfiguration configuration;
private DocumentCollectionManagerFactory managerFactory;
@PostConstruct
public void init() {
configuration = new MongoDBDocumentConfiguration();
Map<String, Object> settings = Collections.singletonMap("mongodb-server-host-1", "localhost:27017");
managerFactory = configuration.get(Settings.of(settings));
}
@Produces
public DocumentCollectionManager getManager() {
return managerFactory.get(COLLECTION);
}
}
Et enfin, un exemple sur la façon d'exécuter des insertions / requêtes :
Person person = Person.builder()
.withPhones(Arrays.asList("234", "432"))
.withName("Name")
.withId(id)
.build();
//using DocumentTemplate
DocumentTemplate documentTemplate = container.select(DocumentTemplate.class).get();
Person saved = documentTemplate.insert(person);
System.out.println("Person saved" + saved);
DocumentQuery query = select().from("Person")
.where(eq(Document.of("_id", id))).build();
Optional<Person> personOptional = documentTemplate.singleResult(query);
System.out.println("Entity found: " + personOptional);
//using PersonRepository
PersonRepository repository = container.select(PersonRepository.class)
.select(ofDocument()).get();
repository.save(person);
List<Person> people = repository.findByName("Name");
System.out.println("Entity found: " + people);
repository.findByPhones("234").forEach(System.out::println);
Plus de détails sur l'implémentation de référence de Jakarta NoSQL sont disponibles sur la page JNoSQL.
Une présentation de Jakarta NoSQL sur Jakarta One est également disponible.
Les utilisateurs qui souhaitent contribuer peuvent s'inscrire sur la liste de diffusion ou rester en contact via Twitter.