DOASample

DOIPTestsuite

doa-sdk-bundle

bdoa-core

bdoa-client

BDOA

BDOA为符合DOA标准的一套完整实现的开源项目,支持标识注册、解析、寻址、查询等功能,主要包括标识系统、注册表和仓库三大子系统,并支持IRP和DOIP两大协议。本文档为BDOA的介绍文档,介绍了BDOA涉及的数字对象体系结构的相关概念以及架构设计等内容,相关代码会在2021年9月份进行开源。

数字对象体系结构(DOA)

数字对象体系结构(Digital Object Architecture, DOA)是现有Internet体系结构的一个逻辑扩展,它支持不同系统之间的数据互操作需求,而不仅仅是将数字形式的信息从Internet的一个位置传送到另一个位置。数字对象体系结构中的基本元素是数字对象(Digital Object),是对任意信息系统数据资源的统一抽象。数字对象分为四个部分:标识、元数据、状态数据以及实体。其中,标识永久且唯一的指向一个数字对象,是数字对象永久不变的属性;元数据是数字对象的描述信息,用于数字对象的检索和发现;状态数据包含数字对象当前位置、访问入口、访问方式等信息,用于数字对象的定位和访问;实体则是数字对象所包含的实际内容,可以是任何比特序列或一系列比特序列的集合。标识和状态数据的分离也使得数字对象的标识不在与数字对象的访问入口紧耦合,使得无论是否在互联网环境中,数字对象都可以被共享、访问,进而实现普适环境下的信息系统互操作。 DO是对互联网资源的抽象,DO代表互联网中有意义或者是有价值的资源。DO的表现形式可以是一个比特序列,或者是多个比特序列的集合;也可以是一个对外提供接口的程序。就像互联网中每一个Host都有一个IP地址作为标识一样,在DOA中每个DO同样有一个标识,用于对这个DO进行唯一的识别,这个标识叫做DOID。DOA中有两个基本协议:标识/解析协议IRP(Identifier/Resolution Protocol)和数字对象接口协议DOIP(Digital Object Interface Protocol)。 DOA中有三个基本的组成部分,分别是标识/解析系统(Identifier/Resolution System)负责DO的标识和解析、仓库系统(Repository System)负责DO的存储和访问、以及注册表系统负责DO元信息的注册和DO的搜索(Registry System)。

标识注册和解析(IRP)

IRP协议规定了DO标识的创建、修改、删除和解析方式,同样指定了标识的语法以及分配方案。IRP协议之于DOA就如同IP协议、路由协议之于Internet。在DOA中,通过IRP协议解析一个DO的标识可以查询到该标识对应的DO的状态信息,其中包括DO的存储位置、所有者等和DO的访问直接相关的信息。

标识/解析系统是DOA体系中三个基本构件之一,其主要功能如下:

• 制定并维护一套标识体系,为每个序列化为DO的资源分配一个全网唯一的标识。无论这个资源的位置在哪,以何种形式、何种技术被访问。
• 提供高效、迅速的解析服务,根据DO的标识,可以迅速的查询到DO的状态,获取DO的存储位置,访问方式,所有者,时间戳等和DO的访问直接相关的状态信息。
• 提供DO状态信息的管理服务。

标识注册与解析系统包括LRS和GRS两种,即局部标识注册与解析系统以及全局标识注册与解析系统。

局部标识注册与解析系统(LRS)

主要有如下功能:

1. 标识注册:为数联网中每个资源、参与者、基础设施赋予唯一、持久标识

• 资源:以数字对象形式存在的数据、算法
• 参与者:参与数联网的组织、个人,关联一对公私钥进行身份识别
• 基础设施:标识解析节点、注册表节点、数字对象仓库节点
• 标识规范:扩展Handle Protocol标准,/.
• NA = . ...... (代表LRS标识)
• NASegment = 任意Unicode编码,除了:‘.’ ‘/’‘@’
• Type = dou(参与者),doip(注册表、仓库),do(数字对象)
• LocalName = 任意Unicode编码

2. 标识解析:基于IRP提供标识解析服务,根据标识查询到标识对应的状态信息

• 根据标识返回本地存储的目标状态信息,或者
• 根据标识前缀,查询GRS,返回对应IRS的状态信息
• 状态信息必填内容:
• 参与者:JWK格式公钥
• 数字对象:所有者标识,所在仓库标识

全局标识注册与解析系统(GRS)

一种特殊的IRS,访问地址全局可知且不变。主要有如下功能:

• 标识注册:为LRS分配标识,公私钥对
• 标识规范:仅包含前缀
• 标识解析:维护所有IRS状态信息,并提供前缀解析服务
• 状态信息:所有者标识(固定为/dou.ADMIN),IRP服务地址,IRP协议版本

注册表和仓库(Registry and Repository)

在数字对象体系结构中,Registry负责对数字对象元信息的管理。Registry和数字对象的实际访问服务提供者Repository逻辑上一般是一对一或一对多的关系,即:在物理上将Repository和Registry部署在一起,同时对外提供数字对象的访问和搜索功能;或者将Registry作为独立构件部署,此时一个Registry一般管理多个Repository中数字对象的元信息,Registry通过标准的数字对象接口协议对外提供元数据的管理服务以及数字对象搜索服务。在DOA中,有一种特殊类型的DOMeta DO。Meta DO中包含的是其他DO的描述信息、标识的键值对,并以固定的格式序列化。通过检索Meta DO中的数据,可以根据关键字搜索到目标DO的标识。注册表系统是一种特殊的仓库系统,仅负责Meta DO的存储、管理。注册表系统同样以DOIP协议的标准对外提供服务,创建、管理Meta DO,并支持DOIP协议中的Search操作。

仓库系统对外提供DO的访问管理及持久化服务。仓库系统需要对外暴露访问接口,接收本文所定义的DOIP请求消息,根据DO的标识和操作标识,处理本地存储的DO,并根据处理结果和协议规范,返回DOIP响应消息。仓库系统提供的DOIP服务也可以被抽象成DO,并在标识/解析系统中注册。根据仓库的标识,可以解析到仓库的访问地址,提供服务的方式等相关信息。DOIP协议对外屏蔽了仓库系统的实现方式,仓库系统可以以任何形式进行实现,只需要对外暴露可以接受DOIP请求消息的接口即可。DOIP服务接口也可以建立在多种传输协议之上,如:http,tcp,udp等。具体的接口形式在标识解析系统中描述清楚即可。关于DOIP 的详细描述,将在下文阐述。

数字对象接口协议(DOIP)

数字对象接口协议(Digital Object Interface Protocol, DOIP)规定了对数字对象的操作语义,以及互操作消息的传输语法。DOIP的操作语义在不同系统中的具体实现可以不同,但对外暴露的接口都需要满足DOIP协议的统一标准。由此数字对象应用系统可以以统一的形式访问不同系统提供的数字对象,而操作的具体细节对应用系统完全透明。

BDOA中关键数据结构定义

数字对象实体的数据结构设计 数字对象的状态信息数据结构设计 数字对象的元数据数据结构设计

BDOA部署和访问流程

BDOA部署

数字对象创建流程 数字对象访问流程 数字对象修改、删除流程 数字对象索引、搜索流程

BDOA项目使用说明

介绍

数字对象体系结构DOA(Digital Object Architecture)是互联网之父,图灵奖得主Robert E. Kahn提出的一种互联网的逻辑扩展, 以数字对象的形式抽象互联网资源,使得系统之间可以直接管理信息,而非仅将数据以比特流的形式从一个节点传递到另一个节点。 以数据为中心的方式实现信息系统之间的互操作。 关于DOA的详细介绍,请参考代码架构

项目包含6个模块

1. doip DOIP协议2.1版本的实现,有关DOIP2.1协议,参考IRP协议文本
2. repository 可运行的数字对象仓库,包含基于DOIP SDK的Repository,以及基于Web的Repository管理服务
3. registry 可运行的数字对象注册表,包含基于DOIP SDK的Registry,以及基于Web的Registry管理服务
4. irs 可运行的标识解析系统,包含基于irp SDK实现的全局标识解析系统GRS(Global Resolution System), 本地标识解析系统LRS(Local Resolution System),以及基于Web的LRS管理服务
5. client DOA客户端,基于IRP SDK和DOIP SDK实现,提供和3 4 5三个构件交互的接口,创建、注册、修改、搜索、删除数字对象。

运行教程

1. 向全局标识解析系统GRS(Global Resolution System)申请前缀,得到GRS分配的前缀和JWK密钥。(可选)

2. 启动irs/src/mian/java/org.bdware.irs/IrsBoot,会启动IRS和GRS服务,以默认账号登陆可以进入GRS的前缀分配界面,分配前缀后,在irsCofig.json文件中可以修改irs的启动信息。可通过port参数修改监听端口,XXX配置前缀、密钥(默认前缀为local)

3. 运行client模块下org.bdware.utils.UserCreator,向IRS注册用户,会在当前目录生成"用户名.jwk"文件,其中为JWK密钥, 用于启动Repository、Registry或运行DOAClient。也可以通过其他JWK生成工具生成,保存为文件,例如public class UserCreator { static String userID = "local/dou.test"; static String IRSAddress = "http://127.0.0.1:10001"; public static void main(String[] args) throws Exception { // 创建JWK并向LRS注册用户标识 // 参考实际代码 } }

public class BDRepositoryHandler extends RegistryHandlerBase {
 static Logger logger = Logger.getLogger(BDRepositoryHandler.class);
 BDRepoStorage store; //数字对象的持久化存储,基于RocksDB
 DoIndexer indexer; //本地创建数字对象索引,基于Lucene
 HashMap<String,RemoteReg> remoteRegs; //记录该Repo接入的远程Registry,支持基于Registry的动态组网
 static final String REMOTE_REG = "REMOTEREG";
 static final String DO_OWNER = "doOwner";

 public BDRepositoryHandler(DoipServiceInfo info, BDRepoStorage store) throws RocksDBException {
 super(info);
 this.store = store;
 if(store.getRaw(REMOTE_REG.getBytes()) != null){
 remoteRegs = loadRegList();
 } else
 remoteRegs = new HashMap<>();
 }

 public BDRepositoryHandler(DoipServiceInfo info, BDRepoStorage store, DoIndexer indexer) throws RocksDBException {
 this(info,store);
 this.indexer = indexer;
 }

 @Override
 public DoipMessage handleHello(DoipMessage request) {
 //处理DoipMessageHeader.parameter中operation=0.DOIP/Op.Delete 的消息
 }

 @Override
 public DoipMessage handleListOps(DoipMessage request) {
 //处理DoipMessageHeader.parameter中operation=0.DOIP/Op.Delete 的消息
 }

 @Override
 public DoipMessage handleCreate(DoipMessage request) {
 //处理DoipMessageHeader.parameter中operation=0.DOIP/Op.Delete 的消息
 }

 @Override
 public DoipMessage handleUpdate(DoipMessage request) {
 //处理DoipMessageHeader.parameter中operation=0.DOIP/Op.Delete 的消息
 }

 @Override
 public DoipMessage handleDelete(DoipMessage request) {
 //处理DoipMessageHeader.parameter中operation=0.DOIP/Op.Delete 的消息
 }

 @Override
 public DoipMessage handleRetrieve(DoipMessage request) {
 //处理DoipMessageHeader.parameter中operation=0.DOIP/Op.Retrieve 的消息
 }

 @Override
 public DoipMessage handleSearch(DoipMessage request) {
 //处理DoipMessageHeader.parameter中operation=0.DOIP/Op.Search的消息
 }
}

public class BDRegistryHandler extends RegistryHandlerBase {
 /*
 其他部分详见具体代码,和BDRepository代码类似
 */

 //扩展操作Op.Join,允许其他Repository或Registry接入,提供分布式搜索功能
 //DoipMessageHeader.parameter中operation=Op.Join
 @Op(op = BasicOperations.Extension,name = "Op.Join")
 public DoipMessage handleJoin(DoipMessage request){
 if(request.header.parameters.attributes == null ||request.header.parameters.attributes.get("repoID")== null){
 logger.info("invalid join request: repoID not found");
 return replyStringWithStatus(request, "invalid join request: repoID not found.", DoipResponseCode.Invalid);
 }
 String repoID = request.header.parameters.attributes.get("repoID").getAsString();
 String repoUrl = request.header.parameters.attributes.get("repoUrl").getAsString();
 remoteRegs.put(repoID,repoUrl);
 saveRegFederation();
 return replyString(request,"success");
 }

 //扩展操作Op.Quit,允许其他Repository或Registry接入,提供分布式搜索功能
 //DoipMessageHeader.parameter中operation=Op.Quit
 @Op(op = BasicOperations.Extension,name = "Op.Quit")
 public DoipMessage handleQuit(DoipMessage request){
 if(request.header.parameters.attributes == null ||request.header.parameters.attributes.get("repoID")== null){
 logger.info("invalid join request: repoID not found");
 return replyStringWithStatus(request, "invalid join request: repoID not found.", DoipResponseCode.Invalid);
 }
 String repoID = request.header.parameters.attributes.get("repoID").getAsString();
 remoteRegs.remove(repoID);
 saveRegFederation();
 return replyString(request,"success");
 }
}

public interface RepositoryHandler {

 @Op(op = BasicOperations.Hello)
 DoipMessage handleHello(DoipMessage request);

 @Op(op = BasicOperations.ListOps)
 DoipMessage handleListOps(DoipMessage request);

 @Op(op = BasicOperations.Create)
 DoipMessage handleCreate(DoipMessage request);

 @Op(op = BasicOperations.Update)
 DoipMessage handleUpdate(DoipMessage request);

 @Op(op = BasicOperations.Delete)
 DoipMessage handleDelete(DoipMessage request);

 @Op(op = BasicOperations.Retrieve)
 DoipMessage handleRetrieve(DoipMessage request);

}

public class RequestHandlerImpl implements DoipRequestHandler {

 Map<String, Method> handlers;
 static Logger logger = Logger.getLogger(NettyServerHandler.class);
 protected RepositoryHandler doipHandler;

 public RequestHandlerImpl(RepositoryHandler doipHandler) {
 handlers = new HashMap<>();
 this.doipHandler = doipHandler;
 Class handlerClass = doipHandler.getClass();

 while(handlerClass != Object.class){
 putDoipHandlerMethod(handlerClass);
 Class[] interfaces = handlerClass.getInterfaces();
 for (Class clz : interfaces) {
 putDoipHandlerMethod(clz);
 }
 handlerClass = handlerClass.getSuperclass();
 }
 }

 private void putDoipHandlerMethod(Class handlerClass) {
 Method[] methods = handlerClass.getDeclaredMethods();
 for (Method m : methods) {
 Op a = m.getAnnotation(Op.class);
 if (a != null) {
 if (a.op() != BasicOperations.Extension) {
 putHandler(a.op().getName(), m);
 } else{
 putHandler(a.name(), m);
 }
 }
 }
 }

 private void putHandler(String name, Method m) {
 if (handlers.containsKey(name)) {
 return;
 }
 logger.debug("[Register operation] name: " + name);
 m.setAccessible(true);
 handlers.put(name, m);
 }

 @Override
 public DoipMessage onRequest(DoipMessage msg) {
 String str = msg.header.parameters.operation;
 logger.debug("[Call operation] name: " + str);
 if (str != null) {
 Method m;
 m = handlers.get(str);
 if (m == null) m = handlers.get(BasicOperations.Unknown.getName());
 if (m != null) {
 try {
 return (DoipMessage) m.invoke(doipHandler, msg);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }
 return null;
 }
}

public class BDRegistryHandler extends RegistryHandlerBase {
 /*
 .....
 */
 @Op(op = BasicOperations.Extension,name = "Op.Join")
 public DoipMessage handleJoin(DoipMessage request){
 if(request.header.parameters.attributes == null ||request.header.parameters.attributes.get("repoID")== null){
 logger.info("invalid join request: repoID not found");
 return replyStringWithStatus(request, "invalid join request: repoID not found.", DoipResponseCode.Invalid);
 }
 String repoID = request.header.parameters.attributes.get("repoID").getAsString();
 String repoUrl = request.header.parameters.attributes.get("repoUrl").getAsString();
 inRegs.put(repoID,repoUrl);
 saveRegFederation();
 return replyString(request,"success");
 }
 /*
 .....
 */
}

public class BlueToothDoipListener implements DoipListener {

 private static final String TAG = "BlueToothDoipListener";
 private static Context ctx;
 private BluetoothServerSocket mSSocket;
 private boolean isListenning = true;
 private PacketMessageCodec codec;
 DoipRequestHandler doipRequestHandler;
 DoipListenerInfo btListenerInfo;

 public BlueToothDoipListener(Context c, DoipListenerInfo listenerInfo) {
 codec = new PacketMessageCodecImpl();
 ctx = c;
 btListenerInfo = listenerInfo;
 }

 @Override
 public void start() {
 log("start listener");
 try {
 listen();
 }catch (Exception e){
 e.printStackTrace();
 }
 }

 @Override
 public void stop() {
 try {
 mSSocket.close();
 isListenning = false;
 } catch (IOException e) {
 e.printStackTrace();
 }
 }

 @Override
 public void setRequestHandler(DoipRequestHandler doipRequestHandler) {
 this.doipRequestHandler = doipRequestHandler;
 }


 /**
 * 监听客户端发起的连接
 */
 @SuppressLint("HardwareIds")
 private void listen() throws IOException {
 BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
 if(bluetoothAdapter == null) {
 //the device doesn't support bluetooth
 Log.e("BlueTooth","do not support Bluetooth");
 return;
 }
 if(!bluetoothAdapter.isEnabled()) {
 Log.e("Bluetooth","start blue tooth first");
 return;
 }

 mSSocket = bluetoothAdapter.listenUsingRfcommWithServiceRecord("DoipBTService", AndroidInitializer.DOIP_SERVICE_UUID);
 log("try to listen, local address: " + bluetoothAdapter.getAddress());
 log("try to listen, local name: " + bluetoothAdapter.getName());
 btListenerInfo.url = "bluetooth://" + bluetoothAdapter.getAddress();

 while(isListenning){
 waitForConnect();
 log("no input for 10s, connection released");
 }
 }

 private void waitForConnect() throws IOException {
 log("wait for connect");
 BluetoothSocket connectedSocket = mSSocket.accept();
 log("device connected, name: " +connectedSocket.getRemoteDevice().getName());
 log("device connected, address: " +connectedSocket.getRemoteDevice().getAddress());
 new BtSocketThread(connectedSocket).start();
 }

 private void handleAndResponseDoipMessage(DoipMessage msg, OutputStream output){
 if (msg.header.parameters == null || msg.header.parameters.operation == null || msg.header.parameters.response != null) {
 replyStringWithStatus(output,msg,"invalid request", DoipResponseCode.Invalid);
 return;
 };
 if(msg.header.isCertified()){
 try {
 if(!GlobalCertifications.verifyDoipMessage(msg)){
 log("verification failed");
 return;
 }
 }catch (Exception e){
 e.printStackTrace();
 return;
 }
 }
 if (msg.credential != null) log("[Caller] client ID: " + msg.credential.getSigner());
 else log("[Caller] client ID: Anonymous");

 DoipMessage response = doipRequestHandler.onRequest(msg);

 if(response != null)
 sendResponse(output, response);
 else
 defaultHandler(output,msg);
 }

 private void defaultHandler(OutputStream ctx, DoipMessage request) {
 replyStringWithStatus(ctx,request,"Unsupported Operation!", DoipResponseCode.Declined);
 }

 private void replyStringWithStatus(OutputStream output, DoipMessage request, String str, DoipResponseCode resp) {
 DoipMessage response;
 response = new DoipMessageFactory.DoipMessageBuilder()
 .createResponse(resp,request)
 .setBody(str.getBytes())
 .create();
 sendResponse(output,response);
 }

 //基于编解码器将DoipMessage编码并通过Bluetooth协议的OutputStream发送
 private void sendResponse(OutputStream output, DoipMessage response){
 try {
 if(response.header.isCertified()){
 try {
 GlobalCertifications.signDoipMessage(response);
 }catch (Exception e){
 e.printStackTrace();
 }
 }
 ArrayList<MessageEnvelope> envs = codec.MessageToEnvelopes(response);
 for(MessageEnvelope env:envs) {
 byte[] envBytes = codec.EnvelopeToBytes(env);
 log("sending bytes length: " + envBytes.length);
 output.write(codec.EnvelopeToBytes(env));
 }
 }catch (Exception e){
 e.printStackTrace();
 }
 }

 //基于编解码器从Bluetooth协议的InputStream中解码DoipMessage
 private DoipMessage getDoipMessage(InputStream in){
 DoipMessage message = null;
 try {
 byte[] envHeader = getBytesFromInputStream(in,24);
 int requestId = ((envHeader[8+3] & 0xFF)
 | ((envHeader[8+2] & 0xFF)<<8)
 | ((envHeader[8+1] & 0xFF)<<16)
 | ((envHeader[8] & 0xFF)<<24));
 log("requestId: " + requestId);
 int contentLength = (int) ((envHeader[20+3] & 0xFF)
 | ((envHeader[20+2] & 0xFF)<<8)
 | ((envHeader[20+1] & 0xFF)<<16)
 | ((envHeader[20] & 0xFF)<<24));
 log("content Length: " + contentLength);

 byte[] envContent = getBytesFromInputStream(in, contentLength);
 return codec.BytesToMessage(envContent,requestId,null);

 } catch (Exception e) {
 e.printStackTrace();
 }

 return message;
 }

 private byte[] getBytesFromInputStream(InputStream in, int len) throws IOException {
 log("reading inputStream, available: " + in.available());
 int count = 0;
 while(in.available() < len && count <100){
 count ++;
 try {
 Thread.sleep(10);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 byte[] bytes = new byte[len];
 in.read(bytes);
 return bytes;
 }

 private static void log(String s){
 Log.d(TAG,s);
 }


 class BtSocketThread extends Thread{
 BluetoothSocket socket;
 BtSocketThread(BluetoothSocket s){
 socket = s;
 }

 @Override
 public void run(){
 try {
 int missingInputCount = 0;
 InputStream input = socket.getInputStream();
 OutputStream output = socket.getOutputStream();
 while(socket.isConnected()){
 if(input.available() == 0){
 missingInputCount ++;
// if(missingInputCount > 10){
// socket.close();
// }
 try {
 Thread.sleep(500);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 continue;
 }
 DoipMessage req = getDoipMessage(input);
 handleAndResponseDoipMessage(req,output);
 }
 log("device disconnected, name: " + socket.getRemoteDevice().getName());
 }catch (Exception e){
 e.printStackTrace();
 }
 }
 }
}

public class BlueToothDoipClient implements DoipClientChannel {

 private Context ctx;
 private String address;
 private final String TAG = "BluetoothDoipClient";

 private BluetoothDevice device;
 private BluetoothAdapter bluetoothAdapter;
 private BluetoothSocket targetSocket;
 private PacketMessageCodec codec = new PacketMessageCodecImpl();
 Random random = new Random();
 boolean isConnected = false;

 private HashMap<Integer,DoipMessageCallback> waitingCallback = new HashMap<>();

 private boolean connecting = false;

 public BlueToothDoipClient(Context c){
 ctx = c;
 }

 @Override
 public void close(){
 try {
 targetSocket.close();
 } catch (IOException e) {
 e.printStackTrace();
 }
 }

 @Override
 public void connect(String url) throws URISyntaxException{
 isConnected = false;
 URI uri = new URI(url);
 this.address = uri.getAuthority();
 try {
 connectBTServer();
 } catch (IOException e) {
 e.printStackTrace();
 }
 }

 @Override
 public boolean isConnected() {
 return isConnected;
 }

 @Override
 public void sendMessage(DoipMessage message, DoipMessageCallback cb){

 log("try to send message");
 if(device == null){
 Log.e(TAG,"no connection to target repository device");
 }
 try {
 while(!isConnected){
 log("not connected, wait for connect.");
 Thread.sleep(500);
 }

 if(message.requestID == 0) message.requestID = random.nextInt();
 log("requestID in message: " + message.requestID);

 OutputStream output = targetSocket.getOutputStream();
 ArrayList<MessageEnvelope> envelopes = codec.MessageToEnvelopes(message);

 waitingCallback.put(message.requestID,cb);

 log("connected: " + targetSocket.isConnected());
 for (MessageEnvelope env : envelopes) {
 log("requestID in envelope: " + env.requestId);
 byte[] envBytes = codec.EnvelopeToBytes(env);
 log("sending bytes length: " + envBytes.length);
 output.write(codec.EnvelopeToBytes(env));
 }
 InputStream input = targetSocket.getInputStream();
 new ResponseHandlerThread(input).start();

 }catch (Exception e){
 e.printStackTrace();
 targetSocket = null;
 }
 };


 private void connectBTServer() throws IOException {

 bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
 if (bluetoothAdapter == null) {
 // 说明此设备不支持蓝牙操作
 log("do not support Bluetooth");
 return;
 }
 if (!bluetoothAdapter.isEnabled()) {
 AlertDialog dialog = new AlertDialog.Builder(ctx).setTitle("提示").setMessage("打开蓝牙再尝试!").create();
 dialog.show();
 return;
 }
 for(BluetoothDevice dev:bluetoothAdapter.getBondedDevices()){
 log("bounded bt address: " + dev.getAddress());
 log("bounded bt name: " + dev.getName());
 log("bounded bt state: " + dev.getType());
 };

 device = bluetoothAdapter.getRemoteDevice(address);
 if(device == null){
 log("cannot find target device. ");
 return;
 }
 log("remote bt address: " + device.getAddress());
 log("remote bt name: " + device.getName());
 log("remote bt state: " + device.getType());

 targetSocket = device.createRfcommSocketToServiceRecord(AndroidInitializer.DOIP_SERVICE_UUID);

 new ConnectThread(targetSocket).start();
 }

 void log(String s){
 Log.d(TAG,s);
 }

 class ConnectThread extends Thread{
 private BluetoothSocket mSocket;

 ConnectThread(BluetoothSocket s) throws IOException {
 mSocket = s;
 }

 @Override
 public synchronized void run(){
 // 关闭发现设备
 bluetoothAdapter.cancelDiscovery();
 if(mSocket.isConnected()) return;
 try{
 log("try to connect device");
 connecting = true;
 mSocket.connect();
 log("connected: " + mSocket.isConnected());
 log("remote device name: " + mSocket.getRemoteDevice().getName());
 log("remote device address: " + mSocket.getRemoteDevice().getAddress());
 isConnected = true;
 }catch(IOException connectException){
 connectException.printStackTrace();
 }finally {
 connecting = false;
 }
 }
 }

 class ResponseHandlerThread extends Thread{
 InputStream input;
 ResponseHandlerThread(InputStream in){
 input = in;
 }

 @Override
 public synchronized void run(){
 log("try to get response:");
 DoipMessage resp = getDoipMessageFromInputStream(input);
 if(resp == null){
 Log.e(TAG,"Unable to get response message");
 return;
 }
 if(waitingCallback.get(resp.requestID) == null){
 Log.e(TAG,"Unable to get callback");
 return;
 }
 waitingCallback.get(resp.requestID).onResult(resp);
 waitingCallback.remove(resp.requestID);
 }

 }
 private DoipMessage getDoipMessageFromInputStream(InputStream in){
 DoipMessage message = null;
 try {
 byte[] envHeader = getBytesFromInputStream(in,24);
 int requestId = (int) ((envHeader[8+3] & 0xFF)
 | ((envHeader[8+2] & 0xFF)<<8)
 | ((envHeader[8+1] & 0xFF)<<16)
 | ((envHeader[8] & 0xFF)<<24));
 log("requestID: " + requestId);
 int contentLength = (int) ((envHeader[23] & 0xFF)
 | ((envHeader[22] & 0xFF)<<8)
 | ((envHeader[21] & 0xFF)<<16)
 | ((envHeader[20] & 0xFF)<<24));
 log("content Length: " + contentLength);

 byte[] envContent = getBytesFromInputStream(in, contentLength);
 return codec.BytesToMessage(envContent,requestId,null);

 } catch (Exception e) {
 e.printStackTrace();
 }

 return message;
 }

 private byte[] getBytesFromInputStream(InputStream in, int len) throws IOException {
 int count = 0;
 while(in.available() < len && count <100){
 count ++;
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 byte[] bytes = new byte[len];
 in.read(bytes);
 return bytes;
 }
}

{
"id":"创建的时候为空",
"type":"0.TYPE/DO",
"attributes":{
"desc":"属性信息",
"metadata":{
"desc":"元数据相关信息"
}
},
"elements":[
{
"id":"DO内部唯一的ID",
"length":"元素长度",
"type":"string",
"dataString":"元素data字节数组的字符串形式",
"attributes":{
"desc":"元素属性"
},
"data":[]
}
]
}

 DoipMessage msg =
 new DoipMessageFactory.DoipMessageBuilder()
 .createRequest(doipInfo.id, BasicOperations.Create.getName())
 .setBody(digitalObject)
 .create();
//设置用户标识
msg.credential = new MessageCredential(userID);

 DoipMessage msg =
 new DoipMessageFactory.DoipMessageBuilder()
 .createRequest(doID,BasicOperations.Retrieve.getName())
 .create();

msg.header.parameters.addAttribute("includeElementData", true);

msg.header.parameters.addAttribute("element", elementID);