Prefacio
Este artículo explica cómo usar Kotlin bajo los conceptos básicos de Spring Boot2, e integrarse perfectamente y mezclar perfectamente. Para hacer que los lectores estén más familiarizados con el azúcar sintáctico de Kotlin, el autor hablará sobre las nuevas características y el azúcar sintáctico de Kotlin en varios artículos futuros. No diré mucho a continuación, echemos un vistazo a la introducción detallada
Modifique el archivo POM y agregue dependencias de arranque de resorte.
<Parent> <MoupRoD> org.springframework.boot </proupid> <artifactid> spring-boot-starter-parent </arfactid> <versers> 2.0.2.release </lection> <lelativePath/> </parent> <pendencies> <pendency> <proupid> org.pringframework.boot </proupid> <artifactid> spring-boot starter </artifactid> </pendency> <pendency> <uproupid> org.springframework.boot </groupid> <artifactid> spring-boot-starter-web </artifactid> </dependency> <epartency> <uproupid> org.springframe.boot </groupid> <artifactID> spring-boot-starter-jdbc </artifactid> </dependencia> </pendencs>
Inmediatamente después, necesitamos agregar dependencias de MySQL.
<Spendency> <MoupRoD> MySQL </groupid> <artifactId> mysql-confonnector-java </arfactid> <versión> 5.1.35 </versión> </pendency> <pendency> <proupId> com.alibaba </groupId> <artifactid> druid </artifactid> <lansione 1.0.14 </versión> </versión> </versión>
Finalmente, agregue la dependencia de Kotlin.
<Spendency> <MoupRoD> org.jetbrains.kotlin </groupid> <artifactid> kotlin-stdlib-jdk8 </artifactid> </pendency> <pendency> <grupoD> org.jetbrains.kotlin </proupId> <artifactid> kotlin-reflectect </artifactid> </dependency> <pendency> <MoupRid> org.jetbrains.kotlin </groupid> <artifactid> kotlin-stdlib </artifactid> </dependencia>
Tenga en cuenta que en Kotlin, la clase de datos no tiene un constructor sin parámetros de forma predeterminada, y la clase de datos predeterminada al tipo final y no se puede heredar. Tenga en cuenta que si usamos el modo Spring + Kotlin, entonces usar @Autowared puede encontrar este problema. Por lo tanto, podemos agregar NOARG para generar constructores sin parámetros como la clase anotada. Use AlloPen para eliminar final para la clase anotada y permita la herencia.
<glugin> <artifactid> kotlin-maven-plugin </artifactid> <grupoD> org.jetbrains.kotlin </proupid> <versión> $ {kotlin.version} </versión> <cacuncioS> <Excution> <di> compile </d> <estimátile> <pil> compil <goals> <goal>test-compile</goal> </goals> </execution> </execution> </execution> </execution> <dependencies> <dependency> <groupId>org.jetbrains.kotlin</groupId> <artifactId>kotlin-maven-noarg</artifactId> <version>${kotlin.version}</version> </dependency> <dependency> <MoupRid> org.jetbrains.kotlin </groupid> <artifactid> kotlin-saven-alopen </artifactid> <versión> $ {kotlin.version} </versión> </pendency> </dependencias> </tugin>En este punto, el entorno de dependencia de nuestro Maven se ha configurado más o menos. Para el código fuente completo, puede consultar el repositorio de GitHub al final del artículo.
Usando la configuración predeterminada de Boot Spring, no necesita crear un DataSource y JDBCTemplate Bean.
Configurar información de origen de datos en SRC/Main/Resources/Application.Properties.
spring.datasource.driver-class-name = com.mysql.jdbc.driverspring.datasource.url = jdbc: mysql: // localhost: 3307/springboot_dbspring.datasource.username = rootspring.datasource.password = root = root = root = root = root = root = root = root = root = root = root
Configurar información de origen de datos en SRC/Main/Resources/Config/Source.Properties.
# mySqlSource.driverClassName = com.mysql.jdbc.driversource.url = jdbc: mysql: // localhost: 3306/springboot_dbsource.usernource.password = root
Aquí, cree DataSource y JDBCTemplate.
@Configuration @enableTransactionManagement @PropertySource (value = *ArrayOf ("classpath: config/source.properties")) Abra la clase beanconfig {@aUtowired private lateInit var envítase @Bean Open Fun DataSource (): DataSource {val dataSource = DruidDataSource () dataSource.dRiverClassNameNameName = = = env !!. diversión jdbctemplate (): jdbctemplate {val jdbctemplate = jdbctemplate () jdbctemplate.dataSource = dataSource () return jdbctemplate}}Primero inicialice el script SQL requerido.
Crear base de datos /*! 32312 Si no existe* /`SpringBoot_db` /*! 40100 Conjunto de caracteres predeterminado UTF8* /; Use `springboot_db`; Tabla de caída si existe `t_author`; CREATE TABLE `t_author` ( `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT 'User ID', `real_name` varchar(32) NOT NULL COMMENT 'User name', `nick_name` varchar(32) NOT NULL COMMENT 'User anonymous', PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
Autor de clases {var id: long? = NULL var realName: String? = NULL VAR NOPO: String? = nulo} Interface AuthorDaoo {Fun Add (Autor: Autor): Int Fun Update (Autor: Autor): Int Fun Delete (ID: Long): int Fun FindAuthor (id: Long): Autor? Fun FindAuthorList (): List <After>}Definamos la clase de implementación y accedamos a los datos a través de JDBCTemplate.
@RepositoryOpen Class authordaoImpl: authordao {@aUtowired private lateInit var jdbctemplate: jdbctemplate override diversh add (autor: autor): int {return jdbctemplate.update ("insertar en t_author (real_n_name, nick_name) Valores (?)", Author.RealName, autor). Actualización (Autor: Autor): int {return jdbctemplate.update ("Update t_author set real_name =?, nick_name =? id)} anular diversión FindAuthor (ID: Long): ¿Autor? {val list = jdbctemplate.query <Hauthor> ("Seleccione * de t_author donde id =?", ArrayOf <Any Any> (id), BeanPropertyRowMapper (autor :: class.java)) return List? .get (0); } anular diversión FindAuthorList (): List <After> {return jdbctemplate.query ("Seleccione * de t_author", arrayof (), beanpropertyRowMapper (autor :: class.java))}} Interface AutorService {Fun Add (Autor: Autor): Int Fun Update (Autor: Autor): Int Fun Delete (ID: Long): int Fun FindAuthor (ID: Long): Autor? Fun FindAuthorList (): List <After>}Definamos la clase de implementación. La capa de servicio llama al método de la capa DAO. Esta es una rutina típica.
@Service ("AutorService") Abrir clase AutorServiceImpl: AutorService {@aUtoWired private LateInit var authordao: authordao anular diversión de diversas actualizaciones (autor: autor): int {return this.authordao.Update (autor)} anular diversión add (autor: autor): int {return this.authorda.add (autor)} overeDing (Id: Id: Id: Id: Id: Id: Id: {return this.authordao.delete (id)} anular diversión finhauthor (id: long): autor? {return this.authordao.findauthor (id)} anular diversión finhauthorList (): list <autor> {return this.authordao.findauthorList ()}}Para mostrar el efecto, primero definimos un conjunto simple de interfaces API RESTFUL para las pruebas.
@RestController @requestMapping (value = "/autores") Class AutorController {@AUTOWIREDIREDREDED LATERINIT VAR AUTORSERVICE: AutorService/*** Query User List*/@RequestMapping (método = [requestmethod.get]) divertido getAuthOrlist (request: httpservetReTrequest): map <string, cualquiera> {valerList = {valerList = this.authorservice.findauthorlist () val param = hashmap <string, any> () param ["total"] = autorlist.size param ["filas"] = autorlist return param}/*** consulta información de usuario*/@RequestMapping (valor = "/{userId: // d+}", método = [requestmethod.get] fun fun getAuthor (@pathvArt (@pathvariAnt. UserId: Long, Solicitud: HttpServletRequest): Autor {return AuthorService.findauthor (userId) ?: throw runtimeException ("error de consulta")} / *** new Method* / @RequestMapping (método = [requestmethod.post]) diversión add (@RequestBody jsonObject: jsonObject) {valsererId = = = = = = = = = = = = = = = jsonObject.getString ("user_id") val realName = jsonObject.getString ("real_name") val Nickname = jsonObject.getString ("nick_name") val autor = autor () autor.id = java.lang.long.valueof (userID) Autor.RealName = RealName Author.nickName = Nickname trey { this.authorservice.add (autor)} catch (e: excepción) {throw runtimeException ("nuevo error")}}/*** Método de actualización*/@RequestMapping (valor = "/{useriD: // d+}", método = [requestmethod.put]) Fun Authorly (@PathVariable UserId: long, @Requestbody: JSonObject: JSonObject: JSonObject) this.authorservice.findauthor (userId) val realName = jsonObject.getString ("real_name") val nickname = jsonObject.getString ("nick_name") try {if (autor! = null) {autor.RealName (Ecuenta) Throw RuntimeException ("Error de actualización")}}/*** Eliminar el método*/@RequestMapping (value = "/{userId: // d+}", método = [requestmethod.delete]) diversión (@PathVariable UserId: long) {this {this.authorService.delete (userId)}}}} showeT (selle (treat {trey {this "DelEdlEntEntET (e userId)}} (E: excepción) Error") } }}Finalmente, ejecutamos el programa a través de SpringkotlinApplication.
@SpringBootApplication (ScanBasePackages = ["com.lianggzone.demo.kotlin"]) Open Class SpringkotlinApplication {Fun Main (args: Array <String>) {SpringApplication.run (SpringkotlinApplication :: Class.Java, *args)}}Aquí, el autor recomienda el cliente de REST del editor de Idea. IDEE El editor REST Client ha sido compatible con la versión IntelliJ Idea 2017.3, y ha agregado muchas funciones en la versión 2018.1. De hecho, es un complemento de cliente HTTP para la idea IntelliJ. Vea otro artículo anterior de mí: Probar rápidamente nuevas habilidades para las interfaces API
### Lista de usuarios de la consulta obtenga http: // localhost: 8080/authorSaccept: aplicación/jsonContent-type: aplicación/json; charset = utf-8 ### Información del usuario de la consulta obtenga http: // localhost: 8080/autores/15accept: aplicación/jsoncontent-thype: aplicación/json; charset = utf-8 ##################ext: Aplicación/jsoncontent-thype: aplicación/json; charset = utf-8 #################ext: Aplicación/jSonContent-thype: Aplicación/JSON; Charset = Utf-8 ##. http: // localhost: 8080/authorsContent-type: application/json {"user_id": "21", "real_name": "liang guizhao", "nick_name": "liang guizhao"} ### Actualizar método Pon http: // localhost: 8080/authors/21content-type/jon {jon {json {joni "Real_name": "Lianggzone", "nick_name": "lianggzone"} ### Eliminar método Eliminar http: // localhost: 8080/autores/21acept: aplicación/jsonContent-type: aplicación/json; charset = utf-8A través del caso simple anterior, descubrimos que es muy fácil integrar Kotlin por el arranque de primavera y simplificar el proceso inicial de construcción y desarrollo de las aplicaciones de resorte. Para hacer que los lectores estén más familiarizados con el azúcar sintáctico de Kotlin, el autor hablará sobre las nuevas características y el azúcar sintáctico de Kotlin en varios artículos futuros.
código fuente
Ejemplos relacionados Código completo: Spring-Kotlin-Samples (descarga local)
De acuerdo, lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.