streamalism.org

Ik heb zojuist het nieuwe aangekondigd Leer de lente natuurlijk, gericht op de basisprincipes van Spring 5 en Spring Boot 2:

1. Overzicht

Er zijn veel manieren waarop we vanuit Java verbinding kunnen maken met een MySQL-database en in deze tutorial gaan we verschillende opties onderzoeken om te zien hoe we dit kunnen bereiken.

We beginnen met het bekijken van misschien wel de meest populaire opties met JDBC en Hibernate.

Vervolgens kijken we ook naar enkele externe bibliotheken, waaronder MyBatis, Apache Cayenne en Spring Data. Onderweg geven we een aantal praktische voorbeelden.

2. Randvoorwaarden

We gaan ervan uit dat we al een MySQL-server hebben geïnstalleerd en draaien op localhost (standaardpoort 3306) en dat we een testschema hebben met de volgende persoonstabel:

MAAK TABEL persoon (ID INT, FIRST_NAME VARCHAR (100), LAST_NAME VARCHAR (100));

We hebben ook de mysql-connector-java artefact dat zoals altijd verkrijgbaar is bij Maven Central:

 mysql mysql-connector-java 8.0.19 

3.Verbinding maken met JDBC

JDBC (Java Database Connectivity) is een API voor het verbinden en uitvoeren van query's op een database.

3.1. Gemeenschappelijke eigenschappen

In de loop van dit artikel zullen we doorgaans verschillende algemene JDBC-eigenschappen gebruiken:

• Verbindings-URL - een tekenreeks die het JDBC-stuurprogramma gebruikt om verbinding te maken met een database. Het kan informatie bevatten zoals waar naar de database moet worden gezocht, de naam van de database waarmee verbinding moet worden gemaakt en andere configuratie-eigenschappen:

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

  We stellen deze eigenschap als volgt in: jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC

• Bestuurdersklasse - de volledig gekwalificeerde klassenaam van de te gebruiken bestuurder. In ons geval gebruiken we de MySQL-driver: com.mysql.cj.jdbc.Driver
• Gebruikersnaam en wachtwoord - de inloggegevens van het MySQL-account

3.2. Voorbeeld van een JDBC-verbinding

Laten we eens kijken hoe we verbinding kunnen maken met onze database en een eenvoudige alles-selectie kunnen uitvoeren via een poging-met-meerdere-bronnen:

String sqlSelectAllPersons = "SELECTEER * VAN persoon"; String connectionUrl = "jdbc: mysql: // localhost: 3306 / test? ServerTimezone = UTC"; probeer (Connection conn = DriverManager.getConnection (connectionUrl, "gebruikersnaam", "wachtwoord"); PreparedStatement ps = conn.prepareStatement (sqlSelectAllPersons); ResultSet rs = ps.executeQuery ()) {while (rs.next ()) {long id = rs.getLong ("ID"); String name = rs.getString ("FIRST_NAME"); String lastName = rs.getString ("LAST_NAME"); // doe iets met de geëxtraheerde gegevens ...}} catch (SQLException e) {// behandel de uitzondering}

Zoals we kunnen zien, binnenin de proberen body, we doorlopen de resultatenset en halen de waarden uit de persoonstabel.

4.Verbinding maken met behulp van ORM's

Meestal maken we verbinding met onze MySQL-database met behulp van een Object Relational Mapping (ORM) Framework. Laten we dus enkele verbindingsvoorbeelden bekijken met behulp van de meer populaire van deze frameworks.

4.1. Native slaapstand-API's

In dit gedeelte zullen we zien hoe u Hibernate kunt gebruiken om een ​​JDBC-verbinding met onze database te beheren.

Eerst moeten we de slaapstand-core Maven-afhankelijkheid:

 org.hibernate hibernate-core 5.4.10.Final 

Hibernate vereist dat voor elke tabel een entiteitsklasse wordt gemaakt. Laten we doorgaan en het Persoon klasse:

@Entity @Table (name = "Person") openbare klasse Persoon {@Id Lange id; @Column (name = "FIRST_NAME") String firstName; @Column (name = "LAST_NAME") String lastName; // getters & setters} 

Een ander essentieel aspect is het maken van het Hibernate-bronbestand, meestal genoemd slaapstand.cfg.xml, waar we configuratie-informatie zullen definiëren:

     com.mysql.cj.jdbc.Driver jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC gebruikersnaam wachtwoord org.hibernate.dialect.MySQL5Dialect valideren 

Hibernate heeft veel configuratie-eigenschappen. Afgezien van de standaard verbindingseigenschappen, is het de moeite waard om de dialecteigenschap te vermelden waarmee we de naam van het SQL-dialect voor de database kunnen specificeren.

Deze eigenschap wordt door het framework gebruikt om Hibernate Query Language (HQL) -instructies correct om te zetten in de juiste SQL voor onze gegeven database. Hibernate wordt geleverd met meer dan 40 SQL-dialecten. Aangezien we ons in dit artikel concentreren op MySQL, houden we vast aan de MySQL5Dialect dialect.

Ten slotte moet Hibernate ook de volledig gekwalificeerde naam van de entiteitsklasse kennen via de mapping-tag. Zodra we de configuratie hebben voltooid, gebruiken we de SessionFactory class, de klasse die verantwoordelijk is voor het maken en poolen van JDBC-verbindingen.

Meestal hoeft dit maar één keer te worden ingesteld voor een toepassing:

SessionFactory sessionFactory; // configureert instellingen van hibernate.cfg.xml StandardServiceRegistry registry = nieuwe StandardServiceRegistryBuilder (). configure (). build (); probeer {sessionFactory = nieuwe MetadataSources (register) .buildMetadata (). buildSessionFactory (); } catch (uitzondering e) {// de uitzondering afhandelen}

Nu we onze verbinding hebben opgezet, kunnen we een query uitvoeren om alle mensen uit onze persoonstabel te selecteren:

Sessiesessie = sessionFactory.openSession (); session.beginTransaction (); Lijstresultaat = session.createQuery ("van persoon", Persoon.klasse) .list (); result.forEach (person -> {// doe iets met Person instance ...}); session.getTransaction (). commit (); session.close ();

4.2. MyBatis

MyBatis werd geïntroduceerd in 2010 en is een SQL-mapper-framework met eenvoud als kracht. In een andere tutorial hebben we het gehad over het integreren van MyBatis met Spring en Spring Boot. Hier zullen we ons concentreren op het rechtstreeks configureren van MyBatis.

Om het te gebruiken, moeten we het mybatis afhankelijkheid:

 org.mybatis mybatis 3.5.3 

Ervan uitgaande dat we het Persoon klasse hierboven zonder annotaties, kunnen we doorgaan met het maken van een PersonMapper koppel:

openbare interface PersonMapper {String selectAll = "SELECTEER * VAN Persoon"; @Select (selectAll) @Results (waarde = {@Result (property = "id", column = "ID"), @Result (property = "firstName", column = "FIRST_NAME"), @Result (property = "lastName" ", column =" LAST_NAME ")}) Lijst selectAll (); }

De volgende stap heeft alles te maken met de MyBatis-configuratie:

Configuratie initMybatis () gooit SQLException {DataSource dataSource = getDataSource (); TransactionFactory trxFactory = nieuwe JdbcTransactionFactory (); Omgeving env = nieuwe omgeving ("dev", trxFactory, dataSource); Configuratie config = nieuwe configuratie (env); TypeAliasRegistry aliassen = config.getTypeAliasRegistry (); aliases.registerAlias ​​("persoon", Persoon.klasse); config.addMapper (PersonMapper.class); return config; } DataSource getDataSource () gooit SQLException {MysqlDataSource dataSource = nieuwe MysqlDataSource (); dataSource.setDatabaseName ("test"); dataSource.setServerName ("localhost"); dataSource.setPort (3306); dataSource.setUser ("gebruikersnaam"); dataSource.setPassword ("wachtwoord"); dataSource.setServerTimezone ("UTC"); retourneer dataSource; }

De configuratie bestaat uit het maken van een Configuratie object dat een container is voor instellingen zoals het Milieu. Het bevat ook de gegevensbroninstellingen.

We kunnen dan de Configuratie -object, dat normaal gesproken eenmaal wordt ingesteld voor een toepassing om een SqlSessionFactory:

Configuratieconfiguratie = initMybatis (); SqlSessionFactory sqlSessionFactory = nieuwe SqlSessionFactoryBuilder (). Build (configuratie); probeer (SqlSession-sessie = sqlSessionFactory.openSession ()) {PersonMapper-mapper = session.getMapper (PersonMapper.class); Lijst personen = mapper.selectAll (); // doe iets met personenlijst ...}

4.3. Apache Cayenne

Apache Cayenne is een persistentiekader waarvan de eerste release dateert uit 2002. Om er meer over te weten, raden we aan om onze inleiding tot Apache Cayenne te lezen.

Laten we zoals gewoonlijk het cayenne-server Maven-afhankelijkheid:

 org.apache.cayenne cayenne-server 4.0.2 

We gaan ons specifiek richten op de MySQL-verbindingsinstellingen. In dit geval configureren we het cayenne-project.xml:

Na het automatisch genereren van de datamap.map.xml en Persoon klasse in de vorm van een CayenneDataObjectkunnen we enkele queries uitvoeren.

We gaan bijvoorbeeld door zoals eerder met alles selecteren:

ServerRuntime cayenneRuntime = ServerRuntime.builder () .addConfig ("cayenne-project.xml") .build (); ObjectContext context = cayenneRuntime.newContext (); Lijst personen = ObjectSelect.query (Person.class) .select (context); // doe iets met personenlijst ...

5.Verbinding maken met Spring Data

Spring Data is een op Spring gebaseerd programmeermodel voor gegevenstoegang. Technisch gezien is Spring Data een overkoepelend project dat veel subprojecten bevat die specifiek zijn voor een bepaalde database.

Laten we eens kijken hoe we twee van deze projecten kunnen gebruiken om verbinding te maken met een MySQL-database.

5.1. Spring Data / JPA

Spring Data JPA is een robuust raamwerk dat helpt bij het verminderen van standaardcode en biedt een mechanisme voor het implementeren van basis CRUD-bewerkingen via een van de verschillende vooraf gedefinieerde repository-interfaces. Daarnaast heeft het vele andere handige functies.

Bekijk onze inleiding tot Spring Data JPA voor meer informatie.

De spring-data-jpa artefact is te vinden op Maven Central:

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

We blijven de Persoon klasse. De volgende stap is om JPA te configureren met behulp van annotaties:

@Configuration @EnableJpaRepositories ("packages.to.scan") openbare klasse JpaConfiguration {@Bean openbare DataSource dataSource () {DriverManagerDataSource dataSource = nieuwe DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC"); dataSource.setUsername ("gebruikersnaam"); dataSource.setPassword ("wachtwoord"); retourneer dataSource; } @Bean openbare JpaTransactionManager transactionManager (EntityManagerFactory emf) {retourneer nieuwe JpaTransactionManager (emf); } @Bean openbare JpaVendorAdapter jpaVendorAdapter () {HibernateJpaVendorAdapter jpaVendorAdapter = nieuwe HibernateJpaVendorAdapter (); jpaVendorAdapter.setDatabase (Database.MYSQL); jpaVendorAdapter.setGenerateDdl (true); retourneer jpaVendorAdapter; } @Bean openbaar LocalContainerEntityManagerFactoryBean entityManagerFactory () {LocalContainerEntityManagerFactoryBean lemfb = nieuwe LocalContainerEntityManagerFactoryBean (); lemfb.setDataSource (dataSource ()); lemfb.setJpaVendorAdapter (jpaVendorAdapter ()); lemfb.setPackagesToScan ("packages.containing.entity.classes"); retourneer lemfb; }}

Om Spring Data in staat te stellen de CRUD-bewerkingen te implementeren, moeten we een interface maken die de CrudRepository koppel:

@Repository openbare interface PersonRepository breidt CrudRepository uit {}

En tot slot, laten we eens kijken naar een voorbeeld van alles selecteren met Spring Data:

personRepository.findAll (). forEach (person -> {// doe iets met de uitgepakte persoon});

5.2. Spring Data / JDBC

Spring Data JDBC is een beperkte implementatie van de Spring Data-familie, met als voornaamste doel eenvoudige toegang tot relationele databases mogelijk te maken.

Om deze reden biedt het geen functies zoals caching, vuile tracking, lazy loading en vele andere JPA-functies.

Deze keer is de Maven-afhankelijkheid die we nodig hebben spring-data-jdbc:

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

De configuratie is lichter in vergelijking met degene die we in de vorige sectie hebben gebruikt voor Spring Data JPA:

@Configuration @EnableJdbcRepositories ("packages.to.scan") openbare klasse JdbcConfiguration breidt AbstractJdbcConfiguration uit {// NamedParameterJdbcOperations wordt intern gebruikt om SQL-instructies naar de database te sturen @Bean NamedParameterJdbcOperations newJdbcOperations (return) -bewerkingen () } @Bean PlatformTransactionManager transactionManager () {retourneer nieuwe DataSourceTransactionManager (dataSource ()); } @Bean openbare DataSource dataSource () {DriverManagerDataSource dataSource = nieuwe DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC"); dataSource.setUsername ("gebruikersnaam"); dataSource.setPassword ("wachtwoord"); retourneer dataSource; }}

In het geval van Spring Data JDBC moeten we een nieuw Persoon class of wijzig de bestaande om enkele Spring-specifieke annotaties toe te voegen.

Dit komt omdat Spring Data JDBC direct voor de entiteitstoewijzing zorgt in plaats van Hibernate:

importeer org.springframework.data.annotation.Id; importeer org.springframework.data.relational.core.mapping.Column; importeer org.springframework.data.relational.core.mapping.Table; @Table (value = "Persoon") openbare klasse Persoon {@Id Lange id; @Column (value = "FIRST_NAME") String firstName; @Column (value = "LAST_NAME") String lastName; // getters en setters}

Met Spring Data JDBC kunnen we ook de CrudRepository koppel. De verklaring zal dus identiek zijn aan degene die we hierboven schreven in het voorbeeld van Spring Data JPA. Hetzelfde geldt voor het voorbeeld alles selecteren.

6. Conclusie

In deze tutorial hebben we verschillende manieren gezien om vanuit Java verbinding te maken met een MySQL-database. We zijn begonnen met de essentiële JDBC-verbinding. Vervolgens hebben we gekeken naar veelgebruikte ORM's zoals Hibernate, Mybatis en Apache Cayenne. Ten slotte hebben we Spring Data JPA en Spring Data JDBC bekeken.

Het gebruik van JDBC- of Hibernate-API's betekent meer standaardcode. Het gebruik van robuuste frameworks, zoals Spring Data of Mybatis, vereist meer configuratie, maar biedt een aanzienlijk voordeel omdat ze standaardimplementaties en functies bieden, zoals caching en lazy loading.

Ik heb zojuist het nieuwe aangekondigd Leer de lente natuurlijk, gericht op de basisprincipes van Spring 5 en Spring Boot 2: