• Android端如何实现拉取RTSP/RTMP流并回调YUV/RGB数据然后注入轻量级RTSP服务？

    技术背景

    我们在对接开发Android平台音视频模块的时候，遇到过这样的问题，厂商希望拉取到海康、大华等摄像机的RTSP流，然后解码后的YUV或RGB数据回给他们，他们做视频分析或处理后，再投递给轻量级RTSP服务模块或RTMP推送模块，实现处理后的数据，二次转发，本文以拉取RTSP流，解析后再注入轻量级RTSP服务为例，介绍下大概的技术实现。

    技术实现

    废话不多说，无图无真相，下图是测试的时候，Android终端拉取RTSP流，然后把YUV数据回调上来，又通过推送接口，注入到轻量级RTSP服务，然后Windows平台拉取轻量级RTSP的URL，整体下来，毫秒级延迟：

    先说拉取RTSP流，需要注意的是，如果不要播放的话，可以SetSurface()的时候，第二个参数设置null，如果不需要audio的话，直接SetMute设置1即可，因为需要回调YUV上来，那么设置下I420回调，如果需要RGB的，只要开RGB的回调即可。

    1. private boolean StartPlay()
    2. 	{
    3. 		if (!OpenPullHandle())
    4. 			return false;
    5.  
    6. 		// 如果第二个参数设置为null，则播放纯音频
    7. 		libPlayer.SmartPlayerSetSurface(playerHandle, sSurfaceView);
    8.  
    9. 		libPlayer.SmartPlayerSetRenderScaleMode(playerHandle, 1);
    10.  
    11.     // libPlayer.SmartPlayerSetExternalRender(playerHandle, new
    12. 		// RGBAExternalRender());
    13. 		 libPlayer.SmartPlayerSetExternalRender(playerHandle, new
    14. 		 I420ExternalRender());
    15.  
    16. 		libPlayer.SmartPlayerSetFastStartup(playerHandle, isFastStartup ? 1 : 0);
    17.  
    18. 		libPlayer.SmartPlayerSetAudioOutputType(playerHandle, 1);
    19.  
    20. 		if (isMute) {
    21. 			libPlayer.SmartPlayerSetMute(playerHandle, isMute ? 1
    22. 					: 0);
    23. 		}
    24.  
    25. 		if (isHardwareDecoder)
    26. 		{
    27. 			int isSupportH264HwDecoder = libPlayer
    28. 					.SetSmartPlayerVideoHWDecoder(playerHandle, 1);
    29.  
    30. 			int isSupportHevcHwDecoder = libPlayer.SetSmartPlayerVideoHevcHWDecoder(playerHandle, 1);
    31.  
    32. 			Log.i(TAG, "isSupportH264HwDecoder: " + isSupportH264HwDecoder + ", isSupportHevcHwDecoder: " + isSupportHevcHwDecoder);
    33. 		}
    34.  
    35. 		libPlayer.SmartPlayerSetLowLatencyMode(playerHandle, isLowLatency ? 1
    36. 				: 0);
    37.  
    38. 		libPlayer.SmartPlayerSetRotation(playerHandle, rotate_degrees);
    39.  
    40. 		int iPlaybackRet = libPlayer
    41. 				.SmartPlayerStartPlay(playerHandle);
    42.  
    43. 		if (iPlaybackRet != 0) {
    44. 			Log.e(TAG, "StartPlay failed!");
    45.  
    46. 			if ( !isPulling && !isRecording && !isPushing && !isRTSPPublisherRunning)
    47. 			{
    48. 				releasePlayerHandle();
    49. 			}
    50.  
    51. 			return false;
    52. 		}
    53.  
    54. 		isPlaying = true;
    55. 		return true;
    56. 	}

    OpenPullHandle()对应的实现如下：

    1. /*
    2.    * SmartRelayDemo.java
    3.    * Created: daniusdk.com
    4.    */
    5.   private boolean OpenPullHandle()
    6. 	{
    7. 		//if (playerHandle != 0) {
    8. 		//	return true;
    9. 		//}
    10.  
    11. 		if(isPulling || isPlaying || isRecording)
    12. 			return true;
    13.  
    14. 		//playbackUrl = "rtsp://xxxx";
    15.     
    16. 		if (playbackUrl == null) {
    17. 			Log.e(TAG, "playback URL is null...");
    18. 			return false;
    19. 		}
    20.  
    21. 		playerHandle = libPlayer.SmartPlayerOpen(myContext);
    22.  
    23. 		if (playerHandle == 0) {
    24. 			Log.e(TAG, "playerHandle is nil..");
    25. 			return false;
    26. 		}
    27.  
    28. 		libPlayer.SetSmartPlayerEventCallbackV2(playerHandle,
    29. 				new EventHandlePlayerV2());
    30.  
    31. 		libPlayer.SmartPlayerSetBuffer(playerHandle, playBuffer);
    32.  
    33. 		// set report download speed
    34. 		libPlayer.SmartPlayerSetReportDownloadSpeed(playerHandle, 1, 5);
    35.  
    36. 		//设置RTSP超时时间
    37. 		int rtsp_timeout = 12;
    38. 		libPlayer.SmartPlayerSetRTSPTimeout(playerHandle, rtsp_timeout);
    39.  
    40. 		//设置RTSP TCP/UDP模式自动切换
    41. 		int is_auto_switch_tcp_udp = 1;
    42. 		libPlayer.SmartPlayerSetRTSPAutoSwitchTcpUdp(playerHandle, is_auto_switch_tcp_udp);
    43.  
    44. 		libPlayer.SmartPlayerSaveImageFlag(playerHandle, 1);
    45.  
    46. 		// It only used when playback RTSP stream..
    47. 		//libPlayer.SmartPlayerSetRTSPTcpMode(playerHandle, 1);
    48.  
    49. 		libPlayer.SmartPlayerSetUrl(playerHandle, playbackUrl);
    50.  
    51. 		return true;
    52. 	}

    拉流端的Event回调状态如下，拉流端主要关注的是链接状态，还有实时下载速度：

    1. class EventHandlePlayerV2 implements NTSmartEventCallbackV2 {
    2. 		@Override
    3. 		public void onNTSmartEventCallbackV2(long handle, int id, long param1,
    4. 											 long param2, String param3, String param4, Object param5) {
    5.  
    6. 			//Log.i(TAG, "EventHandleV2: handle=" + handle + " id:" + id);
    7.  
    8. 			String player_event = "";
    9.  
    10. 			switch (id) {
    11. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_STARTED:
    12. 					player_event = "开始..";
    13. 					break;
    14. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTING:
    15. 					player_event = "连接中..";
    16. 					break;
    17. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTION_FAILED:
    18. 					player_event = "连接失败..";
    19. 					break;
    20. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_CONNECTED:
    21. 					player_event = "连接成功..";
    22. 					break;
    23. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_DISCONNECTED:
    24. 					player_event = "连接断开..";
    25. 					break;
    26. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_STOP:
    27. 					player_event = "停止播放..";
    28. 					break;
    29. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_RESOLUTION_INFO:
    30. 					player_event = "分辨率信息: width: " + param1 + ", height: " + param2;
    31. 					break;
    32. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_NO_MEDIADATA_RECEIVED:
    33. 					player_event = "收不到媒体数据，可能是url错误..";
    34. 					break;
    35. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_SWITCH_URL:
    36. 					player_event = "切换播放URL..";
    37. 					break;
    38. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_CAPTURE_IMAGE:
    39. 					player_event = "快照: " + param1 + " 路径：" + param3;
    40.  
    41. 					if (param1 == 0) {
    42. 						player_event = player_event + ", 截取快照成功";
    43. 					} else {
    44. 						player_event = player_event + ", 截取快照失败";
    45. 					}
    46. 					break;
    47.  
    48. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_RECORDER_START_NEW_FILE:
    49. 					player_event = "[record]开始一个新的录像文件 : " + param3;
    50. 					break;
    51. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_ONE_RECORDER_FILE_FINISHED:
    52. 					player_event = "[record]已生成一个录像文件 : " + param3;
    53. 					break;
    54.  
    55. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_START_BUFFERING:
    56. 					Log.i(TAG, "Start Buffering");
    57. 					break;
    58.  
    59. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_BUFFERING:
    60. 					Log.i(TAG, "Buffering:" + param1 + "%");
    61. 					break;
    62.  
    63. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_STOP_BUFFERING:
    64. 					Log.i(TAG, "Stop Buffering");
    65. 					break;
    66.  
    67. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_DOWNLOAD_SPEED:
    68. 					player_event = "download_speed:" + param1 + "Byte/s" + ", "
    69. 							+ (param1 * 8 / 1000) + "kbps" + ", " + (param1 / 1024)
    70. 							+ "KB/s";
    71. 					break;
    72.  
    73. 				case NTSmartEventID.EVENT_DANIULIVE_ERC_PLAYER_RTSP_STATUS_CODE:
    74. 					Log.e(TAG, "RTSP error code received, please make sure username/password is correct, error code:" + param1);
    75. 					player_event = "RTSP error code:" + param1;
    76. 					break;
    77. 			}
    78. 		}
    79. 	}

    下一步，是启动RTSP服务：

    1. //启动/停止RTSP服务
    2. 	class ButtonRtspServiceListener implements OnClickListener {
    3. 		public void onClick(View v) {
    4. 			if (isRTSPServiceRunning) {
    5. 				stopRtspService();
    6.  
    7. 				btnRtspService.setText("启动RTSP服务");
    8. 				btnRtspPublisher.setEnabled(false);
    9.  
    10. 				isRTSPServiceRunning = false;
    11. 				return;
    12. 			}
    13.  
    14. 			if(!OpenPushHandle())
    15. 			{
    16. 				return;
    17. 			}
    18.  
    19. 			Log.i(TAG, "onClick start rtsp service..");
    20.  
    21. 			rtsp_handle_ = libPublisher.OpenRtspServer(0);
    22.  
    23. 			if (rtsp_handle_ == 0) {
    24. 				Log.e(TAG, "创建rtsp server实例失败! 请检查SDK有效性");
    25. 			} else {
    26. 				int port = 8554;
    27. 				if (libPublisher.SetRtspServerPort(rtsp_handle_, port) != 0) {
    28. 					libPublisher.CloseRtspServer(rtsp_handle_);
    29. 					rtsp_handle_ = 0;
    30. 					Log.e(TAG, "创建rtsp server端口失败! 请检查端口是否重复或者端口不在范围内!");
    31. 				}
    32.  
    33. 				//String user_name = "admin";
    34. 				//String password = "12345";
    35. 				//libPublisher.SetRtspServerUserNamePassword(rtsp_handle_, user_name, password);
    36.  
    37. 				if (libPublisher.StartRtspServer(rtsp_handle_, 0) == 0) {
    38. 					Log.i(TAG, "启动rtsp server 成功!");
    39. 				} else {
    40. 					libPublisher.CloseRtspServer(rtsp_handle_);
    41. 					rtsp_handle_ = 0;
    42. 					Log.e(TAG, "启动rtsp server失败! 请检查设置的端口是否被占用!");
    43. 				}
    44.  
    45. 				btnRtspService.setText("停止RTSP服务");
    46. 				btnRtspPublisher.setEnabled(true);
    47.  
    48. 				isRTSPServiceRunning = true;
    49. 			}
    50. 		}
    51. 	}

    如果需要停止服务，对应实现如下：

    1. //停止RTSP服务
    2. 	private void stopRtspService() {
    3. 		if(!isRTSPServiceRunning)
    4. 			return;
    5.  
    6. 		if (libPublisher != null && rtsp_handle_ != 0) {
    7. 			libPublisher.StopRtspServer(rtsp_handle_);
    8. 			libPublisher.CloseRtspServer(rtsp_handle_);
    9. 			rtsp_handle_ = 0;
    10. 		}
    11.  
    12. 		if(!isPushing)
    13. 		{
    14. 			releasePublisherHandle();
    15. 		}
    16.  
    17. 		isRTSPServiceRunning = false;
    18. 	}

    发布、停止发布RTSP流：

    1. private boolean StartRtspStream()
    2. 	{
    3. 		if (isRTSPPublisherRunning)
    4. 			return false;
    5.  
    6. 		String rtsp_stream_name = "stream1";
    7. 		libPublisher.SetRtspStreamName(publisherHandle, rtsp_stream_name);
    8. 		libPublisher.ClearRtspStreamServer(publisherHandle);
    9.  
    10. 		libPublisher.AddRtspStreamServer(publisherHandle, rtsp_handle_, 0);
    11.  
    12. 		if (libPublisher.StartRtspStream(publisherHandle, 0) != 0)
    13. 		{
    14. 			Log.e(TAG, "调用发布rtsp流接口失败!");
    15.  
    16. 			if (!isPushing)
    17. 			{
    18. 				libPublisher.SmartPublisherClose(publisherHandle);
    19. 				publisherHandle = 0;
    20. 			}
    21.  
    22. 			return false;
    23. 		}
    24.  
    25. 		isRTSPPublisherRunning = true;
    26. 		return true;
    27. 	}
    28.  
    29. 	//停止发布RTSP流
    30. 	private void stopRtspPublisher()
    31. 	{
    32. 		if(!isRTSPPublisherRunning)
    33. 			return;
    34.  
    35. 		isRTSPPublisherRunning = false;
    36.  
    37. 		if (null == libPublisher || 0 == publisherHandle)
    38. 			return;
    39.  
    40. 		libPublisher.StopRtspStream(publisherHandle);
    41.  
    42. 		if (!isPushing && !isRTSPServiceRunning)
    43. 		{
    44. 			releasePublisherHandle();
    45. 		}
    46. 	}

    因为处理后YUV或RGB数据需要重新编码，这时候需要推送端，设置下编码参数：

    1. private boolean OpenPushHandle() {
    2.  
    3. 		if(publisherHandle != 0)
    4. 		{
    5. 			return true;
    6. 		}
    7.  
    8. 		publisherHandle = libPublisher.SmartPublisherOpen(myContext, audio_opt, video_opt,
    9. 				videoWidth, videoHeight);
    10.  
    11. 		if (publisherHandle == 0) {
    12. 			Log.e(TAG, "sdk open failed!");
    13. 			return false;
    14. 		}
    15.  
    16. 		Log.i(TAG, "publisherHandle=" + publisherHandle);
    17.  
    18. 		int fps = 20;
    19. 		int gop = fps * 1;
    20.  
    21. 		int videoEncodeType = 1;	//1: h.264硬编码 2: H.265硬编码
    22.  
    23. 		if(videoEncodeType == 1)  {
    24. 			int h264HWKbps = setHardwareEncoderKbps(true, videoWidth, videoHeight);
    25. 			h264HWKbps = h264HWKbps*fps/25;
    26.  
    27. 			Log.i(TAG, "h264HWKbps: " + h264HWKbps);
    28.  
    29. 			int isSupportH264HWEncoder = libPublisher
    30. 					.SetSmartPublisherVideoHWEncoder(publisherHandle, h264HWKbps);
    31.  
    32. 			if (isSupportH264HWEncoder == 0) {
    33. 				libPublisher.SetNativeMediaNDK(publisherHandle, 0);
    34. 				libPublisher.SetVideoHWEncoderBitrateMode(publisherHandle, 1); // 0:CQ, 1:VBR, 2:CBR
    35. 				libPublisher.SetVideoHWEncoderQuality(publisherHandle, 39);
    36. 				libPublisher.SetAVCHWEncoderProfile(publisherHandle, 0x08); // 0x01: Baseline, 0x02: Main, 0x08: High
    37.  
    38. 				// libPublisher.SetAVCHWEncoderLevel(publisherHandle, 0x200); // Level 3.1
    39. 				// libPublisher.SetAVCHWEncoderLevel(publisherHandle, 0x400); // Level 3.2
    40. 				// libPublisher.SetAVCHWEncoderLevel(publisherHandle, 0x800); // Level 4
    41. 				libPublisher.SetAVCHWEncoderLevel(publisherHandle, 0x1000); // Level 4.1 多数情况下,这个够用了
    42. 				//libPublisher.SetAVCHWEncoderLevel(publisherHandle, 0x2000); // Level 4.2
    43.  
    44. 				// libPublisher.SetVideoHWEncoderMaxBitrate(publisherHandle, ((long)h264HWKbps)*1300);
    45.  
    46. 				Log.i(TAG, "Great, it supports h.264 hardware encoder!");
    47. 			}
    48. 		}
    49. 		else if (videoEncodeType == 2) {
    50. 			int hevcHWKbps = setHardwareEncoderKbps(false, videoWidth, videoHeight);
    51. 			hevcHWKbps = hevcHWKbps*fps/25;
    52.  
    53. 			Log.i(TAG, "hevcHWKbps: " + hevcHWKbps);
    54.  
    55. 			int isSupportHevcHWEncoder = libPublisher
    56. 					.SetSmartPublisherVideoHevcHWEncoder(publisherHandle, hevcHWKbps);
    57.  
    58. 			if (isSupportHevcHWEncoder == 0) {
    59. 				libPublisher.SetNativeMediaNDK(publisherHandle, 0);
    60. 				libPublisher.SetVideoHWEncoderBitrateMode(publisherHandle, 0); // 0:CQ, 1:VBR, 2:CBR
    61. 				libPublisher.SetVideoHWEncoderQuality(publisherHandle, 39);
    62.  
    63. 				// libPublisher.SetVideoHWEncoderMaxBitrate(publisherHandle, ((long)hevcHWKbps)*1200);
    64.  
    65. 				Log.i(TAG, "Great, it supports hevc hardware encoder!");
    66. 			}
    67. 		}
    68.  
    69. 		libPublisher.SetSmartPublisherEventCallbackV2(publisherHandle, new EventHandlePublisherV2());
    70.  
    71. 		libPublisher.SmartPublisherSetGopInterval(publisherHandle, gop);
    72.  
    73. 		libPublisher.SmartPublisherSetFPS(publisherHandle, fps);
    74.  
    75. 		return true;
    76. 	}

    I420ExternalRender实现如下，这里可以拿到拉流的RTSP的YUV数据，然后处理后，可以调用推送端的PostLayerImageI420ByteBuffer()投递到轻量级RTSP服务或RTMP推送端编码发送出去。

    1. class I420ExternalRender implements NTExternalRender {
    2. 		// public static final int NT_FRAME_FORMAT_RGBA = 1;
    3. 		// public static final int NT_FRAME_FORMAT_ABGR = 2;
    4. 		// public static final int NT_FRAME_FORMAT_I420 = 3;
    5.  
    6. 		private int width_ = 0;
    7. 		private int height_ = 0;
    8.  
    9. 		private int y_row_bytes_ = 0;
    10. 		private int u_row_bytes_ = 0;
    11. 		private int v_row_bytes_ = 0;
    12.  
    13. 		private ByteBuffer y_buffer_ = null;
    14. 		private ByteBuffer u_buffer_ = null;
    15. 		private ByteBuffer v_buffer_ = null;
    16.  
    17. 		@Override
    18. 		public int getNTFrameFormat() {
    19. 			Log.i(TAG, "I420ExternalRender::getNTFrameFormat return "
    20. 					+ NT_FRAME_FORMAT_I420);
    21. 			return NT_FRAME_FORMAT_I420;
    22. 		}
    23.  
    24. 		@Override
    25. 		public void onNTFrameSizeChanged(int width, int height) {
    26. 			width_ = width;
    27. 			height_ = height;
    28.  
    29. 			y_row_bytes_ = (width_ + 15) & (~15);
    30. 			u_row_bytes_ = ((width_ + 1) / 2 + 15) & (~15);
    31. 			v_row_bytes_ = ((width_ + 1) / 2 + 15) & (~15);
    32.  
    33. 			y_buffer_ = ByteBuffer.allocateDirect(y_row_bytes_ * height_);
    34. 			u_buffer_ = ByteBuffer.allocateDirect(u_row_bytes_
    35. 					* ((height_ + 1) / 2));
    36. 			v_buffer_ = ByteBuffer.allocateDirect(v_row_bytes_
    37. 					* ((height_ + 1) / 2));
    38.  
    39. 			Log.i(TAG, "I420ExternalRender::onNTFrameSizeChanged width_="
    40. 					+ width_ + " height_=" + height_ + " y_row_bytes_="
    41. 					+ y_row_bytes_ + " u_row_bytes_=" + u_row_bytes_
    42. 					+ " v_row_bytes_=" + v_row_bytes_);
    43. 		}
    44.  
    45. 		@Override
    46. 		public ByteBuffer getNTPlaneByteBuffer(int index) {
    47. 			if (index == 0) {
    48. 				return y_buffer_;
    49. 			} else if (index == 1) {
    50. 				return u_buffer_;
    51. 			} else if (index == 2) {
    52. 				return v_buffer_;
    53. 			} else {
    54. 				Log.e(TAG, "I420ExternalRender::getNTPlaneByteBuffer index error:" + index);
    55. 				return null;
    56. 			}
    57. 		}
    58.  
    59. 		@Override
    60. 		public int getNTPlanePerRowBytes(int index) {
    61. 			if (index == 0) {
    62. 				return y_row_bytes_;
    63. 			} else if (index == 1) {
    64. 				return u_row_bytes_;
    65. 			} else if (index == 2) {
    66. 				return v_row_bytes_;
    67. 			} else {
    68. 				Log.e(TAG, "I420ExternalRender::getNTPlanePerRowBytes index error:" + index);
    69. 				return 0;
    70. 			}
    71. 		}
    72.  
    73.     	public void onNTRenderFrame(int width, int height, long timestamp)
    74.     	{
    75.     		if ( y_buffer_ == null )
    76.     			return;
    77.     		
    78.     		if ( u_buffer_ == null )
    79.     			return;
    80.     		
    81.     		if ( v_buffer_ == null )
    82.     			return;
    83.     		      
    84.     		y_buffer_.rewind();
    85.     		u_buffer_.rewind();
    86.     		v_buffer_.rewind();
    87.     		
    88.     		 if( isPushing || isRTSPPublisherRunning )
    89.          {
    90.             libPublisher.PostLayerImageI420ByteBuffer(publisherHandle, 0, 0, 0,
    91.                 y_buffer_, 0, y_row_bytes_,
    92.                 u_buffer_, 0, u_row_bytes_,
    93.                 v_buffer_, 0, v_row_bytes_,
    94.                 width_, height_, 0, 0,
    95.                 960, 540, 0,0);
    96.          }
    97.     	}
    98.     }

    如果轻量级服务正常启动，会把rtsp的url回调上来：

    1. class EventHandlePublisherV2 implements NTSmartEventCallbackV2 {
    2.    @Override
    3.    public void onNTSmartEventCallbackV2(long handle, int id, long param1, long param2, String param3, String param4, Object param5) {
    4.  
    5.       Log.i(TAG, "EventHandlePublisherV2: handle=" + handle + " id:" + id);
    6.  
    7.       String publisher_event = "";
    8.  
    9.       switch (id) {
    10.          ....
    11.          case NTSmartEventID.EVENT_DANIULIVE_ERC_PUBLISHER_RTSP_URL:
    12.             publisher_event = "RTSP服务URL: " + param3;
    13.             break;
    14.       }
    15.    }
    16. }

    技术总结

    以上是大概的流程，从RTSP拉流到数据处理后，重新塞给轻量级RTSP服务，然后播放端再从轻量级RTSP服务端拉流，如果针对YUV或RGB算法处理延迟不大的话，整体延迟可轻松达到毫秒级，满足大多数场景的技术诉求。

  • 相关阅读:
    【LeetCode】每日一题 2023_11_14 阈值距离内邻居最少的城市（Floyd 最短路算法）
    JavaScript 中 toString 的奇妙使用
    2022学习进阶之路：高并发+性能优化+Spring boot等大型项目实战
    C++核心编程--类篇
    10款实用的市场分析工具，你知道几个？
    Spring 源码分析-简单示例带你了解BeanFactoryPostProcessor
    Spring面试题（一）
    【taro react】---- 微信小程序 通过 Jenkins 实现自动化部署
    vue-devTools Chrome安装配置
    C Primer Plus(6) 中文版 第13章 文件输入/输出 13.2 标准I/O
  • 原文地址：https://blog.csdn.net/renhui1112/article/details/133135936