Um novo projeto foi lançado nos últimos dois dias porque os membros da equipe do projeto sempre usaram o Mybatis. Embora eu prefira pessoalmente o modelo minimalista de JPA, o Mybatis ainda está determinado a manter a seleção unificada de tecnologia para manter o projeto. Fui on -line para encontrar informações relevantes sobre a combinação de bota de primavera e mybatis. Existem várias formas, o que deixa as pessoas cansadas de lê -las. Combinando a demonstração e documentos oficiais da Mybatis, finalmente encontrei os dois modos mais simples. Passei um dia resumindo e compartilhando.
A essência da estrutura ORM é simplificar a codificação dos bancos de dados operacionais na programação. Agora restam basicamente duas empresas. Um é afirmar que você não pode escrever uma frase de SQL Hibernate, e o outro é depurar flexivelmente mybatis do SQL dinâmico. Ambos têm suas próprias características e podem ser usadas com flexibilidade de acordo com as necessidades no desenvolvimento do sistema em nível corporativo. Encontrei um fenômeno interessante: a maioria das empresas tradicionais gosta de usar o Hibernate, e a indústria da Internet geralmente usa Mybatis.
A característica do hibernato é que todo o SQL é gerado usando o código Java, e não há necessidade de escrever (leia) o SQL sem sair do programa. Tem integridade de programação. Ele se desenvolve para o topo do modelo. Basicamente, o SQL correspondente pode ser gerado com base no nome do método. Se você não souber muito, pode ler meu artigo anterior sobre o uso do Spring Data JPA.
O Mybatis é muito problemático no estágio inicial, exigindo vários arquivos de configuração, classes de entidade, associações de mapeamento de camadas DAO e muitas outras configurações. Obviamente, Mybatis também descobriu essa desvantagem. No estágio inicial, o gerador foi desenvolvido, que pode produzir automaticamente classes de entidade, arquivos de configuração e código da camada DAO com base nos resultados da tabela, que podem reduzir parte do volume de desenvolvimento; No estágio posterior, muitas otimizações podem ser usadas para usar anotações, gerenciar automaticamente camadas DAO e arquivos de configuração, etc., e o desenvolvimento no topo é o modelo sobre o qual vamos falar hoje. Mybatis-Spring-Boot-Starter é o Springboot+mybatis pode anotar completamente sem arquivos de configuração e também pode ser uma configuração simples e fácil de começar.
Agora pense bem, a bota da primavera é incrível. Contanto que você associe qualquer coisa à Spring Boot, ela simplificará.
Mybatis-Spring-Boot-Starter
Descrição Oficial: Mybatis Spring-Boot-Starter ajudará você a usar Mybatis com a Spring Boot
De fato, o Mybatis desenvolveu uma solução para participar da diversão por causa da bota da primavera tão popular, mas essa realmente resolveu muitos problemas e é de fato muito mais suave de usar. Existem duas soluções principais para Mybatis-Spring-Boot-Starter. Um é usar anotações para resolver todos os problemas, e o outro é a antiga tradição simplificada.
Obviamente, qualquer modo precisa primeiro apresentar o arquivo POM do Mybatis-Spring-Boot-Starter. Agora, a versão mais recente é 1.1.1 (por acaso é o dobro 11 :))
<Depencency> <PuerpId> org.mybatis.spring.boot </groupiD> <TarifactId> mybatis-spring-boot-starter </artifactId> <versão> 1.1.1 </sipers> </dependency>
Vou apresentar dois modelos de desenvolvimento
Sem versão de anotação do arquivo de configuração
É feito com anotações.
1 Adicione arquivos maven relevantes
<Dependences> <pendency> <voundid> org.springframework.boot </groupiD> <TRAFACTID> Spring-boot-starter </stutifactId> </dependency> <pendence> <puperid> org.springframework.boot </groupid> <ArtifactIdidid> </GroupId> ArtiftId > Spring-Boot-Starter-Test </ArtifactId> <cope> Test </schope> </dependency> <pendence> <puperid> org.springframework.boot </foupid> <stifactId> Spring-Boot-Starter-web </stifactId> </pendence> <Depen Dency> <GroupId> org.mybatis.spring.boot </proupId> <TRAFACTID> mybatis-spring-boot-estrelador </stutifactId> <version> 1.1.1 </versão </dependency> <pendency> <rugnid> mySQL </Groupid> <stifactid> mysql OnNector-Java </stifactId> </dependency> <pendency> <voundid> org.springframework.boot </frupidId> <TRAFACTID> spring-boot-devtools </stutifactid> <pptional> true </pecional> </ipendence> </ipendences>
Não vou postar o pacote POM completo aqui, leia o código -fonte diretamente
2. Application.Properties Adicione configurações relevantes
mybatis.type-aliases-package = com.neo.entityspring.dataSource.driverclassName = com.mysql.jdbc.driverspring.dataSource.url = jdbc: mysql: // lochost: 3306/test1? uso = rootspring.datasource.password = root
O Springboot carregará automaticamente a configuração relevante do spring.dataSource.*, E a fonte de dados será injetada automaticamente no SQLSessionFactory. O SQLSessionFactory será injetado automaticamente no mapeador. A propósito, você não precisa se preocupar com tudo, basta pegá -lo e usá -lo.
Adicione uma varredura de pacote de mapeador na aula de inicialização @MapperScan
@SpringbootApplication@mapperscan ("com.neo.mapper") public class Application {public static void main (string [] args) {springapplication.run (application.class, args);}}Ou apenas adicione anotação @mapper na classe Mapper. Recomenda -se usar o acima, caso contrário, será bastante problemático adicionar anotação a cada mapeador.
3. Desenvolva mapeador
O terceiro passo é a parte mais crítica, e a produção de SQL está aqui
interface pública UserMApper {@Select ("Selecione * FROM USUERS")@Resultados ({@resultado (Property = "Uservax", Column = "User_Sex", Javatype = Uservaxenum.class),@resultado (Property = "ANDENAMENTO", Column = "Nick_name")}) Lista de Identity) (); #{id} ")@Resultados ({@resultado (Property =" useirex ", column =" user_sex ", javatype = usersexenum.class),@resultado (propriedade =" apelido ", column =" nick_name ")}) userentity getOne (long id);@insert (" insert em usuários (usuários ")}), userTone, userne, usern; #{senha},#{useirex}) ") void insert (usuário userentity);@update (" update usuários defina nome de usuário =#{userrame}, nick_name =#{apelido} whereg de id =#{id} ") void update (userentity userentity);@delete (" deLete de usuários##{} ") update (userentity);Para estar mais próximo da produção, sublinhei especialmente os dois atributos de user_sex e nick_name no banco de dados e os nomes de atributos da classe Entidade são inconsistentes. Além disso, user_sex usa enumerações
@Select é uma anotação da aula de consulta, e todas as consultas usam isso
@Result modifique o conjunto de resultados retornados e os atributos da classe de entidade associados e os campos de banco de dados correspondem a um por um. Se os atributos da classe da entidade e os nomes de atributos do banco de dados forem consistentes, esse atributo não será necessário para modificar.
@InSert Insira o banco de dados para usar, a passagem diretamente da classe da entidade analisará automaticamente o atributo ao valor correspondente
@Update é responsável por modificar e também pode ser passado diretamente para o objeto
@Delete é responsável por excluir
Para mais propriedades, consulte aqui: http://www.mybatis.org/mybatis-3/zh/java-api.html
Observe que a diferença entre usar # símbolo e $ símbolo:
// Este exemplo cria uma declaração preparada, algo como selecionar * do professor onde nome =? selectTeachForGivenName (@param ("nome") nome da string);4. Use
As três etapas acima completam basicamente o desenvolvimento da camada relevante. Ao usá -lo, basta usá -lo como uma classe comum e ele pode ser injetado nele.
@Runwith (springrunner.class) @springboottestPublic class UserMApperTest {@AUTOWIDEDPRIVATE UserMApper UserMApper; @Testpublic void testInsert () lança (UserMApper.insert (new userentity ("aa)" a123456 " "B123456", UsersExenum.woman)); UserMApper.insert (New UserEntity ("CC", "B123456", UserMexenum.woman)); Assert.asserTeQuals (3, UsermApper.getAll (). Tamanho ());}@testpublic void () Throws () (). UserMApper.getAll (); System.out.println (users.toString ());}@testpublic void testUpDate () lança a exceção {userentity user = UsermApper.GETEONE (3L); System.out.println (user.toString ()); user.setnickname ("neo"); UserMapper.Update (UserMApper); Assert.assertTrue (("NEO" .Equals (UserMApper.Getone (3l) .getName ()));Existem adições completas, deleções, modificações e pesquisas no código -fonte, então não as postarei aqui
Versão XML minimalista
A versão XML minimalista mantém a antiga tradição de mapear arquivos. A otimização é refletida principalmente na camada de implementação que não precisa ser implementada. O sistema encontrará automaticamente o SQL correspondente no arquivo de mapeamento de acordo com o nome do método.
1. Configuração
O arquivo POM é o mesmo da versão anterior, exceto que a seguinte configuração é adicionada ao application.properties
mybatis.config-locations = ClassPath: mybatis/mybatis-config.xmlmybatis.mapper-locations = ClassPath: mybatis/mapper/*. xml
Especifica o endereço do arquivo de configuração BASIC MYBATIS e o arquivo de mapeamento da classe de entidade
Configuração mybatis-config.xml
<figuration> <typeAliases> <typeAlias alias = "integer" type = "java.lang.integer" /> <typeAlias alias = "long" type = "java.lang.long" /> <tipeAlias alias = "hashmap" type = "java.util.hashMap" /> type = "java.util.LinkedHashmap" /> <typeAlias alias = "ArrayList" type = "java.util.arraylist" /> <typeAlias alias = "LinkedList" type = "java.util.linkedlist" /> < /typeAliases> < /configature>
Aqui você também pode adicionar algumas configurações básicas de mybatis
2. Adicione o arquivo de mapeamento do usuário
<Mapper namespace = "com.neo.mapper.userMapper"> <resultMap id = "baseresultmap" type = "com.neo.entity.userentity"> <id column = "id" property = "id" jdbctype = "bigint" /resulte column = "username" "". propriedades = "senha" jdbctype = "varchar" /> <resultado column = "user_sex" propriedade = "userSex" javatype = "com.neo.enums.usersExenum" /> <resultado column = "nick_name" property = "nickname" jdbctype = "varchar" /> < /> < /> < /> < /resultMap "> <siltMap> Nome de usuário, senha, user_sex, nick_name </sql> <select id = "getall" resultmap = "baseresultmap"> selecione <incluir refid = "base_column_list"/> users </select> <select id = "getOne" parameterType = "java.lang.Long "MapMapMap =" GetOne "ParameterType =" refid="Base_Column_List" />FROM usersWHERE id = #{id}</select><insert id="insert" parameterType="com.neo.entity.UserEntity" >INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{userSex})</insert><update id="update" ParameterType = "com.neo.entity.UserEntity"> Atualizar usuários Definir <se test = "nome de usuário! = null"> nome de usuário = #{nome de usuário}, </if> <se test = "senha! ParameterType = "java.lang.long"> exclua dos usuários onde id = #{id} </lete> </pappper>Na verdade, estava apenas movendo o mapa SQL da versão anterior para o XML aqui
3. Escreva o código da camada DAO
Public Interface UserMApper {List <userentity> getAll (); UserEntity GETONE (LONG ID); void Insert (Usuário Usuário); Void Update (Usuário Usuário); void Delete (Long Id);}Comparado com a etapa anterior, restam apenas métodos de interface.
4. Use
Não há diferença entre usá -lo e a versão anterior, veja o código
Como escolher
Os dois modos têm suas próprias características. A versão anotada é adequada para modos simples e rápidos. De fato, como o modelo de microsserviço popular hoje em dia, um microsserviço corresponderá ao seu próprio banco de dados. A demanda por consulta de conexão com várias mesa será bastante reduzida e se tornará cada vez mais adequada para esse modo.
O antigo modelo tradicional é mais adequado para grandes projetos. Ele pode gerar com flexibilidade o SQL dinamicamente, o que é conveniente para ajustar o SQL e também tem a sensação de escrever SQL com grande prazer e elegância.
Código de exemplo-Github: https://github.com/ityouknok/spring-boot-examples
Exemplo Código-Code Cloud: https://gitee.com/ityouknok/spring-boot-examples