【Hibernate】hibernate原生sql利用transformers返回多表自定义类型对象

@Entity

@Table

public class Person{
    private String id;
    private String name;
    private String age;
    @OneToOne  
    private Book book;
    
    //...
}

@Entity

@Table
public class Book {
    private String id;
    private String bookName;
    @OneToOne  
    private Person person;
    @OneToMany  
    private List<Author> authors;
    //...
}
@Entity

@Table
public class Author{
    private String id;
    private String authorName;
    @ManyToOne 
    private Book book;

    //...
}

String sql = "select p.id id ,p.name name ,b.bookName bookName from person p left join book b on p.bookId=b.id";
SQLQuery q = ....;
//q.addScalar("id",StringType.INSTANCE);
//q.addScalar("name",StringType.INSTANCE);
//q.addScalar("bookName",StringType.INSTANCE);
q.setResultTransformer(Transformers.aliasToBean(Dto.class));

public Object transformTuple(Object[] tuple, String[] aliases) {
        Object result;
        try {
            if ( ! isInitialized ) {
                initialize( aliases ); //exception
            }
            else {
                check( aliases );
            }    
            result = resultClass.newInstance();
            for ( int i = 0; i < aliases.length; i++ ) {
                if ( setters[i] != null ) {
                    setters[i].set( result, tuple[i], null );
                }
            }
        }
        catch ( InstantiationException e ) {
            throw new HibernateException( "Could not instantiate resultclass: " + resultClass.getName() );
        }
        catch ( IllegalAccessException e ) {
            throw new HibernateException( "Could not instantiate resultclass: " + resultClass.getName() );
        }
        return result;
    }

private void initialize(String[] aliases) {
        PropertyAccessor propertyAccessor = new ChainedPropertyAccessor(
                new PropertyAccessor[] {
                        PropertyAccessorFactory.getPropertyAccessor( resultClass, null ),
                        PropertyAccessorFactory.getPropertyAccessor( "field" )
                }
        );
        this.aliases = new String[ aliases.length ];
        setters = new Setter[ aliases.length ];
        for ( int i = 0; i < aliases.length; i++ ) {
            String alias = aliases[ i ];
            if ( alias != null ) {
                this.aliases[ i ] = alias;
                setters[ i ] = propertyAccessor.getSetter( resultClass, alias ); //exception: alias都是大写，再深入看propertyAccessor.getSetter就知道是找不到setter
            }
        }
        isInitialized = true;
    }

// org.hibernate.property.BasicPropertyAccessor 
private static Method setterMethod(Class theClass, String propertyName) { //propertyName就是alias，大写
        BasicPropertyAccessor.BasicGetter getter = getGetterOrNull(theClass, propertyName);
        Class returnType = getter == null?null:getter.getReturnType();
        Method[] methods = theClass.getDeclaredMethods();
        Method potentialSetter = null;
        Method[] arr$ = methods;
        int len$ = methods.length;

        for(int i$ = 0; i$ < len$; ++i$) {
            Method method = arr$[i$];
            String methodName = method.getName();
            if(method.getParameterTypes().length == 1 && methodName.startsWith("set")) {
                String testStdMethod = Introspector.decapitalize(methodName.substring(3));
                String testOldMethod = methodName.substring(3); // 都是dto的setter值，Id、Name、BookName
                if(testStdMethod.equals(propertyName) || testOldMethod.equals(propertyName)) { // 所以，此处if为false；method=null
                    potentialSetter = method;
                    if(returnType == null || method.getParameterTypes()[0].equals(returnType)) {
                        return method;
                    }
                }
            }
        }

        return potentialSetter;
    }

// 这是fluent-hibernate的源码 ；com.github.fluent.hibernate.internal.util.reflection.ReflectionUtils 
    /**
     * Try to find a class getter method by a property name. Don‘t check parent classes or
     * interfaces.
     *
     * @param classToCheck
     *            a class in which find a getter
     * @param propertyName
     *            a property name
     * @return the getter method or null, if such getter is not exist
     */
    public static Method getClassGetter(Class<?> classToCheck, String propertyName) {
        PropertyDescriptor[] descriptors = getPropertyDescriptors(classToCheck);

        for (PropertyDescriptor descriptor : descriptors) {
            if (isGetter(descriptor, propertyName)) {
                return descriptor.getReadMethod();
            }
        }

        return null;
    }

    private static boolean isGetter(PropertyDescriptor descriptor, String propertyName) {
        Method method = descriptor.getReadMethod();
        return method != null && method.getParameterTypes().length == 0
                && descriptor.getName().equalsIgnoreCase(propertyName); //忽略大小写找到setter
    }

 private static PropertyDescriptor[] getPropertyDescriptors(Class<?> beanClass) {
        try {
            return Introspector.getBeanInfo(beanClass).getPropertyDescriptors();
        } catch (IntrospectionException ex) {
            throw InternalUtils.toRuntimeException(ex);
        }
}