目录
- 基础知识
- IP 和 Port
- internet（互联网）
- Java UDP 编程
- UDP（User Datagram Protocol）：``无连接无状态的数据报通讯协议``
- 实现
- Java TCP 编程
- TCP（Transmission Control Protocol）：``面向连接的通讯协议``
- 实现
- Java HTTP 编程
- HTTP（Hyper Text Transfer Protocol）：``超文本传输协议``
- 访问流程
- 实现
基础知识
- 计算机通讯：数据从一个 IP 的 port 出发（发送方），运输到另一个 IP 的 port （接收方）
IP 和 Port
-
每一个计算机设备上都有若干个 网卡，每一个网卡上有 （全球唯一）单独硬件地址，MAC地址，每个网卡/机器都有一个或多个 IP 地址
-
查看本机器（计算机）的
IP 地址：-
运行 cmd，打开 命令行工具
-
输入 ipconfig（Window 系统）
-
输入 ifconfig（Linux/Mac 系统）
-
-
保留 IP ：127.0.0.1（代表 本机） -
port：端口（逻辑上的）-
范围：0~65535
-
0~1023，OS 已经占有，80 是 Web，23 是 telnet
-
1024~65535，任和一个程序都可以使用（注意：一个端口一次只能被一个程序使用）
-
查询（端口号使用情况）：
-
运行 cmd，打开 命令行工具
-
输入 netstat -an（Window/Linux/Mac 上都是）
-
-
-
两台机器（电脑）的通讯就是在：IP+Port 上进行的
internet（互联网）
-
公网（万维网、互联网）与 内网（局域网）
-
网络是分层的，最外层是公网，底下的每层都是内网 -
而，IP 地址可以在每个层次的网重用
-
-
tracert 命令：查看当前机器和目标机器的访问中继
-
运行 cmd，打开 命令行工具
-
输入 tracert [目标机器的 IP]
-
-
TCP/IP 四层网络概念模型协议分组-
应用层：HTTP、TFTP、FTP、NFS、WAIS、SMTP、DNS、TeInet、SNMP、…
-
传输层：TCP、UDP
-
网络层：IP、ICMP、OSPF、EIGRP、IGMP
-
数据链路层：ARP、RARP、…
-
-
HTTP：超文本传输协议，是现在广为流行的 WEB 网络的基础。 -
ICMP（Internet Control Message Protocol，网络控制消息协议）是 TCP/IP 的核心协议之一，用于在 IP 网络中发送控制消息，提供通信过程中的各种问题反馈。-
ICMP 直接使用 IP 数据包传输，但 ICMP 并不被视为 IP 协议的子协议。
-
而，常见的联网状态诊断工具依赖于 ICMP 协议。
-
-
TCP：传输控制协议，是一种面向连接的，可靠的，基于字节流传输的通信协议。TCP 具有端口号的概念，用来标识同一个地址上的不同应用。 -
UDP：用户数据报协议，是一个面向数据报的传输层协议，是不可靠的。同 TCP 一样有用来标识本地应用的端口号。
Java UDP 编程
UDP（User Datagram Protocol）：无连接无状态的数据报通讯协议
-
用户数据报协议，面向数据报地无连接通讯协议（发送方发送消息后，如果接收方不在目的地，那这个消息就丢失了） -
不保证可靠的数据传输（发送方无法得知是否发送成功）
-
速度快，也可以在较差的网络下使用（好处是：简单、节省、经济）
实现
-
DatagramSocket：通讯的数据管道-
send 和 receive 方法
-
（可选，多网卡）绑定一个 IP 和 Port
-
-
DatagramPacket-
集装箱：封装数据
-
地址标签：目的地 IP + Port
-
-
注意：无主次之分，但是为了成功接受信息，
要求接收方必须早于发起方运行
/**
* 数据 发送 与 接收 测试
*/
public class Main {
public static void main(String[] args) throws IOException {
new Thread(() -> {
// 先启动 接收方
try {
UdpInternet.takeOver(3001);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
String str1 = "hello world";
new Thread(() -> {
try {
UdpInternet.send(str1, "127.0.0.1", 3001);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
/**
* UDP 网络编程
*/
public class UdpInternet {
/**
* 接受数据
*
* @param port 端口号
*/
public static void takeOver(int port) throws IOException {
// 管道
DatagramSocket socket = new DatagramSocket(port);
byte[] bytes = new byte[1024];
// 数据集装箱
DatagramPacket packet = new DatagramPacket(bytes, 1024);
System.out.println("UdpInternet.takeOver 正在接收消息！");
System.out.println("接收端的地址 = " + socket.getLocalSocketAddress());
// 接收消息，无限等待
socket.receive(packet);
System.out.println("UdpInternet.takeOver 接收到消息！");
System.out.println("数据：" + new String(packet.getData(), 0, packet.getLength()));
System.out.println("发送端的地址 = " + packet.getSocketAddress());
}
/**
* 发送数据（端口没有指定）
*
* @param str 消息
* @param ip IP
* @param port 端口号
*/
public static void send(String str, String ip, int port) throws IOException {
DatagramSocket socket = new DatagramSocket();
DatagramPacket packet = new DatagramPacket(str.getBytes(), str.length(), InetAddress.getByName(ip), port);
System.out.println("UdpInternet.send 正在发送消息！");
socket.send(packet);
System.out.println("UdpInternet.send 消息发送完成！");
}
}
Java TCP 编程
TCP（Transmission Control Protocol）：面向连接的通讯协议
-
传输控制协议 -
两台机器的
可靠无差错的数据传输 -
双向字节流传递
实现
-
第一步：服务器创建一个 ServerSocket ，等待连接
-
第二步：客户机创建一个 Socket ，连接到服务器
-
第三步：ServerSocket 接收到连接，创建一个 Socket 和客户机的 Socket 建立专线连接，后续服务器和客户机的对话（这一对 Socket）会在一个单独的线程（服务器端）上进行
-
第四步：服务端的 ServerSocket 继续等待连接（可以连接多个客户机），如果有连接请求，就执行 第二步
-
ServerSocket：服务器码头-
需要绑定 port
-
如果有多块网卡，需要再绑定一个 IP 地址
-
-
Socket：运输通道-
客户端需要绑定服务器的地址和 port
-
客户端往 Socket 输入流写入数据，送到服务端
-
客户端从 Socket 输出流获取服务器端传过来的数据
-
服务器亦要如此
-
-
Test
/**
* TCP 测试
*/
public class ServerTest {
public static void main(String[] args) throws IOException {
// 创建服务器
new Thread(() -> {
try {
TcpServer server = new TcpServer(8001);
// 单线程
// server.openInterface();
// 多线程
TcpServer.openInterface(server);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
/**
* TCP 测试
*/
public class ClientTest1 {
public static void main(String[] args) throws IOException {
// 客户端连接服务器
new Thread(() -> {
try {
TcpClient.connect("127.0.0.1", 8001);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
/**
* TCP 测试
*/
public class ClientTest2 {
public static void main(String[] args) throws IOException {
// 客户端连接服务器
new Thread(() -> {
try {
TcpClient.connect("127.0.0.1", 8001);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
- Client
/**
* TCP 客户端
*/
public class TcpClient {
/**
* 连接 服务端
*
* @param ip 主机 IP
* @param port 端口号
* @throws IOException IO异常
*/
public static void connect(String ip, int port) throws IOException {
// 创建 连接
Socket socket = new Socket(InetAddress.getByName(ip), port);
// 开启输入流、输出流
// 开启 通道的输入流，并包装为 缓存，方便 读入
// 客户端的输入流是：服务端的 回应
InputStream is = socket.getInputStream();
BufferedReader input = new BufferedReader(new InputStreamReader(is));
// 开启 通道的输出流，并包装为 数据输出流，方便传输
// 输出数据给 服务端
OutputStream os = socket.getOutputStream();
DataOutputStream output = new DataOutputStream(os);
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
while (socket.isConnected()) {
System.out.println("客户端 请输入（quit 结束）：");
// 读取键盘输入
String read = reader.readLine();
if ("quit".equalsIgnoreCase(read)) {
break;
} else {
// 发送数据给服务器（在数据后加上系统的分隔符）
output.writeBytes(read + System.getProperty("line.separator"));
// 获取 服务器返回的 信息
System.out.println("Server 说: " + input.readLine());
}
}
// 关闭 输出流
output.close();
// 关闭 输入流
input.close();
// 关闭 键盘输入
reader.close();
// 关闭连接
socket.close();
}
}
- Server
/**
* TCP 服务端
*/
public class TcpServer {
/**
* 码头
*/
private static ServerSocket serverSocket;
/**
* 构造函数
* <p>
* 创建 服务器连接 码头
*
* @param port 端口号
* @throws IOException IO异常
*/
public TcpServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
/**
* 创建供客户端连接的端口（多线程式）
*
* @throws IOException IO异常
*/
public static void openInterface(TcpServer server) {
try {
ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);
while (true) {
// 等待 客户端 请求连接
Socket accept = serverSocket.accept();
System.out.println("来了一个 Client!");
executor.submit(new Thread(new Worker(accept, server)));
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 创建供客户端连接的端口（单线程式）
*
* @throws IOException IO异常
*/
public void openInterface() throws IOException {
// 等待 客户端 请求连接
Socket accept = serverSocket.accept();
openInterface(accept);
}
/**
* 创建供客户端连接的端口（单线程式）
*
* @throws IOException IO异常
*/
public void openInterface(Socket accept) throws IOException {
// 开启 通道的输入流，并包装为 缓存，方便 读入
// 服务端的输入流是：客户端的 输出
InputStream is = accept.getInputStream();
BufferedReader input = new BufferedReader(new InputStreamReader(is));
// 开启 通道的输出流
// 输出数据给 客户端
OutputStream os = accept.getOutputStream();
DataOutputStream output = new DataOutputStream(os);
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
while (accept.isConnected()) {
// 获取 客户器发过来的 信息
// 不知道有什么方法可以检测到 客户端 连接已断开，就 先不管吧！！！！！！！！！！
// 虽然 报错
System.out.println("Client 说: " + input.readLine());
System.out.println("服务端 回话（Finish 结束）：");
// 读取键盘输入
String read = reader.readLine();
if ("Finish".equalsIgnoreCase(read)) {
break;
} else {
// 发送数据给客户端
output.writeBytes(read + System.getProperty("line.separator"));
}
}
// 关闭 输出流
output.close();
// 关闭 输入流
input.close();
// 关闭 键盘输入
reader.close();
// 关闭连接
accept.close();
}
}
/**
* 工厂
*/
class Worker implements Runnable {
Socket socket;
TcpServer server;
public Worker(Socket socket, TcpServer server) {
this.socket = socket;
this.server = server;
}
@Override
public void run() {
try {
server.openInterface(socket);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Java HTTP 编程
HTTP（Hyper Text Transfer Protocol）：超文本传输协议
-
而，HTTPS 是 HTTP 的加密安全版本。
-
HTTP 协议通过 TCP 传输，HTTP 默认使用端口 80，HTTPS 使用 443。
访问流程
-
在浏览器输入 URL 地址（如：https://www.baidu.com）
-
浏览器将连接到远程服务器上（IP+80Port）
-
请求下载一个 HTML 文件下来，放到本地临时文件夹中
-
在浏览器显示出来
-
注意：HTTP（超文本传输协议）、HTML（超文本标记语言）
实现
/**
* HTTP 测试（GET、POST）
*/
public class HttpTest {
public static void main(String[] args) {
try {
// GET
// 要访问的 url 地址
String urlName = "https://www.baidu.com";
// 封装
URL url = new URL(urlName);
System.out.println("GET 连接获得的内容：" + HttpTest.doGet(url));
// POST
// 封装
String urlString = "https://tools.usps.com/go/ZipLookupAction.action";
Object userAgent = "HTTPie/0.9.2";
Object redirects = "1";
// cookie 接收策略，全部接收
CookieHandler.setDefault(new CookieManager(null, CookiePolicy.ACCEPT_ALL));
Map<String, String> params = new HashMap<>(3);
params.put("tAddress", "1 Market Street");
params.put("tCity", "San Francisco");
params.put("sState", "CA");
String result = doPost(new URL(urlString), params,
userAgent == null ? null : userAgent.toString(),
redirects == null ? -1 : Integer.parseInt(redirects.toString()));
System.out.println("POST 连接获得的内容：" + result);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 模拟 GET 方法
*
* @param url 封装好的 url
* @return 内容
* @throws IOException IO异常
*/
public static String doGet(URL url) throws IOException {
// 打开连接（获得 URL 连接）
URLConnection connection = url.openConnection();
// 建立连接
connection.connect();
System.out.println("====== 打印 http 的头部信息 ======");
Map<String, List<String>> headerFields = connection.getHeaderFields();
headerFields.forEach(
(key, value1) -> value1.stream().map(value -> key + "：" + value).forEach(System.out::println));
System.out.println("====== 输出收到的内容 属性信息 ======");
System.out.println("内容类型：" + connection.getContentType());
System.out.println("内容长度：" + connection.getContentLength());
System.out.println("内容编码：" + connection.getContentEncoding());
System.out.println("日期：" + connection.getDate());
System.out.println("过期：" + connection.getExpiration());
System.out.println("最后修改时间：" + connection.getLastModified());
// 以 UTF-8 的编码包装，读取 输入流
BufferedReader reader = new BufferedReader(
new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
StringBuilder result = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
result.append(line);
}
// 关闭 输入流
reader.close();
return result.toString();
}
/**
* 模拟 POST 方法
*
* @param url 封装好的 url
* @param nameValuePairs 参数键值对
* @param userAgent 用户代理
* @param redirects 重定向（ >=0 false | <0 true）
* @return 内容
* @throws IOException IO异常
*/
public static String doPost(URL url, Map<String, String> nameValuePairs, String userAgent, int redirects)
throws IOException {
// 打开连接（获得 URL 连接）
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// 设置请求属性
if (userAgent != null) {
connection.setRequestProperty("User-Agent", userAgent);
}
// 设置设置实例 是否 跟随重定向
if (redirects >= 0) {
connection.setInstanceFollowRedirects(false);
}
// 打开 输出流
connection.setDoOutput(true);
// 输出请求参数
try (PrintWriter out = new PrintWriter(connection.getOutputStream())) {
boolean first = true;
for (Map.Entry<String, String> pair : nameValuePairs.entrySet()) {
// 参数之间有一个 '&' 字符用于拼接
if (first) {
first = false;
} else {
out.print('&');
}
// 参数输出格式为：'key'='value'&'key1'='value1'
out.print(pair.getKey());
out.print('=');
out.print(URLEncoder.encode(pair.getValue(), StandardCharsets.UTF_8));
}
}
// 获取内容编码，如果 为空，则 设为 UTF-8
String encoding = connection.getContentEncoding();
if (encoding == null) {
encoding = "UTF-8";
}
if (redirects > 0) {
// 响应码
int responseCode = connection.getResponseCode();
System.out.println("responseCode = " + responseCode);
// 响应码为：301 或 302 或 303 时
if (responseCode == HttpURLConnection.HTTP_MOVED_PERM
|| responseCode == HttpURLConnection.HTTP_MOVED_TEMP
|| responseCode == HttpURLConnection.HTTP_SEE_OTHER) {
// 获取标题字段
String location = connection.getHeaderField("Location");
if (location != null) {
// url
URL base = connection.getURL();
// 断开连接
connection.disconnect();
// 重新 POST
return doPost(new URL(base, location), nameValuePairs, userAgent, redirects - 1);
}
}
} else if (redirects == 0) {
throw new IOException("Too many redirects");
}
// 获取 HTML 内容
StringBuilder response = new StringBuilder();
try (Scanner in = new Scanner(connection.getInputStream(), encoding)) {
while (in.hasNextLine()) {
response.append(in.nextLine());
response.append("\n");
}
} catch (IOException e) {
InputStream err = connection.getErrorStream();
if (err == null) {
throw e;
}
try (Scanner in = new Scanner(err)) {
response.append(in.nextLine());
response.append("\n");
}
}
return response.toString();
}
}
/**
* 基于 HTTP Client（JDK 11） 的 HTTP 测试（GET、POST）
*/
public class HttpClientTest {
public static void main(String[] args) {
// GET
URI baidu = URI.create("https://www.baidu.com");
HttpResponse<String> response = doGet(baidu);
System.out.println("GET 响应内容：" + (response != null ? response.body() : null));
// POST
URI usps = URI.create("https://tools.usps.com/go/ZipLookupAction.action");
HttpResponse<String> response1 = doPost(usps, "HTTPie/0.9.2");
System.out.println("POST 响应内容：" + (response1 != null ? response1.body() : null));
}
/**
* GET 方法模拟
*
* @param uri URI
* @return Http 响应<String>
*/
public static HttpResponse<String> doGet(URI uri) {
try {
// 创建 HTTP 客户端
HttpClient client = HttpClient.newHttpClient();
// 生成 HTTP 请求
HttpRequest request = HttpRequest.newBuilder(uri).build();
// 客户端发送请求，返回 HTTP 应答
return client.send(request, HttpResponse.BodyHandlers.ofString());
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
return null;
}
/**
* POST 方法模拟
*
* @param uri URI
* @param userAgent 用户代理
* @return Http 响应<String>
*/
public static HttpResponse<String> doPost(URI uri, String userAgent) {
try {
// 创建 HTTP 客户端
HttpClient client = HttpClient.newBuilder().build();
// 生成 HTTP 请求
HttpRequest request = HttpRequest.newBuilder()
// URI
.uri(uri)
// 用户代理
.headers("User-Agent", userAgent)
// 内容类型
.header("Content-Type", "application/x-www-form-urlencoded;charset=utf-8")
// 参数 拼接
.POST(HttpRequest.BodyPublishers.ofString(
"tAddress=" + URLEncoder.encode("1 Market Street", StandardCharsets.UTF_8)
+ "&tCity=" + URLEncoder.encode("San Francisco", StandardCharsets.UTF_8)
+ "&sState=CA"))
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println("response 响应码 = " + response.statusCode());
System.out.println("response 标题 = " + response.headers());
return response;
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
return null;
}
}
/**
* 基于 HTTP Commponents（org.apache.httpcomponents） 的 HTTP 测试（GET、POST）
* <p>
* 是一个集成的 JAVA HTTP 工具包
*/
public class HttpComponents {
public static void main(String[] args) {
// GET
HttpGet httpGet = new HttpGet("https://www.baidu.com");
System.out.println("GET 响应内容：" + doGet(httpGet));
// POST
HttpPost httpPost = new HttpPost("https://tools.usps.com/go/ZipLookupAction.action");
// POST 的请求参数
List<BasicNameValuePair> list = new ArrayList<>();
list.add(new BasicNameValuePair("tAddress", URLEncoder.encode("1 Market Street", StandardCharsets.UTF_8)));
list.add(new BasicNameValuePair("tCity", URLEncoder.encode("San Francisco", StandardCharsets.UTF_8)));
list.add(new BasicNameValuePair("sState", "CA"));
System.out.println("POST 响应内容：" + doPost(httpPost, list, "HTTPie/0.9.2"));
}
/**
* GET 方法模拟
*
* @param httpGet HttpGet
* @return String
*/
public static String doGet(HttpGet httpGet) {
// 创建 HTTP 客户端
CloseableHttpClient httpClient = HttpClients.createDefault();
// 请求配置
RequestConfig requestConfig = RequestConfig.custom()
// 设置连接超时
.setConnectTimeout(5000)
// 设置连接请求超时
.setConnectionRequestTimeout(5000)
// 设置套接字超时
.setSocketTimeout(5000)
// 启用 重定向
.setRedirectsEnabled(true)
.build();
// 加入 请求配置
httpGet.setConfig(requestConfig);
// 获取 返回的内容
StringBuilder result = new StringBuilder();
try {
// 执行 GET
CloseableHttpResponse httpResponse = httpClient.execute(httpGet);
// 如果请求成功了
if (httpResponse.getStatusLine().getStatusCode() == 200) {
System.out.println("code：200");
result.append(EntityUtils.toString(httpResponse.getEntity(), StandardCharsets.UTF_8));
} else {
System.out.println("请求失败！响应码：" + httpResponse.getStatusLine().getStatusCode());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 关闭
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result.toString();
}
/**
* 模拟 POST 请求
*
* @param httpPost HTTP post
* @param list 请求参数键值对
* @param userAgent 用户代理
* @return String
*/
public static String doPost(HttpPost httpPost, List<BasicNameValuePair> list, String userAgent) {
// 获取 HTTP Client
CloseableHttpClient httpClient = HttpClientBuilder.create()
// 设置重定向策略（松散的重定向策略）
.setRedirectStrategy(new LaxRedirectStrategy()).build();
// 请求配置
RequestConfig requestConfig = RequestConfig.custom()
// 设置连接超时
.setConnectTimeout(10000)
// 设置连接请求超时
.setConnectionRequestTimeout(10000)
// 设置套接字超时
.setSocketTimeout(10000)
// 不启用 重定向
.setRedirectsEnabled(false)
.build();
// 加入 请求配置
httpPost.setConfig(requestConfig);
// 获取 返回的内容
StringBuilder result = new StringBuilder();
try {
// Url 编码的表单实体(用于装入 POST 请求的参数)
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");
// 将表单加入到 HTTP POST 中
httpPost.setEntity(entity);
// 加入用户代理
httpPost.setHeader("User-Agent", userAgent);
// 执行 POST
HttpResponse httpResponse = httpClient.execute(httpPost);
// 如果请求成功了
if (httpResponse.getStatusLine().getStatusCode() == 200) {
System.out.println("code：200");
result.append(EntityUtils.toString(httpResponse.getEntity(), StandardCharsets.UTF_8));
} else {
System.out.println("Error 响应码：" + httpResponse.getStatusLine().getStatusCode());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 关闭
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result.toString();
}
}
