黑马程序员---java基础之网络编程

java之网络编程

------- android培训、java培训、期待与您交流！ ---------

 

 

网络模型
OSI参考模型
TCP/IP参考模型
图形解析：

网络通讯要素：

IP地址:网络中设备的标识，不易记忆，可用主机名;本地回环地址：127.0.0.1，主机名：localhost

端口号:用于标识进程的逻辑地址，不同进程的标识;有效端口：0-65535，其中0-1024被系统使用或是保留端口。

传输协议：即通讯的规则，常见协议有：TCP UDP

TCP和UDP的区别：

UDP（聊天软件，视频会议，桌面共享等常用，如QQ）

1.将数据及源和目的封装成数据包，不需要建立连接

2.每个数据包的大小限制在64k内

3.因无连接，是不可靠协议

4.不需要建立连接，速度快

TCP(下载软件常用，如迅雷)

1.建立连接，形成传输数据的通道

2.在连接中可以进行大数据量传输

3.通过三次握手完成连接，是可靠协议

4.必须建立连接，效率会稍低

UDP传输

Socket

1.Socket就是为网络服务提供的一种机制。

2.通信的两端都有Socket

3.网络通信其实就是Socket间的通信

4.数据在两个Socket间通过IO传输

使用UDP传输数据

1.使用到DatagramSocket与DatagramPacket

DatagramSocket：用于建立发送端，接收端。
DatagramPacket：用于封装数据包。

代码实现过程：

1. /* 
2.  * 建立发送端 
3.  * 思路 
4.  * 1，建立udpsocket服务 
5.  * 2，提供数据，并将数据封装到数据包中 
6.  * 3，secket服务的发送功能，将数据包发送出去 
7.  * 4，关闭资源 
8.  */  
9. public class UdpSend {  
10.     public static void main(String[] args) throws IOException {  
11.         // 1，创建upd服务。通过DatagramSocket对象   
12.         DatagramSocket ds = new DatagramSocket(/* 6886 */);// 可以指定一个端口，也可不写则由系统随机分配  
13.         // 2,确定数据，并封装成数据包   
14.         byte[] buf = "Hi，你好".getBytes();  
15.         DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress  
16.                 .getByName("127.0.0.1"), 10000);// 构造数据报包，用来将长度为 length  
17.                                                 // 的包发送到指定主机上的指定端口号。  
18.         // 3，通过Socket服务，将已有的数据包发送出去。通过send方法。   
19.         ds.send(dp);  
20.         // 4,关闭资源   
21.         ds.close();  
22.     }  
23. }  
24. /* 
25.  * 定义udp的接收端 
26.  * 思路： 
27.  * 1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识 
28.  * 方便于明确那些数据过来，应用程序可以处理 
29.  * 2，定义一个数据包，因为要存储收到的字节数据。 
30.  * 因为数据包对象中有更多功能可能可以提取字节数据中的不同数据信息 
31.  * 3，通过Socket服务的receive方法将收到的数据存入一定义好的数据包中。 
32.  * 4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。 
33.  * 5，关闭资源。 
34.  */  
35. class UdpRece {  
36.     public static void main(String[] args) throws IOException {  
37.         // 1，创建udp Socket ，建立端点   
38.         DatagramSocket ds = new DatagramSocket(10000);  
39.         // 2，定义数据包，用于存储数据   
40.         byte[] buf = new byte[1024 * 64];  
41.         DatagramPacket dp = new DatagramPacket(buf, buf.length);  
42.         // 3，通过服务的receive方法将收到数据存入数据包中。   
43.         ds.receive(dp);  
44.         // 4,通过数据包的方法获取其中的数据。   
45.         String ip = dp.getAddress().getHostAddress();  
46.         String data = new String(dp.getData(), 0, dp.getLength());  
47.         int port = dp.getPort();// 返回发送端主机的端口号  
48.         System.out.println(ip + "::" + data + "::" + port);  
49.         // 5,关闭资源   
50.         ds.close();  
51.     }  
52. }  

/*
 * 建立发送端
 * 思路
 * 1，建立udpsocket服务
 * 2，提供数据，并将数据封装到数据包中
 * 3，secket服务的发送功能，将数据包发送出去
 * 4，关闭资源
 */
public class UdpSend {
public static void main(String[] args) throws IOException {
// 1，创建upd服务。通过DatagramSocket对象
DatagramSocket ds = new DatagramSocket(/* 6886 */);// 可以指定一个端口，也可不写则由系统随机分配
// 2,确定数据，并封装成数据包
byte[] buf = "Hi，你好".getBytes();
DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress
.getByName("127.0.0.1"), 10000);// 构造数据报包，用来将长度为 length
// 的包发送到指定主机上的指定端口号。
// 3，通过Socket服务，将已有的数据包发送出去。通过send方法。
ds.send(dp);
// 4,关闭资源
ds.close();
}
}
/*
 * 定义udp的接收端
 * 思路：
 * 1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识
 * 方便于明确那些数据过来，应用程序可以处理
 * 2，定义一个数据包，因为要存储收到的字节数据。
 * 因为数据包对象中有更多功能可能可以提取字节数据中的不同数据信息
 * 3，通过Socket服务的receive方法将收到的数据存入一定义好的数据包中。
 * 4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
 * 5，关闭资源。
 */
class UdpRece {
public static void main(String[] args) throws IOException {
// 1，创建udp Socket ，建立端点
DatagramSocket ds = new DatagramSocket(10000);
// 2，定义数据包，用于存储数据
byte[] buf = new byte[1024 * 64];
DatagramPacket dp = new DatagramPacket(buf, buf.length);
// 3，通过服务的receive方法将收到数据存入数据包中。
ds.receive(dp);
// 4,通过数据包的方法获取其中的数据。
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(), 0, dp.getLength());
int port = dp.getPort();// 返回发送端主机的端口号
System.out.println(ip + "::" + data + "::" + port);
// 5,关闭资源
ds.close();
}
}

测试的时候，先运行接收端UdpRece，再运行UdpSend。反过来的话就会导致发送端发送的数据丢失。


2.聊天程序的实现过程

需求：编写一个聊天程序，有收数据的部分和发数据的部分，这两部分需要同时执行，那就需要用到多线程技术，一个线程控制接收，

           一个线程控制发送。

分析：

因为接收和发送动作是不一致的，所以要定义两个run方法，

而且这两个方法要封装到不同的类中。

示例代码：

1. import java.io.*;  
2.   
3. import java.net.*;  
4.   
5. class Send implements Runnable  
6.   
7. {  
8.   
9.          privateDatagramSocket ds ;  
10.   
11.          publicSend(DatagramSocket ds)  
12.   
13.          {  
14.   
15.                    this.ds= ds;  
16.   
17.          }  
18.   
19.          publicvoid run()  
20.   
21.          {  
22.   
23.                    try  
24.   
25.                    {  
26.   
27.                             BufferedReaderbufr =   
28.   
29.                                      newBufferedReader(new InputStreamReader(System.in));  
30.   
31.                             Stringline = null;  
32.   
33.                             while((line =bufr.readLine())!= null)  
34.   
35.                             {  
36.   
37.                                      if("886".equals(line))  
38.   
39.                                                break;  
40.   
41.                                      byte[]buf = line.getBytes();  
42.   
43.                                      DatagramPacketdp=newDatagramPacket(buf,buf.length,InetAddress.getByName("localhost"),10003);  
44.   
45.                                      ds.send(dp);  
46.   
47.                             }  
48.   
49.                    }  
50.   
51.                    catch(Exception e)  
52.   
53.                    {  
54.   
55.                             thrownew RuntimeException("发送端失败");  
56.   
57.                    }  
58.   
59.          }  
60.   
61. }  
62.   
63. class Rece implements Runnable  
64.   
65. {  
66.   
67.          privateDatagramSocket ds ;  
68.   
69.          publicRece(DatagramSocket ds)  
70.   
71.          {  
72.   
73.                    this.ds= ds;  
74.   
75.          }  
76.   
77.          publicvoid run()  
78.   
79.          {  
80.   
81.                    try  
82.   
83.                    {  
84.   
85.                             while(true)  
86.   
87.                             {  
88.   
89.                                      byte[]buf = new byte[1024*64];  
90.   
91.                                      DatagramPacketdp = new DatagramPacket(buf,buf.length);  
92.   
93.                                      ds.receive(dp);  
94.   
95.                                      Stringip = dp.getAddress().getHostAddress();  
96.   
97.                                      Stringdata = new String(dp.getData(),0,dp.getLength());  
98.   
99.                                      System.out.println(ip+":"+data);  
100.   
101.                             }  
102.   
103.                    }  
104.   
105.                    catch(Exception e)  
106.   
107.                    {  
108.   
109.                             thrownew RuntimeException("接收端失败");  
110.   
111.                    }          
112.   
113.          }          
114.   
115. }  
116.   
117. class ChatDemo   
118.   
119. {  
120.   
121.          publicstatic void main(String[] args) throws Exception  
122.   
123.          {  
124.   
125.                    DatagramSocketsendSocket = new DatagramSocket();  
126.   
127.                    DatagramSocketreceSocket = new DatagramSocket(10003);  
128.   
129.                    newThread(new Send(sendSocket)).start();  
130.   
131.                    newThread(new Rece(receSocket)).start();  
132.   
133.          }  
134.   
135. }  

TCP传输
使用到Socket（客户端）和ServerSocket（服务器端）
客户端：
客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。
连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream(),getOutputStream()获取即可。
与服务端通讯结束后，关闭Socket。
服务端：
服务端需要明确它要处理的数据是从哪个端口进入的。
当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。
当该客户端访问结束，关闭该客户端。

需求：定义TCP服务端，接收数据并打印在控制台上。

示例代码：

[java] view plaincopyprint?

1. import java.io.*;  
2.   
3. import java.net.*;  
4.   
5. class TcpServer  
6.   
7. {  
8.   
9.          publicstatic void main(String[] args)throws Exception  
10.   
11.          {  
12.   
13.                    //建立服务端Socket服务，并监听一个端口  
14.   
15.                    ServerSocketss = new ServerSocket(10004);  
16.   
17.                    //通过accept方法获取连接过来的客户端对象。  
18.   
19.                    Sockets = ss.accept();//accept是一个阻塞式方法  
20.   
21.                    //获取客户端的IP地址  
22.   
23.                    Stringip = s.getInetAddress().getHostAddress();  
24.   
25.                    System.out.println(ip+".....connected");  
26.   
27.                    //获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。  
28.   
29.                    InputStreamis = s.getInputStream();  
30.   
31.                    byte[]buf = new byte[1024];  
32.   
33.                    intlen = is.read(buf);  
34.   
35.                    Stringdata = new String(buf,0,len);  
36.   
37.                    System.out.println(data);  
38.   
39.                    s.close();//关闭客户端  
40.   
41.                    ss.close();//关闭服务端，这是一个可选操作。  
42.   
43.          }  
44.   
45. }  

需求：上传图片

示例代码：

[java] view plaincopyprint?

1. //客户端   
2.   
3. import java.io.*;  
4.   
5. import java.net.*;  
6.   
7. class UploadPicClient  
8.   
9. {  
10.   
11.          publicstatic void main(String[] args) throws IOException  
12.   
13.          {  
14.   
15.                    //1.创建Socket服务端点  
16.   
17.                    Sockets = new Socket("localhost",50005);  
18.   
19.                    //2.读取客户端已有的图片数据  
20.   
21.                    FileInputStreamin = new FileInputStream("c:\\1.png");  
22.   
23.                    //3.通过socket输出流将数据发给服务端  
24.   
25.                    OutputStreamout = s.getOutputStream();  
26.   
27.                    byte[]buf = new byte[1024];  
28.   
29.                    intlen = 0 ;  
30.   
31.                    while((len= in.read(buf))!=-1)  
32.   
33.                    {  
34.   
35.                             out.write(buf,0,len);  
36.   
37.                    }  
38.   
39.                    //告诉服务器数据写完了。  
40.   
41.                    s.shutdownOutput();  
42.   
43.                    //4.通过Socket输入流读取服务端反馈的信息  
44.   
45.                    InputStreamis = s.getInputStream();  
46.   
47.                    byte[]bufIn = new byte[1024];  
48.   
49.                    intnum = is.read(bufIn);  
50.   
51.                    System.out.println(newString(bufIn,0,num));  
52.   
53.                    //5.关闭Socket服务  
54.   
55.                    s.close();  
56.   
57.                    in.close();  
58.   
59.          }  
60.   
61. }  
62.   
63. //服务端   
64.   
65. class UploadPicServer  
66.   
67. {  
68.   
69.          publicstatic void main(String[] args) throws IOException  
70.   
71.          {  
72.   
73.                    //1.创建Socket服务，并监听50005端口  
74.   
75.                    ServerSocketss = new ServerSocket(50005);  
76.   
77.                    //2.通过accept方法获取连接进来的客户端对象  
78.   
79.                    Sockets = ss.accept();  
80.   
81.                    Stringip = s.getInetAddress().getHostAddress();  
82.   
83.                    System.out.println(ip+".....connected");  
84.   
85.                    //获取客户端发送过来的数据，使用客户端对象的读取流来读取数据。  
86.   
87.                    InputStreamin = s.getInputStream();  
88.   
89.                    //创建一个文件输出流对象，并指定数据存放目的地  
90.   
91.                    FileOutputStreamout = new FileOutputStream("d:\\sever.png");  
92.   
93.                    byte[]buf = new byte[1024];  
94.   
95.                    intlen = 0 ;  
96.   
97.                    while((len= in.read(buf))!=-1)  
98.   
99.                    {  
100.   
101.                             out.write(buf,0,len);  
102.   
103.                    }  
104.   
105.                    //通过客户端输出流反馈作息给客户端  
106.   
107.                    OutputStreamos = s.getOutputStream();  
108.   
109.                    os.write("上传图片成功！！".getBytes());  
110.   
111.                    //关闭服务  
112.   
113.                    out.close();  
114.   
115.                    s.close();  
116.   
117.                    ss.close();  
118.   
119.          }  
120.   
121. }  

需求：自定义一个服务器

示例代码：

[java] view plaincopyprint?

1. import java.io.*;  
2.   
3. import java.net.*;  
4.   
5. class ServerDemo  
6.   
7. {  
8.   
9.          publicstatic void main(String[] args) throws Exception  
10.   
11.          {  
12.   
13.                    ServerSocketss = new ServerSocket(14000);  
14.   
15.                    while(true)  
16.   
17.                    {  
18.   
19.                             Sockets = ss.accept();  
20.   
21.                             newThread(new ServerThread(s)).start();  
22.   
23.                    }  
24.   
25.          }  
26.   
27. }  
28.   
29. class ServerThread implements Runnable  
30.   
31. {  
32.   
33.          privateSocket s ;  
34.   
35.          ServerThread(Sockets)  
36.   
37.          {  
38.   
39.                    this.s= s;  
40.   
41.          }  
42.   
43.          publicvoid run()  
44.   
45.          {  
46.   
47.                    System.out.println(s.getInetAddress().getHostAddress());  
48.   
49.                    try  
50.   
51.                    {  
52.   
53.                             InputStreamin = s.getInputStream();  
54.   
55.                             byte[]buf = new byte[1024];  
56.   
57.                             intlen = 0;  
58.   
59.                             while((len= in.read(buf))!=-1)  
60.   
61.                             {  
62.   
63.                                      System.out.println(newString(buf,0,len));  
64.   
65.                             }  
66.   
67.                             PrintWriterout = new PrintWriter(s.getOutputStream(),true);  
68.   
69.                             out.println("<b>客户端你好");  
70.   
71.                             s.close();  
72.   
73.                    }  
74.   
75.                    catch(Exception e)  
76.   
77.                    {  
78.   
79.                             thrownew RuntimeException("failed");  
80.   
81.                    }  
82.   
83.          }  
84.   
85. }  

URL

类URL代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。

常用方法：

Object	getContent()             获取此 URL 的内容。
Object	getContent(Class[] classes)             获取此 URL 的内容。
int	getDefaultPort()             获取与此 URL 关联协议的默认端口号。
String	getFile()             获取此 URL 的文件名。
String	getHost()             获取此 URL 的主机名（如果适用）。
String	getPath()             获取此 URL 的路径部分。
int	getPort()             获取此 URL 的端口号。
String	getProtocol()             获取此 URL 的协议名称。
String	getQuery()             获取此 URL 的查询部分。

 

 

URLCollection

它代表应用程序和 URL 之间的通信链接。此类的实例可用于读取和写入此 URL 引用的资源。通常，创建一个到 URL 的连接需要几个步骤：

openConnection()	connect()
对影响到远程资源连接的参数进行操作。	与资源交互；查询头字段和内容。

---------------------------->
时间

1. 通过在 URL 上调用     openConnection 方法创建连接对象。
2. 处理设置参数和一般请求属性。
3. 使用 connect 方法建立到远程对象的实际连接。
4. 远程对象变为可用。远程对象的头字段和内容变为可访问。

使用以下方法修改设置参数：

• setAllowUserInteraction
• setDoInput
• setDoOutput
• setIfModifiedSince
• setUseCaches

使用以下方法修改一般请求属性：

• setRequestProperty

在建立到远程对象的连接后，以下方法用于访问头字段和内容：

• getContent
• getHeaderField
• getInputStream
• getOutputStream

某些头字段需要经常访问。以下方法：

• getContentEncoding
• getContentLength
• getContentType
• getDate
• getExpiration
• getLastModifed 

------- android培训、java培训、期待与您交流！ ---------