java socket网络通信

1.客户端给服务器发送1句话

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class ClientSocket1 {
    public static void main(String[] args) throws IOException, InterruptedException {
        Socket socket = new Socket("127.0.0.1", 9999);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("hello word");
        bw.newLine();
        bw.flush();
    }
}



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

/**
 * 客户端给服务端发送1条数据
 */
public class ServerScoket1 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        while (true){
            String s = br.readLine();
            System.out.println(s);
        }
    }
}

2.客户端给服务器发送n句话

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Scanner;

public class ClientSocket2 {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 9999);
        //创建字符输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        Scanner scanner = new Scanner(System.in);
        //循环往服务器写数据
        String str;
        while (!(str=scanner.nextLine()).equalsIgnoreCase("close")){
            bw.write(str);
            bw.newLine();//必须加上换行，这样服务器就能读出一行数据
            bw.flush();
        }
        //释放资源
        bw.close();
        socket.close();

    }
}



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

/**
 * 客户端给服务端发送无限多数据
 * 当客户端输入close（不区分大小写）时，通信结束
 */
public class ServerSocket2 {
    public static void main(String[] args) throws IOException {
        //获取客户端连接
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
        //创建字符输入流，
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        //循环读数据
        String str ;
        while ((str = br.readLine())!=null){
            System.out.println(str);
        }
        //关流
        br.close();
        socket.close();
    }
}

3.服务器和1个客户端相互发送数据

package com.itheima.test;

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

public class ClientSocket3 {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        //创建客户端socket
        Socket socket = new Socket("127.0.0.1", 9999);
        //接收数据的方法
        Runnable myRunReceive = new Runnable() {
            @Override
            public void run() {
                try {
                    BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    String str;
                    //这个地方等待服务端关闭发送数据流，关闭之后就跳出循环
                    while ((str=br.readLine())!=null){
                        System.out.println(str);
                    }
                    //关流
                    br.close();
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        //发送数据的方法
        Runnable myRunSend = new Runnable() {
            @Override
            public void run() {
                //创建字符输出流
                try {
                    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                    //发送数据，当输入close时，结束
                    String str=null;
                    while (!(str=scanner.nextLine()).equalsIgnoreCase("close")){
                        bw.write(str);
                        bw.newLine();
                        bw.flush();
                    }
                    //跳出循环时，关流
                    bw.close();
                    socket.close();
                } catch (Exception e) {

                }
            }
        };

        //开启1个线程执行接收数据
        new Thread(myRunReceive).start();
        //开启1个线程执行发送数据
        new Thread(myRunSend).start();

    }
}





package com.itheima.test;

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

/**
 * 客户端，服务端双方相互通信，有1方输入close，结束通信
 */
public class ServerSocket3 {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        //等待客户端
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
        //向客户端发送数据方法
        Runnable myRunSend = new Runnable() {
            @Override
            public void run() {
                //创建字符输出流
                try {
                    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                    //发送数据，当输入close时，结束
                    String str=null;
                    while (!(str=scanner.nextLine()).equalsIgnoreCase("close")){
                        bw.write(str);
                        bw.newLine();
                        bw.flush();
                    }
                    //跳出循环时，关流
                    bw.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        };

        //从客户端接收数据方法
        Runnable myRunReceive = new Runnable() {
            @Override
            public void run() {
                try {
                    BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    String str;
                    //这个地方等待客户端关闭发送数据流，关闭之后就跳出循环
                    while ((str=br.readLine())!=null){
                        System.out.println("客户端："+str);
                    }
                    //关流
                    br.close();
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        //开启线程发送数据
        new Thread(myRunSend).start();
        //开启线程 ，接收数据
        new Thread(myRunReceive).start();
    }
}

4.服务器和多个客户端收发数据，客户端还用上面的ClientSocket3

package com.itheima.test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 服务器可以接收多个客户端
 * 客户端，服务端双方相互通信，有1方输入close，结束通信
 */
public class ServerSocket4 {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        //
        ServerSocket serverSocket = new ServerSocket(9999);
        //创建线程池
        ExecutorService executorPool = Executors.newCachedThreadPool();
        ArrayList<Socket> sockets = new ArrayList<>();

        Runnable myRunSend = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程开启");
                try {
                    while(true){
                        String str = scanner.nextLine();//这里要等以下，因为是多线程，如果sockets里没内容，这个线程直接结束了，所以这个地方卡在输入这
                        for (Socket socket : sockets) {
                            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                            //这个是给所有客户端发个小说
                            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("/Users/liudawei/Documents/develop/javaweb/day19_project/src/com/itheima/test/aa.txt")));
                            String str3 = null;
                            while ((str3=br.readLine())!=null){
                                bw.write(str3);
                                bw.newLine();
                                bw.flush();
                            }
//                             这个是发送一行短的语句
//                            bw.write("服务器："+str);
//                            bw.newLine();
//                            bw.flush();
                        }
                    }

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

        executorPool.execute(myRunSend);


        //接收客户端数据
        while (true) {
            Socket socket = serverSocket.accept();
            sockets.add(socket);
            //从客户端接收数据方法
            Runnable myRunReceive = new Runnable() {
                @Override
                public void run() {
                    try {
                        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        String str;
                        //这个地方等待客户端关闭发送数据流，关闭之后就跳出循环
                        while ((str = br.readLine()) != null) {
                            String str1 = "客户端" + Thread.currentThread().getName() + "：" + str;
                            System.out.println(str1);
                            //这里向每一个客户端发送数据，包括自己
                            for (Socket socket1 : sockets) {
                                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket1.getOutputStream()));
                                bw.write(str1);
                                bw.newLine();
                                bw.flush();
                            }
                        }
                        //关流
                        br.close();
                        sockets.remove(socket);
                        Thread.sleep(2000);
                        socket.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            executorPool.execute(myRunReceive);
        }

    }
}

涉及到多线程，没有用线程同步，也可以实现需求