程序员社区

Java中Socket实现TCP/IP协议的通信

TCP/IP(Transmission Control Protocol/Internet Protocol)即传输控制协议/网间协议,是一个工业标准的协议集,它是为广域网(WANs)设计的。
Java中的网络支持
针对网络通信的不同层次,Java提供了不同的API,其提供的网络功能有四大类:
①InetAddress:用于标识网络上的硬件资源,主要是IP地址
②URL:统一资源定位符,通过URL可以直接读取或写入网络上的数据
③Sockets:使用TCP协议实现的网络通信Socket相关的类
④Datagram:使用UDP协议,将数据保存在用户数据报中,通过网络进行通信。

TCP编程:

TCP协议是面向连接的、可靠的、有序的、以字节流的方式发送数据,通过三次握手方式建立连接,形成传输数据的通道,在连接中进行大量数据的传输

Java中基于TCP协议实现网络通信的类有客户端的Socket类和服务器端的ServerSocket类
Java中Socket实现TCP/IP协议的通信插图
740688-20150907234728090-211300057.jpg
socket实现通信包括服务端和客户端

服务器端:
① 创建ServerSocket对象,绑定监听端口,端口一般选择1024-65535的某个端口
② 通过accept()方法监听客户端请求
③ 连接建立后,通过输入流读取客户端发送的请求信息
④ 通过输出流向客户端发送相应信息
⑤ 关闭相关资源

public class server {
    public static void main(String[] args){
        try {
            //1.创建一个serverSocket,绑定监听端口
            ServerSocket serverSocket=new ServerSocket(8888);
            //2.调用accept()方法开始监听,等待客户端连接
            System.out.println("服务器即将启动 等待客户端连接");
            Socket socket=serverSocket.accept();
            //3.获取输入流,用来读取客户端发送的信息
            InputStream  is=socket.getInputStream();//字节输入流;
            InputStreamReader isr=new InputStreamReader(is);//将字节输入流转换为字符输入流
            BufferedReader br=new BufferedReader(isr);//为输入流添加缓冲
            //循环读取客户端提交的信息
            String info=null;
            while ((info=br.readLine())!=null){//循环读取
                System.out.println("我是服务器,客户端说:"+info);
                info=br.readLine();
            }
            //关闭输入流,防止造成阻塞
            socket.shutdownInput();
            //服务器向客户端进行响应
            //获取输出流,响应客户端的请求
            OutputStream os=socket.getOutputStream();
            PrintWriter pw=new PrintWriter(os);//包装为打印流
            pw.write("欢迎您!");
            pw.flush();//调用flush()方法刷新缓冲输出
            //关闭资源
            pw.close();
            os.close();
            br.close();
            isr.close();
            is.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端:
① 创建Socket对象,指明需要连接的服务器的地址和端口号
② 连接建立后,通过输出流向服务器端发送请求信息
③ 通过输入流获取服务器响应的信息
④ 关闭相关资源

public class client {
    public static void main(String[] args) {
        try {
            //1.创建客户端Socket,指定服务器地址和端口
            Socket socket=new Socket("localhost", 8888);
            //2.获取输出流,向服务器端发送信息
            OutputStream os=socket.getOutputStream();//字节输出流
            PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名:jinbin;密码:1997");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //3.获取输入流,并读取服务器端的响应信息
            InputStream is=socket.getInputStream();
            //字节流包装为字符流
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String info=null;
            while((info=br.readLine())!=null){
                System.out.println("我是客户端,服务器说:"+info);
            }
            //4.关闭资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

下面我们来测试一下,需要先启动服务器端再启动客户端
启动完服务器端会显示

Java中Socket实现TCP/IP协议的通信插图1
image.png

下面来启动客户端
启动完后客户端控制台会出现

Java中Socket实现TCP/IP协议的通信插图2
image.png

再来看看服务器端的控制台信息

Java中Socket实现TCP/IP协议的通信插图3
image.png

这样看来服务端和客户端都收到了信息,实现了通信

上面只是实现了服务端对应一个客户端的效果,下面来实现服务端对应多个客户端,通过多线程来实现

应用多线程实现服务器与多客户端之间的通信
① 服务器端创建ServerSocket,循环调用accept()等待客户端连接
② 客户端创建一个socket并请求和服务器端连接
③ 服务器端接收客户端请求,创建socket与该客户建立专线连接
④ 建立连接的两个socket在一个单独的线程上对话
⑤ 服务器端继续等待新的连接

服务器端线程处理类

public class serverThread extends Thread{
    // 和本线程相关的Socket
    Socket socket = null;

    public serverThread(Socket socket) {
        this.socket = socket;
    }

    //线程执行的操作,响应客户端的请求
    @Override
    public void run(){
        InputStream is=null;
        InputStreamReader isr=null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        try {
            //获取输入流,并读取客户端信息
            is = socket.getInputStream();
            isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            String info=null;
            while((info=br.readLine())!=null){//循环读取客户端的信息
                System.out.println("我是服务器,客户端说:"+info);
            }
            socket.shutdownInput();//关闭输入流
            //获取输出流,响应客户端的请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("欢迎您!");
            pw.flush();//调用flush()方法将缓冲输出
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //关闭资源
            try {
                if(pw!=null) {
                    pw.close();
                }
                if(os!=null) {
                    os.close();
                }
                if(br!=null) {
                    br.close();
                }
                if(isr!=null) {
                    isr.close();
                }
                if(is!=null) {
                    is.close();
                }
                if(socket!=null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

关闭资源为何要加一个判断条件:不为空 ???
这是一种正确、严谨的写法。
验证非NULL是编码中很重要的一环。假如本来就是NULL,这是调用各自的close()方法是会报错的。
如果在实例化这些对象时出错导致这些对象为NULL,或是实例化没问题但中途出了什么异常导致这些对象为NULL,都会在未经验证非NULL前尝试调用close()方法关闭时报错。

在服务器端需要进行循环的监听

public class server {
    public static void main(String[] args){
        try {
            //1.创建一个服务器端Socket,即ServerSocket,指定绑定的端口,并监听此端口
            ServerSocket serverSocket=new ServerSocket(8888);
            Socket socket=null;
            //记录客户端的数量
            int count=0;
            System.out.println("***服务器即将启动,等待客户端的连接***");
            //循环监听等待客户端的连接
            while(true){
                //调用accept()方法开始监听,等待客户端的连接
                socket=serverSocket.accept();
                //创建一个新的线程
                serverThread serverThread=new serverThread(socket);
                //启动线程
                serverThread.start();
                count++;//统计客户端的数量
                System.out.println("客户端的数量:"+count);
                InetAddress address=socket.getInetAddress();
                System.out.println("当前客户端的IP:"+address.getHostAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码不用改
下面来测试一下
启动服务端,显示和之前的一样

Java中Socket实现TCP/IP协议的通信插图4
image.png

下面启动一个客户端
客户端收到的回复一样

Java中Socket实现TCP/IP协议的通信插图5
image.png

看下服务端
这里服务端并没有立刻关闭,在等待监听下一个

Java中Socket实现TCP/IP协议的通信插图6
image.png

下面我改一下客户端socket的发送信息

Java中Socket实现TCP/IP协议的通信插图7
image.png

再启动一次
在服务端的控制台可以看到客户端数量是2,由于sockethost我依然是写localhost,所以IP依然是127.0.0.1

Java中Socket实现TCP/IP协议的通信插图8
image.png

客户端的监听端口号不能随便改,不然服务端就监听不到了

赞(0) 打赏
未经允许不得转载:IDEA激活码 » Java中Socket实现TCP/IP协议的通信

相关推荐

  • 暂无文章

一个分享Java & Python知识的社区