Java入门——（8）网络编程

 

关键词：IP地址、、端口、UDP、DatagramPacket类、DatagramSocket类、TCP、ServerSocket类、Socket类、文件上传

 

 

一、基本概念

       1、基本概念

      ①MAC：MAC（Media Access Control或者Medium Access Control）地址，意译为媒体访问控制，或称为物理地址、硬件地址，用来定义网络设备的位置。在OSI模型中，第三层网络层负责IP地址 ，第二层数据链路层则负责 MAC地址。因此一个主机会有一个MAC地址，而每个网络地址会有一个专属于它的IP地址。

 

      ②IP地址：是指互联网协议地址（Internet Protocol Address，又译为网际协议地址），是IP Address的缩写。IP地址是IP协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。目前还有些ip代理软件，但大部分都收费。

      

 

TCP/IP 网络模式

应用层

如HTTP、FTP、DNS

传输层

如TCP、UDP

网络层

如IP、ICMP、IGMP

链锯层

如驱动程序、接口

 

        ③端口：可以认为是设备与外界通讯交流的出口。

        端口号是用两个字节（16位的二进制数）表示，它的取值范围是0~65 535 ，其中0~1023之间的端口号用于以下知名的网络服务和应用，用户的普通应用程序需要使用1024以上的端口号。端口分为物理端口和逻辑端口（软件应用程序的数字标识）。

        ④TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。

        TCP协议是面向连接的通信协议，提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；

         ⑤UDP是无线通信协议，不为IP提供可靠性、流控或差错恢复功能。

         2、常见InetAddress类的常用方法示例：

 1 public class Example1 {
 2     public static void main(String[] args) throws Exception{
 3         //创建一个表示本地主机的InetAddress对象
 4         InetAddress localAddress = InetAddress.getLocalHost(); 
 5         //获得指定主机的InetAddress对象
 6         InetAddress remoteAddress = InetAddress.getByName("www.itcast.cn");
 7         //得到IP地址的主机名。
 8         System.out.println("本机的IP地址："+localAddress.getHostName());
 9         //获得字符串格式的原始IP地址
10         System.out.println("itcast的IP地址："+remoteAddress.getHostAddress());
11         //判断指定的时间内地址是否可以到达
12         System.out.println("3秒是否可达："+remoteAddress.isReachable(3000));
13        
14         System.out.println("itcast的主机名为："+remoteAddress.getHostName());
15     }
16 }

运行结果：

本机的IP地址：wrt.local
itcast的IP地址：123.57.45.99
3秒是否可达：false
itcast的主机名为：www.itcast.cn

 二、UDP通信

      1、DatagramPacket

      该类类似于集装箱，在创建发送端和接收端的DatagramPacket对象时，使用的构造方法有所不同，接收端的构造方法只需要接收一个字节数组来存放接收到的数据，而发送端的构造方法不但要接收存放了发送数据的字节数组还需要制定发送端IP地址和端口号。

      DatagramPacket构造方法：

       ①DatagramPacket（byte[] buf,int length）

       用于接收端, 创建DatagramPacket对象时，指定了封装数据的字节数组和数据大小。

       ②DatagramPacket（byte[] buf,int length，InetAddress addr,int port）

       用于发送端, 创建DatagramPacket对象时，指定了封装数据的字节数组、数据大小、数据包的目标IP地址（addr）以及端口号（port）。

       ③DatagramPacket（byte[] buf,int offset,int length）

        用于接收端，创建DatagramPacket对象时，指定了封装数据的字节数组、数据大小，以及起始位置。offset 参数用于指定接收的数据在放入buf缓冲数组时是从offset处开始的。

        ④DatagramPacket（byte[] buf,int offset，int length，InetAddress addr,int port）

       用于发送端, 创建DatagramPacket对象时，指定了封装数据的字节数组、数据大小、数据包的目标IP地址（addr）以及端口号（port）。offset 参数用于指定发送数据的偏移量为offset，即从offset位置开始发送数据。

DatagramPacket类中的常用方法
方法声明	功能描述
InetAddress  getAddress()	该方法用于返回发送端或者接收端的IP地址，如果发送端的DatagramPacket对象，就返回接收端的IP地址，反之，就返回发送端的IP地址
int getPort()	该方法用于返回发送端或者接收端的端口号，如果发送端的DatagramPacket对象，就返回接收端的端口号，反之，就返回发送端的端口号
byte[] getData()	该方法用于返回将要接收或者将要发送的数据，如果是发送端的DatagramPacket对象，就返回将要发送的数据，反之，就返回接收到的数据
int getLength()	该方法用于返回将要接收或者将要发送数据的长度，如果是发送端的DatagramPacket对象，就返回将要发送的数据长度，反之，就返回接收到数据的长度

      2、DatagramSocket

      DatagramSocket类似与码头，实例对象就可以发送和接收DatagramPacket数据包，在创建发送端和接收端的DatagramSocket对象时，使用的构造方法有所不同。

      DatagramSocket构造方法：

       ①DatagramSocket（）

       用于创建发送端的DatagramSocket对象时，在创建对象时，并没有指定端口号，此时，系统会分配一个没有被其他网络程序使用的端口号。

       ②DatagramSocket（int port）

       该方法即可用于创建接收端的DatagramSocket对象，又可以创建发送端的DatagramSocket对象，在创建接收端的DatagramSocket对象时，必须要指定一个端口号，这样就可以监听指定的端口。

       ③DatagramSocket（int port,InetAddress addr）

       使用该构造方法在DatagramSocket时，不仅指定端口号，还指定了相关的IP地址，这种情况适用于计算上有多块网卡的情况。

DatagramSocket类中的常用方法
方法声明	功能描述
void receive(DatagramPacket p)	该方法用于将接收到的数据填充到DatagramPacket数据包中，在接收到数据之前会一直处于阻塞状态，只有当接收到数据包时，该方法才会返回。
void  send(DatagramPacket p)	该方法用于发送DatagramPacket数据包，发送的数据包中包含将要发送的数据、数据的长度、远程主机的IP地址和端口号
void close()	关闭当前的Socket,通知驱动程序释放为这个Socket保留的资源。

     3、UDP 网络程序

     在通信时只有接收端程序先运行，才能避免因发送端发送的数据无法接收，而造成数据丢失。示例：

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 
 4 //接收端程序
 5 public class Example2 {
 6     public static void main(String[] args) throws Exception{
 7         //创建一个长度为1024的字节数组，用于接收数据
 8         byte [] buf = new byte[1024];
 9         //定义一个DatagramSocket对象，监听的端口为8954
10         DatagramSocket ds = new DatagramSocket(8954);
11         //定义一个DatagramPacket对象，用于接收数据
12         DatagramPacket dp = new DatagramPacket(buf,1024);
13         System.out.println("等待接收数据");
14         ds.receive(dp);          //等待接收数据，如果没有数据则会阻塞
15         //调用DatagramPacket的方法获得接收的消息，包括内容、长度、IP地址和端口号
16         String str = new String(dp.getData(),0,dp.getLength())
17                 +"from"+dp.getAddress().getHostAddress()+":"+dp.getPort();
18         System.out.println(str); //打印收到的信息
19         ds.close();              //释放资源
20     }
21 }
22 
23 
24 import java.net.DatagramPacket;
25 import java.net.DatagramSocket;
26 import java.net.InetAddress;
27 
28 //发送端程序
29 public class Example3 {
30     public static void main(String[] args) throws Exception {
31         //创建一个DatagramSocket对象
32         DatagramSocket ds = new DatagramSocket(3000);
33         String str = "Hello World!";     //要发送的数据
34         /*
35          * 创建一个要发送的数据包，包括发送数据，数据长度，接收端IP地址以及端口号
36          */
37         DatagramPacket dp = new DatagramPacket(str.getBytes(),str.length(),
38                 InetAddress.getByName("localhost"),8954);
39         System.out.println("发送消息");
40         ds.send(dp);                     //发送数据
41         ds.close();                      //释放资源
42     }

运行结果

发送消息

等待接收数据
Hello World!from127.0.0.1:3000

解析：发送货物（数据）前，确定到货码头是否能接收。

         创建空间（数据容器）接收货物（数据），创建码头【DatagramSocket(8954)】并实时监听发货码头发货通道（端口），创建集装箱并将空间加入用于接收货物，一直等待接收货物，接收码头将货物填充到集装箱中，获取到货物信息（数据等信息）。

         发送货物需要建一个码头【DatagramSocket(3000)】，码头可指定发送通道即端口（也可以不指定发送通道），将要发送货物（数据）装进集装箱（DatagramPacket

）中，并指定发送到的码头名字（IP地址或主机名）及接收通道（端口），通过码头把集装箱发出去[send()]，腾出空间（close）。

三、TCP通信

      1、ServerSocket

       在开发TCP程序时，首先需要创建服务器端程序，其构造方法如下：

      ①ServerSocket（）

      使用该构造方法在创建ServerSocket对象时并没有绑定端口号，不能直接使用，还需要继续调用bind(SocketAddress endpoint)方法将其绑定到指定的端口上，才能正常使用。

      ②ServerSocket（int port）【最常用】

      使用用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上。

      ③ServerSocket（int port，int backlog）

      backlog 参数用于指定在服务器忙时，可以与之保持连接请求的等待客户数量，如果没有指定这个参数默认为50 。

      ④ServerSocket（int port，int backlog，InetAddress bindAddr）

      指定了相关的IP地址，适用于计算机上有多块网卡和多个IP的情况。

     

ServerSocket类中的常用方法
方法声明	功能描述
Socket accept()	该方法用于等待客户端的连接，在客户端连接之前一直处于阻塞状态，如果有客户端连接就会返回一个与之对应的Socket对象
InetAddress getInetAddress()	该方法用于返回一个InetAddress对象，该对象封装了ServerSocket绑定的IP地址
boolean isClosed()	该方法用于判断ServerSocket对象是否为关闭状态，如果是关闭状态则返回true，反之则返回false
void bind(SocketAddress endpoint)	该方法用于判断ServerSocket对象绑定到指定的IP地址和端口号，其中参数endpoint封装了IP地址和端口号。

      

     2、Socket

         Socket类常用构造方法：

         ①Socket（）

        使用该构造方法在创建Socket对象时，并没指定IP地址和端口号，创建对象后还需调用connect（SocketAddress endpoint）方法，才能完成与指定服务器的连接，参数endpoint封装了IP地址和端口号。

         ②Socket（String host,int port）

         使用该构造方法在创建Socket对象时，根据参数去连接在指定IP地址和端口上运行的服务器程序，其中参数host接收的一个字符类型的IP地址。

         ③Socket（InetAddress addres,int port）

         与第二个构造方法类似，参数address用于接收一个InetAddress类型的对象，该对象用于封装一个IP地址。

 

Socket类中的常用方法
方法声明	功能描述
int getPort()	该方法返回一个int类型对象，该对象时Socket对象与服务器端连接的端口号
InetAddress getLocalAddress()	该方法用于获取Socket对象绑定的本地IP地址，并将IP地址封装成InetAddress类型的对象返回
void close()	该方法用于关闭Socket连接，结束本次通信。在关闭Socket之前，应将于Socket相关的所有的输入与输出流全部关闭，这是因为一个良好的程序应该在执行完毕时释放所有的资源
IputStream getInputStream()	该方法返回一个InputStream类型的输入流对象，如果该对象是由服务器端的Socket返回，就用于读取客户端发送的数据，反之，用于读取服务器端发送的数据
OutputStream getOutputStream()	该方法返回一个OutputStream类型的输出流对象，如果该对象是由服务器端的Socket返回，就用于向客户端发送数据，反之，用于向服务器端发送数据

 

     3、简单的TCP网络程序

 1 import java.io.OutputStream;
 2 import java.net.ServerSocket;
 3 import java.net.Socket;
 4 
 5 public class Example4 {
 6     public static void main(String[] args) throws Exception {
 7         new TCPServer().listen();      //创建TCPServer对象，并调用listen（）方法
 8     }
 9 }
10 //TCP服务器端
11 class TCPServer{
12     private static final int PORT= 7788;//定义一个端口号
13 
14     public void listen() throws Exception{ //定义一个listen（）方法，抛出一个异常
15         ServerSocket serverSocket = new ServerSocket(PORT);//创建ServerSocket对象
16         Socket client=serverSocket.accept();  //调用ServerSocket的accept（）方法接收数据
17         OutputStream os = client.getOutputStream(); //获取客户端的输出流
18         System.out.println("开始与客户端交换数据");
19         os.write(("Java欢迎你！").getBytes());
20         Thread.sleep(5000);      //模拟执行其他功能占用的时间
21         System.out.println("结束与客户端交互数据");
22         os.close();
23         client.close();
24     }
25 }

 1 import java.io.InputStream;
 2 import java.net.InetAddress;
 3 import java.net.Socket;
 4 
 5 public class Example5 {
 6     public static void main(String[] args) throws Exception{
 7         new TCPClient().connect();//创建TCPClient对象，并调用connect（）方法
 8     }
 9 }
10 //TCP客户端
11 class TCPClient{
12     private static final int PORT=7788;//服务端的端口号
13     public void connect() throws Exception{
14         //创建一个Socket并连接到给出地址和端口号的计算机
15         Socket client = new Socket(InetAddress.getLocalHost(),PORT);
16         InputStream is = client.getInputStream(); //得到接收数据的流
17         byte[] buf = new byte[1024];  //定义1024个字节数组的缓冲区
18         int len=is.read(buf);    //将数据读取到缓冲区中
19         System.out.println(new String(buf,0,len));  //将缓冲区中的数据输出
20         client.close();       //关闭Socket对象，释放资源
21     }
22 }

Example4 运行结果：
开始与客户端交换数据
结束与客户端交互数据

Example5 运行结果：
Java欢迎你！

  4、TCP案例——文件上传

      实现图片上传到服务器的功能。

 服务端程序：

 1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.InputStream;
 4 import java.io.OutputStream;
 5 import java.net.ServerSocket;
 6 import java.net.Socket;
 7 
 8 public class Example7 {
 9     public static void main(String[] args) throws Exception{
10         ServerSocket serverSocket = new ServerSocket(10001);//创建ServerSocket对象
11         while (true){
12             //调用accept（）方法接收客户端请求，得到Socket对象
13             Socket s = serverSocket.accept();
14             //每当和客户端建立Socket连接后，单独开启一个线程处理和客户端的交互
15             new Thread(new ServerThread(s)).start();
16         }
17     }
18 }
19 class ServerThread implements Runnable{
20     private Socket socket ;     //持有一个Socket类型的属性
21     public ServerThread(Socket socket){   //构造方法中吧Socket对象作为实参传入
22         this.socket=socket;
23     }
24 
25     @Override
26     public void run() {
27         String ip = socket.getInetAddress().getHostAddress(); //获取客户端的IP地址
28         int count =1;        //上传图片个数
29         try{
30             InputStream in = socket.getInputStream();
31             //创建上传图片目录的File对象
32             File parentFile =new File("/Users/adims/Downloads/upload/");
33             if (!parentFile.exists()){  //如果不存在，就创建这个目录
34                 parentFile.mkdir();
35             }
36             //把客户端的IP地址作为上传出文件的文件名
37             File file = new File(parentFile,ip+"("+count+").jpeg");
38             while (file.exists()){
39                 //如果文件名存在，则把count++
40                 file=new File(parentFile,ip+"("+(count++)+").jpeg");
41             }
42             //创建FileOutputStream对象
43             FileOutputStream fos = new FileOutputStream(file);
44             byte[] buf=new byte[1024];  //定义一个字节数组
45             int len=0;     //定义一个int类型的变量len，初始值为0
46             while ((len=in.read(buf))!=-1){   //循环读取数据
47                 fos.write(buf,0,len);
48             }
49             OutputStream out = socket.getOutputStream();  //获取服务端的输出流
50             out.write(("上传成功").getBytes());    //上传成功后向客户端写出"上传成功"
51             fos.close();                          //关闭输出流对象
52             socket.close();                       //关闭Socket对象
53         }catch (Exception e){
54               throw new RuntimeException(e);
55         }
56     }
57 }

客户端程序：

 1 import java.io.FileInputStream;
 2 import java.io.InputStream;
 3 import java.io.OutputStream;
 4 import java.net.InetAddress;
 5 import java.net.Socket;
 6 
 7 public class Example8 {
 8     public static void main(String[] args) throws Exception{
 9         Socket socket= new Socket(InetAddress.getLocalHost(),10001);  //创建客户端Socket对象，指定IP地址和端口号
10         OutputStream out= socket.getOutputStream();  //获取Socket的输出流对象
11         //创建FileInputStream对象
12         FileInputStream fis = new FileInputStream("/Users/adims/Downloads/WechatIMG1.jpeg");
13         byte[] buf =new byte[1024]; //定义一个字节数组
14         int len;       //定义一个int类型的变量len
15         while ((len=fis.read(buf))!=-1){    //循环读取数据
16             out.write(buf,0,len);
17         }
18         socket.shutdownOutput();      //关闭客户端输出流
19         InputStream in = socket.getInputStream();   //获取Socket的输入流对象
20         byte[] bufMsg = new byte[1024];    //定义一个字节数组
21         int num =in.read(bufMsg);          //接收服务端的信息
22         String Msg = new String(bufMsg,0,num);
23         System.out.println(Msg);
24         fis.close();                   //关闭输入流对象
25         socket.close();                //关闭Socket对象
26     }
27 }

需注意：shutdownOutput()方法非常重要，因为服务器端程序在while循环中读取客户端发送的数据，当读取到-1时才会结束循环，如果客户端不调用shutdownOutput（）方法关闭输出流，服务器端就不会读到-1，而会一直执行while循环，同时客户端服务器端的read（byte[]）方法也是一个阻塞方法，这样客户端与服务器端进入一个“死锁”状态。