No artigo anterior, os princípios básicos e o uso da bota da primavera foram explicados por meio de um simples programa Helloworld. Este artigo explica principalmente como acessar o banco de dados através da Spring Boot. Este artigo demonstrará três maneiras de acessar o banco de dados. O primeiro é o JDBCTemplate, o segundo é JPA e o terceiro é Mybatis. Como mencionado anteriormente, esta série usará um sistema de blog como base para explicação, portanto este artigo explicará o armazenamento e o acesso do artigo (mas não inclui os detalhes do artigo). Como a implementação final é concluída através do Mybatis, apenas uma demonstração simples do JDBCTemplate e JPA será feita, e a parte Mybatis implementará completamente a adição, exclusão, modificação e pesquisa do artigo.
1. Preparação
Antes de demonstrar esses métodos, você precisa preparar algo primeiro. O primeiro é o banco de dados. Este sistema é implementado usando o MySQL. Precisamos criar uma tabela de tb_article primeiro:
DROP TABLE IF EXISTS `tb_article`;CREATE TABLE `tb_article` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `title` varchar(255) NOT NULL DEFAULT '', `summary` varchar(1024) NOT NULL DEFAULT '', `status` int(11) NOT NULL DEFAULT '0', `type` int(11) NOT NULL, `user_id` bigint (20) não nulo padrão '0', `CREATE_TIME` Timestamp NÃO NULL NULL Current_timestamp,` update_time` timestamp NÃO NULL padrão Current_timestamp, `public_time` timestamp NOUN NULL Padrent_timestamp, chave primária (` id`)) mecan
Na demonstração subsequente, esta tabela será adicionada, excluída, modificada e verificada. Você deve ver que não há detalhes do artigo nesta tabela. O motivo é que os detalhes do artigo são relativamente longos. Se colocado nesta tabela, afetará facilmente a eficiência de consultar a lista de artigos, para que os detalhes do artigo sejam armazenados em outra tabela separadamente. Além disso, precisamos configurar o pool de conexão do banco de dados. Aqui usamos o pool de conexão Druid. Além disso, o arquivo de configuração é configurado usando YAML, ou seja, Application.yml (você também pode usar o arquivo de configuração do Application.Properties. Não há grande diferença. Se você não está familiarizado com o YMAL e está interessado, pode conferir, o que é relativamente simples). A configuração do pool de conexão é a seguinte:
Spring: DataSource: URL: JDBC: MySQL: //127.0.0.1: 3306/blog? useunicode = true & caracterEncoding = utf-8 & usessl = falserclassName: com.mysql.jdbc.driver usename: root senha: 123456 tipo: com.mysql.jdb.dbriver usename: root senha: 12346
Por fim, também precisamos estabelecer uma classe Pojo correspondente ao banco de dados, o código é o seguinte:
Public classe Artigo {Private Long Id; título de sequência privada; Resumo de String Private; data privada createTime; Data privada Publictime; Data privada UpdateTime; private Long UserID; status inteiro privado; Tipo inteiro privado;}Ok, esse é todo o trabalho que você precisa preparar e agora comece a implementar a operação do banco de dados.
2. Integração com JDBCTemplate
Primeiro, primeiro acessamos o banco de dados através do JDBCTemplate. Aqui apenas demonstramos a inserção de dados. Conforme mencionado no artigo anterior, a Spring Boot fornece muitos iniciantes para suportar diferentes funções. Para apoiar o JDBCTemplate, precisamos apenas apresentar o seguinte iniciador:
<Depencency> <PuerpId> org.springframework.boot </frugiD> <TRATIFACTID> Spring-boot-starter-jdbc </artifactId> </dependency>
Agora podemos implementar a inserção de dados através do JDBCTemplate:
interface pública articledao {long inserttarticle (artigo do artigo);} @repositorypublic classe articledaojdbctemplateImpl implementa articledao {@aUTowired Private denometeCarameterjdbctemplate jdbctemplate; @Override Public Long Inserttarticle (artigo do artigo) {String sql = "Inserir em tb_article (título, resumo, user_id, create_time, public_time, update_time, status)" + "valores (: título ,: resumo ,: userID ,: CreateTime ,: publicTime ,:: atualização, :: status)"; Mapa <string, object> param = new hashmap <> (); param.put ("title", artigo.getTitle ()); param.put ("resumo", artigo.getSummary ()); param.put ("userID", artigo.getUserId ()); param.put ("status", artigo.getStatus ()); param.put ("CreateTime", artigo.getCreateTime ()); param.put ("CreateTime", artigo.getCreateTime ()); param.put ("PublicTime", Article.getPublictime ()); param.put ("updateTime", artigo.getUpDateTime ()); return (longo) jdbctemplate.update (sql, param); }}Usamos o Junit para testar o código acima:
@Runwith (springjunit4classrunner.class) @springboottest (classes = Application.class) classe pública articleDaotest {@AUTOWIRED PRIVADO ARTICLEDAO ARTICLEDAO; @Test public void testInsert () {artigo do artigo = novo artigo (); artigo.setTitle ("Título do teste"); artigo.SetSummary ("Resumo do teste"); artigo.setUserID (1L); artigo.SetStatus (1); artigo.setCreateTime (new Date ()); artigo.SetUpDateTime (new Date ()); artigo.setPublictime (new Date ()); articledao.InserTarticle (artigo); }}Para apoiar o programa de teste acima, você também precisa apresentar um acionador de partida:
<Ependency> <GrupidId> org.springframework.boot </frugiD> <ArtifactId> Spring-boot-Starter-test </sutifactId> <cope> Test </schope> </dependency>
A partir do código acima, podemos ver que, de fato, basicamente não há configuração, exceto a introdução do início do JDBC. Este é o processo de configuração automática da inicialização da mola. O código acima precisa prestar atenção à localização da classe de aplicativo. Esta classe deve estar localizada no pacote pai da classe DAO. Por exemplo, o DAO está localizado no pacote com.pandy.blog.dao. Agora, movemos a classe Application.java do pacote com.pandy.blog para o pacote com.pandy.blog, e o seguinte erro será exibido:
Causado por: org.springframework.beans.factory.nosuchbeandEfinitionException: nenhum feijão qualificado do tipo 'com.pandy.blog.dao.articledao' disponível: esperado pelo menos 1 bean que se qualifica como candidato da AutoWire. Anotações de dependência: {@org.springframework.beans.factory.annotation.autowired (requerir = true)} em org.springframework.beans.factory.support.defaultListableBeanFactory.raisenomatchingBeanfound (DefullableBeanFactory.Java.Java.JAVA.JAVA.RAISENOMATCHINGBean9 org.springframework.beans.factory.support.defaultListableBeanFactory.DORESOLVEDEPENDÊNCIA (DefaultListableBeanFactory.java:1104) em org.springframework.bean.factory.support.DefaultBeanBeanFactory.ResFramework.BeanS.Factory.support.DefaultBeanBeanFactory.RSOUNDWORK.Beank.Factory.Support.DefaultBeanBeanBeNtorywork org.springframework.beans.factory.annotation.autowiredannotationBeanPostProcessor $ automáticoEm outras palavras, a implementação de Articledao não pode ser encontrada. Qual é o motivo? Na postagem anterior do blog, vimos que a anotação @springbootaplication herda @ComponentsCan, que apenas digitaliza os pacotes e subpackagens em que a classe de aplicativo está localizada por padrão. Portanto, para o erro acima, além de manter a classe de aplicativo no pacote pai da DAO, você também pode especificar o pacote digitalizado para resolver:
@Springbootapplication@componentscan ({"com.pandy.blog"}) public class Application {public static void main (string [] args) lança exceção {springapplication.run (application.class, args); }}3. Integração com JPA
Agora começaremos a explicar como implementar operações de banco de dados através do JPA. Ainda é semelhante ao JDBCTemplate. Primeiro, precisamos apresentar o iniciador correspondente:
<Depencency> <PuerpId> org.springframework.boot </frugiD> <stifactId> primavera-boot-starter-data-jpa </stutifactId> </dependency>
Em seguida, precisamos adicionar anotação de entidades à classe Pojo e especificar o nome da tabela (se não for especificado, o nome da tabela padrão é o artigo) e, em seguida, precisamos especificar o ID e sua estratégia de geração. Tudo isso é conhecimento JPA e não tem nada a ver com a inicialização da primavera. Se você não estiver familiarizado com isso, pode olhar para os pontos de conhecimento da JPA:
@Entity (name = "tb_article") Artigo da classe pública {@id @generatedValue Private Long Id; título de sequência privada; Resumo de String Private; data privada createTime; Data privada Publictime; Data privada UpdateTime; private Long UserID; status inteiro privado;}Finalmente, precisamos herdar a classe jparepository. Aqui implementamos dois métodos de consulta. A primeira é uma consulta que está em conformidade com a especificação de nomeação JPA. A JPA nos ajudará automaticamente a concluir a geração de declarações de consulta. A outra maneira é implementar o JPQL (uma consulta do tipo SQL suportada pelo JPA).
interface pública articlerepository estende jparepository <artigo, long> {public list <trus> findbyuserId (long userID); @Query ("Selecione Art em com.pandy.blog.po.article Art Where title =: title") Lista pública <Artigo> querybytitle (@param ("title") título da string);}Ok, podemos testar o código acima novamente:
@Runwith (springjunit4classrunner.class) @springboottest (classes = Application.class) public class ArticleRepositoryTest {@AUTOWIRED ARTICLEREPOSIENTE DE ARTICLEREPOSIENTO DE ARTICLEREPOSIITY; @Test public void testQuery () {list <Tritter> articleList = articlerepository.QueryByTitle ("Título do teste"); assertTrue (articlelist.size ()> 0); }}Observe que ainda existem problemas semelhantes ao JDBCTemplate aqui. Você precisa tornar a aula de inicialização do aplicativo não no pacote pai de classes de repositório e entidade, caso contrário, o seguinte erro será exibido:
Causado por: org.springframework.beans.factory.nosuchbeandEfinitionException: Nenhum feijão qualificado do tipo 'com.pandy.blog.dao.articlerepository' disponível: esperado pelo menos 1 feijão que se qualifica como candidato da Autowire. Anotações de dependência: {@org.springframework.beans.factory.annotation.autowired (requerir = true)} em org.springframework.beans.factory.support.defaultListableBeanFactory.raisenomatchingBeanfound (DefullableBeanFactory.Java.Java.JAVA.JAVA.RAISENOMATCHINGBean9 org.springframework.beans.factory.support.defaultListableBeanFactory.DORESOLVEDEPENDÊNCIA (DefaultListableBeanFactory.java:1104) em org.springframework.bean.factory.support.DefaultBeanBeanFactory.ResFramework.BeanS.Factory.support.DefaultBeanBeanFactory.RSOUNDWORK.Beank.Factory.Support.DefaultBeanBeanBeNtorywork org.springframework.beans.factory.annotation.autowiredannotationBeanPostProcessor $ automáticoObviamente, você também pode especificar o pacote JPA digitalizado anotando @enablejparepositories, mas ainda não funciona, e o seguinte erro aparecerá:
Causado por: java.lang.illegalargumentException: não é um tipo gerenciado: classe com.pandy.blog.po.article em org.hibernate.jpa.internal.metamodel.metamodelimpl.managedtype (metamodelimpl.java:210) em org.springframework.data.jpa.repository.support.jpametamodElentityInformation org.springframework.data.jpa.repository.support.jpaentityInformationsupport.getEntityInformation (jpaentityInformationsupport.java:68) em org.springframework.data.jpa.repository.support.jparepositoryfactory.getEntityInformation (jparepositoryfactory.java:153) em org.springframework.data.jpa.repository.support.jparepositoryfactory.getTargetRepository (jparepositoryfactory.java:100) em org.springframework.data.jpa.repository.support.jparepositoryfactory.getTargetRepository (jparepositoryfactory.java:82) em org.springframework.data.repository.core.support.repositoryfactorysupport.getRepository (repositoryfactorysupport.java:199) em org.springframework.data.repository.core.support.repositoryFactoryBeansupport.initandreturn (RepositoryFactoryBeansupport.java:277) em org.springframework.data.repository.core.support.repositoryFactoryBeansupport.afterPropertiesset (repositórioFactoryBeansupport.java:263) em org.springframework.data.jpa.repository.support.jparepositoryFactoryBean.afterPropertiesset (jparepositoryFactoryBean.java:101) em org.springframework.beans.factory.support.abstractaUTowirecAcleBeanFactory.invokeInitMethods (abstractaUTowirecAbleBeanFactory.java:1687) em org.springframework.beans.factory.support.abstractraToTowirecAcleBeanFactory.initializeBean (abstractaUTowirecAcleBeanFactory.java:1624) ... 39 mais
Este erro indica que a entidade não pode ser reconhecida; portanto, você também precisa especificar o pacote de entidades anotando @entityScan. A configuração final é a seguinte:
@Springbootapplication@componentscan ({"com.pandy.blog"})@enableJparePositories (bashepackages = "com.pandy.blog")@entityscan ("com.pandy.blog") public class Application {public static void main (string. [] args) slows throws {springslatication }}4. Integração com Mybatis
Por fim, vamos dar uma olhada em como obter acesso ao banco de dados através do MyBatis. Da mesma forma, ainda precisamos apresentar o iniciador:
<Depencency> <PuerpId> org.mybatis.spring.boot </groupiD> <TRAFACTID> mybatis-spring-boot-starter </artifactid> <versão> 1.1.1 </version> </pendence>
Como o motor de partida não é oficialmente fornecido pela Spring Boot, o número da versão é inconsistente com a bota da primavera e precisa ser especificado manualmente.
Mybatis geralmente pode especificar o SQL que opera bancos de dados por meio de XML ou anotações. Pessoalmente, eu prefiro XML, então este artigo demonstra apenas o acesso a bancos de dados através do XML. Primeiro, precisamos configurar o diretório do mapeador. Nós o configuramos no application.yml:
Mybatis: Config-Locations: mybatis/mybatis-config.xml Mapper-Locations: mybatis/mapper/*. Xml tipo-aliases-package: com.pandy.blog.po
A configuração aqui inclui principalmente três partes, uma é algumas configurações do próprio Mybatis, como alias para tipos básicos. O segundo é especificar a localização do arquivo mapeador, e o terceiro é o alias da classe Pojo. Essa configuração também pode ser implementada através da configuração Java. Devido a problemas de espaço, não explicarei em detalhes aqui. Amigos interessados podem implementá -lo sozinhos.
Após a configuração, primeiro escrevemos a interface do mapeador:
interface pública ArticleMapper {public Long Inserttarticle (artigo do artigo); public void updatearticle (artigo do artigo); Artigo público QuerybyId (Long ID); Lista pública <Artigo> QueryarticlesBypage (@param ("artigo") Artigo do artigo, @param ("Pagesize") int PageSize, @param ("offset") int offset);}Essa interface define temporariamente apenas quatro métodos, a saber, adicionando, atualizando e consultando com base em ID e paginação. Esta é uma interface e é semelhante ao JPA, para que você não precise implementar classes. Em seguida, escrevemos um arquivo XML:
<? xml versão = "1.0" coding = "utf-8"?> <! namespace="com.pandy.blog.dao.ArticleMapper"> <resultMap id="articleMap" type="com.pandy.blog.po.Article"> <id column="id" property="id" jdbcType="INTEGER"/> <result column="title" property="title" jdbcType="VARCHAR"/> <result coluna = "resumo" propriedade = "resumo" jdbctype = "varchar"/> <resultado column = "user_id" propriedade = "userId" jdbctype = "integer"/> <resultado column = "status" cate = "status" jdbctype = "intelect"/> <timclumn = "cate =" status "" jdbctype = "intelect"/> <timer "_time_time = "status" " <resultado column = "update_time" property = "updateTime" jdbctype = "timestamp"/> <resultado column = "public_time" property = "publicTime" jdbctype = "timestamp"/> </resultMap> <sql id = "base_column"> title _batter, starty, stardMap, status, status, status, status </resultMap> <sql id = "base_column"> title_er_id, status, status. id = "insertArticle" parameterType = "Artigo"> inserir no tb_article (<incluir refid = "base_column"/>) value (#{title},#{summary},#{userId},#{status},#{} "},#{upTeTime},#{status {}, {}},},#{upTeTime} ParameterType = "Artigo"> Atualize tb_article <Set> <se test = "title! = null"> title = #{title}, </if> <if test = "summary! = null"> sumy = #{sumy}, </if> <se test = "test! #{publicTime}, </if> <if test = "updateTime! = null"> update_time = #{updateTime}, </if> </set> where id = #{id} </update> <select id = "querybyId" parameterType = "Long" result = "" ATCLEMAP "> tb_article where id = #{id} </select> <select id = "Queryarticlesbypage" resultMap = "articleMap"> selecione ID, <incluir refid = "base_column"> </bitcle> de tb_article <where> <se test = "artigo.title! test = "Artigo.UserID! = NULL"> user_id = #{artigo.userId} </if> </where> limite #{Offset}, #{paGaSize} </select> </mapper>Por fim, precisamos especificar manualmente os pacotes digitalizados pelo mapeador:
@Springbootapplication@mapperscan ("com.pandy.blog.dao") public class Application {public static void main (string [] args) lança exceção {springapplication.run (application.class, args); }}OK, a integração com Mybatis também está concluída, vamos testá -lo novamente:
@Runwith (springjunit4classrunner.class) @springboottest (classes = Application.class) public class ArticleMappertest {@AUTOWIRED PRIVADO ARTICLEMAPPER MAPPER; @Test public void testInsert () {artigo do artigo = novo artigo (); artigo.setTitle ("Título 2 do teste"); artigo.SetSummary ("Resumo do teste 2"); artigo.setUserID (1L); artigo.SetStatus (1); artigo.setCreateTime (new Date ()); artigo.SetUpDateTime (new Date ()); artigo.setPublictime (new Date ()); mapper.InserTarticle (artigo); } @Test public void testMyBatisQuery () {artigo do artigo = mappper.QueryById (1L); assertnotNull (artigo); } @Test public void testUpDate () {artigo do artigo = mappper.QueryById (1L); artigo.setPublictime (new Date ()); artigo.SetUpDateTime (new Date ()); artigo.SetStatus (2); Mapper.UpDatearticle (artigo); } @Test public void testQueryBypage () {artigo do artigo = novo artigo (); artigo.setUserID (1L); List <Track> List = Mapper.QueryarticlesByPage (artigo, 10,0); assertTrue (list.size ()> 0); }}5. Resumo
Este artigo demonstra a integração do Spring Boot com JDBCTemplate, JPA e Mybatis. No geral, a configuração é relativamente simples. Os alunos que fizeram configurações relacionadas antes devem sentir que é óbvio. A Spring Boot realmente nos forneceu grande ajuda a esse respeito. Nos artigos subsequentes, usaremos apenas o MYBATIS para executar operações de banco de dados. Outra coisa a observar aqui é que a consulta de paginação de Mybatis é manuscrita aqui. Essa paginação pode ser concluída através de plug-ins durante o desenvolvimento formal, mas isso não tem nada a ver com a inicialização da primavera; portanto, este artigo usa temporariamente esse método manual para realizar o processamento de paginação.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.