将Hibernate Query.list（）强制转换为List <Type>的“正确”方法是什么？

我是Hibernate的新手，我正在写一个简单的方法来返回与特定过滤器匹配的对象列表。List<Foo>似乎是自然的回报类型。

不管我做什么，除非雇用了ugly，否则似乎都无法使编译器满意@SuppressWarnings。

import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;

public class Foo {

    public Session acquireSession() {
        // All DB opening, connection etc. removed,
        // since the problem is in compilation, not at runtime.
        return null;
    }

    @SuppressWarnings("unchecked") /* <----- */

    public List<Foo> activeObjects() {
        Session s = acquireSession();
        Query   q = s.createQuery("from foo where active");
        return (List<Foo>) q.list();
    }
}

我想摆脱它SuppressWarnings。但是如果我这样做，我会得到警告

Warning: Unchecked cast from List to List<Foo>

（我可以忽略它，但是我不想一开始就得到它），如果我删除泛型以符合.list()返回类型，则会收到警告

Warning: List is a raw type. References to generic type List<E>
should be parameterized.

我注意到org.hibernate.mapping 确实声明了List；但这是完全不同的类型-Query返回ajava.util.List作为原始类型。我发现最近的Hibernate（4.0.x）无法实现参数化类型很奇怪，因此我怀疑是我自己在做错事情。

它看起来非常像将Hibernate结果转换为对象列表，但是在这里我没有“硬”错误（系统知道类型为Foo，并且我没有使用SQLQuery，而是使用了直接查询）。所以没有喜悦。

我也看过Hibernate Class Cast Exception，因为它看起来很有希望，但是后来我意识到我实际上并没有得到任何信息Exception……我的问题只是一个警告的问题-如果可以的话，是一种编码样式。

关于jboss.org的文档，Hibernate手册和一些教程似乎没有如此详细地涵盖该主题（或者我没有在正确的位置搜索？）。当他们确实进入细节时，他们会使用即时转换-以及不在jboss.org官方网站上的教程中使用的转换，因此我有些警惕。

代码一旦编译，就不会出现明显的问题……我知道……。结果是预期的。

所以：我这样做对吗？我是否缺少明显的东西？有“正式”或“推荐”的方式吗？

简短的答案@SuppressWarnings是正确的方法。

长答案，HibernateList从该Query.list方法返回一个原始值，请参见此处。这不是Hibernate的错误，也不是可以解决的问题，查询返回的类型在编译时未知。

因此，当你写

final List<MyObject> list = query.list();

您正在执行从List到的不安全转换List<MyObject>-无法避免。

您可能无法安全地执行转换，因为其中List 可能包含任何内容。

使错误消失的唯一方法是更丑陋

final List<MyObject> list = new LinkedList<>();
for(final Object o : query.list()) {
    list.add((MyObject)o);
}

解决方法是改用TypedQuery。当从EntityManager创建查询时，应这样调用它：

TypedQuery<[YourClass]> query = entityManager.createQuery("[your sql]", [YourClass].class);
List<[YourClass]> list = query.getResultList(); //no type warning

这对于命名查询，本机命名查询等也相同。相应的方法具有与将返回原始查询的名称相同的名称。只要知道返回类型，就使用它代替查询。

您可以使用以下解决方法来避免编译器警告：

List<?> resultRaw = query.list();
List<MyObj> result = new ArrayList<MyObj>(resultRaw.size());
for (Object o : resultRaw) {
    result.add((MyObj) o);
}

但是此代码存在一些问题：

• 创建多余的ArrayList
• 查询返回的所有元素上不必要的循环
• 更长的代码。

而且区别只是外观上的，因此，我认为使用这种解决方法是没有意义的。

您必须忍受这些警告或压制它们。

要回答您的问题，没有“正确的方法”可以做到这一点。现在，如果只是打扰您的警告，避免扩散的最佳方法是将Query.list()方法包装到DAO中：

public class MyDAO {

    @SuppressWarnings("unchecked")
    public static <T> List<T> list(Query q){
        return q.list();
    }
}

这样，您@SuppressWarnings("unchecked")只能使用一次。

对我而言唯一可行的方法是使用Iterator。

Iterator iterator= query.list().iterator();
Destination dest;
ArrayList<Destination> destinations= new ArrayList<>();
Iterator iterator= query.list().iterator();
    while(iterator.hasNext()){
        Object[] tuple= (Object[]) iterator.next();
        dest= new Destination();
        dest.setId((String)tuple[0]);
        dest.setName((String)tuple[1]);
        dest.setLat((String)tuple[2]);
        dest.setLng((String)tuple[3]);
        destinations.add(dest);
    }

使用其他发现的方法，我出现了问题

List<Person> list = new ArrayList<Person>();
Criteria criteria = this.getSessionFactory().getCurrentSession().createCriteria(Person.class);
for (final Object o : criteria.list()) {
    list.add((Person) o);
}

您可以这样使用ResultTransformer：

public List<Foo> activeObjects() {
    Session s = acquireSession();
    Query   q = s.createQuery("from foo where active");
    q.setResultTransformer(Transformers.aliasToBean(Foo.class));
    return (List<Foo>) q.list();
}

正确的方法是使用休眠变压器：

public class StudentDTO {
private String studentName;
private String courseDescription;

public StudentDTO() { }  
...
} 

。

List resultWithAliasedBean = s.createSQLQuery(
"SELECT st.name as studentName, co.description as courseDescription " +
"FROM Enrolment e " +
"INNER JOIN Student st on e.studentId=st.studentId " +
"INNER JOIN Course co on e.courseCode=co.courseCode")
.setResultTransformer( Transformers.aliasToBean(StudentDTO.class))
.list();

StudentDTO dto =(StudentDTO) resultWithAliasedBean.get(0);

遍历Object []是多余的，并且会降低性能。有关转炉使用的详细信息，您将在这里找到： 用于HQL和SQL的变压器

如果您正在寻找更简单的解决方案，则可以使用开箱即用的地图转换器：

List iter = s.createQuery(
"select e.student.name as studentName," +
"       e.course.description as courseDescription" +
"from   Enrolment as e")
.setResultTransformer( Transformers.ALIAS_TO_ENTITY_MAP )
.iterate();

String name = (Map)(iter.next()).get("studentName");

仅使用Transformers对我不起作用，我遇到了类型转换异常。

sqlQuery.setResultTransformer(Transformers.aliasToBean(MYEngityName.class)) 没有用，因为我在返回列表元素中获取了对象数组，而不是列表元素的固定MYEngityName类型。

当我进行以下更改时sqlQuery.addScalar(-)，它对我有用。当我添加了每个选定的列及其类型时，对于特定的String类型列，我们不必映射其类型。喜欢addScalar("langCode");

我将MYEngityName与NextEnity结合在一起，我们不能仅仅select *在Query中将它返回列表中的Object数组。

下面的代码示例：

session = ht.getSessionFactory().openSession();
                String sql = new StringBuffer("Select txnId,nft.mId,count,retryReason,langCode FROM  MYEngityName nft INNER JOIN NextEntity m on nft.mId  =  m.id where nft.txnId < ").append(lastTxnId)
                       .append(StringUtils.isNotBlank(regionalCountryOfService)? " And  m.countryOfService in ( "+ regionalCountryOfService +" )" :"")
                       .append(" order by nft.txnId desc").toString();
                SQLQuery sqlQuery = session.createSQLQuery(sql);
                sqlQuery.setResultTransformer(Transformers.aliasToBean(MYEngityName.class));
                sqlQuery.addScalar("txnId",Hibernate.LONG)
                        .addScalar("merchantId",Hibernate.INTEGER)
                        .addScalar("count",Hibernate.BYTE)
                        .addScalar("retryReason")
                        .addScalar("langCode");
                sqlQuery.setMaxResults(maxLimit);
                return sqlQuery.list();

它可能会有所帮助。以这种方式为我工作。

我在这里找到了最佳解决方案，此问题的关键是 addEntity方法

public static void testSimpleSQL() {
    final Session session = sessionFactory.openSession();
    SQLQuery q = session.createSQLQuery("select * from ENTITY");
    q.addEntity(Entity.class);
    List<Entity> entities = q.list();
    for (Entity entity : entities) {
        System.out.println(entity);
    }
}