TOC

MyBatis com Spring

MyBatis com Spring

1. Introdução

MyBatis é uma das estruturas de código aberto mais usadas para implementar o acesso a bancos de dados SQL em aplicativos Java.

Neste tutorial rápido, apresentaremos como integrar MyBatis com Spring e Spring Boot.

Para aqueles que ainda não estão familiarizados com esta estrutura, certifique-se de verificar nossoarticle on working with MyBatis.

2. Definindo o modelo

Vamos começar definindo POJO simples que usaremos em todo o nosso artigo: 

public class Article {
    private Long id;
    private String title;
    private String author;

    // constructor, standard getters and setters
}

E um arquivo SQLschema.sql equivalente: 

CREATE TABLE IF NOT EXISTS `ARTICLES`(
    `id`          INTEGER PRIMARY KEY,
    `title`       VARCHAR(100) NOT NULL,
    `author`      VARCHAR(100) NOT NULL
);

A seguir, vamos criar um arquivodata.sql, que simplesmente insere um registro em nossa tabelaarticles: 

INSERT INTO ARTICLES
VALUES (1, 'Working with MyBatis in Spring', 'example');

Ambos os arquivos SQL devem ser incluídos emclasspath.

3. Spring Config

Para começar a usar MyBatis, temos que incluir duas dependências principais -MyBatiseMyBatis-Spring: 


    org.mybatis
    mybatis
    3.5.2



    org.mybatis
    mybatis-spring
    2.0.2

Além disso, precisaremos deSpring dependencies básicos: 


    org.springframework
    spring-context
    5.1.8.RELEASE



    org.springframework
    spring-beans
    5.1.8.RELEASE

Em nossos exemplos, usaremosthe H2 embedded database para simplificar a configuração eEmbeddedDatabaseBuilder class do módulospring-jdbc para configuração: 


    com.h2database
    h2
    1.4.199



    org.springframework
    spring-jdbc
    5.1.8.RELEASE

3.1. Configuração baseada em anotação

O Spring simplifica a configuração do MyBatis. The only required elements are javax.sql.Datasource, org.apache.ibatis.session.SqlSessionFactory, and at least one mapper.

Primeiro, vamos criar uma classe de configuração: 

@Configuration
@MapperScan("com.example.mybatis")
public class PersistenceConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
          .setType(EmbeddedDatabaseType.H2)
          .addScript("schema.sql")
          .addScript("data.sql")
          .build();
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource());
        return factoryBean.getObject();
    }
}

Também aplicamos uma anotação@MapperScan do MyBatis-Spring que verifica os pacotes definidos e seleciona automaticamente as interfaces usando qualquer uma das anotações do mapeador, como@Select ou@Delete.

Usar@MapperScan também garante que cada mapeador fornecido seja automaticamente registrado comoBeane pode ser usado posteriormente com a anotação@Autowired.

Agora podemos criar uma interfaceArticleMapper simples: 

public interface ArticleMapper {
    @Select("SELECT * FROM ARTICLES WHERE id = #{id}")
    Article getArticle(@Param("id") Long id);
}

E, finalmente, teste nossa configuração: 

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = PersistenceConfig.class)
public class ArticleMapperIntegrationTest {

    @Autowired
    ArticleMapper articleMapper;

    @Test
    public void whenRecordsInDatabase_shouldReturnArticleWithGivenId() {
        Article article = articleMapper.getArticle(1L);

        assertThat(article).isNotNull();
        assertThat(article.getId()).isEqualTo(1L);
        assertThat(article.getAuthor()).isEqualTo("example");
        assertThat(article.getTitle()).isEqualTo("Working with MyBatis in Spring");
    }
}

No exemplo acima, usamos MyBatis para recuperar o único registro que inserimos anteriormente em nosso arquivodata.sql.

3.2. Configuração baseada em XML

Conforme descrito anteriormente, para usar MyBatis com Spring, precisamos deDatasource,SqlSessionFactory, e pelo menos um mapeador.

Vamos criar as definições de bean necessárias no arquivo de configuraçãobeans.xml:

Neste exemplo, também usamos o esquema XML personalizado fornecido porspring-jdbc para configurar nossa fonte de dados H2.

Para testar essa configuração, podemos reutilizar a classe de teste implementada anteriormente. No entanto, precisamos ajustar a configuração do contexto, o que podemos fazer aplicando a anotação: 

@ContextConfiguration(locations = "classpath:/beans.xml")

4. Spring Boot

O Spring Boot fornece mecanismos que simplificam ainda mais a configuração do MyBatis com o Spring.

Primeiro, vamos adicionarthemybatis-spring-boot-starterdependency ao nossopom.xml: 


    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    2.1.0

Por padrão, se usarmos um recurso de configuração automática,Spring Boot detects the H2 dependency from our classpath and configures both Datasource and SqlSessionFactory for us. Além disso, ele também executa a inicialização filhoschema.sql anddata.sql .

Se não usarmos um banco de dados embutido, podemos usar a configuração por meio de um arquivoapplication.yml ouapplication.properties ou definir um beanDatasource apontando para nosso banco de dados.

A única coisa que resta fazer é definir uma interface de mapeador, da mesma maneira que antes, e anotar com a anotação@Mapper de MyBatis. Como resultado, o Spring Boot verifica nosso projeto, procurando essa anotação, e registra nossos mapeadores como beans.

Depois disso, podemos testar nossa configuração usando a classe de teste definida anteriormente, aplicando anotações despring-boot-starter-test: 

@RunWith(SpringRunner.class)
@SpringBootTest

5. Conclusão

Neste artigo, exploramos várias maneiras de configurar o MyBatis com o Spring.

Vimos exemplos de como usar a configuração XML e baseada em anotações e mostramos os recursos de configuração automática do MyBatis com Spring Boot.

Como sempre, o código completo usado neste artigo está disponívelover on GitHub.

Related