如何将同一表单数据同步存储到JPA的两个数据库表中？

Hey there! Let's tackle this JPA problem you're facing—saving the same form input to two different tables (Table1.things and Table2.things_1) in your test database. I've got a couple of solid approaches that should work seamlessly with your Angular 5 backend setup:

Approach 1: Manual Handling in Service Layer (Most Straightforward) #

This is the easiest to implement and maintain, since you have full control over the data flow. You'll receive the form data in a DTO (Data Transfer Object) from your Angular frontend, then map that value to both entities before saving them.

Step 1: Create a DTO for Form Input #

public class ThingsFormDTO {
    private String thingsValue;
    // Add other form fields here, plus getters and setters
}

Step 2: Implement the Service Logic #

Use your JPA repositories to save both entities within a single transaction to ensure data consistency:

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ThingsService {
    private final Table1Repository table1Repo;
    private final Table2Repository table2Repo;

    // Constructor injection (preferred over @Autowired)
    public ThingsService(Table1Repository table1Repo, Table2Repository table2Repo) {
        this.table1Repo = table1Repo;
        this.table2Repo = table2Repo;
    }

    @Transactional // Ensures both saves succeed or fail together
    public void saveFormData(ThingsFormDTO formDTO) {
        // Create and save Table1 entity
        Table1 table1 = new Table1();
        table1.setThings(formDTO.getThingsValue());
        // Set other Table1 fields as needed
        table1Repo.save(table1);

        // Create and save Table2 entity
        Table2 table2 = new Table2();
        table2.setThings_1(formDTO.getThingsValue());
        // Set other Table2 fields as needed
        table2Repo.save(table2);
    }
}

Approach 2: JPA Entity Lifecycle Callbacks #

If you want to tie the save of Table2 directly to the save of Table1, you can use JPA's lifecycle annotations like @PrePersist or @PostPersist. Just make sure to handle transactions properly.

Example with @PrePersist #

import javax.persistence.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Entity
@Table(name = "Table1")
public class Table1 {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String things;

    // Use @Transient so JPA doesn't map this as a database column
    @Transient
    @Autowired
    private Table2Repository table2Repo;

    @PrePersist
    private void saveTable2OnPersist() {
        Table2 table2 = new Table2();
        table2.setThings_1(this.things);
        // Set other Table2 fields
        table2Repo.save(table2);
    }

    // Getters and setters
}

Note: Make sure your entity is managed by Spring (e.g., use @Component or ensure it's scanned) so the repository gets autowired correctly. Also, wrap the save operation in a @Transactional method to avoid transaction issues.

Approach 3: Database Trigger (Database-Level Solution) #

If you prefer not to modify your JPA code, you can create a database trigger that automatically inserts a row into Table2 whenever a new row is added to Table1. Here's an example for MySQL:

DELIMITER //
CREATE TRIGGER after_table1_insert
AFTER INSERT ON Table1
FOR EACH ROW
BEGIN
    INSERT INTO Table2 (things_1) VALUES (NEW.things);
    -- Add other columns you need to populate here
END //
DELIMITER ;

This approach is great if the sync logic is purely database-centric, but keep in mind it's tied to your specific database system (adjust syntax for PostgreSQL, SQL Server, etc.).

Key Notes to Remember #

• Transaction Management: Always use @Transactional (if using Spring) or JPA transactions to ensure both operations succeed or fail together—this prevents partial data saves.
• Updates: If you need to handle updates (not just inserts), extend the logic to cover @PreUpdate (for Approach 2) or create an AFTER UPDATE trigger (for Approach 3).
• DTO Best Practices: Using a DTO to receive frontend data keeps your entities clean and avoids exposing internal database structure to the client.

内容的提问来源于stack exchange，提问作者mdguit