J'ai introduit quelques exemples de couches Web, notamment en créant une API RESTful et en rendant une vue Web à l'aide du moteur de modèle Thymeleaf, mais ces contenus ne sont pas suffisants pour créer une application dynamique. Habituellement, que nous créons des applications ou des applications Web, nous avons besoin de contenu et le contenu est généralement stocké dans différents types de bases de données. Après avoir reçu la demande d'accès, le serveur doit accéder à la base de données pour les obtenir et les traiter dans un formulaire de données affiché pour les utilisateurs.
Cet article présente des exemples de configuration de sources de données sous Spring Boot et d'écriture d'accès aux données via JDBCTemplate.
Configuration de la source de données
Lorsque nous accédons à la base de données, nous devons d'abord configurer une source de données. Voici plusieurs méthodes de configuration de la base de données différentes.
Tout d'abord, afin de vous connecter à la base de données, vous devez introduire le support JDBC et la configuration suivante est introduite dans build.gradle:
compiler "org.springframework.boot: printemps-boot-starter-jdbc: $ printemps_boot_version"
Connectez-vous aux sources de données
Prendre l'exemple de la base de données MySQL, introduisez d'abord le package de dépendance de la connexion MySQL et ajoutez-le à build.gradle:
Compiler "MySQL: MySQL-Connector-Java: $ mysql_version"
Build complet.gradle
groupe 'name.quanke.kotlin'version' 1.0-snapshot'buildscript {ext.kotlin_version = '1.2.10' ext. Dépendances {classpath "org.jetbrains.kotlin: Kotlin-Gradle-Plugin: $ kotlin_version" ClassPath ("org.springframework.boot: printemps-boot-gradle-plagin: $ printemps_boot_version") // Kotlin intègre le constructeur par défaut de la classe par défaut de Springboot, et set tous ClassPath ("org.Jetbrains.kotlin: Kotlin-noarg: $ kotlin_version") ClassPath ("org.Jetbrains.kotlin: Kotlin-allopen: $ kotlin_version")}} Appliquer le plugin: 'Kotlin'Apply Plugin: "Kotlin-Spring" // See https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-pluginApply: 'org.springframework.boot'jar {basename =' Chapter11-6-1-SERVIC compiler "org.jetbrains.kotlin: kotlin-stdlib-jre8: $ kotlin_version" compiler "org.springframework.boot: printemps-boot-starter-web: $ printemps_boot_version" compile "org.springframework.boot: Spring-boot-starter-jdbc: $ printemps_version" "mysql: mysql-connector-java: $ mysql_version" testcompile "org.springframework.boot: printemps-boot-starter-test: $ printemps_boot_version" testcompile "org.Jetbrains.kotlin: kotlin-test-junit: $ kotlin_version"} compilekotlin { kotlinoptions.jvmtarget = "1.8"} compileTestkotlin {kotlinoptions.jvmtarget = "1.8"}Configurer les informations de source de données dans SRC / Main / Resources / Application.yml
Spring: DataSource: URL: JDBC: MySQL: // LocalHost: 3306 / Test Username: Root Motword: 123456 Driver-Class-Name: com.mysql.jdbc.
Connectez-vous à la source de données JNDI
Lorsque vous déployez une application sur un serveur d'applications, vous pouvez utiliser la méthode de configuration suivante pour introduire la source de données JNDI.
Si vous ne savez pas grand-chose sur JNDI, veuillez vous référer à https://baike.baidu.com/item/jndi/3792442?fr=aladdin
printemps.datasource.jndi-name = java: jboss / datasources / clients
Utilisez JDBCTemplate pour faire fonctionner la base de données
JDBCTEmplate de Spring est automatiquement configuré et vous pouvez utiliser @Autowired pour l'injecter dans votre propre bean.
Par exemple: nous créons une table utilisateur, y compris l'ID d'attributs, le nom et l'âge. Écrivons les objets d'accès aux données et les cas de test unitaire.
Définissez une interface abstraite qui contient l'insertion, la suppression et la requête.
Interface UserService {/ ** * Obtenez le nombre total d'utilisateurs * / VAL ALLUSERS: INT? / ** * Ajouter un nouvel utilisateur * @param name * @param age * / fun create (nom: chaîne, mot de passe: string?) / ** * supprimer un utilisateur élevé selon le nom * @param name * / fun deleteByName (name: string) / ** * supprimer tous les utilisateurs * / fun deleteAlLUSERS ()}Implémentez les opérations d'accès aux données définies dans le service d'utilisateur via JDBCTemplate
import org.springframework.beans.factory.annotation.AutowiredImport org.springframework.jdbc.core.jdbctemplatemport org.springframework.sterreotype.service / ** * créé par http://quanke.name le 2018/1/10. * / @ ServiceClass UserServiceImpl: UserService {@Autowired Private Val JDBCTemplate: JDBCTemplate? = Null Override Val ALLUSERS: int? get () = jdbcTemplate !!. QueryForObject ("SELECT COUNT (1) From User", int :: class.java) Override Fun Create (Name: String, Motway: String?) {JDBCTemplate !!. Update ("Insert dans l'utilisateur (nom d'utilisateur, mot de passe) (? Utilisateur où username =? ", Name)} remplacer le plaisir de DeleTeAlLusers () {jdbCTemplate !!. Update (" supprimer de l'utilisateur ")}}Créez des cas de test unitaire pour les services d'utilisateur pour vérifier l'exactitude des opérations de base de données en créant, en supprimant et en interrogeant.
/ ** * Créé par http://quanke.name le 2018/1/9. * / @ Runwith (springrunner :: class) @springboottestclass applicationtests {val log = logfactory.getLog (applicationtests :: class.java) !! @Autowired LateInit var userservice: userService @test fun `jdbc test" `() {val username =" quanke "val password =" 123456 "// insérer 5 utilisateurs userservice.create (" $ username a "," $ mot de passe 1 ") userservice.create (" $ username b "", "$ mot de passe 2" "). C "," $ mot de passe 3 ") userservice.create (" $ username d "," $ mot de passe 4 ") userservice.create (" $ username e "," $ mot de passe 5 ") log.info (" Total utilisateurs $ {userservice.allusers} ") // deletewerservice.DeleteByname (" $ userName a ") userservice.DeleteBename ($ userName a") userservice.DeleteBename ($ userName a ") Usersservice.DeleteBename ($ userName a") ") Usersservices b ") log.info (" utilisateur total $ {userservice.allusers} ")}}Le JDBCTemplate introduit ci-dessus n'est que quelques-unes des opérations les plus élémentaires. Pour plus d'informations sur l'utilisation d'autres opérations d'accès aux données, veuillez vous référer à: JDBCTemplate API
Grâce à l'exemple simple ci-dessus, nous pouvons voir que la configuration de l'accès aux bases de données sous Spring Boot adhère toujours à l'intention d'origine du cadre: simple. Nous devons seulement ajouter des dépendances de la base de données à pom.xml, puis configurer les informations de connexion dans application.yml. Nous n'avons pas besoin de créer une application JDBCTemplate Bean comme Spring, et nous pouvons l'injecter directement et l'utiliser dans notre propre objet.
Résumer
Ce qui précède est la méthode d'utilisation de JDBCTemplate pour se connecter à la base de données MySQL par Spring Boot et Kotlin, que je vous ai présenté. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!