• Skip to primary navigation
  • Skip to content

Mauda

IT, Java and Music

Graduação   SCJP   Mestrado
  • Apresentação
  • Certificação Java
  • JPA
    • Exceptions
  • JSF
  • Versionamento
  • Contato

Atualização da versão Hibernate – Interface org.hibernate.Query foi descontinuada

March 15, 2021 by Mauda Leave a Comment

Conteúdo do Post:
  1. Classes/Interfaces descontinuadas
  2. E o que a interface org.hibernate.Query tem a ver com isso?
  3. Exemplo de modificação
  4. Trocando as interfaces
  5. finally{

Olá Pessoal, tudo bem?

Continuando ainda nos problemas que ocorreram no projeto SeminariosCientificos devido a atualização do Hibernate, chegamos em um ponto interessante sobre a descontinuação (deprecated) da interface org.hibernate.Query. Veja na continuação deste artigo.

Classes/Interfaces descontinuadas

Um projeto de software, se bem utilizado pelo cliente, pode ter muitos anos de vida. Nesse tempo de vida do projeto, novas funcionalidades foram sendo construídas e outras, foram descontinuadas. Normalmente quando não queremos que uma classe/interface não seja utilizada mais pelos desenvolvedores é utilizada a annotation @Deprecated. Mas ela não se limita apenas a classe. As vezes você deseja que apenas um método seja descontinuado, a annotation pode ser utilizada nele também.

Na IDE Eclipse ao utilizar essa annotation, a IDE irá tachar o nome da classe/interface/método para que o desenvolvedor perceba que não pode continuar a utilizar aquele método. Normalmente junto com a annotation é informado o motivo da descontinuação.

 

E o que a interface org.hibernate.Query tem a ver com isso?

Então, essa annotation foi utilizada nessa interface, como mostra o javadoc abaixo:

Java
1
2
3
4
5
6
7
8
9
10
11
/**
* Represents an HQL/JPQL query or a compiled Criteria query
*
* @author Gavin King
* @author Steve Ebersole
*
* @deprecated (since 5.2) use {@link org.hibernate.query.Query} instead
*/
@Deprecated
@SuppressWarnings("UnusedDeclaration")
public interface Query<R> extends TypedQuery<R>, CommonQueryContract {

 

Perceba que foi colocada a versão do Hibernate que essa interface foi descontinuada, 5.2, além de informar qual é a nova interface que deverá ser utilizada. Nesse caso a org.hibernate.query.Query. Assim você deverá mudar em seu código todos os lugares que utilizam a interface Query do package org.hibernate.

Além dessa mudança de package o que mais a interface trouxe? Agora é possível declarar a tipagem que o Hibernate irá retornar em uma query. Antes era necessário fazer um type cast para o retorno desejado, além de gerar um warning de ¨Type safety: Unchecked cast from Object to AreaCientifica¨.

 

Exemplo de modificação

O código do método abaixo mostra uma classe ainda com a interface org.hibernate.Query. Nesse exemplo, o import da interface Query foi adicionado no começo do código. A declaração da classe e outros métodos foram omitidos a fim de deixar o código menor.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//no começo da classe
import org.hibernate.Query;
 
//Declaração da classe e outros métodos omitidos
 
    public AreaCientifica findById(Long id) {
        Session session = HibernateUtil.getSession();
        try {
            Query byIdQuery = session.createQuery(this.findByIdHQL);
            byIdQuery.setParameter("id", id);
            AreaCientifica object = (AreaCientifica) byIdQuery.uniqueResult();
            this.inicializaLazyObjects(object);
            return object;
        } catch (Exception e) {
            throw new SeminariosCientificosException(e);
        } finally {
            session.close();
        }
    }

 

Perceba que nas linhas marcadas, não são especificados nenhum tipo. Na linha 6 quando fazemos a tipagem a força (Type Cast) é gerado o seguinte warning:

¨Type safety: Unchecked cast from Object to AreaCientifica¨

 

Trocando as interfaces

Para realizar essa troca de interfaces corretamente, precisaremos realizar 3 passos básicos:

  • Alterar o import com o package novo
  • Adicionar o tipo de retorno desejado ao método CreateQuery e o tipo na declaração de Query
  • Remover o Type Cast

Para alterar o import, vamos adicionar o query ao package já existente, como mostra o código abaixo:

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//no começo da classe
import org.hibernate.query.Query;
 
//Declaração da classe e outros métodos omitidos
 
    public AreaCientifica findById(Long id) {
        Session session = HibernateUtil.getSession();
        try {
            Query byIdQuery = session.createQuery(this.findByIdHQL);
            byIdQuery.setParameter("id", id);
            AreaCientifica object = (AreaCientifica) byIdQuery.uniqueResult();
            this.inicializaLazyObjects(object);
            return object;
        } catch (Exception e) {
            throw new SeminariosCientificosException(e);
        } finally {
            session.close();
        }
    }

 

Alterado o import, vamos adicionar o tipo desejado como parâmetro ao método createQuery. No caso como estamos recuperando uma instancia da classe AreaCientifica, vamos adicionar essa classe. Outro ponto é modificar a declaração da variável local Query com a tipagem generics da classe indicada, como mostra o código abaixo:

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//no começo da classe
import org.hibernate.query.Query;
 
//Declaração da classe e outros métodos omitidos
 
    public AreaCientifica findById(Long id) {
        Session session = HibernateUtil.getSession();
        try {
            Query<AreaCientifica> byIdQuery = session.createQuery(this.findByIdHQL, AreaCientifica.class);
            byIdQuery.setParameter("id", id);
            AreaCientifica object = (AreaCientifica) byIdQuery.uniqueResult();
            this.inicializaLazyObjects(object);
            return object;
        } catch (Exception e) {
            throw new SeminariosCientificosException(e);
        } finally {
            session.close();
        }
    }

 

Por fim, agora que o método createQuery já retornou uma instância de Query, com a tipagem de AreaCientifica, pode ser removido o type cast da linha 11, como mostra o código abaixo:

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//no começo da classe
import org.hibernate.query.Query;
 
//Declaração da classe e outros métodos omitidos
 
    public AreaCientifica findById(Long id) {
        Session session = HibernateUtil.getSession();
        try {
            Query<AreaCientifica> byIdQuery = session.createQuery(this.findByIdHQL, AreaCientifica.class);
            byIdQuery.setParameter("id", id);
            AreaCientifica object = byIdQuery.uniqueResult();
            this.inicializaLazyObjects(object);
            return object;
        } catch (Exception e) {
            throw new SeminariosCientificosException(e);
        } finally {
            session.close();
        }
    }

 

E pronto seu método já está utilizando a nova interface Query, que agora possui tipagem direta em sua declaração!

finally{

Ainda existem mais pontos dessa atualização. Fique ligado no próximos artigos!

Duvidas ou sugestões? Deixe seu feedback! Isso ajuda a saber a sua opinião sobre os artigos e melhorá-los para o futuro! Isso é muito importante!

Até um próximo post!

Filed Under: Hibernate, Java, JPA Tagged With: Hibernate, Java, JPA, Query, Type Cast

About Mauda

Mestre em Informática, Analista de Sistemas, Professor, SCJP e Baterista. Desde 2002 trabalhando no mundo Java e ensinando pessoas sobre desenvolvimento de sistemas. Mais informações

Reader Interactions

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Advertisements

Copyright © 2025 · Genesis Framework · WordPress · Log in