Java 6个TCP套接字通信练习

菠萝味菠萝啤

已于 2022-03-25 10:46:24 修改

阅读量435

点赞数

分类专栏：计算机网络编程文章标签：套接字

于 2021-12-26 01:28:37 首次发布

本文链接：https://blog.csdn.net/dd_Mr/article/details/122053517

版权

计算机网络编程专栏收录该内容

12 篇文章 1 订阅

订阅专栏

练习1

客户端：发送数据，接收数据
服务器：发送数据，接收数据

package demo1;



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

/**
 * 练习1
 * 客户端：发送数据，接收数据
 * 服务器：发送数据，接收数据
 */
public class client {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("127.0.0.1",12345);
        //发送数据，输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,你好服务器".getBytes());

        //接收服务器数据，输入流，读数据
        InputStream is = s.getInputStream();
        //字节流，按字节数组来读
        byte[] bys = new byte[1024];
        int len = is.read(bys);

        String data = new String(bys,0,len);    //长度是读到数据的长度
        System.out.println("客户端收到："+data);

        s.close();
    }
}

package demo1;

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

public class server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(12345);
        //监听客户端
        Socket s = ss.accept();
        //收数据,读数据，输入
        InputStream is = s.getInputStream();

        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys,0,len);

        System.out.println("服务器收到的数据:"+data);

        //发数据，write。输出流
        OutputStream os = s.getOutputStream();
        os.write("发送给客户端".getBytes());

        ss.close();
    }
}

在这里插入图片描述

练习3

客户端和练习2一样不变

package com.itheima_07;

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

/*
    客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        s.close();
    }
}

服务器端：

package com.itheima_07;

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

/*
    服务器：接收到的数据写入文本文件
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\s.txt"));

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

        //释放资源
        bw.close();
        ss.close();
    }
}

练习5

客户端：数据来自于文本文件，接收服务器反馈
服务器端：接收到的数据写入文本文件，给出反馈
出现问题：程序一直等待
原因：读数据的方法是阻塞式的
解决办法：

自定义结束标记比如定义886，
使用shutdownOutput()方法（推荐）

ip地址唯一表示一个主机
端口号标识唯一进程
进程里面可以有好多线程

客户端代码

package socketTest5;

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

/**
 *  数据来自文本文件，接收服务器反馈
 */
public class ClientDemo {

    public static void main(String[] args) throws IOException {
        //创造客户端套接字,ip地址标识唯一主机，端口号标识唯一进程
        Socket socket = new Socket("127.0.0.1", 10086);
        //读数据,封装文本文件数据
        BufferedReader br = new BufferedReader(new FileReader("src\\student1.owl"));
        //发送数据， 封装输出流写数据，确实要用套接字传过去
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        //开始写数据
        //这个是把数据一行一行的读
        String line;
        while((line = br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //写完数据，之后，需要用个输出结束标记，告诉服务器，我写完了
        socket.shutdownOutput();


        //接收反馈,接收到的数据用字符缓冲流接收
        BufferedReader brClient = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        //等待读取数据
        String data = brClient.readLine();  //把放到容器中的内容， 一行一行读出来，因为就一行，所以不用循环
        System.out.println("服务器反馈："+data);
        //释放资源
        br.close();     //关闭输入流，那个读数据的
        socket.close(); //关闭套接字

    }

}

服务器代码：

package socketTest5;

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

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器套接字
        ServerSocket serverSocket = new ServerSocket(10086);
        //监听客户端链接。返回一个对应的socket
        Socket accept = serverSocket.accept();
        //开始接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        //把数据写入到文本文件
        //如果没有这个文件，那么就创建一个
        BufferedWriter bw = new BufferedWriter(new FileWriter("src\\copy.owl"));

        String line;    //等待读取数据
        while((line = br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //给出反馈
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
        bwServer.write("文件上传成功");
        bwServer.newLine();
        bwServer.flush();

        //释放资源
        bw.close();//关闭写文件流
        serverSocket.close();//关闭服务器套接字流
    }
}

在这里插入图片描述

练习6

客户端：数据来自文本文件，接收服务器反馈
服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程

客户端：

package com.itheima_10;

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

/*
    客户端：数据来自于文本文件，接收服务器反馈
 */

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

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

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

        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);

        //释放资源
        br.close();
        s.close();
    }
}

服务器端：

package com.itheima_10;

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

/*
    服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //监听客户端连接，返回一个对应的Socket对象
            Socket s = ss.accept();
            //为每一个客户端开启一个线程
            new Thread(new ServerThread(s)).start();
        }

//        ss.close();
    }
}

多线程

package com.itheima_10;

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

public class ServerThread implements Runnable {
    private Socket s;
    
    public ServerThread(Socket s) {
        this.s = s;
    }
    
    @Override
    public void run() {
        try {
            //接收数据写到文本文件
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//            BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));
            //解决名称冲突问题
            int count = 0;
            File file = new File("myNet\\Copy["+count+"].java");
            while (file.exists()) {
                count++;
                file = new File("myNet\\Copy["+count+"].java");
            }
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));

            String line;
            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.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}