Kurzanleitung zu MyBatis

1. Einführung

MyBatis ist ein Open Source-Persistenz-Framework, das die Implementierung des Datenbankzugriffs in Java-Anwendungen vereinfacht. Es bietet Unterstützung für benutzerdefiniertes SQL, gespeicherte Prozeduren und verschiedene Arten von Zuordnungsbeziehungen.

Einfach ausgedrückt ist es eine Alternative zu JDBC und Hibernate.

2. Maven-Abhängigkeiten

Um MyBatis nutzen zu können, müssen wir die Abhängigkeit zu unserenpom.xml: hinzufügen


    org.mybatis
    mybatis
    3.4.4

Die neueste Version der Abhängigkeit befindet sich inhere.

3. Java-APIs

3.1. SQLSessionFactory

SQLSessionFactory ist die Kernklasse für jede MyBatis-Anwendung. Diese Klasse wird mithilfe der MethodeSQLSessionFactoryBuilder'sbuilder()instanziiert, mit der eine XML-Konfigurationsdatei geladen wird:

String resource = "mybatis-config.xml";
InputStream inputStream Resources.getResourceAsStream(resource);
SQLSessionFactory sqlSessionFactory
  = new SqlSessionFactoryBuilder().build(inputStream);

Die Java-Konfigurationsdatei enthält Einstellungen wie Datenquellendefinition, Transaktionsmanagerdetails und eine Liste von Mappern, die Beziehungen zwischen Entitäten definieren. Diese werden zusammen verwendet, um die Instanz vonSQLSessionFactoryzu erstellen:

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 enthält Methoden zum Ausführen von Datenbankoperationen, zum Abrufen von Mappern und zum Verwalten von Transaktionen. Es kann aus der Klasse vonSQLSessionFactoryinstanziiert werden. Instanzen dieser Klasse sind nicht threadsicher.

Nach dem Ausführen des Datenbankvorgangs sollte die Sitzung geschlossen werden. DaSqlSession dieAutoCloseable-Schnittstelle implementiert, können wir dentry-with-resources-Block verwenden:

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

4. Mapper

Mapper sind Java-Schnittstellen, die Methoden den entsprechenden SQL-Anweisungen zuordnen. MyBatis bietet Anmerkungen zum Definieren von Datenbankoperationen:

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

Sehen wir uns einige der wichtigsten Anmerkungen von MyBatis an:

*@Insert, @Select, @Update, @Delete* – Diese Annotationen stellen SQL-Anweisungen dar, die durch Aufrufen annotierter Methoden ausgeführt werden sollen:

@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 - Dies ist eine Liste von Ergebniszuordnungen, die Details zur Zuordnung der Datenbankspalten zu Java-Klassenattributen enthalten:

@Select("Select personId, name from Person where personId=#{personId}")
@Results(value = {
  @Result(property = "personId", column = "personId")
    // ...
})
public Person getPersonById(Integer personId);

@Result - stellt eine einzelne Instanz vonResult aus der Liste der Ergebnisse dar, die von@Results. abgerufen wurden. Es enthält Details wie die Zuordnung von der Datenbankspalte zur Java-Bean-Eigenschaft, den Java-Typ der Eigenschaft und auch die Zuordnung zu anderen Java-Objekten:
```
@Results(value = {
  @Result(property = "personId", column = "personId"),
  @Result(property="name", column = "name"),
  @Result(property = "addresses", javaType =List.class)
    // ...
})
public Person getPersonById(Integer personId);
```
*@Many* – gibt eine Zuordnung eines Objekts zu einer Sammlung der anderen Objekte an:
```
@Results(value ={
  @Result(property = "addresses", javaType = List.class,
    column = "personId",
    [email protected](select = "getAddresses"))
})
```
Hier istgetAddresses die Methode, die die Sammlung vonAddress durch Abfragen der Adresstabelle zurückgibt.
```
@Select("select addressId, streetAddress, personId from address
  where personId=#{personId}")
public Address getAddresses(Integer personId);
```
Ähnlich wie bei der Annotation von@Manyhaben wir die Annotation von@One, die die Eins-zu-Eins-Zuordnungsbeziehung zwischen Objekten angibt.
*@MapKey* – Hiermit wird die Liste der Datensätze inMap der Datensätze konvertiert, wobei der Schlüssel durch das Attributvalue definiert wird:
```
@Select("select * from Person")
@MapKey("personId")
Map getAllPerson();
```
*@Options* – Diese Annotation gibt eine Vielzahl von Schaltern und Konfigurationen an, die definiert werden sollen, damit wir sie nicht in anderen Anweisungen definieren können, sondern@Options:
```
@Insert("Insert into address (streetAddress, personId)
  values(#{streetAddress}, #{personId})")
@Options(useGeneratedKeys = false, flushCache=true)
public Integer saveAddress(Address address);
```

6. Dynamisches SQL

Dynamic SQL ist eine sehr leistungsstarke Funktion von MyBatis. Auf diese Weise können wir unser komplexes SQL präzise strukturieren.

Mit herkömmlichem JDBC-Code müssen wir SQL-Anweisungen schreiben, sie mit der Genauigkeit von Leerzeichen zwischen ihnen verketten und die Kommas an die richtigen Stellen setzen. Dies ist sehr fehleranfällig und bei großen SQL-Anweisungen sehr schwierig zu debuggen.

Lassen Sie uns erkunden, wie wir dynamisches SQL in unserer Anwendung verwenden können:

@SelectProvider(type=MyBatisUtil.class, method="getPersonByName")
public Person getPersonByName(String name);

Hier haben wir eine Klasse und einen Methodennamen angegeben, die das endgültige SQL erstellen und generieren:

public class MyBatisUtil {

    // ...

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

Dynamic SQL stellt alle SQL-Konstrukte als Klasse bereit, z. SELECT,WHERE usw. Damit können wir die Generierung derWHERE-Klausel dynamisch ändern.

7. Unterstützung für gespeicherte Prozeduren

Wir können die gespeicherte Prozedur auch mit der Annotation@Selectausführen. Hier müssen wir den Namen der gespeicherten Prozedur und die Parameterliste übergeben und ein explizitesCall für diese Prozedur verwenden:

@Select(value= "{CALL getPersonByProc(#{personId,
  mode=IN, jdbcType=INTEGER})}")
@Options(statementType = StatementType.CALLABLE)
public Person getPersonByProc(Integer personId);

8. Fazit

In diesem kurzen Tutorial haben wir die verschiedenen Funktionen von MyBatis und die Vereinfachung der Entwicklung datenbankbezogener Anwendungen kennengelernt. Wir haben auch verschiedene Anmerkungen der Bibliothek gesehen.

Der vollständige Code für diesen Artikel ist inover on GitHub verfügbar.

TOC

Kurzanleitung zu MyBatis