Guide rapide de MyBatis

1. Introduction

MyBatis est un framework de persistance open source qui simplifie la mise en œuvre de l'accès aux bases de données dans les applications Java. Il prend en charge le SQL personnalisé, les procédures stockées et différents types de relations de mappage.

En termes simples, c'est une alternative à JDBC et Hibernate.

2. Dépendances de Maven

Pour utiliser MyBatis, nous devons ajouter la dépendance à notre pom.xml:

 org.mybatis mybatis 3.4.4 

La dernière version de la dépendance peut être trouvée ici.

3. API Java

3.1. SQLSessionFactory

SQLSessionFactory est la classe principale de chaque application MyBatis. Cette classe est instancié en utilisant « SQLSessionFactoryBuilder de constructeur () méthode qui charge un fichier XML de configuration:

String resource = "mybatis-config.xml"; InputStream inputStream Resources.getResourceAsStream(resource); SQLSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

Le fichier de configuration Java comprend des paramètres tels que la définition de la source de données, les détails du gestionnaire de transactions et une liste de mappeurs qui définissent les relations entre les entités, qui sont utilisés ensemble pour créer l' instance SQLSessionFactory :

public static SqlSessionFactory buildqlSessionFactory() { DataSource dataSource = new PooledDataSource(DRIVER, URL, USERNAME, PASSWORD); Environment environment = new Environment("Development", new JdbcTransactionFactory(), dataSource); Configuration configuration = new Configuration(environment); configuration.addMapper(PersonMapper.class); // ... SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); return builder.build(configuration); }

3.2. SQLSession

SQLSession contient des méthodes pour effectuer des opérations de base de données, obtenir des mappeurs et gérer des transactions. Il peut être instancié à partir de la classe SQLSessionFactory . Les instances de cette classe ne sont pas thread-safe.

Après avoir effectué l'opération de base de données, la session doit être fermée. Puisque SqlSession implémente l' interface AutoCloseable , nous pouvons utiliser le bloc try-with-resources :

try(SqlSession session = sqlSessionFactory.openSession()) { // do work }

4. Cartographes

Les mappeurs sont des interfaces Java qui mappent les méthodes aux instructions SQL correspondantes. MyBatis fournit des annotations pour définir les opérations de base de données:

public interface PersonMapper { @Insert("Insert into person(name) values (#{name})") public Integer save(Person person); // ... @Select( "Select personId, name from Person where personId=#{personId}") @Results(value = { @Result(property = "personId", column = "personId"), @Result(property="name", column = "name"), @Result(property = "addresses", javaType = List.class, column = "personId", [email protected](select = "getAddresses")) }) public Person getPersonById(Integer personId); // ... }

5. Annotations MyBatis

Voyons quelques-unes des principales annotations fournies par MyBatis:

  • @Insert, @Select, @Update, @Delete - ces annotations représentent des instructions SQL à exécuter en appelant des méthodes annotées:
    @Insert("Insert into person(name) values (#{name})") public Integer save(Person person); @Update("Update Person set name= #{name} where personId=#{personId}") public void updatePerson(Person person); @Delete("Delete from Person where personId=#{personId}") public void deletePersonById(Integer personId); @Select("SELECT person.personId, person.name FROM person WHERE person.personId = #{personId}") Person getPerson(Integer personId);
  • @Results - il s'agit d'une liste de mappages de résultats qui contiennent les détails de la façon dont les colonnes de la base de données sont mappées aux attributs de classe Java:
    @Select("Select personId, name from Person where personId=#{personId}") @Results(value = { @Result(property = "personId", column = "personId") // ... }) public Person getPersonById(Integer personId);
  • @Result - il représente une seule instance de Result dans la liste des résultats extraits de @Results. Il comprend des détails tels que le mappage de la colonne de base de données à la propriété du bean Java, le type Java de la propriété et également l'association avec d'autres objets Java:
    @Results(value = { @Result(property = "personId", column = "personId"), @Result(property="name", column = "name"), @Result(property = "addresses", javaType =List.class) // ... }) public Person getPersonById(Integer personId);
  • @Many - il spécifie un mappage d'un objet à une collection des autres objets:
    @Results(value ={ @Result(property = "addresses", javaType = List.class, column = "personId", [email protected](select = "getAddresses")) })

    Ici, getAddresses est la méthode qui renvoie la collection Address en interrogeant la table Address.

    @Select("select addressId, streetAddress, personId from address where personId=#{personId}") public Address getAddresses(Integer personId);

    Semblable à @Many annotation, nous avons une annotation @One qui spécifie la relation de mappage un à un entre les objets.

  • @MapKey - ceci est utilisé pour convertir la liste des enregistrements en carte des enregistrements avec la clé définie par l'attribut value :
    @Select("select * from Person") @MapKey("personId") Map getAllPerson();
  • @Options - cette annotation spécifie un large éventail de commutateurs et de configuration à définir afin qu'au lieu de les définir sur d'autres instructions, nous puissions @Options pour les définir:
    @Insert("Insert into address (streetAddress, personId) values(#{streetAddress}, #{personId})") @Options(useGeneratedKeys = false, flushCache=true) public Integer saveAddress(Address address);

6. SQL dynamique

Dynamic SQL est une fonctionnalité très puissante fournie par MyBatis. Avec cela, nous pouvons structurer notre SQL complexe avec précision.

Avec le code JDBC traditionnel, nous devons écrire des instructions SQL, les concaténer avec la précision des espaces entre elles et mettre les virgules aux bons endroits. Ceci est très sujet aux erreurs et très difficile à déboguer, dans le cas de grandes instructions SQL.

Explorons comment nous pouvons utiliser le SQL dynamique dans notre application:

@SelectProvider(type=MyBatisUtil.class, method="getPersonByName") public Person getPersonByName(String name);

Ici, nous avons spécifié une classe et un nom de méthode qui construisent et génèrent réellement le SQL final:

public class MyBatisUtil { // ... public String getPersonByName(String name){ return new SQL() {{ SELECT("*"); FROM("person"); WHERE("name like #{name} || '%'"); }}.toString(); } }

Dynamic SQL fournit toutes les constructions SQL sous forme de classe, par exemple SELECT , WHERE, etc. Avec cela, nous pouvons modifier dynamiquement la génération de la clause WHERE .

7. Prise en charge des procédures stockées

Nous pouvons également exécuter la procédure stockée en utilisant l' annotation @Select . Ici, nous devons passer le nom de la procédure stockée, la liste des paramètres et utiliser un appel explicite à cette procédure:

@Select(value= "{CALL getPersonByProc(#{personId, mode=IN, jdbcType=INTEGER})}") @Options(statementType = StatementType.CALLABLE) public Person getPersonByProc(Integer personId);

8. Conclusion

Dans ce rapide tutoriel, nous avons vu les différentes fonctionnalités fournies par MyBatis et comment cela facilite le développement d'applications face à la base de données. Nous avons également vu diverses annotations fournies par la bibliothèque.

Le code complet de cet article est disponible à l'adresse over sur GitHub.