“我怎么能？”；巢；具有OpenRDF和分配资源IRIs的对象？

我尝试将Java对象映射到RDF三元组，然后再映射回来。目前，我正在研究它如何处理对象图

我有两个对象，内部和外部。外部有对内部的引用。当我持久化一个外部实例时，内部实例似乎总是表示为b节点，即使我以前使用分配的IRI持久化了内部实例

我必须做些什么才能成功地分配内部实例的IRI，而不是创建b节点

额外信用问题：如何使资源IRI成为Java对象上的一个属性，而不是使其与它标识的对象并行但断开连接

---

代码：

内部：

包alibabaeval.domain；
导入org.openrdf.annotations.Iri；
@Iri（”http://example.com/innerType")
公共阶级内部{
@Iri（”http://example.com/innerType/data")
私有字符串数据；
公共内部（字符串数据）{
这个数据=数据；
}
//如果缺少此选项，检索时将抛出一个没有帮助的ClassCastException
公共内部{
}
公共字符串getData（）{
返回数据；
}
公共void setData（字符串数据）{
这个数据=数据；
}
}

外部：

包alibabaeval.domain；
导入org.openrdf.annotations.Iri；
@Iri（”http://example.com/outerType")
公共舱外{
@Iri（”http://example.com/outerType/data")
私有字符串外部数据；
@Iri（”http://example.com/outerType/innerObject")
私有内部对象；
公共外部（字符串外部数据）{
this.outerData=outerData；
}
//如果缺少此选项，检索时将抛出一个没有帮助的ClassCastException
公共图书馆{
}
公共字符串getOuterData（）{
返回外部数据；
}
public void setOuterData（字符串outerData）{
this.outerData=outerData；
}
公共内部getInnerObject（）{
返回内部对象；
}
公共void setInnerObject（内部对象）{
this.innerObject=innerObject；
}
}

测试程序：

包装alibabaeval；
导入org.junit.Test；
导入org.openrdf.model.URI；
导入org.openrdf.model.ValueFactory；
导入org.openrdf.query.QueryLanguage；
导入org.openrdf.repository.repository；
导入org.openrdf.repository.object.ObjectConnection；
导入org.openrdf.repository.object.ObjectRepository；
导入org.openrdf.repository.object.config.ObjectRepositoryFactory；
导入org.openrdf.repository.sail.SailRepository；
导入org.openrdf.rio.RDFFormat；
导入org.openrdf.rio.RDFWriter；
导入org.openrdf.rio.rio；
导入org.openrdf.sail.memory.MemoryStore；
导入alibabaeval.domain.Inner；
导入alibabaeval.domain.Outer；
公共类AlibabaEval{
公共静态void main（字符串[]args）引发异常{
Repository store=new-SailRepository（new-MemoryStore（））；
store.initialize（）；
//包装在对象存储库中
ObjectRepositoryFactory=新的ObjectRepositoryFactory（）；
ObjectRepository repository=factory.createRepository（存储）；
//将内容添加到存储库
ObjectConnection con=repository.getConnection（）；
ValueFactory vf=con.getValueFactory（）；
内部=新内部（“某些内部数据”）；
URI innerId=vf.createURI（“http://example.com/inners/inner1");
con.addObject（innerId，inner）；
URI outerId=vf.createURI（“http://example.com/outers/outer1");
外部=新的外部（“某些外部数据”）；
外部.setInnerObject（内部）；
con.addObject（outerId，outer）；
//看看创建的三元组
System.out.println（“\n\n\n生成的三元组：”；
RDFWriter writer=Rio.createWriter（RDFFormat.NTRIPLES，System.out）；
con.prepareGraphQuery（QueryLanguage.SPARQL，“构造{s？p？o}，其中{s？p？o}”）.evaluate（编写器）；
//关闭一切
con.close（）；
repository.shutDown（）；
}
}

---

输出：

我只创建了两个对象实例，并将它们分别持久化。阿里巴巴似乎忽略了这一点，并创建了内部实例的第二个副本作为b节点，用于外部实例的引用

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/C:/Users/me/.gradle/caches/modules-2/files-2.1/org.slf4j/slf4j-jdk14/1.7.7/25d160723ea37a6cb84e87cd70773ff02997e857/slf4j-jdk14-1.7.7.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/C:/Users/me/.gradle/caches/modules-2/files-2.1/org.slf4j/slf4j-log4j12/1.7.12/485f77901840cf4e8bf852f2abb9b723eb8ec29/slf4j-log4j12-1.7.12.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.JDK14LoggerFactory]
Jan 08, 2016 6:00:21 PM org.openrdf.repository.object.managers.helpers.Scanner scan
INFO: Scanning C:\workspace\AlibabaTest\bin for concepts
Jan 08, 2016 6:00:22 PM org.openrdf.repository.object.ObjectRepository compileSchema
INFO: Compiling schema
Jan 08, 2016 6:00:22 PM org.openrdf.repository.object.composition.ClassResolver setBaseClassRoles
WARNING: Concept will only be mergable: class alibabaeval.domain.Inner
Jan 08, 2016 6:00:22 PM org.openrdf.repository.object.composition.ClassResolver setBaseClassRoles
WARNING: Concept will only be mergable: class alibabaeval.domain.Outer



Generated triples:
<http://example.com/inners/inner1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.com/innerType> .
<http://example.com/inners/inner1> <http://example.com/innerType/data> "some inner data" .
<http://example.com/outers/outer1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.com/outerType> .
_:node1a8hqu4aqx1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.com/innerType> .
_:node1a8hqu4aqx1 <http://example.com/innerType/data> "some inner data" .
<http://example.com/outers/outer1> <http://example.com/outerType/innerObject> _:node1a8hqu4aqx1 .
<http://example.com/outers/outer1> <http://example.com/outerType/data> "some outer data" .

SLF4J:类路径包含多个SLF4J绑定。
SLF4J：在[jar:file:/C:/Users/me/.gradle/caches/modules-2/files-2.1/org.SLF4J/SLF4J-jdk14/1.7.7/25d160723ea37a6cb84e87cd70773ff02997e857/SLF4J-jdk14-1.7.7.jar！/org/SLF4J/impl/StaticLoggerBinder.class]中找到绑定
SLF4J:在[jar:file:/C:/Users/me/.gradle/caches/modules-2/files-2.1/org.SLF4J/SLF4J-log4j12/1.7.12/485f77901840cf4e8bf852f2abb9b723eb8ec29/SLF4J-log4j12.jar！/org/SLF4J/impl/StaticLoggerBinder.class]中找到绑定
SLF4J：参见http://www.slf4j.org/codes.html#multiple_bindings 我需要一个解释。
SLF4J:实际绑定的类型为[org.SLF4J.impl.JDK14LoggerFactory]
2016年1月8日下午6:00:21 org.openrdf.repository.object.managers.helpers.Scanner扫描
信息：扫描C:\workspace\AlibabaTest\bin中的概念
2016年1月8日下午6:00:22 org.openrdf.repository.object.ObjectRepository compileSchema
信息：编译模式
2016年1月8日下午6:00:22 org.openrdf.repository.object.composition.ClassResolver setBaseClassRoles
警告：概念将仅为mergable:class alibabaeval.domain.Inner
2016年1月8日下午6:00:22 org.openrdf.repository.object.composition.ClassResolver setBaseClassRoles
警告：概念将仅为mergable:类alibabaeval.domain.Outer
生成的三元组：
.
“一些内部数据”。
.
_：node1a8hqu4aqx1。
_：node1a8hqu4aqx1“一些内部数据”。
_：node1a8hqu4aqx1。
“一些外部数据”。

问题在于

内部

的id会添加到存储中，但实际的

内部

POJO不会得到更新。要解决这个问题，只需添加一行

inner=con.getObject（inner.class，innerId
package alibabaeval.domain;

import org.openrdf.annotations.Iri;
import org.openrdf.model.Resource;
import org.openrdf.model.impl.URIImpl;
import org.openrdf.repository.object.ObjectConnection;
import org.openrdf.repository.object.RDFObject;

@Iri("http://example.com/#innerType")
public class Inner implements RDFObject {

    @Iri("http://example.com/innerType/data")
    private String data;

    private Resource detachedId;

    public Inner() {

    }

    @Override
    public ObjectConnection getObjectConnection() {
        // don't really care about this one right now
        return null;
    }

    @Override
    public Resource getResource() {
        // only run on detached object, is hidden by a proxy on managed objects
        return detachedId;
    }

    public Resource getDetachedId() {
        return detachedId;
    }

    public void setDetachedId(Resource detachedId) {
        this.detachedId = detachedId;
    }

    public void setDetachedId(String detachedId) {
        this.detachedId = new URIImpl(detachedId);
    }

    public void setResource(Resource resource) {
        detachedId = resource;
    }

    public Inner(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

    Inner inner = new Inner("some inner data");
    inner.setDetachedId("http://example.com/inners/inner1");

    URI outerId = vf.createURI("http://example.com/outers/outer1");
    Outer outer = new Outer("some outer data");
    outer.setInnerObject(inner);
    con.addObject(outerId, outer);

<http://example.com/inners/inner1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.com/#innerType> .
<http://example.com/inners/inner1> <http://example.com/innerType/data> "some inner data" .
<http://example.com/outers/outer1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.com/#outerType> .
<http://example.com/outers/outer1> <http://example.com/outerType/data> "some outer data" .
<http://example.com/outers/outer1> <http://example.com/outerType/innerObject> <http://example.com/inners/inner1> .