黑马程序员-笔记--网络编程

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

java中的网络模型：
    TCP/IP：自上至下分为：应用层，传输层，网络层，网际层。 

结合代码：UDP与TCP的区别，以及UDP传输的基本代码。

[java]  view plain copy

1. public class Play38 {  
2.     /** 
3.      * @throws IOException  
4.      * 网络编程： 
5.      * UDP：面向无连接的。 
6.      * 数据封装在数据包中， 
7.      * 每个包大小最大64K， 
8.      * 无连接不可靠。但速度快。 
9.      *  
10.      *  
11.      * TCP：面向连接， 
12.      * 形成数据通道，数据不限大小。 
13.      * 一次传输，三次握手， 
14.      * 建立连接导致速度降低。 
15.      *  
16.      * Socket：为网络服务停工的一种机制。 
17.      * 通信的两端都有Socket。网络通信就是Socket的通信。 
18.      * 两个Socket通过IO流传输。 
19.      *  
20.      * UDP的套接字Socket：DatagramSocket 
21.      * UnknownHostException 未知主机异常。 
22.      *  
23.      * @throws  
24.      */  
25.     public static void main(String[] args) throws IOException,InterruptedException  {  
26.         new Thread(){  
27.             @Override  
28.             public void run() {  
29.                 try {  
30.                     UDPGet();  
31.                 } catch (IOException e) {  
32.                     e.printStackTrace();  
33.                 }  
34.             };  
35.         }.start();  
36. //      for(int i=0;i<10;i++){  
37. //          Thread.sleep(1000);  
38. //          UDPSend();  
39. //      }  
40.         UDPSend2();  
41.     }  
42.     public static void test() throws UnknownHostException{  
43.         InetAddress ia = InetAddress.getLocalHost();//获取本机主机名和地址。  
44.         String address= ia.getHostAddress();//获取主机名称。  
45.         String name = ia.getHostName();  
46.         System.out.println(ia+":::"+address+":::"+name);  
47.           
48.         InetAddress iaAddress = InetAddress.getByName("www.baidu.com");//通过主机名或者ip地址，获得其InetAddress  
49.         System.out.println(iaAddress.getHostAddress());//建议使用地址，使用主机名，有解析过程。  
50.           
51.         InetAddress[] ias = iaAddress.getAllByName("www.baidu.com");//通过主机名，获取器全部ip。  
52.         System.out.println(ias.length);  
53.         for(InetAddress ia1 : ias){  
54.             System.out.println(ia1.getHostAddress());  
55.         }  
56.     }  
57.       
58.     /* 
59.      * UDP传输思路： 
60.      * 建立UDPScoket服务 
61.      * 提供并封装数据 
62.      * 使用Socket的发送功能发送数据 
63.      * 关闭资源。 
64.      *  
65.      */  
66.     public static void UDPSend() throws IOException{  
67.         System.out.println("send++++");  
68.         //创建UPD服务，建立对应的Socket对象。  
69.         DatagramSocket ds = new DatagramSocket();  
70.         //提供数据，封装成包。  
71.         byte[] data = "UDP send message test,测试。".getBytes();  
72.         DatagramPacket dp = new DatagramPacket(data, data.length,InetAddress.getLocalHost(),10000);  
73.         //通过send方法，发送数据。  
74.         ds.send(dp);  
75.         //关闭资源。  
76.         ds.close();  
77.     }  
78.     /* 
79.      * UDP接收数据。 
80.      * UDP的接收端是阻塞式方法。 
81.      * 定义UDPSocket服务， 
82.      * 定义数据包，因为要存储接收到的字节数据，因为数据包对象有更多功能提取字节数据中的不同数据信息。 
83.      * 通过socket的receive方法将收到数据封装在定义的数据包中。 
84.      * 通过数据包的功能，打印数据 
85.      * 关闭资源。 
86.      *  
87.      */  
88.     public static void UDPGet() throws IOException{  
89.         DatagramSocket ds = new DatagramSocket(10000);//服务不能建立在while中，否则端口异常，同时使用同一个端口。  
90.         while(true){  
91.               
92.           
93.         byte[] data = new byte[1024];  
94.         DatagramPacket dp = new DatagramPacket(data, data.length);  
95.         ds.receive(dp);//该方法如果没有接收到数据，线程阻塞。  
96.         String ip = dp.getAddress().getHostAddress();  
97.         int port = dp.getPort();  
98.         String str = new String(dp.getData(),0,dp.getLength());  
99.         System.out.println(ip+"|||"+port+"|||"+str);  
100.         }  
101.         //ds.close();  
102.     }  
103. }   
104.   
105. TCP传输的基本代码：  
106.  public class Play39 {  
107.     /** 
108.      *TCP：对应客户端与服务端。 
109.      * 
110.      *客户端对应的是：Socket 
111.      *通过查阅Socket对象，发现在该对象建立时，就可以去连接指定主机。 
112.      *TCP是面向连接，所以建立Socket时，就要服务端已经存在，并连接成功，形成通路 
113.      *在该通道上就行数据传输。 
114.      * 
115.      *服务端对应的是：ServerSocket 
116.      * @throws IOException  
117.      * @throws UnknownHostException  
118.      */  
119.     public static void main(String[] args) throws UnknownHostException, IOException {  
120.         new Thread(){  
121.             @Override  
122.             public void run() {  
123.                 try{  
124.                     server();//服务端一定要先启动。  
125.                 }catch (Exception e) {  
126.                 }  
127.             };  
128.         }.start();  
129.   
130.         client();  
131.           
132.     }  
133.       
134.     /*客户端。 
135.      *  
136.      *1.创建Socket服务。指定连接的主机和端口。 
137.      *2.创建流。 
138.      *3.操作。 
139.      *  
140.      */  
141.     public static void client() throws UnknownHostException, IOException{  
142.         //创建客户端Socket  
143.         Socket s = new Socket(InetAddress.getLocalHost(),10001);  
144.         //发出数据，获取输出流。  
145.         OutputStream os = s.getOutputStream();  
146.         os.write("TCP send Test! Server,你好啊。".getBytes());  
147.           
148.         //接受服务端的响应，使用输入流  
149.         InputStream is = s.getInputStream();  
150.         byte[] data = new byte[1024];  
151.         int length = is.read(data);  
152.         System.out.println(new String(data,0,length));  
153.           
154.         s.close();  
155.     }  
156.     /* 
157.      * 服务端 
158.      * 创建ServerSocket对象，并监听端口。 
159.      * 获取链接过来的客户端对象。没有链接过来就等待，是一个阻塞式的方法。 
160.      * 通过客户端Socket对象获得流，从而获得数据。 
161.      */  
162.     public static void server() throws IOException, InterruptedException {  
163.         ServerSocket ss = new ServerSocket(10001);  
164.         Socket s = ss.accept();  
165.         InputStream is = s.getInputStream();  
166.         byte[] data = new byte[1024];  
167.         int length = is.read(data);  
168.         System.out.println(new String(data,0,length)+"|||"+s.getPort()+"+++"+s.getInetAddress());  
169.           
170.           
171.         //使用服务端给客户端响应  
172.         OutputStream os = s.getOutputStream();  
173.         Thread.sleep(10000);  
174.         os.write("Get Message,roger".getBytes());  
175.         s.close();  
176.           
177.         //ss.close();//在现实中，ServerSocket是没有必要关闭，他需要继续接受别的请求。  
178.     }  
179. }  
180.   
181. 使用TCP实现一个类似聊天室的功能。  
182. public class Play40 {  
183.     public static void main(String[] args) throws UnknownHostException, IOException {  
184.         new Thread(){  
185.             @Override  
186.             public void run() {  
187.                 try{  
188.                     server();  
189.                 }catch (Exception e) {  
190.                 }  
191.             };  
192.         }.start();  
193.         client();  
194.     }  
195.       
196.     public static void client() throws UnknownHostException, IOException{  
197.   
198.         Socket s = new Socket(InetAddress.getLocalHost(),10001);  
199.           
200.         PrintWriter pw = new PrintWriter(s.getOutputStream(),true);//使用打印流，可以取代缓冲流刷新，以及继续换行的作用。  
201.         //BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
202.         BufferedReader brs = new BufferedReader(new InputStreamReader(s.getInputStream()));  
203.         BufferedReader br =  new BufferedReader(new InputStreamReader(System.in));  
204.         String line = null;  
205.         while((line=br.readLine())!=null){  
206.             if(line.equals("end"))break;  
207.             pw.println(line);  
208.             System.out.println(brs.readLine());  
209.         }  
210.         pw.close();  
211.         br.close();  
212.         brs.close();  
213.         s.close();    
214.     }  
215.       
216.       
217.     public static void server() throws IOException, InterruptedException {  
218.         ServerSocket ss = new ServerSocket(10001);  
219.         Socket s = ss.accept();  
220.         System.out.println(s.getInetAddress());  
221.         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));  
222.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
223.           
224.           
225.         String str = null;  
226.         while((str=br.readLine())!=null){  
227.             System.out.println(str);  
228.             Thread.sleep(100);  
229.             bw.write(str.toUpperCase());  
230.             bw.newLine();//在一行数据发送完毕，接收端，需要接收到回车符，才能知道一次数据接受完毕。所以需要使用newLine方法。  
231.             bw.flush();//BufferedWriter是一个具有缓冲作用的流，需要刷新将一次的数据读入。  
232.               
233.         }  
234.         s.close();  
235.         ss.close();  
236.       
237.     }  
238.       
239. }