addressbookservice.java

Java p2p程序设计2002年版

/*
 * AddressBookService.java
 *
 * Created on November 29, 2001, 1:27 PM
 */

package com.sams.jxta.pda;

import javax.swing.DefaultListModel;
import net.jxta.peergroup.PeerGroup;
import net.jxta.discovery.DiscoveryService;
import net.jxta.peer.PeerID;
import net.jxta.impl.resolver.ResolverServiceImpl;
import java.util.Vector;
import java.util.Hashtable;
import com.sams.jxta.vcard.*;
import net.jxta.resolver.QueryHandler;
import java.util.Date;
import java.text.SimpleDateFormat;
import net.jxta.impl.resolver.*;
import net.jxta.protocol.*;
import net.jxta.impl.protocol.*;

import org.jdom.*;
import org.jdom.output.*;
import org.jdom.input.*;

import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.util.*;
import net.jxta.document.AdvertisementFactory;
import  net.jxta.peergroup.*;
import  net.jxta.pipe.*;
import net.jxta.discovery.*;
//import net.jxta.document.*;
import net.jxta.document.MimeMediaType;
import net.jxta.endpoint.*;
import net.jxta.id.*;
import net.jxta.exception.*;
import net.jxta.peer.*;
import net.jxta.pipe.*;
import net.jxta.peergroup.*;
import net.jxta.platform.*;
import net.jxta.protocol.*;
import net.jxta.service.*;
import javax.swing.DefaultListModel;

//import net.jxta.document.*;

/**
 *
 * @author  Administrator
 */
public class AddressBookService {
    
    protected String syncHandlerName = "SyncAddressBook";//Pull
    protected String pushHandlerName = "PushAddressItem";//Push
    protected String credential ="SAMS";
    //Hashtable addressGroups = new Hashtable();
    protected Hashtable allEntries = new Hashtable();
    protected PeerID peerID;
    /** Creates new CalendarService */
    protected PeerGroup rootPeerGroup;
    //InfoResolver resolverX;
    protected DiscoveryService discovery;
    protected ResolverServiceImpl resolver;
    //SynchronizerResolver synchronizerResolver;
    /** Creates new AddressBookService
     * @param rootPeerGroup  */
    public AddressBookService(PeerGroup rootPeerGroup) {
        this.rootPeerGroup = rootPeerGroup;
        //syncHandlerName += "-"+rootPeerGroup.getPeerGroupName();
        //pushHandlerName += "-"+rootPeerGroup.getPeerGroupName();
        peerID = rootPeerGroup.getPeerID();
        discovery = rootPeerGroup.getDiscoveryService();
        
        PushHandler pushHandler = new  PushHandler(pushHandlerName,credential);
        SyncHandler syncHandler = new  SyncHandler(syncHandlerName,allEntries,credential);
        
        resolver = (ResolverServiceImpl)rootPeerGroup.getResolverService();
        
        resolver.registerHandler(pushHandlerName, pushHandler);
        resolver.registerHandler(syncHandlerName, syncHandler);
        
    }
    
    
    static Vector models = new Vector(1);
    
    public synchronized void addModel(DefaultListModel model){
        models.add(model);
    }
    public void addEntry( VCard vCard){
        vCard.setGroupID(rootPeerGroup.getPeerGroupID().toString());
        vCard.setGroupName(rootPeerGroup.getPeerGroupName());
        vCard.setPeerID(rootPeerGroup.getPeerID().toString());
        vCard.setPeerName(rootPeerGroup.getPeerName());
        vCard.setGroupDesc( rootPeerGroup.getPeerGroupAdvertisement().getDescription());
        merge(vCard);
        update(vCard.toXML());
        
    }
    public void  update(String message){
        System.out.println("Resolver sending messages");
        ResolverQueryMsg resolverQueryMsg = null;
        resolverQueryMsg = new ResolverQuery(pushHandlerName, credential,rootPeerGroup.getPeerID().toString(), message,1);
        
        // Note that the following may throw a RuntimeException
        // if the peer is not found.
        //rootPeerGroup.setRendezvous(true);
        System.out.println("isRendezvous:"+ rootPeerGroup.isRendezvous());
        ResolverSend resolverSend = new  ResolverSend (resolver, null, resolverQueryMsg);
        resolverSend.start();
    }

    public void synchronize(){
        //synchronizerResolver.synchronize();
        System.out.println("Resolver sending synchronize");
        ResolverQueryMsg resolverQueryMsg = null;
        resolverQueryMsg = new ResolverQuery(syncHandlerName, credential,rootPeerGroup.getPeerID().toString(), "",1);
        
        // Note that the following may throw a RuntimeException
        // if the peer is not found.
        ResolverSend resolverSend = new  ResolverSend (resolver, null, resolverQueryMsg);
        
        resolverSend.start();
    }
    public void updateEntry(VCard vCard){
    }
    public void deleteEntry(VCard vCard){
    }
    /**
     * Merge the new event into our database.
     */
    public synchronized void merge(VCard vCard){
        if (allEntries.get(vCard.getDtstamp())!=null){
            // We already have this message
            return;
        }else{
            //New address  message
            allEntries.put(vCard.getDtstamp(),vCard);
        }
       
        for (int i =0;i <models.size();i++){
            ((javax.swing.DefaultListModel)models.elementAt(i)).addElement(vCard);
        }
        
    }
    /**
     * implementation of QueryHandler for for synchronization.
     */
    class SyncHandler implements QueryHandler{
        protected String handlerName;
        protected String credential;
        protected Hashtable entryBook;
        protected SimpleDateFormat format   = new SimpleDateFormat("MM, dd, yyyy hh:mm:ss.S");
        
        public SyncHandler(String handlerName,Hashtable entryBook, String credential){
            this.handlerName = handlerName;
            this.credential = credential;
            this.entryBook = entryBook;
            
        }// end of constructor PullHandler()
        /**
         * call back method, when messages are received by the ResolverService
         * it calls back this method to deal with received responses
         * @param response ResolverQueryMsg reponse
         *
         * @version $Revision: 1.1 $
         * @since JXTA 1.0
         */
        public void processResponse(ResolverResponseMsg response) {
            System.out.println("Received a response");
            String textDoc = response.getResponse();
            if (textDoc ==null)return;
            //System.out.println("Received a response:"+textDoc);
            
            try{
                ByteArrayInputStream in = new ByteArrayInputStream(textDoc.getBytes());
                org.jdom.input.SAXBuilder builder = new org.jdom.input.SAXBuilder();
                Document doc = builder.build(in);
                Element root = doc.getRootElement();
                java.util.List book = (java.util.List) root .getChildren("vcard");
                java.util.ListIterator lister = book.listIterator();
                
                System.out.println("===="+root.getName()+"=====$$$$$$$$$$$$$$$$$$$");
                while (lister.hasNext()){
                    Element entry = (Element) lister.next();
                    System.out.println("Received a response:"+entry.getText());
                    XMLOutputter putter = new XMLOutputter("  ",true);
                    StringWriter writer = new StringWriter();
                    putter.output(entry,writer);
                    
                    System.out.println(" sync messag:"+writer.toString());
                    String xml = writer.toString();
                    merge(new VCard(xml));
                }
                
            }catch(Exception je){//org.jdom.JDOMException je){
                je.printStackTrace();
                // return null;
            }
            
            
            
            //String textDoc = response.getResponse();
            //System.out.println(textDoc);
            System.out.println(((ResolverResponse)response).toString());
        }// End of processResponse()
        
        /**
         * Process the resolver query, and generate response
         * @return GenericResolverMsg Response to the query
         * @param query ResolverQueryMsg query
         */
        public ResolverResponseMsg processQuery(ResolverQueryMsg query) throws NoResponseException, ResendQueryException, DiscardQueryException{
            try{
                System.out.println("Received a synchronizer query");
                
                Element root = new Element("address-book");//,format.format( new Date(now)));
                Document doc = new Document(root);
                
                java.util.Enumeration enum = entryBook.elements();
                for(;enum.hasMoreElements();){
                    Document d2 =((VCard)enum.nextElement()).toJDOM();
                    Element ele = d2.getRootElement();
                    ele.detach();
                    root.addContent(ele);
                }
                // Return a generic response;
                ResolverResponseMsg message = null;
                XMLOutputter putter = new XMLOutputter("  ",true);
                StringWriter writer = new StringWriter();
                putter.output(doc,writer);
                
                System.out.println(" sync messag:"+writer.toString());
                message = new ResolverResponse(handlerName, credential,query.getQueryId(), writer.toString());
                return (ResolverResponseMsg)message;
            }catch(Exception e ){
                e.printStackTrace();
                throw new NoResponseException("Error processing query");
            }
        }// end of processQuery()
        
    }// end of class PullHandler
    
    class PushHandler implements QueryHandler{
        protected String handlerName;
        protected String credential;
        protected SimpleDateFormat format   = new SimpleDateFormat("MM, dd, yyyy hh:mm:ss.S");
        
        public PushHandler(String handlerName, String credential){
            this.handlerName = handlerName;
            this.credential = credential;
        }// end of constructor CalendarHandler()
        /**
         * call back method, when messages are received by the ResolverService
         * it calls back this method to deal with received responses
         * @param response ResolverQueryMsg reponse
         *
         * @version $Revision: 1.1 $
         * @since JXTA 1.0
         */
        public void processResponse(ResolverResponseMsg response) {
            System.out.println("Received a address response");
            //String textDoc = response.getResponse();
            //System.out.println(textDoc);
            System.out.println(((ResolverResponse)response).toString());
        }// End of processResponse()
        
        /**
         * Process the resolver query, and generate response
         * @return GenericResolverMsg Response to the query
         * @param query ResolverQueryMsg query
         *
         * @exception NoResponseException is thrown when the resolver service
         * does not have an response and is not interested by the response.
         * @exception ResendQueryException is thrown when the resolver service
         * does not have a response, but is interested by the response. In that
         * case, the resolver service is responsible for forward the response
         * to the original peer that has issued the query.
         * @exception DiscardQueryException is thrown when the resolver service
         * has decided that the query should simply be ignored.
         * @exception IOException is thrown when the service resolver was not able to
         * process the query
         *
         * @version $Revision: 1.1 $
         * @since JXTA 1.0
         */
        public ResolverResponseMsg processQuery(ResolverQueryMsg query) throws NoResponseException, ResendQueryException, DiscardQueryException{
            System.out.println("Received address query");
            System.out.println(((ResolverQuery)query).toString());
            //net.jxta.document.StructuredTextDocument doc = null;
            String xml = query.getQuery();
            // Process the incomming data
            merge(new VCard(xml));
            
            throw new NoResponseException("Got the data we were interested in.");
                /*
            try{
                doc = (StructuredTextDocument)StructuredDocumentFactory.newStructuredDocument(new MimeMediaType( "text/xml" ),
                new ByteArrayInputStream(xml.getBytes()) );
            }catch(java.io.IOException ioe){
                ioe.printStackTrace();
            }
            // Let the originator know we received the message.
            net.jxta.document.Element e = null;
            long now = System.currentTimeMillis();
            e = doc.createElement("message consumed:",format.format( new Date(now)));
            doc.appendChild(e);
            // Return a generic response;
            ResolverResponseMsg message = null;
            xml = serializeDoc(doc);
            message = new ResolverResponse(handlerName, credential,query.getQueryId(), xml);
            return (ResolverResponseMsg)message;
                 */
        }// end of processQuery()
        
    }// end of class CalendarHandler
    
}