备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

网游开发之socket的简单设计

2014-06-11 781
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 对于普通应用的网络模块一般使用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开发
小金子
目录
相关文章
1941623231718325
|
18天前
|
网络协议 Python
Python网络编程基础（Socket编程）创建UDP socket对象
【4月更文挑战第8天】在Python中创建UDP服务器涉及使用`socket`模块创建socket对象，如`udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)`，然后绑定到特定IP地址和端口，如`udp_socket.bind((&#39;localhost&#39;, 12345))`。服务器通过`recvfrom`在无限循环中监听和接收数据报。这只是基础，实际应用还需处理接收、解析、响应及错误处理等。接下来可学习如何利用socket对象进行数据交互以构建完整服务器。
1941623231718325
18 1
Man9Oo
|
6月前
|
存储 网络协议 Unix
网络基础：socket套接字
网络基础：socket套接字
Man9Oo
59 0
dearQiHao
|
3月前
|
网络协议 Linux 定位技术
网络编程函数小总结与初识socket
总结服务器端的函数和客户端的函数 再次声明博主写的都是对于linux下的网络编程,没有写关于Windows的网络编程,也许以后会写到。 这里只是总结一下,具体参数的含义等后面的跟新
dearQiHao
27 0
Paranoid
|
9月前
|
网络协议
socket聊天室--socket的建立
socket聊天室--socket的建立
Paranoid
64 0
CBeann
Socket基础使用
Socket基础使用
CBeann
102 0
老师我作业忘带了
|
域名解析 缓存 网络协议
网络编程及socket模块（1）
网络编程及socket模块（1）
老师我作业忘带了
96 0
网络编程及socket模块（1）
老师我作业忘带了
|
移动开发 网络协议 Linux
网络编程及socket模块（2）
网络编程及socket模块（2）
老师我作业忘带了
102 0
网络编程及socket模块（2）
xiaohua616
|
设计模式 网络协议 小程序
Socket 案例
Socket 案例
xiaohua616
84 4
Socket 案例
小白鸡菜
|
消息中间件 网络协议 Unix
socket概念
socket概念
小白鸡菜
198 0
半生瓜のblog
|
网络协议 Unix Linux
【Socket】Socket相关概念及函数
【Socket】Socket相关概念及函数
半生瓜のblog
153 0
【Socket】Socket相关概念及函数

热门文章

最新文章

  • 1
    理解事务的4种隔离级别
  • 2
    疑犯追踪第一季/全集Person Of Interest迅雷下载
  • 3
    简单实用的数据建模工具PDManer
  • 4
    详细讲解！Canal+Kafka实现MySQL与Redis数据同步！
  • 5
    71.7. Script for automatic startup on boot
  • 6
    关于Oracle客户端显示乱码问题
  • 7
    PHPWAMP站点管理的“域名模式”和“端口模式”详解、均支持自定义
  • 8
    jsHelper
  • 9
    学校里学不到的东西(一)
  • 10
    Python 3 教程一:入门
  • 1
    Python的装饰器
    34
  • 2
    R语言用潜类别混合效应模型(Latent Class Mixed Model ,LCMM)分析老年痴呆年龄数据
    20
  • 3
    数据分享|R语言用logistic逻辑回归和AFRIMA、ARIMA时间序列模型预测世界人口
    16
  • 4
    【视频】马尔可夫链蒙特卡罗方法MCMC原理与R语言实现|数据分享（下）
    21
  • 5
    【视频】马尔可夫链蒙特卡罗方法MCMC原理与R语言实现|数据分享（上）
    27
  • 6
    数据分享|数据探索电商平台用户行为流失可视化分析
    29
  • 7
    电商平台数据可视化分析网红零食销量
    18
  • 8
    R语言线性回归模型拟合诊断异常值分析家庭燃气消耗量和卡路里实例带自测题
    16
  • 9
    数据分享|R语言GLM广义线性模型：逻辑回归、泊松回归拟合小鼠临床试验数据（剂量和反应）示例和自测题
    12
  • 10
    数据分享|R语言逻辑回归、线性判别分析LDA、GAM、MARS、KNN、QDA、决策树、随机森林、SVM分类葡萄酒交叉验证ROC（下）
    17

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）