Java 当yml文件包含映射引用其他对象的对象时，Fixtures loadModel无法正确加载

init-datasample.yml

Book(a): &a
  title: Play in Action
  price: 30.00

Book(b): &b
  title: Alice in Wonderland
  price: 12.00

Person(b):
  name: Bob Joe
  ratings:
    ? *a: 8
    ? *b: 8

Person的Java类定义

@Entity
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public class Person extends Model
{
    public String name;

    // choice and importance score
    @ElementCollection(targetClass=Integer.class)
        @MapKeyClass(Book.class)
    public Map<Book, Integer> ratings;
}

@实体
@缓存（用法=缓存并发策略。非严格读写）
公共类人扩展模型
{
公共字符串名称；
//选择和重要性得分
@ElementCollection（targetClass=Integer.class）
@MapKeyClass（Book.class）
公众地图评级；
}

Fixture.loadModels（“init datasample.yml”）不加载上面定义的初始额定值。我试着不放&a，&b，也没用。有人能帮忙吗

---

谢谢。

好的，工作安排好了。想在这里分享一下。如果有人可以看一看并认为值得提交git源代码，请帮助这样做

问题是嵌入式系统目前不受支持。因此Fixtures类中的resolveDependencies不会解析定义的映射中的引用

我的工作是扩展Fixtures类，并隐藏loadModels方法。及 在

Fixtures.loadmodels(String name, Map<String, Object> idCache) {

... ...
                            if (f.getType().isAssignableFrom(Map.class)) {

/* new below */
                                    ElementCollection ec = f.getAnnotation(ElementCollection.class);
                                    MapKeyClass mkc = f.getAnnotation(MapKeyClass.class);
                                    if (ec != null && mkc != null) {
                                        Map mapper = (Map) objects.get(key).get(f.getName());
                                        if (mapper == null) continue;
                                        Class targetClass = ec.targetClass();
                                        Class mapKeyClass = mkc.value();
                                        Map<Object, Object> fieldValue = new HashMap();
                                        for (Object k : mapper.keySet()) {
                                            Object mapKey = retrieveObject(mapKeyClass, k, idCache);
                                            Object targetValue = retrieveObject(targetClass, mapper.get(k), idCache);
                                            fieldValue.put(mapKey, targetValue);
                                        }
                                        f.set(model, fieldValue);
                                    } else {
                                        f.set(model, objects.get(key).get(f.getName()));
                                    }
                                }

... ...

}

/* new method below */
private static Object retrieveObject(Class targetClass, Object alias, Map<String, Object> idCache)
    {
        if (targetClass.isAssignableFrom(alias.getClass())) {
            return alias;
        }

        Object targetValue = idCache.get(targetClass.getCanonicalName() + "-"+ alias);

        if (targetValue != null) {
            targetValue = Model.Manager.factoryFor(targetClass).findById(targetValue);
        }else {
            try {
                targetValue = targetClass.getConstructor(String.class).newInstance(alias.toString());
            } catch(Exception ex) {
                ex.printStackTrace();
                return null;
            }
        }

        return targetValue;
    }

Fixtures.loadmodels（字符串名称，映射idCache）{
... ...
if（f.getType（）.isAssignableFrom（Map.class））{
/*新下*/
ElementCollection ec=f.getAnnotation（ElementCollection.class）；
MapKeyClass mkc=f.getAnnotation（MapKeyClass.class）；
if（ec！=null&&mkc！=null）{
MapMapper=（Map）objects.get（key.get）（f.getName（））；
如果（mapper==null）继续；
Class targetClass=ec.targetClass（）；
类mapKeyClass=mkc.value（）；
Map fieldValue=新的HashMap（）；
对于（对象k:mapper.keySet（））{
Object mapKey=retrieveObject（mapKeyClass，k，idCache）；
Object targetValue=retrieveObject（targetClass，mapper.get（k），idCache）；
fieldValue.put（映射键，targetValue）；
}
f、 设置（模型、字段值）；
}否则{
f、 set（model，objects.get（key）.get（f.getName（））；
}
}
... ...
}
/*新方法如下*/
私有静态对象检索对象（类targetClass、对象别名、映射idCache）
{
if（targetClass.isAssignableFrom（alias.getClass（）））{
返回别名；
}
Object targetValue=idCache.get（targetClass.getCanonicalName（）+“-”+别名）；
if（targetValue！=null）{
targetValue=Model.Manager.factoryFor（targetClass）.findById（targetValue）；
}否则{
试一试{
targetValue=targetClass.getConstructor（String.class）.newInstance（别名.toString（））；
}捕获（例外情况除外）{
例如printStackTrace（）；
返回null；
}
}
返回目标值；
}

如果有人想引用一个已经存在的实体（例如，该实体是在早期的@OnApplicationStart中加载的），您可以通过ID引用它们：

固定装置：

User(user01):
  email: user01@g.com
  userGroup.id: ${models.UserGroup.getGroupForYml(models.UserGroup.GROUP_SALES)}

用户组模型：

@Entity
public class UserGroup extends Model {

    public static final String GROUP_ADMIN = "admin";
    public static final String GROUP_CUSTOMER = "customer";
    public static final String GROUP_SALES = "sales";

    @OneToMany(mappedBy = "userGroup")
    public List<User> userList;

    @Column(name="groupId")
    public String group;

    /**
     * Used in the yml fixtures
     * @param group - the group id
     */
    public static Long getGroupForYml(String group) {
        UserGroup ug = UserGroup.find("byGroup", group).first();
        return ug.id;
    }
}

@Entity
@Table(name = "users")
public class User extends BaseModel {
    publis String email;

    @ManyToOne
    public UserGroup userGroup;
}