MyBatis CRUD-Kurs | Java-Persistence | Datenbankverwaltung

Einführung

In diesem Projekt lernst du, wie du mit MyBatis, einem beliebten Java-Persistence-Framework, CRUD-Operationen (Create, Read, Update, Delete) auf einer Kursplanungstabelle ausführen kannst.

👀 Vorschau

Vorschau der Kursplanungstabelle

🎯 Aufgaben

In diesem Projekt wirst du lernen:

Wie du das Projekt konfigurierst und die erforderlichen Abhängigkeiten einrichtest
Wie du die Course-Entitätsklasse verbesserst, indem du Eigenschaften, Konstruktoren, Setter/Getter-Methoden und anderen Inhalt hinzufügst
Wie du die MyBatis-Konfigurationsdatei mybatis-config.xml verbesserst
Wie du die CourseMapper-Schnittstelle und deren entsprechende Methoden implementierst
Wie du die SQL-Mapping in der CourseMapper.xml-Datei implementierst
Wie du die Testfälle in der MyBatisTest.java-Datei implementierst

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

Mit MyBatis mit einer MySQL-Datenbank zu interagieren
Entitätsklassen zu definieren und die MyBatis-Mapping-Dateien zu konfigurieren
CRUD-Operationen mit MyBatis umzusetzen
Unit-Tests zu schreiben, um die Funktionalität der Anwendung zu überprüfen

Projekt konfigurieren

In diesem Schritt lernst du, wie du das Projekt konfigurierst und die erforderlichen Abhängigkeiten einrichtest.

Öffne die pom.xml-Datei im Projekt MyBatisCourseDemo02.
Füge die folgenden Abhängigkeiten zum <dependencies>-Abschnitt hinzu:

<!-- MyBatis jar -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>

    <!-- MySQL-Datenbanktreiberjar -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>

Füge die folgenden Eigenschaften zum <properties>-Abschnitt hinzu, um die Zeichensatzkodierung und die JDK-Version zu konfigurieren:

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

Füge den folgenden <build>-Abschnitt hinzu, um die XML-Mapping-Dateien zum Classpath hinzuzufügen:

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

Entitätsklasse verbessern

In diesem Schritt wirst du die Course-Entitätsklasse verbessern, indem du Eigenschaften, Konstruktoren, Setter/Getter-Methoden und anderen Inhalt hinzufügst.

Öffne die Course.java-Datei im Verzeichnis /src/main/java/org/labex/pojo.
Füge die folgenden Eigenschaften zur Course-Klasse hinzu:

    private int cNo;
    private String cName;
    private String teacher;

Füge den folgenden Konstruktor hinzu:

    public Course() {

    }

    public Course(int cNo, String cName, String teacher) {
        this.cNo = cNo;
        this.cName = cName;
        this.teacher = teacher;
    }

Füge die folgenden Getter- und Setter-Methoden hinzu:

    public int getCNo() {
        return cNo;
    }

    public void setCNo(int cNo) {
        this.cNo = cNo;
    }

    public String getCName() {
        return cName;
    }

    public void setCName(String cName) {
        this.cName = cName;
    }

    public String getTeacher() {
        return teacher;
    }

    public void setTeacher(String teacher) {
        this.teacher = teacher;
    }

Füge die folgende toString()-Methode hinzu:

    @Override
    public String toString() {
        return "Course number: " + this.cNo + "\tCourse name: " + this.cName + "\tTeacher: " + this.teacher;
    }

MyBatis-Konfiguration verbessern

In diesem Schritt wirst du die MyBatis-Konfigurationsdatei mybatis-config.xml verbessern.

Öffne die mybatis-config.xml-Datei im Verzeichnis src/main/resources.
Füge den folgenden <typeAliases>-Abschnitt hinzu, um Aliase für die Entitätsklassen zu definieren:

    <typeAliases>
        <package name="org.labex.pojo"/>
    </typeAliases>

Konfiguriere die Datenquellenumgebung im <environments>-Abschnitt:

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}" />
                <property name="url" value="${mysql.url}" />
                <property name="username" value="${mysql.username}" />
                <property name="password" value="${mysql.password}" />
            </dataSource>
        </environment>
    </environments>

Registriere die SQL-Mapping-Datei CourseMapper.xml im <mappers>-Abschnitt:

    <mappers>
        <package name="org.labex.mapper" />
    </mappers>

CourseMapper-Schnittstelle implementieren

In diesem Schritt wirst du die CourseMapper-Schnittstelle und deren entsprechende Methoden implementieren.

Öffne die CourseMapper.java-Datei im Paket org.labex.mapper.
Füge die folgenden Methoden zur CourseMapper-Schnittstelle hinzu:

import java.util.List;

import org.labex.pojo.Course;

public interface CourseMapper {

    /**
     * Abfrage aller Kursinformationen
     */
    public List<Course> queryAllCourse();

    /**
     * Einfügen eines neuen Kurses
     * @param course
     */
    public int insertCourse(Course course);

    /**
     * Aktualisieren von Kursinformationen
     * @param course
     */
    public int updateCourse(Course course);

    /**
     * Löschen von Kursinformationen anhand der Kursnummer
     * @param course
     */
    public int deleteCourse(int cNo);
}

SQL-Mapping implementieren

In diesem Schritt wirst du das SQL-Mapping in der CourseMapper.xml-Datei implementieren.

Öffne die CourseMapper.xml-Datei im Verzeichnis src/main/java/org/labex/mapper.
Füge die folgenden SQL-Mapping-Anweisungen hinzu:

    <!-- Abrufen aller Kursinformationen -->
    <select id="queryAllCourse" resultType="org.labex.pojo.Course">
        select * from course
    </select>

    <!-- Einfügen eines neuen Kurses -->
    <insert id="insertCourse" parameterType="org.labex.pojo.Course">
        insert into course(cNo,cName,teacher)
        values(#{cNo},#{cName},#{teacher})
    </insert>

    <!-- Aktualisieren von Kursinformationen basierend auf der Kursnummer -->
    <update id="updateCourse" parameterType="org.labex.pojo.Course">
        update course set cName=#{cName},teacher=#{teacher}
        where cNo=#{cNo}
    </update>

    <!-- Löschen von Kursinformationen basierend auf der Kursnummer -->
    <delete id="deleteCourse" parameterType="int">
        delete from course where cNo=#{cNo}
    </delete>

Testfälle implementieren

In diesem Schritt wirst du die Testfälle in der MyBatisTest.java-Datei implementieren.

Öffne die MyBatisTest.java-Datei im Verzeichnis /src/test/java/org/labex/test.
Füge die folgenden Testmethoden hinzu:

import java.io.IOException;
import java.io.Reader;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import org.labex.mapper.CourseMapper;
import org.labex.pojo.Course;

public class MyBatisTest {

    SqlSessionFactory sessionFactory = null;
    SqlSession session = null;

    @Before
    public void before() throws IOException{
        String resource = "mybatis-config.xml";
        // Lade die MyBatis-Konfigurationsdatei
        Reader reader = Resources.getResourceAsReader(resource);
        // Erstelle die SqlSession-Factory
        sessionFactory = new SqlSessionFactoryBuilder().build(reader);
        // Erstelle ein SqlSession-Objekt, das in der Lage ist, SQL-Anweisungen in SQL-Mapping-Dateien auszuführen
        session = sessionFactory.openSession();
    }

    @Test
    public void testSel() throws IOException{
        // Rufe die getMapper()-Methode in session auf, um das Schnittstellenobjekt zurückzugeben
        CourseMapper cMapper = session.getMapper(CourseMapper.class);
        // Führe die Abfrage aus und gebe alle Course-Objekte zurück
        List<Course> courses = cMapper.queryAllCourse();
        System.out.println(courses);
        session.close();
    }

    @Test
    public void testIns() throws IOException{
        // Rufe die getMapper()-Methode in session auf, um das Schnittstellenobjekt zurückzugeben
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

        Course course = new Course(8,"Künstliche Intelligenz","Tom");

        int i = cMapper.insertCourse(course);

        session.commit();

        System.out.println((i!=0? "Daten erfolgreich hinzugefügt":"Fehler beim Hinzufügen der Daten"));

        session.close();
    }

    @Test
    public void testUpd() throws IOException{
        // Rufe die getMapper()-Methode in session auf, um das Schnittstellenobjekt zurückzugeben
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

        Course course = new Course(1,"Softwaretesting","Jack");

        int i = cMapper.updateCourse(course);

        session.commit();

        System.out.println((i!=0? "Daten erfolgreich aktualisiert":"Fehler beim Aktualisieren der Daten"));

        session.close();
    }

    @Test
    public void testDEl() throws IOException{
        // Rufe die getMapper()-Methode in session auf, um das Schnittstellenobjekt zurückzugeben
        CourseMapper cMapper = session.getMapper(CourseMapper.class);

        int i = cMapper.deleteCourse(7);

        session.commit();

        System.out.println((i!=0? "Daten erfolgreich gelöscht":"Fehler beim Löschen der Daten"));

        session.close();
    }
}

Nach Abschluss dieser Schritte hast du das Projekt erfolgreich konfiguriert, die Entitätsklasse verbessert, die MyBatis-Einstellungen konfiguriert, die CourseMapper-Schnittstelle implementiert und die Testfälle implementiert. Du kannst jetzt die Tests ausführen, um die Funktionalität der Anwendung zu überprüfen.

Ausführen

Als nächstes kompilieren und ausführen Sie im Terminal und verwenden Sie Maven, um die Testdateien zu überprüfen:

cd MyBatisCourseDemo02
mvn test

Sie können sich an den untenstehenden Schritten wenden, um die Herausforderungsergebnisse zu überprüfen.

Unfertiger Testfall-Bild

Testausführungsresultate

Zusammenfassung

Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Labore absolvieren, um deine Fähigkeiten zu verbessern.

Kursplanung CRUD mit MyBatis