Kurzanleitung zu MyBatis

1. Einleitung

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 unserer pom.xml hinzufügen :

 org.mybatis mybatis 3.4.4 

Die neueste Version der Abhängigkeit finden Sie hier.

3. Java-APIs

3.1. SQLSessionFactory

SQLSessionFactory ist die Kernklasse für jede MyBatis-Anwendung. Diese Klasse wird instanziiert mithilfe von SQLSessionFactoryBuilder‘ s - Builder () Methode , die Lasten einer XML - Konfigurationsdatei:

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 Zuordnern, die Beziehungen zwischen Entitäten definieren. Diese werden zusammen zum Erstellen der SQLSessionFactory- Instanz verwendet:

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 über die SQLSessionFactory- Klasse instanziiert werden . Instanzen dieser Klasse sind nicht threadsicher.

Nach dem Ausführen des Datenbankvorgangs sollte die Sitzung geschlossen werden. Da SqlSession die AutoCloseable- Schnittstelle implementiert , können wir den Try-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 - repräsentiert eine einzelne Instanz von Result aus der Liste der Ergebnisse, die aus @Results abgerufen wurden. Es enthält die 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 ist getAddresses die Methode, die die Sammlung von Adressen 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 @Many haben wir die Annotation @One, die die Eins-zu-Eins-Zuordnungsbeziehung zwischen Objekten angibt.

  • @MapKey - Dies wird verwendet, um die Liste der Datensätze in die Karte der Datensätze mit dem Schlüsselzu konvertieren, der durch das Wertattribut definiert ist :
    @Select("select * from Person") @MapKey("personId") Map getAllPerson();
  • @Options - Diese Annotation gibt eine Vielzahl von Schaltern und Konfigurationen an, die definiert werden sollen, sodass wir sie nicht in anderen Anweisungendefinierenkönnen, sondern @Options , um sie zu definieren:
    @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. Damit können wir unser komplexes SQL genau 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 schwer zu debuggen.

Lassen Sie uns untersuchen, 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 tatsächlich 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. B. SELECT , WHERE usw. Damit können wir die Generierung der WHERE- Klausel dynamisch ändern .

7. Unterstützung für gespeicherte Prozeduren

Wir können die gespeicherte Prozedur auch mit der Annotation @Select ausführen . Hier müssen wir den Namen der gespeicherten Prozedur und die Parameterliste übergeben und diese Prozedur explizit aufrufen :

@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 gesehen, die von der Bibliothek bereitgestellt wurden.

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