Java Hibernate转换器别名ToBeanNestedResultTransformer

我有一个这样的疑问。我传递学生ID我需要来自学生及其家长的一些字段以及来自家长的一些字段->地址[这是我面临的主要问题]我使用的是

别名NeastedResultTransformer

transformer by

下面是它的实现

这是我的密码

public List<Student>searchForStudent(Integer studentId)
{           
    Projection p=Projections.projectionList().create()
    .add(Projections.property("name"),"name")//the student name it works O.K
    .add(Projections.property("lastname"),"lastname")//the student name it works O.K
    .add(Projections.property("age"),"age")//the student AGE it works O.K                
    .add(Projections.property("p.phone"),"parent.phone")//the parent phone it works O.K                
    .add(Projections.property("address.state").as("parent.Address.state")); // i need a field from address.state here is the problem...  
    Session session = ......
    Criteria like = session.createCriteria(Student.class).add(prepareForSelect())//some filters..
    .createAlias("parent","p")//the parent of the student. a student have one parent
    .createAlias("parent.Address","address")//the address of the parent.... a parent have one address.
    .setProjection(p)                
    .setResultTransformer(new AliasToBeanNestedResultTransformer(Student.class));    
    List<Student>results=like.list();   
    return results;     
}         

仅供参考，我在

SAMI

code中做了一些跟踪，我看到了这一点

[MyState]
[Address]

在这种情况下，Hibernate似乎返回了

字符串状态

MyState

，而转换器使用的是

地址对象

，这就是

类型不匹配。

有什么需要帮助的吗

---

非常感谢。

我改进了SamiAndoni课程，也许它能解决你的问题

package com.alutiiq.develop.promanagesys.core.util;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.property.PropertyAccessor;
import org.hibernate.property.PropertyAccessorFactory;
import org.hibernate.property.Setter;
import org.hibernate.transform.AliasToBeanResultTransformer;
import org.hibernate.transform.AliasedTupleSubsetResultTransformer;
import org.hibernate.transform.ResultTransformer;

/**
 * Help to transform alises with nested alises
 * 
 * @author Miguel Resendiz
 * 
 */
public class AliasToBeanNestedResultTransformer extends
    AliasedTupleSubsetResultTransformer {

    private static final long serialVersionUID = -8047276133980128266L;

    private static final int TUPE_INDEX = 0;
    private static final int ALISES_INDEX = 1;
    private static final int FIELDNAME_INDEX = 2;

    private static final PropertyAccessor accessor = PropertyAccessorFactory
        .getPropertyAccessor("property");

    private final Class<?> resultClass;

    private Object[] entityTuples;
    private String[] entityAliases;

    private Map<String, Class<?>> fieldToClass = new HashMap<String, Class<?>>();
    private Map<String, List<?>> subEntities = new HashMap<String, List<?>>();
    private List<String> nestedAliases = new ArrayList<String>();
    private Map<String, Class<?>> listFields = new HashMap<String, Class<?>>();

    public boolean isTransformedValueATupleElement(String[] aliases,
        int tupleLength) {
    return false;
    }

    public AliasToBeanNestedResultTransformer(Class<?> resultClass) {

    this.resultClass = resultClass;
    }

    public Object transformTuple(Object[] tuple, String[] aliases) {

    handleSubEntities(tuple, aliases);
    cleanParams(tuple, aliases);
    ResultTransformer rootTransformer = new AliasToBeanResultTransformer(
        resultClass);
    Object root = rootTransformer.transformTuple(entityTuples,
        entityAliases);

    loadSubEntities(root);

    cleanMaps();
    return root;
    }

    private void handleSubEntities(Object[] tuple, String[] aliases)
        throws HibernateException {
    String fieldName = "";
    String aliasName = "";
    try {
        for (int i = 0; i < aliases.length; i++) {
        String alias = aliases[i];
        if (alias.contains(".")) {

            String[] sp = alias.split("\\.");
            StringBuilder aliasBuilder = new StringBuilder();
            for (int j = 0; j < sp.length; j++) {
            if (j == 0) {
                fieldName = sp[j];
            } else {
                aliasBuilder.append(sp[j]);
                aliasBuilder.append(".");
            }
            }
            aliasName = aliasBuilder.substring(0,
                aliasBuilder.length() - 1);

            nestedAliases.add(alias);
            manageEntities(fieldName, aliasName, tuple[i]);
        }
        }
    } catch (NoSuchFieldException e) {
        throw new HibernateException("Could not instantiate resultclass: "
            + resultClass.getName() + " for field name: " + fieldName
            + " and alias name:" + aliasName);
    }
    }

    private Class<?> findClass(String fieldName) throws NoSuchFieldException,
        SecurityException {
    if (fieldToClass.containsKey(fieldName)) {
        return fieldToClass.get(fieldName);
    } else {
        Class<?> subclass = resultClass.getDeclaredField(fieldName)
            .getType();

        if (subclass.equals(List.class) || subclass.equals(Set.class)) {
        if (subclass.equals(List.class)) {
            listFields.put(fieldName, LinkedList.class);
        } else {
            listFields.put(fieldName, HashSet.class);
        }
        Field field = resultClass.getDeclaredField(fieldName);
        ParameterizedType genericType = (ParameterizedType) field
            .getGenericType();
        subclass = (Class<?>) genericType.getActualTypeArguments()[0];

        }
        fieldToClass.put(fieldName, subclass);
        return subclass;
    }
    }

    @SuppressWarnings("unchecked")
    private void manageEntities(String fieldName, String aliasName,
        Object tupleValue) throws NoSuchFieldException, SecurityException {
    Class<?> subclass = findClass(fieldName);
    if (!subEntities.containsKey(fieldName)) {
        List<Object> list = new ArrayList<Object>();
        list.add(new ArrayList<Object>());
        list.add(new ArrayList<String>());
        list.add(FIELDNAME_INDEX, subclass);
        subEntities.put(fieldName, list);
    }
    ((List<Object>) subEntities.get(fieldName).get(TUPE_INDEX))
        .add(tupleValue);
    ((List<String>) subEntities.get(fieldName).get(ALISES_INDEX))
        .add(aliasName);
    }

    private void cleanParams(Object[] tuple, String[] aliases) {
    entityTuples = new Object[aliases.length - nestedAliases.size()];
    entityAliases = new String[aliases.length - nestedAliases.size()];

    for (int j = 0, i = 0; j < aliases.length; j++) {
        if (!nestedAliases.contains(aliases[j])) {
        entityTuples[i] = tuple[j];
        entityAliases[i] = aliases[j];
        ++i;
        }
    }
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    private void loadSubEntities(Object root) throws HibernateException {
    try {
        for (String fieldName : subEntities.keySet()) {
        Class<?> subclass = (Class<?>) subEntities.get(fieldName).get(
            FIELDNAME_INDEX);

        ResultTransformer subclassTransformer = new AliasToBeanNestedResultTransformer(
            subclass);

        Object subObject = subclassTransformer.transformTuple(
            ((List<Object>) subEntities.get(fieldName).get(0))
                .toArray(),
            ((List<Object>) subEntities.get(fieldName).get(1))
                .toArray(new String[0]));

        Setter setter = accessor.getSetter(resultClass, fieldName);
        if (listFields.containsKey(fieldName)) {
            Class<?> collectionClass = listFields.get(fieldName);
            Collection subObjectList = (Collection) collectionClass
                .newInstance();
            subObjectList.add(subObject);
            setter.set(root, subObjectList, null);
        } else {
            setter.set(root, subObject, null);
        }
        }
    } catch (Exception e) {
        throw new HibernateException(e);
    }
    }

    private void cleanMaps() {
    fieldToClass = new HashMap<String, Class<?>>();
    subEntities = new HashMap<String, List<?>>();
    nestedAliases = new ArrayList<String>();
    listFields = new HashMap<String, Class<?>>();
    }

}

package com.alutiiq.develope.promanagesys.core.util；
导入java.lang.reflect.Field；
导入java.lang.reflect.ParameterizedType；
导入java.util.ArrayList；
导入java.util.Collection；
导入java.util.HashMap；
导入java.util.HashSet；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Map；
导入java.util.Set；
导入org.hibernate.hibernateeexception；
导入org.hibernate.property.PropertyAccessor；
导入org.hibernate.property.PropertyAccessorFactory；
导入org.hibernate.property.Setter；
导入org.hibernate.transform.aliastobeansulttransformer；
导入org.hibernate.transform.aliasedtupleSubstresultTransformer；
导入org.hibernate.transform.ResultTransformer；
/**
*使用嵌套Alise转换Alise的帮助
* 
*@作者米格尔·雷森迪兹
* 
*/
公共类别名ToBeanNestedResultTransformer扩展
AliasedTupleSubstresultTransformer{
私有静态最终长serialVersionUID=-8047276133980128266L；
私有静态最终int TUPE_索引=0；
私有静态最终综合指数=1；
私有静态final int FIELDNAME_INDEX=2；
私有静态最终PropertyAccessor访问器=PropertyAccessorFactory
.getPropertyAccessor（“财产”）；
私有最终类resultClass；
私有对象[]实体元组；
私有字符串[]EntityAlias；
私人地图>（）；
私人地图>（）；
私有列表nestedAliases=newArrayList（）；
私人地图>（）；
公共布尔值isTransformedValueATupleElement（字符串[]别名，
int tupleLength）{
返回false；
}
公共别名ToBeanNestedResultTransformer（类resultClass）{
this.resultClass=resultClass；
}
公共对象转换元组（对象[]元组，字符串[]别名）{
handleSubEntities（元组、别名）；
cleanParams（元组、别名）；
ResultTransformer rootTransformer=新别名为ResultTransformer(
结果类）；
对象根=rootTransformer.transformTuple（entityTuples，
实体（别名）；
加载子实体（根）；
cleanMaps（）；
返回根；
}
私有void handleSubEntities（对象[]元组，字符串[]别名）
抛出冬眠异常{
字符串fieldName=“”；
字符串别名=”；
试一试{
对于（int i=0；ipackage com.alutiiq.develop.promanagesys.core.util;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.property.PropertyAccessor;
import org.hibernate.property.PropertyAccessorFactory;
import org.hibernate.property.Setter;
import org.hibernate.transform.AliasToBeanResultTransformer;
import org.hibernate.transform.AliasedTupleSubsetResultTransformer;
import org.hibernate.transform.ResultTransformer;

/**
 * Help to transform alises with nested alises
 * 
 * @author Miguel Resendiz
 * 
 */
public class AliasToBeanNestedResultTransformer extends
    AliasedTupleSubsetResultTransformer {

    private static final long serialVersionUID = -8047276133980128266L;

    private static final int TUPE_INDEX = 0;
    private static final int ALISES_INDEX = 1;
    private static final int FIELDNAME_INDEX = 2;

    private static final PropertyAccessor accessor = PropertyAccessorFactory
        .getPropertyAccessor("property");

    private final Class<?> resultClass;

    private Object[] entityTuples;
    private String[] entityAliases;

    private Map<String, Class<?>> fieldToClass = new HashMap<String, Class<?>>();
    private Map<String, List<?>> subEntities = new HashMap<String, List<?>>();
    private List<String> nestedAliases = new ArrayList<String>();
    private Map<String, Class<?>> listFields = new HashMap<String, Class<?>>();

    public boolean isTransformedValueATupleElement(String[] aliases,
        int tupleLength) {
    return false;
    }

    public AliasToBeanNestedResultTransformer(Class<?> resultClass) {

    this.resultClass = resultClass;
    }

    public Object transformTuple(Object[] tuple, String[] aliases) {

    handleSubEntities(tuple, aliases);
    cleanParams(tuple, aliases);
    ResultTransformer rootTransformer = new AliasToBeanResultTransformer(
        resultClass);
    Object root = rootTransformer.transformTuple(entityTuples,
        entityAliases);

    loadSubEntities(root);

    cleanMaps();
    return root;
    }

    private void handleSubEntities(Object[] tuple, String[] aliases)
        throws HibernateException {
    String fieldName = "";
    String aliasName = "";
    try {
        for (int i = 0; i < aliases.length; i++) {
        String alias = aliases[i];
        if (alias.contains(".")) {

            String[] sp = alias.split("\\.");
            StringBuilder aliasBuilder = new StringBuilder();
            for (int j = 0; j < sp.length; j++) {
            if (j == 0) {
                fieldName = sp[j];
            } else {
                aliasBuilder.append(sp[j]);
                aliasBuilder.append(".");
            }
            }
            aliasName = aliasBuilder.substring(0,
                aliasBuilder.length() - 1);

            nestedAliases.add(alias);
            manageEntities(fieldName, aliasName, tuple[i]);
        }
        }
    } catch (NoSuchFieldException e) {
        throw new HibernateException("Could not instantiate resultclass: "
            + resultClass.getName() + " for field name: " + fieldName
            + " and alias name:" + aliasName);
    }
    }

    private Class<?> findClass(String fieldName) throws NoSuchFieldException,
        SecurityException {
    if (fieldToClass.containsKey(fieldName)) {
        return fieldToClass.get(fieldName);
    } else {
        Class<?> subclass = resultClass.getDeclaredField(fieldName)
            .getType();

        if (subclass.equals(List.class) || subclass.equals(Set.class)) {
        if (subclass.equals(List.class)) {
            listFields.put(fieldName, LinkedList.class);
        } else {
            listFields.put(fieldName, HashSet.class);
        }
        Field field = resultClass.getDeclaredField(fieldName);
        ParameterizedType genericType = (ParameterizedType) field
            .getGenericType();
        subclass = (Class<?>) genericType.getActualTypeArguments()[0];

        }
        fieldToClass.put(fieldName, subclass);
        return subclass;
    }
    }

    @SuppressWarnings("unchecked")
    private void manageEntities(String fieldName, String aliasName,
        Object tupleValue) throws NoSuchFieldException, SecurityException {
    Class<?> subclass = findClass(fieldName);
    if (!subEntities.containsKey(fieldName)) {
        List<Object> list = new ArrayList<Object>();
        list.add(new ArrayList<Object>());
        list.add(new ArrayList<String>());
        list.add(FIELDNAME_INDEX, subclass);
        subEntities.put(fieldName, list);
    }
    ((List<Object>) subEntities.get(fieldName).get(TUPE_INDEX))
        .add(tupleValue);
    ((List<String>) subEntities.get(fieldName).get(ALISES_INDEX))
        .add(aliasName);
    }

    private void cleanParams(Object[] tuple, String[] aliases) {
    entityTuples = new Object[aliases.length - nestedAliases.size()];
    entityAliases = new String[aliases.length - nestedAliases.size()];

    for (int j = 0, i = 0; j < aliases.length; j++) {
        if (!nestedAliases.contains(aliases[j])) {
        entityTuples[i] = tuple[j];
        entityAliases[i] = aliases[j];
        ++i;
        }
    }
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    private void loadSubEntities(Object root) throws HibernateException {
    try {
        for (String fieldName : subEntities.keySet()) {
        Class<?> subclass = (Class<?>) subEntities.get(fieldName).get(
            FIELDNAME_INDEX);

        ResultTransformer subclassTransformer = new AliasToBeanNestedResultTransformer(
            subclass);

        Object subObject = subclassTransformer.transformTuple(
            ((List<Object>) subEntities.get(fieldName).get(0))
                .toArray(),
            ((List<Object>) subEntities.get(fieldName).get(1))
                .toArray(new String[0]));

        Setter setter = accessor.getSetter(resultClass, fieldName);
        if (listFields.containsKey(fieldName)) {
            Class<?> collectionClass = listFields.get(fieldName);
            Collection subObjectList = (Collection) collectionClass
                .newInstance();
            subObjectList.add(subObject);
            setter.set(root, subObjectList, null);
        } else {
            setter.set(root, subObject, null);
        }
        }
    } catch (Exception e) {
        throw new HibernateException(e);
    }
    }

    private void cleanMaps() {
    fieldToClass = new HashMap<String, Class<?>>();
    subEntities = new HashMap<String, List<?>>();
    nestedAliases = new ArrayList<String>();
    listFields = new HashMap<String, Class<?>>();
    }

}

public List<? extends Entity<?>> cleanList(
        List<? extends Entity<?>> resultList) throws DataException {
    List<Entity<?>> entities = new ArrayList<Entity<?>>();
    Entity<?> current = null;
    try {
        for (Entity<?> entity : resultList) {
        if (entity.getId() == null) {
            continue;
        }
        if (current == null) {
            current = entity;
            continue;
        }
        if (current.getId().equals(entity.getId())) {
            append(current, entity);
        } else {
            entities.add(current);
            current = entity;
        }
        }
        if (current != null) {
        entities.add(current);
        }
        cleanSubList(entities);
        return entities;
    } catch (Exception e) {
        throw new DataException(e);
    }
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public Set<? extends Entity<?>> cleanList(
        Set<? extends Entity<?>> resultList) throws DataException {
        List listToClean = new LinkedList();
        listToClean.addAll(resultList);
        listToClean = cleanList(listToClean);
        resultList.clear();
        resultList.addAll(listToClean);
        return resultList;
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    private void append(Entity<?> current, Entity<?> next)
        throws IllegalArgumentException, IllegalAccessException {
    Field[] fields = current.getClass().getDeclaredFields();
    for (Field field : fields) {
        if (field.getType().equals(List.class)) {
        field.setAccessible(true);
        List valueNext = (List) field.get(next);
        List valueCurrent = (List) field.get(current);
        if (valueNext != null) {
            if (valueCurrent != null) {
            valueCurrent.addAll(valueNext);
            field.set(current, valueCurrent);
            } else {
            field.set(current, valueNext);
            }
        }
        } else if (field.getType().equals(Set.class)) {
        field.setAccessible(true);
        Set valueNext = (Set) field.get(next);
        Set valueCurrent = (Set) field.get(current);
        if (valueNext != null) {
            if (valueCurrent != null) {
            valueCurrent.addAll(valueNext);
            field.set(current, valueCurrent);
            } else {
            field.set(current, valueNext);
            }
        }
        }
    }

    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    private void cleanSubList(List<? extends Entity<?>> listToClean)
        throws IllegalArgumentException, IllegalAccessException,
        DataException {
            for (Entity<?> entity : listToClean) {
                Field[] fields = entity.getClass().getDeclaredFields();
                for (Field field : fields) {
                    if (field.getType().equals(List.class)) {
                        field.setAccessible(true);
                        List valueToClean = (List) field.get(entity);
                        // Throw a thread
                        if (valueToClean != null) {
                            valueToClean = cleanList(valueToClean);
                            field.set(entity, valueToClean);
                        }
                        } else if (field.getType().equals(Set.class)) {
                            field.setAccessible(true);
                            Set valueToClean = (Set) field.get(entity);
                            // Throw a thread
                            if (valueToClean != null) {
                                valueToClean = cleanList(valueToClean);
                                field.set(entity, valueToClean);
                            }
                        }

                }
            }
    }

package com.alutiiq.develop.promanagesys.common.entity;

import java.io.Serializable;

/**
 * Entity for Hibernate comunications
 * 
 * @author Miguel Resendiz
 * 
 * @param <I>
 *            Primary key type
 */
public interface Entity<I extends Serializable> extends Serializable {

    /**
     * Enable poissibility to write generic queries using primary key
     * 
     * @return primary key value for entity
     */
    I getId();

    void setId(I id);

    void setId(String id);

}

criteria.setResultTransformer(new AliasToBeanNestedResultTransformer(
    entityClass));
List<Project> projects = criteria.list();
projects = (List<Project>) cleanList(projects);