下面列出了怎么用com.sun.corba.se.impl.protocol.giopmsgheaders.Message的API类实例代码及写法，或者点击链接到github查看源代码。
private void setWorkThenPoolOrResumeSelect(Message header)
{
if (getConnection().getEventHandler().shouldUseSelectThreadToWait()) {
resumeSelect(header);
} else {
// Leader/Follower when using reader thread.
// When this thread is done working it will go back in pool.
isThreadDone = true;
// First unregister current registration.
orb.getTransportManager().getSelector(0)
.unregisterForEvent(getConnection().getEventHandler());
// Have another thread become the reader.
orb.getTransportManager().getSelector(0)
.registerForEvent(getConnection().getEventHandler());
}
}
/**
* Full constructor with a CodeBase parameter useful for
* unmarshaling RMI-IIOP valuetypes (technically against the
* intention of an encapsulation, but necessary due to OMG
* issue 4795. Used by ServiceContexts.
*/
public EncapsInputStream(org.omg.CORBA.ORB orb,
byte[] data,
int size,
GIOPVersion version,
CodeBase codeBase) {
super(orb,
ByteBuffer.wrap(data),
size,
false,
version, Message.CDR_ENC_VERSION,
BufferManagerFactory.newBufferManagerRead(
BufferManagerFactory.GROW,
Message.CDR_ENC_VERSION,
(ORB)orb));
this.codeBase = codeBase;
performORBVersionSpecificInit();
}
private CDROutputObject createAppropriateOutputObject(
CorbaMessageMediator messageMediator,
Message msg, LocateReplyMessage reply)
{
CDROutputObject outputObject;
if (msg.getGIOPVersion().lessThan(GIOPVersion.V1_2)) {
// locate msgs 1.0 & 1.1 :=> grow,
outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
(ORB) messageMediator.getBroker(),
this,
GIOPVersion.V1_0,
(CorbaConnection) messageMediator.getConnection(),
reply,
ORBConstants.STREAM_FORMAT_VERSION_1);
} else {
// 1.2 :=> stream
outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
(ORB) messageMediator.getBroker(),
messageMediator,
reply,
ORBConstants.STREAM_FORMAT_VERSION_1);
}
return outputObject;
}
public static BufferManagerRead newBufferManagerRead(
GIOPVersion version, byte encodingVersion, ORB orb) {
// REVISIT - On the reading side, shouldn't we monitor the incoming
// fragments on a given connection to determine what fragment size
// they're using, then use that ourselves?
if (encodingVersion != Message.CDR_ENC_VERSION) {
return new BufferManagerReadGrow(orb);
}
switch (version.intValue())
{
case GIOPVersion.VERSION_1_0:
return new BufferManagerReadGrow(orb);
case GIOPVersion.VERSION_1_1:
case GIOPVersion.VERSION_1_2:
// The stream reader can handle fragmented and
// non fragmented messages
return new BufferManagerReadStream(orb);
default:
// REVISIT - what is appropriate?
throw new INTERNAL("Unknown GIOP version: "
+ version);
}
}
private CDROutputObject createAppropriateOutputObject(
CorbaMessageMediator messageMediator,
Message msg, LocateReplyMessage reply)
{
CDROutputObject outputObject;
if (msg.getGIOPVersion().lessThan(GIOPVersion.V1_2)) {
// locate msgs 1.0 & 1.1 :=> grow,
outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
(ORB) messageMediator.getBroker(),
this,
GIOPVersion.V1_0,
(CorbaConnection) messageMediator.getConnection(),
reply,
ORBConstants.STREAM_FORMAT_VERSION_1);
} else {
// 1.2 :=> stream
outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
(ORB) messageMediator.getBroker(),
messageMediator,
reply,
ORBConstants.STREAM_FORMAT_VERSION_1);
}
return outputObject;
}
public CDROutputObject(ORB orb, CorbaMessageMediator mediator,
GIOPVersion giopVersion,
CorbaConnection connection, Message header,
byte streamFormatVersion)
{
this(
orb,
giopVersion,
header,
BufferManagerFactory.
newBufferManagerWrite(giopVersion,
header.getEncodingVersion(),
orb),
streamFormatVersion,
mediator);
this.connection = connection ;
}
public static BufferManagerRead newBufferManagerRead(
int strategy, byte encodingVersion, ORB orb) {
if (encodingVersion != Message.CDR_ENC_VERSION) {
if (strategy != BufferManagerFactory.GROW) {
ORBUtilSystemException wrapper =
ORBUtilSystemException.get((ORB)orb,
CORBALogDomains.RPC_ENCODING);
throw wrapper.invalidBuffMgrStrategy("newBufferManagerRead");
}
return new BufferManagerReadGrow(orb);
}
switch (strategy) {
case BufferManagerFactory.GROW:
return new BufferManagerReadGrow(orb);
case BufferManagerFactory.COLLECT:
throw new INTERNAL("Collect strategy invalid for reading");
case BufferManagerFactory.STREAM:
return new BufferManagerReadStream(orb);
default:
throw new INTERNAL("Unknown buffer manager read strategy: "
+ strategy);
}
}
public static BufferManagerWrite newBufferManagerWrite(
int strategy, byte encodingVersion, ORB orb) {
if (encodingVersion != Message.CDR_ENC_VERSION) {
if (strategy != BufferManagerFactory.GROW) {
ORBUtilSystemException wrapper =
ORBUtilSystemException.get((ORB)orb,
CORBALogDomains.RPC_ENCODING);
throw wrapper.invalidBuffMgrStrategy("newBufferManagerWrite");
}
return new BufferManagerWriteGrow(orb);
}
switch (strategy) {
case BufferManagerFactory.GROW:
return new BufferManagerWriteGrow(orb);
case BufferManagerFactory.COLLECT:
return new BufferManagerWriteCollect(orb);
case BufferManagerFactory.STREAM:
return new BufferManagerWriteStream(orb);
default:
throw new INTERNAL("Unknown buffer manager write strategy: "
+ strategy);
}
}
public static BufferManagerRead newBufferManagerRead(
int strategy, byte encodingVersion, ORB orb) {
if (encodingVersion != Message.CDR_ENC_VERSION) {
if (strategy != BufferManagerFactory.GROW) {
ORBUtilSystemException wrapper =
ORBUtilSystemException.get((ORB)orb,
CORBALogDomains.RPC_ENCODING);
throw wrapper.invalidBuffMgrStrategy("newBufferManagerRead");
}
return new BufferManagerReadGrow(orb);
}
switch (strategy) {
case BufferManagerFactory.GROW:
return new BufferManagerReadGrow(orb);
case BufferManagerFactory.COLLECT:
throw new INTERNAL("Collect strategy invalid for reading");
case BufferManagerFactory.STREAM:
return new BufferManagerReadStream(orb);
default:
throw new INTERNAL("Unknown buffer manager read strategy: "
+ strategy);
}
}
public static BufferManagerRead newBufferManagerRead(
int strategy, byte encodingVersion, ORB orb) {
if (encodingVersion != Message.CDR_ENC_VERSION) {
if (strategy != BufferManagerFactory.GROW) {
ORBUtilSystemException wrapper =
ORBUtilSystemException.get((ORB)orb,
CORBALogDomains.RPC_ENCODING);
throw wrapper.invalidBuffMgrStrategy("newBufferManagerRead");
}
return new BufferManagerReadGrow(orb);
}
switch (strategy) {
case BufferManagerFactory.GROW:
return new BufferManagerReadGrow(orb);
case BufferManagerFactory.COLLECT:
throw new INTERNAL("Collect strategy invalid for reading");
case BufferManagerFactory.STREAM:
return new BufferManagerReadStream(orb);
default:
throw new INTERNAL("Unknown buffer manager read strategy: "
+ strategy);
}
}
private CDROutputObject(
ORB orb, GIOPVersion giopVersion, Message header,
BufferManagerWrite manager, byte streamFormatVersion,
CorbaMessageMediator mediator)
{
super(orb, giopVersion, header.getEncodingVersion(),
false, manager, streamFormatVersion,
((mediator != null && mediator.getConnection() != null) ?
((CorbaConnection)mediator.getConnection()).
shouldUseDirectByteBuffers() : false));
this.header = header;
this.orb = orb;
this.wrapper = ORBUtilSystemException.get( orb, CORBALogDomains.RPC_ENCODING ) ;
this.omgWrapper = OMGSystemException.get( orb, CORBALogDomains.RPC_ENCODING ) ;
getBufferManager().setOutputObject(this);
this.corbaMessageMediator = mediator;
}
private void setWorkThenPoolOrResumeSelect(Message header)
{
if (getConnection().getEventHandler().shouldUseSelectThreadToWait()) {
resumeSelect(header);
} else {
// Leader/Follower when using reader thread.
// When this thread is done working it will go back in pool.
isThreadDone = true;
// First unregister current registration.
orb.getTransportManager().getSelector(0)
.unregisterForEvent(getConnection().getEventHandler());
// Have another thread become the reader.
orb.getTransportManager().getSelector(0)
.registerForEvent(getConnection().getEventHandler());
}
}
public CDROutputObject(ORB orb, CorbaMessageMediator mediator,
GIOPVersion giopVersion,
CorbaConnection connection, Message header,
byte streamFormatVersion)
{
this(
orb,
giopVersion,
header,
BufferManagerFactory.
newBufferManagerWrite(giopVersion,
header.getEncodingVersion(),
orb),
streamFormatVersion,
mediator);
this.connection = connection ;
}
public CDROutputObject(ORB orb, CorbaMessageMediator mediator,
GIOPVersion giopVersion,
CorbaConnection connection, Message header,
byte streamFormatVersion)
{
this(
orb,
giopVersion,
header,
BufferManagerFactory.
newBufferManagerWrite(giopVersion,
header.getEncodingVersion(),
orb),
streamFormatVersion,
mediator);
this.connection = connection ;
}
private CDROutputObject(
ORB orb, GIOPVersion giopVersion, Message header,
BufferManagerWrite manager, byte streamFormatVersion,
CorbaMessageMediator mediator)
{
super(orb, giopVersion, header.getEncodingVersion(),
false, manager, streamFormatVersion,
((mediator != null && mediator.getConnection() != null) ?
((CorbaConnection)mediator.getConnection()).
shouldUseDirectByteBuffers() : false));
this.header = header;
this.orb = orb;
this.wrapper = ORBUtilSystemException.get( orb, CORBALogDomains.RPC_ENCODING ) ;
this.omgWrapper = OMGSystemException.get( orb, CORBALogDomains.RPC_ENCODING ) ;
getBufferManager().setOutputObject(this);
this.corbaMessageMediator = mediator;
}
public CDROutputObject(ORB orb,
MessageMediator messageMediator,
Message header,
byte streamFormatVersion,
int strategy)
{
this(
orb,
((CorbaMessageMediator)messageMediator).getGIOPVersion(),
header,
BufferManagerFactory.
newBufferManagerWrite(strategy,
header.getEncodingVersion(),
orb),
streamFormatVersion,
(CorbaMessageMediator)messageMediator);
}
public static CDROutputStreamBase newOutputStream(
ORB orb, GIOPVersion version, byte encodingVersion) {
switch(version.intValue()) {
case GIOPVersion.VERSION_1_0:
return new CDROutputStream_1_0();
case GIOPVersion.VERSION_1_1:
return new CDROutputStream_1_1();
case GIOPVersion.VERSION_1_2:
if (encodingVersion != Message.CDR_ENC_VERSION) {
return
new IDLJavaSerializationOutputStream(encodingVersion);
}
return new CDROutputStream_1_2();
default:
ORBUtilSystemException wrapper = ORBUtilSystemException.get( orb,
CORBALogDomains.RPC_ENCODING ) ;
// REVISIT - what is appropriate? INTERNAL exceptions
// are really hard to track later.
throw wrapper.unsupportedGiopVersion( version ) ;
}
}
public static BufferManagerRead newBufferManagerRead(
GIOPVersion version, byte encodingVersion, ORB orb) {
// REVISIT - On the reading side, shouldn't we monitor the incoming
// fragments on a given connection to determine what fragment size
// they're using, then use that ourselves?
if (encodingVersion != Message.CDR_ENC_VERSION) {
return new BufferManagerReadGrow(orb);
}
switch (version.intValue())
{
case GIOPVersion.VERSION_1_0:
return new BufferManagerReadGrow(orb);
case GIOPVersion.VERSION_1_1:
case GIOPVersion.VERSION_1_2:
// The stream reader can handle fragmented and
// non fragmented messages
return new BufferManagerReadStream(orb);
default:
// REVISIT - what is appropriate?
throw new INTERNAL("Unknown GIOP version: "
+ version);
}
}
private CDROutputObject createAppropriateOutputObject(
CorbaMessageMediator messageMediator,
Message msg, LocateReplyMessage reply)
{
CDROutputObject outputObject;
if (msg.getGIOPVersion().lessThan(GIOPVersion.V1_2)) {
// locate msgs 1.0 & 1.1 :=> grow,
outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
(ORB) messageMediator.getBroker(),
this,
GIOPVersion.V1_0,
(CorbaConnection) messageMediator.getConnection(),
reply,
ORBConstants.STREAM_FORMAT_VERSION_1);
} else {
// 1.2 :=> stream
outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
(ORB) messageMediator.getBroker(),
messageMediator,
reply,
ORBConstants.STREAM_FORMAT_VERSION_1);
}
return outputObject;
}
public MessageMediator finishCreatingMessageMediator(Broker broker,
Connection conn, MessageMediator messageMediator)
{
ORB orb = (ORB) broker;
CorbaConnection connection = (CorbaConnection) conn;
CorbaMessageMediator corbaMessageMediator =
(CorbaMessageMediator)messageMediator;
if (orb.transportDebugFlag) {
dprint(
".finishCreatingMessageMediator: waiting for message body on connection: "
+ connection);
}
Message msg = corbaMessageMediator.getDispatchHeader();
msg.setByteBuffer(corbaMessageMediator.getDispatchBuffer());
// read giop body only
msg = MessageBase.readGIOPBody(orb, connection, msg);
ByteBuffer byteBuffer = msg.getByteBuffer();
msg.setByteBuffer(null);
corbaMessageMediator.setDispatchHeader(msg);
corbaMessageMediator.setDispatchBuffer(byteBuffer);
return corbaMessageMediator;
}
public void handleInput(Message header) throws IOException
{
try {
messageHeader = header;
if (transportDebug())
dprint(".handleInput->: "
+ MessageBase.typeToString(header.getType()));
setWorkThenReadOrResumeSelect(header);
switch(header.getType())
{
case Message.GIOPCloseConnection:
if (transportDebug()) {
dprint(".handleInput: CloseConnection: purging");
}
connection.purgeCalls(wrapper.connectionRebind(), true, false);
break;
case Message.GIOPMessageError:
if (transportDebug()) {
dprint(".handleInput: MessageError: purging");
}
connection.purgeCalls(wrapper.recvMsgError(), true, false);
break;
default:
if (transportDebug()) {
dprint(".handleInput: ERROR: "
+ MessageBase.typeToString(header.getType()));
}
throw wrapper.badGiopRequestType() ;
}
releaseByteBufferToPool();
} finally {
if (transportDebug()) {
dprint(".handleInput<-: "
+ MessageBase.typeToString(header.getType()));
}
}
}
public CorbaMessageMediatorImpl(ORB orb,
CorbaConnection connection,
Message dispatchHeader,
ByteBuffer byteBuffer)
{
this( orb, connection ) ;
this.dispatchHeader = dispatchHeader;
this.dispatchByteBuffer = byteBuffer;
}
public EncapsOutputStream(ORB orb,
GIOPVersion version,
boolean isLittleEndian)
{
super(orb, version, Message.CDR_ENC_VERSION, isLittleEndian,
BufferManagerFactory.newBufferManagerWrite(
BufferManagerFactory.GROW,
Message.CDR_ENC_VERSION,
orb),
ORBConstants.STREAM_FORMAT_VERSION_1,
usePooledByteBuffers);
}
public MessageMediator createMessageMediator(Broker broker,Connection conn)
{
ORB orb = (ORB) broker;
CorbaConnection connection = (CorbaConnection) conn;
if (orb.transportDebugFlag) {
if (connection.shouldReadGiopHeaderOnly()) {
dprint(
".createMessageMediator: waiting for message header on connection: "
+ connection);
} else {
dprint(
".createMessageMediator: waiting for message on connection: "
+ connection);
}
}
Message msg = null;
if (connection.shouldReadGiopHeaderOnly()) {
// read giop header only
msg = MessageBase.readGIOPHeader(orb, connection);
} else {
// read entire giop message
msg = MessageBase.readGIOPMessage(orb, connection);
}
ByteBuffer byteBuffer = msg.getByteBuffer();
msg.setByteBuffer(null);
CorbaMessageMediator messageMediator =
new CorbaMessageMediatorImpl(orb, connection, msg, byteBuffer);
return messageMediator;
}
public void handleInput(Message header) throws IOException
{
try {
messageHeader = header;
if (transportDebug())
dprint(".handleInput->: "
+ MessageBase.typeToString(header.getType()));
setWorkThenReadOrResumeSelect(header);
switch(header.getType())
{
case Message.GIOPCloseConnection:
if (transportDebug()) {
dprint(".handleInput: CloseConnection: purging");
}
connection.purgeCalls(wrapper.connectionRebind(), true, false);
break;
case Message.GIOPMessageError:
if (transportDebug()) {
dprint(".handleInput: MessageError: purging");
}
connection.purgeCalls(wrapper.recvMsgError(), true, false);
break;
default:
if (transportDebug()) {
dprint(".handleInput: ERROR: "
+ MessageBase.typeToString(header.getType()));
}
throw wrapper.badGiopRequestType() ;
}
releaseByteBufferToPool();
} finally {
if (transportDebug()) {
dprint(".handleInput<-: "
+ MessageBase.typeToString(header.getType()));
}
}
}
public static CDROutputObject newCDROutputObject(
final ORB orb, final MessageMediator messageMediator,
final Message header, final byte streamFormatVersion,
final int strategy) {
return AccessController.doPrivileged(
new PrivilegedAction<CDROutputObject>() {
@Override
public CDROutputObject run() {
return new CDROutputObject(orb, messageMediator,
header, streamFormatVersion, strategy);
}
});
}
public MessageMediator createMessageMediator(Broker broker,Connection conn)
{
ORB orb = (ORB) broker;
CorbaConnection connection = (CorbaConnection) conn;
if (orb.transportDebugFlag) {
if (connection.shouldReadGiopHeaderOnly()) {
dprint(
".createMessageMediator: waiting for message header on connection: "
+ connection);
} else {
dprint(
".createMessageMediator: waiting for message on connection: "
+ connection);
}
}
Message msg = null;
if (connection.shouldReadGiopHeaderOnly()) {
// read giop header only
msg = MessageBase.readGIOPHeader(orb, connection);
} else {
// read entire giop message
msg = MessageBase.readGIOPMessage(orb, connection);
}
ByteBuffer byteBuffer = msg.getByteBuffer();
msg.setByteBuffer(null);
CorbaMessageMediator messageMediator =
new CorbaMessageMediatorImpl(orb, connection, msg, byteBuffer);
return messageMediator;
}
protected void sendHelper(GIOPVersion giopVersion, Message msg)
throws IOException
{
// REVISIT: See comments in CDROutputObject constructor.
CDROutputObject outputObject =
sun.corba.OutputStreamFactory.newCDROutputObject((ORB)orb, null, giopVersion,
this, msg, ORBConstants.STREAM_FORMAT_VERSION_1);
msg.write(outputObject);
outputObject.writeTo(this);
}
/**
* Send a CancelRequest message. This does not lock the connection, so the
* caller needs to ensure this method is called appropriately.
* @exception IOException - could be due to abortive connection closure.
*/
public void sendCancelRequest(GIOPVersion giopVersion, int requestId)
throws IOException
{
Message msg = MessageBase.createCancelRequest(giopVersion, requestId);
sendHelper(giopVersion, msg);
}
protected void sendHelper(GIOPVersion giopVersion, Message msg)
throws IOException
{
// REVISIT: See comments in CDROutputObject constructor.
CDROutputObject outputObject =
sun.corba.OutputStreamFactory.newCDROutputObject((ORB)orb, null, giopVersion,
this, msg, ORBConstants.STREAM_FORMAT_VERSION_1);
msg.write(outputObject);
outputObject.writeTo(this);
}