Prefácio
Este artigo explica como usar o Kotlin sob o básico do Spring Boot2 e se integrar e se misturar perfeitamente. Para tornar os leitores mais familiarizados com o açúcar sintático de Kotlin, o autor falará sobre os novos recursos e açúcar sintático de Kotlin em vários artigos futuros. Não vou dizer muito abaixo, vamos dar uma olhada na introdução detalhada
Modifique o arquivo POM e adicione dependências de inicialização da mola.
<Parent> <puerpiid> org.springframework.boot </frugiD> <ArtifactId> Spring-boot-Starter-Parent </ArtifactId> <Versão> 2.0.2.Release </sipers> <RelityPath/> </parent> <Pendencies> <Pendency> <Puperid> org.sPringFramework.Boot </Groupncy> <Pundency> <Puperid> Org.sPringFamework.BoT </Groupncy> <pidency> <pidency> <purbring> org.springframework </groupncy> <rugnency> <pidency> <pidency> org.sPringFramework </parment> <TRAFACTID> Spring-Boot-Starter </starfactId> </pendesicency> <pendence> <puperid> org.springframework.boot </frugiD> <TRARFACTID> Spring-boot-starter-web </ArtifactId> </dependência> <pusency> <voundid> ou ourg.springframework.BoT.BoT.BoT.Brot.BringFamework.Beb </Artifactid> </dependência> <puadent> ourg.springfamework <TarfactId> Spring-Boot-Starter-JDBC </RartifactId> </ndependência> </dependências>
Imediatamente depois, precisamos adicionar dependências MySQL.
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.35</version></dependency><dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.0.14</version></dependency>
Finalmente, adicione a dependência de Kotlin.
<Depencency> <PuerpId> org.Jetbrains.kotlin </frugiD> <stifactId> kotlin-stdlib-jdk8 </artifactId> </dependency> <pendence> <puperid> org.jetbrains.kotlin </groupid> <stifactid> kotlin-rreflectId </Artiftid <GrupidId> org.jetbrains.kotlin </frupid> <TRAFACTID> KOTLIN-STDLIB </RORTIFACTID> </PEEPENCENCIDADE>
Observe que, em Kotlin, a classe de dados não possui um construtor sem parâmetros por padrão, e os padrões da classe de dados para o tipo final e não podem ser herdados. Observe que, se usarmos o modo Spring + Kotlin, o uso do @Autowared poderá encontrar esse problema. Portanto, podemos adicionar Noarg para gerar construtores sem parâmetros como a classe anotada. Use o alopeno para remover o final da classe anotada e permita a herança.
<plugin> <artifactId>kotlin-maven-plugin</artifactId> <groupId>org.jetbrains.kotlin</groupId> <version>${kotlin.version}</version> <executions> <execution> <id>compile</id> <goals> <goal>compile</goal> </goals> </execution> <execution> <ID> test-compile </dod> <gestes> <lect> test-compile </as Goal> </metas> </secution> </secution> </secution> </secution> <pendes> <pendencency> <voupid> org.jetbrains.kotlin </groupid> <TifactId> kotlin--mavenn-on-narg <skotlin </groupid> <Tifactid> <Versão> $ {Kotlin.version} </sistER> </dependency> <pendency> <puperid> org.jetbrains.kotlin </groupiD> <TRARFACTID> KOTLIN-MAVEN-ALOPEN </Artifactid> <Versão> $ {Kotlin.Version} </Version> </dependência>Neste ponto, o ambiente de dependência do nosso Maven foi configurado aproximadamente. Para o código -fonte completo, você pode consultar o repositório do GitHub no final do artigo.
Usando a configuração padrão da inicialização da primavera, você não precisa criar um feijão DataSource e JDBCTemplate.
Configure as informações da fonte de dados em SRC/Main/Recursos/Application.Properties.
spring.dataSource.driver-class-name = com.mysql.jdbc.driverspring.dataSource.url = jdbc: mysql: // localhost: 3307/springboot_dbspring.datasource.username = rootspring.datasource.passource.string
Configure as informações da fonte de dados em SRC/Main/Resources/Config/Source.Properties.
# mysqlsource.driverclassName = com.mysql.jdbc.driversource.url = jdbc: mysql: // localhost: 3306/springboot_dbsource.username = rootsource.password = root = root = raiz
Aqui, crie DataSource e JDBCTemplate.
@Configuration @EnabetRansactionManagement @PropertySource (Value = *Arrayof ("ClassPath: config/fonte.properties")) Classe aberta beanConfig {@AUTOWIRED PRIVADO LATTERINIT VAR ENVN: Ambiente @Bean Open Fun DataSource (): DataSource {Val DataSource = DruidDataSource (): DataSource {Val DataeRce = DruidDataSo Envi !!. jdbcTemplate (): jdbcTemplate {val jdbcTemplate = jdbcTemplate () jdbctemplate.dataSource = DataSource () return jdbctemplate}}}Primeiro, inicialize o script SQL necessário.
Criar banco de dados /*! 32312 se não existir* /`Springboot_db` /*! 40100 Definir caracteres padrão utf8* /; Use `Springboot_db`; Tabela de soltar se existe `t_author`; Criar tabela `t_author` (` id` bigint (20) não assinado não nulo auto_increment Comentário 'ID do usuário', `real_name` varchar (32) não nulo comentário 'nome de usuário',` `` `` `` `` `` `` `` ”)
Autor da classe {var id: long? = nulo var realname: string? = NULL VAR NENHAMENTO: String? = nulo} Interface Authordao {Fun ADD (Autor: Autor): Int Fun Update (Autor: Autor): Int Fun Delete (ID: Long): Int Fun Finalizador (ID: Long): Autor? Finalmente FindAuthorList (): List <oril>}Vamos definir a classe de implementação e acessar os dados através do JDBCTemplate.
@RepositoryOPen Classe AuthordaoImpl: Authordao {@aUTowired Private LateInit var jdbcTemplate: JDBCTemplate Substitua Fun ADD (Author: Author): int {return jdbctemplate.Update ("insert in t_author (real_name, nick_name) (? Fun Update (autor: autor): int {return jdbctemplate.UpDate ("Atualize t_author Set real_name =?, nick_name =? Onde id =?", *Arrayof (Author.RealName, Author.nickName, Author.id))} Substitua delete (idiat): Int {Return Jdb, ? ", Id)} Substitua FindAuthor Fun (id: Long): Autor? {Val list = jdbctemplate.query <orildor> ("selecione * de t_author onde id =?", Arrayof <bome> (id), beanpropertyRowmapper (autor :: class.java)) Lista de retorno? .get (0); } substituir FUN FINDAUTHORLIST (): List <oril> {return jdbctemplate.query ("Selecione * de t_author", Arrayof (), BeanPropertyRowmapper (Autor :: Class.java))}}}} Interface AuthorService {Fun ADD (Autor: Autor): Int Fun Atualize (Autor: Autor): Int Fun Delete (ID: Long): Int Fun Finalizador (ID: Long): Autor? Finalmente FindAuthorList (): List <oril>}Vamos definir a classe de implementação. A camada de serviço chama o método da camada DAO. Esta é uma rotina típica.
@Service ("AuthorService") Open Class AuthorServiceImpl: AuthorService {@AUTOWIRed Private LateInit var Authordao: Authordao Substitua Fun Update (Author: Author): int {return this.authordao.Update (Author)} Substitua Fun: Autor: Autor): {ReturnAthortHor.aThate (Author)} Aubrador add (autor: Autor): {ReturnAthorth {ReturnAtHorO {return this.authordao.delete (id)} Substitua o FindAuthor Fun (id: long): autor? {return this.authordao.findauthor (id)} Substitua FindAuthorList (List <orthyPara mostrar o efeito, primeiro definimos um simples conjunto de interfaces de API RESTful para teste.
@RestController@RequestMapping(value = "/authors")class AuthorController { @Autowired private lateinit var authorService: AuthorService /** * Query user list*/ @RequestMapping(method = [RequestMethod.GET]) fun getAuthorList(request: HttpServletRequest): Map<String, Any> { val authorList = this.authorService.findauthorList () val param = hashmap <string, qualquer> () param ["total"] = autorList.size param ["linhas"] = autorlist retornar param}/*** consulta Informações do usuário*/@ReQuestMapping (value "/{{{//) fETATHM [@ReQuestMapp ("/{{UserID: // d+} " Longo, solicitação: httpServletRequest): autor {return autorsservie.findauthor (userID) ?: LIME RUNTimeException ("Erro de consulta")} / *** novo método* / @requestMapping (Method = [requestmethod.post]) add (@RequestBody JSONBOTCJET: JSONOBJETO) {requestmethod.post]) add (@RequestBody JSONBJET: realname = jsonObject.getString ("real_name") val, apelido = jsonObject.getString ("nick_name") val autor = autor () autor.id = java.lang.long.valueof (userId) autor.realname = realname autor.nickname = names {aTerId) Autor.Art.Art.Art.Alname = realName Author.nickName (name »datty (the userr) RUNTimeException ("novo erro")}}/*** Método de atualização*/@RequestMapping (value = "/{userId: // d+}", método = [requestmethod.put]) update (@PathVariable UserID: Long, @RequestBody JsonObject: JsonObject) (Var AuthorThuthUtRice.Ather.Futher.FUTHUTHER.FUSTRICE: @REQUESTBODY jsonObject.getString ("real_name") val, apelido = jsonObject.getString ("nick_name") tente {if (autor! = null) {autor.realname = realname autor.nickname = apelido this.authorService.Update (autor)}} catch (e: e:) {excepction) {excepctionExt) {uptlet*** Método*/@RequestMapping (value = "/{userId: // d+}", método = [requestMethod.delete]) FUNLETE DELETE (@PathVariable UserID: long) {Try {this.authorService.Delete (userId)} Catch (e: Exception) {Throw RunTimeException (Dellete Errorlete ")Finalmente, executamos o programa através do SpringkotlinApplication.
@SpringbooTApplication (scanBasePackages = ["com.lianggzone.demo.kotlin"]) Classe aberta SpringkotlinApplication {Fun Main (Args: Array <tring>) {springappatication.run (springkotlinapplication: Class.java, *args)}Aqui, o autor recomenda o cliente de descanso do editor da Idea. O cliente do editor da Idea foi suportado na versão Intellij Idea 2017.3 e adicionou muitos recursos na versão de 2018.1. De fato, é um plug -in HTTP Client para Intellij Idea. Veja outro artigo anterior para mim: testando rapidamente novas habilidades para interfaces de API
### Lista de usuários de consulta Get http: // localhost: 8080/autorsaccept: Application/jsonContent-Type: Application/json; Charset = UTF-8 ### Informações do usuário da consulta/JSONCONTP: // LocalHost: 8080/Authors/15Ccept: http: // localhost: 8080/autorscontent-type: Application/json {"user_id": "21", "real_name": "liang guizhao", "nick_name": "liang guizhao"} ####} update put httttp: // localhost: 8080 8080: "real_name": "lianggzone", "nick_name": "lianggzone"}#### excluir método excluir http: // localhost: 8080/autores/21Acept: Application/jsonContent-type: Application/json; Charset = utf-8Através do caso simples acima, descobrimos que é muito fácil integrar Kotlin pela Spring Boot e simplificar o processo inicial de construção e desenvolvimento de aplicações de mola. Para tornar os leitores mais familiarizados com o açúcar sintático de Kotlin, o autor falará sobre os novos recursos e açúcar sintático de Kotlin em vários artigos futuros.
código -fonte
Exemplos relacionados Código completo: Spring-Kotlin-Samples (download local)
Ok, o acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.