10 - JavaSE之网络编程

时间  2019-11-16
标签 javase 网络 编程 栏目 Java 繁體版
原文   原文链接

网络编程java

网络通讯协议分层思想编程

为何要分层呢？由于整个网络协议很是复杂，要涉及到方方面面的知识，并且还有对底层硬件的操做，利用分层的思想，咱们能够将复杂的通讯协议分割成一层层的形式，上一层能够调用下一层，而与再下一层不发生关系，各层之间互不影响，便于系统的开发。咱们把用户程序做为最高层，把物理通讯线路做为最底层，高层到底层一步步封装，咱们不须要直接操做底层，而是操做最简单的最高层，这就是分层的意义。服务器

参考模型网络

  1. OSI七层模型

物理层、数据链路层、网络层、传输层、会话层、表示层、应用层socket

  1. TCP/IP参考模型

应用层、传输层（TCP/UDP层）、网络层（IP层）、数据链路层、物理层.net

咱们今天要讲的主要是传输层。3d

IP协议code

IP层：给咱们作的最大贡献就是提供了独一无二的IP地址。server

IP TCP UDP 网关 内网 子网掩码对象

  • TCP
  1. TCP是Transfer Control Protocol（传输控制协议）的简称，是一种面向链接的保证可靠传输的协议。一个TCP链接必需要通过三次“对话”才能创建起来。
  2. 在TCP/IP协议中，IP层主要负责网络主机的定位，数据传输的路由，由IP地址能够惟一肯定Internet上的一台主机。而TCP层则提供面向应用的可靠的或非可靠的数据传输机制，这是网络编程的主要对象，通常不须要关心IP层是如何处理数据的。
  3. 发送方和接收方的成对的两个socket之间必须创建链接，以便在TCP协议的基础上进行通讯。当一个socket（一般都是serversocket）等待创建链接时，另外一个socket能够要求进行链接，一旦这两个socket链接起来，它们就能够进行双向数据传输，双方均可以进行发送或接收操做。
  • UDP

UDP是User Datagram Protocol的简称，是一种无链接的协议。UDP是从一台计算机向另外一台计算机发送称为数据报的独立数据包的协议，该协议并不保证数据报是否能正确地到达目的地，它是一个非面向链接的协议。每一个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，所以可否到达目的地，到达时间以及内容的正确性都是不能保证的。

  • TCP和UDP的比较
  1. 使用UDP时，每一个数据报中都给出了完整的地址信息，所以无需创建发送方和接收方的链接。对于TCP协议，因为它是一个面向链接的协议，在socket之间进行数据传输以前必然要创建链接，因此在TCP中多了一个链接创建的时间。
  2. 使用UDP传输数据时是有大小限制的，每一个被传输的数据报必须限定在64KB以内。TCP没有这方面的限制，一旦链接创建起来，双方的socket就能够按统一的格式传输大量的数据。
  3. UDP是一个不可靠的协议，发送方所发送的数据报并不必定以相同的次序到达接收方；TCP是一个可靠的协议，它确保接收方彻底正确地获取发送方所发送的所有数据。
  4. 可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽。所以TCP传输的效率不如UDP高。
  5. TCP在网路通讯上有极强的生命力，例如远程链接（Telnet）和文件传输（FTP）都须要不定长度的数据被可靠地传输。相比之下UDP操做简单，并且仅须要较少的监护，所以一般用于局域网高可靠性的分散系统中client/server应用程序。
  • Socket
  1. 两个 Java 应用程序能够经过一个双向的网络通讯链接实现数据交换，这个双向链路的一端称为一个Socket。
  2. Socket 一般用来实现 client-server 链接。
  3. java.net 包中定义的两个类 Socket 和 ServerSocket ，分别用来实现双向链接的 client 和 server 端。
  4. 创建链接时所需的寻址信息为远程计算机的 IP 地址和端口号（Port）

端口：用于区分不一样的网络应用程序 ，占两个字节，因此共有 65535 个端口号。不过系统会随时征用 1024 如下端口。

端口又分TCP和UDP端口，各有 65535 个端口。

TCP Socket 通讯模型

示例1：最简单的Socket模型：Client写数据务器读数据

// Server
import java.net.*;
import java.io.*;

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(6666); // 已经开始监听6666端口了      
        while(true) {
            Socket s = ss.accept(); // ss创建一个插座Socket，接受和客户端s的链接（阻塞式链接）,链接成功，至关于服务器和客户端之间链接了两根管道。读的管道（InputStream）和写的管道（OutputStream）。
            System.out.println("A Client has Connected!");
            DataInputStream dis = new DataInputStream(s.getInputStream());
            System.out.println(dis.readUTF());// 因此先获取管道，要说就获取写的管道，要听就获取读的管道。
            dis.close();
            s.close();
        }
    }
}

// Client
import java.net.*;
import java.io.*;

public class Client {
    public static void main(String[] args) throws Exception {
        Socket s = new Socket("127.0.0.1", 6666);// 申请和ss创建链接   
        DataOutputStream dos = new DataOutputStream(s.getOutputStream());       
        dos.writeUTF("Hello TCP."); // 链接好以后开始说话，经过管道流的方式来讲话，因此先获取管道，要说就获取写的管道，要听就获取读的管道。   
        dos.flush();
        dos.close();
        s.close();
    }
}

Client 端的 IP 地址不能随意指定，不知为什么。

示例2：服务器向客户端发送数据，客户端接收数据

// Server
import java.net.*;
import java.io.*;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(6666);       
            while(true) {
                Socket s = ss.accept();
                System.out.println("A Client has Connected!");
                DataOutputStream dos = new DataOutputStream(s.getOutputStream());
                dos.writeUTF("Hi [#IP:" + s.getInetAddress() + " #Port:" + s.getPort() + "], I'm Server.");
                dos.close();
                s.close();
            }
        } catch (IOException e) {
            System.out.println("Server Error!!!");
            e.printStackTrace();
        }
    }
}

// Client
import java.net.*;
import java.io.*;

public class Client {
    public static void main(String[] args) {
        try {
            Socket s = new Socket("127.0.0.1", 6666);       
            DataInputStream dis = new DataInputStream(s.getInputStream());      
            System.out.println(dis.readUTF());  
            dis.close();
            s.close();
        } catch(IOException e) {
            System.out.println("Client Error!!!");
            e.printStackTrace();
        }
    }
}
//I:\Java\Demo>java Client
//Hi [#IP:/127.0.0.1 #Port:15944], I'm Server.

//I:\Java\Demo>java Client
//Hi [#IP:/127.0.0.1 #Port:15953], I'm Server.

//I:\Java\Demo>java Client
//Hi [#IP:/127.0.0.1 #Port:15954], I'm Server.

//I:\Java\Demo>java Client
//Hi [#IP:/127.0.0.1 #Port:15955], I'm Server.

示例3：服务器和客户端同时读写数据（固然一个先读一个先写喽，若是两个都读或都写的话就卡死啦）

// Server
// 服务器先接收客户端的数据，而后再发送数据给客户端
import java.net.*;
import java.io.*;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(6666);
            Socket s = ss.accept();
            
            System.out.println("A Client has Connected!");
            
            DataInputStream dis = new DataInputStream(s.getInputStream());
            DataOutputStream dos = new DataOutputStream(s.getOutputStream());
            
            String str = null;
            if((str=dis.readUTF()) != null)
            {
                System.out.println("I'm reseaving message...");
                Thread.sleep(3000);
                dos.writeUTF("Hi [#IP:" + s.getInetAddress() + " #Port:" + s.getPort() + "], I hava reseaved: " + str);
            }
            
            dis.close();
            dos.close();
            s.close();
        } catch (IOException e) {
            System.out.println("Server Error!!!");
            e.printStackTrace();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


// Client
// 客户端先发送数据给服务器，再接收服务器的回复。
import java.net.*;
import java.io.*;

public class Client {
    public static void main(String[] args) {
        try {
            Socket s = new Socket("localhost", 6666);
            
            DataInputStream dis = new DataInputStream(s.getInputStream());
            DataOutputStream dos = new DataOutputStream(s.getOutputStream());
            
            System.out.println("Hi Server, I'm sending message to you...");
            
            Thread.sleep(2000);
            
            dos.writeUTF("Hello HYJ.");
            System.out.println(dis.readUTF());
            
            dis.close();
            s.close();
        } catch(UnknownHostException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

注意：这里面使用的是 Socket s = new Socket("localhost", 6666);

最后要 catch(UnknownHostException e)，UnknownHostException 小于 IOException 因此要放前面。

UDP 通讯模型

示例：

// UDPServer 接收并打印来自客户端的数据
import java.net.*;
import java.io.*;

public class UDPServer {
    public static void main(String[] args) {
        try {
            byte[] buf = new byte[1024];
            DatagramPacket dp = new DatagramPacket(buf, buf.length);
            DatagramSocket ds = new DatagramSocket(8888);
            while(true) {
                ds.receive(dp);
                //ByteArrayInputStream bais = new ByteArrayInputStream(buf);
                //DataInputStream dis = new DataInputStream(bais);
                //System.out.println("UDPClient: " + dis.readUTF());
               System.out.println("UDPClient: " + new String(buf, 0, dp.getLength()));
            }           
        } catch (IOException e) {
            System.out.println("UDPServer Error!!!");
            e.printStackTrace();
        }
    }
}


// UDPClient 发送数据给服务器
import java.net.*;
import java.io.*;

public class UDPClient {
    public static void main(String[] args) {
        try {
            //ByteArrayOutputStream baos = new ByteArrayOutputStream();         
            //DataOutputStream dos = new DataOutputStream(baos);
            
            //dos.writeUTF("Hello HYJ!");
            //dos.flush();

            //byte[] buf = baos.toByteArray();
           byte[] buf = (new String("Hello HYJ!")).getBytes();
            System.out.println("buf.length = " + buf.length);
            
            DatagramPacket dp = new DatagramPacket(buf, buf.length, new InetSocketAddress("127.0.0.1", 8888));
            DatagramSocket ds = new DatagramSocket(7777);
            
            ds.send(dp);
            ds.close();
            
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程