• TCP通信实战案例-即时通信

    即时通信是什么含义，要实现怎么样的设计？

    即时通信，是指一个客户端的消息发出去，其他客户端可以接收到。

    即时通信需要进行端口转发的设计思想。

    服务端需要把在线的Socket管道存储起来。

    一旦收到一个消息要推送给其他管道。

    即时通信-端口转发

     代码实现

    1. /**
    2.     拓展：即时通信
    4.     客户端：发消息的同时，随时有人发消息过来。
    5.     服务端：接收消息后，推送给其他所有的在线socket
    6.  */
    7. public class ClientDemo1 {
    8.     public static void main(String[] args) {
    9.         try {
    10.             System.out.println("====客户端启动===");
    11.             // 1、创建Socket通信管道请求有服务端的连接
    12.             // public Socket(String host, int port)
    13.             // 参数一：服务端的IP地址
    14.             // 参数二：服务端的端口
    15.             Socket socket = new Socket("127.0.0.1", 6868);
    16.  
    17.             // 马上为客户端分配一个独立的线程负责读取它收到的消息
    18.             new ClientReaderThread(socket).start();
    19.  
    20.             // 2、从socket通信管道中得到一个字节输出流 负责发送数据
    21.             OutputStream os = socket.getOutputStream();
    22.  
    23.             // 3、把低级的字节流包装成打印流
    24.             PrintStream ps = new PrintStream(os);
    25.  
    26.             Scanner sc =  new Scanner(System.in);
    27.             while (true) {
    28.                 System.out.println("请说：");
    29.                 String msg = sc.nextLine();
    30.                 // 4、发送消息
    31.                 ps.println(msg);
    32.                 ps.flush();
    33.             }
    34.             // 关闭资源。
    35.             // socket.close();
    36.  
    37.         } catch (Exception e) {
    38.             e.printStackTrace();
    39.         }
    40.     }
    41. }
    1. public class ClientReaderThread extends Thread{
    2.     private Socket socket;
    3.     public ClientReaderThread(Socket socket){
    4.         this.socket = socket;
    5.     }
    6.     @Override
    7.     public void run() {
    8.         try {
    9.             // 3、从socket通信管道中得到一个字节输入流
    10.             InputStream is = socket.getInputStream();
    11.             // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
    12.             BufferedReader br = new BufferedReader(new InputStreamReader(is));
    13.             // 5、按照行读取消息
    14.             String msg;
    15.             while ((msg = br.readLine()) != null){
    16.                 System.out.println(socket.getRemoteSocketAddress() + "收到了: " + msg);
    17.             }
    18.         } catch (Exception e) {
    19.             System.out.println("服务端把你踢出去了~~");
    20.         }
    21.     }
    22. }
    1. /**
    2.    目标: 即时通信
    3.  */
    4. public class ServerDemo2 {
    5.  
    6.     public static List onLineSockets = new ArrayList<>();
    7.  
    8.     public static void main(String[] args) {
    9.         try {
    10.             System.out.println("===服务端启动成功===");
    11.             // 1、注册端口
    12.             ServerSocket serverSocket = new ServerSocket(6868);
    13.             // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
    14.             while (true) {
    15.                 // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
    16.                 Socket socket = serverSocket.accept();
    17.                 System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
    18.                 // 把当前客户端管道Socket加入到在线集合中去
    19.                 onLineSockets.add(socket);
    20.  
    21.                 // 3、开始创建独立线程处理socket
    22.                 new ServerReaderThread(socket).start();
    23.             }
    24.         } catch (Exception e) {
    25.             e.printStackTrace();
    26.         }
    27.     }
    28. }
    1. public class ServerReaderThread extends Thread{
    2.     private Socket socket;
    3.     public ServerReaderThread(Socket socket){
    4.         this.socket = socket;
    5.     }
    6.     @Override
    7.     public void run() {
    8.         try {
    9.             // 3、从socket通信管道中得到一个字节输入流
    10.             InputStream is = socket.getInputStream();
    11.             // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
    12.             BufferedReader br = new BufferedReader(new InputStreamReader(is));
    13.             // 5、按照行读取消息
    14.             String msg;
    15.             while ((msg = br.readLine()) != null){
    16.                 System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
    17.                 // 把这个消息发给当前所有在线socket
    18.                 sendMsgToAll(msg);
    19.             }
    20.         } catch (Exception e) {
    21.             System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
    22.             // 从在线集合中抹掉本客户端socket
    23.             ServerDemo2.onLineSockets.remove(socket);
    24.         }
    25.     }
    26.  
    27.     private void sendMsgToAll(String msg) {
    28.         try {
    29.             // 遍历全部的在线 socket给他们发消息
    30.             for (Socket onLineSocket : ServerDemo2.onLineSockets) {
    31.                 // 除了自己的socket，其他socket我都发！！
    32.                 if(onLineSocket != socket){
    33.                     PrintStream ps = new PrintStream(onLineSocket.getOutputStream());
    34.                     ps.println(msg);
    35.                     ps.flush();
    36.                 }
    37.             }
    38.         } catch (Exception e) {
    39.             e.printStackTrace();
    40.         }
    41.     }
    42. }

    简易聊天系统代码

    1. package com.itheima.d9_chat.即时通信;
    2.  
    3.  
    4. import javax.swing.*;
    5. import java.awt.*;
    6. import java.awt.event.ActionEvent;
    7. import java.awt.event.ActionListener;
    8. import java.io.DataInputStream;
    9. import java.io.DataOutputStream;
    10. import java.net.Socket;
    11.  
    12. /**
    13.  * @Author xlei(徐磊)
    14.  * 客户端界面
    15.  */
    16. public class ClientChat implements ActionListener {
    17. 	/** 1.设计界面  */
    18. 	private JFrame win = new JFrame();
    19. 	/** 2.消息内容框架 */
    20. 	public JTextArea smsContent =new JTextArea(23 , 50);
    21. 	/** 3.发送消息的框  */
    22. 	private JTextArea smsSend = new JTextArea(4,40);
    23. 	/** 4.在线人数的区域  */
    24. 	/** 存放人的数据 */
    25. 	/** 展示在线人数的窗口 */
    26. 	public JList onLineUsers = new JList<>();
    27.  
    28. 	// 是否私聊按钮
    29. 	private JCheckBox isPrivateBn = new JCheckBox("私聊");
    30. 	// 消息按钮
    31. 	private JButton sendBn  = new JButton("发送");
    32.  
    33. 	// 登录界面
    34. 	private JFrame loginView;
    35.  
    36. 	private JTextField ipEt , nameEt , idEt;
    37.  
    38. 	private Socket socket ;
    39.  
    40. 	public static void main(String[] args) {
    41. 		new ClientChat().initView();
    42.  
    43. 	}
    44.  
    45. 	private void initView() {
    46. 		/** 初始化聊天窗口的界面 */
    47. 		win.setSize(650, 600);
    48.  
    49. 		/** 展示登录界面  */
    50. 		displayLoginView();
    51.  
    52. 		/** 展示聊天界面 */
    53. 		//displayChatView();
    54.  
    55.  
    56. 	}
    57.  
    58. 	private void displayChatView() {
    59.  
    60. 		JPanel bottomPanel = new JPanel(new BorderLayout());
    61. 		//-----------------------------------------------
    62. 		// 将消息框和按钮 添加到窗口的底端
    63. 		win.add(bottomPanel, BorderLayout.SOUTH);
    64. 		bottomPanel.add(smsSend);
    65. 		JPanel btns = new JPanel(new FlowLayout(FlowLayout.LEFT));
    66. 		btns.add(sendBn);
    67. 		btns.add(isPrivateBn);
    68. 		bottomPanel.add(btns, BorderLayout.EAST);
    69. 		//-----------------------------------------------
    70. 		// 给发送消息按钮绑定点击事件监听器
    71. 		// 将展示消息区centerPanel添加到窗口的中间
    72. 		smsContent.setBackground(new Color(0xdd,0xdd,0xdd));
    73. 		// 让展示消息区可以滚动。
    74. 		win.add(new JScrollPane(smsContent), BorderLayout.CENTER);
    75. 		smsContent.setEditable(false);
    76. 		//-----------------------------------------------
    77. 		// 用户列表和是否私聊放到窗口的最右边
    78. 		Box rightBox = new Box(BoxLayout.Y_AXIS);
    79. 		onLineUsers.setFixedCellWidth(120);
    80. 		onLineUsers.setVisibleRowCount(13);
    81. 		rightBox.add(new JScrollPane(onLineUsers));
    82. 		win.add(rightBox, BorderLayout.EAST);
    83. 		//-----------------------------------------------
    84. 		// 关闭窗口退出当前程序
    85. 		win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    86. 		win.pack();  // swing 加上这句 就可以拥有关闭窗口的功能
    87. 		/** 设置窗口居中,显示出来  */
    88. 		setWindowCenter(win,650,600,true);
    89. 		// 发送按钮绑定点击事件
    90. 		sendBn.addActionListener(this);
    91. 	}
    92.  
    93. 	private void displayLoginView(){
    94.  
    95. 		/** 先让用户进行登录
    96. 		 *  服务端ip
    97. 		 *  用户名
    98. 		 *  id
    99. 		 *  */
    100. 		/** 显示一个qq的登录框     */
    101. 		loginView = new JFrame("登录");
    102. 		loginView.setLayout(new GridLayout(3, 1));
    103. 		loginView.setSize(400, 230);
    104.  
    105. 		JPanel ip = new JPanel();
    106. 		JLabel label = new JLabel("   IP:");
    107. 		ip.add(label);
    108. 		ipEt = new JTextField(20);
    109. 		ip.add(ipEt);
    110. 		loginView.add(ip);
    111.  
    112. 		JPanel name = new JPanel();
    113. 		JLabel label1 = new JLabel("姓名:");
    114. 		name.add(label1);
    115. 		nameEt = new JTextField(20);
    116. 		name.add(nameEt);
    117. 		loginView.add(name);
    118.  
    119. 		JPanel btnView = new JPanel();
    120. 		JButton login = new JButton("登陆");
    121. 		btnView.add(login);
    122. 		JButton cancle = new JButton("取消");
    123. 		btnView.add(cancle);
    124. 		loginView.add(btnView);
    125. 		// 关闭窗口退出当前程序
    126. 		loginView.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    127. 		setWindowCenter(loginView,400,260,true);
    128.  
    129. 		/** 给登录和取消绑定点击事件 */
    130. 		login.addActionListener(this);
    131. 		cancle.addActionListener(this);
    132.  
    133. 	}
    134.  
    135. 	private static void setWindowCenter(JFrame frame, int width , int height, boolean flag) {
    136. 		/** 得到所在系统所在屏幕的宽高 */
    137. 		Dimension ds = frame.getToolkit().getScreenSize();
    138.  
    139. 		/** 拿到电脑的宽 */
    140. 		int width1 = ds.width;
    141. 		/** 高 */
    142. 		int height1 = ds.height ;
    143.  
    144. 		System.out.println(width1 +"*" + height1);
    145. 		/** 设置窗口的左上角坐标 */
    146. 		frame.setLocation(width1/2 - width/2, height1/2 -height/2);
    147. 		frame.setVisible(flag);
    148. 	}
    149.  
    150. 	@Override
    151. 	public void actionPerformed(ActionEvent e) {
    152. 		/** 得到点击的事件源 */
    153. 		JButton btn = (JButton) e.getSource();
    154. 		switch(btn.getText()){
    155. 			case "登陆":
    156. 				String ip = ipEt.getText().toString();
    157. 				String name = nameEt.getText().toString();
    158. 				// 校验参数是否为空
    159. 				// 错误提示
    160. 				String msg = "" ;
    161. 				// 12.1.2.0
    162. 				// \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\
    163. 				if(ip==null || !ip.matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}")){
    164. 					msg = "请输入合法的服务端ip地址";
    165. 				}else if(name==null || !name.matches("\\S{1,}")){
    166. 					msg = "姓名必须1个字符以上";
    167. 				}
    168.  
    169. 				if(!msg.equals("")){
    170. 					/** msg有内容说明参数有为空 */
    171. 					// 参数一：弹出放到哪个窗口里面
    172. 					JOptionPane.showMessageDialog(loginView, msg);
    173. 				}else{
    174. 					try {
    175. 						// 参数都合法了
    176. 						// 当前登录的用户,去服务端登陆
    177. 						/** 先把当前用户的名称展示到界面 */
    178. 						win.setTitle(name);
    179. 						// 去服务端登陆连接一个socket管道
    180. 						socket = new Socket(ip, Constants.PORT);
    181.  
    182. 						//为客户端的socket分配一个线程 专门负责收消息
    183. 						new ClientReader(this,socket).start();
    184.  
    185. 						// 带上用户信息过去
    186. 						DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
    187. 						dos.writeInt(1); // 登录消息
    188. 						dos.writeUTF(name.trim());
    189. 						dos.flush();
    190.  
    191. 						// 关系当前窗口 弹出聊天界面
    192. 						loginView.dispose(); // 登录窗口销毁
    193. 						displayChatView(); // 展示了聊天窗口了
    194.  
    195.  
    196. 					} catch (Exception e1) {
    197. 						e1.printStackTrace();
    198. 					}
    199. 				}
    200. 				break;
    201. 			case "取消":
    202. 				/** 退出系统 */
    203. 				System.exit(0);
    204. 				break;
    205. 			case "发送":
    206. 				// 得到发送消息的内容
    207. 				String msgSend = smsSend.getText().toString();
    208. 				if(!msgSend.trim().equals("")){
    209. 					/** 发消息给服务端 */
    210. 					try {
    211. 						// 判断是否对谁发消息
    212. 						String selectName = onLineUsers.getSelectedValue();
    213. 						int flag = 2 ;// 群发 @消息
    214. 						if(selectName!=null&&!selectName.equals("")){
    215. 							msgSend =("@"+selectName+","+msgSend);
    216. 							/** 判断是否选中了私法 */
    217. 							if(isPrivateBn.isSelected()){
    218. 								/** 私法 */
    219. 								flag = 3 ;//私发消息
    220. 							}
    221.  
    222. 						}
    223.  
    224. 						DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
    225. 						dos.writeInt(flag); // 群发消息  发送给所有人
    226. 						dos.writeUTF(msgSend);
    227. 						if(flag == 3){
    228. 							// 告诉服务端我对谁私发
    229. 							dos.writeUTF(selectName.trim());
    230. 						}
    231. 						dos.flush();
    232.  
    233. 					} catch (Exception e1) {
    234. 						e1.printStackTrace();
    235. 					}
    236.  
    237. 				}
    238. 				smsSend.setText(null);
    239. 				break;
    240.  
    241. 		}
    242.  
    243. 	}
    244. }
    245.  
    246. class ClientReader extends Thread {
    247.  
    248. 	private Socket socket;
    249. 	private ClientChat clientChat ;
    250.  
    251. 	public ClientReader(ClientChat clientChat, Socket socket) {
    252. 		this.clientChat = clientChat;
    253. 		this.socket = socket;
    254. 	}
    255.  
    256. 	@Override
    257. 	public void run() {
    258. 		try {
    259. 			DataInputStream dis = new DataInputStream(socket.getInputStream());
    260. 			/** 循环一直等待客户端的消息 */
    261. 			while(true){
    262. 				/** 读取当前的消息类型 ：登录,群发,私聊 , @消息 */
    263. 				int flag = dis.readInt();
    264. 				if(flag == 1){
    265. 					// 在线人数消息回来了
    266. 					String nameDatas = dis.readUTF();
    267. 					// 展示到在线人数的界面
    268. 					String[] names = nameDatas.split(Constants.SPILIT);
    269.  
    270. 					clientChat.onLineUsers.setListData(names);
    271. 				}else if(flag == 2){
    272. 					// 群发消息
    273. 					String msg = dis.readUTF() ;
    274. 					clientChat.smsContent.append(msg);
    275. 					//滾動到底端
    276. 					clientChat.smsContent.setCaretPosition(clientChat.smsContent.getText().length());
    277. 				}
    278. 			}
    279. 		} catch (Exception e) {
    280. 			e.printStackTrace();
    281. 		}
    282.  
    283. 	}
    284. }
    1. package com.itheima.d9_chat.即时通信;
    2.  
    3. public class Constants {
    4. 	/** 常量 */
    5. 	public static final int PORT = 7778 ;
    6. 	
    7. 	/** 协议分隔符 */
    8. 	public static final String SPILIT = "003197♣♣㏘♣④④♣";
    9. }
    1. package com.itheima.d9_chat.即时通信;
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.DataOutputStream;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7. import java.text.SimpleDateFormat;
    8. import java.util.Collection;
    9. import java.util.HashMap;
    10. import java.util.Map;
    11. import java.util.Set;
    12.  
    13. /**
    14.  * @Author
    15.  * @Email dlei0009@163.com
    16.  */
    17. public class ServerChat {
    18.  
    19. 	/** 定义一个集合存放所有在线的socket  */
    20. 	public static Map onLineSockets = new HashMap<>();
    21.  
    22. 	public static void main(String[] args) {
    23. 		try {
    24. 			/** 注册端口   */
    25. 			ServerSocket serverSocket = new ServerSocket(Constants.PORT);
    26.  
    27. 			/** 循环一直等待所有可能的客户端连接 */
    28. 			while(true){
    29. 				Socket socket = serverSocket.accept();
    30. 				/** 把客户端的socket管道单独配置一个线程来处理 */
    31. 				new ServerReader(socket).start();
    32. 			}
    33. 		} catch (Exception e) {
    34. 			e.printStackTrace();
    35. 		}
    36. 	}
    37. }
    38.  
    39. class ServerReader extends Thread {
    40.  
    41. 	private Socket socket;
    42.  
    43. 	public ServerReader(Socket socket) {
    44. 		this.socket = socket;
    45. 	}
    46.  
    47. 	@Override
    48. 	public void run() {
    49. 		DataInputStream dis = null;
    50. 		try {
    51. 			dis = new DataInputStream(socket.getInputStream());
    52. 			/** 循环一直等待客户端的消息 */
    53. 			while(true){
    54. 				/** 读取当前的消息类型 ：登录,群发,私聊 , @消息 */
    55. 				int flag = dis.readInt();
    56. 				if(flag == 1){
    57. 					/** 先将当前登录的客户端socket存到在线人数的socket集合中   */
    58. 					String name = dis.readUTF() ;
    59. 					System.out.println(name+"---->"+socket.getRemoteSocketAddress());
    60. 					ServerChat.onLineSockets.put(socket, name);
    61. 				}
    62. 				writeMsg(flag,dis);
    63. 			}
    64. 		} catch (Exception e) {
    65. 			System.out.println("--有人下线了--");
    66. 			// 从在线人数中将当前socket移出去  
    67. 			ServerChat.onLineSockets.remove(socket);
    68. 			try {
    69. 				// 从新更新在线人数并发给所有客户端 
    70. 				writeMsg(1,dis);
    71. 			} catch (Exception e1) {
    72. 				e1.printStackTrace();
    73. 			}
    74. 		}
    75.  
    76. 	}
    77.  
    78. 	private void writeMsg(int flag, DataInputStream dis) throws Exception {
    79. //		DataOutputStream dos = new DataOutputStream(socket.getOutputStream()); 
    80. 		// 定义一个变量存放最终的消息形式 
    81. 		String msg = null ;
    82. 		if(flag == 1){
    83. 			/** 读取所有在线人数发给所有客户端去更新自己的在线人数列表 */
    84. 			/** onlineNames = [徐磊,zhangsan,李刚]*/
    85. 			StringBuilder rs = new StringBuilder();
    86. 			Collection onlineNames = ServerChat.onLineSockets.values();
    87. 			// 判断是否存在在线人数 
    88. 			if(onlineNames != null && onlineNames.size() > 0){
    89. 				for(String name : onlineNames){
    90. 					rs.append(name+ Constants.SPILIT);
    91. 				}
    92. 				// 徐磊003197♣♣㏘♣④④♣zhangsan003197♣♣㏘♣④④♣李刚003197♣♣㏘♣④④♣
    93. 				// 去掉最后的一个分隔符 
    94. 				msg = rs.substring(0, rs.lastIndexOf(Constants.SPILIT));
    95.  
    96. 				/** 将消息发送给所有的客户端 */
    97. 				sendMsgToAll(flag,msg);
    98. 			}
    99. 		}else if(flag == 2 || flag == 3){
    100. 			// 读到消息  群发的 或者 @消息
    101. 			String newMsg = dis.readUTF() ; // 消息
    102. 			// 得到发件人 
    103. 			String sendName = ServerChat.onLineSockets.get(socket);
    104.  
    105. 			// 李刚 时间
    106. 			//    内容--
    107. 			StringBuilder msgFinal = new StringBuilder();
    108. 			// 时间  
    109. 			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE");
    110. 			if(flag == 2){
    111. 				msgFinal.append(sendName).append("  ").append(sdf.format(System.currentTimeMillis())).append("\r\n");
    112. 				msgFinal.append("    ").append(newMsg).append("\r\n");
    113. 				sendMsgToAll(flag,msgFinal.toString());
    114. 			}else if(flag == 3){
    115. 				msgFinal.append(sendName).append("  ").append(sdf.format(System.currentTimeMillis())).append("对您私发\r\n");
    116. 				msgFinal.append("    ").append(newMsg).append("\r\n");
    117. 				// 私发 
    118. 				// 得到给谁私发 
    119. 				String destName = dis.readUTF();
    120. 				sendMsgToOne(destName,msgFinal.toString());
    121. 			}
    122. 		}
    123. 	}
    124. 	/**
    125. 	 * @param destName 对谁私发 
    126. 	 * @param msg 发的消息内容 
    127. 	 * @throws Exception
    128. 	 */
    129. 	private void sendMsgToOne(String destName, String msg) throws Exception {
    130. 		// 拿到所有的在线socket管道 给这些管道写出消息
    131. 		Set allOnLineSockets = ServerChat.onLineSockets.keySet();
    132. 		for(Socket sk :  allOnLineSockets){
    133. 			// 得到当前需要私发的socket 
    134. 			// 只对这个名字对应的socket私发消息
    135. 			if(ServerChat.onLineSockets.get(sk).trim().equals(destName)){
    136. 				DataOutputStream dos = new DataOutputStream(sk.getOutputStream());
    137. 				dos.writeInt(2); // 消息类型
    138. 				dos.writeUTF(msg);
    139. 				dos.flush();
    140. 			}
    141. 		}
    142.  
    143. 	}
    144.  
    145. 	private void sendMsgToAll(int flag, String msg) throws Exception {
    146. 		// 拿到所有的在线socket管道 给这些管道写出消息
    147. 		Set allOnLineSockets = ServerChat.onLineSockets.keySet();
    148. 		for(Socket sk :  allOnLineSockets){
    149. 			DataOutputStream dos = new DataOutputStream(sk.getOutputStream());
    150. 			dos.writeInt(flag); // 消息类型
    151. 			dos.writeUTF(msg);
    152. 			dos.flush();
    153. 		}
    154. 	}
    155. }
    1. package com.itheima.d9_chat.即时通信;
    2.  
    3. public class User {
    4. 	private Integer id ;
    5. 	private String name ;
    6. 	
    7. 	public User(Integer id, String name) {
    8. 		this.id = id;
    9. 		this.name = name;
    10. 	}
    11. 	
    12. 	public Integer getId() {
    13. 		return id;
    14. 	}
    15. 	public void setId(Integer id) {
    16. 		this.id = id;
    17. 	}
    18. 	public String getName() {
    19. 		return name;
    20. 	}
    21. 	public void setName(String name) {
    22. 		this.name = name;
    23. 	}
    24. 	@Override
    25. 	public String toString() {
    26. 		return "User [id=" + id + ", name=" + name + "]";
    27. 	}	
    28. }
  • 相关阅读:
    美术如何创建 skybox 贴图资源？
    python+Vue大学生课堂答疑论坛交互系统django
    FlinkCDC基础篇章1-安装使用
    Zabbix邮箱报警
    在 Mac 客户端 C++ 代码中使用 breakpad
    Jetpack：014-Jetpack中的小红点
    有意识的神经网络之对比网络层和后意识层
    我对需求分析的理解
    Android使用ANativeWindow更新surfaceView内容最简Demo
    计算机毕业设计ssm社区基层党建管理信息系统s5738系统+程序+源码+lw+远程部署
  • 原文地址：https://blog.csdn.net/daqi1983/article/details/133988745