ONJava.com -- The Independent Source for Enterprise Java
oreilly.comSafari Books Online.Conferences.


AddThis Social Bookmark Button

Hello JXTA!
Pages: 1, 2, 3

Hello JXTA

Let's start with building something simple, a service that will run in the Java binding, open a listening input pipe, and wait until a message has been received from the pipe. The service will also provide a single method that can be invoked to find a random peer's hello service input pipe and then send it a single message.


First we have to define the interface that the Service is going to export to any application running within the platform. We're going to build a very simple one, only providing a single method that finds a peer running HelloService, opens a pipe to it, and sends it a small message.

public interface HelloService
extends net.jxta.service.Service {
  // find another peer to send a message to, then send 
  // it a message
  public void sendMessage();



Next we need to provide an implementation of the service for the platform to run. Initialization of this service should be dealt with first.

public class HelloServiceImpl
extends Object
implements HelloService {
  // a handle to the discovery service
  private Discovery discovery;

  // a handle to the pipe management service
  private Pipe pipes;

  // the peer group that this service is being
  // booted into
  private PeerGroup peerGroup;

  // the advertisement for the peer group
  private PeerGroupAdvertisement peerGroupAdvertisement;

  // the advertisement for this service
  private ServiceAdvertisement serviceAdvertisement;

  // the advertisement
  private PipeAdvertisement helloPipeAdvertisement;

  // initialize this service
  public void init( PeerGroup group, Advertisement advertisement )
  throws PeerGroupException {
  // save away all the variables given to us
  this.peerGroup = group;
  this.peerGroupAdvertisement = group.getAdvertisement();
  this.serviceAdvertisement = (ServiceAdvertisement)advertisement;

  // get handles to the services that we are going to need later
  this.discovery = this.peerGroup.getDiscovery();
  this.pipes = this.peerGroup.getPipe();

  // start the application running
  startApp( null );


  // provide the ability to get a handle to this
  // service. in more robust services, a proxy object
  // should be passed out to protect the service from
  // malicious applications
  public Service getInterface() {
  return this;


  // simply return the service advertisement that
  // has been passed to us
  public Advertisement getAdvertisement() {
  return this.serviceAdvertisement;


Next we provide a method to start the service. This service creates a pipe to listen for incoming messages. When it gets a message, it writes to System.out who sent the message. Before we open the pipe, however, we need to publish the pipe advertisement into the peer group so that other peers may find it.

// a simple helper function that will create a pipe advertisement
// for the input pipe that we are going to open up
private PipeAdvertisement createPipeAdvertisement() {
  try {
  // create the pipe advertisement object
  PipeAdvertisement pipeAdvertisement = (PipeAdvertisement)AdvertisementFactory.newAdvertisement( PipeAdvertisement.getAdvertisementType() );
  pipeAdvertisement.setPipeID( new PipeID( this.peerGroup.getID() ) );

  // create a simple name for the pipe that we can do
  // an easy lookup on when we are searching later on
  pipeAdvertisement.setName( "HelloService:" + this.peerGroup.getPeerID() );

  return pipeAdvertisement;
  } catch( InvocationTargetException error ) {
  System.err.println( "problem creating the pipe advertisement" );
  return null;



// the input pipe that this service is going to be
// listening on
private InputPipe helloPipe;

// the thread that the service is going to be
// running within
private Thread runningThread;

// start this service -- calling this method will spawn
// a thread that we can use to listen for messages coming
// down the pipe
public int startApp( String[] arguments ) {
// create the pipe that we are going to use to listen for
  // messages
  try {
    // now we are going to publish the pipe that we are
  // going to use both in our local cache and into the
  // caches of the other peers in this peer group
  this.helloPipeAdvertisement = createPipeAdvertisement();
  if( this.helloPipeAdvertisement == null )
   throw new PeerGroupException();
  this.discovery.publish( this.helloPipeAdvertisement, Discovery.ADV );
  this.discovery.remotePublish( this.helloPipeAdvertisement, Discovery.ADV );

  // create the input pipe that we can use
  this.helloPipe = this.pipes.createInputPipe( this.helloPipeAdvertisement );

  } catch( IOException error ) {
  System.err.println( "problem publishing the advertisement for the input pipie" );

  } catch( Exception error ) {
  System.err.println( "problem opening the pipe to read from" );

  } finally {
  if( this.helloPipe == null ) {
  System.err.println( "do not have a pipe to read from" );
    return 1;


  // start a listening thread that constantly listens
  // for messages on the input pipe. as a standard, we choose to
  // format our messages with a "sender" symbolic name that
  // contains the peer id that sent us the message. when
  // a message comes down the pipe, we will just write
  // something to System.out
  this.runningThread = new Thread( new Runnable() {
    public void run() {
    try {
    // block until we receive a message
      Message message = null;
      while( ( message = HelloServiceImpl.this.helloPipe.waitForMessage() ) != null ) {
      // see if this thread has been
      // interrupted
      if( Thread.isInterrupted() )

      // read the sender information
      InputStream senderInputStream = message.pop( "sender" );
      byte[] senderBytes = new byte[senderInputStream.available()];
      senderInputStream.read( senderBytes );
      String sender = new String( senderBytes );

      // print out the information from this message
      System.out.println( "\"" + sender + "\" says hello" );

    } catch( IOException error ) {
    System.err.println( "problem reading from the input pipe" );
    } finally {



  // start running the listening thread
  return 0;


// the corresponding method to startApp -- this
// interrupts the currently running thread
public void stopApp() {
if( this.runningThread != null )


Pages: 1, 2, 3

Next Pagearrow