Sambungkan Spring Boot dengan MySQL

Hello semua,

Dalam tutorial ini saya akan menerangkan proses yang saya ikuti untuk menyambungkan Spring Boot dengan MySQL, untuk mencipta API untuk Front-End saya.

Prasyarat:

• IDE (Saya menggunakan Intellij IDEA jadi tutorial ini akan berdasarkan itu)

• Meja Kerja MySql

Klik di sini untuk kod sumber.

Buat projek Spring Boot menggunakan Spring Initializr

Lawati start.spring.io dan pilih:
Projek: Maven
Bahasa: Java
But Spring: 3.3.0
Tulis medan yang diperlukan dengan kandungan anda
Pembungkusan: JAR
Jawa: 17

Bagi tanggungan, kami memerlukan:

• Pemandu MySQL

• Web Musim Bunga

• Data Musim Bunga JPA

Selepas ini, initializr sepatutnya kelihatan seperti ini:

Klik Jana dan simpan folder dalam laluan yang anda inginkan dan ekstrak kandungan folder.

Konfigurasi Intellij dan Mysql

Pertama sekali buat pangkalan data dalam MySQL. Saya menggunakan MySQL Workbench untuk ini.

Malah pangkalan data yang paling ringkas akan berfungsi, seperti ini:

Buka kandungan folder dalam IDE yang anda inginkan. Saya akan membincangkan tutorial ini menggunakan Intellij IDEA.

Buka fail application.properties yang terletak di scr/resources/application.properties

Dalam fail ini, kami mengkonfigurasi tetapan yang akan membantu kami menyambung dalam pangkalan data kami.

Tulis tetapan ini dalam fail:

Gantikan ${DB_NAME}, ${DB_USER}, ${DB_PASSWORD} dengan bukti kelayakan pangkalan data anda.

Tetapan ini akan membantu kami berhubung dengan pangkalan data yang kami cipta:

spring.jpa.show-sql=true:

Ini membolehkan pengelogan pernyataan SQL yang dijana oleh Hibernate. Apabila ditetapkan kepada benar, Hibernate akan mencetak pernyataan SQL ke konsol.

spring.jpa.hibernate.ddl-auto=update:

Tetapan ini digunakan untuk mengemas kini skema pangkalan data secara automatik agar sepadan dengan definisi entiti. Kemas kini nilai bermakna Hibernate akan mengemas kini skema sedia ada, menambah sebarang lajur atau jadual baharu yang diperlukan oleh pemetaan entiti.

logging.level.org.hibernate.SQL=DEBUG:

Ini menetapkan tahap pengelogan untuk logger Hibernate SQL kepada DEBUG. Ia akan memberikan maklumat terperinci tentang pernyataan SQL yang sedang dilaksanakan.

logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE:

Ini menetapkan tahap pengelogan untuk pengikat SQL deskriptor jenis Hibernate kepada TRACE. Ini akan log maklumat terperinci tentang pengikatan parameter dalam pernyataan SQL.

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver:

Ini menentukan nama kelas pemacu JDBC untuk MySQL. Ia memberitahu Spring Boot pemacu yang hendak digunakan untuk mewujudkan sambungan ke pangkalan data.

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect:

Ini menetapkan dialek Hibernate kepada MySQLDialect, yang dioptimumkan untuk MySQL. Ia membolehkan Hibernate menjana pernyataan SQL yang serasi dengan MySQL.

Sekarang, buat subpakej dalam pakej utama projek anda, dan panggil ia "model". Di dalam, buat kelas memanggilnya mengikut cara yang anda mahu, dalam kes saya, saya akan memanggilnya Pengguna.

package com.evaluation.evaluationSystem.model;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class Users {
    public Long getId() {
        return id;
    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    @Column(name = "email")
    private String email;

    @Column(name = "password")
    private String password;

    public void setId(Long id) {
        this.id = id;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

Dalam fail ini, dalam fail ini kami mentakrifkan Pengguna entiti JPA yang akan dipetakan kepada pengguna jadual pangkalan data. Kelas termasuk medan untuk id, e-mel dan kata laluan yang sepadan dengan lajur dalam jadual pengguna, jadi pastikan medan itu sejajar dengan lajur pangkalan data anda.

Seterusnya, buat subpakej lain yang dipanggil "pengawal" dan buat fail di dalamnya.

package com.evaluation.evaluationSystem.controller;

import com.evaluation.evaluationSystem.model.Users;
import com.evaluation.evaluationSystem.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
public class UsersController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<Users> getUsers(@RequestParam("search") Optional<String> searchParam){
        return searchParam.map(param -> userRepository.getContainingQuote(param))
                .orElse(userRepository.findAll());
    }
}

Dalam fail ini, kami mentakrifkan titik akhir API RESTful (/pengguna) yang boleh menapis entiti Pengguna secara pilihan berdasarkan parameter carian. Ia menggunakan UserRepository untuk interaksi pangkalan data dan mengembalikan hasil dalam format JSON disebabkan oleh anotasi @RestController. Gantikan "/users" dengan mana-mana titik akhir yang anda mahukan.

Buat satu lagi (yang terakhir) sub-pakej yang dipanggil repositori dan buat antara muka fail (berhati-hati, bukan kelas).

package com.evaluation.evaluationSystem.repository;

import com.evaluation.evaluationSystem.model.Users;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface UserRepository extends JpaRepository<Users, Long> {
    @Query("SELECT u FROM Users u WHERE u.email LIKE %:word%")
    List<Users> getContainingQuote(@Param("word") String word);
}

Dalam fail ini, kami mentakrifkan pertanyaan yang akan membolehkan kami mendapatkan semula data daripada pangkalan data. Pastikan anda mengeditnya berdasarkan keperluan anda. Kami menulis pertanyaan ini menggunakan JPQL (Java Persistence Query Language). Ia ialah bahasa pertanyaan yang ditakrifkan sebagai sebahagian daripada spesifikasi Java Persistence API (JPA), yang digunakan untuk melaksanakan operasi pangkalan data pada objek dan entiti Java.

Struktur folder terakhir anda sepatutnya kelihatan seperti ini:

Sekarang, navigasi ke fail utama (dalam kes saya, EvaluationSystemApplication) dan jalankan projek. Jika semuanya berfungsi dengan baik, melawat localhost:8080/users (atau titik akhir yang anda pilih) akan memaparkan data anda daripada pangkalan data. Pastikan anda mengisi jadual data dengan beberapa kandungan.

Kesimpulan

Saya harap tutorial ini membantu anda. Saya juga baru dalam persekitaran ini, jadi saya juga belajar. Setiap komen dan cadangan adalah lebih daripada dialu-alukan!

Jangan teragak-agak untuk berhenti mengikuti akaun GitHub saya untuk kekal dikemas kini dalam perjalanan saya untuk membangunkan apl web tindanan penuh menggunakan Spring Boot, MySQL dan React!

Atas ialah kandungan terperinci Sambungkan Spring Boot dengan MySQL. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!