TCP实现客户端和服务器端连接、文件上传，UDP发送消息、实现多线程在线咨询

TCP实现客户端和服务器端连接

客户端：

1. 连接服务器Socket
2. 发送消息

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

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {

        Socket socket =null;
        OutputStream outputStream=null;
        try {
            //1.要知道服务器的地址，端口号
            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //2.创建一个socket连接
            socket = new Socket(address, port);
            //3.发消息
            outputStream = socket.getOutputStream();
            outputStream.write("你好世界！".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (socket!=null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream!=null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器端：

1. 建立服务的端口 ServerSocket
2. 等待用户的连接 accept
3. 接收消息

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

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {

        ServerSocket serverSocket =null;
        Socket socket =null;
        InputStream inputStream=null;
        ByteArrayOutputStream stream=null;
        try {
            //1.我得有一个地址
            serverSocket = new ServerSocket(9999);
            //2.等待客户端连接
            socket = serverSocket.accept();
            //3.读取客户端的消息
            inputStream = socket.getInputStream();

            //管道流
            stream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len=inputStream.read(buffer))!=-1){
                stream.write(buffer,0,len);
            }
            System.out.println(stream.toString());


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if (stream!=null){
                try {
                    stream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

TCP文件上传

服务端：

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


public class TcpServerDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建一个服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端连接
        //3.获取输入流
        InputStream inputStream = socket.getInputStream();
        //4.文件输出
        FileOutputStream fileOutputStream = new FileOutputStream(new File("receive.png"));
        byte[] bytes = new byte[1024];
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len);
        }

        //通知客户端输入完毕了
        OutputStream stream = socket.getOutputStream();
        stream.write("接收完毕！".getBytes());
        // 关闭资源
        fileOutputStream.close();
        inputStream.close();
        socket.close();
    rverSocket.close();
    }
}

客户端：

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


public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2.创建一个输入流
        OutputStream outputStream = socket.getOutputStream();
        //3.读取文件
        FileInputStream fileInputStream = new FileInputStream(new File("1.png"));
        //4.写出文件
        byte[] bytes = new byte[1024];
        int len;
        while ((len=fileInputStream.read(bytes))!=-1){
            outputStream.write(bytes,0,len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput();
        //确定服务端输入完毕
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] bytes1 = new byte[2014];
        int len2;
        while ((len2=inputStream.read(bytes1))!=-1){
            baos.write(bytes1,0,len2);
        }

        System.out.println(baos.toString());

        //5.关闭资源
        baos.close();
        inputStream.close();
        fileInputStream.close();
        outputStream.close();
        socket.close();
    }
}

UDP发送消息

事先不需要知道对方地址。

发送方：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.建个包
        String msg="你好啊，服务器";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        //数据，数据长度起始，发给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

接收方：

import java.net.DatagramPacket;
import java.net.DatagramSocket;

//还是要等待客户端
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);//接收

        socket.receive(packet);

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        //关闭连接
        socket.close();
    }
}

UDP实现多线程在线咨询

双方既可以是发送方，也可以是接收方

发送类：

package com.tao.chat;

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

public class TalkSend implements Runnable{
    DatagramSocket socket =null;
    BufferedReader reader =null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            //准备数据,控制台读取System.in
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                String data = reader.readLine();
                byte[] dataBytes = data.getBytes();
                DatagramPacket packet = new DatagramPacket(dataBytes, 0, dataBytes.length, new InetSocketAddress(this.toIP, this.toPort));

                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

接收类：

package com.tao.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class TalkReceive implements Runnable {
    DatagramSocket socket=null;
    private int port;
    private String msgForm;

    public TalkReceive(int port,String msgForm) {
        this.port= port;
        this.msgForm=msgForm;
        try {
            socket=new DatagramSocket(port);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                //准备接收包裹
                byte[] container= new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);
                //断开连接
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);

                System.out.println(msgForm+":"+receiveData);

                if (receiveData.equals("bye")){
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

学生线程：

package com.tao.chat;

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

老师线程：

package com.tao.chat;

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

运行效果如下：

//学生端线程
老师您好
老师:怎么啦有什么事                                               
我是过了武汉理工大学考研初试的学生，想让您作为我的研究生导师
老师:看你各方面都不错，准了                                       
谢谢老师
   
//老师端线程
学生:老师您好                                                   
怎么啦有什么事
学生:我是过了武汉理工大学考研初试的学生，想让作为我的研究生导师        
看你各方面都不错，准了
学生:谢谢老师