精华内容
下载资源
问答
  • 基于JAVA局域网广播系统毕业设计
    2021-03-13 22:52:29

    1功能概述

    该系统是一个基于局域网的广播系统,使用了多点广播这种相当新的技术,可以将信息发送给那些等待接收信息的接收者,有服务器端和客户端两部分,由服务器端进行广播,服务器端循环播放选定的文件,每隔几秒钟播放一条消息,为用户学习及资源共享提供网络上的便利。客户端只需运行相应的客户端程序,就可以接收到服务器广播的信息,客户端可以随时开始或停止接收广播。同时,局域网内的任意节点均可将本地时间与服务器端时间同步。这种小型系统轻巧实用,可移植性好,在网络学习上利用的非常广泛。

    3.2.2功能划分

    (1)文件选择、广播时间及接收时间控制:

    服务器端可选择要广播的文件,控制广播的开始和结束,客户端可控制解手广播的开始和结束。

    (2)广播内容显示:

    服务器可显示已广播的内容、正在广播的内容、客户端则可显示已接收的内容和正在接收的内容。

    (3)数据发送:

    服务器端可读取所广播文件的内容,将其打包并发送出去,同样,还必须获取本地系统时间和日期,打包再发送。

    (4)数据接收:

    客户端可接收数据报,将数据还原并显示在文本框中。

    (5)时间同步:

    客户端将获取的表示时间日期的数据报作为参数,以此来设置本地时间和日期。

    3.3模块划分及功能分析

    设计系统的功能模块如下:

    服务器端:

    (1) 选择文件、开始及停止广播模块

    ① 选择所要播放的文件

    ② 开始广播

    ③ 停止广播

    (2) 文本显示模块

    ① 显示正在播放的内容

    ② 显示已经播放的内容

    (3) 本地时间日期处理模块

    ① 获取当前服务器时间日期

    ② 将时间日期格式化

    ③ 给格式化后的时间日期加标志

    (4) 广播套接字及广播范围模块

    ① 确定组播地址及端口号

    ② 设定数据报的生存期

    ③ 将套接字加入到同一组中

    (5) 数据打包发送模块

    ① 数据打包并发送

    客户端:

    (1) 接收时间控制模块

    ① 开始接收数据

    ② 停止接收数据

    (2) 接收内容显示模块

    ① 显示正在接收的内容

    ② 显示已经接收的内容

    (3) 包的接收及处理模块

    ① 获取数据包

    ② 将数据包中的数据还原

    ③ 根据标志将时间日期包和普通包分离

    (4) 时间同步

    ① 去除时间日期标志

    ② 设置本地时间日期

    模块的具体功能如下:

    (1) 选择文件、开始及停止广播模块

    ① 选择文件

    主要功能:在本地计算机上选择一个要广播的文件

    ② 开始及停止广播

    主要功能:激发一个事件,服务器端开始广播或停止广播数据

    (2) 文本显示模块

    ① 正在接收内容显示区

    主要功能:显示当前正在接收的内容,时间日期信息除外

    ② 已经接收内容显示区

    主要功能:将目前为止已接收的所有信息显示出来,时间日期信息除外

    (3) 本地时间日期处理模块

    ① 时间获取

    主要功能:调用系统函数,将当前的时间日期存放到一个类对象中

    ② 时间日期的格式化

    主要功能:分别给时间和日期规定一种格式 ,如日期格式为"yyyy-MM-dd",时间的格式为"HH:mm:ss",并将类对象中的数据按这种格式格式化

    ③ 区分格式化后的日期和时间字符串

    主要功能:将格式化后的数据加上标志,如时间字符串前加"t",日期字符串前加"d"

    (4) 组播设置模块

    主要功能: 用一个D类地址建立一个组播组,创建一个固定端口上的多点广播套接字,并将套接字加入到组中,做好广播数据报的前期工作;设置数据报的生存期——局域网范围内。

    (5) 数据打包和发送模块

    主要功能:将字符串中的数据存放到字节数组中,然后创建在指定地址,指定端口上广播的数据报,然后再利用多点广播套接字将数据包发送出去。

    (6) 接收时间控制模块

    主要功能:任意控制客户端接收时间。

    ① 开始接收数据。启动线程,开始接收数据报。

    ② 停止接收数据。中断线程,不再接收数据。

    (7) 接收内容显示模块

    主要功能:显示已接收和正在接收的内容。

    ① 正在接收。将前一条内容清空,显示当前接收的非时间日期数据。

    ② 已经接收。将当前接收的非时间日期数据加入到文本中。

    (8) 数据报的接收及处理模块

    主要功能:创建多点广播套接字,从组播组中接收数据报,并将数据报还原为字符串,判断字符串的起始标志,筛选出表示时间的字符串、表示日期的字符串以及其他普通的串,如以"t"开头的串表示时间,以"d"开头的串表示日期。

    (9) 时间同步模块

    主要功能:将收到的时间日期包中的数据设置为本地系统时间。

    ① 去除时间日期标志模块

    主要功能:将表示时间和日期的字符串去除标志,如将表示时间的串中的标志"t"去除,将新的串存放至字符串中;同样,将表示日期的串中的标志"d"去除,将新串放至字符串中备用。将MS-DOS下命令"cmd /c time "或"cmd /c date "作为字符串和前面分离出来的子串合并。

    ② 设置本地时间日期模块

    主要功能:利用系统函数调用MS-DOS下设置系统时间,日期的命令改变当前系统的时间日期。

    以上是大纲或介绍,如需要完整的资料或者如不符合您的要求,请联系技术人员qq:58850198咨询

    更多相关内容
  • java局域网广播系统

    2022-04-07 16:47:00
    /* * To change this template, choose Tools | Templates * and open the template in the editor. ...import java.net.*; import java.awt.*; import java.awt.event.*; public class Receive extends Frame i.
    /*
     * To change this template, choose Tools | Templates
     * and open the template in the editor.
     */
    
    package client;
    
    /**
     *
     * @author Administrator
     */
    import java.net.*;
    import java.awt.*; 
    import java.awt.event.*;
    
    public class Receive extends Frame implements Runnable,ActionListener
    { 
      int port;                                        
      InetAddress group=null;                          
      MulticastSocket socket=null;                     
      Button 开始接收,停止接收;   
      TextArea 显示正在接收内容,显示已接收的内容;  
      Thread thread;                                   
      boolean 停止=false;
      public Receive()
       { 
         super("定时接收信息");
         thread=new Thread(this);
         开始接收=new Button("开始接收");
         停止接收=new Button("停止接收");
         停止接收.addActionListener(this); 
         开始接收.addActionListener(this); 
         显示正在接收内容=new TextArea(10,10);
         显示正在接收内容.setForeground(Color.blue); 
         显示已接收的内容=new TextArea(10,10);
         Panel north=new Panel();
         north.add(开始接收);
         north.add(停止接收);
         add(north,BorderLayout.NORTH);
         Panel center=new Panel();
         center.setLayout(new GridLayout(1,2)); 
         center.add(显示正在接收内容);
         center.add(显示已接收的内容);
         add(center,BorderLayout.CENTER);
         validate();
         port=5000;                                       
         try{
             group=InetAddress.getByName("239.255.0.0");  
             socket=new MulticastSocket(port);            
             socket.joinGroup(group);           
                                                
           }
        catch(Exception e)
           {
           } 
       setBounds(100,50,360,380);   
       setVisible(true);
       addWindowListener(new WindowAdapter()
                         { public void windowClosing(WindowEvent e)
                           { System.exit(0);
          	               }
          	             });
                                
       }
      public void actionPerformed(ActionEvent e)
       {
        if(e.getSource()==开始接收)
          {
            开始接收.setBackground(Color.blue);
            停止接收.setBackground(Color.gray);
            if(!(thread.isAlive()))
               {
                 thread=new Thread(this);
               }
            try
               {
                 thread.start(); 
                 停止=false;        
               }
            catch(Exception ee)
               {
               }
          }
        if(e.getSource()==停止接收)
          {
            开始接收.setBackground(Color.gray);
            停止接收.setBackground(Color.blue);
            thread.interrupt(); 
            停止=true; 
          }
       }
    
      public void run()
      {
       
        while(true)   
        {  
           byte data[]=new byte[8192];
           DatagramPacket packet=null;
           packet=new DatagramPacket(data,data.length,group,port);  
           try
               {  
                 socket.receive(packet);
                 String message=new String(packet.getData(),0,packet.getLength());
                 显示正在接收内容.setText("正在接收的内容:\n"+message);
                 显示已接收的内容.append(message+"\n");
               }
          catch(Exception e)
               {
               }
          if(停止==true)
               {
                 break;
               } 
        } 
      }
     
     public static void main(String args[])
     { 
        new Receive();
     }
    } 
    
    /*
     * To change this template, choose Tools | Templates
     * and open the template in the editor.
     */
    
    package server;
    
    /**
     *
     * @author Administrator
     */
    import java.io.*;
    import java.net.*;
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.Timer;
     
    public class BroadCastWord extends Frame implements ActionListener
    {   
       int port;                                        
       InetAddress group=null;                          
       MulticastSocket socket=null;                     
       Timer time=null;                                 
       FileDialog open=null;                            
       Button select,开始广播,停止广播;
       File file=null;                                  
       String FileDir=null,fileName=null;
       FileReader in=null;                              
       BufferedReader bufferIn=null;
       int   token=0;                                   
       TextArea 显示正在播放内容,显示已播放的内容;       
      public BroadCastWord()
      {
       super("单词广播系统");
       select=new Button("选择要广播的文件");
       开始广播=new Button("开始广播");
       开始广播.setEnabled(false);
       停止广播=new Button("停止广播");
       select.addActionListener(this); 
       开始广播.addActionListener(this); 
       停止广播.addActionListener(this); 
       time=new Timer(2000,this);                       
       open=new FileDialog(this,"选择要广播的文件",FileDialog.LOAD);  
       显示正在播放内容=new TextArea(10,10);
       显示正在播放内容.setForeground(Color.blue); 
       显示已播放的内容=new TextArea(10,10);
       Panel north=new Panel();
       north.add(select);
       north.add(开始广播);
       north.add(停止广播);
       add(north,BorderLayout.NORTH);
       Panel center=new Panel();
       center.setLayout(new GridLayout(1,2)); 
       center.add(显示正在播放内容);
       center.add(显示已播放的内容);
       add(center,BorderLayout.CENTER);
       validate();
       try 
          {
           port=5000;                                   
           group=InetAddress.getByName("239.255.0.0");  
           socket=new MulticastSocket(port);            
           socket.setTimeToLive(1);                     
           socket.joinGroup(group);                     
                                                       
          } 
      catch(Exception e)
           {
             System.out.println("Error: "+ e);          
           }
      setBounds(100,50,360,380);   
      setVisible(true);
      addWindowListener(new WindowAdapter()
                         { public void windowClosing(WindowEvent e)
                           { System.exit(0);
          	               }
          	             });
     }
     public void actionPerformed(ActionEvent e)
     {
       if(e.getSource()==select)
         {
          显示已播放的内容.setText(null);
          open.setVisible(true);
          fileName=open.getFile();
          FileDir=open.getDirectory(); 
          if(fileName!=null)
           { 
             time.stop();                                                
             file=new File(FileDir,fileName);
             try
                {
                   file=new File(FileDir,fileName);
                   in=new FileReader(file);                      
                   bufferIn=new BufferedReader(in);
                   开始广播.setEnabled(true);  
                }
             catch(IOException ee)
                {
                }
           }
         }
       else if(e.getSource()==开始广播)
         {
            time.start();
         }
       else if(e.getSource()==time)
         {
           String s=null;
            try
                {  
                  if(token==-1)
                     {
                       file=new File(FileDir,fileName);
                       in=new FileReader(file);                      
                       bufferIn=new BufferedReader(in);
                     }
                  s=bufferIn.readLine();
                  if(s!=null)
                    {
                      token=0;
                      显示正在播放内容.setText("正在广播的内容:\n"+s);
                      显示已播放的内容.append(s+"\n");
                      DatagramPacket packet=null;                               
                      byte data[]=s.getBytes(); 
                      packet=new DatagramPacket(data,data.length,group,port); 
                      socket.send(packet);                                      
                    }
                  else
                    {
                      token=-1;
                    }
                }
            catch(IOException ee)
                {
                }
         }
       else if(e.getSource()==停止广播)
         {
           time.stop();
         }
     }
                                             
     public static void main(String[] args) 
       {
          BroadCastWord broad=new BroadCastWord();
       }
    }

    展开全文
  • JAVA0003JAVA局域网广播系统参考.pdf
  • JAVA0003JAVA局域网广播系统.pdf
  • JAVA0003JAVA局域网广播系统终稿.pdf
  • JAVA0003JAVA局域网广播系统实用.pdf
  • JAVA0003JAVA局域网广播系统剖析.pdf
  • 局域网广播系统java源码.rar
  • 使用UDP协议进行信息的传输之前不需要建议连接。换句话说就是客户端向服务器发送信息,客户端只需要给出服务器的ip地址和端口号,然后将信息封装到一个待发送的报文中并且...对于广播,网络中的所有主机都会接收一份...

    使用UDP协议进行信息的传输之前不需要建议连接。换句话说就是客户端向服务器发送信息,客户端只需要给出服务器的ip地址和端口号,然后将信息封装到一个待发送的报文中并且发送出去。至于服务器端是否存在,或者能否收到该报文,客户端根本不用管。

    通常我们讨论的udp的程序都是一对一的单播程序。本章将讨论一对多的服务:广播(broadcast)、多播(multicast)。对于广播,网络中的所有主机都会接收一份数据副本。对于多播,消息只是发送到一个多播地址,网络知识将数据分发给哪些表示想要接收发送到该多播地址的数据的主机。总得来说,只有UDP套接字允许广播或多播。

    UDP广播

    广播UDP与单播UDP的区别就是IP地址不同,广播使用广播地址255.255.255.255,将消息发送到在同一广播网络上的每个主机。值得强调的是:本地广播信息是不会被路由器转发。当然这是十分容易理解的,因为如果路由器转发了广播信息,那么势必会引起网络瘫痪。这也是为什么IP协议的设计者故意没有定义互联网范围的广播机制。

    广播地址通常用于在网络游戏中处于同一本地网络的玩家之间交流状态信息等。广播就不在写演示程序了,读者可以将ECHO程序的ip地址改为广播地址即可。

    其实广播顾名思义,就是想局域网内所有的人说话,但是广播还是要指明接收者的端口号的,因为不可能接受者的所有端口都来收听广播。

    UDP多播

    同样的UDP多播也要指明接受者的端口号,而且与广播相似的是多播与单播之间的区别还在于地址。ipv4中的多播地址范围是:224.0.0.0到239.255.255.255。在JAVA中,多播一样十分好实现,要实现多播,就要用到MulticastSocket类,其实该类就是DatagramSocket的子类,在使用时除了多播自己的一些特性外,把它当做DatagramSocket类使用就可以了。

    使用java 的UDP进行广播,要分两步走,首先要加入到广播组地址,其次要建立套接字传输信息

    关于广播,涉及到MulticastSocket,他用于接收广播的信息,前提是要将它加入到广播组,组播的地址是保留的D类地址从224.0.0.0—239.255.255.255,而且一些地址有特定的用处如,224.0.0.0—244.0.0.255只能用于局域网中路由器是不会转发的,并且224.0.0.1是所有主机的地址,224.0.0.2所有路由器的地址,224.0.0.5所有ospf路由器的地址,224.0.13事PIMv2路由器的地址;239.0.0.0—239.255.255.255是私有地址(如192.168.x..x);224.0.1.0—238.255.255.255可以用与Internet上的。这里我们就选取230.0.0.1作为我们的广播地址。

    此软件类似于飞鸽,用于局域网通信,每个客户端上线都要寻找局域网其他主机并把自己的信息和所有主机交换,以此模式更新。。。

    import java.net.DatagramPacket;

    import java.net.DatagramSocket;

    import java.net.InetAddress;

    import java.net.MulticastSocket;

    /**

    *

    项目名称:UDPMulticastDemo

    *

    类名称:lanDemo

    *

    类描述:

    *

    创建人:wuzq,zhongqianhit@163.com

    *

    创建时间:2012-6-7 上午10:21:06

    *

    修改人:wuzq,zhongqianhit@163.com

    *

    修改时间:2012-6-7 上午10:21:06

    *

    修改备注:

    * @version

    **/

    class lanSend {

    // 广播地址

    private static final String BROADCAST_IP = "230.0.0.1";// 广播IP

    private static final int BROADCAST_INT_PORT = 40005; // 不同的port对应不同的socket发送端和接收端

    MulticastSocket broadSocket;// 用于接收广播信息

    DatagramSocket sender;// 数据流套接字 相当于码头,用于发送信息

    InetAddress broadAddress;// 广播地址

    public lanSend() {

    try {

    // 初始化

    broadSocket = new MulticastSocket(BROADCAST_INT_PORT);

    broadAddress = InetAddress.getByName(BROADCAST_IP);

    sender = new DatagramSocket();

    } catch (Exception e) {

    // TODO: handle exception

    System.out.println("*****lanSend初始化失败*****" + e.toString());

    }

    }

    void join() {

    try {

    broadSocket.joinGroup(broadAddress); // 加入到组播地址,这样就能接收到组播信息

    new Thread(new GetPacket()).start(); // 新建一个线程,用于循环侦听端口信息

    } catch (Exception e) {

    // TODO: handle exception

    System.out.println("*****加入组播失败*****");

    }

    }

    // 广播发送查找在线用户

    void sendGetUserMsg() {

    byte[] b = new byte[1024];

    DatagramPacket packet; // 数据包,相当于集装箱,封装信息

    try {

    b = ("find@" + lanDemo.msg).getBytes();

    packet = new DatagramPacket(b, b.length, broadAddress,

    BROADCAST_INT_PORT); // 广播信息到指定端口

    sender.send(packet);

    System.out.println("*****已发送请求*****");

    } catch (Exception e) {

    System.out.println("*****查找出错*****");

    }

    }

    // 当局域网内的在线机子收到广播信息时响应并向发送广播的ip地址主机发送返还信息,达到交换信息的目的

    void returnUserMsg(String ip) {

    byte[] b = new byte[1024];

    DatagramPacket packet;

    try {

    b = ("retn@" + lanDemo.msg).getBytes();

    packet = new DatagramPacket(b, b.length, InetAddress.getByName(ip),

    BROADCAST_INT_PORT);

    sender.send(packet);

    System.out.print("发送信息成功!");

    } catch (Exception e) {

    // TODO: handle exception

    System.out.println("*****发送返还信息失败*****");

    }

    }

    // 当局域网某机子下线是需要广播发送下线通知

    void offLine() {

    byte[] b = new byte[1024];

    DatagramPacket packet;

    try {

    b = ("offl@" + lanDemo.msg).getBytes();

    packet = new DatagramPacket(b, b.length, broadAddress,

    BROADCAST_INT_PORT);

    sender.send(packet);

    System.out.println("*****已离线*****");

    } catch (Exception e) {

    // TODO: handle exception

    System.out.println("*****离线异常*****");

    }

    }

    class GetPacket implements Runnable { // 新建的线程,用于侦听

    public void run() {

    DatagramPacket inPacket;

    String[] message;

    while (true) {

    try {

    inPacket = new DatagramPacket(new byte[1024], 1024);

    broadSocket.receive(inPacket); // 接收广播信息并将信息封装到inPacket中

    message = new String(inPacket.getData(), 0,

    inPacket.getLength()).split("@"); // 获取信息,并切割头部,判断是何种信息(find--上线,retn--回答,offl--下线)

    if (message[1].equals(lanDemo.ip))

    continue; // 忽略自身

    if (message[0].equals("find")) { // 如果是请求信息

    System.out.println("新上线主机:" + " ip:" + message[1]

    + " 主机:" + message[2]);

    returnUserMsg(message[1]);

    } else if (message[0].equals("retn")) { // 如果是返回信息

    System.out.println("找到新主机:" + " ip:" + message[1]

    + " 主机:" + message[2]);

    } else if (message[0].equals("offl")) { // 如果是离线信息

    System.out.println("主机下线:" + " ip:" + message[1]

    + " 主机:" + message[2]);

    }

    } catch (Exception e) {

    // TODO: handle exception

    System.out.println("线程出错 " + e);

    }

    }

    }

    }

    }

    public class lanDemo {

    // 全局变量

    public static String msg;

    public static String ip;

    public static String hostName;

    public static void main(String[] args) { // 程序入口点

    lanSend lSend;

    try {

    InetAddress addr = InetAddress.getLocalHost();

    ip = addr.getHostAddress().toString();

    hostName = addr.getHostName().toString();

    msg = ip + "@" + hostName;

    lSend = new lanSend();

    lSend.join(); // 加入组播,并创建线程侦听

    lSend.sendGetUserMsg(); // 广播信息,寻找上线主机交换信息

    Thread.sleep(10000); // 程序睡眠5秒

    lSend.offLine(); // 广播下线通知

    } catch (Exception e) {

    System.out.println("*****获取本地用户信息出错*****");

    }

    }

    }

    展开全文
  • import java.io.*; import java.net.*; import java.awt.*; import java.awt.event.*; import javax.swing.Timer; public class BroadCastWord extends Frame implements ActionListener { int port; ...
  • 由服务器进行广播,客户端只需要进行相应的客户端程序,就可以接收到服务器广播的信息。客户端可以随时开始或停止接收广播.此系统必须在有局域网的计算机上才能运行。并有详细的说明文档。是一个不错的广播程序。
  • 网络数据传播有单播、多播、广播几种形式。大部分的多播数据为音频或者视频,因为允许部分丢失,但是传输速度比TPCP快。 C类广播地址一般为XXX.XXX.XXX.255。例如,对于10.1.1.0 (255.255.255.0 )网段,其广播...

    概述

    网络数据传播有单播、多播、广播几种形式。大部分的多播数据为音频或者视频,因为允许部分丢失,但是传输速度比TPCP快。
    在这里插入图片描述
    C类广播地址一般为XXX.XXX.XXX.255。例如,对于10.1.1.0 (255.255.255.0 )网段,其广播地址为10.1.1.255 (255 即为2 进制的11111111 ),当发出一个目的地址为10.1.1.255 的分组(封包)时,它将被分发给该网段上的所有计算机。

    IP 地址的网络字段和主机字段全为 1 就是受限广播地址255.255.255.255。该地址用于主机配置过程中IP数据包的目的地址,此时,主机可能还不知道它所在网络的网络掩码,甚至连它的IP地址也不知道。在任何情况下,路由器都不转发目的地址为受限的广播地址的数据报,这样的数据报仅出现在本地网络中。

    代码示例

    可以利用受限广播地址完成局域网内好友的上线服务发现功能。
    Provider:服务提供者。
    Searcher:服务发现者。
    每台服务设备Provider上线,在固定端口P监听,如果局域网内有服务搜索Searcher运行,会向255.255.255.255的P端口发送固定格式消息,消息里包含回送消息的端口。这样Provider收到消息之后,回送自己的ID给Searcher。

    /**
     * UDP 提供者,用于提供服务
     */
    public class UDPProvider {
    
        public static void main(String[] args) throws IOException {
            // 生成一份唯一标示
            String sn = UUID.randomUUID().toString();
            Provider provider = new Provider(sn);
            provider.start();
    
            System.in.read();
            provider.exit();
        }
    
        private static class Provider extends Thread {
            private final String sn;
            private boolean done = false;
            private DatagramSocket ds = null;
    
            public Provider(String sn) {
                super();
                this.sn = sn;
            }
    
            @Override
            public void run() {
                System.out.println("UDPProvider Started.");
                try {
                    ds = new DatagramSocket(20000);
                    while (!done) {
                        final byte[] buf = new byte[512];
                        DatagramPacket receivePack = new DatagramPacket(buf, buf.length);
                        ds.receive(receivePack);
    
                        String ip = receivePack.getAddress().getHostAddress();
                        int port = receivePack.getPort();
                        int dataLen = receivePack.getLength();
                        String data = new String(receivePack.getData(), 0, dataLen);
                        System.out.println("UDPProvider receive form ip:" + ip + ",port:" + port + ",data:" + data);
                        // 解析端口号
                        int responsePort = Ciphertext.parsePort(data);
                        if (responsePort != -1) {
                            // 构建一份回送数据
                            String responseData = Ciphertext.buildWithSn(sn);
                            byte[] responseDataBytes = responseData.getBytes();
                            // 直接根据发送者构建一份回送信息
                            DatagramPacket responsePacket = new DatagramPacket(responseDataBytes, responseDataBytes.length,
                                    receivePack.getAddress(),responsePort);
                            ds.send(responsePacket);
                        }
                    }
                } catch (Exception ignored) {
                } finally {
                    close();
                }
                System.out.println("UDPProvider Finished.");
            }
            private void close() {
                if (ds != null) {
                    ds.close();
                    ds = null;
                }
            }
    
            void exit() {
                done = true;
                close();
            }
        }
    }
    
    /**
     * 通讯协议
     */
    public class Ciphertext {
        private static final String SN_HEADER = "ID";
        private static final String PORT_HEADER = "PORT";
    
        public static String buildWithPort(int port) {
            return PORT_HEADER + port;
        }
    
        public static int parsePort(String data) {
            if (data.startsWith(PORT_HEADER)) {
                return Integer.parseInt(data.substring(PORT_HEADER.length()));
            }
            return -1;
        }
    
        public static String buildWithSn(String sn) {
            return SN_HEADER + sn;
        }
    
        public static String parseSn(String data) {
            if (data.startsWith(SN_HEADER)) {
                return data.substring(SN_HEADER.length());
            }
            return null;
        }
    }
    
    /**
     * UDP 搜索者,用于搜索服务支持方
     */
    public class UDPSearcher {
        private static final int LISTEN_PORT = 30000;
    
    
        public static void main(String[] args) throws IOException, InterruptedException {
            System.out.println("UDPSearcher Started.");
            Listener listener = listen();
            sendBroadcast();
            System.in.read();
            List<Device> devices = listener.getDevicesAndClose();
            for (Device device : devices) {
                System.out.println("Device:" + device.toString());
            }
            // 完成
            System.out.println("UDPSearcher Finished.");
        }
    
        private static Listener listen() throws InterruptedException {
            System.out.println("UDPSearcher start listen.");
            CountDownLatch countDownLatch = new CountDownLatch(1);
            Listener listener = new Listener(LISTEN_PORT, countDownLatch);
            listener.start();
    
            countDownLatch.await();
            return listener;
        }
    
        private static void sendBroadcast() throws IOException {
            System.out.println("UDPSearcher sendBroadcast started.");
            DatagramSocket ds = new DatagramSocket();
            String requestData = Ciphertext.buildWithPort(LISTEN_PORT);
            byte[] requestDataBytes = requestData.getBytes();
            DatagramPacket requestPacket = new DatagramPacket(requestDataBytes, requestDataBytes.length);
            requestPacket.setAddress(InetAddress.getByName("255.255.255.255"));
            requestPacket.setPort(20000);
            ds.send(requestPacket);
            ds.close();
            System.out.println("UDPSearcher sendBroadcast finished.");
        }
    
        private static class Device {
            final int port;
            final String ip;
            final String sn;
    
            private Device(int port, String ip, String sn) {
                this.port = port;
                this.ip = ip;
                this.sn = sn;
            }
    
            @Override
            public String toString() {
                return "Device{" +
                        "port=" + port +
                        ", ip='" + ip + '\'' +
                        ", sn='" + sn + '\'' +
                        '}';
            }
        }
    
        private static class Listener extends Thread {
            private final int listenPort;
            private final CountDownLatch countDownLatch;
            private final List<Device> devices = new ArrayList<>();
            private boolean done = false;
            private DatagramSocket ds = null;
    
    
            public Listener(int listenPort, CountDownLatch countDownLatch) {
                super();
                this.listenPort = listenPort;
                this.countDownLatch = countDownLatch;
            }
    
            @Override
            public void run() {
                super.run();
                // 通知已启动
                countDownLatch.countDown();
                try {
                    // 监听回送端口
                    ds = new DatagramSocket(listenPort);
                    while (!done) {
                        // 构建接收实体
                        final byte[] buf = new byte[512];
                        DatagramPacket receivePack = new DatagramPacket(buf, buf.length);
                        // 接收
                        ds.receive(receivePack);
    
                        // 打印接收到的信息与发送者的信息
                        // 发送者的IP地址
                        String ip = receivePack.getAddress().getHostAddress();
                        int port = receivePack.getPort();
                        int dataLen = receivePack.getLength();
                        String data = new String(receivePack.getData(), 0, dataLen);
                        System.out.println("UDPSearcher receive form ip:" + ip + ",port:" + port + ",data:" + data);
                        String sn = Ciphertext.parseSn(data);
                        if (sn != null) {
                            Device device = new Device(port, ip, sn);
                            devices.add(device);
                        }
                    }
                } catch (Exception ignored) {
                } finally {
                    close();
                }
                System.out.println("UDPSearcher listener finished.");
            }
    
            private void close() {
                if (ds != null) {
                    ds.close();
                    ds = null;
                }
            }
    
            List<Device> getDevicesAndClose() {
                done = true;
                close();
                return devices;
            }
        }
    }
    
    

    运行

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • java UDP实现局域网广播

    千次阅读 2014-09-26 11:14:37
    使用java 的UDP进行广播,要分两步走,首先要加入到广播组地址,其次要建立套接字传输信息 关于广播,涉及到MulticastSocket,他用于接收广播的信息,前提是要将它加入到广播组,组播的地址是保留的D类地址从224....
  • java源码:局域网广播系统java源码.rar
  • 局域网广播系统

    2018-11-17 16:55:57
    基于java语言实现的局域网广播系统,对于刚接触java语言的同学比较适用,有java 简单的网络编程知识点,比较好用,共勉
  • 局域网广播系统JAVA

    2009-07-06 18:57:07
    JAVA实现的局域网广播系统。带有GUI界面,服务器端检测输入类型,客户端有提交IP和端口功能。
  • UDP广播与接收,用于局域网内多台设备之间的通信
  • 局域网广播系统 java

    2010-01-19 11:43:28
    局域网广播系统,java编写,包含若干个*.java文件,可使用myeclipse,eclipse等环境打开(或用记事本打开复制),把所有*.java文件复制到新建工程的src文件夹,然后点运行即可。
  • 基于java的远程屏幕共享小程序,包括客户端和服务器程序,仅供学习参考
  • 本人接触JAVA 一个多月了 自己写了个 局域网聊天 传文件 和群聊的小软件。群聊不是用的服务器客户端的模式,而是直接在局域网中用 multiCastSocket进行广播。但是 自己的机器上不管能收到广播,在局域网其他的机器上...
  • JAVA开发项目合集(学生管理系统,计算器系统,考试系统,图片生成器系统,Hannoi塔,记忆测试系统,局域网广播系统) 大学生JAVA课程设计,期末作业,学习自学JAVA 开发。
  • 局域网广播系统{java源码}
  • 这个应用程序将在某个教师和学生之间建立关于“问题-答案”的会话。该会话中的教师将会创建一个通信代理,这个通信代理将记录从该学生中接收到的问题的答案进行评分,然后该应用程序将根据该学生的考试成绩推荐其对...
  • Java获得广播地址

    2021-02-12 18:16:24
    同时还规定,IP地址可以用来指定一个广播(Broadcast,这种地址影射到硬件广播):主机号所有位都为1的地址就是该网络的Broadcast Address.在IP地址编址方法上存在定向广播地址(Directed BA)和有限广播地址(Limited BA...
  • 本文实例为大家分享了Java实现简单局域网聊天室的具体代码,供大家参考,具体内容如下Java 的Socket编程:1、TCP协议是面向连接的、可靠的、有序的、以字节流的方式发送数据,通过三次握手方式建立连接,形成传输...
  • //FileName:IpClassify.java package xiaoqiang.main; /**  * @author nKF65624  *  */ public class IpClassify {  private String ip;  private String ipmask;  public IpClassify(String ip, ...
  • Java局域网聊天的例子

    2010-04-01 15:22:14
    使用Java编写的局域网UDP广播方式聊天的例子

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,946
精华内容 4,378
关键字:

java 局域网广播

java 订阅