BT

Accueil InfoQ Actualités Présentation De Jakarta NoSQL

Présentation De Jakarta NoSQL

Favoris

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 CassandraMongoDBNeo4JCouchDB 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.

 

Evaluer cet article

Pertinence
Style

Bonjour étranger!

Vous devez créer un compte InfoQ ou cliquez sur pour déposer des commentaires. Mais il y a bien d'autres avantages à s'enregistrer.

Tirez le meilleur d'InfoQ

Html autorisé: a,b,br,blockquote,i,li,pre,u,ul,p

Commentaires de la Communauté

Html autorisé: a,b,br,blockquote,i,li,pre,u,ul,p

Html autorisé: a,b,br,blockquote,i,li,pre,u,ul,p

BT

Votre profil est-il à jour? Merci de prendre un instant pour vérifier.

Note: en cas de modification de votre adresse email, une validation sera envoyée.

Nom de votre entreprise:
Rôle dans votre entreprise:
Taille de votre entreprise:
Pays/Zone:
État/Province/Région:
Vous allez recevoir un email pour confirmer la nouvelle adresse email. Ce pop-up va se fermer de lui-même dans quelques instants.