大学-Java课程-第十三章 Java网络编程

已于 2023-05-31 22:02:29 修改
阅读量209 收藏 2
点赞数 1
分类专栏： 大学Java实用教程笔记 文章标签： java 网络 开发语言
于 2023-05-10 01:12:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73293867/article/details/130544364
版权

第十三章 JavaJava网络编程

13.1 URL（Uniform Resource Location-系统资源定义符） 类

  • 介绍：URL是一个有关网络的一个类在java.net下，可以获取一些关于网址的信息和网址的内容。
  • 类中的重要方法
    • 常用构造方法public URL(String spec)throws MalformedURLException
    • 常用方法
      • 建立输入流public final InputStream openStream()throws IOException
  • 例子（从网页获取网页文件）
    Example13_1.java
import java.net.*;
import java.io.*;
import java.util.*;
public class Example13_1 {
   public static void main(String args[]) {
       Scanner scanner;
       //定义URL对象
       URL url;
       //定义一个线程
       Thread readURL;
       //定义访问网站的类
       Look look = new Look();
       System.out.println("输入URL资源：");
       //传入网站
       scanner = new Scanner(System.in);
       String source = scanner.nextLine();
       try {  url = new URL(source);
              look.setURL(url);
              readURL = new Thread(look);
              readURL.start();
       }
       catch(Exception exp){
          System.out.println(exp);
       } 
   }
}

Look.java

import java.net.*;
import java.io.*;
public class Look implements Runnable {
   //松耦合，定义url
   URL url;
   public void setURL(URL url) {
      this.url=url;
   }
   public void run() {
      try { 
        //定义一个流用于传输数据
        InputStream in = url.openStream();
        byte [] b = new byte[1024];
        int n=-1;
        while((n=in.read(b))!=-1) {
            /*读取字节到数组b中，如果数组长度为0，则返回值为0，
            如果数组长度不为0且没有的东西可以读取则返回值为-1，
            其他情况则返回值是实际读取的字节数*/
           String str = new String(b,0,n,"utf-8");
           /*将数组b中的字节从第0个开始编码以utf-8的格式
           */
           System.out.print(str);
        }
      }
      catch(IOException exp){}
   }
}
  • 程序简易流程图
创建一个线程readURL,一个URL变量url,一个Look对象
Scanner获取用户输入的网址
将初始化完成的URL对象传给副线程readURL <就此完成设定目标网站>
创立一个输出流用openStream <就此联通主机和网站的通道建立成功>
read方法读取网页内容

13.2 InetAddress 类

  • 介绍：此类获取主机的IP地址和域名
  • 杂：一个IP可以对应几个域名，一个域名只能对应一个IP
import java.net.*; 
public class Example13_2 {
   public static void main(String args[]) {
      try{  InetAddress address=InetAddress.getByName("www.sina.com.cn");
            System.out.println(address.toString()); 
            address=InetAddress.getByName("221.180.220.34");
            System.out.println(address.toString());
            address=InetAddress.getLocalHost();
            System.out.println(address.toString());
      }
      catch(UnknownHostException e) {
           System.out.println(""+e);
      } 
   }
}

结果

www.sina.com.cn/218.61.192.109
/221.180.220.34
DESKTOP-RVBPOVA/10.0.0.1

13.3 套接字

13.3.1 套接字概述

  • 介绍：套接字简单理解就是IP+端口，有了套接字之后就可以把客户机和服务器相互连接进行数据传送。

13.3.2 客户套接字的建立

  • 客户套接字的构造方法：Socket（String host,int port）
    • host是IP
    • port是端口号
  • 使用例子
    try{
	Socket clientSocket = new Socket("192.168.0.78",2010);
}catch(IOException e){}
  • 在建立套接字之后就可以使用getInputStream(),getOutputStream()方法与服务器建立输入输出流。
    • 注意：客户端就是服务器的输出流的目的地，同时服务器就是客户端的输出流的目的地。

13.3.3 服务器套接字的建立

  • 为了能使客户成功连接到服务器服务器必须建立一个ServerSocket对象
  • ServerSocket的构造方法：ServerSocket(int port)port是端口号
  • 例子
    try{
	ServerSocket serverForClient = ServerSocket(2010);
}catch(IOException e){}

13.3.4 服务器与客户机的连接

  • 问题：服务器的ServerSocket对象为什么不能和Socket对象一样直接建立输入输出流，而是要通过ServerSocket对象建立Socket对象从而建立输入输出流。
  • 建立连接的原理：经过客户端套接字和服务器套接字的建立由于客户端定位了服务器的IP和端口，而服务器的端口又和客户机寻找的端口一致就为连接客户机和服务器的连接构成了条件，所以可以通过accept()方法建立Socket对象，从而通过Socket对象建立输入输出流。通信完毕后要close()。
  • 套接字连接读取数据和从文件中读取数据的区别
    • 读取文件中的数据：文件中的数据已经存在，直接读取就好了。
    • 套接字：客户机中的数据没存在而服务器就开始读取了，所以在服务器读取不到客户数据的这段时间就是阻塞状态。（就像银行和客人一样：银行的人员始终等待着客户但是客户可能来可能不来给你数据）
  • 例子
    Client.java
import java.io.*;
import java.net.*;
public class Client {
   public static void main(String args[]) {
   	  //设定3个问题
      String [] mess ={"珠穆朗玛峰的高度是多少？","亚洲有多少个国家?","西宁是哪个省的省会？"};
      /*
      定义一些对象
      1. 套接字对象
      2. 数据输入流
      3. 数据输出流
      */
      Socket mysocket;
      DataInputStream in=null;
      DataOutputStream out=null;
      try{  
      		//使用直接设定服务器的IP和端口的构造方法，在服务器没有故障的情况下就此和服务器建立联系
      		mysocket=new Socket("127.0.0.1",2010);
      		//调用Socket对象的方法创立输入字符输入流和输出流作为数据流的底层流
            in=new DataInputStream(mysocket.getInputStream());
            out=new DataOutputStream(mysocket.getOutputStream()); 
            for(int i=0;i<mess.length;i++) {
              out.writeUTF(mess[i]);
              String  s=in.readUTF();   //in读取信息，堵塞状态
              System.out.println("客户收到服务器的回答:"+s);
              Thread.sleep(1000);
            } 
       }
       catch(Exception e) {
            System.out.println("服务器已断开"+e);
       }
   } 
}

Server.java

import java.io.*;
import java.net.*;
public class Server {
   public static void main(String args[]) {
   	  //设定答案
      String [] answer ={"顶岩石面海拔8844.43米","48个","青海省"};
      /*1. 建立服务套接字对象，
      	2. 建立以后用于通信的套接字
      	3. 建立数据输入输出流
      */
      ServerSocket serverForClient=null;
      Socket socketOnServer=null;
      DataOutputStream out=null;
      DataInputStream  in=null;
     //用服务器套接字设定接口
      try { serverForClient = new ServerSocket(2010);
      }
      catch(IOException e1) {
          //如果端口号已经被占用，将触发异常
            System.out.println(e1);
      } 
      try{ 
      	   System.out.println("等待客户呼叫");
      	   //设定Socket对象，就此用完accept方法之后，如果客户有要求就此和客户连接起来
           socketOnServer = serverForClient.accept(); 
           //服务器套接字的介个方法获得客户的地址
           System.out.println("客户的地址:"+socketOnServer.getInetAddress());
           System.out.println("客户的端口:"+socketOnServer.getPort());
           //定义数据流
           out=new DataOutputStream(socketOnServer.getOutputStream());
           in=new DataInputStream(socketOnServer.getInputStream());
           for(
           	  //就此在数据流中获取信息
           	  int i=0;i<answer.length;i++) {
              String s=in.readUTF(); // in读取信息，堵塞状态
              System.out.println("服务器收到客户的提问:"+s);
              out.writeUTF(answer[i]);
              Thread.sleep(1000);
           }
      }
      catch(Exception e) {
          System.out.println("客户已断开"+e);
      }
   }
}
服务器
客户机
否
否
是
是
结束
判断是否还是要继续提问
不断回答答案
不断获取客户机的提问
getInputStream初始化数据输入流
getOutputStream初始化数据输出流
调用accept方法等待客户机呼叫
ServerSocket设置端口号
服务器
结束
判断是否还是要继续提问
不断获取服务器的答案
不断向服务器提问
不断读取服务器传输过来的内容
getInputStream初始化数据输入流
getOutputStream初始化数据输出流
创立并初始化套接字

13.3.4 使用多线程技术

  • 例子
    Client.java
import java.io.*;//DataInputStream DataOutputStream
import java.net.*;//Socket InetAddress InetSocketAddress
import java.util.*;//Scanner
public class Client  {
   public static void main(String args[]) {
      /*定义1. 调用用户的键盘
            2. 套接字
            3. 数据输入流
            4. 数据输出流
            5. 定义一个线程
            6. 创建一个read对象
      */
      Scanner scanner = new Scanner(System.in);
      Socket mysocket=null;
      DataInputStream in=null;
      DataOutputStream out=null;
      Thread readData ; 
      Read read=null;
      
      try{  
            //创立一个未连接的套接字
            mysocket=new Socket();
            //实现接口read
            read = new Read();
            readData = new Thread(read);
            
            //如果没有连接上，输入服务器的IP和接口
            System.out.print("输入服务器的IP:");
            String IP = scanner.nextLine();
            System.out.print("输入端口号:");
            int port = scanner.nextInt();
            
            if(mysocket.isConnected()){}//如果连接就没有什么命令
            else{
              /*由于创建套接字的时候没有给定服务器的IP，
              没有办法连接到服务器所以要用connect方法来连接服务器
              使用connect方法的时候需要在参数InetSocketAddress中的构造方法中的
              InetAddress中设置服务器的IP*/
              InetAddress  address=InetAddress.getByName(IP);//创立address对象，设置IP
              InetSocketAddress socketAddress=new InetSocketAddress(address,port);//设置IP和接口
              mysocket.connect(socketAddress); //连接服务器
              in =new DataInputStream(mysocket.getInputStream());//设置输入流
              out = new DataOutputStream(mysocket.getOutputStream());//设置输出流
              read.setDataInputStream(in);//在线程中设置输入流
              readData.start();//开启线程
            }
       }
       catch(Exception e) {
            System.out.println("服务器已断开"+e);
       }
       System.out.print("输入园的半径(放弃请输入N):");
       while(scanner.hasNext()) {
           double radius=0; 
           //这次的try-catch是用于防止输入非double类的数字
           try {
               radius = scanner.nextDouble();
           }
           catch(InputMismatchException exp){
              System.exit(0);
           }   
           //这次的try-catch是用于防止没有连接上服务器
           try { 
               out.writeDouble(radius);
           }
           catch(Exception e) {}
       } 
   }
}

Read.java

import java.io.*;
public class Read implements Runnable {
   //设置数据输入流，松耦合
   DataInputStream in;
   public void setDataInputStream(DataInputStream in) {
      this.in = in;
   }
   public void run() {
      double result=0;
      while(true) {
        try{ result=in.readDouble();
             System.out.println("圆的面积:"+result);
             System.out.print("输入园的半径(放弃请输入N):");
        }
        catch(IOException e) { 
             System.out.println("与服务器已断开:"+e);
             break;
        }   
      }
   }
}

Server.java

import java.io.*;
import java.net.*;
import java.util.*;
public class Server {
   public static void main(String args[]) {
      //建立服务器套接字
      ServerSocket server=null;
      ServerThread thread;
      Socket you=null;
      //创立服务器接口
      while(true) {
        try{  server=new ServerSocket(2010);
        }
        catch(IOException e1) { 
           //ServerSocket对象不能重复创建，除非更换端口号
              System.out.println("正在监听"); 
        } 
        try{  System.out.println("等待客户呼叫");
              you=server.accept();
              System.out.println("客户的地址:"+you.getInetAddress());
        } 
        catch (IOException e) {
              System.out.println("正在等待客户");
        }
        if(you!=null) { 
        	  /*将you这个Socket对象传给另一个线程，当多个用户同时访问服务器时因为new过所以不会扰乱线程
        	  每一次new过的地址不会被系统清理所以线程还在继续*/
              new ServerThread(you).start(); //为每个客户启动一个专门的线程
        }
      }
   }
}
class ServerThread extends Thread {
   //就此开启线程
   /*
   1. 创立Socket对象
   2. 数据输入输出流
   */
   Socket socket;
   DataOutputStream out=null;
   DataInputStream  in=null;
   String s=null;
   //重写构造方法
   ServerThread(Socket t) {
      socket=t;
      //实体化数据流
      try {  out=new DataOutputStream(socket.getOutputStream());
             in=new DataInputStream(socket.getInputStream());
      }
      catch (IOException e){}
   }  
   public void run() {        
      while(true) {
         try{  
         	   //计算圆面积
         	   double r=in.readDouble();//堵塞状态，除非读取到信息
               double area=Math.PI*r*r;
               out.writeDouble(area);
         }
         catch (IOException e) {
               System.out.println("客户离开");
                return;
         }
      }
   } 
}
客户机2
服务器
客户机1
线程1
线程2
是
否
是
否
是
是
建立套接字对象,输入输出流对象,read对象,Thread对象
实体化无参数的套接字对象,实现接口,实体化线程
用InetAddress,InetSocketAddress,connect两个类和一个方法设置IP和端口
套接字设置完毕,开始start线程<不用在意线程先后,结果一样>
通过输出流获取圆的半径,并且传输到服务器
通过输入流获取经过虚拟机计算后的结构并且输出
判断是否有还需要计算
结束
设立服务器端口
创立套接字等必备变量
accept命令等待接受客户机
接收到客户机并实体化套接字you
线程...
new线程同时也创立输入输出流
start开启线程
输入流接受半径长度
计算圆的面积
输出流传出计算结果
对于同一个 客户机判断是否需要继续计算
结束
new线程同时也创立输入输出流
you作为线程类的构造方法的参数创立线程
start开启线程
输入流接受半径长度
计算圆的面积
输出流传出计算结果
对于同一个 客户机判断是否需要继续计算
结束
建立套接字对象,输入输出流对象,read对象,Thread对象
实体化无参数的套接字对象,实现接口,实体化线程
用InetAddress,InetSocketAddress,connect两个类和一个方法设置IP和端口
套接字设置完毕,开始start线程<不用在意线程先后,结果一样>
通过输出流获取圆的半径,并且传输到服务器
通过输入流获取经过虚拟机计算后的结构并且输出
判断是否有还需要计算
结束
客户机...

13.4 UDP 数据报

  • 介绍：不是点对点连接传输数据，速度快，可靠性低，

13.4.1 发送数据包

  • 用到的类：DatagramPacket（此类创建的对象称为数据包）
  • 构造方法
    • DatagramPacket(byte data[],int length,IntAddress address,int port)（这里的address是IntAddress类的对象，port是端口）
    • DatagramPack(byte data[],int offset,int length,InetAddress address,int port)
    • DatagramSocket()不带参数只有传输数据的功能。eg： 
      •   DatagramSocket mail_out = new DatagramSocket();
  mail_out.send(data_pack);
  • 其他方法
    • 获取数据包的目标端口：public int getPort()
    • 获取数据包的目标地址：public InetAddress getAddress()
    • 获取数据包的目标字节数组：public byte[] getData()

13.4.2 接收数据包

  • 用到的类：DatagramSocket
  • 构造方法：DatagramSocket(int port)
  • 用法
    • 创建方法的参数：用一个新的构造方法创建DatagramPack对象DatagramPack(byte data[],int length)（data是用于接收的字节数组，length是每次接收的长度）
    • 使用receive方法接收数据receive(DatagramPacket pack)
  • 注意
    • receive()方法会阻塞，直到收到数据包
    • 数据包中的数据长度不要超过8192KB
  • 接收数据包的例子
    DatagramSocket mail_in = new DatagramSocket(5666);
byte data[] = new byte[100];
int length = 90;
DatagramPacket pack = new DatagramPacket(data,length);
mail_in.receive(pack);
  • 例子
    ZhangSan.java
import java.util.*;
public class ZhangSan  {
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        //用自己写的类定义的发送数据的包，创建对象
        SendDataPacket sendDataPacket=new SendDataPacket();
        //定义目标IP
        sendDataPacket.setIP("127.0.0.1");
        //定义目标端口
        sendDataPacket.setPort(666);
        //自己定义的结合搜数据的包，创建对象
        ReceiveDatagramPacket receiveDatagramPacket = new ReceiveDatagramPacket(); 
        //设置端口
        receiveDatagramPacket.setPort(888);
        //启动线程                       
        receiveDatagramPacket.receiveMess();
        System.out.print("输入发送给李四的信息:");
        while(scanner.hasNext()) {//判断是否还有字符串
        	//将字符串赋值给
            String mess = scanner.nextLine();
            //如果字符串长度为0则报错
            if(mess.length()==0) 
                 System.exit(0);
            //将字符串转换为字节存放在字节数组中
            byte buffer[] = mess.getBytes();
            //发送信息
            sendDataPacket.sendMess(buffer);  
            System.out.print("继续输入发送给李四的信息:");
        }
    }
}

LiSi.java

import java.util.*;
public class LiSi  {
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        SendDataPacket sendDataPacket=new SendDataPacket();  //负责发送数据包
        sendDataPacket.setIP("127.0.0.1");
        sendDataPacket.setPort(888);
        ReceiveDatagramPacket receiveDatagramPacket =
        new ReceiveDatagramPacket();  
        receiveDatagramPacket.setPort(666);                       
        receiveDatagramPacket.receiveMess();//负责接受数据包
        System.out.print("输入发送给张三的信息:");
        while(scanner.hasNext()) {
            String mess = scanner.nextLine();
            if(mess.length()==0) 
                 System.exit(0);
            byte buffer[] = mess.getBytes();
            sendDataPacket.sendMess(buffer);  
            System.out.print("继续输入发送给张三的信息:");
        }
    }
}

ReceiveDatagramPacket.java

import java.net.*;
public class ReceiveDatagramPacket implements Runnable {
	//松耦合创建线程
    Thread thread;
    //设置接口变量
    public int port;
    //初始化线程
    public ReceiveDatagramPacket(){
        thread = new Thread(this);
    }
    //设置接口方法
    public void setPort(int port){
       this.port = port;
    }
    //启动线程方法
    public void receiveMess(){
        thread.start();
    }
    public void run() {
    	//创建发送数据对象-pack
        DatagramPacket pack=null;
        //创建接受数据对象-datagramSocket
        DatagramSocket datagramSocket=null;
        //创建最大数据量的字节数组
        byte  data[]=new byte[8192];
        try{  
        	  //初始化发送接收数据的对象
        	  pack=new DatagramPacket(data,data.length);
              datagramSocket=new DatagramSocket(port);
        }
        catch(Exception e){} 
        if(datagramSocket==null) return;
        while(true) {  
           try{ 
           		//就此使用receive方法开始接受包中的数据
           		datagramSocket.receive(pack); 
                String message=new String(pack.getData(),0,pack.getLength());
                System.out.printf("%25s\n","收到:"+message);
           }
           catch(Exception e){}
        } 
    }
}

SendDataPacket.java

import java.net.*;
public class SendDataPacket {
    public byte messBySend [];     //存放要发送的数据
    public String IP;             //目标IP地址
    public int port;               //目标端口
    //定义目标端口方法
    public void setPort(int port){
       this.port = port;
    }
    //定义目标IP方法
    public void setIP(String IP){
       this.IP = IP;
    }
    //定义发送信息的方法
    public void sendMess(byte messBySend []){
        try{
          //定义InetAddress作为下面方法的参数
          InetAddress address=InetAddress.getByName(IP);
          DatagramPacket dataPack=new DatagramPacket(messBySend,messBySend.length,address,port);
          DatagramSocket datagramSocket = new DatagramSocket();
          datagramSocket.send(dataPack);
        }
        catch(Exception e){} 
    }
}
  • 注意
    • 接收的Java文件用多线程的原因是可能发生阻塞

13.5 广播数据报

  • 预备知识

    • IP

      • 不同体系中的网络模型分层和对应的协议。
        在这里插入图片描述

    • IP地址分类（IP协议）

      • IPv4地址：由段组成，每一段是一个字节，最大值时255（转换为10进制之后）。
        在这里插入图片描述
        • A类地址：(1.0.0.1-126.255.255.254)一般用于大型网络。
        • B类地址：(128.1.0.1-191.254.255.254)一般用于中型网络。
        • C类地址：(192.0.1.1-223.255.254.254)一般用于小型网络。
        • D类地址：(224.0.0.1-239.255.255.254)用于广播
        • E类地址：(240.0.0.0—255.255.255.254) 保留地址
        • 一些特殊的地址（书中的例子三的IP就是127.0.0.1指向本机）
          在这里插入图片描述

    • IPV6地址：现在不常用，IPv6产生原因是IPv4的地址不够用所以产生了IPv6。

  • 创建多点广播
    • 介绍：创建广播分为单点广播和多点广播。他们的共同点是IP地址都需要是广播地址（IPv4-D类，IPv6-FF0::1），而且用到的协议都是UDP。只是由服务器给用户传输数据没有用户给服务器传输数据的过程。
      • 单点广播：把上边的UDP的例子的IP改为D类地址就行。（DatagramSocket类）
      • 多点广播：所用的类是MulticastSocket，是继承DatagramSocket类在此类上增加了支持多点传播数据的方法，并且需要加入多点广播组。
    • 具体的使用方法
      • 准备组播的端口、地址、多点广播套接字，建立group
        int port=5858;
//这个时候定义IP，建立group
InetAddress group==InetAddress.getByName("239.255.8.0");
//这个时候定义端口
MulticastSocket socket=new MulticastSocket(port);
      • 定义广播网络范围加入group
        //定义网络范围参数是1就是本地网路，其中参代表可以经过的路由器数量，每经过一个路由器参数就减1
socket.setTimeToLive(1);
//jdk14以后新定义joinGroup的方法
InetSocketAddress socketAddress = new InetSocketAddress(group,port);
NetworkInterface networkInterface = NetworkInterface.getByInetAddress(group);
socket.joinGroup(sockedAddress,networkInterface); //加入group后,socket发送的数据报被group中的成员接收到
      • 开始传输信息
        //等待传输数据UDP协议
DatagramPacket packet=null;
byte data[]=s.getBytes(); 
//打包数据
packet=new DatagramPacket(data,data.length,group,port); 
//发送数据
socket.send(packet);             //广播数据包
  • 例子
    BroadCast.java
    import java.net.*;
public class BroadCast  { 
   //设置播报内容
   String s="国庆放假时间是9月30日"; 
   //设置接口
   int port=5858;
   //创建播组地址
   InetAddress group=null;
   //创建多点广播套接字,作用是使所用连到这个接口的客户都能收到信息
   MulticastSocket socket=null;
   //定义构造方法
   BroadCast() { 
      try { 
      	 //设置广播组地址
         group=InetAddress.getByName("239.255.8.0");
         //设置多点广播组端口
         socket=new MulticastSocket(port);
         //多点广播套接字发送数据报范围为本地网络
         socket.setTimeToLive(1);
         //jdk14以后新定义joinGroup的方法
         InetSocketAddress socketAddress = new InetSocketAddress(group,port);
         NetworkInterface networkInterface = NetworkInterface.getByInetAddress(group);
         socket.joinGroup(sockedAddress,networkInterface); //加入group后,socket发送的数据报被group中的成员接收到
      }                                 
      catch(Exception e) {
         System.out.println("Error: "+ e);          
      }
   }
   public void play() {
      while(true) {
        try{   DatagramPacket packet=null;        //待广播的数据包
               byte data[]=s.getBytes(); 
               //用UDP传输
               packet=new DatagramPacket(data,data.length,group,port); 
               System.out.println(new String(data)); 
               socket.send(packet);             //广播数据包
               Thread.sleep(2000);
        }
        catch(Exception e) {
               System.out.println("Error: "+ e);          
        }
      }
   }
   public static void main(String args[]) {
      new BroadCast().play();
   }
}
    Receiver.java
    import java.net.*;
import java.util.*;
public class Receiver  {
   public static void main(String args[]) {
      int port = 5858;                               //组播的端口
      InetAddress group=null;                        //组播组的地址
      MulticastSocket socket=null;                   //多点广播套接字 
      try{
          group=InetAddress.getByName("239.255.8.0");//设置广播组的地址为239.255.8.0
          socket=new MulticastSocket(port);    //多点广播套接字将在port端口广播
          InetSocketAddress socketAddress = new InetSocketAddress(group,port);
     	  NetworkInterface networkInterface = NetworkInterface.getByInetAddress(group);
          socket.joinGroup(sockedAddress,networkInterface); //加入group
      }                          
      catch(Exception e){} 
      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());
                System.out.println("接收的内容:\n"+message);
         }
         catch(Exception e) {}
      }
   }
}
  • 例子的示意图
group IP:239.255.8.0
服务器BroadCast 端口:5858
Receiver1
Receiver2
...
  • 例子的流程图
客户机2
客户机1
服务器
构造方法
play方法
设置IP和端口
建立端口 组 多点广播套接字
加入group
建立数组 包
接收数据
输出接收到的数据
设置IP和端口
建立端口 组 多点广播套接字
加入group
建立数组 包
接收数据
输出接收到的数据
.play开启服务器服务
设定播报内容 端口等变量
不断发送数据包
将要播报的内容打包到数据包中
sleep
让服务器加入group
设置服务器端口 group的IP
客户机...

13.6 Java远程调用

13.6.1 远程对象

13.6.2 RMI 的设计细节

七百~~~汪汪汪
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础知识【第19期】-- 网络编程
小郭的博客
05-26 351
导读: 本篇是JAVA基础系列的第20篇，今天我们梳理java网络编程的相关知识点。计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。 1.网络体系结构 计算机网络分为网络协议和网络体系结构 通过网络发送数据是一项复杂的操作，必须仔细地协调网络的物理特性以及所发送数据的逻辑特征。通过网络将数据从一台主机发送到另外的主机，这个过程是通过计算机网络通...
Java网络编程学习
weixin_47605863的博客
07-13 159
Java网络编程学习记录
大学-Java课程-第四章 类与对象
m0_73293867的博客
11-01 286
大学-Java课程-第四章 类与对象
大学java专业核心课程_计算机应用技术专业核心课程有哪些？
weixin_31539351的博客
02-27 870
对于报考或者有想法学习计算机应用技术专业的学生们来说，其实，计算机应用技术专业所要学习的专业课程还是比较多的，大家应该去了解一下，那么计算机应用技术专业核心课程有哪些?专业核心课程1、Vf数据库应用主要讲授数据库的基本原理，数据库系统的组成;关系型数据库的特点、基本运算、数据组成;以Visual Foxpro为实例，学习数据库的设计和开发，掌握数据库的应用。2、VB .NET程序设计本课程主要讲授...
大学java课程教学课件
12-09
这是我从我的java老师那里拷的课件，个人觉得做得还不错，特别在介绍对象的时候比较形象，较容易理解。
java大学课程教材
04-18
java大学课程教材,非常适合初学者的教材,而且非常的好,代码教材都有了.
大学java课程课件
06-18
.。。。。java课件，大学课程老师用的
Java实用编程技术第章-Java语言概述及编程基础.pptx
11-17
"Java实用编程技术" Java语言概述及编程基础： Java语言是一种面向对象、分布式、平台中立、可移植、高效、安全的编程语言。它具有以下特点： 1、简单：Java语言的语法简单易学，易于程序员掌握和使用。 2、面向...
第13章-Java网络编程-Java面向对象程序设计教程-微课视频版-程杰-清华大学出版社.pptx
05-31
JAVA 面向对象程序设计教程 第13章 Java网络编程 第13章-Java网络编程-Java面向对象程序设计教程-微课视频版-程杰-清华大学出版社全文共17页，当前为第1页。 第13章 Java网络编程 第13章-Java网络编程-Java面向对象...
Java2实用教程第4版-第13章-Java网络编程.ppt
12-18
Java2实用教程第4版-第13章-Java网络编程.ppt
大学java课程
03-28
这是关于大学课程java的ppt，希望这个课件对要学习的人有一些帮助
大学课程java课件，非常详细
05-06
大学课程java的课件，自己老师给的，很有用！
Java高级程序设计：第13章-多线程编程.pptx
05-26
在一个Java程序内启动多条线程;练习;使用Runnable接口创建线程时指定和取得线程名称;The Thread Class ;继承Thread类创建线程类;继承Thread类创建线程类;在一个Java程序内启动多条线程;继承Thread类时设置线程的名字...
第2章Java编程基础ppt课件.ppt
11-12
"Java编程基础知识点总结" 在本篇文章中，我们将对Java编程基础知识点进行总结，涵盖了Java基础知识点、数据类型、变量、运算符、控制流语句、方法等方面的知识点。 一、Java基础知识点 1. Java中的注释作用：对...
准大一生必看的Java学习路线
yuZhenXS的博客
07-30 1551
我是一个准大三的计算机学生.又到了新的一个学期，相信有很多的大一的新生选择了计算机专业，那么计算机专业究竟应该怎么自学，这篇文章就是针对大一新生所写的，当然大二，大三的同学如果还对自己的学习路线感到迷茫，也可以停下来看一看。 个人认为（仅代表个人）：大学中的由于一堂课一次一般只有2节，老师可能为了进度，只能教到浅显，而且因为计算机的快速迭代发展，导致一些大学课程都是落后的，所以我更推荐自学。下面是我大学自学的经历。 大一 1.JAVA基础(时间:2个月到4个月) 大一期间的课程绝大多数都是基础课，例如c,c
大学本科 java教材_Java程序设计(21世纪大学本科计算机专业系列教材普通高等
weixin_29202687的博客
02-13 3123
**篇基础篇第1章Java概述1.1 Java语言1.1.1 Java语言的特点1.1.2 Java平台的体系结构1.2 Java运行环境与开发环境1.2.1 Java运行环境1.2.2 Java开发环境1.3 Java程序举例1.3.1编写**个Java Application1.3.2编写**个Java Applet习题与思考第2章Java程序设计基础2.1标识符和关键字2.1.1标识符**篇...
阿里云大学免费课程分享：Java零基础入门
lihuixin_的博客
06-20 5667
Java开发零基础入门，阿里云大学免费精品课，名师李兴华主讲，戳这里学习：http://click.aliyun.com/m/23565/ 本课程主要讲解JavaSE的发展历史，JDK开发环境的搭建，CLASSPATH属性作用，Java程序基本结构、基本数据类型的划分及使用、程序结构、方法的定义与使用，本课程是作为Java系列课程的初期课程，掌握本课程之后可以继续学习Java高级开发部分。
java课程内容是什么？零基础学java要学哪些内容？
qf2019的博客
12-18 753
java课程内容是什么?零基础学java要学哪些内容?下面就跟着小编一起来看看吧! 总有朋友问Java程序员课程教什么，下面是Java课程大纲，希望能够对你有所帮助： 阶段一的Java基础。JavaEE的学习内容从计算机基本概念，DOS命令开始，为你入门编程语言扫盲，什么是程序，如何配置JAVA开发环境，JAVA编程的过程是怎样的，JAVA有什么物特点，程序是如何运行的，这些你都可以在这里得到答案...
java研发工程师该怎么入门_java开发工程师一般都做什么开发？
weixin_29162439的博客
02-13 1061
展开全部java开发工程师一般做以下开发：一、初级部分1、Java 程序设计基础32313133353236313431303231363533e78988e69d8331333365643562，包括 J2sdk基础、Java面向对象基础、Java API使用、数据结构及算法基础、Java AWT图形界面程序开发；2、J2SE平台Java程序设计，包括Swing图形程序设计, Socket网络应...
java核心技术第十一版pdf
最新发布
09-03
第十一版是该书的最新版本，完整地介绍了Java编程的基础知识和高级技术。 该书的内容非常全面，涵盖了Java语言的方方面面。第一部分介绍了Java编程的基础，包括Java语言的语法、数据类型、数组、面向对象编程等基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值