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 ...
随机推荐
- wangEditor 轻量级富文本框编辑器使用方法
首先第一步先去wangEditor官网下载所需要的脚本文件! http://www.wangeditor.com/ 接下来先在你的项目的HTML标签里加上这样一段标签: 1 <body> ...
- MinkowskiEngine demo ModelNet40分类
MinkowskiEngine demo ModelNet40分类 本文将看一个简单的演示示例,该示例训练用于分类的3D卷积神经网络.输入是稀疏张量,卷积也定义在稀疏张量上.该网络是以下体系结构的扩展 ...
- 英特尔内存革新助平安云 Redis 云服务降本增效
英特尔内存革新助平安云 Redis 云服务降本增效 英特尔 傲腾 数据中心级持久内存的引入,为平安云的降本增效开启了一条新的道路.通过对平安云 Redis 数据库产品的支持,用户能享受到性能优异且价格 ...
- P1828 [USACO3.2]香甜的黄油 Sweet Butter
题目描述 农夫$John$发现做出全威斯康辛州最甜的黄油的方法:糖.把糖放在一片牧场上,他知道$N(1\leqslant N\leqslant 500)$只奶牛会过来舔它,这样就能做出能卖好价钱的超甜 ...
- 使用NDepend衡量代码的SOLID程度
SOLID是面向对象的软件开发中的5条准则,也是开发人员可以提升自己代码质量的准则.那么如何衡量自己的代码是否符合SOLID准则呢?NDepend这款工具也许可以帮得上忙.本文将介绍一些NDepend ...
- 【NX二次开发】获取两个面之间的所有面
已知两个蓝色面,使用遍历面的方法求紫色面.算法例子: 1 bool is_NeighborFace(tag_t tagFace1, tag_t tagFace2) 2 { 3 vector<ta ...
- java并发编程JUC第九篇：CountDownLatch线程同步
在之前的文章中已经为大家介绍了java并发编程的工具:BlockingQueue接口.ArrayBlockingQueue.DelayQueue.LinkedBlockingQueue.Priorit ...
- ABP Framework V4.4 RC 新增功能介绍
目录 新增功能概述 启动模板删除 EntityFrameworkCore.DbMigrations 项目 CMS-Kit 动态菜单管理 Razor引擎对文本模板的支持 DbContext/Entiti ...
- Exponentiation java大数
Exponentiation 大数a的n次幂,直到读到EOF(文件结尾)为止,其中忽略小数后面的0 1 import java.util.*; 2 import java.math.*; 3 impo ...
- Docker：docker国内镜像加速
创建或修改 /etc/docker/daemon.json 文件,修改为如下形式 { "registry-mirrors": [ "https://registry.do ...