Hey there! Let's work through your problem step by step—first figuring out why your @Async isn't working, then looking at way better options for bulk data storage that'll save you loads of time.

Why isn't your @Async annotation working? #

You already know two key limitations of @Async, but there are a couple more critical boxes you might have missed:

1. You haven't enabled Spring's async support
   This is the most common mistake! You need to add the @EnableAsync annotation to your Spring Boot main application class or a configuration class. Without it, Spring doesn't even know to look for @Async methods, so it won't create the proxy needed to run them asynchronously.

   Example:

   @SpringBootApplication
   @EnableAsync // Don't forget this line!
   public class YourApplication {
       public static void main(String[] args) {
           SpringApplication.run(YourApplication.class, args);
       }
   }
   

2. How you're calling the async method matters
   Your Controller calls gaugeCategoryService.saveOrUpdate(), and you've added @Async to the Dao layer method. Make sure your Service is using a Spring-injected instance of the Dao (not a newed-up GaugeCategoryDaoImpl—that won't be proxied). Also, if your Service method is annotated with @Transactional, note that each async Dao call will run in its own separate transaction, which might cause data consistency issues down the line.

3. Proxy type limitations
   Spring uses JDK dynamic proxies by default, which only work on interface methods. Since you're implementing GaugeCategoryDao and overriding the method, this should be fine—but if you were using a class without an interface, you'd need to enable CGLIB proxies. That doesn't seem to be your issue here, though.

Better, faster bulk storage options #

Even if you get @Async working, saving individual records one by one (even asynchronously) isn't efficient for bulk data. You'll tie up database connections, and transaction management gets messy. Here are way better approaches:

1. Use Spring Data JPA's built-in bulk save #

If your Dao extends JpaRepository or CrudRepository, you can use the saveAll(Iterable<T>) method—it's designed for bulk operations and will optimize inserts/updates under the hood.

Update your Service layer:

@Service
public class GaugeCategoryService {
    private final GaugeCategoryDao gaugeCategoryDao;

    // Constructor injection (best practice)
    public GaugeCategoryService(GaugeCategoryDao gaugeCategoryDao) {
        this.gaugeCategoryDao = gaugeCategoryDao;
    }

    public void batchSaveOrUpdate(List<GaugeCategory> categories) {
        gaugeCategoryDao.saveAll(categories); // No more loops!
    }
}

Then in your Controller, pass the entire list instead of looping:

// Controller code
List<GaugeCategory> categoryList = ...; // Your bulk data collection
gaugeCategoryService.batchSaveOrUpdate(categoryList);

2. Configure JPA for true bulk operations #

To make sure Hibernate actually runs bulk SQL instead of individual statements, add these settings to your application.properties or application.yml:

# Hibernate bulk operation config
spring.jpa.properties.hibernate.jdbc.batch_size=50
spring.jpa.properties.hibernate.order_inserts=true
spring.jpa.properties.hibernate.order_updates=true
spring.jpa.properties.hibernate.batch_versioned_data=true

• batch_size: Adjust this based on your data volume (50-100 is a good starting point)
• order_inserts/order_updates: Makes Hibernate group similar SQL statements together for bulk execution
• batch_versioned_data: Required if your entity uses a @Version field for optimistic locking

3. Go native with JDBC batch operations #

If you need maximum performance, skip JPA's ORM layer and use Spring's JdbcTemplate for direct bulk SQL operations. This is faster but requires writing your own SQL:

@Repository
public class GaugeCategoryDaoImpl implements GaugeCategoryDao {
    private final JdbcTemplate jdbcTemplate;

    public GaugeCategoryDaoImpl(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public void batchSaveOrUpdate(List<GaugeCategory> categories) {
        // Adjust the SQL to match your table and fields
        String sql = "INSERT INTO gauge_category (name, description, ...) VALUES (?, ?, ...) " +
                     "ON DUPLICATE KEY UPDATE name = VALUES(name), description = VALUES(description), ...";
        
        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                GaugeCategory category = categories.get(i);
                ps.setString(1, category.getName());
                ps.setString(2, category.getDescription());
                // Set other fields here
            }

            @Override
            public int getBatchSize() {
                return categories.size();
            }
        });
    }
}

4. Don't forget transaction management #

Wrap your bulk operations in a transaction to ensure all records are saved/updated successfully, or none are. Add @Transactional to your Service method:

@Service
public class GaugeCategoryService {
    // ...

    @Transactional
    public void batchSaveOrUpdate(List<GaugeCategory> categories) {
        gaugeCategoryDao.saveAll(categories);
    }
}

Wrap-up #

1. First, fix the @Async issue by adding @EnableAsync and making sure you're calling the proxied Dao bean correctly.
2. Ditch the loop and use JPA's saveAll with the right bulk config for clean, efficient bulk operations.
3. For top-tier performance, use JDBC batch operations.
4. Always use transactions to keep your data consistent.

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