streamalism.org

Jeg kunngjorde nettopp det nye Lær våren kurs, med fokus på det grunnleggende i vår 5 og vårstøvel 2:

1. Oversikt

Det er mange måter vi kan koble til en MySQL-database fra Java, og i denne opplæringen skal vi utforske flere alternativer for å se hvordan du kan oppnå dette.

Vi begynner med å se på uten tvil de mest populære alternativene ved hjelp av JDBC og Hibernate.

Deretter vil vi også se på noen eksterne biblioteker, inkludert MyBatis, Apache Cayenne og Spring Data. Underveis gir vi en rekke praktiske eksempler.

2. Forutsetninger

Vi antar at vi allerede har en MySQL-server installert og kjører på localhost (standardport 3306), og at vi har et testskjema med følgende persontabell:

OPPRETT TABELLperson (ID INT, FIRST_NAME VARCHAR (100), LAST_NAME VARCHAR (100));

Vi trenger også mysql-connector-java gjenstand som som alltid er tilgjengelig fra Maven Central:

 mysql mysql-connector-java 8.0.19 

3.Koble til med JDBC

JDBC (Java Database Connectivity) er et API for tilkobling og utføring av spørsmål i en database.

3.1. Vanlige egenskaper

I løpet av denne artikkelen bruker vi vanligvis flere vanlige JDBC-egenskaper:

• Connection URL - en streng som JDBC-driveren bruker for å koble til en database. Den kan inneholde informasjon som hvor du skal søke etter databasen, navnet på databasen du skal koble til og andre konfigurasjonsegenskaper:

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

  Vi setter denne eiendommen slik: jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC

• Sjåførklasse - det fullt kvalifiserte klassenavnet til sjåføren som skal brukes. I vårt tilfelle bruker vi MySQL-driveren: com.mysql.cj.jdbc.Driver
• Brukernavn og passord - legitimasjonen til MySQL-kontoen

3.2. Eksempel på JDBC-tilkobling

La oss se hvordan vi kan koble til databasen vår og utføre en enkel utvelgelse gjennom en prøve-med-flere ressurser:

String sqlSelectAllPersons = "VELG * FRA person"; Streng connectionUrl = "jdbc: mysql: // localhost: 3306 / test? ServerTimezone = UTC"; prøv (Connection conn = DriverManager.getConnection (connectionUrl, "brukernavn", "passord"); PreparedStatement ps = conn.prepareStatement (sqlSelectAllPersons); ResultSet rs = ps.executeQuery ()) {while (rs.next ()) {long id = rs.getLong ("ID"); Strengnavn = rs.getString ("FIRST_NAME"); Streng etternavn = rs.getString ("LAST_NAME"); // gjør noe med de ekstraherte dataene ...}} fangst (SQLException e) {// håndter unntaket}

Som vi kan se, inne i prøve kropp, gjentar vi gjennom resultatsettet og trekker ut verdiene fra persontabellen.

4.Koble til ved hjelp av ORM-er

Mer typisk vil vi koble til MySQL-databasen vår ved hjelp av en Object Relational Mapping (ORM) Framework. Så la oss se noen eksempler på tilkobling ved å bruke de mest populære av disse rammene.

4.1. Innfødte dvale-APIer

I denne delen vil vi se hvordan du bruker dvalemodus til å administrere en JDBC-forbindelse til databasen vår.

Først må vi legge til dvale-kjerne Maven avhengighet:

 org. dvale-dvalekjerne 5.4.10.Final 

Dvalemodus krever at det må opprettes en enhetsklasse for hver tabell. La oss gå videre og definere Person klasse:

@Entity @Table (name = "Person") offentlig klasse Person {@Id Long id; @Column (name = "FIRST_NAME") Streng fornavn; @Column (name = "LAST_NAME") Strengens etternavn; // getters & setters} 

Et annet viktig aspekt er å opprette ressursfilen Hibernate, vanligvis kalt dvalemodus.cfg.xml, der vi definerer konfigurasjonsinformasjon:

     com.mysql.cj.jdbc.Driver jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC brukernavn passord org.hibernate.dialect.MySQL5Dialect validere 

Dvalemodus har mange konfigurasjonsegenskaper. Bortsett fra standard tilkoblingsegenskaper, er det verdt å nevne dialektegenskapen som lar oss spesifisere navnet på SQL-dialekten for databasen.

Denne egenskapen brukes av rammeverket til å konvertere Hibernate Query Language (HQL) uttalelser riktig til riktig SQL for den gitte databasen vår. Dvale skip med mer enn 40 SQL-dialekter. Når vi fokuserer på MySQL i denne artikkelen, vil vi holde oss til MySQL5Dialect dialekt.

Endelig trenger dvalemodus også å vite det fullstendige navnet på enhetsklassen via kartleggingen. Når vi har fullført konfigurasjonen, bruker vi SessionFactory klasse, som er klassen som er ansvarlig for å opprette og samle JDBC-forbindelser.

Vanligvis trenger dette bare å settes opp en gang for en applikasjon:

SessionFactory sessionFactory; // konfigurerer innstillinger fra hibernate.cfg.xml StandardServiceRegistry registry = new StandardServiceRegistryBuilder (). configure (). build (); prøv {sessionFactory = nye MetadataSources (register) .buildMetadata (). buildSessionFactory (); } fange (Unntak e) {// håndtere unntaket}

Nå som vi har konfigurert forbindelsen vår, kan vi kjøre et spørsmål for å velge alle personene fra personbordet vårt:

Sessionsøkt = sessionFactory.openSession (); session.beginTransaction (); Listeresultat = session.createQuery ("fra person", person.klasse) .liste (); result.forEach (person -> {// gjør noe med Person-forekomst ...}); session.getTransaction (). commit (); session.close ();

4.2. MyBatis

MyBatis ble introdusert i 2010 og er et SQL mapper-rammeverk med enkelhet som styrke. I en annen opplæring snakket vi om hvordan du integrerer MyBatis med Spring and Spring Boot. Her vil vi fokusere på hvordan du konfigurerer MyBatis direkte.

For å bruke den, må vi legge til mybatis avhengighet:

 org.mybatis mybatis 3.5.3 

Forutsatt at vi gjenbruker Person klasse over uten merknader, kan vi fortsette å lage en PersonMapper grensesnitt:

offentlig grensesnitt PersonMapper {String selectAll = "SELECT * FROM Person"; @Velg (selectAll) @Results (value = {@Result (property = "id", column = "ID"), @Result (property = "firstName", column = "FIRST_NAME"), @Result (property = "lastName ", column =" LAST_NAME ")}) List selectAll (); }

Det neste trinnet handler om MyBatis-konfigurasjonen:

Konfigurasjon initMybatis () kaster SQLException {DataSource dataSource = getDataSource (); TransactionFactory trxFactory = ny JdbcTransactionFactory (); Miljø env = nytt miljø ("dev", trxFactory, dataSource); Configuration config = new Configuration (env); TypeAliasRegistry aliases = config.getTypeAliasRegistry (); aliases.registerAlias ​​("person", Person.class); config.addMapper (PersonMapper.class); returkonfigurasjon; } DataSource getDataSource () kaster SQLException {MysqlDataSource dataSource = ny MysqlDataSource (); dataSource.setDatabaseName ("test"); dataSource.setServerName ("localhost"); dataSource.setPort (3306); dataSource.setUser ("brukernavn"); dataSource.setPassword ("passord"); dataSource.setServerTimezone ("UTC"); returner datakilde; }

Konfigurasjonen består av å lage en Konfigurasjon objekt som er en beholder for innstillinger som Miljø. Den inneholder også innstillingene for datakilden.

Vi kan da bruke Konfigurasjon objekt, som normalt settes opp en gang for et program for å opprette et SqlSessionFactory:

Konfigurasjonskonfigurasjon = initMybatis (); SqlSessionFactory sqlSessionFactory = ny SqlSessionFactoryBuilder (). Build (konfigurasjon); prøv (SqlSession session = sqlSessionFactory.openSession ()) {PersonMapper mapper = session.getMapper (PersonMapper.class); Liste personer = mapper.selectAll (); // gjør noe med personlisten ...}

4.3. Apache Cayenne

Apache Cayenne er en utholdenhetsramme hvis første utgivelse dateres tilbake til 2002. For å lære mer om det, foreslår vi at du leser introduksjonen til Apache Cayenne.

Som vanlig, la oss legge til cayenne-server Maven avhengighet:

 org.apache.cayenne cayenne-server 4.0.2 

Vi skal spesifikt fokusere på MySQL-tilkoblingsinnstillingene. I dette tilfellet konfigurerer vi cayenne-project.xml:

Etter automatisk generering av datamap.map.xml og Person klasse i form av en CayenneDataObject, kan vi utføre noen spørsmål.

For eksempel fortsetter vi som tidligere med et utvalg alle:

ServerRuntime cayenneRuntime = ServerRuntime.builder () .addConfig ("cayenne-project.xml") .build (); ObjectContext context = cayenneRuntime.newContext (); Liste personer = ObjectSelect.query (Person.class) .select (context); // gjør noe med personliste ...

5.Koble til ved hjelp av vårdata

Spring Data er en vårbasert programmeringsmodell for datatilgang. Teknisk sett er Spring Data et paraplyprosjekt som inneholder mange delprosjekter som er spesifikke for en gitt database.

La oss se hvordan du bruker to av disse prosjektene for å koble til en MySQL-database.

5.1. Vårdata / JPA

Spring Data JPA er et robust rammeverk som hjelper til med å redusere kjeleplatekoden og gir en mekanisme for implementering av grunnleggende CRUD-operasjoner via ett av flere forhåndsdefinerte depotgrensesnitt.. I tillegg til dette har den mange andre nyttige funksjoner.

Husk å sjekke ut introduksjonen til Spring Data JPA for å lære mer.

De vår-data-jpa artefakt finner du på Maven Central:

 org.springframework.data spring-data-jpa 2.2.4.RELEASE 

Vi fortsetter å bruke Person klasse. Neste trinn er å konfigurere JPA ved hjelp av merknader:

@Configuration @EnableJpaRepositories ("packages.to.scan") offentlig klasse 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 ("brukernavn"); dataSource.setPassword ("passord"); returner datakilde; } @Bean public JpaTransactionManager transactionManager (EntityManagerFactory emf) {returner ny JpaTransactionManager (emf); } @Bean public JpaVendorAdapter jpaVendorAdapter () {HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter (); jpaVendorAdapter.setDatabase (Database.MYSQL); jpaVendorAdapter.setGenerateDdl (true); returner jpaVendorAdapter; } @Bean public LocalContainerEntityManagerFactoryBean entityManagerFactory () {LocalContainerEntityManagerFactoryBean lemfb = ny LocalContainerEntityManagerFactoryBean (); lemfb.setDataSource (dataSource ()); lemfb.setJpaVendorAdapter (jpaVendorAdapter ()); lemfb.setPackagesToScan ("packages.containing.entity.classes"); returner lemfb; }}

For å tillate Spring Data å implementere CRUD-operasjonene, må vi lage et grensesnitt som utvider CrudRepository grensesnitt:

@Repository offentlig grensesnitt PersonRepository utvider CrudRepository {}

Og til slutt, la oss se et eksempel på select-all med Spring Data:

personRepository.findAll (). forEach (person -> {// gjør noe med den ekstraherte personen});

5.2. Vårdata / JDBC

Spring Data JDBC er en begrenset implementering av Spring Data-familien, med sitt primære mål å gi enkel tilgang til relasjonsdatabaser.

Av denne grunn gir den ikke funksjoner som hurtigbufring, skitten sporing, lat lasting og mange andre JPA-funksjoner.

Denne gangen er Maven-avhengigheten vi trenger vår-data-jdbc:

 org.springframework.data spring-data-jdbc 1.1.4.RELEASE 

Konfigurasjonen er lettere sammenlignet med den vi brukte i forrige avsnitt for Spring Data JPA:

@Configuration @EnableJdbcRepositories ("packages.to.scan") offentlig klasse JdbcConfiguration utvider AbstractJdbcConfiguration {// NamedParameterJdbcOperations brukes internt til å sende inn SQL-setninger til databasen @Bean NamedParameterJdbcOperations-operasjoner () {return newJam } @Bean PlatformTransactionManager transactionManager () {returner ny DataSourceTransactionManager (dataSource ()); } @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 ("brukernavn"); dataSource.setPassword ("passord"); returner datakilde; }}

Når det gjelder Spring Data JDBC, må vi definere en ny Person klasse eller endre den eksisterende for å legge til noen vårspesifikke merknader.

Dette er fordi Spring Data JDBC tar seg av enhetskartleggingen i stedet for dvalemodus:

importer org.springframework.data.annotation.Id; importer org.springframework.data.relational.core.mapping.Column; importer org.springframework.data.relational.core.mapping.Table; @Table (value = "Person") Person i offentlig klasse {@Id Lang id; @Column (value = "FIRST_NAME") Streng fornavn; @Column (value = "LAST_NAME") Strengens etternavn; // getters og setters}

Med Spring Data JDBC kan vi også bruke CrudRepository grensesnitt. Så deklarasjonen vil være identisk med den vi skrev ovenfor i Spring Data JPA-eksemplet. På samme måte gjelder det samme eksemplet.

6. Konklusjon

I denne opplæringen har vi sett flere forskjellige måter å koble til en MySQL-database fra Java. Vi startet med den essensielle JDBC-forbindelsen. Så så vi på vanlige ORM-er som Hibernate, Mybatis og Apache Cayenne. Til slutt så vi på Spring Data JPA og Spring Data JDBC.

Å bruke JDBC eller Hibernate APIer betyr mer kjeleplatekode. Å bruke robuste rammer, som Spring Data eller Mybatis, krever mer konfigurasjon, men gir en betydelig fordel fordi de gir standardimplementeringer og funksjoner som caching og lat lasting.

Jeg kunngjorde nettopp det nye Lær våren kurs, med fokus på det grunnleggende i vår 5 og vårstøvel 2: