网络编程总结

JAVA_SE —基础知识总结–网络编程

## (1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享
## (2)网络编程模型
## (3)网络编程的三要素
     ### I:IP地址
        #### IP地址的组成：网络号段+主机号段
            A类：第一号段为网络号段+后三段的主机号段
                一个网络号：256*256*256 = 16777216
            B类：前二号段为网络号段+后二段的主机号段
                一个网络号：256*256 = 65536
            C类：前三号段为网络号段+后一段的主机号段
                一个网络号：256
        #### IP地址的分类：
            A类  1.0.0.1---127.255.255.254   
                (1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)           
                (2)127.X.X.X是保留地址，用做循环测试用的。
            B类  128.0.0.1---191.255.255.254 172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。
            C类  192.0.0.1---223.255.255.254 192.168.X.X是私有地址
            D类  224.0.0.1---239.255.255.254     
            E类  240.0.0.1---247.255.255.254
        #### 两个DOS命令：
            ipconfig 查看本机ip地址
            ping 后面跟ip地址。测试本机与指定的ip地址间的通信是否有问题

        #### 特殊的IP地址：
            127.0.0.1 回环地址(表示本机)
            x.x.x.255 广播地址
            x.x.x.0 网络地址
    ### II:端口
        是应用程序的标识。范围：0-65535。其中0-1024不建议使用。
    ### III:协议
        UDP:数据打包,有限制,不连接,效率高,不可靠
        TCP:建立数据通道,无限制,效率低,可靠
## (4)Socket机制
    A:通信两端都应该有Socket对象
    B:所有的通信都是通过Socket间的IO进行操作的

## (5)UDP协议发送和接收数据

### 发送：

           ```import java.io.IOException;
            import java.net.DatagramPacket;
            import java.net.DatagramSocket;
            import java.net.InetAddress;
            /*
             * UDP协议发送数据：
             * A:创建发送端Socket对象
             * B:创建数据，并把数据打包
             * C:调用Socket对象的发送方法发送数据包
             * D:释放资源
             */
            public class SendDemo {
                public static void main(String[] args) throws IOException {
                    // 创建发送端Socket对象
                    // DatagramSocket()
                    DatagramSocket ds = new DatagramSocket();

                    // 创建数据，并把数据打包
                    // DatagramPacket(byte[] buf, int length, InetAddress address, int port)
                    // 创建数据
                    byte[] bys = "hello,udp,我来了".getBytes();
                    // 长度
                    int length = bys.length;
                    // IP地址对象
                    InetAddress address = InetAddress.getByName("192.168.12.92");
                    // 端口
                    int port = 10086;
                    DatagramPacket dp = new DatagramPacket(bys, length, address, port);

                    // 调用Socket对象的发送方法发送数据包
                    // public void send(DatagramPacket p)
                    ds.send(dp);

                    // 释放资源
                    ds.close();
                }
            }```

### 接收：

                      `
     `import java.io.IOException;
        import java.net.DatagramPacket;
        import java.net.DatagramSocket;
        import java.net.InetAddress;

        /*
         * UDP协议接收数据：
         * A:创建接收端Socket对象
         * B:创建一个数据包(接收容器)
         * C:调用Socket对象的接收方法接收数据
         * D:解析数据包，并显示在控制台
         * E:释放资源
         */
        public class ReceiveDemo {
            public static void main(String[] args) throws IOException {
                // 创建接收端Socket对象
                // DatagramSocket(int port)
                DatagramSocket ds = new DatagramSocket(10086);

                // 创建一个数据包(接收容器)
                // DatagramPacket(byte[] buf, int length)
                byte[] bys = new byte[1024];
                int length = bys.length;
                DatagramPacket dp = new DatagramPacket(bys, length);

                // 调用Socket对象的接收方法接收数据
                // public void receive(DatagramPacket p)
                ds.receive(dp); // 阻塞式

                // 解析数据包，并显示在控制台
                // 获取对方的ip
                // public InetAddress getAddress()
                InetAddress address = dp.getAddress();
                String ip = address.getHostAddress();
                // public byte[] getData():获取数据缓冲区
                // public int getLength():获取数据的实际长度
                byte[] bys2 = dp.getData();
                int len = dp.getLength();
                String s = new String(bys2, 0, len);
                System.out.println(ip + "传递的数据是:" + s);

                // 释放资源
                ds.close();
            }
        }`

## (6)TCP协议发送和接收数据

### 发送：

           `import java.io.IOException;
            import java.io.OutputStream;
            import java.net.Socket;

            /*
             * TCP协议发送数据：
             * A:创建发送端的Socket对象
             *      这一步如果成功，就说明连接已经建立成功了。
             * B:获取输出流，写数据
             * C:释放资源
             * 
             * 连接被拒绝。TCP协议一定要先开服务器。
             * java.net.ConnectException: Connection refused: connect
             */
            public class ClientDemo {
                public static void main(String[] args) throws IOException {
                    // 创建发送端的Socket对象
                    // Socket(InetAddress address, int port)
                    // Socket(String host, int port)
                    // Socket s = new Socket(InetAddress.getByName("192.168.12.92"), 8888);
                    Socket s = new Socket("192.168.12.92", 8888);

                    // 获取输出流，写数据
                    // public OutputStream getOutputStream()
                    OutputStream os = s.getOutputStream();
                    os.write("hello,tcp,我来了".getBytes());

                    // 释放资源
                    s.close();
                }
            }`

### 接收：

            `import java.io.IOException;
            import java.io.InputStream;
            import java.net.ServerSocket;
            import java.net.Socket;

            /*
             * TCP协议接收数据：
             * A:创建接收端的Socket对象
             * B:监听客户端连接。返回一个对应的Socket对象
             * C:获取输入流，读取数据显示在控制台
             * D:释放资源
             */
            public class ServerDemo {
                public static void main(String[] args) throws IOException {
                    // 创建接收端的Socket对象
                    // ServerSocket(int port)
                    ServerSocket ss = new ServerSocket(8888);

                    // 监听客户端连接。返回一个对应的Socket对象
                    // public Socket accept()
                    Socket s = ss.accept(); // 侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。

                    // 获取输入流，读取数据显示在控制台
                    InputStream is = s.getInputStream();

                    byte[] bys = new byte[1024];
                    int len = is.read(bys); // 阻塞式方法
                    String str = new String(bys, 0, len);

                    String ip = s.getInetAddress().getHostAddress();

                    System.out.println(ip + "---" + str);

                    // 释放资源
                    s.close();
                    // ss.close(); //这个不应该关闭
                }
            }
            `