Outil de gestion d’une bibliothèque personnelle · Projet de licence professionnelle en conception et développement orientés objet d’applications multi tiers à l’université

Outil de gestion d’une bibliothèquepersonnelle

Projet de licence professionnelle en conception et développement orientés objetd’applications multi tiers à l’université de Franche-Comté

Dominguez JonathanRagot Alexis

Encadré par FELEA VioletaSession 2013 /2014

Sommaire

Remerciements................................................................................................................. 3

Introduction...................................................................................................................... 4

I Outil de gestion d’une bibliothèque personnelle

- Besoins............................................................................................................... 5

- Fonctionnalités................................................................................................... 5

II Analyse............................................................................................................................. 6

III Aspects conceptuels et technologiques

- L’architecture n-tiers.......................................................................................... 8

- Le modèle MVC................................................................................................ 9

- Les design patterns............................................................................................. 9

- Logiciels et langages utilisés............................................................................. 10

IV Développement de l’application de gestion de bibliothèque

- Description technique du modèle MVC............................................................ 12

- Description technique du tier Métier................................................................. 14

- Description technique du tier Physique............................................................. 15

- Les API utilisés.................................................................................................. 16

- Bootstrap............................................................................................................ 18

- Paramétrage de l’application.............................................................................. 19

- Le téléchargement de fichiers............................................................................ 19

V Gestion du projet

- Diagramme de Gantt.......................................................................................... 20

- Travail en binôme.............................................................................................. 21

Conclusion....................................................................................................................... 22

ANNEXES

- Règles de codage................................................................................................ 23

- Glossaire............................................................................................................ 24

- Interfaces utilisateurs......................................................................................... 25

- Diagrammes UML métier et physique............................................................... 30

- Méthode de positionnement des livres.................................................. 31

Netographie...................................................................................................................... 32

Bibliographie.................................................................................................................... 32

Outil de gestion d’une bibliothèque personnelle page 2/33

Remerciements

Nous tenons à remercier dans un premier temps, toute l’équipe pédagogique de l'Université deFranche-Comté et les intervenants professionnels responsables de la licence professionnelleConception et développement orientés objet d'applications multi-tiers, pour avoir assuré la partiethéorique de celle-ci.

Nous remercions également Madame Felea notre enseignante tutrice pour l’aide et les conseilsconcernant le projet et à l'élaboration du rapport.


Introduction

Le projet de Licence Professionnelle informatique est très important pour l’obtention du diplôme.Outre pour ce diplôme, ce projet est un plus sur le CV pour notre avenir. L'équipe de projet estconstitué de Ragot Alexis et de Dominguez Jonathan. Nous avons choisi de faire l’applicationpermettant de gérer une bibliothèque personnelle. Nous avons choisi ce projet pour deux raisonsdifférentes mais complémentaires, la partie JEE que nous ne connaissions pas avant et la partie enJava que nous voulions approfondir.

Ce projet a été proposé par l'enseignante en JEE madame Violeta Felea, cours qui ont été effectuéslors du second semestre. Ce projet a pour but de proposer une application permettant la gestiond'une bibliothèque personnelle tout en offrant un accès informatique aux utilisateurs. C'est à partirde cela que nous avons élaboré un cahier des charges avec notre tutrice. La première nouveauté aété l'utilisation de la plateforme JEE avant que les cours nous soient dispensés. Puis nousprésenterons des API Open Source pour certaines fonctionnalités. Nous allons donc voir à travers cerapport dans une première partie une présentation du projet ainsi que ces principaux objectifs. Puisnous verrons quels ont été nos choix pour effectuer ce projet. Et finalement, le résultat de ce travail.


I . Outil de gestion d’une bibliothèque personnelle

1) Le besoin

L’organisation d’une bibliothèque personnelle s’avère facilitée par des outils informatiques. Il s’agitpremièrement de fournir un inventaire de tout ouvrage présent dans la bibliothèque, sous formed’un catalogue.

Semblable aux outils présents dans les bibliothèques publiques (municipales, universitaire),l’application de gestion d’une bibliothèque personnelle fournit aussi une aide organisationnelle (àune toute autre échelle comparée aux bibliothèques publiques, mais tout aussi utile) : positionner unouvrage dans une bibliothèque et être capable de le retrouver facilement.

Proposer des solutions d’organisation et les intégrer dans l’application constituent également desattentes du projet.

2) Fonctionnalités

L'application propose deux types d'accès différents, bibliothécaire et utilisateur, car l'applicationpropose des fonctionnalités supplémentaires à la bibliothécaire servant à gérer la bibliothèque.

En effet la bibliothécaire peut ajouter, modifier et supprimer un livre ainsi qu'une armoire (elle-même obligatoirement composée d'étagères). Chaque livre peut exister en plusieurs exemplaires etpeut posséder plusieurs volumes différents.

La bibliothécaire peut aussi effectuer une sauvegarde entière des données sous un format Excel etpeut charger un ensemble de livres à partir d'un fichier Excel.

L'application possède aussi une fonctionnalité permettant de ranger automatiquement labibliothèque avec des armoires et des étagères rentrées au préalable dans l'application. Par ailleurs,celles-ci sont sauvegardées au même titre que les livres. De plus la bibliothécaire peut visualiser etmodifier les structures sauvegardées.

L'application met à disposition la possibilité d'effectuer des recherches avec mot-clé en fonction descaractéristiques d’un livre (titre, auteur, catégorie) avec comme option de n'afficher que les livresavec de multiples exemplaires. Pour que les recherches soient facilement accessibles et utilisableselles peuvent être sauvegardé sous un format PDF.

L'application propose aussi une pagination dans la page de recherche afin que les résultats soitaffichable sur plusieurs pages pour une meilleur lisibilité.


II . Analyse

L’analyse du système a permis d’établir le diagramme d’entités ci-dessous. Les classes entités sont les classes dont il faudra assurer la persistance.

Analyse pour la gestion des livres

Afin de pouvoir répondre aux fonctionnalités demandées, nous choisissons de créer une entitéLivre. Cette entité comportera différents attributs tels que son auteur, son titre, son tome, sonnombre d’exemplaire, son origine, son année de parution, son prix ainsi qu’un objet de l’entitéCatégorie.

Par ailleurs, la séparation de la catégorie du livre permet de faciliter le développement car diversesfonctionnalités nécessiteront uniquement la catégorie et non le livre.

Analyse pour le rangement :

Le rangement automatique des livres n’est pas une tâche simple et nécessite une analyse.Le but de cette fonctionnalité est de pouvoir retrouver le livre physiquement dans une bibliothèque.Pour pouvoir réaliser cette fonctionnalité nous définissons des structures. Ces structures possèdentun nom ainsi qu’un ensemble d’armoires. De même que les structures, les armoires ont un nommais sont composées d’étagères.


Les étagères ont différents attributs, afin de représenter au mieux la réalité.Ces attributs sont :

- Un numéro représentant l’étagère au sein de l’armoire (1,2,3 ...)

- Le nombre de livres pouvant être mis l’un à côté de l’autre sur l’étagère(une marge en pourcentage est défini pour ce nombre afin d’avoir une flexibilité)

- Le nombre de livres pouvant être l’un derrière l’autre (profondeur)

- Le nombre de livres pouvant se superposer l’un par dessus l’autre (hauteur).

Lors du rangement, chaque livre aura comme position :

- Le nom de l’armoire dans laquelle il se trouve

- Le numéro de l’étagère

- Le numéro de la rangée en profondeur

- Le numéro de la rangée en hauteur

Chacune de ces informations sur la position sont séparées par le caractère "-" afin d’obtenir unevaleur lisible. (La méthode résultante de cette analyse est présente dans l'annexe)

Analyse de l’aspect visuel :

Une partie de l'analyse consistait à réaliser des croquis des interfaces utilisateurs.Les principales interfaces résultantes de cette analyse sont les suivantes :- La page d’accueil (qui nous informe sur le nombre total de livre physique dans la bibliothèque)

- La page de recherche avec l’affichage des livres (recherche selon l’auteur, le titre et la catégorie)

- La page d’ajout d’exemplaires pour un livre

- La page d’ajout d’un livre

- La page de suppression d’exemplaire ou de livre

- La page d’information sur la structure d’une armoire

- La page de visualisation des armoires en fonction de la structure choisi.

- La page de sauvegarde de l’ensemble des livre de la bibliothèque en fichier Excel

- La page de sauvegarde d’une recherche en fichier PDF

Ces pages sont visibles dans l’annexe.


III . Aspects conceptuels et technologiques

L’architecture et les principes de développement sont le cœur d’une application. Les respecter favorise une maintenance et une évolution simple de l’application. Ce chapitre aborde l’architecturede l’application, le modèle MVC, les design patterns ainsi que les différents logiciels et langages utilisés.

1) L’architecture n-tiers

L’architecture en n-tiers définit, que lors du l’utilisation de l’application celle-ci peut être déployée sur "n" postes différents. Plus il y a de tier, plus l’application est facilement réutilisable, maintenable et évolutive.

L’outil de gestion est demandé pour une bibliothèque personnelle ; par conséquent, nous avons décidé d’utiliser une architecture en 3-tiers qui sont :

Le tier Client correspondant à l'affichage, la restitution desinfos sur le poste de travail de l’utilisateur, le dialogue avecl'utilisateur

Le tier Métier correspondant à la mise en œuvre del'ensemble des règles de gestion et de la logique applicative

Le tier Physique correspondant aux données qui sontdestinées à être conservées sur la durée, voire de manièredéfinitive.


2) Le modèle MVC

Le modèle MVC ou Model – View – Controller, s’intègre à l’architecture en 3-tiers. Il va approfondir la relation entre les tiers Métier et Client.

Model représente le tier Métier.

View est matérialisé par des interfaces avec le client donc le tier Client.

Controller réalise le lien entre les tiers Métier et Client. Ilrécupère des informations provenant de l’interfaceutilisateur, il utilise le tier Métier pour des traitements etmodifie l’interface utilisateur.

Un avantage apporté par ce modèle est la clarté de l'architecture qu'il impose. Cela simplifie la tâchedu développeur qui tenterait d'effectuer une maintenance ou une amélioration sur le projet. En effet,la modification des traitements dans le modèle ne change en rien la vue. Par exemple on peut passerd'une base de données de type SQL à XML en changeant simplement les traitements d'interactionavec la base, et les vues ne s'en trouvent pas affectées.

3) Les design patternsUn design pattern est une solution donnée à un problème récurrent. Cela permet de résoudre des problèmes connus et fréquents par des méthodologies. Nous avons utilisé les designs patterns Factory et Singleton.

Le design pattern Factory permet d'instancier plusieurs classes différentes héritant d'une même classe Interface.

Le design pattern Singleton est utilisé pour limiter le nombre d'exemplaires d'un objet, ici une seule instanciation par implémentation.

Chacune de ces instanciations est unique grâce au design pattern Singleton. Les designs patterns Factory et Singleton sont utilisés avec les classes java "MetierFactory" ainsi que "Physique Factory".Exemple :


La Factory possède un objet du type de l'interface, ici StructureBibliothequeService, et un accesseurqui lui est associé. Dans cet accesseur on vérifie si l'objet est nul ; si c’est le cas on initialise cet objet avec le constructeur de l'implémentation (polymorphisme). Cela signifie aussi que l'objet est initialisé une seule fois, la première fois que la méthode est appelée (Design pattern Singleton).

Le mot clé "static" devant une méthode (ou variable) indique que celle-ci n'appartient pas à une instance particulière de la classe. Dans les classes factory, les methodes static permettent de récupérer les attributs, eux aussi statiques, sans instancier la classe. Cela permet de récupérer les instances des implémentations qui ne sont faite qu’une seule fois.

4) Logiciels et langages

L angages:

Java / JEE(JDK 7 et JRE 7)

SQL

HTML 5 (avec CSS 3)


Serveur d’application s :

Glassfish 4(uniquement pour sa partie serveur web)

Environnement de développement :

Netbeans 7.4

Système de gestion de base de données :

MySQL


IV . Développement de l’application de gestion d’une bibliothèque

1) Description technique du modèle MVC pour les application web avec Java

Pour le développement de l’application, divers choix technologiques ont été effectués tels que l’utilisation de la plateforme Java JEE.Ce langage peut s’adapter sur le modèle MVC, nous expliquerons comment ce langage et ce modèles’associent.

Tout d’abord, la communication entre la vue et le contrôleur.Avec la plateforme JEE, les vues seront les pages ".jsp" et les contrôleurs seront les "servlets".Nous prendrons comme exemple la page de connexion de notre application qui est « Connexion.jsp » La vue transmet les informations par le biais d’un formulaire simplifié comme ci-dessous.

Connexion.jsp

<form action="/BibliothequeJEE/Connexion" method="post"> <input type="text" name="login" placeholder="Login"/> <input type="password" name="mdp"/> <input type="submit" value="Connexion"/>

</form>

Quatre aspects sont importants, les noms des deux champs de saisie (login et mdp), la méthode du formulaire (post) ainsi que l’action de ce formulaire vers la servlet « Connexion.java ».Cette action fait référence à un lien défini dans le descripteur de déploiement « web.xml » qui est obligatoire à réaliser lors de la création de la servlet.

web.xml

<servlet> <servlet-name>Connexion</servlet-name> <servlet-class>controleur.Connexion</servlet-class>

</servlet>

<servlet-mapping> <servlet-name>Connexion</servlet-name> <url-pattern>/Connexion</url-pattern> </servlet-mapping>

Le premier paragraphe ci-dessus permet de définir un nom (avec la balise <servlet-name>) qui sera associé à une classe (avec la balise <servlet-class>). Cette association est réalisée dans l’élément "<servlet>".Une fois cette association effectuée, il faut définir un chemin d’accès. Pour cela, l’élément <servlet-mapping> permet, grâce au nom de servlet définie précédemment, de définir une URL d’accès (avec l’élément <url-pattern>).

Maintenant que le formulaire envoie les informations au contrôleur voulut, nous montrons comment"Connexion.jave" les récupère.


Le contrôleur est composé de la méthode doPost() que nous utilisons car elle correspond à la méthode de notre formulaire.

package controleur;public class Connexion extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

boolean connexion;

//Récupération des champs du formulaire String login = request.getParameter("login"); String mdp = request.getParameter("mdp");

// Traitement de l’information avec par le tier métier Controleur controleur = Metier.MetierFactory.getControleur() ; connexion = controleur.verificationConnexion(login, mdp); request.setAttribute("connexion", connexion); this.getServletContext().getRequestDispatcher("Connexion.jsp").forward( request, response ); }}

On peut apercevoir que la méthode doPost() dispose comme paramètre d’un objet"HttpServletRequest". Cet objet est important car il permet de récupérer les informations envoyéespar les formulaires avec "request.getParameter("login") ;" en indiquant le nom du champcorrespondant du formulaire afin de récupérer la valeur saisie.

Ensuite, le contrôleur appelle une méthode du tier Métier et récupérer un booléen.Ce booléen est enregistré comme attribut de requête grâce à"request.setAttribute("connexion", connexion);".Le premier paramètre sera le nom sous lequel le booléen est enregistré.

Pour finir, on appelle la JSP "Connexion.jsp" en lui donnant l’objet "HttpServletRequest".Elle pourra ainsi récupérer la valeur du booléen enregistré en utilisant la méthode "request.getAttribut("connexion"); " entre les balises permettant d’écrire du code Java (les scriptlet <% ,%>).

<% boolean connexion = Boolean.parseBoolean((String)request.getAttribute("connexion")); %>


2) Description technique du tier Métier

Dans ce tier se trouvent :- Les entités.- Les interfaces.- Les implémentations de celles-ci.- Une factory pour récupérer les instanciations des interfaces du tier Métier.- Une classe contrôleur où se font les calculs pour certaines méthodes.

Une modélisation de la factory et des interfaces est présente en annexe.

Voici une méthode de la classe contrôleur réalisant un tri dans une liste comportant des livres :

Cette méthode reçoit en paramètre une liste d'objet "Livre", un "int" représentant par quel attribut l'utilisateur veut-il trier la liste et un "int" précisant si la liste sera triée dans l'ordre croissant ou décroissant que l'on applique à un attribut de "Livre" qui sera expliqué plus tard. Pour ce faire l'objet Livre possède un objet de type "Comparator<Livre>" pour chaque attribut selon lequel on peut trier.Cette méthode est utilisée pour trier une recherche de livres selon différents critères.


Ici on vérifie si la valeur de l'attribut (titre) selon lequel on veut trier est égale dans les deux objets "Livre". En cas affirmatif on trie selon un autre attribut (auteur). Autrement, on trie avec l'attribut de départ. C’est dans cette méthode que s’applique le parametre "croissantOrNot" qui permet de définir un tri croissant ou décroissant. En effet la méthode "compareToIgnoreCase" renvoit un "int" indiquant la position du livre "arg0" par rapport à "arg1". Si l'utilisateur veut que ce soit croissant alors le "int" vaudra 1 et ne changera rien car à la base, le tri est croissant. Cependant si l'utilisateur veut un tri décroissant alors "croissantOrNot" vaudra -1 et cela inversera tout simplement les résultats.

3) Description technique du tier Physique

Dans ce tier se trouvent :- Les interfaces.- Les implémentations de celles-ci.- Une factory pour l'accès de la couche métier à physique (et uniquement en ce sens)- Une classe gérant la connexion avec la base de données où se font les actions pour certaines méthodes.

Une modélisation de la factory et des interfaces est présente en annexe.

Voici une méthode permettant l'ajout(« INSERT INTO ») d'un objet "Livre" dans la table « livre » grâce à une requête SQL. Cette requête est exécuté par un objet Statement récupéré grâce à une autre classe créée pour gérer la connexion avec la base de données.


4) Les API utilisées

Afin de pouvoir sauvegarder sous format PDF une recherche faite au préalable dans l’application etainsi faciliter la recherche d’un livre dans la bibliothèque, nous utilisons l'API iTextPDF. Cette APInous permet de générer un fichier PDF et d’y écrire.

Voici un exemple simple de création d’un fichier PDF contenant le texte « Hello World » :

Document document = new Document(PageSize.A4); try { PdfWriter.getInstance(document, new FileOutputStream("c:/test.pdf")); document.open(); document.add(new Paragraph("Hello World")); } catch (Exception e) { e.printStackTrace(); } document.close();

Pour qu'un(e) bibliothécaire puisse charger un ensemble de livre à partir d'un fichier Excel nousutilisons les API FileUpload et Apache POI. Cette dernière nous permet de lire mais aussi d'écrire un fichier Excel (.xls), ce qui est utilisé pourpouvoir effectuer une sauvegarde de la base de données sous format Excel (.xls). Ces fichierspossèdent un format bien particulier dans notre application qui est précisé lors de la possible mise àjour. Cette fonctionnalité impose le standard de fichier Excel (.xls). Le programme lit chaquefeuille, chaque ligne et chaque cellule du fichier Excel dans un ordre bien précis.

Voici un exemple simple de création d’un fichier Excel :

HSSFWorkbook wb = new HSSFWorkbook(); FileOutputStream fileOut; try { fileOut = new FileOutputStream("monfichier.xls"); wb.write(fileOut); fileOut.close(); } catch (Exception e) { e.printStackTrace();

}


L’API FileUpload nous permet de transférer facilement un fichier du client au serveur.Pour ce faire, il est nécessaire de créer un formulaire disposant d’un champ "input" de type "file" etde préciser dans la balise "form" un attribut "enctype" ayant pour valeur "multipart/form-data".Voici la récupération par la servlet :

List<FileItem> items = new ServletFileUpload(new DiskFileItemFactory()).parseRequest(request); for (FileItem item : items) { if (!item.isFormField()) { // Traiter les champs de type fichier (input type="file") String nomFichier = FilenameUtils.getName(item.getName()); if(nomFichier.endsWith(".xls")){ InputStream is = item.getInputStream(); Controleur controleur = Metier.MetierFactory.getControleur(); controleur.lireSauvegardeExcel(is); } } }

Pour notre projet, seul le flux du fichier a été récupéré et il n’a pas été sauvegardé sur le serveur.

Pour se connecter à la base de données MySql nous avons utilisé l'API JDBC. JDBC est un ensemble de classes permettant de développer des applications capables de se connecter à des serveurs de base de données.


Voici un exemple illustrant la connexion à une base de données et l’exécution d’une requête Sql :

Cette requête SQL permet d’extraire tous les livres sauvegardés dans la table "livre" de la base de données "bibliotheque".

5) Boostrap

Bootstrap est une collection d’outils utiles à la création de sites web et d’applications web. Il offre un ensemble de CSS et d’extensions JavaScript. Pour l’application il permet de rendre le site «responsive design» c’est-à-dire qu’il s’adaptera à n’importe quelle taille d’écran (PC, tablette, smartphone, etc...).


6) Paramétrage de l’application

Au lancement du serveur Glassfish, une servlet est appelée afin de récupérer des informations relatives au bon fonctionnement de l'application. Cette servlet reçoit les informations par le biais du descripteur de déploiement "web.xml" dans lequel il peut être défini pour chaque servlet une valeur associée à un nom.

<init-param> <param-name>pagination</param-name> <param-value>15</param-value> </init-param>

<init-param> <param-name>connectionProperties</param-name> <param-value>connectionConfig</param-value> </init-param>

Dans cet extrait, nous définissons une variable "pagination" ayant pour valeur "15". C'est ici qu'il est possible de modifier le nombre de livres affichables par page. De plus ce fichier xml nous renseigne sur une variable ayant pour valeur "connectionConfig", ceci est le chemin du fichier "connectionConfig.properties".L’intérêt de ce fichier de propriétés est qu'il est facilement modifiable et nécessite peu de temps pour pouvoir être modifié.Ce fichier est utile pour pouvoir modifier facilement tous les paramètres de connexion à la base de données.Voici un exemple pour enregistrer une valeur dans un fichier de propriétés :

nomBase=bibliotheque

On remarque qu'il suffit simplement de mettre un nom que l'on initialise avec une valeur.Afin de récupérer cette valeur, nous avons créé un objet "ResourceBundle" et récupérer la valeur à l'aide du nom de celle-ci dans le fichier de propriétés :

ResourceBundle rb = ResourceBundle.getBundle(url); String base = rb.getString("nomBase");

7) Le téléchargement de fichiers

Le download est utilisé pour la sauvegarde d’une recherche en PDF. Pour le réaliser, il faut préciser dans le constructeur de l’objet PdfWriter que l’on écrit dans le flux de sorti, qui sera transmis au client. Ensuite, une fois le flux créé, on écrit dans ce flux le contenu du fichier PDF.

PdfWriter pdfWriter = PdfWriter.getInstance(myPDF, response.getOutputStream()); myPDF.open(); Paragraph paragraph = controleur.imprimerRecherche(livres, critere); myPDF.add(paragraph); myPDF.close(); response.getOutputStream().close();


V . Gestion du projet

1) Diagramme de Gantt

Afin de mieux gérer l’organisation du travail nous avons établi dès le début du projet un diagramme de Gantt.

Ce premier diagramme nous a permis d’avoir une vision du rythme de travail mais il ne représente pas la réalité. Voici le diagramme de Gantt en temps réel au cours de l’évolution du projet.


2) Travail en binôme

Le travail en binôme au sein d’un même projet n’est pas toujours simple, c’est pourquoinous avons décidé d’utiliser un outil appelé Github. Cet outil fournit un service d’hébergementd’application web et de gestion de logiciels pour permettre à plusieurs personnes de travailler sur unprojet simultanément. De plus il est directement incorporé à l’environnement de développementNetBeans utilisé et permet ainsi une utilisation simple et rapide.

Pour ce projet, la répartition des tâches a été une chose simple car nos attentes étaient vraimentcomplémentaires. Globalement, Dominguez Jonathan a réalisé les tiers métier et physique tandisque Ragot Alexis a développé le tier Client avec l’application du modèle MVC.


Conclusion

Dans le cadre de notre projet nous avons réalisé une application web pour gérer une bibliothèque. Cette application permet de gérer les livres d'une bibliothèque de manière ergonomique tout en proposant des fonctionnalités de sauvegarde de la base de données, d'import de base de données et de rangement de bibliothèque. De plus, l'application offre la possibilité aux utilisateurs d'effectuer des recherches avec mot clé et critères multiples et d'en sauvegarder les résultats. Le tout sur un navigateur web pouvant s'adapter à n'importe quel support technologique (ordinateur, tablette, portable, …).

Cependant, des améliorations possibles existent. En effet, le système de rangement ne range pas de manière la plus optimale. Le rangement se fait par origine et catégorie mais ne prend pas en compte l'épaisseur des livres. Il est donc possible que des livres plus volumineux perturbent les positions affectées. De plus, la lecture de fichier Excel se limite au format .xls, une amélioration possible serait de rendre la lecture compatible avec le format .ods. Nous avons rencontré un problème avec les accents roumains et n'avons réussi à trouver une solution.

Ce projet nous a permis d’appliquer les connaissances qui nous ont été dispensées au cours de cette année de Licence Professionnelle à l'Université de Franche-Comté. Nous avons appris à utilisé des technologies que nous ne connaissions pas et que nous n'aurions jamais connus en cours. Nous avons été confrontés à de nombreux problèmes auxquels nous avons trouvé des solutions. Pour ce projet nous n'avons que peu de temps pour réaliser ce que nous souhaitions faire, cependant cela a été une bonne expérience et nous a beaucoup apportées.


ANNEXES

1) Règles de codage

Les règles de codage sont un ensemble de règles à suivre pour uniformiser les pratiques dedéveloppements logiciel, diffuser les bonnes pratiques de développement et éviter les erreurs dedéveloppement classiques au sein d’un groupe de développeurs.

Elles permettent d’assurer une meilleure lisibilité du code en utilisant le même style de codage et enévitant les constructions qui rendent le code difficile à lire ou à modifier.Les règles de codage participent à la qualité logicielle. Ainsi, plus l’importance des développementsest élevée, plus les besoins en règles de codages sont nécessaire.

CamelCase :

Le camelCase c’est la manière la plus utilisée pour le nommage en Java.CamelCase, cela signifie que chaque première lettre d’un mot (variable, methode etc...) prend unemajuscule, que tous les mots sont collés les uns aux autres et petite subtilité, le premier mot neprend pas de majuscule (sauf pour une classe). Pourquoi camelCase, parce que ça ressemble auxbosses d’un chameau.

Les classes :

Les classes sont nommées selon la méthode camelCase et comportent généralement un verbed’action. Exemple : Recherche, SauvegardeExcel, etc.

En plus de cela, il faut savoir que dans une classe on retrouve souvent des méthodes de type getteret setter (accesseur, modificateur), pour récupérer une variable de classe ou la modifier sans toucherdirectement à la variable. Les getters et setters se nomment généralement getNomDeLaVariable() etsetNomDeLVariable(Object nomDeLaVariable). Il existe également d’autres mot-clés fréquemmentutilisés comme add et remove (ajout, supprimer) pour ajouter et supprimer quelque chose :addSomething(Object something), removeAll(), etc.

Les variables :

Les variables commencent selon en camelCase par une lettre (a-z). Le nom d’une variable devraitêtre court et clair. Les variables à un caractère sont à éviter sauf pour un usage temporaire (i, j, k, l,m, n pour les entiers et c, d, e pour les caractères) .Exemples : nombreLivre, listeLivre, i, etc.


2) Glossaire

MVC : Model View Controller (Modèle Vue Contrôleur)

JSP : JavaServer Pages

UML : Unified Modeling Language

JEE : Java Enterprise Edition

IDE : Integrated Development Environment (Environnement de Développement Intégré)

API : Application Programming Interface

HTML : Hypertext Markup Language

PDF : Portable Document Format

CSS : Cascading Style Sheets

SQL : Structured Query Language

CDOOAM : Conception et Développement Orientés Objet d’Application Multi tiers


3) Interfaces utilisateurs

Voici quelques interfaces utilisateurs de l'application.

La page d'accueil

La page de recherche avec l'affichage du résultat d’une recherche


La page d'ajout d'exemplaires pour un livre

La page d'ajout d'un livre


La page d'information sur la structure d’une armoire

La page de supression d'exemplaire ou de livre


La page de visualisation d'une structure

La page de sauvegarde de la base de données en fichier Excel


La page de sauvegarde d'une recherche en fichier PDF.


4) Diagrammes UML métier et physique

Diagramme du tier physique

Diagramme du tier métier


5) Méthode de positionnement des livres


Netographie

Site communautaire :

http://fr.openclassrooms.com/ (Consulté Février 2014)

http://stackoverflow.com/ (Consulté Février 2014)

Site officiel :

http://docs.oracle.com/javase/7/docs/ (Consulté Février 2014)

Site API :

http://itextpdf.com/ (Consulté Février 2014)

http://commons.apache.org/proper/commons-fileupload/ (Consulté Février 2014)

http://poi.apache.org/ (Consulté Février 2014)

http://www.jmdoudoux.fr/accueil_java.htm (Consulté Février 2014)

Bibliographie

Goncalves, Antonio. Java EE6 et Glassfish 3. Pearson, 554.


http://fr.openclassrooms.com/

http://www.jmdoudoux.fr/accueil_java.htm

http://poi.apache.org/

http://commons.apache.org/proper/commons-fileupload/

http://itextpdf.com/

http://docs.oracle.com/javase/7/docs/

http://stackoverflow.com/

Résumé

Dans le cadre de notre projet de Licence Professionnelle CDOOAM de l'université de Franche-Comté, nous avons développé une application permettant de gérer une bibliothèque.

Cette application a été développée sur la plateforme JEE, elle permet de gérer le contenu physiqued'une bibliothèque.

Elle permet aussi à des utilisateurs, avec des accès limités à certaines fonctionnalités, de l'utiliser.L'application offre la possibilité de ranger automatiquement les livres enregistrés, par le calcul de laposition du livre dans la bibliothèque.

Le fait de développer une telle application se montre utile dans la gestion, parfois fastidieuse, d'unegrande bibliothèque personnelle.

Mots-clés : Bibliothèque, Java, JEE, n-tiers, Singleton, Factory, MVC, iText, Apache POI, FileUpload, Bootstrap

Summary

As part of our project of professional licence CDOOAM from the University of Franche-Comté, wehave developed an application to manage a library.

This application has been developed on the JEE platform, it can manage the physical contents of alibrary.

It also enables users with limited access to use some features. The application offers the possibilityto automatically store books recorded by the calculation of the position of the book in the library.

The fact of developing such application shows itself useful in management, sometimes tedious, of alarge personal library.

Keyword : Library, Java, JEE, n-tiers, Singleton, Factory, MVC, iText, Apache POI, FileUpload, Bootstrap

Documents

Outil de gestion d’une bibliothèque personnelle · Projet de licence professionnelle en conception et développement orientés objet d’applications multi tiers à l’université