BlogJava-路漫漫其修远兮，吾将上下而求索-随笔分类-网络技术

ByteBuffer用法小结(未完待续)

龙屠日 — Thu, 04 Feb 2010 01:47:00 GMT

ByteBuffer用法小结(未完待续)

在NIO中,数据的读写操作始终是与缓冲区相关联的.读取时信道(SocketChannel)将数据读入缓冲区,写入时首先要将发送的数据按顺序填入缓冲区.缓冲区是定长的,基本上它只是一个列表,它的所有元素都是基本数据类型.ByteBuffer是最常用的缓冲区,它提供了读写其他数据类型的方法,且信道的读写方法只接收ByteBuffer.因此ByteBuffer的用法是有必要牢固掌握的.

1.创建ByteBuffer
1.1 使用allocate()静态方法
    ByteBuffer buffer=ByteBuffer.allocate(256);
    以上方法将创建一个容量为256字节的ByteBuffer,如果发现创建的缓冲区容量太小,唯一的选择就是重新创建一个大小合适的缓冲区.

1.2 通过包装一个已有的数组来创建
    如下,通过包装的方法创建的缓冲区保留了被包装数组内保存的数据.
    ByteBuffer buffer=ByteBuffer.wrap(byteArray);

    如果要将一个字符串存入ByteBuffer,可以如下操作:
    String sendString="你好,服务器. ";
    ByteBuffer sendBuffer=ByteBuffer.wrap(sendString.getBytes("UTF-16"));

2.回绕缓冲区
buffer.flip();
这个方法用来将缓冲区准备为数据传出状态,执行以上方法后,输出通道会从数据的开头而不是末尾开始.回绕保持缓冲区中的数据不变,只是准备写入而不是读取.

3.清除缓冲区
buffer.clear();
这个方法实际上也不会改变缓冲区的数据,而只是简单的重置了缓冲区的主要索引值.不必为了每次读写都创建新的缓冲区,那样做会降低性能.相反,要重用现在的缓冲区,在再次读取之前要清除缓冲区.

4.从套接字通道(信道)读取数据
int bytesReaded=socketChannel.read(buffer);
执行以上方法后,通道会从socket读取的数据填充此缓冲区,它返回成功读取并存储在缓冲区的字节数.在默认情况下,这至少会读取一个字节,或者返回-1指示数据结束.

5.向套接字通道(信道)写入数据
socketChannel.write(buffer);
此方法以一个ByteBuffer为参数,试图将该缓冲区中剩余的字节写入信道.

龙屠日 2010-02-04 09:47 发表评论

使用SocketChannel的NIO客户机服务器通信示例。

龙屠日 — Wed, 03 Feb 2010 08:49:00 GMT

这只是长征路上的一小步，以后还有待改进。

NIO Selector示意图：

客户端代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

/**
* NIO TCP 客户端
*
* @date    2010-2-3
* @time    下午03:33:26
* @version 1.00
*/
public class TCPClient{
  // 信道选择器
  private Selector selector;

  // 与服务器通信的信道
  SocketChannel socketChannel;

  // 要连接的服务器Ip地址
  private String hostIp;

  // 要连接的远程服务器在监听的端口
  private int hostListenningPort;

  /**
   * 构造函数
   * @param HostIp
   * @param HostListenningPort
   * @throws IOException
   */
  public TCPClient(String HostIp,int HostListenningPort)throws IOException{
    this.hostIp=HostIp;
    this.hostListenningPort=HostListenningPort;

    initialize();
  }

  /**
   * 初始化
   * @throws IOException
   */
  private void initialize() throws IOException{
    // 打开监听信道并设置为非阻塞模式
    socketChannel=SocketChannel.open(new InetSocketAddress(hostIp, hostListenningPort));
    socketChannel.configureBlocking(false);

    // 打开并注册选择器到信道
    selector = Selector.open();
    socketChannel.register(selector, SelectionKey.OP_READ);

    // 启动读取线程
    new TCPClientReadThread(selector);
  }

  /**
   * 发送字符串到服务器
   * @param message
   * @throws IOException
   */
  public void sendMsg(String message) throws IOException{
    ByteBuffer writeBuffer=ByteBuffer.wrap(message.getBytes("UTF-16"));
    socketChannel.write(writeBuffer);
  }

  public static void main(String[] args) throws IOException{
    TCPClient client=new TCPClient("192.168.0.1",1978);

    client.sendMsg("你好!Nio!醉里挑灯看剑,梦回吹角连营");
  }
}

客户端读取线程代码：

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

public class TCPClientReadThread implements Runnable{
  private Selector selector;

  public TCPClientReadThread(Selector selector){
    this.selector=selector;

    new Thread(this).start();
  }

  public void run() {
    try {
      while (selector.select() > 0) {
        // 遍历每个有可用IO操作Channel对应的SelectionKey
        for (SelectionKey sk : selector.selectedKeys()) {

          // 如果该SelectionKey对应的Channel中有可读的数据
          if (sk.isReadable()) {
            // 使用NIO读取Channel中的数据
            SocketChannel sc = (SocketChannel) sk.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            sc.read(buffer);
            buffer.flip();

            // 将字节转化为为UTF-16的字符串
            String receivedString=Charset.forName("UTF-16").newDecoder().decode(buffer).toString();

            // 控制台打印出来
            System.out.println("接收到来自服务器"+sc.socket().getRemoteSocketAddress()+"的信息:"+receivedString);

            // 为下一次读取作准备
            sk.interestOps(SelectionKey.OP_READ);
          }

          // 删除正在处理的SelectionKey
          selector.selectedKeys().remove(sk);
        }
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

服务器端代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;

/**
* TCP服务器端
*
* @date    2010-2-3
* @time    上午08:39:48
* @version 1.00
*/
public class TCPServer{
  // 缓冲区大小
  private static final int BufferSize=1024;

  // 超时时间，单位毫秒
  private static final int TimeOut=3000;

  // 本地监听端口
  private static final int ListenPort=1978;

  public static void main(String[] args) throws IOException{
    // 创建选择器
    Selector selector=Selector.open();

    // 打开监听信道
    ServerSocketChannel listenerChannel=ServerSocketChannel.open();

    // 与本地端口绑定
    listenerChannel.socket().bind(new InetSocketAddress(ListenPort));

    // 设置为非阻塞模式
    listenerChannel.configureBlocking(false);

    // 将选择器绑定到监听信道,只有非阻塞信道才可以注册选择器.并在注册过程中指出该信道可以进行Accept操作
    listenerChannel.register(selector, SelectionKey.OP_ACCEPT);

    // 创建一个处理协议的实现类,由它来具体操作
    TCPProtocol protocol=new TCPProtocolImpl(BufferSize);

    // 反复循环,等待IO
    while(true){
      // 等待某信道就绪(或超时)
      if(selector.select(TimeOut)==0){
        System.out.print("独自等待.");
        continue;
      }

      // 取得迭代器.selectedKeys()中包含了每个准备好某一I/O操作的信道的SelectionKey
      Iterator<SelectionKey> keyIter=selector.selectedKeys().iterator();

      while(keyIter.hasNext()){
        SelectionKey key=keyIter.next();

        try{
          if(key.isAcceptable()){
            // 有客户端连接请求时
            protocol.handleAccept(key);
          }

          if(key.isReadable()){
            // 从客户端读取数据
            protocol.handleRead(key);
          }

          if(key.isValid() && key.isWritable()){
            // 客户端可写时
            protocol.handleWrite(key);
          }
        }
        catch(IOException ex){
          // 出现IO异常（如客户端断开连接）时移除处理过的键
          keyIter.remove();
          continue;
        }

        // 移除处理过的键
        keyIter.remove();
      }
    }
  }
}

协议接口代码：

import java.io.IOException;
import java.nio.channels.SelectionKey;

/**
* TCPServerSelector与特定协议间通信的接口
*
* @date    2010-2-3
* @time    上午08:42:42
* @version 1.00
*/
public interface TCPProtocol{
  /**
   * 接收一个SocketChannel的处理
   * @param key
   * @throws IOException
   */
  void handleAccept(SelectionKey key) throws IOException;

  /**
   * 从一个SocketChannel读取信息的处理
   * @param key
   * @throws IOException
   */
  void handleRead(SelectionKey key) throws IOException;

  /**
   * 向一个SocketChannel写入信息的处理
   * @param key
   * @throws IOException
   */
  void handleWrite(SelectionKey key) throws IOException;
}

协议实现类代码：

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Date;

/**
* TCPProtocol的实现类
*
* @date    2010-2-3
* @time    上午08:58:59
* @version 1.00
*/
public class TCPProtocolImpl implements TCPProtocol{
  private int bufferSize;

  public TCPProtocolImpl(int bufferSize){
    this.bufferSize=bufferSize;
  }

  public void handleAccept(SelectionKey key) throws IOException {
    SocketChannel clientChannel=((ServerSocketChannel)key.channel()).accept();
    clientChannel.configureBlocking(false);
    clientChannel.register(key.selector(), SelectionKey.OP_READ,ByteBuffer.allocate(bufferSize));
  }

  public void handleRead(SelectionKey key) throws IOException {
    // 获得与客户端通信的信道
    SocketChannel clientChannel=(SocketChannel)key.channel();

    // 得到并清空缓冲区
    ByteBuffer buffer=(ByteBuffer)key.attachment();
    buffer.clear();

    // 读取信息获得读取的字节数
    long bytesRead=clientChannel.read(buffer);

    if(bytesRead==-1){
      // 没有读取到内容的情况
      clientChannel.close();
    }
    else{
      // 将缓冲区准备为数据传出状态
      buffer.flip();

      // 将字节转化为为UTF-16的字符串
      String receivedString=Charset.forName("UTF-16").newDecoder().decode(buffer).toString();

      // 控制台打印出来
      System.out.println("接收到来自"+clientChannel.socket().getRemoteSocketAddress()+"的信息:"+receivedString);

      // 准备发送的文本
      String sendString="你好,客户端. @"+new Date().toString()+"，已经收到你的信息"+receivedString;
      buffer=ByteBuffer.wrap(sendString.getBytes("UTF-16"));
      clientChannel.write(buffer);

      // 设置为下一次读取或是写入做准备
      key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
    }
  }

  public void handleWrite(SelectionKey key) throws IOException {
    // do nothing
  }
}

龙屠日 2010-02-03 16:49 发表评论

使用DatagramChannel实现的服务器客户端通信例程

龙屠日 — Tue, 02 Feb 2010 05:50:00 GMT

改成了多线程处理，其余和原来差不多。

服务器端代码：

import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;

/**
* UDP服务器端
* @author Administrator
*
*/
public class UDPServer{
    public static void main(String[] args) throws Exception{
        // 使用DatagramChannel的open工厂方法创建一个数据报信道实例,该实例未绑定
        DatagramChannel channel=DatagramChannel.open();

        // 将该数据报信道实例的底层套接字绑定到5000端口
        channel.socket().bind(new InetSocketAddress(5000));

        // 使用ByteBuffer的静态方法创建一个新缓冲区,最长接收为60字节的数据报文
        ByteBuffer bf=ByteBuffer.allocate(60);

        while(true){
            System.out.println("监听开始");

            // 将接收到的数据报文存入指定的缓冲区并返回发送者的地址,如果缓冲区的剩余空间小于数据报文中的数据大小,多余的数据将毫无提示的丢失
            SocketAddress remoteAddress=channel.receive(bf);

            // 使用一个线程获得和返回信息
            new ProcessClientRequestThread(channel,remoteAddress,bf);
        }
    }
}

服务器端处理客户端请求代码：

import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.charset.Charset;

/**
* 服务器端处理客户端请求的线程
* @author Administrator
*
*/
public class ProcessClientRequestThread implements Runnable{
    // 监听的数据报信道
    private DatagramChannel channel;

    // 连接过来的远程服务器
    private SocketAddress remoteAddress;

    // 获取信息的缓冲区
    private ByteBuffer bf;

    /**
     * 构造函数
     * @param channel
     * @param remoteAddress
     * @param bf
     */
    public ProcessClientRequestThread(DatagramChannel channel,SocketAddress remoteAddress,ByteBuffer bf){
        this.channel=channel;
        this.remoteAddress=remoteAddress;
        this.bf=bf;

        new Thread(this).start();
    }

    @Override
    public void run() {
        try{
            System.out.println("收到了客户端的请求.");

            /********************************************
             *  接收部分
             ********************************************/
            // 反转此缓冲区,为下次读取做准备
            bf.flip();

            // 将字节转化为为UTF-16的字符串
            String receivedString=Charset.forName("UTF-16").newDecoder().decode(bf).toString();

            // 控制台打印出来
            System.out.println("接收到来自客户端"+remoteAddress.toString()+"的信息:"+receivedString);

            /********************************************
             *  发送部分
             ********************************************/
            // 将信息回执发送回去
            String sendString="你好,客户端("+remoteAddress.toString()+") 我已收到你的来信.";
            ByteBuffer bfSend=ByteBuffer.wrap(sendString.getBytes("UTF-16"));
            channel.send(bfSend, remoteAddress);

            System.out.println("处理客户端的请求完毕.");
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
    }
}

服务器端输出：

监听开始
收到了客户端的请求.
接收到来自客户端/192.168.1.107:55909的信息:你好,服务器. @Tue Feb 02 13:44:07
处理客户端的请求完毕.

客户端代码：

import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.charset.Charset;
import java.util.Date;

/**
* UDP客户端
* @author Administrator
*
*/
public class UDPClient{
    public static void main(String[] args) throws Exception{
        /********************************************
         *  发送部分
         ********************************************/
        // 使用DatagramChannel的open工厂方法创建一个数据报信道实例,该实例未绑定
        DatagramChannel channel=DatagramChannel.open();

        // 准备发送的文本
        String sendString="你好,服务器. @"+new Date().toString();

        // 将要发送的文本进行编码后置入一个缓冲区中
        ByteBuffer sendBuffer=ByteBuffer.wrap(sendString.getBytes("UTF-16"));

        // 创建一个包含了给定缓冲区中的中的数据的数据报文,并将其发送到目的地址指定的SocketAddress上
        channel.send(sendBuffer, new InetSocketAddress("192.168.1.107",5000));
        System.out.println("向服务器发送信息完毕");

        /********************************************
         *  接收部分
         ********************************************/
        // 使用ByteBuffer的静态方法创建一个新缓冲区,最长接收为80字节的数据报文
        ByteBuffer receiveBuffer=ByteBuffer.allocate(80);

        // 收取服务器端返回的信息
        SocketAddress remoteAddress=channel.receive(receiveBuffer);
        receiveBuffer.flip();

        // 将字节转化为为UTF-16的字符串
        String receivedString=Charset.forName("UTF-16").newDecoder().decode(receiveBuffer).toString();

        // 控制台打印出来
        System.out.println("接收到来自服务器"+remoteAddress.toString()+"的信息:"+receivedString);
    }
}

客户端输出：

向服务器发送信息完毕
接收到来自服务器/192.168.1.107:5000的信息:你好,客户端(/192.168.1.107:55912) 我已收到你的来信.

龙屠日 2010-02-02 13:50 发表评论

转载有关IM通信的讨论

龙屠日 — Mon, 01 Feb 2010 13:48:00 GMT

个人觉得分析得比较在理。
http://kayo.javaeye.com/blog/358559

这一篇帖子有不少干货：
http://topic.csdn.net/t/20021012/13/1090361.html

这一篇稍短些：
http://www.javaeye.com/topic/20659

这两篇也不错：
http://article.01hr.com/wenzhang/556732.htm
http://www.west263.com/info/html/wangzhanyunying/jianzhanjingyan/20080417/69972.html

一篇关于UDP文件传送的文章：
http://blog.csdn.net/pony1976bj/archive/2007/04/18/1568722.aspx

长连接的实现探讨：
http://www.javaeye.com/topic/246962

TCP长连接的Java实现：
http://www.cnblogs.com/pony/archive/2008/05/05/1183550.html

龙屠日 2010-02-01 21:48 发表评论

使用Java操作控制台命令Ping测试某台机器是否能连通示例

龙屠日 — Mon, 01 Feb 2010 06:26:00 GMT

在C/S程序编写中，常常需要知道对方机器的在线状态，因为只有对方在线了，其它的才有可能谈起。因此，我们在程序中需要一个“ping命令”。

网络上关于这方面的解决方案较多，有些是使用的InetAddress类的isReachable方法，我个人测试感觉不如Doc的ping命令可靠，于是还是转向了用Java调用控制台执行ping命令的传统方案。

具体的思路是这样的：通过程序调用类似“ping 192.168.172.1 -n 10 -w 4”的命令，这命令会执行ping十次，如果通顺则会输出类似“来自192.168.172.1的回复：字节=32 时间=23ms TTL=62”的文本（具体数字根据实际情况会有变化），其中中文是根据环境本地化的，有些机器上的中文部分是英文，但不论是中英文环境，后面的“=23ms TTL=62”字样总是固定的，它表明一次ping的结果是能通的。如果这个字样出现的次数等于10次即测试的次数，则说明192.168.172.1是百分之百能连通的。技术上具体调用dos命令用Runtime.getRuntime().exec实现，查看字符串是否符合格式用正则表达式实现，其它不值得赘述，请看具体的程序：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* 此類用於測試能否ping通另一臺機器
* @author 龍屠日
*
*/
public class Pinger {
    // 想要ping的遠程機器IP地址
    private String remoteIpAddress;

    // ping遠程機器的次數
    private final int pingTimes = 10;

    // 超時時間
    private int timeOut = 4;

    /**
     * 構造函數
     * @param remoteIpAddress
     * @param timeOut
     */
    public Pinger(String remoteIpAddress, int timeOut) {
        this.remoteIpAddress = remoteIpAddress;
        this.timeOut = timeOut;
    }

    /**
     * 測試是否能ping通
     * @param server
     * @param timeout
     * @return
     */
    public boolean isReachable() {
        BufferedReader in = null;
        Runtime r = Runtime.getRuntime();

        // 將要執行的ping命令,此命令是windows格式的命令
        String pingCommand = "ping " + remoteIpAddress + " -n "+pingTimes+" -w " + timeOut;

        try {
            // 執行命令并獲取輸出
            Process p = r.exec(pingCommand);
            if (p == null) {
                return false;
            }
            in = new BufferedReader(new InputStreamReader(p.getInputStream()));

            // 逐行檢查輸出,計算類似=23ms TTL=62這樣的字樣出現的次數
            int connectedCount=0;
            String line = null;
            while ((line = in.readLine()) != null) {
                connectedCount+=getCheckResult(line);
            }

            // 如果出現類似=23ms TTL=62這樣的字樣出現的次數等於測試次數則返回真
            return connectedCount==pingTimes;
        } catch (Exception ex) {
            ex.printStackTrace();

            // 出現異常則返回假
            return false;
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 若line含有=18ms TTL=16字樣,說明已經ping通,返回一,否則返回零.
     * @param line
     * @return
     */
    private static int getCheckResult(String line){
        Pattern pattern=Pattern.compile("(=\\d+ms)(\\s+)(TTL=\\d+)", Pattern.CASE_INSENSITIVE);
        Matcher matcher=pattern.matcher(line);
        while(matcher.find()){
            return 1;
        }

        return 0;
    }

    public static void main(String[] args) {
        Pinger p=new Pinger("129.125.162.12",10);

        System.out.println(p.isReachable());
    }
}

龙屠日 2010-02-01 14:26 发表评论

获取本机外网IP地址（External IP Address）示例

龙屠日 — Mon, 01 Feb 2010 03:21:00 GMT

程序如下。

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* 获取本机外网IP地址
* 思想是访问网站http://checkip.dyndns.org/，得到返回的文本后解析出本机在外网的IP地址
* @author Administrator
*
*/
public class ExternalIpAddressFetcher {
    // 外网IP提供者的网址
    private String externalIpProviderUrl;

    // 本机外网IP地址
    private String myExternalIpAddress;

    public ExternalIpAddressFetcher(String externalIpProviderUrl) {
        this.externalIpProviderUrl = externalIpProviderUrl;

        String returnedhtml = fetchExternalIpProviderHTML(externalIpProviderUrl);

        parse(returnedhtml);
    }

    /**
     * 从外网提供者处获得包含本机外网地址的字符串
     * 从http://checkip.dyndns.org返回的字符串如下
     * Current IP CheckCurrent IP Address: 123.147.226.222
     * @param externalIpProviderUrl
     * @return
     */
    private String fetchExternalIpProviderHTML(String externalIpProviderUrl) {
        // 输入流
        InputStream in = null;

        // 到外网提供者的Http连接
        HttpURLConnection httpConn = null;

        try {
            // 打开连接
            URL url = new URL(externalIpProviderUrl);
            httpConn = (HttpURLConnection) url.openConnection();

            // 连接设置
            HttpURLConnection.setFollowRedirects(true);
            httpConn.setRequestMethod("GET");
            httpConn.setRequestProperty("User-Agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows 2000)");

            // 获取连接的输入流
            in = httpConn.getInputStream();
            byte[] bytes=new byte[1024];// 此大小可根据实际情况调整

            // 读取到数组中
            int offset = 0;
            int numRead = 0;
            while (offset < bytes.length
                   && (numRead=in.read(bytes, offset, bytes.length-offset)) >= 0) {
                offset += numRead;
            }

            // 将字节转化为为UTF-8的字符串
            String receivedString=new String(bytes,"UTF-8");

            // 返回
            return receivedString;
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
                httpConn.disconnect();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }

        // 出现异常则返回空
        return null;
    }

    /**
     * 使用正则表达式解析返回的HTML文本,得到本机外网地址
     * @param html
     */
    private void parse(String html){
        Pattern pattern=Pattern.compile("(\\d{1,3})[.](\\d{1,3})[.](\\d{1,3})[.](\\d{1,3})", Pattern.CASE_INSENSITIVE);
        Matcher matcher=pattern.matcher(html);
        while(matcher.find()){
            myExternalIpAddress=matcher.group(0);
        }
    }

    /**
     * 得到本机外网地址,得不到则为空
     * @return
     */
    public String getMyExternalIpAddress() {
        return myExternalIpAddress;
    }

    public static void main(String[] args){
        ExternalIpAddressFetcher fetcher=new ExternalIpAddressFetcher("http://checkip.dyndns.org/");

        System.out.println(fetcher.getMyExternalIpAddress());
    }
}

龙屠日 2010-02-01 11:21 发表评论

取得本地IP地址（非外部地址）程序示例

龙屠日 — Mon, 01 Feb 2010 02:12:00 GMT

/**
* 此类用于取出本机的IP地址
*
* @date 2009-11-5
* @time 上午10:41:13
*/
public class IPAddrFetcher{
    public String getIPInfo(){

        StringBuilder sb=new StringBuilder();

        try{
            Enumeration<NetworkInterface> interfaces=NetworkInterface.getNetworkInterfaces();

            while(interfaces.hasMoreElements()){
                NetworkInterface ni=interfaces.nextElement();

                sb.append("Interface "+ni.getName()+":\r\n");


                Enumeration<InetAddress> inetAddresses=ni.getInetAddresses();

                while(inetAddresses.hasMoreElements()){
                    InetAddress address=inetAddresses.nextElement();

                    sb.append("Address");

                    if(address instanceof Inet4Address){
                        sb.append("(v4)");
                    }
                    else{
                        sb.append("(v6)");
                    }

                    sb.append(":address="+address.getHostAddress()+" name="+address.getHostName()+"\r\n");
                }
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }

        return sb.toString();
    }

    public static void main(String[] args){
        IPAddrFetcher iPAddrFetcher=new IPAddrFetcher();
        System.out.println(iPAddrFetcher.getIPInfo());
    }
}

取出结果：

1 Interface lo:
2 Address(v6):address=0:0:0:0:0:0:0:1 name=0:0:0:0:0:0:0:1
3 Address(v4):address=127.0.0.1 name=127.0.0.1
4 Interface net0:
5 Interface net1:
6 Interface ppp0:
7 Interface eth0:
8 Interface eth1:
9 Interface ppp1:
10 Interface net2:
11 Interface eth2:
12 Interface eth3:
13 Address(v6):address=fe80:0:0:0:61d1:8ddf:b502:c3a3%10 name=fe80:0:0:0:61d1:8ddf:b502:c3a3%10
14 Interface net3:
15 Address(v6):address=fe80:0:0:0:5ed:3570:c040:1e1b%11 name=CHINESE-EVJ6MAU
16 Address(v4):address=192.168.1.100 name=CHINESE-EVJ6MAU
17 Interface net4:
18 Interface net5:
19 Address(v6):address=fe80:0:0:0:0:5efe:c0a8:164%13 name=fe80:0:0:0:0:5efe:c0a8:164%13
20 Interface net6:
21 Address(v6):address=2001:0:cf2e:3096:9e:1f8:3f57:fe9b name=CHINESE-EVJ6MAU
22 Address(v6):address=fe80:0:0:0:9e:1f8:3f57:fe9b%14 name=CHINESE-EVJ6MAU
23 Interface eth4:
24 Interface eth5:
25 Interface eth6:
26 Interface eth7:
27 Interface net7:
28 Interface net8:
29
30

龙屠日 2010-02-01 10:12 发表评论

使用数据报信道收发信息示例

龙屠日 — Mon, 01 Feb 2010 02:01:00 GMT

发送程序：

/**
* 数据报发送者类
*
* @date    2010-2-1
* @time    上午08:54:10
* @version 1.00
*/
public class Sender{
    public static void main(String[] args) throws Exception{
        // 使用DatagramChannel的open工厂方法创建一个数据报信道实例,该实例未绑定
        DatagramChannel channel=DatagramChannel.open();

        // 准备发送的文本
        String sendString="你好,服务器. @"+new Date().toString();

        // 将要发送的文本进行编码后置入一个缓冲区中
        ByteBuffer bf=ByteBuffer.wrap(sendString.getBytes("UTF-16"));

        // 创建一个包含了给定缓冲区中的中的数据的数据报文,并将其发送到目的地址指定的SocketAddress上
        channel.send(bf, new InetSocketAddress("192.168.0.1",5000));
    }
}

收取程序：

/**
* 数据报接收者类
*
* @date    2010-2-1
* @time    上午09:03:10
* @version 1.00
*/
public class Receiver{
    public static void main(String[] args) throws Exception{
        // 使用DatagramChannel的open工厂方法创建一个数据报信道实例,该实例未绑定
        DatagramChannel channel=DatagramChannel.open();

        // 将该数据报信道实例的底层套接字绑定到5000端口
        channel.socket().bind(new InetSocketAddress(5000));

        // 使用ByteBuffer的静态方法创建一个新缓冲区,最长接收为60字节的数据报文
        ByteBuffer bf=ByteBuffer.allocate(60);

        // 将接收到的数据报文存入指定的缓冲区并返回发送者的地址,如果缓冲区的剩余空间小于数据报文中的数据大小,多余的数据将毫无提示的丢失
        SocketAddress remoteAddress=channel.receive(bf);

        // 反转此缓冲区,为下次读取做准备
        bf.flip();

        // 将字节转化为为UTF-16的字符串
        String receivedString=Charset.forName("UTF-16").newDecoder().decode(bf).toString();

        // 控制台打印出来
        System.out.println("接收到来自"+remoteAddress.toString()+"的信息:"+receivedString);
    }
}

注意：
以上方法在局域网内好用，互联网内需要服务器端在公网。

龙屠日 2010-02-01 10:01 发表评论