Implémenter des applications de niveau entreprise à l'aide de Spring Boot et du langage Kotlin

Alors que la demande d'applications d'entreprise continue d'augmenter, diverses nouvelles technologies émergent également. Cependant, avec le développement de la technologie Java, de plus en plus de développeurs commencent à s’intéresser au langage Kotlin. Kotlin est un langage de programmation à typage statique développé par JetBrains. Il fournit un code plus simple, plus sûr et plus facile à lire et à écrire pour les applications basées sur JVM, et reflète donc une plus grande productivité en développement.

Dans le même temps, Spring Boot est devenu le framework préféré pour les applications de niveau entreprise en raison de sa construction légère et rapide et de sa simple configurabilité. Cet article explique comment utiliser Spring Boot et le langage Kotlin pour implémenter des applications au niveau de l'entreprise.

1. Construction et configuration du projet

Spring Boot fournit un outil Spring Initializr qui peut configurer rapidement les dépendances et les fichiers de configuration requis. En tant que langage de programmation émergent, le langage Kotlin est également pris en charge dans cet outil.

Pour créer le projet, vous devez d'abord télécharger JDK 1.8 ou supérieur, et vous devez également installer un outil IDE. Il est recommandé d'utiliser IntelliJ IDEA.

1.1 Nouveau projet

Ouvrez IntelliJ IDEA, sélectionnez Fichier -> Nouveau -> Projet dans le menu principal, puis sélectionnez Spring Initializr dans la boîte de dialogue contextuelle, remplissez les informations de base du projet (telles que le projet nom, description, etc.), cliquez sur Suivant.

Dans la configuration Spring Initializr, sélectionnez Kotlin comme langage de programmation principal et ajoutez les dépendances requises telles que Web, JPA, MySQL, etc., comme indiqué dans la figure ci-dessous :

Cliquez sur Suivant pour configurer le nom, l'emplacement et d'autres informations sur le projet. Au cours de ce processus, assurez-vous que Gradle est utilisé comme outil de construction et que Java SDK 8.0 ou supérieur est utilisé.

Cliquez sur Terminer, IntelliJ IDEA générera automatiquement un projet nommé "spring-kotlin-demo".

1.2 Configuration du projet

Afin de construire le projet dans un package Jar ou War déployable, vous devez modifier le fichier de configuration du projet build.gradle :

//build.gradle fichier
plugins {

kotlin("jvm") version "1.4.30"
id("org.springframework.boot") version "2.4.3"
kotlin("plugin.spring") version "1.4.30"

}

group = "com.example"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_1_8

repositories {

mavenCentral()

}

dépendances {

implementation("org.springframework.boot:spring-boot-starter-data-jpa")
implementation("org.springframework.boot:spring-boot-starter-web")
implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
implementation("mysql:mysql-connector-java")
testImplementation("org.springframework.boot:spring-boot-starter-test")

}

Le fichier build.gradle comprend les modifications suivantes :
– Le plugin du langage Kotlin est ajouté
– La version Java est ciblée sur 1.8
– Les dépendances nécessaires sont ajoutées pour créer l'application Spring Boot pour JPA, Web et MySQL.
– Le module Jackson pour le connecteur Kotlin et MySQL .

2. Implémentation des exigences métier

Dans Spring Boot, utiliser le langage Kotlin pour implémenter les exigences métier ne nécessite pas de compétences particulières et est similaire au langage Java. Ici, nous illustrons son utilisation spécifique avec un cas d’utilisation simple.

2.1 Créer un modèle de données

Dans Kotlin, la définition des classes d'entités est similaire à celle de Java. Lors de la définition d'une classe spécifique, vous devez utiliser le mot-clé data class. Il s'agit d'une manière de définir les classes de données fournies dans le langage Kotlin :

//UserModel.kt

package com.example.demo.model

import javax. .persistence .*

@Entity
@Table(name = "user")
data class UserModel(

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
val id: Long? = null,

val name: String,
val age: Int

)

Dans le code ci-dessus, les annotations @Entity et @Table sont utilisées pour spécifier le nom de la table de données et spécifiez que la classe est une classe d'entité JPA. Chaque classe d'entité doit spécifier une clé primaire, annotée avec l'annotation @Id. Contrairement à Java, une classe de données est définie à l'aide du mot-clé data.

2.2 Implémentation de la couche d'accès aux données

Pour implémenter la couche d'accès aux données, vous devez utiliser Spring Data JPA, qui est un outil fourni par le framework Spring pour accéder à la base de données. Spring Data JPA peut aider les développeurs à lire et à transférer des données de la base de données sans écrire d'instructions SQL fastidieuses.

//UserRepository.kt

package com.example.demo.repository

import com.example.demo.model.UserModel
import org.springframework.data.repository.CrudRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepository : CrudRepository {

fun findByName(name: String): Iterable<UserModel>

}

Dans le code ci-dessus, une interface UserRepository est définie, qui utilise CrudRepository pour implémenter des opérations courantes d'ajout, de suppression, de modification et de vérification. Une méthode permettant de rechercher des utilisateurs par nom est également définie.

2.3 Implémentation de la couche de contrôle

Dans Spring Boot, utiliser Kotlin pour implémenter un contrôleur est similaire à Java. Vous pouvez utiliser une annotation pour créer le contrôleur :

//UserController.kt

package com.example.demo.controller.

import com.example.demo.model.UserModel
import com.example.demo.repository.UserRepository
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.*

@RestController
@RequestMapping("/user")
class UserController {

@Autowired
lateinit var userRepository: UserRepository

@GetMapping("/findAll")
fun findAll() = userRepository.findAll()

@GetMapping("/findByName/{name}")
fun findByName(@PathVariable("name") name: String) = userRepository.findByName(name)

@PostMapping("/save")
fun saveUser(@RequestBody userModel: UserModel) = userRepository.save(userModel)

@PutMapping("/update")
fun updateUser(@RequestBody userModel: UserModel) = userRepository.save(userModel)

@DeleteMapping("/delete/{id}")
fun deleteUser(@PathVariable("id") id: Long) = userRepository.deleteById(id)

}

Dans le code ci-dessus, une classe de contrôleur UserController est définie, qui utilise l'annotation @Autowired pour assembler automatiquement le userRepository. Parallèlement, la méthode d'ajout, de suppression, de modification et de vérification des utilisateurs est également définie.

3. Exécuter et tester

Dans le répertoire racine du projet, exécutez la commande gradle bootRun pour démarrer l'application Spring Boot, et vous pouvez appeler l'interface API via localhost:8080/user/findAll pour les tests. Lorsque vous utilisez le langage Kotlin, vous pouvez également voir des résultats de sortie similaires à Java.

En résumé, l'utilisation de Spring Boot et du langage Kotlin pour implémenter des applications au niveau de l'entreprise peut rendre le travail de développement plus simple, plus sûr et plus productif. Cependant, il faut noter que le coût de l’apprentissage de la langue Kotlin est relativement élevé, donc plus de pratique et de réflexion sont nécessaires pendant le processus de développement lui-même.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!