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；

Java入門筆記9_Socket

Java入門筆記2_Applet

Java入門筆記5_異常

Java入門筆記9_Socket

Java入門筆記4_訪問控制和包

S1240(74版)話單說明

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結