Entidades de consulta por datas e horas com o JPA de dados da primavera

1. Introdução

Neste tutorial rápido, veremos como consultar entidades por datas com Spring Data JPA.

Primeiro, vamos refrescar nossa memória sobre como mapear datas e horas com JPA.

Então, vamos criar uma entidade com campos de data e hora, bem como um repositório Spring Data para consultar essas entidades.

2. Mapeando datas e horas com o JPA

Para começar,we’ll review a bit of theory about mapping dates with JPA. O importante é que precisamos decidir se queremos representar:

Apenas uma data
Apenas um tempo
Ou ambos

Além da anotação@Column (opcional), precisaremos adicionar a anotação@Temporal para especificar o que o campo representa.

Esta anotação leva um parâmetro que é um valor deTemporalType enum:

TemporalType.DATE
TemporalType.TIME
TemporalType.TIMESTAMP

Um artigo detalhado sobre o mapeamento de datas e horas com JPA pode ser encontradohere.

3. Na prática

Na prática, uma vez que nossas entidades estejam configuradas corretamente, não há muito trabalho para consultá-las usando o Spring Data JPA. Só temos que usarquery methods, @Query annotation.

Every Spring Data JPA mechanism will work just fine.

Vejamos alguns exemplos de entidades consultadas por datas e horas com Spring Data JPA.

3.1. Configurar uma entidade

Para começar, digamos que temos uma entidadeArticle, com uma data de publicação, uma hora de publicação e uma data e hora de criação:

@Entity
public class Article {

    @Id
    @GeneratedValue
    Integer id;

    @Temporal(TemporalType.DATE)
    Date publicationDate;

    @Temporal(TemporalType.TIME)
    Date publicationTime;

    @Temporal(TemporalType.TIMESTAMP)
    Date creationDateTime;
}

Dividimos a data e a hora da publicação em dois campos para fins de demonstração. Dessa forma, os três tipos temporais são representados.

3.2. Consultar as entidades

Agora que nossa entidade está configurada, vamos criar um Spring Datarepository para consultar esses artigos.

Vamos criar três métodos, usando vários recursos do Spring Data JPA:

public interface ArticleRepository
  extends JpaRepository {

    List findAllByPublicationDate(Date publicationDate);

    List findAllByPublicationTimeBetween(
      Date publicationTimeStart,
      Date publicationTimeEnd);

    @Query("select a from Article a where a.creationDateTime <= :creationDateTime")
    List findAllWithCreationDateTimeBefore(
      @Param("creationDateTime") Date creationDateTime);

}

Então, definimos três métodos:

findAllByPublicationDate que recupera artigos publicados em uma determinada data
findAllByPublicationTimeBetween que recupera artigos publicados entre duas horas fornecidas
efindAllWithCreationDateTimeBefore que recupera artigos criados antes de uma determinada data e hora

Os dois primeiros métodos contam com o mecanismo Spring Dataquery methods e o último com a anotação@Query.

No final das contas, isso não muda a forma como as datas serão tratadas. The first method will only consider the date part of the parameter.

O segundo considerará apenas o tempo dos parâmetros. E o último usará data e hora.

3.3. Teste as consultas

A última coisa que devemos fazer é configurar alguns testes para verificar se essas consultas funcionam conforme o esperado.

Primeiro importaremos alguns dados para nosso banco de dados e, em seguida, criaremos a classe de teste que verificará cada método do repositório:

@RunWith(SpringRunner.class)
@DataJpaTest
public class ArticleRepositoryIntegrationTest {

    @Autowired
    private ArticleRepository repository;

    @Test
    public void whenFindByPublicationDate_thenArticles1And2Returned() {
        List result = repository.findAllByPublicationDate(
          new SimpleDateFormat("yyyy-MM-dd").parse("2018-01-01"));

        assertEquals(2, result.size());
        assertTrue(result.stream()
          .map(Article::getId)
          .allMatch(id -> Arrays.asList(1, 2).contains(id)));
    }

    @Test
    public void whenFindByPublicationTimeBetween_thenArticles2And3Returned() {
        List result = repository.findAllByPublicationTimeBetween(
          new SimpleDateFormat("HH:mm").parse("15:15"),
          new SimpleDateFormat("HH:mm").parse("16:30"));

        assertEquals(2, result.size());
        assertTrue(result.stream()
          .map(Article::getId)
          .allMatch(id -> Arrays.asList(2, 3).contains(id)));
    }

    @Test
    public void givenArticlesWhenFindWithCreationDateThenArticles2And3Returned() {
        List result = repository.findAllWithCreationDateTimeBefore(
          new SimpleDateFormat("yyyy-MM-dd HH:mm").parse("2017-12-15 10:00"));

        assertEquals(2, result.size());
        assertTrue(result.stream()
          .map(Article::getId)
          .allMatch(id -> Arrays.asList(2, 3).contains(id));
    }
}

Cada teste verifica se apenas os artigos correspondentes às condições são recuperados.

4. Conclusão

Neste breve artigo, vimos como consultar entidades usando seus campos de datas e horas com Spring Data JPA.

Aprendemos um pouco de teoria antes de usar os mecanismos do Spring Data para consultar as entidades. Vimos que esses mecanismos funcionam da mesma maneira com datas e horas do que com outros tipos de dados.

O código-fonte deste artigo está disponívelover on GitHub.

TOC

Entidades de consulta por datas e horas com o JPA de dados da primavera