2020重新出发，JAVA基础，网络编程

Java网络编程

随着互联网的发展趋势，大量的两络应用程序涌现出来，使得网络编程技术得到了很好的发展。网络编程就是在两个或者两个以上的设备（例如计算机）之间传输数据，编程人员所做的事情就是把数据发送到指定位置或者接收到指定的数据，这就是狭义的网络编程。

Java 语言中设计了一些 API 来专门实现数据发送和接收等功能，只需要编程人员调用即可。要进行网络编程就必须对网络协议、端口和套接字等知识有所了解。

Java网络编程基础知识

网络编程的目的就是直接或间接地通过网络协议与其他计算机进行通信。在 Java 语言中包含网络编程所需要的各种类，编程人员只需要创建这些类的对象，调用相应的方法，就可以进行网络应用程序的编写。

要进行网络程序的编写，编程人员需要对网络传输协议、端口和套接字等方面的知识有一定的了解。

网络分类

了解网络编程之前首先带领读者对计算机网络进行一些简单的了解。计算机网络是指将有独立功能的多台计算机，通过通信设备线路连接起来，在网络软件的支持下，实现彼此之间资源共享和数据通信的整个系统。

按照地理范围主要将网络分为局域网、城域网、广域网和因特网。

局域网（LocalArea Network）简称 LAN，是一种在小范围内实现的计算机网络，一般在一个建筑物内或者一个工厂、一个事业单位内部独有，范围较小。城域网（Metropolitan Area Network）简称为 MAN，一般是一个城市内部组建的计算机信息网络，提供全市的信息服务。广域网（Wide Area Network）简称为 WAN，它的范围很广，可以分布在一个省、一个国家或者几个国家。因特网（Internet）则是由无数的 LAN 和 WAN 组成的。

网络编程模型

在网络通信中主要有两种模式的通信方式：一种是客户机/服务器（Client/Server）模式，简称为 C/S 模式；另一种是浏览器/服务器（Browser/Server）模式，简称 B/S 模式。下面主要针对这两种模式进行介绍。

Client/Server 模式

图是客户机、服务器以及网络三者之间的关系图，使用这种模式的程序很多，例如网络游戏，需要在本机上安装一个客户端，服务器运行在游戏开发公司的机房。

使用 C/S 模式的程序，在开发时需要分别针对客户端和服务器端进行专门开发。这种开发模式的优势在于由于客户端是专门开发的，表现力会更强。缺点就是通用性差，也就是说一种程序的客户端只能和对应的服务器端进行通信，不能和其他的服务器端进行通信，在实际维护中，也需要维护专门的客户端和服务器端，维护的压力较大。

Browser/Server 模式

对于很多程序，运行时不需要专门的客户端，而是使用通用的客户端，例如使用浏览器。用户使用浏览器作为客户端的这种模式叫作浏览器/服务器模式。使用这种模式开发程序时只需开发服务器端即可，开发的压力较小，不需要维护客户端。但是对浏览器的限制比较大，表现力不强。

网络协议

网络协议是网络上所有设备（网络服务器、计算机及交换机、路由器、防火墙等）之间通信规则的集合，它规定了通信时信息必须采用的格式和这些格式的意义。目前的网络协议有很多种，在这里简单介绍几种常用的网络协议。

IP 协议

IP 是英文 Internet Protocol（网络之间互联的协议）的缩写，中文简称为网协，也就是为计算机网络相互连接进行通信而设计的协议。在 Internet 中它是能使连接到网上的所有计算机网络实现相互通信的一套规则，规定了计算机在 Internet 上进行通信时应当遵守的规则。任何厂家生产的计算机系统只有遵守 IP 协议才可以与 Internet 互联。

Internet 网络中采用的协议是 TCP/IP 协议，其全称是 Transmission Control Protocol/Internet Protocol。Internet 依靠 TCP/IP 协议在全球范围内实现不同硬件结构、不同操作系统、不同网络的互联。

对网络编程来说，主要是计算机和计算机之间的通信，首要的问题就是如何找到网络上数以亿计的计算机。为了解决这个问题，网络中的每个设备都会有唯一的数字标识，也就是 IP 地址。

在计算机网络中，现在命名 IP 地址的规定是 IPv4 协议，该协议规定每个 IP 地址由 4 个 0~255 的数字组成。每台接入网络的计算机都拥有一个唯一的 IP 地址，这个地址可能是固定的，也可能是动态的。

目前 IETF（Internet Engineering Task Force，互联网工程任务组）设计的用于替代现行版本 IP 协议（IPv4）的下一代协议 IPv6，釆用 6 字节来表示 IP 地址，但目前还没有开始使用。

TCP/IP 定义了电子设备如何连入 Internet 以及数据如何在它们之间传输的标准。协议采用 4 层的层级结构，分别是应用层、传输层、网络层和网络接口层。每一层都呼叫它的下一层所提供的网络来完成自己的需求。

TCP 负责发现传输的问题，一有问题就发出信号要求重新传输，直到所有数据安全正确地传输到目的地，而 IP 是给 Internet 的每一台电脑规定一个地址。图 2 是 TCP/IP 层次结构图。

如果服务器接收到客户端的请求，就会创建一个套接字，客户端使用该套接字与服务器通信，但此时客户端的套接字并没有绑定到与服务器连接的端口号上。

Java InetAddress类及其常用方法

Internet 上的主机有两种方式表示地址，分别为域名和 IP 地址。http://java.net 包中的 InetAddress 类对象包含一个 Internet 主机地址的域名和 IP 地址。

InetAddress 类提供了操作 IP 地址的各种方法。该类本身没有构造方法，而是通过调用相关静态方法获取实例。InetAddress 类中的常用方法如下表 所示。

例 编写程序练习 InetAddress 类的基本使用方法，主要步骤如下所示。

(1) 创建类。在 main() 方法中创建一个 InetAddress 对象，调用getByName() 方法并传递参数“www.qq.com”输出此对象的 IP 地址字符串和主机名代码如下。

public static void main(String[] args) { try { InetAddress ia1=InetAddress.getByName("www.qq.com"); System.out.println(ia1.getHostName()); System.out.println(ia1.getHostAddress()); } catch(UnknownHostException e) { e.printStackTrace(); } }

(2) main() 方法添加代码，创建一个 InetAddress 对象，调用 getByName() 方法并传递参数“61.135.169.105”输出此对象的 IP 地址字符串和主机名，如下所示。

try { InetAddress ia2=InetAddress.getByName("61.135.169.105"); System.out.println(ia2.getHostName()); System.out.println(ia2.getHostAddress()); } catch(UnknownHostException e) { e.printStackTrace(); }

(3) 创建一个 InetAddress 对象用于获取本地主机的信息，输出此对象的 IP 地址字符串和主机名，如下所示。

try { InetAddress ia3=InetAddress.getLocalHost(); System.out.println("主机名："+ia3.getHostName()); System.out.println("本地ip地址："+ia3.getHostAddress()); } catch(UnknownHostException e) { e.printStackTrace(); }

(4) 执行程序，运行结果如下所示。

www.qq.com 123.151.137.18 61.135.169.105 61.135.169.105 主机名：WQ-20161107KCPN 本地ip地址：192.168.0.102

注意：在上述代码中包含互联网的地址，所以运行时需要连网，否则会出现异常。

Java TCP通信：Java ServerSocket类和Socket类

TCP 网络程序是指利用 Socket 编写的通信程序。利用 TCP 协议进行通信的两个应用程序是有主次之分的，一个是服务器程序，一个是客户端程序，两者的功能和编写方法不太一样。其中 ServerSocket 类表示 Socket 服务器端，Socket 类表示 Socket 客户端，两者之间的交互过程如下：

服务器端创建一个 ServerSocket（服务器端套接字），调用 accept() 方法等待客户端来连接。客户端程序创建一个 Socket，请求与服务器建立连接。服务器接收客户的连接请求，同时创建一个新的 Socket 与客户建立连接，服务器继续等待新的请求。

ServerSocket 类

ServerSocket 类是与 Socket 类相对应的用于表示通信双方中的服务器端，用于在服务器上开一个端口，被动地等待数据（使用 accept() 方法）并建立连接进行数据交互。

服务器套接字一次可以与一个套接字连接，如果多台客户端同时提出连接请求，服务器套接字会将请求连接的客户端存入队列中，然后从中取出一个套接字与服务器新建的套接字连接起来。若请求连接大于最大容纳数，则多出的连接请求被拒绝；默认的队列大小是 50。

ServerSocket 的构造方法

ServerSocket 的构造方法如下所示。

ServerSocket()：无参构造方法。ServerSocket(int port)：创建绑定到特定端口的服务器套接字。ServerSocket(int port,int backlog)：使用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口。ServerSocket(int port,int backlog,InetAddress bindAddr)：使用指定的端口、监听 backlog 和要绑定到本地的 IP 地址创建服务器。

在上述方法的参数中 port 指的是本地 TCP 端口，backlog 指的是监听 backlog，bindAddr 指的是要将服务器绑定到的 InetAddress。

创建 ServerSocket 时可能会拋出 IOException 异常，所以要进行异常捕捉。如下所示为使用 8111 端口的 ServerSocket 实例代码。

try{ ServerSocket serverSocket=new ServerSocket(8111); }catch(IOException e){ e.printStackTrace(); }

ServerSocket 的常用方法

ServerSocket 的常用方法如下所示。

Server accept()：监听并接收到此套接字的连接。void bind(SocketAddress endpoint)：将 ServerSocket 绑定到指定地址（IP 地址和端口号）。void close()：关闭此套接字。InetAddress getInetAddress()：返回此服务器套接字的本地地址。int getLocalPort()：返回此套接字监听的端口。SocketAddress getLocalSoclcetAddress()：返回此套接字绑定的端口的地址，如果尚未绑定则返回 null。int getReceiveBufferSize()：获取此 ServerSocket 的 SO_RCVBUF 选项的值，该值是从 ServerSocket 接收的套接字的建议缓冲区大小。

调用 accept() 方法会返回一个和客户端 Socket 对象相连接的 Socket 对象，服务器端的 Socket 对象使用 getOutputStream() 方法获得的输出流将指定客户端 Socket 对象使用 getInputStream() 方法获得那个输入流。同样，服务器端的 Socket 对象使用的 getInputStream() 方法获得的输入流将指向客户端 Socket 对象使用的 getOutputStream() 方法获得的那个输出流。也就是说，当服务器向输出流写入信息时，客户端通过相应的输入流就能读取，反之同样如此，整个过程如图所示。

了解上面的基础知识后，下面使用 ServerSocket 类在本机上创建一个使用端口 8888 的服务器端套接字，实例代码如下所示。

public static void main(String[] args) { try { //在8888端口创建一个服务器端套接字 ServerSocket serverSocket=new ServerSocket(8888); System.out.println("服务器端Socket创建成功"); while(true) { System.out.println("等待客户端的连接请求"); //等待客户端的连接请求 Socket socket=serverSocket.accept(); System.out.println("成功建立与客户端的连接"); } } catch(IOException e) { e.printStackTrace(); } }

如上述代码所示，在成功建立 8888 端口的服务器端套接字之后，如果没有客户端的连接请求，则 accept() 方法为空，所以不会输出“成功建立与客户端的连接”，运行结果如下所示。

服务器端S.ocket创違成功 等待客户端的连接请求

Socket 类

Socket 类表示通信双方中的客户端，用于呼叫远端机器上的一个端口，主动向服务器端发送数据（当连接建立后也能接收数据）。

Socket 的构造方法

Socket 的构造方法如下所示。

Socket()：无参构造方法。Socket(InetAddress address,int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口。Soclcet(InetAddress address,int port,InetAddress localAddr,int localPort)：创建一个套接字并将其连接到指定远程地址上的指定远程端口。Socket(String host,int port)：创建一个流套接字并将其连接到指定主机上的指定端口。Socket(String host,int port,InetAddress localAddr,int localPort)：创建一个套接字并将其连接到指定远程地址上的指定远程端口。Socket 会通过调用 bind() 函数来绑定提供的本地地址及端口。

在上述方法的参数中，address 指的是远程地址，port 指的是远程端口，localAddr 指的是要将套接字绑定到的本地地址，localPort 指的是要将套接字绑定到的本地端口。

Socket 的常用方法

Socket 的常用方法如下所示。

void bind(SocketAddress bindpoint)：将套接字绑定到本地地址。void close()：关闭此套接字。void connect(SocketAddress endpoint)：将此套接字连接到服务器。InetAddress getInetAddress()：返回套接字的连接地址。InetAddress getLocalAddress()：获取套接字绑定的本地地址。InputStream getInputStream()：返回此套接字的输入流。OutputStream getOutputStream()：返回此套接字的输出流。SocketAddress getLocalSocketAddress()：返回此套接字绑定的端点地址，如果尚未绑定则返回 null。SocketAddress getRemoteSocketAddress()：返回此套接字的连接的端点地址，如果尚未连接则返回 null。int getLoacalPort()：返回此套接字绑定的本地端口。intgetPort()：返回此套接字连接的远程端口。

编写 TCP 程序，包括一个客户端和一个服务器端。要求服务器端等待接收客户端发送的内容，然后将接收到的内容输出到控制台并做出反馈。

(1) 创建一个类作为客户端，首先在 main() 方法中定义一个 Socket 对象、一个 OutputStream 对象和一个 InputStream 对象并完成初始化。接着定义服务器端的 IP 地址和端口号，代码如下所示。

public static void main(String[] args){ Socket socket=null; OutputStream out=null; InputStream in=null; String serverIP="127.0.0.1"; //服务器端 IP 地址 int port=5000; //服务器端端口号 }

(2) 建立与服务器端的连接并将数据发送到服务器端，代码如下所示。

socket=new Socket(serverIP,port); //建立连接 out=socket.getOutputStream(); //发送数据 out.write("我是客户端数据 ".getBytes());

(3) 从输入流中读出服务器的反馈信息并输出到控制台，代码如下所示。

byte[] b=new byte[1024]; in=socket.getInputStream(); int len=in.read(b); System.out.println(" 服务器端的反馈为："+new String(b,0,len));

(4) 关闭输入/输出流以及 Socket 对象，代码如下所示。

in.close(); out.close(); socket.close();

(5) 创建一个类作为服务器端，编写 main() 方法，创建 ServerSocket、Socket、InputStream、OutputStream 以及端口号并初始化，代码如下所示。

ServerSocket ServerSocket=null; Socket socket=null; InputStream in=null; OutputStream out=null; int port=5000;

(6) 开启服务器并接收客户端发送的数据，代码如下所示。

ServerSocket=new ServerSocket(port); //创建服务器套接字 System.out.println("服务器开启，等待连接。。。"); socket=ServerSocket.accept(); //获得连接 //接收客户端发送的内容 in=socket.getInputStream(); byte[] b=new byte[1024]; int len=in.read(b); System.out.println("客户端发送的内容为："+new String(b,0,len));

(7) 使用输出流对象将信息反馈给客户端，代码如下所示。

out=socket.getOutputStream(); out.write("我是服务器端".getBytes());

(8) 关闭输入/输出流、Socket 对象以及 ServerSocket 对象，代码如下所示。

in.close(); out.close(); ServerSocket.close(); socket.close();

(9) 运行服务器端程序代码，运行结果如下所示。

服务器开启，等待连接。。。

(10) 为了使程序的结果更加清晰，在步骤 (2) 的代码最后加入一句代码“Thread.sleep(1000);”。接着运行客户端程序代码，刚开始会出现如下所示的运行结果。

服务器开启，等待连接。。。 客户端发送的内容为：我是客户端数据

紧接着又会出现如下所示的运行结果。

客户端的反馈为：我是服务器端

客户端与服务器端的简单通信

在了解 TCP 通信中 ServerSocket 类和 Socket 类的简单应用之后，本节将编写一个案例实现客户端向服务器发送信息，服务器读取客户端发送的信息，并将读取的数据写入到数据流中。

首先来看一下客户端的代码，如下所示：

public class SocketDemo { public static void main(String[] args) { Socket socket=null; PrintWriter out=null; BufferedReader in=null; String serverIP="127.0.0.1"; //服务器端ip地址 int port=5000; //服务器端端口号 try { socket=new Socket(serverIP,port); in=new BufferedReader(new InputStreamReader(socket.getInputStream())); out=new PrintWriter(socket.getOutputStream(),true); while(true) { int number=(int)(Math.random()*10)+1; System.out.println("客户端正在发送的内容为："+number); out.println(number); Thread.sleep(2000); } } catch(IOException | InterruptedException e) { // TODO 自动生成的 catch 块 e.printStackTrace(); } } }

如上述代码所示，客户端代码主要是使用 Socket 连接 IP 为 127.0.0.1（本机）的 5000 端口。在建立连接之后将随机生成的数字使用 PrintWriter 类输出到套接字。休眠 2 秒后，再次发送随机数，如此循环。

再来看一个服务器端的代码，如下所示：

package ch16; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; public class SocketDemoServer1 { public static void main(String[] args) { ServerSocket serverSocket=null; Socket clientSocket=null; BufferedReader in=null; int port=5000; String str=null; try { serverSocket=new ServerSocket(port); //创建服务器套接字 System.out.println("服务器开启，等待连接。。。"); clientSocket=serverSocket.accept();// 获得链接 //接收客户端发送的内容 in=new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); while(true) { str=in.readLine(); System.out.println("客户端发送的内容为："+str); Thread.sleep(2000); } } catch(IOException | InterruptedException e) { // TODO 自动生成的 catch 块 e.printStackTrace(); } } }

如上述代码所示，服务器端与客户端代码类似，首先使用 ServerSocket 在 IP为127.0.0.1（本机）的 5000 端口建立套接字监听。在 accept() 方法接收到客户端的 Socket 实例之后调用 BufferedReader 类的 readLine() 方法，从套接字中读取一行作为数据，再将它输出到控制后休眠 2 秒。

要运行本案例，必须先执行服务器端程序，然后执行客户端程序。客户端每隔 2 秒向服务器发送一个数字，如下所示。

客户端正在发送的内容为：10 客户端正在发送的内容为：5 客户端正在发送的内容为：10 客户端正在发送的内容为：4 客户端正在发送的内容为：3

服务器端会将客户端发送的数据输出到控制台，如下所示。

服务器幵启，等待连接。。。客户端发送的内容为：7客户端发送的内容为：2客户端发送的内容为：10客户端发送的内容为：5客户端发送的内容为：10

......

传输对象数据

经过前面的学习，掌握了如何在服务器开始一个端口监听套接字，以及如何在客户端连接服务器，发送简单的数字。

本次案例将实现如何在客户端发送一个对象到服务器端，服务器如何解析对象中的数据。

第一步是创建用于保存数据的类。这里使用的 User 类是一个普通的类，包含 name 和 password 两个成员。由于需要序列化这个对象以便在网络上传输，所以需要实现 java. io.Serializable 接 P。

User 类的代码如下：

package ch16; public class User implements java.io.Serializable { private String name; private String password; public User(String name,String password) { this.name=name; this.password=password; } public String getName() { return name; } public void setName(String name) { this.name=name; } public String getPassword() { return password; } public void setPassword(String password) { this.password=password; } }

接下来编写服务器端的代码。服务器的作用是接收客户端发送过来的数据，将数据转换成 User 对象并输出成员信息，然后对 User 对象进行修改输出给客户端。

服务器端 MyServer 类的实现代码如下：

package ch16; import java.io.BufferedInputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.net.ServerSocket; import java.net.Socket; public class MyServer { public static void main(String[] args) throws IOException { // 监听10000端口 ServerSocket server=new ServerSocket(10000); while(true) { //接收客户端的连接 Socket socket=server.accept(); //调用客户端的数据处理方法 invoke(socket); } } private static void invoke(final Socket socket) throws IOException { //开启一个新线程 new Thread(new Runnable() { public void run() { //创建输入流对象 ObjectInputStream is=null; //创建输出流对象 ObjectOutputStream os=null; try { is=new ObjectInputStream(socket.getInputStream()); os=new ObjectOutputStream(socket.getOutputStream()); //读取一个对象 Object obj = is.readObject(); //将对象转换为User类型 User user=(User) obj; //在服务器端输出name成员和password成员信息 System.out.println("user: "+user.getName()+"/"+user.getPassword()); //修改当前对象的name成员数据 user.setName(user.getName()+"_new"); //修改当前对象的password对象数据 user.setPassword(user.getPassword()+"_new"); //将修改后的对象输出给客户端 os.writeObject(user); os.flush(); } catch(IOException|ClassNotFoundException ex) { ex.printStackTrace(); } finally { try { //关闭输入流 is.close(); //关闭输出流 os.close(); //关闭客户端 socket.close(); } catch(Exception ex){} } } }).start(); } }

如上述代码所示，在服务器端分别使用 ObjectInputStream 和 ObjectOutputStream 来接收和发送 socket 中的 InputStream 和OutputStream，然后转换成 User 对象。

客户端需要连接服务器，接收服务器输出的数据并解析，同时需要创建 User 对象并发给服务器。客户端 MyClient 类的实现代码如下：

package ch16; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.net.Socket; public class MyClient { public static void main(String[] args) throws Exception { //循环100次 for(int i=0;i

DatagramSocket 类

DatagramSocket 类用于表示发送和接收数据报包的套接字。数据报包套接字是包投递服务的发送或接收点。每个在数据报包套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。

DatagramSocket 类的常用构造方法如表所示。

DatagramSocket 类的常用方法如表 所示。

编写 UDP 程序，要求客户端程序可以向服务器端发送多条数据，服务器端程序可以接收客户端发送的多条数据并将其信息输出在控制台，主要步骤如下所示。

(1) 创建一个类作为客户端，在 main() 方法定义一个 DatagramSocket 对象和一个 DatagramPacket 对象并初始化为 null。然后再定义一个 InetAddress 对象和一个端口号并分别进行初始化，代码如下所示。

public static void main(String[] args) { DatagramSocket ds=null; DatagramPacket dpSend=null; InetAddress ia=InetAddress.getByName("127.0.0.1"); int port=3021; }

(2) 使用 DatagramSocket 的 send(DatagramPacket p) 方法向服务器端发送数据报包，使用循环的方式完成 5 次数据的发送，每发送 1 次数据线程休眠 1000 毫秒，数据发送完毕调用 close() 方法，关闭 DatagramSocket 对象，代码如下。

try { ds=new DatagramSocket(); for(int i=0;i

URL 的常用方法如表所示。

URLConnection 类

完成了 URL 的定义，接下来就可以获得 URL 的通信连接。在 http://java.net 包中，定义了专门的 URLConnection 类来表示与 URL 建立的通信连接，URLConnection 类的对象使用 URL 类的 openConnection() 方法获得。

URLConnection 类的主要方法如表所示。

例 使用 URL 和 URLConnection 类获取与百度首页的链接并将其页面信息输出到控制台，主要步骤如下所示。

(1) 创建一个类，编写 main() 方法，在该方法中创建一个 URL 对象，然后传入参数“http://www.baidu.com/”，输出 URL 的相关信息，代码如下所示。

package ch16; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.net.URLConnection; public class URLDemo { public static void main(String[] args) { try { URL url=new URL("http://www.baidu.com/"); System.out.println("协议：" + url.getProtocol()); System.out.println("主机：" + url.getHost()); System.out.println("端口：" + url.getPort()); InputStream in; } catch(IOException e) { //TODO 自动生成的 catch 块 e.printStackTrace(); } } }

(2) 在 main() 方法的 try 模块中继续添加代码，获得 URLConnection 对象，通过输入流读取页面源代码并将信息输出到控制台，代码如下所示。

URLConnection uc=url.openConnection(); in=uc.getInputStream(); byte[] b=new byte[1024]; int len; while((len=in.read(b))!=-1) { System.out.println(new String(b,0,len)); } in.close();

(3) 运行程序，执行结果如下所示。

协议：http 主机：www.baidu.com 端口：-1