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

การสร้างเอนทิตีและคลังข้อมูล

กำหนดเอนทิตี JPA เพื่อแทนแบบจำลองข้อมูล และใช้คลังข้อมูล Spring Data สำหรับเข้าถึงข้อมูล

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

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

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

What are JPA Entities?

Welcome to creating your data model! In Spring Boot with JPA, an Entity is a plain Java object that represents a table in your database.

Think of it as a blueprint for the rows in your table. Each instance of an entity class corresponds to a single row in the database table.

Marking a Class as an Entity

To tell Spring Boot that a Java class is an entity, we use the @Entity annotation. This annotation comes from the Java Persistence API (JPA).

When Spring sees @Entity, it knows to map this class to a database table. By default, the table name will be the same as the class name (e.g., a Product class maps to a Product table).

Defining Primary Keys with @Id

Every database table needs a primary key to uniquely identify each record. In JPA, we mark a field as the primary key using the @Id annotation.

Often, we want the database to automatically generate this ID for us. For this, we use the @GeneratedValue annotation, typically with a strategy like IDENTITY for auto-incrementing numbers.

Our First Product Entity

Let's create a simple Product entity. It will have an ID, a name, and a price. Notice the annotations @Entity, @Id, and @GeneratedValue.

Remember to include a default constructor and getters/setters for JPA to work correctly.

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

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

Introducing Spring Data Repositories

Now that we have an entity, how do we interact with the database to save, retrieve, update, or delete products? This is where Repositories come in!

Spring Data JPA provides a powerful abstraction that simplifies data access. Instead of writing complex SQL queries, you define simple interfaces.

The JpaRepository Interface

The core of Spring Data JPA is the JpaRepository interface. When your repository interface extends JpaRepository, Spring automatically provides standard CRUD (Create, Read, Update, Delete) methods for your entity.

You just need to specify the entity type and the type of its primary key, like this: JpaRepository<YourEntity, ID_Type>.

Defining Our Product Repository

Let's create a repository for our Product entity. It's just an interface that extends JpaRepository, telling Spring to generate the necessary code for us.

We specify Product as the entity type and Long as the primary key type.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    // Spring Data JPA automatically provides methods like:
    // save(), findById(), findAll(), deleteById(), etc.
}

Using Repositories in Spring

In a Spring Boot application, you would typically inject your repository into a service or controller using @Autowired. Then, you can call the built-in methods.

  • repository.save(product): Saves a new product or updates an existing one.
  • repository.findById(id): Finds a product by its ID.
  • repository.findAll(): Retrieves all products.

Entity & Repository in Action

Here's a conceptual example showing how an entity is created and how a repository would save it. We're simulating the repository behavior to make it runnable without a full Spring Boot setup.

This demonstrates creating a Product object and using a 'save' method.

// --- Simulated Product Entity --- //
class Product {
    private Long id;
    private String name;
    private double price;

    public Product(Long id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
    // Getters and Setters (simplified 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 + "}";
    }
}

// --- Simulated Product Repository Interface --- //
interface ProductRepository {
    Product save(Product product);
}

// --- Simulated Product Repository Implementation --- //
class SimpleProductRepository implements ProductRepository {
    private static Long nextId = 1L;
    @Override
    public Product save(Product product) {
        if (product.getId() == null) {
            product.setId(nextId++); // Assign a new ID
        }
        System.out.println("Simulating save: " + product);
        return product;
    }
}

public class Main {
    public static void main(String[] args) {
        // 1. Create a Product entity instance
        Product newProduct = new Product(null, "Wireless Earbuds", 99.99);
        System.out.println("Created product: " + newProduct);

        // 2. Simulate saving it using our repository
        ProductRepository repository = new SimpleProductRepository();
        Product savedProduct = repository.save(newProduct);

        System.out.println("Product after simulated save: " + savedProduct);
    }
}

Quick Check: Core Concepts

Which of the following annotations is used to mark a class as a JPA entity that maps to a database table?

Recap: Entities & Repositories

You've learned the fundamentals of defining your data model with Spring Data JPA!

  • Entities are Java objects representing database tables, marked with @Entity.
  • Primary keys are defined with @Id and often auto-generated using @GeneratedValue.
  • Repositories are interfaces that extend JpaRepository, providing powerful, ready-to-use methods for interacting with your database.

These two concepts are the cornerstone of data persistence in Spring Boot.

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

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

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

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

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

บทเรียน “การสร้างเอนทิตีและคลังข้อมูล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การสร้างเอนทิตีและคลังข้อมูล”

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

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

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

บทเรียน “การสร้างเอนทิตีและคลังข้อมูล” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การผสานฐานข้อมูล H2 และ JPA
  2. บทนำสู่ Spring Data JPA
  3. การสร้างเอนทิตีและคลังข้อมูล
  4. การกำหนดเอนทิตีและคลังข้อมูล
  5. การดำเนินการ CRUD ด้วย REST
  6. การดำเนินการ CRUD
← กลับไปที่ Spring Boot 4 Microservices & REST APIs