A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

  1. package com.kxg_01;

  2. import java.io.IOException;
  3. import java.net.InetAddress;

  4. public class InetAddrssDemo {
  5.         public static void main(String[] args) throws IOException {
  6.                 // public static InetAddress getByName(String host):在给定主机名的情况下确定主机的 IP
  7.                 // 地址。
  8.                 InetAddress address = InetAddress.getByName("10.164.23.26");

  9.                 // public String getHostName():获取此 IP 地址的主机名
  10.                 String name = address.getHostName();

  11.                 // public String getHostAddress():返回 IP 地址
  12.                 String ip = address.getHostAddress();

  13.                 System.out.println(name + ":" + ip);
  14.         }
  15. }
复制代码


4 个回复

倒序浏览
UDP发送端:
  1. import java.io.IOException;
  2. import java.net.DatagramPacket;
  3. import java.net.DatagramSocket;
  4. import java.net.InetAddress;

  5. /*
  6. * UDP协议发送数据:
  7. *                 1.创建发送端Socket对象
  8. *                 2.创建数据,并把数据打包
  9. *                 3.调用Socket对象的发送方法发送数据包
  10. *                 4.释放资源
  11. */
  12. public class InetAddressDemo2 {
  13.         public static void main(String[] args) throws IOException {
  14. //                UDP协议利用DatagramSocket类创建Socket对象
  15.                 DatagramSocket ds = new DatagramSocket();
  16.                
  17. //                DatagramPacket类:此类表示数据报包
  18.                 // public DatagramPacket(byte[] buf,int length, InetAddress address,int
  19.                 // port)打包数据

  20.                 // 创建数据
  21.                 byte[] bys = "hello,java".getBytes();

  22.                 // 长度
  23.                 int length = bys.length;

  24.                 // 获取IP
  25.                 InetAddress adress = InetAddress.getByName("10.164.22.254");

  26.                 // 定义端口
  27.                 int port = 48264;

  28.                 // 打包数据
  29.                 DatagramPacket dp = new DatagramPacket(bys, length, adress, port);

  30.                 // 发送数据
  31.                 ds.send(dp);

  32.                 // 释放资源
  33.                 ds.close();
  34.         }
  35. }
复制代码



回复 使用道具 举报
UDP接收端:
  1. package com.kxg_02;

  2. import java.io.IOException;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;

  6. /*
  7. * UDP协议接受数据:
  8. *                 1.创建接收端Socket对象
  9. *                 2.创建一个空数据包(接收发来的数据)
  10. *                 3.调用Socket对象的接收方法接受数据
  11. *                 4.解析数据,并显示控制台
  12. *                 5.释放资源
  13. */
  14. public class ReceiveDemo {
  15.         public static void main(String[] args) throws IOException {
  16.                 // public DatagramSocket(int port):指定端口的Socket对象
  17.                 // 注意:需要和发送端端口一致
  18.                 DatagramSocket ds = new DatagramSocket(48264);

  19.                 // public DatagramPacket(byte[] buf,int length):用来接收长度为 length 的数据包
  20.                 byte[] bys = new byte[1024];
  21.                 int length = bys.length;
  22.                 DatagramPacket dp = new DatagramPacket(bys, length);

  23.                 // public void receive(DatagramPacket p):从此套接字接收数据报包
  24.                 ds.receive(dp);

  25.                 // 解析数据包,并显示控制台
  26.                 // 获取发送者IP
  27.                 InetAddress address = dp.getAddress();
  28.                 String ip = address.getHostAddress();

  29.                 // public byte[] getData():返回数据缓冲区
  30.                 byte[] bys2 = dp.getData();

  31.                 // public int getLength():接收到的数据的长度
  32.                 int length2 = dp.getLength();

  33.                 // 转为字符串类型并输出
  34.                 String s = new String(bys2, 0, length2);
  35.                 System.out.println(ip + ":" + s);

  36.                 // 释放资源
  37.                 ds.close();
  38.         }
  39. }
复制代码



回复 使用道具 举报
简化版:
发送端:
  1. package com.kxg_03;
  2. import java.io.IOException;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;

  6. /*
  7. * UDP协议发送数据:
  8. *                 1.创建发送端Socket对象
  9. *                 2.创建数据,并把数据打包
  10. *                 3.调用Socket对象的发送方法发送数据包
  11. *                 4.释放资源
  12. */
  13. public class SendDemo {
  14.         public static void main(String[] args) throws IOException {
  15. //                UDP协议利用DatagramSocket类创建Socket对象
  16.                 DatagramSocket ds = new DatagramSocket();
  17.                
  18. //                DatagramPacket类:此类表示数据报包
  19.                 // public DatagramPacket(byte[] buf,int length, InetAddress address,int
  20.                 // port)打包数据

  21.                 byte[] bys = "hello,UDP".getBytes();
  22.                 // 打包数据
  23.                 DatagramPacket dp = new DatagramPacket(bys, bys.length,
  24.                                 InetAddress.getByName("10.164.22.254"), 48264);

  25.                 // 发送数据
  26.                 ds.send(dp);

  27.                 // 释放资源
  28.                 ds.close();
  29.         }
  30. }
复制代码

接收端:
  1. package com.kxg_03;

  2. import java.io.IOException;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;

  5. /*
  6. * UDP协议接受数据:
  7. *                 1.创建接收端Socket对象
  8. *                 2.创建一个空数据包(接收发来的数据)
  9. *                 3.调用Socket对象的接收方法接受数据
  10. *                 4.解析数据,并显示控制台
  11. *                 5.释放资源
  12. */
  13. public class ReceiveDemo {
  14.         public static void main(String[] args) throws IOException {
  15.                 // public DatagramSocket(int port):指定端口的Socket对象
  16.                 // 注意:需要和发送端端口一致
  17.                 DatagramSocket ds = new DatagramSocket(48264);

  18.                 // public DatagramPacket(byte[] buf,int length):用来接收长度为 length 的数据包
  19.                 byte[] bys = new byte[1024];
  20.                 DatagramPacket dp = new DatagramPacket(bys, bys.length);

  21.                 // public void receive(DatagramPacket p):从此套接字接收数据报包
  22.                 ds.receive(dp);

  23.                 // 解析数据包,并显示控制台
  24.                 // 获取发送者IP
  25.                 String ip = dp.getAddress().getHostAddress();

  26.                 // 转为字符串类型并输出
  27.                 String s = new String(dp.getData(), 0, dp.getLength());
  28.                 System.out.println(ip + ":" + s);

  29.                 // 释放资源
  30.                 ds.close();
  31.         }
  32. }
复制代码



回复 使用道具 举报
TCP客户端:
  1. package com.kxg_06;

  2. import java.io.IOException;
  3. import java.io.OutputStream;
  4. import java.net.Socket;

  5. /*
  6. * TCP协议发送数据:
  7. *                 1.创建发送端口的Socket对象
  8. *                 2.获取输出流,写数据
  9. *                 3.释放资源
  10. */
  11. public class ClientDemo {
  12.         public static void main(String[] args) throws IOException {
  13.                 // public Socket(String host,int port)
  14.                 // 创建一个流套接字并将其连接到指定主机上的指定端口号
  15.                 Socket s = new Socket("10.164.22.254", 48264);
  16.                
  17.                 // 获取输出流
  18.                 // public OutputStream getOutputStream():返回此套接字的输出流。
  19.                 OutputStream os = s.getOutputStream();
  20.                 os.write("hello,TCP".getBytes());
  21.                
  22.                 // 释放资源
  23.                 s.close();
  24.         }
  25. }
复制代码
TCP服务器端:
  1. package com.kxg_06;

  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;

  6. /*
  7. * TCP协议接收数据:
  8. *                 1.创建接收端的Socket对象
  9. *                 2.监听客户端连接,返回一个对应的Socket对象
  10. *                 3.获取输入流,读取数据显示在控制台
  11. *                 4.释放资源
  12. */
  13. public class ServerDemo {
  14.         public static void main(String[] args) throws IOException {
  15.                 // ServerSocket类:此类实现服务器套接字。服务器套接字等待请求通过网络传入
  16.                 // public ServerSocket(int port)
  17.                 // 创建绑定到特定端口的服务器套接字
  18.                 ServerSocket ss = new ServerSocket(48264);

  19.                 // public Socket accept()
  20.                 // 监听客户端连接,返回一个对应的Socket对象
  21.                 Socket s = ss.accept();

  22.                 String ip = s.getInetAddress().getHostAddress();
  23.                 // public InputStream getInputStream():获取输入流
  24.                 InputStream is = s.getInputStream();

  25.                 // 解析数据并输出控制台
  26.                 byte[] bys = new byte[1024];
  27.                 int len = is.read(bys);
  28.                 String str = new String(bys, 0, len);
  29.                 System.out.println(ip + ":" + str);

  30.                 // 释放资源
  31.                 s.close();
  32.         }
  33. }
复制代码



回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马