Ce support s’adresse aux développeurs qui souhaitent découvrir les principaux outils de l’environnement de développement intégré Apache NetBeans utiles pour le développement, la maintenance et l’industrialisation d’applications avec le langage Java. Dans chaque chapitre, les notions théoriques essentielles sont expliquées puis mises en pratique grâce à des exemples détaillés et des exercices corrigés.

Les auteurs commencent par décrire la mise en fonctionnement d’Apache NetBeans et de l’environnement Java sur un poste de développement, avant de détailler les notions importantes de la programmation orientée objet grâce à la réalisation d’un programme. La prise en main de l’IDE est approfondie grâce à la présentation de fonctionnalités facilitant et accélérant les développements.

Dans la suite du support, le lecteur aborde des connaissances plus poussées lui permettant de développer des applications plus riches. Un cas concret d’utilisation propose une comparaison de deux librairies graphiques, Swing et JavaFX. La notion d’industrialisation d’une application est illustrée avec la présentation en profondeur d’outils comme Git, Maven ou SonarQube, très fréquemment rencontrés dans le milieu professionnel et nécessaires à la mise en place d’une maintenance efficace et pérenne des applications développées avec Java. Un exercice corrigé permet au lecteur de découvrir la technique de développement TDD (Test Driven Development) utilisée pour réaliser des logiciels de qualité.

La conception et l’exploitation de services sont décrites avec le développement de services web de type SOAP et REST, qu’ils soient automatiquement générés grâce aux outils d’Apache NetBeans ou entièrement développés grâce au framework Spring.

Les principaux patrons de conception, Model-View-Controller et Model- View-Presentation, sont également étudiés puis mis en pratique grâce aux outils proposés par Apache NetBeans et aux librairies JSP et JSF utilisées dans le cadre de développement d’applications Java EE.

Pour aller plus loin, les auteurs familiarisent également le lecteur avec le profilage d’applications Java pour mettre en place une analyse en profondeur des performances d’une application Java.

Téléchargements

• Des fichiers complémentaires (309 Ko)

Installation et configuration initiale

1. 1. Introduction
2. 2. Installation du kit de développement Java
   1. 2.1 Avant de commencer : note sur la plateforme Java
      1. 2.1.1 Les éléments de la plateforme : JVM, JRE, JDK
      2. 2.1.2 Focus sur la JVM
      3. 2.1.3 Un environnement pour chaque utilisation
   2. 2.2 Quel JDK sélectionner ?
   3. 2.3 Quelle version sélectionner ?
3. 3. Installation de NetBeans
4. 4. Configuration initiale

Créer son premier projet avec NetBeans

1. 1. Introduction
2. 2. Les types de projets Java
3. 3. Création d'un projet Java simple avec Maven
4. 4. Notions de programmation orientée objet
   1. 4.1 Définition d'une classe
   2. 4.2 Modélisations, classes, types et exécution en Java
      1. 4.2.1 Les classes métier
      2. 4.2.2 Les points d'entrée d'exécution du programme
   3. 4.3 Notion de package
      1. 4.3.1 Définition
      2. 4.3.2 Règle de nommage
5. 5. Présentation de l'interface de NetBeans
6. 6. Création d'une classe Java avec NetBeans
   1. 6.1 Création d'une classe
   2. 6.2 Création d'un attribut
   3. 6.3 Création d'un accesseur et d'un mutateur
   4. 6.4 Création d'une méthode
7. 7. Définition d’un point d’entrée pour l’exécution de son programme
8. 8. Compilation d'un projet
   1. 8.1 Définition du compilateur
   2. 8.2 Compilation d'un projet avec NetBeans
9. 9. Exécution d'un projet
   1. 9.1 Sélectionner le point d’entrée du programme
   2. 9.2 Construire son projet avec NetBeans
10. 10. Documentation d'une application
    1. 10.1 Tags Javadoc
    2. 10.2 Analyse de la Javadoc
    3. 10.3 Exécution de la Javadoc
11. 11. Exercice corrigé : Calcul géométrique

Les outils du développeur

1. 1. Introduction
2. 2. Débogage d'une application grâce à NetBeans
   1. 2.1 Découvrir le mode debug
   2. 2.2 Apprendre les notions importantes
      1. 2.2.1 Les déplacements pas à pas
      2. 2.2.2 Les points d'arrêts
      3. 2.2.3 Les observateurs
   3. 2.3 Déboguer un programme
3. 3. Capacités de génération de code
   1. 3.1 Les attributs
   2. 3.2 Les constructeurs
   3. 3.3 Les méthodes equals() et hashCode()
   4. 3.4 La méthode toString()
   5. 3.5 Les méthodes comportementales
   6. 3.6 La méthode clone()
      1. 3.6.1 Le clonage en surface
      2. 3.6.2 Le clonage en profondeur
4. 4. Refactoring avec NetBeans
   1. 4.1 L'introduction de variables
   2. 4.2 L'introduction de constantes
   3. 4.3 L'introduction d'attributs
   4. 4.4 L'introduction de méthodes
   5. 4.5 L'introduction de paramètres
5. 5. Internationalisation d'un projet
6. 6. Diagrammes de classes UML avec NetBeans
   1. 6.1 Installation du plugin easyUML
   2. 6.2 Génération d'un diagramme de classes
7. 7. Groupement de projets

Le développement d'applications riches

1. 1. Introduction
2. 2. Objectif des applications riches
3. 3. Programmation graphique : composants et évènements
4. 4. Bonnes pratiques pour la programmation au sein des frameworks graphiques
   1. 4.1 Séparation de la couche métier et de la couche de présentation
   2. 4.2 Intrication du code métier et du code de présentation
   3. 4.3 Débordement de la couche métier dans la couche graphique
5. 5. Cas concret d'utilisation d'une librairie graphique et implémentation avec NetBeans
6. 6. Implémentation d'un exemple avec Swing
   1. 6.1 Maquettage avec Swing
      1. 6.1.1 Création d'un projet Java pour démarrer avec Swing
      2. 6.1.2 Fonctionnement global de Swing et intégration dans NetBeans
      3. 6.1.3 Édition des propriétés, génération d'évènements
      4. 6.1.4 Utilisation de l'historique
   2. 6.2 Composants et programmation des interactions
      1. 6.2.1 Manipulation du JTable
      2. 6.2.2 Manipulation du JFileChooser
      3. 6.2.3 Mise en place d'un thème
7. 7. Implémentation d'un exemple avec JavaFX
   1. 7.1 Différence d'approche entre Swing et JavaFX
   2. 7.2 Maquettage avec JavaFX
      1. 7.2.1 Création d'un projet JavaFX
      2. 7.2.2 Configuration de Scene Builder dans NetBeans
      3. 7.2.3 Première exécution
      4. 7.2.4 Fonctionnement global de JavaFX
      5. 7.2.5 Prise en main de SceneBuilder
      6. 7.2.6 Création d'un panneau (Scene)
      7. 7.2.7 Programmation des interactions avec l'utilisateur
   3. 7.3 Composants et programmation des interactions
      1. 7.3.1 Manipulation du TableView
      2. 7.3.2 Manipulation du FileChooser
8. 8. Swing ou JavaFX ?

Vers l’industrialisation du logiciel

1. 1. Introduction
2. 2. Travail en équipe : intégration avec Git
   1. 2.1 Fonctionnement de Git
      1. 2.1.1 Git, un système distribué
      2. 2.1.2 L'aspect concurrent de Git
   2. 2.2 Git : branches et tags
   3. 2.3 Partage et modification d'un projet avec Git et NetBeans
      1. 2.3.1 Intégration initiale
      2. 2.3.2 Réalisation et intégration (locale et distante) de modifications
      3. 2.3.3 Intégration de la modification sur le repository local
      4. 2.3.4 Intégration de la modification dans un repository distant
   4. 2.4 Suivi des modifications
      1. 2.4.1 Intégration dans l'éditeur de code
      2. 2.4.2 Affichage de l’historique d’un fichier
      3. 2.4.3 Gestion des conflits
3. 3. Construction du projet : utilisation de Maven dans NetBeans
   1. 3.1 Fonctionnement de Maven
      1. 3.1.1 Maven : la convention comme philosophie
      2. 3.1.2 Structuration du projet
      3. 3.1.3 Gestion des dépendances
      4. 3.1.4 Système de coordonnées
      5. 3.1.5 Référentiels (repository) d'artefacts
      6. 3.1.6 Nature d'une dépendance : packaging et classifier
   2. 3.2 Configuration de la construction du projet
      1. 3.2.1 Flux de construction d'un projet Maven
      2. 3.2.2 Instructions de construction grâce aux plugins
      3. 3.2.3 Exemple : mise en œuvre avec la construction de la Javadoc
      4. 3.2.4 Configuration des plugins Maven
   3. 3.3 Déclenchement de constructions depuis NetBeans
      1. 3.3.1 Première construction
      2. 3.3.2 Historiques et enregistrement des paramètres de construction dans NetBeans
   4. 3.4 Ajout de dépendances
      1. 3.4.1 Ajout assisté dans le pom.xml
      2. 3.4.2 Visualisation de l'arbre des dépendances
      3. 3.4.3 Conflits et exclusion de dépendance
   5. 3.5 Réutilisation de projets : héritage et composition
      1. 3.5.1 Définition d'un projet parent
      2. 3.5.2 Déclaration du parent dans les projets fils
      3. 3.5.3 Effet de la déclaration d'un parent sur le projet
      4. 3.5.4 Limites de l'héritage
      5. 3.5.5 Composition grâce au BOM
   6. 3.6 Construction groupée de projet : projets multimodules
      1. 3.6.1 Conception d'un projet multimodule
      2. 3.6.2 Distinction entre le réacteur et le parent
4. 4. Exécution des tests unitaires dans NetBeans
   1. 4.1 Méthodologie de définition du test unitaire
      1. 4.1.1 Approche systématique : hypothèse, action, vérification
      2. 4.1.2 Principe d'indépendance et de transparence des tests
      3. 4.1.3 Méthodologie de développement intégrant les tests : BDD et TDD
      4. 4.1.4 Exemple de formalisation du test BDD
      5. 4.1.5 Différence entre une erreur (error) et un échec (failure)
   2. 4.2 Définition d'un test unitaire avec JUnit
      1. 4.2.1 Écriture d'un premier test
      2. 4.2.2 Exécution des actions systématiques grâce aux annotations
      3. 4.2.3 Assertions
      4. 4.2.4 Interprétation du résultat des tests
      5. 4.2.5 Génération des tests unitaires par NetBeans
5. 5. Analyse de la qualité de code intégrée à l’outil
   1. 5.1 Utilisation de l'analyseur de code intégré de NetBeans
      1. 5.1.1 Analyse globale
      2. 5.1.2 Analyse sur critère unique
      3. 5.1.3 Analyse en vue d'une migration
   2. 5.2 Couverture des tests
      1. 5.2.1 Couverture en lignes et couverture en branches
      2. 5.2.2 Configuration et analyse de la couverture de test dans NetBeans
      3. 5.2.3 Comparaison avec la couverture de test de JaCoCo - Java Code Coverage
   3. 5.3 Intégration de SonarQube
      1. 5.3.1 Introduction à SonarQube
      2. 5.3.2 Installation d'un serveur SonarQube local
      3. 5.3.3 Les sept axes de la qualité selon SonarQube
      4. 5.3.4 Installation de SonarLint4Netbeans
      5. 5.3.5 Analyse d'un projet grâce au plugin Maven sonar
6. 6. Exercice corrigé : Conception d'un service de lecture de fichiers CSV en approche TDD
   1. 6.1 Spécifications de l'exercice
      1. 6.1.1 Préparation du projet
      2. 6.1.2 Modélisation des données
      3. 6.1.3 Désérialisation grâce à la classe CSVReader
   2. 6.2 Solution de l'exercice
      1. 6.2.1 Préparation du projet
      2. 6.2.2 Modélisation des données
      3. 6.2.3 Désérialisation grâce à la classe de service CSVReader
      4. 6.2.4 Recherche d'amélioration

La conception et l'exploitation de services

1. 1. Introduction
2. 2. Créer une base de données
   1. 2.1 Créer une base de données H2
   2. 2.2 Initialiser la base de données H2
3. 3. Développer des services REST pour exposer des APIs
   1. 3.1 Notion d'API
   2. 3.2 Principe KISS
   3. 3.3 Veiller à l’aspect Stateless de l’API
   4. 3.4 Verbes de la grammaire REST
   5. 3.5 Installation d'un serveur d'applications WildFly
   6. 3.6 Création d'un projet d'application Web
   7. 3.7 Génération d'entités et services REST
      1. 3.7.1 À propos des entités et de JPA
      2. 3.7.2 Manipulation
      3. 3.7.3 Bonnes pratiques de conception
   8. 3.8 Configuration et test de services REST
4. 4. Développer des services SOAP
   1. 4.1 Créer un projet Spring Boot
   2. 4.2 Générer les entités Java
   3. 4.3 Créer des objets de transfert de données
   4. 4.4 Développer des services Soap
   5. 4.5 Définir l'adresse d'un service web
   6. 4.6 Exécuter un projet
   7. 4.7 Tester des services Soap
5. 5. Exercice corrigé : développer une API REST avec Spring
   1. 5.1 Créer un projet Spring Boot
   2. 5.2 Créer l'entité Etudiant
   3. 5.3 Créer la classe EtudiantDAO
   4. 5.4 Créer la classe EtudiantController
   5. 5.5 Tester l'API REST

NetBeans, Java et le Web

1. 1. Introduction
2. 2. Présentation de l'architecture Java EE
   1. 2.1 Le pattern Modèle - Vue - Contrôleur
      1. 2.1.1 Composants de base du Web en Java
      2. 2.1.2 MVC, MVC 2 et les frameworks Java
   2. 2.2 Le pattern MVP
3. 3. Création d'une interface web avec JSF
   1. 3.1 Créer une application web
   2. 3.2 Générer les entités Java
   3. 3.3 Générer les pages JSF
   4. 3.4 Tester l'interface web
   5. 3.5 Manipuler la palette JSF de NetBeans
4. 4. Création d'une interface JSP
   1. 4.1 Créer une première page JSP
   2. 4.2 Développer une application en JSP
      1. 4.2.1 Les balises
      2. 4.2.2 Les directives
      3. 4.2.3 Le développement d’une page JSP
      4. 4.2.4 Le développement d’une servlet
      5. 4.2.5 Le développement du JavaScript
5. 5. Exercice corrigé : développement d’une application web JSF
   1. 5.1 Créer une application Web
   2. 5.2 Créer l'entité Etudiant
   3. 5.3 Créer la classe EtudiantDAO
   4. 5.4 Créer la classe EtudiantPresenter
   5. 5.5 Créer les pages JSF
   6. 5.6 Tester l'application JSF
   7. 5.7 Aller plus loin

Le profilage d'applications Java

1. 1. Introduction
2. 2. Avant de commencer : les grands principes de fonctionnement de la JVM
   1. 2.1 Gestion automatique de la mémoire
      1. 2.1.1 Les grandes zones mémoire de la JVM
      2. 2.1.2 Les mécanismes de recyclage : garbage collector
   2. 2.2 Aspect multithread
3. 3. Premier profilage d'une application avec NetBeans
   1. 3.1 Déclenchement et configuration du premier profilage
      1. 3.1.1 Lancement et calibration
      2. 3.1.2 Choix des métriques
      3. 3.1.3 Télémétrie globale de l'application
   2. 3.2 Techniques de relevés pour le profilage
      1. 3.2.1 Le sampling
      2. 3.2.2 L'observation continue
4. 4. Analyses possibles relatives à la mémoire
   1. 4.1 Analyse globale de la mémoire
      1. 4.1.1 Observation et interprétation du comportement de la mémoire
      2. 4.1.2 Observation de la mémoire dans un cas de mauvaise conception
   2. 4.2 Analyse des instances en cours d'exécution
      1. 4.2.1 Observation des instances en mode sampling
      2. 4.2.2 Observation continue des instances en cours d'exécution
      3. 4.2.3 Avantages et limites de l'observation de la mémoire en cours d'exécution
   3. 4.3 Analyses de la mémoire à froid
      1. 4.3.1 Réalisation d'un dump et découverte du HeapWalker
      2. 4.3.2 Comparaison de dumps
      3. 4.3.3 Console OQL
5. 5. Analyses possibles relatives à l'utilisation du processeur
6. 6. Autres possibilités du profileur de NetBeans
8. Index