`
damies
  • 浏览: 238513 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java socket开发实例入门

阅读更多
socket用中文意思就是我们常说的”套接字“,我们用它来解决基于TCP/IP协议的网络通信。Java有一套功能强大而又易于使用的网络开发API,这个API是一系列的接口和类,在java.net和javax.net包中可以找到它们。套接字一般分为两种:流套接字(Stream Socket)和数据报套接字(Datagram Sockets)。关于套接字的编程可以写成一本书,本文不想在这里做深入探究(其实是本人功力还不够,嘿嘿...),这次主要是了解一下流套接字的基本开发。

一、几个重要的API
1、InetAddress类
描述
:该类在套接字编程中份演着目的地角色,通常作为参数传递给流套接字类和数据报套接字的构造方法或其它方法。
 
构造方法:该类只有一个默认的不带参的构造方法。
不能直接用new创建一个InetAddress对象。象这样做
    InetAddress ia = new InetAddress ();
就是错误的。但是我们可以通过它的5个静态工厂方法获得一个InetAddress对象或对象数组。
 
重要方法:
    static InetAddress[] getAllByName(String host);
    通过传递参数host(主机名),返回一个InetAddress对象数组的引用。如果指定的主机没有IP地址存在,则方法抛出一个UnknownHostException 异常对象。
    static InetAddress getByAddress(byte[] addr);
    通过传递一个用字节数组表示的二进制IP地址参数(4字节对应Ipv4,16字节对应Ipv6),返回一个InetAddress对象的引用。如果返回对象的数组既不是4字节也不是16字节,则方法抛出一个UnknownHostException 异常对象。
    static InetAddress getByAddress(String host, byte[] addr);
    创建一个基于给定主机名和给定字节数组组成的IP地址的InetAddress对象。如果返回对象中的数组既不是4字节也不是16字节,则方法抛出一个UnknownHostException 异常对象。
    static InetAddress getByName(String host);
    返回一个与给定主机名的InetAddress对象。如果指定的主机没有IP对应,则方法抛出一个UnknownHostException异常对象。
    static InetAddress getLocalHost();
    返回一个包含本地主机的IP地址的InetAddress对象。
   
    上面讲到的方法均提到返回一个或多个InetAddress对象的引用,实际上每一个方法都要返回一个或多个Inet4Address/Inet6Address对象的引用。一旦获得了InetAddress对象,你就可以使用其他非静态方法得到你想要的东东了。
 
2、Socket类
描述:Socket是建立网络连接时使用的。在连接成功时,服务端和客户端都会产生一个Socket实例,操作这个实例,完成所需的会话。对于一个网络连接来说,套接字是平等的,并没有差别,不因为在服务器端或在客户端而产生不同级别。
 
构造方法:该类有多个构造方法,常用的有两个:Socket(InetAddress addr, int port) Socket(String host, int port)
    两个构造方法都创建了一个基于指定接服务器主机名或InetAddress和服务器端口号的流套接字。对于第一个InetAddress子类对象通过addr参数获得服务器主机的IP地址,对于第二个函数host参数包被分配到InetAddress对象中,如果没有IP地址与host参数相一致,那么将抛出UnknownHostException异常对象。
    如果创建连接成功,java网络API将在客户端的流套接字中捆绑客户程序的IP地址和任意一个端口号,否则两个函数都会抛出一个IOException对象。
 
重要方法:
    InputStream getInputStream();
    获得网络连接输入,同时返回一个IutputStream对象实例。
    OutputStream getOutputStream();
    获得网络连接输出,连接的另一端将得到输入,同时返回一个OutputStream对象实例。
    必须捕获两个方法可能产生的IOException。怎么操作这些流对象就看你要作什么了!:)
 
3、ServerSocket类
描述:该类用于服务器端。
构造方法:该类有四个构造方法,常用的有:
    ServerSocket(int port)
    通过指定监听端口号来创建ServerSocket对象,如果在这时出现错误将抛出IOException异常对象,否则将创建ServerSocket对象并开始准备接收连接请求。接下来无限循环调用accept()方法。
 
重要方法:
    Socket accept();
    调用开始后accept()方法将导致调用线程阻塞直到连接建立。在建立连接后accept()返回一个最近创建的Socket对象,该Socket对象绑定了客户程序的IP地址和端口号。
 
4、注意事项:
    在服务端和客户端均未发送数据时,不要在同时在两端的while()循环里读取 InputStream。否则将造成阻塞。
    如果用字符流处理数据,请在数据末尾加上 “\r\n”,并记得 flush()一下。
 
二、实例
1、 服务端 SimpleServerSocket:
    例子采用字节流来操作,注释部分是采用字符流来操作。
java 代码
  1. package com.unihub.unicall.test;   
  2.   
  3. import java.io.IOException;   
  4. import java.net.ServerSocket;   
  5.   
  6. public class SocketServerTest {   
  7.     private ServerSocket server = null;   
  8.      private int port = 9999;   
  9.      public SocketServerTest() throws IOException    
  10.      {   
  11.       int counter = 1;   
  12.       try    
  13.       {   
  14.        this.server = new ServerSocket(this.port);   
  15.       }    
  16.       catch (Exception ex)    
  17.       {   
  18.        System.err.println("Can't listening on port:" + this.port);   
  19.        ex.printStackTrace(System.err);   
  20.        System.exit(-1);   
  21.       }   
  22.       System.out.println("Start listening on port:" + this.port);   
  23.       while (true)    
  24.       {   
  25.        new ServerThread(server.accept(),counter).start();   
  26.        counter++;   
  27.       }   
  28.      }   
  29.      public static void main(String[] args) throws Exception    
  30.      {   
  31. //       SocketServerTest sserver =    
  32.              new SocketServerTest();   
  33.      }   
  34.   
  35. }   

线程类:

java 代码
  1. package com.unihub.unicall.test;   
  2.   
  3. import java.io.BufferedInputStream;   
  4. import java.io.BufferedOutputStream;   
  5. import java.io.IOException;   
  6. import java.net.Socket;   
  7.   
  8. import com.unihub.unicall.common.util.SocketUtil;   
  9.   
  10. public class ServerThread extends Thread {   
  11.     private Socket client;   
  12.   
  13.     private int counter;   
  14.   
  15.     public ServerThread(Socket client, int counter) {   
  16.         System.out.println("[info] Create connection with "  
  17.                 + client.getInetAddress().getHostAddress().toString()   
  18.                 + " successful.");   
  19.         this.client = client;   
  20.         this.counter = counter;   
  21.     }   
  22.   
  23.     public void run() {   
  24.         try {   
  25.             BufferedInputStream bis = new BufferedInputStream(client   
  26.                     .getInputStream());   
  27.             BufferedOutputStream bos = new BufferedOutputStream(client   
  28.                     .getOutputStream());   
  29.             // BufferedReader in = new BufferedReader(new   
  30.             // InputStreamReader(client.getInputStream()));   
  31.             // PrintWriter out = new PrintWriter(client.getOutputStream(),true);   
  32.   
  33.             bos.write(("Hi! Enter QUIT to exit.\r\n").getBytes());   
  34.             bos.flush();   
  35.   
  36.             boolean done = false;   
  37.             byte[] bytes = new byte[client.getReceiveBufferSize()];   
  38.             while (!done) {   
  39.                 int contentLength = bis.read(bytes);   
  40.   
  41.                 if (contentLength == -1) {   
  42.                     System.out.println("contentLength = " + contentLength);   
  43.                     done = true;   
  44.                 } else {   
  45. //                  String recieve = new String(bytes, 0, contentLength);   
  46. //                  if (recieve.trim().equalsIgnoreCase("quit")) {   
  47. //                      done = true;   
  48. //                  } else {   
  49. //                      System.out.println("[info] " + recieve);   
  50. //   
  51. //                      bos   
  52. //                              .write(("Echo server(" + counter + "):"   
  53. //                                      + recieve + "\r\n").getBytes());   
  54. //                      bos.flush();   
  55. //                  }   
  56.                     byte[] b1 = SocketUtil.getSubByte(bytes, 04);   
  57.                     byte[] b2 = SocketUtil.getSubByte(bytes, 44);   
  58.                     byte[] b3 = SocketUtil.getSubByte(bytes, 20257);   
  59.                     System.out.println("111111111111:"+SocketUtil.byte2int(b1));   
  60.                     System.out.println("报文长度:"+SocketUtil.byte2int(b2));   
  61.                     System.out.println("报文内容:"+new String(b3,"ISO-8859-1"));   
  62.                 }   
  63.             }   
  64.                
  65.             // String recieve;   
  66.             // while((recieve = in.readLine()) != null)   
  67.             // {   
  68.             // if(recieve.trim().equalsIgnoreCase("quit")){break;}   
  69.             // else   
  70.             // {   
  71.             // System.out.println("[info] " + recieve);   
  72.             // out.println("Echo server("+ counter +"):" + recieve);   
  73.             // }   
  74.             // }   
  75.         } catch (Exception e) {   
  76.             e.printStackTrace();   
  77.         } finally {   
  78.             try {   
  79.                 if (client != null) {   
  80.                     client.close();   
  81.                     System.out.println("[info] Disconnect successful.");   
  82.                 }   
  83.             } catch (IOException e1) {   
  84.                 e1.printStackTrace();   
  85.             }   
  86.         }   
  87.     }   
  88.   
  89. }   

2、 客户端 SimpleSocket:

java 代码
  1. package com.cyberobject.socket;   
  2.     
  3. import java.io.*;   
  4. import java.net.*;   
  5.   
  6. public class SimpleSocket    
  7. {    
  8.  private Socket client;   
  9.  private String host = "192.168.0.66";   
  10.  private int port = 30000;   
  11.     
  12.  public SimpleSocket()     
  13.  {     
  14.   try    
  15.   {   
  16.    this.client = new Socket(InetAddress.getByName(this.host),this.port);   
  17.         
  18.    System.out.println("[info] Connect to " + this.host + " successful.");   
  19.     
  20. //          BufferedReader in = new BufferedReader(new   
  21. //          InputStreamReader(client.getInputStream()));   
  22. //          PrintWriter out = new PrintWriter(client.getOutputStream(),true);   
  23.    BufferedReader systemIn = new BufferedReader(new InputStreamReader(System.in));   
  24.        
  25.     BufferedInputStream bis = new BufferedInputStream(client.getInputStream());   
  26.    BufferedOutputStream bos = new BufferedOutputStream(client.getOutputStream());   
  27.     
  28.    System.out.println("[info] Start...");   
  29.     
  30.   boolean done = false;   
  31. //              while(!done)   
  32. //              {   
  33. //               String recieve = in.readLine();   
  34. //               if(recieve == null) done = true;   
  35. //               else   
  36. //               {   
  37. //                System.out.println(recieve);   
  38. //                out.println(systemIn.readLine());   
  39. //               }   
  40. //              }   
  41.     
  42.    byte[] bytes = new byte[client.getReceiveBufferSize()];   
  43.    int len = 0;   
  44.    while (!done)   
  45.    {    
  46.     len = bis.read(bytes);   
  47.     if (len == -1) done = true;   
  48.     else    
  49.     {       
  50.      String recieve = new String(bytes, 0, len);   
  51.          
  52.       System.out.println(recieve);   
  53.      bos.write(systemIn.readLine().getBytes());   
  54.      bos.flush();   
  55.     }   
  56.    }   
  57.       
  58.    System.out.println("[info] Stop.");   
  59.   }      
  60.   catch (Exception ex)    
  61.   {   
  62.    ex.printStackTrace(System.err);   
  63.   }    
  64.   finally    
  65.   {   
  66.    try  
  67.    {   
  68.     if (client != null)    
  69.     {   
  70.      client.close();   
  71.     }   
  72.    }    
  73.    catch (IOException e)    
  74.    {   
  75.     e.printStackTrace();   
  76.    }   
  77.   }   
  78.  }   
  79.     
  80.  public static void main(String[] args)    
  81.  {   
  82.   SimpleSocket ssocket = new SimpleSocket();   
  83.  }   
  84. }   
分享到:
评论
4 楼 struts2VSspring 2012-01-06  
貌似运行有错唉
3 楼 f_zongjian 2009-04-22  
wzx7934003 写道

兄弟,少一个socketutil类啊,能麻烦贴一下吗

-------------------------
public static byte[] getSubByte(byte[] byteArray, int startIndex, int endIndex) {
byte[] newArray = new byte[endIndex - startIndex + 1];
for(int index = 0; index < (endIndex - startIndex); index++) {
newArray[index] = byteArray[startIndex + index];
}
return newArray;
}
public static int byte2int(byte[] byteArray) {
return new Integer(new String(byteArray)).intValue();
}
2 楼 ypluck 2008-12-17  
SocketUtil就实现了一个截取,一个转换,自己写个就OK
1 楼 wzx7934003 2008-11-26  
兄弟,少一个socketutil类啊,能麻烦贴一下吗

相关推荐

    有关Java的Socket编程入门例子

    通过这个入门例子,初学者可以理解Java Socket编程的基本原理和操作步骤,为进一步的网络编程打下坚实的基础。实际开发中,还可以结合NIO(非阻塞I/O)或其他高级框架如Netty,提高网络通信的效率和灵活性。

    Java Socket传输图片源代码

    在Java编程语言中,Socket是实现网络通信的基础组件。...同时,这个例子也适合初学者作为入门教程,通过实际操作加深对Socket编程的理解。在实际开发中,可以结合其他技术,如多线程、NIO等,提升程序性能和稳定性。

    Java网络编程从入门到精通

    本教程“Java网络编程从入门到精通”将详细讲解这些概念,并通过实例代码说明如何在实践中应用。通过学习,你将掌握创建网络服务、处理网络请求、优化网络性能等技能,为你的Java开发生涯打下坚实的基础。无论是新手...

    220个JAVA初学者实例

    以上只是Java初学者实例中可能涉及的部分关键知识点,通过220个实例的实践,你可以逐步建立起扎实的Java基础,为后续深入学习和项目开发打下坚实的基础。不断地练习和巩固这些知识,将有助于你成长为一名合格的Java...

    Java Socket网络编程初级入门

    Java Socket网络编程是Java开发中实现网络通信的基础,它提供了客户端和服务器端进行数据交换的接口。在Java SDK中,`java.net`包包含了Socket相关的API,使得开发者能够轻松地进行网络编程。 首先,要理解网络编程...

    Java开发从入门到精通 扶松柏,陈小玉编著 2016.09 随书光盘

    《Java开发从入门到精通》是由扶松柏和陈小玉两位专家编著的书籍,旨在帮助初学者和有一定基础的开发者系统学习和掌握Java编程技术。2016年9月出版的这本书包含了丰富的教学内容,配合随书光盘,提供了一套完整的...

    Java简单实例入门

    本资源“Java简单实例入门”旨在为初学者提供一个轻松的学习起点,引导他们踏入编程的世界。CHM(Compiled Help Manual)文件是一种常见的帮助文档格式,用于存储教程和指南,便于用户查阅和学习。 在“Java简单...

    java 整理实例入门教程

    本教程《Java 整理实例入门教程》是为初学者精心准备的,旨在帮助学习者快速掌握Java的基础知识和实际操作技巧。首先,我们可以从"java_百度百科.htm"中了解到Java的历史、特点和主要应用领域。这篇文档可能包含了...

    Java入门与实例教程(非常详细,适合初学者)

    最后,为了确保初学者能够适应实际开发需求,教程可能会介绍Java Swing或JavaFX库来创建图形用户界面(GUI),或者讲解如何使用Java进行网络编程,例如Socket通信。 总之,“Java入门与实例教程”为初学者提供了...

    Java网络编程基础教程之Socket入门实例

    在Java中,你可以通过`java.net.Socket`类来创建一个Socket实例。例如,要连接到指定IP地址和端口号的服务器,你可以这样操作: ```java Socket socket = new Socket("78.46.84.171", 80); ``` 如果IP地址是域名,...

    《Java从入门到精通:实例版》源程序

    《Java从入门到精通:实例版》是一本旨在帮助初学者快速掌握Java编程语言的教程。这本书通过实例化的教学方式,让学习者能够在实践中理解并掌握Java的核心概念和技术。源程序包含了书中各个章节的实例代码,是加深...

    JAVA基础入门到精通pdf

    Java编程语言是全球范围内广泛应用的开发工具,尤其在企业级应用和互联网开发中占据着重要地位。本资源“JAVA基础入门到精通pdf”提供了一条系统学习Java的路径,适合初学者作为入门教程。以下是对Java基础知识的...

    Java入门笔记9_Socket

    ### Java入门笔记9_Socket详解 #### 一、Socket概念与分类 在计算机网络通信领域,Socket被广泛地应用于客户端与服务器之间的数据交互。Socket,即套接字,是网络编程中的基本概念,用于实现不同计算机系统之间的...

    java网络编程从入门到精通

    Java网络编程是开发分布式应用...通过阅读"Java网络编程从入门到精通"这本书,你将系统地学习到以上所有内容,并通过实例和练习加深理解,从而在实际项目中灵活运用这些知识,成为一名精通Java网络编程的专业开发者。

    socket入门Demo

    这个“socket入门Demo”应该包含了基本的Socket编程实例,旨在帮助初学者理解和掌握Socket通信的基本原理和操作步骤。 Socket在概念上可以理解为通信的端点,它提供了在网络中发送和接收数据的接口。在Java中,...

    Java.2.入门与实例教程

    入门与实例教程"是一个针对初学者的教育资源,旨在帮助新手快速掌握Java编程的基础概念和实战技巧。这个教程可能包含了从基础知识到实际项目案例的全方位讲解,帮助学习者逐步建立起对Java语言的理解。 首先,让...

    Java基础入门.rar

    在压缩包中,"Java基础入门"可能包含了一系列初级到中级的Java编程教程或实例。这些源码可能是逐步引导读者理解基本语法、数据类型、控制结构、类与对象、继承、多态、异常处理等核心概念的示例。通过实际编写和运行...

    完整版精品java课件 Java基础入门教程 Java程序设计 第14章 socket网络编程(共24页).ppt

    7. **示例代码**:服务器端通常先创建`ServerSocket`并调用`accept()`阻塞等待,然后通过返回的新`Socket`实例进行数据交换。客户端则创建`Socket`对象指定服务器的IP和端口,获取流并进行通信。通信结束后,都要...

    Java程序设计(入门)+习题

    Java提供了Socket和ServerSocket类进行网络通信,实现了客户端和服务器之间的数据传输。 十、习题解答 书中的习题涵盖了上述所有知识点,通过解题,读者可以更好地理解和掌握Java编程。每个习题都对应详细的答案,...

    java从入门到精通第四版课本实例源程序

    6. **网络编程**:Java提供了Socket编程接口,使得开发网络应用程序成为可能。"sl"中的实例可能涉及TCP/IP连接、数据的发送和接收,展示了如何进行网络通信。 7. **数据库操作**:Java JDBC(Java Database ...

Global site tag (gtag.js) - Google Analytics