Как называется поиск, позволяющий перекидывать данные из приложения в базу данных

Persist: сохранение данных из приложения в базу

Вопрос касается операции сохранения данных из Java приложения в базу данных. Это называется persist или persistance. Есть несколько подходов и терминов:

1. JPA Persist операция

В контексте JPA/Hibernate это называется persist:

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private EntityManager entityManager;
    
    // Через Repository
    public User createUser(User user) {
        return userRepository.save(user); // save = persist
    }
    
    // Через EntityManager (более низкоуровневый)
    public void persistUser(User user) {
        entityManager.persist(user); // явная persist операция
    }
    
    // Merge — для обновления detached объектов
    public User updateUser(User detachedUser) {
        return entityManager.merge(detachedUser);
    }
}

2. Жизненный цикл JPA сущностей

Есть четыре состояния сущности:

┌─────────────────────────────────────┐
│  Managed (Transient) State          │
│  - Объект создан, но не в БД        │
│  - entityManager.persist(object)    │
└─────────────────────────────────────┘
              ↓
┌─────────────────────────────────────┐
│  Persisted State                    │
│  - Объект сохранён в БД            │
│  - Когда commit() вызывается       │
└─────────────────────────────────────┘
              ↓
┌─────────────────────────────────────┐
│  Detached State                     │
│  - Session закрыта, но объект есть │
│  - entityManager.merge()            │
└─────────────────────────────────────┘

3. Spring Data JPA save() метод

Это главный способ в современных приложениях:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // JpaRepository имеет save() из CrudRepository
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public User createUser(CreateUserRequest request) {
        User user = new User();
        user.setEmail(request.getEmail());
        user.setName(request.getName());
        
        // save() = persist для новых объектов, merge для существующих
        return userRepository.save(user);
    }
    
    // Batch save — несколько объектов
    @Transactional
    public List<User> createUsers(List<CreateUserRequest> requests) {
        List<User> users = requests.stream()
            .map(r -> new User(r.getEmail(), r.getName()))
            .collect(Collectors.toList());
        
        return userRepository.saveAll(users);
    }
}

4. Explicit persist vs auto persist

Explicit persist:

@Service
public class ExplicitPersistService {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void saveUser(User user) {
        entityManager.persist(user); // явно указываем persist
    }
}

Auto persist (через CascadeType):

@Entity
public class Order {
    @OneToMany(cascade = CascadeType.PERSIST) // автоматически persist-ятся items
    private List<OrderItem> items;
}

@Service
public class AutoPersistService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public Order createOrder(Order order) {
        // При save(order) автоматически persist-ятся все items благодаря cascade
        return orderRepository.save(order);
    }
}

5. Batch Insert для оптимизации

Для больших объёмов данных:

@Service
public class BatchInsertService {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void insertLargeAmount(List<User> users) {
        int batchSize = 100;
        
        for (int i = 0; i < users.size(); i++) {
            entityManager.persist(users.get(i));
            
            // flush и clear каждые batchSize записей
            if ((i + 1) % batchSize == 0) {
                entityManager.flush();
                entityManager.clear(); // очищаем кэш
            }
        }
        
        entityManager.flush(); // final flush
    }
}

6. Flush и Commit

Важно понимать разницу:

@Service
public class FlushCommitService {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void demonstrateFlushCommit() {
        User user = new User("john@example.com");
        
        entityManager.persist(user); // добавляем в контекст
        // В БД ещё нет!
        
        entityManager.flush(); // отправляем в БД, но транзакция открыта
        // Теперь в БД, но можем откатить если ошибка
        
        // При выходе из метода @Transactional автоматически commit-ится
        // Если выброшено исключение — rollback
    }
}

7. Разные способы сохранения

1. Repository.save() — самый простой

User user = new User("email@example.com");
UserRepository.save(user);

2. EntityManager.persist() — более контролируемый

User user = new User("email@example.com");
entityManager.persist(user);
entityManager.flush();

3. Прямой SQL через JdbcTemplate — когда нужна скорость

@Service
public class BulkInsertService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public void insertBulk(List<User> users) {
        String sql = "INSERT INTO users (email, name) VALUES (?, ?)";
        
        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                ps.setString(1, users.get(i).getEmail());
                ps.setString(2, users.get(i).getName());
            }
            
            @Override
            public int getBatchSize() {
                return users.size();
            }
        });
    }
}

Мой рекомендуемый подход

1. Для обычных операций: использй Repository.save()
2. Для batch операций: используй JdbcTemplate.batchUpdate()
3. Для контроля lifecycle: используй EntityManager.persist()
4. Всегда обёртывай в @Transactional: автоматический commit/rollback

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional // критично для persist
    public User createUser(CreateUserRequest request) {
        User user = User.builder()
            .email(request.getEmail())
            .name(request.getName())
            .build();
        
        return userRepository.save(user);
    }
}

Термин persist в контексте Java/JPA означает сохранение объекта из памяти приложения в постоянное хранилище (базу данных).