Openfire MessageRouter 消息路由

public void route(Message packet) {
    if (packet == null) {
        throw new NullPointerException();
    }
    ClientSession session = sessionManager.getSession(packet.getFrom());
    try {
        // Invoke the interceptors before we process the read packet
        InterceptorManager.getInstance().invokeInterceptors(packet, session, true, false);
        if (session == null || session.getStatus() == Session.STATUS_AUTHENTICATED) {
            JID recipientJID = packet.getTo();

            // Check if the message was sent to the server hostname
            if (recipientJID != null && recipientJID.getNode() == null && recipientJID.getResource() == null &&
                    serverName.equals(recipientJID.getDomain())) {
                if (packet.getElement().element("addresses") != null) {
                    // Message includes multicast processing instructions. Ask the multicastRouter
                    // to route this packet
                    multicastRouter.route(packet);
                }
                else {
                    // Message was sent to the server hostname so forward it to a configurable
                    // set of JID's (probably admin users)
                    sendMessageToAdmins(packet);
                }
                return;
            }

            try {
                // Deliver stanza to requested route
                routingTable.routePacket(recipientJID, packet, false);
            }
            catch (Exception e) {
            	log.error("Failed to route packet: " + packet.toXML(), e);
                routingFailed(recipientJID, packet);
            }
        }
        else {
            packet.setTo(session.getAddress());
            packet.setFrom((JID)null);
            packet.setError(PacketError.Condition.not_authorized);
            session.process(packet);
        }
        // Invoke the interceptors after we have processed the read packet
        InterceptorManager.getInstance().invokeInterceptors(packet, session, true, true);
    } catch (PacketRejectedException e) {
        // An interceptor rejected this packet
        if (session != null && e.getRejectionMessage() != null && e.getRejectionMessage().trim().length() > 0) {
            // A message for the rejection will be sent to the sender of the rejected packet
            Message reply = new Message();
            reply.setID(packet.getID());
            reply.setTo(session.getAddress());
            reply.setFrom(packet.getTo());
            reply.setType(packet.getType());
            reply.setThread(packet.getThread());
            reply.setBody(e.getRejectionMessage());
            session.process(reply);
        }
    }
}

private boolean routeToLocalDomain(JID jid, Packet packet,
		boolean fromServer) {
	boolean routed = false;
	if (jid.getResource() == null) {
	    // Packet sent to a bare JID of a user
	    if (packet instanceof Message) {
	        // Find best route of local user
	        routed = routeToBareJID(jid, (Message) packet);
	    }
	    else {
	        throw new PacketException("Cannot route packet of type IQ 
                or Presence to bare JID: " + packet.toXML());
	    }
	}
	else {
	    // Packet sent to local user (full JID)
	    ClientRoute clientRoute = usersCache.get(jid.toString());
	    if (clientRoute == null) {
	        clientRoute = anonymousUsersCache.get(jid.toString());
	    }
	    if (clientRoute != null) {
	        if (!clientRoute.isAvailable() && routeOnlyAvailable(packet, fromServer) &&
	                !presenceUpdateHandler.hasDirectPresence(packet.getTo(), packet.getFrom())) {
	        	Log.debug("Unable to route packet. Packet should only be sent to 
                    available sessions and the route is not available. {} ", packet.toXML());
	            routed = false;
	        }
	        else {
	            if (localRoutingTable.isLocalRoute(jid)) {
	                // This is a route to a local user hosted in this node
	                try {
	                    localRoutingTable.getRoute(jid.toString()).process(packet);
	                    routed = true;
	                } catch (UnauthorizedException e) {
	                    Log.error("Unable to route packet " + packet.toXML(), e);
	                }
	            }
	            else {
	                // This is a route to a local user hosted in other node
	                if (remotePacketRouter != null) {
	                    routed = remotePacketRouter
	                            .routePacket(clientRoute.getNodeID().toByteArray(), jid, packet);
	                    if (!routed) {
	                    	removeClientRoute(jid); // drop invalid client route
	                    }
	                }
	            }
	        }
	    }
	}
	return routed;
}

public void routingFailed(JID receipient, Packet packet) {
    // If message was sent to an unavailable full JID of a user then retry using the bare JID
    if (serverName.equals(receipient.getDomain()) && receipient.getResource() != null &&
            userManager.isRegisteredUser(receipient.getNode())) {
        routingTable.routePacket(new JID(receipient.toBareJID()), packet, false);
    } else {
        // Just store the message offline
        messageStrategy.storeOffline((Message) packet);
    }
}