聊一聊

最新推荐文章于 2024-09-28 16:23:38 发布
最新推荐文章于 2024-09-28 16:23:38 发布
阅读量405 收藏
点赞数 1
分类专栏： 项目 文章标签： Socket ServerSocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sophia__yu/article/details/86552352
版权

网络通信是服务器与客户端之间的数据传输。
客户端连接服务器时需要知道服务器的IP（哪一台电脑）和端口（电脑上具体的应用）。

在Java中，网路传输服务器需要干的事情有：
1.建立基站，表示通过服务器的端口通信：

创建绑定到本机的特定端口的服务器套接字
public ServerSocket(int port) throws IOException

2.等待客户端请求连接：

监听并接收连接到本服务器的客户端连接，此方法会一直阻塞，直至有客户端请求连接
public Socket accept() throws IOException

3.获取客户端的输入输出流
4.关闭流

在Java中，客户端网络传输需要干的事情有：
1.建立与服务器之间的连接：
首先介绍下Socket：
Socket类代表客户端和服务器都用来互相沟通的套接字。客户端通过实例化来获取一个Socket对象，服务器通过accept()的返回值获取一个Socket对象。

//host是服务器的IP地址
//port是主机的端口号 
public Socket(String host, int port)      throws UnknownHostException, IOException

2.利用输入输出流进行数据传输。
3.关闭流

基于单线程的服务端与客户端通信
客户端：

package CODE.Socket聊天室;


import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

//单线程客户端
//1.建立连接
//2.进行数据输入输出
public class SingleTreadClient {
    public static void main(String[] args) {
        try {
            //1.建立连接
            Socket client=new Socket("127.0.0.1",9999);
            //2.进行数据输入输出
            //客户端首先进行从服务器的数据读
            Scanner clientInput=new Scanner(client.getInputStream());
            if(clientInput.hasNext())
            {
                System.out.println("服务器say:"+clientInput.nextLine());
            }

            //客户端进行数据输出,但是先从键盘获取标准输入
            System.out.println("请输入向服务器发送的消息");
            Scanner in=new Scanner(System.in);
            String str="";
            if(in.hasNext())
            {
                str=in.nextLine();
            }
            //向服务器输出
            PrintStream clientOut=new PrintStream(client.getOutputStream(),true,"UTF-8");
            clientOut.println(str);

            //3.关闭流
            clientInput.close();
            in.close();
            clientOut.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

服务端：

package CODE.Socket聊天室;


import Work.Exception.Ex;

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

//单线程服务端
public class SingleThreadServer {
    public static void main(String[] args) throws Exception {
        //1.建立基站类
        ServerSocket serverSocket=new ServerSocket(9999);
        //2.等待客户端连接
        System.out.println("等待客户端连接ing");
        Socket client=serverSocket.accept();  //阻塞监听客户端连接
        //3.连接成功后，获取客户端输入输出流
        System.out.println("有新的客户端连接，客户端端口号为："+client.getPort());

        //客户端输出流
        PrintStream clientOut=new PrintStream(client.getOutputStream(),true,"UTF-8");
        clientOut.println("hello i am server");

        //客户端输入流
        Scanner clientInput=new Scanner(client.getInputStream());
        if(clientInput.hasNext())
        {
            System.out.println("客户端端口号为"+client.getPort()+"say："+clientInput.nextLine());
        }

        //4.关闭流
        clientInput.close(); //关闭客户端输入流
        clientOut.close();  //关闭客户端输出流
        serverSocket.close(); //关闭基站

    }

}

服务端：
在这里插入图片描述
客户端：
在这里插入图片描述
单线程：也就是说只有服务器只能连接一个客户端，并且读写数据顺序有限制，如果写在读之前，只有写了才能读，放在现实中就是在给好友发消息时，不能接受好友发过来的消息，这明显不合实际，所以，进入多线程，即读写线程并发。

多线程服务端和客户端通信

多线程客户端：

在多线程客户端中接受数据和写入数据可以并发。在实际通信中，对应在给好友发消息时可以接受到好友的消息。

package CODE.Socket聊天室;

//多线程客户端  发送和读取是并行
//读和写是2个线程，但是是一个socket，通过构造

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

//关闭socket是写线程关闭，读线程只读
class ReadFromServer implements  Runnable
{
    //读线程
    private Socket client;
    public ReadFromServer(Socket client)
    {
        this.client=client;
    }

    @Override
    public void run() {
        //获取输入流来取得服务器发来的信息
        try {
            Scanner in=new Scanner(client.getInputStream());
            while(true)
            {
                if(client.isClosed())
                {
                    System.out.println("客户端已关闭");
                    in.close();
                    break;
                }
                else if(in.hasNext())
                {
                    String msgFromServer=in.nextLine();
                    System.out.println("服务器发来的信息为："+msgFromServer);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//写线程
class WriteToServer implements Runnable
{
    private Socket client;

    public WriteToServer(Socket client) {
        this.client = client;
    }

    @Override
    public void run() {
        //从键盘获取标准输入
        Scanner in=new Scanner(System.in);
        PrintStream clientOut= null;
        try {
            clientOut = new PrintStream(client.getOutputStream(),true,"UTF-8");
            while(true)
            {
                //获取向服务端发送的信息
                String msgToServer="";
                if(in.hasNext())
                {
                    msgToServer=in.nextLine();
                }
                //向服务端输出信息
                clientOut.println(msgToServer);
                if(msgToServer.contains("bye"))
                {
                    System.out.println("客户端"+client.getInetAddress()+"退出聊天室");
                    //客户端输出bye,关闭该客户端连接
                    clientOut.close();  //关闭输出流
                    in.close();
                    client.close();  //关闭socket，根据输入终止，
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public class MultiThreadClient {
    public static void main(String[] args) {
        try {
            //1.建立连接
            Socket client=new Socket("127.0.0.1",9999);
            //2.启动读写线程，进行数据输入输出
            Thread readThread=new Thread(new ReadFromServer(client));
            Thread writeThread=new Thread(new WriteToServer(client));
            readThread.start();
            writeThread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多线程服务端：
在多线程中，服务端需要做到：
1.一个服务器可以接收多个客户端请求；
2.保存多个客户端连接
3.服务端中可以将客户端的请求保存，可以将客户端的数据发送指定客户端或所有客户端，可以在客户端退出时及时作出反应。在实际通信中，分别对应私聊、群聊、用户下线。

package CODE.Socket聊天室;


import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//多线程的服务器
//需要接收多个连接
public class MuliThreadServer {
    //用ConcurrentHashMap是为了保证线程安全,存储每个连接的客户端
    private static Map<String,Socket> clientMap=new ConcurrentHashMap<>();

    //具体执行与每个客户端的通信  内部类，
    private static class RealExcuteClient  implements Runnable
    {
        private Socket client;

        public RealExcuteClient(Socket client) {
            this.client = client;
        }

        @Override
        public void run() {
            String msgFromClient="";
            try {
                Scanner in=new Scanner(client.getInputStream());  //获取客户端输入流
                while(true)
                {
                    if(in.hasNext())
                    {
                        msgFromClient=in.nextLine();
                        //由于在Windows在\r\n是换行，所以需要消除自带的\r，用" "替换掉
                        Pattern pattern=Pattern.compile("\r"); //表示识别"\r"的格式
                        Matcher matcher=pattern.matcher(msgFromClient); //msgFromClient是否有\r
                        //若有
                        msgFromClient=matcher.replaceAll(" ");

                        //注册：将连接的客户端添加到Map集合中
                        if(msgFromClient.startsWith("userName"))
                        {
                            String name=msgFromClient.split(":")[1];
                            if(addClientToMap(name,client))
                                continue;
                            else
                                break; //该客户端注册失败
                        }

                        //Group代表群聊，comment是内容，Group:comment
                        if(msgFromClient.startsWith("Group")){
                            String comment=msgFromClient.split(":")[1];
                            groupChat(comment);
                            continue;
                        }

                        //private代表私聊，name代表私聊对象，comment代表私聊的内容  private:name-comment
                        if(msgFromClient.startsWith("Private"))
                        {
                            String name=msgFromClient.split(":")[1].split("-")[0];
                            String comment=msgFromClient.split(":")[1].split("-")[1];
                            privateChat(name,comment);
                                continue;
                        }

                        //用户下线，从Map集合中删除该信息   用户名：内容
                        if(msgFromClient.contains("再见，下次再聊"))
                        {
                            String name=msgFromClient.split(":")[0];
                            quitChat(name);
                            break;  //客户端自己会将连接关闭
                        }

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

        }

        //注册
        public static  boolean addClientToMap(String name,Socket client)
        {
            //判断用户名是否已经存在
            if(clientMap.get(name)!=null || client.isClosed())
            {
                System.out.println("用户名已经存在或连接已关闭，注册失败");
                return false;
            }
            clientMap.put(name,client);
            System.out.println("客户端"+name+"已经进入嗨聊空间");
            System.out.println("客户端注册成功，"+"当前嗨聊空间人数为："+clientMap.size());
            try {
                PrintStream out=new PrintStream(client.getOutputStream());
                out.println(name+"注册成功");
            } catch (IOException e) {
                e.printStackTrace();
            }
            return true;
        }

        //群聊
        public static void groupChat(String comment)
        {
            //将Map集合变为Set集合
            Set<Map.Entry<String,Socket>> clientSet=clientMap.entrySet();
            for(Map.Entry<String,Socket> entry:clientSet)
            {
                //取得每一个客户端的socket
                Socket sigClient=entry.getValue();
                try {
                    PrintStream outToClient=new PrintStream(sigClient.getOutputStream());
                    outToClient.println(comment);
                } catch (IOException e) {
                    System.out.println("群聊异常，错误为："+e);
                }
            }
        }

        //私聊
        public static void privateChat(String name,String comment)
        {
            Socket privateClient=clientMap.get(name);  //获取对应的客户端socket
            if(privateClient==null)
                System.out.println("私聊失败，私聊对象不存在");
            else{
                try {
                    PrintStream privateOut=new PrintStream(privateClient.getOutputStream());
                    privateOut.println(comment);
                } catch (IOException e) {
                    System.out.println("私聊异常，错误为："+e);
                }
            }
        }

        //用户下线
        public static void quitChat(String name)
        {
            System.out.println(name+"下线");
            clientMap.remove(name);
            System.out.println("当前嗨聊空间人数为："+clientMap.size());
        }
    }

    public static void main(String[] args) {
        try {
            //建立基站
            ServerSocket serverSocket=new ServerSocket(9999);
            //线程池，也就是最多允许15个客户端连接服务器
            ExecutorService executorService= Executors.newFixedThreadPool(15);
            for(int i=0;i<15;i++)
            {
                System.out.println("等待客户端连接");
                //返回的是连接的客户端信息
                Socket client=serverSocket.accept();
                System.out.println("有新的客户端连接,客户端端口号为"+client.getPort());
                executorService.submit(new RealExcuteClient(client));
            }
            executorService.shutdown();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

启动3个客户端，结果如下：
服务端：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

sophia__yu
关注
专栏目录
深聊测试开发之：从订单支付流程来聊一聊，如何预防重复支付，建议收藏。
商务合作 | 面试培训 | 职场规划 ==>主页扫码
09-26 3510
拒绝出现订单重复支付， 关爱顾客， 人人有责。
来聊一聊std::function和lambda性能效率问题
神技圈子的博客
07-17 2294
详细讲解std::function和lambda在日常开发过程，大家最关心的性能效率问题
Netty详解
努力分享一些干货内容，纯干货，没有一点水
07-31 3161
Netty是一个高性能、异步的网络应用框架，用于开发高效的网络通信程序。它是JavaNIO的一个抽象，简化了网络编程的复杂性，并提供了一系列高级功能，使网络编程变得更简单。Netty是一个高效的网络框架，专注于处理大量并发连接。它通过异步IO处理来避免阻塞，这让它在处理高并发时表现出色。Netty还利用了优化的内存管理和零拷贝技术，降低了性能开销。框架的灵活性也很高，开发者可以通过管道机制自定义数据处理流程，API和文档丰富，帮助简化网络编程。不过，Netty。
Netty和Tomcat区别
weixin_42354735的博客
11-02 8694
Netty与Tomcat区别 它们的区别不少，最大的区别就在于通信协议，这是众所周知的，Tomcat是一个服务器，它一定是基于Http协议的，它的实质是一个基于http协议的web容器，Netty则不同，Netty可以通过编程自定义各种协议，这是因为netty能够通过codec自己来编码/解码字节流，完成一种类似redis访问的功能，这就是它们之间最大的不同。 事实上很多人都说netty的性能肯定比tomcat性能高，实际tomcat从6.x开始就一直支持nio模式，且后续还有arp模式，这是一种通过j
Netty入门
最新发布
我的博客
09-28 1187
【零拷贝】的体现之一，对原始 ByteBuf 进行切片成多个 ByteBuf，切片后的 ByteBuf 并没有发生内存复制，还是使用原始 ByteBuf 的内存，切片后的 ByteBuf 维护独立的 read，write 指针。netty 中的 Future 与 jdk 中的 Future 同名，但是是两个接口，netty 的 Future 继承自 jdk 的 Future，而 Promise 又对 netty Future 进行了扩展。connect 方法是异步的，意味着不等连接建立，方法执行就返回了。
Netty
飘然生的博客
05-06 2198
Netty实战精髓篇 常见的网络通信框架？ Netty（JBoss） Mina（Apach） Grizzly（sum） 前言。BIO和NIO的通信流程区别 中间多插入一个多路复用器 BIO:服务端——线程——socket——客户端 （有几个客户端就有几个线程） NIO:服务端——线程——selector——socket——客户端 （一个线程，一个多路复用器进行轮询） 一。...
超详细Netty入门，看这篇就够了！
You can walk as far as you want.
02-23 7912
本文主要讲述Netty框架的一些特性以及重要组件，希望看完之后能对Netty框架有一个比较直观的感受，希望能帮助读者快速入门Netty，减少一些弯路。官方的介绍：Netty isNetty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。
（一）为什么需要Netty？
太阳不落山
06-05 7402
一套性能优异、使用简单、极致的内存管理技术、开源社区强大、适用于高并发场景的网络编程框架--Netty
聊一聊卡卷签名的那些坑
03-29
最近在做小程序卡卷，真是一个接一个的坑，不仅网上的资料不多，官方文档更是混乱，搞了好几天才搞定，这里说说过程中遇到的坑，基本上这些坑90%都出在签名上。 卡卷签名主要用到以下几个参数： api_ticket （调用...
高级产品经理来聊一聊，什么是产品架构
02-25
产品经理之前已经将产品第一个版本的功能需求都整理好了，也输出了一份详细的功能需求列表，这个时候要做的工作就是为产品搭建一个好的架构，也就是产品设计的第三个环节——搭框架了。任何一款互联网产品都应该有一...
Netty 介绍
热门推荐
北漂码农的博客
04-19 8万+
1.1. Netty 原理 Netty 是一个高性能、异步事件驱动的 NIO 框架，基于 JAVA NIO 提供的 API 实现。它提供了对 TCP、UDP 和文件传输的支持，作为一个异步 NIO 框架，Netty 的所有 IO 操作都是异步非阻塞 的，通过 Future-Listener 机制，用户可以方便的主动获取或者通过通知机制获得 IO 操作结果。 1.2. Netty 高性能 ...
【Netty系列】使用Netty搭建TcpServer
秋装什么的博客
12-17 1303
【Netty系列】使用Netty搭建TcpServer
Netty创建TCPServer服务java版
09-28 967
java使用Netty搭建TCPServer，接入传统的RS485/232等TCP协议的电气设备，实现物联网的数据采集与指令下发，以及监听设备的实时状态，包括16进制数据解析为String类型
【Java】Netty创建网络服务端客户端（TCP/UDP）
DevFrank的博客
11-09 5074
Netty创建网络服务端客户端示例
使用Netty构建TCP和UDP服务器和客户端
lonely_baby的博客
03-09 1993
上述示例代码中，分别定义了一个TCP服务器、TCP客户端、UDP服务器和UDP客户端，并使用了Netty提供的NIO事件循环组（EventLoopGroup）、服务器/客户端启动器（ServerBootstrap/Bootstrap）和通道初始化器（ChannelInitializer）等组件，以实现服务器和客户端的建立、连接、数据读写等功能。总之，使用Netty构建TCP和UDP服务器和客户端，可以帮助开发人员快速构建高性能、可扩展的网络应用程序，并通过其丰富的功能和插件实现更加细粒度的控制和调试。
【网络编程实例】C++11实现基于TCP的服务器和客户端通信
weixin_42659457的博客
11-12 1309
参考《TCP/IP网络编程》第二章，基于C++11实现基于TCP的服务器和客户端通信
Netty入门实例 TCP服务
男儿当自强
08-11 265
基于Netty开发一个入门程序，主要功能：服务端启动后监听一个端口，客户端启动后会给服务端发送一条消息，服务端收到后通过Handler读取消息，进行处理，读取完通过Handler反馈一条消息给客户端。 服务端： Server package com.tech.netty.netty; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.
在本地搭建基于TCP协议的服务器端和客户端（实现通信）——如果天总也不亮，那就摸黑过生活
sxr__nc的博客
05-21 2086
前不久分析了一个挖矿病毒，整个过程可以说是极其折磨人，但是也有很多值得学习的地方，最近几天一直在反思和学习病毒在执行过程中涉及到的一些点。今天尝试测试了在本地搭建基于TCP协议进行通信的服务器和客户端，并且让二者实现一个简单的通信。 不多说，直接上代码，之后再简要解释一下 代码分为两段，（同时需要打开两个VS，创建两个项目，分别进行编译运行） 服务端： #include<stdio.h> #include<windows.h> #include<winsock.h> #p
java网络编程之基于TCP的socket编程，实现客户端和服务器相互通信
LJH_laura_li的博客
09-05 1万+
网络通信 首先说网络通信，网络通信使用IP地址标识internet上的计算机，使用端口号标识服务器上的进程(程序)。也就是说，如果服务器上的一个程序不占用一个端口号，用户程序就无法找到它，就无法和该程序交互通信。端口号选取大于1023。 当两个程序需要通信时，它们可以通过使用Socket类建立套接字并连接在一起(端口号与IP地址的组合得出一个网络套接字) 套接字 它允许程序把网络连接看成一个流(...
聊一聊typescript
10-28
TypeScript是一种由微软开发的开源编程语言，它是JavaScript的超集，意味着它包含了JavaScript的所有特性，并且还提供了额外的功能和工具，例如静态类型检查、类、接口、泛型等等。TypeScript的主要目的是提高代码的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值