Introduzi alguns exemplos de camadas da Web, incluindo a criação de uma API RESTful e a renderização de uma visualização da Web usando o mecanismo de modelo ThymEleaf, mas esses conteúdos não são suficientes para criar um aplicativo dinâmico. Geralmente, quer fabriquemos aplicativos ou aplicativos da Web, precisamos de conteúdo e o conteúdo geralmente é armazenado em vários tipos de bancos de dados. Depois de receber a solicitação de acesso, o servidor precisa acessar o banco de dados para obter e processá -lo em um formulário de dados exibido para os usuários.
Este artigo apresenta exemplos de configuração de fontes de dados em Spring Boot e escrevendo acesso de dados através do JDBCTemplate.
Configuração da fonte de dados
Quando acessamos o banco de dados, precisamos configurar primeiro uma fonte de dados. A seguir, são apresentados vários métodos diferentes de configuração de banco de dados.
Primeiro, para se conectar ao banco de dados, você precisa introduzir suporte ao JDBC e a seguinte configuração é introduzida no Build.gradle:
Compile "org.springframework.boot: spring-boot-starter-jdbc: $ spring_boot_version"
Conectar -se a fontes de dados
Tomando o banco de dados MySQL como exemplo, primeiro apresente o pacote de dependência de conexão MySQL e adicione -o ao 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 Dependências {ClassPath "Org.Jetbrains.Kotlin: Kotlin-Gradle-Plugin: $ Kotlin_Version" ClassPath ("org.springframework.boot: Spring-Boot-Gradle-Plugin: $ Spring_Boot_version") // Kotlin integra o parâmetros de defesa de troca de all springboot para o parâmetros de defesa do troca de troca de troca ClassPath ("Org.Jetbrains.Kotlin: Kotlin-noarg: $ kotlin_version") ClassPath ("org.Jetbrains.kotlin: Kotlin-allopen: $ kotlin_version")}} aplicar plugin: 'Kotlin'Applly Plugin: "Kotlin-spring" //}, veja o plugin:' Kotlin'Applyply: " https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-pluginapply plugin: 'org.springframework.Boot'jar {Basename =' Capítulo11-1-1-service 'versão = 0.1.0 Compile "org.Jetbrains.kotlin: Kotlin-stdlib-jre8: $ kotlin_version" compile "org.springframework.boot: spring-boot-starter-web: spring_boot_version" compile "org.springframework.boot: spring-starter- starter- "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" kotlin " kotlinoptions.jvmtarget = "1.8"} CompileTestkotlin {KotLinOptions.jvmtarget = "1.8"}Configurar informações da fonte de dados em SRC/Main/Recursos/Application.yml
Spring: DataSource: URL: JDBC: MySQL: // localhost: 3306/Teste Nome de usuário: Raiz Senha: 123456 Nome da classe de driver: com.mysql.jdbc.driver
Conecte -se à fonte de dados JNDI
Ao implantar um aplicativo em um servidor de aplicativos, você pode usar o seguinte método de configuração para introduzir a fonte de dados JNDI.
Se você não sabe muito sobre Jndi, consulte https://baike.baidu.com/item/jndi/3792442?fr=aladdin
spring.dataSource.jndi-name = java: jboss/datasources/clientes
Use JDBCTemplate para operar o banco de dados
O JDBCTemplate da Spring é configurado automaticamente e você pode usar o @Autowired para injetá -lo em seu próprio feijão.
Por exemplo: estamos criando uma tabela de usuários, incluindo ID de atributos, nome e idade. Vamos escrever objetos de acesso a dados e casos de teste de unidade.
Defina uma interface abstrata que contém inserção, exclusão e consulta.
Interface UserService { / *** Obtenha o número total de usuários* / AllUsers Val: int? / *** Adicione um novo usuário* Nome @param* @param Age*/ Fun Create (Nome: String, Senha: String?)/ *** Exclua um usuário alto de acordo com o nome* @param nome*/ FUN DELETEBYNAME (Nome: String)/ *** Exclua todos os usuários*/ FUN DELETEALLUSERS ()}Implementar operações de acesso a dados definidas no UserService através do JDBCTemplate
importar org.springframework.beans.factory.annotation.autowiredimport org.springframework.jdbc.core.jdbctemplateimport org.springframework.tereotype.service/*** Criado por http://quanke.name em 2018/110 */ @ServiceClass UserServiceImpl: UserService {@AUTOWIRED VAL JDBCTEMPLATE: JDBCTemplate? = Substituir nulo Val AllUser: Int? get () = jdbcTemplate !!. QueryForObject ("Selecione contagem (1) do usuário", int :: class.java) substituir Fun Create (Nome: String: Senha: String?) {JdbcTemplate !!. Atualize (inserir no usuário (nome do usuário, senha) (?) ")" Nome)}}} jdbcTemplate !!. Atualize ("Exclua do usuário onde o nome de usuário =?", nome)} Substitua Fun DeleTeallLusers () {JDBCTemplate !!. Update ("delete do usuário")}}Crie casos de teste de unidade para o UserService verificar a correção das operações de banco de dados criando, excluindo e consultando.
/*** Criado por http://quanke.name em 2018/1/9. */@Runwith (springrunner :: classe) @springboottestclass ApplicationTests {val log = logFactory.getLog (ApplicationTests :: Class.java) !! @AUTOWIRED LATELINIT Var Userservice: UserService @test FUN `JDBC Test" `() {Val UserName =" Quanke "Val Password =" 123456 "// Insira 5 Usuários do Usuários.Create (" $ USERNAME A "$ senha 1") UserSevice.create ("username B" B "", "$ senha 1") usuários.create.create ("username B" B "", "$" $ ") UserSevice.create (" username B "B" "," $ senha 1 ") Usuários.create.create (" username b "b" "," $ senha 1 ") usuários.create.create (" username b "b" b "", $ senha 1 ". "$password 3") userService.create("$username d", "$password 4") userService.create("$username e", "$password 5") log.info("Total users${userService.allUsers}") // Delete two users userService.deleteByName("$username a") userService.deleteByName("$username b") log.info ("Usuário total $ {userservice.allusers}")}}O JDBCTemplate introduzido acima é apenas algumas das operações mais básicas. Para obter mais informações sobre o uso de outras operações de acesso a dados, consulte: JDBCTemplate API
Através do exemplo simples acima, podemos ver que a configuração dos bancos de dados de acesso ao Spring Boot ainda adere à intenção original da estrutura: simples. Precisamos adicionar apenas dependências de banco de dados ao pom.xml e, em seguida, configurar as informações de conexão no Application.yml. Não precisamos criar um feijão JDBCTemplate como o aplicativo Spring, e podemos injetar e usá -lo diretamente em nosso próprio objeto.
Resumir
O exposto acima é o método de usar o JDBCTemplate para conectar -se ao banco de dados MySQL pela Spring Boot e Kotlin, que eu apresentei a você. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!