JAVA网络编程写TCP多线程聊天室

package 网络编程.TCP数据;

import jdk.nashorn.internal.runtime.Scope;

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

public class TCP接收端 {
    /*
        A.创建接收端的sock对象
        B.监听客户端，返回一个对应的Socket对象
        C.获取输入流显示数据到控制台
        D.释放资源
     */
    public static void main(String[] args) throws IOException {
        //创建接收端的sock对象
        ServerSocket ss =new ServerSocket(8888);
        //监听客户端返回一个对应的sock对象
        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);
        System.out.println(str);
        System.out.println(str);
        ss.close();
        s.close();
    }
}

package 网络编程.TCP数据;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/*
    TCP协议发送数据
    A:创建发送端的Socke对象
        这一步如果成功表示链接建立成功
    B：获取输出流，写数据
    C：释放资源

 */
public class TCP发送 {
    public static void main(String[] args) throws IOException {
        //创建发送端对象
        Socket sc= new Socket("127.0.0.1",8888);
        //获取输出流写数据
        OutputStream os =sc.getOutputStream();
        os.write("hallotcp".getBytes());
        //释放资源
        sc.close();


    }
}

添加一个信息反馈也就是链接成功后的返回信息

 public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket s =new ServerSocket(8888);
        //监听客户端链接
        Socket sc = s.accept();
        //获取输入流
        InputStream in = sc.getInputStream();
        byte[] bys =new byte[1024];
            int len= in.read(bys);
        String str =new String(bys,0,len);
        System.out.println(str);
        //获取输出流
        OutputStream out =sc.getOutputStream();
        out.write("收到了".getBytes());
        sc.close();
    }

 public static void main(String[] args) throws IOException {
        //创建一个Socket对象
        Socket s = new Socket("127.0.0.1",8888);
        //获取输出流
        OutputStream out = s.getOutputStream();
        out.write("hhh".getBytes());
        //获取输入流
        InputStream in =s.getInputStream();
        byte [] bys= new byte[1024];
        int len =in.read(bys);
        String str =new String(bys,0,len);
        System.out.println(str);
        s.close();

    }

使用包装优化添加输入输出
服务器端

package 网络编程.TCP数据.键盘录入;

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

public class Server {
    public static void main(String[] args) throws IOException {
        //创建服务sock
        ServerSocket ser =new ServerSocket(8888);
        //获取接收字节对象

            Socket soc= ser.accept();
            //接收获得的数据
            BufferedReader bf =new BufferedReader(new InputStreamReader(soc.getInputStream()));
            String str =null;
            while ((str=bf.readLine())!=null){
                System.out.println(str);
            }

                soc.close();


    }
}

客户端

package 网络编程.TCP数据.键盘录入;

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

public class 客户端 {
    public static void main(String[] args) throws IOException {
        Scanner scan =new Scanner(System.in);
        //获取sockey对象
        Socket sockey =new Socket("127.0.0.1",8888);
        //将输出的字符流变为字节流进行包装自动换行
        BufferedWriter br =new BufferedWriter(new OutputStreamWriter(sockey.getOutputStream()));
        //把输入的字节流解码成字符流
        BufferedReader bs =new BufferedReader(new InputStreamReader(System.in));

        String str =null;
        while ((str=bs.readLine())!=null){

            br.write(str);
            br.newLine();
            br.flush();//刷新缓冲区
        }
        br.close();
        sockey.close();

    }
}

多线程TCP优化

package 网络编程.TCP数据.多线程优化代码;

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

public class Maindemo {
    public static void main(String[] args) throws IOException {
        //创建服务端口
        ServerSocket ser =new ServerSocket(9999);
        //创建客户端的对象
        Socket soc =new Socket("127.0.0.1",9999);
        Server server =new Server(ser);
        KEHUDUAN kehuduan =new KEHUDUAN(soc);
        Thread thrser = new Thread(server);
        Thread thrkehuduan = new Thread(kehuduan);
        thrser.start();
        thrkehuduan.start();

    }
}

客户端

package 网络编程.TCP数据.多线程优化代码;

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

public class KEHUDUAN implements Runnable{
    private Socket s;
    public KEHUDUAN (Socket s){
        this.s=s;
    }
    @Override
    public void run() {
        try {
//把输入内容通过转换到字节流
        BufferedReader bf =new BufferedReader(new InputStreamReader(System.in));
//把内容写到服务端
            BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            String line =null;
            while ((line=bf.readLine())!=null){
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }


    }
}

服务端

package 网络编程.TCP数据.多线程优化代码;

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

public class Server implements Runnable{

    private ServerSocket ser;
    public Server(ServerSocket ser){

        this.ser=ser;
    }


    @Override
    public void run() {
        //创建服务sock
        Socket s=null;


        try {


        //获取接收字节对象

          s= ser.accept();
        //接收获得的数据
        BufferedReader bf =new BufferedReader(new InputStreamReader(s.getInputStream()));
        String str =null;
        while ((str=bf.readLine())!=null){
            System.out.println(str);
        }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                ser.close();
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}