Ce livre 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 livre, 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.



Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (320 Ko)

Avant-propos

1. Introduction

Installation et configuration initiale

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

Créer son premier projet avec NetBeans

1. Introduction
2. Les types de projets Java
3. Création d'un projet Java simple avec Maven
4. Notions de programmation orientée objet
   1. 1. Définition d’une classe
   2. 2. Modélisations, classes, types et exécutionen Java
      1. a. Les classes métier
      2. b. Les points d’entrée d’exécutiondu programme
   3. 3. Notion de package
      1. a. Définition
      2. b. Règle de nommage
5. Présentation de l'interface de NetBeans
6. Création d'une classe Java avec NetBeans
   1. 1. Création d’une classe
   2. 2. Création d’un attribut
   3. 3. Création d’un accesseur et d’un mutateur
   4. 4. Création d’une méthode
7. Définition d’un point d’entrée pour l’exécution de son programme
8. Compilation d'un projet
   1. 1. Définition du compilateur
   2. 2. Compilation d’un projet avec NetBeans
9. Exécution d'un projet
   1. 1. Sélectionner le point d’entréedu programme
   2. 2. Construire son projet avec NetBeans
10. Documentation d'une application
    1. 1. Tags Javadoc
    2. 2. Analyse de la Javadoc
    3. 3. Exécution de la Javadoc
11. Exercice corrigé : Calcul géométrique

Les outils du développeur

1. Introduction
2. Débogage d'une application grâce à NetBeans
   1. 1. Découvrir le mode debug
   2. 2. Apprendre les notions importantes
      1. a. Les déplacements pas à pas
      2. b. Les points d’arrêts
      3. c. Les observateurs
   3. 3. Déboguer un programme
3. Capacités de génération de code
   1. 1. Les attributs
   2. 2. Les constructeurs
   3. 3. Les méthodes equals() et hashCode()
   4. 4. La méthode toString()
   5. 5. Les méthodes comportementales
   6. 6. La méthode clone()
      1. a. Le clonage en surface
      2. b. Le clonage en profondeur
4. Refactoring avec NetBeans
   1. 1. L’introduction de variables
   2. 2. L’introduction de constantes
   3. 3. L’introduction d’attributs
   4. 4. L’introduction de méthodes
   5. 5. L’introduction de paramètres
5. Internationalisation d'un projet
6. Diagrammes de classes UML avec NetBeans
   1. 1. Installation du plugin easyUML
   2. 2. Génération d’un diagramme de classes
7. Groupement de projets

Le développement d'applications riches

1. Introduction
2. Objectif des applications riches
3. Programmation graphique :  composants et évènements
4. Bonnes pratiques pour la programmation  au sein des frameworks graphiques
   1. 1. Séparation de la couche métier etde la couche de présentation
   2. 2. Intrication du code métier et du code deprésentation
   3. 3. Débordement de la couche métier  dansla couche graphique
5. Cas concret d'utilisation d'une librairie graphique et implémentation avec NetBeans
6. Implémentation d'un exemple avec Swing
   1. 1. Maquettage avec Swing
      1. a. Création d’un projet Java pour démarreravec Swing
      2. b. Fonctionnement global de Swing et intégrationdans NetBeans
      3. c. Édition des propriétés,génération d’évènements
      4. d. Utilisation de l’historique
   2. 2. Composants et programmation des interactions
      1. a. Manipulation du JTable
      2. b. Manipulation du JFileChooser
      3. c. Mise en place d’un thème
7. Implémentation d'un exemple avec JavaFX
   1. 1. Différence d’approche entre Swing et JavaFX
   2. 2. Maquettage avec JavaFX
      1. a. Création d’un projet JavaFX
      2. b. Configuration de Scene Builder dans NetBeans
      3. c. Première exécution
      4. d. Fonctionnement global de JavaFX
      5. e. Prise en main de SceneBuilder
      6. f. Création d’un panneau (Scene)
      7. g. Programmation des interactions avec l’utilisateur
   3. 3. Composants et programmation des interactions
      1. a. Manipulation du TableView
      2. b. Manipulation du FileChooser
8. Swing ou JavaFX ?

Vers l’industrialisation du logiciel

1. Introduction
2. Travail en équipe : intégration avec Git
   1. 1. Fonctionnement de Git
      1. a. Git, un système distribué
      2. b. L’aspect concurrent de Git
   2. 2. Git : branches et tags
   3. 3. Partage et modification d’un projet avec Git et NetBeans
      1. a. Intégration initiale
      2. b. Réalisation et intégration (localeet distante) de modifications
      3. c. Intégration de la modification sur le repositorylocal
      4. d. Intégration de la modification dans un repositorydistant
   4. 4. Suivi des modifications
      1. a. Intégration dans l’éditeur de code
      2. b. Affichage de l’historique d’un fichier
      3. c. Gestion des conflits
3. Construction du projet : utilisation de Maven dans NetBeans
   1. 1. Fonctionnement de Maven
      1. a. Maven : la convention comme philosophie
      2. b. Structuration du projet
      3. c. Gestion des dépendances
      4. d. Système de coordonnées
      5. e. Référentiels (repository) d’artefacts
      6. f. Nature d’une dépendance : packaging et classifier
   2. 2. Configuration de la construction du projet
      1. a. Flux de construction d’un projet Maven
      2. b. Instructions de construction grâce aux plugins
      3. c. Exemple : mise en œuvre avec laconstruction de la Javadoc
      4. d. Configuration des plugins Maven
   3. 3. Déclenchement de constructions depuis NetBeans
      1. a. Première construction
      2. b. Historiques et enregistrement des paramètresde construction dans NetBeans
   4. 4. Ajout de dépendances
      1. a. Ajout assisté dans le pom.xml
      2. b. Visualisation de l’arbre des dépendances
      3. c. Conflits et exclusion de dépendance
   5. 5. Réutilisation de projets : héritageet composition
      1. a. Définition d’un projet parent
      2. b. Déclaration du parent dans les projets fils
      3. c. Effet de la déclaration d’un parent sur leprojet
      4. d. Limites de l’héritage
      5. e. Composition grâce au BOM
   6. 6. Construction groupée de projet : projetsmultimodules
      1. a. Conception d’un projet multimodule
      2. b. Distinction entre le réacteur et le parent
4. Exécution des tests unitaires dans NetBeans
   1. 1. Méthodologie de définition du testunitaire
      1. a. Approche systématique : hypothèse,action, vérification
      2. b. Principe d’indépendance et de transparencedes tests
      3. c. Méthodologie de développement intégrantles tests : BDD et TDD
      4. d. Exemple de formalisation du test BDD
      5. e. Différence entre une erreur (error) et un échec(failure)
   2. 2. Définition d’un test unitaire avec JUnit
      1. a. Écriture d’un premier test
      2. b. Exécution des actions systématiquesgrâce aux annotations
      3. c. Assertions
      4. d. Interprétation du résultat des tests
      5. e. Génération des tests unitaires parNetBeans
5. Analyse de la qualité de code intégrée à l’outil
   1. 1. Utilisation de l’analyseur de code intégré deNetBeans
      1. a. Analyse globale
      2. b. Analyse sur critère unique
      3. c. Analyse en vue d’une migration
   2. 2. Couverture des tests
      1. a. Couverture en lignes et couverture en branches
      2. b. Configuration et analyse de la couverture de testdans NetBeans
      3. c. Comparaison avec la couverture de test de JaCoCo -Java Code Coverage
   3. 3. Intégration de SonarQube
      1. a. Introduction à SonarQube
      2. b. Installation d’un serveur SonarQube local
      3. c. Les sept axes de la qualité selon SonarQube
      4. d. Installation de SonarLint4Netbeans
      5. e. Analyse d’un projet grâce au plugin Mavensonar
6. Exercice corrigé : Conception d'un service de lecture de fichiers CSV en approche TDD
   1. 1. Spécifications de l’exercice
      1. a. Préparation du projet
      2. b. Modélisation des données
      3. c. Désérialisation grâce à laclasse CSVReader
   2. 2. Solution de l’exercice
      1. a. Préparation du projet
      2. b. Modélisation des données
      3. c. Désérialisation grâce à laclasse de service CSVReader
      4. d. Recherche d’amélioration

La conception et l'exploitation de services

1. Introduction
2. Créer une base de données
   1. 1. Créer une base de données H2
   2. 2. Initialiser la base de données H2
3. Développer des services REST pour exposer des APIs
   1. 1. Notion d’API
   2. 2. Principe KISS
   3. 3. Veiller à l’aspect Stateless del’API
   4. 4. Verbes de la grammaire REST
   5. 5. Installation d’un serveur d’applications WildFly
   6. 6. Création d’un projet d’application Web
   7. 7. Génération d’entités etservices REST
      1. a. À propos des entités et de JPA
      2. b. Manipulation
      3. c. Bonnes pratiques de conception
   8. 8. Configuration et test de services REST
4. Développer des services SOAP
   1. 1. Créer un projet Spring Boot
   2. 2. Générer les entités Java
   3. 3. Créer des objets de transfert de données
   4. 4. Développer des services Soap
   5. 5. Définir l’adresse d’un service web
   6. 6. Exécuter un projet
   7. 7. Tester des services Soap
5. Exercice corrigé : développer une API REST avec Spring
   1. 1. Créer un projet Spring Boot
   2. 2. Créer l’entité Etudiant
   3. 3. Créer la classe EtudiantDAO
   4. 4. Créer la classe EtudiantController
   5. 5. Tester l’API REST

NetBeans, Java et le Web

1. Introduction
2. Présentation de l'architecture Java EE
   1. 1. Le pattern Modèle - Vue - Contrôleur
      1. a. Composants de base du Web en Java
      2. b. MVC, MVC 2 et les frameworks Java
   2. 2. Le pattern MVP
3. Création d'une interface web avec JSF
   1. 1. Créer une application web
   2. 2. Générer les entités Java
   3. 3. Générer les pages JSF
   4. 4. Tester l’interface web
   5. 5. Manipuler la palette JSF de NetBeans
4. Création d'une interface JSP
   1. 1. Créer une première page JSP
   2. 2. Développer une application en JSP
      1. a. Les balises
      2. b. Les directives
      3. c. Le développement d’une page JSP
      4. d. Le développement d’une servlet
      5. e. Le développement du JavaScript
5. Exercice corrigé : développement d’une application web JSF
   1. 1. Créer une application Web
   2. 2. Créer l’entité Etudiant
   3. 3. Créer la classe EtudiantDAO
   4. 4. Créer la classe EtudiantPresenter
   5. 5. Créer les pages JSF
   6. 6. Tester l’application JSF
   7. 7. Aller plus loin

Le profilage d'applications Java

1. Introduction
2. Avant de commencer : les grands principes de  fonctionnement de la JVM
   1. 1. Gestion automatique de la mémoire
      1. a. Les grandes zones mémoire de la JVM
      2. b. Les mécanismes de recyclage : garbage collector
   2. 2. Aspect multithread
3. Premier profilage d'une application avec NetBeans
   1. 1. Déclenchement et configuration du premierprofilage
      1. a. Lancement et calibration
      2. b. Choix des métriques
      3. c. Télémétrie globale de l’application
   2. 2. Techniques de relevés pour le profilage
      1. a. Le sampling
      2. b. L’observation continue
4. Analyses possibles relatives à la mémoire
   1. 1. Analyse globale de la mémoire
      1. a. Observation et interprétation du comportementde la mémoire
      2. b. Observation de la mémoire dans un cas demauvaise conception
   2. 2. Analyse des instances en cours d’exécution
      1. a. Observation des instances en mode sampling
      2. b. Observation continue des instances en cours d’exécution
      3. c. Avantages et limites de l’observation de la mémoireen cours d’exécution
   3. 3. Analyses de la mémoire à froid
      1. a. Réalisation d’un dump et découvertedu HeapWalker
      2. b. Comparaison de dumps
      3. c. Console OQL
5. Analyses possibles relatives à l'utilisation du processeur
6. Autres possibilités du profileur de NetBeans