Spring-data-jpa kullanarak bir varlığı nasıl güncelleyebilirim?

Soru hemen hemen her şeyi söylüyor. JPARepository kullanarak bir varlığı nasıl güncelleyebilirim?

JPARepository'nin sadece bir kaydetme yöntemi vardır, bu gerçekten oluşturup güncellemediğini söylemez. Mesela ben üç alanı vardır veritabanı kullanıcı, basit bir nesne ekleyin: firstname, lastnameve 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;
  }
}

Sonra ben sadece save(), bu noktada aslında veritabanına bir insert olduğunu çağırmak :

 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);

Çok uzak çok iyi. Şimdi bu kullanıcıyı güncellemek istiyorum, diyelim yaşını değiştir. Bu amaçla bir Query, QueryDSL veya NamedQuery kullanabilirsiniz. Ancak, sadece spring-data-jpa ve JPARepository kullanmak istediğimi düşünürsek, bir ekleme yerine güncelleme yapmak istediğimi nasıl anlarım?

Özellikle, spring-data-jpa'ya aynı kullanıcı adı ve adıyla kullanıcıların aslında EQUAL olduğunu ve mevcut varlığın güncellenmesi gerektiğini nasıl söyleyebilirim? Eşit değerlerin geçersiz kılınması bu sorunu çözmedi.

Varlıkların kimliği birincil anahtarları ile tanımlanır. Yana firstnameve lastnamebirincil anahtar parçaları değil, sen tedavi için JPA söyleyemem Useraynı ile s firstnames ve lastnamebunlar farklı varsa eşit olarak s userIds.

Bu nedenle, bir Usertanımlanmış tarafından güncellenmek istiyorsanız firstnameve lastnamebunu Userbir sorgu ile bulmanız ve ardından bulduğunuz nesnenin uygun alanlarını değiştirmeniz gerekir. Bu değişiklikler işlem sonunda veritabanında otomatik olarak temizlenir, böylece bu değişiklikleri açıkça kaydetmek için herhangi bir şey yapmanız gerekmez.

DÜZENLE:

Belki de JPA'nın genel anlambilimi üzerinde durmalıyım. Kalıcılık API'larının tasarımında iki ana yaklaşım vardır:

• ekleme / güncelleme yaklaşımı . Veritabanını değiştirmeniz gerektiğinde, kalıcılık API'lerini açıkça çağırmalısınız: insertbir nesne eklemek veya nesnenin updateyeni durumunu veritabanına kaydetmek için çağrı yaparsınız .

• İş Birimi yaklaşımı . Bu durumda , kalıcılık kitaplığı tarafından yönetilen bir dizi nesneniz vardır . Bu nesnelerde yaptığınız tüm değişiklikler, İş Birimi'nin sonunda (yani, tipik olarak mevcut işlemin sonunda) otomatik olarak veritabanına temizlenir. Veritabanına yeni kayıt eklemeniz gerektiğinde, karşılık gelen nesneyi yönetirsiniz .Yönetilen nesneleri önceden birincil anahtarla bir nesne yaparsanız böylece, onların birincil anahtarlar tanımlanır yönetilen otomatik olarak o kayda yayılacaktır veritabanı aynı id kayıt ve bu nesnenin durumu ile ilişkili olacaktır.

JPA ikinci yaklaşımı izler. save()Baharda Veri JPA tarafından desteklenmektedir merge()bu nedenle sizin varlık yapar, düz JPA yönetilen yukarıda açıklandığı gibi. Bu save(), önceden tanımlanmış kimliği olan bir nesneyi çağırmanın , yeni bir tane eklemek yerine karşılık gelen veritabanı kaydını güncelleyeceği ve neden save()çağrılmadığını açıklayacağı anlamına gelir create().

@Axtavt tarafından cevap odaklanır yana JPAdeğilspring-data-jpa

Bir varlığı sorgulayarak güncellemek için kaydetme verimli değildir, çünkü iki sorgu gerektirir ve sorgu diğer tablolara katılıp tüm koleksiyonları yükleyebileceğinden oldukça pahalı olabilir. fetchType=FetchType.EAGER

Spring-data-jpagüncelleme işlemini destekler.
Yöntemi Depo arabiriminde tanımlamanız ve @Queryve ile açıklama eklemeniz gerekir @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);

@Queryözel sorgu tanımlamak için ve @Modifyingsöylüyorum içindir spring-data-jpabu sorgu bir güncelleme operasyon olduğunu ve onu gerektiriyor executeUpdate()değilexecuteQuery() .

Diğer iade türlerini belirleyebilirsiniz:
int - güncellenmekte olan kayıt sayısı.
boolean- güncellenen bir kayıt varsa true. Aksi takdirde, yanlış.

Not : Bu kodu bir İşlemde çalıştırın .

Save () JPAfunction ile bu işlevi kullanabilirsiniz, ancak parametre olarak gönderilen nesnenin veritabanında varolan bir kimliği içermesi gerekir, aksi takdirde çalışmaz, çünkü kimliği olmayan bir nesneyi gönderdiğimizde save (), doğrudan bir satır ekler ancak mevcut kimliğe sahip bir nesne gönderirsek, veritabanında zaten bulunan sütunları değiştirir.

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);
}

Başkaları tarafından daha önce bahsedildiği gibi, save()kendisi hem oluşturma hem de güncelleme işlemini içerir.

Sadece save()yöntemin arkasında neler olduğu hakkında ek bilgi eklemek istiyorum .

İlk olarak, genişleme / uygulama hiyerarşisini CrudRepository<T,ID>,

Tamam, save()uygulamayı şu adreste kontrol edelim 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);
    }
}

Gördüğünüz gibi, öncelikle kimliğin var olup olmadığını kontrol eder, eğer varlık zaten oradaysa, sadece güncelleme merge(entity)yöntemle gerçekleşir ve aksi takdirde yöntemle yeni bir kayıt eklenir persist(entity).

Spring-data-jpa kullanarak save()@DtechNet ile aynı sorunu yaşıyordum. Yani her save()şey güncelleme yerine yeni bir nesne oluşturuyordu. Bunu çözmek versioniçin varlık ve ilgili tabloya alan eklemek zorunda kaldım .

Sorunu şu şekilde çözdüm:

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

yay verisi save() yöntemi her ikisini de gerçekleştirmenize yardımcı olacaktır: yeni öğe ekleme ve mevcut bir öğeyi güncelleme.

Sadece arayın save()ve hayatın tadını çıkarın :))

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));
}

Spesifik olarak, spring-data-jpa'ya aynı kullanıcı adı ve adına sahip kullanıcıların aslında EQUAL olduğunu ve varlığı güncellemesi gerektiğini nasıl söyleyebilirim. Geçersiz kılma eşit işe yaramadı.

Bu özel amaç için, böyle bir kompozit anahtar sokulabilir:

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`))

haritalama:

@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
}

İşte nasıl kullanılır:

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

    private String description;

    //...
}

JpaRepository şöyle görünecektir:

public interface UserEntityRepository extends JpaRepository<UserEntity, UserKey>

Ardından, aşağıdaki deyimi kullanabilirsiniz : DTO'yu kullanıcı bilgileriyle kabul edin, adı ve adı çıkarın ve UserKey'i oluşturun, sonra bu kompozit anahtarla bir UserEntity oluşturun ve sonra sizin için her şeyi sıralaması gereken Spring Data save () öğesini çağırın.