Getting started

Installer Generic System

Pré-requis

Pour pouvoir utiliser le moteur d’informations Generic System dans votre projet, vous aurez besoin de disposer de Java 8 (JRE ou JDK). Vous pourrez télécharger la dernière version sur le site d’Oracle : télécharger Java. Pour plus de renseignements concernant la procédure d’installation relative à votre système d’exploitation, vous pouvez consulter le guide d’installation d’Oracle.

Configuration du projet (Maven)

Vous devez tout d’abord ajouter le dépôt Maven de Middleware Factory. Pour cela, insérez le code suivant dans le fichier de configuration pom.xml de votre projet :

<repository>
    <id>middlewarefactory</id>
    <url>http://middlewarefactory.com/repository</url>
    <releases>
        <enabled>true</enabled>
        <updatePolicy>daily</updatePolicy>
    </releases>
    <snapshots>
        <enabled>true</enabled>
        <updatePolicy>daily</updatePolicy>
    </snapshots>
</repository>

<id>middlewarefactory</id>

<url>http://middlewarefactory.com/repository</url>

<updatePolicy>daily</updatePolicy>

</releases>

<updatePolicy>daily</updatePolicy>

</snapshots>

</repository>

Vous pouvez ensuite ajouter la dépendance maven suivante :

<dependency>
    <groupId>org.genericsystem</groupId>
    <artifactId>gs-kernel</artifactId>
    <version>4.0-SNAPSHOT</version>
</dependency>

<groupId>org.genericsystem</groupId>

<artifactId>gs-kernel</artifactId>

<version>4.0-SNAPSHOT</version>

</dependency>

Et voilà ! Vous êtes prêt à utiliser Generic System dans votre projet.

Créer une nouvelle application Generic System

Principes de base

Le moteur d’informations de Generic System permet de créer et d’exécuter très rapidement un moteur de base de données. Vous trouverez plus d’informations sur le fonctionnement de base de Generic System dans les articles suivants :

Le moteur d’informations de Generic system peut être exécuté de deux manières (modes) différentes :

Le mode embarqué : le système est exécuté en mémoire seulement, il n’y a pas de persistance.
Le mode persistant : le système est exécute en mémoire, et le graphe de Generic est régulièrement persisté sur le disque.

L’utilisation la plus simple consiste à démarrer le moteur en mode embarqué. Pour cela, vous devez créer une nouvelle instance d' Engine sans fournir d’arguments :

Engine engine = new Engine();

1	Engine engine = new Engine();

Il n’est pas nécessaire de fournir des arguments, et vous bénéficiez de toute la puissance de Generic System sans qu’aucune donnée ne soit sauvegardée sur votre ordinateur. Ce mode est idéal pour apprendre à utiliser Generic System, ou bien pour tester une preuve de concept. Cependant, vous pouvez tout à fait décider de vouloir démarrer le moteur en mode persistant, ne serait-ce que pour sauvegarder les données. Dans ce cas, vous allez créer une instance d' Engine en lui fournissant un nom et un chemin de persistance :

Engine engine = new Engine("myDataBase", System.getenv("HOME") + "/path/to/my/folder");

1	Engine engine = new Engine("myDataBase", System.getenv("HOME") + "/path/to/my/folder");

Dans cet exemple très simple, on crée une base de données appelée “myDataBase” dans le répertoire $HOME/path/to/my/folder . C’est la seule configuration dont vous aurez besoin pour créer votre base de données ! Si vous souhaitez plus d’informations concernant la gestion de la persistance, vous pouvez consulter l’article suivant :

Avancé – Engine et son point d’accès le Cache.

Vous trouverez de nombreux exemples d’utilisation du moteur d’informations dans les articles de ce site. Dans la majorité des cas c’est le mode embarqué qui a été utilisé, mais il est tout à fait possible de reproduire ces exemples dans le mode persistant.

Cas d’utilisation simple comparé au paradigme relationnel

Prenons l’exemple de la création d’un véhicule possédant une puissance. Nous voulons ajouter un véhicule nommé “myBmw” d’une puissance de 233 ch. Voici comment procéder avec Generic System :

// Create the database
Engine engine = new Engine(); // (1)

// Create the structure
Generic vehicle = engine.addInstance("Vehicle"); // (2)
Generic power = vehicle.addAttribute("Power"); // (3)

// Add data
Generic myBmw = vehicle.addInstance("myBmw"); // (4)
myBmw.addHolder(power, 233); // (5)

// Persist changes
engine.getCurrentCache().flush(); // (6)

// Create the database

Engine engine = new Engine(); // (1)

// Create the structure

Generic vehicle = engine.addInstance("Vehicle"); // (2)

Generic power = vehicle.addAttribute("Power"); // (3)

// Add data

Generic myBmw = vehicle.addInstance("myBmw"); // (4)

myBmw.addHolder(power, 233); // (5)

// Persist changes

engine.getCurrentCache().flush(); // (6)

Le tableau comparatif ci-dessous présente les analogies et différences entre Generic System et les bases de données relationnelles :

Ref	Generic System	Equivalent SGBDR
(1)	Crée et démarre un nouveau moteur (en mode embarqué), crée un nouveau cache sur le moteur.	Démarre la base de données et commence une nouvelle transaction.
(2)	Crée un nouveau type Vehicle.	Crée une nouvelle table Vehicle.
(3)	Positionne l’attribut Power sur le type Vehicle.	Crée une nouvelle colonne Power dans la table Vehicle.
(4)	Crée une nouvelle instance myBmw de type Vehicle.	Crée un nouvel enregistrement dans la table Vehicle.
(5)	Assigne la valeur 233 pour l’instance myBmw à l’attribut Power du type Vehicle.	Assigne la valeur 233 pour l’enregistrement créé à la colonne Power de la table Vehicle.
(6)	Valide l’ensemble des opérations réalisées sur le cache et persiste l’information.	Valide la transaction.

Recherche de l’information

Comme dans tout système de persistance des données, il est possible de rechercher une (ou plusieurs) information(s) dans Generic System. Vous trouverez des exemples détaills dans les articles suivants :

Gestion des contraintes

De façon similaire à ce qui existe en base de données relationnelles, il est possible d’imposer certaines contraintes à notre modèle de persistance. La contrainte SingularConstraint permet par exemple de créer des mapping OneToOne, OneToMany, ManyToOne ou ManyToMany. Vous trouverez plus d’informations sur les contraintes de Generic System dans les articles suivants :

Notions avancées

Dans la majorité des exemples présentés jusque là, les generic sont créés de façon dynamique : on crée un type, puis on pose un attribut, puis on crée une instance, etc. Sachez qu’il est également possible de créer un modèle de données de façon statique grâce aux annotations. Vous trouverez plus d’explications dans les articles suivants :

Enfin, certaines notions plus spécifiques sont abordées dans les articles suivants :

Exemples d’utilisation

Si vous souhaitez intégrer Generic System dans vos projets, voici quelques exemples de projets dans lesquels Generic System a été utilisé :

Installer et utiliser Generic System avec CDI (Java EE)

Si vous souhaitez utiliser Generic System avec CDI (JEE), il est nécessaire d’ajouter la dépendance gs-cdi au fichier de configuration pom.xml de votre projet :

<dependency>
    <groupId>org.genericsystem</groupId>
    <artifactId>gs-cdi</artifactId>
    <version>4.0-SNAPSHOT</version>
</dependency>

<groupId>org.genericsystem</groupId>

<version>4.0-SNAPSHOT</version>

</dependency>

Par ailleurs, vous devez disposer d’une implémentation de CDI 1.2.

Ensuite, le moteur n’est plus créé mais directement injecté :

@Inject
Engine engine;

1 2	@Inject Engine engine;