streamalism.org

Most jelentettem be az újat Tanulj tavaszt tanfolyam, amelynek középpontjában az 5. tavasz és a tavaszi bakancs 2 alapjai állnak:

1. Áttekintés

Sokféleképpen kapcsolódhatunk a MySQL adatbázishoz a Java-ból, és ebben az oktatóanyagban több lehetőséget is meg fogunk vizsgálni, hogy miként lehet ezt elérni.

Kezdjük azzal, hogy megvizsgáljuk a JDBC és a Hibernate használatával vitathatatlanul legnépszerűbb lehetőségeket.

Ezután néhány külső könyvtárat is megvizsgálunk, beleértve a MyBatis, az Apache Cayenne és a Spring Data programokat. Útközben számos gyakorlati példát közölünk.

2. Előfeltételek

Feltételezzük, hogy már van egy MySQL szerver telepítve és futtatva a localhoston (alapértelmezett 3306-os port), és hogy van egy teszt sémánk a következő személy táblával:

CREATE TABLE személy (ID INT, FIRST_NAME VARCHAR (100), LAST_NAME VARCHAR (100));

Szükségünk lesz a mysql-connector-java műtárgy, amely mint mindig elérhető a Maven Central-tól:

 mysql mysql-connector-java 8.0.19 

3.Csatlakozás a JDBC használatával

A JDBC (Java Database Connectivity) egy API lekérdezések összekapcsolására és végrehajtására egy adatbázisban.

3.1. Közös tulajdonságok

A cikk folyamán általában több általános JDBC tulajdonságot fogunk használni:

• Kapcsolat URL - egy karaktersorozat, amelyet a JDBC illesztőprogram használ az adatbázishoz való csatlakozáshoz. Tartalmazhat olyan információkat, mint például az adatbázis keresési helye, a csatlakozáshoz szükséges adatbázis neve és egyéb konfigurációs tulajdonságok:

  jdbc: mysql: // [host] [, failoverhost ...] [: port] / [adatbázis] [? propertyName1] [= propertyValue1] [& propertyName2] [= propertyValue2] ...

  Ezt a tulajdonságot úgy állítjuk be: jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC

• Vezetőosztály - a használni kívánt vezető teljes osztályú neve. Esetünkben a MySQL illesztőprogramot fogjuk használni: com.mysql.cj.jdbc.Driver
• Felhasználónév és jelszó - a MySQL-fiók hitelesítő adatai

3.2. JDBC csatlakozási példa

Lássuk, hogyan tudunk csatlakozni az adatbázisunkhoz és végrehajtani egy egyszerű kijelölést egy erőforrás-próbálkozás segítségével:

String sqlSelectAllPersons = "SELECT * FROM személy"; Karakterlánc-kapcsolatUrl = "jdbc: mysql: // localhost: 3306 / test? ServerTimezone = UTC"; próbáld meg (Connection connect = DriverManager.getConnection (connectionUrl, "felhasználónév", "jelszó"); PreparedStatement ps = conn.prepareStatement (sqlSelectAllPersons); ResultSet rs = ps.executeQuery ()) {while (rs.next ()) {long id = rs.getLong ("ID"); Karakterlánc neve = rs.getString ("FIRST_NAME"); Karakterlánc vezetéknév = rs.getString ("LAST_NAME"); // tegyen valamit a kivont adatokkal ...}} catch (SQLException e) {// kezelje a kivételt}

Mint láthatjuk, a próbáld ki testet, végigvezetjük az eredményhalmazon, és kivonjuk az értékeket a személytáblázatból.

4.Csatlakozás ORM-ek használatával

Jellemzőbb módon a MySQL adatbázisunkhoz egy Object Relational Mapping (ORM) keretrendszer segítségével csatlakozunk. Tehát nézzünk meg néhány kapcsolódási példát, amelyek e keretek közül a legnépszerűbbeket használják.

4.1. Natív hibernált API-k

Ebben a szakaszban megtudhatjuk, hogyan lehet a Hibernate használatával kezelni az adatbázisunkhoz tartozó JDBC kapcsolatot.

Először hozzá kell adnunk a hibernált mag Maven-függőség:

 org.hibernate hibernate-core 5.4.10.Végső 

A hibernáláshoz minden egyes táblához létre kell hozni egy entitásosztályt. Menjünk előre, és definiáljuk a Személy osztály:

@Entity @Table (név = "Személy") nyilvános osztály Személy {@Id Hosszú id; @ Oszlop (név = "FIRST_NAME") Karakterlánc keresztnév; @ Oszlop (név = "LAST_NAME") Karakterlánc vezetéknév; // getters & setters} 

Egy másik lényeges szempont a Hibernate erőforrásfájl létrehozása, amelyet általában elneveznek hibernate.cfg.xml, ahol meghatározzuk a konfigurációs információkat:

     com.mysql.cj.jdbc.Driver jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC felhasználónév jelszó org.hibernate.dialect.MySQL5Dialect érvényesítés 

A hibernálásnak sok konfigurációs tulajdonsága van. A szokásos kapcsolattulajdonságok mellett érdemes megemlíteni a dialektus tulajdonságot, amely lehetővé teszi számunkra, hogy megadjuk az adatbázis SQL-dialektusának nevét.

Ezt a tulajdonságot használja a keretrendszer a Hibernate Query Language (HQL) utasítások megfelelő átalakítására az adott adatbázisunk megfelelő SQL-be. A hibernálás több mint 40 SQL-dialektussal rendelkezik. Mivel ebben a cikkben a MySQL-re koncentrálunk, maradunk a MySQL5Dialect nyelvjárás.

Végül a Hibernate-nek tudnia kell az entitásosztály teljes minősítésű nevét is a leképező címkén keresztül. Miután befejeztük a konfigurációt, használjuk a SessionFactory osztály, amely a JDBC kapcsolatok létrehozásáért és egyesítéséért felelős osztály.

Általában ezt csak egyszer kell beállítani egy alkalmazáshoz:

SessionFactory sessionFactory; // konfigurálja a hibernate.cfg.xml beállításokat a StandardServiceRegistry registry = new StandardServiceRegistryBuilder (). configure (). build (); próbáld ki az {sessionFactory = new MetadataSources (register) .buildMetadata (). buildSessionFactory (); } catch (e kivétel) {// a kivétel kezelése}

Most, hogy létrejött a kapcsolatunk, futtathatunk egy lekérdezést, hogy kiválasszuk az összes embert a személyi táblázatunkból:

Munkamenet = sessionFactory.openSession (); session.beginTransaction (); Lista eredménye = session.createQuery ("személytől", Személy.osztály) .lista (); result.forEach (személy -> {// tegyen valamit a Személy példánnyal ...}); session.getTransaction (). kötelezettség (); session.close ();

4.2. MyBatis

A MyBatis 2010-ben került bevezetésre, és egy SQL mapper keretrendszer, amelynek erőssége az egyszerűség. Egy másik oktatóanyagban arról beszéltünk, hogy miként integrálható a MyBatis a Spring and Spring Boot programba. Itt a MyBatis közvetlen konfigurálására összpontosítunk.

Használatához hozzá kell adnunk a mybatis függőség:

 org.mybatis mybatis 3.5.3 

Feltéve, hogy újrafelhasználjuk a Személy osztályban anotációk nélkül folytathatjuk a PersonMapper felület:

nyilvános felület PersonMapper {String selectAll = "SELECT * FROM Person"; @Select (selectAll) @Results (value = {@Result (tulajdonság = "id", oszlop = "ID"), @Result (tulajdonság = "keresztnév", oszlop = "FIRST_NAME"), @Result (tulajdonság = "vezetéknév" ", oszlop =" LAST_NAME ")}) Lista selectAll (); }

A következő lépés a MyBatis konfigurációjáról szól:

Az initMybatis () konfiguráció eldobja az SQLException {DataSource dataSource = getDataSource (); TransactionFactory trxFactory = new JdbcTransactionFactory (); Környezet env = új Környezet ("dev", trxFactory, dataSource); Configuration config = new Configuration (env); TypeAliasRegistry aliases = config.getTypeAliasRegistry (); aliases.registerAlias ​​("személy", Személy.osztály); config.addMapper (PersonMapper.class); return config; } DataSource getDataSource () dobja az SQLException {MysqlDataSource dataSource = új MysqlDataSource (); dataSource.setDatabaseName ("teszt"); dataSource.setServerName ("localhost"); dataSource.setPort (3306); dataSource.setUser ("felhasználónév"); dataSource.setPassword ("jelszó"); dataSource.setServerTimezone ("UTC"); return dataSource; }

A konfiguráció a Konfiguráció objektum, amely az olyan beállítások tárolója, mint a Környezet. Tartalmazza az adatforrás beállításait is.

Ezután használhatjuk a Konfiguráció objektum, amelyet általában egyszer állítanak be egy alkalmazás számára a SqlSessionFactory:

Konfigurációs konfiguráció = initMybatis (); SqlSessionFactory sqlSessionFactory = új SqlSessionFactoryBuilder (). Build (konfiguráció); try (SqlSession session = sqlSessionFactory.openSession ()) {PersonMapper mapper = session.getMapper (PersonMapper.class); Személyek felsorolása = mapper.selectAll (); // tegyen valamit a személyek listájával ...}

4.3. Apache Cayenne

Az Apache Cayenne egy olyan perzisztencia keretrendszer, amelynek első kiadása 2002-re nyúlik vissza. További információért javasoljuk, hogy olvassa el az Apache Cayenne bevezetését.

Szokás szerint tegyük hozzá a cayenne-szerver Maven-függőség:

 org.apache.cayenne cayenne-server 4.0.2 

Kifejezetten a MySQL kapcsolati beállításokra fogunk összpontosítani. Ebben az esetben konfiguráljuk a cayenne-project.xml:

A. Automatikus generálása után datamap.map.xml és Személy osztály a formájában CayenneDataObject, végrehajthatunk néhány kérdést.

Például folytatjuk a korábbiakhoz hasonlóan az összeset:

ServerRuntime cayenneRuntime = ServerRuntime.builder () .addConfig ("cayenne-project.xml") .build (); ObjectContext context = cayenneRuntime.newContext (); Személyek felsorolása = ObjectSelect.query (Person.class) .select (context); // tegyen valamit a személyek listájával ...

5.Csatlakozás a tavaszi adatok használatával

A Spring Data egy tavaszi programozási modell az adatokhoz való hozzáféréshez. Technikailag a Spring Data egy ernyő projekt, amely számos alprojektet tartalmaz, amelyek egy adott adatbázisra jellemzőek.

Lássuk, hogyan használhat két ilyen projektet a MySQL adatbázishoz való csatlakozáshoz.

5.1. Tavaszi adatok / JPA

A Spring Data JPA egy robusztus keretrendszer, amely segít csökkenteni a kazánlap kódját, és mechanizmust biztosít az alapvető CRUD műveletek végrehajtására a több előre definiált tárolói interfész egyikén keresztül.. Emellett számos más hasznos funkcióval is rendelkezik.

További információkért olvassa el a Spring Data JPA bevezetését.

A spring-data-jpa műtárgy megtalálható a Maven Central-on:

 org.springframework.data spring-data-jpa 2.2.4.KÖZLEMÉNY 

Folytatjuk a Személy osztály. A következő lépés a JPA beállítása kommentárokkal:

@Configuration @EnableJpaRepositories ("package.to.scan") nyilvános osztályú JpaConfiguration {@Bean public DataSource dataSource () {DriverManagerDataSource dataSource = new DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC"); dataSource.setUsername ("felhasználónév"); dataSource.setPassword ("jelszó"); return dataSource; } @Bean public JpaTransactionManageractionManager (EntityManagerFactory emf) {return new JpaTransactionManager (emf); } @Bean public JpaVendorAdapter jpaVendorAdapter () {HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter (); jpaVendorAdapter.setDatabase (Adatbázis.MYSQL); jpaVendorAdapter.setGenerateDdl (true); return jpaVendorAdapter; } @Bean public LocalContainerEntityManagerFactoryBean entitásManagerFactory () {LocalContainerEntityManagerFactoryBean lemfb = új LocalContainerEntityManagerFactoryBean (); lemfb.setDataSource (dataSource ()); lemfb.setJpaVendorAdapter (jpaVendorAdapter ()); lemfb.setPackagesToScan ("package.containing.entity.classes"); visszatér lemfb; }}

Ahhoz, hogy a Spring Data megvalósítsa a CRUD műveleteket, létre kell hoznunk egy interfészt, amely kiterjeszti a CrudRepository felület:

@Repository nyilvános felület A PersonRepository kiterjeszti a CrudRepository {}

És végül lássunk egy példát az összes kiválasztására a tavaszi adatokkal:

personRepository.findAll (). forEach (person -> {// tegyen valamit a kibontott személlyel});

5.2. Tavaszi adatok / JDBC

A Spring Data JDBC a Spring Data család korlátozott megvalósítása, amelynek elsődleges célja a relációs adatbázisokhoz való egyszerű hozzáférés lehetővé tétele.

Emiatt nem nyújt olyan funkciókat, mint a gyorsítótár, a piszkos követés, a lusta betöltés és sok más JPA funkció.

Ezúttal a Maven-függőségre van szükségünk spring-data-jdbc:

 org.springframework.data spring-data-jdbc 1.1.4.KÖZLEMÉNY 

A konfiguráció könnyebb ahhoz képest, amelyet az előző szakaszban használtunk a Spring Data JPA-hoz:

@Configuration @EnableJdbcRepositories ("package.to.scan") nyilvános osztály A JdbcConfiguration kiterjeszti az AbstractJdbcConfiguration {// NamedParameterJdbcOperations-t belsőleg használják SQL-utasítások elküldéséhez a @Bean NamedParameterJdbcOperdációs műveletek ((new); } @Bean PlatformTransactionManageractionManager () {return new DataSourceTransactionManager (dataSource ()); } @Bean public DataSource dataSource () {DriverManagerDataSource dataSource = új DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC"); dataSource.setUsername ("felhasználónév"); dataSource.setPassword ("jelszó"); return dataSource; }}

A Spring Data JDBC esetében meg kell határoznunk egy újat Személy osztályban vagy módosítsa a meglévőt néhány tavaszi megjegyzés hozzáadásához.

Ennek oka, hogy a Spring Data JDBC a hibernálás helyett közvetlenül az entitás leképezéséről gondoskodik:

import org.springframework.data.annotation.Id; import org.springframework.data.relational.core.mapping.Column; import org.springframework.data.relational.core.mapping.Table; @Table (value = "Person") public class Person {@Id Long id; @ Oszlop (érték = "FIRST_NAME") Karakterlánc keresztnév; @ Oszlop (érték = "LAST_NAME") Karakterlánc vezetéknév; // szerelők és beállítók}

A Spring Data JDBC-vel a CrudRepository felület. Tehát a nyilatkozat megegyezik azzal, amelyet fentebb írtunk a Spring Data JPA példában. Hasonlóképpen, ugyanez vonatkozik az Összes kijelölése példára is.

6. Következtetés

Ebben az oktatóanyagban számos különböző módszert láthattunk, hogyan lehet csatlakozni egy MySQL adatbázishoz Java-ból. A nélkülözhetetlen JDBC kapcsolattal kezdtük. Ezután olyan gyakran használt ORM-eket néztünk meg, mint a Hibernate, a Mybatis és az Apache Cayenne. Végül megnéztük a Spring Data JPA-t és a Spring Data JDBC-t.

A JDBC vagy a Hibernate API-k használata több kazánlap kódot jelent. A robusztus keretek, például a Spring Data vagy a Mybatis használata nagyobb konfigurációt igényel, de jelentős előnyt jelent, mert alapértelmezett megvalósításokat és funkciókat biztosítanak, mint például a gyorsítótár és a lusta betöltés.

Most jelentettem be az újat Tanulj tavaszt tanfolyam, amelynek középpontjában az 5. tavasz és a tavaszi bakancs 2 alapjai állnak: