Comment puis-je mettre à jour une entité à l'aide de spring-data-jpa?

Identité des entités est définie par leurs clés primaires. Depuis firstname et lastname ne font pas partie de la clé primaire, on ne peut pas dire JPA pour traiter Users avec le même firstnames et lastnames comme égales si elles ont différentes userIds.

Donc, si vous voulez mettre à jour un User identifié par son firstname et lastname, vous avez besoin de trouver User par une requête, puis changer les champs appropriés de l'objet de votre découvert. Ces changements seront vidées à la base de données automatiquement à la fin de la transaction, de sorte que vous n'avez pas besoin de faire quelque chose pour sauver ces changements de manière explicite.

EDIT:

Peut-être que je devrait élaborer sur l'ensemble de la sémantique de la JPA. Il existe deux principales approches pour la conception de la persistance Api:

• insérer/mettre à jour l'approche. Lorsque vous avez besoin de modifier la base de données, vous devez appeler les méthodes de la persistance API explicitement: vous appelez insert pour insérer un objet, ou update pour enregistrer le nouvel état de l'objet à la base de données.

• Unité de Travail approche. Dans ce cas, vous disposez d'un ensemble d'objets géré par la persistance de la bibliothèque. Toutes les modifications que vous apportez à ces objets seront vidées à la base de données automatiquement à la fin de l'Unité de Travail (c'est à dire à la fin de la transaction en cours dans le cas typique). Lorsque vous avez besoin d'insérer un nouvel enregistrement dans la base de données, vous faites l'objet correspondant géré. Géré les objets sont identifiés par leurs clés primaires, de sorte que si vous en faites un objet prédéfini clé primaire géré, il sera associé à l'enregistrement de base de données de la même id, et l'état de cet objet va être propagées à cet enregistrement automatiquement.

JPA suit l'autre approche. save() au Printemps de Données JPA est soutenu par merge() dans la plaine, JPA, par conséquent, il rend votre entité géré comme décrit ci-dessus. Cela signifie que l'appel save() sur un objet avec l'id prédéfini sera mise à jour de la base de données correspondante, plutôt que d'insérer un nouveau un seul, et explique aussi pourquoi save() n'est pas appelé create().

Que ce qui a déjà mentionné par d'autres, la save() lui-même contient à la fois de créer et d'opération de mise à jour.

Je veux juste ajouter un supplément à propos de ce que derrière le save() méthode.

Tout d'abord, nous allons voir l'étendre en œuvre de la hiérarchie de l' CrudRepository<T,ID>,

Ok, nous allons vérifier la save() la mise en œuvre au 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);
    }
}

Comme vous pouvez le voir, il vérifie si l'ID de l'existence ou non d'une part, si l'entité est déjà là, seule la mise à jour se fera par merge(entity) méthode, et si d'autre, un nouvel enregistrement est inséré par persist(entity) méthode.

À l'aide de spring-data-jpa save(),
J'ai eu le même problème que @DtechNet. Je veux dire tous les save() a été la création de nouveaux objets au lieu de les mettre à jour. Pour résoudre cela, j'ai dû ajouter "version" déposée à l'entité et de la table liée.

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

Précisément comment dois-je dire à spring-data-jpa que les utilisateurs qui ont le
même nom d'utilisateur et le prénom sont en fait ÉGAUX et qu'il est censé
pour mettre à jour l'entité. Primordial est égal n'a pas de travail.

Dans ce but on peut introduire une clé composée comme ceci:

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

Cartographie:

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

Voici comment l'utiliser:

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

    private String description;

    //...
}

JpaRepository devrait ressembler à ceci:

public interface UserEntityRepository extends JpaRepository<UserEntity, UserKey>

Ensuite, vous pouvez utiliser les éléments suivants idiome: accepter DTO avec les infos de l'utilisateur, l'extrait de nom et de prénom et de créer UserKey, puis créer un UserEntity avec cette clé composite puis d'appeler le Printemps de sauvegarde de Données (), qui doit tout régler pour vous.