Java Socket实现基于TCP和UDP多线程通信

一.通过Socket实现TCP编程

1.1 TCP编程

　　TCP协议是面向连接，可靠的，有序的，以字节流的方式发送数据。基于TCP协议实现网络通信的类有客户端的Socket类和服务器端的ServerSocket类。

1.2 服务器端套路

　　1.创建ServerSocket对象，绑定监听端口。

　　2.通过accept（）方法监听客户端请求。

　　3.连接建立后，通过输入流读取客户端发送的请求信息。

　　4.通过输出流向客户端发送响应信息。

　　5.关闭响应的资源。

1.3 客户端套路

　　1.创建Socket对象，指明需要连接的服务器的地址和端口号。

　　2.连接建立后，通过输出流向服务器发送请求信息。

　　3.通过输入流获取服务器响应的信息。

　　4.关闭相应资源。

1.4 多线程实现服务器与多客户端之间通信步骤

　　1.服务器端创建ServerSocket，循环调用accept（）等待客户端连接。

　　2. 客户端创建一个socket并请求和服务器端连接。

　　3.服务器端接受客户端请求，创建socket与该客户建立专线连接。

　　4.建立连接的两个socket在一个单独的线程上对话。

　　5.服务器端继续等待新的连接。

1.5 创建处理线程类ServerThread

　　这里选择实现runnable接口而不是继承Thread是因为一个类只能继承一个父类，当我需要继承其他类的时，父类就就不好处理了。

package SocketThread;

import java.io.*;
import java.net.Socket;

/**
 * 1.4 多线程实现服务器与多客户端之间通信步骤
 *
 * 　　1.服务器端创建ServerSocket，循环调用accept（）等待客户端连接。
 *
 * 　　2. 客户端创建一个socket并请求和服务器端连接。
 *
 * 　　3.服务器端接受客户端请求，创建socket与该客户建立专线连接。
 *
 * 　　4.建立连接的两个socket在一个单独的线程上对话。
 *
 * 　　5.服务器端继续等待新的连接。
 *
 * 这里选择实现runnable接口而不是继承Thread是因为一个类只能继承一个父类，
 * 当我需要继承其他类的时，父类就就不好处理了。
 */

public class ServerThread implements Runnable {

    Socket socket = null;  //和本线程相关的Socket

    public ServerThread(Socket socket){
        this.socket =socket;
    }



    public void run() {
        InputStream is = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        OutputStream os = null;
        PrintWriter pw = null;

        try {
            //与客户端建立通信，获取输入流，读取客户端提供的信息
            is = socket.getInputStream();
            isr = new InputStreamReader(is,"UTF-8");
            br = new BufferedReader(isr);

            String data = null;

            //循环读取客户端的信息
            while ((data=br.readLine())!=null){
                System.out.println("我是服务器，客户端提交信息为:" + data);
            }
            socket.shutdownInput();  //关闭输入流

            //获取输出流
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("服务器响应成功!");
            pw.flush();
            socket.shutdownOutput();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源即相关socket

            try {

                if(pw!=null)
                    pw.close();
                /* 这里直接把socket.getOutputStream();给关了，并且导致socket也直接关闭
                if(os!=null)
                    os.close();

                 */
                if(br!=null)
                    br.close();
                if(isr!=null)
                    isr.close();
                if(is!=null)
                    is.close();

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


        }
    }
}

1.6 创建服务器端类

　　使用while以达到可以循环侦听不同客户端的连接请求。因为这是一个死循环，所以不用关闭也没有机会去关闭serverSocket。设置count值，用于记录服务器端被连接过的次数并显示客户端所在ip值。如果线程处理类是继承Thread类，那么创建新线程代码可以改为ServerThread serverThread = new ServerThread(socket);serverThread.start();

package SocketThread;

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


/**
 * 使用while以达到可以循环侦听不同客户端的连接请求。因为这是一个死循环
 * ，所以不用关闭也没有机会去关闭serverSocket。设置count值，
 * 用于记录服务器端被连接过的次数并显示客户端所在ip值。如果线程处理类是继承Thread类，
 * 那么创建新线程代码可以改为ServerThread serverThread = new ServerThread(socket);
 * serverThread.start();
 */

public class Server {

    public static void main(String[] args) {

        try {
            //创建一个服务器的Socket,即ServerSocket，绑定需要监听的端口
            ServerSocket serverSocket = new ServerSocket(8888);
            Socket socket = null;
            //记录连接过服务器的客户端数量
            int count = 0 ;
            System.out.println("*****服务器即将启动,等待客户端的连接****");
            while (true){   //循环监听新的客户端的连接
                //调用accept()方法倾听，等待客户端的连接以及获取Socket实例
                socket = serverSocket.accept();
                //创建新线程
                Thread thread = new Thread(new ServerThread(socket));
                thread.start();

                count++;
                System.out.println("服务器端被连接的次数: " + count);
                InetAddress address = socket.getInetAddress();
                System.out.println("当前客户端的IP为："+address.getHostAddress());
            }
            //serverSocket   一直监听，不用关闭连接
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

1.7 创建客户端类

　　在后面的关闭资源中，我把输入输出相关的流关闭注释了，是因为对于同一个Socket，关闭socket的时候也会把输入输出流关闭，直接关闭socket就行，当然保留也是可以的。

package SocketThread;

import java.io.*;
import java.net.Socket;

public class Client {

    public static void main(String[] args) {
        try {
            //创建客户端Socket,指定服务器地址和端口
            Socket socket = new Socket("localhost",8888);
            //建立连接后，获取输出流，向服务器发送信息
            OutputStream os = socket.getOutputStream();
            //输出流包装为打印流
            PrintWriter pw = new PrintWriter(os);
            //向服务器端发送信息
            pw.write("用户名：zzh;密码：123");//写入内存缓冲区
            pw.flush();//刷新缓存，向服务器端输出信息
            socket.shutdownOutput();  //关闭输出流

            InputStream is = socket.getInputStream();


            BufferedReader br = new BufferedReader(new InputStreamReader(is,"UTF-8"));
            String data = null;

            while((data=br.readLine())!= null){
                System.out.println("我是客户端，服务器端提交信息为："+data);

            }
            socket.shutdownInput();

            //关闭其他资源
//            br.close();
//            is.close();
//            pw.close();
//            os.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

二. 通过Socket实现UDP编程

2.1 UDP编程

　　UDP协议又叫用户数据报协议，是无连接，不可靠的，无序的。特点是传输速度相对要快，UDP协议以数据报作为数据传输的载体。当进行数据传输时，首先需要将要传输的数据定义成数据报（Datagram），在数据报中指明数据所要达到的Socket（主机地址和端口号），然后再将数据报发送出去。相关操作类有：DatagramPacket数据报包，DatagramSocket进行端到端通信的类。

2.2 服务器端实现套路

　　1.创建DatagramSocket，指定端口号。2.创建DatagramPacket。3.接收客户端发送的数据信息。4.读取数据。

2.3 客户端实现套路

　　1.定义发送信息，比如发送地址，端口号和内容。2. 创建DatagramPacket，包含将要发送的信息。3.创建DatagramSocket。4.发送数据。

2.4 多线程实现服务器与多客户端之间通信步骤

　　1.服务器端创建DatagramSocket的实例socket，循环调用receive（）方法，此方法在接收到数据报之前会一直阻塞。

　　2.客户端创建DatagramSocket，将含有地址，端口号和内容的数据报包发送出去。

　　3. 服务器端收到数据报包packet，通过DatagramSocket和packet与客户端建立一个线程

　　4. 服务器端继续等待新的数据报包。

　　5. 发送方的DatagramPacket构造方法传递四个参数包含数据内容，数据大小，地址和端口号。接收方的DatagramPacket构造方法有两个参数接收数据和数据大小。

2.5 创建服务器线程处理类UDPThread

　　注意，DatagramSocket的实例socket不能关闭，会出现SocketException。读取数据用到的new String(packet.getData(), 0, packet.getLength())，参数表示数据报中的字节数组，位置和长度。

 

三 TCP与UDP的差别