java网络编程（socket（Tcp小Dome））

Posted 2021-08-15 HUTEROX

目录

• • Java流
  • socket定义
  • Java socket的使用
  • 客户端
  • 多客户端请求处理

Java流

在进行网络编程之前，我们一定要搞清楚，流这玩意对于Java来说是多么重要。我们可以通过流来完成文件的存储，读取，同时也通过流来对网络数据进行传输。在Java当中没有指针的概念，我们知道在C语言当中它把所以的抽象的概念例如屏幕，键盘都看作了文件，对应就是指针（例如屏幕stdout标准输出，stdin标准输入）那么在Java当中流也充当了类似指针的作业。

socket定义

何为socket，这玩意其实就我们的网络驱动程序开放的接口，我们通过它来完成我们网络的连接数据的发生。当然在不同的计算机语言当中其具体的操作有细微的区别，例如在Java当中我们可以直接使用字符流来进行中文的直接传输，但是在python当中在传输时都必须先将数据转换为bytes，之后在对其进行解码。
一,Java

二,python

    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    id = socket.gethostbyname(socket.gethostname()).split(":")[0]
    s.connect((id,8089))
    s.send('你好！'.encode('utf8'))
    print("数据发送完成")
    tes=s.recv(1024)
    print(tes.decode('utf8'))
    s.close()

Java socket的使用

socket的流程图
一.发送数据的过程

二.接受数据的过程

Java中socket需要使用到的基本方法

我们在这里需要先了解到三个方法

1. getInputStream()这玩意可以得到在网络当中传输的数据流（发送至当前设备的数据，这个时直接在网卡那边获取的）

2. getOutputStream()这玩意是用来发送的流，将你想要发送的数据发送出去

3. accept()这玩意是服务端进行接听是否有数据传入的，是否有连接，返回类型为socket

此外在客户端使用的是socket在服务端使用的是servicesocket

服务端代码
这里的话方便做参考就写两个吧，一个是Java的一个是python的
一java

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


public class EchoServiceDome {

public static void main(String[] args) {
    try {

        ServerSocket server = new ServerSocket(6666);
        System.out.println("服务器已启动正在等待客户端连接");
        Socket socket = server.accept();//和python一样时阻塞的 
        System.out.println("客户端连接成功:"+server.getInetAddress().getHostAddress());
        //socke.getInputStream()通过流进行数据传递所以我们那啥可以用这个获取接受
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        //读取那个网络的数据
        String info = br.readLine();
        System.out.println(info);

        //写入数据，返回给客户端
        PrintStream ps = new PrintStream(new BufferedOutputStream(socket.getOutputStream()));
        ps.println("echo:"+info);
        ps.flush();
        ps.close();
        br.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}
}

二python

    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    id = socket.gethostbyname(socket.gethostname()).split(":")[0]
    s.connect((id,8089))
    s.send('hello'.encode('utf8'))
    print("数据发送完成")
    tes=s.recv(1024)
    print(tes.decode('utf8'))
    s.close()

客户端

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class EchoClientDome {
    public static void main(String[] args) {
        
        //我们时直接通过字符流来传输的，所以不用和python一样那个是统一转换为了bytes之后我们在解码
        //主要是有用python做了很多封装本质上也是类似的
        try {
            //连接服务器
            Socket  socket = new Socket("localhost",6666);
            PrintStream ps = new PrintStream(new BufferedOutputStream(socket.getOutputStream()));//发送给服务器
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));//接手服务器的反馈

            ps.println("你好");
            ps.flush();
            //读取,在服务器未发送数据前会处于堵塞状态，也就是会等待服务器相应。
            String info = br.readLine();
            System.out.println(info);
            ps.close();
            br.close();

        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

二python

    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    id = socket.gethostbyname(socket.gethostname()).split(":")[0]
    s.bind((id,8089))
    print("TCP服务器开启")
    s.listen(128)
    data,ip_where=s.accept()
    print(data.recv(1024).decode('utf8'))
    data.send('world'.encode('utf8'))

多客户端请求处理

具体的流程如下图

代码如下：

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class MutilateServiceDome {
    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(4);
        try {
            ServerSocket server = new ServerSocket(6666);
            System.out.println("服务器已开启......");
            while(true){
                Socket s = server.accept();
                System.out.println("Host:"+s.getInetAddress().getHostAddress()+"请求访问!");
                es.execute(new UserDoThread(s));
            }

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}

class UserDoThread implements Runnable{
    private Socket s;
    private BufferedReader br;
    private PrintStream ps;
    public UserDoThread(Socket s){
        this.s = s;
    }
    public void run(){
        try {
            br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            ps = new PrintStream(new BufferedOutputStream(s.getOutputStream()));
            String info = br.readLine();
            System.out.println(info+"---来自:"+s.getInetAddress().getHostAddress());
            ps.println("echo:"+info);
            ps.flush();
            ps.close();
            br.close();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            ps.flush();
            ps.close();
            try {
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }
}