m
, it executes that message's run()
method. Messages between pairs of PEs are received and executed in FIFO order: if PE0
sends m0
and then m1
to PE1
, then PE1
runs m0.run()
to completion befor starting m1.run()
. A message's run()
method should therefore not block for non-trivial durations. If you need to block, use aleph.AsynchMessage
. Messages from different PEs are not synchronized: if PE0
sends m0
and PE1
sends m1
to PE2
, then m0.run()
and m1.run()
may be run concurrently.
@see aleph.AsynchMessage
@author Maurice Herlihy
@date July 1998
Represents a complete HL7 message including all structures, segments, and fields.
Note this it is not recommended to implement this interface directly, as it is subject to change. Instead, extend abstract implementations for your model classes, such as {@link AbstractMessage} and {@link AbstractGroup}
@author Bryan Tripp (bryan_tripp@sourceforge.net)A message must have a least one {@link Recipient}.
A message may be marked as Urgent in which case it is placed at the top of the queue.
Represents the message to be sent, composed of a subject and a body.
Message represents data collected during application runtime. It will be sent to back-end system asynchronous for further processing.
Super interface of Event
, Heartbeat
and Transaction
.
Instances of this class are immutable and should be created using a {@link Builder}. Examples: Simplest message:
Message message = new Message.Builder().build();
Message with optional attributes: Message message = new Message.Builder() .collapseKey(collapseKey) .timeToLive(3) .delayWhileIdle(true) .build();
Message with optional attributes and payload data: Message message = new Message.Builder() .collapseKey(collapseKey) .timeToLive(3) .delayWhileIdle(true) .addData("key1", "value1") .addData("key2", "value2") .build();
Messages can be formatted for immediate display to the user, or can be fed to another tool, such as an documentation or metadata generator, that might use then produce derived files. @author mikesamuel@gmail.com
User: Zhang Kaitao
Date: 13-5-22 下午1:51
Version: 1.0
Message
objects that may contain different elements depending on the underlying messaging protocol. This is different from Datagram
s that are assumed always to be just blocks of binary data. An adapter specification for a given messaging protocol may define further interfaces derived from the Message
interfaces included in this generic specification. The wireless messaging protocols that are accessed via this API are typically of store-and-forward nature, unlike network layer datagrams. Thus, the messages will usually reach the recipient, even if the recipient is not connected at the time of sending the message. This may happen a significant time later if the recipient is disconnected for a long time. Sending, and possibly also receiving, these wireless messages, typically involves a financial cost to the end user that cannot be neglected. Therefore, applications should not send many messages unnecessarily.
This interface contains the functionality common to all messages. Concrete object instances representing a message will typically implement other (sub)interfaces providing access to the content and other information in the message which is dependent on the type of the message.
Object instances implementing this interface are just containers for the data that is passed in. The setAddress()
method just sets the value of the address in the data container without any checking whether the value is valid in any way.
A {@link Message} consists of the following:
The basic idea behind the {@link Message} is to hide the actualdata representation. For example, a {@link Message} might beconstructed on top of an {@link InputStream} from the accepted HTTP connection,or it might be constructed on top of a JAXB object as a result of the method invocation through {@link Proxy}. There will be a {@link Message} implementation for each of those cases.
This interface provides a lot of methods that access the payload in many different forms, and implementations can implement those methods in the best possible way.
A particular attention is paid to make sure that a {@link Message}object can be constructed on a stream that is not fully read yet. We believe this improves the turn-around time on the server side.
It is often useful to wrap a {@link Message} into another {@link Message}, for example to encrypt the body, or to verify the signature as the body is read.
This representation is also used for a REST-ful XML message. In such case we'll construct a {@link Message} with emptyattachments and headers, and when serializing all headers and attachments will be ignored.
XOP is considered as an {@link Codec}, and therefore when you are looking at {@link Message}, you'll never see <xop:Include> or any such elements (instead you'll see the base64 data inlined.) If a consumer of infoset isn't interested in handling XOP by himself, this allows him to work with XOP correctly even without noticing it.
For producers and consumers that are interested in accessing the binary data more efficiently, they can use {@link XMLStreamReaderEx} and{@link XMLStreamWriterEx}.
Often {@link Packet} include information local to a particularinvocaion (such as {@code HttpServletRequest}, from this angle, it makes sense to tie a lifespan of a message to one pipeline invocation.
On the other hand, if you think about WS-RM, it often needs to hold on to a message longer than a pipeline invocation (you might get an HTTP request, get a message X, get a second HTTP request, get another message Y, and only then you might want to process X.)
TODO: what do we do about this?
TODO: can body element have foreign attributes? maybe ID for security? Yes, when the SOAP body is signed there will be an ID attribute present But in this case any security based impl may need access to the concrete representation. TODO: HTTP headers? Yes. Abstracted as transport-based properties. TODO: who handles SOAP 1.1 and SOAP 1.2 difference? As separate channel implementations responsible for the creation of the message? TODO: session? TODO: Do we need to expose SOAPMessage explicitly? SOAPMessage could be the concrete representation but is it necessary to transform between different concrete representations? Perhaps this comes down to how use channels for creation and processing. TODO: Do we need to distinguish better between creation and processing? Do we really need the requirement that a created message can be resused for processing. Shall we bifurcate? TODO: SOAP version issue SOAP version is determined by the context, so message itself doesn't carry it around (?) TODO: wrapping message needs easier. in particular properties and attachments.@author Kohsuke Kawaguchi
A {@link Message} consists of the following:
The basic idea behind the {@link Message} is to hide the actualdata representation. For example, a {@link Message} might beconstructed on top of an {@link InputStream} from the accepted HTTP connection,or it might be constructed on top of a JAXB object as a result of the method invocation through {@link Proxy}. There will be a {@link Message} implementation for each of those cases.
This interface provides a lot of methods that access the payload in many different forms, and implementations can implement those methods in the best possible way.
A particular attention is paid to make sure that a {@link Message}object can be constructed on a stream that is not fully read yet. We believe this improves the turn-around time on the server side.
It is often useful to wrap a {@link Message} into another {@link Message}, for example to encrypt the body, or to verify the signature as the body is read.
This representation is also used for a REST-ful XML message. In such case we'll construct a {@link Message} with emptyattachments and headers, and when serializing all headers and attachments will be ignored.
XOP is considered as an {@link Codec}, and therefore when you are looking at {@link Message}, you'll never see <xop:Include> or any such elements (instead you'll see the base64 data inlined.) If a consumer of infoset isn't interested in handling XOP by himself, this allows him to work with XOP correctly even without noticing it.
For producers and consumers that are interested in accessing the binary data more efficiently, they can use {@link XMLStreamReaderEx} and{@link XMLStreamWriterEx}.
Often {@link Packet} include information local to a particularinvocaion (such as {@code HttpServletRequest}, from this angle, it makes sense to tie a lifespan of a message to one pipeline invocation.
On the other hand, if you think about WS-RM, it often needs to hold on to a message longer than a pipeline invocation (you might get an HTTP request, get a message X, get a second HTTP request, get another message Y, and only then you might want to process X.)
TODO: what do we do about this?
TODO: can body element have foreign attributes? maybe ID for security? Yes, when the SOAP body is signed there will be an ID attribute present But in this case any security based impl may need access to the concrete representation. TODO: HTTP headers? Yes. Abstracted as transport-based properties. TODO: who handles SOAP 1.1 and SOAP 1.2 difference? As separate channel implementations responsible for the creation of the message? TODO: session? TODO: Do we need to expose SOAPMessage explicitly? SOAPMessage could be the concrete representation but is it necessary to transform between different concrete representations? Perhaps this comes down to how use channels for creation and processing. TODO: Do we need to distinguish better between creation and processing? Do we really need the requirement that a created message can be resused for processing. Shall we bifurcate? TODO: SOAP version issue SOAP version is determined by the context, so message itself doesn't carry it around (?) TODO: wrapping message needs easier. in particular properties and attachments.@author Kohsuke Kawaguchi
Interface representing a Message.
Warning: This is a facade provided for use by user code, not for implementation. User implementations of this interface are highly likely to be incompatible with future releases of the product at both binary and source levels.
@volantis-api-include-in InternalAPIformat()
method. Since arguments do not have names, their order is important.
@see de.odysseus.calyxo.base.I18nSupport
@author Christoph Beck
A message represents a little message agents can send and receive. A message has a sender and one or more recipients. The body of a message is a String
which may be verified by concrete implementations for validity to the standard of the plattform. This standard will not be defined in this framework, but it's up to the application. Standards could be free-form text, Agent Control Message etc. A specific message type gets registered in the execution environment which clones the given message and uses it for message passing in the system.
A recipient and sender of a message may be an Agent
, a computer or some kind of service in the p2p-network.
Message
interface lets you discover the following information about a compiler message. 1. getLevel() - Error level: error, warning or info. 2. getPath() - Location. 3. getLine() - Line number. 4. getColumn() - Column number. 5. toString() - Message string.The
Message.toString()
method returns the message text.
@version 2.0.1
@author Clement Wong
The following features are supported:
Message
objects that may contain different elements depending on the underlying messaging protocol. This is different from Datagram
s that are assumed always to be just blocks of binary data. An adapter specification for a given messaging protocol may define further interfaces derived from the Message
interfaces included in this generic specification. The wireless messaging protocols that are accessed via this API are typically of store-and-forward nature, unlike network layer datagrams. Thus, the messages will usually reach the recipient, even if the recipient is not connected at the time of sending the message. This may happen significantly later if the recipient is disconnected for a long time. Sending, and possibly also receiving, these wireless messages typically involves a financial cost to the end user that cannot be neglected. Therefore, applications should not send many messages unnecessarily.
This interface contains the functionality common to all messages. Concrete object instances representing a message will typically implement other (sub)interfaces providing access to the content and other information in the message which is dependent on the type of the message.
Object instances implementing this interface are just containers for the data that is passed in. The setAddress()
method just sets the value of the address in the data container without any checking whether the value is valid in any way.
A message can deliver itself. @author Kir
This class provides easy access to the content and key fields of an instant Message. Content types are represented using MIME types. [IETF RFC 2045-2048].
Messages are created through the OperationSetBaicInstanceMessaging operation set.
All messages have message ids that allow the underlying implementation to notify the user of their successful delivery. @author Emil Ivov
Message
is the base for all classes that handle the data of requests and responses. It contains all methods and attributes which are independent of the application-protocol.
Title: im
Description:
Copyright: Copyright (c) 2001
Company:
@author E.S. de Boer @version 1.0Basic interface for all messages.
A Message
is not a simple String but all the information needed to create those Strings for multiple situations. The situation ist determined by the used {@link MessageContext}.
Message
object. Message msg = new Message(new FileInputStream("mime.msg"));@version $Id: Message.java,v 1.3 2004/10/02 12:41:11 ntherning Exp $
Note: Message objects should not be considered to be thread safe nor should they be assumed to be safely reusable even on the same thread. The logging system may provide information to the Message objects and the Messages might be queued for asynchronous delivery. Thus, any modifications to a Message object by an application should by avoided after the Message has been passed as a parameter on a Logger method.
@doubt Interfaces should rarely extend Serializable according to Effective Java 2nd Ed pg 291.(RG) That section also says "If a class or interface exists primarily to participate in a framework that requires all participants to implement Serializable, then it makes perfect sense for the class or interface to implement or extend Serializable". Such is the case here as the LogEvent must be Serializable.Message
is the class whose instances represent one-way messages in SOAP. While messages are one-way, they are sometimes carried on two-way transports such as HTTP. To accomodate that, the API supported here has a "receive" method as well - that is only applicable if the transport that is being used supports the receive() method (@see org.apache.soap.transport.SOAPTransport) so that this API can get at the 'response' envelope.
@author Sanjiva Weerawarana (sanjiva@watson.ibm.com)
Message
directly, consider implementing {@link org.axonframework.commandhandling.CommandMessage CommandMessage
} or {@link EventMessage} instead.
@param < T> The type of payload contained in this Message
@author Allard Buijze
@see org.axonframework.commandhandling.CommandMessage CommandMessage
@see EventMessage
@since 2.0
The Bayeux protocol exchange information by means of messages.
This interface represents the API of a Bayeux message, and consists mainly of convenience methods to access the known fields of the message map.
This interface comes in both an immutable and {@link Mutable mutable} versions.Mutability may be deeply enforced by an implementation, so that it is not correct to cast a passed Message, to a Message.Mutable, even if the implementation allows this.
The following features are supported:
The following features are supported:
try { bindPropertiesFromFile(); } catch (IOException e) { addError(e); }@author crazybob@google.com (Bob Lee)
| | boolean byte short int long float double String byte[] |---------------------------------------------------------------- |boolean | X X |byte | X X X X X |short | X X X X |int | X X X |long | X X |float | X X X |double | X X |String | X X X X X X X X |byte[] | X |-----------------------------------------------------------------
Copyright (C) 2011-2013 Carlos Eduardo Leite de Andrade
This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with this program. If not, see www.gnu.org/licenses/
For more information, contact: www.japura.org
@author Carlos Eduardo Leite de Andrade
Message instances are normally created with the help of {@link MessageBuilder}, but individual Message implementations may also be created directly if desired.
@author Mike Brock
@author Jonathan Fuerth
Every message in the system has a unique identifier. This identifier is unique within the context of the session that created it, but may not be globally unique. For message that need to be unique across clients, the session id of the originating session should be included in the message.
Wonderland messages are by default serialized and sent to clients. Messages that are very frequent should be hand-packed using the Externalizable interface. @see java.io.Externalizable @author jkaplan
The byte buffer can point to a reference, and we can subset it using index and length. However, when the message is serialized, we only write the bytes between index and length. @author Bela Ban @version $Id: Message.java,v 1.94 2008/11/11 09:30:08 belaban Exp $
Message type | |||||
Field | Normal | Chat | Group Chat | Headline | XMPPError |
subject | SHOULD | SHOULD NOT | SHOULD NOT | SHOULD NOT | SHOULD NOT |
thread | OPTIONAL | SHOULD | OPTIONAL | OPTIONAL | SHOULD NOT |
body | SHOULD | SHOULD | SHOULD | SHOULD | SHOULD NOT |
error | MUST NOT | MUST NOT | MUST NOT | MUST NOT | MUST |
Message
objects that render the same text regardless of the requested locale. This class implements CharSequence
so that messages can be supplied as arguments to other messages. This way messages can be composed of fragments of other messages if necessary.
@see org.nasutekds.messages.MessageDescriptor
[thread] |- [message] |- [message] |- [message] |- [message] |- [message] |- [message]
Each message has a subject and body. Messages are authored by a user in the system or can be anonymous. An ID is given to each message so that it can be tracked uniquely. Because is possible that one might want to store considerable more information with each message besides a subject and body, each message can have an arbitrary number of properties. For example, a property "IP" could be stored with each message that records the IP address of the person posting the message for security reasons.
The creation date, and the date the message was last modified are maintained for each message.
For added functionality, any number of filters can be applied to a message. Filters dynamically format the subject and body of a message. Methods are also provided to bypass filters. @see ForumMessageFilter
javax.jms.Message
interface. A Joram message encapsulates a proprietary message which is also used for effective MOM transport facility.
Message
class actually provides the transport facility for the data exchanged during MOM operations. A message content is always wrapped as a bytes array, it is characterized by properties and "header" fields.
Message
data structure.
There are two distinct parts to a message:
TransientObject
A message can have one of several {@link Type Types}. For each message type, different message fields are typically used as follows:
Message type | |||||
Field | Normal | Chat | Group Chat | Headline | Error |
subject | SHOULD | SHOULD NOT | SHOULD NOT | SHOULD NOT | SHOULD NOT |
thread | OPTIONAL | SHOULD | OPTIONAL | OPTIONAL | SHOULD NOT |
body | SHOULD | SHOULD | SHOULD | SHOULD | SHOULD NOT |
error | MUST NOT | MUST NOT | MUST NOT | MUST NOT | MUST |
MessageManager
. A message has the usual attributes (author, boards to which it is posted, etc.) one would assume. There are two unique ways to reference a message: It's URI and it's message ID. The URI is to be given to the user if he wants to tell other people about the message, the message ID is to be used for querying the database for a message in a fast way. Activation policy: Class Message does automatic activation on its own. This means that objects of class Message can be activated to a depth of only 1 when querying them from the database. All methods automatically activate the object to any needed higher depth.
@author xor (xor@freenetproject.org)
@author saces
There are no restrictions on the syntax of the items. If constructing a message string by hand, however, take care that all sequences of consecutive colons (::) correspond to message separators; otherwise, the message will be decoded incorrectly. Additionally, if colon-slash sequences (:/) exist in an item, they will be modified by the decoding methods. In both these cases, adding a slash after the first colon will allow correct decoding of the message items; this is precisely what is done when messages are encoded normally, to allow for arbitrary syntax of message items.
Note that the shortest valid message is a single colon (:) (message with no header and no body) and that all messages must have at least one colon.
As of version 6.1, the internal encoding of messages is handled with arrays of bytes, to prevent conversion errors when encoding byte arrays as strings. For the basic types, these arrays correspond to the byte representation of the items' string representations, not their internal numeric representation. Byte array accessors were added to manipulate these items directly as byte arrays, for serialized objects or raw byte payloads. @author Andres Quiroz Hernandez @version 6.19
content
and binaryContent
, respectively. Messages store a number of other fields for a variety of purposes, including:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|