Bagaimana cara memperbarui entitas menggunakan spring-data-jpa?

Yah pertanyaannya cukup banyak mengatakan segalanya. Menggunakan JPARepository, bagaimana cara saya memperbarui suatu entitas?

JPARepository hanya memiliki metode penyimpanan , yang tidak memberi tahu saya apakah itu benar-benar membuat atau memperbarui. Sebagai contoh, saya memasukkan Obyek sederhana untuk Pengguna database, yang memiliki tiga bidang: firstname, lastnamedan age:

 @Entity
 public class User {

  private String firstname;
  private String lastname;
  //Setters and getters for age omitted, but they are the same as with firstname and lastname.
  private int age;

  @Column
  public String getFirstname() {
    return firstname;
  }
  public void setFirstname(String firstname) {
    this.firstname = firstname;
  }

  @Column
  public String getLastname() {
    return lastname;
  }
  public void setLastname(String lastname) {
    this.lastname = lastname;
  }

  private long userId;

  @Id
  @GeneratedValue(strategy=GenerationType.AUTO)
  public long getUserId(){
    return this.userId;
  }

  public void setUserId(long userId){
    this.userId = userId;
  }
}

Maka saya cukup menelepon save(), yang pada saat ini sebenarnya adalah memasukkan ke dalam basis data:

 User user1 = new User();
 user1.setFirstname("john"); user1.setLastname("dew");
 user1.setAge(16);

 userService.saveUser(user1);// This call is actually using the JPARepository: userRepository.save(user);

Sejauh ini baik. Sekarang saya ingin memperbarui pengguna ini, katakan ubah usianya. Untuk tujuan ini saya bisa menggunakan Query, baik QueryDSL atau NamedQuery, apa pun. Tetapi, mengingat saya hanya ingin menggunakan pegas-data-jpa dan JPARepository, bagaimana saya mengatakannya bahwa alih-alih memasukkan saya ingin melakukan pembaruan?

Secara khusus, bagaimana cara memberi tahu pegas-data-jpa bahwa pengguna dengan nama pengguna dan nama depan yang sama sebenarnya EQUAL dan bahwa entitas yang ada seharusnya diperbarui? Override sama dengan tidak menyelesaikan masalah ini.

Identitas entitas didefinisikan oleh kunci utama mereka. Karena firstnamedan lastnamebukan bagian dari kunci utama, Anda tidak dapat memberi tahu JPA untuk memperlakukan Users dengan firstnames dan lastnames yang sama jika mereka memiliki userIds yang berbeda .

Jadi, jika Anda ingin memperbarui yang Userdiidentifikasi oleh firstnamedan lastname, Anda perlu menemukannya Userdengan kueri, lalu ubah bidang yang sesuai dari objek yang Anda temukan. Perubahan-perubahan ini akan dihapus ke database secara otomatis pada akhir transaksi, sehingga Anda tidak perlu melakukan apa pun untuk menyimpan perubahan ini secara eksplisit.

EDIT:

Mungkin saya harus menguraikan semantik keseluruhan JPA. Ada dua pendekatan utama untuk merancang API persistensi:

• masukkan / perbarui pendekatan . Ketika Anda perlu memodifikasi database Anda harus memanggil metode API kegigihan secara eksplisit: Anda menelepon insertuntuk menyisipkan objek, atau updateuntuk menyimpan keadaan objek yang baru ke database.

• Pendekatan Unit Kerja . Dalam hal ini Anda memiliki satu set objek yang dikelola oleh perpustakaan kegigihan. Semua perubahan yang Anda lakukan pada objek-objek ini akan disiram ke database secara otomatis di akhir Unit Kerja (yaitu pada akhir transaksi saat ini dalam kasus khusus). Saat Anda perlu menyisipkan catatan baru ke database, Anda membuat objek terkait dikelola . Objek yang dikelola diidentifikasi oleh kunci utama mereka, sehingga jika Anda membuat objek dengan kunci utama yang telah ditentukan sebelumnya dikelola , itu akan dikaitkan dengan catatan basis data dari id yang sama, dan keadaan objek ini akan disebarkan ke catatan itu secara otomatis.

JPA mengikuti pendekatan yang terakhir. save()di Spring Data JPA didukung oleh merge()dalam JPA biasa, karena itu membuat entitas Anda dikelola seperti dijelaskan di atas. Ini berarti bahwa memanggil save()objek dengan id yang telah ditentukan akan memperbarui catatan database yang sesuai daripada memasukkan yang baru, dan juga menjelaskan mengapa save()tidak dipanggil create().

Karena jawaban oleh @axtavt berfokus pada JPAtidakspring-data-jpa

Untuk memperbarui entitas dengan kueri, maka menyimpan tidak efisien karena memerlukan dua kueri dan mungkin kueri bisa sangat mahal karena dapat bergabung dengan tabel lain dan memuat koleksi apa pun yang memiliki fetchType=FetchType.EAGER

Spring-data-jpamendukung operasi pembaruan.
Anda harus mendefinisikan metode dalam antarmuka Repositori. Dan menjelaskannya dengan @Querydan @Modifying.

@Modifying
@Query("update User u set u.firstname = ?1, u.lastname = ?2 where u.id = ?3")
void setUserInfoById(String firstname, String lastname, Integer userId);

@Queryadalah untuk mendefinisikan permintaan kustom dan @Modifyingbagi mengatakan spring-data-jpabahwa query ini adalah operasi update dan membutuhkan executeUpdate()tidak executeQuery().

Anda dapat menentukan jenis pengembalian lainnya:
int- jumlah catatan yang diperbarui.
boolean- true jika ada catatan yang diperbarui. Kalau tidak, salah.

Catatan : Jalankan kode ini dalam Transaksi .

Anda cukup menggunakan fungsi ini dengan fungsi save () JPA, tetapi objek yang dikirim sebagai parameter harus berisi id yang ada dalam database jika tidak maka tidak akan berfungsi, karena save () ketika kami mengirim objek tanpa id, ia menambahkan langsung satu baris dalam database, tetapi jika kami mengirim objek dengan id yang ada, itu mengubah kolom yang sudah ditemukan dalam database.

public void updateUser(Userinfos u) {
    User userFromDb = userRepository.findById(u.getid());
    // crush the variables of the object found
    userFromDb.setFirstname("john"); 
    userFromDb.setLastname("dew");
    userFromDb.setAge(16);
    userRepository.save(userFromDb);
}

Seperti apa yang telah disebutkan oleh orang lain, save()itu sendiri berisi operasi buat dan perbarui.

Saya hanya ingin menambahkan suplemen tentang apa di balik save()metode ini.

Pertama, mari kita lihat hierarki extended / implement dari CrudRepository<T,ID>,

Ok, mari kita periksa save()implementasinya di SimpleJpaRepository<T, ID>,

@Transactional
public <S extends T> S save(S entity) {

    if (entityInformation.isNew(entity)) {
        em.persist(entity);
        return entity;
    } else {
        return em.merge(entity);
    }
}

Seperti yang Anda lihat, itu akan memeriksa apakah ID ada atau tidak pertama, jika entitas sudah ada, hanya pembaruan yang akan terjadi dengan merge(entity)metode dan jika lain, catatan baru dimasukkan dengan persist(entity)metode.

Menggunakan spring-data-jpa save(), saya mengalami masalah yang sama dengan @DtechNet. Maksud saya setiap save()membuat objek baru alih-alih pembaruan. Untuk mengatasi ini saya harus menambahkan versionbidang ke entitas dan tabel terkait.

Inilah cara saya memecahkan masalah:

User inbound = ...
User existing = userRepository.findByFirstname(inbound.getFirstname());
if(existing != null) inbound.setId(existing.getId());
userRepository.save(inbound);

save()metode data pegas akan membantu Anda melakukan keduanya: menambahkan item baru dan memperbarui item yang ada.

Panggil saja save()dan nikmati hidup :))

public void updateLaserDataByHumanId(String replacement, String humanId) {
    List<LaserData> laserDataByHumanId = laserDataRepository.findByHumanId(humanId);
    laserDataByHumanId.stream()
            .map(en -> en.setHumanId(replacement))
            .collect(Collectors.toList())
            .forEach(en -> laserDataRepository.save(en));
}

Khususnya bagaimana saya memberi tahu spring-data-jpa bahwa pengguna yang memiliki nama pengguna dan nama depan yang sama sebenarnya EQUAL dan bahwa itu seharusnya memperbarui entitas. Override sama dengan tidak bekerja.

Untuk tujuan khusus ini orang dapat memperkenalkan kunci komposit seperti ini:

CREATE TABLE IF NOT EXISTS `test`.`user` (
  `username` VARCHAR(45) NOT NULL,
  `firstname` VARCHAR(45) NOT NULL,
  `description` VARCHAR(45) NOT NULL,
  PRIMARY KEY (`username`, `firstname`))

Pemetaan:

@Embeddable
public class UserKey implements Serializable {
    protected String username;
    protected String firstname;

    public UserKey() {}

    public UserKey(String username, String firstname) {
        this.username = username;
        this.firstname = firstname;
    }
    // equals, hashCode
}

Berikut cara menggunakannya:

@Entity
public class UserEntity implements Serializable {
    @EmbeddedId
    private UserKey primaryKey;

    private String description;

    //...
}

JpaRepository akan terlihat seperti ini:

public interface UserEntityRepository extends JpaRepository<UserEntity, UserKey>

Kemudian, Anda dapat menggunakan idiom berikut : terima DTO dengan info pengguna, ekstrak nama dan nama depan dan buat UserKey, lalu buat UserEntity dengan kunci komposit ini dan aktifkan Spring Data save () yang seharusnya memilah semuanya untuk Anda.