java socket 实现客户端、服务端（while、线程、线程池）

最新推荐文章于 2024-05-17 16:27:50 发布
最新推荐文章于 2024-05-17 16:27:50 发布
阅读量830 收藏 2
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43820352/article/details/106820237
版权
友情提示：SocketServer是服务端，SocketClient是客户端，先运行服务端再运行客户端，在客户端输入信息可在服务端返回，实现最简单的交互服务。另注意导包问题。

While 实现

socket 编程 C/S 结构

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

/**
 * 客户端
 */
public class SocketClient {
    public static void main(String[] args) {
        try {
            //初始化一个socket
            Socket socket = new Socket("127.0.0.1", 9999);
            //通过socket获取字符流
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            //通过标准输入流获取字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
            while (true) {
                String str = bufferedReader.readLine();
                bufferedWriter.write(str);
                bufferedWriter.write("\n");
                bufferedWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 服务端，while循环连续接受客户端信息
 */
public class SocketServer {
    public static void main(String[] args) {
        try {
            //初始化服务端socket并且绑定9999端口
            ServerSocket serverSocket = new ServerSocket(9999);
            //等待客户端的连接
            Socket socket = serverSocket.accept();
            //获取输入流,并且指定统一的编码格式
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
            //读取一行数据
            String str;
            //通过while循环不断读取信息，
            while ((str = bufferedReader.readLine()) != null) {
                //输出打印
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

如果你想拓展，可以看看下面的多线程实现

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

public class SocketClient1 {
    public static void main(String[] args) {
        try {
            //初始化一个socket
            Socket socket = new Socket("127.0.0.1", 9999);
            //通过socket获取字符流
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            //通过标准输入流获取字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
            while (true) {
                String str = bufferedReader.readLine();
                bufferedWriter.write(str);
                bufferedWriter.write("\n");
                bufferedWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

/**
 * 多线程下 socket 服务端
 *
 * @author NNroc
 * @date 2020/6/15 15:31
 */
public class SocketServer1 {
    public static void main(String[] args) throws IOException {
        //初始化服务端socket并且绑定9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        while (true) {
            //等待客户端的连接
            Socket socket = serverSocket.accept();
            //每当有一个客户端连接进来后，就启动一个单独的线程进行处理
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //获取输入流,并且指定统一的编码格式
                    BufferedReader bufferedReader = null;
                    try {
                        bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
                        //读取一行数据
                        String str;
                        //通过while循环不断读取信息
                        while ((str = bufferedReader.readLine()) != null) {
                            //输出打印
                            System.out.println("客户端" + str);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

线程

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

/**
 * 多线程下 socket 服务端
 * 对于大量数据来说，当线程创建出来后未回收，会大量占用资源
 *
 * @author NNroc
 * @date 2020/6/15 15:31
 */
public class SocketServer1 {
    public static void main(String[] args) throws IOException {
        //初始化服务端socket并且绑定9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        while (true) {
            //等待客户端的连接
            Socket socket = serverSocket.accept();
            //每当有一个客户端连接进来后，就启动一个单独的线程进行处理
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //获取输入流,并且指定统一的编码格式
                    BufferedReader bufferedReader = null;
                    try {
                        bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
                        //读取一行数据
                        String str;
                        //通过while循环不断读取信息
                        while ((str = bufferedReader.readLine()) != null) {
                            //输出打印
                            System.out.println("客户端" + str);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

线程池

服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池下 socket 服务端，保证线程的复用
 *
 * @author NNroc
 * @date 2020/6/15 15:46
 */
public class SocketServer2 {
    public static void main(String[] args) throws IOException {
        //初始化服务端socket并且绑定9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        //创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        while (true) {
            //等待客户端的连接
            Socket socket = serverSocket.accept();
            Runnable runnable = () -> {
                SocketAddress remoteSocketAddress = socket.getRemoteSocketAddress();
                BufferedReader bufferedReader = null;
                try {
                    bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
                    //读取一行数据
                    String str;
                    //通过while循环不断读取信息
                    while ((str = bufferedReader.readLine()).length() != 0) {
                        //输出打印
                        System.out.println("客户端" + remoteSocketAddress.toString() + "发送：" + str);
                    }
                } catch (SocketException e) {
                    System.out.println("客户端" + remoteSocketAddress.toString() + "断开连接");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            };
            executorService.submit(runnable);
        }
    }
}
客户端
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

/**
 * @author NNroc
 * @date 2020/6/15 15:35
 */
public class SocketClient1 {
    public static void main(String[] args) {
        try {
            //初始化一个socket
            Socket socket = new Socket("127.0.0.1", 9999);
            //通过socket获取字符流
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            //通过标准输入流获取字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
            while (true) {
                String str = bufferedReader.readLine();
                if (str.equals("end")) {
                    break;
                }
                bufferedWriter.write(str);
                bufferedWriter.write("\n");
                bufferedWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

设置需求

服务端
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * socket 指定长度发送数据
 * 在不定长通讯中，通常使用的方式时每次默认读取 8*1024长度的字节，若输入流中仍有数据，则再次读取，一直到输入流没有数据为止。
 * 但是如果发送数据过大时，发送方会对数据进行分包发送，这种情况下或导致接收方判断错误，误以为数据传输完成，因而接收不全。
 * 在这种情况下就会引出一些问题，诸如半包，粘包，分包等问题，
 *
 * @author NNroc
 * @date 2020/6/15 16:01
 */
public class SocketServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(9999);
            Socket client = serverSocket.accept();
            InputStream inputStream = client.getInputStream();
            DataInputStream dataInputStream = new DataInputStream(inputStream);
            while (true) {
                byte b = dataInputStream.readByte();
                int len = dataInputStream.readInt();
                byte[] data = new byte[len - 5];
                dataInputStream.readFully(data);
                String str = new String(data);
                System.out.println("获取的数据类型为：" + b);
                System.out.println("获取的数据长度为：" + len);
                System.out.println("获取的数据内容为：" + str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
客户端
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

/**
 * @author NNroc
 * @date 2020/6/15 16:09
 */
public class SocketClient1 {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1", 9999);
            OutputStream outputStream = socket.getOutputStream();
            DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
            Scanner scanner = new Scanner(System.in);
            if (scanner.hasNext()) {
                String str = scanner.next();
                int type = 1;
                byte[] data = str.getBytes();
                int len = data.length + 5;
                dataOutputStream.writeByte(type);
                dataOutputStream.writeInt(len);
                dataOutputStream.write(data);
                dataOutputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
幽影相随
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVA服务器端应用Socket线程池
10-16
JAVA服务器端应用Socket线程池，代码简练实用，仅作技术交流，勿用于商业用途.
java socket while_关于socket 服务端的 while循环 报错 求大神帮忙看看代码和错误信息...
weixin_33514582的博客
02-16 137
new Thread(){public void run(){try {Log.i("TService", "================>SHIT");service=new DatagramSocket(PORT);mExecutorService = Executors.newCachedThreadPool(); //创建线程池Log.i("TService", "=======...
Java 网络编程-Socket编程（一、简易客户端-服务器）
最新发布
jiaoyaqiang的博客
05-17 780
很显然，客户端调用Socket构造器，创建了Socket，并且连接了服务器（服务器已经运行的情况下）。上面是服务器读取客户端发送的消息的代码，一行一行的读取消息，并且只有当客户端发送“quit”给服务器时，才表示此客户端要退出，并且在这个过程中其他客户端是不能与服务器进行连接的，因为服务器一直在while里面读取此客户端发送的数据，不过，这只是一个体验版，以后会一步一步进行升级的，毕竟学习也是一步一步学出来的。向服务器发送消息，并且接收服务器的回复，也是一行一行的读取。大家也自己进行测试，应该是没问题的。
Java Socket学习笔记（三）- TCP服务端线程池
Watson的码步
07-31 346
一、服务端回传服务类： import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.util.logging.Level; import java.util.logging.Logger; pub...
java socket线程池_java socket 线程池服务器与客户端
weixin_35070578的博客
02-12 212
服务器：import java.io.IOException;import java.net.ServerSocket;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ThreadServer {public static void main(String[...
java socket client_Java Socket client端
weixin_32925455的博客
02-16 125
之前写过一个Server Socket端。今天特意写了个client端。java Socket 多线程Server端两个结合起来，可以组成一个即时通讯的雏形。package com.javaer.examples.socket;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamRea...
Java通过socket客户端保持连接服务端实现代码
08-25
虽然本文主要介绍了Java通过socket客户端保持连接服务端实现代码，但是我们也需要了解Socket服务端的实现。Socket服务端需要监听客户端的连接请求，并在客户端连接成功后，发送数据给客户端。在Java中，Socket服务端...
python socket实现客户端服务端通信列子
02-18
标题中的"python socket实现客户端服务端通信列子"指的就是使用Python的socket库来创建一个客户端（client）和一个服务器端（server），以便它们可以通过网络进行交互。这个过程通常包括以下几个步骤： 1. **创建...
Java Socket编程实例（三）- TCP服务端线程池
09-02
总结来说，Java Socket编程中的TCP服务端线程池实例展示了如何利用线程池优化服务器性能，避免频繁创建线程，同时提供了一种优雅的方式来处理并发客户端请求。在实际开发中，结合Spring框架，我们可以更加灵活且高效...
tcp socket客户端和服务端示例分享
09-04
TCP Socket是网络编程中用于建立可靠、面向连接通信的基本组件，它在客户端和服务端之间提供了数据传输的通道。本文将详细解析TCP Socket客户端和服务端的示例代码，并讲解相关知识点。 首先，TCP（Transmission ...
java实现Socket通信之单线程服务
08-27
本文将深入探讨如何使用Java实现单线程服务端的Socket通信。 首先，我们来理解Socket的概念。Socket在编程中被视为网络通信的端点，它包含了IP地址和端口号，用于标识网络上的特定服务。在TCP/IP模型中，Socket是...
java线程池 socket_Java多线程与线程池实现Socket多个客户端连接服务器同时通信代码...
weixin_30572265的博客
02-21 290
多线程是实现的服务器端：package com.main;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStr...
socket编程中客户端常用函数 以及简单实现
weixin_30628077的博客
05-14 129
1 常用函数 1.1 connect() int connect(int sockfd, const struct sockaddr *servaddr, socklen_taddrlen); 　　客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。connect()成功返回...
（七）Socket简介及客户端服务端代码实现
roothahh的博客
04-10 4056
（一）Socket概念： socket时TCP/IP协议的抽象，是操作系统对外开放的接口 socket起源于unix，京客户端和服务端各自管理一个文件，是其能分别对文件进行读写操作 socket的通信流程： (二)代码实现： 编写TCP和UDP实现服务端与客户端的通信： TCP实现： import java.net.ServerSocket; import java.net.Socket; public class TCPServer{ public stati
java socket线程池_Java Socket编程实例（三）- TCP服务端线程池
weixin_39722188的博客
02-12 170
一、服务端回传服务类：import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.Socket;import java.util.logging.Level;import java.util.logging.Logger;public class EchoProt...
客户端Socket（异步方式）
oncruise的博客
04-28 663
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Net.Sockets; using System.Net; namespace ClientSocket { public class ClientHandle { private string ip; .
linux循环接收socket,Linux下socket编程（实现回声客户端功能（修改版while（）循环接收））...
weixin_36399948的博客
05-15 273
#include #define BUF_SIZE 100int main(){//创建套接字int serv_sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);//将套接字和ip、端口绑定struct sockaddr_in serv_addr;memset(&serv_addr,0,sizeof(serv_addr));//每个字节都用0填充s...
java线程内使用while_java多线程中while中使用了if后
weixin_39672572的博客
02-25 95
packagetest;publicclassTestBank{publicstaticvoidmain(String[]args){newTestBank().run();}publicvoidrun(){Familyf=newFamily();newThread(f).start();while(true){System.out.pr...package test;public class T...
Java网络编程精解之ServerSocket用法详解二1
KEVIN_LONG的专栏
06-04 1576
3.6  创建多线程的服务器在本书第1章的1.5.1节的例程1-2的EchoServer中，其service()方法负责接收客户连接，以及与客户通信。service()方法的处理流程如下： while (true) {Socket socket=null;try {socket = serverS
使用java代码实现socket多线程服务端的功能
03-13
以下是一个简单的Java代码示例，用于实现socket多线程服务端的功能： ``` import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class MultiThreadedServer { public ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值