1. Supports de cours
  2. Java Spring - Le socle technique des applications Java EE (2e édition)

Java Spring Le socle technique des applications Java EE (2e édition)

  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne
  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

Ce livre apporte les éléments clés pour se repérer dans les différentes technologies utilisées dans les projets basés sur Spring. Il prend en compte les différences de configuration liées aux versions de Spring (en version 4.5 et 5.0 au moment de l'écriture) et se base sur des exemples concrets d'utilisation. Il permet au lecteur d'être très rapidement autonome sur un projet d'entreprise qui utilise Spring, que ce soit au début d'un nouveau projet ou pour maintenir un projet existant : compréhension du noyau, accès aux données, maîtrise de la couche web. Des connaissances sur le développement Java et notamment le développement d'applications web sont un prérequis indispensable pour tirer le meilleur parti possible du livre.

L'auteur présente tout d'abord les éléments simples et courants de Spring (la configuration, les contextes, les librairies tiers) et explique ensuite certains aspects plus complexes que l'on rencontre souvent dans les projets (Ressources, Bindeurs, Validateurs, Convertisseurs et Tests). La programmation par aspects est expérimentée, les applications web Spring MVC et les Web Services sont détaillés avec les tests unitaires associés. L'auteur présente les nouveautés Spring Boot, Kotlin avec Angular, les applications orientées messages et Spring Batch et termine par une description de la partie Spring d'un projet généré à partir de JHipster afin d'illustrer une mise en œuvre très actuelle.

Tout au long des chapitres, l'auteur s'appuie sur des exemples fonctionnels afin de permettre l'expérimentation au plus tôt par le lecteur. Dans ce but, des éléments sont en téléchargement sur le site www.editions-eni.fr.


Les chapitres du livre :
Avant-propos – Éléments constitutifs du framework – Spring et les design patterns – Rappels sur les éléments externes à Spring – Le conteneur Spring – Configuration avancée – Programmation Orientée Aspect avec Spring – Les tests et Spring – Partie back de l'application – Spring dans un contexte web JSP – Intégration JSF2 – Application Spring Angular 5 – Spring-HATEOAS – Documentation Rest Doc – Spring Boot – Spring et le NoSQL – Spring Batch – Les intergiciels à messages (MOM) – Spring et Kotlin – Spring et JHispster



Quizinclus dans
la version en ligne !
  • Testez vos connaissances à l'issue de chaque chapitre
  • Validez vos acquis

Table des matières

  • Avant-propos
    • 1. Préambule
    • 2. Introduction
    • 3. Organisation du livre
    • 4. Public visé
    • 5. Pourquoi Spring
    • 6. Prérequis pour aborder Spring et Java EE
    • 7. Objectifs du livre
  • Éléments constitutifs du framework
    • 1. Introduction
    • 2. Historique
    • 3. Utilité de Spring dans un projet
    • 4. Vue d'ensemble et sujets abordés dans l'ouvrage
      • 4.1 Les modules Spring
      • 4.2 Sujets abordés
      • 4.3 Version des briques Spring utilisées dans l'ouvrage
      • 4.4 Version des ressources externes
      • 4.5 Gestion des dépendances Maven
      • 4.6 Utilisation d'un BOM (Bill Of Materials) Maven
    • 5. Points clés
  • Spring et les design patterns
    • 1. Introduction
    • 2. Le singleton en Java
      • 2.1 Préoccupation
      • 2.2 Solution Spring
      • 2.3 Exemple
    • 3. L'inversion de contrôle
    • 4. Façade
    • 5. Fabrique
    • 6. Active record
    • 7. Proxy
    • 8. Modèle Vue Contrôleur (MVC)
    • 9. Le contrôleur de partie frontale (Front Controller)
    • 10. Les assistants de vue (View Helper)
    • 11. Les templates
    • 12. Stratégie
    • 13. Points clés
  • Rappels sur les éléments externes à Spring
    • 1. Codage equals et hashCode
      • 1.1 Description de la problématique
      • 1.2 Mise en œuvre
    • 2. Projet Lombok
    • 3. Les systèmes de log
    • 4. Bases de données H2
      • 4.1 Description de la problématique
      • 4.2 Mise en œuvre
        • 4.2.1 Installation
        • 4.2.2 Configuration du POM
        • 4.2.3 Connexion à la base de données en utilisant JDBC
        • 4.2.4 Utiliser un listener de servlet pour démarrer et arrêter la base
    • 5. Projets Maven
      • 5.1 Description de la problématique
      • 5.2 Mise en œuvre
      • 5.3 Installation de Maven sous Windows
      • 5.4 Utilisation d'un archétype Maven
      • 5.5 Contenu du fichier pom.xml dans les cas simples utilisés dans ce livre
    • 6. Rappels Java 8 et 9
      • 6.1 Nouveauté Java 8+
      • 6.2 Le langage de programmation
      • 6.3 Collections
      • 6.4 Sécurité
      • 6.5 Les dates
      • 6.6 Concurrency
      • 6.7 Optional
      • 6.8 Parallel arrays
      • 6.9 Date et Time
      • 6.10 Lambda
      • 6.11 L’API Stream
    • 7. Points clés
  • Le conteneur Spring
    • 1. Introduction
    • 2. Les contextes de Spring
    • 3. Configuration des beans
      • 3.1 Fichier XML
      • 3.2 Annotations pour configurer l'application
      • 3.3 Configurer les beans applicatifs implicitement
      • 3.4 Configuration par lambdas
    • 4. Utilisation des beans : injection par setters et constructeurs
      • 4.1 Mapping via le constructeur en XML
      • 4.2 Comparaison des méthodes d'instanciation
    • 5. Contrôle du cycle de vie : construction et destruction
    • 6. Exemple illustrant les mappings standards
      • 6.1 Le projet Maven
      • 6.2 Fichier de configuration de Spring
      • 6.3 Dépendance Spring Core et système de log
      • 6.4 Dépendance vers les librairies de tests unitaires
      • 6.5 Exemple illustrant l'utilisation des logs
      • 6.6 Fichier de configuration spécifique pour les tests
    • 7. Points clés
  • Configuration avancée
    • 1. Introduction
    • 2. Fichier XML et fichiers properties
    • 3. Les fichiers de ressources
      • 3.1 Les fichiers de ressources standards
      • 3.2 Les fichiers de ressources chargés via le contexte
      • 3.3 Les fichiers de ressources chargés via un service ResourceLoaderAware
        • 3.3.1 Le programme principal
        • 3.3.2 Le service ResourceLoaderAware
    • 4. Convertisseurs et formateurs
      • 4.1 Built-in converters
        • 4.1.1 Pour les types standards
        • 4.1.2 Pour les tableaux et les listes
        • 4.1.3 Pour les énumérations
        • 4.1.4 Pour les objets en général
      • 4.2 Convertir un Array en Collection et String
      • 4.3 Converter Factory
        • 4.3.1 Classe StringToUtilisateurConverterFactory
        • 4.3.2 Classe UtilisateurToStringConverterFactory
        • 4.3.3 Classe LesConversions5
      • 4.4 Les convertisseurs et les formateurs par défaut
        • 4.4.1 Classe LesConversions6
      • 4.5 Les formateurs personnalisés
        • 4.5.1 Classe CarteDeCredit
        • 4.5.2 Classe CarteDeCreditParser
        • 4.5.3 Classe CarteDeCreditPrinter
        • 4.5.4 Classe CarteDeCreditFormatter
        • 4.5.5 Classe LesConversions7
    • 5. Les BeanWrappers, le binding et les validateurs
      • 5.1 Classe LesBeanWrappers
      • 5.2 Classe UtilisateurValidator
    • 6. Points clés
  • Programmation orientée aspect avec Spring
    • 1. Introduction
    • 2. Les concepts d’AOP
    • 3. Limites de Spring AOP et utilisation d’AspectJ
    • 4. Le support @AspectJ dans Spring
      • 4.1 Activation du support
      • 4.2 Activation de @AspectJ avec configuration XML
      • 4.3 Déclaration d'un aspect
      • 4.4 Déclaration d'un pointcut
      • 4.5 Déclaration des greffons simples
      • 4.6 Les types génériques
      • 4.7 Détermination de noms d'arguments
      • 4.8 Ordre d’appel des greffons interceptant le point de jonction
      • 4.9 Injection
      • 4.10 Le mécanisme des proxies
      • 4.11 La face cachée des proxies en AOP
    • 5. Les API bas niveau pour Spring AOP
      • 5.1 L’interface PointCut
      • 5.2 L’interface ClassFilter
      • 5.3 L’interface MethodMatcher
    • 6. Points clés
  • Les tests et Spring
    • 1. Introduction
    • 2. Les Mock objects
      • 2.1 Mocks spécialisés pour "environnement"
      • 2.2 Support
        • 2.2.1 Utilités générales
        • 2.2.2 Spring MVC
      • 2.3 Tests d'intégration
        • 2.3.1 Vue d'ensemble
        • 2.3.2 Mise en cache du contexte de test
        • 2.3.3 Tests back et front
      • 2.4 Annotations
        • 2.4.1 @ContextConfiguration
        • 2.4.2 @WebAppConfiguration
        • 2.4.3 @ContextHierarchy
        • 2.4.4 @ActiveProfiles
        • 2.4.5 @TestPropertySource
        • 2.4.6 @DirtiesContext
        • 2.4.7 Interface TestExecutionListener
        • 2.4.8 @TransactionConfiguration
        • 2.4.9 @Transactional
        • 2.4.10 @Rollback
        • 2.4.11 @BeforeTransaction
        • 2.4.12 @AfterTransaction
        • 2.4.13 @Sql, @SqlConfig et @SqlGroup
      • 2.5 Annotations standards
    • 3. Les frameworks de test JUnit et testNG
      • 3.1 Utilisation avec JUnit
        • 3.1.1 Spring JUnit Runner
        • 3.1.2 @IfProfileValue
        • 3.1.3 @ProfileValueSourceConfiguration
        • 3.1.4 @Timed
        • 3.1.5 @Repeat
        • 3.1.6 Méta-annotations de support pour les tests
      • 3.2 Les arcanes du framework Spring TestContext
        • 3.2.1 Classes et interfaces du framework de tests
        • 3.2.2 Configuration du TestExecutionListener par les annotations
        • 3.2.3 Les TestExecutionListeners
        • 3.2.4 Mélange XML et classes annotées
      • 3.3 Configuration des contextes de tests
        • 3.3.1 Configuration de contexte avec des initialiseurs de contexte
        • 3.3.2 L’héritage dans la configuration des contextes
        • 3.3.3 Prise en compte des profils d'environnement
        • 3.3.4 Configuration de contexte avec des fichiers de propriétés de test
        • 3.3.5 Déclarer un fichier de propriétés pour les tests
        • 3.3.6 Détection du fichier de propriétés par défaut
      • 3.4 Hiérarchie des contextes de tests
        • 3.4.1 Héritage et surcharge des propriétés de test
        • 3.4.2 Chargement d'un WebApplicationContext
        • 3.4.3 Conventions
        • 3.4.4 La sémantique de ressources explicites
        • 3.4.5 Injecter des objets mockés
        • 3.4.6 Cachabilité du contexte de test
        • 3.4.7 Les hiérarchies des contextes
        • 3.4.8 L'injection de dépendance dans les tests
      • 3.5 Le scope session lors d’un test de requête
        • 3.5.1 Le scope session lors d’un test de requête
        • 3.5.2 Test de beans de scope request
        • 3.5.3 Configuration d’un bean de scope session
      • 3.6 Les transactions
        • 3.6.1 La gestion des transactions
        • 3.6.2 Les transactions managées par le test
        • 3.6.3 Activation et désactivation des transactions
        • 3.6.4 Comportement du commit et du rollback d’une transaction
        • 3.6.5 Exécution de code en dehors d'une transaction
        • 3.6.6 Configuration d'un gestionnaire de transactions
        • 3.6.7 Démonstration de toutes les annotations liées à la transaction
      • 3.7 Les scripts SQL
        • 3.7.1 Exécuter des scripts SQL
        • 3.7.2 La sémantique du path des ressources
        • 3.7.3 La détection de script par défaut
        • 3.7.4 Déclaration de plusieurs @Sql
        • 3.7.5 Phases d'exécution pour les scripts
        • 3.7.6 Script de configuration avec SqlConfig
        • 3.7.7 La gestion des transactions pour @Sql
      • 3.8 Classes de support TestContext
        • 3.8.1 Classes de support de JUnit
        • 3.8.2 Spring JUnit Runner
        • 3.8.3 Classes de support TestNG
      • 3.9 Framework Spring MVC Test
        • 3.9.1 Projet autonome
        • 3.9.2 Tests côté serveur
        • 3.9.3 Définir les attendus
        • 3.9.4 Ajouts de filtres
        • 3.9.5 Tests REST côté client
      • 3.10 Autres ressources
    • 4. Points clés
  • Partie back de l’application
    • 1. Description de la problématique
    • 2. Mise en œuvre
      • 2.1 Configuration d’une entité de la couche domaine
      • 2.2 Accès à l'objet du domaine
      • 2.3 Requêtes typées
      • 2.4 Cache de niveaux 1 et 2
      • 2.5 Bean Validation (JSR-303)
      • 2.6 L'API Criteria
      • 2.7 Accès à la base de données
      • 2.8 Le fichier persistence.xml
      • 2.9 Tests JPA
    • 3. Points clés
  • Spring dans un contexte web JSP
    • 1. Spring MVC
      • 1.1 Fonctionnement global
        • 1.1.1 Configuration simple XML
        • 1.1.2 Configuration par annotation
      • 1.2 Éléments complexes du contrôleur
        • 1.2.1 Fonctionnement global du contrôleur
        • 1.2.2 Exemple de la classe Simple
        • 1.2.3 Simple revisité
        • 1.2.4 Par le path
        • 1.2.5 Par un motif sur le path
        • 1.2.6 Par le path et une méthode
        • 1.2.7 Mappé par path + méthode + présence de paramètres de query
        • 1.2.8 Mappé par path + méthode + présence d’un header
        • 1.2.9 Par l'absence d'un header
        • 1.2.10 Par consommation
        • 1.2.11 Par production via Accept=application/json
        • 1.2.12 Par production via Accept=application/xml
        • 1.2.13 Paramètres de query
        • 1.2.14 Groupes de paramètres de query
        • 1.2.15 Variable du path
        • 1.2.16 Variable Matrix
        • 1.2.17 Variables Matrix multiples
        • 1.2.18 Header
        • 1.2.19 Corps de la requête
        • 1.2.20 En-tête et corps de la requête
        • 1.2.21 Arguments dans la requête
        • 1.2.22 Reader sur la requête
        • 1.2.23 InputStream de la requête
        • 1.2.24 Arguments de la réponse
        • 1.2.25 Writer de la réponse
        • 1.2.26 OutputStream de la réponse
        • 1.2.27 Session
        • 1.2.28 Handler personnalisé
        • 1.2.29 Utiliser l’annotation @ResponseBody seule
        • 1.2.30 Utiliser l’annotation @ResponseBody avec UTF-8 requis
        • 1.2.31 Utiliser l’annotation @ResponseBody avec UTF-8 produit
        • 1.2.32 Réponse avec un statut personnalisé
        • 1.2.33 Réponse avec un en-tête personnalisé
        • 1.2.34 Obtention d’un cookie
        • 1.2.35 Lire une chaîne de caractères
        • 1.2.36 Écrire une chaîne de caractères
        • 1.2.37 Lire les données encodées dans l’URL
        • 1.2.38 Retourner une MultiValueMap
        • 1.2.39 Lire une structure XML
        • 1.2.40 Écrire dans une structure XML via Accept=application/xml
        • 1.2.41 Lire une structure JSON
        • 1.2.42 Écrire dans une structure JSON via Accept=application/json
        • 1.2.43 Lire un Atom
        • 1.2.44 Écrire un Atom
        • 1.2.45 Lire un flux RSS
        • 1.2.46 Écrire un flux RSS
        • 1.2.47 HTML généré par un template JSP
        • 1.2.48 Mapping à partir d’un modèle
        • 1.2.49 Utiliser des variables dans un template de vue
        • 1.2.50 Data binding avec des variables d'URI
        • 1.2.51 Types primitifs
        • 1.2.52 Date
        • 1.2.53 Conversion des collections
        • 1.2.54 Utiliser des collections formatées
        • 1.2.55 Utiliser des objets personnalisés
        • 1.2.56 Utiliser un convertisseur personnalisé
        • 1.2.57 Validation
        • 1.2.58 @ExceptionHandler dans un contrôleur
        • 1.2.59 @ExceptionHandler global
        • 1.2.60 Templates de String pour les URI
        • 1.2.61 UriComponentsBuilder
        • 1.2.62 GET /async/callable/response-body
    • 2. Client REST
      • 2.1 Utilisation du RestTemplate
      • 2.2 Le bean de domaine avec l'annotation REST pour les champs manquants
    • 3. Spring Security
      • 3.1 Introduction à Spring Security
      • 3.2 Spring Security dans un environnement web
        • 3.2.1 Authentification par Spring
        • 3.2.2 Authentification par page de login personnalisée
        • 3.2.3 Authentification par base de données
    • 4. Points clés
  • Intégration JSF2
    • 1. Introduction
    • 2. Mojarra
    • 3. Architecture
    • 4. Cycle de vie
      • 4.1 Requête
      • 4.2 Restore View ou Reconstruct Component Tree
      • 4.3 Apply Request Value
      • 4.4 Perform Validation
      • 4.5 Synchronize Model ou Update Model Values
      • 4.6 Invoke Application Logic
      • 4.7 Render Response
      • 4.8 Réponse
      • 4.9 Fichier web.xml
      • 4.10 Dépendances
      • 4.11 Fichier faces-config.xml
      • 4.12 Bean managé sans Spring
      • 4.13 Exemple de vue JSF
      • 4.14 Apercu d’un composant JSF
    • 5. Intégration Spring
      • 5.1 Architecture
      • 5.2 Dépendances
      • 5.3 Fichier web.xml
      • 5.4 Fichier faces-config.xml
      • 5.5 Couches basses (back)
    • 6. Points clés
  • Application Spring Angular
    • 1. Introduction
    • 2. La partie backend
      • 2.1 Génération d’un backend
    • 3. La partie frontend
      • 3.1 Angular CLI
      • 3.2 Création du projet initial
      • 3.3 Démarrage de l’application
      • 3.4 Créer un service Compte
    • 4. Points clés
  • Spring-HATEOAS
    • 1. Introduction
      • 1.1 Exemple de liens hypermédias codés manuellement
      • 1.2 Aller plus loin avec l’hypermédia
      • 1.3 Autoconfiguration par annotation
      • 1.4 Fournisseurs de relations
      • 1.5 Fournisseur d’URI compacte
      • 1.6 Support du côté client
      • 1.7 Découverte de liens coté client
      • 1.8 Utilisation du @RepositoryRestResource
    • 2. Points clés
  • Documentation Spring REST Docs
    • 1. Introduction
    • 2. Exemples de génération de la documentation
      • 2.1 Dépendance sur la bibliothèque de tests
      • 2.2 Dépendance sur les plug-ins Maven
      • 2.3 Les extraits (snippets)
    • 3. Exemple JUnit 5
    • 4. Requête et réponse
    • 5. Réponse avec un JSON imbriqué
      • 5.1 Les paramètres de requête
      • 5.2 Les paramètres inclus dans le path
      • 5.3 Les Request parts
      • 5.4 Les Request parts payloads
      • 5.5 Les champs
      • 5.6 Liens hypermédias dans la réponse
      • 5.7 Les en-têtes
    • 6. Personnalisation de la documentation
      • 6.1 Utilisation de @AutoConfigureRestDocs
    • 7. Couplage Swagger 2
      • 7.1 Utilisation Springfox
      • 7.2 En dehors de Spring Boot
    • 8. Utilisation avec Spring Data Rest
    • 9. Récapitulatif sur la documentation générée
    • 10. Points clés
  • Spring Boot
    • 1. Introduction
    • 2. Configuration des exemples
      • 2.1 Configuration Maven pour la version 1.5 de Spring Boot
      • 2.2 Configuration Maven pour la version 2 de Spring Boot
      • 2.3 Utilisation du hot swapping
      • 2.4 Packaging et lancement de l’application
      • 2.5 Application Spring MVC minimum
    • 3. L’autoconfiguration Spring Boot
      • 3.1 La configuration automatique des Beans Spring
    • 4. Les starters
      • 4.1 Les starters courants
      • 4.2 Les starters orientés messages
      • 4.3 Les bases de données
      • 4.4 Les web services
      • 4.5 Les moteurs de rendus
      • 4.6 Les starters moins courants
    • 5. Spring MVC
    • 6. Personnalisation de la bannière
    • 7. Événements d’applications
    • 8. La récupération des arguments de la ligne de commande
      • 8.1 CommandLineRunner
      • 8.2 ApplicationRunner
      • 8.3 La configuration yaml et profiles
    • 9. La configuration des logs
      • 9.1 Les logs en couleur
      • 9.2 Choix du type de logs
    • 10. L’autoconfiguration pour Spring MVC
    • 11. La gestion des sessions
    • 12. Le guide de migration de la version 1.5 à la version 2.0
      • 12.1 Fichiers de configuration
      • 12.2 Comportements différents
      • 12.3 Démarrage
      • 12.4 Utilisation de ApplicationRunner ou CommandLineRunner
      • 12.5 Configuration externalisée
      • 12.6 Développement d’applications web
        • 12.6.1 Web Starter en tant que dépendance transitive
      • 12.7 Sécurité
    • 13. Points clés
  • Spring et le NoSQL
    • 1. Introduction
    • 2. Les modèles de données
      • 2.1 Clé-valeur
      • 2.2 Documents
      • 2.3 Orienté colonne
      • 2.4 Les bases orientées Graph
    • 3. Principes des bases de données
      • 3.1 Consistance des données
    • 4. Pourquoi et quand utiliser une base NoSQL
    • 5. Problèmes liés à l’utilisation des bases NoSQL
    • 6. Limitations des bases de données NoSQL
    • 7. Spring et le NoSQL
    • 8. Cache de données
      • 8.1 Cache simple
    • 9. Cacher des données avec GemFire
    • 10. GemFire en tant que base de données NoSQL
    • 11. Redis en autonome
      • 11.1 Utilisation de Redis pour le cache de données
      • 11.2 Utilisation de Redis pour gérer des messages
    • 12. MongoDB
      • 12.1 MongoDB avec Spring Boot
      • 12.2 MongoDB avec une API REST
    • 13. Points clés
  • Spring Batch
    • 1. Introduction
    • 2. Architecture de l’application
    • 3. Exemple Spring Batch 4
    • 4. Chargeur H2 depuis un CSV
    • 5. Dépendances Spring Batch 3 et 4
    • 6. Autres nouveautés de la version 4
    • 7. Points clés
  • Les intergiciels à messages (MOM)
    • 1. Introduction
    • 2. Implémentations open source
    • 3. Implémentations propriétaires
    • 4. Les cas d’utilisation
    • 5. JMS et ActiveMQ
      • 5.1 Utilisation simplifiée
    • 6. RabbitMQ
      • 6.1 Spring AMQP et RabbitMQ
      • 6.2 Exemple RabbitMQ
    • 7. Points clés
  • Spring et Kotlin
    • 1. Introduction
    • 2. Caractéristiques principales du langage Kotlin
      • 2.1 Les méthodes et les fonctions
      • 2.2 L’immutabilité des objets
      • 2.3 Les types
      • 2.4 La gestion des valeurs nulles
      • 2.5 Les appels chaînés sécurisés
      • 2.6 Les lambdas
    • 3. Contrôleur Spring MVC, Spring Boot en Kotlin
      • 3.1 Fonction principale
      • 3.2 Test associé à la fonction principale
    • 4. Les plug-ins
    • 5. Points clés
  • Spring et JHipster
    • 1. Introduction
    • 2. JHipster comme outils multitechnologies
      • 2.1 Côté client
      • 2.2 Côté serveur
      • 2.3 Côté déploiement
      • 2.4 Côté Spring
    • 3. Exemple de projet
    • 4. Structure du projet
      • 4.1 La partie front
      • 4.2 Les grandes lignes de la partie back
        • 4.2.1 Spring Boot
        • 4.2.2 La classe serveur HTTP/servlet
    • 5. Points clés
    • Index

Auteur

Hervé LE MORVANEn savoir plus

Hervé LE MORVAN est aujourd'hui consultant DevOps pour de grands comptes de la Banque, de l'Assurance et des Telecoms. Durant ses vingt années d'expérience, il est principalement intervenu en tant que référent technique et formateur dans des équipes de Recherche et Développement ou d'Architectes et en tant que support au développement d'applications sur des missions de migration ou de modernisation de Systèmes d'Information. À ce titre, il est intervenu dans de nombreux projets de migration utilisant le socle Spring et connaît parfaitement les attentes des équipes dans ce domaine. C'est toute cette expérience qu'il partage volontiers tout au long des pages de ce livre.

Caractéristiques

  • Niveau Expert
  • Nombre de pages 503 pages
  • Parution mai 2018
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-01384-3
    • EAN : 9782409013843
    • Ref. ENI : EP2JASP
  • Niveau Expert
  • Parution mai 2018
    • HTML
    • ISBN : 978-2-409-01385-0
    • EAN : 9782409013850
    • Ref. ENI : LNEP2JASP

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires (1,23 Mo)