@DynamicUpdate com Spring Data JPA

1. Visão geral

Quando usamos o Spring Data JPA com o Hibernate, também podemos usar os recursos adicionais do Hibernate. @DynamicUpdate é um desses recursos.

@DynamicUpdate é uma anotação em nível de classe que pode ser aplicada a uma entidade JPA. It ensures that Hibernate uses only the modified columns in the SQL statement that it generates for the update of an entity.

Neste artigo, daremos uma olhada na anotação@DynamicUpdate, com a ajuda de um exemploSpring Data JPA.

2. JPA@Entity

Quando um aplicativo é iniciado, o Hibernate gera as instruções SQL para operações CRUD de todas as entidades. Essas instruções SQL são geradas uma vez e são armazenadas em cache, na memória, para melhorar o desempenho.

A instrução de atualização SQL gerada inclui todas as colunas de uma entidade. Caso atualizemos uma entidade, os valores das colunas modificadas são passados para a instrução de atualização SQL. Para as colunas que não são atualizadas, o Hibernate usa seus valores existentes para a atualização.

Vamos tentar entender isso com um exemplo. Primeiro, vamos considerar uma entidade JPA chamadaAccount:

@Entity
public class Account {

    @Id
    private int id;

    @Column
    private String name;

    @Column
    private String type;

    @Column
    private boolean active;

    // Getters and Setters
}

A seguir, vamos escrever um repositório JPA para a entidadeAccount:

@Repository
public interface AccountRepository extends JpaRepository {
}

Agora, usaremosAccountRepository para atualizar o camponame de um objetoAccount:

Account account = accountRepository.findOne(ACCOUNT_ID);
account.setName("Test Account");
accountRepository.save(account);

Depois de executar esta atualização, podemos verificar a instrução SQL gerada. A instrução SQL gerada incluirá todas as colunas deAccount:

update Account set active=?, name=?, type=? where id=?

3. JPA@Entity com@DynamicUpdate

Vimos que, embora tenhamos modificado apenas o camponame, o Hibernate incluiu todas as colunas na instrução SQL.

Agora, vamos adicionar a anotação@DynamicUpdate à entidadeAccount:

@Entity
@DynamicUpdate
public class Account {
    // Existing data and methods
}

A seguir, vamos executar o mesmo código de atualização que usamos na seção anterior. Podemos ver que o SQL gerado pelo Hibernate, neste caso, inclui apenas a colunaname:

update Account set name=? where id=?

Então,what happens when we use @DynamicUpdate on an entity?

Na verdade, quando usamos@DynamicUpdate em uma entidade, o Hibernate não usa a instrução SQL em cache para a atualização. Em vez disso, ele gerará uma instrução SQL sempre que atualizarmos a entidade. Estegenerated SQL includes only the changed columns.

Para descobrir as colunas alteradas, o Hibernate precisa rastrear o estado da entidade atual. Portanto, quando alteramos qualquer campo de uma entidade, ele compara os estados atual e modificado da entidade.

Isso significa que@DynamicUpdate has a performance overhead associated with it. Portanto, devemos apenas usá-lo quando for realmente necessário.

Certamente, existem alguns cenários nos quais devemos usar esta anotação - por exemplo, se uma entidade representa uma tabela que possui um grande número de colunas e apenas algumas dessas colunas precisam ser atualizadas com frequência. Além disso, quando usamos o bloqueio otimista sem versão, precisamos usar@DynamicUpdate.

4. Conclusão

Neste tutorial, vimos a anotação@DynamicUpdate do Hibernate. Usamos um exemplo de Spring Data JPA para ver@DynamicUpdate em ação. Além disso, discutimos quando devemos usar esse recurso e quando não devemos.

Como sempre, os exemplos de código completos usados neste tutorial estão disponíveisover on Github.

TOC

@DynamicUpdate com Spring Data JPA