Tutoriel de base pour démarrer avec Java Mybatis Framework_Basic Knowledge

1. Introduction à Mybatis

MyBatis est un framework de persistance de première classe qui prend en charge le SQL personnalisé, les procédures stockées et le mappage avancé. MyBatis élimine presque tout le code JDBC et il n'est pratiquement pas nécessaire de définir manuellement les paramètres et d'obtenir les résultats de la recherche. MyBatis peut être configuré à l'aide d'un simple format XML ou d'annotations, et peut mapper des éléments de données de base, des interfaces Map et des POJO (objets Java ordinaires) aux enregistrements de la base de données.

2. Flux de travail MyBatis

(1) Charger la configuration et initialiser

Condition de déclenchement : Charger le fichier de configuration

La configuration provient de deux endroits, l'un est le fichier de configuration et l'autre est l'annotation du code Java. Les informations de configuration SQL sont chargées dans les objets MappedStatement (y compris la configuration de mappage des paramètres entrants, les instructions SQL exécutées et les résultats). . configuration de mappage), stockée en mémoire.

(2) Recevoir une demande d'appel

Condition de déclenchement : Appeler l'API fournie par Mybatis

Paramètres entrants : ID SQL et objet paramètre entrant

Processus de traitement : transmettez la demande à la couche inférieure de traitement des demandes pour traitement.

(3) Traiter la demande d'opération. Condition de déclenchement : la couche d'interface API transmet la demande

Paramètres entrants : ID SQL et objet paramètre entrant

Processus de traitement :

(A) Recherchez l'objet MappedStatement correspondant en fonction de l'ID SQL.
(B) Analysez l'objet MappedStatement en fonction de l'objet paramètre entrant pour obtenir le SQL final à exécuter et les paramètres entrants d'exécution.
(C) Obtenez la connexion à la base de données, transmettez l'instruction SQL finale et les paramètres d'exécution à la base de données pour exécution et obtenez le résultat de l'exécution.
(D) Convertissez le résultat d'exécution obtenu selon la configuration de mappage des résultats dans l'objet MappedStatement et obtenez le résultat final du traitement.
(E) Libérer les ressources de connexion.

(4) Renvoie le résultat du traitement et renvoie le résultat final du traitement

Idée de base des outils ORM

Que vous ayez utilisé hibernate ou mybatis, vous pouvez les comparer avec un point commun :

• Récupérez sessionfactory.
à partir du fichier de configuration (généralement un fichier de configuration XML)
• session générée par sessionfactory
• Terminez l'ajout, la suppression, la modification et la soumission des données de transaction dans la session.
• Fermez la séance après utilisation.
• Il existe un fichier de configuration de mappage entre l'objet Java et la base de données, qui est généralement un fichier XML.

Architecture fonctionnelle

L'architecture fonctionnelle de Mybatis est divisée en trois couches :

1. Couche d'interface API : API d'interface fournie pour un usage externe. Les développeurs utilisent ces API locales pour manipuler la base de données. Une fois que la couche d'interface reçoit la demande d'appel, elle appellera la couche de traitement des données pour terminer un traitement de données spécifique.

2. Couche de traitement des données : responsable de la recherche SQL spécifique, de l'analyse SQL, de l'exécution SQL et du traitement du mappage des résultats d'exécution, etc. Son objectif principal est d'effectuer une opération de base de données en fonction de la demande appelante.

3. Couche de support de base : responsable du support fonctionnel le plus élémentaire, y compris la gestion des connexions, la gestion des transactions, le chargement de la configuration et le traitement du cache. Ce sont des éléments courants, et ils sont extraits en tant que composants les plus élémentaires. Fournit le support le plus basique pour la couche supérieure de traitement des données.

Plus de packages de pilotes doivent être ajoutés :

Voici un démarrage rapide :

L'annuaire est le suivant :

Utilisateur de classe d'entité

package com.oumyye.model;

public class User {
  private String id;
  private String name;
  private int age;
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  @Override
  public String toString() {
    return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
  }

}

Fichier de mappage UserMapping.xml

<&#63;xml version="1.0" encoding="UTF-8" &#63;>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.oumyye.mapping.UserMapping">
  <!-- 在select标签中编写查询的SQL语句， 设置select标签的id属性为getUser，id属性值必须是唯一的，不能够重复
  使用parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回的结果集类型
  resultType="com.oumyye.model.User"就表示将查询结果封装成一个User类的对象返回
  User类就是users表所对应的实体类
  -->
  <!-- 
    根据id查询得到一个user对象
   -->
  <select id="getUser" parameterType="String" 
    resultType="com.oumyye.model.User">
    select * from user where id=#{id}
  </select>
</mapper>

Fichier ressource mybatis.xml

<&#63;xml version="1.0" encoding="UTF-8"&#63;>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC" />
      <!-- 配置数据库连接信息 -->
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
        <property name="username" value="root" />
        <property name="password" value="root" />
      </dataSource>
    </environment>
  </environments>
  <mappers>

<mapper resource="com/oumyye/mapping/userMapping.xml"/>
   </mappers>
</configuration>

Classe de test :

package test;

import java.io.InputStream;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import com.oumyye.model.User;

public class Tests {
@Test
public void test(){
 String resource = "mybatis.xml";
    //使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）
    InputStream is = Tests.class.getClassLoader().getResourceAsStream(resource);
    //构建sqlSession的工厂
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

SqlSession session = sessionFactory.openSession();
    /**
     * 映射sql的标识字符串，
     * com.oumyye.mapping.UserMapping是userMapper.xml文件中mapper标签的namespace属性的值，
     * getUser是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
     */
    String statement = "com.oumyye.mapping.UserMapping.getUser";//映射sql的标识字符串
    //执行查询返回一个唯一user对象的sql
    User user = session.selectOne(statement, "1123");
    System.out.println(user.toString());
}
}

Résultat :

Ce qui précède est un tutoriel de base pour démarrer avec le framework Java Mybatis. J'espère qu'il sera utile à l'apprentissage de chacun.