• 使用javacv对摄像头视频转码并实现播放

    要实现Java接受RTSP流解码，并推送给前端实现播放实时流，可以使用一些流媒体处理库，比如JavaCV或者FFmpeg等。以下是一个简单的示例代码：

    1.控制层方面的

    根据视频rtsp流链接打开转换，通过响应写出流到前台使用flvjs播放视频

     一个播放器销毁时，将对应转换器线程暂停

    1. @RestController
    2. @RequestMapping("flv")
    3. public class FlvVideoController {
    4.  
    5. 	@Autowired
    6. 	private IFLVService iflvService;
    7.  
    8. 	/**
    9. 	 * 根据视频rtsp流链接打开转换，通过响应写出流到前台使用flvjs播放视频
    10. 	 * @param url 视频链接
    11. 	 * @param httpServletResponse 响应请求
    12. 	 * @author xufeng
    13. 	 */
    14. 	@RequestMapping(method = RequestMethod.GET, value = "/open/{param}")
    15. 	public void open(@PathVariable(value = "param") String url, HttpServletResponse httpServletResponse) {
    16. 		try {
    17. 			System.out.println("==url="+url);
    18. 			if(StringUtils.isBlank(url)) {
    19. 				url="";
    20. 			}
    21. 			BASE64Decoder base64Decoder = new BASE64Decoder();
    22. 			//获取当前登录用户主键
    23. 			String userId = "1";
    24. 			//String userId = UserContext.getCurrentUser().getId();
    25. 			//为保持url长度，需要先对前端传来的url进行base64解码，再调用flvService接口
    26. 			iflvService.open(new String(base64Decoder.decodeBuffer(url)), userId, httpServletResponse);
    27. 		} catch (Exception e) {
    28. 			e.printStackTrace();
    29. 		}
    30.  
    31. 	}
    32.  
    33. 	/**
    34. 	 * 一个播放器销毁时，将对应转换器线程暂停
    35. 	 * @author xufeng
    36. 	 * @param videoUrl 视频流链接
    37. 	 * @return EosDataTransferObject
    38. 	 */
    39. 	@ResponseBody
    40. 	@RequestMapping(method = RequestMethod.GET, value = "/closeTransThread")
    41. 	public JsonResult closeTransThread(/*@RequestParam(value = "videoUrl") String videoUrl*/) {
    42. 		try {
    43. 			String videoUrl="rtsp://admin:xxx:554/cam/realmonitor?channel=1&subtype=0";
    44. 			//视频流链接为空直接返回
    45. 			if (StringUtils.isBlank(videoUrl)) {
    46. 				return new JsonResult();
    47. 			}
    48. 			//获取当前登录用户主键
    49. 			String userId = "1";
    50. 			//String userId = UserContext.getCurrentUser().getId();
    51. 			//使用主键获取当前所有转换器
    52. 			ConcurrentHashMap conMaps = ConverterRegistration.getAllConverters(userId);
    53. 			//通过视频流链接取对应的转换器
    54. 			Converter converter = ConverterRegistration.isExist(videoUrl, conMaps);
    55. 			if (null != converter) {
    56. 				//暂停转换器线程，1分钟无新线程创建，该线程即被销毁
    57. 				converter.exit();
    58. 			}
    59. 		} catch (Exception e) {
    60. 			e.printStackTrace();
    61. 		}
    62. 		return new JsonResult();
    63. 	}
    64.  
    65. }

    2.视频流转换接口

    1. public interface IFLVService {
    2.  
    3. 	/**
    4. 	 * 打开一个流地址
    5. 	 *
    6. 	 * @param url rtsp流链接
    7. 	 * @param userId 用户主键
    8. 	 * @param response 响应请求
    9. 	 * @author xufeng
    10. 	 */
    11. 	void open(String url,String userId, Object response);
    12.  
    13. }
    FLV流转换
    1. @Service("flvService")
    2. public class FLVService implements IFLVService {
    3.  
    4. 	/**
    5. 	 * 打开一个流地址，写入response
    6. 	 * @param url 流地址
    7. 	 * @param userId 用户主键
    8. 	 * @param object HttpServletResponse
    9. 	 * @author xufeng
    10. 	 */
    11. 	@Override
    12. 	public void open(String url, String userId, Object object) {
    13. 		//创建转换器线程并启动
    14. 		Converter c = ConverterRegistration.open(url, userId);
    15. 		//UUID设置一个key值
    16. 		String key = UUID.randomUUID().toString();
    17. 		//创建输出字节流
    18. 		OutputStreamEntity outEntity = new OutputStreamEntity(new ByteArrayOutputStream(), System.currentTimeMillis(),
    19. 				key);
    20. 		//添加流输出
    21. 		System.out.println("==添加流输出=="+key);
    22. 		c.addOutputStreamEntity(key, outEntity);
    23. 		try {
    24. 			HttpServletResponse response = (HttpServletResponse) object;
    25. 			//设置响应头
    26. 			response.setContentType("video/x-flv");
    27. 			response.setHeader("Connection", "keep-alive");
    28. 			response.setStatus(HttpServletResponse.SC_OK);
    29. 			//写出缓冲信息，并清空
    30. 			response.flushBuffer();
    31. 			//循环读取outEntity里的流输出给前台
    32. 			System.out.println(c.getConverterState()+"==(response)循环读取outEntity里的流输出给前台==");
    33. 			readFlvStream(c, outEntity, response);
    34. 		} catch (Exception e) {
    35. 			//客户端长连接过程中被异常关闭，关闭该长连接对应的转换器线程
    36. 			c.exit();
    37. 			e.printStackTrace();
    38. 			//c.removeOutputStreamEntity(outEntity.getKey());
    39. 		}
    40. 	}
    41.  
    42. 	/**
    43. 	 * 递归读取转换好的视频流
    44. 	 *
    45. 	 * @param c 转换器
    46. 	 * @param outEntity 输出流
    47. 	 * @param response 响应
    48. 	 * @author xufeng
    49. 	 * @throws Exception
    50. 	 */
    51. 	public void readFlvStream(Converter c, OutputStreamEntity outEntity, HttpServletResponse response)
    52. 			throws Exception {
    53. 		//根据转换器状态来决定是继续等待、读取、结束流输出
    54. 		switch (c.getConverterState()) {
    55. 			case INITIAL:
    56. 				Thread.sleep(300);
    57. 				readFlvStream(c, outEntity, response);
    58. 				break;
    59. 			case OPEN:
    60. 				Thread.sleep(100);
    61. 				//System.out.println("=== OPEN递归读取转换好的视频流=="+c.getUrl());
    62. 				readFlvStream(c, outEntity, response);
    63. 				break;
    64. 			case RUN:
    65. 				if (outEntity.getOutput().size() > 0) {
    66.  
    67. 					byte[] b = outEntity.getOutput().toByteArray();
    68. 					outEntity.getOutput().reset();
    69. 					response.getOutputStream().write(b);
    70. 					outEntity.setUpdateTime(System.currentTimeMillis());
    71. 				}
    72. 				System.out.println("=== RUN递归读取转换好的视频流=="+c.getUrl());
    73. 				c.setUpdateTime(System.currentTimeMillis());
    74. 				Thread.sleep(100);
    75. 				readFlvStream(c, outEntity, response);
    76. 				break;
    77. 			case CLOSE:
    78. 				//log.info("close");
    79. 				break;
    80. 			default:
    81. 				break;
    82. 		}
    83. 	}
    84.  
    85. }

    3.转换

    1. public class ConverterRegistration {
    2.  
    3. 	/**
    4. 	 * 转换器集合（根据用户ID分类）
    5. 	 */
    6. 	private static ConcurrentHashMap> converters = new ConcurrentHashMap<>();
    7. 	/**
    8. 	 * 线程池
    9. 	 */
    10. 	private static ExecutorService executorService = Executors.newCachedThreadPool();
    11.  
    12. 	/**
    13. 	 * 开始一个转换
    14. 	 * 如果已存在这个流的转换就直接返回已存在的转换器
    15. 	 * @author xufeng
    16. 	 * @param url 视频流链接
    17. 	 * @param userId 用户主键
    18. 	 * @return converter
    19. 	 */
    20. 	public static Converter open(String url, String userId) {
    21. 		System.out.println("===开始一个转换==="+url);
    22. 		//判断当前用户是否存在转换器线程集合，没有则新建
    23. 		ConcurrentHashMap concurrentHashMap = converters.get(userId);
    24. 		if (concurrentHashMap == null) {
    25. 			concurrentHashMap = new ConcurrentHashMap<>(16);
    26. 			converters.put(userId, concurrentHashMap);
    27. 		}
    28. 		//判断是否已存在该转换器
    29. 		Converter c = isExist(url, concurrentHashMap);
    30. 		System.out.println("===判断是否已经存在转换器=="+c);
    31. 		try {
    32. 			if (null == c) {
    33. 				String key = UUID.randomUUID().toString();
    34. 				//创建线程
    35. 				c = new ConverterFactories(url, UUID.randomUUID().toString(), converters.get(userId));
    36. 				//记录到集合
    37. 				concurrentHashMap.put(key, c);
    38. 				//c.start();
    39. 				//用线程池启动
    40. 				executorService.execute((Runnable) c);
    41. 			}
    42. 		}catch (Exception e) {
    43. 			e.printStackTrace();
    44. 		}
    45. 		//如果该线程存在，但处于停止状态，则重新设置状态播放
    46. 		if (!c.isRuning()) {
    47. 			//设置运行状态
    48. 			c.setRuning(true);
    49. 			//设置初始化标志
    50. 			c.setState(ConverterState.INITIAL);
    51. 			//线程池启动
    52. 			executorService.execute((Runnable) c);
    53. 		}
    54. 		return c;
    55. 	}
    56.  
    57. 	/**
    58. 	 * 如果流已存在，就共用一个
    59. 	 * @author xufeng
    60. 	 * @param url 链接
    61. 	 * @param concurrentHashMap 转换器集合
    62. 	 * @return converter
    63. 	 */
    64. 	public static Converter isExist(String url, ConcurrentHashMap concurrentHashMap) {
    65. 		//遍历集合，根据url判断是否已存在该流视频
    66. 		for (Converter c : concurrentHashMap.values()) {
    67. 			if (url.equals(c.getUrl())) {
    68. 				return c;
    69. 			}
    70. 		}
    71. 		return null;
    72. 	}
    73.  
    74. 	/**
    75. 	 * 返回集合中的所有转换器
    76. 	 * @author xufeng
    77. 	 * @param userId 用户主键
    78. 	 * @return converters
    79. 	 */
    80. 	public static ConcurrentHashMap getAllConverters(String userId){
    81. 		return converters.get(userId);
    82. 	}
    83. }

    4.使用javacv

    1. public class ConverterFactories extends Thread implements Converter {
    2.  
    3. 	/**
    4. 	 * 运行状态
    5. 	 */
    6. 	public volatile boolean runing = true;
    7. 	/**
    8. 	 * 读流器
    9. 	 */
    10. 	private FFmpegFrameGrabber grabber;
    11. 	/**
    12. 	 * 转码器
    13. 	 */
    14. 	private FFmpegFrameRecorder recorder;
    15. 	/**
    16. 	 * 转FLV格式的头信息
    17. 	 * 如果有第二个客户端播放首先要返回头信息
    18. 	 */
    19. 	private byte[] headers;
    20. 	/**
    21. 	 * 保存转换好的流
    22. 	 */
    23. 	private ByteArrayOutputStream stream;
    24. 	/**
    25. 	 * 流地址，h264,aac
    26. 	 */
    27. 	private String url;
    28. 	/**
    29. 	 * 流输出
    30. 	 */
    31. 	private Map outEntitys;
    32.  
    33. 	/**
    34. 	 * 当前转换器状态
    35. 	 */
    36. 	private ConverterState state = ConverterState.INITIAL;
    37. 	/**
    38. 	 * key用于表示这个转换器
    39. 	 */
    40. 	private String key;
    41. 	/**
    42. 	 * 上次更新时间
    43. 	 * 客户端读取是刷新
    44. 	 * 如果没有客户端读取，会在一分钟后销毁这个转换器
    45. 	 */
    46. 	private long updateTime;
    47. 	/**
    48. 	 * 转换队列
    49. 	 */
    50. 	private Map factories;
    51.  
    52. 	public ConverterFactories(String url, String key, Map factories) {
    53. 		this.url = url;
    54. 		this.key = key;
    55. 		this.factories = factories;
    56. 		this.updateTime = System.currentTimeMillis();
    57. 	}
    58.  
    59. 	@Override
    60. 	public void run() {
    61. 		try {
    62. 			//使用ffmpeg抓取流，创建读流器
    63. 			grabber = new FFmpegFrameGrabber(url);
    64. 			//如果为rtsp流，增加配置
    65. 			if ("rtsp".equals(url.substring(0, 4))) {
    66. 				//设置打开协议tcp / udp
    67. 				grabber.setOption("rtsp_transport", "tcp");
    68. 				//设置未响应超时时间 0.5秒
    69. 				grabber.setOption("stimeout", "500000");
    70. 				//设置缓存大小，提高画质、减少卡顿花屏
    71. 				//grabber.setOption("buffer_size", "1024000");
    72. 				//设置视频比例
    73. 				//grabber.setAspectRatio(1.7777);
    74. 			} else {
    75. 				grabber.setOption("timeout", "500000");
    76. 			}
    77. 			grabber.start();
    78. 			stream = new ByteArrayOutputStream();
    79. 			outEntitys = new ConcurrentHashMap<>();
    80. 			//设置转换状态为打开
    81. 			state = ConverterState.OPEN;
    82. 			//创建转码器
    83. 			recorder = new FFmpegFrameRecorder(
    84. 					stream, grabber.getImageWidth(),
    85. 					grabber.getImageHeight(),
    86. 					grabber.getAudioChannels());
    87.  
    88. 			//配置转码器
    89. 			recorder.setFrameRate(grabber.getFrameRate());
    90. 			recorder.setSampleRate(grabber.getSampleRate());
    91. 			if (grabber.getAudioChannels() > 0) {
    92. 				recorder.setAudioChannels(grabber.getAudioChannels());
    93. 				recorder.setAudioBitrate(grabber.getAudioBitrate());
    94. 				recorder.setAudioCodec(grabber.getAudioCodec());
    95. 				//设置视频比例
    96. 				//recorder.setAspectRatio(grabber.getAspectRatio());
    97. 			}
    98. 			recorder.setFormat("flv");
    99. 			recorder.setVideoBitrate(grabber.getVideoBitrate());
    100. 			recorder.setVideoCodec(grabber.getVideoCodec());
    101. 			recorder.start(grabber.getFormatContext());
    102. 			//进入写入运行状态
    103. 			state = ConverterState.RUN;
    104.  
    105. 			if (headers == null) {
    106. 				headers = stream.toByteArray();
    107. 				stream.reset();
    108. 				for (OutputStreamEntity o : outEntitys.values()) {
    109.  
    110. 					o.getOutput().write(headers);
    111. 				}
    112. 			}
    113. 			int errorNum = 0;
    114. 			//线程运行时
    115. 			while (runing) {
    116. 				//FFmpeg读流压缩
    117. 				AVPacket k = grabber.grabPacket();
    118. 				if (k != null) {
    119. 					try {
    120. 						//转换器转换
    121. 						recorder.recordPacket(k);
    122. 					} catch (Exception e) {
    123. 					}
    124. 					byte[] b = stream.toByteArray();
    125. 					stream.reset();
    126. 					for (OutputStreamEntity o : outEntitys.values()) {
    127. 						if (o.getOutput().size() < (1024 * 1024)) {
    128. 							o.getOutput().write(b);
    129. 						}
    130. 					}
    131. 					errorNum = 0;
    132. 				} else {
    133. 					errorNum++;
    134. 					if (errorNum > 500) {
    135. 						break;
    136. 					}
    137. 				}
    138. 			}
    139. 		} catch (Exception e) {
    140. 			//log.error(e.getMessage(), e);
    141. 			state = ConverterState.ERROR;
    142. 		} finally {
    143. 			closeConverter();
    144. 			//log.info("exit");
    145. 			state = ConverterState.CLOSE;
    146. 			factories.remove(this.key);
    147. 		}
    148. 	}
    149.  
    150. 	/**
    151. 	 * 退出转换
    152. 	 */
    153. 	public void closeConverter() {
    154. 		try {
    155. 			//停止转码器
    156. 			if (null != recorder) {
    157. 				recorder.stop();
    158. 			}
    159. 			//停止、关闭读流器
    160. 			grabber.stop();
    161. 			grabber.close();
    162. 			//关闭转码器
    163. 			if (null != recorder) {
    164. 				recorder.close();
    165. 			}
    166. 			//关闭流
    167. 			if (null != stream) {
    168. 				stream.close();
    169. 			}
    170. 			if (null != outEntitys) {
    171. 				for (OutputStreamEntity o : outEntitys.values()) {
    172. 					o.getOutput().close();
    173. 				}
    174. 			}
    175. 		} catch (Exception e) {
    176. 			e.printStackTrace();
    177. 			//log.error(e.getMessage(), e);
    178. 		}
    179. 	}
    180.  
    181. 	@Override
    182. 	public String getKey() {
    183. 		return this.key;
    184. 	}
    185.  
    186. 	@Override
    187. 	public String getUrl() {
    188. 		return this.url;
    189. 	}
    190.  
    191. 	@Override
    192. 	public ConverterState getConverterState() {
    193. 		return this.state;
    194. 	}
    195.  
    196. 	@Override
    197. 	public void addOutputStreamEntity(String key, OutputStreamEntity entity) {
    198. 		try {
    199. 			switch (this.state) {
    200. 				case INITIAL:
    201. 					Thread.sleep(100);
    202. 					addOutputStreamEntity(key, entity);
    203. 					break;
    204. 				case OPEN:
    205. 					outEntitys.put(key, entity);
    206. 					break;
    207. 				case RUN:
    208. 					entity.getOutput().write(this.headers);
    209. 					outEntitys.put(key, entity);
    210. 					break;
    211. 				default:
    212. 					break;
    213. 			}
    214. 		} catch (Exception e) {
    215. 			//log.error(e.getMessage(), e);
    216. 		}
    217. 	}
    218.  
    219. 	@Override
    220. 	public void setUpdateTime(long updateTime) {
    221. 		this.updateTime = updateTime;
    222. 	}
    223.  
    224. 	@Override
    225. 	public long getUpdateTime() {
    226. 		return this.updateTime;
    227. 	}
    228.  
    229. 	@Override
    230. 	public void exit() {
    231. 		//设置线程状态为非运行状态，最后会进入finally块关闭读流器、转码器、流
    232. 		this.runing = false;
    233. 		try {
    234. 			this.join();
    235. 		} catch (Exception e) {
    236. 			e.printStackTrace();
    237. 			//log.error(e.getMessage(), e);
    238. 		}
    239. 	}
    240.  
    241. 	@Override
    242. 	public OutputStreamEntity getOutputStream(String key) {
    243. 		if (outEntitys.containsKey(key)) {
    244. 			return outEntitys.get(key);
    245. 		}
    246. 		return null;
    247. 	}
    248.  
    249. 	@Override
    250. 	public Map allOutEntity() {
    251. 		return this.outEntitys;
    252. 	}
    253.  
    254. 	@Override
    255. 	public void removeOutputStreamEntity(String key) {
    256. 		this.outEntitys.remove(key);
    257. 	}
    258.  
    259. 	@Override
    260. 	public boolean isRuning() {
    261. 		return runing;
    262. 	}
    263.  
    264. 	@Override
    265. 	public void setRuning(boolean runing) {
    266. 		this.runing = runing;
    267. 	}
    268.  
    269. 	@Override
    270. 	public void setState(ConverterState state) {
    271. 		this.state = state;
    272. 	}
    273. }

    rtsp流转换器接口

    1. public interface Converter {
    2.  
    3. 	/**
    4. 	 * 设置线程状态
    5. 	 * @param state 状态标志
    6. 	 */
    7. 	void setState(ConverterState state);
    8.  
    9. 	/**
    10. 	 * 获取该转换的key
    11. 	 */
    12. 	public String getKey();
    13.  
    14. 	/**
    15. 	 * 获取该转换的url
    16. 	 *
    17. 	 * @return
    18. 	 */
    19. 	public String getUrl();
    20.  
    21. 	/**
    22. 	 * 获取转换的状态
    23. 	 *
    24. 	 * @return
    25. 	 */
    26. 	public ConverterState getConverterState();
    27.  
    28. 	/**
    29. 	 * 添加一个流输出
    30. 	 *
    31. 	 * @param entity
    32. 	 */
    33. 	public void addOutputStreamEntity(String key, OutputStreamEntity entity);
    34.  
    35. 	/**
    36. 	 * 所有流输出
    37. 	 *
    38. 	 * @return
    39. 	 */
    40. 	public Map allOutEntity();
    41.  
    42. 	/**
    43. 	 * 移除一个流输出
    44. 	 *
    45. 	 * @param key
    46. 	 */
    47. 	public void removeOutputStreamEntity(String key);
    48.  
    49. 	/**
    50. 	 * 设置修改时间
    51. 	 *
    52. 	 * @param updateTime
    53. 	 */
    54. 	public void setUpdateTime(long updateTime);
    55.  
    56. 	/**
    57. 	 * 获取修改时间
    58. 	 *
    59. 	 * @return
    60. 	 */
    61. 	public long getUpdateTime();
    62.  
    63. 	/**
    64. 	 * 退出转换
    65. 	 */
    66. 	public void exit();
    67.  
    68. 	/**
    69. 	 * 启动
    70. 	 */
    71. 	public void start();
    72.  
    73. 	/**
    74. 	 * 获取输出的流
    75. 	 *
    76. 	 * @param key
    77. 	 * @return
    78. 	 */
    79. 	public OutputStreamEntity getOutputStream(String key);
    80.  
    81. 	/**
    82. 	 * 判断线程是否在运行
    83. 	 * @return boolean
    84. 	 */
    85. 	public boolean isRuning();
    86.  
    87. 	/**
    88. 	 * 设置运行状态
    89. 	 * @param runing 运行标志
    90. 	 */
    91. 	public void setRuning(boolean runing);
    92. }

    6.输出视频流

    1. public class OutputStreamEntity {
    2.  
    3. 	public OutputStreamEntity(ByteArrayOutputStream output, long updateTime, String key) {
    4. 		super();
    5. 		this.output = output;
    6. 		this.updateTime = updateTime;
    7. 		this.key = key;
    8. 	}
    9.  
    10. 	/**
    11. 	 * 字节数组输出流
    12. 	 */
    13. 	private ByteArrayOutputStream output;
    14. 	/**
    15. 	 * 更新时间
    16. 	 */
    17. 	private long updateTime;
    18. 	/**
    19. 	 * key标识
    20. 	 */
    21. 	private String key;
    22.  
    23. 	public ByteArrayOutputStream getOutput() {
    24. 		return output;
    25. 	}
    26.  
    27. 	public void setOutput(ByteArrayOutputStream output) {
    28. 		this.output = output;
    29. 	}
    30.  
    31. 	public long getUpdateTime() {
    32. 		return updateTime;
    33. 	}
    34.  
    35. 	public void setUpdateTime(long updateTime) {
    36. 		this.updateTime = updateTime;
    37. 	}
    38.  
    39. 	public String getKey() {
    40. 		return key;
    41. 	}
    42.  
    43. 	public void setKey(String key) {
    44. 		this.key = key;
    45. 	}
    46.  
    47.  
    48. }
    1. 转换器状态（初始化、打开、关闭、错误、运行）
    2. public enum ConverterState {
    3. 	INITIAL, OPEN, CLOSE, ERROR, RUN
    4. }
    1. public class JsonResult extends HashMap implements Serializable {
    2.  
    3. 	private static final long serialVersionUID = 1L;
    4. 	public static final int SUCCESS = 200;
    5.  
    6. 	public JsonResult() {
    7. 	}
    8.  
    9. 	/**
    10. 	 * 返回成功
    11. 	 */
    12. 	public static JsonResult ok() {
    13. 		return ok("操作成功");
    14. 	}
    15.  
    16. 	/**
    17. 	 * 返回成功
    18. 	 */
    19. 	public static JsonResult okFallBack() {
    20. 		return okFallBack("操作成功");
    21. 	}
    22.  
    23. 	/**
    24. 	 * 返回成功
    25. 	 */
    26. 	public JsonResult put(Object obj) {
    27. 		return this.put("data", obj);
    28. 	}
    29.  
    30. 	/**
    31. 	 * 返回成功
    32. 	 */
    33. 	public static JsonResult ok(String message) {
    34. 		return result(200, message);
    35. 	}
    36.  
    37. 	/**
    38. 	 * 降级函数 - 返回成功
    39. 	 */
    40. 	public static JsonResult okFallBack(String message) {
    41. 		return result(205, message);
    42. 	}
    43.  
    44. 	/**
    45. 	 * 返回成功
    46. 	 */
    47. 	public static JsonResult result(int code, String message) {
    48. 		JsonResult jsonResult = new JsonResult();
    49. 		jsonResult.put("timestamp", System.currentTimeMillis());
    50. 		jsonResult.put("status", code);
    51. 		jsonResult.put("message", message);
    52. 		return jsonResult;
    53. 	}
    54.  
    55. 	/**
    56. 	 * 返回失败
    57. 	 */
    58. 	public static JsonResult error() {
    59. 		return error("操作失败");
    60. 	}
    61.  
    62. 	/**
    63. 	 * 返回失败
    64. 	 */
    65. 	public static JsonResult error(String message) {
    66. 		return error(500, message);
    67. 	}
    68.  
    69. 	/**
    70. 	 * 返回失败
    71. 	 */
    72. 	public static JsonResult error(int code, String message) {
    73. 		JsonResult jsonResult = new JsonResult();
    74. 		jsonResult.put("timestamp", System.currentTimeMillis());
    75. 		jsonResult.put("status", code);
    76. 		jsonResult.put("message", message);
    77. 		return jsonResult;
    78. 	}
    79.  
    80. 	/**
    81. 	 * 设置code
    82. 	 */
    83. 	public JsonResult setCode(int code) {
    84. 		super.put("status", code);
    85. 		return this;
    86. 	}
    87.  
    88. 	/**
    89. 	 * 设置message
    90. 	 */
    91. 	public JsonResult setMessage(String message) {
    92. 		super.put("message", message);
    93. 		return this;
    94. 	}
    95.  
    96. 	/**
    97. 	 * 放入object
    98. 	 */
    99. 	@Override
    100. 	public JsonResult put(String key, Object object) {
    101. 		super.put(key, object);
    102. 		return this;
    103. 	}
    104.  
    105. 	/**
    106. 	 * 权限禁止
    107. 	 */
    108. 	public static JsonResult forbidden(String message) {
    109. 		JsonResult jsonResult = new JsonResult();
    110. 		jsonResult.put("timestamp", System.currentTimeMillis());
    111. 		jsonResult.put("status", 401);
    112. 		jsonResult.put("message", message);
    113. 		return jsonResult;
    114. 	}
    115.  
    116. 	/*@Override
    117. 	public String toString() {
    118. 		return JSONObject.toJSONString(this);
    119. 	}
    121. 	public JSONObject toJSONObject() {
    122. 		return JSONObject.parseObject(toString());
    123. 	}*/
    124.  
    125. }

    7.前端展现

    4. "UTF-8">
    5. Insert title here
    9. 	
      "video-video-div">
    10. 		
    11.
  • "text" id="url" value="rtsp://127.0.0.1/myvideo">

  • 相关阅读:
    Cadence Allegro 通过全局视窗局部放大板卡的方法
    容器化部署，不能识别中文件夹和中文文件
    【SQL】按特定字符分割一行转多行
    623. 在二叉树中增加一行（难度：中等）
    C++ 读MTK代码 综测校准 PSU读开关电源电压或电流 visa
    微服务框架 SpringCloud微服务架构 4 Ribbon 4.1 负载均衡原理
    csapp-Machine-Level Representation of Program-review
    mysql下载和安装，使用
    @Bean注解详解
    Nginx的反向代理、动静分离、负载均衡
  • 原文地址：https://blog.csdn.net/ruiguang21/article/details/139353132