TCP协议接收与发送数据

TCP：
    建立连接通道
    数据无限制
    速度慢
    可靠

TCP协议发送数据：
1:创建发送端的Socket对象 这一步如果成功，就说明连接已经建立成功了。
2:获取输出流，写数据
3:释放资源

    public static void main(String[] args) throws IOException {
        // 创建发送端的Socket对象
        // Socket(InetAddress address, int port)   创建指定 IP 地址，指定端口号的socket对象
        // Socket(String host, int port) 创建指定 指定主机，指定端口号的socket对象
        // Socket s = new Socket(InetAddress.getByName("192.168.12.92"), 123);
        Socket s = new Socket("192.168.1.104", 123);

        //   返回此套接字的输出流。
        // public OutputStream getOutputStream()
        OutputStream os = s.getOutputStream();
        os.write("我是发送端".getBytes());//将数据发送到通道
        // 释放资源
        s.close();
    }

TCP协议接收数据：
1:创建接收端的Socket对象
2:监听客户端连接。返回一个对应的Socket对象
3:获取输入流，读取数据显示在控制台
4:释放资源

    public static void main(String[] args) throws IOException {
        // 创建接收端的Socket对象
        // ServerSocket(int port)
        ServerSocket ss = new ServerSocket(123);

        // 监听客户端连接。返回一个对应的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);
        //获取发送端Ip
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip + "---" + str);
        // 释放资源
        s.close();
    }
输出：
192.168.1.104---我是发送端

多线程实现接收端，多个发送端的TCP

发送端：

    public static void main(String[] args) throws IOException {
        // 创建客户端Socket对象
        Socket s = new Socket("192.168.1.104", 123);

        // 读取文件的流
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        // 通道写入流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        //将数据写入到通道
        String line = null;
        while ((line = br.readLine()) != null) {// 阻塞
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        // Socket  禁用此套接字的输出流。告诉接收端，数据已经发送完毕，你不要堵塞了
        s.shutdownOutput();
        // 获取接收端反馈过来的数据
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String str = brClient.readLine(); // 阻塞，等待接收端数据发送完毕
        System.out.println(str);
        // 释放资源
        br.close();
        s.close();
    }
输出：
文件已经上传成功了

接收端：

    public static void main(String[] args) throws IOException {
        // 创建服务器Socket对象
        ServerSocket ss = new ServerSocket(123);
        //一直创建服务器，对象是同一个，不过重复监听的过程
        while (true) {
            Socket s = ss.accept();//建立连接通道，堵塞，// 监听客户端连接
            new Thread(new ServiceThread (s)).start();
        }

}

接收端多线程的实现

public class ServiceThread implements Runnable {
    private Socket s;

    public UserThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        try {
            // 封装通道内的流
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));


            // 为了防止名称冲突
            String newName = System.currentTimeMillis() + ".txt";
            BufferedWriter bw = new BufferedWriter(new FileWriter(newName));

            String line = null;
            while ((line = br.readLine()) != null) { // 阻塞
                bw.write(line);
                bw.newLine();
                bw.flush();
            }

            // 给出反馈给发送端
            BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件已经上传成功了");
            bwServer.newLine();
            bwServer.flush();
            s.shutdownOutput();
            // 释放资源
            bw.close();
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

结果：

注意：可以开启多个发送端进行，因为接收端一直在重复监听