Spring Boot 4 Microservices & REST APIs · บทเรียน

การดำเนินการ CRUD

นำการดำเนินการสร้าง อ่าน อัปเดต และลบไปใช้โดยใช้เมธอดคลังข้อมูลอันทรงพลังของ Spring Data JPA

บทเรียน 6 จาก 611 ขั้นตอน

การดำเนินการ CRUD เป็นบทเรียน Spring Boot 4 Microservices & REST APIs ฟรีบน CoddyKit นี่คือบทเรียนที่ 6 จากทั้งหมด 6 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Spring Boot 4 Microservices & REST APIs และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Spring Boot 4 Microservices & REST APIs มีบทเรียนทั้งหมด 6 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

CRUD Operations: The Core

Welcome to the heart of data management! Today, we'll master CRUD operations with Spring Data JPA. CRUD is a fundamental concept for almost any application that interacts with a database.

Create: Adding new data.
Read: Retrieving existing data.
Update: Modifying existing data.
Delete: Removing data.

Spring Data JPA provides powerful, easy-to-use methods for all of these!

Our Example Setup: Product

To demonstrate CRUD, we'll use a simple Product entity and its corresponding repository. You would have learned to set these up in previous lessons.

Here's our basic Product entity and ProductRepository interface:

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    public Product() {}
    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    // Getters and Setters (omitted for brevity)
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }

    @Override
    public String toString() {
        return "Product{id=" + id + ", name='" + name + "', price=" + price + "}";
    }
}

// ProductRepository.java
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
}

Creating New Data (C)

To create new data, we use the save() method from our repository. If the entity's ID is null (or 0 for primitive types), Spring Data JPA knows it's a new entry and will insert it into the database.

Try creating a new product:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Entity
class Product {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    public Product() {}
    public Product(String name, double price) {
        this.name = name; this.price = price;
    }
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() { return "Product{id=" + id + ", name='" + name + "', price=" + price + "}"; }
}

@Repository
interface ProductRepository extends JpaRepository<Product, Long> {}

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class, args);
        ProductRepository productRepository = context.getBean(ProductRepository.class);

        Product newProduct = new Product("Laptop", 1200.00);
        Product savedProduct = productRepository.save(newProduct);
        System.out.println("Created: " + savedProduct);
    }
}

Reading Data by ID (R)

To read a specific item, you often need its unique identifier (ID). The findById(ID id) method is perfect for this. It returns an Optional, which helps handle cases where the item might not exist.

Let's find the product we just created:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;

@Entity
class Product {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    public Product() {}
    public Product(String name, double price) {
        this.name = name; this.price = price;
    }
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() { return "Product{id=" + id + ", name='" + name + "', price=" + price + "}"; }
}

@Repository
interface ProductRepository extends JpaRepository<Product, Long> {}

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class, args);
        ProductRepository productRepository = context.getBean(ProductRepository.class);

        Product newProduct = new Product("Keyboard", 75.00);
        Product savedProduct = productRepository.save(newProduct);
        System.out.println("Created: " + savedProduct);

        Optional<Product> foundProduct = productRepository.findById(savedProduct.getId());
        foundProduct.ifPresent(p -> System.out.println("Found: " + p));
    }
}

Reading All Data (R)

What if you want to see all the products in your database? The findAll() method does exactly that! It returns a List of all entities of that type.

Let's retrieve all products:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;

@Entity
class Product {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    public Product() {}
    public Product(String name, double price) {
        this.name = name; this.price = price;
    }
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() { return "Product{id=" + id + ", name='" + name + "', price=" + price + "}"; }
}

@Repository
interface ProductRepository extends JpaRepository<Product, Long> {}

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class, args);
        ProductRepository productRepository = context.getBean(ProductRepository.class);

        productRepository.save(new Product("Mouse", 25.00));
        productRepository.save(new Product("Monitor", 300.00));

        List<Product> allProducts = productRepository.findAll();
        System.out.println("All Products:");
        allProducts.forEach(System.out::println);
    }
}

Updating Existing Data (U)

To update an existing item, you first retrieve it, modify its properties, and then call save() again. Spring Data JPA detects that the entity already has an ID, so it performs an update instead of an insert.

Let's update a product's price:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Entity
class Product {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    public Product() {}
    public Product(String name, double price) {
        this.name = name; this.price = price;
    }
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() { return "Product{id=" + id + ", name='" + name + "', price=" + price + "}"; }
}

@Repository
interface ProductRepository extends JpaRepository<Product, Long> {}

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class, args);
        ProductRepository productRepository = context.getBean(ProductRepository.class);

        Product existingProduct = new Product("Headphones", 150.00);
        productRepository.save(existingProduct);
        System.out.println("Original: " + existingProduct);

        existingProduct.setPrice(120.00); // Update the price
        Product updatedProduct = productRepository.save(existingProduct);
        System.out.println("Updated: " + updatedProduct);
    }
}

Deleting Data by ID (D)

To delete an item, you can use its ID with the deleteById(ID id) method. This is a common way to remove a specific record from the database.

Let's delete a product by its ID:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Entity
class Product {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    public Product() {}
    public Product(String name, double price) {
        this.name = name; this.price = price;
    }
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() { return "Product{id=" + id + ", name='" + name + "', price=" + price + "}"; }
}

@Repository
interface ProductRepository extends JpaRepository<Product, Long> {}

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class, args);
        ProductRepository productRepository = context.getBean(ProductRepository.class);

        Product productToDelete = new Product("Webcam", 50.00);
        productRepository.save(productToDelete);
        System.out.println("Product to delete: " + productToDelete);

        productRepository.deleteById(productToDelete.getId());
        System.out.println("Is product deleted? " + !productRepository.existsById(productToDelete.getId()));
    }
}

Deleting an Entity Object (D)

Alternatively, you can delete an entity by passing the actual entity object to the delete(T entity) method. This is useful if you've already retrieved the object and want to remove it.

Let's delete a product using its object:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Entity
class Product {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    public Product() {}
    public Product(String name, double price) {
        this.name = name; this.price = price;
    }
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() { return "Product{id=" + id + ", name='" + name + "', price=" + price + "}"; }
}

@Repository
interface ProductRepository extends JpaRepository<Product, Long> {}

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Main.class, args);
        ProductRepository productRepository = context.getBean(ProductRepository.class);

        Product productToRemove = new Product("Microphone", 80.00);
        productRepository.save(productToRemove);
        System.out.println("Product to remove: " + productToRemove);

        productRepository.delete(productToRemove);
        System.out.println("Is product removed? " + !productRepository.existsById(productToRemove.getId()));
    }
}

Beyond Basic: Derived Query Methods

While findById() and findAll() are great, Spring Data JPA offers even more! You can define custom derived query methods directly in your repository interface.

Spring automatically generates the query based on the method name.
For example, findByName(String name) will find products by their name.
This simplifies common read operations without writing SQL!

We'll explore more complex custom queries in a future lesson.

Quick Check: CRUD Actions

Which of the following Spring Data JPA repository methods are used for reading existing data?

ตอบคำถามในบทเรียนแบบโต้ตอบ

Recap: Mastering CRUD

Congratulations! You've learned how to perform the essential CRUD operations using Spring Data JPA. These methods are the backbone of almost any data-driven application.

Create/Update: Use repository.save(entity).
Read: Use repository.findById(id) for single items and repository.findAll() for all items.
Delete: Use repository.deleteById(id) or repository.delete(entity).

With these powerful repository methods, you can efficiently manage your application's data!

เริ่มต้นได้ฟรี

เรียนรู้ Java ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 24
บทเรียน: 93

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “การดำเนินการ CRUD” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การดำเนินการ CRUD” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Spring Boot 4 Microservices & REST APIs ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Spring Boot 4 Microservices & REST APIs มีบทเรียนทั้งหมด 6 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การดำเนินการ CRUD”

นำการดำเนินการสร้าง อ่าน อัปเดต และลบไปใช้โดยใช้เมธอดคลังข้อมูลอันทรงพลังของ Spring Data JPA คุณปฏิบัติ Spring Boot 4 Microservices & REST APIs ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Spring Boot 4 Microservices & REST APIs หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Spring Boot 4 Microservices & REST APIs บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 6 จากทั้งหมด 6 บทเรียน

บทเรียน “การดำเนินการ CRUD” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Spring Boot 4 Microservices & REST APIs นี้ได้ไหม

ได้ บทเรียน Spring Boot 4 Microservices & REST APIs ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Spring Boot 4 Microservices & REST APIs