Analysez l'exemple de démarrage rapide de MyBatis en Java

1. Qu'est-ce que MyBatis

En termes simples, MyBatis est un excellent framework de couche de persistance pour simplifier le développement JDBC. MyBatis lui-même est un projet open source d'Apache. Il s'appelait à l'origine iBatis. En 2010, le projet a été déplacé vers Google Code et renommé MyBatista. En 2013, le projet a été déplacé vers GitHub. MyBatis是一款优秀的持久层框架，用于简化JDBC开发。MyBatis本身是Apache的一个开源项目，期初叫做iBatis，2010年这个项目前移到google code，并改名为MyBatista。在2013年该项目迁移到GitHub。

概念中的持久层怎么理解?指将数据保存到数据库的那一层代码。在海量的代码中，为了保证每一块代码的职责单一，把同数据库操作的代码叫做持久层。同时，JavaEE三层架构中，表现层负责页面的展示，业务层负责逻辑的处理，而持久层就是负责将数据存储到数据库中。

什么是框架?框架是指一个半成品的软件，是一套可重用的，通用的，软件基础代码模型，同时，在框架基础之上进行开发大量的节省了成本，而且更加的规范，通用且扩展性较强。

2. JDBC存在的缺点

既然我们使用MyBatis来简化JDBC开发，那么JDBC究竟存在什么缺点呢？

硬编码

首先在注册驱动，获取链接的时候，字符串信息如果发生变动，例如密码，此时需要手动修改。其次，在定义sql语句时候，使用字符串同样使得代码的维护性变差。

操作繁琐

当我们手动设置参数和手动设置结果集时，存在着操作繁琐的问题。

下面JDBC使用的一段代码做展示：

3.Mybatis简化JDBC开发

既然JDBC开发存在硬编码，操作繁琐的缺点，那么怎么解决这些问题呢？首先我们把字符串写到单独的配置文件中，解决JDBC硬编码的问题，其次，可以采用一种方法来自动完成JDBC操作繁琐的代码。于是，我们使用MyBatis来简化JDBC开发。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。

Comment comprendre la couche de persistance dans le concept

Elle fait référence à la couche de code qui enregistre les données dans la base de données. Dans le code massif, afin de garantir que chaque morceau de code a une seule responsabilité, le code qui opère sur la même base de données est appelé la couche de persistance. Dans le même temps, dans l'architecture à trois niveaux JavaEE, la couche de présentation est responsable de l'affichage des pages, la couche métier est responsable du traitement logique et la couche de persistance est responsable de l'affichage des pages. responsable du stockage des données dans la base de données.

Qu'est-ce qu'un framework

 ? Un framework fait référence à un logiciel semi-fini. Il s'agit d'un ensemble de modèles de code logiciel de base réutilisables, universels, développés sur la base de. le cadre peut permettre d'économiser beaucoup d'argent. Le coût est réduit et il est plus standardisé, polyvalent et évolutif.

2. Inconvénients de JDBC

1. Puisque nous utilisons MyBatis pour simplifier le développement de JDBC, quelles sont les lacunes de JDBC ?

Codage en dur

2. Tout d'abord, lors de l'enregistrement du pilote et de l'obtention du lien, si les informations de la chaîne changent, comme le mot de passe, elles doivent être modifiées manuellement. Deuxièmement, lors de la définition d'instructions SQL, l'utilisation de chaînes rend également le code moins maintenable.

   Opération complexe

   Lorsque nous définissons manuellement les paramètres et définissons manuellement l'ensemble de résultats, il existe un problème d'opération lourde.
3. Ce qui suit est un morceau de code utilisé par JDBC pour la démonstration :
   
4. 3. Mybatis simplifie le développement JDBC
   Étant donné que le développement JDBC présente les inconvénients du codage en dur et des opérations lourdes, comment résoudre ces problèmes ? Premièrement, nous écrivons la chaîne dans un fichier de configuration séparé pour résoudre le problème du codage en dur JDBC. Deuxièmement, nous pouvons utiliser une méthode pour compléter automatiquement le fastidieux code d'opération JDBC. Par conséquent, nous utilisons MyBatis pour simplifier le développement JDBC. MyBatis élimine presque tout le code JDBC ainsi que le travail de définition des paramètres et d'obtention des jeux de résultats.
5. Par exemple : écrivez les informations sur les paramètres dans le fichier de configuration et lisez-les directement lorsqu'elles seront utilisées à l'avenir pour résoudre le problème du codage en dur

   <environment id="test">
               <transactionManager type="JDBC"/>
               <dataSource type="POOLED">
                   <!--数据库连接信息-->
                   <property name="driver" value="com.mysql.jdbc.Driver"/>
                   <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
                   <property name="username" value="root"/>
                   <property name="password" value="1234"/>
               </dataSource>
           </environment>
       </environments>

   Il existe de nombreux choix pour le framework de couche de persistance sur le marché, mais MyBatis a de nombreux choix sur le marché intérieur.

4.Démarrage rapide MyBatis | Explication détaillée des projets pratiques

Nous commençons avec MyBatis en interrogeant rapidement toutes les données de la table utilisateur via des opérations pratiques, c'est-à-dire en interrogeant les données de la table utilisateur, en les mettant dans l'utilisateur objet, puis se mettre mutuellement dans la collection pour terminer l'opération. Terminez l'opération en suivant les étapes suivantes :

1. Créer une table utilisateur, ajouter des données

2. Créer un module, importer des coordonnées

3. Écrire le fichier de configuration principal MyBatis, remplacer les informations de connexion pour résoudre le problème codé en dur

4. Écrire un fichier de mappage SQL, gestion unifiée des instructions SQL, résoudre des problèmes de codage

Écrire du code

Utilisez les étapes suivantes lors de l'écriture du code :

Définir la classe POJO

Charger le fichier de configuration de base et obtenir l'objet sqlSessionFactory

Obtenir l'objet sqlSession et exécuter l'instruction sql

Libérer les ressources

Affichage global de la structure du projet :

La démonstration suivante utilise une démonstration détaillée pour démarrer rapidement avec MyBatis :

Création d'une table utilisateur, ajout de données :

create database mybatis;
use mybatis;
drop table if exists tb_user;
create table tb_user(
	id int primary key auto_increment,
	username varchar(20),
	password varchar(20),
	gender char(1),
	addr varchar(30)
);
INSERT INTO tb_user VALUES (1, '小张', 'abc', '男', '北京');
INSERT INTO tb_user VALUES (2, '小李', '123', '女', '天津');
INSERT INTO tb_user VALUES (3, '小美', '456', '女', '上海');

La base de données MySQL est utilisée ici, et navicat est utilisé comme outil de visualisation de base de données.

Créez un module dans l'idée et importez les coordonnées :

Cliquez sur Nouveau projet dans l'idée, sélectionnez Maven pour le système de construction, entrez le nom du projet (MyBatis-demo est utilisé ici), définissez l'ID de groupe et l'ID d'artefact, et cliquez sur Créer. Ensuite, importez les dépendances et placez le code de dépendance suivant dans le fichier pom.xml :

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>x.x.x</version>
</dependency>

Ensuite, importez les dépendances mysql, les coordonnées junit et les coordonnées de connexion, et collez le fichier de configuration logback.xml dans les ressources : Écrit par 🎜

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <!-- 添加slf4j日志api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.20</version>
        </dependency>
        <!-- 添加logback-classic依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- 添加logback-core依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>

🎜 🎜 Fichier de configuration principal MyBatis : 🎜🎜🎜Créez un nouveau fichier de configuration mybatis.config.xml dans MyBatis-demo/src/main/resources. 🎜

<?xml version="1.0" encoding="UTF-8" ?>
<!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:///mybatis?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="abc123"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--加载sql的映射文件-->
        <mapper resource="UerMapper.xml"/>
    </mappers>
</configuration>

🎜🎜Écrivez le fichier de mappage SQL : 🎜🎜🎜Ajoutez le fichier de mappage SQL UserMapper.xml dans MyBatis-demo/src/main/resources. 🎜

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="test">
    <select id="selectAll" resultType="com.example.pojo.User">
        select * from tb_user;
    </select>
</mapper>

🎜Modifiez le fichier de configuration principal de MyBatis pour charger le fichier de mappage SQL. 🎜

  <mappers>
        <!--加载sql的映射文件-->
        <mapper resource="UserMapper.xml"/>
  </mappers>

🎜🎜Après avoir terminé les opérations ci-dessus, vous pouvez commencer à coder. Tout d'abord, définissez la classe POJO : 🎜🎜

package com.example.pojo;
public class User {
    private Integer id;
    private String username;
    private String password;
    private String gender;
    private String addr;
    public Integer getId() {
        return id;
    }
    public String getUsername() {
        return username;
    }
    public String getPassword() {
        return password;
    }
    public String getGender() {
        return gender;
    }
    public String getAddr() {
        return addr;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", gender='" + gender + '\'' +
                ", addr='" + addr + '\'' +
                '}';
    }
}

🎜🎜Chargez le fichier de configuration principal et obtenez l'objet sqlSessionFactory : 🎜🎜🎜Vous devez d'abord créer un MyBatisDemo.java. fichier et ajoutez une méthode principale. Écrivez du code. 🎜

public class MyBatisDemo {
    public static void main(String[] args) throws IOException {
    	//加载MyBatis核心配置文件
        String resource = "mybatis.config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }
}

获取sqlSession对象，执行sql语句：

//获取SqlSession对象，用它来执行sql
        SqlSession sqlSession=sqlSessionFactory.openSession();
        //执行sql
        List<User> users = sqlSession.selectList("test.selectALL");
        System.out.println(users);
		//释放资源
        sqlSession.close();

到这里我们就完成了整个项目的构建，接下来我们运行程序，可以看到，我们成功的查询到tb_user中的数据！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!