Hubungkan Java ke Database MySQL

Java Top

Saya baru saja mengumumkan kursus Learn Spring baru , yang berfokus pada dasar-dasar Spring 5 dan Spring Boot 2:

>> LIHAT KURSUSnya

1. Ikhtisar

Ada banyak cara kita dapat terhubung ke database MySQL dari Java dan dalam tutorial ini, kita akan menjelajahi beberapa opsi untuk melihat bagaimana mencapainya.

Kami akan mulai dengan melihat opsi yang bisa dibilang paling populer menggunakan JDBC dan Hibernate.

Kemudian, kita juga akan melihat beberapa pustaka eksternal termasuk MyBatis, Apache Cayenne dan Spring Data . Kami akan memberikan sejumlah contoh praktis.

2. Prasyarat

Kami akan berasumsi bahwa kami sudah menginstal server MySQL dan berjalan di localhost (port default 3306) dan kami memiliki skema pengujian dengan tabel orang berikut:

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

Kami juga membutuhkan artefak mysql-connector-java yang seperti biasa tersedia dari Maven Central:

 mysql mysql-connector-java 8.0.19 

3. Menghubungkan Menggunakan JDBC

JDBC (Java Database Connectivity) adalah API untuk menghubungkan dan menjalankan kueri pada database.

3.1. Properti Umum

Selama kursus artikel ini, kami biasanya akan menggunakan beberapa properti JDBC umum :

  • Connection URL - string yang digunakan driver JDBC untuk menyambungkan ke database. Ini bisa berisi informasi seperti di mana mencari database, nama database yang akan disambungkan dan properti konfigurasi lainnya:
    jdbc:mysql://[host][,failoverhost...] [:port]/[database] [?propertyName1][=propertyValue1] [&propertyName2][=propertyValue2]...

    Kami akan menyetel properti ini seperti ini: jdbc: mysql: // localhost: 3306 / test? ServerTimezone = UTC

  • Kelas pengemudi - nama kelas yang sepenuhnya memenuhi syarat dari pengemudi yang akan digunakan. Dalam kasus kami, kami akan menggunakan driver MySQL: com.mysql.cj.jdbc.Driver
  • Nama pengguna dan kata sandi - kredensial akun MySQL

3.2. Contoh Koneksi JDBC

Mari kita lihat bagaimana kita dapat terhubung ke database kita dan menjalankan pilihan semua sederhana melalui coba-dengan-banyak-sumber:

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 }

Seperti yang bisa kita lihat, di dalam tubuh percobaan , kita mengulang melalui kumpulan hasil dan mengekstrak nilai dari tabel orang.

4. Menghubungkan Menggunakan ORM

Biasanya, kami akan terhubung ke database MySQL kami menggunakan Kerangka Pemetaan Relasional Objek (ORM) . Jadi, mari kita lihat beberapa contoh koneksi yang menggunakan kerangka kerja yang lebih populer ini.

4.1. API Hibernasi Asli

Di bagian ini, kita akan melihat bagaimana menggunakan Hibernate untuk mengelola koneksi JDBC ke database kita.

Pertama, kita perlu menambahkan dependensi Maven hibernate-core :

 org.hibernate hibernate-core 5.4.10.Final 

Hibernasi mensyaratkan bahwa kelas entitas harus dibuat untuk setiap tabel. Mari lanjutkan dan tentukan kelas Person :

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

Aspek penting lainnya adalah membuat file sumber daya Hibernate, biasanya bernama hibernate.cfg.xml , di mana kami akan menentukan informasi konfigurasi:

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

Hibernate memiliki banyak properti konfigurasi. Terlepas dari properti koneksi standar, ada baiknya menyebutkan properti dialek yang memungkinkan kita menentukan nama dialek SQL untuk database.

Properti ini digunakan oleh kerangka kerja untuk mengubah pernyataan Hibernate Query Language (HQL) dengan benar ke dalam SQL yang sesuai untuk database yang kami berikan. Hibernate dikirimkan dengan lebih dari 40 dialek SQL. Karena kami fokus pada MySQL dalam artikel ini, kami akan tetap menggunakan dialek MySQL5Dialect .

Terakhir, Hibernate juga perlu mengetahui nama kelas entitas yang sepenuhnya memenuhi syarat melalui tag pemetaan. Setelah kami menyelesaikan konfigurasi, kami akan menggunakan kelas SessionFactory , yang merupakan kelas yang bertanggung jawab untuk membuat dan menggabungkan koneksi JDBC.

Biasanya, ini hanya perlu disiapkan sekali untuk aplikasi:

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 }

Sekarang setelah koneksi kami siap, kami dapat menjalankan kueri untuk memilih semua orang dari tabel person kami:

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 diperkenalkan pada tahun 2010 dan merupakan kerangka kerja SQL mapper dengan kesederhanaan sebagai kekuatannya . Di tutorial lain, kami berbicara tentang cara mengintegrasikan MyBatis dengan Spring dan Spring Boot. Di sini, kita akan fokus pada bagaimana mengkonfigurasi MyBatis secara langsung.

Untuk menggunakannya, kita perlu menambahkan dependensi mybatis :

 org.mybatis mybatis 3.5.3 

Dengan asumsi bahwa kita menggunakan kembali kelas Person di atas tanpa anotasi, kita dapat melanjutkan untuk membuat antarmuka PersonMapper :

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(); }

Langkah selanjutnya adalah tentang konfigurasi MyBatis:

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; }

The configuration consists of creating a Configuration object which is a container for settings such as the Environment. It also contains the data source settings.

We can then use the Configuration object, which is normally set up once for an application to create a SqlSessionFactory:

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 is a persistence framework whose first release dates back to 2002. To learn more about it, we suggest reading our introduction to Apache Cayenne.

As usual, let's add the cayenne-server Maven dependency:

 org.apache.cayenne cayenne-server 4.0.2 

We're going to specifically focus on the MySQL connection settings. In this case, we'll configure the 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 }

Dengan Spring Data JDBC, kita juga dapat menggunakan antarmuka CrudRepository . Jadi deklarasi akan identik dengan yang kami tulis di atas dalam contoh JPA Spring Data. Demikian juga, hal yang sama berlaku untuk contoh pilih semua.

6. Kesimpulan

Dalam tutorial ini, kami telah melihat beberapa cara berbeda untuk terhubung ke database MySQL dari Java . Kami mulai dengan koneksi JDBC yang penting. Kemudian kami melihat ORM yang umum digunakan seperti Hibernate, Mybatis, dan Apache Cayenne. Terakhir, kami melihat Spring Data JPA dan Spring Data JDBC.

Menggunakan JDBC atau Hibernate API berarti lebih banyak kode boilerplate. Menggunakan kerangka kerja yang kuat, seperti Spring Data atau Mybatis, memerlukan lebih banyak konfigurasi tetapi memberikan keuntungan yang signifikan karena kerangka tersebut menyediakan implementasi dan fitur default seperti caching dan lazy loading.

Jawa bawah

Saya baru saja mengumumkan kursus Learn Spring baru , yang berfokus pada dasar-dasar Spring 5 dan Spring Boot 2:

>> LIHAT KURSUSnya