网络通信
1)两台及以上设备之间通过网络实现数据传输;
2)将数据通过网络从一台设备传送到另一台设备;
3)java.net包下提供了一系列的类或者接口使用来实现网络通信。
网络
1)两台或者多台设备通过一定物理设备连接起来构成了网络;
2)根据覆盖范围不同分为:局域网、城域网、广域网。
IP地址
1)用于唯一标识网络中的每台计算机/主机;
2)查看本机ip:ipconfig;
3)IPv4地址的表示方式:点分十进制:0.0.0.0~255.255.255.255;
①IPv4地址分为A、B、C、D、E五类。A类从0.0.0.0到127.255.255.255;B类从128.0.0.0到191.255.255.255;C类从192.0.0.0到223.255.255.255;D类从224.0.0.0到239.255.255.255;E类从240.0.0.0到247.255.255.255;
4)每个十进制数的范围:0~255;
5)ip地址的组成:网络地址+主机地址;
6)IPv6是互联网工程任务组设计的用于替代IPv4的下一代协议;
7)由于IPv4最大的问题在于网络地址资源有限,严重制约了互联网的应用和发展;IPv6的使用,能够解决网络资源的有限问题,并且解决了多种接入设备连接互联网的障碍。
域名
1)例如www.baidu.com
2)将ip地址映射成域名,方便记忆,HTTP协议
端口号
1)用于表示计算机上某个特定的网络程序;
2)表示形式:以整数形式,端口范围0~65535((2^16) -1)
3)0~1024已经被占用,比如:ssh 22,ftp 21,smtp 25,http 80;
4)常见的网络程序端口号:tomcat:8080;mysql:3306;oracle:1521;sqlserver:1433;
网络通讯协议
TCP/IP(Transmission Control Protocol/ Internet Protocol)传输控制协议/因特网互联协议,又称为网络通讯协议,这个协议是Internet最基本的协议,由网络层的IP协议和传输层的TCP协议组成。
OSI模型 | TCP/IP模型 | TCP/IP模型各层对应协议 |
应用层 | 应用层 | HTTP、ftp、telnet、DNS... |
表示层 | ||
会话层 | ||
传输层 | 传输层 | TCP、UDP... |
网络层 | 网络层 | IP、ICMP、ARP... |
数据链路层 | 物理+数据链路层 | Link |
物理层 |
TCP和UDP
★TCP协议:传输控制协议
1)使用TCP协议之前,须先建立TCP链接,形成传输数据通道;
2)传输前,采用“三次握手”的方式,具备很强的可靠性;
3)TCP协议进行通信的两个应用进程:客户端和服务端;
4)在连接中可进行大量数据的传输;
5)传输完毕后需释放已建立的链接,效率较低。
★UDP协议:
1)将数据、源、目的封装成数据包,不需要建立连接;
2)每个数据包的大小限制在64K以内;
3)无需链接,是不可靠的;
4)发送数据结束时无需释放资源(不是面向连接的),速度快;
InetAddress类
1)获取本机InetAddress对象getLocalHost;
2)根据指定本机名/域名获取ip地址对象getByName;
3)获取InetAddress对象的主机名getHostName;
4)获取InetAddress对象的地址getHostAddress。
package com.pero;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* @author Pero
* @version 1.0
*/
public class InetAddress_ {
public static void main(String[] args) throws UnknownHostException {
//获取本机InetAddress对象
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost); //DESKTOP-KHU9144/192.168.0.105
//根据主机名获取InetAddress
InetAddress byName = InetAddress.getByName("www.baidu.com");
System.out.println(byName); //www.baidu.com/220.181.38.149
//获取InetAddress对象的主机名getHostName
String hostName = byName.getHostName();
System.out.println(hostName); //www.baidu.com
//获取InetAddress对象的地址getHostAddress。
String hostAddress = byName.getHostAddress();
System.out.println(hostAddress); //220.181.38.150
}
}
Socket类(TCP编程,UDP编程)
1)套接字(Socket)开发网络应用程序被广泛采用,以至于成为事实上的标准;
2)通信的两端都要有Socket,是两台机器间通信的端点;
3)网络通信其实就是Socket间的通信;
4)Socket允许程序把网络连接当成一个流,数据在两个Socket间通过IO传输;
5)一般主动发起通信的应用程序属于客户端,等待通信请求(监听)的为服务器端。
socket.getOutputStream();
socket.getInputStream();
TCP网络通信编程
1)基于客户端—服务端的网络通信;
2)底层使用的是TCP/IP协议;
3)客户端发送数据,服务端接收并显示控制台;
4)基于Socket的TCP编程。
5)当客户端连接到服务器端后,实际上客户端也是通过一个端口和服务器端进行通信,这个端口是由TCP/IP分配的是随机的不确定的。
Server | ↔ | Client |
SeverSocket(int port) ⬇ Socket accept() | Socket(InetAddress address,int port) | |
InputStream Socket.getInputStream() OutputStream Socket.getOutputStream() | ← → | OutputStream Socket.getOutputStream() InputStream Socket.getInputStream() |
Socket.close() | Socket.close() |
字节流传输
服务器端代码
package com.pero.net_;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 编写一个服务器端和一个客户端
* 服务器端在9999端口监听
* 客户端连接到服务器端,发送"hello,server"然后退出
* 服务器端接收到客户端发送的信息,输出,并推出
*
* @author Pero
* @version 1.0
*/
public class SocketServer_ {
public static void main(String[] args) throws IOException {
//监听
//调用ServerSocket构造器填入端口号(端口号必须是没有被占用的,否则报错)创建对象对象,
//serverSocket可以通过accept()方法创建有多个socket,
// 多个客户端连接服务器的并发,服务器端可以监听多个端口
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器9999端口监听,等待连接...");
//等待连接
//当没有客户端连接9999端口时,程序会阻塞,等待连接
//如果有客户端连接,则会返回Socket对象,程序继续运行
Socket socket = serverSocket.accept(); //这里阻塞
System.out.println("客户端连接到9999端口,程序运行" + socket.getClass());
//连接成功后
//获取socket对象的输入流
InputStream inputStream = socket.getInputStream();
//设置缓冲,读取数据
byte[] bytes = new byte[1024];
int length = 0;
while ((length = inputStream.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, length));
}
//返回发送收到
OutputStream outputStream = socket.getOutputStream();
outputStream.write("receive,over".getBytes());
//设置写入结束标记
socket.shutdownOutput();
//关闭流、socket和serverSocket
inputStream.close();
outputStream.close();
socket.close();
serverSocket.close();
}
}
客户端代码
package com.pero.net_;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 编写一个服务器端和一个客户端
* 服务器端在9999端口监听
* 客户端连接到服务器端,发送"hello,server"然后退出
* 服务器端接收到客户端发送的信息,输出,并推出
*
* @author Pero
* @version 1.0
*/
public class SocketClient_ {
public static void main(String[] args) throws IOException {
//连接服务器端(ip,端口)
//调用Socket构造器(目标主机的InetAddress对象,端口号)来连接目标主机端口
//如果连接成功则返回socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端与服务器端连接成功" + socket.getClass());
//获取socket对象的输出流
OutputStream outputStream = socket.getOutputStream();
//将信息写入流中
outputStream.write("hello,server".getBytes());
//设置写入结束标记
socket.shutdownOutput();
//获取socket输入流
InputStream inputStream = socket.getInputStream();
//设置缓冲,读取数据
byte[] bytes = new byte[1024];
int readLength = 0;
while ((readLength = inputStream.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, readLength));
}
//关闭流对象和socket对象
outputStream.close();
inputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
字符流传输
服务器端代码
package com.pero.net_;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 编写一个服务端,一个客户端
* 服务端在9999端口监听
* 客户端连接到服务器端,发送"hello,server",并接收服务端回发的"hello,client"在退出
* 服务端接收到客户端发送的信息,输出,并发送"hello,client"再退出
*
* @author Pero
* @version 1.0
*/
public class SocketServerChar_ {
public static void main(String[] args) throws IOException {
//创建服务器9999端口serverSocket对象
ServerSocket serverSocket = new ServerSocket(9999);
//获取socket
//如果连接成功返回socket
Socket socket = serverSocket.accept();
System.out.println("客户端与服务端口连接成功");
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(inputStream, "utf8"));
String s = bufferedReader.readLine();
System.out.println(s);
//必须以readLine()作为读,否则无法读取换行无法结束接收
//socket.shutdownInput();
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(
new OutputStreamWriter(outputStream, "utf8"));
bufferedWriter.write("hello,client(字符流)");
bufferedWriter.newLine();
bufferedWriter.flush();
//socket.shutdownOutput();
bufferedReader.close();
bufferedWriter.close();
socket.close();
serverSocket.close();
}
}
客户端代码
package com.pero.net_;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 编写一个服务端,一个客户端
* 服务端在9999端口监听
* 客户端连接到服务器端,发送"hello,server",并接收服务端回发的"hello,client"在退出
* 服务端接收到客户端发送的信息,输出,并发送"hello,client"再退出
*
* @author Pero
* @version 1.0
*/
public class SocketClientChar_ {
public static void main(String[] args) throws IOException {
//建立与服务器连接的socket传输口
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(
new OutputStreamWriter(outputStream, "utf8"));
bufferedWriter.write("hello,server(字符流)");
bufferedWriter.newLine(); //接收方必须以readLine()作为读取结束标记,否则无法读取换行,无法结束接收
//必须手动刷新,否则数据无法写入通道
bufferedWriter.flush();
//如果以writer.newLine()作为写入结束标记,则接收方必须以readLine()作为读取结束标记,否则无法读取
//socket.shutdownOutput();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(inputStream, "utf8"));
String s= bufferedReader.readLine();
System.out.println(s);
//socket.shutdownInput();
bufferedWriter.close();
bufferedReader.close();
socket.close();
System.out.println("客户端退出");
}
}
文件传输
服务器端代码
package com.pero.net_;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author Pero
* @version 1.0
*/
public class TCPFileUploadServer {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务端口8888监听中...");
Socket socket = serverSocket.accept();
System.out.println("客户端连接服务端成功!");
//读取数据
InputStream inputStream = socket.getInputStream();
BufferedInputStream bis = new BufferedInputStream(inputStream);
byte[] bytes = StreamUtils.StreamToByteArray(bis);
String filePath = "src\\4.jpeg";
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(filePath));
bos.write(bytes);
bos.close();
//回复"收到图片"
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(
new OutputStreamWriter(outputStream, "utf8"));
bufferedWriter.write("收到图片");
bufferedWriter.flush();
//bufferedWriter.newLine(); //与flush二选一
socket.shutdownOutput();
//关闭资源
bufferedWriter.close();
bis.close(); //先开后关
socket.close();
serverSocket.close();
}
}
客户端代码
package com.pero.net_;
import java.io.*;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* @author Pero
* @version 1.0
*/
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//获取与服务端链接的插口
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//将本地文件输入到磁盘中
String filePath = "C:\\Users\\Pero\\Desktop\\4.jpeg";
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream(filePath));
byte[] bytes = StreamUtils.StreamToByteArray(bis);
//文件传输给服务端
OutputStream outputStream = socket.getOutputStream();
BufferedOutputStream bos = new BufferedOutputStream(outputStream);
bos.write(bytes);
bis.close();
socket.shutdownOutput(); //输出数据结束
//读取服务器回复
InputStream inputStream = socket.getInputStream();
String s = StreamUtils.StreamToString(inputStream);
System.out.println(s);
//关闭资源
inputStream.close();
bos.close();
socket.close();
}
}
工具类代码
package com.pero.net_;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* @author Pero
* @version 1.0
*/
public class StreamUtils {
public static byte[] StreamToByteArray(InputStream is) throws Exception{
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] b = new byte[1024];
int len;
while ((len = is.read(b)) != -1){
bos.write(b,0,len);
}
byte[] array = bos.toByteArray();
bos.close();
return array;
}
public static String StreamToString(InputStream is) throws Exception {
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder builder = new StringBuilder();
String line;
while ((line = reader.readLine()) != null){
builder.append(line +"\r\n");
}
return builder.toString();
}
}
netstat指令
1)netstat -an 可以查看当前主机网络情况,包括端口监听情况和网络连接情况;
2)netstat -an | more 可以分页显示;
3)在dos控制台下执行。
说明:
①Listening表示某个端口在监听;
②如果有一个外部程序(客户端)连接到该端口,会显示连接信息;
③输入ctrl+c推出指令。
UDP网络通信编程
1)类DatagramSocket【数据报套接字】和DatagramPacket【数据报】实现了基于UDP协议网络程序;
2)UDP数据报通过数据报套接字DatagramSocket发送和接收,系统不保证UDP数据包一定能够安全到达目的地,也不能确定什么时间可以抵达;
3)DatagramPacket对象封装了UDP数据报,在数据报中报含了发送端的IP地址和端口号以及接收端的IP地址和端口号;
4)UDP协议中每个数据报都给出完整的地址信息,因此无需建立发送方和接收方的链接。
说明:
①没有明确的服务端和客户端,演变成数据的发送端和接收端;
②接收数据和发送数据都是通过DatagramSocket对象完成;
③将数据封装到DatagramPacket对象/装包;
④当接收到DatagramPacket对象,需要进行拆包取出数据;
⑤DatagramSocket可以指定在哪个端口接收数据。
基本流程:
1)核心的两个类/对象 DatagramSocket与DatagramPacket;
2)建立发送端,接收端;
3)建立数据包;
4)调用DatagramSocket的发送、接收方法;
5)关闭DatagramSocket 。
代码测试
接收端A
package com.pero.net_;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
* 编写一个接收端A,一个发送端B
* 接收端A在9999端口等待接收数据
* 发送端B向接收端A发送数据"hello,明天吃火锅"
* 接收端A收到发送端B发送的数据,回复"好的,明天见“再退出
* 发送端接收回复的数据,再退出
*
* @author Pero
* @version 1.0
*/
public class UDPReceiverA {
public static void main(String[] args) throws IOException {
//创建接收端/发送端,并指定端口9999
DatagramSocket datagramSocket = new DatagramSocket(9999);
//数据包最大64KB
byte[] bytes = new byte[64*1024]; //1024个字节等于1KB
//创建数据报
DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
//调用接收方法,将接收到的数据填充到datagramPacket中
//当有数据包发送到9999端口时,就会接收到数据,
System.out.println("接收端等待接收数据");
datagramSocket.receive(datagramPacket);// 如果没有数据包发送到9999端口时,程序会在这里阻塞
//拆包,提取数据
int length = datagramPacket.getLength(); //实际接收数据长度
byte[] data = datagramPacket.getData(); //接收到的数据
String s = new String(data, 0, length);
System.out.println(s);
//发送回复消息
byte[] bytes1 = "好的,明天见".getBytes();
DatagramPacket datagramPacket1 = new DatagramPacket(
bytes1, bytes1.length, InetAddress.getByName("192.168.0.105"), 9998);
datagramSocket.send(datagramPacket1);
//关闭资源
datagramSocket.close();
System.out.println("接收端A退出");
}
}
发送端B
package com.pero.net_;
import java.io.IOException;
import java.net.*;
/**
* 编写一个接收端A,一个发送端B
* 接收端A在9999端口等待接收数据
* 发送端B向接收端A发送数据"hello,明天吃火锅"
* 接收端A收到发送端B发送的数据,回复"好的,明天见“再退出
* 发送端接收回复的数据,再退出
*
* @author Pero
* @version 1.0
*/
public class UDPSenderB {
public static void main(String[] args) throws IOException {
//创建发送端/接收端,并指定端口
DatagramSocket datagramSocket = new DatagramSocket(9998);
//将发送数据封装到DatagramPacket中
byte[] bytes = "hello,明天吃火锅".getBytes();
//封装到DatagramPacket的内容有bytes数据内容,bytes.length数据长度
//InetAddress.getByName(目标主机IPv4地址),端口号
DatagramPacket datagramPacket = new DatagramPacket(
bytes, bytes.length, InetAddress.getByName("192.168.0.105"), 9999);
//发送数据报
datagramSocket.send(datagramPacket);
//接收回复数据
byte[] bytes1 = new byte[64*1024];
DatagramPacket datagramPacket1 = new DatagramPacket(bytes1, bytes.length);
datagramSocket.receive(datagramPacket1);
//先获取数据长度,在获取数据
int length = datagramPacket1.getLength();
byte[] data = datagramPacket1.getData();
String s = new String(data, 0, length);
System.out.println(s);
//关闭资源
datagramSocket.close();
System.out.println("发送端B退出");
}
}