restopeer.java

这个事关于jxta编程的入门级代码

	// the brand name of RestoPeer. So each RestoPeer instance
	// must have a unique name.
	myAdv.setName("RestoNet:RestoPipe:" + brand);
	myAdv.setType(PipeService.UnicastType);

	// Create the module impl advertisement that represents
	// the RestoPeer service.
	// Peergroup services are also represented by modules since a
	// peergroup service needs to be dynamically loaded when the
	// corresponding peergroup is instantiated on the peer.
	// The constructor of the service 
	// module impl takes a set of arguments to describe the service:
	//    msrvID : unique spec ID of the restoNet service
	//    "RestoPeerService" : is the java class implementing the service
	//    "http://jxta.org/tutorial/RestoPeer.jar" : location to find jar file
	//    "sun.com" : provider of the service
	//    a description of the service
        ModuleImplAdvertisement restoImplAdv =
                createServiceModuleImplAdv(msrvID,
		"RestoPeerService", "http://jxta.org/tutorial/RestoPeer.jar",
		"sun.com","RestoPeer Service Module Implementation", myAdv);

        // Create a new peergroup that is a clone of the NetPeergroup
        // but with the added RestoPeer Service.
        return createPeerGroup(netpg, "RestoNet", restoImplAdv);
    }

    // This is a utility method to create a new peergroup
    // implementation. The new peergroup will have all the
    // same services as the parent peergroup; it will have an
    // additional service (the srvImpl).
    // 
    // The method creates the
    // new Peer Group Module Implementation Advertisement and
    // publishes it; creates the associated PeerGroup Adv and
    // publishes it; and instantiates the peergroup
    // using the just created PeerGroup Adv.
    //  
    // parent: parent peergroup the new group is created into
    // groupName : name of the new group
    // srvImpl :  new peergroup service to add to the default set of
    //            NetPeergroup services
    private PeerGroup  createPeerGroup(PeerGroup parent, String groupName, 
				       ModuleImplAdvertisement srvImpl) {

        PeerGroup myPeerGroup = null;
        PeerGroupAdvertisement myPeerGroupAdvertisement = null;
        ModuleImplAdvertisement myModuleImplAdv = null;
        
        // Create the PeerGroup Module Implementation adding the
	// new peergroup service
        myModuleImplAdv = createPeerGroupModuleImplAdv(parent, srvImpl);

        // Publish the new peergroup module implementation in the
        // parent peer group
        DiscoveryService parentDiscovery = parent.getDiscoveryService();

        // Publish advertisement in the parent peergroup with the default
        // lifetime and expiration time for remote publishing
        try {
            parentDiscovery.publish(myModuleImplAdv, DiscoveryService.ADV, 
		PeerGroup.DEFAULT_LIFETIME, PeerGroup.DEFAULT_EXPIRATION);
            parentDiscovery.remotePublish(myModuleImplAdv,
                DiscoveryService.ADV, PeerGroup.DEFAULT_EXPIRATION);
        }
        catch (java.io.IOException e) {
            System.err.println(
                "Cannot publish the new peergroup ModuleImplAdv");
            return null;
        }    

	System.out.println(
                "Published new Peergroup ModulImpl advertisement for : "
                + groupName);

        // Create and publish the new PeerGroup Advertisement
        // corresponding to the new peergroup implementation
        myPeerGroupAdvertisement= createPeerGroupAdvertisement(
				  myModuleImplAdv,groupName);

        // Publish the advertisementin the parent peer group with the
        // default lifetime and expiration time
        try {
            parentDiscovery.publish(myPeerGroupAdvertisement,
                DiscoveryService.GROUP, PeerGroup.DEFAULT_LIFETIME,
                PeerGroup.DEFAULT_EXPIRATION);
            parentDiscovery.remotePublish(myPeerGroupAdvertisement,
                DiscoveryService.GROUP, PeerGroup.DEFAULT_EXPIRATION);
        }
        catch (java.io.IOException e) {
            System.err.println("Cannot create the new PeerGroupAdvertisement");
	    return null;
        }

	System.out.println("Published the new PeerGroup advertisement for :"
	    + groupName);

	try {
	    // Finally, instantiate the new PeerGroup
            myPeerGroup = parent.newGroup(myPeerGroupAdvertisement);
	    System.out.println("Instantiated the new PeerGroup " + groupName);
        } catch (net.jxta.exception.PeerGroupException e) {
            System.err.println("Cannot create the new Peer Group");
            return null;
        }

        return myPeerGroup;
    }

    // This method is a generic method used to create a new
    // module impl advertisement for representing a peergroup
    // service. Each module implementation corresponds to a unique
    // module spec id that uniquely identifies a peergroup service.
    //
    // A peergroup service is represented by:
    //     id: unique module spec id identifying the new peergroup service
    //     code: java class that implement the peergroup service
    //     uri: location where we can download the java class implementing the service
    //     provider: identity of the provider
    //     desc: description of the service.
    //     padv: pipe advertisement to invoke the service
    private  ModuleImplAdvertisement createServiceModuleImplAdv(
               ModuleSpecID id,
	       String       code,
	       String       uri,
	       String       provider,
	       String       desc,
	       PipeAdvertisement padv) {

	// Construct a new module implementation advertisment
        ModuleImplAdvertisement ServiceModuleImplAdv =
            (ModuleImplAdvertisement)
            AdvertisementFactory.newAdvertisement(
                ModuleImplAdvertisement.getAdvertisementType());

	// Set a unique module Spec ID associated with this
	// service implementation
        ServiceModuleImplAdv.setModuleSpecID(id);

	// Set the java class that implements this service
        ServiceModuleImplAdv.setCode(code);
	
	// Set the description of the new service
        ServiceModuleImplAdv.setDescription(desc);

	// Define the compatibility Java JDK1.4 for loading this module
	StructuredTextDocument doc = (StructuredTextDocument)
                StructuredDocumentFactory.newStructuredDocument(
                    new MimeMediaType("text", "xml"), "Comp");
        Element e = doc.createElement("Efmt", "JDK1.4");
        doc.appendChild(e);
        e = doc.createElement("Bind", "V1.0 Ref Impl");
        doc.appendChild(e);
        ServiceModuleImplAdv.setCompat(doc);

	// Set the URL where we can download the code for this module
        ServiceModuleImplAdv.setUri(uri);

	// Set the provider for this module
        ServiceModuleImplAdv.setProvider(provider);

	// Set the pipe advertisement into a param doc to be used 
	// by a peer to connect to the service
	StructuredTextDocument paramDoc = (StructuredTextDocument)
                 StructuredDocumentFactory.newStructuredDocument
                 (new MimeMediaType("text/xml"), "Parm");
        StructuredDocumentUtils.copyElements(paramDoc, paramDoc,	
		 (Element) padv.getDocument(new MimeMediaType("text/xml")));
        ServiceModuleImplAdv.setParam(paramDoc);

	// Return the new module implementation for this service
        return ServiceModuleImplAdv;
    }

    // Create a Module Impl Advertisement that represents a peergroup
    // which is a clone of the NetPeerGroup, but adds a new peergroup
    // service to the peergroup.
    private ModuleImplAdvertisement createPeerGroupModuleImplAdv(
                PeerGroup parent, 
		ModuleImplAdvertisement serviceModuleImplAdv) {

        ModuleImplAdvertisement allPurposePeerGroupImplAdv = null;
        StdPeerGroupParamAdv PeerGroupParamAdv = null;

        try {
	    // Clone the parent (NetPeerGroup) implementation to get
	    // a module implementation
            allPurposePeerGroupImplAdv =
                parent.getAllPurposePeerGroupImplAdvertisement();
        }
        catch (Exception e) {
            System.err.println("Cannot get allPurposePeerGroupImplAdv " + e);
	    return null;
        }
        
	// Get the param field that conatins all the peergroup services
	// associated with the peergroup
        try {
            PeerGroupParamAdv = new StdPeerGroupParamAdv(
			        allPurposePeerGroupImplAdv.getParam());
        }
        catch (PeerGroupException e) {
            System.err.println("Cannot get StdPeerGroupParamAdv " + e);
 	    return null;
        }
	
	// Get the hashtable containaing the list of all the peergroup
	// services from the param advertisements
        Hashtable allPurposePeerGroupServicesHashtable =
            PeerGroupParamAdv.getServices();

	// Add our new peergroup service to the list of peergroup services
	allPurposePeerGroupServicesHashtable.put(mcID, serviceModuleImplAdv);
	
	// Update the PeerGroupModuleImplAdv with our new list
	// of peergroup services
	allPurposePeerGroupImplAdv.setParam((Element) 
	        PeerGroupParamAdv.getDocument(new MimeMediaType("text/xml")));

	// Set the new unique Spec ID that identifies this new peergroup
	// implementation
	allPurposePeerGroupImplAdv.setModuleSpecID(msID);
 
        // We are done creating our new peergroup implementation
        return allPurposePeerGroupImplAdv;
    }

    // This utility method is used to create a PeerGroup advertisement
    // associated with a module peergroup implementation
    private PeerGroupAdvertisement createPeerGroupAdvertisement(
	 ModuleImplAdvertisement implAdv, String groupName) {

	// Create a new peergroup advertisement
        PeerGroupAdvertisement myadv = (PeerGroupAdvertisement) 
	    AdvertisementFactory.newAdvertisement(
	        PeerGroupAdvertisement.getAdvertisementType());
        
        // Instead of creating a new group ID we use the
        // RestoPeer pre-defined peergroup id, so we create the same
        // peergroupId each time the group
	// is created
        myadv.setPeerGroupID(restoPeerGroupID);

	// Assign the pre-defined module spec id that corresponds
	// to our peergroup module implementation
        myadv.setModuleSpecID(implAdv.getModuleSpecID());
	
	// Assign peergroup name
        myadv.setName(groupName);

	// Set the peergroup description
        myadv.setDescription("This is RestoNet Peergroup");
        
        return myadv;
    }
}