AI 助理
备案控制台
开发者社区 云计算 文章 正文

计算机网络实验socket通信

2024-03-04 45
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 计算机网络实验socket通信

先上运行截图

1，运行服务端：

2，运行客户端，与服务端建立连接：

3，连接成功，发送消息：

4，客户端向服务端定期发送心跳包保持连通性：

接下来上代码：

1，服务端

package socket.ab;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
public class Server {
  //创建集合对象
  public static List<MyChannel> list=new ArrayList<MyChannel>();
  public static void main(String[] args) {
    try {
      System.out.println("服务器开始运行");
      ServerSocket serverSocket=new ServerSocket(8080);
      while(true) {
        Socket socket=serverSocket.accept();//接收客户请求
        
        //一个客户机与服务器通信
        //new Thread(new Listen(socket)).start();
        //new Thread(new Send(socket)).start();
        
        //服务器用于交换消息，创建线程类对象
        MyChannel channel=new MyChannel(socket);
        //添加到集合
        list.add(channel);
        if(list != null) {
          System.out.println("服务器收到"+channel+"连接");
        }
        
        new Thread(channel).start();
        
      }
    } catch (IOException e) {
      // TODO 自动生成的 catch 块
      e.printStackTrace();
    }
  }
}

2，集合对象

package socket.ab;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.List;
public class MyChannel implements Runnable{
  private Socket socket;
  private boolean flag=true;
  private ObjectInputStream ois;
  private ObjectOutputStream oos;
  //初始化
  public MyChannel(Socket socket){
    this.socket=socket;
    try {
      ois=new ObjectInputStream(socket.getInputStream());//获取输入流
      oos=new ObjectOutputStream(socket.getOutputStream());//获取输出流
    } catch (IOException e) {
      // TODO 自动生成的 catch 块
      e.printStackTrace();
      flag=false;
      try {
        socket.close();
      } catch (IOException e1) {
        // TODO 自动生成的 catch 块
        e1.printStackTrace();
      }
    }
  }
  //接收数据方法
  private String receive(){
    String str="";
    try {
      str=ois.readUTF();
      if(str.equals("我是心跳包")) {
        System.out.println(str);
      }
    } catch (IOException e) {
      System.out.println("断开连接");
      flag=false;
      try {
        socket.close();
      } catch (IOException e1) {
        Server.list.remove(this);
      }
    }
    return str;
  }
  //发送数据方法
  private void send(String str) {
    if(str!=null&&str.length()!=0) {
      if(!str.equals("我是心跳包")) {
        try {
          oos.writeUTF(str);
          oos.flush();
        } catch (IOException e) {
          flag=false;
          try {
            socket.close();
//            Server.list.remove(this);
          } catch (IOException e1) {
//            Server.list.remove(this);
          }
        }
      }
    }
  }
  //转发
  private void sendOther() {
    String str=this.receive();
    List<MyChannel> list=Server.list;
    if(list.size()>1) {
      for(MyChannel other :list) {
        if(other==this) {
          continue;//不发给自己
        }
        other.send(str);
      }
    }
  }
  @Override
  public void run() {
    // TODO 自动生成的方法存根
    while(flag) {
      //this.send(receive());
      sendOther();
    }
  }
}

3，send方法

package socket.ab;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;
public class Send implements Runnable{
  private Socket socket;
  private ObjectOutputStream oos;
  public static String name="";
  Send(Socket socket,String name,ObjectOutputStream oos){
    this.socket=socket;
    Send.name=name;
    this.oos=oos;
  }
  String str="";
  @Override
  public void run() {
    // TODO 自动生成的方法存根
    try {
      while(true) {
          Thread.sleep(1000);
          oos.writeUTF(Frame.text);
          oos.flush();
          Frame.text="";
      }
    } catch (IOException | InterruptedException e) {
      System.out.println("发送失败");
    }
  }
  
}

4，listen方法

package socket.ab;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
public class Listen implements Runnable{
  private Socket socket;
  //初始化
  Listen(Socket socket){
    this.socket=socket;
  }
  @Override
  public void run() {
    // TODO 自动生成的方法存根
    try {
      //获取输入流
      ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());
      while(true) {
        String read=ois.readUTF();
        Frame.jtx.append(Frame.date()+"\n"+"收到"+read+"\n");
//        System.out.println("收到"+ois.readUTF());
      }
    } catch (IOException e) {
      System.out.println("接收失败");
      Client.connet_state=false;
      Client.reconnet();
    }finally {
      try {
        socket.close();
      } catch (IOException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
      }
    }
  }
}

5，客户端

package socket.ab;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
  private static Socket socket;
  private static ObjectOutputStream oos;
  public static boolean connet_state=false;
  public static String name=Frame.tit;
//  static String[] arrays=new String[5];
  
  public static void main(String[] args) {
    new Frame();
    System.out.println(name+"连接到服务器");
    connet();
    if(connet_state) {
      try {
        oos=new ObjectOutputStream(socket.getOutputStream());
        new Thread(new Listen(getSocket())).start();
        new Thread(new Send(getSocket(),name,oos)).start();
        new Thread(new HeartBeat(getSocket(),oos)).start();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
  private static void connet() {
    try {
      setSocket(new Socket("127.0.0.1",8080));
      connet_state=true;
    } catch (UnknownHostException e) {
      // TODO 自动生成的 catch 块
      e.printStackTrace();
      connet_state=false;
    } catch (IOException e) {
      // TODO 自动生成的 catch 块
      e.printStackTrace();
      connet_state=false;
    }
  }
  public static void reconnet() {
    while(!connet_state) {
      System.out.println("尝试重新连接...");  
      try {
        connet();
        Thread.sleep(5000);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
    if(connet_state) {
      try {
        oos=new ObjectOutputStream(socket.getOutputStream());
        new Thread(new Listen(getSocket())).start();
        new Thread(new Send(getSocket(),name,oos)).start();
        new Thread(new HeartBeat(getSocket(),oos)).start();
        System.out.println("重连成功");
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
  public static Socket getSocket() {
    return socket;
  }
  public static void setSocket(Socket socket) {
    Client.socket = socket;
  }
}

6，界面显示

package socket.ab;
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.ScrollPaneConstants;
public class Frame extends java.awt.Frame implements Runnable{
  public static JTextArea jtx=new JTextArea(200,150);
  public static TextField tf=new TextField(30);
  public Frame() {
    initFrame();
    initEventListner();
  }
  public static String text="";
  public static String tit="用户"+new Random().nextInt(900)+100;
  public static String tit2=tit;
//  public static String getTit() {
//    return tit;
//  }
  public static boolean sendflag=true;
//  public static String getText() {
//    return text;
//  }
  private void initFrame() {
    setTitle(tit);
    setSize(600, 500);
    setLocation(new Random().nextInt(500)+100, new Random().nextInt(900)+100);
    setResizable(false);
    Panel p=new Panel();
    
    setLayout(new BorderLayout());
    //滚动条
    JScrollPane j=new JScrollPane();
    j.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
    j.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
//    JTextArea jtx=new JTextArea(200,150);
    jtx.setFocusable(false);
    j.setViewportView(jtx);
    add(j,BorderLayout.CENTER);
    p.setLayout(new FlowLayout());
    add(p,BorderLayout.SOUTH);
    
    Button btn=new Button("发送");
    
    tf.requestFocus();
    p.add(tf);
    p.add(btn);
    btn.addActionListener(new ActionListener() {
      
      @Override
      public void actionPerformed(ActionEvent e) {
        // TODO 自动生成的方法存根
//        if(text!=null && !text.trim().equals("")) {
          text=Send.name+":"+tf.getText();
          jtx.append(date()+"\n");
          jtx.append("我发送了："+tf.getText()+"\n");
          sendflag=true;
          tf.setText("");
//        }
      }
    });
    
    setVisible(true);
    repaint();
    
  }
  public static String date() {
    Date time=new Date();
    SimpleDateFormat format=new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
    return "----------"+format.format(time);
    
  }
  private void initEventListner() {        
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
                System.exit(0);
           }
        });
    }
  @Override
  public void run() {
    // TODO 自动生成的方法存根
    new Frame();
  }
}

7，心跳包测试

package socket.ab;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
public class HeartBeat implements Runnable{
  private Socket socket;
  private ObjectOutputStream oos;
  public static String heart="我是心跳包";
  public HeartBeat(Socket socket,ObjectOutputStream oos){
    this.socket=socket;
    this.oos=oos;
  }
  
  @Override
  public void run() {
    // TODO Auto-generated method stub
    System.out.println("心跳包线程已启动...");
    try {
      while(true) {
        Thread.sleep(5000);
        oos.writeUTF(heart);
//        oos.flush();
      }
      
    } catch (InterruptedException | IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      Client.connet_state=false;
      Client.reconnet();
    }
  }
}

点赞支持一下吧~

关键词：
网络通信
计算机网络通信
网络socket
socket通信
网络实验
达芬奇要当程序员
目录
相关文章
jsjsjjs
|
1月前
|
负载均衡 网络协议 算法
不为人知的网络编程(十九)：能Ping通，TCP就一定能连接和通信吗？
这网络层就像搭积木一样，上层协议都是基于下层协议搭出来的。不管是ping（用了ICMP协议）还是tcp本质上都是基于网络层IP协议的数据包，而到了物理层，都是二进制01串，都走网卡发出去了。 如果网络环境没发生变化，目的地又一样，那按道理说他们走的网络路径应该是一样的，什么情况下会不同呢？ 我们就从路由这个话题聊起吧。
jsjsjjs
65 4
不为人知的网络编程(十九)：能Ping通，TCP就一定能连接和通信吗？
sunrr
|
2月前
|
安全 搜索推荐 网络安全
HTTPS协议是**一种通过计算机网络进行安全通信的传输协议
HTTPS协议是**一种通过计算机网络进行安全通信的传输协议
sunrr
86 11
Skyund
|
2月前
|
网络协议
计算机网络与通信
计算机网络基本概念：了解计算机网络的定义、功能、分类和拓扑结构（如总线型、星型、环型、树形、网状等）。 网络通信原理：了解网络通信的基本原理、协议和技术，如TCP/IP协议、网络通信设备等。
Skyund
37 3
XIAZHI
|
2月前
|
算法
数据结构之卫星通信网络（BFS）
本文介绍了卫星通信网络及其重要性，并探讨了广度优先搜索（BFS）算法在其中的应用。卫星通信网络通过在轨卫星提供全球覆盖的通信服务，尤其在偏远地区和紧急救援中发挥关键作用。BFS算法用于网络拓扑分析、路径规划和故障排除，确保通信网络的高效运行。文章还包括BFS算法的工作原理、特点、优缺点及其实现代码示例。
XIAZHI
64 1
wljslmz
|
2月前
|
传感器 自动驾驶 物联网
探秘 5G 核心网络之 5G RAN：开启高速通信新时代
探秘 5G 核心网络之 5G RAN：开启高速通信新时代
wljslmz
87 4
一位隐者
|
2月前
|
物联网 5G 数据中心
光纤连接器：现代通信网络的隐形英雄
【10月更文挑战第23天】
一位隐者
95 3
一位隐者
|
2月前
|
网络协议 算法 数据库
OSPF 与 BGP 的互操作性：构建复杂网络的通信桥梁
OSPF 与 BGP 的互操作性：构建复杂网络的通信桥梁
一位隐者
60 0
一位隐者
|
2月前
|
边缘计算 5G 数据处理
5G网络能耗管理：绿色通信的实践
【10月更文挑战第30天】
一位隐者
58 0
qhhf_地道酬勤
|
2月前
|
存储 缓存 网络协议
计算机网络常见面试题（二）：浏览器中输入URL返回页面过程、HTTP协议特点，GET、POST的区别，Cookie与Session
计算机网络常见面试题（二）：浏览器中输入URL返回页面过程、HTTP协议特点、状态码、报文格式，GET、POST的区别，DNS的解析过程、数字证书、Cookie与Session，对称加密和非对称加密
qhhf_地道酬勤
182 2
qhhf_地道酬勤
|
2月前
|
网络协议 算法 网络性能优化
计算机网络常见面试题（一）：TCP/IP五层模型、TCP三次握手、四次挥手，TCP传输可靠性保障、ARQ协议
计算机网络常见面试题（一）：TCP/IP五层模型、应用层常见的协议、TCP与UDP的区别，TCP三次握手、四次挥手，TCP传输可靠性保障、ARQ协议、ARP协议
qhhf_地道酬勤
127 2

热门文章

最新文章

  • 1
    阿里云先知安全沙龙(武汉站) - 网络空间安全中的红蓝对抗实践
  • 2
    TCP报文格式全解析：网络小白变高手的必读指南
  • 3
    云原生应用网关进阶：阿里云网络ALB Ingress 全能增强
  • 4
    基于改进遗传优化的BP神经网络金融序列预测算法matlab仿真
  • 5
    Linux网络文件系统NFS：配置与管理指南
  • 6
    网络安全视角：从地域到账号的阿里云日志审计实践
  • 7
    什么是零信任模型？如何实施以保证网络安全？
  • 8
    基于AI的网络流量分析：构建智能化运维体系
  • 9
    动态IP代理技术详解及网络性能优化
  • 10
    揭示Transformer重要缺陷！北大提出傅里叶分析神经网络FAN，填补周期性特征建模缺陷
  • 1
    在Python中，我们使用`socket`模块来进行网络通信。首先，我们需要导入这个模块。
    44
  • 2
    Java面试题：简述Java Socket编程的基本流程，包括客户端和服务器的创建与通信。
    117
  • 3
    Java中的网络编程：Socket编程详解
    70
  • 4
    Java中的Socket编程与应用
    41
  • 5
    ERR_SOCKET_TIMEOUT Socket timeout
    54
  • 6
    深入了解Java中的网络编程与Socket通信
    50
  • 7
    Java中的网络编程：Socket编程详解
    198
  • 8
    Java中的Socket编程与应用
    35
  • 9
    Java网络编程基础与Socket实现技术
    33
  • 10
    Socket网络编程实战指南
    172

    • 相关课程

    更多
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 云网络白皮书-阿里云网络系列课
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 计算机网络基础
  • 网络管理者必知-2分钟了解新出台的《网络安全法》

    • 相关电子书

    更多
  • Session：更加安全、可靠的数据中心网络产品更新
  • Session：极简易用的全球化网络产品更新
  • Session：弹性、高可用、可观测的应用交付网络产品更新

    • 相关实验场景

    更多
  • 使用Java面向对象编写网络通信程序应用
  • 容器的网络入门
  • 容器的自定义网络
  • 容器的共享网络模型
  • 使用阿里云容器服务和容器网络文件系统搭建WordPress网站
    • 下一篇
    阿里云开通OSS存储服务详细流程