Java入门笔记9_Socket （转）

1. Client/Server Networking

Java通过socket来完成它所有的网络底层的通讯，socket是一种通讯的通道，通过它可以将数据通过特定的端中发送及接收。Java中的socket可以分成二大类：

（1） Datagram Sockets：数据包socket；

（2） Stream Sockets：流socket；

1.2 Datagram Socket

Datagram socket使用UDP来实现数据通讯，因此它不能保证数据能够到达目的地，但是由于它不需要专用的网络链接，所以它所需的资源相对少的多。

Datagram以包的方式发送数据，但它不能保证这些数据包以特定的顺序到达目的，因此包中往往需要包含序列号的信息，接收方可以根据序列号的信息决定是否所有的包都已收到，并按正常顺序重组这些包。

Java通过两个类DatagramSocket和DatagramPacket来支持Datagram socket。DatagramSocket实现了Datagram socket的基本功能，而DatagramPacket则提供了对包的一些支持。

DatagramSocket的几个重要方法：

（1） DatagramSocket()：随机绑定一个有效的端口；

（2） DatagramSocket(int port)：绑定指定的端口；

（3） Void send(DatagramPacket p)：发送数据报，由于目的地的地址信息已包含在数据报中，所以不需要在本函数中提供地址信息；

（4） synchronized void receive(DatagramPacket p)：接收数据包，线程安全；

（5） synchronized void close()：关闭socket；

在DatagramSocket中并不区分ServerSocket和ClientSocket，如果一定要区分，那么发送的是client，而接收的是server。

DatagramPacket有以几个重要的方法：

（1） DatagramPacket(byte ibuf[], int ilength)：用于接收数据报；

（2） DatagramPacket(byte ibuf[], int ilength, InetAddressiaddr, int iport)：用于发送的数据报；

（3） byte[] getData()

（4） int getLength()

以下是完整的Datagram Socket的例子：

接收端，Server端代码：

import java.io.*;

import java.net.*;

 

class FortuneServer1 extends Thread

{

  DatagramSocket ServerSocket;

  public FortuneServer1()

  {

    super("FortuneServer1");

    try

      {

        ServerSocket = new DatagramSocket(1114);

        System.out.println("FortuneServer up and running...");

      }

    catch (SocketException e)

      {

        System.err.println("Exception: couldn't create datagram socket");

        System.exit(1);

      }  } 

 

  public static void main(String[] args)

  {

     FortuneServer1 server = new FortuneServer1();

     server.start();

  }

 

 public void run()

 {

   if (ServerSocket == null)

     return;

 

   while (true)

   {

     try

       {

          InetAddress     address;

          int             port;

          DatagramPacket  packet;

          byte[]          data = new byte[256];

          int             num = 1;

         

          packet = new DatagramPacket(data, data.length);

          ServerSocket.receive(packet);   

          address = packet.getAddress();

          port = packet.getPort();

         

          File inFile = new File("Fortunes.txt");

          FileInputStream inStream = new FileInputStream(inFile);

         

          if (inStream.read(data) <= 0)

            {

               System.err.println("Error: couldn't read fortunes");            

            }

         

         packet = new DatagramPacket(data, data.length, address, port);

          ServerSocket.send(packet);

       }

     catch (Exception e)

       {

          System.err.println("Exception: " + e);

          e.printStackTrace();

       }   } } }

说明：

（1） 这个例子中接收端的socket使用了多线程，多线程的概念可以参考本文的多线程部分；

（2） 在构造函数中创建了DatagramSocket，并且使用了1114这个端口；

（3） 本例子的关键函数是run，它使用了死循环，在循环中使用了receive这方法来临听1114端口，如果1114端口没有请求数据到来，那么这个程序就一直停留在receive这个位置，不再往下执行；

（4） 当1114端有数据时，receive方法将接收到的DatagramPacket数据包放在packet这个对象中，然后解析其中的数据，获取发送方的地址信息；

（5） 然后再创建DatagramPacket包，并填充数据，发送到原接收端。

以下是发送端的代码：

import java.io.*;

import java.net.*;

class FortuneClient

{

    public static void main(String args[])

    {

        FortuneClient client = new FortuneClient();

        System.out.println(client.getMessage());

    }

   

    public String getMessage()

    {

        String fortune;

   try {

     DatagramSocket  socket;

     DatagramPacket  packet;

     byte[]          data = new byte[256];

 

     socket = new DatagramSocket();

     packet = new DatagramPacket(data, data.length,InetAddress.getByName("127.0.0.1"), 1114);

     socket.send(packet);

 

     packet = new DatagramPacket(data, data.length);

     socket.receive(packet);

     fortune = new String(packet.getData(), 0);

     socket.close();

   }

   catch (UnknownHostException e) {

     System.err.println("Exception: host could not be found");

     return null;

   }

   catch (Exception e) {

     System.err.println("Exception: " + e);

     e.printStackTrace();

     return null;

   }

   return fortune;

  } }

客户端的代码与服务器端的代码基本相同，只是没有了循环，并且处理步骤与服务器端的基本相反。这也说明了Datagram Socket不真正区分Server和Client。

1.3 Stream Socket

Stream Socket与Datagram Socket不同，它有一个永久性的链接，可以确保数据可靠的发送到对方。但是Stream Socket所占的资源更多。

Java主要通过Socket及ServerSocket来实现Stream Socket，一个用于客户端，另一个用户服务器端。

Socket类的几个重要方法如下：

（1） Socket(String host, int port)

（2） Socket(InetAddress address, int port)

（3） synchronized void close()

（4） InputStream getInputStream()

（5） OutputStream getOutputStream()

可以看出Stream Socket中的Socket与Datagram Socket中的Socket的区别：

（1） 在构造函数中，这里需要指定服务器的地址与端口，用于它发送数据之前建立链接，而Datagram的Socket不需要建立链接，它仅需要在要发送的数据包中包含地址信息即可；

（2） Stream Socket的两个重要方法和其它流的方法类似，而且在操作上也相似，其实在操作Stream Socket时，只要建立了链接，那么以后的操作和流的操作一样了，你可以忘了你在操作Socket，只当做自己在操作普通的流。

ServerSocket有以下几个重要的方法：

（1） ServerSocket(int port)：监听指定端口，监听时间为默认值50；

（2） ServerSocket(int port, int count)：监听指定端口，并指定监听时间；

（3） ServerSocket(int port, int backlog, InetAddress bindAddr)：只接收指定接口发过来的数据；

（4） Socket accept()：accpet方法会返回一个Socket对象，使用该Socket对象的getInputStream及getOutputStream方法获取输入及输出流。由此可见无论是服务器端还是客户端，它们都是通过Socket对象来收发数据的。程序执行到accpet时会进入监听状态，不再向下执行一直到接收到数据。

（5） void close()

以下是关于Stream Socket的一个例子，在这个例子中使用单独的二个类Receiver和Sender负责对指定的输入及输出流进行操作，用另一个类SocketPerformer来创建Receiver和Sender这两个类的实例，并传入指定的输入及输出流，而在Client及Server这两个类中，负责创建SocketPerformer对象，并传入指定的Socket。因此这五个类在功能上分为三层，第一层负责对流进行操作，第二层负责创建指定的Socket流，并这些Socket流传到第一层，第三层负责创建Socket并将这些Socket传到第二层。

Receriver代码：

package socketChat;

import java.io.BufferedReader;

public class Receiver extends Thread {

    BufferedReader reader;

    public Receiver(BufferedReader theSocketReader) {

        reader = theSocketReader;

    }

 

    public void run() {

        while (true) {

            try {

                String words = reader.readLine();                System.out.println("/r/n<<< " + words);

            } catch (Exception e) {

                e.printStackTrace();

                return;

            }        }    }}

Sender代码：

package socketChat;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

 

public class Sender extends Thread {   

    PrintWriter writer;

    public Sender(PrintWriter theWriter) {

        writer = theWriter;

    }

    public void run() {

        try {

            while (true) {

                BufferedReader consoleReader = new BufferedReader(

                        new InputStreamReader(System.in));

                String userInput = consoleReader.readLine();

                writer.write(userInput + "/r/n");

                writer.flush(); // send the data in buffer immediately

            }

        } catch (Exception e) {

            e.printStackTrace();

            return;

        }    }}

SocketPerformer代码：

package socketChat;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

public class SocketPerformer {

    Socket socket;

    public SocketPerformer(Socket theSoc){

        socket = theSoc;

    }

    public void execut() throws Exception{

        BufferedReader socketReader = new BufferedReader(new InputStreamReader(

                socket.getInputStream()));

        PrintWriter socketWriter = new PrintWriter(socket.getOutputStream());

        System.out.println("connection built !"); 

     

        Receiver rec = new Receiver(socketReader);

        rec.start();

       

        Sender sender = new Sender(socketWriter);

        sender.start();

    }}

Server代码：

package socketChat;

 

import java.net.ServerSocket;

import java.net.Socket;

public class Server {

    public static void main(String[] args) throws Exception {      

        ServerSocket server = new ServerSocket(30000, 5);

        Socket socket = null;

        System.out.println("waiting incoming connection...");

        socket = server.accept();

        System.out.println("a connection built!");

        System.out.println("the peer ip is: " + socket.getInetAddress().getHostAddress());

        new SocketPerformer(socket).execut();

        server.close();

    }}

Client端代码如下：

package socketChat;

import java.net.Socket;

public class Client {

 

    public static void main(String[] args) throws Exception {

        String ip = "127.0.0.1";                  

        int port = 30000;

        System.out.println("connecting to server: " + ip

                + " at port: " + port + " ...");       

 

        Socket soc = new Socket(ip, port);

        new SocketPerformer(soc).execut();

    }}

2. 其它

（1） 常量定义以final做修饰符，如final int I = 3；final还可以用在class及method上，如果用在class上，那么该class不能被继承，如果用在method上，那么该method不能被重载

（2） 类变量定义：static int sum

（3） 判断对象类型：objName instanceof className，如"helloWorld" instanceof String，判断的结果是true

（4） 提取对象的类名：objName.getClass().getName()

（5） java.lang：Java最基本的包，包含java语言最基本的定义

（6） java.util：包含如Date，及基本的集合类，如Vector、Hashtable等

（7） java.io：包含输入输出的定义

（8） java.net：包含如Socket等

（9） java.awt：用于Window界面开发

（10） java.applet：用于applet开发

（11） null关键字引用null对象，注意大小写

（12） 每个基本的数据类型如int，都有相应的类与之对应中Int

（13） 构造函数名与类名相同，并且不需要返回类型，即在构造函数前不需要加类型修饰符

（14） 调用自身的构造函数：this(参数列表);

（15） 调用父类的构造函数：super(参数列表);

（16） 调用父类已被重载的函数：super.方法名(参数列表);

（17） 在同一文件中可以有多个类的定义，但只能有一个类是public并且类名与文件一样，该文件编译成功后会生成多个.class文件，与类的定义一一对应；

（18） 接口比抽象类功能强有：抽象类属于特定的类结构树中，它不能被其它树中的类共享；

（19） 接口的定义与类的定义类似，只需将class改成interface即可，但接口定义必须是public或者缺省的（package）；

（20） 在接口中可以定义方法和变量，接口中的定义的方法应是public并且是abstract的（缺省）；变量的定义必须是public static final（缺省）；

（21） String.copyValueOf(buffer, 0, offset)：用于从字符数组中取出字符，并形成字符串；

（22） new String(buf, 0, count)

（23） System.in(标准输入)是一个InputStream；

（24） System.err是一个PrintStream；

（25） System.out是一个PrintStream；