Jak zaktualizować encję za pomocą Spring-Data-JPA?

Cóż, pytanie w zasadzie mówi wszystko. Korzystanie z JPARepository jak zaktualizować encję?

JPARepository ma tylko metodę zapisywania , która nie mówi mi, czy faktycznie jest tworzona czy aktualizowana. Na przykład wstawić prosty obiekt do użytkownika bazy danych, który ma trzy pola: firstname, lastnamei 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;
  }
}

Następnie po prostu wywołuję save(), która w tym momencie jest właściwie wstawką do bazy danych:

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

Na razie w porządku. Teraz chcę zaktualizować tego użytkownika, powiedzmy zmień jego wiek. W tym celu mógłbym użyć Query, QueryDSL lub NamedQuery, cokolwiek. Ale biorąc pod uwagę, że chcę po prostu użyć spring-data-jpa i JPARepository, jak mam to powiedzieć, że zamiast wstawki chcę wykonać aktualizację?

W szczególności, jak mam powiedzieć spring-data-jpa, że ​​użytkownicy z tą samą nazwą użytkownika i imieniem są w rzeczywistości RÓWNI i że istniejący byt powinien zostać zaktualizowany? Zastąpienie równości nie rozwiązało tego problemu.

Tożsamość jednostek jest definiowana przez ich klucze podstawowe. Ponieważ firstnamei lastnamenie są częściami klucza podstawowego, nie można nakazać JPA, aby traktowały Userte same firstnamesi lastnamesi równe, jeśli mają różne userIds.

Tak więc, jeśli chcesz zaktualizować Userzidentyfikowany przez niego firstnamei lastname, musisz znaleźć to Userprzez zapytanie, a następnie zmienić odpowiednie pola znalezionego obiektu. Zmiany te zostaną automatycznie wprowadzone do bazy danych pod koniec transakcji, dzięki czemu nie trzeba nic robić, aby jawnie zapisać te zmiany.

EDYTOWAĆ:

Być może powinienem rozwinąć ogólną semantykę WZP. Istnieją dwa główne podejścia do projektowania interfejsów API trwałości:

• podejście do wstawiania / aktualizacji . Gdy musisz zmodyfikować bazę danych, powinieneś jawnie wywołać metody API trwałości: wywołujesz, insertaby wstawić obiekt lub updatezapisać nowy stan obiektu w bazie danych.

• Podejście jednostki pracy . W tym przypadku masz zestaw obiektów zarządzanych przez bibliotekę trwałości. Wszystkie zmiany, które wprowadzisz w tych obiektach, zostaną automatycznie usunięte do bazy danych na końcu Jednostki Pracy (tj. Na koniec bieżącej transakcji w typowym przypadku). Kiedy trzeba wstawić nowy rekord do bazy danych, zarządza się odpowiednim obiektem . Zarządzane obiekty są identyfikowane przez ich klucze podstawowe, więc jeśli utworzysz obiekt z zarządzanym predefiniowanym kluczem podstawowym , zostanie on powiązany z rekordem bazy danych o tym samym identyfikatorze, a stan tego obiektu zostanie automatycznie propagowany do tego rekordu.

WZP stosuje to drugie podejście. save()w Spring Data JPA jest zabezpieczony merge()zwykłym JPA, dlatego zarządza twoją jednostką w sposób opisany powyżej. Oznacza to, że wywołanie save()obiektu o zdefiniowanym identyfikatorze spowoduje zaktualizowanie odpowiedniego rekordu bazy danych zamiast wstawienia nowego, a także wyjaśni, dlaczego save()nie jest wywoływany create().

Ponieważ odpowiedź @axtavt koncentruje się na JPAniespring-data-jpa

Aby zaktualizować jednostkę za pomocą zapytania, zapisywanie nie jest wydajne, ponieważ wymaga dwóch zapytań i być może zapytanie może być dość drogie, ponieważ może łączyć się z innymi tabelami i ładować dowolne kolekcje, które mają fetchType=FetchType.EAGER

Spring-data-jpaobsługuje operację aktualizacji.
Musisz zdefiniować metodę w interfejsie repozytorium. I opatrzyć ją adnotacjami za pomocą @Queryi @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);

@Queryjest do zdefiniowania niestandardowego zapytania i @Modifyingjest za mówienie spring-data-jpa, że ta kwerenda jest operacja aktualizacji i wymaga executeUpdate()nie executeQuery().

Możesz określić inne typy zwrotów:
int- liczbę aktualizowanych rekordów.
boolean- prawda, jeśli aktualizowany jest rekord. W przeciwnym razie fałszywe.

Uwaga : uruchom ten kod w transakcji .

Możesz po prostu użyć tej funkcji z funkcją JPA save (), ale obiekt wysłany jako parametr musi zawierać istniejący identyfikator w bazie danych, inaczej nie zadziała, ponieważ save (), gdy wysyłamy obiekt bez identyfikatora, dodaje bezpośrednio wiersz w baza danych, ale jeśli wyślemy obiekt z istniejącym identyfikatorem, zmieni to kolumny już znalezione w bazie danych.

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

Jak już wspomnieli inni, save()sam zawiera operacje tworzenia i aktualizacji.

Chcę tylko dodać suplement dotyczący tego, co kryje się za tą save()metodą.

Po pierwsze, zobaczmy hierarchię rozszerzania / implementowania CrudRepository<T,ID>,

Ok, niech sprawdzić save()wdrażania na 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);
    }
}

Jak widać, sprawdzi najpierw, czy identyfikator istnieje, czy nie, jeśli jednostka już tam jest, tylko aktualizacja zostanie wykonana merge(entity)metodą, a jeśli nie, nowy rekord zostanie wstawiony persist(entity)metodą.

Korzystając z spring-data-jpa save(), miałem taki sam problem jak @DtechNet. Mam na myśli, że każdy save()tworzył nowy obiekt zamiast aktualizacji. Aby rozwiązać ten problem, musiałem dodać versionpole do encji i powiązanej tabeli.

Oto jak rozwiązałem problem:

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

save()metoda danych wiosennych pomoże Ci wykonać zarówno: dodanie nowego elementu, jak i aktualizację istniejącego elementu.

Wystarczy zadzwonić save()i cieszyć się życiem :))

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

W szczególności, jak mam powiedzieć spring-data-jpa, że ​​użytkownicy, którzy mają tę samą nazwę użytkownika i imię, są w rzeczywistości RÓWNI i że ma to aktualizować byt. Zastąpienie równości nie działało.

W tym konkretnym celu można wprowadzić klucz złożony taki jak ten:

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

Mapowanie:

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

Oto jak z niego korzystać:

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

    private String description;

    //...
}

JpaRepository wyglądałby tak:

public interface UserEntityRepository extends JpaRepository<UserEntity, UserKey>

Następnie możesz użyć następującego idiomu: zaakceptuj DTO z informacjami o użytkowniku, wyodrębnij nazwę i imię i utwórz UserKey, następnie utwórz UserEntity za pomocą tego klucza złożonego, a następnie wywołaj Spring Data save (), który powinien wszystko dla ciebie rozwiązać.