JXTA is a set of open, generalized Peer-to-Peer (P2P) protocols that allow any . JDK in your machine and to download JXTA jxse-lib, tutorial, documents, src. Introduction to JXTA Peer discovery and pipe messaging. The guide . setDescription(“Tutorial example to use JXTA module advertisement. package orld;. import kManager;. import eFormat;. import ;. /**. * A simple example which.

Author: Gardakree Arashizragore
Country: El Salvador
Language: English (Spanish)
Genre: Health and Food
Published (Last): 16 February 2015
Pages: 323
PDF File Size: 3.18 Mb
ePub File Size: 10.41 Mb
ISBN: 783-1-14882-149-2
Downloads: 70951
Price: Free* [*Free Regsitration Required]
Uploader: Bragor

Instant messaging, either local within an Intranet, wide-area inside an enterprise, or global over the Internet, is quickly becoming a ‘killer application’ for P2P technology. Unfortunately, most P2P networks existing today either have a proprietary development system, or complex open source APIs and operation models that take weeks or even months to understand.

Tutodial only there were a way to get on-board the P2P train quickly, and absorb the intricate lower-level details at tutorila own pace. This article introduces a one-afternoon solution to writing an instant messaging application based on the JXTA network.

The P2P application we’ll create will be called the VSJ World Wide Messenger wwmand will enable users to send instant messages to one another without any centralized server support. Instant IDE development using the IMBean Our development cycle is greatly tutorual in this case because all the complex code involved in communicating with the P2P network and handling the messaging protocol is eliminated from the application, as it has been factored into a reusable, drag-and-drop deployable, JavaBean.

The IMBean is located in the imbean. Figure 1 illustrates jxt the IMBean can do for us. The only tasks we have to perform in our own code are to: Accept user input outgoing messages and send it via the IMBean Hook up an event handler to receive incoming messages To use the IMBean in your own chat application, follow these programming steps: JTextFielda UI element to display all messages i.

JTextAreaand a UI button to send messages After the initialization tutoril of the GUI, add code to call the initBean method of the IMBean to “boot” the bean In the actionPerformed handler of the UI button, retrieve the input message and call the IMBean’s sendMessage method to send the message Hook up an event handler for IMBean’s MessageReceivedEvent usually by selecting the Events tab in the IDE’s properties panel when the IMBean is selected ; in this handler, access the incoming message via the event’s getMessageText and getSender methods, add this incoming message to the message display UI element set up in step 2 That’s all there is to it — an instant messaging application in five simple steps.

If you are not using an IDE, you can follow the steps by examining the source code supplied. Once the bean is on the palette, drag and drop it into the GUI we create in Step 2shown next. The layout is shown in Figure 2, together with the type and name of each GUI component.

The GUI for the example The class we are creating is located in the uk. The skeletal code generated by the IDE is: Do NOT modify this code. Font “Dialog”, 0, 10 ; jPanel1. Font “Dialog”, 2, 12 ; jTextArea1.

Dimension; jTextArea1. Dimension; jPanel2. IMBean chatBean1; private javax. JButton jButton1; private javax. JPanel jPanel1; private javax. JPanel jPanel2; private javax. JTextArea jTextArea1; private javax.

This is done by modifying the generated constructor for VSJChat, shown in the code below. All we need to know is that it will allow us to join existing IM sessions with the supplied user name. It is also in the localInit method where we can tutoial other available parameters of the IMBean such as its alias and topic properties. These properties are not used by our simple VSJChat application, but other applications may use these properties to provide additional functionality tutoriwl of messages, etc.


We then input a handler’s name, “SendClicked” in our case. This will create a handler method for us in VSJChat automatically.

IM over JXTA – Java tutorial – developer Fusion

The code generated includes the listener subscription code: We fill in the method to grab the user’s input and send jxtq using the IMBean as shown below. This can be done by handling the actionPerformed event of the jTextField1 component.

This registration code is generated. The IMBean supports two models of message handling — event handling and polling. Depending on your application, you can use either method. We will be using the event handling approach.

If you are tutrial the polling model, you can check to see if an incoming message is available at any time by calling IMBean’s getAvailableMessages method. If messages are available, they can be retrieved one at a time using the getChatMessage method. To add a listener to the IMBean’s MessageReceived event, we can use the IDE by highlighting the IMBean component in the component hierarchy display, and selecting the “event” tab in the property sheets. We will call this event handler “messageHandler”.

The code generated by the IDE includes the event subscription code, shown below. Here, we fill in the logic to retrieve the incoming message and update the messages displaying jTextArea. We can now compile the code and test the IM application.

JXSE and Equinox Tutorial, Part 1

Otherwise, the source distribution has a compile. You should have this JXTA 2 platform installed on your machine before building and testing the application. Configuring a JXTA network for testing The JXTA platform is designed to be highly generic and flexible, adaptable to a variety of networking topologies and application environments.

This often makes it appear to require complex configuration.

java – How do I discover peers and send messages in JXTA-JXSE ? – Stack Overflow

After this initial configuration, the configured state is stored in a. The JXTA chat configuration We can see in the figure that we are pointing two edge peers called peer1 and peer2 to a peer acting as a known rendezvous called rendz1.

JXTA uses a peer network of “rendezvous” machines to handle distributed communications. A JXTA peer starting up must connect to a rendezvous before starting message transmission. The JXTA platform offers discovery mechanisms to automatically locate a “rendezvous”, we will not use them in this scenario to simplify the testing. Although we’ve set up a dedicated peer for rendezvous in this test configuration, it is not strictly necessary.

Any peer can become a rendezvous at any time on the JXTA platform. In fact, under JXTA 2, a peer will become a rendezvous automatically if it fails to locate any available rendezvous after a configurable time period, we are avoiding this adaptive behavior to make our testing more predictable. Assuming that you’re simulating all 3 peers on the same machine during testing, the following are the different configurations that you will need for each peer.

You can configure for three different machines by changing the IPs below. The hypothetical IP we will use for my single test machine is: First, create the rendezvous peer, which can be started using the runit. If you look into the runit. For this peer, enter the configuration shown in the table below when prompted by the configurator: Use the configuration shown below: This peer can be started via the runit.


Try typing in some messages, you should see something similar to Figure 4. Let us take a brief look at how these pieces fit together. Also in the figure, we can see that JAL provides an effective insulation between applications, the JavaBeans, and the harsher programming environment of the raw JXTA platfom. JAL provides a significantly simpler programming model.

You can browse the simple source code of IMBean at ezel. Instead, it abstracts the common elements that are often found in other P2P system. The programming model is quite simple, and consists of the following steps: Boot the peer Find out what other peers are available Start sending messages to other peers JAL also optionally supports the notion of group.

A peer can join and leave a group at any time. Once joined, only the peers in the same group will be visible. As with peers, groups are identified purely by a string name in JAL. The main programming interface for JAL is the net. This interface specifies the methods that all Peer implementations must provide. Here is the definition of the Peer interface: The group handling methods are optionally used, because by definition all JXTA peers boot into a default group called netpeergroup.

The displayXXX information utility methods print directly to the console, and are typically used in debugging and diagnosing problems. The message handling methods enable you to attach any serialisable Java object to the message and send the message. The attached object s are tagged with a String name, and can be easily retrieved at the receiver end.

While the exercise is certainly interesting on its own, readers are urged to ponder its greater implications.

In fact, stepping back a little, you can easily think of hundreds of other uses for IMBean’s features that do not involve chatting or a GUI. Consider a “lowest airfare spotting system” that enables flyers worldwide to report and share their instantaneous sightings on the various web-booking systems.

Or a spontaneous buy-and-sell network of people offering and bidding for goods or services? The possibilities are limitless. Consider also that, starting with JXTA 2, the platform is scalable to literally thousands of users joining and leaving the “group” in an ad-hoc manner.

They can all be using your P2P application, without the need for a single centralized server! Yet, all of the new features and enhancements of the new platform releases are immediately available to the application. Sing Li is a consultant, trainer and freelance writer specialising in Java, Windows NT and distributed object technologies. You might also like Comments About the author Sing Li Sing Li has been writing software, and writing about software for twenty plus years.

His specialities include scalable distributed computing systems and peer-to-peer technologies. Interested in writing for us? Why not write for us?