Java基础00-网络编程29
1. 网络编程入门
1.1 网络编程概述
1.2 网络编程三要素
1.3 IP地址
在命令提示符中使用
1.4 InetAddress的使用
代码示例：
public class InetAddressDemo {
// InetAddress
// 此类表示Internet协议(IP) 地址
public static void main(String[] args) throws UnknownHostException {
// public static InetAddress getByName (String host):
// 确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址，推荐是使用IP地址
//InetAddress address = InetAddress.getByName("WxW");
InetAddress address = InetAddress.getByName("192.168.0.105");
// public String getHostName ():获取此IP地址的主机名
String hostName = address.getHostName();
System.out.println(hostName);
// public String getHostAddress (): 返回文本显示中的IP地址字符串
String hostAddress = address.getHostAddress();
System.out.println(hostAddress);
}
}
运行结果：
代码示例：
public class InetAddressTest {
public static void main(String[] args) throws UnknownHostException {
System.out.println(InetAddress.getLocalHost());//LAPTOP-VEKHRDDR/192.168.240.1
System.out.println(InetAddress.getLocalHost().getHostName());//LAPTOP-VEKHRDDR
System.out.println(InetAddress.getLocalHost().getHostAddress());//192.168.240.1
System.out.println(InetAddress.getByName("192.168.3.11"));//输出：/192.168.3.11
System.out.println(InetAddress.getByName("192.168.3.11").getHostName());//LAPTOP-VEKHRDDR
System.out.println(InetAddress.getByName("192.168.3.11").getHostAddress());//192.168.3.11
System.out.println(InetAddress.getByName("LAPTOP-VEKHRDDR"));//LAPTOP-VEKHRDDR/192.168.240.1
System.out.println(InetAddress.getByName("LAPTOP-VEKHRDDR").getHostName());//LAPTOP-VEKHRDDR
System.out.println(InetAddress.getByName("LAPTOP-VEKHRDDR").getHostAddress());//192.168.240.1
}
}
运行结果：
1.5 端口
1.6 协议
三次握手
2. UDP通信程序
2.1 UDP通信原理
2.2 UDP发送数据
代码示例：
创建发送端
public class SendDemo {
public static void main(String[] args) throws IOException {
// 1:创建发送端的Socket对象(DatagramSocket)
// DatagramSocket ()构造数据报套接字并将其绑定到本地主机上的任何可用端口
DatagramSocket ds = new DatagramSocket();
// 2:创建数据，并把数据打包
// DatagramPacket (byte[] buf, int Length, InetAddress address, int port)
// 构造一个数据包，发送长度为length的数据 包到指定主机上的指定端口号。
byte[] bys = "hello,udp,我来了".getBytes();
int length = bys.length;
InetAddress destAddress = InetAddress.getByName("192.168.0.105");
int port = 10086;
DatagramPacket dp = new DatagramPacket(bys, length, destAddress, port);
// 上面的步骤也可以写成这样
// DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.0.105"), 10086);
// 3:调用DatagramSocket对象的方法发送数据
// void send (DatagramPacket p)从此套接字发送数据报包
ds.send(dp);
// 4:关闭发送端
ds.close();
}
}
运行结果：
运行后并没有输出结果，因为还没有写接收端
2.3 UDP接收数据
代码示例：
创建接受端public class ReceiveDemo { public static void main(String[] args) throws IOException {
// 1:创建接收端的Socket对象(DatagramSocket )
// DatagramSocket (int port)构造数据报套接字并将其绑定到本地主机上的指定端口
DatagramSocket ds = new DatagramSocket(10086); // 2:创建一个数据包，用于接收数据
// DatagramPacket (byte[] buf, int length) 构造一个 DatagramPacket用于 接收长度为Length数据包
byte[] bys = new byte[1024];
DatagramPacket dp = new DatagramPacket(bys, bys.length); // 3:调用DatagramSocket对象的方法接收数据
ds.receive(dp); // 4:解析数据包，并把数据在控制台显示
// byte[] getData() 返回数据缓仲区
byte[] datas = dp.getData();
// int getLength () 返回要发送的数据的长度或接收到的数据的长度
int len = dp.getLength();
String dataString = new String(datas, 0, len); // 这样写是为了让输出的数据正好而不多余。
System.out.println("数据是：" + dataString); // 上面的步骤也可以这样写
// System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
String ip = dp.getAddress().getHostAddress();
System.out.println("收到"+ip+"发来的消息");
// 5:关闭接收端
ds.close(); }
}
运行结果：
运行时要先运行接收端再运行发送端，这样就就可以在接收端的控制台上看见接收到的数据了。
2.4 UDP通信程序练习
代码示例：
UDP发送端
/*
UDP发送数据:
数据来自于键盘录入，直到输入的数据是886，发送数据结束
*/
public class SendDemo {
public static void main(String[] args) throws IOException {
// 创建发送端的Socket对象(DatagramSocket )
DatagramSocket ds = new DatagramSocket(); // 自己封装键盘录入数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line = br.readLine()) != null) {
// 输入的数据的886，发送数据接收
if ("886".equals(line)) {
break;
} // 创建数据，并把数据打包
byte[] bys = line.getBytes();
DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.0.105"), 12345); // 调用DatagramSocket对象发送程序
ds.send(dp);
}
// 关闭发送端
ds.close(); }
}
UDP接收端
/*
UDP接收数据:
因为接收端不知道发送端什么时候停止发送，故采用死循环接收
*/
public class ReceiveDemo {
public static void main(String[] args) throws IOException {
// 创建接收端的Socket对象(DatagramSocket)
DatagramSocket ds = new DatagramSocket(12345); while (true) {
// 创建一个数据包，用于接收数据
byte[] bys = new byte[1024];
DatagramPacket dp = new DatagramPacket(bys, bys.length); // 调用DatagramSocket对象的方法接收数据
ds.receive(dp);
String data = new String(dp.getData(), 0, dp.getLength());
// 解析数据包，并把数据在控制台显示
System.out.println("数据是：" + data);
}
// 因为是采用死循环所以不需要关闭接收端
}
}
运行结果：
输入886结束接收
还可以开启多个发送数据窗口，每个窗口都可以发送数据，互不影响。
3. TCP通信程序
3.1 TCP通信原理
3.2 TCP发送数据
代码示例：
//TCP发送数据
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 1:创建客户端的Socket对象(Socket)
// Socket (InetAddress address, int port)创建流套接字并将其连接到指定IP地址的指定端口号
// Socket s = new Socket(InetAddress.getByName("192.168.0.105"), 1000);
// Socket (String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
Socket s = new Socket("192.168.0.105", 1000);// 这两个方法做的是同一件事 // 2:获取输出流，写数据
// OutputStream getOutputStream () 返回此套接字的输出流
OutputStream os = s.getOutputStream();
os.write("Hello,tcp,我来了".getBytes()); // 3:释放资源
s.close(); }
}
3.3 TCP接收数据
代码示例：
//TCP接收数据
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 1:创建服务器端的Socket对象(ServerSocket)
// ServerSocket (int port)创建绑定到指定端口的服务器套接字
ServerSocket ss = new ServerSocket(10000); // Socket accept() 侦听要连接到此套接字并接受它
Socket s = ss.accept(); // 2:获取输入流，读数据，并把数据显示在控制台
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len;
while ((len = is.read(bys)) != -1) {
System.out.println("数据是：" + new String(bys, 0, len));
} // 3:释放资源
ss.close();
}
}
运行结果：
先开启接收端再开启发送端
3.4 TCP通信程序练习
3.4.1 练习1：发送数据接收反馈，接受数据发出反馈
代码示例：
创建客户端：
/*
* 客户端:发送数据，接收服务器反馈
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端的Socket对象(Socket)
Socket s = new Socket(" ", 1000); // 获取输出流，写数据
OutputStream os = s.getOutputStream();
os.write("hello,tcp,我来了".getBytes()); // 接收服务器反馈
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String data = new String(bys, 0, len);
System.out.println("客户端：" + data); // 释放资源
s.close(); }
}
创建服务器端：
/*
* 服务器:接收数据，给出反馈
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务器端的Socket对象(ServerSocket)
ServerSocket ss = new ServerSocket(1000); // 监听客户端连接，返回一个Socket对象
Socket s = ss.accept(); // 获取输入流，读数据，并把数据显示在控制台
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String data = new String(bys, 0, len);
System.out.println("服务器：" + data); // 给出反馈
OutputStream os = s.getOutputStream();
os.write("数据已收到".getBytes()); // 释放资源
ss.close(); }
}
运行结果：
先打开服务器，然后等待客户端连接。
3.4.2 练习2：用键盘录入数据
代码示例：
创建客户端：
/*
* 客户端:数据来自于键盘录入，直到输入的数据是886，发送数据结束
*/
public class ClientDemo { public static void main(String[] args) throws IOException {
// 创建客户点Socket对象
Socket s = new Socket("192.168.0.105", 10000); // 数据来自于键盘录入，直到输入的数据是886，发送数据结束
// 使用自己包装的键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 封装输出流对象，将输出流封装成缓存流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); String line;
while ((line = br.readLine()) != null) { if ("886".equals(line)) {
break;
} // 获取输出流对象
// OutputStream os = s.getOutputStream();
// os.write(line.getBytes());
bw.write(line);
bw.newLine();
bw.flush();
}
// 释放资源
s.close();
}
}
创建服务器端：
/*
* 服务器:接收到的数据在控制台输出
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务器Socket对象
ServerSocket ss = new ServerSocket(10000); // 监听客户端的连接，返回一个对应的Socket对象
Socket s = ss.accept(); // 获取输入流，将输出流封装成缓存流
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
// 释放资源
ss.close();
}
}
运行结果：
先运行服务器端再运行客户端，在客户端输入数据发送到服务器端。
3.4.3 练习3：将键盘录入的数据写入文本文件
代码示例：
创建客户端：
客户端和练习2是一样的
/*
* 客户端:数据来自于键盘录入，直到输入的数据是886，发送数据结束
*/
public class ClientDemo { public static void main(String[] args) throws IOException {
// 创建客户点Socket对象
Socket s = new Socket("192.168.0.105", 10000); // 数据来自于键盘录入，直到输入的数据是886，发送数据结束
// 使用自己包装的键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 封装输出流对象
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); String line;
while ((line = br.readLine()) != null) { if ("886".equals(line)) {
break;
} // 获取输出流对象
// OutputStream os = s.getOutputStream();
// os.write(line.getBytes());
bw.write(line);
bw.newLine();
bw.flush();
}
// 释放资源
s.close();
}
}
创建服务端：
/*
* 服务器:接收到的数据写入文本文件
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务端Socket对象
ServerSocket ss = new ServerSocket(10000); // 监听客户端，返回一个对应的Socket对象
Socket s = ss.accept(); // 接收数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream())); // 把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("s.text"));
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
ss.close(); }
}
运行结果：
先运行服务器再运行客户端，再客户端写数据传入服务器再写入文本文件。
3.4.4 练习4：数据来自文本，发送到服务器再写入文本（上传接收）
代码示例：
被复制文件是练习3的s.text
创建客户端：
/*
* 客户端:数据来自于文本文件
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket("192.168.0.105", 10000); // 封装文本文件的数据
BufferedReader br = new BufferedReader(new FileReader("s.text")); // 封装输出流写数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
} // 释放资源
br.close();
s.close(); }
}
创建服务器：
服务器和练习3是一样的
/*
* 服务器:接收到的数据写入文本文件
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务端Socket对象
ServerSocket ss = new ServerSocket(10000); // 监听客户端，返回一个对应的Socket对象
Socket s = ss.accept(); // 接收数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream())); // 把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.text"));
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
ss.close(); }
}
运行结果：
先运行服务器端再运行客户端。
3.4.5 练习5：在练习4的基础上加上服务器反馈
按照常规的方法会出现问题
代码示例：
接收服务器的反馈最重要的是在客户端加入结束标签shutdownOutput()，这样才能让服务器端知道你已经结束输出数据了。
创建客户端：
/*
* 客户端:数据来自于文本文件
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket("192.168.0.105", 10000); // 封装文本文件的数据
BufferedReader br = new BufferedReader(new FileReader("s.text")); // 封装输出流写数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
} // 定义结束标签
// void shutdownOutput() 禁用此套接字的输出流。
s.shutdownOutput(); // 接收反馈
BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String data = brClient.readLine();
System.out.println("服务器的反馈：" + data); // 释放资源
br.close();
s.close();
}
}
创建服务端：
/*
* 服务器:接收到的数据写入文本文件
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务端Socket对象
ServerSocket ss = new ServerSocket(10000); // 监听客户端，返回一个对应的Socket对象
Socket s = ss.accept(); // 接收数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream())); // 把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.text"));
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
} // 给出反馈
BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwServer.write("文件上传成功！");
bwServer.newLine();
bwServer.flush(); // 释放资源
bw.close();
ss.close();
}
}
运行结果：
3.4.6 练习6：利用多线程使服务器接收多个客户端的文件
代码示例：
创建客户端类：
/*
* 客户端:数据来自于文本文件
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket("192.168.0.105", 10000); // 封装文本文件的数据
BufferedReader br = new BufferedReader(new FileReader("s.text")); // 封装输出流写数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
} // 定义结束标签
// void shutdownOutput() 禁用此套接字的输出流。
s.shutdownOutput(); // 接收反馈
BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String data = brClient.readLine();
System.out.println("服务器的反馈：" + data); // 释放资源
br.close();
s.close();
}
}
创建服务器类：
/*
* 服务器:接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务端Socket对象
ServerSocket ss = new ServerSocket(10000); while (true) {
// 监听客户端，返回一个对应的Socket对象
Socket s = ss.accept();
// 为每一个客户端开启一个线程
new Thread(new ServerTherad(s)).start();
}
}
}
创建线程类：
public class ServerTherad implements Runnable {
private Socket s;
public ServerTherad(Socket s) {
this.s = s;
}
@Override
public void run() {
try {
// 接收数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// 把数据写入文本文件
// 解决命名冲突问题
int count = 0;
File file = new File("Copy[" + count + "].text");
while (file.exists()) {
count++;
file = new File("Copy[" + count + "].text");
}
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
// 给出反馈
BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwServer.write("文件上传成功！");
bwServer.newLine();
bwServer.flush();
// 释放资源
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果：
先运行服务器再运行客户端，不过这次可以运行多次客户端，可以复制对个文件夹，而且不会重名。
第一次
第二次
Java基础00-网络编程29的更多相关文章
- 黑马程序员：Java基础总结----网络编程
黑马程序员:Java基础总结 网络编程 ASP.Net+Android+IO开发 . .Net培训 .期待与您交流! 网络编程 网络通讯要素 . IP地址 . 网络中设备的标识 . 不易记忆,可用 ...
- java基础知识——网络编程、IO流
IO流 字节流:处理字节数据的流对象,计算机中最小数据单元就是字节.InputStream OutputStream 字符流:字符编码问题,将字节流和编码表封装成对象就是字符流.Reader Writ ...
- 黑马程序员——JAVA基础之网络编程
------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 网络编程 网络模型:OSI参考模型和TCP/IP参考模型 网络通讯三要素: IP地址:InetA ...
- java基础篇---网络编程(TCP程序设计)
TCP程序设计 在Java中使用Socket(即套接字)完成TCP程序的开发,使用此类可以方便的建立可靠地,双向的,持续的,点对点的通讯连接. 在Socket的程序开发中,服务器端使用serverSo ...
- java基础篇---网络编程(IP与URL)
一:IP与InetAddress 在Java中支持网络通讯程序的开发,主要提供了两种通讯协议:TCP协议,UDP协议 可靠地连接传输,使用三方握手的方式完成通讯 不可靠的连接传输,传输的时候接受方不一 ...
- 【Java基础】网络编程
网络编程 网络编程概述 网络编程的目的:直接或简洁地通过网络协议与其他计算机实现数据交换,进行通讯. 网络编程的两个主要问题: 如果准确地定位网络上一台或多台主机,并定位主机上的特定应用: 找到主机后 ...
- Java基础之网络编程
网络编程:1.网络编程概述 (1)网络模型 OSI参考模型 TCP/IP参考模型 (2)网络通讯要素 IP地址 端口号 传输协议 (3)网络通讯前提: **找到对方IP **数据要发送到指定端口.为了 ...
- 黑马程序员——【Java基础】——网络编程
---------- android培训.java培训.期待与您交流! ---------- 一.网络模型概述 网络模型示意图: 说明: (1)数据的传输:在用户端,应用层的数据,经过层层封包,最后到 ...
- java基础：网络编程TCP,URL
获取域名的两种方法: package com.lanqiao.java.test; import java.net.InetAddress;import java.net.UnknownHostExc ...
随机推荐
- 人脸标记检测：ICCV2019论文解析
人脸标记检测:ICCV2019论文解析 Learning Robust Facial Landmark Detection via Hierarchical Structured Ensemble 论 ...
- ARM NEON指令集优化理论与实践
ARM NEON指令集优化理论与实践 一．简介 NEON就是一种基于SIMD思想的ARM技术,相比于ARMv6或之前的架构,NEON结合了64-bit和128-bit的SIMD指令集,提供128-bi ...
- AI解决方案：边缘计算和GPU加速平台
AI解决方案:边缘计算和GPU加速平台 一．适用于边缘 AI 的解决方案 AI 在边缘蓬勃发展.AI 和云原生应用程序.物联网及其数十亿的传感器以及 5G 网络现已使得在边缘大规模部署 AI 成为可能 ...
- springMVC源码解读笔记
1: DispatcherServlet 的初始化流程(调用的init方法) a) 初始化spring高级容器,WebApplicationContext(容器初始化12个步骤) Servlet类的i ...
- MySQL必知必会笔记——查询的基础知识
查询基础知识 第七章 数据过滤 组合where子句 MySQL允许给出多个WHERE子句.这些子 句可以两种方式使用:以AND子句的方式或OR子句的方式使用. AND操作符 可使用AND操作符给WHE ...
- 二、创建测试JSP页面
root@web1 ~]# rm -rf /usr/local/tomcat/webapps/ROOT/* 1.创建测试网页 [root@web1 ROOT]# vim /usr/local/tomc ...
- 权限管理（基本权限、附加权限、ACL权限）
基本权限 •访问方式(权限) 读取:允许查看内容-read r 写入:允许修改内容-write w 可执行:允许运行和切换-execute x 对于文本文件 r: cat head ...
- 【NX二次开发】基准特征
创建基准特征UF_MODL_create_fixed_daxis 创建一个固定的基准轴特征,方向由点1指向点2UF_MODL_create_fixed_dplane 创建一个固定的基准面特征,输入点和 ...
- 【无线通信篇01 | Zstack协议栈】CC2530 Zigbee Zstack协议栈组网项目及详细讲解篇
演示视频:https://www.bilibili.com/video/BV1Ew411o7Fp 物联网无线通信技术,ZigBee无线传感网络 CC2530最大的特点就是一个拥有无线收发器(RF)的单 ...
- 如何使用 jest 和 lint-staged 只检测发生改动的文件
我们现在在推进 EPC 的过程中,单元测试是必备的技能,在本地的 Git commit 之前进行单测非常有必要,总不能把所有的单测的压力都放在流水线上. 毕竟在流水线运行单测的成本还是挺高的,从 pu ...