AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

网游开发之socket的简单设计

2014-06-11 800
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 对于普通应用的网络模块一般使用http文本协议，在android开发中使用http协议比较简单，sdk已经做了很好的封装了，具体使用方法可以参考我的这篇博文。

对于普通应用的网络模块一般使用http文本协议，在android开发中使用http协议比较简单，sdk已经做了很好的封装了，具体使用方法可以参考我的这篇博文。而在游戏开发中，可以结合使用http和socket，当然了http协议底层也是基于tcp协议的。http协议是无连接、无状态的，每次连接只能处理一个请求，然后就断了，而且发一个请求需要附加额外信息(请求行、请求头),每次请求都需要重新建立连接；使用socket的好处是更高效和省流量，建立一次连接后，只要不手动或者出现异常断开，就可以一直互相发送数据，而且是直接以字节的形式发送，不需要额外的附加信息，缺点就是难度加大了，需要服务端和客户端很好的配合，保证发送和读取时数据的顺序一致。本文通过一个简单的demo介绍开发android网游时socket的使用方法，主要包括：android客户端和一个简单的使用java实现的server端，实现客户端和服务端互相发送数据的功能。
1.客户端代码实现
首先创建一个Android应用，名称:AndroidSocketTest
然后分别创建4个文件：BytesUtil.java、BytesReader.java、BytesWriter.java、TCPCommunication.java,下面分别介绍这几个文件的用处和源码：
BytesUtil.java：包含了一些静态工具方法：基本类型和字节数组的相互转换，字符串和字节数组的相互转换，字节数组的赋值和大小重置，对输入流进行读取保存等。比较简单，下面直接看源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/**
author:alexzhou
email :zhoujiangbohai@163.com
date  :2012-11-7
  **/
 
public final class BytesUtil {
 
     /**
      *整型转换成字节数组
      * @param value 要转换的整型值
      * @return
      */
     public static byte [] shortToBytes( int value) {
         byte []write = new byte [ 2 ];
         write[ 0 ] = ( byte )( (value >>> 8 ) & 0xFF );
         write[ 1 ] = ( byte )( (value >>> 0 ) & 0xFF );
         return write;
     }
 
     public static byte [] intToBytes( int value) {
         byte []write = new byte [ 4 ];
         write[ 0 ] = ( byte )( (value >>> 24 ) & 0xFF );
         write[ 1 ] = ( byte )( (value >>> 16 ) & 0xFF );
         write[ 2 ] = ( byte )( (value >>> 8 ) & 0xFF );
         write[ 3 ] = ( byte )( (value >>> 0 ) & 0xFF );
         return write;
     }
 
     public static byte [] longToBytes( long value) {
         byte []write = new byte [ 8 ];
         write[ 0 ] = ( byte )( (value >>> 56 ) & 0xFF );
         write[ 1 ] = ( byte )( (value >>> 48 ) & 0xFF );
         write[ 2 ] = ( byte )( (value >>> 40 ) & 0xFF );
         write[ 3 ] = ( byte )( (value >>> 32 ) & 0xFF );
         write[ 4 ] = ( byte )( (value >>> 24 ) & 0xFF );
         write[ 5 ] = ( byte )( (value >>> 16 ) & 0xFF );
         write[ 6 ] = ( byte )( (value >>> 8 ) & 0xFF );
         write[ 7 ] = ( byte )( (value >>> 0 ) & 0xFF );
         return write;
     }
 
     /**
      * 字节数组转换成整型
      * @param value
      * @return
      */
     public static int bytesToInt( byte []value) {
         int i1 = (value[ 0 ] & 0xFF ) << 24 ;
         int i2 = (value[ 1 ] & 0xFF ) << 16 ;
         int i3 = (value[ 2 ] & 0xFF ) << 8 ;
         int i4 = (value[ 3 ] & 0xFF ) << 0 ;
         return (i1 | i2 | i3 | i4);
     }
 
     public static short bytesToShort( byte [] value) {
         int s1 = (value[ 0 ] & 0xFF ) << 8 ;
         int s2 = (value[ 1 ] & 0xFF ) << 0 ;
         return ( short )(s1 | s2);
     }
 
     public static long bytesToLong( byte [] value) {
         long L1 = (value[ 0 ] & 0xFF ) << 56 ;
         long L2 = (value[ 1 ] & 0xFF ) << 48 ;
         long L3 = (value[ 2 ] & 0xFF ) << 40 ;
         long L4 = (value[ 3 ] & 0xFF ) << 32 ;
         long L5 = (value[ 4 ] & 0xFF ) << 24 ;
         long L6 = (value[ 5 ] & 0xFF ) << 16 ;
         long L7 = (value[ 6 ] & 0xFF ) << 8 ;
         long L8 = (value[ 7 ] & 0xFF ) << 0 ;
         return (L1 | L2 | L3 | L4 | L5 | L6 | L7 | L8);
     }
 
     /**
      * 从指定字节数组中拷贝部分数据
      * @param origin
      * @param from
      * @param to
      * @return
      */
     public static byte [] copyBytes( byte [] origin, int from, int to) {
         int len = to - from;
         if (len < 0 || origin.length - from <= 0 ) {
             throw new IllegalArgumentException( "copyBytes->error arguments:to=" +to+ ",from=" +from);
         }
         byte [] ret = new byte [len];
         if (len == 0 ) return ret;
         System.arraycopy(origin, from, ret, 0 , Math.min(len, origin.length - from));
         return ret;
     }
 
     /**
      * 重置字节数组的大小，然后把原内容复制到新的字节数组中
      * @param origin
      * @param newSize
      * @return
      */
     public static byte [] resizeBytes( byte [] origin, int newSize) {
         if (newSize < 0 ) {
             throw new IllegalArgumentException( "resizeBytes->newSize must >= 0" );
         }
         byte [] ret = new byte [newSize];
         if (newSize == 0 ) return ret;
         System.arraycopy(origin, 0 ,ret, 0 ,Math.min(origin.length, newSize));
         return ret;
     }
 
     /**
      * 读取输入流中字节,并保存到指定的字节数组中
      * @param is
      * @param data
      * @param off
      * @param len
      */
     public static void readData(InputStream is, byte data[], int off, int len) {
         int hasRead = 0 ;
         final int BUFFER = 1024 ;
         while (hasRead < len) {
             try {
                 int remain = len - hasRead;
                 int count = is.read(data, off + hasRead, remain > BUFFER ? BUFFER : remain);
                 if (count < 0 ) throw new IOException( "readData->read data error" );
                 hasRead += count;
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
}

BytesReader.java：从服务端接收数据时使用，定义了一个字节数组类型的成员变量，用来保存从输入流中读取的数据。封装了一些从该字节数组中读取相应数据类型的函数，源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/**
  * 接受服务端数据时，读取字节并转换到相应类型
author:alexzhou
email :zhoujiangbohai@163.com
date  :2012-11-7
  **/
 
public final class BytesReader {
 
     private final byte []data;
     //字节数组的大小
     private final int size;
     //当前读取的位置
     private int position;
 
     public BytesReader( byte []data) {
         this .data = data;
         this .size = data.length;
         this .position = 0 ;
     }
 
     public byte [] read( int len) {
         if (len < 0 ) return null ;
         byte [] value = BytesUtil.copyBytes(data, position, position + len);
         this .position += len;
         return value;
     }
 
     public int getSize() {
         return size;
     }
 
     public boolean isAvailable() {
         return size - position > 0 ;
     }
 
     public short readShort() {
         byte [] value = read( 2 );
         return BytesUtil.bytesToShort(value);
     }
 
     public int readInt() {
         byte [] value = read( 4 );
         return BytesUtil.bytesToInt(value);
     }
 
     public long readLong() {
         byte [] value = read( 8 );
         return BytesUtil.bytesToLong(value);
     }
 
     public byte readByte() {
         int value = this .isAvailable() ? ( 0xFF & data[position++]) : - 1 ;
         return ( byte )value;
     }
 
     public byte [] readBytes() {
         int len = readShort();
         //读取大数据
         if (len >= 0xFFFF ) {
             len = this .readInt();
         }
         return len == 0 ? null : read(len);
     }
 
     public String readUTF() {
         byte [] bytes = readBytes();
         if ( null != bytes) {
             try {
                 return new String(bytes, "UTF-8" );
             } catch (UnsupportedEncodingException e) {
                 e.printStackTrace();
             }
         }
         return null ;
     }
}

BytesWriter.java：向服务端发送数据时使用，跟BytesReader.java对应，也是把需要发送的数据保存到字节数组中，然后一次性发送给服务器。源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/**
author:alexzhou
email :zhoujiangbohai@163.com
date  :2012-11-9
  **/
 
public final class BytesWriter {
 
     private byte [] data;
     private int count;
 
     public BytesWriter() {
         this ( 64 );
     }
 
     public BytesWriter( int size) {
         this .data = new byte [size];
     }
 
     public byte [] getBytes() {
         return this .data.length == count ? data : count == 0 ? null : BytesUtil.resizeBytes( this .data, count);
     }
 
     public void write( byte [] value) {
         this .write(value, 0 , value == null ? 0 : value.length);
     }
 
     public void write( byte [] d, int offset, int len) {
         if (d == null || len == 0 ) return ;
         int newCount = count + len;
         if (newCount > this .data.length) {
             int newSize = Math.max( this .data.length << 1 , newCount);
             this .data = BytesUtil.resizeBytes( this .data, newSize);
         }
         System.arraycopy(d, offset, this .data, this .count, len);
         this .count = newCount;
     }
 
     public void writeInt( int value) {
         this .write(BytesUtil.intToBytes(value));
     }
 
     public void writeShort( int value) {
         this .write(BytesUtil.shortToBytes(value));
     }
 
     public void writeLong( long value) {
         this .write(BytesUtil.longToBytes(value));
     }
 
     public void writeByte( byte value) {
         int newCount = count + 1 ;
         if (newCount > this .data.length) {
             int newSize = Math.max( this .data.length << 1 , newCount);
             this .data = BytesUtil.resizeBytes( this .data, newSize);
         }
         this .data[count] = value;
         this .count = newCount;
     }
 
     public void writeBytes( byte [] value) {
         int length = (value == null ? 0 : value.length);
         //发送大数据时
         if (length >= 0xFFFF ) {
             this .writeShort( 0xFFFF );
             this .writeInt(length);
         } else {
             //告诉服务端发送的数据的大小
             this .writeShort(length);
         }
         this .write(value);
     }
 
     public void writeUTF(String value) {
         if (value == null || value.length() == 0 ) {
             this .writeShort( 0 );
         }
         byte [] bytes = null ;
         try {
             bytes = value.getBytes( "UTF-8" );
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
         this .writeBytes(bytes);
     }
 
}

TCPCommunication.java：上面的三个类都是辅助工具类，是给它使用的，它负责socket的创建和连接服务器、读取和发送数据，以及通过Handler发送消息给UI线程更新界面显示数据。由于我们的目的是使用socket通信，所以去掉了很多代码，这里只是简单的建立一次连接，发送和接收完数据后就关闭连接了。源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
public class TCPCommunication implements Runnable {
 
     private Socket mSocket;
     private DataInputStream mDis;
     private DataOutputStream mDos;
     private Handler mHandler;
 
     private volatile boolean isRunning = false ;
 
     public TCPCommunication(Handler handler) {
         this .mHandler = handler;
     }
 
     public boolean isRunning() {
         return isRunning;
     }
 
     public void startWork() {
         Thread t = new Thread( this );
         t.setPriority(Thread.MAX_PRIORITY);
         t.start();
     }
 
     public void stopWork() {
         this .isRunning = false ;
     }
 
     @Override
     public void run() {
         try {
             mSocket = new Socket( "10.0.2.2" , 8888 );
             mDis = new DataInputStream(mSocket.getInputStream());
             mDos = new DataOutputStream(mSocket.getOutputStream());
             //开始发送数据到服务端
             BytesWriter bw = new BytesWriter();
             String username = "alexzhou" ;
             String password = "123456" ;
             int flag1 = 12345 ;
             short flag2 = 12 ;
             long flag3 = 100000000L;
             bw.writeUTF(username);
             bw.writeUTF(password);
             bw.writeInt(flag1);
             bw.writeShort(flag2);
             bw.writeLong(flag3);
             byte [] data = bw.getBytes();
 
             BytesWriter out = null ;
             if (data.length >= 0xFFFF ) {
                 out = new BytesWriter(data.length + 6 );
                 out.writeShort( 0xFFFF );
                 out.writeInt(data.length);
             } else {
                 out = new BytesWriter(data.length + 2 );
                 out.writeShort(data.length);
             }
             out.write(data);
             mDos.write(out.getBytes());
 
             //开始从服务端接收数据
             int len = mDis.readShort();
             if (len == 0xFFFF ) {
                 len = mDis.readInt();
             }
             byte [] inputData = new byte [len];
             BytesUtil.readData(mDis, inputData, 0 , len);
             BytesReader br = new BytesReader(inputData);
             String user_id = br.readUTF();
             String recv_username = br.readUTF();
             String nickname = br.readUTF();
             int i = br.readInt();
             short s = br.readShort();
             long l = br.readLong();
 
             String result = "登录成功~您的信息如下\n id:" +user_id + "\n用户名:" + recv_username + "\n昵称:" + nickname + "\n 序列号:" + i + "-" + s + "-" + l;
             Message msg = mHandler.obtainMessage();
             msg.what = 0 ;
             msg.obj = result;
             mHandler.sendMessage(msg);
 
             mDis.close();
             mDos.close();
             mSocket.close();
 
         } catch (UnknownHostException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     };
 
}

MainActivty.java的代码比较简单，源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class MainActivity extends Activity {
 
     private TextView mTextView;
     private Button mButton;
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super .onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         mTextView = (TextView) this .findViewById(R.id.text);
         mButton = (Button) this .findViewById(R.id.button_send);
         mButton.setOnClickListener( new OnClickListener() {
 
             @Override
             public void onClick(View v) {
                 new TCPCommunication(mHandler).startWork();
             }
         });
     }
 
     private Handler mHandler = new Handler() {
 
         @Override
         public void handleMessage(Message msg) {
             String result = (String)msg.obj;
             mTextView.setText(result);
         }
 
     };
 
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
         getMenuInflater().inflate(R.menu.activity_main, menu);
         return true ;
     }
}

到此为止，Android客户端的代码已经全部完成了，记得给应用添加访问网络的权限哦：在配置文件中添加

1
< uses-permission android:name = "android.permission.INTERNET" />

2.服务端代码实现
服务端的代码比较简单，当然了，一般在实际的开发中，服务端和客户端不是同一个人写的，这里我就把客户端里的那几个工具类拿来直接用了。
创建一个java项目，然后把BytesReader.java、BytesWriter.java、BytesUtil.java三个文件拷贝到项目的包下，然后创建Server.java，功能比较简单，监听8888端口，然后等待客户端连接，接收和发送数据。源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/**
author:alexzhou
email :zhoujiangbohai@163.com
date  :2012-11-7
  **/
 
public final class Server implements Runnable{
 
     private ServerSocket mServerSocket;
     private Socket mClient;
     private DataInputStream mDis;
     private DataOutputStream mDos;
 
     private boolean isRunning = false ;
 
     public void start() {
         this .isRunning = true ;
         Thread t = new Thread( this );
         t.start();
     }
 
     public void stop() {
         this .isRunning = false ;
     }
 
     public static void main(String []args) {
         new Server().start();
     }
     @Override
     public void run() {
         try {
             mServerSocket = new ServerSocket( 8888 );
             System.out.println( "start server" );
             while (isRunning) {
                 System.out.println( "wait client connect!!" );
                 mClient = mServerSocket.accept();
 
                 //接收客户端发送的数据
                 mDis = new DataInputStream(mClient.getInputStream());
                 //数据的长度
                 int len = mDis.readShort();
                 if (len == 0xFFFF ) {
                     len = mDis.readInt();
                 }
                 System.out.println( "client data size:" + len);
                 byte [] inputData = new byte [len];
                 BytesUtil.readData(mDis, inputData, 0 , len);
                 BytesReader br = new BytesReader(inputData);
                 String username = br.readUTF();
                 String password = br.readUTF();
                 int i = br.readInt();
                 short s = br.readShort();
                 long l = br.readLong();
                 System.out.println( "username:" +username+ ";password=" +password+ "Long=" +l);
 
                 //向客户端发送数据
                 mDos = new DataOutputStream(mClient.getOutputStream());
                 BytesWriter bw = new BytesWriter( 32 );
                 String user_id = "123456" ;
                 String nickname = "周江海" ;
                 bw.writeUTF(user_id);
                 bw.writeUTF(username);
                 bw.writeUTF(nickname);
                 bw.writeInt(i);
                 bw.writeShort(s);
                 bw.writeLong(l);
                 byte [] data = bw.getBytes();
                 BytesWriter out = null ;
                 if (data.length >= 0xFFFF ) {
                     out = new BytesWriter(data.length + 6 );
                     out.writeShort( 0xFFFF );
                     out.writeInt(data.length);
                 } else {
                     out = new BytesWriter(data.length + 2 );
                     out.writeShort(data.length);
                 }
                 out.write(data);
                 mDos.write(out.getBytes());
 
                 mDos.close();
                 mDis.close();
                 mClient.close();
             }
         } catch (IOException e) {
             e.printStackTrace();
         }  
     }
}

现在验证一下，先启动Server，然后运行Android客户端应用，屏幕中间会出现TextView和一个button，TextView的内容是HelloWorld，点击button就会发送登陆信息给服务端，然后服务端返回数据显示到TextView上。下面分别是服务端的打印消息和客户端的显示截图。


主要需要掌握基本数据类型和字符串跟字节数组的转换，然后按照指定的顺序发送。最重要的是要注意客户端和服务端从字节数组读取和往字节数组写入数据时的顺序要对应。

文章标签：
Java
Android开发
小金子
目录
相关文章
Man9Oo
|
存储 网络协议 Unix
网络基础：socket套接字
网络基础：socket套接字
Man9Oo
132 0
长梦
|
4月前
|
C# 开发者
C# 一分钟浅谈：Socket 编程基础
【10月更文挑战第7天】本文介绍了Socket编程的基础知识、基本操作及常见问题，通过C#代码示例详细展示了服务器端和客户端的Socket通信过程，包括创建、绑定、监听、连接、数据收发及关闭等步骤，帮助开发者掌握Socket编程的核心技术和注意事项。
长梦
159 3
C# 一分钟浅谈：Socket 编程基础
dearQiHao
|
9月前
|
网络协议 Linux 定位技术
网络编程函数小总结与初识socket
总结服务器端的函数和客户端的函数 再次声明博主写的都是对于linux下的网络编程,没有写关于Windows的网络编程,也许以后会写到。 这里只是总结一下,具体参数的含义等后面的跟新
dearQiHao
85 0
xiaohua616
|
设计模式 网络协议 小程序
Socket 案例
Socket 案例
xiaohua616
117 4
Socket 案例
老师我作业忘带了
|
域名解析 缓存 网络协议
网络编程及socket模块（1）
网络编程及socket模块（1）
老师我作业忘带了
164 0
网络编程及socket模块（1）
老师我作业忘带了
|
移动开发 网络协议 Linux
网络编程及socket模块（2）
网络编程及socket模块（2）
老师我作业忘带了
139 0
网络编程及socket模块（2）
爱喝汤的技术少年
|
网络协议 Java Unix
Socket简介和I/O多路复用
Socket简介和I/O多路复用
爱喝汤的技术少年
280 0
Socket简介和I/O多路复用
CBeann
Socket基础使用
Socket基础使用
CBeann
133 0
xumaojun
|
网络协议 Unix Linux
从问题看本质：socket到底是什么？
原文:http://blog.csdn.net/yeyuangen/article/details/6799575 一、问题的引入——socket的引入是为了解决不同计算机间进程间通信的问题 1.socket与进程的关系 1).socket与进程间的关系:socket   用来让一个进程和其他的进程互通信息(IPC)，而Socket接口是TCP/IP网络的API接口函数。
xumaojun
2067 0
小白鸡菜
|
消息中间件 网络协议 Unix
socket概念
socket概念
小白鸡菜
265 0

热门文章

最新文章

  • 1
    Oracle使用expdp/impdp实现全库导入导出的整体流程
  • 2
    Python实现阿里云域名DDNS支持ipv4和ipv6
  • 3
    Tensorflow车牌识别完整项目（含完整源代码及训练集）
  • 4
    linux误删除了文件
  • 5
    系统架构技能之设计模式-组合模式
  • 6
    php判断上传文件是不是图片，如果是，返回图片格式
  • 7
    用户手册概要
  • 8
    Android -- 与WEB交互在同一个会话Session中通信
  • 9
    青岛城市圈：青岛 OSCER 技术交流会(1月12日)
  • 10
    springMVC对异常处理的支持
  • 1
    【2025穿越时空 怀旧经典】VMware Workstation Pro助你重返WindowsXP，让怀旧不再是空谈！
    24
  • 2
    【2025最新】 神奇！VMware Workstation Pro虚拟机还原与删除功能，让你轻松应对各种场景！
    31
  • 3
    【2025最新】VMware Workstation Pro 虚拟机配置与安装VMware Tools 感受它的强大~
    28
  • 4
    【2025最新】VMware Workstation Pro 虚拟机基础配置教程，方便你的神操作!
    28
  • 5
    【02】整体试验思路，在这之前我们发现sec_uid,sec_uid是什么和uid的关系又是什么？相互如何转换？python开发之理论研究试验，如何通过抖音视频下方的用户的UID获得抖音用户的手机号-本系列文章仅供学习研究-禁止用于任何商业用途-仅供学习交流-优雅草卓伊凡
    23
  • 6
    十、MyBatis的缓存
    21
  • 7
    【独家揭秘2025】VMware Workstation Pro虚拟机：免费安装教程大放送，一键解锁操作系统模拟神器！
    17
  • 8
    算法系列之递归反转单链表
    20
  • 9
    【Java并发】【线程池】带你从0-1入门线程池
    89
  • 10
    《解锁脑电信号密码：探秘标准化与归一化处理》
    13

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    通义万相：视觉生成大模型再进化