[19/04/15-星期一] 基于Socket(套接字)的TCP和UDP通讯的实现

一、TCP

在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序，简称客户端，而在第一次通讯中等待连接的程序被称作服务器端(Server)程序，

简称服务器。一旦通讯建立，则客户端和服务器端完全一样，没有本质的区别。

“请求-响应”模式：

1. Socket类：发送TCP消息。

2. ServerSocket类：创建服务器。

套接字是一种进程间的数据交换机制。这些进程既可以在同一机器上，也可以在通过网络连接的不同机器上。换句话说，套接字起到通信端点的作用。

单个套接字是一个端点，而一对套接字则构成一个双向通信信道，使非关联进程可以在本地或通过网络进行数据交换。一旦建立套接字连接，数据即可在相同

或不同的系统中双向或单向发送，直到其中一个端点关闭连接。套接字与主机地址和端口地址相关联。主机地址就是客户端或服务器程序所在的主机的IP地址。

端口地址是指客户端或服务器程序使用的主机的通信端口。

在客户端和服务器中，分别创建独立的Socket，并通过Socket的属性，将两个Socket进行连接，这样，客户端和服务器通过套接字所建立的连接使用输入输出流进行通信。

TCP/IP套接字是最可靠的双向流协议，使用TCP/IP可以发送任意数量的数据。

实际上，套接字只是计算机上已编号的端口。如果发送方和接收方计算机确定好端口，他们就可以通信了。套接字就像传输层为应用层开的一个小口，应用程序通过这个小口

像远程发送数据或者从远程就收数据。而这个小口之内，也就是数据进入这个口之后，或者从这个口出来之前，是不知道也不需知道数据是如何传输的，这属于网络其它层次的工

作。

如图12-6所示为客户端与服务器端的通信关系图：

图12-6 客户端与服务器端的通信关系图

TCP/IP通信连接的简单过程：

位于A计算机上的TCP/IP软件向B计算机发送包含端口号的消息，B计算机的TCP/IP软件接收该消息，并进行检查，查看是否有它知道的程序正在该端口上接收消息。

如果有，他就将该消息交给这个程序。

要使程序有效地运行，就必须有一个客户端和一个服务器。

通过Socket的编程顺序：

1. 创建服务器ServerSocket，在创建时，定义ServerSocket的监听端口(在这个端口接收客户端发来的消息)。

2. ServerSocket调用accept()方法，使之处于阻塞状态。

3. 创建客户端Socket，并设置服务器的IP及端口。

4. 客户端发出连接请求，建立连接。

5. 分别取得服务器和客户端Socket的InputStream和OutputStream。

6. 利用Socket和ServerSocket进行数据传输。

7. 关闭流及Socket。

【代码示例】

/***客户端
 * 1、建立连接，使用Socket建立客户端，需要指定服务器的地址和端口
 * 2、操作：输入和输出流操作
 * 3、释放资源
 * 
 */
package cn.sxt.net;


import java.io.DataOutputStream;
import java.net.Socket;


public class Test_0416_TcpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端.....");
        Socket  client=new Socket("localhost",8888);//1、建立连接，使用Socket建立客户端，需要指定服务器的地址和端口
        
        //客户端(输出)---->(输入)服务器端(输出)----->(输入)客户端
        DataOutputStream dos =new DataOutputStream(client.getOutputStream());//2、操作：输入和输出流操作
        dos.writeUTF("hello");
        dos.flush();
        dos.close();     
        client.close();// 3、释放资源    
        
    }
}


/***创建服务器 它与客户端的地位不平等，比客户端地址高
 *1、 指定端口，使用ServerSocket创建服务器
 *2、阻塞式等待连接 accept
 *3、操作：输入流输出流操作
 *4、释放资源
 */

package cn.sxt.net;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;


public class Test_0416_TcpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("服务器端.....");
        ServerSocket server =new ServerSocket(8888);//指定端口，使用ServerSocket创建服务器
        Socket client=server.accept();//等待一个客户端的连接
        System.out.println("一个客户端建立了连接");
        
        DataInputStream dis =new DataInputStream(client.getInputStream());
        System.out.println(dis.readUTF());
        
        dis.close();
        
        client.close();        
    }
    
}

【登录验证】

/***
 * 登录的服务端
 */
package cn.sxt.net;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Test_0416_LoginServer {
    public static void main(String[] args) throws Exception {
        System.out.println("服务器端.....");
        boolean isRunning=true;
        ServerSocket server =new ServerSocket(8888);//指定端口，使用ServerSocket创建服务器

        while (isRunning) {
            Socket client=server.accept();//等待一个客户端的连接
            System.out.println("一个客户端建立了连接");
            new Thread(new Channel(client)).start();

        }
        server.close();
    }

}

class Channel implements Runnable{
    private Socket client;
    DataInputStream dis;
    DataOutputStream dos;
    public Channel (Socket client) {
        this.client=client;
        try {
            dis = new DataInputStream(client.getInputStream());//输入
            dos =new DataOutputStream(client.getOutputStream());//输出
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //接收数据
    private String  receive() {
        String datas="";
        try {
            datas = dis.readUTF();
        } catch (IOException e) {
            e.printStackTrace();
        }    
        return datas;    
    }
    //发送数据
    private void  send(String msg) {
        try {
            dos.writeUTF(msg);
            dos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }    
    }
    
    //释放资源
    private void release() {
        try {
            dis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }    
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }    
    }
    
    public void run() {    

        String uName="";
        String uPsd="";

        String[] dataArray=receive().split("&");//分割字符串 传过来的"uName="+uName+"&"+"uPsd="+uPsd
        //dataArray[]是一个包含"uName=小李"、"uPsd=12345"的数组
        for (String info : dataArray) {
            String userInfo[]=info.split("=");//再次分割"uName=小李"和"uPsd=12345"
            if (userInfo[0].equals("uName")) {
                System.out.println("用户名是："+userInfo[1]);
                uName=userInfo[1];

            } else if (userInfo[0].equals("uPsd")){
                System.out.println("密码是："+userInfo[1]);
                uPsd=userInfo[1];
            }
        }    
        //向客户端反馈结果，反向输出
        if (uName.equals("小李")&&uPsd.equals("12345")) {
            send("登陆成功，欢迎回来！");

        } else {
            send("用户名或密码错误");
            
        }        
        release();

    }

}


/***客户端
 * 1、建立连接，使用Socket建立客户端，需要指定服务器的地址和端口
 * 2、操作：输入和输出流操作
 * 3、释放资源
 * 
 */
package cn.sxt.net;


import java.io.DataOutputStream;
import java.net.Socket;


/**
 * 
 */
package cn.sxt.net;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @author Administrator
 *
 */
public class Test_0416_LoginClient {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端.....");
        BufferedReader user=new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入用户名：");
        String uName=user.readLine();    
        System.out.println("请输入密码：");
        String uPsd=user.readLine();

        Socket  client=new Socket("localhost",8888);//1、建立连接，使用Socket建立客户端，需要指定服务器的地址和端口
        
    /*//未封装的代码 
        DataOutputStream dos =new DataOutputStream(client.getOutputStream());
        dos.writeUTF("uName="+uName+"&"+"uPsd="+uPsd);
        dos.flush();
        
        DataInputStream dis =new DataInputStream(client.getInputStream());
        String result=dis.readUTF();
        System.out.println(result);
        dos.close();
        client.close();*/
        
        new Send(client).send("uName="+uName+"&"+"uPsd="+uPsd);
        new Receive(client).receive();

        client.close();// 3、释放资源
    }
    //内部类  //客户端(输出)---->(输入)服务器端(输出)----->(输入)客户端
    static class Send{
        private Socket client;
        private DataOutputStream dos;
        public  Send(Socket client) throws IOException {
            this.client=client;//
            dos =new DataOutputStream(client.getOutputStream());//2、操作：输入和输出流操作
        }

        public void send(String msg) throws IOException {
            dos.writeUTF(msg);
            dos.flush();
        }
    }
   

    static class Receive{//接收来自服务器端的反馈
        private Socket client;
        private DataInputStream dis;
        public  Receive(Socket client) throws IOException {
            this.client=client;
            dis =new DataInputStream(client.getInputStream());//2、操作：输入和输出流操作
        }

        public void receive()throws IOException  {
            String result = dis.readUTF();
            System.out.println(result);
        }
    }
    
}

二、UDP

▪ DatagramSocket：用于发送或接收数据报包

当服务器要向客户端发送数据时，需要在服务器端产生一个DatagramSocket对象，在客户端产生一个DatagramSocket对象。服务器端的DatagramSocket将

DatagramPacket发送到网络上，然后被客户端的DatagramSocket接收。

DatagramSocket有两种常用的构造函数。一种是无需任何参数的，常用于客户端;另一种需要指定端口，常用于服务器端。如下所示：

DatagramSocket() ：构造数据报套接字并将其绑定到本地主机上任何可用的端口。

DatagramSocket(int port) ：创建数据报套接字并将其绑定到本地主机上的指定端口。

常用方法：

Ø send(DatagramPacket p) ：从此套接字发送数据报包。

Ø receive(DatagramPacket p) ：从此套接字接收数据报包。

Ø close() ：关闭此数据报套接字。

▪ DatagramPacket：数据容器(封包)的作用

此类表示数据报包。数据报包用来实现封包的功能。

常用方法：

Ø DatagramPacket(byte[] buf, int length) ：构造数据报包，用来接收长度为 length 的数据包。

Ø DatagramPacket(byte[] buf, int length, InetAddress address, int port) ：构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

Ø getAddress() ：获取发送或接收方计算机的IP地址，此数据报将要发往该机器或者是从该机器接收到的。

Ø getData() ：获取发送或接收的数据。

Ø setData(byte[] buf) ：设置发送的数据。

UDP通信编程基本步骤：

1. 创建客户端的DatagramSocket，创建时，定义客户端的监听端口。

2. 创建服务器端的DatagramSocket，创建时，定义服务器端的监听端口。

3. 在服务器端定义DatagramPacket对象，封装待发送的数据包。

4. 客户端将数据报包发送出去。

5. 服务器端接收数据报包。

【代码示例】

服务器端

/***
 * UDP服务端
 1、使用 DatagramSocket() 指定端口 创建发送端
 2、准备数据，一定转成字节数组
 3、封装DatagramPacket包裹，需要指定目的地
 4、发送包裹 send(DatagramPacket p)
 5、释放资源
 */
package cn.sxt.net;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;



public class Test_0415_UdpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("发送方启动中......");
        DatagramSocket server=new DatagramSocket(8888);//1、(收货人地址)指定发送端端口,如“8888”
        //String data="知否知否应是绿肥红瘦";//2、(邮件)准备数据，一定转成字节数组
        
        //对于基本数据类型,需要借助IO流中的装饰流：DataStraem
        
        ByteArrayOutputStream baos=new ByteArrayOutputStream();
        DataOutputStream dos=new DataOutputStream(baos);
        
        dos.writeUTF("编码");
        dos.writeInt(345);
        dos.flush();
        
        byte[] datas=baos.toByteArray();
        
        //3、(邮局打包)封装DatagramPacket包裹，需要指定目的地端口,如本机的“9999”端口
        DatagramPacket packet=new DatagramPacket(datas, 0,datas.length,new InetSocketAddress("localhost",6666) );        
        //4、(邮局发送)端口发送包裹 send(DatagramPacket p)
        server.send(packet);
        server.close();            
    }
}

接收端

/***数据容器(封包)的作用
 DatagramPacket(byte[] buf, int length) ：构造数据报包，用来接收长度为 length 的数据包。
   
 DatagramPacket(byte[] buf, int length, InetAddress address, int port) 构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

 getAddress() ：获取发送或接收方计算机的IP地址，此数据报将要发往该机器或者是从该机器接收到的。

 getData() ：获取发送或接收的数据。

 setData(byte[] buf) ：设置发送的数据。
 DatagramSocket有两种常用的构造函数。一种是无需任何参数的，常用于客户端;另一种需要指定端口，常用于服务器端。如下所示：

      DatagramSocket() ：构造数据报套接字并将其绑定到本地主机上任何可用的端口。

      DatagramSocket(int port) ：创建数据报套接字并将其绑定到本地主机上的指定端口。
 方法：     
      send(DatagramPacket p) ：从此套接字发送数据报包。

      receive(DatagramPacket p) ：从此套接字接收数据报包。

      close() ：关闭此数据报套接字。
 
 UDP客户端(地位与服务端平等，没有绝对的高下之分)
 Datagram:数据报、报文 Packet:包裹、小包
 
 1、使用 DatagramSocket() 指定端口 创建接收端
 2、准备容器，封装成DatagramPacket包裹
 3、阻塞式接收包裹 receive(DatagramPacket p)
 4、拆包分析数据 getData() getlength()
 5、释放资源
 */
package cn.sxt.net;


import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;


public class Test_0415_UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("接收方启动中......");//同一个协议下端口不能相同
        DatagramSocket client=new DatagramSocket(6666);//1、(收货方)指定接收端端口,由于在本机不要与发送方的端口相同
        
        byte[] receiveContainer=new byte[1024*60];//2、(收货方)准备接收容器(拿个标准箱子去接收),最多60KB，即最多60个字节。
        DatagramPacket packet1=new DatagramPacket(receiveContainer, 0,receiveContainer.length);        

        //3、(邮局接收)阻塞式接收DatagramPacket包裹
        client.receive(packet1);    
        
        //4、(邮局拆包)拆开包裹，分析数据，即解码
        byte[] datas=packet1.getData();
        int len=packet1.getLength();
        
        //一些基本数据类型接收
        ByteArrayInputStream bis=new ByteArrayInputStream(datas);
        DataInputStream dis=new DataInputStream(bis);
    
        System.out.println(dis.readUTF());    
        System.out.println(dis.readInt());
        
        //System.out.println(new String(datas,0,len));
        //5、释放资源
        client.close();        

    }
}

【一个在线聊天的例子】

【发送端】

/***
 * 发送端
 */
package cn.sxt.net;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class Test_0415_TalkSend implements Runnable{
    private DatagramSocket server;
    private BufferedReader reader;
    
    //private String myName;
    
    private String toIP;//对方的ip
    private int  toPort;//对方的端口


    public Test_0415_TalkSend(int port,String toIP,int toPort) {
        //this.myName=myName;没想好怎么弄
        this.toIP=toIP;
        this.toPort=toPort;
        try {
            this.server = new DatagramSocket(port);
            this.reader=new BufferedReader(new InputStreamReader(System.in));

        } catch (SocketException e) {
            e.printStackTrace();
        }
    }


    public void run() {
        while (true) {
            //System.out.print(myName+":");
            String data;
            try {
                data = reader.readLine();
                byte datas[]=data.getBytes();

                //3、(邮局打包)封装DatagramPacket包裹，需要指定目的地端口,如本机的“9999”端口
                DatagramPacket packet=new DatagramPacket(datas, 0,datas.length,
                        new InetSocketAddress(this.toIP,this.toPort));        
                //4、(邮局发送)端口发送包裹 send(DatagramPacket p)
                server.send(packet);
                if (data.equals("bye")) {
                    break;        
                }

            } catch (IOException e) {
                e.printStackTrace();
            }            
        }
        server.close();    
    }
}

【接收端】

/***
 * 接收端
 */
package cn.sxt.net;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class Test_0415_TalkReceive implements Runnable {
    private DatagramSocket client;
    private String from;//对方的名字
    int port;

    public Test_0415_TalkReceive(int port,String from) {
        this.from=from;
        try {
            client=new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }

    }


    public void run() {
        while (true) {
            byte[] receiveContainer=new byte[1024*60];//2、(收货方)准备接收容器(拿个标准箱子去接收),最多60KB，即最多60个字节。
            DatagramPacket packet1=new DatagramPacket(receiveContainer, 0,receiveContainer.length);        

            //3、(邮局接收)阻塞式接收DatagramPacket包裹
            try {
                client.receive(packet1);
                //4、(邮局拆包)拆开包裹，分析数据，即解码
                byte[] datas=packet1.getData();
                int len=packet1.getLength();    
                String data=new String(datas,0,len);
                
                System.out.println(from+":"+data);
                
                if(data.equals("bye")){
                    break;
                }
            } catch (IOException e) {

                e.printStackTrace();
            }        
        }
        //5、释放资源
        client.close();        

    }


}

【2个主类】

package cn.sxt.net;

/**
 * @author Administrator
 *
 */
public class Test_0415_Talk_Student {
    public static void main(String[] args) {
        System.out.println("学生端启动....");
        new Thread(new Test_0415_TalkSend(8000, "localhost", 7777)).start();//学生端发送 端口8000 ,老师:本机7777端口
        new Thread(new Test_0415_TalkReceive(5555,"咨询师")).start();//学生端(端口为5555)接收教师端的 
    }

}



package cn.sxt.net;

public class Test_0415_Talk_Teacher {
    public static void main(String[] args) {
        System.out.println("教师端启动....");
        new Thread(new Test_0415_TalkReceive(7777,"小李")).start();//老师端接收(来自学生端的)，教师端端口是7777 
        new Thread(new Test_0415_TalkSend(9999, "localhost", 5555) ).start();//老师端(9999)往学生端(端口5555)发送
    }

}

posted @ 2019-04-11 20:55 ID长安忆阅读(304) 评论(0) 收藏举报

刷新页面返回顶部

ID长安忆

[19/04/15-星期一] 基于Socket(套接字)的TCP和UDP通讯的实现

公告