Redis è più di un negozio di valori chiave.
Quindi vuoi quanto segue:
- messaggi chat,
- discussioni tra due persone,
- non hai menzionato i limiti di tempo, quindi supponiamo che archivi i messaggi dopo un po',
- inoltre non dici se vuoi "thread" separati tra due persone, come forum o messaggi continui, come facebook. Presumo continuo.
Per ogni utente, devi memorizzare i messaggi che invia. Diciamo APP_NAMESPACE:MESSAGES:<USER_ID>:<MESSAGE_ID> . Aggiungiamo userId qui in modo da poter recuperare facilmente tutti i messaggi inviati da un singolo utente.
E, per ogni due utenti, devi tenere traccia delle loro conversazioni. Come chiave, puoi semplicemente usare i loro ID utente APP_NAMESPACE:CONVERSATIONS:<USER1_ID>-<USER2_ID> . Per assicurarti di ottenere sempre la stessa conversazione condivisa per i due utenti, puoi ordinare i loro ID in ordine alfabetico, in modo che gli utenti 132 e 145 abbiano entrambi 132:145 come chiave di conversazione
Quindi cosa memorizzare nelle "conversazioni"? Usiamo un elenco:[messageKey, messageKey, messageKey] .
Ok, ma qual è ora la messageKey? Combinazione di userId sopra e un messageId (così possiamo ottenere il messaggio vero e proprio).
Quindi, fondamentalmente, hai bisogno di due cose:
- Memorizza il messaggio e assegnagli un ID
- Memorizza un riferimento a questo messaggio nella conversazione pertinente.
Con il nodo e il client standard redis/hiredis questo sarebbe qualcosa del tipo (salterò gli errori evidenti ecc. e scriverò ES6. Se non riesci ancora a leggere ES6, incollalo su babel):
// assuming the init connects to redis and exports a redisClient
import redisClient from './redis-init';
import uuid from `node-uuid`;
export function storeMessage(userId, toUserId, message) {
return new Promise(function(resolve, reject) {
// give it an id.
let messageId = uuid.v4(); // gets us a random uid.
let messageKey = `${userId}:${messageId}`;
let key = `MY_APP:MESSAGES:${messageKey}`;
client.hmset(key, [
"message", message,
"timestamp", new Date(),
"toUserId", toUserId
], function(err) {
if (err) { return reject(err); }
// Now we stored the message. But we also want to store a reference to the messageKey
let convoKey = `MY_APP:CONVERSATIONS:${userId}-${toUserId}`;
client.lpush(convoKey, messageKey, function(err) {
if (err) { return reject(err); }
return resolve();
});
});
});
}
// We also need to retreive the messages for the users.
export function getConversation(userId, otherUserId, page = 1, limit = 10) {
return new Promise(function(resolve, reject) {
let [userId1, userId2] = [userId, otherUserId].sort();
let convoKey = `MY_APP:CONVERSATIONS:${userId1}-${userId2}`;
// lets sort out paging stuff.
let start = (page - 1) * limit; // we're zero-based here.
let stop = page * limit - 1;
client.lrange(convoKey, start, stop, function(err, messageKeys) {
if (err) { return reject(err); }
// we have message keys, now get all messages.
let keys = messageKeys.map(key => `MY_APP:MESSAGES:${key}`);
let promises = keys.map(key => getMessage(key));
Promise.all(promises)
.then(function(messages) {
// now we have them. We can sort them too
return resolve(messages.sort((m1, m2) => m1.timestamp - m2.timestamp));
})
.catch(reject);
});
});
}
// we also need the getMessage here as a promise. We could also have used some Promisify implementation but hey.
export function getMessage(key) {
return new Promise(function(resolve, reject) {
client.hgetall(key, function(err, message) {
if (err) { return reject(err); }
resolve(message);
});
});
}
Ora è grezzo e non testato, ma questo è il succo di come puoi farlo.
