網絡編程

時間 2019-11-19

標籤網絡編程欄目系統網絡简体版

原文原文鏈接

~~Edit~~html

網絡編程

網絡編程

一.網絡編程基礎

網絡編程的目的：直接或間接地經過網絡協議與其餘計算機進行通信。java

網絡編程中有兩個主要的問題：
1.如何準確地定位網絡上一臺或多臺主機。
2.找到主機後如何可靠高效地進行數據傳輸。web

1.IP地址

IP地址：爲實現網絡中不一樣的計算機之間的通訊，在網絡中的每臺機器都必須有一個不同凡響事標識，這就是IP地址（IP Address）。數據庫

格式：數字型、32位、由4段8位的二進制數組成。通常表示爲十進制形式（4個0~255的十進制整數），中間用圓點隔開。如：166.111.78.98編程

域名地址：也是分段表示的，便於記憶的、字符串形式。數組

2.端口

端口：一個16位的整數，用於表示數據交給哪一個通訊程序處理。所以，端口就是應用程序與外界交流的出入口，它是一種抽象的軟件結構，包括一些數據結構和I/O（基本輸入/輸出）緩衝區。瀏覽器

端口用一個整數型標識符來表示，即端口號。
端口號跟協議相關，TCP/IP傳輸層的兩個協議TCP和UDP是徹底獨立的兩個軟件模塊，所以各自的端口號也相互獨立，端口一般稱爲協議端口（protocol port），簡稱端口服務器

不一樣的應用程序處理不一樣端口上的數據，同一臺機器上不能有兩個程序使用同一個端口，端口號能夠從0到65535，一般將它分爲三類：網絡

公認端口（Well Known Ports）：從0到1023，它們緊密綁定（Binding）一些服務。數據結構
註冊端口（Registered Ports）：從1024到49151。它們鬆散地綁定一些服務。
動態和/或私有端口（Dynamic and/or Private Ports）：從49152到65535，這些端口是應用程序使用的動態端口，應用程序通常不會主動使用這些端口。

3.網絡體系參考模型

OSI(Open System Interconnection)參考模型將網絡的不一樣功能劃分爲7層：

應用層：處理網絡應用

表示層：數據表示

會話層：主機間通訊

傳輸層：端到端的鏈接

網絡層：尋址和最短路徑

數據鏈路層：介質訪問（接入）

物理層：二進制傳輸

通訊實體的對等層之間不容許直接通訊，各層之間是嚴格的單向依賴，上層（Service user）使用下層提供的服務，下層（Service provider）向上層提供服務。

對等層通訊的實質：對等層實體之間虛擬通訊，下層向上層提供服務，實際通訊在最底層完成。

OSI各層所使用的協議：

應用層：Telnet、FTP、HTTP、DNS、SMTP、POP3

傳輸層：TCP、UDP ( 其中TCP：面向鏈接的可靠的傳輸協議。UDP：是無鏈接的，不可靠的傳輸協議。)

網絡層：IP、ICMP、IGMP

4.數據封裝

　一臺計算機要發送數據到另外一臺計算機，數據首先必須打包，打包的過程稱爲封裝。

封裝就是在數據前面加上特定的協議頭部。

OSI參考模型中，對等層協議之間的交換的信息單元稱爲協議數據單元（PDU, Protocol Data Unit）。

OSI參考模型中的每一層都要依靠下一層提供的服務。

爲了提供服務，下層把上層的PDU做爲本層的數據封裝，而後加入本層的頭部（和尾部）。頭部中含有完成數據傳輸所需的控制信息。

這樣，數據自上而下遞交的過程實際上就是不斷封裝的過程。到達目的地後自下而上遞交的過程就是不斷拆封的過程。由此可知，在物理線路上傳輸的數據，其外面實際上被包封了多層「信封」。

二.InetAddress類

InetAddress類
InetAddress類用來封裝咱們前面討論的數字式的IP地址和該地址的域名。
InetAddress類內部隱藏了地址數字。

InetAddress類中的工廠方法
InetAddress類沒有明顯的構造函數。爲生成一個InetAddress對象，必須運用一個可用的工廠方法。
工廠方法（factory method）僅是一個類中靜態方法返回一個該類實例的約定。
對於InetAddress，三個方法:getLocalHost()、getByName()以及getAllByName()能夠用來建立InetAddress的實例。
getLocalHost()僅返回象徵本地主機的InetAddress對象。

本機地址還爲localhost,127.0.0.1，這三個地址都是一回事。
getByName()方法返回一個傳給它的主機名的InetAddress。
若是這些方法不能解析主機名，它們引起一個UnknownHostException異常。
在Internet上，用一個名稱來表明多個機器是常有的事。
getAllByName()工廠方法返回表明由一個特殊名稱分解的全部地址的InetAddresses類數組。
在不能把名稱分解成至少一個地址時，它將引起一個UnknownHostException異常。

另外,在SocketAddress中的子類InetSocketAddress , 此類實現 IP 套接字地址（IP 地址 + 端口號）。

1.import java.net.*;
2.class InetAddressDemo
3.{
4.    public static void main(String[] args) throws Exception
5. {
6.        InetAddress ia = InetAddress.getLocalHost();//獲取本機IP地址
7.        System.out.println(ia.getHostAddress());//
8.        System.out.println(ia.getHostName());
9.
10.        InetAddress[] ia2 = InetAddress.getAllByName("www.baidu.com");
11.        for (int i=0;i<ia2.length ;i++ )
12.        {
13.            System.out.println(ia2[i].getHostAddress());
14.            System.out.println(ia2[i].getHostName());
15.        }
16.
17.    }
18.}
19.

三.UDP

UDP是User Datagram Protocol的簡稱，是一種無鏈接的協議，每一個數據報都是一個獨立的信息，包括完整的源地址或目的地址，它在網絡上以任何可能的路徑傳往目的地，所以可否到達目的地，到達目的地的時間以及內容的正確性都是不能被保證的。

1.特色

1，每一個數據報中都給出了完整的地址信息，所以無須要創建發送方和接收方的鏈接。

2， UDP傳輸數據時是有大小限制的，每一個被傳輸的數據報必須限定在64KB以內。

3， UDP是一個不可靠的協議，發送方所發送的數據報並不必定以相同的次序到達接收方

4, UDP不須要創建創建鏈接, 速度快

5, UDP操做簡單，並且僅須要較少的監護，所以一般用於局域網高可靠性的分散系統中client/server應用程序, 多用於視頻會議,桌面共享之類

2.Java中操做UDP

使用位於JDK中Java.net包下的DatagramSocket和DatagramPacket類，能夠很是方便地控制用戶數據報文。
DatagramSocket類：建立接收和發送UDP的Socket實例

DatagramSocket()：建立實例。一般用於客戶端編程，它並無特定監聽的端口，僅僅使用一個臨時的。

DatagramSocket(int port)：建立數據報Socket並將其綁定到本地主機上的指定端口。。

DatagramSocket(int port, InetAddress localAddr)：這是個很是有用的構建器，當一臺機器擁有多於一個IP地址的時候，由它建立的實例僅僅接收來自LocalAddr的報文。

receive(DatagramPacket d)：接收數據報文到d中。receive方法產生一個「阻塞」。

send(DatagramPacket d)：發送報文d到目的地。

setSoTimeout(int timeout)：設置超時時間，單位爲毫秒。

close()：關閉DatagramSocket。在應用程序退出的時候，一般會主動釋放資源，關閉Socket，可是因爲異常地退出可能形成資源沒法回收。因此，應該在程序完成時，主動使用此方法關閉Socket，或在捕獲到異常拋出後關閉Socket。

DatagramPacket：用於處理報文，將byte數組、目標地址、目標端口等數據包裝成報文或者將報文拆卸成byte數組。

DatagramPacket(byte[] buf, int length, InetAddress addr, int port)： 構造數據報包，用來將長度爲 length 的包發送到指定主機上的指定端口號。

DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)：從buf數組中，取出offset開始的、length長的數據建立數據包對象，目標是addr地址，port端口。

DatagramPacket(byte[] buf, int offset, int length)：構造 DatagramPacket，用來接收長度爲 length 的包，在緩衝區中指定了偏移量。

DatagramPacket(byte[] buf, int length)：構造 DatagramPacket，用來接收長度爲 length 的數據包。

getData()：它從實例中取得報文的byte數組編碼。

3.UDP實現發送和接收

1.發送端

1./*
2.需求:
3.定義發送端,經過udp傳輸方式,將鍵盤錄入的一段文字數據發送出去;
4.
5.思路:
6.1.經過DatagramSocket創建udpsocket服務;
7.2.提供數據,並經過DatagramPacket將數據封裝到數據包中;
8.3.經過上面創建的socket服務的發送功能將數據發送出去;
9.4.關閉資源;
10.*/
11.import java.net.*;
12.import java.io.*;
13.class UdpSendDemo
14.{
15.    public static void main(String[] args) throws Exception
16. {
17.        DatagramSocket ds = new DatagramSocket(10004);//將該socket綁定在該主機的10004指定端口,從這個端口發送
18.        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
19.        String line = null;
20.        while ((line=bufr.readLine()) !=null)
21.        {
22.            if (line.equals("886"))//用一個"886"的標識符來讓循環中止
23.            {
24.                break;
25.            }
26.            byte[] buf = line.getBytes();
27.            DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),10000);//從指定該主機指定端口10000發送buf字符串中一段數據
28.            ds.send(dp);//用該socket發送dp數據包
29.        }
30.        ds.close();
31.    }
32.}
33.

2.接收端

1./*
2.需求:
3.定義接收端,接收udp協議接收的數據並進行處理;
4.
5.思路:
6.1.經過DatagramSocket創建udp socket服務;
7.2.經過DatagramPacket定義數據包,用於存儲接收到的數據;
8.3.經過上面創建功能將接收到的數據存入已定義好的數據包中;
9.4.經過數據包特有的方法來操做的socket服務的接收數據;
10.5.關閉資源;
11.*/
12.import java.net.*;
13.class UdpReceDemo
14.{
15.    public static void main(String[] args) throws Exception
16. {
17.        DatagramSocket ds = new DatagramSocket(10000);//將該socket綁定在該主機的10000指定端口,用於監聽該端口的數據
18.        while (true)
19.        {
20.            byte[] buf = new byte[1024];
21.            DatagramPacket dp = new DatagramPacket(buf,buf.length);//構造 DatagramPacket，用來接收長度爲 length 的數據包。
22.            ds.receive(dp);     
23.            String address = dp.getAddress().getHostAddress();//由於getAddress()返回的是InetAddress類
24.            String data = new String(dp.getData(),0,dp.getLength());
25.            int port = dp.getPort();
26.            System.out.println(address+"::"+data+"::"+port);
27.            //ds.close();由於通常接收端會一直開等待接收數據
28.        }
29.
30.    }
31.}

4.利用多線程在一個程序裏面實現發送接收

1./*
2.利用多線程,將發送端和接收端放在一個程序下運行,相似QQ
3.*/
4.import java.io.*;
5.import java.net.*;
6.class ChatDemo
7.{
8.    public static void main(String[] args) throws Exception
9. {
10.        DatagramSocket sendsocket = new DatagramSocket();
11.        DatagramSocket recesocket = new DatagramSocket(10003);
12.        new Thread(new Send(sendsocket)).start();
13.        new Thread(new Rece(recesocket)).start();
14.    }
15.}
16.class Send implements Runnable
17.{
18.    private DatagramSocket ds;
19.    Send(DatagramSocket ds)
20.    {
21.        this.ds = ds;
22.    }
23.    public void run()
24. {
25.        try
26.        {
27.            BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
28.            String line = null;
29.            while ((line=bufr.readLine())!=null)
30.            {
31.                if (line.equals("886"))
32.                {
33.                    break;
34.                }
35.                byte[] buf = line.getBytes();
36.                DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),10003);
37.                ds.send(dp);
38.            }
39.            ds.close();         
40.        }
41.        catch (Exception e)
42.        {
43.            throw new RuntimeException("發送端出錯");
44.        }
45.    }
46.}
47.class Rece implements Runnable
48.{
49.    private DatagramSocket ds;
50.    Rece(DatagramSocket ds)
51.    {
52.        this.ds = ds;
53.    }
54.    public void run()
55. {
56.        try
57.        {
58.            while (true)
59.            {
60.                byte[] buf = new byte[1024];
61.                DatagramPacket dp = new DatagramPacket(buf,buf.length);
62.                ds.receive(dp);
63.                String address = dp.getAddress().getHostAddress();
64.                String data = new String(dp.getData(),0,dp.getLength());
65.                int port = dp.getPort();
66.                System.out.println(address+"::"+data+"::"+port);
67.            }           
68.        }
69.        catch (Exception e )
70.        {
71.            throw new RuntimeException("接收端出錯");
72.        }
73.
74.
75.    }
76.}

四.TCP

TCP是Tranfer Control Protocol的簡稱，是一種面向鏈接的保證可靠傳輸的協議。

經過TCP協議傳輸，獲得的是一個順序的無差錯的數據流。

發送方和接收方的成對的兩個 socket之間必須創建鏈接，以便在TCP協議的基礎上進行通訊，當一個socket（一般都是server socket）等待創建鏈接時，另外一個socket能夠要求進行鏈接，一旦這兩個socket鏈接起來，它們就能夠進行雙向數據傳輸，雙方均可以進行發送或接收操做。

1.特色

1，面向鏈接的協議，在socket之間進行數據傳輸以前必然要創建鏈接(經過三次握手創建鏈接),因此在TCP中須要鏈接時間。

2， TCP一旦鏈接創建起來，雙方的socket就能夠按統一的格式傳輸大的數據。

3， TCP是一個可靠的協議，它確保接收方徹底正確地獲取發送方所發送的所有數據。

4，由於須要創建鏈接,效率偏低。

2.TCP實現發送接收

1.客戶端

1.TCP分爲客戶端和服務端,客戶端的對象是Socket,服務端的對象是ServerSocket
2.
3.定義客戶端步驟:
4.1.建立Socket服務,並鏈接指定主機和端口;
5.
6.2.爲了發送數據,獲取Socket流中的輸出流;
7.
8.
9.*/
10.import java.io.*;
11.import java.net.*;
12.class TcpClientDemo 
13.{
14.    public static void main(String[] args) throws Exception
15. {
16.        Socket s = new Socket(InetAddress.getLocalHost(),10004);
17.        OutputStream ops = s.getOutputStream();
18.        byte[] buf = "服務端,你好".getBytes();
19.        ops.write(buf);
20.
21.        //接收服務端發送過來的數據
22.        InputStream ips = s.getInputStream();
23.        byte[] buf2 = new byte[1024];
24.        int len = ips.read(buf2);
25.        System.out.println(new String(buf2,0,len));
26.        s.close();
27.    }
28.}
29.

2.服務端

1./*
2.定義服務端步驟:
3.1.創建服務端的Socket服務,ServerSocket;
4.2.獲取鏈接過來的客戶端對象,經過ServerSocket裏的accept()方法,沒有鏈接則會等待,該方法是阻塞式方法;
5.3.經過獲取到的客戶端的Socket對象的讀取流InputStream,來接收信息;
6.4.關閉服務器;
7.
8.ServerSocket裏面有構造方法ServerSocket(int port,int backlog),其中backlog表明服務容許的最大鏈接數
9.
10.*/
11.import java.io.*;
12.import java.net.*;
13.class TcpServerDemo 
14.{
15.    public static void main(String[] args) throws Exception
16. {
17.        ServerSocket ss = new ServerSocket(10004);
18.        Socket s = ss.accept();
19.        InputStream ips = s.getInputStream();
20.        byte[] buf = new byte[1024];
21.        int num = ips.read(buf);
22.        String data = new String(buf,0,num);
23.        String ip = s.getInetAddress().getHostAddress();
24.        System.out.println(data+"::"+ip);
25.
26.        //給客戶端反饋數據
27.        OutputStream ops = s.getOutputStream();
28.        ops.write("收到消息,你也好啊".getBytes());
29.
30.        s.close();
31.        ss.close();
32.    }
33.}

3.創建一個文本轉換服務器

需求:創建一個文本轉換服務器.
客戶端給服務器發送文本,服務端將文本轉成大寫返回給客戶端, 而且客戶端能夠不斷的進行文本轉換,當客戶端輸入over時結束.

1.客戶端
客戶端:
用IO的思想來思考,
源:鍵盤錄入.
目的:網絡設備,網絡輸出流.
操做的是文本數據,能夠選擇字符流.

步驟:
1.創建服務;
2.獲取鍵盤錄入;
3.將數據發送給服務端;
4.獲取服務端返回的數據;

1./*
2.該例子容易出現的問題:服務端和客戶端莫名的都等待;
3.由於客戶端和服務端都有阻塞式方法,這些方法沒有讀到結束標記,要麼數據沒有從緩衝區刷出或者沒有讀到換行符\r\n;
4.
5.*/
6.
7.import java.io.*;
8.import java.net.*;
9.class TransClientDemo 
10.{
11.    public static void main(String[] args) throws Exception
12. {
13.        Socket s = new Socket(InetAddress.getLocalHost(),10005);
14.        //定義讀取鍵盤數據的流對象
15.        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
16.        //目的,將數據寫入到socket輸出流,發給服務端
17.        BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
18.        //這裏用用PrintWriter來代替上面的bufout:PrintWriter out = new PrintWriter(s.getOutputStream(),true)
19.        //定義一個socket讀取流,讀取服務端返回的數據
20.        BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));       
21.        String line = null;
22.        while ((line=bufr.readLine()) !=null)
23.        {
24.            if ("over".equals(line))
25.            {
26.                break;
27.            }
28.            bufout.write(line);//將數據寫入socket輸出流
29.            bufout.newLine();//由於服務端的readLine()方法以\r\n來判斷結束標記,若是沒有則會一直阻塞,因此加入換行符
30.            bufout.flush();//必須將緩衝區裏面數據刷出
31.            //若是上面用了PrintWriter的話,這裏上面三行能夠直接用out.println(line)
32.            String str = bufin.readLine();//讀取服務端返回的數據
33.            System.out.println("Server:"+str);
34.        }
35.        s.close();
36.        bufr.close();
37.    }
38.}
39.

服務端

1.import java.io.*;
2.import java.net.*;
3.class TransServerDemo 
4.{
5.    public static void main(String[] args) throws Exception
6. {
7.        ServerSocket ss = new ServerSocket(10005);
8.        Socket s = ss.accept();
9.        //讀取socket讀取流中的數據
10.        BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));
11.        //目的,socket輸出流,將大寫數據寫入socket輸出流
12.        BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
13.        //這裏用用PrintWriter來代替上面的bufout:PrintWriter out = new PrintWriter(s.getOutputStream(),true)
14.        String line = null;
15.        while ((line=bufin.readLine()) !=null)
16.        {
17.            System.out.println(line);
18.            bufout.write(line.toUpperCase());
19.            bufout.newLine();
20.            bufout.flush();
21.            //若是上面用了PrintWriter的話,這裏上面三行能夠直接用out.println(line)
22.        }
23.        s.close();
24.        ss.close();
25.    }
26.}
27.

4.客戶端向服務器發送文本文件

1.客戶端

1./*
2.將文件從客戶端上傳到服務端
3.*/
4.import java.io.*;
5.import java.net.*;
6.class UploadClientDemo
7.{
8.    public static void main(String[] args) throws Exception
9. {
10.        Socket s = new Socket(InetAddress.getLocalHost(),10005);
11.
12.        BufferedReader bufr = new BufferedReader(new FileReader("CopyDemo.java"));
13.
14.        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
15.
16.        BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
17.        String line = null;
18.        while ((line=bufr.readLine())!=null)
19.        {
20.            out.println(line);
21.        }
22.        out.println("over");//發送一個結束標記,而後服務端會一直等待
23.        //在實際開發中,直接用s.shutdownOutput(),以此來關閉發送流,同時服務端就收到一個結束標記
24.        String str = in.readLine();
25.        System.out.println(str);
26.        s.close();
27.        bufr.close();
28.    }
29.}
30.

2.服務端

1.import java.io.*;
2.import java.net.*;
3.class UploadServerDemo 
4.{
5.    public static void main(String[] args) throws Exception
6. {
7.        ServerSocket ss = new ServerSocket(10005);
8.        Socket s =  ss.accept();
9.        BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
10.        PrintWriter bufw = new PrintWriter(new FileWriter("e:\\haha.txt"),true);
11.        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
12.
13.        String line = null;
14.        while ((line=in.readLine())!=null)
15.        {
16.            if ("over".equals(line))
17.            {
18.                break;
19.            }
20.            bufw.println(line);
21.        }
22.
23.        out.println("發送成功");
24.        s.close();
25.        ss.close();
26.        bufw.close();
27.
28.    }
29.}

5.客戶端向服務器發送圖片

1.客戶端

1./*
2.客戶端向服務端上傳圖片
3.*/
4.import java.io.*;
5.import java.net.*;
6.class PicClientDemo 
7.{
8.    public static void main(String[] args) throws Exception
9. {
10.        Socket s = new Socket(InetAddress.getLocalHost(),10007);
11.        FileInputStream fis = new FileInputStream("e:\\1.jpg");
12.        OutputStream ops = s.getOutputStream();
13.        int len = 0;
14.        byte[] buf = new byte[1024];
15.        while ((len=fis.read(buf))!=-1)
16.        {
17.            ops.write(buf,0,len);
18.        }
19.        s.shutdownOutput();
20.        s.close();
21.        fis.close();
22.    }
23.
24.}

2.服務端

1.import java.io.*;
2.import java.net.*;
3.class PicServerDemo 
4.{
5.    public static void main(String[] args) throws Exception
6. {
7.        ServerSocket ss = new ServerSocket(10007);
8.        Socket s = ss.accept();
9.        InputStream ips = s.getInputStream();
10.        FileOutputStream fos = new FileOutputStream("e:\\2.jpg");
11.        byte[] buf = new byte[1024];
12.        int len = 0;
13.        while ((len=ips.read(buf))!=-1)
14.        {
15.            fos.write(buf,0,len);
16.        }
17.        fos.close();
18.        s.close();
19.        ss.close();
20.    }
21.}
22.
23.

6.使用多線程實現多個客戶端同時向服務端發送文件

1.客戶端

1./*
2.當多個客服端同時向服務端發送文件時,須要採用多線程才行
3.
4.*/
5.import java.io.*;
6.import java.net.*;
7.class UploadPicByThreadClient 
8.{
9.    public static void main(String[] args) throws Exception
10. {
11.        if (!(args.length == 1))
12.        {
13.            System.out.println("請選擇一個圖片上傳");
14.            return;
15.        }
16.        if (!(args[0].endsWith(".jpg")))
17.        {
18.            System.out.println("請選擇一個.jpg文件");
19.            return;
20.        }
21.        File file = new File(args[0]);
22.        if (!(file.exists() && file.isFile()))
23.        {
24.            System.out.println("文件不存在或者不是文件");
25.            return;
26.        }
27.
28.        Socket s = new Socket("192.168.0.114",10008);
29.        FileInputStream fis = new FileInputStream(file);
30.        OutputStream ops = s.getOutputStream();
31.        int len = 0;
32.        byte[] buf = new byte[1024];
33.        while ((len=fis.read(buf))!=-1)
34.        {
35.            ops.write(buf,0,len);
36.        }
37.        s.shutdownOutput();
38.        s.close();
39.        fis.close();
40.    }
41.}
42.

2.服務端

1.import java.io.*;
2.import java.net.*;
3.class UploadPicByThreadServer 
4.{
5.    public static void main(String[] args) throws Exception
6. {
7.        ServerSocket ss = new ServerSocket(10008);
8.        while (true)
9.        {
10.            Socket s = ss.accept();
11.            new Thread(new PicThread(s)).start();
12.        }
13.    }
14.}
15.class PicThread implements Runnable
16.{
17.    Socket s;
18.    PicThread(Socket s)
19.    {
20.        this.s = s;
21.    }
22.
23.    public void run()
24. {
25.        String ip = s.getInetAddress().getHostAddress();
26.        System.out.println(ip+":::connect");
27.        int num = 1;
28.        try
29.        {
30.            InputStream ips = s.getInputStream();
31.
32.            File file = new File("e:\\"+ip+"("+num+")"+".jpg");
33.            while (file.exists())
34.            {
35.                file = new File("e:\\"+ip+"("+(num++)+")"+".jpg");
36.            }
37.            FileOutputStream fos = new FileOutputStream(file);
38.            byte[] buf = new byte[1024];
39.            int len = 0;
40.            while ((len=ips.read(buf))!=-1)
41.            {
42.                fos.write(buf,0,len);
43.            }
44.            fos.close();
45.            s.close();
46.
47.        }
48.        catch (Exception e)
49.        {
50.            throw new RuntimeException("上傳失敗");
51.        }
52.
53.    }
54.}
55.
56.

7.客戶端併發登陸服務器

客戶端經過鍵盤錄入用戶名;
服務端對這個用戶名進行校驗;
若是該用戶存在,在服務端顯示: 「XXX,已登陸」 , 並在客戶端顯示: 「XXX,歡迎光臨」

若是該用戶不存在,在服務端顯示: 「XXX,嘗試登陸」 , 並在客戶端顯示:」XXX,該用戶不存在」
1.客戶端

1./*
2.客戶端併發登陸服務器
3.
4.客戶端經過鍵盤錄入用戶名;
5.服務端對這個用戶名進行校驗;
6.若是該用戶存在,在服務端顯示: "XXX,已登陸" , 並在客戶端顯示: "XXX,歡迎光臨"
7.
8.若是該用戶不存在,在服務端顯示: "XXX,嘗試登陸" , 並在客戶端顯示:"XXX,該用戶不存在"
9.
10.
11.*/
12.import java.io.*;
13.import java.net.*;
14.class UserLoginClient
15.{
16.    public static void main(String[] args) throws Exception
17. {
18.        Socket s = new Socket(InetAddress.getLocalHost(),10009);
19.        //定義讀取流,讀取鍵盤錄入
20.        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
21.        //socket輸出流,發送登陸的的name
22.        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
23.        //socket輸入流,接收服務端發送的信息
24.        BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));      
25.        for (int x=0;x<3;x++ )
26.        {
27.            //接收鍵盤錄入
28.            String name = bufr.readLine();
29.            if (name == null)
30.            {
31.                break;
32.            }
33.            //發送給服務端
34.            out.println(name);
35.            //接收服務端信息
36.            String info = in.readLine();
37.            System.out.println(info);
38.            if (info.equals(name+"歡迎登陸"))
39.            {
40.                break;
41.            }
42.        }
43.        s.close();
44.        bufr.close();
45.    }
46.}
47.

2.服務端

1.import java.io.*;
2.import java.net.*;
3.class UserLoginServer 
4.{
5.    public static void main(String[] args) throws Exception
6. {
7.        ServerSocket ss = new ServerSocket(10009);
8.        while (true)
9.        {
10.            Socket s = ss.accept();
11.            new Thread(new UserThread(s)).start();
12.        }
13.    }
14.}
15.class UserThread implements Runnable
16.{
17.    Socket s;
18.    UserThread(Socket s)
19.    {
20.        this.s = s;
21.    }
22.    public void run()
23. {
24.        //獲取到登陸客戶端的ip
25.        String ip = s.getInetAddress().getHostAddress();
26.        System.out.println(ip+":::connect");
27.        try
28.        {
29.            //獲取socket輸入流,讀取客服端發送過來的信息
30.            BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
31.            //定於輸出流,向客戶端發送信息
32.            PrintWriter out = new PrintWriter(s.getOutputStream(),true);
33.            //定義一個標記,來判斷客戶端發送過來的信息和數據庫中的信息是否相同 
34.            boolean flag = false;
35.            String name = null;//用來接收客戶端發送過來的用戶登陸信息
36.            for (int x =0;x<3 ;x++ )//容許用戶連續嘗試登陸三次
37.            {   
38.                //用於讀取服務器中存的用戶列表
39.                BufferedReader bufr = new BufferedReader(new FileReader("e:\\1.txt"));
40.                name = in.readLine();//讀取一次socket輸入流中的用戶信息
41.                String line = null;
42.                while ((line=bufr.readLine())!=null)
43.                {
44.                    if (name.equals(line))
45.                    {
46.                        flag = true;
47.                        break;
48.                    }
49.                }               
50.                if (flag == true)
51.                {
52.                    System.out.println(ip+"登陸成功");
53.                    out.println(name+"歡迎登陸");
54.                    bufr.close();
55.                    break;
56.                }
57.                System.out.println(ip+"嘗試登陸");
58.                out.println(name+"用戶不存在");
59.                bufr.close();               
60.            }   
61.            s.close();      
62.        }
63.        catch (Exception e)
64.        {
65.            throw new RuntimeException("上傳失敗");
66.        }       
67.    }
68.}
69.
70.

8.自定義瀏覽器功能

1./*
2.自定義瀏覽器功能
3.*/
4.import java.io.*;
5.import java.net.*;
6.class MyIE
7.{
8.    public static void main(String[] args) throws Exception
9. {
10.        Socket s = new Socket(InetAddress.getLocalHost(),8080);
11.        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
12.
13.        //模擬瀏覽器向服務器發送的請求消息頭
14.        out.println("GET /myweb/web.html HTTP/1.1");
15.        out.println("Accept: */*");
16.        out.println("Accept-Language: zh-Hans-CN,zh-Hans;q=0.5");
17.        out.println("Host: 221.237.64.248:10010");
18.        out.println("Connection: closed");
19.        out.println();
20.        out.println();
21.
22.        BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));
23.        String line = null;
24.        while ((line=bufr.readLine())!=null)
25.        {
26.            System.out.println(line);
27.        }
28.        s.close();
29.    }
30.}
31.//瀏覽器向TOMCAT服務器發送的請求消息頭
32./*
33.GET / HTTP/1.1
34.Accept: text/html, application/xhtml+xml, image/jxr
35.Accept-Language: zh-Hans-CN,zh-Hans;q=0.5
36.User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2
37.704.79 Safari/537.36 Edge/14.14393
38.Accept-Encoding: gzip, deflate
39.Host: 221.237.64.248:10010
40.Connection: Keep-Alive
41.*/
42.
43.//TOMCAT服務器向瀏覽器返回的應答消息頭
44./*
45.HTTP/1.1 200 OK
46.Server: Apache-Coyote/1.1
47.Accept-Ranges: bytes
48.ETag: W/"191-1476517035954"
49.Last-Modified: Sat, 15 Oct 2016 07:37:15 GMT
50.Content-Type: text/html
51.Content-Length: 191
52.Date: Sat, 15 Oct 2016 14:06:12 GMT
53.Connection: close
54.
55.
56.*/
57.

五.URL和URLConnection

1.應用

1./*
2.URL
3.URLConnection
4.*/
5.import java.io.*;
6.import java.net.*;
7.class URLDemo 
8.{
9.    public static void main(String[] args) throws Exception
10. {
11.        URL url = new URL("http://221.237.64.124:8080/myweb/web.html");
12.        String protocol = url.getProtocol();//獲取協議 獲得http
13.        String host = url.getHost();//獲取主機
14.        int port = url.getPort();//獲取端口
15.        String path = url.getPath();//獲取路徑
16.        String file = url.getFile();//獲取文件名
17.        String query = url.getQuery();//獲取查詢部分
18.
19.        //URLConnection將數據在應用層封裝,因此返回的數據只有網頁裏面的數據,就如瀏覽器返回的數據同樣,不會將服務器返回的應答消息頭顯示出來
20.        URLConnection conn = url.openConnection();//返回一個 URLConnection 對象，它表示到 URL 所引用的遠程對象的鏈接。
21.        System.out.println(conn);//結果爲:sun.net.www.protocol.http.HttpURLConnection:http://221.237.64.124:8080/myweb/web.html?name=zhangsan&color=red
22.        InputStream in = conn.getInputStream();//獲取URLConnection裏的讀取流
23.        byte[] buf = new byte[1024];
24.        int len = in.read(buf);
25.        System.out.println(new String(buf,0,len));
26.    }
27.}

2.域名解析

域名解析:
域名解析是把域名指向網站空間IP，讓人們經過註冊的域名能夠方便地訪問到網站的一種服務。IP地址是網絡上標識站點的數字地址，爲了方便記憶，採用域名來代替IP地址標識站點地址。域名解析就是域名到IP地址的轉換過程。域名的解析工做由DNS服務器完成

當咱們在輸入網址,系統會先訪問本地的hosts文件,位置C:WINDOWS\system32\driver\setc,而後在訪問DNS服務器
1.好比避開盜版軟件的驗證服務器,在本地的host文件將網址改成本地host,127.0.0.1,這樣就會驗證失敗
2.能夠避開一些垃圾網站,在本地host中將網址的映射改爲127.0.0.1

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。