定制网站【uni-app】小程序实现微信在线聊天（私聊/群聊）

定制网站之前学习使用简单实现定制网站一个在线聊天的功能，定制网站今天记录一下项目核心定制网站功能的实现过程。页面UI定制网站以及功能逻辑全部来源于微信，定制网站即时聊天业务的实现使用socket.io，前端使用uni-app开发，定制网站后端服务器基于node实现，定制网站数据库选择mongoDB。

定制网站首先在系统中注册两个用户，定制网站将对方添加为好友后，定制网站开始正常聊天，定制网站先简单看一下聊天功能的效果图，定制网站分为私聊和群聊两大部分

定制网站一对一聊天效果：

定制网站在好友列表中添加群成定制网站员创建群后即可群聊，群聊效果：

目录

定制网站聊天信息列表的渲染

定制网站聊天信息列表区域是一个滚动区，这里使用scroll-view组件，定制网站其中对于聊天信息展示，定制网站主要分为自己的消息和定制网站好友的消息，定制网站自己的消息位于右侧，定制网站好友的消息位于左侧，定制网站所以静态页面阶段要实定制网站现是左侧消息和右侧消定制网站息的页面布局，定制网站以及这些消息类型为文字，图片，语音，定制网站位置信息时的布局。

定制网站后端接口返回的聊天信定制网站息是按照时间顺序排列的，定制网站渲染聊天信息时使用v-for遍历定制网站接口返回的消息列表的内容即可，定制网站需要注意的是，定制网站还需要使用条件渲染v-if定制网站根据每一条消息的发送者id定制网站和定制网站当前用户的id定制网站判断消息的发送方和接受方，定制网站渲染在左右指定的区域，当前用户的id定制网站从本地存储localStorage中获取；还有就是定制网站使用条件渲染判断消息的类型，是文字，图片，定制网站语音或定位，合理展示。

  1. <!-- 定制网站一条聊天记录  -->
  2. <view class="chat-item" v-for="(item,index) in msg" :key="item.id">
  3.     <!-- 时间  -->
  4. 	<view class="time" v-if="item.isShowTime">{{handleTime(item.time)}}</view>
  5. 	<!-- b - 定制网站对方的消息  -->
  6. 	<view class="content-wrapper-left" v-if="item.fromId !== uid" >
  7.         <!-- 头像 -->
  8. 		<image :src="item.imgUrl" class="avator avator-left"></image>
  9. 		<!-- 0 - 文字 -->
  10. 		<view class="chat-content-left" v-if="item.types === '0'">......</view>
  11. 		<!-- 1 - 图片 -->
  12. 		<view class="chat-image-left" v-if="item.types === '1'">......</view>
  13. 		<!-- 2 - 语音 -->
  14. 		<view class="chat-voice-left" v-if="item.types === '2'">......</view>
  15. 		<!-- 3 - 位置信息 -->
  16. 		<view class="chat-site-left" v-if="item.types === '3'">......</view>	
  17. 	</view>
  18. 	<!--a - 定制网站自己的信息-->
  19. 	<view class="content-wrapper-right" v-if="item.fromId === uid">
  20. 		<!-- 0 - 文字 -->
  21. 		<view class="chat-content-right" v-if="item.types === '0'">......</view>
  22. 		<!-- 1 - 图片 -->
  23. 		<view class="chat-image-right" v-if="item.types === '1'">......</view>
  24. 		<!-- 2 - 语音 -->
  25. 		<view class="chat-voice-right" v-if="item.types === '2'">......</view>
  26. 		<!-- 3 - 位置信息 -->
  27. 		<view class="chat-site chat-site-right">......</view>
  28. 		<!-- 头像 -->
  29. 		<image :src="item.imgUrl" class="avator avator-right"></image>
  30. 	</view>
  31. </view>

定制网站聊天信息发送的相关问题

定制网站点击发送按钮，定制网站正式将信息发送给服务器之前，定制网站还有几个问题需要解决，定制网站这里面有许多坑，定制网站在实现的时候走了不少弯路。

1.scroll-view定制网站如何始终定位在最底部？

如下图，定制网站当发送了一条聊天信息时，定制网站聊天信息列表就会增加这条消息，定制网站之所以能够看到这条消息，定制网站那是因为的滚动条在消定制网站息添加时将位置定位到了最底部，定制网站这是需要进行一些处理的，定制网站默认效果是这样的

定制网站是不是很变扭？定制网站这样的用户体验很差，定制网站滚动条不会自动定位到底部，定制网站这里需要给scroll-view定制网站组件添加一个scroll-into-view属性，定制网站按照官方文档的说法它的值应为某子元素id。设置哪个方向可滚动，则在哪个方向滚动到该元素，也就是说可以动态的修改这个属性的值，从而让scroll-view组件的滚动到想要滚动的页面元素位置。

这里就给每一个scroll-view的子元素(聊天记录item)添加id属性，属性值为 msg + 每条聊天记录的id

  1. <scroll-view class="chat-main" 
  2.  scroll-y="true" 
  3.  :scroll-into-view="scrollToView"
  4.  :scroll-with-animation="needScrollAnimation"
  5.  :style="{height:paddingBottom}">
  6.     <!-- 聊天记录item --->
  7.     <view class="chat-item" v-for="(item,index) in msg" :id="'msg' + item.id" :key="item.id" >
  8.         ......
  9.     </view>
  10. </scroll-view>

在发送消息的方法中修改scroll-into-view的值scrollToView，让其为最新一条聊天记录即msg.length - 1的id值，必须使用在$nextTick回调中，这是为了在新的聊天记录渲染完毕后再去定位。

  1. this.$nextTick(function(){
  2. 	this.scrollToView = 'msg' + this.msg[this.msg.length - 1].id;
  3. });

 这样才能实现最终的效果

 

2.如何动态修改scroll-view的高度

如下图，点击 + 按钮发送位置信息时会弹出底部菜单栏，但此时scroll-view内的聊天内容会被覆盖，用户想要看最后一条记录还需操作滚动条，这也是不好的用户体验。

需要做到的是弹出底部菜单栏的同时减小聊天内容区域scroll-view组件的高度，让用户能够完整的看到最后的聊天记录。

需要获取底部菜单栏弹出的高度，随后让scroll-view组件减少这部分高度即可。在uni-app中无法操作dom，获取元素的尺寸使用createSelectorQuery获取页面节点，再用 boundingClientRect查询节点的尺寸。官方文档：

使用如下代码获取页面节点的尺寸，可能无法及时获取到(得到的可能是undefined)，这里需要用定时器包裹，才能拿到菜单栏的高度

  1. <view class="more-view" v-show="showMore">
  2. 	<swiper :indicator-dots="true">
  3. 		<swiper-item v-for="(swiper,index1) in moreArr" :key="index1">
  4. 			<view class="swiper-item" v-for="(list,index2) in swiper" :key="index2">
  5. 				<view class="item-wrapper" v-for="item in list" :key="item.id">
  6. 					<view class="pic-wrapper" :class="{hidePicWrapper:!item.pic}">
  7. 						<image :src="item.pic" @tap="handleMoreFunction(item.flag)"></image>
  8. 					</view>
  9. 					<view class="text-wrapper">{{item.text}}</view>
  10. 				</view>
  11. 			</view>
  12. 		</swiper-item>
  13. 	</swiper>
  14. </view>
  15.  
  16. ......
  17.  
  18. // 获取指定选择器元素的高度
  19. getHeight(classNa){
  20. 	setTimeout(() => {
  21. 		const query = uni.createSelectorQuery().in(this);
  22. 		query.select(classNa).boundingClientRect(data => {
  23. 			this.$emit('heightChange',data.height);
  24. 		}).exec();
  25. 	},10);
  26. },
  27. // 切换菜单栏显示隐藏
  28. changeMode(){	
  29. 	if(this.showMore){
  30. 		this.showMore = !this.showMore;
  31. 		this.getHeight('.more-view');
  32. 	}
  33. },
  34.

拿到底部菜单栏的高度后，使用calc计算并修改行内样式，并修改scroll-view的元素内的子元素定位，这里修改scrollToView的值，一定要置空后再修改，否则会修改无效。

  1. <scroll-view class="chat-main" 
  2.  scroll-y="true" 
  3.  :scroll-into-view="scrollToView"
  4.  :scroll-with-animation="needScrollAnimation"
  5.  @scrolltoupper="debounce"
  6.  :style="{height:scrollViewHeight}"
  7. ></scroll-view>
  8.  
  9. ...... 
  10.  
  11. // 弹出菜单栏修改scroll-view高度
  12. handleHeightChange(height){
  13. 	this.scrollViewHeight= `calc(100vh - 208rpx - ${height}px - ${this.statusBarHeight}px)`;
  14. 	this.scrollToView = '';
  15. 	this.$nextTick(function(){		
  16. 		this.scrollToView = 'msg' + this.msg[this.msg.length - 1].id;
  17. 	})
  18. }

实现一对一聊天

关于

项目中使用的socket.io底层使用到的是websocket协议，可以实现服务器主动推送消息给客户端，一般应用于实时通信，在线支付等场景，虽然socket.io对其进行了封装，但对其原理的了解还是有必要的。

在websock出现之前，一般使用ajax轮询(设置定时器在相同时间间隔内反复发送请求到服务器拿到服务器最新的数据)，长轮询(在指定时间内不让当前请求断开)，流化技术等手段进行即时通信，这三者都基于http协议实现，但都非常占用服务器的资源， 显著增加了延时。

websocket协议解决这些缺点，它是一种全双工、双向、单套接字的连接，建立在TCP协议之上，当websocket连接建立后，服务器和客户端可以双向通信，具有以下特点：

1）建立在TCP协议之上，服务端的实现比较容易；

2）于HTTP协议有着良好的兼容性，默认的端口也是80和443，并且握手阶段采用HTTP协议；

3）数据格式轻量，性能开销小，通信高效；

4）可以发送文本，也可以发送二进制数据；

5）没有同源限制

http请求响应图解：

客户端发送请求，服务器响应，至此一次请求响应结束，再次获取服务端最新数据，需要再次重复上述过程；

websocket图解：

黄色部分是握手阶段，客户端给服务端发送请求，该请求基于http协议，服务器返回101状态码，代表成功建立连接，随后客户端和服务器可以开始全双工数据交互，且服务器可以主动推送消息给浏览器，下面是websocket的请求报文：

1.使用websocket请求行的路径是以ws开头，代表使用的是websocket协议

2.请求头Connection:Upgrade代表当前服务器这是一个升级的链接

3.请求头Upgrade:websocket代表需要将当前的链接升级为websocket链接

4.请求头Sec-WebSocket-Key: JnoOq+qL9WP3um80g1Sz3A==是客户端使用base64编码的24位随机字符序列，用户服务器标识当链接的客户端，同时要求服务器响应一个同样加密的Sec-WebSocket-Accept头作为应答；

websocket响应报文如下：

1.服务器响应101状态码代表websocket链接建立成功

2.响应头Sec-WebSocket-Accept: Eu6A8ipjouG1LVFt6xFMSrPFk1E=是对客户端请求头Sec-WebSocket-Key的应答，用于给客户端标识当前的服务器

客户端websocket实现

websocket是HTML5的新特性之一，首先你的浏览器必须支持websocket

1.创建WebSocket实例

const ws = new WebSocket('ws:localhost:8000');

参数url：ws://ip地址:端口号/资源名

2.WebSocket对象包含以下事件

open：连接建立时触发

message：客户端接收服务端数据时触发

error：通信发生错误时触发

close：连接关闭时触发

3.WebSocket对象常用方法

send()：使用连接给服务端发送数据

客户端websocket代码模板：

  1. ;((doc,WebSocket) => {
  2.  
  3.     const msg = doc.querySelector('#msg');  // 获取输入框，需要发送的消息
  4.     const send = doc.querySelector('#send');  // 发送按钮
  5.  
  6.     // 创建websocket实例
  7.     const ws = new WebSocket('ws:localhost:8000');
  8.     
  9.     // 初始化
  10.     const init = () => {
  11.         bindEvent();
  12.     }
  13.     
  14.     // 绑定事件
  15.     function bindEvent () {
  16.         send.addEventListener('click',handleSendBtnClick,false);
  17.         ws.addEventListener('open',handleOpen,false);
  18.         ws.addEventListener('close',handleClose,false);
  19.         ws.addEventListener('error',handleError,false);
  20.         ws.addEventListener('message',handleMessage,false);
  21.  
  22.     }
  23.  
  24.     function handleSendBtnClick () {
  25.         const message = msg.value;
  26.         
  27.         // 将数据发送给服务器
  28.         ws.send(JSON.stringify({
  29.             message:message
  30.         }));
  31.  
  32.         msg.value = '';
  33.     }
  34.  
  35.     function handleOpen () {
  36.         console.log('open');
  37.         // 当连接建立时，一般做一些页面初始化操作
  38.     }
  39.     
  40.     function handleClose () {
  41.         console.log('close');
  42.         // 当连接关闭时
  43.     }
  44.  
  45.     function handleError () {
  46.         console.log('error');
  47.         // 当连接出现异常时
  48.     }
  49.  
  50.     function handleMessage (e) {
  51.         // 在这里获取后端广播的数据，数据通过事件对象e活得，数据存放在e.data中
  52.         const showMsg = JSON.parse(e.data);
  53.     }
  54.  
  55.     init();
  56. })(document,WebSocket)

由此可见，使用原生websocket完全可以进行聊天通信，但是它提供的事件和api有限，对于一些复杂的需求实现起来比较困难，socket.io是一个websocket库，它对于websocket进行了很好的封装，提供了许多api，以及自定义事件，使用起来比较灵活。

聊天功能的前后端交互顺序图

需要实现的是客户端A发送消息给客户端B，客户端B能够自动接收并显示，实现私聊的关键是要确定需要将消息发送给谁，所以在进入聊天界面的的时候，每一个连接服务器的客户端就需要将自己的id告诉服务器，服务器会维护一个对象专门用于存放当前已连接的用户id。

客户端A进入聊天界面的的时候，还需要存放客户端B的用户id，在发送消息的时候将客户端B的id传递给服务器，让服务器知道当前的这条消息要发送给谁，服务器收到后就会查询存放用户id的对象，如果客户端B连接那么就将A的消息发送给它，这就是私聊的大致思路。

建立连接

能够实现客户端之间的通信首先需要将客户端与服务器建立连接，首先下载依赖，客户端使用weapp.socket.io，服务端使用socket.io

  1. npm i socket.io@2.3.0 --save
  2. npm i express@4.17.1 --save
  3. npm i weapp.socket.io@2.1.0 --save

为了保证能连接正常，建议下载指定版本，前后端版本不匹配会导致连接失败报错。

官方文档英文：

W3Cschool中文文档：

客户端：

客户端下载完毕后，可以将weapp.socket.io.js文件单独拿出，其存放的文件位置如下图

将其放在项目指定文件夹下引入，这里放在socket文件下；随后在项目的main.js中引入使用，这里将io挂载在Vue的原型上，供全局使用，连接地址为服务器的地址，端口号需与服务器socket.io监听的端口保持一致；

  1. import io from './socket/weapp.socket.io.js'
  2. Vue.prototype.socket = io('http://localhost:8000');

服务器：

服务器使用node的express框架搭建，在入口js中配置如下，io.on用于绑定事件，connection事件在连接时触发，它是socket.io内置事件之一。

  1. const express = require('express');
  2. const app = express();
  3. let server = app.listen(8000);
  4. let io = require('socket.io').listen(server);
  5.  
  6. io.on('connection',(socket) => {   
  7.     console.log("socket.io连接成功");
  8. });

socket.io建立连接会产生跨域问题，这里直接通过express的方式使用CORS解决跨域：

  1. app.all('*', function(req, res, next) {
  2.   res.header("Access-Control-Allow-Origin", "*");
  3.   res.header("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With");
  4.   res.header("Access-Control-Allow-Methods","PUT,POST,GET,DELETE,OPTIONS");
  5.   res.header("X-Powered-By",' 3.2.1')
  6.   if(req.method=="OPTIONS") res.send(200);/*让options请求快速返回*/
  7.   else  next();
  8. });

当然socket.io也提供了跨域的解决方案，具体可见 

完成以上配置后，启动项目，客户端便可使用socket.io与服务器正常连接。

观察浏览器network选项卡，请求类型为websocket，响应状态码101，可见socket.io的连接底层走的就是websocket协议

存储连接的用户

用户登陆成功跳转到index主页，每一位用户在注册时都会在数据库生成一个唯一的用户id，这里需要将每一个连接成功的用户id发送给服务器

       =>     

socket.io服务端除了connection(socket连接成功之后触发)，message(客户端通过socket.send来传送消息时触发此事件)，disconneting(socket失去连接时触发，包括关闭浏览器，主动断开，掉线等任何断开连接的情况) 等内置的默认事件外，还可以使用自定义事件，客户端也类似。

API上，使用emit()触发事件，使用on()绑定事件，进入首页后在客户端onLoad中触发自定义事件login，同时从本地存储中取出用户uid，上传服务器

  1. export default {
  2. 	data() {
  3. 		return {
  4. 			uid:'',  // 当前用户id
  5. 	},
  6.     onLoad() {
  7. 		this.getStroage();
  8.         this.addUserToSocket(this.uid);
  9.     },
  10.     methods:{
  11.         // 获取本地存储
  12.         getStroage(){
  13. 			const value = uni.getStorageSync('user');
  14. 			if(value){
  15. 			    this.uid = value.id;
  16. 			} else {
  17. 				uni.navigateTo({
  18. 					 url:'/pages/login/login'
  19. 				})
  20. 			}
  21. 	    },
  22.         // 添加连接的用户
  23.         addUserToSocket(uid){
  24. 		    this.socket.emit('login',uid);
  25. 		},
  26.     }
  27. }

在服务端绑定login事件，同时创建对象connectedUsers存放连接的用户， 将用户uid作为key保存，value是socket.id，socket.id是connection回调参数的一个属性，socket.id用于socket.io唯一标识连接的用户。

当用户退出应用时触发disconnecting事件，将此用户信息从connectedUsers对象中删除。

  1. let connectedUsers = {}; 
  2. io.on('connection',(socket) => {   
  3.     
  4.     console.log("socket.io连接成功");
  5.     // console.log(socket);
  6.     // 用户进入主页时获取用户id保存
  7.     socket.on('login',(id) => {
  8.         console.log("socket.id:" + socket.id);
  9.         socket.name = id;
  10.         connectedUsers [id] = socket.id;
  11.     });
  12.  
  13.     // 用户离开
  14.     socket.on('disconnecting',() => {
  15.         console.log('leave：' + socket.id);
  16.         if(users.hasOwnProperty(socket.name)){
  17.             delete connectedUsers [socket.name];
  18.         }
  19.     });
  20. });

总结：

1）io.on可用来给当前socket连接绑定connection事件，参数socket可以获取这次连接的配置信息，最常用的就是socket.id，它是本次连接的唯一标识

io.on('connection',function(socket){ ...... })

2）on用于绑定事件,用于接收传递的数据

socket.on('自定义事件名',function(参数1,参数2,......,参数n) { ...... });

3）emit用于触发事件，用于传递数据

socket.emit('自定义事件名',参数1,参数2,......,参数n);

4）disconnecting在失去连接时时触发，断开可能是关闭浏览器，主动断开，掉线等导致

socket.on('disconnecting',() => {}）

发送聊天信息 

客户端发送消息，将聊天内容加工处理后，触发自定义事件msg，将内容，发送者id和接收者id发送给服务器，代码如下：

客户端chatroom.vue：

  1. // 发送聊天数据
  2. sendSocket(msg){
  3. 	if(this.type === '0'){
  4. 		// 1对1聊天
  5. 		this.socket.emit('msg',msg,this.uid,this.fid);
  6. 	} else {
  7. 		// 群消息
  8. 		this.socket.emit('gmsg',msg,this.uid,this.fid);
  9. 	}
  10. },

服务器绑定msg事件，得到客户端发来数据，首先需要操作数据库完成插入最新的聊天内容，更改最后的通讯时间等操作，如果对方用户在线，则connectedUsers 对象中必然存在该用户的id，使用socket.to(指定接收者的socket.io)将消息发送给指定的用户，同时触发自定义事件backMsg，用法如下：

发送给指定 socketid 的客户端（私密消息）

socket.to(<socketid>).emit('自定义事件名', 参数);

注意：如果不使用socket.to方法直接调用emit，则会发送给所有在线的用户。 

服务器代码：

  1. // 引入数据库文件
  2. let dataBase= require("./dataBase");
  3. // 1对1消息发送
  4. socket.on('msg',(msg,fromId,toId) => {
  5.     console.log('服务器收到用户' + fromId + '发送给' + toId + '的消息')
  6.     console.log('发送的消息是：',msg);
  7.     // 修改好友最后通讯时间
  8.     dataBase.updateLastMsgTime(fromId,toId);
  9.     dataBase.updateLastMsgTime(toId,fromId);
  10.     // 添加消息
  11.     dataBase.insertMsg(fromId,toId,msg.message,msg.types);
  12.     console.log('数据库插入成功');
  13.     
  14.     // 将获取的消息发送给好友，users[toId]就是好友的socket.id
  15.     if(connectedUsers[toId]){
  16.         console.log('将消息发送给',toId,'成功');
  17.         socket.to(connectedUsers[toId]).emit('backMsg',msg,fromId,0);
  18.     }   
  19. });

这样客户端绑定backMsg事件，就能拿到发送消息了！处理消息展示即可，但需要判断当前用户此时打开的聊天界面是否就是当前发送者聊天对话框即if(fromId === this.fid && type === 0)，否则会造成聊天内容的错误展示，比如当前用户可能存在多个好友，客户端A给客户端B发消息时B打开的是和C的聊天对话框，此时就会在C的对话框中错误的收到A发来的消息

客户端chatroom.vue：

  1. this.socket.on('backMsg',(msg,fromId,type) => {
  2. 	// 如果是1对1消息fromId是当前聊天窗口的好友id时执行
  3. 	if(fromId === this.fid && type === 0){
  4. 		......
  5. 		// 一条聊天记录
  6. 		let newMsg = {
  7. 			fromId:fromId,
  8. 			id:msg.id,
  9. 			imgUrl:msg.imgUrl,
  10. 			message:msg.message,
  11. 			types:msg.types,  // 0 - 文字信息，1 - 图片信息, 2 - 音频
  12. 			time:new Date(),
  13. 			isFirstPlay:true,
  14. 		};
  15. 		this.msg.push(newMsg);  
  16. 		// 如果消息是图片
  17. 		if(msg.types === '1') {
  18. 			this.msgImage.push(msg.message)
  19. 		}
  20. 		this.$nextTick(function(){
  21. 			this.scrollToView = 'msg' + this.msg[this.msg.length - 1].id;
  22. 		});
  23. 		......
  24. 	}	
  25. });

测试效果如下： 

 

服务器终端输出结果如下：

首页新消息提示

如下图，用户有新消息会在首页及时显示，并提示未读消息数量

 

需要给首页绑定获取消息的自定义事件backMsg，绑定时机是在生命周期onLoad中，事件一旦触发代表有好友向你发送消息了，会获取服务器传来的消息，在事件回调中要完成两个操作，首先查找发来新消息的好友在首页好友列表数组的索引下标，随后修改指定的数组元素内容，更新这个好友最后消息的时间、最后消息的内容、未读消息数；并将该元素现有位置删除，添加到整个数组的头部，即把这个好友item放到首页列表的最上方，首页index.vue相关代码如下：

  1. <view class="fl-wrapper">
  2. 	<view class="friend-list" v-for="(item,index) in friends" :key="index" @tap="toChatInterface(item)">
  3.         <!-- 用户头像 -->
  4. 		<view class="avator">
  5.             <!-- 未读消息数 -->
  6. 			<view class="new-message-number" v-show="item.unreadMsg">{{item.unreadMsg}}</view>
  7. 			<image :src="item.imgUrl" class="img" ></image>
  8. 		</view>
  9. 		<view class="wrapper-right">
  10. 			<view class="wrapper-right-left">
  11.                 <!-- 好友名 最后聊天时间 -->
  12. 				<view class="text">
  13. 					<view class="name">{{item.nickName}}</view>
  14. 					<view class="time">{{getTime(item.lastTime)}}</view>
  15. 				</view>
  16.                 <!-- 最后聊天消息 -->
  17. 				<view class="message" v-if="item.lastMsgType==='0'">{{item.lastMsgUsername ? item.lastMsgUsername : ''}}{{item.lastMsg}}</view>
  18. 				<view class="message" v-if="item.lastMsgType==='1'">{{item.lastMsgUsername ? item.lastMsgUsername : ''}}[图片]</view>
  19. 				<view class="message" v-if="item.lastMsgType==='2'">{{item.lastMsgUsername ? item.lastMsgUsername : ''}}[语音]</view>
  20. 				<view class="message" v-if="item.lastMsgType==='3'">{{item.lastMsgUsername ? item.lastMsgUsername : ''}}[位置]</view>
  21. 			</view>						
  22. 		</view>					
  23. 	</view>
  24. </view>
  25.  
  26. ......
  27.  
  28. onLoad() {
  29.     this.receiveSocket('backMsg');
  30. }
  31. methods:{
  32.     // 接收个人/群聊天信息
  33.     receiveSocket(eventName){
  34. 	    this.socket.on(eventName,(msg,fromId,type) => {
  35. 		    if(type === 0){
  36. 			    let index;
  37. 			    if(eventName == 'backMsg') {
  38.                     // 获取有新消息的好友在整个好友数组中的索引下标
  39. 				    index = this.friends.findIndex((item) => {
  40. 				    	return item.id === fromId
  41. 				    });
  42. 		    	}
  43. 		    	// 修改未读消息数 
  44. 		    	this.getUnreadMsg(this.friends[index]);
  45.                 // 修改最后聊天时间
  46. 		    	this.friends[index].lastTime = msg.time;
  47.                 // 修改最后聊天信息
  48. 		    	this.friends[index].lastMsg = msg.message;
  49.                 // 修改最后聊天信息的类型
  50. 		    	this.friends[index].lastMsgType = msg.types;
  51.                 
  52.                 // 删除当前item,将其插入到数组的首部，即展示在列表最上方
  53. 	    		const tempItem = this.friends[index];
  54. 	    		this.friends.splice(index,1);
  55. 	    		this.friends.unshift(tempItem);
  56. 	    	}
  57.     	});
  58.     },
  59. }
  60.

此外还有一个问题就是何时清空未读消息数，清空的操作需要进行两次，一次是用户进入聊天页面时进行清空，在聊天页生命周期onLoad中调用清空消息数的后端接口，清空现有的未读消息；另一次是在点击返回按钮如下图，返回首页时清空，在此按钮事件的回调中调用清空未读消息数的接口，这是为了清空用户和他人聊天时已读的消息，两次操作缺一不可。

实现群聊

群聊的前后端顺序图如下所示：

需要实现的是客户端A在群内发送了消息后，在同一群内的客户端BCD都能同时收到A发送的消息。群聊的大致思路和私聊基本相似，不同点在于群聊中引入了房间的概念，在房间内的成员就是这个群聊的群成员，任何群成员的群内发言就会在这个房间内进行广播，所有在线的群成员都能及时够收到。

加入房间

使用socket.join()加入房间，具体使用如下：

socket.join('room',function(){ ...... });

room：房间id,是一个字符串，用户自定义，加入房间会触发参数二回调

socket.leave(room,function(){ ...... })

与join相对应的是leave方法，即退出指定的房间，参数二异常回调函数为可选值。需要注意的是，当与客户端断开连接时，会自动将其从加入的房间中移除

在这个项目里房间id使用的是每一个群聊的群id号，它可以唯一标识一个群聊；

加入房间的操作同样是在用户登录成功进入首页时进行，一个用户可能加入了多个群聊，那么在主页请求用户群聊接口后，需要依次遍历接口返回的群聊列表，为每一个群聊触发addGroup事件，将当前的群id发送给后端，让当前用户加入每个群聊的房间。

index.vue

  1. // 获取当前用户的群消息
  2. getGroup(){
  3. 	uni.request({
  4. 		url:`${this.baseUrl}/index/getGroupList`,
  5. 		method:'POST',
  6. 		data:{
  7. 			uid:this.uid,  // 用户id
  8. 		},
  9. 		success: (res) => {
  10. 			let data = res.data.result;
  11.             // 遍历当前用户的群列表
  12. 			for (var i = 0; i < data.length; i++) {
  13. 				......
  14.                 // 触发addGroup事件，携带群id，加入房间
  15. 				this.socket.emit('addGroup',data[i].id);
  16. 			}            
  17.             ......
  18. 		}
  19. 	});
  20. },

 服务器绑定addGroup事件，调用socket.join，让当前用户连接加入房间号为groupId的房间

  1. io.on('connection',(socket) => { 
  2.     // 加入群
  3.     socket.on('addGroup',(groupId) => {
  4.         console.log('用户',socket.id,'加入了groupId为',groupId,'的群聊');
  5.         socket.join(groupId);
  6.     });
  7. }

效果：例如当前这个用户加入了三个群聊，首页加载后就会触发addGroup三次，依次加入这三个群id标识的房间。

服务器终端输出效果如下：

发送群消息

某一群成员在群内发送消息，会和私聊同样的方式将语音和图片这些静态资源上传服务器，返回服务器存放地址后进行封装，触发gmsg事件将处理后的消息提交服务器

  1. // 发送聊天数据
  2. sendSocket(msg){
  3. 	if(this.type === '0'){
  4. 		// 1对1聊天
  5. 		this.socket.emit('msg',msg,this.uid,this.fid);
  6. 	} else {
  7. 		// 群消息
  8. 		this.socket.emit('gmsg',msg,this.uid,this.fid);
  9. 	}
  10. },

群内广播消息使用到的api是socket.to，具体使用如下：

将内容发送给同在房间名roomName的所有客户端，除了发送者

socket.to(roomName).emit('事件名',参数1,参数2,......参数n);

如果需要包含发送者可以使用

io.in(roomName).emit('事件名',参数1,参数2,......参数n);

也可以同时发送给在多间房间的客户端，使用to链式调用的形式，不包含发送者

socket.to(roomName1).to(roomName2).emit('事件名',参数1,参数2,......参数n);

当然，当前项目中只需要使用第一种方式即可

服务器的gmsg事件回调中，同样需要将获取到的消息插入数据库，同时修改群最后通信时间以及全体成员的未读消息数，最后调用 socket.to方法，触发groupMsg事件，将消息发送给群聊内的其它在线用户。

  1. // 引入数据库文件
  2. let dataBase = require("./dataBase");
  3. // 接收群消息
  4. socket.on('gmsg',(msg,fromId,groupId) => {
  5.     console.log('服务器接收到来自群',groupId,'的用户',fromId,'的消息',msg);
  6.     // 修改群的最后通信时间
  7.     dataBase.updateGroupLastTime(groupId);
  8.     // 添加群消息
  9.     dataBase.insertGroupMsg(fromId,groupId,msg.message,msg.types);
  10.     //将所有成员的未读消息数加一
  11.     dataBase.changeGroupUnreadMsgNum(groupId);
  12.     console.log('消息',msg.message,'插入数据库成功')
  13.     // 获取当前用户的名字和头像
  14.     dataBase.userDetails(fromId).then((data) => {
  15.         console.log('查询发送者用户名成功，用户名是：',data[0]);
  16.         console.log('正在将信息',msg.message,'发送至群',groupId,'内');
  17.         // 群内广播消息
  18.         socket.to(groupId).emit('groupMsg',msg,fromId,0,data[0].name,groupId);
  19.     });
  20. });

客户端在线群成员收到消息，执行groupMsg事件回调中的方法，内部大致逻辑和私聊完全一致，可以将其封装成公共方法使用，需要注意的依旧是要做群id一致性判断，防止获取的消息显示在其它聊天窗口中，即 if(fromId !== this.uid && groupId === this.fid)。

  1. this.socket.on('groupMsg',(msg,fromId,type,friendName,groupId) => {
  2. 	// 判断当前打开的群id和接收消息的群id是否一致，防止消息错误显示
  3. 	if(fromId !== this.uid && groupId === this.fid){
  4. 		......
  5. 		// 模拟服务器数据
  6. 		let newMsg = {
  7. 			fromId:fromId,
  8. 			id:msg.id,
  9. 			imgUrl:msg.imgUrl,
  10. 			message:msg.message,
  11. 			types:msg.types,  // 0 - 文字信息，1 - 图片信息, 2 - 音频
  12. 			time:new Date(),
  13. 			isFirstPlay:true,
  14. 			friendName:friendName   // 群需显示发送消息用户的名字
  15. 		};
  16. 		this.msg.push(newMsg);
  17. 		// 如果消息是图片
  18. 		if(msg.types === '1') {
  19. 			this.msgImage.push(msg.message)
  20. 		}
  21. 		this.$nextTick(function(){
  22. 			this.scrollToView = 'msg' + this.msg[this.msg.length - 1].id;
  23. 		});
  24. 		......
  25. 	}	
  26. });

效果演示：输入一段文字发送到群内

服务器此时终端输出如下

以上就是项目聊天功能难点的全部内容，前端实现实时聊天主要就是对于socket.io提供api的合理使用，剩余的难点就是页面显示的部分逻辑处理，用户体验的优化，还可以在此基础上添加更多的功能，若有不足之处恳请指正！

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发