Spring Data JPA在Java 8功能图中节省方法的有效性

Question

When using Spring Data together with Java 8 we have two options to save the collection:

1. We can use classic List<S> save(Iterable<S> entities) method that takes the whole list.
   Example:

    someOtherRepository.save( someRepository.findAll() .stream() .map(something -> { //some operations return someOtherThing; }) .collect(Collectors.toList()) ); 

2. We can use S save(S entity) method that takes single entity and use it in a stream in a map .
   Example:

    someRepository.findAll() .stream() .map(something -> { //some operations return someOtherThing; }) .map(someOtherRepository::save) .collect(Collectors.toList()); 

The question is:
Is there a difference in execution time between those two approaches? If yes which is more effective (faster).

Answer 1

It depends on many things and therefore is hard to predict. But I would expect it not to make much of a difference.

You seem to be talking Spring Data JPA here since the question is tagged with hibernate . Assuming your transaction spans all the calls to save , saving really just adds the entity to the EntityManager without actually accessing the database. And when finally a flush happens (typically at the end of the transaction), all entities will get persisted to the database in one go by Hibernate.

Therefore performance differences come from the different code paths in your code and in Spring Data. Those differences should be neglectable from anything coming from actually persisting entities.

If we are talking about huge numbers of entities the performance characteristics of the EntityManager itself might become relevant.

If every call to save creates its own transaction single calls will most likely be much slower.

So in the end, it boils down to:

Why don't you just try it with your data? And let us know the results?

Answer 2

save(Iterable<S> entities) relies on iterating and invoking save(S entity) :

@Transactional
public <S extends T> List<S> save(Iterable<S> entities) {

    List<S> result = new ArrayList<S>();

    if (entities == null) {
        return result;
    }

    for (S entity : entities) {
        result.add(save(entity));
    }

    return result;
}

So the two should give the same result in terms of performance.

To do batch insert, you have to specify it in your hibernate configuration ( hibernate.jdbc.batch_size ) and handle yourself the flush.

Answer 3

In case of the list with more than one element, the first approach will be much faster (if the list is has just one element, it should be the same)

Just briefly describing the reason why. During batch insert you will not have the overhead of multiple connection established with single insert multiple time.