Analysieren Sie das Schnellstartbeispiel von MyBatis in Java

1. Was ist MyBatis

Einfach ausgedrückt ist MyBatis ein hervorragendes Persistenzschicht-Framework JDBC-Entwicklung. MyBatis selbst ist ein Open-Source-Projekt von Apache. Es hieß ursprünglich iBatis. Im Jahr 2010 wurde das Projekt zu Google Code verschoben und in MyBatista umbenannt. 2013 wurde das Projekt auf GitHub verschoben. 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代码以及设置参数和获取结果集的工作。

Wie verstehen Sie die Persistenzschicht im Konzept

? Sie bezieht sich auf die Codeschicht, die Daten in der Datenbank speichert. Um im massiven Code sicherzustellen, dass jeder Codeabschnitt eine einzige Verantwortung hat, wird der Code, der auf derselben Datenbank arbeitet, als Persistenzschicht bezeichnet. Gleichzeitig ist in der dreistufigen JavaEE-Architektur die Präsentationsschicht für die Seitenanzeige, die Business-Schicht für die Logikverarbeitung und die Persistenzschicht verantwortlich Verantwortlich für die Speicherung der Daten in der Datenbank.

Was ist ein Framework? Gleichzeitig spart die Entwicklung auf Basis des Frameworks viel Kosten und ist standardisierter, vielseitiger und skalierbarer.

2. Nachteile von JDBC

1. Da wir MyBatis verwenden, um die JDBC-Entwicklung zu vereinfachen, was sind die Mängel von JDBC?

   Harte Codierung

Wenn sich beim Registrieren des Treibers und Abrufen des Links zunächst die Zeichenfolgeninformationen ändern, z. B. das Passwort, müssen diese geändert werden manuell. Zweitens macht die Verwendung von Zeichenfolgen beim Definieren von SQL-Anweisungen den Code auch weniger wartbar.

2. Komplexe Bedienung

   Wenn wir Parameter manuell festlegen und die Ergebnismenge manuell festlegen, besteht das Problem einer umständlichen Bedienung.

Der folgende von JDBC verwendete Code wird angezeigt:

3. 

3. Mybatis vereinfacht die JDBC-Entwicklung

4. Da die JDBC-Entwicklung die Nachteile harter Codierung und umständlicher Vorgänge hat Wie können diese Probleme gelöst werden? Erstens schreiben wir die Zeichenfolge in eine separate Konfigurationsdatei, um das Problem der JDBC-Hardcodierung zu lösen. Zweitens können wir eine Methode verwenden, um den mühsamen JDBC-Operationscode automatisch zu vervollständigen. Daher verwenden wir MyBatis, um die JDBC-Entwicklung zu vereinfachen. MyBatis eliminiert fast den gesamten JDBC-Code und die Arbeit, Parameter festzulegen und Ergebnismengen zu erhalten.

Zum Beispiel: Schreiben Sie Parameterinformationen in die Konfigurationsdatei und lesen Sie sie direkt, wenn Sie sie in Zukunft verwenden, um das Problem der harten Codierung zu lösen

5. <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>

   Persistenzschicht-Framework Auf dem Markt gibt es viele Möglichkeiten, aber MyBatis hat einen großen Anteil der Nutzung auf dem heimischen Markt.

4.MyBatis-Schnellstart|Detaillierte Erläuterung praktischer Projekte

Wir beginnen mit MyBatis, indem wir schnell alle Daten in der Benutzertabelle durch praktische Operationen, also Abfragen, abfragen Geben Sie die Daten in die Benutzertabelle ein und fügen Sie sie zum Benutzerobjekt und zum anderen in die Sammlung ein, um den Vorgang abzuschließen. Schließen Sie den Vorgang mit den folgenden Schritten ab:

1. Benutzertabelle erstellen, Daten hinzufügen

2. Modul erstellen, importieren Koordinaten

3. MyBatis-Kernkonfigurationsdatei schreiben und Verbindungsinformationen ersetzen, um hartcodierte Probleme zu lösen

4. SQL schreiben Zuordnen von Dateien, einheitliche Verwaltung von SQL-Anweisungen, Lösen von Codierungsproblemen

Code schreiben

Verwenden Sie Folgendes, wenn Schritte zum Schreiben von Code:

POJO-Klasse definieren

Laden Sie die Kernkonfigurationsdatei und rufen Sie das sqlSessionFactory-Objekt ab# 🎜🎜## #

#🎜 🎜#Gesamtprojektstrukturanzeige:

Die folgende Demonstration verwendet eine detaillierte Demonstration, um schnell mit MyBatis zu beginnen : #🎜🎜 #

Erstellen Sie die Benutzertabelle und fügen Sie Daten hinzu:

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', '女', '上海');

Hier wird die MySQL-Datenbank verwendet und navicat als Datenbankvisualisierungstool verwendet.

Erstellen Sie ein Modul in idea und importieren Sie die Koordinaten:

Klicken Sie in idea auf Neues Projekt, wählen Sie Maven als Build-System aus und geben Sie das ein Projektnamen (hier mit MyBatis-demo), legen Sie die Gruppen-ID und die Artefakt-ID fest und klicken Sie auf Erstellen. Importieren Sie als Nächstes die Abhängigkeiten und fügen Sie den folgenden Abhängigkeitscode in die Datei pom.xml ein:

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

Importieren Sie als Nächstes die MySQL-Abhängigkeiten, Junit-Koordinaten und Logback-Koordinaten und fügen Sie die Konfigurationsdatei logback.xml in die Ressourcen ein :

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

Schreiben Sie die MyBatis-Kernkonfigurationsdatei:

Erstellen Sie eine neue Konfigurationsdatei mybatis.config in MyBatis-demo/src/main/ Ressourcen.

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

Schreiben Sie die SQL-Zuordnungsdatei:

Fügen Sie die SQL-Zuordnungsdatei UserMapper.xml in MyBatis-demo/src/main/resources hinzu.

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

#🎜🎜#Ändern Sie die Kernkonfigurationsdatei von MyBatis, um die SQL-Zuordnungsdatei zu laden. #🎜🎜#

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

#🎜🎜##🎜🎜#Nach Abschluss der oben genannten Vorgänge können Sie mit dem Codieren beginnen. Definieren Sie zunächst die POJO-Klasse: #🎜🎜##🎜🎜#

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 + '\'' +
                '}';
    }
}

#🎜🎜##🎜🎜#Laden Sie die Kernkonfigurationsdatei. Rufen Sie das sqlSessionFactory-Objekt ab: #🎜🎜##🎜🎜##🎜🎜#Zuerst müssen Sie eine MyBatisDemo.java-Datei erstellen, eine Hauptmethode hinzufügen und Code schreiben. #🎜🎜#

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中的数据！

Das obige ist der detaillierte Inhalt vonAnalysieren Sie das Schnellstartbeispiel von MyBatis in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!