JXTA 点对点管道通信

P2P点对点进行通讯是在管道进行通讯的。

主要是PipeAdvertisement：管道通告 InputPipe：输入管道，用于接收消息 OutputPipe：输出管道用于发送消息

package first;

import java.io.IOException;
import java.util.Enumeration;

import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.endpoint.Message;
import net.jxta.endpoint.Message.ElementIterator;
import net.jxta.endpoint.MessageElement;
import net.jxta.endpoint.StringMessageElement;
import net.jxta.id.IDFactory;
import net.jxta.peergroup.PeerGroup;
import net.jxta.pipe.InputPipe;
import net.jxta.pipe.OutputPipe;
import net.jxta.pipe.PipeService;
import net.jxta.platform.NetworkConfigurator;
import net.jxta.platform.NetworkManager;
import net.jxta.platform.NetworkManager.ConfigMode;
import net.jxta.protocol.PipeAdvertisement;

public class Chat {
	private NetworkManager networkManager = null;// 配置
	private PeerGroup netWorkPeerGroup = null;// 对等组
	private DiscoveryService discoveryService = null;// 发现服务
	private PipeService pipeService = null;// 管道服务
	private InputPipe inputPipe = null;// 输入管道
	private OutputPipe outputPipe = null;// 输出管道
	Enumeration<Advertisement> enumeration = null;

	// 初始化配置
	public void init(String name) {
		try {
			// 相当于jxta的配置,如果不写的话会出现配置页面,手动配置也可
			networkManager = new NetworkManager(ConfigMode.ADHOC, name);
			// 在一台pc测试的时候,端口号不能一致,这里修改下端口号
			NetworkConfigurator configurator = networkManager.getConfigurator();
			configurator.setTcpPort(9703);
			configurator.save();
			// 启动创建对等组
			// netWorkPeerGroup=new NetPeerGroupFactory().getInterface();
			netWorkPeerGroup = networkManager.startNetwork();
			// 初始化discoveryService和pipeService
			discoveryService = netWorkPeerGroup.getDiscoveryService();
			pipeService = netWorkPeerGroup.getPipeService();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 创建一个管道通告
	public PipeAdvertisement createPipeAdvertisement(String name) {
		PipeAdvertisement advertisement = (PipeAdvertisement) AdvertisementFactory
				.newAdvertisement(PipeAdvertisement.getAdvertisementType());
		advertisement.setPipeID(IDFactory.newPipeID(netWorkPeerGroup
				.getPeerGroupID()));
		advertisement.setName(name);
		advertisement.setType(PipeService.UnicastType);
		return advertisement;
	}

	// 发布通告
	public void publish(PipeAdvertisement advertisement) {
		try {
			discoveryService.publish(advertisement);
			discoveryService.remotePublish(advertisement);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 初始化管道
	public void initPipe(String name) {
		// 管道通告,相当于名片
		PipeAdvertisement advertisement = createPipeAdvertisement(name);
		// 发布 告诉别人我是谁
		publish(advertisement);
		try {
			// 初始化管道
			inputPipe = pipeService.createInputPipe(advertisement);// 输入通道
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 找你想聊的人
	public PipeAdvertisement discover(String name) {
		int count = 3;// 担心一次连不上
		while (count-- > 0) {
			try {
				// 先从本地缓存里头找
				enumeration = discoveryService.getLocalAdvertisements(
						DiscoveryService.ADV, "Name", name);
				if (enumeration != null && enumeration.hasMoreElements()) {
					PipeAdvertisement pipeAdvertisement = (PipeAdvertisement) enumeration
							.nextElement();
					return pipeAdvertisement;
				}
				discoveryService.getRemoteAdvertisements(null,
						DiscoveryService.ADV, "Name", name, 1, null);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	// 发送信息
	public void sendMessage(String name, String msg) {
		try {
			outputPipe = pipeService.createOutputPipe(discover(name), 0);
			// 发送的信息
			Message message = new Message();
			StringMessageElement string = new StringMessageElement("data", msg,
					null);
			message.addMessageElement(string);
			outputPipe.send(message);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 接收消息
	public void receiveMessage() {
		while (true) {
			try {
				// 接收
				Message message = inputPipe.waitForMessage();
				// 解析获取到的信息
				ElementIterator messageElements = message.getMessageElements();
				if (messageElements != null) {
					while (messageElements.hasNext()) {
						MessageElement next = messageElements.next();
						System.out.println("接收到消息:" + next.toString());
					}
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public void stop() {
		// 停止服务
		networkManager.stopNetwork();
	}

	public void start() {
		init("peer1");
		initPipe("peer1");
		discover("peer2");
		sendMessage("peer2", "hello!!!!");
	}

	public static void main(String[] args) {
		Chat chat = new Chat();
		chat.start();
	}
}

还有一种是基于监听事件的接收消息PipeMsgListener

Chat implements PipeMsgListener后

@Override

public void pipeMsgEvent(PipeMsgEvent event) {

Message message = event.getMessage();

// 解析获取到的信息

ElementIterator messageElements = message.getMessageElements();

if (messageElements != null) {

while (messageElements.hasNext()) {

MessageElement next = messageElements.next();

System.out.println("接收到消息:" + next.toString());

}

}

}

只要有消息发送过来就可以接收到。