网络编程最主要的工作就是在发送端把信息通过规定好的协议进行组装包，在接收端按照规定好的协议把包进行解析，从而提取出对应的信息，达到通信的目的。 —— 百度百科
Table of Contents
先来一张Java网络编程基础知识体系架构：
网络通信协议
现在来简单回忆一下，计算机网络的有关基础原理：
网络通信协议有很多种，目前应用最广泛的是TCP/IP协议(Transmission Control Protocal/Internet Protoal传输控制协议/英特网互联协议)，它是一个包括TCP协议和IP协议，UDP（User Datagram Protocol）协议和其它一些协议的协议组，在学习具体协议之前首先了解一下TCP/IP协议组的层次结构。
在进行数据传输时，要求发送的数据与收到的数据完全一样，这时，就需要在原有的数据上添加很多信息，以保证数据在传输过程中数据格式完全一致。TCP/IP协议的层次结构比较简单，共分为四层，如图所示。
TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层，每层分别负责不同的通信功能，接下来针对这四层进行详细地讲解。
- 链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。
- 网络层：网络层是整个TCP/IP协议的核心，它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。
- 传输层：主要使网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议。
- 应用层：主要负责应用程序的协议，例如HTTP协议、FTP协议等。
要想使网络中的计算机能够进行通信，必须为每台计算机指定一个标识号，通过这个标识号来指定接受数据的计算机或者发送数据的计算机。在TCP/IP协议中，这个标识号就是IP地址，它可以唯一标识一台计算机，目前，IP地址广泛使用的版本是IPv4，它是由4个字节大小的二进制数来表示。
由于二进制形式表示的IP地址非常不便记忆和处理，因此通常会将IP地址写成十进制的形式，每个字节用一个十进制数字(0-255)表示，数字间用符号“.”分开，如 “192.168.1.100”。
通过IP地址可以连接到指定计算机，但如果想访问目标计算机中的某个应用程序，还需要指定端口号。在计算机中，不同的应用程序是通过端口号区分的。端口号是用两个字节（16位的二进制数）表示的，它的取值范围是0~65535，其中，0~1023之间的端口号用于一些知名的网络服务和应用，用户的普通应用程序需要使用1024以上的端口号，从而避免端口号被另外一个应用或服务所占用。
网络通信中的IP和端口：
IP管理类(InetAddress类)
功能：管理IP地址与主机名(域名)之间的转换，以及IP地址本身格式的转换（把32二进制转换为4个十进制数）。
静态方法：
- static InetAddress[] getAllByName(String host) 根据主机或者域名的名称，根据系统上配置的名称服务返回其IP地址数组。
- static InetAddress getByAddress(byte[] addr) 给定原始IP地址返回 InetAddress对象。
- static InetAddress getByAddress(String host, byte[] addr) 根据提供的主机名和IP地址创建InetAddress。
- static InetAddress getByName(String host) 根据主机名、域名称确定主机的IP地址。
IP管理类的方法使用
import java.net.InetAddress;
import java.net.UnknownHostException;
public class Main {
public static void main(String[] args) throws UnknownHostException {
ipAddress();
}
public static void ipAddress() throws UnknownHostException {
//getLocalHost 获取本机的IP地址对象
InetAddress address = InetAddress.getLocalHost();
System.out.println("IP地址："+address.getHostAddress());
System.out.println("主机名："+address.getHostName());
//获取别人机器的IP地址对象。
//可以根据一个IP地址的字符串形式或者是一个主机名生成一个IP地址对象。
InetAddress address1 = InetAddress.getByName("KYLE");
System.out.println("IP地址："+address1.getHostAddress());
System.out.println("主机名："+address1.getHostName());
InetAddress[] arr = InetAddress.getAllByName("www.baidu.com");//域名
for(InetAddress s:arr) { //输出该域名所表示的所有IP地址
System.out.println(s);
}
}
public static void fun() throws UnknownHostException {
//根据主机名或域名获取iP地址
InetAddress ip01 = InetAddress.getByName("KYLE"); //根据主机名获取IP地址
InetAddress ip02 = InetAddress.getByName("hackyle.net"); //根据域名获取主机的IP地址
System.out.println(ip01); //KYLE/192.168.1.50
System.out.println(ip02); //hackyle.net/116.62.148.72
//将IP地址转换为字节数组
byte[] byteIP = ip02.getAddress();
//根据IP地址的字节形式和返回其IP
InetAddress ip03 = InetAddress.getByAddress(byteIP);
System.out.println(ip03); //输出：116.62.148.72
}
}
基于UDP协议编程
理解UDP：
- UDP（User Datagram Protocol）是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。
- 简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
- 由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。
- 但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。
特性：
- 将数据封装为数据包，面向无连接。
- 每个数据包大小限制在64K中
- 因为无连接，所以不可靠
- 因为不需要建立连接，所以速度快
- UDP通讯是不分服务端与客户端的，只分发送端与接收端。
UDP协议下的Socket相关类：
- java.net.DatagramPacket类：将数据包装起来
- java.net.DatagramSocket类：将数据包发送和接收
DatagramSocket类
构造方法：
DatagramSocket(int port) ：数据报套接字并将其绑定到本地主机上的指定端口。
- 该构造方法既可用于创建接收端的DatagramSocket对象，又可以创建发送端的DatagramSocket对象；
- 在创建接收端的DatagramSocket对象时，必须要指定一个端口号，这样就可以监听指定的端口。
DatagramSocket() ：据报套接字并将其绑定到本地主机上任何可用的端口。
- 该构造方法用于创建发送端的DatagramSocket对象；
- 在创建DatagramSocket对象时，并没有指定端口号，此时，系统会分配一个没有被其它网络程序所使用的端口号。
方法：
- void receive(DatagramPacket p)：从此套接字接收数据报包；
- void send(DatagramPacket p)：从此套接字发送数据报包
DatagramPacket类
构造方法：
DatagramPacket(byte[] buf, int length) ：DatagramPacket，用来接收长度为 length 的数据包。
- 使用该构造方法在创建DatagramPacket对象时，指定了封装数据的字节数组和数据的大小，没有指定IP地址和端口号。
- 很明显，这样的对象只能用于接收端，不能用于发送端。
- 因为发送端一定要明确指出数据的目的地(ip地址和端口号)，而接收端不需要明确知道数据的来源，只需要接收到数据即可。
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)：构造数据报包，用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。
- 使用该构造方法在创建DatagramPacket对象时，不仅指定了封装数据的字节数组和数据的大小，还指定了数据包的目标IP地址（addr）和端口号（port）。
- 该对象通常用于发送端。
- 因为在发送数据时必须指定接收端的IP地址和端口号，就好像发送货物的集装箱上面必须标明接收人的地址一样。
实例-UDP发送端
发送端的使用步骤：
1. 建立UDP的服务：启动插座（DatagramSocket）
2. 准备数据，把数据封装到数据包中发送。 发送端的数据包要带上ip地址与端口号：建立包（DatagramPacket）
3. 调用UDP的服务，发送数据：从插座中发送；
4. 关闭资源：关闭插座；
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.net.DatagramPacket;
import java.io.IOException;
//发送端
public class Sender {
private static String ip = "116.62.148.72";
private static int port = 9190;
public static void main(String[] args) {
InetAddress iaddress = null;
DatagramSocket ds = null;
System.out.println("Start sending...");
try {
iaddress = InetAddress.getByName(ip);
ds = new DatagramSocket();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (SocketException e) {
e.printStackTrace();
}
String data = "嗨，接收端。";
try {
DatagramPacket dp = new DatagramPacket(data.getBytes(),data.getBytes().length,iaddress,port);
ds.send(dp);
} catch(IOException e) {
e.printStackTrace();
} finally {
ds.close();
System.out.println("Send Finished...");
}
}
}
实例-UDP接收端
接收端的使用步骤
- 建立udp的服务：启用插座（DatagramSocket）；
- 准备空 的数据 包接收数据：（byte[]；DatagramPacket）；
- 调用udp的服务接收数据：插座的对象receive存放于DatagramPacket对象的包中；
- 关闭资源：关闭插座；
import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.io.IOException;
public class Receiver {
public static void main(String[] args) {
DatagramSocket ds = null;
DatagramPacket dp = null;
System.out.println("Start receiving....");
byte[] buf = new byte[1024];
try {
ds = new DatagramSocket(9190);
dp = new DatagramPacket(buf,buf.length);
ds.receive(dp);
System.out.println(new String(buf,0,dp.getLength()));
} catch (IOException e) {
e.printStackTrace();
} finally {
ds.close();
System.out.println("Receive Finished....");
}
}
}
基于TCP协议编程
理解TCP：
- TCP协议是面向连接的通信协议，即在传输数据前先在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
- 在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。
- 第一次握手，客户端向服务器端发出连接请求，等待服务器确认；
- 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求；
- 第三次握手，客户端再次向服务器端发送确认信息，确认连接。
- 由于TCP协议的面向连接特性，它可以保证传输数据的安全性，所以是一个被广泛采用的协议，例如在下载文件时，如果数据接收不完整，将会导致文件数据丢失而不能被打开，因此，下载文件时必须采用TCP协议。
理解TCP3次握手建立连接：
- 发送方：你听得到吗（SYN）？
- 接收方：我听得到（ACK），你能听得到我吗（SYN）？
- 发送方：我听得到（ACK）。
- 此时双方都知道彼此具备收发数据的能力！
TCP通讯协议特点：
- 是基于IO流进行数据 的传输，面向连接（双方都确认存活才建立连接）。
- 进行数据传输的时候是没有大小限制的。
- 是面向连接，通过三次握手的机制保证数据的完整性。是可靠协议。
- 是面向连接的，所以速度慢。
- 是区分客户端与服务端的。
Socket类
功能：工作在客户端。专用于客户端去连接服务端。
构造方法：
- Socket(InetAddress address, int port)：根据参数去连接在指定地址和端口上运行的服务器程序，参数address用于接收一个InetAddress类型的对象，该对象用于封装一个IP地址。
- Socket(String host, int port)：根据参数去连接在指定地址和端口上运行的服务器程序，其中参数host接收的是一个字符串类型的IP地址。
方法：
- int getPort()：该方法返回一个int类型对象，该对象是Socket对象与服务器端连接的端口号
- InetAddress getLocalAddress()：该方法用于获取Socket对象绑定的本地IP地址，并将IP地址封装成InetAddress类型的对象返回
- void close()：该方法用于关闭Socket连接，结束本次通信。在关闭socket之前，应将与socket相关的所有的输入/输出流全部关闭，这是因为一个良好的程序应该在执行完毕时释放所有的资源
- InputStream getInputStream()：该方法返回一个InputStream类型的输入流对象，如果该对象是由服务器端的Socket返回，就用于读取客户端发送的数据，反之，用于读取服务器端发送的数据
- OutputStream getOutputStream()：该方法返回一个OutputStream类型的输出流对象，如果该对象是由服务器端的Socket返回，就用于向客户端发送数据，反之，用于向服务器端发送数据
ServerSocket类
功能：工作在服务器。专门用于与客户端之间建立连接，然后互相通信。
核心方法：
- 创建一个监听端口的服务器套接字：ServerSocket(int port);
- 等待连接，直道有客户端连接为止，连城成功后返回一个Socket对象：accept();
- 关闭连接：void close();
实例-TCP服务端
ServerSocket的使用 步骤
1. 建立tcp服务端 的服务：启用插座（ServerSocket）
2. 接受客户端的连接产生一个Socket：建立接受从插座来的数据接口Socket；
3. 获取对应的流对象读取或者写出数据：以字节流方式读取数据；
4. 关闭资源：关闭插座
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.io.InputStream;
import java.io.OutputStream;
public class TcpServer {
public static void main(String[] args) {
tcp_server();
}
public static void tcp_server() {
ServerSocket ss = null;
Socket so = null;
InputStream inputStream = null; //从客户端接收
OutputStream outputStream = null; //从服务器发送
//创建连接
try {
System.out.println("服务器启动成功！");
ss = new ServerSocket(9595); //建立Tcp的服务端,并且监听一个端口
so = ss.accept();
} catch(IOException e) {
e.printStackTrace();
}
while(true) {
System.out.println("作为服务器，你要发送（1），还是接收（2），或者是关闭（3）？");
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
if(x==1) {
sendToClient(so,outputStream);
} else if(x==2) {
recevice(so,inputStream);
} else {
try {
ss.close();
break;
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void recevice(Socket so, InputStream inputStream) {
/*** 接收客户端 ***/
byte[] buf = new byte[1024];
int length = 0;
try {
inputStream = so.getInputStream();
length = inputStream.read(buf);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("服务端接收到的数据：" + new String(buf,0,length));
}
public static void sendToClient(Socket so, OutputStream outputStream) {
/*** 发送：向客户端 ***/
String data = "客户端你好！我是服务器";
try {
outputStream = so.getOutputStream();
outputStream.write(data.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("数据从服务器发送到客户端成功！");
}
}
实例-TCP客户端
TCP的客户端使用步骤：
1. 建立TCP的客户端服务：启用插座；
2. 获取到对应的流对象：建立输出通道，即输出到服务端；
3. 写出或读取数据：输出；
4. 关闭资源：关闭插座；
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
public class TcpClient {
public static void main(String[] args) {
tcp_client();
}
public static void tcp_client() {
Socket so = null;
String ip = "127.0.0.1";
int port = 9595;
InputStream inputStream = null;
OutputStream outputStream = null;
try {
so = new Socket(ip,port);
} catch (IOException e) {
e.printStackTrace();
}
while(true) {
System.out.println("作为客户端，你要发送（1），还是接收（2），或者是关闭（3）？");
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
if(x==1) {
sendToServer(so,outputStream);
} else if (x==2){
recevice(so,inputStream);
} else {
try {
so.close();
break;
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void recevice(Socket so, InputStream inputStream) {
/** 从服务器接收 **/
byte[] buf = new byte[1024];
int length = 0;
try {
inputStream = so.getInputStream();
length = inputStream.read(buf);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("客户端接收到的数据：" + new String(buf,0,length));
}
public static void sendToServer(Socket so, OutputStream outputStream) {
/** 向服务器发送 **/
String data = "服务器你好！我是客户端";
try {
outputStream = so.getOutputStream();
outputStream.write(data.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("数据从客户端发送到服务器成功！");
}
}
实现结果：
TCP-文件上传
实现展示：
客户端
- Socket套接字连接服务器
- 通过Socket获取字节输出流，写图片
- 使用自己的流对象，读取图片数据源：FileInputStream
- 读取图片，使用字节输出流，将图片写到服务器
- 采用字节数组进行缓冲
- 通过Socket套接字获取字节输入流
- 读取服务器发回来的上传成功
- 关闭资源
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class TcpPictureUploadClient {
public static void main(String[] args) throws IOException{
Socket socket = new Socket("127.0.0.1", 8000);
//获取字节输出流,图片写到服务器
OutputStream out = socket.getOutputStream();
//创建字节输入流,读取本机上的数据源图片
FileInputStream fis = new FileInputStream("c:\\users\\kyle\\desktop\\a.jpg");
//开始读写字节数组
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = fis.read(bytes))!=-1){
out.write(bytes, 0, len);
}
//给服务器写终止序列
socket.shutdownOutput();
//获取字节输入流,读取服务器的上传成功
InputStream in = socket.getInputStream();
len = in.read(bytes);
System.out.println(new String(bytes,0,len));
fis.close();
socket.close();
}
}
服务器
- ServerSocket套接字对象,监听端口8000
- 方法accept()获取客户端的连接对象
- 客户端连接对象获取字节输入流,读取客户端发送图片
- 创建File对象,绑定上传文件夹，判断文件夹存在, 不存,在创建文件夹
- 创建字节输出流,数据目的File对象所在文件夹
- 字节流读取图片,字节流将图片写入到目的文件夹中
- 将上传成功会写客户端
- 关闭资源
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
public class TcpPictureUploadServer {
public static void main(String[] args) throws IOException{
ServerSocket server = new ServerSocket(8000);
Socket socket = server.accept();
//通过客户端连接对象,获取字节输入流,读取客户端图片
InputStream in = socket.getInputStream();
//将目的文件夹封装到File对象
File upload = new File("c:\\users\\kyle\\desktop\\up");
if(!upload.exists()) {
upload.mkdirs();
}
//防止文件同名被覆盖,从新定义文件名字
// 规则: 域名+毫秒值+6位随机数
String filename = "itcast" + System.currentTimeMillis() + new Random().nextInt(999999) + ".jpg";
// 创建字节输出流,将图片写入到目的文件夹中
FileOutputStream fos = new FileOutputStream(upload + File.separator + filename);
//读写字节数组
byte[] bytes = new byte[1024];
int len = 0;
while ((len = in.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
// 通过客户端连接对象获取字节输出流
// 上传成功写回客户端
socket.getOutputStream().write("上传成功".getBytes());
fos.close();
socket.close();
server.close();
}
}
91
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
