diff --git a/game-server/app/services/redisService.ts b/game-server/app/services/redisService.ts
index bfb0929ad..b356cfccf 100644
--- a/game-server/app/services/redisService.ts
+++ b/game-server/app/services/redisService.ts
@@ -14,7 +14,7 @@ import { comBtlRanges } from '../pubUtils/gamedata';
  * 在服务重新启动时，将信息存入redis
  */
 export async function initAllRank() {
-    const client: Redis.RedisClient = pinus.app.get('redis');
+    const client: Redis.RedisClient = redisClient();
     const serverList = await GameModel.getAllServerList();
     await client.delAsync(REDIS_KEY.ONLINE_USERS);
     await client.delAsync(REDIS_KEY.USER_INFO);
@@ -35,7 +35,7 @@ export async function initAllRank() {
  */
 export async function initRank(serverId: number) {
     // console.log('*****', 'initRank')
-    const client: Redis.RedisClient = pinus.app.get('redis');
+    const client: Redis.RedisClient = redisClient();
     await client.expireAsync(getKeyName(REDIS_KEY.TOWER_RANK, serverId), 30 * 24 * 60 * 60);
     await client.expireAsync(REDIS_KEY.PVP_RANK, 30 * 24 * 60 * 60);
     await client.expireAsync(REDIS_KEY.USER_INFO, 30 * 24 * 60 * 60);
@@ -64,9 +64,8 @@ export async function initSingleRank(key: string) {
  */
 export async function initSingleRankWithServer(key: string, serverId: number) {
 
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    await client.delAsync(getKeyName(key, serverId));
-    await client.expireAsync(key, 30 * 24 * 60 * 60);
+    await redisClient().delAsync(getKeyName(key, serverId));
+    await redisClient().expireAsync(key, 30 * 24 * 60 * 60);
     await setRankRedisFromDb(key, serverId);
 }
 
@@ -76,12 +75,11 @@ export async function initSingleRankWithServer(key: string, serverId: number) {
  * @param serverId 分服
  */
 async function setRankRedisFromDb(type: string, serverId: number) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     if(type == REDIS_KEY.TOWER_RANK) {
         let ranks = await RoleModel.getRank('tower', serverId, ['roleId', 'roleName', 'towerLv', 'lv', 'vLv', 'headHid', 'sHid', 'title', 'updatedAt']);
         for(let {towerLv, roleId, roleName, lv, vLv, towerUpTime, headHid, sHid, title} of ranks) {
             // console.log(roleId);
-            await client.zaddAsync(getKeyName(REDIS_KEY.TOWER_RANK, serverId), encodeScoreWithTime(towerLv, towerUpTime?towerUpTime.getTime():0), roleId);
+            await redisClient().zaddAsync(getKeyName(REDIS_KEY.TOWER_RANK, serverId), encodeScoreWithTime(towerLv, towerUpTime?towerUpTime.getTime():0), roleId);
             let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
             await redisUserInfoAdd(REDIS_KEY.USER_INFO, roleId, rankPram);
         }
@@ -90,7 +88,7 @@ async function setRankRedisFromDb(type: string, serverId: number) {
         for(let { code, icon, name, lv, leader, activeWeekly = 0, activeUpdateTime = 0 } of ranks) {
             let _leader = <RoleType>leader;
             let { roleName, title, sHid, headHid, lv: leaderLv } = _leader;
-            await client.zaddAsync(getKeyName(REDIS_KEY.GUILD_ACTIVE_RANK, serverId), encodeScoreWithTime(activeWeekly, activeUpdateTime * 1000 ), code);
+            await redisClient().zaddAsync(getKeyName(REDIS_KEY.GUILD_ACTIVE_RANK, serverId), encodeScoreWithTime(activeWeekly, activeUpdateTime * 1000 ), code);
             let rankParam = new GuildRankParam(icon, name, lv, { roleName, title, sHid, headHid, lv: leaderLv });
             await redisUserInfoAdd(REDIS_KEY.GUILD_INFO, code, rankParam);
         }
@@ -100,8 +98,7 @@ async function setRankRedisFromDb(type: string, serverId: number) {
 
 // 排行榜是否存在
 export async function existsRank(key: string, serverId: number) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    const result = await client.existsAsync(getKeyName(key, serverId));
+    const result = await redisClient().existsAsync(getKeyName(key, serverId));
     return result;
 }
 
@@ -115,37 +112,34 @@ export function getKeyName(key: string, serverId?: number) {
 
 // 更新玩家信息
 export async function redisUserInfoUpdate(key: string, roleId: string, arr: Array<{field: string, value:(string|number|GuildLeader)}>) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    let params = await client.hgetAsync(key, roleId);
+    let params = await redisClient().hgetAsync(key, roleId);
     if(params) {
         let obj = JSON.parse(params);
         for(let {field, value} of arr) {
             obj[field] = value;
         }
-        return await client.hsetAsync(key, roleId, JSON.stringify(obj));
+        return await redisClient().hsetAsync(key, roleId, JSON.stringify(obj));
     }
 }
 
 // 添加玩家信息缓存
 export async function redisUserInfoAdd(key: string, roleId: string, params: RankParam|GuildRankParam) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     let value = JSON.stringify(params);
-    return await client.hsetAsync(key, roleId, value);
+    return await redisClient().hsetAsync(key, roleId, value);
 }
 
 // 更新排行榜, 如pvp这样跨服的，serverId传0
 export async function setRank(key: string, serverId: number, myId: string, score: number, timestamp: number, params: RankParam|GuildRankParam, limit = 100) {
  
-    const client: Redis.RedisClient = pinus.app.get('redis');
     // 更新分数
     const _score = encodeScoreWithTime(score, timestamp);
-    await client.zaddAsync(getKeyName(key, serverId), _score, myId);
+    await redisClient().zaddAsync(getKeyName(key, serverId), _score, myId);
     // 移除100名以外
-    await client.zremrangebyrankAsync(getKeyName(key, serverId), limit, 10000);
+    await redisClient().zremrangebyrankAsync(getKeyName(key, serverId), limit, 10000);
 
     let infoKey = REDIS_RANK_TO_INFO.get(key);
     // 如果没有信息，更新玩家信息
-    const hasCurUser = await client.hexistsAsync(infoKey, myId);
+    const hasCurUser = await redisClient().hexistsAsync(infoKey, myId);
     if(!hasCurUser) {
         await redisUserInfoAdd(infoKey, myId, params);
     }
@@ -155,16 +149,15 @@ export async function setRank(key: string, serverId: number, myId: string, score
 // 获取排行榜
 export async function getRank(key: string, serverId: number, roleId: string) {
 
-    const client: Redis.RedisClient = pinus.app.get('redis');
     let ranks = [], myRank = null;
-    const rankFromDb = await client.zrevrangebyscoreAsync(getKeyName(key, serverId), '+inf', '-inf', "WITHSCORES", "LIMIT", 0, 100);
+    const rankFromDb = await redisClient().zrevrangebyscoreAsync(getKeyName(key, serverId), '+inf', '-inf', "WITHSCORES", "LIMIT", 0, 100);
 
     let infoKey = REDIS_RANK_TO_INFO.get(key);
 
     for(let ii = 0; ii < rankFromDb.length; ii+=2) {
         const _roleId = rankFromDb[ii];
         const _score = decodeScoreWithTime(rankFromDb[ii + 1]);
-        const info = await client.hgetAsync(infoKey, _roleId);
+        const info = await redisClient().hgetAsync(infoKey, _roleId);
         const _userInfo = JSON.parse(info);
         const tmp = {..._userInfo, num: _score, rank: Math.floor(ii/2)+1};
         if(infoKey == REDIS_KEY.USER_INFO) {
@@ -180,15 +173,13 @@ export async function getRank(key: string, serverId: number, roleId: string) {
 
 // 获取我的排名
 export async function getMyRank(key: string, serverId: number, roleId: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    let myRank = await client.zrevrankAsync(getKeyName(key, serverId), roleId);
+    let myRank = await redisClient().zrevrankAsync(getKeyName(key, serverId), roleId);
     return myRank + 1;
 }
 
 // 获取排名第几名的信息
 export async function getFieldByRank(key: string, serverId: number, rank: number) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    let myRank = await client.zrevrangeAsync(getKeyName(key, serverId), rank - 1, rank - 1);
+    let myRank = await redisClient().zrevrangeAsync(getKeyName(key, serverId), rank - 1, rank - 1);
     return myRank;
 }
 
@@ -209,8 +200,7 @@ function decodeScoreWithTime(num: string): number {
 
 // 从排行榜中移除
 export async function removeFromRank(key: string, serverId: number, myId: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    await client.zremAsync(getKeyName(key, serverId), myId);
+    await redisClient().zremAsync(getKeyName(key, serverId), myId);
 
     return true;
 }
@@ -246,14 +236,13 @@ function getComTeamValue(roleId: string, sid: string) {
  * @returns
  */
 export async function setTeamSearchReq(roleId: string, sid: string, qualityArr: Array<number>, lvRange: number) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     let cmds = [];
     qualityArr.forEach(quality => {
         if (quality) {
             cmds.push(['sadd', getComTeamKey(quality, lvRange), getComTeamValue(roleId, sid)]);
         }
     });
-    const multiClient = client.multi(cmds) as Redis.Multi;
+    const multiClient = redisClient().multi(cmds) as Redis.Multi;
     const newMulti = promisifyAll(multiClient) as Redis.Multi;
     const res = await newMulti.execAsync();
     console.log('setTeamSearchReq: ', res);
@@ -270,7 +259,6 @@ export async function setTeamSearchReq(roleId: string, sid: string, qualityArr:
  */
 export async function rmRoleFromQueue(roleId: string, sid: string, qualityArr: Array<number>, lvRange: number) {
 
-    const client: Redis.RedisClient = pinus.app.get('redis');
     let cmds = [];
     for (let q of qualityArr) {
         if (lvRange) {
@@ -281,7 +269,7 @@ export async function rmRoleFromQueue(roleId: string, sid: string, qualityArr: A
             }
         }
     };
-    const multiClient =  client.multi(cmds) as Redis.Multi;
+    const multiClient =  redisClient().multi(cmds) as Redis.Multi;
     const newMulti = promisifyAll(multiClient) as Redis.Multi;
     await newMulti.execAsync();
 }
@@ -294,9 +282,8 @@ export async function rmRoleFromQueue(roleId: string, sid: string, qualityArr: A
  * @returns
  */
 export async function getTeamSearchByQuality(quality: number, lvRange: number) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     // TODO: 操作不具有原子性
-    const userInfos = await client.srandmemberAsync(getComTeamKey(quality, lvRange), 2);
+    const userInfos = await redisClient().srandmemberAsync(getComTeamKey(quality, lvRange), 2);
     console.log('getTeamSearchByQuality: ' + userInfos);
     if (!userInfos || !userInfos.length) return null;
 
@@ -320,9 +307,8 @@ export async function getTeamSearchByQuality(quality: number, lvRange: number) {
  * @returns
  */
 export async function checkRoleInQueue(roleId: string, sid: string, qualityArr: Array<number>, lvRange: number) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     for (let quality of qualityArr) {
-        let res = await client.sismemberAsync(getComTeamKey(quality, lvRange), `${roleId}:${sid}`);
+        let res = await redisClient().sismemberAsync(getComTeamKey(quality, lvRange), `${roleId}:${sid}`);
         if (res) {
             return true;
         }
@@ -335,34 +321,40 @@ export async function checkRoleInQueue(roleId: string, sid: string, qualityArr:
  * @export
  */
 export async function clearComBtlQueue() {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     for (let q of COM_BTL_QUALITY) {
         for (let lvRange of comBtlRanges()) {
-            await client.delAsync(getComTeamKey(q, lvRange));
+            await redisClient().delAsync(getComTeamKey(q, lvRange));
         }
     }
 }
 
 export function setRedis(key: string, data: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    client.setAsync(key, data);
+    redisClient().setAsync(key, data);
 }
 
 export async function getRedis(key: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    const str =  await client.getAsync(key);
+    const str =  await redisClient().getAsync(key);
     return str;
 }
 
 export async function delRedis(key: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    await client.delAsync(key);
+    await redisClient().delAsync(key);
 }
 
 export function redisSidKey(roleId: string) {
     return `login_roleId_${roleId}`;
 }
 
+export async function redisChannelServer(roomId: string) {
+    const sid = await redisClient().hgetAsync(REDIS_KEY.ONLINE_USERS, roomId);
+    return sid;
+}
+
+export async function addRedisChannel(roomId: string, sid: string) {
+    const result = await redisClient().hsetAsync(REDIS_KEY.ONLINE_USERS, roomId, sid);
+    return result;
+}
+
 /**
  * 玩家上线
  * @param roleId role表id
@@ -370,9 +362,8 @@ export function redisSidKey(roleId: string) {
  * @param sid connector服的那个sid
  */
 export async function roleLogin(roleId: string, userCode: string, sid: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     let param = { userCode, sid };
-    return await client.hsetAsync(REDIS_KEY.ONLINE_USERS, roleId, JSON.stringify(param));
+    return await redisClient().hsetAsync(REDIS_KEY.ONLINE_USERS, roleId, JSON.stringify(param));
 }
 
 /**
@@ -380,8 +371,7 @@ export async function roleLogin(roleId: string, userCode: string, sid: string) {
  * @param roleId role表id
  */
 export async function roleLeave(roleId: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    return await client.hdelAsync(REDIS_KEY.ONLINE_USERS, roleId);
+    return await redisClient().hdelAsync(REDIS_KEY.ONLINE_USERS, roleId);
 }
 
 /**
@@ -389,8 +379,7 @@ export async function roleLeave(roleId: string) {
  * @param roleId role表id
  */
 export async function isRoleOnline(roleId: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    let result = await client.hexistsAsync(REDIS_KEY.ONLINE_USERS, roleId);
+    let result = await redisClient().hexistsAsync(REDIS_KEY.ONLINE_USERS, roleId);
     return !!result;
 }
 
@@ -399,8 +388,7 @@ export async function isRoleOnline(roleId: string) {
  * @param roleId 
  */
 export async function getRoleOnlineInfo(roleId: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    let str = await client.hgetAsync(REDIS_KEY.ONLINE_USERS, roleId);
+    let str = await redisClient().hgetAsync(REDIS_KEY.ONLINE_USERS, roleId);
     if(str) {
         try {
             let result = JSON.parse(str);
@@ -421,14 +409,12 @@ export async function getRoleOnlineInfo(roleId: string) {
  * 获得所有在线的玩家
  */
 export async function getAllOnlineRoles() {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    let allRoles = await client.hgetallAsync(REDIS_KEY.ONLINE_USERS);
+    let allRoles = await redisClient().hgetallAsync(REDIS_KEY.ONLINE_USERS);
     return allRoles;
 }
 
 export async function resetPvpRanks() {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    await client.delAsync(REDIS_KEY.PVP_RANK);
+    await redisClient().delAsync(REDIS_KEY.PVP_RANK);
     let { seasonNum } = await SystemConfigModel.findSystemConfig();
     console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
     let pvpRank = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
@@ -438,9 +424,9 @@ export async function resetPvpRanks() {
             continue;
         }
         let { roleName, headHid, sHid, title, lv, vLv } = role;
-        await client.zaddAsync(getKeyName(REDIS_KEY.PVP_RANK), encodeScoreWithTime(score, updatedAt?updatedAt.getTime():0), roleId);
+        await redisClient().zaddAsync(getKeyName(REDIS_KEY.PVP_RANK), encodeScoreWithTime(score, updatedAt?updatedAt.getTime():0), roleId);
         
-        const hasCurUser = await client.hexistsAsync(REDIS_KEY.USER_INFO, roleId);
+        const hasCurUser = await redisClient().hexistsAsync(REDIS_KEY.USER_INFO, roleId);
         if(!hasCurUser) {
             let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
             await redisUserInfoAdd(REDIS_KEY.USER_INFO, roleId, rankPram);
@@ -450,31 +436,26 @@ export async function resetPvpRanks() {
 
 // 排行榜是否存在
 export async function smembersAsync(key: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    const result = await client.smembersAsync(key);
+    const result = await redisClient().smembersAsync(key);
     return result;
 }
 
 export async function saddAsync(key: string, values: Array<string>) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    const result = await client.saddAsync(key, values);
+    const result = await redisClient().saddAsync(key, values);
     return result;
 }
 
 export async function sismemberAsync(key: string, value: string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    const result = await client.sismemberAsync(key, value);
+    const result = await redisClient().sismemberAsync(key, value);
     return result;
 }
 
 export async function delAsync(key:string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    await client.delAsync(key);
+    await redisClient().delAsync(key);
 }
 
 export async function sremAsync(key:string, member:string) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    await client.sremAsync(key, member);
+    await redisClient().sremAsync(key, member);
 }
 /**************** 寻宝相关 end */
 
@@ -485,20 +466,23 @@ export async function readDataBase() {
 }
 
 async function setServerList() {
-    const client: Redis.RedisClient = pinus.app.get('redis');
     const serverList = await GameModel.getAllServerList();
-    await client.delAsync(REDIS_KEY.DB_GAME);
+    await redisClient().delAsync(REDIS_KEY.DB_GAME);
 
     for(let { id, serverType, name } of serverList) {
         // console.log(roleId);
-        await client.hsetAsync(REDIS_KEY.DB_GAME, `${serverType}_${id}`, name);
+        await redisClient().hsetAsync(REDIS_KEY.DB_GAME, `${serverType}_${id}`, name);
     }
 }
 
 export async function getServerName(serverType: string, serverId: number) {
-    const client: Redis.RedisClient = pinus.app.get('redis');
-    let name = await client.hgetAsync(REDIS_KEY.DB_GAME, `${serverType}_${serverId}`);
+    let name = await redisClient().hgetAsync(REDIS_KEY.DB_GAME, `${serverType}_${serverId}`);
     return name
 }
 
+function redisClient() {
+    const client: Redis.RedisClient = pinus.app.get('redis');
+    return client;
+}
+
 /**************** 数据库表end */
\ No newline at end of file