เชื่อมต่อ Spring boot application กับ database ด้วย Spring data JPA

กลับมาอีกครั้งกับบทความเกี่ยวกับ Spring และสำหรับวันนี้ผมก็มากับหัวข้อที่มีชื่อว่า “เชื่อมต่อ Spring boot application กับ database ด้วย JPA” นั่นเอง

JPA คืออะไร

ก่อนอื่นก็ต้องมาพูดถึงไอ่เจ้าตัว JPA ก่อนเลยว่ามันคืออะไร มีไว้ทำอะไร

JPA เป็นมาตรฐานหรือแนวทางในการทำ ORM (Object Relational Mapping) เช่น เคยเห็นพวก class java ของเราใช่มะ คือ JPA อ่ะ จะเป็นตัวบอกว่าเราจะต้องทำยังไงบ้างเพื่อที่จะเชื่อมต่อ java class ให้ไปเป็น table หรือ column ที่อยู่ใน database ของเรา

โดยส่วนใหญ่ใน spring เนี่ย มันจะมีสิ่งที่เรียกว่า Hibernate ให้ใช้อยู่ และ Hibernate ได้ทำการ implement ตาม JPA ไว้เรียบร้อยแล้ว พูดง่ายๆ อีซี่ แต่ทำจริงก็ เอ่อ…

สิ่งที่เราจะทำ

ถ้าจำได้เรามีโปรเจคลบเครื่องสำอางแฟนอยู่ สำหรับคนที่ยังไม่ได้อ่านและทำตามสามารถดูได้จากโพสนี้เลยงับ

Part 1: https://link.medium.com/SUtzD3V1bR

Part 2: https://link.medium.com/OrDOFBZ1bR

สำหรับ episode นี้เราก็จะมาเชื่อมต่อ Cosmetic api กับ H2 database กัน

สิ่งที่ต้องเตรียม

1. Project Cosmetics เดิมของเรานั่นเอง
2. เวลาอีกสัก 15 นาทีเหมือนเดิม

ลงมือ !

1. จัดการเตรียมสิ่งที่เราต้องใช้ให้พร้อม

ก่อนอื่นเลยเราต้องมาทำการเพิ่ม JPA module ไว้ในโปรเจคของเราก่อน โดยการใส่โค้ดด้านล่างไว้ใน pom.xml ของโปรเจคภายใต้ tag <dependencies> นั่นเองครับ

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

เท่านี้เราก็สามารถ implement JPA ได้แล้วคร้าบ

แต่ แต่ แต่ แต่ แต่ !! เราต้องใส่ module ของ database ที่เราจะใช้ลงไปใน pom.xml ของเราด้วยเช่นกัน จะใช้ oracle ก็ใส่ oracle ใช้ mysql ก็ใส่ mysql นะครับ ซึ่งผมเนี่ยจะใช้ H2 เพราะว่า มันใช้ง่ายเนื่องจากมันเป็น In-memory database พูดง่ายๆก็คือมันเก็บข้อมูลของเรา อยู่ใน RAM น่ะแหล่ะครับ

นั่นหมายความว่าข้อมูลทุกอย่างมันจะหายไปถ้าเราปิด Spring boot application ของเรา ซึ่งจริงๆมันมีวิธีทำให้มันไม่หายไปอยู่นะครับ แต่จะไม่ทำเพราะขี้เกียจ ถ้าสนใจลองเสิชหาคำว่า spring boot persistent h2 database ในกูเกิลดูครับ

ใส่โค้ดอันนี้เข้าไปใน pom.xml ภายใต้ tag <dependencies> ได้เลยค้าบ

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>

2. จัดโครงสร้าง package ของโปรเจคเราให้มันน่ารักสักนิ้ดนึง

เดิมที โปรเจค cosmetic api ของเราเนี่ย ทุกอย่างได้ถูกรวมอยู่ใน package เดียวเลยก็คือ com.thirajade.cosmetic.api แต่ตอนนี้โค้ดเรามันจะเริ่มเยอะขึ้นแล้ว ก็ต้องมาแบ่งให้มันดีๆสักหน่อย หน้าตาจะกลายเป็นแบบนี้

โครงสร้างของโปรเจคดูเป็นระเบียบขึ้นนิ้ดๆ

คือจริงๆลืมอธิบายไปใน บทความก่อนๆ ว่า ทำไมอ่ะ ทำไมมันต้อง controller? ทำไมมันต้อง service? ก็แหมะๆมันเข้าไปในไฟล์เดียวไม่ได้อ่อ controller ก็ไม่เห็นจะทำอะไรเรียกแค่ service

ก็มันเป็น concept ที่เรียกว่า MVC นั่นแหล่ะ ย่อมากจาก Model, View, and Controller หลายคนอาจจะเคยได้ยิน คือ โค้ดของเราจะถูกแบ่งเป็นสามส่วนนั่นก็คืออออออ

1. Model คือ ส่วนที่ทำหน้าที่เป็นรูปร่างลักษณะข้อมูลของเราว่าจะมีหน้าตาเป็นยังไง เช่นของเราเป็น cosmetic ใช่มะ ก็มี id, name, amount อะไรแบบนี้
2. View คือ ส่วนที่เป็นหน้าต่างของหัวใจให้ทุกคนเห็นซึ่ง… ในโค้ดของเรามันไม่มีอ่ะ ก็มันเป็นแค่ backend จะไปดูตรงไหนของมันดี 5555 ถ้าเป็น web จริงๆ ก็คือหน้า web นั่นแหล่ะ
3. Controller คือ ส่วนที่ทำหน้าที่เป็นสมองส่วนกลางของสามส่วนนี้ คือ รับ input มาจาก user แล้วก็ตัดสินใจ หรือ ประมวลผลว่า จะทำอะไรต่อน้า แล้วก็ทำ จากนั้นส่งค่า output กลับไปให้ user

ก็ประมาณนั้นครับ แต่ว่าในส่วนของ spring เนี่ย มันจะมีขึ้นมาอีกสองส่วนเล็กๆ นั่นก็คือ Service กับ Repository

4. Service คือ ส่วนที่ทำหน้าที่เก็บ Business Logic ทั้งหมดไว้เลย สังเกตว่า ใน Controller เรามันไม่ได้ทำอะไรเลยอ่ะ รับ input มาละก็เรียก service เลย อะไรแบบนั้น เพราะทุกอย่างมันมากองอยู่ตรงนี้ละแหล่ะ

5. Repository คือ ส่วนที่เชื่อมต่อ Database ให้เรา จะมี method query ต่างๆอยู่ในนี้เลย พวก findAll findBy โน่นนี่ จะมาอยู่ในนี่หมดเลย

มา ต่อไป เอาจริงละ

3. สร้าง entity หรือ model ของเราขึ้นมา

จริงๆเรามี entity แล้วแหล่ะ ก็คือ ตัว Cosmetic.java ของเรานั่นเอง แต่ Spring มันยังไม่รู้ว่าไอ้ตัวเนี้ยมันคือ entity นะ เราเลยต้องบอก spring สักหน่อย โดยการใส่ annotation @Entity เข้าไปให้ class Cosmetic หน้าตาก็จะเป็นแบบนี้เลย

เห็นว่าจะมีการใส่ Annotation @Id เข้าไปด้วย และตัว Id นี่แหล่ะจะเป็นส่วนที่บอกว่า field ไหนเป็น Primary Key ของเรา ส่วน @GeneratedValue เนี่ย ก็เป็นเหมือนการบอก spring ว่า ในdatabase อ่ะ column เนี้ย ขอเป็น auto-increment อะไรแบบนี้นะ

มีการแอบเพิ่ม default constructor เข้าไปด้วยแหล่ะ ก็คือ constructor ที่ไม่ทำอะไรเลย แต่ก็ต้องมีเนื่องจากว่า spring เนี่ย จำเป็นต้องใช้ default constructor ในการสร้าง instance ของ entity ขึ้นมานั่นเอง

4. สร้าง Repository โลด

สร้างแพคเกจใหม่ที่ชื่อ repositories ขึ้นมา และสร้างไฟล์ที่ชื่อ CosmeticRepository.java ได้เลย

ตัว Repository เนี่ย เราแทบจะไม่ต้อง Implement เองเลย เราแค่ทำการ extends JpaRepository ซึ่งหลังจากที่เราเพิ่ม spring-boot-starter-data-jpa เข้าไปก็จะมีตัวนี้ให้ใช้โดยอัตโนมัติเลย

เราจะสร้าง Repository เป็นแค่ Interface ก็พอเนื่องจากว่าเนื้อโค้ดที่จะใช้ในการทำ action กับ database เนี่ยมันถูก implement ไว้ให้ใน JpaRepository อยู่แล้ว หน้าตาที่ได้ออกมาก็เลยจะน่ารักกรุบกริบเลยทีเดียว

จุดสำคัญก็คือ extends JpaRepository<Cosmetic, String> สังเกตว่าตามหลัง JpaRepository มี Cosmetic กับ String แล้วสองตัวนี้คืออะไรล่ะ

• Cosmetic นั้นหมายถึง Entity ของเรา เราใช้ Entity ชื่ออะไรก็ใส่เป็นชื่อนั้นแหล่ะครับ
• String คือ Data type ของ Primary Key ของตัวแปร Entity นั้นๆ ซึ่งของเราเป็น String นั่นเองครับ

Method ที่ JpaRepository ได้ implement ให้เรามาแล้วเนี่ย สามารถไปดู source code interface ของเค้าได้ใน github ตาม link ด้านล่างได้เลยนะครับ อย่าลืมเลือก version ที่จะดูด้วยนะ

Link: https://github.com/spring-projects/spring-data-jpa/blob/master/src/main/java/org/springframework/data/jpa/repository/JpaRepository.java

5. แก้ ​Controller กับ Service ให้สามารถเพิ่มเครื่องสำอางได้

เราจะเพิ่ม Method POST สำหรับ path

/cosmetics 

เข้าไปให้กับ Controller ทำได้โดยใช้ Annotation ที่ชื่อ RequestMapping เหมือนเดิมเลย แค่เพิ่ม method เข้าไป ก็จะหน้าแบบนี้

@RequestMapping(value = "/cosmetics", method=RequestMethod.POST)

5.1 สร้าง Method addCosmetic ใน Controller

@RequestMapping(value = "/cosmetics", method=RequestMethod.POST)
public void addCosmetic(@RequestBody Cosmetic cosmetic) {
   cosmeticService.addCosmetic(cosmetic);
}

จะเห็นว่ามี Parameter ชนิด Cosmetic ที่ชื่อว่า cosmetic ด้วย แถมยังมี annotation RequestBody อีก มันไว้ทำอะไรล่ะเนี่ย

คือ Annotation RequestBody เนี่ย ไว้สำหรับบอก spring ว่า method นี้จะเป็น Body ของ HTTP POST request นั่นเอง

5.2 แก้ Service ให้รู้จัก Repository

สำหรับ Service นี่จะแก้เยอะหน่อย เนื่องจากคราวก่อนเราทำเป็นเก็บใส่ Attribute ของ class CosmeticService แต่ตอนนี้เราจะทำการลบออก และแก้บางส่วน หน้าตาจะเปลี่ยนไปเยอะหน่อย แต่จะน่ารักขึ้นนะ แบบนี้

ส่วนที่แก้ก็มี

• ลบตัวแปร cosmetics
• เพิ่ม CosmeticRepository และ ทำการ Autowire ด้วย
• แก้ทุก method ที่มีให้ใช้ CosmeticRepository
• เพิ่ม method addCosmetic

ใน method getCosmetic เนี่ย จะมีการใช้ cosmeticRepository.findAll() ด้วย ก็หมายถึงว่าเราจะ ค้นหา Cosmetic ทั้งหมดนั่นเอง

ส่วน addCosmetic ก็จะเป็น cosmeticRepository.save() ซึ่ง .save() เนี่ยก็คือการเก็บข้อมูลลงไปใน database นี่เอง

ทีนี้ทุกครั้งที่แฟนเราซื้อเครื่องสำอางเราก็มาแอบเพิ่มในนี้เนี่ยแหล่ะ หึหึหึหึหึหึ

5. ทดสอบบบบบบบ

สำหรับคนที่ยังไม่มี Postman ต้องไปโหลดก่อนนะครับ โหลดได้ที่ลิ้งค์นี้เลย

Download Postman

ถ้ามีแล้วก็มาลองเพิ่ม เครื่องสำอางดูกันดีกว่า ไหนๆก็มี API ให้ใช้ละ ทำการส่ง request ไปที่ path

localhost:8080/cosmetics

โดยใช้ Method เป็น POST และใส่ Body เป็นแบบนี้ อย่าลืมเปลี่ยนเป็น type application/json ด้วยน้า

พอกด Send ก็จะได้ผลลัพธ์เปล่าๆมา แสดงว่าสำเร็จแล้วว แบบนี้

ผลลัพธ์ว่างเปล่า แสดงว่าสำเร็จ

ลอง GET ขึ้นมาดูสักหน่อย

ผลลัพธ์จากการ GET ขึ้นมา

ได้แล้ววววววววว อิอิ

บทสรุป

การเชื่อมต่อ database เบื้องต้นก็สามารถทำได้โดยใช้ JpaRepository ก็ทำให้เราใช้ method พื้นฐานเช่น .save() หรือ .findAll() และเห็นได้ว่า โค้ดที่เขียนนั้นมีไม่เยอะและเข้าใจง่ายอีกด้วยครับ ทีนี้ก็จะสร้างจะลบให้สะใจไปซะเลย หึ่ย ไม่ได้เก็บกดเท่าไหร่

สำหรับตอนหน้าจะเป็นเนื้อหาเกี่ยวกับอะไรก็กด follow ติดตามไว้ได้เลยคร้าบ

อ้างอิงจาก

Accessing Data with JPA