Sommaire

1 Présentation générale
2 Projet
- 2.1 Le sujet
- 2.2 Cahier des charges
3 Informations importantes
4 Mise en œuvre
- 4.1 Manipulation des données MongoDB à l'aide d'une application java
  - 4.1.1 Logiciel et librairie utilisé
  - 4.1.2 Développement de l'application de gestion java
- 4.2 Développement de l'application web en java
5 Source
- 5.1 Documentation
- 5.2 Tutoriel

Présentation générale

Nom du projet : Développement d'une base de donnée

Stagiaire : Fabien DI NATALE

Projet

Le sujet

Nous devons créer une base de donnée dont le but sera de regrouper toute les interfaces connectées au réseau et de pouvoir les retrouver par des requêtage spécifique : Nous pourrons rechercher les interfaces connectées par Caractéristiques, par nom ou par ID. Cette base de donnée devra être accessible et modifiable par une application web codé en java. Nous ne devons pas sous estimer la possibilité d’une augmentation exponentiel des données en cas d’utilisation de notre projet à plus grande ampleur. Sans oublier la protection des données.

Chaque interface connectées comportera les champs suivants:

Un FCC_ID
Un nom
Son mode de communication
Sa marque
Sa version
Ses caractéristiques
Ses failles de sécurité

Cahier des charges

Contexte : Énormément d’interfaces connectée sont utilisé dans le monde mais aucune base de donnée de l’IRCICA permet leur identification et le stockage de leurs information

Objectif : Créer une base de donnée capable de gérer une grandes quantité d’interface connectée et accessible à travers le monde

Besoins fonctionnels : Nous avons besoin que cette base de donnée soit facilement et rapidement modifiable Facilement et rapidement accessible La plus résistante possible aux différentes attaques

Contraintes : Le serveur web doit être développé en Java et nous devons avoir un niveau de sécurité élevé

Résultats attendus : Une applications web protégé et accessible avec une grande efficacité de recherche et de modification des données

Exigences : Nous devons avoir notre base de donnée ainsi que notre application web bien protégé contre les cyber attaque

Informations importantes

Les Bases de données

Pour commencer voici les différents type de base de données:

Les bases de données relationnel:

Les bases de données relationnel sont les bases de données de référence, les plus anciennes et les plus utilisé, elles possèdent toute le même language le SQL. Celles ci permettent une grande rapidité de traitement et la possibilité de gérer de grand volume. Cependant les bases de données relationnel sont très strict dans leur conception et une fois faite elles ne peuvent plus être modifier. De plus chaque membres d'une table doit posséder les attributs avec lesquels la table a était créé.

Les bases de données orientées clé-valeur:

Ces bases de données reliant simplement une clé à une valeur sont des bases de données très rapide, ce sont les bases de données les plus rapide en terme de recherche et d'accés aux données mais sont limité dans la formation des donnée et la gestion de requête sophistiqué.

Les bases de données orientée documents:

Ces bases de données est l'évolution des bases de données clé-valeur ajoutant certains avantage comme une structure très libre contrairement aux structure clé-valeur se limitant à une clé pour une valeur. Ces bases de données permettent des recherches plus sophisitiqué et peuvent enregistré des structures extrèmement varié au sein de la même base de donnée. Ceci lui fait perdre un peu de rapidité par rapport aux bases de données clé-valeur. Cependant les bases de données orientée documents reste très performante et très rapide.

Les bases de données orientée collones :

Ces bases de données sont orientée collones, elles peuvent ainsi modifier toute les données à l'aide d'une seule commande très rapidement. Ces bases de données permettent l'ajout d'un attribut très rapidement. Ces bases de données sont alors recherché et utilisé pour leur capacité à monter en charge et à acceuillir une forte volumétrie de données.

Les bases de données à index inversé:

Ces bases de données font appel aux même principe que les bases de données orientée documents tout en profitant d'excellentes capacité de requêtage, ce système de BDD a était popularisé par google et est donc très puissant pour les recherches en milieu de texte mais ceci augmente le temps d'insertion de nouvelles données.

Comme nous avons pu le voir plus haut notre base de donnée a besoin de pouvoir faire des recherches rapide, simple et organisé tout en gardant une rapidité de modification et d'ajout de données. Nous voulons aussi que la bases de données nous donne la possibilité de modifier facilement les structures de données déjà présente. J'ai alors choisie l'utilisation d'une base de données orientées document.

Couchbase:

Cette base orientée documents privilégie la cohérence des données aux performances pures. Couchbase dispose d'un outil de requêtage normalisé SQL appelé N1QL. Couchbase vise les applications web et peut être utilisé sur mobile. Possibilité d'utiliser les jointures à l'aide du language N1QL. Couchbase est très proche de CouchDB. BDD orientée clé-valeur et documents, fait un mix des deux pour rendre le plus polyvalent possible.

MongoDB:

Moteur orientée documents reconnu pour la souplesse de sa structure. Il reste très souple, pas besoin de préstructurer les données il suffit de créer des collections d'y mettre des éléments sans avoir besoin de dire comment les organiser. Tout en répondant à 80% des besoins couverts par une base relationnelle traditionnelle, à l'exception du transactionnel. Ce moteur s'appuie sur la technique json. Recherche rapide et puissante mais pas de fonction join.

J'ai fait le choix d'utiliser la base de données MongoDB car c'est une base de données très performante et très souple possédant une énorme communauté et donc énormément de documentation, tutoriel et peu de bug. De plus, MongoDB profite d'un driver très bien aboutit pour le code java nous permettant alors de manipuler toute les bases de données facilement tout en respectant notre cahier des charges.

MongoDB

MongoDB est une base de données noSQL ce qui signifie n'utilisant pas le language de communication ainsi que les requête SQL. Ce n'est donc pas une base de données relationnel comme on a l'habitude de voir mais une base de données orienté document.

Cette orientation document lui donne plusieurs avantage comme :

une grande simplicité;
une grande souplesse ;
une grande évolutivité.

De plus MongoDB propose les fonctionnalités suivantes:

la réplication lui permettant de dupliquer les serveurs de base de données pour répondre à une monté en charge rapide tout en augmantant sa tolérance aux pannes;
le Sharding lui permettant de répartir les données sur plusieurs serveurs afin d'augmenter les performances ou de répartir les données géographiquement;
un système d’information géographique permettant de manipuler simplement des positions sur un plan ou sur le globe terrestre;
un système de recherche optimisé en fonction de la langue utilisée.

MongoDB utilise les fichiers JSON pour gérer ses données rendant ainsi les fichiers facilement manipulable et modifiable. Les bases de données MongoDB sont alors utilisé lorsque les systèmes ont besoin de prévoir une montée en charge rapide, ayant besoin de schéma souple et facilement reconfigurable, ayant besoin d'une répartition géographique des données ou encore une base de données ayant besoin de système de recherche, de stockage de fichier ou d’un système information géographique.

Java EE

Le terme « Java EE » signifie Java Enterprise Edition, et était anciennement raccourci en « J2EE ». Il fait quant à lui référence à une extension de la plate-forme standard. Autrement dit, la plate-forme Java EE est construite sur le langage Java et la plate-forme Java SE, et elle y ajoute un grand nombre de bibliothèques remplissant tout un tas de fonctionnalités que la plate-forme standard ne remplit pas d'origine. L'objectif majeur de Java EE est de faciliter le développement d'applications web robustes et distribuées, déployées et exécutées sur un serveur d'applications. Java EE a était très longtemps déprécié par sa complexité menant même à la naissance du framework Spring visant à remplacer Java EE trop complexe à prendre en main mais Java EE a su évoluer et se simplifier tandisque Spring se compléxifié.

Java EE se distingue de ses concurent par la prise en charge de toute les bibliothèques standard répondant à la plupart des besoin ainsi que des bibliothèques logicielles additionnelles dédiées à des applications professionnelles, facilitant par exemple le développement d'applications pour architecture distribuée.

Aujourd'hui confié par Oracle à la fondation éclipse et maintenant appelé Jakarta EE, il dispose d'énormément de composant. En particulier des API ainsi que des composant orienté développement web tel que les Servlets qui est le controller dans les modèles MVC des sites web. Il possédes aussi des framexork web ainsi que des bibliothèques de balises tel que les JavaServer Pages (JSP), les Java Standard Tag Library (JSTL) et les JavaServer Faces (JSF).

Mise en œuvre

Manipulation des données MongoDB à l'aide d'une application java

Logiciel et librairie utilisé

Afin de apprendre à manipuler MongoDB et que cela corresponde bien à notre cahier des charges nous avons utilisé les logiciels suivant:

MongoDB:

mongo-tools
collection of tools for administering MongoDB servers
mongodb-org
MongoDB open source document-oriented database system (metapackage)
mongodb-org-mongos
MongoDB sharded cluster query router
mongodb-org-server
MongoDB database server
mongodb-org-shell
MongoDB shell client

API java :

MongoDB driver

Afin d'utiliser l'API MongoDB driver nous avons installé maven et intégré la dépendance suivante :

<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-driver-sync</artifactId>
        <version>3.10.1</version>
    </dependency>
</dependencies>

Développement de l'application de gestion java

Afin de gérer la base de donnée MongoDB nous avons choisi d'utiliser le language de programmation java.

Afin de répondre au cahier des charges et intégrer les fonctions aux serveur web par la suite,

voici les fonctions a réaliser :

afficher les objets connectés;
afficher les caractéristiques;
recherche d'un objet connecté par nom;
ajout d'un objet connecté;
ajout d'une caractéristique ;
recherche d'un objet connecté par ID;
listage des objets connectés par caracteristique;
ajouter une caracteristique à un objet connecté;
ajouter une faille à un objet connecté ;
supprimer une caracteristique d'un objet connecté;
supprimer une faille d'un objet connecté;
supprimer un objet connecté.

Afin d'expliquer au mieux ce code sans que cela soit trop rébarbatif je vais vous présenter quelque fonction :

Pour commencer voici une fonction de recherche, ici celle de recherche par nom:

   static List<IOT> recherche_IOTs_nom(MongoCollection c, String name) throws NullPointerException{
       BasicDBObject textSearch = new BasicDBObject("nom", new BasicDBObject("$regex", ".*"+name+".*"));
       FindIterable findIterable = c.find(textSearch);      
       if(findIterable == null){
           throw new NullPointerException();
       }
       List<IOT> r = new ArrayList<>();
       MongoCursor<Document> it = findIterable.iterator();
       while(it.hasNext()){
           Document doc = it.next();
           r.add(Recuperation_BDD_IOT_V2(doc));
       }
       return r;
   }

Dans cette fonction nous déterminons l'object de recherche à l'aide de regex permettant une recherche souple, c'est à dire que tous les documents comportant dans leur attribut nom le String name, qu'il soit parfaitement identique ou noyé au milieu d'une longue phrase seront retourné. Nous allons ensuite vérifier que nous avons bien un document correspondant à la recherche puis nous récupérons les informations à l'aide d'une fonction de récupération des objets nommée Recuperation_BDD_IOT_V2. Nous retournons enfin la list des Objets trouvé sous forme de ArrayList.

Cette fonction Recuperation_BDD_IOT_V2 est basé sur le même fonctionnement que la fonction suivante :

   static caracteristique Recuperation_BDD_caracteristique(Document doc){
       List list = new ArrayList(doc.values());
       if(list.size() < 1){
           return null;
       }
       String id_s = list.get(0).toString();
       String name = (String) list.get(1); 
       String description = null;
       try{
           description = (String) list.get(2);
       }
       catch(IndexOutOfBoundsException e){
           description = null;
       }
       //int id;
       //id = ObjectId(id_s);
       caracteristique c = new caracteristique(id_s,name,description);
       return c;
   }

Nous prenons un document en entrée, on lui fait subir un cast pour en faire une list et ensuite nous utilisons la méthode get afin de récupérer les différents champs du document en faisant bien attention aux exceptions IndexOutOfBoundsException qui apparaisse assez souvent car à cause de la flexibilité de mongoDB les documents ne sont pas tous de la même taille rendant alors les fonctions de récupération assez longue.

Nous allons maintenant voir comment ajouter un objet ainsi qu'une caractéristique dans la base de données :

   public void add_BDD(MongoCollection collection){
       Document newDoc = new Document();
       newDoc.put("ID", this.ID);
       newDoc.put("nom", this.nom);
       newDoc.put("MDC", this.MDC);
       newDoc.put("version", this.Version);
       newDoc.put("nbr_caracteristique", this.nbr_caracteristique);
       List<Document> d = new ArrayList<>();
       for(int i = 0 ; i < this.nbr_caracteristique ; i++){
           d.add(new Document("caracteristique",this.caracteristiques.get(i)));
       }
       newDoc.put("caracteristique", d);
       newDoc.put("nbr_faille", this.nbr_faille);
       List<Document> f = new ArrayList<>();
       for(int i = 0 ; i < this.nbr_faille ; i++){
           f.add(new Document("faille",this.faille.get(i)));
       }
       newDoc.put("faille", f);
       try{
           collection.insertOne(newDoc);
       }
       catch(MongoException e){
           System.out.println("Update fail\n");
       }
   }

Dans cette fonction nous créon un Document dans lequel nous ajoutons tous les attributs de notre objet les un après les autres tout en créant un tableau de string pour les caractéristiques et les failles, ces tableaux pourront être de n'importequelle taille d'où les deux attribut : nbr_caracteristique et nbr_faille.

Pour finir nous pouvons voir comment l'ajout de caractéristique ce fait, donc voici la fonction qui s'en occupe :

public void add_caracteristique(MongoCollection collection, caracteristique c){

       this.nbr_caracteristique++;
       this.caracteristiques.add(c.nom);
       BasicDBObject searchQuery = new BasicDBObject("ID", this.ID);
       Document newDoc = new Document();
       newDoc.append("nbr_caracteristique", this.nbr_caracteristique);
       newDoc = new Document().append("$set", newDoc);
       try{
           collection.updateOne(searchQuery, newDoc, new UpdateOptions().upsert(true));
       }
       catch(MongoException e){
           System.out.println("Update fail\n");
       }
       newDoc.put("$push",new Document().append("caracteristique", c.nom));
       try{
           collection.updateOne(searchQuery, newDoc, new UpdateOptions().upsert(true));
       }
       catch(MongoException e){
           System.out.println("Update fail\n");
           this.nbr_caracteristique--;
           this.caracteristiques.remove(c.nom);
       }
   }

Nous pouvons identifier le searchQuery permettant de sélectionner l'objet souhaité et le newDoc qui dans un premier temps met à jour le nombre de caracteristique que l'objet possède avec la commande $set et dans un second temps ajoute le nom de la caractéristique au tableau des caractéristiques avec la commande $push .

Maintenant que toute ces fonctions sont fonctionnel et vérifié à l'aide du script shell MongoDB nous pouvons passer à la partie serveur web du projet.

Développement de l'application web en java

Logiciel et librairie utilisé

Afin de créer le plus proprement et le plus facilement possible notre serveur web nous avons fait le choix d'installer un IDE: netbeansIDE qui s'est avéré très pratique pour l'utilisation de maven et l'intégration des accès aux bases de données MongoDB dans notre serveur Web.

Nous avons ajouté la dépendance suivante :

<dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-web-api</artifactId>
    <version>6.0</version>
    <scope>provided</scope>
</dependency>

Dans cette partie du code nous avons seulement ajouté les librairie implémenter par le framework java EE au librairie de mongoDB que nous avons eu l'occasion d'utiliser précédemment.

Modèle utilisé

Afin de réaliser ce projet je me suis orienté vers un modèle de serveur web spécifique, le modèle MVC.

Ce modèle décrit une architecture précise comportant trois parties : La partie Modèle , la partie Vue et la partie Contrôleur pour MVC. La partie Modèle est la partie encapsulant la logique métier ainsi que l'accès aux donner. Cette partie de l'architecture sera représenté par nos classes métier. La partie Vue s'occupe de toute les interactions avec l'utilisateur donc ici ça sera toute nos page web écrit en JSP. La partie Contrôleur gère le liens entre l'utilisateur et le reste de l'application, ici nous gérerons ce lien à l'aide des Servlets.

Ce modèle permet d'avoir une séparation claire des différentes partie du code même si ceci augmente la complexité de l'architecture de notre serveur web. Nous pouvons donc avoir dans notre serveur web trois partie très distincte représentant les trois parties du modèle MVC avec en appuie quelque classes rassemblé sous un package bean représentant les différentes classes que nous allons manipuler dans les trois partie.