Verbinden Sie Java mit einer MySQL-Datenbank

Java Top

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs

1. Übersicht

Es gibt viele Möglichkeiten, wie wir von Java aus eine Verbindung zu einer MySQL-Datenbank herstellen können. In diesem Lernprogramm werden wir verschiedene Optionen untersuchen, um zu sehen, wie dies erreicht werden kann.

Wir werden uns zunächst die wohl beliebtesten Optionen mit JDBC und Hibernate ansehen.

Dann werden wir uns auch einige externe Bibliotheken ansehen, darunter MyBatis, Apache Cayenne und Spring Data . Auf dem Weg werden wir eine Reihe von praktischen Beispielen liefern.

2. Voraussetzungen

Wir gehen davon aus, dass auf localhost bereits ein MySQL-Server installiert ist und ausgeführt wird (Standardport 3306) und dass wir ein Testschema mit der folgenden Personentabelle haben:

CREATE TABLE person ( ID INT, FIRST_NAME VARCHAR(100), LAST_NAME VARCHAR(100) );

Wir benötigen auch das MySQL-Connector-Java- Artefakt, das wie immer bei Maven Central erhältlich ist:

 mysql mysql-connector-java 8.0.19 

3. Verbindung über JDBC herstellen

JDBC (Java Database Connectivity) ist eine API zum Verbinden und Ausführen von Abfragen in einer Datenbank.

3.1. Allgemeine Eigenschaften

Im Verlauf dieses Artikels werden normalerweise mehrere allgemeine JDBC-Eigenschaften verwendet :

  • Verbindungs-URL - Eine Zeichenfolge, mit der der JDBC-Treiber eine Verbindung zu einer Datenbank herstellt. Es kann Informationen enthalten, z. B. wo nach der Datenbank gesucht werden soll, den Namen der Datenbank, zu der eine Verbindung hergestellt werden soll, und andere Konfigurationseigenschaften:
    jdbc:mysql://[host][,failoverhost...] [:port]/[database] [?propertyName1][=propertyValue1] [&propertyName2][=propertyValue2]...

    Wir werden diese Eigenschaft wie folgt festlegen : jdbc: mysql: // localhost: 3306 / test? ServerTimezone = UTC

  • Treiberklasse - Der vollständig qualifizierte Klassenname des zu verwendenden Treibers. In unserem Fall verwenden wir den MySQL-Treiber: com.mysql.cj.jdbc.Driver
  • Benutzername und Passwort - die Anmeldeinformationen des MySQL-Kontos

3.2. Beispiel für eine JDBC-Verbindung

Mal sehen, wie wir uns mit unserer Datenbank verbinden und eine einfache Auswahl durch einen Versuch mit mehreren Ressourcen ausführen können:

String sqlSelectAllPersons = "SELECT * FROM person"; String connectionUrl = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC"; try (Connection conn = DriverManager.getConnection(connectionUrl, "username", "password"); 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"); // do something with the extracted data... } } catch (SQLException e) { // handle the exception }

Wie wir sehen können, durchlaufen wir im try- Body die Ergebnismenge und extrahieren die Werte aus der Personentabelle.

4. Verbinden mit ORMs

In der Regel stellen wir mithilfe eines ORM-Frameworks (Object Relational Mapping) eine Verbindung zu unserer MySQL-Datenbank her . Schauen wir uns also einige Verbindungsbeispiele an, die das populärere dieser Frameworks verwenden.

4.1. Native Hibernate-APIs

In diesem Abschnitt erfahren Sie, wie Sie mit Hibernate eine JDBC-Verbindung zu unserer Datenbank verwalten.

Zuerst müssen wir die Maven-Abhängigkeit im Ruhezustand hinzufügen :

 org.hibernate hibernate-core 5.4.10.Final 

Für den Ruhezustand muss für jede Tabelle eine Entitätsklasse erstellt werden. Lassen Sie uns fortfahren und die Personenklasse definieren :

@Entity @Table(name = "Person") public class Person { @Id Long id; @Column(name = "FIRST_NAME") String firstName; @Column(name = "LAST_NAME") String lastName; // getters & setters } 

Ein weiterer wesentlicher Aspekt ist das Erstellen der Hibernate-Ressourcendatei mit dem typischen Namen hibernate.cfg.xml , in der Konfigurationsinformationen definiert werden:

     com.mysql.cj.jdbc.Driver jdbc:mysql://localhost:3306/test?serverTimezone=UTC username password  org.hibernate.dialect.MySQL5Dialect  validate    

Der Ruhezustand verfügt über viele Konfigurationseigenschaften. Neben den Standardverbindungseigenschaften ist die Dialekteigenschaft zu erwähnen, mit der wir den Namen des SQL-Dialekts für die Datenbank angeben können.

Diese Eigenschaft wird vom Framework verwendet, um HQL-Anweisungen (Hibernate Query Language) korrekt in das entsprechende SQL für unsere angegebene Datenbank zu konvertieren. Der Ruhezustand wird mit mehr als 40 SQL-Dialekten geliefert. Da wir uns in diesem Artikel auf MySQL konzentrieren, bleiben wir beim MySQL5Dialect- Dialekt.

Schließlich muss Hibernate auch den vollständig qualifizierten Namen der Entitätsklasse über das Mapping-Tag kennen. Sobald wir die Konfiguration abgeschlossen haben, verwenden wir die SessionFactory- Klasse, die für das Erstellen und Zusammenführen von JDBC-Verbindungen verantwortlich ist.

In der Regel muss dies nur einmal für eine Anwendung eingerichtet werden:

SessionFactory sessionFactory; // configures settings from hibernate.cfg.xml StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build(); try { sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory(); } catch (Exception e) { // handle the exception }

Nachdem wir unsere Verbindung eingerichtet haben, können wir eine Abfrage ausführen, um alle Personen aus unserer Personentabelle auszuwählen:

Session session = sessionFactory.openSession(); session.beginTransaction(); List result = session.createQuery("from Person", Person.class).list(); result.forEach(person -> { //do something with Person instance... }); session.getTransaction().commit(); session.close();

4.2. MyBatis

MyBatis wurde 2010 eingeführt und ist ein SQL-Mapper-Framework, dessen Stärke die Einfachheit ist . In einem anderen Tutorial haben wir darüber gesprochen, wie MyBatis in Spring und Spring Boot integriert werden kann. Hier konzentrieren wir uns darauf, wie Sie MyBatis direkt konfigurieren.

Um es zu verwenden, müssen wir die mybatis- Abhängigkeit hinzufügen :

 org.mybatis mybatis 3.5.3 

Angenommen, wir verwenden die oben genannte Person- Klasse ohne Anmerkungen wieder, können wir eine PersonMapper- Schnittstelle erstellen :

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

Der nächste Schritt dreht sich alles um die MyBatis-Konfiguration:

Configuration initMybatis() throws SQLException { DataSource dataSource = getDataSource(); TransactionFactory trxFactory = new JdbcTransactionFactory(); Environment env = new Environment("dev", trxFactory, dataSource); Configuration config = new Configuration(env); TypeAliasRegistry aliases = config.getTypeAliasRegistry(); aliases.registerAlias("person", Person.class); config.addMapper(PersonMapper.class); return config; } DataSource getDataSource() throws SQLException { MysqlDataSource dataSource = new MysqlDataSource(); dataSource.setDatabaseName("test"); dataSource.setServerName("localhost"); dataSource.setPort(3306); dataSource.setUser("username"); dataSource.setPassword("password"); dataSource.setServerTimezone("UTC"); return dataSource; }

Die Konfiguration besteht aus dem Erstellen eines Konfigurationsobjekts , das ein Container für Einstellungen wie die Umgebung ist . Es enthält auch die Datenquelleneinstellungen.

Wir können dann das Konfigurationsobjekt verwenden , das normalerweise einmal für eine Anwendung eingerichtet wird, um eine SqlSessionFactory zu erstellen :

Configuration configuration = initMybatis(); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration); try (SqlSession session = sqlSessionFactory.openSession()) { PersonMapper mapper = session.getMapper(PersonMapper.class); List persons = mapper.selectAll(); // do something with persons list ... }

4.3. Apache Cayenne

Apache Cayenne ist ein Persistenz-Framework, dessen erste Veröffentlichung auf das Jahr 2002 zurückgeht. Um mehr darüber zu erfahren, empfehlen wir Ihnen, unsere Einführung in Apache Cayenne zu lesen.

Fügen wir wie gewohnt die Cayenne-Server- Maven-Abhängigkeit hinzu:

 org.apache.cayenne cayenne-server 4.0.2 

Wir werden uns speziell auf die MySQL-Verbindungseinstellungen konzentrieren. In diesem Fall konfigurieren wir die Datei cayenne-project.xml :

After the automatic generation of the datamap.map.xml and Person class in the form of a CayenneDataObject, we can execute some queries.

For example, we'll continue as previously with a select all:

ServerRuntime cayenneRuntime = ServerRuntime.builder() .addConfig("cayenne-project.xml") .build(); ObjectContext context = cayenneRuntime.newContext(); List persons = ObjectSelect.query(Person.class).select(context); // do something with persons list...

5.Connecting Using Spring Data

Spring Data is a Spring-based programming model for data access. Technically, Spring Data is an umbrella project which contains many subprojects that are specific to a given database.

Let's see how to use two of these projects to connect to a MySQL database.

5.1. Spring Data / JPA

Spring Data JPA is a robust framework that helps reduce boilerplate code and provides a mechanism for implementing basic CRUD operations via one of several predefined repository interfaces. In addition to this, it has many other useful features.

Be sure to check out our introduction to Spring Data JPA to learn more.

The spring-data-jpa artifact can be found on Maven Central:

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

We'll continue using the Person class. The next step is to configure JPA using annotations:

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

To allow Spring Data to implement the CRUD operations, we have to create an interface that extends the CrudRepository interface:

@Repository public interface PersonRepository extends CrudRepository { }

And finally, let's see an example of select-all with Spring Data:

personRepository.findAll().forEach(person -> { // do something with the extracted person });

5.2. Spring Data / JDBC

Spring Data JDBC is a limited implementation of the Spring Data family, with its primary goal to allow simple access to relational databases.

For this reason, it doesn't provide features like caching, dirty tracking, lazy loading, and many other JPA features.

This time the Maven dependency we need is spring-data-jdbc:

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

The configuration is lighter compared to the one we used in the previous section for Spring Data JPA:

@Configuration @EnableJdbcRepositories("packages.to.scan") public class JdbcConfiguration extends AbstractJdbcConfiguration { // NamedParameterJdbcOperations is used internally to submit SQL statements to the database @Bean NamedParameterJdbcOperations operations() { return new NamedParameterJdbcTemplate(dataSource()); } @Bean PlatformTransactionManager transactionManager() { return new 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("username"); dataSource.setPassword("password"); return dataSource; } }

In the case of Spring Data JDBC, we have to define a new Person class or modify the existing one to add some Spring specific annotations.

This is because Spring Data JDBC will take care directly of the entity mapping instead of Hibernate:

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; @Column(value = "FIRST_NAME") String firstName; @Column(value = "LAST_NAME") String lastName; // getters and setters }

Mit Spring Data JDBC können wir auch die CrudRepository- Schnittstelle verwenden. Die Deklaration ist also identisch mit der, die wir oben im Spring Data JPA-Beispiel geschrieben haben. Gleiches gilt auch für das Select-All-Beispiel.

6. Fazit

In diesem Tutorial haben wir verschiedene Möglichkeiten gesehen, eine Verbindung zu einer MySQL-Datenbank von Java aus herzustellen . Wir haben mit der wesentlichen JDBC-Verbindung begonnen. Dann haben wir uns häufig verwendete ORMs wie Hibernate, Mybatis und Apache Cayenne angesehen. Schließlich haben wir uns Spring Data JPA und Spring Data JDBC angesehen.

Die Verwendung von JDBC- oder Hibernate-APIs bedeutet mehr Boilerplate-Code. Die Verwendung robuster Frameworks wie Spring Data oder Mybatis erfordert mehr Konfiguration, bietet jedoch einen erheblichen Vorteil, da sie Standardimplementierungen und -funktionen wie Caching und verzögertes Laden bieten.

Java unten

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs