Java Socket通信

最新推荐文章于 2022-11-02 13:54:51 发布
最新推荐文章于 2022-11-02 13:54:51 发布
阅读量259 收藏
点赞数
分类专栏： java 文章标签： java socket serversocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinjin10086/article/details/105708549
版权

Socket简介

Socket综述
Socket被翻译为套接字，是端到端的链接通信方式，处在网络七层（或五层）协议模型的传输层和应用层之间，我们这里主要基于TCP/IP链接
的Socket，这是对传输层的一个抽象封装，通过简单的api就可以实现端到端的传输。
Socket相关的类
  1. Socket：实现通信的主要类，流的读写等操作都是通过此类来完成。
  2. ServerSocket：socket服务器，创建服务器，等待链接接入，接入完成返回Socket进行相关通信。
  3. SocketImpl：实际工作的类，Socket和ServerSocket内部都是基于此完成，有子类如AbstractPlainSocketImpl、DualStackPlainSocketImpl等。
  4. SocketImplFactory：工厂模式，用于产生SocketImpl对象。

Socket使用

简单使用

服务器代码：

package edu.gj.demo1;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author Simple
 * @date 2020/4/23 14:58
 */
public class Server {


    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;

        OutputStream outputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        PrintStream printStream = null;
        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader reader = null;

        try {
            //创建服务  等待链接
            serverSocket = new ServerSocket(8888);
            //链接获取到socket对象
            socket = serverSocket.accept();
            //获取输入输出流
            outputStream = socket.getOutputStream();
            inputStream = socket.getInputStream();
            bufferedOutputStream = new BufferedOutputStream(outputStream);
            printStream = new PrintStream(bufferedOutputStream);
            inputStreamReader = new InputStreamReader(inputStream);
            reader = new BufferedReader(inputStreamReader);

            String info = reader.readLine();
            System.out.println("服务器获取到信息：" + info);

            printStream.println("客户端，你好！");
            printStream.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (null != reader){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != inputStreamReader){
                try {
                    inputStreamReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != inputStream){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != printStream){
                printStream.close();
            }
            if (null != bufferedOutputStream){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != outputStream){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != socket){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != serverSocket){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }


}

客户端代码：

package edu.gj.demo1;

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

/**
 * @author Simple
 * @date 2020/4/23 14:58
 */
public class Client {

    public static void main(String[] args) {

        Socket socket = null;

        OutputStream outputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        PrintStream printStream = null;
        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader reader = null;


        try {
             socket = new Socket("localhost",8888);
            //获取输入输出流
            outputStream = socket.getOutputStream();
            inputStream = socket.getInputStream();
            bufferedOutputStream = new BufferedOutputStream(outputStream);
            printStream = new PrintStream(bufferedOutputStream);
            inputStreamReader = new InputStreamReader(inputStream);
            reader = new BufferedReader(inputStreamReader);

            printStream.println("服务器，你好！");
            printStream.flush();

            String info = reader.readLine();
            System.out.println("客户端收到反馈：" + info);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (null != reader){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != inputStreamReader){
                try {
                    inputStreamReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != inputStream){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != printStream){
                printStream.close();
            }
            if (null != bufferedOutputStream){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != outputStream){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != socket){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }

}

启动：
先启动服务器Server代码，再启动客户端代码Client
运行结果如下：
服务器：
日志1
客户端：
日志2
通信过程总结如下：
1、服务器：

  1. 创建ServerSocket，等待链接。
  2. 链接获取到Socket对象。
  3. 获取输入输出流进行通信。
  4. 通信前程，关闭流。

2、客户端：

  1. 创建Socket对象，链接服务器。
  2. 获取输入输出流进行通信。
  3. 通信完成，关闭输入输出流
Socket长链接进行两个客户端之间通信
大家可以发现，上述只是一次性通信，并没有实现随时接入，也没有实现多客户端接入，下面我们解决这两个问题，实现两个客户端通信。

1、引入ServerThread类启动线程去处理多客户端接入问题问题。
2、服务器死循环实现接收多个客户端连接。
3、Socket死循环，随时接收信息，接收多条信息。
4、防止资源浪费，引入心跳机制。
5、防止消息混乱，引入消息机制。
具体代码实现如下：
1、消息分类实现，引入类MessageBean：

package edu.gj.demo;

/**
 * @author Simple
 * @date 2020/4/17 16:53
 */
public class MessageBean {

    /**
     * 消息类型
     * 0 心跳消息
     * 1 链接初始化消息
     * 2 系统分发消息
     * 3 点对点消息
     */
    private int type;
    /**
     * 用户名  发给系统初始化信息的时候用到
     */
    private String userName;

    /**
     * 消息发送者
     */
    private String sender;
    /**
     * 消息接受者
     */
    private String to;
    /**
     * 消息内容
     */
    private String content;

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getTo() {
        return to;
    }

    public void setTo(String to) {
        this.to = to;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

2、多客户端接入问题，引入线程处理ServerThread：

package edu.gj.demo;

import com.google.gson.Gson;
import org.json.JSONObject;

import java.io.*;
import java.net.Socket;
import java.net.SocketException;

/**
 * @author Simple
 * @date 2020/4/17 15:00
 */
public class ServerThread extends Thread {


    private String clientName;

    private Socket socket;


    InputStream inputStream = null;
    InputStreamReader inputStreamReader = null;
    BufferedReader bufferedReader = null;
    OutputStream outputStream = null;
    BufferedOutputStream bufferedOutputStream = null;
    PrintStream printStream = null;


    public ServerThread(Socket socket) {
        this.socket = socket;
        try {
            socket.setKeepAlive(true);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            inputStream = socket.getInputStream();
            inputStreamReader = new InputStreamReader(inputStream);
            bufferedReader = new BufferedReader(inputStreamReader);
            outputStream = socket.getOutputStream();
            bufferedOutputStream = new BufferedOutputStream(outputStream);
            printStream = new PrintStream(bufferedOutputStream);
            startMessageAccept(bufferedReader);
        } catch (Exception e) {
            e.printStackTrace();
            closeResources();
        }
    }

    private void closeResources() {
        try {
            inputStream.close();
            inputStreamReader.close();
            bufferedReader.close();
            outputStream.close();
            bufferedOutputStream.close();
            printStream.close();
            socket.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 发送消息
     *
     * @param message
     */
    public void sendMessage(String message) {
        printStream.println(message);
        printStream.flush();
    }


    public void startMessageAccept(BufferedReader reader) {
        lastHeartTime = System.currentTimeMillis();
        new Thread(new NoticeTimeRunnable()).start();
        isHearting = true;
        while (isHearting) {
            try {
                String message = reader.readLine();
                MessageBean messageBean = new Gson().fromJson(message,MessageBean.class);
                JSONObject jsonObject = new JSONObject(message);
                if (messageBean.getType() == 0) {
                    //心跳消息
                    System.out.println("心跳消息" + jsonObject.toString());
                } else {
                    //正常消息
                    handleMessage(messageBean);
                }
            } catch (IOException e) {
                e.printStackTrace();
                closeResources();
                return;
            }
        }
    }


    private void handleMessage(MessageBean body) {
        System.out.println("收到消息：" + new Gson().toJson(body));
        if (body.getType() == 3){
            Server.sendMessage(body);
        }else if (body.getType() == 1){
            clientName = body.getUserName();
        }
    }


    private long lastHeartTime;
    private boolean isHearting;

    private class NoticeTimeRunnable implements Runnable{

        public void run() {
            while (true){
                try {
                    Thread.sleep(50);
                    if (System.currentTimeMillis() - lastHeartTime > 1000){
                        isHearting = false;
                        closeResources();
                        return;
                    }
                    lastHeartTime = System.currentTimeMillis();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public String getClientName() {
        return clientName;
    }

}

3、两个客户端代码大同小异Client和Client02：

package edu.gj.demo;

import com.google.gson.Gson;
import org.json.JSONObject;

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

/**
 * @author Simple
 * @date 2020/4/16 13:55
 */
public class Client {

    public static void main(String[] args) throws IOException {


        Socket socket = new Socket("localhost", 8080);
        final PrintStream printStream = new PrintStream(new BufferedOutputStream(socket.getOutputStream()));
        final BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        MessageBean messageBean = new MessageBean();
        messageBean.setType(1);
        messageBean.setUserName("client");
        printStream.println(new Gson().toJson(messageBean));
        printStream.flush();
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    try {
                        Thread.sleep(2 * 60 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    MessageBean messageBean = new MessageBean();
                    messageBean.setType(0);
                    messageBean.setContent("心跳消息");
                    printStream.println(new Gson().toJson(messageBean));
                    printStream.flush();
                }
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                while (true) {
                    try {
                        String message = reader.readLine();
                        MessageBean messageBean = new Gson().fromJson(message, MessageBean.class);
                        if (messageBean.getType() == 2) {
                            //系统分发：
                            System.out.println("系统消息：" + messageBean.getContent());
                        } else if (messageBean.getType() == 3) {
                            //点对点消息
                            System.out.println("收到来自：" + messageBean.getSender() + "的消息：" + messageBean.getContent());
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        return;
                    }
                }
            }
        }).start();


        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            MessageBean messageBeanSend = new MessageBean();
            messageBeanSend.setType(3);
            messageBeanSend.setContent(scanner.nextLine());
            messageBeanSend.setSender("client");
            messageBeanSend.setTo("client2");
            printStream.println(new Gson().toJson(messageBeanSend));
            printStream.flush();
        }

    }


}

package edu.gj.demo;

import com.google.gson.Gson;
import org.json.JSONObject;

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

/**
 * @author Simple
 * @date 2020/4/16 13:55
 */
public class Client02 {

    public static void main(String[] args) throws IOException {


        Socket socket = new Socket("localhost", 8080);
        final PrintStream printStream = new PrintStream(new BufferedOutputStream(socket.getOutputStream()));
        final BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        MessageBean messageBean = new MessageBean();
        messageBean.setType(1);
        messageBean.setUserName("client2");
        printStream.println(new Gson().toJson(messageBean));
        printStream.flush();
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    try {
                        Thread.sleep(2 * 60 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    MessageBean messageBean = new MessageBean();
                    messageBean.setType(0);
                    messageBean.setContent("心跳消息");
                    printStream.println(new Gson().toJson(messageBean));
                    printStream.flush();
                }
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                while (true) {
                    try {
                        String message = reader.readLine();
                        MessageBean messageBean = new Gson().fromJson(message, MessageBean.class);
                        if (messageBean.getType() == 2) {
                            //系统分发
                            System.out.println("系统消息：" + messageBean.getContent());
                        } else if (messageBean.getType() == 3) {
                            //点对点消息
                            System.out.println("收到来自：" + messageBean.getSender() + "的消息：" + messageBean.getContent());
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        return;
                    }
                }
            }
        }).start();


        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            MessageBean messageBeanSend = new MessageBean();
            messageBeanSend.setType(3);
            messageBeanSend.setContent(scanner.nextLine());
            messageBeanSend.setSender("client2");
            messageBeanSend.setTo("client");
            printStream.println(new Gson().toJson(messageBeanSend));
            printStream.flush();
        }

    }

}

4、服务端Server代码：

package edu.gj.demo;

import com.google.gson.Gson;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Simple
 * @date 2020/4/16 13:48
 */
public class Server {
    private static List<ServerThread> serverThreads = new ArrayList<ServerThread>();

    public static void main(String[] args) throws IOException {

        int count = 0;

        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("Server is start");
        while (true) {
            count++;
            Socket socket = serverSocket.accept();
            System.out.println("accept client count:"+count);
            ServerThread serverThread = new ServerThread(socket);
            serverThreads.add(serverThread);
            serverThread.start();
        }
    }


    public static void sendMessage(MessageBean messageBean){
        for (ServerThread serverThread :
                serverThreads) {
            if (serverThread.getClientName().equals(messageBean.getTo())){
                serverThread.sendMessage(new Gson().toJson(messageBean));
            }
        }
    }


}

5、启动：
先启动Server，接着启动客户端Client和客户端Client02
启动后在Client控制台输入你好，再在客户端Client02控制台输入你好，日志如下：
服务器：
日志3
Client:
日志4
Client02:
日志5

源码

源码链接： Demo源码

总结

1、以前总觉得Socket很神秘，玩不转，其实不是那么回事，只是自己没有仔细研究而已。
2、多思考，思路很重要。
3、这里只是抛砖引玉，实现了简单的通信过程，难免有考虑不周或者思维局限。
MakerGaoGao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Socket通信实现
qq_34219506的博客
02-10 292
一、利用Java的Socket实现简单的服务器 实现客户端将控制台输入的信息发送给服务器 服务器将接收的到客户端的信息返回给客户端 客户端再将服务器端返回的数据打印在控制台实现原理：服务器：new一个ServerSocket对象serverSocket，并且设置其端口号（端口号要保证没有被占用），调用serverSocket对象的accept()方法，返回一个Socket对象socket,当代码执...
Java Socket通讯
brushli的专栏
10-25 829
Socket（套接字）是基于客户端/服务器架构下的一种通讯服务。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl
java实现Socket客户端向服务端发送信息
一个摩羯座的程序猿
06-17 9762
Socket什么是socket？socket字面意思其实就是一个插口或者套接字，包含了源ip地址、源端口、目的ip地址和源端口。 但是socket在那个位置呢 ，在TCP/IP网络的四层体系和OSI七层好像都找不到他的影子，如下图所示， Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。一般由操作系统
java socket 客户端接收_java socket多客户端简单示例
weixin_28822657的博客
02-24 564
因为有多线程的存在，所以当连接请求到达时，可以在服务端创建多个socket，分别和不同的客户端进行连接通信。服务端SocketServerRelease 用于不断接收客户端的连接，并创建socketpublic class SocketServerRelease extends Thread{public static ServerSocket server = null;static{try ...
10.Java 利用Socket发送和接收对象
c1776167012的博客
11-05 1517
关键点在于使用： ObjectOutputStream和ObjectInputStream这两个类具体代码如下： 一共三个类 2.客户端 3.实体类 运行效果如下： 代码地址： https://gitee.com/yan-jiadou/study/tree/master/Java%E5%8A%A8%E6%89%8B%E5%81%9A%E4%B8%80%E5%81%9A/src/main/java/InternetCode/Socket...
java使用socket发送邮件
liouwb的博客
07-11 689
java使用socket发送邮件 package com.abke.email.utils; import java.io.*; import java.net.Socket; /** * @author liouwb */ public class SendMailUtil { public static void main(String[] arg) { String email = "liou@163.com"; sendMail(email,"smt
Java实现socket通信详解(UDP/TCP)c/s模式
weixin_49862595的博客
10-29 6288
Java实现socket通信详解(UDP/TCP)c/s模式超详细！
Java Socket 通信
02-27
Java Socket通信是网络编程中的重要一环，它提供了在两台计算机之间建立低级连接的能力，使得数据可以在两个应用程序之间双向传输。在这个过程中，一台计算机作为服务器（Server），等待客户端（Client）的连接请求...
java Socket通信实现.zip
08-27
Java Socket通信是网络编程中的基础概念，主要用于两台计算机之间的数据传输。Socket在Java中被封装为类，提供了客户端和服务器端进行双向通信的能力。在这个"java Socket通信实现.zip"的压缩包中，可能包含了关于...
java Socket通信实现
06-06
Java Socket通信实现是Java网络编程中的重要组成部分，它允许两台计算机通过TCP/IP协议进行双向通信。在Java中，Socket提供了低级别的、基于连接的、面向数据流的通信API，可以用于实现客户端-服务器架构的应用程序...
基于SOCKET的端到端通信实现
12-06
了解Socket的实现，里面包含源文件和文档之类的，齐全！！
UDP 实现端到端的通讯，两者之间绑定IP 端口
08-02
绑定IP 和 客户端的 UDP 通讯 ，可以建两个相同的工程，互相对发（修改下绑定的IP 和端口） 详细介绍见https://mp.csdn.net/postedit/81352132
JAVA与android之间通过socket通信
11-17
java作为客户端，android作为服务端，通过socket通信。
java Socket通信实现.rar
05-17
Java Socket通信实现是Java网络编程中的重要组成部分，它允许两个应用程序通过网络进行双向通信。Socket在TCP/IP协议栈中扮演着客户端与服务器端交互的角色，提供了低级别的、面向连接的、可靠的字节流通信。本代码...
深入理解Java Socket通信
08-31
本文将深入探讨Java Socket通信的核心概念，包括ServerSocket和Socket的使用，以及TCP/IP协议在其中的角色。 首先，Java中的Socket可以分为普通Socket和NioSocket两种类型。普通Socket基于传统的I/O模型，而Nio...
TCP网络编程
weixin_45673116的博客
04-02 74
//因方便查看，所以未使用try-catch，将评论中补充 import org.junit.Test; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; /** * @author * @date 2021/4/2 1
Socket编程
一个后端菜鸟的博客
12-28 363
文章目录一、Socketbc编程1.IP和端口号（组成网络）2.Tcp与UDP概念3.Socket编程原理4.代码5.UDP程序的原理6.主要类的方法7、代码具体实现8、UDP对聊总结 一、Socketbc编程 public class ServerSocket extends Object implements Closeable 这个类实现了服务器套接字。 服务器套接字等待通过网络进入的请求。 它根据该请求执行一些操作，然后可能将结果返回给请求者。 服务器套接字的实际工作由SocketImpl类的实.
【Java学习笔记】——网络编程
qq_52970412的博客
11-02 120
【Java学习笔记】———网络编程
Socket网络聊天室（续）
weixin_44482951的博客
10-13 98
接之前的聊天室
java socket通信
最新发布
09-21
Java中的Socket通信是一种基于网络的通信方式，可以实现进程间的数据交换和通信。下面是一个简单的Java Socket通信的示例代码： ```java // 服务器端 import java.io.IOException; import java.io.InputStream; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值