He introducido algunos ejemplos de capas web, incluida la creación de una API RESTFUL y la presentación de una vista web utilizando el motor de plantilla Thymeleaf, pero estos contenidos no son suficientes para construir una aplicación dinámica. Por lo general, ya sea que realicemos aplicaciones o aplicaciones web, necesitamos contenido y el contenido generalmente se almacena en varios tipos de bases de datos. Después de recibir la solicitud de acceso, el servidor debe acceder a la base de datos para obtenerla y procesarla en un formulario de datos que se muestra para los usuarios.
Este artículo presenta ejemplos de configuración de fuentes de datos bajo el arranque de Spring y la escritura de acceso a datos a través de JDBCTemplate.
Configuración de la fuente de datos
Cuando accedemos a la base de datos, primero debemos configurar una fuente de datos. Los siguientes son varios métodos de configuración de bases de datos diferentes.
Primero, para conectarse a la base de datos, debe introducir el soporte JDBC, y la siguiente configuración se introduce en Build.gradle:
compilar "org.springframework.boot: spring-boot-starter-jdbc: $ spring_boot_version"
Conectarse a fuentes de datos
Tomando la base de datos MySQL como ejemplo, primero introduzca el paquete de dependencia de la conexión MySQL y agréguelo a Build.gradle:
compilar "mysql: mysql-connector-java: $ mysql_version"
Complete Build.gradle
Grupo 'name.quanke.kotlin'version' 1.0-snapshot'buildscript {ext.kotlin_version = '1.2.10' ext.spring_boot_version = '1.5.4.release' ext.springfox_swagger2_version = '2.7.0' ext.mysql_version = '5.1.21' repositories {{) dependencias {classpath "org.jetbrains.kotlin: kotlin-cradle-plugin: $ kotlin_version" classpath ("org.springframework.boot: spring-boot-cradle-plugin: $ spring_boot_version") // kotlin integra la construcción de parámetros predeterminados de SpringBoot, y sets todos los plements de clases de los clases de la clase, por defecto de la clases, por defecto "). classpath ("org.jetbrains.kotlin: kotlin-noarg: $ kotlin_version") classpath ("org.jetbrains.kotlin: kotlin-allopen: $ kotlin_version")}} Aplicar complemento: 'kotlin'apply complemento: "kotlin-spring" // ver https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-pluginapply plugin plugin compilar "org.jetbrains.kotlin: kotlin-stdlib-jre8: $ kotlin_version" compilar "org.springframework.boot: spring-boot-starter-web: $ spring_boot_version" compilat "mySql: mySQL-Connector-java: $ mysql_version" testCompile "org.springframework.boot: spring-boot-starter-test: $ spring_boot_version" testCompile "org.jetbrains.kotlin: kotlin-test-junit: $ kotlin_version"} Compilekotlin { kotlinoptions.jvmtarget = "1.8"} compiletestkotlin {kotlinoptions.jvmtarget = "1.8"}Configurar información de origen de datos en SRC/Main/Resources/Application.yml
Spring: DataSource: URL: JDBC: MySQL: // Localhost: 3306/Test UserName: Root Password: 123456 Driver-Class-Name: com.mysql.jdbc.driver
Conectarse a la fuente de datos JNDI
Cuando implementa una aplicación en un servidor de aplicaciones, puede usar el siguiente método de configuración para introducir la fuente de datos JNDI.
Si no sabe mucho sobre JNDI, consulte https://baike.baidu.com/item/jndi/3792442?fr=aladdin
spring.datasource.jndi-name = java: jboss/dataSources/clientes
Use JDBCTemplate para operar la base de datos
JDBCTemplate de Spring se configura automáticamente, y puede usar @aUtowired para inyectarlo en su propio frijol.
Por ejemplo: estamos creando una tabla de usuario, que incluye ID de atributos, nombre y edad. Escribamos objetos de acceso a datos y casos de prueba unitaria.
Defina una interfaz abstracta que contenga inserción, eliminación y consulta.
Interface UserService { / *** Obtenga el número total de usuarios* / Val Allusers: int? / *** Agregue un nuevo usuario* @param nombre* @param edad*/ diversión create (nombre: cadena, contraseña: string: string?)/ *** Eliminar un usuario alto según el nombre* @param nombre*/ diversión deletyname (name: string)/ *** Eliminar todos los usuarios*/ FUN DELeteAllusers ()}Implementar operaciones de acceso a datos definidas en UserService a través de JDBCTemplate
importar org.springframework.beans.factory.annotation.aUtowiredImport org.springframework.jdbc.core.jdbctemplateImport org.springframework.stereotype.service/*** creado por http://quanke.name el 2018/1/10. */ @ServiceClass UserServiceImpl: UserService {@aUtowired private val jdbctemplate: jdbctemplate? = NULL ENVRIDE VAL ALLUSERS: INT? get () = jdbctemplate !!. QueryForObject ("Seleccione Count (1) del usuario", int :: class.java) anular diversión create (nombre: cadena, contraseña: string?) {jdbctemplate! jdbctemplate !!. update ("Eliminar del usuario donde username =?", nombre)} anular diversión deletealLusers () {jdbctemplate !!. update ("eliminar del usuario")}}Cree casos de prueba unitaria para UserService para verificar la corrección de las operaciones de la base de datos creando, eliminando y consultando.
/*** Creado por http://quanke.name el 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 "// Inserte 5 usuarios de usuarios UserService.Create (" $ usame a "," $ contraseña 1 ") UserService.create (" $ Username B "," $ PASSINTY 2 ") UserService (" ("" UserName. c "," $ Password 3 ") UserService.Create (" $ UserName d "," $ Password 4 ") UserService.Create (" $ UserName E "," $ Password 5 ") log.info (" Usuarios totales $ {UserSerservice.AllUsers} ") // delete UserSerSerEnservice.DelEteByName (" UserName A ") b ") log.info (" Total User $ {Userservice.allusers} ")}}El JDBCTEMPLATE presentado anteriormente es solo algunas de las operaciones más básicas. Para obtener más información sobre el uso de otras operaciones de acceso a datos, consulte: API JDBCTEMPLATE
A través del simple ejemplo anterior, podemos ver que la configuración de acceder a las bases de datos en el arranque de resorte todavía se adhiere a la intención original del marco: simple. Solo necesitamos agregar dependencias de la base de datos a pom.xml y luego configurar la información de conexión en Application.yml. No necesitamos crear un frijol JDBCTemplate como la aplicación Spring, y podemos inyectarlo y usarlo directamente en nuestro propio objeto.
Resumir
Lo anterior es el método de usar JDBCTemplate para conectarse a la base de datos MySQL por Spring Boot y Kotlin, que le presenté. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!