Spring Data JPA Repository非自动装配初始化后无法保存数据至数据库

Hey there! Let's break down why your manual TravelAlertRepository setup can read data but fails to persist updates or create new records, and fix it step by step.

Core Issue: Missing Transaction Context & Proper EntityManager Configuration #

Spring Data JPA's default repository implementations rely on two key pieces for write operations: a transactional context and a correctly configured EntityManager. When you manually implement repositories without using @EnableJpaRepositories, it's easy to overlook these—especially since read operations can work without explicit transactions, but write operations (persist/merge) require them to sync changes to the database.

Step 1: Ensure You're Using a Transactional EntityManager #

Your EntityManager needs to be bound to a transaction to persist changes. Without a transaction, any persist() or merge() calls only modify in-memory state, never flushing to the database. Here's how to handle transactions manually:

import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

// Inject your pre-configured DataSource and PlatformTransactionManager
private final EntityManager em;
private final PlatformTransactionManager transactionManager;

public TravelAlertRepositoryImpl(EntityManager em, PlatformTransactionManager transactionManager) {
    this.em = em;
    this.transactionManager = transactionManager;
}

// Example create operation
public TravelAlert createTravelAlert(TravelAlert alert) {
    TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
    try {
        em.persist(alert); // Adds new entity to the persistence context
        transactionManager.commit(status); // Triggers flush to database
        return alert;
    } catch (Exception e) {
        transactionManager.rollback(status); // Rollback on failure
        throw new RuntimeException("Failed to create travel alert", e);
    }
}

// Example update operation
public TravelAlert updateTravelAlert(TravelAlert alert) {
    TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
    try {
        TravelAlert updatedAlert = em.merge(alert); // Syncs modified entity to persistence context
        transactionManager.commit(status);
        return updatedAlert;
    } catch (Exception e) {
        transactionManager.rollback(status);
        throw new RuntimeException("Failed to update travel alert", e);
    }
}

Step 2: Verify EntityManagerFactory Configuration #

Make sure your EntityManagerFactory is properly set up to scan your entity classes, use your existing DataSource, and has correct JPA properties (like database dialect):

import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;

@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
    LocalContainerEntityManagerFactoryBean emFactory = new LocalContainerEntityManagerFactoryBean();
    emFactory.setDataSource(dataSource);
    emFactory.setPackagesToScan("com.your.package.entity"); // Replace with your entity package
    emFactory.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
    
    // Add JPA properties (adjust based on your database)
    Properties jpaProps = new Properties();
    jpaProps.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
    jpaProps.setProperty("hibernate.hbm2ddl.auto", "update"); // Or validate/create as needed
    emFactory.setJpaProperties(jpaProps);
    
    return emFactory;
}

// Don't forget to define a TransactionManager bean
@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory emFactory) {
    return new JpaTransactionManager(emFactory);
}

Step 3: Use @Transactional (If Allowed) #

Even without @EnableJpaRepositories, you can leverage Spring's @Transactional annotation to automate transaction management—this cleans up your code and avoids manual transaction boilerplate:

import org.springframework.transaction.annotation.Transactional;

@Transactional
public TravelAlert createTravelAlert(TravelAlert alert) {
    em.persist(alert);
    return alert;
}

@Transactional
public TravelAlert updateTravelAlert(TravelAlert alert) {
    return em.merge(alert);
}

Spring will automatically start a transaction before the method runs, commit it on success, and roll back if an exception is thrown.

Step 4: Troubleshooting with Manual Flush (Temporary) #

If you're still having issues, you can manually trigger a flush to force the EntityManager to sync changes to the database before committing the transaction. This is a debugging step only—avoid using it in production unless absolutely necessary:

em.persist(alert);
em.flush(); // Forces immediate sync to database
transactionManager.commit(status);

Key Takeaway #

The root cause of your write operation failures is almost certainly missing transaction boundaries. By wrapping your persist()/merge() calls in a transaction and ensuring your EntityManagerFactory is correctly configured, you'll get your create/update operations working as expected.

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