黑马程序员-java网络编程以及IO流的应用

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

---导读

!--网络基本知识：

OSI参考模型
应用层、表示层、会话层、传输层、网络层、数据链路层、物理层

TCP/IP参考模型
应用层、传输层、网际层、主机至网络层

!--在Java中网络程序有两种协议：TCP和UDP，TCP通过握手协议进行可靠的连接

UDP：    将数据及源和目的封装成数据包中，不需要建立连接
            每个数据报的大小在限制在64k内
            因无连接，是不可靠协议
            不需要建立连接，速度快
            
 TCP:    建立连接，形成传输数据的通道
            在连接中形成大数据量传输
            通过三次握手完成连接，是可靠协议
            必须建立连接，效率会稍低

IP地址：用于标记一台计算机的身份证。IP地址由网络地址（确定网络）和主机地址（网络中的主机）组成。

URL和URI

URI：统一资源标识符，用于标识一个web资源，包含了两个部分。

URL：统一资源定位符，能够精确的定位数据的URI。

URN：统一资源名称，除了URL的URI。

在java中URI和URL是分开的两个类，URI类专门用于解析，URL用于通信。

InetAddress：根据域名得到IP地址和主机名，没有构造方法。

[java] view plaincopy

1. package cn.itheima.day23;  
2.   
3. import java.net.InetAddress;  
4. import java.net.UnknownHostException;  
5.   
6. public class InetAddressTest {  
7.   
8.     public static void main(String[] args) throws Exception {  
9.         // TODO Auto-generated method stub  
10.           
11.         InetAddress local = InetAddress.getLocalHost();  
12.         System.out.println("Address:" + local.getHostAddress());  
13.         System.out.println("Name:"+local.getHostName());  
14.           
15.         InetAddress[] remote = InetAddress.getAllByName("www.baidu.com");  
16.         for(InetAddress a: remote){  
17.             System.out.println("Address:" + a.getHostAddress());  
18.             System.out.println("name:" + a.getHostName());  
19.         }  
20.     }  
21. }  

!--Socket(TCP)

Socket就是为网络服务提供的一种机制，通信的两端都有socket，网络通信其实就是socket间的通信，数据在两个socket间通过IO传输。

示例1：TCP通信

[java] view plaincopy

1. package cn.itheima.day23;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.io.OutputStream;  
6. import java.net.ServerSocket;  
7. import java.net.Socket;  
8.   
9. /* 
10.  客户端对应的对象是socket 
11.  服务端对应的对象是ServerSocket 
12.  */  
13.   
14.   
15. /* 
16.  客户端： 
17.     通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机 
18.     因为TCP是面向连接的，所以在建立socket服务时， 
19.     就要有服务端存在，并连接成功，形成通路后，在该通道进行数据传输 
20.      
21.  步骤： 
22.   1. 创建socket服务，并知道那个要连接的主机和端口 
23.   2. 获取socket流中的输出流，将数据写到该流中，通过网络发送给服务器 
24.   3. 获取socket流中的输入流，将服务端反馈的数据获取到 
25.   4. 关闭客户端资源 
26.    
27.  */  
28. class TcpClient{  
29.       
30.     public static void main(String[] args) throws Exception, IOException{  
31.         //创建客户端的socket服务，指定目的主机和端口  
32.         Socket s = new Socket("192.168.1.254", 10003);  
33.           
34.         //为了发送数据，应该获取socket流中的输出流  
35.         OutputStream out = s.getOutputStream();  
36.           
37.         out.write("tcp sss".getBytes());  
38.           
39.         InputStream in = s.getInputStream();  
40.           
41.         byte[] buf = new byte[1024];  
42.           
43.         int len = in.read(buf);  
44.           
45.         System.out.println(new String(buf, 0, len));  
46.           
47.         s.close();  
48.     }  
49. }  
50.   
51. /* 
52.  服务端： 
53.     1. 建立服务端的socket服务并监听一个端口，ServerSocket(); 
54.     2. 获取连接过来的对象。 
55.         通过ServerSocket的accept方法，没有连接就会等，所以这个方法是阻塞式的， 
56.     3. 客户端如果发过来数据，那么服务端要使用对应的客户端对象， 
57.         并获取到该客户对象的读取流来读取发过来的数据 
58.     4. 关闭服务端（可选） 
59.  */  
60. class TcpServer{  
61.       
62.     public static void main(String [] args) throws Exception{  
63.         //建立服务端的socket服务，并监听端口  
64.         ServerSocket ss = new ServerSocket(10003);  
65.           
66.         //通过accept方法获取连接过来的客户端对象  
67.         Socket s = ss.accept();  
68.           
69.         String ip = s.getInetAddress().getHostAddress();  
70.         System.out.println(ip + "....connected");  
71.           
72.         InputStream in = s.getInputStream();  
73.           
74.         byte [] buf = new byte[1024];  
75.           
76.         int len = in.read(buf);  
77.           
78.         System.out.println(new String(buf, 0, len));  
79.           
80.         s.close();  
81.     }  
82. }  
83.   
84. public class TcpSemo {  
85.   
86.     public static void main(String[] args) {  
87.         // TODO Auto-generated method stub  
88.   
89.     }  
90.   
91. }  

示例2：UDP通信

[java] view plaincopy

1. package cn.itheima.day23;  
2.   
3. import java.io.IOException;  
4. import java.net.DatagramPacket;  
5. import java.net.DatagramSocket;  
6. import java.net.InetAddress;  
7. import java.net.SocketException;  
8. import java.net.UnknownHostException;  
9.   
10. /* 
11. 需求：通过udp传输方式，将一段文字数据发送出去 
12.  
13. 思路： 
14.     1. 建立udpsocket服务。 
15.     2. 提供数据，并将数据封装到数据包中。 
16.     3. 通过socket服务的发送功能，将数据包发出去。 
17.     4. 关闭资源。 
18.  */  
19.   
20. public class UdpSend {  
21.   
22.     public static void main(String[] args) throws IOException {  
23.         // TODO Auto-generated method stub  
24.         //创建udp服务，通过DatagramSocket对象  
25.         DatagramSocket ds = new DatagramSocket();  
26.           
27.         //确定数据，并封装成数据包  
28.         byte [] buf = "udp ge men lai le ".getBytes();  
29.         DatagramPacket dp =   
30.                 new DatagramPacket(buf, buf.length, InetAddress.getByName("10.0.11.120"), 10000);  
31.           
32.         ds.send(dp);  
33.         ds.close();  
34.     }  
35. }  
36.   
37. /* 
38. 需求：定义一个程序，用于接收udp传输的数据 
39.  
40. 定义udp的接收端 
41. 思路： 
42.     1. 定义udpsocket服务。通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识。 
43.     2. 定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。 
44.     3. 通过socket服务中的receive方法将接收到的数据存入已定义号的数据包中。 
45.     4. 通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上 
46.     5. 关闭资源 
47.  */  
48.   
49.   
50. class UdpRece{  
51.     public static void main(String[] args) throws Exception{  
52.         //创建udp socket， 建立端点  
53.         DatagramSocket ds = new DatagramSocket(10000);  
54.           
55.         //定义数据包，用于存储数据  
56.         byte[] buf = new byte[1024];  
57.         DatagramPacket dp = new DatagramPacket(buf, buf.length);  
58.           
59.         //通过服务的receive方法将接收到的数据存入数据包中  
60.         ds.receive(dp);  
61.           
62.           
63.         String ip = dp.getAddress().getHostAddress();  
64.         String data = new String(dp.getData(),0, dp.getLength());  
65.         int port = dp.getPort();  
66.           
67.         System.out.println(ip+ "::" + data + "::" + data);;  
68.           
69.         ds.close();  
70.           
71.     }  
72. }  

!--深入理解分析Tcp通信---复制文件

第一步：定义服务端

/**
 * 服务端
 * @author Administrator
 *
 */
import java.io.*;
import java.net.*;
public class ServerDemo implements Runnable{
private ServerSocket ss;//服务端
public ServerDemo(ServerSocket ss){
this.ss=ss;
}
public void run(){
try {
Socket s=ss.accept();//从服务端获得该服务端监听的客户端
BufferedWriter bfw=new BufferedWriter(new FileWriter("E:\\3.java"));
PrintWriter pw=new PrintWriter(bfw,true);//目的流
BufferedReader bfrClient=
new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while((line=bfrClient.readLine())!=null){
pw.println(line);
}
String info="上传成功！";
PrintWriter pwClient=new PrintWriter(s.getOutputStream(),true);
pwClient.println(info);
s.close();
//System.out.println(info);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{

try {
if(ss!=null){
ss.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}
}

第二步：定义客户端

/**
 * 客户端
 * @author Administrator
 *
 */
import java.io.*;
import java.net.*;
public class CopyFileByInet implements Runnable{

private Socket s;//定义一个客户端服务
public void setSocket(Socket s){//可以设置
this.s=s;
}
public CopyFileByInet(Socket s){//对客户端进行初始化
this.s=s;
}
public void run(){//线程入口
File f=new File("D:\\ab","Event.java");
if(f.exists()){
if(!f.isDirectory()){
PrintWriter pw;//定义一个目的流
BufferedReader bfrServer=null;//从服务器端读入的数据封装
BufferedReader bfr=null;
try {
pw=new PrintWriter(s.getOutputStream(),true);//对目的流初始化：后面true代表自动刷新
} catch (IOException e1) {
// TODO Auto-generated catch block
System.out.println("获取文本输入流失败");
return;
}
try {
bfr=new BufferedReader(new FileReader(f));
String line=null;
try {
while((line=bfr.readLine())!=null){
pw.println(line);
}
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("硬盘文件读取失败");
return;
}
try {
s.shutdownOutput();
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("客户端输入流关闭失败！");
}

try {

bfrServer=new BufferedReader(new InputStreamReader(s.getInputStream()));
String info=bfrServer.readLine();
System.out.println(info);

} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("获取服务端输入流失败client！");
}

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
System.out.println("文件读取失败");
}finally{
try {
if(bfrServer!=null||pw!=null||bfr!=null)
bfrServer.close();
pw.close();
bfr.close();
s.close();
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("资源关闭失败！");
}
}
}else System.out.println("该文件是目录，不可读取");
}else System.out.println("该文件不存在");
}
}

第三步：测试

/**
 * 网络编程--网络通讯
 * 测试类

 * ip地址
 * 端口
 * 传输协议
 * @author Administrator
 *需求：通过客户端服务端完成文件的复制
 */
/**
 *特别注意事项：
 *1：注意：只要使用了Socket中流的readLine()方法：这个方法就是阻塞式方法：只要
 *Socket中的输出流打开着，它就一直阻塞，等待接受输入而输出！！！
 *2：对readLine()这个方法：它是以换行符为标准得到数据的，所以在Socket中，得到的数据必须是换行的
 *--因此有集中解决方案：第一：在客户端传入数据时，得到的数据必须进行换行放到Socket的输出流中！！！
 *第二：就是把Socket输出流用printWriter(Writer/OutputStream,true)或者printStram()包装起来
 */
import java.io.*;
import java.net.*;
public class Test {

public static void main(String[] args) {

//注意：Tcp协议中，必须现有服务端才能有客户端！！！
//System.out.println("进入");
try {
ServerSocket ss=new ServerSocket(10020);
new Thread(new ServerDemo(ss)).start();
Socket s;
try {
s = new Socket("192.168.1.105",10020);
//System.out.println("进入1");
new Thread(new CopyFileByInet(s)).start();
} catch (UnknownHostException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
} catch (IOException e) {
// TODO Auto-generated catch block
new RuntimeException("创建服务器端失败！");
}

}
}

结果：上传成功

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------