Как добавить запись в БД в JPA

Как добавить запись в БД в JPA?

Добавление записи (persist) в базу данных через JPA выполняется несколькими способами. Основной подход — использование EntityManager или Spring Data Repository с методом save().

1. Базовый способ через Spring Data Repository

// 1. Создаём JPA Entity
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String email;
    
    @Column
    private String name;
    
    // Getters, Setters
}

// 2. Создаём Repository
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // JpaRepository автоматически реализует CRUD методы
    // включая save()
}

// 3. Используем в сервисе
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(String email, String name) {
        User user = new User();
        user.setEmail(email);
        user.setName(name);
        
        // Сохраняем в БД
        User savedUser = userRepository.save(user);
        return savedUser; // Содержит сгенерированный ID
    }
}

// 4. Используем в контроллере
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody CreateUserRequest request) {
        User user = userService.createUser(request.getEmail(), request.getName());
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

2. Разница между методами сохранения

save() — Обновляет или вставляет (Upsert)

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    // Сценарий 1: Вставка новой записи
    public void insertNewUser() {
        User user = new User();
        user.setEmail("john@example.com");
        user.setName("John");
        // user.id = null (не установлен)
        
        User saved = userRepository.save(user);
        // ↓ SQL: INSERT INTO users (email, name) VALUES ('john@example.com', 'John')
        // ↓ Возвращает User с установленным ID
        System.out.println(saved.getId()); // Например: 5
    }
    
    // Сценарий 2: Обновление существующей записи
    public void updateExistingUser(Long id) {
        User user = userRepository.findById(id).orElseThrow();
        user.setName("Jane"); // Изменяем
        
        User saved = userRepository.save(user);
        // ↓ SQL: UPDATE users SET name = 'Jane' WHERE id = 5
    }
}

saveAll() — Сохранение нескольких записей

@Service
public class BulkUserService {
    @Autowired
    private UserRepository userRepository;
    
    public void insertMultipleUsers() {
        List<User> users = new ArrayList<>();
        
        for (int i = 0; i < 1000; i++) {
            User user = new User();
            user.setEmail("user" + i + "@example.com");
            user.setName("User " + i);
            users.add(user);
        }
        
        // Сохраняем все одновременно
        List<User> saved = userRepository.saveAll(users);
        // ↓ SQL: INSERT INTO users (email, name) VALUES (...), (...), ...
        // ↓ Оптимизировано для bulk операций
        
        System.out.println("Inserted " + saved.size() + " users");
    }
}

3. Использование EntityManager напрямую

@Service
public class UserService {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional // ВАЖНО: нужна транзакция
    public void createUserWithEntityManager() {
        User user = new User();
        user.setEmail("jane@example.com");
        user.setName("Jane");
        
        // persist() — добавляет объект в persistence context
        entityManager.persist(user);
        // ↓ На этом этапе SQL еще не выполнен!
        // ↓ Объект добавлен в "managed state"
        
        System.out.println(user.getId()); // null на этом этапе
        
        // После выхода из @Transactional метода:
        // entityManager.flush() вызывается автоматически
        // ↓ SQL: INSERT INTO users (email, name) VALUES ('jane@example.com', 'Jane')
        // ↓ ID генерируется БД
    }
}

4. Жизненный цикл объекта в JPA

Объект Java → JPA Persistence Context → База Данных

    new User()  
        ↓
    TRANSIENT (неуправляемый)
        ↓
    entityManager.persist()
        ↓
    MANAGED (управляемый)
        ↓
    @Transactional завершена
        ↓
    DETACHED (отделённый)
        ↓
    @Transactional снова
        ↓
    MERGED (переприсоединён)
        ↓
    MANAGED

@Service
public class UserLifecycleService {
    @Autowired
    private EntityManager entityManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public void demonstrateLifecycle() {
        // 1. TRANSIENT (новый объект, не управляется JPA)
        User user = new User();
        user.setEmail("test@example.com");
        user.setName("Test");
        // entityManager не знает об этом объекте
        
        // 2. MANAGED (JPA управляет объектом)
        entityManager.persist(user);
        // Теперь JPA отслеживает изменения этого объекта
        
        // 3. Изменения автоматически синхронизируются с БД
        user.setName("Updated Test");
        // SQL UPDATE будет выполнен при flush()
        
        // 4. DETACHED (после выхода из @Transactional)
        // @Transactional завершилась, session закрыта
    }
    
    // После выхода из @Transactional метода
    public void updateDetachedUser(User detachedUser) {
        // detachedUser больше не управляется JPA
        
        // Чтобы снова управлять:
        User managedUser = userRepository.save(detachedUser);
        // или
        // User merged = entityManager.merge(detachedUser);
    }
}

5. Полный пример: создание пользователя с валидацией

// Entity
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true, length = 100)
    @NotNull(message = "Email cannot be null")
    @Email(message = "Email should be valid")
    private String email;
    
    @Column(nullable = false, length = 100)
    @NotBlank(message = "Name cannot be blank")
    private String name;
    
    @Column
    private String phone;
    
    @CreationTimestamp
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    @Column
    private LocalDateTime updatedAt;
    
    // Getters, Setters
}

// Repository
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
    List<User> findByNameContainingIgnoreCase(String name);
}

// DTO для API
public class CreateUserRequest {
    @NotNull
    @Email
    private String email;
    
    @NotBlank
    private String name;
    
    private String phone;
    
    // Getters, Setters
}

// Service
@Service
@Transactional
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(CreateUserRequest request) {
        // Проверяем, не существует ли уже такой email
        if (userRepository.findByEmail(request.getEmail()) != null) {
            throw new UserAlreadyExistsException("User with email " + request.getEmail() + " already exists");
        }
        
        // Создаём новый объект User
        User user = new User();
        user.setEmail(request.getEmail());
        user.setName(request.getName());
        user.setPhone(request.getPhone());
        
        // Сохраняем в БД
        User savedUser = userRepository.save(user);
        
        // Теперь у savedUser есть ID, createdAt и updatedAt автоматически установлены
        return savedUser;
    }
    
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

// Controller
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    
    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody CreateUserRequest request) {
        User user = userService.createUser(request);
        
        return ResponseEntity
            .status(HttpStatus.CREATED)
            .header("Location", "/api/users/" + user.getId())
            .body(user);
    }
    
    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        List<User> users = userService.getAllUsers();
        return ResponseEntity.ok(users);
    }
}

6. Добавление записей с связями

// Entity с One-to-Many связью
@Entity
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String title;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false)
    private User author;
    
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();
}

@Entity
public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column
    private String text;
    
    @ManyToOne
    @JoinColumn(name = "post_id")
    private Post post;
}

// Service
@Service
@Transactional
public class PostService {
    @Autowired
    private PostRepository postRepository;
    
    @Autowired
    private UserRepository userRepository;
    
    public Post createPostWithComments(String title, Long userId, List<String> commentTexts) {
        // 1. Получаем существующего пользователя
        User author = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("User not found"));
        
        // 2. Создаём Post
        Post post = new Post();
        post.setTitle(title);
        post.setAuthor(author);
        
        // 3. Добавляем комментарии
        for (String text : commentTexts) {
            Comment comment = new Comment();
            comment.setText(text);
            comment.setPost(post);
            post.getComments().add(comment);
        }
        
        // 4. Сохраняем всё
        Post savedPost = postRepository.save(post);
        // ↓ SQL: INSERT INTO posts (title, user_id) VALUES ('...', 1)
        // ↓ INSERT INTO comments (text, post_id) VALUES ('...', generated_post_id) × 3
        // ↓ cascade = CascadeType.ALL автоматически сохранит комментарии
        
        return savedPost;
    }
}

7. Транзакции и @Transactional

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    // БЕЗ @Transactional
    public void createUserWithoutTransaction() {
        User user = new User();
        user.setEmail("test@example.com");
        
        // ❌ Проблема: нет активной транзакции
        // LazyInitializationException может быть выброшена
        userRepository.save(user);
    }
    
    // С @Transactional
    @Transactional
    public void createUserWithTransaction() {
        User user = new User();
        user.setEmail("test@example.com");
        
        // ✓ Открывается транзакция
        User saved = userRepository.save(user);
        // ✓ Изменения автоматически синхронизируются
        // ✓ Транзакция коммитится при выходе
    }
    
    // С явным откатом при ошибке
    @Transactional(rollbackFor = Exception.class)
    public void createMultipleUsers(List<String> emails) throws Exception {
        for (String email : emails) {
            User user = new User();
            user.setEmail(email);
            userRepository.save(user);
            
            if (email.contains("invalid")) {
                throw new InvalidEmailException("Invalid email: " + email);
                // ↓ Все сохранения откатываются!
            }
        }
    }
}

8. Batch insert для оптимизации

@Service
public class BulkImportService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public void importLargeNumberOfUsers(List<CreateUserRequest> requests) {
        int batchSize = 100;
        
        for (int i = 0; i < requests.size(); i++) {
            User user = new User();
            user.setEmail(requests.get(i).getEmail());
            user.setName(requests.get(i).getName());
            
            userRepository.save(user);
            
            // Каждые 100 записей делаем flush
            if ((i + 1) % batchSize == 0) {
                entityManager.flush();
                entityManager.clear(); // Очищаем persistence context
            }
        }
    }
}

Итоговое резюме

Основные способы добавить запись в БД через JPA:

1. userRepository.save(user) — базовый способ, рекомендуется использовать
2. userRepository.saveAll(users) — для bulk операций
3. entityManager.persist(user) — низкоуровневый подход
4. @Transactional — обязателен для синхронизации с БД
5. Cascade — для автоматического сохранения связанных объектов

Ключевые моменты:

• Объект должен иметь @Entity аннотацию
• Repository должен расширять JpaRepository
• Метод должен быть в @Transactional контексте
• save() возвращает сохранённый объект с установленным ID
• Изменения управляемых объектов автоматически сохраняются