Ce livre sur le langage de programmation Kotlin et ses fra­meworks Ktor et Exposed vise à familiariser les développeurs backend avec une stack technologique entièrement basée sur ce langage. Il montre comment Kotlin peut être utilisé pour dé­velopper toutes les couches d’une application web moderne et performante.

L’auteur commence par une introduction détaillée aux bases du langage Kotlin (variables, fonctions, structures de contrôle) et à sa syntaxe, avant de vous guider à travers les tests et l’utilisation des coroutines, un des principes avancés du langage.

La deuxième partie est entièrement dédiée à la création de ser­vices REST avec Ktor, le framework développé par JetBrains pour développer des applications web performantes et robustes.

Ensuite, vous explorez le framework Exposed, également déve­loppé par JetBrains, qui facilite la connexion et la gestion des bases de données relationnelles. Vous pourrez ainsi apprendre à manipuler les données efficacement et en toute sécurité.

Enfin, le livre aborde des concepts avancés tels que le déve­loppement multi-plateforme avec Kotlin Multiplatform et le développement frontend, vous permettant d’étendre vos com­pétences et de créer des applications complètes et cohérentes.

Téléchargements

• Des fichiers complémentaires (90 Ko)

Avant-propos

1. À propos de Kotlin
2. Audience de cet ouvrage
3. Organisation de l’ouvrage

Présentation du langage Kotlin

1. Pourquoi Kotlin ?
2. Outils de développement
   1. 1. Environnement de développement intégré
   2. 2. Compilateur Kotlin
   3. 3. Maven
   4. 4. Gradle
   5. 5. SonarQube
   6. 6. Ktlint
3. Les bases de Kotlin
   1. 1. Programme minimal
   2. 2. Les commentaires
   3. 3. Les variables
   4. 4. Les types nullable et non-nullable
   5. 5. Conversion entre deux types (cast)
   6. 6. Les chaînes de caractères
   7. 7. Les fonctions
      1. a. Déclarer une fonction
      2. b. Appeler une fonction
      3. c. Les paramètres nommés
      4. d. Les paramètres avec valeurs par défaut
      5. e. Surcharge des fonctions
      6. f. Les fonctions d’ordre supérieur
      7. g. Les fonctions anonymes
      8. h. Les lambdas
   8. 8. Les structures de contrôle
      1. a. Les conditions
      2. b. Les boucles
   9. 9. Les packages
   10. 10. Les indicateurs de visibilité
   11. 11. Les classes
       1. a. Les propriétés
       2. b. Personnalisation des getters et des setters
       3. c. Les constructeurs
       4. d. Les méthodes
       5. e. Les classes data
       6. f. Les classes Enum
   12. 12. L’héritage
       1. a. Surcharge des méthodes
       2. b. Surcharge des propriétés
   13. 13. Les interfaces
   14. 14. Les classes abstraites
   15. 15. Les classes et interfaces scellées
   16. 16. Les classes imbriquées
   17. 17. Les extensions
       1. a. Les fonctions d’extension
       2. b. Les propriétés d’extension
   18. 18. La délégation
   19. 19. L’objet singleton
   20. 20. Les collections
       1. a. Les tableaux
       2. b. Les listes
       3. c. Les collections de type Map
4. Les coroutines
   1. 1. Introduction
   2. 2. Fonctionnement des coroutines
      1. a. L’installation
      2. b. Les fonctions suspendues
      3. c. La création d’une coroutine
      4. d. Les répartiteurs
5. Tester son code
   1. 1. Introduction
      1. a. Installation de Kotest avec Gradle
      2. b. Installation de Kotest avec Maven
      3. c. Configuration d’IntelliJ
   2. 2. Écrire des tests avec Kotest
      1. a. FunSpec
      2. b. StringSpec
      3. c. FreeSpec
      4. d. AnnotationSpec
   3. 3. Utiliser la bibliothèque d’assertions
   4. 4. Simuler les comportements des objets
6. Conclusion

Développement d’API avec Ktor

1. Introduction
   1. 1. Qu’est-ce que Ktor ?
   2. 2. Comparaison avec le framework Spring
      1. a. Le temps de démarrage
      2. b. L’écosystème
      3. c. La syntaxe
      4. d. La performance
   3. 3. Créer une application serveur en utilisantKtor
      1. a. Choisir un moteur HTTP pour le serveur
      2. b. Ajouter Ktor à un projet Gradle
      3. c. Ajouter Ktor à un projet Maven
      4. d. La fonction main de l’application
      5. e. Le fichier de configuration
      6. f. Les modules Ktor
   4. 4. Fonctionnement de Ktor
      1. a. Architecture basée sur un systèmede plugins
      2. b. Installation d’un plugin
2. Les bases de Ktor
   1. 1. Écrire une API REST
      1. a. Définir l’API
      2. b. Récupérer les variables d’unchemin de routage
      3. c. Récupérer les paramètresde la requête
   2. 2. La sérialisation des objets
      1. a. Ajouter le plugin Gradle/Maven de sérialisation
      2. b. Désérialisation des messages desrequêtes HTTP
      3. c. Sérialisation des messages des réponsesHTTP
   3. 3. Validation des contenus des requêtes
      1. a. Installation du plugin de validation de requêtes
      2. b. Configuration du plugin de validation de requêtes
   4. 4. Contrôler le code HTTP renvoyé lorsd’une exception
   5. 5. Gérer les en-têtes HTTP
      1. a. Récupérer les en-têtesHTTP d’une requête
      2. b. Définir des en-têtes HTTP d’uneréponse
   6. 6. Servir du contenu statique
      1. a. Servir des fichiers depuis le système defichiers
      2. b. Servir des ressources depuis le classpath
      3. c. Exclure des fichiers
   7. 7. Templates HTML
      1. a. Générer le code HTML en Kotlin
      2. b. Créer des composants réutilisables
      3. c. Utiliser des balises HTML personnalisées
      4. d. Gérer des templates complexes
   8. 8. Bien structurer son application
3. Sécuriser son API
   1. 1. Authentification basique
   2. 2. Utilisation d’un token JWT
   3. 3. Intégration avec LDAP
   4. 4. Authentification OAuth
   5. 5. Gestion des sessions et des cookies
      1. a. Installation du plugin de gestion des sessions
      2. b. Représentation des données d’unesession
      3. c. Passer la session dans un en-tête HTTP
      4. d. Passer la session dans un cookie
      5. e. Protéger les données de la session
4. Ktor : documenter son API
   1. 1. Documentation OpenAPI
   2. 2. Exposer l’interface OpenAPI
   3. 3. Exposer l’interface Swagger
5. Tester son API REST
   1. 1. Configuration de l’environnement de test
   2. 2. Écriture du test
6. Se connecter à une API REST avec le client HTTP
   1. 1. Installation et configuration
   2. 2. Configuration d’un plugin
   3. 3. Envoyer des requêtes HTTP
7. Utilisation des WebSockets
   1. 1. Configurer le plugin WebSockets
   2. 2. Définir un point d’accèsWebSocket
   3. 3. Utiliser les WebSockets côté client
8. Monitoring d’une application Ktor
   1. 1. Logging
   2. 2. Intégration avec Micrometer
9. Déploiement de l’application
   1. 1. Déploiement sous forme d’un Fat-JAR
      1. a. Génération du Fat-JAR avec Gradle
      2. b. Génération du Fat-JAR avec Maven
   2. 2. Déploiement sous forme d’un dossierd’installation
   3. 3.  Déploiement sous forme d’imageDocker
      1. a. Créer l’image Docker en utilisantle plugin Gradle de Ktor
      2. b. Créer l’image Docker avec un DockerFile
10. Conclusion

Connexion aux bases de données avec Exposed

1. Introduction
2. Comparaison entre Exposed et Hibernate
   1. 1. Maintenabilité
   2. 2. Maturité
   3. 3. Performance
3. Installation et configuration
   1. 1. Ajout des dépendances
   2. 2. Configuration de la connexion
   3. 3. Gestion des transactions
4. Les bases du framework Exposed
   1. 1. Représentation des tables
      1. a. Déclarer les tables
      2. b. Ajouter des contraintes
      3. c. Définir les index
      4. d. Définir les relations
      5. e. Initialiser le schéma
   2. 2. Utilisation de Flyway
      1. a. Définir les migrations
      2. b. Appliquer les migrations
   3. 3. Exécution des requêtes
      1. a. Utiliser l’API DAO
      2. b. Utiliser l’API DSL
5. Gérer les jointures
   1. 1. Gérer les jointures avec la syntaxe DSL
      1. a. Les jointures internes
      2. b. Les jointures à droite
      3. c. Les jointures à gauche
      4. d. Les jointures complètes
   2. 2. Gérer les jointures avec la syntaxe DAO
6. Utilisation des fonctions SQL
7. Tester les requêtes
8. Monitoring des requêtes
   1. 1. Activation des logs
   2. 2. Intégration avec Micrometer
9. Conclusion

Aller plus loin avec Kotlin Multiplatform

1. Introduction
2. Structuration de code
   1. 1. Le plugin Gradle
   2. 2. Structure du projet
   3. 3. Gestion des dépendances
   4. 4. Génération du binaire
   5. 5. Les avantages de la compilation Kotlin en native
3. Développement frontend avec Kotlin/JS
   1. 1. Création et configuration d’un projetKotlin/JS
   2. 2. Ajouter des dépendances NPM
   3. 3. Ajouter des feuilles de style CSS
   4. 4. Utilisation du framework React
   5. 5. Appeler une API REST
   6. 6. Déploiement de l’application web

Conclusion

1. Introduction