devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot（三）websocket实现服务端，客户端的视频传输_javaspringboot websocket video

作者：笔触狂放9 | 2024-03-06 06:13:02

赞

踩

javaspringboot websocket video

1.服务端

1.1pom.xml引入库

  1.  <!--引入websocket依赖-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-websocket</artifactId>
  5.         </dependency>
  6.  
  7.         <dependency>
  8.             <groupId>org.java-websocket</groupId>
  9.             <artifactId>Java-WebSocket</artifactId>
  10.             <version>1.3.5</version>
  11.         </dependency>

1.2新建配置类， 开启WebSocket支持：

发现问题

经过了测试，发现几个问题，
一.连接断开，而且不报任何错
解决方式：是因为缓冲区过小，而传输的视频过大，websocket的默认缓冲区应该是8k，我们传输的视频有10几兆了，所以我们应该去改动缓冲区，查询资料，这里的缓冲区是独立的，有几个websocket连接就有几个缓冲区。

  1. package com.example.demo.config;
  2.  
  3. import org.springframework.boot.web.servlet.ServletContextInitializer;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.socket.server.standard.ServerEndpointExporter;
  7. import org.springframework.web.util.WebAppRootListener;
  8.  
  9. import javax.servlet.ServletContext;
  10. import javax.servlet.ServletException;
  11.  
  12. /**
  13.  * 开启WebSocket支持
  14.  **/
  15.  
  16. @Configuration
  17. public class WebSocketConfig implements ServletContextInitializer {
  18.     @Bean
  19.     public ServerEndpointExporter serverEndpointExporter() {
  20.         return new ServerEndpointExporter();
  21.     }
  22.     //设置websocket发送内容长度
  23.     @Override
  24.     public void onStartup(ServletContext servletContext) throws ServletException {
  25.         servletContext.addListener(WebAppRootListener.class);
  26.         //这里设置了30兆的缓冲区
  27.         //Tomcat每次请求过来时在创建session时都会把这个webSocketContainer作为参数传进去所以对所有的session都生效了
  28.         servletContext.setInitParameter("org.apache.tomcat.websocket.textBufferSize","30000000");
  29.         servletContext.setInitParameter("org.apache.tomcat.websocket.binaryBufferSize","30000000");
  30.     }
  31. }

1.3新建一个websocket处理类,这里我创建一个类为WebSocketServer

  1. package dzftxt.web.controller;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import dzftxt.data.dataobject.Videos;
  6. import dzftxt.data.form.VideoForm;
  7. import dzftxt.service.SaveFileI;
  8. import dzftxt.service.VideoService;
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11. import org.springframework.beans.BeanUtils;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.stereotype.Component;
  14.  
  15. import javax.websocket.OnClose;
  16. import javax.websocket.OnMessage;
  17. import javax.websocket.OnOpen;
  18. import javax.websocket.Session;
  19. import javax.websocket.server.PathParam;
  20. import javax.websocket.server.ServerEndpoint;
  21. import java.io.IOException;
  22. import java.util.HashMap;
  23. import java.util.Map;
  24. import java.util.concurrent.CopyOnWriteArraySet;
  25.  
  26.  
  27. /**
  28.  * @author ：Siyuan Gao
  29.  * @date ：Created in 2020/9/12 10:24
  30.  * @description：用于接受处理客户端向服务端传递的信息
  31.  * @modified By：
  32.  * @version: $
  33.  */
  34. @Component
  35. @ServerEndpoint("/upload/{sid}")
  36. public class WebSocketUploadServer {
  37.  
  38.     private static final Logger LOG =  LoggerFactory.getLogger(WebSocketUploadServer.class);
  39.     //用来记录当前在线连接数，
  40.     private static int onlineCount = 0;
  41.     //线程安全的set，用来存放每个客户端对应的websocket对象
  42.     private static CopyOnWriteArraySet<WebSocketUploadServer> webSocketSet = new CopyOnWriteArraySet<>();
  43.  
  44.     //与某个客户端的连接会话，需要通过它来给客户端发送数据
  45.     private Session session;
  46.  
  47.     private static SaveFileI saveFileI;
  48.     @Autowired
  49.     public void setSaveFileI(SaveFileI saveFileI){
  50.         WebSocketUploadServer.saveFileI=saveFileI;
  51.     }
  52.     //用hashmap存储文件对象和文件路径
  53.     private HashMap docUrl;
  54.     //结束标志
  55.     private String endupload = "over";
  56.  
  57.     private static VideoService videoService;
  58.     @Autowired
  59.     public void setVideoService(VideoService videoService){
  60.         WebSocketUploadServer.videoService=videoService;
  61.     }
  62.     //连接成功时，服务端会自动调用这个方法
  63.     @OnOpen
  64.     public void onOpen(Session session, @PathParam("sid") String sid){
  65.        //这一句是注入session，否则this无法发送消息
  66.         this.session=session;
  67.         webSocketSet.add(this);
  68.         addOnlineCount();
  69.         LOG.info(sid + "------连接成功---当前在线人数为"+onlineCount);
  70.     }
  71.     /**
  72.      * 连接关闭时调用的方法
  73.      */
  74.     @OnClose
  75.     public void onClose(@PathParam("sid") String sid) {
  76.         //在线人数减1
  77.         subOnlineCount();
  78.         //从set中删除
  79.         webSocketSet.remove(this);
  80.         LOG.info(sid + "已关闭连接" + "----剩余在线人数为：" + onlineCount);
  81.     }
  82.     /*
  83.     下面这个onmessage只负责处理客户端传来的字符串类型的文件，主要用于和前端的配合，
  84.     */
  85.     /*@OnMessage
  86.     public void onMessage(String message, @PathParam("sid") String sid) {
  87.         //把前端传来的json转为对象‘
  88.         JSONObject jsonObject = JSON.parseObject(message);
  89.         //消息类型 比如类型有文件名称filename，传的文件的第几份filecount，是否结束over
  90.         String type = jsonObject.getString("type");
  91.         //得到消息内容
  92.         String data = jsonObject.getString("data");
  93.         //一开始文件名传进来，服务端接受后生成有具体地址的文件对象，并向客户端传递ok进行下一步的传输
  94.         if ("fileName".equals(type)) {
  95.             LOG.info("传输的文件名为：" + data);
  96.             try {
  97.                 Map<String, Object> map = saveFileI.docPath(data);
  98.                 docUrl = (HashMap) map;
  99.                 this.sendMessage("ok");
  100.             } catch (IOException e) {
  101.                 e.printStackTrace();
  102.             }
  103.  
  104.  
  105.         }
  106.         //如果是发来的文件的第几份，那么打印出是第几份
  107.         else if("fileCount".equals(type)){
  108.             LOG.info("传输第"+data+"份");
  109.         }
  110.         //如果传递的是结束，则给客户端返回一个文件存储地址
  111.         else if (endupload.equals(type)){
  112.             LOG.info("===============>传输成功");
  113.             String path = (String) docUrl.get("nginxPath");
  114.             try {
  115.                 this.sendMessage(path);
  116.             } catch (IOException e) {
  117.                 e.printStackTrace();
  118.             }
  119.         }
  120.  
  121.  
  122.     }*/
  123.      /*
  124.     下面这个onmessage只负责处理客户端传来的byte[]的文件，主要用于和前端的配合，进行分段传输
  125.     */
  126.      /*@OnMessage
  127.     public void onMessage(byte[] message,Session session){
  128.         //
  129.         try{
  130.             //把传来的字节流数组写入到上面创建的文件对象里去
  131.              saveFileI.saveFileFromBytes(message,docUrl);
  132.            // saveFileI.saveFileFromBytes(message);
  133.             //只有客户端接受到ok才会传输下一段文件
  134.             this.sendMessage("服务端已成功接受视频");
  135.         }catch (IOException e){
  136.             e.printStackTrace();
  137.         }
  138.  
  139.  
  140.     }*/
  141.     /*
  142.     * 下面的onmessage用于接受经过json转换的map
  143.     * */
  144.     @OnMessage
  145.     public void onMessage(String message, @PathParam("sid") String sid)  {
  146.         //把前端传来的json转为对象‘
  147.         JSONObject jsonObject = JSON.parseObject(message);
  148.         //消息类型 比如类型有文件名称filename，传的文件的第几份filecount，是否结束over
  149.         String fileName= jsonObject.getString("fileName");
  150.         VideoForm videos=JSON.toJavaObject(jsonObject,VideoForm.class);
  151.         //得到消息内容
  152.  
  153.         if (videos.getContent()==null) System.out.println("传输的内容为空！");
  154.         Map<String, Object> map = saveFileI.docPath(fileName);
  155.         //
  156.        try {
  157.            saveFileI.saveFileFromBytes(videos.getContent(),map);
  158.            this.sendMessage("服务端已成功接受视频:"+videos.toString());
  159.            //保存视频信息到数据库
  160.            Videos videos1=new Videos();
  161.            BeanUtils.copyProperties(videos,videos1);
  162.            videos1.setPath((String) map.get("path"));
  163.            videoService.saveVideo(videos1);
  164.            this.sendMessage("服务端已成功保存该视频");
  165.            LOG.info(sid + "------视频传输成功---");
  166.        }catch (IOException e){
  167.            e.printStackTrace();
  168.        }
  169.  
  170.  
  171.     }
  172.     //这个方法用于接受处理客户端传来的字节流数组类型的文件
  173.     @OnMessage
  174.     public void onMessage(byte[] message,Session session){
  175.         //
  176.         try{
  177.             //把传来的字节流数组写入到上面创建的文件对象里去
  178.           // saveFileI.saveFileFromBytes(message,docUrl);
  179.            saveFileI.saveFileFromBytes(message);
  180.             //只有客户端接受到ok才会传输下一段文件
  181.             this.sendMessage("服务端已成功接受视频");
  182.         }catch (IOException e){
  183.             e.printStackTrace();
  184.         }
  185.  
  186.  
  187.     }
  188.  
  189.     //服务端向客户端发送消息
  190.     public void sendMessage(String message) throws IOException{
  191.         this.session.getBasicRemote().sendText(message);
  192.     }
  193.     /**
  194.      * 群发消息功能
  195.      *
  196.      * @param message 消息内容
  197.      * @param sid     房间号
  198.      */
  199.     public static void sendInfo(String message, @PathParam("sid") String sid) {
  200.         LOG.info("推送消息到所有客户端" + sid + "，推送内容:" + message);
  201.         for (WebSocketUploadServer item : webSocketSet) {
  202.             try {
  203.                 //这里可以设定只推送给这个sid的，为null则全部推送
  204.                 item.sendMessage(message);
  205.             } catch (IOException e) {
  206.                 LOG.error("消息发送失败" + e.getMessage(), e);
  207.                 return;
  208.             }
  209.         }
  210.     }
  211.     /**
  212.      * 原子性的++操作
  213.      */
  214.     public static synchronized void addOnlineCount() {
  215.         WebSocketUploadServer.onlineCount++;
  216.     }
  217.  
  218.     /**
  219.      * 原子性的--操作
  220.      */
  221.     public static synchronized void subOnlineCount() {
  222.         WebSocketUploadServer.onlineCount--;
  223.     }
  224. }
  225.

 savefilei.java

  1. package dzftxt.service;
  2.  
  3. import java.util.Map;
  4.  
  5. public interface SaveFileI {
  6.     /**
  7.      * 生成文件路径
  8.      * @param fileName  接收文件名
  9.      * @return  返回一个map，里面包换文件路径，文件，相对路径
  10.      */
  11.     Map<String,Object> docPath(String fileName);
  12.  
  13.     /**
  14.      * 将字节流写入文件
  15.      * @param b 字节流数组，是前端传来的。把这个字节流数组添加到map中的file中去（先通过file生成文件流对象outputstream）
  16.      * @param map  文件路径
  17.      * @return  返回是否成功
  18.      */
  19.     boolean saveFileFromBytes(byte[] b, Map<String, Object> map);
  20.     boolean saveFileFromBytes(byte[] b);
  21. }
  22.

saveFileImpl.java

  1. package dzftxt.service;
  2.  
  3. import org.springframework.stereotype.Service;
  4.  
  5. import javax.websocket.server.ServerEndpoint;
  6. import java.io.File;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  9. import java.text.SimpleDateFormat;
  10. import java.util.Date;
  11. import java.util.HashMap;
  12. import java.util.Map;
  13.  
  14. /**
  15.  * @author ：Siyuan Gao
  16.  * @date ：Created in 2020/9/12 10:17
  17.  * @description：
  18.  * @modified By：
  19.  * @version: $
  20.  */
  21. @Service
  22. public class SaveFileImpl implements SaveFileI{
  23.  
  24.     public Map<String, Object> docPath(String fileName) {
  25.         HashMap<String, Object> map = new HashMap<>();
  26.         //根据时间生成文件夹路径
  27.         Date date = new Date();
  28.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
  29.         String docUrl = simpleDateFormat.format(date);
  30.         //文件保存地址
  31.         String path = "/data/images/" + docUrl;
  32.         //创建文件
  33.         File dest = new File(path+"/" + fileName);
  34.         //如果文件已经存在就先删除掉
  35.         if (dest.getParentFile().exists()) {
  36.             dest.delete();
  37.         }
  38.         map.put("dest", dest);
  39.         map.put("path", path+"/" + fileName);
  40.         map.put("nginxPath","/"+docUrl+"/"+fileName);
  41.         return map;
  42.     }
  43.  
  44.  
  45.     public boolean saveFileFromBytes(byte[] b, Map<String, Object> map) {
  46.         //创建文件流对象
  47.         FileOutputStream fstream = null;
  48.         //从map中获取file对象
  49.         File file = (File) map.get("dest");
  50.         //判断路径是否存在，不存在就创建
  51.         if (!file.getParentFile().exists()) {
  52.             file.getParentFile().mkdirs();
  53.         }
  54.         try {
  55.             fstream = new FileOutputStream(file, true);
  56.             fstream.write(b);
  57.         } catch (Exception e) {
  58.             e.printStackTrace();
  59.             return false;
  60.         } finally {
  61.             if (fstream != null) {
  62.                 try {
  63.                     fstream.close();
  64.                 } catch (IOException e1) {
  65.                     e1.printStackTrace();
  66.                 }
  67.             }
  68.         }
  69.         return true;
  70.     }
  71.     public boolean saveFileFromBytes(byte[] b) {
  72.         //创建文件流对象
  73.         FileOutputStream fstream = null;
  74.         //从map中获取file对象
  75.         File file = new File("E:\\Users\\Administrator.DESKTOP-K38H7QV\\Desktop\\videos\\test.mp4");
  76.         //判断路径是否存在，不存在就创建
  77.         if (!file.getParentFile().exists()) {
  78.             file.getParentFile().mkdirs();
  79.         }
  80.         try {
  81.             fstream = new FileOutputStream(file, true);
  82.             fstream.write(b);
  83.         } catch (Exception e) {
  84.             e.printStackTrace();
  85.             return false;
  86.         } finally {
  87.             if (fstream != null) {
  88.                 try {
  89.                     fstream.close();
  90.                 } catch (IOException e1) {
  91.                     e1.printStackTrace();
  92.                 }
  93.             }
  94.         }
  95.         return true;
  96.     }
  97. }
  98.

2.客户端

WebSocketConfig.java

  1. package com.nju.config;
  2.  
  3. import org.java_websocket.drafts.Draft_6455;
  4. import org.java_websocket.handshake.ServerHandshake;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.stereotype.Component;
  7. import org.java_websocket.client.WebSocketClient;
  8.  
  9.  
  10. import java.net.URI;
  11.  
  12. /**
  13.  * @author ：Siyuan Gao
  14.  * @date ：Created in 2020/9/8 14:08
  15.  * @description：websocket的bean
  16.  * @modified By：
  17.  * @version: $
  18.  */
  19. @Component
  20. public class WebSocketConfig {
  21.     @Bean
  22.     public WebSocketClient webSocketClient(){
  23.  
  24.         try{
  25.             WebSocketClient webSocketClient=new WebSocketClient(new URI("ws://localhost:8090/dzftxt/upload/25477fes1"),new Draft_6455()) {
  26.  
  27.                 @Override
  28.                 public void onOpen(ServerHandshake serverHandshake) {
  29.                     System.out.println("客户端建立连接");
  30.                 }
  31.  
  32.                 @Override
  33.                 public void onMessage(String s) {
  34.  
  35.                     System.out.println("客户端收到消息----"+s);
  36.                 }
  37.  
  38.                 @Override
  39.                 public void onClose(int i, String s, boolean b) {
  40.                     System.out.println("客户端关闭连接");
  41.                 }
  42.  
  43.                 @Override
  44.                 public void onError(Exception e) {
  45.  
  46.                 }
  47.             };
  48.             webSocketClient.connect();
  49.             return webSocketClient;
  50.  
  51.         }catch (Exception e){
  52.             e.printStackTrace();
  53.         }
  54.  
  55.  
  56.         return null;
  57.     }
  58. }
  59.  
  1. package com.nju.service;
  2.  
  3. import org.java_websocket.client.WebSocketClient;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Component;
  6.  
  7. /**
  8.  * @author ：Siyuan Gao
  9.  * @date ：Created in 2020/9/8 11:19
  10.  * @description：用于websocket传输视频的接口
  11.  * @modified By：
  12.  * @version: $
  13.  */
  14. @Component
  15. public class WebSocketService {
  16.     @Autowired
  17.     private WebSocketClient webSocketClient;
  18.     public void sendMessageToServe(String s){
  19.         webSocketClient.send(s);
  20.     }
  21.     public void sendByteMessage(byte[] bytes){
  22.         webSocketClient.send(bytes);
  23.     }
  24.  
  25.  
  26. }
  27.  
  1. package com.nju.controller;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.nju.Utils.FileUtil;
  5. import com.nju.service.WebSocketService;
  6.  
  7. import com.alibaba.fastjson.JSONObject;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11.  
  12. import javax.websocket.server.ServerEndpoint;
  13. import java.io.*;
  14. import java.text.SimpleDateFormat;
  15. import java.util.*;
  16.  
  17. /**
  18.  * @author ：Siyuan Gao
  19.  * @date ：Created in 2020/9/9 10:39
  20.  * @description：测试文件上传
  21.  * @modified By：
  22.  * @version: $
  23.  */
  24. @Controller
  25. @ServerEndpoint("/clientWs")
  26. public class UploadFileController {
  27.  
  28.  
  29.     private static WebSocketService webSocketService;
  30.     @Autowired
  31.     public void setWebSocketService(WebSocketService webSocketService){
  32.         UploadFileController.webSocketService=webSocketService;
  33.     }
  34.     @RequestMapping("/upload")
  35.     public String uploadFile(){
  36.         return "fileUpload";
  37.     }
  38.     /*
  39.     * 下面这个wsupload用于直接传输byte类型
  40.     * */
  41.     @RequestMapping("/wsUpload")
  42.     public String wsUpload() throws FileNotFoundException {
  43. //        File file=new File("E:\\Users\\Administrator.DESKTOP-K38H7QV\\Desktop\\test.mp4");
  44.         File file=new File("D:\\BaiduYunDownload\\14test.mp4");
  45.         String name=file.getName();
  46.         byte[] bytes = FileUtil.fileToBinArray(file);
  47.         //如果直接传入会不会出问题呢测试一下
  48.         webSocketService.sendByteMessage(bytes);
  49.        /* int start_size=0;
  50.         int end_size=0;
  51.         //当服务端处理完了
  52.         while(end_size<bytes.length){
  53.             byte[] temp= Arrays.copyOfRange(bytes,start_size,end_size);
  54.             webSocketService.sendByteMessage(temp);
  55.  
  56.         }*/
  57.  
  58.  
  59.         System.out.println("客户端发送了视频");
  60.         return "success";
  61.     }
  62.     /*
  63.     * 下面这个wsupload用于测试传输含有byte类型的map转化为string
  64.     * */
  65.     @RequestMapping("/wsUpload1")
  66.     public String wsUpload1() throws FileNotFoundException {
  67. //        File file=new File("E:\\Users\\Administrator.DESKTOP-K38H7QV\\Desktop\\test.mp4");
  68.         File file=new File("D:\\BaiduYunDownload\\02vuetest.avi");
  69.         byte[] bytes = FileUtil.fileToBinArray(file);
  70.         HashMap<String,Object> map=new HashMap();
  71.         map.put("fileName",file.getName());
  72.         map.put("content",bytes);
  73.         map.put("ah","案号test");
  74.         map.put("dzftId","锁id");
  75.         map.put("fydm","法院代码test");
  76.         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  77.         map.put("createTime",(df.format(new Date())).toString());
  78.  
  79.         webSocketService.sendMessageToServe(JSON.toJSONString(map));
  80.        /* int start_size=0;
  81.         int end_size=0;
  82.         //当服务端处理完了
  83.         while(end_size<bytes.length){
  84.             byte[] temp= Arrays.copyOfRange(bytes,start_size,end_size);
  85.             webSocketService.sendByteMessage(temp);
  86.  
  87.         }*/
  88.  
  89.  
  90.         System.out.println("客户端发送了视频");
  91.         return "success";
  92.     }
  93.  
  94.  
  95. }
  96.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/196406
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号