streamalism.org

1. Inleiding

MyBatis is een open source persistentieframework dat de implementatie van databasetoegang in Java-applicaties vereenvoudigt. Het biedt ondersteuning voor aangepaste SQL, opgeslagen procedures en verschillende soorten mapping-relaties.

Simpel gezegd, het is een alternatief voor JDBC en Hibernate.

2. Maven afhankelijkheden

Om gebruik te kunnen maken van MyBatis moeten we de afhankelijkheid toevoegen aan onze pom.xml:

 org.mybatis mybatis 3.4.4 

De laatste versie van de afhankelijkheid is hier te vinden.

3. Java-API's

3.1. SQLSessionFactory

SQLSessionFactory is de kernklasse voor elke MyBatis-applicatie. Deze klasse wordt geïnstantieerd door SQLSessionFactoryBuilder 's bouwer() methode die een XML-configuratiebestand laadt:

String resource = "mybatis-config.xml"; InputStream inputStream Resources.getResourceAsStream (bron); SQLSessionFactory sqlSessionFactory = nieuwe SqlSessionFactoryBuilder (). Build (inputStream);

Het Java-configuratiebestand bevat instellingen zoals gegevensbrondefinitie, transactiebeheerderdetails en een lijst met mappers die relaties tussen entiteiten definiëren, deze worden samen gebruikt om de SQLSessionFactory voorbeeld:

openbare statische SqlSessionFactory buildqlSessionFactory () {DataSource dataSource = nieuwe PooledDataSource (DRIVER, URL, GEBRUIKERSNAAM, WACHTWOORD); Environment environment = nieuwe omgeving ("Ontwikkeling", nieuwe JdbcTransactionFactory (), dataSource); Configuratieconfiguratie = nieuwe configuratie (omgeving); configuration.addMapper (PersonMapper.class); // ... SqlSessionFactoryBuilder builder = nieuwe SqlSessionFactoryBuilder (); return builder.build (configuratie); }

3.2. SQLSession

SQLSession bevat methoden voor het uitvoeren van databasebewerkingen, het verkrijgen van mappers en het beheren van transacties. Het kan worden geïnstantieerd vanuit SQLSessionFactory klasse. Instanties van deze klasse zijn niet thread-safe.

Na het uitvoeren van de databasebewerking moet de sessie worden afgesloten. Sinds SqlSession implementeert het AutoCloseable interface, kunnen we de probeer-met-middelen blok:

probeer (SqlSession session = sqlSessionFactory.openSession ()) {// werk doen}

4. Mappers

Mappers zijn Java-interfaces die methoden toewijzen aan de bijbehorende SQL-instructies. MyBatis biedt annotaties voor het definiëren van databasebewerkingen:

openbare interface PersonMapper {@Insert ("Invoegen in persoon (naam) waarden (# {naam})") openbaar geheel getal save (Persoon persoon); // ... @Select ("Select personId, name from Person where personId = # {personId}") @Results (value = {@Result (property = "personId", column = "personId"), @Result (property = "name", column = "name"), @Result (property = "adressen", javaType = List.class, column = "personId", [email protected] (select = "getAddresses"))}) publiek persoon getPersonById (Geheel getal personId); // ...}

5. MyBatis-annotaties

Laten we eens kijken naar enkele van de belangrijkste annotaties van MyBatis:

• @Insert, @Select, @Update, @Delete – die annotaties vertegenwoordigen SQL-instructies die moeten worden uitgevoerd door geannoteerde methoden aan te roepen:

  @Insert ("Invoegen in persoon (naam) waarden (# {naam})") openbaar Geheel getal save (Persoon persoon); @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 ("SELECTEER person.personId, person.name VAN persoon WAAR person.personId = # {personId}") Persoon getPerson (Integer personId);

• @Resultaten - het is een lijst met resultaattoewijzingen die de details bevatten van hoe de databasekolommen worden toegewezen aan Java-klasseattributen:

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

• @Resultaat - het vertegenwoordigt een enkel exemplaar van Resultaat uit de lijst met resultaten die zijn opgehaald uit @Resultaten. Het bevat de details zoals de toewijzing van de databasekolom naar de Java-bean-eigenschap, het Java-type van de eigenschap en ook de associatie met andere Java-objecten:

  @Results (waarde = {@Result (property = "personId", column = "personId"), @Result (property = "name", column = "name"), @Result (property = "adressen", javaType = Lijst .class) // ...}) public Person getPersonById (Integer personId);

• @Veel – het specificeert een toewijzing van een object aan een verzameling van de andere objecten:

  @Results (waarde = {@Result (property = "adressen", javaType = List.class, column = "personId", [email protected] (select = "getAddresses"))})

  Hier getAddresses is de methode die de verzameling van Adres door de Adrestabel op te vragen.

  @Select ("selecteer addressId, streetAddress, personId from address where personId = # {personId}") openbaar adres getAddresses (Integer personId);

  Gelijkwaardig aan @Veel annotatie hebben we @Een annotatie die de één-op-één-toewijzingsrelatie tussen objecten specificeert.

• @MapKey – dit wordt gebruikt om de lijst met records naar te converteren Kaart van records met de sleutel zoals gedefinieerd door waarde attribuut:

  @Select ("select * from Person") @MapKey ("personId") Map getAllPerson ();

• @Opties – deze annotatie specificeert een breed scala aan schakelaars en configuraties die moeten worden gedefinieerd, zodat we in plaats van ze op andere instructies te definiëren, @Opties om ze te definiëren:

  @Insert ("Invoegen in adres (streetAddress, personId) waarden (# {streetAddress}, # {personId})") @Options (useGeneratedKeys = false, flushCache = true) openbaar geheel getal saveAddress (adresadres);

6. Dynamische SQL

Dynamic SQL is een zeer krachtige functie van MyBatis. Hiermee kunnen we onze complexe SQL nauwkeurig structureren.

Met traditionele JDBC-code moeten we SQL-instructies schrijven, deze samenvoegen met de nauwkeurigheid van spaties ertussen en de komma's op de juiste plaats zetten. Dit is zeer foutgevoelig en erg moeilijk te debuggen, in het geval van grote SQL-instructies.

Laten we eens kijken hoe we dynamische SQL in onze applicatie kunnen gebruiken:

@SelectProvider (type = MyBatisUtil.class, method = "getPersonByName") publieke persoon getPersonByName (String naam);

Hier hebben we een klasse en een methode naam gespecificeerd die feitelijk de uiteindelijke SQL construeert en genereert:

openbare klasse MyBatisUtil {// ... openbare tekenreeks getPersonByName (tekenreeksnaam) {retourneer nieuwe SQL () {{SELECT ("*"); FROM ("persoon"); WAAR ("naam zoals # {naam} || '%'"); }}. toString (); }}

Dynamische SQL biedt alle SQL-constructies als een klasse, bijv. SELECTEER, WAAR etc. Hiermee kunnen we de generatie van dynamisch veranderen WAAR clausule.

7. Ondersteuning voor opgeslagen procedures

We kunnen de opgeslagen procedure ook uitvoeren met @Selecteer annotatie. Hier moeten we de naam van de opgeslagen procedure, de parameterlijst doorgeven en een expliciet Bel bij die procedure:

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

8. Conclusie

In deze korte tutorial hebben we de verschillende functies van MyBatis gezien en hoe het de ontwikkeling van database-gerichte applicaties vergemakkelijkt. We hebben ook verschillende annotaties gezien van de bibliotheek.

De volledige code voor dit artikel is beschikbaar op GitHub.