TOC

Anotação JPA @Basic

Anotação JPA @Basic

1. Visão geral

Neste tutorial rápido, exploraremos a anotação JPA _ @ Basic_. Também discutiremos a diferença entre as anotações _ @ Basic_ e _ @ Column_ JPA.

2. Tipos básicos

O JPA suporta vários tipos de dados Java como campos persistentes de uma entidade, geralmente conhecidos como tipos básicos.

*Um tipo básico é mapeado diretamente para uma coluna no banco de dados.* Eles incluem primitivas Java e suas classes de wrapper, _String_, _java.math.BigInteger_ e_ java.math.BigDecimal_, várias classes de data e hora disponíveis, enumerações e qualquer outro tipo que implementa _java.io.Serializable_.

O Hibernate, como qualquer outro fornecedor de ORM, mantém um registro de tipos básicos e o utiliza para resolver org.hibernate.type.Type de uma coluna específica.

3. _ @ Anotação Básica

Podemos usar a anotação _ @ Basic_ para marcar uma propriedade de tipo básico:

@Entity
public class Course {

    @Basic
    @Id
    private int id;

    @Basic
    private String name;
    ...
}

Em outras palavras, a anotação _ @ Basic_ em um campo ou propriedade significa que é um tipo básico e o Hibernate deve usar o mapeamento padrão para sua persistência.

*Observe que é uma anotação opcional.* E assim, podemos reescrever nossa entidade _Course_ como:
@Entity
public class Course {

    @Id
    private int id;

    private String name;
    ...
}

  • Quando não especificamos a anotação _ @ Basic_ para um atributo de tipo básico, ela é assumida implicitamente e os valores padrão dessa anotação se aplicam.

4. Por que usar a anotação _ @ Basic_?

A anotação _ @ Basic_ possui dois atributos, optional e fetch. Vamos dar uma olhada em cada um.

*O atributo _optional_ é um parâmetro _boolean_ que define se o campo ou a propriedade marcada permite _null _.* O padrão é _true_. Portanto, se o campo não for um tipo primitivo, a coluna subjacente será assumida como _nullable_ por padrão.

O atributo fetch aceita um membro da enumeração Fetch, que especifica se o campo ou a propriedade marcada deve ser carregada ou buscada com folga preguiçosamente. O padrão é FetchType.EAGER, mas podemos permitir o carregamento lento, definindo-a como _FetchType.LAZY. _

O carregamento lento apenas fará sentido quando tivermos um objeto Serializable grande mapeado como um tipo básico, pois, nesse caso, o custo de acesso ao campo pode ser significativo.

Temos um tutorial detalhado que aborda https://www..com/hibernate-lazy-eager-loading [Carregamento ansioso/preguiçoso no Hibernate] que faz um mergulho mais profundo no tópico.

Agora, digamos que não queira permitir nulls para nossos Course‘s name e queira carregar preguiçosamente essa propriedade também. Em seguida, definiremos nossa entidade Course como:

@Entity
public class Course {

    @Id
    private int id;

    @Basic(optional = false, fetch = FetchType.LAZY)
    private String name;
    ...
}
*Devemos usar explicitamente a anotação _ @ Basic_ quando desejar desviar dos valores padrão dos parâmetros _optional_ e _fetch_* . Podemos especificar um ou ambos os atributos, dependendo de nossas necessidades.

5. JPA _ @ Básico_ vs _ @ Coluna_

Vejamos as diferenças entre as anotações _ @ Basic_ e _ @ Column_:

  • Os atributos da anotação _ @ Basic_ são aplicados às entidades JPA, enquanto os atributos de _ @ Column_ são aplicados às colunas do banco de dados

  • O atributo optional da anotação _ @ Basic_ define se o campo da entidade pode ser nulo ou não; por outro lado, o atributo nullable da anotação _ @ Column_ especifica se a coluna do banco de dados correspondente pode ser null

  • Podemos usar _ @ Basic_ para indicar que um campo deve ser carregado lentamente

  • A anotação _ @ Column_ permite especificar o name da coluna do banco de dados mapeado

6. Conclusão

Neste artigo, aprendemos quando e como usar a anotação _ @ Basic_ da JPA. Também falamos sobre como ela difere da anotação _ @ Column_.

Como sempre, exemplos de código estão disponíveis over no Github.

Related