Java CacheFactory类代码示例

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
@Override
public String remove(Object key) {
    String value;
    synchronized (this) {
        value = properties.remove(key);
        // Also remove any children.
        Collection<String> propNames = getPropertyNames();
        for (String name : propNames) {
            if (name.startsWith((String)key)) {
                properties.remove(name);
            }
        }
        deleteProperty((String)key);
    }

    // Generate event.
    Map<String, Object> params = Collections.emptyMap();
    MUCServicePropertyEventDispatcher.dispatchEvent(subdomain, (String)key, MUCServicePropertyEventDispatcher.EventType.property_deleted, params);

    // Send update to other cluster members.
    CacheFactory.doClusterTask(MUCServicePropertyClusterEventTask.createDeleteTask(subdomain, (String) key));

    return value;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Deletes the {@link PEPService} belonging to the specified owner.
 * 
 * @param owner
 *            The JID of the owner of the service to be deleted.
 */
public void remove(JID owner) {
	PEPService service = null;

	final Lock lock = CacheFactory.getLock(owner, pepServices);
	try {
		lock.lock();
		service = pepServices.remove(owner.toBareJID());
	} finally {
		lock.unlock();
	}

	if (service == null) {
		return;
	}

	// Delete the user's PEP nodes from memory and the database.
	CollectionNode rootNode = service.getRootCollectionNode();
	for (final Node node : service.getNodes()) {
		if (rootNode.isChildNode(node)) {
			node.delete();
		}
	}
	rootNode.delete();
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Retuns the total number of occupants in all rooms in the server.
 *
 * @param onlyLocal true if only users connected to this JVM will be considered. Otherwise count cluster wise.
 * @return the number of existing rooms in the server.
 */
@Override
public int getNumberConnectedUsers(boolean onlyLocal) {
    int total = 0;
    for (LocalMUCUser user : users.values()) {
        if (user.isJoined()) {
            total = total + 1;
        }
    }
    // Add users from remote cluster nodes
    if (!onlyLocal) {
        Collection<Object> results =
                CacheFactory.doSynchronousClusterTask(new GetNumberConnectedUsers(), false);
        for (Object result : results) {
            if (result == null) {
                continue;
            }
            total = total + (Integer) result;
        }
    }
    return total;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Removes a disco item for a component that has been removed from the server.
 *
 * @param jid the jid of the component being removed.
 */
public void removeComponentItem(String jid) {
    if (serverItems == null) {
        // Safety check
        return;
    }
    Lock lock = CacheFactory.getLock(jid, serverItems);
    try {
        lock.lock();
        ClusteredServerItem item = serverItems.get(jid);
        if (item != null && item.nodes.remove(XMPPServer.getInstance().getNodeID())) {
            // Update the cache with latest info
            if (item.nodes.isEmpty()) {
                serverItems.remove(jid);
            }
            else {
                serverItems.put(jid, item);
            }
        }
    }
    finally {
        lock.unlock();
    }
    // Remove locally added server item
    localServerItems.remove(jid);
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Starts the cluster service if clustering is enabled. The process of starting clustering
 * will recreate caches as distributed caches.<p>
 *
 * Before starting a cluster the
 * {@link XMPPServer#setRemoteSessionLocator(org.jivesoftware.openfire.session.RemoteSessionLocator)} and
 * {@link org.jivesoftware.openfire.RoutingTable#setRemotePacketRouter(org.jivesoftware.openfire.RemotePacketRouter)}
 * need to be properly configured.
 */
public static synchronized void startup() {
    if (isClusteringStarted()) {
        return;
    }
    // See if clustering should be enabled.
    if (isClusteringEnabled()) {
        if (XMPPServer.getInstance().getRemoteSessionLocator() == null) {
            throw new IllegalStateException("No RemoteSessionLocator was found.");
        }
        if (XMPPServer.getInstance().getRoutingTable().getRemotePacketRouter() == null) {
            throw new IllegalStateException("No RemotePacketRouter was found.");
        }
        // Start up the cluster and reset caches
        CacheFactory.startClustering();
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Retrieves a PEP service -- attempting first from memory, then from the
 * database.
 * 
 * @param jid
 *            the bare JID of the user that owns the PEP service.
 * @return the requested PEP service if found or null if not found.
 */
public PEPService getPEPService(String jid) {
	PEPService pepService = null;

	final Lock lock = CacheFactory.getLock(jid, pepServices);
	try {
		lock.lock();
		if (pepServices.containsKey(jid)) {
			// lookup in cache
			pepService = pepServices.get(jid);
		} else {
			// lookup in database.
			pepService = loadPEPServiceFromDB(jid);
			
			// always add to the cache, even if it doesn't exist. This will
			// prevent future database lookups.
			pepServices.put(jid, pepService);
		}
	} finally {
		lock.unlock();
	}

	return pepService;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void joinedCluster(byte[] nodeID) {
    Object result = CacheFactory.doSynchronousClusterTask(new GetNewMemberRoomsRequest(), nodeID);
    if (result instanceof List<?>) {
        List<RoomInfo> rooms = (List<RoomInfo>) result;
        for (RoomInfo roomInfo : rooms) {
            LocalMUCRoom remoteRoom = roomInfo.getRoom();
            MultiUserChatServiceImpl service = (MultiUserChatServiceImpl)remoteRoom.getMUCService();
            LocalMUCRoom localRoom = service.getLocalChatRoom(remoteRoom.getName());
            if (localRoom == null) {
                // Create local room with remote information
                localRoom = remoteRoom;
                service.chatRoomAdded(localRoom);
            }
            // Add remote occupants to local room
            for (OccupantAddedEvent event : roomInfo.getOccupants()) {
                event.setSendPresence(true);
                event.run();
            }
        }
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Approves or cancels a subscriptions that was pending to be approved by a node owner.
 * Subscriptions that were not approved will be deleted. Approved subscriptions will be
 * activated (i.e. will be able to receive event notifications) as long as the subscriber
 * is not required to configure the subscription.
 *
 * @param subscription the subscriptions that was approved or rejected.
 * @param approved true when susbcription was approved. Otherwise the subscription was rejected.
 */
public void approveSubscription(NodeSubscription subscription, boolean approved) {
    if (!subscription.isAuthorizationPending()) {
        // Do nothing if the subscription is no longer pending
        return;
    }
    if (approved) {
        // Mark that the subscription to the node has been approved
        subscription.approved();
        CacheFactory.doClusterTask(new ModifySubscriptionTask(subscription));
    }
    else  {
        // Cancel the subscription to the node
        cancelSubscription(subscription);
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
public Presence updateOccupant(UpdateOccupantRequest updateRequest) throws NotAllowedException {
    MUCRole occupantRole = occupants.get(updateRequest.getNickname().toLowerCase());
    if (occupantRole != null) {
        if (updateRequest.isAffiliationChanged()) {
            occupantRole.setAffiliation(updateRequest.getAffiliation());
        }
        occupantRole.setRole(updateRequest.getRole());
        // Notify the othe cluster nodes to update the occupant
        CacheFactory.doClusterTask(new UpdateOccupant(this, occupantRole));
        return occupantRole.getPresence();
    }
    else {
        Log.debug("LocalMUCRoom: Failed to update information of local room occupant. Occupant nickname: " +
                updateRequest.getNickname());
    }
    return null;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
public Collection<String> getGroupNames(JID user) {
	Cache<JID, Collection<String>> userMembershipCache = CacheFactory.createCache(USER_MEMBERSHIP_CACHE_NAME);
	Collection<String> groups = userMembershipCache.get(user);
	if (groups != null) {
		return groups;
	}
	
	try {
		groups = manager.getUserGroups(user.getNode());
		userMembershipCache.put(user, groups);
		return groups;
	} catch (RemoteException re) {
		LOG.error("Failure to load the groups of user:" + String.valueOf(user), re);
	}
	
	userMembershipCache.put(user, new ArrayList<String>());
	return Collections.emptyList();
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Returns the secret key that was randomly generated. When running inside of a cluster
 * the key will be unique to all cluster nodes.
 *
 * @return the secret key that was randomly generated.
 */
private static String getSecretkey() {
    String key = "secretKey";
    Lock lock = CacheFactory.getLock(key, secretKeyCache);
    try {
        lock.lock();
        String secret = secretKeyCache.get(key);
        if (secret == null) {
            secret = StringUtils.randomString(10);
            secretKeyCache.put(key, secret);
        }
        return secret;
    }
    finally {
        lock.unlock();
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
@Override
public Collection<String> getGroupNames(JID user) {
    Cache<JID, Collection<String>> userMembershipCache = CacheFactory.createCache(USER_MEMBERSHIP_CACHE_NAME);
    Collection<String> groups = userMembershipCache.get(user);
    if (groups != null) {
        return groups;
    }
    
    try {
        groups = manager.getUserGroups(user.getNode());
        userMembershipCache.put(user, groups);
        return groups;
    } catch (RemoteException re) {
        LOG.error("Failure to load the groups of user:" + String.valueOf(user), re);
    }
    
    userMembershipCache.put(user, new ArrayList<String>());
    return Collections.emptyList();
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Retuns the total number of occupants in all rooms in the server.
 *
 * @param onlyLocal true if only users connected to this JVM will be considered. Otherwise count cluster wise.
 * @return the number of existing rooms in the server.
 */
public int getNumberConnectedUsers(boolean onlyLocal) {
    int total = 0;
    for (LocalMUCUser user : users.values()) {
        if (user.isJoined()) {
            total = total + 1;
        }
    }
    // Add users from remote cluster nodes
    if (!onlyLocal) {
        Collection<Object> results =
                CacheFactory.doSynchronousClusterTask(new GetNumberConnectedUsers(), false);
        for (Object result : results) {
            if (result == null) {
                continue;
            }
            total = total + (Integer) result;
        }
    }
    return total;
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
/**
 * Returns the set of active conversations.
 *
 * @return the active conversations.
 */
public Collection<Conversation> getConversations() {
    if (ClusterManager.isSeniorClusterMember()) {
        List<Conversation> conversationList = new ArrayList<Conversation>(conversations.values());
        // Sort the conversations by creation date.
        Collections.sort(conversationList, new Comparator<Conversation>() {
            public int compare(Conversation c1, Conversation c2) {
                return c1.getStartDate().compareTo(c2.getStartDate());
            }
        });
        return conversationList;
    } else {
        // Get this info from the senior cluster member when running in a cluster
        return (Collection<Conversation>) CacheFactory.doSynchronousClusterTask(new GetConversationsTask(), ClusterManager
                .getSeniorClusterMember().toByteArray());
    }
}
 

import org.jivesoftware.util.cache.CacheFactory; //导入依赖的package包/类
@Override
public boolean removeComponentRoute(JID route) {
    String address = route.getDomain();
    boolean removed = false;
    Lock lock = CacheFactory.getLock(address, componentsCache);
    try {
        lock.lock();
        Set<NodeID> nodes = componentsCache.get(address);
        if (nodes != null) {
            removed = nodes.remove(server.getNodeID());
            if (nodes.isEmpty()) {
                componentsCache.remove(address);
            }
            else {
                componentsCache.put(address, nodes);
            }
        }
    } finally {
        lock.unlock();
    }
    localRoutingTable.removeRoute(new DomainPair("", address));
    return removed;
}