网上聊天室的设计与开发(课程设计)

课程设计

题目：网上聊天室的设计与开发

第一章引言

1.1 课题的提出

1.1.1需要解决的问题

该课题要研究的是采用JXTA技术来创建网上聊天室。该聊天室应该能够体现对等网络（P2P）交互的思想，不依赖于中间服务器而实现用户之间的直接通信，聊天。聊天的各个用户应该是完全的对等体。

1.1.2对问题的分析以及解决方法的提出

传统的网上聊天室采用的是客户/服务器模式，聊天的用户要想聊天必须首先登陆服务器，在服务器上验证之后，再由服务器向用户提供服务。这种模式对服务器的性能，以及资源要求比较高。而本课题研究的是如何采用对等网络(P2P)技术来创建网上聊天室。由于P2P技术是一项比较新的技术，目前在P2P领域做的比较好的要数JXTA技术了，因此考虑采用JXTA技术来创建网上聊天室。至于聊天室具体的实现，可以用java，也可以采用C#，本课题立足于java编程语言来实现这个网上聊天室。

1.1.3存在的需要解决的问题

1．该课题研究的是采用P2P技术来构建网上聊天室，因此在对传统的客户/服务器模式有所了解的基础上，应该发挥出P2P技术的特点。所以必须对P2P技术很熟悉。

2．P2P技术是一个比较笼统地概念，要完成P2P技术的聊天室，必须选定一个支持P2P技术的开发平台。在此平台下来进行聊天室的创建。

3．创建的聊天室应该能够实现各个用户之间的实时交互，并且具有C/S模式聊天室的一些基本功能。并能切实的发挥出P2P技术的优势。

1．2 JXTA技术的背景以及采用该技术创建网上聊天室的可行性

对等网络P2P (Peer to Peer) 是因特网实现下一次飞跃的关键, 在P2P 网络模式的研究领域里, JXTA (juxtapose , 并行) 作为一种全新的P2P 网络解决方案已经日益受到关注。

1．2.1P2P 概述

P2P(Peer to Peer) 技术,中文译为对等互联或点对点技术。在P2P 网络中没有指定的客户机(Client) 、服务器(Server) 的概念,任何节点都可能成为客户机或服务器。从本质上说,P2P 网络提供了一种在不需要超强中心服务器情况下将各个PC 机联接起来的解决方案。

目前,大多数分布式网络都采取客户/ 服务器模式,在这种模式中,客户请求服务,服务器提供服务。这种模式是集中式网络模式的典型代表,整个网络完全依赖于中心节点—服务器来提供服务,一旦服务器出现故障,整个网络则近乎瘫痪。

不同于客户/ 服务器模式,P2P 网络是一种分散式的网络模式,如图1 所示。在这种网络模式中不存在固定的客户、服务器,网络中的每一个实体称为对等体(Peer) ,它们具有对等的地位,这意味着任何实体都可以向其它实体请求服务(作为客户) 或给其它实体提供服务(作为服务器) 。图1 说明了这种网络模式的结构。虽然所有的对等体都具有相同的地位,但它们并不具备相同的物理处理能力。P2P 网络中包含着从移动设备到大型主机等各种具有不同能力的对等体。可移动对等体可能由于自身条件的限制并不能成为其它对等体的服务器,但是这并不会影响整个P2P 网络的性能。

当然,这两种网络模式都各有优缺点。在客户/服务器模式中,随着客户机的不断增加,中心节点—服务器的压力会越来越大。客户机的增加意味着服务器性能的削弱,而服务器的故

障又将导致整个网络的崩溃。而在P2P 网络中,每个实体都是网络活动的积极参与者,它们为P2P 网络提供了诸如存储空间、CPU 等资源,随着对等体的不断增加,网络的处理能力和存储能力也随之增强,所以并不会出现上述客户/ 服务器网络的不足。理论上讲,在P2P 网络中只要有一个对等体还处于活动状态便可认为P2P 网络仍然可以继续运行,这一点是不同于客户/服务器网络模式的。当然,P2P 网络也有缺陷,它不易管理,它的安全策略、备份策略等都造成了系统管理的复杂。另外,由于每个对等体均可任意的加入或离开P2P 网络,因此, P2P 网络协议的交互性较强,这对网络的性能也有一定的影响。

图1-1 The peer to peer model

1．2．2 JXTA 技术

1.2.2.1 概述

JXTA技术是由SUN公司在2001年2月提出的一项新技术，主要用于提供P2P程序所需的基础服务。该技术致力于创建一个通用的平台，以简单而有效的方式构建特定的对等式和分布式服务与应用，使得开发者不需要过多考虑如何解决对等计算的技术问题，而可以专注于如何实现与完善可扩展、互操作性强且具有高可用性的高层应用。

不同的协议、不同的体系结构、不同的实现机制准确的描述了当前P2P 解决方案的特点,开发者使用不同的方法开发P2P 应用程序,由于没有统一的标准,通用性很差。鉴于

此,Sun 公司提出了JXTA 技术。

JXTA 技术提供了建立P2P 网络应用的核心技术,旨在为P2P 应用建立一个通用的开发平台。JXTA 技术主要包括一个独立于编程语言、系统平台和网络平台的协议集,这个协议集说明了P2P 应用的最基本的需求。可以说,JXTA 是位于操作系统或虚拟机之上、P2P 网络服务或应用之下的一个P2P 堆栈,它提供了P2P 应用所需的核心功能。

目前,JXTA 定义了六个协议,但并不是每一个JXTA 对等体都必须实现这六个协议,它需要实现哪些协议是由对等体自身的能力决定的。建立在TCP/ IP 协议之上的各个应用并不具备交互能力,同样建立在JXTA 协议之上的应用也不具备交互能力,要实现这种交互,开发者必须自行开发。提供基础协议的第一步是要选择大部分平台都可理解的数据表达方式,JXTA 采用XML (eXtensible Markup Lan2guage) 来实现数据的表示。XML 语言是一种通用的、独立于语言、独立于平台的数据表达方式,而且它易于转化为其它编码形式。因此,JXTA 用XML语言定义了所有的协议。

1.2.2.2JXTA 的术语

对等体( Peers) : 对等体是任意能够使用JXTA协议的实体。对等体可以表现为一台大型机、一部移动电话、一个进程等等。每一个对等体都是独立存在的,它和其它对等体进行

异步通讯。

对等体组( Peer Groups) : 对等体组是一个支持对等体组协议的虚拟的实体。一般来说,对等体组就是一组相互合作提供公用服务的对等体的集合。JXTA 对一个对等体或对等体组的产生次序并不关心,它也不限制对等体可同时参加的组数以及是否可以生成嵌套的组。它仅仅定义了如何使用对等体发现协议(PDP) 来发现一个对等体组。对等体组中有一个特殊的组称为世界对等体组(the World PeerGroup) ,它包含所有的JXTA 对等体。虽然所有的JXTA 对等体都属于世界对等体组,但并不意味着在这个特殊的组中所有对等体都一定能够相互发现或通信,因为它们可能被网络分隔开来。默认情况下,每一个对等体都参与到世界对等体组当中。

消息(Messages) :在JXTA 网络中,所有的通信都是通过发送和接收消息实现的。消息用于异步的、不可靠的、单向的传输,它被设计成一个数据报的形式,包含封装体和带有协议头堆栈的主体。这个封装体包含头部、消息摘要、源端点和目的端点。一个端点就是一个逻辑目的地, 以URL (Universal Re2source Locater) 的形式给出。通过消息层可以将端点映射为物理地址。每一个协议主体都包含可变数量的字节。

管道(Pipes) :管道是一种异步的、单向的、用于收发消息的虚拟信息通路。管道有输入管道和输出管道。一个管道端点可以绑定到多个对等体节点。通过管道绑定协议( PBP) ,管道可在运行时刻动态绑定到一个对等体节点。在不同的时刻,同一管道可以绑定到不同的对等体。例如,当一个对等体组提供高级的容错服务时,一旦有一个对等体失效,只需要将管道重新绑定到新的对等体上就可以保证系统继续顺利运行。管道将两个对等体联系在一起,对于发送方来说是输出管道,对于接收方来说它是输入管道,传输是由发送方到接收方的单向传输。传播管道可以将一个输出管道与多个输入管道相连,这样,任何一个发向输出管道的消息将被发向所有与之相连的输入管道。管道可以使用任何单播或多播协议以及它们的算法。实际管道可以串接在一起,串接的每一段可以使用完全不同的传输协议。

代码/ 数据(Codat 即Code/ Data) :在JXTA 中Co2dat 是指文本内容,它可以是代码或数据。Codats 可以被发布、发现或复制。

服务(Services) :对等体和对等体组都可提供服务。对等体服务是由单个对等体提供的,一旦对等体出现问题,服务就可能不复存在;对等体组服务是由多个对等体提供,因此具有更强的可靠性。

广告(Advertisements) : 广告用于发布或发现任何JXTA 资源,包括对等体、对等体组、管道或Co2dats ,广告表示成XML 的形式。标识符( Identifiers) :标识符用来唯一标识一个实体(如对等体、广告、服务等) 。JXTA 的标识符定义为URN(Uniform Resource Name) 的形式,URN 实际就是URI (Uniform Resource Identifier) ,它可唯一标识资源。

1.2.2.3JXTA 协议

对等体发现协议( Peer Discovery Protocol 即PDP) :该协议是包括世界对等体组

( the World PeerGroup) 在内的所有对等体组的默认发现协议。对等体通过PDP 协议发现已经发布的JXTA 资源。由于使用广告表示资源,所以PDP 实际上用于发现其它对等体上的广告。

对等体解析协议(Peer Resolver Protocol 即PRP) :在JXTA 网络中,对等体向其它对等体发送请求以寻求所需服务,PRP 协议用于标准化请求的格式。

对等体信息协议( Peer Information Protocol 即PIP) :PIP 协议使一个对等体能够了解其它对等体的信息和状态。例如:可以发送一个Ping 消息来判断一个对等体是否已经激活。如果对等体的属性有名字和值,可以通过本协议得到它的属性信息。

对等体成员资格协议( Peer Membership Protocol即PMP) :对等体可通过PMP 协议加入或离开对等体组。PMP 协议包括四个独立的部分: 申请( ap2ply) 、加入(Join) 、更新

( renew) 、取消(cancel) 。每一部分都定义了相应的JXTA 消息格式。权力认证和安全管理可以提供相应等级的保护。

Apply:如果一个对等体对某一个组感兴趣,便可以向这个组的认证机构发送申请

求;Join :申请之后,对等体就可发送加入请求;Renew:如果对等体需要更新它在组内的成员

信息,可以发送更新请求;Cancel :对等体可以通过发送离开请求选择离开这个组。

管道绑定协议(Pipe Binding Protocol 即PBP) :在JXTA 环境中,对等体通过管道访问服务,它可以在运行中时时绑定到一个管道的端点以便访问服务。对等体还可以创建新的服务、绑定到一个存在的管道或解除管道绑定。这些情况下都用到了PBP 协议。从某种意义上来说,一个管道可以看作是一个支持新建、打开、关闭、删除、发送、接收等抽象操作命名的消息队列。绑定发生在打开操作阶段,而解除绑定发生在关闭阶段。

端点路由协议( Endpoint Routing Protocol 即ERP) :该协议可以保证一个对等体向另一个路由对等体问询到达目的地的可用路径。一般两个通信的对等体并不直接相连。例如,

两个使用不同网络协议的对等体或被防火墙和网络地址转换(NAT) 分隔的对等体。对等体路由用有效的路由信息来响应请求,通常路由信息是这条路径所经过的网关列表。

1.2.2.4JXTA 体系结构(Architecture)

JXTA 软件的体系结构分为三层,其层次结构如图2 所示。

图1-2 The JXTA Layer - Cake

从图2 可以看出,最底层是平台层即核心层,这一层包含了P2P 网络的最基本的要素,如对等体或对等体组(Peer) 的建立、资源发现、通信管理(如路由等) 和其它一些底层的服务。中间层是服务层,在这层中提供诸如索引、查找、文件共享、协议转化、授权服务、PKI (Public Key Infrastructure) 服务之类的高级服务。这些服务需要大量调用由核心层提供的基本操作。高层是应用层,它主要提供诸如邮件、存储之类的服务。当然,一些特性如安全管理在这三层中均有体现并贯穿于整个P2P 系统。

JXTA 的体系结构与其它分布式网络实现模式的区别主要表现在以下三个方面:

.JXTA 使用XML 文档来描述网络资源;

.JXTA 网络中不使用中心命名机制和中心寻址机制;

.JXTA 网络采用统一的对等体寻址机制

1.2.3 采用JXTA技术创建聊天室的可行性

由本课题的要求来看，采用P2P技术创建网上聊天室，由于JXTA技术是P2P技术的开发平台，所以，在JXTA平台上可以自己编程实现网上聊天室。JXTA非常适合编写聊天程序，而且可以有多种实现方法，包括完全的集中式、代理方式到完全非集中式。而且一个非常有意思的情况是，用JXTA来实现一个集中式的聊天程序非常困难，而实现完全非集中式的聊天程序反而简单，因为JXTA平台本身已经完全解决了底层Peer之间的发现和通信问题。

1.2.4 聊天室编程的实现语言的选取

虽然JXTA技术是独立于语言的，可以采用C#或者是java编程语言。但是在实现该聊天室的时候，采用了java语言作为开发工具。因为java在开发P2P程序方面有其固有的优势，主要是在各个平台之间的可移植性。Java提供我们详尽的API，可以建立相当好的平台。

1．3 课题的目的

本课题目的在于采用现在比较新的技术P2P技术来创建网上聊天室，该聊天室应该能够实现点对点客户直接交互，包括一对一，多对多的用户之间的不依赖于服务器的直接通信。

第二章总体设计和概要说明

2.1 设计前的准备

2.1.1 建立Java环境

使用JXTA首先要建立环境，必须为运行JXTA建立Java环境。为此需要三个要素：Java

平台，JXTA类库和需要运行的JXTA程序。

首先是建立Java平台。要提供Java平台，需要Java2标准版（J2SE的1.3.1版或者更高版本），本次设计安装了1.4版的。对于JXTA编程，还需要Java2软件开发包（SDK）。在安装了Jdk之后，还需要配置Java环境变量。

其次，是获得JXTA类文件和程序。JXTA的类库可以从网上站点

https://www.360docs.net/doc/ec8599380.html,/easyinstall/install.html下载。由于使用的是Windows操作系统，故下载了可执行（.Exe）文件.。按照提示进行安装。为了编程实现的方便，还安装了JCreator3.10。

2.1.2 JXTA应用程序配置

在安装了JXTA之后，还需要打开JXTA configurator tool（JXTA配置管理器）进行配置，配置的信息保存在本地目录中。配置信息还包含了一个本地端口号，JXTA应用程序将在该端口上进行监听。

2.2 设计思路与模块划分

本次设计将根据聊天室的具体实现功能而将设计分成三个部分来完成，这三部分是：发现服务通告；构建JXTA管道使得对等体相互通信；使JXTA聊天程序成为服务。其中使JXTA程序成为服务将在发布通告和JXTA管道进行通信的部分说明。因为无论是发布通告还是构建管道都是与使JXTA成为服务密不可分的。

本次设计的主要程序包有以下几个：

net.jxta.discovery包

对等体使用net.jxta.discovery包中的发现服务去发现JXTA环境中的资源。对等体使用发现服务去发现已发布的通告，包括对等组，管道和网络服务的通告。当发现服务查找到一个新的资源时，就发送发现事件对象。发现事件被发送到该监听者的DiscoveryEvent()方法。

实现DiscoveryListener接口的对象能够在发现服务中注册，当找到新的通告，它将调用这个已注册对象的DiscoveryEvent()方法，并向该方法传递一个DiscoveryEvent对象。

DiscoveryService接口通过PeerGroup类的getDiscoveryService()方法来获得特定的对等组的发现服务。应用程序使用getRemoteAdvertisement()方法寻找未缓存的通告。该方法使用PDP发送发现消息，发现事件监听者通过调用addDiscoveryListener()方法在发现服务中注册，当发现了新的通告，该监听者将被调用。

net.jxta.peer包

该程序包中包含了处理JXTA对等体信息的类，获取对等体信息的过程与发现对等体的过程相同：先查询本地缓存中的对等体通告，再查询提供远程对等体信息的对等体服务。

net.jxta.peergroup包

JXTA对等体通过调用PeerGroup类的newGroupFactory()方法来加入MyJXTA对等组，该方法返回一个对等组对象。

net.jxta.pipe包

管道是对等体之间进行通信的主要手段。InputPipe用于读取其它对等体发来的消息，createInputPipe()方法用于创建输入管道。OutputPipe用于向其它的对等体发送消息，createOutputPipe()方法用于创建输出管道。当一个输入管道连接到一个输出管道时，管道间的路径必须被解析。管道路径的解析用OutputPipeEvent类来表示。

第三章发现服务通告

3.1 通告的使用与构造

3.1.1 通告的使用

通告是JXTA的核心，只有通过寻找通告才能发现JXTA的对等体及其资源，而且只有

通过发布通告才能向外界提供自己的服务。

通告由抽象类Advertisement表示，每个通告都有一个唯一的类型，用getAdvertisementType（）方法获取该类型。JXTA API定义了以下的核心通告类型：PeerAdvertisement

PeerGroupAdvertisement

PipeAdvertisement

PeerInfoAdvertisement

EndpointAdvertisement

TranseportAdvertisement

获取通告对象有两种途径，首先是创建通告对象。当发布通告时，必须创建通告对象。其次，可以通过PeerGroup类的getPeerGroupAdvertisement()方法获取用于创建对等组的通告。

3.1.2 通告的构造

通告对应着不同的资源，虽然各种通道的类型不同，但是它们的创建方式相同。首先，从AdvertisementFactory类获取一个空白的通告文档。然后使用特定类型的通告内部的方法来设置通告文档中的各个要素。

3.2 JXTA发现

聊天的对等体首先要做的是了解其周围环境。对等体在四周环境中寻找资源，支持自身，访问需要的服务以及支持自己的范围。用户要找人聊天，首先必须发现并加入聊天组。当然，不能保证用户进入聊天室的时候，聊天组已经存在，所以peer用户必须好去创建聊天组。

JXTA中的发现是在对等组环境中执行的，每个对等体都会加入到MyJXTA对等组中。在MyJXTA环境中执行的发现使得任何对等体都可能发现在MyJXTA中发布的任何通告。由于MyJXTA中的通告的数量十分庞大，因此在MyJXTA中执行发现是是不切实际的。因此聊天的对等体应该尝试在MyJXTA中发现对等组，然后在更小的对等组内发现其它资源。

3.2.1 异步发现机制

JXTA发现使用一种异步机制来发现通告。想要发现资源的对等体在选定的对等组范围内传播一个发现请求。该请求的响应是异步接收的。是否能接收到响应或者什么时候能收到响应是不确定的。这种不可预料且不可靠的P2P网络使得难以指定超时时间或预知行为。应用程序的职责在于判断得到相应的时间。异步编程模型最适合与这种不可靠的P2P网络环境。异步机制大大简化了错误恢复，因为错误是作为普通情况来处理，而不是作为异常来处理的。

3.2.2 发现服务的实现

GroupSearch负责发现对等组，如果没有找到对等组，那么对等体将创建对等组。

GroupSearch类的结构很简单：

1．发现现有的对等组的通告

A．寻找本地缓存中以前发现的通告。

B．发送PDP请求，以发现通告。

这可以使用广播类型机制或者通过联系已知的汇聚对等体来完成，这两种方法都是同步调用。在后台，API将创建一个新的县城来侦听响应。随着响

应的到来，后台线程将读取它们，并把响应插入到对等体的本地通告缓存中。

C．等待响应得到来。

D．再次查看本地缓存中的响应。

2．如果没有找到现有的PeerGroup，就为之创建一个对等体通告，再根据通告创建PeerGroup组。

3．如果现有的PeerGroup 没有找到，就使用发现通告来加入对等组。

下面是执行这些步骤所必须的代码：

package net.jxta.myjxta2.search;

import net.jxta.peergroup.PeerGroup;

import net.jxta.myjxta2.util.Group;

import net.jxta.myjxta2.util.GroupNode;

import net.jxta.discovery.DiscoveryListener;

import net.jxta.discovery.DiscoveryService;

import net.jxta.discovery.DiscoveryEvent;

import net.jxta.protocol.DiscoveryResponseMsg;

import net.jxta.protocol.PeerGroupAdvertisement;

import java.io.IOException;

import java.util.Enumeration;

import net.jxta.myjxta2.MyJXTA;

public class GroupSearch

extends AbstractSearch

implements DiscoveryListener {

public static final String ATTRIBUTE_NAME = "Name";

//定义的ATTRIBUTE_NAME 为我们想要搜寻的属性的名称

//定义要搜寻的标题

private static final String TITLE = "Group Search";

/*对搜寻的描述*/

private static final String DESCRIPTION = "groups";

public GroupSearch(Group group, MyJXTA myJxta) {

super(group, myJxta);

setTitle(TITLE);

}

public String getSearchDescription() {

return getDescription(DESCRIPTION);

}

在这段里面，首先创建一个GroupSearch的实例，参数group是搜寻完成之后所在的组。参数MyJXTA表示本系统得默认实例。当前在该实例中搜索到的对等组可能和group参数代表的对等组不同。

//下面的程序实现对特定条件的对等组

//参数term是指要搜寻的对等组的条件

public void search(String term) {

setTerm(term);

String criteria = (term.trim().length() == 0 ||

term.equals(WILDCARD) ? null : term);

cancel();

isRunning(true);

DiscoveryService discover = getDiscovery(); // this also fixes the group

try {

process(discover.getLocalAdvertisements(

DiscoveryService.GROUP,

criteria != null ? ATTRIBUTE_NAME : null, criteria));

} catch (IOException ioe) {}

discover.getRemoteAdvertisements(null, DiscoveryService.GROUP,

criteria != null ? ATTRIBUTE_NAME : null, criteria,

REMOTE_THRESHOLD, this);

isRunning(false);

}

//discover.getRemoteAdvertisements（）方法用来搜寻本地的通告，因为要搜索的通告可//能已经保存在本地缓存中了，如果本地缓存中已有该对等组，就不需要再到网络上去搜寻了。//一般的搜索都是按照先本地，再网络的方法进行的。

public void cancel() {

if (isRunning()) {

isRunning(false);

getDiscovery().removeDiscoveryListener(this);

super.cancel();

}

}

public void discoveryEvent(DiscoveryEvent de) {

DiscoveryResponseMsg rm = de.getResponse();

if (rm.getDiscoveryType() == DiscoveryService.GROUP) {

process(rm.getAdvertisements());

}

}

// discoveryEvent（）方法用于处理发现事件，因为该系统得设计是基于事件的。如果发现了要搜寻的对等组，就作出响应，返回发现的类型。

private void process(Enumeration advertisements) {

PeerGroupAdvertisement pga = null;

Object o = null;

while (advertisements != null &&

advertisements.hasMoreElements()) {

o = advertisements.nextElement();

if (o instanceof PeerGroupAdvertisement) {

pga = (PeerGroupAdvertisement)o;

Group go = new Group(myJxta, pga, group);

add(new GroupNode(go));

}

}

}

}

//该方法用于处理发现的所有的通告，advertisements用于返回所有发现的通告，将所有发现的通告一一列举出来，传递到函数里面，然后用一个循环来处理发现的所有通告。在循环体内，处理通告的方法是当循环未结束，就为每个通告创建一个对等组节点，加入到已有的对等组节点里面。

//首先创建一个MyJXTA实例，初始化对象

private void initialize() {

Group g = null;

setStatus(this.resources.getString("status.jxta.connect"));

//将对象的状态设置为连接

//新建一个对等组

try {

g = new Group(this, PeerGroupFactory.newNetPeerGroup(), null);

} catch (PeerGroupException pge) {

if (LOG.isEnabledFor(Level.ERROR)) {

LOG.error("Caught unexpected Exception", pge);

}

}

if (g != null) {

this.peerName = g.getPeerGroup().getPeerName();

this.preferencesManager = new PreferenceManager(this);

setStatus(this.resources.getString("status.jxta.start"));

String gid = Constants.getInstance().get(Constants.GROUP_ID, "").trim();

g.setVisible(gid.length() == 0);

joinGroup(g, false, false, gid.length() == 0);

initializeGroup(g);

this.preferencesManager.presetPreferences();

} else {

setStatus(this.resources.getString("error.jxta.start"));

}

}

//以上语句是对新建的对等组进行默认设置，设置对等组的缺省属性。然后调用initializeGroup方法进行对等组的初始化设置。下面定义了几个initializeGroup（）的重载函数。

private void initializeGroup(Group parent) {

initializeGroup(parent, Constants.GROUP, "/@id");

}

private void initializeGroup(Group parent, String queryPrefix,

String queryPostfix) {

String prefix = queryPrefix != null ? queryPrefix.trim() : null;

String postfix = queryPostfix != null ? queryPostfix.trim() : null;

if (prefix != null &&

postfix != null) {

Constants c = Constants.getInstance();

for (Iterator gi = c.getAll(prefix + postfix).iterator();

gi.hasNext(); ) {

String gid = ((String)gi.next()).trim();

if (gid.length() > 0) {

String q = prefix + "[@id=\"" + gid + "\"]";

String gn = c.get(q + "/@name", Defaults.GROUP_NAME);

String gp = c.get(q + "/@password", null);

String gd = c.get(q + "/@description",

Defaults.GROUP_DESCRIPTION);

//设置对等组的ID，对等组名称，密码以及对该对等组的描述。

setStatus(this.resources.getString("status.group.create") +" " + gn);

Group g = null;

try {

PeerGroup ppg = parent.getPeerGroup();

PeerGroupAdvertisement pga =

PeerGroupUtil.create(ppg, gn, gd, gp,

(PeerGroupID)PeerGroupID.create(new URI(gid)));

g = new Group(this, ppg.newGroup(pga), parent);

} catch (PeerGroupException pge) {

LOG.error("Caught unexpected Exception",pge);

} catch (Exception e) {

LOG.error("Caught unexpected Exception",e);

}

//根据搜索到的对等组通告的属性，在本地创建对等组，parent参数用来指明该对等组的父//对等组

if (g != null) {

g.setVisible(true);//设置该对等组为可见

joinGroup(g, true, true, true);

initializeGroup(g, q, "/group/@id");

} else {

setStatus(this.resources.getString("error.group.create")

+ " " + gn);

}

}

}

}

}

GroupSearch首先必须做的是发现并加入MyJXTA，在加入这个对等组之后，它就能使用该对等组的服务。以上程序段中，它使用MyJXTA对象的发现服务来寻找对等组通告。发现通告的时间设置为三分钟，由于网络的不可预料性，因此没有办法知道找到一个通告需要多长时间。尝试的时间取决于网络环境。

因为是寻找对等组通告，因此要在getLocalAdvertisements（）方法中使用DiscoveryService.GROUP类型。对等体通告的Name字段用来搜索对等组，任何本地缓存中的对等组通告类型，属性值对匹配，将通过该方法返回。如果找到这样的通告，那么任务

完成，从发现循环中退出。

如果本地缓存中没有找到通告，那么在MyJXTA对等组中通过getRemoteAdvertisements()方法发送发现请求，来寻找PeerGroup通告。由于对等体ID为空，因此发现请求将被传播到当前子网络的所有对等体上，以及知道的MyJXTA的汇聚对等体上。因为只有一个PeerGroup通告，因此该请求的阈值参数设置为1。

在发送了发现请求之后，要停一段时间再去检查缓存，看是否接收到一些响应。当接收到响应时，通告会被自动存储在本地缓存中。

如果三分钟之后还没有找到PeerGroup通告，将继续创建PeerGroup对等组。本地程序就可能使第一个试图加入PeerGroup的对等体，或者所有其它知道PeerGroup组的对等体可能关闭了或不可到达。

3.2.3 创建对等组

如果没有找到PeerGroup通告，就必须创建一个新的PeerGroup对等组。使用PeerGroup 类来创建对等组通告。这样会创建一个一般性的通告。它根据MyJXTA来自动设置对等组通告的所有属性。

然后可以把对等组通告传给MyJXTA的newGroup（）方法。该方法将创建新的对等组，并把此信对等组的信息发送到JXTA网络。这样就发布了通告。NewGroup（）方法是自动发布的。

如果对等组找不到PeerGroup对等组，那么就要创建相同的对等组。为了避免不同的对等体创建不同版本的对等组的情况，通过使用makeGroupID()方法和预定义的字符串，可以达到这一目标。

这样就完成了PeerGroup的实现。有了一个可以发现和创建PeerGroup对等组的服务。

Peer类代表要参与聊天的个人用户，跟上面GroupSearch一样，Peer首先发现并加入MyJXTA。Peer的joinGroup()方法的基本框架和GroupSearch中的非常相似，只是如果joinGroup()方法没有找到PeerGroup组，它将不会创建该对等组。如果程序没有找到现有的PeerGroup对等组，它将退出。

不能找到PeerGroup通告并不能说明没有PeerGroup对等体运行在JXTA网络上，而只是说明不能到达任何PeerGroup对等体。这可能因为没有等待应答返回足够长时间，或者找不到连接运行中的PeerGroup对等体的路径。

聊天客户Peer加入对等组的源代码如下：

public void joinGroup(final Group group, boolean autoStart, boolean discover,

boolean isInteractive) {

PeerGroup pg = group.getPeerGroup();

//首先获得要加入对等组的句柄

setStatus(this.resources.getString("status.group.join") + " " +

pg.getPeerGroupName());

this.view.setTitle(pg.getPeerName() + "@" + pg.getPeerGroupName());

PipeAdvertisement pa = PipeUtil.getAdv(pg,

Dialog.getDialogNamer(OneToOneCommandDialog.class).getDialogName(pg.getPeerName()), PipeService.UnicastType, null, true);

// pa获得要加入对等组的管道通告，管道服务的类型设置为UnicastType，该类型为单播型的，即点对点的，在管道上传送的消息将被送到单一的网络地址。

setStatus(this.resources.getString("status.group.display") + " " +

pg.getPeerGroupName());

addJxtaNode(new PeerNode(new Peer(pa), group), true);

//找到后，将peer节点加入到该对等组里面

restore(group);

if (discover) {

discover(group);

}

if (isInteractive) {

setStatus(this.resources.getString("status.dialog.many.register"));

String pn = Dialog.getDialogNamer(ManyToManyDialog.class).

getDialogName(pg.getPeerName());

pa = DialogManager.getInstance(group,pn,PipeService.PropagateType).getPipeAdv(pg);

//以上几行程序获得对等点的名字及管道通告。

addDialog(DialogManager.getDialog(ManyToManyDialog.class, group, pa, this));

setStatus(this.resources.getString("https://www.360docs.net/doc/ec8599380.html,mand.register"));

pn =

Dialog.getDialogNamer(OneToOneCommandDialog.class).getDialogName(pg.getPeerName());

setStatus(this.resources.getString("status.dialog.listener.add") +": " + pn);

DialogManager.getInstance(group, pn, PipeService.UnicastType).

addPipeListener(pg, new DialogPipeListener() {

public void receive(PeerGroup pg, JxtaBiDiPipe pipe) { DialogManager.getCommander(OneToOneCommandDialog.class,

group, pipe, MyJXTA.this);

}

//添加管道监听器，用以监听有没有对话请求。

public void receive(PeerGroup pg, Message msg) {}

});

pn = Dialog.getDialogNamer(OneToOneDialog.class).

getDialogName(pg.getPeerName());

setStatus(this.resources.getString("status.dialog.listener.add") +": " + pn);

DialogManager.getInstance(group, pn, PipeService.UnicastSecureType).

addPipeListener(pg, new DialogPipeListener() {

public void receive(PeerGroup pg, JxtaBiDiPipe pipe) {

addDialog(DialogManager.getDialog(OneToOneDialog.class,

group, pipe, MyJXTA.this));

}

public void receive(PeerGroup pg, Message msg) {}

});

setStatus(this.resources.getString("status.share.register"));

}

if (autoStart) {

setStatus(this.resources.getString("status.group.rendezvous.auto") +

": " + DEFAULT_AUTOSTART);

}

pg.getRendezV ousService().setAutoStart(autoStart, DEFAULT_AUTOSTART);

}

3.2.4 发现的主要优势

性能随着系统变老而提升的能力是JXTA网络的一个基本特色。聊天的对等体首次发现另外一个对等体时会花费一些时间。第二次会花费较少的时间，因为该对等体对先前的发现进行了缓存。这对对等体有益。

第四章聊天管道API的设计

4.1 管道在创建聊天室中的作用

聊天的用户找到并加入PeerGroup对等组之后，彼此之间就靠管道进行通信。由于JXTA 为管道提供了Java API的绑定，使得这种通信成为可能。管道是JXTA允许对等体之间彼此

进行通信的基本结构。想提供服务的对等体会创建一个管道，并向JXTA对等组发布一个通告。想使用服务的对等体在一个对等组中发现管道通告，然后通过该管道与该服务建立连接。

4.2 创建管道

4.2.1 创建管道步骤

要使两个聊天客户能够在PeerGroup对等组内进行通信，必须要添加一组管道。创建管道的方式在逻辑上与创建对等组的方法相同。本次设计中：

A．使用getLocalAdvertisement（）方法在本地的缓存中搜索现有的通告，使用Discovery.AOV作为通告的类型。

B．如果没有找到所需的通告，就调用getRemoteAdvertisemeny()方法尝试着发现该通告。我们等待三分钟让查找程序继续执行，然后在本地缓存中看能否找到该通告。

C．如果仍然没有发现通告，那么必须创建一个通告，使用AdvertisementFactory类去构建该通告。然后在该通告中设置适当的信息，包括管道名，管道唯一的ID，以及管道类型。

D．在得到管道之后，我们将其发送到管道服务以实例化输入管道。PeerGroup在该管道上监听请求，稍后，PeerGroup必须创建一个输出管道，它在该管道上向特定的Peer发送响应。

实现的代码如下：

package net.jxta.myjxta2.util;

import net.jxta.discovery.DiscoveryListener;

import net.jxta.discovery.DiscoveryService;

import net.jxta.document.AdvertisementFactory;

import net.jxta.id.IDFactory;

import net.jxta.peergroup.PeerGroup;

import net.jxta.pipe.PipeID;

import net.jxta.protocol.PipeAdvertisement;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.List;

public class PipeUtil {

public static final byte[] GROUP_CHAT_PIPE_ID = {

(byte)0xD1, (byte)0xD1, (byte)0xD1, (byte)0xD1,

(byte)0xD1, (byte)0xD1, (byte)0xD1, (byte)0xD1,

(byte)0xD1, (byte)0xD1, (byte)0xD1, (byte)0xD1,

(byte)0xD1, (byte)0xD1, (byte)0xD1, (byte)0xD1

};

//定义聊天用户组的网络ID地址

public static PipeAdvertisement getAdv(PeerGroup pg, String name,

String type, byte[] pipeId) {

return getAdv(pg, name, type, pipeId, false);

}

public static PipeAdvertisement getAdv(PeerGroup pg, String name,

String type, byte[] pipeId, boolean remote) {

PipeAdvertisement pa = searchLocal(pg, name);

if (pa == null) {

pa = createAdv(pg, name, type, pipeId);

publish(pg, pa, remote);

}

return pa;

}

//首先搜索本地管道通告，获得通告的各种参数，如果本地没有通告，就创建一个管道通告。并且对外发布该通告。

public static List getAdvs(PeerGroup pg, String name) {

List p = new ArrayList();

try {

for (Enumeration pas = pg.getDiscoveryService().

getLocalAdvertisements(DiscoveryService.ADV,

https://www.360docs.net/doc/ec8599380.html,Tag, name);

pas.hasMoreElements(); ) {

Object o = pas.nextElement();

if (o instanceof PipeAdvertisement) {

p.add((PipeAdvertisement)o);

}

}

} catch (IOException ioe) {}

return p;

}

//该方法将搜寻到的各个通告按照链表的方式组织，找到一个通告，就将其加入链表中

public static PipeAdvertisement searchLocal(PeerGroup pg, String name) {

PipeAdvertisement pa = null;

try {

for (Enumeration pas = pg.getDiscoveryService().

getLocalAdvertisements(DiscoveryService.ADV,

https://www.360docs.net/doc/ec8599380.html,Tag, name);

pas.hasMoreElements(); ) {

pa = (PipeAdvertisement)pas.nextElement();

if (pa.getName().equals(name)) {

break;

} else {

pa = null;

}

}

} catch (IOException ioe) {}

return pa;

//本方法的功能是搜寻远程的管道通告。首先开启通告的发现服务，然后搜寻远程的通告。

public static void discoverAdvs(PeerGroup pg, String name,

DiscoveryListener listener) {

DiscoveryService s = pg.getDiscoveryService();

s.getRemoteAdvertisements(null, DiscoveryService.ADV,

name != null ? https://www.360docs.net/doc/ec8599380.html,Tag : null,

name, 10, listener);

}

//该方法负责创建一个管道通告

public static PipeAdvertisement createAdv(PeerGroup pg, String name,

String type) {

return createAdv(pg, name, type, null);

}

//createAdv（）方法的重载函数，用于创建管道通告，并且从通告名称，通告ID，通告的类型几方面对管道通告进行初始化设置。

public static PipeAdvertisement createAdv(PeerGroup pg, String name,

String type, byte[] id) {

PipeAdvertisement pa = (PipeAdvertisement)AdvertisementFactory.

newAdvertisement(PipeAdvertisement.getAdvertisementType());

pa.setPipeID(id != null ?

(PipeID)IDFactory.newPipeID(pg.getPeerGroupID(), id) :

(PipeID)IDFactory.newPipeID(pg.getPeerGroupID()));

pa.setName(name);

pa.setType(type);

return pa;

}

public static void publish(PeerGroup pg, PipeAdvertisement pa) {

publish(pg, pa, false);

}

//publish（）方法的重载函数，用于等通告创建之后来发布通告，以使通告能够被发现和识别。

public static void publish(PeerGroup pg, PipeAdvertisement pa,

boolean remote) {

DiscoveryService ds = pg.getDiscoveryService();

try {

ds.publish(pa);

} catch (IOException ioe) {}

if (remote) {

// xxx: no remote publishing

// ds.remotePublish(pa, DiscoveryService.ADV);

}

}//pulish()方法用于发布通告，先要开启发现服务，然后发布通告

///////////////////////////////////////////////////////////////////////////////////////////package

net.jxta.myjxta2.dialog;

import net.jxta.myjxta2.util.PipeUtil;

import net.jxta.endpoint.Message;

import net.jxta.peergroup.PeerGroup;

import net.jxta.pipe.PipeMsgEvent;

import net.jxta.pipe.PipeMsgListener;

import net.jxta.pipe.PipeService;

import net.jxta.pipe.InputPipe;

import net.jxta.protocol.PipeAdvertisement;

import java.io.IOException;

import java.util.Iterator;

class PropogateDialogManager

extends AbstractDialogManager {

//记住管道，在必要时可以关闭它

private InputPipe pipe = null;

// PropagatePipeListener类监听管道消息事件并且将数据送到所有已经注册过的对话管道监听器，

private class PropagatePipeListener

implements PipeMsgListener{

//pg是监听器运行所在的对等组

private PeerGroup pg;

//创建一个新的PropagatePipeListener的对象

protected PropagatePipeListener(PeerGroup pg){

this.pg = pg;

}

// 当接收导管道消息事件时，该pipeMsgEvent（）方法就被调用

public void pipeMsgEvent(PipeMsgEvent pme) {

Message msg = pme.getMessage();

for (Iterator l = getListeners(pg).iterator(); l.hasNext(); ) {

((DialogPipeListener)l.next()).receive(pg, msg);

}

}

}

public PropogateDialogManager(String name, String type) {

super(name, type);

}

//为特定的对等组PeerGroup初始化对话管理器DialogManager

public void initialize(final PeerGroup pg) {

try {

this.pipe = pg.getPipeService().createInputPipe(getPipeAdv(pg), // createInputPipe（）方法用于创建输入管道

new PropagatePipeListener(pg));