黑马程序员 Java自学总结十六 网络编程

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------

总结内容来源于黑马毕老师的java基础教学视频

网络编程:

为了实现不同主机之间的数据传输和通信 。

网络模型：

OSI模型：从顶到底层 分别是： 应用层，表示层，会话层，传输层，网络层，数据链路层，物理层，分七层；

TCP/IP模型：它由应用层，传输层，网际层，网络接入组成；

FTP,HTTP都在应用层，TCP,UDP在传输层，IP在网际层。

网络通讯的三个要素：

1.IP地址：是主机在网络上的地址，在网上的唯一标识，127.0.0.1是本地回环地址，可测试网卡是否损坏；

2.端口号：数据要发送到对方指定的应用程序上，为了标识这些应用程序，用数字对其标识，这些数字就是端   口，或被称为逻辑端口；它并无物理实体与之对应;有效端口号从0~65535，其中0~1024是系统保留的                    端口号；

一些常见的端口：浏览器:80 ;     tomcat服务器：8080；  mysql：3306;

3.传输协议：要完成传输，还要遵守相同的通信协议，国际通用协议是 TCP/IP协议，既能用于局域网，也可用于广域网，除了TCP/IP,还有 UDP,FTP,HTTP等协议；

数据封包：数据从应用层开始，每经一层，都加入该层的标识信息，直到物理层，这个过程叫数据封包，之后           变成二进制数据从物理设备上输出；

数据拆包：去掉每层的标识信息，获取数据的过程就是拆包过程；

网络编程现阶段主要是在网际层，传输层，而javaweb开发主要是在应用层；

java中对各个层都创建了对象与之对应，以方便我们开发使用；

IP地址：是数字，由四段组成，如192.168.1.1，使用时不便于记忆，所以有与之对应的主机名，主机名与IP地址相对应；IP常用的方法如下：都在java。net包中；

InetAddress: getLocalHost();可获取主机名和本地地址；

getHostAddress():主机地址的字符串表现形式；

getHostName():获取主机名称；

如果网络获取主机名称，可能出现解析不成功的情况，那么IP地址就是主机名，getByName("")可通过给定主机名，获取主机的IP地址；

代码:

[java]  view plain copy

1. //IP协议类InetAddress  
2. import java.net.*;  
3. import java.util.*;  
4. class InetAddressDemo  
5. {  
6.      public static void main(String[] args) throws Exception  
7.      {  
8.           InetAddress i = InetAddress.getLocalHost();  
9.           System.out.println(i.toString());  
10.   
11.           InetAddress[] ia = InetAddress.getAllByName("www.baidu.com");  
12.           System.out.println(Arrays.asList(ia));  
13.      }  
14. }  

TCP和UDP协议:两者都在传输层；

两者的区别：

1.UDP:(User Datagram Protocol),用户数据报协议，是一种面向无连接的不可靠协议，它将数据源和目的封装成数据报包，在不需要建立连接的情况下就可实现传输，每个数据报包大小限制在64K内，特点是传输速度快；存在数据丢失的可能，主要应用于即时数据的传输，如QQ聊天程序，对话机，网络视频会议等；

2.TCP:(Transmission Control Protocol)，传输控制协议,它是面向连接的可靠的传输协议，通过三次握手的形式完成数据传输通道的连接，传输大量的数据，特点是速度相对较慢，适合对数据完整性要求高的程序，如下载应用程序；

Socket：（插座，套接字）：

网络编程其实就是socket编程，它是为网络服务的一种机制，每个应用程序都有一个socket通信端点，可以把socket想象为每个应用程序的插座，通信的两端都有socket，数据在两个socket之间通过IO传输；

UDP传输：UDP两端是发送端和接受端；

DatagramSocekt:UDP传输专用的程序通信断电，既能发送也能接受；

DatagramPacket: 数据报包，封装了UDP传输的数据报包，里面可以设置发送目的地的IP地址，端口和内容；

广播地址：每个网段尾数为255的IP 地址，如192.168.1.255就是一个广播地址；

UDP协议类及其使用

[java]  view plain copy

1. import java.net.*;  
2. import java.io.*;  
3. /* 
4. 需求:通过udp传输方式,将一段文字数据发送出去 
5. 思路: 
6. 1.建立udpsochet服务. 
7. 2.提供数据,并将数据封装到数据包中. 
8. 3.通过soket服务发送功能,将数据发出去. 
9. */  
10. class UdpSend  
11.   
12. {  
13.      public static void main(String[] args) throws Exception  
14.      {  
15.           //1.创建udp服务,通过DatagramSocket对象.  
16.           DatagramSocket ds = new DatagramSocket(8888);  
17.   
18.           //2.确定数据,并封装成数据包.  
19.           BufferedReader br =  
20.                new BufferedReader(new InputStreamReader(System.in));  
21.           String line = null;  
22.         while ((line=br.readLine())!=null)  
23.         {    
24.               byte[] buf = line.getBytes();  
25.                DatagramPacket dp =  
26.                     new DatagramPacket(buf,buf.length,InetAddress.getByName(""),10000);  
27.   
28.                //3通过soket服务,将已有的数据包发送出去.通过send方法.  
29.                ds.send(dp);  
30.                if ("over".equals(line))  
31.                     break;  
32.         }  
33.           //4.关闭资源  
34.           ds.close();  
35.      }  
36. }  
37.   
38. /* 
39. 需求: 
40. 定义一个应用程序,用于接收udp协议传输并处理. 
41.  
42. 思路: 
43. 1.定义udpsocket服务.通常会监听一个端口,其实就是给这个接收端定义数字标识 
44.      方便于明确哪些数据过来该应用程序可以处理. 
45. 2.定义一个数据包,因为要存储接收到的字节数据, 
46.      数据包对象中有更多功能可以提取字节数据中不同数据信息. 
47. 3.通过socket服务的receive方法将收到数据存入已定义好的数据包中. 
48. 4.通过数据包对象的特有功能,将这些不同数据取出.打印在控制台上. 
49. 5.关闭资源 
50. */  
51. class UdpReceive  
52. {  
53.      public static void main(String[] args) throws Exception  
54.      {  
55.           //1.创建udpsocket,建立端点  
56.           DatagramSocket ds = new DatagramSocket(10000);  
57.   
58.           //可以达到重复接收数据的目的  
59.           while(true)  
60.           {  
61.                //2.定义数据包,用于存储数据.  
62.                byte[] buf = new byte[1024];  
63.                DatagramPacket dp = new DatagramPacket(buf,1024);  
64.   
65.                //3.通过服务的receive方法将收到的数据存入到数据包中.  
66.                ds.receive(dp);  
67.   
68.                //4.通过数据包的方法获取其中的数据.  
69.                String ip = dp.getAddress().getHostAddress();  
70.                String data = new String(dp.getData(),0,dp.getLength());  
71.                int port = dp.getPort();  
72.                System.out.println(ip+"::"+data+"::"+port);  
73.   
74.                //5.关闭资源  
75.                //ds.close();  
76.           }  
77.      }  
78. }  

UDP协议编写聊天程序

[java]  view plain copy

1. /* 
2. 知识点: 
3. UDP协议, 线程, IO 
4.  
5. 编写一个聊天程序 
6. 收数据和发数据需要同时执行,那就需要用到多线程技术. 
7.                          一个线程控制收,一个线程控制发. 
8.  
9. 因为收和发动作是不一致的,所以要定义两个run方法, 
10.                     而且这两个方法要封装到不同类中. 
11. */  
12. import java.net.*;  
13. import java.io.*;  
14.   
15. class Send implements Runnable   
16. {  
17.      private DatagramSocket ds;  
18.      Send(DatagramSocket ds)  
19.      {  
20.           this.ds = ds;  
21.      }  
22.      public void run()  
23.      {  
24.           try  
25.           {  
26.                BufferedReader br =  
27.                     new BufferedReader(new InputStreamReader(System.in));  
28.                String line = null;  
29.                while ((line=br.readLine())!=null)  
30.                {  
31.                     if("over".equals(line))  
32.                          System.exit(0);  
33.                     byte[] buf = line.getBytes();  
34.                     DatagramPacket dp =  
35.                          new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10005);  
36.                     //将定义好的数据包发送到指定主机的指定端口  
37.                     ds.send(dp);  
38.                }                
39.           }  
40.           catch (Exception e)  
41.           {  
42.                throw new RuntimeException("发送端失败");  
43.           }  
44.      }  
45. }  
46. class Rece implements Runnable   
47. {  
48.      private DatagramSocket ds;  
49.      Rece(DatagramSocket ds)  
50.      {  
51.           this.ds = ds;  
52.      }  
53.      public void run()  
54.      {  
55.           try  
56.           {  
57.                while (true)  
58.                {  
59.                     byte[] buf = new byte[1024];  
60.                     DatagramPacket dp = new DatagramPacket(buf,buf.length);  
61.                     //将获取到的数据存储到定义好的数据包当中  
62.                     ds.receive(dp);  
63.   
64.                     String ip = dp.getAddress().getHostAddress();  
65.   
66.                     String data = new String(dp.getData(),0,dp.getLength());  
67.   
68.                     System.out.println(ip+".."+data);  
69.                }  
70.           }  
71.           catch (Exception e)  
72.           {  
73.                throw new RuntimeException("发送端失败");  
74.           }  
75.      }  
76. }  
77.   
78.   
79.   
80. class CharTest  
81. {  
82.      public static void main(String[] args) throws Exception  
83.      {  
84.           DatagramSocket sendSocket = new DatagramSocket();  
85.           DatagramSocket receSocket = new DatagramSocket(10005);  
86.   
87.           new Thread(new Send(sendSocket)).start();  
88.           new Thread(new Rece(receSocket)).start();  
89.   
90.      }  
91. }  

TCP传输：对应的是客户端和服务端

Socket：TCP传输客户端通信端点；

ServerSocket: TCP传输服务端端点；serversocket（port，backlog）这个构造函数中的backlog用于指定客户端的最大连接数；

因为TCP需要建立连接，所以socket客户端一建立就要指定服务端的IP和端口，而在服务端建立时，要设置监听的端口，TCP连接成功后，在客户端和服务端就会产生网络流，客户端提供对网络流进行读写的输入流和输出流对象，服务端操作网络流时，先获取客户端的socket对象，然后利用该socket的字节输入输出流进行读写操作，客户端和服务端进行多次交互时，注意阻塞式方法对程序的影响；
TCP代码演示一：

演示TCP传输。  
1.tcp分客户端和服务端。  
2.客户端对应的对象是Socket。  
    服务端对应的对象是SeverSocket 

TCP协议及其使用

[java]  view plain copy

1. /* 
2. 演示tcp传输. 
3.  
4. 1.tcp分客户端和服务端. 
5. 2.客户端对应的对象是Socket. 
6.      服务端对应的对象是ServerSocket. 
7.  
8. 客户端: 
9. 通过查阅socket对象,发现该对象建立时,就可以去连接主机. 
10. 因为tcp是面向连接的.所以在建立socket服务时, 
11. 就要有服务端存在.并连接成功.形成通路后,在该通道进行数据传输. 
12.  
13. 需求:给服务端发送一个文本数据. 
14.  
15. 步骤: 
16. 1.创建socket服务.并指定要连接的主机和端口. 
17. 2.获取socket中的输出流,在流中写入数据. 
18. */  
19. import java.net.*;  
20. import java.io.*;  
21. class  TcpClient  
22. {  
23.      public static void main(String[] args) throws Exception  
24.      {  
25.           //创建客户端socket服务.指定目的主机和端口  
26.           Socket s = new Socket("LocalHost",10001);  
27.   
28.           //为了发送数据,应该获取socket中的输出流.  
29.           OutputStream out = s.getOutputStream();  
30.   
31.           out.write("tcp is coming".getBytes());  
32.   
33.           s.close();  
34.      }  
35. }  
36. /* 
37. 需求:定义端点接收数据并打印在控制台上. 
38.  
39. 服务端: 
40. 1.建立服务端的socket服务.ServerSocket();并监听一个端口 
41. 2.获取连接过来的客户端对象.通过 ServerSocket的accept方法,这个方法是阻塞的. 
42. 3.客户端如果发过来数据,那么服务端要使用对应的客户端对象, 
43.      并获取到该客户端对象的读取流来读取发过来的数据. 
44. 4.关闭服务端.(可选) 
45. */  
46. class  TcpServer  
47. {  
48.      public static void main(String[] args) throws Exception  
49.      {  
50.           //建立服务端socket服务.并监听一个端口  
51.           ServerSocket ss = new ServerSocket(10001);  
52.   
53.           //通过accept方法获取连接过来的客户端对象  
54.           Socket s = ss.accept();  
55.   
56.           String ip = s.getInetAddress().getHostAddress();  
57.           System.out.println(ip+"....connected");  
58.   
59.           //获取客户端发送过来的数据,使用客户端对象的读取流  
60.           InputStream in = s.getInputStream();  
61.           byte[] buf = new byte[1024];  
62.           int len = in.read(buf);  
63.           System.out.println(new String(buf,0,len));  
64.           s.close();  
65.           ss.close();  
66.      }  
67. }  

TCP协议的客户端和服务端互访

[java]  view plain copy

1. /* 
2. 演示tcp传输的客户端和服务端的互访. 
3. 需求:客户端给服务端发送数据,服务端收到后,给客户端反馈信息. 
4. */  
5. /* 
6. 客户端: 
7. 1.建立socket服务,指定要连接的主机和端口 
8. 2.获取输出流,将数据写入,通过网络发送给服务端. 
9. 3.获取输入流,将服务端反馈的数据获取到并打印 
10. 4.关闭客户端资源. 
11. */  
12. import java.io.*;  
13. import java.net.*;  
14. class TcpClient2  
15. {  
16.      public static void main(String[] args) throws Exception  
17.      {  
18.           Socket s = new Socket("LocalHost",10002);  
19.   
20.           OutputStream out = s.getOutputStream();  
21.           out.write("hello server".getBytes());  
22.   
23.           InputStream in = s.getInputStream();  
24.           byte[] buf = new byte[1024];  
25.           int len = in.read(buf);  
26.           System.out.println(new String(buf,0,len));  
27.      }  
28. }  
29. class TcpServer2  
30. {  
31.      public static void main(String[] args) throws Exception  
32.      {  
33.           ServerSocket ss = new ServerSocket(10002);  
34.   
35.           Socket s = ss.accept();  
36.   
37.           String ip = s.getInetAddress().getHostAddress();  
38.           System.out.println(ip+".....connected");  
39.   
40.           InputStream in = s.getInputStream();  
41.           byte[] buf = new byte[1024];  
42.           int len = in.read(buf);  
43.           System.out.println(new String(buf,0,len));  
44.   
45.           OutputStream out = s.getOutputStream();  
46.           out.write("received,hello client".getBytes());  
47.   
48.      }  
49. }  

TCP协议练习

[java]  view plain copy

1. /* 
2. 需求:建立一个文本转换服务器. 
3. 客户端给服务端发送文本,服务端会将文本转成大写在返回客户端. 
4. 而且客户端可以不断的进行文本转换.当客户端输入over时,转换结束. 
5.  
6. 分析: 
7. 客户端: 
8. 既然是操作设备上的数据,那么可以使用io技术,并按照io操作规律思考. 
9. 源,键盘录入. 
10. 目的:网络设备,网络输出流. 
11. 而且操作的是文本数据.可以选择字符流. 
12.  
13. 步骤 
14. 1.建立服务. 
15. 2.获取键盘录入. 
16. 3.将数据发给服务端. 
17. 4.获取服务端返回的大写数据. 
18. 5.关闭资源. 
19.  
20. 都是文本数据,可以使用字符流进行操作,同时提高效率,加入缓冲. 
21. */  
22. import java.io.*;  
23. import java.net.*;  
24. class  TransClient  
25. {  
26.      public static void main(String[] args) throws Exception  
27.      {  
28.           Socket s = new Socket("localhost",10010);  
29.   
30.           //定义键盘录入的字符流  
31.           BufferedReader br =  
32.                new BufferedReader(new InputStreamReader(System.in));  
33.   
34.           //获取socket的输出流并转成字符输出流,发给服务端  
35.           OutputStreamWriter osw = new OutputStreamWriter(s.getOutputStream());  
36.           BufferedWriter bwout = new BufferedWriter(osw);  
37.   
38.           //定义一个socket读取流,读取服务端返回的大写信息.  
39.           BufferedReader brin =  
40.                new BufferedReader(new InputStreamReader(s.getInputStream()));           
41.   
42.           String line = null;  
43.           while ((line=br.readLine())!=null)  
44.           {  
45.                if(line.equals("over"))  
46.                     break;  
47.                bwout.write(line);  
48.                bwout.newLine();  
49.                bwout.flush();  
50.                 
51.                //服务端返回的数据  
52.                String str = brin.readLine();  
53.                System.out.println("server......"+str.toUpperCase());                
54.           }  
55.           s.close();  
56.           br.close();  
57.   
58.      }  
59. }  
60. /* 
61. 服务端: 
62. 源:socket读取流 
63. 目的:socket输出流 
64. 都是字符,用字符流 
65. */  
66. class  TransServer      
67. {  
68.      public static void main(String[] args) throws Exception  
69.      {  
70.           ServerSocket ss = new ServerSocket(10010);  
71.           Socket s = ss.accept();  
72.           String ip = s.getInetAddress().getHostAddress();  
73.           System.out.println(ip+"........connected");  
74.           //读取socket读取流中的数据  
75.           BufferedReader brin =  
76.                new BufferedReader(new InputStreamReader(s.getInputStream()));  
77.           //获取socket输出流,将大写数据写道输出流中,发给客户端  
78.           BufferedWriter bwout =  
79.                new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
80.           String line = null;  
81.           while ((line=brin.readLine())!=null)  
82.           {  
83.                System.out.println(line);  
84.                if(line.equals("over"))  
85.                     break;  
86.                bwout.write(line);  
87.                bwout.newLine();  
88.                bwout.flush();  
89.           }  
90.           s.close();                
91.     }  
92. }  
93. /* 
94. 该例子出现的问题. 
95.      现象:客服端和服务端都在莫名的等待. 
96. 为什么呢? 
97.      因为客户端和服务端都有阻塞式方法,这些方法没读到结束标记, 
98.      那么就导致两端都在等待. 
99. */  

TCP协议--上传TXT文件

[java]  view plain copy

1. //需求:用Tcp协议复制txt文件,从客户端上传到服务端  
2. /* 
3. 客户端: 
4.  
5. 分析. 
6. 操作硬盘上的文件用到io流, 
7. 源:硬盘 
8. 目的:网络输出流 
9. 操作的文本文件,可以用字符流 
10.  
11. 步骤. 
12. 1.建立一个socket服务 
13. 2.获取txt文件内容 
14. 3.将数据发给服务端 
15. 4.接收服务端返回的信息 
16. 5.关闭资源 
17. */  
18. import java.io.*;  
19. import java.net.*;  
20. class  TextClient  
21. {  
22.      public static void main(String[] args) throws Exception  
23.      {  
24.           Socket s = new Socket("192.168.1.250",10100);  
25.            
26.           //定义一个读取字符流缓冲区  
27.           BufferedReader br = new BufferedReader(new FileReader("tcp.txt"));  
28.   
29.           //获取socket输出流,把读取流中的数据写到socket输出流  
30.           BufferedWriter bwout =  
31.                new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
32.   
33.           //获取socket输入流,接收服务端返回的数据  
34.           BufferedReader brin =  
35.                new BufferedReader(new InputStreamReader(s.getInputStream()));  
36.            
37.   
38.           String line = null;  
39.           while ((line=br.readLine())!=null)  
40.           {  
41.                bwout.write(line);  
42.                bwout.newLine();  
43.                bwout.flush();  
44.           }  
45.           s.shutdownOutput();  
46.           String str = brin.readLine();  
47.           System.out.println(str);  
48.           s.close();  
49.           br.close();  
50.      }  
51. }  
52. /* 
53. 服务端: 
54.  
55. 分析. 
56. 接收socket输入流数据, 
57. 源:网络输入流 
58. 目的:硬盘 
59. 操作的文本文件,可以用字符流 
60.  
61. 步骤. 
62. 1.建立一个socket服务 
63. 2.获取socket输入流中的数据 
64. 3.将数据用文件输出流写道txt文件中 
65. 4.给客户端发送已成功信息 
66. 5.关闭资源 
67. */  
68. class  TextServer  
69. {  
70.      public static void main(String[] args) throws Exception  
71.      {  
72.           ServerSocket ss = new ServerSocket(10100);  
73.           Socket s = ss.accept();  
74.           System.out.println(s.getInetAddress().getHostAddress()+"...connected");  
75.            
76.           //获取socket输入流,接收客户端发来的数据  
77.           BufferedReader brin =  
78.                new BufferedReader(new InputStreamReader(s.getInputStream()));  
79.           //定义一个文件输出流缓冲区  
80.           BufferedWriter bw = new BufferedWriter(new FileWriter("tcp-2.txt"));  
81.   
82.           //获取socket输出流,把数据通过socket输出流返回给客户端  
83.           BufferedWriter bwout =  
84.                new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
85.            
86.   
87.           String line = null;  
88.           while ((line=brin.readLine())!=null)  
89.           {  
90.                bw.write(line);  
91.                bw.newLine();  
92.                bw.flush();  
93.           }  
94.           bwout.write("文件上传成功");  
95.           bwout.close();  
96.           s.close();  
97.           bw.close();  
98.      }  
99. }  

TCP协议--上传图片文件

[java]  view plain copy

1. //需求:客户端上传图片到服务端  
2. /* 
3. 客户端. 
4. 1.创建端点socket. 
5. 2.用文件输入流获取图片文件数据. 
6. 3.用socket输出流将数据上传给服务端. 
7. 4.接收服务端返回的socket输入流. 
8. 5.关闭资源. 
9. */  
10. import java.io.*;  
11. import java.net.*;  
12. class  PicClient  
13. {  
14.      public static void main(String[] args) throws Exception  
15.      {  
16.           //1.创建端点  
17.           Socket s = new Socket("192.168.1.250",10008);  
18.           //2.获取图片数据  
19.           FileInputStream fis = new FileInputStream("a.jpg");  
20.           //3.获取socket输出流,把数据发送到服务端  
21.           OutputStream out = s.getOutputStream();  
22.   
23.           byte[] buf = new byte[1024];  
24.           int num = 0;  
25.           while ((num=fis.read(buf))!=-1)  
26.           {  
27.                out.write(buf,0,num);  
28.           }  
29.           //为socket输出流做标记,数据已发送完,结束阻塞  
30.           s.shutdownOutput();  
31.           //4.接收服务端返回的数据  
32.           InputStream in = s.getInputStream();  
33.           byte[] bys = new byte[1024];  
34.           int len = in.read(bys);  
35.           System.out.println(new String(bys,0,len));  
36.           //5.关闭资源  
37.           s.close();  
38.           fis.close();  
39.      }  
40. }  
41. /* 
42. 服务端. 
43. 1.建立端点ServerSocket. 
44. 2.建立文件输出流. 
45. 3.获取socket输入流中的数据,把获取到的数据写到硬盘 
46. 4.用socket输出流返回给客户端信息. 
47. 5.关闭资源. 
48. */  
49. class PicServer  
50. {  
51.      public static void main(String[] args) throws Exception  
52.      {  
53.           //1.创建端点,并接收客户端信息  
54.           ServerSocket ss = new ServerSocket(10008);  
55.           Socket s = ss.accept();  
56.           System.out.println(s.getInetAddress().getHostAddress()+"..con");  
57.           //2.建立文件输出流  
58.           FileOutputStream fos = new FileOutputStream("b.jpg");  
59.   
60.           //3.获取socket输入流中的数据,并用文件输出流写到硬盘  
61.           InputStream in = s.getInputStream();  
62.           byte[] buf = new byte[1024];  
63.           int num = 0;  
64.           while ((num=in.read(buf))!=-1)  
65.           {  
66.                fos.write(buf,0,num);  
67.           }  
68.           //4.用socket输出流给客户端返回信息  
69.           OutputStream out = s.getOutputStream();  
70.           out.write("It's done.".getBytes());  
71.           //5.关闭资源  
72.           s.close();  
73.           fos.close();  
74.      }  
75. }  

TCP协议--客户端并发上传图片--多线程

[java]  view plain copy

1. import java.io.*;  
2. import java.net.*;  
3. //服务端  
4. class PicServerThread implements Runnable  
5. {  
6.      private Socket s;  
7.      PicServerThread(Socket s)  
8.      {  
9.           this.s = s;  
10.      }  
11.      public void run()  
12.      {  
13.           int count = 1;  
14.           String ip = s.getInetAddress().getHostAddress();  
15.           try  
16.           {  
17.                System.out.println(ip+"..con");  
18.                 
19.                File file = new File(ip+"("+(count)+")"+".jpg");  
20.                //用循环判断文件是否存在  
21.                while (file.exists())  
22.                     file = new File(ip+"("+(count++)+")"+".jpg");                
23.   
24.                //2.建立文件输出流  
25.                FileOutputStream fos = new FileOutputStream(file);  
26.   
27.                //3.获取socket输入流中的数据,并用文件输出流写到硬盘  
28.                InputStream in = s.getInputStream();  
29.                byte[] buf = new byte[1024];  
30.                int num = 0;  
31.                while ((num=in.read(buf))!=-1)  
32.                {  
33.                     fos.write(buf,0,num);  
34.                }  
35.                //4.用socket输出流给客户端返回信息  
36.                OutputStream out = s.getOutputStream();  
37.                out.write("It's done.".getBytes());  
38.                //5.关闭资源  
39.                s.close();  
40.                fos.close();  
41.           }  
42.           catch (Exception e)  
43.           {  
44.                throw new RuntimeException(ip+"上传失败");  
45.           }  
46.      }  
47. }  
48. //服务端  
49. class ServerThreadTest  
50. {  
51.      public static void main(String[] args) throws Exception  
52.      {  
53.           //1.创建端点,并接收客户端信息  
54.           ServerSocket ss = new ServerSocket(10008);  
55.           while (true)  
56.           {  
57.                Socket s = ss.accept();  
58.                new Thread(new PicServerThread(s)).start();  
59.           }  
60.      }  
61. }  
62.   
63.   
64. //客户端  
65. class  PicClientThread  
66. {  
67.      public static void main(String[] args) throws Exception  
68.      {  
69.           //判断是否通过主函数传值进来进来  
70.           if (args.length!=1)  
71.           {  
72.                System.out.println("请选择一个jpg文件");  
73.                return ;  
74.           }  
75.           //判断文件是否存在  
76.           File file = new File(args[0]);  
77.           if (!(file.exists() && file.isFile()))  
78.           {  
79.                System.out.println("该文件有问题,要么不存在,要么不是文件");  
80.                return ;  
81.           }  
82.           //判断文件格式是否正确  
83.           if (!file.getName().endsWith(".jpg"))  
84.           {  
85.                System.out.println("图片格式错误");  
86.                return ;  
87.           }  
88.           //判断文件大小是否超过5M  
89.           if (file.length() > 1024*1024*5)  
90.           {  
91.                System.out.println("图片超过5M");  
92.                return ;  
93.           }  
94.           //1.创建端点  
95.           Socket s = new Socket("192.168.1.250",10008);  
96.           //2.获取图片数据  
97.           FileInputStream fis = new FileInputStream(file);  
98.           //3.获取socket输出流,把数据发送到服务端  
99.           OutputStream out = s.getOutputStream();  
100.   
101.           byte[] buf = new byte[1024];  
102.           int num = 0;  
103.           while ((num=fis.read(buf))!=-1)  
104.           {  
105.                out.write(buf,0,num);  
106.           }  
107.           //为socket输出流做标记,数据已发送完,结束阻塞  
108.           s.shutdownOutput();  
109.           //4.接收服务端返回的数据  
110.           InputStream in = s.getInputStream();  
111.           byte[] bys = new byte[1024];  
112.           int len = in.read(bys);  
113.           System.out.println(new String(bys,0,len));  
114.           //5.关闭资源  
115.           s.close();  
116.           fis.close();  
117.      }  
118. }  

TCP协议--客户端并发登陆

[java]  view plain copy

1. import java.io.*;  
2. import java.net.*;  
3. //客户端  
4. class LoginClient  
5. {  
6.      public static void main(String[] args) throws Exception  
7.      {  
8.           //建立端点  
9.           Socket s = new Socket("127.0.0.1",10009);  
10.           //用字符读取流读取键盘录入  
11.           BufferedReader br =  
12.                new BufferedReader(new InputStreamReader(System.in));  
13.           //获取socket输出流,向服务端发送数据  
14.           PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
15.           //获取socket输入流,以获取服务端返回数据  
16.           BufferedReader brin =  
17.                new BufferedReader(new InputStreamReader(s.getInputStream()));  
18.   
19.           String line = null;  
20.           //限制输入3次  
21.           for (int x=0; x<3; x++)  
22.           {  
23.                line=br.readLine();  
24.                if (line==null)  
25.                     break;  
26.   
27.                pw.println(line);  
28.   
29.                String info = brin.readLine();  
30.                System.out.println(info);  
31.                if (info.contains("欢迎"))  
32.                     return;  
33.           }  
34.           s.close();  
35.           br.close();           
36.      }  
37. }  
38.   
39. class LoginServer  
40. {  
41.      public static void main(String[] args) throws Exception  
42.      {  
43.           ServerSocket ss = new ServerSocket(10009);  
44.           while (true)  
45.           {  
46.                Socket s = ss.accept();  
47.                new Thread(new UserThread(s)).start();  
48.           }  
49.      }  
50. }  
51. //服务端线程  
52. class UserThread implements Runnable  
53. {  
54.      private Socket s;  
55.      UserThread(Socket s)  
56.      {  
57.           this.s = s;  
58.      }  
59.      public void run()  
60.      {  
61.           //老师的思想  
62.           String ip = s.getInetAddress().getHostAddress();  
63.           System.out.println(ip+".....con");  
64.           try  
65.           {     //限制输入3次  
66.                for (int x=0; x<3; x++)  
67.                {  
68.                     BufferedReader brin =  
69.                          new BufferedReader(new InputStreamReader(s.getInputStream()));  
70.                     String user = brin.readLine();  
71.                     if(user==null)  
72.                          break;  
73.   
74.                     BufferedReader br =  
75.                          new BufferedReader(new FileReader("user.txt"));  
76.   
77.                     PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
78.                 
79.                     String line = null;  
80.                     //定义一个标记  
81.                     boolean flag = false;  
82.                     while ((line=br.readLine())!=null)  
83.                     {  
84.                          if (user.equals(line))  
85.                          {  
86.                               flag = true;  
87.                               break;  
88.                          }  
89.                     }  
90.                     if (flag)  
91.                     {  
92.                          System.out.println("登陆成功");  
93.                          pw.println("欢迎"+user);  
94.                          break;  
95.                     }  
96.                     else  
97.                     {  
98.                          System.out.println(user+"尝试登陆");  
99.                          pw.println(user+"用户名错误");  
100.                     }  
101.   
102.                }  
103.                s.close();  
104.           }  
105.           catch (Exception e)  
106.           {  
107.                throw new RuntimeException(ip+"校验失败");  
108.           }  
109.   
110.           /*自己的思想 
111.           try 
112.           { 
113.                String ip = s.getInetAddress().getHostAddress(); 
114.                System.out.println(ip+".....con"); 
115.                PrintWriter pw = null; 
116.                for (int x=0; x<3; x++) 
117.                { 
118.                     BufferedReader brin = 
119.                          new BufferedReader(new InputStreamReader(s.getInputStream())); 
120.                     String user = brin.readLine(); 
121.                     if(user==null) 
122.                          break; 
123.  
124.                     BufferedReader br = 
125.                          new BufferedReader(new FileReader("user.txt")); 
126.  
127.                     pw = new PrintWriter(s.getOutputStream(),true); 
128.                
129.                     System.out.println(user+"尝试登陆"); 
130.  
131.                     String line = null; 
132.                     while ((line=br.readLine())!=null) 
133.                     { 
134.                          if (user.equals(line)) 
135.                          { 
136.                               System.out.println("登陆成功"); 
137.                               pw.println("欢迎"+user); 
138.                               return ; 
139.                          } 
140.                     } 
141.  
142.                     pw.println(user+"用户名错误"); 
143.                     System.out.println("登陆失败"); 
144.  
145.                } 
146.                pw.println("您的次数用尽"); 
147.                
148.           } 
149.           catch (Exception e) 
150.           { 
151.                throw new RuntimeException("校验失败"); 
152.           } 
153.           */  
154.      }  
155. }  

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

常用方法：

①int getDefaultPort(): 获取与此URL关联协议的默认端口；

②String getFile(): 获取此URL的文件名；

③String getHost(): 获取此URL的主机名；

④String getPath()：或取此URL的路径；

⑤int getPort(): 获取此URL的端口号；

⑥ String getProtocol(): 获取此URL的协议名称；

⑦String getQuery(): 获取此URL的查询部分；
代码

[java]  view plain copy

1. import java.net.*;      
2. class  URLDemo      
3. {      
4.     public static void main(String[] args) throws Exception      
5.     {      
6.         //URL url=new URL("http://192.168.1.13:11000/myweb/demo.html");      
7.         URL url=new URL("http://192.168.1.13:11000/myweb/demo.html?name=haha&age=30");      
8.         System.out.println("getProtocol():"+url.getProtocol()); //http                
9.         System.out.println("getHost():"+url.getHost());//192.168.1.13      
10.         System.out.println("getDefaultPort():"+url.getDefaultPort());//80，如果关联的协议没有默认的端口，则值为-1；      
11.         System.out.println("getPort():"+url.getPort()); //  11000,如果没有设置则为-1；      
12.         System.out.println("getPath():"+url.getPath());// /myweb/demo.html      
13.         System.out.println("getFile():"+url.getFile());///myweb/demo.html?name=haha&age=30      
14.         System.out.println("getQuery():"+url.getQuery());//name=haha&age=30      
15.       
16.     /*  int port = url.getPort();   
17.         if(port==-1)   
18.             port =80;   
19.         getPort（） = -1   
20.     */      
21.     }      
22. }      

URLConnection：作用类似于socket，其实内部封装了socket，所以可以获取网络输入输出流，通过URL和URLConnection可以方便的对应用层网络数据进行读取和操作；

代码

[java]  view plain copy

1. import java.net.*;      
2. import java.io.*;      
3.       
4. class URLConnectionDemo       
5. {      
6.     public static void main(String[] args) throws Exception      
7.     {      
8.         URL url=new URL("http://192.168.1.13:8080/myweb/demo.html");      
9.            
10.         URLConnection conn = url.openConnection();      
11.             
12.         System.out.println(conn+"-------");      
13.             
14.         InputStream in = conn.getInputStream();      
15.             
16.         byte [] buf =new byte[1024];      
17.             
18.         int len = in.read(buf);      
19.             
20.         System.out.println(new String(buf,0,len));      
21.       
22.     }      
23. }    

自定义图形化界面浏览器

[java]  view plain copy

1. import java.awt.*;      
2. import java.awt.event.*;      
3. import java.io.*;      
4. import java.net.*;      
5. class  MyIEByGUI      
6. {      
7.     private Frame f;      
8.     private TextField tf;      
9.     private Button but;      
10.     private TextArea ta;      
11.       
12.     private Dialog d;      
13.     private Label lab;      
14.     private Button okBut;      
15.       
16.     MyIEByGUI()      
17.     {      
18.         init();      
19.     }      
20.     public void init()      
21.     {      
22.         f = new Frame("My IE");      
23.         f.setBounds(300,100,500,400);      
24.         f.setLayout(new FlowLayout());      
25.       
26.         tf = new TextField(40);      
27.         but = new Button("转到");      
28.         ta = new TextArea(20,50);      
29.       
30.         d = new Dialog(f,"提示信息-self",true);      
31.         d.setBounds(400,200,240,200);      
32.         d.setLayout(new FlowLayout());       
33.       
34.         lab =new Label();      
35.         okBut=new Button("确定");      
36.       
37.         d.add(lab);      
38.         d.add(okBut);      
39.       
40.         f.add(tf);      
41.         f.add(but);      
42.         f.add(ta);      
43.               
44.         myEvent();      
45.         f.setVisible(true);      
46.       
47.     }      
48.     public void myEvent()      
49.     {      
50.         but.addActionListener(new ActionListener()      
51.         {      
52.             public void actionPerformed(ActionEvent e)      
53.             {      
54.                 try      
55.                 {      
56.                     showWebPage();      
57.       
58.                 }      
59.                 catch (Exception ex)      
60.                 {      
61.                 }      
62.                       
63.             }      
64.         });      
65.         tf.addKeyListener(new KeyAdapter()      
66.         {      
67.             public void keyPressed(KeyEvent e)      
68.             {      
69.                 if(e.getKeyCode()==KeyEvent.VK_ENTER)      
70.                 {      
71.                     try      
72.                     {      
73.                         showWebPage();      
74.       
75.                     }      
76.                     catch (Exception ex)      
77.                     {      
78.                     }      
79.                           
80.                 }      
81.             }      
82.       
83.         });      
84.         okBut.addActionListener(new ActionListener()      
85.         {      
86.             public void actionPerformed(ActionEvent e)      
87.             {      
88.                 d.setVisible(false);      
89.             }      
90.         });      
91.         d.addWindowListener(new WindowAdapter()      
92.         {      
93.             public void windowClosing(WindowEvent e)      
94.             {      
95.                 d.setVisible(false);      
96.             }      
97.         });      
98.         f.addWindowListener(new WindowAdapter()      
99.         {      
100.             public void windowClosing(WindowEvent e)      
101.             {      
102.                 System.exit(0);      
103.             }      
104.         });      
105.               
106.     }      
107.     private void showWebPage() throws Exception      
108.     {      
109.         ta.setText("");      
110.               
111.         //http://192.168.1.13:8080/myweb/demo.html      
112.         String url =tf.getText();      
113.               
114.         int index1 = url.indexOf("//")+2;      
115.         int index2 = url.indexOf("/",index1);      
116.       
117.         String str =url.substring(index1,index2);      
118.         String[] arr = str.split(":");      
119.         String host = arr[0];             
120.         int port = Integer.parseInt(arr[1]);      
121.         String dir = url.substring(index2);      
122.         //ta.setText(url);      
123.         ta.setText(port+","+null);      
124.         //建立Socket客户端      
125.         Socket s = new Socket(host,port);      
126.         //发送请求消息头      
127.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);//别忘了加true      
128.         out.println("GET "+dir+" HTTP/1.1");      
129.         out.println("Accept: */*");      
130.         out.println("Accept-Language: zh-cn");      
131.         out.println("Host: 192.168.1.13:11000");      
132.         out.println("Connection: Keep-Closed");      
133.         out.println();//记得一定要加空行      
134.         out.println();      
135.       
136.         BufferedReader bufr =       
137.             new BufferedReader(new InputStreamReader(s.getInputStream()));      
138.         String line = null;      
139.         while((line=bufr.readLine())!=null)      
140.         {      
141.             ta.append(line+"\r\n");      
142.         }      
143.         s.close();      
144.       
145.     }      
146.       
147.     public static void main(String[] args)       
148.     {      
149.         new MyIEByGUI();      
150.     }      
151. }      
152.     
153. private void showWebPage() throws Exception      
154. {      
155.     //使用URL和URLConnection对showWebPage改写。      
156.     //很明显，这两个封装的应用层对象使用起来更方便简洁      
157.     ta.setText("");           
158.     String urlPath =tf.getText();             
159.     URL url=new URL(urlPath);      
160.     URLConnection conn = url.openConnection();      
161.     //System.out.println(conn);      
162.     InputStream in = conn.getInputStream();      
163.     byte [] buf =new byte[1024];      
164.     int len = in.read(buf);      
165.     ta.setText(new String(buf,0,len));      
166. }    

域名解析：用IP地址登陆网站，数字不好记忆，习惯用主机名，如www.baidu.com，从主机名到获得该主机名对应的IP地址的过程，就是域名解析，它一般是DNS服务器完成的；

域名解析步骤大致分为2步：

①查找本地的IP地址和主机名映射表，如果存在映射，则使用本机映射，如：127.0.0.1和localhost的对应关系就在这个映射表中，通过对映射文件进行配置可以实现一些功能，如:将常用网站配置在表中，这样速度快些，还可以屏蔽过滤一些垃圾网站；

②如果第一步没有找到，就会去设置的DNS服务器查找，找到对应的IP地址，获取地址后，再返回给本机IP地址，本机再通过IP地址链接上想要访问的网站。

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------