TOC

Guide rapide de MyBatis

Guide rapide de MyBatis

1. introduction

MyBatis est un framework de persistance open source qui simplifie l'implémentation de l'accès aux bases de données dans les applications Java. Il fournit un support pour 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 Maven

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


    org.mybatis
    mybatis
    3.4.4

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

3. API Java

3.1. SQLSessionFactory

SQLSessionFactory est la classe principale de chaque application MyBatis. Cette classe est instanciée à l'aide de la méthodeSQLSessionFactoryBuilder'sbuilder() 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, ces derniers sont utilisés pour créer l'instanceSQLSessionFactory: 

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 classeSQLSessionFactory. 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. PuisqueSqlSession implémente l'interfaceAutoCloseable, nous pouvons utiliser le bloctry-with-resources: 

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

4. Mappeurs

Les mappeurs sont des interfaces Java mappant des méthodes aux instructions SQL correspondantes. MyBatis fournit des annotations pour la définition des 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. MyBatis Annotations

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 contenant 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 deResult dans la liste des résultats récupérés à partir 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"))
})

    IcigetAddresses est la méthode qui retourne la collection deAddress en interrogeant la table d'adresses. 

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

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

  • *@MapKey* – ceci est utilisé pour convertir la liste d'enregistrements enMap d'enregistrements avec la clé définie par l'attributvalue: 

    @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 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

Le SQL dynamique 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 placer les virgules au bon endroit. Ceci est très sujet aux erreurs et très difficile à déboguer, dans le cas de grandes instructions SQL.

Voyons 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 construit et génère le code SQL final: 

public class MyBatisUtil {

    // ...

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

Le SQL dynamique 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 clauseWHERE.

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 unCall 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 didacticiel, nous avons vu les différentes fonctionnalités fournies par MyBatis et comment il facilite le développement d'applications orientées vers les bases de données. Nous avons également vu diverses annotations fournies par la bibliothèque.

Le code complet de cet article est disponibleover on GitHub.

Related