Java Socket的几种通信示例(TCP)

最新推荐文章于 2024-04-22 19:08:57 发布
最新推荐文章于 2024-04-22 19:08:57 发布
阅读量452 收藏 1
点赞数
分类专栏： Socket 文章标签： socket java tcpip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smith789/article/details/104340350
版权

在这里插入图片描述

示例1：多客户端

功能介绍

可以运行多个client，client连接，Server打印连接信息。
client控制台发送消息给Server，Server打印收到的消息，并回送收到的消息长度。
client发送bye，断开连接。
运行效果：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

Server源码

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 Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(2000);
        System.out.println("服务器准备就绪～");
        System.out.println("服务器信息：" + server.getInetAddress() + " P:" + server.getLocalPort());
        // 等待客户端连接
        while(true) {
            // 得到客户端
            Socket client = server.accept();
            // 客户端构建异步线程
            ClientHandler clientHandler = new ClientHandler(client);
            // 启动线程
            clientHandler.start();
        }
    }

    /**
     * 客户端消息处理
     */
    private static class ClientHandler extends Thread {
        private Socket socket;
        private boolean flag = true;

        ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            super.run();
            System.out.println("新客户端连接：" + socket.getInetAddress() + " P:" + socket.getPort());
            try {
                // 得到打印流，用于数据输出；服务器回送数据使用
                PrintStream socketOutput = new PrintStream(socket.getOutputStream());
                // 得到输入流，用于接收数据
                BufferedReader socketInput = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                while(flag){
                    // 客户端拿到一条数据
                    String str = socketInput.readLine();
                    if ("bye".equalsIgnoreCase(str)) {
                        flag = false;
                        // 回送
                        socketOutput.println("bye");
                    } else {
                        // 打印到屏幕。并回送数据长度
                        System.out.println(str);
                        socketOutput.println("回送：" + str.length());
                    }
                }
                socketInput.close();
                socketOutput.close();
            } catch (Exception e) {
                System.out.println("连接异常断开");
            } finally {
                // 连接关闭
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("客户端已退出：" + socket.getInetAddress() + " P:" + socket.getPort());
        }
    }
}

Client源码

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

public class Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket();
        // 超时时间
        socket.setSoTimeout(3000);
        // 连接本地，端口2000；超时时间3000ms
        socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), 2000), 3000);
        System.out.println("已发起服务器连接，并进入后续流程～");
        System.out.println("客户端信息：" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
        System.out.println("服务器信息：" + socket.getInetAddress() + " P:" + socket.getPort());
        try {
            todo(socket);
        } catch (Exception e) {
            System.out.println("异常关闭");
        }
        socket.close();
        System.out.println("客户端已退出～");
    }

    private static void todo(Socket client) throws IOException {
        // 构建键盘输入流
        InputStream in = System.in;
        BufferedReader input = new BufferedReader(new InputStreamReader(in));

        // 得到Socket输出流，并转换为打印流
        OutputStream outputStream = client.getOutputStream();
        PrintStream socketPrintStream = new PrintStream(outputStream);

        // 得到Socket输入流，并转换为BufferedReader
        InputStream inputStream = client.getInputStream();
        BufferedReader socketBufferedReader = new BufferedReader(new InputStreamReader(inputStream));

        boolean flag = true;
        while(flag){
            // 键盘读取一行
            String str = input.readLine();
            // 发送到服务器
            socketPrintStream.println(str);
            // 从服务器读取一行
            String echo = socketBufferedReader.readLine();
            if ("bye".equalsIgnoreCase(echo)) {
                flag = false;
            }else {
                System.out.println(echo);
            }
        }
        socketPrintStream.close();
        socketBufferedReader.close();
    }
}

示例2：回显服务器

功能：Client发送什么消息给Server，Server回送什么消息。不支持多client

EchoServer源码

public class EchoServer {
    private int port = 8000;
    private ServerSocket serverSocket;

    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        System.out.println("服务器启动");
    }

    public String echo(String msg) {
        return "echo:" + msg;
    }

  /**
   * 用PrintWriter包裝OutputStream，能够写一行数据
   * @param socket
   * @return
   * @throws IOException
   */
    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream socketOut = socket.getOutputStream();
        return new PrintWriter(socketOut, true);
    }

  /**
   * BufferedReader包装InputStream，能够读一行数据
   * @param socket
   * @return
   * @throws IOException
   */
    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream socketIn = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn));
    }

    public void service() {
        while (true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();  //等待客户连接
                System.out.println("New connection accepted " + socket.getInetAddress() + ":" + socket.getPort());
                BufferedReader br = getReader(socket);
                PrintWriter pw = getWriter(socket);

                String msg = null;
                while ((msg = br.readLine()) != null) {
                    System.out.println(msg);
                    pw.println(echo(msg));
                    if (msg.equals("bye")) //如果客户发送的消息为“bye”，就结束通信
                        break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (socket != null) socket.close();  //断开连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String args[]) throws IOException {
        new EchoServer().service();
    }
}

EchoClient源码

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

public class EchoClient {
    private String host = "localhost";
    private int port = 8000;
    private Socket socket;

    public EchoClient() throws IOException {
        socket = new Socket(host, port);
    }

    public static void main(String args[]) throws IOException {
        new EchoClient().talk();
    }

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream socketOut = socket.getOutputStream();
        return new PrintWriter(socketOut, true);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream socketIn = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn));
    }

    public void talk() throws IOException {
        try {
            BufferedReader br = getReader(socket);
            PrintWriter pw = getWriter(socket);
            BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
            String msg = null;
            while ((msg = localReader.readLine()) != null) {

                pw.println(msg);
                System.out.println(br.readLine());

                if (msg.equals("bye"))
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

示例3：多线程版本

功能

给每一个进来的Client建立一个线程

public class EchoServer {
    private int port = 8000;
    private ServerSocket serverSocket;

    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        System.out.println("服务器启动");
    }

    public void service() {
        while (true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();  //接收客户连接
                Thread workThread = new Thread(new Handler(socket));  //创建一个工作线程
                workThread.start();  //启动工作线程
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String args[]) throws IOException {
        new EchoServer().service();
    }
}

class Handler implements Runnable {
    private Socket socket;

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

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream socketOut = socket.getOutputStream();
        return new PrintWriter(socketOut, true);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream socketIn = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn));
    }

    public String echo(String msg) {
        return "echo:" + msg;
    }

    public void run() {
        try {
            System.out.println("New connection accepted " +
                    socket.getInetAddress() + ":" + socket.getPort());
            BufferedReader br = getReader(socket);
            PrintWriter pw = getWriter(socket);

            String msg = null;
            while ((msg = br.readLine()) != null) {
                System.out.println(msg);
                pw.println(echo(msg));
                if (msg.equals("bye"))
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (socket != null) socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class EchoClient {
    private String host = "localhost";
    private int port = 8000;
    private Socket socket;

    public EchoClient() throws IOException {
        socket = new Socket(host, port);
    }

    public static void main(String args[]) throws IOException {
        new EchoClient().talk();
    }

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream socketOut = socket.getOutputStream();
        return new PrintWriter(socketOut, true);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream socketIn = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn));
    }

    public void talk() throws IOException {
        try {
            BufferedReader br = getReader(socket);
            PrintWriter pw = getWriter(socket);
            BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
            String msg = null;
            while ((msg = localReader.readLine()) != null) {

                pw.println(msg);
                System.out.println(br.readLine());

                if (msg.equals("bye"))
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

示例4：线程池版本

Client同上。
Server如下：

import java.io.*;
import java.net.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EchoServer {
    private int port = 8000;
    private ServerSocket serverSocket;
    private final int POOL_SIZE = 4;  //单个CPU时线程池中工作线程的数目
    ExecutorService executorService;
    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        //创建线程池
        //Runtime的availableProcessors()方法返回当前系统的CPU的数目
        //系统的CPU越多，线程池中工作线程的数目也越多
        executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
        System.out.println("服务器启动");
    }

    public void service() {
        while (true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();
                executorService.execute(new Handler(socket)); //把与客户通信的任务交给线程池
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String args[]) throws IOException {
        new EchoServer().service();
    }
}

class Handler implements Runnable {
    private Socket socket;

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

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream socketOut = socket.getOutputStream();
        return new PrintWriter(socketOut, true);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream socketIn = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn));
    }

    public String echo(String msg) {
        return "echo:" + msg;
    }

    public void run() {
        try {
            System.out.println("New connection accepted " +
                    socket.getInetAddress() + ":" + socket.getPort());
            BufferedReader br = getReader(socket);
            PrintWriter pw = getWriter(socket);

            String msg = null;
            while ((msg = br.readLine()) != null) {
                System.out.println(msg);
                pw.println(echo(msg));
                if (msg.equals("bye"))
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (socket != null) socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
smith789
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Socket通信之TCP协议
可能是一只知更鸟
03-19 4347
java流套接字通信模型 TCP流套接字编程 两个例子（回显服务器/查字典服务器） TCP中的长短连接 短连接 长连接 协议 为什么需要协议？ 封装/分用 VS 序列化/反序列化 自定义协议
Java Socket实用样例
BHSZZY的博客
01-10 3982
一、前言 最近用到了Java的Socket通信。 在搜索用法的过程中，发现好多都是用System.in举例的； 但是实际工作中，并不是用System.in从控制台输入消息的，不太好用。 以下是个人从工作中总结的Socket实用代码样例。 二、服务器端（ServerSocket） 服务器端等待Socket连接的建立，接收Socket请求报文，处理后给Socket客户端返回响应报文。 1.SocketThread类，主要处理类，用来接收Socket请求报文、处理、返回响应报文。 @Slf4j public cl
Java-Socket(案例)
BASK2312的博客
06-27 454
套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。通信的两端都要有Socket,是两台机器间通信的端点网络通信其实就是Socket间的通信。Socket允许程序把网络连接当成一个流，数据在两个Socketl间通过IO传输。一般主动发起通信的应用程序属客户端，等待通信请求的为服务端基于客户端一服务端的网络通信底层使用的是TCP/IP协议应用场景举例：客户端发送数据，服务端接受并显示控制台基于Socket的TCP编程。
【Java网络编程】TCP通信（Socket 与 ServerSocket）和UDP通信的三种数据传输方式
最新发布
m0_65277261的博客
04-22 1378
TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象 通信之前要保证连接已经建立（注意TCP是一定要建立连接的） TCP是通过Socket产生I0流来进行网络通信的，所以发送端和接收端的两个流的方向是不一样的，比如客户端和服务器进行通信（通信前要确保建立了连接），然后客户端向服务器发送了“你好帅”，这一次发送数据的过程，它们流的方向是不一样的，针对客户端来说，它是往外发所以用的是输出流，而针对服务器来说，它是接收数据所以用的是输入流。
全网最全的Java Socket通讯例子
Kelly
08-22 4929
前言 网上关于Java的比较完整的Socket编程例子屈指可数，参考价值不大。要么是短连接且只支持纯文本通讯；要么是短连接且只支持文件通讯；要么是基于多个短连接的文本和文件通讯；前面这些基本是单向通讯的例子，而且长连接的例子很少。当然也有比较著名的socket框架，如Netty。但这些框架高度封装，对于入门和理解Socket基础编程，未免显得吃力。本文介绍Java Socket原始通讯例子，全双工通讯，客户端和服务端互发消息，支持文本和大文件通讯，可基于例子理想可自由扩展。 ...
socket实例java_Java 网络编程之socket实例
weixin_39914825的博客
02-22 85
Java中的网络通信是通过Socket来实现的，socket分为ServerSocket和Socket两大类，ServerSocket用于服务端，可以通过accept方法监听请求，监听到请求返回Socket，Socket用于用于完成数据传输，客户端使用Socket发起请求并传输数据。1.ServerSocket简单示例import java.io.BufferedReader;import jav...
Java网络编程（三）Socket通信代码示例
琅琊之榜
08-04 789
Java是一种功能强大的编程语言，它提供了丰富的网络编程功能，使得我们可以轻松地创建网络应用程序。其中，Socket是Java网络编程的核心组件之一，它允许我们在不同的计算机之间建立通信连接。本文将介绍如何使用Java的Socket类进行基本的网络通信。首先，我们需要了解Socket的基本概念。Socket是一种抽象的网络通信端点，它可以用于建立客户端和服务器之间的连接。在Java中，我们可以使用java.net包中的Socket类来创建和管理Socket对象。
Java Socket 聊天通信演示代码
06-06
Java Socket 是一种基于TCP/IP协议族的网络编程接口，它允许Java程序在两台计算机之间建立可靠的、双向的通信连接。在这个"Java Socket 聊天通信演示代码"中，我们将探讨如何使用Java Socket实现一个简单的聊天应用...
基于Java的实例源码-Java Socket通信实现.zip
06-27
本实例源码提供了关于如何使用Java Socket进行通信的具体示例，帮助开发者理解和实践相关技术。 首先，我们来理解Socket的基本原理。Socket是TCP/IP协议族的一部分，它为应用程序提供了一个低级别的接口，允许它们...
java实现Socket通信之单线程服务
08-27
Java中的Socket通信是一种基于TCP协议的网络通信方式，它允许两个网络应用进行全双工（双向）通信。在Java中，Socket和ServerSocket是实现TCP通信的核心类，它们位于java.net包下。本文将深入探讨如何使用Java实现单...
Java--Socket通信（客户端服务端双向）
08-31
总结来说，Java中的Socket通信提供了一种可靠的、面向连接的通信方式，适用于客户端和服务器之间的双向交互。通过创建和管理多个线程，我们可以同时进行读取和写入操作，实现高效的数据交换。在实际应用中，可能还...
Android TCP Socket通信封装
03-14
在Android开发中，TCP Socket通信是移动应用与服务器进行数据交互的一种常见方式。TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，确保了数据的顺序传输和数据完整性...
【Socket（套接字）】Java Socket通信示例
qq_47450919的博客
09-16 159
Socket是计算机网络通信的基础，通过IP地址和端口号的组合，它能够确保数据在计算机之间的准确传递，就像电话一样。在互联网上，这个机制被广泛用于不同应用之间的数据交换，从网页浏览到电子邮件，再到在线游戏，Socket都发挥着关键作用。你可以说话，朋友可以听到，朋友也可以回应你，你可以听到朋友的回应。在计算机网络中，Socket就像这部手机和电话线一样，它提供了一种标准的方式，让计算机之间可以建立连接、发送数据和关闭连接。在Socket中，当通信完成后，可以关闭Socket连接，释放资源。
Java Socket几个简单的入门示例
杂七杂八
10-18 4774
Socket是面向网络传输层的编程接口，需要程序员直面网络连接，字节流的读写，数据包的解析等。其难点在于服务端的迸发性能处理、数据格式的定义与拆解，在程序底层的算法上会有一定要求，更加考验程序员的编程技巧。
java socket通讯实例_Java基于TCP的socket通讯案例
weixin_35935249的博客
02-13 155
java中的socket编程案例，一个是服务端，一个是客户端，运行时先启动服务端，再启动客户端。//客户端packagecom.socket;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStream;importjava.io.InputStreamReader;importjava...
使用socket实现信息回显，客户端可以发送从控制台输入的信息，服务器端在接收到信息后，使用服务器端信息标识“Server received msg：”与接收到的信息组合，发送回客户端
qq_41119203的博客
12-01 1159
使用socket实现信息回显，客户端可以发送从控制台输入的信息，服务器端在接收到信息后，使用服务器端信息标识“Server received msg：”与接收到的信息组合，发送回客户端。如：客户端发送消息“Hello”,则服务器端发送回消息“Server received msg：Hello”（10分） 服务器类： public class Server { public stati...
Socket介绍及使用Java实现socket通信
热门推荐
weixin_49561506的博客
07-05 2万+
使用Java实现socket通信。
用Java实现基于Socket的网络编程
小姚的博客
11-23 7968
使用Java语言，采用TCP协议，实现一对一、一对多的通信（无用户界面）
java socket 案例_java Socket完美实例
weixin_32441957的博客
02-16 959
java socekt 同步套节字编程主要用到java.net.Socket类，通常情况下我们需要socket的长连接模式。其次就是在连接的另一端断开之后需要及时响应。对于连接的判断，socket提供的isClosed,isConnected等都是判断本地套节字的状态。要判断运程的连接，可以通过发送紧急数据来判断，紧急数据发送成功与否，就表示远程是否断开。package org.noka.nsoc...
Java TCP Socket服务器端示例及协议分析
这篇文章提供了一个基础的Java服务器端编程示例，展示了如何通过ServerSocket监听客户端连接，以及如何在TCP/IP架构下设计网络通信协议的选用策略。这对于学习和实践网络编程，尤其是服务器端编程的学生和开发者来说...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值