Java Socket基本例子——使用最原始方法

Wesley13
• 阅读 492

使用最原始的java.net.ServerSocket和java.net.Socket进行socket通信。实现的效果为:客户端向服务端发送消息、服务端向客户端发送消息、保留统计客户端的信息列表、剔除已经断开的客户端等。

本文所有代码均可在https://gitee.com/songxinqiang/JavaSocketDemo查看。

服务端

接受用户输入端口并且启动服务器的入口类，还需要完成接受用户输入发送给客户端

public class Main {

    public static void main(String[] args) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("请输入服务器端口(默认8080):");
        Integer port =8080;
        try {
            port = Integer.parseInt(reader.readLine());
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        
        SocketServer server = new SocketServer(port);
        while (true) {
            try {
                String line = reader.readLine();
                if (line.equals("exit")) {
                    System.exit(0);
                    break;
                }
                server.sendMessage(line);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

服务器类需要完成启动ServerSocket接受客户端连接、保留客户端信息、清除已经断开的客户端信息、对外暴露向客户端发送消息的接口

使用到了定时器，代码需要java8环境，日志记录为slf4j接口

public class SocketServer extends TimerTask {

    private static final Logger logger = LoggerFactory.getLogger(SocketServer.class);

    ServerSocket serverSocket;

    private List<SocketClientHandler> clients = new ArrayList<>();

    /**
     * 开启监听，接受链接
     */
    public SocketServer(Integer port) {
        // 清理客户端
        new Timer(true).schedule(this, 1000, 1000);
        try {
            serverSocket = new ServerSocket(port);
            logger.info("服务端已启动，等待客户端连接..");
            new Thread(() -> {
                while (!serverSocket.isClosed()) {
                    try {
                        Socket socket = serverSocket.accept();
                        String clientIP = socket.getInetAddress()
                                .getHostAddress();

                        logger.info("client:{}", clientIP);

                        SocketClientHandler handler = new SocketClientHandler(socket);
                        handler.start();

                        clients.add(handler);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();

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

    /**
     * {@inheritDoc}<br>
     * 用于清理已经断开的客户端
     *
     */
    @Override
    public void run() {
        Iterator<SocketClientHandler> it = clients.iterator();
        while (it.hasNext()) {
            SocketClientHandler handler = it.next();
            if (!handler.isAlive()) {
                it.remove();
            }
        }
    }

    /**
     * 往客户端发送消息
     *
     * @param msg
     *            消息
     */
    public void sendMessage(String msg) {
        logger.info("send:{}", msg);
        clients.stream()
                .forEach(client -> client.sendMessage(msg));
    }

}

客户端信息处理为单独的线程，保存客户端的socket对象，接受客户端消息并进行处理(这里只是打印),同时实际完成向客户端发送消息

public class SocketClientHandler extends Thread {

    private static final Logger logger = LoggerFactory.getLogger(SocketClientHandler.class);

    Socket client;
    String ip;

    BufferedReader reader;
    PrintWriter writer;

    public SocketClientHandler(Socket socket) {
        this.ip = socket.getInetAddress()
                .getHostAddress();
        try {
            this.client = socket;
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new PrintWriter(socket.getOutputStream(), true);
        } catch (IOException e) {
            logger.error("init socket client error,{}", e.getMessage());
        }
    }

    /**
     * {@inheritDoc}<br>
     *
     */
    @Override
    public void run() {
        while (!client.isClosed()) {
            try {
                String msg = reader.readLine();
                if (msg == null) {
                    break;
                }
                receiveMessage(msg);
            } catch (IOException e) {
                logger.info(e.getMessage());
                break;
            }
        }
    }

    /**
     * 收到消息之后的处理
     *
     * @param msg
     *            收到的消息
     */
    public void receiveMessage(String msg) {
        logger.info("from:{},receive:{}", ip, msg);
    }

    /**
     * 发送消息
     *
     * @param msg
     *            发送的消息
     */
    public void sendMessage(String msg) {
        logger.info("to:{},send:{}", ip, msg);
        writer.println(msg);
    }

}

代码通过Main类启动之后要求用户输入服务器端口,然后开始接受客户端连接,打印客户端ip地址、发送过来的信息、接受用户输入并向所有客户端进行发送。

客户端

客户端的启动类完成向用户询问服务器地址和端口的操作，然后向服务端发起连接，接受用户输入，并发送到服务端

public class SocketClient {

    private static final Logger logger = LoggerFactory.getLogger(SocketClient.class);

    /**
     * 启动客户端，连接服务器
     */
    public SocketClient() {
        try {
            // 从控制台输入
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

            System.out.print("请输入服务器地址:");
            String host = reader.readLine();
            System.out.print("请输入服务器端口:");
            Integer port = Integer.parseInt(reader.readLine());

            Socket socket = new Socket(host, port);
            logger.info("连接：{}:{}", host, port);

            // 开启多线程接收信息，并解析
            ClientHandler thread = new ClientHandler(socket);
            thread.start();
            PrintWriter writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
            while (!socket.isClosed()) {
                String line = reader.readLine();
                if (line == null || line.isEmpty()) {
                    continue;
                }
                logger.info("读取：{}", line);
                // 发送消息
                writer.println(line);
                writer.flush();
            }

        } catch (Exception e) {
            logger.error("服务器异常,{}", e.getMessage());
        }
    }

    public static void main(String[] args) {
        new SocketClient();
    }

}

客户端信息处理

由于客户端的启动类需要完成用户输入的收集，所以接受服务端消息的操作由单独的线程进行，用于对服务器端发送过来的消息进行处理

public class ClientHandler extends Thread {

    private static final Logger logger = LoggerFactory.getLogger(ClientHandler.class);

    private Socket socket;
    BufferedReader reader;

    public ClientHandler(Socket socket) {
        this.socket = socket;
        try {
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * {@inheritDoc}<br>
     * 接收消息并打印，在收到的消息为{@code null}或者空字符串时退出
     *
     */
    @Override
    public void run() {
        while (!socket.isClosed()) {
            try {
                String msg = reader.readLine();
                if (msg == null) {
                    break;
                }
                receiveMessage(msg);
            } catch (IOException e) {
                logger.info(e.getMessage());
                break;
            }
        }
    }

    /**
     * 对服务器发送消息进行处理
     *
     * @param msg
     *            消息内容
     */
    public void receiveMessage(String msg) {
        logger.info("收到：{}", msg);
    }

}

maven打包

为了将程序打包为一个可执行jar,同时包含日志记录依赖,使用maven打包,关键代码为(以client为例,服务器端类似,详见git)

    <properties>
        <assembly-plugin.version>3.1.0</assembly-plugin.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 构建一个单文件可执行jar -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>${assembly-plugin.version}</version>
                <configuration>
                    <descriptors>
                        <descriptor>src/assembly/assembly.xml</descriptor>
                    </descriptors>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>cn.songxinqiang.demo.socket.SocketClient</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

运行效果

程序使用maven打包之后运行效果为

Java Socket基本例子——使用最原始方法

socketstringJavaJava
点赞
收藏
评论区
推荐文章
blmius blmius
•
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时，报错：原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等，这样可以更容易地在不同的环境中使用MySQL。全局s
4244
0
0
待兔 待兔
•
5个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
1133
0
0
Jacquelyn38 Jacquelyn38
•
3年前
2020年前端实用代码段，为你的工作保驾护航
有空的时候，自己总结了几个代码段，在开发中也经常使用，谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
2445
0
0
Wesley13 Wesley13
•
3年前
Java日期时间API系列31
　　时间戳是指格林威治时间1970年01月01日00时00分00秒起至现在的总毫秒数，是所有时间的基础，其他时间可以通过时间戳转换得到。Java中本来已经有相关获取时间戳的方法，Java8后增加新的类Instant等专用于处理时间戳问题。 1获取时间戳的方法和性能对比1.1获取时间戳方法Java8以前
1104
0
0
Stella981 Stella981
•
3年前
KVM调整cpu和内存
一.修改kvm虚拟机的配置1、virsheditcentos7找到“memory”和“vcpu”标签，将<namecentos7</name<uuid2220a6d1a36a4fbb8523e078b3dfe795</uuid
1376
0
0
Stella981 Stella981
•
3年前
Android So动态加载 优雅实现与原理分析
背景:漫品Android客户端集成适配转换功能(基于目标识别(So库35M)和人脸识别库(5M)),导致apk体积50M左右,为优化客户端体验,决定实现So文件动态加载.!(https://oscimg.oschina.net/oscnet/00d1ff90e4b34869664fef59e3ec3fdd20b.png)点击上方“蓝字”关注我
1896
0
0
Wesley13 Wesley13
•
3年前
Java服务端与C#客户端实现websocket通信（发送消息和文件）
设计思路使用websocket通信，客户端采用C开发界面，服务端使用Java开发，最终实现Java服务端向C客户端发送消息和文件，C客户端实现语音广播的功能。Java服务端设计packageservlet.websocket;importjava.io.IOException;importjava
1026
0
0
Wesley13 Wesley13
•
3年前
00：Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork)，斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。Java是简单易学，完全面向对象，安全可靠，与平台无关的编程语言。
1311
0
0
Stella981 Stella981
•
3年前
Django中Admin中的一些参数配置
设置在列表中显示的字段，id为django模型默认的主键list_display('id','name','sex','profession','email','qq','phone','status','create_time')设置在列表可编辑字段list_editable
1232
0
0
Stella981 Stella981
•
3年前
Netty 应用：Socket服务器
Socket服务器Netty作为Socket服务器，需要编写服务端和客户端，服务器端和客户端收发消息通过自定义的Handler.channelRead0方法来交互，客户端连接上服务器后，需要在active时向服务器发送一条消息来触发服务器的行为。服务端实现/Createdbyfubinon2019/7/
710
0
0
Wesley13
Wesley13
Lv1
最大的安心是自律温柔和爱自己。
文章
1.2w
粉丝
22
获赞
1.7k
热门文章
JavPlayer：AI破坏马赛克，大量马赛克破坏版影片流出
2020年最新可用的磁力搜索引擎&种子搜索网站，持续整理分享
8个在线接收手机短信验证码的免费网络服务整理
IDM 激活破解工具
java.net.ConnectException：Connection timed out：connect 出现连接超时的问题？